Haz tus luces personalizadas de Vader

Había planeado subir el avance sobre mis luces de la caja del pecho de Vader, así que lo hice en tutorial y aquí está.

Mientras estuve investigando para hacer mis set de luces me di cuenta que no hay una secuencia definitiva ya que el acceso a los props originales está restringido, y las grabaciones y referencias que hay no son muy claras. Así que hice de ESB yendo cuadro por cuadro, y el resultado lo puedes ver en este video que hice:

Las cajas en el filme parecen tener 2 luces separadas por cada ranura, lo que significa que hay muchas más combinaciones y la secuencia (de haberla) es más compleja. Yo consideré 1 sola luz por cada ranura ya que es lo que casi todos hacen. Creo que sólo Space-In-Vader en Vaderbase.com tiene una caja con 2 luces por y ranura y está increíble, pero nada barata.

Después de hacer mi propio set de luces puedo decir que sería mas práctico comprarlas de Fettronics or cualquier otro proveedor, porque si nunca haz soldado componentes electrónicos puede resultar algo difícil y tardado, y después de materiales y herramientas, ... casi el único ahorro es el costo de envío y/o los impuestos. Pero la gran ventaja es que puedes personalizar tus luces, y tener la satisfacción personal de haberlas hecho tú mismo!.

Lo que necesitas es lo siguiente:

Materiales:
1 controlador Arduino. ( Adafruit Trinket o Trinket Pro.)
1 switch interruptor pequeño
1 push button
1 m cable rojo cal. 24 o 26
1 m cable negro cal. 24 o 26
1/8", 1/4", 1/2" aislante termofit o “heat shrink”
1 batería 9v. (también se puede usar usar batería recargable de litio, checa la documentación del Trinket)
9 leds rojos de alta luminosidad
1 led rojo difusos (opcional)
1 led azul difuso (opcional)
3 resistors (oro-negro-rojo-rojo)
Soldadura y pasta

Herramientas :
Cautín para electronica
Pinzas de corte y punta
“Helping hands” caimanes de ayuda
Herramienta rotativa (o Dremel)

Así que usé un pequeño controlador de Adafruit que se llama Trinket que se puede usar con arduino y está listo para usarse, y esta bastante barato ($7 usd). También un Trinket Pro que tiene el doble de características que en una de esas y hasta sonido puedes ponerle. Aca te dejo el link si quieres saber mas: Adafruit Trinket

Una cosa acerca del Trinket es que sólo tiene 3 pines analogos que aceptan PWM (Pulso Con Modulación), que quiere decir que la luz del led se puede desvanecer lentamente. Y esos son los pines 0, 1, y 4.
(*nota: el Trinket Pro tiene el doble de pines PWM).

Así que los pines ; 0, 1, 4, serán los que usemos para las luces de las ranuras.
El Pin 3 será para el botón para cambiar de secuencia.
El pins 2 es para la luces adicionales azul y rojo (opcionales)
El pin BAT es para la batería
El pin GND es tierra para aterrizar el circuito.

Y así el diagrama para el ser de luces es el siguiente:


Ahora los 3 led de cada ranura los agrupé con una tableta, y la corté con el Dremel. Y así pude montar la resistencia y los leds quedando bien separados parejitos. Y como todos los negativos tienen que ir aterrizados juntos para cerrar el circuito hice lo mismo, los monté en una tira de tableta cortada. Traté de usar el máximo de termofit posible para proteger todas las soldaduras y tratar de evitar que los cables se rompan. Te diré que a mi se me rompió mas de un cable mientras soldaba otro.

Y así es como se ve el set de luces armado:

Ahora la secuencia... La primer secuencia que definí fue la “ESB en stand by”; que tiene una pequeña pausa entre los pasos 6 y 7, y pausas completas en los pasos 8 y 10.

La segunda secuencia que definí es “ESB activa “ que tiene pequeñas pausas entre 4 y 5, entre 6 y 7, y entre 8 y 9. Y pausas completas en los pasos 12 y 14.

Y como referencia abajo te dejo las secuencias de Fettronics para ROTJ y las de Anovos para ESB y ROTJ.

Ahora, para cargar el código (o sketch) en el controlador, tienes que instalar el software de Arduino y el firmware del Trinket en tu compu, una vez instalado conectar el Trinket a la compu con un cable micro USB, y cargar el sketch con las secuencias. Checa la documentación y el website del Trinket para mayor información. Así que descarga el archivo del sketch con las secuencias, cárgalo al Trinket y córrelo a ver que tal. El sketch lo puedes personalizar como tu quieras.

*Nota: Para cambiar entre secuencias, el botón debe permanecer presionado hasta que se acabe el ciclo de la secuencia, así el Trinket puede leer que el botón fué presionado. Esto pasa porque lo programé usando el comando ‘delay’ que impide cualquier input hasta que el comando ‘delay’ haya terminado. Una mejor manera de programar sería usando ‘time’ y ‘millis’ que permiten al Trinket leer si el botón es presionado en cualquier momento. Pero no se cómo hacerlo.

Aquí está el sketch de Arduino para las luces: ESB_fade_w-button_rev1.1.ino
Mas abajo les dejo el codigo por si alguien lo quiere ver , o lo sabe mejorar, adelante.

Aquí les dejo un demo de como están mis luces:

Saludos!,

*Nota: Junté las secuencias 1 y 2, y bloquee las secuencias 3 y 4, para que al final quedaran 5 secuencias. Mientras estén bloqueadas es como si no exisiteran.

CODE, HTML o PHP Insertado:

/* Instructions
  Darth Vader Chestbox lights.
  This example code is in the public domain.

  To upload to your Gemma or Trinket:
  1) Select the proper board from the Tools->Board Menu
  2) Select USBtinyISP from the Tools->Programmer
  3) Plug in the Gemma/Trinket, make sure you see the green LED lit
  4) For windows, install the USBtiny drivers
  5) Press the button on the Gemma/Trinket - verify you see
    the red LED pulse. This means it is ready to receive data
  6) Click the upload button above within 10 seconds
*/
//Define constants and variables
const int button = 3;    // the number of the pushbutton pin used to switch between sequences.
int buttonState = 1;      // variable for reading the pushbutton status, inital value 1
int ledA = 0; // blink LED on pin 0
int ledB = 1; // blink LED on 'digital' pin 1 - AKA the built in red LED
int ledC = 4; // blink LED on pin 4
int ledD = 2; // blink LED on pin 2

// the setup routine runs once when you press reset:
void setup() {
  // initialize the digital pins as an output.
  pinMode(ledA, OUTPUT);
  pinMode(ledB, OUTPUT);
  pinMode(ledC, OUTPUT);
  pinMode(ledD, OUTPUT);
  // initialize the pushbutton pin as an input:
  pinMode(button, INPUT);
  digitalWrite(button, HIGH); //Use internal pull up resistor for the button. It saved a resistor for the button.

  delay(1000); // A delay so you know when it starts.
  {//Imperial March 1st bar as boot sequence, just for fun.
  digitalWrite(ledA, 255); //Turn LEDs on...
  digitalWrite(ledB, 255);
  digitalWrite(ledC, 255);
  delay(500); //...for this amount of time
  digitalWrite(ledA, 0);  //Then turn LEDs off...
  digitalWrite(ledB, 0);
  digitalWrite(ledC, 0);
  delay(100); // ...for this much time
  digitalWrite(ledA, 255);
  digitalWrite(ledB, 255);
  digitalWrite(ledC, 255);
  delay(500);
  digitalWrite(ledA, 0);
  digitalWrite(ledB, 0);
  digitalWrite(ledC, 0);
  delay(100);
  digitalWrite(ledA, 255);
  digitalWrite(ledB, 255);
  digitalWrite(ledC, 255);
  delay(500);
  digitalWrite(ledA, 0);
  digitalWrite(ledB, 0);
  digitalWrite(ledC, 0);
  delay(100);
  digitalWrite(ledC,255);
  delay(350);
  digitalWrite(ledC,0);
  delay(50);
  digitalWrite(ledA,255);
  delay(150);
  digitalWrite(ledA,0);
  delay(50);
  digitalWrite(ledA, 255);
  digitalWrite(ledB, 255);
  digitalWrite(ledC, 255);
  delay(500);
  digitalWrite(ledA, 0);
  digitalWrite(ledB, 0);
  digitalWrite(ledC, 0);
  delay(100);
  digitalWrite(ledC,255);
  delay(350);
  digitalWrite(ledC,0);
  delay(50);
  digitalWrite(ledA,255);
  delay(150);
  digitalWrite(ledA,0);
  delay(50);
  digitalWrite(ledA, 255);
  digitalWrite(ledB, 255);
  digitalWrite(ledC, 255);
  delay(350);
  for (int i=255; i>=0; i--) {  // PWM to fade the LED from 255 (max) to 0
  analogWrite(ledA, i);
  analogWrite(ledB, i);
  analogWrite(ledC, i);
  delay(7);
  }}

  delay(1500);
  digitalWrite(ledD, 255);
}

// the loop routine runs over and over again forever:
void loop() {
//Define the button
if (digitalRead(button) == LOW){ //if button is pressed
  digitalWrite(ledD, 0);
  buttonState++; //add to button state
  if (buttonState > 5) buttonState = 1; //Define how many button states are there. button State from 1 to 5
  delay(300); //simple button bouncing, adjust to best result.
  digitalWrite(ledD, 255);
}
switch (buttonState){ //Instruction to switch between states

case 1:
{//ESB Sequence with fading.
//Part 1 - JC Gardea's style sequence.
  for (int i=0; i<256; i++) { //STEP 1
    analogWrite(ledB, i);
    delay(1);
    }
    delay(300);
  for (int i=255; i>=0; i--) { //STEP 2
    analogWrite(ledB, i);
    delay(1);
    }
  for (int i=0; i<256; i++) {
    analogWrite(ledA, i);
    delay(1);
    }
    delay(300);
  for (int i=255; i>=0; i--) {  //STEP 3
    analogWrite(ledA, i);
    delay(1);
    }
  for (int i=0; i<256; i++) {
    analogWrite(ledB, i);
    delay(1);
    }
    delay(300);
  for (int i=255; i>=0; i--) { //STEP 4
    analogWrite(ledB, i);
    delay(1);
    }
  for (int i=0; i<256; i++) {
    analogWrite(ledA, i);
    delay(1);
    }
    delay(300);
  for (int i=255; i>=0; i--) {  //STEP 5
    analogWrite(ledA, i);
    delay(1);
    }
  for (int i=0; i<256; i++) {
    analogWrite(ledB, i);
    delay(1);
    }
    delay(300);
  for (int i=255; i>=0; i--) { //STEP 6
    analogWrite(ledB, i);
    delay(1);
    }
  for (int i=0; i<256; i++) {
    analogWrite(ledA, i);
    delay(1);
    }
    delay(300);
    for (int i=255; i>=0; i--) { //STEP 7
    analogWrite(ledA, i);
    delay(1);
    }
    delay(100);
  for (int i=0; i<256; i++) {
    analogWrite(ledA, i);
    delay(1);
    }
    delay(300); 
    for (int i=255; i>=0; i--) { //STEP 8
    analogWrite(ledA, i);
    delay(1);
    }
    delay(600);
  for (int i=0; i<256; i++) { //STEP 9
    analogWrite(ledC, i);
    delay(1);
    }
    delay(600);
  for (int i=255; i>=0; i--) {  //STEP 10
    analogWrite(ledC, i);
    delay(1);
    }
    delay(600);
/*//ESB Pt.1 sequence end. 
break;

case 2:
{//ESB Sequence with fading.
//Part 2 - JC Gardea's style sequence.*/
  for (int i=0; i<256; i++) { //STEP 1
    analogWrite(ledA, i);
    analogWrite(ledB, i);
    analogWrite(ledC, i);
    delay(1);
    }
    delay(600);
  for (int i=255; i>=0; i--) {  //STEP 2
    analogWrite(ledB, i);
    delay(1);
    }
    delay(600);
  for (int i=0; i<256; i++) { //STEP 3
    analogWrite(ledB, i);
    delay(1);
    }
    delay(600);
  for (int i=255; i>=0; i--) {  //STEP 4
    analogWrite(ledB, i);
    analogWrite(ledC, i);
    delay(1);
    }
    delay(600);
  for (int i=255; i>=0; i--) {  //STEP 5
    analogWrite(ledA, i);
    delay(1);
    }
    delay(100);
  for (int i=0; i<256; i++) {
    analogWrite(ledA, i);
    analogWrite(ledB, i);
    analogWrite(ledC, i);
    delay(1);
    }
    delay(600);
  for (int i=255; i>=0; i--) {  //STEP 6
    analogWrite(ledB, i);
    analogWrite(ledC, i);
    delay(1);
    }
    delay(600);
  for (int i=255; i>=0; i--) {  //STEP 7
    analogWrite(ledA, i);
    delay(1);
    }
    delay(100);
  for (int i=0; i<256; i++) {
    analogWrite(ledA, i);
    analogWrite(ledB, i);
    analogWrite(ledC, i);
    delay(1);
    }
    delay(600);
  for (int i=255; i>=0; i--) {  //STEP 8
    analogWrite(ledA, i);
    delay(1);
    }
    delay(600);
  for (int i=255; i>=0; i--) {  //STEP 9
    analogWrite(ledB, i);
    analogWrite(ledC, i);
    delay(1);
    }
    delay(100);
  for (int i=0; i<256; i++) {
    analogWrite(ledA, i);
    analogWrite(ledC, i);
    delay(1);
    }
    delay(600);
  for (int i=0; i<256; i++) { //STEP 10
    analogWrite(ledB, i);
    delay(1);
    }
    delay(600);
  for (int i=255; i>=0; i--) {  //STEP 11
    analogWrite(ledB, i);
    delay(1);
    }
    delay(600);
  for (int i=255; i>=0; i--) {  //STEP 12
    analogWrite(ledA, i);
    analogWrite(ledC, i);
    delay(1);
    }
    delay(750);
  for (int i=0; i<256; i++) { //STEP 13
    analogWrite(ledA, i);
    delay(1);
    }
    delay(750);
  for (int i=255; i>=0; i--) {  //STEP 14
    analogWrite(ledA, i);
    delay(1);
    }
    delay(750);}
//ESB Pt. 2 sequence end. 
break;

/*
case 3:
//ESB Sequence with fading - Fettronics's & Phaeton's style sequence.
  for (int i=0; i<256; i++) { //STEP 1
    analogWrite(ledA, i); 
    digitalWrite(ledB, 255);
    digitalWrite(ledC, 255);
    delay(2);
    }
    delay(1200);
  for (int i=255; i>=0; i--) {  //STEP 2
    analogWrite(ledB, i);
    delay(2);
    }
    delay(1200);
  for (int i=255; i>=0; i--) {//STEP 3
    analogWrite(ledA, i);
    analogWrite(ledC, i);
    delay(2);
    } 
    for (int i=0; i<256; i++) {
    analogWrite(ledB, i);
    delay(2);
    }
    delay(1200);
  for (int i=255; i>=0; i--) { //STEP 4
    analogWrite(ledB, i);
    delay(2);
    }
    for (int i=0; i<256; i++) {
    analogWrite(ledC, i);
    delay(2);
    }
    delay(1200);
  for (int i=0; i<256; i++) {//STEP 5
    analogWrite(ledB, i);
    delay(2);
    }
    delay(1200);
  for (int i=255; i>=0; i--) { //STEP 6
    analogWrite(ledC, i);
    delay(2);
    }
    delay(1200);
  for (int i=0; i<256; i++) {//STEP 7
    analogWrite(ledA, i);
    delay(2);
    }
    delay(1200);
//ESB Fettronics's & Phaeton's sequence end.
break;

case 4:
//ESB Sequence with fading - Gino's, GuCaBe's style sequence. 
  for (int i=0; i<256; i++) {//STEP 1
    analogWrite(ledC, i);
    delay(2);
    }
    delay(1200);
  for (int i=255; i>=0; i--) { //STEP 2
    analogWrite(ledC, i);
    delay(2);
    }
    delay(1200);
  for (int i=255; i>=0; i--) { //STEP 3
    analogWrite(ledA, i);
    analogWrite(ledB, i);
    delay(2);
    }
    for (int i=0; i<256; i++) {
    analogWrite(ledC, i);
    delay(2);
    }
    delay(1200);
  for (int i=0; i<256; i++) {//STEP 4
    analogWrite(ledB, i);
    delay(2);
    }
    delay(1200);
  for (int i=255; i>=0; i--) { //STEP 5
    analogWrite(ledC, i);
    delay(2);
    }
    delay(1200);
  for (int i=0; i<256; i++) {//STEP 6
    analogWrite(ledC, i);
    delay(2);
    }
    delay(1200);
  for (int i=255; i>=0; i--) { //STEP 7
    analogWrite(ledC, i);
    delay(2);
    }
    for (int i=0; i<256; i++) {
    analogWrite(ledA, i);
    delay(2);
    }
    delay(1200);
  for (int i=255; i>=0; i--) { //STEP 8
    analogWrite(ledA, i);
    delay(2);
    }
    for (int i=0; i<256; i++) {
    analogWrite(ledC, i);
    delay(2);
    }
    delay(1200);
//ESB sequence end.
break;
*/

case 2:
{//ROTJ Fettronics sequence
  for (int i=0; i<256; i++) { //STEP 1
  analogWrite(ledA, i);
  analogWrite(ledB, i);
  analogWrite(ledC, i);
  delay(2);
  }
  delay(900);
  for (int i=255; i>=0; i--) { //STEP 2
  analogWrite(ledB, i);
  delay(2);
  }
  delay(900);
  for (int i=0; i<256; i++) { //STEP 3
  analogWrite(ledB, i);
  delay(2);
  }
  delay(900);
  for (int i=255; i>=0; i--) { //STEP 4
  analogWrite(ledB, i);
  delay(2);
  }
  delay(900);
  for (int i=0; i<256; i++) { //STEP 5
  analogWrite(ledB, i);
  delay(2);
  }
  delay(900);
  for (int i=255; i>=0; i--) { //STEP 6
  analogWrite(ledA, i);
  delay(2);
  }
  delay(900);
  for (int i=255; i>=0; i--) { //STEP 7
  analogWrite(ledB, i);
  analogWrite(ledC, i);
  delay(2);
  }
  digitalWrite(ledA, 255);
  delay(450);
  digitalWrite(ledA, 0);  //STEP 8
  digitalWrite(ledB, 255);
  digitalWrite(ledC, 255);
  delay(450);
  digitalWrite(ledB, 0)  ;//STEP 9
  digitalWrite(ledC, 0);
  delay(900);
  for (int i=0; i<256; i++) { //STEP 10
  analogWrite(ledB, i);
  analogWrite(ledC, i);
  delay(2);
  }
  delay(900);
  for (int i=255; i>=0; i--) { //STEP 11
  analogWrite(ledB, i);
  analogWrite(ledC, i);
  delay(2);
  }
  delay(900);
  for (int i=0; i<256; i++) { //STEP 12
  analogWrite(ledA, i);
  analogWrite(ledB, i);
  analogWrite(ledC, i);
  delay(2);
  }
  delay(900);
  for (int i=255; i>=0; i--) { //STEP 13
  analogWrite(ledB, i);
  delay(2);
  }
  delay(900);
  digitalWrite(ledB, 255);  //STEP 14
  delay(450);
  digitalWrite(ledC, 0);  //STEP 15
  delay(450);
  digitalWrite(ledC, 255);  //STEP 16
  delay(450);
  digitalWrite(ledB, 0);  //STEP 17
  delay(450);
  for (int i=0; i<256; i++) { //STEP 18
  analogWrite(ledB, i);
  delay(2);
  }
  delay(900);
  for (int i=255; i>=0; i--) { //STEP 19
  analogWrite(ledB, i);
  delay(2);
  }
  delay(900);
  for (int i=255; i>=0; i--) { //STEP 20
  analogWrite(ledA, i);
  delay(2);
  }
  for (int i=0; i<256; i++) {
  analogWrite(ledB, i);
  delay(2);
  }
  delay(900);
  for (int i=255; i>=0; i--) { //STEP 21
  analogWrite(ledB, i);
  analogWrite(ledC, i);
  delay(2);
  }
  delay(900);
  for (int i=0; i<256; i++) { //STEP 22
  analogWrite(ledB, i);
  analogWrite(ledC, i);
  delay(2);
  }
  delay(900);
  for (int i=255; i>=0; i--) { //STEP 23
  analogWrite(ledB, i);
  analogWrite(ledC, i);
  delay(2);
  }
  delay(900); }
//ROTJ sequence end.
break;

case 3:
{//Knight Rider sequence
    for (int i=0; i<256; i++) {
    analogWrite(ledA, i);
    delay(1);
    }
    delay(150);
    for (int i=0; i<256; i++) {
    analogWrite(ledB, i);
    delay(1);
    } 
    for (int i=255; i>=0; i--) {
    analogWrite(ledA, i);
    delay(1);
    }
    delay(150);
    for (int i=0; i<256; i++) {
    analogWrite(ledC, i);
    delay(1);
    } 
    for (int i=255; i>=0; i--) {
    analogWrite(ledB, i);
    delay(1);
    }
    delay(150);
    for (int i=255; i>=0; i--) {
    analogWrite(ledC, i);
    delay(1);
    }
    delay(300);
    for (int i=0; i<256; i++) {
    analogWrite(ledC, i);
    delay(1);
    }
    delay(150);
    for (int i=0; i<256; i++) {
    analogWrite(ledB, i);
    delay(1);
    }
    for (int i=255; i>=0; i--) {
    analogWrite(ledC, i);
    delay(1);
    }
    delay(150);
    for (int i=0; i<256; i++) {
    analogWrite(ledA, i);
    delay(1);
    }
    for (int i=255; i>=0; i--) {
    analogWrite(ledB, i);
    delay(1);
    }
    delay(150);
    for (int i=255; i>=0; i--) {
    analogWrite(ledA, i);
    delay(1);
    }
    delay(300);}
//Knight Rider end
break;

case 4:
{//Breathe/Pulse sequence
    for (int i=0; i<255; i++) {
    analogWrite(ledB, i);
    delay(3);
    }
    for (int i=0; i<255; i++) {
    analogWrite(ledA, i);
    analogWrite(ledC, i);
    delay(3);
    }
    delay(400);
    for (int i=255; i>=0; i--) {
    analogWrite(ledA, i);
    analogWrite(ledC, i);
    delay(4);
    }
    for (int i=255; i>=0; i--) {
    analogWrite(ledB, i);
    delay(4);
    }
    delay(500);}
//Breathe/Pulse end.
break;

case 5:
{//Heartbeat sequence
  digitalWrite(ledA, 84);
  delay(50);
    for (int i=84; i>=0; i--) {
    analogWrite(ledA, i);
    delay(3);
    }
    for (int i=255; i>=0; i--) {
    analogWrite(ledB, i);
    analogWrite(ledA, i);
    analogWrite(ledC, i);
    delay(7);
    }
    delay(300);
  digitalWrite(ledC, 84);
  delay(50);
    for (int i=84; i>=0; i--) {
    analogWrite(ledC, i);
    delay(3);
    }
    for (int i=255; i>=0; i--) {
    analogWrite(ledB, i);
    analogWrite(ledA, i);
    analogWrite(ledC, i);
    delay(7);
    }
    delay(300);}
//Heartbeat end.
break;
}//switch ends
}

Una manera mas eficiente de hacer el código sería utlizando "push button without delay" lo que eliminaria todos las ordenes "delay" y me permitirian cambiar de secuencia en el instante en el que el botón sea presionado, sin tener que esperar a que la secuencia termine. Pero tendría que cambiar el codigo completo utilizando los comandos "time" y "millis", sólo que aun no le entiendo bien como se usa.
https://www.baldengineer.com/millis-tutorial.html