Ceas cu oglindă infinită cu potențiometre: 3 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:42

Am dat peste o oglindă infinită și mi s-a părut a fi o mișto tare. Acest lucru m-a inspirat să fac o oglindă infinită, dar aveam nevoie de ea pentru a avea un scop. Așadar, am decis să fac un ceas oglindă infinită funcțional. Aceasta este o oglindă infinită care vă permite să schimbați modurile, viteza și culorile folosind potențiometre. (Notă: Este prima dată când fac așa ceva)

Provizii

Să ne scufundăm în ceea ce aveți nevoie pentru a face acest lucru!

Vei avea nevoie…

1) 1 Arduino Uno

3) 1 Pană de pâine

4) 1 Comutator glisant

5) 3 potențiometre

6) 1 baterie de 9V

7) Benzi LED de 5 metri WS2811

8) Sârme de cablu jumper

9) Un ceas (Ceasul pe care l-am folosit cu un ceas modern de 12 inci)

10) Foaie oglindă flexibilă (cea pe care am folosit-o foaie oglindă)

11) Film de confidențialitate (cel pe care l-am folosit cu o singură oglindă)

12) Este posibil să fie necesară lipirea, aceasta depinde de materialele pe care le aveți

Pasul 1: Cablare

Cablarea este destul de simplă

- Comutatorul SPST pornește și oprește LED-urile (A0)

- Potențiometrul din stânga controlează lumina (A1)

- Potențiometrul din mijloc controlează modurile (A2)

- Potențiometrul din dreapta controlează viteza (A3)

Pasul 2: Codul

#include

#define PIN 6

#define NUM_LEDS 54

#define A0 A0

#define A1 A1

#define A2 A2

#define A3 A3

// Parametrul 1 = numărul de pixeli în bandă

// Parametrul 2 = numărul pinului (majoritatea sunt valide)

// Parametrul 3 = steaguri tip pixel, adăugați împreună după cum este necesar:

// NEO_KHZ800 800 KHz bitstream (majoritatea produselor NeoPixel cu LED-uri WS2812)

// NEO_KHZ400 400 KHz (clasic 'v1' (nu v2) pixeli FLORA, drivere WS2811)

// Pixelii NEO_GRB sunt conectați la fluxul de biți GRB (majoritatea produselor NeoPixel)

// Pixelii NEO_RGB sunt conectați la fluxul de biți RGB (v1 pixeli FLORA, nu v2)

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

configurare nulă () {

strip.begin ();

strip.show (); // Inițializați toți pixelii la „dezactivat”

}

bucla nulă () {

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

}

altceva {

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

}

altceva {

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

}

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

if (analogRead (A1)> = 768) {

octet r, g, b;

r = aleatoriu (255);

g = aleatoriu (255);

b = aleatoriu (255);

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

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

octet r, g, b;

r = aleatoriu (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) {

octet r, g, b;

r = 0;

g = aleatoriu (255);

b = 0;

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

}

altceva {

octet r, g, b;

r = 0;

g = 0;

b = aleatoriu (255);

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

}

}

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

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

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

RunningLights (aleatoriu (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));

}

altceva {

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

}

}

} altceva {

setAll (0, 0, 0);

}

}

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

octet * c;

uint16_t i, j;

pentru (j = 0; j <256 * 5; j ++) {// 5 cicluri de toate culorile pe roată

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

pauză;

}

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

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

pauză;

}

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

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

}

showStrip ();

întârziere (SpeedDelay);

}

}

octet * Roată (octet WheelPos) {

octet static 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;

} altceva {

WheelPos - = 170;

c [0] = 0;

c [1] = WheelPos * 3;

c [2] = 255 - WheelPos * 3;

}

retur c;

}

void CylonBounce (octet roșu, octet verde, octet albastru, 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;}

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)) | | ((vechi A3 + 256)

pauză;

}

setAll (0, 0, 0);

setPixel (i, roșu / 10, verde / 10, albastru / 10);

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

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

pauză;

}

setPixel (i + j, roșu, verde, albastru);

}

setPixel (i + EyeSize + 1, roșu / 10, verde / 10, albastru / 10);

showStrip ();

întârziere (SpeedDelay);

}

întârziere (ReturnDelay);

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

setAll (0, 0, 0);

setPixel (i, roșu / 10, verde / 10, albastru / 10);

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

pauză;

}

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

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

pauză;

}

setPixel (i + j, roșu, verde, albastru);

}

setPixel (i + EyeSize + 1, roșu / 10, verde / 10, albastru / 10);

showStrip ();

întârziere (SpeedDelay);

}

întârziere (ReturnDelay);

}

void RunningLights (octet roșu, octet verde, octet albastru, int oldA0, int oldA1, int oldA2, int oldA3) {

Poziție int = 0;

int WaveDelay;

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

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

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

else {WaveDelay = 20;}

pentru (int j = 0; j

{

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

pauză;

}

Poziție ++; // = 0; // Poziție + Rată;

pentru (int i = 0; i

// undă sinusoidală, 3 unde compensate fac curcubeu!

// float level = sin (i + Poziție) * 127 + 128;

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

// float level = sin (i + Poziție) * 127 + 128;

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

pauză;

}

setPixel (i, ((sin (i + Poziție) * 127 + 128) / 255) * roșu, ((sin (i + Poziție) * 127 + 128) / 255) * verde, ((sin (i + Poziție) * 127 + 128) / 255) * albastru);

}

showStrip ();

întârziere (WaveDelay);

}

}

void meteorRain (octet roșu, octet verde, octet albastru, octet meteorSize, octet 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;}

altfel dacă (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)) | | ((vechi A3 + 256)

pauză;

}

// estompează luminozitatea tuturor LED-urilor cu un singur pas

pentru (int j = 0; j

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

pauză;

}

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

fadeToBlack (j, meteorTrailDecay);

}

}

// desenați meteor

for (int j = 0; j <meteorSize; j ++) {

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

pauză;

}

if ((i-j = 0)) {

setPixel (i-j, roșu, verde, albastru);

}

}

showStrip ();

întârziere (SpeedDelay);

}

}

void fadeToBlack (int ledNo, byte fadeValue) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

uint32_t oldColor;

uint8_t r, g, b;

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

#endif

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

leduri [ledNo].fadeToBlackBy (fadeValue);

#endif

}

// *** ÎNLOCUIȚI AICI ***

void showStrip () {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.show ();

#endif

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

FastLED.show ();

#endif

}

void setPixel (int Pixel, octet roșu, octet verde, octet albastru) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.setPixelColor (Pixel, strip. Color (roșu, verde, albastru));

#endif

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

leduri [Pixel].r = roșu;

leduri [Pixel].g = verde;

leduri [Pixel].b = albastru;

#endif

}

void setAll (octet roșu, octet verde, octet albastru) {

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

setPixel (i, roșu, verde, albastru);

}

showStrip ();

}

Pasul 3: Crearea ceasului

Aș recomanda să obțineți un ceas de sticlă care să fie plat în interior. Când aplicam oglinda flexibilă în interiorul ceasului, a apărut o problemă din cauza numerelor din interiorul ceasului care ieșeau, oglinda se îndoaie, rezultând efectul oglinzii infinit care nu se întâmplă. Trebuie să aveți foaia de oglindă flexibilă și filmul de confidențialitate pentru a fi cât mai plate posibil. Dacă primiți un ceas, asigurați-vă că puteți plasa LED-ul în interior fără probleme.

Pasul 1: Deschideți ceasul și scoateți sticla din față

Pasul 2: Puneți filmul de confidențialitate pe sticla frontală (Acest videoclip vă arată cum să o faceți)

Pasul 3: Aplicați oglinda flexibilă pe interiorul ceasului (Scoateți mâinile ceasurilor înainte de a face acest lucru)

Pasul 4: Faceți o gaură în mijloc pentru ca mâinile ceasului să fie așezate din nou

Pasul 5: Plasați banda LED în jurul pereților interiori ai ceasului (am folosit un pistol de adeziv fierbinte pentru acest pas)

Pasul 6: Porniți banda LED și așezați sticla deasupra ceasului pentru a vedea dacă există efectul oglinzii infinite

Pasul 7: Odată ce ați terminat, puneți ceasul împreună și lăsați firele să treacă în spate

Pasul 8: Felicitări, ați finalizat proiectul și totul ar trebui să funcționeze bine

Dacă aveți întrebări, vă rugăm să le comentați mai jos (să știți că s-ar putea să nu pot răspunde, dar voi face tot posibilul)