Sei sulla pagina 1di 40

Universita degli Studi di Firenze Facolta di Ingegneria

Corso di laurea in

Ingegneria Elettrica e dellAutomazione

Implementazione IFT per il processo Helicopter Humusoft CE 150

Elaborato di

Baldi Marco Cordelli Alessioi Cheli Andrea

Anno Accademico 2010/2011

Indice
Introduzione 1 Modello Humusoft CE 150 2 IFT - Iterative Feedback Tuning 3 Controllo 4 Implementazione IFT 5 Analisi Sperimentale 6 Miglioramento del controllo Conclusioni A Calcolo derivate del controllo B IFT - Codice per elevazione C IFT - Codice per azimuth D IFT - Codice per disaccoppiamento E Piattaforma ARTIST 1 2 3 4 5 6 7 8 9 11 19 27 35

Elenco delle gure

II

Elenco dei codici


B.1 Main per lelevazione riferito al modello . . . . . . . . . . . . . . . B.2 Funzione per lelevazione riferita al modello . . . . . . . . . . . . 11 12

B.3 Funzione per lelevazione riferita al modello. Variante per la stima dellHessiano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . B.4 Main per elevazione riferita al processo . . . . . . . . . . . . . . . B.5 Function per Elevazione riferita al processo . . . . . . . . . . . . . C.1 Main per lazimuth riferito al modello . . . . . . . . . . . . . . . . C.2 Funzione per lazimuth riferita al modello . . . . . . . . . . . . . . C.3 Funzione per lazimuth riferita al modello. Variante per la stima dellHessiano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C.4 Main per azimuth riferita al processo . . . . . . . . . . . . . . . . C.5 Function per Azimuth riferita al processo . . . . . . . . . . . . . . D.1 Main per il disaccoppiamento riferito al modello . . . . . . . . . . D.2 Funzione per disaccoppiamento riferita al modello . . . . . . . . . D.3 Funzione per disaccoppiamento riferita al modello. Variante per la stima dellHessiano . . . . . . . . . . . . . . . . . . . . . . . . . . D.4 Main per disaccoppiamento riferita al processo . . . . . . . . . . . D.5 Function per disaccoppiamento riferita al processo . . . . . . . . . 29 30 31 21 23 24 27 28 13 15 16 19 20

III

Introduzione

Capitolo 1 Modello Humusoft CE 150


ciao

Capitolo 2 IFT - Iterative Feedback Tuning

Capitolo 3 Controllo

Capitolo 4 Implementazione IFT

Capitolo 5 Analisi Sperimentale

Capitolo 6 Miglioramento del controllo


Anti - Windup

Conclusioni

Appendice A Calcolo derivate del controllo


Per il calcolo delle derivate si ` considerata la funzione di trasferimento clase sica del PID, CP ID (z), moltiplicata per il ltro,F (z), inserito: CP ID (z) =Kp + Ki Ts 1 + z 1 1 z 1 + Kd , 2 1 z 1 Ts 0, 8z 1 F (z) = . 1 0, 2z 1

Essendo i parametri dinteresse i tre guadagni del PID si avranno tre derivate uguali sia per il PID dellelevazione che di azimuth, queste valgono: C = C Kp C = 2Ts z 1 +2Ts z 2 Ki 56z 1 +z 2 C 4z 1 +4z 2 Kd 5Ts +Ts z 1 4z 1 5z 1

Per il disaccoppiamento si ` considerata la funzione, H(z), data da: e H(z) = C(z) F (z) Kdis F (z). La sua derivata rispetto a Kdis vale: (A.1)

8[2Kde + Ts (Kie Ts + 2Kpe )]z 2 + 8[Ts (Kie Ts 2Kpe 4Kde )]z 3 + 16Kde z 4 C = Kdis 25Ts 35Ts z 1 + 11Ts z 2 Ts z 3

APPENDICE A. CALCOLO DERIVATE DEL CONTROLLO

IFT

Nellapplicazione dellIFT sul modello si ` provveduto al calcolo del prodotto e delle derivate prime del controllo. Considerando il prodotto tra CP ID (z) e F (z) si ` ottenuta una matrice 3x3 nella forma: e

d11 C T = d12 d13

d12 d22 d23

d13 d23 d33

Dove vale: d11 = d12 = d13 = d22 = d23 = d33 = 16z 2 , 25 10z 1 + z 2 8Ts z 2 + 8Ts z 3 , 25 35z 1 + 11z 2 z 3 16z 2 16z 3 , 25Ts 10Ts z 1 + Ts z 2 4Ts 2 z 2 + 8Ts 2 z 3 + 8Ts 2 z 4 , 1 21 + z 2 8z 2 + 8z 3 , 25 10z 1 + z 2 16z 2 32z 3 + 16z 4 . 25Ts 2 16Ts 2 z 1 + Ts 2 z 2

I calcoli riportati precedentemente sono risultati utili per determinare la stima del gradiente delluscita per il terzo esperimento.

10

Appendice B IFT - Codice per elevazione


IFT su elevazione - Modello
Codice B.1: Main per lelevazione riferito al modello
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

clear all ; clc ; % % INIZIALIZZAZIONE Ts = 0.005; % % ELEVAZIONE Kpe = 0.30; Kie = 0.095; Kde = 0.27; rho_el = [ Kpe , Kie , Kde ]; % % AZIMUTH Kpa = 0.15; Kia = 0.07; Kda = 0.25; % % DISACCOPPIAMENTO Kdis = -0.51; fprintf ( \ n = = = = = = = = = = = = == = = = = = \ n INIZIALIZZAZIONE \ n = = = = = = = = = = = = = = = = = = = \ n ); fprintf ( \ n Inizializzato con :\ n Kpe = % f \ n Kie = % f \ n Kde = % f \ n , rho_el (1) , rho_el (2) , rho_el (3)); iter_min =1; % iterazione di partenza iter_max =7; % iterazione finale Xvet = 0 : 1 : iter_max ; est_J = 0 : 1 : iter_max ; est_J_regime = 0 : iter_max ; for j = iter_min : ( iter_max +1) [ rho_el ,J , Jr ] = ift_elevazione (j , rho_el , Ts , iter_max ); Kpe = rho_el (1); Kie = rho_el (2); Kde = rho_el (3);

11

APPENDICE B. IFT - CODICE PER ELEVAZIONE


33 34 35 36 37 38 39

IFT

est_J ( j )= J ; est_J_regime ( j )= Jr ; end figure (2) plot ( Xvet , est_J ) figure (3) plot ( Xvet , est_J_regime )

Codice B.2: Funzione per lelevazione riferita al modello


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

function [ rho_el , est_J , est_J_regime ]= ift_elevazione (j , rho_ele , Ts , iter_max ) sim ( modello_taratura ); N = length ( Elevazione . signals . values (: ,1)); % Struttura con tempo dell errore yerr_el = struct ( time , Elevazione . time , signals , struct ( values ,[] , dimensions ,[])); yerr_el . signals . values = Elevazione . signals . values (: ,1) Elevazione . signals . values (: ,2); yerr_el . signals . dimensions = 1; % calcolo di J est_J =( yerr_el . signals . values * yerr_el . signals . values )/(2* N ); fprintf ( \ nJ per % d it \ n ,j -1) est_J N1 = length ( Elevazione . signals . values (2001: N ,1)); A = zeros (2000 ,1); B = ones ( N1 ,1); peso = [ A ; B ]; est_J_regime =(( peso .* yerr_el . signals . values ) * ( peso .* yerr_el . signals . values ))/(2* N1 ); fprintf ( \ n \ nJ_regime per % d it \ n ,j -1) est_J_regime y_2 = gradientey ( yerr_el ); y_3 = hessianoy ( y_2 ); % Calcolo stima del gradiente dell uscita dy_dKpe = filter ([0 4] , [5 -1] , y_2 . signals . values (: ,1)); dy_dKie = filter ([0 2* Ts 2* Ts ] , [5 -6 1] , y_2 . signals . values (: ,1)); dy_dKde = filter ([0 -4 4] , [ -5* Ts Ts ] , y_2 . signals . values (: ,1)); dy_drho = [ dy_dKpe ; dy_dKie ; dy_dKde ]; % CREAZIONE MATRICE DI FILTRI PER HESSIANO DI Y d2y_11 = 2* filter ([0 0 16] , [25 -10 1] , y_3 . signals . values (: ,1)); d2y_12 = 2* filter ([0 0 8* Ts 8* Ts ] , [25 -35 11 -1] , y_3 . signals . values (: ,1)); d2y_13 = 2* filter ([0 0 16 -16] , [25* Ts -10* Ts Ts ] , y_3 . signals . values (: ,1)); d2y_22 = 2* filter ([0 0 4*( Ts ^2) 8*( Ts ^2) 8*( Ts ^2)] , [25 -60 46 -12 1] , y_3 . signals . values (: ,1)); d2y_23 = 2* filter ([0 0 8 8] , [25 -10 1] , y_3 . signals . values (: ,1));

12

APPENDICE B. IFT - CODICE PER ELEVAZIONE


46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97

IFT

d2y_33 = 2* filter ([0 0 16 -32 16] , [25*( Ts ^2) -16*( Ts ^2) ( Ts ^2)] , y_3 . signals . values (: ,1)); % Calcolo del primo addendo per l hessiano di J C11 = d2y_11 * yerr_el . signals . values ; C12 = d2y_12 * yerr_el . signals . values ; C13 = d2y_13 * yerr_el . signals . values ; C22 = d2y_22 * yerr_el . signals . values ; C23 = d2y_23 * yerr_el . signals . values ; C33 = d2y_33 * yerr_el . signals . values ; C =[ C11 , C12 , C13 ; C12 , C22 , C23 ; C13 , C23 , C33 ]; % CALCOLO GRADIENTE DI J dJ_drho = (1/ N )*( yerr_el . signals . values * dy_drho ); fprintf ( \ nGradiente di J per % d it \ n ,j -1) dJ_drho % CALCOLO HESSIANO DI J d2J_drho2 = ( C + dy_drho * dy_drho )/ N ; fprintf ( \ nHessiano di J per % d it \ n ,j -1) d2J_drho2 % PASSO DI AGGIORNAMENTO h = 160/ j ^2; if j < iter_max +1 rho_el = rho_ele - h * ( d2J_drho2 ^( -1) * dJ_drho ) ; % AGGIORNAMENTO DEI PARAMETRI DEL CONTROLLO fprintf ( \ n = = = = = == = = = = = = = = = = = = \ n ITER % d \n = = = = = = = = = = = = = = = = = = = \ n ,j ); fprintf ( Valori controllo per % d iterazione :\ n Kpe = % f \ n Kie = % f \ n Kde = % f \ n ,j , rho_el (1) , rho_el (2) , rho_el (3)); else rho_el = rho_ele ; end end

function [ y_2 ] = gradientey ( yerr_el ) ref_esty = struct ( time , yerr_el . time , signals , struct ( values , - yerr_el . signals . values , dimensions , yerr_el . signals . dimensions )); assignin ( base , ref_esty , ref_esty ); sim ( m o d e l l o _ t a r a t u r a_ 2 e s p ); end function [ y_3 ] = hessianoy ( y_2 ) ref_est2y = struct ( time , y_2 . time , signals , struct ( values , - y_2 . signals . values , dimensions , y_2 . signals . dimensions )); assignin ( base , ref_est2y , ref_est2y ); sim ( m o d e l l o _ t a r a t u r a_ 3 e s p ); end

Codice B.3: Funzione per lelevazione riferita al modello. Variante per la stima 13

APPENDICE B. IFT - CODICE PER ELEVAZIONE dellHessiano


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

IFT

function [ rho_el , est_J , est_J_regime ]= ift_elevazione (j , rho_ele , Ts , iter_max ) sim ( modello_taratura ); N = length ( Elevazione . signals . values (: ,1)); % Struttura con tempo dell errore yerr_el = struct ( time , Elevazione . time , signals , struct ( values ,[] , dimensions ,[])); yerr_el . signals . values = Elevazione . signals . values (: ,1) Elevazione . signals . values (: ,2); yerr_el . signals . dimensions = 1; % calcolo di J est_J =( yerr_el . signals . values * yerr_el . signals . values )/(2* N ); fprintf ( \ nJ per % d it \ n ,j -1) est_J N1 = length ( Elevazione . signals . values (2001: N ,1)); A = zeros (2000 ,1); B = ones ( N1 ,1); peso = [ A ; B ]; est_J_regime =(( peso .* yerr_el . signals . values ) * ( peso .* yerr_el . signals . values ))/(2* N1 ); fprintf ( \ n \ nJ_regime per % d it \ n ,j -1) est_J_regime y_2 = gradientey ( yerr_el ); % Calcolo stima del gradiente dell uscita dy_dKpe = filter ([0 4] , [5 -1] , y_2 . signals . values (: ,1)); dy_dKie = filter ([0 2* Ts 2* Ts ] , [5 -6 1] , y_2 . signals . values (: ,1)); dy_dKde = filter ([0 -4 4] , [ -5* Ts Ts ] , y_2 . signals . values (: ,1)); dy_drho = [ dy_dKpe ; dy_dKie ; dy_dKde ]; % CALCOLO GRADIENTE DI J dJ_drho = (1/ N )*( yerr_el . signals . values * dy_drho ); fprintf ( \ nGradiente di J per % d it \ n ,j -1) dJ_drho % CALCOLO HESSIANO DI J Ri = (1/ N )*( dy_drho * dy_drho ); % PASSO DI AGGIORNAMENTO h = 160/ j ^2; if j < iter_max +1 rho_el = rho_ele - h * ( Ri ^( -1) * dJ_drho ) ; % AGGIORNAMENTO DEI PARAMETRI DEL CONTROLLO fprintf ( \ n = = = = = == = = = = = = = = = = = = \ n \n ITER % d = = = = = = = = = = = = = = = = = = = \ n ,j ); fprintf ( Valori controllo per % d iterazione :\ n Kpe = % f \ n Kie = % f \ n Kde = % f \ n ,j , rho_el (1) , rho_el (2) , rho_el (3)); else rho_el = rho_ele ; end end

14

APPENDICE B. IFT - CODICE PER ELEVAZIONE


55 56 57 58 59 60 61 62

IFT

function [ y_2 ] = gradientey ( yerr_el ) ref_esty = struct ( time , yerr_el . time , signals , struct ( values , - yerr_el . signals . values , dimensions , yerr_el . signals . dimensions )); assignin ( base , ref_esty , ref_esty ); sim ( m o d e l l o _ t a r a t u r a_ 2 e s p ); end

IFT su elevazione - Processo


Codice B.4: Main per elevazione riferita al processo
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

clear all ; clc ; % INIZIALIZZAZIONE Ts = 0.005; % ELEVAZIONE Kpe = 0.3; Kie = 0.095; Kde = 0.27; rho_el = [ Kpe , Kie , Kde ]; % AZIMUTH Kpa = 0.15; Kia = 0.07; Kda = 0.25; % DISACCOPPIAMENTO Kdis = -0.51; fprintf ( \ n = = = = = = = = = = = = = = = = = = = = = = \ n INIZIALIZZAZIONE \ n = = = = = = = = = = = = = = = = = = = = = = \ n ); fprintf ( \ n Inizializzato con :\ n Kpe = % f \ n Kie = % f \ n Kde = % f \ n , rho_el (1) , rho_el (2) , rho_el (3)); iter_min =1; iter_max =2; Xvet = 0 : 1 : iter_max ; est_J = 0 : 1 : iter_max ; est_J_regime = 0 : iter_max ; for j = iter_min : ( iter_max +1) [ rho_el ,J , Jr ] = ift_elevazione (j , rho_el , Ts , iter_max , Kpa , Kia , Kda ); Kpe = rho_el (1); Kie = rho_el (2); Kde = rho_el (3); est_J ( j )= J ; est_J_regime ( j )= Jr ; end figure (2) plot ( Xvet , est_J ) figure (3) plot ( Xvet , est_J_regime )

15

APPENDICE B. IFT - CODICE PER ELEVAZIONE Codice B.5: Function per Elevazione riferita al processo
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

IFT

function [ rho_el , est_J , est_J_regime ] = ift_elevazione (j , rho_ele , Ts , iter_max , Kpa , Kia , Kda ) attesa = input ( Caricare elevazione per la J - esima iter .\ nPer continuare premere c \ n , s ); if isempty ( attesa ) attesa = c ; end load ( strcat ( Ele , int2str (j -1))); Nt = length ( Ele (: ,1)); t = Nt * 0.005; Elevazione = struct ( time ,(0:0.005: t -0.005) , signals , struct ( values , Ele (: ,2:3) , dimensions , 2)); N = length ( Elevazione . signals . values (: ,1)); fprintf ( \ nI dati relativi alla elevazione sono stati caricati \ n ) % Struttura con tempo dell errore yerr_el = struct ( time , Elevazione . time , signals , struct ( values , [] , dimensions , [])); yerr_el . signals . values = Elevazione . signals . values (: ,1) Elevazione . signals . values (: ,2); yerr_el . signals . dimensions = 1; % Calcolo della funzione di costo J est_J = ( yerr_el . signals . values * yerr_el . signals . values )/(2* N ); fprintf ( \ n \ nJ per % d it \ n ,j -1) est_J N1 = length ( Elevazione . signals . values (2001: N ,1)); A = zeros (2000 ,1); B = ones ( N1 ,1); peso = [ A ; B ]; est_J_regime =(( peso .* yerr_el . signals . values ) * ( peso .* yerr_el . signals . values ))/(2* N1 ); fprintf ( \ n \ nJ_regime per % d it \ n ,j -1) est_J_regime Kpe = rho_ele (1); Kie = rho_ele (2); Kde = rho_ele (3); % Trovo le uscite del secondo esperimento y_2 , % risultati utili per il calcolo del gradiente dell uscita i = _primo ; y_2_primo = gradientey ( yerr_el , Kpe , Kie , Kde , Kpa , Kia , Kda ,i , j ); i = _secondo ; y_2_secondo = gradientey ( yerr_el , Kpe , Kie , Kde , Kpa , Kia , Kda ,i , j ); fprintf ( \ nSono stati caricati gli esperimenti gradiente , ora si procede al filtraggio \ n ) % Calcolo la stima del primo gradiente dell uscita dy_dKpe_primo = filter ( [0 4] , [5 -1] , y_2_primo . signals . values (: ,1)); dy_dKie_primo = filter ( [0 2* Ts 2* Ts ] , [5 -6 1] , y_2_primo . signals . values (: ,1)); dy_dKde_primo = filter ( [0 -4 4] , [ -5* Ts Ts ] , y_2_primo . signals . values (: ,1));

16

APPENDICE B. IFT - CODICE PER ELEVAZIONE


55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109

IFT

dy_drho_primo = [ dy_dKpe_primo ; dy_dKie_primo ; dy_dKde_primo ]; % Calcolo la stima del secondo gradiente dell uscita dy_dKpe_secondo = filter ( [0 4] , [5 -1] , y_2_secondo . signals . values (: ,1)); dy_dKie_secondo = filter ( [0 2* Ts 2* Ts ] , [5 -6 1] , y_2_secondo . signals . values (: ,1)); dy_dKde_secondo = filter ( [0 -4 4] , [ -5* Ts Ts ] , y_2_secondo . signals . values (: ,1)); dy_drho_secondo = [ dy_dKpe_secondo ; dy_dKie_secondo ; dy_dKde_secondo ]; % CALCOLO DEL GRADIENTE DI J dJ_drho_primo = (1/ N )*( yerr_el . signals . values * dy_drho_primo ); fprintf ( \ n \ nPrimo gradiente di J per % d it \ n ,j -1) dJ_drho_primo dJ_drho_secondo = (1/ N )*( yerr_el . signals . values * dy_drho_secondo ); fprintf ( \ n \ nSecondo gradiente di J per % d it \ n ,j -1) dJ_drho_secondo % Stima dell hessiano del funzionale di costo J Ri = ( dy_drho_primo * dy_drho_secondo )/ N ; % PASSO DI AGGIORNAMENTO if j == 1 h = 15; else h = 1; end % Aggiornamento if j < iter_max +1 rho_el = rho_ele - h * ((( Ri )^( -1)) * dJ_drho_primo ) ; % AGGIORNAMENTO DEI PARAMETRI DEL CONTROLLO fprintf ( \ n = = = = = == = = = = = = = = = = = = = = = \ n ITER % d \ n = = = = = = = = = = = = = = = = = = = = = = \ n ,j ); fprintf ( Valori controllo per % d iterazione :\ n Kpe = % f \ n Kie = % f \ n Kde = % f \ n , j , rho_el (1) , rho_el (2) , rho_el (3)); else rho_el = rho_ele ; end end function [ y2 ] = gradientey ( yerr_el , Kpel , Kiel , Kdel , Kpaz , Kiaz , Kdaz ,i , j ) ref_esty = struct ( time , yerr_el . time , signals , struct ( values ,- yerr_el . signals . values , dimensions , yerr_el . signals . dimensions )); assignin ( base , ref_esty , ref_esty ); Kpe = Kpel ;

17

APPENDICE B. IFT - CODICE PER ELEVAZIONE


110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134

IFT

Kie = Kiel ; Kde = Kdel ; Kpa = Kpaz ; Kia = Kiaz ; Kda = Kdaz ; Ts = 0.005; d = strcat ( datiy2_ , int2str (j -1) , i ); % Creo file . mat da passare per fare esperimento gradiente save (d , ref_esty , Kpe , Kie , Kde , Kpa , Kia , Kda , Ts ); fprintf ( \ nSalvato file datiy2_ % d % s . mat per esperimento di y2 % s .\ n ,j -1 ,i , i ) attesa = input ( \ nAspettare il file di y2 , premere c per continuare \ n , s ); if isempty ( attesa ) attesa = c ; end % Attesa dei dati u = strcat ( y_2_ , int2str (j -1) , i ); load ( u ); Nt = length ( y_2 (: ,1)); t = Nt * 0.005; % Creo la struttura y2 y2 = struct ( time ,(0:0.005: t -0.005) , signals , struct ( values , y_2 (: ,2) , dimensions , 1)); end

18

Appendice C IFT - Codice per azimuth


IFT su azimuth - Modello
Codice C.1: Main per lazimuth riferito al modello
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

clear all ; clc ; % % INIZIALIZZAZIONE Ts = 0.005; % % ELEVAZIONE Kpe = 3.699038; Kie = 0.019570; Kde = 1.582781; % % AZIMUTH Kpa = 0.15; Kia = 0.07; Kda = 0.25; rho_az = [ Kpa , Kia , Kda ]; % % DISACCOPPIAMENTO Kdis = -0.51; fprintf ( \ n = = = = = = = = = = = = == = = = = = \ n INIZIALIZZAZIONE \ n = = = = = = = = = = = = = = = = = = = \ n ); fprintf ( \ n Inizializzato con :\ n Kpa = % f \ n Kia = % f \ n Kda = % f \ n , rho_az (1) , rho_az (2) , rho_az (3)); iter_min =1; % iterazione di partenza iter_max =7; % iterazione finale Xvet = 0 : 1 : iter_max ; est_J = 0 : 1 : iter_max ; est_J_regime = 0 : iter_max ; for j = iter_min : ( iter_max +1) [ rho_az ,J , Jr ] = ift_azimuth (j , rho_az , Ts , iter_max ); Kpa = rho_az (1); Kia = rho_az (2); Kda = rho_az (3);

19

APPENDICE C. IFT - CODICE PER AZIMUTH


33 34 35 36 37 38 39

IFT

est_J ( j )= J ; est_J_regime ( j )= Jr ; end figure (2) plot ( Xvet , est_J ) figure (3) plot ( Xvet , est_J_regime )

Codice C.2: Funzione per lazimuth riferita al modello


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

function [ rho_az , est_J , est_J_regime ]= ift_azimuth (j , rho_azi , Ts , iter_max ) sim ( modello_taratura ); N = length ( Azimuth . signals . values (: ,1)); % Struttura con tempo dell errore yerr_az = struct ( time , Azimuth . time , signals , struct ( values ,[] , dimensions ,[])); yerr_az . signals . values = Azimuth . signals . values (: ,1) Azimuth . signals . values (: ,2); yerr_az . signals . dimensions = 1; % calcolo di J est_J =( yerr_az . signals . values * yerr_az . signals . values )/(2* N ); fprintf ( \ nJ per % d it \ n ,j -1) est_J N1 = length ( Azimuth . signals . values (2001: N ,1)); A = zeros (2000 ,1); B = ones ( N1 ,1); peso = [ A ; B ]; est_J_regime =(( peso .* yerr_az . signals . values ) * ( peso .* yerr_az . signals . values ))/(2* N1 ); fprintf ( \ n \ nJ_regime per % d it \ n ,j -1) est_J_regime y_2 = gradientey ( yerr_az ); y_3 = hessianoy ( y_2 ); % Calcolo stima del gradiente dell uscita dy_dKpa = filter ([0 4] , [5 -1] , y_2 . signals . values (: ,1)); dy_dKia = filter ([0 2* Ts 2* Ts ] , [5 -6 1] , y_2 . signals . values (: ,1)); dy_dKda = filter ([0 -4 4] , [ -5* Ts Ts ] , y_2 . signals . values (: ,1)); dy_drho = [ dy_dKpa ; dy_dKia ; dy_dKda ]; % CREAZIONE MATRICE DI FILTRI PER HESSIANO DI Y d2y_11 = 2* filter ([0 0 16] , [25 -10 1] , y_3 . signals . values (: ,1)); d2y_12 = 2* filter ([0 0 8* Ts 8* Ts ] , [25 -35 11 -1] , y_3 . signals . values (: ,1)); d2y_13 = 2* filter ([0 0 16 -16] , [25* Ts -10* Ts Ts ] , y_3 . signals . values (: ,1)); d2y_22 = 2* filter ([0 0 4*( Ts ^2) 8*( Ts ^2) 8*( Ts ^2)] , [25 -60 46 -12 1] , y_3 . signals . values (: ,1)); d2y_23 = 2* filter ([0 0 8 8] , [25 -10 1] , y_3 . signals . values (: ,1));

20

APPENDICE C. IFT - CODICE PER AZIMUTH


46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96

IFT

d2y_33 = 2* filter ([0 0 16 -32 16] , [25*( Ts ^2) -16*( Ts ^2) ( Ts ^2)] , y_3 . signals . values (: ,1)); % Calcolo del primo addendo per l hessiano di J C11 = d2y_11 * yerr_az . signals . values ; C12 = d2y_12 * yerr_az . signals . values ; C13 = d2y_13 * yerr_az . signals . values ; C22 = d2y_22 * yerr_az . signals . values ; C23 = d2y_23 * yerr_az . signals . values ; C33 = d2y_33 * yerr_az . signals . values ; C =[ C11 , C12 , C13 ; C12 , C22 , C23 ; C13 , C23 , C33 ]; % CALCOLO GRADIENTE DI J dJ_drho = (1/ N )*( yerr_az . signals . values * dy_drho ); fprintf ( \ nGradiente di J per % d it \ n ,j -1) dJ_drho % CALCOLO HESSIANO DI J d2J_drho2 = ( C + dy_drho * dy_drho )/ N ; fprintf ( \ nHessiano di J per % d it \ n ,j -1) d2J_drho2 % PASSO DI AGGIORNAMENTO h = 7/ j ; if j < iter_max +1 rho_az = rho_azi - h * ( d2J_drho2 ^( -1) * dJ_drho ) ; % AGGIORNAMENTO DEI PARAMETRI DEL CONTROLLO fprintf ( \ n = = = = = == = = = = = = = = = = = = \ n ITER % d \n = = = = = = = = = = = = = = = = = = = \ n ,j ); fprintf ( Valori controllo per % d iterazione :\ n Kpa = % f \ n Kia = % f \ n Kda = % f \ n ,j , rho_az (1) , rho_az (2) , rho_az (3)); else rho_az = rho_azi ; end end function [ y_2 ] = gradientey ( yerr_az ) ref_esty = struct ( time , yerr_az . time , signals , struct ( values , - yerr_az . signals . values , dimensions , yerr_az . signals . dimensions )); assignin ( base , ref_esty , ref_esty ); sim ( m o d e l l o _ t a r a t u r a_ 2 e s p ); end function [ y_3 ] = hessianoy ( y_2 ) ref_est2y = struct ( time , y_2 . time , signals , struct ( values , - y_2 . signals . values , dimensions , y_2 . signals . dimensions )); assignin ( base , ref_est2y , ref_est2y ); sim ( m o d e l l o _ t a r a t u r a_ 3 e s p ); end

Codice C.3: Funzione per lazimuth riferita al modello. Variante per la stima

21

APPENDICE C. IFT - CODICE PER AZIMUTH dellHessiano


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

IFT

function [ rho_az , est_J , est_J_regime ]= ift_azimuth (j , rho_azi , Ts , iter_max ) sim ( modello_taratura ); N = length ( Azimuth . signals . values (: ,1)); % Struttura con tempo dell errore yerr_az = struct ( time , Azimuth . time , signals , struct ( values ,[] , dimensions ,[])); yerr_az . signals . values = Azimuth . signals . values (: ,1) Azimuth . signals . values (: ,2); yerr_az . signals . dimensions = 1; % calcolo di J est_J =( yerr_az . signals . values * yerr_az . signals . values )/(2* N ); fprintf ( \ nJ per % d it \ n ,j -1) est_J N1 = length ( Azimuth . signals . values (2001: N ,1)); A = zeros (2000 ,1); B = ones ( N1 ,1); peso = [ A ; B ]; est_J_regime =(( peso .* yerr_az . signals . values ) * ( peso .* yerr_az . signals . values ))/(2* N1 ); fprintf ( \ n \ nJ_regime per % d it \ n ,j -1) est_J_regime y_2 = gradientey ( yerr_az ); % Calcolo stima del gradiente dell uscita dy_dKpa = filter ([0 4] , [5 -1] , y_2 . signals . values (: ,1)); dy_dKia = filter ([0 2* Ts 2* Ts ] , [5 -6 1] , y_2 . signals . values (: ,1)); dy_dKda = filter ([0 -4 4] , [ -5* Ts Ts ] , y_2 . signals . values (: ,1)); dy_drho = [ dy_dKpa ; dy_dKia ; dy_dKda ]; % CALCOLO GRADIENTE DI J dJ_drho = (1/ N )*( yerr_az . signals . values * dy_drho ); fprintf ( \ nGradiente di J per % d it \ n ,j -1) dJ_drho % CALCOLO HESSIANO DI J Ri = (1/ N )*( dy_drho * dy_drho ); % PASSO DI AGGIORNAMENTO h = 7/ j ; if j < iter_max +1 rho_az = rho_azi - h * ( Ri ^( -1) * dJ_drho ) ; % AGGIORNAMENTO DEI PARAMETRI DEL CONTROLLO fprintf ( \ n = = = = = == = = = = = = = = = = = = \ n \n ITER % d = = = = = = = = = = = = = = = = = = = \ n ,j ); fprintf ( Valori controllo per % d iterazione :\ n Kpa = % f \ n Kia = % f \ n Kda = % f \ n ,j , rho_az (1) , rho_az (2) , rho_az (3)); else rho_az = rho_azi ; end end

22

APPENDICE C. IFT - CODICE PER AZIMUTH


55 56 57 58 59 60 61

IFT

function [ y_2 ] = gradientey ( yerr_az ) ref_esty = struct ( time , yerr_az . time , signals , struct ( values , - yerr_az . signals . values , dimensions , yerr_az . signals . dimensions )); assignin ( base , ref_esty , ref_esty ); sim ( m o d e l l o _ t a r a t u r a_ 2 e s p ); end

IFT su azimuth - Processo


Codice C.4: Main per azimuth riferita al processo
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

clear all ; clc ; % INIZIALIZZAZIONE Ts = 0.005; % ELEVAZIONE Kpe = 0.568145; Kie = 0.090525; Kde = 0.474374; % AZIMUTH Kpa = 0.15; Kia = 0.07; Kda = 0.25; rho_az = [ Kpa , Kia , Kda ]; % DISACCOPPIAMENTO Kdis = -0.51; fprintf ( \ n = = = = = = = = = = = = == = = = = = \ n INIZIALIZZAZIONE \ n = = = = = = = = = = = = = = = = = = = \ n ); fprintf ( \ n Inizializzato con :\ n Kpa = % f \ n Kia = % f \ n Kda = % f \ n , rho_az (1) , rho_az (2) , rho_az (3)); iter_min =1; iter_max =2; Xvet = 0 : 1 : iter_max ; est_J = 0 : 1 : iter_max ; est_J_regime = 0 : iter_max ; for j = iter_min : ( iter_max +1) [ rho_az ,J , Jr ] = ift_azimuth (j , rho_az , Ts , iter_max , Kpe , Kie , Kde ); Kpa = rho_az (1); Kia = rho_az (2); Kda = rho_az (3); est_J ( j )= J ; est_J_regime ( j )= Jr ; end figure (2) plot ( Xvet , est_J ) figure (3) plot ( Xvet , est_J_regime )

23

APPENDICE C. IFT - CODICE PER AZIMUTH Codice C.5: Function per Azimuth riferita al processo
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

IFT

function [ rho_az , est_J , est_J_regime ]= ift_azimuth (j , rho_azi , Ts , iter_max , Kpe , Kie , Kde ) attesa = input ( Caricare azimuth per la J - esima iter . \ nPer continuare premere c \ n , s ); if isempty ( attesa ) attesa = c ; end load ( strcat ( Azi , int2str (j -1))); Nt = length ( Ele (: ,1)); t = Nt * 0.005; Elevazione = struct ( time ,(0:0.005: t -0.005) , signals , struct ( values , Ele (: ,2:3) , dimensions , 2)); Azimuth = struct ( time ,(0:0.005:89.995) , signals , struct ( values , Azi (: ,2:3) , dimensions , 2)); N = length ( Azimuth . signals . values (: ,1)); attesa = input ( Per continuare premere c \ n , s ); if isempty ( attesa ) attesa = c ; end % Creo la struttura con tempo dell errore % fra azimuth effettiva e riferimento yerr_az = struct ( time , Azimuth . time , signals , struct ( values , [] , dimensions , [])); yerr_az . signals . values = Azimuth . signals . values (: ,1) Azimuth . signals . values (: ,2); yerr_az . signals . dimensions = 1; % Calcolo della funzione di costo J est_J = ( yerr_az . signals . values * yerr_az . signals . values )/(2* N ); fprintf ( \ n \ nJ per % d it \ n ,j -1) est_J N1 = length ( Azimuth . signals . values (2001: N ,1)); A = zeros (2000 ,1); B = ones ( N1 ,1); peso = [ A ; B ]; est_J_regime =(( peso .* yerr_az . signals . values ) * ( peso .* yerr_az . signals . values ))/(2* N1 ); fprintf ( \ n \ nJ_regime per % d it \ n ,j -1) est_J_regime Kpa = rho_azi (1); Kia = rho_azi (2); Kda = rho_azi (3); % Trovo y_2 , risultato utile per il calcolo % del gradiente dell uscita % -> i identifica l esperimento per il gradiente % -> j -1 ` il numero delll iterazione e i = _primo ; y_2_primo = gradientey ( yerr_az , Kpe , Kie , Kde , Kpa , Kia , Kda ,i , j ); i = _secondo ;

24

APPENDICE C. IFT - CODICE PER AZIMUTH


55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109

IFT

y_2_secondo = gradientey ( yerr_az , Kpe , Kie , Kde , Kpa , Kia , Kda ,i , j ); % Calcolo stima del primo gradiente dell uscita dy_dKpa_primo = filter ([0 4] , [5 -1] , y_2_primo . signals . values (: ,1)); dy_dKia_primo = filter ([0 2* Ts 2* Ts ] , [5 -6 1] , y_2_primo . signals . values (: ,1)); dy_dKda_primo = filter ([0 -4 4] , [ -5* Ts Ts ] , y_2_primo . signals . values (: ,1)); % Matrice 3 righe ed N colonne dy_drho_primo = [ dy_dKpa_primo ; dy_dKia_primo ; dy_dKda_primo ]; % Calcolo stima del secondo gradiente dell uscita dy_dKpa_secondo = filter ([0 4] ,[5 -1] , y_2_secondo . signals . values (: ,1)); dy_dKia_secondo = filter ([0 2* Ts 2* Ts ] , [5 -6 1] , y_2_secondo . signals . values (: ,1)); dy_dKda_secondo = filter ([0 -4 4] , [ -5* Ts Ts ] , y_2_secondo . signals . values (: ,1)); dy_drho_secondo = [ dy_dKpa_secondo ; dy_dKia_secondo ; dy_dKda_secondo ]; % CALCOLO DEL GRADIENTE DI J , % sar` un vettore a 3 colonne . a dJ_drho_primo = (1/ N )*( yerr_az . signals . values * dy_drho_primo ); % Stampa il gradiente di J fprintf ( \ n \ nPrimo gradiente di J per % d it \ n ,j -1) dJ_drho_primo dJ_drho_secondo = (1/ N )*( yerr_az . signals . values * dy_drho_secondo ); fprintf ( \ n \ nSecondo gradiente di J per % d it \ n ,j -1) dJ_drho_secondo dJ_drho_media = ( dJ_drho_primo + dJ_drho_secondo )/2; fprintf ( \ n \ nMedia fra i gradienti di J per % d it \ n ,j -1) dJ_drho_media % PASSO DI AGGIORNAMENTO if j ==1 h = 0.5; else h = 0.2; end Ri = ( dy_drho_primo * dy_drho_secondo )/ N ; if j < iter_max +1 % AGGIORNAMENTO DEI PARAMETRI DEL CONTROLLO rho_az = rho_azi - h * ((( Ri )^( -1)) * dJ_drho_primo ) ; % Stampa parametri aggiornati fprintf ( Valori controllo per % d iterazione : \ n Kpa = % f \ n Kia = % f \ n Kda = % f \ n ,j , rho_az (1) , rho_az (2) , rho_az (3)); else rho_az = rho_azi ; end end function [ y2 ] = gradientey ( yerr_az , Kpel , Kiel , Kdel , Kpaz , Kiaz , Kdaz , i , j )

25

APPENDICE C. IFT - CODICE PER AZIMUTH


110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135

IFT

ref_esty = struct ( time , yerr_az . time , signals , struct ( values ,- yerr_az . signals . values , dimensions , yerr_az . signals . dimensions )); assignin ( base , ref_esty , ref_esty ); Kpe = Kpel ; Kie = Kiel ; Kde = Kdel ; Kpa = Kpaz ; Kia = Kiaz ; Kda = Kdaz ; Ts = 0.005; t = strcat ( datiy2_ , int2str (j -1) , i ); save (t , ref_esty , Kpe , Kie , Kde , Kpa , Kia , Kda , Ts ); fprintf ( \ nSalvato file datiy2_ % d % s . mat per esperimento di y2 % s .\ n ,j -1 ,i , i ) attesa = input ( \ nAspettare il file di y2 , premere c per continuare \ n , s ); if isempty ( attesa ) attesa = c ; end u = strcat ( y_2_ , int2str (j -1) , i ); load ( u ); y2 = struct ( time ,(0:0.005:89.995) , signals , struct ( values , y_2 (: ,2) , dimensions , 1)); end

26

Appendice D IFT - Codice per disaccoppiamento


IFT su disaccoppiamento - Modello
Codice D.1: Main per il disaccoppiamento riferito al modello
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

clear all ; clc ; % % INIZIALIZZAZIONE Ts = 0.005; % % ELEVAZIONE Kpe = 3.699038; Kie = 0.019570; Kde = 1.582781; % % AZIMUTH Kpa = 2.247885; Kia = 0.056408; Kda = 1.570027; % % DISACCOPPIAMENTO Kdis = -0.51; fprintf ( \ n = = = = = = = = = = = = == = = = = = \ n INIZIALIZZAZIONE \ n = = = = = = = = = = = = = = = = = = = \ n ); fprintf ( \ n Inizializzato con :\ n Kdis = % f \ n , Kdis ); iter_min =1; % iterazione di partenza iter_max =7; % iterazione finale Xvet = 0 : 1 : iter_max ; est_J = 0 : 1 : iter_max ; est_J_regime = 0 : iter_max ; for j = iter_min : ( iter_max +1) [ Kdis ,J , Jr ] = i f t _ d i sa c c o p p i a m e n t o (j , Kpe , Kie , Kde , Kdis , Ts , iter_max ); est_J ( j )= J ; est_J_regime ( j )= Jr ;

27

APPENDICE D. IFT - CODICE PER DISACCOPPIAMENTO


30 31 32 33 34

IFT

end figure (2) plot ( Xvet , est_J ) figure (3) plot ( Xvet , est_J_regime )

Codice D.2: Funzione per disaccoppiamento riferita al modello


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

function [ Kdis , est_J , est_J_regime ]= i f t _ d i s a c c o p p i a m e n t o (j , Kpe , Kie , Kde , Kdis_in , Ts , iter_max ) sim ( modello_taratura ); N = length ( Azimuth . signals . values (: ,1)); % Struttura con tempo dell errore yerr_az = struct ( time , Azimuth . time , signals , struct ( values ,[] , dimensions ,[])); yerr_az . signals . values = Azimuth . signals . values (: ,1) Azimuth . signals . values (: ,2); yerr_az . signals . dimensions = 1; % calcolo di J est_J =( yerr_az . signals . values * yerr_az . signals . values )/(2* N ); fprintf ( \ nJ per % d it \ n ,j -1) est_J N1 = length ( Azimuth . signals . values (2001: N ,1)); A = zeros (2000 ,1); B = ones ( N1 ,1); peso = [ A ; B ]; est_J_regime =(( peso .* yerr_az . signals . values ) * ( peso .* yerr_az . signals . values ))/(2* N1 ); fprintf ( \ n \ nJ_regime per % d it \ n ,j -1) est_J_regime y_2 = gradientey ( yerr_az ); y_3 = hessianoy ( y_2 ); % Calcolo stima del gradiente dell uscita dy_dKdis = filter ([0 0 (16* Kde +8* Ts *( Kie * Ts +2* Kpe )) (8* Ts *( Kie * Ts -2* Kpe ) -32* Kde ) 16* Kde ] , [25* Ts -35* Ts 11* Ts - Ts ] , y_2 . signals . values (: ,1)); % HESSIANO DI Y d2y_dKdis2 =2* filter ([0 0 0 0 64*(4*( Kde ^2)+4* Kde * Ts * ( Kie * Ts +2* Kpe )+( Ts ^2)*( Kie * Ts +2* Kpe )^2) 128*(2* Kde + Ts *( Kie * Ts +2* Kpe ))* ( Ts *( Kie * Ts -2* Kpe ) -4* Kde ) 64*(24*( Kde ^2)+4* Kde * Ts * (6* Kpe - Kie * Ts )+( Ts ^2)*( Kie * Ts -2* Kpe )^2) 256* Kde *( Ts *( Kie * Ts -2* Kpe ) -4* Kde ) 256*( Kde ^2)] , [625*( Ts ^2) -1750*( Ts ^2) 1775*( Ts ^2) -820*( Ts ^2) +191*( Ts ^2) -22*( Ts ^2) ( Ts ^2)] , y_3 . signals . values (: ,1) ); % Calcolo primo addendo dell hessiano di J C = d2y_dKdis2 * yerr_az . signals . values ; % CALCOLO GRADIENTE DI J dJ_dKdis = (1/ N )*( yerr_az . signals . values * dy_dKdis );

28

APPENDICE D. IFT - CODICE PER DISACCOPPIAMENTO


48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

IFT

fprintf ( \ nGradiente di J per % d it \ n ,j -1) dJ_dKdis % CALCOLO HESSIANO DI J d2J_dKdis2 = ( C + dy_dKdis * dy_dKdis )/ N ; fprintf ( \ nHessiano di J per % d it \ n ,j -1) d2J_dKdis2 % PASSO DI AGGIORNAMENTO h = 30/ j ^2; if j < iter_max +1 Kdis = Kdis_in - h * ((( d2J_dKdis2 )^( -1)) * dJ_dKdis ) ; % AGGIORNAMENTO DEI PARAMETRI DEL CONTROLLO fprintf ( \ n = = = = = == = = = = = = = = = = = = \ n ITER % d \n = = = = = = = = = = = = = = = = = = = \ n ,j ); fprintf ( Valori controllo per % d iterazione :\ n Kpa = % f \ n , j , Kdis ); else Kdis = Kdis_in ; end end function [ y_2 ] = gradientey ( yerr_az ) ref_esty = struct ( time , yerr_az . time , signals , struct ( values , - yerr_az . signals . values , dimensions , yerr_az . signals . dimensions )); assignin ( base , ref_esty , ref_esty ); sim ( m o d e l l o _ t a r a t u r a_ 2 e s p ); end function [ y_3 ] = hessianoy ( y_2 ) ref_est2y = struct ( time , y_2 . time , signals , struct ( values , - y_2 . signals . values , dimensions , y_2 . signals . dimensions )); assignin ( base , ref_est2y , ref_est2y ); sim ( m o d e l l o _ t a r a t u r a_ 3 e s p ); end

Codice D.3: Funzione per disaccoppiamento riferita al modello. Variante per la stima dellHessiano
1 2 3 4 5 6 7 8 9 10 11 12 13

function [ Kdis , est_J , est_J_regime ]= i f t _ d i s a c c o p p i a m e n t o (j , Kpe , Kie , Kde , Kdis_in , Ts , iter_max ) sim ( modello_taratura ); N = length ( Azimuth . signals . values (: ,1)); % Struttura con tempo dell errore yerr_az = struct ( time , Azimuth . time , signals , struct ( values ,[] , dimensions ,[])); yerr_az . signals . values = Azimuth . signals . values (: ,1) Azimuth . signals . values (: ,2); yerr_az . signals . dimensions = 1; % calcolo di J

29

APPENDICE D. IFT - CODICE PER DISACCOPPIAMENTO


14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

IFT

est_J =( yerr_az . signals . values * yerr_az . signals . values )/(2* N ); fprintf ( \ nJ per % d it \ n ,j -1) est_J N1 = length ( Azimuth . signals . values (2001: N ,1)); A = zeros (2000 ,1); B = ones ( N1 ,1); peso = [ A ; B ]; est_J_regime =(( peso .* yerr_az . signals . values ) * ( peso .* yerr_az . signals . values ))/(2* N1 ); fprintf ( \ n \ nJ_regime per % d it \ n ,j -1) est_J_regime y_2 = gradientey ( yerr_az ); % Calcolo stima del gradiente dell uscita dy_dKdis = filter ([0 0 (16* Kde +8* Ts *( Kie * Ts +2* Kpe )) (8* Ts *( Kie * Ts -2* Kpe ) -32* Kde ) 16* Kde ] , [25* Ts -35* Ts 11* Ts - Ts ] , y_2 . signals . values (: ,1)); % CALCOLO GRADIENTE DI J dJ_dKdis = (1/ N )*( yerr_az . signals . values * dy_dKdis ); fprintf ( \ nGradiente di J per % d it \ n ,j -1) dJ_dKdis % CALCOLO HESSIANO DI J Ri = (1/ N )*( dy_drho * dy_drho ); % PASSO DI AGGIORNAMENTO h = 30/ j ^2; if j < iter_max +1 Kdis = Kdis_in - h * ((( Ri )^( -1)) * dJ_dKdis ) ; % AGGIORNAMENTO DEI PARAMETRI DEL CONTROLLO fprintf ( \ n = = = = = == = = = = = = = = = = = = \ n ITER % d \n = = = = = = = = = = = = = = = = = = = \ n ,j ); fprintf ( Valori controllo per % d iterazione :\ n Kpa = % f \ n , j , Kdis ); else Kdis = Kdis_in ; end end function [ y_2 ] = gradientey ( yerr_az ) ref_esty = struct ( time , yerr_az . time , signals , struct ( values , - yerr_az . signals . values , dimensions , yerr_az . signals . dimensions )); assignin ( base , ref_esty , ref_esty ); sim ( m o d e l l o _ t a r a t u r a_ 2 e s p ); end

IFT su disaccoppiamento - Processo


Codice D.4: Main per disaccoppiamento riferita al processo
1 2

clear all ; clc ;

30

APPENDICE D. IFT - CODICE PER DISACCOPPIAMENTO


3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

IFT

% INIZIALIZZAZIONE Ts = 0.005; % ELEVAZIONE Kpe = 0.568145; Kie = 0.090525; Kde = 0.474374; % AZIMUTH Kpa = 0.259340; Kia = 0.068118; Kda = 0.258119; % DISACCOPPIAMENTO Kdis = -0.51; fprintf ( \ n = = = = = = = = = = = = == = = = = = \ n INIZIALIZZAZIONE \ n = = = = = = = = = = = = = = = = = = = \ n ); fprintf ( \ n Inizializzato con :\ n Kdis = % f \ n , Kdis ); iter_min =1; iter_max =2; Xvet = 0 : 1 : iter_max ; est_J = 0 : 1 : iter_max ; est_J_regime = 0 : iter_max ; for j = iter_min : ( iter_max +1) [ Kdis ,J , Jr ] = ift_1_dis (j , Kpe , Kie , Kde , Kdis , Ts , iter_max , Kpa , Kia , Kda ); est_J ( j ) = J ; est_J_regime ( j )= Jr ; end figure (2) plot ( Xvet , est_J ) figure (3) plot ( Xvet , est_J_regime )

Codice D.5: Function per disaccoppiamento riferita al processo


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

function [ Kdis , est_J , est_J_regime ] = ift_1_dis (j , Kpe , Kie , Kde , Kdis_in , Ts , iter_max , Kpa , Kia , Kda ) attesa = input ( Caricare elevazione per la J - esima iter . \ nPer continuare premere c \ n , s ); if isempty ( attesa ) attesa = c ; end % Con questo comando viene caricato il file Ele0 . mat e % Azi0 . mat % Contiene una variabile Ele con i dati sull elevazione % ed Azi con dati dell azimuth % NOTA : ogni iterazione viene caratterizzata da un numero % che la identifica load ( strcat ( Azi , int2str (j -1))); load ( strcat ( Ele , int2str (j -1))); % Creo l asse dei tempi Ne = length ( Ele (: ,1)); Na = length ( Azi (: ,1));

31

APPENDICE D. IFT - CODICE PER DISACCOPPIAMENTO


22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

IFT

if Ne ~= Na fprintf ( \ nProblema sul numero di campioni dei dati \ n ) else t = Na * 0.005; end % Creo una struttura elevazione Azimuth = struct ( time ,(0:0.005: t -0.005) , signals , struct ( values , Azi (: ,2:3) , dimensions , 2)); Elevazione = struct ( time ,(0:0.005: t -0.005) , signals , struct ( values , Ele (: ,2:3) , dimensions , 2)); N = length ( Azimuth . signals . values (: ,1)); fprintf ( \ nI dati relativi alla elevazione sono stati caricati \ n ) attesa = input ( Per continuare premere c \ n , s ); if isempty ( attesa ) attesa = c ; end % Creo la struttura con tempo dell errore fra elevazione % effettiva e riferimento yerr_az = struct ( time , Azimuth . time , signals , struct ( values , [] , dimensions , [])); yerr_az . signals . values = Azimuth . signals . values (: ,1) Azimuth . signals . values (: ,2); yerr_az . signals . dimensions = 1; % Calcolo della funzione di costo J est_J = ( yerr_az . signals . values * yerr_az . signals . values )/(2* N ); % Stampa della funzione di costo fprintf ( \ n \ nJ_regime per % d it \ n ,j -1) est_J N1 = length ( Azimuth . signals . values (2001: N ,1)); A = zeros (2000 ,1); B = ones ( N1 ,1); peso = [ A ; B ]; est_J_regime =(( peso .* yerr_az . signals . values ) * ( peso .* yerr_az . signals . values ))/(2* N1 ); fprintf ( \ n \ nJ per % d it \ n ,j -1) est_J_regime % Trovo y_2 , risultato utile per il calcolo del gradiente % -> i identifica l esperimento per il gradiente % -> j -1 ` il numero delll iterazione e i = _primo ; y_2_primo = gradientey ( yerr_az , Kpe , Kie , Kde , Kpa , Kia , Kda ,i , j ); i = _secondo ; y_2_secondo = gradientey ( yerr_az , Kpe , Kie , Kde , Kpa , Kia , Kda ,i , j ); fprintf ( \ nSono stati caricati gli esperimenti gradiente , ora si procede al filtraggio \ n ) dy_dKdis_primo = filter ([0 0 (16* Kde +8* Ts *( Kie * Ts +2* Kpe )) (8* Ts *( Kie * Ts -2* Kpe ) -32* Kde ) 16* Kde ] ,

32

APPENDICE D. IFT - CODICE PER DISACCOPPIAMENTO


77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131

IFT

[25* Ts -35* Ts 11* Ts - Ts ] , y_2_primo . signals . values (: ,1)); dy_dKdis_secondo = filter ([0 0 (16* Kde +8* Ts *( Kie * Ts +2* Kpe )) (8* Ts *( Kie * Ts -2* Kpe ) -32* Kde ) 16* Kde ] , [25* Ts -35* Ts 11* Ts - Ts ] , y_2_secondo . signals . values (: ,1)); % CALCOLO DEL GRADIENTE DI J , sar` un vettore a 3 colonne a dJ_dKdis = (1/ N )*( yerr_az . signals . values * dy_dKdis_primo ); fprintf ( \ n \ nGradiente di J per % d it \ n ,j -1) dJ_dKdis % Stima dell hessiano del funzionale di costo J Ri = ( dy_dKdis_primo * dy_dKdis_secondo )/ N ; % PASSO DI AGGIORNAMENTO if j == 1 || j ==2 h = 30; else h =5; end % Aggiornamento if j < iter_max +1 % blocco per far stampare gli ultimi dati Kdis = Kdis_in - h * ((( Ri )^( -1)) * dJ_dKdis ) ; % AGGIORNAMENTO DEI PARAMETRI DEL CONTROLLO fprintf ( \ n = = = = = == = = = = = = = = = = = = = = = \ n ITER % d \ n = = = = = = = = = = = = = = = = = = = = = = \ n ,j ); fprintf ( Valori controllo per % d iterazione : \ n Kdis = % f \ n ,j , Kdis ); else Kdis = Kdis_in ; % nell ultima it non aggiorna i parametri end end function [ y2 ] = gradientey ( yerr_az , Kpel , Kiel , Kdel , Kpaz , Kiaz , Kdaz , i , j ) ref_esty = struct ( time , yerr_az . time , signals , struct ( values , - yerr_az . signals . values , dimensions , yerr_az . signals . dimensions )); assignin ( base , ref_esty , ref_esty ); Kpe = Kpel ; Kie = Kiel ; Kde = Kdel ; Kpa = Kpaz ; Kia = Kiaz ; Kda = Kdaz ; Ts = 0.005; d = strcat ( datiy2_ , int2str (j -1) , i ); % Creo file . mat da passare per fare esperimento gradiente save (d , ref_esty , Kpe , Kie , Kde , Kpa , Kia , Kda , Ts ); fprintf ( \ nSalvato file datiy2_ % d % s . mat per esperimento di y2 % s .\ n ,j -1 ,i , i ) attesa = input ( \ nAspettare il file di y2 , premere c per continuare \ n , s ); if isempty ( attesa ) attesa = c ; end % Attesa dei dati

33

APPENDICE D. IFT - CODICE PER DISACCOPPIAMENTO


132 133 134 135 136 137 138 139 140 141 142

IFT

% NOTA : i dati devono essere passati come y _ 2 _ n i t _ n . esp , con % all interno una variabile y_2 con i dati u = strcat ( y_2_ , int2str (j -1) , i ); load ( u ); Nt = length ( y_2 (: ,1)); t = Nt * 0.005; % Creo la struttura y2 che utilizzeremo y2 = struct ( time ,(0:0.005: t -0.005) , signals , struct ( values , y_2 (: ,2) , dimensions , 1)); end end

34

Appendice E Piattaforma ARTIST


La piattaforma ARTIST ` un sistema che permette allutente di interfacciarsi e con una scheda real-time dedicata al controllo e allacquisizione dati. Tale scheda interagisce col processo che deve essere controllato in tempo reale. Oltre allinterfacciamento con il sistema da controllare, ARTIST riceve il controllo da applicare al processo sotto forma di modello del controllore e parametri ad esso relativi; questi due le di tipo .mdl (modello) e .mat (dati) che sono generati rispettivamente da Simulink e Matlab, vengono successivamente processati dal RealTime toolbox di Matlab e quindi convertiti dal sistema in codice C. Caricato il controllo del processo ` poi possibile metterlo in funzione mediante e unapplicazione Java che, se impostata a dovere, permette di cambiare on-line i parametri del controllo, visualizzare le forme donda nei punti del controllore in cui siano stati inseriti, in Simulink, degli scope, ed inne, salvare le forme donda stesse. Tali segnali sono per` resi disponibili in forma di vettori di dati tabulati in un o le di testo; si rende quindi necessaria una manipolazione degli stessi mediante Matlab che, individuando la tabulazione, permette di inserire questi dati in una matrice con tante colonne quanti sono i segnali entranti nello scope (pi` una come u indice) e tante righe quanti sono i campioni.

35

Bibliograa
[1] Controllo e simulazione di un modello di elicottero in realt virtuale, a Simone Brilli, (Universit degli studi di Firenze, Facolt di Ingegneria, 2010). a a [2] Iterative Feedback Tuning, H akan Hjalmarsson, (Department of Signals, Sensors and Systems, The Royal Institute of Technology, S-100 44 Stockholm, Sweden, 2002). [3] Ecient Tuning of Linear Multivariable Controllers Using Iterative Feedback Tuning, H akan Hjalmarsson, (Department of Signals, Sensors and Systems, The Royal Institute of Technology, S-100 44 Stockholm, Sweden, 1999). [4] Unbiased Estimation of the Hessian for Iterative Feedback Tuning (IFT), Gabriel Solari and Michel Gevers, (Center for Systems Engineering and Applied Mechanics (CESAME) Universite Catholique de Louvain, Batiment Euler B-1348 Louvain-la-Neuve, Belgium, 2004). [5] Fondamenti di Controlli Automatici, Paolo Bolzern, Riccardo Scattolini, Nicola Schiavoni, (McGraw-Hill, 2008). [6] Appunti del corso: Laboratorio di Automatica e Azionamenti C.I., Giorgio Battistelli, Michele Basso, (2011).

36