Matematik, mantiqiy, taqqoslovchi va shartli operatorlar

Matematik operatorlar

Arduinoda arifmetik operatorlarni bajarish uchun ifodada bevosita sonlarning o’zini qo’llash yoki oldin ularni o’zgaruvchiga o’zlashtirilib, so’ng ular ustida operatorlarni bajarish mumkin. Muhimi, o’zgaruvchilarning qiymat turini (qiymat qabul qilish sohasini) oldindan aniq belgilab olish zarur. Masalan, int turidagi o’zgaruvchi faqat -32 768… 32 767 oralig’ida, unsigned int turidagi o’zgaruvchi faqat 0 … 65 535 oralig’ida butun sonli qiymat qabul qila oladi. Undan kattaroq butun sonlar bilan ishlash uchun long (-2 147 483 648 … 2 147 483 647), unsigned long (0 … 4 294 967 295) kabi qiymat turlarini tanlash mumkin.

Kasr sonlar bilan ishlashda esa, float qiymat turidan foydalaniladi. Biroq yuqori aniqlik yoki tezlik talab etilgan vaziyatlarda undan foydalanish tavsiya etilmaydi. Chunki, mazkur qiymat turi bilan bog’liq hisoblashlarda natija aniqligi 7-8 xonadan oshmaydi, hisoblash nisbatan sekin (butun sonlarga nisbatan 7-10 baravar sekinroq) bajarilishi esa, mikrokontroller ishlashi va qurilma ishining umumiy samaradorligiga salbiy ta’sir o’tkazishi mumkin. Shuning uchun, uning o’rniga hisoblashni butun sonlarda bajarib, keyin kerakli aniqlikka erishish uchun 10 ning darajalariga bo’lish mumkin: 42949,67 = 4294967/100.

Arifmetik operatorlar:

+ qo’shish (a + b)
– ayirish (a – b)
* ko’paytirish (a * b)
/ bo’lish (a / b)
% bo’linmaning qoldig’i (a % b)
= o’zlashtirish operatori (a = b)
+= qo’shma yig’indi (o’zgaruvchi qiymatiga yangi qiymat qo’shish: a += 10 bilan a = a + 10 bir xil)
-= qo’shma ayirma (o’zgaruvchi qiymatidan yangi qiymatni ayirish: a -= 10 bilan a = a – 10 bir xil)
*= qo’shma ko’paytma (o’zgaruvchi qiymatiga yangi qiymatni ko’paytirish: a *= 10 bilan a = a * 10 bir xil)
/= qo’shma bo’linma (o’zgaruvchi qiymatini yangi qiymatga bo’lish: a /= 10 bilan a = a / 10 bir xil)
%= qo’shma qoldiq (o’zgaruvchi qiymatini yangi qiymatga bo’lish qoldig’i: a %= 10 bilan a = a % 10 bir xil)
++ inkrement (o’zgaruvchi qiymatiga 1 ni qo’shish: a++ bilan a = a + 1 bir xil). O’zgaruvchi nomi operatorning qaysi tomonida ko’rsatilganidan kelib chiqib 2 xil turi mavjud: pre-inkrement (a++) va post-inkrement (++a). Quyiroqdagi misollarga qarang.
– – dekrement (o’zgaruvchi qiymatidan 1 ni ayirish: a- – bilan a = a – 1 bir xil). O’zgaruvchi nomi operatorning qaysi tomonidaligidan kelib chiqib 2 xil turi mavjud: pre-dekrement (a- -) va post-dekrement (- -a). Quyiroqdagi misollarga qarang.

Arifmetik operatorlarni misollarda ko’rib chiqamiz va hisoblash natijalarini port monitorida kuzatamiz:

Arifmetik operatorlarga misollar

void setup() {
Serial.begin(9600);
Serial.println(25 + 35); //natija: 60
Serial.println(2 * 3 – 3); //natija: 3
int a = 4; int b = 20; int c = 0; fload d = 12345678.9 * 12.3;
Serial.println(a * b); //natija: 80
c=a * b;
Serial.println(c); //natija: 80
c = a + b;
c = b – a;
Serial.println(c); //natija: 16
Serial.println(b / a); //natija: 5
Serial.println(c – (b / a)); //natija: 11
Serial.println(d); //natija: 151851856.00, aniqlik 8-xonagacha. Aslida tog’ri natija: 151 851 850,47
d = 123.456*12.34;
Serial.println(d); //natija: 1523.45, aniqlik 5-xonagacha. Aslida tog’ri natija: 1523,44704
unsigned long g = 286331153 * 15;
Serial.println(g); //natija: 4294967295

int a = 0; int b = 0;
a++; //inkrement
Serial.println(a); //natija: 1
a = 0; b = 0;
b=a++; //pre-inkrement
Serial.println(b); //natija: 0
a = 0; b = 0;
b=++a; //post-inkrement
Serial.println(b); //natija: 1

int a = 1; int b = 1;
a–; //dekrement
Serial.println(a); //natija: 0
a = 1; b = 1;
b=a–; //pre-dekrement
Serial.println(b); //natija: 1
a = 1; b = 1;
b=–a; //post-dekrement
Serial.println(b); //natija: 0
}

void loop() {
}

Boshqa matematik (trigonometrik) operatorlar Arduinoda kamdan-kam qo’llaniladi. Shuning uchun ular haqidagi ma’lumotlarni biz keltirmaymiz.

Taqqoslash (solishtirish) operatorlari

Arduinoda taqqoslash operatorlari (operatorlari) 2 ta va undan ortiq qiymatlarni yoki operatorlarni o’zaro solishtirish uchun ishlatiladi. Shuningdek, amaliyotda qurilmaga ulangan datchiklar ko’rsatkichlariga ko’ra, tashqi yuklamani boshqarishda katta rol o’ynaydi. Masalan, yorug’lik darajasi o’zgarishiga qarab, chiroqni yoqib-o’chirish yoki ob-havo darajasiga qarab konditsioner yoki isitish vositalarini boshqarish, shuningdek, obyektdagi ogohlantirish datchiklari (masalan, tovush, harakat, temperatura va boshqa datchiklar ko’rsatkichlaridagi o’zgarishlar) holati haqida egasini ogohlantiruvchi signallarni yuborish kabi jarayonlarini avtomatlashtirish mumkin.

Arduinoda quyidagi taqqoslash operatorlari qo’llaniladi:

== teng (a == b)
!= teng emas (a != b. Ushbu amal a=!b amali bilan har doim ham bir xil natija bermaydi!)
> katta (a > b)
< kichik (a < b)
>= katta yoki teng (a >= b)
<= kichik yoki teng (a <= b)

Taqqoslash operatori natijasi true yoki 1 (shart bajarilganda), false yoki 0 (shart bajarilmaganda) qiymatlariga teng bo’lishi mumkin.

Taqqoslash operatorlari ko’proq if/else shartli operatori tarkibida qo’llaniladi (masalan, if(a > b) {…}, if(a != b){…}else{…} kabi).

Misollar:

Taqqoslash operatorlariga misollar

void setup() {
Serial.begin(9600);
int a = 24; int b = 48 / 2; int c = 30;
Serial.println(a == b); //natija: 1 (true)
Serial.println(a == c); //natija: 0 (false)
Serial.println(a != b); //natija: 0 (false)
Serial.println(!(a != b)); //natija: 1 (true)
Serial.println(b > c); //natija: 0 (false)
Serial.println(b < a); //natija: 0 (false)
Serial.println(a <= c); //natija: 1 (true)
Serial.println(c <= b); //natija: 0 (false)
Serial.println(!(c < b)); //natija: 1 (true)
}

void loop() {
}

Mantiqiy operatorlar

Arduinoda mantiqiy operatorlar quyidagicha ifodalanadi:

&& mantiqiy “VA” operatori
|| mantiqiy “YOKI” operatori
! (not) mantiqiy “EMAS” (inkor qilish) operatori

Mantiqiy operatorlarga misollar

Serial.println(a == b && b == c); //natija: 0 (false)
Serial.println(a == b || b == c); //natija: 1 (true)
Serial.println(a == b && b != c); //natija: 1 (true)
Serial.println((a == b && b != c) && a != c); //natija: 1 (true)
Serial.println((a == b && b != c) || a != c); //natija: 1 (true)
Serial.println((a == b && b != c) || a == c); //natija: 1 (true)
Serial.println((a == b && b == c) || a == c); //natija: 0 (false)

Mantiqiy operatorlar ko’pincha bir nechta taqqoslash operatorlarini birlashtirish maqsadida qo’llaniladi.

Shartli operatorlar

Shartli operator deganda, ma’lum bir kodning muayyan shart bajarilganda (yoki bajarilmaganda) bajarilishini ta’minlaydigan operatorga aytiladi. Arduinoda bir nechta shartli operator turlaridan keng foydalaniladi:

if/else/else if shartli operatori
? uchlik shartli operatori (“тернарный оператор”)
switch/case (tanlash) shartli operatori

Arduinoda shartli operatorlar o’zgaruvchilarni, ifodalarni, qiymatlarni taqqoslash maqsadida foydalaniladi, shuningdek ular shartni belgilash qismida mantiqiy operatorlar bilan ham birgalikda qo’llaniladi.

if/else if/else shartli operatori – shart yoki solishtirish asosida amallarni bajarish operatori. Sintaksisi:

if(<shart>) {<shart bajarilgandagi kod>} else if {2-shart bajarilgandagi kod} … else {hech qaysi shart bajarilmagandagi kod}

Agar shartdan keyin faqat 1 ta amal bajarilsa, {} belgilaridan foydalanish shart emas.

'if/else if/else' operatoriga misollar

if (a > b) c = 10; // “agar a b dan katta bo’lsa, c = 10 bo’lsin”
else if (a == b) c = 20; else c = 30;// “aksincha, с = 20 bo’lsin”. Qisqartirlgan holda:
if (a > b) c = 10; else if (a == b) c = 20; else c = 30;

// solishtirish operatori o’rniga mantiqiy o’zgaruvchini qo’llasa ham bo’ladi:
boolean myFlag, myFlag2;
if(myFlag == true) c = 10; //”Agar myFlag = true bo’lsa c=10″ yoki
if(myFlag) c = 10; //”Agar myFlag = true bo’lsa c=10.
//Ya’ni, shartda true qiymati bilan taqqoslashni ko’rsatmasa ham bo’ladi.

// 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”

? (“тернарный оператор”) uchlik shartli operatorining (if/else operatorining qisqartirilgan ko’rinishi) sintaksisi:

(shart) ? <u holda> : <aksincha>

'?' operatoriga misollar

(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) to’g’ridan-to’g’ri port monitorida ko’rsatiladi.

switch/case – tanlashga asoslangan shartli operator. Sintaksisi:

switch (<o’zgaruvchi>){
case <1-qiymat>: <1-kod>
break;
case <2-qiymat>: <2-kod>
break;
default: <3-kod>
break;
}

// default – qo’llanishi majburiy emas bo’lgan buyruq
// break – qo’llanishi majburiy bo’lgan buyruq

'switch/case/break' operatoriga misollar

switch (val){
case 1: // “agar val = 1 bo’lsa 1-kod bajarilsin:”
// 1-kod
break; //shartdan chiqiladi
case 2: // “agar val = 2 bo’lsa 2-kod bajarilsin:”
// 2-kod
break; //shartdan chiqiladi
default: // “agar val yuqoridagi hech qaysi qiymatga teng bo’lmasa, 3-kod bajarilsin:”
// 3-kod
break; //shartdan chiqiladi
} //shartli operator oxiri

Tanishing

Matematik, mantiqiy, taqqoslovchi va shartli operatorlar

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