PIDMng, PID management

Vai all indice del manuale di programmazione

Tipo: Blocco funzione

Libreria LogicLab: eLLabUtyLib

Libreria Codesys: Non disponibile

ll controllo Proporzionale-Integrale-Derivativo, è un sistema in retroazione negativa ampiamente impiegato nei sistemi di controllo, questo FB acquisisce in ingresso un valore da un processo PValue, e lo confronta con un valore di riferimento SetPoint. La differenza, il cosiddetto segnale di errore, viene usata per determinare il valore della variabile di uscita OValue, che è la variabile di gestione del processo. Il PID regola l’uscita in base a 3 azioni:

Azione proporzionale (P): Il valore del segnale di errore.
Azione integrale (I): I valori passati del segnale di errore.
Azione derivativa (D): Quanto velocemente il segnale di errore varia.

Il valore OValue di uscita può variare nel range definito dai parametri OVLow e OVHigh, il segno dell’uscita sarà positivo se SetPoint>PValue o negativo nel caso contrario. Tramite WControl.4 è possibile invertire la polarità.

Il valore di uscita andrà poi opportunamente scalato per la gestione del processo, può essere ad esempio utilizzato per gestire una modulazione PWM su di un riscaldatore e/o per gestire il riferimento di velocità di un motore.

Taratura PID con Ziegler-Nichols

Si attiva un controllo esclusivamente proporzionale (ITime e DTime impostati a zero);
Il guadagno KProp viene gradualmente aumentato;
Il guadagno Ku è il valore al quale le oscillazioni del processo non spariscono dopo un transitorio;
Si registra il periodo critico T delle oscillazioni;
Secondo la seguente tabella, si determinano le costanti per il controllore P, PI o PID.

Tipo regolazione	KProp	ITime	DTime
Proporzionale	Ku*0.5	0	0
Proporzionale/Integrativa	Ku*0.45	T/1.25	0
Proporzionale/Integrativa/Derivativa	Ku*06	T/2	T/8

Descrizione

Enable (BOOL) Abilitazione regolazione PID, attivando l’ingresso si abilita la regolazione. Disattivandolo si azzera il valore in uscita OValue.
SpyOn (BOOL) Se attivo permette di spiare il funzionamento della FB (Vedi articolo).
WControl (WORD) Word di controllo, vedi descrizione.
Manual (BOOL) Comando funzionamento manuale, OValue:=MValue.
MValue (REAL) Impostazione valore uscita manuale, viene trasferito su OValue se Manual attivo (%).
Bias (REAL) Impostazione offset valore uscita, se PID in automatico (%).
SetPoint (REAL) Set point, valore di set point (Grandezza fisica).
PValue (REAL) Valore acquisito dal processo (Grandezza fisica).
DBand (REAL) Banda morta, valore di errore processo tra le grandezze fisiche SetPoint e PValue entro il quale è azzerato l’errore. Impostando valore 0 si disabilita il controllo.
KProp (REAL) Costante proporzionale, si ricorda che più è elevato il valore più è pronta è la regolazione con un conseguente aumento del valore di overshot. Il valore è un numero.
ITime (REAL) Tempo integrativo, si ricorda che più è elevato il valore meno è veloce la regolazione integrativa a recuperare l’errore (S). Impostando valore 0 si disabilita l’azione integrativa.
DTime (REAL) Tempo derivativo, si ricorda che più è elevato il valore più è veloce la regolazione derivativa a recuperare l’errore (S). Impostando valore 0 si disabilita l’azione derivativa.
ScTime (TIME) Tempo esecuzione regolazione PID. La regolazione viene eseguita ogni tempo definito.
OVHigh (REAL) Valore massimo uscita PID (%).
OVLow (REAL) Valore minimo uscita PID (%).
Enabled (BOOL) Regolazione PID abilitata.
WStatus (WORD) Word di stato, vedi descrizione.
PError (REAL) Errore di processo (Grandezza fisica).
PTerm (REAL) Termine di correzione proporzionale (%).
ITerm (REAL) Termine di correzione integrale (%).
DTerm (REAL) Termine di correzione derivativa (%).
OValue (REAL) Valore uscita regolazione PID. Questo valore deve essere utilizzato per il comando del processo (%)

WControl

WControl.4: Inversione polarità errore di processo.
WControl.12: Attiva spionaggio esteso.

WStatus

WStatus.4: PID stà operando in modo manuale.
WStatus.6: Usato internamente.
WStatus.7: Usato internamente.
WStatus.8: OValue è in limite basso OVLow.
WStatus.9: OValue è in limite alto OVHigh.
WStatus.12: Usato internamente.

Trigger di spy

Se SpyOn attivo è possibile utilizzare la console di spionaggio per verificare il funzionamento della FB. Sono previsti vari livelli di triggers.

Livelli di trigger

Trigger	Descrizione
16#10000000	Lg: Logs di esecuzione.

Dati in spionaggio

Attivando lo spionaggio nella console ad ogni tempo di scansione definito ScTime, viene ritornato un record in formato CSV con tutti idati interni della regolazione, salvandolo su disco è possibile importarlo in Excel per una analasi approfondita.

02:38:32(9000)|PIDMng:Lg|Mode;   MValue;     Bias;   SPoint;   PValue; ActError;    PTerm;    ITerm;    DTerm;   OValue
02:38:32(   0)|PIDMng:Lg|Auto;    0.000;    0.000;    5.000;    4.000;    1.000;    1.000;    0.000;    0.000;    1.000
02:38:33(1000)|PIDMng:Lg|Auto;    0.000;    0.000;    5.000;    4.000;    1.000;    1.000;    0.000;    0.000;    1.000
02:38:34(1000)|PIDMng:Lg|Auto;    0.000;    0.000;    5.000;    4.000;    1.000;    1.000;    0.000;    0.000;    1.000
02:38:35(1000)|PIDMng:Lg|Auto;    0.000;    0.000;    5.000;    4.000;    1.000;    1.000;    0.000;    0.000;    1.000
02:38:36(1000)|PIDMng:Lg|Auto;    0.000;    0.000;    5.000;    4.000;    1.000;    1.000;    0.000;    0.000;    1.000
02:38:37(1000)|PIDMng:Lg|Auto;    0.000;    0.000;    5.000;    4.000;    1.000;    1.000;    0.000;    0.000;    1.000

Attivando il bit WControl.12 è possibile avere un record esteso.

02:36:27(----)|PIDMng:Lg|Mode;   MValue;     Bias;   SPoint;   PValue;  PrError; ActError;    PTerm;    ITerm;    DTerm;   OVHigh;    OVLow;   OValue
02:36:27(   0)|PIDMng:Lg|Auto;    0.000;    0.000;    5.000;    4.000;    1.000;    1.000;    1.000;    0.000;    0.000;  100.000; -100.000;    1.000
02:36:28(1000)|PIDMng:Lg|Auto;    0.000;    0.000;    5.000;    4.000;    1.000;    1.000;    1.000;    0.000;    0.000;  100.000; -100.000;    1.000
02:36:29(1000)|PIDMng:Lg|Auto;    0.000;    0.000;    5.000;    4.000;    1.000;    1.000;    1.000;    0.000;    0.000;  100.000; -100.000;    1.000
02:36:30(1000)|PIDMng:Lg|Auto;    0.000;    0.000;    5.000;    4.000;    1.000;    1.000;    1.000;    0.000;    0.000;  100.000; -100.000;    1.000
02:36:31(1000)|PIDMng:Lg|Auto;    0.000;    0.000;    5.000;    4.000;    1.000;    1.000;    1.000;    0.000;    0.000;  100.000; -100.000;    1.000

Caratteristiche del regolatore PID

Deadband: Banda morta utilizzata per prevenire oscillazioni o ripetuti cicli di attivazione-disattivazione dell’attuatore.
Anti-Reset Windup: Funzione che impedisce alla regolazione integrale di continuare a crescere quando la somma tra la regolazione PID ed il Bias raggiungono i limiti definiti in OVLow/OVHigh.
Manual mode with bumpless transfer: Nel funzionamento manuale (Attivando l’ingresso Manual) viene esclusa la regolazione PID e l’uscita Out viene impostata con il valore definito in MValue. Nel passaggio da manuale ad automatico viene calcolata l’azione integrale richiesta per avere un passaggio bumpless.
Feed forward o Bias: Il feed forward è una tecnica di previsione che stima l’output del PID senza attendere la risposta dell’algoritmo. Questo permette di ridurre l’errore più velocemente o mantenere l’errore più piccolo rispetto alla sola regolazione PID.

Esempi

Come utilizzare gli esempi.
FBD_PIDMng_v3: Viene gestita la termoregolazione di un forno. Una sonda Pt100 acquisisce il valore di temperatura, e l’uscita del FB tramite il FB PWMOut gestisce il forno. La funzione oscilloscopio di LogicLabpermette di verificare il funzionamento e procedere alla ottimizzazione dei valori per ottenere la regolazione migliore.

ST_PIDMngTest: Viene simulato un caso reale di regolazione PID. L’uscita del FB è connessa ad un FB LRamp che simula il processo. Da debug è possibile gestire il passaggio bumpless da regolazione automatica a manuale e viceversa.

LogicLab (Ptp114, FBD_PIDMng)

PROGRAM FBD_PIDMng
VAR
    Enable : BOOL := TRUE; (* PID enable *)
    SetPoint : REAL; (* PID Set point *)
    PValue : REAL; (* PID process value *)
    KProp : REAL := 1.0; (* Proportional coefficent (Nr) *)
    ITime : REAL := 20.0; (* Integrative time (Sec) *)
    DTime : REAL := 5.0; (* Derivative time (Sec) *)
    ScTime : TIME := T#200ms; (* Scansion time *)
    AIn : SysGetAnInp; (* Analog input acquisition *)
    PIDFb : PIDMng_v3; (* PID function block *)
    POut : PWMOut_v1; (* PWM out command *)
END_VAR

LogicLab (Ptp114, ST_PIDMngTest)

PROGRAM ST_PIDMngTest
VAR
    Enable : BOOL := TRUE; (* PID enable *)
    SetPoint : REAL; (* PID Set point *)
    PValue : REAL; (* PID process value *)
    KProp : REAL := 1.0; (* Proportional coefficent (Nr) *)
    ITime : REAL := 20.0; (* Integrative time (Sec) *)
    DTime : REAL := 5.0; (* Derivative time (Sec) *)
    ScTime : TIME := T#200ms; (* Scansion time *)
    AIn : SysGetAnInp; (* Analog input acquisition *)
    PIDFb : PIDMng_v3; (* PID function block *)
    Ramp : LRamp; (* Ramp FB *)
END_VAR

// *****************************************************************************
// PROGRAM "ST_PIDMngTest"
// *****************************************************************************
// This program realizes a simply PID temperature regulation.
// -----------------------------------------------------------------------------

    // -------------------------------------------------------------------------
    // INITIALIZATION
    // -------------------------------------------------------------------------
    // Initialize all FBs.

    IF (SysFirstLoop) THEN

        // Initialize PID FB.

        PIDFb.Bias:=0.0; //Bias value (%)
        PIDFb.DBand:=0.0; //Dead Band (Nr)
        PIDFb.OVHigh:=100.0; //Output value high (%)
        PIDFb.OVLow:=0.0; //Output value low (%)

        // Initialize ramp FB.

        Ramp.UPSlope:=1.0; //Up slope
        Ramp.DWSlope:=1.0; //Dw slope
    END_IF;

    // -------------------------------------------------------------------------
    // PID REGULATION
    // -------------------------------------------------------------------------
    // Manage the PID.

    PIDFb.Enable:=Enable; //PID enable
    PIDFb.ScTime:=ScTime; //Scansion time
    PIDFb.KProp:=KProp; //Proportional coefficent (Nr)
    PIDFb.ITime:=ITime; //Integrative time (Sec)
    PIDFb.DTime:=DTime; //Derivative time (Sec)
    PIDFb.PValue:=Ramp.Out; //Process value
    PIDFb(); //PID function block

    // Auto/Manual actions to avoid bumping.
    // If PID on Auto mode transfer the Out to MValue.
    // If PID on Manual mode transfer the PValue to SetPoint.

    IF NOT(PIDFb.Manual) THEN PIDFb.MValue:=PIDFb.OValue; END_IF;
    IF (PIDFb.Manual) THEN PIDFb.SetPoint:=PIDFb.PValue; END_IF;

   // Execute the ramp to simulate the process.

    Ramp.In:=PIDFb.OValue; //Input value
    Ramp(Enable:=TRUE); //Execute the ramp
    PValue:=Ramp.Out; //PID process value

// [End of file]

Was this article helpful?

Yes No