Arduino के साथ DIY स्मार्ट इलेक्ट्रॉनिक Ukulele: 14 कदम (चित्रों के साथ)

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

हम चरण दर चरण यह समझाने जा रहे हैं कि आप अपने स्वयं के गिटार को कैसे डिज़ाइन कर सकते हैं और कुछ प्रभाव जोड़ सकते हैं जो इसे अद्वितीय बना देंगे, जैसे कि कुछ ऐसा बनाना जो हम गिटार की सतह पर चाहते हैं या कुछ प्रकाश प्रभाव जोड़ना।

इसे बनाने के लिए, एक गिटार किट खरीदना आवश्यक है।

हम यह समझाने जा रहे हैं कि उपकरण को कैसे इकट्ठा किया जाए, और विभिन्न समस्याओं को हल किया जाए जो प्रकट हो सकती हैं।

चरण 1: सामग्री

संरचना सामग्री:

DIY यूकेलेल माउंटिंग किट (यह एक और अलग किट हो सकती है) द्वारा बनाई गई:

1- शरीर।

2-गर्दन।

3-काठी

4-रस्सी समर्थन

5-ब्रिज

6-स्ट्रिंग अखरोट।

मशीन हेड (x4) के लिए 7-फिक्सिंग रिंग।

8-मशीन हेड्स (x4)।

9-मशीन के सिर के लिए बढ़ते शिकंजा (x8)।

मशीन पुल (x2) के लिए 10-बढ़ते शिकंजा।

ब्रिज माउंटिंग स्क्रू (x2) के लिए 11-कवर कैप।

12-स्ट्रिंग्स (x4)।

इलेक्ट्रॉनिक सामग्री:

• नैनो अरुडिनो।
• एलईडी का पहिया WS2812।
• एक्सेलेरोमीटर BMA220 (वैकल्पिक)।
• बैटरी कनेक्टर।
• 9वी की बैटरी।
• स्विच करें।

अन्य

• लकड़ी का वार्निश।
• वेल्क्रो।
• सोल्डरिंग टिन।
• वार्निशिंग के लिए सुरक्षात्मक प्लास्टिक।
• गर्म पिघल सिलिकॉन।

उपकरण:

• लेजर उत्कीर्णन।
• सैंडपेपर
• स्टार पेचकश।
• पेंटब्रश।
• गर्म पिघल बंदूक।
• टिन टांका लगाने वाला लोहा।

चरण 2: गिटार को अनुकूलित करें

अपने गिटार को पोशाक में बदलने के लिए हम शरीर पर एक लेजर कटर के साथ एक चित्र का उत्कीर्णन कर सकते हैं। वह उपकरण न होने की स्थिति में, हम उसे पेंट कर सकते हैं।

हमने जो तस्वीर चुनी है, वह सबसे पहले सामने आती है।

सबसे पहले, हमें उत्कीर्णन बनाने के लिए ड्राइंग टेम्प्लेट को डिज़ाइन करना होगा।

ऐसा करने के लिए, हम 'इंकस्केप' नामक एक सॉफ्टवेयर का उपयोग करेंगे जिसे हम इस लिंक से प्राप्त कर सकते हैं:

इसका उपयोग करने के लिए, हमें उस चित्र को समायोजित करना होगा जिसे हम उपयोग करना चाहते हैं जैसे हम दूसरी छवि में दिखाते हैं। आप देख सकते हैं कि हमने उपकरण के घेरे के साथ हाथ के चक्र को समायोजित करने के लिए प्रारंभिक छवि को घुमाया है। जैसा कि हमने पहले कहा है, आप कोई भी इमेज लगा सकते हैं।

चरण 3: इंकस्केप का उपयोग करके एक छवि को वेक्टर करें

हम देखेंगे कि एक पिक्समैप (जेपीजी, पीएनजी, जो भी रास्टर प्रारूप इंकस्केप खोल सकता है) से वेक्टर फ़ाइल कैसे बनाएं।

इंकस्केप इंकस्केप एक ओपन-सोर्स वेक्टर ग्राफिक्स एडिटर है, और जैसा कि शीर्षक से पता चलता है, यह वह उपकरण है जिसका उपयोग मैं लोगो को वेक्टर करने के लिए करूंगा। सदिशीकरण चरण किसी भी वैश्वीकरण के लिए चरण सामान्य हैं जो हम करना चाहते हैं।

1. छवि को इंकस्केप में खोलें
2. ट्रेस बिटमैप टूल पथ खोलें-> ट्रेस बिटमैप
3. ट्रेस बिटमैप विकल्पों के आसपास खेलें
4. ट्रेसिंग चलाएं
5. परिणाम साफ़ करें (यदि आवश्यक हो)

"चारों ओर खेलना" भाग पर ध्यान दें। मैं ट्रेसिंग का विशेषज्ञ नहीं हूं, इसलिए मैं इस टूल को एक ब्लैक बॉक्स के रूप में मानता हूं जिसमें नॉब्स और लाइट्स हैं, जब तक कि मुझे सबसे अच्छा परिणाम नहीं मिल जाता है, तब तक मैं घुमाता और बदलता रहता हूं।

चरण 4: लोगो उत्कीर्णन

इसके लिए, सतह का एक सिल्हूट होना जरूरी है, जिस पर ड्राइंग की नक्काशी की जाएगी।

उत्कीर्णन बनाने के लिए, हम 'T2Laser' सॉफ्टवेयर का उपयोग करने जा रहे हैं। हम इस सॉफ्टवेयर को यहां से प्राप्त कर सकते हैं:

एक बार जब हम सॉफ्टवेयर खोल लेते हैं, तो हमें उस छवि को लोड करना होता है जो हमने अंतिम चरण में बनाई है। फिर, "नियंत्रण लेजर" बटन दबाएं, और सीएनसी नियंत्रण प्रकट होता है। दो तस्वीरें हमारे लेजर कटर के साथ उत्कीर्णन की प्रक्रिया और परिणाम दिखाती हैं।

चरण 5: सैंडिंग और वार्निशिंग

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

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

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

** सावधानियां: वार्निश एक रासायनिक उत्पाद है, इसलिए इस प्रक्रिया को हवादार जगह पर करना आवश्यक है, सांस लेने में गंध और सुरक्षात्मक चश्मे से बचने के लिए मास्क पहनें।

जिन सामग्रियों को हमें सही ढंग से काम करने में सक्षम होना चाहिए, वे वे हैं जो तस्वीरों में दिखाई देते हैं। मुख्य रूप से हम एक ब्रश, एक वार्निश कैन (हमारे मामले में लाल रंग), थोड़ा विलायक और दृश्य सुरक्षा के साथ काम करेंगे। और सब से ऊपर अच्छी तरह हवादार जगहों में काम करते हैं।

चरण 6: हार्डवेयर

Arduino के साथ हमारी पट्टिका, एक्सेलेरोमीटर और एलईडी के साथ पहिया को एक छोटे से ब्रैकेट में पेश किया जा रहा है ताकि सभी घटकों को उपकरण में स्थानांतरित न किया जा सके।

हमने इसे और अधिक आरामदायक बनाने के लिए एक बैटरी होल्डर और एक स्विच भी जोड़ा है और जब हम उपकरण का उपयोग नहीं कर रहे होते हैं तो हम बैटरी खराब नहीं करते हैं। हम इस समर्थन को वेल्क्रो के एक टुकड़े के साथ जोड़ देंगे (यह सिलिकॉन और एक गर्म पिघल बंदूक के साथ भी काम करेगा) यूकेलेल बॉडी के अंदरूनी हिस्से में। दूसरी ओर, एलईडी व्हील छेद से छोटा है, इसलिए यह गिर जाएगा. एक समर्थन तैयार किया गया है ताकि यह अच्छी तरह से धारण कर सके और अपना कार्य कर सके।

चरण 7: सॉफ्टवेयर

हमारे गिटार को एक विशेष सजावट देने के लिए, हम एलईडी के एक पहिये के लिए धन्यवाद प्रकाश प्रभाव जोड़ सकते हैं। हम WS2812 का उपयोग करने जा रहे हैं, लेकिन आप डेटाशीट के निर्देशों का पालन करते हुए किसी अन्य का उपयोग कर सकते हैं। हम एक एक्सेलेरोमीटर (BMA220) का भी उपयोग करेंगे, जो हमें गुरुत्वाकर्षण का प्रभाव बनाने की अनुमति देता है।

वास्तव में, हमारे पास प्रकाश के 4 नाटक होंगे, जिन्हें Arduino के 'Adafruit' नामक कंप्यूटर लाइब्रेरी में शामिल किया गया है। उसके लिए, हमें तीन घटकों के बीच एक सही संबंध बनाना चाहिए: Arduino NANO, WS2812 और BMA220, जैसा कि पहली छवि में दिखाई देता है।

लाल तार बिजली के लिए हैं, जीएनडी काले और बाकी सही संचालन के लिए आवश्यक कनेक्शन हैं। लाइट किट के लिए हमने जो कोड इस्तेमाल किया है वह "play_of_light_v0.ino" नामक फ़ाइल में संलग्न है। सुनिश्चित करें कि आपने कार्यक्रम के सही संचालन के लिए आवश्यक पुस्तकालयों को शामिल किया है। जिस बैटरी को हम बाहरी सर्किट में जोड़ते हैं उसमें न्यूनतम वोल्टेज 9V होना चाहिए और हमें यह सुनिश्चित करना होगा कि यह पूरे सर्किट को बिजली देने के लिए आवश्यक न्यूनतम करंट देने में सक्षम हो।

// चर contador e interrupciónint काउंटर; // वेरिएबल उदाहरण ग्रेवडैड #include #include #include #define NUMBER_OF_LEDS_ON_RING 16 #define NEOPIXEL_RING_DATA_PIN 9

बाइट संस्करण [3];

int8_t x_data; int8_t y_data; int8_t z_data; बाइट रेंज = 0x00; फ्लोट डिवी = 16; फ्लोट एक्स, वाई, जेड; फ्लोट पाई = 3.14159265359; फ्लोट एनएक्स, एनवाई, कोण; इंट एलईडी, पिछला एलईडी; कतार सूची नेतृत्व कतार; Adafruit_NeoPixel neoring = Adafruit_NeoPixel(NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// वेरिएबल्स लूस आर्कोइरिस

#include #ifdef _AVR_ #include #endif #define PIN 9 // पैरामीटर 1 = स्ट्रिप में पिक्सल की संख्या // पैरामीटर 2 = Arduino पिन नंबर (अधिकांश मान्य हैं) // पैरामीटर 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 नहीं) के लिए वायर्ड होते हैं // NEO_RGBW पिक्सेल RGBW बिटस्ट्रीम (NeoPixel RGBW उत्पादों) के लिए वायर्ड होते हैं Adafruit_NeoPixel स्ट्रिप = Adafruit_NeoPixel (16, पिन, NEO_GRB + NEO_KHZ800); // महत्वपूर्ण: NeoPixel बर्नआउट जोखिम को कम करने के लिए, // पिक्सेल पावर लीड में 1000 uF कैपेसिटर जोड़ें, पहले पिक्सेल के डेटा इनपुट पर 300 - 500 ओम रेसिस्टर जोड़ें // और Arduino और पहले पिक्सेल के बीच की दूरी को कम करें। लाइव सर्किट पर // कनेक्ट करने से बचें … अगर आपको चाहिए, तो पहले GND कनेक्ट करें।

// वेरिएबल्स रुएडा डे कोलोरेस

// NeoPixel रिंग सिंपल स्केच (c) 2013 Shae Erisson // AdaFruit NeoPixel लाइब्रेरी के बाकी हिस्सों से मेल खाने के लिए GPLv3 लाइसेंस के तहत जारी किया गया

#शामिल

#ifdef _AVR_ #include #endif

// Arduino पर कौन सा पिन NeoPixels से जुड़ा है?

// ट्रिंकेट या जेम्मा पर हम इसे 1 #define PIN 9. में बदलने का सुझाव देते हैं

// Arduino से कितने NeoPixels जुड़े हुए हैं?

#परिभाषित करें NUMPIXELS 16

// जब हम NeoPixel लाइब्रेरी को सेटअप करते हैं, तो हम उसे बताते हैं कि सिग्नल भेजने के लिए कितने पिक्सल और किस पिन का उपयोग करना है।

// ध्यान दें कि पुराने NeoPixel स्ट्रिप्स के लिए आपको तीसरे पैरामीटर को बदलने की आवश्यकता हो सकती है - संभावित मूल्यों के बारे में अधिक जानकारी के लिए स्ट्रैंडटेस्ट // उदाहरण देखें। Adafruit_NeoPixel पिक्सेल = Adafruit_NeoPixel(NUMPIXELS, पिन, NEO_GRB + NEO_KHZ800); इंट डिलेवल = ५०; // 50ms. के लिए देरी

// वेरिएबल कलर्स एलेटोरियोस

#शामिल करें #ifdef _AVR_ #शामिल करें #endif

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

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

#ब्राइटनेस 200 परिभाषित करें

// Adafruit_NeoPixel स्ट्रिप = Adafruit_NeoPixel (NUM_LEDS, पिन, NEO_GRBW + NEO_KHZ800);

बाइट नियोपिक्स_गामा = {

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25, 25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36, 37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50, 51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68, 69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89, 90, 92, 93, 95, 96, 98, 99, 101, 102, 104, 105, 107, 109, 110, 112, 114, 115, 117, 119, 120, 122, 124, 126, 127, 129, 131, 133, 135, 137, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 167, 169, 171, 173, 175, 177, 180, 182, 184, 186, 189, 191, 193, 196, 198, 200, 203, 205, 208, 210, 213, 215, 218, 220, 223, 225, 228, 231, 233, 236, 239, 241, 244, 247, 249, 252, 255 }; /////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////

/मेटोडो सेटअप

शून्य सेटअप () {// कोडिगो: डायरेक्शन डे ला ग्रेवडैड नियोरिंग.बेगिन (); neoring.setBrightness (200); सीरियल.बेगिन (९६००); वायर.बेगिन (); वायर.बेगिनट्रांसमिशन (0x0A); // एक्सेलेरोमीटर का पता // रेंज सेटिंग्स वायर.राइट (0x22); // रजिस्टर पता वायर.राइट (रेंज); // "0x00" "0x01" "0x02" "0x03" पर सेट किया जा सकता है, विकी पर डेटाशेट देखें // कम पास फिल्टर Wire.write(0x20); // रजिस्टर पता वायर.राइट (0x05); //"0x05""0x04"……"0x01""0x00" पर सेट किया जा सकता है, विकी Wire.endTransmission() पर डेटाशेट देखें;

// कोडिगो; लुसेस आर्कोइरिस

// यह ट्रिंकेट 5V 16MHz के लिए है, यदि आप ट्रिंकेट का उपयोग नहीं कर रहे हैं तो आप इन तीन लाइनों को हटा सकते हैं #if परिभाषित (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // ट्रिंकेट स्पेशल कोड स्ट्रिप का अंत। शुरू (); कपड़े उतारने का प्रदर्शन(); // सभी पिक्सल को 'ऑफ' करने के लिए इनिशियलाइज़ करें

// कोडिगो रुएडा डे कोलोरेस

// यह ट्रिंकेट 5V 16MHz के लिए है, यदि आप ट्रिंकेट का उपयोग नहीं कर रहे हैं तो आप इन तीन लाइनों को हटा सकते हैं #if परिभाषित (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // ट्रिंकेट स्पेशल कोड का अंत

पिक्सल। शुरू (); // यह NeoPixel लाइब्रेरी को इनिशियलाइज़ करता है।

// कोडिगो इंटररप्सियन

काउंटर = 1;

// कोडिगो कोलोरेस varios

// यह ट्रिंकेट 5V 16MHz के लिए है, यदि आप ट्रिंकेट का उपयोग नहीं कर रहे हैं तो आप इन तीन लाइनों को हटा सकते हैं #if परिभाषित (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // ट्रिंकेट स्पेशल कोड स्ट्रिप का अंत। सेटब्राइटनेस (ब्राइटनेस); पट्टी। शुरू (); कपड़े उतारने का प्रदर्शन(); // सभी पिक्सल को 'ऑफ' करने के लिए इनिशियलाइज़ करें}

///////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

/ब्यूकल इनफिनिटो

शून्य लूप () {// कैसो १: जुएगो डे लुसेस डे ला ग्रेवडैड; अगर (काउंटर == 1) {के लिए (इंट आई = 0; आई 0.0) { अगर (एनएक्स 0.0) कोण + = 180; अन्य कोण += ३६०; }//अंत और अगर (कोण == 360.0) कोण = 0.0; एलईडी = गोलाकार (कोण / (360 / NUMBER_OF_LEDS_ON_RING)); // लेड मूवमेंट को सुचारू बनाएं यदि (पिछला लेड == एलईडी) {// कुछ नहीं करना है} और अगर (काउंटरक्लॉकवाइज डिस्टेंसबेटवीन लेड्स (पिछला एलईडी, एलईडी) <= 8) एलईडी = सर्कुलराइज (पिछला एलईडी + 1); अन्य नेतृत्व = परिपत्र (पिछला एलईडी - 1); एलईडी क्यू। पुश (एलईडी); मेकलाइटशो (); पिछला एलईडी = नेतृत्व किया; देरी (25); } काउंटर = 2; }//एंड अगर काउंटर == 1 // कैसो 2: कोडिगो डेल जुएगो डे लुसेस डेल आर्कोइरिस और अगर (काउंटर == 2) {के लिए (इंट जे = 0; जे <5; जे ++) {// कुछ उदाहरण प्रक्रियाएं दिखा रही हैं पिक्सल को कैसे प्रदर्शित करें: colorWipe1(strip. Color(255, 0, 0), 50); // लाल रंग वाइप 1 (पट्टी। रंग (0, 255, 0), 50); // हरा रंगWipe1(strip. Color(0, 0, 255), 50); // नीला रंगWipe1(strip. Color(0, 0, 0, 255), 50); // व्हाइट RGBW // थिएटर पिक्सेल चेज़ इन… थिएटरचेज़ (स्ट्रिप। कलर (१२७, १२७, १२७), ५०); // व्हाइट थिएटरचेस (पट्टी। रंग (127, 0, 0), 50); // रेड थिएटरचेस (स्ट्रिप। कलर (0, 0, 127), 50); // नीला

इंद्रधनुष(५);

इंद्रधनुष चक्र(५); थिएटरचेसइंद्रधनुष(5); } काउंटर = 3; }//End if काउंटर==2 //Caso 3: Luces Aleatorias else if(counter == 3){ for(int k=0;k<50;k++){ // NeoPixels के एक सेट के लिए पहला NeoPixel है 0, दूसरा 1 है, सभी तरह से पिक्सल माइनस वन की गिनती तक। इंट ए = यादृच्छिक (255); इंट बी = यादृच्छिक (255); इंट सी = यादृच्छिक (255); के लिए(int i=0;i

// पिक्सेल। रंग आरजीबी मान लेता है, 0, 0, 0 से 255, 255, 255. तक

pixel.setPixelColor(i, pixel. Color(a, b, c)); // मध्यम चमकीला हरा रंग।

पिक्सल.शो (); // यह अद्यतन पिक्सेल रंग हार्डवेयर को भेजता है।

देरी (देरी); // समय की अवधि के लिए देरी (मिलीसेकंड में)।

} ए = यादृच्छिक (255); बी = यादृच्छिक (255); सी = यादृच्छिक (255); for(int i=NUMPIXELS;i>0;i--){

// पिक्सेल। रंग आरजीबी मान लेता है, 0, 0, 0 से 255, 255, 255. तक

pixel.setPixelColor(i, pixel. Color(a, b, c)); // मध्यम चमकीला हरा रंग।

पिक्सल.शो (); // यह अद्यतन पिक्सेल रंग हार्डवेयर को भेजता है।

देरी (देरी); // समय की अवधि के लिए देरी (मिलीसेकंड में)।

} } काउंटर = 4; } और अगर (काउंटर == 4) {के लिए (इंट जी = 0; जी <= 6; जी ++) {// कुछ उदाहरण प्रक्रियाएं दिखाती हैं कि पिक्सल को कैसे प्रदर्शित किया जाए: कलरवाइप (स्ट्रिप। कलर (255, 0, 0), 50); // लाल रंग पोंछें (पट्टी। रंग (0, 255, 0), 50); // हरा रंग वाइप (पट्टी। रंग (0, 0, 255), 50); // नीला रंगवाइप (पट्टी। रंग (0, 0, 0, 255), 50); // व्हाइट व्हाइटओवररेनबो (20, 75, 5); पल्सव्हाइट(५); // फुलव्हाइट (); // देरी (2000); रेनबोफ़ेड२व्हाइट(३, ३, १);

}

काउंटर = 1; } } ///////////////////////////////////////////// ////////////////////////////////////////////// /////////////////////////////////////////////// /////////////////

/मेटोडोस डेल एजेम्प्लो डे ला ग्रेवडैड

शून्य एक्सेलेरोमीटरइनिट () {वायर.बेगिनट्रांसमिशन (0x0A); // एक्सेलेरोमीटर का पता // एक्सेलेरोमीटर वायर को रीसेट करें। लिखें (0x04); // एक्स डेटा वायर.एंडट्रांसमिशन (); Wire.requestFrom (0x0A, 1); // स्लेव डिवाइस से 6 बाइट्स का अनुरोध करें # 2 जबकि (वायर.उपलब्ध ()) // गुलाम अनुरोध से कम भेज सकता है {संस्करण [0] = वायर.रीड (); // चरित्र के रूप में एक बाइट प्राप्त करें} x_data=(int8_t)संस्करण[0]>>2; वायर.बेगिनट्रांसमिशन (0x0A); // एक्सेलेरोमीटर का पता // एक्सेलेरोमीटर वायर को रीसेट करें। लिखें (0x06); // वाई डेटा वायर.एंडट्रांसमिशन (); Wire.requestFrom (0x0A, 1); // स्लेव डिवाइस से 6 बाइट्स का अनुरोध करें # 2 जबकि (वायर.उपलब्ध ()) // गुलाम अनुरोध से कम भेज सकता है {संस्करण [1] = वायर.रीड (); // चरित्र के रूप में एक बाइट प्राप्त करें} y_data=(int8_t)संस्करण[1]>>2; वायर.बेगिनट्रांसमिशन (0x0A); // एक्सेलेरोमीटर का पता // एक्सेलेरोमीटर वायर को रीसेट करें। लिखें (0x08); // जेड डेटा वायर.एंडट्रांसमिशन (); Wire.requestFrom (0x0A, 1); // स्लेव डिवाइस से 6 बाइट्स का अनुरोध करें # 2 जबकि (वायर.उपलब्ध ()) // गुलाम अनुरोध से कम भेज सकता है {संस्करण [2] = वायर.रीड (); // चरित्र के रूप में एक बाइट प्राप्त करें} z_data=(int8_t)संस्करण[2]>>2; एक्स = (फ्लोट) x_data/divi; y=(फ्लोट)y_data/divi; z=(फ्लोट)z_data/divi; सीरियल.प्रिंट ("एक्स ="); सीरियल.प्रिंट (एक्स); // चरित्र को प्रिंट करें Serial.print(""); सीरियल.प्रिंट ("वाई ="); सीरियल.प्रिंट (वाई); // चरित्र को प्रिंट करें Serial.print(""); सीरियल.प्रिंट ("जेड ="); // चरित्र को प्रिंट करें Serial.println(z); }

इंट सर्कुलराइज़ (इंट पॉज़) {

अगर (स्थिति> = NUMBER_OF_LEDS_ON_RING) वापसी (स्थिति - NUMBER_OF_LEDS_ON_RING); और अगर (स्थिति <0) वापसी (स्थिति + NUMBER_OF_LEDS_ON_RING); अन्य वापसी (स्थिति); }

अंतर दूरी;

इंट काउंटरक्लॉकवाइज डिस्टेंसबीच एलईडी (इंट प्रीवपोस, इंट नेक्स्ट पोस) {दूरी = नेक्स्टपोस - प्रीवपोस; अगर (दूरी <0) दूरी += NUMBER_OF_LEDS_ON_RING; वापसी (दूरी); }

int नेतृत्व स्थिति, currentQueueSize;

#परिभाषित करें NUMBER_OF_LEDS_TO_SHINE 10 इंट ब्राइटनेसस्टेप = 255/NUMBER_OF_LEDS_TO_SHINE;

शून्य मेकलाइटशो () {

for(int j = 0; j <NUMBER_OF_LEDS_ON_RING; j++) neoring.setPixelColor(j, 0, 0, 0); currentQueueSize = ledQueue.count (); for(int k = 0; k <currentQueueSize; k++){ledPosition =ledQueue.pop(); neoring.setPixelColor (ledPosition, 0, (ब्राइटनेसस्टेप * k), 0); if((k == 0 && currentQueueSize 0) ledQueue.push(ledPosition); } neoring.show(); }

///////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

/मेटोडोस डेल जुएगो डे लुसेस डेल आर्कोइरिस

// डॉट्स को एक के बाद एक रंग शून्य रंग से भरें (uint32_t c, uint8_t प्रतीक्षा करें) { for(uint16_t i=0; i

शून्य इंद्रधनुष (uint8_t प्रतीक्षा करें) {

uint16_t मैं, जे;

for(j=0; j<256; j++) { for(i=0; i

// थोड़ा अलग, यह इंद्रधनुष को समान रूप से वितरित करता है

शून्य इंद्रधनुष चक्र (uint8_t प्रतीक्षा करें) { uint16_t i, j;

for(j=0; j<256*5; j++) {// 5 चक्र पर सभी रंगों के चक्र के लिए (i=0; i< strip.numPixels(); i++) { strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels ()) + j) और 255); } कपड़े उतारने का प्रदर्शन(); देरी (प्रतीक्षा); } }

// थिएटर-शैली रेंगने वाली रोशनी।

शून्य थिएटरचेज़ (uint32_t c, uint8_t प्रतीक्षा करें) { के लिए (int j=0; j<10; j++) {// का पीछा करने के 10 चक्र करें (int q=0; q <3; q++) { के लिए (uint16_t i= 0; मैं < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, c); // हर तीसरे पिक्सेल को } स्ट्रिप.शो () पर चालू करें;

देरी (प्रतीक्षा);

के लिए (uint16_t i=0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, 0); // हर तीसरे पिक्सेल को बंद करें } } } }

// थिएटर-शैली रेंगने वाली रोशनी इंद्रधनुष प्रभाव के साथ

शून्य थिएटरचेसरेनबो (uint8_t प्रतीक्षा) { के लिए (int j=0; j <256; j++) {// चक्र में सभी 256 रंगों के लिए (int q=0; q <3; q++) { के लिए (uint16_t i=0 i // हर तीसरे पिक्सेल को } स्ट्रिप.शो () पर चालू करें;

देरी (प्रतीक्षा);

के लिए (uint16_t i=0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, 0); // हर तीसरे पिक्सेल को बंद करें } } } }

// रंग मान प्राप्त करने के लिए 0 से 255 मान इनपुट करें।

// रंग एक संक्रमण आर-जी-बी-बैक टू आर हैं। uint32_t व्हील (बाइट व्हीलपॉज़) {व्हीलपॉज़ = 255 - व्हीलपॉज़; अगर (व्हीलपॉस <85) {रिटर्न स्ट्रिप। कलर (255 - व्हीलपॉस * 3, 0, व्हीलपॉस * 3); } अगर (व्हीलपोस <१७०) {व्हीलपोस - = ८५; वापसी पट्टी। रंग (0, व्हीलपॉस * 3, 255 - व्हीलपॉस * 3); } व्हीलपोस - = १७०; वापसी पट्टी। रंग (व्हीलपॉस * 3, 255 - व्हीलपॉस * 3, 0); }

///////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

/मेटोडोस रुएडा डे कोलोरेस

// int elegirColor = random(0x000000, 0xffffff); // से एलीगे एलेटोरियामेंट एंट्रे टोडा ला गामा डे कोलोरेस कॉम्प्रेन्डिडा एंट्रे 0x000000 y 0xFFFFFF

//CylonEyeColor=HtmlColor(elegirColor); // int elegirColor = random(1, 7); // Podemos elegir aleatoriamente entre los 7 colores que hay debajo0xf0ffff // if(elegirColor == 1) CylonEyeColor=HtmlColor(0xff0000);//Rojo // if(elegirColor == 2) CylonEyeColor=HtmlColor(0x00ff00);//Verde // if(elegirColor == 3) CylonEyeColor=HtmlColor(0x0000ff);//Azul // if(elegirColor == 4) CylonEyeColor=HtmlColor(0xffff00);//Amarillo // अगर (elegirColor == 5) CylonEyeColor = HtmlColor (0x200020); // मोराडो // अगर (elegirColor == 6) CylonEyeColor = HtmlColor (0x00ffff); // Azul Claro // if (elegirColor == 7) CylonEyeColor= HtmlColor(0x100010);//Rosa //CylonEyeColor=HtmlColor(0x000000);

///////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

/Metodos luces varias

// डॉट्स को एक के बाद एक रंग से भरें

शून्य colorWipe1 (uint32_t c, uint8_t प्रतीक्षा करें) { for(uint16_t i=0; i

शून्य पल्स व्हाइट (uint8_t प्रतीक्षा करें) {

for(int j = 0; j <256; j++){ for(uint16_t i=0; i

के लिए (इंट जे = 255; जे> = 0; जे--) {

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

शून्य इंद्रधनुषफेड 2 व्हाइट (uint8_t प्रतीक्षा करें, इंट रेनबोलूप्स, इंट व्हाइटलूप्स) {

फ्लोट फेडमैक्स = १००.०; इंट फ़ेडवैल = 0; uint32_t व्हीलवैल; इंट रेडवैल, ग्रीनवैल, ब्लूवैल;

के लिए (इंट के = 0; के <इंद्रधनुष लूप्स; के ++) {के लिए (इंट जे = 0; जे <256; जे ++) {// व्हील पर सभी रंगों के 5 चक्र

for(int i=0; i< strip.numPixels(); i++) {

WheelVal = Wheel(((i * 256 / strip.numPixels ()) + j) और 255);

redVal = लाल (व्हीलवैल) * फ्लोट (fadeVal/fadeMax);

ग्रीनवैल = हरा (व्हीलवैल) * फ्लोट (फीडवैल / फेडमैक्स); BlueVal = नीला (व्हीलवैल) * फ्लोट (fadeVal/fadeMax);

स्ट्रिप.सेट पिक्सेलकलर (i, स्ट्रिप। कलर (रेडवैल, ग्रीनवैल, ब्लूवैल));

}

// पहला लूप, फीका इन!

अगर (के == 0 && फेडवैल <fadeMax-1) {fadeVal++; }

// अंतिम लूप, फीका आउट!

और अगर (के == रेनबोलूप्स - 1 && जे> 255 - फेडमैक्स) {fadeVal--; }

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

देरी (प्रतीक्षा); } }

देरी (500);

के लिए (इंट के = 0; के <व्हाइटलूप्स; के ++) {

के लिए (इंट जे = 0; जे <256; जे ++) {

for(uint16_t i=0; i < strip.numPixels(); i++) { strip.setPixelColor(i, strip. Color(0, 0, 0, neopix_gamma[j])); } कपड़े उतारने का प्रदर्शन(); }

देरी (2000);

के लिए (इंट जे = 255; जे> = 0; जे--) {

for(uint16_t i=0; i < strip.numPixels(); i++) { strip.setPixelColor(i, strip. Color(0, 0, 0, neopix_gamma[j])); } कपड़े उतारने का प्रदर्शन(); } }

देरी (500);

}

शून्य सफेद ओवररेनबो (uint8_t प्रतीक्षा करें, uint8_t सफेद गति, uint8_t सफेद लंबाई) {

if(whiteLength>= strip.numPixels()) whiteLength = strip.numPixels() - 1;

इंट हेड = व्हाइटलेंथ - 1;

इंट टेल = 0;

इंट लूप्स = 3;

इंट लूपनम = 0;

स्थिर अहस्ताक्षरित लंबे समय तक अंतिम समय = 0;

जबकि (सच) {

for(int j=0; j<256; j++) { for(uint16_t i=0; i=tail && i head && i >=tail) || (पूंछ > सिर && i <= सिर)) {trip.setPixelColor(i, strip. Color(0, 0, 0, 255)); } और {trip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) और 255); } }

अगर (मिली () - लास्टटाइम> व्हाइटस्पीड) {

सिर++; पूंछ++; अगर (सिर == स्ट्रिप.numPixels ()) {लूपनम ++; } लास्टटाइम = मिली (); }

अगर (लूपनम == लूप) वापसी;

सिर%=strip.numPixels(); पूंछ%=strip.numPixels(); कपड़े उतारने का प्रदर्शन(); देरी (प्रतीक्षा); } } } पूर्ण सफेद () { के लिए (uint16_t i=0; i

// थोड़ा अलग, यह इंद्रधनुष को समान रूप से वितरित करता है

शून्य इंद्रधनुष साइकिल1(uint8_t प्रतीक्षा करें) { uint16_t i, j;

for(j=0; j<256 * 5; j++) {// 5 चक्रों के सभी रंगों के पहिए के लिए (i=0; i< strip.numPixels(); i++) { strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels ()) + j) और 255); } कपड़े उतारने का प्रदर्शन(); देरी (प्रतीक्षा); } }

शून्य इंद्रधनुष1(uint8_t प्रतीक्षा करें) {

uint16_t मैं, जे;

for(j=0; j<256; j++) { for(i=0; i

// रंग मान प्राप्त करने के लिए 0 से 255 मान इनपुट करें।

// रंग एक संक्रमण आर-जी-बी-बैक टू आर हैं। uint32_t Wheel1(बाइट WheelPos) { WheelPos = 255 - WheelPos; अगर (व्हीलपॉस <85) {रिटर्न स्ट्रिप। कलर (255 - व्हीलपॉस * 3, 0, व्हीलपॉस * 3, 0); } अगर (व्हीलपोस <१७०) {व्हीलपोस - = ८५; वापसी पट्टी। रंग (0, व्हीलपॉस * 3, 255 - व्हीलपॉस * 3, 0); } व्हीलपोस - = १७०; वापसी पट्टी। रंग (व्हीलपॉस * 3, 255 - व्हीलपॉस * 3, 0, 0); }

uint8_t लाल (uint32_t c) {

वापसी (सी >> 16); } uint8_t हरा (uint32_t c) {रिटर्न (c >> 8); } uint8_t नीला (uint32_t c) {वापसी (c); }

चरण 8: 3D डिज़ाइन

सबसे पहले, आपको सही के बारे में सुनिश्चित करने के लिए अपने हार्डवेयर घटकों को आकार देना चाहिए। यदि वे हमारे जैसे ही हैं, तो आप उन्हीं फाइलों का उपयोग कर सकते हैं जो हम आपको उधार देते हैं।

दोनों समर्थनों को एक 3D प्रिंटर के साथ डिज़ाइन किया गया है, जो इस प्रकार भी शामिल हैं:

ukelele_support_arduino_v0.stl: https://www.tinkercad.com/things/1aAGZ1xFptA-ukel… ukelele_support_WS2812_v0.stl:

अंत में, प्रकाश दो अंतिम चित्रों की तरह होगा।

चरण 9: गर्दन को माउंट करना

सबसे पहले हम काठी को गर्दन पर रखेंगे। शिकंजा को पकड़ने के लिए जिन छेदों की आवश्यकता होती है, वे वहां नहीं होते हैं, इसलिए हमें उन्हें बनाना होगा, यह चिन्हित करते हुए कि उन्हें कहाँ जाना चाहिए और सावधानी से, एक बरमा के साथ, छेद बनाना।

वही उन छेदों पर लागू होता है जहां शिकंजा जो गर्दन को उपकरण के शरीर पर रखता है। उन्हें करना आवश्यक नहीं है, क्योंकि इस बन्धन के लिए कोई पेंच नहीं है, लेकिन अगर हम इसे करना चाहते हैं, तो कोई समस्या नहीं होगी।

महत्वपूर्ण: मस्तूल की शुरुआत और ट्यूनिंग कांटा की शुरुआत के बीच 5 मिमी की जगह छोड़ दें, क्योंकि उस छेद में अखरोट रखा जाएगा।

हम आकृति द्वारा इंगित दिशा में अखरोट को गोंद के साथ गोंद करेंगे।

अंत में, हम 4 पिनों को उन छेदों में पेश करेंगे जो मस्तूल की शुरुआत में हैं, प्रत्येक पिन को 2 छोटे स्क्रू के साथ पकड़े हुए जैसा कि चित्र में दिखाया गया है।

चरण 10: बर्डगे को माउंट करना

पुल को ग्लूइंग द्वारा और शरीर पर एक केंद्रीय स्थिति में दो लंबे शिकंजे के साथ तय किया गया है। एक पेंसिल के साथ शरीर में सही स्थिति को चिह्नित करना उचित है। हम उन दूरियों को लेंगे जो छवि में चिह्नित हैं।

हम दो घटकों के मिलन पर गोंद लगाएंगे। जब तक जोड़ सूख नहीं जाता तब तक हम कसने वाले पेंच की मदद से दोनों हिस्सों को सावधानी से ठीक करते हैं। हम लकड़ी के लिए 1.5 मिमी ड्रिल बिट के साथ शिकंजा के लिए दो छेद बनाएंगे। शरीर में दो लंबे शिकंजे के साथ पुल को ठीक करें। और अंत में, हम शिकंजा के सिर पर सुरक्षात्मक टोपी लगाते हैं।

चरण 11: शरीर और गर्दन की विधानसभा

दो हिस्सों को इकट्ठा करने के लिए, हमारे शरीर के सिर में छेद होते हैं, जहां गर्दन दो अनुमानों के साथ फिट होगी। हम उन्हें गोंद के साथ या गर्म पिघल बंदूक के साथ गोंद कर सकते हैं। अधिक से अधिक निर्धारण करने के लिए, आप ट्यूनिंग कांटा के अंत में छेद बना सकते हैं ताकि इसे शरीर में शामिल किया जा सके।

चरण १२: गिटार के तार लगाएं

अंत में हमें तार लगाने होंगे ताकि हमारा यंत्र समाप्त हो जाए।

पहले हम इन के अनुमानों में पिन के फिक्सिंग रिंग डालेंगे जो मस्तूल से गुजरते हैं। तार लगाने के लिए हमने किट के साथ आए 4 तार लिए। पहले आपको प्रत्येक स्ट्रिंग को अलग करना होगा क्योंकि वे सभी समान नहीं हैं। आपको प्रत्येक स्ट्रिंग के एक छोर को बांधना होगा (दो मोटे वाले एक सामान्य गाँठ के साथ, और दो पतले वाले एक डबल के साथ) और स्ट्रिंग्स को पुल के स्लॉट्स में डालें।

फिर हम स्ट्रिंग्स को इस तरह से रखेंगे कि:

• पहली स्थिति: जी स्ट्रिंग (दूसरी सबसे मोटी स्ट्रिंग)।

• दूसरी स्थिति: सी स्ट्रिंग (मोटा स्ट्रिंग)।

• तीसरी स्थिति: ई स्ट्रिंग (दूसरी पतली स्ट्रिंग)।

• चौथी स्थिति: एक स्ट्रिंग (पतली स्ट्रिंग)।

दिए गए प्लग के छेद में स्ट्रिंग्स को थ्रेड करें। प्रत्येक रस्सी को पिन पर दो या तीन मोड़ देकर ठीक करने का प्रयास करें। बहुत अधिक बल लगाए बिना स्ट्रिंग्स को तनाव दें और स्ट्रिंग्स और सैडल के बीच की दूरी की जांच करें।

यदि आपको इस बारे में कोई संदेह है कि इसे कैसे बनाया जाए, तो आप उस ट्यूटोरियल को व्हाट कर सकते हैं जो आपको समझाता है कि स्ट्रिंग्स को सही तरीके से कैसे रखा जाए।

चरण 13: परीक्षण

अंत में, हमें यह देखना होगा कि क्या गिटार को इस तरह से ठीक से इकट्ठा किया गया है कि पहले झल्लाहट पर आदर्श दूरी 0.1 मिमी है और बारहवीं पर यह लगभग 1.2 मिमी है।

यह आवश्यक है कि आप गिटार के तारों को ट्यून करें। मैं आपको इस ऐप की अनुशंसा करता हूं: गिटार टूना

चरण 14: इसका आनंद लें

अब, आपको केवल अपने गिटार का आनंद लेना है।

यदि आप हमारे बारे में अधिक जानकारी जानना चाहते हैं, तो आप हमें इसमें ढूंढ सकते हैं:

ट्विटर: @Innovart_cc

फेसबुक: @Innovartcc

इंस्टाग्राम: @Innovart_cc

वेब: Innovart.cc