Vous êtes sur la page 1sur 22

METODOS NUMERICOS

AUTORES:

BRAYAN PILA
ANDRES PILICITA
PAOLA ROBAYO

CARRERA: ELECTRNICA E INSTRUMENTACIN

TUTOR: ING.WILSON TRAVEZ

LATACUNGA, JULIO, 2016


INFORME DE AVANCES DE PROYECTO

TEMA: Interpolacin de la adquisicin de datos de un circuito RLC basados en la


plataforma arduino y matlab.

OBJETIVOS:
Realizar un sistema basado en Arduino que permita controlar un sistema fsico
mediante Matlab
Desarrollar un sistema sencillo, cuya interaccin sea intuitiva
Comprobar la curva de los sistemas RLC de segundo orden con un programa
interactivo y amigable con el usuario.
Aplicar el mtodo de regresin o interpolacin para la obtencin de la curva con los
datos medidos del arduino.

MARCO TEORICO
ARDUINO UNO
Arduino es una plataforma de electrnica abierta para la creacin de prototipos basada en
software y hardware flexibles y fciles de usar. Se cre para artistas, diseadores,
aficionados y cualquiera interesado en crear entornos u objetos interactivos . Dicha
plataforma consiste en un soporte hardware formado por una placa que proporciona la
alimentacin, el oscilador, y la carga del programa en micro controladores de la serie 8 bit
de Atmel y soporte software formado por un entorno de desarrollo basado en Wiring [2],
que es un framework abierto para la programacin de micro controladores; y un lenguaje
llamado Processing [3], usado para el aprendizaje, realizacin de prototipos y productos
En este trabajo se ha optado por adquirir las placas ensambladas, sin embargo gracias a que
toda la documentacin se encuentra disponible de forma abierta, las placas pueden ser
ensambladas manualmente y que sean compatibles con dicha plataforma

1
El Hardware se describir la parte del sistema electrnico correspondiente a la siguiente
figura:

Desde la parte izquierda, de arriba hacia debajo se observa con la marca X1 un conector
serie que usa el estndar RS-232 que se utiliza para conectar la placa al ordenador y cargar
los programas. A continuacin, debajo se encuentra la alimentacin por un Jack centro-
positivo que puede funcionar entre 7-20V aunque lo recomendado es mantenerse en un
rango de 9-12V.
A ambos lados, en la parte superior e inferior de la imagen, estn las regletas de pines de
entradas/salidas digitales en la parte superior, y analgicas en la inferior. Debajo de los
pines digitales 9-10-11 se puede ver el cristal de 16Mhz.

Arduino proporciona un entorno de desarrollo basado en Wiring, Figura 5, el cul se trata


de un framework abierto para la programacin de micro controladores y est constituido por
un editor de texto para escribir cdigo y debajo de ste un rea de mensajes.
En la parte superior se tiene una barra de herramientas con las funciones bsicas de
verificar/compilar el programa, volcado en la placa Arduino, etc. La herramienta ms til
ser el monitor serie con el que se podr estar en contacto continuo con la placa

2
Estructura de un programa
Un programa para Arduino comienza incluyendo las libreras que van a ser utilizadas, esto
es la forma de extender la funcionalidad de nuestros programas. Para utilizar una librera
simplemente insertamos en nuestro programa la directiva:
#include <miLibreria.h>
Esto ser descrito ms tarde, cundo al conectar el mdulo de expansin Ethernet, que
como se conecta a travs del puerto SPI, se utilizarn las directivas:
#include <SPI.h>
#include <Ethernet.h>
Otras libreras de las que disponemos oficialmente son la librera EEPROM, para
leer/escribir en memorias permanentes; Firmata, para comunicacin con aplicaciones en el
ordenador a travs del protocolo Serial; Servo, para controlar servomotores; Liquid Crystal
para controlar pantallas LCD; etc.
A continuacin aparece la funcin setup(), cuyo cdigo slo se ejecutar una vez. Es el lugar
dnde inicializar y configurar variables y programas. Despus se encuentra la funcin
loop(), que se ejecutar en un bucle continuo mientras la placa est alimentada. Tras la
funcin loop(), pueden aparecer las funciones llamadas por el programa, si las hay.
#include <miCabecera.h>
void setup()
{
//
}
void loop()
{

3
... funcion_1();
}
int funcion_1()
{}
De esta forma el esquema de un programa en Arduino, tambin llamado sketch, se construye
a partir de las siguientes lneas:
Otro punto destacable, adems de la familia de placas Arduino, es que gracias a su
popularidad y a su carcter abierto se ha creado una gran comunidad en torno a estas placas,
que proporciona mdulos, accesorios para su expansin, libreras y en general mucha
documentacin y ayuda para realizar las interfaces con otro software y hardware. Estas
caractersticas de modularidad y expansin harn que esta plataforma sea una opcin ideal
para ste proyecto.

MATLAB

MATLAB es una herramienta de software matemtico que ofrece un entorno de desarrollo


integrado (IDE) con un lenguaje de programacin propio (lenguaje M). Est disponible para
las plataformas Unix, Windows, Mac OS X y GNU/Linux .

Entre sus prestaciones bsicas se hallan: la manipulacin de matrices, la representacin de


datos y funciones, la implementacin de algoritmos, la creacin de interfaces de usuario
(GUI) y la comunicacin con programas en otros lenguajes y con otros dispositivos
hardware. El paquete MATLAB dispone de dos herramientas adicionales que expanden sus
prestaciones, a saber, Simulink (plataforma de simulacin multidominio) y GUIDE (editor
de interfaces de usuario - GUI). Adems, se pueden ampliar las capacidades de MATLAB
con las cajas de herramientas (toolboxes); y las de Simulink con los paquetes de bloques
(blocksets).

Es un software muy usado en universidades y centros de investigacin y desarrollo. En los


ltimos aos ha aumentado el nmero de prestaciones, como la de programar directamente
procesadores digitales de seal o crear cdigo VHDL.

CIRCUITOS DE PRIMER ORDEN

4
Los circuitos de primer orden son circuitos que contienen solamente un componente que
almacena energa (puede ser un condensador o inductor), y que adems pueden describirse
usando solamente una ecuacin diferencial de primer orden. Los dos posibles tipos de
circuitos primer orden:

1. Circuito RC (Resistor y Condensador)


2. Circuito RL (Resistor e Inductor)

Los circuitos serie RL y RC (figura 1) tienen un comportamiento similar en cuanto a su


respuesta en corriente y en tensin, respectivamente.

Al cerrar el interruptor S en el circuito serie RL, la bobina crea una fuerza electromotriz
(FEM) que se opone a la corriente que circula por el circuito, denominada por ello fuerza
contra electromotriz. Como consecuencia de ello, en el mismo instante de cerrar el
interruptor (t0 en la figura 2) la intensidad ser nula e ir aumentando exponencialmente
hasta alcanzar su valor mximo, Io=E/R (de t0 a t1). Si a continuacin, en el mismo circuito
abrimos S (se har circuito abierto en la red RL),y el valor de Io no desaparecera
instantneamente, sino que ira disminuyendo de forma exponencial hasta hacerse cero (de
t2 a t3).

Por otro lado, en el circuito serie RC, al cerrar el interruptor S (t0 en la figura 2), el
condensador comienza a cargarse, aumentando su tensin exponencialmente hasta alcanzar
su valor mximo E0 (de t0 a t1), que coincide con el valor de la FEM E de la fuente. Si a
continuacin, en el mismo instante de abrir S (t2 en la figura 2) se har corto circuito en la
red RC, el valor de Eo no desaparecera instantneamente, sino que ira disminuyendo de
forma exponencial hasta hacerse cero (de t2 a t3).

5
CIRCUITO DE SEGUNDO ORDEN
Son circuitos de segundo orden aquellos cuyas variables estn caracterizadas por ecuaciones
diferenciales de segundo orden. Un circuito que tiene dos elementos almacenadores de
energa de distinto tipo (una bobina y un condensador) es, normalmente, un circuito de
segundo orden. A veces hay circuitos con ms de dos elementos almacenadores de energa
que son de segundo orden. Por ejemplo, cuando se pueden agrupar elementos del mismo
tipo en uno equivalente. La ecuacin diferencial de los circuitos RLC serie es:

Obteniendo asi los tres casos:

6
Sobreamortiguado.

Subamortiduado

Crticamente amortiguado.

7
DESARROLLO
PROGRAMACION ARDUINO
Conexin arduino-matlab
Adquisicin de datos para el programa matlab
Descarga de libreras para el funcionamiento de arduino.

/* Analog and Digital Input and Output Server for MATLAB */


/* Giampiero Campa, Copyright 2009 The MathWorks, Inc */
/* This file is meant to be used with the MATLAB arduino IO
package, however, it can be used from the IDE environment
(or any other serial terminal) by typing commands like:

0e0 : assigns digital pin #4 (e) as input


0f1 : assigns digital pin #5 (f) as output
0n1 : assigns digital pin #13 (n) as output

1c : reads digital pin #2 (c)


1e : reads digital pin #4 (e)
2n0 : sets digital pin #13 (n) low
2n1 : sets digital pin #13 (n) high
2f1 : sets digital pin #5 (f) high
2f0 : sets digital pin #5 (f) low
4j2 : sets digital pin #9 (j) to 50=ascii(2) over 255
4jz : sets digital pin #9 (j) to 122=ascii(z) over 255
3a : reads analog pin #0 (a)
3f : reads analog pin #5 (f)

R0 : sets analog reference to DEFAULT


R1 : sets analog reference to INTERNAL
R2 : sets analog reference to EXTERNAL

8
99 : returns script type (1 basic, 2 motor, 3 general) */

/* define internal for the MEGA as 1.1V (as as for the 328) */
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define INTERNAL INTERNAL1V1
#endif

void setup() {
/* Make sure all pins are put in high impedence state and
that their registers are set as low before doing anything.
This puts the board in a known (and harmless) state */
int i;
for (i=0;i<20;i++) {
pinMode(i,INPUT);
digitalWrite(i,0);
}
/* initialize serial */
Serial.begin(115200);
}

void loop() {

/* variables declaration and initialization */

static int s = -1; /* state */


static int pin = 13; /* generic pin number */

int val = 0; /* generic value read from serial */


int agv = 0; /* generic analog value */
int dgv = 0; /* generic digital value */

9
/* The following instruction constantly checks if anything
is available on the serial port. Nothing gets executed in
the loop if nothing is available to be read, but as soon
as anything becomes available, then the part coded after
the if statement (that is the real stuff) gets executed */

if (Serial.available() >0) {

/* whatever is available from the serial is read here */


val = Serial.read();

/* This part basically implements a state machine that


reads the serial port and makes just one transition
to a new state, depending on both the previous state
and the command that is read from the serial port.
Some commands need additional inputs from the serial
port, so they need 2 or 3 state transitions (each one
happening as soon as anything new is available from
the serial port) to be fully executed. After a command
is fully executed the state returns to its initial
value s=-1 */

switch (s) {

/* s=-1 means NOTHING RECEIVED YET ******************* */


case -1:

/* calculate next state */


if (val>47 && val<90) {
/* the first received value indicates the mode
49 is ascii for 1, ... 90 is ascii for Z

10
s=0 is change-pin mode
s=10 is DI; s=20 is DO; s=30 is AI; s=40 is AO;
s=90 is query script type (1 basic, 2 motor)
s=340 is change analog reference
*/
s=10*(val-48);
}

/* the following statements are needed to handle


unexpected first values coming from the serial (if
the value is unrecognized then it defaults to s=-1) */
if ((s>40 && s<90) || (s>90 && s!=340)) {
s=-1;
}

/* the break statements gets out of the switch-case, so


/* we go back to line 97 and wait for new serial data */
break; /* s=-1 (initial state) taken care of */

/* s=0 or 1 means CHANGE PIN MODE */

case 0:
/* the second received value indicates the pin
from abs('c')=99, pin 2, to abs('t')=116, pin 19 */
if (val>98 && val<117) {
pin=val-97; /* calculate pin */
s=1; /* next we will need to get 0 or 1 from serial */
}
else {
s=-1; /* if value is not a pin then return to -1 */
}
break; /* s=0 taken care of */

11
case 1:
/* the third received value indicates the value 0 or 1 */
if (val>47 && val<50) {
/* set pin mode */
if (val==48) {
pinMode(pin,INPUT);
}
else {
pinMode(pin,OUTPUT);
}
}
s=-1; /* we are done with CHANGE PIN so go to -1 */
break; /* s=1 taken care of */

/* s=10 means DIGITAL INPUT ************************** */

case 10:
/* the second received value indicates the pin
from abs('c')=99, pin 2, to abs('t')=116, pin 19 */
if (val>98 && val<117) {
pin=val-97; /* calculate pin */
dgv=digitalRead(pin); /* perform Digital Input */
Serial.println(dgv); /* send value via serial */
}
s=-1; /* we are done with DI so next state is -1 */
break; /* s=10 taken care of */

12
/* s=20 or 21 means DIGITAL OUTPUT ******************* */

case 20:
/* the second received value indicates the pin
from abs('c')=99, pin 2, to abs('t')=116, pin 19 */
if (val>98 && val<117) {
pin=val-97; /* calculate pin */
s=21; /* next we will need to get 0 or 1 from serial */
}
else {
s=-1; /* if value is not a pin then return to -1 */
}
break; /* s=20 taken care of */

case 21:
/* the third received value indicates the value 0 or 1 */
if (val>47 && val<50) {
dgv=val-48; /* calculate value */
digitalWrite(pin,dgv); /* perform Digital Output */
}
s=-1; /* we are done with DO so next state is -1 */
break; /* s=21 taken care of */

/* s=30 means ANALOG INPUT *************************** */

case 30:
/* the second received value indicates the pin
from abs('a')=97, pin 0, to abs('f')=102, pin 6,
note that these are the digital pins from 14 to 19

13
located in the lower right part of the board */
if (val>96 && val<103) {
pin=val-97; /* calculate pin */
agv=analogRead(pin); /* perform Analog Input */
Serial.println(agv); /* send value via serial */
}
s=-1; /* we are done with AI so next state is -1 */
break; /* s=30 taken care of */

/* s=40 or 41 means ANALOG OUTPUT ******************** */

case 40:
/* the second received value indicates the pin
from abs('c')=99, pin 2, to abs('t')=116, pin 19 */
if (val>98 && val<117) {
pin=val-97; /* calculate pin */
s=41; /* next we will need to get value from serial */
}
else {
s=-1; /* if value is not a pin then return to -1 */
}
break; /* s=40 taken care of */

case 41:
/* the third received value indicates the analog value */
analogWrite(pin,val); /* perform Analog Output */
s=-1; /* we are done with AO so next state is -1 */
break; /* s=41 taken care of */

14
/* s=90 means Query Script Type (1 basic, 2 motor) */
case 90:
if (val==57) {
/* if string sent is 99 send script type via serial */
Serial.println(1);
}
s=-1; /* we are done with this so next state is -1 */
break; /* s=90 taken care of */

/* s=340 or 341 means ANALOG REFERENCE *************** */

case 340:
/* the second received value indicates the reference,
which is encoded as is 0,1,2 for DEFAULT, INTERNAL
and EXTERNAL, respectively */

switch (val) {

case 48:
analogReference(DEFAULT);
break;

case 49:
analogReference(INTERNAL);
break;

case 50:
analogReference(EXTERNAL);
break;

15
default: /* unrecognized, no action */
break;
}

s=-1; /* we are done with this so next state is -1 */


break; /* s=341 taken care of */

/* ******* UNRECOGNIZED STATE, go back to s=-1 ******* */

default:
/* we should never get here but if we do it means we
are in an unexpected state so whatever is the second
received value we get out of here and back to s=-1 */

s=-1; /* go back to the initial state, break unneeded */

} /* end switch on state s */

} /* end if serial available */

} /* end loop statement */

PROGRAMA DE MATLAB

Realizar la Interpolacin o regresin de los datos adquiridos por la placa arduino desde
los circuitos de primer y segundo orden
Realizar Programa amigable con el usuario por medio de GUIDE
Programar para las grficas de las curvas de carga y descarga del condensador.
Comprobar las grficas con un simulador (proteus) para verificar si la curva obtenida es la
correcta

16
% --- Executes on button press in calcular.
function calcular_Callback(hObject, eventdata, handles)
% hObject handle to calcular (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

global solucionf ejs


cap_ = get(handles.menu_c, 'value');
switch cap_
case 1
cap_2 = 1e-3;
case 2
cap_2 = 1e-6;
case 3
cap_2 = 1e-9;
case 4
cap_2 = 1e-12;
end
colr = [0.071 0.212 0.141];
F = str2num(get(handles.fuente, 'string'));
R = str2num(get(handles.resistencia, 'string'));
L = str2num(get(handles.bobina, 'string'));
C = cap_2*(str2num(get(handles.capacitor, 'string')));
V0 = F;
I0 = F/R;
A1 = 'D2y + ';
A2 = num2str(R/L);
A3 = '*Dy + ';
A4 = num2str(1/(L*C));
A5 = '*y = 0';
B1 = 'y(0) = ';
B2 = num2str(V0);
C1 = 'Dy(0) = ';
C2 = num2str(I0/C);
solucionf = simple(dsolve(strcat(A1, A2, A3, A4, A5),strcat(B1, B2),
strcat(C1, C2)));
clc
Ec2 = [1, R/L, 1/(L*C)]
sol_ec2 = roots(Ec2)
alpha = real(sol_ec2)
solucionff = char(solucionf);
set(handles.solucion, 'visible', 'on');
set(handles.solucion, 'string', solucionff);
set(handles.v0, 'string', V0);
set(handles.i0, 'string', I0);
t = linspace(0,3, 500);
vt = subs(solucionf, t);
set(handles.axes1, 'visible', 'on')
axes(handles.axes1);
plot(t, vt, '-g', 'LineWidth',2),
title('\bf\fontsize{16}\fontname{algerian}OSCILOSCOPIO'),...
xlabel('\bf\fontsize{12}tiempo [s]'),
ylabel('\bf\fontsize{12}Voltaje [V]');
% ezplot(solucionf, [0,3], '-g'), title('OSCILOSCOPIO'),
xlabel('tiempo'),
% ylabel('Voltaje');
hold on
% e= exp(alpha(1).*t);
% alpha(1)
% plot(t, e);

17
grid on;
grid minor
edo = sym(solucionff);
fprintf('LA SOLUCION DE LA ECUACION DIFERENCIAL ES:\n\n')
pretty(edo)
set(handles.axes1, 'color', colr);
set(handles.animacion, 'visible', 'on')
set(handles.animacion, 'enable', 'on')
set(handles.animacion3, 'enable', 'on')
ejs = axis;
msgbox({'El clculo ha finalizado.',...
'La solucin de la ecuacin diferencial, se presentara tambin en la
pantalla principal de MATLAB.'},...
'GRACIAS POR ESPERAR', 'help');
% lap = laplace()

% --- Executes on button press in limpiar.


function limpiar_Callback(hObject, eventdata, handles)
% hObject handle to limpiar (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
cla
set(handles.axes1, 'visible', 'off')
set(handles.fuente, 'string', '');
set(handles.resistencia, 'string', '');
set(handles.bobina, 'string', '');
set(handles.capacitor, 'string', '');
set(handles.solucion, 'string', '');
set(handles.i0, 'string', '');
set(handles.v0, 'string', 'help');
set(handles.animacion, 'visible', 'off')
set(handles.solucion, 'visible', 'off');
clear all
set(handles.animacion3, 'enable', 'off')

% --- Executes on button press in animacion.


function animacion_Callback(hObject, eventdata, handles)
% hObject handle to animacion (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
global ejs solucionf
set(handles.axes1, 'visible', 'on')
% axis off
cla
axes(handles.axes1);
colr = [0.071 0.212 0.141];
for i=0:0.1:3
set(handles.axes1, 'color', colr);
t1 = linspace(0, i,500);
ft = subs(solucionf, t1);
plot(t1, ft, 'g', 'LineWidth',2);
set(handles.axes1, 'color', colr);
axis(ejs);
pause(0.00000000001);
end
title('\bf\fontsize{16}\fontname{algerian}OSCILOSCOPIO'),...

18
xlabel('\bf\fontsize{12}tiempo [s]'),
ylabel('\bf\fontsize{12}Voltaje [V]');
% grid minor
grid on

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

RESULTADOS

INTERFAZ GRAFICA PARA UN CIRCUITO RLC

GRAFICA LA CURVA CON ALGUNOS DATOS ALEATORIOS

19
REALIZAMOS LA COMUNICACIN CON ARDUINOY GRAFICA LAS OTRAS DOS
CURVAS

CONCLUCIONES
En este trabajo se a realizado un sistema de adquisicin de datos entre el arduino
uno y el programa de matlab de forma correcta.
Pudimos verificar la curva de los circuitos RLC mediante un software.
Pudimos aplicar de la mejor forma la regresin o interpolacin aprendida en clase
Pudimos observar que la grfica obtenida por el arduino y la grafica interpolada son
muy similares
Saber sobre el manejo de vectores para la interpolacin polinomial y saber que el
vector guardado debe tener datos solo numricos

RECOMENDACIONES
Realizar la conexin matlab-arduino de manera correcta ya que puede efectuar algn
tipo de errores en la hora de adquisicin de datos.

20
Es recomendable que la adquisicin de datos que realiza el arduino sea guardado
como un vector en el programa Matlab.
Descargar todas las libreras necesarias para la programacin de arduino.
Aprender de forma correcta la Interpolacin polinomial y su aplicacin en matlab

BIBLIOGRAFIA
https://es.wikipedia.org/wiki/MATLAB
https://es.wikipedia.org/wiki/Arduino
https://www.arduino.cc/en/Reference/Libraries
http://arduino.cc/es/Main/Hardware
http://www.mathworks.com/matlabcentral/fileexchange/32374-matlab-support-
package-for-arduino-aka-arduinoio-package

21