{"id":4277,"date":"2024-09-18T18:48:55","date_gmt":"2024-09-18T13:48:55","guid":{"rendered":"https:\/\/yarat.uz\/?p=4277"},"modified":"2025-03-19T15:27:03","modified_gmt":"2025-03-19T10:27:03","slug":"arduino-bibliotekasini-yaratish-18","status":"publish","type":"post","link":"https:\/\/yarat.uz\/?p=4277","title":{"rendered":"Arduino bibliotekasini yaratish [18+]"},"content":{"rendered":"

Ilgari<\/a> 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<\/strong>” buyrug’i yordamida qo’shib olish yetarli bo’ladi.<\/p>\n

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

Yangi biblioteka yaratish<\/strong><\/p>\n

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<\/strong>” (header), realizatsiya fayli esa “.cpp<\/strong>” (C++) kengaytmasiga ega bo’ladi.<\/p>\n

Bundan tashqari, standart biblioteka tarkibida “keywords.txt<\/strong>” matnli fayli va “examples<\/strong>” 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.<\/p>\n

Agar biblioteka kam sondagi vazifalarni bajarishga mo’ljallangan bo’lsa, sarlavha va realizatsiya fayllari kodini yagona faylga – sarlavha (.h<\/strong>) 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.<\/p>\n

Sodda biblioteka<\/strong><\/p>\n

Sodda biblioteka yaratish uchun C++ dasturlash tiliga murojaat qilish talab etilmaydi. Jumladan,\u00a0.cpp<\/strong> 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.<\/p>\n

1-misol.<\/strong> 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.<\/p>\n

Ma’lumki, sketchning dastlabki ko’rinishi quyidagicha:<\/p>\n

<\/span>Original 'Blink' sketchi<\/div>
\nvoid setup(){
\npinMode(13, OUTPUT);
\n}<\/p>\n

void loop(){
\ndigitalWrite(13, HIGH);
\ndelay(1000);
\ndigitalWrite(13, LOW);
\ndelay(1000);
\n}
\n<\/div><\/div>\nAlohida 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:<\/p>\n

<\/span>O'zgartirilgan 'Blink' sketchi<\/div>
\n

void setup(){
\n}<\/p>\n

void loop(){
\nmiltilla(LED_BUILTIN, 1000);
\n}<\/p>\n

void miltilla(int pin, int pauza){
\npinMode(pin, OUTPUT);
\ndigitalWrite(pin, HIGH);
\ndelay(pauza);
\ndigitalWrite(pin, LOW);
\ndelay(pauza);
\n}<\/p>\n<\/div><\/div>\n

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

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

<\/span>'miltillash' sketchi. 1-versiya<\/div>
\nint pin = LED_BUILTIN;
\nint pauza = 1000;
\nint hisobchi = 5;
\nvoid setup() {
\npinMode(pin, OUTPUT);
\nmiltillash(pin, pauza, hisobchi);
\n}<\/p>\n

void loop() {<\/p>\n

}<\/p>\n

void miltillash(int pin, int pauza, int hisobchi){
\nif (hisobchi>0) {
\nfor (int i=0; i<hisobchi; i++){
\ndigitalWrite(pin, HIGH);
\ndelay(pauza);
\ndigitalWrite(pin, LOW);
\ndelay(pauza);
\n}
\n}
\n}
\n<\/div><\/div>\n

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.<\/p>\n

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.<\/p>\n

Bunday fayllarni yaratish uchun, dastlab Arduino IDE dasturi sketchlari saqlanadigan papkadagi “libraries”<\/strong> papkasini topamiz va yangi “YangiBlinkLib”<\/strong> deb nomlangan yangi papka hosil qilamiz (sketchlar papkasiga “\u0421\u043a\u0435\u0442\u0447”<\/strong> menyusidagi “\u041f\u043e\u043a\u0430\u0437\u0430\u0442\u044c \u043f\u0430\u043f\u043a\u0443 \u0441\u043a\u0435\u0442\u0447\u0430”<\/strong> elementi yoki “Ctrl+K”<\/strong> klavishalar kombinatsiyasi orqali o’tish mumkin). Uning ichida esa, ixtiyoriy matnli redaktor yordamida “YangiBlink.h”<\/strong> sarlavha fayli, “YangiBlink.cpp”<\/strong> 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.<\/p>\n

Biblioteka fayllarini Arduino IDE yordamida ham hosil qilishimiz mumkin. Buni 2 xil usulda amalga oshirsa bo’ladi:<\/p>\n

1-usulda fayllar sketch ko’rinishida yaratiladi va alohida papka ichida .ino<\/strong> kengaytmasi bilan saqlanadi. Shundan keyin, har bir fayl yaratilganidan keyin fayl menejeri orqali (masalan, Total Commanderda) uning kengaytmasini .h<\/strong>,\u00a0.cpp<\/strong> va txt<\/strong> 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.<\/p>\n

2-usulda Arduino IDE dasturida yangi sketch yaratib, dastur oynasidag sketch nomidan o’ng tomonda joylashgan menyudan “\u041d\u043e\u0432\u0430\u044f \u0432\u043a\u043b\u0430\u0434\u043a\u0430<\/strong>” buyrug’i yoki “Ctrl+Shift+N<\/strong>” klavishalari kombinatsiyasi yordamida yangi oynalar yaratamiz, ularga biblioteka nomi bilan bir xil, lekin .h<\/strong> va .cpp<\/strong> kengaytmaga ega bo’lgam nomlar beramiz: “YangiBlink.h” va “YangiBlink.cpp” (Bunday usul bilan .txt<\/strong> kengaytmali fayl yaratib bo’lmaydi. Lekin “keywords.txt” faylini sketch ko’rinishida yaratib, keyin uning kengaytmasini .ino<\/strong> dan .txt<\/strong> 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.<\/p>\n

Biblioteka fayllarini quyidagi ko’rinishga keltiramiz:<\/p>\n

“YangiBlink.h” fayli:<\/strong><\/p>\n

<\/span>'YangiBlink.h' - bibliotekaning sarlavha fayli<\/div>
\n#include “Arduino.h”
\nvoid miltilla(int pin); \/\/ takrorlanish soni va pauza davomiyligi ko’rsatilmaydigan variant uchun
\nvoid miltillaint pin, int pauza); \/\/ takrorlanish soni ko’rsatilmaydigan variant uchun
\nvoid miltilla(int pin, int pauza, int hisobchi); \/\/ barcha argumentlar ko’rsatiladigan variant uchun
\n<\/div><\/div>\n

“YangiBlink.cpp” fayli:<\/strong>
\n

<\/span>'YangiBlink.cpp' - realizatsiya fayli<\/div>
\n#inclide “Arduino.h”
\n#include “YangiBlink.h”<\/p>\n

void miltilla(int pin){ \/\/ takrorlanish soni va davomiylik ko’rsatilmaydigan funksiya
\npinMode(pin, OUTPUT);
\ndigitalWrite(pin, HIGH);
\ndelay(1000);
\ndigitalWrite(pin, LOW);
\ndelay(1000);
\n}
\nvoid miltilla(int pin, int pauza){ \/\/ takrorlanish soni ko’rsatilmaydigan funksiya
\npinMode(pin, OUTPUT);
\ndigitalWrite(pin, HIGH);
\ndelay(pauza);
\ndigitalWrite(pin, LOW);
\ndelay(pauza);
\n}
\nvoid miltilla(int pin, int pauza, int hisobchi){ \/\/ barcha argumentlar ko’rsatiladigan funksiya
\npinMode(pin, OUTPUT);
\nfor (int i=0;i<hisobchi; i++){
\ndigitalWrite(pin, HIGH);
\ndelay(pauza);
\ndigitalWrite(pin, LOW);
\ndelay(pauza);
\n}
\n}
\n<\/div><\/div>\n

Ko’rinib turibdiki, realizatsiya faylida PinMode()<\/strong> 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:<\/p>\n

<\/span>'keywords.txt' - kalit-so'zlar fayli<\/div>
\nYangiBlink KEYWORD1
\nmiltilla KEYWORD1
\n<\/div><\/div>\n

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.<\/p>\n

Shundan keyin, Arduino IDE ni to’liq yopib, qayta ishga tushiramiz va yangi sketch yaratib, “\u0421\u043a\u0435\u0442\u0447\/\u041f\u043e\u0434\u043a\u043b\u044e\u0447\u0438\u0442\u044c \u0431\u0438\u0431\u043b\u0438\u043e\u0442\u0435\u043a\u0443”<\/strong> menyusidan “YangiBlinkLib<\/strong>” (biz yaratgan biblioteka papkasining nomi) yozuvini topib tanlaymiz (Agar menyuda “YangiBlink<\/strong>Lib<\/strong>” yozuvi mavjud bo’lmasa, bu biblioteka yaratilishi jarayonida xatolik yuz berganini bildiradi). Xatolik kuzatilmasa, sketchda #include <YangiBlink.h><\/strong> yozuvi paydo bo’lishi kerak.<\/p>\n

Yangi sketchmizni\u00a0quyidagi holga keltiramiz va ishga tushiramiz:<\/p>\n

<\/span>'miltillash' sketchi. 2-versiya<\/div>
\n

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

void loop() {
\nmiltilla(LED_BUILTIN); \/\/ takrorlanish soni va pauza davomiyligi (1000 ms) ko’rsatilmaydigan variant
\n}<\/p>\n<\/div><\/div>\n

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.<\/p>\n

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.<\/p>\n

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 “\u0424\u0430\u0439\u043b\/\u041f\u0440\u0438\u043c\u0435\u0440\u044b\/YangiBlinkLib<\/strong>” 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.<\/p>\n

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

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.<\/p>\n

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<\/a> asosida qiymat turlarini, jumladan matnli qatorni konvertatsiyalash buyruqlarini eslab olamiz.<\/p>\n

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\u00a0 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.<\/p>\n

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

<\/span>WiFi sozlamalarini EEPROM-xotiraga saqlash sketchi. 1-versiya<\/div>
\n#include <EEPROM.h>
\nvoid setup() {
\nEEPROM.begin(1024);
\nSerial.begin(115200);
\ndelay(100);
\nSerial.println();
\nmatnSaqla(0, “Ofis”); \/\/ SSIDni 0-katakdan boshlab saqlash
\nmatnSaqla(21, “12345678”); \/\/ Parolni 21-katakdan boshlab saqlash
\n}<\/p>\n

void matnSaqla(byte boshManzil, String matn){
\nbyte uzunlik = matn.length();
\nif (matn==””) uzunlik=0;
\nEEPROM.put(boshManzil, uzunlik); \/\/ dastlabki katakka matn uzunligini saqlash
\nSerial.println(boshManzil);
\nif (uzunlik>0) {
\nfor (int i=0; i<uzunlik; i++) {
\nEEPROM.put(boshManzil+i+1, matn[i]); \/\/ keyingi katakdan boshlab matndagi belgilarni alohida baytlar sifatida saqlash
\nSerial.print(matn[i]);
\n}
\nSerial.println();
\n}
\nEEPROM.commit();
\n}<\/p>\n

void loop() {
\n}
\n<\/div><\/div>\n

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.<\/p>\n

Matnli qatorni EEPROM-xotiradan o’qish (‘MatnniUqish.ino’ ) sketchi esa, quyidagi ko’rinishda bo’ladi:<\/p>\n

<\/span>WiFi sozlamalarini EEPROM-xotiradan o'qish sketchi. 1-versiya<\/div>
\n#include <EEPROM.h>
\nSerial.begin(115200);
\ndelay(100);
\nSerial.println();
\nString ssid=matnUqi(0); \/\/ SSIDni o’qish
\nSerial.println(“SSID: ” + ssid);
\nString parol=matnUqi(21); \/\/ Parolni o’qish
\nSerial.println(“Parol: ” + parol);
\n}<\/p>\n

String matnUqi(int boshManzil){
\nString matn = “”;
\nint uzunlik=EEPROM.read(boshManzil); \/\/ matn uzunligini xotiradan o’zlashtirish
\nSerial.println(uzunlik);
\nif (uzunlik>0) { \/\/ matn uzunligi 0 dan farqli bo’lsa, ularni ketma-ket o’qish va matn sifatida birlashtirish
\nfor (int i=0;i<uzunlik;i++){
\nmatn += (char)EEPROM.read(boshManzil+i+1);
\n}
\n}
\nreturn matn;
\n}<\/p>\n

void loop() {
\n}
\n<\/div><\/div>\n

Dasturni ishga tushirib, oldingi misol yordamida saqlangan SSID hamda parol uzunligi va ularning matnini port monitorida ko’rishimiz mumkin.<\/p>\n

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

<\/span>'TxtEEPROM.h' sarlavha fayli<\/div>
\n#include “Arduino.h”
\nvoid matnSaqla(byte boshManzil, String matn);
\nString matnUqi(int boshManzil);
\n<\/div><\/div>\n
<\/span>'TxtEEPROM.cpp' realizatsiya fayli<\/div>
\n#include “Arduino.h”
\n#include “EEPROM.h”
\n#include “TxtEEPROM.h”<\/p>\n

void matnSaqla(byte boshManzil, String matn){
\nbyte uzunlik = matn.length();
\nif (matn==””) uzunlik=0;
\nEEPROM.put(boshManzil, uzunlik);
\nif (uzunlik>0) {
\nfor (int i=0; i<uzunlik; i++) {
\nEEPROM.put(boshManzil+i+1, matn[i]);
\n}
\n}
\nEEPROM.commit();
\n}<\/p>\n

String matnUqi(int boshManzil){
\nString matn = “”;
\nint uzunlik=EEPROM.read(boshManzil);
\nif (uzunlik>0) {
\nfor (int i=0;i<uzunlik;i++){
\nmatn += (char)EEPROM.read(boshManzil+i+1);
\n}
\n}
\nreturn matn;
\n}
\n<\/div><\/div>\n

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:<\/p>\n

<\/span>WiFi sozlamalarini biblioteka yordamida EEPROM-xotiraga saqlash sketchi. 2-versiya<\/div>
\n#include <EEPROM.h>
\n#include <txtEEPROM.h>
\nvoid setup() {
\nEEPROM.begin(1024);
\nSerial.begin(115200);
\ndelay(100);
\nSerial.println();
\nmatnSaqla(0, “Ofis2”); \/\/ SSIDni 0-katakdan boshlab saqlash
\nmatnSaqla(21, “1234567890”); \/\/ Parolni 21-katakdan boshlab saqlash
\n}<\/p>\n

void loop() {
\n}
\n<\/div><\/div>\n

<\/span>WiFi sozlamalarini biblioteka yordamida EEPROM-xotiradan o'qish sketchi. 2-versiya<\/div>
\n#include <EEPROM.h>
\n#include <txtEEPROM.h>
\nvoid setup() {
\nEEPROM.begin(1024);
\nSerial.begin(115200);
\ndelay(100);
\nSerial.println();
\nString ssid=matnUqi(0); \/\/ SSIDni 0-katakdan boshlab o’qish
\nSerial.println(“SSID: ” + ssid);
\nString parol=matnUqi(21); \/\/ Parolni 21-katakdan boshlab o’qish
\nSerial.println(“Parol: ” + parol);
\n}<\/p>\n

void loop() {
\n}
\n<\/div><\/div>\n

Har ikki dasturni navbat bilan ishga tushirib, matn xotiraga to’g’ri saqlanganiga ishonch hosil qilishimiz mumkin.<\/p>\n

Standart bibliotekaning 2-varianti<\/strong><\/p>\n

Bibliotekaning bunday turini yaratish uchun, Wiring dasturlash tilidan tashqari, C++ imkoniyatlaridan ham foydalanishga to’g’ri keladi.<\/p>\n

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

Standart bibliotekani yaratish uchun avvalo boshqa darsda o’rganilgan, C++ ning klass<\/strong> va metod<\/strong> tushunchalari<\/a> 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.<\/strong> Chunki, klass yaratilganidan keyingi bosqichlar shunchaki bibliotekani rasmiylashtirish bosqichi hisoblanadi.<\/p>\n

Klassni yaratish<\/strong><\/p>\n

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.<\/p>\n

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.<\/p>\n

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

public<\/strong> 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.<\/p>\n

private<\/strong> 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.<\/p>\n

Demak, sohalarini hisobga olgan holda, klassni quyidagicha e’lon qilish mumkin:<\/p>\n

class <KLASS_NOMI>{
\npublic:
\n<\/strong>\/\/ dasturdan murojaat qilish uchun ochiq soha
\n<klass_1-a’zosi>;<\/strong>
\n\u00a0 <klass_2-a’zosi>;
\nprivate:
\n<\/strong>\/\/ faqat klass ichida murojaat qilish uchun ochiq soha
\n<klass_3-a’zosi>;
\n<klass_4-a’zosi>;
\n<\/strong>};<\/strong><\/p>\n

Klassda kamida 1 ta soha ko’rsatib ketilishi kerak. Masalan, faqat\u00a0public<\/strong> sohasi.<\/p>\n

Ba’zi bibliotekalarni yaratishda klassning public<\/strong> 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:<\/p>\n

class <KLASS_NOMI> {
\npublic:<\/strong><\/p>\n

<konstruktor_nomi>(int a, String b){
\n_a=a;<\/strong>
\n_b=b;<\/strong>
\n}<\/strong><\/p>\n

<konstruktor_nomi>(int a){
\n_a=a;<\/strong>
\n_b=”matn”;<\/strong>
\n}<\/strong><\/p>\n

\/\/ dasturdan murojaat qilish uchun ochiq soha<\/p>\n

private:
\n<\/strong>\/\/ faqat klass ichida murojaat qilish uchun ochiq soha
\n};<\/strong><\/p>\n

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.<\/p>\n

Klass obyektini yaratish<\/strong><\/p>\n

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:<\/p>\n

<KLASS_NOMI> <obyekt_nomi>;<\/strong> obyekt yaratish
\n<KLASS_NOMI> <obyekt_nomi>[10];<\/strong> obyektlar massivini yaratish<\/p>\n

Klass a’zolariga murojaat qilish ham xuddi struktura a’zolariga murojaat qilgandek bajariladi. Ya’ni, klass nomi va metodi o’rtasida\u00a0“.”<\/strong> (nuqta) qo’llaniladi:<\/p>\n

<obyekt_nomi>.<metod_nomi>();<\/strong> obyekt metodini chaqirish, yoki
\n<obyekt_nomi[tartib_raqami]>.<metod_nomi>();<\/strong> obyektlar massividan obyekt metodini chaqirish.<\/p>\n

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

3-misol.<\/strong> Dastlab, yuqoridagi “miltillash<\/strong>” 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<\/strong>” deb nomlaymiz. Natijada sketchimiz quyidagi holatga keladi:<\/p>\n

<\/span>'miltillash' sketchi. 2-versiya<\/div>
\n

class LED {
\npublic:
\nLED(int pin, uint32_t pauza, int hisobchi){
\n_pin=pin;
\n_pauza=pauza;
\n_hisobchi=hisobchi;
\npinMode(_pin, OUTPUT);
\n}
\nvoid miltilla(){
\nif (_hisobchi>0) {
\nfor (int i=0; i<_hisobchi; i++){
\ndigitalWrite(_pin, HIGH);
\ndelay(_pauza);
\ndigitalWrite(_pin, LOW);
\ndelay(_pauza);
\n}
\n}
\n}<\/p>\n

private:
\nint _pin;
\nuint32_t _pauza;
\nint _hisobchi;
\n};<\/p>\n

LED led1(2, 200, 10); \/\/\u00a0 led1 obyektini e’lon qilish
\nLED led2(3, 500, 1); \/\/ led2 obyektini e’lon qilish<\/p>\n

void setup() {
\nled1.miltilla();
\n}<\/p>\n

void loop() {
\nled2.miltilla();
\n}<\/p>\n<\/div><\/div>\n

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.<\/p>\n

Ushbu sketchning bir nechta konstruktorli varianti, masalan quyidagicha bo’lishi mumkin:<\/p>\n

<\/span>'miltillash' sketchi. 3-versiya<\/div>
\n

class LED {
\npublic:
\nLED(int pin, uint32_t pauza, int hisobchi){ \/\/ 1-konstruktor
\n_pin=pin; \/\/ pin raqami o’zgarishi mumkin
\n_pauza=pauza; \/\/ pauza qiymati o’zgarishi mumkin
\n_hisobchi=hisobchi; \/\/ takrorlanish qiymati o’zgarishi mumkin
\npinMode(_pin, OUTPUT);
\n}
\nLED(int pin, uint32_t pauza){ \/\/ 2-konstruktor
\n_pin=pin; \/\/ pin raqami o’zgarishi mumkin
\n_pauza=pauza; \/\/ pauza qiymati o’zgarishi mumkin
\n_hisobchi=1; \/\/ takrorlanish qiymati o’zgarmaydi
\npinMode(_pin, OUTPUT);
\n}
\nLED(int pin){ \/\/ 3-konstruktor
\n_pin=pin; \/\/ pin raqami o’zgarishi mumkin
\n_pauza=1000; \/\/ pauza qiymati o’zgarmaydi
\n_hisobchi=1; \/\/ takrorlanish qiymati o’zgarmaydi
\npinMode(_pin, OUTPUT);
\n}
\nvoid pauzaQiymati(uint32_t pauza){
\n_pauza=pauza;
\n}
\nvoid hisobchiQiymati(int hisobchi){
\n_hisobchi=hisobchi;
\n}
\nvoid miltilla(){
\nif (_hisobchi>0) {
\nfor (int i=0; i<_hisobchi; i++){
\ndigitalWrite(_pin, HIGH);
\ndelay(_pauza);
\ndigitalWrite(_pin, LOW);
\ndelay(_pauza);
\n}
\n}
\n}<\/p>\n

private:
\nint _pin;
\nuint32_t _pauza;
\nint _hisobchi;
\n};<\/p>\n

LED led1(2, 200, 10); \/\/ 1-konstruktor asosidagi led1 obyekti
\nLED led2(3, 500); \/\/ 2-konstruktor asosidagi led2 obyekti
\nLED led3(4); \/\/ 3-konstruktor asosidagi led3 obyekti<\/p>\n

void setup() {
\nled1.miltilla();
\nled2.miltilla();
\nled2.pauzaQiymati(1000);
\nled2.hisobchiQiymati(5);
\nled2.miltilla();
\n}<\/p>\n

void loop() {
\nled3.miltilla();
\n}<\/p>\n<\/div><\/div>\n

 <\/p>\n

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.<\/p>\n

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).<\/p>\n

Faqat 1 ta fayldan iborat bo’lgan “YangiBlink2” bibliotekasi kodi (“YangiBlink2.h” sarlavha faylidagi “#pragma once<\/strong>” 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<\/strong>” operatorlari juftligi qo’llanilgan):<\/p>\n

<\/span>'YangiBlink2.h' fayli<\/div>
\n

#pragma once
\n#include “Arduino.h”<\/p>\n

class LED {
\npublic:
\nLED(int pin, uint32_t pauza, int hisobchi); \/\/ konstruktor
\nLED(int pin, uint32_t pauza); \/\/ konstruktor
\nLED(int pin); \/\/ konstruktor
\nvoid miltilla();
\nvoid pauzaUrnat(uint32_t pauza);
\nvoid hisobchiUrnat(int hisobchi);
\nuint32_t pauzaQiymati();
\nint hisobchiQiymati();<\/p>\n

private:
\nint _pin;
\nuint32_t _pauza;
\nint _hisobchi;
\n};<\/p>\n

LED::LED(int pin, uint32_t pauza, int hisobchi){ \/\/ klass ekzemplyari
\n_pin=pin;
\n_pauza=pauza;
\n_hisobchi=hisobchi;
\npinMode(_pin, OUTPUT);
\n}
\nLED::LED(int pin, uint32_t pauza){ \/\/ klass ekzemplyari
\n_pin=pin;
\n_pauza=pauza;
\n_hisobchi=1;
\npinMode(_pin, OUTPUT);
\n}
\nLED::LED(int pin){ \/\/ klass ekzemplyari
\n_pin=pin;
\n_pauza=1000;
\n_hisobchi=1;
\npinMode(_pin, OUTPUT);
\n}
\nvoid LED::miltilla(){ \/\/ metod
\nif (_hisobchi>0) {
\nfor (int i=0; i<_hisobchi; i++){
\ndigitalWrite(_pin, HIGH);
\ndelay(_pauza);
\ndigitalWrite(_pin, LOW);
\ndelay(_pauza);
\n}
\n}
\n}
\nvoid LED::pauzaUrnat(uint32_t pauza){
\n_pauza=pauza;
\n}
\nvoid LED::hisobchiUrnat(int hisobchi){
\n_hisobchi=hisobchi;
\n}
\nuint32_t LED::pauzaQiymati(){
\nreturn _pauza;
\n}
\nint LED::hisobchiQiymati(){
\nreturn _hisobchi;
\n}<\/p>\n<\/div><\/div>\n

Ushbu biblioteka imkoniyatlarini ko’rsatib beruvchi sketch kodi :<\/p>\n

<\/span>'miltillash' sketchi. 4-versiya<\/div>
\n

#include <YangiBlink2.h><\/p>\n

LED led1(2, 200, 10); \/\/ 1-konstruktor asosidagi led1 obyekti
\nLED led2(3, 500); \/\/ 2-konstruktor asosidagi led2 obyekti
\nLED led3(4); \/\/ 3-konstruktor asosidagi led3 obyekti<\/p>\n

void setup() {
\nSerial.begin(115200);<\/p>\n

led1.miltilla();<\/p>\n

led1.pauzaUrnat(1000);
\nled1.hisobchiUrnat(5);
\nled1.miltilla();<\/p>\n

led2.miltilla();
\nled2.pauzaUrnat(2000);
\nled2.miltilla();
\n}<\/p>\n

void loop() {
\nSerial.println(led1.pauzaQiymati());
\nSerial.println(led1.hisobchiQiymati());<\/p>\n

Serial.println(led2.pauzaQiymati());
\nSerial.println(led2.hisobchiQiymati());<\/p>\n

Serial.println(led3.pauzaQiymati());
\nSerial.println(led3.hisobchiQiymati());<\/p>\n

led3.miltilla();
\n}<\/p>\n<\/div><\/div>\n

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.<\/p>\n

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:<\/p>\n

<\/span>'YangiBlink3.h' sarlavha fayli<\/div>
\n

#pragma once
\n#include “Arduino.h”<\/p>\n

class LED {
\npublic:
\nLED(int pin, uint32_t pauza, int hisobchi); \/\/ konstruktor
\nLED(int pin, uint32_t pauza); \/\/ konstruktor
\nLED(int pin); \/\/ konstruktor<\/p>\n

void miltilla(); \/\/ metodni e’lon qilish
\nvoid pauzaUrnat(uint32_t pauza); \/\/ metodni e’lon qilish
\nvoid hisobchiUrnat(int hisobchi); \/\/ metodni e’lon qilish
\nuint32_t pauzaQiymati(); \/\/ metodni e’lon qilish
\nint hisobchiQiymati(); \/\/ metodni e’lon qilish<\/p>\n

private:
\nint _pin;
\nuint32_t _pauza;
\nint _hisobchi;
\n};<\/p>\n<\/div><\/div>\n

<\/span>'YangiBlink3.cpp' realizatsiya fayli<\/div>
\n

#include “Arduino.h”
\n#include “YangiBlink3.h”<\/p>\n

\/\/ metodlar realizatsiyasi:<\/p>\n

LED::LED(int pin, uint32_t pauza, int hisobchi){ \/\/ klass ekzemplyari
\n_pin=pin;
\n_pauza=pauza;
\n_hisobchi=hisobchi;
\npinMode(_pin, OUTPUT);
\n}
\nLED::LED(int pin, uint32_t pauza){ \/\/ klass ekzemplyari
\n_pin=pin;
\n_pauza=pauza;
\n_hisobchi=1;
\npinMode(_pin, OUTPUT);
\n}
\nLED::LED(int pin){ \/\/ klass ekzemplyari
\n_pin=pin;
\n_pauza=1000;
\n_hisobchi=1;
\npinMode(_pin, OUTPUT);
\n}<\/p>\n

void LED::miltilla(){
\nif (_hisobchi>0) {
\nfor (int i=0; i<_hisobchi; i++){
\ndigitalWrite(_pin, HIGH);
\ndelay(_pauza);
\ndigitalWrite(_pin, LOW);
\ndelay(_pauza);
\n}
\n}
\n}
\nvoid LED::pauzaUrnat(uint32_t pauza){
\n_pauza=pauza;
\n}
\nvoid LED::hisobchiUrnat(int hisobchi){
\n_hisobchi=hisobchi;
\n}
\nuint32_t LED::pauzaQiymati(){
\nreturn _pauza;
\n}
\nint LED::hisobchiQiymati(){
\nreturn _hisobchi;
\n}<\/p>\n<\/div><\/div>\n

 <\/p>\n

4-misol. <\/strong>Xuddi yuqoridagidek, “MATN<\/strong>” 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:<\/p>\n

<\/span>WiFi sozlamalarini EEPROM-xotiraga saqlash va undan o'qish sketchi. Klassni asosiy kodda qo'llash. 1-versiya<\/div>
\n

#include <EEPROM.h>
\nclass MATN {
\npublic:
\nMATN(int EEPROM_hajmi, byte matnUzunligi){
\n_EEPROM_hajmi=EEPROM_hajmi;
\n_matnUzunligi=matnUzunligi;
\nEEPROM.begin(_EEPROM_hajmi);
\n}
\nvoid saqla(int _boshManzil, String _matn){
\nbyte u = _matn.length();
\nif (u>_matnUzunligi) u=_matnUzunligi;
\nif (_matn==””) u=0;
\nEEPROM.put(_boshManzil, u);
\nif (u>0) {
\nfor (int i=0; i<u; i++) {
\nEEPROM.put(_boshManzil+i+1, _matn[i]);
\n}
\n}
\nEEPROM.commit();
\n}
\nString uqi(int _boshManzil){
\nString _matn = “”;
\nint u=EEPROM.read(_boshManzil);
\nSerial.println(u);
\nif (u>0) {
\nfor (int i=0;i<u;i++){
\n_matn += (char)EEPROM.read(_boshManzil+i+1);
\n}
\n}
\nreturn _matn;
\n}<\/p>\n

private:
\nint _EEPROM_hajmi;
\nbyte _matnUzunligi;
\nint _boshManzil;
\nString _matn;
\n};<\/p>\n

MATN matn1(1024, 20);<\/p>\n

void setup() {
\nSerial.begin(115200);
\nmatn1.saqla(0, “Ofis”); \/\/ SSIDni 0-katakdan boshlab saqlash
\nmatn1.saqla(21, “12345678”); \/\/ SSIDni 0-katakdan boshlab saqlash
\nSerial.println();
\ndelay(100);
\nString ssid=matn1.uqi(0); \/\/ SSIDni o’qish
\nSerial.println(“SSID: ” + ssid);
\nString parol=matn1.uqi(21); \/\/ Parolni o’qish
\nSerial.println(“Parol: ” + parol);
\n}
\nvoid loop() {
\n}<\/p>\n<\/div><\/div>\n

Klassni 1 ta fayldan iborat biblioteka fayli ko’chirilgan variant va unga mos sketch:<\/p>\n

<\/span>'TxtEEPROM2.h' sarlavha fayli<\/div>
\n

#pragma once
\n#include “Arduino.h”
\n#include <EEPROM.h>
\nclass MATN {
\npublic:
\nMATN(int EEPROM_hajmi, byte matnUzunligi); \/\/ 1-konstruktor
\nMATN(int EEPROM_hajmi); \/\/ 2-konstruktor
\nvoid saqla(int _boshManzil, String _matn);
\nString uqi(int _boshManzil);<\/p>\n

private:
\nint _EEPROM_hajmi;
\nbyte _matnUzunligi;
\nint _boshManzil;
\nString _matn;
\n};<\/p>\n

MATN::MATN(int EEPROM_hajmi, byte matnUzunligi){
\n_EEPROM_hajmi=EEPROM_hajmi;
\n_matnUzunligi=matnUzunligi;
\nEEPROM.begin(_EEPROM_hajmi);
\n}
\nMATN::MATN(int EEPROM_hajmi){
\n_EEPROM_hajmi=EEPROM_hajmi;
\n_matnUzunligi=20;
\nEEPROM.begin(_EEPROM_hajmi);
\n}<\/p>\n

void MATN::saqla(int _boshManzil, String _matn){
\nbyte u = _matn.length();
\nif (u>_matnUzunligi) u=_matnUzunligi;
\nif (_matn==””) u=0;
\nEEPROM.put(_boshManzil, u);
\nif (u>0) {
\nfor (int i=0; i<u; i++) {
\nEEPROM.put(_boshManzil+i+1, _matn[i]);
\n}
\n}
\nEEPROM.commit();
\n}
\nString MATN::uqi(int _boshManzil){
\nString _matn = “”;
\nint u=EEPROM.read(_boshManzil);
\nSerial.println(u);
\nif (u>0) {
\nfor (int i=0;i<u;i++){
\n_matn += (char)EEPROM.read(_boshManzil+i+1);
\n}
\n}
\nreturn _matn;
\n}<\/p>\n<\/div><\/div>\n

<\/span>WiFi sozlamalarini EEPROM-xotiraga saqlash va undan o'qish sketchi. Klassni 1 ta biblioteka faylida qo'llash. 2-versiya<\/div>
\n

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

void setup() {
\nSerial.begin(115200);
\nmatn1.saqla(0, “Ofis”); \/\/ SSIDni 0-katakdan boshlab saqlash
\nmatn1.saqla(21, “12345678”); \/\/ SSIDni 0-katakdan boshlab saqlash
\nSerial.println();
\ndelay(100);
\nString ssid=matn1.uqi(0); \/\/ SSIDni o’qish
\nSerial.println(“SSID: ” + ssid);
\nString parol=matn1.uqi(21); \/\/ Parolni o’qish
\nSerial.println(“Parol: ” + parol);
\n}<\/p>\n

void loop() {
\n}<\/p>\n<\/div><\/div>\n

Klassni 2 ta standart biblioteka fayllariga ko’chirilgan variant va unga mos sketch:<\/p>\n

<\/span>'TxtEEPROM3.h' sarlavha fayli<\/div>
\n

#pragma once
\n#include “Arduino.h”
\n#include <EEPROM.h>
\nclass MATN {
\npublic:
\nMATN(int EEPROM_hajmi, byte matnUzunligi); \/\/ 1-konstruktor
\nMATN(int EEPROM_hajmi); \/\/ 2-konstruktor
\nvoid saqla(int _boshManzil, String _matn);
\nString uqi(int _boshManzil);<\/p>\n

private:
\nint _EEPROM_hajmi;
\nbyte _matnUzunligi;
\nint _boshManzil;
\nString _matn;
\n};<\/p>\n<\/div><\/div>\n

<\/span>'TxtEEPROM3.cpp' realizatsiya fayli<\/div>
\n

#pragma once
\n#include “Arduino.h”
\n#include “TxtEEPROM3.h”
\n#include <EEPROM.h><\/p>\n

\/\/ Metodlar realizatsiyasi:<\/p>\n

MATN::MATN(int EEPROM_hajmi, byte matnUzunligi){
\n_EEPROM_hajmi=EEPROM_hajmi;
\n_matnUzunligi=matnUzunligi;
\nEEPROM.begin(_EEPROM_hajmi);
\n}
\nMATN::MATN(int EEPROM_hajmi){
\n_EEPROM_hajmi=EEPROM_hajmi;
\n_matnUzunligi=20;
\nEEPROM.begin(_EEPROM_hajmi);
\n}
\nvoid MATN::saqla(int _boshManzil, String _matn){
\nbyte u = _matn.length();
\nif (u>_matnUzunligi) u=_matnUzunligi;
\nif (_matn==””) u=0;
\nEEPROM.put(_boshManzil, u);
\nif (u>0) {
\nfor (int i=0; i<u; i++) {
\nEEPROM.put(_boshManzil+i+1, _matn[i]);
\n}
\n}
\nEEPROM.commit();
\n}
\nString MATN::uqi(int _boshManzil){
\nString _matn = “”;
\nint u=EEPROM.read(_boshManzil);
\nSerial.println(u);
\nif (u>0) {
\nfor (int i=0;i<u;i++){
\n_matn += (char)EEPROM.read(_boshManzil+i+1);
\n}
\n}
\nreturn _matn;
\n}<\/p>\n<\/div><\/div>\n

<\/span>WiFi sozlamalarini EEPROM-xotiraga saqlash va undan o'qish sketchi. Klassni standart biblioteka fayllarida qo'llash. 3-versiya<\/div>
\n

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

void setup() {
\nSerial.begin(115200);
\nmatn1.saqla(0, “Ofis”); \/\/ SSIDni 0-katakdan boshlab saqlash
\nmatn1.saqla(21, “12345678”); \/\/ SSIDni 0-katakdan boshlab saqlash
\nSerial.println();
\ndelay(100);
\nString ssid=matn1.uqi(0); \/\/ SSIDni o’qish
\nSerial.println(“SSID: ” + ssid);
\nString parol=matn1.uqi(21); \/\/ Parolni o’qish
\nSerial.println(“Parol: ” + parol);
\n}<\/p>\n

void loop() {
\n}<\/p>\n<\/div><\/div>\n

4-misolning yuqoridagi barcha variantlarida sketch ishga tushirilganda, dastlab WiFi tarmog’i parametrlari (SSID va paroli) EEPROM-xotiraga MATN<\/strong> klassining\u00a0matn1<\/strong>\u00a0obyekti hamda saqla <\/strong>metodi yordamida saqlanadi. uqi<\/strong>\u00a0metodi yordamida esa, matn xotiradan o’qiladi. Natijalar port monitoriga chiqarib boriladi.<\/p>\n","protected":false},"excerpt":{"rendered":"

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 […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[12],"tags":[],"class_list":["post-4277","post","type-post","status-publish","format-standard","hentry","category-qollanmalar"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/yarat.uz\/index.php?rest_route=\/wp\/v2\/posts\/4277","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/yarat.uz\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/yarat.uz\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/yarat.uz\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/yarat.uz\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=4277"}],"version-history":[{"count":46,"href":"https:\/\/yarat.uz\/index.php?rest_route=\/wp\/v2\/posts\/4277\/revisions"}],"predecessor-version":[{"id":5204,"href":"https:\/\/yarat.uz\/index.php?rest_route=\/wp\/v2\/posts\/4277\/revisions\/5204"}],"wp:attachment":[{"href":"https:\/\/yarat.uz\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=4277"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/yarat.uz\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=4277"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/yarat.uz\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=4277"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}