ARDUINO ऊर्जा मीटर: 10 कदम (चित्रों के साथ)

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

[वीडियो चलाएं]

मैं भारत के ओडिशा के एक गाँव से ताल्लुक रखता हूँ जहाँ बार-बार बिजली कटना बहुत आम बात है। यह हर किसी के जीवन में बाधा डालता है। मेरे बचपन के दिनों में शाम के बाद पढ़ाई जारी रखना एक वास्तविक चुनौती थी। इस समस्या के कारण मैंने प्रायोगिक आधार पर अपने घर के लिए सोलर सिस्टम तैयार किया। मैंने कुछ चमकीले एल ई डी को जलाने के लिए 10 वाट, 6 वी के सौर पैनल का उपयोग किया। काफी मुश्किलों का सामना करने के बाद यह परियोजना सफल हुई। फिर मैंने सिस्टम में शामिल वोल्टेज, करंट, पावर और एनर्जी की निगरानी करने का फैसला किया। इसने एक ऊर्जा मीटर डिजाइन करने का विचार लाया। मैंने इस परियोजना के दिल के रूप में ARDUINO का उपयोग किया क्योंकि इसकी IDE में कोड लिखना बहुत आसान है और इंटरनेट में बड़ी संख्या में ओपन सोर्स लाइब्रेरी उपलब्ध है जिसका उपयोग इसके अनुसार किया जा सकता है आवश्यकता है। मैंने बहुत छोटे रेटेड (10 वाट) सौर प्रणाली के लिए परियोजना का प्रयोग किया है लेकिन इसे उच्च रेटिंग प्रणाली के उपयोग के लिए आसानी से संशोधित किया जा सकता है।

आप मेरे सभी प्रोजेक्ट यहां देख सकते हैं:

फ़ीचर: 1.एलसीडी डिस्प्ले द्वारा ऊर्जा की निगरानी 2. इंटरनेट के माध्यम से (Xively अपलोड) 3. एसडी कार्ड में डेटा लॉगिंग

आप मेरा नया निर्देश योग्य ARDUINO MPPT सोलर चार्ज कंट्रोलर (संस्करण-3.0) देख सकते हैं

आप मेरे अन्य अनुदेशक भी देख सकते हैं

ARDUINO सोलर चार्ज कंट्रोलर (संस्करण 2.0)

ARDUINO सोलर चार्ज कंट्रोलर (संस्करण -1)

चरण 1: आवश्यक भाग:

1. ARDUINO UNO (अमेज़ॅन)2. ARDUINO ईथरनेट शील्ड (अमेज़ॅन)

3. 16x2 कैरेक्टर एलसीडी (अमेज़ॅन)

4. एसीएस 712 करंट सेंसर (अमेज़ॅन)4. प्रतिरोधी (10k, 330ohm) (अमेज़ॅन) 5। 10K पोटेंशियोमीटर (अमेज़ॅन)6. जम्पर वायर्स (अमेज़ॅन)7. ईथरनेट केबल (अमेज़ॅन)8. ब्रेड बोर्ड (अमेज़न)

चरण 2: शक्ति और ऊर्जा

पावर: पावर वोल्टेज (वोल्ट) और करंट (Amp) का उत्पाद है P=VxI पावर की यूनिट वाट या KWEnergy है: ऊर्जा पावर (वाट) और समय (घंटे) का उत्पाद है E= Pxt ऊर्जा की यूनिट वाट घंटा या किलोवाट है घंटा (kWh) उपरोक्त सूत्र से यह स्पष्ट है कि ऊर्जा को मापने के लिए हमें तीन मापदंडों की आवश्यकता होती है 1. वोल्टेज 2. वर्तमान 3. समय

चरण 3: वोल्टेज मापन

वोल्टेज को वोल्टेज डिवाइडर सर्किट की मदद से मापा जाता है। चूंकि ARDUINO एनालॉग पिन इनपुट वोल्टेज 5V तक सीमित है, इसलिए मैंने वोल्टेज डिवाइडर को इस तरह से डिज़ाइन किया है कि इससे आउटपुट वोल्टेज 5V से कम होना चाहिए। मेरी बैटरी का उपयोग स्टोर करने के लिए किया जाता है सौर पैनल से बिजली 6v, 5.5Ah रेटेड है। इसलिए मुझे इस 6.5v को 5V से कम वोल्टेज पर ले जाना होगा। मैंने R1=10k और R2 =10K का उपयोग किया। R1 और R2 का मान एक कम हो सकता है लेकिन समस्या यह है कि जब प्रतिरोध कम होता है तो इसके माध्यम से उच्च धारा प्रवाहित होती है जिसके परिणामस्वरूप बड़ी मात्रा में बिजली (P = I^2R) गर्मी के रूप में नष्ट हो जाती है। तो अलग प्रतिरोध मूल्य चुना जा सकता है लेकिन प्रतिरोध के पार बिजली के नुकसान को कम करने के लिए देखभाल की जानी चाहिए। Vout=R2/(R1+R2)*Vbat Vbat=6.5 पूरी तरह चार्ज होने पर R1=10k और R2=10k Vout=10/(10+10)*6.5=3.25v जो कि 5v से कम है और ARDUINO एनालॉग पिन के लिए उपयुक्त है। बेयर बोर्ड सर्किट में 9 वोल्ट की बैटरी दिखाई गई है, उदाहरण के लिए तारों को जोड़ने के लिए। लेकिन मैंने जो वास्तविक बैटरी इस्तेमाल की है वह 6 वोल्ट, 5.5Ah लेड एसिड बैटरी है। वोल्टेज कैलिब्रेशन: जब बैटरी पूरी तरह से चार्ज हो जाती है (6.5v) हम प्राप्त करेंगे एक वाउट = 3.25 वी और अन्य कम बैटरी वोल्टेज के लिए कम मूल्य। AEDUINO ADC एनालॉग सिग्नल को संबंधित डिजिटल सन्निकटन में परिवर्तित करता है। जब बैटरी वोल्टेज 6.5v होता है तो मुझे वोल्टेज डिवाइडर से 3.25v और सीरियल मॉनीटर में नमूना 1 = 696 मिला, जहां नमूना 1 एडीसी मान 3.25v से मेल खाता है बेहतर समझ के लिए मैंने वोल्टेज माप अंशांकन के लिए 123D.circuit द्वारा रीयल टाइम सिमुलेशन संलग्न किया है: 3.25v 696 1 के बराबर है 3.25/696=4.669mv Vout = (4.669*sample1)/1000 वोल्ट वास्तविक बैटरी वोल्टेज = (2*Vout) voltARDUINO CODE: // 2sec के अंतराल के साथ वोल्टेज डिवाइडर से 150 नमूने लेना और फिर (int i=0;i<150;i++) {sample1=sample1+analogRead(A2); // विभक्त सर्किट देरी से वोल्टेज पढ़ें (2); } नमूना1=नमूना1/150; वोल्टेज = 4.669 * 2 * नमूना 1/1000;

चरण 4: वर्तमान मापन

वर्तमान माप के लिए मैंने हॉल इफेक्ट करंट सेंसर ACS 712 (20 A) का उपयोग किया। बाजार में विभिन्न वर्तमान रेंज ACS712 सेंसर उपलब्ध हैं, इसलिए अपनी आवश्यकता के अनुसार चुनें। ब्रेड बोर्ड आरेख में मैंने एलईडी को लोड के रूप में दिखाया है लेकिन वास्तविक भार अलग है। कार्य सिद्धांत: हॉल प्रभाव एक विद्युत कंडक्टर में वोल्टेज अंतर (हॉल वोल्टेज) का उत्पादन होता है, जो कंडक्टर में विद्युत प्रवाह के लिए अनुप्रस्थ होता है और धारा के लंबवत चुंबकीय क्षेत्र। हॉल इफेक्ट सेंसर के बारे में अधिक जानने के लिए यहां क्लिक करें एसीएस 712 सेंसर की डेटा शीट यहां डेटा शीट से मिली है। एसीएस 712 सकारात्मक और नकारात्मक 20 एएमपीएस मापता है, एनालॉग आउटपुट 100 एमवी / ए 2 के अनुरूप है। VCC/2 =5v/2=2.5Vअंशांकन: एनालॉग रीड 0-1023 का मान उत्पन्न करता है, जो 0v से 5v के बराबर होता है इसलिए एनालॉग रीड 1 = (5/1024) V =4.89mv मान = (4.89*एनालॉग रीड वैल्यू)/ 1000 V लेकिन डेटा शीट के अनुसार ऑफसेट 2.5V है (जब वर्तमान शून्य आपको सेंसर के आउटपुट से 2.5V मिलेगा) वास्तविक मूल्य = (मान-2.5) V वर्तमान में amp = वास्तविक मूल्य * 10ARDUINO CODE: // 150 नमूने ले रहा है 2 सेकंड के अंतराल के साथ सेंसर और फिर (int i=0;i<150;i++) {sample2+=analogRead(A3); // सेंसर देरी से करंट पढ़ें (2); } नमूना2=नमूना2/150; वैल =(5.0*नमूना2)/1024.0; वास्तविक = वैल-2.5; // ऑफसेट वोल्टेज 2.5v amps = वास्तविक * 10 है;

चरण 5: समय मापन

समय मापने के लिए किसी बाहरी हार्डवेयर की आवश्यकता नहीं है, क्योंकि ARDUINO में ही इनबिल्ट टाइमर है। मिलिस () फ़ंक्शन मिलीसेकंड की संख्या लौटाता है क्योंकि Arduino बोर्ड ने वर्तमान कार्यक्रम चलाना शुरू किया था। ARDUINO CODE: long milisec = मिलिस (); // मिलीसेकंड में समय की गणना करें लंबे समय = मिलीसेकंड/1000; // मिलीसेकंड को सेकंड में बदलें

चरण 6: कैसे ARDUINO शक्ति और ऊर्जा की गणना करता है

टोटैम्प्स = टोटैम्प्स + एम्प्स; // कुल amps avgamps = totamps / समय की गणना करें; // औसत amps amphr=(avgamps*time)/3600; // amp-घंटे वाट = वोल्टेज * amps; // शक्ति = वोल्टेज * वर्तमान ऊर्जा = (वाट * समय) / 3600; 1hr(3600sec)//ऊर्जा=(वाट*समय)/(1000*3600); kWh. में पढ़ने के लिए

चरण 7: दृश्य आउटपुट

सभी परिणाम सीरियल मॉनिटर में या एलसीडी का उपयोग करके देखे जा सकते हैं। मैंने पिछले चरणों में प्राप्त सभी परिणामों को प्रदर्शित करने के लिए 16x2 वर्ण एलसीडी का उपयोग किया। योजनाबद्ध के लिए ऊपर दिखाए गए ब्रेड बोर्ड सर्किट को देखें। एलसीडी को ARDUINO के साथ नीचे दिए गए अनुसार कनेक्ट करें: LCD -> Arduino 1. VSS -> Arduino GND 2. VDD - > Arduino +5v 3. VO -> Arduino GND पिन + रेसिस्टर या पोटेंशियोमीटर 4. RS -> Arduino pin 8 5. RW -> Arduino pin 7 6. E -> Arduino pin 6 7. D0 -> Arduino - कनेक्टेड नहीं 8 D1 -> Arduino - कनेक्ट नहीं है 9. D2 -> Arduino - कनेक्ट नहीं है 10. D3 -> Arduino - कनेक्ट नहीं है 11. D4 -> Arduino पिन 5 12. D5 -> Arduino पिन 4 13. D6 -> Arduino पिन 3 14. D7 -> Arduino pin 2 15. A -> Arduino Pin 13 + Resistor (बैकलाइट पावर) 16. K -> Arduino GND (बैकलाइट ग्राउंड) ARDUINO CODE: सीरियल मॉनिटर के लिए:

सीरियल.प्रिंट ("वोल्टेज:"); सीरियल.प्रिंट (वोल्टेज); Serial.println ("वोल्ट"); सीरियल.प्रिंट ("वर्तमान:"); सीरियल.प्रिंट (amps); Serial.println ("एम्प्स"); सीरियल.प्रिंट ("पावर:"); सीरियल.प्रिंट (वाट); Serial.println ("वाट"); सीरियल.प्रिंट ("ऊर्जा की खपत:"); सीरियल.प्रिंट (ऊर्जा); Serial.println ("वाट-घंटा"); सीरियल.प्रिंट्लन (""); // रिक्त लाइन विलंब (2000) के बाद पैरामीटर के अगले सेट को प्रिंट करें; एलसीडी के लिए: एलसीडी डिस्प्ले के लिए आपको पहले "लिक्विड क्रिस्टल" लाइब्रेरी को कोड में आयात करना होगा। LequidCrystal लाइब्रेरी के बारे में अधिक जानने के लिए यहां क्लिक करें LCD ट्यूटोरियल के लिए यहां क्लिक करें निम्नलिखित कोड LCD में प्रदर्शित करने के लिए पावर और ऊर्जा के लिए सभी गणनाओं को प्रदर्शित करने के लिए एक प्रारूप है #include LCD(8, 7, 6, 5, 4, 3, 2); इंट बैकलाइट = 9; शून्य सेटअप () {पिनमोड (बैकलाइट, आउटपुट); // आउटपुट एनालॉग के रूप में पिन 9 सेट करें (बैकलाइट, 150); // बैकलाइट की तीव्रता को नियंत्रित करता है 0-254 LCD.begin (16, 2); // स्तंभ पंक्तियां। डिस्प्ले का आकार LCD.clear (); // स्क्रीन साफ़ करें} शून्य लूप () {lcd.setCursor (16, 1); // कर्सर को डिस्प्ले काउंट के बाहर सेट करें LCD.print(""); // खाली वर्ण विलंब प्रिंट करें (600); //////////////////////////////////////// एलसीडी को पावर और ऊर्जा प्रिंट करें/ //////////////////////////////////////////// LCD.setCursor (१, ०); // कर्सर को पहली कॉल और पहली पंक्ति के LCD.प्रिंट (वाट) पर सेट करें; एलसीडी.प्रिंट ("डब्ल्यू"); एलसीडी.प्रिंट (वोल्टेज); एलसीडी.प्रिंट ("वी"); LCD.setCursor(1, 1); // कर्सर को पहली और दूसरी पंक्ति के LCD.print (ऊर्जा) पर सेट करें; एलसीडी.प्रिंट ("डब्ल्यूएच"); LCD.प्रिंट (amps); एलसीडी.प्रिंट ("ए"); }

चरण 8: Xively.com पर डेटा अपलोड करना

बेहतर अंडरस्टैंडिंग के लिए उपरोक्त स्क्रीनशॉट देखें। xively.com पर डेटा अपलोड करने के लिए निम्नलिखित लाइब्रेरी को पहले डाउनलोड किया जाना है HttpClient: यहां क्लिक करेंXively: यहां क्लिक करेंSPI: arduino IDE से आयात करें (स्केच -> इम्पोर्ट लाइब्रेरी…..) ईथरनेट: arduino से आयात करें आईडीई ((स्केच -> आयात पुस्तकालय…..) https://xively.com (पूर्व में pachube.com और cosm.com) के साथ एक खाता खोलें https://xively.com पर एक निःशुल्क डेवलपर खाते के लिए साइन अप करें

एक उपयोगकर्ता नाम, पासवर्ड चुनें, अपना पता और समय क्षेत्र आदि सेट करें। आपको एक पुष्टिकरण ईमेल प्राप्त होगा;

फिर अपने खाते को सक्रिय करने के लिए सक्रियण लिंक पर क्लिक करें। सफलतापूर्वक खाता खोलने के बाद आपको विकास उपकरण पृष्ठ पर भेज दिया जाएगा

• +डिवाइस जोड़ें बॉक्स पर क्लिक करें
• अपने डिवाइस और विवरण को एक नाम दें (उदा. ऊर्जा निगरानी)·
• निजी या सार्वजनिक डेटा चुनें (मैं निजी चुनता हूं)·
• डिवाइस जोड़ें पर क्लिक करें

डिवाइस जोड़ने के बाद आपको एक नए पेज पर ले जाया जाता है जहां कई महत्वपूर्ण जानकारी होती है

• प्रोडक्ट आईडी, प्रोडक्ट सीक्रेट, सीरियल नंबर, एक्टिवेशन कोड·
• फ़ीड आईडी, FeedURL, API एंड पॉइंट (फ़ीड आईडी का उपयोग ARDUINO कोड में किया जाता है)
• चैनल जोड़ें (INERGY और POWER चुनें, लेकिन आप अपनी पसंद के अनुसार चुन सकते हैं)पैरामीटर के लिए यूनिट और सिंबल दें।
• अपना स्थान जोड़ें ·
• API कुंजियाँ (ARDUINO कोड में प्रयुक्त, इस नंबर को साझा करने से बचें)·
• ट्रिगर (किसी घटना के घटित होने पर वेब पेज को पिंग करना, जैसे कि जब ऊर्जा की खपत एक निश्चित सीमा से अधिक हो)

चरण 9: Xively और ARDUINO कोड

यहां मैंने एसडी कार्ड डेटा लॉगिंग को छोड़कर ऊर्जा मीटर के लिए पूरा कोड (बीटा संस्करण) संलग्न किया है जो अगले चरण में अलग से संलग्न है। /** ऊर्जा निगरानी डेटा xively पर अपलोड करें **/ #include #include #include #define API_KEY "xxxxxxxx" // अपनी Xively API कुंजी दर्ज करें #FEED_ID xxxxxxxxx को परिभाषित करें // अपना Xively फ़ीड आईडी दर्ज करें // अपने लिए मैक पता दर्ज करें ईथरनेट शील्ड बाइट मैक = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED}; // एनालॉग पिन जिसकी हम निगरानी कर रहे हैं (0 और 1 ईथरनेट शील्ड द्वारा उपयोग किए जाते हैं) int sensorPin = 2; अहस्ताक्षरित लंबे पिछले कनेक्शन समय = 0; // पिछली बार जब हम Cosm const अहस्ताक्षरित लंबे कनेक्शन से जुड़े थेइंटरवल = 15000; // मिलीसेकंड में Cosm से कनेक्ट होने में देरी // Cosm लाइब्रेरी को इनिशियलाइज़ करें // हमारे डेटास्ट्रीम ID char sensorId = "POWER" के लिए स्ट्रिंग को परिभाषित करें; चार सेंसरआईड२ = "ऊर्जा"; XivelyDatastream डेटास्ट्रीम = {XivelyDatastream (sensorId, strlen (sensorId), DATASTREAM_FLOAT), XivelyDatastream (sensorId2, strlen (sensorId2), DATASTREAM_FLOAT), DATASTREAM_FLOAT),}; // डेटास्ट्रीम को एक फ़ीड में लपेटें XivelyFeed फ़ीड(FEED_ID, डेटास्ट्रीम, 2 /* डेटास्ट्रीम की संख्या */); ईथरनेट क्लाइंट क्लाइंट; XivelyClient xivelyclient (क्लाइंट); शून्य सेटअप () {Serial.begin (९६००); Serial.println ("नेटवर्क प्रारंभ करना"); जबकि (ईथरनेट.बेगिन (मैक)! = 1) { Serial.println ("डीएचसीपी के माध्यम से आईपी पता प्राप्त करने में त्रुटि, फिर से प्रयास करना …"); देरी (15000); } Serial.println ("नेटवर्क इनिशियलाइज़्ड"); सीरियल.प्रिंट्लन (); } शून्य लूप () { अगर (मिली () - लास्टकनेक्शनटाइम> कनेक्शनइंटरवल) {sendData (); // xively getData () को डेटा भेजें; // डेटास्ट्रीम को xively lastConnectionTime = मिलिस () से वापस पढ़ें; // कनेक्शन समय अपडेट करें ताकि हम फिर से कनेक्ट होने से पहले प्रतीक्षा करें } } void sendData() {int sensor1 = वाट; इंट सेंसर2 = ऊर्जा; डेटास्ट्रीम [0]। सेटफ्लोट (सेंसर 1); // पावर वैल्यू डेटास्ट्रीम [1]। सेटफ्लोट (सेंसर 2); // ऊर्जा मूल्य सीरियल.प्रिंट ("पावर पढ़ें"); Serial.println (डेटास्ट्रीम [0]। getFloat ()); Serial.print ("ऊर्जा पढ़ें"); Serial.println(datastreams[1].getFloat()); Serial.println ("Xively पर अपलोड करना"); int ret = xivelyclient.put (फ़ीड, API_KEY); Serial.print ("रिटर्न कोड डालें:"); सीरियल.प्रिंट्लन (सेवानिवृत्त); सीरियल.प्रिंट्लन (); } // xively से डेटास्ट्रीम का मान प्राप्त करें, हमें प्राप्त मूल्य को प्रिंट करना शून्य getData() { Serial.println ("Xively से डेटा पढ़ना"); इंट रेट = xivelyclient.get (फ़ीड, API_KEY); Serial.print ("रिटर्न कोड प्राप्त करें:"); सीरियल.प्रिंट्लन (सेवानिवृत्त); अगर (रिट> 0) {सीरियल.प्रिंट ("डेटास्ट्रीम है:"); Serial.println (फ़ीड [0]); सीरियल.प्रिंट ("पावर वैल्यू है:"); Serial.println (फ़ीड [0]। getFloat ()); Serial.print ("डेटास्ट्रीम है:"); Serial.println (फ़ीड [1]); Serial.print ("ऊर्जा मान है:"); Serial.println (फ़ीड [1]। getFloat ()); } सीरियल.प्रिंट्लन ();

चरण 10: एसडी कार्ड में डेटा लॉगिंग

एसडी कार्ड में डेटा स्टोर करने के लिए आपको एसडी लाइब्रेरी को आयात करना होगा ट्यूटोरियल के लिए यहां क्लिक करें एसडी लाइब्रेरी के बारे में अधिक जानने के लिए यहां क्लिक करें एसडी कार्ड में डेटा स्टोर करने के लिए कोड अलग से लिखा जाता है क्योंकि मेरे पास मेरे ARDUINO UNO में पर्याप्त मेमोरी नहीं है एलसीडी डिस्प्ले और डेटा अपलोड करने के लिए कोड लिखना xively.com। लेकिन मैं बीटा संस्करण कोड में सुधार करने की कोशिश कर रहा हूं ताकि एक कोड में सभी सुविधाएं (एलसीडी डिस्प्ले, एक्सिवली डेटा अपलोडिंग और एसडी कार्ड में डेटा स्टोरिंग) शामिल हो सकें। डेटा लॉगिंग के लिए कोड नीचे संलग्न है। यदि कोई एक लिखता है मेरे कोड को संशोधित करके बेहतर कोड कृपया मेरे साथ साझा करें। यह मेरा पहला तकनीकी निर्देश है, अगर किसी को इसमें कोई गलती मिलती है, तो बेझिझक टिप्पणी करें.. ताकि मैं खुद को सुधार सकूं। यदि आपको इस परियोजना में सुधार के क्षेत्र मिलते हैं तो कृपया टिप्पणी करें या मुझे संदेश भेजें, तो परियोजना अधिक शक्तिशाली होगी। मुझे लगता है कि यह दूसरों के साथ-साथ मेरे लिए भी मददगार होगा।

१२३डी सर्किट प्रतियोगिता में तीसरा पुरस्कार