Verstehen Sie den Fluss eines PI-Controllers?

Ich bin mir theoretisch bewusst, wie ein PID-Controller funktioniert, habe noch nie einen implementiert. Ich implementiere eine Steuermethode zum Ansteuern eines Ventils über PWM.

Details zum Anwendungsfall: Das System verfügt über zwei ADC-Kanäle, einen für die Eingabe und den anderen für die Rückmeldung. Das Lesen von ADC-Kanälen ist freilaufend, wobei ausreichend Proben genommen werden.

Vorhandene Implementierung: Es gibt eine Endlosschleife, die nur zwei Aufgaben erledigt: ADC-Werte lesen und PWM erzeugen. Es gibt einen Timer-Interrupt, der so konfiguriert ist, dass er bei 20 ms aufgerufen wird. Also 'Ist die Zeit abgelaufen?' im Flussdiagramm unten wird alle 20 ms mit „Ja“ bewertet. Unten ist das Flussdiagramm dessen, was ich jetzt mache.

Folgendes ist das Programm, das ich mir anschaue:

/*
    Some information on variables that are being used:

    CURR_OUT_CH is Feedback channel
    CMD_INP_CH is the channel where external input is applied.
    So, ADC_Val.fADC_Final_mAVal[CURR_OUT_CH] is where I am receiving the value of feedback
    And, ADC_Val.fADC_Final_mAVal[CMD_INP_CH ] is where I am receiving the value of external input that I am trying to achieve
    MAX_ALLOWABLE_DUTY_CYCLE  is a macro set to ((uint16_t)480) which Maps to 60% - This is a requirement.

        (Op-Amp output is in mV, I convert it into mA based on resistor values)

    (Config[chUser_Config_Mode].uiMaxCMD_I) is 350. (max current allowed through, in mA)
*/

#define RESTRICT(x, low, high)   (x = (x)<(low)?(low):((x)>(high)?(x=high):(x)))

typedef struct {

    float fFeedback;
    float fOutput;
    float Kp;
    float Ki;
    float fIntegralError;
    float fSetpoint;

} PIControl_t;

PIControl_t PI;
uint16_t Load_Dutycount;

void PICompute(PIControl_t *pPI) 
{
    // I know that if PI is already a global, then taking the pointer doesn't make sense here,
    // but, I may have to add another PI for a different sensor here, that is why I have used 
    // it this way!

    // Instantaneous error is always local
    float fError = 0.0;

    // The classic PID error term
    fError = pPI->fSetpoint - pPI->fFeedback;

    // Compute the integral term
    pPI->fIntegralError += (pPI->Ki * fError);

    // Run all the terms together to get the overall output
    pPI->fOutput = (pPI->Kp * fError) + (pPI->fIntegralError);
}

void Update_PWM_Module(void)
{
    // Might want to get rid of this fCount, lets see.
    float fCount = 0.0;

    // Timer hasn't generated an interrupt yet (Integration time hasn't elapsed)
    // ISR sets the bCompute variable - Flags are Not the best way, but does what it should.
    // And, Timer doesn't start counting if bCompute is set
    if(!bCompute)
    {
        // No control action needed, return!
        return;
    }

    // Assign the feedback value read for PI output computation
    PI.fFeedback = ADC_Val.fADC_Final_mAVal[CURR_OUT_CH];

    // Compute the PI Controller output
    PICompute(&PI);

    // Formulate the value to be used to generate PWM
    ADC_Val.fADC_Final_mAVal[CURR_OUT_CH] = ADC_Val.fADC_Final_mAVal[CURR_OUT_CH] + PI.fOutput;

    // Map Output to no. of counts
    fCount = (float) ((ADC_Val.fADC_Final_mAVal[CURR_OUT_CH] * MAX_ALLOWABLE_DUTY_CYCLE) / (float)(Config[chUser_Config_Mode].uiMaxCMD_I));

    // Convert into compatible Duty Count type - uint16_t
    Load_Dutycount = (uint16_t) fCount;

    // Bound the output count between worst case lower and higher points
    RESTRICT(Load_Dutycount, MIN_DUTY_CYCLE_COUNT, MAX_ALLOWABLE_DUTY_CYCLE);

    // Generate PWM
    Generate_PWM(Load_Dutycount);

    // Assign the latest external input value read from ADC as the Setpoint for PI computation
    PI.fSetpoint = ADC_Val.fADC_Final_mAVal[CMD_INP_CH] ;

    // Not sure about this --- Because I think with a new Setpoint, the integrated error (which was developed based on previous Setpoints) will have no significance.
    PI.fIntegralError = 0.0;

    // Start integration all over again (Timer doesn't start counting if bCompute is set)
    bCompute = false;
}    

int main(void)
{
    // Some code for Power-ON initialization like,
    //    ADC
    //    Timer
    //    PWM
    //    PI variables
    //    Everything else which needs one-time initialization before going into the infinite loop

    while(1)
    {
        Read_ADC();
        Update_PWM_Module();
    }
}

Sobald die PWM erzeugt ist, läuft sie frei. Das Tastverhältnis bleibt konstant, es sei denn, ich ändere es, daher ändert es sich nur periodisch basierend auf der PI-Berechnung.

Zur Verdeutlichung, wenn ich sage "den Wert des integrierten Fehlers aufheben", meinte ich pPI->integralError = 0.0;das C-Programm.

Problemstellung: Die Gesamtzeit für die Ausführung der Schleife, wenn der Timer nicht abgelaufen ist, beträgt ungefähr 2 ms. Die Ausführungszeit erhöht sich natürlich, wenn die PI-Berechnung abgeschlossen ist und die PWM-Erzeugungsfunktion aufgerufen wird.

Ich prüfe die beiden Signale:
- Ausgang der Rückkopplung am Ausgang des verwendeten Operationsverstärkers.
- Eingabe in das System.

Meine Frage ist, ist der Betriebsablauf korrekt? Habe ich Recht, PWM erst nach Abschluss der PI-Berechnung zu erzeugen und den Wert des integrierten Fehlers auf 0,0 zurückzusetzen, wenn ein neuer Sollwert zugewiesen wird? Beim Testen mit einem Schritteingang von 0-4 V, 0,5 Hz auf dem Oszilloskop sehe ich, dass das System etwa 120 ms benötigt, um seinen Ausgang auf den Eingang anzuheben. Ich kann korrelieren, dass die P- und I-Werte angepasst werden müssen, um die Zeit zu verbessern. In diesem Beitrag geht es nicht viel um die Abstimmung der Werte der P- und I-Faktoren.

Verwandte Lektüre: Fragen zu electronic.stackexchange, die ich durchgelesen habe und eng damit verbunden sind:

• Missverständnisse über PID-Controller
• Entwurf eines PI-Reglers