Kp, Ki, Kd für Software-PID-Regelung

Ich entwerfe eine Software-PID-Steuerung. Logik ist fast endgültig, aber ich frage mich, wie ich den Wert bestimme k P , k ich Und k D . Außerdem muss ich den maximalen und minimalen Wert für Pterm Item und Dterm bestimmen. Wie mache ich das?. Außerdem versuche ich, die inverse Steuerung zu implementieren. Gehe ich beim Entwerfen der Software-PID auch auf dem richtigen Weg? Auch wenn integrale Zeit und k ich beide sind gleich? Der Code, den ich bisher geschrieben habe, ist unten angegeben.

Calculate_Error();
    P_Term = Percnt_Error;

    P_Term = KP * P_Term;


    if(P_Term >= PMAX)
    {
        P_Term = PMAX;
    }
    else if(P_Term <= PMIN)
    {
        P_Term = PMIN;
    }

// Integral calculation

    if(Integraltime==1)                 // Take integration at every 1s
    {
        Integraltime = 0;
        Error_Accum = Error_Accum + Percnt_Error;   // Error Accumulation over time
        if(Error_Accum >= MaxAccumError)
        {
            Error_Accum = MaxAccumError;
        }

        if(Error_Accum <= -MinAccumError)
        {
            Error_Accum = -MinAccumError;
        }

        I_Term = (Error_Accum)*KI;

        if(I_Term >= IMAX)
        {
            I_Term = IMAX;
        }
        else if(I_Term <= IMIN)
        {
            I_Term = IMIN;
        }
    }
Haben Sie versucht, nach "PID-Tuning" zu suchen? Ich meine mich zu erinnern, dass es einige Standard-Tuning-Methoden gibt, die Ihnen nahe kommen, aber die Feinabstimmung ist ebenso Kunst wie Wissenschaft.
Es gibt die ultimative Methode von Zeiger-Nichols, zuerst den Kp-Anteil implementieren, Kp auf 0 setzen, Kp erhöhen, bis das Ausgangsverhalten zyklisch wird (leichter gesagt als getan), die Periodizität dieses zyklischen Verhaltens sowie die Amplitude dienen als Heuristik um den PI-, PD- oder PID-Regler abzustimmen.

Antworten (3)

Alle Anerkennung dafür stammt aus dem (inzwischen leider toten) Balancing Robots for Dummies- Thread im Arduino-Forum.

Der PID-Regler ist wie folgt:

int
updatePID(int setPoint, int currentPoint)
{
    float error;
    static float last_error;
    static float integrated_error;

    float pTerm, iTerm, dTerm;

/*  Calculate error and proportional value.*/
    error = setPoint - currentPoint;
    pTerm = Kp * error;

/*  Calculate error and intergral value.*/
    integrated_error += error;
    iTerm = Ki * constrain(integrated_error, LOWER_LIMIT, UPPER_LIMIT);

/*  Calculate deriviative value and reset error.*/
    dTerm = Kd * (error - last_error);
    last_error = error;

/*  Return the PID controlled value.*/
    return constrain(i32K*(pTerm + iTerm + dTerm)), LOWER_LIMIT, UPPER_LIMIT);

}

Diese Version der 'Software-PID-Steuerung' implementiert die Begrenzung des Integralwerts (ähnlich wie Ihr Code) mithilfe der Constrain- Funktion aus der Arduino-Bibliothek. Der zusätzliche Vorteil dieses Codes besteht darin, dass Sie auswählen können, was Sie vom Controller möchten, indem Sie den Rückgabewert ändern. ZB würde ein PD-Controller das iTermaus dem Rückgabewert entfernen.

Was das Tuning betrifft, ist es ähnlich wie bei Illegal Immigrant .

Set Ki, Kp, and Kd to 0.
Tune Kp until oscillation occurs.
Reduce oscillation and overshoot by tuning Kd.
Tune Ki to increase the speed of the system.

Dies ist das erste Mal, dass ich antworte. Hoffentlich habe ich das richtig gemacht und Ihnen ein wenig auf dem Weg geholfen!

Willkommen bei EE:SE. Ich wünschte, meine erste Antwort wäre so gut gewesen wie diese!

Welche Art von Integrator möchten Sie implementieren? Wenn Sie sich Ihren Code ansehen, haben Sie einen einfachen Akkumulator, er wird funktionieren, aber es gibt bessere Integratoren, die auch die Zuordnung zur S-Domäne erleichtern

fwdEuler? j ( N ) = j ( N − 1 ) + K × [ T ( N ) − T ( N − 1 ) ] × X ( N − 1 )

RevEuler? j ( N ) = j ( N − 1 ) + K × [ T ( N ) − T ( N − 1 ) ] × X ( N )

Fangen? j ( N ) = j ( N − 1 ) + K × [ T ( N ) − T ( N − 1 ) ] × [ X ( N ) + X ( N − 1 ) ] / 2

Es ist gut, dass Sie erwägen, Summierungsgrenzen für die PID festzulegen. Darf ich Ihnen empfehlen, ein individuelles Limit für die festzulegen K ich Begriff und eine Gesamtsummierungsgrenze. Dadurch werden Abwicklungsbedenken beim Integrator gemildert.

lim − X → X ( K P + lim − X → X K ich + K D )

Wie bestimmen Sie den Maximalwert für die Grenzwerte? Es hängt davon ab, was die PID einspeist.

Angenommen, es ist der Controller für einen Geschwindigkeitsregelkreis. Die Ausgabe davon wird eine aktuelle Nachfrage sein. Wenn der maximale Strom, auf den Sie steuern möchten, beispielsweise 100 Ampere beträgt, möchten Sie nicht, dass die Geschwindigkeits-PID eine höhere Anforderung ausgibt, ebenso möchten Sie dies nicht K ich sich höher akkumulieren (siehe vorherige Aussage zu Anti-Windup)

So wählen Sie die Ziffer aus K P , K ich , K D ? Willkommen in der Kontrolltheorie. Es gibt eine Reihe von Möglichkeiten. In der Regel werden ein Systemmodell und Stabilitätskriterien benötigt.

Ich habe es hier nicht erwähnt, aber ich habe auch die minimale und maximale Grenze für meinen PID-Ausgang angegeben. Als letztes PID = P+I-D.unter Berücksichtigung des Maximalwerts jeder einzelnen Komponente habe ich PIDmax und PIDmin erhalten. Was kp, KI und kd angeht, nähere ich mich gerade der Try-and-Error-Methode. Aber ich bin mir ein bisschen unsicher, ob es eine gute Praxis ist oder nicht.
Kann ich für die Simulation ein generisches Tool oder so haben?
Sie können Python verwenden. Ich habe einen einfachen Z-Domain-Controller, der in Python funktioniert.
Gibt es einen guten Excel-Simulator? Ich versuche selbst, einen für meine Anwendung zu bauen, eine Referenz kann sehr nützlich sein.
Es fliegen einige herum (google "PID excel"). Ich habe eine, die ich verwendet habe, weil es manchmal einfacher ist, jemandem ein Excel-Blatt (das er öffnen kann) zu geben als ein Matlab-Modell oder ein Py-Skript
Ich habe kein Matlab dabei, also suche ich nach einem Excel-Simulator

Wenn Sie ein Überschwingen tolerieren können, lesen Sie die Ziegler-Nichols-Methode auf Wikipedia nach. Dies ist aggressiv und findet oft die beste Reaktionsgeschwindigkeit innerhalb der Leistungsgrenzen Ihres Stellantriebs. Wenn Sie eine kritische Dämpfung benötigen (z. B. Werkzeugmaschinen), benötigen Sie etwas anderes. Viel mehr bei Loop-Tuning-Methoden

Kp, Ki, Kd für Software-PID-Regelung
AntwortenHierDatenschutz-Bestimmungen1y, 0v