Module d'affichage LED multiple : 6 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Bonjour à tous, J'aime travailler avec des écrans LED à 7 segments ou à matrice de points et j'ai déjà réalisé de nombreux projets différents avec eux.

A chaque fois ils sont intéressants car il y a une sorte de magie dans leur fonctionnement car ce que vous voyez est une illusion d'optique !

Les écrans ont beaucoup de broches pour la connexion avec un Arduino (ou un autre microcontrôleur) et la meilleure solution est d'appliquer les techniques de multiplexage de données pour minimiser l'utilisation de leurs ports.

Lorsque vous faites cela, chaque segment ou chaque LED sera allumé pendant quelques instants (millisecondes ou moins), mais la répétition de cela autant de fois par seconde crée l'illusion de l'image que vous voulez montrer.

Pour moi, le plus intéressant est de développer la logique, le programme afin de découvrir comment ils peuvent afficher les informations correctes en fonction de votre projet.

Dans un seul projet, l'utilisation d'écrans demande beaucoup de temps pour assembler tous les composants sur une maquette avec de nombreux fils pour les connexions.

Je sais qu'il existe de nombreux écrans différents sur le marché fonctionnant avec I2C, avec des moyens simplifiés (ou non), de les programmer et je les ai également utilisés mais je préfère travailler avec des composants standard comme 74HC595 (multiplexeur IC) et ULN2803 (drivers) car ils vous donnent plus de contrôle dans votre programme et aussi plus de robustesse et de fiabilité dans votre utilisation.

Pour simplifier le processus d'assemblage, j'ai développé un module LED Dipslay à des fins multiples en utilisant des composants simples et courants dans le monde Arduino.

Avec ce module, vous pouvez travailler avec une matrice de points avec des LED bicolores en deux tailles standard (plus grande et plus petite) et vous pouvez également contrôler un affichage 7 Seg x 4 Digits qui est très courant et facile à trouver sur le marché.

Et vous pouvez également travailler avec ces modules en cascade de manière série (différentes données dans les écrans) ou en parallèle (mêmes données dans les écrans).

Voyons donc comment ce module peut fonctionner et vous aider dans vos développements !

Vidéo (module d'affichage LED)

Vidéo (test matriciel)

Salutations, LAGSILVA

Étape 1: Composants

PCB (circuit imprimé)

- 74HC595 (03 x)

- ULN2803 (02x)

- Transistor PNP - BC327 (08x)

- Résistance 150 Ohms (16x)

- Résistance 470 Ohms (08x)

- Condensateur 100 nF (03 x)

- IC Socket 16 broches (03 x)

- IC Socket 18 broches (02 x)

- Connecteur à broches femelle - 6 broches (8 x)

- En-têtes de broche 90º (01 x)

- Embases à broches 180º (01 x)

- Connecteur Borne KRE 02 broches (02 x)

- PCB (01 x) - Fabriqué

Autres

- Arduino Uno R3 / Nano / similaire

- Affichage LED 04 chiffres x 7 segments - (Anode commune)

- LED matricielle double couleur (vert et rouge) - (anode commune)

Remarques importantes:

1. Je mets la fiche technique de tous les composants les plus importants uniquement comme référence mais vous devez vérifier la fiche technique de vos propres composants avant de les utiliser.
2. Cette carte a été conçue pour n'utiliser que des écrans de COMMON ANODE.

Étape 2: premiers prototypes

Mon premier prototype a été réalisé sur une maquette pour tester le circuit.

Après cela, j'ai fait un autre prototype en utilisant une carte universelle comme vous pouvez le voir sur les photos.

Ce genre de carte est intéressant pour réaliser un prototype rapide mais on s'aperçoit qu'on garde quand même pas mal de fils.

C'est une solution fonctionnelle mais pas si élégante par rapport à un PCB fabriqué final (le bleu).

Je ne suis pas doué pour la soudure car je n'ai pas assez d'expérience avec ce procédé mais même cela j'ai obtenu de bons résultats avec les deux expériences et plus important: je n'ai brûlé aucun composant ni mes mains !

Les résultats sur ma prochaine planche seront probablement meilleurs grâce à la pratique.

Pour cette raison, je vous encourage à essayer ce genre d'expérience car elle sera excellente pour vous.

N'oubliez pas de faire attention au fer chaud et essayez de ne pas passer plus de quelques secondes sur un composant pour éviter de le brûler !!

Et enfin, sur Youtube, vous pouvez trouver de nombreuses vidéos sur la soudure que vous pouvez apprendre avant d'aller dans le monde réel.

Étape 3: Conception de PCB

J'ai conçu ce PCB à l'aide d'un logiciel dédié pour produire une carte double couche et il a été développé plusieurs versions différentes avant cette dernière.

Au début, j'avais une version pour chaque type d'écran et après tout, j'ai décidé de tout combiner dans une seule version.

Cibles de conception:

• Simple et utile pour les prototypes.
• Configuration facile et extensible.
• Capable d'utiliser 3 types d'écrans différents.
• Largeur maximale de la grande matrice de points de LED.
• Longueur maximale à 100 mm pour minimiser les coûts de production de la planche.
• Appliquez des composants traditionnels au lieu de SMD pour éviter plus de difficultés lors du processus de soudage manuel.
• La carte doit être modulaire pour être connectée à d'autres cartes en cascade.
• Sortie série ou parallèle pour d'autres cartes.
• Plusieurs cartes doivent être contrôlées par un Arduino uniquement.
• Seulement 3 fils de données pour la connexion d'Arduino.
• Connexion d'alimentation externe 5V.
• Augmentez la robustesse électrique en appliquant des transistors et des pilotes (ULN2803) pour contrôler les LED.

Remarque:

Lié à ce dernier élément, je vous recommande de lire mon autre Instructables sur ces composants:

Utilisation du registre à décalage 74HC595 avec ULN2803, UDN2981 et BC327

Fabrication de PCB:

Après avoir terminé la conception, je l'ai envoyé à un fabricant de PCB en Chine après de nombreuses recherches auprès de différents fournisseurs locaux et dans différents pays.

Le problème principal était lié à la quantité de planches par rapport au coût, car je n'en ai besoin que de quelques-unes.

Finalement, j'ai décidé de passer une commande régulière (pas une commande expresse en raison des coûts plus élevés) de seulement 10 planches avec une entreprise en Chine.

Après seulement 3 jours les planches ont été fabriquées et m'ont été envoyées en traversant le monde en plus de 4 jours.

Les résultats étaient excellents !!

Une semaine après la commande, les planches étaient entre mes mains et j'ai été vraiment impressionné par leur haute qualité et leur rapidité !

Étape 4: Programmation

Pour la programmation, vous devez garder à l'esprit certains concepts importants concernant la conception matérielle et le registre à décalage 74HC595.

La fonction principale du 74HC595 est de transformer l'entrée série 8 bits en 8 sorties parallèles.

Toutes les données série vont à la broche #14 et à chaque signal d'horloge, les bits vont à ses broches parallèles correspondantes (Qa à Qh).

Si vous continuez à envoyer plus de données, les bits seront déplacés un par un vers la broche #9 (Qh') en tant que sortie série et grâce à cette fonctionnalité, vous pouvez mettre d'autres puces connectées en cascade.

Important:

Dans ce projet, nous avons trois circuits intégrés de 74HC595. Les deux premiers fonctionnent pour contrôler les colonnes (avec logique POSITIVE) et le dernier pour contrôler les lignes (avec logique NÉGATIVE en raison du fonctionnement des transistors PNP).

La logique positive signifie que vous devez envoyer un signal de niveau HAUT (+5V) depuis Arduino et la logique négative signifie que vous devez envoyer un signal de niveau BAS (0V).

Matrice de points de LED

1. Le premier est pour les sorties des cathodes des LED rouges (8 x) >> COLONNE ROUGE (1 à 8).
2. La seconde est pour la sortieL des cathodes des LED vertes (8 x) >> COLONNE VERTE (1 à 8).
3. Le dernier est pour la sortie des anodes de toutes les LED (08 x Rouge & Vert) >> LIGNES (1 à 8).

Par exemple, si vous souhaitez allumer uniquement la LED verte de la colonne 1 et de la ligne 1, vous devez envoyer la séquence de données série suivante:

1º) LIGNES

~10000000 (seule la première ligne est activée) - Le symbole ~ permet d'inverser tous les bits de 1 à 0 et vice-versa.

2º) COLONNE Vert

10000000 (seule la première colonne de la LED verte est allumée)

3º) COLONNE ROUGE

00000000 (toutes les colonnes de LED rouges sont éteintes)

Déclarations Arduino:

shiftOut(dataPin, clockPin, LSBFIRST, ~B10000000); // Logique négative pour les lignes

shiftOut(dataPin, clockPin, LSBFIRST, B10000000); // Logique positive pour les colonnes vertes

shiftOut(dataPin, clockPin, LSBFIRST, B00000000); // Logique positive pour les colonnes rouges

Remarque:

Vous pouvez également combiner les deux LED (verte et rouge) pour produire la couleur JAUNE comme suit:

shiftOut(dataPin, clockPin, LSBFIRST, ~B10000000);

shiftOut(dataPin, clockPin, LSBFIRST, B10000000);

shiftOut(dataPin, clockPin, LSBFIRST, B10000000);

Affichage 7 segments

Pour ce type d'affichage, la séquence est la même. La seule différence est que vous n'avez pas besoin d'utiliser les LED vertes.

1º) CHIFFRE (1 à 4 de gauche à droite) ~10000000 (définir le chiffre #1)

~01000000 (définir le chiffre #2)

~0010000 (définir le chiffre #3)

~00010000 (définir le chiffre #4)

2º) NON UTILISÉ

00000000 (tous les bits mis à zéro)

3º) SEGMENTS (A à F et DP - vérifiez votre fiche technique d'affichage)

10000000 (définir le segment A)

01000000 (définir le segment B)

0010000 (définir le segment C)

00010000 (définir le segment D)

00001000 (définir le segment E)

00000100 (définir le segment F)

0000010 (définir le segment G)

0000001 (définir DP)

Exemple Arduino pour définir l'affichage #2 avec le numéro 3:

shiftOut(dataPin, clockPin, LSBFIRST, ~B01000000); //Régler AFFICHAGE 2 (Logique négative)

shiftOut(dataPin, clockPin, LSBFIRST, 0); //Définir les données à zéro (non utilisé)

shiftOut(dataPin, clockPin, LSBFIRST, B11110010); //Définir les segments A, B, C, D, G)

Enfin, en appliquant ce processus, vous pouvez contrôler n'importe quelle LED de votre écran et vous pouvez également créer tous les caractères spéciaux dont vous avez besoin.

Étape 5: Tester

Voici deux programmes comme exemple de fonctionnalité du module d'affichage.

1) Affichage du compte à rebours (de 999,9 secondes à zéro)

2) Matrice de points (chiffres 0 à 9 et alphabet A à Z)

3) Horloge numérique RTC à affichage LED de 4 chiffres et 7 segments

Ce dernier est une mise à jour de ma première version de Digital Clock.

Étape 6: Conclusion et prochaines étapes

Ce module sera utile dans tous les projets futurs nécessitant un affichage LED.

Dans les prochaines étapes, j'assemblerai d'autres cartes pour travailler avec elles en mode cascade et je développerai également une bibliothèque pour simplifier encore plus la programmation.

J'espère que vous avez apprécié ce projet.

S'il vous plaît, envoyez-moi vos commentaires car c'est important pour améliorer le projet et les informations de ce Instructable.

Salutations, LAGSILVA

26. Mai.2016