POLITECNICO DI MILANO
Facoltà di Ingegneria dell’informazione Corso di laurea in Ingegneria Elettronica
ESPERIENZE DIDATTICHE DI CONTROLLO AVANZATO
DEL PENDOLO DI FURUTA TRAMITE EASY JAVA SIMULATIONS
Relatore Prof. Alberto LEVA
Tesi di laurea di Nicholas COMOTTI
Matr. 681625
Anno Accademico 2006/2007
Dedicata alla mia famiglia
Fiorenzo, Francesca e Luisa
Indice
I
1. INTRODUZIONE............................................................................................................................................... 1
2. IL MODELLO DEL PENDOLO DI FURUTA ........................................................................................................... 5
1. PREMESSE ................................................................................................................................................................ 5 2. CINEMATICA DEL PENDOLO .......................................................................................................................................... 6 3. ENERGIA DEL PENDOLO ............................................................................................................................................... 8 4. EQUAZIONI DEL MOTO .............................................................................................................................................. 10 5. MODELLO IN VARIABILI DI STATO ................................................................................................................................ 12 6. PUNTI DI EQUILIBRIO ................................................................................................................................................ 13 7. SISTEMA LINEARIZZATO ............................................................................................................................................. 14 8. AUTOVALORI DEL SISTEMA LINEARIZZATO E STABILITÀ DEGLI EQUILIBRI ............................................................................... 17 9. CALCOLO DELLA FUNZIONE DI TRASFERIMENTO .............................................................................................................. 22 10. SISTEMA APPROSSIMATO .......................................................................................................................................... 23 11. SIMULATORE MATLAB ............................................................................................................................................ 25
3. IL CONTROLLO DEL PENDOLO DI FURUTA ...................................................................................................... 27
1. PREMESSE .............................................................................................................................................................. 27 2. SINTESI DEL CONTROLLO BASATO SU PID ...................................................................................................................... 29 3. SINTESI DEL CONTROLLORE LQR ................................................................................................................................. 43 4. SWINGING UP CON CONTROLLO DELL’ENERGIA (EC) ....................................................................................................... 51 5. CONTROLLO DEL PENDOLO CON STRATEGIA EC‐LQR ...................................................................................................... 61 6. CONTROLLO VIRTUAL GRAVITY (VG) ........................................................................................................................... 63 7. CONTROLLO VIRTUAL SPRING (VS) ............................................................................................................................. 69
4. LE ESPERIENZE DI CONTROLLO SIMULATE ...................................................................................................... 81
1. INTRODUZIONE A EASY JAVA SIMULATIONS ................................................................................................................... 81 2. IL SIMULATORE DEL PENDOLO DI FURUTA ..................................................................................................................... 82 3. ESPERIENZE CON CONTROLLO EC‐LQR ........................................................................................................................ 86 4. ESPERIENZE CON CONTROLLO VIRTUAL GRAVITY ............................................................................................................ 90 5. ESPERIENZE CON CONTROLLO VIRTUAL SPRING .............................................................................................................. 92
5. CONCLUSIONI ............................................................................................................................................... 95
6. BIBLIOGRAFIA ............................................................................................................................................. 101
7. INDICE DELLE FIGURE .................................................................................................................................. 103
Politecnico di Milano
II
Introduzione
1
1. Introduzione Questa tesi tratta della realizzazione di esperienze di controllo relative al pendolo di Furuta e
implementate con l'ambiente Easy Java Simulations.
Le esperienza di cui sopra sono state concepite a scopo essenzialmente didattico; tuttavia,
l'implementazione in un ambiente altamente interattivo di metodi di controllo avanzati può
rivestire un certo interesse anche dal punto di vista della ricerca.
Il pendolo di Furuta è un oggetto di largo uso per la sperimentazione di metodologie di controllo.
Esso infatti presenta delle caratteristiche dinamiche relativamente semplici da comprendere (dal
che il suo vasto uso anche in ambito didattico) ma tutt'altro che banali da regolare (dal che la sua
presenza come “test bed” anche in molti lavori di ricerca).
Easy Java Simulations (Ejs) è un ambiente interattivo per la simulazione di sistemi, di concezione
recente e sempre più diffuso per applicazioni didattiche e/o dimostrative. Oltre a ciò, Ejs sta oggi
integrandosi con ambienti meno concepiti per l'interattività ma più per applicazioni avanzate di
modellistica, simulazione e controllo (quali Matlab, Scilab e traduttori Modelica). Riferimenti in
proposito sono ad esempio [24]. Da ultimo, Ejs è free software distribuito nei termini della licenza
GNU GPL, il che risolve a priori qualsiasi problema relativo alla disseminazione dei risultati
ottenuti.
Tutto ciò premesso, in questa tesi s'implementano e si analizzano algoritmi di controllo sia
“classici” che “avanzati” per il pendolo di Furuta, ottenendone poi tramite Ejs dei programmi di
simulazione interattiva fruibili sia in modalità stand‐alone che tramite il web, nella forma di applet
Java. In dettaglio, gli algoritmi considerati sono:
Politecnico di Milano
2
• PID: classico controllo che agisce sul segnale errore, sulla sua derivata e sul suo valore
integrale soppesando i singoli contributi con tre guadagni scelti in fase di progettazione;
• LQR: algoritmo di controllo che ottimizza una indice quadratico funzione dello stato e del
segnale di controllo stesso, tramite la tecnica della retroazione di stato;
• Speed Gradient: strategia di controllo avanzata per l’ottimizzazione del gradiente di un
indice di costo funzione dello stato del sistema;
• Virtual Gravity : metodo di regolazione che simula il funzionamento del processo in un
ambiente “a gravità invertita” tramite la sintesi di un opportuno segnale di controllo;
• Virtual Spring : tecnica di controllo innovativa per la sintesi di un segnale di controllo atto a
simulare il funzionamento del processo sottoposto a dei “vincoli virtuali”, quale appunto
un sistema molla – smorzatore, il cui effetto è portare il sistema medesimo nella posizione
desiderata come risultato del controllo.
La tesi è organizzata come segue:
Il capitolo 1 è dedicato allo studio del pendolo di Furuta. In questa sezione si ricavano le
equazioni dinamiche che regolano il moto del pendolo di Furuta, si studiano i punti di
equilibrio del modello (non lineare) ottenuto e si caratterizza il processo, attorno a tali
punti di equilibrio, con le funzioni di trasferimento degli opportuni sistemi linearizzati.
Successivamente si cerca di ridurre la complessità del modello non lineare, approssimando
il pendolo di Furuta con un pendolo semplice. L’ultima parte del capitolo è dedicata
all’implementazione dei modelli ricavati in ambiente Matlab/Simulink.
Il capitolo 2 è dedicato alla sintesi dei sistemi di controllo per il pendolo di Furuta. Si
analizzano inizialmente due tecniche classiche (PID e LQR) per stabilizzare il sistema,
passando poi alla sintesi di un controllore avanzato per la generazione di oscillazioni
controllate tramite la tecnica “speed gradient”. I tre sistemi di controllo così ottenuti sono
poi implementati in ambiente Matlab/Simulink per effettuarne un'analisi comparativa ed
evidenziarne pregi e difetti. Successivamente si realizzano due sistemi di controllo avanzati,
il primo basato sul concetto di “gravità virtuale” e il secondo su quello di “vincolo virtuale”.
Anche in quest’ultimo caso, le due tecniche di controllo sono poi implementate in
ambiente Matlab/Simulink e analizzate in dettaglio.
Introduzione
3
Il capitolo 3 è dedicato alla realizzazione, in ambiente Ejs, di simulatori del pendolo di
Furuta e dei sistemi di controllo sintetizzati. Al termine del lavoro si hanno quindi a
disposizione dei programmi di simulazione completamente indipendenti che possono
essere usati sia a scopo didattico, per spiegare in modo semplice la dinamica del pendolo di
Furuta e le possibili soluzioni per il suo controllo, sia a scopo di ricerca, per effettuare delle
analisi comparative sui sistemi i controllo considerati. E' ovviamente possibile estendere i
risultati ottenuti includendovi altre tecnche di controllo. Il software realizzato è disponibile
nei termini della licenza GNU GPL ed è scaricabile dalla sezione “progetti” del sito web del
relatore (http://home.dei.polimi.it/leva).
Politecnico di Milano
4
Il modello del Pendolo di Furuta
5
2. Il modello del pendolo di Furuta 1. Premesse
Figura 1 : Modello del pendolo di Furuta
Il pendolo di Furuta è mostrato in figura 1.
Il sistema è composto da due corpi rigidi connessi tra di loro:
un pilastro centrale, con momento di inerzia J, rigidamente connesso ad un braccio
orizzontale di lunghezza La, di massa (linearmente distribuita) Ma
e un pendolo di lunghezza Lp, di massa (linearmente distribuita) Mp.
Il pendolo è poi connesso ad un corpo di bilanciamento con massa (ritenuta puntiforme) M.
I parametri del sistema sono quindi, con riferimento alla figura 1, i seguenti:
Mp [Kg] Lp [m] Ma [Kg] La [m] M [Kg] J [Kgm^2] 0.00775 0.4125 0.072 0.250 0.02025 0.0000972
Politecnico di Milano
6
2. Cinematica del pendolo Anzitutto una breve premessa terminologica. Dato l’uso (anche in letteratura) del termine
“pendolo” per riferirsi sia al pendolo di Furuta nel suo complesso che alla parte di esso compresa
tra il braccio e la massa (l’elemento di lunghezza Lp in figura 1), qui si dirà, a costo di qualche
ridondanza ma con l’effetto di evitare confusioni, “pendolo di Furuta” per riferirsi al tutto e
“pendolo” tout court per riferirsi alla parte.
La posizione di un generico elemento infinitesimo del pendolo di Furuta, assimilato nel seguito per
comodità ad un punto generico detto P, può essere descritta da un vettore posizione
TRpRaRzRpRaRyRpRaRxRpRaR )],(),,(),,([),( = (1)
Dove
ϑϑφφϑφφ
cos),(sincossin),(sinsincos),(
RpRpRaRzRpRaRpRaRyRpRaRpRaRx
=+=−=
(2)
La variabile Ra rappresenta la distanza dall’origine dell’elemento di pendolo di Furuta assimilato al
punto P quando tale elemento appartiene al braccio, mentre la variabile Rp ha lo stesso significato
quando l’elemento (ossia il punto P) appartiene al pendolo. La distanza è misurata dal centro di
rotazione per entrambi i corpi.
Derivando la (1) rispetto al tempo si ricava l’espressione del vettore velocità
TRpRaVzRpRaVyRpRaVxRpRaV )],(),,(),,([),( = (3)
Dove
ϑϑ
φφϑϑφϑφφ
φφϑϑφϑφφ
&
&&&
&&&
sin),(sinsincoscoscos),(
cossinsincoscos),(
RpRpRaVzRpRpRaRpRaVy
RpRpRaRpRaVx
−=
−+=
−−−=
(4)
Il modello del Pendolo di Furuta
7
Infine è possibile calcolare il modulo del vettore velocità nel punto P
2222222 cos2)sin(),( ϑϑφϑφϑ &&&& RpRaRpRpRaRpRaV +++= (5)
Politecnico di Milano
8
3. Energia del pendolo In questa sezione verranno calcolate le espressioni dell’energia cinetica e potenziale del sistema in
studio.
L’energia cinetica di un corpo è definita come
dmVT ∫= 2
21
(6)
Mentre l’energia potenziale può essere calcolata tramite la seguente relazione
∫= RzdmgV (7)
Per semplicità, al posto di utilizzare le espressioni riportate sul sistema totale, si procederà in
modo additivo e si calcoleranno le due energie separatamente per ogni corpo.
• Pilastro centrale
02 2
==
VcJTc φ& (8)
• Braccio orizzontale
031)0,(2
0
222
=
== ∫Va
MaLadsLaMasVTa
La
φ& (9)
Il modello del Pendolo di Furuta
9
• Pendolo
∫
∫
==
+++==
Lp
Lp
gMpLpdsLpMpsLaRzgVp
MpLpMpLaLpLpLaMpdsLpMpsRaVTp
0
0
2222222
cos21),(
31cos)sin
31(),(2
ϑ
ϑϑφϑφϑ &&&&
(10)
• Massa di bilanciamento
ϑϑϑφϑφϑ
coscos2)sin(2 222222
gMLpVmMLpMLaLpLpLaMTm
=+++= &&&&
(11)
Una volta calcolate tutte le energie necessarie è possibile ricavare l’energia cinetica totale
TmTpTaTcT +++= (12)
e l’energia potenziale totale
VmVpVaVcV +++= (13)
Politecnico di Milano
10
4. Equazioni del moto La funzione Lagrangiana [1,2] può essere costruita come combinazione lineare dell’energia cinetica
e potenziale
VTL −= (14)
Questa funzione soddisfa il seguente sistema di equazioni differenziali
ξϑϑ
τφφ
=∂∂
−⎟⎠⎞
⎜⎝⎛∂∂
=∂∂
−⎟⎟⎠
⎞⎜⎜⎝
⎛∂∂
LLdtd
LLdtd
&
& (15)
Dove τ e ζ sono forzanti esterne applicate rispettivamente alla giuntura del braccio orizzontale e
alla giuntura del pendolo.
Le derivate parziali contenute nel sistema (15) hanno la seguente forma
ϑφϑϑ
ϑϑφϑφϑϑϑ
ϑϑφϑφ
φ
&&&
&&&
&&&
2
22
222
)31(cos)
21(
sin)21(sin)
21(sincos)
31(
cos)21(]sin)
31()
31([
0
LpMpMLaLpMpML
gLpMpMLaLpMpMLpMpML
LaLpMpMLpMpMLaMpMaMJL
L
+++=∂∂
+++−+=∂∂
+++++++=∂∂
=∂∂
(16)
Sostituendo la (16) nella (15) e introducendo quattro costanti geometriche
gLpMpM
LpMpM
LaLpMpM
LaMpMaMJ
)21(
)31(
)21(
)31( 22
+=
+=
+=
+++=
δ
β
χ
α
(17)
si ricavano le equazioni del moto del pendolo di Furuta [3,4]
Il modello del Pendolo di Furuta
11
ξϑδφϑϑβϑβφϑχ
τϑϑχϑφϑϑβϑϑχφϑβα
=−−+
=−+++
sinsincoscossinsincos2cos)sin(
2
22
&&&&&
&&&&&&&
(18)
E’ possibile inoltre considerare l’attrito presenti nei due giunti come un termine dissipativo
proporzionale alla velocità angolare che si sottrae alle forzanti applicate
⎥⎦
⎤⎢⎣
⎡
−−
=⎥⎦
⎤⎢⎣
⎡−−
=⎥⎦
⎤⎢⎣
⎡ϑξφτ
ξξττ
ξτ
ϑ
φ
ϑ
φ
&
&
fe
a
a (19)
Tali equazioni possono anche essere espresse in forma matriciale
⎥⎦
⎤⎢⎣
⎡=+⎥
⎦
⎤⎢⎣
⎡+⎥
⎦
⎤⎢⎣
⎡
ϑ
φ
ξτ
ϑφϑφ
ϑφϑφϑφ
ϑφ ),(),,,(),( gCD&
&&&
&&
&&
(20)
definendo la matrice d’inerzia
⎥⎦
⎤⎢⎣
⎡ +=
βϑχϑχϑβα
ϑφcos
cos)sin(),(
2
D (21)
la matrice dei momenti centripeti e di Coriolis
⎥⎦
⎤⎢⎣
⎡
−−+
=f
eC
φϑϑβϑϑχφϑϑβϑϑϑβ
ϑφϑφ&
&&&&&
sincossinsincossincos
),,,( (22)
e la matrice dei momenti gravitazionali
⎥⎦
⎤⎢⎣
⎡−
=ϑδ
φϑsin0
),(g (23)
Politecnico di Milano
12
5. Modello in variabili di stato Studiando il sistema di equazioni appena ricavato è possibile vedere che il pendolo di Furuta è
caratterizzato da quattro variabili di stato, la posizione angolare θ del pendolo, quella del braccio
φ e le relative velocità angolari.
Ridefinendo queste grandezze in termini di Xi
φ
φϑ
ϑ
&
&
=
==
=
4
3
2
1
X
XX
X
(24)
e chiamando le forzanti
ξτ
==
2
1
UU
(25)
È possibile riscrivere il sistema (18) in modo integrale
]coscossincos
sinsincos2sin)1(sin[sin)(
1
]sincos
)sin(cossin)sin(sincos
sin)sin1(2sincos)sin([sin)(
1
21421111
2214211
22411
2
122224
43
212
241
212
111122
2112
421122
41112
122222
21
XXfeXUXUXX
XXXXXXXXXX
X
XX
XXffXXXe
UXUXXXXXX
XXXXXXXXX
X
XX
χβχβχδ
βχββχχβχαβ
βαχ
βαχβαδχ
βχβαβχβχαβ
+−−+−
++−−++−
=
=
−−+
+++−++−
+−++++−
=
=
&
&
&
&
(26)
Il modello del Pendolo di Furuta
13
6. Punti di equilibrio I generici punti di equilibrio di un qualsiasi sistema possono essere calcolati annullando le derivate
delle variabili di stato e risolvendo il sistema.
Nel caso in esame annullando velocità e accelerazione dei moti angolari, in presenza di forzanti e
attriti nulli, si ricavano i seguenti punti di equilibrio:
0
0
4
3
2
1
=ℜ∈=
=Ζ∈=
XNconNX
XKconKX π
(27)
Ovvero il sistema in condizioni statiche avrà velocità angolari nulle in entrambi i giunti, l’angolo di
rotazione del braccio potrà assumere ogni valore e l’angolo del pendolo potrà essere 0° oppure
180°.
Politecnico di Milano
14
7. Sistema linearizzato Definito il vettore delle variabili di stato X e degl’ingressi U
⎥⎦
⎤⎢⎣
⎡=
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡
=
2
1
4
3
2
1
UU
U
XXXX
X (28)
E riscritto il sistema dinamico in forma normale ),(/ UXfdtdX =
Il sistema può essere linearizzato nell’intorno del punto di equilibrio di interesse
⎥⎦
⎤⎢⎣
⎡=
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡
=
00
0000
U
X (29)
La linearizzazione consiste nell’introdurre le variazioni δu(t), δx(t), ponendo
)()( tuutu δ+= )()( tuxtx δ+= (30)
Supponendo la funzione f(x(t),u(t)), che definisce il sistema non lineare sufficientemente regolare,
le matrici A, B, si ottengono ponendo:
uuxxx
uxfA==∂
∂=
),(
uuxxu
uxfB==∂
∂=
),( (31)
Il modello del Pendolo di Furuta
15
É quindi possibile scrivere il sistema come
UBXAX δδδ +=& (32)
Dove le matrici A e B, calcolate attraverso la formula di linearizzazione, hanno la seguente forma
⎥⎥⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢⎢⎢
⎣
⎡
−−
−
−
−−
=
⎥⎥⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢⎢⎢
⎣
⎡
−−
−−−
−−−
−=
2
2
2
2
222
222
0
0
0
0
01000
00010
χαβχ
χαβα
χαββ
χαβχ
χαββ
χαβχ
χαβχδ
χαβχ
χαβα
χαβαδ
B
ef
ef
A
(33)
Semplificando ulteriormente il modello è possibile porre uguale a zero la forzante applicata sul
giunto del pendolo (di fatto il sistema comunemente usato nelle applicazioni in letteratura è in
tale condizione, ovvero è sotto attuato).
In questo modo elaborando la (32) è possibile scrivere il sistema linearizzato del pendolo di Furuta
124222124
43
124222122
21
UXeXfXX
XX
UXeXfXX
XX
χαββ
χαββ
χαβχ
χαβχδ
χαβχ
χαβχ
χαβα
χαβαδ
−+
−−
−+
−−=
=
−−
−+
−−
−=
=
&
&
&
&
(34)
La stessa cosa può essere fatta nel secondo punto di equilibrio, ovvero quando l’angolo di
rotazione del pendolo assume il valore di 180°.
Seguendo lo stesso procedimento precedentemente esposto, una volta definiti i vettori
Politecnico di Milano
16
⎥⎦
⎤⎢⎣
⎡=
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡
=
00
000
U
X
π
(35)
Si ricavano le seguenti matrici
⎥⎥⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢⎢⎢
⎣
⎡
−
−
−
−=
⎥⎥⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢⎢⎢
⎣
⎡
−−
−−
−−
−−
−−
−−
=
2
2
2
2
222
222
0
0
0
0
01000
00010
χαβχ
χαβα
χαββ
χαβχ
χαββ
χαβχ
χαβχδ
χαβχ
χαβα
χαβαδ
B
ef
ef
A
(36)
Che permettono di ottenere, una volta annullata la forzante sul giunto del pendolo (ovvero ancora
considerando il sistema sotto attuato), il seguente sistema linearizzato
124222124
43
124222122
21
UXeXfXX
XX
UXeXfXX
XX
χαββ
χαββ
χαβχ
χαβχδ
χαβχ
χαβχ
χαβα
χαβαδ
−+
−−
−−
−−=
=
−+
−−
−−
−−=
=
&
&
&
&
(37)
Il modello del Pendolo di Furuta
17
8. Autovalori del sistema linearizzato e stabilità degli equilibri Per caratterizzare i punti di equilibrio ricavati si procederà in due fasi, nella prima si trascureranno
le componenti di attrito ( )0( == fe ) e si ricaveranno analiticamente gli autovalori della matrice
caratteristica. Successivamente si simulerà la risposta libera del sistema in ambiente Matlab e si
tracceranno gli andamenti delle variabili di stato; qui si potranno verificare le considerazioni fatte
analiticamente e si potrà verificare il contributo della componente d’attrito.
Il sistema caratterizzato dalle matrici (33), ponendo )0( == fe può essere riscritto come
⎥⎥⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢⎢⎢
⎣
⎡
−−
−
−
−−
=
⎥⎥⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢⎢⎢
⎣
⎡
−−
−=
2
2
2
2
2
2
0
0
0
0
0001000
0000010
χαβχ
χαβα
χαββ
χαβχ
χαβχδ
χαβαδ
B
A
Risolvendo il polinomio caratteristico )0( =− IA λ si ricavano i seguenti autovalori:
⎭⎬⎫
⎩⎨⎧
−−
−+ 22 ,,0,0
χαβαδ
χαβαδ
(38)
Come si può constatare uno di essi ha parte reale maggiore di zero, conseguentemente il sistema
linearizzato risulta instabile. Essendo instabile il sistema linearizzato, tramite il metodo indiretto di
Liapunov, è possibile affermare che il punto di equilibrio del sistema non lineare è instabile.
Politecnico di Milano
18
Il sistema caratterizzato dalle matrici (36) con attrito nullo )0( == fe
⎥⎥⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢⎢⎢
⎣
⎡
−−
−
−
−=
⎥⎥⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢⎢⎢
⎣
⎡
−−
−−
=
2
2
2
2
2
2
0
0
0
0
0001000
0000010
χαβχ
χαβα
χαββ
χαβχ
χαβχδ
χαβαδ
B
A
ammette, invece, come autovalori della matrice A i valori
⎭⎬⎫
⎩⎨⎧
−−
−+ 22 ,,0,0
χαβαδ
χαβαδ ii (39)
In questo caso gli autovalori che nel sistema (33) portavano all’instabilità, si sono tramutati in
valori immaginari. Essendo autovalori posti sull’asse immaginario originano delle orbite
periodiche. Tali orbite, stabili per il sistema linearizzato, non permettono di caratterizzare il
sistema non lineare in quanto il metodo indiretto di Liapunov nulla dice a riguardo. Rifacendoci
alla fisica del problema però ci si può attendere che tale punto di equilibrio risulti sicuramente
stabile in quanto punto a minima energia per il sistema. L’andamento puramente oscillatorio non
deve spaventare in quanto generato solamente dall’assenza dell’attrito. Durante la simulazione
Matlab ci si dovranno quindi aspettare degli autovalori a parte reale sicuramente negativa e quindi
si potrà affermare con sicurezza che questo stato di equilibrio è asintoticamente stabile.
Utilizzando Matlab è possibile introdurre le matrici dinamiche del sistema e, una volta inizializzate
con le costanti opportune e scelte le condizioni iniziali, simulare la risposta libera del sistema e
verificare quanto affermato precedentemente.
Il seguente sorgente definisce le matrici caratteristiche del sistema (33) e (36) e esegue la
simulazione della risposta libera quando il sistema risulta in stato di quiete con l’angolo di
rotazione del pendolo pari a 0.1rad.
Il modello del Pendolo di Furuta
19
Figura 2 : Script matlab per il calcolo degli autovalori e della risposta libera
Politecnico di Milano
20
Il risultato di tale operazione viene riportato di seguito:
Figura 3 : Risposta libera con attrito
Come volevasi dimostrare il sistema ammette quattro autovalori (Do e Dp) di cui quelli associati al
punto di equilibrio instabile con parte reale maggiore di zero e quelli associati al punto di
equilibrio stabile con parte reale negativa.
Il grafico riporta l’andamento delle quattro variabili di stato; risulta di facile interpretazione il
significato del termine instabilità, in quanto nel primo grafico, quello associato all’equilibrio (0°),
tutte le grandezze tendono a divergere mentre nel secondo (equilibrio 180°) tutte le variabili di
stato tendono asintoticamente a zero.
Rieseguendo la simulazione annullando i termini di attrito si ricava proprio quello esposto
precedentemente, ovvero gli andamenti delle variabili di stato sono oscillatori; questo
Il modello del Pendolo di Furuta
21
esperimento verifica quanto esposto ovvero che gli autovalori puramente immaginari sono
originati solo dall’assenza dell’attrito e non da un instabilità del punto di equilibrio 180° nel
sistema non lineare.
Figura 4 : Risposta libera senza attrito
Politecnico di Milano
22
9. Calcolo della funzione di trasferimento Consideriamo il sistema dinamico completo delle componenti d’attrito:
(40)
Linearizzando le equazione nel punto di equilibrio superiore
)0,0,0,0(),,,( =φφϑϑ &&
E annullando la forzante sul giunto del pendolo, si ricava il seguente modello lineare:
0=+−+
=++
ϑδϑϑβφχ
τϕϑχφα&&&&&
&&&&&
fe
Esplicitando dalla seconda equazione l’accelerazione angolare del braccio e trasformandola
secondo Laplace si ottiene:
χϑβϑδϑφ 2
2
ssfs −−
=
Sostituendo questo termine nella prima equazione è possibile ricavare la funzione di
trasferimento:
δαδβααβχχ
τϑ
eefsefsss
+−+−−+−=
)()()( 223 (41)
Tale funzione di trasferimento è caratterizzata da uno zero nell’origine e da tre poli.
ϑξϑδφϑϑβϑβφϑχ
ϕτϑϑχϑφϑϑβϑϑχφϑβα&&&&&&
&&&&&&&&
f
e
−=−−+
−=−+++
sinsincoscos
sinsincos2cos)sin(2
22
Il modello del Pendolo di Furuta
23
10. Sistema approssimato Il modello del pendolo di Furuta, che, per chiarezza di esposizione viene riportato di seguito,
⎥⎦
⎤⎢⎣
⎡=+⎥
⎦
⎤⎢⎣
⎡+⎥
⎦
⎤⎢⎣
⎡
ϑ
φ
ξτ
ϑφϑφ
ϑφϑφϑφ
ϑφ ),(),,,(),( gCD&
&&&
&&
&&
⎥⎦
⎤⎢⎣
⎡ +=
βϑχϑχϑβα
ϑφcos
cos)sin(),(
2
D
⎥⎦
⎤⎢⎣
⎡
−−+
=f
eC
φϑϑβϑϑχφϑϑβϑϑϑβ
ϑφϑφ&
&&&&&
sincossinsincossincos
),,,(
⎥⎦
⎤⎢⎣
⎡−
=ϑδ
φϑsin0
),(g
può essere approssimato ad un sistema del secondo ordine sotto alcune ipotesi realizzative.
Se si ipotizza che le velocità angolari ϑφ &&, sono abbastanza piccole, i valori quadratici 22 ,ϑφ && e
i prodotti misti ϑφ &&* posso essere trascurati ed è possibile porre uguale a zero i termini relativi
ai momenti centripeti e di Coriolis ( 0),,,( =ϑφϑφ &&C ).
Inoltre, se pMM >> , le costanti presenti nel modello possono essere semplificate
MgLpMLaLpMLpLaMaMJ ===++= δχβα 22)31(
Con questa scelta e imponendo pa LL >> il primo termine della matrice d’inerzia diventa
effJLaMaMJ
MLpLaMaMJMLpLaMaMJ
=++≈
+++≤+++=+
2
222222
)31(
)31(sin)
31()sin( ϑϑβα
Riscrivendo il sistema dinamico con le ipotesi semplificative esposte:
0sincos
cos2 =−+
=+
ϑϑφϑ
τϑϑφ
pppa
paeff
MgLMLLML
LMLJ&&&&
&&&&
Politecnico di Milano
24
E definendo φ&&aLa = , accelerazione del braccio,
a
effeff
eff
aeff
eff
a
eff
apaa
LJ
se
JL
JL
JLLML
La
),(
),()cos(
ϑϑττ
τϑϑττϑϑτφ
&
&&&
&&
>>
≈−=−
==
Si giunge al modello semplificato:
0sincos 2 =−+ ϑϑϑ ppp MgLMLaML && (42)
Tale modello rappresenta un semplice pendolo piano, privo di attrito e alimentato da un segnale
di accelerazione proporzionale alla coppia generata. Studiandone i punti di equilibrio si ricavano
ancora le stesse conclusioni fatte precedentemente. Tale approssimazione può essere utilizzata
come modello base per la sintesi dei regolatori per poi verificare il loro funzionamento sul modello
completo. Già da ora si può notare che tra tutte le ipotesi fatte quella più restrittiva riguarda la
condizione sull’accelerazione proporzionale alla coppia di controllo. In tale approssimazione si è
trascurato del tutto sia la dinamica del braccio che l’influenza dell’angolo del pendolo
sull’accelerazione stessa ( 0),( =ϑϑτ &eff ).
Il modello del Pendolo di Furuta
25
11. Simulatore MATLAB
I sistemi dinamici (18) e (42) sono stati implementati in ambiente Matlab/Simulink cosi da poter
testare e paragonare in maniera semplice i controllori sintetizzati. Di seguito vengono riportati gli
schemi Simulink: essi contengono dei blocchi “Fcn” con cui sono state implementate le equazioni
non lineari che caratterizzano i modelli e degli integratori per ottenere il vettore di stato.
Figura 5 : Simulatore matlab del pendolo di Furuta
Figura 6 : Simulatore matlab del pendolo approssimato
Politecnico di Milano
26
Tali modelli per essere utilizzati devono essere inizializzati, di seguito vengono riportati i sorgenti
Matlab di inizializzazione.
Figura 7 : Script matlab per l’inizializzazione del pendolo di Furuta
Figura 8 : Script matlab per l’inizializzazione del
pendolo approssimato
Il controllo del Pendolo di Furuta
27
3. Il controllo del Pendolo di Furuta 1. Premesse Il pendolo di Furuta, come risulta evidente dal modello ricavato, presenta (a meno dell'angolo del
braccio, che può assumere all'equilibrio qualsiasi valore) due punti di equilibrio, uno stabile e
l’altro instabile.
Scopo di questa sezione sarà quello di controllare il sistema e di stabilizzare la seconda condizione
stazionaria, ovvero quella col pendolo “in alto” )0( ==== ϑϑϕϕ && .
Studiando il punto di equilibrio di interesse risulta evidente che, per un buon controllo e
adottando per un momento una terminologia più suggestiva che rigorosa, il sistema dovrà arrivarci
con una velocità pressoché nulla.
Una leggera variazione di velocità, infatti, farebbe oltrepassare tale punto e conseguentemente
riportare il pendolo in regime oscillatorio nell’intorno del punto di equilibrio stabile.
Per far si che ciò accada, e più in generale per l'instabilità della dinamica del sistema attorno
all'equilibrio d'interesse, per mantenere il pendolo nella posizione “in alto” sarà ovviamente
necessario un regolatore in retroazione.
Molto diversa è tuttavia la situazione se al controllo si chiede non soltanto di mantenere il pendolo
nella posizione “in alto” (UP d'ora in poi) ma anche di portarvelo a partire da uno stato di riposo,
ad esempio con esso in un equilibrio stabile (DOWN con ovvio significato del termine).
Sorge quindi l’esigenza di dividere il controllo in due parti:
• una che si occupi di far oscillare il pendolo, al fine di posizionarlo nei pressi della posizione
verticale (UP)
• e l’altra di stabilizzare tale oscillazione al fine di annullare la velocità di rotazione e quindi di
stabilizzare definitivamente il sistema.
Il lavoro verrà quindi diviso in due parti; inizialmente si ipotizzerà il pendolo già in posizione UP e
si ricaveranno due leggi di controllo atte a stabilizzare tale situazione. La prima legge di controllo
utilizzerà dei semplici regolatori PID mentre la seconda un regolatore LQR.
Politecnico di Milano
28
La seconda fase del lavoro consisterà nello studio di leggi di controllo non lineari al fine di far
oscillare il sistema per portarlo dalla posizione DOWN a quella UP. Tale situazione verrà chiamata
di SWINGING UP.
Una volta sintetizzati i controllori atti a mantenere la posizione UP verrà scelta la configurazione di
controllo migliore e verrà simulata la dinamica completa del sistema. Si affronterà qui il problema
della gestione della commutazione tra il controllo SWINGING UP e quello di mantenimento della
posizione UP, ottenendo con ciò il controllore “completo” [5,6].
Una volta controllato il sistema con l’utilizzo della configurazione completa sintetizzata, si
cercheranno delle nuove leggi di controllo atte ad eseguire contemporaneamente la fase di
SWINGING UP e quella di mantenimento (STABILIZZAZIONE d'ora in poi). Si cercherà di sviluppare
due tipologie di controllori, una basata sulla compensazione della gravita (CONTROLLO VIRTUAL
GRAVITY) e l’altra sulla generazione di vincoli virtuali che impongano delle orbite al sistema
(CONTROLLO VIRTUAL SPRING).
Il controllo del Pendolo di Furuta
29
2. Sintesi del controllo basato su PID In generale una struttura PID [7,8,9,10] implementa un regolatore in grado di trasferire in uscita
una variabile di controllo legata alla somma di tre contributi.
Questi tre fattori sono proporzionali all’errore, al suo integrale e alla sua derivata.
Tramite questa struttura sarà cosi possibile annullare asintoticamente l’errore, a fronte di segnali
di riferimento o disturbi additivi costanti e prevedere il suo andamento negli istanti futuri.
Un regolatore PID è caratterizzato dalla seguente funzione di trasferimento (nel caso ideale):
( )s
KsKsKsPID IPD ++=
2
(43)
Dove Kp, Kd, e Ki sono, rispettivamente, i coefficienti dell’azione proporzionale, derivativa e
integrativa.
Tale funzione di trasferimento genera una rete a sella ideale; come noto tale funzione di
trasferimento genererebbe un sistema improprio, ovvero non realizzabile.
Nella pratica, allora, viene introdotto un polo ad alta frequenza proporzionale ad una costante
positiva N. La scelta di tale parametro dovrà essere fatta per spostare tale polo al di fuori della
banda di frequenze di interesse per il controllo.
Concludendo, la sintesi di un regolatore PID può essere fatta scegliendo opportunamente le
quattro costanti menzionate.
I valori ottimi di tali parametri possono essere ricavati principalmente in due modi; tramite lo
studio del modello del sistema da controllare, oppure tramite delle tecniche automatiche, tipo il
metodo di Ziegler e Nichols.
Ipotizzando che il sistema da controllare sia in posizione UP è possibile approssimare il suo
andamento con il modello linearizzato sviluppato in (34) e riportato di seguito
Politecnico di Milano
30
124222124
43
124222122
21
UXeXfXX
XX
UXeXfXX
XX
χαββ
χαββ
χαβχ
χαβχδ
χαβχ
χαβχ
χαβα
χαβαδ
−+
−−
−+
−−=
=
−−
−+
−−
−=
=
&
&
&
&
⎥⎥⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢⎢⎢
⎣
⎡
−
−−
=
⎥⎥⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢⎢⎢
⎣
⎡
−−
−−−
−−−
−=
2
2
222
222
0
0
01000
00010
χαββ
χαβχ
χαββ
χαβχ
χαβχδ
χαβχ
χαβα
χαβαδ
B
ef
ef
A
Supponendo che l’unica variabile di stato misurabile sia la posizione del pendolo, la
trasformazione d’uscita può essere scritta in forma matriciale come
[ ] [ ]UXDUCXy 00001 +=+=
Rielaborando le matrici A,B,C,D è possibile riscrivere il sistema per mezzo della sua funzione di
trasferimento [ ] DBAsICsG +−= −1)( . Tale calcolo è già stato eseguito analiticamente durante lo
sviluppo del modello del pendolo di Furuta. Di seguito viene riportato il risultato finale.
δαδβααβχχ
τϑ
eefsefsss
+−+−−+−=
)()()( 223
Valutiamo ora la funzione di trasferimento sostituendo i valori utilizzati precedentemente tramite
il seguente script Matlab:
Il controllo del Pendolo di Furuta
31
Figura 9 : Script matlab per il calcolo della funzione di trasferimento
Politecnico di Milano
32
Il risultato di tale operazione viene riportato di seguito:
Per la sintesi del controllore è meglio riscrivere la funzione di trasferimento fattorizzando il
denominatore. Dopo semplici passaggi matematici si ottiene:
(44)
La funzione di trasferimento da controllare sarà quindi caratterizzata da tre poli e da uno zero.
)2277.01)(3791.01)(0808.01(5472.2)(
sssssG
−++=
Il controllo del Pendolo di Furuta
33
Quando il sistema sotto controllo è instabile, come in questo caso, per la presenza di poli a parte
reale positiva, non è possibile utilizzare i metodi di sintesi in frequenza basati sul criterio di Bode.
In questi casi il progetto del controllore può essere effettuato mediante il metodo del luogo delle
radici. Tuttavia la definizione delle specifiche risulta spesso poco agevole in quanto i requisiti di
velocità e robustezza non sono più legati direttamente a indicatori quali il margine di guadagno, il
margine di fase e la pulsazione critica.
Per sopperire a tale problema è possibile utilizzare un sistema di controllo a doppia retroazione,
dove l’anello interno serve a rendere stabile il sistema mentre quello esterno viene sintetizzato
successivamente al fine di soddisfare i requisiti di progetto.
Di seguito viene riportato lo schema di riferimento:
Figura 10 : Sistema di controllo a doppia retroazione
Effettuando una prima analisi sul sistema di controllo da progettare si nota che il valore di
riferimento dell’angolo del pendolo deve essere nullo. Tale vincolo semplifica notevolmente il
lavoro in quanto il controllore non dovrà necessariamente essere pronto a fronte di variazioni sul
SET POINT ma dovrà solo annullare eventuali disturbi presenti sulla linea d’andata. Tale disturbi
saranno generati principalmente dal moto del braccio che genera una coppia motrice fittizia sul
pendolo stesso.
Politecnico di Milano
34
Presa per valida questa osservazione, anche lo schema di riferimento può essere semplificato
come segue:
Figura 11 : Sistema di controllo semplificato
Definendo le funzioni di trasferimento:
)1)(1)(1()2277.01)(3791.01)(0808.01(5472.2)(
321 sTsTsTsg
sssssG
−++=
−++=
( )s
KsKsKsR IPD ++=
2
La funzione di trasferimento del sistema retroazionato risulta:
)1()()()(
)()(1)()(
3212
3231213
321 ++−+++−−++−=
=+
=
IPD gKsTTTgKsTTTTTTgKsTTTsg
sRsGsGsH
Scegliendo 18020 −=−=−= DIP KKK e sostituendo i restanti parametri si ottiene:
(45)
Caratterizzata da uno zero nell’origine e da tre poli reali a pulsazione ‐355.61, ‐14.63 e ‐5.59.
8.20271.50621.2006975.0547.2)( 23 +++
−=sss
ssH
Il controllo del Pendolo di Furuta
35
Il sistema di controllo progettato risulta quindi stabile e capace di annullare eventuali disturbi
presenti all’ingresso del pendolo. Tale sistema però risulta non realizzabile in quanto il regolatore
presenta un numero di zeri maggiore del numero di poli. Per risolvere questo problema basta
aggiungere un ulteriore polo al regolatore. Tale polo deve essere scelto per non influenzare la
dinamica dell’anello sintetizzato, quindi deve stare all’esterno della banda di frequenze di
interesse nel controllo, ma non può nemmeno essere spostato troppo ad alta frequenza per non
aumentare troppo il guadagno del regolatore fuori banda.
Scegliamo:
(46)
Figura 12 : Diagrammi di Bode del regolatore PID
Come si nota dal diagramma di Bode riportato, il polo introdotto genera un guadagno ad alta
frequenza pari a circa 40 dB, valore più che soddisfacente.
( ))
1001(
2
ss
KsKsKsR IPD
+
++=
Politecnico di Milano
36
Valutiamo ora il diagramma di Nyquist della funzione d’anello:
Figura 13 : Diagramma di Nyquist della funzione d'anello
Il diagramma di Nyquist compie un giro antiorario intorno al punto ‐1 quindi la stabilità dell’anello
risulta soddisfatta anche introducendo il polo che rende realizzabile la rete correttrice PID.
Il controllo del Pendolo di Furuta
37
Effettuando la risposta ad un impulso e ad un gradino si ottengono i seguenti grafici:
Figura 14 : Risposta all'impulso con il regolatore PID
Figura 15 : Risposta al gradino con il regolatore PID
Politecnico di Milano
38
Effettuiamo ora la simulazione del sistema progettato in ambiente Simulink:
Figura 16 : Schema simulink del controllo PID
Il controllo del Pendolo di Furuta
39
Inizializzando il sistema con lo script Matlab si ottiene la seguente evoluzione delle variabili di
stato:
Figura 17 : Simulazione del controllo PID
Il pendolo di Furuta è stato inizializzato con un angolo theta di 0.1 rad ed il sistema ha risposto
prontamente muovendo il braccio in modo tale da recuperare questo scostamento. Confrontiamo
ora il comportamento del sistema al variare dell’angolo iniziale del pendolo:
Figura 18 : Confronto risposta del controllo PID
Politecnico di Milano
40
In questo caso è possibile constatare il limite di utilizzo del controllore sintetizzato. Il sistema
risponde in modo corretto solo entro un range limitato da un’inizializzazione pari a 0.4 rad. Tale
limite è imposto non tanto dalla scelte dei parameri del PID ma dall’ipotesi di linearità del sistema
da controllare, ovvero oltre questo itelimϑ la linearizzazione del sistema nell’interno del punto di
equilibrio UP (34) non vale più.
Il controllore sintetizzato soffre anche di un altro problema.
Il pendolo di Furuta presenta quattro variabili di stato. Durante la sintesi del controllore proposto,
è stata retroazionato l’angolo di rotazione del pendolo (G(s)): come dimostrato in simulazione, è
così possibile far tendere a zero le variabili di stato ϑϑ &, ma (ovviamente) non si ha alcun
controllo sulle rimanenti due ϕϕ &, .
Il controllo del Pendolo di Furuta
41
Questo concetto può essere meglio compreso con il grafico seguente:
Figura 19 : Andamento delle variabili di stato del pendolo di Furuta con il controllo PID
Si nota come l’evoluzione del pendolo tende a zero sia in rotazione che in velocità mentre quella
del braccio ad un moto rotativo a velocità costante.
Volendo risolvere tale problema si possono seguire due strade diverse: la prima consiste nel
sommare alla variabile di controllo un ulteriore termine a banda stretta che il regolatore
dell'angolo del pendolo vede come un disturbo in andata entro la banda di controllo. Tale disturbo
può essere generato da un anello esterno, sintetizzato per controllare (con dinamica appunto più
lenta) l'angolo del braccio. Tale soluzione richiede però uno sforzo di sintesi non trascurabile in
quanto i due segnali di controllo non devono influenzarsi “troppo” a vicenda. Quindi la sintesi deve
tener conto sia della separazione in frequenza che del peso da dare ai singoli contributi al fine di
non saturare l’organo di attuazione.
La seconda strada prevede invece l’utilizzo di una retroazione multipla, secondo la tecnica nota in
letteratura come “retroazione dello stato”. Questa modalità risulta molto più semplice da
affrontare in quando esiste una tecnica standard per la sintesi del controllore. Sarà scopo del
Politecnico di Milano
42
paragrafo successivo introdurre questa tecnica per poi sintetizzare e simulare il controllore
ricercato.
Il controllo del Pendolo di Furuta
43
3. Sintesi del controllore LQR Una tecnica alternativa per la sintesi del controllore consiste nell’usare il metodo del controllo
ottimo del tipo lineare quadratico (LQR) [11,12,13,14,15]. Tale tecnica minimizza la funzione costo
quadratica:
( )∫∞
+=0
)()()()( dttRUtUtQXtXJ TT
(47) Per un noto teorema, se la coppia (A,B) è raggiungibile esiste una soluzione al problema e questa è
unica se la coppia (A,C) è osservabile.
Valutiamo quindi le matrici di raggiungibilità e osservabilità del sistema (34) sostituendo i soliti
parametri caratteristici e definendo la trasformazione d’uscita come:
UXDUCXy ⎥⎦
⎤⎢⎣
⎡+⎥
⎦
⎤⎢⎣
⎡=+=
00
01000001
(48)
(49)
(50)
[ ]⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡
−−−−−
−−
==
3630.65328.00458.00057.05328.00458.00057.00419.65326.00387.00037.05326.00387.00037.00
01 532 BABAABBR
⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢
⎣
⎡
−−−−−
−=
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡
=
8.4504.742.3787.3804.856.3657.506.36.35
6.309.49.471000001001000001
3
2
CACACAC
O
Politecnico di Milano
44
Le matrici di raggiungibilità e osservabilità hanno rango massimo quindi la legge di controllo
ottima è data da )()( tKXtu −= con PBRK T1−= dove P è la soluzione dell’equazione algebrica di
Riccati 01 =−++ − PBPBRQPAPA TT
Il problema principale consiste ora nel determinare il valore delle matrici peso R e Q. Si tratta in
realtà di determinare univocamente la matrice Q in quanto solo l’entità relativa degli elementi di
tali matrici modifica la regolazione.
Se Q è relativamente grande rispetto a R, la procedura di ottimizzazione fornisce un vettore di
stato X relativamente piccolo rispetto all’ingresso U. Ciò corrisponde a prediligere la velocità del
controllo rispetto all’entità dello sforzo richiesto all’attuatore.
Se viceversa Q è relativamente piccola rispetto a R, la priorità è assegnata alla limitazione
dell’azione di controllo.
Si sceglie R pari alla matrice unitaria, ed essendo in questo caso uno scalare si pone:
PuR = (51)
La matrice Q può essere definita a partire dalla matrice C moltiplicandola per due costanti che
tengono conto del peso che si vuole dare alla dinamica delle variabili d’uscita:
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡
→
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡
==
00000000000000
0000010000000001
ϕ
ϑ
P
P
CCQ T
(52)
In questo caso si stanno pesando solo i contributi relativi agli angoli di rotazione e non le rispettive
velocità. Questo modo di operare semplifica notevolmente la sintesi del controllore, in quanto
elimina due gradi di libertà, e non inficia il funzionamento del sistema, in quanto una volta
annullate le variazione angolari anche le velocità andranno a zero.
Ora non resta che sostituire alcuni valori ai tre parametri di progetto e simulare la risposta
ottenuta. Questo può essere fatto in modo agevole in Matlab ricorrendo alla funzione LQR che
calcola automaticamente il valore del guadagno ottimo passandogli come parametro le matrici
A,B,Q,R.
Il controllo del Pendolo di Furuta
45
Di seguito viene riportato lo script Matlab usato:
Figura 20 : Script matlab del controllo LQR
Politecnico di Milano
46
Il guadagno ottimo K è stato utilizzato per inizializzare il seguente modello Simulink:
Figura 21 : Schema simulink del controllo LQR
Dove il blocco LQR è cosi definito:
Figura 22 : Schema simulink del blocco LQR
La simulazione ha confermato quanto evidenziato in via teorica (si vedano i grafici riportati di
seguito). All’aumentare del parametro Pu il segnale di controllo diventa via via più piccolo
mantenendo inalterato il tempo di assestamento a zero. Se si variano, invece, i parametri sugli
stati Pt,Pp si riscontra un aumento di velocità nella risposta del sistema alla convergenza nello
stato di equilibrio.
Il controllo del Pendolo di Furuta
47
Figura 23 : Simulazione del controllo LQR
Figura 24 : Simulazione del controllo LQR
Politecnico di Milano
48
Figura 25 : Simulazione del controllo LQR
Per quanto riguardo il caso specifico, dopo alcune prove sul simulatore, si è scelto:
50=R
⎥⎥⎥⎥
⎦
⎤
⎢⎢⎢⎢
⎣
⎡
=
0000010000000000300
Q
In questo modo si è giunti ad un sistema in anello chiuso caratterizzato dai quattro poli complessi
coniugati ‐22.5734+20.5453i, ‐22.5734‐20.5453i, ‐2.1229+1.5394i, ‐2.1229‐1.5394i.
Tale scelta è risultata la più adeguata in quanto “buon compromesso” tra velocità di risposta e
ampiezza del segnale di controllo.
Il controllo del Pendolo di Furuta
49
Di seguito vengono riportati i grafici di simulazione per un angolo iniziale del pendolo pari a 0.3
rad.
Figura 26 : Andamento delle variabili di stato del pendolo di Furuta con il controllo LQR
Come si può notare dai grafici il controllore LQR sintetizzato riesce a controllare il sistema e a farlo
ritornare nella sua posizione di equilibrio risolvendo il problema della perdita di controllo
sull’angolo di rotazione del braccio che aveva il controllore a PID.
Tale controllore risulta anche robusto a fronte di significative saturazioni sull’attuatore, come
evidenziato dal seguente grafico in cui si riporta l’andamento dell’angolo di rotazione del pendolo
e del segnale di controllo:
Politecnico di Milano
50
Figura 27 : Simulazione del controllo LQR saturato
Impostando una saturazione pari a 0.2 si nota un allungamento del tempo di assestamento, con
generazione di un ulteriore oscillazione intorno al punto di equilibrio, senza però perdere la
convergenza dell’angolo di rotazione del pendolo alla posizione desiderata.
Il controllo del Pendolo di Furuta
51
4. Swinging Up con controllo dell’energia (EC) Consideriamo il sistema approssimato del pendolo di Furuta (42) ipotizzando che valgano le
considerazioni fatte nel capitolo ad esso dedicato.
0sincos 2 =−+ ϑϑϑ ppp MgLMLaML &&
Il sistema è caratterizzato da due variabili di stato, l’angolo di rotazione ϑ e la relativa velocità
angolare ϑ& , ed ammette due punti di equilibrio )0,0(),( =ϑϑ &e )0,(),( πϑϑ =&
. Anche in
questo caso, come facilmente dimostrabile, il primo punto di equilibrio risulta stabile mentre il
secondo no.
Per la sintesi del controllore si utilizzerà il metodo del gradiente di velocità (Speed Gradient
Method), soffermiamoci brevemente sulla sua analisi [19,20,21].
Consideriamo un generico sistema dinamico non lineare descritto dalla seguente equazione
differenziale vettoriale:
uxgxfX )()( +=& (53)
Dove nRX ∈ è il vettore di stato,
mRu ∈ vettore dell’ingresso di controllo e f(x),g(x) due
funzioni vettoriali differenziabili.
È possibile definire una funzione costo Q(x,t) e pretendere che essa tenda a zero per un tempo t
che tende all’infinito. Tale funzione deve essere differenziabile due volte e tale per cui
0),( ≥txQ , 0)ˆ,ˆ( =txQ nel punto di equilibrio x̂ .
Valutiamo l’evoluzione temporale della funzione costo approssimandola al primo ordine:
tttutxWttxQttttxQ Δ+=Δ+Δ+ )),(),(()),(()),(( (54)
Politecnico di Milano
52
Dove
))()(()),(),(( uxgxfxQ
tQ
tx
xQ
tt
tQ
tQttutxW +
∂∂
+∂∂
=∂∂
∂∂
+∂∂
∂∂
=∂∂
= (55)
Per prevenire delle escursioni troppo ampie sul segnale di controllo è possibile introdurre un
termine penalizzante proporzionale al controllo stesso scalato di un fattore K:
)ˆ()ˆ(21)),(),(()),((
)),((
uuK
tuutttutxWttxQ
ttttxQ
T −Δ
−+Δ+=
=Δ+Δ+
(56)
La minimizzazione dell’evoluzione della funzione costo può essere effettuata ponendo uguale a
zero la sua derivata rispetto al segnale di controllo stesso.
(57)
Risolvendo rispetto a u si ricava:
)()(ˆ xgxxQKuu
∂∂
−= (58)
Il metodo SG, oltre a fornire un modo analitico per il calcolo della variabile di controllo, garantisce
anche l’asintotica stabilità della funzione costo, perché Q(x) è una funzione di Lyapunov.
[ ]
0)ˆ()()ˆ(
)ˆ()ˆ(21)),(),((
)),((
=Δ
−+Δ∂∂
=Δ
−+Δ∂∂
=
=⎥⎦⎤
⎢⎣⎡ −
Δ−+Δ
∂∂
=
=Δ+Δ+∂∂
Ktuutxg
xQ
Ktuut
uW
uuK
tuutttutxWu
ttttxQu
T
Il controllo del Pendolo di Furuta
53
Applichiamo ora il metodo esaminato al caso specifico [16,17,18].
L’energia totale del sistema può essere espressa come somma dell’energia cinetica e di quella
potenziale; considerando nulla l’energia potenziale quando il pendolo si trova in posizione
orizzontale )2/( πϑ = si ottiene:
Calcolando la derivata dell’energia rispetto al tempo si ottiene:
ϑϑϑϑϑϑϑϑϑϑϑϑ coscossin &&&&&&&&&&&&&PPPPpP MaLMaLJJMgLJE −=−−=−=
Dove l’equazione (42) è stata usata per effettuare l’ultima semplificazione.
Tale espressione evidenzia come sia possibile variare l’energia del sistema semplicemente agendo
sull’accelerazione (a). Si avrà una variazione positiva se 0>a quando 0cos <ϑϑ& e tale
variazione sarà tanto più efficiente quanto ϑ è vicina a 0 o π e la velocità angolare è alta. Si avrà
una perdita di controllo, invece, quando il pendolo si trova in posizione orizzontale )2/( πϑ =
o quando si avrà un inversione di moto 0=ϑ& .
Consideriamo ora una funzione di Lyapunov definita come
20
2)( EEQ −
= , tale funzione è
sempre positiva tranne nel punto )0,0(),( =ϑϑ & dove è nulla perché PMgLEE == 0 .
Calcoliamo la derivata di tale funzione rispetto al tempo:
[ ]2000 cos)(cos)()( ϑϑϑϑ &&&& EEKMLMaLEEEEEQ PP −−=−−=−=
Dove si è scelto ϑϑ cos)( 0&EEKa −= come legge di controllo per ottenere 0≤Q& e
l’uguaglianza vale proprio quando l’energia del sistema eguaglia quella della posizione verticale.
La scelta della variabile di controllo è stata effettuata proprio utilizzando il metodo SG descritto
precedentemente. Proviamo a calcolare analiticamente tale valore.
ϑϑϑϑ cos21cos
21 222
pPpP MgLJMgLMLE +=+= &&
Politecnico di Milano
54
Riscrivendo il sistema (42) evidenziando le matrici f(x), g(x) si ottiene:
aL
XX
Lg
XX
pp⎥⎥
⎦
⎤
⎢⎢
⎣
⎡−+
⎥⎥⎥
⎦
⎤
⎢⎢⎢
⎣
⎡= 1
1
2cos
0
0sin
0&
Dove si è posto ϑϑ &== 21 XX
Calcoliamo il valore ottimo della variabile di controllo:
[ ]
120120
122
010
cos)(~cos)(~ˆ
cos0
)()sin)((ˆ
)()(ˆ
XXEEKXXEEKu
LXXMLEEXMgLEEKu
xgxxQKuu
p
PP
−=−+
=⎥⎥
⎦
⎤
⎢⎢
⎣
⎡−−−−−
=∂
∂−=
(59)
Avendo imposto 0ˆ =u
Il controllo del Pendolo di Furuta
55
Studiando la legge di controllo ricavata si vede che per far variare l’energia del sistema il più
velocemente possibile si deve imporre che il segnale di controllo abbia l'ampiezza massima
possibile. Tale condizione può essere imposta modificando la relazione come segue:
[ ]ϑϑ cos)( 0&EEKSIGNa −=
(60)
Dove si è utilizzata la funzione segno per massimizzare il termine ϑϑ cos)( 0&EE − .
Questa legge di controllo non fa altro che commutare l’accelerazione del sistema tra i suoi due
valori estremi fino a far tendere l’energia al valore voluto. Senza nemmeno simulare il suo
andamento si può subito affermare che essa è certamente affetta da chattering nell’intorno del
punto di equilibrio. Per risolvere anche questo problema è possibile modificare ulteriormente la
legge di controllo introducendo la funzione saturazione.
[ ]{ }ϑϑ cos)( 0&SIGNEEKSATa −=
(61)
Tale legge di controllo può essere pensata come una funzione lineare, per piccole variazioni
dell’energia rispetto al valore imposto, e come un'approssimazione della legge di controllo “a
funzione segno” (o “bang bang”) per variazioni elevate di energia.
Studiamo ora la legge di controllo (61) valutando il significato dei vari parametri.
Il guadagno K influenza la regione di linearità della legge di controllo: se K è elevato il
comportamento è del tutto simile a quello delle legge a funzione segno. Il parametro relativo al
valore di saturazione, invece, riveste un ruolo determinante nel comportamento oscillatorio del
sistema, infatti rappresenta la massima accelerazione applicabile al pendolo.
Volendo portare il pendolo nella posizione verticale, con una sola oscillazione, bisogna imporre
che l’accelerazione introduca l’energia necessaria in una sola volta. Tale energia deve essere pari a
MgL2 quindi servirà un accelerazione minima pari a g2 . Valori maggiori di g2 velocizzeranno il
transitorio mentre valori minori di g2 richiederanno più oscillazioni del pendolo prima che esso
possa raggiungere la posizione UP.
Politecnico di Milano
56
Simuliamo il comportamento del sistema approssimato del pendolo di Furuta al variare di tale
parametro utilizzando il seguente schema Simulink:
Figura 28 : Schema simulink del controllo energia per il pendolo approssimato
Il blocco Energy Control, che implementa la legge di controllo ricavata precedentemente, viene
riportato di seguito:
Figura 29 : Schema simulink del blocco Energy Control
Il controllo del Pendolo di Furuta
57
Valutiamo due simulazione al variare del parametro di saturazione per verificare quanto
enunciato.
Figura 30 : Simulazione del controllo EC per il pendolo approssimato
In questo primo esempio, dove si è utilizzata un’accelerazione massima pari a 5g, si nota come sia
bastata una sola transizione del segnale di controllo per portare il pendolo in posizione verticale.
Politecnico di Milano
58
Abbassando a 0.25g il livello di accelerazione massimo si ottine:
Figura 31 : Simulazione del controllo EC per il pendolo approssimato
In questo secondo esempio si nota l’andamento oscillatorio del pendolo prima di raggiungere la
posizione verticale e gli incrementi parziali di energia dovuti alle singole transizioni della variabile
di controllo.
In entrambi i casi però, il sistema raggiunge la condizione ricercata e l’errore di energia tende
asintoticamente a zero. Questo verifica anche sperimentalmente che la legge di controllo ricavata
attraverso il metodo SG può essere utilizzata per lo Swinging Up del pendolo approssimato.
Il controllo del Pendolo di Furuta
59
Proviamo ora ad applicare la stessa legge di controllo al sistema non approssimato (26) utilizzando
il seguente schema Simulink:
Figura 32 : Schema simulink del controllo energia per il pendolo di Furuta
Figura 33 : Simulazione del controllo EC per il pendolo di Furuta
Politecnico di Milano
60
Come si può facilmente verificare dai grafici riportati, anche in questo caso la legge di controllo
sintetizzata risulta adeguata per portare il pendolo nella posizione verticale. Confrontando le
dinamiche temporali ci si accorge addirittura che l’applicazione di tale legge risulta più efficiente in
questo caso rispetto al caso precedente.
Questa osservazione può essere spiegata ricordando che la variazione di energia è proporzionale
all’accelerazione. Nel caso del pendolo semplice la variabile di controllo era l’accelerazione stessa
quindi il suo valore massimo limitava direttamente la variazione di energia. Nel caso del pendolo di
Furuta, invece, la variabile di controllo è la coppia motrice, e tale segnale risulta proporzionale
all’accelerazione del braccio moltiplicata per il prodotto tra la massa del braccio per la sua
lunghezza (basti pensare ad un semplice modello descritto da ττϕ =→= MLaML &&2 )
Essendo il prodotto massa per lunghezza minore di uno, l’accelerazione risulta maggiore che nel
caso precedente e quindi tale è anche la massima variazione di energia.
Il controllore sviluppato con il metodo SG ha quindi il vantaggio il portare il pendolo nella
posizione verticale, con un segnale di controllo limitato, in un tempo proporzionale a tale limite. In
un’applicazione reale è possibile quindi trovare un giusto compromesso tra la coppia che
l’attuatore deve poter erogare e le tempistiche richieste dalle specifiche di progetto.
Il difetto principale del controllore SG, invece, è la necessità di utilizzarlo in unione a un secondo
controllore che stabilizza il pendolo nella posizione verticale. Questo difetto deriva dalla
progettazione stessa, in quanto si è sintetizzato un trasferimento asintoticamente stabile
dell’energia del sistema e non un controllo sull’angolo di rotazione del pendolo.
Il controllo del Pendolo di Furuta
61
5. Controllo del pendolo con strategia EC-LQR Simuliamo ora il comportamento del sistema completo tramite il seguente schema Simulink:
Figura 34 : Schema simulink del controllo EC-LQR
Lo schema proposto implementa un controllo ibrido composto da due parti, la prima (EC) fa
oscillare il pendolo mentre la seconda (LQR) stabilizza il pendolo nella posizione verticale.
Politecnico di Milano
62
Di seguito si riportano i grafici della simulazione:
Figura 35 : Simulazione del controllo EC-LQR
Il risultato conferma quanto ipotizzato nel paragrafo precedente, il controllore EC permette
l’oscillazione del pendolo portandolo nella posizione superiore annullando l’errore di energia (il
terzo grafico riporta la differenza di energia rispetto alla posizione superiore) mentre il controllore
LQR stabilizza tale configurazione.
Il controllo del Pendolo di Furuta
63
6. Controllo Virtual Gravity (VG) Consideriamo il sistema approssimato del pendolo di Furuta (42) ipotizzando che valgano le
considerazioni fatte nel capitolo ad esso dedicato.
0sincos 2 =−+ ϑϑϑ ppp MgLMLaML &&
Il sistema può essere riscritto in questo modo:
ϑττϑϑ cossin2 aMLdoveMgLML ppp −==−&& (62)
Cosi facendo si è giunti ad un sistema del secondo ordine controllabile tramite il segnale di coppia.
È possibile scegliere tale segnale in modo da invertire l’accelerazione gravitazionale e rendere
attrattiva la posizione verticale [22].
L’asintotica stabilità dell’origine può essere quindi raggiunta introducendo un ulteriore termine al
segnale di controllo al fine di sintetizzare un semplice trasferimento PD e creare la seguente
dinamica ad anello chiuso:
ϑϑϑτ
ϑϑϑϑ&
&&&
10
102
sin2
sin
KKMgLdove
KKMgLML
p
pp
−−−=
−−−=
(63)
Ricaviamo ora l’accelerazione da fornire al sistema per ottenere il segnale di coppia voluto:
ϑϑϑ
ϑϑϑϑ
ϑ
ϑϑϑϑτ
cos)(tan2
cos)(tan2
cossin2'
1'
010
10
&&
&
KKgML
KKga
aMLKKMgL
p
pp
++=
++=
−=−−−=
(64)
Politecnico di Milano
64
Simuliamo ora il comportamento del sistema descritto con il seguente schema Simulink:
Figura 36 : Schema simulink del controllo VG per il pendolo approssimato
Il blocco MATLAB Fcn implementa la seguente funzione:
Figura 37 : Script matlab della funzione di controllo VG per il pendolo approssimato
utilizzata per la generazione del segnale di controllo.
Il controllo del Pendolo di Furuta
65
Di seguito viene riportato l’evoluzione temporale del sistema:
Figura 38 : Simulazione del controllo VG per il pendolo approssimato
I grafici evidenziano come l’origine sia davvero un punto di equilibrio asintoticamente stabile per il
sistema.
Trascurando il termine gravitazionale, la dinamica a ciclo chiuso diventa:
0102 =++ ϑϑϑ &&& KKMLp (65)
Riscrivendo in termini di trasformata di Laplace le variabili di stato e ricavando i poli del sistema si
giunge a:
21
2200
24
P
P
MLKMLKK
s−±−
= (66)
Il sistema è quindi caratterizzato da due poli che possono essere scelti a piacere tramite i
parametri di guadagno della struttura PD.
Politecnico di Milano
66
Come già fatto per la sintesi del controllore basato sull’energia, applichiamo ora la legge di
controllo sintetizzata al sistema non approssimato (26) tramite il seguente schema Simulink:
Figura 39 : Schema simulink del controllo VG per il pendolo di Furuta
Anche in questo caso il blocco MATLAB “Fcn” implementa la retroazione di stato con la seguente
funzione:
Figura 40 : Script matlab della funzione di controllo VG per il pendolo di Furuta
Rispetto al caso del pendolo semplice, però, l’accelerazione generata non sarà più quella
tangenziale al pendolo ma quella del braccio. Per risolvere questo problema basta ricordare il
legame aLa =ϕ&& e scrivere aLa /=ϕ&& .
La funzione riportata implementa proprio questa correzione.
Il controllo del Pendolo di Furuta
67
Inizializzando il sistema con il solito script Matlab ed eseguendo la simulazione si ricavano i
seguenti grafici:
Figura 41 : Simulazione del controllo VG per il pendolo di Furuta
Analizzando gli andamenti delle variabili di stato si nota come il controllore sintetizzato sia in
grado di eseguire la fase di Swinging Up e di stabilizzazione del pendolo senza ricorrere a strutture
ibride, come nel caso del sistema EC‐LQR.
Il difetto principale, invece, riguarda la perdita di controllo nell’angolo di rotazione del braccio.
Questo problema genera una rotazione del braccio a velocità costante come quello già riscontrato
nella sintesi del controllore PID.
Anche in questo caso è possibile risolvere il problema introducendo un secondo anello con una
dinamica limitata in modo da generare un disturbo che annulli la rotazione del braccio.
Politecnico di Milano
68
In prima analisi tale strada sembrerebbe la più appropriata da un punto di vista “controllistico” in
quanto la sintesi del'ulteriore anello aggiunto può essere eseguita sfruttando la teoria ben nota
dei controllori PID. Seguendo questa strada però si perde la natura “fisica” della legge di controllo
ricavata visto che non si riesce in modo agevole a dare un origine fisica al segnale aggiunto al
controllo (visto come disturbo dall'anello che regola l'angolo del pendolo) per regolare le posizione
del braccio.
Sorge quindi l’esigenza di chiedersi se non sia possibile perseguire insieme i due obiettivi di
controllo (l’annullamento degli errori sui due spostamenti angolari rispetto ai valori di riferimento)
con un ragionamento basato completamente sull’origine fisica del segnale di controllo.
Il controllo del Pendolo di Furuta
69
7. Controllo Virtual Spring (VS) L’idea che sta alla base di questa nuova modalità di controllo è quella di generare un segnale che
simuli la dinamica di un sistema meccanico soggetto a dei vincoli posizionati (ed eventualmente
spostati nel tempo) ad hoc per seguire una traiettoria di riferimento.
Pensiamo all’obiettivo di controllo del pendolo di Furuta: creare delle oscillazioni sul pendolo al
fine di portarlo in posizione UP e poi far tendere a zero ogni variazione delle variabili di stato, sia in
posizione che in velocità. Basandoci sulla teoria del controllo si è realizzato un sistema ibrido EC‐
LQR che svolge completamente tale mansione. Per sintetizzare il suddetto sistema si sono dovuti
introdurre due argomenti di non immediata comprensione, il metodo SG e il controllo ottimo.
Si vuole ora veder se, sfruttando l’idea dei vincoli virtuali, è o meno possibile risolvere lo stesso
problema di controllo.
Pensiamo di vincolare la massa del pendolo ad un sistema molla‐smorzatore (MS) appeso ad un
anello situato sopra il pendolo di Furuta. Tale sistema aggiunto non farà altro che attirare a se il
braccio e il pendolo al fine di minimizzare l’energia totale del sistema.
Inoltre avendo a disposizione due gradi di libertà quali la costante elastica della molla e il
coefficiente di attrito dello smorzatore è altresì possibile scegliere la dinamica e quindi
l’evoluzione della variazione di tale energia.
Politecnico di Milano
70
Consideriamo il seguente modello:
MS
Come si può notare dal disegno, il sistema meccanico da modellizzare è del tutto simile al classico
pendolo di Furuta con l’aggiunta del blocco MS.
Tale blocco subirà delle deformazioni rispetto alla posizione di riposo che possono essere
proiettate sui tre assi ortogonali x,y,z:
)cos1(),()0,(sincos)sin(sin),()0,(
sinsin)cos(cos),()0,(
00
000
000
ϑϑφφϑφφφϑφφϑφφφϑφφ
−=−=−−=−=+−=−=
RpZZDZRpRaYYDY
RpRaXXDX
(67)
Tale deformazioni non sono altro che la differenza tra le coordinate del punto in cui si è fissato il
sistema MS, in questo caso si è scelto un angolo 0φ generico e si è posto 00 =ϑ , e le coordinate
della massa di bilanciamento.
Figura 42 : Modello del controllo VS
Il controllo del Pendolo di Furuta
71
Derivando tali deformazioni rispetto al tempo si ricava l’espressione del vettore velocità:
TRpRaDVzRpRaDVyRpRaDVxRpRaDV )],(),,(),,([),( = (68)
Infine è possibile calcolare il modulo del vettore deformazione e del vettore velocità del sistema
MS:
)sincos2cossinsin(cossin2)sinsincos(cos2cos222),(
00
0022222
φφφφφφϑφφφφϑ
−++++−−+=
RaRpRaRpRpRaRpRaDL
(69)
2222222 cos2)sin(),( ϑϑφϑφϑ &&&& RpRaRpRpRaRpRaDV +++= (70)
Una volta ricavati tali vettori, essi possono essere utilizzati per calcolare l’energia potenziale della
molla e la funzione dissipazione dello smorzatore ricordando di sostituire le generiche posizioni Ra
e Rp con le lunghezze effettive del braccio (La) e del pendolo (Lp):
22
21,
21 rDVDkDLV smorzatoremolla ==
(71)
Introducendo le sopracitate grandezze il sistema di equazioni che governa la dinamica del sistema
complessivo diventa:
ϑϑϑϑ
φφφφ
&&
&&
∂∂
−=∂
∂+
∂∂
−⎟⎠⎞
⎜⎝⎛∂∂
∂∂
−=∂
∂+
∂∂
−⎟⎟⎠
⎞⎜⎜⎝
⎛∂∂
smorzatoremolla
smorzatoremolla
DVLLdtd
DVLLdtd
(72)
Una volta calcolate le derivate opportune, il sistema può essere riscritto in forma matriciale:
⎥⎦
⎤⎢⎣
⎡=+⎥
⎦
⎤⎢⎣
⎡+⎥
⎦
⎤⎢⎣
⎡00
),(),,,(),( modmod ϑφϑφ
ϑφϑφϑφ
ϑφ gCD&
&&&
&&
&&
(73)
Politecnico di Milano
72
Il nuovo sistema è del tutto analogo al precedente fatta eccezione per le matrici C e g, che
contengono i contributi del sistema MS, e per la scomparsa dei segnali di controllo. Tali segnali
sono volutamente stati omessi in quanto è la struttura stessa del sistema meccanico a garantire
l’orbita di riferimento cercata, che quindi non deve essere forzata esternamente. E' ovvio che poi
nella realtà i segnali di controllo vi sono e nel modello (72) corrispondono alle coppie ai giunti del
pendolo equivalenti all'effetto del blocco MS (si veda più avanti).
Le matrici caratteristiche del sistema sono le seguenti:
⎥⎦
⎤⎢⎣
⎡ +=
βϑχϑχϑβα
ϑφcos
cos)sin(),(
2
D
⎥⎦
⎤⎢⎣
⎡
++−+−+++
=2
222
mod cossincoscossinsincos)sin(sincos
),,,(rLpfrLaLp
rLaLpLpLareC
ϑφϑϑβϑϑϑχφϑϑβϑϑϑϑβ
ϑφϑφ&
&&&&&
⎥⎦
⎤⎢⎣
⎡
−−+−++
=ϑδϑφϑφϑϑ
φϑφϑφϑφφϑ
sincossinsin2sinsinsincossin2sinsin2cossinsin
),(2
222
mod kLaLpkLaLpkLpkLaLpkLaLpkLaLpkLa
g
Il controllo del Pendolo di Furuta
73
Prima di valutare la struttura del sistema di controllo costruiamo un modello simulink in grado di
simulare il sistema pendolo di Furuta modificato. Di seguito viene riportato il risultato di tale
operazione:
Figura 43 : Schema simulink del pendolo di Furuta modificato con il sistema MS
L’inizializzazione del modello viene fatta con il solito script Matlab con l’unica differenza di
introdurre i due termini aggiuntivi del sistema MS, k e r.
Il coefficiente di smorzamento r influenza la presenza o meno di eventuali oscillazioni rispetto alla
posizione di riferimento e il tempo con cui esse tendono ad arrestarsi. Il coefficiente k della molla,
invece, riveste un ruolo decisamente più importante in quanto è proprio questo parametro che
permette la fase di SWINGING UP del pendolo. Per poter portare il pendolo in posizione UP deve
valere la seguente disuguaglianza (si veda la matrice ),(mod φϑg ):
kLp
kkLp ~sinsin 22 =≥→≥
δϑδϑ (74)
Politecnico di Milano
74
Valutiamo il risultato della simulazione impostando 1.0=r e kk ~*2= .
Figura 44 : Simulazione del pendolo di Furuta modificato con il sistema MS
Come si può notare dai grafici riportati il sistema risponde proprio come si era ipotizzato e tutte le
variabili di stato tendono al loro valore di riferimento.
Il controllo del Pendolo di Furuta
75
Proviamo ora ad effettuare la stessa simulazione con un valore di k più basso del valore limite
menzionato precedentemente imponendo 1.0=r e kk ~*5.0= .
Figura 45 : Simulazione del pendolo di Furuta modificato con il sistema MS Anche in questo caso la simulazione conferma quanto esposto precedentemente, la molla non
riesce a contrastare il peso della massa di bilanciamento e la fase di SWINGING UP non viene
eseguita.
Politecnico di Milano
76
Infine valutiamo il caso in cui il coefficiente di smorzamento sia più piccolo di quello utilizzato nelle
simulazioni precedenti imponendo 05.0=r e kk ~*2= .
Figura 46 : Simulazione del pendolo di Furuta modificato con il sistema MS Si nota che, avendo imposto un valore kk ~
> , la fase di SWINGING UP viene eseguita
correttamente ma si riscontrano dei notevoli overshoot causati da una scelta del parametro di
smorzamento non ottimale.
Il controllo del Pendolo di Furuta
77
Una volta capita la dinamica del pendolo di Furuta “modificato” (ovvero del sistema pendolo di
Furuta più molla virtuale) non rimane altro che dedurne il segnale di controllo. Per semplicità di
esposizione riscriviamo i modelli matriciali dei due sistemi meccanici:
⎥⎦
⎤⎢⎣
⎡=+⎥
⎦
⎤⎢⎣
⎡+⎥
⎦
⎤⎢⎣
⎡
ϑ
φ
ξτ
ϑφϑφ
ϑφϑφϑφ
ϑφ ),(),,,(),( gCD&
&&&
&&
&&
⎥⎦
⎤⎢⎣
⎡=+⎥
⎦
⎤⎢⎣
⎡+⎥
⎦
⎤⎢⎣
⎡00
),(),,,(),( modmod ϑφϑφ
ϑφϑφϑφ
ϑφ gCD&
&&&
&&
&&
Combiniamo algebricamente le due equazioni matriciali eseguendo la differenza delle due:
[ ] [ ] [ ] ⎥⎦
⎤⎢⎣
⎡=−+⎥
⎦
⎤⎢⎣
⎡−+⎥
⎦
⎤⎢⎣
⎡−
ϑ
φ
ξτ
ϑφϑφϑφ
ϑφϑφϑφϑφϑφ
ϑφϑφ ),(),(),,,(),,,(),(),( modmod ggCCDD&
&&&&&
&&
&&
In questo modo possiamo scrivere:
),(~),,,(~ ϑφϑφ
ϑφϑφξτ
ϑ
φ gC +⎥⎦
⎤⎢⎣
⎡=⎥
⎦
⎤⎢⎣
⎡&
&&&
(75)
Questa espressione rappresenta la retroazione di stato da effettuare per far si che la dinamica del
pendolo di Furuta simuli quella del pendolo di Furuta modificato dall’aggiunta del sistema molla –
smorzatore.
Politecnico di Milano
78
Figura 47 : Schema simulink del controllo VS
Il modello Simulink riportato implementa il controllo VS retroazionando il sistema tramite le due
equazioni ricavate precedentemente.
Inizializzando il modello impostando 2.0=r e kk ~*2= si ricavano i seguenti grafici:
Figura 48 : Simulazione del controllo VS
Il controllo del Pendolo di Furuta
79
L’andamento delle variabili di stato evidenzia come il controllore sintetizzato riesca a soddisfare
perfettamente gli obiettivi di controllo.
Terminata quest’analisi, si potrebbe pensare di confrontare i risultati ottenuti con il controllore EC‐
LQR e il sistema VS. Valutando solamente gli andamenti delle variabili di stato si potrebbe pensare
che i due sistemi siano del tutto equivalenti e quindi affermare che la strada della sintesi basata sul
posizionamento di vincoli sia la migliore e la più semplice in quanto “basata solo sulla natura fisica
del problema”.
Analizzando meglio i segnali di controllo, però, si nota subito come il confronto sia impari in
quanto i due sistemi hanno un numero diverso di ingressi. Il sistema EC‐LQR si basa sul pendolo
sottoattuato mentre il sistema VS per funzionare necessita una completa attuazione dei giunti.
Senza volersi diffondere eccessivamente sul tema, è comunque opportuno sottolineare qui il
valore didattico dell’aver osservato un simile fatto. E’ in molti settori tradizione cercar di
comprendere (e anche a volte di controllare) sistemi meccanici (o a essi assimilabili)
“assemblando” modelli di tali sistemi e dei comportamenti desiderati fatti appunto da masse,
molle, smorzatori e altri simili componenti che dovrebbero “descrivere sinteticamente e in modo
equivalente” i fenomeni con e senza controllo. E’ opinione dell’autore (e del suo relatore) che un
tale modo di procedere mostri a volte la corda, in quanto l’assemblare “elementi meccanici” di cui
sopra altro non è che un modo potenzialmente surrettizio di assemblare equazioni. Quando poi
occorre analizzare i risultati per vedere in termini di teoria dei sistemi e del controllo cosa si è
voluto fare e/o cosa si è fatto, non è infrequente che i risultati ottenuti – come peraltro è successo
qui – non possano essere tradotti in pratica se non assumendo condizioni (qui di attuazione) non
realistiche e neppur necessarie, a patto però di affrontare il problema “da sistemisti” fin da subito.
Lungi dal promuovere una critica aprioristica dell’approccio “a equivalenti meccanici”, l’esperienza
descritta in questo capitolo può pertanto evidenziarne i limiti e chiarire a un eventuale
sperimentatore “discente” i necessari caveat da tenere a mente.
Politecnico di Milano
80
Le esperienze di controllo simulate
81
4. Le esperienze di controllo simulate
1. Introduzione a Easy Java Simulations Easy Java Simulations (Ejs) [23,24] è uno strumento software progettato per la simulazione
discreta al computer di modelli fisici.
Una simulazione su elaboratore è un programma destinato alla riproduzione di un fenomeno
naturale descritto mediante sistemi di equazioni differenziali. Tale equazioni saranno
caratterizzate da delle variabili di stato che Ejs farà evolvere e visualizzerà a video.
Esistono molti programmi che permettono questo tipo di operazione; qui è stato scelto Ejs perché
nato proprio dall’esigenza di professori e ricercatori di avere un software capace di simulare delle
variabili dinamiche senza perdere troppo tempo nella realizzazione del sorgente.
È proprio questa la potenza di Ejs; il programma fornisce tutti gli strumenti base per essere subito
operativi senza perdere troppe ore di training prima di poter lanciare la prima simulazione.
Questa semplicità di utilizzo però, non rende Ejs meno prestante rispetto a programmi concorrenti
più professionali: con Ejs è possibile tracciare qualsiasi tipo di grafico, disegnare qualsiasi tipo di
modello e analizzare la maggior parte dei fenomeni che interessano l’ambito della ricerca
scientifica.
Un ulteriore punto di forza di Ejs sta nel fatto che genera automaticamente degli Applet Java che
possono essere visualizzati su dei semplici Browser Internet, questa peculiarità permette di
stendere simulazioni multipiattaforma che possono essere visualizzate da qualsiasi utente.
Politecnico di Milano
82
2. Il simulatore del Pendolo di Furuta La realizzazione del modello è stata sviluppata in due fasi: inizialmente si è costruita una struttura
3D composta da dei semplici cilindri legati tra loro da dei vincoli di posizionamento,
successivamente sono state inserire le equazioni dinamiche che regolano l’evoluzione degli angoli
e delle relative velocità.
Il risultato di questa operazione è il seguente:
Figura 49 : Modello Ejs del pendolo di Furuta
Le esperienze di controllo simulate
83
Figura 50 : Equazioni Ejs del pendolo di Furuta
Figura 51 : Definizione delle equazioni del pendolo di Furuta
Politecnico di Milano
84
Come già introdotto nel paragrafo precedente, la stesura del modello è stata molto veloce, frutto
della semplicità di utilizzo di Ejs; una volta disegnata la struttura del pendolo sono state
implementate le quattro equazioni differenziali tramite la schermata Evolution. Tali equazioni non
sono altro che una copia del modello integrale sviluppato in (26) definite nella schermata Custom.
Tutte le equazioni scritte sono state parametrizzate tramite l’introduzione di variabili, in modo tale
da poter simulare il pendolo in qualsiasi condizione operativa assegnando a esse i valori opportuni.
Figura 52 : Variabili Ejs del pendolo di Furuta
Le esperienze di controllo simulate
85
Figura 53 : Inizializzazione Ejs del pendolo di Furuta
Politecnico di Milano
86
3. Esperienze con controllo EC-LQR Il controllo EC‐LQR è stato implementato definendo nella schermata Custom le funzioni introdotte
nel paragrafo 3.3 e 3.4 ad esso dedicato.
Figura 54 : Algoritmo di controllo EC-LQR
Le esperienze di controllo simulate
87
La strategia di switching è stata invece definita nella schermata Evolution
Figura 55 : Strategia di controllo EC-LQR
Il pendolo, per come è stato sviluppato il modello, si troverà a 0° nella posizione UP oppure a 360°,
in base al senso di rotazione del braccio. Per non dover prevedere le due situazioni in fase di
switching si è deciso di utilizzare la funzione coseno: tale funzione, essendo pari, si comporterà
nello stesso modo a fronte di rotazioni orarie o antiorarie del pendolo. Dopo qualche tentativo si è
giunti alla conclusione che un valore limite di 0.9 permette un passaggio appropriato tra le due
politiche di controllo.
Per rendere ancora più generale il simulatore sviluppato si è anche deciso di introdurre una
saturazione sulla variabile di controllo: tale saturazione può essere gestita inzializzando
correttamente la variabile Usat.
Politecnico di Milano
88
Le figure sottostanti riportano un esempio di utilizzo del programma realizzato.
Figura 56 : Modello Ejs del controllo EC-LQR
Figura 57 : Simualzione del controllo EC-LQR nella fase EC
Le esperienze di controllo simulate
89
Figura 58 : Simulazione del controllo EC-LQR nella fase LQR
Il programma, oltre ad offrire una semplice interfaccia interattiva, visualizza anche l’evoluzione dei
segnali che caratterizzano il sistema e una label per identificare il tipo di controllo in azione.
L’esempio riportato mostra l’evoluzione del pendolo dalla posizione DOWN a quella UP
evidenziando lo switch tra il controllo EC e LQR.
Politecnico di Milano
90
4. Esperienze con controllo Virtual Gravity Il controllo VG è stato implementato definendo nella schermata Custom le funzioni introdotte nel
paragrafo 3.6 ad esso dedicato.
Figura 59 : Algoritmo di controllo VG
La strategia di controllo è stata definita nella schermata Evolution
Figura 60 : Strategia di controllo VG
Anche in questo caso è stata introdotta una funzione saturazione per permettere la simulazione di
attuatori a dinamica limitata.
Le esperienze di controllo simulate
91
Le figure sottostanti riportano un esempio di utilizzo del programma realizzato.
Figura 61 : Modello Ejs del controllo VG
Figura 62 : Simulazione del controllo VG
I grafici confermano ancora una volta come il controllo VG sia in grado di eseguire
contemporaneamente la fase di SWINGING UP del pendolo e di stabilizzare la configurazione UP.
Politecnico di Milano
92
5. Esperienze con controllo Virtual Spring
Il controllo Vs è stato implementato definendo nella schermata Custom le funzioni introdotte nel
paragrafo 3.7 ad esso dedicato.
Figura 63 : Algoritmo di controllo VS
La strategia di controllo è stata definita nella schermata Evolution
Figura 64 : Strategia di controllo VS
In questo caso è stato necessario ridefinire il set di equazione del simulatore del pendolo di Furuta
per introdurre il secondo segnale di controllo che gestisce l’attuazione del giunto del pendolo.
Questa modifica è stata fatta modificando nella schermata Custom il modello integrale definito
dalle equazione f1 e f2:
Le esperienze di controllo simulate
93
Figura 65 : Ridefinizioni delle equazioni del pendolo di Furuta
Politecnico di Milano
94
Valutiamo ora l’utilizzo del simulatore sviluppato:
Figura 66 : Modello Ejs del controllo VS
Figura 67 : Simulazione del controllo VS
Anche in quest’ultimo caso il simulatore conferma le conclusioni tratte in fase di sintesi:
il sistema di controllo VS riesce perfettamente a stabilizzare il pendolo di Furuta nella posizione
UP.
Conclusioni
95
5. Conclusioni
Si sono realizzate e descritte esperienze di controllo relative al pendolo di Furuta, a scopo didattico
ma anche (potenzialmente) per la sperimentazione in simulazione di tecniche di controllo evolute.
A tale scopo è stato impiegato un ambiente software (Ejs) di simulazione adatto alla
prototipazione rapida di simulatori dotati d'interfaccia utente “ricca” e flessibile, fruibili sia
localmente che tramite il web e col solo utilizzo di software libero.
Il lavoro svolto è stato suddiviso in tre sezioni:
• Studio e analisi del modello del pendolo di Furuta
• Sintesi di sistemi di controllo per il pendolo di Furuta
• Realizzazione di simulatori per il pendolo di Furuta
Il pendolo di Furuta è stato modellizzato per mezzo delle equazioni di Eulero‐Lagrange. Si è anche
deciso di inserire nel modello le componenti di attrito presenti nei giunti del pendolo (in
letteratura si trovano spesso modelli privi di attrito). Si è così giunti ad un modello a parametri
distribuiti caratterizzato da due coppie di controllo (una sul giunto del braccio e l’altra su quello
del pendolo) e da due coppie di attrito.
Il sistema di equazioni non lineari ricavato è stato poi analizzato per caratterizzare i punti di
equilibrio del pendolo di Furuta, che ovviamente ne ammette infiniti (il braccio risulta vincolato ad
un piano del sistema quindi qualsiasi posizione risulta di equilibrio) i quali possono essere suddivisi
in base alla posizione assunta del pendolo. Se il pendolo risulta rivolto verso il basso (posizione
chiamata DOWN) le configurazioni di equilibrio risultano stabili mentre se il pendolo si trova
rivolto verso l’alto (UP) gli equilibri – quelli peraltro d'interesse per il controllo ‐ risultano instabili.
Si è poi pensato ad un modo per approssimare il pendolo di Furuta con un pendolo semplice, utile
in fase di sintesi dei controllori, che non considera il braccio del pendolo.
I modelli sviluppati sono stati implementati in ambiente Matlab per aver un supporto software sul
quale elaborare le varie prove e simulazioni. Anche in questo caso si è deciso di sfruttare la
potenzialità di Matlab per realizzate dei simulatori parametrici al fine di poter testare i sistemi in
ogni condizione operativa. Si è scelto di poter variare tutti i parametri geometrici del pendolo di
Furuta, quali masse e lunghezze, e tutte le condizioni iniziali, ovvero posizione e velocità del
braccio e del pendolo.
Politecnico di Milano
96
Durante questa prima fase si è potuto constatare come la stesura di un modello non sia solo la
premessa per la sintesi di un controllore, come spesso capita di leggere, ma riveste un ruolo
fondamentale per semplificare il lavoro di sintesi stesso. La scelta del modello deve essere fatta sia
per massimizzare la semplicità delle equazioni che per comprendere la natura fisica del problema
da affrontare. Quindi un buon progetto di controllo nasce proprio da una buona scelta del
modello di partenza. Un modello ottimo deve possedere due caratteristiche fondamentali:
• Il modello deve essere il più semplice possibile
• Il modello deve essere il più generale possibile
Proprio per queste due regole si è scelto di sviluppare un modello completamente parametrizzato
che include i contributi di attrito ed entrambe le coppie di controllo (una che agisce sul braccio e
l’altra sul pendolo) pur utilizzando nella maggior parte del lavoro un modello sotto attuato del
pendolo di Furuta.
Un altro aspetto fondamentale è anche il modo con cui un modello viene rappresentato. Spesso si
trascura questo aspetto in quanto tutte le possibili rappresentazioni sono equivalenti dal punto di
vista dinamico ma non lo sono dal punto di vista applicativo. Per esempio un modello espresso in
variabili di stato risulta molto più semplice da gestire per la realizzazione di un simulatore rispetto
al suo equivalente differenziale; al contrario una rappresentazione differenziale, riscritta magari in
termini matriciali, risulta più comoda per il calcolo dei punti di equilibrio o di possibili retroazioni di
stato non lineari. Proprio per questo motivo, dato il carattere didattico delle esperienze trattate, si
è deciso di riportare il modello del pendolo di Furuta sia per mezzo della rappresentazione di stato
che in termini matriciali. La prima rappresentazione è stata utilizzata per realizzare i simulatori
Matlab ed Ejs mentre la seconda è tornata utile, per esempio, per calcolare i segnali di controllo
durante la sintesi del controllo “virtual spring”.
Una volta concluso il lavoro di modellizzazione e analisi si è passati alla sintesi dei controllori.
Prima si è operato sul sistema linearizzzato del pendolo di Furuta nella posizione UP e si sono
studiati due controllori standard (PID e LQR), successivamente si è affrontato il problema di
portare il pendolo dalla posizione DOWN alla posizione UP tramite la sintesi del controllo EC (fase
di SWINGING UP). In ultimo si è pensato di sintetizzare un controllo capace di effettuare sia lo
SWINGING UP del pendolo che di stabilizzare la posizione UP (controllo VG e VS).
Conclusioni
97
Si sono presto evidenziati i limiti della struttura PID, che gestisce solo l’angolo di rotazione del
pendolo (quindi a regime il pendolo di Furuta si troverà in posizione UP ma il braccio continuerà a
ruotare).
Per sopperire a tale limite, tra le varie strade possibili, si è deciso di adottare quella di sintetizzare
un controllore LQR, che permette sia la stabilizzazione della posizione UP del pendolo che
l’annullamento della rotazione del braccio. Questo comportamento è stato testato facendo variare
l’angolo di inizializzazione del pendolo è si è ricavato un valore limite entro il quale il controllo LQR
interviene correttamente. Questo parametro è stato in seguito utilizzato per gestire la
commutazione tra la fase di SWINGING UP e quella di stabilizzazione del pendolo di Furuta.
Per portare il pendolo dalla posizione DOWN alla posizione UP si è utilizzato un controllore che in
letteratura è conosciuto con il nome di “Energy Control”. L’idea base è quella di far variare
l’energia interna del sistema in modo che essa tenda ad un valore di riferimento, quella della
posizione UP nel caso del pendolo di Furuta. In letteratura esistono molti riferimenti a riguardo ma
tutti trascurano il procedimento di calcolo di tale legge di controllo dando per scontato che esista
e che dia origine a delle traiettorie stabili subordinando poi alla simulazione numerica il compito di
dimostrarlo. Volendo sopperire a tale lacuna e capire meglio il significato fisico del controllo EC si è
quindi studiato il metodo “Speed Gradient”. Tale metodo non è altro che una sorta di controllo
ottimo che minimizza non un indice di costo funzione dello stato e della variabile di controllo ma il
suo gradiente. Si è inizialmente analizzato il comportamento del metodo SG su un sistema
dinamico generico e poi si sono applicati i risultati ottenuti sul pendolo di Furuta sintetizzando la
legge di controllo EC.
Si è quindi simulato il suo comportamento facendone variare i parametri e anche in questo caso,
come nell’LQR, si è evidenziato un trade‐off tra la prontezza del sistema e l’escursione del segnale
di controllo. Inoltre si è anche visto come tale algoritmo risenta notevolmente della presenza di
attrito nel pendolo di Furuta, per valori troppo elevati di coefficienti di attrito, anche con segnali di
attuazione molto grandi, il sistema non riesce a portare il pendolo oltre il valore limite,
menzionato quando si è parlato del controllore LQR, e quindi non permette la conclusione della
fase di SWINGING UP.
Politecnico di Milano
98
Una volta sviluppato il controllore per lo SWINGING UP e quello per la stabilizzazione della
posizione UP si è realizzato un sistema aggregato dei due sottosistemi. Il meccanismo di
regolazione ottenuto è stato testato in ambiente Simulink e si è osservato come esso sia
effettivamente in grado di raggiungere l’obiettivo di controllo prefissato. Durante la prima fase il
sottosistema EC controlla l’oscillazione del pendolo, raggiunto il valore limite sull’angolo un
meccanismo di commutazione attiva il sottosistema LQR che completa, durante la seconda fase
della compensazione, la stabilizzazione della traiettoria facendola convergere alla posizione UP.
Il difetto principale di tale struttura è la necessità di dover sintetizzare due tipologie di controllori
cercando di disaccoppiare il più possibile i due contributi sul pendolo di Furuta durante la fase di
commutazione. Se i due sistemi, per la presenza di disturbi non presi in considerazione,
risentissero l’uno dell’altro durante lo switch, si potrebbero generare dei segnali di controllo tali
da saturare l’attuatore o, nelle peggiore delle ipotesi, da destabilizzare il pendolo di Furuta.
La necessità di sopperire a quest’ultimo difetto ha reso necessario lo studio di un ulteriore sistema
di controllo capace di effettuare contemporaneamente lo SWINGING UP e la stabilizzazione. La
soluzione è stata cercata ragionando sulle forze applicate al pendolo di Furuta e vedendo come sia
solo il contributo gravitazionale a rendere instabile la posizione UP. Una possibile alternativa è
stata quindi cercata sintetizzando un opportuno segnale di controllo capace di “far sentire” al
pendolo una forza di gravità invertita. Inizialmente si è ragionato sul modello approssimato e si è
visto come, con una semplice retroazione non lineare, sia possibile rendere asintoticamente
stabile la posizione UP. Successivamente si è applicato lo stesso ragionamento al modello
completo e il risultato è stato identico. Durante quest’analisi si è visto come una semplice
compensazione di gravità riesca ad invertire lo stato di instabilità del pendolo ma, non essendoci
parametri liberi su cui intervenire, non sia possibile controllare il modo con cui la traiettoria del
pendolo converga alla posizione UP. Si è quindi valutato il contributo di attrito su tale sistema e si
è visto come esso sia in grado di favorire il raggiungimento dell’obiettivo di controllo. Coppie di
attrito basse generano dei moti oscillatori nell’intorno della posizione UP che si smorzano in un
intervallo di tempo proporzionale al modulo stesso della coppia di attrito. Essendo l’attrito un
parametro intrinseco del sistema, non è possibile utilizzarlo per migliorare la risposta del sistema
però è possibile simulare il suo contributo modificando la legge di controllo. Il metodo ricavato è
stato quello di aggiungere al segnale di compensazione una parte proporzionale all’angolo di
rotazione del pendolo e alla sua velocità angolare (regolatore PD). L’introduzione di due parametri
Conclusioni
99
liberi ha quindi reso possibile la sintesi del controllore VG per venire incontro alle specifiche di
progetto sul tempo di assestamento e sulla presenza o meno di oscillazioni nell’intorno della
posizione UP.
Scelti tali parametri è stato quindi possibile simulare il comportamento del sistema VG, applicato
al pendolo di Furuta, e stabilizzare la configurazione in esame. Anche in questo caso si è
riscontrata la perdita di controllo sull’angolo di rotazione del braccio; questo difetto deriva
principalmente dal fatto che la gravità agisce solo sul pendolo (il braccio è vincolato ad un piano
orizzontale) e lo stesso discorso vale anche per il contributo PD.
Il sistema di controllo progettato può essere rivisto da un punto di vista meccanico
schematizzandolo come una sistema molla‐smorzatore che collega il pendolo ad un generico
punto posto sopra la posizione UP. Durante la sintesi del segnale di controllo VG si è quindi
ipotizzato che tale sistema sia soggetto solo all’angolo di rotazione del pendolo e non risenta in
alcun modo dell’angolo di rotazione del braccio. Questa strada è stata generalizzata, introducendo
anche questo secondo contributo, sintetizzando il regolatore VS.
Prima di procedere con la sintesi del segnale di controllo si è voluto verificare se la strada scelta
portasse o meno al controllo contemporaneo dei due angoli di rotazione, modificando il classico
pendolo di Furuta aggiungendo il sistema molla‐smorzatore. Si sono ricavate, sempre tramite la
meccanica Lagrangiana, le equazioni che regolano il moto di questo sistema meccanico e si è
simulato il suo comportamento tramite uno schema Simulink. I risultati ottenuti hanno dimostrato
la validità dell’ipotesi di partenza. Avendo ricavato il set di equazioni del pendolo di Furuta e di
quello modificato si è quindi passati alla sintesi dei segnali di controllo per eguagliare le due
dinamiche. L’algoritmo VS ha quindi reso possibile la realizzazione della fase di SWINGING UP, la
stabilizzazione della posizione UP e la permanenza del braccio in una situazione di quiete.
L’ultima parte del lavoro è stata la stesura dei programmi di simulazione, in ambiente Easy Java
Simulations, in modo da poter verificare sperimentalmente quanto studiato nelle due fasi
precedenti. Il primo programma realizzato è stato il modello del pendolo di Furuta. Utilizzando
questo simulatore è possibile visualizzare sia tramite un animazione 3D che con l’ausilio di grafici
2D, l’evoluzione del pendolo a fronte di qualsiasi tipo di inizializzazione e con qualunque tipo di
settaggio per i parametri quali masse, lunghezze e coefficienti d’attrito.
Politecnico di Milano
100
L’utente sarà quindi in grado di comprendere il concetto di punto di equilibrio e convincersi della
differenza tra un equilibrio stabile ed uno instabile.
Successivamente si sono implementati tre controllori atti a regolare il moto del pendolo di Furuta.
Si è deciso di sviluppare un simulatore per il sistema EC‐LQR, uno per il sistema VG e un altro per il
meccanismo VS. Sfruttando la parametrizzazione offerta da Ejs l’utente sarà ancora una volta in
grado di verificare il comportamento del sistema al variare dei parametri di controllo e quindi
effettuare un analisi comparata delle differenze tra le tre tipologie di controllo messe a
disposizione.
Bibliografia
101
6. Bibliografia
[1] Francesco Fasso (2003‐2004). Meccanica lagrangiana. Appunti del corso “istituzioni di
fisica matematica”.
[2] Benettin, Galgani, Giorgilli (1991‐1992). Appunti di meccanica razionale. Appunti del
corso “meccanica razionale”.
[3] Magnus Gafvert (1998). Modelling the Furuta Pendulum.
[4] Masami Iwase. Modelling of Furuta Pendulum. Technical reports of Iwase laboratory.
[5] Ernest, Horacek. Algorithms for control of a rotating pendulum.
[6] Cristian Secchi. Controllo di sistemi robotici. Appunti del corso “controllo di sistemi
robotici”.
[7] Mariagrazia Dottoli. Regolatori standard PID. Appunti del corso “controlli automatici”.
[8] Mariagrazia Dottoli. Sintesi di regolatori PID con Matlab. Appunti del corso “controlli
automatici”.
[9] Alberto Leva (2000). Introduzione al PID industriale.
[10] Luca Rancati. Sistema di controllo per il pendolo inverso.
[11] De Persis (2004). Controllo ottimo lineare quadratico. Appunti del corso “fondamenti di
automatica”.
[12] Formulazione del problema di controllo ottimo. Appunti del corso “calcolo delle
variazioni e controllo ottimo”.
[13] Luca Rancati. Teoria del controllo ottimo. Appunti del corso “teoria dei sistemi e del
controllo”.
[14] Franco Bernelli Zazzera (2004‐2005). Servosistemi spaziali.
[15] Ploplys, Kawka, Alleyne (2004). Closed loop contro lover wireless networks. IEEE control
systems magazine giugno 2004.
[16] Astrom, Furuta (1996). Swinging up a pendulum by energy control. 13th IFAC world
congress, San Francisco, CA, 1996.
[17] Gordillo, Acosta, Aracil (2003). A new swing‐up law for the Furuta Pendulum.
[18] Acosta, Gordillo, Aracil. Swinging up the Furuta pendulum by the speed gradient method.
[19] Ananjevsky, Efimov, Fradkov, Krivtsov. Resonance curve and speed gradient design of
control algorithms for dissociation of diatomic molecule ensembles.
Politecnico di Milano
102
[20] Fradkov, Andrievsky (2004). Singular perturbations of system controlled by energy speed
gradient method. 43rd IEEE conference on decision and control, Atlantis, Bahamas.
[21] Druzhinina, Moklegaard, Stefanopoulou. Speed gradient approach to longitudinal control
of heavy‐duty vehicles equipped with variable compression brake.
[22] Furuta, Suzuki, Azuma. Virtual Gravity Control for Swing‐Up pendulum.
[23] Francisco Esquembre (2005). Easy java simulations the manual.
[24] Francisco Esquembre (2004). How to use Ejs with Matlab and Simulink.
Indice delle figure
103
7. Indice delle figure Figura 1 : Modello del pendolo di Furuta ............................................................................................ 5 Figura 2 : Script matlab per il calcolo degli autovalori e della risposta libera ................................... 19 Figura 3 : Risposta libera con attrito .................................................................................................. 20 Figura 4 : Risposta libera senza attrito ............................................................................................... 21 Figura 5 : Simulatore matlab del pendolo di Furuta .......................................................................... 25 Figura 6 : Simulatore matlab del pendolo approssimato .................................................................. 25 Figura 7 : Script matlab per l’inizializzazione del pendolo di Furuta ................................................. 26 Figura 8 : Script matlab per l’inizializzazione del pendolo approssimato .......................................... 26 Figura 9 : Script matlab per il calcolo della funzione di trasferimento .............................................. 31 Figura 10 : Sistema di controllo a doppia retroazione ....................................................................... 33 Figura 11 : Sistema di controllo semplificato ..................................................................................... 34 Figura 12 : Diagrammi di Bode del regolatore PID ............................................................................ 35 Figura 13 : Diagramma di Nyquist della funzione d'anello ................................................................ 36 Figura 14 : Risposta all'impulso con il regolatore PID ........................................................................ 37 Figura 15 : Risposta al gradino con il regolatore PID ......................................................................... 37 Figura 16 : Schema simulink del controllo PID ................................................................................... 38 Figura 17 : Simulazione del controllo PID .......................................................................................... 39 Figura 18 : Confronto risposta del controllo PID ............................................................................... 39 Figura 19 : Andamento delle variabili di stato del pendolo di Furuta con il controllo PID ................ 41 Figura 20 : Script matlab del controllo LQR ....................................................................................... 45 Figura 21 : Schema simulink del controllo LQR .................................................................................. 46 Figura 22 : Schema simulink del blocco LQR ...................................................................................... 46 Figura 23 : Simulazione del controllo LQR ......................................................................................... 47 Figura 24 : Simulazione del controllo LQR ......................................................................................... 47 Figura 25 : Simulazione del controllo LQR ......................................................................................... 48 Figura 26 : Andamento delle variabili di stato del pendolo di Furuta con il controllo LQR ............... 49 Figura 27 : Simulazione del controllo LQR saturato ........................................................................... 50 Figura 28 : Schema simulink del controllo energia per il pendolo approssimato ............................. 56 Figura 29 : Schema simulink del blocco Energy Control .................................................................... 56 Figura 30 : Simulazione del controllo EC per il pendolo approssimato ............................................. 57 Figura 31 : Simulazione del controllo EC per il pendolo approssimato ............................................. 58 Figura 32 : Schema simulink del controllo energia per il pendolo di Furuta ..................................... 59 Figura 33 : Simulazione del controllo EC per il pendolo di Furuta ..................................................... 59 Figura 34 : Schema simulink del controllo EC‐LQR ............................................................................ 61 Figura 35 : Simulazione del controllo EC‐LQR .................................................................................... 62 Figura 36 : Schema simulink del controllo VG per il pendolo approssimato ..................................... 64 Figura 37 : Script matlab della funzione di controllo VG per il pendolo approssimato ..................... 64 Figura 38 : Simulazione del controllo VG per il pendolo approssimato ............................................ 65 Figura 39 : Schema simulink del controllo VG per il pendolo di Furuta ............................................ 66 Figura 40 : Script matlab della funzione di controllo VG per il pendolo di Furuta ............................ 66 Figura 41 : Simulazione del controllo VG per il pendolo di Furuta .................................................... 67 Figura 42 : Modello del controllo VS .................................................................................................. 70 Figura 43 : Schema simulink del pendolo di Furuta modificato con il sistema MS ........................... 73 Figura 44 : Simulazione del pendolo di Furuta modificato con il sistema MS ................................... 74 Figura 45 : Simulazione del pendolo di Furuta modificato con il sistema MS ................................... 75 Figura 46 : Simulazione del pendolo di Furuta modificato con il sistema MS ................................... 76
Politecnico di Milano
104
Figura 47 : Schema simulink del controllo VS .................................................................................... 78 Figura 48 : Simulazione del controllo VS ............................................................................................ 78 Figura 49 : Modello Ejs del pendolo di Furuta ................................................................................... 82 Figura 50 : Equazioni Ejs del pendolo di Furuta ................................................................................. 83 Figura 51 : Definizione delle equazioni del pendolo di Furuta .......................................................... 83 Figura 52 : Variabili Ejs del pendolo di Furuta ................................................................................... 84 Figura 53 : Inizializzazione Ejs del pendolo di Furuta......................................................................... 85 Figura 54 : Algoritmo di controllo EC‐LQR ......................................................................................... 86 Figura 55 : Strategia di controllo EC‐LQR ........................................................................................... 87 Figura 56 : Modello Ejs del controllo EC‐LQR ..................................................................................... 88 Figura 57 : Simualzione del controllo EC‐LQR nella fase EC ............................................................... 88 Figura 58 : Simulazione del controllo EC‐LQR nella fase LQR ............................................................ 89 Figura 59 : Algoritmo di controllo VG ................................................................................................ 90 Figura 60 : Strategia di controllo VG .................................................................................................. 90 Figura 61 : Modello Ejs del controllo VG ............................................................................................ 91 Figura 62 : Simulazione del controllo VG ........................................................................................... 91 Figura 63 : Algoritmo di controllo VS ................................................................................................. 92 Figura 64 : Strategia di controllo VS ................................................................................................... 92 Figura 65 : Ridefinizioni delle equazioni del pendolo di Furuta ......................................................... 93 Figura 66 : Modello Ejs del controllo VS ............................................................................................ 94 Figura 67 : Simulazione del controllo VS ............................................................................................ 94