Arduino में एक मेनू, और बटन का उपयोग कैसे करें: 10 कदम (चित्रों के साथ)

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

मेरे Arduino 101 ट्यूटोरियल में, आपको सिखाया जाएगा कि अपने वातावरण को Tinkercad में कैसे सेटअप किया जाए। मैं टिंकरकाड का उपयोग करता हूं क्योंकि यह एक बहुत शक्तिशाली ऑनलाइन प्लेटफॉर्म है जो मुझे सर्किट बनाने के लिए छात्रों को कई प्रकार के कौशल का प्रदर्शन करने की अनुमति देता है। Arduino IDE और एक वास्तविक Arduino का उपयोग करके मेरे सभी ट्यूटोरियल बनाने के लिए स्वतंत्र महसूस करें!

इस ट्यूटोरियल में, हम बटन के बारे में जानेंगे! हमें पता करने की जरूरत है:

• उन्हें कैसे तार-तार करें
• उनका मूल्य पढ़ना
• बहस, और यह क्यों महत्वपूर्ण है
• एक व्यावहारिक अनुप्रयोग (एक मेनू बनाना)

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

तैयार? आएँ शुरू करें!

चरण 1: बोर्ड सेट करें

पहला कदम एक Arduino और Breadboard Small को प्रोटोटाइप क्षेत्र पर रखना है। पावर रेल को वायर करने का तरीका देखने के लिए ऊपर दी गई छवियों की जाँच करें।

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

जब आप शक्ति जोड़ते हैं, तो काले और लाल तारों का उपयोग क्रमशः ऋणात्मक और धनात्मक में करें। अंत में तार जोड़ें जो बोर्ड के दूसरी तरफ बिजली चलाते हैं। हम उस पक्ष का उपयोग नहीं करेंगे, लेकिन यह अच्छा अभ्यास है।

चरण 2: बटन और रोकनेवाला जोड़ें

कंपोनेंट्स ट्रे से एक छोटा पुशबटन जोड़ें। यह छवि में जैसा दिखना चाहिए। सुनिश्चित करें कि यह एक स्विच नहीं है! एक रोकनेवाला भी जोड़ें। इसे क्लिक करें, और इसका मान 10kΩ पर सेट करें। यह कनेक्ट नहीं होने पर पिन को कम खींचने के लिए पर्याप्त है, जो बाद में कोड में बहुत महत्वपूर्ण है।

घटक को ब्रेडबोर्ड के बीच में रखें। जिस तरह से एक बटन काम करता है वह है:

• कोने से कोने तक, बटन जुड़ा नहीं है। बटन दबाने से संपर्क बंद हो जाते हैं और कोने जुड़ जाते हैं।
• बटन के किनारे जुड़े हुए हैं। यदि आप एक तार को ऊपर बाईं ओर और नीचे बाईं ओर जोड़ते हैं, तो सर्किट बंद हो जाएगा।

यही कारण है कि हम कंपोनेंट को बीच में पूरे स्पेस में रखते हैं। यह सुनिश्चित करता है कि बोर्ड में पिन के नीचे कोने जुड़े नहीं हैं।

अगला चरण कुछ चित्र प्रदान करता है जो इन बिंदुओं को दर्शाता है।

रोकनेवाला को निचले दाएं पिन से स्तंभों पर रखें, ताकि वह क्षैतिज रूप से बैठे।

चरण 3: बटन कनेक्शन

ऊपर दिए गए चित्र यह स्पष्ट रूप से स्पष्ट करते हैं कि बटन कैसे जुड़ते हैं। यह हमेशा भ्रम की स्थिति थी जब आपको लगता है कि कुछ अच्छा है और यह काम नहीं करता है!

अब, तारों को जोड़ते हैं।

• एक सकारात्मक पावर पिन से लाल लीड को बटन पर नीचे दाएं पिन के समान कॉलम में रखें
• एक नकारात्मक शक्ति पिन से एक ब्लैक लीड को रोकनेवाला के समान कॉलम में रखें।
• Arduino पर डिजिटल पिन 2 के ऊपरी बाएँ पिन से एक रंगीन तार (लाल/काला नहीं) रखें

यह सुनिश्चित करने के लिए कि आपकी वायरिंग सही है, ऊपर दी गई छवियों की जाँच करें।

चरण 4: कोड …

आइए एक बुनियादी बटन के लिए कोड पर एक नजर डालते हैं।

कोड संपादक खोलें और ब्लॉक से टेक्स्ट में बदलें। आने वाली चेतावनी को साफ़ करें। हम पाठ से खुश हैं!

आप मूल सेटअप जानते हैं, तो चलिए बटन को परिभाषित करते हैं और एक बुनियादी रीड करते हैं। हम आउटपुट को सीरियल में प्रिंट करेंगे।

मैंने नीचे दिए गए कोड में कुछ अतिरिक्त टिप्पणियां डाली हैं ताकि छवि की तुलना में इसे पढ़ना आसान हो।

// स्थिरांक परिभाषित करें

# परिभाषित करें बटन 2 शून्य सेटअप () {पिनमोड (बटन, इनपुट); सीरियल.बेगिन (९६००); } शून्य लूप () {// बटन की स्थिति की जांच करने के लिए डिजिटल पिन पढ़ें int दबाया = digitalRead (बटन); // बटन दबाए जाने पर उच्च लौटाता है, यदि नहीं तो कम (दबाया गया == उच्च) {Serial.println ("दबाया!"); } }

ठीक है, यह काम करता है!

अनिवार्य रूप से, हम हर बार कोड लूप होने पर डिजिटल पिन की स्थिति की जांच कर रहे हैं। यदि आप स्टार्ट सिम्युलेशन पर क्लिक करते हैं और बटन दबाते हैं, तो आप सीरियल मॉनिटर (कोड के नीचे दिए गए बटन पर क्लिक करें) को "दबाया!" प्रदर्शित करेंगे। बार-बार।

उपरोक्त कोड में आपको एक विशेषता दिखाई देगी यदि () स्थिति मूल्यांकन हो रहा है। इस मामले में सभी कोड एक प्रश्न पूछ रहे हैं और मूल्यांकन कर रहे हैं कि क्या यह सच है। हम बराबर है (दोहरे बराबर चिह्न, इस तरह: ==) का उपयोग यह जांचने के लिए करते हैं कि चर का मान एक निश्चित मान के बराबर है या नहीं। एक digitalRead() उच्च या निम्न देता है।

if() और if/el का उपयोग करके हम कई शर्तों या सभी शर्तों की जांच कर सकते हैं, और यदि आप Arduino Basics पर वापस जाते हैं, तो आप कुछ तुलनाओं को देखेंगे जो आप कर सकते हैं।

अब… हमारा कोड पूरा दिख सकता है… लेकिन हमें एक समस्या है।

देखें, सिम्युलेटर में यह वास्तव में अच्छा काम करता है। लेकिन वास्तविक बिजली में शोर होता है, खासकर डीसी इलेक्ट्रॉनिक्स। तो हमारा बटन कभी-कभी गलत रीडिंग लौटा सकता है। और यह एक समस्या है, क्योंकि हो सकता है कि आपका प्रोजेक्ट उपयोगकर्ता के लिए सही तरीके से प्रतिक्रिया न दे।

चलो इसे ठीक करें!

चरण 5: एक छोटी सी बहस

हम अपनी बटन समस्या को दूर करने के लिए debounce नामक एक प्रक्रिया का उपयोग करते हैं। यह अनिवार्य रूप से एक निर्दिष्ट समय की प्रतीक्षा करता है जब बटन को धक्का दिया गया था और वास्तव में पुश का जवाब दे रहा था। यह अभी भी उपयोगकर्ता के लिए स्वाभाविक लगता है (जब तक कि आप समय को बहुत लंबा न कर दें)। आप इसका उपयोग प्रेस की लंबाई की जांच के लिए भी कर सकते हैं, ताकि आप हर बार अलग-अलग प्रतिक्रिया दे सकें। आपको किसी भी वायरिंग को बदलने की आवश्यकता नहीं है!

आइए कोड देखें:

#डिफाइन बटन 2#डेब्यू को परिभाषित करेंटाइमआउट 100

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

लांग इंट लास्टडेब्यून्सटाइम;

यह चर स्थिरांक के नीचे घोषित किया गया है। यह एक long int प्रकार है, जो मूल रूप से हमें स्मृति में लंबी संख्याओं को संग्रहीत करने की अनुमति देता है। हमने इसे lastDebounceTime कहा।

हमें शून्य सेटअप () फ़ंक्शन में कुछ भी बदलने की आवश्यकता नहीं है। चलो उसी को छोड़ दें।

शून्य लूप () {// बटन की स्थिति की जांच करने के लिए डिजिटल पिन पढ़ें int दबाया = digitalRead (बटन); लॉन्ग इंट करंटटाइम = मिली (); // बटन कोड }

लूप () फ़ंक्शन में हम जो पहला बदलाव करते हैं, वह बटन को पढ़ने के लिए कॉल के अंतर्गत होता है। हमें वर्तमान समय का ध्यान रखना चाहिए। मिलिस () फ़ंक्शन घड़ी का वर्तमान समय लौटाता है क्योंकि Arduino मिलीसेकंड में बूट होता है। हमें इसे एक लंबे इंट टाइप वेरिएबल में स्टोर करने की जरूरत है।

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

शून्य लूप () {// बटन की स्थिति की जांच करने के लिए डिजिटल पिन पढ़ें int दबाया = digitalRead (बटन); लॉन्ग इंट करंटटाइम = मिली (); अगर (दबाया गया == कम) {// बटन दबाए जाने पर गिनती समय रीसेट करें lastDebounceTime = currentTime; } // बटन कोड }

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

शून्य लूप () {// बटन की स्थिति की जांच करने के लिए डिजिटल पिन पढ़ें int दबाया = digitalRead (बटन); लॉन्ग इंट करंटटाइम = मिली (); अगर (दबाया गया == कम) {// बटन दबाए जाने पर गिनती समय रीसेट करें lastDebounceTime = currentTime;) Serial.println ("दबाया!"); } }

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

अपना कोड चलाएं और जांचें कि यह काम करता है। यदि आपको त्रुटियां हैं, तो अपना कोड जांचें!

अब, आइए एक व्यावहारिक उदाहरण देखें।

चरण 6: एक मेनू बनाना

बटन दिलचस्प हैं, क्योंकि उनके साथ बहुत सारी संभावनाएं हैं! इस उदाहरण में, हम एक मेनू बनाने जा रहे हैं। मान लें कि आपने यह वास्तव में शानदार उपकरण बनाया है, और उपयोगकर्ताओं को कुछ चीजों को चालू या बंद करने के लिए विकल्प बदलने में सक्षम होना चाहिए, या किसी सेटिंग के लिए कोई विशेष मान सेट करना चाहिए। यह तीन बटन डिजाइन ऐसा कर सकता है!

तो, इस परियोजना के लिए हमें चाहिए:

• तीन बटन
• तीन प्रतिरोधक 10kΩ. पर सेट हैं

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

तीन बटन एक मेनू खुला/अगला विकल्प, एक परिवर्तन विकल्प (जैसा कि, सेटिंग बदलें), और एक सहेजें/बंद मेनू बटन हैं।

इसे तार दें, आइए कोड देखें!

चरण 7: कोड ब्रेकडाउन - ग्लोबल

ठीक है, यह एक लंबा कदम होने जा रहा है, लेकिन मैं कोड के प्रत्येक खंड से गुजरने जा रहा हूं।

सबसे पहले, आइए आवश्यक वैश्विक चरों को देखें।

// स्थिरांक को परिभाषित करें#मेनू को परिभाषित करेंबटन 2 #मेन्यू को परिभाषित करें3#परिभाषित करेंमेनू को परिभाषित करें4 #डिफाइन डेबॉन्सटाइमआउट 50 // वैरिएबल को परिभाषित करें इंट मेन्यूबटनपिछलास्टेट = कम; int मेनू चयन करें पिछलास्टेट = कम; int मेनूसेवपिछलास्टेट = कम; लांग इंट लास्टडेब्यून्सटाइम; // मेनू विकल्प चार * मेनू विकल्प = {"अस्थायी जांचें", "लाइट की जांच करें"}; बूल फीचरसेटिंग = {झूठा, झूठा}; बूल मेनूमोड = झूठा; बूल मेनूनीड्सप्रिंट = झूठा; int विकल्प चयनित = 0;

ये तीन ब्लॉक काफी हद तक वैसा ही है जैसा हमने पहले देखा है। पहले में, मैंने तीन बटन और टाइमआउट को परिभाषित किया है। परियोजना के इस भाग के लिए, मैंने इसे 50ms पर सेट किया है, इसलिए इसे काम करने के लिए एक जानबूझकर प्रेस की आवश्यकता होती है।

दूसरा ब्लॉक सभी चर है। हमें ButtonPreviousState का ट्रैक रखने की आवश्यकता है, और हमें lastDebounceTime का ट्रैक रखने की आवश्यकता है। ये सभी int प्रकार के चर हैं, लेकिन अंतिम एक लंबा प्रकार है क्योंकि मुझे लगता है कि हमें स्मृति में स्थान की आवश्यकता है।

मेनू विकल्प ब्लॉक में कुछ नई विशेषताएं हैं। सबसे पहले, चार * (हाँ, यह एक जानबूझकर तारांकन है), जो एक वर्ण/स्ट्रिंग शाब्दिक चर है। यह स्मृति में स्थिर भंडारण के लिए एक सूचक है। आप इसे बदल नहीं सकते (जैसे आप पायथन में कर सकते हैं, उदाहरण के लिए)। यह char *menuOptions लाइन स्ट्रिंग अक्षर की एक सरणी बनाता है। आप जितने चाहें उतने मेनू आइटम जोड़ सकते हैं।

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

मैंने मेन्यूमोड का ट्रैक रखा है, इसलिए अगर मुझे अपने डिस्प्ले पर अन्य चीजें चाहिए तो मैं ऐसा कर सकता था। इसके अलावा, अगर मेरे पास सेंसर लॉजिक होता तो मैं मेनू ऑपरेशन के दौरान उसे रोक सकता था, बस कुछ विरोध होने पर। मेरे पास एक menuNeedsPrint चर है क्योंकि मैं मेनू को विशिष्ट समय पर प्रिंट करना चाहता हूं, न कि केवल हर समय। अंत में, मेरे पास एक विकल्प चयनित चर है, इसलिए मैं चयनित विकल्प का ट्रैक रख सकता हूं क्योंकि मैं इसे कई स्थानों पर एक्सेस करता हूं।

आइए कार्यों के अगले सेट को देखें।

चरण 8: कोड ब्रेकडाउन - सेटअप और कस्टम फ़ंक्शंस

सेटअप () फ़ंक्शन काफी आसान है, केवल तीन इनपुट घोषणाएं:

शून्य सेटअप () {पिनमोड (मेनू चयन करें, इनपुट); पिनमोड (मेनू सेव, इनपुट); पिनमोड (मेनू चयन करें, इनपुट); सीरियल.बेगिन (९६००); }

आगे तीन कस्टम फ़ंक्शन हैं। आइए पहले दो को देखें, फिर अंतिम को अलग से।

हमें दो कार्यों की आवश्यकता है जो कुछ जानकारी लौटाते हैं। इसका कारण यह है कि हम यह सुनिश्चित करना चाहते हैं कि यह एक प्रकार का मानव पठनीय हो। यदि हमें कोई समस्या है तो यह कोड को डीबग करने में भी मदद करेगा। कोड:

// वर्तमान चयनित विकल्प को वापस करने का कार्य * रिटर्नऑप्शन सिलेक्टेड () {चार * मेनूऑप्शन = मेन्यूऑप्शन [विकल्प चयनित]; // वापसी विकल्पचयनित वापसी मेनूविकल्प; } // वर्तमान चयनित विकल्प की स्थिति वापस करने के लिए कार्य चार *रिटर्नऑप्शनस्टैटस () {बूल विकल्प सेटिंग = फीचरसेटिंग [विकल्प चयनित]; चार *विकल्पसेटिंगवैल; अगर (विकल्प सेटिंग == गलत) {विकल्प सेटिंगवैल = "गलत"; }else{ optionSettingVal = "True"; } // रिटर्न ऑप्शनसेटिंग रिटर्न ऑप्शनसेटिंगवैल; }

char *ReturnOptionSelected() फ़ंक्शन चयनित विकल्प की जांच करता है (यदि आप ऊपर देखते हैं, तो हम उस पर नज़र रखने के लिए एक चर सेट करते हैं), और हमारे द्वारा पहले बनाए गए सरणी से स्ट्रिंग अक्षर को खींचता है। यह फिर इसे एक चार प्रकार के रूप में लौटाता है। हम इसे जानते हैं क्योंकि फ़ंक्शन रिटर्न प्रकार को इंगित करता है।

दूसरा फ़ंक्शन, char *ReturnOptionStatus() सरणी में सहेजे गए विकल्प की स्थिति को पढ़ता है और एक स्ट्रिंग अक्षर देता है जो मान का प्रतिनिधित्व करता है। उदाहरण के लिए, यदि हमने जो सेटिंग संग्रहीत की है, वह गलत है, तो मैं "गलत" लौटाऊंगा। ऐसा इसलिए है क्योंकि हम उपयोगकर्ता को यह चर दिखाते हैं और यह सब तर्क एक साथ रखना बेहतर है। मैं इसे बाद में कर सकता था, लेकिन इसे यहां करने के लिए और अधिक समझ में आता है।

// वर्तमान विकल्प को टॉगल करने का कार्य टॉगल विकल्प चयनित () {फीचरसेटिंग [विकल्प चयनित] = फीचर सेटिंग [विकल्प चयनित]; सच लौटना; }

फ़ंक्शन बूल ToggleOptionSelected() हमारे द्वारा मेनू में चुनी गई सेटिंग के मान को बदलने के लिए एक सुविधा फ़ंक्शन है। यह सिर्फ मूल्य को फ़्लिप करता है। यदि आपके पास विकल्पों का अधिक जटिल सेट है, तो यह काफी भिन्न हो सकता है। मैं इस फ़ंक्शन में सच लौटाता हूं, क्योंकि मेरा कॉलबैक (बाद में कोड में कॉल जो इस फ़ंक्शन को सक्रिय करता है) एक सही/गलत उत्तर की अपेक्षा करता है। मुझे 100% यकीन है कि यह काम करेगा, इसलिए मैंने इसे काम नहीं करने के लिए जिम्मेदार नहीं ठहराया, लेकिन मैं एक तैनात आवेदन (बस मामले में) में होगा।

चरण 9: लूप…

लूप () फ़ंक्शन काफी लंबा है, इसलिए हम इसे भागों में करेंगे। आप इस फ़ंक्शन के भीतर घोंसले के नीचे सब कुछ मान सकते हैं:

शून्य लूप () {

// यहां काम करें <----- }

ठीक है, हमने यह सामान पहले देखा था:

// बटन पढ़ें int menuButtonPressed = digitalRead(menuButton); इंट मेन्यू सिलेक्टप्रेस्ड = डिजिटलरीड (मेनू सेलेक्ट); इंट मेन्यू सेवप्रेस्ड = डिजिटलरीड (मेनू सेव); // वर्तमान समय लंबा प्राप्त करें int currentTime = मिली (); if(menuButtonPressed == LOW && menuSelectPressed == LOW && MenuSavePressed == LOW) {// काउंट टाइम रीसेट करें जबकि बटन दबाया नहीं जाता है lastDebounceTime = currentTime; मेनूबटन पिछलास्टेट = कम; मेनू चयन पिछला राज्य = कम; मेनू सेवपिछलास्टेट = कम; }

मुझे यहां केवल तीन digitalRead () कॉलों में जोड़ना था, और सुनिश्चित करें कि मैंने इस तथ्य के लिए जिम्मेदार ठहराया है कि यदि सभी बटन कम थे, तो हमें टाइमर (lastDebounceTime = currentTime) को रीसेट करना चाहिए और पिछले सभी राज्यों को कम पर सेट करना चाहिए। मैं currentTime में मिलिस() भी स्टोर करता हूं।

अगला खंड लाइन के अंदर घोंसला बनाता है

अगर (((करंटटाइम - लास्टडेब्यूसटाइम)> डेब्यूसटाइमआउट)) {

// यहां काम करें <---- }

तीन खंड हैं। हां, मैं उन्हें अपने कार्यों में स्थानांतरित कर सकता था, लेकिन सादगी के लिए मैंने यहां तीन मुख्य बटन एल्गोरिदम रखे।

अगर ((मेनूबटन दबाया == उच्च) && (मेनूबटन पिछलास्टेट == कम)) {अगर (मेनूमोड == झूठा) {मेनूमोड = सत्य; // उपयोगकर्ता को बताएं कि Serial.println ("मेनू सक्रिय है"); } और अगर (मेनूमोड == सत्य && विकल्प चयनित = 1) {// विकल्प रीसेट करें विकल्प चयनित = 0; } // मेनू मेन्यू प्रिंट करेंNeedsPrint = true; // बटन को टॉगल करें पिछला। केवल मेनू प्रदर्शित करने के लिए राज्य // यदि बटन जारी किया जाता है और फिर से दबाया जाता है मेनूबटन पिछलास्टेट = मेनूबटन दबाया गया; // उच्च होगा}

जब मेनूबटन दबाया जाता है, या जब मेनू बटन दबाया जाता है तो यह पहला संभालता है। यह सुनिश्चित करने के लिए भी जांच करता है कि पिछली स्थिति कम थी, ताकि बटन को फिर से दबाए जाने से पहले उसे छोड़ना पड़े, जो प्रोग्राम को एक ही घटना को बार-बार फायर करने से रोकता है।

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

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

// मेन्यू सेलेक्ट को दबाया जाता है, लॉजिकिफ प्रदान करें ((मेनू सेलेक्टप्रेस्ड == हाई) && (मेनू सेलेक्टप्रिवियसस्टेट == लो)) {अगर (मेनूमोड) {// चयनित विकल्प को बदलें // फिलहाल, यह सिर्फ सच / गलत है // लेकिन कुछ भी हो सकता है बूल टॉगल = ToggleOptionSelected (); अगर (टॉगल) {menuNeedsPrint = सच; }else{ Serial.println ("कुछ गलत हुआ। कृपया पुनः प्रयास करें"); } } // जारी होने और फिर से दबाए जाने पर केवल टॉगल करने के लिए राज्य को टॉगल करें }

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

ध्यान देने वाली मुख्य बात टॉगल वैरिएबल है, जो कॉलबैक की सफलता को ट्रैक करता है और सही होने पर मेनू को प्रिंट करता है। अगर यह कुछ भी नहीं देता है या गलत है, तो यह त्रुटि संदेश प्रिंट करेगा। यह वह जगह है जहां आप अन्य चीजों को करने के लिए अपने कॉलबैक का उपयोग कर सकते हैं।

if((menuSavePressed == High) && (menuSavePreviousState == LOW)) {// मेनू से बाहर निकलें // यहां आप कोई भी सफाई कर सकते हैं // या EEPROM मेनू में सेव कर सकते हैं। Serial.println ("मेनू बाहर निकल गया"); // स्थिति टॉगल करें ताकि मेनू केवल एक बार मेनू से बाहर निकल जाए } }

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

if(menuMode && menuNeedsPrint){// हमने मेनू को प्रिंट कर लिया है, इसलिए जब तक कि कुछ // नहीं होता है, इसे फिर से प्रिंट करने की कोई आवश्यकता नहीं है menuNeedsPrint = false; चार * विकल्प सक्रिय = रिटर्नऑप्शन चयनित (); चार * विकल्पस्टैटस = रिटर्नऑप्शनस्टैटस (); सीरियल.प्रिंट ("चयनित:"); सीरियल.प्रिंट (विकल्प सक्रिय); सीरियल.प्रिंट (":"); सीरियल.प्रिंट (विकल्प स्थिति); सीरियल.प्रिंट्लन (); }

यह मेन्यूप्रिंट एल्गोरिथम है, जो केवल तभी सक्रिय होता है जब मेन्यू सक्रिय होता है और जब मेन्यूनीड्सप्रिंट वेरिएबल सत्य पर सेट होता है।

यह निश्चित रूप से अपने स्वयं के कार्य में ले जाया जा सकता है, लेकिन सादगी के लिए..!

हां इसी तरह! संपूर्ण कोड ब्लॉक के लिए अगला चरण देखें।

चरण 10: अंतिम कोड ब्लॉक

// स्थिरांक परिभाषित करें

# परिभाषित मेनूबटन 2 # मेन्यू परिभाषित करें 3 चुनें # मेन्यू परिभाषित करें 4 सहेजें #डिफाइन करेंटाइमआउट 50 इंट मेन्यूबटन पिछलास्टेट = कम; int मेनू चयन करें पिछलास्टेट = कम; int मेनूसेवपिछलास्टेट = कम; // लंबे समय तक चर को परिभाषित करें lastDebounceTime; बूल लाइट सेंसर = सच; बूल टेम्प सेंसर = सच; // मेनू विकल्प चार * मेनू विकल्प = {"अस्थायी जांचें", "लाइट की जांच करें"}; बूल फीचरसेटिंग = {झूठा, झूठा}; बूल मेनूमोड = झूठा; बूल मेनूनीड्सप्रिंट = झूठा; int विकल्प चयनित = 0; // सेटअप फ़ंक्शन

शून्य सेटअप () {पिनमोड (मेनू चयन करें, इनपुट); पिनमोड (मेनू सेव, इनपुट); पिनमोड (मेनू चयन करें, इनपुट); सीरियल.बेगिन (९६००); }

// वर्तमान चयनित विकल्प को वापस करने का कार्य चार *रिटर्नऑप्शन सिलेक्टेड (){ चार *मेनूऑप्शन = मेन्यूऑप्शन [विकल्प चयनित]; // वापसी विकल्पचयनित वापसी मेनूविकल्प; } // वर्तमान चयनित विकल्प की स्थिति वापस करने के लिए कार्य चार *रिटर्नऑप्शनस्टैटस () {बूल विकल्प सेटिंग = फीचरसेटिंग [विकल्प चयनित]; चार *विकल्पसेटिंगवैल; अगर (विकल्प सेटिंग == गलत) {विकल्प सेटिंगवैल = "गलत"; }else{ optionSettingVal = "True"; } // रिटर्न ऑप्शनसेटिंग रिटर्न ऑप्शनसेटिंगवैल; } // वर्तमान विकल्प को टॉगल करने के लिए फ़ंक्शन बूल टॉगलऑप्शन सेलेक्टेड () {फीचरसेटिंग [ऑप्शन सेलेक्टेड] =! फीचरसेटिंग [ऑप्शन सेलेक्टेड]; सच लौटना; } // मुख्य लूप

शून्य लूप () {// बटन पढ़ें int menuButtonPressed = digitalRead(menuButton); इंट मेन्यू सिलेक्टप्रेस्ड = डिजिटलरीड (मेनू सेलेक्ट); इंट मेन्यू सेवप्रेस्ड = डिजिटलरीड (मेनू सेव); // वर्तमान समय लंबा प्राप्त करें int currentTime = मिली (); if(menuButtonPressed == LOW && menuSelectPressed == LOW && MenuSavePressed == LOW) {// काउंट टाइम रीसेट करें जबकि बटन दबाया नहीं जाता है lastDebounceTime = currentTime; मेनूबटन पिछलास्टेट = कम; मेनू चयन पिछला राज्य = कम; मेनू सेवपिछलास्टेट = कम; } if(((currentTime - lastDebounceTime) > debounceTimeout)) {// यदि टाइमआउट पूरा हो गया है, तो बटन दबाया गया!

// मेनूबटन दबाया जाता है, तर्क प्रदान करें

// केवल तभी सक्रिय होता है जब बटन पहले जारी किया गया हो अगर ((मेनूबटन दबाया == उच्च) && (मेनूबटन पिछलास्टेट == कम)) {अगर (मेनूमोड == झूठा) {मेनूमोड = सत्य; // उपयोगकर्ता को बताएं कि Serial.println ("मेनू सक्रिय है"); } और अगर (मेनूमोड == सत्य && विकल्प चयनित = 1) {// विकल्प रीसेट करें विकल्प चयनित = 0; } // मेनू मेन्यू प्रिंट करेंNeedsPrint = true; // बटन को टॉगल करें पिछला। केवल मेनू प्रदर्शित करने के लिए राज्य // यदि बटन जारी किया जाता है और फिर से दबाया जाता है मेनूबटन पिछलास्टेट = मेनूबटन दबाया गया; // हाई होगा } // मेन्यू सेलेक्ट को दबाया जाता है, लॉजिक प्रदान करें if((menuSelectPressed == High) && (menuSelectPreviousState == LOW)){ if(menuMode){// चयनित विकल्प बदलें // फिलहाल, यह है बस सच/गलत//लेकिन कुछ भी हो सकता है बूल टॉगल = टॉगलऑप्शन चयनित (); अगर (टॉगल) {menuNeedsPrint = सच; }else{ सीरियल.प्रिंट ("कुछ गलत हो गया। कृपया पुनः प्रयास करें"); } } // जारी होने और फिर से दबाए जाने पर केवल टॉगल करने के लिए राज्य को टॉगल करें } if((menuSavePressed == High) && (menuSavePreviousState == LOW)){//मेनू से बाहर निकलें // यहां आप कोई भी सफाई कर सकते हैं // या EEPROM मेनू में सेव कर सकते हैं। Serial.println ("मेनू बाहर निकल गया"); // स्थिति टॉगल करें ताकि मेनू केवल एक बार मेनू से बाहर निकल जाए } } // वर्तमान मेनू विकल्प को सक्रिय रूप से प्रिंट करें, लेकिन इसे केवल एक बार प्रिंट करें यदि (मेनूमोड && मेन्यूनीड्सप्रिंट) {// हमने मेनू प्रिंट किया है, इसलिए जब तक कुछ // नहीं होता है, इसे फिर से प्रिंट करने की कोई आवश्यकता नहीं है मेन्यूनीड्सप्रिंट = झूठा; चार * विकल्प सक्रिय = रिटर्नऑप्शन चयनित (); चार * विकल्पस्टैटस = रिटर्नऑप्शनस्टैटस (); सीरियल.प्रिंट ("चयनित:"); सीरियल.प्रिंट (विकल्प सक्रिय); सीरियल.प्रिंट (":"); सीरियल.प्रिंट (विकल्प स्थिति); सीरियल.प्रिंट्लन (); } } }

सर्किट टिंकरकाड साइट पर उपलब्ध है। मैंने आपको देखने के लिए नीचे सर्किट एम्बेड किया है!

हमेशा की तरह, यदि आपके कोई प्रश्न या मुद्दे हैं, तो कृपया मुझे बताएं!