Sand traffic light: la suite.

Je n’avais posté de message depuis un petit temps mais j’ai été bien occupé

Cela ne m’a pas empêché de réfléchir et  d’avancer sur mon projet de feu rouge basé sur un sablier.

Capture d’écran 2016-05-20 à 17.54.30

J’ai commencé par finir de dessiner le plan, histoire d’avoir une idée claire et dimensionnée de mon projet et surtout de me pencher plus sérieusement sur la partie électronique/code.

Au fur et à mesure de l’avancement du projet, j’ai eu de nouvelles idées qui ont sensiblement complexifié la tâche. Il est maintenant articulé autour de deux parties:

  • Une partie matérielle utilisant un support en MDF, 400 LEDs et une carte électronique qui gère les LEDs.
  • Une partie logicielle avec un programme réalisé en Python qui servira à dessiner l’animation du sablier et à gérer les phases du feu (vert-orange-rouge).

La partie matérielle

La partie affichage fait appel à deux concepts fondamentaux dans le monde de l’affichage: le multiplexage et la persistance visuelle.

Le multiplexage, comment ca marche?

Partons d’un schéma simple:

multiplexage

J’utilise ici 8 LEDs RVB (à anode commune) divisée en 2 blocs de 4: le BLOC0 et le BLOC1.

La cathode rouge de la 1ere LED du BLOC0 est reliée à celle de la 1ère LED du BLOC1, idem pour les 3 autres et pour les cathodes vertes.

Q1 et Q2 sont des transistors de puissance type MOSFET à canal P. Ils permettent de commander de grosses puissances à l’aide d’une petite tension appliquée sur la grille.
Imaginons que je raccorde ROUGE2 à la masse et que j’active BLOC0: D3 s’allume en rouge.
Je désactive BLOC0 et active BLOC1: D3 s’éteint et  D7 s’allume en rouge.
J’active maintenant BLOC0 et BLOC1: D3 et D7 s’allument en rouge.
J’active en plus VERT2: D3 et D7 sont maintenant orange.
Je désactive ROUGE2: D3 et D7 sont verte.

Autre exemple: je souhaite allumer  en même temps D1 et D8 en rouge. Je raccorde donc ROUGE0 et ROUGE3 à la masse et j’active BLOC0 et BLOC1. Et là, on obtient pas le résultat obtenu! D1, D4, D5 et D7 sont allumées en même temps.

Heureusement, il existe une parade largement utilisée de nos jours: la persistance rétinienne.

Prenons l’exemple d’une vidéo. Ce  n’est jamais qu’une suite de photos qui défile rapidement (+/- 25 images/sec). La cadence est tellement élevée pour l’oeil qu’il ne parvient plus à voir la succession d’images.

Nous allons appliquer le même principe à notre montage. Nous allons donc allumer D1 puis allumer D8, puis D1, puis D8, …. à une fréquence de 40 Hz. C’est ce qu’on appelle le taux de rafraichissement: c’est le nombre de fois que les images vont changer.

Les images vont tellement défiler rapidement que l’oeil ne fera plus aucune distinction et donc D1 et D8 donneront l’impression d’être allumé en même temps.

On comprend donc l’intérêt du multiplexage: on peut gérer un grand nombre de LEDs avec beaucoup moins de fils. En appliquant en plus la persistance, on économise des circuits et de l’énergie car toutes les LEDs ne sont pas allumées en même temps.

J’ai 400 LEDs à gérer. Celles-ci sont divisées en 7 blocs: 6 de 64 LEDs et un 7ème de 16 LEDs.

Autre contrainte: le microcontrôleur que j’ai choisit (ATMEL Atmega 32u4) ne sais gérer que 16 entrées/sorties. J’ai donc opté pour des drivers de LEDs TLC5940 de chez Texas Instruments. A l’aide de 5 fils de commande, chaque circuit peut gérer 16 LEDs de manière individuelle mais ils peuvent être chainé pour augmenter ainsi le nombre de sorties.

Dans mon cas, j’en ai chainé 8 ensembles. 8×16 =128 sorties. Or mes blocs gèrent chacun 64 LEDs. En fait, les 4 premiers circuits gèrent la couleur rouge, les quatres autres la couleur verte.

La gestion de l’alimentation des blocs est faite grâce à des MOSFETs à canal P eux-même piloté par un SN74HC595 afin d’économiser à nouveau des broches.

Voici donc le schéma de l’unité de contrôle:

redlight_control_board
Schéma de la carte de commande

En haut à gauche, on retrouve le microcontrôleur Atmega32u4 de chez Atmel. J’ai choisi celui-ci car il gère nativement l’USB, donc pas besoin de convertisseur RS232/USB de type FTDI. Je chargerai le bootloader de l’Arduino Leonardo (mon apprentissage du language C-AVR pur n’est pas encore assez bon)

En dessous,c’est la partie qui contrôle les alimentations des blocs. La commande est envoyée au 74HC595 qui lui-même commandera les MOSFETs.
A droite, on trouve les drivers de LEDs: les 4 à gauche gèrent le rouge, les 4 à droite le vert.

J’ai également ajouté une petite mémoire EEPROM  de 256 Ko (24LC256 de chez Microchip) afin de stocker les différentes images qui vont défiler sur le feu car la mémoire interne du microcontrôleur était bien trop faible.

 La partie logicielle

Au départ, je voulais simplement faire un code côté Arduino qui allume les LEDs en fonction d’un tableau de valeurs correspondant aux dessins à afficher.

Créer les tableaux de valeurs à la main allait vite se révéler fastidieux, j’ai donc créé un logiciel  en Python côté Mac qui me permet de dessiner les motifs et de les envoyer à la carte de contrôle à l’aide de la liaison série. Dans un soucis de compatibilité maximum, j’ai utilisé le GUI Tkinter livré nativement avec python. La seule librairie externe nécessaire au fonctionnement de l’appli est pySerial

Capture d’écran 2016-09-08 à 10.59.26.png
L’interface utilisateur

Le fonctionnement est simple. J’ai une liste de 400 valeurs correspondant chacun à une LED. Si je clique sur une LED, je fais passer la valeur dans la liste correspondant à  cette LED  à si 1 si elle est éteinte ou  à 0 si elle est allumée.

J’ai un tableau dans lequel je peux ajouter ou supprimer des images. Je crée le dessin à afficher, j’appuie sur « + ». Les valeurs de la liste de LEDs sont converties en Hexadécimal.
Je peux également supprimer une image en surlignant l’image à effacer et en cliquant sur « -« .  En double-cliquant sur une image, celle-ci s’affiche sur le dessin de gauche.

Le bouton « Play » permet de simuler la séquence animée sur le dessin.

Il est déjà possible de se connecter à la carte (à un arduino pour mes tests) à l’aide du menu « Connexion » dans la barre de menu.

Le logiciel va encore recevoir les fonctionnalités suivantes:

  • Possibilité de déterminer la durée de la phase rouge et verte.
  • Tester l’image dessinée sur le feu.
  • Envoi de la séquence sur le feu et stockage dans l’EEPROM.
  • En mode autonome, le feu affichera la séquence sur le programme si le câble USB est connecté

 

Etat d’avancement

J’ai décrit l’état d’avancement du logiciel du paragraphe précédent, je ne reviendrai pas là dessus.

Niveau matériel, ca bouge aussi.

J’ai réalisé le feu avec un panneau MDF de 12mm d’épaisseur. J’ai tracé et foré les trous, un petit passage par l’atelier peinture (apprêt et peinture noir) et hop, on en parle plus.

img_20160815_182656
L’atelier peinture

La soudure des LEDs avance lentement mais surement. C’est clairement la partie la plus fastidieuse du projet .

hdr
Allez courage, plus que 308 LEDs !

Le pcb est presque fini d’être designé, je vais bientôt commander mon prototype en Chine.

capture-decran-2016-09-08-a-11-43-28
Hit the road Jack!

Conclusion

Encore pas mal de travail en perspective mais au moins j’avance sur ce projet. Il me tarde d’enfin pouvoir tester l’interaction entre le feu et le logiciel et d’enfin voir le temps s’écouler.

Si vous voulez de plus amples détails, contactez-moi ou laissez un commentaire.

 

Publicités