Solver: Algoritmo Gradencialbibing.us.es/proyectos/abreproy/5123/descargar... · 0 es la denominada...

Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768

Dpto. Ing. de Sistemas y Automática

Universidad de Sevilla

Solver: Algoritmo Gradencial

Proyecto Fin de Carrera


Dpto. Ing. de Sistemas y Automática Página 147 Ramón Jesús Cuesta Pérez

Capítulo 7

Solver: Algoritmo Gradencial


Ramón Jesús Cuesta Pérez

Curso 2011/2012




7.1 Formulación teórica

En este capítulo vamos a programar un

resolver el siguiente problema QP:

u* =

Uno de los fundamentos de este algoritmo es, al igual que ocurría con el de Jacobi,

pasar de resolver un problema N

dimensionales. Sin embargo utilizaremos métodos gradenciales para llegar al óptimo.

Antes de entrar en la formulación teórica del algoritmo conviene presentar una serie de

conceptos matemáticos que van a ser fundamentales para el poster

algoritmo. Para ello emplearemos una nomenclatura matemática clásica:

Sea f (z) una función real convexa

en C, donde C ⊆ RN es un conjunto cerrado y convexo. El problema de optimización

que queremos resolver es el siguiente:

Al ser f diferenciable en C,

f (z) ≥ f (

Lo cual se puede demostrar fácilmente mediante el desarrollo en serie de Taylor, que

establece que f (z) = f

desconocida.




Formulación teórica

En este capítulo vamos a programar un solver basado en métodos gradenciales para

resolver el siguiente problema QP:

= u

minarg 2

1uTHu + bu

s. a 1u ≤ u ≤ 1u

1U ≤ Tu + u(t−1) 1 ≤ 1U


pasar de resolver un problema N-dimensional a resolver N problemas mono



conceptos matemáticos que van a ser fundamentales para el posterior desarrollo del


(z) una función real convexa f : RN → R que al menos sea diferenciable de clase 1

es un conjunto cerrado y convexo. El problema de optimización

que queremos resolver es el siguiente:

f* = min f (z)

s.a z ∈ C

C, f (z) estará acotada inferiormente por

(y) + ∇ f (y)T (z − y) , ∀ y, z ∈ C (1)


f (y) + ∇ f (y)T (z − y) + 2

2

1∇ f (c)T (z − y



Curso 2011/2012

basado en métodos gradenciales para


N problemas mono



ior desarrollo del


que al menos sea diferenciable de clase 1

es un conjunto cerrado y convexo. El problema de optimización


y)2, donde c=cte




Si f(z) es estrictamente convexa

f (z) ≥ f (y) + ∇ f (y)T (z −

La siguiente propiedad que

decir:

||∇ f (z) −

Donde L ≥ 0 es la denominada constante de Lipschitz. L

una función sea lipschitzian

dicho entorno, por lo que a

su gradiente fuese lipschitziano y cumpliese la condición anterior.

Si combinamos (1) y (2) llegamos fácilmente a que

demostramos:

f (z) ≥ f (y) + ∇ f

||∇

Por tanto, al ser L una cota superior de

superiormente según:

f (z) ≤ f

Una vez claras estas propiedades matemáticas volvemos a nuestro

original, en el que podemos comprobar que la función objetivo

diferenciable de clase dos en el recint




es estrictamente convexa se cumple que 2

2

1∇ f (c)T (z − y)2

y) cqd.

La siguiente propiedad que imponemos a f(z) es que su gradiente sea lipschitziano, es

− ∇ f (y) || ≤ L ||z – y|| , ∀z,y ∈ C (2)

0 es la denominada constante de Lipschitz. La condición suficiente para que

una función sea lipschitziana en un entorno es que dicha función sea diferenciable en

dicho entorno, por lo que a f le bastaría con ser diferenciable de clase dos en

su gradiente fuese lipschitziano y cumpliese la condición anterior.

Si combinamos (1) y (2) llegamos fácilmente a que 2∇ f (z) ≤ L

f (y)T (z − y), => f (z) − f (y) ≥ + ∇ f (y)T (

∇ f (z) − ∇ f (y) || ≥ 2∇ f (y)T (z − y)

||∇ f (z) − ∇ f (y) || ≤ L ||z – y||

2∇ f (z) ≤ L cqd

Por tanto, al ser L una cota superior de 2∇ f (z), la función quedará también acotada

f (y) + ∇ f (y)T (z − y) + 2

L||z – y||2 (3)

Una vez claras estas propiedades matemáticas volvemos a nuestro

original, en el que podemos comprobar que la función objetivo f (u) =

diferenciable de clase dos en el recinto definido por las restricciones. P



Curso 2011/2012

2 ≥ 0, entonces

imponemos a f(z) es que su gradiente sea lipschitziano, es

a condición suficiente para que

dicha función sea diferenciable en

le bastaría con ser diferenciable de clase dos en C para que

L ∀z ∈ C. Lo

(z − y)

, la función quedará también acotada

Una vez claras estas propiedades matemáticas volvemos a nuestro problema QP

2

1uTHu + bu es

o definido por las restricciones. Puesto que H es




definida positiva, cumple también

propiedades anteriores son aplicables a ella.

Entremos ya en la formulación del algoritmo. Los métodos gradenciales de

optimización tradicionales se basan en seguir la dirección del gradiente en cada

iteración para encontrar de la forma más rápida posible el mínimo.

iteración nos llevaría de uk

Seguiríamos iterando hasta que

mismo, hasta que el gradiente se hiciese cero, lo que indica que habríamos llegado al

mínimo.

Si atendemos a la condición (3), considerando que z =

cota superior de la variación de la función objetivo en cada iteración del algoritmo del

solver:

f (u

Donde ∆u = uk+1 – uk (no confundir con el incremento de control en el algoritmo MPC)

y ∇ f = Hx + b.

La idea del algoritmo que vamos a programar es minimizar la cota superior de

f (uk+1) − f (uk), de modo que forzaremos a que la diferencia

objetivo entre sucesivas iteraciones sea cada vez más pequeña, lo que indicará que nos

estaremos acercando al óptimo utilizando además la dirección del gradiente.

que hacíamos en el capítulo anterior, realizaremos esta minimización para cada una de

las N variables de decisión por separado, de modo que el problema mono dimensional

que nos queda es:

∆ui* =




definida positiva, cumple también con la condición de convexidad. Por tanto

propiedades anteriores son aplicables a ella.



ontrar de la forma más rápida posible el mínimo. De esta forma, una

a uk+1 usando un paso h de la siguiente forma:

uk+1 = uk − h∇ f (uk)

Seguiríamos iterando hasta que f (uk) y f (uk+1) fuesen muy parecidos, o lo que es lo

el gradiente se hiciese cero, lo que indica que habríamos llegado al

Si atendemos a la condición (3), considerando que z = uk+1 e y = uk, podemos obtener la


uk+1) − f (uk) ≤ 2

L ∆u 2 + ∇ f (uk)

T ∆u

(no confundir con el incremento de control en el algoritmo MPC)


, de modo que forzaremos a que la diferencia del valor


estaremos acercando al óptimo utilizando además la dirección del gradiente.

en el capítulo anterior, realizaremos esta minimización para cada una de


* = u

minarg 2

L ∆ui

2 + ∇ fi (u) ∆ui

s. a u ≤ ui + ∆ui ≤ u

U ≤ ui,k + ∆ui,k + Ui-1,k ≤ U



Curso 2011/2012

de convexidad. Por tanto, todas las



De esta forma, una

de la siguiente forma:

) fuesen muy parecidos, o lo que es lo

el gradiente se hiciese cero, lo que indica que habríamos llegado al

, podemos obtener la


(no confundir con el incremento de control en el algoritmo MPC)


del valor de la función


estaremos acercando al óptimo utilizando además la dirección del gradiente. Y, al igual

en el capítulo anterior, realizaremos esta minimización para cada una de





Donde ∇ fi (u) es la componente i de

anterior.

Resolviendo este problema tendremos el incremento

de u en cada iteración del solver

Al igual que hicimos en el algoritmo de Jacobi, obtenemos

las restricciones y luego comprobamos si se ha salido de la región, aplicando la acción

correctora.

La solución analítica al problema sin restricciones pues, es

Comprobamos ahora si el nuevo valor de u

es decir, si:

Asignaremos el valor límite para que cumpla las restricciones a

original no es válido.

El último paso, tras realizar la iteración para los N problemas monodimensionales,

comprobar si ||∆u*|| ha sido mayor que la tolerancia indicada, en cuyo caso volvemos a

iterar hasta que se cumpla la condición de paro.

iteración donde combinamos los N resultados obtenidos en las optimizaciones mono

dimensionales, ya que el gradiente de la función objetivo se calcula con el vector

completo, quedándonos luego con cada componente obtenida por separado.

El único punto que nos queda por justificar es el valor de la constante de Lipschitz, L.

Como hemos visto, ésta debe suponer una cota superior para

función objetivo vale precisamente

positiva, su máximo valor singular coincidirá con su máximo autovalor. Como además

H no depende de u (es constante), este máximo valor es válido como cota superior. Así

pues, tomaremos:




es la componente i de ∇ f (u) y Ui-1 es la acción de control absoluta

Resolviendo este problema tendremos el incremento que experimenta cada componente

solver, hasta que finalmente este ∆u sea muy próximo a cero.

Al igual que hicimos en el algoritmo de Jacobi, obtenemos ∆ui* como si no tuviésemos


problema sin restricciones pues, es ∆ui* = L

f i∇−

Comprobamos ahora si el nuevo valor de ui,k+1 = ui,k + ∆ui,k* incumple las restricciones,

u ≤ ui,k + ∆ui,k* ≤ u

U ≤ ui,k + ∆ui,k* + ui-1,k ≤ U

el valor límite para que cumpla las restricciones a ∆u

, tras realizar la iteración para los N problemas monodimensionales,

ha sido mayor que la tolerancia indicada, en cuyo caso volvemos a

iterar hasta que se cumpla la condición de paro. Nótese que es al principio de cada

eración donde combinamos los N resultados obtenidos en las optimizaciones mono

dimensionales, ya que el gradiente de la función objetivo se calcula con el vector



Como hemos visto, ésta debe suponer una cota superior para 2∇ f , que para nuestra

función objetivo vale precisamente H. Debido a que esta matriz es simétrica y definida

, su máximo valor singular coincidirá con su máximo autovalor. Como además

(es constante), este máximo valor es válido como cota superior. Así



Curso 2011/2012

es la acción de control absoluta

que experimenta cada componente

sea muy próximo a cero.

como si no tuviésemos


L

ui )(.

incumple las restricciones,

ui,k* si su valor

, tras realizar la iteración para los N problemas monodimensionales, es

ha sido mayor que la tolerancia indicada, en cuyo caso volvemos a

Nótese que es al principio de cada

eración donde combinamos los N resultados obtenidos en las optimizaciones mono

dimensionales, ya que el gradiente de la función objetivo se calcula con el vector u



, que para nuestra

simétrica y definida

, su máximo valor singular coincidirá con su máximo autovalor. Como además

(es constante), este máximo valor es válido como cota superior. Así




Calcularemos el valor de L fuera de línea, desde el generador de código de MATLAB,

incluyendo su valor en una variable global constante declarada en

generado:

L=max(eig(H)); ... fprintf(f,

const double L=797.458633;

Una vez justificado este último aspecto teórico

código debidamente comentado.

7.2 Programación del algoritmo en C++

double * qp_gradient( doubledouble L, double uant){ double dxj, fyj; /* Variables para problema 1D */ double *dx; /* Vector de incrementos de x */ double step; /* Variable para cálculo de ||dx|| */ double prev_u; /* Variable que almacena la int fin=0; /* Flag para condición de paro */ dx= vec_din(N); //Creamos el vector de incrementos de x

while (!fin) //Iteraremos hasta que se cumpla la condición de fi n { step=0; prev_u=uant; //Inicializamos con la última acción de control del MPC //Dividimos el problema de dimensión N en N problem as 1D for ( int j=0; j<N; j++) {




L = λmax(H).


incluyendo su valor en una variable global constante declarada en el fichero de cabecera

fprintf(f, '\tconst double L=%f;\n\n' ,L);

L=797.458633; (Fichero generado)

Una vez justificado este último aspecto teórico pasamos sin más dilación

código debidamente comentado.

Programación del algoritmo en C++

double *x, const double H[][N], doubleuant)

/* Variables para problema 1D */ /* Vector de incrementos de x */ /* Variable para cálculo de ||dx|| */ /* Variable que almacena la acción de control previa *//* Flag para condición de paro */

//Creamos el vector de incrementos de x

//Iteraremos hasta que se cumpla la condición de fi n

//Inicializamos con la última acción de control del MPC

//Dividimos el problema de dimensión N en N problem as 1D j=0; j<N; j++)

{ //Calculamos la componente j del gradiente de f // fy = b + Hx fyj=b[j]; for ( int i=0; i<N; i++) fyj=fyj+H[j][i]*x[i]; //Obtenemos el mínimo sin restricciones dxj=-fyj/L;



Curso 2011/2012


el fichero de cabecera

,L); (Generador)

sin más dilación a presentar el

double *b, const

acción de control previa */

//Iteraremos hasta que se cumpla la condición de fi n

//Inicializamos con la última acción de control del MPC

j del gradiente de f

//Obtenemos el mínimo sin restricciones




} for ( int i=0; i<N; i++) x[i]=x[i]+dx[i]; if ( sqrt(step)<tol) fin=1; } free(dx); //Liberamos memoria reservada dinámicamente

return (x); //Devolvemos x* }

Nota: la tolerancia (tol ) se define fuera de la función, asignándole un valor constante

por ejemplo: #define tol 0.0001

Lo mismo ocurre con las restricciones:

#define XMIN -0.5 #define XMAX 0.5 #define UMIN -3 #define UMAX 3 El motivo de esto no es otro que reducir la memoria RAM requerida, almacenando estos

valores constantes en memoria flash.

7.3 Simulaciones

Realicemos ahora las simulaciones, repitiendo la secuencia seguida en los

anteriores.

Comenzamos comparando cómo cambia el control con las variaciones de N y




//Forzamos a que se cumpla la primera restricción if (x[j]+dxj>XMAX) dxj=XMAX-x[j]; if (x[j]+dxj<XMIN) dxj=XMIN-x[j]; //Forzamos a que se cumpla la segunda restricción if ((x[j]+dxj+prev_u)>UMAX) dxj=UMAX-prev_u-x[j]; if ((x[j]+dxj+prev_u)<UMIN) dxj=UMIN-prev_u-x[j]; dx[j]=dxj; //Almacenamos el valor definitivo de dx step=step+dxj*dxj; //Vamos calculando ||dx|| prev_u=prev_u+x[j]+dxj; //Actualizamos el u previo

}

i=0; i<N; i++) //Actualizamos x con los dx obtenidosx[i]=x[i]+dx[i];

(step)<tol) //Comprobamos si se satisface la condición de paro

//Liberamos memoria reservada dinámicamente

//Devolvemos x*

) se define fuera de la función, asignándole un valor constante

#define tol 0.0001

Lo mismo ocurre con las restricciones:

El motivo de esto no es otro que reducir la memoria RAM requerida, almacenando estos

valores constantes en memoria flash.

Realicemos ahora las simulaciones, repitiendo la secuencia seguida en los

Comenzamos comparando cómo cambia el control con las variaciones de N y



Curso 2011/2012

//Forzamos a que se cumpla la primera restricción

//Forzamos a que se cumpla la segunda restricción

//Almacenamos el valor definitivo de dx //Vamos calculando ||dx||

//Actualizamos el u previo

//Actualizamos x con los dx obtenidos

//Comprobamos si se satisface la condición de paro

//Liberamos memoria reservada dinámicamente

) se define fuera de la función, asignándole un valor constante,

El motivo de esto no es otro que reducir la memoria RAM requerida, almacenando estos

Realicemos ahora las simulaciones, repitiendo la secuencia seguida en los capítulos

Comenzamos comparando cómo cambia el control con las variaciones de N y λ.




Modelo del sistema

( 0

6.1)(

−=

zzG

En primer lugar fijaremos las restricciones de control y el valor de

Tomamos los siguientes valores:

% Modelo del sistema A=[1 -0.6 -0.16]; B=1.6*[0 1 -0.3]; % Horizonte de control y ponderación de la acción de control

N=[variable]; lambda=1; % Restricciones de controldumin=- 0.5; dumax=0.5; umin=

Obtenemos los siguientes resultados tras realizar cada simulación con 200 iteraciones y

sucesivos cambios de set-point.




( ))( )2.08.0

3.0

+−⋅z

z ;

( )( )(1

111

2.018.01

3.016.1)( −−

−−−

+−−⋅=

zz

zzzG

En primer lugar fijaremos las restricciones de control y el valor de λ, haciendo variar N.

Tomamos los siguientes valores: λ = 1 , ∆umin = -0.5 , ∆umax = 0.5 , umin

control y ponderación de la acción de control

% Restricciones de control 0.5; dumax=0.5; umin= -1; umax=4;


point.



Curso 2011/2012

))1−

λ, haciendo variar N.

= -1 , umax = 4.

control y ponderación de la acción de control





La conclusión que se extrae es la misma que en los capítulos anteriores: un aumento de

N mejora la anticipación al cambio de referencia. Lo que sí es cierto es que los

resultados divergen menos al aumentar el horizonte usando este

utilizando el algoritmo de Jacobi. Esto nos indica que deberíamos aumentar el número

de iteraciones del algoritmo del capítulo 6 conforme aumentamos N. Veamos ahora una

zona ampliada de esta gráfica.

Observemos ahora las evoluciones de

anterior, es notorio como se reducen los picos al aumentar N, suavizando el control.






resultados divergen menos al aumentar el horizonte usando este solver



zona ampliada de esta gráfica.

las evoluciones de las distintas u(t). Como ocurría en el capítulo




Curso 2011/2012



solver gradencial que



. Como ocurría en el capítulo





Finalmente, los tiempos de ejecución para cada valor de N son los siguientes:

Horizonte Tiempo mín. (s)

7 0.000

15 0.0011

20 0.0042

25 0.028

30 0.064

50 0.7404

Vemos como, para N=7, el algoritmo es más rápido que los de Lemke y Jacobi,

consumiendo además mucha menos memoria RAM que el primero y aproximadamente

la misma que el segundo. Los tiempos van aumentando progresivamente, siendo del

orden de las décimas de segundo hasta N=25. A partir de N=30 ya entramos en el orden

de magnitud del segundo. Esto podría mejorarse fijando un número máximo de

iteraciones para el solver.




os tiempos de ejecución para cada valor de N son los siguientes:

Tiempo mín. (s) Tiempo máx. (s) Tiempo medio

0.0004 0.0305

0.0011 0.3687

0.0042 0.7600

0.0288 1.1095

0.0645 1.8104

0.7404 6.8466




segundo hasta N=25. A partir de N=30 ya entramos en el orden




Curso 2011/2012

os tiempos de ejecución para cada valor de N son los siguientes:

Tiempo medio (s)

0.0055

0.1205

0.2740

0.5602

1.1102

3.8327




segundo hasta N=25. A partir de N=30 ya entramos en el orden





Fijemos ahora el horizonte de control y variemos

N = 20, ∆umin = -0.5 , ∆umax

% Modelo del sistema A=[1 -0.6 -0.16]; B=1.6*[0 1 -0.3]; % Horizonte de control y ponderación de la acción d e control

N=20; lambda= [variable]; % Restricciones de controldumin=- 0.5; dumax=0.5;

Los resultados obtenidos son los siguientes:

Como era de prever según las conclusiones sacadas en el capítulo anterior, el parámetro

λ no tiene mucha influencia al utilizar horizontes “altos” como los que podemos

alcanzar con esta versión del algoritmo. Ampliemos la gráfica para ver su efecto:




Fijemos ahora el horizonte de control y variemos λ. Tomamos los siguientes valores:

max = 0.5 , umin = -1 , umax = 4.

% Horizonte de control y ponderación de la acción d e control

;

% Restricciones de control 0.5; dumax=0.5; umin=-1; umax=4;

Los resultados obtenidos son los siguientes:


no tiene mucha influencia al utilizar horizontes “altos” como los que podemos

sión del algoritmo. Ampliemos la gráfica para ver su efecto:



Curso 2011/2012

. Tomamos los siguientes valores:



no tiene mucha influencia al utilizar horizontes “altos” como los que podemos

sión del algoritmo. Ampliemos la gráfica para ver su efecto:




La evolución de u(t) es:






Curso 2011/2012




Ampliamos una región de la imagen para comprobar cómo un incremento de

los picos y suaviza el control.

La conclusión que sacamos es que tiene más peso

elegido que la ponderación de la acción de control en la función objetivo (

cuando trabajamos con horizontes del orden de las decenas o superior.

Simulemos ahora los casos particulares.

Sistema con cero de fase no mínima

( 0

1)(

−−=

zzG

Tomaremos como horizonte N = 20, y como

∆umin = -0.5 , ∆umax = 0.5 , u




Ampliamos una región de la imagen para comprobar cómo un incremento de

los picos y suaviza el control.

La conclusión que sacamos es que tiene más peso sobre el control el horizonte (N)

elegido que la ponderación de la acción de control en la función objetivo (

cuando trabajamos con horizontes del orden de las decenas o superior.

os ahora los casos particulares.

fase no mínima

( ))( )2.08.0

21

+−⋅z

z ;

( )( )(1

111

2.018.01

211)( −−

−−−

+−−⋅−=

zz

zzzG

Tomaremos como horizonte N = 20, y como λ = 0.5. Impondremos como restricciones:

umin = -2 , umax = 2.



Curso 2011/2012

Ampliamos una región de la imagen para comprobar cómo un incremento de λ reduce

sobre el control el horizonte (N)

elegido que la ponderación de la acción de control en la función objetivo (λ), al menos

)1−

= 0.5. Impondremos como restricciones:




% Modelo del sistema A=[1 -0.6 -0.16]; B=-1*[0 1 -2]; % Horizonte de control y ponderación de la acción d e controlN=20; lambda=0.5; % Restricciones de controldumin=- 0.5; dumax=0.5; umin=

Realizamos la simulación con 2

salida del sistema obtenida es la siguiente:

Como en el capítulo anterior, para un sistema de fase no mínima mejora el control

cuanto más alto es el horizonte de control/predicción.

Por su parte, la evolución de u(t) es la siguiente:






Realizamos la simulación con 240 iteraciones y sucesivos cambios de set

obtenida es la siguiente:


cuanto más alto es el horizonte de control/predicción.




Curso 2011/2012


0 iteraciones y sucesivos cambios de set-point. La





Observamos en la gráfica como se

también se cumplen las relativas a

0.000000

0.000000

- 0.500000

7.171088

7.338602

7.469028

Queda demostrado, pues, el cumplimiento de todas las restricciones.

Por último indicamos los tiempos de ejecución:

Tiempo mínimo de iteración:

Tiempo máximo de iteración:

Tiempo medio de iteración:




Observamos en la gráfica como se cumple la restricción sobre umin, veamos ahora cómo

también se cumplen las relativas a ∆u observando los resultados numéricos:

y u w

0.000000 0.000000 3.000000

0.000000 0.500000 3.000000

0.500000 1.000000 3.000000

7.171088 1.443120 7.000000

7.338602 0.967748 7.000000

7.469028 0.467748 7.000000



Tiempo mínimo de iteración: 0.001843 segundos

Tiempo máximo de iteración: 0.991128 segundos

Tiempo medio de iteración: 0.176084 segundos



Curso 2011/2012

, veamos ahora cómo

éricos:




Integrador

Como parámetros tomaremos N = 20 y

= -0.5 , ∆umax = 0.5 , umin =

% Modelo del sistema A=[1 -1]; B=[0 1]; % Horizonte de control y ponderación de la acción d e controlN=20; lambda=1; % Restricciones de controldumin=- 0.5; dumax=0.5; umin=






1

1)(

−=

zzG ; 1

11

1)( −

−−

−=

z

zzG

Como parámetros tomaremos N = 20 y λ = 1. Impondremos como restricciones:

-2 , umax = 2 , ymin = 0 , ymax = 18.


% Restricciones de control 0.5; dumax=0.5; umin= -2; umax=2; ymin=0; ymax=18;





Curso 2011/2012

. Impondremos como restricciones: ∆umin


Realizamos la simulación con 440 iteraciones y sucesivos cambios de set-point. La




El hecho de que hayamos tomado

que la acción del controlador sea m

capítulos 4 y 5, lo mismo que nos ocurría en el capítulo 6. Obtenemos pues una

respuesta con más sobreoscilaciones y transiciones de menor pendiente.

Por su parte, la evolución de u(t) es la siguient

La acción de control es menos agresiva que en los capítulos 4 y 5.

gráfica como se cumple la restricción sobre u

cumplen las relativas a ∆u observando los resultados num

0.000000

0.000000

0.500000

1.080501




El hecho de que hayamos tomado λ=1 y tengamos un horizonte de control mayor hace

que la acción del controlador sea menos agresiva que en el control de este sistema en los


respuesta con más sobreoscilaciones y transiciones de menor pendiente.


La acción de control es menos agresiva que en los capítulos 4 y 5. Observamos en la

gráfica como se cumple la restricción sobre umin, veamos ahora cómo también se

∆u observando los resultados numéricos:

y u w

0.000000 0.000000 3.000000

0.000000 0.500000 3.000000

0.500000 0.580501 3.000000

1.080501 0.503259 3.000000



Curso 2011/2012

=1 y tengamos un horizonte de control mayor hace

enos agresiva que en el control de este sistema en los


Observamos en la

, veamos ahora cómo también se




9.186241

11.186241

12.858886

14.150139






Sistema inestable

)( =zG

Respecto al capítulo anterior, aumentamos el horizonte a N =

Mantenemos las restricciones:

ymax = 9.

% Modelo del sistema A=[1 -1.1]; B=0.1*[1 0.2]; % Horizonte de control y ponderación de la acción d e controlN=20; lambda=0.5; % Restricciones de controldumin=- 2; dumax=2; umin=


modo certificaremos que se verifican dichas restricciones. La salida del sistema

que se muestra en la página siguiente. Obtenemos unos picos de sobreoscilación

menores que en el capítulo anterior, mejorando también la anticipación al cambio de

set-point al haber aumentado el horizonte de control.




y u w

9.186241 2.000000 3.000000

11.186241 1.672645 16.000000

12.858886 1.291252 16.000000

14.150139 0.945639 16.000000





de iteración: 0.208179 segundos

( )1.1

2.01.0

−+⋅

z

z ;

( )1

11

1.11

2.011.0)( −

−−

−+⋅=

z

zzG

Respecto al capítulo anterior, aumentamos el horizonte a N = 20, y tomamos un

Mantenemos las restricciones: ∆umin = -2 , ∆umax = 2 , umin = -10 , umax


% Restricciones de control 2; dumax=2; umin= -10; umax=10; ymin=0; ymax=9;


modo certificaremos que se verifican dichas restricciones. La salida del sistema

en la página siguiente. Obtenemos unos picos de sobreoscilación

ores que en el capítulo anterior, mejorando también la anticipación al cambio de

point al haber aumentado el horizonte de control.



Curso 2011/2012

, y tomamos un λ = 0.5.

max = 10 , ymin = 0 ,


Realizamos la simulación con 440 iteraciones y sucesivos cambios de set-point. De este

modo certificaremos que se verifican dichas restricciones. La salida del sistema es la

en la página siguiente. Obtenemos unos picos de sobreoscilación

ores que en el capítulo anterior, mejorando también la anticipación al cambio de











Curso 2011/2012




En esta gráfica se aprecia también la mejora en el anticipo al

Observamos en la gráfica como se cumple la restricción sobre u


0.000000

0.200000

0.564478

0.985764

5.864291

6.349721

6.766304

7.115823

Queda demostrado, pues, el cumplimiento de todas

indicamos los tiempos de ejecución:




Sistema tipo dead-beat

)(zG =

Tomaremos N = 20 y λ

∆umax = 0.5 , umin = -5 , umax

% Modelo del sistema A=[1]; B=3*[0 0 0 0 1 0.3]; % Horizonte de control y ponderación de la acción d e N=20; lambda=0.5; % Restricciones de controldumin=- 0.5; dumax=0.5; umin=

Realizamos la simulación con 4





En esta gráfica se aprecia también la mejora en el anticipo al cambio de referencia y

Observamos en la gráfica como se cumple la restricción sobre umin, veamos ahora cómo


y u w

0.000000 0.000000 3.000000

0.200000 2.000000 3.000000

0.564478 3.044784 3.000000

0.985764 3.039420 3.000000

5.864291 -0.007313 8.000000

6.349721 -1.008525 8.000000

6.766304 -1.982190 8.000000

7.115823 -2.874681 8.000000


indicamos los tiempos de ejecución:




( )5

3.0

z

zK + ; ( )141 3.01)( −−− +⋅= zzKzG

y λ = 0.5. Impondremos como restricciones:

max = 5.







Curso 2011/2012

cambio de referencia y.

, veamos ahora cómo

éricos:

las restricciones. Por último

= 0.5. Impondremos como restricciones: ∆umin = -0.5 ,

control

0 iteraciones y sucesivos cambios de set-point. La




Apenas se observan diferencias su parte, la evolución de u(t) es la siguiente:




Apenas se observan diferencias con respecto a los resultados del capítulo anterior.su parte, la evolución de u(t) es la siguiente:



Curso 2011/2012

con respecto a los resultados del capítulo anterior. Por




Observamos en la gráfica como se cumple


0.000000

0.000000

0.000000

17.990037

18.012

18.060700






Simulación con ruido

Cerramos las simulaciones añadiendo ruido. Tomaremos para ello el sistema estable de

las primeras simulaciones y unos valores de N =

restricciones serán las siguientes:

% Modelo del sistema A=[1 -0.6 -0.16]; B=1.6*[0 1 -0.3]; % Horizonte de control y ponderación de la acción d e controlN=15; lambda=0.5; % Restricciones de controldumin=- 0.5; dumax=0.5; umin=

El nivel de ruido será de ± 0.05, el doble que en los capítulos 4 y 5.

simulación son los mostrados en la página siguiente. Como en el capítulo anterior, el

ruido afecta al control menos de lo que lo hacía en los capítulos 4 y 5, donde el

horizonte era menor.




Observamos en la gráfica como se cumple las restricciones sobre u, veamos ahora cómo


y u w

0.000000 0.000000 3.000000

0.000000 0.500000 3.000000

0.000000 0.727105 3.000000

17.990037 4.445193 18.000000

18.012 760 3.945193 18.000000

18.060700 3.445193 18.000000






erramos las simulaciones añadiendo ruido. Tomaremos para ello el sistema estable de

las primeras simulaciones y unos valores de N = 20 y λ = 0.5. Por su parte, las

restricciones serán las siguientes: ∆umin = -0.5 , ∆umax = 0.5 , umin = -1 ,


Restricciones de control 0.5; dumax=0.5; umin= -1; umax=4;

El nivel de ruido será de ± 0.05, el doble que en los capítulos 4 y 5. Los resultados de la

mostrados en la página siguiente. Como en el capítulo anterior, el

a al control menos de lo que lo hacía en los capítulos 4 y 5, donde el



Curso 2011/2012

u, veamos ahora cómo

éricos:

erramos las simulaciones añadiendo ruido. Tomaremos para ello el sistema estable de

Por su parte, las

umax = 4.


Los resultados de la

mostrados en la página siguiente. Como en el capítulo anterior, el

a al control menos de lo que lo hacía en los capítulos 4 y 5, donde el




La evolución de u(t) es la siguiente:




La evolución de u(t) es la siguiente:



Curso 2011/2012




La menor incidencia del ruido

aprecia que no se violan las restricciones

cumplen las restricciones sobre

0.000000

0.030000

0.838000

7.294714

6.537181

5.348081

Para acabar comprobaremos que los tiempos de ejecución

este caso. Ello se debe al tipo de condición de paro utilizada. En el algoritmo del

capítulo 6 se realizan siempre las mismas iteraciones, pero en éste varían en función de

la tolerancia. Cuando nos encontramos en régimen perman

apenas cambia de una iteración a otra del MPC, por lo que el

rápido. Al añadir ahora ruido nos obliga a iterar más veces en estos tramos,

resintiéndose un poco los tiempo

Tiempo mínimo de iteració


Tiempo medio de iteració




La menor incidencia del ruido puede apreciarse en la gráfica anterior, donde además se

n las restricciones sobre u(t). Comprobamos que también se

cumplen las restricciones sobre ∆u(t) atendiendo a los siguientes valores numéricos.

y u w

0.000000 0.000000 3.000000

0.030000 0.500000 3.000000

0.838000 1.000000 3.000000

7.294714 0.936266 8.000000

6.537181 0.436266 8.000000

5.348081 0.372252 4.000000

Para acabar comprobaremos que los tiempos de ejecución si se ven algo afectados en



la tolerancia. Cuando nos encontramos en régimen permanente y sin ruido la solución

apenas cambia de una iteración a otra del MPC, por lo que el solver halla el óptimo muy


resintiéndose un poco los tiempos de ejecución:

de iteració n: 0.001877 segundos


Tiempo medio de iteració n: 0.345731 segundos



Curso 2011/2012

donde además se

. Comprobamos que también se

os siguientes valores numéricos.

si se ven algo afectados en



ente y sin ruido la solución

halla el óptimo muy





7.4 Bibliografía del capítulo

Richter, S. Jones, C.N. Morari, MMethods

Joint 48th IEEE Conference on Decision and Control and 28th

Shanghai, P.R. China, December 16

Camacho, EF. Bordons, C. Model Predictive Control

London : Springer, cop. 2004

2nd ed.

Balagurusamy, E. Programación orientada a objetos con C++

Madrid [etc.] : McGraw-Hill/Interamericana de España, 2007

3ª ed.

Rodríguez Ramírez, D. Camacho, EF.

Escuela Superior de Ingenieros. Universidad de Sevilla. 2011

Pizarro, L. Mesa, J . Apuntes y transparencias de





Bibliografía del capítulo

Morari, M. Real-Time Input-Constrained MPC Using Fast Gradient

Joint 48th IEEE Conference on Decision and Control and 28th Chinese Control Conference

Shanghai, P.R. China, December 16-18, 2009

Model Predictive Control

Programación orientada a objetos con C++

Hill/Interamericana de España, 2007

Camacho, EF. Apuntes y transparencias de Ingeniería de


Apuntes y transparencias de Métodos Matemáticos

Superior de Ingenieros. Universidad de Sevilla. 2011



Curso 2011/2012

Constrained MPC Using Fast Gradient

Chinese Control Conference

Apuntes y transparencias de Ingeniería de Control

Solver: Algoritmo Gradencialbibing.us.es/proyectos/abreproy/5123/descargar... · 0 es la denominada...

Documents

Transcript of Solver: Algoritmo Gradencialbibing.us.es/proyectos/abreproy/5123/descargar... · 0 es la denominada...