Module TM1637

Un afficheur à quatre chiffres demande normalement douze fils : un par segment, plus les broches communes. Le module TM1637 ramène ce câblage à quatre fils, dont deux seulement pour la commande. Le pilote TM1637, soudé sous l’afficheur, fait le multiplexage à la place de la carte et ne réclame que deux signaux : une horloge et une ligne de données.

Le résultat tient sur une plaque d’essai en deux minutes : quatre fils, un programme de quelques lignes, et vous affichez un compteur, une température, une heure ou un numéro d’étape. Aucun câblage de segments, aucune résistance de limitation à calculer.

Caractéristiques techniques

Brochage : quatre fils, pas un de plus

La carte se relie directement à la Uno, sans composant intercalé : le module embarque son pilote et ses résistances de tirage, il n’y a rien à ajouter entre lui et la carte.

Le piège à connaître : selon le lot, l’ordre des libellés sur la sérigraphie change (VCC en haut sur certains modules, GND en haut sur d’autres). Suivez l’inscription de la carte que vous avez en main, jamais l’ordre d’une photo : une inversion de VCC et GND ne se pardonne pas, et une inversion de DIO et CLK donne un afficheur qui reste éteint alors que tout paraît correctement branché. Les deux broches de commande, elles, sont libres : D2 et D3 conviennent comme n’importe quels autres numéros, il suffit de les déclarer dans le programme.

Ce que le pilote fait à votre place

Un afficheur 7 segments nu, comme l’afficheur 5161BS, consomme une broche par segment et vous laisse gérer le multiplexage dès que plusieurs chiffres se suivent. Ici, tout ce travail est descendu dans le circuit : le TM1637 allume les segments, balaie les quatre chiffres assez vite pour que l’œil ne voie aucun clignotement, et se contente de recevoir des octets.

Chaque octet représente un chiffre, un bit par segment, dans l’ordre a, b, c, d, e, f, g, puis le point décimal en bit de poids fort. La bibliothèque TM1637Display construit ces octets pour vous, y compris l’affichage d’un nombre entier en une seule instruction.

Applications

• Compteur d’objets — pièces produites, passages, tours de bobine, avec remise à zéro au bouton.
• Banc de mesure — température, tension, poids, avec une décimale affichée.
• Horloge ou minuterie — quatre chiffres suffisent pour une heure ou un compte à rebours en minutes et secondes.
• Affichage de poste — numéro d’étape, de recette ou de programme dans un atelier.
• Jeu électronique — score à quatre chiffres, dé à plusieurs faces.

Mini-projet : un compteur d’objets de 0 à 9999

Un seul bouton pour tout faire : un appui court ajoute un objet, un appui maintenu remet le compteur à zéro. Le programme tient en une trentaine de lignes et se monte en un quart d’heure, soudure exclue.

Ce qu’il faut

Le câblage

Le bouton se branche directement entre D4 et la masse : la résistance de tirage interne de l’Arduino (INPUT_PULLUP) remplace la résistance externe, et il n’y a rien à calculer.

Le programme

À copier dans l’IDE Arduino après avoir installé la bibliothèque TM1637Display (Croquis → Inclure une bibliothèque → Gérer les bibliothèques), puis à téléverser sur la carte :

/*
 * Compteur d'objets de 0 a 9999 sur un afficheur quatre chiffres TM1637
 * Carte : Arduino Uno -- appui court : un objet de plus, appui long : remise a zero
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

#include "TM1637Display.h"

const byte BROCHE_CLK = 2;      // horloge du module
const byte BROCHE_DIO = 3;      // ligne de donnees du module
const byte BROCHE_BOUTON = 4;   // bouton vers la masse

TM1637Display afficheur(BROCHE_CLK, BROCHE_DIO);

unsigned int compteur = 0;

void setup() {
  afficheur.setBrightness(4);          // luminosite de 0 (eteint) a 7 (maximum)
  afficheur.clear();
  pinMode(BROCHE_BOUTON, INPUT_PULLUP);
  afficheur.showNumberDec(compteur, true, 4, 0);   // quatre chiffres, zeros en tete
}

void loop() {
  static boolean repos = true;
  static unsigned long debutAppui = 0;
  boolean appui = (digitalRead(BROCHE_BOUTON) == LOW);

  if (repos && appui) {                 // le bouton vient d'etre presse
    debutAppui = millis();
  }

  if (!repos && !appui) {               // le bouton vient d'etre relache
    unsigned long duree = millis() - debutAppui;

    if (duree > 1200) {
      compteur = 0;                     // appui long : on repart de zero
    } else {
      compteur = compteur + 1;          // appui court : un objet de plus
      if (compteur > 9999) {
        compteur = 0;                   // le compteur boucle apres 9999
      }
    }

    afficheur.showNumberDec(compteur, true, 4, 0);
  }

  repos = !appui;
  delay(10);
}

Comment ça marche

• La bibliothèque s’instancie avec les deux broches de commande : TM1637Display afficheur(BROCHE_CLK, BROCHE_DIO). L’ordre de ces deux paramètres compte, il suit l’ordre du constructeur et non celui de vos fils sur la plaque.
• setBrightness(4) fixe la luminosité sur les huit niveaux disponibles, de 0 à 7. C’est une instruction envoyée au pilote : aucun réglage mécanique, et le niveau peut changer en cours de route, par exemple s’éteindre la nuit.
• showNumberDec(valeur, true, 4, 0) affiche l’entier sur quatre chiffres avec les zéros en tête, ce qui donne une lecture stable : le compteur passe de 0007 à 0008 sans que l’affichage saute de largeur.
• Le bouton est lu en INPUT_PULLUP : au repos la broche est à l’état haut, un appui la met à la masse. Le programme mesure la durée entre l’appui et le relâchement, ce qui distingue l’ajout d’un objet de la remise à zéro sans ajouter un second bouton.
• Le delay(10) de fin de boucle n’est pas une temporisation de confort : il évite de lire la broche des milliers de fois par seconde, ce qui ne sert à rien.

Variante : une mesure avec une décimale

Le pilote gère aussi le point décimal, et la bibliothèque expose showNumberDecEx(), qui prend un masque de points en second paramètre. Avec un capteur DHT11 branché sur une autre broche, on affiche une température comme 23.5 : il suffit d’envoyer la valeur multipliée par dix et d’allumer le point du bon chiffre. Le même principe donne une horloge en heures et minutes avec une horloge temps réel DS3231, qui garde l’heure exacte même après une coupure d’alimentation.

Pour un affichage plus grand, ou pour plusieurs modules pilotés par une seule carte, deux familles voisines existent au catalogue : le circuit MAX7219CNG, qui commande huit chiffres avec trois fils, et la matrice LED 8 × 8 MAX7219 pour du texte défilant. Et si c’est du texte fixe que vous voulez afficher, l’afficheur LCD 16 × 02 en I2C est plus lisible qu’un afficheur à segments.

Questions fréquentes

Est-ce que c’est de l’I2C ?

Non, et la confusion est fréquente parce que le module se branche avec quatre fils, comme un petit écran I2C. Le TM1637 utilise un protocole à deux fils qui lui est propre : pas d’adresse, pas de bus partagé, pas de tirage à ajouter. La conséquence pratique est importante : deux modules ne peuvent pas cohabiter sur les mêmes broches, contrairement à deux écrans I2C.

Puis-je brancher plusieurs modules sur une même carte ?

Oui, à condition de donner à chacun sa propre paire de broches : le premier sur D2 et D3, le deuxième sur D5 et D6, et ainsi de suite. Une carte Uno en accepte quatre sans difficulté. Au-delà, ou si vous voulez afficher huit chiffres d’un coup, un MAX7219 est plus économe en broches.

L’afficheur reste éteint

Trois causes couvrent presque tous les cas. La masse n’est pas commune entre le module et la carte. VCC et GND sont inversés — c’est la vérification à faire en premier, la sérigraphie variant d’un lot à l’autre. Ou DIO et CLK sont croisés : le module reçoit bien des octets, mais sur les mauvaises lignes, et rien ne s’allume. Vérifiez aussi que les broches déclarées dans le programme sont celles où les fils sont réellement plantés ; un décalage d’une seule position est facile à ne pas voir.

Faut-il des résistances de limitation ?

Non. Le module embarque le pilote et ses résistances : les segments sont commandés en courant par le TM1637, et vous ne branchez que l’alimentation et les deux lignes de commande. C’est justement l’intérêt de la carte par rapport à un afficheur nu.

Peut-on afficher des lettres ?

Quelques-unes : la bibliothèque permet d’envoyer un octet segment par segment, ce qui dessine A, b, C, d, E, F, H, L, P, U et les chiffres hexadécimaux. Le M, le W et la plupart des autres lettres ne sont pas lisibles sur sept barres. Pour du texte, visez l’afficheur LCD en I2C ou une matrice à points.

Le module fonctionne-t-il en 3,3 V ?

Oui, la plage d’alimentation va de 3,3 V à 5 V. Sur une carte en 3,3 V, comme un ESP32, l’affichage reste lisible ; il est simplement un peu moins lumineux, l’afficheur bleu demandant une tension directe plus élevée que l’afficheur rouge. Si la luminosité compte, alimentez le module en 5 V et laissez les lignes DIO et CLK à la carte : elles ne transportent que des signaux.

Peut-on régler la luminosité ?

Oui, par logiciel, sur huit niveaux, avec setBrightness(). Il n’y a pas de potentiomètre sur cette carte, et il n’en faut pas : le réglage se fait dans le programme, ce qui permet de l’adapter à la pièce, de baisser l’intensité la nuit ou d’éteindre l’afficheur sans le débrancher.

À combiner avec

Le Kit Arduino Uno maroc réunit la carte Uno, la plaque d’essai, les fils et des composants : avec le module TM1637 en plus, le compteur de cette page est monté tel quel. Si vous partez de zéro, le trio Uno R3 + cable usb, plaque d’essai 400 points et fils mâle-mâle suffit, avec un mini bouton poussoir pour le compteur. Et pour aller vers une mesure plutôt qu’un comptage, ajoutez un capteur DHT11 ou une horloge temps réel DS3231.