Arduino cilpas. FOR un WHILE cilpas Arduino Nested cilpas Arduino

• kamēr (stāvoklis) ()

• do() while(condition);

• for(skaitīšanas mainīgais; nosacījums; palielināt skaita mainīgo) ()

Katrai programmēšanas valodai ir vadības instrukciju kopa, kas ļauj atkārtoti izpildīt vienu un to pašu kodu (cilpa), izvēlēties atbilstošu koda daļu (nosacījumus) un instrukcijas, kā iziet no pašreizējā koda daļas.

Arduino IDE lielāko daļu nepieciešamo vadīklu aizņem no C/C++. To sintakse ir identiska C. Tālāk mēs īsi aprakstīsim to sintaksi.

ja paziņojums

If paziņojums ļauj izpildīt noteiktu programmas fragmentu atkarībā no noteikta nosacījuma pārbaudes rezultāta. Ja nosacījums ir izpildīts, tad programmas kods tiks izpildīts, bet, ja nosacījums nav izpildīts, tad programmas kods tiks izlaists. Komandas if sintakse ir šāda:

Ja(nosacījums) ( instrukcija1; instrukcija2; )

Nosacījums var būt jebkurš funkcijas atgrieztā mainīgā vai vērtības salīdzinājums. Galvenais ja nosacījuma kritērijs ir tas, ka atbildei vienmēr jābūt patiesai vai nepatiesai. Ja priekšraksta nosacījumu piemēri:

Ja(a!=2) ( ) ja(x<10) { } if(znak==’B’) { }

Iekavās, kas ir ierakstītas nosacījuma iekšpusē, varat izpildīt kodu.

Cilvēki, kuri sāk mācīties programmēšanu, bieži pieļauj kļūdu, pielīdzinot noteikta mainīgā vērtību, izmantojot vienu zīmi "=". Šāds apzīmējums skaidri norāda uz mainīgas vērtības piešķiršanu, un tāpēc nosacījums vienmēr būs “patiess”, tas ir, izpildīts. Pārbaudi, vai mainīgais ir vienāds ar noteiktu vērtību, vienmēr norāda ar dubultu vienādības zīmi (==).

Funkcijas stāvokli varat izmantot kā nosacījumu, piemēram:

If(init()) ( Serial.print("ok"); )

Iepriekš minētais piemērs tiks izpildīts šādi: Pirmajā solī tiek izsaukta funkcija init(). Šī funkcija atgriež vērtību, kas tiks interpretēta kā "true" vai "false". Atkarībā no salīdzināšanas rezultāta tiks nosūtīts “ok” teksts vai nekas netiks nosūtīts.

Ja… cits paziņojums

Paplašināts if paziņojums ir if….else paziņojums. Tas nodrošina, ka viens koda gabals tiek izpildīts, ja nosacījums ir patiess (true), un otrs koda gabals tiek izpildīts, ja nosacījums nav izpildīts (false). F if….else priekšraksta sintakse ir šāda:

Ja (nosacījums) ( // komanda A ) else ( // komanda B )

"A" komandas tiks izpildītas tikai tad, ja nosacījums ir izpildīts, komanda "B" tiks izpildīts, ja nosacījums nav izpildīts. Komandu “A” un “B” vienlaicīga izpilde nav iespējama. Šis piemērs parāda, kā izmantot if...else sintaksi:

If (init()) ( Serial.print("ok"); ) else ( Serial.print("kļūda"); )

Tādā veidā var pārbaudīt pareizu funkcijas izpildi un informēt par to lietotāju.

Izplatīta prakse ir nosacījuma noraidīšana. Tas ir saistīts ar faktu, ka pareizi izpildīta funkcija atgriež vērtību 0, bet funkcija, kas kāda iemesla dēļ izpildīta nepareizi, atgriež vērtību, kas nav nulle.

Šīs "dzīves komplikācijas" izskaidrojums ir vienkāršs. Ja funkcija tiek izpildīta pareizi, tad šī ir vienīgā mums nepieciešamā informācija. Kļūdas gadījumā dažreiz ir vērts saprast, kas nogāja greizi un kāpēc funkcija netika veikta pareizi. Un šeit palīgā nāk skaitļi, kas nav nulle, t.i., izmantojot digitālos kodus, mēs varam noteikt kļūdas veidu. Piemēram, 1 - problēma ar kādas vērtības nolasīšanu, 2 - nav vietas atmiņā vai diskā utt.

Pēdējais pārveidotais piemērs parāda, kā izsaukt funkciju, kas atgriež nulli, ja tā tiek izpildīta pareizi:

If (!init()) ( Serial.print("ok"); ) else ( Serial.print("kļūda"); )

Pārslēgt gadījuma paziņojumu

Paziņojums if ļauj pārbaudīt tikai vienu nosacījumu. Dažreiz ir nepieciešams veikt kādu no darbībām atkarībā no atgrieztās vai nolasītās vērtības. Slēdža atbilžu variantu operators ir ideāls šim nolūkam. Slēdža komandas sintakse ir parādīta zemāk:

Slēdzis (var) (1. gadījums: //instrukcija var=1 pārtraukumam; 2. gadījums: //instrukcija var=2 pārtraukumam; noklusējuma: //noklusējuma instrukcija (ja var atšķiras no 1 un 2) )

Atkarībā no mainīgā mainīgā vērtības tiek izpildītas instrukcijas konkrētos blokos. Gadījuma etiķete norāda norādītās vērtības bloka sākumu. Piemēram, gadījums 1: nozīmē, ka šis bloks tiks izpildīts ar vērtību var, kas vienāda ar vienu.

Katrs bloks ir jāpabeidz ar pārtraukuma komandu. Tas pārtrauc tālāku slēdža priekšraksta izpildi. Ja pārtraukuma komanda tiek izlaista, norādījumi tiks izpildīti nākamajos blokos pirms pārtraukuma komandas. Noklusējuma etiķete nav obligāta, tāpat kā cita priekšraksta if. Noklusējuma blokā esošās instrukcijas tiek izpildītas tikai tad, ja mainīgā mainīgā vērtība neatbilst nevienam modelim.

Bieži gadās, ka vienai no vairākām vērtībām ir jāizpilda vienas un tās pašas instrukcijas. To var panākt šādi:

Slēdzis (x) (1. gadījums: //instrukcija x=1 pārtraukumam; 2. gadījums: 3. gadījums: 5. gadījums: //instrukcija x=2 vai 3 vai 4 pārtraukumam; 4. gadījums: //instrukcija pārtraukumam x=4 ; 6. gadījums: // instrukcija x=6 pārtraukumam; noklusējuma: // noklusējuma instrukcija (ja x atšķiras no 1,2,3,4,5,6)

Atkarībā no mainīgā x vērtības tiks izpildīts attiecīgais instrukciju bloks. 2. gadījuma atkārtošana: 3. gadījums: 5. gadījums: informē kompilatoru, ka, ja mainīgajam x ir vērtība 2, 3 vai 5, tiks izpildīts tas pats koda fragments.

par paziņojumu

Priekšraksts for tiek izmantots, lai atkal un atkal izpildītu vienu un to pašu kodu. Bieži vien ir jāizpilda tie paši norādījumi, mainot tikai kāda mainīgā vērtību. Šim nolūkam ir ideāli piemērota cilpa for. Komandas sintakse ir šāda:

Int i; for(i=0;i<10;i++) { // инструкции для выполнения в цикле }

Pirmais parametrs, kas norādīts priekšrakstā, ir mainīgā sākotnējā vērtība. Vēl viens elements ir cilpas izpildes turpināšanas nosacījuma pārbaude. Cilpa darbojas tik ilgi, kamēr ir izpildīts nosacījums. Pēdējais elements ir mainīgā lieluma vērtības izmaiņas. Visbiežāk mēs palielinām vai samazinām tā vērtību (pēc vajadzības). Šajā piemērā cilpā ietvertās instrukcijas tiks izpildītas ar i=0...9.

Bieži vien cilpā izmantotais mainīgais tiek deklarēts tur:

For(int i=0;i<10;i++) { // инструкции для выполнения в цикле }

Mainīgo, kas tiek izmantots, lai skaitītu turpmākās cilpas darbības, tajā var izmantot, lai izsauktu funkciju ar atbilstošiem parametriem.

For(int i=10;i>0;i—) ( Serial.print(i); // tiks nosūtīti skaitļi 10,9,8,7,6,5,4,3,2,1)

kamēr paziņojums

For cilpa ir ideāli piemērota, ja mēs vēlamies veikt skaitīšanu. Situācijā, kad mums ir jāveic noteiktas darbības kāda notikuma rezultātā, kas nav obligāti paredzams (piemēram, mēs gaidām, kad tiks nospiesta poga), tad varam izmantot priekšrakstu while, kas izpilda priekšraksta bloku kā kamēr nosacījums ir izpildīts. Paziņojuma while sintakse ir šāda:

While(nosacījums) ( // izpildāmo instrukciju bloks)

Ir svarīgi, lai statusa pārbaude notiktu cikla sākumā. Var gadīties, ka instrukcijas while cilpas iekšpusē nekad netiek izpildītas. Ir iespējams arī izveidot bezgalīgu cilpu. Apskatīsim divus piemērus:

Int x=2; while(x>5) ( Serial.print(x); ) ——————————————- int y=5; while(y>0) ( Serial.print(y); )

Pirmais paziņojumu bloks, kas atrodas iekšā while, nekad netiks izpildīts. Mainīgajam x ir vērtība divi, un tā nekļūs lielāka par 5. Otrajā piemērā mums ir darīšana ar bezgalīgu cilpu. Mainīgajam “y” ir vērtība 5, t.i., lielāka par nulli. Cilpas iekšpusē mainīgais "y" netiek mainīts, tāpēc cilpa nekad netiks pabeigta.

Tā ir izplatīta kļūda, kad aizmirstam mainīt parametru, kas izraisa cilpas pārtraukšanu. Tālāk ir sniegti divi pareizi kamēr cilpas izmantošanas piemēri.

Int x=0; while(x<10) { //блок инструкций x++; } —————————————- while(true) { if(условие) break; // блок инструкций }

Pirmajā piemērā mēs parūpējāmies par nosacījumā pārbaudītā mainīgā vērtības maiņu. Tā rezultātā cikls galu galā beigsies. Otrajā piemērā ar nolūku tika izveidota bezgalīga cilpa. Šī cilpa ir līdzvērtīga cilpa () funkcijai Arduino IDE. Turklāt cilpas iekšpusē ir ieviesta stāvokļa pārbaude, pēc kuras cilpa beidzas ar pārtraukuma komandu.

darīt… kamēr paziņojums

Cilpas while variants ir do...while cilpa. Papildus sintaksei tā atšķiras arī stāvokļa pārbaudes vietā. Do...while gadījumā nosacījums tiek pārbaudīts pēc instrukciju bloka izpildes. Tas nozīmē, ka instrukciju bloks cilpas pamattekstā tiks izpildīts vismaz vienu reizi. Tālāk ir norādīta komandas do...while sintakse:

Do ( // instrukciju bloks ) while(condition)

Viss, kas rakstīts par operatoru while attiecas arī uz do...while. Tālāk ir sniegts cilpas do...while izmantošanas piemērs:

Int x=10; do ( // instrukciju bloks x—; ) while(x>0); —————————————- do ( // instrukciju bloks if (condition) break; ) while(true);

pārtraukuma paziņojums

Pārtraukuma paziņojums ļauj iziet no cilpas (do...while, for, while) un iziet no slēdža opcijas. Nākamajā piemērā apsveriet pārtraukuma komandas izpildi:

For(i=0;i<10;i++) { if(i==5) break; Serial.print(i); }

Cilpa ir jāizpilda skaitļiem no 0 līdz 9, bet skaitlim 5 ir izpildīts nosacījums, kas aktivizē pārtraukuma paziņojumu. Tas iziet no cilpas. Rezultātā uz seriālo portu (Serial.print) tiks nosūtīti tikai skaitļi 0,1,2,3,4.

Turpināt operators

Operators turpināt liek cilpas instrukcijām (do...while, for, while) pārtraukt pašreizējās vērtības izpildi un pāriet uz nākamo cilpas darbību. Šis piemērs parāda, kā darbojas turpinājuma priekšraksts:

For(i=0;i<10;i++) { if(i==5) continue; Serial.print(i); }

Kā nav grūti pamanīt, cilpa tiks izpildīta vērtībām no 0 līdz 9. Vērtībai 5 tiks izpildīta komanda turpināt, kā rezultātā instrukcijas pēc šīs komandas netiks izpildītas. Rezultātā skaitļi 0,1,2,3,4,6,7,8,9 tiks nosūtīti uz seriālo portu (Serial.print).

atgriešanas paziņojums

Atgriešanas paziņojums pabeidz izsauktās funkcijas izpildi un atgriež noteikta veida vērtību. Kā komandas parametru varat norādīt skaitli, simbolu vai noteikta veida mainīgo. Ir svarīgi, lai atgriešanas vērtība atbilstu deklarētās funkcijas veidam. Šis piemērs parāda, kā izmantot atgriešanas priekšrakstu:

Int checkSensor())( if (analogRead(0) > 400) ( // analogās ievades nolasīšana atgriež 1; // Vērtībām, kas lielākas par 400, 1 tiek atgriezts else( return 0; // citiem, 0 ir atgriezās))

Kā redzat, vienā funkcijā varat izmantot vairākus atgriešanas paziņojumus, taču vienmēr darbosies tikai viens no tiem. Ir pieļaujams izmantot atgriešanas operatoru bez parametriem. Tas ļauj priekšlaicīgi pārtraukt funkciju, kas neatgriež nekādu vērtību.

Void function_name() ( instrukcija1; if(x==0) return; instruction2; instruction3; )

Iepriekš minētajā piemērā instrukcija1 tiks izpildīta ikreiz, kad tiks izsaukta funkcija. Instruction2 un instruction3 izpilde ir atkarīga no komandas if rezultāta. Ja nosacījums ir patiess (true), tiks izpildīta atgriešanas komanda un funkcija tiks aizvērta.

Gadījumā, ja nosacījums nav izpildīts, netiek izpildīta arī atgriešanas komanda, bet tiek izpildītas instrukcijas instrukcija2 un instrukcija3, un pēc tam funkcija pabeidz savu darbu.

goto paziņojums

Ideoloģisku apsvērumu dēļ ir nepieciešams izlaist šo aprakstu... Goto paziņojums ir komanda, kuru nevajadzētu lietot parastajā programmēšanā. Tas rada koda sarežģītību un ir slikts programmēšanas ieradums. Mēs ļoti iesakām neizmantot šo komandu savās programmās. Tā kā goto ir iekļauts oficiālajā dokumentācijā vietnē arduino.cc, šeit ir īss tās apraksts. goto komandas sintakse:

…. goto mark; // dodieties uz rindu ar apzīmējumu "metka" ..... .... …. metka: // etiķete, ar kuru programma turpinās darbu...

Komanda ļauj pāriet uz norādīto atzīmi, t.i., uz vietu programmā.

Cilpas, izmantojot paziņojumus priekš Un kamēr ir viena no svarīgākajām C++ valodas konstrukcijām, kas ir Arduino pamatā. Tie ir atrodami pilnīgi katrā skicē, pat ja jūs to nezināt. Šajā rakstā mēs sīkāk aplūkosim cilpas, uzzināsim, kāda ir atšķirība starp for un while, kā ar viņu palīdzību var vienkāršot programmas rakstīšanu un no kādām kļūdām vajadzētu izvairīties.

Ja jūs joprojām esat iesācējs programmētājs un vēlaties saprast, kas ir cilpa un kāpēc tā ir nepieciešama, skatiet šī raksta nākamo sadaļu ar detalizētu aprakstu.

Operators WHILE tiek izmantots C++ un Arduino, lai atkārtotu vienas un tās pašas komandas patvaļīgu skaitu reižu. Salīdzinot ar cilpu FOR, cilpa WHILE izskatās vienkāršāka; to parasti izmanto, ja mums nav jāskaita mainīgā atkārtojumu skaits, bet vienkārši jāatkārto kods, līdz kaut kas mainās vai notiek kāds notikums.

WHILE sintakse

kamēr(<условие или список условий>)
{
<программный блок, который будет повторяться>
}

Kā nosacījumus var izmantot jebkuru valodas konstrukciju, kas atgriež Būla vērtību. Nosacījumi var būt salīdzināšanas darbības, funkcijas, konstantes, mainīgie. Tāpat kā ar citām Arduino loģiskajām operācijām, jebkura vērtība, kas nav nulle, tiks uztverta kā patiesa, nulle - nepatiesa.

// Bezgalīga cilpa while(true)( Serial.println("Gaida..."); ) // Cilpa, kas darbojas, līdz mainās funkcijas checkSignal() vērtība while(!checkSignal())( Serial.println ("Gaida...");)

Ņemiet vērā, ka priekšrakstu while var izmantot, nebloķējot bloku ar krokainajām iekavām, un tādā gadījumā tiks atkārtota pirmā komanda pēc cilpas. Ļoti nav ieteicams lietot, kamēr nav cirtaini breketes, jo šajā gadījumā ir ļoti viegli kļūdīties. Piemērs:

While(true) Serial.print("Gaida pārtraukumu"); kavēšanās (1000);

Šajā gadījumā uzraksts tiks parādīts bezgalīgā cilpā bez pauzēm, jo ​​komanda delay(1000) netiks atkārtota. Jūs varat pavadīt daudz laika, lai noķertu šādas kļūdas - ir daudz vieglāk izmantot cirtainu lencīti.

Piemērs kamēr cilpas izmantošanai

Visbiežāk kamēr tiek izmantots, lai gaidītu kādu notikumu. Piemēram, Sērijas objekta gatavība darbam.

Serial.begin(9600); kamēr (!Serial) ( ; // Dažiem Arduino dēļiem ir jāgaida, līdz seriālais ports ir brīvs)

Piemērs, kad tiek gaidīts rakstzīmes ierašanās no ārējām ierīcēm, izmantojot UART:

While(Serial.available())( int byteInput = Seria.read(); // Dažas citas darbības)

Šajā gadījumā mēs nolasīsim vērtības, kamēr Serial.available() atgriež vērtību, kas nav nulle. Kad visi buferī esošie dati beigsies, cilpa apstāsies.

FOR cilpa programmā Arduino

FOR cilpā mums ir iespēja ne tikai iestatīt robežnosacījumus, bet arī nekavējoties definēt skaitītāja mainīgo un norādīt, kā tā vērtības mainīsies katrā iterācijā.

FOR cilpas sintakse

Šeit dizains būs nedaudz sarežģītāks:
priekš (<начальное значение счетчика>;<условие продолжения выполнения цикла>;<изменение значения счетчика на каждом шаге>){
<список_команд>
}

Vienkāršākais piemērs:

For(int i=5;i<10;i++){ // Конструкция «3 в одном» pinMode(i, OUTPUT); }

Mēs nekavējoties izveidojām mainīgo, inicializējām to un norādījām, ka katra cikla beigās skaitītāja vērtība jāpalielina par vienu. Un tas arī viss – tagad vari izmantot mainīgo cilpas iekšpusē.

Mainīgais solis var būt atšķirīgs. Šeit ir piemēri:

• for(int i=0; i<10; i=i+2) // Шаг 2
• for(int i=0; i<10; i+=2) // Аналогичен предыдущему
• for(int i=10; i>0; i–) // Atgriezties — no 10 uz 1

darīt kamēr cilpa

Dažos gadījumos mums ir jāorganizē cilpa tā, lai bloka norādījumi tiktu izpildīti vismaz vienu reizi, un pēc tam tiek veikta pārbaude. Šādiem algoritmiem varat izmantot do, kamēr konstruēšanu. Piemērs:

Do ( Serial.println("Darbs"); ) while (checkSomething());

Šī cilpas versija nesagādā nekādas grūtības - mēs vienkārši pārvietojām bloku ar nosacījumiem uz leju, tāpēc viss saturs, kas atrodas cirtainajās iekavās pēc operatora do, tiks izpildīts pirms pirmās pārbaudes.

Turpiniet un pārtrauciet apgalvojumus

Pastāv situācijas, kad jums steidzami jāpārtrauc cilpas izpilde cilpas blokā, negaidot, lai pārietu uz stāvokļa pārbaudes bloku. Lai to izdarītu, varat izmantot operatoru pārtraukums:

Kamēr (patiess) (if (checkSomething()) ( break; ) )

Ja mēs vienkārši vēlamies apturēt pašreizējās iterācijas gaitu, bet neiziet no cilpas, bet pāriet uz stāvokļa pārbaudes bloku, tad mums ir jāizmanto operators Turpināt:

Kamēr (patiess) (if (checkSomething()) (turpināt; ) )

Paziņojumus turpināt un pārtraukt var izmantot ar visiem FOR un WHILE cilpu variantiem.

Ligzdotas cilpas Arduino

Jebkurus cilpu variantus var viegli kombinēt savā starpā, veidojot ligzdotas struktūras. Mainīgie, kas definēti “pārklājošās” cilpas blokā, būs pieejami iekšējā. Visizplatītākais šāda veida cilpas piemērs ir divdimensiju masīvu šķērsošana. Nākamajā piemērā mēs izmantojam dubulto cilpu: pirmā atkārtos rindas (mainīgais i), otrā, ligzdotā, cilpu cauri masīva kolonnām (mainīgais j), ko mēs definējām mainīgajā arr.

Int arr; void setup() ( for (int i = 0; i< 10; i++) { for (int j = 0; j < 3; j++) { arr[i][j] = i * j; Serial.println(arr[i][j]); } } }

Vairāk par cikliem

Ja jūs nekad neesat strādājis ar cilpām, iedziļināsimies teorijas pasaulē un noskaidrosim, kas ir cilpas un kāpēc mums ir vajadzīgas šīs noslēpumainās valodas konstrukcijas.

Kāpēc mums ir vajadzīga cilpa?

Faktiski cilpas galvenais uzdevums ir vairākas reizes atkārtot vienas un tās pašas valodas konstrukcijas. Šī vajadzība rodas gandrīz katrā programmā, un noteikti neviena Arduino skice nevar iztikt bez cilpas - funkcija loop() tiek izsaukta arī bezgalīgā cilpā.

Apskatīsim šādu piemēru. Jums vienlaikus jāpiegādā strāva 5 gaismas diodēm, kas savienotas ar Arduino plati no 5. līdz 9. tapām. Acīmredzamākā iespēja būtu ievietot piecus norādījumus pēc kārtas:

digitalWrite(5, AUGSTS);

digitalWrite(6, AUGSTS);

digitalWrite(7, AUGSTS);

digitalWrite(8, AUGSTS);

digitalWrite(9, AUGSTS);

Pagaidām ignorēsim jautājumu par šādas darbības riskantumu, jo šāda skaita gaismas diožu vienlaicīga iekļaušana rada palielinātu slodzi dēļa strāvas ķēdē. Mums šobrīd galvenais ir tas, ka esam izveidojuši piecas koda rindas, no kurām katra atšķiras no pārējām tikai ar vienu ciparu. Šai pieejai ir šādi trūkumi:

• Veicot jebkādas izmaiņas, jums vienlaikus būs jāveic izmaiņas daudzās rindās. Piemēram, ja mums ir jāpārslēdz gaismas diodes uz tapām no 2 līdz 6 vai jāizslēdz spriegums, nevis jāieslēdz tas, mums būs jāveic 5 izmaiņas kodā. Ko darīt, ja ir vairāk norādījumu un izmaiņu?
• Liels kods ar lielu skaitu līdzīgu instrukciju ir neērti un nepatīkami lasāms. Piecas identiskas līnijas nav ļoti biedējošas. Bet netīrā koda ieradums galu galā novedīs pie desmitiem un simtiem papildu lappušu sarakstā, kas padarīs gan jūs, gan jūsu kolēģus izmisumā.
• Gandrīz identisku instrukciju “kopēšanas-ielīmēšanas” procesā var viegli kļūdīties, piemēram, aizmirstot nomainīt pin numuru: digitalWrite(5, HIGH); digitalWrite(5, AUGSTS);
• Jūs varat viegli izgāzties intervijā jebkurā parastā programmatūras uzņēmumā, parādot intervētājam šo kodu.

No tā visa mēs varam secināt, ka gandrīz vienmēr ir jāizvairās no vienas un tās pašas virknes atkārtotas izmantošanas un jāaizstāj ar cilpām. Turklāt daudzās situācijās nav iespējams iztikt bez cikliem, nekas tos nevar aizstāt. Programmas darbības laikā nevar mainīt koda atkārtošanas reižu skaitu. Piemēram, jums ir jāapstrādā katrs elements datu masīvs, saņemts no ārējām ierīcēm. Jūs nekad neparedzēsiet, cik daudz datu būs, cik reižu apstrāde tiks atkārtota, un tāpēc raksta tapšanas laikā nevarēsiet ievietot nepieciešamo instrukciju skaitu.

Un šeit mums palīgā nāk cikli.

Sintakses noteikumi

Cilpa programmā Arduino ir īpašs programmas bloks, kas programmas izpildes laikā tiks izsaukts noteiktu skaitu reižu. Šajā blokā mēs aprakstām pašas komandas, kas tiks izsauktas, un noteikumus, pēc kuriem kontrolieris noteiks, cik reižu tās ir jāizsauc.

Iepriekš minētajā piemērā mēs varētu norādīt kontrolierim sekojošo:

Atkārtojiet komandu digitālaisRakstiet 5 reizes

Ideālā pasaulē ar robotu programmētājiem ar to droši vien pietiktu, taču, tā kā mēs runājam ar datoru C++ valodā, mums šī frāze ir jātulko šajā valodā:

Atkārtojiet komandu – ir jāizmanto īpaši norādījumi, kas norāda kontrolierim, ka ar while vai for cilpām drīz sāksies kaut kas interesants

digitalWrite – atstājiet to tādu, kāds tas ir, bet uzrakstiet to vienreiz un ievietojiet to cirtainajās lencēs. Ko darīt ar PIN numuriem - tieši zemāk.

5 reizes – šim nolūkam izmantojiet skaitītāju, kas palielināsies ar katru atkārtojumu. Bloka sākumā (vai beigās) varat salīdzināt šī skaitītāja vērtību ar robežvērtību (šajā gadījumā 5), izmantojot salīdzināšanas darbību.

Apskatīsim šādas "tulkotas" cilpas komandas piemēru ar a while paziņojumu:

Int skaitītājs = 0; // Mainīgais, kas saglabās skaitītāja vērtību // Mēs lūdzam procesoru atkārtot konstrukciju cirtainajās iekavās, līdz nosacījums iekavās atgriezīsies true. // Mūsu gadījumā skaitītājs ir mūsu skaitītājs, 5 ir robežvērtība, nosacījums, lai skaitītāja vērtība ir mazāka par 5. // Bet mēs varam norādīt pilnīgi dažādus loģiskos operatorus, kamēr (skaitītājs< 5) { digitaWrite(5, HIGH); // Будем включать светодиод counter++; // Увеличиваем значение счетчика } // Дойдя до сюда, исполняющий процессор переместится в начало блока и опять займется проверкой условий. Если условия вернут истину, команды в блоке между { и } выполнятся еще раз. Если условие не выполнится - процессор переместится к концу блока и пойдет дальше. Этот цикл больше его не заинтересует.

Tiem, kuri pamanīja kļūdu dotajā kodā, mēs dodam pieci un rakstām cilpas bloku citādi:

Kamēr (skaitītājs< 5) { // Вот теперь мы будем включать разные светодиоды, с 5 (0+5) по 9 (4+5) digitalWrite(counter + 5, HIGH); counter++; }

To pašu rezultātu var sasniegt, izmantojot FOR cilpu:

For(int skaitītājs =0; skaitītājs<5; counter ++){ digitalWrite(counter+5, HIGH); }

Kā redzat, šajā gadījumā mēs nekavējoties ievietojam visas nepieciešamās darbības ar skaitītāju vienā FOR instrukcijā - tas ir daudz ērtāk, ja nepieciešams saskaitīt nepieciešamo daudzumu.

Detalizētu informāciju par cilpu izmantošanas noteikumiem varat iegūt attiecīgajās šī raksta sadaļās.

Secinājums

Šajā rakstā mēs apskatījām ļoti svarīgas Arduino valodas konstrukcijas: FOR un WHILE cilpas. Šos operatorus var atrast gandrīz jebkurā vairāk vai mazāk sarežģītā skicē, jo bez cilpām daudzas darbības ar datiem nebūtu iespējamas. Cilpu sintaksē nav nekā sarežģīta – pie tām var viegli pierast un aktīvi izmantot savos projektos.

Apskatīsim, kā Arduino IDE darbojas cilpas operatori for, while un do while, kā pareizi izmantot cilpas skicēs un no kādām kļūdām izvairīties. Izmantojot vienkāršus piemērus, mēs parādīsim, kā jūs varat apturēt cilpu vai pāriet no vienas cilpas uz otru. Lai saprastu rakstīšanas ciklu pareizību, pirmkārt, vajadzētu izpētīt algoritmu veidus un īpašības robotikā.

Kā cilpas darbojas Arduino IDE

Jebkura cilpa C++ un Arduino programmēšanas valodā ir darbība, kas tiek atkārtota daudzas vai bezgalīgi daudz reižu. Neviena Arduino mikrokontrollera programma nav pabeigta bez cilpas, piemēram, tukšuma cilpa tiek izsaukta bezgalīgā cilpā. Ir trīs veidu cilpas operatori: for, while un do while — apskatīsim katru operatoru un apskatīsim, kā tie darbojas, izmantojot piemērus.

For un while darbības principu var izskaidrot ar šādiem vienkāršiem piemēriem. For cilpa tiek izpildīta ierobežotu skaitu reižu (norādīts operatora nosacījumā); to izmanto, ja programma, piemēram, pieprasa LED mirgot vairākas reizes. Kamēr cilpa var darboties bezgalīgi, piemēram, kad Arduino LED indikators mirgo, līdz mainās sensora dati.

For cilpas apraksts Arduino ar piemēru

Arduino konstrukcija ir definēta šādi:

For cilpa tiek izmantota, lai atkārtotu noteiktas komandas, kas ietvertas cirtainos iekavās. Šis cikls ir piemērots jebkuru atkārtotu darbību veikšanai.
Plkst inicializācija tiek izveidots mainīgais un tiek piešķirta sākotnējā vērtība.
IN stāvokli tiek ierakstīta mainīgā vērtība, pie kuras tiks izpildīta cilpa.
IN mainīt norāda, kā mainīgais mainīsies katrā cilpas solī.

Piemēra skicē ir iestatīts mainīgais ar sākotnējo vērtību i=0, nosacījums nosaka, ka cilpa darbosies, līdz mainīgais būs vienāds ar vai lielāks par pieciem i<=5 . Izmaiņas nosaka, ka mainīgais katrā cilpas solī tiks palielināts par vienu. Visbeidzot, cilpa for iziet, kad mainīgais ir vienāds ar pieci, tāpēc gaismas diode mirgos piecas reizes pirms cilpas beigām.

Mainīgais solis (izmaiņas) var būt jebkas. Ja ir nepieciešams palielināt mainīgo par divām vienībām uzreiz, tad izmaiņas skaitītājā jāraksta šādi: i=i+2. For cilpu var izmantot tukšuma iestatīšanas procedūrā, piemēram, lai norādītu vairāku tapu darbības režīmu vienlaikus. Un arī tukšuma cilpas procedūrā, piemēram, programmā Arduino gaismas diožu secīgai ieslēgšanai.

Arduino while cilpas apraksts ar piemēru

Kamēr konstrukcija Arduino ir definēta šādi:

Cikla while darbosies nepārtraukti un bezgalīgi, ja vien nosacījums iekavās ir patiess. Cilpas izeja tiks sasniegta, kad mainās mainīgais while nosacījumā, tāpēc kaut kam ir jāmaina tā vērtība. Mainīgo var mainīt programmas kodā cilpas iekšpusē vai nolasot vērtības no jebkura sensora, piemēram, no ultraskaņas tālmēra HC-SR04.

Izmantojot funkciju while, mainīgais ir jāizveido pirms cilpas sākuma. Skicē piemērā pirms cikla beigām gaismas diode mirgos piecas reizes. Ja nemainīsit mainīgo lielumu cirtainajās lencēs i++, tad cikls atkārtosies bezgalīgi. Otrs veids, kā iziet no Arduino Uno kamēr cilpas, ir nolasīt datus no sensora un izmantot if paziņojumu, lai mainītu mainīgo.

Vēl viena cilpa, ko var izmantot Arduino IDE, ir pēcnosacījuma cilpa. darīt kamēr. Izmantojot šo konstrukciju, komandas cilpā tiks izpildītas vismaz vienu reizi neatkarīgi no nosacījuma, jo nosacījums tiek pārbaudīts pēc cilpas pamatteksta izpildes. Nākamajā koda piemērā gaismas diode ieslēgsies neatkarīgi no sensora rādījumiem un tikai pēc tam pārbaudīs pēcstāvokli.

Kā izlauzties no brīža vai uz cilpu

Gadījumā, ja ir nepieciešams iziet no cilpas korpusa, neatkarīgi no norādītajiem nosacījumiem, tiek izmantots operators pārtraukums vai iet uz. Pārtraukuma paziņojums ļauj iziet no cilpas, un programma turpinās izpildīt šādas komandas. Paziņojums goto ļauj ne tikai iziet no cilpas, bet arī turpināt programmas izpildi no vēlamā punkta gar etiķeti, piemēram, varat pāriet uz citu cilpu Arduino.