Relógio de espelho infinito com potenciômetros: 3 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Eu me deparei com um espelho infinito e achei muito legal. Isso me inspirou a fazer um espelho infinito, mas eu precisava dele para ter um propósito. Então, decidi fazer um relógio de espelho infinito funcional. Este é um espelho infinito que permite alterar os modos, velocidade e cores usando potenciômetros. (Nota: esta é minha primeira vez fazendo algo assim)

Suprimentos

Vamos mergulhar no que você precisa para fazer isso!

Você vai precisar …

1) 1 Arduino Uno

3) 1 placa de ensaio

4) 1 interruptor deslizante

5) 3 potenciômetros

6) 1 bateria de 9 V

7) Faixa LED WS2811 de 5 metros

8) Fios de cabo de jumper

9) Um relógio (o relógio que usei, um grande relógio moderno de 12 polegadas)

10) Folha de espelho flexível (a que usei folha de espelho)

11) Filme de privacidade (aquele em que usei espelho único)

12) Pode ser necessária solda, isso depende dos materiais que você possui

Etapa 1: Fiação

A fiação é bastante simples

- O interruptor SPST liga e desliga os LEDs (A0)

- O potenciômetro esquerdo controla a luz (A1)

- O potenciômetro do meio controla os modos (A2)

- O potenciômetro certo controla a velocidade (A3)

Etapa 2: O 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 pixels na faixa

// Parâmetro 2 = número do pino (a maioria é válida)

// Parâmetro 3 = sinalizadores de tipo de pixel, some conforme necessário:

// NEO_KHZ800 800 KHz bitstream (a maioria dos produtos NeoPixel com LEDs WS2812)

// NEO_KHZ400 400 KHz (clássico 'v1' (não v2) pixels FLORA, drivers WS2811)

// NEO_GRB Pixels são conectados para GRB bitstream (a maioria dos produtos NeoPixel)

// NEO_RGB Pixels são conectados para bitstream RGB (v1 FLORA pixels, não v2)

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

void setup () {

strip.begin ();

strip.show (); // Inicializa todos os pixels para 'desligado'

}

void loop () {

if (analogRead (A0)> = 512) {

if (analogRead (A2)> = 768) {

if (analogRead (A3)> = 768) {

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

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

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

} else if (analogRead (A3)> = 256) {

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

}

outro{

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

}

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

if (analogRead (A1)> = 768) {

CylonBounce (aleatório (255), aleatório (255), aleatório (255), 4, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

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

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

} else if (analogRead (A1)> = 256) {

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

}

outro{

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

}

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

if (analogRead (A1)> = 768) {

byte r, g, b;

r = aleatório (255);

g = aleatório (255);

b = aleatório (255);

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

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

byte r, g, b;

r = aleatório (255);

g = 0;

b = 0;

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

} else if (analogRead (A1)> = 256) {

byte r, g, b;

r = 0;

g = aleatório (255);

b = 0;

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

}

outro{

byte r, g, b;

r = 0;

g = 0;

b = aleatório (255);

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

}

}

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

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

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

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

} else if (analogRead (A1)> = 256) {

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

}

outro{

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

}

}

}outro{

setAll (0, 0, 0);

}

}

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

byte * c;

uint16_t i, j;

para (j = 0; j <256 * 5; j ++) {// 5 ciclos de todas as cores na roda

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

pausa;

}

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

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

pausa;

}

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

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

}

showStrip ();

atraso (SpeedDelay);

}

}

byte * Wheel (byte WheelPos) {

byte estático c [3];

if (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;

} outro {

WheelPos - = 170;

c [0] = 0;

c [1] = WheelPos * 3;

c [2] = 255 - WheelPos * 3;

}

return c;

}

void CylonBounce (byte vermelho, 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;}

senão {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)) | | ((antigo A3 + 256)

pausa;

}

setAll (0, 0, 0);

setPixel (i, vermelho / 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)) | | ((antigo A3 + 256)

pausa;

}

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

}

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

showStrip ();

atraso (SpeedDelay);

}

atraso (ReturnDelay);

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

setAll (0, 0, 0);

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

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

pausa;

}

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

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

pausa;

}

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

}

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

showStrip ();

atraso (SpeedDelay);

}

atraso (ReturnDelay);

}

void RunningLights (byte vermelho, byte verde, byte azul, int oldA0, int oldA1, int oldA2, int oldA3) {

posição int = 0;

int WaveDelay;

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

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

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

senão {WaveDelay = 20;}

para (int j = 0; j

{

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

pausa;

}

Posição ++; // = 0; // Posição + Taxa;

para (int i = 0; i

// onda senoidal, 3 ondas compensadas formam um arco-íris!

// nível flutuante = sin (i + Posição) * 127 + 128;

// setPixel (i, nível, 0, 0);

// nível flutuante = sin (i + Posição) * 127 + 128;

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

pausa;

}

setPixel (i, ((sin (i + Posição) * 127 + 128) / 255) * vermelho, ((sin (i + posição) * 127 + 128) / 255) * verde, ((sin (i + Posição) * 127 + 128) / 255) * azul);

}

showStrip ();

atraso (WaveDelay);

}

}

void meteorRain (byte red, byte green, byte blue, byte meteorSize, byte meteoroTrailDecay, 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;}

senão {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)) | | ((antigo A3 + 256)

pausa;

}

// desvanece o brilho de todos os LEDs em um passo

para (int j = 0; j

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

pausa;

}

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

fadeToBlack (j, meteorTrailDecay);

}

}

// desenhar meteoro

para (int j = 0; j <tamanho do meteoro; j ++) {

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

pausa;

}

if ((i-j = 0)) {

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

}

}

showStrip ();

atraso (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 = (cor antiga & 0x00ff0000UL) >> 16;

g = (cor antiga & 0x0000ff00UL) >> 8;

b = (cor antiga & 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);

#fim se

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

leds [ledNo].fadeToBlackBy (fadeValue);

#fim se

}

// *** SUBSTITUIR PARA AQUI ***

void showStrip () {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.show ();

#fim se

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

FastLED.show ();

#fim se

}

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

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.setPixelColor (Pixel, strip. Color (red, green, blue));

#fim se

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

leds [Pixel].r = vermelho;

leds [Pixel].g = verde;

leds [Pixel].b = azul;

#fim se

}

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

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

setPixel (i, vermelho, verde, azul);

}

showStrip ();

}

Etapa 3: Criação do relógio

Eu recomendaria comprar um relógio de vidro que seja plano por dentro. Quando eu estava aplicando o espelho flexível no interior do relógio, houve um problema devido aos números dentro do relógio aparecerem, o espelho estava dobrado resultando no efeito de espelho infinito não acontecendo. Você precisa ter a folha de espelho flexível e o filme de privacidade para ser o mais plano possível. Se você estiver recebendo um relógio, certifique-se de colocar o LED dentro dele sem problemas.

Etapa 1: abra o relógio e remova o vidro frontal

Etapa 2: coloque o filme de privacidade no vidro frontal (este vídeo mostra como fazer isso)

Etapa 3: aplique o espelho flexível na parte interna do relógio (remova os ponteiros do relógio antes de fazer isso)

Etapa 4: faça um orifício no meio para que os ponteiros do relógio sejam colocados de volta

Etapa 5: coloque a faixa de LED em torno das paredes internas do relógio (usei uma pistola de cola quente para esta etapa)

Passo 6: Ligue a faixa de LED e coloque o vidro em cima do relógio para ver se o efeito de espelho infinito está lá

Passo 7: Depois de terminar tudo, coloque o relógio no lugar e deixe os fios passarem para trás

Etapa 8: Parabéns, você concluiu o projeto e tudo deve funcionar bem

Se você tiver alguma dúvida, comente-as abaixo (saiba que posso não ser capaz de responder, mas farei o meu melhor)