🌘 🙌🏽 🧔🏻 घुटने पर मॉडल उन्मुख डिजाइन, MATLAB / Simulink में सिस्टम पहचान 😤 🤹🏾 🌝

हेलो, हेब्र!

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

दिलचस्पी रखने वालों के लिए, मैं बिल्ली माँगता हूँ।

हार्डवेयर और सॉफ्टवेयर उपलब्ध

~~प्रहरी प्रहरी~~ :

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

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

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

सिमुलिंक के तहत Arduino के साथ काम करने के लिए मैं Arduino के लिए लाइब्रेरी एंबेडेड कोडर लक्ष्य का उपयोग करता हूं।

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

वास्तव में, प्रस्तुत घटकों में से किसी को भी इसी कार्यात्मक एनालॉग के साथ प्रतिस्थापित किया जा सकता है (बतख को छोड़कर, निश्चित रूप से!)। लेकिन, चूंकि सब कुछ "घुटने पर" किया गया था - इस महत्वपूर्ण संयुक्त के मालिक के लिए विकल्प छोड़ दिया गया है।

जब इकट्ठे हुए, अगर इसे संग्रह कहा जा सकता है, तो सब कुछ इस तरह दिखता है:

समस्या का बयान

एक प्रणाली है - आपको आगे के काम के लिए इसका मॉडल प्राप्त करने की आवश्यकता है। कहीं आसान नहीं है।

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

इस बार मैंने विवरण में जाना, पहली बार में सब कुछ पहले से ही दिखाई दे रहा है, आंख से

लेकिन यह ध्यान दिया जाना चाहिए कि पर्दे के पीछे महत्वपूर्ण और दिलचस्प विषय हैं - प्रयोगात्मक डिजाइन ( डीओई ) और विश्लेषण का विश्लेषण ( एएनओवीए ), जो अलग-अलग विचार के लायक है।

कुछ सन्निकटन और सरलीकरण के साथ लक्ष्य प्रणाली में सबसिस्टम के निम्नलिखित सेट शामिल हैं:

असतत सबसिस्टम - अरुडिनो
सतत मैकेनिकल सबसिस्टम - इंजन
सतत विद्युत - मोटर शील्ड

सिस्टम इनपुट - PWM सेटप्‍वाइंट 0-100% ।

"एनालॉग" Arduino पोर्ट के आउटपुट में 0 से 255 तक uint8 मूल्यों की आपूर्ति करके PWM सिग्नल के कर्तव्य चक्र को बदलने का एक अवसर है। आपको यह जानने की जरूरत है कि पावर इलेक्ट्रॉनिक्स और मोटर इस प्रभाव का जवाब कैसे देंगे।

परीक्षण वेक्टर को नियंत्रक में तार दिया जाएगा, इसमें 501 तत्व शामिल हैं और इसे 0.04 के नमूने दर के साथ जारी किया जाता है। परीक्षण जोखिम के कुल ~ 20 सेकंड।

परीक्षण वेक्टर इस तरह दिखता है:

सिस्टम आउटपुट में, मुझे कम से कम कुछ इस तरह से देखने की उम्मीद है :-)

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

सिस्टम आउटपुट - शाफ्ट रोटेशन की गति, शाफ्ट रोटेशन कोण। क्वाडरेचर एनकोडर से, जब मोटर शाफ्ट घूमता है, तो मुझे पीआई / 2 के चरण ऑफसेट के साथ दो मेन्डर्स मिलते हैं। वे एक हार्डवेयर डिकोडर द्वारा संसाधित होते हैं, जो कि विन्यास योग्य I / O कार्डों में से एक पर मौजूद होता है। जब एक सिमुलिंक मॉडल को वास्तविक समय मशीन पर लोड किया जाता है, तो आवश्यक इनपुट / आउटपुट प्रदान करने के लिए FPGA को "फ्लैश" किया जाता है। डिकोडर से टिक्स को गुणांक से गुणा किया जाता है और एक कोण में बदल दिया जाता है, और गति में उनकी संख्या के परिवर्तन की दर। मोटर एनकोडर प्रति क्रांति 64 ट्रिगर बनाता है, जो अच्छी सटीकता के साथ ऊपर वर्णित मापदंडों को ट्रैक करने की अनुमति देता है। एक वास्तविक समय मशीन पर मुख्य एल्गोरिथ्म मेरे द्वारा 10 kHz की आवृत्ति के साथ काम करने के लिए सेट किया गया है - आउटपुट पर मुझे 0.0001 एस के नमूने की अवधि के साथ प्रयोगात्मक डेटा मिलता है। FPGA हार्डवेयर 33 मेगाहर्ट्ज की आवृत्ति पर काम करता है , जो मूल डिकोडिंग एल्गोरिदम के अलावा, उच्च गति पर माप सटीकता का त्याग किए बिना एंटी-बाउंस एल्गोरिदम का उपयोग करने का समय देता है। सरल शब्दों में, एक FPGA पर क्वाडरेचर सिग्नल को डिकोड करना उत्कृष्ट लेख fpga4fun -> QuadratureDecoder में वर्णित है।

मात्राओं का विघटन, समय की देरी, यांत्रिक भागों की जड़ता के क्षण, शांत घर्षण, स्लाइडिंग घर्षण, रोलिंग घर्षण, यांत्रिक नाटक, असंतुलन, अनुनाद घटना, प्रेरक सर्किट स्विचिंग, संपर्क फिसलने, स्पार्किंग - यह उन कारकों की पूरी सूची नहीं है जिन्हें हम प्रयास करते समय सामना करेंगे। इस प्रणाली का विश्लेषणात्मक वर्णन करें। लेकिन यह सिर्फ एक मोटर के साथ एक arduinka है !

मैं मानता हूं, कुछ बारीकियों को पूरी तरह से उपेक्षित किया जा सकता है, लेकिन व्यवहार में, किसी भी कारक की उपेक्षा करने का निर्णय सबसे आसान समाधान नहीं है।

यह कैसे Arduino (पीला) से PWM और एक विशुद्ध रूप से प्रतिरोधक भार पर वोल्टेज है जो ढाल के रूप में जुड़ा हुआ है:

लेकिन जब इंजन अभी तक कताई नहीं कर रहा है, और पहले से ही कताई है:

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

सिमुलिंक मॉडल

एक वास्तविक समय मशीन पर, मैं इस मॉडल को चलाता हूं:

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

Arduino के लिए फर्मवेयर प्राप्त करने के लिए मॉडल निम्नानुसार है:

एक सत्य तालिका जो सिग्नल के संकेत को ट्रैक करती है और मोटर शील्ड इनपुट को नियंत्रित करती है

एल्गोरिथ्म कोड को स्पॉइलर के नीचे देखा जा सकता है:

सी ++

// // File: arduinoTestVector.cpp // // Code generated for Simulink model 'arduinoTestVector'. // // Model version : 1.229 // Simulink Coder version : 8.6 (R2014a) 27-Dec-2013 // C/C++ source code generated on : Thu May 22 14:47:55 2014 // // Target selection: arduino_ec.tlc // Embedded hardware selection: Atmel->AVR // Code generation objectives: // 1. Execution efficiency // 2. ROM efficiency // 3. RAM efficiency // Validation result: Not run // #include "arduinoTestVector.h" // Constant parameters (auto storage) const ConstParam_arduinoTestVector arduinoTestVector_ConstP = { // Expression: myData // Referenced by: '<S1>/Constant1' { 0, 1, 3, 4, 5, 6, 8, 9, 10, 11, 13, 14, 15, 17, 18, 19, 20, 22, 23, 24, 26, 27, 28, 29, 31, 32, 33, 34, 36, 37, 38, 40, 41, 42, 43, 45, 46, 47, 48, 50, 51, 52, 54, 55, 56, 57, 59, 60, 61, 62, 0, -1, -3, -4, -5, -6, -8, -9, -10, -11, -13, -14, -15, -17, -18, -19, -20, -22, -23, -24, -26, -27, -28, -29, -31, -32, -33, -34, -36, -37, -38, -40, -41, -42, -43, -45, -46, -47, -48, -50, -51, -52, -54, -55, -56, -57, -59, -60, -61, -62, 0, 3, 5, 8, 10, 13, 15, 18, 20, 23, 26, 28, 31, 33, 36, 38, 41, 43, 46, 48, 51, 54, 56, 59, 61, 64, 66, 69, 71, 74, 77, 79, 82, 84, 87, 89, 92, 94, 97, 99, 102, 105, 107, 110, 112, 115, 117, 120, 122, 125, 0, -3, -5, -8, -10, -13, -15, -18, -20, -23, -26, -28, -31, -33, -36, -38, -41, -43, -46, -48, -51, -54, -56, -59, -61, -64, -66, -69, -71, -74, -77, -79, -82, -84, -87, -89, -92, -94, -97, -99, -102, -105, -107, -110, -112, -115, -117, -120, -122, -125, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, -255, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }; // Block signals (auto storage) BlockIO_arduinoTestVector arduinoTestVector_B; // Block states (auto storage) D_Work_arduinoTestVector arduinoTestVector_DWork; // Model step function void arduinoTestVector_step(void) { // local block i/o variables uint8_T rtb_MOTORSHIELD_IN1; uint8_T rtb_MOTORSHIELD_IN2; uint8_T rtb_Abs; boolean_T aVarTruthTableCondition_1; boolean_T aVarTruthTableCondition_2; boolean_T aVarTruthTableCondition_3; uint16_T rtb_Init; // Outputs for Enabled SubSystem: '<Root>/ENABLE_TEST' incorporates: // EnablePort: '<S1>/Enable' // S-Function (sfunar_digitalInput): '<Root>/RUN_TEST' if (((uint8_T)digitalRead(((uint8_T)2U))) > 0) { if (!arduinoTestVector_DWork.ENABLE_TEST_MODE) { // InitializeConditions for UnitDelay: '<S1>/Unit Delay' arduinoTestVector_DWork.UnitDelay_DSTATE = false; // InitializeConditions for UnitDelay: '<S4>/FixPt Unit Delay2' arduinoTestVector_DWork.FixPtUnitDelay2_DSTATE = 1U; // InitializeConditions for UnitDelay: '<S4>/FixPt Unit Delay1' arduinoTestVector_DWork.FixPtUnitDelay1_DSTATE = 0U; arduinoTestVector_DWork.ENABLE_TEST_MODE = true; } // Switch: '<S4>/Init' incorporates: // Constant: '<S4>/Initial Condition' // Logic: '<S4>/FixPt Logical Operator' // UnitDelay: '<S1>/Unit Delay' // UnitDelay: '<S4>/FixPt Unit Delay1' // UnitDelay: '<S4>/FixPt Unit Delay2' if (arduinoTestVector_DWork.UnitDelay_DSTATE || (arduinoTestVector_DWork.FixPtUnitDelay2_DSTATE != 0)) { rtb_Init = 0U; } else { rtb_Init = arduinoTestVector_DWork.FixPtUnitDelay1_DSTATE; } // End of Switch: '<S4>/Init' // Selector: '<S1>/Selector' incorporates: // Constant: '<S1>/Constant1' arduinoTestVector_B.Selector = arduinoTestVector_ConstP.Constant1_Value [(int16_T)rtb_Init]; // Switch: '<S4>/Reset' incorporates: // UnitDelay: '<S1>/Unit Delay' if (arduinoTestVector_DWork.UnitDelay_DSTATE) { // Update for UnitDelay: '<S4>/FixPt Unit Delay1' incorporates: // Constant: '<S4>/Initial Condition' arduinoTestVector_DWork.FixPtUnitDelay1_DSTATE = 0U; } else { // Update for UnitDelay: '<S4>/FixPt Unit Delay1' incorporates: // Constant: '<S1>/Constant' // Sum: '<S1>/Add' arduinoTestVector_DWork.FixPtUnitDelay1_DSTATE = rtb_Init + 1U; } // End of Switch: '<S4>/Reset' // Update for UnitDelay: '<S1>/Unit Delay' incorporates: // Constant: '<S3>/Constant' // RelationalOperator: '<S3>/Compare' arduinoTestVector_DWork.UnitDelay_DSTATE = (rtb_Init == 500U); // Update for UnitDelay: '<S4>/FixPt Unit Delay2' incorporates: // Constant: '<S4>/FixPt Constant' arduinoTestVector_DWork.FixPtUnitDelay2_DSTATE = 0U; } else { if (arduinoTestVector_DWork.ENABLE_TEST_MODE) { // Disable for Outport: '<S1>/TEST_OUT' arduinoTestVector_B.Selector = 0; arduinoTestVector_DWork.ENABLE_TEST_MODE = false; } } // End of S-Function (sfunar_digitalInput): '<Root>/RUN_TEST' // End of Outputs for SubSystem: '<Root>/ENABLE_TEST' // Truth Table: '<Root>/Truth Table' // Truth Table Function 'Truth Table': '<S2>:1' // ClockWise // Condition '#1': '<S2>:1:10' aVarTruthTableCondition_1 = (arduinoTestVector_B.Selector > 0); // CounterClockWise // Condition '#2': '<S2>:1:14' aVarTruthTableCondition_2 = (arduinoTestVector_B.Selector < 0); // Stop // Condition '#3': '<S2>:1:18' aVarTruthTableCondition_3 = (arduinoTestVector_B.Selector == 0); if ((!aVarTruthTableCondition_1) && (!aVarTruthTableCondition_2) && aVarTruthTableCondition_3) { // Decision 'D1': '<S2>:1:20' // Stop // Action '3': '<S2>:1:48' rtb_MOTORSHIELD_IN1 = 0U; // Action '3': '<S2>:1:49' rtb_MOTORSHIELD_IN2 = 0U; } else { // Decision 'D2': '<S2>:1:20' if (aVarTruthTableCondition_1 && (!aVarTruthTableCondition_2) && (!aVarTruthTableCondition_3)) { // Decision 'D2': '<S2>:1:22' // ClockWise // Action '1': '<S2>:1:34' rtb_MOTORSHIELD_IN1 = 1U; // Action '1': '<S2>:1:35' rtb_MOTORSHIELD_IN2 = 0U; } else { // Decision 'D3': '<S2>:1:22' if ((!aVarTruthTableCondition_1) && aVarTruthTableCondition_2 && (!aVarTruthTableCondition_3)) { // Decision 'D3': '<S2>:1:24' // CounterClockWise // Action '2': '<S2>:1:41' rtb_MOTORSHIELD_IN1 = 0U; // Action '2': '<S2>:1:42' rtb_MOTORSHIELD_IN2 = 1U; } else { // Decision 'D4': '<S2>:1:24' // Decision 'D4': '<S2>:1:26' // Default // None // Action '4': '<S2>:1:55' rtb_MOTORSHIELD_IN1 = 0U; // Action '4': '<S2>:1:56' rtb_MOTORSHIELD_IN2 = 0U; } } } // End of Truth Table: '<Root>/Truth Table' // S-Function (sfunar_digitalOutput): '<Root>/MOTORSHIELD_IN1' digitalWrite(((uint8_T)8U), rtb_MOTORSHIELD_IN1); // S-Function (sfunar_digitalOutput): '<Root>/MOTORSHIELD_IN2' digitalWrite(((uint8_T)11U), rtb_MOTORSHIELD_IN2); // Abs: '<Root>/Abs' if (arduinoTestVector_B.Selector < 0) { rtb_Abs = (uint8_T)-arduinoTestVector_B.Selector; } else { rtb_Abs = (uint8_T)arduinoTestVector_B.Selector; } // End of Abs: '<Root>/Abs' // S-Function (sfunar_analogOutput): '<Root>/SPEEDPIN_A' analogWrite(((uint8_T)9U), rtb_Abs); } // Model initialize function void arduinoTestVector_initialize(void) { // Registration code // block I/O (void) memset(((void *) &arduinoTestVector_B), 0, sizeof(BlockIO_arduinoTestVector)); // states (dwork) (void) memset((void *)&arduinoTestVector_DWork, 0, sizeof(D_Work_arduinoTestVector)); // S-Function (sfunar_digitalInput): <Root>/RUN_TEST pinMode(((uint8_T)2U), INPUT); // InitializeConditions for Enabled SubSystem: '<Root>/ENABLE_TEST' // InitializeConditions for UnitDelay: '<S1>/Unit Delay' arduinoTestVector_DWork.UnitDelay_DSTATE = false; // InitializeConditions for UnitDelay: '<S4>/FixPt Unit Delay2' arduinoTestVector_DWork.FixPtUnitDelay2_DSTATE = 1U; // InitializeConditions for UnitDelay: '<S4>/FixPt Unit Delay1' arduinoTestVector_DWork.FixPtUnitDelay1_DSTATE = 0U; // End of InitializeConditions for SubSystem: '<Root>/ENABLE_TEST' // S-Function (sfunar_digitalOutput): <Root>/MOTORSHIELD_IN1 pinMode(((uint8_T)8U), OUTPUT); // S-Function (sfunar_digitalOutput): <Root>/MOTORSHIELD_IN2 pinMode(((uint8_T)11U), OUTPUT); // S-Function (sfunar_analogOutput): <Root>/SPEEDPIN_A pinMode(((uint8_T)9U), OUTPUT); } // // File trailer for generated code. // // [EOF] //

पूरे प्रोजेक्ट को यहां डाउनलोड किया जा सकता है ।

मॉडल जो मैं परिणामों को सत्यापित करने के लिए उपयोग करूंगा:

सभी मॉडल यहां डाउनलोड किए जा सकते हैं ।

"खोला और लॉन्च किया गया" काम नहीं कर सकता है, बारीकियां हैं। पीएम के सवालों के साथ, या टिप्पणियों में।

वीडियो

परिणाम

यहाँ परिणाम है:

ब्लू एक इनपुट सिग्नल है, जिसकी सीमा -255 से लेकर 5.35 तक है । वोल्ट के संदर्भ में, यह लगभग -8.5 से 8.5 होगा ।

ग्रीन - मोटर शाफ्ट रोटेशन की गति।

पीडब्लूएम को 25% से कम लगाने पर हमें एक समय की देरी, रोटेशन की कमी, या बहुत कम रोटेशन दिखाई देता है। हम एक क्लासिक aperiodic क्षणिक का भी निरीक्षण करते हैं।

और यहां वह जानकारी है जो एक वास्तविक समय मशीन से जुड़े प्रदर्शन पर प्रयोग के दौरान प्रदर्शित होती है:

पहचान

सबसिस्टम में से एक, अर्थात् इंजन, निम्नलिखित हस्तांतरण फ़ंक्शन द्वारा वर्णित किया जा सकता है:

इसलिए TAU पाठ्यक्रम हमें बताता है, हम इसके साथ शुरू करेंगे।

MATLAB में सिस्टम की पहचान करने के लिए एक बढ़िया टूल है - सिस्टम आइडेंटिफिकेशन टूलबॉक्स । यह एक ग्राफिकल इंटरफ़ेस और फ़ंक्शन के सेट के रूप में उपलब्ध है जो MATLAB लिपियों में उपयोग किया जा सकता है। ग्राफिकल इंटरफेस में पहले काम पर विचार करें।

हम प्रयोग और परीक्षण प्रभाव के दौरान प्राप्त डेटा को आयात करते हैं:

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

"अनुमानित" ड्रॉप-डाउन सूची से स्थानांतरण फ़ंक्शन मॉडल का चयन करें।

हमें ट्रांसफर फ़ंक्शन मिलता है:

आइए परिणामी फ़ंक्शन और सिस्टम के व्यवहार की तुलना करें:

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

आगे बढ़ते हुए, हम हैमरस्टीन-वीनर मॉडल टेम्पलेट का उपयोग करते हैं, जो सिस्टम के गैर-व्यवहार व्यवहार का वर्णन करना संभव बनाता है:

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

बाकी डिफ़ॉल्ट विकल्प, अनुमान पर क्लिक करें।

MichaelBorisov के अनुरोध पर # 1 अपडेट करें:

अधिक विस्तार से, नॉनलाइनर भाग का विन्यास इस तरह दिखता है:

डेड जोन के मामले के लिए, सब कुछ सरल है - हम प्रकार और सीमा मान निर्धारित करते हैं।

रैखिक भाग सेट करने से आप ऑर्डर को पूर्व-निर्दिष्ट कर सकते हैं और देरी का अनुमान लगा सकते हैं:

इस तथ्य के बावजूद कि यह एक "ब्लैक बॉक्स" है - व्यवहार में, पर्याप्त परिणाम प्राप्त करना उस प्रणाली के बारे में ज्ञान की मात्रा पर निर्भर करता है जिसे आप गणना कॉन्फ़िगरेशन में रखते हैं।

माइकलबोरिसोव के अनुरोध पर endOfUpdate # 1:

प्रयोगात्मक डेटा के साथ परिणाम की तुलना करें:

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

अब हमें बस इस मॉडल को सिमुलिंक को निर्यात करना है, जहां हम एक नियंत्रण प्रणाली विकसित करना शुरू कर सकते हैं। लेकिन अगले विषय में इसके बारे में और अधिक!

आपका ध्यान के लिए धन्यवाद, मुझे आशा है कि यह दिलचस्प था?

और एक छोटे से सर्वेक्षण के जवाब के लिए फिर से धन्यवाद:

घुटने पर मॉडल उन्मुख डिजाइन, MATLAB / Simulink में सिस्टम पहचान