Die Augen des Kürbisses - Halloween kommt ganz plötzlich

Halloween kommt immer so plötzlich. Noch ist etwas Zeit bis das Kürbisschnitzen beginnt, aber einige Vorbereitungen können wir schon treffen. Nach dem fantastischen Projekt von Andreas Wolter im vergangenen Jahr mit den bewegten Augen wollte ich dieses Jahr eine preiswertere und wetterfeste Lösung für die Augen basteln und programmieren. 

Die Idee ist, funkelnde Augen mit RGBLEDs in die Augenhöhlen zu stecken, die verschiedene Farben in Abhängigkeit vom Abstand zu den näherkommenden Personen annehmen können.

Dafür benötigen wir:

Direkt das ganze Projekt (ohne Kürbis 🎃) kaufen: Vollständiges Zubehör

Auf der nachfolgenden Fotostrecke zeige ich Ihnen, wie ich die RGBLED mit Vorwiderständen versehen und mit Schrumpfschläuchen allwettertauglich gemacht habe. Doch zunächst möchte ich das wichtigste über RGBLEDs in Erinnerung rufen.

RGBLEDs sind sozusagen drei LEDs in einem Gehäuse. Wenn man sie von Nahem betrachtet, erkennt man die einzelnen Farben: RGB steht für rot - grün - blau. Das Bauteil hat dementsprechend vier „Beinchen“, eins je Farbe und ein gemeinsames. Und da kommt bereits die erste Hürde: Ist das gemeinsame Beinchen die Anode (der Pluspol) oder die Kathode (der Minuspol)? An der Bauform kann man es nicht erkennen. An der Länge der Beinchen erkennt man nur den gemeinsamen Anschluss: Es ist der längste der vier Drähte. Der einzelne daneben ist der Anschluss für rot, zur anderen Seite sind dann zwei Drähte für grün und blau. Bei der Frage, ob der gemeinsame Anschluss die Kathode oder die Anode ist, hilft nur ausprobieren. (Es kann nichts kaputt gehen.) Meine RGBLEDs haben eine gemeinsame Kathode, d.h. hier erfolgt der Anschluss an Masse. Die anderen drei Beinchen werden über einen Vorwiderstand an PWM-taugliche Anschlüsse gesteckt, häufig gekennzeichnet mit der Tilde ~. 

Beim Versuchsaufbau habe ich festgestellt, dass der Grün-Anteil deutlich heller ist als rot und blau, deshalb verwende ich hier einen höheren Vorwiderstand und berücksichtige das im Sketch (s.u.). Dann geht es an das Löten.

Hier das verwendete Material: Das längste Beinchen der RGBLED ist der gemeinsame Anschluss, bei mir die Kathode. Für die rote und blaue Anode verwende ich 330 Ohm – Vorwiderstände, für den grünen Anschluss 680 Ohm.

Ich beginne mit der grünen Anode in der Mitte. Das Beinchen wird umwickelt und verlötet.

Dann verlöte ich ein grünes Jumperkabel mit dem Widerstand.

Achtung: Wegen der Größe des Dupont-Steckers musste ich den grünen Schrumpfschlauch vor dem Löten über das Kabel ziehen.

Für den gemeinsamen Anschluss braucht es keinen Vorwiderstand. Deshalb habe ich das Jumperkabel nicht gekürzt, sondern nur die Isolierung entfernt und das Beinchen der RGBLED verlötet. Ach ja, auch hier ggf. vorher den Schrumpfschlauch über das Kabel ziehen.

Dann habe ich den schwarzen und grünen Schlauch geschrumpft. In Ermangelung einer Heißluftdüse habe ich dafür ein Gasfeuerzeug bzw. eine Kerze genommen.

Dann habe ich die beiden äußeren Anschlüsse (rot und blau) in gleicher Weise angelötet und die verbleibenden Schläuche geschrumpft. Man erahnt noch die Vorwiderstände an den Verdickungen in den farbigen Schrumpfschläuchen.

Am Ende habe ich über alle vier Anschlusskabel und Vorwiderstände einen größeren Schrumpfschlauch gezogen. Damit ist nicht nur Schutz gegen Feuchtigkeit (Regen bzw. Kürbis) gewährleistet, sondern auch Zugentlastung und mechanische Stabilität.

Der von mir favorisierte Abstandssensor ist der VL53L0X Time of Flight, der die Entfernung mit Infrarot-Lichtimpulsen misst und den Wert über die I2C – Schnittstelle an den Micro Controller weitergibt.

Von den sechs Anschlüssen nutzen wir für dieses Projekt nur die oberen vier, wobei VCC sowohl an 3,3V oder 5V angeschlossen werden kann.

Nun zu meinem Sketch für den Aufbau mit den leuchtenden Augen, den Sie selbstverständlich Ihren eigenen Vorstellungen anpassen können. Wie oben erwähnt, benötigen wir für die RGBLEDs jeweils PWM-fähige Ausgänge. Ich habe beide RGBLEDs parallel geschaltet, deshalb nutze ich nur drei Pins: rot an Pin ~3, grün an Pin ~5 und blau an Pin ~6. Die jeweiligen Farbanteile werden mit analogWrite() und Werten zwischen 0 und 255 an den jeweiligen Pin gesendet.

Sensor VL53L0X an ATMega328p MC:

RGBLEDs an ATMega328p MC:

Auf einen Blau-Anteil habe ich persönlich verzichtet (aber Vorsorge für Ihre möglichen Wünsche getroffen), der Grünanteil ist bei großer Entfernung hoch und wird niedriger, der Rotanteil wird mit abnehmender Entfernung größer. Um das Blinzeln von Augen zu simulieren, verlöschen die LEDs nach einigen Sekunden kurzzeitig.

Bei Distanzen über 255 cm wird der Wert auf 255 begrenzt. Der PWM-Wert für grün entspricht der Distanz (wegen des hellen Grün-Anteils bei meiner RGBLED habe ich den Wert durch 2 geteilt), der Wert für den Rot-Anteil wird berechnet mit (255 – distance). Bei mittleren Abständen leuchten die rote und grüne LED gleich hell und das ergibt dann gelb. Mit der selbst definierten Funktion twinkle() simuliere ich das Augenzwinkern.

Wie üblich installieren Sie die Bibliothek für den Abstandssensor unter /Werkzeuge/Bibliotheken verwalten … Ich habe mich für die Bibliothek von Polulu entschieden, die auch zwei Beispiel-Sketche mitliefert.

Hier der 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);
   }
 }

Anstelle des Abstandssensors VL53L0X können Sie selbstverständlich auch den Ultraschall-Abstandssensor HC-SR04 benutzen. Hierbei benötigen wir zwei digitale Pins; der Trigger-Anschluss steuert den Ultraschallsender; dieser benötigt 5 V. Das Echo wird über den zweiten Pin ausgewertet.

Sensor HC-SR04 an ATMega328p MC:

Der Algorithmus für die Ansteuerung der RGBLEDs bleibt der gleiche, jedoch wird eine andere Bibliothek für den HC-SR04 benötigt. Hier die abweichenden Zeilen im Sketch (download):

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

 HCSR04.begin(triggerPin, echoPin);

in void loop()

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

Viel Spaß beim Nachbau. Schreiben Sie mir gern Ihre Ideen für weitere Gimmicks.