पोटेंशियोमीटर के साथ इन्फिनिटी मिरर क्लॉक: 3 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:19

मैं अनंत दर्पण में आया और मैंने इसे वास्तव में बहुत अच्छा पाया। इसने मुझे एक अनंत दर्पण बनाने के लिए प्रेरित किया, लेकिन मुझे एक उद्देश्य के लिए इसकी आवश्यकता थी। इसलिए, मैंने एक कार्यशील अनंत दर्पण घड़ी बनाने का निर्णय लिया। यह एक अनंत दर्पण है जो आपको पोटेंशियोमीटर का उपयोग करके मोड, गति और रंग बदलने की अनुमति देता है। (नोट: मैं पहली बार ऐसा कुछ बना रहा हूं)

आपूर्ति

आइए जानें कि इस चीज़ को बनाने के लिए आपको क्या चाहिए!

आपको चाहिये होगा…

१) १ Arduino Uno

3) 1 ब्रेडबोर्ड

4) 1 स्लाइड स्विच

5) 3 पोटेंशियोमीटर

6) 1 9वी बैटरी

7) 5 मीटर WS2811 LED स्ट्रिप

8) जम्पर केबल तार

9) एक घड़ी (जिस घड़ी में मैंने 12 इंच की बड़ी आधुनिक घड़ी का इस्तेमाल किया)

10) फ्लेक्सिबल मिरर शीट (जिस पर मैंने मिरर शीट का इस्तेमाल किया)

11) प्राइवेसी फिल्म (मैंने वन वे मिरर का इस्तेमाल किया)

१२) सोल्डरिंग की आवश्यकता हो सकती है यह इस बात पर निर्भर करता है कि आपके पास क्या सामग्री है

चरण 1: वायरिंग

वायरिंग काफी सरल है

- SPST स्विच LED को चालू और बंद करता है (A0)

- बायां पोटेंशियोमीटर प्रकाश को नियंत्रित करता है (A1)

- मध्य पोटेंशियोमीटर मोड को नियंत्रित करता है (A2)

- दायां पोटेंशियोमीटर गति को नियंत्रित करता है (A3)

चरण 2: कोड

#शामिल

#पिन परिभाषित करें 6

#परिभाषित करें NUM_LEDS 54

# परिभाषित करें A0 A0

# परिभाषित करें A1 A1

# परिभाषित करें A2 A2

# परिभाषित करें A3 A3

// पैरामीटर 1 = पट्टी में पिक्सेल की संख्या

// पैरामीटर 2 = पिन नंबर (अधिकांश मान्य हैं)

// पैरामीटर 3 = पिक्सेल प्रकार के झंडे, आवश्यकतानुसार एक साथ जोड़ें:

// NEO_KHZ800 800 KHz बिटस्ट्रीम (अधिकांश NeoPixel उत्पाद w/WS2812 LED)

// NEO_KHZ400 400 KHz (क्लासिक 'v1' (v2 नहीं) FLORA पिक्सल, WS2811 ड्राइवर)

// NEO_GRB पिक्सेल GRB बिटस्ट्रीम (अधिकांश NeoPixel उत्पाद) के लिए वायर्ड हैं

// NEO_RGB पिक्सेल RGB बिटस्ट्रीम (v1 FLORA पिक्सेल, v2 नहीं) के लिए वायर्ड हैं

Adafruit_NeoPixel स्ट्रिप = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);

व्यर्थ व्यवस्था() {

पट्टी। शुरू ();

कपड़े उतारने का प्रदर्शन(); // सभी पिक्सल को 'ऑफ' करने के लिए इनिशियलाइज़ करें

}

शून्य लूप () {

अगर (एनालॉगरीड (ए 0)> = 512) {

अगर(एनालॉगरीड(ए2)>=768){

अगर(एनालॉगरीड(A3)>=768){

इंद्रधनुष चक्र (80, एनालॉगरेड (ए 0)), एनालॉग रीड (ए 1), एनालॉग रीड (ए 2), एनालॉग रीड (ए 3));

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

इंद्रधनुष चक्र (60, एनालॉगरेड (ए0), एनालॉग रीड (ए 1), एनालॉग रीड (ए 2), एनालॉग रीड (ए 3));

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

रेनबोसाइकल (४०, एनालॉगरेड (ए०), एनालॉगरेड (ए१), एनालॉगरेड (ए२), एनालॉगरेड (ए३);

}

अन्यथा{

इंद्रधनुष चक्र (20, एनालॉगरेड (ए 0)), एनालॉग रीड (ए 1), एनालॉग रीड (ए 2), एनालॉग रीड (ए 3));

}

} और अगर (एनालॉगरीड (ए 2)> = 512) {

अगर(एनालॉगरीड(A1)>=768){

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

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

CylonBounce (यादृच्छिक (255), 0, 0, 4, एनालॉगरेड (A0), एनालॉगरेड (A1), एनालॉगरेड (A2), एनालॉगरेड (A3));

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

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

}

अन्यथा{

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

}

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

अगर(एनालॉगरीड(A1)>=768){

बाइट आर, जी, बी;

आर = यादृच्छिक (255);

जी = यादृच्छिक (255);

बी = यादृच्छिक (255);

उल्का वर्षा (आर, जी, बी, 10, 20, सच, एनालॉग रीड (ए 0), एनालॉग रीड (ए 1), एनालॉग रीड (ए 2), एनालॉग रीड (ए 3));

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

बाइट आर, जी, बी;

आर = यादृच्छिक (255);

जी = 0;

बी = 0;

उल्का वर्षा (आर, जी, बी, 10, 20, सच, एनालॉग रीड (ए 0), एनालॉग रीड (ए 1), एनालॉग रीड (ए 2), एनालॉग रीड (ए 3));

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

बाइट आर, जी, बी;

आर = 0;

जी = यादृच्छिक (255);

बी = 0;

उल्का वर्षा (आर, जी, बी, 10, 20, सच, एनालॉग रीड (ए 0), एनालॉग रीड (ए 1), एनालॉग रीड (ए 2), एनालॉग रीड (ए 3));

}

अन्यथा{

बाइट आर, जी, बी;

आर = 0;

जी = 0;

बी = यादृच्छिक (255);

उल्का वर्षा (आर, जी, बी, 10, 20, सच, एनालॉग रीड (ए 0), एनालॉग रीड (ए 1), एनालॉग रीड (ए 2), एनालॉग रीड (ए 3));

}

}

और {अगर (एनालॉगरीड (ए 1)> = 768) {

रनिंगलाइट्स (रैंडम (255), रैंडम (255), रैंडम (255), एनालॉगरेड (ए0), एनालॉगरेड (ए 1), एनालॉगरेड (ए 2), एनालॉगरेड (ए 3));

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

रनिंगलाइट्स (यादृच्छिक (255), 1, 1, एनालॉग रीड (ए 0), एनालॉग रीड (ए 1), एनालॉग रीड (ए 2), एनालॉग रीड (ए 3));

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

रनिंगलाइट्स (1, यादृच्छिक (255), 1, एनालॉग रीड (ए 0), एनालॉग रीड (ए 1), एनालॉग रीड (ए 2), एनालॉग रीड (ए 3));

}

अन्यथा{

रनिंगलाइट्स (1, 1, यादृच्छिक (255), एनालॉग रीड (ए 0), एनालॉग रीड (ए 1), एनालॉग रीड (ए 2), एनालॉग रीड (ए 3));

}

}

}अन्यथा{

सेटऑल (0, 0, 0);

}

}

शून्य इंद्रधनुष साइकिल (इंट स्पीडडेले, इंट ओल्डए0, इंट ओल्डए1, इंट ओल्डए2, इंट ओल्डए3) {

बाइट * सी;

uint16_t मैं, जे;

for(j=0; j<256*5; j++) {// व्हील पर सभी रंगों के 5 चक्र

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ओल्डए३+२५६)

टूटना;

}

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

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ओल्डए३+२५६)

टूटना;

}

सी = व्हील (((i * 256 / NUM_LEDS) + जे) और 255);

सेट पिक्सेल (i, *c, *(c+1), *(c+2));

}

शोस्ट्रिप ();

देरी (गति देरी);

}

}

बाइट * व्हील (बाइट व्हीलपॉस) {

स्थिर बाइट सी [3];

अगर (व्हीलपॉस <85) {

सी [0] = व्हीलपोस * 3;

ग [1] = २५५ - व्हीलपॉस * ३;

ग [2] = 0;

} और अगर (व्हीलपॉस <१७०) {

व्हीलपोस - = 85;

सी [0] = २५५ - व्हीलपोस * ३;

ग [1] = 0;

सी [२] = व्हीलपोस * ३;

} अन्यथा {

व्हीलपोस - = १७०;

सी [0] = 0;

ग [1] = व्हीलपोस * ३;

सी [२] = २५५ - व्हीलपॉस * ३;

}

वापसी ग;

}

शून्य CylonBounce (बाइट लाल, बाइट हरा, बाइट नीला, int EyeSize, int oldA0, int oldA1, int oldA2, int oldA3) {

इंट स्पीडडेले;

इंट रिटर्नडेले;

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

और अगर (एनालॉगरीड (ए 3)> = 512) {स्पीडडेले = 60; रिटर्नडेले = 100;}

और अगर (एनालॉग रीड (ए 3)> = 256) {स्पीडडेले = ४०; रिटर्नडेले = ८०;}

अन्य {स्पीडडेले = २०; रिटर्नडेले = ६०;}

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))| |((ओल्डए३+२५६)

टूटना;

}

सेटऑल (0, 0, 0);

सेट पिक्सेल (i, लाल / 10, हरा / 10, नीला / 10);

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

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ओल्डए३+२५६)

टूटना;

}

सेट पिक्सेल (i + j, लाल, हरा, नीला);

}

सेट पिक्सेल (i + आईसाइज + 1, लाल / 10, हरा / 10, नीला / 10);

शोस्ट्रिप ();

देरी (गति देरी);

}

देरी (रिटर्नडेले);

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

सेटऑल (0, 0, 0);

सेट पिक्सेल (i, लाल / 10, हरा / 10, नीला / 10);

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ओल्डए३+२५६)

टूटना;

}

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

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ओल्डए३+२५६)

टूटना;

}

सेट पिक्सेल (i + j, लाल, हरा, नीला);

}

सेट पिक्सेल (i + आईसाइज + 1, लाल / 10, हरा / 10, नीला / 10);

शोस्ट्रिप ();

देरी (गति देरी);

}

देरी (रिटर्नडेले);

}

शून्य रनिंगलाइट्स (बाइट रेड, बाइट ग्रीन, बाइट ब्लू, इंट ओल्डए0, इंट ओल्डए1, इंट ओल्डए2, इंट ओल्डए3) {

इंट पोजीशन = 0;

इंट वेवडेले;

अगर (एनालॉगरीड (ए 3)> = 768) {वेवडेले = 80;}

और अगर (एनालॉगरीड (ए 3)> = 512) {वेवडेले = 60;}

और अगर (एनालॉगरीड (ए 3)> = 256) {वेवडेले = 40;}

अन्य {वेवडेले = २०;}

for(int j=0; j

{

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ओल्डए३+२५६)

टूटना;

}

स्थिति++; // = 0; // स्थिति + दर;

के लिए(int i=0; i

// साइन लहर, 3 ऑफसेट तरंगें इंद्रधनुष बनाती हैं!

// फ्लोट स्तर = पाप (i + स्थिति) * 127 + 128;

// सेट पिक्सेल (i, स्तर, 0, 0);

// फ्लोट स्तर = पाप (i + स्थिति) * 127 + 128;

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ओल्डए३+२५६)

टूटना;

}

setPixel(i, ((sin(i+Position) * 127 + 128)/255)*लाल, ((पाप(i+स्थिति) *१२७ + १२८)/२५५)*हरा, ((पाप(i+स्थिति) *१२७ + १२८)/२५५)*नीला);

}

शोस्ट्रिप ();

देरी (वेवडेले);

}

}

शून्य उल्का वर्षा (बाइट लाल, बाइट हरा, बाइट नीला, बाइट उल्का आकार, बाइट उल्का ट्रेलडे, बूलियन उल्का रैंडमडे, int oldA0, int oldA1, int oldA2, int oldA3) {

सेटऑल (0, 0, 0);

इंट स्पीडडेले;

अगर (एनालॉगरीड (ए 3)> = 768) {स्पीडडेले = 80;}

और अगर (एनालॉगरीड (ए 3)> = 512) {स्पीडडेले = 60;}

और अगर (एनालॉगरीड (ए 3)> = 256) {स्पीडडेले = 40;}

अन्य {गति विलंब = २०;}

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))| |((ओल्डए३+२५६)

टूटना;

}

// फीका चमक सभी एल ई डी एक कदम

for(int j=0; j

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ओल्डए३+२५६)

टूटना;

}

अगर((!meteorRandomDecay) ||(यादृच्छिक(10)>5)) {

फेडटोब्लैक (जे, उल्काट्रेलडेके);

}

}

// उल्का खींचना

के लिए (इंट जे = 0; जे <उल्का आकार; जे ++) {

if(oldA0!=analogRead(A0)||((oldA1-256)>analogRead(A1))||((oldA1+256)analogRead(A2))||((oldA2+256)analogRead(A3))| |((ओल्डए३+२५६)

टूटना;

}

अगर ((आई-जे = 0)) {

setPixel (i-j, लाल, हरा, नीला);

}

}

शोस्ट्रिप ();

देरी (गति देरी);

}

}

शून्य फ़ेडटोब्लैक (इंट लेडनो, बाइट फ़ेडवैल्यू) {

#ifdef ADAFRUIT_NEOPIXEL_H

// नियोपिक्सेल

uint32_t पुराना रंग;

uint8_t आर, जी, बी;

इंट वैल्यू;

पुराना रंग = पट्टी.getPixelColor(ledNo);

आर = (पुराना रंग और 0x00ff0000UL) >> 16;

जी = (पुराना रंग और 0x0000ff00UL) >> 8;

बी = (पुराना रंग और 0x000000ffUL);

आर = (आर <= 10)? 0: (int) r-(r*fadeValue/256);

जी = (जी <= 10)? 0: (int) g-(g*fadeValue/256);

बी = (बी <= 10)? 0: (int) b-(b*fadeValue/256);

strip.setPixelColor (ledNo, r, g, b);

#अगर अंत

#ifndef ADAFRUIT_NEOPIXEL_H

// फास्टलेड

एल ई डी [ledNo].fadeToBlackBy (fadeValue);

#अगर अंत

}

// *** यहां बदलें ***

शून्य शोस्ट्रिप () {

#ifdef ADAFRUIT_NEOPIXEL_H

// नियोपिक्सेल

कपड़े उतारने का प्रदर्शन();

#अगर अंत

#ifndef ADAFRUIT_NEOPIXEL_H

// फास्टलेड

FastLED.शो ();

#अगर अंत

}

शून्य सेट पिक्सेल (इंट पिक्सेल, बाइट रेड, बाइट ग्रीन, बाइट ब्लू) {

#ifdef ADAFRUIT_NEOPIXEL_H

// नियोपिक्सेल

स्ट्रिप.सेट पिक्सेलकलर (पिक्सेल, स्ट्रिप। कलर (लाल, हरा, नीला));

#अगर अंत

#ifndef ADAFRUIT_NEOPIXEL_H

// फास्टलेड

एल ई डी [पिक्सेल]। आर = लाल;

एल ई डी [पिक्सेल]। जी = हरा;

एल ई डी [पिक्सेल]। बी = नीला;

#अगर अंत

}

शून्य सेटऑल (बाइट रेड, बाइट ग्रीन, बाइट ब्लू) {

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

सेट पिक्सेल (i, लाल, हरा, नीला);

}

शोस्ट्रिप ();

}

चरण 3: घड़ी बनाना

मैं एक कांच की घड़ी लेने की सलाह दूंगा जो अंदर की तरफ सपाट हो। जब मैं लचीले दर्पण को घड़ी के अंदर लगा रहा था, तो घड़ी के अंदर की संख्या बाहर निकलने के कारण एक समस्या थी, दर्पण झुक रहा था जिसके परिणामस्वरूप अनंत दर्पण प्रभाव नहीं हो रहा था। आपके पास लचीला दर्पण शीट और गोपनीयता फिल्म जितना संभव हो उतना सपाट होना चाहिए। यदि आपको घड़ी मिल रही है तो सुनिश्चित करें कि आप बिना किसी समस्या के एलईडी को अंदर रख सकते हैं।

चरण 1: घड़ी खोलें और सामने का शीशा हटा दें

चरण 2: प्राइवेसी फिल्म को फ्रंट ग्लास पर लगाएं (यह वीडियो आपको दिखाता है कि यह कैसे करना है)

चरण 3: लचीले दर्पण को घड़ी के अंदर लगाएं (ऐसा करने से पहले घड़ियों के हाथ हटा दें)

चरण 4: घड़ी के हाथों को वापस अंदर रखने के लिए बीच में एक छेद करें

चरण 5: एलईडी पट्टी को घड़ी की अंदर की दीवारों के चारों ओर रखें (मैंने इस चरण के लिए एक गर्म गोंद बंदूक का इस्तेमाल किया)

चरण 6: एलईडी पट्टी चालू करें और कांच को घड़ी के ऊपर रखें यह देखने के लिए कि क्या अनंत दर्पण प्रभाव है या नहीं

चरण 7: एक बार जब आप सब कुछ कर लेते हैं तो घड़ी को एक साथ रख दें और तारों को पीछे से गुजरने दें

चरण 8: बधाई हो कि आपने प्रोजेक्ट पूरा कर लिया है और सब कुछ ठीक काम करना चाहिए

यदि आपके कोई प्रश्न हैं, तो कृपया उन्हें नीचे टिप्पणी करें (जानें कि मैं जवाब देने में सक्षम नहीं हो सकता, लेकिन मैं अपनी पूरी कोशिश करूंगा)