Controllo PID: differenze tra le versioni

Versione delle 04:57, 14 mar 2019

Versione attuale delle 06:44, 13 mar 2025

(45 versioni intermedie di 29 utenti non mostrate)

Riga 1:

[[File:Pneumatische regelaar.jpg|thumb|upright=1.4|Controllore pneumatico PID. In alto sono visibili i comandi di regolazione per l'azione proporzionale (P), integrale (I) e derivativa (D).]]

Il '''controllo Proporzionaleproporzionale-Integraleintegrale-Derivativoderivativo'''<ref>Massimiliano Veronesi, [http://books.google.it/books?id=OyzmAq9LTgcC&pg=PA7&dq=#v=onepage&q&f=false "Regolazione PID". FrancoAngeli, 2007]</ref> (talvoltaoppure tradotto anche con ''Proporzionaleproporzionale-Integrativointegrativo-Derivativo'', dall'inglese ''Proportional-Integral-Derivative''derivativo), comunementein abbreviato comebreve '''controllo PID''', è un sistema in [[retroazione]] negativa ampiamente impiegato nei [[Controllo automatico|sistemi di [[controllo automatico]]. È 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.<ref>[http://books.google.it/books?id=cdG9fNqTDS8C&pg=PA24&dq#v=onepage&q&f=false 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".</ref>.

== Fondamenti ==

Riga 19:

* 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, quindi non possono quindi essere usati in sistemi inerentemente multivariabili, come per esempio le [[Colonna di distillazione|colonne di distillazione]].

== Azioni di controllo di un PID ==

[[File:Pid-feedback-nct-int-correct.png|thumb|Schema a blocchi di un PID]]

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

:<math>u(t) = u_P(t) + u_I(t) + u_D(t)</math>

=== Azione proporzionale (P) ===

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

:<math>u_P (t) = K_P\,e(t)</math>

È perfettamente possibile regolare un processo con un simile controllore, che, in alcuni casi semplici, 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) ===

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

:<math>u_I(t) = {K_I} \int\limits_{0}^{t} e(t\tau)\,\mathrm{d}t\tau</math>

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 [[metastabilità|metastabile]] di un PID, perché un ingresso costante non convergerà a un determinato valore. Il fenomeno del [[windup]] è dovuto alla presenza dell'integratore.

Riga 40:

=== Azione derivativa (D) ===

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

:<math>u_D(t) = K_D \frac{\mathrm{d} e (t)}{\mathrm{d}t}</math>

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.

Riga 52:

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

:<math>K_I = \frac{K}{\tau_I}</math>

:<math>K_D = {K} { \tau_D}</math>

==Regole di Ziegler-Nichols==

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<ref>{{Cita pubblicazione|titolo=Optimum settings for automatic controllers|autore=Ziegler, J.G and Nichols, N. B.|anno=1942|serie=Transactions of the ASME|volume=64|pp=759–768759-768|url=http://www2.eie.ucr.ac.cr/~valfaro/docs/Ziegler%26Nichols.pdf|urlmorto=sì|accesso=9 aprile 2013|urlarchivio=https://web.archive.org/web/20130202172939/http://www2.eie.ucr.ac.cr/~valfaro/docs/Ziegler%26Nichols.pdf|dataarchivio=2 febbraio 2013}}</ref>.

# Il processo viene fatto controllare da un controllore esclusivamente proporzionale (''K_I'' e ''K_D'' vengono impostati a zero);

Riga 72:

! Tipo

! <math>K_p</math>

! <math>K_i\tau_i</math>

! <math>K_d\tau_d</math>

|- style="text-align:center;"

! ''P''

Riga 82:

! ''PI''

| <math>0{,}45{K_u}</math>

| <math>P_u/1{,}2{K_p}/P_u</math>

| -

|- style="text-align:center;"

! ''PID''

| <math>0{,}60{K_u}</math>

| <math>2{K_p}/P_u/2</math>

| <math>{K_p}{P_u}/8</math>

|}

== PID in forma digitale ==

La [[funzione di trasferimento]] di un regolatore PID digitale si ottiene partendo da quella di un PID tempo continuo ed applicando la procedura di discretizzazione. È però necessario tenere conto della presenza del mantenitore di ordine zero<ref>{{Cita web|url=http://cse.lab.imtlucca.it/~bemporad/teaching/controllodigitale/pdf/10b-sistemi_dati_campionati.pdf|titolo=IMT Lucca - Controllo Digitale - A. Bemporad}}</ref>. Per esempio nella tecnica empirica di Ziegler Nichols a catena aperta, quando si leggono i valori dei parametri dalla tabella, è necessario aggiungere il ritardo finito del mantenitore di ordine zero. La forma digitale del controllo PID presenta il grande vantaggio di poter essere facilmente implementata sotto forma di algoritmo eseguito da un dispositivo microcontrollore<ref>{{Cita web|url=https://manipolando.it/modulazione-di-larghezza-dimpulso-e-sistemi-di-controllo/|titolo=Modulazione a larghezza d’impulso e controllo della velocità}}</ref> e trova larga applicazione in diversi ambiti.

== Pseudocodice ==

Questa è una semplice implementazione pratica di un controllo PID, attraverso semplificazioni ingegneristiche (dato che normalmente, se 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. <br>

La parte proporzionale è direttamente proporzionale all'errore. <br>

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. <br>

La parte derivativa limita le oscillazioni della variabile di output, rendendo le variazioni di "actual position" più dolci.<br>

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. Inoltre non è presente una funzione anti-windup.

<syntaxhighlight lang="text">

<pre>

previous_error = 0

integral = 0

Riga 109 ⟶ 112:

wait(dt)

goto start

</syntaxhighlight>

</pre>

<pre>

</pre>

== Codice esempio per Micro GT (PIC 16F876 oriented) ==

{{C|Non funziona la parte di derivata|ingegneria|febbraio 2015}}

Questo è il codice funzionante, presentato 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 Technology.

<pre>

/***********************************************

* *

* 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 derivazione 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 priori

calcolato_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;

}

</pre>

}

== Note ==

Riga 200 ⟶ 122:

* 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 InternationalyInternational, 1984.

* Marro, ''Controlli automatici'', Zanichelli, 2004.<!-- The link to Note nr. 3 is not working -->

*Marco Gottardo, Let's Program a PLC!!!, edizione 2016, editore LULU,28 luglio 2015, terza edizione, ISBN 9781326143312

* Seborg, Edgar, Mellichamp, ''Process Dynamics and Control'', Wiley, 1989.

* Massimiliano Veronesi, ''Regolazione PID'', FrancoAngeli, 2011 (III Ediz.).

Riga 219 ⟶ 141:

{{interprogetto}}

{{Controllo di autorità}}

{{Portale|Controllicontrolli automatici}}

[[Categoria:Teoria del controllo]]