Infinity spiegelklok met potentiometers - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:15

Ik kwam infinity mirror tegen en ik vond het een heel coole. Dit inspireerde me om een oneindigheidsspiegel te maken, maar ik had het nodig om een doel te hebben. Dus besloot ik een functionerende oneindige spiegelklok te maken. Dit is een oneindige spiegel waarmee u de modi, snelheid en kleuren kunt wijzigen met behulp van potentiometers. (Opmerking: dit is de eerste keer dat ik zoiets maak)

Benodigdheden

Laten we eens kijken wat je nodig hebt om dit ding te maken!

Je zal nodig hebben…

1) 1 Arduino Uno

3) 1 Breadboard

4) 1 schuifschakelaar

5) 3 Potentiometers

6) 1 9V batterij

7) 5 meter WS2811 LED-strip

8) Jumperkabeldraden

9) Een klok (de klok die ik gebruikte 12 inch grote moderne klok)

10) Flexibel spiegelblad (degene die ik gebruikte spiegelblad)

11) Privacyfilm (degene die ik heb gebruikt One Way Mirror)

12) Solderen kan nodig zijn, dit hangt af van welke materialen je hebt

Stap 1: Bedrading

De bedrading is vrij eenvoudig

- De SPST-schakelaar schakelt de LED's in en uit (A0)

- De linker potmeter regelt het licht (A1)

- De middelste potentiometer regelt de standen (A2)

- De rechter potmeter regelt het toerental (A3)

Stap 2: De code

#erbij betrekken

#definieer pincode 6

#define NUM_LEDS 54

#definieer A0 A0

#definieer A1 A1

#definieer A2 A2

#definieer A3 A3

// Parameter 1 = aantal pixels in strip

// Parameter 2 = pinnummer (de meeste zijn geldig)

// Parameter 3 = pixeltype vlaggen, voeg zo nodig bij elkaar:

// NEO_KHZ800 800 KHz bitstream (de meeste NeoPixel-producten met WS2812 LED's)

// NEO_KHZ400 400 KHz (klassieke 'v1' (niet v2) FLORA-pixels, WS2811-stuurprogramma's)

// NEO_GRB Pixels zijn bedraad voor GRB-bitstream (de meeste NeoPixel-producten)

// NEO_RGB-pixels zijn bedraad voor RGB-bitstream (v1 FLORA-pixels, niet v2)

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

ongeldige setup() {

strip.begin();

strip.show(); // Initialiseer alle pixels op 'uit'

}

lege lus() {

if(analogRead(A0)>=512){

if(analogRead(A2)>=768){

if(analogRead(A3)>=768){

rainbowCycle (80, analoog lezen (A0), analoog lezen (A1), analoog lezen (A2), analoog lezen (A3));

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

rainbowCycle (60, analoog lezen (A0), analoog lezen (A1), analoog lezen (A2), analoog lezen (A3));

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

rainbowCycle (40, analoog lezen (A0), analoog lezen (A1), analoog lezen (A2), analoog lezen (A3));

}

anders{

rainbowCycle (20, analoog lezen (A0), analoog lezen (A1), analoog lezen (A2), analoog lezen (A3));

}

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

if(analogRead(A1)>=768){

CylonBounce (willekeurig (255), willekeurig (255), willekeurig (255), 4, analoog lezen (A0), analoog lezen (A1), analoog lezen (A2), analoog lezen (A3));

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

CylonBounce (willekeurig (255), 0, 0, 4, analoog lezen (A0), analoog lezen (A1), analoog lezen (A2), analoog lezen (A3));

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

CylonBounce (0, willekeurig (255), 0, 4, analoog lezen (A0), analoog lezen (A1), analoog lezen (A2), analoog lezen (A3));

}

anders{

CylonBounce (0, 0, willekeurig (255), 4, analoog lezen (A0), analoog lezen (A1), analoog lezen (A2), analoog lezen (A3));

}

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

if(analogRead(A1)>=768){

byte r, g, b;

r = willekeurig (255);

g = willekeurig (255);

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

b = 0;

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

}

anders{

byte r, g, b;

r = 0;

g = 0;

b = willekeurig (255);

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

}

}

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

RunningLights (willekeurig (255), willekeurig (255), willekeurig (255), analoog lezen (A0), analoog lezen (A1), analoog lezen (A2), analoog lezen (A3));

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

RunningLights (willekeurig (255), 1, 1, analoog lezen (A0), analoog lezen (A1), analoog lezen (A2), analoog lezen (A3));

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

RunningLights (1, willekeurig (255), 1, analoog lezen (A0), analoog lezen (A1), analoog lezen (A2), analoog lezen (A3));

}

anders{

RunningLights (1, 1, willekeurig (255), analoog lezen (A0), analoog lezen (A1), analoog lezen (A2), analoog lezen (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 cycli van alle kleuren op het wiel

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

pauze;

}

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

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

pauze;

}

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

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

}

toonStrip();

vertraging (SpeedDelay);

}

}

byte * Wiel (byte WielPos) {

statische byte c[3];

if(WielPos < 85) {

c[0]=WielPos * 3;

c[1]=255 - WielPos * 3;

c[2]=0;

} else if(WielPos < 170) {

WielPos -= 85;

c[0]=255 - WielPos * 3;

c[1]=0;

c[2]=WielPos * 3;

} anders {

WielPos -= 170;

c[0]=0;

c[1]=WielPos * 3;

c[2]=255 - WielPos * 3;

}

terug c;

}

void CylonBounce(byte rood, byte groen, byte blauw, 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;}

anders{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))| |((oudeA3+256)

pauze;

}

setAll(0, 0, 0);

setPixel(i, rood/10, groen/10, blauw/10);

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

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

pauze;

}

setPixel(i+j, rood, groen, blauw);

}

setPixel(i+EyeSize+1, rood/10, groen/10, blauw/10);

toonStrip();

vertraging (SpeedDelay);

}

vertraging (ReturnDelay);

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

setAll(0, 0, 0);

setPixel(i, rood/10, groen/10, blauw/10);

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

pauze;

}

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

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

pauze;

}

setPixel(i+j, rood, groen, blauw);

}

setPixel(i+EyeSize+1, rood/10, groen/10, blauw/10);

toonStrip();

vertraging (SpeedDelay);

}

vertraging (ReturnDelay);

}

void RunningLights(byte rood, byte groen, byte blauw, int oldA0, int oldA1, int oldA2, int oldA3) {

int Positie=0;

int WaveDelay;

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

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

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

anders{WaveDelay=20;}

for(int j=0; j

{

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

pauze;

}

Positie++; // = 0; // Positie + Tarief;

for(int i=0; i

// sinusgolf, 3 offsetgolven vormen een regenboog!

//float niveau = sin (i+Positie) * 127 + 128;

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

//float niveau = sin (i+Positie) * 127 + 128;

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

pauze;

}

setPixel(i, ((sin(i+Positie) * 127 + 128)/255)*rood, ((sin(i+Positie) * 127 + 128)/255)*groen, ((sin(i+Positie) * 127 + 128)/255)*blauw);

}

toonStrip();

vertraging (WaveDelay);

}

}

void meteorRain(byte rood, byte groen, byte blauw, 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;}

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

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

anders{SpeedDelay=20;}

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

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

pauze;

}

// vervaag de helderheid van alle LED's in één stap

for(int j=0; j

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

pauze;

}

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

fadeToBlack(j, meteorTrailDecay);

}

}

// teken meteoor

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

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

pauze;

}

if((i-j =0)) {

setPixel (i-j, rood, groen, blauw);

}

}

toonStrip();

vertraging (SpeedDelay);

}

}

void fadeToBlack(int ledNo, byte fadeValue) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

uint32_t oldColor;

uint8_t r, g, b;

int-waarde;

oldColor = strip.getPixelColor(ledNo);

r = (oude kleur & 0x00ff0000UL) >> 16;

g = (oude kleur & 0x0000ff00UL) >> 8;

b = (oude kleur & 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);

#stop als

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

leds[ledNo].fadeToBlackBy(fadeValue);

#stop als

}

// *** VERVANG HIER ***

ongeldige showStrip() {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.show();

#stop als

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

FastLED.show();

#stop als

}

void setPixel(int Pixel, byte rood, byte groen, byte blauw) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.setPixelColor (Pixel, strip. Color (rood, groen, blauw));

#stop als

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

leds[Pixel].r = rood;

leds[Pixel].g = groen;

leds[Pixel].b = blauw;

#stop als

}

void setAll (byte rood, byte groen, byte blauw) {

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

setPixel(i, rood, groen, blauw);

}

toonStrip();

}

Stap 3: De klok maken

Ik zou aanraden om een glazen klok te kopen die van binnen plat is. Toen ik de flexibele spiegel aan de binnenkant van de klok aan het aanbrengen was, was er een probleem doordat de cijfers in de klok naar buiten sprongen, de spiegel was aan het buigen, waardoor het oneindige spiegeleffect niet plaatsvond. U moet het flexibele spiegelblad en de Privacy Film zo vlak mogelijk hebben. Als u een klok krijgt, zorg er dan voor dat u de LED zonder problemen erin kunt plaatsen.

Stap 1: Open de klok en verwijder het voorglas

Stap 2: Doe de Privacy Film op het glas aan de voorkant (deze video laat zien hoe je dat doet)

Stap 3: Breng de flexibele spiegel aan de binnenkant van de klok aan (verwijder de wijzers voordat u dit doet)

Stap 4: Maak een gat in het midden om de wijzers terug te plaatsen

Stap 5: Plaats de LED-strip rond de binnenwanden van de klok (ik heb voor deze stap een heet lijmpistool gebruikt)

Stap 6: Zet de LED-strip aan en plaats het glas op de klok om te zien of het oneindige spiegeleffect er is

Stap 7: Als je klaar bent met alles, zet je de klok in elkaar en laat je de draden door naar de achterkant

Stap 8: Gefeliciteerd, je hebt het project voltooid en alles zou goed moeten werken

Als je vragen hebt, stel ze dan hieronder (weet dat ik misschien niet kan reageren, maar ik zal mijn best doen)