Nozioni di base ed esercitazione sul controller PID: implementazione del PID in Arduino

Per coloro che lavorano nel campo dei controlli industriali, la teoria del controllo proporzionale-integrale-derivativo (PID) è probabilmente un concetto familiare. Per la maggior parte delle persone questo termine è del tutto sconosciuto, ma a te potrebbe essere più familiare di quanto pensi. Quando premi il pedale dell'acceleratore di un'auto, non stai solo considerando quanto sei lontano dalla tua velocità ideale, ovvero la parte proporzionale del PID, ma anche il modo in cui il tuo veicolo accelera e affronta diverse condizioni, ad esempio le salite.

Per coloro che lavorano nel campo dei controlli industriali, la teoria del controllo proporzionale-integrale-derivativo (PID) è probabilmente un concetto familiare. Per la maggior parte delle persone questo termine è del tutto sconosciuto, ma a te potrebbe essere più familiare di quanto pensi. Quando premi il pedale dell'acceleratore di un'auto, non stai solo considerando quanto sei lontano dalla tua velocità ideale, ovvero la parte proporzionale del PID, ma anche il modo in cui il tuo veicolo accelera e affronta diverse condizioni, ad esempio le salite.

Questi effetti più discreti sono ciò che i termini I e D considerano matematicamente. In questo esempio, impedirebbero alla velocità di un'auto di passare da un limite superiore a un limite inferiore e possiamo applicare lo stesso concetto a tutta una serie di situazioni di controllo. Sebbene il controllo basato sui limiti possa permetterti di ottenere dei risultati, il tuo sistema tenderà ad agire in modo imprevedibile.

Equazione PID

Il controllo PID può essere espresso matematicamente dalla seguente equazione. P, I e D sono rappresentati dai tre termini che qui si sommano. K_p, K_i e K_d sono costanti che determinano come il sistema reagisce a ciascun fattore:

Possiamo anche sostituire K_i e K_d rispettivamente con 1/T_i e T_d. Questa modifica consente all'equazione di avvicinarsi al suo significato fisico e di esprimere correttamente le unità come un numero senza unità:

Possiamo anche trasporre l'equazione per estrarre il valore K_p e applicarlo all'intera equazione, in quella che viene definita forma standard. Un vantaggio di questa forma è che possiamo regolare la costante K_p complessiva per l'intera equazione in una sola volta:

Tutto questo può sembrare un po' intimidatorio, anche per qualcuno con una laurea in ingegneria. La buona notizia è che non è necessario tirare fuori il libro di testo Modeling and Analysis of Dynamic Systems (Modellazione e analisi dei sistemi dinamici) per capire cosa sta succedendo. E anche se non fa male, non è necessario saper fare i calcoli.

Scomponendo la prima equazione, produciamo u(t), ovvero l'uscita del controller senza unità sul lato sinistro dell'equazione, aggiungendo tre elementi matematici sul lato destro del segno uguale: P, I e D. Ogni elemento è preceduto da un valore costante K (K_p, K_i e K_d), che indica il peso di ciascun elemento quando forma u(t), ovvero l'uscita del controller in un dato momento. Possiamo regolare singolarmente ciascun valore K per migliorare le prestazioni del sistema, come spiegheremo più avanti:

Proporzionale (P—K_p)

Il primo e più importante termine di questa equazione è e(t). Pertanto, il valore K_p che lo precede è generalmente maggiore degli altri valori K nell'equazione. Qui e(t) è semplicemente l'errore istantaneo in un determinato momento: il valore effettivo di un dispositivo controllato meno il valore desiderato. Moltiplicando questo valore per K_p si otterrà il suo contributo al valore totale dell'uscita del controller.

Integrale (I—K_I)

Il secondo termine di questa equazione si riferisce al valore dell'errore combinato nel tempo. È la somma di tutti gli errori riscontrati sul dispositivo:

Ogni volta che un controller calcola u(t), aggiunge l'errore istantaneo a un conteggio parziale.

Questa cifra viene quindi moltiplicata per K_i e il risultato viene aggiunto a u(t).

Consideriamo, ad esempio, una situazione in cui una forza mantiene un motore in posizione e ne impedisce il ritorno al setpoint in condizioni normali. Man mano che le specifiche vengono superate, il termine I continuerà ad aumentare, consentendo di superare questa forza o di raggiungere i limiti della capacità del motore.

Derivativo (D—K_d)

Il terzo termine in questa equazione si riferisce alla velocità con cui cambia l'errore:

In teoria, se in questa equazione fosse presente solo un termine D e il processo mantenesse costantemente il valore sbagliato, questo termine rimarrebbe zero e non contribuirebbe all'uscita corretta del controller. D'altra parte, se uno degli altri due termini tenta di riportare l'uscita del dispositivo in posizione troppo rapidamente, il derivativo può aiutare a smorzare l'effetto.

Sebbene l'espressione basata sui calcoli di questo concetto possa essere utile, la realtà del controllo PID è molto meno magica di quanto sembri a prima vista. In pratica, calcoliamo l'uscita utilizzando solo l'addizione, la sottrazione e la moltiplicazione, tenendo conto dell'errore e del tempo tra le letture. In effetti, abbiamo utilizzato sistemi pneumatici per implementare le prime forme del controllo PID, utilizzando mezzi meccanici per inserire ciascun "termine".

1. I controller effettuano una lettura istantanea dell'errore.

2. Viene sottratto il valore della lettura istantanea precedente.

3. Il risultato viene moltiplicato per K_d per calcolare il contributo a u(t).

Tutorial sul controller Arduino PID

In molte situazioni può essere conveniente collegare un controller PID dedicato per il tuo processo, ma puoi crearne uno tu stesso utilizzando un Arduino o un'altra scheda di sviluppo simile. Puoi anche scrivere una tua propria routine PID. Esprimi ogni termine nel tuo codice nel modo seguente:

• P:errore istantaneo = setpoint – ingresso;
• I:errore cumulativo = += errore * tempo trascorso;
• D:tasso di errore = (errore – errore ultimo calcolo)/tempo trascorso

Per ottenere il valore di uscita richiesto, ciascun termine viene moltiplicato per il rispettivo valore K e sommato insieme. Se invece non vuoi "reinventare la ruota", puoi semplicemente utilizzare la libreria PID di Brett Beuregard. Questa libreria si prende cura dei dettagli per te in modo che tu possa concentrarti sulla regolazione dei valori delle costanti P, I e D, secondo necessità.

Per mettere in pratica la teoria del controllo PID, ho utilizzato una scheda Arduino Nano Every insieme ai seguenti componenti:

• Scheda driver motore
• Sensore a infrarossi
• Motore recuperato da un drone Hubsan H107C

Ho stampato un supporto per breadboard da utilizzare con il motore insieme a una "ventola" che blocca la luce il 50% delle volte per evitare la perdita di impulsi quando gira. Il driver del motore funge da ingresso al motore (altrimenti non controllato) e il feedback si basa sul tempo tra gli impulsi.

Una volta elaborato il codice e ottenuto le parti stampate in 3D, sono riuscito a controllare il motore in un modo più sofisticato rispetto all'azionamento del pulsante di accensione con un'uscita PWM (modulazione di larghezza di impulso) costante.

Frammenti di codice dalla routine PID associata sopra

Parti importanti di codice includono l'uso di una routine di interruzione per registrare ogni impulso mentre il dispositivo di blocco gira e calcolando il tempo tra gli impulsi utilizzando millis(). Ho impostato il PID nella prima parte del codice al di fuori delle funzioni con:

PID myPID (&difference, &driverOut, &setPoint,Kp,Ki,Kd, DIRECT)

Kp, Ki e Kd sono definiti prima di questa riga nel codice e &difference controlla &driverOut, dove &setPoint viene modificato dal monitor seriale. Possiamo modificare questo calcolo per trasformare questa differenza di tempo in giri al minuto. Tuttavia, le impostazioni PID funzionano come uscite DIRETTE perché questo driver speciale viene attivato quando l'ingresso viene abbassato. Man mano che l'uscita analogica cresce (motori spenti), aumenta anche il ritardo tra gli impulsi.

Una versione precedente della routine PID. CH1 legge gli impulsi in ingresso, mentre CH2 è l'uscita calcolata utilizzando la routine PID: gli impulsi bassi vengono inviati al motore.

Questo semplice esempio di controller PID è stato realizzato utilizzando componenti esistenti (inclusa la nuova scheda Arduino Nano Every) e un motore che non mi era del tutto sconosciuto. Nel complesso, sono riuscito a dimostrare come il controllo PID possa essere implementato in un'ampia varietà di situazioni. Che si tratti di controllare un motore o la temperatura di un forno o di bilanciare un robot, con un minimo di configurazione e messa a punto di un controller PID avrai infinite possibilità di sperimentazione.

Ti sei già registrato?

Iscriviti per ricevere offerte speciali, novità sui prodotti e gli ultimi sviluppi del settore.