Lecții de antrenament Arduino. Aplicație. Directorul mobil. Tema pentru acasă - termometru digital

În acest articol am decis să colectez un complet ghid pas cu pas Pentru Arduino incepatori. 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 ei. 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 ei, chiar poți face dispozitive utile.
Pornind de la simple lumini intermitente, stații meteo, sisteme de automatizare și terminând cu casă inteligentă, mașini CNC și vehicule aeriene fără pilot. Posibilitățile nu sunt limitate nici măcar de imaginația ta, pentru că există o cantitate mare instructiuni si 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 să cumperi trusa de pornire Arduino, dar poți alege singur tot ce ai 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 piese individuale pe care cu siguranță va trebui să le studiați:

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. Este foarte simplu și program convenabil. Pe site-ul meu am descris deja procesul de descărcare, instalare și configurare a mediului de dezvoltare. Deci aici voi lăsa doar link-uri către ultima versiune programe și

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 constructe de limbaj pe pagina de la 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.

Tot 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 ) return current ) void loop() ( currentButton = debounse(lastButton); if(lastButton == LOW && currentButton == HIGH) ( ledOn = !ledOn; ) lastButton = currentButton ; (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 unui 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 când înregistrați videoclipuri, 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 pin ș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); ) )

" prezintă cursul de formare „Arduino pentru începători”. Seria este reprezentată de 10 lecții, precum și material suplimentar. Lecțiile includ instrucțiuni text, fotografii și videoclipuri de antrenament. În fiecare lecție veți găsi o listă de componente necesare, o listă de programe și o diagramă de conectare. După ce ai studiat aceste 10 lecții de bază, poți începe să faci mai multe modele interesanteși asamblarea roboților bazați pe Arduino. Cursul este destinat începătorilor; nu aveți nevoie de cunoștințe pentru a începe. Informații suplimentare din inginerie electrică sau robotică.

Scurte informații despre Arduino

Ce este Arduino?

Arduino (Arduino) este o platformă hardware de calcul, 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 relativ preț scăzutși distribuție aproape în masă printre amatorii și profesioniștii roboticii și ingineriei electrice. Odată ce ați început să utilizați 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 produce radiații optice atunci când este trecut prin el curent electricî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, în timp ce 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 regulatoare diverși 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ă. Ele vin în mici placă de circuit imprimat, pe care sunt amplasate rezistențe și 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 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 cum să organizați trimitere automată 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ă matrice la Placa Arduino, și, de asemenea, familiarizați-vă cu diverse scheme interesante.

Tastatura Matrix conceput pentru a simplifica conexiunea un numar mare 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 de ceas în timp real- Acest circuit electronic, conceput pentru înregistrarea datelor cronometrice ( ora curentă, data, ziua săptămânii etc.), este un sistem de sursă autonomă sursa de alimentare si dispozitiv de contorizare.

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 potrivit pentru cei care circuite electrice nu deosebit de atractiv.

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 permite de la aceeași componente fă-ți jucării noi.

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

Acest simulator funcționează cel mai bine pe browserul Chrome
Să aruncăm o privire mai atentă la Arduino.

Arduino nu este calculator mare, la care se pot conecta 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 de pe folosind Arduino IDE. port USB oferă, de asemenea, energie pentru arduino.

Există un conector de alimentare separat. Placa are doi pini etichetați 5v și 3.3v, care sunt necesari pentru alimentare diverse 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 accepta 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 poate fi folosit separat.

Cum se utilizează panou.

Placa este necesară pentru a conecta temporar piesele, pentru a verifica cum funcționează dispozitivul, înainte de a lipi totul împreună.
Toate exemplele de mai jos 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.

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ă dependență liniară curent de la 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 care 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 tensiune de operare 3c. 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, vrem 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, rezistența 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 folosit 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 curge 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ță. Îl puteți întoarce sau î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 sketch. 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 circuitul LED la unul dintre cele digitale Pini Arduinoși îl vom porni și opri folosind programul și veți învăța, de asemenea, 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 (IESIREA). 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 (IESIREA). 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 nivel inalt Î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. La Programare 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-ului(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: 1187)

Reglarea luminozității LED-ului

Uneori va trebui să modificați luminozitatea LED-urilor din program. Acest lucru se poate face folosind comanda analogWrite() . Această comandă aprinde ș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. Se numeste modularea lățimii impulsului(PWM sau PWM în engleză). Calea este folosită destul de des, deoarece poate fi folosită pentru a controla o componentă „analogică”. 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 schimbaț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 completă (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); //întârziere de jumătate de luminozitate (127/255 ~= 0,5) (1000);//pauză 1 secundă digitalWrite (ledPin, LOW);//întârziere LED-ul de oprire (1000);/ /pauză 1 sec analogWrite(ledPin, 63); //sferturi de luminozitate (63/255 ~= 0,25) delay(1000);//pauză 1 sec digitalWrite(ledPin, LOW);//stinge LED-ul delay(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);//scurt delay luminozitate = luminozitate + 1;
Dar, înțelegi, acest lucru nu va fi practic. Cel mai bun mod de a face acest lucru este utilizarea bucla FOR care a fost folosit anterior.
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.

Inclusiv LED-uri diferite Cu o luminozitate diferită, puteți combina și obține 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.

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, random(256)); analogWrite(verde, random(256));

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: 326)
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: 365)
Să ne uităm la definirea funcției bucată cu bucată. Funcția este numită faderși are două 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: 272)

Buton

Următoarea schiță va folosi un buton cu contacte normal deschise, fără blocare.

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 va fi imprimat 2,5 / 5 * 1023 = 512
analogRead are un singur argument - Acesta este numărul intrării analogice (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"); ( digitalWrite(ledPin, LOW);//oprire dacă butonul nu este apăsat Serial.println("ne apăsat"); ) )