Î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țin despre întârzieri ș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 la pin, apoi facem o întârziere de 10 secunde. În acest timp, programul pare să fie suspendat. Apoi se dă 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 punct de referință salvat anterior. Dacă diferența este mai mare decât valoarea dorită, atunci executați codul. Dacă nu, nu faceți nimic */ if (millis() - timing > 10000)( // În loc de 10000, înlocuiți valoarea de pauză de care aveți nevoie de sincronizare = 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.
" prezintă cursul de formare „Arduino pentru începători”. Seria constă din 10 lecții, precum și material suplimentar. Lecțiile includ instrucțiuni text, fotografii și videoclipuri cu instrucțiuni. În fiecare lecție veți găsi o listă de componente necesare, o listă de programe și o diagramă de conectare. Odată ce ați finalizat aceste 10 lecții de bază, veți putea trece la modele mai interesante și la construirea de roboți bazați pe Arduino. Cursul se adresează începătorilor; nu sunt necesare informații suplimentare din inginerie electrică sau robotică pentru a-l începe.
Scurte informații despre Arduino
Ce este Arduino?
Arduino (Arduino) este o platformă de calcul hardware, ale cărei componente principale sunt o placă de intrare-ieșire și un mediu de dezvoltare. Arduino poate fi folosit pentru a crea obiecte interactive de sine stătătoare sau pentru a se conecta la software care rulează pe un computer. Arduino este un computer cu o singură placă.
Cum sunt conectați Arduino și roboții?
Răspunsul este foarte simplu - Arduino este adesea folosit ca creierul robotului.
Avantajul plăcilor Arduino față de platforme similare este prețul lor relativ scăzut și distribuția aproape pe scară largă în rândul amatorilor și profesioniștilor din robotică și inginerie electrică. Odată ce intrați în Arduino, veți găsi asistență în orice limbă și oameni care vă vor răspunde la întrebări și vor discuta despre evoluțiile dvs.
Lecția 1. LED intermitent pe Arduino
În prima lecție veți învăța cum să conectați un LED la un Arduino și să îl controlați să clipească. Acesta este cel mai simplu și de bază model.
Dioda electro luminiscenta- un dispozitiv semiconductor care creează radiații optice atunci când un curent electric este trecut prin el în direcția înainte.
Lecția 2. Conectarea unui buton pe Arduino
În acest tutorial veți învăța cum să conectați un buton și un LED la un Arduino.
Când butonul este apăsat, LED-ul se va aprinde; când butonul este apăsat, nu se va aprinde. Acesta este și modelul de bază.
Lecția 3. Conectarea unui potențiometru la Arduino
În acest tutorial veți învăța cum să conectați un potențiometru la Arduino.
Potențiometru- Acest rezistență cu rezistență reglabilă.Potențiometrele sunt folosite ca regulatori ai diferiților parametri - volumul sunetului, puterea, tensiunea etc.Aceasta este, de asemenea, una dintre schemele de bază. În modelul nostru de la rotirea butonului potențiometruluiLuminozitatea LED-ului va depinde.
Lecția 4. Controlul servo pe Arduino
În acest tutorial veți învăța cum să conectați un servo la un Arduino.
Servoeste un motor a cărui poziție a arborelui poate fi controlată prin setarea unghiului de rotație.
Servo-urile sunt folosite pentru a simula diverse mișcări mecanice ale roboților.
Lecția 5. LED-uri în trei culori pe Arduino
În acest tutorial veți învăța cum să conectați un LED tricolor la un Arduino.
LED tricolor(led rgb) - acestea sunt trei LED-uri de culori diferite într-o singură carcasă. Acestea vin fie cu o placă mică de circuit imprimat pe care sunt amplasate rezistențele, fie fără rezistențe încorporate. Lecția acoperă ambele opțiuni.
Lecția 6. Element piezoelectric pe Arduino
În această lecție veți învăța cum să conectați un element piezo la un Arduino.
Element piezo- un convertor electromecanic care se traduce tensiune electrică în vibrația membranei. Aceste vibrații creează sunet.
În modelul nostru, frecvența sunetului poate fi reglată prin setarea parametrilor corespunzători în program.
Lecția 7. Fotorezistor pe Arduino
În această lecție a cursului nostru veți învăța cum să conectați un fotorezistor la Arduino.
Fotorezistor- un rezistor a cărui rezistență depinde de luminozitatea luminii care cade pe el.
În modelul nostru, LED-ul se aprinde numai dacă luminozitatea luminii de deasupra fotorezistorului este mai mică decât o anumită luminozitate; această luminozitate poate fi reglată în program.
Lecția 8. Senzor de mișcare (PIR) pe Arduino. Trimiterea automată de e-mail
În această lecție a cursului nostru veți învăța cum să conectați un senzor de mișcare (PIR) la Arduino, precum și să organizați trimiterea automată de e-mail. 
Senzor de mișcare (PIR)- senzor infrarosu pentru a detecta miscarea sau prezenta oamenilor sau animalelor.
În modelul nostru, atunci când primește un semnal despre mișcarea omului de la un senzor PIR, Arduino trimite o comandă către computer pentru a trimite un e-mail și scrisoarea este trimisă automat.
Lecția 9. Conectarea unui senzor de temperatură și umiditate DHT11 sau DHT22
În această lecție a noastră, veți învăța cum să conectați un senzor de temperatură și umiditate DHT11 sau DHT22 la un Arduino și, de asemenea, vă veți familiariza cu diferențele dintre caracteristicile acestora. 
Senzor de temperatura si umiditate este un senzor digital compozit format dintr-un senzor capacitiv de umiditate și un termistor pentru măsurarea temperaturii.
În modelul nostru, Arduino citește citirile senzorului și afișează citirile pe ecranul computerului.
Lecția 10. Conectarea unei tastaturi matrice
În această lecție a cursului nostru, veți învăța cum să conectați o tastatură matriceală la o placă Arduino și, de asemenea, să vă familiarizați cu diverse circuite interesante.
Tastatura Matrix inventat pentru a simplifica conectarea unui număr mare de butoane. Astfel de dispozitive se găsesc peste tot - în tastaturile computerelor, calculatoare și așa mai departe.
Lecția 11. Conectarea modulului de ceas în timp real DS3231
În ultima lecție a cursului nostru, veți învăța cum să conectați un modul de ceas în timp real din familie 
DS la placa Arduino și, de asemenea, familiarizați-vă cu diverse circuite interesante.
Modul ceas în timp real- acesta este un circuit electronic destinat înregistrării datelor cronometrice (ora curentă, data, ziua săptămânii etc.), și este un sistem format dintr-o sursă de alimentare autonomă și un dispozitiv de înregistrare.
Aplicație. Cadre gata făcute și roboți Arduino
Puteți începe să învățați Arduino nu numai de pe placa în sine, ci și prin achiziționarea unui robot gata făcut, cu drepturi depline, bazat pe această placă - un robot păianjen, o mașină robot, un robot țestoasă etc. Astfel de cale Este potrivit și pentru cei care nu sunt deosebit de atrași de circuitele electrice.
Prin achiziționarea unui model de robot funcțional, de ex. de fapt, o jucărie high-tech gata făcută poate trezi interesul pentru design independent și robotică. Deschiderea platformei Arduino vă permite să faceți jucării noi din aceleași componente.
O altă opțiune este să achiziționați un cadru sau un corp de robot: o platformă pe roți sau o pistă, un umanoid, un păianjen etc. În acest caz, va trebui să faceți singur umplutura robotului.
Aplicație. Directorul mobil
– un asistent pentru dezvoltatorii de algoritmi pentru platforma Arduino, al cărui scop este acela de a oferi utilizatorului final posibilitatea de a avea un set mobil de comenzi (carte de referință).
Aplicația constă din 3 secțiuni principale:
- Operatori;
- Date;
- Funcții.
De unde să cumpărați Arduino
truse Arduino
Cursul va fi actualizat cu lecții suplimentare. Urmați-ne
Astăzi vom vorbi despre utilizarea cardurilor SD și micro SD în Arduino. Ne vom da seama cum să conectăm cardurile SD la Arduino, cum să scriem și să citim informații. Utilizarea memoriei suplimentare poate fi foarte utilă în multe proiecte. Dacă nu știți ce sunt pinii SPI, I2C și analogi, atunci vă sfătuiesc să urmăriți lecțiile trecute și să înțelegeți aceste interfețe de comunicare Arduino.
În acest tutorial vom vorbi despre comunicarea wireless între două plăci Arduino. Acest lucru poate fi foarte util pentru a transmite comenzi de la un Arduino la altul sau pentru a face schimb de informații între bricolajele tale. Posibilitatea transmiterii de date wireless deschide noi oportunități în crearea proiectelor dumneavoastră.
În acest tutorial vom afla despre magistrala I2C. I2C este o magistrală de comunicații care utilizează doar două linii. Folosind această interfață, Arduino poate comunica cu multe dispozitive prin două fire. Astăzi ne vom da seama cum să conectăm senzorii la Arduino prin magistrala I2C, cum să accesăm un anumit dispozitiv și cum să primim date de la aceste dispozitive.
În acest tutorial vom vorbi despre interfața de comunicare serială Arduino. Am folosit deja această interfață în lecțiile anterioare, când am afișat valorile de la senzori pe ecranul computerului. Astăzi vom arunca o privire mai atentă asupra modului în care funcționează această conexiune și vom învăța, de asemenea, cum să folosim datele transferate pe monitorul portului computerului folosind Procesare.
Astăzi vom vorbi despre tranzistori și conectarea sarcinilor la Arduino. Arduino în sine nu poate produce o tensiune mai mare de 5 volți și un curent mai mare de 40 mA de la un pin. Acest lucru este suficient pentru senzori și LED-uri, dar dacă dorim să conectăm dispozitive care necesită mai mult curent, va trebui să folosim tranzistori sau relee.
În această lecție vom vorbi despre elementele de bază ale proiectării circuitelor aplicate la Arduino. Și să începem, desigur, cu legea lui Ohm, deoarece aceasta este baza tuturor circuitelor. Tot în această lecție vom vorbi despre rezistență, rezistențe pull-up și pull-up, calculul curentului și tensiunii.
În acest articol, am decis să alcătuiesc un ghid complet pas cu pas pentru începătorii Arduino. Ne vom uita la ce este Arduino, ce aveți nevoie pentru a începe să învățați, de unde să descărcați și cum să instalați și să configurați mediul de programare, cum funcționează și cum să utilizați limbajul de programare și multe altele care sunt necesare pentru a crea cu drepturi depline. dispozitive complexe bazate pe familia acestor microcontrolere.
Aici voi încerca să dau un minim condensat, astfel încât să înțelegeți principiile lucrului cu Arduino. Pentru o imersiune mai completă în lumea microcontrolerelor programabile, acordați atenție altor secțiuni și articole ale acestui site. Voi lăsa link-uri către alte materiale pe acest site pentru un studiu mai detaliat al unor aspecte.
Ce este Arduino și pentru ce este?
Arduino este un kit de construcție electronică care permite oricui să creeze o varietate de dispozitive electro-mecanice. Arduino este format din software și hardware. Partea software include un mediu de dezvoltare (un program pentru scrierea și depanarea firmware-ului), multe biblioteci gata făcute și convenabile și un limbaj de programare simplificat. Hardware-ul include o linie mare de microcontrolere și module gata făcute pentru acestea. Datorită acestui lucru, lucrul cu Arduino este foarte ușor!
Cu ajutorul Arduino puteți învăța programare, inginerie electrică și mecanică. Dar acesta nu este doar un constructor educațional. Pe baza acestuia, puteți crea dispozitive cu adevărat utile.
Pornind de la simple lumini intermitente, stații meteo, sisteme de automatizare și terminând cu sisteme de casă inteligentă, mașini CNC și vehicule aeriene fără pilot. Posibilitățile nu sunt nici măcar limitate de imaginația ta, deoarece există un număr mare de instrucțiuni și idei de implementare.
Kit de pornire Arduino
Pentru a începe să învățați Arduino, trebuie să achiziționați placa microcontrolerului în sine și părți suplimentare. Cel mai bine este să achiziționați un kit de pornire Arduino, dar puteți alege singur tot ce aveți nevoie. Recomand să alegeți un set pentru că este mai ușor și adesea mai ieftin. Iată link-uri către cele mai bune seturi și părți individuale pe care cu siguranță va trebui să le studiați:
| Kit de bază Arduino pentru începători: | Cumpără |
| Set mare pentru antrenament și primele proiecte: | Cumpără |
| Set de senzori și module suplimentari: | Cumpără |
| Arduino Uno este cel mai simplu și mai convenabil model din linie: | Cumpără |
| Placă fără sudură pentru învățare și prototipare ușoară: | Cumpără |
| Set de fire cu conectori convenabil: | Cumpără |
| Set LED: | Cumpără |
| Kit rezistoare: | Cumpără |
| Butoane: | Cumpără |
| Potențiometre: | Cumpără |
Mediul de dezvoltare Arduino IDE
Pentru a scrie, depana și descărca firmware, trebuie să descărcați și să instalați IDE-ul Arduino. Acesta este un program foarte simplu și convenabil. Pe site-ul meu am descris deja procesul de descărcare, instalare și configurare a mediului de dezvoltare. Prin urmare, aici voi lăsa pur și simplu link-uri către cea mai recentă versiune a programului și către
| Versiune | Windows | Mac OS X | Linux |
| 1.8.2 |
Limbajul de programare Arduino
Când aveți o placă de microcontroler în mâini și un mediu de dezvoltare instalat pe computer, puteți începe să scrieți primele schițe (firmware). Pentru a face acest lucru, trebuie să vă familiarizați cu limbajul de programare.
Programarea Arduino folosește o versiune simplificată a limbajului C++ cu funcții predefinite. Ca și în alte limbaje de programare asemănătoare C, există o serie de reguli pentru scrierea codului. Iată cele mai de bază:
- Fiecare instrucțiune trebuie să fie urmată de un punct și virgulă (;)
- Înainte de a declara o funcție, trebuie să specificați tipul de date returnat de funcție sau nul dacă funcția nu returnează o valoare.
- De asemenea, este necesar să se indice tipul de date înainte de a declara o variabilă.
- Comentariile sunt desemnate: // Inline și /* bloc */
Puteți afla mai multe despre tipurile de date, funcții, variabile, operatori și construcții de limbaj pe pagina de Nu este necesar să memorați și să vă amintiți toate aceste informații. Puteți oricând să mergeți la cartea de referință și să vă uitați la sintaxa unei anumite funcții.
Toate firmware-ul Arduino trebuie să conțină cel puțin 2 funcții. Acestea sunt setup() și loop().
funcția de configurare
Pentru ca totul să funcționeze, trebuie să scriem o schiță. Să facem LED-ul să se aprindă după apăsarea butonului și să ne stingem după următoarea apăsare. Iată prima noastră schiță:
// variabile cu pinii dispozitivelor conectate int switchPin = 8; int ledPin = 11; // variabile pentru a stoca starea butonului și LED-ul boolean lastButton = LOW; curent booleanButton = LOW; boolean ledOn = fals; void setup() ( pinMode(switchPin, INPUT); pinMode(ledPin, OUTPUT); ) // funcție pentru debouncing boolean debounse(boolean last) ( boolean current = digitalRead(switchPin); if (last != current) ( întârziere ( 5); curent = digitalRead(switchPin); ) returnează curent; ) void loop() ( currentButton = debounse(lastButton); if(lastButton == LOW && currentButton == HIGH) ( ledOn = !ledOn; ) lastButton = currentButton ; digitalWrite(ledPin, ledOn); )
// variabile cu pini de dispozitive conectate int switchPin = 8 ; int ledPin = 11 ; // variabile pentru a stoca starea butonului și a LED-ului boolean lastButton = LOW ; curent booleanButton = LOW ; boolean ledOn = fals ; void setup() ( pinMode(switchPin, INPUT); pinMode(ledPin, OUTPUT); // funcţie pentru debouncing boolean debounse (boolean last ) ( curent boolean = digitalRead(switchPin); dacă (ultimul != curent ) ( întârziere(5); curent = digitalRead(switchPin); curent de retur; void loop() ( currentButton = debounse(lastButton); dacă (lastButton == LOW && currentButton == HIGH ) ( ledOn = ! A condus la; lastButton = curentButton ; digitalWrite(ledPin, ledOn); |
În această schiță, am creat o funcție suplimentară de debounse pentru a suprima respingerea contactului. Există informații despre respingerea contactelor pe site-ul meu. Asigurați-vă că verificați acest material.
PWM Arduino
Modularea lățimii impulsului (PWM) este procesul de control al tensiunii folosind ciclul de lucru al unui semnal. Adică, folosind PWM putem controla fără probleme sarcina. De exemplu, puteți modifica fără probleme luminozitatea unui LED, dar această modificare a luminozității se obține nu prin scăderea tensiunii, ci prin creșterea intervalelor semnalului scăzut. Principiul de funcționare al PWM este prezentat în această diagramă:
Când aplicăm PWM la LED, acesta începe să se aprindă rapid și să se stingă. Ochiul uman nu este capabil să vadă acest lucru deoarece frecvența este prea mare. Dar atunci când filmați, cel mai probabil veți vedea momente în care LED-ul nu este aprins. Acest lucru se va întâmpla cu condiția ca rata de cadre a camerei să nu fie un multiplu al frecvenței PWM.
Arduino are un modulator de lățime a impulsului încorporat. Puteți utiliza PWM numai pe acei pini care sunt acceptați de microcontroler. De exemplu, Arduino Uno și Nano au 6 pini PWM: aceștia sunt pinii D3, D5, D6, D9, D10 și D11. Știfturile pot diferi pe alte plăci. Puteți găsi o descriere a tablei care vă interesează
Pentru a utiliza PWM în Arduino există o funcție.Acesta ia ca argumente numărul pinului și valoarea PWM de la 0 la 255. 0 este 0% umple cu un semnal ridicat, iar 255 este 100%. Să scriem o schiță simplă ca exemplu. Să facem ca LED-ul să se aprindă lin, să așteptăm o secundă și să se stingă la fel de ușor și așa mai departe la infinit. Iată un exemplu de utilizare a acestei funcții:
// LED-ul este conectat la pinul 11 int ledPin = 11; void setup() ( pinMode(ledPin, OUTPUT); ) void loop() ( for (int i = 0; i< 255; i++) { analogWrite(ledPin, i); delay(5); } delay(1000); for (int i = 255; i >0; i--) ( analogWrite(ledPin, i); delay(5); ) )
// LED-ul conectat la pinul 11 int ledPin = 11 ; void setup() ( pinMode(ledPin, OUTPUT); void loop() ( pentru (int i = 0; i< 255 ; i ++ ) { analogWrite(ledPin, i); întârziere(5); întârziere (1000); pentru (int i = 255; i > 0; i -- ) ( |
Acest simulator funcționează cel mai bine pe browserul Chrome
Să aruncăm o privire mai atentă la Arduino.
Arduino nu este un computer mare care poate fi conectat la circuite externe. Arduino Uno folosește Atmega 328P
Acesta este cel mai mare cip de pe placă. Acest cip execută programe care sunt stocate în memoria sa. Puteți descărca programul prin usb folosind Arduino IDE. Portul USB oferă și alimentare arduino.
Există un conector de alimentare separat. Placa are doi pini etichetați 5v și 3.3v, care sunt necesari pentru alimentarea diferitelor dispozitive. Veți găsi, de asemenea, pini marcați GND, aceștia sunt pinii de masă (pământul este 0V). Platforma Arduino are, de asemenea, 14 pini digitali, etichetați de la 0 la 13, care se conectează la noduri externe și au două stări, ridicată sau scăzută (pornit sau oprit). Aceste contacte pot funcționa ca ieșiri sau ca intrări, de ex. pot fie să transmită unele date și să controleze dispozitivele externe, fie să primească date de la dispozitive. Următorii pini de pe placă sunt etichetați A0-A5. Acestea sunt intrări analogice care pot primi date de la diverși senzori. Acest lucru este convenabil mai ales atunci când trebuie să măsurați un anumit interval, cum ar fi temperatura. Intrările analogice au funcții suplimentare care pot fi activate separat.
Cum se utilizează o placă de dezvoltare.
Placa este necesară pentru a conecta temporar piesele, pentru a verifica cum funcționează dispozitivul, înainte de a lipi totul împreună.
Toate exemplele următoare sunt asamblate pe o placă, astfel încât să puteți face rapid modificări la circuit și să reutilizați piesele fără să vă deranjați cu lipirea.
Placa are șiruri de găuri în care puteți introduce piese și fire. Unele dintre aceste găuri sunt conectate electric între ele.
Cele două rânduri de sus și de jos sunt conectate în rânduri de-a lungul întregii plăci. Aceste rânduri sunt folosite pentru a furniza energie circuitului. Ar putea fi de 5V sau 3,3V, dar în orice caz, primul lucru pe care trebuie să-l faceți este să conectați 5V și GND la placa, așa cum se arată în imagine. Uneori, aceste conexiuni de rând pot fi rupte în mijlocul plăcii, apoi, dacă este necesar, le puteți conecta așa cum se arată în imagine.
Găurile rămase, situate în mijlocul plăcii, sunt grupate în grupuri de cinci găuri. Sunt folosite pentru a conecta părțile circuitului.
Primul lucru pe care îl vom conecta la microcontrolerul nostru este un LED. Schema de conectare electrică este prezentată în imagine.
De ce este nevoie de o rezistență într-un circuit? În acest caz, limitează curentul care trece prin LED. Fiecare LED este proiectat pentru un anumit curent, iar dacă acest curent este mai mare, LED-ul se va defecta. Puteți afla ce valoare ar trebui să aibă rezistorul folosind legea lui Ohm. Pentru cei care nu știu sau au uitat, legea lui Ohm spune că există o relație liniară între curent și tensiune. Adică, cu cât aplicăm mai multă tensiune rezistorului, cu atât mai mult curent va curge prin el.
V=I*R
Unde V- tensiunea pe rezistor
eu- curent prin rezistor
R- rezistenta ce trebuie gasita.
În primul rând, trebuie să aflăm tensiunea pe rezistor. Majoritatea LED-urilor de 3 mm sau 5 mm pe care le veți folosi au o tensiune de funcționare de 3V. Aceasta înseamnă că trebuie să stingem 5-3 = 2V la rezistor.
Vom calcula apoi curentul care trece prin rezistor.
Majoritatea LED-urilor de 3 mm și 5 mm luminează la luminozitate maximă la 20 mA. Un curent mai mare decât acesta le poate dezactiva, în timp ce un curent de intensitate mai mică le va reduce luminozitatea fără a provoca niciun rău.
Deci, dorim să conectăm LED-ul la circuitul de 5V, astfel încât să poată transporta un curent de 20mA. Deoarece toate piesele sunt incluse într-un singur circuit, rezistorul va avea și un curent de 20mA.
Primim
2V = 20 mA * R
2V = 0,02A * R
R = 100 Ohm
100 Ohmi este rezistența minimă, este mai bine să folosiți puțin mai mult, deoarece LED-urile au anumite variații în caracteristici.
În acest exemplu, este utilizat un rezistor de 220 ohmi. Doar pentru că autorul are o mulțime de ele: cu ochiul: .
Introduceți LED-ul în găurile din mijlocul plăcii, astfel încât cablul său lung să fie conectat la unul dintre cablurile rezistenței. Conectați al doilea capăt al rezistenței la 5V și conectați cel de-al doilea cablu al LED-ului la GND. LED-ul ar trebui să se aprindă.
Vă rugăm să rețineți că există o diferență în modul în care conectați LED-ul. Curentul trece de la terminalul mai lung spre cel mai scurt. În diagramă vă puteți imagina că curentul curge în direcția în care este îndreptat triunghiul. Încercați să întoarceți LED-ul cu susul în jos și veți vedea că nu se va aprinde.
Dar modul în care conectați rezistorul nu face nicio diferență. Puteți să-l întoarceți sau să încercați să-l conectați la un alt pin al LED-ului, acest lucru nu va afecta funcționarea circuitului. Acesta va limita în continuare curentul prin LED.
Anatomia schiței Arduino.
Programele pentru Arduino se numesc schiță. Ele constau din două funcții principale. Funcţie înființatși funcția buclă
În această funcție veți seta toate setările de bază. Ce pini vor funcționa ca intrare sau ieșire, ce biblioteci să se conecteze, inițializează variabilele. Funcţie Înființat() rulează o singură dată în timpul schiței, când începe execuția programului.
aceasta este funcția principală care se execută după înființat(). De fapt, este programul în sine. Această funcție va funcționa pe termen nelimitat până când opriți alimentarea.
LED intermitent Arduino
În acest exemplu, vom conecta un circuit LED la unul dintre pinii digitali ai Arduino și îl vom porni și opri folosind un program și, de asemenea, veți învăța câteva funcții utile.
Această funcție este utilizată în înființat() parte a programului și servește la inițializarea pinii pe care îi veți folosi ca intrare (INTRARE) sau ieșire (IEȘIRE). Nu veți putea să citiți sau să scrieți date din pin până când nu îl setați respectiv pinMode. Această funcție are două argumente: Numarul pin este numărul PIN pe care îl veți folosi.
Modul-setează cum va funcționa pinul. La intrare (INTRARE) sau ieșire (IEȘIRE). Pentru a aprinde LED-ul trebuie să dăm un semnal DIN Arduino. Pentru a face acest lucru, configurăm pinul de ieșire.
- această funcție este folosită pentru a seta starea (stat) pina (Numarul pin). Există două stări principale (de fapt 3 dintre ele), una este ÎNALT, vor fi 5V pe pin, asta e altceva Scăzut iar pinul va fi 0v. Aceasta înseamnă că pentru a aprinde LED-ul trebuie să setăm pinul conectat la LED la un nivel ridicat ÎNALT.
Întârziere. Servește pentru a întârzia funcționarea programului pentru o perioadă specificată în msec.
Mai jos este codul care face ca LED-ul să clipească.
//LED Blink int ledPin = 7;//Pinul Arduino la care este conectat LED-ul void setup() ( pinMode(ledPin, OUTPUT);// setarea pinului ca OUTPUT) void loop() ( digitalWrite(ledPin, HIGH) ;// porniți întârzierea LED-ului (1000);// întârziere 1000 ms (1 sec) digitalWrite (ledPin, LOW);//Opriți întârzierea LED-ului (1000);// așteptați 1 secundă)
Mici explicații despre cod.
Liniile care încep cu „//” sunt comentarii și sunt ignorate de Arduino.
Toate comenzile se termină cu punct și virgulă; dacă le uitați, veți primi un mesaj de eroare.
ledPin este o variabilă. Variabilele sunt folosite în programe pentru a stoca valori. În acest exemplu, variabila ledPin valoarea este atribuită la 7, acesta este numărul de pin Arduino. Când programul Arduino întâlnește o linie cu o variabilă ledPin, va folosi valoarea specificată mai devreme.
Deci inregistreaza pinMode(ledPin, OUTPUT) similar cu înregistrarea pinMode(7, IEȘIRE).
Dar în primul caz, trebuie doar să schimbați variabila și aceasta se va schimba în fiecare linie în care este folosită, iar în al doilea caz, pentru a schimba variabila, va trebui să faceți modificări manual în fiecare comandă.
Prima linie indică tipul variabilei. Când programați Arduino, este important să declarați întotdeauna tipul de variabile. Deocamdată este suficient să știi asta INT anunta numere negative si pozitive.
Mai jos este o simulare a schiței. Faceți clic pe Start pentru a vedea circuitul în acțiune.
După cum era de așteptat, LED-ul se stinge și se aprinde din nou după o secundă. Încercați să modificați întârzierea pentru a vedea cum funcționează.
Controlul mai multor LED-uri.
În acest exemplu, veți învăța cum să controlați mai multe LED-uri. Pentru a face acest lucru, instalați încă 3 LED-uri pe placă și conectați-le la rezistențe și pinii Arduino, așa cum se arată mai jos.
Pentru a porni și stinge LED-urile unul câte unul, trebuie să scrieți un program similar cu acesta:
//Multi LED Blink int led1Pin = 4; int led2Pin = 5; int led3Pin = 6; int led4Pin = 7; void setup() ( //setează pinii ca OUTPUT pinMode(led1Pin, OUTPUT); pinMode(led2Pin, OUTPUT); pinMode(led3Pin, OUTPUT); pinMode(led4Pin, OUTPUT); ) void loop() ( digitalWrite(led1Pin, HIGH) );//porniți întârzierea LED (1000);//întârziere 1 sec digitalWrite (led1Pin, LOW);//opriți întârzierea LED-ului (1000);//întârziere 1 sec //faceți același lucru pentru celelalte 3 LED-uri digitalWrite(led2Pin, HIGH);//aprinde LED-ul întârziere(1000);//întârziere 1 sec digitalWrite(led2Pin, LOW);//stinge LED-ul întârziere(1000);//întârziere 1 sec digitalWrite(led3Pin, HIGH); );//aprinde LED-ul întârziere (1000);// întârziere 1 sec digitalWrite (led3Pin, LOW);//stinge LED-ul întârziere (1000);//întârziere 1 sec digitalWrite (led4Pin, HIGH);//pornire întârzierea LED-ului (1000);// întârziere 1 sec digitalWrite (led4Pin, LOW);//stinge întârzierea LED-ului (1000);//întârziere 1 secundă)
Acest program va funcționa excelent, dar nu este soluția cea mai rațională. Codul trebuie schimbat. Pentru ca programul să funcționeze din nou și din nou, vom folosi o construcție numită .
Buclele sunt utile atunci când trebuie să repetați aceeași acțiune de mai multe ori. În codul de mai sus repetăm rândurile
DigitalWrite(led4Pin, HIGH); întârziere (1000); digitalWrite(led4Pin, LOW); întârziere (1000);
codul de schiță complet în atașament (descărcări: 1260)
Reglarea luminozității LED-urilor
Uneori va trebui să modificați luminozitatea LED-urilor din program. Acest lucru se poate face folosind comanda analogWrite()
. Această comandă pornește și stinge LED-ul atât de repede încât ochiul nu poate vedea pâlpâirea. Dacă LED-ul este aprins jumătate din timp și stins jumătate din timp, va apărea vizual că strălucește la jumătate din luminozitate. Aceasta se numește modularea lățimii impulsului (PWM sau PWM în engleză). Shim este folosit destul de des, deoarece poate fi folosit pentru a controla o componentă „analogică” folosind un cod digital. Nu toți pinii Arduino sunt potriviți pentru aceste scopuri. Doar acele concluzii în apropierea cărora se trage o astfel de desemnare " ~
". Îl vei vedea lângă pinii 3,5,6,9,10,11.
Conectați unul dintre LED-urile dvs. la unul dintre pinii PWM (pentru autor acesta este pinul 9). Acum rulați schița intermitentă a LED-ului, dar mai întâi modificați comanda digitalWrite() pe analogWrite(). analogWrite() are două argumente: primul este numărul de pin, iar al doilea este valoarea PWM (0-255), în raport cu LED-urile aceasta va fi luminozitatea acestora, iar pentru motoarele electrice viteza de rotație. Mai jos este un exemplu de cod pentru diferite luminozități LED.
//Schimbați luminozitatea LED-ului int ledPin = 9;//un LED este conectat la acest pin void setup() ( pinMode(ledPin, OUTPUT);// inițializarea pinului la ieșire ) void loop() ( analogWrite( ledPin, 255);// luminozitate maximă (255/255 = 1) întârziere (1000);//pauză 1 sec digitalWrite (ledPin, LOW);//stinge LED întârziere (1000);//pauză 1 sec analog Write ( ledPin, 191);//luminozitate cu 3/4 (191/255 ~= 0,75) întârziere (1000);//pauză 1 secundă digitalWrite (ledPin, LOW);//oprire întârziere LED (1000);// pauză 1 sec analogWrite(ledPin, 127); //jumătate de luminozitate (127/255 ~= 0,5) întârziere (1000);//pauză 1 secundă digitalWrite (ledPin, LOW);//oprire întârziere LED (1000);/ /pauză 1 sec analogWrite(ledPin, 63); //sferturi de luminozitate (63/255 ~= 0,25) întârziere (1000);//pauză 1 sec digitalWrite(ledPin, LOW);//stinge LED-ul întârziere (1000) ;//pauză 1 secundă)
Încercați să modificați valoarea PWM din comandă analogWrite() pentru a vedea cum afectează acest lucru luminozitatea.
În continuare, veți învăța cum să reglați ușor luminozitatea de la maxim la zero. Desigur, puteți copia o bucată de cod de 255 de ori
analogWrite(ledPin, luminozitate); delay(5);//short delay luminozitate = luminozitate + 1;
Dar, înțelegi, acest lucru nu va fi practic. Cel mai bun mod de a face acest lucru este să folosiți bucla FOR pe care am folosit-o mai devreme.
Următorul exemplu utilizează două bucle, una pentru a reduce luminozitatea de la 255 la 0
pentru (luminozitate int=0;luminozitate=0;luminozitate--)( analogWrite(ledPin,luminozitate); delay(5); )
întârziere (5) folosit pentru a încetini viteza de atenuare a luminozității 5*256=1280ms=1.28s)
Prima linie folosește „ luminozitate-" pentru a face ca valoarea luminozității să scadă cu 1 de fiecare dată când bucla este repetată. Rețineți că bucla va rula până când luminozitate >=0.Înlocuirea semnului >
pe semn >=
am inclus 0 în intervalul de luminozitate. Această schiță este modelată mai jos. //schimbați ușor luminozitatea int ledPin = 9;//un LED este conectat la acest pin void setup() ( pinMode(ledPin, OUTPUT);// inițializarea pinului de ieșire) void loop() ( //creșteți ușor luminozitate (de la 0 la 255) pentru (luminozitate int=0;luminozitate=0;luminozitate--)( analogWrite(ledPin,luminozitate); delay(5); ) delay(1000);//așteptați 1 secundă //reduceți ușor luminozitatea (255 la 0) pentru (luminozitate int=255; luminozitate>=0; luminozitate--)( analogWrite(ledPin,luminozitate); delay(5); ) delay(1000);//așteptați 1 secundă) )
Nu este foarte vizibil, dar ideea este clară.
LED RGB și Arduino
Un LED RGB este de fapt trei LED-uri de culori diferite într-un singur pachet.
Prin includerea diferitelor LED-uri cu diferite luminozități, le puteți combina pentru a crea culori diferite. Pentru Arduino, unde numărul de niveluri de luminozitate este 256, veți obține 256^3=16581375 culori posibile. În realitate, desigur, vor fi mai puțini.
LED-ul pe care îl vom folosi este catodul comun. Acestea. toate cele trei LED-uri sunt conectate structural prin catozi la un terminal. Vom conecta acest pin la pinul GND. Pinii rămași, prin rezistențe de limitare, trebuie conectați la pinii PWM. Autorul a folosit pinii 9-11. În acest fel va fi posibil să controlați fiecare LED separat. Prima schiță arată cum să porniți fiecare LED individual.
//LED RGB - test //pin conexiuni int red = 9; int verde = 10; int albastru = 11; void setup())( pinMode(rosu, OUTPUT); pinMode(albastru, OUTPUT); pinMode(verde, OUTPUT); ) void loop())( //porneste/opri LED-ul rosu digitalWrite(rosu, HIGH); delay(500); digitalWrite(rosu, LOW); delay(500); //pornire/oprire LED-ul verde digitalWrite(verde, HIGH); delay(500); digitalWrite(verde, LOW); delay(500); // pornește/oprește LED-ul albastru digitalWrite(albastru, HIGH); delay(500); digitalWrite(albastru, LOW); delay(500); )
Următorul exemplu utilizează comenzile analogWrite()și pentru a obține diferite valori aleatorii de luminozitate pentru LED-uri. Veți vedea diferite culori schimbându-se aleatoriu.
//LED RGB - culori aleatorii //conexiuni pin int red = 9; int verde = 10; int albastru = 11; void setup())( pinMode(red, OUTPUT); pinMode(albastru, OUTPUT); pinMode(verde, OUTPUT); ) void loop())( //alege o culoare aleatorie analogWrite(rosu, random(256)); analogWrite( albastru, aleatoriu (256)); analogWrite (verde, aleatoriu (256)); întârziere (1000);// așteptați o secundă)
Aleatoriu(256)- returnează un număr aleatoriu în intervalul de la 0 la 255.
În fișierul atașat este o schiță care va demonstra tranzițiile netede ale culorilor de la roșu la verde, apoi la albastru, roșu, verde etc. (descărcări: 348)
Exemplul de schiță funcționează, dar există o mulțime de coduri duplicate. Puteți simplifica codul scriind propria funcție de ajutor care se va schimba ușor de la o culoare la alta.
Iată cum va arăta: (descărcări: 385)
Să ne uităm la definiția funcției bucată cu bucată. Funcția este numită fader si are doua argumente. Fiecare argument este separat prin virgulă și are un tip declarat pe prima linie a definiției funcției: void fader (int color1, int color2). Vedeți că ambele argumente sunt declarate ca intși li se dau nume culoare1Și culoare2 ca variabile de condiție pentru a defini o funcție. Vidulînseamnă că funcția nu returnează nicio valoare, pur și simplu execută comenzi. Dacă ar trebui să scrieți o funcție care a returnat rezultatul înmulțirii, ar arăta astfel:
int multiplicator(int număr1, int număr2)( int produs = număr1*număr2; returnează produsul; )
Observați cum am declarat Type intîn schimb ca tip de returnare
vid.
În interiorul funcției există comenzi pe care le-ați folosit deja în schița anterioară, doar numerele de pin au fost înlocuite cu culoare1Și culoare2. Funcția este numită fader, argumentele sale sunt calculate ca culoare1 = roșuȘi culoare2 = verde. Arhiva conține o schiță completă folosind funcții (descărcări: 288)
Buton
Următoarea schiță va folosi un buton cu contacte normal deschise, fără blocare.
Aceasta înseamnă că, în timp ce butonul nu este apăsat, nu trece curent prin el, iar după ce a fost eliberat, butonul revine la poziția inițială.
Pe lângă buton, circuitul folosește un rezistor. În acest caz, nu limitează curentul, ci „trage” butonul la 0V (GND). Acestea. Până când butonul este apăsat, pinul Arduino la care este conectat se va reduce. Rezistorul folosit în circuit este de 10 kOhm.
//determină când butonul este apăsat int buttonPin = 7; void setup())( pinMode(buttonPin, INPUT);//inițializați pinul la intrarea Serial.begin(9600);//inițializați portul serial) void loop())( if (digitalRead(buttonPin)==HIGH )(//dacă este apăsat butonul Serial.println(„apăsat”); // se afișează „apăsat” ) else ( Serial.println(„neapăsat”); // în caz contrar, „neapăsat” ) )
Există mai multe comenzi noi în această schiță.
-Această comandă preia valorile High și Low ale ieșirii pe care o testăm. Această ieșire trebuie mai întâi configurată ca intrare în setup().
; //unde butonulPin este numărul PIN la care este conectat butonul.
Portul serial permite Arduino să trimită mesaje către computer în timp ce controlerul însuși execută programul. Acest lucru este util pentru depanarea unui program, trimiterea de mesaje către alte dispozitive sau aplicații. Pentru a activa transferul de date printr-un port serial (numit și UART sau USART), trebuie să-l inițializați în setup()
Serial.begin() are un singur argument - aceasta este viteza de transfer de date între Arduino și computer.
Schița folosește o comandă pentru a afișa un mesaj pe ecran în Arduino IDE (Tools >> Serial Monitor).
- designul vă permite să controlați progresul execuției programului prin combinarea mai multor verificări într-un singur loc.
Dacă digitalRead revine HIGH, atunci cuvântul „apăsat” este afișat pe monitor. În caz contrar, cuvântul „eliberat” este afișat pe monitor. Acum puteți încerca să porniți și să opriți LED-ul apăsând un buton.
//detecție apăsare buton cu ieșire LED int buttonPin = 7; int ledPin = 8; void setup())( pinMode(buttonPin, INPUT);//de data aceasta vom seta pinul butonului ca INPUT pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop())( if (digitalRead(buttonPin) )= =HIGH)( digitalWrite(ledPin,HIGH); Serial.println(„apăsat”); ) else ( digitalWrite(ledPin,LOW); Serial.println(„ne apăsat”); ) )
Intrare analogică.
analogRead vă permite să citiți date de la unul dintre pinii analogici Arduino și afișează o valoare în intervalul de la 0 (0V) la 1023 (5V). Dacă tensiunea la intrarea analogică este de 2,5 V, atunci se va imprima 2,5 / 5 * 1023 = 512
analogRead are un singur argument - Acesta este numărul de intrare analogică (A0-A5). Următoarea schiță arată codul pentru citirea tensiunii de la potențiometru. Pentru a face acest lucru, conectați un rezistor variabil, bornele exterioare la pinii de 5V și GND și terminalul din mijloc la intrarea A0.
Rulați următorul cod și vedeți în monitorul serial cum se schimbă valorile în funcție de rotația butonului rezistenței.
//intrare analogică int potPin = A0;//pinul central al potențiometrului este conectat la acest pin void setup())( //pinul analogic este inclus ca intrare implicit, deci nu este necesară inițializarea Serial.begin(9600) ); ) void loop())( int potVal = analogRead(potPin);//potVal este un număr între 0 și 1023 Serial.println(potVal); )
Următoarea schiță combină schița de clic pe buton și schița de control al luminozității LED. LED-ul se va aprinde de la buton, iar luminozitatea va fi controlată de un potențiometru.
//detecție apăsare buton cu ieșire LED și intensitate variabilă int buttonPin = 7; int ledPin = 9; int potPin = A0; void setup())( pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop())( if (digitalRead(buttonPin)==HIGH)(//dacă butonul este apăsat int analogVal = analogRead(potPin); int scaledVal = map(analogVal, 0, 1023, 0, 255); analogWrite(ledPin, scaledVal);//porniți led-ul cu intensitatea setată de pot Serial.println("pressed"); ) altfel ( digitalWrite(ledPin, LOW);//oprire dacă butonul nu este apăsat Serial.println("ne apăsat"); ) )
Livrare produse noi de casă la oficiul poștal
Primiți prin e-mail o selecție de produse noi de casă. Fără spam, doar idei utile!