Arduino Uno - Realizarea unui program

În această postare vă voi prezenta modul de realizare al unui program simplu, folosind Arduino și vă voi prezenta câteva exemple.

Pentru început trebuie să aveți o plăcuță Arduino și să aveți instalat programul Arduino IDE.
Pentru modul de instalare a programului și pentru câteva informații despre acesta, puteți consulta o altă postare de pe acest blog: http://gabimath.blogspot.ro/2017/02/notiuni-introductive-arduino.html

Deschideți programul Arduino IDE și o să vă apară fereastra următoare:

Un program Arduino trebuie să conțină obligatoriu, cele 2 funcții care apar și în imaginea de mai sus. Pe lângă acestea, utilizatorul își poate crea propriile funcții, după ceea ce dorește ca programul să realizeze. Dar până să ajungem la crearea unei funcții, să vedem ce fac acestea obligatorii și cum se pot realiza câteva programe simple.

Funcția setup

Așa cum se observă și în imagine, aceasta este funcția de început a unui program Arduino, care se execută o singură dată. Ca o paranteză, specific că într-un program Arduino, ceea ce se scrie după 2 bare oblice ( // ) reprezintă un comentariu. Astfel " // put your setup code here, to run once ", este un comentariu care ne spune ceea ce am scris și eu mai sus.
Conținutul unei funcții în Arduino, se scrie între acolade - { //conținutul funcției }
În această funcție, se declară pinii folosiți și tipul lor, OUTPUT (ieșire) sau INPUT (intrare), se inițializează diverse operații și componente (comunicarea serială, senzori, LCD, receptor IR, etc.)

Funcția loop

Aceasta este funcția principală a unui program Arduino, care rulează "la infinit", bineînțeles atât timp cât plăcuța Arduino este alimentată. Este important să ținem cont de faptul că funcția loop este o funcție repetitivă, atunci când realizăm un program.

Ce mai este de specificat în legătură cu un program realizat în Arduino, este aceea că la început de tot, înainte de funcția setup, includem librăriile care ne sunt necesare ( #include ) și putem defini anumite variabile globale. De asemenea, variabilele pot fi declarate și între cele 2 funcții ale programului, între setup și loop, sau local în funcția loop.

Pentru tipuri de variabile, operatori, structură, funcții, etc., folosite într-un program Arduino, consultați următorul link: https://www.arduino.cc/en/Reference/HomePage



Acum, să începem realizarea unui program cu Arduino Uno.

Nu uitați ca după ce ați conectat plăcuța Arduino la computer, să alegeți în meniul Tools, tipul acesteia și portul corespunzător. Eu voi folosi o plăcuță Arduino Uno, conectată la portul COM 4.

Plăcuța Arduino Uno este prezentată în imaginea următoare.

Nu voi vorbi despre alcătuirea acestei plăcuțe, despre interfețele I2C sau SPI, în ceea ce urmează, deoarece nu acesta este scopul postării.
Ceea ce vreau să specific în legătură cu plăcuța Arduino Uno, este că aceasta are 14 pini care pot fi folosiți ca intrări sau ieșiri digitale ( pinii de la 0 la 13) și 6 pini folosiți ca intrări analogice (pinii A0 la A5). Dintre cei 14 pini digitali, 6 (pinii 3, 5, 6, 9, 10 și 11) sunt pini PWM(~) și vom folosi într-un exemplu de program unul dintre ei. Pinii de tip PWM permit ca la ieșire să variem tensiunea între 0V și 5V.
Pentru mai multe informații despre plăcuța Arduino Uno și pinii acesteia, consultați următoarele pagini:
https://www.arduino.cc/en/Main/ArduinoBoardUno
https://www.allaboutcircuits.com/technical-articles/understanding-arduino-uno-hardware-design/
http://playground.arduino.cc/Learning/Pins

Controlul unui LED

Primul program, cel mai simplu de realizat, este să aprindem și să stingem un LED. Plăcuța Arduino Uno are un LED conectat la pinul 13 și îl vom folosi pe acesta.
Mai întâi. în funcția setup declarăm pinul 13 ca ieșire , iar apoi îi dăm starea de LOW - tensiune 0.
În funcția loop, vom aprinde și vom stinge LED-ul conectat la pinul 13 la câte 1 secundă. Pentru aceasta vom schimba starea pinului din HIGH, adică 5V în LOW - 0 V, la un interval de timp de 1000 ms = 1 s.

Programul folosit este următorul:

void setup() {
 pinMode(13, OUTPUT);  // declaram pinul 13 ca iesire
 digitalWrite(13, LOW);  // starea initiala a pinului - LOW = stins
}

void loop() {
 digitalWrite(13, HIGH);  // punem pinul pe starea HIGH - aprindem ledul
 delay(1000);   // asteaptam 1 secunda (1000 ms - milisecunde)
 digitalWrite(13, LOW);  // punem din nou pinul pe LOW  - stingem ledul
 delay(1000);   // asteptam inca o secunda pana la relearea functiei

}

Instrucțiunile se termină cu caracterul punct și virgulă(;), și după ele eu am pus și câte un comentariu.
Copiați codul, salvați programul, dați upload la program, iar apoi urmăriți funcționarea plăcuței. Ledul situat lângă pinul 13, se va aprinde și stinge la fiecare secundă.

Acum puteți conecta și un LED extern pe oricare din pinii digitali de la 2 la 13. Puneți minusul (-) LED-ului, picioul mai scurt al acestuia la GND, printr-un rezistor și plusul (+) LED-ului la pinul dorit. Folosiți un rezistor de 220 sau 270 ohmi. Pentru leduri albastre, verzi sau albe, și un rezistor de 100 ohmi este bun, însă pentru ledurile roșii, galbene sau portocalii, care merg la tensiune mai mică, folosiți un rezistor cu valoarea în jur de 220 de ohmi, după cum aveți la dispoziție.
Modificați în codul programului, numărul 13, cu numărul pinul ales, de exemplu 7,  peste tot unde acesta apare. Dacă aveți LED-uri la 5V sau la 12V nu mai este necesar să conectați rezistorul respectiv.




Varierea intensității luminoase a unui LED

Următorul program este acela de a modifica intensitatea luminoasă a unui LED. Aceasta o vom face prin varierea tensiunii pe pinul la care vom conecta LED-ul. Astfel, mai întâi vom crește tensiunea de la 0V la 5V, apoi o vom scădea de la 5V înapoi la 0V și acest proces se va repeta atât timp cât lăsăm plăcuța alimentată și nu modificăm programul încărcat pe ea.
Am amintit mai sus de pinii digitali de tip PWM ai plăcuței Arduino. Pentru programul acesta vom folosi un pin dintre aceștia. Eu, de exemplu voi folosi pinul 10 pentru programul care urmează.
Conectăm plusul LED-ului la pinul 10, apoi printr-o rezistență de 220 ohmi cuplăm minusul LED-ului la GND-ul plăcuței Arduino.

Pentru realizarea programului, instrucțiunea principala este analogWrite(pin, valoare), unde în loc de pin scriem numărul unuia din pinii PWM (3, 5, 6, 9, 10 sau 11) - pentru exemplul nostru folosim pinul 10. Pentru valoare putem da orice număr întreg între 0 și 255, valoarea 0 reprezentând 0V, iar 255 reprezentând 5V. Numerele întregi cuprinse între 1 și 254, vor atribui un nivel de tensiune proporțional. De exemplu, pentru 1V vom da valoarea 51, pentru 2,5V vom da valoarea 128, iar pentru  4V avem valoarea 204. Noi vom lua toate valorile între 0 și 255, iar aceasta o vom face cu o structură repetitivă de tip for. Mai întâi luăm valorile crescător de la 0 la 255, apoi descrescător de la 255 la 0.

Programul folosit este următorul:

// varierea intensitatii luminoase a unui LED

void setup() {
pinMode(10, OUTPUT);  // declaram pinul 10 ca iesire
digitalWrite(10, LOW);  // punem pinul in starea LOW - la 0V (zero volti)
}

int i;  // declaram o variabila de tip numar intreg

void loop() {
  // cresterea tensiunii de la 0V la 5V
for(i=0; i<255; i++){
  analogWrite(10, i);  // setam pe pinul 10, nuvelul '"i" de tensiune
  delay(20);   // asteptam 20 ms (mili secunde) pana dam urmatoarea valoare 
  }

  // scaderea tensiunii de la 5V la 0V
for(i=255; i>0; i--){
  analogWrite(10, i);
  delay(20);
  }
}

În program am folosit un timp de asteptare (delay) de 20 ms, înainte de a crește sau descrește cu o unitate nivelul de tensiune. În aproximativ 5s (secunde), intensitatea va ajunge de la 0 la 255, apoi în alte 5s va scădea înapoi la 0. Dacă vă doriți ca aceasta să se facă mai încet, măriți delay-ul, de exemplu la 50, sau dacă vreți ca varierea luminozității să se facă mai rapid, scădeți delay-ul la 10. Acum, modificați codul după bunul plac!



Folosirea ferestrei Serial Monitor


Un ultim program pe care vreau să vi-l prezint în această postare, este acela de a afișa mesaje în fereastra Serial Monitor a programului Arduino IDE.
Acest lucru este foarte util, dacă trebuie să cunoașteți rezultatele anumitor operații sau valorile citite de la diferiți senzori, cuplați la plăcuța Arduino.

Pentru realizarea programului, mai întâi trebuie să inițializăm comunicarea serială, în funcția Setup. Aceasta se face cu instrucțiunea Serial.begin(9600), unde 9600 reprezintă "baud rate-ul" - sau viteza de modulare a simbolurilor. Programul Arduino poate lucra la diferite valori ale baud rate-ului, însă cea mai folosită este aceasta de 9600.
Apoi, în funcția loop, vom afișa diverse mesaje cu comenzile Serial.print("mesaj"); sau Serial.println("mesaj");, dacă ne dorim să trecem pe rândul următor, după afișarea mesajului.
Pentru a lăsa un rând liber sau mai multe între diverse mesaje, vom folosi instrucțiunea: Serial.print("");

Folosim următorul program pentru a scoate în evidență ceea ce am spus puțin mai sus.

// folosirea ferestrei Serial Monitor

void setup() {
  Serial.begin(9600);  // initializam comunicarea seriala 
  Serial.println("TEST SERIAL MONITOR");  // afisam un mesaj de inceput
  Serial.println("");     // lasam un rand liber
}

void loop() {
  // mesajele urmatoare vor fi afisate in mod repetat
  Serial.print("Numele meu este: ");  // afisam mesajul fara a trece pe randul urmator
  Serial.println("Buica Corneliu");   // inlocuiti cu numele vostru
  delay(5000);   // asteptam 5 secunde
  Serial.println("Acesta este un program Arduino!");  // se afiseaza mesajul 
  delay(2000);   // asteptam alte 2 secunde
  Serial.println("Acesta este un mesaj afisat pe Serial Monitor!");
  Serial.println(""); 
  Serial.println("");  // lasam 2 randuri liber
  delay(3000);
}

După ce încărcăm codul pe plăcuța Arduino deschidem fereastra Serial Monitor și vom vedea următoarele mesaje, ca în imaginea de mai jos:

Mesajul din funcția setup se afișează o singură dată, apoi cele 3 mesaje din funcția loop se vor repeta la intervalele de timp stabilite în program, prin instrucțiunile de așteptare - delay().
Dacă apăsați butonul de reset al plăcuței, programul o va lua de la început, veți vedea mesajul inițial, apoi celelalte 3 mesaje repetându-se.
Acum, modificați programul, introduceți și alte mesaje, modificați timpul de așteptare dintre ele, încercați mai multe combinații.


Pentru încă un tutorial Arduino, în care sunt prezentate alte 3 programe de început, consultați următoarea postare, o continuare a acesteia:
Realizarea programelor Arduino - partea 2

Succes!

Notă: Programele realizate pentru o plăcuță Arduino UNO, pot fi încărcate și rulate și pe un Arduino Nano, cu procesor ATmega328. Configurația pinilor este aceeași, trebuie doar să setați în meniul Tools, la Board și la Port, tipul corespunzător.