Matrice LED utilisant des registres à décalage : 7 étapes (avec images)

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

Cette instructable est censée être une explication plus complète que d'autres disponibles en ligne. Notamment, cela fournira plus d'explications matérielles que celles disponibles dans le chapiteau LED instructable par led555.

Buts

Cette instructable présente les concepts impliqués dans les registres à décalage et les pilotes high side. En illustrant ces concepts avec une matrice LED 8x8, j'espère vous fournir les outils nécessaires pour vous adapter et s'étendre à la taille et à la disposition de votre projet.

Expérience et compétences

Je dirais que ce projet est de difficulté moyenne:

• Si vous avez déjà de l'expérience dans la programmation de microcontrôleurs et l'utilisation de LED, ce projet devrait être assez facile à réaliser et à adapter à de plus grands réseaux de lumières.
• Si vous débutez avec les microcontrôleurs et que vous avez fait clignoter une LED ou deux, vous devriez pouvoir terminer ce projet avec l'aide de notre ami google.
• Si vous avez peu ou pas d'expérience avec les microcontrôleurs ou la programmation, c'est probablement au-delà de ce dans quoi vous devriez vous lancer. Essayez quelques autres projets pour débutants et revenez quand vous aurez plus d'expérience dans l'écriture de programmes pour microcontrôleurs.

Avis de non-responsabilité et crédit

Premièrement, je ne suis pas ingénieur électricien. Si vous voyez quelque chose qui ne va pas ou qui n'est pas une bonne pratique, faites-le moi savoir et je ferai la correction. Faites-le à vos risques et périls ! Vous devez savoir ce que vous faites ou vous pouvez endommager votre ordinateur, votre microcontrôleur et même vous-même. J'ai beaucoup appris sur Internet, en particulier sur les forums à l'adresse: https://www.avrfreaks.net un jeu de polices fourni avec la bibliothèque universelle C ks0108. Vérifiez cela ici:

Étape 1: Pièces

Liste des pièces

Pièces générales

Pour réaliser une grille de LED 8x8 et les contrôler il vous faudra:

• 64 LED au choix
• 8 résistances pour les LED
• 1 registre à décalage pour les colonnes
• 1 tableau de pilotes pour les lignes
• 8 résistances pour commuter le tableau de pilotes
• 1 microcontrôleur
• 1 source d'horloge pour microcontrôleur
• 1 planche de prototypage
• 1 alimentation
• Brancher le fil

Pièces spécifiques utilisées ici

Pour cette instructable, j'ai utilisé les éléments suivants:

• 64 LED vertes (pièce Mouse #604-WP7113GD)
• 8 résistances 220ohm 1/4 watt pour les LED (pièce Mouse #660-CFS1/4CT52R221J)
• 1 driver LED HEF4794 avec registre à décalage (pièce Mouse #771-HEF4794BPN)
• 1 matrice de pilotes source haute tension haute tension mic2981 (pièce Digikey #576-1158-ND)
• 8 résistances 3,3kohm 1/4 watt pour commuter le réseau de pilotes (pièce Radio Shack #271-1328)
• 1 microcontrôleur Atmel ATmega8 (pièce Mouse #556-ATMEGA8-16PU)
• 1 cristal 12MHz pour la source d'horloge du microcontrôleur (pièce Mouse #815-AB-12-B2)
• 1 carte de prototypage 2200 trous (Radio Shack pièce #276-147)
• Alimentation ATX convertie: voir ce Instructable
• Fil de branchement à âme pleine de 22 awg (pièce Radio Shack #278-1221)
• Planche à pain sans soudure (pièce Radio Shack #276-169 (plus disponible, essayez: 276-002)
• AVR Dragon (Mouser partie #556-ATAVRDRAGON)
• Dragon Rider 500 par Ecros Technologies: voir ce Instructable

Remarques concernant les pièces

Pilotes de lignes et de colonnes: la partie la plus difficile de ce projet est probablement la sélection des pilotes de lignes et de colonnes. Tout d'abord, je ne pense pas qu'un registre à décalage standard 74HC595 soit une bonne idée ici car ils ne peuvent pas gérer le type de courant que nous voulons envoyer à travers les LED. C'est pourquoi j'ai choisi le pilote HEF4794 car il peut facilement absorber le courant présent lorsque les 8 leds sont allumées sur une rangée. Le registre à décalage est présent sur le côté bas (la broche de masse des leds). Nous aurons besoin d'un pilote de ligne qui peut fournir suffisamment de courant pour enchaîner plusieurs colonnes ensemble. Le mic2981 peut fournir jusqu'à 500mA. La seule autre pièce que j'ai trouvée qui effectue cette tâche est l'UDN2981 (pièce digikey #620-1120-ND) qui est la même pièce d'un fabricant différent. S'il vous plaît envoyez-moi un message si vous connaissez d'autres pilotes high-side qui fonctionneraient bien dans cette application. Matrice LED: Cette matrice est de 8x8 car les pilotes de ligne et de colonne ont chacun 8 broches. Un réseau de LED plus grand peut être construit en enchaînant plusieurs matrices ensemble et sera discuté dans l'étape « concepts modulaires ». Si vous voulez une grande matrice, commandez toutes les pièces nécessaires en même temps. Il existe des matrices LED 8x8, 5x7 et 5x8 disponibles dans un seul emballage pratique. Ceux-ci devraient être faciles à remplacer par une matrice de bricolage. Ebay est une bonne source pour ces derniers. Mouser propose des unités 5x7 telles que la pièce #604-TA12-11GWA. J'ai utilisé des LED vertes bon marché parce que je ne fais que jouer et m'amuser. Dépenser plus pour des LED à haute luminosité et haute efficacité peut vous permettre de produire un affichage beaucoup plus spectaculaire… c'est assez bon pour moi cependant ! Matériel de contrôle: La matrice est contrôlée par un microcontrôleur Atmel AVR. Vous aurez besoin d'un programmeur pour cela. Parce que je fais du prototypage, j'utilise le Dragon Rider 500 pour lequel j'ai écrit des instructions d'assemblage et d'utilisation. C'est un outil facile pour le prototypage et je le recommande fortement.

Étape 2: La matrice

Je vais construire ma propre matrice LED pour ce projet en utilisant des LED de 5 mm et une carte de prototypage de Radio Shack. Il convient de noter que vous pouvez acheter des modules led matriciels 8x8 auprès de plusieurs sources, y compris ebay. Ils devraient fonctionner très bien avec cette instructable.

Considérations relatives à la construction

AlignementLes LEDS doivent être alignées de manière à faire face à la même direction sous le même angle. J'ai trouvé que l'option la plus simple pour moi était de mettre le corps de la LED au ras de la carte et de le maintenir là avec un petit morceau de plexiglas et une pince. J'ai mis quelques LED en place à quelques centimètres de la ligne sur laquelle je travaillais pour m'assurer que le plexiglas était parallèle à la carte de prototypage. Lignes et colonnesNous devons avoir une connexion commune pour chaque ligne ainsi que chaque colonne. En raison de notre choix de pilote de ligne et de colonne, nous devons avoir l'anode (fil positif de la LED) connectée par rangée et la cathode (fil négatif de la LED) connectée par colonne. Fils de contrôle Pour ce prototype, j'utilise un fil de raccordement à âme pleine (à conducteur unique). Ce sera très facile à interfacer avec une maquette sans soudure. N'hésitez pas à utiliser un type de connecteur différent en fonction de votre projet.

Construire la matrice

1. Placez la première colonne de LEDS dans la carte de prototypage.2. Vérifiez que votre polarité pour chaque LED est correcte, cela sera très difficile à corriger si vous vous en rendez compte plus tard.3. Soudez les deux fils de la LED à la carte. Assurez-vous qu'ils sont correctement alignés (pas à des angles étranges) et coupez les fils cathodiques. Assurez-vous de ne pas couper le fil de l'anode, nous en aurons besoin plus tard, alors laissez-le pointer vers le haut.4. Retirez l'isolant d'un morceau de fil à âme pleine. Soudez ce morceau de fil à chaque cathode juste au niveau de la carte.

• Je l'ai cloué à chaque extrémité puis je suis revenu et j'ai ajouté un peu de soudure à chaque jonction.
• Ce fil doit passer devant votre dernière LED pour créer une interface facile lorsque nous ajoutons des fils de commande.

5. Répétez les parties 1 à 4 jusqu'à ce que toutes les LED soient en place et tous les bus de colonne soudés.6. Pour créer un bus de rangée, pliez plusieurs fils d'anode à un angle de 90 degrés afin qu'ils touchent les autres fils d'anode de la même rangée.

• Il y a des images détaillées de cela ci-dessous.
• Veillez à ce qu'ils n'entrent pas en contact avec les bus colonnes, créant ainsi un court-circuit.

7. Soudez les fils à chaque jonction et coupez les fils d'anode en excès.

Laissez la dernière anode dépasser la dernière LED. Ceci sera utilisé pour connecter les fils de commande du pilote de rangée

8. Répétez les parties 6 et 7 jusqu'à ce que toutes les rangées de bus aient été soudées.9. Attachez les fils de commande.

• J'ai utilisé du fil à âme pleine rouge pour les lignes et noir pour les colonnes.
• Connectez un fil pour chaque colonne et un pour chaque rangée. Cela peut facilement être fait à la fin de chaque bus.

Important

Cette matrice de LED n'a pas de résistances de limitation de courant. Si vous testez cela sans résistances, vous brûlerez probablement vos LED et tout ce travail ne servira à rien.

Étape 3: Le matériel de contrôle

Nous devons contrôler les colonnes et les lignes de notre matrice LED. La matrice a été construite de sorte que les anodes (côté tension de la LED) constituent les lignes et les cathodes (côté masse de la LED) constituent les colonnes. Cela signifie que notre pilote de ligne doit générer du courant et que notre pilote de colonne doit l'absorber. Afin d'économiser sur les broches, j'utilise un registre à décalage pour contrôler les colonnes. De cette façon, je peux contrôler un nombre presque illimité de colonnes avec seulement quatre broches de microcontrôleur. Il est possible d'en utiliser seulement trois si la broche Activer la sortie est directement liée à la tension. J'ai sélectionné le driver LED HEF4794 avec registre à décalage. C'est une meilleure option qu'un 74HC595 standard car il peut facilement absorber le courant présent lorsque les 8 LED sont allumées en même temps. Du côté haut (source de courant pour les rangées), j'utilise un micro2981. Le schéma montre un UDN2981, je crois que ces deux sont interchangeables. Ce pilote peut fournir jusqu'à 500 mA de courant. Parce que nous ne conduisons qu'une ligne à la fois, cela donne beaucoup de possibilités d'extension, jusqu'à 33 colonnes pour cette puce (plus d'informations à ce sujet dans l'étape "concepts modulaires").

Construire le matériel de contrôle

Pour cette instructable, je viens de tester ce circuit. Pour une solution plus permanente, vous voudrez soit graver votre propre carte de circuit imprimé, soit utiliser une carte de prototypage.1. Pilote de ligne

• Placez le mic2981 (ou UDN2981) dans la maquette
• Connectez la broche 9 à la tension (cela prête à confusion dans le schéma)
• Connectez la broche 10 à la terre (cela prête à confusion dans le schéma)
• insérez des résistances 3k3 connectées aux broches 1-8
• Connectez du port D de l'ATmega8 (PD0-PD8) aux 8 résistances
• Connectez les fils de commande à 8 rangées de la matrice de LED aux broches 11-18 (notez que j'ai connecté la rangée de LED la plus basse à la broche 18 et la rangée la plus élevée à la broche 11).

2. Pilote de colonne

• Placez le hef4794 dans la planche à pain
• Connectez la broche 16 à la tension
• Connectez la broche 8 à la terre
• Connectez des résistances de 220 ohms aux broches 4-7 et 11-14.
• Connectez les 8 fils de commande de colonne de la matrice LED aux 8 résistances que vous venez de connecter.
• Connectez Pin1 (Latch) au PC0 de l'ATmega8
• Connectez Pin2 (données) au PC1 de l'ATmega8
• Connectez Pin3 (horloge) au PC2 de l'ATmega8
• Connectez Pin15 (Activer la sortie) au PC3 de l'ATmega8

3. Horloge en cristal

Connectez un cristal de 12 MHz et chargez des condensateurs comme indiqué sur le schéma

4. FAI

Connectez l'en-tête de programmation comme indiqué dans le schéma

5. Condensateur de filtrage et résistance pull-up

• Il est préférable de filtrer la tension fournie à l'ATmega8. Utilisez un condensateur de 0,1 uf entre les broches 7 et 8 de l'ATmega8
• La broche de réinitialisation ne doit pas rester flottante car elle peut provoquer des réinitialisations aléatoires. Utilisez une résistance pour le connecter à la tension, tout ce qui concerne 1k devrait être bon. J'ai utilisé une résistance de 10k dans le schéma.

6. Assurez-vous que vous utilisez une alimentation régulée +5v. C'est à vous de concevoir le régulateur.

Étape 4: Logiciel

L'astuce

Oui, comme tout, il y a un truc. L'astuce est qu'il n'y a jamais plus de 8 LED allumées à la fois. Pour que cela fonctionne bien, un peu de programmation astucieuse est nécessaire. Le concept que j'ai choisi est d'utiliser une interruption de minuterie. Voici comment fonctionne l'interruption d'affichage en anglais simple:

• Le temporisateur compte jusqu'à un certain point, lorsqu'il est atteint, la routine de service d'interruption est exécutée.
• Cette routine décide quelle ligne est la prochaine à afficher.
• Les informations de la ligne suivante sont recherchées dans un tampon et déplacées dans le pilote de colonne (ces informations ne sont pas "verrouillées" et ne sont donc pas encore affichées).
• Le pilote de ligne est éteint, aucune LED n'est actuellement allumée.
• Le driver de colonne est "verrouillé" fait dans les informations que nous avons décalées il y a deux étapes les informations courantes à afficher.
• Le pilote de ligne fournit ensuite le courant à la nouvelle ligne que nous affichons.
• La routine de service d'interruption se termine et le programme revient au flux normal jusqu'à la prochaine interruption.

Cela arrive très très vite. L'interruption est lancée toutes les 1 ms. Cela signifie que nous actualisons l'ensemble de l'affichage environ une fois toutes les 8 ms. Cela signifie un taux d'affichage d'environ 125 Hz. Il y a une certaine inquiétude concernant la luminosité car nous utilisons essentiellement les LED à un cycle de service de 1/8 (elles sont éteintes 7/8 du temps). Dans mon cas, j'obtiens un écran suffisamment lumineux sans clignotement visible. L'écran LED complet est mappé dans un tableau. Entre les interruptions, le tableau peut être modifié (attention à l'atomicité) et apparaîtra à l'écran lors de la prochaine interruption. Les spécificités de l'écriture du code pour le microcontrôleur AVR et de la façon d'écrire le code pour parler aux registres à décalage dépassent le cadre de cette instructable. J'ai inclus le code source (écrit en C et compilé avec AVR-GCC) ainsi que le fichier hexa à programmer directement. J'ai commenté tout le code, vous devriez donc pouvoir l'utiliser pour clarifier toutes les questions sur la façon d'obtenir des données dans le registre à décalage et sur le fonctionnement de l'actualisation des lignes. Veuillez noter que j'utilise un fichier de police fourni avec le ks0108 bibliothèque universelle C. Cette bibliothèque peut être trouvée ici:

Registres à décalage: comment faire

J'ai décidé d'ajouter un peu sur la façon de programmer avec des registres à décalage. J'espère que cela clarifie les choses pour ceux qui n'ont jamais travaillé avec eux auparavant. Dans ce cas, il y a un fil de données qui reçoit les données et 8 broches qui sont contrôlées en fonction des données reçues. Pour améliorer les choses, il existe une broche de sortie pour chaque registre à décalage qui peut être connectée à la broche d'entrée d'un autre registre à décalage. C'est ce qu'on appelle la cascade et fait du potentiel d'expansion une perspective presque illimitée. Les registres Control PinsShift ont 4 broches de contrôle:

• Verrou - Cette broche indique au registre à décalage quand il est temps de passer aux données nouvellement entrées
• Données - Les 1 et les 0 indiquant au registre à décalage les broches à activer sont reçues sur cette broche.
• Horloge - Il s'agit d'une impulsion envoyée par le microcontrôleur qui indique au registre à décalage de lire les données et de passer à l'étape suivante du processus de communication.
• Activer la sortie - Il s'agit d'un interrupteur marche/arrêt, High=On, Low=Off

Faire en sorte qu'il fasse vos enchères:Voici un cours intensif sur le fonctionnement des broches de contrôle ci-dessus:Étape 1: Réglez le verrouillage, les données et l'horloge à un niveau bas

Régler le Latch bas indique au registre à décalage que nous sommes sur le point d'y écrire

Étape 2: définissez la broche de données sur la valeur logique que vous souhaitez envoyer au registre de décalage.

Toutes les autres valeurs actuellement dans le registre à décalage se déplaceront d'une place, laissant de la place à la valeur logique actuelle de la broche de données

Étape 4: Réglez la broche d'horloge sur Low et répétez les étapes 2 et 3 jusqu'à ce que toutes les données aient été envoyées au registre à décalage.

La broche d'horloge doit être réglée bas avant de passer à la prochaine valeur de données. Basculer cette broche entre haut et bas est ce qui crée l'« impulsion d'horloge » dont le registre à décalage a besoin pour savoir quand passer à l'étape suivante du processus

Étape 5: Réglez le loquet haut

Cela indique au registre à décalage de prendre toutes les données qui ont été déplacées et de les utiliser pour activer les broches de sortie. Cela signifie que vous ne verrez pas les données au fur et à mesure qu'elles se déplacent; aucun changement dans les broches de sortie ne se produira jusqu'à ce que le verrou soit réglé haut

Étape 6: définissez l'option Activer la sortie à un niveau élevé

• Il n'y aura pas de sortie de broche jusqu'à ce que la sortie d'activation soit réglée sur haut, peu importe ce qui se passe avec les trois autres broches de contrôle.
• Cette épingle peut toujours être laissée haute si vous le souhaitez

CascadeIl y a deux broches que vous pouvez utiliser pour la cascade, Os et Os1. Os est pour les horloges à montée rapide et Os1 est pour les horloges à montée lente. Accrochez cette broche à la broche de données du registre à décalage suivant et le débordement de cette puce sera inscrit dans le suivant. Fin de la mise à jour

Adressage de l'affichage

Dans l'exemple de programme, j'ai créé un tableau de 8 octets appelé row_buffer. Chaque octet correspond à une ligne de l'affichage 8x8, la ligne 0 étant en bas et la ligne 7 en haut. Le bit le moins significatif de chaque ligne est à droite, le bit le plus significatif à gauche. Changer l'affichage est aussi simple que d'écrire une nouvelle valeur dans ce tableau de données, la routine de service d'interruption se charge de rafraîchir l'affichage.

La programmation

La programmation ne sera pas détaillée ici. Je vous préviens de ne pas utiliser de câble de programmation DAPA car je pense que vous ne pourrez pas programmer la puce une fois qu'elle fonctionnera à 12 MHz. Tous les autres programmeurs standard devraient fonctionner (STK500, MKII, Dragon, programmeurs parallèles/séries, etc.). Fusibles: assurez-vous de programmer les fusibles pour utiliser le crystalhfuse 12 MHz: 0xC9lfuse: 0xEF

En action

Une fois que vous avez programmé la puce, l'affichage devrait faire défiler un "Hello World!". Voici une vidéo de la matrice LED en action. La qualité vidéo est assez faible car je l'ai fait avec la fonction vidéo de mon appareil photo numérique et non avec une vidéo ou une webcam appropriée.

Étape 5: Concepts modulaires

Ce projet est évolutif. Le seul vrai facteur limitant sera la quantité de courant que votre alimentation peut fournir. (L'autre réalité est le nombre de LED et de sélecteurs de registre dont vous disposez).

Math

Je pilote les LED à environ 15mA (5V-1.8vDrop/220ohms=14.5mA). Cela signifie que je peux piloter jusqu'à 33 colonnes avec le pilote mic2981 (500mA/15mA=33,3). Divisé par 8 on voit que cela permet d'enchaîner 4 registres à décalage. Considérez également que vous n'avez pas besoin que les 32 colonnes s'étirent de gauche à droite. Vous pouvez à la place créer un tableau 16x16 qui est câblé de la même manière qu'un tableau 8x32. Cela serait résolu par un décalage de 4 octets…. les deux premiers se déplaceraient jusqu'aux leds de la 9ème rangée, les deux autres octets se déplaceraient dans la première rangée. Les deux rangées proviendraient d'une seule broche sur le pilote de rangée.

Registres à décalage en cascade

Les registres à décalage utilisés sont des registres à décalage en cascade. Cela signifie que lorsque vous changez de données, le débordement apparaît sur la broche Os. Le devient très utile car un ensemble de registres à décalage peut être connecté les uns aux autres, de la broche Os à la broche Data, en ajoutant 8 colonnes avec chaque nouvelle puce. Tous les registres à décalage se connecteront aux mêmes broches Latch, Clock et Enable Output sur le microcontrôleur. L'effet "cascading" est créé lorsque l'Os du premier registre à décalage est connecté à la broche Data du second. La programmation devra être modifiée pour refléter l'augmentation du nombre de colonnes. Le tampon qui stocke les informations et la fonction qui déplace les informations pour chaque colonne doivent être mis à jour pour refléter le nombre réel de colonnes. Un schéma de ceci est donné ci-dessous à titre d'exemple.

Pilotes à plusieurs rangées

Le pilote de ligne (mic2981) peut fournir suffisamment de courant pour piloter 32 colonnes. Et si vous voulez plus de 32 colonnes ? Il devrait être possible d'utiliser plusieurs pilotes de rangée sans utiliser plus de broches de microcontrôleur. Nous avons besoin que les pilotes de ligne fournissent suffisamment de courant pour allumer les LED. Si vous utilisez plus de colonnes qu'il n'est possible d'éclairer à la fois, des pilotes de ligne supplémentaires peuvent fournir le courant nécessaire. Les mêmes broches d'entrée du microcontrôleur sont utilisées, il n'est donc pas nécessaire de modifier le balayage des lignes. En d'autres termes, chaque pilote contrôle les lignes d'un bloc 8x32. Même si 64 colonnes peuvent avoir le même placement de ligne PHYSIQUE, nous divisons les bus de ligne en deux, en utilisant un pilote pour les 8 lignes des 32 premières colonnes et un second pilote pour les 8 lignes des 32 secondes colonnes et ainsi de suite. Un schéma de ceci est donné ci-dessous à titre d'exemple. Erreurs potentielles: 1. N'utilisez pas de pilotes à plusieurs lignes avec le même nombre de colonnes. Cela signifierait que chaque broche du registre à décalage piloterait plus d'une LED à la fois.2. Vous devez avoir un jeu de 8 résistances (3k3) pour chaque pilote de ligne, un jeu pour plusieurs pilotes de ligne ne fonctionnera pas car il ne fournira pas le courant nécessaire pour commuter les portes.

Par exemple

J'ai décidé de développer la matrice que j'ai construite plus tôt. J'ai ajouté 7 lignes supplémentaires pour un total de 15 car c'est tout ce que je peux mettre sur ce protoboard. Je viens également de découvrir un concours qu'Instructables fait appelé "Let it Glow". Voici une vidéo de mon point de vue là-dessus. Encore une fois, l'appareil photo numérique que j'ai utilisé pour prendre la vidéo ne lui rend pas justice. Cela a fière allure à l'œil humain, surtout là où toutes les LED clignotent, mais n'a pas l'air aussi bien dans la vidéo. Profitez: le code source de cet écran plus grand est inclus ci-dessous.

Étape 6: Conclusion

Ajouts possibles

I2CI a laissé les broches de l'interface à deux fils (I2C) inutilisées dans cette conception. Il existe plusieurs perspectives intéressantes qui peuvent utiliser ces deux broches. L'ajout d'une EEPROM I2C permettra le stockage de messages beaucoup plus volumineux. Il y a aussi la perspective de concevoir une programmation pour transformer le mega8 en un pilote d'affichage compatible I2C. Cela ouvrirait la possibilité d'avoir un périphérique USB pour afficher les données sur votre matrice de LED en les passant sur le bus I2C. EntréeIl reste de nombreuses broches qui pourraient être utilisées pour des boutons ou un récepteur IR. Cela permettrait de programmer les messages via un système de menus. AffichagePour cette instruction, je n'ai mis en œuvre que quelques fonctions d'affichage. L'un écrit simplement des caractères sur l'écran, l'autre fait défiler les caractères sur l'écran. La chose importante à retenir est que ce que vous voyez dans les lumières est représenté dans un tableau de données. Si vous trouvez des moyens plus intelligents de modifier le tableau de données, les lumières changeront de la même manière. Certaines opportunités alléchantes incluent la création d'un compteur graphique à partir des colonnes. Cela pourrait être utilisé comme un analyseur de signal avec une chaîne stéréo. Le défilement peut être mis en œuvre de haut en bas ou de bas en haut, voire de gauche à droite. Bonne chance, amuse toi bien!

Étape 7: Suivi

Après avoir laissé le circuit du contrôleur reposer dans la maquette pendant des mois, j'ai finalement conçu et gravé quelques cartes de circuits imprimés pour assembler ce prototype. Tout s'est très bien passé, je ne pense pas qu'il y ait quelque chose que j'aurais fait différemment.

Caractéristiques du circuit imprimé

• Les registres à décalage sont sur des cartes séparées qui peuvent être connectées en guirlande pour augmenter la taille de l'affichage.
• La carte contrôleur a son propre régulateur de puissance, elle peut donc être alimentée par n'importe quelle source d'alimentation fournissant 7v-30v (batterie 9v ou alimentation de banc 12v, les deux fonctionnent très bien pour moi).
• Embase ISP à 6 broches incluse pour que le microcontrôleur puisse être reprogrammé sans le retirer de la carte.
• Embase à 4 broches disponible pour une utilisation future du bus I2C. Cela pourrait être utilisé pour un eeprom pour stocker plus de messages ou même pour en faire un appareil esclave contrôlé par un autre microcontrôleur (ticker RSS quelqu'un ?)
• 3 boutons poussoirs momentanés sont inclus dans la conception. Je pourrais modifier le firmware à l'avenir pour inclure l'utilisation de ces boutons.

Assemblée

Donnez-moi du plexiglas, des équerres, des vis à métaux 6x32, des écrous et des rondelles, ainsi qu'un jeu de tarauds pour fileter les trous et je peux créer n'importe quoi.

Deuxième prix du concours Let It Glow!