Arduino 7 segments : afficher des chiffres

Afficher des chiffres sur un afficheur 7 segments avec Arduino ouvre la porte à des projets concrets : compteur, thermostat, horloge, monitoring de consommation, tableau d’atelier… Encore faut‑il bien maîtriser le câblage, le décodage des chiffres et la gestion de la luminosité.

Entre modules à 1, 4 ou 8 digits, interfaces I2C, SPI ou TTL, consommation électrique variable et résistances à dimensionner, les choix techniques influencent directement la fiabilité de votre montage. Les lignes qui suivent structurent ces décisions pour que chaque afficheur 7 segments devienne un outil lisible, stable et parfaitement intégré à votre projet.

Principe de l’afficheur 7 segments avec Arduino

Un afficheur 7 segments est un ensemble de LED organisées en segments formant un chiffre. En alimentant sélectivement ces segments, Arduino représente les chiffres de 0 à 9 et quelques lettres simples (A, b, C, d, E, F…). Chaque segment correspond à une LED indépendante, le huitième LED sert de point décimal pour les valeurs numériques ou les unités.

Dans la majorité des modules, les segments portent la nomenclature suivante : a, b, c, d, e, f, g pour les sept segments principaux et « dp » pour le decimal point. En contrôlant ces huit sorties, Arduino peut afficher une valeur numérique stable, un compteur incrémental ou un retour d’état simplifié.

Afficheur à cathode commune et anode commune

La fiche technique indiquée décrit un type cathode commune. Tous les segments partagent la même cathode (GND), et Arduino applique une tension positive sur chaque segment à allumer via une résistance série. À l’inverse, un afficheur à anode commune relie toutes les anodes au +V et Arduino tire chaque segment à la masse pour l’éclairer.

Ce choix influence la logique du code : avec une cathode commune, un état HIGH sur la broche Arduino allume le segment, alors qu’avec une anode commune, l’état LOW allume le segment. Sur un projet plus large (tableau de commande, atelier, garage), cette inversion de logique peut se répercuter sur l’ensemble du schéma de commande, au même titre qu’un câblage dans un schéma électrique domestique.

« Un afficheur 7 segments ne se limite pas à un gadget lumineux. Il devient réellement utile quand la logique, la consommation et l’ergonomie d’affichage sont alignées avec le projet global. »

Caractéristiques techniques d’un afficheur 7 segments pour Arduino

Un projet robuste repose sur la compréhension des paramètres électriques et mécaniques de l’afficheur. Les valeurs qui suivent servent de référence pour dimensionner l’alimentation, les résistances et choisir l’interface adaptée.

Tension d’alimentation et tension directe des LED

L’afficheur générique présenté fonctionne typiquement sous 3,3 V à 5 V. La tension directe d’une LED rouge varie entre 1,7 V et 2,0 V (1,8 V générique), valeur cohérente pour des diodes rouges classiques. Cette marge impose une résistance pour limiter le courant de chaque segment.

ArduinoArduino et domotique : automatiser sa maison pour pas cher

Sur Arduino Uno ou Nano, la logique 5 V alimente directement les segments via des résistances de 330 Ω, alors que sur des cartes plus modernes (ESP32, Arduino MKR) en 3,3 V, la luminosité change légèrement et impose parfois un ajustement de la valeur de résistance pour garder un courant maîtrisé et un éclairement satisfaisant.

Consommation électrique par segment et par module

La consommation se décompose en deux parties : courant de la logique (pilotage via I2C/SPI/TTL) et courant des LED d’affichage. Le récapitulatif suivant donne des ordres de grandeur :

• Module 4 digits (TTL/SPI/I2C) : 3,8 à 7,9 mA sous 3,3 V, 6,9 à 14,1 mA sous 5 V pour la partie logique.
• Module 8 digits I2C : consommation pouvant atteindre 130 mA en fonction du nombre de segments allumés et du niveau de luminosité.
• Afficheur 5161AS simple : 20 mA typiques pour l’ensemble, à moduler selon les résistances.
• Consommation par segment avec résistance de 330 Ω : environ 10 mA par segment.

Un chiffre comme « 8 » active sept segments simultanément. Sur un seul digit, la consommation atteint alors environ 70 mA, ce qui reste raisonnable, mais qui requiert une attention particulière sur des montages à plusieurs digits, proches de la limite de courant totale d’un microcontrôleur.

Dimensions et ergonomie de lecture

Les dimensions influencent la lisibilité et l’intégration mécanique dans un boîtier ou un pupitre :

• Afficheur générique : 19 x 12,7 x 13,8 mm.
• Module 4 digits : partie afficheur 40 x 13 x 7 mm, taille du PCB environ 41 x 23 mm.
• Module 8 digits : longueur d’environ 117 x 22 mm.
• Écran : 0,56″ avec des digits de 10 mm de hauteur.

Ces valeurs donnent une idée claire de la place à réserver sur un panneau frontal, un coffret d’atelier ou le boîtier d’un projet Arduino placé dans une armoire technique au milieu d’un réseau de câbles comparable à ceux d’un atelier équipé en électricité.

Température de fonctionnement et robustesse

Une plage de température de -40 à 85 °C assure un fonctionnement stable dans la plupart des environnements : garage froid en hiver, boîtier légèrement chauffé en plein été, zone technique ventilée. Pour un projet installé sur la durée, cette caractéristique évite les dysfonctionnements liés à la dérive thermique des composants.

La couleur rouge reste classique pour une bonne lisibilité, même dans une ambiance lumineuse modérée. Combinée à une gestion logique de la luminosité sur plusieurs niveaux, elle garantit un affichage confortable sans éblouir.

Interfaces de pilotage : direct, BCD, I2C, SPI, TTL

Le choix de l’interface change la complexité du câblage et la charge logicielle. Arduino peut adresser un afficheur 7 segments de plusieurs façons, depuis le pilotage direct jusqu’aux modules avec décodeur intégré.

Pilotage direct des segments depuis Arduino

Le pilotage direct consiste à relier chaque segment (a, b, c, d, e, f, g, dp) à une broche de sortie. Arduino active ou désactive chaque broche suivant une table de vérité correspondant au chiffre à afficher.

Pour un seul digit, la configuration reste simple et didactique :

• 8 broches de sortie pour les segments.
• Résistance série de 330 Ω par segment, dimensionnée pour environ 10 mA.
• Une broche commune reliée à la masse (cathode commune) ou au +V (anode commune).

Ce mode reste adapté aux montages pédagogiques et aux tests rapides, mais montre ses limites dès que plusieurs digits s’ajoutent. Le nombre de broches nécessaires explose, au détriment d’autres capteurs ou actionneurs.

Utilisation d’un décodeur BCD vers 7 segments

Le décodeur BCD reçoit quatre bits binaires (0000 à 1001) et produit en sortie les sept signaux correspondant aux segments nécessaires pour afficher le chiffre. Arduino n’utilise plus que quatre broches pour coder un chiffre, au lieu de sept ou huit.

Les éléments clés de cette approche :

• Réduction des broches Arduino (4 bits BCD + éventuellement un signal d’activation).
• Logique matérielle qui gère directement la table de vérité.
• Facilité pour enchaîner plusieurs digits avec des techniques de multiplexage.

À l’échelle d’une maquette de panneau d’atelier ou de coffre électrique, cette stratégie rapproche le fonctionnement d’un synoptique industriel, où la logique câblée effectue déjà une partie du travail avant que l’automate ne prenne le relais.

Interfaces I2C, SPI et TTL : réduire le nombre de broches

Les modules 4 ou 8 digits avec interface I2C, SPI ou TTL intègrent un contrôleur qui pilote les segments. Arduino échange uniquement des données : quel chiffre afficher, sur quel digit, avec quelle luminosité. L’intérêt principal repose sur la réduction du nombre de fils.

• I2C : deux lignes partagées (SDA, SCL), adressage par bus, idéal pour multiplier les modules et autres capteurs.
• SPI : communication rapide, plusieurs fils (MOSI, MISO, SCK, CS), adapté à des affichages réactifs.
• TTL série : interface simple façon UART, notamment pour certains modules prêts à l’emploi.

Un module 8 digits I2C avec consommation logique inférieure à 130 mA offre un bon compromis entre densité d’affichage et simplicité de câblage. Arduino gère alors le contenu à afficher via quelques lignes de code, sans se soucier des états individuels de chaque segment.

Câblage d’un afficheur 7 segments avec Arduino

Le câblage conditionne la lisibilité, la longévité des LED et la stabilité du microcontrôleur. Un schéma rigoureux limite les erreurs et facilite le dépannage en cas de chiffre erroné ou de segment permanent.

Résistances série et protection des segments

Chaque segment étant une LED, le courant doit rester limité. Une résistance de 330 Ω représente une valeur courante pour obtenir environ 10 mA par segment sous 5 V, après prise en compte de la chute de tension de la LED (environ 1,8 V).

Le calcul présente la logique suivante :

• Tension d’alimentation : 5 V.
• Tension LED : 1,8 V.
• Tension aux bornes de la résistance : 5 V − 1,8 V = 3,2 V.
• Cible de courant : environ 10 mA.
• Résistance théorique : R = 3,2 V / 0,01 A = 320 Ω → 330 Ω normalisée.

Avec un microcontrôleur 3,3 V, la tension sur la résistance diminue et le courant baisse légèrement, tout en restant suffisant pour un affichage lisible dans la plupart des situations.

Câblage d’un afficheur à 1 digit

Pour un module type 5161AS (cathode commune rouge) :

• Relier la cathode commune au GND de l’Arduino.
• Relier chaque segment (a…g, dp) à une broche numérique via une résistance de 330 Ω.
• Prendre soin de bien associer les broches physiques au bon segment selon la documentation.

Dans le code, un tableau de configuration décrit quels segments activer pour chaque chiffre. Ce schéma constitue une base solide avant de passer aux modules à plusieurs digits.

Câblage d’un module 4 ou 8 digits

Avec un module 4 ou 8 digits piloté par I2C, SPI ou TTL, le câblage se simplifie :

• VCC relié au 5 V (ou 3,3 V selon la version).
• GND relié à la masse Arduino.
• Deux ou trois fils de communication (SDA/SCL pour I2C, MOSI/SCK/CS pour SPI…).

Le module intègre généralement ses résistances et sa logique de multiplexage. Le rôle du développeur se déplace alors du câblage vers la configuration logicielle et la gestion des données à afficher.

Logique d’affichage : de 0 à 9 sur un afficheur 7 segments

Chaque chiffre correspond à une combinaison déterminée de segments. Une table de vérité formalise ces combinaisons, que ce soit dans le hardware (décodeur BCD) ou dans le code Arduino.

Table de segments pour les chiffres décimaux

Sur un afficheur 7 segments classique :

• 0 : segments a, b, c, d, e, f activés.
• 1 : segments b, c.
• 2 : segments a, b, d, e, g.
• 3 : segments a, b, c, d, g.
• 4 : segments b, c, f, g.
• 5 : segments a, c, d, f, g.
• 6 : segments a, c, d, e, f, g.
• 7 : segments a, b, c.
• 8 : tous les segments.
• 9 : segments a, b, c, d, f, g.

Dans un code Arduino, un tableau de bytes encode cette configuration. Chaque bit correspond à un segment, sur le principe : bit 0 pour a, bit 1 pour b, etc. Un simple masque binaire suffit alors à allumer le chiffre souhaité.

Affichage de lettres et caractères spéciaux

Outre les chiffres, quelques lettres se représentent de manière adaptée :

• A : segments a, b, c, e, f, g.
• b : segments c, d, e, f, g.
• C : segments a, d, e, f.
• d : segments b, c, d, e, g.
• E : segments a, d, e, f, g.
• F : segments a, e, f, g.

Pour un montage de mesure, cette capacité permet d’afficher une unité (V, A, °C approximé par un C) ou un code d’erreur simplifié. La lecture reste rudimentaire comparée à un écran texte, mais largement suffisante pour de nombreux usages industriels légers ou projets de makers.

Multiplexage et gestion de plusieurs digits

Un afficheur multi‑digits partage souvent les segments (a…g, dp) et sélectionne chaque digit tour à tour à grande vitesse. Le principe repose sur le multiplexage : une seule ligne de segments commune et une ligne d’activation par digit.

Principe du multiplexage temporel

Arduino allume les segments pour le premier digit, active ce digit pendant quelques millisecondes, puis passe au suivant avec la nouvelle valeur. À une fréquence suffisante (souvent supérieure à 60 Hz), l’œil humain perçoit un affichage continu.

• Réduction du nombre de broches nécessaires pour plusieurs digits.
• Contrôle fin de la luminosité par modulation du temps d’activation.
• Charge processeur en hausse, surtout avec d’autres tâches simultanées.

Les modules prêts à l’emploi I2C ou SPI masquent cette complexité. Le contrôleur interne gère lui‑même le multiplexage et propose une interface simplifiée à Arduino.

Gestion de la luminosité sur 16 niveaux

Certains modules indiquent une luminosité réglable sur 16 niveaux. Ce réglage s’effectue généralement en envoyant une commande de configuration au contrôleur, qui ajuste le rapport cyclique interne de multiplexage.

Une luminosité plus faible améliore la durée de vie des LED et limite l’échauffement. Dans un environnement sombre, comme un boîtier d’atelier, un niveau moyen rend l’affichage plus confortable qu’une luminosité maximale permanente.

Consommation, alimentation et sécurité du montage

Une gestion rigoureuse de la consommation préserve le microcontrôleur et évite les coupures inopinées. Un afficheur 7 segments rouge semble simple, mais plusieurs digits illuminés simultanément représentent une charge réelle pour l’alimentation.

Dimensionner l’alimentation

Pour un module 8 digits I2C consommant jusqu’à 130 mA, l’alimentation 5 V doit fournir ce courant en plus de celui requis par Arduino, les capteurs et les autres actionneurs. Une marge confortable évite les chutes de tension visibles sous forme de scintillement ou de reset intempestif.

ArduinoPiloter un relais 230 V avec Arduino en sécurité : 5 erreurs à éviter

Sur USB, la réserve de courant reste parfois limitée, notamment sur certains hubs ou ordinateurs portables. Une alimentation externe 5 V régulée, reliée proprement au GND Arduino, renforce la stabilité du montage, comme une ligne dédiée dans une installation électrique pour un équipement précis.

Respecter les limites de courant des broches Arduino

Chaque broche d’un Arduino Uno supporte typiquement 20 mA en continu. Avec des segments à 10 mA, on reste dans la plage sécurisée, à condition de ne pas activer trop de segments en même temps sur un même port sans multiplexage. La limite de courant total par groupe de broches impose également de répartir intelligemment les segments.

Des drivers de LED ou des transistors de commutation libèrent Arduino de cette contrainte. Le microcontrôleur contrôle alors seulement les grilles des transistors, tandis que ces derniers gèrent le courant principal des LED.

« Un afficheur net et stable repose souvent sur une alimentation sérieuse. Une tension qui s’effondre de quelques centaines de millivolts suffit à transformer un affichage propre en série de segments erratiques. »

Conception logicielle : du compteur simple au tableau de valeurs

Une fois le câblage validé, la logique logicielle structure l’affichage. La clarté du code influence la maintenance du projet, en particulier lorsque l’afficheur sert dans un système plus large.

Fonctions de base pour afficher un chiffre

Sur un afficheur à segments pilotés directement, une fonction dédiée reçoit un entier de 0 à 9 et active les broches correspondantes. Cette fonction :

• éteint tous les segments au départ ;
• lit un tableau de correspondance chiffre → segments ;
• met chaque broche à l’état HIGH ou LOW suivant la logique de l’afficheur.

Cette approche favorise la lisibilité du code et facilite l’extension ultérieure à plusieurs digits ou à l’affichage de lettres.

Gestion de plusieurs digits et alignement des valeurs

Pour un module 4 ou 8 digits, il devient pertinent de concevoir une fonction chargée d’afficher une valeur entière ou flottante en répartissant les chiffres sur les digits disponibles. Elle gère :

• la conversion de la valeur en chaîne de caractères ;
• l’alignement à gauche, à droite ou centré ;
• l’affichage du point décimal (dp) au bon endroit.

Dans une application de monitoring (température, tension, courant), cette logique rend l’affichage plus clair, même pour un observateur qui n’a pas construit lui‑même le montage.

Intégration dans des projets concrets Arduino

Un afficheur 7 segments rouge se marie bien avec des projets de mesure, de commande ou de retour d’état rapide. Son format compact et son coût modéré complètent utilement des systèmes plus complexes.

Compteur d’impulsions ou de tours

Connecté à un capteur d’impulsions (interrupteur fin de course, capteur optique, effet Hall), l’afficheur 7 segments indique le nombre de tours, de pièces produites ou d’actions réalisées. L’utilisateur suit l’avancement en un coup d’œil, sans consulter un terminal série.

Dans un atelier équipé, ce type d’affichage apporte une information immédiate sur la production d’une machine, comme une scie ou une perceuse, tout en restant simple à intégrer sur la façade d’un coffret.

Thermomètre, horloge, indicateur de tension

Associé à un capteur de température ou à un module d’horloge temps réel, l’afficheur 7 segments présente :

• la température locale en °C ;
• l’heure sur 4 digits (HH:MM) ou sur 6 digits ;
• une tension mesurée via un pont diviseur et un convertisseur analogique.

La couleur rouge et les digits de 10 mm restent lisibles à une certaine distance, avantage appréciable sur un tableau de contrôle mural, dans un garage ou un atelier.

Choisir son afficheur 7 segments pour Arduino

Entre un module simple et une barrette 8 digits I2C, plusieurs critères orientent le choix : contraintes de câblage, consommation, surface disponible et type de données à afficher.

Comparatif rapide des options courantes

Pour un montage compact, un module 4 ou 8 digits avec interface I2C offre un bon équilibre : peu de câblage, luminosité réglable sur 16 niveaux, consommation maîtrisée et intégration directe dans un projet complexe relié à d’autres capteurs et actionneurs.