CONVERTIDOR DC-DC BOOST
1 2 3
Daniel Obed Paz Torres ; Nelson Andres Portilla ; Javier Castillo Cifuentes ;
1 2 3
daniel_obed.paz@uao.edu.co nelson.portilla@uao.edu.co javier.castillo@uao.edu.co
Facultad de Ingeniería, Departamento de Electrónica y Automática.
Control Inteligente
Universidad Autónoma de Occidente
Cali, Colombia
Abstract — The following report is based on the simulation of a DC-DC
boost converter, the data acquisition using Simulink having the dynamic II. MARCO TEÓRICO
analysis of the same and thus its representation in state variables and the
subsequent learning process using MATLAB, the verification of the creation
of the neural network and the subsequent implementation in hardware and
A. Convertidor DC-DC Boost
thus also the validation both in its serial port of the arduino IDE arduino and
the simulation in simulink. El convertidor elevador o convertidor boost (del inglés boost
converter) es un convertidor DC a DC que obtiene a su salida una
Keywords – dynamic analysis, learning process, neural network. tensión continua mayor que a su entrada. Es un tipo de fuente de
alimentación conmutada que contiene al menos dos interruptores
I. INTRODUCCIÓN semiconductores (diodo y transistor), y al menos un elemento para
almacenar energía (condensador, bobina o combinación de ambos).
La inteligencia artificial es una herramienta muy importante en Frecuentemente se añaden filtros construidos con inductores y
muchos aspectos relacionados con la ciencia y la tecnología, está a su condensadores para mejorar el rendimiento. A continuación se describe
vez ha revolucionado la manera en cómo vemos y utilizamos una el modelo dinámico del mismo.
computadora, ya que a través de la simulación de algoritmos
relacionados es como nosotros los humanos aprendemos cada día, las
máquinas pueden llegar a simular y hasta razonar de manera artificial
diferentes procesos de manera autónoma y es así cómo podemos
relacionar esta herramienta con los sistemas de control autónomos, con
el hecho de poder enseñar a una red neuronal comportarse como la
planta en su defecto, podemos así controlar esta de manera más
eficiente, así revolucionando el control autónomo de enfoque clásico;
El siguiente informe se basa en la simulación de un convertidor
DC-DC boost, la adquisición de datos utilizando Simulink teniendo el
análisis dinámico del mismo y así su representación en variables de
estado y el posterior proceso de aprendizaje utilizando MATLAB, la Figura 1. Esquemático Convertidor DC-DC boost
comprobación de la creación de la red neuronal y la posterior
implementación en hardware y así también la validación tanto en su Cabe notar que para realizar el análisis se tiene como entrada u la
puerto serial del propio IDE de arduino y la simulación en simulink. conmutación del mosfet.
para u=0
II. OBJETIVOS
A. General
Emular un sistema dinámico no lineal usando una RNA MLP
implementada en Arduino.
B. Específicos Para u=1
● Adquirir los datos a través de su análisis dinámico usando
Simulink
● Entrenar la red neuronal en Matlab y comprobación en simulink
● Implementar la red neuronal en Arduino
● Validar la respuesta de arduino con la implementación en
simulink.
1de8
Así obtenemos el modelo conmutado:
y conociendo los siguientes dato
Para realizar un análisis de eficiencia se tiene que buscar un promedio
de la entrada y definir los valores de eficacia, entonces de la misma
manera anterior obtenemos el modelo promediado
Por lo tanto:
Organizamos las ecuaciones para así obtener la representación en Como se puede apreciar en las ecuaciones L es igual a C porque
variables de estado 1 1
es igual a 𝐶 como a 𝐿 de esta forma podemos encontrar el
valor de R
Dando como estados la corriente en la inductancia y el voltaje en el
capacitor III.MATERIALES Y MÉTODOS
Para el desarrollo de este proyecto se necesitaba de un arduino, no
era necesario tenerlo físico pero era lo ideal así qué hablaremos un
poco sobre él. Además el uso de software como lo es Matlab y
Arduino IDE.
A. Arduino
Es un tipo de hardware de bajo costo el cual incorpora un
microcontrolador específicamente el Atmega2560 o Atmega328P entre
otros según la capacidad del hardware, se usa en conjunto con el
Es así cómo podemos comparar las ecuaciones dadas para este software propio de Arduino para poder realizar la programación debida
proyecto, y así poder encontrar los valores de los parámetros y poder visualizar o realizar diversas acciones.
por lo siguiente podemos igualar los parámetros de las ecuaciones
encontradas por el modelo promediado y las dadas para el desarrollo
de este proyecto.
Figura 2. Hardware Arduino NANO, UNO, MEGA
2de8
Lo qué se debe hacer con este hardware es conectarlo a un ordenador
mediante cable USB para poder programarlo y poder usar sus puertos
ya sea del arduino o los puertos de transferencia entre el computador y
arduino (puertos serie).
B. Matlab
Mediante el uso de software como Matlab y sus diferentes instancias
como Simulink podemos realizar la asignación de parámetros
predefinidos como variables globales y usarlas en código de Matlab y
Simulink simultáneamente, con este último podemos esquematizar el
sistema a identificar con diagramas de bloques y funciones como
integradores, multiplexores, bloques de funciones para obtener los
valores de multiplexores, sumadores y osciloscopios para visualizar
nuestros datos.
Figura 5. Interfaz de Arduino IDE
IV. METODOLOGÍA
Como suministro para llevar a cabo este proyecto, se tiene las
ecuaciones que modelan el sistema de conversión DC-DC Boost las
cuales no son lineales es por ello que se recurre al uso de multiplexores
en Simulink para mediante los bloques de funciones alternar las
variables de estado y la entrada según la ecuación, así para las dos
ecuaciones predispuestas, luego de los bloques de función Fcn se tiene
integradores para obtener finalmente los estados 𝑥 𝑦 𝑥 de manera
1 2
Figura 3. Interfaz de Matlab independiente y poder visualizar según la respuesta planteada, en este
caso la salida será el estado 𝑥 . Adicional a ello se incluyen en Matlab
2
los coeficientes establecidos como 𝑤0, 𝑤1, 𝑏 𝑦 𝑢 y creados en el
workspace para incluirlas en los bloques de función desde Simulink y
proceder a graficar el comportamiento del sistema y capturar datos de
entrada y salida con los bloques llamados To Workspace, los cuales
mediante un tiempo de muestreo y la configuración de array, nos
genera variables manipulables Entrada y Salida en el Workspace de
Matlab y así poder usarlas luego para las posteriores operaciones.
Luego de generar los datos de entrada y salida del sistema se cambia
de nombre a las variables por notación únicamente, para la entrada la
letra U y para la salida la letra Y y con ellas se hace las operaciones
pertinentes para formar un regresor (Phi) de orden [2,2,1] (dos retardos
en la salida, dos retardos en la entrada y delay en 1), se elige ese orden
puesto que las ecuaciones nos muestran que es un sistema de orden
dos; se le realiza la transpuesta al vector Phi y adicionalmente se
obtiene la salida real llamada YReal también transpuesta para generar
Figura 4. Interfaz de Simulink la red neuronal. Siguiendo con lo mencionado, la red neuronal se
construye mediante la función newff a la cual se le envían como
C. Arduino IDE parámetros Phi, YReal, la cantidad de neuronas en la capa oculta, las
funciones de activación de entrada y salida y el tipo de entrenamiento a
Es un software de uso libre para desarrolladores en diferentes usar para dicha red; luego viene el número de iteraciones que la red
ámbitos a aplicar. Aquí se deberá implementar el código realizará para lograr un resultado óptimo, la orden de entrenamiento y
correspondiente a la identificación del sistema y posteriormente la generación de un bloque de Simulink para hacer posteriores
cargarlo en el hardware Arduino para obtener datos de comparación comparaciones y valoraciones de la respuesta del sistema y la red.
La secuencia del código de matlab nos lleva a obtener los pesos
sinápticos de la capa oculta y de salida al igual qué sus vías
correspondientes y concatenarlos en un arreglo tal qué nos permita
pasar ese sistema de entrenamiento por red neuronal hacia Arduino
3de8
IDE. También se obtienen los X minimos y maximos y D minimos y Predicción a un paso
maximos para realizar la normalización tal qué entienda nuestro Después de obtener la red neuronal entrenada se pasa a la simulación
software y hardware Arduino. Ya en el código de Arduino se crean las en las cuatro categorías mencionadas anteriormente. Para la
variables Xmin y max, al igual que las D y se les asigna los valores comparación más básica se tiene la predicción a un paso, configuración
obtenidos en Matlab, de igual forma los pesos de capa oculta y de en la que se tiene un arreglo que permite a la neurona obtener sus datos
salida con sus respectivos bias, luego de ello se empieza con el proceso de entrada por medio de los datos de salida del sistema (X2). En la
de normalización y finalmente la creación de valores random de siguiente figura se muestra la configuración utilizada.
entrada entre el rango establecido para poner a prueba el entrenamiento
de la red a través de arduino. Al cargar el código en el hardware,
podemos habilitar la opción de plot serial para poder observar cómo se
comporta la salida ante valores aleatorios de entrada y ya con esto
desde simulink mediante el bloque Query Instrument podemos
conectar el puerto serie en el qué trabaja arduino y enviar los valores
random hacia la entrada del sistema y de la neurona obtenidos en
Simulink y paralelo la respuesta del entrenamiento en arduino de la red
neuronal para comparar con la salida de la neurona y la salida propia
del sistema; esta visualización se puede hacer mediante un scope
donde se puede comparar las 3 gráficas simultáneamente y observar
cuán semejantes son y si el entrenamiento verdaderamente dió un
resultado satisfactorio.
V. ANÁLISIS Y RESULTADOS
Para el análisis de resultados se debe tener en cuenta que estos se
abordan en base a los diferentes procesos de simulación que se utilizan
para la planta. Así pues se tienen en cuenta las siguientes categorías:
a. Predicción a un paso b. Simulación Pura
Figura 7. Predicción a un paso
c. Simulación Arduino d. Comparación simulaciones
En la figura anterior se puede ver que se está utilizando el bloque de
Teniendo en cuenta las categorías mencionadas anteriormente se
simulink de la red entrenada que se alimenta de la salida del sistema
describe a continuación el procedimiento general para obtener el
para obtener una segunda salida que posteriormente se va comparar
fragmento más importante: la neurona artificial o red entrenada.
con la salida propia del sistema, esta configuración produce los
siguientes resultados:
Neurona Artificial (red entrenada)
Para realizar una correcta simulación de la planta en cuestión se
utilizan diversas técnicas que permiten identificar la planta y así poder
utilizar esta herramienta de manera similar a un observador de estados,
para posteriormente controlar el proceso involucrado.
El proceso descrito anteriormente pasa por ciertas fases que permiten
realizar una adecuada identificación del sistema. Lo primero que se
debe hacer es asignar ciertos valores como el tamaño del regresor, el
número de neuronas, el número de datos que se van a procesar, el
número de interacciones que tendrá el sistema, el tipo de
entrenamiento que se utilizará e incluso el tiempo de muestreo.
Después de haber determinado los valores apropiados para cada uno de
los elementos mencionados se procesa el código y se obtiene la red
entrenada, que se muestra a continuación:
Figura 8. Scope predicción a un paso
En la figura 8 lo primero que se debe apreciar es el correcto proceso de
identificación del sistema, como se puede ver se tienen respuesta
prácticamente iguales, esto en parte se debe a que la simulación no es
pura y solo se está haciendo por el proceso de predicción a un paso,
Figura 6. Neuronal entrenada proceso en el que la neurona regularmente no tiene inconvenientes, ni
siquiera en los picos más altos como en el segundo 9.
Para obtener esta neurona se utilizó el código denominado ANEXO 1.
Ubicado al final del documento.
4de8
Simulación Pura
Después de haber realizado la simulación con predicción a un paso
simplemente basta con cambiar el Switch manual para tener la
simulación pura, pues en este caso se tiene una realimentación propia o
también definida como estructura paralela. En esta sección se define si
el bloque o neurona entrenada realmente está funcionando, ya que esta
sería la representación real de lo que sucedería en el campo en caso de
implementar control inteligente.
En la siguiente figura se muestra el resultado obtenido en simulación
pura (se omite el esquemático de Simulink porque en lo único que
difiere con predicción a un paso es la posición del Switch manual).
Figura 10. Simulación Arduino
En la figura 10 se muestra la respuesta obtenida desde la placa Arduino
uno, esta gráfica se obtuvo del serial plotter propio del IDE.
Como se puede apreciar en la imagen se tiene la línea azul como la
entrada, esta se definió entre 0,8 y 9,5, tal y como se tiene en el
planteamiento del sistema, además se tiene la línea roja que representa
la respuesta obtenida del procesamiento.
Figura 9. Simulación pura
Comparación simulaciones
En la figura anterior se pueden apreciar cada una de las interacciones Finalmente, después de haber realizado cada una de las simulaciones
involucradas en la simulación, la línea amarilla representa la respuesta se procede con la comparación de las respuestas obtenidas, desde
del sistema, la línea negra representa la respuesta obtenida por la Simulink se recopilan los datos de entrada (línea morada), los datos de
neurona y la línea roja representa el valor aleatorio de la entrada, cabe la respuesta del sistema (línea verde) y de la respuesta de la neurona
mencionar que esta entrada está acotada entre 0,8 y 0,95. Teniendo en (línea amarilla), para incluir la respuesta generada desde la placa
cuenta estas apreciaciones se puede observar la fidelidad con la que se arduino fue necesario implementar un bloque denominado Query
está identificando el sistema, se puede llegar a esta consideración por Instrument, con el que se puede obtener la respuesta por el puerto serie
la similitud entre la respuesta dada por el sistema y la respuesta que (línea roja).
obtenemos en la simulación pura. A continuación se muestra en la Figura 11 se muestra lo descrito
anteriormente, se tiene el sistema, la neurona a simulación pura, la
Simulación Arduino entrada y la respuesta de arduino al mismo Scope, con el que se genera
En esta sección se describe el proceso de simulación con arduino, para la gráfica mostrada en la Figura 12.
esta fase se utilizó un Arduino Uno con el que se realizó la
implementación del código y con el cual se pudo ver la respuesta en
base a los datos tomados de Matlab.
Los datos que se utilizaron fueron los valores para normalizar la
entrada y la salida de la red, los pesos de la capa oculta y los pesos de
la capa de salida. Aparte de estos datos se tiene que definir en el
código el mismo número de neuronas de la capa oculta, el número de
entradas y salidas, además de que se debe configurar de tal manera que
el regresor esté implementado de igual forma que en Matlab, ya que
esto es vital para que la simulación sea la adecuada y los pesos de la
capa oculta y de salida sean los correspondientes.
El código utilizado está descrito en su totalidad en el ANEXO 2.
Ubicado al final del documento.
Figura 11. Simulación Sistema En Comparación
5de8
en simulink y la del entrenamiento en arduino no erán tan diferentes, se
podía observar algunas discrepancias en cambios demasiado bruscos o
muy pequeños en los escalones, donde la respuesta de arduino
generaba una gráfica tipo escalera, claro está no siempre era así, la
gran mayoría se tenía una respuesta muy pegada a la red de Matlab por
lo cual ambos métodos de asimilación del sistema original fueron
idóneos y cumplieron las expectativas qué se tenían.
REFERENCIAS
[1]
http://repositorio.utp.edu.co/dspace/bitstream/handle/11059/11359/621
.312136%20O83.pdf?sequence=1&isAllowed=y
Figura 12. Respuestas En Comparación [2]
[3]
Comparando los datos obtenidos en la simulación mostrada
anteriormente podemos observar una clara similitud entre las
respuestas generadas, sin embargo podemos apreciar que existen
diferencias muy pequeñas en los puntos más “complejos” como los
picos, donde la neurona y la respuesta del arduino no son del todo
genuinas o exactas, aun así se puede valorar este resultado como
positivo, ya que existe un rango de error muy bajo (al menos en lo que
se puede apreciar gráficamente).
VI.CONCLUSIONES
Durante la realización de este proyecto el grupo se encontró con
diversas dificultades en algunas ocasiones, esto debido a qué al tratar
de sacar los tiempos de muestreo para la toma de datos y para el ancho
o periodo de cada escalón, esto puesto a qué al hacer la visualización
de la señal de salida, se tenían señales fuera de lo esperado en gran
mayoría con tiempos de estabilización demasiado pequeños en el rango
de 1 ms o cuando más 10 ms, esto debido a qué Matlab presentaba
fallas al ejecutar dichos diagramas, no entendimos la razón y adicional
a eso los tiempos de muestreo no se sincronizaban. Otro error fue en la
obtención del regresor Phi y del vector YReal, al realizar el
entrenamiento de la red neuronaL, Matlab mostraba error dado qué los
vectores no eran de las dimensiones requeridas para ser operados entre
sí y las causas fueron de sintaxis en el código, cada uno de los vectores
debía ir transpuesto para así poder operar sin problema, fue lo qué se
omitió y no permitía continuar con el desarrollo del proyecto según lo
planeado.
Al hacer ya el entrenamiento de la red neuronal el gradiente fue muy
−8
bueno aproximadamente de 9. 03𝑥10 y un performance de
−10
2. 77𝑥10 entonces se puede decir que el entrenamiento de la red fue
correcto y tendrá una buena asimilación del sistema original. Cuando
se realizó la predicción serie-paralelo se obtuvo una respuesta
demasiado buena por parte de la red neuronal, esta seguía de manera
uniforme la respuesta del sistema original y con una mínima diferencia
cuando se realizaba en simulación pura o paralela, así pues se concluye
que hubo un correcto procedimiento.
En cuanto a Arduino, la respuesta en el monitor serial del software fue
algo confuso puesto qué no se comportaba de una manera similar qué
en Simulink, se pensaba qué había error en la forma en cómo estamos ANEXO 1: CÓDIGO MATLAB
graficando o los parámetros no erán los correctos, pero al llevar estos clc
datos a Simulink, la diferencia entre la salida del bloque de la neurona clear all
6de8
********************************************************* const float X1Min = 0.0235;
%%tiempos de estabilización minimo 0.1 y maximo 0.8 const float X1Max = 2.5467;
%%u entre 0.8 y 0.95 const float X2Min = 0;
w0=1.5811e3; const float X2Max = 2.5467;
w1=1.6667e3; const float X3Min = 0.8071;
b=106.06; const float X3Max = 0.9402;
********************************************************* const float X4Min = 0.8071;
%% const float X4Max = 0.9402;
U=Entrada;
Y=Salida; // Valores para normalizar la salida de la red
%regresor de segundo orden [2,2,1] const float DMin =0.0543;
Phi=[Y(2:end-1),Y(1:end-2),U(2:end-1),U(1:end-2)]'; const float DMax =2.5467;
YReal=[Y(3:end)]';
********************************************************* // Los pesos de la red fueron obtenidos en Matlab y se copiaron a este
%% entrenamiento por regresion bayesiana programa
Red=newff(Phi,YReal,[10],{'tansig','purelin'},'trainbr'); // Pesos capa oculta
Red.dividefcn=''; %usa todos los datos proporcionados para entrenar const float PesosOculta[NeuronasOculta][NeuronasEntrada+1]= {
Red.trainparam.epochs=300; { 0.0990, 0.0951, -0.0191, -0.0493, -0.0105},
Red=train(Red,Phi,YReal); %ENTRENO DE LA RED { 0.1751, 0.1386, -0.6637, 0.4336, 0.9934},
gensim(Red,0.002) { -0.1761, -0.0738, 0.0934, 0.1192, -0.0643},
********************************************************* { 0.1328, 0.0421, -0.3419, 0.1550, 0.5755},
%% { -0.1810, -0.0513, 0.0470, 0.0541, -0.0233},
WCO=Red.iw{1}; { 0.1446, 0.0894, -0.0149, -0.0509, -0.0136},
WCS=Red.lw{2,1}; { -0.0851, -0.1050, 0.0079, 0.0571, 0.0146},
BCO=Red.b{1}; { 0.1758, -0.1579, -0.7245, 0.9710, -0.7593},
BCS=Red.b{2}; { 0.3208, -0.1204, 0.9271, -0.7557, 0.2641},
COculta = [WCO BCO] { 0.3025, 0.0576, -0.9696, 0.9786, -0.9710},
CSalida = [WCS BCS] };
Xmin = Red.inputs{1}.processSettings{1}.xmin
Xmax = Red.inputs{1}.processSettings{1}.xmax // Pesos capa de salida
X2min = Red.inputs{1}.processSettings{1}.xmin const float PesosSalida[NeuronasSalida][NeuronasOculta+1] = {
X2max = Red.inputs{1}.processSettings{1}.xmax { 0.1915, 0.8929, -0.3947, 0.6699, -0.3123,
Dmin = Red.outputs{2}.processSettings{1}.xmin 0.2752, -0.1968, 1.0459, 1.3692, 1.1625, 0.0983}
Dmax = Red.outputs{2}.processSettings{1}.xmax };
int i, j, p, q, r;
float Neta;
float CapaOculta[NeuronasOculta];
float CapaSalida[NeuronasSalida];
ANEXO 2: CÓDIGO ARDUINO float CapaEntrada[NeuronasEntrada];
void setup(){
********************************************************* //start serial connection
#include <math.h> Serial.begin(9600);
********************************************************* randomSeed(analogRead(0));
* Configuración de la Red }
********************************************************* void loop(){
const int NeuronasOculta = 10; float Entrada;
const int NeuronasEntrada = 4; float Salida;
const int NeuronasSalida = 1; float Tiempo;
float Samples=0; Samples=Samples+1;
float randNumber; if (Samples==1)
float Y_K_1=0; {
float U_K_1=0; randNumber = random(80,95);
float Y_K_2=0; Samples=Samples+1;
float U_K_2=0; }
if (Samples>60)
// Estos valores son necesarios para la normalización {
//de los datos cuando entran y salen de la red Samples=0;
// Rango de normalización }
const float YMin = -1; Entrada=(randNumber/100);
const float YMax = 1; // Normalización de las entradas que se usará en la red neuronal
CapaEntrada[0]=YMin+
// Valores para normalizar la entrada de la red ((Y_K_1-X1Min)*((YMax-YMin)/(X1Max-X1Min)));
7de8
CapaEntrada[1]=YMin+
((Y_K_2-X2Min)*((YMax-YMin)/(X2Max-X2Min)));
CapaEntrada[2]=YMin+
((U_K_1-X3Min)*((YMax-YMin)/(X3Max-X3Min)));
CapaEntrada[3]=YMin+
((U_K_2-X4Min)*((YMax-YMin)/(X4Max-X4Min)));
*******************************************************
* Calculo de la salida de la capa oculta
*******************************************************
for( i = 0 ; i < NeuronasOculta ; i++ ) {
Neta = PesosOculta[i][NeuronasEntrada] ;
for( j = 0 ; j < NeuronasEntrada ; j++ ) {
Neta += PesosOculta[i][j]*CapaEntrada[j];
}
CapaOculta[i] = (2.0/(1.0 + exp(-2*Neta)))-1.0;
}
********************************************************
* Calculo de la salida de la red
*********************************************************
for( i = 0 ; i < NeuronasSalida ; i++ ) {
Neta = PesosSalida[i][NeuronasOculta] ;
for( j = 0 ; j < NeuronasOculta ; j++ ) {
Neta += PesosSalida[i][j]*CapaOculta[j];
}
CapaSalida[i] = Neta;
}
// La salida da la red esta nromalizada, para que quede en el rango
original //hay que desnormalizar
// Desnormalización de la salida de la red neuronal
Salida=DMin+
((CapaSalida[0]-YMin)*((DMax-DMin)/(YMax-YMin)));
Y_K_2=Y_K_1;
Y_K_1=Salida;
U_K_2=U_K_1;
U_K_1=Entrada;
Serial.println(Entrada);
Serial.println(Salida);
delay(50); }
8de8
