NodeMCU के साथ रिमोट नियंत्रित टाइमर: 14 कदम

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

यहां हम एक NodeMCU और Adafruit का उपयोग करके एक टाइमर बनाने जा रहे हैं। हम अपने टाइमर को एक एलईडी पट्टी के साथ प्रदर्शित करने जा रहे हैं और हम अपने फोन या कंप्यूटर का उपयोग करके इसे नियंत्रित करने में सक्षम होंगे!

हमारा लक्ष्य:

एक एलईडी पट्टी का उपयोग करके एक टाइमर बनाएं जो हम कर सकते हैं: अपने फोन या कंप्यूटर का उपयोग करके शुरू करें, रोकें और रीसेट करें।

आपूर्ति

हार्डवेयर:

• नोडएमसीयू ईएसपी 8266
• एडफ्रूट नियोपिक्सल एलईडी स्ट्रिप

पुस्तकालय:

• Adafruit_NeoPixel.h
• AdafruitIO_WiFi.h

अन्य:

एक अच्छा वाईफाई कनेक्शन

चरण 1: आइए Adafruit में एक फ़ीड बनाएँ

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

चलिए अब एक नया फ़ीड बनाते हैं

हम अपने फ़ीड को कुछ भी नाम दे सकते हैं, मैं इसे 'टाइमर' कह रहा हूं।

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

चरण 2: अब एक डैशबोर्ड बनाते हैं

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

चरण 3: हमारी कुंजी प्राप्त करें

अगर हम अपने Arduino को अपने फ़ीड से जोड़ना चाहते हैं तो हमें अपनी Adafruit कुंजी प्राप्त करने की आवश्यकता है, यह आपका गुप्त पासवर्ड है जो सुनिश्चित करेगा कि केवल आप ही अपने फ़ीड से जुड़ सकते हैं।

आप Adafruit में अपनी स्क्रीन के शीर्ष दाईं ओर पीले AIO कुंजी बटन पर क्लिक करके अपनी कुंजी प्राप्त कर सकते हैं।

इस कुंजी को कहीं सेव कर लें, हमें बाद में इसकी आवश्यकता होगी।

अपनी चाबी साझा न करें! अन्यथा बुरे इरादे वाले लोग आपके फ़ीड और उपकरणों से जुड़ सकते हैं।

चरण 4: फ़ीड पढ़ें उदाहरण खोलें

अब अपना Arduino IDE खोलें और कोडिंग प्रक्रिया शुरू करें। सबसे पहले हमें Adafruit IO Arduino लाइब्रेरी स्थापित करने की आवश्यकता है।

पता नहीं पुस्तकालय कैसे स्थापित करें? यह Adafruit का एक बेहतरीन मार्गदर्शक है: Arduino लाइब्रेरी

Adafruit हमारे लिए उपयोग करने और सीखने के लिए बहुत सारे पूर्व-निर्मित उदाहरण प्रस्तुत करता है। इनमें से एक उदाहरण है: adafruitio_21_feed_read. आप इस उदाहरण को यहाँ पा सकते हैं: फ़ाइल - उदाहरण Adafruit IO Arduino adafruitio_21_feed_read

(छवि में मेरे डच इंटरफ़ेस को क्षमा करें)

चरण 5: आइए अपना कनेक्शन सेट करें

यदि आपने adafruitio_21_feed_read स्केच को सफलतापूर्वक खोल लिया है, तो आपको अपने स्केच में 2 टैब दिखाई देने चाहिए: adafruitio_21_feed_read और config.h. यह स्केच इसलिए बनाया गया था ताकि हम उस फ़ीड से जुड़ सकें जिसे हमने चरण 1 में बनाया था।

इस फ़ीड से जुड़ने के लिए हमें अपने वाईफाई और हमारे एडफ्रूट खाते के बारे में कुछ विवरण भरने होंगे,

आइए config.h की यात्रा करें, यहां हम निम्नलिखित विवरण भरेंगे:

आपका एडफ्रूट यूजरनेम:

#define IO_USERNAME "joopert"

आपकी एडफ्रूट कुंजी:

#define IO_KEY "1234567890abcdefghijklmnop"

आपके वाईफाई का नाम:

#परिभाषित वाईफ़ाई_एसएसआईडी "माईवाईफाई"

और आपका वाईफाई पासवर्ड:

#define WIFI_PASS "aVerySecretPassword"

अब adafruitio_21_feed_read टैब पर वापस जाएं और इसे भरें:

आपका एडफ्रूट यूज़रनेम… फिर से:

#FEED_OWNER "जूपर्ट" परिभाषित करें

और अंत में आपका फ़ीडनाम (उस फ़ीड से जिसे हमने चरण 1 में बनाया है):

AdafruitIO_Feed *sharedFeed = io.feed("timer", FEED_OWNER);

चरण 6: Adafruit IO से कनेक्शन की जाँच करें

यह जांचने के लिए कि क्या हमने पहले जो कदम उठाए हैं, उन्हें सही तरीके से निष्पादित किया गया है, हम अपने स्केच को NodeMCU पर अपलोड करने जा रहे हैं। यदि आप अपना सीरियल मॉनिटर खोलते हैं, तो यह ऊपर की तस्वीर जैसा कुछ दिखना चाहिए। सबसे पहले सीरियल मॉनिटर आपको दिखा रहा है कि यह आपके वाईफाई और एडफ्रूट से कनेक्ट करने का प्रयास कर रहा है। अगर वह पूरा हो गया है तो उसे कहना चाहिए:

एडफ्रूट आईओ जुड़ा

यह अच्छी खबर है! अब हम अपने टाइमर में कार्यक्षमता जोड़ना शुरू कर सकते हैं…

चरण 7: चलो एलईडी

अब हमारी एलईडी पट्टी को चालू करने का समय आ गया है!

अपनी LED स्ट्रिप को D5 पिन से कनेक्ट करें (यदि आपको D5 नहीं मिल रहा है तो इसे दूसरे पिन से कनेक्ट करें और कोड में LED_PIN बदलें)।

एलईडी पट्टी को परिभाषित करें

निम्नलिखित कोड NeoPixel लाइब्रेरी को जोड़ देगा (इस लाइब्रेरी के बारे में यहाँ और जानें: https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-use) और सुनिश्चित करें कि हमारा Arduino जानता है कि हमारी LED स्ट्रिप कहाँ है और उसके पास कितनी रोशनी है। यदि आपकी एलईडी पट्टी में अलग-अलग विनिर्देश हैं, तो इसे कोड में बदलें।

शून्य सेटअप के ऊपर निम्न कोड जोड़ें ():

// NeoPixel कनेक्शन सेट करें#include #ifdef _AVR_ #include #endif

#define LED_PIN D5 // LED स्ट्रिप कहां से जुड़ी है?

#define LED_COUNT 30 // इसमें कितने पिक्सेल होते हैं?

#define BRIGHTNESS 50 // NeoPixel ब्राइटनेस, 0 (न्यूनतम) से 255 (अधिकतम)

Adafruit_NeoPixel स्ट्रिप (LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

एलईडी पट्टी शुरू करें

अब हम अपनी एलईडी पट्टी शुरू करेंगे और चमक सेट करेंगे (चमक 0 मिनट से 255 अधिकतम तक जाती है, लेकिन मेरा सुझाव है कि 50… 255 वास्तव में उज्ज्वल है)।

शून्य सेटअप () में निम्न कोड जोड़ें:

पट्टी। शुरू (); // NeoPixel स्ट्रिप ऑब्जेक्ट (आवश्यक) स्ट्रिप.शो () शुरू करें; // सभी पिक्सल को ASAP स्ट्रिप.सेटब्राइटनेस (50) बंद करें; // ब्राइटनेस को लगभग 1/5 पर सेट करें (अधिकतम = 255)

लेडऑन (); // प्रत्येक एलईडी को एक-एक करके चालू करने के लिए फ़ंक्शन को कॉल करें

बत्ती जलाओ

हो सकता है कि आपने पहले ही नोटिस किया हो कि हम एक ऐसे फंक्शन को कॉल कर रहे हैं जो अभी तक मौजूद नहीं है, यह कोडिंग का हमारा अगला भाग होगा। अगर हम अपनी रोशनी चालू करना चाहते हैं तो हमें एक 'लूप के लिए' बनाना होगा जो प्रत्येक व्यक्ति को एक-एक करके एलईडी चालू करता है (पता नहीं कि लूप क्या है? इसे यहां देखें: www.arduino.cc/reference/ en/भाषा/संरचना/नियंत्रण-संरचना/के लिए/)।

अब हम फंक्शन बनाने जा रहे हैं: ledsOn ();

निम्न कोड को शून्य हैंडलमैसेज के नीचे जोड़ें ():

शून्य एलईडीऑन () {के लिए (इंट आई = 0; आई < स्ट्रिप.numPixels (); i ++) {// स्ट्रिप में प्रत्येक पिक्सेल के लिए… स्ट्रिप.सेट पिक्सेलकलर (i, 0, 0, 255); // पिक्सेल के रंग को नीली पट्टी पर सेट करें। शो (); // मैच के लिए स्ट्रिप अपडेट करें } }

डालना

अब मजेदार हिस्सा है, आइए अपना कोड NodeMCU पर अपलोड करें… यदि सब कुछ सही ढंग से काम करता है तो आपकी एलईडी पट्टी अब पूरी तरह से नीली हो जानी चाहिए!

क्या कोई पिक्सेल नहीं दिख रहा है?: क्या आपने पट्टी को दाहिने पिन से जोड़ा है? या हो सकता है कि आपका इंटरनेट कनेक्शन खो गया हो।

क्या केवल कुछ पिक्सेल दिखाई नहीं दे रहे हैं?: जांचें कि क्या आपने सही मात्रा में पिक्सेल सेट किए हैं!

चरण 8: टाइमर में समय जोड़ें

अब हम यह सुनिश्चित करने जा रहे हैं कि हमारा टाइमर वास्तव में… ठीक है… बार, कुछ।

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

यदि आप इसमें रुचि रखते हैं कि यह कैसे काम करता है तो आप इस लेख को देख सकते हैं:

आइए मिलिस () के लिए कोड जोड़ें:

इस कोड को शून्य सेटअप के ऊपर रखें ()

अहस्ताक्षरित लंबे पिछलेमिलिस = 0; // पिछली बार स्टोर करेगा जब एलईडी पट्टी अपडेट की गई थीअंतराल = १०००; // हमारे टाइमर का अंतराल (मिलीसेकंड)

और इस कोड को शून्य लूप () में डालते हैं:

अहस्ताक्षरित लंबी वर्तमानमिलिस = मिली ();// टाइमर शुरू करें ************************************************ ********* अगर (करंटमिलिस - पिछलामिलिस>= अंतराल) {पिछलामिलिस = करंटमिलिस;

// समाप्ति टाइमर RYTHM *********************************************** ***********

हमने अभी जो किया वह एलईडी को बंद करने के लिए हमारी एलईडी पट्टी के लिए एक लय बना रहा था, अगले चरण में हम ऐसा करने के लिए कोड जोड़ देंगे।

चरण 9: उलटी गिनती

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

हम शीर्ष पर एक 'int' बनाएंगे जिसे 'leds' कहा जाता है। यह बाद में हमारे टाइमर को बताएगा कि कितने एलईडी को अभी भी बंद करना है।

शून्य सेटअप के ऊपर निम्न कोड जोड़ें ():

इंट एलईडी = LED_COUNT-1; // बताता है कि कितने पिक्सेल जलाए जाने चाहिए

अब चलिए फंक्शन 'टाइमर ();' जोड़ते हैं, यह हर सेकेंड में एक लाइट बंद कर देगा

निम्न कोड को शून्य एलईडीऑन () के नीचे जोड़ें:

शून्य टाइमर () {trip.setPixelColor (एल ई डी, 0, 0, 0);

अगर (एल ई डी > -1) {एल ई डी--; } और {ब्लिंकी (); } }

हम उपयोगकर्ता को कुछ प्रतिक्रिया देना चाहते हैं कि सभी रोशनी जल जाने के बाद टाइमर किया जाता है। 'ब्लिंकी ();' के साथ टाइमर हो जाने के बाद एल ई डी लाल हो जाएगा!

शून्य सेटअप के ऊपर निम्न कोड जोड़ें ():

इंट ब्लिंकस्टैटस = 1; // ब्लिंकी को बताता है (); फंक्शन वेदर लाइट चालू या बंद होनी चाहिए

शून्य टाइमर के नीचे निम्न कोड जोड़ें ():

शून्य ब्लिंकी () { अगर (ब्लिंकस्टैटस == 1) {

ब्लिंकस्टैटस = 0; स्ट्रिप.क्लियर (); } और {ब्लिंकस्टैटस = 1; for (int i = 0; i < strip.numPixels (); i++) {// स्ट्रिप में प्रत्येक पिक्सेल के लिए… strip.setPixelColor(i, 255, 0, 0); // पिक्सेल का रंग सेट करें (रैम में) स्ट्रिप.शो (); // मैच के लिए स्ट्रिप अपडेट करें } } } }

अंत में हमें अपने शून्य लूप (); में फ़ंक्शन को कॉल करना होगा, TIMER RYTHM याद रखें जिसे हमने चरण 8 में जोड़ा था? इसमें अगर स्टेटमेंट हम फंक्शन टाइमर (); को कॉल करेंगे।

TIMER RYTHM अब इस तरह दिखना चाहिए:

// टाइमर शुरू करें ************************************************ *********

अगर (करंटमिलिस - पिछलामिलिस>= अंतराल) {पिछलामिलिस = करंटमिलिस; टाइमर (); स्ट्रिप.शो ();} // एंड टाइमर RYTHM ************************ ******

अब इस कोड को अपलोड करें!

अभी आपकी एलईडी पट्टी प्रत्येक सेकंड में 1 एलईडी बंद कर रही है और जब यह हो जाए तो लाल रंग की झपकाएं …

आइए अब इस मातृ-प्रेमी को रिमोट से नियंत्रित करें!

चरण 10: इसे रिमोट से नियंत्रित करें: भाग I

हमें अपना टाइमर मिल गया है, यह सब ठीक है और बांका है लेकिन मैंने आपसे वादा किया था कि आप इसे अपने फोन से नियंत्रित कर पाएंगे, है ना? आइए अपनी परियोजना के अंतिम चरण में प्रवेश करें: हमारे टाइमर को रिमोट नियंत्रित बनाना।

अभी भी आपका एडफ्रूट टैब खुला है? आइए io.adafruit.com पर वापस जाएं और हमारे टाइमर इंटरफ़ेस डैशबोर्ड पर जाएं और एक नया ब्लॉक बनाएं: TOGGLE

1. टॉगल को TIMER फ़ीड से कनेक्ट करें
2. ON मान को इस पर सेट करें: 1
3. OFF मान को इस पर सेट करें: 0

इसका कारण यह है कि Adafruit हमारे NodeMCU को टेक्स्ट डेटा नहीं भेजता है, बल्कि केवल नंबर भेजता है।

आप चाहें तो टॉगल को एक नाम भी दे सकते हैं, हो सकता है: 'चालू/बंद स्विच'

अब वापस Arduino IDE पर चलते हैं

बस यह सुनिश्चित करने के लिए कि हमारा कोड अप टू डेट है, आइए एक बार फिर से अपना कोड अपलोड करें।

सीरियल मॉनिटर को अपलोड करने के बाद खोलें और हमारे एडफ्रूट डैशबोर्ड पर कुछ बार टॉगल दबाएं। अब हमें अपने सीरियल मॉनीटर में ऐसा कुछ दिखाई देना चाहिए:

प्राप्त <- 0 प्राप्त <- 1 प्राप्त <- 0 प्राप्त <- 1 प्राप्त <- 0

इसका मतलब है कि हम वास्तव में अपने NodeMCU को नियंत्रण भेज सकते हैं!

अगर आपको ये संदेश नहीं मिल रहे हैं, तो जांच लें कि आपके config.h में आपका एडफ्रूट डेटा अभी भी सही है या नहीं।

चरण 11: इसे रिमोट से नियंत्रित करें: भाग II

अब जो कुछ बचा है वह हमारे प्राप्त नियंत्रणों के साथ कुछ करना है।

ऐसा करने के लिए हमें अपने TIMER RYTHM को बदलना होगा यदि शून्य लूप में कथन (); थोड़ा सा।

हम अपने NodeMCU को बताने जा रहे हैं कि Adafruit से '1' (जिसका अर्थ है: ON) प्राप्त करने के बाद ही इसे टाइमर शुरू करना चाहिए।

सबसे पहले एडफ्रूट हमें जो डेटा भेजता है उसे इकट्ठा करते हैं

शून्य सेटअप के ऊपर निम्न कोड जोड़ें ():

इंट एडाडाटा; // डेटा एकत्र करता है AdaFruit हमें भेजता है

आइए अब वास्तव में उस डेटा को इकट्ठा करते हैं

शून्य हैंडल मैसेज () के अंदर निम्न कोड जोड़ें:

adaData = डेटा-> toInt ();

आइए हमारे शून्य लूप को बदलें ();

TIMER RYTHM अब इस तरह दिखना चाहिए:

// टाइमर शुरू करें ************************************************ ********* अगर (करंटमिलिस - पिछलामिलिस>= अंतराल) {पिछलामिलिस = करंटमिलिस; अगर (adaData == 0) {Serial.println ("मैं नहीं चल रहा हूं"); } और अगर (adaData == 1) {टाइमर (); } कपड़े उतारने का प्रदर्शन(); } // एंड टाइमर RYTHM ****************************** *************

अपना कोड अपलोड करें…

अब आप Adafruit में स्विच का उपयोग करके टाइमर को चालू और बंद करने में सक्षम होंगे!

चरण 12: चारों ओर खेलें! हम कर रहे हैं… या हम हैं?

अभी आपके पास पूरी तरह से काम करने वाला रिमोट टाइमर होना चाहिए! अगर यह आपके लिए है तो इस परियोजना के साथ आने के लिए धन्यवाद!

यदि आप कुछ देर और जारी रखना चाहते हैं, तो अगले कुछ चरणों में हम अपने टाइमर के लिए एक रीसेट बटन जोड़ने जा रहे हैं!

चरण 13: अतिरिक्त: क्षणिक बटन बनाएँ

आइए अपने डैशबोर्ड पर वापस आते हैं। अब हम फिर से एक नया ब्लॉक बनाना चाहते हैं।

1. एक क्षणिक बटन बनाएँ
2. इसे 'टाइमर' फ़ीड से कनेक्ट करें
3. प्रेस मान को इस पर सेट करें: 2
4. रिलीज़ मान निकालें
5. इसे एक अच्छा रंग दें!

सुविधाजनक रूप से क्षणिक बटन को पहले से ही 'रीसेट' कहा जाता है!

एक बार जब आप इस ब्लॉक को बना लेते हैं तो इसका परीक्षण करें, यदि आपको प्राप्त होता है तो बटन काम करता है:

प्राप्त <- 2

आपके सीरियल मॉनीटर में।

अगर आपको यह संदेश नहीं दिखाई दे रहा है, तो स्केच को फिर से अपलोड करने का प्रयास करें

चरण 14: अतिरिक्त: रीसेट फ़ंक्शन जोड़ें

रीसेट बटन को कुछ भी करने के लिए हमें एक ऐसा फ़ंक्शन जोड़ने की ज़रूरत है जो सभी एल ई डी को मूल स्थिति में रीसेट कर दे।

शून्य ब्लिंकी () के नीचे निम्नलिखित कोड जोड़ें:

शून्य फिर से चलाना () {एल ई डी = LED_COUNT; लेडऑन (); }

अब बस हमारे फंक्शन को कॉल करना बाकी है, इसके लिए हमें TIMER RYTHM को आखिरी बार बदलना होगा

TIMER RYTHM अब इस तरह दिखना चाहिए:

// टाइमर शुरू करें ************************************************ ********* अगर (करंटमिलिस - पिछलामिलिस>= अंतराल) {पिछलामिलिस = करंटमिलिस अगर (adaData == 0) { Serial.println ("इम नहीं चल रहा है"); } और अगर (adaData == 1) {टाइमर (); } और अगर (adaData == 2) {फिर से चलाएँ (); } कपड़े उतारने का प्रदर्शन(); } // एंड टाइमर RYTHM ****************************** *************

अपना कोड अपलोड करें…

अब आप भी बटन दबाकर टाइमर को रीसेट करने में सक्षम होना चाहिए!