Interfaccia display a sette segmenti con Arduino Nano

Arduino Nano è 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. Usando un microcontrollore Arduino Nano, è 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 anodo comune a sette segmenti è un anodo comune o un catodo comune
• 5: interfacciamento a sette segmenti con Arduino Nano
• 5.1: schema
• 5.2: hardware
• 5.3: installazione della libreria richiesta
• 6: Controlla a sette segmenti usando la libreria con Arduino Nano
• 6.1: codice
• 6.2: output
• 7: Controlla sette segmenti senza usare la libreria Arduino Nano
• 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 Arduino per controllare un display a sette segmenti, l'Arduino invia segnali ai pin specifici sul display a sette segmenti, dicendole quali segmenti si accendono o spegne.

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.

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

4: come controllare un anodo comune a sette segmenti è 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 dei segmenti si illumina, 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: interfacciamento a sette segmenti con Arduino Nano

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

• Un microcontrollore Arduino Nano
• Un display a sette segmenti
• Una breadboard
• Fili jumper

Arduino Nano 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'Arduino Nano 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 Arduino Nano, 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 Arduino Nano. Utilizzando lo schema di riferimento seguente collega la scheda Arduino Nano con un display a sette segmenti.

Seguendo la tabella di pinout per la connessione Arduino Nano con un singolo display a sette segmenti:

Codice PIN	Nome PIN	Arduino Nano Pin
1	B	D3
2	UN	D2
3	Com	GND/VCC dipende dalla configurazione - catodo/anodo comune
4	F	D7
5	G	D8
6	dp	PIN LED DOT
7	C	D4
8	Com	GND/VCC dipende dalla configurazione - catodo/anodo comune
9	D	D5
10	e	D6

5.2: hardware

L'immagine sotto mostra l'hardware di Arduino Nano 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 Arduino Nano con sette segmenti. Vai alla ricerca di Biblioteca Manager Sevseg libreria e installalo in Arduino IDE:

6: Controlla a sette segmenti usando la libreria con Arduino Nano

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

6.1: codice

Apri l'IDE e carica il codice dato su Arduino Nano:

#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 [] = 2, 3, 4, 5, 6, 7, 8; /*Definisci pin digitali Arduino 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. Dopodiché abbiamo definito il numero di segmenti che stiamo usando con Arduino Nano. I pin di segmento a LED sono definiti per le schede Arduino Nano. Cambia il pin in base al tipo di nano Arduino che stai usando.

È possibile utilizzare uno qualsiasi dei pin digitali Arduino Nano. Successivamente come stiamo usando il Anodo comune Digita, quindi l'abbiamo definito all'interno del codice:

In caso di Catodo comune Sostituilo 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 a sette segmenti senza usare la libreria con Arduino Nano

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 collega Arduino Nano. Dopo questo caricamento il codice a sette segmenti dato su Arduino Nano:

int segppins [] = 2, 3, 4, 5, 6, 7, 8;/*pin Arduino 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 Arduino Nano dove saranno collegati sette seggi. 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 nel void loop () Funzione è definito 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 in sette segamenti.

Conclusione

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