Reloj de espejo infinito con potenciómetros: 3 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:40

Me encontré con un espejo infinito y me pareció realmente genial. Esto me inspiró a hacer un espejo infinito, pero lo necesitaba para tener un propósito. Entonces, decidí hacer un reloj de espejo infinito que funcione. Este es un espejo infinito que te permite cambiar los modos, la velocidad y los colores mediante potenciómetros. (Nota: esta es la primera vez que hago algo como esto)

Suministros

¡Vamos a sumergirnos en lo que necesitas para hacer esto!

Necesitará…

1) 1 Arduino Uno

3) 1 tablero

4) 1 interruptor deslizante

5) 3 potenciómetros

6) 1 batería de 9V

7) Tira de LED WS2811 de 5 metros

8) Cables de cable de puente

9) Un reloj (el reloj que usé un reloj moderno grande de 12 pulgadas)

10) Hoja de espejo flexible (la que usé Hoja de espejo)

11) Película de privacidad (la que usé One Way Mirror)

12) Es posible que se requiera soldar, esto depende de los materiales que tenga

Paso 1: cableado

El cableado es bastante simple.

- El interruptor unipolar enciende y apaga los LED (A0)

- El potenciómetro izquierdo controla la luz (A1)

- El potenciómetro central controla los modos (A2)

- El potenciómetro derecho controla la velocidad (A3)

Paso 2: el código

#incluir

#define PIN 6

#define NUM_LEDS 54

#define A0 A0

#define A1 A1

#define A2 A2

#define A3 A3

// Parámetro 1 = número de píxeles en la tira

// Parámetro 2 = número de pin (la mayoría son válidos)

// Parámetro 3 = banderas de tipo de píxel, agregue según sea necesario:

// NEO_KHZ800 800 KHz bitstream (la mayoría de los productos NeoPixel con LED WS2812)

// NEO_KHZ400 400 KHz (píxeles FLORA clásicos 'v1' (no v2), controladores WS2811)

// Los píxeles NEO_GRB están conectados para el flujo de bits GRB (la mayoría de los productos NeoPixel)

// Los píxeles NEO_RGB están conectados para el flujo de bits RGB (píxeles FLORA v1, no v2)

Adafruit_NeoPixel strip = Adafruit_NeoPixel (NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);

configuración vacía () {

strip.begin ();

strip.show (); // Inicializar todos los píxeles a 'desactivados'

}

bucle vacío () {

if (analogRead (A0)> = 512) {

si (analogRead (A2)> = 768) {

si (analogRead (A3)> = 768) {

rainbowCycle (80, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

} más si (analogRead (A3)> = 512) {

rainbowCycle (60, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

} más si (analogRead (A3)> = 256) {

rainbowCycle (40, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

}

demás{

rainbowCycle (20, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

}

} else if (analogRead (A2)> = 512) {

si (analogRead (A1)> = 768) {

CylonBounce (aleatorio (255), aleatorio (255), aleatorio (255), 4, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

} más si (analogRead (A1)> = 512) {

CylonBounce (aleatorio (255), 0, 0, 4, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

} más si (analogRead (A1)> = 256) {

CylonBounce (0, aleatorio (255), 0, 4, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

}

demás{

CylonBounce (0, 0, aleatorio (255), 4, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

}

} más si (analogRead (A2)> = 256) {

si (analogRead (A1)> = 768) {

byte r, g, b;

r = aleatorio (255);

g = aleatorio (255);

b = aleatorio (255);

meteorRain (r, g, b, 10, 20, verdadero, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

} más si (analogRead (A1)> = 512) {

byte r, g, b;

r = aleatorio (255);

g = 0;

b = 0;

meteorRain (r, g, b, 10, 20, verdadero, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

} más si (analogRead (A1)> = 256) {

byte r, g, b;

r = 0;

g = aleatorio (255);

b = 0;

meteorRain (r, g, b, 10, 20, verdadero, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

}

demás{

byte r, g, b;

r = 0;

g = 0;

b = aleatorio (255);

meteorRain (r, g, b, 10, 20, verdadero, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

}

}

else {if (analogRead (A1)> = 768) {

RunningLights (aleatorio (255), aleatorio (255), aleatorio (255), analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

} más si (analogRead (A1)> = 512) {

RunningLights (aleatorio (255), 1, 1, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

} más si (analogRead (A1)> = 256) {

RunningLights (1, aleatorio (255), 1, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

}

demás{

RunningLights (1, 1, aleatorio (255), analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

}

}

}demás{

setAll (0, 0, 0);

}

}

void rainbowCycle (int SpeedDelay, int oldA0, int oldA1, int oldA2, int oldA3) {

byte * c;

uint16_t i, j;

for (j = 0; j <256 * 5; j ++) {// 5 ciclos de todos los colores en la rueda

if (oldA0! = analogRead (A0) || ((oldA1-256)> analogRead (A1)) || ((oldA1 + 256) analogRead (A2)) || ((oldA2 + 256) analogRead (A3)) | | ((antiguo A3 + 256)

rotura;

}

para (i = 0; i <NUM_LEDS; i ++) {

if (oldA0! = analogRead (A0) || ((oldA1-256)> analogRead (A1)) || ((oldA1 + 256) analogRead (A2)) || ((oldA2 + 256) analogRead (A3)) | | ((antiguo A3 + 256)

rotura;

}

c = Rueda (((i * 256 / NUM_LEDS) + j) & 255);

setPixel (i, * c, * (c + 1), * (c + 2));

}

showStrip ();

retraso (SpeedDelay);

}

}

byte * Wheel (byte WheelPos) {

byte estático c [3];

si (WheelPos <85) {

c [0] = WheelPos * 3;

c [1] = 255 - WheelPos * 3;

c [2] = 0;

} else if (WheelPos <170) {

WheelPos - = 85;

c [0] = 255 - WheelPos * 3;

c [1] = 0;

c [2] = WheelPos * 3;

} demás {

WheelPos - = 170;

c [0] = 0;

c [1] = WheelPos * 3;

c [2] = 255 - WheelPos * 3;

}

return c;

}

void CylonBounce (byte rojo, byte verde, byte azul, int EyeSize, int oldA0, int oldA1, int oldA2, int oldA3) {

int SpeedDelay;

int ReturnDelay;

if (analogRead (A3)> = 768) {SpeedDelay = 80; ReturnDelay = 120;}

else if (analogRead (A3)> = 512) {SpeedDelay = 60; ReturnDelay = 100;}

else if (analogRead (A3)> = 256) {SpeedDelay = 40; ReturnDelay = 80;}

else {SpeedDelay = 20; ReturnDelay = 60;}

para (int i = 0; i <NUM_LEDS-EyeSize-2; i ++) {

if (oldA0! = analogRead (A0) || ((oldA1-256)> analogRead (A1)) || ((oldA1 + 256) analogRead (A2)) || ((oldA2 + 256) analogRead (A3)) | | ((antiguo A3 + 256)

rotura;

}

setAll (0, 0, 0);

setPixel (i, rojo / 10, verde / 10, azul / 10);

para (int j = 1; j <= EyeSize; j ++) {

if (oldA0! = analogRead (A0) || ((oldA1-256)> analogRead (A1)) || ((oldA1 + 256) analogRead (A2)) || ((oldA2 + 256) analogRead (A3)) | | ((antiguo A3 + 256)

rotura;

}

setPixel (i + j, rojo, verde, azul);

}

setPixel (i + EyeSize + 1, rojo / 10, verde / 10, azul / 10);

showStrip ();

retraso (SpeedDelay);

}

retraso (ReturnDelay);

para (int i = NUM_LEDS-EyeSize-2; i> 0; i--) {

setAll (0, 0, 0);

setPixel (i, rojo / 10, verde / 10, azul / 10);

if (oldA0! = analogRead (A0) || ((oldA1-256)> analogRead (A1)) || ((oldA1 + 256) analogRead (A2)) || ((oldA2 + 256) analogRead (A3)) | | ((antiguo A3 + 256)

rotura;

}

para (int j = 1; j <= EyeSize; j ++) {

if (oldA0! = analogRead (A0) || ((oldA1-256)> analogRead (A1)) || ((oldA1 + 256) analogRead (A2)) || ((oldA2 + 256) analogRead (A3)) | | ((antiguo A3 + 256)

rotura;

}

setPixel (i + j, rojo, verde, azul);

}

setPixel (i + EyeSize + 1, rojo / 10, verde / 10, azul / 10);

showStrip ();

retraso (SpeedDelay);

}

retraso (ReturnDelay);

}

Void RunningLights (byte rojo, byte verde, byte azul, int oldA0, int oldA1, int oldA2, int oldA3) {

int Posición = 0;

int WaveDelay;

if (analogRead (A3)> = 768) {WaveDelay = 80;}

si no (analogRead (A3)> = 512) {WaveDelay = 60;}

si no (analogRead (A3)> = 256) {WaveDelay = 40;}

else {WaveDelay = 20;}

para (int j = 0; j

{

if (oldA0! = analogRead (A0) || ((oldA1-256)> analogRead (A1)) || ((oldA1 + 256) analogRead (A2)) || ((oldA2 + 256) analogRead (A3)) | | ((antiguo A3 + 256)

rotura;

}

Posición ++; // = 0; // Posición + Tasa;

para (int i = 0; i

// onda sinusoidal, ¡3 ondas compensadas forman un arcoíris!

// nivel flotante = sin (i + Posición) * 127 + 128;

// setPixel (i, nivel, 0, 0);

// nivel flotante = sin (i + Posición) * 127 + 128;

if (oldA0! = analogRead (A0) || ((oldA1-256)> analogRead (A1)) || ((oldA1 + 256) analogRead (A2)) || ((oldA2 + 256) analogRead (A3)) | | ((antiguo A3 + 256)

rotura;

}

setPixel (i, ((sin (i + Posición) * 127 + 128) / 255) * rojo, ((sin (i + Posición) * 127 + 128) / 255) * verde, ((sin (i + Posición) * 127 + 128) / 255) * azul);

}

showStrip ();

retraso (WaveDelay);

}

}

void meteorRain (byte rojo, byte verde, byte azul, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int oldA0, int oldA1, int oldA2, int oldA3) {

setAll (0, 0, 0);

int SpeedDelay;

if (analogRead (A3)> = 768) {SpeedDelay = 80;}

else if (analogRead (A3)> = 512) {SpeedDelay = 60;}

else if (analogRead (A3)> = 256) {SpeedDelay = 40;}

else {SpeedDelay = 20;}

para (int i = 0; i <NUM_LEDS + NUM_LEDS; i ++) {

if (oldA0! = analogRead (A0) || ((oldA1-256)> analogRead (A1)) || ((oldA1 + 256) analogRead (A2)) || ((oldA2 + 256) analogRead (A3)) | | ((antiguo A3 + 256)

rotura;

}

// atenuar el brillo de todos los LED en un paso

para (int j = 0; j

if (oldA0! = analogRead (A0) || ((oldA1-256)> analogRead (A1)) || ((oldA1 + 256) analogRead (A2)) || ((oldA2 + 256) analogRead (A3)) | | ((antiguo A3 + 256)

rotura;

}

if ((! meteorRandomDecay) || (aleatorio (10)> 5)) {

fadeToBlack (j, meteorTrailDecay);

}

}

// dibujar meteorito

para (int j = 0; j <tamañometeor; j ++) {

if (oldA0! = analogRead (A0) || ((oldA1-256)> analogRead (A1)) || ((oldA1 + 256) analogRead (A2)) || ((oldA2 + 256) analogRead (A3)) | | ((antiguo A3 + 256)

rotura;

}

si ((i-j = 0)) {

setPixel (i-j, rojo, verde, azul);

}

}

showStrip ();

retraso (SpeedDelay);

}

}

void fadeToBlack (int ledNo, byte fadeValue) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

uint32_t oldColor;

uint8_t r, g, b;

valor int;

oldColor = strip.getPixelColor (ledNo);

r = (color antiguo y 0x00ff0000UL) >> 16;

g = (color antiguo y 0x0000ff00UL) >> 8;

b = (oldColor & 0x000000ffUL);

r = (r <= 10)? 0: (int) r- (r * fadeValue / 256);

g = (g <= 10)? 0: (int) g- (g * fadeValue / 256);

b = (b <= 10)? 0: (int) b- (b * fadeValue / 256);

strip.setPixelColor (ledNo, r, g, b);

#terminara si

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

leds [ledNo].fadeToBlackBy (fadeValue);

#terminara si

}

// *** SUSTITUIR A AQUÍ ***

void showStrip () {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.show ();

#terminara si

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

FastLED.show ();

#terminara si

}

void setPixel (int Pixel, byte rojo, byte verde, byte azul) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.setPixelColor (Pixel, strip. Color (rojo, verde, azul));

#terminara si

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

leds [Pixel].r = rojo;

leds [Pixel].g = verde;

leds [Pixel].b = azul;

#terminara si

}

void setAll (byte rojo, byte verde, byte azul) {

para (int i = 0; i <NUM_LEDS; i ++) {

setPixel (i, rojo, verde, azul);

}

showStrip ();

}

Paso 3: creación del reloj

Recomendaría conseguir un reloj de cristal que sea plano por dentro. Cuando estaba aplicando el espejo flexible en el interior del reloj, había un problema debido a que los números dentro del reloj salían, el espejo se doblaba y el efecto de espejo infinito no sucedía. Debe tener la hoja de espejo flexible y la película de privacidad para que sean lo más planas posible. Si está comprando un reloj, asegúrese de que puede colocar el LED en el interior sin problemas.

Paso 1: abre el reloj y quita el cristal frontal

Paso 2: coloque la película de privacidad en el vidrio frontal (este video le muestra cómo hacerlo)

Paso 3: aplique el espejo flexible en el interior del reloj (retire las manecillas del reloj antes de hacer esto)

Paso 4: Haga un agujero en el medio para colocar las manecillas del reloj.

Paso 5: coloque la tira de LED alrededor de las paredes interiores del reloj (utilicé una pistola de pegamento caliente para este paso)

Paso 6: Encienda la tira de LED y coloque el vidrio en la parte superior del reloj para ver si el efecto de espejo infinito está ahí.

Paso 7: Una vez que haya terminado con todo, coloque el reloj junto y deje que los cables pasen por la parte posterior

Paso 8: Felicitaciones, ha completado el proyecto y todo debería funcionar bien

Si tiene alguna pregunta, por favor coméntela a continuación (sepa que es posible que no pueda responder, pero haré todo lo posible)