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
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 8 Ramón Jesús Cuesta Pérez
Capítulo 2
Generador de código en MATLAB para matrices y
métodos MPC
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
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
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
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 9 Ramón Jesús Cuesta Pérez
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.
No obstante las ideas generales en que se basan todo estos algoritmos son las mismas,
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
respuesta impulsional. Su modelo comercial se denomina IDCOM.
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
transferencia, modelos con los que cualquier estudiante de Ingeniería de Control se
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:
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
(Control Predictivo basado en Modelo) existen
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,
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
respuesta impulsional. Su modelo comercial se denomina IDCOM.
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
transferencia, modelos con los que cualquier estudiante de Ingeniería de Control se
que nos decantemos por este tipo de
, conviene recordar las principales ventajas
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
- 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
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 10 Ramón Jesús Cuesta Pérez
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.
Una vez justificada la elección del algoritmo y comentadas sus ventajas e
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
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
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
Una vez justificada la elección del algoritmo y comentadas sus ventajas e
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
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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(
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 11 Ramón Jesús Cuesta Pérez
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
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-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
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
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
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
que aparecen en la función de
) ha de tener la forma:
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 12 Ramón Jesús Cuesta Pérez
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.
El primer sumatorio incluye los errores futuros al cuadrado y el segundo los
incrementos de acción de control al cuadrado, ponderados por un factor
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 de coste comenzamos con el algoritmo
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 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)
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
es de tipo cuadrática:
]t 2)|1
referencia, de la cual podemos conocer sus valores futuros.
El primer sumatorio incluye los errores futuros al cuadrado y el segundo los
factor λ. La elección
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,
e coste comenzamos con el algoritmo
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.
que hemos tomado C(z-1) = 1.
. Si dividimos el polinomio 1
) y como resto z-jFj(z-1).
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 13 Ramón Jesús Cuesta Pérez
1) zj∆ obtenemos:
)()|1()()( 111 zEtdjtuzBzE jj +−−+∆= −−−
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 Ej(z-1) es j
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()()()() 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)
Llegados a este punto es importante señalar que existe otra forma más eficiente de
(z-1) y Ej(z-1) (y por ende Gj(z
-1)) desde el punto de vista
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 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).
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
)() jte + (3)
Teniendo en cuenta que el valor esperado del ruido blanco es cero, sus valores futuros
) es j-1 y por tanto
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):
(4)
(5)
Llegados a este punto es importante señalar que existe otra forma más eficiente de
el punto de vista
computacional que realizando la división de polinomios. En efecto, estos polinomios se
pueden calcular de manera iterativa, como argumentaremos a continuación.
) 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
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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) , … ,
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 14 Ramón Jesús Cuesta Pérez
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
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
)()|()|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
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
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
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
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 15 Ramón Jesús Cuesta Pérez
+−+
+
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
anterior. De esta forma se simplifica el cálculo computacional, y es el método que se
en el generador de código programado.
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
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
anterior. De esta forma se simplifica el cálculo computacional, y es el método que se
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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.
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 16 Ramón Jesús Cuesta Pérez
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. 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.
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
Una vez definida la predicción pasamos a la fase de optimización, la cual nos
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
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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.
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 17 Ramón Jesús Cuesta Pérez
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
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 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.
Una vez definido totalmente el problema QP utilizaremos un algoritmo de optimización
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
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 estimado. Por tanto
u(t+1|t) y así sucesivamente. Es lo que se denomina estrategia de
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
Para definir el problema QP solo falta expresar las restricciones de modo que la
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
. 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
Una vez definido totalmente el problema QP utilizaremos un algoritmo de optimización
*, que contiene los N futuros ∆u que
De todos estos N
u(t|t), y desechamos el
resto. Hacemos esto porque en el siguiente tiempo de muestreo calcularemos
timado. Por tanto ∆u(t+1|t+1)
í sucesivamente. Es lo que se denomina estrategia de
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 18 Ramón Jesús Cuesta Pérez
Aplicaremos pues la señal de control calculada y comenzaremos una nueva iteración,
donde volveremos a predecir las salidas futuras del sistema y optimizaremos las señales
de control que hay que ir aplicando, quedándonos siempre con la primera y desechando
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
Por tanto, a la hora de ejecutar la aplicación que programemos necesitaremos tener
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
horizonte de control y el factor de ponderación de la acción de control en la función
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
archivo de cabecera para incluir en el programa del microcontrolador que contenga
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
Aplicaremos pues la señal de control calculada y comenzaremos una nueva iteración,
s futuras del sistema y optimizaremos las señales
de control que hay que ir aplicando, quedándonos siempre con la primera y desechando
, 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
Por tanto, a la hora de ejecutar la aplicación que programemos necesitaremos tener
, así como los vectores A y B.
del modelo del sistema, el
horizonte de control y el factor de ponderación de la acción de control en la función
Todos estos datos son conocidos antes de la ejecución del programa, por lo
calcularlos fuera de línea con MATLAB y crear un
archivo de cabecera para incluir en el programa del microcontrolador que contenga
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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)
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 19 Ramón Jesús Cuesta Pérez
más los declararemos como constantes (const) para hacer uso de la
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.
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;
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
) para hacer uso de la
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.
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
-------- ----%
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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));
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 20 Ramón Jesús Cuesta Pérez
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));
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
% 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
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 21 Ramón Jesús Cuesta Pérez
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
estás últimas líneas en las que se obtienen unas componentes para la “versión Lemke”
. Esto se debe a la realización del cambio de variable
solver (ver capítulo 4), que nos permite eliminar directamente N
restricciones de la matriz R, lo cual repercutirá positivamente en el tiempo de cálculo y
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
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
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í
estás últimas líneas en las que se obtienen unas componentes para la “versión Lemke”
Esto se debe a la realización del cambio de variable
, que nos permite eliminar directamente N
restricciones de la matriz R, lo cual repercutirá positivamente en el tiempo de cálculo y
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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}};
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 22 Ramón Jesús Cuesta Pérez
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.
Una vez calculadas todas las matrices en MATLAB vamos a copiarlas al fichero de
cabecera. Para ello utilizaremos la función fprintf , con la que vamos añadiendo una a
una todas las componentes de las matrices y vectores al fichero que hemos abierto
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' );
Esto, para un ejemplo con N=4, genera el siguiente texto en el archivo de cabecera:
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}};
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
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.
Una vez calculadas todas las matrices en MATLAB vamos a copiarlas al fichero de
a que vamos añadiendo una a
una todas las componentes de las matrices y vectores al fichero que hemos abierto
----------- ------%
Esto, para un ejemplo con N=4, genera el siguiente texto en el archivo de cabecera:
G[4][4]={{0.0000, 0.0000, 0.0000, 0.0000},
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
% 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};
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 23 Ramón Jesús Cuesta Pérez
% 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};
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
% 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:
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 24 Ramón Jesús Cuesta Pérez
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:
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
H[4][4]={{13.8379, 7.4461, 2.8251, 0.0000},
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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.
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 25 Ramón Jesús Cuesta Pérez
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}};
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 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
deberemos diseñar una función capaz de actualizar estos vectores en tiempo de
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
permitiese simular el sistema una vez obtenida la señal de control óptima, o bien una
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
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
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.
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
R[20][4]={{1.0000, 0.0000, 0.0000, 0.0000},
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
que los otros dos vectores que aparecían en el problema
, varían en cada iteración. Por tanto
deberemos diseñar una función capaz de actualizar estos vectores en tiempo de
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
permitiese simular el sistema una vez obtenida la señal de control óptima, o bien una
tras cada tiempo de muestreo cuando estemos
as 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
más la clase de definirá en el propio archivo de cabecera, con lo que se
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 26 Ramón Jesús Cuesta Pérez
A continuación se presenta la segunda parte del generador de código, donde se crea en
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:
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
A continuación se presenta la segunda parte del generador de código, donde se crea en
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
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 27 Ramón Jesús Cuesta Pérez
double *ref, double *y, double *du, doublevoid );
double uk); double uk, double y_in);
double *ref, double *y, double *du, doublevoid );
double uk); double uk, double y_in);
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);
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
double u);
double u);
, como se verá más
, en el cual se asignan
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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'
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 28 Ramón Jesús Cuesta Pérez
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' );
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
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,
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 29 Ramón Jesús Cuesta Pérez
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.
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
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.
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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,
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 30 Ramón Jesús Cuesta Pérez
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' );
En este segundo bucle completamos el cálculo de b, multiplicando primero por G y
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
En primer lugar escribimos en el fichero las N primeras componentes, que son
constantes y están almacenadas en el vector de MATLAB cprima .
tc[%d]=%.4f; \n' ,i,cprima(i+1));
Las siguientes 2N componentes tienen una parte constante, calculada en MATLAB
N+1)*dumin, más/menos el valor de la variable uant:
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
En este segundo bucle completamos el cálculo de b, multiplicando primero por G y
almacenado en auxx. En la
terminado. Para obtener ahora a sumamos el término
, descompuesta en un valor constante
En primer lugar escribimos en el fichero las N primeras componentes, que son
Las siguientes 2N componentes tienen una parte constante, calculada en MATLAB
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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 }
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 31 Ramón Jesús Cuesta Pérez
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];
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
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
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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.
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 32 Ramón Jesús Cuesta Pérez
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.
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
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
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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' );
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 33 Ramón Jesús Cuesta Pérez
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' );
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
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
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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' );
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 34 Ramón Jesús Cuesta Pérez
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 --)
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á
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' );
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
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á
act:
);
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática
Universidad de Sevilla
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
Proyecto Fin de Carrera
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Dpto. Ing. de Sistemas y Automática Página 35 Ramón Jesús Cuesta Pérez
double uk, double y_in)
i=1;i>0;i --)
i=0;i>0;i --)
u[1]; i=1;i>0;i --)
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
Véanse los anexos o la carpeta de archivos del capítulo 2 del CD-ROM para visualizar
los códigos sin interrupciones tanto de las diferentes versiones de generador de código
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
Implementación de algoritmos MPC con restricciones en mbed NXP LPC1768
Ramón Jesús Cuesta Pérez
Curso 2011/2012
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
ROM para visualizar
los códigos sin interrupciones tanto de las diferentes versiones de generador de código
Apuntes y transparencias de Ingeniería de Control