Sisteme Încorporate

Curs 8
Sisteme Încorporate
7. Sistemele Arduino

 Arduino este un sistem cu microcontroler (ATmega), simplu, extensibil și

open-source;
 Arduino este o familie în care se găsesc:
 Plăci de bază și plăci pentru o gamă largă de aplicații;
 O bibliotecă bogată;

 Tipuri de aplicații:
 Preluarea de informații de la senzori: de temperatură, umiditate, presiune,
sunet, gaz GPL, monoxid de carbon, nivel de alcool în aerul expirat, incendiu,
măsurare distanțe, detectare prezență, nivel de iluminare, accelerometru,
măsurare a consumului energetic etc.
 Comanda motoarelor și actuatoarelor: motoare de curent continuu, motoare
pas cu pas;
 Conectarea la Internet și comunicări prin: conexiune radio, plăci WiFi, module
GSM (pentru SMS, apeluri de voce, transfer în rețelele 3G, 4G), module
Bluetooth (pentru conectarea la telefoane mobile și laptop-uri);
 Afișarea pe: led-uri, module cu 7 segmente, LCD-uri alfanumerice și grafice;
Sisteme Încorporate
7.1. Plăci de bază Arduino
 Sisteme Încorporate

 Diferă prin:
 Microcontroler: 8, 16 sau 32 biți;
 Frecvență a tactului: 8, 16, 48 sau 84 MHz;
 Tensiune de alimentare nominală: 3,3 sau 5 V;
 Număr de pini de intrare/ieșire digitali;
 Număr de pini de intrare/ieșire analogici (PWM);
 Memorie internă;
 Interfețe și comunicare;
 Dimensiuni;
 Recomandări:
 Pentru aplicații simple: UNO;
 Monitorizarea și comanda mediului: Mega;
 Miniaturizare: Mini;
 Monitorizarea și comanda mediului + putere de calcul: Due;
 Pentru aplicații complexe: Yun;
Sisteme Încorporate

7.1.1. Placa Arduino UNO

 Sisteme Încorporate

 1 – conector USB: pentru programare și alimentare;

 2 – conector pentru alimentare AC;
 3 – stabilizator de tensiune;
 4 – oscilator;
 5, 17 – inițializare: asigurată fie prin comutatorul RESET (17) fie prin
terminalul RESET (5);
 6 – tensiune de ieșire, 3,3 V;
 7 – tensiune de ieșire, 5 V;
 8 – GND;
 9 – Vin: intrare pentru alimentare AC;
 10 – intrări analogice: 6 intrări, informația citită este convertită în digital;
 11 – microcontroler;
 12 – ICSP: conector pentru interfață SPI + Vcc și GND;
 Sisteme Încorporate

 13 – LED pentru indicarea alimentării;

 14 – LED-uri pentru interfața serială UART; indică transferul pe
terminalele Rx și Tx;
 15 – 14 terminale pentru intrări/ieșiri: atunci când sunt configurate ca
intrări sunt digitale iar când sunt configurate ca ieșiri sunt digitale și
analogice (cele indicate cu ~); ieșirile analogice generează format PWM;
 16 – AREF (Analog Reference): fixează o tensiune de referință între 0 și
5 V ca tensiune limită pentru conversia analog digitală;

 Alte caracteristici:
 Curent continuu la terminalul de 3,3 V: 50 mA;
 Curent continuu la terminalele de intrare/ieșire: 40 mA;
 Conectare la PC prin cablu USB A – B;
Sisteme Încorporate

7.1.2. Placa Arduino Due

Terminale:


 0 – 53: intrări/ieșiri digitale; 12 ieșiri pot fi configurate ca ieșiri PWM;

 A0 – A11: intrări analogice;
 DAC1, DAC2: ieșiri din convertorul analog/digital;
 L: LED conectat la pinul 13 (1 – aprins, 0 – stins);
Sisteme Încorporate

 TWI1: SDA și SCL (cu rezistențe interne);

 TWI2: SDA1 și SCL1 (fără rezistențe interne);
 CAN: CANRX și CANTX;
 Serial 0 – 3: 4 x Rx și 4 x Tx;
 SPI: conector pentru SPI;
 RESET;
 AREF;
 Vin, 5V și 3V3;
 Alte caracteristici:
 Curent continuu la terminalul 3V3: 800 mA;
 Curent continuu la terminalul 5V: 800 mA;
 Curent însumat la terminalele de I/E: 130 mA;
 2 porturi USB pentru programare;
 Port Native USB: poate fi port client USB și host USB;
 Conectare la PC prin cablu USB A – mini B.
Sisteme Încorporate

7.2. Software-ul plăcilor Arduino

7.2.1. Mediul de programare Arduino IDE
 Instalare a mediului de programare Arduino IDE
 Nu este necesară pentru Linux sau MAC;
 Pentru Windows:
 Driverele se descarcă de la adresa http://arduino.cc/en/Main/Software; se obține
o arhivă zip;
 Se dezarhivează, se conectează placa la portul USB și se furnizează PC-ului
driverele aferente;
 Device Manager va conține o intrare numită ”arduino”;
 Ghid: http://arduino.cc/en/Guide/Windows ;
 Programarea plăcii Arduino
 Se lansează programul ”arduino” din mediul descărcat;
 Se conectează placa la PC prin USB la un port serial; se determină portul;
 Se selectează tipul de placă;
 Se pot deschide programe existente sau se crează programe noi;
 Sisteme Încorporate

 Structura unui program Arduino:

 2 secțiuni:
 Setup: se execută o singură dată, la alimentarea plăcii sau după acționarea RESET;
inițializează variabilele, modul de lucru al terminalelor, pornește utilizarea
bibliotecilor;
 Void: se execută ciclic, cât timp placa este alimentată; este aplicația propriu – zisă;

void setup() {
//instrucțiuni care se execută o singură dată
}
void loop () {
//instrucțiuni care se execută repetitiv
}

 După compilare, programul este încărcat pe placa Arduino, prin portul USB;
Sisteme Încorporate

7.2.2. Funcții din biblioteca Arduino

7.2.2.1. Funcții de I/E
 pinMode (pin, Mode)
 Setează pinul pin ca INPUT, INPUT_PULLUP sau OUTPUT;
 INPUT_PULLUP înseamnă conectarea rezistenței interne între pin și
alimentare;
 digitalWrite (pin, value)
 Dacă pin a fost setat ca ieșire, value va fi HIGH (5V sau 3,3V, în funcție de
placă) sau LOW (0V);
 Dacă pin a fost setat ca intrare, HIGH va conecta rezistența internă de pull-up
iar LOW va deconecta această rezistență;
 analogRead (pin)
 Se referă la pinii la care se pot conecta tensiuni analogice (0-11 la Due), de
ex. ieșiri ale senzorilor;
 Returnează o valoare între 0 și 1023 care reprezintă o tensiune între 0 și 5V
(3,3V).
Sisteme Încorporate

7.2.2.2. Funcții pentru caractere

 int isdigit( int c )

 Returnează 1 dacă c este un digit și 0 în caz contrar;
 int isalpha( int c )
 Returnează 1 dacă c este o literă și 0 în caz contrar;
 int isupper( int c )
 Returnează 1 dacă c este o literă mare și 0 în caz contrar;
 int islower( int c )
 Returnează 1 dacă c este o literă mică și 0 în caz contrar;
 int iscntrl( int c )
 Returnează 1 dacă c este un caracter de control, ca newline ('\n'), form
feed ('\f'), carriage return ('\r'), horizontal tab ('\t'), vertical tab, ('\v'), alert
('\a'), backspace ('\b') și 0 în caz contrar.
Sisteme Încorporate

7.2.2.3. Funcții aritmetice

 M_E
 Constanta e; valoarea 2.7182818284590452354;
 double cbrt (double __x)
 Funcția cbrt() returnează rădăcina cubică a lui __x;
 double cos(double __x)
 Funcția cos() returnează cos __x;
 double exp (double __x)
 Funcția exp() returnează valoarea exponențială a lui __x;
 double log (double __x)
 Funcția log() returnează logaritmul natural al lui __x;
 double fma (double __x, double __y, double __z)
 Funcția fma() realizează operația multiply-add în virgulă flotantă; este
operația (__x *__y) + __z.
Sisteme Încorporate

7.2.3. Aplicații
 Comanda unui LED conectat la pinul 13:
 Programul aprinde LED-ul timp de 1 sec. și apoi îl stinge timp de 1 sec.

void setup () {
pinMode (13, OUTPUT);
}
void loop () {
digitalWrite (13, HIGH);
delay (1000);
digitalWrite (13, LOW);
delay (1000);
}
Sisteme Încorporate

 Comanda unui LED cu intensitate variabilă:

 Se consideră LED-ul conectat la pinul 9 care poate genera semnal PWM
void setup () {
pinMode (9, OUTPUT)
}
void loop () {
for (int i = 0, i < 255, i ++) {
analogWrite (9, i)
delay (200)
}
for (int i = 255, i < 0, i --) {
analogWrite (9, i)
delay (200)
}
}
Sisteme Încorporate
 Conectarea unui comutator
 Aprinderea unui LED la acționarea unui comutator pull-down
 Sisteme Încorporate

int stareCom = 0; //variabilă pentru citirea stării

comutatorului
void setup () {
pinMode (2, OUTPUT);
pinMode (8, INPUT);
}
void loop () {
stareCom = digitalRead (8); //se citește starea comutatorului
if (stareCom == HIGH); //dacă se apasă comutatorul
digitalWrite (2, HIGH); //se aprinde LED-ul
} else {
digitalWrite (2, LOW); //se stinge LED-ul
}
}
Sisteme Încorporate
 Citirea temperaturii
 Se folosește senzorul de temperatură LM35:
 Oferă o tensiune analogică proporțională liniar cu temperatura în grade C;
 Sisteme Încorporate

float temp;
int analogPin = 0;
void setup () {
Serial.begin (9600);
}
void loop () {
temp = analogRead (analogPin);//se citește tens. analogică
temp = temp * 0,48828125; //conversie în grade C
}

Serial.print (”TEMPERATURA = ”);

Serial.print (temp);//afișare a valorii temperaturii
Serial.print (”*C”);
Serial.println(); //se va tipări la rând nou
delay (1000); //temperatura se citește și afișează în fiecare sec.
}
Sisteme Încorporate
 Control al luminii ambientale
 Se citește nivelul luminii ambientale cu senzorul TEMT6000; dacă este
sub un anume nivel, se aprinde LED-ul conectat la pinul 13;
 Senzorul TEMT6000 funcționează conform schemei echivalente:
 Sisteme Încorporate

int temt6000Pin = A0; // pinul folosit pentru citirea nivelului luminii

float light;
int light_value;
void setup() {
Serial.begin(112500);
pinMode(temt6000Pin, INPUT);
pinMode(13, OUTPUT);
}
void loop() {
int light_value = analogRead(temt6000Pin);
light = light_value * 0.0976;// corecție
Serial.println(light);
delay(100);
if (light_value < 1000) {
digitalWrite(13, HIGH);
}
else {
digitalWrite(13,LOW);}
}
Sisteme Încorporate

 Alcoolmetru
 Se folosește o placă Arduino Leonardo, un senzor MQ-3, un LCD
alfanumeric și 3 led-uri (verde, galben și roșu) care se vor aprinde în
funcție de nivelul alcoolemiei; senzorul necesită o tensiune continuă de
5V care se obține de la un stabilizator extern;
 Schema și conexiunile:
Sisteme Încorporate

#include <LiquidCrystal.h> //biblioteca LCD

#define nivel1 40 //se definesc 3 constante de nivel
#define nivel2 60
#define nivel3 80
int analog_in = A0; //pinul la care este legat senzorul
int led_verde = 13; //pinii la care sunt conectate cele 3 led-uri
int led_galben = 12;
int led_rosu = 11;
int analog_reading = 0; //variabila ce va memora valoarea concentrației
int percent_reading = 0; //variabila pentru procentul de concentrație
LiquidCrystal lcd(7, 6, 5, 4, 3, 2); //inițializare LCD
void setup() {
pinMode(led_verde, OUTPUT);
pinMode(led_galben, OUTPUT);
pinMode(led_rosu, OUTPUT);
lcd.begin(16, 2); //setare LCD
lcd.print("Alcoolmetru"); //afișare pe LCD
delay(1000);
lcd.clear(); //ștergere LCD
lcd.setCursor(0,0);
lcd.print("Indicatie senzor"); //afișare pe LCD
}
 Sisteme Încorporate

void loop() {
lcd.setCursor(0,1); //poziționare cursor la linia 1, coloana 0
analog_reading = analogRead(analog_in); //citire de la senzor
lcd.print(analog_reading); //afișare valoare citită de la senzor
percent_reading=map(analog_reading, 0, 1023, 0, 100); //schimbare domeniu la 0-100
//aprindere led-uri în funcție de nivelul concentrației
if (percent_reading < nivel1){
digitalWrite(led_verde,HIGH);
digitalWrite(led_galben,LOW);
digitalWrite(led_rosu,LOW);
} else if (percent_reading < nivel2){
digitalWrite(led_verde,HIGH);
digitalWrite(led_galben,HIGH);
digitalWrite(led_rosu,LOW);
} else if (percent_reading < nivel3){
digitalWrite(led_verde,HIGH);
digitalWrite(led_galben,HIGH);
digitalWrite(led_rosu,HIGH);
}
}
Sisteme Încorporate

 Comunicare serială de tip UART

 Se folosesc funcții predefinite:
 Serial.begin(value): deschide canalul serial UART, rata de transfer va fi value bd;
 Serial.print(”msg”): afișează msg în continuarea a ceea ce era afișat;
 Serial.println(”msg”): afișează msg pe rând nou;
 Ex.:
void setup()
{
Serial.begin(9600);
Serial.println("hello world");
}
void loop()
{
}
Sisteme Încorporate

 Comunicare I2C
 Structura

 Pini:
 UNO: A4 – SDA, A5 – SCL;
 Due: 20 – SDA, 21 – SCL;
 Moduri de conectare/comunicare
 Master transmitter – Slave receiver;
 Master receiver – Slave transmitter;
 Sisteme Încorporate

 Master transmitter – Slave receiver

 Master transmitter: trebuie inclusă biblioteca Wire:

Wire.begin(address): master-ul stabilește adresa slave-ului care va fi partener;

Wire.beginTransmission(address): începe transmisia la slave-ul cu adresa fixată;
Wire.write(value): trimite octetul sau octeții la slave;
Wire.endTransmission(): încheie transmisia;
Sisteme Încorporate

#include <Wire.h> //include biblioteca Wire

int x = 0;
void setup() {
Wire.begin(); // conectare la I2C ca master
}
void loop() {
Wire.beginTransmission(2); // transmisie la slave-ul cu adresa 2
Wire.write(x); // trimite x
Wire.endTransmission(); // oprește transmisia
x++; // incrementează x
if (x > 5) x = 0; // anulează x atunci când ajunge la valoarea 6
delay(1000);
}
 Sisteme Încorporate

 Slave receiver: funcțiile sunt:

Wire.begin(address): address este adresa slave-ului care va comunica;
Wire.onReceive(received data handler): funcția este apelată atunci când slave-ul primește
date de la master;
Wire.available(): returnează nr. de octeți care sunt disponibili ptr. a fi preluați cu Wire.read;
funcția trebuie apelată în cadrul lui Wire.onReceive;

#include <Wire.h> //include biblioteca Wire

int LED = 13;
int x = 0;
void setup() {
pinMode (LED, OUTPUT); // setează pinul LED ca ieșire
Wire.begin(); // conectare la I2C ca slave, cu adresa 2
Wire.onReceive(receiveEvent); //se atașează funcția apelată la recepție
}
void receiveEvent(int bytes) {
x = Wire.read(); // citește un caracter dela master
}
Sisteme Încorporate

void loop() {
//dacă valoarea citită este 0 aprinde LED timp de 500 ms
if (x == '0') {
digitalWrite(LED, HIGH);
delay(500);
digitalWrite(LED, LOW);
delay(500);
}
// dacă valoarea citită este 3 aprinde LED timp de 1s
if (x == '3') {
digitalWrite(LED, HIGH);
delay(1000);
digitalWrite(LED, LOW);
delay(1000);
}
}
 Sisteme Încorporate

 Master receiver – Slave transmitter

 Master receiver: master-ul cere și apoi citește datele trimise de slave;
Wire.request(address, number of bytes): address este adresa slave-ului iar number
of bytes este nr. de octeți trimiși de slave; octeții vor fi preluați cu funcțiile
wire.available() și wire.read();
#include <Wire.h>

void setup() {
  Wire.begin();        // conectare la I2C ca master
  Serial.begin(9600);  // deschide canalul serial UART
}

void loop() {
  Wire.requestFrom(2, 2);    // cere 2 octeți de la slave-ul cu adresa 2
  while (Wire.available()) {
    char c = Wire.read(); // citește un octet ca un caracter
    Serial.print(c);         // afișează caracterul
  }
  delay(500);
}
 Sisteme Încorporate

 Slave transmitter
Wire.onRequest(handler): se apelează o funcție atunci când master-ul cere date de la
slave;
#include <Wire.h>

void setup() {
  Wire.begin(2); // conectare la I2C ca slave cu adresa 2
  Wire.onRequest(requestEvent); // atunci când master-ul cere date se
va apela funcția requestEvent
}

void loop() {
  delay(100);
}

// funcția care va fi apelată atunci când master-ul va cere date

void requestEvent() {
  Wire.write("20"); // se trimit cei 2 octeți ceruți de master
}