Resetare Millis arduino. Arduino delay millis și micros pentru organizarea întârzierii în schiță. Exemplu de întârziere cu LED-ul care clipește

Primul lucru pe care îl întâlnește un începător care învață Arduino este proprietatea neplăcută a funcției delay() - blocarea execuției programului. Multe exemple de pe Internet folosesc această funcție, dar aplicația practică sugerează cumva că este mai bine să te descurci fără ea.

După cum se potrivește unui începător, am reinventat roata și am făcut propria implementare a întârzierii neblocante. Sarcina a fost astfel:

Furnizați pseudo-multitasking astfel încât diferite evenimente să apară la timpul lor, la intervale proprii și să nu se blocheze reciproc.
A fost convenabil să folosești asta.
Ar putea fi proiectat ca o bibliotecă și inclus cu ușurință în alte proiecte fără copiere-lipire.

După ce am observat că majoritatea bibliotecilor Arduino sunt realizate folosind OOP, am decis, de asemenea, să nu mă arăt și am scris clasa SmartDelay, care poate fi obținută din GitHub ca zip pentru adăugarea la IDE-ul Arduino sau pentru a face o clonă git în ~/Arduino/libraries /

Rezultatul este acesta.

#include SmartDelay foo(1000000UL); // în microsecunde void loop () ( if (foo.Now()) ( // Codul de aici execută fiecare interval de microsecunde specificat în constructorul de mai sus. ) // Alt cod )
Metoda Now() returnează adevărat dacă intervalul a trecut. În acest caz, numărătoarea inversă începe din nou la același interval. Adică, Now() este „reîncărcat” automat de fiecare dată.

Clipirea clasică a LED-ului poate fi imediat complicată la două clipiri. De exemplu, becurile conectate la pinii 12 și 11 ar trebui să clipească la intervale de 1s și, respectiv, 777ms.

#include SmartDelay led12(1000000UL); SmartDelay led11(777000UL); setup () ( pinMode(12,OUTPUT); pinMode(11,OUTPUT); ) byte led12state=0; octet led11state=0; bucla void () ( if (led12.Now()) ( digitalWrite(12,led12state); led12state=!led12state; ) if (led11.Now()) ( digitalWrite(11,led11state); led11state=!led11state; ) )
Puteți face altceva în buclă; LED-urile intermitente nu vor bloca execuția acestui cod.

Este clar că aceasta nu este o înlocuire completă a delay(), care oprește fluxul pentru un anumit timp, programul trebuie întotdeauna scris ca un FSM (mecanism de mașină cu stări finite). Adică stocați starea și, în funcție de aceasta, mutați-vă în locul dorit din cod.

Versiune veche:

Acțiunea1(); întârziere (1000); acțiunea2(); întârziere (500); acțiunea3(); ...
Opțiune nouă:

Stare octet=0; SmartDelay d(); ... comutați (stare) ( cazul 0: acțiune1(); d.Set(1000000UL); stare=1; pauză; caz 1: dacă (d.Acum()) ( acțiune2(); d.Set(500000UL) ; stare=2 ) caz 2: if (d.Now()) ( acțiune3();
Metoda Set(interval) setează un nou interval și returnează cel vechi. Puteți privi pur și simplu intervalul folosind metoda Get() ;

Stop() oprește procesarea și Now() returnează întotdeauna false.

Start() se reia și Now() începe să funcționeze normal.

Dacă trebuie să încetiniți calculul timpului, dar nu să îl opriți complet, atunci există metoda Wait(). De exemplu, dacă LED-ul 12 clipește, dar nu clipește când butonul este apăsat, trebuie doar să adăugați următorul cod la loop() în exemplul cu două diode de mai sus:

If (digitalRead(9)) led12.Wait(); ...
Deci, cu un nivel de semnal ridicat pe piciorul 9, dioda de pe piciorul 12 nu va clipi și va continua când apare 0 acolo.

Când un ecran este desenat folosind un astfel de „cronometru”, de exemplu, și butoanele sunt procesate în paralel, poate fi necesar să redesenați ecranul sau o parte imediat după apăsarea butonului, mai degrabă decât să așteptați sfârșitul intervalului. Pentru aceasta este folosită metoda Reset(), după care următorul apel la Now() va returna adevărat. De exemplu:

Afișaj SmartDelay (1000000UL); void loop() ( dacă (btClick()) display.Reset(); // ați apăsat butonul, trebuie să desenați ecranul. if (display.Now()) screenRedraw(); // desenați ecranul. )
Singurul bug pe care îl văd este că nu se ține cont de overflow-ul contorului de microsecunde, dar în rest, da, codul trebuie curățat. Nu-mi place cum se face Reset(), încă mă gândesc la asta.

Dacă doriți să „întrerupeți” microcontrolerul, atunci trebuie doar să introduceți instrucțiunea de întârziere în locul potrivit din program. Dar acest lucru devine un adevărat obstacol atunci când încercați să faceți alte lucruri, cum ar fi urmărirea clicurilor pe buton. În acest caz, este necesar să se implementeze un fel de multitasking.

Da, va adăuga câteva linii de cod la programele dvs., dar acest lucru, la rândul său, vă va face un programator mai experimentat și va crește potențialul Arduino. Pentru a face acest lucru, trebuie doar să înveți cum să folosești funcția millis.

Trebuie înțeles că funcția de întârziere întrerupe execuția programului dvs. Arduino, făcându-l incapabil să facă altceva în acea perioadă de timp. În loc să întrerupem întregul program pentru o anumită perioadă de timp, vom învăța să numărăm cât timp a trecut până la finalizarea unei acțiuni. Acest lucru se face, desigur, folosind funcția millis() și câteva variabile prieten pentru a stoca datele noastre. Pentru a face totul ușor de înțeles, vom începe cu prima schiță tutorial numită „Blink”, dar în acest caz vom clipi LED-ul fără întârziere.

Începutul acestui program este același cu orice alt program standard Arduino. Mai întâi vine declararea tuturor variabilelor necesare și a liniilor de intrare/ieșire (de exemplu, linia 13 pentru LED). Aici avem nevoie și de o variabilă întreagă pentru a stoca starea curentă a LED-ului. Acesta va fi setat la LOW deoarece starea inițială a LED-ului este stinsă. Apoi declarăm variabila „previousMillis” de tip „unsigned long”. Spre deosebire de „int”, variabilele lungi fără semn sunt de 32 de biți, acest lucru este necesar pentru variabilele a căror valoare poate deveni foarte mare - cum ar fi timpul potențial pe care îl putem aștepta până când se ia măsuri. Variabila precedentă Millis va fi folosită pentru a stoca ora la care LED-ul a clipit ultima dată. Există și un tip „const long”, este și pe 32 de biți, dar nu schimbă valoarea, adică este pentru constante (în acest caz pentru constanta de interval). Îl vom seta la 1000 și îl vom folosi ca timp de pauză, măsurat în milisecunde.

const int ledPin = 13; // definiți ieșirea LED-ului // Variabilele se vor schimba: int ledState = LOW; // ledState este folosit pentru a determina starea LED-ului unsigned long previousMillis = 0; // va economisi timpul când LED-ul a fost actualizat ultima dată // constantele nu se vor schimba: const long interval = 1000 // interval de clipire în milisecunde void setup() ( // se configurează linia 13 din output pinMode(ledPin, OUTPUT); );

Apoi intrăm într-o buclă infinită. Amintiți-vă că, în loc de întârziere, vrem să numărăm cât timp a trecut de la ultima noastră clipire, în cazul nostru 1000 ms. Dacă timpul specificat a trecut, este timpul să schimbăm starea LED-ului nostru.

Mai întâi, vom seta „currentMillis” lung nesemnat la „millis()”, care specifică timpul curent în milisecunde. Acest lucru ne va ajuta să ne dăm seama dacă diferența dintre ora actuală și cea anterioară a depășit 1000 ms. Pentru a face acest lucru, spunem: „Dacă ora curentă minus ora anterioară a LED-ului nostru intermitent este mai mare sau egală cu valoarea noastră atribuită de 1000 ms, stocați ultimul timp de clipire ca pe cel precedent”. Acest lucru ne va ajuta să ne amintim cât timp a trecut de la ultima clipire din următoarea rundă a buclei. Apoi, dacă starea LED-ului este LOW, faceți-l HIGH, altfel faceți-l LOW. Apoi utilizați comanda digitalWrite pentru a scrie starea curentă pe LED.

void loop() (unsigned long currentMillis = millis(); if (currentMillis - previousMillis >= interval) ( // salvează ora ultimei modificări în starea LED-ului precedentMillis = currentMillis; // dacă LED-ul este stins, apoi porniți-l și invers dacă (ledState == LOW) (ledState = HIGH; ) else (ledState = LOW; ) // ieșire la LED digitalWrite(ledPin, ledState) )

Funcția millis() vă permite să numărați timpul care a trecut de la pornirea programului curent. Funcția returnează o valoare în formatul „unsigned long” și vă permite să numărați valori până la 50 de zile din momentul lansării programului. După acest timp, numărătoarea inversă va începe din nou. Mai jos este un exemplu de utilizare a funcției millis():

Nesemnat de mult timp; void setup())( Serial.begin(9600); ) void loop())( Serial.print("On time: "); time = millis(); // amintiți-vă valoarea de timp Serial.println(time); // trimiterea de informații prin portul serial delay(1000);

În exemplul de mai sus, în fiecare secundă, informații despre timpul care a trecut de la lansarea programului vor fi trimise către monitorul portului. Deoarece timpul este măsurat în milisecunde, fiecare valoare ulterioară va diferi cu 1000. Precizia citirii depinde de stabilitatea rezonatorului cuarț Arduino.

funcția micros().

Funcția micros() este un analog al funcției millis(), diferența constă în precizia măsurării. Folosind funcția micros() vom obține timpul scurs de când programul curent a fost lansat în microsecunde. Contorul de microsecunde numărat va fi resetat după 70 de minute. Mai jos este un exemplu de utilizare a funcției micros():

Nesemnat de mult timp; void setup())( Serial.begin(9600); ) void loop())( Serial.print("Timp de la început: "); time = micros(); Serial.print(time); Serial.println(" µs "); întârziere (1000);

La fel ca în exemplul cu funcția millis(), aici informații despre timpul măsurat vor fi trimise la monitorul portului în fiecare secundă, singura diferență este că în acest caz timpul este măsurat în microsecunde.

funcția delay().

Funcția delay() vă permite să întrerupeți execuția programului curent pentru timpul specificat în parametru. Sintaxa comenzii este următoarea:

//comenzi delay(500); //întârziere cu 0,5 sec //comenzi delay(1000); //întârziere cu 1s

Timpul este indicat în milisecunde (1 sec = 1000 ms). Acest parametru poate fi de tip „unsigned long”, care variază de la 0 la 4294967295. Mai jos este un exemplu de utilizare a comenzii delay():

#define ledPin 13 void setup() ( pinMode(ledPin,13); ) void loop() ( digitalWrite(ledPin,HIGH); //pornire întârziere LED (500); //așteptați 500ms (0,5 sec) digitalWrite(ledPin ,LOW); //întârziere de oprire a LED-ului (1000 //așteptați 1000 ms (1 sec));

În exemplul de mai sus, LED-ul se aprinde timp de 0,5 secunde, apoi se stinge timp de 1 secundă și așa mai departe până când Arduino este oprit.

funcția delayMicroseconds().

Funcția delayMicroseconds() este o variație a funcției delay(). Diferența constă în cantitatea și acuratețea timpului. Funcția delay() vă permite să păstrați timpul cu o precizie de 1 milisecundă, în timp ce delayMicroseconds() vă permite să măsurați timpul cu o precizie de 1 microsecundă.

Valoarea care poate fi specificată în parametru variază de la 0 la 16383. Pentru intervale de timp mai lungi, utilizați funcția delay() sau utilizați delayMicroseconds() de mai multe ori.

#define outPin 8 void setup() ( pinMode(outPin, OUTPUT); // pin 8 ca ieșire) void loop() ( digitalWrite(outPin, HIGH); // pin 8 high state delayMicrosecunde(50); // pauză 50 microsecunde digitalWrite(outPin, LOW // pin 8 low state delayMicrosecunde(50) // pauză 50 microsecunde);

Acest exemplu generează o undă pătrată cu o perioadă de 100 de microsecunde și o rată de umplere de 50%.

Întârzierile în Arduino joacă un rol foarte important. Fără ele, chiar și cel mai simplu exemplu de Blink, care clipește un LED după o anumită perioadă de timp, nu poate funcționa. Dar majoritatea programatorilor începători știu puține despre întârzierile de timp și folosesc numai întârzierea Arduino fără a cunoaște efectele secundare ale acestei comenzi. În acest articol, voi vorbi în detaliu despre funcțiile de sincronizare și despre cum să le folosesc în IDE-ul Arduino.

Există mai multe comenzi diferite în Arduino care sunt responsabile pentru lucrul cu timpul și pauzele:

întârziere()
delayMicrosecunde()
milis()
micros()

Ele diferă în precizie și au propriile lor caracteristici care ar trebui să fie luate în considerare la scrierea codului.

Folosind funcția de întârziere arduino

Sintaxă

Arduino delay este cea mai simplă comandă și este cel mai des folosită de începători. În esență, este o întârziere care întrerupe programul pentru numărul de milisecunde indicat în paranteze. (Sunt 1000 de milisecunde într-o secundă.) Valoarea maximă poate fi 4294967295 ms, care este aproximativ egală cu 50 de zile. Să ne uităm la un exemplu simplu care arată clar cum funcționează această comandă.

Void setup() ( pinMode(13, OUTPUT); ) void loop() ( digitalWrite(13, HIGH); // trimite un semnal ridicat la pin 13 delay(10000); // pauză 10000ms sau 10 secunde digitalWrite13, LOW) ; // trimite un semnal scăzut la pinul 13 delay(10000); // pauză 10000 ms sau 10 secunde)

In metoda înființat Precizăm că pinul 13 va fi folosit ca ieșire. În partea principală a programului, un semnal ridicat este mai întâi trimis către pin, apoi îl întârziem cu 10 secunde. În acest timp, programul pare să fie suspendat. Apoi este dat un semnal scăzut și din nou există o întârziere și totul începe din nou. Ca rezultat, obținem că pinul este alimentat alternativ fie cu 5 V, fie cu 0.

Trebuie să înțelegeți clar că în timpul unei pauze de utilizare a întârzierii, activitatea programului este suspendată, aplicația nu va primi date de la senzori. Acesta este cel mai mare dezavantaj al folosirii funcției de întârziere Arduino. Puteți ocoli această limitare folosind întreruperi, dar vom vorbi despre asta într-un articol separat.

Exemplu de întârziere cu LED-ul care clipește

Un exemplu de circuit pentru a ilustra modul în care funcționează funcția de întârziere.
Puteți construi un circuit cu un LED și un rezistor. Apoi vom avea un exemplu standard - clipirea unui LED. Pentru a face acest lucru, trebuie să conectați un LED cu un contact pozitiv la pin, pe care l-am desemnat ca ieșire. Conectăm piciorul liber al LED-ului la masă printr-un rezistor de aproximativ 220 Ohmi (este posibil puțin mai mult). Puteți determina polaritatea uitându-vă la interiorul acesteia. Cupa mare din interior este conectată la minus, iar piciorul mic la plus. Dacă LED-ul este nou, atunci puteți determina polaritatea după lungimea cablurilor: piciorul lung este plus, piciorul scurt este minus.

Funcția delayMicroseconds

Această funcție este un analog complet al întârzierii, cu excepția faptului că unitățile sale de măsură nu sunt milisecunde, ci microsecunde (într-o secundă sunt 1.000.000 de microsecunde). Valoarea maximă va fi 16383, care este egală cu 16 milisecunde. Rezoluția este 4, adică numărul va fi întotdeauna un multiplu de patru. Un exemplu de fragment ar arăta astfel:

DigitalWrite(2, HIGH); // trimite un semnal mare la pinul 2 delayMicroseconds(16383); // pauză 16383 µs digitalWrite(2, LOW); // trimite un semnal scăzut la pinul 2 delayMicroseconds(16383); // pauză 16383 µs

Problema cu întârziereaMicrosecundelor este exact aceeași ca și cu întârzierea - aceste funcții „atârnă” complet programul și literalmente îngheață pentru o perioadă. În acest moment, este imposibil să lucrați cu porturi, să citiți informații de la senzori și să efectuați operații matematice. Această opțiune este potrivită pentru lumini intermitente, dar utilizatorii experimentați nu o folosesc pentru proiecte mari, deoarece astfel de defecțiuni nu sunt necesare acolo. Prin urmare, este mult mai bine să utilizați funcțiile descrise mai jos.

Funcția Millis în loc de întârziere

Funcția millis() vă va permite să efectuați o întârziere fără întârziere pe Arduino, eludând astfel deficiențele metodelor anterioare. Valoarea maximă a parametrului millis este aceeași cu cea a funcției de întârziere (4294967295ms sau 50 de zile).

Folosind millis, nu oprim execuția întregii schițe, ci pur și simplu indicăm cât timp Arduino ar trebui pur și simplu să „ocolească” blocul exact de cod pe care vrem să-l întrerupem. Spre deosebire de delay millis, nu oprește nimic de la sine. Această comandă pur și simplu ne returnează de la temporizatorul încorporat al microcontrolerului numărul de milisecunde care au trecut de la pornire. Cu fiecare apel la buclă, măsuram noi înșine timpul care a trecut de la ultimul apel al codului nostru și dacă diferența de timp este mai mică decât pauza dorită, atunci ignorăm codul. De îndată ce diferența devine mai mare decât pauza necesară, executăm codul, obținem ora curentă folosind aceleași milimetri și ne amintim - de această dată va fi noul punct de plecare. În următorul ciclu, numărătoarea inversă va fi deja din noul punct și vom ignora din nou codul până când noua diferență dintre milis și valoarea noastră salvată anterior ajunge din nou la pauza dorită.

Întârzierea fără întârziere folosind millis necesită mai mult cod, dar cu ajutorul acestuia puteți clipi un LED și puteți întrerupe o schiță fără a opri sistemul.

Iată un exemplu care ilustrează clar munca echipei:

Nesemnat de lungă durată; // Variabilă pentru stocarea punctului de referință void setup() ( Serial.begin(9600); ) void loop() ( /* În acest moment începe execuția analogului delay(). Calculați diferența dintre momentul curent și punctul de referință salvat anterior, dacă diferența este mai mare decât valoarea dorită, atunci executați codul. = millis(); Serial.println ("10 secunde");

Mai întâi introducem variabila de sincronizare, care va stoca numărul de milisecunde. În mod implicit, valoarea variabilei este 0. În partea principală a programului, verificăm condiția: dacă numărul de milisecunde de la începutul microcontrolerului minus numărul scris în variabila de sincronizare este mai mare de 10000, atunci se efectuează acțiunea de a trimite un mesaj către monitorul portului și valoarea curentă a timpului este scrisă în variabilă. Ca urmare a funcționării programului, mesajul 10 secunde va fi afișat pe monitorul portului la fiecare 10 secunde. Această metodă vă permite să clipiți LED-ul fără întârziere.

Micros funcționează în loc de întârziere

Această funcție poate efectua și o întârziere fără a utiliza comanda delay. Funcționează exact la fel ca milisecunde, dar numără mai degrabă microsecunde decât milisecunde cu o rezoluție de 4 μs. Valoarea sa maximă este de 4294967295 microsecunde sau 70 de minute. Dacă depășește, valoarea este pur și simplu resetată la 0, nu uitați de asta.

rezumat

Platforma Arduino ne oferă mai multe modalități de a implementa o întârziere în proiectul nostru. Folosind întârziere, puteți întrerupe rapid execuția unei schițe, dar, în același timp, veți bloca funcționarea microcontrolerului. Utilizarea comenzii millis vă permite să faceți fără întârziere în Arduino, dar acest lucru va necesita puțin mai multă programare. Alege cea mai bună metodă în funcție de complexitatea proiectului tău. De regulă, în schițe simple și cu o întârziere mai mică de 10 secunde, se folosește întârzierea. Dacă logica de operare este mai complexă și este necesară o întârziere mare, atunci este mai bine să folosiți milis în loc de întârziere.

Salut Andrei. Abordarea ta de a transfera cunoștințele și experiența acumulată este foarte interesantă. Ajută foarte mult în demersurile tale. Ei bine, eu, începând să stăpânesc arduino, am o dorință de progres. Mai mult, cu ajutorul din exterior o pot face mai repede. Deci: la început sarcina mea a fost să fac un robot care să conducă de-a lungul unei linii. Am făcut-o - totul a fost bine. Dar apoi, oferindu-i opțiuni suplimentare, nu am înțeles de ce a încetat să mai răspundă corect la linie. Am dat peste acest articol și am înțeles motivul.

Acum am o întrebare pentru tine: în schița menționată și finalizată mai jos, ținând cont de problemele cu întârzierea, trebuie să trec la millis peste tot unde este prezentă această funcție? Dacă da, atunci înțeleg că aproape toată schița va trebui refăcută? Și nu este complet clar cum să folosiți milimetrii în măsurarea distanței? Mulțumesc.

//Robot cu linie albă care urmează funcție

// ************************ Instalarea cablurilor motorului ************************ *

int MotorLeftSpeed = 5; // SPEED motor stânga (A) - ENA

int MotorLeftForward = 4; // Motorul stânga (A) ÎNAINTE - IN1

int MotorLeftBack = 3; // Motorul stânga (A) BACK - IN2

int MotorRightForward = 8; // Dreapta (B) motor FORWARD - IN3

int MotorRightBack = 7; // Motor dreapta (B) BACK - IN4

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

// ************************ Instalarea ieșirilor senzorilor cu ultrasunete************************ * *

int trigPinL = 14; // setarea numărului pin al senzorului ultrasonic trig stâng

int echoPinL = 15; // setarea numărului de ieșire al senzorului ultrasonic ecou stâng

int trigPinC = 10; // setarea numărului de ieșire al senzorului ultrasonic central trig

int echoPinC = 11; // setarea numărului de ieșire al senzorului cu ultrasunete eco central

int trigPinR = 12; // setarea codului PIN al senzorului ultrasonic trig drept

int echoPinR = 13; // setarea numărului de ieșire al senzorului ultrasonic ecou drept

// ******************** Instalarea pinii senzorului de linie ********************

const int LineSensorLeft = 19; // intrare senzor linie stânga

const int LineSensorRight = 18; // intrarea senzorului de linie dreaptă

int SL; // starea senzorului stâng

int SR; // starea senzorului din dreapta

// ********************Setarea ieșirii alarmei luminoase și sonore****************

int Lumină = 2; // setarea numărului ieșirii alarmei luminoase

int Zumm = 6; // setarea numărului de ieșire a soneriei

int ledState = LOW; // setați starea LED-ului cu această variabilă

lung precedentMillis = 0; // stochează ora ultimei comutare LED

interval lung = 300; // interval între pornirea/oprirea LED-ului (0,3 secunde)

// ********************* Măsurare variabilă a distanței prin senzori****************

unsigned int impulseTimeL=0;

unsigned int impulseTimeC=0;

unsigned int impulseTimeR=0;

distanță lungăL=0; // distanță măsurată de senzorul ultrasonic stâng

distanță lungăC=0; // distanta masurata de senzorul ultrasonic central

distR lung=0; // distanță măsurată de senzorul cu ultrasunete drept

// ********************************** ÎNFIINȚAT ************ * ********************

Serial.begin(9600); //porniți portul serial (viteza 9600)

//*************** Setați contactele motorului****************

pinMode(MotorRightBack, OUTPUT); // Motorul dreapta (B) ÎNAPOI

pinMode(MotorRightForward, OUTPUT); // Dreapta (B) motor înainte

pinMode(MotorLeftBack, OUTPUT); // Motorul stânga (A) ÎNAPOI

pinMode(MotorLeftForward, OUTPUT); // Motorul stânga (A) ÎNAINTE

întârziere (durată);

//*************** Setați contactele senzorului de bandă****************

pinMode(LineSensorLeft, INPUT); // definirea pinului senzorului de linie din stânga

pinMode(LineSensorRight, INPUT); // determinând pinul senzorului de linie dreaptă

// ****************Setarea modurilor de ieșire ale senzorilor cu ultrasunete************************

pinMode(trigPinL, OUTPUT); // setarea modului de funcționare a ieșirii trig stânga a senzorului ultrasonic

pinMode(echoPinL, INPUT); // setarea modului de funcționare al ieșirii senzorului ultrasonic ecoul stâng

pinMode(trigPinC, OUTPUT); // setarea modului de funcționare al ieșirii senzorului ultrasonic de declanșare centrală

pinMode(echoPinC, INPUT); // setarea modului de funcționare al ieșirii senzorului cu ultrasunete eco central

pinMode(trigPinR, OUTPUT); // setarea modului de funcționare al ieșirii senzorului ultrasonic trig drept

pinMode(echoPinR, INPUT); // setarea modului de funcționare al ieșirii senzorului cu ultrasunete ecoul drept

// ****************Setați contacte pentru alarme luminoase și sonore**************************** * *****

pinMode(Zumm,OUTPUT); // setarea modului de funcționare al ieșirii soneriei

pinMode (lumină, IEȘIRE); // setarea modului de funcționare a ieșirii de semnalizare luminoasă

// ******************** Comenzi de mișcare de bază ******************

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

analogWrite(MotorRightSpeed, sa);

analogWrite(MotorLeftSpeed, sa);

void dreapta (int b, int sb) // ROTATE RIGHT (o parte)

digitalWrite(MotorRightBack, LOW);

digitalWrite(MotorLeftBack, LOW);

digitalWrite(MotorLeftForward, HIGH);

analogWrite(MotorLeftSpeed, sb);

void stânga (int k, int sk) // RĂȘTIȚI LA stanga (o parte)

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);

// ********************************* Măsurarea distanței**************** ****** *

void izmdistL () // măsurarea distanței cu senzorul ultrasonic stâng

digitalWrite(trigPinL, HIGH);

digitalWrite(trigPinL, LOW); // Impuls de 10 mS la ieșirea trig a senzorului ultrasonic pentru măsurarea distanței

impulseTimeL = pulseIn(echoPinL, HIGH); // citirea distanței de la senzorul ultrasonic

distL=impulseTimeL/58; // Convertiți în centimetri

void izmdistC () // măsurarea distanței de către senzorul ultrasonic central

digitalWrite(trigPinC, HIGH);

digitalWrite(trigPinC, LOW); // Impuls de 10 mS la ieșirea trig a senzorului ultrasonic pentru măsurarea distanței

impulseTimeC = pulseIn(echoPinC, HIGH); // citirea distanței de la senzorul ultrasonic

distC=impulseTimeC/58; // Convertiți în centimetri

void izmdistR () // măsurarea distanței de către senzorul ultrasonic central

digitalWrite(trigPinR, HIGH);

digitalWrite(trigPinR, LOW); // Impuls de 10 mS la ieșirea trig a senzorului ultrasonic pentru măsurarea distanței

impulseTimeR = pulseIn(echoPinR, HIGH); // citirea distanței de la senzorul ultrasonic

distR=impulseTimeR/58; // Convertiți în centimetri

// ************************************ BUCLĂ ************ ********************

// ************************ LINE următorul mod ************************ ********* ***

// ********************* alarmă luminoasă și sonoră***************

ton (Zumm,900); // pornește sunetul la 900 Hz

ton (Zumm,900); // pornește sunetul la 800 Hz

unsigned long currentMillis = millis();

if (currentMillis - previousMillis > interval) //verificați dacă intervalul necesar a trecut, dacă a trecut atunci

previousMillis = currentMillis; // salvează ora ultimei comutare

if (ledState == LOW) // dacă LED-ul nu este aprins, atunci aprindeți-l și invers

ledState = HIGH;

digitalWrite(Light, ledState); // setați stările de ieșire pentru a porni sau opri LED-ul

// ************************ Măsurarea distanței************************ **

Serial.println(distL);

Serial.println(distC);

Serial.println(distR);

if (distL>50 && distC>50 && distR>50) // dacă distanța măsurată este mai mare de 50 de centimetri, mergem

SL = digitalRead(LineSensorLeft); // citește semnalul de la senzorul benzii din stânga

SR = digitalRead(LineSensorRight); // citește semnalul de la senzorul benzii din dreapta

// ******************************** Urmând linia neagră ************ ****** ****

// ROBOT pe bandă - mergeți drept

if (SL == LOW & SR == LOW) // ALB - ALB - merge DREPT

înainte (10, 100) // DIRECT (timp, viteză)

// ROBOT începe să iasă din bandă - rulăm

altfel dacă (SL == LOW & SR == HIGH) // NEGRU - ALB - rotiți la STÂNGA

la stânga (10, 100) // viraj STÂNGA (timp, viteză)

else if (SL == HIGH & SR == LOW) // ALB - NEGRU - intoarce DREAPTA

dreapta (10, 100) // viraj DREAPTA (timp, viteza)

// FINALIZARE - ROBOT vede dunga cu ambii senzori

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

stop (50);

else // daca distanta masurata este mai mica sau egala cu minimul - ne oprim