smi_lab3

Laborator Sisteme cu Microprocesoare Integrate Departamentul de Automatică și Informatică Industrială

1

Lucrare 3 – Utilizarea pinilor I/O

Conținutul lucrării pe scurt:

Prezentarea componentelor software de comandă a pinilor I/O

Prezentarea modulului de interconectarea a unui led la placa Arduino Uno

Exemplu de joc de lumini

Echipamente necesare lucrării:

Placă de dezvoltare Arduino Uno sau compatibilă

Cablu de conectare USB

Breadboard + fire de interconectare

8 leduri + 8 rezistori 220ohm

1 shift-register pe 8 biți (74HC595 sau TPIC6B595)

Secțiuni lucrare:

Configurația internă a pinilor I/O

Utilizarea software a pinilor I/O

Conectarea unu led la un pin I/O

Proiect joc de lumini (conectare individuală)

Proiect joc de lumini (shift-register)

Utilizarea pinilor I/O pentru comandă analogică

Proiect joc de lumini (comandă analogică)

Referințe online


2

Configuraţia internă a pinilor I/O

Caracteristicile electrice și logice ale pinilor plăcii de dezvoltare Arduino Uno sunt preluate de la

microcontrolerul ATmega 328P cu care este echipată placa. Pinii microcontrolerului sunt

conectați direct la conectorii plăcii fără alte circuite auxiliare intercalate. Diagrama de mai jos

prezintă corespondența între pinii microcontrolerului și pinii conectorilor de placa de

dezvoltare.

Pinii plăcii de dezvoltare Arduino pot fi configurați sau ca intrări sau ca ieșiri. Mai jos este

prezentată structura internă electrică a unui pin a microcontrolerului ATmega328P. Implicit

pinii sunt configurați ca intrări deci doar în momentul în care sunt folosiți ca ieșiri trebui

configurați în mod expres. Din punct de vedere extern pinii se află implicit într-o stare de

impedanță mare nefiind vizibili ca ieșiri.


3

Utilizarea software a pinilor I/O

Mediul Arduino IDE pune la dispoziție trei funcții pentru manipularea pinilor I/O generici:

pinMode(pin, mode) – setează comportamentul unui anumit pin. Argumentul pin

specifică numărul pinului care se configurează iar argumentul mode poate avea valorile INPUT,

OUTPUT sau INPUT_PULLUP. Valoarea INPUT_PULLUP specifică faptul că se activează o

rezistență internă de pull-up cu toate că pinul este de intrare – pinul nu va fi vizibil ca ”1” logic

extern. Această funcție împreună cu funcția digitalWrite() au fost folosite în lucrarea 1 în

exemplul de program Blink pentru a aprinde led-ul aflat pe placa de dezvoltare conectat la pinul

13.

digitalWrite(pin, valoare) – setează pinul pin pe nivel logic ”0” sau ”1” în funcție

de parametrul valoare (HIGH sau LOW).

digitalRead (pin) – returnează starea pinului pin: LOW sau HIGH.

Pinii digitali ai plăcii de dezvoltare pot fi utilizați și pentru a genera forme de undă:

tone(pin, frequency, duration) – este o funcție care generează pe pinul pin o

formă de undă dreptunghiulară de frecvență frequency și de durată duration. Este utilă în

cazul în care se dorește comanda unui buzzer pentru generarea de frecvențe sonore diverse.

Această funcție va fi folosită în lucrările viitoare. Poate fi utilizată doar pe câte un pin.

notone(pin) – oprește generarea formei de undă dreptunghiulare pe pinul pin.

Mediul de programare IDE Arduino mai pune la dispoziție și alte funcții avansate I/O printre

care și funcții de transmisie serială sincronă:

shiftOut(dataPin, clockPin, bitOrder, value) – transmite câte un bit din

numărul value pe pinul dataPin sincronizat cu pinul clockPin în ordinea bitOrder

(MSBFIRST sau LSBFIRST). Această funcție este o implementare software de transmisie

serială sincronă. Funcția transmite doar un octet la fiecare apel. Pentru a transmite structuri de

date mai mari se apelează în mod repetat în conjuncție cu deplasări adecvate. Această funcție

va fi folosită în lucrare curentă pentru încărcarea stării ledurilor într-un registru cu shiftare (al

doilea exemplu al lucrării).

byte incoming = shiftIn(dataPin, clockPin, bitOrder) – încarcă în

variabila pe 8 biți incoming un octet primit serial.


4

pulseIn(pin, value, timeout) – returnează durată în microsecunde a unui puls

primit pe pinul pin având valoare value (HIGH sau LOW). Variabila timeout este opțională

(implicit o secundă) și indică timpul de așteptare pentru începerea pulsului în microsecunde.

Conectarea unui led la un pin I/O

Una dintre cele mai simple modalități de utilizare a unui pin I/O este comanda unui element de tip LED. Comanda de aprindere se poate da atât pe LOW cât și pe HIGH. Pinul microcontrolerului va suplini sursa sau masa în funcție de comanda aleasă. Pentru a putea aprinde un led este necesară inserarea unui rezistor pentru limitarea curentului.

În ambele cazuri de comandă nu există probleme la resetul hardware deoarece starea inițială a

pinilor este de impedanță mărită. Dacă se alege comanda pe HIGH (a unui led sau a unui alt

consumator) trebuie avut în vedere faptul că pinii microcontrolerului ATmega 328P (și implicit

ai plăcii Arduino) pot debita un curent de maxim 40mA dar nu mai mult de 200mA per

ansamblu (nu puteți utiliza toți pinii la un curent debitat de 40mA simultan). Depășirea

curentului maxim debitat va conduce la arderea pinilor I/O ai microcontrolerului.

Calculularea valorii rezistorului se face în funcție de parametrii electrici ai ledului: curentul de

aprindere și tensiunea de alimentare. Inserarea unui rezistor mai mare va scădea intensitatea

de aprindere a ledului, inserarea unui rezistor mai mic va forța ledul la intensitate maximă

scăzându-i durata de viață. Un calculator automat pentru alimentarea unui led sau a unei

matrice de leduri se găsește la adresa [1].

Citirea valorii unui rezistor se face pe baza codului de bare colorate înscrise pe rezistor. Benzile

1, 2 și 3 (numai în cazul codului cu 5 bare) reprezintă cele mai reprezentative cifre ale valorii,

banda 3 multiplicatorul valorii și banda 4 toleranța. Mai jos avem un tabel cu codul culorilor

pentru rezistori.


5

Culoare Banda 1 Banda 2 Banda 3 Banda 4 (toleranță)

Negru 0 0 X 1 Maro 1 1 X 10

Roșu 2 2 X 100

Portocaliu 3 3 X 1,000 Galben 4 4 X 10,000

Verde 5 5 X 100,000 Albastru 6 6 X 10^6

Violet 7 7 X 10^7

Gri 8 8 X 10^8 Alb 9 9 X 10^9

Auriu X 0.1 5% Argintiu X 0.01 10%

Fără culoare 20%


6

Proiect joc de lumini (conectare individuală)

Presupunem următoarea schemă de interconectare a 8 leduri cu placa de dezvoltare Arduino

Uno în mod individual – fiecare led este comandat în mod direct de câte un pin al plăcii de

dezvoltare (led 1 – pin 2, led 2 – pin 3…. led 8 – pin 9):

Dorim să implementăm un joc de lumini cu patru tipare de aprindere. Selectarea tiparului de aprindere se va face de către utilizator prin intermediul unui meniu implementat peste comunicație serială. Jocul 1 va aprinde cele opt leduri în mod intermitent intercalat patru câte patru.


7

Jocul 2 va aprinde ledurile pe rând și apoi le va stinge pe rând (ca un efect de umplere și golire).

Jocul 3 va muta un led aprins de pe poziția 1 până pe poziția a 8-a iar jocul 4 va aprinde și va

stinge ledurile în mod aleatoriu.

Funcția setup() a programului va trebui să configureze toți cei opt pini utilizați ca fiind pini de

ieșire și să seteze viteza de comunicație serială.

void setup() {

pinMode(2, OUTPUT);

pinMode(3, OUTPUT);

pinMode(4, OUTPUT);

pinMode(5, OUTPUT);

pinMode(6, OUTPUT);

pinMode(7, OUTPUT);

pinMode(8, OUTPUT);

pinMode(9, OUTPUT);

Serial.begin(9600);

}

Funcția principală loop() va prelua prin comunicație serială selecția efectuată de utilizator

(un întreg între 1 și 4) și va rula la infinit jocul de lumini ales prin apelarea funcției

corespondente. Reluarea alegerii jocului de lumini se poate face doar prin resetare hardware a

plăcii care va conduce la reinițializarea programului.

void loop() {

int alege = 0;

Serial.println("Joc de lumini");

Serial.println("Alegeti varianta de joc (1-4)");

while (alege<'1' || alege>'4') {

alege = Serial.read();

delay(1000);

}

alege = alege - 48;

Serial.print("Ati ales jocul: ");

Serial.print(alege,DEC);

Serial.println();

Serial.println("Pentru reinitializare apasati butonul Reset al

placii");

switch (alege) {

case 1:

joc1();

case 2:

joc2();


8

case 3:

joc3();

case 4:

joc4();

}

}

Jocul 1 de lumini va aprinde alternativ la un interval de 1 secundă ledurile de rang impar și

ledurile de rang par (led 1, led 3, led 5, led 7 – led 2, led 4, led 6, led 8).

void joc1() {

while (1) {

for (int i=2; i<10; i++) {

if ((i%2)==0) digitalWrite(i,HIGH);

else digitalWrite(i,LOW);

}

delay(1000);

for (int i=2; i<10; i++) {

if ((i%2)==0) digitalWrite(i,LOW);

else digitalWrite(i,HIGH);

}

delay(1000);

}

}

Jocul 2 de lumini va aprinde unul câte unul (pornind de la led-ul 1 până la led-ul 8) toate led-

urile și apoi le va stinge în mod similar (în ordine inversă). Operația de aprindere sau stingere a

unui led se va efectua la un interval de 500 milisecunde.

void joc2() {

while (1) {

for (int i=2;i<10;i++) {

digitalWrite(i,HIGH);

delay(500); }

for (int i=9;i>1;i--) {

digitalWrite(i,LOW);

delay(500);

}

}

}


9

Jocul 3 de lumini va aprinde câte un led pornind de la poziția 1 până la poziția 8. Mutarea led-

ului aprins de pe o poziție pe alta se va face la un interval de 100 milisecunde.

void joc3() {

while (1) {

for (int i=2;i<10;i++) {

for (int j=2;j<10;j++) {

if (j==i) {

digitalWrite(i,HIGH);

}

else {

digitalWrite(j,LOW);

}

delay(100);

}

delay(100);

}

}

}

Jocul 4 de lumini va aprinde sau va stinge total aleatoriu câte un led la un interval de 100

milisecunde.

void joc4() {

int pozitie;

int aprins;

while (1) {

pozitie = random(2,10);

aprins = random(0,2);

digitalWrite(pozitie,aprins);

delay(100);

}

}


10

Proiect joc de lumini (conectare prin intermediul shift-register)

Cel de al doilea exemplu de interconectare utilizează un registru de shiftare pe 8 biți care va fi

utilizat ca un registru cu încărcare serială. Astfel liniile de comandă a ansamblului de 8 leduri va

fi redus de la 8 la 3. Comanda de aprindere a ledurilor nu va mai fi dată de pinii plăcii de

dezvoltare ci de liniile de ieșire a registrului de shiftare.

Ca registru de shiftare vom utiliza un circuit 74HC595. Liniile de ieșire a circuitului care vor comanda cele 8 leduri sunt prezente pe pinii 15, 1, 2, 3, 4, 5, 6 și 7 ai circuitului (Q0-Q7). Pinii 8 și 16 ai circuitului vor trebui conectați la +5V li la masă (Vcc și GND). Pinul 9 este semnalul de transport utilizat în cazul unei încascadări și nu va fi conectat în cazul montajului nostru. Pinul 14 (DS – serial data input) este linia de încărcare a registrului și în cazul nostru va fi conectat la pinul 2 al plăcii de dezvoltare (dataPin). Pinul 13 (/OE – Output Enable) va fi conetat la masă (activat întotdeauna). Pinii 11 și 12 (SHCP shift register clock input, STCP storage register clock input) vor fi conectați la pinii 3 și 4 ai plăcii Arduino

74HC595 [3]

pentru generarea semnalului de ceas (clockPin) și a comenzii de încărcare (latchPin). Pinul 10 (/MR – Master Reset) va fi conectat la Vcc (inactiv). [2] Un circuit echivalent este circuitul TPIC6B595. Echivalențele de pini se observă imediat: DRAINx – Qx (linii de comandă pentru leduri), SER IN – DS (dataPin), SER OUT – Q7S (neconectat), , SRCK – SHCP (clockPin), RCK – STCP (latchPin) /SRCLR - /MR (inactiv – conectat la Vcc), /G - /OE (activat întotdeana – la masă). Pinii NC ai acestui circuit nu sunt conectați intern. Există două diferențe majore între 74HC595 și TPIC6B595: comanda de aprindere la 74HC595 se dă pe ”1” logic iar la TPIC6B595 pe ”0” logic (în schema cu TPIC6B595 se va conecta catodul ledului la pinul de comandă); circuitul TPIC6B595 are o putere mai mare de comandă (150mA/pin) față de 74HC595 (35mA/pin).

TPIC6B595 [4]


11

Schemă de interconectare bazată pe 74HC595


12

Schemă de interconectare bazată pe TPIC6B595


13

Programul va conține definirea celor trei pini de comandă și comunicație pentru registrul de

shiftare:

const int latchPin = 4;

const int clockPin = 3;

const int dataPin = 2;

Funcția de inițializare va configura cei trei pini ca ieșiri, va seta viteza de comunicație serială și

va inițializa conținutul registrului cu 0.

void setup() {

pinMode(latchPin, OUTPUT);

pinMode(dataPin, OUTPUT);

pinMode(clockPin, OUTPUT);

Serial.begin(9600);

digitalWrite(latchPin, LOW);

shiftOut(dataPin, clockPin, MSBFIRST, 0);

digitalWrite(latchPin, HIGH);

}

Funcția principală nu trebuie modificată față de exemplul precedent (conectare individuală) dar

partea de comandă efectivă a ledurilor trebuie adaptată transmiterii prin registrul de shiftare.

Funcția pentru joc 1 de lumini va arăta în felul următor:

void joc1() {

while (1) {




delay(1000);




delay(1000);

}

}

Valorile transmise către registru sunt echivalente cu starea dorită a celor 8 leduri (170 în binar

10101010 – aprins/stins/aprins/stins/aprins/stins/aprins/stins iar 85 în binar 01010101). Pentru

încărcarea în registru a valorilor se dezactivează semnalul de latchPin după care se utilizează

funcția shiftOut pentru a transmite valoarea dorită. Activarea semnalului de latchPin


14

conduce la memorarea și transmiterea la ieșiri a valorii transmise serial. În mod similar se pot

rescrie și celelalte trei funcții (joc2, joc3, joc4):

void joc2() {

int afisare = 0;

while (1) {

for (int i=0;i<9;i++) {

afisare = afisare + (1<<i);


shiftOut(dataPin, clockPin, MSBFIRST, afisare);


delay(500);

}

for (int i=8;i>-1;i--) {

afisare = afisare - (1<<i);


shiftOut(dataPin, clockPin, MSBFIRST, afisare);


delay(500);

}

}

}

void joc3() {

int afisare = 1;

while (1) {

for (int i=0;i<8;i++) {


shiftOut(dataPin, clockPin, MSBFIRST, afisare << i);


delay(500); }

}

}

void joc4() {

int configuratie;

while (1) {

configuratie = random(0,256);


shiftOut(dataPin, clockPin, MSBFIRST, configuratie);


delay(100); }

}


15

Utilizarea pinilor I/O pentru comandă analogică

Placa Arduino Uno (versiunea R3, dar si cele precedente) nu detine ca și componentă

hardware internă un convertor digital analogic (CNA) astfel nu este posibilă transformarea unei

valori digitale într-o valoare analogică – nu putem comanda, de exemplu, intensitatea de

aprindere a unui led din program. Alte modele, Arduino Mega sau Arduino Due, dețin CNA

integrat și permit comanda analogică direct pe anumiți pini ai plăcii de dezvoltare.

Una din posibilitățile de a ”mima” o comandă analogică utilizând placa de dezvoltare Arduino

Uno este utilizarea pinilor care permit generarea semnalelor PWM (mai multe despre comanda

de tip PWM se regăsesc în lucrarea 10): pinii 3, 5, 6, 9, 10 și 11 ai plăcii. Semnalul PWM permite

generarea unui tren de impulsuri 0 / 1 logic care prin variația factorului de umplere (duty cycle

– durata semnalului de 1 logic) conduce la generarea unui semnal similar cu cel analogic din

punct de vedere al consumatorului (generează o cantitate de energie electrică echivalentă cu

semnalul analogic dorit – o exemplificare a echivalenței semnal PWM – semnal analogic se

poate vedea în imaginea următoare). O detaliere a utilizării semnalului PWM la placa de

dezvoltare Arduino este disponibilă la adresa [5].


16

Pentru generarea unui semnal de tip PWM pe pinii plăcii de dezvoltare Arduino se poate utiliza

comanda analogWrite(pin, valoare) unde pin poate lua valoarea 3, 5, 6, 9, 10 sau

11 iar valoare este un întreg între 0 și 255 (0 corespunde unei tensiuni echivalente de 0V iar

255 unei tensiuni echivalente de 5V – rezoluția de variație este de aproximativ 0.0196 V).

Pentru folosirea acestei funcții pinul utilizat trebuie configurat ca pin de ieșire –

pinMode(pin, OUTPUT).

Generarea semnalului PWM se bazează pe utilizarea timer-elor interne ale plăcii Arduino (instrumente care permit măsurarea intervalelor de timp), din acest motiv utilizarea simultană a timer-elor (sau a altor instrumente care își bazează funcționarea pe timer-e) și a comenzii PWM nu este întotdeauna posibilă. Legătura dintre cei șase pini generatori de semnal PWM și cele trei timer-e interne este următoarea: pinii 5 și 6 generează semnal PWM bazându-se pe timer-

ul 0, pinii 9 și 10 pe timer-ul 1 și pinii 11 și 3 pe timer-ul 2. De exemplu, instrucțiunile delay și milis (funcții care permit introducerea de întârzieri în mediul IDE Arduino) utilizează timer-ul intern 0 – nu pot fi utilizate dacă dorim să generăm comandă de tip PWM pe pinii 5 sau 6.

Proiect joc de lumini (comandă analogică)

Putem utiliza comanda de tip PWM pentru a crea un joc de lumini în care să implicăm și efecte

de aprindere / stingere treptată a ledurilor (fade in / fade aut). Din cauza limitării numărului de

pini pe care putem genera comanda PWM nu putem utiliza opt leduri, ca în exemplele

precedente, ci doar șase. Ledurile vor fi conectate la pinii care permit generarea comenzii

PWM: 3, 5, 6, 9, 10 și 11 (schemă de interconectare prezentată mai jos). Interconectarea

ledurilor cu placa de dezvoltare Arduino se va face în mod direct, nu mai există posibilitatea

utilizării unui shift-register care ar altera comanda de tip PWM transmisă de placa de

dezvoltare.

Vom modifica cele patru jocuri de lumini prezentate anterior astfel încât toate operațiile de

aprindere / stingere a ledurilor să se facă în mod treptat (fade in / fade out). Cele patru funcții

definite anterior vor suferi următoarele modificări:

Având în vedere faptul că pinii utilizați nu au identificatori ”la rând” se va utiliza un

vector care va stoca numărul pinilor care sunt utilizați în program permițând astfel o

accesare facilă:

int leds [] = {3, 5, 6, 9, 10, 11};

astfel inițializarea pinilor va avea forma:


17

pinMode(leds[0], OUTPUT);






Funcția delay(milisecunde) va fi înlocuită cu funcția

_delay_ms(milisecunde) pentru a evita blocarea programului (funcția delay nu

poate fi folosită împreună cu generarea de semnal PWM pe pinii 5 sau 6). Funcția

_delay_ms necesită includerea header-ului <util/delay.h>.

Comanda de aprindere / stingere a unui led: digitalWrite(pin, LOW / HIGH) va fi înlocuită

de o construcție care să implementeze efectele de fade in / fade out:

o fade in: for (int j=0; j<250; j+=20)

{ analogWrite(leds[i],j); _delay_ms(50); }

o fade out: for (int j=240; j>-1; j-=20)


Forma finală a celor patru funcții de jocuri de lumini va fi următoarea:

void joc1() {

while (1) {

for (int i=0; i<6; i+=2)

for (int j=0; j<250; j+=20)


_delay_ms(1000);

for (int i=0; i<6; i+=2)

for (int j=240; j>-1; j-=20)


_delay_ms(1000);

for (int i=1; i<6; i+=2)

for (int j=0; j<250; j+=20)


_delay_ms(1000);

for (int i=1; i<6; i+=2)


18

for (int j=240; j>-1; j-=20)


_delay_ms(1000); }

}

void joc2() {

while (1) {

for (int i=0;i<6;i++) {

for (int j=0; j<250; j+=20)


_delay_ms(500); }

for (int i=5;i>-1;i--) {

for (int j=240; j>-1; j-=20)


_delay_ms(500); }

}

}

void joc3() {

while (1) {

for (int i=0;i<6;i++) {

for (int j=0; j<250; j+=20)

{ analogWrite(leds[i],j); _delay_ms(50);};

for (int j=240; j>-1; j-=20)

{ analogWrite(leds[i],j); _delay_ms(50); };

}

_delay_ms(100); }

}

void joc4() {

int pozitie;

int aprins;

while (1) {

pozitie = random(0,6);

aprins = random(0,2);

if (aprins==0)

{ for (int j=0; j<250; j+=20)

{ analogWrite(leds[pozitie],j); _delay_ms(50); }; }

else

{ for (int j=240; j>-1; j-=20)

{ analogWrite(leds[pozitie],j); _delay_ms(50); }; }

_delay_ms(100); }

}


19

Schemă de interconectare individuală pe pinii PWM


20

Referințe online

[1] LED series/parallel array wizard http://led.linear1.org/led.wiz

[2] Serial to Parallel Shifting-Out with a 74HC595 http://arduino.cc/en/Tutorial/ShiftOut

[3] 74HC595 8-bit serial-in, serial or parallel-out shift register with output latches

http://www.nxp.com/documents/data_sheet/74HC_HCT595.pdf

[4] TPIC6B595 POWER LOGIC 8-BIT SHIFT REGISTER

http://www.datasheetcatalog.org/datasheet/texasinstruments/tpic6b595.pdf

[5] Secrets of Arduino PWM http://arduino.cc/en/Tutorial/SecretsOfArduinoPWM

smi_lab3

Documents