Tutoriel Arduino pour écran LED 7 segments 4 chiffres TM1637

Dans ce tutoriel, vous apprendrez comment contrôler des afficheurs 7 segments 4 chiffres TM1637 avec Arduino. Ces afficheurs sont parfaits pour afficher des données de capteurs, la température, l’heure, etc.

J’ai inclus 3 exemples dans ce tutoriel. Dans le premier exemple, nous verrons les fonctions de base de la bibliothèque TM1637Display. Dans le deuxième exemple, je vous montrerai comment afficher l’heure sur un afficheur 4 chiffres. Le dernier exemple peut être utilisé pour créer un simple affichage de température en combinaison avec le DHT11.

Fournitures

Composants matériels

	TM1637 4-digit 7-segment display	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Breadboard	× 1	Amazon
	Jumper wires	~ 10	Amazon
	DS3231 RTC	× 1	Amazon
	Adafruit DS3231 Precision RTC Breakout (alternative)	× 1	Amazon
	DHT11 temperature and humidity sensor (3 broches)	× 1	Amazon
	USB cable type A/B	× 1	Amazon

Logiciel

Arduino IDE

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.

Informations sur l’afficheur

Les afficheurs 7 segments 4 chiffres nus nécessitent généralement 12 broches de connexion. C’est assez nombreux et cela ne laisse pas beaucoup de place pour d’autres capteurs ou modules. Grâce au circuit intégré TM1637 monté à l’arrière du module d’affichage, ce nombre peut être réduit à seulement quatre. Deux broches sont nécessaires pour l’alimentation et les deux autres servent à contrôler les segments.

Les afficheurs 7 segments contiennent 7 (ou 8) LED adressables individuellement. Les segments sont étiquetés de A à G et certains afficheurs ont aussi un point (la 8ème LED). Utilisez cette image comme référence pour configurer les segments individuellement dans le code plus tard.

Vous pouvez acheter de nombreux modules d’affichage différents utilisant un circuit TM1637. La couleur, la taille, les points et les points de connexion peuvent varier. Je n’ai pas d’expérience avec toutes les versions de cet afficheur, mais tant qu’ils utilisent le TM1637, les exemples de code fournis ci-dessous devraient fonctionner.

Voici les spécifications de base du module d’affichage que j’ai utilisé dans ce tutoriel.

Spécifications de l’afficheur 7 segments 4 chiffres TM1637

Tension de fonctionnement	3,3 – 5 V
Consommation	80 mA
Niveaux de luminance	8
Dimensions de l’affichage	30 x 14 mm (chiffres de 0,36″)
Dimensions totales	42 x 24 x 12 mm
Dimensions des trous	38 x 20, ⌀ 2,2 mm
Température de fonctionnement	-10 – 80 °C
Coût	Check price

Le circuit TM1637 est fabriqué par Titan Micro Electronics. Pour plus d’informations, vous pouvez consulter la fiche technique ci-dessous :

Câblage – Connexion de l’afficheur 7 segments 4 chiffres TM1637 à Arduino UNO

Connecter l’afficheur à un Arduino ou autre microcontrôleur est très simple. Il suffit de connecter 4 fils : 2 pour l’alimentation et 2 pour transférer les données.

Le schéma de câblage ci-dessous montre comment connecter l’afficheur à l’Arduino.

Les connexions sont aussi indiquées dans le tableau ci-dessous :

Connexions de l’afficheur TM1637

Afficheur 4 chiffres TM1637	Arduino
VCC	5 V
GND	GND
CLK	Broche digitale 2
DIO	Broche digitale 3

Notez que l’ordre et l’emplacement des broches peuvent varier selon le fabricant !

Pour ce tutoriel, j’ai connecté CLK et DIO aux broches 2 et 3 respectivement, mais vous pouvez les changer pour n’importe quelles broches digitales. Il suffit d’adapter la configuration des broches dans le code en conséquence.

Exemple de code Arduino pour afficheur 7 segments 4 chiffres TM1637

Avishay Orpaz a écrit une excellente bibliothèque pour les afficheurs TM1637, la TM1637Display library. Cette bibliothèque comprend plusieurs fonctions intégrées qui facilitent le contrôle de l’afficheur.

Les fonctions principales incluent :

• setSegments() – Définit la valeur brute des segments de chaque chiffre
• showNumberDec() – Affiche un nombre décimal
• showNumberDecEx() – Affiche un nombre décimal avec points décimaux ou deux-points
• setBrightness() – Définit la luminosité de l’afficheur
• clear() – Efface l’afficheur

L’exemple de code ci-dessous utilise toutes ces fonctions. Je vous expliquerai plus en détail comment utiliser chacune d’elles.

Vous pouvez téléverser l’exemple de code sur votre Arduino avec l’IDE Arduino.

Pour installer la bibliothèque, vous pouvez la télécharger au format .zip depuis Github. Ensuite, allez dans Sketch > Include Library > Add .ZIP Library… dans l’IDE Arduino.

Une autre option est d’aller dans Tools > Manage Libraries… ou de taper Ctrl + Maj + I sous Windows. Le gestionnaire de bibliothèques s’ouvrira et mettra à jour la liste des bibliothèques installées.

Vous pouvez chercher ‘tm1637’ et trouver la bibliothèque d’Avishay Orpaz. Sélectionnez la dernière version puis cliquez sur Installer.

Exemple de code

Vous pouvez copier le code en cliquant sur le bouton en haut à droite du champ de code.

/* 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);
}

Comment fonctionne le code :

Le code commence par inclure la bibliothèque. Assurez-vous d’avoir la bonne bibliothèque installée, sinon vous aurez un message d’erreur lors de la compilation.

// Include the library:
#include "TM1637Display.h"

L’étape suivante est de spécifier les broches de connexion. L’instruction #define sert à donner un nom à une valeur constante. Le compilateur remplacera toute référence à cette constante par la valeur définie lors de la compilation du programme. Ainsi, partout où vous mentionnez CLK, le compilateur le remplacera par la valeur 2 lors de la compilation.

// Define the connections pins:
#define CLK 2
#define DIO 3

Initialiser l’afficheur

Ensuite, nous créons un objet d’affichage de type TM1637Display avec les broches CLK et DIO définies. Notez que j’ai appelé l’afficheur ‘display’, mais vous pouvez utiliser d’autres noms comme ‘temperature_display’.

Le nom que vous donnez à l’afficheur sera utilisé plus tard pour écrire des données sur cet afficheur particulier. Vous pouvez créer et contrôler plusieurs objets d’affichage avec des noms et broches différents. Il n’y a actuellement aucune limite dans la bibliothèque.

// 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);

Il existe plusieurs façons de contrôler les segments individuels de l’afficheur. Avant la section setup du code, j’ai défini plusieurs tableaux pour configurer les segments individuels. Nous utiliserons la fonction setSegments() plus tard pour les écrire sur l’afficheur.

La première option est d’écrire des nombres hexadécimaux sur l’afficheur pour chaque chiffre. L’hexadécimal 0xff correspond à 11111111 en binaire, ce qui allume tous les segments (y compris le point si votre afficheur en a un). 0xef par exemple correspond à 11101111. Cela allumerait tous les segments sauf le segment E. Notez que le comptage se fait de droite à gauche, donc 11111111 correspond aux segments (point)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 bibliothèque possède une fonction intégrée qui facilite la configuration des segments individuels. Voir l’extrait de code ci-dessous. Vous pouvez créer des tableaux pour écrire des mots. Chaque segment est séparé par un | et les chiffres de l’afficheur sont séparés par une virgule.

// 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
};

Fonction setup

Vous pouvez laisser la section setup vide si vous le souhaitez. J’ai juste utilisé la fonction clear() pour m’assurer que l’afficheur était effacé.

void setup() {
  // Clear the display:
  display.clear();
  delay(1000);
}

Fonction loop

Dans la section loop du code, je montre plusieurs exemples des différentes fonctions de la bibliothèque :

setSegments(segments[ ], length, position)

Cette fonction sert à définir les segments individuels de l’afficheur. Le premier argument est le tableau contenant les informations des segments. Le deuxième argument spécifie le nombre de chiffres à modifier (0-4). Si vous voulez écrire dOnE, ce sera 4, pour un symbole °C, ce sera 2. Le troisième argument définit la position de départ (0 – le plus à gauche, 3 – le plus à droite). Donc, si vous voulez afficher un symbole °C sur le troisième et quatrième chiffre, vous utiliseriez :

// 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);

Le deuxième et troisième argument de la fonction peuvent aussi être omis.

showNumberDec(number, leading_zeros, length, position)

C’est probablement la fonction que vous utiliserez le plus. Le premier argument est un nombre que vous voulez afficher à l’écran. Les autres arguments sont optionnels.

Le deuxième argument permet d’activer ou désactiver les zéros non significatifs. 10 sans zéros non significatifs s’affichera comme __10 et avec zéros non significatifs comme 0010. Vous pouvez les activer en mettant cet argument à true ou les désactiver en le mettant à false. NOTE : les zéros non significatifs ne sont pas supportés avec les nombres négatifs.

Le troisième et quatrième argument sont les mêmes que dans la fonction précédente.

// 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)

Cette fonction vous permet de contrôler les points de l’afficheur. Seul le deuxième argument diffère de la fonction showNumberDec. Il permet de définir les points entre les chiffres.

Vous pouvez utiliser les valeurs suivantes.

Pour les afficheurs avec des points entre chaque chiffre, utilisez

• 0b10000000 – 0.000
• 0b01000000 – 00.00
• 0b00100000 – 000.0
• 0b11100000 – 0.0.0.0

pour les afficheurs avec juste un deux-points, utilisez

• 0b01000000 – 00:00

et pour les afficheurs avec points et deux-points, utilisez

• 0b11100000 – 0.0:0.0

Donc, si vous voulez afficher une horloge avec le deux-points central allumé (voir exemple d’horloge ci-dessous), vous utiliseriez quelque chose comme :

// Print 1234 with the center colon:
display.showNumberDecEx(1234, 0b11100000, false, 4, 0);

setBrightness(brightness, true/false)

Cette fonction règle la luminosité de l’afficheur (comme son nom l’indique). Vous pouvez spécifier un niveau de luminosité de 0 (le plus faible) à 7 (le plus élevé). Le deuxième paramètre permet d’allumer ou d’éteindre l’afficheur, false signifie éteint.

// Set the display brightness (0-7):
display.setBrightness(7);

Exemple d’horloge : afficheur 7 segments 4 chiffres TM1637 avec RTC DS3231

Une des utilisations typiques d’un afficheur 7 segments 4 chiffres est d’afficher l’heure. En combinant le TM1637 avec un module horloge temps réel (RTC), vous pouvez facilement créer une horloge 24 heures.

Dans cet exemple, j’ai utilisé ce module couramment utilisé DS3231 RTC module. Ce module communique avec l’Arduino via I2C, donc vous n’avez besoin que de deux connexions pour lire l’heure.

Le schéma de câblage ci-dessous montre comment connecter le DS3231 RTC à l’Arduino. Notez que l’afficheur TM1637 est connecté de la même manière qu’avant.

Les connexions sont aussi indiquées dans le tableau ci-dessous :

Connexions DS3231 RTC

DS3231	Arduino
VCC	5 V
GND	GND
SDA	A4
SCL	A5

L’exemple de code suivant peut être utilisé pour afficher l’heure au format 24 heures. Si votre afficheur a un deux-points central, ce code le fera clignoter. Vous pouvez aussi désactiver cela en supprimant les dernières lignes du code.

La première fois que vous téléversez le code, le RTC sera réglé à l’heure de compilation du sketch.

Vous pouvez installer une pile bouton à l’arrière du module, pour que l’heure soit conservée en cas de coupure de courant. Apparemment, le circuit de charge de la plupart des modules chinois peut éventuellement surcharger la pile bouton (link), donc vous pourriez préférer acheter une DS3231 module chez Adafruit à la place.

Le code utilise la bibliothèque RTC Adafruit, que vous pouvez télécharger sur GitHub. Vous pouvez aussi l’installer via le gestionnaire de bibliothèques dans l’IDE Arduino en cherchant « RTClib », ou cliquer sur le bouton de téléchargement ci-dessous :

Exemple de code

/* 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);
}

Exemple de thermomètre : afficheur 7 segments 4 chiffres TM1637 avec capteur de température et humidité DHT11

Les afficheurs 7 segments 4 chiffres sont parfaits pour afficher des mesures de capteurs comme la température, l’humidité, la tension ou la vitesse. Dans l’exemple suivant, je vous montre comment afficher la température sur l’afficheur TM1637.

Nous utiliserons le populaire DHT11 capteur de température et d’humidité. Le schéma de câblage ci-dessous montre comment connecter le capteur DHT11 en combinaison avec l’afficheur TM1637 à l’Arduino.

Notez que l’afficheur TM1637 est connecté de la même manière qu’avant.

Les connexions sont aussi indiquées dans le tableau ci-dessous :

Connexions DHT11

DHT11	Arduino
+	5 V
–	GND
s	Broche digitale 4

Notez que l’ordre des broches peut varier selon le fabricant.

Si vous souhaitez utiliser un capteur 4 broches, consultez mon tutoriel pour les capteurs de température et humidité DHT11 et DHT22 : How to use DHT11 and DHT22 Sensors with Arduino.

Le code exemple ci-dessous peut être utilisé pour afficher les mesures de température sur l’afficheur. Il alterne entre la température en Celsius et Fahrenheit, chacune affichée pendant 2 secondes.

La fonction setSegments() sert à afficher les symboles Celsius et Fahrenheit.

Le code utilise la bibliothèque Adafruit DHT sensor que vous pouvez télécharger sur GitHub. Cette bibliothèque ne fonctionne que si vous avez aussi installé la bibliothèque Adafruit Unified Sensor, également disponible sur GitHub.

Vous pouvez aussi télécharger les deux bibliothèques en cliquant sur les boutons ci-dessous :

Exemple de code

/* 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);
}

Conclusion

Dans cet article, je vous ai montré comment utiliser un afficheur 7 segments 4 chiffres TM1637 avec Arduino. Nous avons aussi vu un exemple d’horloge et de thermomètre.

Pour plus de tutoriels sur les afficheurs, consultez nos How to control a character I2C LCD with Arduino et How to use a 16×2 character LCD with Arduino tutoriels.

Si vous avez des questions, n’hésitez pas à laisser un commentaire ci-dessous.