🌺 ⏮️ 🥓 Arduino पर एक बैलेंसर रोबोट बनाना 👩‍🎓 ↕️ 💞

एक लंबे समय के लिए मुझे कुछ जटिल तंत्र की गणना करने और उसके जीवन का एहसास करने की इच्छा से प्रेतवाधित किया गया था।

विकल्प उलटे पेंडुलम की समस्या पर गिर गया। वीडियो का परिणाम:

गणितीय मॉडल

मैं गति के समीकरणों की व्युत्पत्ति नहीं दूंगा, सभी समान हैं, यह संस्थान का तीसरा पाठ्यक्रम है। जो लोग निष्कर्ष में रुचि रखते हैं, उनके लिए लेख के अंत में एक लिंक है जहां इसे और अधिक विवरण में वर्णित किया गया है।

हम निम्नलिखित रूप में सिस्टम का प्रतिनिधित्व करते हैं:

एक पेंडुलम एक द्रव्यमान m _{p है} जो लंबाई l के भारहीन छड़ के अंत से जुड़ा होता है। शाफ्ट के दूसरे छोर से एक मोटर जुड़ी हुई है, जो अधिकतम क्षण M _{k को} विकसित कर रही है और इसे मास m _w और त्रिज्या r के एक पहिये तक पहुंचाती है।

नियंत्रण कार्य एक लंबवत स्थिति में पेंडुलम को स्थिर करना और पहिया को अपनी प्रारंभिक स्थिति में वापस करना है।

उलटे पेंडुलम का वर्णन करने वाली गति के समीकरणों को निम्नानुसार दर्शाया जा सकता है:

वे बल्कि अप्रिय लगते हैं, लेकिन रोबोट खुद उनके बारे में कुछ नहीं जानता है, और नियंत्रण एक रैखिक मॉडल का उपयोग करता है, अर्थात:

सिंथेसाइजिंग नियंत्रण

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

मतलाब में, नियंत्रक की गणना आदेशों का एक समूह है:

A=[0 1.0 0 0;0 0 -140 0;0 0 0 1.0;0 0 28 0] B=[0;212.85;0;-19.15] Q=[5 0 0 0;0 5 0 0;0 0 1 0;0 0 0 1] R=1500 [K,S,e]=lqr(A,B,Q,R)

यहाँ, वास्तविक A रोबोट के प्रतिस्थापित मूल्यों के साथ मेट्रिसेस A और B रेखीयकृत मॉडल से संबंधित मैट्रिक्स हैं।

क्यू मैट्रिक्स यह निर्धारित करता है कि हमारे मामले में मूल, नोट से भटकने के लिए सिस्टम को कितना जुर्माना लगाने की आवश्यकता है, समन्वय में गति शामिल है।

मैट्रिक्स आर यह निर्धारित करता है कि नियंत्रण द्वारा ऊर्जा की बर्बादी के लिए सिस्टम को कितना जुर्माना करने की आवश्यकता है।

चर K में नियंत्रक के गुणांक होंगे।

सिमुलेशन

मतलाब सिमुलिंक में, आप आसानी से एक प्रणाली का अनुकरण कर सकते हैं यदि किसी को लेख के अंत में एक गणितीय मॉडल के साथ भंडार का लिंक चाहिए। यहाँ मैं केवल रेखांकन दूंगा।

पेंडुलम विक्षेपण कोण:

पहिया विक्षेपण कोण:

इंजन टोक़:

लोहे में बोध

रोबोट का फ्रेम स्वयं एल्यूमीनियम प्रोफाइल 12 मिमी और 14 मिमी है, वे एक दूसरे में प्रवेश करते हैं। Rivets द्वारा जुड़ा हुआ है। इलेक्ट्रॉनिक्स अक्षर T के रूप में फाइबरग्लास के एक टुकड़े से जुड़े होते हैं। मोटर्स को एक फाइबर ग्लास एडाप्टर के माध्यम से भी जोड़ा जाता है।

प्रारंभ में, मैंने इन मोटर्स का उपयोग करने की कोशिश की:

इनका टॉर्क 2.2kg * cm या 0.2Nm है। सिमुलेशन के आधार पर, हमें और अधिक की आवश्यकता है, इसलिए अन्य मोटर्स को चुना गया:

निर्माता संदर्भ

अधिकतम टोक़ 14 किग्रा * सेमी या 1.4Nm। वे 5 ए तक वर्तमान का उपभोग करते हैं, इसलिए Arduino ड्राइवरों के बीच लोकप्रिय L293D, यहां काम नहीं करेगा।

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

वे विभिन्न फिल्टर का उपयोग करते हैं, लेकिन सबसे लोकप्रिय हैं कलमन फ़िल्टर और आरसी फ़िल्टर (पूरक फ़िल्टर)। मैं इस तरह कोड का उपयोग कर रहा हूं:

 float lastCompTime=0; float filterAngle=1.50; float dt=0.005; float comp_filter(float newAngle, float newRate) { dt=(millis()-lastCompTime)/1000.0; float filterTerm0; float filterTerm1; float filterTerm2; float timeConstant; timeConstant=0.5; filterTerm0 = (newAngle - filterAngle) * timeConstant * timeConstant; filterTerm2 += filterTerm0 * dt; filterTerm1 = filterTerm2 + ((newAngle - filterAngle) * 2 * timeConstant) + newRate; filterAngle = (filterTerm1 * dt) + filterAngle; lastCompTime=millis(); return filterAngle; }

यह पूरी तरह से काम नहीं करता है, लेकिन इस कार्य के लिए पर्याप्त है।

अगला सेंसर मोटर पर एक क्वाडरेचर एनकोडर है। यह अपने आउटपुट में से 2 पर आयताकार दालों को उत्पन्न करता है:

उन्हें या तो व्यवधान माना जा सकता है या लूप में मूल्यों को पढ़कर। Arduino खेल के मैदान में कोड उदाहरण के साथ एक शानदार लेख है ।

यह पहिया के कोणीय वेग को प्राप्त करने के लिए बनी हुई है। यहां स्कूल का फार्मूला तय की गई दूरी / समय की सहायता के लिए आता है।

 #define ToPhiRad(x) ((x)*0.00280357142) timer_old = timer; timer=millis(); G_Dt = (timer-timer_old)/1000.0; dPhi=(ToPhiRad(encoder0Pos)-lastPhi)/G_Dt;

ToPhiRad एनकोडर के टिक्स की संख्या को पहिया के कोने में अनुवाद करता है, मेरा एनकोडर प्रति क्रांति लगभग 2240 टिक्स उत्पन्न करता है। कोण प्राप्त करने के लिए आपको टिक्कों को 2 पाई से गुणा करना होगा और पूर्ण पहिया घुमाव पर उनकी संख्या से विभाजित करना होगा।

सेंसर रीडिंग LQR कंट्रोलर के पास जाती है:

 float K1=0.1,K2=0.29,K3=6.5,K4=1.12; long getLQRSpeed(float phi,float dphi,float angle,float dangle){ return constrain((phi*K1+dphi*K2+K3*angle+dangle*K4)*285,-400,400); }

Matlab से गुणांक लिया जाता है, हालांकि स्थिरता के लिए मैंने पहले 2 गुणांक को सही किया।

मेरा ड्राइवर, या इसकी लाइब्रेरी, -400 से 400 तक मान लेता है। मैंने माना कि 400 में यह 12V मोटर देता है, अर्थात्। मोटर एक अधिकतम टोक़ (1.4Nm) विकसित करता है। 400 को 1.4 से विभाजित करने पर, हमें Nm से रूपांतरण कारक मिलता है, जो LQR को देता है, ऐसे मान जो ड्राइवर के लिए समझ में आते हैं।

बस एक बिंदु पर रोबोट को स्थिर करना बहुत दिलचस्प नहीं है, इसलिए बीटी-मॉड्यूल एचसी -05 को इसमें जोड़ा गया। मॉड्यूल माइक्रोकंट्रोलर के सीरियल पोर्ट से जुड़ा हुआ है। यह 5V पर 3.3V, और Arduino पर काम करता है, इसलिए आपको वोल्टेज डिवाइडर के माध्यम से मॉड्यूल के प्राप्त इनपुट को कनेक्ट करना होगा। यहाँ कनेक्शन आरेख है:

चक्र के दौरान, माइक्रोकंट्रोलर पात्रों के लिए मॉड्यूल को प्रदूषित करता है:

 float phiDif=0.f; float factorDif=0.f; float getPhiAdding(float dif){ //       - if(dif<200 && dif>-200){return 0.f;} float ret = dif*0.08; return ret; } float getFactorAdding(float dif){//      if(dif<200 && dif>-200){return 0.f;} float ret = dif/500*20; return ret; } //======== if (Serial.available()){ BluetoothData=Serial.read(); if(BluetoothData=='w'){ phiDif=200; } else if(BluetoothData=='s'){ phiDif=-200; } else if(BluetoothData=='a'){ factorDif=200; } else if(BluetoothData=='d'){ factorDif=-200; } else if(BluetoothData=='c'){ factorDif=0; phiDif=0; } }

अंततः, सेंसर रीडिंग नियामक के पास जाते हैं, और इसका नियंत्रण और उपयोगकर्ता प्रभाव मोटरों पर जाता है:

  encoder0Pos+=getPhiAdding(phiDif); lastPhi=ToPhiRad(encoder0Pos); spd=getLQRSpeed(ToPhiRad(encoder0Pos),dPhi,balanceAt-angle,gyroRate[coordY]); float factorL=getFactorAdding(factorDif); md.setSpeeds(spd-factorL,spd+factorL);

हर 50 मिलीसेकंड में एक बार रोबोट का टेलीमेट्री कोण भेजा जाता है:

  if(millis()%50==0){ Serial.println(angle); }

रेडियो नियंत्रण जोड़ें

हम एंड्रॉइड के लिए फोन से नियंत्रित करेंगे।

एप्लिकेशन शुरू करते समय, हम उपयोगकर्ता को यह चुनने के लिए कहते हैं कि किससे कनेक्ट होना है, बीटी-मॉड्यूल को पहले से ही फोन (मानक कोड 1234) के साथ जोड़ा जाना चाहिए।

 BluetoothAdapter bluetooth; String []boundedItems; protected static final int RECIEVE_MESSAGE = 1; @Override protected void onCreate(Bundle savedInstanceState) { //... bluetooth = BluetoothAdapter.getDefaultAdapter(); if(bluetooth != null){ if (!bluetooth.isEnabled()) { bluetooth.enable(); } } Set<BluetoothDevice> bounded=bluetooth.getBondedDevices(); boundedItems=new String[bounded.size()]; int i=0; for (BluetoothDevice bluetoothDevice : bounded) { boundedItems[i++]=bluetoothDevice.getName(); } showListDialog(); //... } public void showListDialog(){ AlertDialog.Builder builder = new AlertDialog.Builder(this); builder.setTitle("Pick a device"); builder.setItems(boundedItems, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int item) { connectTo(item); } }); AlertDialog alert = builder.create(); alert.show(); }

डिवाइस चुनने के बाद, उससे कनेक्ट करें:

  private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"); BluetoothSocket btSocket; public void connectTo(int id){ Set<BluetoothDevice> bounded=bluetooth.getBondedDevices(); for (BluetoothDevice bluetoothDevice : bounded) { if(bluetoothDevice.getName().equalsIgnoreCase(boundedItems[id])){ try { btSocket=bluetoothDevice.createRfcommSocketToServiceRecord(MY_UUID); btSocket.connect(); ct=new ConnectionThread(btSocket); ct.start(); } catch (IOException e) { e.printStackTrace(); try { btSocket.close(); } catch (IOException e1) { e1.printStackTrace(); } showListDialog(); } return; } } }

कनेक्ट होने के बाद, प्रवाह शुरू होता है, जो अनुप्रयोग और रोबोट के बीच संचार में लगा हुआ है:

 private class ConnectionThread extends Thread{ private final InputStream mmInStream; private final BufferedReader br; private final OutputStream mmOutStream; public ConnectionThread(BluetoothSocket socket) throws IOException { mmInStream = socket.getInputStream(); br=new BufferedReader(new InputStreamReader(mmInStream)); mmOutStream = socket.getOutputStream(); } public void run() { while (true) { try { String line=br.readLine(); h.obtainMessage(RECIEVE_MESSAGE, line).sendToTarget(); } catch (IOException e) { e.printStackTrace(); } } } public void sendCmd(char cmd){ try{ mmOutStream.write(cmd); }catch (IOException e) { e.printStackTrace(); } } }

थ्रेड अनुप्रयोग के मुख्य थ्रेड को हैंडलर के माध्यम से एक संदेश भेजता है, जिसे निम्नानुसार परिभाषित किया गया है:

 h = new Handler() { public void handleMessage(android.os.Message msg) { switch (msg.what) { case RECIEVE_MESSAGE: String line=(String)msg.obj; try{ float a=Float.parseFloat(line.trim()); balancerView.setAngle((float) (a-Math.PI/2.f)); }catch (Exception e) { } break; } }; };

balancerView SurfaceView वर्ग का एक वंशज है, यह रोबोट की वर्तमान स्थिति को प्रदर्शित करने में लगा हुआ है।

यहाँ उसकी redraw विधि है:

 public void draw(Canvas canvas) { Paint paint=new Paint(); paint.setStrokeWidth(3); canvas.save(); canvas.rotate((float) (angle*180.f/Math.PI), cx, cy); paint.setColor(Color.BLACK); canvas.drawRect(cx-15, cy-150, cx+15, cy, paint); paint.setColor(Color.WHITE); canvas.drawRect(cx-12, cy-147, cx+12, cy-3, paint); paint.setColor(Color.BLACK); canvas.drawCircle(cx, cy, 30, paint); paint.setColor(Color.WHITE); canvas.drawCircle(cx, cy, 25, paint); canvas.restore(); }

चालू होने पर रोबोट को कमांड भेजे जाते हैं, ताकि बटन दबाकर आप रोबोट को नियंत्रित कर सकें।

  @Override public boolean onTouch(View v, MotionEvent me) { if(me.getAction()==MotionEvent.ACTION_UP){ ct.sendCmd('c'); return false; } if(v==wB){ ct.sendCmd('w'); }else if(v==aB){ ct.sendCmd('a'); }else if(v==sB){ ct.sendCmd('s'); }else if(v==dB){ ct.sendCmd('d'); } return false; }

निष्कर्ष

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

जैसा कि वादा किया गया था, एक पहिया पर एक उल्टे पेंडुलम की गति के समीकरणों की व्युत्पत्ति: समीकरणों की व्युत्पत्ति और निर्माण के बारे में थोड़ा सा

गितुब भंडार

Arduino पर एक बैलेंसर रोबोट बनाना