Dans cet article, je vais vous montrer comment fonctionne le circuit intégré pilote LED TM1638 à 7 segments et comment le connecter à un Arduino UNO.
J’ai utilisé le circuit intégré pilote LED TM1638 dans des projets précédents, car il décharge énormément de travail du microcontrôleur hôte. Ajouter ce pilote LED à votre projet est simple et facile.
Je commencerai par vous présenter les spécifications du pilote LED, partager des astuces, et vous montrer comment afficher des chiffres et scanner les boutons.
Nous entrerons ensuite dans les détails avec le guide de connexion et le code Arduino pour l’interface parallèle LCD du pilote LED TM1638. Nous répondrons aussi aux questions fréquentes.
Prenez votre carte Arduino, et c’est parti !
Composants nécessaires pour réaliser le projet Arduino et TM1638
Composants matériels
- Arduino UNO x 1
- Arduino Compatible TM1638 display module x 1
- Dupont wire x 1 set
- USB Cable for Arduino Programming x 1
Logiciel
Principes fondamentaux du module pilote LED TM1638
Commençons par comprendre les principales caractéristiques du circuit intégré pilote LED TM1638 :
- Contrôle de 8 chiffres (7 segments)
- Pilotage de 8 LEDs
- Scan de huit interrupteurs tactiles
- Contrôle de la luminosité
- Interface série – CLK, DIO, STB
Une connexion typique entre l’Arduino et le circuit intégré TM1638 est illustrée dans l’image ci-dessous.
Dans la section suivante, nous étudierons les interfaces entre les différents périphériques et le TM1638.
Détails des broches du circuit intégré pilote LED TM1638
| Nom de la broche | Type de broche | Description de la broche |
| DIO | Entrée/sortie de données | Données série entre l’Arduino et le circuit intégré TM1638 |
| STB | Sélection du circuit | Initialise l’interface série lors du front descendant/montant, puis reçoit l’instruction. Le premier octet est l’instruction lorsque STB est bas. CLK est ignoré lorsque STB est haut. |
| CLK | Entrée d’horloge | Entrée de sortie sur les données série |
| K1 ~ K3 | Entrée de données de scan des touches | Les données entrées sur cette broche sont verrouillées après la fin du cycle d’affichage. |
| SEG1/KS1 ~ SEG8/KS8 | Sortie (segment) | Sortie segment. Sortie drain ouvert. |
| SEG9 ~ SEG10 | Sortie (segment) | Sortie segment. Sortie drain ouvert. |
| GRID1 ~ GRID8 | Sortie (grille) | Sortie grille. Sortie drain ouvert. |
| VDD | Alimentation logique | 5 V ± 10% |
| GND | Masse logique | Connexions à la masse |
Une note spéciale concernant la broche DIO : La broche Digital-Input-Output (DIO) du module TM1638 est un N-type open drain. Vous devez fournir une résistance de tirage externe pour maintenir la ligne DIO à un niveau logique haut. La valeur recommandée est de 10 kOhms. Voir le circuit ci-dessous :
Scan des touches et registre de données de scan
Le taux de trame du scan des touches est de 8 x 3 bits. C’est similaire à une matrice de lignes et colonnes. Vous pouvez considérer cela comme une matrice de huit lignes et trois colonnes. Cela signifie que vous pouvez utiliser jusqu’à 24 boutons poussoirs.
Dans l’image ci-dessous, vous pouvez voir comment utiliser les broches K et KS du circuit intégré TM1638 pour scanner 24 boutons.
Jeu d’instructions
Vous pouvez utiliser les bits B7 et B6 du bit DIO pour déterminer le type d’instruction. Le circuit intégré TM1638 utilise le mécanisme de décodage ci-dessous pour identifier le type d’instruction envoyé par l’Arduino.
| B7 | B6 | Instruction |
| 0 | 1 | Jeu d’instructions de données |
| 1 | 0 | Jeu d’instructions de contrôle d’affichage |
| 1 | 1 | Jeu d’instructions d’adresse |
Jeu d’instructions de données .
Typiquement, vous utiliserez surtout le jeu d’instructions de données. Il est responsable de la lecture et de l’écriture des données. Note : B1 et B0 ne doivent pas être réglés sur 01 ou 11 pour ce jeu d’instructions.
| B7 | B6 | B5 | B4 | B3 | B2 | B1 | B0 | Fonction | Instruction |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Mode d’écriture des données | Écrire des données dans le registre |
| 0 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | Lire les données du scan des touches | |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Mode d’ajout d’adresse | Ajout automatique d’adresse |
| 0 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | Adresse fixe | |
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | Mode test | Mode normal |
| 0 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | Mode test |
Dans les images ci-dessous, vous pouvez voir le timing et le schéma d’horloge pour l’écriture et la lecture depuis le circuit intégré TM1638.
Notez que lors de la lecture des données depuis la puce, vous devez insérer un délai d’au moins 1 µs entre l’instruction et la réception des données. Ceci est obligatoire.
Pour savoir comment connecter les broches d’affichage TM1638 à l’afficheur LED 7 segments, référez-vous à l’image ci-dessous. L’exemple ci-dessous est pour un type d’afficheur à cathode commune, où toutes les broches cathodes des LEDs sont reliées ensemble.
Une alternative est le type d’afficheur à anode commune, où toutes les broches anodes des LEDs sont reliées ensemble.
Il est important de connaître les spécifications électriques de la puce avec laquelle vous travaillez. Cela vous aidera à déboguer et à éviter d’endommager la puce. Plus vous connaissez les spécificités du circuit intégré, plus il sera facile de faire les connexions et de construire des circuits fiables.
Voici les spécifications électriques du circuit intégré pilote LED TM1638 :
| Paramètre | Plage |
| Tension d’alimentation logique | Typique 5 V |
| Tension d’entrée haut niveau | Minimum 0,7 x VDD |
| Tension d’entrée bas niveau | Maximum 0,3 x VDD |
| Courant de sortie haut niveau | Maximum 40 mA |
| Courant de sortie bas niveau | Maximum 140 mA |
| Consommation de courant active | Maximum 5 mA |
| Fréquence d’horloge maximale | 1 MHz |
| Capacité d’entrée | 15 pF |
Assez de théorie ; ) Dans les sections suivantes, construisons le projet !
Comment connecter le TM1638 à l’Arduino UNO
Je vais maintenant vous montrer comment réaliser un projet avec l’Arduino UNO et le module d’affichage TM1638. Commençons par les connexions matérielles.
Voici le résumé des connexions nécessaires pour relier l’Arduino UNO au module TM1638. J’espère que cela vous donnera une vue d’ensemble. Suivez le guide de connexion.
| Broche sur le module TM1638 | Broche Arduino UNO | Remarques |
| VCC | 5 V | Alimentation |
| GND | GND | Connexions à la masse |
| STB | Ligne de stroboscope, broche 8 | N’importe quelle broche IO |
| CLK | Ligne de données, broche 9 | N’importe quelle broche IO |
| DIO | Ligne d’horloge, broche 10 | N’importe quelle broche IO |
Étape 1 : Compléter la connexion TM1638 et Arduino UNO
Voici le schéma de connexion entre l’Arduino UNO et la puce TM1638.
Les données série utilisent seulement deux fils. Cela vous permet d’économiser des broches sur la carte et réduit aussi le nombre de fils.
Le protocole série utilisé par le TM1638 n’est pas un standard. Mais pas d’inquiétude. Il existe d’excellentes bibliothèques que vous pouvez utiliser ! Vous pouvez en trouver une telle bibliothèque here.
N’oubliez jamais de commencer par les connexions à la masse. Attendez de fournir l’alimentation au projet que toutes les connexions soient faites.
Étape 2 : Programmer le code Arduino UNO ci-dessous
Suivez l’étape suivante pour comprendre l’implémentation du code. Vous pouvez utiliser le code ci-dessous pour tester le module TM1638. Nous n’utilisons aucune bibliothèque ici.
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);
}
Étape 3 : Explication du code
Parcourons le code.
const int strobe = 8; // STB to D8 const int clock = 9; // CLK to D9 const int data = 10; // DIO to D10
strobe, clock, et data sont des constantes représentant les broches connectées aux broches STB, CLK, et DIO du module d’affichage, respectivement.
void sendCommand(uint8_t value)
Cette fonction envoie une commande au module d’affichage. Elle met la broche STB à bas, envoie l’octet de commande avec la fonction shiftOut() , puis remet la broche STB à haut.
void reset()
Cette fonction réinitialise le module d’affichage à son état initial.
Elle appelle sendCommand() pour activer le mode d’incrémentation automatique et réinitialiser l’adresse de départ. Ensuite, elle utilise une boucle pour envoyer 16 octets de valeur 0x00 afin d’effacer l’affichage.
La fonction setup() effectue les tâches suivantes une fois :
Elle configure les modes des broches STB, CLK, et DIO. Elle appelle sendCommand() pour activer l’affichage avec la luminosité maximale. Enfin, elle appelle reset() pour initialiser l’affichage.
La fonction loop() est appelée en boucle après setup(). C’est la boucle principale du programme qui tourne en continu. Elle utilise une variable statique mode pour suivre le mode actuel.
void loop()
Elle utilise une instruction switch pour exécuter différentes actions selon le mode actuel :
COUNTING_MODE appelle la fonction counting() et incrémente le mode lorsque le compteur atteint une condition spécifique.
SCROLL_MODE appelle la fonction scroll() et incrémente le mode lorsque le défilement atteint une condition particulière.
BUTTON_MODE appelle la fonction buttons() pour gérer les entrées des boutons.
Elle inclut des délais entre les actions. J’espère que cela vous aidera.
FAQ sur le circuit intégré pilote LED TM1638
Vous trouverez ci-dessous une liste des questions les plus fréquemment posées sur les projets réalisés avec l’Arduino UNO et le circuit intégré pilote LED TM1638.
Si vous avez d’autres questions, n’hésitez pas à les poser dans la section commentaires.
Qu’est-ce qu’un module d’affichage TM1638 ?
Le module d’affichage TM1638 est une option populaire pour les amateurs pour interfacer des affichages LED, des boutons et d’autres périphériques. Il intègre un contrôleur d’affichage et un scanner de clavier. Cela facilite le contrôle et l’interaction avec diverses entrées et sorties.
Comment le module d’affichage TM1638 communique-t-il avec un microcontrôleur ?
Le module TM1638 communique avec un microcontrôleur via un protocole de communication série simple.
Pour envoyer et recevoir des données, trois lignes de contrôle sont nécessaires (données, horloge et strobe). Veuillez vous référer à la section principes fondamentaux de l’article pour comprendre en détail le protocole de communication.
Quelles sont les principales caractéristiques du module d’affichage TM1638 ?
Le module TM1638 offre généralement huit affichages LED à 7 segments, un ensemble d’indicateurs LED, et plusieurs boutons tactiles. Il fournit aussi un contrôle de la luminosité pour l’affichage et supporte le multiplexage pour réduire le nombre de broches I/O nécessaires.
Puis-je contrôler plusieurs modules TM1638 avec un seul microcontrôleur ?
Il est possible de contrôler plusieurs modules TM1638 avec un seul microcontrôleur. Chaque module peut se voir attribuer une adresse unique via un adressage matériel, permettant un contrôle individuel dans une configuration multi-modules.
Quels microcontrôleurs sont compatibles avec le module d’affichage TM1638 ?
Le module TM1638 peut être interfacé avec divers microcontrôleurs, y compris les plus populaires comme Arduino, Raspberry Pi, et ESP8266. Tant que le microcontrôleur supporte l’I/O numérique et la communication série, il peut être utilisé avec ce module.
Un aspect important est de vérifier la compatibilité de tension entre le microcontrôleur et le module TM1638.
Existe-t-il des bibliothèques pour programmer le module d’affichage TM1638 ?
Oui, plusieurs bibliothèques sont disponibles pour différentes plateformes et langages de programmation afin de simplifier l’intégration du module TM1638.
Ces bibliothèques fournissent des fonctions et abstractions pour contrôler l’affichage, lire les entrées des boutons, et gérer d’autres fonctionnalités du module. Veuillez consulter la section Code Arduino pour trouver des bibliothèques utiles.
Puis-je utiliser le module d’affichage TM1638 pour des projets autres que l’affichage principal et la saisie par boutons ?
Absolument ! Le module TM1638 est polyvalent et peut être utilisé au-delà des fonctions principales d’affichage et de boutons pour de nombreux projets.
Conclusion
Cet article a couvert toutes les informations essentielles pour utiliser le TM1638 avec l’Arduino UNO.
L’article était-il facile à suivre ? Si vous avez des suggestions pour l’améliorer, n’hésitez pas à partager vos retours.
J’aimerais beaucoup avoir de vos nouvelles ! Faites-nous savoir si vous souhaitez que je traite d’autres sujets dans de futurs articles.
