Arduino bibliotekasini yaratish [18+]

Ilgari aytib o’tilganidek, aksariyat standart bibliotekalar qaysidir datchik, modul yoki bog’lanish interfeysidan foydalanishni osonlashtirish maqsadida yaratiladi. Biroq foydalanuvchi o’zi ko’p qo’llaydigan dasturiy bloklarni va funksiyalarini ham alohida tashqi faylga sodda biblioteka sifatida saqlab olishi mumkin. Natijada, har safar shu funksiyagadan foydalanish zarurati tug’ilganda, shunchaki kerakli sketchga uni biblioteka sifatida “#include” buyrug’i yordamida qo’shib olish yetarli bo’ladi.

Biz quyida foydalanuvchi bibliotekasini yaratishning sodda va nisbatan murakkab (standart biblioteka) bo’lgan 2 ta variantini alohida-alohida ko’rib chiqamiz. Shuningdek, har bir usulni 2 tadan misolning bir nechta versiyalari yordamida ko’ramiz.

Yangi biblioteka yaratish

Aksariyat hollarda qulaylik uchun, standart biblioteka asosan 2 ta fayldan tashkil topadi. Ulardan biri “sarlavha fayli” deb (bunday deyilishiga sabab, bu fayl bibliotekaning barcha boshqa fayllariga havolalarni o’z ichiga oladi), 2-si esa, “realizatsiya fayli” deb yuritiladi (bunday deyilishiga sabab, asosiy bajariladigan kod shu faylda saqlanadi). Biblioteka sarlavha va realizatsiya fayllari nomi bir xil bo’lishi shart. Sarlavha fayli “.h” (header), realizatsiya fayli esa “.cpp” (C++) kengaytmasiga ega bo’ladi.

Bundan tashqari, standart biblioteka tarkibida “keywords.txt” matnli fayli va “examples” ichki papkasi ham bo’lishi mumkin. “keywords.txt” faylining vazifasi faqat biblioteka ayrim elementlarini (klass, metodlarni) alohida ranglarda ajratib ko’rsatish hisoblanadi. “examples” papkasida, nomidan ko’rinib turibdiki, biblioteka funksiyalarini namoyish qilishga mo’ljallangan misollar (sketchlar) saqlanadi.

Agar biblioteka kam sondagi vazifalarni bajarishga mo’ljallangan bo’lsa, sarlavha va realizatsiya fayllari kodini yagona faylga – sarlavha (.h) fayliga birlashtirish ham mumkin. Bunda, realizatsiya faylidagi kod asosiy faylga ko’chirib olib o’tilishi kerak. Shuning uchun o’rganish davomida bibliotekaning 1 ta faylli variantini ham ko’rib o’tamiz.

Sodda biblioteka

Sodda biblioteka yaratish uchun C++ dasturlash tiliga murojaat qilish talab etilmaydi. Jumladan, .cpp kengaytmali faylimizda ham o’zimizga tanish bo’lgan Wiring tilidagi kodlarni qo’llash bilan cheklanamiz. Chunki, ilgari ham tilga olinganidek, Wiring ham C++ ning soddalashtirilgan ko’rinishlaridan biri xolos.

1-misol. Ushbu usulni o’rganish uchun, “Blink” sketchi qanchalik sodda bo’lmasin, biz uni biblioteka yordamida boshqariladigan boshqacha ko’rinishga keltiramiz. Aynan sketchning soddaligi va hammaga tanishligi ham yangi biblioteka yaratish jarayonini osonlashtiradi. Bundan tashqari, bibliotekaga pirpirash davomiyligi, takrorlanishlar sonini ko’rsatish rejimlarini ham qo’shamiz.

Ma’lumki, sketchning dastlabki ko’rinishi quyidagicha:

Original 'Blink' sketchi

void setup(){
pinMode(13, OUTPUT);
}

void loop(){
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}

Alohida faylga olib o’tishdan oldin sketchning bajarish (realizatsiya) qismini alohida funksiyaga aylantiramiz va skecthni ushbu ko’rinishida ifodalab olamiz. Bundan tashqari, sketch aksariyat mikrokontrollerda ishlashi uchun 13-pin o’rniga LED_BUILTIN yozuvini qo’llaymiz:

O'zgartirilgan 'Blink' sketchi

void setup(){
}

void loop(){
miltilla(LED_BUILTIN, 1000);
}

void miltilla(int pin, int pauza){
pinMode(pin, OUTPUT);
digitalWrite(pin, HIGH);
delay(pauza);
digitalWrite(pin, LOW);
delay(pauza);
}

Sketchni mikrokontrollerga yuklasak, avvalgidek ishlayotganini kuzatishimiz mumkin. Asosiy kodni alohida funksiyaga ajratib olishimizdan maqsad shuki, uni bo’lajak bibliotekamizning realizatsiya (bajarish) qismi sifatida foydalanamiz.

Shu yerda sketchimizni yanada takomillashtiramiz. Sketchdagi miltilla() funksiyasiga yangi “hisobchi” argumentini qo’shamiz. Keyinchalik ham sketchning faqat shu variantini takomillashtirib boramiz. Oldingi “Blink” sketchidan farqlash uchun uni “miltillash” deb nomlaymiz. Demak, “miltillash.ino” sketchining kodi quyidagicha bo’ladi:

'miltillash' sketchi. 1-versiya

int pin = LED_BUILTIN;
int pauza = 1000;
int hisobchi = 5;
void setup() {
pinMode(pin, OUTPUT);
miltillash(pin, pauza, hisobchi);
}

void loop() {

}

void miltillash(int pin, int pauza, int hisobchi){
if (hisobchi>0) {
for (int i=0; i<hisobchi; i++){
digitalWrite(pin, HIGH);
delay(pauza);
digitalWrite(pin, LOW);
delay(pauza);
}
}
}

Bu yerdagi “hisobchi” o’zgaruvchisi qiymatini setup() funksiyasi sohasida o’zgartirish orqali takrorlanishlar sonini cheklash mumkin bo’ladi. loop() funksiyasida esa, takrorlanishlar sonini ko’ratishning ma’nosi yo’q.

Endi standart bibliotekaning 1-varianti yaratishga kirishamiz. Bunday bibliotekada, shunchaki yuqoridagi misolda dasturning ichki funksiyasi sifatida qaralgan miltilla() funksiyasini va unga taalluqli o’zgaruvchilarni alohida fayllarga olib o’tamiz.

Bunday fayllarni yaratish uchun, dastlab Arduino IDE dasturi sketchlari saqlanadigan papkadagi “libraries” papkasini topamiz va yangi “YangiBlinkLib” deb nomlangan yangi papka hosil qilamiz (sketchlar papkasiga “Скетч” menyusidagi “Показать папку скетча” elementi yoki “Ctrl+K” klavishalar kombinatsiyasi orqali o’tish mumkin). Uning ichida esa, ixtiyoriy matnli redaktor yordamida “YangiBlink.h” sarlavha fayli, “YangiBlink.cpp” nomli realizatsiya fayli va “keywords.txt” kalit-so’zlar faylini yaratib olamiz. Bundan tashqari “YangiBlinkLib” papkasi ichida “examples” papkasini ham yaratib qo’yamiz. Unga keyinchalik, yaratilgan bibliotekadan foydalanishga misol tariqasida o’zimiz yaratadigan sketch faylini nusxalab qo’yamiz.

Biblioteka fayllarini Arduino IDE yordamida ham hosil qilishimiz mumkin. Buni 2 xil usulda amalga oshirsa bo’ladi:

1-usulda fayllar sketch ko’rinishida yaratiladi va alohida papka ichida .ino kengaytmasi bilan saqlanadi. Shundan keyin, har bir fayl yaratilganidan keyin fayl menejeri orqali (masalan, Total Commanderda) uning kengaytmasini .h, .cpp va txt ga o’zgartirilishi, sketchlarni o’z ichiga olgan papkalar o’chirib yuborilishi, “libraries” papkasi ichida “YangiBlinkLib” papkasini yaratib, sketchlarni unga ko’chirish kerak bo’ladi.

2-usulda Arduino IDE dasturida yangi sketch yaratib, dastur oynasidag sketch nomidan o’ng tomonda joylashgan menyudan “Новая вкладка” buyrug’i yoki “Ctrl+Shift+N” klavishalari kombinatsiyasi yordamida yangi oynalar yaratamiz, ularga biblioteka nomi bilan bir xil, lekin .h va .cpp kengaytmaga ega bo’lgam nomlar beramiz: “YangiBlink.h” va “YangiBlink.cpp” (Bunday usul bilan .txt kengaytmali fayl yaratib bo’lmaydi. Lekin “keywords.txt” faylini sketch ko’rinishida yaratib, keyin uning kengaytmasini .ino dan .txt ga o’zgartirib olish mumkin). Bu fayllar sketch bilan bitta papkaga saqlanadi. Ularni yuqorida ko’rsatilgan tartibda “libraries” papkasi ichida yangi “YangiBlinkLib” papkasini yaratib, shu papkaga ko’chirib olib o’tamiz.

Biblioteka fayllarini quyidagi ko’rinishga keltiramiz:

“YangiBlink.h” fayli:

'YangiBlink.h' - bibliotekaning sarlavha fayli

#include “Arduino.h”
void miltilla(int pin); // takrorlanish soni va pauza davomiyligi ko’rsatilmaydigan variant uchun
void miltillaint pin, int pauza); // takrorlanish soni ko’rsatilmaydigan variant uchun
void miltilla(int pin, int pauza, int hisobchi); // barcha argumentlar ko’rsatiladigan variant uchun

“YangiBlink.cpp” fayli:

'YangiBlink.cpp' - realizatsiya fayli

#inclide “Arduino.h”
#include “YangiBlink.h”

void miltilla(int pin){ // takrorlanish soni va davomiylik ko’rsatilmaydigan funksiya
pinMode(pin, OUTPUT);
digitalWrite(pin, HIGH);
delay(1000);
digitalWrite(pin, LOW);
delay(1000);
}
void miltilla(int pin, int pauza){ // takrorlanish soni ko’rsatilmaydigan funksiya
pinMode(pin, OUTPUT);
digitalWrite(pin, HIGH);
delay(pauza);
digitalWrite(pin, LOW);
delay(pauza);
}
void miltilla(int pin, int pauza, int hisobchi){ // barcha argumentlar ko’rsatiladigan funksiya
pinMode(pin, OUTPUT);
for (int i=0;i<hisobchi; i++){
digitalWrite(pin, HIGH);
delay(pauza);
digitalWrite(pin, LOW);
delay(pauza);
}
}

Ko’rinib turibdiki, realizatsiya faylida PinMode() funksiyasi ham kodga kiritilgan. Natijada, yaratilayotgan sketchda setup() funksiyasi tarkibida uni alohida ko’rsatib qo’yishga hojat qolmaydi. “keywords.txt” faylida quyidagi ma’lumotlar mavjud bo’lishi kerak:

'keywords.txt' - kalit-so'zlar fayli

YangiBlink KEYWORD1
miltilla KEYWORD1

Shu yo’l bilan, fayldagi KETWORD1 yozuvi yordamida “YangiBlink” va “miltilla” so’zlarini kalit-so’z sifatida alohida rangda ko’rsatilishi kerakligini belgilab qo’yilmoqda.

Shundan keyin, Arduino IDE ni to’liq yopib, qayta ishga tushiramiz va yangi sketch yaratib, “Скетч/Подключить библиотеку” menyusidan “YangiBlinkLib” (biz yaratgan biblioteka papkasining nomi) yozuvini topib tanlaymiz (Agar menyuda “YangiBlinkLib” yozuvi mavjud bo’lmasa, bu biblioteka yaratilishi jarayonida xatolik yuz berganini bildiradi). Xatolik kuzatilmasa, sketchda #include <YangiBlink.h> yozuvi paydo bo’lishi kerak.

Yangi sketchmizni quyidagi holga keltiramiz va ishga tushiramiz:

'miltillash' sketchi. 2-versiya

#include <YangiBlink.h>
void setup() {
miltilla(LED_BUILTIN, 200, 10); // barcha argumentlar ko’rsatiladigan variant
miltilla(LED_BUILTIN, 3000); // takrorlanish soni ko’rsatilmaydigan variant
}

void loop() {
miltilla(LED_BUILTIN); // takrorlanish soni va pauza davomiyligi (1000 ms) ko’rsatilmaydigan variant
}

Sketchdagi pauza davomiyligi ko’rsatilmaydigan variantda uning davomiyligi 1000 ms (1 sekund) deb qabul qilinadi, chunki bibliotekadagi tegishli funksiyada delay() funksiyasi argumentida o’zgaruvchi o’rniga “1000” qiymati aniq belgilab qo’yilgan. Xuddi shuningdek, takrorlanishlar soni ko’rsatilmagan variantda takrorlanish qiymati 1 ga teng deb qabul qilinadi.

Dasturni ishga tushirib, LED_BUILTIN raqamli piniga ulangan svetodiod dastlab 200 millisekundlik pauza bilan 10 marta, keyin 3000 millisekundlik pauza bilan 1 marta, undan keyin esa, uzluksiz 1000 millisekundlik pauza bilan miltillayotganini kuzatishimiz mumkin.

Yuqorida aytib o’tilganidek, oxirgi sketchimizni biblioteka asosiy papkasi ichidagi “examples” papkasiga nusxalab qo’ysak, u biz yaratgan yangi biliotekadan foydalanishga misol sifatida Arduino IDE dasturi menyusining “Файл/Примеры/YangiBlinkLib” bo’limida ham doim ko’rinadi. Ya’ni, bibliotekamiz asosidagi yangi sketchni har safar boshidan yaratib o’tirmasdan shu sketchga o’zgartirish kiritib, yangi nom bilan saqlab olish qulayroq bo’ladi.

2-misol. Ushbu misolda yuqoridagidek sodda sketch yaratish usuli bilan, matnli formatdagi o’zgaruvchi qiymatini sozlama sifatida EEPROM-xotiraga saqlash va undan o’qish bibliotekasini yaratamiz.

Ma’lumki, EEPROM-xotiraga yozuvlar baytlar ko’rinishida saqlanadi va unga matnni to’g’ridan-to’g’ri saqlash uchun tayyor funksiya mavjud emas. Shuning uchun har safar sketchga shunday vazifani bajaruvchi alohida kod qo’sishga to’g’ri keladi. Agar matnni EEPROM-xotiraga saqlash va undan o’qish uchun maxsus biblioteka yaratilsa, sketchlarda undan oson foydalanish mumkin bo’ladi.

Biz bunday bibliotekaning asosida, WiFi tarmog’i asosiy parametrlarini saqlash va aksincha ularni xotiradan o’qish sketchlarini yaratamiz, keyinchalik esa, ularni yagona sketchga birlashtiramiz. Ushbu misolni keltirishimizga sabab, keyinroq standart bibliotekani yaratish davomida ham shu misolga o’zgartirishlar kiritib, sodda biblioteka bilan standart bibliotekaning farqini tushunib olishimiz osonroq bo’ladi. Dastlab, ilgari o’rganilgan material asosida qiymat turlarini, jumladan matnli qatorni konvertatsiyalash buyruqlarini eslab olamiz.

Ma’lumki, matnli qatorni EEPROM-xotiraga saqlashda unga massiv sifatida qarash eng oson usul hisoblanadi. Ixtiyoriy matnli qatorni, xususan WiFi tarmog’i nomi (SSID) va parolini EEPROM-xotiradan o’qishda ulardagi belgilar xotira kataklarining qaysi diapazonida (kataklar oralig’ida) saqlanganini bilish zarurati tug’iladi. Shuning uchun, har bir matnli qatorni saqlashdan oldin matnning uzunligi ko’rsatib qo’yilishi maqsadga muvofiq.

Shulardan kelib chiqsak, matnli qatorni EEPROM-xotiraga saqlash (‘MatnniSaqlash.ino’) sketchi quyidagi ko’rinishda bo’ladi:

WiFi sozlamalarini EEPROM-xotiraga saqlash sketchi. 1-versiya

#include <EEPROM.h>
void setup() {
EEPROM.begin(1024);
Serial.begin(115200);
delay(100);
Serial.println();
matnSaqla(0, “Ofis”); // SSIDni 0-katakdan boshlab saqlash
matnSaqla(21, “12345678”); // Parolni 21-katakdan boshlab saqlash
}

void matnSaqla(byte boshManzil, String matn){
byte uzunlik = matn.length();
if (matn==””) uzunlik=0;
EEPROM.put(boshManzil, uzunlik); // dastlabki katakka matn uzunligini saqlash
Serial.println(boshManzil);
if (uzunlik>0) {
for (int i=0; i<uzunlik; i++) {
EEPROM.put(boshManzil+i+1, matn[i]); // keyingi katakdan boshlab matndagi belgilarni alohida baytlar sifatida saqlash
Serial.print(matn[i]);
}
Serial.println();
}
EEPROM.commit();
}

void loop() {
}

Dasturni ishga tushirsak, dastlab ko’rsatilgan matnlarning uzunligi EEPROM-xotiraning ko’rsatilgan manzillariga (ushbu misolda WiFi nomi uzunligi 0-katakka, parol uzunligi esa, 21-katakka) saqlanadi. Keyingi (1- va 22-) katakdan boshlab esa, matn belgilari ketma-ket saqlab qo’yiladi.

Matnli qatorni EEPROM-xotiradan o’qish (‘MatnniUqish.ino’ ) sketchi esa, quyidagi ko’rinishda bo’ladi:

WiFi sozlamalarini EEPROM-xotiradan o'qish sketchi. 1-versiya

#include <EEPROM.h>
Serial.begin(115200);
delay(100);
Serial.println();
String ssid=matnUqi(0); // SSIDni o’qish
Serial.println(“SSID: ” + ssid);
String parol=matnUqi(21); // Parolni o’qish
Serial.println(“Parol: ” + parol);
}

String matnUqi(int boshManzil){
String matn = “”;
int uzunlik=EEPROM.read(boshManzil); // matn uzunligini xotiradan o’zlashtirish
Serial.println(uzunlik);
if (uzunlik>0) { // matn uzunligi 0 dan farqli bo’lsa, ularni ketma-ket o’qish va matn sifatida birlashtirish
for (int i=0;i<uzunlik;i++){
matn += (char)EEPROM.read(boshManzil+i+1);
}
}
return matn;
}

void loop() {
}

Dasturni ishga tushirib, oldingi misol yordamida saqlangan SSID hamda parol uzunligi va ularning matnini port monitorida ko’rishimiz mumkin.

Endi yuqoridagi standart bibliotekaning 1-varianti kabi, yangi “TextToEEPROM” nomli biblioteka yaratib olamiz (yuqorida keltirilgan tartibda “TextToEEPROMLib” biblioteka papkasini hosil qilib, uning ichida “TxtEEPROM.h“, “TxtEEPROM.cpp” matnli fayllarini yaratamiz). Sketchdagi funksiyalarni biblioteka fayllariga ko’chirilganligi sababli, biblioteka fayllari quyidagi ko’rinishga keladi:

'TxtEEPROM.h' sarlavha fayli

#include “Arduino.h”
void matnSaqla(byte boshManzil, String matn);
String matnUqi(int boshManzil);

'TxtEEPROM.cpp' realizatsiya fayli

#include “Arduino.h”
#include “EEPROM.h”
#include “TxtEEPROM.h”

void matnSaqla(byte boshManzil, String matn){
byte uzunlik = matn.length();
if (matn==””) uzunlik=0;
EEPROM.put(boshManzil, uzunlik);
if (uzunlik>0) {
for (int i=0; i<uzunlik; i++) {
EEPROM.put(boshManzil+i+1, matn[i]);
}
}
EEPROM.commit();
}

String matnUqi(int boshManzil){
String matn = “”;
int uzunlik=EEPROM.read(boshManzil);
if (uzunlik>0) {
for (int i=0;i<uzunlik;i++){
matn += (char)EEPROM.read(boshManzil+i+1);
}
}
return matn;
}

Arduino IDE menyusidagi bibliotekalari ro’yxatida esa, “TextToEEPROMLib” papkasi nomi ham ko’rinishi kerak. Yuqoridagi 2 ta sketchlar esa, tegishli o’zgarishlardan so’ng quyidagi ko’rinishlarga keladi:

WiFi sozlamalarini biblioteka yordamida EEPROM-xotiraga saqlash sketchi. 2-versiya

#include <EEPROM.h>
#include <txtEEPROM.h>
void setup() {
EEPROM.begin(1024);
Serial.begin(115200);
delay(100);
Serial.println();
matnSaqla(0, “Ofis2”); // SSIDni 0-katakdan boshlab saqlash
matnSaqla(21, “1234567890”); // Parolni 21-katakdan boshlab saqlash
}

void loop() {
}

WiFi sozlamalarini biblioteka yordamida EEPROM-xotiradan o'qish sketchi. 2-versiya

#include <EEPROM.h>
#include <txtEEPROM.h>
void setup() {
EEPROM.begin(1024);
Serial.begin(115200);
delay(100);
Serial.println();
String ssid=matnUqi(0); // SSIDni 0-katakdan boshlab o’qish
Serial.println(“SSID: ” + ssid);
String parol=matnUqi(21); // Parolni 21-katakdan boshlab o’qish
Serial.println(“Parol: ” + parol);
}

void loop() {
}

Har ikki dasturni navbat bilan ishga tushirib, matn xotiraga to’g’ri saqlanganiga ishonch hosil qilishimiz mumkin.

Standart bibliotekaning 2-varianti

Bibliotekaning bunday turini yaratish uchun, Wiring dasturlash tilidan tashqari, C++ imkoniyatlaridan ham foydalanishga to’g’ri keladi.

Bibliotekaning bunday variantida ham, odatda biblioteka fayllari soni 2 ta va undan ortiq bo’ladi. Bundan tashqari, biblioteka asosiy papkasi ichida “src“, “examples” nomli va yana boshqa yordamchi papkalar yaratilishi ham mumkin. Asosiy biblioteka (“.h“, “.cpp“) fayllari “src” papkasi ichida joylashadi. Agar biblioteka ko’plab fayllardan tashkil topgan bo’lsa, ularning barcha fayllari aynan shu papkada joylashadi.

Standart bibliotekani yaratish uchun avvalo boshqa darsda o’rganilgan, C++ ning klass va metod tushunchalari bilan tanishib olishimiz kerak bo’ladi. Ushbu tushunchalar C++ dasturlash tilidan Arduino IDE da qo’llaniladigan Wiring dasturlash tiliga meros bo’lib o’tgan. Aslida, klass yaratildi degani – deyarli yangi biblioteka ham yaratildi degani bo’ladi. Chunki, klass yaratilganidan keyingi bosqichlar shunchaki bibliotekani rasmiylashtirish bosqichi hisoblanadi.

Klassni yaratish

Yuqorida aytilganidek, klass va uning elementlari bevosita asosiy dasturda yoki bibliotekaning sarlavha hamda realizatsiya fayllarida hosil qilinishi mumkin. Bevosita bibliotekada klassni yaratishga o’tishdan oldin, qulaylik uchun biz uni dastlab asosiy dasturning o’zida yaratib, uning ishlash prinsipi bilan yaqindan tanishib olamiz.

Klassning e’lon qilinishi va qo’llanilishi, o’z xususiyatlariga ko’ra, strukturaga o’xshab ketadi. Lekin, aslida uning ichki imkoniyatlari juda keng va obyektga yo’naltirilgan dasturlash konsepsiyasining asoslaridan biri hisoblanadi.

Klassning strukturadan eng muhim farqi – uning sohalarga ajratilishi hisoblanadi: public (ochiq) va private (yopiq) sohalariga. Bir soha boshqa soha boshlanadigan joygacha yoki klassdagi yopuvchi figurali qavsgacha amal qiladi.

public sohasi a’zolari obyekt yaratilgan asosiy dasturdan (sketchdan) murojaat qilish uchun ochiq hisoblanadi. U klassning a’zolariga (o’zgaruvchi va kontantalariga) obyekt yaratiladigan asosiy dastur (sketch) dan murojaat qilish mumkin bo’lgan (global) soha hisoblanadi. Ushbu sohani sketchning global o’zgaruvchilar e’lon qilinadigan sohasiga qiyoslash mumkin.

private sohasi a’zolari faqat klass ichida murojaat qilish uchun ochiq, asosiy dastur uchun esa yopiq hisoblanadi. Ushbu sohani sketchning ma’lum bir funksiyasi ichida amal qiladigan lokal o’zgaruvchilar sohasiga qiyoslash mumkin.

Demak, sohalarini hisobga olgan holda, klassni quyidagicha e’lon qilish mumkin:

class <KLASS_NOMI>{
public:
// dasturdan murojaat qilish uchun ochiq soha
<klass_1-a’zosi>;
<klass_2-a’zosi>;
private:
// faqat klass ichida murojaat qilish uchun ochiq soha
<klass_3-a’zosi>;
<klass_4-a’zosi>;
};

Klassda kamida 1 ta soha ko’rsatib ketilishi kerak. Masalan, faqat public sohasi.

Ba’zi bibliotekalarni yaratishda klassning public sohasida konstruktor ham qo’llanilishi mumkin. U obyektni yaratish paytida chaqiriladi va klass nomi bilan bir xil bo’lgan nomga ega bo’ladi. Konstruktor klassga murojaat qilishning bir nechta variantlarini yaratish imkonini beradi. Masalan:

class <KLASS_NOMI> {
public:

<konstruktor_nomi>(int a, String b){
_a=a;
_b=b;
}

<konstruktor_nomi>(int a){
_a=a;
_b=”matn”;
}

// dasturdan murojaat qilish uchun ochiq soha

private:
// faqat klass ichida murojaat qilish uchun ochiq soha
};

Misolda ko’rinib turibdiki, asosiy dasturdan klass ekzemplyariga murojaat qilinganda, uni obyekt argumentlari sonidan kelib chiqib, 2 xil usul bilan amalga oshirish mumkin: 2 ta argument bilan yoki faqat 1-argument bilan. 2-variantdagi 2-argument o’rniga, klassda har doim o’zgarmaydigan qiymat qo’llaniladi.

Klass obyektini yaratish

Obyekt yaratish, yuqorida aytib o’tilganidek, asosiy dasturda bajariladi. Agar klass asosiy dasturda yaratilgan bo’lsa, obyekt undan keyingi navbatda yaratilishi kerak, aksincha xatolik yuz beradi. Obyektni yaratish xuddi strukturani yaratishdek – klass nomi bo’yicha bajariladi:

<KLASS_NOMI> <obyekt_nomi>; obyekt yaratish
<KLASS_NOMI> <obyekt_nomi>[10]; obyektlar massivini yaratish

Klass a’zolariga murojaat qilish ham xuddi struktura a’zolariga murojaat qilgandek bajariladi. Ya’ni, klass nomi va metodi o’rtasida “.” (nuqta) qo’llaniladi:

<obyekt_nomi>.<metod_nomi>(); obyekt metodini chaqirish, yoki
<obyekt_nomi[tartib_raqami]>.<metod_nomi>(); obyektlar massividan obyekt metodini chaqirish.

Sodda hamda standart bibliotekalarning klass yordamida yaratiladigan 2-variantlarini misollar yordamida, aniqrog’i yuqoridagi misollarga o’zgartirish kiritish orqali ko’rib chiqamiz. Bunda ham dastlab klassni bevosita asosiy dasturimiz kodida qo’llaymiz. Shundan keyin uni alohida biblioteka fayllariga olib o’tamiz.

3-misol. Dastlab, yuqoridagi “miltillash” sketchini klass yordamida takomillashtirib, uning yangi versiyasini hosil qilamiz. Yuqoridagi bazaviy ma’lumotlarimiz asosida sketchning bibliotekalar va o’zgaruvchilarni e’lon qilish sohasida yangi klass yaratamiz. Uni “LED” deb nomlaymiz. Natijada sketchimiz quyidagi holatga keladi:

'miltillash' sketchi. 2-versiya

class LED {
public:
LED(int pin, uint32_t pauza, int hisobchi){
_pin=pin;
_pauza=pauza;
_hisobchi=hisobchi;
pinMode(_pin, OUTPUT);
}
void miltilla(){
if (_hisobchi>0) {
for (int i=0; i<_hisobchi; i++){
digitalWrite(_pin, HIGH);
delay(_pauza);
digitalWrite(_pin, LOW);
delay(_pauza);
}
}
}

private:
int _pin;
uint32_t _pauza;
int _hisobchi;
};

LED led1(2, 200, 10); // led1 obyektini e’lon qilish
LED led2(3, 500, 1); // led2 obyektini e’lon qilish

void setup() {
led1.miltilla();
}

void loop() {
led2.miltilla();
}

Sketch ishga tushirilgach, dastlab 2-raqamli pinga ulangan svetodiod (led1 obyekti) 200 ms pauza bilan 10 marta va 3-raqamli pinga ulangan svetodiod (led2 obyekti) 500 ms pauza bilan uzliksiz miltillaganini kuzatish mumkin.

Ushbu sketchning bir nechta konstruktorli varianti, masalan quyidagicha bo’lishi mumkin:

'miltillash' sketchi. 3-versiya

class LED {
public:
LED(int pin, uint32_t pauza, int hisobchi){ // 1-konstruktor
_pin=pin; // pin raqami o’zgarishi mumkin
_pauza=pauza; // pauza qiymati o’zgarishi mumkin
_hisobchi=hisobchi; // takrorlanish qiymati o’zgarishi mumkin
pinMode(_pin, OUTPUT);
}
LED(int pin, uint32_t pauza){ // 2-konstruktor
_pin=pin; // pin raqami o’zgarishi mumkin
_pauza=pauza; // pauza qiymati o’zgarishi mumkin
_hisobchi=1; // takrorlanish qiymati o’zgarmaydi
pinMode(_pin, OUTPUT);
}
LED(int pin){ // 3-konstruktor
_pin=pin; // pin raqami o’zgarishi mumkin
_pauza=1000; // pauza qiymati o’zgarmaydi
_hisobchi=1; // takrorlanish qiymati o’zgarmaydi
pinMode(_pin, OUTPUT);
}
void pauzaQiymati(uint32_t pauza){
_pauza=pauza;
}
void hisobchiQiymati(int hisobchi){
_hisobchi=hisobchi;
}
void miltilla(){
if (_hisobchi>0) {
for (int i=0; i<_hisobchi; i++){
digitalWrite(_pin, HIGH);
delay(_pauza);
digitalWrite(_pin, LOW);
delay(_pauza);
}
}
}

private:
int _pin;
uint32_t _pauza;
int _hisobchi;
};

LED led1(2, 200, 10); // 1-konstruktor asosidagi led1 obyekti
LED led2(3, 500); // 2-konstruktor asosidagi led2 obyekti
LED led3(4); // 3-konstruktor asosidagi led3 obyekti

void setup() {
led1.miltilla();
led2.miltilla();
led2.pauzaQiymati(1000);
led2.hisobchiQiymati(5);
led2.miltilla();
}

void loop() {
led3.miltilla();
}

Ushbu sketch ishga tushirilganda, dastlab 2-raqamli pinga ulangan svetodiod (led1 obyekti) 200 ms pauza bilan 10 marta, 3-raqamli pinga ulangan svetodiod (led2 obyekti) 500 ms pauza bilan 1 marta, keyin xuddi shu svetodiod 1000 ms pauza bilan 5 marta va 4-raqamli pinga ulangan svetodiod (led3 obyekti) 1000 ms pauza bilan uzliksiz miltillaganini kuzatish mumkin.

Yuqoridagi “LED” klassini asosiy dasturdan alohida biblioteka fayliga olib o’tish orqali, undan boshqa dasturlarda ham imkoniyatini yaratishimiz mumkin. Yuqorida aytib o’tilganidek, bunday bibliotekani faqat 1 ta sarlavha fayli yordamida ham yaratishimiz mumkin. Chunki, biz yaratgan klass unchalik murakkab emas. Lekin, shunday bo’lsa-da, ushbu klass asosida 2 ta asosiy fayldan iborat standart biblioteka yaratish variantini ham ko’rib chiqamiz. Har ikki hol uchun alohida bibliotekalar yaratiladi va har ikki holda ham, sketchga deyarli o’zgartirish talab etilmaydi (faqat kerakli biblioteka fayli nomi ko’rsatilishi kerak xolos).

Faqat 1 ta fayldan iborat bo’lgan “YangiBlink2” bibliotekasi kodi (“YangiBlink2.h” sarlavha faylidagi “#pragma once” operatori quyida sanab o’tiladigan bibliotekalar faqat 1 marta qo’llanilishi kerakligini qat’iy belgilab qo’yadi, murakkab biblioteka fayllarida ularning tasodifan qayta qo’llanilishining oldini oladi. Arduino IDE ning eski versiyalarida uning o’rniga “#ifndef/#define/#endif” operatorlari juftligi qo’llanilgan):

'YangiBlink2.h' fayli

#pragma once
#include “Arduino.h”

class LED {
public:
LED(int pin, uint32_t pauza, int hisobchi); // konstruktor
LED(int pin, uint32_t pauza); // konstruktor
LED(int pin); // konstruktor
void miltilla();
void pauzaUrnat(uint32_t pauza);
void hisobchiUrnat(int hisobchi);
uint32_t pauzaQiymati();
int hisobchiQiymati();

private:
int _pin;
uint32_t _pauza;
int _hisobchi;
};

LED::LED(int pin, uint32_t pauza, int hisobchi){ // klass ekzemplyari
_pin=pin;
_pauza=pauza;
_hisobchi=hisobchi;
pinMode(_pin, OUTPUT);
}
LED::LED(int pin, uint32_t pauza){ // klass ekzemplyari
_pin=pin;
_pauza=pauza;
_hisobchi=1;
pinMode(_pin, OUTPUT);
}
LED::LED(int pin){ // klass ekzemplyari
_pin=pin;
_pauza=1000;
_hisobchi=1;
pinMode(_pin, OUTPUT);
}
void LED::miltilla(){ // metod
if (_hisobchi>0) {
for (int i=0; i<_hisobchi; i++){
digitalWrite(_pin, HIGH);
delay(_pauza);
digitalWrite(_pin, LOW);
delay(_pauza);
}
}
}
void LED::pauzaUrnat(uint32_t pauza){
_pauza=pauza;
}
void LED::hisobchiUrnat(int hisobchi){
_hisobchi=hisobchi;
}
uint32_t LED::pauzaQiymati(){
return _pauza;
}
int LED::hisobchiQiymati(){
return _hisobchi;
}

Ushbu biblioteka imkoniyatlarini ko’rsatib beruvchi sketch kodi :

'miltillash' sketchi. 4-versiya

#include <YangiBlink2.h>

LED led1(2, 200, 10); // 1-konstruktor asosidagi led1 obyekti
LED led2(3, 500); // 2-konstruktor asosidagi led2 obyekti
LED led3(4); // 3-konstruktor asosidagi led3 obyekti

void setup() {
Serial.begin(115200);

led1.miltilla();

led1.pauzaUrnat(1000);
led1.hisobchiUrnat(5);
led1.miltilla();

led2.miltilla();
led2.pauzaUrnat(2000);
led2.miltilla();
}

void loop() {
Serial.println(led1.pauzaQiymati());
Serial.println(led1.hisobchiQiymati());

Serial.println(led2.pauzaQiymati());
Serial.println(led2.hisobchiQiymati());

Serial.println(led3.pauzaQiymati());
Serial.println(led3.hisobchiQiymati());

led3.miltilla();
}

Sketch ishga tushirilsa, dastlab 2-pinga ulangan svetodiod 200 ms pauza bilan 10 marta, keyin aynan shu svetodiod 1000 ms pauza bilan 5 marta (chunki pauza va takrorlanishlar soni mos holda “pauzaUrnat” va “hisobchiUrnat” metodlari yordamida o’zgartirildi), shundan keyin 3-pinga ulangan svetodiod (led2 obyekti) dastlab 500 ms pauza bilan 1 marta va 2000 ms pauza bilan yana 1 marta miltillaydi. Oxirida esa, 4-pinga ulangan svetodiod (led3 obyekti) 1000 ms pauza bilan uzluksiz miltillay boshlaydi. Bundan tashqari, 4-pindagi svetodiod bilan birga ketma-ket portda har bir svetodiodning miltillash parametrlari ko’rsatila boshlaydi.

Yuqoridagi yagona biblioteka faylini standart biblioteka sifatida 2 ta alohida fayllarga ajratilib, oxirgi sketch qo’llanilsa ham oxirgi natijalarni kuzatish mumkin. Asosiysi, sketch boshida “YangiBlink2.h” fayli o’rniga “YangiBlink3.h” fayli ko’rsatilib qo’yilishi kerak:

'YangiBlink3.h' sarlavha fayli

#pragma once
#include “Arduino.h”

class LED {
public:
LED(int pin, uint32_t pauza, int hisobchi); // konstruktor
LED(int pin, uint32_t pauza); // konstruktor
LED(int pin); // konstruktor

void miltilla(); // metodni e’lon qilish
void pauzaUrnat(uint32_t pauza); // metodni e’lon qilish
void hisobchiUrnat(int hisobchi); // metodni e’lon qilish
uint32_t pauzaQiymati(); // metodni e’lon qilish
int hisobchiQiymati(); // metodni e’lon qilish

private:
int _pin;
uint32_t _pauza;
int _hisobchi;
};

'YangiBlink3.cpp' realizatsiya fayli

#include “Arduino.h”
#include “YangiBlink3.h”

// metodlar realizatsiyasi:

void LED::miltilla(){
if (_hisobchi>0) {
for (int i=0; i<_hisobchi; i++){
digitalWrite(_pin, HIGH);
delay(_pauza);
digitalWrite(_pin, LOW);
delay(_pauza);
}
}
}
void LED::pauzaUrnat(uint32_t pauza){
_pauza=pauza;
}
void LED::hisobchiUrnat(int hisobchi){
_hisobchi=hisobchi;
}
uint32_t LED::pauzaQiymati(){
return _pauza;
}
int LED::hisobchiQiymati(){
return _hisobchi;
}

4-misol. Xuddi yuqoridagidek, “MATN” nomli yangi klass yaratib, yuqoridagi 2-misolda ko’rsatilgan matnli qatorni EEPROM-xotiraga saqlash hamda undan o’qish sketchlari kodini va tegishli bibliotekalar kodlarini ham quyidagicha ifodalash mumkin:

WiFi sozlamalarini EEPROM-xotiraga saqlash va undan o'qish sketchi. Klassni asosiy kodda qo'llash. 1-versiya

#include <EEPROM.h>
class MATN {
public:
MATN(int EEPROM_hajmi, byte matnUzunligi){
_EEPROM_hajmi=EEPROM_hajmi;
_matnUzunligi=matnUzunligi;
EEPROM.begin(_EEPROM_hajmi);
}
void saqla(int _boshManzil, String _matn){
byte u = _matn.length();
if (u>_matnUzunligi) u=_matnUzunligi;
if (_matn==””) u=0;
EEPROM.put(_boshManzil, u);
if (u>0) {
for (int i=0; i<u; i++) {
EEPROM.put(_boshManzil+i+1, _matn[i]);
}
}
EEPROM.commit();
}
String uqi(int _boshManzil){
String _matn = “”;
int u=EEPROM.read(_boshManzil);
Serial.println(u);
if (u>0) {
for (int i=0;i<u;i++){
_matn += (char)EEPROM.read(_boshManzil+i+1);
}
}
return _matn;
}

private:
int _EEPROM_hajmi;
byte _matnUzunligi;
int _boshManzil;
String _matn;
};

MATN matn1(1024, 20);

void setup() {
Serial.begin(115200);
matn1.saqla(0, “Ofis”); // SSIDni 0-katakdan boshlab saqlash
matn1.saqla(21, “12345678”); // SSIDni 0-katakdan boshlab saqlash
Serial.println();
delay(100);
String ssid=matn1.uqi(0); // SSIDni o’qish
Serial.println(“SSID: ” + ssid);
String parol=matn1.uqi(21); // Parolni o’qish
Serial.println(“Parol: ” + parol);
}
void loop() {
}

Klassni 1 ta fayldan iborat biblioteka fayli ko’chirilgan variant va unga mos sketch:

'TxtEEPROM2.h' sarlavha fayli

#pragma once
#include “Arduino.h”
#include <EEPROM.h>
class MATN {
public:
MATN(int EEPROM_hajmi, byte matnUzunligi); // 1-konstruktor
MATN(int EEPROM_hajmi); // 2-konstruktor
void saqla(int _boshManzil, String _matn);
String uqi(int _boshManzil);

private:
int _EEPROM_hajmi;
byte _matnUzunligi;
int _boshManzil;
String _matn;
};

void MATN::saqla(int _boshManzil, String _matn){
byte u = _matn.length();
if (u>_matnUzunligi) u=_matnUzunligi;
if (_matn==””) u=0;
EEPROM.put(_boshManzil, u);
if (u>0) {
for (int i=0; i<u; i++) {
EEPROM.put(_boshManzil+i+1, _matn[i]);
}
}
EEPROM.commit();
}
String MATN::uqi(int _boshManzil){
String _matn = “”;
int u=EEPROM.read(_boshManzil);
Serial.println(u);
if (u>0) {
for (int i=0;i<u;i++){
_matn += (char)EEPROM.read(_boshManzil+i+1);
}
}
return _matn;
}

WiFi sozlamalarini EEPROM-xotiraga saqlash va undan o'qish sketchi. Klassni 1 ta biblioteka faylida qo'llash. 2-versiya

#include <TxtEEPROM2.h>
MATN matn1(1024, 20);
// MATN matn1(512);

void loop() {
}

Klassni 2 ta standart biblioteka fayllariga ko’chirilgan variant va unga mos sketch:

'TxtEEPROM3.h' sarlavha fayli

private:
int _EEPROM_hajmi;
byte _matnUzunligi;
int _boshManzil;
String _matn;
};

'TxtEEPROM3.cpp' realizatsiya fayli

#pragma once
#include “Arduino.h”
#include “TxtEEPROM3.h”
#include <EEPROM.h>

// Metodlar realizatsiyasi:

MATN::MATN(int EEPROM_hajmi, byte matnUzunligi){
_EEPROM_hajmi=EEPROM_hajmi;
_matnUzunligi=matnUzunligi;
EEPROM.begin(_EEPROM_hajmi);
}
MATN::MATN(int EEPROM_hajmi){
_EEPROM_hajmi=EEPROM_hajmi;
_matnUzunligi=20;
EEPROM.begin(_EEPROM_hajmi);
}
void MATN::saqla(int _boshManzil, String _matn){
byte u = _matn.length();
if (u>_matnUzunligi) u=_matnUzunligi;
if (_matn==””) u=0;
EEPROM.put(_boshManzil, u);
if (u>0) {
for (int i=0; i<u; i++) {
EEPROM.put(_boshManzil+i+1, _matn[i]);
}
}
EEPROM.commit();
}
String MATN::uqi(int _boshManzil){
String _matn = “”;
int u=EEPROM.read(_boshManzil);
Serial.println(u);
if (u>0) {
for (int i=0;i<u;i++){
_matn += (char)EEPROM.read(_boshManzil+i+1);
}
}
return _matn;
}

WiFi sozlamalarini EEPROM-xotiraga saqlash va undan o'qish sketchi. Klassni standart biblioteka fayllarida qo'llash. 3-versiya

#include <TxtEEPROM3.h>
MATN matn1(1024, 20); // EEPROM-xotira o’lchami va matn maksimal uzunligi
// MATN matn1(512); // EEPROM-xotira o’lchami (matn maksimal uzunligi 20 ga teng bo’ladi)

void loop() {
}

4-misolning yuqoridagi barcha variantlarida sketch ishga tushirilganda, dastlab WiFi tarmog’i parametrlari (SSID va paroli) EEPROM-xotiraga MATN klassining matn1 obyekti hamda saqla metodi yordamida saqlanadi. uqi metodi yordamida esa, matn xotiradan o’qiladi. Natijalar port monitoriga chiqarib boriladi.

Tanishing

Arduino bibliotekasini yaratish [18+]

Добавить комментарий Отменить ответ