Millis arduino reset. Arduino késleltetés millis és mikros a vázlat késleltetésének megszervezéséhez. Példa késleltetésre villogó LED-del

Az első dolog, amivel egy kezdő Arduino tanuló találkozik, a delay() függvény kellemetlen tulajdonsága – a programvégrehajtás blokkolása. Az interneten számos példa használja ezt a funkciót, de a gyakorlati alkalmazás valahogy azt sugallja, hogy jobb nélküle csinálni.

Ahogy egy kezdőhöz illik, újra feltaláltam a kereket, és elkészítettem a nem blokkoló késleltetést. A feladat így hangzott:

Biztosítson pszeudo-multitaskingot, hogy a különböző események a maguk idejében, saját időközönként történjenek, és ne blokkolják egymást.
Kényelmes volt ezt használni.
Megtervezhető könyvtárnak, és könnyen beilleszthető más projektekbe másolás-beillesztés nélkül.

Miután észrevettem, hogy a legtöbb Arduino könyvtár OOP használatával készül, úgy döntöttem, hogy nem mutatkozom meg, és megírtam a SmartDelay osztályt, amely a GitHubból zip-ként beszerezhető az Arduino IDE-hez való hozzáadáshoz vagy a ~/Arduino/libraries git klónozásához. /

Az eredmény ez.

#beleértve SmartDelay foo (1000000UL); // mikroszekundumban void loop () ( if (foo.Now()) ( // Az itt található kód minden, a fenti konstruktorban megadott mikroszekundum intervallumot végrehajt. ) // Egyéb kód )
A Now() metódus igazat ad vissza, ha az intervallum elmúlt. Ebben az esetben a visszaszámlálás ugyanazon időközönként újraindul. Vagyis a Now() minden alkalommal automatikusan „feltöltődik”.

A klasszikus LED-villogás azonnal két villanásra bonyolítható. Például a 12. és 11. érintkezőhöz csatlakoztatott izzóknak 1 másodpercenként, illetve 777 ms-os időközönként kell villogniuk.

#beleértve SmartDelay led12(1000000UL); SmartDelay led11(777000UL); setup () ( pinMode(12,OUTPUT); pinMode(11,OUTPUT); ) bájt led12state=0; bájt led11állapot=0; void loop () ( if (led12.Now()) ( digitalWrite(12,led12state); led12state=!led12state; ) if (led11.Now()) ( digitalWrite(11,led11state); led11state=!led11state; ) )
A hurokban mást is tehet; a villogó LED-ek nem blokkolják a kód végrehajtását.

Nyilvánvaló, hogy ez nem helyettesíti teljesen a delay()-et, amely egy adott időre leállítja a folyamot, a programot mindig FSM-ként (véges állapotú gépként) kell megírni. Vagyis tárolja az állapotot, és attól függően lépjen a kód kívánt helyére.

Régi verzió:

Action1(); késleltetés(1000); akció2(); késleltetés(500); akció3(); ...
Új lehetőség:

Byte állapot=0; SmartDelay d(); ... kapcsoló (állapot) ( 0. eset: action1(); d.Set(1000000UL); állapot=1; szünet; 1. eset: if (d.Now()) ( action2(); d.Set(500000UL) állapot=2 ) 2. eset: if (d.Now()) ( action3(); state=0; ) break;
A Set(interval) metódus új intervallumot állít be, és a régit adja vissza. Egyszerűen megtekintheti az intervallumot a Get() metódussal;

A Stop() leállítja a feldolgozást, a Now() pedig mindig false értéket ad vissza.

A Start() folytatódik, és a Now() a szokásos módon kezd működni.

Ha le kell lassítani az időszámítást, de nem kell teljesen leállítani, akkor ott van a Wait() metódus. Például, ha a 12-es LED villog, de nem villog a gomb megnyomásakor, egyszerűen adja hozzá a következő kódot a loop()-hoz a fenti két diódával rendelkező példában:

If (digitalRead(9)) led12.Wait(); ...
Tehát a 9. láb magas jelszintje esetén a 12. lábon lévő dióda nem villog, és tovább fog villogni, amikor a 0 megjelenik.

Ha például egy képernyőt ilyen „időzítővel” rajzolnak meg, és a gombokat párhuzamosan dolgozzák fel, előfordulhat, hogy a képernyőt vagy a részt közvetlenül a gomb megnyomása után újra kell rajzolni, nem pedig megvárni az intervallum végét. Erre a Reset() metódust használjuk, ami után a Now() következő hívása igazat ad vissza. Például:

SmartDelay kijelző (1000000UL); void loop() ( if (btClick()) display.Reset(); // megnyomta a gombot, meg kell rajzolnia a képernyőt. if (display.Now()) screenRedraw(); // rajzolja meg a képernyőt. )
Az egyetlen hiba, amit látok, hogy a mikroszekundumos számláló túlcsordulását nem veszik figyelembe, de egyébként igen, a kódot meg kell tisztítani. Nem tetszik, ahogy a Reset() működik, még mindig gondolkodom rajta.

Ha szeretné „szüneteltetni” a mikrokontrollert, akkor csak a késleltetési utasítást kell beírnia a program megfelelő helyre. Ez azonban valódi akadályt jelent, ha más dolgokat próbál meg tenni, például nyomon követni a gombkattintásokat. Ebben az esetben egyfajta multitasking megvalósítása szükséges.

Igen, ez néhány sor kódot ad a programjaihoz, de ezzel tapasztaltabb programozóvá válik, és növeli az Arduino potenciálját. Ehhez csak meg kell tanulnia a millis függvény használatát.

Meg kell érteni, hogy a késleltetési funkció szünetelteti az Arduino program végrehajtását, így nem tud mást tenni ebben az időszakban. Ahelyett, hogy egy bizonyos időre szüneteltetnénk a teljes programunkat, megtanuljuk megszámolni, mennyi idő telt el a művelet befejezése előtt. Ez természetesen a millis() függvény és néhány barát változó használatával történik az adatok tárolására. Hogy minden könnyen érthető legyen, kezdjük az első oktatóvázlattal, a „Pillogással”, de ebben az esetben késedelem nélkül villogni fogunk a LED-en.

Ennek a programnak az eleje megegyezik bármely más szabványos Arduino programéval. Először az összes szükséges változó és bemeneti/kimeneti sor deklarálása következik (például a LED 13. sora). Itt is szükségünk van egy egész változóra a LED aktuális állapotának tárolására. LOW-ra lesz állítva, mert a LED kezdeti állapota ki van kapcsolva. Ezután deklaráljuk az „unsigned long” típusú „previousMillis” változót. Az "int"-től eltérően a hosszú előjel nélküli változók 32 bitesek, erre olyan változóknál van szükség, amelyek értéke nagyon nagyra nőhet - mint például az a potenciális idő, amellyel megvárhatjuk a cselekvést. Az előző Millis változó a LED utolsó villogásának időpontjának tárolására szolgál. Létezik „const long” típus is, az is 32 bites, de nem változtat az értéken, vagyis konstansokra (jelen esetben az intervallumállandóra) való. 1000-re állítjuk, és ezt használjuk szünetidőként, ezredmásodpercben mérve.

const int ledPin = 13; // a LED kimenet meghatározása // A változók megváltoznak: int ledState = LOW; // A ledState a LED előjel nélküli hosszú előző állapotának meghatározására szolgálMillis = 0; // megmenti a LED utolsó frissítésének idejét // a konstansok nem változnak: const long interval = 1000 // villogó intervallum ezredmásodpercben void setup() ( // a kimenet 13. sorának beállítása pinMode(ledPin, OUTPUT); )

Ezután egy végtelen körbe megyünk. Ne feledje, hogy a késleltetés helyett azt szeretnénk számolni, hogy mennyi idő telt el az utolsó pislogás óta, esetünkben 1000 ms. Ha a megadott idő letelt, ideje megváltoztatni a LED-ünk állapotát.

Először az előjel nélküli hosszú "currentMillis"-t "millis()"-re állítjuk, ami az aktuális időt ezredmásodpercben adja meg. Ez segít kitalálni, hogy a jelenlegi és az előző időpont közötti különbség nem haladta-e meg az 1000 ms-ot. Ehhez azt mondjuk: "Ha az aktuális idő mínusz a LED-ünk előző villogása nagyobb vagy egyenlő, mint a hozzárendelt 1000 ms-os érték, akkor az utolsó villogási időt az előzőként tárolja." Ez segít emlékeznünk arra, hogy a ciklus következő fordulójában mennyi idő telt el az utolsó pislogás óta. Majd ha a LED állapota LOW, állítsa MAGAS, egyébként pedig LOW. Ezután a digitalWrite paranccsal írja be az aktuális állapotot a LED-be.

void loop() ( előjel nélküli long currentMillis = millis(); if (currentMillis - előzőMillis >= intervallum) ( // a LED állapotának utolsó változásának időpontjának mentése previousMillis = currentMillis; // ha a LED nem világít, majd kapcsolja be, és fordítva, ha (ledState == LOW) ( ledState = HIGH; ) else ( ledState = LOW; ) // kimenet a LED-re digitalWrite(ledPin, ledState) )

A millis() függvény lehetővé teszi az aktuális program indítása óta eltelt idő megszámlálását. A függvény „előjel nélküli hosszú” formátumú értéket ad vissza, és lehetővé teszi az értékek számlálását a program indításától számított 50 napig. Ezen idő elteltével a visszaszámlálás újra kezdődik. Az alábbiakban egy példa a millis() függvény használatára:

Hosszú ideig aláíratlan; void setup())( Serial.begin(9600); ) void loop())( Serial.print("On time: "); time = millis(); // emlékszik az időértékre Serial.println(time); // információ küldése soros porton keresztül delay(1000);

A fenti példában minden másodpercben a program indítása óta eltelt időről szóló információ kerül elküldésre a portfigyelőnek. Mivel az időt ezredmásodpercben mérik, minden következő érték 1000-rel különbözik. A leolvasás pontossága az Arduino kvarcrezonátor stabilitásától függ.

micros() függvény

A micros() függvény a millis() függvény analógja, a különbség a mérési pontosságban rejlik. A micros() függvény segítségével mikroszekundumban kapjuk meg az aktuális program indítása óta eltelt időt. A számláló mikroszekundum számláló 70 perc elteltével nullázódik. Az alábbiakban egy példa a micros() függvény használatára:

Hosszú ideig aláíratlan; void setup())( Serial.begin(9600); ) void loop())( Serial.print("Kezdés óta eltelt idő: "); time = micros(); Serial.print(time); Serial.println(" µs "); késleltetés(1000);

Csakúgy, mint a példában a millis() függvénnyel, itt is másodpercenként elküldik a mért időről szóló információkat a portmonitornak, csak annyi a különbség, hogy ebben az esetben az időt mikroszekundumban mérjük.

delay() függvény

A delay() függvény lehetővé teszi az aktuális program végrehajtásának szüneteltetését a paraméterben megadott ideig. A parancs szintaxisa a következő:

//parancsok késleltetése(500); //késleltetés 0,5 másodperccel //parancsok késleltetése(1000); //1 másodperces késleltetés

Az idő ezredmásodpercben van megadva (1 mp = 1000 ms). Ez a paraméter „unsigned long” típusú lehet, amely 0 és 4294967295 között lehet. Az alábbiakban egy példa a delay() parancs használatára:

#define ledPin 13 void setup() ( pinMode(ledPin,13); ) void loop() ( digitalWrite(ledPin,HIGH); //a LED késleltetés bekapcsolása (500); //várjon 500 ms (0,5 mp) digitalWrite( ledPin ,LOW //kikapcsolja a LED késleltetést (1000 //vár 1000 ms (1 mp));

A fenti példában a LED 0,5 másodpercre bekapcsol, majd 1 másodpercre kialszik, és így tovább, amíg az Arduino ki nem kapcsol.

delayMicroseconds() függvény

A delayMicroseconds() függvény a delay() függvény egy változata. A különbség a mennyiségben és az időzítési pontosságban rejlik. A delay() függvény lehetővé teszi az idő 1 ezredmásodperces, míg a delayMicroseconds() függvény 1 mikroszekundumos pontosságú mérést tesz lehetővé.

A paraméterben megadható érték 0 és 16383 között van. Hosszabb időintervallumok esetén használja a delay() függvényt, vagy használja többször a delayMicroseconds() függvényt.

#define outPin 8 void setup() ( pinMode(outPin, OUTPUT); // pin 8 kimenetként ) void loop() ( digitalWrite(outPin, HIGH); // pin 8 high state delayMicroseconds(50); // pause 50 microseconds digitalWrite(outPin, LOW // pin 8 low state delayMicroseconds(50) // szünet 50 mikroszekundum);

Ez a példa négyszöghullámot generál 100 mikromásodperces periódussal és 50%-os kitöltési aránnyal.

Az Arduino késései nagyon nagy szerepet játszanak. Nélkülük a Blink legegyszerűbb példája sem működik, amely meghatározott idő elteltével villog egy LED-et. De a legtöbb kezdő programozó keveset tud az időkésleltetésről, és csak az Arduino késleltetést használja anélkül, hogy ismerné ennek a parancsnak a mellékhatásait. Ebben a cikkben részletesen beszélek az időzítési funkciókról és azok használatáról az Arduino IDE-ben.

Az Arduino-ban számos különböző parancs található, amelyek felelősek az idővel és a szünetekkel való munkavégzésért:

késleltetés()
késleltetésMikroszekundum()
millis()
micros()

Pontosságban különböznek, és megvannak a saját jellemzőik, amelyeket figyelembe kell venni a kód írásakor.

Az arduino késleltetési funkció használata

Szintaxis

Az Arduino késleltetés a legegyszerűbb parancs, és leggyakrabban kezdők használják. Lényegében ez egy késleltetés, amely szünetelteti a programot a zárójelben jelzett ezredmásodpercekre. (Egy másodpercben 1000 ezredmásodperc van.) A maximális érték 4294967295 ms lehet, ami megközelítőleg 50 napnak felel meg. Nézzünk egy egyszerű példát, amely világosan megmutatja, hogyan működik ez a parancs.

Void setup() ( pinMode(13, OUTPUT); ) void loop() ( digitalWrite(13, HIGH); // magas jel küldése a 13-as érintkezőnek delay(10000); // szünet 10000 ms vagy 10 másodperc digitalWrite13, LOW) ; // alacsony jel küldése a 13-as lábnak delay(10000); // szünet 10000 ms vagy 10 másodperc)

A módszerben beállít Meghatározzuk, hogy a 13-as láb kimenetként kerül felhasználásra. A program fő részében először egy magas jelet küldünk a pinre, majd 10 másodperces késleltetést teszünk. Ez idő alatt a program felfüggeszteni látszik. Ezután alacsony jelet adnak, és ismét késés következik, és minden kezdődik elölről. Ennek eredményeként azt kapjuk, hogy a tűt felváltva 5 V vagy 0 táplálja.

Világosan meg kell értenie, hogy a késleltetést használó szünet alatt a program működése felfüggesztésre kerül, az alkalmazás nem kap adatokat az érzékelőktől. Ez az Arduino késleltetési funkció használatának legnagyobb hátránya. Ezt a korlátozást megkerülheti megszakításokkal, de erről egy külön cikkben fogunk beszélni.

Példa késleltetésre villogó LED-del

Egy példaáramkör a késleltetési függvény működésének szemléltetésére.
LED-del és ellenállással áramkört építhet. Akkor lesz egy szabványos példa - villogó LED. Ehhez egy pozitív érintkezős LED-et kell csatlakoztatni a tűhöz, amelyet kimenetként jelöltünk meg. A LED szabad lábát körülbelül 220 ohmos ellenálláson keresztül csatlakoztatjuk a földhöz (egy kicsit több is lehetséges). A polaritást a belsejének megtekintésével határozhatja meg. A benne lévő nagy csésze a mínuszhoz, a kis láb a pluszhoz kapcsolódik. Ha új LED-ed, akkor a vezetékek hosszával határozhatod meg a polaritást: a hosszú láb plusz, a rövid láb mínusz.

delayMicroseconds funkció

Ez a funkció a késleltetés teljes analógja, azzal a különbséggel, hogy mértékegységei nem ezredmásodpercek, hanem mikroszekundumok (1 másodpercben 1 000 000 mikroszekundum van). A maximális érték 16383 lesz, ami 16 ezredmásodpercnek felel meg. A felbontás 4, vagyis a szám mindig négy többszöröse lesz. Egy példarészlet így nézne ki:

DigitalWrite(2, HIGH); // magas jelet küld a 2. lábnak delayMicroseconds(16383); // szünet 16383 µs digitalWrite(2, LOW); // alacsony jelet küld a 2. lábnak delayMicroseconds(16383); // szünet 16383 µs

A delayMicroseconds probléma pontosan ugyanaz, mint a késleltetéssel - ezek a funkciók teljesen „lefagyják” a programot, és szó szerint lefagy egy időre. Jelenleg lehetetlen portokkal dolgozni, érzékelőktől származó információkat olvasni és matematikai műveleteket végrehajtani. Ez az opció villogó fényekhez alkalmas, de a tapasztalt felhasználók nem használják nagy projektekhez, mivel ott nincs szükség ilyen hibákra. Ezért sokkal jobb az alább leírt funkciók használata.

Millis funkció késleltetés helyett

A millis() függvény lehetővé teszi, hogy késleltetés nélkül hajtsa végre az Arduino-t, ezzel megkerülve az előző módszerek hiányosságait. A millis paraméter maximális értéke megegyezik a késleltetési funkcióéval (4294967295 ms vagy 50 nap).

A millis használatával nem állítjuk le a teljes vázlat végrehajtását, hanem egyszerűen jelezzük, mennyi ideig kell az Arduino-nak egyszerűen „megkerülnie” azt a kódblokkot, amelyet szüneteltetni szeretnénk. Ellentétben a késleltető millissel, nem állít meg semmit magától. Ez a parancs egyszerűen visszaadja nekünk a mikrokontroller beépített időzítőjéből az indítás óta eltelt ezredmásodpercek számát. Minden hurokhívásnál mi magunk mérjük a kódunk utolsó hívása óta eltelt időt, és ha az időeltolódás kisebb, mint a kívánt szünet, akkor figyelmen kívül hagyjuk a kódot. Amint a különbség nagyobb, mint a szükséges szünet, végrehajtjuk a kódot, lekérjük az aktuális időt ugyanazzal a milliszel, és emlékezzünk rá - ez lesz az új kiindulási pont. A következő ciklusban a visszaszámlálás már az új ponttól fog történni, és ismét figyelmen kívül hagyjuk a kódot, amíg a millis és a korábban elmentett érték közötti új különbség ismét el nem éri a kívánt szünetet.

A késleltetés nélküli késleltetés millis használatával több kódot igényel, de segítségével a rendszer leállítása nélkül villoghat egy LED és szüneteltethet egy vázlatot.

Íme egy példa, amely egyértelműen illusztrálja a csapat munkáját:

Előjel nélküli hosszú időzítés; // Változó a referenciapont tárolására void setup() ( Serial.begin(9600); ) void loop() ( /* Ezen a ponton kezdődik a delay() analóg végrehajtása. Számítsa ki a különbséget az aktuális pillanat és a korábban mentett referenciapont Ha a különbség nagyobb, mint a kívánt érték, akkor hajtsa végre a kódot. = millis(); Serial.println ("10 másodperc") ;

Először bemutatjuk az időzítési változót, amely az ezredmásodpercek számát tárolja. Alapértelmezésben a változó értéke 0. A program fő részében ellenőrizzük a feltételt: ha a mikrokontroller indulásától számított ezredmásodpercek száma mínusz az időzítési változóba írt szám nagyobb, mint 10000, akkor a üzenetet küld a portfigyelőnek, és az aktuális időértéket a változóba írja. A program működése következtében 10 másodpercenként megjelenik a 10 másodperc üzenet a port monitoron. Ez a módszer lehetővé teszi a LED késleltetés nélküli villogását.

Micros funkció késleltetés helyett

Ez a funkció késleltetést is végrehajthat a késleltetés parancs használata nélkül. Pontosan ugyanúgy működik, mint a millis, de ezredmásodperc helyett mikroszekundumokat számol 4 μs felbontással. Maximális értéke 4294967295 mikroszekundum vagy 70 perc. Ha túlcsordul, az érték egyszerűen visszaáll 0-ra, ne feledkezzünk meg róla.

Összegzés

Az Arduino platform számos módot biztosít számunkra, hogy késleltetést hajtsunk végre projektünkben. A késleltetés segítségével gyorsan szüneteltetheti a vázlat végrehajtását, ugyanakkor blokkolja a mikrokontroller működését. A millis parancs használatával késedelem nélkül megteheti az Arduino-t, de ez egy kicsit több programozást igényel. Válassza ki a legjobb módszert a projekt összetettségétől függően. Általában az egyszerű vázlatoknál és 10 másodpercnél rövidebb késleltetésnél késleltetést használnak. Ha a működési logika bonyolultabb és nagy késleltetésre van szükség, akkor a késleltetés helyett jobb a millis használata.

Szia Andrei. Nagyon érdekes az Ön megközelítése a felhalmozott tudás és tapasztalat átadásához. Sokat segít a törekvéseiben. Nos, én, amikor elkezdem elsajátítani az arduino-t, vágyom a fejlődésre. Sőt, külső segítséggel gyorsabban meg tudom csinálni. Tehát: először az volt a feladatom, hogy készítsek egy vonal mentén haladó robotot. Megcsináltam – minden rendben volt. De további lehetőségeket biztosítva nem értettem, miért nem reagál megfelelően a vonalra. Találkoztam ezzel a cikkel, és megértettem az okát.

Most lenne egy kérdésem hozzád: az alább említett és kész vázlatban a késleltetéssel kapcsolatos problémákat figyelembe véve mindenhol át kell váltani millisra ahol ez a funkció megvan? Ha igen, akkor megértem, hogy szinte a teljes vázlatot újra kell készíteni? És nem teljesen világos, hogyan kell használni a millimétereket a távolság mérésében? Köszönöm.

//Robot fehér vonalat követő funkcióval

// **************************Motorkábelek beszerelése *************************** *

int MotorLeftSpeed = 5; // Bal (A) motor SPEED - ENA

int MotorLeftForward = 4; // Bal (A) motor FORWARD - IN1

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

int MotorRightForward = 8; // Jobb (B) motor ELŐRE - IN3

int MotorRightBack = 7; // Jobb (B) motor VISSZA - IN4

int MotorRightSpeed = 9; // Jobb (B) motor SPEED - ENB

// ************************** Ultrahangos érzékelő kimenetek telepítése************************ ***

int trigPinL = 14; // a bal oldali trig ultrahangos érzékelő pin számának beállítása

int echoPinL = 15; // a bal oldali echo ultrahangos érzékelő kimeneti számának beállítása

int trigPinC = 10; // a központi trig ultrahangos érzékelő pin számának beállítása

int echoPinC = 11; // a központi echo ultrahangos érzékelő kimeneti számának beállítása

int trigPinR = 12; // a jobb trig ultrahangos érzékelő pin számának beállítása

int echoPinR = 13; // a jobb echo ultrahangos érzékelő kimeneti számának beállítása

// ********************* Vonalérzékelő érintkezők beszerelése *******************

const int LineSensorLeft = 19; // bal oldali érzékelő bemenet

const int LineSensorRight = 18; // a jobb oldali érzékelő bemenete

int SL; // bal oldali érzékelő állapota

int SR; // jobb érzékelő állapota

// *********************A fény- és hangriasztás kimenet beállítása***************

int Fény = 2; // a fényriasztás kimenet számának beállítása

int Zumm = 6; // a hangjelzés kimeneti számának beállítása

int ledState = LOW; // állítsa be a LED állapotát ezzel a változóval

hosszú előzőMillis = 0; // tárolja az utolsó LED váltás időpontját

hosszú intervallum = 300; // a LED be-/kikapcsolása közötti intervallum (0,3 másodperc)

// *********************Változó távolságmérés érzékelőkkel***************

unsigned int impulseTimeL=0;

unsigned int impulseTimeC=0;

unsigned int impulseTimeR=0;

long distL=0; // a bal oldali ultrahangos érzékelő által mért távolság

hosszú distC=0; // a központi ultrahangos érzékelő által mért távolság

hosszú disztR=0; // a jobb oldali ultrahang érzékelő által mért távolság

// ******************************** BEÁLLÍT ************ *** *****************

Serial.begin(9600); //indítsa el a soros portot (9600-as sebesség)

//*************** Állítsa be a motor érintkezőit****************

pinMode(MotorRightBack, OUTPUT); // Jobb (B) motor VISSZA

pinMode(MotorRightForward, OUTPUT); // Jobb (B) motor ELŐRE

pinMode(MotorLeftBack, OUTPUT); // Bal (A) motor VISSZA

pinMode(MotorLeftForward, OUTPUT); // Bal (A) motor ELŐRE

késleltetés(időtartam);

//*************** Állítsa be a szalagérzékelő érintkezőit**************

pinMode(LineSensorLeft, INPUT); // a bal oldali vonalérzékelő tűjének meghatározása

pinMode(LineSensorRight, INPUT); // a jobb oldali érzékelő tűjének meghatározása

// *************** Ultrahangos érzékelők kimeneti módjának beállítása***********************

pinMode(trigPinL, OUTPUT); // az ultrahangos érzékelő bal oldali trig kimenetének üzemmódjának beállítása

pinMode(echoPinL, INPUT); // a bal oldali echo ultrahangos érzékelő kimenetének üzemmódjának beállítása

pinMode(trigPinC, OUTPUT); // a központi trig ultrahangos érzékelő kimenetének üzemmódjának beállítása

pinMode(echoPinC, INPUT); // a központi echo ultrahangos érzékelő kimenetének üzemmódjának beállítása

pinMode(trigPinR, OUTPUT); // a jobb trig ultrahangos érzékelő kimenetének üzemmódjának beállítása

pinMode(echoPinR, INPUT); // a jobb echo ultrahangos érzékelő kimenetének üzemmódjának beállítása

// **************Érintkezők beállítása fény- és hangriasztásokhoz**************************** *****

pinMode(Zumm,OUTPUT); // a berregő kimenet üzemmódjának beállítása

pinMode(Light,OUTPUT); // a fényjelző kimenet üzemmódjának beállítása

// ****************** Alapvető mozgásparancsok ******************

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

analogWrite(MotorRightSpeed, sa);

analogWrite(MotorLeftSpeed, sa);

üres jobb (int b, int sb) // ROTATE RIGHT (egyik oldal)

digitalWrite(MotorRightBack, LOW);

digitalWrite(MotorLeftBack, LOW);

digitalWrite(MotorBal előre, HIGH);

analógWrite(MotorLeftSpeed, sb);

void left (int k, int sk) // FORDULAT BALRA (egyik oldal)

digitalWrite(MotorRightBack, LOW);

digitalWrite(MotorRightForward, HIGH);

analogWrite(MotorRightSpeed, sk);

digitalWrite(MotorLeftBack, LOW);

void stop (int f) // STOP

digitalWrite(MotorRightBack, LOW);

digitalWrite(MotorRightForward, LOW);

digitalWrite(MotorLeftBack, LOW);

digitalWrite(MotorLeftForward, LOW);

// ************************************* Távolságmérés************* ******

void izmdistL () // távolságmérés a bal oldali ultrahangos érzékelővel

digitalWrite(trigPinL, HIGH);

digitalWrite(trigPinL, LOW); // 10 mS impulzus az ultrahangos érzékelő trig kimenetére a távolság mérésére

impulzusIdőL = pulseIn(echoPinL, HIGH); // az ultrahangos érzékelő távolságának leolvasása

distL=impulseTimeL/58; // Átalakítás centiméterre

void izmdistC () // távolságmérés a központi ultrahangos érzékelővel

digitalWrite(trigPinC, HIGH);

digitalWrite(trigPinC, LOW); // 10 mS impulzus az ultrahangos érzékelő trig kimenetére a távolság mérésére

impulzusIdőC = pulseIn(echoPinC, HIGH); // az ultrahangos érzékelő távolságának leolvasása

distC=impulseTimeC/58; // Átalakítás centiméterre

void izmdistR () // távolságmérés a központi ultrahangos érzékelővel

digitalWrite(trigPinR, HIGH);

digitalWrite(trigPinR, LOW); // 10 mS impulzus az ultrahangos érzékelő trig kimenetére a távolság mérésére

impulzusidőR = pulseIn(echoPinR, HIGH); // az ultrahangos érzékelő távolságának leolvasása

distR=impulseTimeR/58; // Átalakítás centiméterre

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

// *********************** LINE követési mód *********************** ********* ***

// *********************fény- és hangriasztó***************

hangszín (Zumm,900); // bekapcsolja a hangot 900 Hz-en

hangszín (Zumm,900); // kapcsolja be a hangot 800 Hz-en

előjel nélküli hosszú áramMillis = millis();

if (currentMillis - previousMillis > interval) //ellenőrizze, hogy a szükséges intervallum eltelt-e, ha elmúlt, akkor

előzőMillis = jelenlegiMillis; // az utolsó váltás időpontjának mentése

if (ledState == LOW) // ha a LED nem világít, akkor világít, és fordítva

ledState = MAGAS;

digitalWrite(Light, ledState); // a kimeneti állapotok beállítása a LED be- vagy kikapcsolásához

// ************************ Mérési távolság*********************** **

Serial.println(distL);

Serial.println(distC);

Serial.println(distR);

if (distL>50 && distC>50 && distR>50) // ha a mért távolság több mint 50 centiméter, akkor megyünk

SL = digitalRead(LineSensorLeft); // beolvassa a jelet a bal sáv érzékelőjétől

SR = digitalRead(LineSensorRight); // beolvassa a jelet a jobb oldali sáv érzékelőjétől

// ************************************ A fekete vonalat követve ************ ******* ****

// ROBOT a sávon - menj egyenesen

if (SL == LOW & SR == LOW) // FEHÉR - FEHÉR - EGYENES

előre (10, 100 // KÖZVETLEN (idő, sebesség)

// A ROBOT elkezd kimozdulni a sávból – taxizunk

else if (SL == LOW & SR == HIGH) // FEKETE - FEHÉR - forduljon BALRA

balra (10, 100 // balra fordulás (idő, sebesség)

else if (SL == HIGH & SR == LOW) // FEHÉR - FEKETE - forduljon JOBBRA

jobbra (10, 100 // forgatás JOBBRA (idő, sebesség)

// FINISH – A ROBOT mindkét érzékelővel látja a csíkot

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

stop (50); // STOP

else // ha a mért távolság kisebb vagy egyenlő, mint a minimum - megállunk