In questo tutorial imparerai come controllare i display TM1637 a 4 cifre e 7 segmenti con Arduino. Questi display sono fantastici per mostrare dati di sensori, temperatura, orario, ecc.
Ho incluso 3 esempi in questo tutorial. Nel primo esempio vedremo le funzioni base della libreria TM1637Display. Nel secondo esempio ti mostrerò come visualizzare l’ora su un display a 4 cifre. L’ultimo esempio può essere usato per creare un semplice termometro in combinazione con il DHT11.
Materiale necessario
Componenti hardware
Software
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Informazioni sul display
I display a 4 cifre e 7 segmenti nudi richiedono solitamente 12 pin di connessione. Sono parecchi e non lasciano molto spazio per altri sensori o moduli. Grazie al circuito integrato TM1637 montato sul retro del modulo display, questo numero si riduce a soli quattro. Due pin servono per l’alimentazione e gli altri due per controllare i segmenti.
I display a 7 segmenti contengono 7 (o 8) LED indirizzabili singolarmente. I segmenti sono etichettati da A a G e alcuni display hanno anche un punto (l’8° LED). Usa questa immagine come riferimento per impostare i singoli segmenti nel codice più avanti.
Puoi acquistare molti moduli display diversi che usano un circuito TM1637. Colore, dimensioni, punti e punti di connessione possono variare. Non ho esperienza con tutte le versioni di questo display, ma finché usano il TM1637, gli esempi di codice forniti dovrebbero funzionare.
Qui trovi le specifiche base del modulo display che ho usato in questo tutorial.
Specifiche del display TM1637 4 cifre 7 segmenti
| Tensione di funzionamento | 3.3 – 5 V |
| Assorbimento di corrente | 80 mA |
| Livelli di luminosità | 8 |
| Dimensioni del display | 30 x 14 mm (cifre da 0,36″) |
| Dimensioni complessive | 42 x 24 x 12 mm |
| Dimensioni dei fori | 38 x 20, ⌀ 2.2 mm |
| Temperatura di funzionamento | -10 – 80 °C |
| Costo | Check price |
Il circuito TM1637 è prodotto da Titan Micro Electronics. Per maggiori informazioni, puoi consultare il datasheet qui sotto:
Collegamenti – Connettere il display TM1637 4 cifre 7 segmenti ad Arduino UNO
Collegare il display ad Arduino o ad un altro microcontrollore è molto semplice. Devi collegare solo 4 fili: 2 per l’alimentazione e 2 per trasferire i dati.
Lo schema di collegamento qui sotto mostra come connettere il display ad Arduino.
I collegamenti sono anche indicati nella tabella qui sotto:
Collegamenti display TM1637
| Display TM1637 4 cifre | Arduino |
|---|---|
| VCC | 5 V |
| GND | GND |
| CLK | Pin digitale 2 |
| DIO | Pin digitale 3 |
Nota che l’ordine e la posizione dei pin possono variare a seconda del produttore!
Per questo tutorial ho collegato CLK e DIO ai pin 2 e 3 rispettivamente, ma puoi cambiare questi pin con qualsiasi pin digitale tu voglia. Devi solo modificare la configurazione dei pin nel codice di conseguenza.
Esempio di codice Arduino per display TM1637 4 cifre 7 segmenti
Avishay Orpaz ha scritto un’ottima libreria per i display TM1637, la TM1637Display library. Questa libreria include diverse funzioni integrate che rendono abbastanza semplice il controllo del display.
Le funzioni principali includono:
- setSegments() – Imposta il valore grezzo dei segmenti di ogni cifra
- showNumberDec() – Visualizza un numero decimale
- showNumberDecEx() – Visualizza un numero decimale con punti decimali o due punti
- setBrightness() – Imposta la luminosità del display
- clear() – Pulisce il display
L’esempio di codice qui sotto include tutte queste funzioni. Spiegherò come usare ciascuna funzione più in dettaglio.
Puoi caricare l’esempio di codice sul tuo Arduino usando l’IDE Arduino.
Per installare la libreria, puoi scaricarla come file .zip da Github. Poi vai su Sketch > Include Library > Add .ZIP Library… nell’IDE Arduino.
Un’altra opzione è andare su Tools > Manage Libraries… oppure premere Ctrl + Shift + I su Windows. Si aprirà il Library Manager che aggiornerà la lista delle librerie installate.
Puoi cercare ‘tm1637’ e trovare la libreria di Avishay Orpaz. Seleziona l’ultima versione e clicca su Install.
Esempio di codice
Puoi copiare il codice cliccando il pulsante in alto a destra nel campo del codice.
/* Example code for TM1637 4 digit 7 segment display with Arduino.
www.www.makerguides.com */
// Include the library:
#include "TM1637Display.h"
// Define the connections pins:
#define CLK 2
#define DIO 3
// Create display object of type TM1637Display:
TM1637Display display = TM1637Display(CLK, DIO);
// Create array that turns all segments on:
const uint8_t data[] = {0xff, 0xff, 0xff, 0xff};
// Create array that turns all segments off:
const uint8_t blank[] = {0x00, 0x00, 0x00, 0x00};
// You can set the individual segments per digit to spell words or create other symbols:
const uint8_t done[] = {
SEG_B | SEG_C | SEG_D | SEG_E | SEG_G, // d
SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F, // O
SEG_C | SEG_E | SEG_G, // n
SEG_A | SEG_D | SEG_E | SEG_F | SEG_G // E
};
// Create degree Celsius symbol:
const uint8_t celsius[] = {
SEG_A | SEG_B | SEG_F | SEG_G, // Circle
SEG_A | SEG_D | SEG_E | SEG_F // C
};
void setup() {
// Clear the display:
display.clear();
delay(1000);
}
void loop() {
// Set the brightness:
display.setBrightness(7);
// All segments on:
display.setSegments(data);
delay(1000);
display.clear();
delay(1000);
// Show counter:
int i;
for (i = 0; i < 101; i++) {
display.showNumberDec(i);
delay(50);
}
delay(1000);
display.clear();
delay(1000);
// Print number in different locations, loops 2 times:
int j;
for (j = 0; j < 2; j++) {
for (i = 0; i < 4; i++) {
display.showNumberDec(i, false, 1, i);
delay(500);
display.clear();
}
}
delay(1000);
display.clear();
delay(1000);
// Set brightness (0-7):
int k;
for (k = 0; k < 8; k++) {
display.setBrightness(k);
display.setSegments(data);
delay(500);
}
delay(1000);
display.clear();
delay(1000);
// Print 1234 with the center colon:
display.showNumberDecEx(1234, 0b11100000, false, 4, 0);
delay(1000);
display.clear();
delay(1000);
int temperature = 24;
display.showNumberDec(temperature, false, 2, 0);
display.setSegments(celsius, 2, 2);
delay(1000);
display.clear();
delay(1000);
display.setSegments(done);
while(1);
}
Come funziona il codice:
Il codice inizia includendo la libreria. Assicurati di avere la libreria corretta installata, altrimenti riceverai un messaggio di errore durante la compilazione.
// Include the library: #include "TM1637Display.h"
Il passo successivo è specificare i pin di connessione. L’istruzione #define viene usata per dare un nome a un valore costante. Il compilatore sostituirà ogni riferimento a questa costante con il valore definito quando il programma viene compilato. Quindi ovunque menzioni CLK, il compilatore lo sostituirà con il valore 2 durante la compilazione.
// Define the connections pins: #define CLK 2 #define DIO 3
Inizializza il display
Poi creiamo un oggetto display di tipo TM1637Display con i pin CLK e DIO definiti. Nota che ho chiamato il display ‘display’, ma puoi usare altri nomi come ‘temperature_display’.
Il nome che dai al display sarà usato più avanti per scrivere dati a quel display specifico. Puoi creare e controllare più oggetti display con nomi e pin di connessione diversi. Attualmente non c’è un limite nella libreria.
// Create display object of type TM1637Display: TM1637Display display = TM1637Display(CLK, DIO); // You can create more than one display object. Give them different names and connection pins: TM1637Display display_1 = TM1637Display(2, 3); TM1637Display display_2 = TM1637Display(4, 5); TM1637Display display_3 = TM1637Display(6, 7);
Ci sono diversi modi per controllare i singoli segmenti del display. Prima della sezione setup del codice, ho specificato diversi array per impostare i singoli segmenti del display. Useremo la funzione setSegments() più avanti per scriverli sul display.
La prima opzione è scrivere numeri esadecimali sul display per ogni cifra. L’esadecimale 0xff corrisponde a 11111111 in binario, questo accende tutti i segmenti (incluso il punto se il tuo display ce l’ha). 0xef per esempio corrisponde a 11101111. Questo accenderebbe tutti i segmenti tranne il segmento E. Nota che il conteggio va da destra a sinistra, quindi 11111111 corrisponde ai segmenti (punto)GFEDCBA.
// Create array that turns all segments on:
const uint8_t data[] = {0xff, 0xff, 0xff, 0xff};
// Create array that turns all segments off:
const uint8_t blank[] = {0x00, 0x00, 0x00, 0x00};
La libreria ha una funzione integrata che rende più semplice impostare i singoli segmenti. Vedi il frammento di codice qui sotto. Puoi creare array per scrivere parole. Ogni segmento è separato da | e le cifre del display sono separate da una virgola.
// You can set the individual segments per digit to spell words or create other symbols:
const uint8_t done[] = {
SEG_B | SEG_C | SEG_D | SEG_E | SEG_G, // d
SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F, // O
SEG_C | SEG_E | SEG_G, // n
SEG_A | SEG_D | SEG_E | SEG_F | SEG_G // E
};
Funzione setup
Puoi lasciare vuota la sezione setup del codice se vuoi. Io ho usato la funzione clear() per assicurarmi che il display fosse pulito.
void setup() {
// Clear the display:
display.clear();
delay(1000);
}
Funzione loop
Nella sezione loop del codice mostro diversi esempi delle varie funzioni della libreria:
setSegments(segments[ ], length, position)
Questa funzione può essere usata per impostare i singoli segmenti del display. Il primo argomento è l’array che contiene le informazioni sui segmenti. Il secondo argomento specifica il numero di cifre da modificare (0-4). Se vuoi scrivere dOnE, questo sarà 4, per un simbolo °C sarà 2. Il terzo argomento imposta la posizione da cui iniziare a stampare (0 – più a sinistra, 3 – più a destra). Quindi se vuoi stampare un simbolo °C sulla terza e quarta cifra, useresti:
// Create degree Celsius symbol:
const uint8_t celsius[] = {
SEG_A | SEG_B | SEG_F | SEG_G, // Circle
SEG_A | SEG_D | SEG_E | SEG_F // C
};
display.setSegments(celsius, 2, 2);
Il secondo e terzo argomento della funzione possono anche essere omessi.
showNumberDec(number, leading_zeros, length, position)
Questa è probabilmente la funzione che userai di più. Il primo argomento è un numero che vuoi visualizzare sullo schermo. Gli altri argomenti sono opzionali.
Il secondo argomento può essere usato per attivare o disattivare gli zeri iniziali. 10 senza zeri iniziali si stampa come __10 e con zeri iniziali come 0010. Puoi attivarli impostando questo argomento a true o disattivarli impostandolo a false. NOTA: gli zeri iniziali non sono supportati con numeri negativi.
Il terzo e quarto argomento sono uguali a quelli della funzione precedente.
// Print the number 12 without leading zeros on the second and third digit: display.showNumberDec(12, false, 2, 1);
showNumberDecEx(number, dots, leading_zeros, length, position)
Questa funzione ti permette di controllare i punti del display. Solo il secondo argomento è diverso dalla funzione showNumberDec. Ti permette di impostare i punti tra le singole cifre.
Puoi usare i seguenti valori.
Per display con punti tra ogni cifra usa
- 0b10000000 – 0.000
- 0b01000000 – 00.00
- 0b00100000 – 000.0
- 0b11100000 – 0.0.0.0
per display con solo due punti usa
- 0b01000000 – 00:00
e per display con punti e due punti usa
- 0b11100000 – 0.0:0.0
Quindi se vuoi visualizzare un orologio con i due punti centrali accesi (vedi esempio orologio sotto), useresti qualcosa come:
// Print 1234 with the center colon: display.showNumberDecEx(1234, 0b11100000, false, 4, 0);
setBrightness(brightness, true/false)
Questa funzione imposta la luminosità del display (come suggerisce il nome). Puoi specificare un livello di luminosità da 0 (minima luminosità) a 7 (massima luminosità). Il secondo parametro può essere usato per accendere o spegnere il display, false significa spento.
// Set the display brightness (0-7): display.setBrightness(7);
Esempio orologio: display TM1637 4 cifre 7 segmenti con RTC DS3231
Uno degli usi tipici di un display 4 cifre 7 segmenti è mostrare l’ora. Combinando il TM1637 con un modulo orologio in tempo reale (RTC), puoi facilmente creare un orologio 24 ore.
In questo esempio ho usato questo comune DS3231 RTC module. Questo modulo comunica con Arduino via I2C, quindi servono solo due collegamenti per leggere l’ora.
Lo schema di collegamento qui sotto mostra come connettere il DS3231 RTC ad Arduino. Nota che il display TM1637 è collegato come prima.
I collegamenti sono anche indicati nella tabella qui sotto:
Collegamenti DS3231 RTC
| DS3231 | Arduino |
|---|---|
| VCC | 5 V |
| GND | GND |
| SDA | A4 |
| SCL | A5 |
Il codice di esempio seguente può essere usato per visualizzare l’ora in formato 24 ore. Se il tuo display ha i due punti centrali, questo codice li farà lampeggiare. Puoi anche disabilitare questa funzione rimuovendo le ultime righe di codice.
La prima volta che carichi il codice, l’RTC sarà impostato all’ora in cui lo sketch è stato compilato.
Puoi installare una batteria a bottone sul retro del modulo, così l’ora viene mantenuta in caso di mancanza di alimentazione. A quanto pare il circuito di carica della maggior parte dei moduli cinesi può sovraccaricare la batteria a bottone (link), quindi potresti voler acquistare una DS3231 module da Adafruit invece.
Il codice usa la libreria RTC di Adafruit, che puoi scaricare da GitHub. Puoi anche installarla tramite il Library Manager nell’IDE Arduino cercando “RTClib”, oppure clicca il pulsante di download qui sotto:
Esempio di codice
/* Arduino example code to display a 24 hour time format clock on a
TM1637 4 digit 7 segment display with a DS32321 RTC.
www.www.makerguides.com */
// Include the libraries:
#include "RTClib.h"
#include "TM1637Display.h"
// Define the connections pins:
#define CLK 2
#define DIO 3
// Create rtc and display object:
RTC_DS3231 rtc;
TM1637Display display = TM1637Display(CLK, DIO);
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Wait for console opening:
delay(3000);
// Check if RTC is connected correctly:
if (!rtc.begin()) {
Serial.println("Couldn't find RTC");
while (1);
}
// Check if the RTC lost power and if so, set the time:
if (rtc.lostPower()) {
Serial.println("RTC lost power, lets set the time!");
// The following line sets the RTC to the date & time this sketch was compiled:
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
// This line sets the RTC with an explicit date & time, for example to set
// January 21, 2014 at 3am you would call:
//rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
}
// Set the display brightness (0-7):
display.setBrightness(5);
// Clear the display:
display.clear();
}
void loop() {
// Get current date and time:
DateTime now = rtc.now();
// Create time format to display:
int displaytime = (now.hour() * 100) + now.minute();
// Print displaytime to the Serial Monitor:
Serial.println(displaytime);
// Display the current time in 24 hour format with leading zeros enabled and a center colon:
display.showNumberDecEx(displaytime, 0b11100000, true);
// Remove the following lines of code if you want a static instead of a blinking center colon:
delay(1000);
display.showNumberDec(displaytime, true); // Prints displaytime without center colon.
delay(1000);
}
Esempio termometro: display TM1637 4 cifre 7 segmenti con sensore temperatura e umidità DHT11
I display 4 cifre 7 segmenti sono ottimi per mostrare letture di sensori come temperatura, umidità, tensione o velocità. Nel seguente esempio ti mostrerò come visualizzare la temperatura sul display TM1637.
Useremo il popolare DHT11 sensore di temperatura e umidità. Lo schema di collegamento qui sotto mostra come connettere il sensore DHT11 in combinazione con il display TM1637 ad Arduino.
Nota che il display TM1637 è collegato come prima.
I collegamenti sono anche indicati nella tabella qui sotto:
Collegamenti DHT11
| DHT11 | Arduino |
|---|---|
| + | 5 V |
| – | GND |
| s | Pin digitale 4 |
Nota che l’ordine dei pin può variare a seconda del produttore.
Se vuoi usare un sensore a 4 pin, dai un’occhiata al mio tutorial sui sensori di temperatura e umidità DHT11 e DHT22: How to use DHT11 and DHT22 Sensors with Arduino.
Il codice di esempio qui sotto può essere usato per visualizzare la temperatura sul display. Alterna la visualizzazione tra gradi Celsius e Fahrenheit, entrambi mostrati per 2 secondi.
La funzione setSegments() è usata per mostrare i simboli Celsius e Fahrenheit.
Il codice usa la libreria Adafruit DHT sensor library che puoi scaricare da GitHub. Questa libreria funziona solo se hai anche installato la libreria Adafruit Unified Sensor, anch’essa disponibile su GitHub.
Puoi anche scaricare le due librerie cliccando sui pulsanti qui sotto:
Esempio di codice
/* Arduino example sketch to display DHT11 temperature readings
on a TM1637 4-digit 7-segment display.
www.www.makerguides.com */
// Include the libraries:
#include "TM1637Display.h"
#include "Adafruit_Sensor.h"
#include "DHT.h"
// Define the connections pins:
#define CLK 2
#define DIO 3
#define DHTPIN 4
// Create variable:
int temperature_celsius;
int temperature_fahrenheit;
// Create degree Celsius symbol:
const uint8_t celsius[] = {
SEG_A | SEG_B | SEG_F | SEG_G, // Circle
SEG_A | SEG_D | SEG_E | SEG_F // C
};
// Create degree Fahrenheit symbol:
const uint8_t fahrenheit[] = {
SEG_A | SEG_B | SEG_F | SEG_G, // Circle
SEG_A | SEG_E | SEG_F | SEG_G // F
};
// Set DHT type, uncomment whatever type you're using!
#define DHTTYPE DHT11 // DHT 11
//#define DHTTYPE DHT22 // DHT 22 (AM2302)
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Create display object of type TM1637Display:
TM1637Display display = TM1637Display(CLK, DIO);
// Create dht object of type DHT:
DHT dht = DHT(DHTPIN, DHTTYPE);
void setup() {
// Set the display brightness (0-7):
display.setBrightness(0);
// Clear the display:
display.clear();
// Setup sensor:
dht.begin();
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Wait for console opening:
delay(2000);
}
void loop() {
// Read the temperature as Celsius and Fahrenheit:
temperature_celsius = dht.readTemperature();
temperature_fahrenheit = dht.readTemperature(true);
// Print the temperature to the Serial Monitor:
Serial.println(temperature_celsius);
Serial.println(temperature_fahrenheit);
// Show the temperature on the TM1637 display:
display.showNumberDec(temperature_celsius, false, 2, 0);
display.setSegments(celsius, 2, 2);
delay(2000);
display.showNumberDec(temperature_fahrenheit, false, 2, 0);
display.setSegments(fahrenheit, 2, 2);
delay(2000);
}
Conclusione
In questo articolo ti ho mostrato come usare un display TM1637 4 cifre 7 segmenti con Arduino. Abbiamo anche visto un esempio di orologio e uno di termometro.
Per altri tutorial sui display, vedi i nostri How to control a character I2C LCD with Arduino e How to use a 16×2 character LCD with Arduino tutorial.
Se hai domande, lascia un commento qui sotto.
