Arduino डामर के साथ संतुलन खेल।

Arduino सहायक के साथ संतुलन खेल: 9 कदम (चित्रों के साथ)

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

अच्छा Arduino बिट्स का भार ...

  • ड्राइविंग सर्वो।
  • एनालॉग लिखें एलईडी फीका करने के लिए।
  • बटन के माध्यम से डिजिटल इनपुट।
  • WS2812 एलईडी की एक सरणी ड्राइविंग।
  • रैंडम नंबर।

आपूर्ति:

चरण 1: लकड़ी का निर्माण।

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

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

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

चरण 2: बिट्स टूगेदर, और बिट ऑफ़ पेंटिंग।

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

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

चित्र।

जब मैं क्रिसमस की खरीदारी कर रहा था तब मुझे पेंट के लिए एक लुक दिया गया था, और पहली बार में कुछ छोटे ट्यूब 1.99 पाउंड में मिले, लेकिन जब तक मैं 1 पाउंड के लिए टेस्टर पॉट देख रहा था, तब तक मैंने यही चुना। और मुझे लगता है कि पेंट बहुत अच्छा था क्योंकि यह अच्छी तरह से कवर किया गया था और टिकाऊ लगता है। इसके अलावा इसकी एक नई शैली घरेलू पेंट की गंध नहीं थी और इसे पानी से धोया जा सकता था इसलिए यह मेरी छोटी लड़की के लिए मदद करने के लिए एकदम सही था। मैं शायद बिट्स की संख्या के साथ ओवरबोर्ड चला गया और चित्रित किया गया था, लेकिन एक बार मैंने देखा था कि इसे स्थापित करना सिर्फ उन्हें जल्दी से काटने का मामला था।

दो व्यास 18 मिमी और 28 मिमी। 40 मिमी और 20 मिमी की दो अलग-अलग लंबाई में कटौती

डॉवल्स को इस प्रकार काटा गया।

28 मिमी दीया * 40 मिमी लंबे 2 प्रत्येक 4 खिलाड़ियों और 4 जोकरों में से प्रत्येक के लिए प्रत्येक रंग। कुल 36।

28 मिमी दीया * प्रत्येक 4 खिलाड़ियों में से प्रत्येक के लिए 20 मिमी लंबा 1 रंग। कुल 16।

4 मिमी में से प्रत्येक के लिए प्रत्येक रंग से 18 मिमी व्यास * 40 मिमी लंबा 1। कुल 16।

18 मिमी दीया * प्रत्येक 4 खिलाड़ियों में से प्रत्येक के लिए 20 मिमी लंबा 1 रंग। कुल 16।

चरण 3: इलेक्ट्रॉनिक्स बिल्ड।

मुझे Arduino Nano (या क्लोन!) का उपयोग करना अच्छा लगता है और इसे बहुत ही कम मात्रा में खरीदा जा सकता है। लागत इतनी सस्ती है कि मैं सोल्डर पिंस के लिए खुश हूं जहां मैं उन्हें चाहता हूं और फिर से बोर्ड का पुन: उपयोग नहीं करने के बारे में चिंता करने की ज़रूरत नहीं है! (eBay से £ 2.00 से कम या यदि आप अधिक भुगतान करना चाहते हैं, तो आप उन्हें £ 19.99 के लिए "उच्च सड़क पर" पा सकते हैं!) मुझे बिना हेडर के बोर्ड मिलाए गए हैं और एक और यूएसबी लीड प्राप्त करने से बचने की कोशिश करें!

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

नैनो में मैंने हेडर को सिर्फ उस पिन से जोड़ा, जिसका मैं उपयोग करना चाहता था। ये इस प्रकार हैं।

डी 2 सर्वो 1 (आउटपुट)

डी 3 सर्वो 2 (आउटपुट)

D4 सर्वो 3 (आउटपुट)

D5 शेक एलईडी (PWM एनालॉग आउटपुट)

D6 रोल एलईडी (PWM एनालॉग आउटपुट)

D7 शेक बटन (डिजिटल इनपुट)

D8 रोल बटन (डिजिटल इनपुट)

WS912 LED के D9 एलईडी सर्कल 16 सरणी

पावर के लिए मैंने सर्वोस को पावर देने के लिए एक यूबीईसी का इस्तेमाल किया। सबसे पहले मैंने कवर को छीन लिया और इनपुट और आउटपुट तारों को हटा दिया। फिर मैंने इनपुट पर डीन प्लग के साथ तारों को जोड़ा और आउटपुट (या तो 5 या 6 वोल्ट) था, जहां मैंने 3 लाल और 3 काले तारों को इमदादी एक्सटेंशन केबलों से जोड़ा था, 3 सफेद तारों को सर्वो से 3 तरह से जोड़ा गया था प्लग। अन्त में UBEC से मूल आउटपुट तार को UBEC के इनपुट पक्ष से जोड़ने और नैनो को LIPO वोल्टेज के साथ Vin और GND को आपूर्ति करने के लिए पुन: उपयोग किया गया। मैंने इसे इस तरह से किया है कि यूबीईसी को 6 वोल्ट देने के लिए सेट किया जा सकता है, इसलिए विन को एक उच्च वोल्टेज की आपूर्ति करना सुरक्षित है और यूबीईसी (आउटपुट) को 5 वोल्ट पिन पर सीधे कनेक्ट नहीं करना है और मुझे उम्मीद है कि UBEC को कभी 6 वोल्ट पर सेट न करें?

चरण 4: कार्यक्रम भाग 1! बटन इनपुट और एलईडी (PWM)

बटन के लिए बेसिक बटन इनपुट और एनालॉग आउटपुट।

जब मैं कुछ इस तरह का निर्माण करता हूं तो मुझे इस परियोजना को थोड़े से हिस्सों में तोड़ना पसंद होता है और प्रत्येक को एक समय में काम करने में मदद मिलती है।

इसलिए बटन शुरू करने के लिए एक आसान जगह है।

const int / * यह बहुत कम करने के लिए एक बहुत लंबा कार्यक्रम है! यह मूल रूप से * रोल बटन एलईडी को पल्स करते हुए रोल बटन को पढ़ता है, * बटन दबाए जाने के बाद, शेक बटन पल्स करना शुरू कर देता है, * फिर से जब आप शेक बटन दबाते हैं तो यह रोल पर वापस स्वैप हो जाता है * / const int LEDRoll - 6; const int LEDShake = 5; const int BUTTONShake = 7; const int BUTTONRoll = 8; int चमक = 20; int fadeAmount = 1; शून्य सेटअप () // परिभाषित करें कि कौन से बटन और एलईडी किस पिन में जाते हैं। {पिनमोड (LEDRoll, OUTPUT); // LED को PWM पर पिनकोड (LEDShake, OUTPUT) पर जाने की जरूरत है; // काम करने के लिए फीका करने की अनुमति दें (analogWrite) pinMode (BUTTONShake, INPUT); पिनमोड (BUTTONRoll, INPUT); TIMSK0 = 0; // T / C 0 इंटरप्ट बंद करें (सर्वो जिटर बंद हो जाता है)} शून्य लूप () {readButtons (BUTTONRoll, LEDRoll); // कॉल रीडबटन फक्शन रॉएल पहले रीडबटन (बटनटन, एलईडीशेक); } void readButtons (int बटन, int LED) // ऊपर से रोल के साथ शुरू करके {int दबाया = digitalRead (Button); // वांछित बटन को पढ़ें, जबकि (दबाया == 0) // लूप को दबाए जाने तक और निम्न करें {दबाया = digitalRr (बटन); // बटन को फिर से पढ़ें fade_LED (LED); // LED विलम्बित विलंबित L2 (8000) ; // फीका काम करने के लिए देरी जोड़ें, 8000 अच्छी तरह से काम करता है। } analogWrite (LED, 0); // एक बार बटन दबाने पर LED की बारी आती है} void fade_LED (int चुने गए) // उदाहरणों से कॉपी की जाती है! (उदाहरण / मूल बातें / फीका) {एनालॉगवर्इट (चुना गया, चमक); चमक = चमक + फीकाअमाउंट; अगर (चमक <= 10 || चमक> = 200) // वांछित फीका पाने के लिए vaules बदलें {fadeAmount = -fadeAmount; }} // नीचे देरी दिनचर्या का उपयोग किया जाता है क्योंकि मैं देरी () कमांड का उपयोग कर सकता हूं। void delay02 (अहस्ताक्षरित int गुणक) // मैक्सिमम संख्या 65535 {के लिए (अहस्ताक्षरित T = 0; T <गुणक; T = T + 1) {__asm ​​__ ("nop n" t "); // कुछ नहीं, एक घड़ी चक्र बर्बाद? }}

चरण 5: कार्यक्रम भाग 2! WS2812 एलईडी ऐरे ड्राइविंग

WS2812 एलईडी सरणी ड्राइविंग।

मैंने अलग-अलग प्रभावों का इस्तेमाल किया है। सबसे पहले मैं 4 रंगों को रोल करता हूं।

/ * 4 रंगों को घुमाने का पहला कार्यक्रम। * यहाँ वास्तव में कुछ भी नहीं फैंसी! * अंतिम कार्यक्रम में मैंने प्रदर्शन को तेज करने के लिए एक लूप में देरी को कम कर दिया * तेजी से, फिर थोड़ी देर के लिए एक तेज स्पिन में फिर से प्रदर्शन किया। * फिर एक ठोस रंग प्रदर्शित किया। * / # ईमानदारी Adafruit_NeoPixel स्ट्रिप = Adafruit_NeoPixel (16, 9, NEO_GRB + NEO_KHZ800); uint32_t ब्लू = स्ट्रिप.कोलर (0,0,50); // रंगों को परिभाषित करें uint32_t ग्रीन = स्ट्रिप.कोलर (0,50,0); uint32_t रेड = स्ट्रिप.कोलर (50,0,0); uint32_t येलो = स्ट्रिप.कोलर (40,40,0); int i = 0; शून्य सेटअप () {पट्टी.begin (); कपड़े उतारने का प्रदर्शन(); TIMSK0 = 0; // T / C 0 इंटरप्ट बंद करें (सर्वो जिटर बंद हो जाता है)} शून्य लूप () {रोलडाइस (); } void रोलडाइस () {के लिए (int k = 0; k <4; k = k + 1) // 4 को पीले की एक पंक्ति में सेट करें {strip.setPixelColor (i, Yellow); // सेट टू येलो टेस्ट (); ; // चेक करें कि क्या आपने 16 एलईडी का} (int k = 0; k <4; k = k + 1) // को अगले 4 पर सेट करके लाल {पट्टी.setPixelColor (i, Red); 0 परीक्षण (); // जांच करें कि क्या आपने 16 LED का} (int k = 0; k <चक्र? K = k + 1) // को ओवरफ्लो किया है, अगली 4 पंक्ति में हरे {पट्टी.setPixelColor (i, Green) के लिए सेट करें ), // 0 परीक्षण (); // जांचें कि क्या आपने 16 एलईडी का} (int k = 0; k <4; k = k + 1) के लिए ओवरफ्लो किया था, अगली 4 पंक्ति में नीले {पट्टी.setPixelColor पर सेट करें (i, नीला); // 0 परीक्षण (); // जांचें कि क्या आपने 16 एलईडी के} स्ट्रिप.शो (), // को डिस्प्ले टेस्ट में अपडेट किया है (); // चेक करें कि क्या आपने 16 एलईडी का ओवरफ्लो किया है और कोई अन्य जोड़ें प्रदर्शन में देरी करने के लिए देरी ०२ (६५०००); // देरी की एक जोड़ी को जोड़ने में देरी ०२ (६५०००) को धीमा कर देती है; } void delay02 (अहस्ताक्षरित int गुणक) // अधिकतम संख्या 65535 {के लिए (अहस्ताक्षरित T = 0; T <गुणक; T = T + 1) {__asm ​​__ ("nop's n t") है; // कुछ नहीं, एक घड़ी चक्र बर्बाद? }} शून्य परीक्षण () // इसका उपयोग यह जांचने के लिए किया जाता है कि क्या आप 16 वीं एलईडी सेट करने के लिए उपस्थित हो रहे हैं! {i = i + 1; अगर (i> 15) {i = 0; // पहली एलईडी शून्य है अंतिम 15 है ...}

अगले मैं एक यादृच्छिक ताकत का अनुकरण करने के लिए प्रदर्शन को ऊपर और नीचे रैंप करें

/ * एलईडी के रिंग के ऊपर और नीचे जाने का दूसरा कार्यक्रम। * यहाँ वास्तव में कुछ भी नहीं फैंसी! केवल एक रंग चुना। * अंतिम कार्यक्रम में मैंने पैटर्न को एक-दो बार किया था * यादृच्छिक शक्ति दिखाने के लिए एलईडी रिंग में गया। * / # ईमानदारी Adafruit_NeoPixel स्ट्रिप = Adafruit_NeoPixel (16, 9, NEO_GRB + NEO_KHZ800); uint32_t ब्लू = स्ट्रिप.कोलर (0,0,50); // रंगों को परिभाषित करें uint32_t ग्रीन = स्ट्रिप.कोलर (0,50,0); uint32_t रेड = स्ट्रिप.कोलर (50,0,0); uint32_t येलो = स्ट्रिप.कोलर (40,40,0); int i = 0; शून्य सेटअप () {पट्टी.begin (); कपड़े उतारने का प्रदर्शन(); TIMSK0 = 0; // T / C 0 इंटरप्ट बंद करें (सर्वो जिटर बंद हो जाता है)} शून्य लूप () {selectIntensity (); } शून्य चयनात्मकता () {के लिए (int X = 16; X> 0; X = X - 1) {strip.setPixelColor (X, 0); कपड़े उतारने का प्रदर्शन(); delay02 (60000); } के लिए (इंट एक्स = 0; एक्स <16; एक्स = एक्स + 1) {स्ट्रिप.सेटपिक्सेलकोलर (एक्स, ग्रीन); कपड़े उतारने का प्रदर्शन(); delay02 (60000); }} void delay02 (अहस्ताक्षरित int गुणक) // मैक्सिमन संख्या 65535 {(अहस्ताक्षरित int T = 0; T <गुणक; T = T + 1) {__asm ​​__ ("nop's n t") है; // कुछ नहीं, एक घड़ी चक्र बर्बाद? }}

चरण 6: कार्यक्रम भाग 3! रैंडम नंबर (ODDS के साथ)

इसलिए मुझे इस बात का अहसास हुआ कि सिर्फ रैंडम नंबर 1-16 लेने से काम नहीं चलने वाला। 9 से अधिक की संख्या के कारण बहुत सारे टुकड़े गिर गए, इसलिए मुझे उच्च संख्या को सीमित करने की आवश्यकता थी। इसलिए इसे प्राप्त करने के लिए मैंने इसमें 99 नंबर के साथ एक स्ट्रिंग बनाई, और फिर 99 तक एक यादृच्छिक संख्या को चुना और फिर उस नंबर को स्ट्रिंग से उठाया। इसका मतलब यह है कि मैं कितनी बार एक संख्या स्ट्रिंग में प्रकट होता है और इसलिए इसे लेने की संभावना को सीमित कर सकते हैं।

int randomNumber [] = {११,१,१,२,२,२,३,३,३,३,३,१,१,१,१,२,२,२,३,३, ३, 3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7,8,8,9,9,10,10,11,12,13, 14,15,16,15,14,13,12,11,10,10,9,9,8,8,7,7,6,6,6,6,5,5,5,5,4, 4,4,4,1,1,1,1,2,2,2,2,3,3,3,3,3,3,3,3,2,2,2,2,1,1, 1,1};

ODDS इस प्रकार हैं

1-2-3 = 16%

4-5-6 = 8%

7-8-9-10 = 4%

11-12-13-14-15 = 2%

16 = 1%

मुझे उम्मीद है कि इसका कोई अर्थ है। जोड़ने के लिए केवल दूसरा बिट है, जिसका उपयोग "randomSeed (analogRead (3))"; " यादृच्छिकता में सहायता करने के लिए!

चरण 7: कार्यक्रम भाग 4. सर्वो ड्राइविंग और एसआईएन पैटर्न

/ * सर्वोस को चलाने के लिए यह दिनचर्या है * प्रत्येक सर्वो एक पाप तरंग पैटर्न में ड्राइव करता है, लेकिन 120 से अलग हो जाता है। * यह एक घूर्णन पैटर्न देता है। * यदि आप चाहते थे कि पैटर्न केवल दूसरी दिशा में घूमने के लिए बदले * पाप दिनचर्या में "राशियों" का क्रम * / const int servoOne = 2; const int servoTwo = 3; const int servoThree = 4; const int ऑफसेट 1 = 1552; const int ऑफसेट 2 = 1490; const int ऑफसेट 3 = 1538; फ्लोट राशि 1 = 1552; फ्लोट अमाउंट 2 = 1490; फ्लोट राशि 3 = 1538; शून्य सेटअप () {pinMode (इमदादी, बाहर); पिनमोड (सर्वो, ओउटपुत); पिनमोड (सर्वोट्री, आउटपूट); TIMSK0 = 0; // T / C 0 इंटरप्ट बंद करें (सर्वो जिटर बंद हो जाता है)} शून्य लूप () {sinRotate (120); } void sinRotate (int R) // R पाप तरंग का आयाम है {for (float y = 0.0; y <12.566; y = y + 0.005) //12.566 को 4 चक्र देने के लिए चुना {float a = y; ए = पाप (ए) * आर; मात्रा 1 = ए + ऑफसेट 1; ए = वाई + 2.094395; ए = पाप (ए) * आर; अमूर्त 2 = ए + ऑफसेट 2; // राशि 2 को राशि 3 में बदलकर ए = वाई + 4.18879 रिवर्स करने के लिए; ए = पाप (ए) * आर; राशि 3 = ए + ऑफसेट 3; }} शून्य servoOutput () {digitalWrite (सर्वो, उच्च); delayMicroseconds (Amount1); digitalWrite (इमदादी, कम); digitalWrite (सर्वो, उच्च); delayMicroseconds (AMOUNT2); digitalWrite (सर्वो, एलओडब्ल्यू); digitalWrite (सर्वो, हाई); delayMicroseconds (Amount3); digitalWrite (सर्वो, LOW); }

चरण 8: खेल चालू है!

  1. सभी खिलाड़ियों को रंगीन टुकड़े दें।
  2. पहले खिलाड़ियों ने ग्रीन रोल बटन दबाया।
  3. एक यादृच्छिक रंग चुना जाता है और एक यादृच्छिक शक्ति।
  4. खिलाड़ी को पेड़ में सही रंग का मसाला डालना चाहिए।
  5. यदि खिलाड़ी को सही रंग नहीं मिला है, तो वह फिर से रोल बटन दबाकर गुजरता है।
  6. अगर खिलाड़ी पास करना चाहता है क्योंकि ताकत बहुत अधिक है तो वह ऐसा कर सकता है।
  7. एक बार जब खिलाड़ी ने सही बिट जोड़ दिया तो वह पेड़ को स्थानांतरित करने के लिए रेड शेक बटन दबाता है।
  8. अगर कोई बिट्स गिर जाता है तो खिलाड़ी को उन्हें ले जाना पड़ता है।
  9. रोल बटन दबाने वाले अगले व्यक्ति के साथ खेलना जारी है।
  10. विजेता वह खिलाड़ी होता है जो पहले अपने सभी बिट्स से छुटकारा पाता है।

चरण 9: सर्वो घबराना। (इसे कैसे हल करें)

  1. सबसे पहले आपको यह समझना चाहिए कि एक Arduino नैनो या Uno में विशाल मात्रा में बिजली नहीं होती है, इसलिए जब तक आप छोटे धीमे सर्वो का उपयोग नहीं करते हैं तब तक आपको अपने स्वयं के आपूर्ति के साथ सर्वो की आपूर्ति करने की आवश्यकता होगी, यही कारण है कि मैंने यूबीईसी का उपयोग किया है।
  2. जबकि सर्वोस को हर 20 मिलीसेकंड में एक पल्स भेजा जाना चाहिए, वास्तव में एक बार जब इमदाद की स्थिति होती है तो यह तब भी रहेगा जब इसे कोई और दाल नहीं मिलती है। यह भी इंगित करने योग्य है कि सर्वो हर 20mS की तुलना में तेजी से एक पल्स प्राप्त करने के लिए खुश हैं। इसलिए यदि आप चाहते हैं कि आप पल्स को इमदाद प्राप्त करने के लिए पोज़िशन भेजें तो न भेजें और न ही तब तक जब तक आप फिर से चलना न चाहें।
  3. मेरे मामले में मैंने समाधान के लिए इंटरनेट की ओर रुख करने से पहले कई चीजों की कोशिश की। मूल रूप से आपको निम्न कमांड "TIMSK0 = 0" का उपयोग करके टाइमर / काउंटर वन (T / C-0) की रुकावट सुविधा को अक्षम करना होगा। यह T / C-0 द्वारा उत्पन्न तीन व्यवधान को बंद कर देता है। मुझे पूरा कारण समझ में नहीं आता है कि यह क्यों काम करता है लेकिन इंटरनेट पर पढ़ने से लेकर Arduino सॉफ्टवेयर समय के लिए T / C-0 का उपयोग करता है? इसका मतलब यह है कि T / C-0 पृष्ठभूमि में चल रहा है और समय के प्रयोजनों के लिए व्यवधान उत्पन्न कर रहा है। यह अन्य मुद्दों का कारण बनता है लेकिन उन्हें दूर करने के लिए मुश्किल नहीं है। मूल रूप से आप मिलिस () / माइक्रो () / देरी () स्टेटमेंट और अन्य कार्यों का उपयोग नहीं कर सकते हैं जो कि टी / सी -०० पर निर्भर करते हैं जो मेरा मानना ​​है कि यह सीरियल भी है। शुक्र है कि मैंने देरीमाइक्रोसेकंड का उपयोग किया है जो देरी करने के लिए प्रोसेसर चक्र का उपयोग करता है।
  4. यह आपके ऊपर है कि आप अपने सर्वोस को चलाने के लिए किस कोड का उपयोग करते हैं, मैं हमेशा देरी करने के लिए उपयोग करता हूं। लेकिन आप सर्वो पुस्तकालय का भी उपयोग कर सकते हैं। जब मुझे झटके की समस्या थी तो मैंने सर्वो लाइब्रेरी की कोशिश की और इससे कोई फर्क नहीं पड़ा।

कार्यक्रम के लिए कृपया नीचे देखें जैसा कि उपरोक्त वीडियो में है।

const int servoOne = 2; const int BUTTONShake = 7; const int BUTTONRoll = 8; फ्लोट राशि 1 = 1500; शून्य सेटअप () {pinMode (इमदादी, बाहर); pinMode (6, आउटपुट); पिनमोड (बट्टनशेक, INPUT); पिनमोड (BUTTONRoll, INPUT); TIMSK0 = 0; // T / C 0 इंटरप्ट बंद करें (सर्वो जिटर बंद हो जाता है)} शून्य लूप () {servoOutput (); int up = digitalRead (BUTTONShake); if (अप == 1) {अमाउंट 1 = अमाउंट 1 + 1; } int down = digitalRead (BUTTONRoll); if (डाउन == 1) {अमाउंट १ = अमाउंट १ - १; } देरी ०२ (४००००- (२ * अमाउंट १)); } शून्य सर्वऑउटपुट () {digitalWrite (6, उच्च); digitalWrite (सर्वो, उच्च); delayMicroseconds (Amount1); digitalWrite (6, LOW); digitalWrite (इमदादी, कम); } void delay02 (अहस्ताक्षरित int गुणक) // अधिकतम संख्या 65535 {के लिए (अहस्ताक्षरित T = 0; T <गुणक; T = T + 1) {__asm ​​__ ("nop's n t") है; // कुछ नहीं, एक घड़ी चक्र बर्बाद? }}