Generador de código en MATLAB para matrices y...

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

Dpto. Ing. de Sistemas y Automática

Universidad de Sevilla

Generador de código en MATLAB para matrices y

Proyecto Fin de Carrera


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

Capítulo 2


métodos MPC


Ramón Jesús Cuesta Pérez

Curso 2011/2012





2.1 Introducción al Control Predictivo Generalizado (GPC)

Dentro del amplio marco del

diversos algoritmos con mayor o menor aceptación en el mundo académico e industrial.

No obstante las ideas generales en que se basan todo estos algoritmos son las mismas,

difiriendo entre ellos principalmente en el tipo de modelo y en la función de coste

utilizados. Algunos de los algoritmos con mayor popularidad son los siguientes:

- DMC (Dynamic Matrix Control

el proceso. Goza de a

sistemas inestables.

- MAC (Model Algorithm Control

respuesta impulsional. Su modelo comercial se denomina IDCOM.

- PFC (Predictive Functional Control

especialmente indicado para procesos rápidos, lo cual lo hace atractivo para

industrias como la química.

- GPC (Generalized Predictive Control

transferencia.

Para el desarrollo del proyecto vamos a

(GPC), algoritmo propuesto

sin embargo goza de una buena aceptación

válido para cualquier tipo

dead-beat. Esta característica

transferencia, modelos con los que cualquier estudiante de Ingeniería de Control se

encuentra especialmente familiarizado, hacen

algoritmo en detrimento del resto anteriormente propuestos.

Además de las ventajas intrínsecas del

derivadas de emplear un control




Introducción al Control Predictivo Generalizado (GPC)

Dentro del amplio marco del MPC (Control Predictivo basado en Modelo) existen

con mayor o menor aceptación en el mundo académico e industrial.


ndo entre ellos principalmente en el tipo de modelo y en la función de coste

Algunos de los algoritmos con mayor popularidad son los siguientes:

Dynamic Matrix Control), utiliza la respuesta ante escalón para modelar

el proceso. Goza de amplia aceptación en la industria, aunque no es válido para

Model Algorithm Control), similar al anterior, usa un modelo de


Predictive Functional Control), modelo en espacio de estados

indicado para procesos rápidos, lo cual lo hace atractivo para

industrias como la química.

Generalized Predictive Control), basado en modelos en función de

Para el desarrollo del proyecto vamos a optar por el Control Predictivo Generalizado

, algoritmo propuesto en el ámbito académico por Clarke et al. en 1987

goza de una buena aceptación en la industria. Su principal ventaja es que es

de sistema, ya sea inestable, de fase no mínima e incluso

Esta característica y el hecho de que emplee modelos en funci


encuentra especialmente familiarizado, hacen que nos decantemos por este tipo de

algoritmo en detrimento del resto anteriormente propuestos.

Además de las ventajas intrínsecas del GPC, conviene recordar las principales ventajas

derivadas de emplear un control MPC:



Curso 2011/2012

(Control Predictivo basado en Modelo) existen

con mayor o menor aceptación en el mundo académico e industrial.


ndo entre ellos principalmente en el tipo de modelo y en la función de coste

Algunos de los algoritmos con mayor popularidad son los siguientes:

), utiliza la respuesta ante escalón para modelar

mplia aceptación en la industria, aunque no es válido para

usa un modelo de


n espacio de estados

indicado para procesos rápidos, lo cual lo hace atractivo para

), basado en modelos en función de

optar por el Control Predictivo Generalizado

en 1987 pero que

principal ventaja es que es

, de fase no mínima e incluso

l hecho de que emplee modelos en función de


que nos decantemos por este tipo de

, conviene recordar las principales ventajas




- Permite incluir restricciones de

- Puede ser utilizado para controlar una gran variedad de procesos, con dinámicas

muy distintas.

- Posee intrínsecamente compensación de retardo al incluirlo en el modelo.

- Permite usar el conocimiento de referenc

bruscas.

- Puede extenderse con facilidad al caso multivariable.

- Resulta atractivo para personal sin un conocimiento profundo de control debido

a la facilidad de sus conceptos facilidad de sintonización.

- Está abierto a futuras extensiones.

No obstante, el MPC presenta una serie de inconvenientes

cuenta:

- En determinados casos presenta una carga computacional alta.

- La fidelidad del modelo con el sistema real es clave para el buen funcionamiento

del control, por lo que sus prestaciones dependerán en gran medida de las

discrepancias existentes entre el proceso real y el modelo usado.

Una vez justificada la elección del algoritmo y comentadas sus ventajas e

inconvenientes pasaremos a realizar la des

desarrollo matemático para un sistema SISO (una sola entrada y una sola salida).

En GPC modelamos el sistema mediante un modelo de función de transferencia

autorregresivo de media móvil integrado, denominado como CARIMA (

Auto-Regressive Integrated Moving

−(zA




Permite incluir restricciones de operación en el cálculo de la señal de control.

Puede ser utilizado para controlar una gran variedad de procesos, con dinámicas

Posee intrínsecamente compensación de retardo al incluirlo en el modelo.

Permite usar el conocimiento de referencias futuras, lo cual evita transiciones

Puede extenderse con facilidad al caso multivariable.

Resulta atractivo para personal sin un conocimiento profundo de control debido

a la facilidad de sus conceptos facilidad de sintonización.

futuras extensiones.

presenta una serie de inconvenientes que conviene tener en

En determinados casos presenta una carga computacional alta.

La fidelidad del modelo con el sistema real es clave para el buen funcionamiento

l control, por lo que sus prestaciones dependerán en gran medida de las

discrepancias existentes entre el proceso real y el modelo usado.


inconvenientes pasaremos a realizar la descripción del mismo apoyándonos en su

para un sistema SISO (una sola entrada y una sola salida).

modelamos el sistema mediante un modelo de función de transferencia

autorregresivo de media móvil integrado, denominado como CARIMA (

Regressive Integrated Moving-Average):

∆+−= −−−− )(

)()1()()() 111 tezCtuzzBty d



Curso 2011/2012

operación en el cálculo de la señal de control.

Puede ser utilizado para controlar una gran variedad de procesos, con dinámicas

Posee intrínsecamente compensación de retardo al incluirlo en el modelo.

ias futuras, lo cual evita transiciones

Resulta atractivo para personal sin un conocimiento profundo de control debido

que conviene tener en

La fidelidad del modelo con el sistema real es clave para el buen funcionamiento

l control, por lo que sus prestaciones dependerán en gran medida de las


cripción del mismo apoyándonos en su

para un sistema SISO (una sola entrada y una sola salida).

modelamos el sistema mediante un modelo de función de transferencia

autorregresivo de media móvil integrado, denominado como CARIMA (Controller




Donde

y(t) ≡ salida del sistema

u(t) ≡ acción de control

e(t) ≡ perturbaciones

d ≡ retardo del sistema

∆ ≡ 1 − z-1

El polinomio C(z-1) pondera el ruido y lo define si éste se trata de un ruido blanco

coloreado. En la práctica es difícil modelar correctamente estas perturbaciones, p

que resulta complicado hallar el valor

C(z-1) como parámetro de diseño para rechazo de perturbaciones o mejora de la

robustez. Lo habitual, no obstante, es tomar C(z

corresponde con un ruido blanco de media cero, lo cual no descabellado al ser este un

tipo de ruido habitual en la mayoría de procesos. En el desarrollo de este proyecto

haremos siempre esta hipótesis.

Por su parte los polinomios A(z

transferencia que modela al sistema:

Además, en el modelo CARIMA el polinomio A(z

A

Mientras que B(z-1) sí podrá tener un primer término distinto de cero

B(




salida del sistema

ción de control

perturbaciones, ruido blanco

retardo del sistema

pondera el ruido y lo define si éste se trata de un ruido blanco

coloreado. En la práctica es difícil modelar correctamente estas perturbaciones, p

que resulta complicado hallar el valor de este polinomio. Así pues se puede emplear

) como parámetro de diseño para rechazo de perturbaciones o mejora de la

robustez. Lo habitual, no obstante, es tomar C(z-1) = 1, hipótesis válida cuando e(t) se



haremos siempre esta hipótesis.

Por su parte los polinomios A(z-1) y B(z-1) son los que aparecen en la función de

transferencia que modela al sistema:

)z(

)zB(z

)U(z

)Y(z)(z

1-

-d-1

1-

-11-

AG ==

Además, en el modelo CARIMA el polinomio A(z-1) ha de tener la forma:

nn zazazazA −−−− ++++= ...1)( 2

21

11

) sí podrá tener un primer término distinto de cero

mm zbzbzbbz −−−− ++++= ...)( 2

21

101



Curso 2011/2012

pondera el ruido y lo define si éste se trata de un ruido blanco

coloreado. En la práctica es difícil modelar correctamente estas perturbaciones, por lo

de este polinomio. Así pues se puede emplear

) como parámetro de diseño para rechazo de perturbaciones o mejora de la

) = 1, hipótesis válida cuando e(t) se



que aparecen en la función de

) ha de tener la forma:




Por otro lado, la función de coste que se utiliza en el

=uNNNJ 21 ),,(

Donde

N1, N2 ≡ horizontes de predicción. N

Nu ≡ horizonte de control.

λ ≡ factor de ponderación de la acción de control.

ω(t) ≡ referencia, de la cual podemos conocer sus valores futuros.

El primer sumatorio incluye los errores futuros al cuadrado y el segundo los

incrementos de acción de control al cuadrado, ponderados por un

de este factor y de los horizontes de predicción y control nos permitirán sintonizar

adecuadamente el controlador, cuya efectividad dependerá también, y en gran medida,

de la veracidad del modelo.

Una vez definidos modelo y función d

propiamente dicho. El primer paso consiste en realizar la predicción óptima de las

futuras salidas, que dependen de las salidas pasadas y las acciones de control futuras

Para ello operaremos con el modelo CARIMA, en el

−(zA

Denominaremos )(~ 1− =zA

entre )(~ 1−zA obtendremos como cociente el polinomio E

Obtenemos de este modo la siguiente ecuación diofántica:

1




Por otro lado, la función de coste que se utiliza en el GPC es de tipo cuadrática:

[ ] [∑∑==

−+∆++−+=uN

j

N

Nj

jtujttjty1

2 1()()|(ˆ2

1

λω

horizontes de predicción. N2 > N1 ; N1 > d+1

horizonte de control. 2NNu ≤

de ponderación de la acción de control. λ > 0

referencia, de la cual podemos conocer sus valores futuros.


incrementos de acción de control al cuadrado, ponderados por un factor



de la veracidad del modelo.

Una vez definidos modelo y función de coste comenzamos con el algoritmo


futuras salidas, que dependen de las salidas pasadas y las acciones de control futuras

Para ello operaremos con el modelo CARIMA, en el que hemos tomado C(z

∆+−= −−− )(

)1()()() 11 tetuzzBty d (1)

)()1()( 111 −−− ⋅−=⋅∆ zAzzA . Si dividimos el polinomio 1

obtendremos como cociente el polinomio Ej(z-1) y como resto z

Obtenemos de este modo la siguiente ecuación diofántica:

)()(~

)( 111 −−−− += zFzzAzE jj

j (2)



Curso 2011/2012

es de tipo cuadrática:

]t 2)|1

referencia, de la cual podemos conocer sus valores futuros.


factor λ. La elección



e coste comenzamos con el algoritmo


futuras salidas, que dependen de las salidas pasadas y las acciones de control futuras.

que hemos tomado C(z-1) = 1.

. Si dividimos el polinomio 1

) y como resto z-jFj(z-1).




Multiplicando (1) por Ej(z-1

)()()(~ 11 jtyzEzA j +−−

Teniendo en cuenta que el valor esperado del ruido blanco es cero, sus valores futuros

serán cero. Por tanto, teniendo en cuenta que el grado de E

obtendremos siempre términos de ruido futuros en (3), podemos eliminar el último

término del segundo miembro. Además, usando la ecuación diofántica definida en (2):

( )(1 1zFz jj− −−

Ecuación que podemos reescribir como

)( Fjty =+

Denominando )( 1− = EzG j

)( jty +

Llegados a este punto es importante señalar que existe otra forma más eficiente de

obtener los polinomios Fj(z

computacional que realizando la división de polinomios. En efecto, estos polinomios se

pueden calcular de manera iterativa, como argumentaremos a continuación.

Debido a que los polinomios E

pasos de la división de 1 entre Ã(z

Ej(z-1) más un nuevo término. Además, puesto que Ã(z

zazazA −−− +++= ~~1)(~ 2

21

11

coeficiente del resto, que recordemos está factorizado como z




1) zj∆ obtenemos:

)()|1()()( 111 zEtdjtuzBzE jj +−−+∆= −−−


serán cero. Por tanto, teniendo en cuenta que el grado de Ej(z-1) es j



) )|1()()()() 11 tdjtuzBzEjty j −−+∆=+ −−

Ecuación que podemos reescribir como

)|1()()()( 11 tdjtuzBzEtyF jj −−+∆+ −− (5)

)()( 11 −− zBzE j llegamos a la expresión

)()|1()( 1 tyFtdjtuzG jj +−−+∆= − (6)


(z-1) y Ej(z-1) (y por ende Gj(z

-1)) desde el punto de vista



Debido a que los polinomios Ej(z-1) se van obteniendo como los cocientes en sucesivos

pasos de la división de 1 entre Ã(z-1), cada Ej+1(z-1) estará compuesto por el anterior

más un nuevo término. Además, puesto que Ã(z-1) es de la forma

nn za −++ ~... , dicho nuevo término será igual al primer

coeficiente del resto, que recordemos está factorizado como z-jFj(z-1).



Curso 2011/2012

)() jte + (3)


) es j-1 y por tanto



(4)

(5)


el punto de vista



) se van obteniendo como los cocientes en sucesivos

) estará compuesto por el anterior

) es de la forma

, dicho nuevo término será igual al primer




Por tanto,

Por su parte, el nuevo resto será

divisor. Por tanto, los coeficientes del polinomio F

Así pues, conociendo sendos E

Fj+1(z-1) y Gj+1(z

-1) (multiplicando

Para estos polinomios iniciales basta con tomar

obtiene que F1 = z(1−Ã).

polinomios requeridos. Este es el método que se usa para calcular los polinomios en el

generador de código de MATLAB que presentaremos más adelante en este capítulo.

Tras esta aclaración retomamos la ecuación (6) para definir las ecuaciones de

predicción:

(y

(y

…

(y

Estas ecuaciones son susceptibles de expresarse en forma matricial:

y = Gu

Donde

y = [ y(t+d+1|t) , y

u = [ ∆u(t|t) , ∆u(t+1|t) , … ,




Ej+1(z-1) = Ej(z

-1) + fj0z-j

e, el nuevo resto será el anterior menos el producto del cociente por el

divisor. Por tanto, los coeficientes del polinomio Fj+1 serán:

f j+1,i = fj,i+1 − fj,0·ãi+1 , i = 0,…,n

Así pues, conociendo sendos Ej(z-1) y Fj(z

-1) podemos obtener fácilmente

) (multiplicando Ej+1(z-1) por B(z-1)).

Para estos polinomios iniciales basta con tomar E1 = 1. De la ecuación diofántica (2)

De ahí en adelante iremos iterando para obtener todos los

Este es el método que se usa para calcular los polinomios en el



)()|()|1( 11 tyFttuGtdt dd ++ +∆=++

)()|1()|2( 22 tyFttuGtdt dd ++ ++∆=++

…

)()|()|( tyFtNtuGtNdt NdNd ++ ++∆=++

Estas ecuaciones son susceptibles de expresarse en forma matricial:

Gu + F(z-1)y(t) + G’(z-1)∆u(t-1) (7)

y(t+d+2|t) , … , y(t+d+N|t) ]T

u(t+1|t) , … , ∆u(t+N-1|t) ]T



Curso 2011/2012

el anterior menos el producto del cociente por el

) podemos obtener fácilmente Ej+1(z-1),

e la ecuación diofántica (2), se

iremos iterando para obtener todos los

Este es el método que se usa para calcular los polinomios en el






G =

−+

+

+

1,

1,2

0,1

...

NNd

d

d

g

g

g

G’(z-1) =

(

⋅N Gz

Es habitual denominar f =

reduce a

Para facilitar el cálculo computacional, la expresión polinomial

matricialmente como f = Fx

Fx =

++

++

+

0,

0,2

0,1

...

.........

...

...

dNd

dd

dd

ff

ff

ff

donde n es el orden del polinomio A(z

Simplemente se han expresado los vectores de polinomios

matrices, agrupándolas después en una sola (

y ∆u(t-1) se han ordenado vectorialmente de acuerdo a las dimensiones de la matriz

anterior. De esta forma se simplifica el cálculo computacional, y es el método que se

utiliza para evaluar f en el generador de códi




+−+

+

0,2,

0,2

...

.........

0...

0...0

NdNNd

d

gg

g F(z-1) =

+

+

+

(

...

(

(

2

1

F

F

F

Nd

d

d

( )( )

−−−−

−−⋅−⋅

−−+

−++

−+

−++

−+

+−

+

1,1

1,0,1

11,20,1

12

20,1

11

...)(

...

)(

)(

NNdNdNdNd

ddd

dd

zgzggzG

zggzGz

gzGz

= F(z-1)y(t) + G’(z-1)∆u(t-1), por lo que la ecuación (7) se

y = Gu + f (8)

Para facilitar el cálculo computacional, la expresión polinomial f se expresa también

xx, definiendo:

−+++

−+++

−+++

1,0,,

1,20,2,2

1,10,1,1

'...'

............

'...'

'...'

mNdNdnN

mddn

mddn

gg

gg

gg

x =

∆...

donde n es el orden del polinomio A(z-1) y m el de B(z-1).

Simplemente se han expresado los vectores de polinomios F(z-1)

matrices, agrupándolas después en una sola (Fx). Por su parte los valores pasados de y(t)

1) se han ordenado vectorialmente de acuerdo a las dimensiones de la matriz


en el generador de código programado.



Curso 2011/2012

−

−

−

)(

...

)(

)(

1

1

1

z

z

z

)

−− )1(N

1), por lo que la ecuación (7) se

se expresa también

−∆

−∆−

−

)(

...)1(

)(

...

)1(

)(

mtu

tu

nty

ty

ty

y G’(z-1) como

Por su parte los valores pasados de y(t)

1) se han ordenado vectorialmente de acuerdo a las dimensiones de la matriz





Una vez definida la predicción pasamos a la fase de optimización, la cual nos

proporcionará la secuencia de señales de control futuras óptima

la función de coste usando la expresión matricial definida en (8):

J = (y −−−− w)T(y −−−− w) +

Esta expresión, a su vez, se puede reescribir

H = 2·(GTG + λI )

b = 2·(f − w)TG

f0 = (f − w)T(f − w)

Estos cambios de variable están motivados

coste orientada a la resolución del problema QP

quedar definido al añadir las restricciones de operación.

imponer son las siguientes:

Las cuales se pueden reescribir en forma matricial fácilmente como:

Donde 1 es un vector columna de unos de la dimensión N y T es una matriz triangular

inferior NxN cuyos elementos no nulos son unos.





proporcionará la secuencia de señales de control futuras óptima. Para ello reescribimos

la función de coste usando la expresión matricial definida en (8):

) + λuTu = (Gu + f −−−− w)T(Gu + f −−−− w) + λuTu

Esta expresión, a su vez, se puede reescribir como aparecerá en (10) definiendo

J = 2

1uTHu + bu + f0 (10)

Estos cambios de variable están motivados por obtener una expresión de la función de

coste orientada a la resolución del problema QP (programación cuadrática)

quedar definido al añadir las restricciones de operación. Las restricciones que se van a

imponer son las siguientes:

UtuU ≤≤ )(

ututuu ≤−−≤ )1()(

ytyy ≤≤ )(

Las cuales se pueden reescribir en forma matricial fácilmente como:

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

1u ≤ u ≤ 1u

1 y ≤ Gu + f ≤ 1 y

es un vector columna de unos de la dimensión N y T es una matriz triangular

inferior NxN cuyos elementos no nulos son unos.



Curso 2011/2012


Para ello reescribimos

u (9)

definiendo:

por obtener una expresión de la función de

(programación cuadrática) que va a

Las restricciones que se van a

es un vector columna de unos de la dimensión N y T es una matriz triangular




Para definir el problema QP solo falta expresar las restricciones de modo que

formulación del problema nos quede:

u* = u

minarg 2

1

sujeto a Ru

Por tanto, es inmediato ver la forma que deben tomar

R =

−

−

−

G

T

I

I NxN

Así pues, para un horizonte de control N tendremos 6xN restricciones. Nótese como las

2xN primeras restricciones no cambian a lo largo del tiempo y son de tipo caja, pues

definen una región rectangular en la cual

dependen de u(t−1), por lo que cambiarán

Lo mismo ocurre con las 2xN

dependen de y(t) y u(t-1), variando así en el tiempo y definiendo una región que desd

luego dista mucho de ser rectangular.

Una vez definido totalmente el problema QP utilizaremos un algoritmo de optimización

o solver que lo resuelva para obtener el vector

habría que aplicar para obtener una respuest

futuros valores de ∆u nos quedamos tan solo con el primero,

resto. Hacemos esto porque en el siguiente tiempo de muestreo calcularemos

∆u(t+1|t+1) utilizando el valor real de y(t+1) y no el es

será mejor que ∆u(t+1|t) y as

horizonte deslizante.




Para definir el problema QP solo falta expresar las restricciones de modo que

nos quede:

2

1uTHu + bu + f0

Ru ≤ c

Por tanto, es inmediato ver la forma que deben tomar R y c:

−

−

G

G

T

T

I NxN

NxN

c =

+−−

−+−−−

−

fy

fy

tuU

tuU

u

u

1

1

)1(11

)1(11

1

1



definen una región rectangular en la cual se acota el valor de u. Las 2xN siguientes

1), por lo que cambiarán su valor en cada iteración del algoritmo GPC.

Lo mismo ocurre con las 2xN últimas de forma aún más notoria, pues en este caso

1), variando así en el tiempo y definiendo una región que desd

rectangular.


que lo resuelva para obtener el vector u*, que contiene los N futuros

habría que aplicar para obtener una respuesta óptima del sistema. De todos estos N

u nos quedamos tan solo con el primero, ∆u(t|t), y desechamos el


u(t+1|t+1) utilizando el valor real de y(t+1) y no el estimado. Por tanto

u(t+1|t) y así sucesivamente. Es lo que se denomina estrategia de



Curso 2011/2012

Para definir el problema QP solo falta expresar las restricciones de modo que la



. Las 2xN siguientes sí

iteración del algoritmo GPC.

de forma aún más notoria, pues en este caso

1), variando así en el tiempo y definiendo una región que desde


*, que contiene los N futuros ∆u que

De todos estos N

u(t|t), y desechamos el


timado. Por tanto ∆u(t+1|t+1)

í sucesivamente. Es lo que se denomina estrategia de




Aplicaremos pues la señal de control calculada y comenzaremos una nueva iteración,

donde volveremos a predecir las salida

de control que hay que ir aplicando, quedándonos siempre con la primera y desechando

el resto.

Esta es la estructura del GPC

explicación y justificación d

2.2 Elementos necesarios para la resolución computacional del GPC

Desde el punto de vista computacional, pues, tendremos que

realizando una minimización de la función

restricciones usando un determinado algoritmo de optimización o

argumentos mínimos tendremos que pasar al

vectores b y c.

Además, para actualizar los

de generador de código

necesitamos tener acceso en tiempo de ejecución a la

Por último, si vamos a simular el sistema dentro del propio

necesitaremos tener también acceso al modelo del mismo, almacenado en los vectores

y B.

Por tanto, a la hora de ejecutar la aplicación que programemos necesitaremos tener

almacenadas en memoria las matrices

Todos ellos son constantes en el tiempo y solo depende

horizonte de control y el factor de ponderación de la acción de control en la función

objetivo (λ). Todos estos datos son conocidos antes de la ejecución del programa, por lo

que resulta atractiva la idea de

archivo de cabecera para incluir en el programa del microcontrolador que contenga





donde volveremos a predecir las salidas futuras del sistema y optimizaremos las señales


GPC, una vez argumentada y comprendida procedemos a la

explicación y justificación del generador de código desarrollado.

Elementos necesarios para la resolución computacional del GPC

Desde el punto de vista computacional, pues, tendremos que resolver un problema QP

una minimización de la función de coste J(u) sujeta a una serie de

usando un determinado algoritmo de optimización o

mínimos tendremos que pasar al solver las matrices H y

para actualizar los vectores b (que por notación se denominará

para el solver basado en el algoritmo de Lemke

necesitamos tener acceso en tiempo de ejecución a las matrices G y Fx.

Por último, si vamos a simular el sistema dentro del propio microcontrolador

necesitaremos tener también acceso al modelo del mismo, almacenado en los vectores


almacenadas en memoria las matrices H, R, G y Fx, así como los v

Todos ellos son constantes en el tiempo y solo dependen del modelo del sistema, el


Todos estos datos son conocidos antes de la ejecución del programa, por lo

que resulta atractiva la idea de calcularlos fuera de línea con MATLAB y crear un




Curso 2011/2012


s futuras del sistema y optimizaremos las señales


, una vez argumentada y comprendida procedemos a la

Elementos necesarios para la resolución computacional del GPC

resolver un problema QP

sujeta a una serie de

usando un determinado algoritmo de optimización o solver. Como

y R, así como los

(que por notación se denominará a en la versión

basado en el algoritmo de Lemke) y c

.

microcontrolador

necesitaremos tener también acceso al modelo del mismo, almacenado en los vectores A


, así como los vectores A y B.

del modelo del sistema, el


Todos estos datos son conocidos antes de la ejecución del programa, por lo

calcularlos fuera de línea con MATLAB y crear un





estos datos. Además los declararemos como constantes (

memoria flash del dispositivo en lugar de la RAM, que es la que nos va a limitar.

Así pues, la primera parte del archivo de cabecera contendrá estas declaraciones.

Veamos esta parte del código del generador antes de continuar en su explicación.

Nota: en este generador de código

tanto los parámetros con los que jugaremos en la funci

permitirán sintonizar el controlador serán

%--------------------- %---------- Ramón J. Cuesta Pérez. Proyecto Fin de Carrera close all clear all % Apertura del fichero: nombre def=fopen( 'mat_qp_sensor.h' % Tiempo de muestreo T=2; % Modelo del sistema A=[1 (T-42.7)/42.7]; B=[0 15*T/42.7]; % Punto de linealizacióny_eq=10.5; u_eq=3.5; % Horizonte de control y ponderación de la acción d e controlN=4; lambda=0.5; % Restricciones de controldumin=- 1;dumax=1;umin=1.7

% Valores iniciales de salida, acción de control y referenciaviy=0-y_eq; viu=0- u_eq; ref=0;

%------------- Obtención de las matri

integ=[1 -1]; Avir=conv(integ,A); na=length(A)- 1; nb=length(B)




más los declararemos como constantes (const) para hacer uso de la



igo del generador antes de continuar en su explicación.

este generador de código MPC se ha decidido tomar N1 = 1 y N

tanto los parámetros con los que jugaremos en la función de coste y que por tanto

permitirán sintonizar el controlador serán λ y N.

--------------------- GENERADOR DE CÓDIGO MPC------------------------

Ramón J. Cuesta Pérez. Proyecto Fin de Carrera ------------

% Apertura del fichero: nombre de la cabecera 'mat_qp_sensor.h' , 'wt' );

% Punto de linealización

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

% Restricciones de control 1;dumax=1;umin=1.7 -u_eq;umax=5-u_eq;ymin=0- y_eq;ymax=25

% Valores iniciales de salida, acción de control y referenciau_eq; ref=0;

Obtención de las matri ces del GPC en Matlab --------

1; nb=length(B) -1;



Curso 2011/2012

) para hacer uso de la



igo del generador antes de continuar en su explicación.

N2 = Nu = N. Por

ón de coste y que por tanto nos

------------------------ %

------------ %

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

y_eq;ymax=25 -y_eq;

% Valores iniciales de salida, acción de control y referencia

-------- ----%




F=zeros(N,na+1); poluno=[1 zeros(1,na+1)];Flaux=poluno-Avir; % Matriz F F(1,:)=Flaux(1,2:na+2);for j=1:(N-1) for i=0:na-1; F(j+1,i+1)=F(j,i+2) end F(j+1,na+1)=- F(j,1)*Avir(1,na+2);end % Vectores E E=zeros(N,N); E(1,1)=1; for j=1:(N-1) E(j+1,:)=E(j,:); E(j+1,j+1)=F(j,1);end % Matriz G Gpols=zeros(N,N+nb); for j=1:N Gpols(j,:)=conv(E(j,:),B);end G=zeros(N,N); for j=1:N k=1; for i=j:-1:1 G(j,k)=Gpols(j,i); k=k+1; end end % Matriz G prima Gprima=[]; if (nb>0) Gprima=zeros(N,nb); for j=1:N Gprima(j,:)=Gpols(j,i+j:(j)+nb); end end % Matriz H H=2*(G'*G+lambda*eye(N));




poluno=[1 zeros(1,na+1)];

F(1,:)=Flaux(1,2:na+2);

F(j+1,i+1)=F(j,i+2) -F(j,1)*Avir(1,i+2);

F(j,1)*Avir(1,na+2);

E(j+1,j+1)=F(j,1);

Gpols(j,:)=conv(E(j,:),B);

G(j,k)=Gpols(j,i);

Gprima=zeros(N,nb);

Gprima(j,:)=Gpols(j,i+j:(j)+nb);

H=2*(G'*G+lambda*eye(N));



Curso 2011/2012




% Matriz R R=[eye(N);tril(ones(N,N)); % Matriz Fx Fx=[F Gprima]; % Partes constantes de los vectores a y c uno=ones(N,1); cprima=uno*(dumax- dumin);aprima=dumin*uno'*H;

Nótese que se han calculado las matrices en M

las estructuras explicados detalladamente en el apartado 2.1 de este capítulo.

La única salvedad es la matriz

estás últimas líneas en las que se obtienen unas componentes para la “versión Lemke”

del generador de código.

u = 1u + x para este solver

restricciones de la matriz R, lo cual repercutirá positivamente en el tiempo de cálculo y

la memoria RAM necesaria.

R =

−

−

G

G

T

T

I NxN

El problema QP queda reescrito como

x* = x

minarg 2

1

sujeto a R

Con a = b + u 1TH y f




R=[eye(N);tril(ones(N,N)); -tril(ones(N,N));G;-G];

% Partes constantes de los vectores a y c (versión Lemke)

dumin);

Nótese que se han calculado las matrices en MATLAB siguiendo los procedimientos

explicados detalladamente en el apartado 2.1 de este capítulo.

La única salvedad es la matriz R, y posteriormente lo serán los vectores


. Esto se debe a la realización del cambio de variable

solver (ver capítulo 4), que nos permite eliminar directamente N


la memoria RAM necesaria. La matriz R y el vector c pasan a ser:

c =

( )

++−−−

−++−−−−

−

uGfy

uGfy

tuuTU

tuuTU

uu

1

1

)1(111

)1(111

1

El problema QP queda reescrito como

2

1xTHx + ax + f1

Rx ≤ c

f1 = f0 + 2u 1TH1 + bu



Curso 2011/2012

siguiendo los procedimientos y

explicados detalladamente en el apartado 2.1 de este capítulo.

, y posteriormente lo serán los vectores a (b) y c, de ahí


Esto se debe a la realización del cambio de variable

, que nos permite eliminar directamente N





Las parte constante de todas las componentes de

denominado en la última línea presentada del generador de código como

parte el vector cprima es el que contiene las primeras N componentes de

siempre constantes.

En la implementación de los otros

Gradencial, FIORDOS) no utilizamos explícitamente la matriz

restricciones, por lo que ni ésta ni el vector

generador de código. En dichas versiones tam

anterior y trabajamos con el vector

Una vez calculadas todas las matrices en MATLAB vamos a copiarlas al fichero de

cabecera. Para ello utilizaremos la función

una todas las componentes de las matrices y vectores al fichero que hemos abierto

previamente usando la función

%----------------- Generación del % Escribimos en el fichero la

fprintf(f, '\ tconst double G[%d][%d]={'for i=0:N-1 fprintf(f, '{' ); for j=0:N-1 if j<N-1 fprintf(f, '%.4f, ' else fprintf(f, '%.4f' end end if i<N-1 fprintf(f, '},\n\t \ end end fprintf(f, '}};\n\n' );

Esto, para un ejemplo con N=4, genera el siguiente texto en el archivo de cabecera:

const double G[4][4]={{0.0000, 0.0000, 0.0000, 0.0000}, {0.7026, 0.0000, 0.0000, {1.3722, 0.7026, 0.0000, 0.0000}, {2.0105, 1.3722, 0.7026, 0.0000}};




Las parte constante de todas las componentes de a (u 1TH) es la que hemos

denominado en la última línea presentada del generador de código como

es el que contiene las primeras N componentes de

En la implementación de los otros solvers que aparecerán en el proyecto (Jacobi,

Gradencial, FIORDOS) no utilizamos explícitamente la matriz R para expresar las

restricciones, por lo que ni ésta ni el vector c aparecen en sus respectivas versiones del

generador de código. En dichas versiones tampoco se hace el cambio de variable

anterior y trabajamos con el vector b tal y como se describió en el apartado 2.1.


cabecera. Para ello utilizaremos la función fprintf , con la que vamos añadiendo una a


previamente usando la función fopen .

Generación del archivo de cabecera -----------

% Escribimos en el fichero la matriz G

tconst double G[%d][%d]={' ,N,N);

'%.4f, ' ,G(i+1,j+1));

'%.4f' ,G(i+1,j+1));

\ t\t\t' );


G[4][4]={{0.0000, 0.0000, 0.0000, 0.0000},{0.7026, 0.0000, 0.0000, 0.0000}, {1.3722, 0.7026, 0.0000, 0.0000}, {2.0105, 1.3722, 0.7026, 0.0000}};



Curso 2011/2012

) es la que hemos calculado y

denominado en la última línea presentada del generador de código como aprima . Por su

es el que contiene las primeras N componentes de c, que serán

que aparecerán en el proyecto (Jacobi,

para expresar las

aparecen en sus respectivas versiones del

poco se hace el cambio de variable

tal y como se describió en el apartado 2.1.


a que vamos añadiendo una a


----------- ------%


G[4][4]={{0.0000, 0.0000, 0.0000, 0.0000},




% Escribimos en el fichero la matriz Fx

fprintf(f, '\ tconst double Fx[%d][%d]={'for i=0:size(Fx,1)-1 fprintf(f, '{' ); for j=0:size(Fx,2) if j<size(Fx,2) fprintf(f, '%.4f, ' else fprintf(f, '%.4f' end end if i<size(Fx,1)-1 fprintf(f, '},\n\t \ end end fprintf(f, '}};\n\n' );

El texto generado es:

const double Fx[4][3]={{1.9532, {2.8617, {3.7276, {4.5530, % Escribimos en el fichero el vector A

fprintf(f, '\ tconst double A[%d]={'for i=0:na if i<na fprintf(f, '%f, ' ,A(i+1)); else fprintf(f, '%f};\n \ end end % Escribimos en el fichero el vector B fprintf(f, '\ tconst double B[%d]={'for i=0:nb if i<nb fprintf(f, '%f, ' ,B(i+1)); else fprintf(f, '%f};\n \ end end

A y B aparecen en el fichero cabecera como

const double A[2]={1.000000,

const double B[2]={0.000000, 0.702576};




% Escribimos en el fichero la matriz Fx

tconst double Fx[%d][%d]={' ,size(Fx));

j=0:size(Fx,2) -1 j<size(Fx,2) -1

'%.4f, ' ,Fx(i+1,j+1));

'%.4f' ,Fx(i+1,j+1));

\ t\t\t' );

Fx[4][3]={{1.9532, -0.9532, 0.7026}, {2.8617, -1.8617, 1.3722}, {3.7276, -2.7276, 2.0105}, {4.5530, -3.5530, 2.6190}};

% Escribimos en el fichero el vector A

tconst double A[%d]={' ,na+1);

,A(i+1));

\ n' ,A(i+1));

% Escribimos en el fichero el vector B

tconst double B[%d]={' ,nb+1);

,B(i+1));

\ n' ,B(i+1));

A y B aparecen en el fichero cabecera como:

A[2]={1.000000, -0.953162};

B[2]={0.000000, 0.702576};



Curso 2011/2012




% Escribimos en el fichero la matriz H fprintf(f, '\ tconst double H[%d][%d]={'for i=0:N-1 fprintf(f, '{' ); for j=0:N-1 if j<N-1 fprintf(f, '%.4f, ' else fprintf(f, '%.4f' end end if i<N-1 fprintf(f, '},\n\t \ end end fprintf(f, '}};\n\n' );

Obtenemos una matriz H declarada en el fichero cabecera:

const double H[4][4]={{13.8379, 7.4461, 2.8251, 0.0000}, {7.4461, 5.7533, 1.9282, 0.0000}, {2.8251, 1.9282, 1.9872, 0.0000}, {0.0000, 0.0000, 0.0000, 1.0000}}; % Escribimos en el fichero la matriz R fprintf(f, '\ tconst double R[%d][%d]={'for i=0:5*N-1 fprintf(f, '{' ); for j=0:N-1 if j<N-1 fprintf(f, '%.4f, ' else fprintf(f, '%.4f' end end if i<5*N-1 fprintf(f, '},\n\t \ end end fprintf(f, '}};\n\n' );

La matriz R aparece entonces en el fichero:




fichero la matriz H

tconst double H[%d][%d]={' ,N,N);

'%.4f, ' ,H(i+1,j+1));

'%.4f' ,H(i+1,j+1));

\ t\t\t' );

Obtenemos una matriz H declarada en el fichero cabecera:

H[4][4]={{13.8379, 7.4461, 2.8251, 0.0000},{7.4461, 5.7533, 1.9282, 0.0000}, {2.8251, 1.9282, 1.9872, 0.0000}, {0.0000, 0.0000, 0.0000, 1.0000}};

% Escribimos en el fichero la matriz R

tconst double R[%d][%d]={' ,5*N,N);

'%.4f, ' ,R(i+1,j+1));

'%.4f' ,R(i+1,j+1));

\ t\t\t' );

La matriz R aparece entonces en el fichero:



Curso 2011/2012

H[4][4]={{13.8379, 7.4461, 2.8251, 0.0000},




const double R[20][4]={{1.0000, 0.0000, 0.0000, 0.0000}, {0.0000, 1.0000, 0.0000, 0.0000}, {0.0000, 0.0000, 1.0000, 0.0000}, {0.0000, 0.0000, 0.0000, 1.0000}, {1.0000, 0.0000, 0.0000, 0.0000}, {1.0000, 1.0000, 0.0000, 0.0000}, {1.0000, 1.0000, 1.0000, 0.0000}, {1.0000, 1.0000, 1.0000, 1.0000}, {- 1.0000, {- 1.0000, {- 1.0000, {- 1.0000, {0.0000, 0.0000, 0.0000, 0.0000}, {0.7026, 0.0000, 0.0000, 0.0000}, {1.3722, 0.7026, 0.0000, 0.00 {2.0105, 1.3722, 0.7026, 0.0000}, {- 0.0000, {- 0.7026, {- 1.3722, {- 2.0105,

Llegados a este punto tenemos en nuestro archivo de cabecera todas las matrices y

vectores constantes que dijimos que nos serían necesarios. Sin embargo ya vimos en el

apartado 2.1 de este capítulo

QP, b (a, tras el cambio de variable en Lemke) y

deberemos diseñar una función capaz de actualizar estos vectores en tiempo de

ejecución. Para este fin, además,

y(t), los m últimos de de ∆u(t) y, por tanto, los m+1

grados de los polinomios de A(z

gestionar las futuras referencias. Por

permitiese simular el sistema una vez obtenida la señal de control óptima, o bien una

función para actualizar los vectores

controlando una planta real.

Estas necesidades motivan la creación de una clase de C++ que contenga todas estas

variables y funciones o métodos. La idea de crear una clase es la de encapsular y

condensar los datos y funciones, de tal modo que la programación sea más clara y

elegante. Además la clase de definirá en el propio archivo de cabecera, con lo que se

adaptará a las dimensiones del modelo y horizonte de control elegidos.




R[20][4]={{1.0000, 0.0000, 0.0000, 0.0000},{0.0000, 1.0000, 0.0000, 0.0000}, {0.0000, 0.0000, 1.0000, 0.0000}, {0.0000, 0.0000, 0.0000, 1.0000}, {1.0000, 0.0000, 0.0000, 0.0000}, {1.0000, 1.0000, 0.0000, 0.0000}, {1.0000, 1.0000, 1.0000, 0.0000}, {1.0000, 1.0000, 1.0000, 1.0000},

1.0000, -0.0000, -0.0000, -0.0000}, 1.0000, -1.0000, -0.0000, -0.0000}, 1.0000, -1.0000, -1.0000, -0.0000}, 1.0000, -1.0000, -1.0000, -1.0000},

{0.0000, 0.0000, 0.0000, 0.0000}, {0.7026, 0.0000, 0.0000, 0.0000}, {1.3722, 0.7026, 0.0000, 0.00 00}, {2.0105, 1.3722, 0.7026, 0.0000},

0.0000, -0.0000, -0.0000, -0.0000}, 0.7026, -0.0000, -0.0000, -0.0000}, 1.3722, -0.7026, -0.0000, -0.0000}, 2.0105, -1.3722, -0.7026, -0.0000}};



apartado 2.1 de este capítulo que los otros dos vectores que aparecían en el problema

, tras el cambio de variable en Lemke) y c, varían en cada iteración. Por tanto


Para este fin, además, deberemos ir almacenar los n+1 últimos valores de

∆u(t) y, por tanto, los m+1 últimos de u(t), donde n y m son los

grados de los polinomios de A(z-1) y B(z-1) respectivamente. Además hemos de

gestionar las futuras referencias. Por último sería necesario crear una función que nos


función para actualizar los vectores u e y tras cada tiempo de muestreo cuando estemos

controlando una planta real.

as necesidades motivan la creación de una clase de C++ que contenga todas estas



más la clase de definirá en el propio archivo de cabecera, con lo que se

adaptará a las dimensiones del modelo y horizonte de control elegidos.



Curso 2011/2012

R[20][4]={{1.0000, 0.0000, 0.0000, 0.0000},



que los otros dos vectores que aparecían en el problema

, varían en cada iteración. Por tanto


deberemos ir almacenar los n+1 últimos valores de

últimos de u(t), donde n y m son los

Además hemos de

último sería necesario crear una función que nos


tras cada tiempo de muestreo cuando estemos

as necesidades motivan la creación de una clase de C++ que contenga todas estas



más la clase de definirá en el propio archivo de cabecera, con lo que se




A continuación se presenta la segunda parte del generador de código, donde se crea en

el fichero de cabecera la clase, así como su constructor y demás métodos.

Para el generador de código destinado al

% Escribimos en el fichero la definición de la clas e qpmfprintf(f, 'class qpm\ n{ fprintf(f, 'public:\n' );

fprintf(f, '\ tdouble c[%d];fprintf(f, '\ tdouble a[%d];fprintf(f, '\ tdouble y[%d];fprintf(f, '\ tdouble u[%d];fprintf(f, '\ tdouble du[%d];fprintf(f, '\ tdouble xu[%d];fprintf(f, '\ tdouble w[%d];fprintf(f, '\ tdouble uant;fprintf(f, '\ tqpm(void); //Constructorfprintf(f, '\ tvoid get_xuw(double *ref, double *y, double *du, d ouble u); //Actualiza los vectores xu y wfprintf(f, '\ tvoid get_ac(void); //Actualiza a y cfprintf(f, '\ tvoid sim(double uk); //Simulacion del sistemafprintf(f, '\ tvoid act(double uk, double y_in); //Lectura de sen sores y actualizacion\n' ); fprintf(f, '};\n\n' );

La clase qpm aparece entonces

class qpm { public : double c[20]; double a[4]; double y[2]; double u[2]; double du[1]; double xu[3]; double w[4]; double uant; qpm( void ); void get_xuw( double void get_ac( void void sim( double void act( double};

Las versiones de Jacobi y Gradencial no incluyen el vector

son ligeramente diferentes a esta versión de Lemke. Las

denominan respectivamente





clase, así como su constructor y demás métodos.

Para el generador de código destinado al solver de Lemke la clase se denomina

% Escribimos en el fichero la definición de la clas e qpm n{ \n' );

);

tdouble c[%d]; \n' ,5*N); tdouble a[%d]; \n' ,N); tdouble y[%d]; \n' ,na+1); tdouble u[%d]; \n' ,nb+1); tdouble du[%d]; \n' ,nb); tdouble xu[%d]; \n' ,size(Fx,2)); tdouble w[%d]; \n' ,N); tdouble uant; \n' ); tqpm(void); //Constructor \n' ); tvoid get_xuw(double *ref, double *y, double *du, d ouble

u); //Actualiza los vectores xu y w \n' ); tvoid get_ac(void); //Actualiza a y c \n' ); tvoid sim(double uk); //Simulacion del sistematvoid act(double uk, double y_in); //Lectura de sen sores y

aparece entonces declarada en el fichero:

double *ref, double *y, double *du, doublevoid );

double uk); double uk, double y_in);

Las versiones de Jacobi y Gradencial no incluyen el vector c, por lo que sus prototipos

son ligeramente diferentes a esta versión de Lemke. Las clases, en dichos casos, se

ominan respectivamente jbm y grm:



Curso 2011/2012


clase, así como su constructor y demás métodos.

de Lemke la clase se denomina qpm:

tvoid get_xuw(double *ref, double *y, double *du, d ouble

tvoid sim(double uk); //Simulacion del sistema \n' ); tvoid act(double uk, double y_in); //Lectura de sen sores y

double u);

, por lo que sus prototipos

clases, en dichos casos, se




class jbm { public : double b[4]; double y[2]; double u[2]; double du[1]; double xu[3]; double w[4]; double uant; jbm( void ); void get_xuw( double void get_b( void void sim( double void act( double};

class grm { public : double b[4]; double y[2]; double u[2]; double du[1]; double xu[3]; double w[4]; double uant; grm( void ); void get_xuw( double void get_b( void void sim( double void act( double};

Nótese que al no aparecer cadelante. Retomamos ahora la clase qpm y programamos su los valores iniciales a las variables de la clase. % Definición del constructor fprintf(f, 'qpm::qpm(void)

for i=0:na fprintf(f, '\ ty[%d]=%f;end for i=0:nb fprintf(f, '\ tu[%d]=%f;end








c el método get_ac se sustituye por get_b, como se verá más

la clase qpm y programamos su constructor, en el cual se asignan los valores iniciales a las variables de la clase.

% Definición del constructor

'qpm::qpm(void) \n{\n' );

ty[%d]=%f; \n' ,i,viy);

tu[%d]=%f; \n' ,i,viu);



Curso 2011/2012

double u);

double u);

, como se verá más

, en el cual se asignan




for i=0:nb-1 fprintf(f, '\ tdu[%d]=%f;end for i=0:N-1 fprintf(f, '\ tw[%d]=%f;end fprintf(f, '\tuant=%f; \

fprintf(f, '}\n\n' );

Constructor en el fichero:

qpm:: qpm( void ) { y[0]=- 10.500000; y[1]=- 10.500000; u[0]=- 3.500000; u[1]=- 3.500000; du[0]=0.0 00000; w[0]=0.000000; w[1]=0.000000; w[2]=0.000000; w[3]=0.000000; uant=- 3.500000;}

Pasamos ahora a definir el método

actualiza el vector de referencias futuras (

y por otra compone con valores pasados de y(t) y

por la matriz Fx nos dará el valor de

% Definición del método get_xuw fprintf(f, 'void qpm::get_xuw(double *ref, double *y, double * du, double u)\n{\n' ); fprintf(f, '\tuant=u;\ n'fprintf(f, '\ tfor(int i=0;i<%d;i++)fprintf(f, '\ tw[i]=ref[i];fprintf(f, '\ tfor(int i=0;i<%d;i++)fprintf(f, '\t\ tif(i<%d)fprintf(f, '\t\ txu[i]=y[i];fprintf(f, '\t\telse\ n'fprintf(f, '\t\ txu[i]=du[ifprintf(f, '\t}\n}\n\ n'




tdu[%d]=%f; \n' ,i,viu);

tw[%d]=%f; \n' ,i,ref);

\ n' ,viu);

10.500000; 10.500000; 3.500000; 3.500000;

00000;

3.500000;

Pasamos ahora a definir el método get_xuw, que tiene una función doble: por una parte

actualiza el vector de referencias futuras (w) y el valor uant (acción de control anterior),

y por otra compone con valores pasados de y(t) y ∆u(t) el vector xu, que multiplicado

nos dará el valor de f, como se explicó en el apartado 2.1 (página 15).

% Definición del método get_xuw

'void qpm::get_xuw(double *ref, double *y, double * du,

n' ); tfor(int i=0;i<%d;i++) \n' ,N); tw[i]=ref[i]; \n' ); tfor(int i=0;i<%d;i++) \n\t{\n' ,size(Fx,2));

tif(i<%d) \n' ,na+1); txu[i]=y[i]; \n' );

n' ); txu[i]=du[i -%d];\n' ,na+1);

n' );



Curso 2011/2012

, que tiene una función doble: por una parte

(acción de control anterior),

, que multiplicado

, como se explicó en el apartado 2.1 (página 15).

'void qpm::get_xuw(double *ref, double *y, double * du,




Método get_xuw en el fichero:

void qpm:: get_xuw( double{ uant=u; for ( int i=0;i<4;i++) w[i]=ref[i]; for ( int i=0;i<3;i++) { if (i<2) xu[i]=y[i]; else xu[i]=du[i - } }

Es ahora el turno del método

equivalente de las otras versiones,

no hay que sumarle la parte constante que se le suma

calculamos el vector c.

% Definición del método get_ac fprintf(f, 'void qpm::get_ac(void) fprintf(f, '\ tdouble vaux;fprintf(f, '\ tdouble aux[%d];fprintf(f, '\ tdouble auxx[%d];

Después de declarar una serie de variables auxiliares procedemos al cálculo del vector

(b, en get_b). Recordemos las expresiones de

a =

El término u 1TH constante de a lo tenemos ya almacenado en el vector de MATLAB

aprima . Por tanto vamos a calcular el vector

%Vector a fprintf(f, '\n\ tfor(int i=0;i<%d;i++){ fprintf(f, '\t\ tvaux=0; fprintf(f, '\t\ tfor(int j=0;j<%d;j++) fprintf(f, '\t\ tvaux=vaux+Fx[i][j]*xu[j]; fprintf(f, '\t\ taux[i]=vaux

En este primer bucle anidado hemos calculado

Este resultado provisional queda almacenado en el vector




Método get_xuw en el fichero:

double *ref, double *y, double *du,

i=0;i<4;i++)

i=0;i<3;i++)

xu[i]=y[i];

- 2];

Es ahora el turno del método get_ac, propio de la versión Lemke

equivalente de las otras versiones, get_b, es idéntico, con la salvedad de que al vector

no hay que sumarle la parte constante que se le suma a, y porque en

% Definición del método get_ac

'void qpm::get_ac(void) \n{\n' );

tdouble vaux; \n\n' ); tdouble aux[%d]; \n' ,N); tdouble auxx[%d]; \n' ,N);

Después de declarar una serie de variables auxiliares procedemos al cálculo del vector

). Recordemos las expresiones de a y b:

= b + u 1TH ; b = 2·(f − w)TG

constante de a lo tenemos ya almacenado en el vector de MATLAB

. Por tanto vamos a calcular el vector b y luego le sumaremos este término.

tfor(int i=0;i<%d;i++){ \n' ,N); tvaux=0; \n' ); tfor(int j=0;j<%d;j++) \n' ,size(Fx,2)); tvaux=vaux+Fx[i][j]*xu[j]; \n' ); taux[i]=vaux -w[i];\n\t}\n' );

En este primer bucle anidado hemos calculado f − w, teniendo en cuenta que

Este resultado provisional queda almacenado en el vector aux.



Curso 2011/2012

*du, double u)

, propio de la versión Lemke. El método

, es idéntico, con la salvedad de que al vector b

, y porque en get_b no

Después de declarar una serie de variables auxiliares procedemos al cálculo del vector a

constante de a lo tenemos ya almacenado en el vector de MATLAB

y luego le sumaremos este término.

, teniendo en cuenta que f = Fx xu.




fprintf(f, '\n\ tfor(int i=0;i<%d;i++){ fprintf(f, '\t\ tvaux=0; fprintf(f, '\t\ tfor(int j=0;j<%d;j++) fprintf(f, '\t\ tvaux=vaux+aux[j]*G[j][i]; fprintf(f, '\t\ tauxx[i]=2*vaux;

En este segundo bucle completamos el cálculo de b, multiplicando primero por G y

luego por 2, de tal modo que tenemos

función get_b ya habríamos

constante almacenado en aprima

for i=0:N-1 fprintf(f, '\ ta[%d]=auxx[%d]+%.4f;end

En este punto ya tenemos lista la expresión de

que aparece en el fichero sumando a cada componente de

Pasamos ahora a calcular c.

En primer lugar escribimos en el fichero las N primeras componentes, que son

constantes y están almacenadas en el vector de MATLAB

%Vector c for i=0:N-1 fprintf(f, '\ tc[%d]=%.4f;end

Las siguientes 2N componentes tienen una parte constante, calculada en MATLAB

como umax-(i-N+1)*dumin,




tfor(int i=0;i<%d;i++){ \n' ,N); tvaux=0; \n' ); tfor(int j=0;j<%d;j++) \n' ,N); tvaux=vaux+aux[j]*G[j][i]; \n' ); tauxx[i]=2*vaux; \n\t}\n\n' );


luego por 2, de tal modo que tenemos b = 2·(f − w)TG almacenado en

ya habríamos terminado. Para obtener ahora a sumamos el término

aprima :

ta[%d]=auxx[%d]+%.4f; \n' ,i,i,aprima(i+1));

punto ya tenemos lista la expresión de a, descompuesta en un valor constante

que aparece en el fichero sumando a cada componente de auxx.

. Recordemos su expresión:

c =

( )

++−−−

−++−−−−

−

uGfy

uGfy

tuuTU

tuuTU

uu

1

1

)1(111

)1(111

1


constantes y están almacenadas en el vector de MATLAB cprima .

tc[%d]=%.4f; \n' ,i,cprima(i+1));


N+1)*dumin, más/menos el valor de la variable uant:



Curso 2011/2012


almacenado en auxx. En la

terminado. Para obtener ahora a sumamos el término

, descompuesta en un valor constante






for i=N:2*N-1 fprintf(f, '\ tc[%d]=%fend for i=2*N:3*N-1 fprintf(f, '\ tc[%d]=%f+uant;end

Finalmente las 2N últimas componentes

multiplicación por G. Por ello se calcularan de forma análoga a la explicada con el

vector a. Estas componentes están formadas por tres

primer sumando lo tenemos almacenado en las variable

podemos escribir directamente en el fichero. El segundo sumando,

obtener del cálculo realizado anteriormente para el vector

almacenado en aux el vector

sumando necesitamos usar un bucle

multiplicarla posteriormente por

fprintf(f, '\n\ tfor(int i=0;i<%d;i++){fprintf(f, '\t\ tvaux=0;fprintf(f, '\t\ tfor(int j=0;j<%d;j++)fprintf(f, '\t\ tvaux=vaux+G[i][j];fprintf(f, '\t\ tc[i+%d]=%dw[i];\n\t}\n\n' ,3*N,ymax,dumin); fprintf(f, '\n\ tfor(int i=0;i<%d;i++){fprintf(f, '\t\ tvaux=0;fprintf(f, '\t\ tfor(int j=0;j<%d;j++)fprintf(f, '\t\ tvaux=vaux+G[i][j];fprintf(f, '\t\ tc[i+%d]=1*%d+vaux*%d+aux[i]+w[i];

El método get_ac aparecerá

void qpm:: get_ac( void{ double vaux; double aux[4]; double auxx[4]; for ( int i=0;i<4;i++){ vaux=0; for ( int j=0;j<3;j++) vaux=vaux+Fx[i][j]*xu[j]; aux[i]=vaux }




tc[%d]=%f -1*uant;\n' ,i,umax-(i- N+1)*dumin);

tc[%d]=%f+uant; \n' ,i,-umin+(i- 2*N+1)*dumin);

Finalmente las 2N últimas componentes dependen de f y además requieren una

. Por ello se calcularan de forma análoga a la explicada con el

Estas componentes están formadas por tres sumandos: y /

primer sumando lo tenemos almacenado en las variable ymax /ymin de MATLAB y l

podemos escribir directamente en el fichero. El segundo sumando,

obtener del cálculo realizado anteriormente para el vector a, donde habíamos

el vector f – w. Por tanto, f = aux + w. Para calcular el último

sumando necesitamos usar un bucle for para obtener la suma por filas de

icarla posteriormente por u . Así, la programación nos queda:

tfor(int i=0;i<%d;i++){ \n' ,N); tvaux=0; \n' ); tfor(int j=0;j<%d;j++) \n' ,N); tvaux=vaux+G[i][j]; \n' ); tc[i+%d]=%d -1*vaux*%d-aux[i]-

,3*N,ymax,dumin);

tfor(int i=0;i<%d;i++){ \n' ,N); tvaux=0; \n' ); tfor(int j=0;j<%d;j++) \n' ,N); tvaux=vaux+G[i][j]; \n' ); tc[i+%d]= -

1*%d+vaux*%d+aux[i]+w[i]; \n\t}\n}\n' ,4*N,ymin,dumin);

aparecerá en el fichero como:

void )

auxx[4];

i=0;i<4;i++){

j=0;j<3;j++) vaux=vaux+Fx[i][j]*xu[j]; aux[i]=vaux -w[i];



Curso 2011/2012

N+1)*dumin);

2*N+1)*dumin);

y además requieren una

. Por ello se calcularan de forma análoga a la explicada con el

y/ , f y Gu . El

de MATLAB y lo

podemos escribir directamente en el fichero. El segundo sumando, f, lo podemos

, donde habíamos

. Para calcular el último

para obtener la suma por filas de G y




for ( int i=0;i<4;i++){ vaux=0; for ( int j=0;j<4;j++) vaux=vaux+aux[j]*G[j][i]; auxx[i]=2*vaux; } a[0]=auxx[0]+- 24.1092; a[1]=auxx[1]+- 15.1277; a[2]=auxx[2]+- 6.7406; a[3]=auxx[3]+- 1.0000;

c[0]=2.0000; c[1]=2.0000; c[2]=2.0000; c[3]=2.0000; c[4]=2.500000- 1*uant; c[5]=3.500000- 1*uant; c[6]=4.500000- 1*uant; c[7]=5.500000- 1*uant; c[8]=0.800000+uant; c[9]=- 0.200000+uant; c[10]=- 1.200000+uant; c[11]=- 2.200000+uant;

for ( int i=0;i<4;i++){ vaux=0; for ( int j=0;j<4;j++) vaux=vaux+G[i][j]; c[i+12]=1.450000e+001 } for ( int i=0;i<4;i++){ vaux=0; for ( int j=0;j<4;j++) vaux=vaux+G[i][j]; c[i+16]=- 1* } }

Se recomienda volver a leer las explicaciones de cómo se obtienen las distintas

componentes de los vectores

por delante para mayor claridad.

Nótese que para que el cálculo de

previamente a la función get_xuw

iteración actual del algoritmo.




i=0;i<4;i++){

j=0;j<4;j++) vaux=vaux+aux[j]*G[j][i]; auxx[i]=2*vaux;

24.1092; 15.1277; 6.7406; 1.0000;

1*uant; 1*uant; 1*uant; 1*uant;

c[8]=0.800000+uant; 0.200000+uant;

1.200000+uant; 2.200000+uant;

i=0;i<4;i++){

j=0;j<4;j++) vaux=vaux+G[i][j]; c[i+12]=1.450000e+001 -1*vaux*-1-aux[i]-w[i];

i=0;i<4;i++){

j=0;j<4;j++) vaux=vaux+G[i][j];

1* -1.050000e+001+vaux*- 1+aux[i]+w[i];

volver a leer las explicaciones de cómo se obtienen las distintas

componentes de los vectores a y c con el código generado (el que aparece recuadrado)

por delante para mayor claridad.

Nótese que para que el cálculo de a y c sea correcto debemos haber llam

get_xuw para que el cálculo de f sea el correspondiente a la

iteración actual del algoritmo.



Curso 2011/2012

1+aux[i]+w[i];

volver a leer las explicaciones de cómo se obtienen las distintas

con el código generado (el que aparece recuadrado)

sea correcto debemos haber llamado

sea el correspondiente a la




Por su parte, el código generado para el método

void jbm:: get_b( void{ double vaux; double aux[4]; for ( int i=0;i<4;i++){ vaux=0; for ( int j=0;j<3;j++) vaux=vaux+Fx[i][j]*xu[j]; aux[i]=vaux } for ( int i=0;i<4;i++){ vaux=0; for ( int j=0;j<4;j++) vaux=vaux+aux[j]*G[j][i]; b[i]=2*vaux; } }

Pasamos ahora a explicar la función de simulación, cuyo cometido es actualizar las

variables que forman parte de la clase

desplazamiento y simular la salida que tendría el sistema al aplicar l

que nos haya proporcionado el

dado por los vectores A(z

continuación:

% Definición del método sim (simulación)

fprintf(f, '\ nvoid qpm::sim(double uk)fprintf(f, '\ tfor(int i=%d;i>0;ifprintf(f, '\tu[i]=u[i -fprintf(f, '\tu[0]=uk; \fprintf(f, '\tuant=uk; \fprintf(f, '\ tfor(int i=%d;i>0;ifprintf(f, '\ tdu[i]=du[ifprintf(f, '\t du[0]=u[0]fprintf(f, '\ tdouble aux=0;fprintf(f, '\ tfor(int i=0;i<%d;i++)fprintf(f, '\taux=aux- A[i+1]*y[i];fprintf(f, '\ tfor(int i=0;i<%d;i++)fprintf(f, '\ taux=aux+B[i]*u[i];fprintf(f, '\ tfor(int i=%d;i>0;ifprintf(f, '\ty[i]=y[i -fprintf(f, '\ ty[0]=aux;fprintf(f, '}\n' );




Por su parte, el código generado para el método get_b sería:

void )

i=0;i<4;i++){

j=0;j<3;j++) vaux=vaux+Fx[i][j]*xu[j]; aux[i]=vaux -w[i];

i=0;i<4;i++){

j=0;j<4;j++) vaux=vaux+aux[j]*G[j][i]; b[i]=2*vaux;

asamos ahora a explicar la función de simulación, cuyo cometido es actualizar las

variables que forman parte de la clase tratando los vectores como registros de

y simular la salida que tendría el sistema al aplicar la acción de control

que nos haya proporcionado el solver. Para ello utilizaremos el modelo del proceso

dado por los vectores A(z-1) y B(z-1). El código es simple, tal y como se muestra a

% Definición del método sim (simulación)

nvoid qpm::sim(double uk) \n{\n ' ); tfor(int i=%d;i>0;i --)\n' ,nb);

- 1];\n' ); \ n' ); \ n' );

tfor(int i=%d;i>0;i --)\n' ,nb-1); tdu[i]=du[i -1];\n' );

du[0]=u[0] -u[1];\n' ); tdouble aux=0; \n' ); tfor(int i=0;i<%d;i++) \n' ,na);

A[i+1]*y[i]; \n' ); tfor(int i=0;i<%d;i++) \n' ,nb+1); taux=aux+B[i]*u[i]; \n' ); tfor(int i=%d;i>0;i --)\n' ,na);

- 1];\n' ); ty[0]=aux; \n' );



Curso 2011/2012

asamos ahora a explicar la función de simulación, cuyo cometido es actualizar las

tratando los vectores como registros de

a acción de control

. Para ello utilizaremos el modelo del proceso

. El código es simple, tal y como se muestra a




Método sim en el fichero:

void qpm:: sim( double{ for ( int i=1;i>0;i u[i]=u[i-1]; u[0]=uk; uant=uk; for ( int i=0;i>0;i du[i]=du[i-1]; du[0]=u[0]- u[1]; double aux=0; for ( int i=0;i<1;i++) aux=aux- A[i+1]*y[i]; for ( int i=0;i<2;i++) aux=aux+B[i]*u[i]; for ( int i=1;i>0;i y[i]=y[i-1]; y[0]=aux; }

En el caso en el que estemos controlando una planta real y no usando la función de

simulación debemos realizar una llamada a otra función que realice el mismo cometido

que la anteriormente explicada, con la salvedad de que el nuevo valor de y(t) no será

simulado, sino leído de los sensores. Para ello programamos el método

% Definición del método act (control de planta real )

fprintf(f, '\ nvoid qpm::act(double uk, double y_in)fprintf(f, '\ tfor(int i=%d;i>0;ifprintf(f, '\tu[i]=u[i -fprintf(f, '\tu[0]=uk; \fprintf(f, '\tuant=uk; \fprintf(f, '\ tfor(int i=%d;i>0;ifprintf(f, '\ tdu[i]=du[ifprintf(f, '\ tdu[0]=u[0]fprintf(f, '\ tfor(int i=%d;i>0;ifprintf(f, '\ty[i]=y[i -fprintf(f, '\ ty[0]=y_in;fprintf(f, '}\n' );




double uk)

i=1;i>0;i --)

i=0;i>0;i --)

u[1];

i=0;i<1;i++) A[i+1]*y[i]; i=0;i<2;i++)

aux=aux+B[i]*u[i]; i=1;i>0;i --)




mulado, sino leído de los sensores. Para ello programamos el método act

% Definición del método act (control de planta real )

nvoid qpm::act(double uk, double y_in) \n{\n ' );tfor(int i=%d;i>0;i --)\n' ,nb);

- 1];\n' ); \ n' ); \ n' );

tfor(int i=%d;i>0;i --)\n' ,nb-1); tdu[i]=du[i -1];\n' ); tdu[0]=u[0] -u[1];\n' ); tfor(int i=%d;i>0;i --)\n' ,na);

- 1];\n' ); ty[0]=y_in; \n' );



Curso 2011/2012




act:

);




Método act en el fichero:

void qpm:: act( double{ for ( int i=1;i>0;i u[i]=u[i-1]; u[0]=uk; uant=uk; for ( int i=0;i>0;i du[i]=du[i-1]; du[0]=u[0]- u[1]; for ( int i=1;i>0;i y[i]=y[i-1]; y[0]=y_in; }

Una vez tenemos todos los métodos de la clase definidos en el archivo de cabecera

podemos cerrar el fichero, concluyendo asimismo la explicación del generador de

código.

%Cerramos el fichero fclose(f); Véanse los anexos o la carpeta de archivos del capítulo 2 del CD

los códigos sin interrupciones tanto de las diferentes versiones de generador de código

como de los archivos de cabecera generados.

2.3 Bibliografía del capítulo

Camacho, EF. Constrained Generalized Predictive Control.

IEEE Transactions on Automatic Control

Vol 38, No. 2, February 1993

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,

3ª ed.

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

Escuela Superior de Ingenieros. Universidad de Sevilla. 2011




double uk, double y_in)

i=1;i>0;i --)

i=0;i>0;i --)

u[1]; i=1;i>0;i --)



Véanse los anexos o la carpeta de archivos del capítulo 2 del CD-ROM para visualizar


como de los archivos de cabecera generados.

ibliografía del capítulo

Constrained Generalized Predictive Control.

IEEE Transactions on Automatic Control

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 Control

Escuela Superior de Ingenieros. Universidad de Sevilla. 2011



Curso 2011/2012



ROM para visualizar


Apuntes y transparencias de Ingeniería de Control

Generador de código en MATLAB para matrices y...

Documents

Transcript of Generador de código en MATLAB para matrices y...