Bucle folosind instrucțiuni pentruȘi in timp ce sunt una dintre cele mai importante constructe ale limbajului C++ care stă la baza Arduino. Apar în absolut fiecare schiță, chiar dacă nu o știi. În acest articol, vom arunca o privire mai atentă asupra buclelor, vom afla care este diferența dintre for și while, cum puteți simplifica scrierea unui program cu ajutorul lor și ce greșeli ar trebui evitate.

Dacă sunteți încă un programator începător și doriți să înțelegeți ce este un ciclu și de ce este necesar, consultați următoarea secțiune a acestui articol cu ​​o descriere detaliată.

Operatorul WHILE este folosit în C++ și Arduino pentru a repeta aceleași comenzi de un număr arbitrar de ori. În comparație cu FOR, bucla WHILE pare mai simplă, este de obicei folosită acolo unde nu trebuie să numărăm numărul de iterații dintr-o variabilă, ci pur și simplu trebuie să repetăm ​​codul până când ceva se schimbă, are loc un eveniment.

Sintaxă WHILE

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

Orice construct de limbaj care returnează o valoare booleană poate fi folosit ca condiții. Condițiile pot fi operații de comparare, funcții, constante, variabile. Ca și în cazul oricărei alte operații logice din Arduino, orice valoare, alta decât zero, va fi percepută ca adevărată (adevărată), zero - fals (fals).

// Buclă infinită while(true)( Serial.println("Waiting..."); ) // Buclă care rulează până când valoarea funcției checkSignal() se schimbă while(!checkSignal())( Serial.println("Waiting... ");)

Rețineți că instrucțiunea while poate fi folosită fără acolade în jurul blocului, caz în care prima comandă întâlnită după buclă va fi repetată. Este foarte descurajat să se folosească fără bretele, deoarece in acest caz este foarte usor sa gresesti. Exemplu:

While(true) Serial.print("Se așteaptă întrerupere"); întârziere (1000);

În acest caz, inscripția va fi afișată într-o buclă infinită fără pauze, deoarece comanda delay(1000) nu se va repeta. Poți petrece mult timp descoperind astfel de erori - este mult mai ușor să folosești o breteză.

Un exemplu de utilizare a unei bucle while

Cel mai adesea, while este folosit pentru a aștepta un eveniment. De exemplu, disponibilitatea obiectului Serial de a funcționa.

Serial.begin(9600); în timp ce (!Serial) ( ; // Unele plăci Arduino vă cer să așteptați până când portul serial este liber )

Un exemplu de așteptare a sosirii unui personaj de pe dispozitive externe prin UART:

While(Serial.available())( int byteInput = Seria.read(); // Faceți altceva)

În acest caz, vom citi valori până când Serial.available() returnează o valoare non-nulă. De îndată ce toate datele din buffer se termină, bucla se va opri.

bucla FOR în Arduino

În bucla FOR, avem posibilitatea nu numai să setăm condițiile limită, ci și să definim imediat o variabilă pentru contor, să indicăm cum se va schimba valoarea acesteia la fiecare iterație.

Sintaxa buclei FOR

Aici construcția va fi puțin mai complicată:
pentru (<начальное значение счетчика>;<условие продолжения выполнения цикла>;<изменение значения счетчика на каждом шаге>){
<список_команд>
}

Cel mai simplu exemplu:

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

Am creat imediat o variabilă, am inițializat-o, am indicat că la sfârșitul fiecărui ciclu, valoarea contorului ar trebui să crească cu unu. Și asta este tot - acum poți folosi variabila în interiorul buclei.

Pasul variabil poate fi diferit. Aici sunt cateva exemple:

• 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–) // Întoarce-te - de la 10 la 1

face bucla while

În unele cazuri, trebuie să organizăm bucla în așa fel încât instrucțiunile de bloc să fie executate cel puțin o dată, iar apoi verificarea este deja efectuată. Pentru astfel de algoritmi, puteți utiliza construcția do while. Exemplu:

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

Această versiune a buclei nu prezintă dificultăți - pur și simplu am mutat blocul cu condițiile în jos, astfel încât totul în interiorul acoladelor după instrucțiunea do va fi executat înainte de prima verificare.

continuați și întrerupeți declarațiile

Există situații în care trebuie să întrerupeți urgent execuția buclei în interiorul blocului de bucle, fără a aștepta să sari la blocul de verificare a stării. Pentru a face acest lucru, puteți utiliza operatorul pauză:

În timp ce (adevărat) ( ​​dacă (bifează Ceva ()) ( pauză; ) )

Dacă vrem doar să oprim progresul iterației curente, dar nu să ieșim din buclă, ci să mergem la blocul de verificare a condiției, atunci trebuie să folosim operatorul continua:

În timp ce (adevărat) ( ​​dacă (bifați Ceva()) (continuați; ))

Instrucțiunile continue și break pot fi folosite cu toate buclele FOR și WHILE.

Bucle imbricate în Arduino

Orice variante de cicluri pot fi ușor combinate între ele, realizând construcții imbricate. Variabilele definite în blocul buclei „supraiacente” vor fi disponibile în cea interioară. Cel mai obișnuit exemplu de acest tip de buclă este traversarea tablourilor bidimensionale. În exemplul următor, folosim o buclă dublă: prima va itera peste rândurile (variabila i), a doua, imbricată, coloanele (variabila j) ale matricei pe care am definit-o în variabila arr.

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

Mai multe despre cicluri

Dacă nu ați lucrat niciodată cu bucle, să ne aruncăm puțin în lumea teoriei și să ne dăm seama ce sunt buclele și de ce avem nevoie de aceste construcții de limbaj misterioase.

De ce avem nevoie de un ciclu

De fapt, sarcina principală a buclei este de a repeta aceleași construcții de limbaj de mai multe ori. O astfel de nevoie apare în aproape fiecare program și, cu siguranță, nicio schiță Arduino nu poate face fără un ciclu - funcția buclă () este numită și într-o buclă infinită.

Să ne uităm la următorul exemplu. Trebuie să alimentați simultan 5 LED-uri conectate la placa Arduino de la pinii 5 la 9. Cea mai evidentă opțiune pentru aceasta ar fi să plasați cinci instrucțiuni la rând:

digitalWrite(5, HIGH);

digitalWrite(6, HIGH);

digitalWrite(7, HIGH);

digitalWrite(8, HIGH);

digitalWrite(9, HIGH);

Deocamdată, să omitem întrebarea cu privire la riscul unei astfel de acțiuni, deoarece pornirea simultană a unui astfel de număr de LED-uri creează o sarcină crescută pe circuitul de alimentare al plăcii. Principalul lucru pentru noi acum este că am creat cinci linii de cod, fiecare dintre ele diferită de celelalte printr-o singură cifră. Această abordare are următoarele dezavantaje:

• Cu orice modificare, va trebui să faceți modificări la mai multe linii în același timp. De exemplu, dacă trebuie să comutăm LED-urile la pinii de la 2 la 6 sau să nu pornim, dar să oprim tensiunea, atunci va trebui să facem 5 modificări în cod. Și dacă sunt mai multe instrucțiuni și modificări?
• Codul voluminos cu un număr mare de instrucțiuni de același tip este incomod și neplăcut de citit. Cinci rânduri identice - nu foarte înfricoșătoare. Dar obiceiul de a folosi codul murdar va duce în cele din urmă la zeci și sute de pagini suplimentare în listă, ceea ce vă va scufunda atât pe dvs., cât și pe colegii dvs. în descurajare.
• În procesul de „copiere și lipire” instrucțiuni aproape identice, este ușor să faceți o greșeală, de exemplu, uitând să schimbați numărul de pini: digitalWrite(5, HIGH); digitalWrite(5, HIGH);
• Puteți eșua cu ușurință la un interviu la orice companie de software obișnuită, arătând intervievatorului un astfel de cod.

Din toate acestea, putem concluziona că utilizarea repetată a acelorași șiruri ar trebui aproape întotdeauna evitată și înlocuită cu bucle. Mai mult, în multe situații, ciclurile nu pot fi renunțate în principiu, nimic nu le poate înlocui. Nu puteți modifica numărul de repetări de cod în timp ce programul rulează. De exemplu, trebuie să procesați fiecare element matrice de date primit de la dispozitive externe. Nu veți prezice niciodată câte date vor fi, de câte ori să repetați prelucrarea și, prin urmare, nu veți putea introduce numărul necesar de instrucțiuni în momentul scrierii articolului.

Aici ciclurile vin în ajutor.

Reguli de sintaxă

Ciclu în Arduino- Acesta este un bloc de program special care va fi apelat de un anumit număr de ori în momentul execuției programului. În cadrul acestui bloc, descriem comenzile în sine care vor fi apelate și regulile prin care controlerul va determina de câte ori trebuie să fie apelate.

În exemplul nostru de mai sus, am putea spune următoarele controlerului:

Repetați comanda digitalScrie de 5 ori

Într-o lume ideală cu roboți programatori, acest lucru ar fi probabil suficient, dar deoarece vorbim cu un computer în C ++, trebuie să traducem această frază în acest limbaj:

Repetați comanda - trebuie să folosiți instrucțiuni speciale care să spună controlerului că ceva interesant este pe cale să înceapă cu while sau for loops

digitalWrite - lăsați-l așa cum este, dar scrieți-l o dată și includeți-l între paranteze. Cum să te ocupi de numerele PIN - chiar mai jos.

de 5 ori - foloseste un contor pentru asta, care va creste cu fiecare repetare. La începutul (sau la sfârșitul) blocului, puteți compara valoarea acestui contor cu valoarea limită (5 în acest caz) folosind o operație de comparare.

Să ne uităm la un exemplu de astfel de comandă buclă „tradusă” cu o instrucțiune while:

int counter = 0; // Variabilă pentru a stoca valoarea contorului // Solicităm procesorului să repete construcția între acolade până când condiția din paranteze revine adevărată. // În cazul nostru, contorul este contorul nostru, 5 este valoarea limită, condiția este că valoarea contorului este mai mică de 5. // Dar putem specifica operatori logici complet diferiți în timp ce (contorul< 5) { digitaWrite(5, HIGH); // Будем включать светодиод counter++; // Увеличиваем значение счетчика } // Дойдя до сюда, исполняющий процессор переместится в начало блока и опять займется проверкой условий. Если условия вернут истину, команды в блоке между { и } выполнятся еще раз. Если условие не выполнится - процессор переместится к концу блока и пойдет дальше. Этот цикл больше его не заинтересует.

Pentru cei care au observat o eroare în codul de mai sus, punem cinci și scriem blocul buclă într-un mod diferit:

În timp ce (contra< 5) { // Вот теперь мы будем включать разные светодиоды, с 5 (0+5) по 9 (4+5) digitalWrite(counter + 5, HIGH); counter++; }

Același rezultat poate fi obținut folosind o buclă FOR:

For(int counter =0; counter<5; counter ++){ digitalWrite(counter+5, HIGH); }

După cum puteți vedea, în acest caz, punem imediat toate operațiunile necesare cu contorul într-o singură instrucțiune FOR - aceasta este mult mai convenabilă dacă trebuie să numărați numărul necesar.

Puteți obține informații detaliate despre regulile de utilizare a ciclurilor în secțiunile relevante ale acestui articol.

Concluzie

În acest articol, ne-am uitat la constructe foarte importante ale limbajului Arduino: bucle FOR și WHILE. Veți putea întâlni acești operatori în aproape orice schiță mai mult sau mai puțin complexă, deoarece fără bucle, multe operațiuni de date ar fi imposibile. Nu este nimic complicat în sintaxa ciclurilor - vă puteți obișnui cu ele cu ușurință și le puteți utiliza activ în proiectele dvs.

Fiecare limbaj de programare are un set de instrucțiuni de control care asigură execuția multiplă a aceluiași cod (buclă), selectarea fragmentului de cod adecvat (condiții) și instrucțiuni pentru ieșirea din fragmentul de cod curent.

Arduino IDE a împrumutat majoritatea controalelor necesare de la C/C++. Sintaxa lor este identică cu C. Mai jos descriem pe scurt sintaxa lor.

declarația dacă

Instrucțiunea if vă permite să executați un anumit fragment de program în funcție de rezultatul verificării unei anumite condiții. Dacă condiția este îndeplinită, atunci codul programului va fi executat; dacă condiția nu este îndeplinită, atunci codul programului va fi omis. Sintaxa pentru comanda if este următoarea:

Dacă(condiție) ( declarație1; declarație2; )

O condiție poate fi orice comparație a unei variabile sau a unei valori returnate de o funcție. Principalul criteriu pentru condiția if este că răspunsul trebuie să fie întotdeauna adevărat (adevărat) sau fals (fals). Exemple de condiții pentru o declarație if:

Dacă(a!=2) ( ) dacă(x<10) { } if(znak==’B’) { }

În parantezele care sunt scrise în interiorul condiției, puteți executa codul.

Oamenii care încep să învețe programarea fac adesea greșeala de a echivala valoarea unei anumite variabile cu un singur semn „=". O astfel de înregistrare indică fără ambiguitate atribuirea unei valori unei variabile și, prin urmare, condiția va fi întotdeauna „adevărată”, adică va fi îndeplinită. Verificarea faptului că o variabilă este egală cu o anumită valoare se notează întotdeauna printr-un semn dublu egal (==).

Puteți utiliza starea unei funcții ca o condiție, de exemplu:

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

Exemplul de mai sus ar fi executat după cum urmează: primul pas este apelarea funcției init(). Această funcție returnează o valoare care va fi interpretată ca „adevărat” sau „fals”. În funcție de rezultatul comparației, se va trimite textul „ok” sau nu se va trimite nimic.

if...altfel afirmație

Instrucțiunea if extinsă este instrucțiunea if….else. Acesta asigură că o bucată de cod este executată atunci când condiția este adevărată (adevărată), iar a doua bucată de cod este executată dacă condiția nu este adevărată (falsă). Sintaxa instrucțiunii if….else este următoarea:

Dacă (condiție) ( // comanda A ) else ( // comanda B )

Comenzile „A” vor fi executate numai dacă condiția este îndeplinită, comanda „B” va fi executată atunci când condiția nu este îndeplinită. Executarea simultană a comenzii „A” și „B” nu este posibilă. Următorul exemplu arată cum se utilizează sintaxa if...else:

Dacă (init()) ( Serial.print("ok"); ) else ( Serial.print("eroare"); )

În acest fel, puteți verifica execuția corectă a funcției și puteți informa utilizatorul despre aceasta.

Practica obișnuită este de a anula condiția. Acest lucru se datorează faptului că o funcție care se execută corect returnează 0, în timp ce o funcție care eșuează dintr-un anumit motiv returnează o valoare diferită de zero.

Explicația pentru această „complicație a vieții” este simplă. Dacă funcția este executată corect, atunci aceasta este singura informație de care avem nevoie. În cazul unei erori, uneori merită să înțelegeți ce a mers prost, de ce funcția nu a fost executată corect. Și aici vin în ajutor numere care diferă de zero, adică, cu ajutorul codurilor digitale, putem determina tipul de eroare. De exemplu, 1 - o problemă cu citirea unei valori, 2 - nu există spațiu în memorie sau pe disc etc.

Ultimul exemplu modificat arată cum să apelați o funcție care returnează zero atunci când este executată corect:

Dacă (!init()) ( Serial.print("ok"); ) else ( Serial.print("eroare"); )

declarație switch case

Declarația if vă permite să verificați o singură condiție. Uneori este necesar să efectuați una dintre acțiuni în funcție de valoarea returnată sau citită. Declarația switch cu alegere multiplă este ideală pentru aceasta. Sintaxa comenzii de comutare este prezentată mai jos:

Comutare (var) ( cazul 1: // instrucțiune pentru var=1 pauză; cazul 2: // instrucțiune pentru var=2 pauză; implicit: // instrucțiune implicită (dacă var este diferită de 1 și 2) )

În funcție de valoarea variabilei var, instrucțiunile sunt executate în anumite blocuri. Eticheta cazului înseamnă începutul blocului pentru valoarea specificată. De exemplu, cazul 1: înseamnă că blocul dat va fi executat pentru valoarea variabilei var egală cu unu.

Fiecare bloc trebuie terminat cu comanda break. Întrerupe execuția ulterioară a instrucțiunii switch. Dacă comanda break este omisă, atunci instrucțiunile vor fi executate în blocurile ulterioare până la comanda break. Eticheta implicită este opțională, la fel ca și restul din instrucțiunea if. Instrucțiunile din blocul implicit sunt executate numai atunci când valoarea variabilei var nu se potrivește cu niciun model.

Se întâmplă adesea ca aceleași instrucțiuni să fie executate pentru una dintre mai multe valori. Acest lucru se poate realiza astfel:

Comutator (x) ( cazul 1: // instrucțiune pentru x=1 pauză; cazul 2: cazul 3: cazul 5: // instrucțiune pentru x=2 sau 3 sau 4 pauză; cazul 4: // instrucțiune pentru x=4 pauză ; cazul 6: // instrucțiune pentru x=6 pauză; implicit: // instrucțiune implicită (dacă x este diferit de 1,2,3,4,5,6) )

În funcție de valoarea variabilei x, se va executa blocul de instrucțiuni corespunzător. Repetarea cazului 2: caz 3: caz 5: informează compilatorul că dacă variabila x are valoarea 2 sau 3 sau 5, atunci aceeași bucată de cod va fi executată.

pentru declarație

Instrucțiunea for este folosită pentru a executa în mod repetat același cod. Adesea este necesar să se execute aceleași instrucțiuni, schimbând doar valoarea unei variabile. Bucla for este perfectă pentru asta. Sintaxa comenzii este următoarea:

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

Primul parametru dat în instrucțiunea for este valoarea inițială a variabilei. Un alt element este verificarea condiției pentru a continua execuția buclei. Bucla este executată atâta timp cât condiția este îndeplinită. Ultimul element este modificarea valorii variabilei. Cel mai adesea, îi creștem sau micșorăm valoarea (după nevoie). În acest exemplu, instrucțiunile conținute în buclă vor fi executate la i=0…9.

Adesea, o variabilă utilizată într-o buclă este declarată în același loc:

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

O variabilă care este folosită pentru a număra pașii buclei ulterioare poate fi folosită în interiorul acesteia pentru a apela o funcție cu parametrii corespunzători.

For(int i=10;i>0;i—) ( Serial.print(i); // vor fi trimise numerele 10,9,8,7,6,5,4,3,2,1)

în timp ce declarația

Bucla for este perfectă pentru unde vrem să facem numărătoarea. Într-o situație în care este necesar să se efectueze anumite acțiuni ca urmare a unui eveniment care nu este neapărat previzibil (de exemplu, așteptăm să fie apăsat un buton), atunci putem folosi instrucțiunea while, care execută blocul de instrucțiuni. atâta timp cât condiția este îndeplinită. Sintaxa instrucțiunii while este următoarea:

While(condiție) ( // bloc de instrucțiuni de executat )

Este important ca verificarea stării să aibă loc la începutul buclei. Se poate întâmpla ca instrucțiunile din bucla while să nu fie niciodată executate. De asemenea, este posibil să creați o buclă infinită. Să vedem două exemple:

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

Primul bloc de instrucțiuni din interiorul while nu va fi niciodată executat. Variabila x are valoarea doi și nu va deveni mai mare de 5. În al doilea exemplu, avem de-a face cu o buclă infinită. Variabila „y” are o valoare de 5, adică mai mare decât zero. În interiorul buclei, nu există nicio modificare a variabilei „y”, deci bucla nu se va termina niciodată.

Aceasta este o greșeală comună când uităm să modificăm parametrul care determină terminarea buclei. Următoarele sunt două exemple valide de utilizare a unei bucle while:

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

În primul exemplu, ne-am ocupat de modificarea valorii variabilei care este verificată în condiție. Ca urmare, ciclul se va încheia în cele din urmă. În al doilea exemplu, a fost creată în mod deliberat o buclă infinită. Această buclă este echivalentă cu funcția loop() din IDE-ul Arduino. În plus, în interiorul buclei este introdusă o verificare a stării, după care bucla se termină cu comanda break.

face...în timp ce declaraţia

O variație a buclei while este bucla do...while. Pe lângă sintaxă, diferă în locul în care este verificată condiția. În cazul do...while, condiția este verificată după ce blocul de instrucțiuni este executat. Aceasta înseamnă că blocul de instrucțiuni din corpul buclei va fi executat cel puțin o dată. Următoarea este sintaxa pentru comanda do...while:

Do ( // bloc de instrucțiuni ) while(condiție)

Tot ce este scris despre declarația while se aplică și pentru a face...while. Următorul este un exemplu de utilizare a unei bucle do...while:

intx=10; do ( // bloc de instrucțiuni x—; ) while(x>0); —————————————- do ( // bloc de instrucțiuni dacă(condiția) break; ) while(true);

declarație de pauză

Declarația break vă permite să părăsiți bucla (do...while, for, while) și să părăsiți opțiunea switch. În exemplul următor, luați în considerare execuția comenzii break:

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

Bucla ar trebui să fie executată pentru numerele de la 0 la 9, dar pentru numărul 5 este îndeplinită condiția, care declanșează instrucțiunea break. Aceasta va ieși din buclă. Ca urmare, numai numerele 0,1,2,3,4 vor fi trimise către portul serial (Serial.print).

continua declarația

Operatorul continue face ca instrucțiunile buclei (do...while, for, while) să se oprească din execuție pentru valoarea curentă și să treacă la pasul următor al buclei. Următorul exemplu arată cum funcționează instrucțiunea continue:

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

După cum puteți vedea, bucla va fi executată pentru o valoare de la 0 la 9. Pentru o valoare de 5, va fi executată comanda continue, drept urmare instrucțiunile de după această comandă nu vor fi executate. Ca urmare, numerele 0,1,2,3,4,6,7,8,9 vor fi trimise la portul serial (Serial.print).

declarație de returnare

Instrucțiunea return încheie execuția funcției apelate și returnează o valoare de un anumit tip. Ca parametru de comandă, puteți specifica un număr, un caracter sau o variabilă de un anumit tip. Este important ca valoarea returnată să se potrivească cu tipul funcției declarate. Următorul exemplu arată cum se utilizează instrucțiunea return:

Int checkSensor()( dacă (analogRead(0) > 400) ( // citește intrarea analogică returnează 1; // Pentru valori mai mari de 400, 1 este returnat altfel ( return 0; // pentru altele, 0 este returnat) )

După cum puteți vedea, puteți utiliza mai multe instrucțiuni return într-o singură funcție, dar numai una dintre ele va funcționa întotdeauna. Este permisă utilizarea instrucțiunii return fără parametri. Acest lucru vă permite să opriți prematur o funcție care nu returnează nicio valoare.

Void function_name() ( statement1; if(x==0) return; statement2; statement3; )

În exemplul de mai sus, statement1 se va executa ori de câte ori funcția este apelată. Execuția instrucțiunii2 și instrucțiunii3 depinde de rezultatul comenzii if. Dacă condiția este îndeplinită (adevărată), atunci comanda return va fi executată și funcția va ieși.

În cazul în care condiția nu este îndeplinită, nici comanda return nu este executată, dar instrucțiunile instruction2 și instruction3 sunt executate, iar după aceea funcția își încheie activitatea.

Goto declarație

Din motive ideologice, această descriere ar trebui sărită... Instrucția goto este o comandă care nu ar trebui folosită în programarea normală. Determină complexitatea codului și este un obicei prost de programare. Vă recomandăm insistent să nu utilizați această comandă în programele dumneavoastră. Datorită faptului că goto se află în documentația oficială de pe site-ul arduino.cc, vom oferi o scurtă descriere a acestuia. Sintaxa pentru comanda goto este:

…. du-te la etichetă; // sare la linia etichetată „metka” ….. …. …. metka: // etichetă unde programul va continua să funcționeze...

Comanda permite săritul la eticheta desemnată, adică la locația din program.

Astăzi vom studia o parte la fel de importantă a limbajului de programare ca buclele. Pentru ce sunt necesare. Să ne stabilim un obiectiv. Este necesar să aprindeți pe rând șase LED-uri cu o perioadă de 50 ms, apoi să le stingeți pe rând cu același interval. Ei bine, ce ar putea fi mai ușor. Scriem următorul cod:
void setup() ( pinMode(2, OUTPUT); pinMode(3, OUTPUT); pinMode(4, OUTPUT); pinMode(5, OUTPUT); pinMode(6, OUTPUT); pinMode(7, OUTPUT); ) bucla void () (digitalWrite(2, HIGH); delay(50); digitalWrite(3, HIGH); delay(50); digitalWrite(4, HIGH); delay(50); digitalWrite(5, HIGH); delay(50) ; digitalWrite(6, HIGH); delay(50); digitalWrite(7, HIGH); delay(50); digitalWrite(2, LOW); delay(50); digitalWrite(3, LOW); delay(50); digitalWrite (4, LOW); delay(50); digitalWrite(5, LOW); delay(50); digitalWrite(6, LOW); delay(50); digitalWrite(7, LOW); delay(50); ) În primul rând, a inițializat aproximativ șase pini digitali de la al doilea la al șaptelea ca ieșiri, iar în programul principal au scris alternativ pornirea LED-ului, întârzierea și așa mai departe de șase ori. După același lucru, dar de fiecare dată LED-ul a fost stins. Acum completăm Arduino și ne bucurăm de lucru. Dar totuși, ceva nu este în regulă aici. Dacă te uiți îndeaproape la codul programului, vei observa că există părți ale codului care se repetă pe tot parcursul programului. De exemplu, repetarea unei pauze ar trebui să-ți atragă imediat atenția. Și când pinii sunt inițializați, se schimbă doar numărul acestuia. Când îl porniți și dezactivați, se schimbă și numărul. Pentru un program atât de mic, desigur, îl puteți lăsa așa, controlerul îl va înghiți și nu se va sufoca, dar dacă trebuie să executați un cod care se repetă, de exemplu, de 1000 de ori. Cred că va fi suficientă răbdare pentru a-l umple, dar va avea MK suficientă memorie? Desigur, vă puteți întreba, de ce naiba avem nevoie de 1000 de operații identice? Ei bine, da, este greu de imaginat.) Dar asta nu este o problemă, dar dacă avem o serie de 1000 de celule. Acest lucru se întâmplă adesea, de exemplu, mai mulți senzori scriu parametri într-o matrice și cum spuneți să înțelegeți această mizerie. Ar fi necesar sa-l dezasamblam cumva dupa niste parametri. Pentru astfel de incidente au fost inventate ciclurile. O buclă este o bucată de cod care este executată de un anumit număr de ori. O parte a programului executată într-o buclă se numește iterație. Numărul de iterații poate fi de la 0 la infinit. Pentru a executa cicluri în limbajul de programare, există deja trei variante ale ciclului. Crede-mă, dar acest lucru este suficient pentru ochi pentru orice codare sofisticată. Să aruncăm o privire la toate acestea în detaliu.

• în timp ce (condiție) ()

• do () în timp ce(condiție);

• pentru (variabila de numărare; condiție; creșterea variabilă de numărare) ()

Primul ciclu în timp ce (condiție) (). Cum lucrează. După cuvânt in timp ce ar trebui să fie o condiție între paranteze. Condiția poate fi orice, atâta timp cât este adevărată. De îndată ce condiția devine falsă, bucla se va opri și programul va continua să funcționeze de la următoarea linie după buclă. Să luăm un exemplu.
char i = 0; in timp ce eu De fapt, ceea ce am scris aici. Mai întâi inițializam variabila de numărare iși resetați-l. Apoi, intrăm în buclă și începem să verificăm starea dintre paranteze. Dacă valoarea i mai puțin de 10, apoi executați corpul buclei. În corpul buclei în sine, creștem pur și simplu valoarea variabilei de numărare cu una și verificăm din nou condiția. În cazul nostru, bucla va fi executată de 10 ori. Adică mai întâi valoarea i este egal cu zero. Zero este mai puțin de zece. Apoi, am mărit variabila cu unu și am comparat, unul este mai mic de zece și așa mai departe. De îndată ce variabila de numărare devine egală cu zece, atunci verificăm dacă zece este mai mic de zece? Bineînțeles că nu, iar după verificare, bucla va înceta să funcționeze. Așa funcționează ciclul. Și ce se întâmplă dacă trebuie să executați codul în corpul buclei pentru o dată, chiar dacă nu se potrivește condiției. Există un alt ciclu pentru asta numit face () în timp ce (condiție). Funcționează exact la fel ca și ciclul anterior, cu excepția unui dar. În această buclă, corpul buclei este executat mai întâi și apoi are loc testul. Să vedem cum arată în cod.
char i = 0; face ( i++; ) while((i > 0) & (i Vezi cât de interesant. Mai întâi, ca și înainte, inițializam variabila de numărare cu zero, dar în condiția scriem asta i a fost mai mare de zero și mai mică de zece. Adică, valoarea variabilei trebuie să se situeze în intervalul de la unu la nouă. Dacă am fi scris astfel folosind bucla anterioară, atunci nu ar fi fost executată niciodată. Dar avem cuvântul magic do. Asta se va întâmpla. În primul rând, în corpul buclei, valoarea variabilei de numărare va crește și va deveni una, iar aceasta este mai mare decât zero, condiția va deveni adevărată. în consecință, bucla va continua să fie executată până când variabila de numărare devine egală cu zece. Și în sfârșit, a treia versiune a ciclului. Cum lucrează:
chari; pentru(i = 0; i Cum functioneaza. Mai întâi, inițiam din nou variabila de numărare, dar fără o valoare specifică. Apoi scriem cuvântul pentru, dar între paranteze scriem mai întâi variabila noastră de numărare și îi atribuim valoarea inițială. Apoi verificăm condiția și dacă este adevărată, executăm corpul buclei și creștem valoarea variabilei de numărare. În esență, acesta este același cu in timp ce()() deci ce buclă să utilizați depinde de dvs. Câteva cuvinte despre unele puncte. De exemplu, dacă scrii în timp ce(1);, atunci bucla va rula pentru totdeauna. Sau dacă cu pentru, atunci va arăta așa pentru(;;);. Atenție. Uneori, când executați o buclă, doriți doar să lăsați totul și să părăsiți, dar condiția nu permite acest lucru. Cum să fii? Există o altă comandă pentru asta pauză;. De îndată ce MK dă peste această comandă în corpul buclei, iese imediat din buclă și continuă execuția programului de la următoarea linie după buclă. Dar ce se întâmplă dacă, în timpul funcționării ciclului, apare o condiție care nu satisface condiția sau, de exemplu, un moment în care nu trebuie să continuăm să executăm sfârșitul corpului ciclului? Aici echipa ne va ajuta continua;. De îndată ce MK dă peste această comandă, renunță la totul și trece la execuția următoarei iterații a buclei. Sper că am explicat totul clar. Acum, după ce am primit aceste cunoștințe, să ne rescriem programul, dar folosind bucle.
void setup() ( octet i = 2; // Număr variabila while(i // Dacă i este mai mic de 8, atunci executați corpul buclei ( pinMode(i, OUTPUT); // Inițializați pinii începând cu 2 i++; // Crește variabila numărului cu una) ) bucla void() ( octet i = 2; while(i Să aruncăm o privire mai atentă. Mai întâi am inițializat variabila numărare iși i-a atribuit o valoare de doi. De ce doi? Și pentru că am ales în mod special ace de la al doilea până la al șaptelea, pentru a mă asigura că valoarea inițială nu contează. S-a dovedit un fel de joc de cuvinte) Ei bine, desigur, da. În continuare, scriem starea ciclului. Trebuie să facem șase iterații, deoarece avem șase LED-uri. Grozav, numărând doi plus șase este opt. Da, deci trebuie să verificăm variabila de numărare până când este mai mică de opt. Așa că au scris while (i . Acum bucla noastră va funcționa de șase ori. Ce trebuie să facem în corpul buclei. Da, nimic complicat, trebuie doar să introduceți funcția de inițializare a ieșirii la ieșire, doar înlocuiți variabila de numărare în loc de ieșire Care este focalizarea. De îndată ce MK intră în ciclul corpului, înainte de a efectua funcția de inițializare a ieșirii, să ne uităm la argumentele transmise. Unul dintre ele ar trebui să aibă numărul de ieșire și avem acolo o variabilă de numărare. de făcut? număr. Și avem un doi acolo. Ei bine, grozav, să inițializam a doua ieșire. După aceea, creștem valoarea variabilei de numărare cu încă una și verificăm condiția. Da, trei este mai puțin de opt, haideți faceți totul din nou și pentru totdeauna, doar că sunt trei în variabilă acum.Deci vom inițializa ieșirea pentru a treia, iar apoi vom crește variabila de numărare cu 1. În acest fel, trecând prin buclă, vom seta toate ieșirile de care avem nevoie. În plus, creșterea variabilei de numărare cu una nu este o condiție grea. Nimeni nu se deranjează să scrie de exemplu așa: i = ((127*i)/31) & 0xF4;Și acest lucru va funcționa și dacă condiția este adevărată după execuție. Pentru buclă, nu contează ce se întâmplă în corp, este interesat dacă condiția este adevărată sau nu. Asta e tot. În lecția următoare, vom analiza funcțiile, de ce sunt necesare și vom încerca să le scriem pe ale noastre.

/ /

Pentru declarație

Proiecta pentru folosit pentru a repeta un bloc de instrucțiuni cuprinse între acolade. Contorul de increment este de obicei folosit pentru a incrementa și a termina o buclă. Operator pentru potrivit pentru orice activitate repetitivă și este adesea folosit împreună cu matrice de colecții de date/ieșiri.

Antetul ciclului pentru constă din trei părți:

pentru (initializare; condiție; creştere) (instrucțiuni care se execută într-o buclă)

Inițializarea se efectuează mai întâi și o singură dată. De fiecare dată în buclă, condiția este verificată, dacă este adevărată, blocul de instrucțiuni și incrementul sunt executate, apoi condiția este verificată din nou. Când valoarea booleană a condiției devine falsă, bucla se termină.

Exemplu

// Diminuarea LED-ului folosind pinul PWM int PWMpin = 10; // LED-ul în serie cu un rezistor de 10 pini de 470 ohmi void setup() ( // nu este nevoie de configurare ) void loop() ( pentru (int i=0; i<= 255; i++){ analogWrite(PWMpin, i); delay(10); } }

Ciclu pentruîn C este mult mai flexibil decât buclele pentruîn alte limbaje de programare, cum ar fi BASIC. Oricare sau toate cele trei elemente de antet pot fi omise, deși sunt necesare puncte și virgulă. De asemenea, instrucțiunile pentru inițializare, condiții și incremente de buclă pot fi orice instrucțiuni variabile independente valide în C și pot folosi orice tip de date C, inclusiv date în virgulă mobilă (float). Acestea sunt neobișnuite pentru ciclu pentru Tipurile de operatori vă permit să oferiți o soluție programatică la unele probleme nestandard.

De exemplu, utilizarea înmulțirii într-o instrucțiune de contor bucle vă permite să creați o progresie logaritmică:

Pentru(int x = 2; x< 100; x = x * 1.5){ println(x); }

Generat: 2,3,4,6,9,13,19,28,42,63,94

Un alt exemplu este de a scădea sau crește fără probleme nivelul semnalului către LED cu un ciclu. pentru:

Void loop()( int x = 1; for (int i = 0; i > -1; i = i + x)( analogWrite(PWMpin, i); if (i == 255) x = -1; // control comutare la întârziere maximă (10); ) )

Proiecta pentru folosit pentru a repeta un bloc de instrucțiuni cuprinse între acolade. Contorul de increment este de obicei folosit pentru a incrementa și a termina o buclă. Operator pentru potrivit pentru orice activitate repetitivă și este adesea folosit împreună cu matrice de colecții de date/ieșiri.

Antetul ciclului pentru constă din trei părți:

pentru (initializare ; condiție ; creştere) (instrucțiuni care se execută într-o buclă)

Inițializarea se efectuează mai întâi și o singură dată. De fiecare dată în buclă, condiția este verificată, dacă este adevărată, blocul de instrucțiuni și incrementul sunt executate, apoi condiția este verificată din nou. Când valoarea booleană a condiției devine falsă, bucla se termină.

Exemplu

// Diminuarea LED-ului folosind pinul PWM int PWMpin = 10; // LED-ul în serie cu un rezistor de 10 pini de 470 ohmi void setup() ( // nu este nevoie de configurare ) void loop() ( pentru (int i=0; i<= 255; i++){ analogWrite(PWMpin, i); delay(10); } }

Ciclu pentruîn C este mult mai flexibil decât buclele pentruîn alte limbaje de programare, cum ar fi BASIC. Oricare sau toate cele trei elemente de antet pot fi omise, deși sunt necesare puncte și virgulă. De asemenea, instrucțiunile pentru inițializare, condiții și incremente de buclă pot fi orice instrucțiuni variabile independente valide în C și pot folosi orice tip de date C, inclusiv date în virgulă mobilă (float). Acestea sunt neobișnuite pentru ciclu pentru Tipurile de operatori vă permit să oferiți o soluție programatică la unele probleme nestandard.

De exemplu, utilizarea înmulțirii într-o instrucțiune de contor bucle vă permite să creați o progresie logaritmică:

Pentru(int x = 2; x< 100; x = x * 1.5){ println(x); }

Generat: 2,3,4,6,9,13,19,28,42,63,94

Un alt exemplu este de a scădea sau crește fără probleme nivelul semnalului către LED cu un ciclu. pentru:

Void loop() ( int x = 1; for (int i = 0; i > -1; i = i + x)( analogWrite(PWMpin, i); if (i == 255) x = -1; // control comutare la întârziere maximă (10); ) )