Arduino

De la Capisci

Salt la: navigare, căutare
O placă Arduino Uno

Arduino este o platformă hardware open source formată dintr-o placă electronică cu un microcontroller. Ceea ce sună mult mai intimidant decât este în realitate: platforma Arduino a fost dezvoltată cu scopul explicit de a înlesni dezvoltarea proiectelor care necesită componente electronice. În acest articol vom încerca să explicăm pas cu pas modalitatea de exploatare a acestei platforme; la sfârşitul articolului ar trebui să ştiţi ce produse trebuie să achiziţionaţi şi cum le puteţi asambla pentru un proiect minor.

Cuprins

Tipuri de module

Un proiect bazat pe platforma Arduino consistă din mai multe module conectate între ele. Modulele pot fi categorisite în funcţie de diverse criterii; aici le vom structura după funcţie. Vom vedea mai jos cum anume se conectează diversele module la platforma de dezvoltare; în această secţiune dorim doar să vă prezentăm tipurile mari de module, ca să vă faceţi o idee despre posibilităţi.

  • Platforma de dezvoltare — aceasta este placa electronică ce conţine microcontroller-ul („creierul”) programabil. Dat fiind că platforma Arduino este open source, sunt disponibile atât platforme Arduino originale, fabricate în Italia, cât şi clone compatibile, mai ieftine, fabricate în general în China[1]. Vom vedea mai departe că există mai multe modele de astfel de platforme, modele care diferă atât în ceea ce priveşte capabilităţile cât şi în ceea ce priveşte dimensiunile fizice. Totuşi limbajul de programare, mediul de dezvoltare şi interconectarea diverselor module sunt practic identice, indiferent de modelul specific al platformei.
  • Module de intrare — numite şi senzori, acestea sunt module care se conectează la platforma Arduino pentru a trimite date către aceasta (de exemplu butoane, senzori de temperatură, senzori de distanţă, potenţiometre ş.a.m.d.)
  • Module de ieşire — acestea sunt module care se conectează la platforma Arduino pentru a permite acesteia să transmită informaţii către lumea exterioară. Acestea pot fi relee, afişaje, difuzoare ş.a.m.d.
  • Module de date — modulele de date permit platformei Arduino să comunice direct cu alte dispozitive digitale (inclusiv cu alte module Arduino). Modulele de date pot fi module Ethernet, care permit comunicaţia prin Internet sau printr-o reţea locală, module radio, care pot comunica cu computere sau alte platforme Arduino, module USB, module GSM şi aşa mai departe.
  • Accesorii — acestea nu sunt în general considerate module Arduino, însă sunt o parte uzuală a proiectelor de acest gen. Există tot felul de accesorii, de la soluţii de alimentare cu curent electric până la cele mai diverse accesorii.

Conectarea modulelor

În general, un proiect bazat pe platforma Arduino consistă dintr-o platformă Arduino sau compatibilă şi mai multe module conectate la aceasta. Dacă vă uitaţi cu atenţie la plăcuţa din imaginea de mai sus veţi observa că puteţi identifica câteva elemente destul de distincte: un conector USB (cutiuţa argintie), o mufă de alimentare (piesa neagră cilindrică de lângă conectorul USB) şi o sumedenie de conectori (piesele negre proeminente, cu găurele, dispuse în două rânduri, pe marginea de sus şi de jos a plăcii). Toate aceste elemente sunt disponibile, sub o formă sau alta, pe orice placă Arduino sau compatibilă[2].

Conectorul USB este necesar pentru programarea iniţială a microcontrollerului. Prin intermediul acestuia, platforma se conectează la un computer pe care se scrie, se compilează şi se încarcă programul dorit. Vom vedea detalii mai jos.

Mufa de alimentare nu vă interesează pentru moment — platforma Arduino se alimentează prin portul USB, atâta vreme cât consumul de curent este rezonabil.

Pinii disponibili

Conectorii propriu-zişi sunt partea cu adevărat interesantă a întregii poveşti. Conectorii de pe platformele de dezvoltare Arduino[3] sunt conectori mamă[4]; deşi puţin impropriu în aceste circumstanţe, vom numi fiecare conector individual, adică fiecare găurică, un pin[5]. Ei bine, pinii de pe placa de dezvoltare au următoarele funcţii, conform etichetelor tipărite pe placă:

  • GNDground, masa, polul negativ al circuitului, tensiune 0 volţi[6]
  • 5V — 5V, pin care prezintă o tensiune de 5 volţi faţă de GND, indiferent de tensiunea de alimentare.
    N.B.: în funcţie de modelul platformei de dezvoltare, tensiunea de lucru poate fi 5V sau 3,3V; pentru plăcile care funcţionează la 3,3V, toate menţiunile explicite despre tensiunea de 5V din acest articol se vor citi 3,3V[7].
  • VCC — tensiunea de intrare. Platforma Arduino se alimentează fie prin conectorul USB, fie prin mufa de alimentare; acest pin prezintă tensiunea de alimentare neschimbată, indiferent că este 3,3V, 5V, 9V, 12V sau orice altceva.
  • Digital 0, Digital 1, ..., Digital N — pini de intrare/ieşire digitală. Dumneavoastră decideţi din program dacă pinul X va fi folosit pentru intrare sau pentru ieşire. Pinii digitali au doar două stări: 1 sau 0 (logic), HIGH sau LOW (notaţia în cod), 5V sau 0V (tensiunea propriu-zisă). Numărul concret de pini disponibili depinde de modelul specific al platformei de dezvoltare; în general, numărul lor este de 14 sau 54.
  • Analog 0, Analog 1, ..., Analog N — pini exclusiv de intrare analogică. Aceştia pot citi valori discrete între 0 şi 1023, corespunzătoare în mod proporţional tensiunii de intrare (între 0 şi 5V). Din nou, numărul de pini diferă de la placă la placă; în general numărul lor este de 6 sau 16.

În afară de aceşti pini, mai există câţiva pini cu funcţii speciale; în plus, unii dintre pinii de deasupra au funcţii auxiliare suplimentare. Nu vrem să intrăm aici în prea multe detalii, însă câtă vreme sunteţi la început de drum vă sunt suficiente următoarele informaţii:

  • Evitaţi pinii digitali 0 şi 1[8].
  • Pe aproape toate platformele Arduino şi compatibile pinul digital 13 corespunde şi unui LED lipit direct pe placă; acesta este un martor util pentru experimentele dumneavoastră în timpul dezvoltării.
  • Observaţi pinii marcaţi PWM pe placă — aceştia pot fi folosiţi pentru a trimite semnal digital modulat, util de exemplu pentru a simula intensitatea luminoasă variabilă a unui LED

Conectarea propriu-zisă

Aproape orice modul extern are nevoie de cel puţin trei fire de conectare: două pentru alimentare (GND şi 5V) şi cel puţin unul pentru semnal (înspre sau dinspre modul, în funcţie de natura acestuia).

ATENŢIE! Unele module funcţionează la 3,3V, motiv pentru care unele platforme Arduino lucrează la 3,3V în mod nativ. Dacă alimentaţi un modul de 3,3V la de pinul de 5V al unei platforme Arduino aveţi toate şansele să ardeţi ireversibil modulul respectiv!

Un exemplu uşor de înţeles este un buton simplu, pe care îl puteţi conecta la platforma Arduino în felul următor:

Pin modul buton Pin Arduino
1 GND
2 5V
3 Digital 2

Evident, scopul acestui modul este să notifice aplicaţia dumneavoastră în privinţa stării butonului (apăsat sau neapăsat), în aşa fel încât să luaţi o acţiune sau alta. La fel de evident, un singur buton nu ar fi suficient pentru a finaliza o aplicaţie utilă — aveţi nevoie să conectaţi mai multe module în mod simultan. Însă deja aţi folosit pentru buton pinii GND şi 5V de pe placa Arduino — cum veţi mai alimenta următorul modul? Aveţi nevoie să multiplicaţi cumva pinii 5V şi GND. Există mai multe soluţii pentru această problemă.

Varianta simplă este să achiziţionaţi un shield senzor. Acesta se înfige direct în placa Arduino şi multiplică pinii de alimentare, ceea ce rezolvă problema dintr-un foc.

O altă variantă, mai dificilă dar necesară în cazul proiectelor mai complexe, este să achiziţionaţi un breadboard: înfigeţi capătul unui fir de conectare tată-tată în pinul GND de pe Arduino şi celălalt capăt oriunde pe una dintre liniile orizontale albastre de pe breadboard; înfigeţi un capăt al altui fir în pinul 5V de pe Arduino şi celălalt capăt oriunde pe una dintre liniile roşii de pe breadboard. Acum aveţi GND pe toţi pinii de pe linia albastră şi 5V pe toţi pinii de pe linia roşie pe care le-aţi ales în pasul anterior. N.B. ceilalţi pini de pe breadboard sunt interconectaţi pe verticală, de obicei în două bancuri (şanţul orizontal întrerupe conexiunile, împărţind coloanele în două).

Programarea microcontroller-ului

Pentru a programa microcontroller-ul trebuie să conectaţi placa Arduino la un computer pe care aţi instalat mediul de dezvoltare şi driverele necesare. Mediul de dezvoltare este disponibil în mod gratuit pe site-ul producătorului pentru diverse sisteme de operare la adresa http://arduino.cc/en/Main/Software. Explicaţiile noastre se adresează utilizatorilor care folosesc Microsoft Windows:

  1. Descărcaţi aplicaţia de la adresa de mai sus şi dezarhivaţi-o într-un director convenabil; în restul documentului vom presupune că aţi dezarhivat-o în directorul C:\arduino-1.0, dar puteţi să folosiţi orice director vi se pare comod.
  2. Conectaţi placa Arduino la computer printr-un cablu USB; cel puţin un LED ar trebui să se aprindă pe placă
  3. Dacă vi se solicită indicarea locaţiei driverului, indicaţi directorul C:\arduino-1.0\drivers
  4. Porniţi mediul de dezvoltare executând C:\arduino-1.0\arduino.exe
  5. Indicaţi modelul plăcii dumneavoastră în meniul Tools > Board
  6. Indicaţi portul pe care s-a conectat placa Arduino în meniul Tools > Serial Port (în general aveţi o singură opţiune; apăsaţi pe ea[9])
  7. Alegeţi din meniu exemplul Blink: File > Examples > 1. Basics > Blink
  8. Încărcaţi programul pe placă: File > Upload

Felicitări! Dacă nu aţi primit nicio eroare atunci ar trebui să vedeţi un LED clipind lent pe placă — aţi încărcat primul dumneavoastră program pe placa Arduino!

Limbaj şi structură

Limbajul folosit este o variantă simplificată de C/C++, ameliorată cu diverse biblioteci specifice platformei Arduino. Este foarte uşor de folosit pentru oricine are experienţă de programare în orice limbaj cât de cât structurat. De altfel, puteţi constata cât de simplu este analizând exemplul pe care l-am încărcat deasupra:

 1. /*
 2.   Blink
 3.   Turns on an LED on for one second, then off for one second, repeatedly.
 4.  
 5.   This example code is in the public domain.
 6.  */
 7. 
 8. void setup() {                
 9.   // initialize the digital pin as an output.
10.   // Pin 13 has an LED connected on most Arduino boards:
11.   pinMode(13, OUTPUT);     
12. }
13. 
14. void loop() {
15.   digitalWrite(13, HIGH);   // set the LED on
16.   delay(1000);              // wait for a second
17.   digitalWrite(13, LOW);    // set the LED off
18.   delay(1000);              // wait for a second
19. }

După cum vedeţi, codul este cât se poate de inteligibil. Să vedem deci ce se întâmplă aici:

  • Au fost definite două funcţii, setup() (liniile 8-12) şi loop() (liniile 14-19). Aceste două funcţii trebuie să fie prezente în orice program; dacă nu aveţi nevoie de vreuna dintre ele atunci scrieţi-o şi lăsaţi-o goală (deşi este puţin probabil să vă găsiţi vreodată în această situaţie).
  • Funcţia setup() este executată o singură dată, la iniţializarea plăcii (de fiecare dată când este alimentată, de fiecare dată când încărcaţi un program nou şi de fiecare dată când resetaţi placa)
  • Funcţia loop() se execută apoi la infinit, fără pauză. Dacă aveţi nevoie de pauze trebuie să le introduceţi dumneavoastră în mod explicit.
  • În programul nostru, funcţia setup() face un singur lucru: declară pinul 13 (adică pinul digital 13) ca pin de ieşire. Dacă vă amintiţi de mai sus, pinul 13 este conectat şi la LED-ul de pe placă.
  • Funcţia loop() de mai sus face următoarele:
    • linia 15: scrie "1" la pinul 13 (adică din acest moment pinul respectiv va fi alimentat cu 5V)
    • linia 16: aşteaptă 1000 de milisecunde, adică o secundă; nu uitaţi, pinul 13 este alimentat, deci LED-ul de pe placă este aprins
    • linia 17: scrie "0" la pinul 13 (adică din acest moment pinul respectiv nu va mai fi alimentat)
    • linia 18: aşteaptă din nou o secundă (dar de data asta pinul 13 nu mai este alimentat, deci LED-ul este stins).

Dacă încă nu aţi făcut asta, experimentaţi cu valorile de temporizare de la liniile 16 şi 18 (evident, după fiecare modificare trebuie să încărcaţi din nou programul în Arduino, folosind File > Upload în meniu).

Interacţiune

Să analizăm şi un exemplu în care chiar interacţionăm cu plăcuţa noastră. Încărcaţi exemplul Button: File > Examples > 2. Digital > Button. Codul rezultat este următorul:

 1. /*
 2.   Button
 3.  
 4.  Turns on and off a light emitting diode(LED) connected to digital  
 5.  pin 13, when pressing a pushbutton attached to pin 2. 
 6.  
 7.  
 8.  The circuit:
 9.  * LED attached from pin 13 to ground 
10.  * pushbutton attached to pin 2 from +5V
11.  * 10K resistor attached to pin 2 from ground
12.  
13.  * Note: on most Arduinos there is already an LED on the board
14.  attached to pin 13.
15.  
16.  
17.  created 2005
18.  by DojoDave <http://www.0j0.org>
19.  modified 30 Aug 2011
20.  by Tom Igoe
21.  
22.  This example code is in the public domain.
23.  
24.  http://www.arduino.cc/en/Tutorial/Button
25.  */
26. 
27. // constants won't change. They're used here to 
28. // set pin numbers:
29. const int buttonPin = 2;     // the number of the pushbutton pin
30. const int ledPin =  13;      // the number of the LED pin
31. 
32. // variables will change:
33. int buttonState = 0;         // variable for reading the pushbutton status
34. 
35. void setup() {
36.   // initialize the LED pin as an output:
37.   pinMode(ledPin, OUTPUT);      
38.   // initialize the pushbutton pin as an input:
39.   pinMode(buttonPin, INPUT);     
40. }
41. 
42. void loop(){
43.   // read the state of the pushbutton value:
44.   buttonState = digitalRead(buttonPin);
45. 
46.   // check if the pushbutton is pressed.
47.   // if it is, the buttonState is HIGH:
48.   if (buttonState == HIGH) {     
49.     // turn LED on:    
50.     digitalWrite(ledPin, HIGH);  
51.   } 
52.   else {
53.     // turn LED off:
54.     digitalWrite(ledPin, LOW); 
55.   }
56. }

Ignoraţi indicaţiile din comentariile de deasupra şi conectaţi butonul aşa cum am descris în secţiunea Conectarea propriu-zisă, apoi încărcaţi programul şi apăsaţi butonul — dacă aţi conectat totul corect şi programul s-a încărcat fără erori ar trebui să vedeţi (cu bucurie) LED-ul de pe placă aprinzându-se atunci când apăsaţi pe buton. Să analizăm deci codul:

  • Regăsim funcţiile setup() (liniile 35-40) şi loop() (liniile 42-56).
  • Constatăm că s-au definit două constante (buttonPin, la linia 29 şi ledPin, la linia 30) şi o variabilă (buttonState, la linia 33). Constantele din acest exemplu sunt folosite pentru a stoca pinii la care sunt conectate butonul şi respectiv LED-ul; este o bună practică să definiţi şi să utilizaţi şi dumneavoastră pinii în acest fel, fiindcă se întâmplă relativ frecvent ca în mijlocul sau la sfârşitul unui proiect să doriţi să restructuraţi conexiunile modulelor externe.
  • Codul propriu-zis este cât se poate de simplu; singurele noutăţi reale faţă de exemplul anterior (în afară de logică) sunt definirea pinului de intrare pentru buton (linia 39) şi citirea valorii acestuia (linia 44). Restul codului este cât se poate de simplu şi de clar[10].

Debugging

Mai devreme sau mai târziu programul dumneavoastră va deveni atât de complicat încât vă veţi lovi de erori de logică; este inevitabil. Veţi dori deci să monitorizaţi valorile variabilelor, să vedeţi care ramură condiţională se execută şi aşa mai departe. În acest scop aveţi la dispoziţie conexiunea la computer, prezentă şi după ce aţi încărcat aplicaţia. Pentru a vedea cum se face asta, încărcaţi exemplul ASCII Table: File > Examples > 4. Communication > ASCII Table. Încărcaţi aplicaţia, apoi porniţi monitorul serial: Tools > Serial monitor. Asiguraţi-vă că viteza de comunicaţie este configurată la 9600 baud (în colţul din dreapta-jos al ferestrei monitorului). Ce vedeţi în acea fereastră este trimis către computer de către codul pe care l-aţi încărcat.

Note

  1. Compania italiană care a dezvoltat platforma Arduino nu permite, pe bună dreptate, utilizarea numelui Arduino pentru clone. Prin urmare producătorii şi comercianţii acestor clone produse în China le numesc TOSduino, Chinduino sau alte mutaţii similare.
  2. Cu excepţia conectorului USB, care lipseşte de pe unele modele miniaturale. Vom vedea detalii în continuarea articolului.
  3. Conectorii propriu-zişi nu sunt în general prezenţi pe plăcile miniaturizate, iar atunci când sunt prezenţi, de obieci sunt tată.
  4. Conectorii mamă sunt cei în care intră alţi conectori. Conectorii tată sunt cei care intră în conectorii mamă. Înţelegeţi voi.
  5. În mod tradiţional, un pin este un conector individual tată. Aici, deşi conectorul este mamă, folosim sensul general al cuvântului, conform DEX: terminal al unui circuit integrat.
  6. Tensiune 0 volţi este impropriu în acest caz, fiindcă tensiunea, adică diferenţa de potenţial, este exact ce-i spune numele: diferenţa dintre potenţialul masei şi potenţialul elementului măsurat; în cazul masei, este de la sine înţeles că nu există nicio diferenţă de potenţial între ea şi ea însăşi. Am dorit să notăm totuşi explicit tensiunea masei pentru claritate, deoarece vom menţiona mai jos cele două tensiuni posibile ale unui pin digital şi am dorit să fie intuitiv pentru începători faptul că HIGH este VCC şi LOW este GND.
  7. Am fi putut scrie articolul într-un mod mai riguros, dar lectura ar fi fost semnificativ mai greoaie, aşa că am ales varianta mai puţin riguroasă dar mai uşor de parcurs.
  8. Aceştia sunt utilizaţi pentru conectarea la computer; dacă îi conectaţi la un modul extern nu veţi mai putea comunica cu computerul pentru a modifica programul câtă vreme aceştia sunt conectaţi.
  9. Dacă aveţi mai multe porturi şi nu ştiţi care este cel pe care s-a conectat placa dumneavoastră atunci îl puteţi identifica în Device Manager, în secţiunea Ports (COM & LPT); căutaţi dispozitivul care foloseşte driver-ul de la arduino.cc
  10. De fapt codul este excesiv de simplu; în practică veţi dori să folosiţi o bibliotecă pentru a afla dacă butonul a fost apăsat de la ultima citire şi până la ciclul curent.