Ghidul pentru începători pentru Arduino

Indiferent dacă sunteți un veterinar de sisteme integrate, un om de știință de liceu sau o persoană curioasă, trebuie să vă începeți explorările electronice de undeva. Dacă manualul nu este suficient, consultați acest ghid pentru începători pentru Arduino.

Ce este un Arduino?

Arduino este o marcă de plăci de microcontrolere open-source dezvoltate de compania Arduino.

Când vorbești despre Arduino, de obicei este vorba despre placă. Plăcile Arduino sunt speciale pentru că sunt durabile. Ele sunt menite să fie folosite de studenți (sau oricine) care ar putea să încurce lucrurile și să spargă ceva.

Un alt lucru special la ei este că sunt open-source. The fișe de date pentru toate plăcile și scuturile Arduino sunt disponibile online. Vă puteți crea propria placă Arduino dacă aveți cunoștințele tehnice.

Ce înseamnă asta pentru mine?

Pentru un începător, aceasta înseamnă:

1. Nu trebuie să-ți faci propriile circuite pentru a studia microcontrolere.
2. Aceste plăci vin cu caracteristici de siguranță pentru a vă împiedica să le spargeți accidental.
3. Comunitatea de hardware open-source a realizat o gamă largă de plăci pentru diferite scopuri – există chiar și una destinată punând electronice pe haine!

Anatomia unei plăci Arduino

Există multe tipuri de plăci Arduino. Unele sunt la fel de mici ca o baterie, în timp ce altele sunt la fel de mari ca o cameră digitală, dar toate au câteva părți în comun:

1. Unitate de microcontroler
2. Știfturi pentru antet
3. Porturi de alimentare și USB
4. LED-uri indicatoare

Există și alte plăci terțe, bazate pe Arduino, care sunt construite de proprii producători, dar, în mod normal, au aceste lucruri în comun.

Unitate de microcontroler (MCU)

Unitatea de microcontroler, aka MCU, citește și controlează toate intrările și ieșirile de pe placă. De asemenea, stochează codul creat de utilizator care îl face să facă lucruri.

Arduino Uno R3 are un cip MCU special detașabil. În acest fel, puteți înlocui acea piesă odată ce este fie stricată, fie uzată. Alte plăci au chipurile MCU lipite de placa în sine. Dezavantajul de acolo este evident, dar de obicei sunt făcute pentru a fi mult mai mici și mai rapide decât omologii lor nesudate.

Pinuri de antet

În lateral, ar trebui să vedeți câteva bucăți de plastic ridicate, cu găuri deasupra. Sunt știfturi femele pentru antet. Ar trebui să puneți fire sau știfturi masculine în ele.

Există două tipuri de pini: GPIO și pini de alimentare. Pinii GPIO vă permit să procesați intrările și ieșirile. În mod implicit, toți pinii Arduino sunt intrări. Pe de altă parte, pinii de alimentare sunt meniți pentru a muta electricitatea în jurul plăcii. 5V și 3.3V emit întotdeauna atâta tensiune cât spune numele lor. GND înseamnă „sol”, iar Vin vă permite să alimentați placa prin acel pin.

Porturi de alimentare și USB

Toate plăcile Arduino au de obicei două tipuri de porturi: un port USB și mufă DC baril, dar unele nu au o mufă DC baril. De obicei își primesc puterea fie de la portul USB, fie de la pinii de alimentare.

Mufele DC sunt de obicei de 2,1 × 5,5 mm, cu interiorul pozitiv și exterior ca negativ. Sunt proiectate să accepte orice între 7 și 20 de volți, dar ești mai bine ținând la 9 volți ori de câte ori este posibil.

Porturile USB sunt diferite, în funcție de model. Ei pot folosi Type-A, Type-B, USBmicro sau Type-C. Puteți alimenta placa prin acestea și servesc și ca porturi de comunicare.

LED-uri indicatoare

În cele din urmă, există de obicei trei LED-uri indicatoare care vă permit să vedeți starea plăcii.

1. RX (primire)
2. TX (transmitere)
3. L (LED încorporat)
4. ON (pornire)

Pinii L și ON se explică de la sine. Unul este un LED încorporat pe care îl puteți controla, în timp ce celălalt se aprinde ori de câte ori trece electricitatea prin placă. Primele două, pe de altă parte, se pornesc ori de câte ori Arduino primește sau transmite informații prin comunicare în serie.

Arduino IDE

Începătorii ar trebui să înceapă cu Arduino IDE înainte de a trece la orice alt program, cum ar fi PlatformIO, parțial pentru că este ușor, cu tot ce aveți nevoie acolo. De asemenea, este mai puțin probabil să încurci lucrurile dacă folosești acest lucru. La urma urmei, este făcut pentru plăci Arduino.

Arduino IDE are trei funcții importante:

1. Editare
2. Clădire
3. Încărcare

În mod normal, funcțiile de creare și încărcare funcționează mână în mână. De îndată ce ați terminat de tastat și editat codul, îl puteți crea, apoi puteți încărca totul direct pe forum. Dar există momente când trebuie doar să-l construiești și nu trebuie să încarci.

The Arduino IDE poate fi descărcat prin site-ul Arduino.

Modalități de a clipi LED-ul încorporat

Clipirea LED-ului încorporat este versiunea Arduino a unui script „Hello World” și este o modalitate simplă de a testa dacă Arduino funcționează. Demonstrez toate modalitățile diferite de a-l face să clipească, inclusiv să îi spun computerului că clipește deja.

Exemplul 1: Blink de bază

Începem cu scriptul de bază Blink. Va trebui doar să porniți LED-ul încorporat timp de 0,5 secunde, apoi să îl opriți pentru încă 0,5 secunde.

1. Deschideți IDE-ul dvs. Arduino.

2. Ar trebui să fiți întâmpinat cu o nouă schiță imediat ce deschideți IDE-ul. Dacă nu, faceți clic pe „Fișier -> Nou” sau apăsați Ctrl + N.

3. Înlocuiți codul de pe IDE cu următorul cod:

void setup() {
  // put your setup code here, to run once:
  pinMode(LED_BUILTIN, OUTPUT);
}
 
void loop() {
  // put your main code here, to run repeatedly:
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
}

4. Accesați „Schiță -> Încărcare” sau apăsați Ctrl + U pentru a încărca codul în Arduino.

Codul Arduino este de obicei împărțit în două părți: setup() și loop().

Cand vezi setup(), ar trebui să vă definiți ieșirile și intrările. În acest caz, folosim pinMode() pentru a transforma LED_BUILTIN pin într-un pin de ieșire.

The LED_BUILTIN pinul este pinul 13 și este conectat direct la LED-ul L. Îl va porni ori de câte ori primește suficientă energie electrică pentru a-l porni la MARE. Puteți chiar înlocui toate instanțele de LED_BUILTIN cu 13și va funcționa în continuare.

setup() este discutat mai mult în exemplul următor. Aici, totul începe de la prima linie din interior loop(), iar Arduino execută acea linie, apoi o face pe a doua, apoi pe a treia și așa mai departe, până ajunge la ultima linie. Apoi se va întoarce la prima linie după aceea. De aceea se numește a loop().

În acest exemplu, am folosit digitalWrite() la putere LED_BUILTIN la HIGH. 5V de electricitate trec pe aici, atunci delay(500) va opri temporar Arduino să citească mai mult cod timp de 500 de milisecunde. După aceea, Arduino rulează următoarea linie, care aduceLED_BUILTIN până la LOW.

De fapt, este o buclă de pornire, așteptare pentru o jumătate de secundă, oprire, așteptare încă o jumătate de secundă, apoi întoarcere din nou la linia de start. Continuă să scadă atâta timp cât este conectat la o sursă de alimentare.

Exemplul 2: Trei clipiri la pornire

De data asta, ne jucăm cu setup() astfel încât să putem face ca LED-ul încorporat să clipească rapid de trei ori înainte de a clipi lent la fiecare 0,5 secunde.

1. Pe codul actual, mutați cursorul la pinMode(LED_BUILTIN, OUTPUT); face o nouă linie sub void setup().

2. Lipiți următorul cod pe acea linie:

 digitalWrite(LED_BUILTIN, HIGH);
 delay(1000);
 digitalWrite(LED_BUILTIN, LOW);
 delay(250);
 digitalWrite(LED_BUILTIN, HIGH);
 delay(1000);
 digitalWrite(LED_BUILTIN, LOW);
 delay(250);
 digitalWrite(LED_BUILTIN, HIGH);
 delay(1000);
 digitalWrite(LED_BUILTIN, LOW);
 delay(250);

3. Codul dvs. ar trebui să arate astfel:

void setup() {
  // put your setup code here, to run once:
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(250);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(250);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(250);
}
 
void loop() {
  // put your main code here, to run repeatedly:
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
}

4. Încărcați codul, apoi uitați-vă la Arduino go! Amintiți-vă, este fie „Schiță -> Încărcați”, fie Ctrl + U pentru a trimite codul la bord.

Despre exemplul anterior se vorbea loop() și cum funcționează. Să ne întoarcem puțin și să ne extindem setup().

Tot ceea ce plasezi setup() rulează o dată, așa cum spune comentariul pre-scris. Cu aceasta, puteți face Arduino să facă ceva pentru a vă spune că va începe să funcționeze. Dacă aveți un ecran LCD, OLED sau AMOLED, ați putea chiar să îi oferiți o animație de încărcare falsă!

De asemenea, aici ar trebui să porniți comenzi speciale, cum ar fi stabilirea comunicării prin serial.

Exemplul 3: Utilizarea comunicației seriale

Spre deosebire de o comunicare paralelă, o comunicare serială trimite date de la sursă la destinație, câte un bit.

De data aceasta, Arduino va trimite câteva mesaje prin serie pentru a vă oferi actualizări de stare.

1. Pe setup()faceți o nouă linie înainte pinMode(LED_BUILTIN, OUTPUT); și tip Serial.begin(9600);. Faceți o nouă linie dedesubt pentru a arăta puțin mai îngrijit.

2. Faceți o nouă linie după pinMode(LED_BUILTIN, OUTPUT);apoi tastați Serial.println("Arduino, starting up!"); în acea nouă linie. Lăsați o nouă linie între acestea două.

3. Mergi la loop(). Faceți o nouă linie sub digitalWrite(LED_BUILTIN, HIGH); și tip Serial.println("LED on");. Faceți același lucru pentru digitalWrite(LED_BUILTIN, LOW); dar tip Serial.println("LED off"); in schimb.

4. (Opțional) Puteți lăsa o nouă linie între prima delay(500) și digitalWrite(LED_BUILTIN, LOW);.

5. Codul complet ar trebui să arate astfel:

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
 
  pinMode(LED_BUILTIN, OUTPUT);
 
  Serial.println("Arduino, starting up!");
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(250);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(250);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(250);
}
 
void loop() {
  // put your main code here, to run repeatedly:
  digitalWrite(LED_BUILTIN, HIGH);
  Serial.println("LED on");
  delay(500);
 
  digitalWrite(LED_BUILTIN, LOW);
  Serial.println("LED off");
  delay(500);
}

6. Încărcați codul folosind „Sketch -> Upload” sau Ctrl + U.
7. Deschideți Serial Monitor fie accesând „Tools -> Serial Monitor”, fie apăsând Ctrl + Schimb + M pe tastatură. Un ecran dreptunghiular ar trebui să apară și să imprime toate ieșirile seriale cu care ați programat Arduino.

Deoarece software-ul folosește o consolă pentru depanare, ar trebui să utilizați serialul în hardware pentru același lucru.

În setup()ai adăugat linia Serial.begin(9600);. Aceasta îi spune lui Arduino să deschidă un canal cu computerul pentru comunicarea în serie. Numărul de lângă acesta arată cât de repede ar trebui să trimită date.

The 9600 se referă la 9600 baud. Aceasta înseamnă că va trimite 9600 de biți pe secundă. Ratele de transmisie variază de la 300 la mai mult de 2 milioane de baud pentru Arduino IDE. Tarifele mai mici sunt mai bune pentru firele mai lungi (gândiți-vă la firele telefonice pentru distanță), în timp ce cele mai mari sunt pentru firele mai scurte. 2 milioane de baud-uri este exagerat, totuși. În multe cazuri, chiar și 19200 de baudi sunt mai mult decât suficiente chiar și pentru cei mai sensibili senzori pasionați.

Cu asta din drum, hai să vorbim despre Serial.println(); Următorul. Această comandă înseamnă „print, line new” și face o nouă linie după ce imprimă ceea ce este în interiorul () zonă.

Serial.println() acceptă fie șiruri de caractere, fie variabile care conțin șiruri de caractere. Se comportă ciudat atunci când adăugați numere în ele, mai ales dacă începe cu 0.

Dacă vă uitați la rezultatele monitorului dvs. serial, ar trebui să observați și că acesta afișează „Arduino, pornește!” doar o data. Între timp, „LED pornit” și „LED oprit” sunt imprimate în mod repetat la fiecare ciclu de clipire. Asta e marea diferență între setup() și loop().

De fapt, puteți chiar să vă puneți codul de la setup() în loop(), dar aceasta este de obicei o practică proastă. Puteți ajunge să transformați un pin de intrare într-un pin de ieșire, rupând potențial cipul microcontrolerului.

Exemplul 4: Clipește cu For-Loops

Acest lucru ajută foarte mult. O buclă for vă permite să faceți un mini loop() care se încheie după un anumit număr de ori.

Să încercăm să facem modele complexe de clipire cu mai multe bucle for. La prima încărcare, LED-ul ar trebui să clipească de 13 ori, aprins timp de 500 ms și stins timp de 250 ms și doar o dată. Apoi ar trebui să clipească, să clipească de patru ori, pornit timp de 1000 ms și oprit timp de 1000 ms, apoi să clipească încă de două ori, pornit timp de 500 ms și oprit timp de 250 ms.

1. Pe setup()eliminați blocul de cod care se întoarce LED_BUILTIN la HIGH sau LOW. De asemenea, ștergeți delay() funcții.

2. Înlocuiți acel cod cu următorul:

for (int i = 0; i < 12; i++) {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(250);
}

3. La loop()eliminați totul și înlocuiți-l cu următorul cod care aprinde LED-ul timp de 1000 ms și stinge timp de 1000 ms, fiecare de patru ori:

for (int i = 0; i < 4; i++) {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  Serial.println("LED on for 1 second");
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
  Serial.println("LED off for 1 second");
}

4. Faceți o nouă linie și adăugați următorul cod care pornește LED-ul timp de 500 ms și stinge timp de 250 ms, fiecare de două ori:

for (int i = 0; i < 2; i++) {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  Serial.println("LED on for 0.5 seconds");
  digitalWrite(LED_BUILTIN, LOW);
  delay(250);
  Serial.println("LED off for 0.25 seconds");
}

5. Încărcați codul, apoi deschideți monitorul serial. Ar trebui să înceapă să numere până la 13 LED-uri intermitente înainte de a face cele două mini bucle diferite.

For-loop este un instrument simplu, dar ușor de învățat. Are trei părți: for, (int i = 0; i < x; i++)și orice se află în interiorul { }.

• for spune Arduino IDE că este o funcție for-loop. Sunt multe altele, cum ar fi while, ifși switch.
• (int i = 0; i < x; i++) este o condiție. Se spune că în timp ce numărul întreg icare este 0, este sub valoarea lui xatunci fa i++ și executați funcția. i++ este prescurtarea pentru i + 1. Puteți chiar să-l înlocuiți cu i + x unde „x” este orice număr sau faceți numărătoare inversă folosind operatorul „-”.
• The { } conține tot ce va face bucla. Nu are nevoie de un ; la sfarsit. O lași așa cum este.

Concluzie

Cu acest ghid simplu pentru începători pentru Arduino, puteți începe să vă creați propriile efecte de lumină personalizate sau poate o lumină de Crăciun de lux.

Mai sunt de învățat, desigur, dar ar fi mai bine să înveți pe măsură ce mergi. Ai putea încerca motoare, senzori, relee și multe altele! Dacă sunteți pregătit pentru provocare, poate doriți să programați un Arduino folosind un Raspberry Pi.