Arduino rămâne o oră. Arduino are o mulțime de sarcini pentru funcția suplimentară millis. Vikoristannya funcții arduino delay

Dacă doriți să „întrerupeți” microcontrolerul, tot ce trebuie să faceți este să introduceți o instrucțiune de întârziere în locația dorită a programului. Acesta este un instrument util dacă doriți să utilizați alte cuvinte, cum ar fi apăsarea unui buton. Și aici este necesar să implementați un fel de multitasking.

Deci, adăugând câteva linii de cod la programele tale, te va face, la rândul său, un programator mai bun și va crește potențialul Arduino. Pentru aceasta trebuie să înveți cum să folosești funcția millis.

Dacă îți dai seama că funcția de întârziere este folosită de programul tău Arduino, nu va funcționa deloc la această oră. În loc să ne finalizam întregul program pentru o lungă perioadă de timp, vom afla câte ore au trecut înainte de finalizare. Acest lucru, desigur, se bazează pe funcția suplimentară millis() și pe mulți prieteni grozavi pentru a ne salva datele. Pentru ca totul să fie ușor de înțeles, vom începe de la prima schiță inițială numită „Blink”, iar în acest caz o vom ilumina cu un LED fără umbrire.

Nucleul acestui program este același cu orice alt program standard pentru Arduino. Acum toate liniile de intrare/ieșire necesare au fost șterse (de exemplu, linia 13 pentru LED). Aici vom avea nevoie și de un schimbător de tip întreg pentru a salva linia de producție LED. Acesta va fi setat la LOW, iar părțile rămase ale LED-ului vor fi stinse. Apoi, să-l numim „previousMillis” la tipul „unsigned long”. La VIDMIN VID „int” dovgі Zmіnni fără semn, este 32 bіti, Tsarnoye pentru șerpi, cutia valoroasă a marelui - poteți de iac, iacul otikuvati, docurile nu sunt în sănătate. Schimbați anteriorMillis va fi folosit pentru a economisi timp atunci când ledul se aprinde din nou. Același tip este „const long”, este și pe 32 de biți, dar nu modifică valoarea, așa cum este cazul constantelor (în acest caz pentru constanta de interval). L-am setat la 1000 și vikorystvo ca o oră de pauză, care este măsurată în milisecunde.

Apoi intrăm într-un ciclu fără sfârșit. Amintiți-vă că vrem să ne amintim câte ore au trecut de la ultimul nostru moment, în cazul nostru 1000 ms. De îndată ce instrucțiunile au trecut, a sosit ora să schimbăm setarea diodei noastre emițătoare de lumină.

În primul rând, inserăm un „millis curent” lung nesemnat sau „millis()”, ceea ce înseamnă ora curentă în milisecunde. Acest lucru ne va ajuta să înțelegem că diferența dintre ora exactă și ora avansată este de 1000 ms. Pentru cine spunem: „Dacă ora exactă minus ora anterioară, dacă LED-ul nostru strălucește, este mai mare sau egală cu valoarea noastră alocată de 1000 ms, salvați ora minutului momentan rămas ca cea anterioară.” Acest lucru ne va ajuta să ghicim câte ore au trecut de la ultimul minut al ciclului. Apoi, dacă LED-ul devine LOW, setați-l la HIGH, în caz contrar setați-l la LOW. Apoi, folosind comanda digitalWrite, conectați moara de tăiere la LED.

În primul rând, un începător care stăpânește Arduino se confruntă cu faptul că puterea funcției delay() este inacceptabilă - blocarea programelor. Există o mulțime de aplicații pe Internet care folosesc această funcție, dar stagnarea practică sugerează că ar fi mai bine să te descurci fără ea.

Ca începător, mi-am construit propria bicicletă cu implementarea unui blocaj neblocator. Satul a stat astfel:

• Asigurați pseudo-monitorizare astfel încât diferitele etape să fie finalizate în timpul lor, la intervale proprii și să nu se blocheze reciproc.
• Bulo cu ușurință koristuvatsya tsim.
• Ar putea fi proiectat ca o bibliotecă și să includă cu ușurință alte proiecte fără copiere-lipire.

Rezultatul a fost acesta.

#include SmartDelay foo(1000000UL); // în microsecunde void loop () ( if (foo.Now()) ( // Codul de aici se bazează pe intervalul în microsecunde, valorile din constructor sunt mai mari. ) // Mai mult cod )
Metoda Now() returnează adevărat deoarece intervalul a trecut. Și aici începe din nou același interval. Deci, Now() acum „se reîncarcă” automat.

Lumina LED intermitentă clasică poate fi redusă simultan la o lumină intermitentă. De exemplu, becurile sunt conectate la fundul 12 și 11 și se aprind la intervale de 1s și 777ms de fiecare dată.

#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; ))
Ciclul poate fi configurat și pentru a ilumina LED-urile fără a bloca codul.

Este clar că este o înlocuire completă a delay(), care încetinește fluxul sarcinilor, necesitându-vă să scrieți un program ca MCA (mecanismul mașinii cu stare finală). Pentru a salva pasul și într-un mod diferit, mergeți la locul necesar pentru 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 ) rupere; cazul 2: if (d.Now()) ( action3(); d.Stop(); stare=0; ) break; ) ...
Metoda Set(interval) setează un nou interval și îl rotește pe cel vechi. Puteți privi pur și simplu intervalul folosind metoda Get() ;

Stop() resetează procesarea și Now() devine din nou fals.

Start() reînnoiește lucrarea și Now() începe să funcționeze ca înainte.

Dacă trebuie să încetinești timp de o oră, în loc să te oprești complet, folosește metoda Wait(). De exemplu, dacă LED-ul 12 luminează, dar nu luminează atunci când butonul este apăsat, este suficient să adăugați următorul cod la loop() într-o aplicație cu încă două diode:

If (digitalRead(9)) led12.Wait(); ...
Deci, cu un nivel ridicat al semnalului la 9 nr, dioda la 12 nu va fi semnificativă și nu va continua dacă apare 0.

Dacă în spatele unui astfel de „cronometru” există, de exemplu, un ecran și butoanele sunt pictate în paralel, atunci este necesar să pictați ecranul sau o parte a ecranului după apăsarea butonului și să nu așteptați sfârșitul intervalului. În acest scop, este folosită metoda Reset(), după orice atac apelul Now() returnează true. De exemplu:

Afișaj SmartDelay (1000000UL); void loop() ( if (btClick()) display.Reset(); // când faceți clic pe buton, trebuie să pictați ecranul. if (display.Now()) screenRedraw(); // pictați ecranul )
Există doar erori în care vindecatorul de microsecunde nu este acoperit, dar în caz contrar, codul trebuie curățat. Nu-mi place pentru că Reset() este stricat, încă mă gândesc.

Funcția millis() vă permite să schimbați ora care a trecut de la începutul programului cu fire. Funcția rotește valorile în format lung nesemnat și vă permite să introduceți valori până la 50 de zile din momentul lansării programului. După această oră va începe din nou. Mai jos este exemplul funcției millis():

Nesemnat de mult timp; void setup())( Serial.begin(9600); ) void loop())( Serial.print("On hour: "); time = millis(); // amintiți-vă ora Serial.println(time); / / trimiterea de informații prin întârzierea portului serial (1000);

La aplicația selectată, în fiecare secundă portul monitor va primi informații despre ora care a trecut de la momentul lansării programului. În timp ce ora este măsurată în milisecunde, valoarea pielii va fi împărțită la 1000. Precizia citirii depinde de stabilitatea rezonatorului cuarț Arduino.

Funcția micros()

Funcția micros() este analogă cu funcția millis(), diferența constă în precizia măsurării. Funcția suplimentară micros() durează în microsecunde ora care se scurge de la începutul programului de fir. Doctorul de microsecunde reîmprospătat va fi eliminat după 70 de minute. Mai jos este exemplul funcției micros():

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

La fel ca într-o aplicație cu funcția millis(), informațiile despre ora curentă vor fi trimise în portul monitorului în fiecare secundă, diferența constă doar în faptul că în acest caz ora se măsoară în microsecunde.

Întârziere funcție()

Funcția delay() vă permite să întârziați execuția unui program threaded pentru o oră specificată. Sintaxa comenzii arată astfel:

// Întârziere comandă (500); // Oprire pentru 0,5 secunde // Întârziere comandă (1000); //Oprire pentru 1s

Ora este indicată în milisecunde (1 sec = 1000 ms). Acest parametru poate fi de tip unsigned long, care se află în intervalul de la 0 la 4294967295. Mai jos este exemplul comenzii delay():

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

Când aplicația este îndreptată, 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 pornit.

Funcția delayMicrosecunde()

Funcția delayMicroseconds() este un tip de funcție delay(). Diferența depinde de cantitate și de precizie în funcție de oră. Funcția delay() vă permite să reglați ora cu o precizie de până la 1 milisecundă, precum și delayMicroseconds() cu o precizie de până la 1 microsecundă.

Valorile care pot fi specificate în parametru sunt în intervalul de la 0 la 16383. Pentru intervale de timp mai lungi, puteți utiliza 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 delayMicrosecunde(50); // pauză 50 microsecunde digitalWrite(outPin, LOW // pin 8 low delayMicrosecunde(50) // pauză 50 microsecunde);

Acest dispozitiv generează un meandre cu o perioadă de 100 de microsecunde și o rată de umplere de 50%.

Tăierea în Arduino joacă un rol foarte important. Fără ele, este imposibil să lucrezi cu cel mai simplu dispozitiv Blink, care strălucește cu un LED pentru o perioadă de timp. Dar majoritatea programatorilor începători știu puțin despre întârzieri și folosesc doar Arduino delay, fără a cunoaște efectele secundare ale acestei comenzi. În acest articol, voi vorbi despre funcțiile ceasului și despre caracteristicile utilizării lor în nucleul IDE-ului Arduino.

În Arduino există o serie de comenzi diferite care indică lucrul cu o oră și pauză:

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

Acestea variază ca precizie și își dezvoltă propriile caracteristici, așa cum fac atunci când scriu cod.

Vikoristannya funcții arduino delay

Sintaxă

Arduino delay este cea mai simplă comandă și este cea mai des folosită de începători. În esență, este o oprire care pornește robotul cu un program, numărul de milisecunde este indicat în brațe. (Sunt 1000 de milisecunde într-o secundă.) Valoarea maximă poate fi 4294967295 ms, adică aproximativ 50 dB. Să aruncăm o privire la un exemplu simplu care arată clar robotului aceste comenzi.

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 13 pini delay (10000); // pauză 10000 ms sau 10 secunde)

La metoda înființat Se spune că luni 13 va fi vikorystuvatsya ca o cale de ieșire. În partea principală a programului, un semnal ridicat este trimis către pin, apoi o întârziere de 10 secunde. Pentru această oră programul se va opri. Apoi este dat un semnal scăzut și oprirea începe din nou și totul începe din nou. Ca rezultat, putem determina că fie 5, fie 0 este trimis la pin.

Este necesar să înțelegeți clar că în timpul unei ore de pauză pentru întârziere suplimentară, programul robotului pornește, programul nu elimină datele necesare din senzori. Acesta este cel mai mare dezavantaj al funcției de întârziere din Arduino. Puteți ocoli acest schimb pentru întreruperi suplimentare, dar despre asta vom vorbi la statistici.

Delay fund cu lumini LED

Exemplu de circuite pentru a ilustra funcția de întârziere.
Puteți utiliza circuitul cu un LED și un rezistor. Apoi vom vedea un butt standard - LED intermitent. Pentru a face acest lucru, pe pinul pe care l-am desemnat ca ieșire, trebuie să conectați LED-ul la contactul pozitiv. Conectez piciorul LED printr-un rezistor de aproximativ 220 Ohmi (este posibil puțin mai mult) și îl conectez la masă. Prin urmare, polaritatea este posibilă minunându-mă de interiorul său. Doamna cea mare din mijloc este conectată cu un minus, iar fetița cu un plus. Dacă LED-ul este nou, atunci polaritatea poate fi determinată de lungimea pinii: piciorul lung este plus, piciorul scurt este minus.

Funcția delayMicrosecunde

Această funcție este un alt analog al întârzierii, cu excepția faptului că unitățile sale nu sunt milisecunde, ci microsecunde (într-o secundă sunt 1.000.000 de microsecunde). Valoarea maximă va fi 16383, adică mai mult de 16 milisecunde. Clădirea separată este egală cu 4, deci numărul va fi întotdeauna un multiplu de patru. Voi pune fundul împreună așa:

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

Problema cu întârziereaMicrosecundelor este aceeași ca și cu întârzierea – aceste funcții în esență „atârnă” programul și îngheață literalmente zece ore. Este dificil să lucrați cu porturi, să citiți informații de la senzori și să efectuați operații matematice. Pentru flashere, această opțiune este potrivită, cu excepția cazului în care dezvoltatorii nu le folosesc pentru proiecte mari, deoarece astfel de eșecuri nu sunt necesare acolo. Prin urmare, există multe mai multe funcții interesante descrise mai jos.

Funcția milis întârziere înlocuire

Funcția millis() vă permite să opriți oprirea fără întârziere pe Arduino, introducând astfel câteva metode avansate. Valoarea maximă a parametrului millis este aceeași ca și pentru funcția de întârziere (4294967295ms sau 50 dB).

De dragul acestui milis, nu accentuăm întreaga schiță, ci pur și simplu indicăm de câte ori Arduino poate pur și simplu „în minus” chiar blocul de cod pe care vrem să-l reducem. De fapt, delay millis nu înseamnă nimic în sine. Această comandă ne spune pur și simplu numărul de milisecunde care au trecut de la pornirea microcontrolerului. Cu o buclă de apel de piele, noi înșine măsuram ora care a trecut de la restul apelului la codul nostru, iar dacă diferența de oră este mai mică decât pauza necesară, atunci codul este ignorat. De îndată ce diferența devine mai mare pentru pauza necesară, finalizăm codul, scadem ora curentă pentru următorii milimetri și o memorăm - acea oră va fi un nou punct de plecare. În următorul ciclu va apărea un nou punct și vom ignora din nou codul până când noua diferență dintre milis și valoarea noastră salvată anterior ajunge la pauza necesară.

Oprirea fără întârziere cu ajutorul millis are ca rezultat un cod mai mare, iar cu acest ajutor puteți clipi LED-ul și întrerupeți schița fără a întrerupe sistemul.

Axa este un cap, care ilustrează clar comanda robotului:

Nesemnat de lungă durată; // Modificat pentru a salva momentul în timp void setup() ( Serial.begin(9600); ) void loop() ( /* În care moment începe analogul corespunzător delay() Calculăm diferența dintre momentul curent și momentul salvat anterior, diferența este mai mare decât valoarea necesară, atunci nu avem nevoie de nimic */ if (millis() - timing > 10000)( // Înlocuiește 10000 cu valoarea pauză = millis(); Serial.println ("10 secunde");

Acum intrăm în modificarea timpului, ceea ce va economisi câteva milisecunde. După calcul, valoarea variabilei este 0. Practic, programul verifică mintea: câte milisecunde de la pornirea microcontrolerului minus numărul scris în variabila de sincronizare este mai mare decât, mai mică de 10 000, acțiunea din notificarea afișată pe monitorul portului este finalizată și valoarea exactă a timpului este înregistrată în memorie. Ca urmare a rulării programului timp de 10 secunde, monitorul portului va afișa 10 secunde. Această metodă vă permite să clipiți LED-ul fără întârziere.

Întârzierea funcției Micros

Această funcție poate suprascrie comanda de întârziere fără a utiliza comanda de întârziere. Funcționează la fel ca milisecunde, dar ceea ce contează nu sunt milisecunde, ci microsecunde cu o separare de 4 µs. Valoarea maximă este de 4294967295 microsecunde sau 70 de secunde. Dacă valoarea este schimbată, este pur și simplu resetată la 0, nu uitați de acest lucru.

rezumat

Platforma Arduino oferă o serie de moduri de a vă personaliza proiectul. Pentru o întârziere suplimentară, puteți întrerupe rapid schița video, altfel veți bloca robotul microcontrolerului. Utilizarea comenzii millis vă permite să utilizați Arduino fără întârziere, dar pentru asta aveți nevoie de puțin mai multă programare. Alege cea mai scurtă metodă în funcție de complexitatea proiectului tău. De regulă, pentru schițe simple și când timpul este mai mic de 10 secunde, utilizați întârziere. Deoarece logica robotului este complexă și este nevoie de mult efort, atunci este mai bine să înlocuiți întârzierea decât să înlocuiți milis.

Vitayu, Andriy. Chiar înainte de a vă preda bagajele, cunoașteți dovezile a ceea ce ați acumulat. Chiar ajută la sarcini. Ei bine, încep să stăpânesc arduino și sper să progresez. Este mai important să obțin rezultate mai bune din ajutorul extern. De acum înainte, treaba mea a fost să creez un robot de-a lungul liniei. Zrobiv totul este miraculos. În afară de asta, după ce le-au oferit opțiuni suplimentare, ei nu au înțeles de ce au încetat să răspundă corect la linie. După ce am atins acest articol și am înțeles motivul.

Acum am mâncare înaintea ta: pentru schițele mai ieftine și gata făcute, probleme medicale cu întârziere, ce trebuie să fac, unde este această funcție pentru a trece la millis? Dacă da, atunci înțeleg că toată schița va trebui refăcută? Și nu este complet clar cum să vikoristovat millis în lume? Dyakuyu.

//Robot cu funcția de a trece printr-un smoothie alb

// ************************ Instalarea de noi motoare ************************ * *

int MotorLeftSpeed ​​​​= 5; //Livy (A) motor SWIDKIST - 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; // Dreapta (B) motor SPATE - IN4

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

// ************************ Instalarea senzorilor cu ultrasunete************************ ****** *

int trigPinL = 14; // Specificați numărul senzorului ultrasonic trig stâng

int echoPinL = 15; // Specificați numărul senzorului ultrasonic ecou stâng

int trigPinC = 10; // Specificați numărul senzorului ultrasonic central trig

int echoPinC = 11; // Specificați numărul senzorului ultrasonic ecou central

int trigPinR = 12; // Specificați numărul de afișare al senzorului ultrasonic trig drept

int echoPinR = 13; // Specificați numărul senzorului ultrasonic ecou drept

// ********************* Instalarea senzorilor suplimentari de linie ********************

const int LineSensorLeft = 19; // Intrarea senzorului de linie din stânga

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

int SL; // Starea senzorului din stânga

int SR; // starea senzorului din dreapta

// ********************* Instalarea alarmelor luminoase și sonore****************

int Lumină = 2; // Specificarea numărului alarmei luminoase

int Zumm = 6; // Setați numărul de afișat la sonerie

int ledState = LOW; // prin schimbarea sursei de alimentare cu LED-uri

lung precedentMillis = 0; // salvează ora de remixare a LED-urilor rămase

interval lung = 300; // Interval între ridicarea/coborârea LED-ului (0,3 secunde)

// ********************* Schimbați măsurarea distanței de către senzori****************

unsigned int impulseTimeL=0;

unsigned int impulseTimeC=0;

unsigned int impulseTimeR=0;

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

distanță lungăC=0; //Distanța măsurată de senzorul ultrasonic central

distR lung=0; // distanta masurata de senzorul ultrasonic drept

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

Serial.begin(9600); // lansează portul serial (viteza 9600)

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

pinMode(MotorRightBack, OUTPUT); // Dreapta (B) motor ÎNAPOI

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

pinMode(MotorLeftBack, OUTPUT); //Livy (A) motor ÎNAPOI

pinMode(MotorLeftForward, OUTPUT); // Motor ușor (A) ÎNAINTE

întârziere (durată);

//*************** Setează contactele senzorilor de fum***************

pinMode(LineSensorLeft, INPUT); // Pin atribuit senzorului de linie din stânga

pinMode(LineSensorRight, INPUT); // Pin atribuit senzorului de linie dreaptă

//****************Setarea modurilor senzorilor cu ultrasunete**************************** **

pinMode(trigPinL, OUTPUT); // Setați modul robotic pentru afișarea senzorului ultrasonic trig stânga

pinMode(echoPinL, INPUT); // Setați modul robotic pentru afișarea senzorului ultrasonic ecoul stâng

pinMode(trigPinC, OUTPUT); // Setați modul robot pentru afișarea senzorului ultrasonic central de declanșare

pinMode(echoPinC, INPUT); // Setați modul robot pentru afișarea senzorului ultrasonic de eco central

pinMode(trigPinR, OUTPUT); // Setați modul robot pentru afișarea senzorului ultrasonic trig corect

pinMode(echoPinR, INPUT); // Setați modul robot pentru afișarea senzorului ultrasonic ecou drept

// ********************Setați contactele de alarmă luminoasă și sonoră************************ ************* *****

pinMode(Zumm, OUTPUT); // Setați modul robot pentru a afișa soneria

pinMode (lumină, IEȘIRE); // Setați modul robot pentru a afișa alarma luminoasă

// ******************** Comenzi de bază pentru roc ******************

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) // ROTATE LEFT (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);

// ************************************Vizualizare la distanta**************** ****** *

void izmdistL() // Valoarea distanței cu senzorul ultrasonic din stânga

digitalWrite(trigPinL, HIGH);

digitalWrite(trigPinL, LOW); // Impuls de 10 mS la ieșirea senzorului ultrasonic trig al senzorului de vibrații

impulseTimeL = pulseIn(echoPinL, HIGH); // citirea ieșirii de la senzorul ultrasonic

distL=impulseTimeL/58; // Poate fi supraîncărcat până la 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 senzorului ultrasonic trig al senzorului de vibrații

impulseTimeC = pulseIn(echoPinC, HIGH); // citirea ieșirii de la senzorul ultrasonic

distC=impulseTimeC/58; // Poate fi supraîncărcat până la 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 senzorului ultrasonic trig al senzorului de vibrații

impulseTimeR = pulseIn(echoPinR, HIGH); // citirea ieșirii de la senzorul ultrasonic

distR=impulseTimeR/58; // Poate fi supraîncărcat până la centimetri

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

// ************************ Mod de mers pe linie ************************ ********* ***

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

ton (Zumm, 900); // Activați sunetul la 900 Hz

ton (Zumm, 900); // Activați sunetul la 800 Hz

unsigned long currentMillis = millis();

if (currentMillis - previousMillis > interval) //verifică dacă intervalul necesar nu a trecut, dacă a trecut

previousMillis = currentMillis; // salvează o oră de întrerupere rămasă

if (ledState == LOW) // dacă LED-ul nu este aprins, atunci este aprins și totuși

ledState = HIGH;

digitalWrite(Light, ledState); // setați ieșirea să oprească sau să oprească LED-ul

// ************************ distanta Vimir************************ ********** **

Serial.println(distL);

Serial.println(distC);

Serial.println(distR);

if (distL>50 && distC>50 && distR>50) // dacă distanța estimată este mai mare de 50 de centimetri - idemo

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

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

// ******************************** Mergând de-a lungul liniei negre *********** ******** ****

// Robot pe un smoothie - să mergem drept

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

înainte (10, 100); // DIRECT (oră, viteză)

// Robotul începe să se miște în întuneric - controlat

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

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

altfel dacă (SL == HIGH & SR == LOW) // ALB - NEGRU - întoarceți DREAPTA

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

// FINALIZARE - ROBOT pompează senzori în corp

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

stop(50); // STOP

else // dacă distanța curentă este mai mică sau distanța tradițională este minimă - cost