MATLAB-ARDUINO

4.1. ARQUITECTURA ARDUINO

Arduino es una herramienta para hacer que los ordenadores puedan sentir y controlar
el mundo físico a través de tu ordenador personal. Es una plataforma de desarrollo de
computación física (physical computing) de código abierto, basada en una placa con un
sencillo microcontrolador y un entorno de desarrollo para crear software (programas)
para la placa.
Puedes usar Arduino para crear objetos interactivos, leyendo datos de una gran
variedad de interruptores y sensores y controlar multitud de tipos de luces, motores y
otros actuadores físicos. Los proyecto de Arduino pueden ser autónomos o
comunicarse con un programa (software) que se ejecute en tu ordenador (ej. Flash,
Processing, MaxMSP). La placa puedes montarla tu mismo o comprarla ya lista para
usar, y el software de desarrollo es abierto y lo puedes descargar gratis.
El lenguaje de programación de Arduino es una implementación de Wiring, una
plataforma de computación física parecida, que a su vez se basa en Processing, un
entorno de programación multimedia.

¿Porque preferir arduino?

Hay muchos otros microcontroladores y plataformas con microcontroladores

disponibles para la computación física. Parallax Basic Stamp, BX-24 de Netmedia,
Phidgets, Handyboard del MIT, y muchos otros ofrecen funcionalidades similares.
Todas estas herramientas organizan el complicado trabajo de programar un
microcontrolador en paquetes fáciles de usar. Arduino, además de simplificar el
proceso de trabajar con microcontroladores, ofrece algunas ventajas respecto a otros
sistemas a profesores, estudiantes y amateurs:

 Asequible-Las placas Arduino son más asequibles comparadas con otras

plataformas de microcontroladores. La versión más cara de un módulo de
Arduino puede ser montada a mano, e incluso ya montada cuesta bastante
menos de 70$.

 MultiPlataforma-El software de Arduino funciona en los sistemas operativos

Windows, Macintosh OSX y Linux. La mayoría de los entornos para
microcontroladores están limitados a Windows.

 Entorno de programacion simple y directo-El entorno de programación de

Arduino es fácil de usar para principiantes y lo suficientemente flexible para
los usuarios avanzados. Pensando en los profesores, Arduino está basado en el
entorno de programación de Procesing con lo que el estudiante que aprenda a
programar en este entorno se sentirá familiarizado con el entorno de
desarrollo Arduino.

 Software ampliable y de código abierto-El software Arduino esta publicado

bajo una licencia libre y preparado para ser ampliado por programadores
experimentados. El lenguaje puede ampliarse a través de librerías de C++, y si
 se está interesado en profundizar en los detalles técnicos, se puede dar el salto
a la programación en el lenguaje AVR C en el que está basado. De igual modo
se puede añadir directamente código en AVR C en tus programas si así lo
deseas.

 Hadware ampliable y de código abierto-Arduino está basado en los

microcontroladores ATMEGA168,ATMEGA328 y ATMEGA1280. Los planos de
los módulos están publicados bajo licencia Creative Commons, por lo que
diseñadores de circuitos con experiencia pueden hacer su propia versión del
módulo, ampliándolo u optimizándolo. Incluso usuarios relativamente
inexpertos pueden construir la versión para placa de desarrollo para entender
cómo funciona y ahorrar algo de dinero.

DIFERENTES TIPOS DE ARDUINOS

-Arduino UNO
-Arduino Leonardo
-Arduino Due
-Arduino Yun
-Arduino Robot
-Arduino Esplora
-Arduino Mega
-Arduino Mini
-Arduino Nano
-Arduino Micro
-Arduino Pro
-Arduino Ethernet

4.2. REPERTORIO DE INSTRUCCIONES

Se supone que la programación en Arduino es divertida, pero puede resultar frustrante y lenta
en el caso de tareas tales como la representación gráfica de datos de sensores o la
incorporación en los proyectos de rutinas avanzadas de matemáticas, procesamiento de
señales o control.

MATLAB y Simulink abordan varios retos en relación con la programación tradicional en

Arduino. Estos productos admiten dos flujos de trabajo principales:

 Lectura, escritura y análisis de datos de los sensores de Arduino

 Desarrollo de algoritmos que se ejecutan de forma autónoma en el dispositivo Arduino

Lectura, escritura y análisis de datos de los sensores de Arduino

El paquete de soporte de MATLAB para Arduino permite escribir programas de MATLAB que
leen y escriben datos en los dispositivos Arduino y otros dispositivos conectados, tales como
Adafruit Motor Shield, I2C y SPI. Ya que MATLAB es un lenguaje interpretado de alto nivel, la
programación resulta más fácil que con C/C++ y otros lenguajes compilados, de forma que se
pueden ver resultados de las instrucciones de E/S inmediatamente, sin necesidad de
compilación. MATLAB incluye miles de funciones matemáticas, de ingeniería y de
representación gráfica integradas que permiten analizar y visualizar con rapidez los datos
recopilados en el dispositivo Arduino.

Con el paquete de soporte de MATLAB para Arduino, el dispositivo Arduino se conecta a un

equipo que ejecuta MATLAB. El procesamiento se lleva a cabo en el equipo con MATLAB.

Ventajas del uso de MATLAB para la programación en Arduino:

 Lectura y escritura de datos de sensor de forma interactiva sin necesidad de esperar a

la compilación del código

 Análisis de los datos de sensor mediante miles de funciones prediseñadas para

el procesamiento de señales, el aprendizaje automático, el modelado matemático, etc.

 Visualización rápida de los datos gracias a la amplia gama de tipos de gráficos de

MATLAB
Desarrollo de algoritmos que se ejecutan de forma autónoma en el dispositivo Arduino

El paquete de soporte de Simulink para Arduino permite desarrollar algoritmos en Simulink, un

entorno de diagrama de bloques para modelar sistemas dinámicos y desarrollar algoritmos, así
como ejecutarlos de forma autónoma en el dispositivo Arduino. El paquete de soporte amplía
la funcionalidad de Simulink con bloques para configurar los sensores de Arduino, además de
leer y escribir datos en ellos. Tras crear el modelo de Simulink, es posible simularlo, ajustar los
parámetros del algoritmo hasta obtener el resultado deseado y descargar el algoritmo
completado para su ejecución autónoma en el dispositivo. El bloque MATLAB Function permite
incorporar código de MATLAB el modelo de Simulink.

Con el paquete de soporte de Simulink para Arduino, es posible desarrollar el algoritmo en

Simulink y desplegarlo en Arduino mediante la generación automática de código. El
procesamiento se lleva a cabo entonces en el dispositivo Arduino.

Ventajas del uso de Simulink para la programación en Arduino:

 Desarrollo y simulación de los algoritmos en Simulink y uso de la generación

automática de código para ejecutarlos en el dispositivo

 Incorporación de rutinas de procesamiento de señales, diseño de control, lógica de

estados y otras rutinas avanzadas de matemáticas e ingeniería en los proyectos de
hardware

 Ajuste y optimización interactivos de parámetros mientras el algoritmo se ejecuta en

el dispositivo

 Modificación fácil de algoritmos para su ejecución en otras plataformas de hardware

comerciales de bajo coste

INSTALANDO LA TARJETA CON INTERFAZ A MATLAB

Para conectar la tarjeta Arduino UNO, como si fuera una tarjeta de interfaz o de transferencia
de datos, con el IDE MATLAB, siga los siguientes pasos:
1. Descarge el archivo “ArduinoIO.zip”. También está disponible en esta carpeta de
Google Docs, que comparto con ustedes.
 2. Descomprimir el archivo en la carpeta deseada en el equipo. Preferiblemente en
carpeta Matlab, que está en “Mis Documentos”. De esta forma, los M-files, quedan
disponibles inmediatamente, en el directorio corriente del entorno de Matlab.
3. Asumiendo que ya tiene instalado el IDE ARDUINO, abra desde este entorno, el archivo
“adiosrv.pde” que está dentro de la carpeta “adiosrv” , que a su vez está dentro de la
carpeta “pde” , una de las que se descomprimió.
4. Cargue en la tarjeta, este programa. Este sketch, contiene el código necesario para que
la tarjeta Arduino “escuche” los comandos ejecutados desde Matlab, ejecute
instrucciones, interactúe con dispositivos conectados a la tarjeta y transfiera datos
desde sensores y dispositivos, hacia Matlab.
5. Una vez cargado el programa en la tarjeta Arduino, es recomendable cerrar el IDE
ARDUINO, para que Matlab pueda acceder al puerto serial que se abre cuando se
conecta la tarjeta.
6. Abrir el programa Matlab.
7. En la carpeta del “Current Directory”, debe estar el m-file “install_arduino”. Ejecutar
para que se realice la comunicación. Asegúrese que la tarjeta Arduino esté conectada y
activa.
8. Verifique el puerto COM utilizado por la tarjeta para la configuración de esta. El
número de puerto se puede consultar accediendo a: Mi
PC/Propiedades/Hardware/Administrador de Dispositivos. En esta ventana, ubique los
puertos COM disponibles (COM & LPT), expanda el menú para ver en qué puerto COM
está conectado Arduino UNO R3.

CONFIGURACIÓN DE LOS PINES DE LA TARJETA DESDE MATLAB

Para interactuar con la tarjeta, desde el entorno de Matlab; primero se debe crear un objeto
para acceder a la información de puerto de comunicación a la que está conectada la tarjeta. Se
hace con la línea de comando, de la siguiente forma:
cIO = arduino(‘COM3’)
Entre paréntesis, figura el puerto serial al que se conectó la Arduino, como se indica en el paso
“8.” de la sección anterior. En este ejemplo “COM3”, pero puede ser cualquier otro valor.
Al ejecutar la línea anterior en la ventana de comandos, se inicia una conexión y aparecerá en
pantalla, texto informativo sobre la configuración de entradas, salidas y estado actual de los
pines.
Los pines de la tarjeta o borneras de conexión, que permiten conectar el sistema a dispositivos
externos, pueden configurarse como entradas o como salidas y a su vez, en forma digital o
análoga.

CONFIGURACIÓN DE LOS PINES

El procedimiento del objeto “cIO” para configurar los pines como entradas o como salidas es
“pinMode”. A continuación, los ejemplos:
cIO.pinMode(13, ‘OUTPUT’)
Este comando, configura el pin 13 de la tarjeta Arduino, como salida digital.
cIO.pinMode(10, ‘INPUT’)
Configura el pin 10, como entrada digital.
cIO.pinMode(11)
Muestra el estado, de entrada, o salida del pin 11
cIO.pinMode
Muestra el listado del estado de cada uno de los pines.

LECTURA DE ENTRADA DIGITAL

Si un pin ha sido configurado como entrada, el comando para leerlo es:
cIO.digitalRead(10)
que permite leer el estado alto “1” o bajo “0” del pin 10.
val = cIO.digitalRead(10)
Asigna el valor booleano presente en la entrada pin 10, a la variable “val”.

ESCRITURA DIGITAL DE SALIDA

Si un pin ha sido configurado como salida, para colocar un estado alto “1” o bajo “0” en dicha
salida, se usa el comando:
cIO.digitalWrite(13, 1)
Pone en alto el pin 13.
cIO.digitalWrite(13, 0)
Pone el pin 13 en estado bajo.

LECTURA DE ENTRADA ANÁLOGA

Las entradas análogas, son pines de la tarjeta Arduino, que pueden recibir voltajes en un rango
de 0 a 5 voltios. Útiles cuando se requiere un sensor que represente el valor de una variable
análoga, como, por ejemplo: la temperatura. Suministran un valor entero entre 0 y 1023,
proporcional al valor de voltaje de la entrada análoga. El comando para leer es:
cIO.analogRead(5)
Muestra el valor presente en la entrada análoga 5, como un número entero entre 0 y 1023.
lect = cIO.analogRead(1)
Asigna el valor entero presente en la entrada análoga 1, a la variable “lect”, como un número
entero entre 0 y 1023

ESCRITURA EN SALIDA ANÁLOGA

Para asignar un valor análogo a un pin de salida, se sigue el siguiente formato:
cIO.analogWrite(3, 200)
El primer argumento de la función o método, es el pin análogo (Sólo se pueden usar los pines
3, 5, 6, 9, 10, 11) y el segundo argumento, un valor de 0 a 255, proporcional al voltaje de salida
presente en ese pin.

4.3. ENTORNO DE DESARROLLO

A la hora de empezar con cualquier proyecto de aplicación práctica, una de las cuestiones
principales suele ser enlazar la parte teórica (trabajosamente programada en nuestro entorno
informático preferido) como algoritmos de tratamiento de datos, sistemas de control
automático, etc., con el mundo real.
Hasta no hace mucho, la única manera de poder trabajar con datos físicos consistía en adquirir
un sistema comercial de adquisición de datos (DAQ) como los de National Instruments;
afortunadamente hoy en día hay alternativas uno o dos órdenes de magnitud más asequibles:
una de ellas es el popular microcontrolador Arduino.

Uno de los ejemplos más básicos consiste en leer datos de un sensor conectado al Arduino y
transmitirlos al PC mediante comunicación serie; sin embargo, este ejemplo tiene dos
limitaciones: se limita a un único sensor y los datos se leen numéricamente en pantalla, pero
no es posible adquirirlos ni trabajar con ellos. ¡Por eso me ha parecido interesante compartir
este ejemplo, que me ha costado unos cuantos dolores de cabeza!

El objetivo será pues leer una señal analógica de dos (extensible fácilmente a más) sensores
(en este caso potenciómetros) y transmitirla a Matlab, a fin de poder trabajar con ella.

CONFIGURACIÓN DE ARDUINO

Conexión de los dos potenciómetros al Arduino. Easy!

En primer lugar, vamos a preparar el Arduino. Conectamos los potenciómetros entre los pines
de +5V y Gnd (neutro) y sus pines centrales (que por tanto presentarán un voltaje entre +5V y
0V) a las entradas analógicas A0 y A1 del Arduino, de esta manera:

Por supuesto, cualquier otro sensor analógico sirve exactamente igual para este ejemplo. A
continuación, hemos de programar el Arduino, para que recoja la información de A0 y A1 y la
envíe via serie; el formato del envío consiste en: valor de A0, coma, valor de A1 y retorno de
carro + línea nueva (debido a que se usa la función Serial.println() al final)

1 int out1 = 0;
2 int out2 = 0;
 3
4 void setup() {
5 // inicializar puerto serie
6 Serial.begin(9600);
7 }
8
9 void loop() {
10 // leer pines
11 out1 = analogRead(A0);
12 out2 = analogRead(A1);
13 // enviar
14 Serial.print(out1);
15 Serial.print(",");
16 Serial.println(out2);
17 // esperar
18 delay(20);
19 }

CONFIGURACIÓN DE MATLAB

Una vez configurado el Arduino, los datos se enviarán por la propia conexión USB, pero
simulando un puerto serie que deberemos conocer (desde la propia interfaz de Arduino se
puede averiguar). En este caso, en el entorno Windows, el puerto será el COM4. El primer paso
será crear un objeto serie en Matlab y abrirlo para empezar a leer:

1
2 %borrar previos
3 delete(instrfind({'Port'},{'COM4'}));
4 %crear objeto serie
5 s = serial('COM4','BaudRate',9600,'Terminator','CR/LF');
6 warning('off','MATLAB:serial:fscanf:unsuccessfulRead');
7 %abrir puerto
fopen(s);

El siguiente paso es preparar la medida, ajustando dos parámetros: el tiempo total de medida,
y la velocidad de capturas por segundo. Éste último parámetro hay que estimarlo, pero
haremos que el programa nos devuelva el valor real, con lo que si éste se aleja de lo estimado
será inmediato corregirlo.

1 % parámetros de medidas
 2 tmax = 10; % tiempo de captura en s
3 rate = 33; % resultado experimental (comprobar)

A continuación, preparamos la figura en la que leeremos la señal de ambos potenciómetros.

Abrimos una nueva ventana y unos nuevos ejes, y creamos dos objetos gráficos de tipo línea,
que iremos actualizando a medida que tengamos los datos. De esta manera Matlab no se
saturará, que es lo que pasaría si intentásemos utilizar la función plot() dentro del bucle.

1
2 % preparar la figura
3 f = figure('Name','Captura');
4 a = axes('XLim',[0 tmax],'YLim',[0 5.1]);
5 l1 = line(nan,nan,'Color','r','LineWidth',2);
6 l2 = line(nan,nan,'Color','b','LineWidth',2);
7
8 xlabel('Tiempo (s)')
9 ylabel('Voltaje (V)')
10 title('Captura de voltaje en tiempo real con Arduino')
11 grid on
hold on

El núcleo del programa es el bucle de medida, en el cual iremos leyendo del puerto serie los
datos en el formato que hemos especificado, midiendo el tiempo de ejecución y actualizando
los dos objetos línea creados anteriormente: los datos Y serán los voltajes medidos hasta el
momento y los datos X el tiempo de ejecución. Al salir del bucle, imprimiremos el dato de
capturas por segundo que hemos estimado arriba.

1 % inicializar
2 v1 = zeros(1,tmax*rate);
3 v2 = zeros(1,tmax*rate);
4 i = 1;
5 t = 0;
6
7 % ejecutar bucle cronometrado
8 tic
9 while t<tmax
10 t = toc;
11 % leer del puerto serie
12 a = fscanf(s,'%d,%d')';
13 v1(i)=a(1)*5/1024;
 14 v2(i)=a(2)*5/1024;
15 % dibujar en la figura
16 x = linspace(0,i/rate,i);
17 set(l1,'YData',v1(1:i),'XData',x);
18 set(l2,'YData',v2(1:i),'XData',x);
19 drawnow
20 % seguir
21 i = i+1;
22 end
23 % resultado del cronometro
24 clc;
25 fprintf('%g s de captura a %g cap/s \n',t,i/t);

Si queremos, podemos salvar la figura en forma de PDF (vectorial) o cualquier otro formato
que queramos. Para esto yo uso una útil función externa creada por Aslak Grinsted.

1
savefigure('captura_multi','s',[4.5 3],'po','-dpdf')

Por último, cerramos el puerto serie (para que otras aplicaciones lo puedan utilizar) y
eliminamos el objeto serie que hemos creado en el primer paso.

1
2 %% Limpiar la escena del crimen
3 fclose(s);
4 delete(s);
clear s;
RESULTADO

Con el código del ejemplo, obtendríamos una figura semejante a esta:

Por supuesto, una vez recogidos los datos en las variables v1 y v2, ya podemos
analizarlos de cualquier manera que se nos ocurra: podemos realizar un análisis espectral
mediante transformada rápida de Fourier; graficarlos frente a otras variables, realizar un
test de correlación, salvarlos en formato Excel, etc.

4.4. PROGRAMACION BASICA CON ARDUINO EN MATLAB

1. Tener instalado el MATLAB, y descargar los archivos mencionados en las
preguntas frecuentes.
2. Abrir la carpeta “arduino-1.0.4-windows” y luego el “ARDUINO”.
3. Conectar la placa ARDUINO a través del cable USB.
4. Verificar por cual “COM” quedo conectado. Nos dirigimos a Inicio>Equipo “Click
derecho” >Administrar>Administrador de dispositivos>Puertos>Arduino Mega
2560, al lado derecho de “Arduino Mega 2560” sale el COMX, siendo X un
nuevo entre 0 y 6 usualmente.
5. Dentro del ARDUINO ir a Herramientas>Tarjeta y elegir la “placa ARDUINO
MEGA 2560”
6. De nuevo ir a Herramientas>Puerto Serial y seleccionar nuestro puerto COMX,
que ubicamos en el paso 4.
7. Vamos a introducir una sketch dentro de nuestra placa ARDUINO. Esta sketch
nos permitirá hacer la conexión entre el ARDUINO Y MATLAB, se le instala este
sketch a la placa para que pueda entender las ordenes enviadas desde el
MATLAB.
 Dentro del Arduino: Archivo>Abrir Buscamos dentro de los archivos
descargados en la siguiente dirección: ArduinoIO>pde>adiosrv>adiosrv.pde
8. Teniendo el adiosrv abierto le damos a “cargar” y esperamos hasta que diga
“Carga terminada.”
9. Cerramos el “ARDUINO” para dejar de tener el puerto ocupado, así poder
establecer ahora la conexión a través del MATLAB.
10. Se abre como administrador el MATLAB, MATLAB >„Click derecho‟>Ejecutar
como administrador.
11. El directorio “Current Folder” lo ubicamos dentro de la carpeta ArduinoIO.
12. Procedemos a realizar la instalación adecuada insertando los comandos:
Digitamos “install_arduino” (sin comillas). Si sale error es que hicieron mal el
paso 11, o escribieron mal “install_arduino”. Ahora digitamos
“a=arduino('COMX')” (sin comillas). Donde X es el número hallado en el paso 4.
Justo ahora debería de aparecer muchas instrucciones. Dichas instrucciones
entendiéndolas orientaran al usuario en la programación

EJEMPLOS

Codificación
%la velocidad de adquisición es de 33 muestras x segundo
%borrar previos
delete(instrfind({'Port'},{'COM7'}));
%crear objeto serie
s=serial('COM7','BaudRate',9600,'Terminator','CR/LF');
warning('off','MATLAB:serial:fscanf:unsuccessfulRead');
%abrir puerto
fopen(s);
% parámetros de medidas
tmax = 10;
% tiempo de captura en s
rate =39; % resultado experimental (comprobar)
% preparar la figura
f = figure('Name','Captura');%creamos la figura y le damos nombre y captura
a = axes('XLim',[0 tmax],'YLim',[0 5.1]); % le damos el tamaño aos ejes
l1 = line(nan,nan,'Color','r','LineWidth',2); %nan:trazo nimguno(con nan no
agregamos ningun razo)

xlabel('Tiempo (s)')
ylabel('Voltaje (V)')
title('Captura de voltaje en tiempo real con Arduino')
grid on
hold on % congelamos la pantalla para agregar los puntos

% inicializar
v1 = zeros(1,tmax*rate); % creamos el vector
i = 1;
t = 0;
% ejecutar bucle cronometrado
tic % funcion cronometro tiempo de inicion tiempo de testeo toc
while t<tmax
t = toc; % cronometro aqui calculamos cuanto tiempo demora desde q se
inicion en tic
% leer del puerto serie
a = fscanf(s,'%d')'; % lee la funcion y lo lleva a data texto
v1(i)=a(1)*5/1024;
% dibujar en la figura
x = linspace(0,i/rate,i);
set(l1,'YData',v1(1:i),'XData',x); % con set modificamos las propiedades
dentro del parentesis
drawnow % redibuja lo q cambio
% seguir
i = i+1;
end
% resultado del cronometro

clc;
fprintf('%g s de captura a %g cap/s \n',t,i/t);% cerificamos frecuencia
,#muetras y tiempo

%Limpiar la escena del crimen

fclose(s);
delete(s);
clear s;

ESQUEMA

Ubicación de los componentes en el proto-board

 Ubicación del potenciómetro en lugar del pulsador y la resistencia

PRUEBA

Gráfica voltaje en función al tiempo

 Sketch en arduino

Simulación en tiempo real