Controllo PID

Da Wikipedia, l'enciclopedia libera.
(Reindirizzamento da Controllori PID)
Controllore pneumatico PID. In alto sono visibili i comandi di regolazione per l'azione proporzionale (P), integrale (I) e derivativa (D).

Il controllo Proporzionale-Integrale-Derivativo[1] (talvolta tradotto anche con Proporzionale-Integrativo-Derivativo, dall'inglese Proportional-Integral-Derivative), comunemente abbreviato come PID, è un sistema in retroazione negativa ampiamente impiegato nei sistemi di controllo. È il sistema di controllo in retroazione di gran lunga più comune nell'industria, in particolare nella versione PI (senza azione derivativa). Grazie a un input che determina il valore attuale, è in grado di reagire a un eventuale errore positivo o negativo tendendo verso il valore 0. La reazione all'errore può essere regolata e ciò rende questo sistema molto versatile.[2].

Fondamenti[modifica | modifica sorgente]

Il controllore acquisisce in ingresso un valore da un processo, e lo confronta con un valore di riferimento. La differenza, il cosiddetto segnale di errore, viene quindi usata per determinare il valore della variabile di uscita del controllore, che è la variabile manipolabile del processo.

Il PID regola l'uscita in base a:

  • il valore del segnale di errore (azione proporzionale);
  • i valori passati del segnale di errore (azione integrale);
  • quanto velocemente il segnale di errore varia (azione derivativa).

I controllori PID sono relativamente semplici da comprendere, installare, e tarare al confronto con più complessi algoritmi di controllo basati sulla teoria del controllo ottimo e del controllo robusto. La taratura dei parametri avviene di solito attraverso semplici regole empiriche, come i metodi di Ziegler-Nichols, che risultano in controllori stabilizzanti di buone prestazioni per la maggior parte dei processi. Molto spesso l'azione derivativa viene rimossa, risultando nel comunissimo controllore PI.

Limitazioni[modifica | modifica sorgente]

I controllori PID sono spesso sufficienti a controllare processi industriali anche complessi, ma la loro semplicità risulta in una serie di limiti che è bene tener presente:

  • Non sono in grado di adattarsi a cambiamenti nei parametri del processo;
  • Non sono stabili, a causa della presenza dell'azione integrale (vedi Windup);
  • Alcune regole di taratura, come quelle di Ziegler-Nichols, reagiscono male in alcune condizioni;
  • Sono intrinsecamente monovariabili, non possono quindi essere usati in sistemi inerentemente multivariabili come per esempio le colonne di distillazione.

Azioni di controllo di un PID[modifica | modifica sorgente]

Schema a blocchi di un PID

Le tre azioni di un PID vengono calcolate separatamente e semplicemente sommate algebricamente:

u = u_P + u_I + u_D

Azione proporzionale (P)[modifica | modifica sorgente]

L'azione proporzionale è ottenuta moltiplicando il segnale d'errore "e" con un'opportuna costante:

u_P = K_P\,e

È perfettamente possibile regolare un processo con un simile controllore, che risulta anche in grado di stabilizzare processi instabili. Tuttavia, non è possibile garantire che il segnale d'errore "e" converga a zero: questo perché un'azione di controllo "u" è possibile solo se "e" è diverso da zero.

Azione integrale (I)[modifica | modifica sorgente]

L'azione integrale è proporzionale all'integrale nel tempo del segnale di errore "e", moltiplicato per la costante {K_I}:

u_I = {K_I} \int e(t)\,\mathrm{d}t

Questa definizione dell'azione integrale fa sì che il controllore abbia memoria dei valori passati del segnale d'errore; in particolare, il valore dell'azione integrale non è necessariamente nullo se è nullo il segnale d'errore. Questa proprietà dà al PID la capacità di portare il processo esattamente al punto di riferimento richiesto, dove la sola azione proporzionale risulterebbe nulla. L'azione integrale è anche l'elemento metastabile di un PID, perché un ingresso costante non convergerà a un determinato valore. Il fenomeno del windup è dovuto alla presenza dell'integratore.

Azione derivativa (D)[modifica | modifica sorgente]

Per migliorare le prestazioni del controllore si può aggiungere l'azione derivativa:

u_D = K_D \frac{\mathrm{d} e}{\mathrm{d}t}

L'idea è compensare rapidamente le variazioni del segnale di errore: se vediamo che "e" sta aumentando, l'azione derivativa cerca di compensare questa deviazione in ragione della sua velocità di cambiamento, senza aspettare che l'errore diventi significativo (azione proporzionale) o che persista per un certo tempo (azione integrale). L'azione derivativa è spesso tralasciata nelle implementazioni dei PID perché li rende troppo sensibili: un PID con azione derivativa, per esempio, subirebbe una brusca variazione nel momento in cui il riferimento venisse cambiato quasi istantaneamente da un valore a un altro, risultando in una derivata di "e" tendente a infinito, o comunque molto elevata. Ciò sconsiglia l'applicazione dell'azione derivativa in tutti i casi in cui l'attuatore fisico non deve essere sottoposto a sforzi eccessivi.

Se ben tarata e se il processo è abbastanza "tollerante", comunque, l'azione derivativa può dare un contributo determinante alle prestazioni del controllore.

Approssimazione ingegneristica[modifica | modifica sorgente]

Un problema particolare causato dalla presenza dell'azione derivativa è l'impossibilità teorica di realizzare un "derivatore puro": sarebbe necessario infatti misurare il valore del segnale di errore nel futuro. Per questo si calcola invece una derivata ingegneristica, che approssima il derivatore fino ad una certa frequenza. Ciò risulta nella formula complessiva (nel dominio della frequenza):

K(s) = K \, \left(\frac{\tau_I\,s + 1}{\tau_I\,s}\right) \, \left(\frac{\tau_D\,s+1}{\alpha\,\tau_D\,s+1}\right)

dove α è un valore adimensionale piccolo, tipicamente tra 0,05 e 0,2, mentre le costanti di tempo {\tau_I} e {\tau_D} sono tali per cui:

K_I = \frac{K}{\tau_I}

K_D = {K} { \tau_D}

Regole di Ziegler-Nichols[modifica | modifica sorgente]

Il metodo di Ziegler-Nichols, risalente al 1942, è tra i più usati ed è apprezzato per la sua semplicità, per il fatto di non richiedere un modello matematico del processo e per le prestazioni che riesce a produrre.

Si tratta di un algoritmo per trovare il cosiddetto "guadagno critico", dal quale si deriveranno gli altri parametri del PID[3].

  1. Il processo viene fatto controllare da un controllore esclusivamente proporzionale (KI e KD vengono impostati a zero);
  2. Il guadagno K del controllore proporzionale viene gradualmente aumentato;
  3. Il guadagno critico Ku è il valore del guadagno per cui la variabile controllata presenta oscillazioni sostenute, cioè che non spariscono dopo un transitorio: questa è una misura dell'effetto dei ritardi e della dinamica del processo;
  4. Si registra il periodo critico Pu delle oscillazioni sostenute;
  5. Secondo la seguente tabella, si determinano le costanti per il controllore P, PI o PID.
Metodo Ziegler–Nichols
Tipo K_p K_i K_d
P 0.50{K_u} - -
PI 0.45{K_u} 1.2{K_p}/P_u -
PID 0.60{K_u} 2{K_p}/P_u {K_p}{P_u}/8

Pseudocodice[modifica | modifica sorgente]

Questa è una semplice implementazione pratica di un controllo PID, attraverso semplificazioni ingegneristiche (dato che normalmente la funzione da controllare se fosse conosciuta matematicamente non sarebbe necessario controllarla dinamicamente). Questo pseudocodice somma tre componenti per capire quanto manovrare l'output, in base all'errore calcolato volta per volta.
La parte proporzionale è direttamente proporzionale all'errore.
La parte integrativa somma nel tempo gli errori volta per volta; questo riporta nel lungo periodo la variabile di uscita sui binari corretti. Purtroppo questo non impedisce un'oscillazione una volta raggiunto il valore desiderato.
La parte derivativa limita le oscillazioni della variabile di output, rendendo le variazioni di "actual position" più dolci.
Questo pseudocodice funziona di per sé, ma c'è da valutare ogni quanto campionare e quindi eseguire questi calcoli, e soprattutto i valori delle 3 costanti K

 previous_error = 0
 integral = 0 
 start:
   error = setpoint - measured_value
   integral = integral + error*dt
   derivative = (error - previous_error)/dt
   output = Kp*error + Ki*integral + Kd*derivative
   previous_error = error
   wait(dt)
   goto start


Codice esempio per Arduino[modifica | modifica sorgente]

Questa è la struttura di base dell'algoritmo PID scritta in Wiring, linguaggio di programmazione del framework Arduino. All'algoritmo è stata aggiunta la relativizzazione del tempo, la durata del loop non è fissa, ma può variare senza agire sul comportamento dell'algoritmo. Questa viene utilizzata come variabile tempo. In questo caso l'utente non incorrerà nei problemi di base dati dalla tempistica di attuazione dell'algoritmo e delle altre istruzioni. Può essere applicata a robot odometrici, inseguitori di linea, auto bilancianti.

float P = 0; //Proporzionale
float I = 0; //Integrativa
float D = 0; //Derivativa

float kP = 12; //usati per regolazione
float kI = 430;
float kD = 20;
int error = 0;
int previousError = 0;
float time = 0;
float previousTime = time; 
float interval;
float PID;

//Main loop
      time = millis();
      interval = time - previousTime; 
      P = error * kP;
      I = I + (((error + previousError)/2) * interval);
      D = ((error - previousError) / interval)*kD;
      PID = P + (I * kI) + D;
      previousTime = time;
      previousError = error;


Codice esempio per Micro GT (PIC 16F876 oriented)[modifica | modifica sorgente]

Questo è il codice funzionante, rilasciato a scopo didattico, per il quale non è previsto l'uso su applicazioni industriali o commerciali a nome dell'autore. Chi ne volesse fare uso a questo scopo lo può fare sotto la propria responsabilità. Il sorgente dovrà essere salvato in un file con estensione .h e incluso nel proprio lavoro tramite la direttiva #include "nome.h". Il linguaggio e la sintassi è standard. L'IDE software è MPLAB X liberamente scaricabile dal sito di Microchip Tecnology.

/***********************************************
*                                              *
*   Codice scheda:                             *
*   calcola PID PIC16F877 - 16F876             *
*                                              *
*   Firmware version:1.0                       *
*   compilatore Hitech PL 9.7 or upper         *
*   autore: Marco Gottardo                     *
*   Data:25/02/2014                            *
*   MCU: PIC16F877A -16F876A                   *
*   Piattaforma hardware: Micro-GT IDE         *
*   Piattaforma software: MPLAB X 1.58         *
***********************************************/
/**************************************************************
*L'azione PID è definita come l'azione in correzione di       *
* un valore di ritorno dal campo ad un nodo sottrattivo       *
* dove tale valore è calcolato come l'integrazione del valore *
* del setpoint meno il valore in campo (detto errore) diviso  *
* una costante Ki, più la dervivazione del medesimo segnale   *
* moltiplicato per la costante Kd, il tutto sommato al        *
* segnale moltiplicato una costante proporzionale Kd.         *
***************************************************************/
                int errore(int setpoint){ //calcola la distanza attuale tra misura e setpoint
                    int err;
                    err=(setpoint - leggi_ad(0));
                    return err;
                }


                float integrale(int grandezza){
                    float calcolato;
                    int a,b,n,s,i,dx,x,ki;
                    n=20; //preset suddivisione in rettangoli del dominio
                    a=0; //metodo della media mobile, trasla lo zero sul gruppo di campionamenti successivi
                    b=100; //ampiezza intervallo estremo superiore
                    dx=abs((b-a)/n); //calcola il differenziale
                    s=0; //inizializza l'integrale a 0
                    i=0; //indice dei cicli di accumulo
                    do {
                        s=s+dx*leggi_ad(0);
                        DelayMs(5);// x=x+dx;
                        i++;
                    } while (i<=n);
                    calcolato=s;
                    calcolato= ((1/ki)*calcolato);
                    return calcolato;
                }


                int derivata(int grandezza){
                    int calcolato,calcolato_1,calcolato_2;
                    char kd;  // costante proporzionale fissa 12 a prioricalcolato_1=leggi_ad(0);
                    DelayMs(5);
                    calcolato_2=leggi_ad(0);
                    calcolato=calcolato_2-calcolato_1;
                    calcolato=kd*calcolato;
                    return calcolato;
                }
                int proporzionale(int grandezza){
                    int calcolato;
                    char kp;  // costante proporzionale fissa 12 a priori
                    calcolato=kp*grandezza;
                    return calcolato;
                }

float micro_gt_PID(int grandezza){
        float pid;
        pid = (proporzionale(grandezza)+integrale(grandezza)+derivata(grandezza));
return pid;
}


Codice esempio per implementare una classe di calcolo PID su java[modifica | modifica sorgente]

Questo è il codice in java in formato di classe da implementare come un oggetto e calcolare ogni azione del PID separatamente per poi sommarli, rilasciato a scopo didattico, non è previsto l'uso su applicazioni industriali o commerciali. Chi ne volesse fare uso a questo scopo lo può fare sotto la propria responsabilità. Autore: Christian Gobbi.


       /**
       *
       * @author Gobbi Christian
       */
       public class PID {
       public float integrale(float tf,float ti,float ef,float ei,float ki){
       //integrale contiene tutti i valori calcolati dell'intgrale
       // t0 è il tempo iniziale e t è il tempo finale
       // ei è l'errore iniziale ef è l'errore finale
       // ki è il coefficiente integrativo del pid
       float integrale=0;
       float area=((ei+ef)*(tf-ti))/2 ;
       
       integrale=area*ki;//calcoliamo l'integrale sommando il triangolo e il quadrato e molitiplicandolo per il coefficiente integrativ
        
       return integrale;
      
    }
    public float proprorzionale(float e,float kp){
        float proporzionale=kp*e;//calcoliammo la proporzionale
        return proporzionale;
    }
    public float derivativa(float tf,float ti,float ef,float ei,float kd){//derivativa da svillupare
        float ritorno;
        float sen=Math.abs(ef-ei);//seno del triangolo
        float cos=Math.abs(tf-ti);//coseno del triangolo
        ritorno=kd*sen/cos;//derivata dei due punti è uguale alla inclinazione creatasi dalla retta creata virtualmente dai due punti
        return ritorno;
    }
}

Note[modifica | modifica sorgente]

  1. ^ Massimiliano Veronesi, "Regolazione PID". FrancoAngeli, 2007
  2. ^ Karl Johan Åström, Richard M. Murray: "Feedback systems: an introduction for scientists and engineers", Princeton University Press, 2008: "More than 95% of all industrial control problems are solved by PID control, although many of these controllers are actually proportional-integral (PI) controllers because derivative action is often not included".
  3. ^ Ziegler, J.G and Nichols, N. B., Optimum settings for automatic controllers, Transactions of the ASME, vol. 64, 1942, pp. 759–768.

Bibliografia[modifica | modifica sorgente]

  • Karl Johan Åström, Tore Hägglund, PID controllers, 1995.
  • Karl Johan Åström, Tore Hägglund, Advanced PID control, 2006.
  • Bolzern, Scattolini, Schiavoni, Fondamenti di controlli automatici, Mc Graw-Hill, 2008.
  • George Stephanopoulus Chemical Process Control, an introduction to theory and practice, Prentice Hall Internationaly, 1984.
  • Marro, Controlli automatici, Zanichelli, 2004.
  • Marco Gottardo, Let's Program a PLC!!!,Seconda edizione (2.1), editore LULU,14 novembre 2012,ISBN 9781291189322
  • Seborg, Edgar, Mellichamp, Process Dynamics and Control, Wiley, 1989.
  • Massimiliano Veronesi, Regolazione PID, FrancoAngeli, 2011 (III Ediz.).

Voci correlate[modifica | modifica sorgente]

Controlli automatici Portale Controlli automatici: accedi alle voci di Wikipedia che trattano di Controlli automatici