Cos'è un display a 7 segmenti?
Un display a 7 segmenti è un componente elettronico composto da 7 LED individuali disposti in uno schema specifico per visualizzare cifre (da 0 a 9) e alcune lettere. Questi LED sono denominati a, b, c, d, e, f, g e il display include in genere un punto decimale opzionale (dp).
A seconda delle diverse disposizioni e combinazioni, ci sono 128 variazioni (numeri arabi e caratteri) per il display a 7 segmenti.
Schema dei pin del display a 7 segmenti
Lo schema dei pin di un display a 7 segmenti varia in base al suo tipo, che è principalmente diviso in due categorie: anodo comune e catodo comune.
Configurazione dei pin
Di seguito è riportato un esempio di assegnazione dei pin per un tipico display a 7 segmenti (nota che gli schemi dei pin effettivi possono variare a seconda del produttore e del modello):
Anodo comune:
Tutti gli anodi (positivi) del display a 7 segmenti sono collegati insieme e quando un catodo viene portato a livello basso, il LED corrispondente si accende.
- g, f, a, b, e, d, c, dp: questi sono i pin del segmento, corrispondenti ai sette segmenti e al punto decimale, rispettivamente.
- COM: il pin dell’anodo comune, collegato a VCC.
Catodo comune:
Tutti i catodi (negativi) del display a 7 segmenti sono collegati insieme e quando un anodo (positivo) viene portato a livello alto, il LED corrispondente si accende.
Allo stesso modo, i pin del segmento (g, f, a, b, e, d, c, dp) corrispondono ai segmenti e al punto decimale, ma il pin del catodo comune (COM) è collegato a GND.
Cablaggio del display a 7 segmenti
Per far funzionare un display a 7 segmenti, i singoli segmenti (a, b, c, d, e, f, g, dp) devono essere collegati a specifici pin di output su un microcontrollore. Ad esempio, per un display a 7 segmenti a catodo comune, l’estremità negativa di ciascun segmento è collegata a un polo di massa comune, mentre l’estremità positiva di ciascun segmento è collegata a un diverso pin di output sul microcontrollore.
Configurazione di cablaggio di base
- display a 7 segmenti ha 8 pin (7 per i segmenti e 1 per il punto decimale).
- Ogni pin corrispondente a un segmento (da a a g) è collegato al microcontrollore.
- Per la configurazione a catodo comune, collegare il pin del catodo comune a massa.
Esempio di connessione ad Arduino
Quando si interfaccia un display a 7 segmenti con un Arduino, i pin del segmento sono in genere collegati a diversi pin digitali sulla scheda Arduino. Ad esempio, in una configurazione ad anodo comune, i pin del segmento potrebbero essere collegati come segue:
- a – Pin Arduino 7
- b – Pin Arduino 8
- c – Pin Arduino 4
- d – Pin Arduino 3
- e – Pin Arduino 2
- f – Pin Arduino 6
- g – Pin Arduino 5
- COM – Pin Arduino 9 (collegato a VCC)
In questa configurazione, per illuminare un segmento specifico, il pin Arduino corrispondente è impostato su LOW, mentre il pin dell’anodo comune rimane HIGH.
Come controllare un display a 7 segmenti
La chiave per controllare un display a 7 segmenti è fornire la corretta tensione ai singoli segmenti per formare il numero o il simbolo desiderato.
Visualizzazione dei numeri
Per visualizzare un numero, il microcontrollore deve accendere i segmenti appropriati. Ad esempio:
- Per visualizzare 0, i segmenti a, b, c, d, e e f devono essere illuminati, mentre il segmento g rimane spento.
Componenti richiesti
Simile a una matrice LED, questo progetto richiederà una notevole quantità di cablaggio e resistenze. Poiché ogni LED necessita della propria resistenza per prevenire il bruciore, assicurati di avere a disposizione resistenze sufficienti. Per l’intero progetto, avrai bisogno dei seguenti componenti:
- Arduino Uno
- Arduino IDE
- Display a sette segmenti
- Cavi elettrici
- 8 resistenze da 220 ohm
- Breadboard
- Cavo USB
Esempio di codice per visualizzare i numeri
int pin_a = 7, pin_b= 6, pin_c = 5, pin_d = 10, pin_e = 11, pin_f = 8, pin_g = 9, pin_p = 4;
// Segment data for digits 0-9
int numTable[10][8] = {
{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 = 4; i <= 11; i++){
pinMode(i, OUTPUT);
}
}
void loop(){
for (int i = 0; i < 10; i++){
digitalWrite(pin_a, numTable[i][0]);
digitalWrite(pin_b, numTable[i][1]);
digitalWrite(pin_c, numTable[i][2]);
digitalWrite(pin_d, numTable[i][3]);
digitalWrite(pin_e, numTable[i][4]);
digitalWrite(pin_f, numTable[i][5]);
digitalWrite(pin_g, numTable[i][6]);
digitalWrite(pin_p, numTable[i][7]);
delay(1000);
}
}
In questo esempio, l’array numTable contiene i dati necessari per accendere i segmenti appropriati per ogni cifra.
Progetti con display a 7 segmenti a più cifre
Per i display a più cifre, il modo più semplice per controllare più display a 7 segmenti è attraverso il multiplexing, un altro modo è la libreria Arduino.
Tecnica di multiplexing
Con il multiplexing, più display condividono lo stesso set di pin di controllo e ogni display viene acceso in sequenza. Questo viene fatto così velocemente che l’occhio umano percepisce tutte le cifre come illuminate contemporaneamente.
Esempio di codice per display a 7 segmenti multiplexati
const int digitPins[3] = {2, 3, 4}; // Digit selection pins
const int segmentPins[8] = {6, 7, 8, 9, 10, 11, 12, 13}; // Segment pins
int numTable[10][8] = { {0, 0, 0, 0, 0, 0, 1, 1}, {1, 0, 0, 1, 1, 1, 1, 1}, ... };
void setup(){
for (int i = 2; i <= 4; i++) {
pinMode(i, OUTPUT);
digitalWrite(i, LOW);
}
for (int i = 6; i <= 13; i++) {
pinMode(i, OUTPUT);
digitalWrite(i, HIGH);
}
}
void loop(){
for (int i = 0; i < 10; i++){
for (int j = 0; j < 3; j++) {
showdigit(i, j);
}
delay(500);
}
}
void showdigit(int num, int digit){
digitalWrite(digitPins[digit], HIGH);
for (int i = 0; i < 8; i++) {
digitalWrite(segmentPins[i], numTable[num][i]);
}
delay(500);
digitalWrite(digitPins[digit], LOW);
}
Utilizzo di librerie per controllare i display a 7 segmenti
Per comodità, sono disponibili librerie come SevSeg per semplificare il controllo dei display a 7 segmenti. Questa libreria è utile per controllare i display a più cifre, in quanto astrae gran parte del cablaggio e della logica di controllo complessi.
Possiamo cercare e installare SevSeg dal menu Arduino: Strumenti >> Gestisci librerie.
Esempio di codice che utilizza la libreria SevSeg
#include "SevSeg.h"
SevSeg sevseg;
void setup() {
sevseg.begin(COMMON_CATHODE, 3, digitPins, segmentPins);
}
void loop() {
int readValue = analogRead(A0);
int showValue = map(readValue, 0, 1023, 0, 999);
sevseg.setNumber(showValue, 3);
sevseg.refreshDisplay();
}
Applicazioni dei display a 7 segmenti
Grazie alla sua semplicità, facilità d’uso e basso costo, il display a 7 segmenti è ampiamente utilizzato in varie applicazioni, come:
- Orologi elettronici: visualizzazione di ora e data;
- Calcolatrici: visualizzazione dei risultati dei calcoli;
- Elettrodomestici: pannelli di visualizzazione per prodotti come forni a microonde, condizionatori d’aria e lavatrici;
- Cruscotti auto: visualizzazione di informazioni come velocità e chilometraggio;
- Apparecchiature industriali: visualizzazione delle letture da dispositivi come controllori di temperatura e manometri;
- Strumenti di laboratorio: visualizzazione di dati e risultati sperimentali;
- Elettronica di consumo: display del controllo del volume su apparecchiature audio.
Conclusione
I display a 7 segmenti sono componenti versatili che consentono la semplice visualizzazione di dati numerici. Comprendere il loro cablaggio, i metodi di controllo e le applicazioni può migliorare notevolmente la funzionalità dei tuoi progetti, da semplici orologi a display complessi. Che tu stia utilizzando il multiplexing, le librerie o i registri a scorrimento, ci sono molti modi per controllare efficacemente i display a 7 segmenti, ognuno adatto a diversi requisiti di progetto.
