Come usare un display a 7 segmenti: mostrare numeri con Arduino, anodo o catodo comune

Un display a 7 segmenti è un indicatore semplice formato da sette LED a barra disposti come il numero "8", più un piccolo punto. Lo usano gli orologi digitali, i timer dei microonde, i tabelloni segnapunti e i distributori di benzina. È economico, molto luminoso e si legge bene anche da lontano. Nei progetti Arduino è una delle uscite classiche per costruire contatori, dadi, cronometri e orologi.

Come funziona un display a 7 segmenti?

I segmenti si indicano con lettere: partendo dalla a in alto e procedendo in senso orario ci sono b (in alto a destra), c (in basso a destra), d (in basso), e (in basso a sinistra) ed f (in alto a sinistra); la barra centrale è la g e il punto è dp. Ogni segmento è in realtà un LED separato, e a seconda di quali si accendono si formano le diverse cifre. Per l'"1", per esempio, si accendono solo b e c; per l'"8" tutti e sette.

Catodo comune o anodo comune?

Come in un LED RGB, un'estremità di tutti i segmenti è collegata a un pin comune. In un display a catodo comune il pin comune va a GND e un segmento si accende quando riceve HIGH. In uno ad anodo comune il pin comune va al 5V e il segmento si accende con LOW. Dall'esterno sono identici; per capire quale hai, collega il pin comune a GND e tocca il 5V con un pin di segmento tramite una resistenza da 220 Ω. Se il segmento si accende è a catodo comune; se no, inverti il collegamento e riprova.

Piedinatura e collegamento ad Arduino

Nei comuni display a una cifra con 10 pin, con il lato frontale rivolto verso di te, i pin sono numerati in senso antiorario partendo dal basso a sinistra. I due pin centrali (3 e 8) sono il terminale comune e sono collegati internamente. La tabella mostra sia i pin del display sia i pin di Arduino usati dal codice di questo articolo:

Contare da 0 a 9 con Arduino

Salvare in un array, come bit, quali segmenti accende ogni cifra rende il codice molto più corto. Nell'esempio qui sotto il bit più a sinistra di ogni byte è il segmento a e quello più a destra il segmento g. La funzione showDigit() legge questi bit uno per uno e li scrive sui pin; se il tuo display è ad anodo comune, basta impostare COMMON_ANODE a true.

1const int SEG_PINS[7] = {2, 3, 4, 5, 6, 7, 8};   // a, b, c, d, e, f, g
2const bool COMMON_ANODE = false;                 // ortak anotsa true / true for common anode
3
4// her rakam için a–g segmentleri (1 = yanar) / a–g segments per digit (1 = on)
5const byte DIGITS[10] = {
6  0b1111110, // 0
7  0b0110000, // 1
8  0b1101101, // 2
9  0b1111001, // 3
10  0b0110011, // 4
11  0b1011011, // 5
12  0b1011111, // 6
13  0b1110000, // 7
14  0b1111111, // 8
15  0b1111011  // 9
16};
17
18void showDigit(int n) {
19  for (int i = 0; i < 7; i++) {
20    bool on = DIGITS[n] & (1 << (6 - i));       // a en soldaki bit / a is the leftmost bit
21    digitalWrite(SEG_PINS[i], COMMON_ANODE ? !on : on);
22  }
23}
24
25void setup() {
26  for (int i = 0; i < 7; i++) pinMode(SEG_PINS[i], OUTPUT);
27}
28
29void loop() {
30  for (int n = 0; n <= 9; n++) {
31    showDigit(n);
32    delay(1000);
33  }
34}

Display a 4 cifre e multiplexing

Un display a quattro cifre non ha 32 pin di segmento, ma solo 12 pin: 8 linee di segmento (a–g e dp) condivise da tutte le cifre e 4 pin che scelgono quale cifra accendere. Dato che le linee sono condivise, non puoi mostrare numeri diversi su cifre diverse nello stesso istante. La soluzione è il multiplexing: accendi solo la 1ª cifra per qualche millisecondo, poi la 2ª, la 3ª e la 4ª. Quando questo ciclo si ripete più di 50 volte al secondo, l'occhio vede tutte e quattro le cifre accese insieme. Invece di scrivere a mano questa scansione, è molto più semplice usare la libreria SevSeg:

1#include "SevSeg.h"
2
3SevSeg sevseg;
4
5void setup() {
6  byte digitPins[] = {2, 3, 4, 5};                    // hane seçme pinleri / digit select pins
7  byte segmentPins[] = {6, 7, 8, 9, 10, 11, 12, 13};  // a, b, c, d, e, f, g, dp
8  sevseg.begin(COMMON_CATHODE, 4, digitPins, segmentPins, true);  // dirençler segmentlerde / resistors on segments
9  sevseg.setBrightness(90);
10}
11
12void loop() {
13  sevseg.setNumber(millis() / 1000);   // geçen saniye / elapsed seconds
14  sevseg.refreshDisplay();             // sürekli çağrılmalı / must be called continuously
15}

Il modulo TM1637: 4 cifre con soli 2 fili

Se 12 fili e una scansione continua ti sembrano troppo lavoro, il modulo TM1637 fa per te. Il suo chip di controllo gestisce da solo il multiplexing; Arduino gli dice soltanto quale numero mostrare tramite i pin CLK e DIO. La maggior parte delle versioni ha anche i due punti (:) al centro per fare orologi. Installa dal Gestore librerie la libreria TM1637 di Avishay Orpaz; il codice qui sotto mostra minuti e secondi con i due punti:

1#include <TM1637Display.h>
2
3TM1637Display display(2, 3);   // CLK, DIO
4
5void setup() {
6  display.setBrightness(5);    // 0–7
7}
8
9void loop() {
10  int minutes = (millis() / 60000) % 60;
11  int seconds = (millis() / 1000) % 60;
12  // ortadaki iki noktayla dakika:saniye / minutes:seconds with the colon
13  display.showNumberDecEx(minutes * 100 + seconds, 0b01000000, true);
14  delay(200);
15}

Display a 7 segmenti con ESP32 e Raspberry Pi Pico

Puoi collegare un display a una cifra direttamente a un ESP32 o a un Pico; dato che i pin forniscono 3,3 V, i segmenti sono un po' meno luminosi, quindi usa resistenze più piccole, da 100–150 Ω. Anche il modulo TM1637 funziona a 3,3 V e sull'ESP32 si usa con la stessa libreria Arduino. Per MicroPython sul Pico basta copiare sul Pico il file tm1637.py (la libreria di mcauser):

1import tm1637
2from machine import Pin
3import time
4
5tm = tm1637.TM1637(clk=Pin(16), dio=Pin(17))   # tm1637.py Pico'da olmalı / tm1637.py must be on the Pico
6tm.brightness(4)                               # 0–7
7
8count = 0
9while True:
10    tm.number(count)        # -999 … 9999
11    count += 1
12    time.sleep(1)

7 segmenti, LCD o OLED?

Se devi mostrare solo numeri e conta la leggibilità da lontano, il display a 7 segmenti è imbattibile. Se ti servono testo, unità di misura e menu, dai un'occhiata a Usare un display LCD I2C.

Idee di progetti con il display a 7 segmenti

• Dado elettronico: mostra un numero casuale da 1 a 6 alla pressione di un pulsante.
• Contatore a pulsanti: un contatore che sale con un pulsante e si azzera con un altro.
• Orologio digitale: un orologio con TM1637 e modulo RTC che non perde l'ora anche se va via la corrente.
• Conto alla rovescia: un timer regolabile per giochi da tavolo o esperimenti.
• Indicatore di temperatura: mostra a cifre grandi la temperatura misurata con un DHT11.
• Test dei riflessi: mostra in millisecondi quanto velocemente premi il pulsante dopo che si accende un LED.

Errori comuni e come risolverli

• Non si accende nessun segmento: il pin comune è collegato nel posto sbagliato; forse hai collegato a GND un display ad anodo comune.
• Le cifre appaiono sbagliate: la corrispondenza tra segmenti e pin di Arduino è errata; verificala accendendo un segmento alla volta.
• Alcune cifre sono deboli: c'è una sola resistenza sul pin comune; usane una per ogni segmento.
• Sul display a 4 cifre se ne accende solo una o tutto sfarfalla: c'è un delay() in loop() o la scansione non è abbastanza frequente.
• I segmenti che dovrebbero accendersi sono spenti e gli altri accesi: anodo e catodo comune sono stati confusi; cambia COMMON_ANODE.
• I pin non bastano: riduci il numero di pin con un modulo TM1637, un driver MAX7219 o uno shift register 74HC595.

Sapere che ogni segmento è in realtà un LED è la chiave per capire i display a 7 segmenti; per le basi dai un'occhiata a Cos'è un LED? Nell'app BlueGrays trovi progetti per contare da 0 a 9, contatore a pulsante, dado, orologio digitale a 4 cifre e animazione della bomba, passo passo con schemi e codice.