Infinity -spegelklocka med potentiometrar: 3 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:38

Jag stötte på oändlig spegel och jag tyckte att det var riktigt coolt. Detta inspirerade mig att göra en oändlig spegel, men jag behövde det för att ha ett syfte. Så jag bestämde mig för att göra en fungerande oändlig spegelklocka. Detta är en oändlig spegel som låter dig ändra lägen, hastighet och färger med hjälp av potentiometrar. (Obs: Det här är första gången jag gör något så här)

Tillbehör

Låt oss dyka in i vad du behöver för att göra det här!

Du kommer behöva…

1) 1 Arduino Uno

3) 1 brödbräda

4) 1 skjutreglage

5) 3 potentiometrar

6) 1 9V batteri

7) 5 meter WS2811 LED -remsa

8) Bygelkablar

9) En klocka (klockan jag använde 12 tum stor modern klocka)

10) Flexibelt spegelark (det jag använde spegelblad)

11) Sekretessfilm (den jag använde One Way Mirror)

12) Lödning kan krävas, detta beror på vad du har för material

Steg 1: Kabeldragning

Ledningarna är ganska enkla

- SPST -omkopplaren tänder och släcker lysdioderna (A0)

- Den vänstra potentiometern styr ljuset (A1)

- Den mellersta potentiometern styr lägena (A2)

- Den högra potentiometern styr hastigheten (A3)

Steg 2: Koden

#omfatta

#definiera PIN 6

#define NUM_LEDS 54

#definiera A0 A0

#definiera A1 A1

#definiera A2 A2

#definiera A3 A3

// Parameter 1 = antal pixlar i remsan

// Parameter 2 = pin -nummer (de flesta är giltiga)

// Parameter 3 = pixeltypflaggor, lägg ihop efter behov:

// NEO_KHZ800 800 KHz bitström (de flesta NeoPixel -produkter med WS2812 lysdioder)

// NEO_KHZ400 400 KHz (klassiska 'v1' (inte v2) FLORA -pixlar, WS2811 -drivrutiner)

// NEO_GRB Pixlar är anslutna för GRB -bitström (de flesta NeoPixel -produkter)

// NEO_RGB -pixlar är anslutna för RGB -bitström (v1 FLORA -pixlar, inte v2)

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

void setup () {

strip.begin ();

strip.show (); // Initiera alla pixlar till 'av'

}

void loop () {

if (analogRead (A0)> = 512) {

if (analogRead (A2)> = 768) {

if (analogRead (A3)> = 768) {

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

} annars om (analogRead (A3)> = 512) {

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

} annars om (analogRead (A3)> = 256) {

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

}

annan{

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

}

} annars om (analogRead (A2)> = 512) {

if (analogRead (A1)> = 768) {

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

} annars om (analogRead (A1)> = 512) {

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

} annars om (analogRead (A1)> = 256) {

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

}

annan{

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

}

} annars om (analogRead (A2)> = 256) {

if (analogRead (A1)> = 768) {

byte r, g, b;

r = slumpmässig (255);

g = slumpmässig (255);

b = slumpmässig (255);

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

} annars om (analogRead (A1)> = 512) {

byte r, g, b;

r = slumpmässig (255);

g = 0;

b = 0;

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

} annars om (analogRead (A1)> = 256) {

byte r, g, b;

r = 0;

g = slumpmässig (255);

b = 0;

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

}

annan{

byte r, g, b;

r = 0;

g = 0;

b = slumpmässig (255);

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

}

}

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

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

} annars om (analogRead (A1)> = 512) {

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

} annars om (analogRead (A1)> = 256) {

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

}

annan{

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

}

}

}annan{

setAll (0, 0, 0);

}

}

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

byte *c;

uint16_t i, j;

för (j = 0; j <256*5; j ++) {// 5 cykler av alla färger på hjulet

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

ha sönder;

}

för (i = 0; i <NUM_LEDS; i ++) {

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

ha sönder;

}

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

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

}

showStrip ();

fördröjning (SpeedDelay);

}

}

byte * Wheel (byte WheelPos) {

statisk byte c [3];

om (WheelPos <85) {

c [0] = WheelPos * 3;

c [1] = 255 - WheelPos * 3;

c [2] = 0;

} annat om (WheelPos <170) {

WheelPos -= 85;

c [0] = 255 - WheelPos * 3;

c [1] = 0;

c [2] = WheelPos * 3;

} annat {

WheelPos -= 170;

c [0] = 0;

c [1] = WheelPos * 3;

c [2] = 255 - WheelPos * 3;

}

retur c;

}

void CylonBounce (byte röd, byte grön, byte blå, int EyeSize, int oldA0, int oldA1, int oldA2, int oldA3) {

int SpeedDelay;

int ReturnDelay;

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

annars om (analogRead (A3)> = 512) {SpeedDelay = 60; ReturnDelay = 100;}

annars om (analogRead (A3)> = 256) {SpeedDelay = 40; ReturnDelay = 80;}

annars {SpeedDelay = 20; ReturnDelay = 60;}

för (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)) | | ((oldA3+256)

ha sönder;

}

setAll (0, 0, 0);

setPixel (i, röd/10, grön/10, blå/10);

för (int j = 1; j <= EyeSize; j ++) {

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

ha sönder;

}

setPixel (i+j, röd, grön, blå);

}

setPixel (i+EyeSize+1, röd/10, grön/10, blå/10);

showStrip ();

fördröjning (SpeedDelay);

}

delay (ReturnDelay);

för (int i = NUM_LEDS-EyeSize-2; i> 0; i--) {

setAll (0, 0, 0);

setPixel (i, röd/10, grön/10, blå/10);

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

ha sönder;

}

för (int j = 1; j <= EyeSize; j ++) {

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

ha sönder;

}

setPixel (i+j, röd, grön, blå);

}

setPixel (i+EyeSize+1, röd/10, grön/10, blå/10);

showStrip ();

fördröjning (SpeedDelay);

}

delay (ReturnDelay);

}

void RunningLights (byte röd, byte grön, byte blå, int oldA0, int oldA1, int oldA2, int oldA3) {

int Position = 0;

int WaveDelay;

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

annars om (analogRead (A3)> = 512) {WaveDelay = 60;}

annars om (analogRead (A3)> = 256) {WaveDelay = 40;}

annars {WaveDelay = 20;}

för (int j = 0; j

{

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

ha sönder;

}

Position ++; // = 0; // Position + Rate;

för (int i = 0; i

// sinusvåg, 3 offsetvågor gör en regnbåge!

// flytnivå = sin (i + position) * 127 + 128;

// setPixel (i, nivå, 0, 0);

// flytnivå = sin (i + position) * 127 + 128;

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

ha sönder;

}

setPixel (i, ((sin (i + Position) * 127 + 128)/255) * röd, ((sin (i + Position) * 127 + 128)/255) * grön, ((sin (i + Position) * 127 + 128)/255) * blå);

}

showStrip ();

fördröjning (WaveDelay);

}

}

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

annars om (analogRead (A3)> = 512) {SpeedDelay = 60;}

annars om (analogRead (A3)> = 256) {SpeedDelay = 40;}

annars {SpeedDelay = 20;}

för (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)) | | ((oldA3+256)

ha sönder;

}

// blekna ljusstyrka alla lysdioder ett steg

för (int j = 0; j

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

ha sönder;

}

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

fadeToBlack (j, meteorTrailDecay);

}

}

// rita meteor

för (int j = 0; j <meteorSize; j ++) {

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

ha sönder;

}

om ((i-j = 0)) {

setPixel (i-j, röd, grön, blå);

}

}

showStrip ();

fördröjning (SpeedDelay);

}

}

void fadeToBlack (int ledNo, byte fadeValue) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

uint32_t oldColor;

uint8_t r, g, b;

int värde;

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

leds [ledNo].fadeToBlackBy (fadeValue);

#endif

}

// *** ERSÄTT TILL HÄR ***

void showStrip () {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.show ();

#endif

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

FastLED.show ();

#endif

}

void setPixel (int Pixel, byte röd, byte grön, byte blå) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.setPixelColor (Pixel, strip. Color (röd, grön, blå));

#endif

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

lysdioder [Pixel].r = röd;

lysdioder [Pixel].g = grön;

lysdioder [Pixel].b = blå;

#endif

}

void setAll (byte röd, byte grön, byte blå) {

för (int i = 0; i <NUM_LEDS; i ++) {

setPixel (i, röd, grön, blå);

}

showStrip ();

}

Steg 3: Skapa klockan

Jag skulle rekommendera att skaffa en glasur som är platt på insidan. När jag applicerade den flexibla spegeln på insidan av klockan var det ett problem på grund av att siffrorna inuti klockan sprang ut, spegeln böjde sig vilket resulterade i att oändlighetens spegeleffekt inte hände. Du måste ha det flexibla spegelarket och sekretessfilmen för att vara så platt som möjligt. Om du får en klocka, se till att du kan placera lysdioden inuti utan problem.

Steg 1: Öppna klockan och ta bort det främre glaset

Steg 2: Sätt på sekretessfilmen på frontglaset (den här videon visar hur du gör)

Steg 3: Applicera den flexibla spegeln på insidan av klockan (Ta bort klockornas händer innan du gör detta)

Steg 4: Gör ett hål i mitten för att klockan ska placeras tillbaka

Steg 5: Placera LED -remsan runt klockans inre väggar (jag använde en varm limpistol för detta steg)

Steg 6: Slå på LED -remsan och placera glaset ovanpå klockan för att se om infinity -spegeleffekten finns där

Steg 7: När du är klar med allt, sätt ihop klockan och låt ledningarna passera till baksidan

Steg 8: Grattis till att du har slutfört projektet och allt ska fungera bra

Om du har några frågor vänligen kommentera dem nedan (Vet att jag kanske inte kan svara, men jag kommer att göra mitt bästa)