Zegar z lustrem nieskończoności z potencjometrami: 3 kroki

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:28

Natknąłem się na lustro nieskończoności i stwierdziłem, że jest naprawdę fajne. To zainspirowało mnie do stworzenia lustra nieskończoności, ale potrzebowałem, żeby miało jakiś cel. Postanowiłem więc stworzyć działający zegar z lustrem nieskończoności. To lustro nieskończoności, które pozwala zmieniać tryby, prędkość i kolory za pomocą potencjometrów. (Uwaga: to mój pierwszy raz, kiedy robię coś takiego)

Kieszonkowe dzieci

Zagłębmy się w to, czego potrzebujesz, aby to zrobić!

Będziesz potrzebować…

1) 1 Arduino Uno

3) 1 deska do krojenia chleba

4) 1 przełącznik suwakowy

5) 3 potencjometry

6) 1 bateria 9 V

7) 5-metrowa taśma LED WS2811

8) Przewody kabla połączeniowego

9) Zegar (zegar, którego użyłem 12-calowy duży nowoczesny zegar)

10) Elastyczny arkusz lustrzany (ten, którego użyłem arkusz lustrzany)

11) Film prywatności (ten, którego użyłem One Way Mirror)

12) Może być wymagane lutowanie, zależy to od posiadanych materiałów

Krok 1: Okablowanie

Okablowanie jest dość proste

- Przełącznik SPST włącza i wyłącza diody LED (A0)

- Lewy potencjometr steruje światłem (A1)

- Środkowy potencjometr steruje trybami (A2)

- Prawy potencjometr kontroluje prędkość (A3)

Krok 2: Kodeks

#włączać

#zdefiniuj PIN 6

#define NUM_LEDS 54

#zdefiniuj A0 A0

#zdefiniuj A1 A1

#zdefiniuj A2 A2

#definiuj A3 A3

// Parametr 1 = liczba pikseli w pasku

// Parametr 2 = numer pinu (większość jest prawidłowa)

// Parametr 3 = flagi typu piksela, dodaj je w razie potrzeby:

// NEO_KHZ800 800 KHz bitstream (większość produktów NeoPixel z diodami LED WS2812)

// NEO_KHZ400 400 KHz (klasyczne „v1” (nie v2) piksele FLORA, sterowniki WS2811)

// Piksele NEO_GRB są podłączone do strumienia bitów GRB (większość produktów NeoPixel)

// Piksele NEO_RGB są podłączone do strumienia bitów RGB (piksele v1 FLORA, nie v2)

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

pusta konfiguracja () {

strip.początek();

strip.pokaż(); // Zainicjuj wszystkie piksele na „wyłączone”

}

pusta pętla () {

if(analogowyOdczyt(A0)>=512){

jeśli (analogowyOdczyt(A2)>=768){

jeśli (analogowyOdczyt (A3)>=768){

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

}jeżeli(analogRead(A3)>=512){

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

}jeżeli(analogodczyt(A3)>=256){

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

}

w przeciwnym razie{

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

}

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

jeśli (analogowyOdczyt(A1)>=768){

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

}jeżeli(analogRead(A1)>=512){

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

}jeżeli(analogRead(A1)>=256){

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

}

w przeciwnym razie{

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

}

}jeżeli(analogRead(A2)>=256){

jeśli (analogowyOdczyt(A1)>=768){

bajt r, g, b;

r = losowy (255);

g = losowo (255);

b = losowy (255);

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

}jeżeli(analogRead(A1)>=512){

bajt r, g, b;

r = losowy (255);

g = 0;

b = 0;

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

}jeżeli(analogRead(A1)>=256){

bajt r, g, b;

r = 0;

g = losowo (255);

b = 0;

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

}

w przeciwnym razie{

bajt r, g, b;

r = 0;

g = 0;

b = losowy (255);

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

}

}

inaczej {jeśli (analogowyOdczyt(A1)>=768){

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

}jeżeli(analogRead(A1)>=512){

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

}jeżeli(analogRead(A1)>=256){

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

}

w przeciwnym razie{

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

}

}

}w przeciwnym razie{

ustawWszystko(0, 0, 0);

}

}

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

bajt *c;

uint16_ti, j;

for(j=0; j<256*5; j++) { // 5 cykli wszystkich kolorów na kole

if(staryA0!=analogowyOdczyt(A0)||((staryA1-256)>analogowyOdczyt(A1))||((staryA1+256)analogowyOdczyt(A2))||((staryA2+256)analogowyOdczyt(A3))| |((stary A3+256)

przerwa;

}

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

if(staryA0!=analogowyOdczyt(A0)||((staryA1-256)>analogowyOdczyt(A1))||((staryA1+256)analogowyOdczyt(A2))||((staryA2+256)analogowyOdczyt(A3))| |((staryA3+256)

przerwa;

}

c=Koło(((i * 256 / LICZBA_LED) + j) & 255);

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

}

pokażStrip();

opóźnienie (SpeedDelay);

}

}

bajt * Koło(bajt Poz koła) {

bajt statyczny c[3];

if(Pozycja Koła < 85) {

c[0]=Pozycja koła * 3;

c[1]=255 - Pozycja koła * 3;

c[2]=0;

} else if(WheelPos < 170) {

Pozycja koła -= 85;

c[0]=255 - Pozycja koła * 3;

c[1]=0;

c[2]=Pozycja koła * 3;

} w przeciwnym razie {

Pozycja koła -= 170;

c[0]=0;

c[1]=Pozycja koła * 3;

c[2]=255 - Pozycja koła * 3;

}

powrót c;

}

void CylonBounce(bajt czerwony, bajt zielony, bajt niebieski, int EyeSize, int staryA0, int staryA1, int staryA2, int staryA3){

int Opóźnienie Prędkości;

int Opóźnienie Zwrotu;

if(analogowyOdczyt(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{Opóźnienie Opóźnienia=20;Opóźnienie Zwrotu=60;}

for(int i = 0; i < NUM_LEDS-Rozmiar oczu-2; i++) {

if(staryA0!=analogowyOdczyt(A0)||((staryA1-256)>analogowyOdczyt(A1))||((staryA1+256)analogowyOdczyt(A2))||((staryA2+256)analogowyOdczyt(A3))| |((stary A3+256)

przerwa;

}

ustawWszystko(0, 0, 0);

setPixel(i, czerwony/10, zielony/10, niebieski/10);

for(int j = 1; j <= Rozmiar Oczu; j++) {

if(staryA0!=analogowyOdczyt(A0)||((staryA1-256)>analogowyOdczyt(A1))||((staryA1+256)analogowyOdczyt(A2))||((staryA2+256)analogowyOdczyt(A3))| |((stary A3+256)

przerwa;

}

setPixel(i+j, czerwony, zielony, niebieski);

}

setPixel(i+EyeSize+1, czerwony/10, zielony/10, niebieski/10);

pokażStrip();

opóźnienie (SpeedDelay);

}

opóźnienie (opóźnienie powrotu);

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

ustawWszystko(0, 0, 0);

setPixel(i, czerwony/10, zielony/10, niebieski/10);

if(staryA0!=analogowyOdczyt(A0)||((staryA1-256)>analogowyOdczyt(A1))||((staryA1+256)analogowyOdczyt(A2))||((staryA2+256)analogowyOdczyt(A3))| |((staryA3+256)

przerwa;

}

for(int j = 1; j <= Rozmiar Oczu; j++) {

if(staryA0!=analogowyOdczyt(A0)||((staryA1-256)>analogowyOdczyt(A1))||((staryA1+256)analogowyOdczyt(A2))||((staryA2+256)analogowyOdczyt(A3))| |((staryA3+256)

przerwa;

}

setPixel(i+j, czerwony, zielony, niebieski);

}

setPixel(i+EyeSize+1, czerwony/10, zielony/10, niebieski/10);

pokażStrip();

opóźnienie (SpeedDelay);

}

opóźnienie (opóźnienie powrotu);

}

void RunningLights(bajt czerwony, bajt zielony, bajt niebieski, int staryA0, int staryA1, int staryA2, int staryA3) {

int Pozycja=0;

int Opóźnienie fali;

if(analogowyOdczyt(A3)>=768){Opóźnienie Fal=80;}

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

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

inny{WaveDelay=20;}

for(int j=0; j

{

if(staryA0!=analogowyOdczyt(A0)||((staryA1-256)>analogowyOdczyt(A1))||((staryA1+256)analogowyOdczyt(A2))||((staryA2+256)analogowyOdczyt(A3))| |((stary A3+256)

przerwa;

}

Stanowisko++; // = 0; //Pozycja + Stawka;

for(int i=0; i

// sinusoida, 3 przesunięte fale tworzą tęczę!

//poziom zmiennoprzecinkowy = sin(i+Pozycja) * 127 + 128;

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

//poziom zmiennoprzecinkowy = sin(i+Pozycja) * 127 + 128;

if(staryA0!=analogowyOdczyt(A0)||((staryA1-256)>analogowyOdczyt(A1))||((staryA1+256)analogowyOdczyt(A2))||((staryA2+256)analogowyOdczyt(A3))| |((staryA3+256)

przerwa;

}

setPixel(i, ((sin(i+Pozycja) * 127 + 128)/255)*czerwony, ((sin(i+Pozycja) * 127 + 128)/255)*zielony, ((sin(i+Pozycja) * 127 + 128)/255)*niebieski);

}

pokażStrip();

opóźnienie (opóźnienie fali);

}

}

void meteorRain(bajt czerwony, bajt zielony, bajt niebieski, bajt meteorSize, bajt meteorTrailDecay, boolean meteorRandomDecay, int staryA0, int staryA1, int staryA2, int staryA3) {

ustawWszystko(0, 0, 0);

int Opóźnienie Prędkości;

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

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

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

inny{SpeedDelay=20;}

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

if(staryA0!=analogowyOdczyt(A0)||((staryA1-256)>analogowyOdczyt(A1))||((staryA1+256)analogowyOdczyt(A2))||((staryA2+256)analogowyOdczyt(A3))| |((stary A3+256)

przerwa;

}

// zanik jasności wszystkie diody led jeden krok

for(int j=0; j

if(staryA0!=analogowyOdczyt(A0)||((staryA1-256)>analogowyOdczyt(A1))||((staryA1+256)analogowyOdczyt(A2))||((staryA2+256)analogowyOdczyt(A3))| |((stary A3+256)

przerwa;

}

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

fadeToBlack(j, meteorTrailDecay);

}

}

// narysuj meteor

for(int j = 0; j < rozmiar meteoru; j++) {

if(staryA0!=analogowyOdczyt(A0)||((staryA1-256)>analogowyOdczyt(A1))||((staryA1+256)analogowyOdczyt(A2))||((staryA2+256)analogowyOdczyt(A3))| |((stary A3+256)

przerwa;

}

jeśli((i-j =0)) {

setPixel(i-j, czerwony, zielony, niebieski);

}

}

pokażStrip();

opóźnienie (SpeedDelay);

}

}

void fadeToBlack(int ledNo, byte fadeValue) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

uint32_t staryKolor;

uint8_tr, g, b;

int wartość;

staryKolor = strip.getPixelColor(ledNo);

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

g = (staryKolor & 0x0000ff00UL) >> 8;

b = (staryKolor i 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

leds[ledNo].fadeToBlackBy(fadeValue);

#endif

}

// *** ZASTĄP TUTAJ ***

void pokażStrip() {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.pokaż();

#endif

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

FastLED.show();

#endif

}

void setPixel(int Pixel, bajt czerwony, bajt zielony, bajt niebieski) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.setPixelColor(Pixel, strip. Color(czerwony, zielony, niebieski));

#endif

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

diody [Piksel].r = czerwony;

diody[Piksel].g = zielony;

diody [Piksel].b = niebieski;

#endif

}

void setAll(bajt czerwony, bajt zielony, bajt niebieski) {

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

setPixel(i, czerwony, zielony, niebieski);

}

pokażStrip();

}

Krok 3: Tworzenie zegara

Polecam szklany zegar, który jest płaski w środku. Kiedy nakładałem elastyczne lustro na wnętrze zegara, wystąpił problem z powodu wyskakiwania cyfr wewnątrz zegara, lustro wyginało się, co powodowało, że efekt lustra nieskończoności nie występował. Musisz mieć elastyczny arkusz lustrzany i folię prywatności, aby były jak najbardziej płaskie. Jeśli otrzymujesz zegar, upewnij się, że możesz bez problemu umieścić diodę LED w środku.

Krok 1: otwórz zegar i zdejmij przednią szybę

Krok 2: Załóż folię prywatności na przednią szybę (ten film pokazuje, jak to zrobić)

Krok 3: Zastosuj elastyczne lustro po wewnętrznej stronie zegara (przed wykonaniem tej czynności usuń wskazówki zegara)

Krok 4: Zrób otwór w środku, aby ponownie umieścić wskazówki zegara

Krok 5: Umieść pasek LED wokół wewnętrznych ścian zegara (do tego kroku użyłem pistoletu do klejenia na gorąco)

Krok 6: Włącz pasek LED i umieść szkło na zegarze, aby sprawdzić, czy istnieje efekt lustra nieskończoności

Krok 7: Gdy skończysz, złóż zegar razem i pozwól przewodom przejść do tyłu

Krok 8: Gratulacje, że ukończyłeś projekt i wszystko powinno działać dobrze

Jeśli masz jakieś pytania, skomentuj je poniżej (Wiedz, że mogę nie być w stanie odpowiedzieć, ale zrobię co w mojej mocy)