Communication Matlab and Arduino (9600 Bps) Xbee Modules

Hi Guys, in this post i talk about the problems in the connection between Matlab and Arduino for to control any device or sensor or whatever.

step one, if you have problems with 115200 bps or you think that you dont need that data transfer rate it is a great help for u. Giampiere Campa make a awesome library for communication Matlab-Arduino and that library is Adiosrv.pde for arduino and arduino.m and install_arudino.m.

so, you need to program again your devices with 9600 bps, example for arduino

https://mega.co.nz/#!7QZyBQTJ!DXhHD-a34tfvbiJ6Y_TjVb4vqcFgSorgcJJWptHAJO8

File Arduino Modified.

step two, open Matlab ide and move this files to C:\Users\pc\Documents\MATLAB

install_arduino.m and arduino.m 

https://mega.co.nz/#!XEhA1DqI!sSwKOrlnlxcaJieVmYyQW4TWfxVDVWMuXiGlaGFQxDY

https://mega.co.nz/#!7QZyBQTJ!DXhHD-a34tfvbiJ6Y_TjVb4vqcFgSorgcJJWptHAJO8

i have modified this files so no problem data transfer rate, please dont try modified it.

step three, clic on install_arduino.m and then run

please check that, in your command window :D

step four, clic on arduino.m 

if all right, your communication is ok, else sure it is a cause of the arduino programation i want to say, adiosrv.pde because if u have for example programed your arduino to 115200 and as i modified the library sure no conection. SO PLEASE CHECK that ALL DEVICES ARE IN 9600 BPS :)

step 6. now u can make anything my bro :)

PLEASE IF U NEED MORE HELP, PLEASE COMMENT!!

Tutorial 2. ARDUINO UNO + INTERFAZ MATLAB

Para conectar la tarjeta Arduino UNO, como si fuera una tarjeta de interface 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 la misma. 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 que 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 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 10232
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.

Tutorial 1. COMUNICACIÓN CON ARDUINO SIN MATLAB

Es posible controlar la tarjeta Arduino sin necesidad de tener instalado Matlab. Si se cuenta
con un programa que pueda establecer comunicación serial con el puerto que la tarjeta Arduino
establece. Por ejemplo, hyperterminal para Windows 7 (Se puede descargar).
Para que se pueda establecer comunicación, de esta forma, tiene que cargarse el archivo
“adiosrv.pde” en la tarjeta, desde el IDE ARDUINO. Este archivo es uno de los tantos que
viene en el comprimido “ArduinoIO.zip”1 (Lea el tutorial: Intrucciones para Instalar Arduino con
Matlab)

FORMATO DE INSTRUCCIÓN

El programa “adiosrv” cargado en la memoria de la tarjeta, está configurado para enviar y
recibir datos. Las instrucciones que recibe desde el programa que interactúa con la tarjeta,
tiene 3 caracteres típicos, de la forma:

XyZ

X: Número o letra mayúscula indicando la acción. Las acciones pueden ser:

0: Asignar pin digital como entrada o salida, depende del tercer caracter.

1: Lee estado de pin digital especificado en el 2 caracter.

2: Pone el pin digital especificado en el segundo caracter en estado alto o en estado

bajo de acuerdo al valor del tercer caracter ( 1 en alto, 0 en bajo). Para que funcione,

la salida digital debe haber sido configurada como tal.

3: Lee valor en de entrada análoga especificada en 2 caracter

4: Configura salida digital como análoga PWM, especificada en 2 caracter, en un valor

que va de 0 a 255, indicado por el tercer caracter en código ASCII.

y: Letra minúscula indicando el número del pin. Los pines de la tarjeta Arduino están

numerados del 0 al 13 para las terminales digitales. Las terminales de entrada análoga del A0

al A5. El segundo caracter “y” es una minúscula de la “a” a la “n”, de tal forma que:

a = 0,
b = 1,
c = 2,
d = 3,
e = 4,
f = 5,
g = 6,
h = 7
i = 8,
j = 9,
k = 10,
l = 11,
m = 12,
n = 13.
Las letras a a f pueden corresponder tanto al pin digital como al análogo y para determinar cual
se usa (b para pin digital 1 o entrada análoga A1, depende la función implicada por el primer
caracter)
Z: Número o letra indicando el valor a ser transmitido.

CONFIGURACIÓN DE PIN DIGITAL

Un pin digital puede configurarse como entrada o como salida. Si está configurado como salida,
puede suministrar a una carga conectada a él, un voltaje de 5 voltios (HIGH) o de 0 voltios
(LOW), siempre que dicha carga, no exceda el consumo de corriente máximo que la tarjeta
Arduino puede proporcionar. Si el pin digital, sirve como entrada, puede recibir voltajes de 0 ó 5
voltios, unicamente.

Ejemplo 1:
Para poner el pin 13 como salida y encender el led que viene conectado a él:
0n1 % Configura el pin 13(n) como salida
2n1 % Pone el pin 13(n) en estado alto
Se puede establecer comunicación serial por Matlab, si los archivos “arduino.m” y
“install_arduino” no funcionan en la versión de Matlab que se esté utilizando. Se pueden utilizar
las funciones: “serial(‘port’)”, “fopen(obj)”, “fscanf(obj, format)” y “fprintf(obj, ‘cmd’)”
En primer lugar desde Matlab, los comandos para acceder al puerto serie que utiliza Arduino:

El primer comando, borra cualquier objeto previo adjunto al puerto serie COM3, en este caso
particular. El segundo comando, permite crear un nuevo objeto que contiene todos los atributos
y procedimientos para acceder al puerto serie COM3.
A continuación, se abre el puerto para acceder a sus datos:

Para otros programas, deberán existir formas diferentes o similares de configurar el acceso
al puerto que tiene Arduino. En Matlab, la escritura en un pin, como salida digital tiene los
los anteriores pasos, los ultimos comandos, permiten configurar el pin 13 de la tarjeta, como salida y ponerlo en estado bajo con lo que se apagará el led.

Análisis de Temperatura Matlab con Arduino

http://elagmecatronica.blogspot.com/2012/09/control-de-temperatura-con-lm35-arduino.html

En la anterior entrada, se hizo el ejemplo de la comunicación del arduino con el entorno de Matlab. debido a algunos problema me he tomado a la tarea de publicar ese código para que comprendan mejor su desarrollo. cabe aclarar que este código nos sirve para una gran cantidad de cosas, no solo mediciones de temperatura si no también como la humedad, niveles de gases, análisis de ph en otros.

La mayoría de las veces es necesario adquirir los datos de una variable durante un determinado

tiempo. Para empezar, vamos a manejar instrucciones de control para adquirir un determinado número de muestras. Por ejemplo. Guardar 100 lecturas de temperatura en un vector que llamaremos T.

Si se necesita una serie de tiempo, es decir, se quiere obtener datos de una variable respecto al tiempo, es necesario, incluir comando para generar valores de tiempo. Para eso se utiliza la instrucción “tic” combinada con “toc”

El formato es:

tic  %Comienza el conteo en un temporizador interno

toc %Detiene el temporizador

Por ejemplo

En este caso, la variable “t_total” indica el tiempo total de adquisición de datos.

Si se quiere generar un valor de tiempo para cada valor de la variable medida:

Puede ser deseable que el usuario pueda seleccionar, en vez del número de muestras, el tiempo de lectura y la separación entre muestras. Para poder introducir valores en tiempo de ejecución, se utiliza el comando “input(‘Texto a mostrar’)” con lo que en pantalla aparece el cursor a la espera de lo que el usuario digite:

Es decir, el valor ingresado por el usuario, puede asignarse a una variable que se utilice para configurar el tiempo entre muestras y el tiempo total que dure la adquisición de datos.

Finalmente, se puede crear una condición que no dependa de que se completen las muestras sino, de que se cumpla el tiempo total de medición. La sentencia “while(condición)” es la que permite realizarlo:

si tiene en claro todo lo anteriormente dicho(recomendación, entender muy bien lo que se hace en cada paso debido a que es un código sucesivo) el código final quedara así.

espero resolver dudas y no generar mas XD... cualquier duda acerca del código, me dejan un comentario y estaré pendiente

Comunicación Serie Ente Java y Arduino

Hoy veremos como realizar una comunicación serie entre el IDE Netbeans y Arduino. para la realizar de forma adecuada nuestro proyecto, tenemos que tener en cuenta la librería de conexión o comunicación entre estos dos entornos de programación, es una librería muy conocida llamada RXTX, Esta librería reemplazo a las extensiones API que anteriormente existían otra cosa que debemos tener muy en cuenta es que nosotros tenemos que ajustar la dirección del puerto COM de nuestra tarjeta arduino que en ese momento estemos utilizando para mi caso es el "COM36".

 Nuestro primer paso es el de llamar, incluir o agregar nuestra librería RXTX a nuestro IDE(Netbeans). después de haber descargado y descomprimido la librería, abrimos Netbeans Creamos un nuevo proyecto después de esto vamos a las propiedades de este, luego le damos clic en librerías, y por el momento le podemos dar clic en add/jar/folder y seleccionamos la librería RXTXcomm. La otra forma es agregando una librería para que cuando necesitemos esa misma librería no tengamos que hacer el paso anterior si no seleccionarla de las librerías principales de java.

el segundo paso para la comunicación es la configuración de arduino, para ello abrimos el entorno de programación de arduino,  y pegamos el siguiente código:

z

void setup () {
  Serial.begin (9600);  // Velocidad en la transferencia de los datos 9600 bauds
}

void loop () {
  Serial.println ("Hola mundo");  // imprimimos en el serial 
  delay (1000);         // hacemos un retardo de 1 segundo
}

el tercer paso es configurar el IDE de java o nuestro condigo principal para ello arduino nos brinda un código el cual es el mas básico para verificar la comunicación entre java y arduino que es el siguiente:

import java.io.InputStream;   //importamos las librerias
import java.io.OutputStream;
import gnu.io.CommPortIdentifier; 
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent; 
import gnu.io.SerialPortEventListener; 
import java.util.Enumeration;

public class SerialTest implements SerialPortEventListener {
 SerialPort serialPort;
        /** The port we're normally going to use. */
 private static final String PORT_NAMES[] = {  
//  muy importante esta parte ya que muchas personas se pierden en este paso y no// se realiza la comunicación como queremos podemos borrar las demas opciones dep//endiendo de cual sistemas operativo tengamos para mi caso solo dejo la de wind//ows y coloco "COM36".
   "/dev/tty.usbserial-A9007UX1", // Mac OS X
   "/dev/ttyUSB0", // Linux
   "COM3", // Windows
   };
 /** Buffered input stream from the port */
 private InputStream input;
 /** The output stream to the port */
 private OutputStream output;
 /** Milliseconds to block while waiting for port open */
 private static final int TIME_OUT = 2000;
 /** Default bits per second for COM port. */
 private static final int DATA_RATE = 9600; 
//velocidad de transferencia de datos y tiene q coincidir con la que tenemos con //arduino de lo contrario no se establece la comunicación.

 public void initialize() {
  CommPortIdentifier portId = null;
  Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();

  // iterate through, looking for the port
  while (portEnum.hasMoreElements()) {
   CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();
   for (String portName : PORT_NAMES) {
    if (currPortId.getName().equals(portName)) {
     portId = currPortId;
     break;
    }
   }
  }

  if (portId == null) {
   System.out.println("Could not find COM port.");
// en caso de arrojarnos could no find COM port debemos revisar la direccion del //puerto.
   return;
  }

  try {
   // open serial port, and use class name for the appName.
   serialPort = (SerialPort) portId.open(this.getClass().getName(),
     TIME_OUT);

   // set port parameters
   serialPort.setSerialPortParams(DATA_RATE,
     SerialPort.DATABITS_8,
     SerialPort.STOPBITS_1,
     SerialPort.PARITY_NONE);

   // open the streams
   input = serialPort.getInputStream();
   output = serialPort.getOutputStream();

   // add event listeners
   serialPort.addEventListener(this);
   serialPort.notifyOnDataAvailable(true);
  } catch (Exception e) {
   System.err.println(e.toString());
  }
 }

 /**
  * This should be called when you stop using the port.
  * This will prevent port locking on platforms like Linux.
  */
 public synchronized void close() {
  if (serialPort != null) {
   serialPort.removeEventListener();
   serialPort.close();
  }
 }

 /**
  * Handle an event on the serial port. Read the data and print it.
  */
 public synchronized void serialEvent(SerialPortEvent oEvent) {
  if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
   try {
    int available = input.available();
    byte chunk[] = new byte[available];
    input.read(chunk, 0, available);

    // Displayed results are codepage dependent
    System.out.print(new String(chunk));
   } catch (Exception e) {
    System.err.println(e.toString());
   }
  }
  // Ignore all the other eventTypes, but you should consider the other ones.
 }

 public static void main(String[] args) throws Exception {
  SerialTest main = new SerialTest();
  main.initialize();
  System.out.println("Started");
//Si todo la anterior esta bien entonces nos debe imprimir que el puerto esta ini//ciado y nos debe imprimir lo que tiene el arduio en el puerto seria osea el Hol//a Mundo
 }
}



para mas información visitar la pagina de arduino http://arduino.cc/playground/Interfacing/Java.

en internet se encuentra varios ejemplos de interactuar arduino y java de los cuales tome uno para hacer la prueba o verificación de esto en este caso realice la prueba del siguiente vídeo que encontré en internet:













cualquier duda me la hacen saber a través del los comentarios.

Control de Temperatura con Lm35 - Arduino y Matlab

Control y Graficacion de Temperatura (Lm35) Arduino Con Matlab

Materiales:

• Sensor Lm35
• Bombilla 75 Watts
• Placa de desarrollo Arduino
• Ide Matlab y Arduino

A continuación se muestra un pequeño proyecto de control de temperatura empleando un sensor de temperatura, Utilizando Arduino junto con Matlab.

El Circuito:

Como se puede medio-ver tenemos una bombilla conectada a corriente alterna para este caso fue de 122 V , debido a la potencia, la bombilla disipa calor al enfrentar nuestro sensor a ciertas distancias podemos obtener diferentes curvas de control, el pin de la mitad del Lm35 va conectado a la tarjeta arduino(como se va a trabajar con matlab debemos tener cuidado en que entrada vamos a conectarla para después no tener errores), el pin positivo a 5 v de la misma tarjeta y la tierra.
Materiales:

• Sensor Lm35
• Bombilla 75 Watts
• Placa de desarrollo Arduino
• Ide Matlab y Arduino

Montaje:

Código en Arduino:

Este Programa, lo verificamos y lo cargamos en la placa arduino, y cerramos el entorno de programación para centrarnos en matlab.(Para mas ayuda en los códigos de matlab y arduino me dejan su correo en los comentarios o me envían un correo a elalvarez@uniboyaca.edu.co)

Codigo en Matlab:

Bueno eso es todo, una pequeña aplicacion de gran ayuda para las personas que empiezan a trabajar arduino con los demas lenguajes de programacion ya sea de java, processing, labview, matlab entre otros.

finalmente, estas imágenes(No son de buena calidad pero se hizo todo lo posible):

Quedan muchas dudas, pero este blog se hizo para eso para tratar de responder las dudas que se tengan con esta pequeña aplicacion...