बैकस्टेपिंग: Difference between revisions

From Vigyanwiki
No edit summary
m (9 revisions imported from alpha:बैकस्टेपिंग)
 
(3 intermediate revisions by 2 users not shown)
Line 11: Line 11:
  | doi = 10.1109/37.165507
  | doi = 10.1109/37.165507
| s2cid = 27196262
| s2cid = 27196262
  }}</ref><ref name=LB92>{{cite journal | first1=R.|last1=Lozano| first2=B.|last2=Brogliato | year=1992 | title=लचीले जोड़ों के साथ रोबोट मैनिपुलेटर्स का अनुकूली नियंत्रण| journal= IEEE Transactions on Automatic Control | volume=37 | issue=2 | pages=174–181 | doi=10.1109/9.121619|url=https://hal.inria.fr/hal-03592568/file/RLBB_FJ_TAC1992.pdf }}</ref> [[ अरेखीय प्रणाली |अरेखीय प्रणाली]] [[गतिशील प्रणाली]] के विशेष वर्ग के लिए [[ल्यपुनोव स्थिरता]] नियंत्रण को डिजाइन करने के लिए बनाया गया हैं। ये प्रणालियाँ उन उपप्रणालियों से निर्मित होती हैं, जो अपरिवर्तनीय उपप्रणाली से निकलती हैं, जिन्हें किसी अन्य विधि का उपयोग करके स्थिर किया जा सकता है। इस [[ प्रत्यावर्तन |प्रत्यावर्तन]] संरचना के कारण, डिज़ाइनर ज्ञात-स्थिर प्रणालियों पर डिज़ाइन प्रक्रिया प्रारंभ कर सकता है, और इसके लिए नए नियंत्रकों को वापस ले सकता है, जो प्रत्येक बाहरी उपप्रणाली को उत्तरोत्तर स्थिर करते हैं। अंतिम बाह्य नियंत्रण पर पहुँचने पर प्रक्रिया समाप्त हो जाती है। इसलिए इस प्रक्रिया को बैकस्टेपिंग के रूप में जाना जाता है।<ref name="Khalil">{{cite book
  }}</ref><ref name=LB92>{{cite journal | first1=R.|last1=Lozano| first2=B.|last2=Brogliato | year=1992 | title=लचीले जोड़ों के साथ रोबोट मैनिपुलेटर्स का अनुकूली नियंत्रण| journal= IEEE Transactions on Automatic Control | volume=37 | issue=2 | pages=174–181 | doi=10.1109/9.121619|url=https://hal.inria.fr/hal-03592568/file/RLBB_FJ_TAC1992.pdf }}</ref> किसी [[ अरेखीय प्रणाली |अरेखीय प्रणाली]] तथा [[गतिशील प्रणाली]] के विशेष वर्ग के लिए [[ल्यपुनोव स्थिरता]] नियंत्रण को डिजाइन करने के लिए बनाया गया हैं। ये प्रणालियाँ उन उपप्रणालियों से निर्मित होती हैं, जो अपरिवर्तनीयता के कारण उपप्रणाली से निकलती हैं, जिन्हें किसी अन्य विधि का उपयोग करके स्थिर किया जा सकता है। इस [[ प्रत्यावर्तन |प्रत्यावर्तन]] संरचना के कारण डिज़ाइनर इस प्रकार की ज्ञात स्थिर प्रणालियों पर संरचना प्रक्रिया को प्रारंभ कर सकते हैं, और इसके लिए नए नियंत्रकों को वापस ले सकते है, जो इस प्रकार प्रत्येक बाहरी उपप्रणाली को उत्तरोत्तर स्थिर करते हैं। इस प्रकार अंतिम बाह्य नियंत्रण पर पहुँचने पर प्रक्रिया समाप्त हो जाती है। इसलिए इस प्रक्रिया को बैकस्टेपिंग के रूप में जाना जाता है।<ref name="Khalil">{{cite book
  | last = Khalil
  | last = Khalil
  | first = H.K.
  | first = H.K.
Line 24: Line 24:


==बैकस्टेपिंग दृष्टिकोण==
==बैकस्टेपिंग दृष्टिकोण==
बैकस्टेपिंग दृष्टिकोण मुख्य रूप से सख्त प्रतिक्रिया रूप में प्रणाली की [[उत्पत्ति (गणित)]] की ल्यपुनोव स्थिरता के लिए रिकर्सन विधि प्रदान करता है। प्रपत्र की गतिशील प्रणाली पर विचार करें<ref name="Khalil"/>
बैकस्टेपिंग दृष्टिकोण मुख्य रूप से कठोर प्रतिक्रिया रूप में इस प्रणाली की [[उत्पत्ति (गणित)]] की ल्यपुनोव स्थिरता के लिए रिकर्सन विधि प्रदान करता है। इस प्रकार प्रपत्र की गतिशील प्रणाली पर विचार करें<ref name="Khalil"/>


:<math>\begin{align}\begin{cases}
:<math>\begin{align}\begin{cases}
Line 37: Line 37:
\end{cases}\end{align}</math>
\end{cases}\end{align}</math>
जहाँ
जहाँ
* <math>\mathbf{x} \in \mathbb{R}^n</math> साथ <math>n \geq 1</math>,
* <math>\mathbf{x} \in \mathbb{R}^n</math> साथ <math>n \geq 1</math> मान प्राप्त होता हैं,
* <math>z_1, z_2, \ldots, z_i, \ldots, z_{k-1}, z_k</math> [[अदिश (गणित)]] हैं,
* <math>z_1, z_2, \ldots, z_i, \ldots, z_{k-1}, z_k</math> [[अदिश (गणित)]] हैं,
* {{mvar|u}} सिस्टम के लिए अदिश (गणित) इनपुट है,
* {{mvar|u}} प्रणाली के लिए अदिश (गणित) इनपुट है,
* <math>f_x, f_1, f_2, \ldots, f_i, \ldots, f_{k-1}, f_k</math> मूल में विलुप्त (अर्थात, <math>f_i(0,0,\dots,0) = 0</math>),
* <math>f_x, f_1, f_2, \ldots, f_i, \ldots, f_{k-1}, f_k</math> मूल में विलुप्त (अर्थात, <math>f_i(0,0,\dots,0) = 0</math>),
* <math>g_1, g_2, \ldots, g_i, \ldots, g_{k-1}, g_k</math> रुचि के क्षेत्र पर शून्येतर हैं, (अर्थात्, <math>g_i(\mathbf{x},z_1,\ldots,z_k) \neq 0</math> के लिए <math>1 \leq i \leq k</math>)
* <math>g_1, g_2, \ldots, g_i, \ldots, g_{k-1}, g_k</math> के लिए इसका मान इस क्षेत्र पर शून्येत्तर हैं, (अर्थात्, <math>g_i(\mathbf{x},z_1,\ldots,z_k) \neq 0</math> के लिए <math>1 \leq i \leq k</math>) के समान हैं।


यह भी मान लें कि उपप्रणाली
यह भी मान लें कि उपप्रणाली
:<math>\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) u_x(\mathbf{x})</math>
:<math>\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) u_x(\mathbf{x})</math>
मूल (गणित) (अर्थात, <math> \mathbf{x} = \mathbf{0}\,</math>) के लिए ल्यपुनोव स्थिरता है, इनमें से कुछ के लिए ज्ञात मान के आधार पर नियंत्रण द्वारा <math>u_x(\mathbf{x})</math> मान प्राप्त होता हैं, यह मान इस प्रकार है कि <math>u_x(\mathbf{0}) = 0</math> के समान हैं, यह भी माना जाता है, कि [[ल्यपुनोव समारोह|ल्यपुनोव फलन]] <math>V_x</math> के लिए स्थिर उपप्रणाली को जाना जाता है। इस प्रकार प्राप्त होने वाला मान {{math|'''x'''}} हैं जो इसकी उपप्रणाली को किसी अन्य विधि द्वारा स्थिर किया जाता है, और बैकस्टेपिंग इसकी स्थिरता <math>\textbf{z}</math> को बढ़ाता है, जो इसके चारों ओर विवृत रहता हैं।
मूल (गणित) (अर्थात, <math> \mathbf{x} = \mathbf{0}\,</math>) के लिए ल्यपुनोव स्थिरता के समान है, इनमें से कुछ के लिए ज्ञात मान के आधार पर नियंत्रण द्वारा <math>u_x(\mathbf{x})</math> मान प्राप्त होता हैं, यह मान इस प्रकार है कि <math>u_x(\mathbf{0}) = 0</math> के समान हैं, यह भी माना जाता है, कि [[ल्यपुनोव समारोह|ल्यपुनोव फलन]] <math>V_x</math> के लिए स्थिर उपप्रणाली को जाना जाता है। इस प्रकार प्राप्त होने वाला मान {{math|'''x'''}} के समान हैं जो इसकी उपप्रणाली को किसी अन्य विधि द्वारा स्थिर किया जाता है, और बैकस्टेपिंग इसकी स्थिरता <math>\textbf{z}</math> को बढ़ाता है, जो इसके चारों ओर विवृत रहता हैं।


इस कठोर प्रतिक्रिया के लिए इन प्रणालियों में स्थिरता के चारों ओर  {{math|'''x'''}} उपप्रणाली वाले फॉर्म होते है,
इस कठोर प्रतिक्रिया के लिए इन प्रणालियों में स्थिरता के चारों ओर  {{math|'''x'''}} उपप्रणाली वाले फॉर्म होते है,
Line 51: Line 51:
* यहाँ पर <math>z_n</math>  स्थिति पर स्थिर नियंत्रण के समान कार्य करता है, इससे पहले यह मान <math>z_{n-1}</math> के समान हैं।
* यहाँ पर <math>z_n</math>  स्थिति पर स्थिर नियंत्रण के समान कार्य करता है, इससे पहले यह मान <math>z_{n-1}</math> के समान हैं।
* यह प्रक्रिया निरंतर रहती है, जिससे कि इसकी प्रत्येक स्थिति <math>z_i</math> काल्पनिक नियंत्रण <math>z_{i+1}</math> द्वारा स्थिर किया जाता है।
* यह प्रक्रिया निरंतर रहती है, जिससे कि इसकी प्रत्येक स्थिति <math>z_i</math> काल्पनिक नियंत्रण <math>z_{i+1}</math> द्वारा स्थिर किया जाता है।
बैकस्टेपिंग दृष्टिकोण यह निर्धारित करता है कि इसे कैसे स्थिर किया जाए {{math|'''x'''}} उपप्रणाली <math>z_1</math> का उपयोग करना होता हैं, और फिर यह निर्धारित करने के लिए आगे बढ़ता है कि अगला स्थिति <math>z_2</math> कैसे बनायी जा सकती हैं,  इसके आधार पर गाड़ी चलाना <math>z_1</math> को स्थिर करने के लिए आवश्यक नियंत्रण के लिए {{math|'''x'''}} का मान आवश्यक हैं, इसलिए प्रक्रिया पीछे की ओर अग्रसर रहती है, इसके आधार पर {{math|'''x'''}} अंतिम नियंत्रण तक कठोर प्रतिक्रिया प्रपत्र प्रणाली से बाहर {{mvar|u}} बनाया गया है।
बैकस्टेपिंग दृष्टिकोण यह निर्धारित करता है कि इसे कैसे स्थिर किया जाए {{math|'''x'''}} उपप्रणाली <math>z_1</math> का उपयोग करना होता हैं, और फिर यह निर्धारित करने के लिए आगे बढ़ता है कि अगला स्थिति <math>z_2</math> कैसे बनायी जा सकती हैं,  इसके आधार पर गाड़ी चलाना <math>z_1</math> को स्थिर करने के लिए आवश्यक नियंत्रण के लिए {{math|'''x'''}} का मान आवश्यक हैं, इसलिए इस प्रकार की प्रक्रिया पीछे की ओर अग्रसर रहती है, इसके आधार पर {{math|'''x'''}} अंतिम नियंत्रण तक कठोर प्रतिक्रिया प्रपत्र प्रणाली से बाहर {{mvar|u}} बनाया गया है।


==पुनरावर्ती नियंत्रण डिज़ाइन अवलोकन==
==पुनरावर्ती नियंत्रण डिज़ाइन अवलोकन==


# यह दिया गया है कि छोटा (अर्थात, निचले क्रम का) उपप्रणाली
# यह दिया गया है कि छोटा अर्थात, निचले क्रम की उपप्रणाली इस प्रकार हैं।
#::<math>\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) u_x(\mathbf{x})</math>
#::<math>\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) u_x(\mathbf{x})</math>
#:इस प्रकार पहले से ही कुछ नियंत्रण द्वारा मूल बिंदु <math>u_x(\mathbf{x})</math> पर स्थिर कर दिया गया है, जहाँ <math>u_x(\mathbf{0}) = 0</math> अर्थात <math>u_x</math> को उपयोग करते हैं, इस प्रकार इस प्रणाली को स्थिर करने के लिए किसी अन्य विधि का उपयोग करना होगा। यह भी माना जाता है कि ल्यपुनोव फलन <math>V_x</math> के लिए स्थिर उपप्रणाली को जाना जाता है। बैकस्टेपिंग इस उपप्रणाली की नियंत्रित स्थिरता को बड़े सिस्टम तक विस्तारित करने का तरीका प्रदान करता है।
#:इस प्रकार पहले से ही कुछ नियंत्रण द्वारा मूल बिंदु <math>u_x(\mathbf{x})</math> पर स्थिर कर दिया गया है, जहाँ <math>u_x(\mathbf{0}) = 0</math> अर्थात <math>u_x</math> को उपयोग करते हैं, इस प्रकार इस प्रणाली को स्थिर करने के लिए किसी अन्य विधि का उपयोग करना होगा। यह भी माना जाता है कि ल्यपुनोव फलन <math>V_x</math> के लिए स्थिर उपप्रणाली को जाना जाता है। इस प्रकार बैकस्टेपिंग इस उपप्रणाली की नियंत्रित स्थिरता को बड़े प्रणाली तक विस्तारित करने का तरीका प्रदान करता है।
# नियंत्रण <math>u_1(\mathbf{x},z_1)</math> इस प्रकार डिज़ाइन किया गया है कि सिस्टम
# नियंत्रण <math>u_1(\mathbf{x},z_1)</math> इस प्रकार डिज़ाइन किया गया है कि यह प्रणाली कुछ इस प्रकार दिखती हैं।
#::<math>\dot{z}_1 = f_1(\mathbf{x},z_1) + g_1(\mathbf{x},z_1) u_1(\mathbf{x},z_1)</math>
#::<math>\dot{z}_1 = f_1(\mathbf{x},z_1) + g_1(\mathbf{x},z_1) u_1(\mathbf{x},z_1)</math>
#:इस समीकरण के आधार पर यह मान स्थिर किया जाता है, जिससे कि <math>z_1</math> नियंत्रण के लिए वांछित मान <math>u_x</math> का पालन करता है। नियंत्रण डिज़ाइन संवर्धित ल्यपुनोव फलन उम्मीदवार पर आधारित है,
#:इस समीकरण के आधार पर यह मान स्थिर किया जाता है, जिससे कि <math>z_1</math> नियंत्रण के लिए वांछित मान <math>u_x</math> का पालन करता है। नियंत्रण डिज़ाइन संवर्धित ल्यपुनोव फलन उम्मीदवार पर आधारित है,
#::<math>V_1(\mathbf{x},z_1) = V_x(\mathbf{x}) + \frac{1}{2}( z_1 - u_x(\mathbf{x}) )^2</math>
#::<math>V_1(\mathbf{x},z_1) = V_x(\mathbf{x}) + \frac{1}{2}( z_1 - u_x(\mathbf{x}) )^2</math>
#:यह नियंत्रण <math>u_1</math> बाध्य करने के <math>\dot{V}_1</math> शून्य से दूरी के लिए चुना जाता है,
#:यह नियंत्रण <math>u_1</math> बाध्य करने के <math>\dot{V}_1</math> शून्य से दूरी के लिए चुना जाता है,
# नियंत्रण <math>u_2(\mathbf{x},z_1,z_2)</math> इस प्रकार डिज़ाइन किया गया है कि सिस्टम
# नियंत्रण <math>u_2(\mathbf{x},z_1,z_2)</math> इस प्रकार डिज़ाइन किया गया है कि प्रणाली कुछ इस प्रकार प्राप्त होती हैं-
#::<math>\dot{z}_2 = f_2(\mathbf{x},z_1,z_2) + g_2(\mathbf{x},z_1,z_2) u_2(\mathbf{x},z_1,z_2)</math>
#::<math>\dot{z}_2 = f_2(\mathbf{x},z_1,z_2) + g_2(\mathbf{x},z_1,z_2) u_2(\mathbf{x},z_1,z_2)</math>
#:इसके आधार पर यह स्थिर किया जा सकता है, जिससे कि <math>z_2</math> वांछित <math>u_1</math> नियंत्रण का पालन करता है। इसके आधार पर नियंत्रण डिज़ाइन संवर्धित ल्यपुनोव फलन उम्मीदवार पर आधारित है
#:इसके आधार पर यह स्थिर किया जा सकता है, जिससे कि <math>z_2</math> वांछित <math>u_1</math> नियंत्रण का पालन करता है। इसके आधार पर नियंत्रण डिज़ाइन संवर्धित ल्यपुनोव फलन पर आधारित है
#::<math>V_2(\mathbf{x},z_1,z_2) = V_1(\mathbf{x},z_1) + \frac{1}{2}( z_2 - u_1(\mathbf{x},z_1) )^2</math>
#::<math>V_2(\mathbf{x},z_1,z_2) = V_1(\mathbf{x},z_1) + \frac{1}{2}( z_2 - u_1(\mathbf{x},z_1) )^2</math>
#:इस नियंत्रण <math>u_2</math> बाध्य करने के लिए <math>\dot{V}_2</math> शून्य से मान को चुना जा सकता है,
#:इस नियंत्रण <math>u_2</math> बाध्य करने के लिए <math>\dot{V}_2</math> शून्य से मान को चुना जा सकता है,
# यह प्रक्रिया वास्तविक होने तक उपयोग किया जा सकता है, यहाँ पर {{mvar|u}} का मान ज्ञात है, और
# यह प्रक्रिया वास्तविक होने तक उपयोग किया जा सकता है, यहाँ पर {{mvar|u}} का मान ज्ञात है, और
#* वास्तविक नियंत्रण {{mvar|u}} स्थिर करता है, <math>z_k</math> काल्पनिक नियंत्रण <math>u_{k-1}</math> के लिए प्राप्त होता हैं
#* वास्तविक नियंत्रण {{mvar|u}} स्थिर करता है, <math>z_k</math> काल्पनिक नियंत्रण <math>u_{k-1}</math> के लिए प्राप्त होता हैं।
#* काल्पनिक नियंत्रण <math>u_{k-1}</math> स्थिर <math>z_{k-1}</math> काल्पनिक नियंत्रण <math>u_{k-2}</math> के लिए प्राप्त होता हैं
#* काल्पनिक नियंत्रण <math>u_{k-1}</math> स्थिर <math>z_{k-1}</math> काल्पनिक नियंत्रण <math>u_{k-2}</math> के लिए प्राप्त होता हैं।
#* काल्पनिक नियंत्रण <math>u_{k-2}</math> स्थिर <math>z_{k-2}</math> काल्पनिक नियंत्रण <math>u_{k-3}</math> के लिए प्राप्त होता हैं
#* काल्पनिक नियंत्रण <math>u_{k-2}</math> स्थिर <math>z_{k-2}</math> काल्पनिक नियंत्रण <math>u_{k-3}</math> के लिए प्राप्त होता हैं।
#* ...
#* ...
#* काल्पनिक नियंत्रण <math>u_2</math> स्थिर <math>z_2</math> काल्पनिक नियंत्रण <math>u_1</math> के लिए उपयोग किया जाता हैं,  
#* काल्पनिक नियंत्रण <math>u_2</math> स्थिर <math>z_2</math> काल्पनिक नियंत्रण <math>u_1</math> के लिए उपयोग किया जाता हैं,  
Line 77: Line 77:
#* काल्पनिक नियंत्रण <math>u_x</math> स्थिर {{math|'''x'''}} मूल की ओर उपयोग किया जाता हैं,
#* काल्पनिक नियंत्रण <math>u_x</math> स्थिर {{math|'''x'''}} मूल की ओर उपयोग किया जाता हैं,


इस प्रक्रिया को बैकस्टेपिंग के रूप में जाना जाता है, क्योंकि यह स्थिरता के लिए कुछ आंतरिक उपप्रणाली की आवश्यकताओं के साथ प्रारंभ होती है, और प्रत्येक चरण पर स्थिरता बनाए रखते हुए धीरे-धीरे सिस्टम से ''पीछे हटती'' है। क्योंकि
इस प्रक्रिया को बैकस्टेपिंग के रूप में जाना जाता है, क्योंकि यह स्थिरता के लिए कुछ आंतरिक उपप्रणाली की आवश्यकताओं के साथ प्रारंभ होती है, और प्रत्येक चरण पर स्थिरता बनाए रखते हुए धीरे-धीरे प्रणाली से ''पीछे हटती'' है। क्योंकि
* <math>f_i</math> के लिए मूल रूप से लुप्त <math>0 \leq i \leq k</math> हो जाता हैं,
* <math>f_i</math> के लिए मूल रूप से लुप्त <math>0 \leq i \leq k</math> हो जाता हैं,
* <math>g_i</math> के लिए शून्येतर <math>1 \leq i \leq k</math> हैं,
* <math>g_i</math> के लिए शून्येतर <math>1 \leq i \leq k</math> हैं,
Line 85: Line 85:
== इंटीग्रेटर बैकस्टेपिंग ==
== इंटीग्रेटर बैकस्टेपिंग ==


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


यहाँ पर ज्ञात होने वाले फीडबैक स्थिरीकरण नियंत्रण नियम वाले सिस्टम और इसलिए स्थिरीकरण दृष्टिकोण को इंटीग्रेटर बैकस्टेपिंग के रूप में जाना जाता है। इस प्रकार छोटे संशोधनों के साथ, सभी कठोर प्रतिक्रियायें फॉर्म सिस्टम को संभालने के लिए इंटीग्रेटर बैकस्टेपिंग दृष्टिकोण को बढ़ाया जा सकता है।
यहाँ पर ज्ञात होने वाले फीडबैक स्थिरीकरण नियंत्रण नियम वाले प्रणाली और इसलिए स्थिरीकरण दृष्टिकोण को इंटीग्रेटर बैकस्टेपिंग के रूप में जाना जाता है। इस प्रकार छोटे संशोधनों के साथ, सभी कठोर प्रतिक्रियायें फॉर्म प्रणाली को संभालने के लिए इंटीग्रेटर बैकस्टेपिंग दृष्टिकोण को बढ़ाया जा सकता है।


===एकल-एकीकरणकर्ता संतुलन===
===एकल-एकीकरणकर्ता संतुलन===
Line 99: Line 99:
| {{EquationRef|1}}}}
| {{EquationRef|1}}}}


जहाँ <math>\mathbf{x} \in \mathbb{R}^n</math> और <math>z_1</math> अदिश राशि है, यह सिस्टम [[ करनेवाला |करने वाला]] का [[कैस्केड कनेक्शन]] है, इस प्रकार {{math|'''x'''}} उपप्रणाली (अर्थात, इनपुट {{mvar|u}} इंटीग्रेटर और [[ अभिन्न |अभिन्न]] में प्रवेश करता है <math>z_1</math> प्रविष्ट होता है {{math|'''x'''}} उपप्रणाली)
जहाँ <math>\mathbf{x} \in \mathbb{R}^n</math> और <math>z_1</math> अदिश राशि है, यह प्रणाली [[ करनेवाला |करने वाला]] का [[कैस्केड कनेक्शन]] है, इस प्रकार {{math|'''x'''}} उपप्रणाली (अर्थात, इनपुट {{mvar|u}} इंटीग्रेटर और [[ अभिन्न |अभिन्न]] में प्रवेश करता है, जहाँ पर <math>z_1</math> {{math|'''x'''}} उपप्रणाली के अनुसार प्रविष्ट होता है।)


हम मानते हैं कि <math>f_x(\mathbf{0})=0</math>, और यदि ऐसा है <math>u_1=0</math>, <math> \mathbf{x} = \mathbf{0}\,</math> और <math>z_1 = 0</math>, तब
हम मानते हैं कि <math>f_x(\mathbf{0})=0</math>, और यदि ऐसा है <math>u_1=0</math>, <math> \mathbf{x} = \mathbf{0}\,</math> और <math>z_1 = 0</math> के समान होने पर हमें यह समीकरण प्राप्त होता हैं।
:<math>\begin{cases}
:<math>\begin{cases}
\dot{\mathbf{x}} = f_x(\underbrace{\mathbf{0}}_{\mathbf{x}}) + ( g_x(\underbrace{\mathbf{0}}_{\mathbf{x}}) )(\underbrace{0}_{z_1}) = 0 + ( g_x(\mathbf{0}) )(0) = \mathbf{0} & \quad \text{ (i.e., } \mathbf{x} = \mathbf{0} \text{ is stationary)}\\
\dot{\mathbf{x}} = f_x(\underbrace{\mathbf{0}}_{\mathbf{x}}) + ( g_x(\underbrace{\mathbf{0}}_{\mathbf{x}}) )(\underbrace{0}_{z_1}) = 0 + ( g_x(\mathbf{0}) )(0) = \mathbf{0} & \quad \text{ (i.e., } \mathbf{x} = \mathbf{0} \text{ is stationary)}\\
\dot{z}_1 = \overbrace{0}^{u_1} & \quad \text{ (i.e., } z_1 = 0 \text{ is stationary)}
\dot{z}_1 = \overbrace{0}^{u_1} & \quad \text{ (i.e., } z_1 = 0 \text{ is stationary)}
\end{cases}</math>
\end{cases}</math>
तो मूल (गणित) <math>(\mathbf{x},z_1) = (\mathbf{0},0)</math> प्रणाली का संतुलन (अर्थात, [[स्थिर बिंदु]]) है। यदि सिस्टम कभी मूल स्थिति तक पहुंचता है, तो वह उसके पश्चात सदैव के लिए वहीं रहेगा।
तो मूल (गणित) <math>(\mathbf{x},z_1) = (\mathbf{0},0)</math> प्रणाली का संतुलन (अर्थात, [[स्थिर बिंदु]]) है। यदि प्रणाली कभी मूल स्थिति तक पहुंचता है, तो वह उसके पश्चात सदैव के लिए वहीं रहेगा।


===सिंगल-इंटीग्रेटर बैकस्टेपिंग===
===सिंगल-इंटीग्रेटर बैकस्टेपिंग===


इस उदाहरण में बैकस्टेपिंग का उपयोग समीकरण में सिंगल-इंटीग्रेटर सिस्टम को ल्यपुनोव स्थिरता के लिए किया जाता है, ({{EquationNote|1}}) मूल बिंदु पर इसके संतुलन के समीप रहता हैं। कम सटीक होने के लिए, हम नियंत्रण नियम तैयार करना चाहते हैं, इस प्रकार <math>u_1(\mathbf{x},z_1)</math> पर सुनिश्चित करता है कि इस स्थिति <math>(\mathbf{x}, z_1)</math> को वापस <math>(\mathbf{0},0)</math> प्रणाली को कुछ प्रारंभिक स्थिति से प्रारंभ करने के बाद उपयोग होता हैं।
इस उदाहरण में बैकस्टेपिंग का उपयोग समीकरण में सिंगल-इंटीग्रेटर प्रणाली को ल्यपुनोव स्थिरता के लिए किया जाता है, इस प्रकार ({{EquationNote|1}}) मूल बिंदु पर इसके संतुलन के समीप रहता हैं। कम सटीक होने के लिए, हम नियंत्रण नियम तैयार करना चाहते हैं, इस प्रकार <math>u_1(\mathbf{x},z_1)</math> पर सुनिश्चित करता है कि इस स्थिति <math>(\mathbf{x}, z_1)</math> को वापस <math>(\mathbf{0},0)</math> प्रणाली को कुछ प्रारंभिक स्थिति से प्रारंभ करने के बाद उपयोग होता हैं।


* सबसे पहले, धारणा से, उपप्रणाली
* सबसे पहले, धारणा से, उपप्रणाली
Line 119: Line 119:
::<math>\dot{V}_x=\frac{\partial V_x}{\partial \mathbf{x}}(f_x(\mathbf{x})+g_x(\mathbf{x})u_x(\mathbf{x})) \leq - W(\mathbf{x})</math>
::<math>\dot{V}_x=\frac{\partial V_x}{\partial \mathbf{x}}(f_x(\mathbf{x})+g_x(\mathbf{x})u_x(\mathbf{x})) \leq - W(\mathbf{x})</math>
:जहाँ <math>W(\mathbf{x})</math> [[सकारात्मक-निश्चित कार्य|धनात्मक-निश्चित कार्य]] है, अर्थात हम यह मान सकते हैं कि हम पहले ही दिखा चुके हैं कि {{math|'''x'''}} वर्तमान समय के लिए सरल है, इसके आधार पर उपप्रणाली ल्यपुनोव स्थिरता है, इस प्रकार स्थिर ल्यपुनोव के अर्थ में मोटे तौर पर, स्थिरता की इस धारणा का अर्थ है कि:
:जहाँ <math>W(\mathbf{x})</math> [[सकारात्मक-निश्चित कार्य|धनात्मक-निश्चित कार्य]] है, अर्थात हम यह मान सकते हैं कि हम पहले ही दिखा चुके हैं कि {{math|'''x'''}} वर्तमान समय के लिए सरल है, इसके आधार पर उपप्रणाली ल्यपुनोव स्थिरता है, इस प्रकार स्थिर ल्यपुनोव के अर्थ में मोटे तौर पर, स्थिरता की इस धारणा का अर्थ है कि:
** फलन <math>V_x</math> की सामान्यीकृत ऊर्जा के समान है, जहाँ पर {{math|'''x'''}} उपप्रणाली के रूप में {{math|'''x'''}} सिस्टम की अवस्थाएँ मूल, ऊर्जा से दूर चली जाती हैं, जिससे <math>V_x(\mathbf{x})</math> भी बढ़ता है।
** फलन <math>V_x</math> की सामान्यीकृत ऊर्जा के समान है, जहाँ पर {{math|'''x'''}} उपप्रणाली के रूप में {{math|'''x'''}} प्रणाली की अवस्थाएँ मूल, ऊर्जा से दूर चली जाती हैं, जिससे <math>V_x(\mathbf{x})</math> भी बढ़ता है।
** समय के साथ यह दिखाकर, ऊर्जा <math>V_x(\mathbf{x}(t))</math> शून्य हो जाता है, फिर पुनः {{math|'''x'''}} स्थिति <math> \mathbf{x}=\mathbf{0}\,</math> की ओर क्षय होना चाहिए, अर्थात् उत्पत्ति <math> \mathbf{x}=\mathbf{0}\,</math> प्रणाली का स्थिर संतुलन होगा - {{math|'''x'''}} जैसे-जैसे समय के साथ बढ़ेगा, स्थिति क्रमशः मूल के समीप पहुंचेंगी।
** समय के साथ यह दिखाकर, ऊर्जा <math>V_x(\mathbf{x}(t))</math> शून्य हो जाता है, फिर पुनः {{math|'''x'''}} स्थिति <math> \mathbf{x}=\mathbf{0}\,</math> की ओर क्षय होना चाहिए, अर्थात् उत्पत्ति <math> \mathbf{x}=\mathbf{0}\,</math> प्रणाली का स्थिर संतुलन होगा - {{math|'''x'''}} जैसे-जैसे समय के साथ बढ़ेगा, स्थिति क्रमशः मूल के समीप पहुंचेंगी।
** यह कहते हुए कि <math>W(\mathbf{x})</math> धनात्मक निश्चित का अर्थ है कि <math>W(\mathbf{x}) > 0</math> को छोड़कर हर स्थान पर <math> \mathbf{x}=\mathbf{0}\,</math>, और <math>W(\mathbf{0})=0</math> के समान हैं।
** यह कहते हुए कि <math>W(\mathbf{x})</math> धनात्मक निश्चित का अर्थ है कि <math>W(\mathbf{x}) > 0</math> को छोड़कर हर स्थान पर <math> \mathbf{x}=\mathbf{0}\,</math>, और <math>W(\mathbf{0})=0</math> के समान हैं।
** यह कथन <math>\dot{V}_x \leq -W(\mathbf{x})</math> अर्थ कि <math>\dot{V}_x</math> को छोड़कर सभी बिंदुओं <math> \mathbf{x} = \mathbf{0}\,</math> के लिए शून्य से दूर सीमाबद्ध है, अर्थात्, जब तक प्रणाली मूल पर अपने संतुलन पर नहीं है, तब तक इसकी ऊर्जा कम होती रहेगी।
** यह कथन <math>\dot{V}_x \leq -W(\mathbf{x})</math> अर्थ कि <math>\dot{V}_x</math> को छोड़कर सभी बिंदुओं <math> \mathbf{x} = \mathbf{0}\,</math> के लिए शून्य से दूर सीमाबद्ध है, अर्थात्, जब तक प्रणाली मूल पर अपने संतुलन पर नहीं है, तब तक इसकी ऊर्जा कम होती रहेगी।
** चूँकि ऊर्जा का सदैव क्षय होता रहता है, तो प्रणाली स्थिर होनी चाहिए, इसके प्रक्षेप पथ को मूल बिंदु तक पहुंचना चाहिए।
** चूँकि ऊर्जा का सदैव क्षय होता रहता है, तो प्रणाली स्थिर होनी चाहिए, इसके प्रक्षेप पथ को मूल बिंदु तक पहुंचना चाहिए।
:हमारा काम नियंत्रण ढूंढना है, इसके आधार पर {{mvar|u}} जो हमारे कैस्केड बनाता है, इसके लिए बिन्दु <math>(\mathbf{x},z_1)</math> सिस्टम भी स्थिर रहता हैं इसलिए हमें इस नई प्रणाली के लिए नया ल्यपुनोव फलन 'उम्मीदवार' ढूंढना होगा। वह उम्मीदवार नियंत्रण {{mvar|u}} पर निर्भर रहेगा, और नियंत्रण को सही ढंग से चुनकर, हम यह सुनिश्चित कर सकते हैं कि यह हर स्थान पर भी क्षय हो रहा है।
:हमारा काम नियंत्रण ढूंढना है, इसके आधार पर {{mvar|u}} जो हमारे कैस्केड बनाता है, इसके लिए बिन्दु <math>(\mathbf{x},z_1)</math> प्रणाली भी स्थिर रहता हैं इसलिए हमें इस नई प्रणाली के लिए नया ल्यपुनोव फलन 'उम्मीदवार' ढूंढना होगा। वह उम्मीदवार नियंत्रण {{mvar|u}} पर निर्भर रहेगा, और इस प्रकार नियंत्रण को सही ढंग से चुनकर, हम यह सुनिश्चित कर सकते हैं कि यह हर स्थान पर भी क्षय हो रहा है।


* आगे 'और' जोड़कर घटाएँ <math>g_x(\mathbf{x}) u_x(\mathbf{x})</math> (अर्थात, हम सिस्टम को किसी भी तरह से नहीं बदलते क्योंकि हम कोई शुद्ध प्रभाव नहीं डालते हैं)। इसके आधार पर <math>\dot{\mathbf{x}}</math> बड़े का भाग <math>(\mathbf{x},z_1)</math> सिस्टम यह बन जाता है
* <math>g_x(\mathbf{x}) u_x(\mathbf{x})</math> के आगे 'और' जोड़कर घटाएँ (अर्थात, हम प्रणाली को किसी भी तरह से यह मान नहीं बदलते क्योंकि हम कोई शुद्ध प्रभाव नहीं डालते हैं)। इसके आधार पर <math>\dot{\mathbf{x}}</math> बड़े का भाग <math>(\mathbf{x},z_1)</math> प्रणाली यह बन जाता है।


::<math>\begin{cases}\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) z_1 + \mathord{\underbrace{\left( g_x(\mathbf{x})u_x(\mathbf{x}) - g_x(\mathbf{x})u_x(\mathbf{x}) \right)}_{0}}\\\dot{z}_1 = u_1\end{cases}</math>
::<math>\begin{cases}\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) z_1 + \mathord{\underbrace{\left( g_x(\mathbf{x})u_x(\mathbf{x}) - g_x(\mathbf{x})u_x(\mathbf{x}) \right)}_{0}}\\\dot{z}_1 = u_1\end{cases}</math>
Line 132: Line 132:


::<math>\begin{cases}\dot{x} = \mathord{\underbrace{\left( f_x(\mathbf{x}) + g_x(\mathbf{x})u_x(\mathbf{x}) \right)}_{F(\mathbf{x})}} + g_x(\mathbf{x}) \underbrace{\left( z_1 - u_x(\mathbf{x}) \right)}_{z_1 \text{ error tracking } u_x}\\\dot{z}_1 = u_1\end{cases}</math>
::<math>\begin{cases}\dot{x} = \mathord{\underbrace{\left( f_x(\mathbf{x}) + g_x(\mathbf{x})u_x(\mathbf{x}) \right)}_{F(\mathbf{x})}} + g_x(\mathbf{x}) \underbrace{\left( z_1 - u_x(\mathbf{x}) \right)}_{z_1 \text{ error tracking } u_x}\\\dot{z}_1 = u_1\end{cases}</math>
:तो हमारा कैस्केड सुपरसिस्टम ज्ञात-स्थिर <math>\dot{\mathbf{x}} = F(\mathbf{x})</math> को समाहित करता है, इसके कारण उपप्रणाली प्लस इंटीग्रेटर द्वारा उत्पन्न कुछ त्रुटि पायी गयी हैं।
:तो हमारा कैस्केड उपप्रणाली ज्ञात-स्थिर <math>\dot{\mathbf{x}} = F(\mathbf{x})</math> को समाहित करता है, इसके कारण उपप्रणाली प्लस इंटीग्रेटर द्वारा उत्पन्न कुछ त्रुटि पायी गयी हैं।


* अब हम वेरिएबल्स को परविर्तित कर सकते हैं, जैसे <math>(\mathbf{x}, z_1)</math> को <math>(\mathbf{x}, e_1)</math> में परिवर्तित करने से <math>e_1 \triangleq z_1 - u_x(\mathbf{x})</math> भी मान प्राप्त हो सकता हैं। इसलिए
* अब हम वेरिएबल्स को परविर्तित कर सकते हैं, जैसे <math>(\mathbf{x}, z_1)</math> को <math>(\mathbf{x}, e_1)</math> में परिवर्तित करने से <math>e_1 \triangleq z_1 - u_x(\mathbf{x})</math> भी मान प्राप्त हो सकता हैं। इसलिए
Line 141: Line 141:


::<math>\begin{cases}\dot{\mathbf{x}} = (f_x(\mathbf{x}) + g_x(\mathbf{x}) u_x(\mathbf{x}))+g_x(\mathbf{x}) e_1\\\dot{e}_1 = v_1\end{cases}</math>
::<math>\begin{cases}\dot{\mathbf{x}} = (f_x(\mathbf{x}) + g_x(\mathbf{x}) u_x(\mathbf{x}))+g_x(\mathbf{x}) e_1\\\dot{e}_1 = v_1\end{cases}</math>
: हम नए नियंत्रण के माध्यम से फीडबैक द्वारा इस त्रुटि प्रणाली <math>v_1</math> को स्थिर करना चाहते हैं, इस प्रकार किसी सिस्टम को स्थिर करके <math>e_1 = 0</math>, स्थिति <math>z_1</math> वांछित नियंत्रण <math>u_x</math> को ट्रैक करेगा, जिसके परिणामस्वरूप आंतरिक स्थिरता {{math|'''x'''}} उपप्रणाली के अनुसार आएगी।
: हम नए नियंत्रण के माध्यम से फीडबैक द्वारा इस त्रुटि प्रणाली <math>v_1</math> को स्थिर करना चाहते हैं, इस प्रकार किसी प्रणाली को स्थिर करके <math>e_1 = 0</math>, स्थिति <math>z_1</math> वांछित नियंत्रण <math>u_x</math> को ट्रैक करेगा, जिसके परिणामस्वरूप आंतरिक स्थिरता {{math|'''x'''}} उपप्रणाली के अनुसार आएगी।


* हमारे उपस्थिता ल्यपुनोव फलन से <math>V_x</math>, हम संवर्धित ल्यपुनोव फलन उम्मीदवार को परिभाषित करते हैं
* हमारे उपस्थिता ल्यपुनोव फलन से <math>V_x</math>, हम संवर्धित ल्यपुनोव फलन उम्मीदवार को परिभाषित करते हैं
Line 159: Line 159:


::<math>\dot{V}_1 = \overbrace{\frac{\partial V_x}{\partial \mathbf{x}}(f_x(\mathbf{x}) + g_x(\mathbf{x}) u_x(\mathbf{x}))}^{{} \leq -W(\mathbf{x})} + \frac{\partial V_x}{\partial \mathbf{x}}g_x(\mathbf{x}) e_1 + e_1 v_1 \leq -W(\mathbf{x})+ \frac{\partial V_x}{\partial \mathbf{x}} g_x(\mathbf{x}) e_1 + e_1 v_1</math>
::<math>\dot{V}_1 = \overbrace{\frac{\partial V_x}{\partial \mathbf{x}}(f_x(\mathbf{x}) + g_x(\mathbf{x}) u_x(\mathbf{x}))}^{{} \leq -W(\mathbf{x})} + \frac{\partial V_x}{\partial \mathbf{x}}g_x(\mathbf{x}) e_1 + e_1 v_1 \leq -W(\mathbf{x})+ \frac{\partial V_x}{\partial \mathbf{x}} g_x(\mathbf{x}) e_1 + e_1 v_1</math>
: यह सुनिश्चित करने के लिए <math>\dot{V}_1 \leq -W(\mathbf{x}) < 0</math> अर्थात, सुपरसिस्टम की स्थिरता सुनिश्चित करने के लिए हम नियंत्रण नियम को ही चुनते हैं।
: यह सुनिश्चित करने के लिए <math>\dot{V}_1 \leq -W(\mathbf{x}) < 0</math> अर्थात, उपप्रणाली की स्थिरता सुनिश्चित करने के लिए हम नियंत्रण नियम को ही चुनते हैं।


::<math>v_1 = -\frac{\partial V_x}{\partial \mathbf{x}}g_x(\mathbf{x})- k_1 e_1</math>
::<math>v_1 = -\frac{\partial V_x}{\partial \mathbf{x}}g_x(\mathbf{x})- k_1 e_1</math>
Line 176: Line 176:
&< 0
&< 0
\end{align}</math>
\end{align}</math>
: तो हमारे उम्मीदवार ल्यपुनोव कार्य करते हैं, यहाँ पर <math>V_1</math> ल्यपुनोव फलन है, और हमारा सिस्टम इस नियंत्रण नियम के अनुसार स्थिर है, इसलिए <math>v_1</math> जो नियंत्रण नियम <math>u_1</math> से मेल खाता है, क्योंकि <math>v_1 \triangleq u_1 - \dot{u}_x</math> के समान हैं, इसके कारण मूल समन्वय प्रणाली से चर का उपयोग करते हुए समतुल्य ल्यपुनोव फलन का उपयोग किया जाता हैं।
: तो हमारे उम्मीदवार ल्यपुनोव कार्य करते हैं, यहाँ पर <math>V_1</math> ल्यपुनोव फलन है, और हमारा प्रणाली इस नियंत्रण नियम के अनुसार स्थिर है, इसलिए <math>v_1</math> जो नियंत्रण नियम <math>u_1</math> से मेल खाता है, क्योंकि <math>v_1 \triangleq u_1 - \dot{u}_x</math> के समान हैं, इसके कारण मूल समन्वय प्रणाली से चर का उपयोग करते हुए समतुल्य ल्यपुनोव फलन का उपयोग किया जाता हैं।
:
:


Line 190: Line 190:
| {{EquationRef|3}}}}
| {{EquationRef|3}}}}


: स्थिति {{math|'''x'''}} और <math>z_1</math> और कार्य <math>f_x</math> और <math>g_x</math> सिस्टम से फलन <math>u_x</math> हमारे ज्ञात-स्थिर से आता है,  <math>\dot{\mathbf{x}}=F(\mathbf{x})</math> उपप्रणाली के लाभ के लिए पैरामीटर <math>k_1 > 0</math> का अभिसरण करके इसकी उचित दर या हमारे सिस्टम को प्रभावित करता है। इस नियंत्रण नियम के अनुसार हमारी प्रणाली मूल में ल्यपुनोव स्थिरता <math>(\mathbf{x},z_1)=(\mathbf{0},0)</math> पायी जाती है।
: स्थिति {{math|'''x'''}} और <math>z_1</math> और कार्य <math>f_x</math> और <math>g_x</math> प्रणाली से फलन <math>u_x</math> हमारे ज्ञात-स्थिर से आता है,  <math>\dot{\mathbf{x}}=F(\mathbf{x})</math> उपप्रणाली के लाभ के लिए पैरामीटर <math>k_1 > 0</math> का अभिसरण करके इसकी उचित दर या हमारे प्रणाली को प्रभावित करता है। इस नियंत्रण नियम के अनुसार हमारी प्रणाली मूल में ल्यपुनोव स्थिरता <math>(\mathbf{x},z_1)=(\mathbf{0},0)</math> पायी जाती है।


: याद रखें कि <math>u_1</math> समीकरण में ({{EquationNote|3}}) इंटीग्रेटर के इनपुट को चलाता है जो उपप्रणाली से जुड़ा होता है जो नियंत्रण नियम <math>u_x</math> द्वारा फीडबैक-स्थिर होता है, यहाँ पर आश्चर्य की बात नहीं हैं, क्यूंकि नियंत्रण <math>u_1</math> <math>\dot{u}_x</math> वह शब्द जिसे स्थिरीकरण नियंत्रण नियम का पालन करने के लिए एकीकृत किया जाएगा, तथा <math>\dot{u}_x</math> के साथ ही कुछ ऑफसेट भी मिल जाते हैं। इस प्रकार इसकी अन्य शर्तें उस ऑफसेट और किसी अन्य त्रुटियों के प्रभाव को हटाने के लिए डंपिंग प्रदान करती हैं जिसे इंटीग्रेटर द्वारा बढ़ाया जाएगा।
: याद रखें कि <math>u_1</math> समीकरण में ({{EquationNote|3}}) इंटीग्रेटर के इनपुट को चलाता है जो उपप्रणाली से जुड़ा होता है जो नियंत्रण नियम <math>u_x</math> द्वारा फीडबैक-स्थिर होता है, यहाँ पर आश्चर्य की बात नहीं हैं, क्यूंकि नियंत्रण <math>u_1</math> <math>\dot{u}_x</math> वह शब्द जिसे स्थिरीकरण नियंत्रण नियम का पालन करने के लिए एकीकृत किया जाएगा, तथा <math>\dot{u}_x</math> के साथ ही कुछ ऑफसेट भी मिल जाते हैं। इस प्रकार इसकी अन्य शर्तें उस ऑफसेट और किसी अन्य त्रुटियों के प्रभाव को हटाने के लिए डंपिंग प्रदान करती हैं जिसे इंटीग्रेटर द्वारा बढ़ाया जाएगा।


इसलिए क्योंकि यह सिस्टम फीडबैक <math>u_1(\mathbf{x}, z_1)</math> द्वारा स्थिर है, और इसमें ल्यपुनोव फलन <math>V_1(\mathbf{x},z_1)</math> साथ <math>\dot{V}_1(\mathbf{x}, z_1) \leq -W(\mathbf{x}) < 0</math> है , इसका उपयोग किसी अन्य सिंगल-इंटीग्रेटर कैस्केड सिस्टम में ऊपरी उपप्रणाली के रूप में किया जा सकता है।
इसलिए क्योंकि यह प्रणाली फीडबैक <math>u_1(\mathbf{x}, z_1)</math> द्वारा स्थिर है, और इसमें ल्यपुनोव फलन <math>V_1(\mathbf{x},z_1)</math> साथ <math>\dot{V}_1(\mathbf{x}, z_1) \leq -W(\mathbf{x}) < 0</math> के समान है , इसका उपयोग किसी अन्य सिंगल-इंटीग्रेटर कैस्केड प्रणाली में ऊपरी उपप्रणाली के रूप में किया जा सकता है।


=== प्रेरक उदाहरण: दो-इंटीग्रेटर बैकस्टेपिंग ===
=== प्रेरक उदाहरण: दो-इंटीग्रेटर बैकस्टेपिंग ===
Line 206: Line 206:
| {{EquationRef|4}}}}
| {{EquationRef|4}}}}


जहाँ <math>\mathbf{x} \in \mathbb{R}^n</math> और <math>z_1</math> और <math>z_2</math> अदिश हैं, यह सिस्टम समीकरण में सिंगल-इंटीग्रेटर सिस्टम का कैस्केड कनेक्शन है, जहाँ पर समीकरण ({{EquationNote|1}}) दूसरे इंटीग्रेटर के साथ (अर्थात, इनपुट <math>u_2</math> इंटीग्रेटर के माध्यम से प्रवेश करता है, और उस इंटीग्रेटर का आउटपुट समीकरण में सिस्टम में प्रवेश करता है, इस प्रकार समीकरण ({{EquationNote|1}}) के द्वारा <math>u_1</math> इनपुट प्राप्त होता हैं।
जहाँ <math>\mathbf{x} \in \mathbb{R}^n</math> और <math>z_1</math> और <math>z_2</math> अदिश हैं, यह प्रणाली समीकरण में सिंगल-इंटीग्रेटर प्रणाली का कैस्केड कनेक्शन है, जहाँ पर समीकरण ({{EquationNote|1}}) दूसरे इंटीग्रेटर के साथ (अर्थात, इनपुट <math>u_2</math> इंटीग्रेटर के माध्यम से प्रवेश करता है, और उस इंटीग्रेटर का आउटपुट समीकरण में प्रणाली में प्रवेश करता है, इस प्रकार समीकरण ({{EquationNote|1}}) के द्वारा <math>u_1</math> इनपुट प्राप्त होता हैं।


जो इस प्रकार हैं-
जो इस प्रकार हैं-
Line 220: Line 220:
| {{EquationRef|5}}}}
| {{EquationRef|5}}}}


एकल-एकीकरणकर्ता प्रक्रिया द्वारा, नियंत्रण नियम <math>u_y(\mathbf{y}) \triangleq u_1(\mathbf{x},z_1)</math> ऊपरी भाग को स्थिर करता है, जहाँ पर <math>z_2</math>-को-{{math|'''y'''}} ल्यपुनोव फलन का उपयोग कर उपप्रणाली <math>V_1(\mathbf{x},z_1)</math>, और इसलिए समीकरण ({{EquationNote|5}}) नया सिंगल-इंटीग्रेटर सिस्टम है जो संरचनात्मक रूप से समीकरण में सिंगल-इंटीग्रेटर सिस्टम के बराबर है ({{EquationNote|1}}). तो स्थिर नियंत्रण <math>u_2</math> उसी एकल-इंटीग्रेटर प्रक्रिया का उपयोग करके पाया जा सकता है जिसका उपयोग <math>u_1</math> का मान खोजने के लिए किया गया था।
एकल-एकीकरणकर्ता प्रक्रिया द्वारा, नियंत्रण नियम <math>u_y(\mathbf{y}) \triangleq u_1(\mathbf{x},z_1)</math> ऊपरी भाग को स्थिर करता है, जहाँ पर <math>z_2</math>-को-{{math|'''y'''}} ल्यपुनोव फलन का उपयोग कर उपप्रणाली <math>V_1(\mathbf{x},z_1)</math>, और इसलिए समीकरण ({{EquationNote|5}}) नया सिंगल-इंटीग्रेटर प्रणाली है जो संरचनात्मक रूप से समीकरण में सिंगल-इंटीग्रेटर प्रणाली के बराबर है ({{EquationNote|1}}). तो स्थिर नियंत्रण <math>u_2</math> उसी एकल-इंटीग्रेटर प्रक्रिया का उपयोग करके पाया जा सकता है जिसका उपयोग <math>u_1</math> का मान खोजने के लिए किया गया था।


===अनेक-इंटीग्रेटर बैकस्टेपिंग===
===अनेक-इंटीग्रेटर बैकस्टेपिंग===


दो-इंटीग्रेटर स्थिति में, ऊपरी सिंगल-इंटीग्रेटर उपप्रणाली को नया सिंगल-इंटीग्रेटर सिस्टम प्रदान करते हुए स्थिर किया गया था जिसे समान रूप से स्थिर किया जा सकता है। इस पुनरावर्ती प्रक्रिया को किसी भी सीमित संख्या में इंटीग्रेटर्स को संभालने के लिए बढ़ाया जा सकता है। इस प्रमाण को औपचारिक रूप से [[गणितीय प्रेरण]] के साथ सिद्ध किया जा सकता है। यहां, पहले से स्थिर मल्टीपल-इंटीग्रेटर उपप्रणाली के उपप्रणाली से स्थिर मल्टीपल-इंटीग्रेटर सिस्टम बनाया गया है।
दो-इंटीग्रेटर स्थिति में, ऊपरी सिंगल-इंटीग्रेटर उपप्रणाली को नया सिंगल-इंटीग्रेटर प्रणाली प्रदान करते हुए स्थिर किया गया था जिसे समान रूप से स्थिर किया जा सकता है। इस पुनरावर्ती प्रक्रिया को किसी भी सीमित संख्या में इंटीग्रेटर्स को संभालने के लिए बढ़ाया जा सकता है। इस प्रमाण को औपचारिक रूप से [[गणितीय प्रेरण]] के साथ सिद्ध किया जा सकता है। यहां, पहले से स्थिर मल्टीपल-इंटीग्रेटर उपप्रणाली के उपप्रणाली से स्थिर मल्टीपल-इंटीग्रेटर प्रणाली बनाया गया है।


* सबसे पहले, गतिशील प्रणाली पर विचार करें
* सबसे पहले, गतिशील प्रणाली पर विचार करें
::<math>\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) u_x</math>
::<math>\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) u_x</math>
:उसमें अदिश इनपुट है <math>u_x</math> और आउटपुट स्थितियाँ <math>\mathbf{x} = [x_1, x_2, \ldots, x_n]^{\text{T}} \in \mathbb{R}^n</math>. ये मान लीजिए
:उसमें अदिश इनपुट है <math>u_x</math> और आउटपुट स्थितियाँ <math>\mathbf{x} = [x_1, x_2, \ldots, x_n]^{\text{T}} \in \mathbb{R}^n</math>
**<math>f_x(\mathbf{x}) = \mathbf{0}</math> जिससे कि शून्य-इनपुट (अर्थात, <math>u_x = 0</math>) प्रणाली मूल बिंदु पर स्थिर बिंदु <math> \mathbf{x} = \mathbf{0}\,</math> है, इस स्थिति में, उत्पत्ति को प्रणाली का संतुलन कहा जाता है।
*<math>f_x(\mathbf{x}) = \mathbf{0}</math> जिससे कि शून्य-इनपुट (अर्थात, <math>u_x = 0</math>) प्रणाली मूल बिंदु पर स्थिर बिंदु <math> \mathbf{x} = \mathbf{0}\,</math> है, इस स्थिति में, उत्पत्ति को प्रणाली का संतुलन कहा जाता है।
**फीडबैक नियंत्रण नियम <math>u_x(\mathbf{x})</math> प्रणाली को मूल बिंदु पर संतुलन पर स्थिर करता है।
*फीडबैक नियंत्रण नियम <math>u_x(\mathbf{x})</math> प्रणाली को मूल बिंदु पर संतुलन पर स्थिर करता है।
**इस प्रणाली के अनुरूप ल्यपुनोव फलन <math>V_x(\mathbf{x})</math> का वर्णन किया गया है।
*इस प्रणाली के अनुरूप ल्यपुनोव फलन <math>V_x(\mathbf{x})</math> का वर्णन किया गया है।
:अर्थात्, यदि आउटपुट बताता है {{math|'''x'''}} को वापस इनपुट में <math>u_x</math> का मान फीड किया जाता है, इस प्रकार नियंत्रण नियम द्वारा <math>u_x(\mathbf{x})</math>, फिर आउटपुट स्थिति (और ल्यपुनोव फलन) एकल त्रुटि के बाद मूल पर लौट आती है, उदाहरण के लिए, गैर-शून्य प्रारंभिक स्थिति या तेज त्रुटि के बाद यह मान प्राप्त होता हैं। यह उपप्रणाली फीडबैक नियंत्रण नियम  <math>u_x</math> द्वारा स्थिर रहता है।
:अर्थात्, यदि आउटपुट बताता है {{math|'''x'''}} को वापस इनपुट में <math>u_x</math> का मान फीड किया जाता है, इस प्रकार नियंत्रण नियम द्वारा <math>u_x(\mathbf{x})</math>, फिर आउटपुट स्थिति (और ल्यपुनोव फलन) एकल त्रुटि के बाद मूल पर लौट आती है, उदाहरण के लिए, गैर-शून्य प्रारंभिक स्थिति या तेज त्रुटि के बाद यह मान प्राप्त होता हैं। यह उपप्रणाली फीडबैक नियंत्रण नियम  <math>u_x</math> द्वारा स्थिर रहता है।


* इसके बाद, इंटीग्रेटर को इनपुट <math>u_x</math> से कनेक्ट करें, जिससे कि संवर्धित सिस्टम में इनपुट होता हैं, जहाँ पर इंटीग्रेटर के लिए  <math>u_1</math> और आउटपुट स्थिति के लिए {{math|'''x'''}} को परिणामी संवर्धित गतिशील प्रणाली के रूप में दर्शाते है-
* इसके बाद, इंटीग्रेटर को इनपुट <math>u_x</math> से कनेक्ट करें, जिससे कि संवर्धित प्रणाली में इनपुट होता हैं, जहाँ पर इंटीग्रेटर के लिए  <math>u_1</math> और आउटपुट स्थिति के लिए {{math|'''x'''}} को परिणामी संवर्धित गतिशील प्रणाली के रूप में दर्शाते है-
::<math>\begin{cases}
::<math>\begin{cases}
\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) z_1\\
\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) z_1\\
\dot{z}_1 = u_1
\dot{z}_1 = u_1
\end{cases}</math>
\end{cases}</math>
:यह कैस्केड सिस्टम समीकरण के फॉर्म से मेल खाता है ({{EquationNote|1}}), और इसलिए सिंगल-इंटीग्रेटर बैकस्टेपिंग प्रक्रिया समीकरण में स्थिर नियंत्रण नियम  ({{EquationNote|3}}) की ओर ले जाती है। अर्थात यदि हम स्थितिों को फीड बैक करते हैं <math>z_1</math> और {{math|'''x'''}} निवेश करने के लिए <math>u_1</math> नियंत्रण नियम के अनुसार हमें यह समीकरण प्राप्त होता हैं-
:यह कैस्केड प्रणाली समीकरण के फॉर्म से मेल खाता है ({{EquationNote|1}}), और इसलिए सिंगल-इंटीग्रेटर बैकस्टेपिंग प्रक्रिया समीकरण में स्थिर नियंत्रण नियम  ({{EquationNote|3}}) की ओर ले जाती है। अर्थात यदि हम स्थितिों को फीड बैक करते हैं <math>z_1</math> और {{math|'''x'''}} निवेश करने के लिए <math>u_1</math> नियंत्रण नियम के अनुसार हमें यह समीकरण प्राप्त होता हैं-
::<math>u_1(\mathbf{x},z_1)=-\frac{\partial V_x}{\partial \mathbf{x}}g_x(\mathbf{x})-k_1(z_1-u_x(\mathbf{x})) + \frac{\partial u_x}{\partial \mathbf{x}}(f_x(\mathbf{x})+g_x(\mathbf{x})z_1)</math>
::<math>u_1(\mathbf{x},z_1)=-\frac{\partial V_x}{\partial \mathbf{x}}g_x(\mathbf{x})-k_1(z_1-u_x(\mathbf{x})) + \frac{\partial u_x}{\partial \mathbf{x}}(f_x(\mathbf{x})+g_x(\mathbf{x})z_1)</math>
: इस कारण लाभ के साथ <math>k_1 > 0</math>, फिर स्थिति <math>z_1</math> और {{math|'''x'''}} पर वापस आ जाएगा <math>z_1 = 0</math> और <math> \mathbf{x}=\mathbf{0}\,</math> ही इस उपप्रणाली के फीडबैक नियंत्रण नियम <math>u_1</math> द्वारा स्थिर होती है, और समीकरण से संबंधित ल्यपुनोव फलन ({{EquationNote|2}}) के रूप में दर्शाते हैं-
: इस कारण लाभ के साथ <math>k_1 > 0</math>, फिर स्थिति <math>z_1</math> और {{math|'''x'''}} पर वापस आ जाएगा <math>z_1 = 0</math> और <math> \mathbf{x}=\mathbf{0}\,</math> ही इस उपप्रणाली के फीडबैक नियंत्रण नियम <math>u_1</math> द्वारा स्थिर होती है, और समीकरण से संबंधित ल्यपुनोव फलन ({{EquationNote|2}}) के रूप में दर्शाते हैं-
Line 245: Line 245:
:अर्थात, फीडबैक नियंत्रण नियम के अनुसार  <math>u_1</math>, ल्यपुनोव फलन <math>V_1</math> जैसे-जैसे अवस्थाएँ मूल में लौटती हैं, जो बाद में शून्य हो जाती है।
:अर्थात, फीडबैक नियंत्रण नियम के अनुसार  <math>u_1</math>, ल्यपुनोव फलन <math>V_1</math> जैसे-जैसे अवस्थाएँ मूल में लौटती हैं, जो बाद में शून्य हो जाती है।


* इनपुट के लिए नया इंटीग्रेटर <math>u_1</math>कनेक्ट करते हैं, जिससे कि संवर्धित सिस्टम में इनपुट हो <math>u_2</math> और आउटपुट स्थितियाँ {{math|'''x'''}}. परिणामी संवर्धित गतिशील प्रणाली है
* इनपुट के लिए नया इंटीग्रेटर <math>u_1</math>कनेक्ट करते हैं, जिससे कि संवर्धित प्रणाली में इनपुट हो <math>u_2</math> और आउटपुट स्थितियाँ {{math|'''x'''}} परिणामी संवर्धित गतिशील प्रणाली है
::<math>\begin{cases}
::<math>\begin{cases}
\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) z_1\\
\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) z_1\\
Line 251: Line 251:
\dot{z}_2 = u_2
\dot{z}_2 = u_2
\end{cases}</math>
\end{cases}</math>
:जो सिंगल-इंटीग्रेटर सिस्टम के समान होता है।
:जो सिंगल-इंटीग्रेटर प्रणाली के समान होता है।
::<math>\begin{cases}
::<math>\begin{cases}
\overbrace{ \begin{bmatrix} \dot{\mathbf{x}}\\ \dot{z}_1 \end{bmatrix} }^{\triangleq \, \dot{\mathbf{x}}_1}
\overbrace{ \begin{bmatrix} \dot{\mathbf{x}}\\ \dot{z}_1 \end{bmatrix} }^{\triangleq \, \dot{\mathbf{x}}_1}
Line 260: Line 260:
\dot{z}_2 = u_2
\dot{z}_2 = u_2
\end{cases}</math>
\end{cases}</math>
:<math>\mathbf{x}_1</math>, <math>f_1</math>, और <math>g_1</math> के आधार पर इन परिभाषाओं का उपयोग करना, जिसके लिए इस प्रकार की प्रणाली को इस प्रकार भी व्यक्त किया जा सकता है
:<math>\mathbf{x}_1</math>, <math>f_1</math>, और <math>g_1</math> के आधार पर इन परिभाषाओं का उपयोग करना, जिसके लिए इस प्रकार की प्रणाली को इस प्रकार भी व्यक्त किया जा सकता है।
::<math>\begin{cases}
::<math>\begin{cases}
\dot{\mathbf{x}}_1 = f_1(\mathbf{x}_1) + g_1(\mathbf{x}_1) z_2 &\qquad \text{ ( by Lyapunov function } V_1, \text{ subsystem stabilized by } u_1(\textbf{x}_1) \text{ )}\\
\dot{\mathbf{x}}_1 = f_1(\mathbf{x}_1) + g_1(\mathbf{x}_1) z_2 &\qquad \text{ ( by Lyapunov function } V_1, \text{ subsystem stabilized by } u_1(\textbf{x}_1) \text{ )}\\
Line 271: Line 271:
:अर्थात, फीडबैक नियंत्रण नियम के तहत <math>u_2</math>, ल्यपुनोव फलन <math>V_2</math> जैसे-जैसे अवस्थाएँ मूल में लौटती हैं, शून्य हो जाती है।
:अर्थात, फीडबैक नियंत्रण नियम के तहत <math>u_2</math>, ल्यपुनोव फलन <math>V_2</math> जैसे-जैसे अवस्थाएँ मूल में लौटती हैं, शून्य हो जाती है।


* एक इंटीग्रेटर को इनपुट से कनेक्ट करें <math>u_2</math> जिससे कि संवर्धित सिस्टम में इनपुट हो <math>u_3</math> और आउटपुट स्थितियाँ {{math|'''x'''}}. परिणामी संवर्धित गतिशील प्रणाली है
* एक इंटीग्रेटर को इनपुट से कनेक्ट करें <math>u_2</math> जिससे कि संवर्धित प्रणाली में इनपुट हो <math>u_3</math> और आउटपुट स्थितियाँ {{math|'''x'''}}. परिणामी संवर्धित गतिशील प्रणाली है
::<math>\begin{cases}
::<math>\begin{cases}
\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) z_1\\
\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) z_1\\
Line 278: Line 278:
\dot{z}_3 = u_3
\dot{z}_3 = u_3
\end{cases}</math>
\end{cases}</math>
:जिसे एकल-एकीकरणकर्ता प्रणाली के रूप में पुनः समूहीकृत किया जा सकता है
:जिसे एकल-एकीकरणकर्ता प्रणाली के रूप में पुनः समूहीकृत किया जा सकता है।
::<math>\begin{cases}
::<math>\begin{cases}
\overbrace{ \begin{bmatrix} \dot{\mathbf{x}}\\ \dot{z}_1\\ \dot{z}_2 \end{bmatrix} }^{\triangleq \, \dot{\mathbf{x}}_2}
\overbrace{ \begin{bmatrix} \dot{\mathbf{x}}\\ \dot{z}_1\\ \dot{z}_2 \end{bmatrix} }^{\triangleq \, \dot{\mathbf{x}}_2}
Line 287: Line 287:
\dot{z}_3 = u_3
\dot{z}_3 = u_3
\end{cases}</math>
\end{cases}</math>
:इस परिभाषा के अनुसार <math>\mathbf{x}_1</math>, <math>f_1</math>, और <math>g_1</math> पिछले चरण से, इस प्रणाली का भी प्रतिनिधित्व किया जाता है
:इस परिभाषा के अनुसार <math>\mathbf{x}_1</math>, <math>f_1</math>, और <math>g_1</math> पिछले चरण से, इस प्रणाली का भी प्रतिनिधित्व किया जाता है।
::<math>\begin{cases}
::<math>\begin{cases}
\overbrace{ \begin{bmatrix} \dot{\mathbf{x}}_1\\ \dot{z}_2 \end{bmatrix} }^{\dot{\mathbf{x}}_2}
\overbrace{ \begin{bmatrix} \dot{\mathbf{x}}_1\\ \dot{z}_2 \end{bmatrix} }^{\dot{\mathbf{x}}_2}
Line 296: Line 296:
\dot{z}_3 = u_3
\dot{z}_3 = u_3
\end{cases}</math>
\end{cases}</math>
:आगे, इन परिभाषाओं का उपयोग करते हुए <math>\mathbf{x}_2</math>, <math>f_2</math>, और <math>g_2</math>, इस प्रणाली को इस प्रकार भी व्यक्त किया जा सकता है
:आगे, इन परिभाषाओं का उपयोग करते हुए <math>\mathbf{x}_2</math>, <math>f_2</math>, और <math>g_2</math>, इस प्रणाली को इस प्रकार भी व्यक्त किया जा सकता है।
::<math>\begin{cases}
::<math>\begin{cases}
\dot{\mathbf{x}}_2 = f_2(\mathbf{x}_2) + g_2(\mathbf{x}_2) z_3 &\qquad \text{ ( by Lyapunov function } V_2, \text{ subsystem stabilized by } u_2(\textbf{x}_2) \text{ )}\\
\dot{\mathbf{x}}_2 = f_2(\mathbf{x}_2) + g_2(\mathbf{x}_2) z_3 &\qquad \text{ ( by Lyapunov function } V_2, \text{ subsystem stabilized by } u_2(\textbf{x}_2) \text{ )}\\
\dot{z}_3 = u_3
\dot{z}_3 = u_3
\end{cases}</math>
\end{cases}</math>
:तो पुनः समूहित प्रणाली में समीकरण की एकल-एकीकृत संरचना है ({{EquationNote|1}}), और इसलिए सिंगल-इंटीग्रेटर बैकस्टेपिंग प्रक्रिया को फिर से लागू किया जा सकता है। अर्थात, यदि हम स्थितिों को फीड बैक करते हैं <math>z_1</math>, <math>z_2</math>, <math>z_3</math>, और {{math|'''x'''}} निवेश करने के लिए <math>u_3</math> नियंत्रण नियम के अनुसार
:तो पुनः समूहित प्रणाली में समीकरण की एकल-एकीकृत संरचना है ({{EquationNote|1}}), और इसलिए सिंगल-इंटीग्रेटर बैकस्टेपिंग प्रक्रिया को फिर से लागू किया जा सकता है। अर्थात, यदि हम <math>z_1</math> से जुड़ी इस स्थिति फीडबैक करते हैं , तो इसके अनुसार <math>z_2</math>, <math>z_3</math>, और {{math|'''x'''}} निवेश करने के लिए <math>u_3</math> नियंत्रण नियम के अनुसार इस समीकरण द्वारा दर्शाया जाता हैं।
::<math>u_3(\mathbf{x},z_1,z_2,z_3)=-\frac{\partial V_2}{\partial \mathbf{x}_2 } g_2(\mathbf{x}_2)-k_3(z_3-u_2(\mathbf{x}_2)) + \frac{\partial u_2}{\partial \mathbf{x}_2}(f_2(\mathbf{x}_2)+g_2(\mathbf{x}_2)z_3)</math>
::<math>u_3(\mathbf{x},z_1,z_2,z_3)=-\frac{\partial V_2}{\partial \mathbf{x}_2 } g_2(\mathbf{x}_2)-k_3(z_3-u_2(\mathbf{x}_2)) + \frac{\partial u_2}{\partial \mathbf{x}_2}(f_2(\mathbf{x}_2)+g_2(\mathbf{x}_2)z_3)</math>
:लाभ के साथ <math>k_3 > 0</math>, फिर स्थिति <math>z_1</math>, <math>z_2</math>, <math>z_3</math>, और {{math|'''x'''}} पर वापस आ जाएगा <math>z_1 = 0</math>, <math>z_2 = 0</math>, <math>z_3 = 0</math>, और <math> \mathbf{x}=\mathbf{0}\,</math> ही इस उपप्रणाली के फीडबैक नियंत्रण नियम <math>u_3</math> द्वारा स्थिर है, और संबंधित ल्यपुनोव फलन है
:इस प्रकार लाभ के साथ <math>k_3 > 0</math>, फिर स्थिति <math>z_1</math>, <math>z_2</math>, <math>z_3</math>, और {{math|'''x'''}} पर वापस आ जाएगा <math>z_1 = 0</math>, <math>z_2 = 0</math>, <math>z_3 = 0</math>, और <math> \mathbf{x}=\mathbf{0}\,</math> ही इस उपप्रणाली के फीडबैक नियंत्रण नियम <math>u_3</math> द्वारा स्थिर है, और संबंधित ल्यपुनोव फलन है।
::<math>V_3(\mathbf{x},z_1,z_2,z_3) = V_2(\mathbf{x}_2) + \frac{1}{2}( z_3 - u_2(\mathbf{x}_2) )^2</math>
::<math>V_3(\mathbf{x},z_1,z_2,z_3) = V_2(\mathbf{x}_2) + \frac{1}{2}( z_3 - u_2(\mathbf{x}_2) )^2</math>
:अर्थात, फीडबैक नियंत्रण नियम के तहत <math>u_3</math>, ल्यपुनोव फलन <math>V_3</math> जैसे-जैसे अवस्थाएँ मूल में लौटती हैं, शून्य हो जाती है।
:अर्थात, फीडबैक नियंत्रण नियम के तहत <math>u_3</math>, ल्यपुनोव फलन <math>V_3</math> जैसे-जैसे अवस्थाएँ मूल में लौटती हैं, शून्य हो जाती है।


* यह प्रक्रिया सिस्टम में जोड़े गए प्रत्येक इंटीग्रेटर और इसलिए फॉर्म के किसी भी सिस्टम के लिए जारी रह सकती है
* यह प्रक्रिया प्रणाली में जोड़े गए प्रत्येक इंटीग्रेटर और इसलिए फॉर्म के किसी भी प्रणाली के लिए जारी रह सकती है
::<math>\begin{cases}
::<math>\begin{cases}
\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) z_1 &\qquad \text{ ( by Lyapunov function } V_x, \text{ subsystem stabilized by } u_x(\textbf{x}) \text{ )}\\
\dot{\mathbf{x}} = f_x(\mathbf{x}) + g_x(\mathbf{x}) z_1 &\qquad \text{ ( by Lyapunov function } V_x, \text{ subsystem stabilized by } u_x(\textbf{x}) \text{ )}\\
Line 359: Line 359:
::<math>V_i(\mathbf{x}_i) = V_{i-1}(\mathbf{x}_{i-1}) + \frac{1}{2}( z_i - u_{i-1}(\mathbf{x}_{i-1}) )^2</math>
::<math>V_i(\mathbf{x}_i) = V_{i-1}(\mathbf{x}_{i-1}) + \frac{1}{2}( z_i - u_{i-1}(\mathbf{x}_{i-1}) )^2</math>
:इस निर्माण से उच्च नियंत्रण के लिए <math>u(\mathbf{x},z_1,z_2,\ldots,z_k) = u_k(\mathbf{x}_k)</math> (अर्थात, अंतिम पुनरावृत्ति <math>i=k</math> पर अंतिम नियंत्रण पाया जाता है)।
:इस निर्माण से उच्च नियंत्रण के लिए <math>u(\mathbf{x},z_1,z_2,\ldots,z_k) = u_k(\mathbf{x}_k)</math> (अर्थात, अंतिम पुनरावृत्ति <math>i=k</math> पर अंतिम नियंत्रण पाया जाता है)।
इसलिए, इस विशेष मल्टी-इंटीग्रेटर स्ट्रिक्ट-फीडबैक फॉर्म में किसी भी सिस्टम को सीधी प्रक्रिया (उदाहरण के लिए, [[अनुकूली नियंत्रण]] एल्गोरिदम के हिस्से के रूप में) का उपयोग करके फीडबैक स्थिर किया जा सकता है, जिसे स्वचालित भी किया जा सकता है।
इसलिए, इस विशेष मल्टी-इंटीग्रेटर स्ट्रिक्ट-फीडबैक फॉर्म में किसी भी प्रणाली को सीधी प्रक्रिया (उदाहरण के लिए, [[अनुकूली नियंत्रण]] एल्गोरिदम के हिस्से के रूप में) का उपयोग करके फीडबैक स्थिर किया जा सकता है, जिसे स्वचालित भी किया जा सकता है।


==जेनेरिक बैकस्टेपिंग==
==जेनेरिक बैकस्टेपिंग==


विशेष प्रकार की कठोर प्रतिक्रिया के लिए उचित फॉर्म में सिस्टम में कई-इंटीग्रेटर सिस्टम संरचना के समान पुनरावर्ती संरचना होती है। इसी प्रकार उन्हें सबसे छोटे कैस्केड सिस्टम को स्थिर करके और फिर अगले कैस्केड सिस्टम पर वापस जाकर प्रक्रिया को दोहराकर स्थिर किया जाता है। इसलिए एकल-चरणीय प्रक्रिया विकसित करना महत्वपूर्ण है; उस प्रक्रिया को कई-चरणीय मामले को कवर करने के लिए पुनरावर्ती रूप से लागू किया जा सकता है। सौभाग्य से इस प्रकार की कठोर प्रतिक्रिया के लिए फॉर्म में किए गए कार्यों पर आवश्यकताओं के कारण, प्रत्येक एकल-चरण प्रणाली को एकल-एकीकृत प्रणाली में फीडबैक द्वारा प्रस्तुत किया जा सकता है, और उस एकल-एकीकृत प्रणाली को ऊपर चर्चा की गई विधियों का उपयोग करके स्थिर किया जा सकता है।
विशेष प्रकार की कठोर प्रतिक्रिया के लिए उचित फॉर्म में प्रणाली में कई-इंटीग्रेटर प्रणाली संरचना के समान पुनरावर्ती संरचना होती है। इसी प्रकार उन्हें सबसे छोटे कैस्केड प्रणाली को स्थिर करके और फिर अगले कैस्केड प्रणाली पर वापस जाकर प्रक्रिया को दोहराकर स्थिर किया जाता है। इसलिए एकल-चरणीय प्रक्रिया विकसित करना महत्वपूर्ण है, इस प्रक्रिया को कई विभिन्न स्थितियों को कवर करने के लिए पुनरावर्ती रूप से लागू किया जा सकता है। इसके कारण सौभाग्य से इस प्रकार की कठोर प्रतिक्रिया के लिए फॉर्म में किए गए कार्यों पर आवश्यकताओं के कारण, प्रत्येक एकल-चरण प्रणाली को एकल-एकीकृत प्रणाली में फीडबैक द्वारा प्रस्तुत किया जा सकता है, और उस एकल-एकीकृत प्रणाली को ऊपर चर्चा की गई विधियों का उपयोग करके स्थिर किया जा सकता है।


===एकल-चरणीय प्रक्रिया===
===एकल-चरणीय प्रक्रिया===
Line 395: Line 395:
\dot{z}_1 = u_{a1}
\dot{z}_1 = u_{a1}
\end{cases}</math>
\end{cases}</math>
यह नई <math>u_{a1}</math>-को-{{math|'''x'''}} सिस्टम समीकरण में सिंगल-इंटीग्रेटर कैस्केड सिस्टम ({{EquationNote|1}}) से मेल खाता है। यह मानते हुए कि फीडबैक-स्थिरीकरण नियंत्रण नियम है, और इसके आधार पर <math>u_x(\mathbf{x})</math> और ल्यपुनोव फलन <math>V_x(\mathbf{x})</math> ऊपरी उपप्रणाली के लिए जाना जाता है, समीकरण से फीडबैक-स्थिरीकरण नियंत्रण नियम ({{EquationNote|3}}) है
यह नई <math>u_{a1}</math>-को-{{math|'''x'''}} प्रणाली समीकरण में सिंगल-इंटीग्रेटर कैस्केड प्रणाली ({{EquationNote|1}}) से मेल खाता है। यह मानते हुए कि फीडबैक-स्थिरीकरण नियंत्रण नियम है, और इसके आधार पर <math>u_x(\mathbf{x})</math> और ल्यपुनोव फलन <math>V_x(\mathbf{x})</math> ऊपरी उपप्रणाली के लिए जाना जाता है, समीकरण से फीडबैक-स्थिरीकरण नियंत्रण नियम ({{EquationNote|3}}) है
:<math>u_{a1}(\mathbf{x},z_1)=-\frac{\partial V_x}{\partial \mathbf{x}}g_x(\mathbf{x})-k_1(z_1-u_x(\mathbf{x})) + \frac{\partial u_x}{\partial \mathbf{x}}(f_x(\mathbf{x})+g_x(\mathbf{x})z_1)</math>
:<math>u_{a1}(\mathbf{x},z_1)=-\frac{\partial V_x}{\partial \mathbf{x}}g_x(\mathbf{x})-k_1(z_1-u_x(\mathbf{x})) + \frac{\partial u_x}{\partial \mathbf{x}}(f_x(\mathbf{x})+g_x(\mathbf{x})z_1)</math>
लाभ के साथ <math>k_1 > 0</math>. तो अंतिम फीडबैक-स्थिरीकरण नियंत्रण नियम है
लाभ के साथ <math>k_1 > 0</math>. तो अंतिम फीडबैक-स्थिरीकरण नियंत्रण नियम है
Line 413: Line 413:
कई-इंटीग्रेटर बैकस्टेपिंग के समान, संपूर्ण कठोर प्रतिक्रिया प्रणाली को स्थिर करने के लिए एकल-चरण प्रक्रिया को पुनरावृत्त रूप से पूरा किया जा सकता है। प्रत्येक चरण में,
कई-इंटीग्रेटर बैकस्टेपिंग के समान, संपूर्ण कठोर प्रतिक्रिया प्रणाली को स्थिर करने के लिए एकल-चरण प्रक्रिया को पुनरावृत्त रूप से पूरा किया जा सकता है। प्रत्येक चरण में,
# सबसे छोटी अस्थिर एकल-चरण कठोर प्रतिक्रिया प्रणाली पृथक है।
# सबसे छोटी अस्थिर एकल-चरण कठोर प्रतिक्रिया प्रणाली पृथक है।
# फीडबैक का उपयोग सिस्टम को सिंगल-इंटीग्रेटर सिस्टम में परिवर्तित करने के लिए किया जाता है।
# फीडबैक का उपयोग प्रणाली को सिंगल-इंटीग्रेटर प्रणाली में परिवर्तित करने के लिए किया जाता है।
# परिणामी एकल-एकीकरणकर्ता प्रणाली स्थिर हो गई है।
# परिणामी एकल-एकीकरणकर्ता प्रणाली स्थिर हो गई है।
# स्थिर प्रणाली का उपयोग अगले चरण में ऊपरी प्रणाली के रूप में किया जाता है।
# स्थिर प्रणाली का उपयोग अगले चरण में ऊपरी प्रणाली के रूप में किया जाता है।
Line 482: Line 482:
इस निर्माण से, परम नियंत्रण <math>u(\mathbf{x},z_1,z_2,\ldots,z_k) = u_k(\mathbf{x}_k)</math> (अर्थात, अंतिम पुनरावृत्ति <math>i=k</math> पर अंतिम नियंत्रण पाया जाता है)।
इस निर्माण से, परम नियंत्रण <math>u(\mathbf{x},z_1,z_2,\ldots,z_k) = u_k(\mathbf{x}_k)</math> (अर्थात, अंतिम पुनरावृत्ति <math>i=k</math> पर अंतिम नियंत्रण पाया जाता है)।


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


==यह भी देखें==
==यह भी देखें==
Line 498: Line 498:
[[Category: Machine Translated Page]]
[[Category: Machine Translated Page]]
[[Category:Created On 15/08/2023]]
[[Category:Created On 15/08/2023]]
[[Category:Vigyan Ready]]

Latest revision as of 07:42, 13 October 2023

नियंत्रण सिद्धांत में, बैकस्टेपिंग ऐसी तकनीक है, जिसे लगभग 1990 में पेटार वी. कोकोटोविक और अन्य सहयोगियों द्वारा विकसित किया गया है।[1][2] किसी अरेखीय प्रणाली तथा गतिशील प्रणाली के विशेष वर्ग के लिए ल्यपुनोव स्थिरता नियंत्रण को डिजाइन करने के लिए बनाया गया हैं। ये प्रणालियाँ उन उपप्रणालियों से निर्मित होती हैं, जो अपरिवर्तनीयता के कारण उपप्रणाली से निकलती हैं, जिन्हें किसी अन्य विधि का उपयोग करके स्थिर किया जा सकता है। इस प्रत्यावर्तन संरचना के कारण डिज़ाइनर इस प्रकार की ज्ञात स्थिर प्रणालियों पर संरचना प्रक्रिया को प्रारंभ कर सकते हैं, और इसके लिए नए नियंत्रकों को वापस ले सकते है, जो इस प्रकार प्रत्येक बाहरी उपप्रणाली को उत्तरोत्तर स्थिर करते हैं। इस प्रकार अंतिम बाह्य नियंत्रण पर पहुँचने पर प्रक्रिया समाप्त हो जाती है। इसलिए इस प्रक्रिया को बैकस्टेपिंग के रूप में जाना जाता है।[3]

बैकस्टेपिंग दृष्टिकोण

बैकस्टेपिंग दृष्टिकोण मुख्य रूप से कठोर प्रतिक्रिया रूप में इस प्रणाली की उत्पत्ति (गणित) की ल्यपुनोव स्थिरता के लिए रिकर्सन विधि प्रदान करता है। इस प्रकार प्रपत्र की गतिशील प्रणाली पर विचार करें[3]

जहाँ

  • साथ मान प्राप्त होता हैं,
  • अदिश (गणित) हैं,
  • u प्रणाली के लिए अदिश (गणित) इनपुट है,
  • मूल में विलुप्त (अर्थात, ),
  • के लिए इसका मान इस क्षेत्र पर शून्येत्तर हैं, (अर्थात्, के लिए ) के समान हैं।

यह भी मान लें कि उपप्रणाली

मूल (गणित) (अर्थात, ) के लिए ल्यपुनोव स्थिरता के समान है, इनमें से कुछ के लिए ज्ञात मान के आधार पर नियंत्रण द्वारा मान प्राप्त होता हैं, यह मान इस प्रकार है कि के समान हैं, यह भी माना जाता है, कि ल्यपुनोव फलन के लिए स्थिर उपप्रणाली को जाना जाता है। इस प्रकार प्राप्त होने वाला मान x के समान हैं जो इसकी उपप्रणाली को किसी अन्य विधि द्वारा स्थिर किया जाता है, और बैकस्टेपिंग इसकी स्थिरता को बढ़ाता है, जो इसके चारों ओर विवृत रहता हैं।

इस कठोर प्रतिक्रिया के लिए इन प्रणालियों में स्थिरता के चारों ओर x उपप्रणाली वाले फॉर्म होते है,

  • बैकस्टेपिंग-डिज़ाइन किया गया नियंत्रण इनपुट u कि स्थिति पर सबसे तात्कालिक स्थिरीकरण का प्रभाव पड़ता है।
  • यहाँ पर स्थिति पर स्थिर नियंत्रण के समान कार्य करता है, इससे पहले यह मान के समान हैं।
  • यह प्रक्रिया निरंतर रहती है, जिससे कि इसकी प्रत्येक स्थिति काल्पनिक नियंत्रण द्वारा स्थिर किया जाता है।

बैकस्टेपिंग दृष्टिकोण यह निर्धारित करता है कि इसे कैसे स्थिर किया जाए x उपप्रणाली का उपयोग करना होता हैं, और फिर यह निर्धारित करने के लिए आगे बढ़ता है कि अगला स्थिति कैसे बनायी जा सकती हैं, इसके आधार पर गाड़ी चलाना को स्थिर करने के लिए आवश्यक नियंत्रण के लिए x का मान आवश्यक हैं, इसलिए इस प्रकार की प्रक्रिया पीछे की ओर अग्रसर रहती है, इसके आधार पर x अंतिम नियंत्रण तक कठोर प्रतिक्रिया प्रपत्र प्रणाली से बाहर u बनाया गया है।

पुनरावर्ती नियंत्रण डिज़ाइन अवलोकन

  1. यह दिया गया है कि छोटा अर्थात, निचले क्रम की उपप्रणाली इस प्रकार हैं।
    इस प्रकार पहले से ही कुछ नियंत्रण द्वारा मूल बिंदु पर स्थिर कर दिया गया है, जहाँ अर्थात को उपयोग करते हैं, इस प्रकार इस प्रणाली को स्थिर करने के लिए किसी अन्य विधि का उपयोग करना होगा। यह भी माना जाता है कि ल्यपुनोव फलन के लिए स्थिर उपप्रणाली को जाना जाता है। इस प्रकार बैकस्टेपिंग इस उपप्रणाली की नियंत्रित स्थिरता को बड़े प्रणाली तक विस्तारित करने का तरीका प्रदान करता है।
  2. नियंत्रण इस प्रकार डिज़ाइन किया गया है कि यह प्रणाली कुछ इस प्रकार दिखती हैं।
    इस समीकरण के आधार पर यह मान स्थिर किया जाता है, जिससे कि नियंत्रण के लिए वांछित मान का पालन करता है। नियंत्रण डिज़ाइन संवर्धित ल्यपुनोव फलन उम्मीदवार पर आधारित है,
    यह नियंत्रण बाध्य करने के शून्य से दूरी के लिए चुना जाता है,
  3. नियंत्रण इस प्रकार डिज़ाइन किया गया है कि प्रणाली कुछ इस प्रकार प्राप्त होती हैं-
    इसके आधार पर यह स्थिर किया जा सकता है, जिससे कि वांछित नियंत्रण का पालन करता है। इसके आधार पर नियंत्रण डिज़ाइन संवर्धित ल्यपुनोव फलन पर आधारित है
    इस नियंत्रण बाध्य करने के लिए शून्य से मान को चुना जा सकता है,
  4. यह प्रक्रिया वास्तविक होने तक उपयोग किया जा सकता है, यहाँ पर u का मान ज्ञात है, और
    • वास्तविक नियंत्रण u स्थिर करता है, काल्पनिक नियंत्रण के लिए प्राप्त होता हैं।
    • काल्पनिक नियंत्रण स्थिर काल्पनिक नियंत्रण के लिए प्राप्त होता हैं।
    • काल्पनिक नियंत्रण स्थिर काल्पनिक नियंत्रण के लिए प्राप्त होता हैं।
    • ...
    • काल्पनिक नियंत्रण स्थिर काल्पनिक नियंत्रण के लिए उपयोग किया जाता हैं,
    • काल्पनिक नियंत्रण स्थिर काल्पनिक नियंत्रण के लिए उपयोग किया जाता हैं,
    • काल्पनिक नियंत्रण स्थिर x मूल की ओर उपयोग किया जाता हैं,

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

  • के लिए मूल रूप से लुप्त हो जाता हैं,
  • के लिए शून्येतर हैं,
  • दिया गया नियंत्रण है,

तब परिणामी प्रणाली के मूल में संतुलन होता है (अर्थात, जहां , , , ..., , और ) वह ल्यपुनोव फलन विश्व स्तर पर स्पर्शोन्मुख रूप से स्थिर संतुलन है।

इंटीग्रेटर बैकस्टेपिंग

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

यहाँ पर ज्ञात होने वाले फीडबैक स्थिरीकरण नियंत्रण नियम वाले प्रणाली और इसलिए स्थिरीकरण दृष्टिकोण को इंटीग्रेटर बैकस्टेपिंग के रूप में जाना जाता है। इस प्रकार छोटे संशोधनों के साथ, सभी कठोर प्रतिक्रियायें फॉर्म प्रणाली को संभालने के लिए इंटीग्रेटर बैकस्टेपिंग दृष्टिकोण को बढ़ाया जा सकता है।

एकल-एकीकरणकर्ता संतुलन

गतिशील प्रणाली पर विचार करें,

 

 

 

 

(1)

जहाँ और अदिश राशि है, यह प्रणाली करने वाला का कैस्केड कनेक्शन है, इस प्रकार x उपप्रणाली (अर्थात, इनपुट u इंटीग्रेटर और अभिन्न में प्रवेश करता है, जहाँ पर x उपप्रणाली के अनुसार प्रविष्ट होता है।)

हम मानते हैं कि , और यदि ऐसा है , और के समान होने पर हमें यह समीकरण प्राप्त होता हैं।

तो मूल (गणित) प्रणाली का संतुलन (अर्थात, स्थिर बिंदु) है। यदि प्रणाली कभी मूल स्थिति तक पहुंचता है, तो वह उसके पश्चात सदैव के लिए वहीं रहेगा।

सिंगल-इंटीग्रेटर बैकस्टेपिंग

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

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

 

 

 

 

(2)

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

 

 

 

 

(3)

स्थिति x और और कार्य और प्रणाली से फलन हमारे ज्ञात-स्थिर से आता है, उपप्रणाली के लाभ के लिए पैरामीटर का अभिसरण करके इसकी उचित दर या हमारे प्रणाली को प्रभावित करता है। इस नियंत्रण नियम के अनुसार हमारी प्रणाली मूल में ल्यपुनोव स्थिरता पायी जाती है।
याद रखें कि समीकरण में (3) इंटीग्रेटर के इनपुट को चलाता है जो उपप्रणाली से जुड़ा होता है जो नियंत्रण नियम द्वारा फीडबैक-स्थिर होता है, यहाँ पर आश्चर्य की बात नहीं हैं, क्यूंकि नियंत्रण वह शब्द जिसे स्थिरीकरण नियंत्रण नियम का पालन करने के लिए एकीकृत किया जाएगा, तथा के साथ ही कुछ ऑफसेट भी मिल जाते हैं। इस प्रकार इसकी अन्य शर्तें उस ऑफसेट और किसी अन्य त्रुटियों के प्रभाव को हटाने के लिए डंपिंग प्रदान करती हैं जिसे इंटीग्रेटर द्वारा बढ़ाया जाएगा।

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

प्रेरक उदाहरण: दो-इंटीग्रेटर बैकस्टेपिंग

सामान्य मल्टीपल-इंटीग्रेटर केस के लिए पुनरावर्ती प्रक्रिया पर चर्चा करने से पहले, दो-इंटीग्रेटर मामले में उपस्थित रिकर्सन का अध्ययन करना शिक्षाप्रद है। अर्थात् गतिशील प्रणाली पर विचार करें

 

 

 

 

(4)

जहाँ और और अदिश हैं, यह प्रणाली समीकरण में सिंगल-इंटीग्रेटर प्रणाली का कैस्केड कनेक्शन है, जहाँ पर समीकरण (1) दूसरे इंटीग्रेटर के साथ (अर्थात, इनपुट इंटीग्रेटर के माध्यम से प्रवेश करता है, और उस इंटीग्रेटर का आउटपुट समीकरण में प्रणाली में प्रवेश करता है, इस प्रकार समीकरण (1) के द्वारा इनपुट प्राप्त होता हैं।

जो इस प्रकार हैं-

  • ,
  • ,

फिर समीकरण में दो-इंटीग्रेटर प्रणाली (4) एकल-एकीकरणकर्ता प्रणाली बन जाती है

 

 

 

 

(5)

एकल-एकीकरणकर्ता प्रक्रिया द्वारा, नियंत्रण नियम ऊपरी भाग को स्थिर करता है, जहाँ पर -को-y ल्यपुनोव फलन का उपयोग कर उपप्रणाली , और इसलिए समीकरण (5) नया सिंगल-इंटीग्रेटर प्रणाली है जो संरचनात्मक रूप से समीकरण में सिंगल-इंटीग्रेटर प्रणाली के बराबर है (1). तो स्थिर नियंत्रण उसी एकल-इंटीग्रेटर प्रक्रिया का उपयोग करके पाया जा सकता है जिसका उपयोग का मान खोजने के लिए किया गया था।

अनेक-इंटीग्रेटर बैकस्टेपिंग

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

  • सबसे पहले, गतिशील प्रणाली पर विचार करें
उसमें अदिश इनपुट है और आउटपुट स्थितियाँ
  • जिससे कि शून्य-इनपुट (अर्थात, ) प्रणाली मूल बिंदु पर स्थिर बिंदु है, इस स्थिति में, उत्पत्ति को प्रणाली का संतुलन कहा जाता है।
  • फीडबैक नियंत्रण नियम प्रणाली को मूल बिंदु पर संतुलन पर स्थिर करता है।
  • इस प्रणाली के अनुरूप ल्यपुनोव फलन का वर्णन किया गया है।
अर्थात्, यदि आउटपुट बताता है x को वापस इनपुट में का मान फीड किया जाता है, इस प्रकार नियंत्रण नियम द्वारा , फिर आउटपुट स्थिति (और ल्यपुनोव फलन) एकल त्रुटि के बाद मूल पर लौट आती है, उदाहरण के लिए, गैर-शून्य प्रारंभिक स्थिति या तेज त्रुटि के बाद यह मान प्राप्त होता हैं। यह उपप्रणाली फीडबैक नियंत्रण नियम द्वारा स्थिर रहता है।
  • इसके बाद, इंटीग्रेटर को इनपुट से कनेक्ट करें, जिससे कि संवर्धित प्रणाली में इनपुट होता हैं, जहाँ पर इंटीग्रेटर के लिए और आउटपुट स्थिति के लिए x को परिणामी संवर्धित गतिशील प्रणाली के रूप में दर्शाते है-
यह कैस्केड प्रणाली समीकरण के फॉर्म से मेल खाता है (1), और इसलिए सिंगल-इंटीग्रेटर बैकस्टेपिंग प्रक्रिया समीकरण में स्थिर नियंत्रण नियम (3) की ओर ले जाती है। अर्थात यदि हम स्थितिों को फीड बैक करते हैं और x निवेश करने के लिए नियंत्रण नियम के अनुसार हमें यह समीकरण प्राप्त होता हैं-
इस कारण लाभ के साथ , फिर स्थिति और x पर वापस आ जाएगा और ही इस उपप्रणाली के फीडबैक नियंत्रण नियम द्वारा स्थिर होती है, और समीकरण से संबंधित ल्यपुनोव फलन (2) के रूप में दर्शाते हैं-
अर्थात, फीडबैक नियंत्रण नियम के अनुसार , ल्यपुनोव फलन जैसे-जैसे अवस्थाएँ मूल में लौटती हैं, जो बाद में शून्य हो जाती है।
  • इनपुट के लिए नया इंटीग्रेटर कनेक्ट करते हैं, जिससे कि संवर्धित प्रणाली में इनपुट हो और आउटपुट स्थितियाँ x परिणामी संवर्धित गतिशील प्रणाली है
जो सिंगल-इंटीग्रेटर प्रणाली के समान होता है।
, , और के आधार पर इन परिभाषाओं का उपयोग करना, जिसके लिए इस प्रकार की प्रणाली को इस प्रकार भी व्यक्त किया जा सकता है।
यह प्रणाली समीकरण की एकल-एकीकृत संरचना 1) से मेल खाती है। और इसलिए सिंगल-इंटीग्रेटर बैकस्टेपिंग प्रक्रिया को फिर से लागू किया जा सकता है। अर्थात, यदि हम स्थितिों को फीड बैक करते हैं , , और x निवेश करने के लिए नियंत्रण नियम के अनुसार हमें यह समीकरण प्राप्त होता हैं।
लाभ के साथ , फिर स्थिति , , और x पर वापस आ जाएगा , , और ही इस उपप्रणाली के फीडबैक नियंत्रण नियम द्वारा स्थिर रहती है, और संबंधित ल्यपुनोव फलन है
अर्थात, फीडबैक नियंत्रण नियम के तहत , ल्यपुनोव फलन जैसे-जैसे अवस्थाएँ मूल में लौटती हैं, शून्य हो जाती है।
  • एक इंटीग्रेटर को इनपुट से कनेक्ट करें जिससे कि संवर्धित प्रणाली में इनपुट हो और आउटपुट स्थितियाँ x. परिणामी संवर्धित गतिशील प्रणाली है
जिसे एकल-एकीकरणकर्ता प्रणाली के रूप में पुनः समूहीकृत किया जा सकता है।
इस परिभाषा के अनुसार , , और पिछले चरण से, इस प्रणाली का भी प्रतिनिधित्व किया जाता है।
आगे, इन परिभाषाओं का उपयोग करते हुए , , और , इस प्रणाली को इस प्रकार भी व्यक्त किया जा सकता है।
तो पुनः समूहित प्रणाली में समीकरण की एकल-एकीकृत संरचना है (1), और इसलिए सिंगल-इंटीग्रेटर बैकस्टेपिंग प्रक्रिया को फिर से लागू किया जा सकता है। अर्थात, यदि हम से जुड़ी इस स्थिति फीडबैक करते हैं , तो इसके अनुसार , , और x निवेश करने के लिए नियंत्रण नियम के अनुसार इस समीकरण द्वारा दर्शाया जाता हैं।
इस प्रकार लाभ के साथ , फिर स्थिति , , , और x पर वापस आ जाएगा , , , और ही इस उपप्रणाली के फीडबैक नियंत्रण नियम द्वारा स्थिर है, और संबंधित ल्यपुनोव फलन है।
अर्थात, फीडबैक नियंत्रण नियम के तहत , ल्यपुनोव फलन जैसे-जैसे अवस्थाएँ मूल में लौटती हैं, शून्य हो जाती है।
  • यह प्रक्रिया प्रणाली में जोड़े गए प्रत्येक इंटीग्रेटर और इसलिए फॉर्म के किसी भी प्रणाली के लिए जारी रह सकती है
पुनरावर्ती संरचना है
और एकल-इंटीग्रेटर के लिए फीडबैक-स्थिरीकरण नियंत्रण और ल्यपुनोव फलन को ढूंढकर फीडबैक उपप्रणाली (अर्थात, इनपुट के साथ और आउटपुट x) को स्थिर किया जा सकता है और उस आंतरिक उपप्रणाली से अंतिम फीडबैक-स्थिरीकरण नियंत्रण तक पुनरावृत्त होता रहता है, यहाँ पर u का मान ज्ञात रहता है। इसकी पुनरावृत्ति पर यह मान i के समतुल्य रहती है।
संबंधित फीडबैक-स्थिरीकरण नियंत्रण नियम है
लाभ के साथ . संगत ल्यपुनोव फलन है।
इस निर्माण से उच्च नियंत्रण के लिए (अर्थात, अंतिम पुनरावृत्ति पर अंतिम नियंत्रण पाया जाता है)।

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

जेनेरिक बैकस्टेपिंग

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

एकल-चरणीय प्रक्रिया

सरल कठोर प्रतिक्रिया प्रपत्र या कठोर प्रतिक्रिया गतिशील प्रणाली पर विचार करें

 

 

 

 

(6)

जहाँ

  • ,
  • और अदिश (गणित) हैं,
  • सभी के लिए x और , .

फीडबैक-स्थिरीकरण नियंत्रण को डिज़ाइन करने के अतिरिक्त सीधे, नया नियंत्रण पेश करें (बाद में डिज़ाइन किया जाएगा) और नियंत्रण नियम का उपयोग करें

जो संभव है क्योंकि . तो समीकरण में प्रणाली (6) है

जो इसे सरल बनाता है

यह नई -को-x प्रणाली समीकरण में सिंगल-इंटीग्रेटर कैस्केड प्रणाली (1) से मेल खाता है। यह मानते हुए कि फीडबैक-स्थिरीकरण नियंत्रण नियम है, और इसके आधार पर और ल्यपुनोव फलन ऊपरी उपप्रणाली के लिए जाना जाता है, समीकरण से फीडबैक-स्थिरीकरण नियंत्रण नियम (3) है

लाभ के साथ . तो अंतिम फीडबैक-स्थिरीकरण नियंत्रण नियम है

 

 

 

 

(7)

लाभ के साथ . समीकरण से संबंधित ल्यपुनोव फलन (2) है

 

 

 

 

(8)

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

बहु-चरणीय प्रक्रिया

कई-इंटीग्रेटर बैकस्टेपिंग के समान, संपूर्ण कठोर प्रतिक्रिया प्रणाली को स्थिर करने के लिए एकल-चरण प्रक्रिया को पुनरावृत्त रूप से पूरा किया जा सकता है। प्रत्येक चरण में,

  1. सबसे छोटी अस्थिर एकल-चरण कठोर प्रतिक्रिया प्रणाली पृथक है।
  2. फीडबैक का उपयोग प्रणाली को सिंगल-इंटीग्रेटर प्रणाली में परिवर्तित करने के लिए किया जाता है।
  3. परिणामी एकल-एकीकरणकर्ता प्रणाली स्थिर हो गई है।
  4. स्थिर प्रणाली का उपयोग अगले चरण में ऊपरी प्रणाली के रूप में किया जाता है।

अर्थात कोई कठोर प्रतिक्रिया प्रणाली

यह एक पुनरावर्ती संरचना है।

और एकल-इंटीग्रेटर के लिए फीडबैक-स्थिरीकरण नियंत्रण और ल्यपुनोव फलन को ढूंढकर फीडबैक को स्थिर किया जा सकता है, इसके आधार पर उपप्रणाली (अर्थात, इनपुट के साथ और आउटपुट x) और उस आंतरिक उपप्रणाली से अंतिम फीडबैक-स्थिरीकरण नियंत्रण तक पुनरावृत्त होता रहता है u ज्ञात है। जहाँ पर पुनरावृत्ति i पर समतुल्य प्रणाली का उपयोग होता हैं।

समीकरण द्वारा (7), संबंधित फीडबैक-स्थिरीकरण नियंत्रण नियम है

यहां पर लाभ के साथ समीकरण (8) द्वारा संबंधित ल्यपुनोव फलन प्राप्त होता हैं।

इस निर्माण से, परम नियंत्रण (अर्थात, अंतिम पुनरावृत्ति पर अंतिम नियंत्रण पाया जाता है)।

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

यह भी देखें

संदर्भ

  1. Kokotovic, P.V. (1992). "The joy of feedback: nonlinear and adaptive". IEEE Control Systems Magazine. 12 (3): 7–17. doi:10.1109/37.165507. S2CID 27196262.
  2. Lozano, R.; Brogliato, B. (1992). "लचीले जोड़ों के साथ रोबोट मैनिपुलेटर्स का अनुकूली नियंत्रण" (PDF). IEEE Transactions on Automatic Control. 37 (2): 174–181. doi:10.1109/9.121619.
  3. 3.0 3.1 Khalil, H.K. (2002). Nonlinear Systems (3rd ed.). Upper Saddle River, NJ: Prentice Hall. ISBN 978-0-13-067389-3.