आर्टिफिशियल प्लांट इमोशन एक्सप्रेसर (A.P.E.X.): 7 कदम (चित्रों के साथ)

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

लेकिन रुकिए… और भी बहुत कुछ है!

चरण 1: परिचय

एपेक्स क्या है?

एपेक्स एक स्मार्ट (प्यारा उल्लेख नहीं है) प्लांट मॉनिटरिंग डिवाइस है। बस इसे किसी भी संयंत्र में प्लग करें और यह पौधे के "खुशी" स्तर को प्रदर्शित करेगा! अपने पौधों को पानी देने के लिए यह एक महान अनुस्मारक है यदि आपको उन्हें पानी देना भूलने की बुरी आदत है।

यह कैसे काम करता है?

जादू। मजाक था! APEX एक नमी सेंसर से जुड़े Arduino का उपयोग करता है, जिसे पौधे की मिट्टी में डाला जाता है। यह सेंसर मिट्टी की नमी को पढ़ेगा, और फिर Arduino गणना करता है कि किस चेहरे को प्रदर्शित करना है।

लेकिन क्यों?

क्यों नहीं?

चरण 2: भागों और उपकरणों को इकट्ठा करना

आइए इसमें शामिल हों! इस निर्देश के लिए, आपको कुछ भागों और उपकरणों की आवश्यकता होगी। सौभाग्य से आपके लिए, वे सभी नीचे सूचीबद्ध हैं:

माइक्रोकंट्रोलर्स प्रतियोगिता की भावना में, यह परियोजना पूरी तरह से अमेज़ॅन पर खरीदे गए भागों द्वारा बनाई गई थी! (प्रायोजित नहीं)

हिस्सों की सूची:

• Arduino Uno
• 8x8 एलईडी डिस्प्ले
• कैपेसिटिव टच सेंसर
• नमी सेंसर
• 9वी बैटरी कनेक्टर
• 9वी बैटरी

उपकरण सूची:

• 22 गेज तार
• विद्युत टेप
• वायर स्ट्रिपर्स
• सोल्डरिंग आयरन
• डीसोल्डरिंग पंप

एक बार जब आप सभी आवश्यक उपकरण एकत्र कर लेते हैं, तो Arduino सॉफ़्टवेयर को सेटअप करने का समय आ गया है!

चरण 3: Arduino IDE स्थापित करना

इस परियोजना के काम करने के लिए, हमें Arduino को प्रोग्राम करने में सक्षम होना चाहिए। इसके लिए आपके कंप्यूटर पर Arduino इंटीग्रेटेड डेवलपमेंट एनवायरनमेंट (IDE) को डाउनलोड और इंस्टॉल करना होगा। यह काफी सरल व्याख्या है, लेकिन मैं आपको इस प्रक्रिया के बारे में बताऊंगा:

1. Arduino वेबसाइट पर जाएं

2. डाउनलोड पेज पर नेविगेट करें (सॉफ्टवेयर> डाउनलोड)

3. अपने ऑपरेटिंग सिस्टम के लिए डाउनलोड लिंक पर क्लिक करें

साइड नोट: प्रोग्राम विंडोज, मैक और लिनक्स पर काम करेगा।

4. विंडोज़ पर स्थापित करना

• डाउनलोड की गई फ़ाइल को चलाने के लिए उस पर डबल क्लिक करें
• लाइसेंस से सहमत होने के लिए "सहमत" पर क्लिक करें
• बाकी निर्देशों का पालन करें
• कार्यक्रम अब स्थापित किया जाना चाहिए!

(यदि आप खो जाते हैं तो स्क्रीनशॉट देखना सुनिश्चित करें)

5. मैक पर स्थापित करना

• डाउनलोड की गई फ़ाइल पर क्लिक करें
• "खोलें" चुनें
• प्रोग्राम स्वचालित रूप से स्थापित और चलाएगा!

(यदि आप भ्रमित होते हैं तो स्क्रीनशॉट देखना सुनिश्चित करें)

6. बस

और आपने कल लिया! अब आपके सिस्टम पर Arduino IDE डाउनलोड हो गया है!

चरण 4: कोड

यह कदम कोड के बारे में है। यह काफी छोटा कार्यक्रम है, इसलिए मैं आपके साथ इस पर चर्चा करूंगा और बताऊंगा कि यह कैसे काम करता है। सबसे पहले, एक संक्षिप्त अवलोकन, फिर एक गहन व्याख्या, और अंत में इसे Arduino पर कैसे धकेलें!

संक्षिप्त अवलोकन

आप में से उन लोगों के लिए जो कोड की विस्तृत व्याख्या में रुचि नहीं रखते हैं, मैं एक TL; DR खंड प्रदान कर रहा हूँ! यहाँ मूल व्याख्या है। Arduino हर कुछ सेकंड में नमी सेंसर से मूल्यों को पकड़ लेता है। इस जानकारी का उपयोग तब एक निश्चित चेहरे की गणना और प्रदर्शित करने के लिए किया जाता है! अंत में थोड़ा सा कोड भी है जो कैपेसिटिव टच बटन को डिस्प्ले को चालू और बंद करने देता है। बहुत आसान है ना?

एक पदार्थ का मौलिक तत्व

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

इस कार्यक्रम को पांच खंडों में बांटा गया है:

1. पुस्तकालयों सहित और चर बनाना
2. सेटअप फ़ंक्शन
3. चेहरे के भावों के लिए कार्य
4. मैट्रिक्स फ़ंक्शन पर Arduino लिखें
5. लूप फंक्शन

पुस्तकालयों सहित और चर बनाना:

इस कोड का पहला खंड उन सभी चर और पुस्तकालयों के बारे में है जिनका हम उपयोग करेंगे।

#शामिल "LedControlMS.h"

#define TouchSensor 7 LedControl lc=LedControl(12, 11, 10, 1); इंट सेंसरपिन = ए5; इंट सेंसरवैल्यू = 0; बूल शुरू = झूठा; बूल ऑन = सच; बूलियन दबाया = कम;

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

बाइट स्माइल [४] = {बी०००००१००, बी०००११००१०, बी०११००१००, बी०११०००००}; बाइट सरप्राइज [४] = {बी००००१११०, बी००००१०१०, बी०११०१११०, बी१००१००००}; बाइट मेह [४] = {बी००००१००, बी००१००१००, बी००१००१००, बी००१०००००}; बाइट सैड[4]={B00000010, B01100100, B00110010, B00110000}; बाइट डेड[6]={B00001010, B00100100, B00101010, B00100000, B01100000, B01101010}; बाइट त्रुटि [8] = {B00111100, B01000010, B10100001, B10010001, B10001001, B10000101, B01000010, B00111100}; // ईविल फेसेस बाइट एस्माइल [4] = {B00000010, B00101010, B01000100, B01000000}; बाइट एलॉफ[4]={B00000010, B00101010, B01100100, B01100000}; बाइट एप्लेन [4] = {B00000010, B00101010, B00100100, B00100000}; बाइट आईल[4]={B00000001, B01101001, B01100010, B01100000}; बाइट एटॉक [४] = {बी००००००१, बी००१०१००१, बी०११०००१०, बी०११०००००};

ये मान APEX के सभी फलकों का प्रतिनिधित्व करते हैं। प्रत्येक बाइट एक सरणी है जिसमें कई बिट्स होते हैं जो किसी दिए गए पंक्ति में प्रत्येक पिक्सेल की स्थिति को निर्देशित करते हैं। "1" और "0" क्रमशः चालू/बंद का प्रतिनिधित्व करता है।

सेटअप समारोह:

अगले भाग पर चलते हुए, हमारे पास अपना सेटअप फ़ंक्शन है।

शून्य सेटअप () {// एमएस सीरियल आउटपुट सीरियल.बेगिन (९६००);

पिनमोड (टच सेंसर, इनपुट);

// एलईडी मैट्रिक्स सेटअप lc.shutdown(0, false); एलसी.सेटइंटेंसिटी (0, 4); एलसी.क्लियरडिस्प्ले(0); }

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

चेहरे के भावों के लिए कार्य:

यह शायद सबसे लंबा खंड है, लेकिन यह बहुत ही सरल और दोहराव वाला है।

शून्य टूटा हुआ () {lc.setRow (0, 0, त्रुटि [0]); lc.setRow (0, 1, त्रुटि [1]); lc.setRow(0, 2, त्रुटि[2]); lc.setRow (0, 3, त्रुटि [3]); lc.setRow (0, 4, त्रुटि [4]); lc.setRow (0, 5, त्रुटि [5]); lc.setRow (0, 6, त्रुटि [6]); lc.setRow (0, 7, त्रुटि [7]); }

शून्य खुश () {

lc.setRow(0, 0, मुस्कान [0]); lc.setRow(0, 1, मुस्कान [1]); lc.setRow(0, 2, मुस्कान[2]); lc.setRow(0, 3, मुस्कान [3]); lc.setRow(0, 4, मुस्कान [3]); lc.setRow(0, 5, मुस्कान[2]); lc.setRow(0, 6, मुस्कान [1]); lc.setRow(0, 7, मुस्कान [0]); }

शून्य सादा () {

lc.setRow(0, 0, meh[0]); lc.setRow(0, 1, meh[1]); lc.setRow(0, 2, meh[2]); एलसी.सेटरो (0, 3, मेह [3]); lc.setRow(0, 4, meh[3]); lc.setRow(0, 5, meh[2]); lc.setRow(0, 6, meh[1]); एलसी.सेटरो (0, 7, मेह [0]); }

शून्य हैरान () {

lc.setRow(0, 0, आश्चर्य [0]); lc.setRow(0, 1, आश्चर्य [1]); lc.setRow(0, 2, आश्चर्य [2]); lc.setRow(0, 3, आश्चर्य [3]); lc.setRow(0, 4, आश्चर्य [3]); lc.setRow(0, 5, आश्चर्य [2]); lc.setRow(0, 6, आश्चर्य [1]); lc.setRow(0, 7, आश्चर्य [0]); }

शून्य मर रहा है () {

lc.setRow (0, 0, मृत [0]); lc.setRow(0, 1, मृत[1]); lc.setRow(0, 2, मृत[2]); एलसी.सेटरो (0, 3, मृत [3]); एलसी.सेटरो (0, 4, मृत [4]); lc.setRow(0, 5, मृत [5]); lc.setRow(0, 6, मृत[1]); एलसी.सेटरो (0, 7, मृत [0]); }

शून्य रोना () {

lc.setRow (0, 0, उदास [0]); lc.setRow(0, 1, उदास [1]); lc.setRow(0, 2, उदास [2]); lc.setRow(0, 3, उदास [3]); lc.setRow(0, 4, उदास [3]); lc.setRow(0, 5, उदास [2]); lc.setRow (0, 6, उदास [1]); lc.setRow(0, 7, उदास [0]); }

शून्य बुराई मुस्कान () {

lc.setRow(0, 0, esmile[0]); lc.setRow(0, 1, esmile[1]); lc.setRow(0, 2, esmile[2]); lc.setRow(0, 3, esmile[3]); lc.setRow(0, 4, esmile[3]); lc.setRow(0, 5, esmile[2]); lc.setRow(0, 6, esmile[1]); lc.setRow(0, 7, esmile[0]); }

शून्य बुराई () {

lc.setRow(0, 0, elaugh[0]); lc.setRow(0, 1, eaugh[1]); lc.setRow(0, 2, elaugh[2]); lc.setRow(0, 3, elaugh[3]); lc.setRow(0, 4, elaugh[3]); lc.setRow(0, 5, elaugh[2]); lc.setRow(0, 6, elaugh[1]); lc.setRow(0, 7, elaugh[0]); }

शून्य बुराई () {

एलसी.सेटरो (0, 0, ईप्लेन [0]); एलसी.सेटरो (0, 1, ईप्लेन [1]); lc.setRow(0, 2, एप्लेन[2]); lc.setRow(0, 3, एप्लेन [3]); lc.setRow(0, 4, ईप्लेन [3]); lc.setRow(0, 5, एप्लेन[2]); lc.setRow(0, 6, एप्लेन[1]); एलसी.सेटरो (0, 7, ईप्लेन [0]); }

शून्य बुराई () {

lc.setRow(0, 0, eyell[0]); lc.setRow(0, 1, eyell[1]); lc.setRow(0, 2, eyell[2]); lc.setRow(0, 3, eyell[3]); lc.setRow(0, 4, eyell[3]); lc.setRow(0, 5, eyell[2]); lc.setRow(0, 6, eyell[1]); lc.setRow(0, 7, eyell[0]); }

शून्य बुराई बात () {

lc.setRow(0, 0, etalk[0]); lc.setRow(0, 1, etalk[1]); lc.setRow(0, 2, etalk[2]); lc.setRow(0, 3, etalk[3]); lc.setRow(0, 4, etalk[3]); lc.setRow(0, 5, etalk[2]); lc.setRow(0, 6, etalk[1]); lc.setRow(0, 7, etalk[0]); }

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

WriteArduinoOnMatrix फ़ंक्शन:

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

void writeArduinoOnMatrix() { if(sensorValue> 0 && sensorValue 30 && sensorValue 100 && sensorValue 200 && sensorValue 400 && sensorValue 650 && sensorValue <= 800) { हैरान (); } और {टूटा हुआ (); } }

आप देख सकते हैं कि सेंसर के काम करने की सीमा से बाहर जाने की स्थिति में ही हमने "टूटे हुए" चेहरों को जोड़ा है। यह कुछ अजीब शून्य त्रुटियों को रोकता है और हमें कोड के भीतर क्या हो रहा है, इसकी बेहतर दृश्य समझ देता है।

लूप फ़ंक्शन:

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

शून्य लूप () { अगर (शुरू == सच) {देरी = 3000; } // दबाया गया बटन पढ़ें = digitalRead (TouchSensor);

अगर (दबाया) {

अगर (पर == सच) {lc.clearDisplay(0); पर = झूठा; देरी (विलंब समय); } और { पर = सच; देरी (विलंब समय); }} सेंसरवैल्यू = एनालॉग रीड (सेंसरपिन); देरी (विलंब समय); if (on == true) {// ड्रा फेसेस राइटअर्डुइनोऑनमैट्रिक्स (); }

शुरू = सच;

}

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

कोड को Arduino पर पुश करना

अब जब हमने सभी कोड को कवर कर लिया है, तो इसे Arduino पर धकेलने का समय आ गया है! सौभाग्य से, आईडीई इसे बहुत आसान बनाता है। आपको बस अपने Arduino को USB केबल से अपने कंप्यूटर में प्लग करना है, और फिर IDE के ऊपर बाईं ओर दाएँ तीर पर क्लिक करना है। कोड को आगे बढ़ने दें, और यदि आपने इसे सही किया तो आपको प्रोग्राम के निचले भाग पर एक सफलता संदेश देखना चाहिए!

चरण 5: सर्किट आरेख

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

एलईडी डिस्प्ले:

• वीसीसी -> 5 वी
• जीआरडी -> जीआरडी
• दीन -> पिन 12
• सीएस -> पिन 10
• सीएलके -> पिन 11

नमी सेंसर:

• सकारात्मक -> 5V
• नकारात्मक -> जीआरडी
• सिग्नल -> A5

कैपेसिटिव टच सेंसर:

• वीसीसी -> 5वी
• जीआरडी -> जीआरडी
• एसआईजी -> 7

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

चरण 6: यह सब एक साथ रखना

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

बधाई हो! यदि सब कुछ सफलतापूर्वक हो गया, तो अब आपके पास पूरी तरह कार्यात्मक एपेक्स इकाई होनी चाहिए!

अपनी इकाई का परीक्षण करने के लिए, एक पानी वाला पौधा ढूंढें और उसे प्लग इन करें! आपको पता होना चाहिए कि यह या तो खुश है या हैरान है और इसका मतलब है कि इसे काम करना चाहिए !!! परियोजना को पूरा करने के लिए बढ़िया काम!

चरण 7: निष्कर्ष

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

(यह निर्देश एक पुराने प्रोजेक्ट, प्लांट इमोजी से प्रेरित था!)

पी.एस. यह निर्देश माइक्रोकंट्रोलर प्रतियोगिता में दर्ज किया गया है, इसलिए हमें वोट देना न भूलें! हम इसकी बहुत सराहना करते हैं:)

पी.पी.एस. आइए मेक मैगज़ीन में एपेक्स प्राप्त करें! यहां वोट करें! धन्यवाद:)