Les yeux de la citrouille - Halloween arrive à toute vitesse

Halloween arrive toujours si soudainement. Il reste encore un peu de temps avant que la sculpture sur citrouille soit lancée, mais nous pouvons déjà faire quelques préparatifs. Après le fantastique projet d'Andreas Wolter l'année dernière avec les yeux mobiles, j'ai voulu cette année bricoler et programmer une solution moins chère et résistante aux intempéries pour les yeux. 

L'idée est de placer dans les orbites des yeux scintillants dotés de RGBLED qui peuvent prendre différentes couleurs en fonction de la distance avec les personnes qui s'approchent.

Pour cela, nous avons besoin de:

Achetez directement le projet complet (sans citrouille 🎃) : Accessoires complets

Dans la série de photos suivante, je vous montrerai comment j'ai équipé le RGBLED de résistances en série et comment je l'ai adapté à une utilisation par tous les temps avec une gaine thermorétractable. Mais d'abord, je voudrais vous rappeler les choses les plus importantes concernant les RGBLEDs.

Les RGBLEDs sont, pour ainsi dire, trois LEDs dans un seul boîtier. Si vous les regardez de près, vous pouvez voir les différentes couleurs : RVB signifie rouge - vert - bleu. Par conséquent, le composant a quatre "pattes", une pour chaque couleur et une patte commune. Et voilà le premier obstacle : La jambe commune est-elle l'anode (le pôle positif) ou la cathode (le pôle négatif) ? On ne peut pas le dire d'après la forme. La seule chose que l'on peut déduire de la longueur des pattes est la connexion commune : c'est le plus long des quatre fils. L'unique fil à côté est la connexion pour le rouge, puis de l'autre côté il y a deux fils pour le vert et le bleu. La seule façon de savoir si la connexion commune est la cathode ou l'anode est de l'essayer. (Rien ne peut se casser.) Mes RGBLEDs ont une cathode commune, c'est-à-dire qu'ici la connexion est à la terre. Les trois autres pattes sont connectées via une résistance en série à des connexions compatibles avec le PWM, souvent marquées par le tilde ~. 

Lors de la mise en place de l'expérience, j'ai remarqué que le composant vert est beaucoup plus lumineux que le rouge et le bleu, j'utilise donc une résistance de série plus élevée ici et j'en tiens compte dans le croquis (voir ci-dessous). Ensuite, c'est l'heure de la soudure.

Voici le matériel utilisé : La branche la plus longue du RGBLED est la connexion commune, dans mon cas la cathode. J'utilise des résistances en série de 330 Ohm pour l'anode rouge et bleue, 680 Ohm pour la connexion verte.

Je commence par l'anode verte au milieu. La jambe est enveloppée et soudée.

Puis je soude un câble volant vert à la résistance.

Attention : En raison de la taille du connecteur Dupont, j'ai dû tirer la gaine thermorétractable verte sur le câble avant de le souder.

Aucune résistance en série n'est nécessaire pour la connexion commune. C'est pourquoi je n'ai pas raccourci le câble de liaison, mais seulement enlevé l'isolation et soudé la jambe de la LED RGB. Oh oui, si nécessaire, tirez la gaine thermorétractable sur le câble au début.

Puis j'ai rétréci le tuyau noir et vert. A défaut d'une buse d'air chaud, à l'aide d'un briquet à gaz ou d'une bougie.

Puis j'ai soudé les deux connexions extérieures (rouge et bleu) de la même manière et j'ai rétracté les tubes restants. Vous pouvez toujours deviner les résistances de série aux épaississements des tubes rétractables colorés.

Finalement, j'ai tiré une gaine thermorétractable plus grande sur les quatre câbles de connexion et les résistances de série. Cela permet non seulement d'assurer une protection contre l'humidité (pluie ou citrouille), mais aussi une décharge de traction et une stabilité mécanique.

Mon capteur de distance préféré est le VL53L0X Time of Flight, qui mesure la distance avec des impulsions de lumière infrarouge et transmet la valeur au microcontrôleur via l'interface I2C.

Sur les six connexions, nous n'utilisons que les quatre supérieures pour ce projet, VCC pouvant être connecté à 3,3V ou 5V.

Voici maintenant mon croquis pour le montage avec les yeux brillants, que vous pouvez bien sûr adapter à vos propres idées. Comme mentionné ci-dessus, nous avons besoin de sorties compatibles PWM pour chacun des RGBLEDs. J'ai connecté les deux RGBLED en parallèle, de sorte que je n'utilise que trois broches : rouge sur la broche ~3, vert sur la broche ~5 et bleu sur la broche ~6. Les composantes de couleur respectives sont envoyées à la broche respective avec analogWrite() et des valeurs comprises entre 0 et 255.

J'ai personnellement renoncé à la composante bleue (mais j'ai pris des précautions pour vos éventuels souhaits), la composante verte est élevée à longue distance et devient plus faible, la composante rouge devient plus grande avec la distance décroissante. Pour simuler le clignement des yeux, les LED s'éteignent brièvement après quelques secondes.

Pour les distances supérieures à 255 cm, la valeur est limitée à 255. La valeur PWM pour le vert correspond à la distance (en raison de la composante verte brillante de ma LED RGB, j'ai divisé la valeur par 2), la valeur pour la composante rouge est calculée avec (255 - distance). À moyenne distance, les LED rouge et verte brillent avec la même intensité, ce qui donne le jaune. Je simule le clin d'œil avec la fonction auto-définie twinkle().

Comme d'habitude, vous installez la bibliothèque pour le capteur de distance sous /Tools/Manage Libraries...J'ai choisi la bibliothèque de Polulu, qui fournit également deux exemples de sketches.

Voici le Sketch : (Download)

/*
   Eyes of the pumpkin
   RGBLED and distance sensor VL53L0X
   based on example for library VL53L0X
   by Bernd Albrecht for AZ-Delivery
 */
 ​
 #include <Wire.h>
 #include <VL53L0X.h>
 ​
 VL53L0X sensor;
 ​
 const int redPin =  3;    // the number of the red pin
 const int greenPin =  5;  // the number of the green pin
 const int bluePin =  6;   // the number of the blue pin
 int red = 128;            // initial value for red
 int green = 128;          // initial value for green
 int blue = 0;             // initial value for blue
 long interval;            // interval at which to blink (milliseconds)
 unsigned long previousMillis = 0;        // will store last time LED was updated
 ​
 void setup() {
   Serial.begin(9600);
   Wire.begin();
   
 // set the digital pin as output:
   pinMode(redPin, OUTPUT);
   pinMode(greenPin, OUTPUT);
   pinMode(bluePin, OUTPUT);
 ​
   sensor.setTimeout(500);
   if (!sensor.init())
   {
     Serial.println("Failed to detect and initialize sensor!");
     while (1) {}
   }
 ​
   // Argument is the desired inter-measurement period in ms
   sensor.startContinuous(100);
 }
 ​
 void twinkle()  {
   interval = random(3000,6000);   
   analogWrite(redPin,0);
   analogWrite(greenPin,0);  
   analogWrite(bluePin,0);
   delay(200);  
   analogWrite(redPin,red);
   analogWrite(greenPin,green);  
   analogWrite(bluePin,blue);
 }
 ​
 void loop() {
   unsigned long currentMillis = millis();
   int distance =  int(sensor.readRangeContinuousMillimeters()/10);
   Serial.print(distance);
   if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }
   Serial.println();
 ​
   if (distance > 255)  distance=255;
   red = 255-distance;
   green = int(distance/2);
   analogWrite(redPin,red);
   analogWrite(greenPin,green); 
   Serial.print("red = ");
   Serial.print(red);
   Serial.print("  green = ");
   Serial.print(green);       
   Serial.print("  Interval = ");  
   Serial.println(interval);
   if (currentMillis - previousMillis >= interval) {
     // save the last time you blinked the LED
     previousMillis = currentMillis;
     // set the LED with the ledState of the variable:
     twinkle();
     delay(250);
   }
 }

Au lieu du capteur de distance VL53L0X, vous pouvez bien sûr utiliser le capteur de distance à ultrasons HC-SR04. Ici, nous avons besoin de deux broches numériques ; la connexion de déclenchement commande l'émetteur d'ultrasons ; cela nécessite 5 V. L'écho est évalué via la deuxième broche. 

L'algorithme pour contrôler les RGBLEDs reste le même, mais une bibliothèque différente est nécessaire pour le HC-SR04. Voici les lignes déviantes dans le Sketch (Download):

 #include <HCSR04.h>
 byte triggerPin = 8;
 byte echoPin = 9;

 HCSR04.begin(triggerPin, echoPin);

dans void loop()

double* distances = HCSR04.measureDistanceCm();
 int distance =  int (distances[0]);

Amusez-vous bien avec la réplique. N'hésitez pas à m'écrire vos idées pour d'autres gadgets.