In questo articolo ti mostrerò come funziona il driver LED a 7 segmenti TM1638 e come collegarlo a un Arduino UNO.
Ho utilizzato il driver LED TM1638 in progetti precedenti, poiché alleggerisce notevolmente il carico di lavoro del microcontrollore principale. Aggiungere il driver LED al tuo progetto è facile e semplice.
Inizierò illustrandoti le specifiche del driver LED, condividendo consigli e trucchi, e mostrandoti come visualizzare cifre e scansionare i pulsanti.
Successivamente entreremo più nel dettaglio con la guida di collegamento e il codice Arduino per l’interfaccia dati parallela LCD del driver TM1638. Risponderemo anche alle domande frequenti.
Prendi la tua scheda Arduino e iniziamo!
Componenti necessari per costruire il progetto Arduino e TM1638
Componenti hardware
- Arduino UNO x 1
- Arduino Compatible TM1638 display module x 1
- Dupont wire x 1 set
- USB Cable for Arduino Programming x 1
Software
Fondamenti del modulo driver LED TM1638
Comprendiamo prima le caratteristiche principali del driver LED TM1638:
- Controlla 8 cifre (7 segmenti)
- Gestisce 8 LED
- Scansiona otto interruttori tattili
- Puoi controllare la luminosità
- Interfaccia seriale – CLK, DIO, STB
Una tipica connessione tra Arduino e il driver TM1638 è mostrata nell’immagine sottostante.
Nella sezione successiva vedremo le interfacce tra le varie periferiche e il TM1638.
Dettagli dei pin del driver LED TM1638
| Nome pin | Tipo pin | Descrizione pin |
| DIO | Ingresso/uscita dati | Dati seriali tra Arduino e il driver TM1638 |
| STB | Selezione chip | Inizializza l’interfaccia seriale durante il fronte di discesa/salita, quindi riceve l’istruzione. Il primo byte è l’istruzione quando STB è basso. CLK viene ignorato quando STB è alto. |
| CLK | Ingresso clock | Ingresso dati seriali |
| K1 ~ K3 | Ingresso dati scansione tasti | I dati inseriti in questo pin vengono memorizzati dopo la chiusura del ciclo di visualizzazione. |
| SEG1/KS1 ~ SEG8/KS8 | Uscita (segmento) | Uscita segmento. Open drain. |
| SEG9 ~ SEG10 | Uscita (segmento) | Uscita segmento. Open drain. |
| GRID1 ~ GRID8 | Uscita (griglia) | Uscita griglia. Open drain. |
| VDD | Alimentazione logica | 5 V ± 10% |
| GND | Massa logica | Connessioni a massa |
Una nota speciale sul pin DIO: Il pin Digital-Input-Output (DIO) nel modulo TM1638 è un N-type open drain. Devi fornire un pull-up esterno per portare la linea DIO a livello logico alto. Il valore consigliato è 10 kOhm. Vedi circuito sotto:
Scansione tasti e registro dati scansione tasti
Il frame di scansione tasti è 8 x 3 bit. È simile a righe e colonne. Puoi considerarlo come una matrice di otto righe e tre colonne. Significa che puoi usare fino a 24 pulsanti.
Nell’immagine sottostante puoi vedere come utilizzare i pin K e KS del chip TM1638 per scansionare 24 pulsanti
Set di istruzioni
Puoi usare i bit B7 e B6 del bit DIO per decidere il tipo di istruzione. Il TM1638 usa il seguente meccanismo di decodifica per identificare il tipo di istruzione inviata da Arduino.
| B7 | B6 | Istruzione |
| 0 | 1 | Set di istruzioni dati |
| 1 | 0 | Set di istruzioni controllo display |
| 1 | 1 | Set di istruzioni indirizzo |
Set di istruzioni dati .
Tipicamente userai principalmente il set di istruzioni dati. È responsabile della lettura e scrittura dei dati. Nota: B1 e B0 non devono essere impostati su 01 o 11 per questo set di istruzioni.
| B7 | B6 | B5 | B4 | B3 | B2 | B1 | B0 | Funzione | Istruzione |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Impostazione modalità scrittura dati | Scrivi dati nel registro |
| 0 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | Leggi dati scansione tasti | |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Impostazione modalità aggiunta indirizzo | Aggiunta automatica indirizzo |
| 0 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | Indirizzo fisso | |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Modalità test | Modalità normale |
| 0 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | Modalità test |
Nelle immagini sottostanti puoi vedere il timing e il pattern di clock sia per la scrittura che per la lettura dal chip TM1638.
Nota che quando leggi i dati dal chip, devi inserire almeno un ritardo di 1 us tra l’istruzione e la ricezione dei dati. Questo è obbligatorio.
Per sapere come collegare i pin del display TM1638 al display LED a 7 segmenti, fai riferimento all’immagine sottostante. L’esempio è per il tipo a catodo comune, in cui tutti i pin catodo dei LED sono collegati insieme.
Un’alternativa è il tipo anodo comune, dove tutti i pin anodo dei LED sono collegati insieme.
È importante conoscere le specifiche elettriche del chip con cui lavori. Ti aiuterà nel debug e a evitare di danneggiare il chip. Più conosci le specifiche dell’IC, più sarà facile fare collegamenti e costruire circuiti affidabili.
Di seguito le specifiche elettriche del driver LED TM1638:
| Parametro | Intervallo |
| Tensione alimentazione logica | Tipica 5 V |
| Tensione ingresso alto livello | Minimo 0,7 x VDD |
| Tensione ingresso basso livello | Massimo 0,3 x VDD |
| Corrente uscita alto livello | Massima 40 mA |
| Corrente uscita basso livello | Massima 140 mA |
| Consumo corrente attivo | Massimo 5 mA |
| Frequenza clock massima | 1 MHz |
| Capacità ingresso | 15 pF |
Basta con le basi ; ) Nelle prossime sezioni costruiamo il progetto!
Come collegare il TM1638 all’Arduino UNO
Ora ti mostrerò come costruire un progetto usando Arduino UNO e il modulo display TM1638. Iniziamo con i collegamenti hardware.
Ecco un riepilogo dei collegamenti necessari per connettere Arduino UNO al modulo TM1638. Spero dia una panoramica generale. Segui la guida per i dettagli.
| Pin sul modulo TM1638 | Pin Arduino UNO | Note |
| VCC | 5 V | Alimentazione |
| GND | GND | Connessioni a massa |
| STB | Linea strobe, pin 8 | Qualsiasi pin IO |
| CLK | Linea dati, pin 9 | Qualsiasi pin IO |
| DIO | Linea clock, pin 10 | Qualsiasi pin IO |
Passo 1: Completa il collegamento tra TM1638 e Arduino UNO
Ecco lo schema di collegamento tra Arduino UNO e il chip TM1638.
I dati seriali usano solo due fili. Questo ti aiuta a risparmiare pin sulla scheda e riduce il numero di fili.
Il protocollo seriale usato dal TM1638 non è uno standard. Ma non preoccuparti, ci sono ottime librerie che puoi usare! Puoi trovare una di queste librerie here.
Ricorda sempre di iniziare con le connessioni a massa. Aspetta ad alimentare il progetto finché tutti i collegamenti non sono fatti.
Passo 2: Programma il codice Arduino UNO qui sotto
Segui il passo successivo per capire l’implementazione del codice. Puoi usare il codice qui sotto per testare il modulo TM1638. Non usiamo librerie in questo esempio.
const int strobe = 8; // STB to D8
const int clock = 9; // CLK to D9
const int data = 10; // DIO to D10
void sendCommand(uint8_t value)
{
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, value);
digitalWrite(strobe, HIGH);
}
void reset()
{
sendCommand(0x40); // Set auto increment mode
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xc0); // Set starting address to 0
for (uint8_t i = 0; i < 16; i++)
{
shiftOut(data, clock, LSBFIRST, 0x00);
}
digitalWrite(strobe, HIGH);
}
void setup()
{
pinMode(strobe, OUTPUT);
pinMode(clock, OUTPUT);
pinMode(data, OUTPUT);
sendCommand(0x8f); // Set maximum display brightness
reset();
}
#define COUNTING_MODE 0
#define SCROLL_MODE 1
#define BUTTON_MODE 2
void loop()
{
static uint8_t mode = COUNTING_MODE;
switch (mode)
{
case COUNTING_MODE:
mode += counting();
delay(500);
break;
case SCROLL_MODE:
mode += scroll();
break;
case BUTTON_MODE:
buttons();
break;
}
delay(200);
}
bool counting()
{
/*0*/ /*1*/ /*2*/ /*3*/ /*4*/ /*5*/ /*6*/ /*7*/ /*8*/ /*9*/
uint8_t digits[] = { 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f };
static uint8_t digit = 0;
sendCommand(0x40);
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xc0);
for (uint8_t position = 0; position < 8; position++)
{
shiftOut(data, clock, LSBFIRST, digits[digit]);
shiftOut(data, clock, LSBFIRST, 0x00);
}
digitalWrite(strobe, HIGH);
digit = ++digit % 10;
return digit == 0;
}
bool scroll()
{
uint8_t scrollText[] =
{
/* */ /* */ /* */ /* */ /* */ /* */ /* */ /* */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/*H*/ /*E*/ /*L*/ /*L*/ /*O*/ /*.*/ /*.*/ /*.*/
0x76, 0x79, 0x38, 0x38, 0x3f, 0x80, 0x80, 0x80,
/* */ /* */ /* */ /* */ /* */ /* */ /* */ /* */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/*H*/ /*E*/ /*L*/ /*L*/ /*O*/ /*.*/ /*.*/ /*.*/
0x76, 0x79, 0x38, 0x38, 0x3f, 0x80, 0x80, 0x80,
};
static uint8_t index = 0;
uint8_t scrollLength = sizeof(scrollText);
sendCommand(0x40);
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xc0);
for (int i = 0; i < 8; i++)
{
uint8_t c = scrollText[(index + i) % scrollLength];
shiftOut(data, clock, LSBFIRST, c);
shiftOut(data, clock, LSBFIRST, c != 0 ? 1 : 0);
}
digitalWrite(strobe, HIGH);
index = ++index % (scrollLength << 1);
return index == 0;
}
void buttons()
{
uint8_t promptText[] =
{
/*P*/ /*r*/ /*E*/ /*S*/ /*S*/ /* */ /* */ /* */
0x73, 0x50, 0x79, 0x6d, 0x6d, 0x00, 0x00, 0x00,
/* */ /* */ /* */ /* */ /* */ /* */ /* */ /* */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/*b*/ /*u*/ /*t*/ /*t*/ /*o*/ /*n*/ /*S*/ /* */
0x7c, 0x1c, 0x78, 0x78, 0x5c, 0x54, 0x6d, 0x00,
/* */ /* */ /* */ /* */ /* */ /* */ /* */ /* */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static uint8_t block = 0;
uint8_t textStartPos = (block / 4) << 3;
for (uint8_t position = 0; position < 8; position++)
{
sendCommand(0x44);
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xC0 + (position << 1));
shiftOut(data, clock, LSBFIRST, promptText[textStartPos + position]);
digitalWrite(strobe, HIGH);
}
block = (block + 1) % 16;
uint8_t buttons = readButtons();
for (uint8_t position = 0; position < 8; position++)
{
uint8_t mask = 0x1 << position;
setLed(buttons & mask ? 1 : 0, position);
}
}
uint8_t readButtons(void)
{
uint8_t buttons = 0;
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0x42);
pinMode(data, INPUT);
for (uint8_t i = 0; i < 4; i++)
{
uint8_t v = shiftIn(data, clock, LSBFIRST) << i;
buttons |= v;
}
pinMode(data, OUTPUT);
digitalWrite(strobe, HIGH);
return buttons;
}
void setLed(uint8_t value, uint8_t position)
{
pinMode(data, OUTPUT);
sendCommand(0x44);
digitalWrite(strobe, LOW);
shiftOut(data, clock, LSBFIRST, 0xC1 + (position << 1));
shiftOut(data, clock, LSBFIRST, value);
digitalWrite(strobe, HIGH);
}
Passo 3: Analisi del codice
Esaminiamo il codice.
const int strobe = 8; // STB to D8 const int clock = 9; // CLK to D9 const int data = 10; // DIO to D10
strobe, clock e data sono costanti che rappresentano i PIN collegati ai pin STB, CLK e DIO del modulo display.
void sendCommand(uint8_t value)
Questa funzione invia un comando al modulo display. Imposta il pin STB basso, invia il byte comando usando la funzione shiftOut() e poi imposta il pin STB alto.
void reset()
Questa funzione resetta il modulo display al suo stato iniziale.
Chiama sendCommand() per impostare la modalità auto-incremento e resettare l’indirizzo iniziale. Poi usa un ciclo per inviare 16 byte di valore 0x00 per pulire il display.
La funzione setup() esegue le seguenti operazioni una volta:
Imposta le modalità dei pin STB, CLK e DIO. Chiama sendCommand() per attivare il display con luminosità massima. Infine chiama reset() per inizializzare il display.
La funzione loop() viene chiamata ripetutamente dopo setup(). È il ciclo principale del programma che gira continuamente. Usa una variabile statica mode per tenere traccia della modalità corrente.
void loop()
Usa un’istruzione switch per eseguire azioni diverse in base alla modalità corrente:
COUNTING_MODE chiama la funzione counting() e incrementa la modalità quando il contatore raggiunge una certa condizione.
SCROLL_MODE chiama la funzione scroll() e incrementa la modalità quando lo scorrimento raggiunge una certa condizione.
BUTTON_MODE chiama la funzione buttons() per gestire gli input dei pulsanti.
Include ritardi tra le azioni. Spero sia utile.
Domande frequenti sul driver LED TM1638
Di seguito trovi una lista delle domande più frequenti sui progetti con Arduino UNO e il driver LED TM1638.
Se hai altre domande, scrivile nei commenti.
Cos’è un modulo display TM1638?
Il modulo display TM1638 è una scelta popolare per gli hobbisti per interfacciarsi con display LED, pulsanti e altre periferiche. Integra un controller display e uno scanner per tastiera, facilitando il controllo e l’interazione con vari input e output.
Come comunica il modulo display TM1638 con un microcontrollore?
Il modulo TM1638 comunica con un microcontrollore usando un semplice protocollo di comunicazione seriale.
Per inviare e ricevere dati servono tre linee di controllo (dati, clock e strobe). Consulta la sezione basi dell’articolo per capire in dettaglio il protocollo di comunicazione.
Quali sono le principali caratteristiche del modulo display TM1638?
Il modulo TM1638 offre tipicamente otto display LED a 7 segmenti, un set di indicatori LED e diversi pulsanti tattili. Fornisce anche controllo della luminosità e supporta il multiplexing per ridurre i pin I/O necessari.
Posso controllare più moduli TM1638 con un solo microcontrollore?
È possibile controllare più moduli TM1638 con un solo microcontrollore. Ogni modulo può avere un indirizzo unico tramite indirizzamento hardware, permettendo il controllo individuale in configurazioni multi-modulo.
Quali microcontrollori sono compatibili con il modulo display TM1638?
Il modulo TM1638 può essere interfacciato con vari microcontrollori, inclusi Arduino, Raspberry Pi ed ESP8266. Finché il microcontrollore supporta I/O digitale e comunicazione seriale, può essere usato con il modulo.
Un aspetto importante è assicurarsi della compatibilità di tensione tra microcontrollore e modulo TM1638.
Esistono librerie per programmare il modulo display TM1638?
Sì, sono disponibili varie librerie per diverse piattaforme e linguaggi di programmazione per semplificare l’integrazione del modulo TM1638.
Queste librerie offrono funzioni e astrazioni per controllare il display, leggere gli input dei pulsanti e gestire altre funzionalità del modulo. Consulta la sezione Codice Arduino per trovare librerie utili.
Posso usare il modulo display TM1638 per progetti diversi dalla visualizzazione principale e input pulsanti?
Assolutamente! Il modulo TM1638 è versatile e può essere usato oltre la visualizzazione e i pulsanti per molti progetti.
Conclusione
Questo articolo ha coperto tutte le informazioni essenziali sull’uso del TM1638 con Arduino UNO.
L’articolo è stato facile da seguire? Se hai suggerimenti per migliorarlo, sei sempre benvenuto a condividerli.
Mi piacerebbe avere tue notizie! Facci sapere se c’è altro che vorresti che trattassi in futuri articoli.
