Après avoir vu comment poser les LEDs au plafond (Faire un ciel étoilé avec des LEDs (1/2)) , il faut maintenant s’occuper de l’électronique pour les commander. Une partie de l’électronique s’occupe de réguler le courant dans les LEDs (driver), et une autre fait varier l’intensité lumineuse pour créer une ambiance. C’est un microcontrôleur ATMEL qui s’occupe de la variation. Le tout peut être relié au PC par un port USB pour les réglages, ou pour changer dynamiquement l’éclairage. Tout les schémas et codes sources sont disponibles sous licence GPL à la fin de l’article.

Versions

La première version du circuit est celle décrite dans le premier article, ou il y a un total de 161 LEDs, avec 9 circuits indépendants. Chaque circuit est câblé avec des LEDs en série (entre 6 et 10) et en parallèle (jusqu’à 3). L’intérêt de connecter les LEDs en série est que la connexion se fait avec un seul fil, donc l’installation au plafond est beaucoup plus aisée ! Mais en série, la tension de seuil de chaque LED s’ajoute, il faut donc faire un circuit capable d’augmenter la tension l’alimentation (circuit boost).

Mon ami Bru s’est inspiré de l’idée, et a proposé un cahier des charges un peu différent. Il souhaitait faire la décoration de sa salle de home cinéma avec des LEDs de couleur. Pour éviter de devoir faire toutes les soudures, il est parti sur une solution avec de la fibre optique traversant une plaque de BA13 peinte en noir. Les fibres vont toutes vers un groupe de 5 LEDs puissantes : Rouge, Vert, Bleue, blanc chaud et blanc froid. Ainsi, chaque point lumineux peux prendre toutes les couleurs possibles en faisant varier l’intensité des LEDs de couleurs, et ainsi que l’emplacement de la fibre dans le toron. L’effet est magnifique :-). Dans cette version, chaque canal ne va piloter qu’une seule LED, il faut donc un circuit abaisseur.

Driver de LED boost (version Philippe)

Dans cette version, le circuit est séparé entre la partie commande (microcontrôleur), et les drivers de LEDs. L’ATMEL peut gérer jusqu’à 12 canaux, répartis en 3 groupes de 4. Je n’en utilise que 9 dans mon application. Dans l’archive, le schéma de la partie commande est dans le fichier « ciel_main.sch ». La carte avec les 4 drivers est dans « driver_led.sch », et il faut graver cette carte en trois exemplaires.

Caractéristiques

Le circuit driver boost choisi est un CAT4240, de On semiconducteur. Ce circuit est fait pour piloter 10 LEDs en série (38V max), à un courant de 300mA, soit 10W ! Il ne nécessite que peu de composants externes, et réponds à mes besoins.

On voit les cartes avec les 9 circuits identiques. Le plus gros composant est la self, et le plus petit est le régulateur 🙂 Selon le nombre de LEDs en parallèle dans les circuits, la résistance de feedback doit être ajustée.

Driver de LED buck (version Bru)

Caractéristiques

Pour ce circuit, le driver de led ZXLD1350 est utilisé. Son courant maximum est de 350mA, ce qui est parfait pour les LEDs de puissance 1W. Ici, le PCB est unique et supporte tous les composants. Il s’appelle « ciel_bru.sch ». Il y a 7 canaux disponible sur ce circuit, avec des connecteurs pour les LEDs.

Commande de la variation

Il fallait trouver un moyen de faire varier dans le temps la luminosité des LEDs, afin d’imiter le scintillement des étoiles. Il y a à la fois des variation lentes, et des variations rapides. On peut aller jusqu’à l’extinction si on le souhaite. Mais comme faire entrer ça dans un programme de microcontrôleur ? Comment le programmer pour que chaque canal soit indépendant ?

Signal PWM

En dehors de leur caractéristiques électriques, les drivers de LEDs ont aussi été choisi pour avoir une entrée de commande PWM. En changeant le rapport cyclique, on fait varier la luminosité de la LED. Avec un microcontrôleur, produire un signal PWM est facile … sauf quand il y a 12 canaux. Il a fallu optimiser la routine d’interruption qui s’occupe de mettre chaque canal à un et à zero. La valeur de la variation à une résolution de 8 bit, entre 0 (éteint) et 255 (pleine puissance).

Sommes de sinusoïdes

J’ai commencé à commander la puissance des LEDs selon une sinusoïde, mais le résultat visuel n’était pas satisfaisant. Alors j’ai fait des sommes de sinusoïdes. C’était un peu mieux, mais trop régulier. Aussi, on ne pouvait pas faire de petits éclairs brefs. Alors j’ai utilisé des morceaux de sinusoïdes…

Voici un exemple de sinusoïde simple, centrée sur 128, allant de 64 à 192 :

Dans le graph suivant, à chaque période « blanche », on ajoute une demi période « verte » :

Chaque morceau de sinusoïde se programme avec les paramètres suivants :

M Multiplicateur  [-16:15]
D Diviseur        [0:31]
O Offset          [0:255]
s Angle début     [-128:127]
e Angle fin       [-128:127]
t durée           [0:65535]

Dans le 2ème exemple, les paramètres des 2 parties étaient :

* M=1, D=4, O=128, s=-126, e=126, t=200
* M=1, D=6, O=128, s=0,    e=126, t=50

Si on veut faire des éclairs bref, on peut mettre une « bosse » très courte et puissante, avec un « creux » plus long, et presque plat :

Les paramètres sont :

* M=1, D=4,  O=0,  s=10,   e=120, t=40   # Bosse
* M=1, D=25, O=10, s=-120, e=-10, t=500  # Creux

Pour faire une variation lente et fluctuante, on peux utiliser les paramètres suivants :

M=1, D=8, O=90, s=-126, e=127, t=780
M=1, D=4, O=90, s=-126, e=127, t=2020

Si l’on additionne les deux courbes précédentes, on obtient :

Ce qui donne une forme de scintillement !

Pour chaque canal, on peut programmer la somme de 2 « courbes », chaque courbe étant un assemblage de 2 « morceaux » qui sont programmable individuellement. Et ceci pour chaque canal. On peut alors avoir toutes sortes d’effets visuels, que l’on peut programmer avec le PC.

Interface avec le PC

La programmation de tous ces paramètre se fait à l’aide du port série UART disponible sur l’ATMEGA88. Comme ce port à disparu des PCs, on utilise un adaptateur RS232 – USB, à base de FT232 ou CP2102. On branche les fils TX, RX et la masse entre l’adaptateur et la carte. Le protocole permet à l’ordinateur d’avoir un acknoledge, et de récupérer les valeurs qui ont été envoyées.

Les paramètres sont tous stockées dans l’EEPROM du µC, et il n’est pas nécessaire d’avoir l’ordinateur connecté en permanence. Le programme sur le PC est fait en python, et devrait tourner sur tous les OS modernes, et surtout Linux :-). Voici son interface :

$ ./comm.py -h
usage: comm.py [-h] [-v] [--speed BPS] [--port TTY]

               {get_config,get_mode,set_mode,get_pwm_val,set_pwm_fixed,set_sin_part,get_sin_part,get_channel_state,save_eeprom,reset,get_masks}
               ...

Communicate with ciel etoile

optional arguments:
  -h, --help            show this help message and exit
  -v, --verbose         Increase verbosity

Serial port configuration:
  --speed BPS           Speed of the serial link
  --port TTY            Serial port to use

Action commands:
  valid subcommands

  {get_config,get_mode,set_mode,get_pwm_val,set_pwm_fixed,set_sin_part,get_sin_part,get_channel_state,save_eeprom,reset,get_masks}
                        additional help
    get_config          Returns configuration of ciel etoile
    get_mode            Returns the current mode of the board
    set_mode            Set the mode of the board
    get_pwm_val         Returns the current pwm values
    set_pwm_fixed       Take the values given as arguments, and set the output
                        pwm values accordingly. The mode is automaticaly
                        changed to FIXED
    set_sin_part        Set the parameters for a given sine waveform
                        generation
    get_sin_part        Get the parameters for a given sine waveform
                        generation
    get_channel_state   Get status of the internal state of a given PWM
                        channel
    save_eeprom         Save the light mode and all the channel params to the
                        eeprom
    reset               Reset the board.
    get_masks           Returns the masks used during timer interrupts

 

Téléchargement

ciel_etoile_v0.1.tar (302KB)

L’archive contient tous les fichiers nécessaires pour faire le montage :

• Les schéma et typhons au format Eagle, pour les deux versions,
• Le code source pour le µC ATMEL AVR, en C, à compiler avec avr-gcc,
• Le code source en python pour programmer les paramètres (comm.py),
• Un « simulateur » qui m’a permis de tracer les courbes (draw_graph.py)