Arduino zůstane zapnuté hodinu. Arduino má spoustu úkolů pro další funkci milis. Funkce Vikoristannya arduino delay

Pokud chcete mikrokontrolér „pozastavit“, stačí zadat instrukci zpoždění na požadované místo programu. To je užitečný nástroj, pokud chcete použít jiná slova, jako je stisknutí tlačítka. A zde je potřeba implementovat jakýsi multitasking.

Takže přidáním několika řádků kódu do vašich programů z vás zase udělá lepší programátor a zvýší potenciál vašeho Arduina. K tomu se musíte naučit používat funkci milis.

Pokud si uvědomíte, že funkci zpoždění používá váš program Arduino, nebude v tuto hodinu vůbec fungovat. Namísto dlouhého absolvování celého našeho programu se dozvíme, kolik hodin uplynulo před dokončením. To samozřejmě spoléhá na další funkci millis() a mnoho skvělých přátel, kteří zachraňují naše data. Aby bylo vše dobře srozumitelné, začneme od prvního počátečního náčrtu s názvem „Blink“ a v tomto případě jej osvětlíme LED bez stínění.

Jádro tohoto programu je stejné jako jakýkoli jiný standardní program pro Arduino. Nyní jsou všechny požadované vstupní/výstupní řádky vymazány (například řádek 13 pro LED). Zde budeme také potřebovat měnič typu integer, abychom zachránili výrobní linku LED. Bude nastaveno na LOW a zbývající části LED zhasnou. Pak tomu říkejme "previousMillis" až po typ "unsigned long". V případě „int“ dlouhé změny bez znaménka představují 32 bitů, což je potřeba pro změny, které mohou být ještě větší – protože existuje potenciální hodina, kterou můžeme najít před dokončením akce. Změnit předchozíMillis se použije k úspoře času, když se LED světlo znovu rozsvítí. Stejný typ je „const long“, je také 32bitový, ale nemění hodnotu, jako je tomu u konstant (v tomto případě u intervalové konstanty). Nastavili jsme to na 1000 a vikorystvo jako hodinu pauzy, která se měří v milisekundách.

Pak se dostáváme do nekonečného cyklu. Pamatujte, že místo stínování chceme obnovit, kolik hodin uplynulo od okamžiku našeho posledního okamžiku, v našem případě 1000 ms. Jakmile pokyny pominou, nadešla hodina změnit nastavení naší přisvětlovací diody.

Nejprve vložíme dlouhé „aktuální milisekundy“ nebo „millis()“ bez znaménka, což znamená aktuální hodinu v milisekundách. To nám pomůže pochopit, že rozdíl mezi přesnou hodinou a pokročilou hodinou je 1000 ms. Pro koho říkáme: „Pokud je přesná hodina mínus předchozí hodina, pokud naše LED svítí, větší nebo rovna naší přiřazené hodnotě 1000 ms, uložte hodinu zbývající okamžité minuty jako předchozí. To nám pomůže odhadnout, kolik hodin uplynulo od poslední minuty cyklu. Poté, pokud se LED rozsvítí LOW, nastavte ji na HIGH, v opačném případě nastavte na LOW. Poté pomocí příkazu digitalWrite připojte řezací frézu k LED.

Začátečník, který ovládá Arduino, se v první řadě potýká s tím, že síla funkce delay() je nepřijatelná – blokování programů. Na internetu je spousta aplikací, které tuto funkci využívají, ale praktická stagnace naznačuje, že by bylo lepší se bez ní obejít.

Jako nováček jsem si postavil vlastní kolo s implementací neblokovacího zámku. Vesnice stála takto:

• Zajistěte pseudomonitorování, aby byly různé fáze dokončeny ve svém vlastním čase, v jejich vlastních intervalech a vzájemně se neblokovaly.
• Bulo obratně koristuvatsya tsim.
• Mohl by být navržen jako knihovna a snadno zahrnovat další projekty bez kopírování.

Výsledkem bylo toto.

#zahrnout SmartDelay foo (1000000UL); // v mikrosekundách void loop () ( if (foo.Now()) ( // Kód je zde založen na intervalu v mikrosekundách, hodnoty v konstruktoru jsou větší. ) // Více kódu )
Metoda Now() vrátí hodnotu true, protože interval již uplynul. A zde opět začíná stejný interval. Nyní se tedy Now() „nabíjí“ automaticky.

Klasické blikající LED světlo lze najednou zredukovat na blikající světlo. Například žárovky jsou připojeny ke spodkům 12 a 11 a rozsvěcují se pokaždé v intervalech 1 s a 777 ms.

#zahrnout SmartDelay led12(1000000UL); SmartDelay led11(777000UL); setup () ( pinMode(12,OUTPUT); pinMode(11,OUTPUT); ) byte led12state=0; byte led11state=0; void loop () ( if (led12.Now()) ( digitalWrite(12,led12state); led12state=!led12state; ) if (led11.Now()) ( digitalWrite(11,led11state); led11state=!led11state; ))
Cyklus lze také nakonfigurovat tak, aby rozsvítil LED diody bez blokování kódu.

Je jasné, že se jedná o úplnou náhradu delay(), která zpomaluje tok úloh a vyžaduje, abyste program napsali jako MCA (mechanismus koncového stroje). Pro uložení kroku a jiným způsobem přejděte na požadované místo pro kód.

Stará verze:

Akce1(); zpoždění(1000); akce2(); zpoždění(500); akce3(); ...
Nová možnost:

Stav bytu = 0; SmartDelay d(); ... switch (state) ( case 0: action1(); d.Set(1000000UL); state=1; break; case 1: if (d.Now()) ( action2(); d.Set(500000UL) ) stav=2; ) přerušení; případ 2: if (d.Now()) ( action3(); d.Stop(); state=0; ) break; )...
Metoda Set(interval) nastaví nový interval a otočí starý. Na interval se můžete jednoduše podívat pomocí metody Get();

Stop() resetuje zpracování a Now() opět změní hodnotu na hodnotu false.

Start() obnoví práci a Now() začne pracovat jako předtím.

Pokud potřebujete na hodinu zpomalit, místo abyste se úplně zastavili, použijte metodu Wait(). Pokud například LED 12 svítí, ale po stisknutí tlačítka nesvítí, stačí do loop() v aplikaci s dalšími dvěma diodami přidat následující kód:

If (digitalRead(9)) led12.Wait(); ...
Takže s vysokou úrovní signálu na 9 č., dioda na 12 nebude významná a nebude pokračovat, pokud se objeví 0.

Pokud je za takovým „časovačem“ například obrazovka a tlačítka jsou namalována paralelně, pak je nutné po stisknutí tlačítka namalovat obrazovku nebo část obrazovky a nečekat na konec intervalu. K tomuto účelu se používá metoda Reset(), po každém útoku se volání Now() změní na true. Například:

Displej SmartDelay (1000000UL); void loop() ( if (btClick()) display.Reset(); // když kliknete na tlačítko, musíte vymalovat obrazovku. if (display.Now()) screenRedraw(); // vymalovat obrazovku .)
Chyby jsou pouze v tom, že mikrosekundový healer není pokryt, ale jinak je potřeba kód vyčistit. Nelíbí se mi to, protože Reset() je nefunkční, stále přemýšlím.

Funkce millis() umožňuje změnit hodinu, která uplynula od spuštění programu s vlákny. Funkce otáčí hodnoty v dlouhém formátu bez znaménka a umožňuje zadávat hodnoty až 50 dní od okamžiku spuštění programu. Po této hodině to začne znovu. Níže je uveden příklad funkce millis():

Dlouho nepodepsané; void setup())( Serial.begin(9600); ) void loop())( Serial.print("On hour: "); time = millis(); // zapamatovat si hodinu Serial.println(time); / / odeslání informací přes sériový port zpoždění (1000);

U vybrané aplikace obdrží port monitoru každou sekundu informaci o hodině, která uplynula od okamžiku spuštění programu. Zatímco hodina se měří v milisekundách, hodnota skinu bude dělena 1000. Přesnost čtení závisí na stabilitě quartz rezonátoru Arduino.

Funkce micros()

Funkce micros() je obdobou funkce millis(), rozdíl je v přesnosti měření. Dodatečná funkce micros() trvá v mikrosekundách hodinu, která uplyne od spuštění programu vlákna. Doktor obnovených mikrosekund bude odstraněn po 70 minutách. Níže je uveden příklad funkce micros():

Dlouho nepodepsané; void setup())( Serial.begin(9600); ) void loop())( Serial.print("Hodina při spuštění: "); time = micros(); Serial.print(time); Serial.println(" µs ) "); zpoždění (1000); )

Stejně jako v aplikaci s funkcí millis() bude informace o aktuální hodině odesílána na port monitoru každou sekundu, rozdíl je pouze v tom, že v tomto případě se hodina měří v mikrosekundách.

Funkce delay()

Funkce delay() vám umožňuje odložit spuštění programu s vlákny o určitou hodinu. Syntaxe příkazu vypadá takto:

// Zpoždění příkazu (500); // Vypnutí na 0,5 sec // Zpoždění příkazu (1000); //Vypnutí na 1s

Hodina je indikována v milisekundách (1 s = 1000 ms). Tento parametr může být typu unsigned long, který je v rozsahu od 0 do 4294967295. Níže je uveden příklad příkazu delay():

#define ledPin 13 void setup() ( pinMode(ledPin,13); ) void loop() ( digitalWrite(ledPin,HIGH); //zapnutí zpoždění LED(500); //kontrola 500 ms (0,5 s) digitalWrite( ledPin ,LOW); //zpoždění LED sepnutí (1000); //přepnutí 1000 ms (1 s)

Když je aplikace namířena, LED se rozsvítí na 0,5 sekundy, poté na 1 sekundu zhasne a tak dále, dokud se Arduino nezapne.

Funkce delayMicroseconds()

Funkce delayMicroseconds() je typem funkce delay(). Rozdíl závisí na množství a přesnosti v závislosti na hodině. Funkce delay() umožňuje upravit hodinu s přesností až na 1 milisekundu, stejně jako delayMicroseconds() s přesností až 1 mikrosekundu.

Hodnoty, které lze zadat v parametru, jsou v rozsahu od 0 do 16383. Pro delší časové intervaly můžete použít funkci delay() nebo použít delayMicroseconds() několikrát.

#define outPin 8 void setup() ( pinMode(outPin, OUTPUT); // pin 8 jako výstup ) void loop() ( digitalWrite(outPin, HIGH); // pin 8 vysoké zpožděníMicroseconds(50); // pauza 50 mikrosekund digitalWrite(outPin, LOW); // pin 8 nízké zpožděníMicroseconds(50); // pauza 50 mikrosekund)

Toto zařízení generuje meandr s periodou 100 mikrosekund a mírou plnění 50 %.

Ozdoby v Arduinu hrají velmi důležitou roli. Bez nich nelze pracovat s nejjednodušším zařízením Blink, které po určitou dobu svítí LED diodou. Ale většina začínajících programátorů ví jen málo o časových prodlevách a používá pouze Arduino delay, aniž by znali vedlejší účinky tohoto příkazu. V tomto článku budu hovořit o funkcích hodin a vlastnostech jejich použití v jádru Arduino IDE.

V Arduinu existuje řada různých příkazů, které indikují práci s hodinou a pauzou:

• zpoždění()
• delayMicroseconds()
• milis()
• micros()

Liší se přesností a rozvíjejí své vlastní vlastnosti, stejně jako při psaní kódu.

Funkce Vikoristannya arduino delay

Syntax

Arduino delay je nejjednodušší příkaz a je nejčastěji používaným začátečníky. V podstatě se jedná o vypnutí, které spustí robota s programem, v ramenech je uveden počet milisekund. (Jedna sekunda je 1000 milisekund.) Maximální hodnota může být 4294967295 ms, což je přibližně 50 dib. Podívejme se na jednoduchý příklad, který robotovi tyto příkazy názorně ukazuje.

Void setup() ( pinMode(13, OUTPUT); ) void loop() ( digitalWrite(13, HIGH); // odeslání vysokého signálu na pin 13 zpoždění (10000); // pauza 10000 ms nebo 10 sekund digitalWrite13, LOW) ; // odešle nízký signál na 13 pin delay (10000); // pauza 10 000 ms nebo 10 sekund)

U metody založit Uvádí se, že po 13 bude vikorystuvatsya jako východisko. V hlavní části programu je na pin vyslán vysoký signál, poté zpoždění 10 sekund. Na tuto hodinu se program zastaví. Poté je vydán nízký signál a vypínání se spustí znovu a vše se spustí znovu. V důsledku toho můžeme určit, že se na pin posílá buď 5, nebo 0.

Je nutné jasně pochopit, že během hodiny pauzy po dodatečném zpoždění se spustí program robota, program neodstraní potřebná data ze senzorů. To je největší nedostatek funkce delay v Arduinu. Tuto burzu můžete obejít pro další přerušení, ale o tom budeme mluvit ve statistikách.

Delay zadek s LED světly

Příklad obvodů pro ilustraci funkce zpoždění.
Můžete použít obvod s LED a rezistorem. Poté uvidíme standardní zadek - LED bliká. Chcete-li to provést, na kolíku, který jsme označili jako výstupní, musíte připojit LED ke kladnému kontaktu. LED nohu připojím přes odpor přibližně 220 Ohmů (je možné i trochu více) a připojím k zemi. Proto je polarita možná žasnutím nad jejími vnitřnostmi. Velká dáma uprostřed je spojena s mínusem a holčička s plusem. Pokud je LED nová, lze polaritu určit podle délky kolíků: dlouhá nožička je plus, krátká nožka je mínus.

Funkce delayMikrosekundy

Tato funkce je další obdobou zpoždění, až na to, že jejími jednotkami nejsou milisekundy, ale mikrosekundy (za 1 sekundu je 1 000 000 mikrosekund). Maximální hodnota bude 16383, což je více než 16 milisekund. Samostatná budova je rovna 4, takže číslo bude vždy násobkem čtyř. Zadek dám dohromady takto:

DigitalWrite(2, VYSOKÉ); // odeslání vysokého signálu na 2 piny delayMicroseconds(16383); // pauza 16383 µs digitalWrite(2, LOW); // odešle nízký signál na 2 piny delayMicroseconds(16383); // Pauza 16383 µs

Problém se zpožděnímMikrosekund je stejný jako se zpožděním – tyto funkce v podstatě „zavěsí“ program a doslova zamrznou na deset hodin. Je obtížné pracovat s porty, číst informace ze senzorů a provádět matematické operace. Pro flashery je tato možnost vhodná, pokud je však vývojáři nepoužívají pro velké projekty, protože tam takové poruchy nejsou potřeba. Níže je proto popsáno mnoho dalších zajímavých funkcí.

Funkce milis substituční zpoždění

Funkce millis() umožňuje bez prodlení vypnout vypnutí na Arduinu, čímž představuje několik pokročilých metod. Maximální hodnota parametru milis je stejná jako u funkce zpoždění (4294967295ms nebo 50 dB).

V zájmu tohoto milisu nezdůrazňujeme celý náčrt, ale jednoduše naznačujeme, kolikrát může Arduino jednoduše „minusovat“ samotný blok kódu, který chceme snížit. Ve skutečnosti zpoždění milis samo o sobě nic neznamená. Tento příkaz nám jednoduše říká počet milisekund, které uplynuly od spuštění mikrokontroléru. Pomocí skin call smyčky sami měříme hodinu, která uplynula od zbytku volání do našeho kódu, a pokud je rozdíl v hodině menší než požadovaná pauza, pak je kód ignorován. Jakmile se rozdíl po požadovanou pauzu zvětší, dokončíme kód, odečteme aktuální hodinu pro další milis a zapamatujeme si ji – tato hodina bude novým výchozím bodem. V dalším cyklu bude nový bod a kód budeme opět ignorovat, dokud nový rozdíl mezi milis a naší dříve uloženou hodnotou nedosáhne požadované pauzy.

Bezodkladné vypnutí pomocí milis má za následek větší kód a s touto pomocí můžete zablikat LED a pozastavit skicu bez přerušení systému.

Osa je pažba, která jasně ilustruje příkaz robota:

nepodepsané dlouhé načasování; // Změna pro uložení bodu v popředí void setup() ( Serial.begin(9600); ) void loop() ( /* Na jehož místě začíná nová analogie delay() Vypočítáme rozdíl mezi aktuálním momentem a dříve uložený bod v popředí. Cena je větší než požadovaná hodnota, pak se vygeneruje kód. Nepotřebujeme nic */ if (millis() - časování > 10000)( // Nahraďte 10000 hodnotou pauzy, kterou potřeba načasování = millis(); Serial.println ("10 sekund"); ) )

Nyní zadáme změnu časování, která ušetří pár milisekund. Po výpočtu se hodnota proměnné změní na 0. V podstatě program zkontroluje mysl: kolik milisekund od startu mikrokontroléru mínus číslo zapsané v proměnné časování je větší než, menší než 100 00, akce skončí, když se na monitoru portu zobrazí upozornění a bude zaznamenáno do paměti v přesnou hodinu. V důsledku spuštění programu po dobu 10 sekund se na monitoru portu zobrazí 10 sekund. Tato metoda umožňuje blikat LED bez zpoždění.

Zpoždění funkce Micros

Tato funkce může potlačit příkaz zpoždění bez použití příkazu zpoždění. Funguje stejně jako milisekundy, ale důležité nejsou milisekundy, ale mikrosekundy s odstupem 4 µs. Maximální hodnota je 4294967295 mikrosekund nebo 70 sekund. Pokud se hodnota změní, jednoduše se resetuje na 0, nezapomeňte na to.

souhrn

Platforma Arduino nabízí řadu způsobů, jak přizpůsobit svůj projekt. Pro další zpoždění můžete video náčrt rychle pozastavit, jinak zablokujete robota s mikrokontrolérem. Použití příkazu millis vám umožní používat Arduino bez zpoždění, ale k tomu potřebujete trochu více programování. Vyberte nejkratší metodu v závislosti na složitosti vašeho projektu. Zpravidla pro jednoduché náčrty a když je čas kratší než 10 sekund, použijte zpoždění. Protože logika robota je složitá a vyžaduje hodně úsilí, je lepší nahradit zpoždění než milis.

Vitayu, Andriy. Ještě před odevzdáním zavazadel se seznamte s důkazy toho, co jste nashromáždili. Opravdu to pomáhá s úkoly. Začínám ovládat arduino a doufám, že pokročím. Je důležitější, abych dosahoval lepších výsledků z vnější pomoci. Od této chvíle bylo mým úkolem vytvořit robota podél linky. Zrobiv všechno je zázračné. Kromě toho, když jim poskytli další možnosti, nechápali, proč přestali správně reagovat na linku. Když jsem se dotkl tohoto článku a pochopil důvod.

Nyní mám před vámi jídlo: pro levnější a hotové náčrty, zdravotní problémy se zpožděním, co musíte udělat, kde je tato funkce pro přepnutí na milis? Pokud ano, pak chápu, že se bude muset celý náčrt předělat? A není úplně jasné, jak vikoristovat millis ve světě? Dyakuyu.

//Robot s funkcí průchodu bílým smoothie

// *********************** Instalace nových motorů ******************** **

int MotorLeftSpeed ​​​​= 5; //Livy (A) motor SWIDKIST - ENA

int MotorLeftForward = 4; // Levý (A) motor VPŘED - IN1

int MotorLeftBack = 3; // Levý (A) motor BACK - IN2

int MotorRightForward = 8; // Pravý (B) motor VPŘED - IN3

int MotorRightBack = 7; // Pravý (B) motor ZPĚT - IN4

int MotorRightSpeed ​​​​= 9; // Pravý (B) motor SHVIDKIST - ENB

// *********************** Instalace ultrazvukových senzorů************************ ********

int trigPinL = 14; // Zadejte číslo levého trig ultrazvukového senzoru

int echoPinL = 15; // Zadejte číslo levého ultrazvukového senzoru echa

int trigPinC = 10; // Zadejte číslo centrálního spouštěcího ultrazvukového senzoru

int echoPinC = 11; // Zadejte číslo centrálního ultrazvukového senzoru echa

int trigPinR = 12; // Zadejte číslo displeje pravého trig ultrazvukového senzoru

int echoPinR = 13; // Zadejte číslo pravého ultrazvukového senzoru echa

// ******************** Instalace přídavných linkových čidel ********************

const int LineSensorLeft = 19; // Vstup levého řádkového senzoru

const int LineSensorRight = 18; // Vstup pravého linkového senzoru

int SL; // Stav levého senzoru

int SR; // stav pravého senzoru

// ********************* Instalace světelných a zvukových alarmů**************

int Světlo = 2; // Určení čísla světelného alarmu

int Zumm = 6; // Nastaví číslo, které se má zobrazit na bzučáku

int ledState = NÍZKÁ; // za tímto účelem je instalován napájecí zdroj LED

long předchozíMillis = 0; // uložení hodiny zbývajícího LED opětovného míchání

dlouhý interval = 300; // Interval mezi zapnutím a vypnutím LED (0,3 sekundy)

// ********************* Změna měření vzdálenosti pomocí senzorů**************

unsigned int impulsTimeL=0;

unsigned int impulsTimeC=0;

unsigned int impulseTimeR=0;

dlouhý distL=0; //Vzdálenost měřená levým ultrazvukovým senzorem

dlouhý distC=0; //Vzdálenost měřená centrálním ultrazvukovým senzorem

dlouhý distR=0; // vzdálenost měřená pravým ultrazvukovým senzorem

//******************************** ZALOŽIT ************ *** ******************

Serial.begin(9600); // spuštění sériového portu (rychlost 9600)

//*************** Nastavit kontakty motoru****************

pinMode(MotorRightBack, OUTPUT); // Pravý (B) motor ZPĚT

pinMode(MotorRightForward, OUTPUT); // Pravý (B) motor VPŘED

pinMode(MotorLeftBack, OUTPUT); //Livy (A) motor ZPĚT

pinMode(MotorLeftForward, OUTPUT); // Lehký (A) motor VPŘED

zpoždění (trvání);

//*************** Nastavuje kontakty kouřových čidel**************

pinMode(LineSensorLeft, INPUT); // Přiřazený pin levého linkového senzoru

pinMode(LineSensorRight, INPUT); // Přiřazený pin pravého linkového senzoru

//***************Nastavení režimů ultrazvukových senzorů***************************** **

pinMode(trigPinL, OUTPUT); // Nastaví robotický režim pro zobrazení levého trigového ultrazvukového senzoru

pinMode(echoPinL, INPUT); // Nastavení robotického režimu pro zobrazení levého echo ultrazvukového senzoru

pinMode(trigPinC, OUTPUT); // Nastavte režim robota pro zobrazení ultrazvukového senzoru centrálního spouštění

pinMode(echoPinC, INPUT); // Nastavte režim robota pro zobrazení centrálního echo ultrazvukového senzoru

pinMode(trigPinR, OUTPUT); // Nastavte režim robota pro zobrazení pravého spouštěcího ultrazvukového senzoru

pinMode(echoPinR, INPUT); // Nastavte režim robota pro zobrazení pravého ultrazvukového senzoru echa

// ******************Nastavit kontakty pro světelné a zvukové alarmy************************* ************** *****

pinMode(Zumm, OUTPUT); // Nastavení režimu robota pro zobrazení bzučáku

pinMode(Světlo,VÝSTUP); // Nastavte robotický režim pro zobrazení světelného alarmu

// ****************** Základní příkazy pro roc *******************

void forward (int a, int sa) // FORWARD

analogWrite(MotorRightSpeed, sa);

analogWrite(MotorLeftSpeed, sa);

void vpravo (int b, int sb) // OTOČIT DOPRAVA (jedna strana)

digitalWrite(MotorRightBack, LOW);

digitalWrite(MotorLeftBack, LOW);

digitalWrite(MotorLeftForward, HIGH);

analogWrite(MotorLeftSpeed, sb);

void left (int k, int sk) // OTOČIT DOLEVA (jedna strana)

digitalWrite(MotorRightBack, LOW);

digitalWrite(MotorRightForward, HIGH);

analogWrite(MotorRightSpeed, sk);

digitalWrite(MotorLeftBack, LOW);

void stopp (int f) // STOP

digitalWrite(MotorRightBack, LOW);

digitalWrite(MotorRightForward, LOW);

digitalWrite(MotorLeftBack, LOW);

digitalWrite(MotorLeftForward, LOW);

// ************************************** Pohled na vzdálenost*************** ********

void izmdistL() // Hodnota vzdálenosti s levým ultrazvukovým senzorem

digitalWrite(trigPinL, HIGH);

digitalWrite(trigPinL, LOW); // Impuls 10 mS na výstup ultrazvukového snímače vibrací

impulseTimeL = pulseIn(echoPinL, HIGH); // čtení výstupu z ultrazvukového senzoru

distL=impulsTimeL/58; // Může být přebit na centimetry

void izmdistC() // Měření vzdálenosti centrálním ultrazvukovým senzorem

digitalWrite(trigPinC, HIGH);

digitalWrite(trigPinC, LOW); // Impuls 10 mS na výstup ultrazvukového snímače vibrací

impulseTimeC = pulseIn(echoPinC, HIGH); // čtení výstupu z ultrazvukového senzoru

distC=impulseTimeC/58; // Může být přebit na centimetry

void izmdistR() // Měření vzdálenosti centrálním ultrazvukovým senzorem

digitalWrite(trigPinR, HIGH);

digitalWrite(trigPinR, LOW); // Impuls 10 mS na výstup ultrazvukového snímače vibrací

impulseTimeR = pulseIn(echoPinR, HIGH); // čtení výstupu z ultrazvukového senzoru

distR=impulseTimeR/58; // Může být přebit na centimetry

//**************************************** LOOP ************ ************************

// *********************** Režim čáry chůze ************************ ************

// ******************** světelný a zvukový alarm**************

tón (Zumm, 900); // Zapne zvuk na 900 Hz

tón (Zumm, 900); // Zapne zvuk na 800 Hz

unsigned long currentMillis = millis();

if (currentMillis - previousMillis > interval) //kontroluje, zda neuplynul požadovaný interval, pokud prošel

předchozíMillis = aktuálníMillis; // ušetří hodinu zbývajícího přerušení

if (ledState == LOW) // pokud LED nesvítí, pak je zapálená a přesto

ledState = VYSOKÝ;

digitalWrite(Světlo, ledState); // nastaví výstup na vypnutí nebo zhasnutí LED

// ************************ Vzdálenost Vimir************************ ******** ***

Serial.println(distL);

Serial.println(distC);

Serial.println(distR);

if (distL>50 && distC>50 && distR>50) // pokud je odhadovaná vzdálenost větší než 50 centimetrů - idemo

SL = digitalRead(LineSensorLeft); // přečte signál z levého černého senzoru

SR = digitalRead(LineSensorRight); // přečte signál z pravého černého senzoru

// ************************************** Chůze po černé čáře *********** ************

// Robot na smoothie - pojďme rovnou

if (SL == LOW & SR == LOW) // BILIY - BILIY - IDEMO DIRECT

vpřed(10, 100); // DIRECT (hodina, rychlost)

// Robot se začíná pohybovat ve tmě - ovládán

else if (SL == NÍZKÁ & SR == VYSOKÁ) // ČERNO - BÍLÁ - odbočte DOLEVA

doleva (10, 100); // odbočit DOLEVA (hodina, rychlost)

else if (SL == HIGH & SR == LOW) // BÍLÁ - ČERNÁ - odbočte DOPRAVA

doprava (10, 100); // odbočit DOPRAVA (hodina, rychlost)

// DOKONČIT - ROBOT pumpuje senzory do těla

else if (SL == HIGH & SR == HIGH) // BLACK - BLACK - STOP

stop(50); // STOP

else // pokud je aktuální vzdálenost menší nebo tradiční vzdálenost je minimální - náklady