Arduino přejde na začátek programu podle podmínky. Arduino smyčky. Podmínka a větvení v textu programu

Design pro slouží k opakování bloku příkazů uzavřených ve složených závorkách. Čítač přírůstků se obvykle používá ke zvýšení a ukončení smyčky. Operátor pro Vhodné pro jakoukoli opakovanou činnost a často se používá ve spojení s poli sběru dat/výstupů.

Záhlaví smyčky pro se skládá ze tří částí:

pro (inicializace ; stav ; přírůstek) (operátory prováděné ve smyčce)

Inicializace se provádí jako první a pouze jednou. Pokaždé v cyklu se zkontroluje podmínka, pokud je pravdivá, provede se blok příkazů a přírůstek, pak se podmínka zkontroluje znovu. Když se booleovská hodnota podmínky stane nepravdivou, smyčka skončí.

Příklad

// Stmívání LED pomocí PWM pin int PWMpin = 10; // LED v sérii s 470 ohmovým rezistorem pro 10 pinů void setup() ( // není potřeba žádné nastavení) void loop() ( for (int i=0; i<= 255; i++){ analogWrite(PWMpin, i); delay(10); } }

Cyklus pro C je mnohem flexibilnější než smyčky pro v jiných programovacích jazycích, například BASIC. Kterýkoli nebo všechny tři prvky záhlaví mohou být vynechány, ačkoli středníky jsou povinné. Příkazy pro inicializaci smyčky, podmíněné a inkrementační příkazy mohou být také jakýmkoli platným příkazem C s nezávislými proměnnými a mohou používat jakýkoli datový typ C, včetně floats. Ty jsou pro cyklus neobvyklé pro typy operátorů umožňují poskytnout softwarové řešení některých nestandardních problémů.

Například použití násobení v operátoru čítače smyčky vám umožní vytvořit logaritmickou progresi:

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

Vygenerováno: 2,3,4,6,9,13,19,28,42,63,94

Jiný příklad, plynulé snížení nebo zvýšení úrovně signálu na LED pomocí jednoho cyklu pro:

Void loop())( int x = 1; for (int i = 0; i > -1; i = i + x)( analogWrite(PWMpin, i); if (i == 255) x = -1; / / ovládání spínání při maximálním zpoždění(10); ) )

Záhlaví smyčky pro se skládá ze tří částí:

pro (inicializace ; stav ; přírůstek) (operátory prováděné ve smyčce)

Příklad

Například použití násobení v operátoru čítače smyčky vám umožní vytvořit logaritmickou progresi:

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

Vygenerováno: 2,3,4,6,9,13,19,28,42,63,94

Jiný příklad, plynulé snížení nebo zvýšení úrovně signálu na LED pomocí jednoho cyklu pro:

Void loop() ( int x = 1; for (int i = 0; i > -1; i = i + x)( analogWrite(PWMpin, i); if (i == 255) x = -1; // ovládání spínání při maximálním zpoždění(10); ) )

“, jsme se naučili používat smyčku „for“ k organizaci provozu ovladače. Tento typ smyčky se používá všude a více než pokrývá „potřebu operací smyčkování“. Existuje však další typ smyčky - "zatímco". Není to o nic lepší než smyčka for, jen používá jiné principy.

Ve většině případů si můžete vybrat, který ze dvou typů smyček použijete. V jsme použili "zatímco" pro pozastavení programu, dokud uživatel nezadá požadovaná data. V této lekci se blíže podíváme na to, jak tato smyčka funguje na příkladu platformy Arduino.

Pokračujme v práci s obvodem, který se skládá ze 2 LED.

Kromě toho budeme pokračovat v práci s kódem, který jsme dokončili v lekci 14.

Zpátky do minulosti: regulátor vyzve uživatele k zadání dat, čeká na vstup a výsledné hodnoty pak přiřadí proměnným blinkNumberGreen A blinkNumberČervená. To umožňuje uživateli ovládat, kolikrát každá ze 2 LED blikne.

Chcete-li rozšířit světonázor programátora, stojí za to naučit se používat dva typy smyček k implementaci stejných úkolů a v budoucnu můžete prokázat sympatie k jednomu nebo druhému typu.

Pojďme zjistit, jak to funguje:

int z= 1; // deklarujeme proměnnou a přiřadíme jí hodnotu 1

zatímco (z<=10) { //запускаем цикл zatímco

Seriál. println(z); //vypíše aktuální hodnotu proměnnéz přes sériový port

z= z+1 // zvýšení hodnoty proměnnézod 1

) // ukončení smyčky

Cyklus while bude pokračovat ve vykonávání příkazů, dokud platí „podmínka“ popsaná v závorkách. Ve výše uvedeném příkladu bude smyčka pokračovat ve vykonávání příkazů, dokud z bude menší nebo rovno 10. Tělo smyčky provádí 2 příkazy:

Výstup hodnoty proměnné přes sériový port;
Zvýšení hodnoty proměnné o 1 (vědecky nazývané inkrementace).

Zvýšením hodnoty proměnné program nakonec smyčku opustí. Pokud si na vteřinu představíme, že jsme zapomněli specifikovat tento řádek nebo dojde k nějakému selhání, pak program vesele přejde do smyčky (jinými slovy zamrzne).

Smyčka začíná svou práci kontrolou pravdivosti podmínky. Pokud je z menší nebo rovno 10, pak program spustí smyčku. Poté se znovu zkontroluje stav atd. Když hodnota proměnné dosáhne z = 11, podmínka již nebude pravdivá. Program neprovede smyčku a přejde na další řádek bezprostředně za smyčkou složenou závorkou.

Dost teorie, přejděme k praxi. Nahraďte cykly for ve zdrojovém kódu cykly while.

Blikač prováděný cyklem FOR:

for (int i = 1; i<= blinkNumberGreen; i++) // zahájení cykluspro

{

Seriál. tisk("Zelená bliká");

Serial.println(i);

digitalWrite(zelenáLed, HIGH); //zapnout zelená Světelná dioda

delay(timeOnGreenLed); //počkáme

digitalWrite(zelenáLed, NÍZKÁ); //vypnout zelená Světelná dioda

delay(timeOffGreenLed); //počkáme

}

Blikač v cyklu WHILE:

int i=1; //deklarujte proměnnou a přiřaďte jí hodnotu 1

zatímco já<= blinkNumberGreen)

{ // zahájení cykluszatímco

Serial.print("Zelená zamrkal «);

Serial.println(i);

digitalWrite(zelenáLed,HIGH); //zapnout zelená Světelná dioda

delay(timeOnGreenLed); //počkáme

digitalWrite(zelenáLed,LOW); //vypnout zelená Světelná dioda

delay(timeOffGreenLed); //počkáme

i= i+1 //zvýší hodnotu proměnné o 1

}

Uložte program a nahrajte firmware do ovladače. Podívejme se na výsledek.

Smyčky pomocí příkazů pro A zatímco jsou jedním z nejdůležitějších konstruktů jazyka C++, který je základem Arduina. Nacházejí se v naprosto každé skice, i když o tom nevíte. V tomto článku se na smyčky podíváme blíže, zjistíme, jaký je rozdíl mezi for a while, jak si s jejich pomocí můžete zjednodušit psaní programu a jakých chyb se vyvarovat.

Pokud jste stále začínající programátor a chcete pochopit, co je smyčka a proč je potřeba, podívejte se na další část tohoto článku s podrobným popisem.

Operátor WHILE se používá v C++ a Arduinu k opakování stejných příkazů v libovolném počtu. Oproti cyklu FOR vypadá cyklus WHILE jednodušeji, používá se většinou tam, kde nepotřebujeme počítat počet iterací v proměnné, ale stačí opakovat kód, dokud se něco nezmění nebo nenastane nějaká událost.

Syntaxe WHILE

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

Jako podmínky lze použít jakoukoli jazykovou konstrukci, která vrací booleovskou hodnotu. Podmínky mohou být porovnávací operace, funkce, konstanty, proměnné. Stejně jako u jiných logických operací v Arduinu bude jakákoli hodnota jiná než nula vnímána jako pravda, nula – nepravda.

// Nekonečná smyčka while(true)( Serial.println("Waiting..."); ) // Smyčka, která běží, dokud se nezmění hodnota funkce checkSignal() while(!checkSignal())( Serial.println ("Čekání..."); )

Všimněte si, že příkaz while lze použít bez blokování bloku složenými závorkami, v takovém případě se bude opakovat první příkaz, na který se po smyčce narazí. Důrazně se nedoporučuje používat bez složených rovnátek, protože v tomto případě je velmi snadné udělat chybu. Příklad:

While(true) Serial.print("Čekání na přerušení"); zpoždění(1000);

V tomto případě se nápis zobrazí v nekonečné smyčce bez pauz, protože příkaz delay(1000) se nebude opakovat. Chytáním takových chyb můžete strávit spoustu času - je mnohem jednodušší použít složenou ortézu.

Příklad použití zatímco smyčka

Nejčastěji se while používá k čekání na nějakou událost. Například připravenost objektu Serial k práci.

Serial.begin(9600); while (!Serial) ( ; // Některé desky Arduino vyžadují, abyste počkali, dokud se sériový port neuvolní)

Příklad čekání na příchod postavy z externích zařízení přes UART:

While(Serial.available())( int byteInput = Seria.read(); // Některé další akce)

V tomto případě budeme číst hodnoty, dokud Serial.available() vrací nenulovou hodnotu. Jakmile dojdou všechna data ve vyrovnávací paměti, smyčka se zastaví.

smyčka FOR v Arduinu

Ve smyčce FOR máme možnost nejen nastavit okrajové podmínky, ale také rovnou definovat proměnnou pro čítač a udávat, jak se budou jeho hodnoty při každé iteraci měnit.

Syntaxe smyčky FOR

Zde bude design trochu složitější:
pro (<начальное значение счетчика>;<условие продолжения выполнения цикла>;<изменение значения счетчика на каждом шаге>){
<список_команд>
}

Nejjednodušší příklad:

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

Okamžitě jsme vytvořili proměnnou, inicializovali ji a naznačili, že na konci každého cyklu by se hodnota čítače měla zvýšit o jednu. A je to – nyní můžete použít proměnnou uvnitř smyčky.

Variabilní krok může být odlišný. Zde jsou příklady:

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–) // Přejít zpět – z 10 na 1

udělat while smyčku

V některých případech potřebujeme zorganizovat smyčku tak, aby byly instrukce bloku provedeny alespoň jednou a poté byla provedena kontrola. Pro takové algoritmy můžete použít konstrukci do while. Příklad:

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

Tato verze smyčky nepředstavuje žádné potíže - jednoduše jsme přesunuli blok s podmínkami dolů, takže veškerý obsah uvnitř složených závorek po operátoru do bude proveden před první kontrolou.

Pokračujte a přerušte příkazy

Existují situace, kdy potřebujete naléhavě přerušit provádění smyčky uvnitř bloku smyčky, aniž byste čekali na přechod do bloku kontroly stavu. K tomu můžete použít operátora přestávka:

Zatímco (true) (if (checkSomething()) ( break; ) )

Pokud chceme jednoduše zastavit průběh aktuální iterace, ale neopustit smyčku, ale přejít do bloku kontroly stavu, musíme použít operátor pokračovat:

Zatímco (true) (if (checkSomething()) (pokračovat; ) )

Příkazy continue a break lze použít se všemi variantami cyklů FOR a WHILE.

Vnořené smyčky v Arduinu

Jakékoli varianty smyček lze mezi sebou snadno kombinovat a vytvářet tak vnořené struktury. Proměnné definované v bloku „překrývající“ smyčky budou dostupné ve vnitřní. Nejběžnějším příkladem tohoto druhu smyčky je procházení dvourozměrných polí. V následujícím příkladu použijeme dvojitou smyčku: první bude iterovat řádky (proměnná i), druhá, vnořená, bude procházet sloupci (proměnná j) pole, které jsme definovali v proměnné 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]); } } }

Více o cyklech

Pokud jste nikdy nepracovali se smyčkami, pojďme se ponořit trochu do světa teorie a přijít na to, co jsou smyčky a proč potřebujeme tyto tajemné jazykové konstrukty.

Proč potřebujeme smyčku?

Ve skutečnosti je hlavním úkolem smyčky několikrát opakovat stejné jazykové konstrukce. Tato potřeba se objevuje téměř v každém programu a rozhodně se bez smyčky neobejde ani jeden náčrt Arduina – funkce loop() se také volá v nekonečné smyčce.

Podívejme se na následující příklad. Musíte napájet současně 5 LED připojených k desce Arduino z pinů 5 až 9. Nejviditelnější možností by bylo umístit pět instrukcí za sebou:

digitalWrite(5, VYSOKÝ);

digitalWrite(6, VYSOKÝ);

digitalWrite(7, VYSOKÝ);

digitalWrite(8, VYSOKÝ);

digitalWrite(9, VYSOKÝ);

Pomiňme nyní otázku rizikovosti takové akce, protože současné zahrnutí takového počtu LED vytváří zvýšené zatížení napájecího obvodu desky. Pro nás je nyní hlavní, že jsme vytvořili pět řádků kódu, z nichž každý se od ostatních liší pouze jednou číslicí. Tento přístup má následující nevýhody:

Při jakékoli změně budete muset provést změny na mnoha řádcích současně. Pokud například potřebujeme přepnout LED na piny 2 až 6 nebo místo zapnutí vypnout napětí, budeme muset provést 5 změn v kódu. Co když existuje více pokynů a změn?
Velký kód s velkým množstvím podobných instrukcí je nepohodlný a nepříjemný na čtení. Pět stejných čar není příliš děsivé. Zvyk špinavého kódu však nakonec povede k dalším desítkám a stovkám stránek ve výpisu, což vás i vaše kolegy uvrhne do zoufalství.
V procesu „kopírování a vkládání“ téměř identických pokynů můžete snadno udělat chybu, například zapomenout změnit číslo PIN: digitalWrite(5, HIGH); digitalWrite(5, VYSOKÝ);
Můžete snadno propadnout pohovoru v jakékoli normální softwarové společnosti, když tazateli ukážete tento kód.

Z toho všeho můžeme usoudit, že opakovanému používání stejných strun znovu a znovu je třeba se téměř vždy vyhnout a nahradit je smyčkami. Navíc se v mnoha situacích bez cyklů neobejdete, nic je nenahradí. Počet opakování kódu za běhu programu nelze změnit. Například musíte zpracovat každý prvek datové pole, přijaté z externích zařízení. Nikdy nebudete předvídat, kolik dat bude, kolikrát se zpracování bude opakovat, a proto v době psaní článku nebudete moci vložit požadovaný počet instrukcí.

A tady nám pomáhají cykly.

Pravidla syntaxe

Smyčka v Arduinu je speciální programový blok, který bude během provádění programu volán několikrát. V rámci tohoto bloku popisujeme samotné příkazy, které budou volány, a pravidla, podle kterých bude kontrolér určovat, kolikrát je třeba je volat.

V našem příkladu výše bychom mohli říci ovladači následující:

Opakujte příkaz digitalWrite 5krát

V ideálním světě s programátory robotů by to asi stačilo, ale protože mluvíme s počítačem v C++, musíme tuto frázi přeložit do tohoto jazyka:

Opakujte příkaz – musíte použít speciální instrukce, které ovladači sdělí, že začne něco zajímavého se smyčkami while nebo for

digitalWrite – nechte to tak, jak to je, ale napište to jednou a uzavřete to do složených závorek. Co dělat s čísly PIN - níže.

5 krát – použijte k tomu počítadlo, které se bude s každým opakováním zvyšovat. Na začátku (nebo na konci) bloku můžete porovnat hodnotu tohoto čítače s limitní hodnotou (v tomto případě 5) pomocí porovnávací operace.

Podívejme se na příklad takového „přeloženého“ příkazu smyčky s příkazem while:

Int čítač = 0; // Proměnná, která bude ukládat hodnotu čítače // Požádáme procesor, aby opakoval konstrukci ve složených závorkách, dokud podmínka v závorce nevrátí hodnotu true. // V našem případě je čítač náš čítač, 5 je limitní hodnota, podmínkou je, aby hodnota čítače byla menší než 5. // Můžeme ale zadat zcela jiné logické operátory while (čítač< 5) { digitaWrite(5, HIGH); // Будем включать светодиод counter++; // Увеличиваем значение счетчика } // Дойдя до сюда, исполняющий процессор переместится в начало блока и опять займется проверкой условий. Если условия вернут истину, команды в блоке между { и } выполнятся еще раз. Если условие не выполнится - процессор переместится к концу блока и пойдет дальше. Этот цикл больше его не заинтересует.

Pro ty, kteří si všimli chyby v daném kódu, dáme pětku a blok smyčky zapíšeme jinak:

Zatímco (počítadlo< 5) { // Вот теперь мы будем включать разные светодиоды, с 5 (0+5) по 9 (4+5) digitalWrite(counter + 5, HIGH); counter++; }

Stejného výsledku lze dosáhnout pomocí smyčky FOR:

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

Jak vidíte, v tomto případě všechny potřebné operace s počítadlem okamžitě umístíme do jedné instrukce FOR - to je mnohem pohodlnější, pokud potřebujete spočítat požadované množství.

Podrobné informace o pravidlech používání smyček získáte v příslušných částech tohoto článku.

Závěr

V tomto článku jsme se podívali na velmi důležité konstrukce jazyka Arduino: smyčky FOR a WHILE. Tyto operátory můžete najít téměř v každé více či méně složité skice, protože bez smyček by mnoho operací s daty nebylo možné. V syntaxi smyček není nic složitého - snadno si na ně zvyknete a můžete je aktivně používat ve svých projektech.

/ /

Pro operátora

Záhlaví smyčky pro se skládá ze tří částí:

pro (inicializace; stav; přírůstek) (operátory prováděné ve smyčce)

Příklad

Například použití násobení v operátoru čítače smyčky vám umožní vytvořit logaritmickou progresi:

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

Vygenerováno: 2,3,4,6,9,13,19,28,42,63,94

Jiný příklad, plynulé snížení nebo zvýšení úrovně signálu na LED pomocí jednoho cyklu pro:

Void loop())( int x = 1; for (int i = 0; i > -1; i = i + x)( analogWrite(PWMpin, i); if (i == 255) x = -1; / / ovládání spínání při maximálním zpoždění(10); ) )