Comunicación Serial: Enviando datos de Arduino a Java

febrero 13, 2013septiembre 26, 2014 Antony García González 26 Comentarios

La información suministrada en este post es considerada por mi persona como obsoleta debido a que fue publicada antes de mi librería Arduino para Java. Recomiendo visitar el siguiente post donde se explica el uso de la misma y donde es muy fácil comunicar Arduino con Java y vice versa.

***

Hola amigos. En las últimas semanas he estado escribiendo mucho acerca de Arduino, de Java y de como podemos utilizar ambas plataformas para realizar grandes proyectos. Empecé escribiendo como establecer Comunicación Serial con Arduino. Luego escribí como enviar datos de Java a Arduino a través de los métodos ArduinoConnection() y EnviarDatos().

Ahora es tiempo de aprender como recibir datos en Java desde Arduino. Para ello utilizaremos un método similar a EnviarDatos(): RecibirDatos().

Para poder utilizar este método necesitamos modificar nuestra función ArduinoConnection() y declarar algunas variables.

Los datos que enviamos de Arduino a Java se envían a través de una variable OutputStream llamada Output. Ahora declararemos una variable del tipo InputStream llamada Input.

private InputStream Input;

Resumiendo, las variables que necesitamos utilizar para comunicar Arduino y Java, y vice versa, son las siguientes:

private OutputStream Output = null;
private InputStream Input = null;
SerialPort serialPort;
private final String PORT_NAME = "COM3";
private static final int TIME_OUT = 2000;
private static final int DATA_RATE = 9600;

private OutputStream Output = null;

private InputStream Input = null;

SerialPort serialPort;

private final String PORT_NAME = "COM3";

private static final int TIME_OUT = 2000;

private static final int DATA_RATE = 9600;

Ahora necesitamos inicializar la variable Input. Esto se hace en la función ArduinoConnection() donde ya existe una línea que inicializa la variable Output.

public void ArduinoConnection() {

CommPortIdentifier portId = null;
Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();

while (portEnum.hasMoreElements()) {
CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();

if (PORT_NAME.equals(currPortId.getName())) {
portId = currPortId;
break;
}
}

if (portId == null) {

System.exit(ERROR);
return;
}

try {

serialPort = (SerialPort) portId.open(this.getClass().getName(), TIME_OUT);

serialPort.setSerialPortParams(DATA_RATE,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);

Output = serialPort.getOutputStream(); //Se prepara a Output //para enviar datos
Input = serialPort.getInputStream(); //Se prepara input para //recibir datos

serialPort.addEventListener(this); //Se agrega un Event //Listener
serialPort.notifyOnDataAvailable(true); //Se indica que se //notifique al usuario cuando sea que halla datos disponibles en //el puerto serie
} catch (Exception e) {

System.exit(ERROR);
}

}

public void ArduinoConnection() {

CommPortIdentifier portId = null;

Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();

while (portEnum.hasMoreElements()) {

CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();

if (PORT_NAME.equals(currPortId.getName())) {

portId = currPortId;

break;

}

if (portId == null) {

System.exit(ERROR);

return;

}

try {

serialPort = (SerialPort) portId.open(this.getClass().getName(), TIME_OUT);

serialPort.setSerialPortParams(DATA_RATE,

SerialPort.DATABITS_8,

SerialPort.STOPBITS_1,

SerialPort.PARITY_NONE);

Output = serialPort.getOutputStream(); //Se prepara a Output //para enviar datos

Input = serialPort.getInputStream(); //Se prepara input para //recibir datos

serialPort.addEventListener(this); //Se agrega un Event //Listener

serialPort.notifyOnDataAvailable(true); //Se indica que se //notifique al usuario cuando sea que halla datos disponibles en //el puerto serie

} catch (Exception e) {

System.exit(ERROR);

}

Como vemos, se prepara a la variable Input de la misma manera que a la variable Output. Hemos agregado 2 líneas más a nuestra función ArduinoConnection():

serialPort.addEventListener(this); 
serialPort.notifyOnDataAvailable(true);

1 2	serialPort.addEventListener(this); serialPort.notifyOnDataAvailable(true);

Esto permite que se genere un evento cada vez que Arduino envíe datos a Java. Para poder que esto funcione es necesario que implementemos la interfaz SerialPortEventListener de la misma manera que implementamos la interfaz Runnable cuando utilizamos los Java Threads.

Por último necesitamos agregar un método en donde se establezca las acciones que se harán cuando ocurra un SerialPortEvent.

public synchronized void serialEvent(SerialPortEvent oEvent) {
if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
try {
int datos;
datos = RecibirDatos(); //Se invoca la función RecibirDatos()

//Esta función devolverá un valor entero en formato ASCII.
System.out.println((char)datos); //Se imprime en el mensaje

//haciendo la conversión de ASCII a nuestro alfabeto.
} catch (Exception e) {
System.err.println(e.toString());
}
}
}

public synchronized void serialEvent(SerialPortEvent oEvent) {

if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {

try {

int datos;

datos = RecibirDatos(); //Se invoca la función RecibirDatos()

//Esta función devolverá un valor entero en formato ASCII.

System.out.println((char)datos); //Se imprime en el mensaje

//haciendo la conversión de ASCII a nuestro alfabeto.

} catch (Exception e) {

System.err.println(e.toString());

}

Por último agregamos RecibirDatos():

private int RecibirDatos() throws IOException {
int Output = 0;
Output = Input.read();
return Output;
}

private int RecibirDatos() throws IOException {

int Output = 0;

Output = Input.read();

return Output;

}

Con estas variables y estos métodos podemos lograr lo que queremos. Ahora es tiempo de probar si funciona o no.

Yo agregué los elementos necesarios al ejemplo Blink que ya hicimos:

Ahora vamos a Arduino y escribimos lo siguiente:

int count=0;
void setup(){
Serial.begin(9600);
}

void loop(){
Serial.print(count);
count++;
delay(1000);
}

int count=0;

void setup(){

Serial.begin(9600);

}

void loop(){

Serial.print(count);

count++;

delay(1000);

}

Con estos cambios estamos listos para ver como trabaja nuestro código. Lo que haremos es enviar el valor de una variable, en este caso, count, de Arduino a Java, con la salvedad de que cada segundo se aumentará el valor de count en 1 unidad.

Utilizamos Serial.print para enviar el mensaje. Si utilizamos println enviaremos el mensaje con un salto de renglón. Si utilizamos Serial.write, entonces no enviaremos el mensaje en ASCII sino como bits. El problema con esto es que es un bus de 8 bits, por lo que no podremos enviar valores más arriba del 255, ya que 2 elevado a la octava potencia es 256 y el bus solo admite 8 bits, del 0 al 255.

Aquí vemos la demostración:

Como podemos observar los datos se envían 1 a 1, es decir, caracter a caracter.

Espero sus comentarios. Saludos.

Java + Arduino: Encendiendo un LED RGB desde un programa en nuestra PC

febrero 5, 2013septiembre 26, 2014 Antony García González 4 Comentarios

El siguiente post pretende ser un ejemplo básico del control de los colores de un LED RGB, a partir del cual se espera obtener 7 diferentes tonalidades de colores. El control se lleva a cabo desde una aplicación en Java.

Un LED RGB es un tipo especial de LEDs que se caracteriza por ser capaz de generar luz en diferentes tonalidades.

Poseen 4 patas, 3 ánodos y un cátodo. Al inducir una corriente entre uno de los ánodos y el cátodo, se producirá un color diferente. Se le dice RGB por que sus colores primarios son el rojo (Red), verde(Green) y el azul(Blue).

Combinando dichos colores obtendremos otras tonalidades.

En informática se utiliza mucho el RGB como principio básico para la creación de tonalidades. Si utilizamos un editor básico, como el Pain de Windows, podemos observar lo que sucede con los valores RGB. Dichos valores se extienden del 0 al 255. Nosotros con un LED RGB solo podemos tolerar 2 valores, el máximo y el mínimo, es decir, el 0 y el 255.

Si le damos un valor de 255 al ánodo R, es decir, si colocamos 5 voltios en la pata R del LED, obtendremos lo siguente:

Podemos despreciar los valores de las casillas Matiz, Sat y Lum. Concentrémonos en las casillas Rojo, Verde y Azul. El valor 255 representa 5 voltios en la pata R, lo que devuelve un color rojo. Si hacemos lo mismo con las casillas Verde y Azul obtendremos otras tonalidades.

A lo último podemos observar que si colocamos los valores máximos en las 3 casillas obtendremos el blanco; si colocamos los valores mínimos en las 3 casillas, osea 0, obtenemos el color negro, que no es más que un LED apagado por ausencia de voltaje entre el cátodo y cualquiera de los 3 ánodos.

Podríamos formar el Celeste si probamos con 255 Verde y 255 Azul, pero la verdad no se aprecia mucho la diferencia así que decidí excluirlo de este ejemplo.

Ahora procedemos a crear una interfaz para nuestro programa con el que vamos a encender los colores del LED.

Primero vamos a Netbeans IDE y creamos un proyecto. En mi caso yo lo llamé RGB. Insertamos un jFrame y colocamos los siguientes botones:

En caso de que usted no sepa hacer esto, puede visitar el tutorial Cómo crear nuestro primer programa en Java con NetBeans.

Ahora que hemos insertado nuestros botones, le asignaremos un nombre a cada uno. Para ello, le damos clic derecho en el botón cuyo nombre deseamos cambiar y vamos a la opción “Change Variable Name”.

Le damos clic y colocamos el nombre con el siguiente formato: jButton_nombre del botón.

Repetimos el proceso para todos y cada uno de los botones. Al final, en la parte izquierda de nuestro NetBeans IDE podremos visualizar todos los botones con sus respectivos nombres.

Ahora es tiempo de proceder a implementar la función ArduinoConnection() y EnviarDatos().

Agregamos lo siguiente a nuestro código en Java:

private OutputStream Output = null;
SerialPort serialPort;
private final String PORT_NAME = “COM3″;
private static final int TIME_OUT = 2000;
private static final int DATA_RATE = 9600;

public void ArduinoConnection() {

CommPortIdentifier portId = null;
Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();

while (portEnum.hasMoreElements()) {
CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();

if (PORT_NAME.equals(currPortId.getName())) {
portId = currPortId;
break;
}
}

if (portId == null) {

System.exit(ERROR);
return;
}

try {

serialPort = (SerialPort) portId.open(this.getClass().getName(), TIME_OUT);

serialPort.setSerialPortParams(DATA_RATE,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);

Output = serialPort.getOutputStream();

} catch (Exception e) {

System.exit(ERROR);
}

}

private void EnviarDatos(String data) {

try {
Output.write(data.getBytes());

} catch (IOException e) {

System.exit(ERROR);
}
}

private OutputStream Output = null;

SerialPort serialPort;

private final String PORT_NAME = “COM3″;

private static final int TIME_OUT = 2000;

private static final int DATA_RATE = 9600;

public void ArduinoConnection() {

CommPortIdentifier portId = null;

Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();

while (portEnum.hasMoreElements()) {

CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();

if (PORT_NAME.equals(currPortId.getName())) {

portId = currPortId;

break;

}

if (portId == null) {

System.exit(ERROR);

return;

}

try {

serialPort = (SerialPort) portId.open(this.getClass().getName(), TIME_OUT);

serialPort.setSerialPortParams(DATA_RATE,

SerialPort.DATABITS_8,

SerialPort.STOPBITS_1,

SerialPort.PARITY_NONE);

Output = serialPort.getOutputStream();

} catch (Exception e) {

System.exit(ERROR);

}

private void EnviarDatos(String data) {

try {

Output.write(data.getBytes());

} catch (IOException e) {

System.exit(ERROR);

}

También recuerden agregar la librería RXTXComm y los siguientes imports:

import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Enumeration;

import gnu.io.CommPortIdentifier;

import gnu.io.SerialPort;

import java.io.IOException;

import java.io.OutputStream;

import java.util.Enumeration;

Con esto debería trabajar nuestro software a la par de Arduino. Ahora programemos los botones:

Para la comunicación serial entre Arduino y Java utilizaremos el siguiente código:

0 – Apaga el LED (Botón OFF)

1 – Enciende el rojo

2 – Enciende el verde

3 – Enciende el azul

4 – Enciende el morado

5 – Enciende el amarillo

6 – Enciende el blanco

Con esta sencilla configuración, procedemos a implementar el método EnviarDatos() en cada uno de los botones.

No olviden agregar la línea ArduinConnection(); luego de initComponents() en la función que inicia el programa. Si no lo hacen, Arduino y Java no se comunicarán.

Con esto quedamos listos en Java y procedemos a programar en Arduino. Aquí les dejo el código:

int pinR=10; //pin para el color rojo
int pinG=11; //pin para el color verde
int pinB=12; //pin para el color azul
int Input_Data=0;
void setup(){
Serial.begin(9600);
pinMode(pinR,OUTPUT);
pinMode(pinG,OUTPUT);
pinMode(pinB,OUTPUT);
}

void loop(){
if (Serial.available()>0){
Input_Data=Serial.read(); //Leemos los datos que Java nos //envía
LED(Input_Data); //Llamamos la función que encenderá los //colores
}
}

void LED(int input){ //Esta función encenderá los colores que el //usuario decida desde Java. El parámetro input lo proporciona //el usuario a través de los botones en Java.

switch(input){  //La estructura especial switch nos permite //evaluar una variable en sus diferentes valores. Se utilizan los //case que son condiciones. "En el caso que la variable sea '0', //apagar el LED". En el caso que sea '1', encender el rojo. Y Así //sucesivamente.
case '0': 
digitalWrite(pinR,LOW);
digitalWrite(pinG,LOW);
digitalWrite(pinB,LOW);
break; //Un break se requiere al final de cada case.
case '1':
digitalWrite(pinR,HIGH);
digitalWrite(pinG,LOW);
digitalWrite(pinB,LOW);
break;
case '2':
digitalWrite(pinR,LOW);
digitalWrite(pinG,HIGH);
digitalWrite(pinB,LOW);
break;
case '3':
digitalWrite(pinR,LOW);
digitalWrite(pinG,LOW);
digitalWrite(pinB,HIGH);
break;
case '4':
digitalWrite(pinR,HIGH);
digitalWrite(pinG,LOW);
digitalWrite(pinB,HIGH);
break;
case '5':
digitalWrite(pinR,HIGH);
digitalWrite(pinG,HIGH);
digitalWrite(pinB,LOW);
break;
case '6':
digitalWrite(pinR,HIGH);
digitalWrite(pinG,HIGH);
digitalWrite(pinB,HIGH);
break;
}
}

int pinR=10; //pin para el color rojo

int pinG=11; //pin para el color verde

int pinB=12; //pin para el color azul

int Input_Data=0;

void setup(){

Serial.begin(9600);

pinMode(pinR,OUTPUT);

pinMode(pinG,OUTPUT);

pinMode(pinB,OUTPUT);

}

void loop(){

if (Serial.available()>0){

Input_Data=Serial.read(); //Leemos los datos que Java nos //envía

LED(Input_Data); //Llamamos la función que encenderá los //colores

}

void LED(int input){ //Esta función encenderá los colores que el //usuario decida desde Java. El parámetro input lo proporciona //el usuario a través de los botones en Java.

switch(input){ //La estructura especial switch nos permite //evaluar una variable en sus diferentes valores. Se utilizan los //case que son condiciones. "En el caso que la variable sea '0', //apagar el LED". En el caso que sea '1', encender el rojo. Y Así //sucesivamente.

case '0':

digitalWrite(pinR,LOW);

digitalWrite(pinG,LOW);

digitalWrite(pinB,LOW);

break; //Un break se requiere al final de cada case.

case '1':

digitalWrite(pinR,HIGH);

digitalWrite(pinG,LOW);

digitalWrite(pinB,LOW);

break;

case '2':

digitalWrite(pinR,LOW);

digitalWrite(pinG,HIGH);

digitalWrite(pinB,LOW);

break;

case '3':

digitalWrite(pinR,LOW);

digitalWrite(pinG,LOW);

digitalWrite(pinB,HIGH);

break;

case '4':

digitalWrite(pinR,HIGH);

digitalWrite(pinG,LOW);

digitalWrite(pinB,HIGH);

break;

case '5':

digitalWrite(pinR,HIGH);

digitalWrite(pinG,HIGH);

digitalWrite(pinB,LOW);

break;

case '6':

digitalWrite(pinR,HIGH);

digitalWrite(pinG,HIGH);

digitalWrite(pinB,HIGH);

break;

}

Subiendo este código a Arduino podremos interpretar los datos enviados por Java.

Ahora es tiempo de armar el circuito. Necesitaremos un LED RGB y 3 resistencias de un valor que esté entre 220 y 360 Ohm. Yo utilizo 330 para trabajar con 9 voltios, pero aún así funciona bien con los 5 voltios de Arduino. Ahora necesitamos identificar el cátodo y los ánodos. Miramos en el interior del LED y la pata que sea mas gruesa que las otras 3 será el cátodo. Generalmente es el segundo de izquierda a derecha o el tercero de derecha a izquierda.

Procedemos a colocarlo en un ProtoBoard. Introducimos el LED RGB y colocamos una resistencia en cada ánodo.

Una buena práctica que podemos realizar es identificar los colores del LED RGB. Conectaremos el cátodo al GND de Arduino y utilizando un jumper, conectaremos un extremo en los 5V y el otro extremo en alguna de las resistencias para ver que color se produce.

Cuando hallamos probado que todos los colores encienden, conectamos el ánodo R en el pin 10, el ánodo G en el pin 11 y el B en el pin 12. Esto lo establecimos en el código que escribimos para Arduino.

Una vez hecho esto, con nuestro microcontrolador conectado a la PC mediante USB y el código cargado, procedemos a iniciar la aplicación que construimos en Arduini IDE.

Si todo está en orden y no se produce ningún error, obtendremos los siguientes resultados:

Espero sus comentarios. Saludos.

Proyecto con Arduino y Java: Grúa Magnética

febrero 4, 2013julio 30, 2014 Antony García González Deja un comentario

Hola amigos. Les estoy presentando este proyecto que preparé el semestre pasado en la universidad. En él utilizo Arduino y Java como medios para controlar una grúa magnética.

Aquí les dejo el informe que presenté con todos los detalles del proyecto.

http://es.scribd.com/doc/115632708/Arduino-Java-Controlando-un-cabezal-de-impresion

Aquí está el PDF en Google Drive:

https://docs.google.com/folder/d/0B0hsUkhqWH97elQtOU42aTlHTGc/edit?usp=sharing

Programando Arduino con Java

Comunicación Serial: Enviando datos de Arduino a Java

La información suministrada en este post es considerada por mi persona como obsoleta debido a que fue publicada antes de mi librería Arduino para Java. Recomiendo visitar el siguiente post donde se explica el uso de la misma y donde es muy fácil comunicar Arduino con Java y vice versa.

Java + Arduino: Encendiendo un LED RGB desde un programa en nuestra PC

El siguiente post pretende ser un ejemplo básico del control de los colores de un LED RGB, a partir del cual se espera obtener 7 diferentes tonalidades de colores. El control se lleva a cabo desde una aplicación en Java.

Proyecto con Arduino y Java: Grúa Magnética

¡¡Visítanos!!

Mantente en contacto a través de nuestras redes sociales. Visítanos aquí también.