Los ojos de la calabaza - Halloween llega de imprevisto

Halloween siempre llega tan de imprevisto. Todavía queda algo de tiempo antes de que empiece a tallar calabazas, pero ya podemos hacer algunos preparativos. Después del fantástico Proyecto de Andreas Wolter del año pasado con los ojos móviles, este año quise trastear y programar una solución más económica y resistente a la intemperie para los ojos.

La idea es colocar ojos brillantes con RGB LEDs en las cuencas de los ojos que pueden adoptar diferentes colores en función de la distancia a las que se acerquen las personas.

Para esto necesitamos:

En la siguiente serie de fotos, le presento como he instalado el RGB LED con resistencias en serie y lo he hecho apto para su uso en todo tipo de clima con tubo termirretráctil. Pero en primer lugar, me gustaría recordarle lo más importante sobre los RGB LEDs.

Los RGB LEDs son, por así decirlo, tres LED en una sola carcasa. Si los mira de cerca, puede reconocer los colores individuales: RGB significa rojo - verde - azul. De esta forma, el componente tiene cuatro "patas", uno para cada color y una común. Y aquí se presenta el primer obstáculo: ¿La pata común es el ánodo (el polo positivo) o el cátodo (el polo negativo)? No se puede reconocer en el diseño. Lo único que se puede distinguir por la longitud de las patas es la conexión común: es el más largo de los cuatro cables. El único al lado es la conexión para el rojo, al otro lado hay dos cables para el verde y el azul. La única manera de saber si la conexión común es el cátodo o el ánodo es probarlo. (Nada se puede romper) Mis RGB LEDs tienen un cátodo común, es decir, aquí la conexión es a tierra. Las otras tres patas se conectan a terminales compatibles con PWM a través de una resistencia en serie, a menudo marcadas con la tilde ~.

Durante el experimento me he dado cuenta de que la parte verde es claramente más brillante que la roja y la azul, así que aquí utilizo una resistencia en serie más alta y lo tengo en cuenta que en el sketch (ver más abajo). Entonces es el momento de soldar.

Este es el material utilizado: la pata más larga del RGB LED es la conexión común, en mi caso el cátodo. Para ánodo rojo y azul utilizo resistencias en serie de 330 Ohm, para la conexión verde 680 Ohm.

Comienzo con el ánodo verde en el medio. La pata se envuelve y se suelda.

Luego sueldo un cable de puente verde a la resistencia.

Atención: Debido al tamaño del conector DuPont, tuve que tirar del tubo termorretráctil verde sobre el cable antes de soldarlo.

No es necesario utilizar una resistencia en serie para la conexión común. Por eso no acorté el cable de puente, sino que sólo retiré el aislamiento y soldé la pata del RGB LED. Ah, sí, también hay que colocar el tubo termorretráctil sobre el cable antes de soldarlo.

A continuación, encogí los tubos negros y verdes. En ausencia de una boquilla de aire caliente utilicé un encendedor de gas o una vela.

Entonces soldé las dos conexiones exteriores (rojo y azul) de la misma manera y encogí a los tubos restantes. Todavía se pueden ver las resistencias de la serie en los engrosamientos de los tubos retráctiles de colores.

Al final puse un tubo retráctil más grande sobre los cuatro cables de conexión y las resistencias. Esto no sólo proporciona protección contra la humedad (lluvia o calabaza), pero también alivio de la tensión y la estabilidad mecánica.

El sensor de distancia que prefiero es el VL53L0X Tiempo de Vuelo que mide la distancia con pulsos de luz infrarroja y transmite el valor al microcontrolador a través de la interfaz I2C.

De las seis conexiones, sólo utilizamos las cuatro superiores para este proyecto, donde VCC se puede conectar tanto a 3,3V como a 5V.

A continuación, mi boceto para la construcción con los ojos brillantes, que se pueden personalizar con sus propias ideas. Como se mencionó anteriormente, necesitamos salidas con capacidad PWM para cada uno de los RGB LEDs. He conectado los dos RGB LEDs en paralelo, por lo que sólo utilizo tres pines: rojo en el pin ~ 3, verde en el pin ~ 5 y azul en el pin ~ 6. Los componentes de color respectivos se envían al pin correspondiente con analogWrite () y los valores entre 0 y 255.

Personalmente, he omitido el componente azul (pero he tomado precauciones para sus posibles deseos), el componente verde es alto a largas distancias y se vuelve más bajo, el componente rojo se hace más grande con la disminución de la distancia. Para simular el parpadeo de los ojos, los LEDs se apagan brevemente después de unos segundos.

Para distancias superiores a 255 cm, el valor se limita a 255. El valor PWM para el verde corresponde a la distancia (debido a la parte verde brillante de mi RGB LED dividí el valor por 2), el valor del para la parte roja se calcula con (255 - distance). A media distancia, los LEDs rojos y verdes brillan con la misma intensidad, lo que da lugar al color amarillo. Con la función de autodefinido twinkle () simulo el guiño de un ojo.

Como es habitual, se instala la librería del sensor de distancia en / Gestión de herramientas / Gestión de librerías ... decidí la librería de Polulu, que también presenta dos sketches de ejemplo.

Aquí está el sketch (descargar):

 /*
   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);
   }
 }

Por supuesto, en lugar del sensor de distancia VL53L0X, también puede utilizar el sensor de distancia ultrasónico HC-SR04. En este caso, necesitamos dos pines digitales; el pin de disparo controla el transmisor ultrasónico, que requiere 5V. El eco se evalúa a través del segundo PIN.

El algoritmo para controlar los RGB LEDS sigue siendo el mismo, pero se necesita otra librería para el HC-SR04. Aquí están las diferentes líneas del sketch (descargar):

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

 HCSR04.begin(triggerPin, echoPin);

en void loop ()

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

Diviértase con la reconstrucción. No dude en escribirme sus ideas para otros trucos.