मैजिकबिट से सेल्फ बैलेंसिंग रोबोट: 6 कदम

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

यह ट्यूटोरियल दिखाता है कि मैजिकबिट देव बोर्ड का उपयोग करके सेल्फ बैलेंसिंग रोबोट कैसे बनाया जाता है। हम इस परियोजना में विकास बोर्ड के रूप में मैजिकबिट का उपयोग कर रहे हैं जो ईएसपी 32 पर आधारित है। इसलिए इस परियोजना में किसी भी ESP32 विकास बोर्ड का उपयोग किया जा सकता है।

आपूर्ति:

• मैजिकबिट
• दोहरी एच-ब्रिज एल२९८ मोटर चालक
• रैखिक नियामक (7805)
• लाइपो 7.4V 700mah बैटरी
• जड़त्वीय मापन इकाई (IMU) (स्वतंत्रता का 6 डिग्री)
• गियर मोटर्स 3V-6V डीसी

चरण 1: कहानी

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

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

चरण 2: सिद्धांत और कार्यप्रणाली

रोबोट को संतुलित करने के लिए सबसे पहले हमें किसी सेंसर से डेटा मिलता है जो रोबोट के कोण को ऊर्ध्वाधर तल तक मापता है। उस उद्देश्य के लिए हमने MPU6050 का उपयोग किया। सेंसर से डेटा प्राप्त करने के बाद हम झुकाव को लंबवत विमान की गणना करते हैं। यदि रोबोट सीधी और संतुलित स्थिति में है, तो झुकाव कोण शून्य है। यदि नहीं, तो झुकाव कोण धनात्मक या ऋणात्मक मान है। यदि रोबोट सामने की ओर झुका हुआ है, तो रोबोट को आगे की दिशा में जाना चाहिए। इसके अलावा अगर रोबोट रिवर्स साइड की ओर झुका हुआ है तो रोबोट को रिवर्स डायरेक्शन में जाना चाहिए। यदि यह झुकाव कोण अधिक है तो प्रतिक्रिया की गति अधिक होनी चाहिए। इसके विपरीत झुकाव कोण कम है तो प्रतिक्रिया की गति कम होनी चाहिए। इस प्रक्रिया को नियंत्रित करने के लिए हमने पीआईडी नामक विशिष्ट प्रमेय का उपयोग किया। पीआईडी एक नियंत्रण प्रणाली है जो कई प्रक्रियाओं को नियंत्रित करती थी। PID,3 प्रक्रियाओं के लिए खड़ा है।

• पी- आनुपातिक
• मैं- अभिन्न
• डी- व्युत्पन्न

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

पहला संख्यात्मक लाभ से गुणा त्रुटि है। इस लाभ को आमतौर पर केपी कहा जाता है।

पी = त्रुटि * केपी

दूसरा समय क्षेत्र में त्रुटि का अभिन्न अंग उत्पन्न करता है और इसे कुछ लाभ से गुणा करता है। इस लाभ को Ki. कहा जाता है

मैं = अभिन्न (त्रुटि) * Ki

तीसरा समय क्षेत्र में त्रुटि का व्युत्पन्न है और इसे कुछ मात्रा में लाभ से गुणा करें। इस लाभ को Kd. कहा जाता है

डी = (डी (त्रुटि) / डीटी) * केडी

उपरोक्त कार्यों को जोड़ने के बाद हमें अपना अंतिम आउटपुट मिलता है

OUTPUT=P+I+D

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

www.arrow.com/hi/research-and-events/articles/pid-controller-basics-and-tutorial-pid-implementation-in-arduino

PID फ़ंक्शन का आउटपुट 0-255 रेंज (8 बिट PWM रिज़ॉल्यूशन) तक सीमित है और यह PWM सिग्नल के रूप में मोटर्स को फीड करेगा।

चरण 3: हार्डवेयर सेटअप

अब यह हार्डवेयर सेटअप पार्ट है। रोबोट का डिजाइन आप पर निर्भर करता है। जब आप रोबोट के शरीर को डिजाइन करते हैं तो आपको इसे ऊर्ध्वाधर अक्ष के बारे में सममित करना होगा जो मोटर अक्ष में स्थित है। नीचे स्थित बैटरी पैक। इसलिए रोबोट को संतुलित करना आसान है। हमारे डिजाइन में हम मैजिकबिट बोर्ड को शरीर के लिए लंबवत रूप से ठीक करते हैं। हमने दो 12V गियर मोटर्स का इस्तेमाल किया। लेकिन आप किसी भी प्रकार के गियर मोटर्स का उपयोग कर सकते हैं। यह आपके रोबोट आयामों पर निर्भर करता है।

जब हम सर्किट के बारे में चर्चा करते हैं तो यह 7.4V लाइपो बैटरी द्वारा संचालित होता है। पावरिंग के लिए मैजिकबिट ने 5V का इस्तेमाल किया। इसलिए हमने बैटरी वोल्टेज को 5V पर रेगुलेट करने के लिए 7805 रेगुलेटर का इस्तेमाल किया। मैजिकबिट के बाद के संस्करणों में उस नियामक की आवश्यकता नहीं है। क्योंकि यह 12V तक पावर देता है। हम मोटर चालक के लिए सीधे 7.4V की आपूर्ति करते हैं।

नीचे दिए गए आरेख के अनुसार सभी घटकों को कनेक्ट करें।

चरण 4: सॉफ्टवेयर सेटअप

कोड में हमने पीआईडी आउटपुट की गणना के लिए पीआईडी लाइब्रेरी का उपयोग किया।

इसे डाउनलोड करने के लिए निम्न लिंक पर जाएं।

www.arduinolibraries.info/libraries/pid

इसका नवीनतम संस्करण डाउनलोड करें।

बेहतर सेंसर रीडिंग प्राप्त करने के लिए हमने डीएमपी लाइब्रेरी का इस्तेमाल किया। DMP,डिजिटल गति प्रक्रिया के लिए खड़ा है। यह MPU6050 का इनबिल्ट फीचर है। इस चिप में इंटीग्रेटेड मोशन प्रोसेस यूनिट है। तो यह पढ़ना और विश्लेषण करना लेता है। इसके बाद यह माइक्रोकंट्रोलर (इस मामले में मैजिकबिट (ESP32)) के लिए नीरव सटीक आउटपुट उत्पन्न करता है। लेकिन उस रीडिंग को लेने और कोण की गणना करने के लिए माइक्रोकंट्रोलर पक्ष में बहुत सारे काम हैं। तो बस इतना है कि हमने MPU6050 DMP लाइब्रेरी का इस्तेमाल किया। नीचे दिए गए लिंक पर जाकर इसे डाउनलोड करें।

github.com/ElectronicCats/mpu6050

पुस्तकालयों को स्थापित करने के लिए, Arduino मेनू में टूल्स-> लाइब्रेरी शामिल करें-> add.zip लाइब्रेरी पर जाएं और लाइब्रेरी फ़ाइल का चयन करें जिसे आपने डाउनलोड किया है।

कोड में आपको सेटपॉइंट एंगल को सही तरीके से बदलना होगा। PID स्थिरांक मान रोबोट से रोबोट में भिन्न होते हैं। तो उस ट्यूनिंग में, पहले Ki और Kd मानों को शून्य पर सेट करें और फिर Kp को तब तक बढ़ाएं जब तक आपको बेहतर प्रतिक्रिया गति न मिल जाए। अधिक Kp अधिक ओवरशूट का कारण बनता है। फिर केडी मान बढ़ाएँ। इसे हमेशा बहुत कम मात्रा में बढ़ाएं। यह मान आम तौर पर अन्य मूल्यों की तुलना में कम होता है। अब Ki को तब तक बढ़ाएं जब तक आपके पास बहुत अच्छी स्थिरता न हो।

सही COM पोर्ट का चयन करें और बोर्ड टाइप करें। कोड अपलोड करें। अब आप अपने DIY रोबोट के साथ खेल सकते हैं।

चरण 5: स्कैमैटिक्स

चरण 6: कोड

#शामिल

#include "I2Cdev.h" #include "MPU6050_6Axis_MotionApps20.h" #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE #include "Wire.h" #endif MPU6050 mpu; बूल डीएमपीरेडी = झूठा; // सही सेट करें यदि DMP init सफल uint8_t mpuIntStatus था; // एमपीयू uint8_t devStatus से वास्तविक इंटरप्ट स्थिति बाइट रखता है; // प्रत्येक डिवाइस ऑपरेशन के बाद वापसी की स्थिति (0 = सफलता, !0 = त्रुटि) uint16_t packageSize; // अपेक्षित डीएमपी पैकेट आकार (डिफ़ॉल्ट 42 बाइट्स है) uint16_t फीफोकाउंट; // वर्तमान में फीफो uint8_t फीफोबफर [64] में सभी बाइट्स की गिनती; // फीफो स्टोरेज बफर क्वाटरनियन क्यू; // [w, x, y, z] क्वाटरनियन कंटेनर वेक्टरफ्लोट ग्रेविटी; // [x, y, z] ग्रेविटी वेक्टर फ्लोट ypr[3]; // [यॉ, पिच, रोल] यॉ/पिच/रोल कंटेनर और ग्रेविटी वेक्टर डबल ओरिजिनलसेटपॉइंट = १७२.५; डबल सेटपॉइंट = मूलसेटपॉइंट; डबल मूविंगएंगलऑफसेट = 0.1; डबल इनपुट, आउटपुट; इंट मूवस्टेट = 0; डबल केपी = २३;//सेट पी पहले डबल केडी = ०.८;//यह मान आम तौर पर छोटा डबल की = ३००;//यह मान बेहतर स्थिरता के लिए उच्च होना चाहिए पीआईडी पिड(&इनपुट, &आउटपुट, &सेटपॉइंट, केपी, की, केडी, प्रत्यक्ष);//पिड इनिशियलाइज़ int motL1=26;//4 मोटर ड्राइव के लिए पिन int motL2=2; इंट मोटआर1=27; इंट मोटर२=४; अस्थिर बूल एमपीयूइंटरप्ट = झूठा; // इंगित करता है कि क्या एमपीयू इंटरप्ट पिन उच्च शून्य हो गया है dmpDataReady () {mpuInterrupt = true; } शून्य सेटअप() {ledcSetup(0, 20000, 8);//pwm सेटअप LEDcSetup(1, 20000, 8); एलईडीसेटअप (2, 20000, 8); एलईडीसेटअप (3, 20000, 8); LEDcAttachPin (motL1, 0); // मोटर्स का पिनमोड LEDcAttachPin (motL2, 1); LEDcAttachPin (motR1, 2); LEDcAttachPin (motR2, 3); // I2C बस में शामिल हों (I2Cdev पुस्तकालय स्वचालित रूप से ऐसा नहीं करता है) #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE Wire.begin (); वायर.सेटक्लॉक (400000); // 400kHz I2C घड़ी। संकलन में कठिनाई होने पर इस पंक्ति पर टिप्पणी करें #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE Fastwire::setup(400, true); #endif Serial.println(F("I2C डिवाइस को इनिशियलाइज़ कर रहा है…")); पिनमोड (14, इनपुट); // सीरियल कम्युनिकेशन को इनिशियलाइज़ करें // (115200 चुना गया क्योंकि यह चायदानी डेमो आउटपुट के लिए आवश्यक है, लेकिन यह आपके प्रोजेक्ट के आधार पर वास्तव में आप पर निर्भर है) Serial.begin(9600); जबकि (! सीरियल); // लियोनार्डो एन्यूमरेशन की प्रतीक्षा करें, अन्य तुरंत जारी रखें // डिवाइस को इनिशियलाइज़ करें Serial.println (F ("I2C डिवाइसेस को इनिशियलाइज़ करना …")); mpu.initialize (); // कनेक्शन सत्यापित करें Serial.println (F ("डिवाइस कनेक्शन का परीक्षण …")); Serial.println(mpu.testConnection() ? F("MPU6050 कनेक्शन सफल"): F("MPU6050 कनेक्शन विफल")); // DMP Serial.println को लोड और कॉन्फ़िगर करें (F ("DMP प्रारंभ करना …")); devStatus = mpu.dmpInitialize (); // यहां अपने स्वयं के जाइरो ऑफसेट की आपूर्ति करें, न्यूनतम संवेदनशीलता के लिए बढ़ाया गया है mpu.setXGyroOffset(220); mpu.setYGyroOffset(76); mpu.setZGyroOffset(-85); mpu.setZAccelOffset(1788); // मेरी टेस्ट चिप के लिए १६८८ फ़ैक्टरी डिफ़ॉल्ट ")); mpu.setDMPEnabled (सच); // Arduino इंटरप्ट डिटेक्शन को सक्षम करें Serial.println (F ("इंटरप्ट डिटेक्शन को सक्षम करना (Arduino एक्सटर्नल इंटरप्ट 0)…")); अटैचइंटरप्ट (14, dmpDataReady, RISING); mpuIntStatus = mpu.getIntStatus (); // हमारे डीएमपी रेडी फ्लैग को सेट करें ताकि मुख्य लूप () फ़ंक्शन को पता चले कि इसका उपयोग करना ठीक है। Serial.println (F ("डीएमपी तैयार! पहले इंटरप्ट की प्रतीक्षा कर रहा है …")); डीएमपीरेडी = सच; // बाद में तुलना के लिए अपेक्षित डीएमपी पैकेट आकार प्राप्त करें पैकेट आकार = mpu.dmpGetFIFOPacketSize (); // सेटअप PID pid. SetMode (स्वचालित); pid. SetSampleTime(10); pid. SetOutputLimits(-255, 255); } और {//त्रुटि! // 1 = प्रारंभिक मेमोरी लोड विफल // 2 = डीएमपी कॉन्फ़िगरेशन अपडेट विफल // (यदि यह टूटने वाला है, तो आमतौर पर कोड 1 होगा) सीरियल.प्रिंट (एफ ("डीएमपी इनिशियलाइज़ेशन विफल (कोड")); Serial. प्रिंट (devStatus); Serial.println (F (")")); } } शून्य लूप () {// यदि प्रोग्रामिंग विफल हो गई है, तो कुछ भी करने की कोशिश न करें अगर (! dmpReady) वापस आ जाए; // एमपीयू इंटरप्ट या अतिरिक्त पैकेट उपलब्ध होने की प्रतीक्षा करें, जबकि (!mpuInterrupt && fifoCount <पैकेटसाइज) {pid. Compute();//इस समय अवधि का उपयोग डेटा लोड करने के लिए किया जाता है, इसलिए आप इसका उपयोग अन्य गणना मोटरस्पीड के लिए कर सकते हैं (आउटपुट); } // इंटरप्ट फ्लैग को रीसेट करें और INT_STATUS बाइट mpuInterrupt = false प्राप्त करें; mpuIntStatus = mpu.getIntStatus (); // वर्तमान फीफो गणना प्राप्त करें फीफोकाउंट = एमपीयू.गेटफिफोकाउंट (); // अतिप्रवाह के लिए जाँच करें (यह तब तक नहीं होना चाहिए जब तक कि हमारा कोड बहुत अक्षम न हो) अगर ((mpuIntStatus & 0x10) || फीफोकाउंट == 1024) {// रीसेट करें ताकि हम सफाई से जारी रख सकें mpu.resetFIFO (); Serial.println (एफ ("फीफो अतिप्रवाह!")); // अन्यथा, डीएमपी डेटा रेडी इंटरप्ट की जांच करें (यह अक्सर होना चाहिए) } और अगर (mpuIntStatus और 0x02) {// सही उपलब्ध डेटा लंबाई के लिए प्रतीक्षा करें, तो बहुत कम प्रतीक्षा होनी चाहिए (फीफोकाउंट 1 पैकेट उपलब्ध // (यह बिना किसी रुकावट की प्रतीक्षा किए हमें तुरंत और अधिक पढ़ने देता है) फीफोकाउंट -= पैकेटसाइज; mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetGravity(&gravity, &q); mpu.dmpGetYawPitchRoll(ypr, &q, &gravity); #if LOG_INPUT सीरियल। प्रिंट ("ypr\t"); Serial.print(ypr[0] * 180/M_PI);//euler angle Serial.print("\t"); Serial.print(ypr[1] * 180/M_PI); Serial.print("\t"); Serial.println(ypr[2] * 180/M_PI); #endif input = ypr[1] * 180/M_PI + 180; } } void motorSpeed(int PWM){ float एल 1, एल 2, आर 1, आर 2; अगर (पीडब्लूएम> = 0) {// आगे की दिशा एल 2 = 0; एल 1 = एबीएस (पीडब्लूएम); आर 2 = 0; आर 1 = एबीएस (पीडब्लूएम); अगर (एल 1> = 255) { L1=R1=255; } } और {//पिछली दिशा L1=0; L2=abs(PWM); R1=0; R2=abs(PWM); अगर(L2>=255){ L2=R2=255; } } // मोटर ड्राइव LEDcWrite(0, L1);ledcWrite(1, L2);ledcWrite(2, R1*0.97);//0.97 स्पीड फैक्ट है या, क्योंकि दाहिनी मोटर में बायीं मोटर की तुलना में उच्च गति होती है, इसलिए हम इसे तब तक कम करते हैं जब तक कि मोटर की गति बराबर नहीं हो जाती है LEDcWrite(3, R2*0.97);

}