Interfaccia Display a sette segmenti con ESPTOP 10 usando Arduino IDE

ESP32 è una popolare piattaforma elettronica open source che può essere utilizzata per controllare e interagire con un'ampia varietà di dispositivi elettronici, inclusi display a sette segmenti. Utilizzando il microcontrollore ESP32, è possibile controllare facilmente lo stato di ogni segmento in un display a sette segmenti, consentendo la creazione di display numerici personalizzati e altri progetti interattivi.

Questo articolo copre i seguenti contenuti:

• 1: Introduzione a sette segmenti
• 2: pinout a sette segmenti
• 3: tipi di sette segmenti
• 4: come controllare un segmento a sette anni è un anodo comune o un catodo comune
• 5: interfacciando sette segmenti con ESP32
• 5.1: schema
• 5.2: hardware
• 5.3: installazione della libreria richiesta
• 6: Controlla sette segmenti usando la libreria con ESP32
• 6.1: codice
• 6.2: output
• 7: Controlla sette segmenti senza usare la libreria ESP32
• 7.1: codice
• 7.2: output

1: Introduzione a sette segmenti

Un segmento a sette segmenti può visualizzare informazioni numeriche utilizzando un programma di microcontrollore. È costituito da sette singoli segmenti, ognuno dei quali può essere illuminato o disattivato in modo indipendente per creare vari caratteri numerici.

Un display a sette segmenti funziona illuminando diverse combinazioni dei suoi sette segamenti per visualizzare caratteri numerici. Ogni segmento è controllato da un singolo pin, che può essere acceso o spento per creare il carattere numerico desiderato. Quando i segmenti sono illuminati nella combinazione corretta, il carattere numerico è visibile allo spettatore.

Quando si utilizza un microcontrollore ESP32 per controllare un display a sette segmenti, ESP32 invia segnali ai pin specifici sul display a sette segmenti, dicendole quali segmenti si accendono o spegnere per visualizzare un carattere numerico specifico.

Questo viene fatto scrivendo un programma nell'IDE Arduino (ambiente di sviluppo integrato) utilizzando il linguaggio di programmazione C ++. Il programma utilizza la libreria Arduino per controllare lo stato di ciascun segmento con comandi semplici. Il programma può anche essere impostato per visualizzare diversi caratteri numerici in base all'input da sensori o interazione dell'utente.

2: pinout a sette segmenti

Il display a sette segmenti in genere ha 10 Pin, con un perno per ciascun segmento, uno per il decimale e due perni comuni. Ecco una tabella del tipico pinout:

Codice PIN	Nome PIN	Descrizione
1	B	Pin LED in alto a destra
2	UN	Pin LED più in alto
3	VCC/GND	GND/VCC dipende dalla configurazione - catodo/anodo comune
4	F	Pin LED in alto a sinistra
5	G	Pin a LED centrale
6	dp	PIN LED DOT
7	C	Pin LED in basso a destra
8	VCC/GND	GND/VCC dipende dalla configurazione - catodo/anodo comune
9	D	Pin LED inferiore
10	e	Pin LED in basso a sinistra

Ogni segmento è etichettato come A, B, C, D, E, F e G. Il pin comune viene in genere utilizzato per controllare tutti i segmenti contemporaneamente. Il pin comune è attivo basso o attivo in alto a seconda del display.

3: tipi di sette segmenti

Esistono due tipi principali di display a sette segmenti:

• Catodo comune
• Anodo comune.

1: in a Catodo comune Display, tutti i terminali negativi dei segmenti LED sono collegati insieme.

2: in a anodo comune Display, tutti i terminali positivi dei segmenti LED sono collegati.

4: come controllare un segmento a sette anni è un anodo comune o un catodo comune

Per controllare il tipo di sette seggi abbiamo solo bisogno di uno strumento semplice - Multimetro. Seguire i passaggi per controllare il tipo di visualizzazione a sette segmenti:

1. Tenere saldamente in mano il display a sette segmenti e identifica Pin 1 usando il pinout spiegato sopra.
2. Prendi un multimetro. Supponiamo che il piombo rosso per positivo (+) e piombo nero del multimetro per negativo (-).
3. Imposta il test multiple sul test di continuità.
4. Dopo quel che il lavoro di controllo del contatore può essere controllato toccando i cavi sia positivi che negativi. Verrà prodotto un suono segnale acustico se il misuratore funziona correttamente. Altrimenti sostituire le batterie nel multimetro con una nuova.
5. Metti il ​​piombo nero sul pin 3 o 8 del multimetro. Entrambi questi pin sono comuni e collegati internamente. Seleziona qualsiasi pin.
6. Ora metti il ​​piombo rosso o positivo del multimetro su altri pin di sette seggi come 1 o 5.
7. Dopo aver toccato la sonda rossa se un segmento si illumina, il display è un Catodo comune.
8. Inchange i conducenti multimetri se nessun segmento si illumina.
9. Ora collega il cavo rosso al pin 3 o 8.
10. Successivamente ha messo il piombo nero o negativo sui pin rimanenti del display. Ora se qualcuno del bagliore del segmento, il tuo display è un anodo comune, Come nell'anodo comune il pin positivo è comune e il resto è collegato a un alimentazione negativa.
11. Ripeti i passaggi per controllare tutti gli altri segmenti di visualizzazione uno per uno.
12. Se uno qualsiasi dei segmenti non si illumina, allora sarà difettoso.

Ecco un'immagine di riferimento per un test a sette segmenti usando un file multimetro. Possiamo vedere Red Lead è al Pin 8 e il nero è al perno del segmento, quindi stiamo usando Anodo comune Sette segmenti:

5: interfacciando sette segmenti con ESP32

Per interfacciarsi un display a sette segmenti con un ESP32, avrai bisogno dei seguenti materiali:

• Un microcontrollore ESP32
• Un display a sette segmenti
• Una breadboard
• Fili jumper

ESP32 Interfacce con display a sette segmenti in diversi semplici passaggi.

1: Innanzitutto, collegare il display a sette segmenti alla breadboard.

2: Quindi, collega Arduino Nano con un display a sette segmenti usando fili. L'ESP32 verrà utilizzato per inviare segnali al display a sette segmenti, dicendole quali segmenti si accendono o si spegne.

3: Ora scrivi un codice Arduino in IDE. Il programma dovrà inviare segnali ai pin specifici sul display a sette segmenti, dicendole quali segmenti si accendono o spegnere per visualizzare un carattere numerico specifico.

4: Arduino IDE fornisce una libreria utilizzando la quale possiamo facilmente controllare lo stato di ogni segmento con comandi semplici.

5: Una volta che il programma è stato scritto e caricato su ESP32, il display a sette segmenti dovrebbe iniziare a visualizzare i caratteri numerici secondo il programma.

5.1: schema

Per programmare prima sette segamenti dobbiamo progettare il circuito e collegarlo con ESP32. Utilizzando lo schema di riferimento seguente collega la scheda ESP32 con un display a sette segmenti.

Seguendo la tabella Pinout per la connessione ESP32 con un singolo display a sette segmenti:

Codice PIN	Nome PIN	ESP32 PIN
1	B	D2
2	UN	D15
3	Com	GND/VCC dipende dalla configurazione - catodo/anodo comune
4	F	D19
5	G	D21
6	dp	PIN LED DOT
7	C	D4
8	Com	GND/VCC dipende dalla configurazione - catodo/anodo comune
9	D	D5
10	e	D18

5.2: hardware

L'immagine sotto mostra l'hardware di ESP32 e sette segmenti:

5.3: installazione della libreria richiesta

Dopo aver collegato sette segmenti dobbiamo installare una libreria nell'IDE Arduino. Utilizzando questa libreria, possiamo facilmente programmare ESP32 con sette segmenti.

Vai alla ricerca di Biblioteca Manager Sevseg libreria e installalo in Arduino IDE.

6: Controlla sette segmenti usando la libreria con ESP32

Dopo aver installato la libreria, scriveremo un codice Arduino usando la stessa libreria.

6.1: codice

Apri IDE e caricamento Codice fornito su ESP32:

#include "sevseg.H " /*Biblioteca a sette segmenti inclusa* /
Sevseg Sevseg; /*Crea una libreria a sette segmenti*/
void setup ()

Byte Sevensegments = 1; /*Numero di sette segmenti collegati*/
byte comunepins [] = ; /*Definire il pin comune di sette segmenti*/
byte ledsegmentpins [] = 15, 2, 4, 5, 18, 19, 21; /*Definisci i pin digitali ESP32 per sette segmenti*/
bool resistorsonsegments = true; /*Assegnazione del tipo booleano ai registri del sette = segmento*/
Sevseg.inizio (comune_anode, sevensegments, comunepins, ledsegencepins, resistorsonsegments);/ *configurazione a sette segmenti */
Sevseg.SetBrightness (80); /*Luminosità a sette segmenti*/

void loop ()

per (int i = 0; i < 10; i++) /*Display number from 0 to 9 using for loop*/

Sevseg.setNumber (i);
Sevseg.refreshDisplay (); /*Aggiorna il display a sette segmenti dopo ogni iterazione*/
ritardo (1000); /*Ritardo del tempo per l'iterazione del ciclo*/

Codice avviato chiamando il Sevseg biblioteca. Dopo di che abbiamo definito il numero di segmenti, stiamo usando con ESP32. I pin di segmento a LED sono definiti per le schede ESP32. Cambia il pin in base al tipo di ESP32 che stai usando.

È possibile utilizzare uno qualsiasi dei pin digitali ESP32.

Successivamente, poiché stiamo usando il tipo di anodo comune, quindi l'abbiamo definito all'interno del codice.

In caso di catodo comune sostituirlo con il codice sotto:

Alla fine a per Viene utilizzato loop che visualizzerà le cifre da 0 a 9 e aggiorna il display ogni volta che viene visualizzato un numero:

6.2: output

Possiamo vedere sette segmenti che mostrano numeri a partire da 0 a 9:

7: Controlla sette segmenti senza usare la libreria con ESP32

Per controllare i sette segmenti senza alcuna libreria dobbiamo definire manualmente i numeri all'interno del codice Arduino nella loro rappresentazione binaria.

7.1: codice

Apri IDE e Connetti ESP32. Dopo questo caricamento il codice a sette segmenti dato su ESP32:

int segppins [] = 15, 2, 4, 5, 18, 19, 21;/*ESP32 PIN per sette segmenti*/
byte segcode [10] [7] = /*array di numero 0-9 in ordine da a di g* /
// a b c d e f g
0, 0, 0, 0, 0, 0, 1, /*Display 0* /
1, 0, 0, 1, 1, 1, 1, /*display 1* /
0, 0, 1, 0, 0, 1, 0, /*Display 2* /
0, 0, 0, 0, 1, 1, 0, /*Display 3* /
1, 0, 0, 1, 1, 0, 0, /*Display 4* /
0, 1, 0, 0, 1, 0, 0,, /*Display 5* /
0, 1, 0, 0, 0, 0, 0, /*Display 6* /
0, 0, 0, 1, 1, 1, 1, /*Display 7* /
0, 0, 0, 0, 0, 0, 0, /*Display 8* /
0, 0, 0, 0, 1, 0, 0, /*Display 9* /
;
void DisplayDigit (int cifra) /*funzione per inizializzare ciascun segmento* /

per (int a = 0; a < 7; a++)

DigitalWrite (Segpins [A], SegCode [Digit] [A]);/ * Istruendo i rispettivi segmenti per i numeri da 0 a 9 */


void setup ()

per (int a = 0; a < 7; a++) // for loop for setting the pins as output*/

pinMode (Segpins [A], output);


void loop ()

per (int b = 0; b < 10; b++)/* generating numbers from 0 to 9 */

DisplayDigit (b);/*Visualizza i numeri generati*/
ritardo (1000);

Nel codice sopra prima abbiamo definito i pin digitali per ESP32 dove saranno collegati sette segmenti. Un array viene inizializzato per definire il numero da 0 a 9.

Successivamente all'interno dell'array tutte le 10 cifre a partire da 0 a 9 sono definite nella loro rappresentazione binaria.

Prossimo in void setup () La parte A per loop è definita. Questo per loop con l'aiuto di pinmode La funzione imposta i pin a sette segmenti come output.

Finalmente in vuoto ciclo continuo() Funzione è definita un altro loop che genererà un numero da 0 a 9 ogni volta che il programma esegue.

7.2: output

Qui possiamo vedere tutti i numeri definiti all'interno del codice usando il loro equivalente binario sono visualizzati su sette segamenti:

Conclusione

In conclusione, l'interfaccia di un display a sette segmenti con un microcontrollore ESP32 è un semplice processo che può essere fatto con alcuni materiali di base e un po 'di conoscenza della programmazione. Con un codice ESP32 e Arduino, è possibile controllare facilmente lo stato di ogni segmento in un display a sette segmenti, consentendo la creazione di display numerici personalizzati e altri progetti interattivi.