Conectado Java con Arduino

En esta entrada veremos como conectar nuestro arduino con nuestros programas en java mediante comunicación serial, para ello primero debemos configurar ciertas cosas en nuestro equipo. Comencemos...

Configurando Java

Para escribir nuestro programa en JAVA haremos uso de una IDE, en esta ocación usaremos Eclipse, (Si quieres descargarlo haz clic AQUI ), ademas para utilizar la comunicación serial necesitaremos una librería externa ya que por defecto java no tiene una propia, por ello utilizaremos la librería RXTX la cual podemos descargar desde su misma pagina. 

(Haz clic en la imagen para acceder a la pagina de descarga)

En esta pagina descargamos la librería desde la sección de Pre Built Binaries haciendo clic sobre rxtx-2.2pre-bins.zip en Binary

(Encerrado en rojo el enlace de descarga)

Se nos descarga un archivo .rar lo descomprimimos y ahora abrimos el eclipse. Creamos un nuevo proyecto y vamos a la carpeta que acabamos de descargar, entramos en la carpeta Win32 o Win64 dependiendo de nuestro sistema operativo y copiamos el archivo rxtxSerial.dll a nuestro proyecto en eclipse. 

(Copiamos de la carpeta Win64 a nuestro proyecto en Java)

A continuación damos clic derecho sobre nuestro proyecto y damos en Build Path y seleccionamos Add External Archives, ahora seleccionamos el archivo rxtxSerial.dll de la carpeta que descargamos.

(Al hacer clic en External Archives seleccionamos el archivo RXTXcomm.jar)

Con este terminamos de configurar el Eclipse, ahora podemos comenzar a escribir nuestro programa  en java pero primero vamos a programar nuestro arduino.

Escribiendo nuestro programa en arduino

Para programar nuestro arduino primero necesitaremos descargar el IDE oficial en su pagina, el cual puedes descargar AQUI, 

Después de instalar el IDE lo abrimos y haremos un programa simple, con el cual leeremos y escribiremos un carácter por el puerto serial de nuestro arduino, el código es el siguiente:

void setup() {
	pinMode(13,INPUT);
	Serial.begin(9600);
}

int f = 0

void loop() {
  char c;
  while(f == 0){
    c = Serial.read();
    if(c == 'A'){
      Serial.write('B');
      f=1;
    }else{
      Serial.write('Z');
    }
    delay(500);
  }
}

Como se ve en el código el arduino constantemente se encuentra escuchando por el puerto serial y enviando una 'Z' por el mismo pero si recibe el carácter 'A' entonces responderá enviando 'B' terminando el envió de datos por el puerto serial. Dicho proceso lo conectaremos con nuestra pc mediante el programa que realizaremos en java.

Finalmente comprobamos dando click en el botón de check, conectamos nuestro arduino a la pc y subimos nuestra programación al arduino dando clic en el botón de flecha, en caso de ocurrir una falla al subir el programa revisemos que el puerto com este configurado, para ello damos clic en Herramientas > Puerto y seleccionamos el puerto de nuestro arduino como se muestra en la siguiente imagen.

Ahora continuemos con el programa en java

Escribiendo nuestro programa en Java

Abrimos nuevamente el eclipse y empezamos con la programación de nuestro programa en el proyecto que ya hemos configurado. La programación que haremos esta basada en los ejemplos proporcionados por los autores de la librería RXTX la cual puedes consultar en su pagina oficial en el apartado de usage.

Primero escribamos el código para buscar dispositivos con comunicación serial activa, en nuestro caso el arduino.

public String encontrarArduino(){
	// Creamos la variable numPuerto para almacenar los puertos encontrados	
	Enumeration numPuerto = CommPortIdentifier.getPortIdentifiers();

	//Ejecutamos un ciclo while mientras numPuerto tenga elementos
	while ( numPuerto.hasMoreElements() ) {
		CommPortIdentifier puertoId = (CommPortIdentifier) numPuerto.nextElement();
		//Imprimimos los puertos disponibles encontrados
		System.out.println(puertoId.getName());
    }
    
    return 
       
}

Ahora escribimos el codigo para leer y escribir datos por el puerto serial.

public void conectar(String portName) throws Exception{
	//
	CommPortIdentifier puertoId = CommPortIdentifier.getPortIdentifier(portName);
    
    //Verificamos si el puerto esta disponible
	if ( puertoId.isCurrentlyOwned() )
		System.out.println("Error: El puerto esta ocupado");
	else{
    	//Abrimos el puero
		CommPort commPort = puertoId.open(this.getClass().getName(),2000);
        
        //Verificamos que el puerto disponible sea serial 
		if (commPort instanceof SerialPort){
			SerialPort puertoSerial = (SerialPort) commPort;
            //Especificamos los parametros del puerto serial
			puertoSerial.setSerialPortParams(9600,SerialPort.DATABITS_8,SerialPort.STOPBITS_1,SerialPort.PARITY_NONE);
            
            //Abrimos los canales de entrada y salida    
			in = puertoSerial.getInputStream();
			out = puertoSerial.getOutputStream();
            
 			//Ejecutamos los hilos de lectura y escritura
			(new Thread(new SerialReader(in))).start();
			(new Thread(new SerialWriter(out))).start();
		}else
			System.out.println("Error: Solo es admitido puerto serial.");
	}     
}

//Hilo de lectura serial
public class SerialReader implements Runnable{
	InputStream in;
		
	public SerialReader ( InputStream in ){
		this.in = in;
	}
	        
	public void run (){
		byte[] buffer = new byte[1024];
		int len = -1;
		try{
        	//Ejecutamos un while para imprimir los datos leidos por el puerto serial
			while ( ( len = this.in.read(buffer)) > -1 ){
              String temp = new String(buffer,0,len);
              System.out.print(temp);   				
			}
		}catch (IOException e){
			e.printStackTrace();
		}            
	}
}

//Hilo de escritura serial
public class SerialWriter implements Runnable{
	OutputStream out;
	        
	public SerialWriter (OutputStream out){
		this.out = out;
	}
	        
	public void run (){
		try{                
			int c = 0;
			while ( ( c = System.in.read()) > -1 ){
				this.out.write(c);
			}                
		}catch ( IOException e){
			e.printStackTrace();
		}            
	}
}

Finalmente escribamos el método main para ejecutar nuestro programa:

public static void main(String[] args) {
	serial s = new serial();
	String p = s.encontrarArduino();
		
	try {
		s.conectar(p);
	}catch(Exception e) {
		System.err.print(e);
	}
}

Ahora ejecutamos nuestro programa dando clic en el boton de play y obtendremos una respuesta como la siguiente:

Como se ve en la imagen primero se nos imprime el puerto serial al cual esta conectado nuestro arduino, luego empieza a imprimir la letra 'Z' hasta que escribimos una 'A' y termina el arduino de enviarnos data con una letra 'B'. Ahora terminamos el programa en java dando clic en el cuadrado rojo.

Como vemos este es un programa muy simple para comunicar nuestro programa con java mediante el puerto serial, lo que sigue sera hacer una interfaz de usuario para interactuar con el arduino. El cual lo  veremos próximamente.

Haz click aqui para hacer la interfaz gráfica de un alcoholimetro con arduino u java