Universitatea "Constantin Brâncuşi" din Târgu-Jiu

Facultatea de Inginerie

Arduino -
o platformă
pe înțelesul tuturor

Conf. Dr. Ing. GROFU FLORIN

Scurt istoric al microprocesoarelor

Termenul “procesor” este folosit în industria calculatoarelor

încă de la începutul anilor ’60. De atunci forma și
implementarea s-a schimbat radical, însă rolul și
funcționarea de bază a microprocesoarelor au rămas
aceleași.

Primul pas major în istoria procesoarelor a fost apariția

tranzistoarelor la începutul anilor 1950. Cu aceasta inovație
anii ’50-60 au adus procesoare tranzistorizate mult mai
complexe și mai fiabile. Totodată în aceasta perioadă au
apărut și procesoarele ca circuite integrate. Cu evoluția
microelectronicii procesoarele au devenit din ce în ce mai mici
și mai performante.
Odată cu apariția primului microprocesor disponibil comercial, Intel
4004 și a primului microprocesor utilizat pe scară largă, Intel 8080,
microprocesoarele au devenit dominante pe piată și în industrie.

Aceste procesoare timpurii aveau caracteristici foarte modeste în

comparație cu ceea ce suntem obișnuiți astazi.

Intel 4004 avea frecvență de lucru de 740 kHz fiind un procesor pe

4 biti cu 2300 de tranzistoare.

Intel 8080 avea deja frecvență de lucru 2 MHz, 8 biți și 6000 de

tranzistoare.

Un microprocesor actual lucrează la frecvențe uzuale de

până la 5.00 GHz, funcționează pe 64 de biți și are peste 5
miliarde de tranzistoare.
Un sistem cu microprocesor pentru a deveni functional conține
microprocesorul la care se adaugă memorii, porturi pentru interfațare
și timer-e.
Proiectantul decide cantitatea de memorie și necesarul de porturi
de I/O.

Un microcontroller este un circuit care integrează un microprocesor

și alte dispozitive periferice într-un singur circuit integrat punându-
se accent pe un cost redus de producție și consum redus de
energie electrica.
Principala diferență dintre un microcontroller (µC) și un
microprocesor (µP) o constituie faptul ca un µC integrează memoria
de program, memoria de date și alte interfețe de intrare-ieșire sau
circuite periferice.
 La momentul actual în lume exisă câteva zeci de firme producătoare
ce oferă o gamă variată de µC din punct de vedere al arhitecturii,
dotărilor sau vitezei de execuție. Principalele concurente în piața de
8 biți erau companiile Atmel cu famiile AVR și Microchip cu famiile
PIC.

 În anul 2017 firma Microchip a preluat concurentul Atmel.

Platformele realizate cu microcontrolere care au avut o mare

utilizare de-a lungul timpului au fost Basic Stamp și cele realizare
cu microcontrolere din familia PIC, dar cea mai spectaculoasă
evolutie au avut-o modulele Arduino care sunt încă în continuă
ascensiune și diversificare.
Arduino – Scurtă prezentare
Arduino este o companie open-source care produce atât module de
dezvoltare bazate pe microcontrolere, cât și partea
de software destinată funcționării și programării acestora.
Pe lângă acestea include și o comunitate uriașă care se ocupă cu
creația și distribuirea de proiecte care au ca scop crearea de
dispozitive care pot sesiza și controla diverse activități sau procese în
lumea reală.

Proiectul este bazat pe designul plăcilor folosind diverse tipuri de

microcontrolere. Aceste plăci pun la dispoziția utilizatorului pini de
intrare ieșire I/O, digitali și analogici, care pot fi interfațați cu o gamă
largă de plăcuțe numite shield-uri sau cu alte circuite.
Plăcile au interfețe de comunicații seriale, inclusiv USB la unele
modele, pentru a încărca programe din calculatoarele personale.
Pentru programarea microcontrolerelor, Arduino vine cu un mediu de
dezvoltare integrat (IDE) care include suport pentru limbaje de
programare ca C și C++.

Primul modul Arduino a fost lansat în 2005, având ca țintă

asigurarea unei soluții ieftine și simple pentru începători și
profesioniști spre a crea dispozitive capabile să interacționeze cu
mediul, folosind senzori și sisteme de acționare. Cele mai comune
exemple pentru utilizatorii începători sunt dispozitivele precum:
roboții simpli, termostatele și/sau detectoarele de mișcare.
Arduino a început în 2005 ca un proiect al unui student al Institutului
de Interacțiune a Designului din Italia. La acea vreme studenții
foloseau o plăcuță de dezvoltare BASIC Stamp care costa 100$
ceea ce era considerat foarte scump pentru studenți. Massimo
Banzi, unul dintre fondatori, era student la Ivrea.
Numele "Arduino" provine de la un bar din Ivrea, locul unde o parte
din fondatori obișnuiau să se întâlnească.

Arduino include un microcontroler Atmel AVR de 8, 16 sau 32-biți cu

componente complementare care facilitează programarea și
încorporarea în alte circuite. Începând cu 2015 s-au folosit
microcontrolere și de la alți producători.

Un aspect important este acela că Arduino dispune de conectori

standard, care permit utilizatorului să conecteze plăcuța cu
procesorul la diferite module interschimbabile numite shield-uri.
Module Arduino

Nano Uno Mega

Nr. Caracteristici NANO UNO MEGA
Crt
1 Procesor Atemga 328P Atemga 328 Atemga 2560
2 Flash 32K 32K 256K
3 SRAM 2K 2k 8K

4 EEPROM 1K 1K 4K
5 Pini digitali I/O 14 14 54
6 Pini PWM 6 6 14
7 Pini Intrări 8 6 16
Analogice
8 Porturi 1 1 4
Comunicație

9 Clock 16MHz 16MHz 16MHz

10 Conector ICSP DA DA DA

11 USB DA DA DA
Arduino Uno – procesor ATMEGA328
Arduino Uno – Pini
Arduino Nano - procesor ATMEGA328P

Preț începând de la 16 lei

Arduino Mega- procesor ATMEGA2560
Programarea modulelor ARDUINO
Programele Arduino pot fi scrise în orice limbaj de programare cu
un compilator capabil să producă un cod mașină binar. Atmel
oferă un mediu de dezvoltare pentru microcontrolerele sale, AVR
Studio și mai nou, Atmel Studio.

Proiectul Arduino oferă un mediu integrat de dezvoltare (IDE),

care este o aplicație cross-platform, scrisă în Java. Este proiectat
pentru a facilita programarea modulelor Arduino și de cei
nefamiliarizați cu dezvoltarea software. Include un editor de cod
cu funcții ca evidențierea sintaxelor, potrivirea acoladelor și
spațierea automată dar oferă și mecanisme simple cu un singur
click, pentru a compila și a încărca programele în plăcuța Arduino.
Structura unui program
Un program tipic Arduino scris în C/C++ este compus din două
funcții care sunt compilate într-un program executabil cu o execuție
ciclică:

setup():
este o funcție care este rulată o singură
dată la începutul programului, când se
inițializează setările.

loop():
este o funcție apelată în mod repetat până la
oprirea alimentării cu energie a plăcuței.
Mediul de Programare IDE

https://www.arduino.cc/en/Main/Software
Tipuri de variabile
tip nume = valoare ;
int LED = 7;

https://www.arduino.cc/reference/en/#variables
Tipuri de funcții
Returnează valoarea logică a pinului:
digitalRead(pin)
HIGH (1) respectiv LOW (0)

Setează valoarea logică a pinului:

digitalWrite(pin, value) HIGH (1) respectiv LOW (0)

Returnează valoarea analogică a

analogRead(pin)
pinului în domeniul 0-1023
corespunzător unei tensiuni 0-5V

Setează o valoare analogică de

analogWrite(pin, value) tipul PWM a pinului în domeniul
0-255

https://www.arduino.cc/reference/en/#functions
Exemplu de aplicație

Limitatori Tije filetata

Motor DC

Sistem de comandă
cu Arduino NANO
Comada unui motor curent continuu

Curent
+ -
+ +

- -

- + Curent

Polarizare directă Polarizare inversă

Sensul orar Sensul antiorar
 +Vcc
Stabilire sens motor DC

Releu 1 + - Releu 2

+Vcc

Sens orar
Releu 1 + - Releu 2

Sens antiorar
 +Vcc Oprire motor

+ - Releu 2
Releu 1
+Vcc

Releu 1 + - Releu 2
Program aplicație – Definire variabile

int CMD_Releu_R = 4; // Definire pini de comanda

int CMD_Releu_L = 6; // pentru Relee

int Limitator_R =3; // Definire pini de intrare

int Limitator_L =2; // pentru limitatori

int Int_Referinta =A0; // Definire pini de intrare

// Valoare analogică

int Val_Ref=0;
int Contor=0;
int Sens_H =HIGH; // Definire variabile
int Sens_L =LOW;
Program aplicație – Funcția setup()

void setup()
{
pinMode (CMD_Releu_R, OUTPUT);
pinMode (CMD_Releu_L, OUTPUT);
digitalWrite (CMD_Releu_R, Releu_INV);
digitalWrite (CMD_Releu_L, Releu_INV);

pinMode (Limitator_R , INPUT_PULLUP);

pinMode (Limitator_L , INPUT_PULLUP);

}
Program aplicație – Funcția Loop

void loop()
{
if ( digitalRead(Limitator_R)==0 & digitalRead(Limitator_L)==1 )
{
digitalWrite(CMD_Releu_R,Sens_H);
digitalWrite(CMD_Releu_L, Sens_L);
goto FIN_Tst;
}

if ( digitalRead(Limitator_R)==1 & digitalRead(Limitator_L)==0 )

{
digitalWrite(CMD_Releu_R, Sens_L);
digitalWrite(CMD_Releu_L, Sens_H);
goto FIN_Tst;
}
Program aplicație – Funcția Loop

if ( digitalRead(Limitator_R)==0 & digitalRead(Limitator_L)==0 )

{
digitalWrite(CMD_Releu_R, Sens_L);
digitalWrite(CMD_Releu_L, Sens_L);
goto FIN_Tst;
}

if ( digitalRead(Limitator_R)==1 & digitalRead(Limitator_L)==1 )

{
goto FIN_Tst;
}

FIN_Tst:
Program aplicație – Funcția Loop

if ( Contor>= 10)
{
Val_Ref = analogRead(Int_Referinta);
Val_Ref = map(Val_Ref, 0, 1024, 0, 255);
Contor=0;
}
else
{
delay(10);
Contor = Contor + 1; // Contor++
}

} // void loop()
 Încărcare program

Încărcare
program
Vă mulțumesc