Arduino Mega - Affichage 7-Segments 4-Chiffres 74HC595

Matériel requis

Ou vous pouvez acheter les kits suivants:

À propos de l'affichage 7-segments 4-chiffres 74HC595

Le module d'affichage 7-segments 4-chiffres 74HC595 est un système d'affichage LED intelligent qui combine plusieurs composants sur un seul PCB pour fournir une solution d'affichage numérique facile à utiliser pour les projets de microcontrôleur. Comprendre l'architecture du module vous aide à apprécier pourquoi c'est un choix si efficace pour les affichages multi-chiffres.

Architecture du module et composants :

1. Quatre chiffres LED 7-segments : Chaque chiffre consiste en sept segments LED arrangés en motif de figure-8 (étiquetés A à G), plus une huitième LED de point décimal. En illuminant différentes combinaisons de ces segments, l'affichage peut montrer les chiffres 0-9, certaines lettres (A, b, C, d, E, F, etc.), et symboles de base. La configuration cathode commune ou anode commune groupe les cathodes ou anodes de chaque chiffre ensemble pour un contrôle multiplexé.

2. Registres à décalage 74HC595 : Deux circuits intégrés de registres à décalage 74HC595 8-bits série-entrée, parallèle-sortie forment le cœur du module. Ces puces convertissent le flux de données série de votre Arduino en sorties parallèles qui contrôlent les segments LED individuels et les lignes de sélection de chiffres. Le premier registre à décalage contrôle typiquement quels segments s'illuminent (A-G plus point décimal), tandis que le second contrôle quel chiffre est actif (chiffre 1, 2, 3, ou 4).

3. Résistances de limitation de courant : Résistances intégrées (généralement 220Ω à 470Ω) protègent les LED d'un courant excessif, éliminant le besoin de résistances externes et prévenant les dommages des LED par surcourant.

4. Circuit de multiplexage : Plutôt que d'illuminer tous les quatre chiffres simultanément (ce qui nécessiterait des lignes de contrôle séparées pour chaque chiffre), le module utilise le multiplexage temporel. Il fait rapidement défiler les chiffres, illuminant seulement un à la fois en succession rapide. En raison de la persistance de vision, votre œil perçoit tous les quatre chiffres comme continuellement éclairés lorsque le taux de rafraîchissement dépasse approximativement 50Hz. Cette technique réduit considérablement le nombre de broches de contrôle requises.

Comment fonctionne le registre à décalage 74HC595 :

Le 74HC595 reçoit des données série bit par bit de l'Arduino, les décale dans un registre de stockage interne, puis sort tous les 8 bits en parallèle pour contrôler les LED. Trois signaux de contrôle coordonnent ce processus :

• SCLK (Serial Clock) : Chaque impulsion d'horloge décale un bit dans le registre
• DIO (Data In/Out) : Transporte le flux de données série de 1 et de 0
• RCLK (Register Clock/Latch) : Quand pulsé, transfère les données décalées vers les broches de sortie, mettant à jour l'affichage

En cascadant deux puces 74HC595, le module gagne 16 lignes de sortie parallèles—suffisant pour contrôler 8 segments par chiffre (incluant le point décimal) plus 4 lignes de sélection de chiffres, tout à travers un seul flux de données série.

Caractéristiques de l'affichage :

• Hauteur du chiffre : Typiquement 0,36" (9mm) à 0,56" (14mm) selon le modèle
• Couleur : Le plus communément rouge, mais aussi disponible en LED vertes, bleues, ou blanches
• Angle de vue : Approximativement 120° à 160° pour une visibilité claire
• Luminosité : Ajustable à travers la temporisation de rafraîchissement ou contrôle PWM
• Tension de fonctionnement : Compatible 3,3V à 5V (vérifiez votre module spécifique)
• Consommation de courant : Approximativement 20mA à 80mA selon combien de segments sont illuminés
• Plage d'affichage : -999 à 9999 pour les entiers, ou nombres décimaux avec précision ajustable

Avantages par rapport aux affichages 7-segments câblés directement :

• Économie de broches : Nécessite seulement 3 broches Arduino au lieu de 12+
• Code simplifié : Les bibliothèques gèrent la temporisation de multiplexage complexe
• Câblage plus propre : Cinq connexions totales réduisent l'encombrement de la breadboard
• Extensibilité : Peut cascader des registres à décalage additionnels pour plus de chiffres
• Protection : Limitation de courant intégrée prévient les dommages des LED

Ce module est parfait pour tout projet Arduino Mega nécessitant un affichage numérique clair de données de capteurs, mesures, comptes, ou informations de temps sans consumer excessivement les broches GPIO.

Brochage

Le module d'affichage 7-segments 4-chiffres 74HC595 dispose d'une interface 5-broches qui fournit un contrôle complet sur l'affichage en utilisant un minimum de connexions. Comprendre la fonction de chaque broche assure un câblage correct et aide à diagnostiquer les problèmes de connexion.

Descriptions des broches :

1. Broche SCLK (Serial Clock) :

• Fonction : Signal d'horloge qui synchronise le transfert de données vers le registre à décalage
• Fonctionnement : Chaque front montant (transition BAS vers HAUT) décale un bit de données de DIO dans le registre à décalage interne
• Connexion : Connecter à n'importe quelle broche de sortie numérique sur Arduino Mega (exemple : broche 4)
• Électrique : Compatible TTL/CMOS, tolérant 5V
• Temporisation : Fréquence d'horloge jusqu'à 25MHz (bien qu'Arduino fonctionne typiquement beaucoup plus lentement, autour de 1-2MHz)
• Note : La ligne SCLK doit être stable (pas flottante) pour prévenir les décalages aléatoires

2. Broche RCLK (Register Clock / Latch) :

• Fonction : Signal de verrouillage qui transfère les données décalées du registre de stockage vers les broches de sortie
• Fonctionnement : Quand pulsé HAUT puis BAS, les 16 bits stockés dans les registres à décalage apparaissent immédiatement sur les sorties LED
• Connexion : Connecter à n'importe quelle broche de sortie numérique sur Arduino Mega (exemple : broche 3)
• But : Permet des mises à jour d'affichage lisses en tamponnant les données avant de les afficher
• Temporisation : Pulser après envoi de tous les 16 bits de données pour mettre à jour l'affichage sans scintillement
• Noms alternatifs : Parfois appelé broche LATCH ou STCP (storage clock pulse)

3. Broche DIO (Data In/Out) :

• Fonction : Ligne de données série qui transporte le motif de bits à afficher
• Fonctionnement : Les bits de données sont décalés en MSB-first (bit le plus significatif d'abord) ou LSB-first selon la configuration de la bibliothèque
• Connexion : Connecter à n'importe quelle broche de sortie numérique sur Arduino Mega (exemple : broche 2)
• Format de données : Flux 16-bit (8 bits pour contrôle de segment + 8 bits pour sélection de chiffre)
• Électrique : I/O numérique standard, niveau logique 5V
• Noms alternatifs : Peut être étiquetée DS (data serial), SER (serial input), ou DIN (data input)

4. Broche VCC (alimentation) :

• Fonction : Tension d'alimentation positive pour le module
• Plage de tension : 3,3V à 5V DC (vérifiez la datasheet de votre module spécifique)
• Connexion : Connecter à la broche 5V de l'Arduino Mega pour luminosité maximale
• Consommation de courant : Approximativement 20mA à 80mA selon combien de segments LED sont illuminés
• Note : Si vous utilisez 3,3V, la luminosité de l'affichage sera réduite mais toujours fonctionnelle
• Recommandation : Utilisez 5V de l'Arduino pour un fonctionnement standard ; alimentation externe nécessaire seulement pour multiples affichages

5. Broche GND (masse) :

• Fonction : Référence de masse commune pour le module
• Connexion : Connecter à la broche GND de l'Arduino Mega
• Importance : CRITIQUE—la masse doit être partagée entre Arduino et le module d'affichage pour une communication de signal appropriée
• Dépannage : Si l'affichage montre des caractères aléatoires ou ne répond pas, vérifiez d'abord la connexion de masse

Tableau récapitulatif des connexions de broches :

Notes importantes sur les connexions de broches :

• Attribution flexible des broches : Les broches SCLK, RCLK, et DIO peuvent se connecter à n'importe quelles broches numériques Arduino Mega. Assurez-vous simplement que votre code reflète vos attributions de broches choisies.
• PWM non requis : Les broches de sortie numérique standard fonctionnent parfaitement ; pas besoin de broches compatibles PWM.
• Pas de pull-up/pull-down nécessaire : Les entrées du registre à décalage ont une stabilité interne suffisante ; les résistances externes sont inutiles.
• Intégrité du signal : Pour de longs câblages (>30cm), considérez utiliser des fils plus courts ou ajouter de petits condensateurs (0,1µF) près des broches VCC et GND du module pour réduire le bruit électrique.
• Affichages multiples : Pour contrôler plusieurs modules d'affichage 74HC595, vous pouvez partager les lignes SCLK et RCLK tout en utilisant des broches DIO séparées pour chaque module, ou les cascader sériellement pour des chiffres illimités.

Schéma de câblage

Le câblage approprié entre votre Arduino Mega et le module d'affichage 7-segments 4-chiffres 74HC595 est critique pour un fonctionnement fiable. Cette section fournit un guide de connexion complet avec des explications détaillées pour assurer une configuration réussie.

Tableau de connexion broche à broche :

Note : Les numéros de broches utilisés ici (2, 3, 4) sont des recommandations pour ce tutoriel. Vous pouvez connecter SCLK, RCLK, et DIO à n'importe quelles broches numériques disponibles sur votre Arduino Mega (broches 2-53). Rappelez-vous simplement de mettre à jour les définitions de broches dans votre code Arduino pour correspondre à votre câblage physique.

Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.

Instructions de câblage détaillées :

Étape 1 : Connexions d'alimentation

• Connectez la broche VCC du module d'affichage à la broche 5V sur Arduino Mega
• Connectez la broche GND du module d'affichage à n'importe quelle broche GND sur Arduino Mega
• Vérifiez d'abord ces connexions, car un câblage d'alimentation incorrect peut endommager le module

Étape 2 : Connexions des signaux de contrôle

• Connectez SCLK (horloge série) sur l'affichage à la broche numérique 4 sur Arduino Mega
• Connectez RCLK (horloge de registre/verrouillage) sur l'affichage à la broche numérique 3 sur Arduino Mega
• Connectez DIO (données) sur l'affichage à la broche numérique 2 sur Arduino Mega

Étape 3 : Vérification

• Double-vérifiez toutes les cinq connexions contre le tableau ci-dessus
• Assurez-vous qu'aucun fil n'est lâche ou fait contact involontaire avec les broches adjacentes
• Vérifiez que le module d'affichage est orienté correctement (vérifiez les étiquettes de brochage sur le PCB)

Conseils de câblage sur breadboard :

• Placement du module : Positionnez le module d'affichage au bord de votre breadboard pour un affichage facile
• Organisation des fils : Utilisez différentes couleurs de fils de connexion pour distinguer l'alimentation (rouge), la masse (noir), et les lignes de signal (autres couleurs)
• Longueur des fils : Gardez les fils aussi courts que pratique pour minimiser les interférences électromagnétiques
• Disposition soignée : Routez les fils autour des bords de la breadboard plutôt que de croiser par-dessus les composants
• Stabilité : Assurez-vous que le module est fermement inséré dans la breadboard pour prévenir les connexions intermittentes

Configurations alternatives de broches :

Si les broches 2, 3, et 4 sont déjà utilisées par d'autres composants dans votre projet, vous pouvez réassigner les signaux de contrôle de l'affichage à n'importe quelles autres broches numériques.

IMPORTANT : Chaque fois que vous changez les attributions de broches, vous devez mettre à jour les définitions de broches dans votre sketch Arduino :

Erreurs de câblage courantes et dépannage :

Problème : L'affichage ne montre rien (tous les segments éteints)

• Cause : Pas d'alimentation ou connexions d'alimentation inversées
• Solution : Vérifiez que VCC est connecté à 5V et GND à GND ; vérifiez la continuité avec un multimètre

Problème : L'affichage montre des caractères aléatoires ou scintille erratiquement

• Cause : Connexion de masse manquante ou intermittente
• Solution : Assurez-vous que la connexion GND est solide ; essayez un fil de masse différent ou une rangée de breadboard différente

Problème : L'affichage montre de mauvais nombres ou une sortie brouillée

• Cause : Broches de signaux de contrôle échangées ou connectées aux mauvaises broches Arduino
• Solution : Vérifiez que SCLK, RCLK, et DIO sont connectés comme spécifié ; vérifiez que les définitions de broches du code correspondent au câblage physique

Problème : L'affichage est très sombre ou à peine visible

• Cause : Alimentation insuffisante ou tension de batterie faible
• Solution : Connectez à la broche 5V de l'Arduino (pas 3,3V) ; si vous utilisez une alimentation externe, vérifiez que la tension est de 5V ; vérifiez le câble USB et la source d'alimentation

Problème : Seulement certains chiffres fonctionnent, d'autres restent vides

• Cause : Module défectueux ou configuration de bibliothèque incorrecte
• Solution : Testez avec le code d'exemple de la bibliothèque ; essayez différentes positions d'affichage dans le code ; le module peut être défectueux

Considérations de consommation d'énergie :

L'affichage 4-chiffres 74HC595 consomme approximativement 20mA à 80mA selon combien de segments sont illuminés (plus de segments allumés = courant plus élevé). C'est bien dans la capacité de la broche 5V de l'Arduino Mega (qui peut fournir jusqu'à 500mA depuis l'USB, ou plus depuis une alimentation externe). Cependant, si votre projet inclut plusieurs dispositifs à courant élevé (moteurs, nombreuses LED, etc.), considérez :

• Utiliser une alimentation 5V séparée pour les périphériques
• Alimenter l'Arduino Mega via la prise jack DC (7-12V) plutôt que l'USB
• Ajouter un condensateur 100µF à travers les broches VCC et GND de l'affichage pour lisser les surtensions

Notes de sécurité :

• La polarité compte : Toujours connecter VCC au positif et GND à la masse ; inverser la polarité peut endommager le module
• Branchement à chaud : Évitez de connecter ou déconnecter les fils pendant que l'Arduino est sous tension
• Décharge statique : Touchez un objet métallique mis à la terre avant de manipuler le module d'affichage pour prévenir les dommages électrostatiques aux puces 74HC595
• Vérifiez la tension : Certains modules 74HC595 sont 3,3V seulement ; vérifiez les spécifications de votre module avant de connecter à 5V

Installation de la bibliothèque

Pour programmer rapidement un affichage 7-segments 4-chiffres 74HC595, installez la bibliothèque DIYables_4Digit7Segment_74HC595 de DIYables.io. Voici les étapes pour installer la bibliothèque :

• Cliquez sur l'icône Bibliothèques sur le côté gauche de l'IDE Arduino.
• Tapez DIYables_4Digit7Segment_74HC595 dans la boîte de recherche, et trouvez la bibliothèque DIYables_4Digit7Segment_74HC595 de DIYables.io.
• Cliquez sur le bouton Installer.

Vous pouvez aussi consulter cette bibliothèque sur Github

Comment programmer pour le 74HC595 4-chiffres 7-segments avec Arduino Mega

Cette section vous enseigne les techniques de programmation essentielles pour contrôler l'affichage 7-segments 4-chiffres 74HC595 en utilisant la bibliothèque DIYables. Comprendre ces concepts vous permet d'afficher n'importe quelle information numérique ou textuelle requise par votre projet Arduino Mega.

Étape 1 : Inclure la bibliothèque

Au début de chaque sketch Arduino qui utilise l'affichage 74HC595, incluez le fichier d'en-tête de la bibliothèque :

Cette déclaration dit au compilateur Arduino d'inclure toutes les fonctions et définitions de la bibliothèque DIYables, rendant les fonctions de contrôle de l'affichage disponibles dans votre code.

Étape 2 : Définir les connexions de broches

Définissez des constantes pour les broches Arduino Mega connectées au module d'affichage. Utiliser #define ou const int rend votre code plus lisible et plus facile à modifier si vous changez le câblage :

Conventions de nommage des broches :

• SCLK (Serial Clock) : Aussi appelé CLK, SHCP, ou SCK dans certaines documentations
• RCLK (Register Clock) : Aussi appelé LATCH, STCP, ou RCK
• DIO (Data In/Out) : Aussi appelé DATA, DS, ou SER

Important : Les numéros de broches (4, 3, 2) doivent correspondre à votre câblage physique. Si vous avez connecté SCLK à la broche 10 au lieu de la broche 4, changez la définition en #define SCLK 10.

Étape 3 : Créer l'objet d'affichage

Instanciez un objet d'affichage qui représente votre module 74HC595. Cet objet fournit toutes les méthodes pour contrôler l'affichage :

Ceci crée un objet d'affichage global nommé display (vous pouvez choisir n'importe quel nom) et dit à la bibliothèque quelles broches Arduino contrôlent le module. L'ordre des paramètres est important : SCLK, RCLK, DIO.

Étape 4 : Initialiser dans setup()

Dans votre fonction setup(), initialisez l'affichage :

La méthode begin() configure les broches Arduino comme sorties et prépare les registres à décalage pour la communication.

Étape 5 : Afficher des nombres et du texte

La bibliothèque fournit plusieurs méthodes pour afficher différents types de contenu :

Afficher des entiers

Montrer des nombres entiers avec des zéros de tête optionnels :

Paramètres :

• Premier paramètre : L'entier à afficher (-999 à 9999)
• Deuxième paramètre : true = afficher les zéros de tête, false = laisser vides les chiffres non utilisés

Afficher des nombres à virgule flottante

Afficher des nombres décimaux avec un point décimal :

Paramètres :

• Premier paramètre : Le nombre à virgule flottante à afficher
• Deuxième paramètre : Nombre de décimales (0-3)
• Troisième paramètre : true = zéros de tête, false = laisser vides les chiffres non utilisés

Afficher des caractères personnalisés

Contrôlez les chiffres individuels et les points décimaux pour des affichages spécialisés comme les lectures de température :

Caractères spéciaux disponibles :

La bibliothèque fournit ces caractères prédéfinis dans l'espace de noms SegChars :

Positions des chiffres :

L'affichage utilise l'indexation à partir de 1 pour les positions des chiffres :

La position 1 est le chiffre le plus à gauche, la position 4 est le chiffre le plus à droite.

Méthodes de contrôle des chiffres individuels

Étape 6 : Implémenter correctement le code de boucle

EXIGENCE CRITIQUE DE MULTIPLEXAGE :

L'affichage 74HC595 utilise le multiplexage, ce qui signifie qu'un seul chiffre est illuminé à la fois, se cyclant rapidement à travers les quatre chiffres pour créer l'illusion d'un affichage simultané. Pour que cela fonctionne correctement, votre code Arduino doit suivre ces règles :

Requis : Appeler display.show() dans loop()

La méthode show() doit être appelée en continu (des centaines de fois par seconde) pour maintenir le cycle de multiplexage. Sans appels réguliers à show(), l'affichage scintille, montre des données incorrectes, ou apparaît vide.

Interdit : N'utilisez PAS delay() dans loop()

Pourquoi delay() cause des problèmes :

La fonction delay() arrête complètement l'exécution du code, empêchant show() d'être appelée. Pendant la période de délai, l'affichage s'arrête de se rafraîchir, causant un scintillement visible ou des segments vides.

Solution : Utiliser des actions minutées sans blocage

À la place de delay(), utilisez l'approche du minuteur millis() :

Cette approche permet à show() d'être appelée en continu tout en effectuant des mises à jour minutées.

Exemple de programmation complet

Voici un sketch complet démontrant tous les concepts :

Ressources supplémentaires

Pour une documentation complète de l'API, des fonctionnalités avancées, et plus d'exemples, visitez la référence de la bibliothèque.

Résumé des méthodes clés de la bibliothèque :

Code Arduino Mega - Afficher un entier

Cet exemple montre comment afficher des nombres entiers sur l'affichage 7-segments 4-chiffres 74HC595. Le code crée un simple compteur qui s'incrémente chaque seconde, affichant des valeurs de 0 à 9999 avant de réinitialiser. C'est parfait pour des applications comme les compteurs d'événements, minuteries, tableaux d'affichage, ou affichages de quantité de production.

Ce que fait ce code :

• Initialise l'affichage : Configure le module 74HC595 et efface tous les segments aléatoires
• Compte à la hausse : Incrémente une variable compteur toutes les 1000 millisecondes (1 seconde)
• Affiche des nombres : Montre la valeur de comptage actuelle sans zéros de tête
• Réinitialise automatiquement : Quand le comptage atteint 9999, il revient à 0
• Minutage non bloquant : Utilise millis() au lieu de delay() pour maintenir un rafraîchissement d'affichage fluide
• Multiplexage continu : Appelle display.show() répétitivement pour garder tous les chiffres visibles

Concepts de programmation clés :

• Variables statiques : La variable counter conserve sa valeur entre les itérations de la boucle
• Minutage Millis : La fonction millis() retourne le temps écoulé sans bloquer l'exécution
• Affichage entier : printInt(counter, false) affiche l'entier sans zéros de tête ("42" pas "0042")
• Gestion de plage : Les entiers peuvent s'afficher de -999 à 9999 (4 chiffres incluant le signe moins optionnel)

Idées de personnalisation :

• Changez interval de 1000 à 100 pour un comptage plus rapide (10 fois par seconde)
• Ajoutez une entrée bouton pour incrémenter/décrémenter manuellement le compteur
• Affichez des lectures de capteurs (température, distance, niveau de lumière) au lieu du compteur
• Affichez les zéros de tête en changeant false en true dans l'appel printInt()
• Ajoutez un bouton de réinitialisation pour remettre le compteur à zéro à la demande

Étapes rapides

Suivez ces instructions détaillées étape par étape pour faire fonctionner votre affichage compteur :

1. Vérifier le câblage : Assurez-vous que l'affichage 7-segments 4-chiffres 74HC595 est correctement connecté à votre Arduino Mega en suivant le schéma de câblage de la section précédente. Vérifiez les cinq connexions : VCC vers 5V, GND vers GND, SCLK vers la broche 7, RCLK vers la broche 6, et DIO vers la broche 5.

2. Connexion USB : Connectez votre carte Arduino Mega à votre ordinateur via un câble USB. Attendez que votre système d'exploitation reconnaisse l'appareil (vous pouvez entendre un son de connexion sur Windows).

3. Lancer l'IDE Arduino : Ouvrez le logiciel Arduino IDE sur votre ordinateur.

4. Sélection de la carte : Naviguez vers Outils → Carte et sélectionnez "Arduino Mega or Mega 2560" dans la liste des cartes.

5. Sélection du port : Allez à Outils → Port et choisissez le port COM (Windows) ou le port /dev/ttyUSB*/dev/ttyACM* (Mac/Linux) qui correspond à votre Arduino Mega. Le nom du port inclut généralement "Arduino Mega" ou "Mega 2560" pour aider à l'identifier.

6. Vérifier l'installation de la bibliothèque : Assurez-vous d'avoir déjà installé la bibliothèque DIYables_4Digit7Segment_74HC595 comme décrit dans la section Installation de la bibliothèque ci-dessus. Sans cette bibliothèque, le code ne se compilera pas.

7. Copier le code : Sélectionnez et copiez l'intégralité du code d'affichage entier fourni ci-dessus (de la ligne #include à l'accolade fermante de loop()).

8. Coller dans l'IDE : Créez un nouveau sketch dans l'IDE Arduino (Fichier → Nouveau) et collez le code copié, remplaçant tout code de modèle existant.

9. Vérifier le code : Cliquez sur le bouton Vérifier (icône coche) pour compiler le code et vérifier les erreurs. La compilation devrait se terminer avec succès avec un message comme "Compilation terminée."

10. Téléverser le code : Cliquez sur le bouton Téléverser (icône flèche droite) dans la barre d'outils de l'IDE Arduino. Vous verrez "Compilation du sketch..." suivi de "Téléversement..." dans la barre d'état. Attendez que le téléversement se termine (la LED intégrée de l'Arduino clignotera rapidement pendant le téléversement).

11. Observer l'affichage : Une fois le téléversement terminé, l'Arduino redémarre automatiquement et commence à exécuter votre code. Regardez l'affichage 7-segments—vous devriez voir un compteur commençant à 0 et s'incrémentant de 1 chaque seconde : 0, 1, 2, 3, 4... continuant jusqu'à 9999, puis revenant à 0.

12. Vérifier l'affichage fluide : Les nombres devraient apparaître stables et clairs sans scintillement. Si vous voyez du scintillement, consultez la section "Exigence de multiplexage" dans le guide de programmation—votre code peut bloquer les appels display.show().

Comportement attendu :

Dépannage :

• Affichage vide : Vérifiez les connexions d'alimentation (VCC et GND) ; vérifiez que la bibliothèque est installée
• L'affichage montre de mauvais nombres : Vérifiez que les définitions de broches dans le code correspondent à votre câblage physique
• Scintillement de l'affichage : Assurez-vous qu'aucun appel delay() ne bloque display.show() dans la boucle
• Erreurs de compilation : Confirmez que la bibliothèque DIYables est installée ; vérifiez les fautes de frappe dans le code
• Les nombres ne s'incrémentent pas : Vérifiez le Moniteur Série (9600 bauds) pour les messages d'erreur ; vérifiez la logique de minutage
• Échec du téléversement : Vérifiez que la carte et le port corrects sont sélectionnés ; essayez un câble USB différent

Code Arduino Mega - Afficher un flottant

Cet exemple montre l'affichage de nombres à virgule flottante (décimaux) sur l'affichage 7-segments 4-chiffres 74HC595. Le code incrémente un compteur décimal de 0,1 chaque seconde, idéal pour les applications nécessitant une précision décimale comme les voltmètres, capteurs de température, ou affichages de mesures.

Ce que fait ce code :

• Affichage décimal : Montre les nombres à virgule flottante avec une décimale (ex. "12.3")
• Comptage incrémental : Ajoute 0,1 au compteur toutes les 1000 millisecondes
• Contrôle du point décimal : Positionne automatiquement le point décimal entre les chiffres
• Gestion de plage : Réinitialise à 0,0 quand on atteint 999,9 (limite 4-chiffres avec décimale)
• Contrôle de précision : Affiche une décimale de précision

Différences clés par rapport à l'affichage entier :

• Utilise printFloat() au lieu de printInt() pour activer l'affichage du point décimal
• Le deuxième paramètre (1) spécifie le nombre de décimales à afficher
• Le compteur s'incrémente de 0,1 (valeur fractionnaire) au lieu de 1 (nombre entier)
• La valeur maximale affichable est 999,9 (un chiffre réservé pour la précision décimale)

Applications pratiques :

• Thermomètre : Afficher les lectures de température des capteurs DHT22 ou DS18B20 ("23.5°C")
• Voltmètre : Afficher la tension de batterie ou les lectures d'alimentation ("12.6V")
• Mesureur de distance : Afficher les mesures du capteur ultrasonique ("45.2cm")
• Balance : Afficher des mesures de poids précises ("123.4g")
• Affichage de vitesse : Afficher la vitesse ou la fréquence avec précision décimale ("56.7mph")

Options de décimales :

Vous pouvez ajuster la précision en changeant le deuxième paramètre :

Notez que plus de décimales réduisent la plage de la partie entière (moins de chiffres disponibles pour la partie entière du nombre).

Code Arduino Mega - Afficher la température

Cet exemple avancé montre l'affichage d'une lecture de température simulée au format "23.5°C" en utilisant le contrôle de caractères personnalisés. Le code montre comment afficher des caractères non numériques (symbole degré et lettre C) aux côtés de données numériques, parfait pour créer des affichages de capteurs d'aspect professionnel.

Ce que fait ce code :

• Température simulée : Génère de fausses valeurs de température entre 20,0°C et 30,0°C pour la démonstration
• Affichage de caractères personnalisés : Utilise le contrôle individuel de chiffres pour afficher le symbole degré (°) et la lettre C
• Précision décimale : Affiche la température avec une décimale (ex. "23.5")
• Format professionnel : Crée un affichage de température correctement formaté avec les unités
• Contrôle de position : Place manuellement chaque caractère à des positions de chiffres spécifiques

Décomposition du format d'affichage :

Explication du code :

• Position 1 : Chiffre des dizaines de la température (2 dans "23.5")
• Point position 1 : Point décimal après la position 1
• Position 2 : Chiffre des unités et des dixièmes (3 dans "23.5")
• Position 3 : Symbole degré (°)
• Position 4 : Lettre d'unité de température (C pour Celsius)

Comment fonctionne le contrôle individuel des caractères :

Cette approche vous donne un contrôle complet sur ce qui apparaît dans chaque position de chiffre, permettant des formats personnalisés au-delà des simples nombres.

Intégration avec un vrai capteur de température :

Pour afficher des lectures de température réelles, remplacez la valeur simulée par des données de capteurs réels :

Avec le capteur DHT22 :

Avec le capteur DS18B20 :

Avec le capteur analogique LM35 :

Adaptation pour Fahrenheit :

Pour afficher la température en Fahrenheit au lieu de Celsius :

Idées d'affichage personnalisé supplémentaires :

• Humidité : "65.2%H" (pourcentage d'humidité)
• Tension : "12.6 V" (tension de batterie)
• Heure : "12:45" (utiliser le module TM1637 avec deux-points est mieux)
• Distance : "45.2CM" (capteur ultrasonique)
• Vitesse : "56.7 H" (pour mph, rpm, etc.)
• Pression : "1013" (pression atmosphérique en hPa)

Caractères de lettres disponibles :

Les affichages 7-segments ont un support de caractères limité. Ces lettres sont clairement lisibles :

Pour de meilleurs résultats, utilisez des lettres qui sont facilement reconnaissables sur un affichage 7-segments.

Gestion des erreurs :

Dans le code de production avec des capteurs réels, ajoutez la gestion des erreurs :

Cela affiche "Err" sur l'affichage quand les lectures du capteur échouent, aidant au débogage.

Vidéo

Tutoriels connexes

• Arduino Mega - Affichage 7-Segments à 4 Chiffres TM1637