🏇🏿 👨🏾‍⚖️ 🎂 DIY पीआईडी नियंत्रक 🍩 💪🏽 🙁

I. समस्या का विवरण

तापमान को दिए गए स्तर पर रखना और कार्य को बदलना आवश्यक है। एक माइक्रोकंट्रोलर है, जिससे एक तापमान मीटर जुड़ा हुआ है, और शक्ति को नियंत्रित करने के लिए एक त्रियेक है। हम टीएयू पर अपने सिर को गर्म नहीं करेंगे, न ही अंतर योजनाओं द्वारा, बस पीआईडी नियंत्रक को "माथे" में ले जाएं और बनाएं।

द्वितीय। सैद्धांतिक परिचय

एक पीआईडी नियंत्रक कैसे काम करता है? हम वर्तमान तापमान और वांछित के बीच अंतर लेते हैं, एक कस्टम गुणांक से गुणा करते हैं, हमें वह शक्ति मिलती है जिसे फिलहाल जारी करने की आवश्यकता होती है। यह एक आनुपातिक घटक है, यह तब काम करता है जब एक मिसमैच होता है - अर्थात, यह सेट पॉइंट में बदलाव और ऑब्जेक्ट के व्यवहार दोनों को तुरंत प्रतिक्रिया देता है। गर्म होने लगी? शक्ति घटने लगती है। गरम? यह बंद हो गया, या यहां तक कि एक ठंडा संकेत भी दिया। सब कुछ ठीक है, केवल वास्तविक जीवन में प्रभाव का प्रभाव देरी से प्रकट होता है, और वस्तु न केवल हमारे द्वारा, बल्कि पर्यावरण से भी प्रभावित होती है: गर्म रिएक्टर न केवल अंदर गर्म होता है, बल्कि ठंडा भी होता है, जिससे कमरे को गर्मी मिलती है, और इसलिए जैसे ही हम इसे बंद कर देते हैं। शक्ति, यह तुरंत ठंडा होने लगता है। इसलिए, शुद्ध आनुपातिक नियामक समर्थन बिंदु के आसपास दोलन करता है, और जितना अधिक यह उतार-चढ़ाव होता है, पर्यावरण / रिएक्टर सामग्री उतनी ही अधिक होती है।

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

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

इसलिए, भौतिक अर्थ के साथ, हम कार्यान्वयन के मुख्य मुद्दों की ओर मुड़ते हैं।

तृतीय। नियामक का उपयोग कौन करना चाहिए?

- तकनीशियनों के लिए।

इससे क्या होता है? यह इस प्रकार है कि तकनीशियन भौतिक घटक को समझते हैं, और हार्डवेयर पीआईडी नियंत्रक स्थापित करने का अनुभव रखते हैं। इसलिए, सॉफ्टवेयर कार्यान्वयन को तकनीशियनों द्वारा ट्यूनिंग की सुविधा से आगे बढ़ना चाहिए - भौतिक मॉडल को दोहराते हुए। और यह अत्यंत महत्वपूर्ण है! बहुत बार, कोड को सरल बनाने के लिए, गुणांक को बदल दिया जाता है, उदाहरण के लिए, इसके विपरीत - विभाजन से छुटकारा पाने के लिए। नतीजतन, ट्यूनिंग नरक और एक दुःस्वप्न में बदल जाती है, और इस विशेष नियंत्रक को ट्यूनिंग के अनुभव की आवश्यकता होती है, बजाय प्रक्रिया को समझने के। इससे हमें यह पता चलता है कि हमारे गुणांक - एकीकरण निरंतर और विभेदक स्थिरांक - समय का एक आयाम होना चाहिए, जो कि सेकंड में सेट हो, और "1 / s" में बिल्कुल भी नहीं, जैसा कि वे करना चाहते हैं।

चतुर्थ। कार्य करने की गुंजाइश।

हम एक सार्वभौमिक नियामक बनाने की कोशिश कर रहे हैं, जिसका अर्थ है कि यह छोटे तेज वस्तुओं और शक्तिशाली विशाल भट्टियों पर दोनों काम करना चाहिए। इसलिए, यह माना जाना चाहिए कि नियंत्रित तापमान आमतौर पर मीटर द्वारा सीमित है। सबसे अधिक इस्तेमाल XA (K) और XK (L) हैं। प्रयोज्यता का उनका क्षेत्र कहीं 1200 ° C तक है। कूलिंग के लिए अधिक परिष्कृत उपकरणों (क्रायोस्टेट्स) की आवश्यकता होती है, अतिरिक्त शीतलन नियंत्रण (प्रशंसकों और खुले कैबिनेट के दरवाजे) की भी शायद ही कभी आवश्यकता होती है - जिसका अर्थ है कि हमें विचार से बाहर रखा गया है। हम पाते हैं कि नियंत्रित तापमान ~ 15 ° C से ~ 1200 ° C तक है, केवल बिजली की आपूर्ति नियंत्रित है।

माप सटीकता द्वारा नियंत्रण सटीकता पहले निर्धारित की जाती है: अंशांकन टेबल 0.1 डिग्री के बाद दिए जाते हैं; तालिकाओं के अंदर रैखिकता सिद्धांत रूप में सभ्य है, इसलिए सटीकता मुख्य रूप से एम्पलीफायर और वर्तमान मीटर द्वारा सीमित है। मेरे मामले में, मैं 0.1 डिग्री बनाए रखने की सटीकता प्राप्त करना चाहता था, इसलिए मीटर 1/32 डिग्री पर सेट है: यह ~ 3 क्वांटा 0.1 डिग्री देता है, इस प्रकार, सामान्य "शोर" विनियमन + -1 क्वांटम होने से, हम उसी 0.1 के भीतर बने रहते हैं डिग्री कम है। 1/32 का उपयोग करने से आप एक निश्चित बिंदु के साथ काम कर सकते हैं - 5 बिट्स = आंशिक भाग, बाकी पूर्णांक है। 16 बिट्स में यह 0 से 2047 ° तक का प्रतिनिधित्व करता है। नकारात्मक संख्याओं के साथ काम करने के बजाय, हम केल्विन में सेल्सियस के बजाय काम करेंगे, इस प्रकार - यह 0 से 2047 ° K तक दिखाई देता है, जो -273 से 1775 डिग्री सेल्सियस के बराबर है; की वृद्धि में 0.03125 °।

वी। अनुकूलन की सीमा।

एक शक्तिशाली पावर प्लांट के साथ एक माइक्रोसेक्टर को नियंत्रित करने के लिए, यह पता चल सकता है कि 1% बिजली 10 डिग्री पर हीटिंग के लिए पर्याप्त है, जबकि एक बड़ी निष्क्रिय भट्ठी के लिए, 100% हीटिंग पावर मुश्किल से एक डिग्री तक गर्म करने के लिए पर्याप्त है। (वास्तविक जीवन में, यह इस तरह दिखता है - कई मैन्युअल रूप से नियंत्रित हीटर हैं - वे एक अलग चाकू स्विच द्वारा स्विच किए जाते हैं और प्रारंभिक हीटिंग का उत्पादन करते हैं। भविष्य में, तापमान नियामक एक अन्य हीटर को नियंत्रित करके ऑपरेटिंग बिंदु को बनाए रखता है, जो अधिकतम शक्ति पर अधिकतम 10 ° C पैदा करता है; उस पर लगातार गरम)। इसके आधार पर, यह मानना तर्कसंगत है कि प्रति डिग्री 100% शक्ति आनुपातिकता का सीमित गुणांक है। यह अब समझ में नहीं आता है, क्योंकि हम एक 0.1 डिग्री नियंत्रणीयता प्राप्त करना चाहते हैं। न्यूनतम, सादगी के लिए, मैंने उलटा लिया - प्रति 100 डिग्री पर 1% बिजली।

समय गुणांक की सीमाओं की गणना बस हमारे नियामक ऑपरेटिंग स्थितियों के आधार पर की जाती है। चूंकि हम 0 से गुजरने के बाद स्विचिंग के विलंब समय की गणना करके ट्राइक की शक्ति के माध्यम से नियंत्रित करते हैं, नियंत्रक की सीमा आवृत्ति 50 हर्ट्ज है। यदि हमें विश्वास है कि हम उस शक्ति को नियंत्रित करते हैं जिसकी परवाह नहीं है, प्लस या माइनस नहीं है, तो हम 100 हर्ट्ज पर काम कर सकते हैं, लेकिन यह हमेशा ऐसा नहीं होता है, और इसलिए हर बार सकारात्मक और नकारात्मक अर्ध-तरंगों की समान मात्रा में खुराक लेना बेहतर होता है। जीवन को सरल बनाने के लिए, मैंने परिचालन समय को घटाकर 25 हर्ट्ज कर दिया, जिससे कोई भी गणना प्रभाव 4 अर्ध-तरंगों के लिए मान्य होगा और इस दौरान मेरे पास एक नए प्रभाव की गणना करने का अवसर होगा।

इस प्रकार, समय की कमी 1/25 सेकंड में, 0 से ~ 2000 सेकंड (2000 * 25 = 50,000, यह सिर्फ 16 बिट्स) में सेट की जाती है।

ठीक है, हमारे पास 0 से 100% तक न्यूनतम और अधिकतम बिजली सीमा भी है।

छठी। बिजली प्रबंधन।

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

इसलिए, हमने पहले ही तय कर लिया है कि हम 0. से गुजरने के बाद ट्राइक को खोलने में देरी को नियंत्रित करते हैं। इस प्रकार, 0 की देरी का अर्थ है 100% शक्ति, अनंत विलंब = 0% की शक्ति।

प्रश्न: शक्ति को हम किस सटीकता के साथ नियंत्रित कर सकते हैं? सामान्य तौर पर, हमारे टाइमर की उलटी गिनती की सटीकता के साथ। दूसरी ओर, किस शक्ति की आवश्यकता है? हम गणना करते हैं कि 0.04sec पर लागू करने के लिए आपको कितनी% शक्ति चाहिए। सिद्धांत रूप में, अनुभव से, 0.1 सेकंड की आवृत्ति पर 1% की सटीकता के साथ बिजली नियंत्रण भी 1 डिग्री के तापमान को बनाए रखने के लिए पर्याप्त है। हम 0.04sec (2.5 गुना तेज) को नियंत्रित करते हैं। इसलिए, अधिकतम के 1/250 (0.4% की वृद्धि में) के बाद पावर टेबल की गणना करने का निर्णय लिया गया था। यह तालिका को बहुत बड़ी (500 बाइट्स) नहीं होने देता है, और एक ही समय में 1% से अधिक की सटीकता है। यदि आपके मामले में अधिक सटीकता की आवश्यकता है, तो पुनरावृत्ति करना इतना मुश्किल नहीं है।

अब इस तालिका की गणना करने के बारे में बात करते हैं। सबसे पहले, यह ध्यान दिया जाना चाहिए कि शून्य से गुजरने वाले सिग्नल के संचालन का एक क्षण है। मेरे मामले में - 12 वी। यही है, जब इनपुट वोल्टेज 12V से नीचे चला जाता है, तो मुझे 0 से गुजरने वाला एक संकेत प्राप्त होगा।

इसका मतलब है कि 100% शक्ति के लिए, प्रारंभ समय = 12 वी का पारगमन समय।

हम समीकरणों की प्रणाली को हल करते हैं

 ;  सहज: = 12 वी
 ;  अधिकतम: = sqr (220 * sqrt (2))
 ;  {Sqr (पाप (Pi / 2) * K) = मैक्स
 ;  {Sqr (पाप (X) * K) = अंतर्मुखी
 ;
 ;  2 * k / मैक्सकोड = 1 - cos (T * Pi)
 ;  cos (T * Pi) = 1-2 * k / MaxCode
 ;  T * Pi = arccos (1-2 * k / MaxCode)
 ;  टी = आर्कोस (1-2 * के / मैक्सकोड) / पाई

प्रोसेसर मेरे लिए 32786 की आवृत्ति पर काम करता है, पीएलएल को 384/2 पर सेट किया जाता है, आधा-लहर में 100 हर्ट्ज होता है, जहां से हमें पता चलता है कि समय के लिए टाइमर में निरंतर लोड करने के लिए कोड में टी है:

65536-(T*(32768*384/2)/100.0 + 773)

हमें देरी समय की गणना करने की आवश्यकता है, जो साइनसॉइड के शामिल हिस्से के क्षेत्र में एक समान वृद्धि देता है। यही है, हमें समय की रीडिंग के लिए शक्ति में एक समान वृद्धि देने की आवश्यकता है। कुल शक्ति जो हम देते हैं वह संपूर्ण साइन तरंग पर अभिन्न है। [जो जानता है कि हब पर सूत्र कैसे डालें? कोई रास्ता नहीं? मैं तब मेपल अंकन में लिखता हूं]।

 अधिकतम = int (sqr (sin (x)), x = 0..Pi)
 int (sqr (sin (x)), x = 0..T * Pi) = x / 2 - sin (2 * x) / x + C |  0..T * PI = (T * Pi) / 2 - sin (2 * T * Pi) / 4
 (T * Pi) / 2 - sin (2 * T * Pi) / 4 = Q * Pi / 2

इस प्रकार, हमें दिए गए सटीकता के साथ सभी क्यू के माध्यम से जाने की जरूरत है, और उनमें से प्रत्येक के लिए टी की तलाश करें।

मैंने अपने लिए इस तरह मूर्खतापूर्ण निर्णय लिया:

मोती जनक

 #!/usr/bin/perl # (T*Pi)/2 - sin(2*T*Pi)/4 = Q*Pi/2 use constant PI => 4 * atan2(1, 1); $T = 1; for( $i = 250; $i >= 0; $i-- ) { $int = $i*PI/2/250; $ev = ($T*PI)/2-sin(2*$T*PI)/4; while( abs($ev-$int) > 0.0005 ) { $T -= 0.0001; $ev = ($T*PI)/2-sin(2*$T*PI)/4; } #print $i."\t".$T."\n"; $code = 65536-($T*(32768*384/2)/100.0 + 773); printf "DB 0%02Xh, 0%02Xh ; %04Xh = $i/250 of power\n", $code%256, int($code/256), $code, $i; }

यही है, आउटपुट पर हमें टाइमर लोड कॉन्स्टेंट के अनुरूप 250 मानों के साथ एक प्लेट मिली, जब तक कि प्रज्वलन 0 से गुजरने के बारे में संकेत प्राप्त करने के बाद (अधिक सटीक रूप से, 12 वी के माध्यम से, जैसा कि मैंने ऊपर कहा था)।

सातवीं। इनपुट मापन

मैं इस प्रश्न को छोड़ देता हूं क्योंकि यह एक अलग बड़े लेख के योग्य है। मैंने अपने ब्लॉग के संग्रह में थर्मल प्रतिरोध के मुद्दे को कैसे हल किया, जो बोस की मृत्यु हो गई ।

हमें जो मुख्य बात जानने की आवश्यकता है, वह यह है कि हम उस डेटा को उस आवृत्ति से मापते हैं जिसकी हमें आवश्यकता है (इस स्थिति में - 25 हर्ट्ज), और आवश्यक सटीकता (आउटपुट 0 से 2048 डिग्री केल्विन 1/32 डिग्री में एक संख्या है)। डेटा को आगे की सभी गणनाओं के लिए सामान्यीकृत माना जाता है।

यदि यह किसी के लिए दिलचस्प होगा - टिप्पणियों में लिखें, मैं अगली बार साइन करूंगा कि यह थर्मोक्यूल्स के लिए कैसे किया जाता है।

आठवीं। प्रभाव गणना

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

PID नियंत्रक सूत्र को फिर से याद करें:

U = K * ( Err + (1/Ti)*Int + Td*dErr )

यू जारी करने की शक्ति है;
के - आनुपातिक गुणांक (नोट - कोष्ठक से बाहर रखा गया, क्यों - मैं इसे थोड़ा कम वर्णन करूंगा);
टीआई एकीकरण समय स्थिर है। कृपया ध्यान दें कि गणना में व्युत्क्रम का उपयोग किया जाता है;
टीडी - भेदभाव समय स्थिर
इर - वर्तमान बेमेल (सेट बिंदु और मापा तापमान के बीच अंतर)
drr - बेमेल का व्युत्पन्न (वर्तमान और भूतकाल की त्रुटि के बीच का अंतर)
Int संचित बेमेल अभिन्न है (सभी इरस का योग हमने देखा)

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

हम सभी आयामों का उत्पादन करेंगे। आंशिक रूप से आगे देखते हुए, मैंने पहले ही IV में वर्णित किया है, लेकिन अब हम और अधिक विस्तार से खुलासा करेंगे:

यू - शक्ति का% में एक मूल्य है। अधिक सटीक - 2/5% शक्ति पर, क्योंकि हमारी तालिका 100% से 1/250 से गुजरती है।
त्रुटि - बेमेल, डिग्री में सेट। अधिक सटीक - 1/32 डिग्री में।
इंट - इंटीग्रल, समय में डिग्री के योग का प्रतिनिधित्व करता है - जिसका अर्थ है कि इसमें आयाम डिग्री * सेकंड है। अधिक सटीक - (1/32 डिग्री) * (1/25 सेकंड)
टीआई - 1/25 सेकंड में सेट।
(1 / Ti) * इंट - गणना के बाद, एक आयाम (1/32 डिग्री) वाले योगदान देता है।
drr - व्युत्पन्न, एक डिग्री / दूसरा आयाम है, या बल्कि (1/32 डिग्री) / (1/25 सेकंड)
टीडी - 1/25 सेकंड में सेट।
Td * dErr - उत्पाद के बाद आयाम में योगदान होता है (1/32 डिग्री)
(...) - तो, कोष्ठक के अंतर्गत सभी शर्तें आयाम (1/32 डिग्री) तक कम हो जाती हैं
के - यू और (...) से मेल खाता है, जिसका अर्थ है कि इसका प्रतिशत-प्रति-डिग्री आयाम है, अधिक सटीक (2/5)% / (1/32 डिग्री)

अब आप स्पष्ट रूप से देख सकते हैं कि आनुपातिक गुणांक कोष्ठक से बाहर क्यों ले जाया जाता है - यह आपको अंतर और अंतर गुणांक को समय में स्थिर करने की अनुमति देता है, परिणामस्वरूप, ऑपरेटर सेट करते समय सरल और समझ में आने वाली संख्याओं के साथ काम करता है - आनुपातिक और अंतर गुणांक के लिए आनुपातिक और सेकंड के लिए एक प्रतिशत प्रति डिग्री।

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

एक के अतिरिक्त, हमारे पास एक Ti मान है, और गणना के लिए 1 / Ti आवश्यक है। उच्च बिट डिवीजन ऑपरेशन बहुत महंगा है। गुणन का संचालन बहुत सस्ता है, इसलिए हम डिवीलेटर द्वारा उत्कृष्ट लेख का उपयोग बहुविकल्पी का उपयोग करके Invariant Integers द्वारा किया जाएगा । हमारे लिए, आखिरकार, K / Ti / Td में बहुत कम परिवर्तन होते हैं, और इसलिए हम उन्हें बदलने के बाद उनके साथ विकृत हो सकते हैं, मुख्य बात यह है कि गणना का मुख्य चक्र जल्दी से काम करता है।

इस प्रकार, गणना के लिए टीआई के बजाय, हम सेट Ti_m , Ti_sh1 , Ti_sh2 में विघटित होते हैं ; और प्रत्येक चक्र पर हम गणना करते हैं:

 T1 = MULUH(Ti_m, Int) Q = SHR(T1+SHR(Int-T1, Ti_sh1), Ti_sh2)

अब हम थोड़ा गहराई के संतुलन की गणना करते हैं। ऐसा करने के लिए, हम चरण दर चरण पूर्ण सूत्र लिखते हैं:

Eo = E ; हम एक गलती पारित कर दिया है की जरूरत है। त्रुटियाँ - 16bit प्रत्येक
E = YX ; नए बेमेल की गणना करें। 16bit
Int = Int + (E+Eo)/2 ; त्रुटि को एकीकृत करें। इस मामले में, हम अंतर (अंतर स्कीम) की आधी राशि पर विचार करते हैं। 32 बिट = 32 बिट + 16 बिट
cI = Int * (1/Ti) ; हम अभिन्न योगदान पर विचार करते हैं - 32 बिट * 32 बिट => 32 बिट
cD = Td * (E-Eo) ; हम अंतर योगदान पर विचार करते हैं - 16 * 16 => 32 बिट
PID = E + cI + cD ; Podskobochnoe; 16 + 32 + 32 => 32 बिट
U = K*PID/256 ; बाधाओं; 32 * 16/8 बिट => 40 बिट।

सभी गणनाओं में, 7 वें चरण तक बिंदु की स्थिति 5 मी से दाईं ओर बनी हुई है। अंतिम क्षण में कानों के साथ एक दिलचस्प झगड़ा होता है। K को क्रमशः 1/256 में सेट किया जाता है, गुणा के बाद, बिंदु को बाईं ओर 5 + 8 = 13 स्थानों पर स्थानांतरित कर दिया जाता है, इसलिए हमें परिणाम से निचले 8 बिट्स को छोड़ देना चाहिए। और परिणाम का सबसे कम बाइट वह शक्ति है जो हमें 2/5% के बाद चाहिए। यह एक और कारण है कि बिजली को 1/250 चरणों में संरेखित किया जाता है - इससे आप परिणाम को एक बाइट में डाल सकते हैं और आसानी से तालिका से वांछित परिणाम प्राप्त कर सकते हैं।

इसके अलावा, हमें याद है कि हम केवल 0 से 250 तक की शक्ति में रुचि रखते हैं - इसलिए गणना का 7 वां चरण बहुत सरल है, जैसे ही हम एक ऋणात्मक संख्या प्राप्त करते हैं, हम तुरंत uMin जोड़ते हैं। जैसे ही हमें पता चलता है कि कोई भी उच्च बाइट शून्य नहीं है, हम तुरंत uMax जोड़ते हैं। और केवल तभी जब पावर रेंज में हो - हम uMin से कम या अधिक uMax की जांच करते हैं।

अगर अचानक किसी को दिलचस्पी है:

पूर्ण पाद लेख गणना

 ; PID  CalcMainEnd: ; , Go-Go. CalcPid: ; 1. Eo = E | 16bit Pid1: MOV Err0H, ErrH MOV Err0L, ErrL ; 2. E = YX | 16bit Pid2: CLR C MOV A, SettingL SUBB A, ThermoL MOV ErrL, A MOV A, SettingH SUBB A, ThermoH MOV ErrH, A JNB OV, Pid2Ov JB ACC.7, Pid2Max Pid2Min: MOV ErrL, #LOW(-500*32) MOV ErrH, #HIGH(-500*32) SJMP Pid2End Pid2Max: MOV ErrL, #LOW(500*32) MOV ErrH, #HIGH(500*32) SJMP Pid2End Pid2Ov: JNB ACC.7, Pid2OvP Pid2OvN: ;     CLR C MOV A, ErrL SUBB A, #LOW(-500*32) MOV A, ErrH SUBB A, #HIGH(-500*32) JNC Pid2End ;  > -500 =>   SJMP Pid2Min Pid2OvP: CLR C MOV A, ErrL SUBB A, #LOW(500*32) MOV A, ErrH SUBB A, #HIGH(500*32) JNC Pid2Max ;  < 500 =>   Pid2End: ; 3. Int = Int + (E+Eo)/2 | 32bit+16bit Pid3: JNB PowerReady, Pid3End ;    --     MOV A, ErrL ADD A, Err0L MOV R0, A ;  MOV A, ErrH ADDC A, Err0H MOV C, ACC.7 ;     16 ,       RRC A ;     XCH A, R0 ; A=  , R0 -    RRC A ;  JNB IntS, Pid3IntPos ; Int ,    R0:A,        Int CLR C CPL A ADD A, #1 XCH A, R0 CPL A ADDC A, #0 XCH A, R0 Pid3IntPos: ;  Int  R0:A   ,     ADD A, IntLL MOV IntLL, A MOV A, IntLH ADDC A, R0 MOV IntLH, A MOV A, R0 JB ACC.7, Pid3Neg ;   ? ;   ,    JNC jPid3End ;       --     . INC IntHL ;    MOV A, IntHL JNZ Pid3End ;      4  --   INC IntHH ;       MOV A, IntHH JNZ Pid3End ;       --   MOV IntHH, #0FFh ;     --    MOV IntHL, #0FFh MOV IntLH, #0FFh MOV IntLL, #0FFh jPid3End: SJMP Pid3End Pid3Neg: ;   ,      ,  FFh MOV A, IntHL ADDC A, #0FFh MOV IntHL, A MOV A, IntHH ADDC A, #0FFh MOV IntHH, A JC Pid3End ;    ,      CPL IntS ;   ,      CPL C ;     MOV A, #0 SUBB A, IntLL MOV IntLL, A MOV A, #0 SUBB A, IntLH MOV IntLH, A MOV A, #0 SUBB A, IntHL MOV IntHL, A MOV A, #0 SUBB A, IntHH MOV IntHH, A ;      --      Pid3End: ; 5. cI = Int*(1/Ti) | 32*32=>32bit Pid5: ; R3:R2:R1:R0 = Int*(1/Ti) JB Ti_sh1, Pid5Calc ;  Ti_sh1=0,  1/Ti=1  Ti=0.      MOV A, Ti_mLL ORL A, Ti_mLH ORL A, Ti_mHL ORL A, Ti_mHH JZ Pid5Zero MOV R0, IntLL MOV R1, IntLH MOV R2, IntHL MOV R3, IntHH AJMP Pid5End Pid5Zero: MOV A, #0 MOV R0, A MOV R1, A MOV R2, A MOV R3, A MOV IntLL, A MOV IntLH, A MOV IntHL, A MOV IntHH, A AJMP Pid5End Pid5Calc: ; R7:R6:R5:R4[:R3] = MULUH(Int*Ti_m) // R3      MOV R2, #0 ;; R7:R6 = IntHH*Ti_mHH MOV A, IntHH MOV B, Ti_mHH MUL AB MOV R7, B MOV R6, A ; R6:R5 += IntHL*Ti_mHH MOV A, IntHL MOV B, Ti_mHH MUL AB MOV R5, A MOV A, R6 ADD A, B MOV R6, A MOV A, R2 ; A=0 ADDC A, R7 MOV R7, A ; R5:R4 += IntLH*Ti_mHH MOV A, IntLH MOV B, Ti_mHH MUL AB MOV R4, A MOV A, R5 ADD A, B MOV R5, A MOV A, R2 ; A=0 ADDC A, R6 MOV R6, A MOV A, R2 ; A=0 ADDC A, R7 MOV R7, A ; R4:R3 += IntLL*Ti_mHH MOV A, IntLL MOV B, Ti_mHH MUL AB MOV R3, A MOV A, R4 ADD A, B MOV R4, A MOV A, R2 ; A=0 ADDC A, R5 MOV R5, A MOV A, R2 ; A=0 ADDC A, R6 MOV R6, A MOV A, R2 ; A=0 ADDC A, R7 MOV R7, A ;; R6:R5 += IntHH*Ti_mHL MOV A, IntHH MOV B, Ti_mHL MUL AB ADD A, R5 MOV R5, A MOV A, R6 ADDC A, B MOV R6, A MOV A, R2 ; A=0 ADDC A, R7 MOV R7, A ; R5:R4 += IntHL*Ti_mHL MOV A, IntHL MOV B, Ti_mHL MUL AB ADD A, R4 MOV R4, A MOV A, R5 ADDC A, B MOV R5, A MOV A, R2 ; A=0 ADDC A, R6 MOV R6, A MOV A, R2 ; A=0 ADDC A, R7 MOV R7, A ; R4:R3 += IntLH*Ti_mHL MOV A, IntLH MOV B, Ti_mHL MUL AB MOV A, R3 MOV R3, A MOV A, R4 ADDC A, B MOV R4, A MOV A, R2 ; A=0 ADDC A, R5 MOV R5, A MOV A, R2 ; A=0 ADDC A, R6 MOV R6, A MOV A, R2 ; A=0 ADDC A, R7 MOV R7, A ;; R5:R4 += IntHH*Ti_mLH MOV A, IntHH MOV B, Ti_mLH MUL AB ADD A, R4 MOV R4, A MOV A, R5 ADDC A, B MOV R5, A MOV A, R2 ; A=0 ADDC A, R6 MOV R6, A MOV A, R2 ; A=0 ADDC A, R7 MOV R7, A ; R4:R3 += IntHL*Ti_mLH MOV A, IntHL MOV B, Ti_mLH MUL AB ADD A, R3 MOV R3, A MOV A, R4 ADDC A, B MOV R4, A MOV A, R2 ; A=0 ADDC A, R5 MOV R5, A MOV A, R2 ; A=0 ADDC A, R6 MOV R6, A MOV A, R2 ; A=0 ADDC A, R7 MOV R7, A ;; R4:R3 += IntHH*Ti_mLL MOV A, IntHH MOV B, Ti_mLL MUL AB ADD A, R3 MOV R3, A MOV A, R4 ADDC A, B MOV R4, A MOV A, R2 ; A=0 ADDC A, R5 MOV R5, A MOV A, R2 ; A=0 ADDC A, R6 MOV R6, A MOV A, R2 ; A=0 ADDC A, R7 MOV R7, A ;;;  R3 > 7F -- MOV A, R3 JNB ACC.7, Pid5Shift ;  R3<80 --    ANL A, #7Fh JZ Pid5Round ;  = 80 --    MOV A, #1 ADD A, R4 MOV R4, A MOV A, R2 ; A=0 ADDC A, R5 MOV R5, A MOV A, R2 ; A=0 ADDC A, R6 MOV R6, A MOV A, R2 ; A=0 ADDC A, R7 MOV R7, A SJMP Pid5Shift Pid5Round: MOV A, R4 ORL A, #01h MOV R4, A ;JMP Pid5Shift Pid5Shift: ; R3:R2:R1:R0 = (Int-R7:R6:R5:R4) >> 1 CLR C MOV A, IntLL SUBB A, R4 MOV R0, A MOV A, IntLH SUBB A, R5 MOV R1, A MOV A, IntHL SUBB A, R6 MOV R2, A MOV A, IntHH SUBB A, R7 RRC A ; >>1    MOV R3, A MOV A, R2 RRC A MOV R2, A MOV A, R1 RRC A MOV R1, A MOV A, R0 RRC A ;MOV R0, A ; R3:R2:R1:R0 += R7:R6:R5:R4 ;MOV A, R0 ADD A, R4 MOV R0, A MOV A, R1 ADDC A, R5 MOV R1, A MOV A, R2 ADDC A, R6 MOV R2, A MOV A, R3 ADDC A, R7 MOV R7, A ;     sh2. ; sh2    16 (    Ti 16;     16 ) MOV A, Ti_sh2 JNB ACC.4, Pid5ShiftUnder16 ;   >=16 -- 2   mov' MOV R0, 18h+2; R2, bank 3 MOV R1, 18h+3; R3, bank 3 MOV R2, #0 MOV R3, #0 Pid5ShiftUnder16: JNB ACC.3, Pid5ShiftUnder8 ;    >=8 -- 1   mov' MOV R0, 18h+1; R1, bank 3 MOV R1, 18h+2; R2, bank 3 MOV R2, 18h+3; R3, bank 3 MOV R3, #0 Pid5ShiftUnder8: ANL A, #07h JZ Pid5End ;       --  MOV R4, A SJMP Pid5ShiftRight Pid5NextShift: CLR C ;    C      ! Pid5ShiftRight: MOV A, R3 RRC A MOV R3, A MOV A, R2 RRC A MOV R2, A MOV A, R1 RRC A MOV R1, A MOV A, R0 RRC A MOV R0, A DJNZ R4, Pid5NextShift ; ,      ;  ,     R3:R2:R1:R0 ;   ,     IntS Pid5End: ; 4. PID += [ cD = Td * (E-Eo) ] | 16*16=>32bit Pid4: ; cD = R7:R6:R5:R4; ErrD = E-Eo CLR C MOV A, ErrL SUBB A, Err0L MOV DiffL, A MOV A, ErrH SUBB A, Err0H MOV DiffH, A MOV C, ACC.7 ;    MOV DiffS, C ;   E-Eo JNC Pid4Mul ; Diff -- ,   MOV A, DiffL CPL A ADD A, #1 MOV DiffL, A MOV A, DiffH CPL A ADDC A, #0 MOV DiffH, A Pid4Mul: ; R7:R6 = DiffH*TdH ; MOV A, DiffH =    A=DiffH MOV B, TdH MUL AB MOV R6, A MOV R7, B ; R5:R4 = DiffL*TdL MOV A, DiffL MOV B, TdL MUL AB MOV R4, A MOV R5, B ; R6:R5 += DiffH*TdL MOV A, DiffH MOV B, TdL MUL AB ADD A, R5 MOV R5, A MOV A, R6 ADD A, B MOV R6, A MOV A, R7 ADDC A, #0 MOV R7, A ; R6:R5 += DiffL*TdH MOV A, DiffL MOV B, TdH MUL AB ADD A, R5 MOV R5, A MOV A, R6 ADD A, B MOV R6, A MOV A, R7 ADDC A, #0 MOV R7, A ; 6. PID = E + cI + cD | 32bit Pid6: ; R3:R2:R1:R0  cI,   IntS; ; R7:R6:R5:R4 = cD;   DiffS ; E     JB IntS, ChkDiffN JNB DiffS, Pid6Add ; Int>0, Diff>0 => Add SJMP Pid6Sub ; Int>0, Diff<0 => Sub ChkDiffN: JNB DiffS, Pid6Sub ; Int<0, Diff>0 => Sub ; Int<0, Diff<0 => Add Pid6Add: ;   =>       MOV A, R0 ADD A, R4 MOV R0, A MOV A, R1 ADDC A, R5 MOV R1, A MOV A, R2 ADDC A, R6 MOV R2, A MOV A, R3 ADDC A, R7 MOV R3, A JNC Pid6Err ;    -      MOV R3, #0FFh MOV R2, #0FFh MOV R1, #0FFh MOV R0, #0FFh SJMP Pid6Err Pid6Sub: ;   --         CLR C MOV A, R4 SUBB A, R0 MOV R0, A MOV A, R5 SUBB A, R1 MOV R1, A MOV A, R6 SUBB A, R2 MOV R2, A MOV A, R7 SUBB A, R3 MOV R3, A JNC Pid6Err ;    --     DiffS CPL DiffS ;   ,  DiffS      MOV R6, #0 ; R6=0 MOV A, R0 CPL A ADDC A, R6 ; R6=0, C=1 =>  +1 MOV R0, A MOV A, R1 CPL A ADDC A, R6 ; + MOV R1, A MOV A, R2 CPL A ADDC A, R6 MOV R2, A MOV A, R3 CPL A ADDC A, R6 MOV R3, A Pid6Err: MOV R6, #0 ; R6=0 ;  R3:R2:R1:R0 --  cI+cD;    DiffS ;  / Err,     ;   Err  DiffS MOV R4, ErrL MOV A, ErrH JB ACC.7, Pid6ChkDiffS JNB DiffS, Pid6SumErrNoInv ; Err>0, Diff>0 => NoInv SJMP Pid6SumErrInv Pid6ChkDiffS: JNB DiffS, Pid6SumErrNoInv ; Err<0, Diff>0 => NoInv Pid6SumErrInv: ;  Err    DiffS --  SETB C ;     C MOV A, ErrL CPL A ADDC A, R6 ; A+=R6+C, R6=0 C=1 => A+=1 MOV R4, A ; R4=ErrL MOV A, ErrH CPL A ADDC A, R6 Pid6SumErrNoInv: MOV R5, A ; ErrH Pid6SumErr: ; ,  R5:R4  Err,     DiffS;   -  MOV A, R0 ADD A, R4 MOV R0, A MOV A, R5 CLR F0 JNB ACC.7, Pid6SubErrPos SETB F0 MOV R6, #0FFh ;   =>  FF Pid6SubErrPos: ADDC A, R1 MOV R1, A MOV A, R2 ADDC A, R6 ; + MOV R2, A MOV A, R3 ADDC A, R6 ; + MOV R3, A MOV R6, #0 ;         JNC Pid6ChkF0 JB F0, Pid7 ; Err<0,   =>   ,   SJMP Pid6SumOv ; Err>0,   =>  Pid6ChkF0: JNB F0, Pid7 ; Err>0,   =>   ;SJMP Pid6SumUf ; Err<0,   =>   Pid6SumUf: ;  Err<0    =>   CPL DiffS MOV A, R0 CPL A ADD A, #1 ; C=?,   1   MOV R0, A MOV A, R1 CPL A ADDC A, R6 MOV R1, A MOV A, R2 CPL A ADDC A, R6 MOV R2, A MOV A, R3 CPL A ADDC A, R6 MOV R3, A SJMP Pid7 ;     DiffS    Pid6SumOv: ;   =>    MOV R0, #0FFh MOV R1, #0FFh MOV R2, #0FFh MOV R3, #0FFh ; 7. U = K*PID/256 | 32bit*16bit/8bit => 40bit, ; |    10bit ; |   Pid7: ;  R3:R2:R1:R0   PID,  DiffS   ;   K*PID/256,    10 ; K  ,   PID < 0 =>  JB DiffS, Pid7Umin ;       16 , ;   R3 != 0 =>      MOV A, R3 JNZ Pid7Umax ; [R2:R1:R0 * KH:HL] = [R7:R6:R5:R4:R3] ; ,     R7=0 R6=0, ;  ,  R7  R6    ;    ; R7:R6 = R2*KH MOV A, R2 JZ Pid7S1 MOV A, KH JNZ Pid7Umax ;  R2!=0  KH!=0 => R7:R6>0 =>  Pid7S1: ; R6:R5 = R2*KL MOV A, R2 MOV B, KL MUL AB MOV R5, A MOV A, B JNZ Pid7Umax ;  R6 > 0 =>  ; R6:R5 = R1*KH MOV A, R1 MOV B, KH MUL AB ADD A, R5 JC Pid7Umax ;  R6 > 0 =>  MOV R5, A MOV A, B JNZ Pid7Umax ;  R6 > 0 =>  ; R5:R4 = R0*KH MOV A, R0 MOV B, KH MUL AB MOV R4, A MOV A, R5 ADD A, B JC Pid7Umax ;  R6 > 0 =>  MOV R5, A ; R5:R4 = R1*KL MOV A, R1 MOV B, KL MUL AB ADD A, R4 MOV R4, A MOV A, R5 ADDC A, B JC Pid7Umax ;  R6 > 0 =>  MOV R5, A ; R4:R3 = R0*KL MOV A, R0 MOV B, KL MUL AB RLC A ; C = R3>=0x80, Z=R3>0x80 MOV R3, #0FFh ; R3<>0x80 =>  JNZ Pid7S2 MOV R3, #0FEh ; R3==0x80 =>    Pid7S2: MOV A, R4 ADDC A, B ;  , ,  - ANL A, R3 ;        --     MOV R4, A MOV A, R5 ADDC A, R6 ; R6=0     ,           JC Pid7Umax ;  R6 > 0 =>  MOV R5, A ; R5:R4 =>   16   ;    R5:R4  Umax/Umin MOV A, UmaxL SUBB A, R4 ; C=0    MOV A, UmaxH SUBB A, R5 JC Pid7Umax ;  R5:R4>Umax => R5:R4 = Umax MOV A, UminL SUBB A, R4 ; C=0    MOV A, UminH SUBB A, R5 JNC Pid7Umin ;  R5:R4<Umin => R5:R4 = Umin ;   MOV UH, R5 MOV UL, R4 SETB UReady AJMP CalcExit Pid7Umax: ;    MOV UH, UmaxH MOV UL, UmaxL SETB UReady AJMP CalcExit Pid7Umin: ;    MOV UH, UminH MOV UL, UminL SETB UReady AJMP CalcExit

नौवीं। एक्सपोजर का आवेदन।

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

एक्स। नुकसान।

अंतर योजना की तुलना में, प्रत्यक्ष योजना में बहुत कम नुकसान हैं, यहां उन लोगों की एक सूची है जो मैंने देखी:

आयामों के लिए लेखांकन । सबसे महत्वपूर्ण और सबसे आम गलती। आप केवल यू = के * (Err + Ki * Int + Kd * डिफ) को नहीं ले सकते, बिना यह निर्दिष्ट किए कि व्हाट्सएप K, Ki, Kd है। और किस सटीकता के साथ। यह गुणांक की के लिए विशेष रूप से महत्वपूर्ण है, जिसमें समय के विपरीत आयाम है - यदि ऑपरेशन पूर्णांक में है, तो इसके द्वारा गुणा करना आसान नहीं है - चूंकि विभाजन होना चाहिए, और पूर्णांक में वापसी संख्या प्रतिनिधित्व योग्य नहीं है।
लेखांकन संकेत । दूसरा बहुत महत्वपूर्ण है - संकेत पर विचार। सभी ऑपरेशन प्रतीकात्मक होने चाहिए, अभिन्न को प्रतीकात्मक संचय करना चाहिए - क्योंकि यह न केवल आनुपातिक घटक को बदलता है, बल्कि आपको बाहरी प्रभावों का विरोध करने की भी अनुमति देता है, उदाहरण के लिए - मिश्रण की गर्मी; और फिर उसका चिन्ह नकारात्मक है।
अतिप्रवाह के लिए लेखांकन । हमारे लिए यह महत्वपूर्ण है कि या तो 0% से 100% तक बिजली प्राप्त करें, या यह तथ्य कि गणना की गई शक्ति 100% से अधिक या 0% से कम है। उदाहरण के लिए, यदि हम एक नकारात्मक परिणाम प्राप्त करते हैं, तो सभी गणना करने की कोई आवश्यकता नहीं है। लेकिन एक ही समय में, यह ध्यान रखना महत्वपूर्ण है कि उत्पाद-अतिरिक्त के दौरान अतिप्रवाह हो सकता है - और इसे "100% से अधिक" के रूप में ध्यान में रखा जाना चाहिए, और किसी भी तरह से परिणाम अतिप्रवाह के बाद नहीं छोड़ा जाना चाहिए। यह मुख्य रूप से आवश्यक होने पर विनियमन की कमी से भरा होता है - वस्तु आवश्यक तापमान से नीचे है, लेकिन बिजली की आपूर्ति नहीं की जाती है
ट्रैकिंग समय गणना । बड़े पैमाने पर गुणा की आवश्यकता (एक साकार वक्र के साथ, विभाजन भी) में समय लगता है, इसलिए सबसे खराब स्थिति की गणना के निष्पादन समय की गणना करना बेहद महत्वपूर्ण है, और यह मापों के बीच खाली समय से कम होना चाहिए। ऐसा करने में विफलता एक अप्रबंधित वस्तु की ओर ले जाती है जो "काम करने लगती है, लेकिन किसी भी तरह से नहीं

ग्यारहवीं। निष्कर्ष।

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

DIY पीआईडी ​​नियंत्रक