În această lecție, vom efectua câteva experimente de bază pe placa de testare pentru a vă prezenta conceptele de bază Arduino și fluxul de lucru.

În primul rând, vă pregătiți pentru succes prin atașarea plăcii dvs. Arduino Uno și a plăcii de testare, fără lipituri, pe o platou de montaj. Aceasta oferă un avantaj imens de a ține împreună prototipurile și de a le ține departe de probleme! Placa de testare fără lipituri are un autocolant pe spate pe care îl puteți îndepărta (îndepărtați și suportul de hârtie al plăcii de montare), iar Arduino Uno se atașează cu șuruburi de dedesubt. Nu contează în ce direcție se află Arduino tău în raport cu placa de testare. O mică șurubelniță este utilă aici, astfel încât să puteți ține o piuliță de nailon în poziție pe pe partea superioară a plăcii și să înșurubați șurubul din partea inferioară. Doar două combinații șurub/piuliță dispuse în diagonală sunt necesare pentru o fixare sigură.

Pentru a urmări împreună această lecție veți avea nevoie de:

• Calculator care rulează software-ul Arduino

• Unele dintre articolele de la Adafruit Arduino Uno Budget Pack:

Placa Arduino Uno

Cablu USB A-B

Placa testare de dimensiuni reduse

Fire pentru placa de testare

5 LED-uri 5mm roșii

LED-uri luminoase roșu, verde și albastru (câte unul sau un LED RGB)

5 rezistoare 220-1K ohm (aceeași valoare, orice valoare în interval OK)

• Platou de montaj din plastic pentru placa de testare și Arduino

• Șurubelniță mică cu cap plat

Plăci de testare fără lipituri

Plăcile de testare fără sudură sunt destinate circuitelor experimentale rapide și ușoare. Puteți să vă gândiți la acest lucru ca la o placă magnetică, excelentă pentru o soluție și experimentare rapidă. Plăcile de testare vă permit să conectați componente utilizând socluri metalice multiport. Componentele conductive ale plăcii de testare permit electronilor să curgă între lucrurile pe care le conectați.

În partea dreaptă puteți vedea interiorul unei plăci de testare pentru a observa cum sunt conectate aceste socluri. Două șine lungi sunt așezate pe fiecare parte, marcate cu linii roșii și albastre pe față. Acești conectori lungi sunt utilizați în mod obișnuit pentru conexiuni de alimentare și de masă, care sunt utilizate destul de des. Micile rânduri orizontale care cuprind mijlocul plăcii sunt destinate conectării firelor și componentelor. Observați divizorul din mijlocul plăcii - aceasta există pentru a oferi cip-urilor un loc unde să fie plasate, oferind acces independent la fiecare pin.

Circuit Blink (licărire)

Primul circuit pe care îl vom construi pe placa de testare conectează un LED roșu la placa Arduino Uno. Să începem încet, cu o singură conexiune de sârmă la un moment dat. Continuați împreună cu fire de aceeași culoare pentru a ne ușura amândouă. Verificați de două ori că cablul USB este deconectat înainte de a efectua cablarea la placă. Luați un fir roșu și conectați un capăt la pinul marcat cu 5V de pe placa Arduino. Introduceți celălalt capăt al firului roșu în șina plăcii marcată cu o linie roșie - acesta va fi magistrala dvs. de alimentare.

În mod similar, apucați un fir albastru și conectați-l într-una din acele benzi marcate GND, chiar lângă firul roșu. Există trei pini de masă pe un Arduino Uno, și toți sunt conectați la aceeași masă ca și cipul și restul plăcii, deci nu contează ce alegeți. Conectați celălalt capăt al firului dvs. albastru la magistrala albastră de masă de pe placa de testare. Aceasta este o configurație obișnuită pe care o veți folosi din nou și din nou și ar trebui să vă configurați setările pentru plăcile de testare noi, chiar dacă nu utilizați imediat ambele magistrale. Circuitele din această lecție se vor conecta la magistrala de masă, iar în următoarea lecție veți utiliza câteva componente care se vor conecta la magistrala de alimentare cu 5V.

Apoi, conectați un fir galben la pinul Arduino 13. Introduceți celălalt capăt în orice linie orizontală de pe placa de testare (rândul 10 prezentat mai sus). Pentru acest prim circuit, toate conexiunile dvs. ar trebui să fie puse pe jumătatea plăcii cea mai apropiată de placa Arduino.

Conectați un alt fir albastru de la orice pin de pe șina de masă într-un alt rând orizontal de pe placă (rândul 18 arătat mai sus).

Acum, apucați un rezistor de 1K (dungile sunt maro-negru-roșu-auriu), și conectați unul din conductorii săi (nu contează care) în același rând cu firul albastru. Rezistoarele arată toate asemănătoare, cu excepția benzilor folosite pentru a indica valoarea lor.

Introduceți celălalt capăt într-un rând la stânga de lângă firul galben.

Acum, luați un LED roșu (diodă emițătoare de lumină). Vedeți cum unul dintre conductorii săi este mai lung decât celălalt? Acesta este polul pozitiv (anodul), iar conductorul mai scurt este negativ (catod). În circuitul pe care îl construim, sarcina pozitivă vine de la pinul Arduino și trece prin LED și rezistor la masă, deci trebuie să conectați conductorul pozitiv (mai lung) la firul galben și conductorul negativ (mai scurt) la rezistor. Un rezistor ajută la limitarea curentului ce trece printr-un LED, deoarece acesta nu poate limita el însuși curentul.

Un alt mod de a ghici polaritatea unui LED este căutând în interiorul obiectivului la nicovală (bucata mai mare de metal) și stâlp (bucata mai mică de metal). Nicovala este, de obicei, catodul, dar după cum puteți vedea în imaginea de mai sus, nu toate LED-urile respectă aceleași convenții de polaritate. Singura modalitate de a fi siguri de polaritatea sa este să o testați. Pentru a afla mai multe detalii despre rezistoare și LED-uri, verificați lecția LED-uri din LED-urile Instructables & Lighting Class.

Conectați cablul USB și LED-ul trebuie să clipească imediat! Este programat să clipească tot ce este conectat la pinul 13. Aceasta include LED-ul de pe placă, pe care l-ați văzut în configurarea software-ului dvs., precum și cel pe care tocmai l-ați conectat.

Dacă LED-ul dvs. nu clipește, deconectați cablul USB, apoi inversați LED-ul și recuplați USB-ul; poate că LED-ul a fost doar conectat invers (care nu-l va deteriora, dar nici nu-l va aprinde). Sau poate unul dintre celelalte fire sau rezistor nu este conectat corect. Verificați de două ori conexiunile pe schema circuitului:

Găsiți acest circuit pe Tinkercad

Faceți clic pe "Start Simulation" pentru a rula emulatorul Arduino, care are încărcat programul de probă "blink". Vom folosi modulele Tinkercad Circuits ca aceasta în întreaga clasă pentru a vă ajuta să construiți împreună. Acestea conțin diagrame de conexiuni pentru experimentele pe placa de testare, precum și codul de care veți avea nevoie pentru fiecare. Faceți clic pe butonul "Code" pentru a vedea programul, numit Arduino sketch. Arată ca acesta:

Blink by Bekathwia

// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {
// initialize the digital pin as an output.
pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}

Veți folosi IDE-ul Arduino pentru a manipula programele ca acesta și pentru a le trimite la placa dvs. Arduino pentru a rula. Ați încărcat deja această schiță pe placa dvs. Arduino în configurația software-ului din lecția anterioară, dar un refresh nu poate face rău: puteți găsi această schiță și multe alte exemple utilizate în această clasă prin meniul software Arduino (File -> Examples -> Basics -> Blink).

Exemplu de schițe fac marile puncte de pornire pentru experimentare și proiectele proprii pe linie. Aceste exemple sunt neprețuite pentru experiența dvs. de învățare Arduino; utilizați-le! Este obișnuit să faci o mulțime de greșeli atunci când scrieți primul cod, ceea ce poate provoca erori de confuzie. Exemplele sunt la îndemână atunci când doriți să remediați propriul cod care nu funcționează (numit debugging). Comparând munca dvs. cu exemplele definitive de cod de lucru poate fi o strategie utilă pentru a vă ajuta să depanați codul.

Să aruncăm o privire mai atentă la elementele acestei schițe de bază Arduino. Prima este o mică observație:

// Pin 13 has an LED connected on most Arduino boards.

// give it a name:

Acesta este doar un comentariu, menit să ajute oamenii să înțeleagă programul. În programele Arduino, comentariile sunt semnalate cu două II (slash); orice lucru pe o singură linie după slash-uri este elimnat atunci când vine timpul să se compileze (construiți acest cod în versiunea care poate fi citită de mașină care se va executa pe placa Arduino). Prin urmare, comentariile nu contribuie la dimensiunea programului dvs., deci comentați mai departe! Puteți uita cu ușurință ce trebuie să realizeze fiecare secțiune a programului dvs. Vă recomandăm cu tărie să vă obișnuiți să comentați la greu codul dvs. și să citiți comentariile din fiecare dintre exemplele pe care le folosim în această clasă.

int led = 13;

Următoarea este o declarație variabilă. Vă puteți gândi la o variabilă ca o găleată pentru unele informații. Variabilele, ca găleți, au dimensiuni și forme pentru a ține diferite tipuri de informații. Variabilele au, de asemenea, nume, ca o etichetă obligatorie pe găleată. Această linie de cod definește o variabilă de tip int, care înseamnă întreg. Amintiți-vă din nou la clasa de matematică din școala primară, atunci când ați aflat că numerele întregi sunt numere întregi (pozitive sau negative). Așa că avem o găleată care poate conține un număr întreg. Eticheta este led dar ar putea fi la fel de ușor "MyLEDPin" sau orice cuvânt unic (numai litere și numere, sensibile la mărime), deoarece această parte a declarației variabilei depinde de dvs. Vă sfătuiesc să folosiți nume descriptive pentru variabilele dvs., astfel încât să puteți urmări ceea ce face programul dvs.!

După linia de cod de mai sus, oricând vom vedea "led" în program va fi schimbat pentru numărul 13. Acest lucru este util pentru configurații ca ale noastre, în cazul în care vrem o modalitate de a menționa la care PIN este conectat LED-ul, tot timpul, dar dacă cablarea se modifică va trebui să o actualizăm doar într-un singur loc în cod.

// the setup routine runs once when you press reset:

void setup() {

După cum sugerează și comentariul, orice între această linie și acolada de închidere } face parte din configurare, o secțiune de cod care rulează o dată pe sesiune. Codul din cadrul configurației se execută o dată când prima placă se alimentează sau când apăsați butonul de resetare al lui Arduino.

// initialize the digital pin as an output.
pinMode(led, OUTPUT);

}

Pinii 0-13 de pe placa dvs. Arduino sunt pinii digital I/O, ceea ce înseamnă că pot fi fie intrări, fie ieșiri. pinMode();este o funcție, o prescurtare de a face referire la subsetul de comenzi "sub capotă", ca să spun așa. Arduino vă arată că recunoaște anumite elemente de cod prin schimbarea culorii textului. Dacă vreodată un cuvânt cheie nu schimbă culoarea în timp ce îl tastați în Arduino, probabil că aveți o greșeală de scriere, o eroare de scriere cu majuscule sau altă greșeală de scriere. Aceste fragmente de informații transmise funcțiilor sunt numite argumente. Deoarece variabila led va servi conținutul său oricând îl introduceți, numărul PIN-ului trecut la pinMode();este 13, iar starea este OUTPUT. Aceasta stabilește pinul 13 pentru a controla un LED, iar acolada închide configurația.

// the loop routine runs over and over again forever:

void loop() {

Aceasta este partea principală a unei schițe Arduino, în care se întâmplă de obicei acțiuni precum verificarea pinilor de intrare și controlul pinilor de ieșire. Tot ceea ce se întâmplă între această linie și acolada de închidere } se va repeta până când placa va pierde alimentarea.

digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)

Prima în buclă este o funcție numită digitalWrite();, care ia două informații: un număr de pin și o stare HIGH (on) sau LOW (off). Aceste fragmente de informații transmise funcțiilor sunt numite argumente. Întrucât variabila led va servi conținutul său oricând îl introduceți, numărul PIN-ului trecut la digitalWrite(); este 13, iar starea este HIGH (on). Această linie de cod determină ca LED-ul din circuitul dvs. să se aprindă.

delay(1000); // wait for a second

delay();este una din funcțiile încorporate ale lui Arduino. Ea întrerupe programul pentru o perioadă de timp, scrisă în milisecunde. Această linie de cod întrerupe programul pentru 1000 ms sau o secundă.

digitalWrite(led, LOW); // turn the LED off by making the voltage LOW

Ca și mai devreme, digitalWrite(); poate activa sau dezactiva un pin de ieșire. De această dată fixează pinul 13 LOW (off).

delay(1000); // wait for a second

}

Această linie întrerupe programul timp de o secundă, iar acolada indică sfârșitul buclei, care începe imediat din nou. Așa că pentru a rezuma, programul pornește și oprește un LED la intervale de o secundă. Să încercăm să schimbăm intervalul respectiv. Modificați numărul de milisecunde din una sau din ambele declarații delay();. De exemplu, puteți crea o clipire mai neuniformă:

void loop() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(2000); // wait for two seconds
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(500); // wait for a half second

}

Încercați să încărcați schița modificată a blink-ului la placa dvs. Arduino. S-a comportat așa cum v-ați așteptat?

Foarte bine! A fost o mulțime de informații. E în regulă dacă nu înțelegi complet toate lucrurile. Ca și învățarea oricărui limbaj, limbajul de programare Arduino are propria sa sintaxă și structură pe care trebuie să navigați, ceea ce va fi mai familiar cu exersare regulată. Cel mai important lucru de reținut este că poți lucra cu codul fără să știi totul despre programare. Pe măsură ce treceți prin exercițiile din această clasă, vă încurajez să lăsați o fereastră deschisă încărcată cu pagina de referință a limbajului Arduino, care descrie fiecare element și oferă o utilizare de probă.

Adăugați mai multe LED-uri

Acum că aveți ideea de bază despre cum să controlați un singur LED, să adăugăm ceva mai mult! Luați restul LED-urilor roșii și rezistoarelor de 1K. Deconectați Arduino de la USB/alimentare dacă nu era deja. Este inteligent să deconectați alimentarea oricând schimbați circuitul.

Conectați cele două perechi de șine de pe placa de testare: conectați un fir care leagă ambele magistrale de alimentare (roșu, +) și un alt fir care leagă ambele magistrale de masă (albastru, -). Aceasta este o configurație frecvent utilizată, deoarece acum puteți accesa cu ușurință alimentarea și masa de pe ambele margini ale plăcii. Îndoiți terminalele rezistoarelor la 90 de grade și tăiați capetele la aproximativ 6 mm de la îndoire.

Înlocuiți rezistorul de pe placă cu unul mai apropiat și vedeți ce diferență uriașă face în lizibilitatea circuitului. Și este mai puțin probabil să creați un scurtcircuit accidental în acest fel.

Să adăugăm noile LED-uri pe jumătatea de placă neutilizată. Începeți conectând un rezistor apropiat de masă (prize de-a lungul liniei albastre) pe un rând al plăcii. Conectați un LED roșu pe placă, conectând terminalul mai scurt (negativ) pe același rând cu rezistorul.

Adăugați rezistoarele și LED-urile rămase în același model. Amintiți-vă că rezistoarele se pot conecta indiferent cum, dar LED-urile au polaritate și se aprind numai când fluxul de energie electrică curge într-o anumită direcție prin ele.

Mutați firul galben din pinul 13 Arduino pe pinul 7. Conectați un alt fir galben de la pinul 6 Arduino la terminalul pozitiv al următorului LED învecinat.

Conectați mai multe fire galbene conform diagramei circuitului din modulul Tinkercad Circuits (pinii Arduino 3-5 la terminalele pozitive ale LED-urilor rămase). Găsiți acest circuit pe Tinkercad

Faceți clic pe butonul "Start simulation" pentru a vedea unde mergem cu partea de cod a lucrurilor. Programul luminează câte un LED la un moment dat, în ordine, pe linie și înapoi. Faceți clic pe butonul "Code" pentru a vedea codul, apoi faceți clic pe butonul de descărcare (pictograma săgeată îndreptată în jos). Acest exemplu variază ușor de la un exemplu similar care vine cu software-ul Arduino, deci vom folosi în schimb această versiune descărcabilă. Faceți dublu clic pe fișierul "ForLoopIteration.ino" pentru a-l deschide.

Faceți clic pe OK dacă vedeți un prompter, pentru a pune programul în propriul dosar. Dacă fișierul rezultat are întregul cod îmbinat pe o singură linie, probabil că utilizați o versiune veche a lui Arduino și ar trebui să actualizați ultima versiune. Dacă preferați, puteți, de asemenea, să selectați și să copiați codul din modulul de mai sus și să îl inserați într-o schiță nouă (necompletată) Arduino (File -> New, apoi înlocuiți conținutul implicit cu codul pe care l-ați copiat de mai sus).

Conectați-vă și încărcați codul pe placa dvs. Arduino Uno. Poate fi necesar să selectați din nou portul din meniul Tools după reconectare. Să învățăm cum să codificăm o secvență de lumină examinând mai atent elementele programului:

/*
For Loop Iteration

Demonstrates the use of a for() loop.
Lights multiple LEDs in sequence, then in reverse.

The circuit:
* LEDs from pins 3 through 7 to ground

created 2006
by David A. Mellis
modified 30 Aug 2011
by Tom Igoe

This example code is in the public domain.

<a href="http://www.arduino.cc/en/Tutorial/ForLoop"> http://www.arduino.cc/en/Tutorial/ForLoop
</a>

*/

Această primă parte este doar un comentariu lung. Ați învățat deja despre comentariile cu o singură linie, iar acum știți despre comentariile cu mai multe linii, semnificate cu /* pentru start și */ pentru stop.

int timer = 200; // The higher the number, the slower the timing.

O variabilă este declarată! Este un număr întreg numit "timer", iar această linie o stabilește la 200. După cum probabil ați observat, cele mai multe linii de programe Arduino se termină cu un punct și virgulă. Atunci când scrieți și modificați propriile schițe Arduino, aveți grijă la dispariția punct și virgulă, deoarece acestea vor determina erori de compilare care vă vor dezamăgi.

void setup() {
// use a for loop to initialize each pin as an output:
for (int thisPin = 3; thisPin < 8; thisPin++) {
pinMode(thisPin, OUTPUT);
}
}

Setarea configurează pinii 3 până la 7 ca ieșiri folosind o buclă For, care este o buclă specială care repetă o mică secțiune de cod de câteva ori pe baza unei condiții, folosind un contor de incrementare. De fiecare dată prin mini-buclă, condiția este testată și, dacă este adevărată, va continua să execute codul înăuntru. Deci, de mai sus, o variabilă thisPin este setată la 3, condiția este că thisPin ar trebui să fie mai mic de 8, iar contorul de incrementare crește thisPins cu unu de fiecare dată prin buclă ( thisPin++ este același cu thisPin = thisPin + 1). Deci, prima dată prin această buclă, pinul 3 este setat la o ieșire. A doua oară, pinul 4 este setat la o ieșire. Și așa mai departe până când thisPin este 8, moment în care condiția este falsă și codul întrerupe bucla, continuând cu restul programului. Acest lucru poate părea o modalitate complicată de a face un lucru simplu, dar programatorii iubesc eficiența! Puteți realiza la fel de ușor configurațiile pinilor cu următoarea setare:

void setup() {
// initialize each pin as an output:
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
}

Veți observa că de obicei vor exista mai multe modalități de a realiza aceleași sarcini cu programarea Arduino. Codificarea este similară cu a face lucrurile în atelierul dvs.: aveți tendința de a utiliza orice instrumente aveți. Deci, haideți să utilizați o buclă For pentru ceva distractiv ... animație!

void loop () { // bucla de la cel mai mic pin la cel mai înalt: pentru (int thisPin = 3; thisPin <8; thisPin ++) { // activați pinul: digitalWrite (acestPin, HIGH); întârziere (temporizator); // dezactivați pinul: digitalWrite (acestPin, LOW); }

void loop() {

// loop from the lowest pin to the highest:
for (int thisPin = 3; thisPin < 8; thisPin++) {
// turn the pin on:
digitalWrite(thisPin, HIGH);
delay(timer);
// turn the pin off:
digitalWrite(thisPin, LOW);

}

Bucla pornește cu aceeași buclă For ca mai devreme, crescând de la cel mai mic număr de pin la cel mai înalt. În interiorul buclei For, se aprinde LED-ul la thisPin, se oprește pentru 200 ms (setat mai devreme ca temporizator), apoi oprește acel LED înainte de a intra în buclă cu LED-ul următor.

// loop from the highest pin to the lowest:
for (int thisPin = 7; thisPin >= 3; thisPin--) {
// turn the pin on:
digitalWrite(thisPin, HIGH);
delay(timer);
// turn the pin off:
digitalWrite(thisPin, LOW);
}
}

Următoarea parte a codului este altă buclă For, dar aceasta începe de la pinul cel mai înalt și folosește thisPin--, ceea ce înseamnă același lucru ca thisPin = thisPin - 1, și iese din bucla atunci când thisPin nu mai este >= 3 (mai mare sau egal cu trei, aka 2). Acolada finală închide bucla principală. Deci, acest program aprinde fiecare LED în ordine, apoi inversează ordinea și le aprinde din nou.

Attachments ForLoopIteration.ino

Estomparea

Aprinderea și dezactivarea LED-urilor este totală, dar acum să facem să se aprindă și să se stingă treptat cu ajutorul unei funcții numite analogWrite();. Deconectați cablul USB și scoateți toate, mai puțin primul LED de pe placă și mutați conexiunea firului galben la pinul 9 Arduino. Găsiți acest circuit pe Tinkercad

Copiați/descărcați codul din modulul Tinkercad Circuits sau deschideți exemplul din exemplele software-ului Arduino din File -> Examples -> 01.Basics -> Fade.

Conectați-vă și încărcați schița la placa dvs. Arduino Uno și observați estomparea LED-ului.

Să ne uităm la cod pentru a afla cum se realizează această estompare. Am activat numerele de linie în preferințele lui Arduino pentru a putea face mai bine referire la diferitele părți ale codului.

Fade (click pentru cod)

Liniile 16 până la 18 declară trei variabile utilizate în program. Setarea configurează pinul 9 ca ieșire pe linia 23. Pe linia 29, funcția analogWrite(); stabilește pinul 9 la oricare luminozitate variabilă la momentul dat. Pe linia 32, luminozitatea este incrementată cu 5 (fadeAmount). Linia 35 folosește o declarație if pentru a verifica dacă luminozitatea utilizează operatori de comparație. Dacă luminozitatea este mai mică sau egală cu <= zero sau ||mai mare sau egală cu >= 255. Dacă declarația este adevărată, codul interior este executat, altfel este doar omis. Deci, acest cod crește luminozitatea până când atinge sau depășește 255, apoi stabilește fadeAmount la -5 și scade luminozitatea până când ajunge la zero (sau scade sub zero). Întârzierea la sfârșit nu permite codului să ruleze atât de repede încât să nu puteți vedea efectul. Încercați să modificați valoarea fadeAmount și încărcați codul pe placa dvs. Cum se schimbă această variabilă, afectează aspectul estompării?

Placa Arduino este capabilă să genereze numai semnale digitale (HIGH și LOW), dar analogWrite (); simulează apariția luminozității între pornire și oprire utilizând modulația lățimii de impuls (PWM). LED-ul se aprinde și se stinge foarte repede, iar ochiul interpretează o lumină mai slabă. Raportul dintre timpii ON și OFF ai LED-ului determină cât de strălucitor sau de luminos apare LED-ul. Doar anumiți pini sunt capabili de PWM și sunt etichetați pe bord cu S-uri ~ lângă numărul de pin. PWM poate fi, de asemenea, utilizat pentru a controla viteza unui motor DC, pe care o vom face într-o lecție ulterioară.

LED-uri RGB

Culoarea aditivă (pe bază de lumină) are trei culori primare: roșu, verde și albastru. Controlul simultan a luminozității unui LED al fiecăruia dintre aceste culori poate crea aproape orice culoare a luminii. LED-urile cu schimbare a culorilor, cum ar fi cele utilizate în proiectul final, funcționează în același mod, dar LED-urile sunt toate împreună într-un pachet foarte mic numit LED RGB. Să construim propriul LED RGB din trei LED-uri de 5 mm din kitul tău. În kitul Adafruit recomandat pentru această clasă, aceste trei LED-uri au lentile transparente, așa că va trebui să le conectăm pentru a determina ce culoare are LED-ul. LED-urile cu lentile transparente pot fi orice culoare! Dacă utilizați un set diferit, găsiți doar un LED roșu, un verde și un LED albastru (lentilă transparentă sau colorată). Deconectați cablul USB și schimbați LED-ul roșu pentru unul dintre LED-urile cu lentilă transparentă, apoi conectați din nou la USB.

Ce culoare are LED-ul? Dacă găsiți unul roșu la prima încercare, lăsați-l la o parte și repetați procesul pentru a determina culoarea celorlalte două LED-uri. Găsiți acest circuit pe Tinkercad

Conectați celelalte două LED-uri cu rezistoare de 1K la pinii 10 și 11, așa cum se arată în diagramă. Descărcați și deschideți codul din modulul Tinkercad Circuits sau copiați-l și inserați-l într-o nouă schiță Arduino goală. Încărcați-l pe placa dvs. Arduino Uno și vedeți dacă puteți potrivi liniile de cod cu activitatea pe care o vedeți în LED-uri, așa cum am făcut-o împreună până acum.

Partea necunoscută a acestui cod este funcția setColor();. Este o funcție personalizată, definită sub bucla () care s-a încheiat.

void setColor(int red, int green, int blue)
{
analogWrite(redPin, red);
analogWrite(greenPin, green);
analogWrite(bluePin, blue);

}

O function definition declară un nume și ce tip de argumente va avea funcția pe care o puteți considera ca fiind setările configurabile pe care doriți să le modificați de fiecare dată când executați codul pe care îl conține. În această funcție simplă, trei valori întregi sunt scrise la cei trei pini LED folosind analogWrite();.

setColor(255, 255, 0); // yellow

De fiecare dată când această funcție este apelată în bucla principală, programul execută codul în funcție înainte de a continua prin bucla principală. În acest caz, argumentele sunt folosite ca luminozitatea fiecărui LED. Scala pentru luminozitate este 0-255 deoarece fiecare culoare este definită folosind un octet, care permite 256 de modele distincte. Găsiți acest circuit pe Tinkercad. Descărcați și deschideți codul din acest proiect RGB mai complex sau copiați și inserați codul într-o schiță nouă Arduino. Citiți comentariile pentru a afla mai multe despre modul în care funcționează acest program. Ea face ceva matematică pentru a converti un interval de 0-100 la intervalul necesar LED-urilor, astfel încât să puteți gândi în procente în loc de 0-255. Utilizează colecții de variabile numite matrice pentru stocarea culorilor și trei funcții definite de utilizator pentru a calcula valorile pentru o estompare lină între culori, astfel încât bucla () să fie frumoasă și ordonată. crossFade(red); aproape citește ca limba engleză! Vom introduce în câteva din celelalte cuvinte cheie din această schiță în lecțiile viitoare, dar mai întâi este momentul să celebrați tot ce ați realizat până acum.