पीआईडी ​​नियंत्रण बड़ी और अप्रत्याशित विसंगतियों के साथ लूप्स

Question

लघु प्रश्न
क्या एक समान रूप से एक समान नियंत्रण क्षेत्र के भीतर बहुत बड़ी विसंगतियों (परिमाण का क्रम) को संभालने का एक सामान्य तरीका है?

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

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

चीजें जो मैं प्रोटोटाइप कर रहा हूं

• नेस्टेड पीआईडी ​​(बहुत ही आक्रामक जब लक्ष्य से दूर, रूढ़िवादी जब पास हो)
• दूर होने पर निश्चित लाभ, पास होने पर पीआईडी
• कंजर्वेटिव पीआईडी ​​(बिना लोड के काम करता है) + एक बाहरी नियंत्रण जो पीआईडी ​​को स्टाल करने और अतिरिक्त ऊर्जा को लागू करने के लिए देखता है: या तो लक्ष्य हासिल किया जाता है या तेजी से परिवर्तन की दर का पता लगाया जाता है (यानी उच्च लोड क्षेत्र को छोड़कर)

सीमाएं

• पूर्ण यात्रा परिभाषित
• हार्डस्टॉप्स को नहीं जोड़ा जा सकता है (समय में इस बिंदु पर)
• त्रुटि की संभावना कभी भी शून्य नहीं होगी
• उच्च भार को 10% से कम यात्रा से प्राप्त किया जा सकता है (जिसका अर्थ है "कोई प्रारंभ नहीं")

Answer 1

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

अगर मुझे यह आपका कोड सही लगा

// Determine the error delta
dE = abs(last_error - new_error);
last_error = new_error;

हमेशा वर्तमान त्रुटि के आधार पर नियंत्रण शब्द की गणना करेगा, जो पारंपरिक तरीका है कि पीआईडी ​​को कैसे लागू किया गया था। यह ठीक है क्योंकि I अवधि को वैसे भी संचित त्रुटि का ध्यान रखना चाहिए।

हालाँकि, मेरे पास एक ग्राहक था जो निम्नलिखित विचार के साथ आया था जिसे आप आज़माना चाहते हैं। चूंकि आपके पास प्रक्रिया वक्र का एक हिस्सा है जहां अधिक आक्रामक परिवर्तनों की आवश्यकता होती है, आप डी पार्ट त्रुटि को भी जमा कर सकते हैं:

if(TD)                                                 // Calculate D term
{  
   Last_C += (Error - Last_C) / TD;                    // D term simulates
   Dterm = (Error - Last_C) * KD;                      // capacitor discharging
}
else    
   Dterm = 0;                                          // D term is OFF (TD is 0)

यहाँ ध्यान देने योग्य दो रोचक बातें हैं:

• टीडी मान व्युत्पन्न लाभ (जो केडी है) नहीं है, लेकिन व्युत्पन्न समय, एक उपयोगकर्ता स्थिरांक जो त्रुटि के संचय के लिए समय को नियंत्रित करता है। यदि इसे शून्य पर सेट किया गया था, पीआईडी ​​का डी हिस्सा केडी लाभ मूल्य सेट की अवहेलना अक्षम है।

• ध्यान दें कि वर्तमान त्रुटि का उपयोग अंतिम भाग डी गणना पर लेने से पहले Last_C मान को 'चार्ज' करने के लिए कैसे किया गया था। Last_C वैरिएबल एक संधारित्र की तरह काम कर रहा है, यह त्रुटि बड़ी होने के दौरान बनेगा, ताकि आपका व्युत्पन्न हिस्सा त्रुटि के हाल के 'इतिहास' के आधार पर कार्य करे, और उसके बाद (जब त्रुटि छोटी थी) यह 'इतिहास' 'कैपेसिटर की तरह डिस्चार्ज होगा।

बेशक, आपको कुल आउटपुट को सीमित करना चाहिए जिस तरह से आप शायद पहले से ही कर रहे हैं (एंटी विंडअप रीसेट, मैनुअल ट्रांसफर और अन्य सामान्य सामान के लिए ऑटोलेस)।

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

Comments

इनपुट के लिए धन्यवाद। मुझे यह कोशिश करनी होगी। एक त्वरित नज़र में यह समझ में आता है।

— एडम लुईस

मैं देखता हूं, इसलिए आपके 'मुख्य' पीआईडी ​​के भीतर डी टर्म का योगदान है, जो भी स्टाल डिटेक्शन गणना में लाता है।

— दीजेन सिका

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

— एडम लुईस

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

— Drazen Cika

Answer 2

प्रारंभिक समाधान

stalled_pwm_output = PWM / | ΔE |

PWM = अधिकतम PWM मान
=E = last_error - new_error

प्रारंभिक संबंध सफलतापूर्वक मोटर में परिवर्तन की कमी के आधार पर PWM आउटपुट को रैंप करता है। नमूना आउटपुट के लिए नीचे दिया गया ग्राफ़ देखें।

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

वर्तमान समाधान

सिद्धांत

stalled_pwm_output = (kE * PID_PWM) / | ΔE |

केई = स्केलिंग कॉन्स्टेंट
PID_PWM = गैर-
एग्रेसिव PID से वर्तमान PWM अनुरोध ΔE = last_error - new_error

मेरा वर्तमान संबंध अभी भी 1 / ΔE अवधारणा का उपयोग करता है, लेकिन stall_pwm_output निर्धारित करने के लिए गैर-आक्रामक PID PWM आउटपुट का उपयोग करता है। यह PID को stall_pwm_output को वापस थ्रॉटल करने की अनुमति देता है जब यह लक्ष्य सेटपॉइंट के करीब होना शुरू होता है, फिर भी रुकने पर 100% PWM आउटपुट की अनुमति देता है। पीडब्लूएम को संतृप्ति बिंदु (10,000 से नीचे के ग्राफ़ में ऊपर) सुनिश्चित करने के लिए स्केलिंग निरंतर केई की आवश्यकता होती है।

छद्म कोड

ध्यान दें कि मेरे वर्तमान नियंत्रण तर्क में PID PWM आउटपुट में cal_stall_pwm से परिणाम जोड़ा गया है।

int calc_stall_pwm(int pid_pwm, int new_error)
{
    int ret = 0;
    int dE = 0;
    static int last_error = 0;
    const int kE = 1;

    // Allow the stall_control until the setpoint is achived
    if( FALSE == motor_has_reached_target())
    {
        // Determine the error delta
        dE = abs(last_error - new_error);
        last_error = new_error;

        // Protect from divide by zeros
        dE = (dE == 0) ? 1 : dE;

        // Determine the stall_pwm_output
        ret = (kE * pid_pwm) / dE;
    }

    return ret;
}

उत्पादित आंकड़े

रुका हुआ PWM आउटपुट

ध्यान दें कि रुके हुए पीडब्लूएम आउटपुट ग्राफ में ~ 3400 पर अचानक पीडब्लूएम ड्रॉप एक सेफ्टी फीचर एक्टिवेटेड है, क्योंकि मोटर एक निश्चित समय के भीतर स्थिति में पहुंचने में असमर्थ था।

गैर-लोड पीडब्लूएम आउटपुट

Answer 3

आप यह नहीं कहते कि यह आप क्या है ... मोटर गति? स्थान? खैर जो भी हो, पहला कदम यह परिभाषित करना होगा कि स्वीकार्य त्रुटि क्या होगी। उदाहरण के लिए यदि नियंत्रण गति के लिए है तो लक्ष्य के 1% के भीतर अधिकतम त्रुटि सेट की जा सकती है। स्वीकार्य त्रुटि को परिभाषित किए बिना आप यह निर्धारित नहीं कर सकते हैं कि आपको एडीसीएस या पीडब्लूएम गणना के लिए कितने संकल्प की आवश्यकता है। इसके बिना, पीआईडी ​​मुआवजा पूर्ण हो सकता है, लेकिन फिर भी सीमा चक्र दोलनों की सीमा होगी।

फिर आपको ओपन लूप सिस्टम की गतिशीलता को जानना होगा। इसके बिना आप यह नहीं जान सकते हैं कि लूप के आनुपातिक (पी), इंटीग्रल (आई) और व्युत्पन्न (डी) भागों के लिए क्या लाभ चाहिए। आप इनपुट कदम (ड्राइव स्तर या पीडब्लूएम में कदम परिवर्तन) के साथ गतिशील को माप सकते हैं, या लोड में बदलाव (ऐसा लगता है कि यह आपके लिए प्रासंगिक होगा)।

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

लूप का P भाग तात्कालिक त्रुटि का ध्यान रखता है (तुरंत त्रुटि का उत्तर देता है)। लेकिन इसका परिमित लाभ होगा इसलिए कुछ त्रुटि रह जाएगी। लूप का I हिस्सा उस त्रुटि को सही करने के लिए अनंत लाभ (अनंत समय के लिए अनंत समय) को लागू करने के लिए समय के साथ धीरे-धीरे प्रतिक्रिया करता है जिसे P भाग द्वारा छोड़ दिया गया था।

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

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