Orologio a specchio infinito con potenziometri: 3 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Mi sono imbattuto nello specchio infinito e l'ho trovato davvero fantastico. Questo mi ha ispirato a realizzare uno specchio infinito, ma ne avevo bisogno per avere uno scopo. Quindi, ho deciso di creare un orologio a specchio infinito funzionante. Questo è uno specchio infinito che ti permette di cambiare modalità, velocità e colori usando i potenziometri. (Nota: questa è la prima volta che faccio qualcosa del genere)

Forniture

Entriamo in quello che ti serve per realizzare questa cosa!

Avrai bisogno…

1) 1 Arduino Uno

3) 1 tagliere

4) 1 interruttore a scorrimento

5) 3 Potenziometri

6) 1 batteria da 9V

7) Striscia LED WS2811 da 5 metri

8) Cavi del ponticello

9) Un orologio (l'orologio che ho usato con un grande orologio moderno da 12 pollici)

10) Foglio specchio flessibile (quello che ho usato il foglio specchio)

11) Pellicola privacy (quella che ho usato One Way Mirror)

12) Potrebbe essere necessaria la saldatura, questo dipende dai materiali che hai

Passaggio 1: cablaggio

Il cablaggio è abbastanza semplice

- L'interruttore SPST accende e spegne i LED (A0)

- Il potenziometro sinistro comanda la luce (A1)

- Il potenziometro centrale controlla le modalità (A2)

- Il potenziometro destro controlla la velocità (A3)

Passaggio 2: il codice

#includere

#definisci PIN 6

#define NUM_LEDS 54

#definisci A0 A0

#definisci A1 A1

#definisci A2 A2

#definisci A3 A3

// Parametro 1 = numero di pixel nella striscia

// Parametro 2 = numero pin (la maggior parte è valida)

// Parametro 3 = flag di tipo pixel, sommati secondo necessità:

// NEO_KHZ800 800 KHz bitstream (la maggior parte dei prodotti NeoPixel con LED WS2812)

// NEO_KHZ400 400 KHz (pixel FLORA classici 'v1' (non v2), driver WS2811)

// I pixel NEO_GRB sono cablati per il bitstream GRB (la maggior parte dei prodotti NeoPixel)

// I pixel NEO_RGB sono cablati per il flusso di bit RGB (pixel FLORA v1, non v2)

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

void setup() {

strip.begin();

strip.show(); // Inizializza tutti i pixel su 'off'

}

ciclo vuoto() {

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));

}

altro{

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

}

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

if(analogRead(A1)>=768){

CylonBounce(random(255), random(255), random(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));

}

altro{

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 = casuale(255);

g = casuale(255);

b = casuale(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 = casuale(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 = casuale(255);

b = 0;

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

}

altro{

byte r, g, b;

r = 0;

g = 0;

b = casuale(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));

}

altro{

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

}

}

}altro{

setTutto(0, 0, 0);

}

}

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

byte *c;

uint16_t io, j;

for(j=0; j<256*5; j++) { // 5 cicli di tutti i colori sulla ruota

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

rottura;

}

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

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

rottura;

}

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

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

}

showStrip();

ritardo (SpeedDelay);

}

}

byte * Wheel(byte WheelPos) {

byte statico c[3];

if(Pos.ruota < 85) {

c[0]=PosRuota * 3;

c[1]=255 - PosizioneRuota * 3;

c[2]=0;

} else if(Pos.ruota < 170) {

WheelPos -= 85;

c[0]=255 - PosizioneRuota * 3;

c[1]=0;

c[2]=PosRuota * 3;

} altro {

WheelPos -= 170;

c[0]=0;

c[1]=PosRuota * 3;

c[2]=255 - PosizioneRuota * 3;

}

ritorno c;

}

void CylonBounce(byte rosso, byte verde, byte blu, int EyeSize, int oldA0, int oldA1, int oldA2, int oldA3){

int SpeedDelay;

int Ritardo Ritorno;

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;}

for(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))| |((vecchioA3+256)

rottura;

}

setTutto(0, 0, 0);

setPixel(i, rosso/10, verde/10, blu/10);

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

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

rottura;

}

setPixel(i+j, rosso, verde, blu);

}

setPixel(i+EyeSize+1, rosso/10, verde/10, blu/10);

showStrip();

ritardo (SpeedDelay);

}

ritardo(RitardoRitorno);

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

setTutto(0, 0, 0);

setPixel(i, rosso/10, verde/10, blu/10);

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

rottura;

}

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

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

rottura;

}

setPixel(i+j, rosso, verde, blu);

}

setPixel(i+EyeSize+1, rosso/10, verde/10, blu/10);

showStrip();

ritardo (SpeedDelay);

}

ritardo(RitardoRitorno);

}

void RunningLights(byte rosso, byte verde, byte blu, int oldA0, int oldA1, int oldA2, int oldA3) {

int Posizione=0;

int WaveDelay;

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

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

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

else{Ritardo onda=20;}

for(int j=0; j

{

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

rottura;

}

Posizione++; // = 0; //Posizione + Velocità;

for(int i=0; i

// onda sinusoidale, 3 onde sfalsate creano un arcobaleno!

//livello flottante = sin(i+Posizione) * 127 + 128;

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

//livello flottante = sin(i+Posizione) * 127 + 128;

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

rottura;

}

setPixel(i, ((sin(i+Position) * 127 + 128)/255)*rosso, ((sin(i+Position) * 127 + 128)/255)*verde, ((sin(i+Posizione) * 127 + 128)/255)*blu);

}

showStrip();

ritardo(WaveDelay);

}

}

void meteorRain(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int oldA0, int oldA1, int oldA2, int oldA3) {

setTutto(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;}

for(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))| |((vecchioA3+256)

rottura;

}

// dissolvenza della luminosità di tutti i LED in un unico passaggio

for(int j=0; j

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

rottura;

}

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

fadeToBlack(j, meteorTrailDecay);

}

}

// disegna una meteora

for(int j = 0; j < dimensione meteora; j++) {

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

rottura;

}

if((i-j =0)) {

setPixel(i-j, rosso, verde, blu);

}

}

showStrip();

ritardo (SpeedDelay);

}

}

void fadeToBlack(int ledNo, byte fadeValue) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

uint32_t oldColor;

uint8_t r, g, b;

valore int;

oldColor = strip.getPixelColor(ledNo);

r = (oldColor & 0x00ff0000UL) >> 16;

g = (oldColor & 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);

#finisci se

#ifndef ADAFRUIT_NEOPIXEL_H

// LED veloce

leds[ledNo].fadeToBlackBy(fadeValue);

#finisci se

}

// *** SOSTITUISCI QUI ***

void showStrip() {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.show();

#finisci se

#ifndef ADAFRUIT_NEOPIXEL_H

// LED veloce

FastLED.show();

#finisci se

}

void setPixel(int Pixel, byte rosso, byte verde, byte blu) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.setPixelColor(Pixel, strip. Color(rosso, verde, blu));

#finisci se

#ifndef ADAFRUIT_NEOPIXEL_H

// LED veloce

led[Pixel].r = rosso;

led[Pixel].g = verde;

led[Pixel].b = blu;

#finisci se

}

void setAll(byte rosso, byte verde, byte blu) {

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

setPixel(i, rosso, verde, blu);

}

showStrip();

}

Passaggio 3: creazione dell'orologio

Consiglierei di prendere un orologio di vetro che sia piatto all'interno. Quando stavo applicando lo specchio flessibile all'interno dell'orologio c'era un problema a causa dei numeri all'interno dell'orologio che saltavano fuori, lo specchio si piegava e l'effetto specchio infinito non si verificava. È necessario che il foglio dello specchio flessibile e la pellicola per la privacy siano il più piatti possibile. Se stai ricevendo un orologio, assicurati di poter posizionare il LED all'interno senza problemi.

Passaggio 1: apri l'orologio e rimuovi il vetro anteriore

Passaggio 2: applica la pellicola per la privacy sul vetro anteriore (questo video mostra come farlo)

Passaggio 3: applicare lo specchio flessibile all'interno dell'orologio (rimuovere le lancette dell'orologio prima di farlo)

Passaggio 4: praticare un foro nel mezzo per riposizionare le lancette dell'orologio

Passaggio 5: posiziona la striscia LED attorno alle pareti interne dell'orologio (ho usato una pistola per colla a caldo per questo passaggio)

Passaggio 6: accendi la striscia LED e posiziona il vetro sopra l'orologio per vedere se l'effetto specchio infinito è presente

Passaggio 7: una volta terminato, metti insieme l'orologio e lascia che i fili passino sul retro

Passaggio 8: Congratulazioni, hai completato il progetto e tutto dovrebbe funzionare correttamente

Se hai domande, commentale qui sotto (sappi che potrei non essere in grado di rispondere, ma farò del mio meglio)