Bolg -Arduino – Folosire afișaj 7-segmente

Arduino – Folosire afișaj 7-segmente

Postat de pe data de 16 martie 2020 in categoria Arduino

image_pdfimage_print

Aceste afișaje sunt formate din 7 leduri ( de unde și denumirea ) aranjate într-o formă rectangulară.

Fiecare din cele 7 leduri este numit segment și are următoarea notație : de la ”a” la ”g” și punctul notat cu ”dp”.

Prin combinații de conectare ale segmentelor se formează cele zece numere: de la 0 la 9 dar și litere de la ”A” la ”F”.

Afișajele 7-segmente se construiesc în două variante:

– cu anodul comun

– cu catodul comun

La varianta cu anodul comun : anodul se conectează la polul pozitiv al sursei (+) iar segmentul care se vrea activat se conectează la polul negativ al sursei ( – ) sau aplicând ”0” logic ori ”LOW”.

La varianta cu catodul comun: catodul se conectează la polul negativ la sursei ( – ) iar segmentul care se vrea activat se conectează la polul pozitiv al sursei ( + ) sau aplicând ”1” logic sau ”HIGH”.

Un afișaj 7-segmente standard are 7 leduri + 1 led ce reprezintă un punct notat cu ”dp” folosit de obicei pentru a afișa valori cu virgulă ( ex: 7.9 ), binențeles folosind 2 afișaje 7-segmente.

În imaginea următoare se văd ce segmente trebuie să activați pentru a afișa numerele de la 0 la 9, pentru litere este asemănător:

La conectarea într-un circuit a afișajelor 7-segmente trebuie să fim atenți să înseriem câte un rezistor la fiecare segment deoarece segmentul este un LED și trebuie protejat la supracurent. De obicei fiecărui segment îi trebuie cam 15mA pentru a lumina corect și o tensiune de 2.2 – 3.6V acestea depinzând de culoarea segmentelor.

Conform figurii de mai sus putem spune:

  • vrem să afișăm cifra 4 pe afișaj ——- activăm switch-urile ( întrerupătoarele) b, c, f și g.
  • vrem să afișăm cifra 7 pe afișaj ——– activăm switch-urile ( întrerupătoarele ) a, b și c.

Am spus mai sus că fiecare segment ( LED ) are nevoie de un curent minim de 15mA ( poate chiar 20mA în funcție de culoare ) ceea ce înseamnă că tot afișajul va avea nevoie de 120mA pentru a funcționa ( ( 7 segmente + 1 punct ) X 15mA = 120mA ), iar pentru al conecta vom avea nevoie de 7 conexiuni pentru segmente, 1 conexiune pentru punct ( ”dp” ) , o conexiune pentru anod sau catod comun. Din acest motiv, multe conexiuni + puterea consumată, va fi impractic utilizarea acestor afișaje în unele circuite electronice sau cu microcontroller. De aceea vom utiliza un decodor BCD ( Binary Code Decimal ) sau vom folosi tranzistoare bipolare.

Decodoarele BCD au 4 intrări ( notate A, B, C, D ) și 7 ieșiri ( câte o ieșire pentru fiecare segment ). Acestea permit unui număr binar de 4 biți să fie utilizat pentru afișarea numerelor de la 0 la 9. Pentru a afișa numere din 2 cifre vom folosi 2 afișaje 7-segmente, pentru a afișa 3 numere folosim 3 afișaje 7-segmente, etc…. .

Exemplu de folosire a decodorului BCD :

În exemplul de mai sus avem la intrare 0100 cea ce va face ca pe afișaj să apara cifra 4 :

În practică vom folosi rezistoare de 150 – 220 \(\Omega \) pentru fiecare segment, conectate în serie cu decodorul BCD pentru a limita curentul.

Pe piață găsim o mulțime de circuite integrate decodoare BCD pentru afișaje 7-segmente cu anor comun ( 74LS47 ) și catod comun ( 74LS48 ) sau găsim module gata făcute câte 2, 3, 4 afișaje 7-segmente unite deja între ele.

După cum am spus mai sus, în loc de a folosi 8 pini am ajuns să folosim 4 pini pentru a controla un afișaj 7-segmente, dar totuși pe piață există module a câte 4 afișaje 7-segmente care folosesc doar 2 pini pentru a fi controlate. Acestea sunt folosite în circuite electronice cu microcontroller iar comunicarea se face prin 2 fire și anume : SDA ( SerialData ) și SCL ( SerialClock ) sau prin interfața serială I2C ( Inter-Integrated Circuits ).

I2C = o interfață serială sincronă, cu viteză mică de transfer care permite conectarea unuia sau mai multor controllere cu echipamente periferice.

În continuare vom exemplifica ceea ce am scris mai sus prin aplicații simple folosind placa Arduino.

Controlul Afișajului 7-segmente folosind tranzistoare și Arduino

Schema folosită :

În acest exemplu vom afișa aleator numerele de la 0 la 9 pe un afișaj 7-segmente.

Partea software:

int segmentPin[] = {13, 12, 11, 10, 9, 8, 7, 6};
int anodComun = 5;
byte numere[10][8] = {
// a b c d e f g .
{ 1, 1, 1, 1, 1, 1, 0, 0}, // segmenti necesari pentru numarul 0
{ 0, 1, 1, 0, 0, 0, 0, 0}, // segmenti necesari pentru numarul 1
{ 1, 1, 0, 1, 1, 0, 1, 0}, // segmenti necesari pentru numarul 2
{ 1, 1, 1, 1, 0, 0, 1, 0}, // segmenti necesari pentru numarul 3
{ 0, 1, 1, 0, 0, 1, 1, 0}, // segmenti necesari pentru numarul 4
{ 1, 0, 1, 1, 0, 1, 1, 0}, // segmenti necesari pentru numarul 5
{ 1, 0, 1, 1, 1, 1, 1, 0}, // segmenti necesari pentru numarul 6
{ 1, 1, 1, 0, 0, 0, 0, 0}, // segmenti necesari pentru numarul 7
{ 1, 1, 1, 1, 1, 1, 1, 0}, // segmenti necesari pentru numarul 8
{ 1, 1, 1, 1, 0, 1, 1, 0} // segmenti necesari pentru numarul 9
};
void setup()
{
for (int i=0; i < 8; i++)
{
pinMode(segmentPin[i], OUTPUT);
}
pinMode(anodComun, OUTPUT);

}
void loop()
{
static int nr;

nr = random(10);

digitalWrite(anodComun, HIGH);

for (int i=0; i < 8; i++)
{
digitalWrite(segmentPin[i], ! numere[nr][i]);
}
delay(5000);
}

Explicații:

int segmentPin[] = {13, 12, 11, 10, 9, 8, 7, 6}; ——-am folosit un vector pentru a memora pinii la care sunt conectați segmenții afișajului.

int anodComun = 5; —– am declarat pinul anod comun al afișajului ca fiind conectat la pinul digital 5 al plăcii arduino mega. Pentru afișaj în conexiune catod comun vom avea: int catodComun = 5 ;

byte numere[10][8] = {
// a b c d e f g .
{ 1, 1, 1, 1, 1, 1, 0, 0}, // segmenti necesari pentru numarul 0
{ 0, 1, 1, 0, 0, 0, 0, 0}, // segmenti necesari pentru numarul 1
{ 1, 1, 0, 1, 1, 0, 1, 0}, // segmenti necesari pentru numarul 2
{ 1, 1, 1, 1, 0, 0, 1, 0}, // segmenti necesari pentru numarul 3
{ 0, 1, 1, 0, 0, 1, 1, 0}, // segmenti necesari pentru numarul 4
{ 1, 0, 1, 1, 0, 1, 1, 0}, // segmenti necesari pentru numarul 5
{ 1, 0, 1, 1, 1, 1, 1, 0}, // segmenti necesari pentru numarul 6
{ 1, 1, 1, 0, 0, 0, 0, 0}, // segmenti necesari pentru numarul 7
{ 1, 1, 1, 1, 1, 1, 1, 0}, // segmenti necesari pentru numarul 8
{ 1, 1, 1, 1, 0, 1, 1, 0} // segmenti necesari pentru numarul 9
};
— am folosit această matrice pentru a știi ce segmente ale afișajului trebuie activate pentru a afișa numărul.

Ex: pentru a afișa numărul 2 vom accesa matricea la linia 2 iar cu ajutorul instrucțiunii for ne vom plimba pe fiecare coloană și vom trimite către pinii plăcii arduino stările segmentelor pentru a afișa 2.

random(10); ——- generează aleator un număr de la 0 la 9, iar nr — variabila în care memorăm numărul generat.

digitalWrite(anodComun, HIGH); — punem in starea 1 pinul la care este conectat catodul comun al afișajului.Pentru afișaj în conexiune catod comun vom avea: digitalWrite(catodComun, LOW);

for (int i=0; i < 8; i++)
{
digitalWrite(segmentPin[i], ! numere[nr][i]);
}
—– cu ajutorul instrucțiunii for vom accesa matricea noastră și vom trimite valorile din matrice ( de la poziția corespunzătoare numarului nostru ) către cei 8 pini ai la care este conectat afișajul. Ex: dacă considerăm numarul generat ca fiind 8 vom avea următoarele iterații din partea instrucțiunii noastre :

  •  i=0 ⇒ segmentPin[0]=13
  • numere[8][0] =1,  aceasta înseamnă ca la pinul 13 vom transmite 1 logic.
  • i=1 ⇒ segmentPin[1]=12
  • numere[8][1]=1, aceasta înseamnă ca la pinul 12 vom transmite 1 logic.
  • i=2 ⇒ segmentPin[2]=11
  • numere[13][2]=1, aceasta înseamnă ca la pinul 11 vom transmite 1 logic.
  • ……….
  • ………
  • până când i=7.

! numere[nr][i] —— am folosit semnul ! deoarece afișajul este în anod comun iar segmenții se activează la 0 logic, adică mai sus am spus ca se va transmite 1 logic dar având semnul ! în față 1 logic se va transforma în 0 logic.

Acum vă voi expune partea software folosind funcții:

int segmentPin[] = {13, 12, 11, 10, 9, 8, 7, 6};
int anodComun = 5;
byte numere[10][8] = {
// a b  c  d  e  f  g  .
{ 1, 1, 1, 1, 1, 1, 0, 0}, // segmenti necesari pentru numarul 0
{ 0, 1, 1, 0, 0, 0, 0, 0}, // segmenti necesari pentru numarul 1
{ 1, 1, 0, 1, 1, 0, 1, 0}, // segmenti necesari pentru numarul 2
{ 1, 1, 1, 1, 0, 0, 1, 0}, // segmenti necesari pentru numarul 3
{ 0, 1, 1, 0, 0, 1, 1, 0}, // segmenti necesari pentru numarul 4
{ 1, 0, 1, 1, 0, 1, 1, 0}, // segmenti necesari pentru numarul 5
{ 1, 0, 1, 1, 1, 1, 1, 0}, // segmenti necesari pentru numarul 6
{ 1, 1, 1, 0, 0, 0, 0, 0}, // segmenti necesari pentru numarul 7
{ 1, 1, 1, 1, 1, 1, 1, 0}, // segmenti necesari pentru numarul 8
{ 1, 1, 1, 1, 0, 1, 1, 0}  // segmenti necesari pentru numarul 9
};
void setup()
{
for (int i=0; i < 8; i++)
{
pinMode(segmentPin[i], OUTPUT);
}
pinMode(anodComun, OUTPUT);
}
void loop()
{
static int nr;
nr = random(10);
afisare(nr);
}
void afisare(int val)
{
digitalWrite(anodComun, HIGH);
segmenti(val);
delay(500);
}
void segmenti(int n)
{
for (int i=0; i < 8; i++)
{
digitalWrite(segmentPin[i], ! numere[n][i]);
}
}

Explicațiile sunt aceleași doar că am folosit 2 funcții: funcția void afisare() —care se ocupă cu afișarea pe ecran, iar funcția void segmenti() — care se ocupă cu determinarea pinilor ce trebuie activați pentru a afișa numărul generat aleator.

Controlul a 2 afișaje 7-segmente folosint tranzistori și Arduino.

Schema este următoarea:

Partea software:

int segmentPins[] = {13, 12, 11, 10, 9, 8, 7, 6};
int displayPins[] = {5,4};
//int buttonPin = 12;
byte digits[10][8] = {
// a b c d e f g .
{ 1, 1, 1, 1, 1, 1, 0, 0}, // 0
{ 0, 1, 1, 0, 0, 0, 0, 0}, // 1
{ 1, 1, 0, 1, 1, 0, 1, 0}, // 2
{ 1, 1, 1, 1, 0, 0, 1, 0}, // 3
{ 0, 1, 1, 0, 0, 1, 1, 0}, // 4
{ 1, 0, 1, 1, 0, 1, 1, 0}, // 5
{ 1, 0, 1, 1, 1, 1, 1, 0}, // 6
{ 1, 1, 1, 0, 0, 0, 0, 0}, // 7
{ 1, 1, 1, 1, 1, 1, 1, 0}, // 8
{ 1, 1, 1, 1, 0, 1, 1, 0} // 9
};
void setup()
{
for (int i=0; i < 8; i++)
{
pinMode(segmentPins[i], OUTPUT);
}
pinMode(displayPins[0], OUTPUT);
pinMode(displayPins[1], OUTPUT);
//pinMode(buttonPin, INPUT);
}
void loop()
{
static int dice1;
static int dice2;
//if (digitalRead(buttonPin))
//{
dice1 = random(9);
dice2 = random(1,7);
//}
updateDisplay(dice1, dice2);
//updateDisplay(dice1);
//delay(10000);
}
void updateDisplay(int value1, int value2)
{
digitalWrite(displayPins[0], HIGH);
digitalWrite(displayPins[1], LOW);
setSegments(value1);
delay(500);
digitalWrite(displayPins[0], LOW);
digitalWrite(displayPins[1], HIGH);
setSegments(value2);
delay(500);
}
void setSegments(int n)
{
for (int i=0; i < 8; i++)
{
digitalWrite(segmentPins[i], ! digits[n][i]);
}
}

Explicațiile sunt aceleași!!!!!!!

Controlul afișajelor 7-segmente folosint decodor BCD și Arduino.

Schema:

Partea software:

int segmentPin[] = {4,5,6,7};
int anodComun = 5;
byte numere[10][4] = {
// a b  c  d  .
{ 0, 0, 0, 0}, // segmenti necesari pentru numarul 0
{ 0, 0, 0, 1}, // segmenti necesari pentru numarul 1
{ 0, 0, 1, 0}, // segmenti necesari pentru numarul 2
{ 0, 0, 1, 1}, // segmenti necesari pentru numarul 3
{ 0, 1, 0, 0}, // segmenti necesari pentru numarul 4
{ 0, 1, 0, 1}, // segmenti necesari pentru numarul 5
{ 0, 1, 1, 0}, // segmenti necesari pentru numarul 6
{ 0, 1, 1, 1}, // segmenti necesari pentru numarul 7
{ 1, 0, 0, 0}, // segmenti necesari pentru numarul 8
{ 1, 0, 0, 1}  // segmenti necesari pentru numarul 9
};
void setup()
{
for (int i=0; i < 4; i++)
{
pinMode(segmentPin[i], OUTPUT);
}
//pinMode(anodComun, OUTPUT);
Serial.begin(9600);
}
void loop()
{
static int nr;
nr = random(10);
afisare(nr);
}
void afisare(int val)
{
//digitalWrite(anodComun, HIGH);
segmenti(val);
Serial.print(„numarul:”);
Serial.print(val);
delay(5000);
}
void segmenti(int n)
{
for (int i=0; i < 4; i++)
{
digitalWrite(segmentPin[i], numere[n][i]);
//digitalWrite(segmentPin[0], 1);
//digitalWrite(segmentPin[1], 0);
//digitalWrite(segmentPin[2], 0);
//digitalWrite(segmentPin[3], 0);//! numere[n][i])
}
}

Lasă un răspuns

Adresa ta de email nu va fi publicată. Câmpurile obligatorii sunt marcate cu *

Acest sit folosește Akismet pentru a reduce spamul. Află cum sunt procesate datele comentariilor tale.



Insert math as
Block
Inline
Additional settings
Formula color
Text color
#333333
Type math using LaTeX
Preview
\({}\)
Nothing to preview
Insert