שעון מראה אינסוף עם פוטנציומטרים: 3 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:12

נתקלתי במראה אינסוף וגיליתי שזה ממש מגניב. זה נתן לי השראה ליצור מראה אינסופית, אבל הייתי צריך את זה כדי שיהיה לי מטרה. אז, החלטתי להכין שעון מראה אינסופי מתפקד. זוהי מראה אינסופית המאפשרת לך לשנות את המצבים, המהירות והצבעים באמצעות פוטנציומטרים. (הערה: זו הפעם הראשונה שאני מכין דבר כזה)

אספקה

בואו לצלול למה שאתה צריך כדי להפוך את הדבר הזה!

אתה תצטרך…

1) 1 Arduino Uno

3) לוח לחם

4) מתג שקופית אחד

5) 3 פוטנציומטרים

6) סוללה אחת של 9V

7) רצועת LED 5 מטר WS2811

8) חוטי כבל מגשר

9) שעון (השעון שהשתמשתי בו שעון מודרני גדול בגודל 12 אינץ ')

10) גיליון מראה גמיש (זה שהשתמשתי בו גיליון מראה)

11) סרט פרטיות (הסרט שבו השתמשתי במראה חד כיוונית)

12) ייתכן שיהיה צורך בהלחמה, הדבר תלוי בחומרי החומר שלך

שלב 1: חיווט

החיווט פשוט למדי

מתג SPST מדליק ומכבה את נוריות ה- LED (A0)

- הפוטנציומטר השמאלי שולט באור (A1)

- פוטנציומטר האמצעי שולט על המצבים (A2)

- הפוטנציומטר הימני שולט על המהירות (A3)

שלב 2: הקוד

#לִכלוֹל

#הגדר PIN 6

#הגדר NUM_LEDS 54

#הגדר A0 A0

#הגדר A1 A1

#הגדר A2 A2

#הגדר A3 A3

// פרמטר 1 = מספר הפיקסלים ברצועה

// פרמטר 2 = מספר סיכה (רובם תקפים)

// פרמטר 3 = דגלים מסוג פיקסל, הוסף יחד לפי הצורך:

// NEO_KHZ800 800 KHz bitstream (רוב מוצרי NeoPixel עם נוריות WS2812)

// NEO_KHZ400 400 KHz (קלאסי 'v1' (לא v2) פיקסלים של FLORA, מנהלי התקנים WS2811)

// NEO_GRB פיקסלים מחוברים ל- bitstream GRB (רוב מוצרי NeoPixel)

// NEO_RGB פיקסלים מחוברים לזרם סיביות RGB (פיקסלים v1 FLORA, לא v2)

רצועת Adafruit_NeoPixel = Adafruit_NeoPixel (NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);

הגדרת בטל () {

strip.begin ();

strip.show (); // אתחל את כל הפיקסלים ל'כבוי '

}

לולאת חלל () {

if (analogRead (A0)> = 512) {

אם (analogRead (A2)> = 768) {

if (analogRead (A3)> = 768) {

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

} אחרת אם (analogRead (A3)> = 512) {

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

} אחרת אם (analogRead (A3)> = 256) {

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

}

אַחֵר{

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

}

} אחרת אם (analogRead (A2)> = 512) {

if (analogRead (A1)> = 768) {

CylonBounce (אקראי (255), אקראי (255), אקראי (255), 4, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

} אחרת אם (analogRead (A1)> = 512) {

CylonBounce (אקראי (255), 0, 0, 4, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

} אחרת אם (analogRead (A1)> = 256) {

CylonBounce (0, אקראי (255), 0, 4, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

}

אַחֵר{

CylonBounce (0, 0, אקראי (255), 4, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

}

} אחרת אם (analogRead (A2)> = 256) {

if (analogRead (A1)> = 768) {

בייט r, g, b;

r = אקראי (255);

g = אקראי (255);

b = אקראי (255);

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

} אחרת אם (analogRead (A1)> = 512) {

בייט r, g, b;

r = אקראי (255);

g = 0;

b = 0;

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

} אחרת אם (analogRead (A1)> = 256) {

בייט r, g, b;

r = 0;

g = אקראי (255);

b = 0;

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

}

אַחֵר{

בייט r, g, b;

r = 0;

g = 0;

b = אקראי (255);

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

}

}

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

RunningLights (אקראי (255), אקראי (255), אקראי (255), analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

} אחרת אם (analogRead (A1)> = 512) {

RunningLights (אקראי (255), 1, 1, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

} אחרת אם (analogRead (A1)> = 256) {

RunningLights (1, אקראי (255), 1, analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

}

אַחֵר{

RunningLights (1, 1, אקראי (255), analogRead (A0), analogRead (A1), analogRead (A2), analogRead (A3));

}

}

}אַחֵר{

setAll (0, 0, 0);

}

}

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

בייט *ג;

uint16_t i, j;

עבור (j = 0; j <256*5; j ++) {// 5 מחזורים מכל הצבעים על הגלגל

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

לשבור;

}

עבור (i = 0; i <NUM_LEDS; i ++) {

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

לשבור;

}

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

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

}

showStrip ();

עיכוב (SpeedDelay);

}

}

בייט * גלגל (בייט WheelPos) {

בית סטטי c [3];

אם (WheelPos <85) {

c [0] = WheelPos * 3;

c [1] = 255 - WheelPos * 3;

c [2] = 0;

} אחר אם (WheelPos <170) {

WheelPos -= 85;

c [0] = 255 - WheelPos * 3;

c [1] = 0;

c [2] = WheelPos * 3;

} אחר {

WheelPos -= 170;

c [0] = 0;

c [1] = WheelPos * 3;

c [2] = 255 - WheelPos * 3;

}

החזר ג;

}

void CylonBounce (בתים אדומים, בתים ירוקים, בתים כחולים, int EyeSize, int oldA0, int oldA1, int oldA2, int oldA3) {

int SpeedDelay;

int ReturnDelay;

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

אחרת אם (analogRead (A3)> = 512) {SpeedDelay = 60; ReturnDelay = 100;}

אחרת אם (analogRead (A3)> = 256) {SpeedDelay = 40; ReturnDelay = 80;}

אחרת {SpeedDelay = 20; ReturnDelay = 60;}

עבור (int i = 0; i <NUM_LEDS-EyeSize-2; i ++) {

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

לשבור;

}

setAll (0, 0, 0);

setPixel (i, אדום/10, ירוק/10, כחול/10);

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

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

לשבור;

}

setPixel (i+j, אדום, ירוק, כחול);

}

setPixel (i+EyeSize+1, אדום/10, ירוק/10, כחול/10);

showStrip ();

עיכוב (SpeedDelay);

}

עיכוב (ReturnDelay);

עבור (int i = NUM_LEDS-EyeSize-2; i> 0; i--) {

setAll (0, 0, 0);

setPixel (i, אדום/10, ירוק/10, כחול/10);

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

לשבור;

}

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

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

לשבור;

}

setPixel (i+j, אדום, ירוק, כחול);

}

setPixel (i+EyeSize+1, אדום/10, ירוק/10, כחול/10);

showStrip ();

עיכוב (SpeedDelay);

}

עיכוב (ReturnDelay);

}

void RunningLights (בתים אדומים, בתים ירוקים, כחול בתים, int oldA0, int oldA1, int oldA2, int oldA3) {

int מיקום = 0;

int WaveDelay;

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

אחרת אם (analogRead (A3)> = 512) {WaveDelay = 60;}

אחרת אם (analogRead (A3)> = 256) {WaveDelay = 40;}

אחר {WaveDelay = 20;}

עבור (int j = 0; j

{

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

לשבור;

}

עמדה ++; // = 0; // מיקום + שיעור;

עבור (int i = 0; i

// גל סינוס, 3 גלי קיזוז יוצרים קשת!

// רמת צף = חטא (i + מיקום) * 127 + 128;

// setPixel (i, רמה, 0, 0);

// רמת צף = חטא (i + מיקום) * 127 + 128;

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

לשבור;

}

setPixel (i, ((sin (i + Position) * 127 + 128)/255) * אדום, ((חטא (i + מיקום) * 127 + 128)/255) * ירוק, ((sin (i + מיקום) * 127 + 128)/255) * כחול);

}

showStrip ();

עיכוב (WaveDelay);

}

}

void meteorRain (בייט אדום, בייט ירוק, כחול בתים, בייט מטאור גודל, בייט meteorTrailDecay, מטאור בוליאני RandomDecay, int oldA0, int oldA1, int oldA2, int oldA3) {

setAll (0, 0, 0);

int SpeedDelay;

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

אחרת אם (analogRead (A3)> = 512) {SpeedDelay = 60;}

אחרת אם (analogRead (A3)> = 256) {SpeedDelay = 40;}

אחרת {SpeedDelay = 20;}

עבור (int i = 0; i <NUM_LEDS+NUM_LEDS; i ++) {

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

לשבור;

}

// דהיית בהירות כל הלדים שלב אחד

עבור (int j = 0; j

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

לשבור;

}

אם ((! meteorRandomDecay) || (אקראי (10)> 5)) {

fadeToBlack (j, meteorTrailDecay);

}

}

// לצייר מטאור

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

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

לשבור;

}

אם ((i-j = 0)) {

setPixel (i-j, אדום, ירוק, כחול);

}

}

showStrip ();

עיכוב (SpeedDelay);

}

}

void fadeToBlack (int ledNo, byte fadeValue) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

uint32_t oldColor;

uint8_t r, g, b;

ערך 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

leds [ledNo].fadeToBlackBy (fadeValue);

#endif

}

// *** החלף לכאן ***

void showStrip () {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.show ();

#endif

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

FastLED.show ();

#endif

}

void setPixel (int Pixel, byte red, byte green, byte blue) {

#ifdef ADAFRUIT_NEOPIXEL_H

// NeoPixel

strip.setPixelColor (Pixel, strip. Color (אדום, ירוק, כחול));

#endif

#ifndef ADAFRUIT_NEOPIXEL_H

// FastLED

leds [Pixel].r = אדום;

leds [Pixel].g = ירוק;

leds [Pixel].b = כחול;

#endif

}

void setAll (אדום בתים, בתים ירוקים, כחול בתים) {

עבור (int i = 0; i <NUM_LEDS; i ++) {

setPixel (i, אדום, ירוק, כחול);

}

showStrip ();

}

שלב 3: יצירת השעון

אני ממליץ להשיג שעון זכוכית שטוח מבפנים. כשהחלתי את המראה הגמישה בחלק הפנימי של השעון הייתה בעיה בגלל שהמספרים בתוך השעון צצו החוצה, המראה התכופפה וכתוצאה מכך אפקט המראה האינסופי לא קרה. עליך להיות בעל יריעת המראה הגמישה וסרט הפרטיות כדי להיות שטוחים ככל האפשר. אם אתה מקבל שעון וודא שאתה יכול למקם את הנורית בפנים ללא בעיה.

שלב 1: פתח את השעון והסר את הזכוכית הקדמית

שלב 2: שים את סרט הפרטיות על הזכוכית הקדמית (סרטון זה מראה לך כיצד לעשות זאת)

שלב 3: החל את המראה הגמישה בחלק הפנימי של השעון (הסר את ידי השעונים לפני שתעשה זאת)

שלב 4: צור חור באמצע כדי להחזיר את ידי השעון לתוכו

שלב 5: הנח את רצועת הלד סביב הקירות הפנימיים של השעון (השתמשתי באקדח דבק חם לשלב זה)

שלב 6: הפעל את רצועת ה- LED והנח את הזכוכית על גבי השעון כדי לראות אם ישנה אפקט מראה אינסוף

שלב 7: לאחר שתסיים עם הכל, חבר את השעון יחד ותן לחוטים לעבור לגב

שלב 8: כל הכבוד שהשלמת את הפרויקט והכל אמור לעבוד כמו שצריך

אם יש לך שאלות אנא הערה להלן (דע שאולי לא אוכל להגיב, אך אעשה כמיטב יכולתי)