Tag

, , , , , , , ,

Il display 7-segmenti è un componente molto versatile, utile e poco costoso, che viene impiegato spesso nei progetti; ma dato che in commercio ne esistono diversi modelli e che il suo funzionamento non è subito intuitivo, ho pensato di approfondire l’argomento.

Ho raccolto per questo studio alcuni diversi tipi di display: uno a numero singolo, uno a 4 cifre piuttosto semplice (a catodo comune), ed un display bargraph (è tipo un indicatore di carica con le barrette).

Tipi di display

Come abbiamo detto, esistono diversi tipi di display a 7 segmenti. Le differenze principali tra un modello e l’altro riguardano il colore e la grandezza delle cifre, il voltaggio richiesto e il tipo di connessione, che può essere ad anodo comune o a catodo comune.

Anodo comune, catodo comune

Il modello a catodo comune ha di solito un pin che va collegato a terra, e per accendere un segmento si imposta ad HIGH. Viceversa, un modello ad anodo comune in genere va collegato alla 5V, e per accendere un segmento occorre impostarlo a LOW.

Alcuni Modelli

Per mostrare nel dettaglio alcuni dei diversi tipi di display a 7 segmenti, vediamo qualche esempio più da vicino.

Display 7-segments 1-digit

Display 7-segms
1-digit

Display 7-segments 4-digit

Display 7-segms
4-digit

Bargraph

Bargraph

Considerazioni

Le due cose più importanti da tenere in considerazione, quando si utilizza un display a 7 segmenti, sono la mappatura dei suoi pin e il voltaggio che richiede – non tanto perché questi due elementi siano di difficile comprensione, quanto piuttosto perché possono in maniera diretta influenzare la progettazione del nostro circuito: non ha senso impiegare tempo e risorse nel tentativo di costruire un circuito comodo e trasportabile se poi voglio mettere insieme 240 cifre, e per alimentarle mi serve la batteria di un camion…!

Esempio #1 – Display a singola cifra

Dopo questa breve panoramica dei diversi display che utilizzeremo, vediamo di entrare nel dettaglio con qualcosa di pratico. Come primo esempio, vediamo come funziona un display a cifra singola, in questo caso a catodo comune.

Schema 7-segment 1-digit

Schema 7-segment 1-digit

Il funzionamento è molto semplice, ed è stato accennato anche in questo studio. Ogni segmento viene identificato da una lettera (da a, fino a g) ed ha un suo pin, che andrà collegato ad Arduino: avremo quindi 8 pin da controllare (uno per ogni segmento, uno per il punto in basso a destra) – più 1 pin per la terra.

Per comporre una lettera o un numero e farlo apparire sul display, dobbiamo solamente individuare i segmenti che ci occorrono, e impostare il loro valore ad HIGH. Per mappare correttamente pin e segmenti consultate il datasheet del vostro componente. Il mio ha questa corrispondenza, ma il vostro potrebbe essere diverso. Si tratta solo di fare un po’ di prove!

// Definisco la mappatura tra pin e segmenti
int G=4;
int F=5;
int A=6;
int B=7;
int E=8;
int D=9;
int C=10;
int DP=11;

Colleghiamo adesso i 9 pin al nostro Arduino e decidiamo quali lettera fare apparire: nel caso in questione, proviamo a scrivere semplicemente: C-I-A-O.

void loop(){
  lettera_C();
  delay(1000);
  lettera_I();
  delay(1000);
  lettera_A();
  delay(1000);
  lettera_O();
  delay(1000);
}

// Funzioni per scrivere alcuni caratteri (catodo comune)
void lettera_C(){
  digitalWrite(A, HIGH);
  digitalWrite(B, LOW);
  digitalWrite(C, LOW);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, LOW);
  digitalWrite(DP, LOW);
}
void lettera_I(){
  digitalWrite(A, LOW);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, LOW);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, LOW);
  digitalWrite(DP, LOW);
}
void lettera_A(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, LOW);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  digitalWrite(DP, LOW);
}
void lettera_O(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, LOW);
  digitalWrite(DP, LOW);
}

PS: nel caso il vostro display sia ad anodo comune, non a catodo come nell’esempio, il collegamento è alla 5V non alla terra, e il segmento si accende impostato a LOW e non ad HIGH. In questo caso però ricordatevi di mettere delle resistenze (almeno 220 Ohm) per non sovraccaricare i pin di Arduino.

Esempio #2 – Display 4 cifre

Proviamo adesso a sostituire il display a singola cifra con un display a 4 cifre. Anche qui in commercio esistono diversi modelli, anodo o catodo comune, con diverse mappature, ecc. perciò vediamo di cominciare con qualcosa di facile.

Il display a 4 cifre che avevo a disposizione è ad anodo comune, il suo modello si chiama YSD-439AB4B-35, e il suo datasheet è questo.

Allora cominciamo… Ma aspettate! Huston, abbiamo un problema!!

Problema…

Come si può intuire molto facilmente, il problema principale che si incontra a questo punto è evidente: se un display a singola cifra ha bisogno di ben 8 connessioni… per un display a 4 cifre, ne serviranno 32?! E quanti pin dovrebbe avere, allora, il nostro Arduino? Bisogna forse acquistare un Arduino Mega solo per accendere un display a 7 segmenti?

Ovviamente, la soluzione è più a portata di mano. E anzi, di soluzioni ce ne sono diverse.

Naturalmente se volete acquistare un Arduino Mega, non c’è nessuna contro-indicazione ma per lo studio che stiamo facendo non è necessario. Una soluzione più comoda, infatti, è quella di acquistare un tipo di display che – sfruttando un sistema molto simile a quello che viene definito multiplex – consente di ridurre notevolmente il numero di connessioni necessarie.

Cerchiamo di capire di cosa si tratta.

… utilizzare meno connessioni

Questo tipo di display accomuna tutte le uscite che vanno ai pin, e consente di scegliere la cifra da modificare: in questo modo, con soli 16 pin, possiamo controllare ben 4 cifre!

Per collegare il display, infatti, sono necessari 4 pin (per le 4 cifre) mentre per controllare tutti i diversi segmenti, servono soltanto 8 pin, non 8×4=32! Infatti, potendo scegliere la cifra da accendere, il nostro display saprà automaticamente quali segmenti utilizzare, e tutto questo con un notevole risparmio di connessioni e di spazio.

Esempio #2 – Display 4 cifre (reprise)

Dopo tutta questa spiegazione, vediamo quanto è semplice accendere un display 4 cifre:

Schema 7-segment 4-digit

Schema 7-segment 4-digit

PS: purtroppo non ho trovato un display a quattro cifre nella libreria di Fritzing per cui ho cercato di disegnarlo usando 4 display singoli. Immaginate che sia un pezzo unico, con 8 piedini in alto e altri 8 in basso. La numerazione parte dal primo cavo arancione in basso (1) e prosegue in senso anti-orario fino all’ultimo cavetto blu in alto a sinistra (16). I vari collegamenti dovrebbero essere corretti.

// Definisco i pin delle cifre
int digit1 = 2;
int digit2 = 3;
int digit3 = 4;
int digit4 = 5;

// Definisco la mappatura tra pin e segmenti
int C=6;
int D=7;
int DP=8;
int A=9;
int G=10;
int F=11;
int B=12;
int E=13;

// Setup. Imposto ogni cifra e segmento come OUTPUT
void setup(){
  // Imposto le cifre come OUTPUT
  pinMode(digit1, OUTPUT);
  pinMode(digit2, OUTPUT);
  pinMode(digit3, OUTPUT);
  pinMode(digit4, OUTPUT);
  // Imposto i segmenti come OUTPUT
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(E, OUTPUT);
  pinMode(F, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(DP, OUTPUT);
}

Una volta preparati tutti i collegamenti, proviamo a scrivere C-I-A-O utilizzando insieme tutte le 4 le cifre contemporaneamente! Ricordiamoci innanzitutto che il display che qui utilizziamo è ad anodo comune, perciò –  se vogliamo prendere le funzioni dichiarate nel primo esempio e usarle adesso, dobbiamo invertire HIGH e LOW.

// Funzioni per scrivere alcuni caratteri (anodo comune)
void lettera_C(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, LOW);
  digitalWrite(D, LOW);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, HIGH);
  digitalWrite(DP, HIGH);
}
ecc...

Adesso non ci resta che scrivere la nostra funzione loop(). Ma c’è un’ultima accortezza, da tenere in considerazione… Abbiamo visto che questo tipo di componente, accorpando le 4 cifre, permette di risparmiare un gran numero di pin su Arduino.

Questa enorme comodità, però, si paga leggermente a livello software: infatti, così come su certi pin di Arduino è possibile “simulare” un dosaggio di potenza grazie al PWM – che in realtà non fa che “accendere e spegnere” velocemente il pin, dando l’illusione di avere una potenza regolabile – allo stesso modo questo tipo di componente riesce a manovrare ben 4 cifre utilizzando poche connessioni perché in realtà le “accende e spegne” tutte in modo molto veloce! Questo, a livello pratico, si traduce nella necessità di controllare ogni cifra – anche quando non viene utilizzata – e di introdurre un piccolo ritardo tra l’utilizzo di una cifra e l’altra, in modo che l’occhio non si accorga dell’inganno. Ed ecco, in poche parole, il codice del nostro loop():

// Loop. Scrivo un carattere diverso su ogni cifra
 void loop(){
  digitalWrite(digit1, HIGH);
  digitalWrite(digit2, LOW);
  digitalWrite(digit3, LOW);
  digitalWrite(digit4, LOW);
  lettera_C();
  delayMicroseconds(5000);

  digitalWrite(digit1, LOW);
  digitalWrite(digit2, HIGH);
  digitalWrite(digit3, LOW);
  digitalWrite(digit4, LOW);
  lettera_I();
  delayMicroseconds(5000);

  digitalWrite(digit1, LOW);
  digitalWrite(digit2, LOW);
  digitalWrite(digit3, HIGH);
  digitalWrite(digit4, LOW);
  lettera_A();
  delayMicroseconds(5000);

  digitalWrite(digit1, LOW);
  digitalWrite(digit2, LOW);
  digitalWrite(digit3, LOW);
  digitalWrite(digit4, HIGH);
  lettera_O();
  delayMicroseconds(5000);
}

Et voilà! La scritta compare sul display utilizzando tutti e quattro le cifre a disposizione, ed abbiamo occupato un numero tutto sommato abbastanza esiguo di pin su Arduino.

Esempio #3 – Bar Graph

Un elemento più divertente da utilizzare, e che può tornare utile per certi progetti, è il bar-graph. Più semplice di un display a 7 segmenti, funziona in sostanza nello stesso modo. Questo è il datasheet del modello che ho utilizzato.

Tutto quello che occorre per montarlo correttamente sulla breadboard sono 10 cavetti per collegare i piedini su un lato ai pin di Arduino, e altrettante resistenze, da 220 Ohm, per collegare i piedini sul lato opposto alla terra. Vediamo lo schema:

Arduino Bar Graph Schema

Arduino Bar Graph Schema

PS: anche qui, purtroppo, Fritzing non è stato di grande aiuto. Immaginate un unico bargraph al posto dei due singoli display.

Questo infine può essere un semplice codice per accendere e spegnere in progressione tutti i segmenti del bargraph. Per semplificare il codice (anche se potrebbe sembrare più complesso credetemi, non lo è) utilizzo un array per “archiviare” tutti i pin necessari in un’unica variabile: elementi. PS: l’uso degli array è già stato accennato in questo studio.

// Definisco la mappatura degli elementi
int totale = 10; // numero di elementi in totale
int elementi[] = { 2,3,4,5,6,9,10,11,12,13 }; // array con il pin di ogni elemento

Poi nel setup() definisco ogni pin come output:

// Setup. Imposto ogni elemento come OUTPUT
void setup(){
  for ( int n=0; n<totale; n++ ) {
    pinMode(elementi[n],OUTPUT);
  }
}

Infine ciclo gli elementi dell’array per accendere e spegnere in sequenza tutti gli elementi del bar graph. Semplice, no?

// Loop. Accendo e spegno in sequenza ogni elemento
void loop(){
  // Attendo, per mostrare il bar graph spento
  delay(500);
  // Accendo gli elementi in sequenza
  for ( int n=0; n<=totale; n++ ) {
    digitalWrite(elementi[n],HIGH);
    delay(500);
  } 
  // Spengo gli elementi in sequenza
  for ( int n=totale; n>=0; n-- ) {
    digitalWrite(elementi[n],LOW);
    delay(500);
  } 
}

Bene! Per ora, questo è tutto! Buon divertimento con Arduino e alla prossima!

Download: 7-segmenti_approfondimento.zip

Annunci