UNIVERSIDAD DE LAS FUERZAS ARMADAS ESPE

SEDE LATACUNGA
Departamento de Eléctrica y Electrónica
Carrera de Electrónica y Automatización

CONTROL DIGITAL – [4886]

Informe No. 3 de Proyecto Unidad III.

Control de un Proceso Industrial

Aplicación virtual para esquemas de control implementado en Matlab y
Unity3D.

Docente:
PhD. Víctor Hugo Andaluz
Estudiantes:
Bucheli José
Ruiz David
Tercero Jhonatan

Septiembre 05, 2021

Contenido
Objetivo. ............................................................................................................... 2

Objetivo general................................................................................................ 2

Objetivo específico. .......................................................................................... 2

Marco Teórico....................................................................................................... 3

Entornos virtuales ............................................................................................. 3

Software de diseño del entorno virtual ......................................................... 3

Desarrollo.............................................................................................................. 4

Creación del entorno en la herramienta Blender. ............................................. 5

Comunicación bilateral UNITY & Matlab. ...................................................... 7

Configuración para memoria compartida ..................................................... 7

Análisis de resultados ......................................................................................... 20

Conclusiones. ...................................................................................................... 22

Bibliografía ......................................................................................................... 22

Anexos. ............................................................................................................... 24

Objetivo.
Objetivo general.
• Desarrollar un entorno virtual que represente un proceso industrial, a fin de
analizar las características dinámicas de comportamiento del proceso.
Objetivo específico.
• Investigar los entornos virtuales que se puede utilizar en un proceso industrial.
• Comprender el funcionamiento de un entorno virtual.
• Desarrollar un entorno virtual que represente un proceso industrial.
Marco Teórico.
Entornos virtuales
En los últimos años se han realizado varios progresos en cuanto a la investigación
y desarrollo de Realidad Virtual y Realidad Aumentada y sus distintas aplicaciones hacia
varios sectores como el ocio, simulación, enseñanza, arqueología o medicina. En el
ámbito industrial no ha quedado atrás en este estudio, dando como resultado una probada
utilidad ya sea en etapa de desarrollo de un producto, como para su comprobación en
fases finales para determinar su ciclo de vida. (Martín, Espinosa, & Domínguez, 2014).
Una definición de entorno virtual oficial no existe en la actualidad, pero se puede
distinguir una explicación obtenida de (Roehl, 1996) que dice: “La Realidad Virtual es
una simulación de un ambiente tridimensional generada por computadoras, en el que el
usuario es capaz tanto de ver como de manipular los contenidos de ese ambiente”. De esta
cita se puede deducir que los ambientes virtuales proveen diferente tipo de información
sensorial dando a conocer que el sujeto se encuentra en “otro lugar”, usando una
computadora con un software adicional especificado para ingresar, obtener, visualizar,
modificar e interactuar datos del ambiente virtual (Escartín, S/F).
Software de diseño del entorno virtual
• Unity
Es una multiplataforma creada por la empresa Unity Technologies diseñada para
el desarrollo de videojuegos en 2D y 3D a nivel profesional o a su vez entornos virtuales
a nivel industrial. Este software aparte de tener motores de renderizado de imágenes,
físicas y audio en 2D y 3D, tiene varias herramientas dedicadas para navegación y
networking que aporta de gran manera para Inteligencia Artificial por ende brinda soporte
para la Realidad Virtual.

Ilustración 1. Logo oficial de Unity

• Blender
Blender es un software de código libre que sirve para trabajar con objetos en 3d y
se podría decir que internamente incluye varias herramientas para trabajar. Contiene
herramientas para modelado, texturizado, pintado de texturas, editor de partículas,
animación, rigging, esculpido.
Características principales de Blender.
• Es gratuito.
• Tiene soporte y actualizaciones gratuitas
• Integra todo tipo de herramientas y compite con los demás programas del
mismo tipo.
• Está preparado para diferentes tipos de formatos
• Es multiplataforma, lo encontramos para diferentes sistemas operativos.
• Permite importar y exportar formatos a otros programas.
• Es muy ligero.
• Es muy sencillo de manipular y hay mucha documentación.

Modelado
• El modelado es una de las principales herramientas en lo que es Blender.
• Principalmente se basa en crear objetos del mundo real además de
manipular una malla compuesta por polígonos, así como mover vértices y
aristas.
• Muchos de estos objetos se pueden hacer a escala, es decir, se puede
establecer una medida exacta.
• Blender tiene herramientas para trabajar con modelos arquitectónicos.
• Blender permite poner imágenes de referencia para poder obtener muy
buenos resultados.

Ilustración 2.. Logo oficial de Blender

Desarrollo.
Diseñar e implementar un esquema de control en lazo cerrado orientado al área de
automatización y procesos industriales. El diseño del esquema de control deberá
incluir el análisis de estabilidad y robustez ante perturbaciones en la planta y errores
en medición de los sensores.
 Creación del entorno en la herramienta Blender.
• Se desarrollo un entorno donde se muestra una parte de lo que
complementa a una industria azucarera correspondiente a evaporizador de
quíntuple efecto, basado en el diseño 2D del trabajo propuesto.
• El entorno de la planta se desarrolla en Blender un software gratuito para
diseño en 3D, la selección de este herramienta fue que ayuda a exportar el
diseño con la extensión .fbx que es la que necesita Unity, además que en
internet se encuentra la página https://free3d.com/es/modelos-3d/blender
como ayuda para exportar entornos, como árboles, carros, galpones etc.,
por lo que es una gran ayuda a que el entorno tenga una mejor
ambientación.
• El diseño de la planta se empieza estructurando en una sola pieza los
tanques evaporadores, mediante los comandos del software se da forma al
cilindro inicial.

Ilustración 3. Diseño del evaporador en Blender

Ilustración 4. Escalamiento y exportación en. fbx de la planta

Cuando el diseño 3D sea finalizado que no es el caso de la ilustración 4, que solo

es una indicación es como se debe realizar la exportación del entorno de la planta
industrial. A continuación se coloca el diseño completo de la planta industrial, el cual es
exportado y guardado en .fbx para ser importado a Unity donde se realizará la animacón
con el uso de las memórias compartidas para visualizar el comportamiento de la planta y
ver la interacción entre dichos softwares.

Ilustración 5. Modelo final

Considerar que este diseño 3D en Blender debe ser colocado en Unity y este miso
debe ser exportado en .fbx tal como se muestra en la ilustración 4.

Ilustración 6. Exportación de un diseño CAD 3D a Unity

Para exportar en ese formato tenemos la siguiente ilustración, de toda la planta finalizada,
tanto texturas y acondicionamiento del espacio que rodea son hechas por las texturas en
Unity.

Ilustración 7. Exportación de toda la planta para que Unnity lo reconozca

 Comunicación bilateral UNITY & Matlab.
Implementar un canal de comunicación bilateral entre Unity3D y Matlab, a fin de
implementar el modelo dinámico que representan el comportamiento de un proceso
industrial seleccionado

Ilustración 8. Comunicación bilateral Unity-Matlab.

La comunicación bilateral consiste en el envío y recepción de datos de extremo a

extremo. Para el presente proyecto se requiere de este tipo comunicación con el fin
realizar una simulación en un entorno virtual 3D de la planta en cuestión. Estas acciones
se consiguen a través de una memoria compartida (DLL). Los DLL son extensiones de
código ejecutable que forman de softwares y aplicaciones. Estos archivos se encuentran
separados en ficheros distintos y se ejecutan cuando el usuario accede a funciones
determinadas de un software. Gracias a estos archivos, el procesador puede “discriminar”
qué parte de un software ejecutar y cuáles otras deben estar en espera.
Otro uso importante que se basa en los archivos DLL recae en las librerías de enlace
dinámicas compartidas. Así, paquetes de softwares o programas que utilizan los mismos
archivos DLL, no necesitan instalar ficheros de código ejecutable que ya se encuentran
en el ordenador, sino que comparten el uso de estos archivos DLL.
Configuración para memoria compartida
SMClient es un proyecto que ofrece bibliotecas de enlaces dinámicos (* .dll) con
funciones para crear, leer, escribir y liberar memorias virtuales. Shared Memories es un
tipo de comunicación entre procesos (IPC) que permite que dos o varios programas
accedan a una ubicación de memoria, lo que permite transferir datos entre procesos y / o
aplicaciones.
 Inicialmente se ingresa al link: http://github.com/EliGor1989/sharedMemoryClient.
En el cual se encuentra toda la documentación, archivos, ejemplos y ayudas,
correspondientes a la instalación, ejecución, y aplicaciones de las memorias compartidas
entre diversos softwares.

Ilustración 9. Página web GitHub, lugar de descarga de los archivos para la implantación.

Como se puede observar en la Ilustración 10 una vez ingresado a la página web del
link indicado, se pude descargar fácilmente todos los archivos necesarios, comprimidos
en un ZIP. Una vez descomprimida la documentación, el paso siguiente sería la
instalación de la memoria compartida.

Ilustración 11. Contenido del archivo ZIP descargado.

En la Ilustración 11, se puede apreciar todo el contenido del archivo ZIP descargado,
que se encuentra dentro una carpeta sharedMemoryClient-master. Para la instalación y
configuración de la memoria compartida se ingresa a la siguiente dirección
sharedMemoryClient-master\Libraries\64Bits, donde se encuentran dos archivos.dll.
 Ilustración 12. Primer paso para la instalación de memorias compartidas.

Se debe copiar el archivo smClient64.dll, como se muestra en la Ilustración 13, y pegar

en la dirección: C:\Windows\System32, este es el primer paso y uno de los más
importantes para la instalación de memorias compartidas. Luego se vuelve a ingresar a la
carpeta principal, y en esta ocasión se abre la carpeta Help & Examples. Dentro de esta
se encuentra los archivos ejemplo y ayudas para todos los lenguajes de programación que
nos proporciona este proceso de memorias compartidas.

Ilustración 13. Ejemplo de memoria compartida Matlab.

Una vez abierto el archivo ejemplo de memoria compartida en Matlab, es

importante destacar la presencia del archivo smClient.h, este archivo debe estar dentro de
la misma carpeta donde se encuentra el archivo.m, en este caso dependiendo del software,
que contenga o tenga la finalidad de realizar una acción de memoria compartida.
Implementación de memorias compartidas en Matlab
Una vez comprendido el uso de memorias compartidas, hay que aplicar este
concepto en el presente proyecto para realizar una comunicación Unity - Matlab, debido
a que la visualización y simulación de la planta estará dado por Unity, mientras que el
controlador o el control estará en Matlab.
En base al archivo “Memorias_Unity_Matlab.m”, anexado en el presente
proyecto, se implementan las memorias compartidas.
 Ilustración 14. Programa Memorias_Unity_Matlab.m (importar, abrir e inicializar memorias compartidas).

En la Ilustración 15, se muestra la primera parte del código de las memorias

compartidas. Las primeras líneas de código permiten limpiar la ventana de comandos y
las variables. Luego se establece un tiempo de ejecución. Las siguientes líneas código se
utilizan para importar, abrir e inicializar la memoria compartida, como se explicó
anteriormente. Para este caso se generan dos memorias una para Unity y otra para Matlab,
las cuales llevan su mismo nombre, estas contienen 10 espacios de memoria y son de tipo
doble.

Ilustración 16. Escritura y lectura de las memorias compartidas.

 El envío Matlab-Unity de los datos obtenidos en los vectores de entrada, se lo
realiza como se observa en la Ilustración 17, en la sección “Escribir en las memorias
compartidas”, aquí se fijan los valores de tipo doble obtenidos y se los guardan en los
diferentes espacios de la memoria “matlab”. Luego en la sección “Leer memorias
compartidas”, se obtienen los datos en la memoria “unity”, y se los guarda en vectores
para posteriormente graficarlos.
Pasos para crear un personaje controlado en Unity:
Primero ingresamos en mixamo seleccionamos en carácter y escogemos cualquier
avatar.

Ilustración 18. Seleccionamos el carácter

Después nos dirigimos en animaciones y le dejamos una por defecto para que
inicie con unity, que debe estar tranquilo sin movimientos bruscos, descargamos el
archivo en formato fbx.
Es recomendable para que no exista ningún error al momento de que el avatar este
quieto se lo coloca en modo zombie debido que dicha animación es estática y funcionaria
perfecto cuando el avatar este quieto
 Ilustración 19. Eligiendo modo zombie

Ilustración 20. Animación para el inicio

Se crea otro archivo en mixamo, buscamos la animación de caminar y damos click

en in place en el mismo lugar el cual se va controlar el avatar por código, y descargamos
el archivo en fbx.
 Ilustración 21. Animación para caminar

Segundo importamos copiando y pegando los archivos fbx de caminar e iniciar al

assets de animaciones de Unity.

Ilustración 22. Importamos los archivos

Nos dirigimos al archivo iniciar e ingresamos en inspeccionar damos click en rig

y observamos que viene por defecto en animation type con generic y le cambiamos por
humanoid para que se vea los movimientos y definimos el avatar como crear a partir de
este modelo.

Ilustración 23. Modificamos la parte de rig de iniciar

 Después nos dirigimos a la animación de caminar le cambiamos los valores a
humanoide y como copia del avatar de animación de iniciar sirve para compartir el
esqueleto entre las dos animaciones.

Ilustración 24. Modificamos la parte de rig de caminar

Tercero creamos un control de animación le damos click derecho en el archivo

animaciones y creamos un control de animación. Damos click en ese archivo y nos
genera una pantalla llamada base layer, se da click derecho y creamos un from new
blend tree.

Ilustración 25. Creación del control de animación

Damos dobles click y añadimos tres blend tree una de caminar y dos de iniciar.

Ilustración 26. Añadimos tres blend tree

Seleccionamos 2D Freeform Directional, y en el bloque caminar ingresamos las

posiciones de 0,0,1 y en el bloque de iniciar se ingresa dos dimensiones de 1,0,1 y de -
1,0,1.
 Ilustración 27. Ingresamos las posiciones de iniciar y caminar

Cuarto ingresamos en assets y en personaje, creamos un script con el nombre de

personaje_control.

Ilustración 28. Generación del script

 Ilustración 29.Inicialización del entorno virtual

Ilustración 30.Evolución del sistema después de un tiempo y con distintos tipos de set point

Se presenta las gráficas de evolución del sistema con el algoritmo de control, se

observa una tarea de regulación puesto que la salida de la planta llega los valores deseados
en cada uno de los escalones colocados en distintos tiempos y se pude evidenciar que el
controlador realiza su tarea mandando una señal para que el sistema alcance sus valores
esperados.

Ilustración 31.Sistema en evolución con perturbación en la válvula de carga.

Ilustración 32. Paneles de control

 En la ilustración 32 podemos observar el panel las gráficas, el set point y la
perturbación con un deslizador para poder observar como se iguala el valor real con el
del setpoint afectado con una perturbación.

Ilustración 33. Fallo en el proceso

En la Ilustración 33 podemos observar el efecto de una falla que se activa con

una tecla del teclado cuando esta corriendo el programa en Unity y MatLab.

Ilustración 34. Válvula

Observando la Ilustración 34 podemos observar un indicador el cual nos muestra

la concentración que esta pasando en ese momento con su salida estándar de corriente.
Análisis de resultados

Ilustración 35. Evolución del sistema mediante la comunicación bilateral Unity-Matlab

La Ilustración 35 son la representación de los datos obtenidos que recibe Matlab

de Unity de la evolución representada en la ilustración 2, dando a entender que la
comunicación funciona entre los dos softwares, así vez se ve las variaciones del valor
deseado y como la señal llega a estabilizarse, y a su vez en esta ocasión es un sistema sin
perturbación, debido a que cuando se llega a la estabilización no existe pequeñas
oscilaciones.

Ilustración 36. Control del quinto vaso

 Se ve que el controlador realiza sus acciones para que la salida alcance el valor
deseado de concentración además de que se visualiza que existe perturbación visible en
la respuesta del sistema y aunque existe algunos sobre impulsos y pequeñas oscilaciones
cuando se llega al valor deseado pues son mínimos ante la magnitud de la perturbación,
aunque si la perturbación es muy grande en magnitud el sistema resulta que tiende a la
inestabilidad como se ve en la etapa final del proceso mostrado en la gráfica.

Ilustración 37. Error de control

En la Ilustración 37 observamos el error de control el cual es afectado por las

perturbaciones que se analizo en el informe dos, estas perturbaciones están colocadas en
la parte del código de Visual.

Ilustración 38. Acción de Control

Conclusiones.
• Se comprobó que funciona la comunicación bilateral entre Unity y Matlab
mediante la visualización de la simulación cuando termina el tiempo estimado de
toma de datos, si el programa de script realizado en Matlab no se inicializa las
gráficas en el entorno virtual de unity no muestran la evolución del sistema, por
otra parte si la simulación resulta exitosa cuando están funcionando las memorias
compartidas se ve la evolución del sistema y a su vez la transmisión y recepción
de datos cuando se coloca una perturbación se ve que el controlador implementado
en Matlab realiza su trabajo y a aun ves si el valor deseado de concentración de
meladura es modificada a otro set point el controlador realiza la tarea de
regulación alcanzando el valor deseado, recalcando que el proceso de por sí solo
es muy lento.
• El proceso de evaporización es muy complejo debido al modelo matemático y su
abstracción, por tanto, se usó el método de prueba y error para la evolución del
sistema y el control de concentración de meladura fue controlado únicamente en
el último efecto es decir el quinto vaso, donde se realiza una tarea de regulación
mediante el flujo de entrada y el valor de concentración por tanto la ley de control
sigue siendo no lineal empleando únicamente el control en la concentración.
• Se pudo observar la robustez del sistema ante las distintas perturbaciones del
sistema debido que cuando se colocaba error en la medición y error en la planta
en las gráficas se podía evidenciar una oscilación en el set point establecido y de
igual forma a unos pequeños sobre impulsos cuando se varia la válvula de carga
de flujo de vapor en el último efecto, se puede afirmar que el controlador es
óptimo siempre y cuando la perturbación de la válvula de carga no sea exagerada.

Bibliografía

[1] E. J. Adam, Instrumentación y control de procesos, Santa Fe:

Universidad Nacional del litoral., 2019.
[2] S. Kazes Gómez y J. F. De la Cruz Morales, Aplicación de las reglas
heurísticas en la síntesis de procesos., Colombia: Universidad de colombia,
2008.
[3] H. Villavicencio, Diseño, simulación y emulación de una planta
productora de panela., Guayaquil: Escula Superior Politécnica de Litoral,
2006.
[4] L. Pérez Pinto, M. Á. Rodríguez Borroto y F. Fernández Castañeda,
Modelación Matemática y simulación del control automático para el
quíntuple efecto de evaporación del central azucarero "El Palmar" en
Venezuela, Venezuela: Fejióo, 2015.
[5] D. A. Giraldo Giraldo, D. Santos Barbosa y C. Cotrino Badillo,
Estrategia de control predictivo sobre un modelo matemático de un
evaporador, Colombia: Universidad de Colombia Sede Bogotá, 2006.
[6] M. Pérez Alberto, A. Pérez y E. Pérez Berenguer, INTRODUCCION
A LOS SISTEMAS DE CONTROL Y MODELO MATEMÁTICO PARA
SISTEMAS LINEALES INVARIANTES EN EL TIEMPO, San Juan:
Universidad de San Juan, 2007.
Anexos.
➢ Video de la exposición

Link: https://www.youtube.com/watch?v=BCq5Ah6DPHs
➢ Archivos en Drive

https://drive.google.com/drive/folders/1njc-9DMBEzOQ0HY-dson--
BHglCsx3Ge?usp=sharing
➢ Código en Matlab
clc;
clear;
close all;
warning off;
ts=0.1;
t_final=200;
t=[0:ts:t_final];
val=1;
% Parametros
p1=0.8; % densidad
p2=0.8; % densidad
p3=0.8; % densidad
p4=0.8; % densidad
p5=0.8; % densidad
Vo=0.8;
n=2; %numero de tubos
d=0.1; %diametro del tubo

%Maximo 3.65m
N1=3;
N2=3;
N3=3;
N4=0.1;
N5=7; %7.39
hc=1; %5 %altura del cono
%% Importar memoria compartida
loadlibrary('smClient64.dll','./smClient.h')
calllib('smClient64','createMemory','unity',10,2);
calllib('smClient64','createMemory','matlab',10,2);
%% Abriri memoria compartida
calllib('smClient64','openMemory','unity',2); %Abrir memoria, no cambiar el numero 2
calllib('smClient64','openMemory','matlab',2);

%% Inicializar en cero las mermorias

for i=0:10
calllib('smClient64','setFloat','unity',i,0);
calllib('smClient64','setFloat','matlab',i,0);
end

%Vectores de Entrada
Fm1=val*[.95*ones(1,t_final) .99*ones(1,t_final) .95*ones(1,t_final)...
.96*ones(1,t_final) .92*ones(1,t_final) .95*ones(1,t_final)...
.98*ones(1,t_final) .95*ones(1,t_final) .91*ones(1,t_final) .95*ones(1,length(t)-
t_final*9)];

Fc1=val*[.95*ones(1,t_final) .92*ones(1,t_final) .92*ones(1,t_final)...

.94*ones(1,t_final) .91*ones(1,t_final) .95*ones(1,t_final)...
.99*ones(1,t_final) .95*ones(1,t_final) .95*ones(1,t_final) .90*ones(1,length(t)-
t_final*9)];

Fc2=val*[.98*ones(1,t_final) .97*ones(1,t_final) .97*ones(1,t_final)...

.85*ones(1,t_final) .97*ones(1,t_final) .99*ones(1,t_final)...
.99*ones(1,t_final) .95*ones(1,t_final) .95*ones(1,t_final) .99*ones(1,length(t)-
t_final*9)];

Fc3=val*[.98*ones(1,t_final) .98*ones(1,t_final) .97*ones(1,t_final)...

.95*ones(1,t_final) .97*ones(1,t_final) .99*ones(1,t_final)...
 .99*ones(1,t_final) .95*ones(1,t_final) .95*ones(1,t_final) .99*ones(1,length(t)-
t_final*9)];

% Fc4=val*[.98*ones(1,t_final) .98*ones(1,t_final) .98*ones(1,t_final)...

% .80*ones(1,t_final) .97*ones(1,t_final) .79*ones(1,t_final)...
% .99*ones(1,t_final) .97*ones(1,t_final) .79*ones(1,t_final) .99*ones(1,length(t)-
t_final*9)]; % Variable de control

% Fvap5=val*0.991*0.51*[1*ones(1,t_final) 1*ones(1,t_final) 1*ones(1,t_final)...

% 1*ones(1,t_final) 1*ones(1,t_final) 1*ones(1,t_final)...
% 1*ones(1,t_final) 0.4*ones(1,t_final) 1*ones(1,t_final) 1*ones(1,length(t)-
t_final*9)]; %Variable manipulada

Fm1=val*0.95*ones(1,length(t));
Fc1=val*0.95*ones(1,length(t));
Fc2=val*0.95*ones(1,length(t));
Fc3=val*0.95*ones(1,length(t));

calllib('smClient64','setFloat','matlab',5,1);
for k=1:length(t)-1
tic
%Leer memorias compartidas
C1(k) = calllib('smClient64','getFloat','unity',0);
C2(k) = calllib('smClient64','getFloat','unity',1);
C3(k) = calllib('smClient64','getFloat','unity',2);
C4(k) = calllib('smClient64','getFloat','unity',3);
C5(k) = calllib('smClient64','getFloat','unity',4);
C5d(k) = calllib('smClient64','getFloat','unity',5);
Fvap5(k) = calllib('smClient64','getFloat','unity',6);

C5_error(k)=C5d(k)-C5(k);
C_error=[C5_error(k)];

w1=0.12;
W=[w1];

A=[(C4(k)-C5(k))/(p1*(Vo+((k*pi*d^2*(N5-hc))/(2))))];

D=[(C5(k)Fvap5(k))/(p1(Vo+((k*pi*d^2*(N5-hc))/(2))))];

x=inv(A)(W(tanh(C_error))-D);

maxFM=0.98;

% Fc4(k)=x(1);
Fc4(k)=min(maxFM,max(0,(x(1))));

%Escribir en memorias compartidas

calllib('smClient64','setFloat','matlab',0,Fm1(k));
calllib('smClient64','setFloat','matlab',1,Fc1(k));
 calllib('smClient64','setFloat','matlab',2,Fc2(k));
calllib('smClient64','setFloat','matlab',3,Fc3(k));
calllib('smClient64','setFloat','matlab',4,Fc4(k));

while toc<0.085
end
dts(k)=toc;
end
calllib('smClient64','setFloat','matlab',5,0);

C1(length(t))=C1(length(t)-1);
C2(length(t))=C2(length(t)-1);
C3(length(t))=C3(length(t)-1);
C4(length(t))=C4(length(t)-1);
C5(length(t))=C5(length(t)-1);
C5d(length(t))=C5d(length(t)-1);
Fc4(length(t))=Fc4(length(t)-1);
C5_error(length(t))=C5_error(length(t)-1);
Fvap5(length(t))=Fvap5(length(t)-1);
dts(length(t))=dts(length(t)-1);
%% Graficas en Matlab
figure('Name','GRAFICAS VASOS 1-5');
subplot (3,2,1)
plot(t,C1(1:length(t)),'b','LineWidth',2);
grid on;
title('Vaso 1');
hold on

subplot (3,2,2)
plot(t,C2(1:length(t)),'b','LineWidth',2);
grid on;
title('Vaso 2');
hold on
xlabel('Tiempo[ms]');
ylabel('Concentracion 2')

subplot (3,2,3)
plot(t,C3(1:length(t)),'b','LineWidth',2);
grid on;
title('Vaso 3');
hold on
xlabel('Tiempo[ms]');ylabel('Concentracion 3')

subplot (3,2,4)
plot(t,C4(1:length(t)),'b','LineWidth',2);grid on;title('Vaso 4');hold on
xlabel('Tiempo[ms]');ylabel('Concentracion 4')

subplot (3,2,5)
plot(t,C5d(1:length(t)),'r','LineWidth',2);grid on;hold on
plot(t,C5(1:length(t)),'b','LineWidth',2);grid on;hold on
grid on;
title('Vaso 5');
hold on
xlabel('Tiempo[ms]');
ylabel('Concentracion 5')
legend({'C5d','C5'},'Location','southeast')

figure('Name','ERRORES DE CONTROL VASO 5');

plot(t,C5_error(1:length(t)),'m','LineWidth',2);grid on;title('Vaso 5');hold on
xlabel('Tiempo[ms]');ylabel('Flujo Másico de Licor 5')
legend({'C5 Error'},'Location','southeast')

figure('Name','ACCIONES DE CONTROL VASO 5');

plot(t,Fc4(1:length(t)),'g','LineWidth',2);grid on;title('Vaso 5');hold on
xlabel('Tiempo[ms]');ylabel('Flujo Másico de Licor 5')
legend({'Fc4'},'Location','southeast')

figure('Name','Unicamente Quinto vaso');

plot(t,C5d(1:length(t)),'r','LineWidth',2);grid on;hold on
plot(t,C5(1:length(t)),'b','LineWidth',2);grid on;hold on
grid on;
title('Vaso 5');
hold on
xlabel('Tiempo[ms]');
ylabel('Concentracion 5')
legend({'C5d','C5'},'Location','southeast')
%% Liberar Memoria
calllib('smClient64','freeViews')
unloadlibrary smClient64