Infinity-Spiegeluhr mit Potentiometern - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:16

Ich bin auf den Infinity-Spiegel gestoßen und fand ihn wirklich cool. Dies hat mich dazu inspiriert, einen Infinity-Spiegel zu machen, aber ich brauchte ihn, um einen Zweck zu erfüllen. Also beschloss ich, eine funktionierende Infinity-Spiegeluhr zu bauen. Dies ist ein Infinity-Spiegel, mit dem Sie die Modi, Geschwindigkeit und Farben mithilfe von Potentiometern ändern können. (Hinweis: Dies ist das erste Mal, dass ich so etwas mache)

Lieferungen

Lassen Sie uns in das eintauchen, was Sie brauchen, um dieses Ding zu machen!

Du wirst brauchen…

1) 1 Arduino Uno

3) 1 Steckbrett

4) 1 Schiebeschalter

5) 3 Potentiometer

6) 1 9V-Batterie

7) 5 Meter WS2811 LED-Streifen

8) Überbrückungskabeldrähte

9) Eine Uhr (Die Uhr, die ich verwendet habe, 12 Zoll große moderne Uhr)

10) Flexibles Spiegelblatt (das, das ich Spiegelblatt verwendet habe)

11) Sichtschutzfolie (diejenige, die ich verwendet habe Einwegspiegel)

12) Möglicherweise ist Löten erforderlich. Dies hängt davon ab, welche Materialien Sie haben

Schritt 1: Verkabelung

Die Verkabelung ist ganz einfach

- Der SPST-Schalter schaltet die LEDs (A0) ein und aus

- Das linke Potentiometer steuert das Licht (A1)

- Das mittlere Potentiometer steuert die Modi (A2)

- Das rechte Potentiometer steuert die Geschwindigkeit (A3)

Schritt 2: Der Code

#enthalten

#definiere PIN 6

#define NUM_LEDS 54

#define A0 A0

#define A1 A1

#define A2 A2

#define A3 A3

// Parameter 1 = Anzahl der Pixel im Streifen

// Parameter 2 = Pin-Nummer (die meisten sind gültig)

// Parameter 3 = Pixeltyp-Flags, nach Bedarf addieren:

// NEO_KHZ800 800 KHz Bitstream (die meisten NeoPixel Produkte mit WS2812 LEDs)

// NEO_KHZ400 400 KHz (klassisch 'v1' (nicht v2) FLORA Pixel, WS2811 Treiber)

// NEO_GRB-Pixel sind für GRB-Bitstream verdrahtet (die meisten NeoPixel-Produkte)

// NEO_RGB Pixel sind für RGB-Bitstream verdrahtet (v1 FLORA Pixel, nicht v2)

Adafruit_NeoPixel-Streifen = Adafruit_NeoPixel (NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);

Leere Einrichtung () {

strip.begin();

Strip-Show(); // Alle Pixel auf 'off' initialisieren

}

Leere Schleife () {

if(analogRead(A0)>=512){

if(analogRead(A2)>=768){

if(analogRead(A3)>=768){

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

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

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

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

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

}

anders{

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

}

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

if(analogRead(A1)>=768){

CylonBounce (zufällig (255), zufällig (255), zufällig (255), 4, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

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

CylonBounce (zufällig (255), 0, 0, 4, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

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

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

}

anders{

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

}

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

if(analogRead(A1)>=768){

Byte r, g, b;

r = zufällig (255);

g = zufällig (255);

b = zufällig (255);

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

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

Byte r, g, b;

r = zufällig (255);

g = 0;

b = 0;

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

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

Byte r, g, b;

r = 0;

g = zufällig (255);

b = 0;

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

}

anders{

Byte r, g, b;

r = 0;

g = 0;

b = zufällig (255);

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

}

}

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

RunningLights (zufällig (255), zufällig (255), zufällig (255), analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

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

RunningLights (zufällig (255), 1, 1, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

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

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

}

anders{

RunningLights (1, 1, zufällig (255), analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

}

}

}anders{

setAll(0, 0, 0);

}

}

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

Byte *c;

uint16_t i, j;

for(j=0; j<256*5; j++) {// 5 Zyklen aller Farben auf dem Rad

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

brechen;

}

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

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

brechen;

}

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

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

}

showStrip();

Verzögerung (SpeedDelay);

}

}

byte * Wheel(byte WheelPos) {

statisches Byte c[3];

if(RadPos < 85) {

c[0]=RadPos * 3;

c[1]=255 - RadPos * 3;

c[2]=0;

} sonst if(WheelPos <170) {

RadPos -= 85;

c[0]=255 - RadPos * 3;

c[1]=0;

c[2]=RadPos * 3;

} anders {

RadPos -= 170;

c[0]=0;

c[1]=RadPos * 3;

c[2]=255 - RadPos * 3;

}

Rückkehr c;

}

void CylonBounce(byte red, byte green, byte blue, int EyeSize, int oldA0, int oldA1, int oldA2, int oldA3){

int Geschwindigkeitsverzögerung;

int ReturnDelay;

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

sonst if (analogRead (A3)>=512){SpeedDelay=60;ReturnDelay=100;}

sonst 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))| |((altA3+256)

brechen;

}

setAll(0, 0, 0);

setPixel(i, rot/10, grün/10, blau/10);

for(int j = 1; j <= Augengröße; j++) {

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

brechen;

}

setPixel(i+j, rot, grün, blau);

}

setPixel(i+EyeSize+1, Rot/10, Grün/10, Blau/10);

showStrip();

Verzögerung (SpeedDelay);

}

Verzögerung (ReturnDelay);

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

setAll(0, 0, 0);

setPixel(i, rot/10, grün/10, blau/10);

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

brechen;

}

for(int j = 1; j <= Augengröße; j++) {

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

brechen;

}

setPixel(i+j, rot, grün, blau);

}

setPixel(i+EyeSize+1, Rot/10, Grün/10, Blau/10);

showStrip();

Verzögerung (SpeedDelay);

}

Verzögerung (ReturnDelay);

}

void RunningLights(byte red, byte green, byte blue, int oldA0, int oldA1, int oldA2, int oldA3) {

int-Position=0;

int WaveDelay;

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

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

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

sonst{WaveDelay=20;}

for(int j=0; j

{

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

brechen;

}

Position++; // = 0; //Position + Kurs;

for(int i=0; i

// Sinuswelle, 3 Offsetwellen ergeben einen Regenbogen!

// Float-Level = sin (i + Position) * 127 + 128;

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

// Float-Level = sin (i + Position) * 127 + 128;

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

brechen;

}

setPixel(i, ((sin(i+Position) * 127 + 128)/255)*rot, ((sin(i+Position) * 127 + 128)/255)*grün, ((sin(i+Position) * 127 + 128)/255)*blau);

}

showStrip();

Verzögerung (WaveDelay);

}

}

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

setAll(0, 0, 0);

int Geschwindigkeitsverzögerung;

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

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

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

sonst{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))| |((altA3+256)

brechen;

}

// Helligkeit aller LEDs in einem Schritt verblassen

for(int j=0; j

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

brechen;

}

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

fadeToBlack(j, meteorTrailDecay);

}

}

// Meteore zeichnen

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

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

brechen;

}

if((i-j =0)) {

setPixel(i-j, rot, grün, blau);

}

}

showStrip();

Verzögerung (SpeedDelay);

}

}

void fadeToBlack(int ledNo, byte fadeValue) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

uint32_t alteFarbe;

uint8_t r, g, b;

int-Wert;

oldColor = strip.getPixelColor(ledNo);

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

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

b = (alteFarbe & 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

}

// *** HIER ERSETZEN ***

void showStrip() {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

Strip-Show();

#endif

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

FastLED.show();

#endif

}

void setPixel(int Pixel, Byte rot, Byte grün, Byte blau) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.setPixelColor (Pixel, strip. Color (rot, grün, blau));

#endif

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

LEDs[Pixel].r = rot;

LEDs[Pixel].g = grün;

LEDs[Pixel].b = blau;

#endif

}

void setAll(Byte rot, Byte grün, Byte blau) {

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

setPixel(i, rot, grün, blau);

}

showStrip();

}

Schritt 3: Erstellen der Uhr

Ich würde empfehlen, eine Glasuhr zu kaufen, die innen flach ist. Als ich den flexiblen Spiegel an der Innenseite der Uhr anbrachte, gab es ein Problem aufgrund der herausspringenden Zahlen in der Uhr, der Spiegel verbogen, was dazu führte, dass der Unendlichkeitsspiegeleffekt nicht auftrat. Sie müssen die flexible Spiegelfolie und die Sichtschutzfolie so flach wie möglich haben. Wenn Sie eine Uhr bekommen, stellen Sie sicher, dass Sie die LED problemlos darin platzieren können.

Schritt 1: Öffnen Sie die Uhr und entfernen Sie das Frontglas

Schritt 2: Bringen Sie die Sichtschutzfolie auf dem Frontglas an (Dieses Video zeigt Ihnen, wie es geht)

Schritt 3: Bringen Sie den flexiblen Spiegel auf der Innenseite der Uhr an (Entfernen Sie die Uhrzeiger, bevor Sie dies tun)

Schritt 4: Machen Sie ein Loch in der Mitte, damit die Uhrzeiger wieder hineingesteckt werden können

Schritt 5: Legen Sie den LED-Streifen um die Innenwände der Uhr (ich habe für diesen Schritt eine Heißklebepistole verwendet)

Schritt 6: Schalten Sie den LED-Streifen ein und legen Sie das Glas auf die Uhr, um zu sehen, ob der Unendlichkeitsspiegeleffekt vorhanden ist

Schritt 7: Wenn Sie mit allem fertig sind, bauen Sie die Uhr zusammen und lassen Sie die Drähte nach hinten durchgehen

Schritt 8: Herzlichen Glückwunsch, Sie haben das Projekt abgeschlossen und alles sollte gut funktionieren

Wenn Sie Fragen haben, kommentieren Sie diese bitte unten (ich weiß, dass ich möglicherweise nicht antworten kann, aber ich werde mein Bestes tun)