Le module TM1638 réunit sur une seule carte trois choses que l'on assemble d'habitude séparément : un afficheur de huit chiffres à sept segments, huit LED et huit boutons poussoirs. Le tout se pilote avec trois fils seulement, deux pour la liaison série et un pour la sélection.
C'est la carte des interfaces qui doivent à la fois montrer et recevoir : un compteur avec des touches, un menu déroulant sans écran, un tableau de bord de mesure, un mini-jeu. Le travail ingrat — multiplexage des chiffres, balayage des boutons, anti-rebond — est fait par la puce TM1638 elle-même, pas par votre programme.
À quoi sert le module TM1638 ?
Piloter huit chiffres, huit LED et huit boutons « à la main » demanderait des dizaines de broches, un balayage permanent et un code délicat. Le TM1638 est un circuit dédié qui fait ce travail en interne : votre microcontrôleur lui envoie ce qu'il doit afficher, et lui redemande simplement quelles touches sont enfoncées.
Le résultat est économique : trois broches d'Arduino suffisent à faire fonctionner la carte entière, et ces trois broches restent disponibles pour le reste du montage.
- Compteur à touches — une valeur affichée en grand, modifiée par huit boutons.
- Menu sans écran — huit choix, un chiffre par choix, une LED pour dire lequel est actif.
- Tableau de bord — température, tension, vitesse, avec les LED comme témoins d'état.
- Horloge ou minuteur — les informations séparées par des points, avec des réglages par boutons.
- Jeu de réflexe — l'afficheur pose une consigne, le joueur répond sur les touches.
Caractéristiques techniques
| Circuit de commande | TM1638 (Titan Micro Electronics) — pilote d'afficheur sept segments et de clavier |
|---|---|
| Alimentation | 5 V continu — module conçu pour la logique 5 V |
| Afficheur | 8 chiffres à sept segments, cathodes communes, rouges, deux blocs de quatre chiffres |
| Voyants | 8 LED rouges, une par bouton |
| Boutons | 8 boutons poussoirs, balayés par le circuit ; les appuis simultanés sont détectés |
| Interface | Série trois fils, non normalisée : ni I2C ni SPI. Lignes STB, CLK et DIO |
| Broches du connecteur | 5 broches mâles au pas de 2,54 mm : VCC, GND, STB, CLK, DIO |
| Luminosité | 8 niveaux réglables par logiciel, communs à l'afficheur et aux LED |
| Consommation | Environ 130 mA lorsque l'afficheur et toutes les LED sont au maximum ; quelques dizaines de milliampères en usage courant |
| Mise en cascade | Jusqu'à 6 modules chaînés, horloge et données partagées, une broche de sélection par module |
| Dimensions | Environ 76 × 50 mm |
L'interface n'est ni I2C ni SPI, même si elle ressemble à l'une ou l'autre par le nombre de fils : c'est un protocole propre au TM1638. D'où l'usage d'une bibliothèque — la piloter à la main se fait, mais n'apporte rien.
Brochage : cinq fils, dont trois de commande
Le connecteur est sérigraphié sur la carte. Les noms des broches sont toujours les mêmes, leur ordre varie selon la révision de la carte : lisez la sérigraphie de la vôtre, broche par broche, avant de brancher.
| VCC | Alimentation, à relier au 5 V de la carte Arduino. |
|---|---|
| GND | La masse, référence commune avec l'Arduino. |
| STB | Strobe : la broche de sélection. C'est elle qui ouvre et ferme chaque échange avec le circuit. À relier à une sortie numérique, par exemple D7. |
| CLK | L'horloge : chaque impulsion fait avancer d'un bit la donnée. À relier à une sortie numérique, par exemple D9. |
| DIO | La donnée, dans les deux sens : le module reçoit ce qu'il doit afficher et renvoie l'état des boutons. À relier à une sortie numérique, par exemple D8. |
Le module porte cinq broches mâles : pour le relier à une plaque d'essai ou à l'Arduino, il faut des fils mâle-femelle.
Ce que la puce fait toute seule
- Le multiplexage de l'affichage — les huit chiffres sont allumés en alternance, trop vite pour que l'œil le voie. Votre programme n'a pas à s'en occuper.
- Le balayage du clavier — le circuit interroge les huit boutons en permanence et mémorise les appuis. Une seule lecture rend l'état des huit touches à la fois.
- Les appuis simultanés — deux boutons enfoncés ensemble sont vus tous les deux, sans qu'un appui « masque » l'autre.
- La luminosité — huit niveaux, réglés par une seule instruction, et un niveau zéro qui éteint l'affichage sans effacer son contenu.
- La mise en cascade — six modules peuvent cohabiter sur la même horloge et la même ligne de données, chacun avec sa propre broche de sélection.
Mini-projet : un compteur à huit touches
Un montage complet, à faire en une vingtaine de minutes. Chaque bouton enfoncé ajoute sa position au compteur, affiché en grand sur les huit chiffres, et allume la LED correspondante. Vous aurez alors utilisé les trois fonctions essentielles du module : afficher, lire les touches, allumer une LED.
Ce qu'il faut
| L'afficheur et les touches | Le module TM1638 — celui de cette page |
|---|---|
| Le cerveau | Uno R3 + câble USB |
| Les liaisons | 10 × fil mâle-femelle |
Une plaque d'essai n'est pas indispensable ici : les cinq fils du module se raccordent directement aux broches de l'Arduino. Elle devient utile dès que le montage grandit.
Le câblage
Attention à ne pas inverser VCC et GND, et à repérer la sérigraphie de votre carte — l'ordre des cinq broches change d'une révision à l'autre.
Module VCC | → Arduino 5V |
|---|---|
Module GND | → Arduino GND |
Module STB | → Arduino D7 — la sélection |
Module DIO | → Arduino D8 — la donnée |
Module CLK | → Arduino D9 — l'horloge |
Le programme
Le pilotage passe par la bibliothèque TM1638 de Ricardo Batista (rjbatista), disponible dans le gestionnaire de bibliothèques de l'IDE Arduino sous le nom TM1638. Installez-la, puis copiez ce programme :
/*
* Module TM1638 - afficheur 8 chiffres, 8 LED et 8 boutons
* Carte : Arduino Uno R3
* Bibliotheque : TM1638 de Ricardo Batista (rjbatista)
*
* Composants, brochage et fiche complete : www.marocproduits.com
*/
#include "TM1638.h"
const byte PIN_STB = 7; // selection du module
const byte PIN_DIO = 8; // ligne de donnees
const byte PIN_CLK = 9; // horloge
// La bibliotheque attend : donnees, horloge, selection
TM1638 module(PIN_DIO, PIN_CLK, PIN_STB);
unsigned long compteur = 0;
byte touchesPrecedentes = 0;
void setup() {
module.setupDisplay(true, 4); // affichage actif, luminosite 4 sur 7
module.clearDisplay();
module.setDisplayToDecNumber(compteur, 0, false);
}
void loop() {
// Un bit par bouton, de gauche a droite
byte touches = module.getButtons();
// Appuis qui viennent de commencer
byte nouvelles = touches & (byte)~touchesPrecedentes;
if (nouvelles != 0) {
byte bit = 1;
for (byte i = 0; i != 8; i++) {
if (nouvelles & bit) {
compteur += i + 1; // chaque touche ajoute sa position
module.setLED(TM1638_COLOR_RED, i);
}
bit *= 2; // on passe au bouton suivant
}
module.setDisplayToDecNumber(compteur, 0, false);
}
// Boutons relaches : on eteint leur LED
byte relachees = touchesPrecedentes & (byte)~touches;
byte masque = 1;
for (byte i = 0; i != 8; i++) {
if (relachees & masque) {
module.setLED(0, i);
}
masque *= 2;
}
touchesPrecedentes = touches;
delay(20);
}Comment ça marche
module.getButtons()rend un octet : un bit par bouton, de gauche à droite. C'est la puce qui a fait le travail de balayage, pas la boucle du programme.- Comparer les touches actuelles aux précédentes isole les appuis qui viennent de commencer : sans cela, un bouton maintenu enfoncé ajouterait sans arrêt au compteur au lieu d'une seule fois.
module.setDisplayToDecNumber(valeur, 0, false)affiche le nombre en décimal ; le deuxième paramètre place les points décimaux, le troisième force les zéros de tête.module.setLED(TM1638_COLOR_RED, i)allume une LED,module.setLED(0, i)l'éteint. La position se compte de zéro à sept, comme les boutons.- La courte pause de 20 millisecondes remplace un anti-rebond : la puce en fait déjà une partie, cette pause rend le comptage franchement fiable.
Pour aller plus loin
- Un menu à huit choix — affichez un chiffre par ligne sur l'afficheur et laissez la LED marquer la ligne choisie.
- Un mot au lieu d'un nombre —
module.setDisplayToString("BONJOUR")accepte du texte, dans la limite de huit caractères utiles. - Une horloge — ajoutez une horloge temps réel DS3231 et affichez les heures et les minutes, deux points entre les deux.
Variante : un afficheur de mesure avec ses boutons
Le module est souvent utilisé comme la face avant d'un appareil de mesure : les huit chiffres pour la valeur, deux LED pour dire « en marche » et « alarme », et les boutons pour changer d'unité.
Ajoutez un capteur de température et d'humidité DHT11, puis affichez la température sur les quatre chiffres de gauche et le taux d'humidité sur les quatre de droite : un seul appel setDisplayToDecNumber prend la place de deux si vous séparez les valeurs par des points.
Le bouton de gauche change l'unité affichée, le bouton de droite allume la LED « alarme » quand la valeur dépasse le seuil que vous avez fixé dans le programme. Le câblage du module ne change pas d'un fil : tout se joue dans le code.
Questions fréquentes
Quelle différence avec le module TM1637 ?
Le module TM1637 est un afficheur de quatre chiffres seulement, sans boutons et sans LED, relié par deux fils. Le TM1638 offre le double de chiffres, huit boutons, huit LED, mais demande cinq fils et une bibliothèque différente : les deux programmes ne sont pas interchangeables.
Peut-on l'alimenter en 3,3 V ?
Le module est prévu pour 5 V. Beaucoup de cartes tolèrent le 3,3 V mais l'affichage devient nettement plus faible, et la lecture des touches peut devenir capricieuse. Sur un microcontrôleur en 3,3 V (ESP32, ESP8266), la démarche la plus sûre est d'alimenter le module en 5 V et d'intercaler un convertisseur de niveau logique sur les trois lignes de commande. Sur un Arduino Uno ou une Nano, rien de tout cela n'est nécessaire : branchez et travaillez.
Faut-il des résistances ou un condensateur ?
Non : les résistances de limitation des segments et des LED sont déjà montées sur la carte. Vous branchez les cinq fils, rien d'autre. Un condensateur de découplage est également prévu par le fabricant.
Pourquoi l'affichage tremble-t-il, ou pourquoi les boutons répondent-ils mal ?
Trois causes, dans l'ordre : de mauvaises soudures ou des fils trop longs sur les trois lignes de commande (un signal d'horloge parasité se traduit exactement par ces symptômes) ; une alimentation insuffisante, si le module est alimenté depuis une sortie faible ou une alimentation de mauvaise qualité ; et une pause trop courte dans la boucle, qui laisse lire les touches en plein rebond. Une pause de 20 millisecondes règle le troisième cas.
Combien de modules puis-je chaîner ?
Six au maximum selon la documentation du circuit. L'horloge et la ligne de données sont partagées, chaque module garde sa propre broche de sélection. Prévoyez alors une alimentation qui tient le courant : six cartes tout allumé demandent plus qu'une sortie d'Arduino ne peut fournir.
Les huit chiffres peuvent-ils afficher autre chose que des nombres ?
Oui. Le circuit gère une police de caractères par segment : lettres simples, symboles, tirets et points. Certaines lettres majuscules se lisent parfaitement (A, C, E, H, L, P), d'autres sont ambiguës — un S et un 5 se ressemblent, un M n'existe pas en sept segments. Un texte court et en majuscules reste la meilleure règle.
À combiner avec
Si vous partez de zéro, le KIT Starter fournit la carte Uno R3 et les fils nécessaires à ce montage ; en ajoutant le module de cette page, vous avez tout pour l'interface complète. Le Kit Arduino Uno maroc couvre davantage de projets si vous voulez plusieurs montages de front.
Pour un montage plus compact, le module rend les mêmes services avec une carte Nano, et il se marie particulièrement bien avec un encodeur rotatif (la molette pour choisir, les huit touches pour valider) ou avec le LCD Shield à 6 boutons pour une interface à deux écrans. L'horloge temps réel DS3231 et le buzzer actif complètent l'ensemble pour une horloge à alarme réglée par boutons.
