Télécommande pour ruban de LED et annonce nouveau gros projet.

Télécommande pour ruban de LED: FAIL!

Je n’ai plus écrit d’article depuis un certain temps mais entre mon boulot à temps plein, mes cours du soir, les stages, les travaux dans l’appartement et accessoirement un peu de vie privée, j’ai manqué un peu de temps 🙂

J’ai profité de mon dernier jour de congé pour enfin assembler ma carte qui doit contrôler des rubans de LEDs.

Et bein cela ne marche pas! Mon proto fonctionnait bien et à force de vouloir le simplifier, j’ai fait pis que mieux! En gros, les MOSFETs à canal P fonctionne à l’inverse des N: il est passant quand Vgs vaut 0 et bloquant quand Vgs vaut…la tension la plus haute admissible (voir datasheet).

En gros, pour piloter « simplement » un MOSFET P à l’aide d’un microcontrôleur, on peut utiliser le montage suivant:

driving_p-channel_mosfet

J’ai regardé la datasheet et pensé que 5V était suffisant pour pouvoir commuter proprement, hé ben non!

Je vais donc recommencer avec des MOSFET à canal N ( probablement des IRF8313, beaucoup plus facile à commander (une résistance du pull-up ou pull-down suffit!)

C’est en faisant des erreurs qu’on apprend et surtout, le mieux est l’ennemi du bien!

Annonce nouveau projet

J’ai commandé une nouvelle voiture. Je sais qu’il y a une période de rodage à respecter et je comptait m’aider de l’électronique pour fabriquer un petit boitier qui m’indiquerait que je suis trop haut dans les tours. On utilise pour se faire le port OBD2 (prise diag) sur laquelle on peut retirer une volée d’informations. Et c’est grâce à cela que j’ai découvert le bus CAN!

Ce protocole fiable et facile à implémenter va être la base de mon nouveau gros projet: une domotique à base de bus CAN.

Je sais qu’il existe des solution commerciales ou non déjà faite et bien avancées mais j’aime apprendre et faire les choses par moi-meme.

Bien que je consacrerai un petit article sur l’aide au rodage, l’essentiel de mes prochains articles portera sur le projet domotique.

A suivre donc!

 

Publicités

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.

 

Détecteur d’éclairs, partie 1: théorie

15115063028_cb3e35f335_b
Liège, 2014

 

J’ai mis de côté mon feu rouge pour me concentrer sur mon projet de détecteur d’éclairs pour appareil photo car la saison des orages approche et je tiens à être prêt!

J’ai toujours été fasciné par les éclairs. La puissance qu’ils dégagent nous rappelle qu’au final, nous sommes peu de choses.

Faire de la photo d’éclairs de nuit n’est pas trop problématique: une pose longue, un trépied, une télécommande et un peu de chance suffisent amplement. Les photos de jour sont quand à elles plus compliquées…

Tout d’abord, il est impossible de faire des poses longues sans utiliser de filtres à densité neutre. L’avantage, c’est qu’ils allongent le temps de pose et donc les chances de capturer un éclair. L’inconvénient, c’est qu’ils ont tendance à atténuer le halo de l’éclair. celui-ci paraît du coup très « fade ».

Enfin, si on désire se passer de filtres afin d’obtenir un résultat plus « spectaculaire », il va falloir mitrailler au pif en espérant capturer un éclair dans ce laps de temps. Non seulement, cela va faire un paquet de photos à traîter, mais en plus, le rideau et le capteur vont être sollicité pour rien, provoquant l’usure prématurée du matériel.
La solution? Utiliser un détecteur d’éclairs. Il en existe deux types: à radiodétection et optiques.

Les détecteurs à radiodétection fonctionnent à l’aide d’un récepteur AM (identique à ceux utilisé dans les radios). Les éclairs génèrent des perturbations électromagnétiques sur les ondes AM. Le détecteur les repèrent et déclenche l’appareil photo.
Avantage: hyper rapide
Inconvénient: détecte les éclairs jusqu’à 60km de distance. Peu d’intérêt car même pas dans le champ de vision.

Les détecteurs optique fonctionnent quand à eux grâce à l’intensité lumineuse produite par l’éclair. Celle-ci est repérée par le détecteur qui déclenche l’appareil photo.
Avantage: ne détecte que les éclairs visible sur la scène.
Inconvénient: plus lent et plus sensible aux lumières parasites.

Le hic, c’est que ces bestioles coûtent cher: entre 90 et 200€! Alors l’idée m’est venue d’en faire un moi-même.

La théorie:

J’étais partit sur une base d’Arduino couplé avec une photorésistance. Ca marche mais c’est ultra lent! Il faut savoir que la durée d’un éclair est de maximum 50 millisecondes, autant dire que chaque microseconde compte! Je me suis alors tourné vers les composants analogiques et pour moi qui ait de faibles connaissances dans ce domaine, ce fût un véritable défi.

J’avais acheté une photodiode BPW34 de chez Vishay dans le but de faire de la photo haute vitesse avec l’Arduino car elle est très sensible aux variations de lumières et très rapide (180ns de temps de réaction!). Après quelques recherches, j’ai découvert qu’une photodiode s’utilise en inverse. Lorsqu’elle est dans le noir, aucun courant de passe mais dès que la lumière frappe la cellule, un micro-courant de fuite s’échappe de celle-ci. Le problème, c’est qu’il est tellement infime qu’il est inexploitable tel quel. Ça tombe bien, je venais justement de voir les amplis opérationnels en cours qui vont me servir en principe à réaliser mon détecteur.

L’idée de base, c’est d’amplifier le micro-courant en tension exploitable et de comparer cette tension avec une autre qui sert de référence. Quand celle-ci est dépassée, l’appareil photo est déclenché.

J’ai donc utilisé un LM324 (un circuit intégré qui contient 4 amplis) que j’avais sous la main et  j’ai raccordé un des amplis en montage dit « de transimpédance »

Capture d’écran 2016-07-05 à 22.07.29
Ce montage convertit le micro-courant en tension en utilisant le gain énorme des ampli op en s’appuyant sur la relation suivante:

Vout= -Id.R1

-Id: courant de fuite de la photodiode.
Vout: Tension de sortie de l’ampli op
R1 : résistance qui fixe le gain (avec 1MΩ, on utilise le gain maxi).

Et ça marche! Le montage est alimenté en 5V. Quand je raccorde Vout à l’oscilloscope, la tension est à 0V quand la photodiode est plongée dans le noir. Plus on approche une source de lumière, plus la tension augmente. En approchant ou en reculant sa main devant le capteur, on voit clairement la tension fluctuer entre 0V et un peu moins de 5v (saturation de la diode).

J’ai ensuite utilisé un second ampli comme comparateur de tension. La tension de référence est fixée à l’aide d’un potentiomètre.

Capture d’écran 2016-07-05 à 22.36.55

Le potentiomètre (10K) me sert à régler le seuil de déclenchement. Je le règle à peine au dessus de la lumière ambiante, ainsi, une fois qu’un éclair aura lieu, le seuil sera passé, l’ampli saturera et la sortie ira contrôler le déclenchement de l’appareil. J’ai fait des essais avec le flash de l’appareil photo et ça marche parfaitement.

Voilà pour le principe de base. Je vais maintenant vous montrer  mon schéma final et vous expliquer le fonctionnement.

Capture d’écran 2016-07-05 à 22.58.29

Liste des composants:

  • 1 x OPA380 : ampli transimpédance grande vitesse
  • 1 x LM311 : comparateur de tension grande vitesse
  • 1 x NE555 : oscillateur
  • 1 x LM7805 : régulateur de tension 5v
  • 2 x BC547 : transistor NPN
  • 2 x ACPL-217 : optocoupleur rapide
  • 1 x BPW34 : photodiode
  • 1 x Buzzer actif (avec oscillateur intégré, trouvé sur Ebay)
  • 1 x  résistance 470KΩ
  • 3 x  résistance  1KΩ
  • 4 x  résistance  220Ω
  • 1 x résistance 22KΩ
  • 1 x pot 10KΩ
  • 1 x codo 22uF
  • 1 x codo 330nF
  • 3 x codo 100nF
  • 1 led blanche
  • 1 led rouge
  • 3 switchs

Fonctionnement:

Amplification:
La photodiode est branché à l’entrée inverseuse de l’OPA380 qui est un ampli transimpédance rapide. La résistance de contre-réaction vaut 470K , elle sert à fournir un gain élevé tout en évitant le bruit (je vous fait grâce des calculs). Le condensateur de 100nF est un codo de découplage (ne jamais négliger le découplage des circuits).

Comparaison:
La sortie est reliée à l’entrée inverseuse du comparateur de tension LM311, qui est-lui même très rapide (165ns!). Le potentiomètre est raccordé à l’entrée non-inverseuse. Devant le potentiomètre, j’ai placé une résistance de 1K afin d’avoir une plage de réglage la plus fine possible.

Impulsion:
La sortie du comparateur  est reliée à l’entrée du NE555 raccordé en monostable. L’utilité du NE555 est de fournir une impulsion suffisamment longue pour déclencher l’appareil photo. La durée se fait à l’aide du condensateur de 22UF et de la résistance de 22K. On obtient une impulsion d’environ 0.5 s

Déclenchement:
La sortie du NE555 est raccordée à la base des deux transistors NPN BC547. Ils agissent comme des interrupteurs. La résistance de 1K limite le courant mais est suffisante pour faire saturer le transistor. Le 1er déclenche le buzzer, le second la led blanche et l’optocoupleur OPTO1 qui déclenche l’appareil.

Pourquoi deux optocoupleurs alors qu’un seul aurait suffit? il faut d’abord comprendre comment fonctionne le déclencheur photo.

Sur le schéma, on voit trois fils: shutter, focus et GND. le shutter déclenche l’appareil, le focus s’occupe de faire la mise au point, et la masse, ben voilà quoi! Il est impossible de déclencher l’appareil sans avoir fait au préalable le focus.

En résumé:
1. Focus + GND => Mise au point.
2. Shutter  + GND => Rien.
3. Shutter + focus => Rien.
4. Shutter + focus + GND => Clic!

Il est impératif que la mise au point soit faite au moment où le détecteur repère un éclair. En effet, si l’appareil devait faire la mise au point à chaque éclair, l’éclair serait fini que la MAP serait à peine faite.

Donc l’intérêt de l’optocoupleur OPTO2 permet de gagner du temps en maintenant le focus mais aussi de pouvoir le désactiver à l’aide de l’interrupteur. Pourquoi me diriez-vous? Cela permet de faire le réglage du seuil sans faire une batterie de photos à chaque fois qu’il est dépassé!

Alimentation:
Une pile de 9V fournit l’énergie nécessaire au circuit. La tension est abaissée à 5V via le régulateur de tension  linéaire LM7805. Les deux condensateurs de 100 et 330 nF servent au découplage.

Vitesse de déclenchement:
J’ai fait en sorte de trouver de composants les plus rapides, pas évident quand on voit l’épaisseur des catalogues! Il y a surement mieux mais d’après mes calculs, le montage déclenche en moins de 3 microsecondes!
Il faut ajouter à ça la vitesse de l’obturateur propre à mon appareil (Nikon D7000): 53 microsecondes.

Au final, 56 microsecondes se seront écoulées entre la détection de l’éclair et le début de la capture. On comprend tout de suite pourquoi il est impératif que le temps de réponse du montage soit le plus bas possible.

Conclusion:

Voilà pour cette page de théorie un peu lourde. J’espère avoir été suffisamment précis sans avoir été rébarbatif.
Mon montage peut certainement être amélioré. Si vous avez des questions ou des idées, n’hésitez pas à me contacter.

Le prochain article traitera de la réalisation du proto, des problèmes rencontrés et des premiers essais.

 

Sand glass traffic light

Il y a quelques années, j’étais tombé sur un article qui montrait un feu tricolore totalement repensé. J’avais trouvé l’idée tout simplement excellente!

sandglass_signal3

Exit les 3 ampoules classiques! Le tout est remplacé par un sablier en LED qui donne une estimation du temps des différentes phases.

En explorant les méandres de mon cerveau, je suis retombé sur ce concept et je me suis dit que cela devait être réalisable avec un Arduino, des LEDS et un peu d’électronique.

Je me suis donc penché sur le sujet et j’ai essayé de tirer les grosses lignes de ce projet.

Le design

Capture d’écran 2016-05-17 à 01.04.20

A partir du dessin, j’ai dessiné la matrice de leds. Je n’ai pas exactement le même nombre mais j’ai fait en sorte que cela tombe bien. Et c’est le cas: 400 leds tout pile!

Je n’ai pas encore dessiné les contours mais ce n’est pas important pour l’instant, je me concentre avant tout sur l’aspect technique. Vu que je commande mes leds sur Ebay  j’aurai entre 15 jours et un mois pour terminer le design à mon aise 🙂

La technique

Je vais devoir utiliser des leds RGB (des diffuses pour que ça ne soit pas trop agressif pour les yeux). Ok!

C’est la que les choses se corsent. Comment gérer toutes ces leds? Anode ou cathode commune?

Ca paraît évident, on va devoir multiplexer le tout. J’ai déjà utilisé des SN74HC595 pour multiplexer des leds ou des afficheurs 7 segments (je détaillerai une autre fois ce projet). Un 595 ne peut gérer que 8 sorties par circuit. Il y a en plus 3 couleurs par led à gérer.
Un rapide calcul nous donne: (400leds/8 sorties)*3 couleurs = 150 circuits intégrés!! Arghhh!! Sans compter les 3 résistances par LED => 1200 résistances de 330 Ohm!

Bon il va falloir raisonner autrement.

J’ai décidé de m’inspirer des cubes de leds. Je tombe sur un projet plutôt bien détaillé: un cube de 8x8x8 leds RGB. Je me concentre surtout sur la partie commande et là je trouve exactement ce que je voulais: le pilotage des leds se fait à l’aide de drivers de leds (pléonasme?).

Je repart donc à la recherche d’infos et je découvre un circuit que me convient: le TCL5940.

Je découvre qu’il n’y a plus besoin de s’embarrasser de résistances pour chaque led, le circuit le fait pour nous! Il suffit de lui donner le courant de référence qui traverse chaque led (ex: 20mA) et c’est tout!

Pas mal non?

Ce que je retiens de ce circuit:

  • Alimentation de 3 à 5,5v
  • 16 sorties
  • Gère la PWM
  • Fournit un courant stable et défini à l’aide d’une résistance
  • Possibilité de gérer certaines erreurs (T°, leds cramée) à l’aide de flags spécifiques.

 

Là on progresse bien.
Il existe une librairie Arduino qui gère ce circuit. En me renseignant sur son fonctionnement, j’apprends qu’il est préférable d’utiliser des leds à anode commune.

Voilà qui répond à une autre de mes questions. J’ai donc commandé mes 500 leds à anode, histoire de potasser un peu mon projet pendant la livraison.

J’ai ensuite commencé à déterminer des blocs de 16 leds. 400/16= 25 tout rond!

Prochaine étape: potasser sur le multiplexage du tout. Je pense avoir trouvé le fonctionnement mais ça sera pour un autre jour, il est temps pour moi de rejoindre les bras de Morphée.