Gafas con anillos WS2812b RGB LED

 Un disco con el anillo WS2812b RGB led

Hola y bienvenidos a otra serie de blogs sobre nuestro WS2812b RGB led Ring. Una vez más, se trata de la cuestión actual de la mejora. Al fin y al cabo, nadie debe poder decir que el Maker no piensa también en el medio ambiente :).
Esta vez, "upciclen", vamos a hacer unas gafas de sol viejas para una elegante "discoteca" para la próxima visita a la discoteca. Aunque ya no soy una de las discotecas, creo que debería haber un proyecto entre los lectores para nuestros jóvenes jugadores. ¡Espero que les guste la idea de las gafas de Disco LED para la próxima visita de disco! Seguro que os va a encantar la multitud. Los anillos WS2812b LED funcionan aquí como"lentes de gafas". La estructura alrededor de la las dos ojeras se pueden ensamblar con gafas de sol viejas. Como Club, volvemos a usar el Arduino Nano como fuente de energía, un USB Powerbank desde el teléfono. Por lo que respecta al cableado, recomiendo que se extraiga la electricidad y la electrónica de las gafas, por lo que basta con hacer que un fino cable Adriático sobre la parte superior desaparezca de la oreja izquierda o derecha en una caja electrónica en el bolsillo de la camisa o el bolsillo de los pantalones. En esta caja electrónica, construís ... activa el teclado y otros sensores (en las partes siguientes) para controlar las gafas. Para nuestro Blog de hoy, necesitamos una actualización de hardware.:

Como partes, no necesitáis mucho:

1 xAZ-Delivery Nano V 3

2 x RGB anillo LED WS2812b con 12 RGB LEDs 5V para Arduino 50 mm de diámetro exterior

1x teclas

1x Usb Powerbank y USB cable compatible con Arduino Nano

Una vez que hayamos terminado de montar el circuito, lo siguiente que tenemos que hacer es montar la biblioteca Adafruit Neopixel para que podamos encender el LED's del anillo.
La biblioteca necesaria puede ser añadida a través de dos vías de nuestro IDE.:
1) la biblioteca de la URL https://github.com/adafruit/Adafruit_NeoPixel descargando. A continuación, en el IDE, en Sketch -> montar biblioteca- & gt;añadir manualmente ZIP biblioteca.
2) Introduzca en el administrador de la biblioteca el término de búsqueda "Adafruit Neopixel", haga clic en la biblioteca y elija "instalar". Seleccione al menos la versión 1.2.4.

Si todo ha salido bien, por favor, envíe el siguiente código al Nano.:

# include <Adafruit_NeoPixel.h>

# define BUTTON_CHANGEANIMACIÓN  12    // Digital IO pin connected to the button.  Esto va a ser                                       / driven with a pull-up resistor so the switch should                                       / pull the pin to ground momentarily.  On a high - > low                                       // transition the button press logic will execute.
# define PIXEL_PIN    6    // Digital IO pin connected to the NeoPixels.
# define PIXEL_COUNT 24   // All Pixels on Umbrella
# define MaxAninmationsAvail 1
# define STATUS_PIN 13 // Animation Control Button
Adafruit_NeoPixel strip = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_RGB + NEO_KHZ800);

const int hueRedLow = 0;
const int hueRedHigh = 255;
const int hueBlue = 170;
// The size of the angle of one sector (1/6 of a colour wheel), and of a complete
/ cycle of the colour wheel.
const int anglemina = 0;
const int angleSector = 60;
const int angleMax = 360;
const int brightMin = 0;
const int brightMax = 255;

bytes hue, brightness;
// The saturation is fixed at 255 (full) to remove blead-through of different
/ colours.
// It could be linked to another potentiómetro if a demonstration of hue
/ desired.
bytes saturation = 255;

// Temporizador Variable
int TimerSeconds = 0;  // Numerador
int Equipo de alarma de temporizador = 15; / Temporizador 15 Segundos
bool TimerStartFlagFlag = false;
bool Temporizador = true;

// Manual Operations
bool ButtonAPress  = false;
bytes LedMode = 2;

//AnimationControl
int Animación de inmersión  = 0;
int Isanimación  = 0;
int OLDLightBorder = 0;
bool GetONOFFStatus = falso;

bool OLDONOFFStatus = falso;
bool PlayIntro = falso; // Introducción
bool PlayOutro = falso; // Outro
bool ChangeAnimation = falso;
bool Corre una vez = cierto;   // variables universales
byte un,C,re,mi,F;
no firmado En t r, sol, si;

// Rutinas de interrupción

ISR(TIMER1_COMPA_vect)         {
 bool LEDChange,PressedZ; 
 // Cambiar Abfrage
 PressedZ= digitalRead(BUTTON_CHANGEANIMATION);
 Si ((PressedZ == BAJO) y (ButtonAPress == falso))     {       ButtonAPress = cierto;            }     TCNT1 = 0;      // Registrarse inicializando
}

// Finaliza las interrupciones

// comenzar programa
vacío preparar()    {          tira.empezar();     tira.espectáculo();   // Inicializa todos los píxeles a 'apagado'     pinMode(BUTTON_CHANGEANIMATION, INPUT_PULLUP);     pinMode(STATUS_PIN,SALIDA);     digitalWrite(STATUS_PIN, ALTO);     Semilla aleatoria(analogRead(0));     noInterrupts(); // Todas las interrupciones desactivadas     TCCR1A = 0x00;       TCCR1B =  0x02;     TCNT1 = 0;      // Registro de inicialización     OCR1A =  33353;      // Carga Salida Comparar Registro     TIMSK1 |= (1 << OCIE1A);  // Activar temporizador Comparar interrupción      interrumpe();   // Activa todas las interrupciones     De serie.empezar(9600);     De serie.rubor();    }

// Funciones de ayuda
vacío HSBToRGB(     no firmado En t inHue, no firmado En t inSaturación, no firmado En t enBrillo,     no firmado En t *o, no firmado En t *oG, no firmado En t *transmisión exterior )
{     Si (inSaturación == 0)     {         // acromático (gris)         *o = *oG = *transmisión exterior = enBrillo;     }     más     {         no firmado En t escalado = (inHue * 6);         no firmado En t sector = escalado >> 8; // sector 0 a 5 alrededor de la rueda de colores         no firmado En t offsetInSector = escalado - (sector << 8);  // posición dentro del sector         no firmado En t pag = (enBrillo * ( 255 - inSaturación )) >> 8;         no firmado En t q = (enBrillo * ( 255 - ((inSaturación * offsetInSector) >> 8) )) >> 8;         no firmado En t t = (enBrillo * ( 255 - ((inSaturación * ( 255 - offsetInSector )) >> 8) )) >> 8;         cambiar( sector ) {         caso 0:             *o = enBrillo;             *oG = t;             *transmisión exterior = pag;             descanso;         caso 1:             *o = q;             *oG = enBrillo;             *transmisión exterior = pag;             descanso;         caso 2:             *o = pag;             *oG = enBrillo;             *transmisión exterior = t;             descanso;         caso 3:             *o = pag;             *oG = q;             *transmisión exterior = enBrillo;             descanso;         caso 4:             *o = t;             *oG = pag;             *transmisión exterior = enBrillo;             descanso;         defecto:    // caso 5:             *o = enBrillo;             *oG = pag;             *transmisión exterior = q;             descanso;         }     }
}

vacío CheckConfigButtons ()    // InterruptRoutine
{
bool PressedZ;

Si (ButtonAPress == cierto)    {     Debería la animación = !Debería la animación;     retrasar(250);     ButtonAPress = falso;    }
} 

vacío Control de animación ()
{   En t GetSelAnimation = 0;       Si (GetONOFFStatus != OLDONOFFStatus)     {     OLDONOFFStatus = GetONOFFStatus;     Si (GetONOFFStatus)        {       Semilla aleatoria(analogRead(3));            GetSelAnimation = 1;       Debería la animación = GetSelAnimation;       De serie.impresión ("Sistema encendido. Seleccionado:");       De serie.println (Debería la animación);       } más       {       De serie.impresión ("Sistema apagado. Segundos:");       TimerStartFlagFlag = falso;       De serie.println (TimerSeconds);       Debería la animación = 0;       }   }    }

// Bucle principal  ---------------------------------------------- -------------------------

vacío lazo()    {     Control de animación();     RunAnimations();     CheckConfigButtons();   }

// Bucle principal  ---------------------------------------------- ------------------------- Ende


// Introducción
vacío Introducción_RaiseRainbow(bool ascenso)
{   brillo = 255;   En t Rainbowcolor = 0;
 Si (ascenso)
 {   para (En t yo=0; yo < tira.numPixels(); yo++)      {      // wdt_reset ();       matiz = mapa(yo + Rainbowcolor, ángulo mínimo, 60, hueRedLow, hueRedHigh); // Establecer color minuto       HSBToRGB(matiz, saturación, brillo, &r, &sol, &si); // Establecer color de hora       tira.setPixelColor(yo, r, sol, si);     // Calcular valores RGB para píxeles de hora       tira.espectáculo();       retrasar(40);     }
 } más
 {      para (En t yo=0; yo < tira.numPixels(); yo++)      {      // wdt_reset ();       tira.setPixelColor(yo, 0, 0, 0);       tira.espectáculo();       retrasar(40);     }
 } 
}
// animaciones
vacío Ani_AllOff ()
{
para ( En t yo = 0; yo < tira.numPixels(); yo++)      {               tira.setPixelColor(yo,0, 0, 0);      // todo apagado      }
tira.espectáculo();
}

vacío Ani_Rainbow(byte tiempo de retardo)
{   brillo = 100;   En t Rainbowcolor = 0;   hacer   {   para (En t yo=0; yo < tira.numPixels(); yo++)      {        matiz = mapa(yo + Rainbowcolor, ángulo mínimo, 60, hueRedLow, hueRedHigh);            HSBToRGB(matiz, saturación, brillo, &r, &sol, &si);        tira.setPixelColor(yo, r, sol, si);        }   tira.espectáculo();   // Mostrar resultados :)   retrasar(tiempo de retardo);   Rainbowcolor++ ;   } mientras (Rainbowcolor < 61);
}

vacío RunAnimations()
{   Si (!(Debería la animación == IsAnimation))   {     PlayOutro = cierto;     ChangeAnimation = cierto;   }
cambiar (IsAnimation)    {      caso 0:                                    // todos LedsOFF       Si (PlayIntro)          {                  PlayIntro = falso;         Corre una vez = cierto;         }        Si   ((!(PlayIntro)) &&  (!(PlayOutro)))        {           Si (Corre una vez) {  Ani_AllOff (); }          Corre una vez = falso;        }        Si  (PlayOutro)          {                PlayOutro  = falso;         PlayIntro = cierto;         Corre una vez = cierto;         IsAnimation = Debería la animación;         }               descanso;       caso 1:            Si (PlayIntro)          {         Introducción_RaiseRainbow(cierto);            PlayIntro = falso;         }         Si  ((!(PlayIntro)) && (!(PlayOutro)))         {           Ani_Rainbow(20);         }        Si  (PlayOutro)          {         Introducción_RaiseRainbow(falso);                      PlayOutro  = falso;         PlayIntro = cierto;         IsAnimation =  Debería la animación;         }              descanso;    }    }

Jetzt einfach kurz den Taster betätigen und das Schauspiel genießen :). Ein weiterer Tastendruck schaltet die Brille wieder aus.

Ich wünsche viel Spaß beim Nachbauen und wie immer bis zum nächsten Mal.