Arduino पर AC वाल्टमीटर। Arduino पर आधारित ब्लूटूथ वाल्टमीटर

Arduino Uno पर और 1602A डिस्प्ले के साथ होममेड बाइपोलर वोल्टमीटर का योजनाबद्ध आरेख। लेख "ARDUINO UNO पर डबल वोल्टमीटर" (L.1) में, लेखक ने एक वोल्टमीटर का विवरण और दो स्थिर वोल्टेज के एक साथ माप और संकेत के लिए एक कार्यक्रम का प्रस्ताव दिया। यदि आपको एक ही समय में दो निरंतर वोल्टेज को मापने और उनकी तुलना करने की आवश्यकता है तो यह बहुत सुविधाजनक है।

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

हालाँकि, द्विध्रुवी शक्ति वाले सर्किट होते हैं, जब सामान्य "शून्य" के सापेक्ष सर्किट में किसी बिंदु पर वोल्टेज या तो सकारात्मक या नकारात्मक हो सकता है।

सर्किट आरेख

यह वर्णन करता है कि सर्किट और प्रोग्राम को कैसे संशोधित किया जाए ताकि डिवाइस सकारात्मक और नकारात्मक दोनों वोल्टेज को माप सके और इंगित कर सके।

आरंभ करने के लिए, मापा गया वोल्टेज दो एनालॉग इनपुट A1 और A2 को खिलाया जाता है। कुल छह एनालॉग इनपुट हैं, - A0-A5, आप उनमें से कोई भी दो चुन सकते हैं। इस स्थिति में, A1 और A2 का चयन किया जाता है। एनालॉग पोर्ट पर वोल्टेज केवल सकारात्मक हो सकता है और केवल शून्य से माइक्रोकंट्रोलर आपूर्ति वोल्टेज की सीमा के भीतर, यानी नाममात्र रूप से 5V तक हो सकता है।

एनालॉग पोर्ट के आउटपुट को माइक्रोकंट्रोलर के ADC द्वारा डिजिटल रूप में परिवर्तित किया जाता है। वोल्ट की इकाइयों में परिणाम प्राप्त करने के लिए, आपको इसे 5 से गुणा करना होगा (संदर्भ वोल्टेज द्वारा, यानी माइक्रोकंट्रोलर आपूर्ति वोल्टेज द्वारा) और 1024 से विभाजित करना होगा।

चावल। 1. Arduino Uno और 1602A पर द्विध्रुवी वोल्टमीटर का योजनाबद्ध आरेख।

5V से अधिक के वोल्टेज को मापने में सक्षम होने के लिए, या माइक्रोकंट्रोलर की आपूर्ति वोल्टेज से अधिक, क्योंकि ARDUINO UNO बोर्ड पर 5-वोल्ट नियामक के आउटपुट पर वास्तविक वोल्टेज 5V से भिन्न हो सकता है, और आमतौर पर थोड़ा कम, आपको इनपुट पर साधारण प्रतिरोधक डिवाइडर का उपयोग करने की आवश्यकता होती है।

यहां, ये प्रतिरोधक R1, R3 और R2, R4 पर वोल्टेज डिवाइडर हैं। लेकिन क्या होगा यदि वोल्टेज को शून्य से कम मापने की आवश्यकता हो? इस मामले में, केवल एक ही रास्ता है - इनपुट शून्य स्तर को ऊपर उठाना। आदर्श रूप से, आपको आधे आपूर्ति वोल्टेज की आवश्यकता है, यानी 2.5V तक। वहीं, इनपुट वोल्टेज में 2.5V डेटा जोड़ा जाएगा।

फिर, प्रोग्रामेटिक रूप से, इस वोल्टेज को मापे गए वोल्टेज से आसानी से घटा दिया जाता है। लेकिन, इसके लिए इस वोल्टेज के एक अतिरिक्त स्रोत की आवश्यकता होगी। सिद्धांत रूप में, ऐसा करना मुश्किल नहीं है, लेकिन एक आसान समाधान है।

5V वोल्टेज रेगुलेटर के अलावा, ARDUINO UNO बोर्ड में 3.3V वोल्टेज स्रोत भी है। यहां इसे प्रवेश के लिए "आभासी शून्य" के रूप में उपयोग किया जा सकता है।

सर्किट में परिवर्तन चित्र 1 में दिखाई दे रहे हैं। पहले विकल्प की तुलना में, इनपुट "शून्य" को सामान्य शून्य से +3.3V स्रोत में पुनर्व्यवस्थित किया जाता है। इसलिए, जब इनपुट वोल्टेज सकारात्मक होता है, तो यह इनपुट पर 3.3V से अधिक होता है (लेकिन 5V से अधिक नहीं - यह माप की ऊपरी सीमा है), और जब यह नकारात्मक होता है - 3.3V से कम (लेकिन OV से कम नहीं) - यह माप की निचली सीमा है)।

माप सीमा (मॉड्यूलो) में वृद्धि एक प्रतिरोधक विभक्त द्वारा प्राप्त की जाती है, और माइक्रोकंट्रोलर इनपुट पर वोल्टेज से 3.3V के मान को सॉफ्टवेयर घटाकर X2 और X3 को आपूर्ति की गई वास्तविक इनपुट वोल्टेज का संकेत दिया जाता है।

कार्यक्रम तालिका 1 में दिखाया गया है। इसे पंक्तियों में देखा जा सकता है:

वोल्ट=(वाउट*5.0/1024.0-3.3)/0.048;

वोल्टएल=(वाउटएल*5.0/1024.0-3.3)/0.048;

संख्या 3.3 इनपुट के "आभासी शून्य" का दिया गया वोल्टेज मात्र है।

इन पंक्तियों में, संख्या 5.0 ARDUINO UNO बोर्ड स्टेबलाइज़र के आउटपुट पर वोल्टेज है। आदर्श रूप से, यह 5V होना चाहिए, लेकिन वोल्टमीटर के सटीक संचालन के लिए, इस वोल्टेज को पहले मापा जाना चाहिए। बिजली की आपूर्ति कनेक्ट करें और पर्याप्त सटीक वोल्टमीटर के साथ बोर्ड के पावर कनेक्टर पर +5V वोल्टेज को मापें।

जो भी हो, फिर 5.0 के बजाय इन पंक्तियों में दर्ज करें। यही बात वोल्टेज + 3.3V पर भी लागू होती है - इसे बोर्ड कनेक्टर पर मापा जाना चाहिए, क्योंकि वास्तव में यह 3.3V से थोड़ा भिन्न हो सकता है। उदाहरण के लिए, यदि "5V" वास्तव में 4.85V है और "3.3V" वास्तव में 3.32V है, तो लाइनें इस तरह दिखेंगी:

वोल्ट=(vout*4.85/1024.0-3.32)/0.048;

वोल्टएल=(वाउटएल*4.85/1024.0-3.32)/0.048;

अगले चरण में, प्रतिरोधों R1-R4 के वास्तविक प्रतिरोधों को मापना और सूत्रों का उपयोग करके इन रेखाओं के लिए K गुणांक (0.048 इंगित किए गए हैं) निर्धारित करना आवश्यक होगा:

K1 = R3 / (R1+R3) और K2 = R4 / (R2+R4)

मान लीजिए K1 = 0.046, और K2 = 0.051, इसलिए हम लिखते हैं:

वोल्ट=(vout*4.85/1024.0-3.32)/0.046;

वोल्टएल=(वाउटएल*4.85/1024.0-3.32)/0.051;

इस प्रकार, प्रोग्राम के पाठ को ARDUINO UNO बोर्ड के 5-वोल्ट और 3.3-वोल्ट स्टेबलाइजर्स के आउटपुट पर वास्तविक वोल्टेज और प्रतिरोधी डिवाइडर के वास्तविक विभाजन अनुपात के अनुसार संशोधित करने की आवश्यकता है।

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

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

मैं आपको याद दिलाना चाहता हूं कि 1602A प्रकार का H1 लिक्विड क्रिस्टल डिस्प्ले मॉड्यूल ARDUINO UNO बोर्ड के डिजिटल पोर्ट D2-D7 से जुड़ा है। एलसीडी संकेतक 5V वोल्टेज रेगुलेटर द्वारा संचालित होता है, जो 5V वोल्टेज रेगुलेटर बोर्ड पर उपलब्ध होता है।

संकेतक को ARDUINO UNO के साथ इंटरैक्ट करने के लिए, आपको इसे नियंत्रित करने के लिए प्रोग्राम में एक सबरूटीन लोड करना होगा। ऐसी दिनचर्या को "लाइब्रेरी" कहा जाता है, और ARDUINO UNO के सॉफ़्टवेयर पैकेज में कई अलग-अलग "लाइब्रेरी" हैं। HD44780 आधारित एलसीडी डिस्प्ले के लिए लिक्विड क्रिस्टल लाइब्रेरी की आवश्यकता होती है। इसलिए, प्रोग्राम (तालिका 1) इस लाइब्रेरी को लोड करके शुरू होता है:

यह पंक्ति इस लाइब्रेरी को ARDUINO UNO में लोड करने का निर्देश देती है। इसके बाद, आपको ARDUINO UNO पोर्ट असाइन करने की आवश्यकता है जो एलसीडी संकेतक के साथ काम करेगा। मैंने D2 से D7 तक पोर्ट का चयन किया है। आप दूसरों को चुन सकते हैं. ये पोर्ट स्ट्रिंग द्वारा असाइन किए गए हैं:

लिक्विडक्रिस्टल एलईडी(2, 3, 4, 5, 6, 7);

उसके बाद, प्रोग्राम वोल्टमीटर के वास्तविक संचालन के लिए आगे बढ़ता है।

करावकिन वी. आरके-06-17.

साहित्य: 1. करावकिन वी. - ARDUINO UNO पर डबल वोल्टमीटर। आरके-01-17.

Arduino बोर्ड के एनालॉग इनपुट।

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

इन पिनों की संख्या 14 से 19 है। इन्हें प्रारंभ में एनालॉग इनपुट के रूप में स्थापित किया गया है और इन्हें A0-A5 के रूप में संदर्भित किया जा सकता है। किसी भी समय, उन्हें अलग-अलग आउटपुट के मोड में कॉन्फ़िगर किया जा सकता है।

पिनमोड(ए3, आउटपुट); // A3 के लिए असतत आउटपुट मोड सेट करना
डिजिटलराइट(ए3, लो); // आउटपुट A3 को कम पर सेट करना

एनालॉग इनपुट मोड पर लौटने के लिए:

पिनमोड(ए3, इनपुट); // A3 के लिए एनालॉग इनपुट मोड सेट करना

एनालॉग इनपुट और पुल-अप रेसिस्टर्स।

पुल-अप रेसिस्टर्स एनालॉग इनपुट पिन के साथ-साथ डिजिटल पिन से भी जुड़े होते हैं। इन प्रतिरोधों का समावेशन कमांड द्वारा किया जाता है

डिजिटलराइट(ए3, हाई); // इनपुट A3 पर पुल-अप रेसिस्टर चालू करें

कमांड को इनपुट मोड में कॉन्फ़िगर किए गए आउटपुट पर लागू किया जाना चाहिए।

यह याद रखना चाहिए कि अवरोधक इनपुट एनालॉग सिग्नल के स्तर को प्रभावित कर सकता है। पुल-अप रेसिस्टर के माध्यम से 5V बिजली आपूर्ति से करंट, सिग्नल स्रोत के आंतरिक प्रतिरोध में वोल्टेज गिरावट का कारण बनेगा। इसलिए अवरोधक को बंद करना बेहतर है।

एनालॉग-टू-डिजिटल कनवर्टर बोर्ड Arduino।

इनपुट पर वास्तविक वोल्टेज माप 6 चैनलों के स्विच के साथ एक एनालॉग-टू-डिजिटल कनवर्टर (एडीसी) द्वारा किया जाता है। एडीसी का रिज़ॉल्यूशन 10 बिट्स है, जो कनवर्टर आउटपुट कोड 0...1023 से मेल खाता है। माप त्रुटि न्यूनतम महत्वपूर्ण अंक की 2 इकाइयों से अधिक नहीं है।

अधिकतम सटीकता (10 अंक) बनाए रखने के लिए, यह आवश्यक है कि सिग्नल स्रोत का आंतरिक प्रतिरोध 10 kΩ से अधिक न हो। बोर्ड के एनालॉग इनपुट से जुड़े रेसिस्टर डिवाइडर का उपयोग करते समय यह आवश्यकता विशेष रूप से महत्वपूर्ण है। विभक्त प्रतिरोधकों का प्रतिरोध बहुत बड़ा नहीं हो सकता।

एनालॉग इनपुट सॉफ़्टवेयर फ़ंक्शन।

पूर्णांक एनालॉग रीड (पोर्ट)

निर्दिष्ट एनालॉग इनपुट पर वोल्टेज मान पढ़ता है। 0 से वोल्टेज संदर्भ स्तर (अक्सर 5 V) तक के इनपुट वोल्टेज को 0 से 1023 तक के कोड में परिवर्तित किया जाता है।

5 V के संदर्भ वोल्टेज के साथ, रिज़ॉल्यूशन 5 V / 1024 = 4.88 mV है।

इसे परिवर्तित होने में लगभग 100 μs लगते हैं।

पूर्णांक इनपुटकोड; // इनपुट वोल्टेज कोड
फ़्लोट इनपुटवोल्टेज; // V में इनपुट वोल्टेज

इनपुटकोड=एनालॉगरीड(ए3); // इनपुट A3 पर वोल्टेज पढ़ें
इनपुटवोल्टेज= ((फ्लोट)इनपुटकॉड * 5./1024.); // वोल्टेज में रूपांतरण कोड (वी)

शून्य एनालॉग संदर्भ (प्रकार)

ADC के लिए संदर्भ वोल्टेज सेट करता है। यह अधिकतम एनालॉग इनपुट वोल्टेज को परिभाषित करता है जिसे एडीसी सही ढंग से परिवर्तित कर सकता है। संदर्भ वोल्टेज का मान कोड को वोल्टेज में परिवर्तित करने के लिए गुणांक भी निर्धारित करता है:

इनपुट वोल्टेज = एडीसी कोड * संदर्भ वोल्टेज / 1024।

प्रकार तर्क निम्नलिखित मान ले सकता है:

• डिफ़ॉल्ट - संदर्भ वोल्टेज नियंत्रक आपूर्ति वोल्टेज (5 वी या 3.3 वी) के बराबर है। Arduino UNO R3 के लिए - 5 V.
• आंतरिक - ATmega168 और ATmega328 नियंत्रकों वाले बोर्डों के लिए आंतरिक संदर्भ वोल्टेज 1.1 V, ATmega8 के लिए - 2.56 V।
• INTERNAL1V1 - Arduino मेगा नियंत्रकों के लिए 1.1 V आंतरिक संदर्भ वोल्टेज।
• INTERNAL2V56 - Arduino मेगा नियंत्रकों के लिए 2.56V आंतरिक संदर्भ वोल्टेज।
• बाहरी - बाहरी संदर्भ वोल्टेज स्रोत, एआरईएफ इनपुट से जुड़ा हुआ है।

एनालॉगरेफरेंस(आंतरिक); // संदर्भ वोल्टेज 1.1 V है

Arduino पर दो-चैनल वाल्टमीटर।

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

हम निर्णय लेते हैं कि वोल्टमीटर को कम से कम 0 ... 20 V की सीमा में वोल्टेज मापना चाहिए और वोल्टमीटर इनपुट को Arduino UNO बोर्ड से जोड़ने के लिए एक सर्किट विकसित करना चाहिए।

यदि हम संदर्भ वोल्टेज को 5 V पर सेट करते हैं, तो बोर्ड के एनालॉग इनपुट 0 ... 5 V की सीमा में वोल्टेज को मापेंगे। और हमें कम से कम 0 ... 20 V की आवश्यकता है। इसलिए हमें एक का उपयोग करने की आवश्यकता है वोल्टेज विभक्त।

विभक्त के इनपुट और आउटपुट पर वोल्टेज संबंध से संबंधित हैं:

यूआउट = (यूइन / (आर1 + आर2)) * आर2

ट्रांसमिशन अनुपात:

के = यूआउट / यूइन = आर2 / (आर1 + आर2)

हमें 1/4 लाभ (20V * 1/4 = 5V) की आवश्यकता है।

अधिकतम सटीकता (10 अंक) बनाए रखने के लिए, यह आवश्यक है कि सिग्नल स्रोत का आंतरिक प्रतिरोध 10 kΩ से अधिक न हो। इसलिए, हम 4.22 kOhm के बराबर रोकनेवाला R2 चुनते हैं। हम रोकनेवाला R1 के प्रतिरोध की गणना करते हैं।

0.25 = 4.22 / (आर1 + 4.22)
आर1 = 4.22 / 0.25 - 4.22 = 12.66 कोहम

मुझे निकटतम रेटिंग के साथ 15 kOhm के प्रतिरोध वाले प्रतिरोधक मिले। प्रतिरोधों R1 = 15 kΩ और R2 = 4.22 के साथ:

5 / (4.22 / (15 + 4.22)) = 22.77 वी.

Arduino पर आधारित वोल्टमीटर सर्किट इस तरह दिखेगा।

दो वोल्टेज डिवाइडर एनालॉग इनपुट A0 और A1 से जुड़े हुए हैं। कैपेसिटर C1 और C2, डिवाइडर रेसिस्टर्स के साथ मिलकर, लो-पास फिल्टर बनाते हैं जो सिग्नल से उच्च-आवृत्ति शोर को हटाते हैं।

मैंने इस सर्किट को ब्रेडबोर्ड पर इकट्ठा किया।

मैंने वोल्टमीटर के पहले इनपुट को एक विनियमित बिजली आपूर्ति से जोड़ा, और दूसरे को Arduino बोर्ड की 3.3 V आपूर्ति से जोड़ा। वोल्टेज को नियंत्रित करने के लिए, मैंने एक वोल्टमीटर को पहले इनपुट से जोड़ा। प्रोग्राम लिखना बाकी है।

Arduino बोर्ड का उपयोग करके वोल्टेज मापने का एक कार्यक्रम।

एल्गोरिथ्म सरल है. ज़रूरी:

• एडीसी कोड को प्रति सेकंड दो बार पढ़ें;
• इसे वोल्टेज में परिवर्तित करें;
• मापे गए मानों को सीरियल पोर्ट के माध्यम से कंप्यूटर पर भेजें;
• Arduino IDE पोर्ट मॉनिटर प्रोग्राम कंप्यूटर स्क्रीन पर प्राप्त वोल्टेज मान प्रदर्शित करता है।

मैं कार्यक्रम का पूरा खाका पेश करूंगा.

// वोल्टेज माप कार्यक्रम
// एनालॉग इनपुट A0 और A1 पर

#शामिल करना

माप अवधि समय
#आर1 को परिभाषित करें 15. // रोकनेवाला R1
#आर2 4.22 को परिभाषित करें // रोकनेवाला R2

फ्लोट u1, u2; // मापा वोल्टेज

व्यर्थ व्यवस्था()(
सीरियल.शुरू(9600); //

MsTimer2::start(); // व्यवधान सक्षम करें
}

शून्य लूप() (

// अवधि 500 ​​एमएस
यदि (समय गणना >= माप_अवधि) (
समय गणना=0;

//

// चैनल 2 कोड पढ़ना और वोल्टेज में परिवर्तित करना
यू2= ((फ्लोट)एनालॉगरीड(ए1)) * 5. / 1024. / आर2 * (आर1 + आर2);

// सीरियल पोर्ट के माध्यम से डेटा स्थानांतरण
सीरियल.प्रिंट('U1='); सीरियल प्रिंट(u1, 2);
सीरियल.प्रिंट('U2='); सीरियल.प्रिंटएलएन(u2, 2);
}
}

// इंटरप्ट प्रोसेसिंग 1 एमएस
शून्य टाइमरइंटरप्ट() (
टाइमकाउंट++;
}

मैं उस लाइन की व्याख्या करता हूं जिसमें एडीसी कोड को वोल्टेज में परिवर्तित किया जाता है:

// चैनल 1 कोड पढ़ना और वोल्टेज में परिवर्तित करना
यू1= ((फ्लोट)एनालॉगरीड(ए0)) * 5. / 1024. / आर2 * (आर1 + आर2);

• एडीसी कोड पढ़ा जाता है: AnalogRead(A0) ।
• स्पष्ट रूप से फ़्लोटिंग पॉइंट प्रारूप में परिवर्तित: (फ़्लोट)।
• एनालॉग इनपुट पर वोल्टेज में परिवर्तित: * 5./1024। संख्याओं के अंत में बिंदु इंगित करता है कि यह एक फ्लोटिंग पॉइंट संख्या है।
• विभाजक अनुपात को ध्यान में रखा जाता है: / R2 * (R1 + R2) .

आइए प्रोग्राम को बोर्ड में लोड करें, सीरियल पोर्ट मॉनिटर शुरू करें।

दो रनिंग बार मापे गए वोल्टेज के मान दिखाते हैं। सब कुछ काम कर रहा है.

सिग्नल का औसत मान मापना.

आइए अपने वोल्टमीटर के पहले चैनल को उच्च स्तर के तरंग वाले वोल्टेज स्रोत से कनेक्ट करें। ऐसी तस्वीर हमें मॉनिटर पर दिखेगी.

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

इसके अलावा, यदि सिग्नल को अलग-अलग दुर्लभ नमूनों में पढ़ा जाता है, तो कोई भी आवेग शोर माप में एक महत्वपूर्ण त्रुटि ला सकता है।

समाधान यह है कि कई बार-बार नमूने लिए जाएं और मापे गए मान का औसत निकाला जाए। इसके लिए:

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

8वीं कक्षा की गणित पाठ्यपुस्तक से एक कार्य। यहां प्रोग्राम का एक स्केच है, एक दो-चैनल औसत मूल्य वोल्टमीटर।

// मध्यम वोल्टेज माप कार्यक्रम
// एनालॉग इनपुट A0 और A1 पर

#शामिल करना

#माप_अवधि 500 ​​परिभाषित करें // माप अवधि समय
#आर1 को परिभाषित करें 15. // रोकनेवाला R1
#आर2 4.22 को परिभाषित करें // रोकनेवाला R2

पूर्णांक समय गणना; // समय काउंटर
लंबा sumU1, sumU2; // एडीसी कोड के योग के लिए चर
लंबी उपलब्धतायू1, उपलब्धतायू2; // एडीसी कोड का योग (औसत * 500)
बूलियन ध्वज तैयार; // माप डेटा की तैयारी का संकेत

व्यर्थ व्यवस्था()(
सीरियल.शुरू(9600); // पोर्ट प्रारंभ करें, गति 9600
MsTimer2::set(1, टाइमरइंटरप्ट); // टाइमर व्यवधान, अवधि 1 एमएस
MsTimer2::start(); // व्यवधान सक्षम करें
}

शून्य लूप() (

यदि (फ़्लैगरेडी == सत्य) (
फ़्लैगरेडी=झूठा;
// वोल्टेज में रूपांतरण और कंप्यूटर में स्थानांतरण
सीरियल.प्रिंट('U1=');
सीरियल.प्रिंट((फ्लोट)एवरेजयू1 / 500. * 5. / 1024. / आर2 * (आर1 + आर2), 2);
सीरियल.प्रिंट('U2=');
सीरियल.प्रिंटएलएन((फ्लोट)एवरेजयू2 / 500. * 5. / 1024. / आर2 * (आर1 + आर2), 2);
}
}

// इंटरप्ट प्रोसेसिंग 1 एमएस
शून्य टाइमरइंटरप्ट() (

टाइमकाउंट++; // +1 औसत नमूना काउंटर
sumU1+= AnalogRead(A0); // एडीसी कोड का योग
sumU2+= AnalogRead(A1); // एडीसी कोड का योग

// औसत नमूनों की संख्या की जाँच करना
यदि (समय गणना >= माप_अवधि) (
समय गणना=0;
उपलब्धताU1=sumU1; // माध्य मान अधिभार
avarageU2=sumU2; // माध्य मान अधिभार
योगयू1= 0;
sumU2=0;
फ़्लैगरेडी = सत्य; // साइन माप परिणाम तैयार है
}
}

/500, नमूनों की संख्या, एडीसी कोड को वोल्टेज में परिवर्तित करने के सूत्र में जोड़ा गया था। लोड करें, पोर्ट मॉनिटर चलाएं (Cntr + Shift + M)।

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

नमूनों की संख्या को ध्यान में रखते हुए चुना जाना चाहिए:

• नमूनों की संख्या माप समय निर्धारित करती है;
• नमूनों की संख्या जितनी अधिक होगी, हस्तक्षेप का प्रभाव उतना ही कम होगा।

एनालॉग सिग्नल में हस्तक्षेप का मुख्य स्रोत 50 हर्ट्ज नेटवर्क है। इसलिए, ऐसा औसत समय चुनना वांछनीय है जो 10 एमएस का गुणक हो - 50 हर्ट्ज की आवृत्ति के साथ नेटवर्क का आधा-चक्र समय।

गणना का अनुकूलन.

फ़्लोटिंग पॉइंट गणनाएँ केवल 8-बिट माइक्रोकंट्रोलर के संसाधनों को ख़त्म करती हैं। किसी भी फ़्लोटिंग पॉइंट ऑपरेशन के लिए मंटिसा डीनॉर्मलाइज़ेशन, फिक्स्ड पॉइंट ऑपरेशन, मंटिसा नॉर्मलाइज़ेशन, एक्सपोनेंट करेक्शन... और 32 बिट नंबरों के साथ सभी ऑपरेशन की आवश्यकता होती है। इसलिए, फ्लोटिंग पॉइंट गणनाओं के उपयोग को कम करना आवश्यक है। मैं आपको अगले पाठों में यह कैसे करना है बताऊंगा, लेकिन आइए कम से कम अपनी गणनाओं को अनुकूलित करें। प्रभाव महत्वपूर्ण होगा.

हमारे प्रोग्राम में, ADC कोड का वोल्टेज में रूपांतरण इस प्रकार लिखा गया है:

(फ्लोट)avageU1 / 500. * 5. / 1024. / R2 * (R1 + R2)

कितने कैलकुलेशन हैं और सब फ्लोटिंग पॉइंट हैं. लेकिन अधिकांश गणनाएँ स्थिरांक के साथ संक्रियाएँ हैं। पंक्ति भाग:

/ 500. * 5. / 1024. / आर2 * (आर1 + आर2)

(फ्लोट)avageU1 * 0.00004447756

स्मार्ट कंपाइलर स्वयं स्थिरांक के साथ गणनाओं को पहचानते हैं और संकलन समय पर उनकी गणना करते हैं। मेरा एक प्रश्न था कि एंड्रूइनो का कंपाइलर कितना स्मार्ट है। जाँच करने का निर्णय लिया गया।

मैंने एक छोटा कार्यक्रम लिखा. यह 10,000 पासों का एक चक्र निष्पादित करता है और फिर इन 10,000 चक्रों के निष्पादन समय को कंप्यूटर तक पहुंचाता है। वे। यह आपको लूप बॉडी में रखे गए ऑपरेशनों के निष्पादन समय को देखने की अनुमति देता है।

// गणना अनुकूलन जाँच

पूर्णांक x= 876;
फ्लोट वाई;
अहस्ताक्षरित पूर्णांक गिनती;
अहस्ताक्षरित लंबे समयवर्तमान, समयपूर्व;

व्यर्थ व्यवस्था()(
सीरियल.शुरू(9600);
}

शून्य लूप() (
गिनती++;
// y= (फ्लोट)x / 500. * 5. / 1024. / 4.22 * (15. + 4.22);
// y= (फ्लोट)x * 0.00004447756 ;

यदि (गिनती>=10000) (
गिनती=0;
timeCurrent=मिलिस();
सीरियल.प्रिंटएलएन(टाइमकरंट - टाइमप्रेव);
समयपूर्व=समयवर्तमान;
}
}

पहले संस्करण में, जब फ़्लोटिंग-पॉइंट ऑपरेशंस पर टिप्पणी की जाती है और लूप में निष्पादित नहीं किया जाता है, तो प्रोग्राम ने 34 एमएस का परिणाम दिया।

वे। 10,000 खाली चक्र 34ms में पूरे होते हैं।

फिर मैंने पंक्ति खोली:

y= (फ्लोट)x / 500. * 5. / 1024. / 4.22 * (15. + 4.22);

हमारी गणना दोहराता है. परिणाम 922 एमएस में 10,000 पास या

(922 - 34) / 10,000 = 88.8 µs.

वे। फ़्लोटिंग पॉइंट गणना की इस पंक्ति को पूरा होने में 89 µs लगते हैं। मुझे लगा कि और भी बहुत कुछ होगा.

अब मैंने इस पंक्ति को एक टिप्पणी के साथ बंद कर दिया और अगली पंक्ति को, पूर्व-गणना किए गए स्थिरांक से गुणा करके खोला:

y= (फ्लोट)x * 0.00004447756;

परिणाम 166 एमएस में 10,000 पास या

(166 - 34) / 10,000 = 13.2 μs।

अद्भुत परिणाम. हमने प्रति पंक्ति 75.6 μs की बचत की। इसे करीब 7 गुना तेजी से पूरा किया. हमारे पास ऐसी 2 पंक्तियाँ हैं। लेकिन कार्यक्रम में इनकी संख्या और भी बहुत कुछ हो सकती है।

निष्कर्ष - स्थिरांक के साथ गणना स्वयं कैलकुलेटर पर की जानी चाहिए और कार्यक्रमों में तैयार गुणांक के रूप में उपयोग की जानी चाहिए। Arduino कंपाइलर संकलन चरण में उनकी गणना नहीं करेगा। हमारे मामले में, हमें यह करना चाहिए:

#ADC_U_COEFF 0.00004447756 को परिभाषित करें // वोल्टेज रूपांतरण कारक के लिए एडीसी कोड

सीरियल.प्रिंट((फ्लोट)avageU1 * ADC_U_COEFF, 2);

इष्टतम गति विकल्प एडीसी कोड को कंप्यूटर में स्थानांतरित करना है, और इसके साथ सभी फ़्लोटिंग-पॉइंट गणनाएं। इस मामले में, एक विशेष प्रोग्राम को कंप्यूटर पर डेटा प्राप्त करना चाहिए। Arduino IDE से पोर्ट मॉनिटर काम नहीं करेगा।

मैं भविष्य के पाठों में आवश्यकतानुसार Arduino प्रोग्राम को अनुकूलित करने के अन्य तरीकों के बारे में बात करूंगा। लेकिन इस समस्या को हल किए बिना, 8-बिट माइक्रोकंट्रोलर पर जटिल प्रोग्राम विकसित करना असंभव है।

एनालॉग सिग्नल को मापने के लिए समर्पित साइट () पर एक और पाठ दिखाई दिया। यह पृष्ठभूमि में ADC के संचालन से संबंधित है।

अगले पाठ में, हम सीखेंगे कि आंतरिक EEPROM के साथ कैसे काम करें, आइए डेटा अखंडता नियंत्रण के बारे में बात करें।

यह आलेख दिखाता है कि Arduino और PC को कैसे कनेक्ट करें और ADC से PC में डेटा कैसे स्थानांतरित करें। विंडोज़ प्रोग्राम विज़ुअल C++ 2008 एक्सप्रेस का उपयोग करके लिखा गया था। वोल्टमीटर प्रोग्राम बहुत सरल है और इसमें सुधार की काफी गुंजाइश है। इसका मुख्य उद्देश्य COM पोर्ट के साथ काम करना और कंप्यूटर और Arduino के बीच डेटा के आदान-प्रदान को दिखाना था।

Arduino और PC के बीच संचार:

• ADC से रीडिंग लेना तब शुरू होता है जब कंप्यूटर Arduino को 0xAC और 0x1y कमांड भेजता है। पर- एडीसी चैनल नंबर (0-2);
• Arduino को 0xAC और 0x00 कमांड प्राप्त होने के बाद रीडिंग बंद हो जाती है;
• रीडिंग के दौरान, Arduino प्रत्येक 50 एमएस पर कंप्यूटर को 0xAB 0xaa 0xbb कमांड भेजता है, जहां aa और bb अधिकतम और न्यूनतम माप हैं।

Arduino के लिए कार्यक्रम

आप धारावाहिक संचार के बारे में arduino.cc पर अधिक पढ़ सकते हैं। प्रोग्राम काफी सरल है, इसका अधिकांश भाग समानांतर पोर्ट के साथ काम करता है। ADC से डेटा पढ़ने के अंत के बाद, हमें 16-बिट वेरिएबल्स (INT) के रूप में 10-बिट वोल्टेज मान (0x0000 - 0x0400) मिलता है। सीरियल पोर्ट (आरएस-232) आपको 8 बिट के पैकेट में डेटा स्थानांतरित करने की अनुमति देता है। 16-बिट वेरिएबल्स को 8 बिट्स के 2 भागों में विभाजित करना आवश्यक है।

सीरियल.प्रिंट(वोल्टेज>>8,बाइट);

सीरियल.प्रिंट(वोल्टेज%256,बाइट);

हम वेरिएबल 8 बिट्स के बाइट्स को दाईं ओर शिफ्ट करते हैं और फिर 256 से विभाजित करते हैं और परिणाम कंप्यूटर को भेजते हैं।

आप Arduino सॉफ़्टवेयर के लिए पूर्ण स्रोत कोड डाउनलोड कर सकते हैं।

विज़ुअल सी++

मैं मान रहा हूं कि आपको विंडोज़ के लिए C++ प्रोग्रामिंग का बुनियादी ज्ञान पहले से ही है, यदि नहीं तो Google का उपयोग करें। इंटरनेट शुरुआती लोगों के लिए ट्यूटोरियल से भरा है।

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

उपलब्ध सीरियल पोर्ट की खोज करने के बाद, पहला पोर्ट डिफ़ॉल्ट रूप से चुना जाता है। यह कैसे किया है:

सरणी< String ^>^सीरियलपोर्ट्स=nullptr;

सीरियलपोर्ट्स = सीरियलपोर्ट1->गेटपोर्टनाम();

यह->कॉम्बोबॉक्स1->आइटम->एडरेंज(सीरियलपोर्ट);

यह->comboBox1->SelectedIndex=0;

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

सीरियलपोर्ट1->ओपन();

सीरियलपोर्ट1->बंद करें();

सीरियल पोर्ट से डेटा को सही ढंग से पढ़ने के लिए, आपको इवेंट (हमारे मामले में, इंटरप्ट) का उपयोग करना होगा। ईवेंट प्रकार चुनें:

"DataReceived" पर डबल-क्लिक करने पर ड्रॉप-डाउन सूची।

इवेंट कोड स्वचालित रूप से उत्पन्न होता है:

यदि सीरियल पोर्ट पर आया पहला बाइट 0xAB है, तो इसका मतलब है कि बाकी बाइट्स वोल्टेज डेटा ले जाते हैं।

निजी: सिस्टम::शून्य सीरियलपोर्ट1_डेटारिसीव्ड(सिस्टम::ऑब्जेक्ट^ प्रेषक, सिस्टम::आईओ::पोर्ट्स::सीरियलडेटारिसीव्डइवेंटआर्ग्स^ ई) (

अहस्ताक्षरित चार डेटा0, डेटा1;

यदि (serialPort1->ReadByte()==0xAB) (

data0=serialPort1->ReadByte();

डेटा1=सीरियलपोर्ट1->रीडबाइट();

वोल्टेज=गणित::गोल((फ्लोट(डेटा0*256+डेटा1)/1024*5.00),2);

डेटा_काउंट++;

सीरियलपोर्ट1->रीडबाइट();

सीरियल पोर्ट डेटा लिखना और पढ़ना

मेरे लिए, एक छोटी सी समस्या सीरियल पोर्ट के माध्यम से हेक्स रॉ डेटा भेजने की थी। लिखें() कमांड का उपयोग किया गया था; लेकिन तीन तर्कों के साथ: सरणी, प्रारंभ बाइट संख्या, लिखने के लिए बाइट्स की संख्या।

निजी: सिस्टम::शून्य बटन2_क्लिक_1(सिस्टम::ऑब्जेक्ट^ प्रेषक, सिस्टम::इवेंटआर्ग्स^ ई) (

अहस्ताक्षरित चार चैनल=0;

चैनल=यह->सूचीबॉक्स1->चयनितसूचकांक;

सरणी^प्रारंभ =(0xAC,(0x10+चैनल));

सरणी^स्टॉप =(0xAC,0x00);

सीरियलपोर्ट1->लिखें(प्रारंभ,0,2);

यह->बटन2->पाठ='रोकें';

) अन्य (

सीरियलपोर्ट1->लिखें(रोकें,0,2);

यह->बटन2->पाठ='प्रारंभ';

बस इतना ही!

अंग्रेजी में मूल लेख (अनुवाद: अलेक्जेंडर कास्यानोव cxem.net साइट के लिए)