Quyida Arduino bilan ishlashda qo’llaniladigan deyarli barcha buyruqlar, funksiyalar va operatorlar royxati qisqacha misollar bilan keltirilgan. Ularning aksariyati rus va ingliz tilidagi Internet materiallari asosida tayyorlangan, biroq muallif tomonidan amalda sinab ko’rilgandan keyingina qilingan va ro’yxatga qo’shilgan. Arduino buyruqlari va umuman platforma bilan yaqindan tanishish uchun platformaning ingliz tilidagi rasmiy saytiga tashrif buyurish mumkin. Ushbu buyruqlar ro’yxati bilan rus tilida tanishish uchun esa, alexgyver.ru saytiga tashrif buyurish tavsiya etiladi. Ushbu ro’yxat muallif tomonidan muntazam takomillashtirilishi, misollar bilan to’ldirilishi rejalashtirilgan va hozircha dastlabki variant sifatida tuzildi. Arduino tizimi bilan batafsil tanishish uchun ushbu sahifada keltirilgan ro’yxatdagi adabiyotlardan foydalanish mumkin.
Arduino IDE C++ dasturlash tiliga asoslanganligi sababli, uning aksariyat buyruqlari Arduino IDE da ham qo’llanilishi mumkin. Shuning uchun, C++ dasturlash tili bo’yicha onlayn qo’llanmadan foydalanish ham tavsiya etiladi.
Ushbu ro’yxatdagi ayrim murakkab buyruq, funksiya va operatorlar ko’pchilik boshlovchi arduinochilar tomonidan amaliyotda umuman qo’llanilmasligi ham mumkin. Shunday bo’lsa-da, izlanuvchan arduinochilarga ko’mak bo’lishi mumkinligini hisobga olinib, ma’lumot uchun qo’shimcha ma’lumot olish mumkin bo’lgan manbasiga havolalar bilan birga keltirildi.
Qulaylik uchun ro’yxat spoyler ko’rinishida keltirilgan. Kerakli buyruq haqidagi ma’lumotni ochish uchun spoylerning chap tomonidagi ‘+‘ belgisini tanlash zarur (‘–‘ yopish).
Skechning tuzilishi
Kodning sintaksisi va tuzilishi
/* ushbu kodkompilyatsiya qilinmaydi */
// ushbu kod ham
// kompilyatsiya qilinmaydi
#include <Servo.h> // Servo.h bibliotekasini bog’lab olish
#include “Servo.h” // Servo.h bibliotekasini bog’lab olish
Bunda:
<> belgilari ichiga olinganda faylni kompilyator faqat bibliotekalar papkasidan qidiradi.
“” belgilari ichiga olinganda faylni kompilyator avval skech papkasidan, keyin bibliotekalar papkasidan qidiradi.
#define LED_PIN 3 // mikrokontrollerning svetodiodga bog’langan pini raqami ‘3’ ekanligi belgilab olinmoqda
#define MOTOR_PIN 10 // mikrokontrollerning motorga bog’langan pini raqami ’10’ ekanligi belgilab olinmoqda
Natijada, kompilyatsiyadan keyin barcha MOTOR_PIN va LED_PIN so’zlari tegishli konstantalarga almashtiriladi.
Oddiy o’zgaruvchilardan farqli ravishda, bunday usulda konstantalar uchun mikrokontrollerning tezkor xotirasi qo’llanilmaydi (joy band qilinmaydi). Bundan tashqari, define ko’rsatmasi yordamida makro-funksiya deb ataluvchi funksiyalarni belgilashda ham qo’llaniladi. Masalan, Arduinoning sq (kvadrat) funksiyasi makro-funksiya bo’lib, kompilyatsiya jarayonida ko’paytmaga aylantirib olinadi.
#define TEST 1 // 1 qiymatini TEST sifatida belgilab olamiz
#if (TEST == 1) // “agar TEST 1 ga teng bo’lsa”
#define VALUE 10 // “10 qiymatini VALUE sifatida belgilab olinsin”
#elif (TEST == 0) // “aksincha, agar TEST 0 ga teng bo’lsa, “
#define VALUE 20 //”20 qiymatini VALUE sifatida belgilab olinsin”
#else // “aksincha”
#define VALUE 30 // “30 qiymatini VALUE sifatida belgilab olinsin”
#endif // “shart oxiri”
Misol:
#define DEBUG 1
void setup() {
#if (DEBUG == 1)
Serial.begin(9600);
Serial.println(“Hello!”);
#endif
}
Ma’nosi:
ifdef – “belgilab olindimi?” ifndef – “belgilab olinmadimi?”. Misol:
#define TEST // TEST ni belgilab olamiz
#ifdef TEST // “Agar TEST belgilab olingan bo’lsa”
#define VALUE 10 // “u holda VALUE ni 10 ga tenglansin”
#else // “aksincha” (“ya’ni yuqoridagi #define TEST buyrug’i vaqtincha izohga aylantirilgan yoki o’chirib yuborilgan bo’lsa”)
#define VALUE 20 // “u holda VALUE ni 20 ga tenglansin”
#endif // “shart oxiri”
for (byte r = 0; r < 255; r++){
for (byte g = 255; g > -1; g–){
for (byte b = 0; b < 255; b++){
if (analogRead(0)> 250){ //tsikldan chiqib ketish
goto belgi;
}
// turli kod
}
}
}
belgi: // shu joyga o’tiladi
// kod davomi
if, ?, switch shartli (solishtirish) operatorlari
// Shartdan keyin faqat 1 ta amal bajarilganda {} belgilari shart emas:
if (a > b) c = 10; // “agar a b dan katta bo’lsa, c = 10 bo’lsin”
else c = 20; // “aksincha, с = 20 bo’lsin”.
// solishtirish amali o’rniga mantiqiy o’zgaruvchini qo’llasa ham bo’ladi:
boolean myFlag, myFlag2;
if(myFlag) c = 10; //”Agar myFlag = true bo’lsa c=10″
// murakkab shartlar:
if(!myflag && !myFlag2) c = 10; // “agar ikkala o’zgaruvchi qiymati ham false bo’lsa, c=10”
// 2 ta yoki undan ortiq amallar bajarilganda, {} belgilari ko’rsatilishi shart:
if (myFlag) {
с = 10;
b = c;
} else {
с = 20;
b = a;
}
//yoki, yuqoridagi kodni qisqatrirsak:
if(myFlag){с = 10; b = c;} else {с = 20; b = a;} //ham o’rinli
byte buttonState;
if(buttonState == 1) a = 10; // “agar buttonState=1 bo’lsa a=10”
else if(buttonState == 2) a = 20; // “aksincha, agar buttonState=2 bo’lsa, a=20”
else a = 30; // “aksincha, a=30”
(shart) ? u holda : aksincha
Misol:
(a > b) ? c=10 : c=-20; // “agar a > b bo’lsa, u holda с = 10. Aksincha с = -20”, yoki:
с = (a > b) ? 10 : -20; // “agar a > b bo’lsa, u holda с = 10. Aksincha с = -20”
boolean flag = true;
Serial.println((flag) ? (“bayroq ko’tarildi”) : (“bayroq tushirildi”)); //Ya’ni, agar flag=true bo’lsa, ‘bayroq ko’tarildi’ yozuvi, aksincha ‘bayroq tushirildi’ yozuvi port monitorida ko’rsatiladi
if/else operatori o’rnini bosishi mumkin.
Misol:
switch (val){
case 1: // “agar val = 1 bo’lsa kod bajarilsin”
// kod
break; //shartdan chiqiladi
case 2: // “agar val = 2 bo’lsa kod bajarilsin”
// kod
break; //shartdan chiqiladi
default: // “agar val hech qaysi qiymatga teng bo’lmasa, kod bajarilsin”
// kod
break; //shartdan chiqiladi
} //shartli operator oxiri
// default – qo’llanishi majburiy emas
// break – qo’llanishi majburiy
//yana bir misol:
switch (val){
case 1:
case 2:
case 3:
case 4:
// “agar val = 1, 2, 3 yoki 4 bo’lsa kod bajarilsin”
// kod
break;
case 4:
// “agar val = 5 bo’lsa kod bajarilsin”
// kod
break;
}
for, while, do/while takrorlash operatorlari
for (o’zgaruvchi; shart; o’zgarish qadami)
//Misol:
for(int i = 0; i < 10; i++){ // “i o’zgaruvchisi 0 dan 9 gacha 1 qadam bilan o’sganda…”
a = i; // “a o’zgaruvchisiga i qiymati o’zlashtirilsin”
Serial.println(a); // “port monitoriga a ning qiymati chiqarilsin”
}
// Xuddi if/else operatori kabi faqat 1 ta amal uchun {} shart emas:
for(int i = 0; i < 10; i++)
Serial.println(i);
//Yoki, 1 ta satrga sig’dirish mumkin:
for(int i = 0; i < 10; i++) Serial.println(i);
//Yana bir misol:
for(;;); // to’xtovsiz takrorlanish tsikli. Undan faqat break yoki goto operatorlari yordamida chiqiladi
while(a< b){ // “qachonki a<b bo’lsa, quyidagi kod to’xtovsiz bajarilaversin:”
// kod
}
//Yana bir misol:
while(true){// to’xtovsiz takrorlanish tsikli. Faqat break yoki goto operatorlari yordamida chiqiladi
// kod
}
do { // “quyidagi kod bajarilaversin:”
// kod
} while(a < b); //”qachonki a<b bo’lsa”
//yuqoridagi ‘while’ operatoridan farqi shuki, kod kamida 1 marta bajarilib ulguradi 🙂
Sanash, hisoblash, solishtirish operatorlari (amallari)
- bir xil turdagi o’zgaruvchilarni sanab o’tishda
- massivdagi elementlarni sanab o’tishda
- funksiyaning argumentlarini sanab o’tishda
- amallarni ketma-ket bajarishda
int a, b, c;
int raqamlar[4] = {1,3,5,7};
void yigindi(int a, int b, int c) {// kod };
//4-holatga misol:
// a va b ga qiymat o’zlashtirish:
int a = 5, b = 10;
// “dastlab b = 3 bo’lsin, keyin b ga 1 qo’shilsin, oxirida a ga o’zlashtirilsin:”
a = (b = 3, ++b);// natija: a = 4
// “‘i’ va ‘j’ musbat o’zgaruvchilari e’lon qilinsin, ularning qiymatlari soni 9 ta dan oshmasin, ‘i’ o’zgaruvchisi o’zgarish qadami 1, ‘j’ o’zgaruvchisi o’zgarish qadami 2”:
for(byte i = 0, j = 0; i < 10; i++, j += 2){
// ‘i’ 0 dan 9 gacha o’zgaradi
// ‘j’ 0 dan 18 gacha o’zgaradi
//kod
}
+ – qo’shish // c=a+b;
– – ayirish // c=a-b;
* – ko’paytirish // c=a*b;
/ – bo’lish // c=a/b;
% – bo’linma qoldig’i; // int c=a%amp;b;
< – kichik // if (a<=b) c=b-a;
>= – katta yoki teng // if (a>=b) c=a-b;
<= – kichik yoki teng // if (a<=b) c=b-a;
== – tenglik // if (a==b) c=a+b; else c=a*b;
!= – teng emaslik // if (a!=b) c=a+b; (a=!b dan farqlanadi!)
! (not) – mantiqiy ‘EMAS’ (‘НЕ’), ya’ni inkor qilish operatori
// Misol: agar bool a=false, b=false; a=!b bo’lsa, natija: a=true bo’ladi. Chunki, a o’zgaruvchisiga b ning qarama-qarshi qiymati o’zlashtirilmoqda. (Bu yerda ‘a=!b’ yozuvini “a b ga teng emas” tarzida emas, “a b ning qarama-qarshi qiymatiga teng” tarzida qabul qilish kerak!)
&& (and) – mantiqiy ‘VA’ operatori // if (a>b && b<=c) d=a+c-b;
|| (or) – mantiqiy ‘YOKI’ operatori // if (a>b || c<b) d=a-b;
// ‘a++’ (pre-inkrement) va ‘a=a+1’ amallari natijasi bir xil; ‘++b’ (post-inkrement) va ‘b=b+1’ natijasi bir xil; biroq pre-inkrement va post-inkrement natijasini boshqa o’zgaruvchiga o’zlashtirilganda bir-biridan farqli natija olinadi. Chunki pre-inkrementda qiymat inkrement bajarilishidan oldingi qiymat, post-inkrementda esa, inkrement bajarib bo’lingandagi qiymat olinadi. Misol:
int a = 0; int b = 0;
a++; //a ning qiymati 1 ga teng
b=a++; //b ning qiymati 0 ga teng (pre-inkrement qiymati)
b=++a; //b ning qiymati 1 ga teng (post-inkrement qiymati)
— – dekrement (1 ta qiymatga kamaytirish) // ‘a–‘ va ‘a=a-1’ natijasi bir xil
+= – qo’shma yig’indi // ‘a += 10’ va ‘a=a + 10’ natijasi bir xil
-= – qo’shma ayirma // ‘a -= 10’ va ‘a = a – 10’ natijasi bir xil
*= – qo’shma ko’paytma // ‘a *= 10’ va ‘a = a * 10’ natijasi bir xil
/= – qo’shma ko’paytma // ‘a /= 10’ va ‘a = a / 10’ natijasi bir xil
%= – bo’linmaning qoldig’ini qo’shish // ‘a %= 10’ va ‘a = a + a % 10’ natijasi bir xil
&= – qo’shma ‘bitli VA’ // ‘a &= b’ yozuvi ‘a = a & b’ bilan bir xil (8 bit = 1 bayt).
// ‘bitli VA’ (битовое И) mazmuni va vazifasi keyingi qismda keltiriladi
^= – qo’shma ‘bitli chiqarib yuboruvchi YOKI’ // ‘a ^= b’ yozuvi ‘a = a ^ b’ bilan bir xil
// ‘bitli chiqarib yuboruvchi YOKI’ (битовое исключающее ИЛИ) mazmuni va vazifasi keyingi qismda keltirilgan
|= – qo’shma ‘bitli YOKI’ // ‘a |= b’ yozuvi ‘a = a | b’ bilan bir xil
// ‘bitli YOKI’ (исключающее ИЛИ) mazmuni va vazifasi keyingi qismda keltirilgan
<< – bitli ‘chapga surish’ (битовый сдвиг влево)
>> – bitli ‘o’ngga surish’ (битовый сдвиг вправо)
^ (XOR) – bitli ‘chiqarib yuboruvchi YOKI’ (битовое исключающее ИЛИ)
| – bitli ‘YOKI’ (битовое ИЛИ)
~ – bitli ‘EMAS’ (битовое НЕ)
Misollar:
…
& – qiymatning xotiradagi manzili (1-bloki manzili)
* – ko’rsatilgan manzildagi qiymatni bildiradi
–> – strukturaga va klassga ko’rsatkichlar uchun, a’zolarga va metodlarga bilvosita murojaat qilish operatori (amali). Konstruksiyaning ko’rsatkich orqali qisqartirilgan yozuvi hisoblanadi: a->b yozuvi (*a).b yozuvi bilan bir xil.
Ko’rsatkichni hosil qilish formati quyidagicha:
qiymat_turi* ko’rsatkich_nomi (yoki qiymat_turi * ko’rsatkich_nomi, qiymat_turi *ko’rsatkich_nomi, ya’ni, bu yerdagi * belgisining joylashuvi ahamiyatga emas).
Qiymat turlari bilan ishlash
O’zgaruvchi – berilganlarni (raqamlarni) saqlash uchun ajratilgan katak. O’zgaruvchilar turli o’lchamdagi kataklarlarga ega bo’lishi mumkin.
| Nomlanishi | Boshqacha nomi |
O’lchami | Qiymat oralig’i | Xususiyati |
|
boolean
|
bool
|
1 bayt | 0 yoki 1, LOW yoki HIGH, false yoki true | Mantiqiy o’zgaruvchi. bool Arduinoda ham 1 bayt joy talab qiladi (1 bit emas) |
|
char
|
– | 1 bayt | -128… 127 | ASCII belgilar jadvalidagi belgining tartib raqamini saqlaydi |
| – |
int8_t
|
1 bayt | -128… 127 | Butun sonlar |
|
byte
|
uint8_t
|
1 bayt | 0… 255 | Butun sonlar |
|
int
|
int16_t, short
|
2 bayt | -32 768… 32 767 | Butun sonlar |
|
unsigned int
|
uint16_t, word
|
2 bayt | 0… 65 535 | Butun sonlar |
|
long
|
int32_t
|
4 bayt | -2 147 483 648… 2 147 483 647 | Butun sonlar |
|
unsigned long
|
uint32_t
|
4 bayt | 0… 4 294 967 295 | Butun sonlar |
|
float
|
–
|
4 bayt | -3.4E+38 3.4E+38 | Kasr sonlar. Aniqligi: 6-7 ta belgigacha, ya’ni 100% emas! |
|
double
|
–
|
4 bayt | -1.7E+308.. 1.7E+308 | AVR uchun float bilan bir xil. Aslida 8 baytga teng. |
|
–
|
int64_t
|
8 bayt | -(2^64)/2… (2^64)/2-1 | Butun sonlar |
|
–
|
uint64_t
|
8 bayt | 2^64-1 | Butun sonlar |
Qiymatlarning yana ayrim maxsus turlari mavjud:
-
wchar_t
– 16 bitli belgi
-
char16_t
– 2 baytli char
-
char32_t
– 4 baytli char
Qiymat turini qayta belgilash //Eski turni boshqacha nom bilan e’lon qilish:
typedef <tur> <nom>; – <nom> nomi bilan <tur> qiymat turini yaratish. Misol:
Keyinchalik bu tur bilan o’zgaruvchilarni e’lon qilish mumkin:
<yorliq> <struktura nomi>; // 1 ta strukturani e’lon qilish
<yorliq> <1-struktura nomi>, <2-struktura nomi>; // <yorliq> turli 2 ta strukturani e’lon qilish
<yorliq> <struktura nomi>[3]; // <yorliq> turli strukturalar massivini e’lon qilish
Shuningdek, strukturani yorliq yaratmasdan ham e’lon qilish mumkin.
- Struktura a’zosiga murojaat qilish quyidagicha amalga oshiriladi (klass kabi): <struktura nomi>.<o’zgaruvchi nomi> qiymatini o’qish va o’zgartirish imkonini beradi.
- agar 2 ta struktura bir xil tuzilgan bo’lsa (1 ta yorliq asosida e’lon qilingan bo’lsa), 1 ta strukturani boshqasiga o’zlashtirish ham mumkin. Barcha o’zgaruvchilar mos ravishda o’z o’rinlariga yoziladi.
- Strukturani o’zlashtirishning yana bir qulay usuli: <struktura nomi>=(<yorliq>){<1-o’zgaruvchi qiymati>,<2-o’zgaruvchi qiymati>,<3-o’zgaruvchi qiymati>}
//Misollar:
// 1-qadam: ‘yorliq1‘ turli struktura yorlig’i yaratiladi va uning o’zgaruvchilari e’lon qilinadi:
void setup() {
Sanoqlar (enum – enumeration) – nomlangan va bir biridan 1 ta qiymatga farq qiladigan konstantalarning top’lami hisoblanadi. Masalan, #define yordamida belgilanadigan TOVUSH_REJIMI, EKRAN_REJIMI, YORUGLIK_DARAJASI kabi konstantalar qiymati mos ravishda 1, 2 va 3 bo’lsa, ularni umumiy ‘sozlamalar’ yorlig’i bilan ‘int’ turida sanoq sifatida e’lon qilish mumkin:
enum sozlamalar {TOVUSH_REJIMI, EKRAN_REJIMI, YORUGLIK_DARAJASI};//Endi yorliqdan foydalanib sanoqning o’zini e’lon qilish mumkin:
sozlamalar sozlama; // ‘sozlamalar’ yorliqli, ‘sozlama’ nomli sanoq hosil qilindi.
//Sanoqni xuddi, struktrular kabi soddalashtirilgan holda ham e’lon qilish mumkin (ya’ni, bunda yorliq qo’llanilmaydi):
enum {TOVUSH_REJIMI, EKRAN_REJIMI, YORUGLIK_DARAJASI} sozlama;
//Sanoqlarni raqam sifatida yoki nomiga ko’ra o’zaro solishtirish, o’zlashtirish mumkin.
//Misollar:
enum {TOVUSH_REJIMI, EKRAN_REJIMI, YORUGLIK_DARAJASI} sozlama;
void setup() {
Serial.begin(9600);
sozlama = TOVUSH_REJIMI; //sanoqqa dastlabki qiymat o’zlashtirildi;
//Sanoqning qiymatlarini o’zgartirish zarurati tug’ilganda faqat 1-tartibdagi konstanta qiymatini o’zgartirish yetarli, qolgan konstantalar qiymati ketma-ket ravishda o’zgarib qoladi:
enum {TOVUSH_REJIMI=0, EKRAN_REJIMI, YORUGLIK_DARAJASI} sozlama;
//0 dan 2 gacha o’zgarib qoladi
- Klass
- Obyekt
- Xususiyatlar va metodlar
Klass quyidagicha e’lon qilinadi:
Klasslar haqida batafsil bu yerda tanishing.
Massivni e’lon qilish uchun uning nomidan keyin “[ ]” – kvadrat qavslarni ko’rsatish orqali amalga oshiriladi. Qiymatlarni bir yo’la o’zlashtirish, yoki keyinchalik kod davomida o’zlashtirish ham mumkin. Qiymat turi ixtiyoriy bo’lishi mumkin. Qiymatlarni “{ }” katta qavs ichida sanab o’tiladi. Massiv haqida batafsil.
//yoki
float Sens[5] = {0.2, 0.4, -8.5}; // oxirgi 2 ta qiymat 0 ga teng yoki keyinroq e’lon qilinadi
String – matnlar va matnli o’zgaruvchilar bilan ishlash uchun vosita. Matnli o’zgaruvchini turli usullar bilan e’lon qilish mumkin:
Matnli o’zgaruvchilar haqida batafsil.
Matnli o’zgaruvchilarni solishtirish, birlashtirish yoki ayirish mumkin:
|
charAt()
|
|
myString.charAt(index);
myString matnining index tartibli elementini ajratish. myString[index] bilan bir xil; |
|
setCharAt()
|
|
myString.setCharAt(index, val); myString matnining index tartibiga val qiymati o’rnatiladi. myString[index] = val bilan bir xil; |
|
compareTo()
|
|
myString.compareTo(myString2); // bir matn boshqasidan oldin yoki keyin kelishini aniqlash
|
|
concat()
|
|
myString.concat(value); // Argumentdagi sonli qiymatni matnga birlashtirish. Bajarish muvaffaqiyatli bo’lsa “true”, aksincha “false” qiymati qaytariladi. myString + value bilan bir xil. |
|
endsWith()
|
|
myString.endsWith(myString2); // bir matn boshqa matnning oxirida mavjudligini aniqlash. Bajarish muvaffaqiyatli bo’lsa “true”, aksincha “false” qiymati qaytariladi. |
|
startsWith()
|
|
myString.startsWith(myString2); // bir matn boshqa matnning boshida mavjudligini aniqlash. Bajarish muvaffaqiyatli bo’lsa “true”, aksincha “false” qiymati qaytariladi. |
|
equals()
|
|
myString.equals(myString2); // bir matn boshqa matn bilan bir xilligini aniqlash. Bajarish muvaffaqiyatli bo’lsa “true”, aksincha “false” qiymati qaytariladi. Harflar registri farqlanadi. |
|
equalsIgnoreCase()
|
|
myString.equalsIgnoreCase(myString2); // bir matn boshqa matn bilan bir xilligini aniqlash. Bajarish muvaffaqiyatli bo’lsa “true”, aksincha “false” qiymati qaytariladi. Harflar registri farqlanmayadi. |
|
indexOf()
|
|
myString.indexOf(val); // qiymatga ko’ra uning matndagi indeksini, chapdan o’ngga qarab izlash. Har ikki holda ham Faqat birinchi topilgan indeks qaytariladi. val qiymati turi char yoki String bo’lishi mumkin. Agar matnda val topilmasa, -1 qiymati qaytariladi. |
|
lastIndexOf()
|
|
myString.lastIndexOf(val); // qiymatga ko’ra uning matndagi indeksini, o’ngdan chapga qarab izlash. Har ikki holda ham Faqat birinchi topilgan indeks qaytariladi. val qiymati turi char yoki String bo’lishi mumkin. Agar matnda val topilmasa, -1 qiymati qaytariladi. |
|
length()
|
|
myString.length(); // Matndagi belgilar sonini qaytarish |
|
remove()
|
|
myString.remove(indeks); // ko’rsatilgan indeksdan keyingi barcha belgilarni o’chirish |
|
replace()
|
|
myString.replace(substring1, substring2); // Matnda uchragan bir belgilar ketma-ketligini boshqasiga almashtirish. // “birinchi” so’zini “ikkinchi” so’ziga almashtiramiz:
myString.replace(“birinchi”, “ikkinchi”); // natija: “ikkinchi matn”
|
|
reserve()
|
|
myString.reserve(size); // ushbu matnli o’zgaruvchi uchun tezkor xotiradan joy ajratib qo’yish |
|
c_str()
|
|
myString.c_str(); // matnni “c” formatiga (null-terminated string) o’tkazish va hosil bo’lgan matnga ko’rsatkichni qaytarish (batafsil). |
|
trim()
|
|
myString.trim(); // Matn boshi va oxiridagi probellarni o’chirish |
|
substring()
|
|
myString.substring(boshi); // ko’rsatilgan pozitsiyadan boshlab matn ichida mavjud bo’lgan belgilar ketma-ketligining boshlang’ich indeksini ko’rsatish. Topilmasa, -1 qiymati qaytariladi. String myString = “bu birinchi matn”;
String birinchi = myString.substring(3, 12); // natija: “birinchi”
|
|
toCharArray()
|
|
myString.toCharArray(buf, len); // matnning belgilarini char turli buf massiviga, len uzunligigacha o’zlashtirish |
|
getBytes()
|
|
myString.getBytes(buf, len); // matnning belgilarini char turli buf massiviga, len uzunligigacha nusxalash (len (qiymat turi unsigned int gacha bo’lishi mumkin) |
|
toFloat()
|
|
myString.toFloat(); // matn qiymatini float turiga o’tkazish |
|
toDouble()
|
|
myString.toDouble(); // matn qiymatini double turiga o’tkazish |
|
toInt()
|
|
myString.toInt(); // matn qiymatini int turiga o’tkazish String myString = “10500”;
int val = myString.toInt(); // natija: val = 10500
|
|
toLowerCase()
|
|
myString.toLowerCase(); // matnning belgilarini quyi registrga o’tkazish |
|
toUpperCase()
|
|
myString.toUpperCase(); // matnning belgilarini yuqori registrga o’tkazish |
-
const
– konstanta spetsifikatori, bunday o’zgaruvchiga faqat 1 marta qiymat o’zlashtiriladi va uning qiymatini o’zgartirib bo’lmaydi (aksincha xatolik yuz beradi).
const int val = 10; // val nomi bilan int qiymatli konstantani e’lon qilish va qiymat o’zlashtirish.
-
static
– faqat funksiyaning birinchi marta chaqirilishida e’lon qilinadigan va qiymati faqat shu funksiya doirasida qo’llaniladigan hamda qayta o’zlashtiriladigan o’zgaruvchi spetsifikatori. Lokal o’zgaruvchidan farqi – funksiyaning qayta chaqirilganda qayta e’lon qilinmaydi, lekin oldingi chaqirilishida o’zlashtirilgan qiymati saqlanib qolaveradi (lokal o’zgaruvchida funksiya har safar chqirilganda dastlabki qiymat qayta o’zlashtiriladi). Global o’zgaruvchiga o’xshashligi – funksiya har safar chaqirilganda oxirgi qiymati qo’llaniladi, farqi esa – faqat bitta funksiya doirasida ishlatilishi. Qisqacha aytganda, lokal doirada qo’llaniladigan global o’zgaruvchi!
-
volatile
– kompilyatorga o’zgaruvchini optimallashtirish kerak emasligini, uning qiymati tashqi ta’sir (uzilish, “interrupt”) natijasida o’zgarishi mumkinligini eslatuvchi spetsifikator. Bunday spetsifikator o’z qiymatini faqat uzilish davrida o’zgartiradigan o’zgaruvchilarga qo’llanilishi kerak. Batafsil.
-
extern
– kompilyatorga ushbu o’zgaruvchi boshqa faylda (bibliotekada) e’lon qilinganligi va faqat uning qiymatidan foydalanishimiz kerakligini, shunday nom bilan dasturning faol faylida boshqa o’zgaruvchi e’lon qilinmasligi kerakligini eslatuvchi spetsifikator. Bu spetsifikator boshqa fayllarda (bibliotekalarda) e’lon qilingan o’zgaruvchilar bilan ishlash uchun qo’llaniladi!
Bir qator turdagi o’zgaruvchilarning qiymat turi boshqa turga aylantirilishi mumkin. Buning uchun uni qayta e’lon qilish shart emas, shunchaki yangi qiymat turini o’zgaruvchi nomidan oldin qavs ichida ko’rsatish yetarli: (qiymat_turi)o’zgaruvchi
Natija shu amaj jarayonida yangi qiymat turida ifodalanadi, lekin o’zgaruvchining turi o’zgarmaydi:
Xuddi shunday usulda oddiy o’zgaruvchilar, ko’rsatkichlar va boshqa qiymat turlarini ham vaqtincha boshqa turda ifodalash mumkin.
Bitta quymat turidan boshqa turga o’tkazishda yana quyidagi funksilardan ham foydalanish mumkin:
-
toInt() // joriy qiymat turini vaqtincha int turiga o’tkazish
-
toFloat() // joriy qiymat turini vaqtincha float turiga o’tkazish
-
toCharArray() // joriy qiymat turini vaqtincha char belgilar massivi ko’rinishiga o’tkazish
Quyidagi barcha funksiyalar argument sifatida belgi (char turidagi)ni qabul qiladi, tahlil qiladi va vazifasidan kelib chiqib true yoki false qiymatini qaytaradi.
-
isAlpha(shuBelgi) // agar shuBelgi – harf bo’lsa, true qaytariladi
-
isAlphaNumeric(shuBelgi) // agar shuBelgi – harf yoki raqam bo’lsa, true qaytariladi
-
isAscii(shuBelgi) // agar shuBelgi – ASCII jadvaliga kiruvchi belgi bo’lsa, true qaytariladi
-
isControl(shuBelgi) // agar shuBelgi – nazorat belgisi bo’lsa, true qaytariladi
-
isDigit(shuBelgi) // agar shuBelgi – raqam bo’lsa, true qaytariladi
-
isGraph(shuBelgi) // agar shuBelgi – bosma belgi bo’lsa (probeldan tashqari), true qaytariladi
-
isPrintable(shuBelgi) // agar shuBelgi – bosma belgi bo’lsa (probel ham), true qaytariladi
-
isHexadecimalDigit(shuBelgi) // agar shuBelgi – 16 tizimidagi belgi bo’lsa (0…9, A…F), true qaytariladi
-
isPunct(shuBelgi) // agar shuBelgi – tinish belgisi bo’lsa, true qaytariladi
-
isLowerCase(shuBelgi) // agar shuBelgi – quyi registrdagi (kichik) harf bo’lsa, true qaytariladi
-
isUpperCase(shuBelgi) // agar shuBelgi – yuqori registrdagi (katta) harf bo’lsa, true qaytariladi
-
isSpace(shuBelgi) // agar shuBelgi – probel bo’lsa, true qaytariladi
-
isWhitespace(shuBelgi) // agar shuBelgi – formatlangan probel (‘\f’ – formatlangan, ‘\n’ – yangi qator, ‘\r’ – qator oxiri, ‘\t’ – gorizontal tabulyatsiya, ‘\v’ – vertikal tabulyatsiya) bo’lsa, true qaytariladi
Sonlar bilan ishlash
Arduino turli sanoq tizimlaridagi butun sonlar bilan ishlashi mumkin:
| Bazis | Prefiks | Misol | Xususiyatlari |
| 2 (ikkilik) | B yoki 0b (nol b) | B1101001 | 0 va 1 raqamlari |
| 8 (sakkizlik) | 0 (nol) | 0175 | 0 – 7 raqamlari |
| 10 (o’nlik) | – | 100500 | 0 – 9 raqamlari |
| 16 (o’n oltilik) | 0x (0 iks) | 0xFF21A | 0-9 raqamlari, A-F harflari |
Diqqat!
Sukunat bo’yicha arifmetik hisoblashlar uchun long (4 bayt) katagi qo’llaniladi, lekin ko’paytirish va bo’lishda int (2 bayt) katagi qo’llaniladi, bu kutilmagan natijalarga olib kelishi mumkin. Masalan, ko’paytma qiymati 32768 dan ortib ketsa, natija notog’ri hisoblanadi.
Shuning uchun bunday xatoliklarning oldini olish uchun mos keladigan qiymat turini qavs ichida ko’rsatish mumkin: (long)38*1000 kabi.
Suningdek, modifikatorlardan ham foydalanish mumkin:
- u yoki U – unsigned int (0 … 65 535) formatiga o’tkazish. Masalan: 36000u
- l yoki L – long (-2 147 483 648 … 2 147 483 647) formatiga o’tkazish. Masalan: 325646L
- ul yoki UL – unsigned long (от 0 до 4 294 967 295) formatiga o’tkazish. Masalan: 86400000ul
Misollar:
Arduino float (kasr son) qiymat turidagi hisoblashlarga ko’proq vaqt sarflaydi (u Arduino uchun oldindan ma’lum ichki qiymat turi emas).
| Yozuv turi |
Misol | Natija |
| O’nli kasr | 20.5 | 20.5 |
| Ilmiy | 2.34E5 | 2.34*10^5 yoki 234000 |
| Injenerlik | 67e-12 | 67*10^-12 yoki 0.000000000067 |
Bo’lish amalida float turi bilan ishlashda ifodada kasr son qo’llanilmagan taqdirda ham, natija kasr son bo’lishi mumkinligini hisobga olib, ifodadan oldin float yozuvini qo’llash zarur. Aksincha, natija noto’g’ri bo’ladi:
int turiga kasr son o’zlashtirilgan taqdirda, kasr qismi tushirib qoldiriladi. Yaxlitlash uchun alohida ifoda orqali bajarilishi kerak:
Arduinodagi aksariyat matematik funksiyalar math.h bibliotekasi orqali C++ tilidan olinadi. Qolgan funksiyalar esa, makro funksiyalar hisoblanadi.
| Funksiya | Izoh |
|
cos (x)
|
kosinus (radian) |
|
sin (x)
|
sinus (radian) |
|
tan (x)
|
tangens (radian) |
|
fabs (x)
|
float sonlar uchun modul |
|
fmod (x, y)
|
float uchun x ni y ga bo’lishdagi qoldiq |
|
modf (x, *iptr)
|
kasr qismi qaytariladi, butun qismida iptr manzilida saqlanadi (misol) |
|
modff (x, *iptr)
|
kasr qismi qaytariladi, butun qismida iptr manzilida saqlanadi, float uchun. |
|
sqrt (x)
|
Kvadrat ildiz |
|
sqrtf (x)
|
float sonlar uchun kvadrat ildiz |
|
cbrt (x)
|
Kub ildiz |
|
hypot (x, y)
|
Gipotenuza ((x*x + y*y) ning kvadrat ildizi) |
|
square (x)
|
Kvadrat ( x*x ) |
|
floor (x)
|
Butun qismigacha yaxlitlash quyiga |
|
ceil (x)
|
Butun qismigacha yaxlitlash yuqoriga |
|
exp (x)
|
Eksponenta (e^x) |
|
cosh (x)
|
Giperbolik kosinus (radian) |
|
sinh (x)
|
Giperbolik sinus (radian) |
|
tanh (x)
|
Giperbolik tangens (radian) |
|
acos (x)
|
Arkkosinus (radian) |
|
asin (x)
|
Arksinus (radian) |
|
atan (x)
|
Arktangens (radian) |
|
log (x)
|
Natural logarifm х ( ln(x) ) |
|
log10 (x)
|
O’nli logarifm x ( log_10 x) |
|
pow (x, y)
|
Daraja ( x^y ) |
|
isnan (x)
|
nan ga tekshiruv (1 – ha, 0 – yo’q). nan – “raqam emas” (“not a number”) |
|
isinf (x)
|
Agar x +cheksizlik bo’lsa 1, aksincha 0 qaytariladi |
|
isfinite (x)
|
Argument oxirgi qiymatga ega bo’lsagina qiymat qaytariladi. |
|
copysign (x, y)
|
x qiymatni y ishora bilan qaytaradi (ishora = + yoki -) |
|
signbit (x)
|
Argument manfiy son bo’lsa, qiymat qaytariladi |
|
fdim (x, y)
|
x qiymati y dan katta bo’lsa, ayirmani, aksincha 0 ni qaytaradi |
|
fma (x, y, z)
|
x*y + z natijasini qaytaradi |
|
fmax (x, y)
|
sonlarning kattasini qaytaradi |
|
fmin (x, y)
|
sonlarning kichigini qaytaradi |
|
trunc (x)
|
Kasr sonning butun qismini qaytaradi |
|
round (x)
|
Yaxlitlash |
|
lround (x)
|
katta sonlar uchun yaxlitlash |
|
lrint (x)
|
Oxirgi yaxlitlash rejimi va yo’nalishidan kelib chiqib, kasr son bo’lgan argumentning eng yaqin butun qismini qaytaradi |
| Konstanta | Qiymati |
|
UINT8_MAX
|
255 |
|
INT8_MAX
|
127 |
|
UINT16_MAX
|
65535 |
|
INT16_MAX
|
32767 |
|
UINT32_MAX
|
4294967295 |
|
INT32_MAX
|
2147483647 |
| Funksiya | Qiymati |
|
min(a, b)
|
Argumentlarning kichigi qaytariladi |
|
max(a, b)
|
Argumentlarning kattasi qaytariladi |
|
abs(x)
|
Son moduli |
|
constrain(val, low, high)
|
val o’zgaruvchining qiymat qabul qilish oralig’ini cheklaydi |
|
map(val, min, max, outMin, outMax)
|
val o’zgaruvchining o’zgarish oralig’ini (min dan max gacha) oraliqdan yangi (outMin dan outMax gacha) oraliqqa o’zgartiradi. val = map(foiz, 0, 1023, 0, 100) – foiz o’zgaruvchisining qiymat qabul qilish oralig’ini 0…1023 oralig’idan 0…100 oralig’iga o’zgartiradi. Faqat butun sonlarni qabul qiladi! |
|
round(x)
|
Yaxlitlash |
|
radians(deg)
|
Gradusni radianga o’tkazish |
|
degrees(rad)
|
Radianni gradusga o’tkazish |
|
sq(x)
|
Kvadratni hisoblash |
| Konstanta | Qiymati | Izohlar |
|
INT8_MAX
|
127 | char, int8_t uchun maksimal qiymat |
|
UINT8_MAX
|
255 | byte, uint8_t uchun maksimal qiymat |
|
INT16_MAX
|
32767 | int, int16_t uchun maksimal qiymat |
|
UINT16_MAX
|
65535 | unsigned int, uint16_t uchun maksimal qiymat |
|
INT32_MAX
|
2147483647 | long, int32_t uchun maksimal qiymat |
|
UINT32_MAX
|
4294967295 | unsigned long, uint32_t uchun maksimal qiymat |
|
M_E
|
2.718281828 | e (Eyler) soni |
|
M_LOG2E
|
1.442695041 | log_2 e |
|
M_LOG10E
|
0.434294482 | log_10 e |
|
M_LN2
|
0.693147181 | log_e 2 |
|
M_LN10
|
2.302585093 | log_e 10 |
|
M_PI
|
3.141592654 | pi |
|
M_PI_2
|
1.570796327 | pi/2 |
|
M_PI_4
|
0.785398163 | pi/4 |
|
M_1_PI
|
0.318309886 | 1/pi |
|
M_2_PI
|
0.636619772 | 2/pi |
|
M_2_SQRTPI
|
1.128379167 | 2/kvadrat_ildiz(pi) |
|
M_SQRT2
|
1.414213562 | kvadrat_ildiz(2) |
|
M_SQRT1_2
|
0.707106781 | 1/kvadrat_ildiz(2) |
|
NAN
|
__builtin_nan(“”) | nan (raqam emas) |
|
INFINITY
|
__builtin_inf() | cheksizlik |
|
PI
|
3.141592654 | Pi |
|
HALF_PI
|
1.570796326 | Pi/2 |
|
TWO_PI
|
6.283185307 | 2*Pi |
|
EULER
|
2.718281828 | е (Eyler) soni |
|
DEG_TO_RAD
|
0.01745329 | Gradusdan radianga o’tkazish konstantasi |
|
RAD_TO_DEG
|
57.2957786 | Radiandan gradusga o’tkazish konstantasi |
-
random(max) // 0 … max-1 oralig’idagi tasodifiy sonni qaytaradi
-
random(min, max) // min … max-1 oralig’idagi tasodifiy sonni qaytaradi
-
randomSeed(value) // generatorga yangi boshlang’ich nuqtani belgilash. Masalan, dastur ishga tushganda (setup() funksiyasida) analog kirish nuqtasi uchun 0…1024 oralig’idagi tasodifiy son yuboriladi.
Kiritish/chiqarish
|
pinMode(pin, mode)
|
|
pin pinida mode ishchi rejiminini o'rnatiladi (ATmega 328: D0-D13, A0-A5):
Pinlarning ishchi rejimlari haqida alohida darsda qisqacha ma'lumotlar keltirilgan. |
|
digitalRead(pin)
|
|
Raqamli pin holatini o'qish va qaytarish:
|
|
digitalWrite(pin, value)
|
|
Raqamli pinga signal yuborish:
|
|
analogWrite(pin, value)
|
|
Pinda PWM signal generatorini ishga tushirish va value argumenti qiymatini yuborish. Standart 8 bitli rejimda bu qiymat 0...255 oralig'ida bo'ladi. PWM signalni faqat maxsus raqamli pinlarda hosil qilish mumkin xolos. PWM pinlar:
|
|
analogRead(pin)
|
|
Analog pin signalini o’qish (kuchlanishini o’lchash) va raqamlashtirilgan holda qaytarish. Ko’plab platalarda ADC (analog-raqamli konverter) 10 bit razryadga ega, shuning uchun 0…5V oralig’idagi kuchlanish raqamlashgan holda 0…1023 (0…2^10) oralig’ida qaytariladi. |
|
analogReference(mode)
|
|
Analog-raqamli konverterning ishchi rejimini o’rnatadi:
Bu rejimlar o’rnatilishidan maqsad, pindagi kuchlanish qiymatini o’lchashda raqamlashgan signalning maksimal qiymati (1023) sifatida etalon kuchlanish qabul qilinadi va kuchlanishni o’lchash aniqligi ortadi. |
|
attachInterrupt(pin, ISR, mode)
|
||||||||||||||||||||||||||||
|
pin raqamli pinda apparatli uzilish (interrupt)ni faollashtirish, shu vaqtda bajariladigan kodni saqlovchi ISR funksiyasini ishga tushirish va mode uzilish rejimini o’rnatish. Apparatli uzilish – ma’lum usulda mikroprotsessorni boshqa dasturni bajarish uchun yo’naltirish, shundan keyin yana oldingi dasturni bajarishni davom ettirish uchun qaytarish jarayoni. Apparatli uzilish quyidagi rejimlarda (vaziyatlarda) faollashtirilishi mumkin:
Apparatli uzulishlar faqat ayrim pinlarda amalga oshirilishi mumkin:
|
||||||||||||||||||||||||||||
|
digitalPinToInterrupt(pin)
|
||||||||||||||||||||||||||||
|
Tanlangan pinga ko’ra apparatli uzilish tartibini qaytarish. Shu yo’l bilan apparatli uzilishni quyidagicha faollashtirish mumkin:
attachInterrupt(digitalPinToInterrupt(pin), ISR, mode)
|
||||||||||||||||||||||||||||
|
detachInterrupt(pin)
|
||||||||||||||||||||||||||||
|
pin pinida apparatli uzulishni bekor qilish
|
||||||||||||||||||||||||||||
|
interrupts()
|
||||||||||||||||||||||||||||
|
Barcha apparatli uzilishlarga ruxsat berish (sei() funksiyasiga makros)
|
||||||||||||||||||||||||||||
|
noInterrupts()
|
||||||||||||||||||||||||||||
|
Barcha apparatli uzilishlarni bekor qilish (cli() funksiyasiga makros)
|
|
tone(pin, frequency), tone(pin, frequency, duration)
|
|
pin nomli pinda frequency chastotali tovushni hosil qilish (generatsiyalash).
duration – generatsiya davomiyligi. Generatsiyani bir vaqtda faqat bitta pinda amalga oshirish mumkin. Boshqa pinda amalga oshirish uchun oldin oldingi pinda generatsiyani bekor qilish kerak (noTone(pin) funksiyasi yordamida). tone() funksiyasi Timer 2 tizimli taymerini ishlatadi.
|
|
noTone(pin)
|
|
pin pinida tovush generatsiyasini bekor qilish.
|
|
pulseIn(pin, value), pulseIn(pin, value, timeout)
|
|
pin pinidagi value qiymatli (HIGH yoki LOW) impulsni o’qish va uning davomiyligini qaytarish (millisekundlarda). Agar value qiymati HIGH bo’lsa, funksiya pin holati LOW dan HIGH ga o’tishini kutadi va keyingi bor LOW o’rnatiladigan vaqtni o’lchaydi. Va aksincha. timeout argumenti yordamida impuls maksimal qiymatini ko’rsatish mumkin (sukunat bo’yicha 1 sekund). Impuls davomiyligi 10 mks dan 3 daqiqagacha bo’lishi mumkin. |
|
pulseInLong(pin, value), pulseInLong(pin, value, timeout)
|
|
Yuqoridagi funksiyaning uzoq davom etadigan impuls bilan aniqroq ishlaydigan varianti. Apparatli uzilishlar bekor qilinganda ishlamaydi! |
Boshqa ma’lumotlar
|
Serial.begin(speed)
|
|
Serial obyekti orqali bog’lanishni speed tezligida faollashtirish (baud rate, sekundiga bit birligida). Arduino IDE port monitori uchun qo’llash mumkin bo’lgan tezliklar (bit/s):
|
|
Serial.end()
|
|
Serial obyekti orqali bog’lanishni to’xtatish.
Shu yo’l bilan Arduino UNO/Nano platalarining (ATmega328) 0 va 1 raqamli pinlarini boshqa maqsadlar uchun bo’shatib qo’yadi.
|
|
Serial.available()
|
|
Serial obyekti buferida saqlanayotgan va o’qish mumkin bo’lgan baytlar sonini qaytaradi (bufer maksimal o’lchami 64 bayt).
|
|
Serial.availableForWrite()
|
|
Serial obyekti buferiga saqlash mumkin bo’lgan baytlar sonini qaytaradi (bunda yozish funksiyasi uzilmaydi).
|
|
Serial.write(val), Serial.write(buf, len)
|
|
Serial portiga val sonli yoki matnli qiymatini yuborish, yoki buf buferidagi len sondagi baytlarni yuborish. Qiymatlar bayt formatida yuboriladi (ASCII jadvaliga ko’ra). Demak 88 yozuvi yuborilsa, “X” belgisi qabul qilinadi: Serial.write(88); // natija: X
|
|
Serial.print(val), Serial.print(val, format)
|
|
Portga val qiymatini (son yoki matn) yuborish. write() dan farqli ravishda, aynan belgining o’zini yuboriladi: Serial.print(88); // natija: 88. Serial.print(78); // natija: 78
Serial.print(1.23456); // natija: 1.23 (sukunat bo’yicha 2 ta belgi)
Serial.print(‘N’); // natija: N
Serial.print(“Hello world.”); // natija: Hello world.
// formatlangan holda ham chiqarish mumkin
Serial.print(“i have “ + String(50) + ” apples”);
// natija: i have 50 apples
// qiymat o’rniga o’zgaruvchini ham qo’llash mumkin:
byte appls = 50;
Serial.print(“i have “ + String(appls) + ” apples”);
// natija: i have 50 apples
format qiymatlarni chiqarish formatini belgilaydi: BIN, OCT, DEC, HEX – tegishli sanoq tizimlaridagi sonlarni chiqaradi, float formatli sonni chiqarishda chiqariladigan xona aniqligini ko’rsatish mumkin: Serial.print(78, BIN); // natija: “1001110”
Serial.print(78, OCT); // natija: “116”
Serial.print(78, DEC); // natija: “78”
Serial.print(78, HEX); // natija: “4E”
Serial.print(1.23456, 0); // natija: “1”
Serial.print(1.23456, 2); // natija: “1.23”
Serial.print(1.23456, 4); // natija: “1.2345”
|
|
Serial.println(), Serial.println(val), Serial.println(val, format)
|
|
print() ning analogi. Farqi, qiymatlar chiqarilib bo’lgach, keyingi qatorga o’tiladi. Argumentsiz qo’llanilsa, shunchaki keyingi qatorga o’tiladi xolos. |
|
Serial.flush()
|
|
Ma’lumot yuborishning to’xtatilishi kutiladi
|
|
Serial.peek()
|
|
Bufer oxiridagi bayt qaytariladi, lekin buferdan o’chirilmaydi (Serial.read() orqali ham aynan osha baytni qaytarish mumkin, lekin u buferdan o’chiriladi)
|
|
Serial.read()
|
|
Serial obyekti buferidagi baytning ASCII jadvalidagi kodi ko’rinishida qaytariladi. Raqamni qaytarish uchun argument bittalik qo’shtirnoqda ko’rsatiladi.
|
|
Serial.setTimeout(time)
|
|
Serial obyektining ayrim funksiyalari uchun kutish vaqtini (taymautni, millisekundlarda) belgilaydi. Sukunat bo’yicha qiymati 1000 millisekund (quyida keltiriladigan funksiyalar uchun qo’llaniladi).
|
|
Serial.find(target), Serial.find(target, length)
|
|
Buferdagi qiymatlarni o’qiydi va target (char turidagi ) belgilar ketma-ketligini izlaydi, qo’shimcha ravishda izlanayotgan matn uzunligini (length) ham ko’rsatish mumkin. Izlangan matn topilsa, true qiymatini, aksincha false qiymatini qaytaradi. Ma’lumotlar yuborilishini taymaut davomida kutadi. // Serial buferidan “salom” so’zini izlaymiz
char target[] = “salom”;
void setup() {
Serial.begin(9600);
}
void loop() {
if (Serial.available() > 0) {
if (Serial.find(target))
Serial.println(“topildi”);
// agar matn uchrasa, port monitoriga “topildi” matni chiqariladi
}
}
|
|
Serial.findUntil(target, terminal)
|
|
Buferdan qiymatlarni o’qiydi va target (char turidagi) belgilar ketma-ketligini yoki terminal terminal matnini izlaydi. Izlashni taymaut davomida yoki terminal ni o’qigandan keyin to’xtatadi.
|
|
Serial.readBytes(buffer, length)
|
|
Pordagi qiymatlarni o’qiydi va buffer nomli buferga (char[] yoki byte[] massivi) joylashtiradi, shuningdek yoziladigan baytlar soni length ni e’lon qiladi (buferni to’ldirib qo’ymaslik uchun).
|
|
Serial.readBytesUntil(character, buffer, length)
|
|
Pordagi qiymatlarni o’qiydi va buffer nomli buferga (char[] yoki byte[] massivi) joylashtiradi, shuningdek yoziladigan baytlar soni length ni hamda terminal belgisi character ni e’lon qiladi (buferni to’ldirib qo’ymaslik uchun). buffer nomli buferga qabul qilish baytlar soni length ga yetganda, character terminal belgisi qabul qilinganda yoki taymaut bo’yicha to’xtaydi.
|
|
Serial.readString()
|
|
Pordagi qiymatlarni o’qiydi va ulardan iborat String matnini hosil qiladi hamda qaytaradi. O’qishni taymaut bo’yicha yakunlaydi.
|
|
Serial.readStringUntil(terminator)
|
|
Pordagi qiymatlarni o’qiydi va ulardan iborat String matnini hosil qiladi hamda qaytaradi. O’qishni taymaut bo’yicha yoki terminator belgisi (char turidagi) qabul qilinganda yakunlaydi.
|
|
Serial.parseInt(), Serial.parseInt(skipChar)
|
|
Port buferidagi butun sonni o’qiydi va uni qaytaradi (turi long). O’qishni taymaut bo’yicha yoki “-” (minus) belgisidan tashqari ixtiyoriy belgi uchraganda yakunlaydi. Shuningdek, sonni qabul qilishda o’tkazib yuborish kerak bo’lgan skipChar belgisini (masalan, xonalarni ajratuvchi ‘ belgisini) ham ko’rsatish mumkin.Bunday belgi qatnashgan son ham qabul qilinadi.
|
|
Serial.parseFloat()
|
|
Buferdagi float formatli kasr sonni o’qiydi va qaytaradi. Qabul qilishni taymaut bo’yicha yakunlaydi.
|
|
delay(time)
|
|
Kod bajarilishini time millisekund vaqtga to’xtatib turadi (pauza o’rnatadi). time vaqti tugamaguncha dastur ishi to’xtab turadi, apparatli uzilishlardan tashqari (ular haqida yuqorida keltirilgan).
Ushbu funksiyani imkon qadar ishlatmaslik tavsiya etiladi. time argumenti qo’llanilganda uning qaiymat turi unsigned long da ko’rsatiladi va uning maksimal darajasiga (4 294 967 295 millisekund = taxminan 50 sutka) yetganda, sanoq yana noldan boshlanadi. Timer 0 tizim taymerida ishlaydi. Batafsil.
|
|
delayMicroseconds(time)
|
|
delay() funksiyasining analogi, farqi – time argumenti qiymati mikrosekundlarda ko’rsatiladi.
|
|
millis()
|
|
Mikrokontroller ishga tushirilgandan keyingi o’tgan vaqtni millisekundlarda ko’rsatadi. Qiymat turi unsigned long. Ko’p hollarda “delay()” funksiyasi o’rniga “millis()”ni qo’llash tavsiya etiladi (qo’llanilish kodi murakkabroq), chunki “millis()” qo’llanilishi davomida qurilma ishida to’xtash yuzaga kelmaydi.
|
|
micros()
|
|
“millis()”ning analogi, farqi – qiymat turi mikrosekundlarda ko’rsatiladi. Taxminan 70 daqiqadan keyin (4 294 967 295 mikrosekunddan keyin) sanoq yana noldan boshlanadi.
|
|
HIGH va LOW
|
mos ravishda 1 va 0 |
|
INPUT, OUTPUT,
INPUT_PULLUP
|
mos ravishda 0, 1 va 2 |
|
SERIAL, DISPLAY
|
mos ravishda 0 va 1 |
|
LSBFIRST, MSBFIRST
|
mos ravishda 0 va 1 |
|
CHANGE, FALLING, RISING
|
mos ravishda 1, 2 va 3 |
|
F_CPU
|
protsessor chastotasi, Gertsda |
|
__DATE__
|
kompilyatsiya bajarilgan sana kodi, Feb 28 2019 formatida |
|
__TIME__
|
kompilyatsiya bajarilgan vaqt kodi, 14:12:12 formatida |
Utilitalar
|
sizeof(variable)
|
|
O’zgaruvchining o’chamini qaytaradi, baytlarda. Barcha turdagi sonli, massivli va matnli o’zgaruvchilar bilan ishlaydi. Matnli o’zgaruvchi o’chamini aniqlashda uning uzunligi bilan adashtirmaslik kerak. // har xil turdagi massivlar:
byte arrayB[5];
int arrayI[5];
long arrayL[5];
float arrayF[5];
String myString = “matn”;
// massivning umumiy o’lchami
Serial.println(sizeof(arrayB)); // natija: 5
Serial.println(sizeof(arrayI)); // natija: 10
Serial.println(sizeof(arrayL)); // natija: 20
Serial.println(sizeof(arrayF)); // natija: 20
Serial.println(sizeof(myString)); // natija: 6 (uzunligi: 4)
// massiv kataklari sonini aniqlaymiz, buning uchun 1-katak o’chamiga bo’lamiz
Serial.println(sizeof(arrayB) / sizeof(arrayB[0])); // natija: 5
Serial.println(sizeof(arrayI) / sizeof(arrayI[0])); // natija: 5
Serial.println(sizeof(arrayL) / sizeof(arrayL[0])); // natija: 5
Serial.println(sizeof(arrayF) / sizeof(arrayF[0])); // natija: 5
|
|
PROGMEM
|
|
Mikrokontroller tezkor xotirasini iqtisod qilish maqsadida qo’llaniladigan, sketchni unga yuklash bosqichida qiymatlarni (alohida qiymatlar, massivlar, matnlar) flesh-xotiraga joylashtirish va keyin shu joydan o’qish uchun mo’ljallangan utilita. // bir nechta sonlarni saqlash:
const uint16_t ints[] PROGMEM = {65000, 32796, 16843, 10, 11234};
// kasr sonlarni saqlash:
const float floats[] PROGMEM = {0.5, 120.25, 0.9214};
// belgilarni saqlash
const char message[] PROGMEM = {“Salom! Matn”};
void setup() {
Serial.begin(9600);
Serial.println(pgm_read_word(&(ints[2]))); // natija: 16843
Serial.println(pgm_read_float(&(floats[1]))); // natija: 120.25
for (byte i = 0; i < 11; i++)
Serial.print((char)pgm_read_byte(&(message[i])));
// natija: “Salom! Matn”
}
progmem dan o’qish uchun asosiy funksiya – pgm_read_<turi>. Quyidagi 4 ta variantda qo’llashimiz mumkin:
Manfiy (signed) sonlarni ko’o’qishshda ularning qiymat turini ko’rsatish kerak. Misol: // turli ishorali qiymatlarni saqlaymiz:
const int16_t ints[] PROGMEM = {65000, 32796, -16843};
// setup
Serial.println((int)pgm_read_word(&(ints[2]))); // natija: -16843
|
|
F() macro
|
|
“F() macro” – matnni tezkor xotira o’rniga flesh-xotiraga vaqtincha joylashtirishi mumkin bo’lgan utilita. Juda oson va samarali ishlaydi, Serial obyekti orqali bog’lanich/otladka qilishda tezkor xotirani band qilmasligi bilan ahamiyatli. // ushbu matnni portga chiqarish uchun 18 bayt tezkor xotira band bo’ladi:
Serial.println(“Hello <username>!”);
// ushbu matnni “F()” ishtirokida portga chiqarish uchun tezkor xotiradan umuman joy talab etilmaydi:
Serial.println(F(“Type /help to help”));
|
-
malloc() // xotiradan joy ajratish
-
free() // xotirani tozalash
-
new() // xotiradan joy ajratish, “malloc()”ning to’liq analogi
-
delete() // xotirani tozalash, “free()”ning to’liq analogi
-
memset() // manziliga ko’ra xotira bloklarini to’ldiradi
Boshqa operatorlar va so’zlar
Boshqa
-
export – so’z ishlatilmaydi (zahiralangan), batafsil
-
virtual – virtual funksiya spetsifikatori, batafsil
-
yield() – Schelduer bibliotekasining qismi, “ko’poqimlikni hosil qilish uchun”. Batafsil
-
complex – kompleks klass. Batafsil
-
explict – konvertlanmaydigan konstruktorni yaratish imkonini beradi. Batafsil
-
union – “birlashma” obyekti .Batafsil
-
friend – do’st-funksiya. Batafsil
-
NULL – bo’sh ko’rsatkichlar
-
register – ushbu spetsifikator kompilyatorga o’zgaruvchi qiymatini tezkor xotirada emas, protsessor registrida saqlashni ko’rsatma beradi.
-
auto – ma’nosi yo’q
-
mutable – “tegib bo’lmaydigan” obyekt yaratish imkonini beradi
-
override – modifikator
-
final – modifikator
-
namespace – nomlar sohasini yaratish