Bougie Arduino pour illuminer une citrouille d'halloween

Que ce soit pour halloween ou une autre fête, nous sommes friands d'effets lumineux originaux. En novembre, il y a des citrouilles de disponibles dans les jardins (en France) et beaucoup de personnes s'évertuent à les creuser pour y mettre une bougie après y avoir découpé des yeux et une bouche dentellée.
Mais pouvons-nous éviter de perdre cet exellent légume (Cucurbita pepo) après une période d'exposition à une flamme de bougie et autres résidus de parafine ?


Un bon électronicien se doit de trouver des solutions à presque tout.
Nous allons voir ici comment illuminer une citrouille et reproduire le vacillement d'une bougie à partir de LEDs et d'une carte Arduino®. Avec un montage bien protégé nous pourons comsommer notre citrouille le lendemain de son usage festif.

Obtenir de la lumière orange ou rouge-orangée

Les leds oranges ou ambres

Dans ce cas précis il s'agit d'obtenir directement la couleur désirée. Avec une seule led (ordinaire), nous obtenons une lueur plus faible que celle d'une flamme de bougie. Nous avons alors le choix d'utiliser une led monopuce de puissance (1 W à 3 W), un groupement de leds haute luminosité ou un spot à leds oranges pour obtenir un candela d'intensité lumineuse.

Eclairement de led ambre et orange

En utilisant un groupe de 4 à 5 leds, nous pouvons les disposer mécaniquement de façon à rayonner dans les directions utiles. Un éclairement demi-sphérique convient très bien pour illuminer une quelconque lanterne.

La disposition individuelle de plusieurs composants éclairants est un atout suplémentaire pour immiter le comportement et la forme d'une flamme.
C'est la raison pour laquelle, des essais de câblage, de groupement, de coloration et de mode de diffusion, nous permettrons d'optimiser le montage afin de produire l'effet désiré.

Les mélanges rouge et jaune

Nous pouvons aussi pour des raisons techniques ou d'approvisionnement de composants, utiliser d'autre sources lumineuses qui ne sont pas oranges.

Avec plusieurs leds rouges et jaunes et une disposition intelligente de celles-ci, nous allons obtenir des rayonnements lumineux qui se mélangent. La encore, si votre montage est dans la citrouille, l'éclairage résultant imitra la couleur du feu.
Si le montage est placé simplement dans l'obscurité, il faudra placer un diffuseur (papier calque par exemple).
L'ajout d'une feuille de plastique orangé entre les leds et le diffuseur peut aussi amélioré l'effet "couleur flamme" (papier d'emballage de confiserie).

Dans le cas de mélange de leds, il est sourtout intéressant de faire varier les intensités lumineuses de chaque leds (nous pouvons faire aussi la même chose avec toutes sortes de groupements). Nous allons ainsi doser l'effet jaune-orangé avec un rouge plus ou moins accentué.

Les leds blanches

L'avantage des leds blanches c'est qu'elles possèdent une forte luminosité. Nous pouvons donc d'abord générer une source lumineuse intense et par suite la colorer avec des filtres de couleur (papiers de bonbons par exemple ou intercalaires de classeurs en plastique transparents).

Une autre solution consiste à "colorer" les leds avec du vernis à ongle, de la lasure ou de l'encre.
Il est très facile de récupérer des leds blanches sur des lampes frontales ou des mini-torches…

Une led rgb

Aussi surprenant que cela puisse être, mais obtenir une coloration de type flamme est très facile en alimentant la puce rouge et la puce verte d'une led rgb. Il suffit de doser le courant dans chacune des puces pour obtenir une coloration lumineuse jaune/orange/rouge. Si vous alimentez la puce bleue, la lumière devient blanche.

La diffusion de la lumière

Si vous avez des leds de type claire (ou transparente) il en résulte un phénomène d'éblouissement (comme le soleil dans un ciel complètement dégagé).
Si nous désirons une lumière plutôt diffuse il faut alors disposer un diffuseur. Nous pouvons utiliser toutes sortes de matériaux pour le réaliser :

  • Balle de ping-pong décalotée,
  • papier calque à grammage faible,
  • papier sulfurisé ou autres papiers d'emballage alimentaire,
  • papier fin de soie ou papier d'emballage du boulanger,
  • toute matière transparente à la lumière mais présentant un aspect de surface "façon dépolie"…
Leds blanches avec et sans diffuseur

Dans le cas du papier, il faut juste faire un petit cylindre qui entoure les leds. Vous pouvez prendre du plastique transparent et le dépolir (comprendre le rayer) avec du papier de verre fin.

Diffusion lumineuse dans la citrouille

La chair de la citrouille est déjà jaune à orange. Si vous éclairez l'intérieur de la citrouille avec une lumière de la même couleur que la chaire, il n'est pas forcément nécessaire de mettre un diffuseur.
Il est aussi possible de faire des essais avec une lampe à led de voiture (lampe pour le clignotant orange).

Variation d'intensité lumineuse pour immiter une flamme

Pour immiter une flamme, nous avons deux paramètres à ajuster. La couleur et l'intensité lumineuse. Nous avons déjà vu comment faire varier la couleur. Maintenant il faut obtenir l'effet de scintillement. Cet effet s'obtient en faisant varier assez rapidement l'intensité lumineuse et de manière aléatoire. Le recours à une électronique de pilotage est indispensable pour gérer des variations rapides.

Pilotage par une carte Arduino

Il n'est pas difficile de piloter une led à partir d'une carte Arduino, je l'ai déjà expliqué sur le blog et dans le guide téléchargeable. Mais quelques précautions d'utilisation sont à observer :

Par sécurité, nous considérons qu'une sortie d'un atmega-328 (le micro-contrôleur de l'Arduino Uno) ne peut drainer que 20 mA (0,020 A).
Raisonablement, le courant que peut drainer une patte d'alimentation (Vcc et Gnd) du micro-contrôleur est de 150 mA.
Il faut absolument respecter ces contraintes technologiques sous peine de destruction de la carte Arduino.

Une ou deux sorties utlisant chacune 20 mA est acceptable. Si vous désirez commander 8 LEDs avec un courant permanent de 20 mA par sortie, vous prenez le risque d'endommager la carte Arduino ou son micro-contrôleur.
Nous utiliserons plutôt des leds à haut rendement ne consommant que 5 à 10 mA ou nous limitrons à 10 mA toutes les sorties avec une résistances de limitation bien calibrée (300 à 1000 ohms).

Exemple avec une à trois leds oranges

Pour une alimentation en 5 V avec un courant limité à 10 mA, la led orange que j'ai utilisé voit sa tension direct passer à 1,93 V.
La résistance de limitation a pour valeur ohmique : R=(5-1,93)/0,010=307 ohms.
Pour une sécurité accrue nous utilisons une résistance de 330 ohms. Nous pouvons aussi trier parmi un lot de résistances de 300 à 330 ohms, une valeur proche de 310 ohms par exemple. Une puissance de 1/4 watt conviendra parfaitement (330×0,012=0,033 W).

Programme pour piloter une led orange

Dans le programme suivant nous allumons la led en permanence. Cela nous permet de valider notre câblage.


//allume une led orange
//********************
// les etiquettes
int led_or = 9;
// initialisation
void setup()
{
// init mode sortie
pinMode(led_or, OUTPUT);
}
// la boucle
void loop()
{
// ecrit sur les sorties
analogWrite(led_or, 255);
}
// fin de la boucle loop

Simuler le scintillement

Nous allons pour cela faire varier la tension moyenne de la sortie analogique (celle qui pilote notre led) en lui attribuant des valeurs aléatoires. Nous utilisons une valeur mini qui n'est pas à zéro. En effet, une led ne se commande pas en tension mais en courant. Nous avons donc une loi de variation qui n'est pas linéaire.


//fait scintiller une led orange
//********************
// les etiquettes
int led_or = 9;
// initialisation
void setup()
{
// init mode sortie
pinMode(led_or, OUTPUT);
}
// la boucle
void loop()
{
// ecrit sur les sorties
analogWrite(led_or, random(20,80));
delay(random(15,100));
}
// fin de la boucle loop

Programme pour piloter une led rgb


// les etiquettes
int led_r = 9;
int led_v = 10;
int led_b = 11;
// initialisation
void setup()
{
// init mode sortie
pinMode(led_r, OUTPUT);
pinMode(led_v, OUTPUT);
pinMode(led_b, OUTPUT);
}
// la boucle
void loop()
{
// ecrit sur les sorties
analogWrite(led_v, 255);
analogWrite(led_b, 0);
analogWrite(led_r, random(20,80));
delay(random(15,100));
}
// fin de la boucle loop

Schéma de commande pour LEDs de puissance

Ici nous avons le choix entre deux solutions.
Nous pouvons utiliser une seule led de puissance ou constituer un groupement série ou série/parallèle.

Une sortie de micro-contrôleur ne peut pas piloter directement des actionneurs de puissance (led, relai, bobine, moteur…. Il faut interfacer la partie commande avec la partie puissance.
Cela signifie qu'il faut mettre en place un montage qui s'intercale entre la sortie Arduino et la led de puissance.
Comme il faut aussi garder la possibilité de piloter le courant ou la tension moyenne de la led, nous devons utiliser un transistor (temps de commutation rapide qu'un relai ne peut pas faire).

Schéma à trois leds en séries

Nous utilisons ici des led blanches rondes de 10 mm de diamètre. Chaque led possède une tension de seuil de 3,3 volts et consomme 120 mA.
Mise en série le courant dans la branche reste le même. Comme c'est la partie puissance de notre montage, il faut aussi une alimentation séparée. Ici nous utilisons du 12 V continu fourni par une petite batterie ou une alimentation secteur.

Schéma d'interface pour trois leds

Schéma à une led monopuce de puissance

C'est un montage dont l'intensité du courant est importante. Nous ne sommes plus dans la gamme des mA mais des ampères !

Le transistor à associer doit pouvoir drainer plusieurs ampères. Une commande via un optocoupleur isolera correctement la partie puissance de la partie commande.

Schéma d'interface pour une led monopuce

Retourner au début de l'article