Manejo del puerto serial (RS232) con Java

Buen día a todos!!
Acá les traigo un nuevo post, y seguro les interesará..

Se trata de utilizar el puerto serial con Java.

Se trata de un proceso muy pero muy sencillo, construí una clase para hacer este trabajo y voy a explicar el código.

En primer lugar, estoy utilizando el JDK 1.6, con netbeans 6.8.

Bueno, a trabajar.

Para poder hacer esto utilize las librerias para puerto serial GyovinetDriver, que viene siendo un Wrapper para usar el puerto serial tanto en Windows como en Linux.

Bueno, dicho esto, al codigo.

La clase se llama PuertoObj, y vamos con las declaraciones.

Objeto que hace referencia directa al puerto com.
Este objeto es el que enviara los comandos y recibirá las respuestas en el puerto

Com puerto;

Para configurar el puerto com, necesitamos establecer los parámetros de la conexión
en un objeto Parameters.
private Parameters parametros;

La variable formatoCadena y subCadena, reciben string indicando cual es el formato de la cadena recibida por el puerto después de enviar un comando y que parte de la cadena necesitamos regresar con el método LeerDatos de esta clase
Por ejemplo, si el formato que recibiremos por el puerto es SNNNNNNNSKGC puede
que solo nos interese recibir la parte SNNNNNNN que es la que representa el peso(si hablamos de una bascula) Mas adelante están los getters y setters para estas 2 variables.

private String formatoCadena;
private String subCadena;

Esta variable se usa junto con las 2 variables anteriores. En el método LeerDatos
de esta clase, verán de forma mas detallada como funciona.

private int caracterIniciaLectura;

Esta variable toma un valor dependiendo de si queremos regresar todo lo recibimos del puerto o solo la parte que nos interesa. Esto si están configuradas las variables formatoCAdena y subCadena.

private boolean bRegresaCadenaCompleta = false;

Vamos con el codigo en si
Primero un constructor sin parámetros, que lo que hace es inicializar el objeto Parameters

Public PuertoObj() throws Exception
 {
 parametros = new Parameters();
 }

Para poder usar esta clase, debemos pasar toda la información de conexión a ella, para eso utilizamos un método llamado ConfiguraPuerto, que recibie algunos parámetros.
Aquí esta el codigo.

public void ConfiguraPuerto(String nombrePuerto,
 String baudios,
 String paridad,
 String bitsPorCaracter,
 String bitsDeParada) throws Exception{</strong>

parametros.setPort(nombrePuerto);

parametros.setBaudRate(Baud.valueOf(baudios));
 parametros.setParity(paridad);
 parametros.setByteSize(bitsPorCaracter);
 parametros.setStopBits(bitsDeParada);

}

Como pueden ver, este metodo recibe el puerto a utilizar, los baudios, la paridad, etc.
Estos datos son pasados al objeto Parameters que fue inicializado en el constructor de esta clase.

Una vez configurado el puerto, podemos abrirlo, para esto usamos el siguiente metodo.

public void AbrirPuerto() throws Exception
 {
 //Determinal el caracter final de la lectura
 caracterIniciaLectura = 0;
 if(formatoCadena!=null){
 if(subCadena==null)
 subCadena = formatoCadena;</strong>

caracterIniciaLectura = formatoCadena.indexOf(subCadena);
 }else{
 formatoCadena = "";
 bRegresaCadenaCompleta = true;
 }
 try
 {
 if (getFormatoCadena().length()>0){
 //puerto = formatoCadena.length();
 }
 puerto = new Com(parametros);
 }
 catch (Exception ex)
 {
 throw ex;
 }
 }

Este metodo configura a este objeto para que tenga en cuenta la cadena que va a regresar con el metodo LeerDatos, presten especial atención a la linea

puerto = new Com(parametros);

Esta linea es la que realmente abre el puerto, es decir crea una instancia de la clase Com y en el constructor pasa los parámetros que definimos con el método ConfiguraPuerto.

Llegando a este punto en nuestro programa, si todo sale bien, estamos en posición de mandar comandos a nuestro dispositivo, vamos a definir el método que nos ayudara en esta tarea.

public void EscribirDatos(String comando) throws Exception
 {
 try
 {
 puerto.sendArrayChar(comando.toCharArray());
 }
 catch (Exception ex)
 {
 //throw ex;
 }
 }

El objeto puerto, tiene algunas variantes para enviar caracteres al puerto, después de estar probando algunas el método sendArrayChar() es el que me funciono para lo que yo estaba haciendo (Que es conectar con una bascula). Uds pueden probar otros métodos, ya nos contaran qué fue lo que les funcionó.

Volviendo, el método anterior es muy sencillo, solo se le dice que escriba el comando en forma de arreglo de caracteres en el puerto. Cuidado con las excepciones, se debe atrapar o reportar las que se generen.

Ya escrito el comando en el puerto, vamos a leer la respuesta. Esta es otra cosa sencilla, acá va el método que sirve para esta tarea.

public String LeerDatos()
 {
 String dato = "";
 try {
 String dt = puerto.receiveToString(formatoCadena.length());</strong>

//System.out.println("La salida es: "+dt.length());
 if (dt == null || dt.trim().compareTo("")==0) {
 return "No hay datos";
 }
 if (!bRegresaCadenaCompleta) {
 dato = dt.substring(caracterIniciaLectura, subCadena.length());
 } else {
 dato = dt;
 }
 } catch (Exception ex) {
 Logger.getLogger(PuertoObj.class.getName()).log(Level.SEVERE, null, ex);
 }

return dato;

}

La linea mas importante es:

 String dt = puerto.receiveToString(formatoCadena.length());

Observen como le he pasado como parámetro la longitud de la palabra que espero recibir por el puerto. Una vez recibida la palabra, es tratada para devolver solo la parte que le interesa al usuario, ¿recuerdan el uso de las variables formatoCadena, y subCadena? Pues aquí es donde se utilizan.

Para finalizar el ciclo, se debe cerrar el puerto. Aquí esta el metodo.

public void CerrarPuerto()throws Exception{
 try {
 puerto.close();
 } catch (Exception ex) {
 //Logger.getLogger(PuertoObj.class.getName()).log(Level.SEVERE, null, ex);
 throw ex;
 }
 }

Para terminar con el código de nuestra clase, vienen los getter y setters de formatoCadena y subCadena

public String getFormatoCadena() {
 return formatoCadena;
 }

public void setFormatoCadena(String formatoCadena) {
 this.formatoCadena = formatoCadena;
 }

public String getSubCadena() {
 return subCadena;
 }

public void setSubCadena(String subCadena) {
 this.subCadena = subCadena;
 }

Hasta aquí, tenemos nuestra clase terminada.
Sencillo no??

Para lograr que el programa funcione hay que tomar en cuenta algunos detalles.

Primero, descargar el driver para manejo del puerto serial desde java del siguiente link
http://code.google.com/p/giovynetserialport/downloads/list

Al decargar el archivos vienen una serie de carpetas, los archivos importantes son GyovinetDriver.jar y libSerialPort.dll para trabajar con windows.

Segundo, el archivo libSerialPort.dll se debe copiar a la ruta de las librerias donde esta instalado el JDK. En mi caso es C:\Archivos de programa\Java\jdk1.6.0_18\jre\lib.

Y Tercero, se debe agregar la librería GiovinetDriver.jar a nuestro proyecto.

Ahora si, ya tenemos todo listo.. para usar nuestra clase vamos a hacer lo siguiente.:

Incluir el import de nuestra clase; en mi caso queda así:

import Util.PuertoObj;
 public static void main(String[] args) {

PuertoObj puerto = new PuertoObj();

puerto.ConfiguraPuerto(“COM1”,”_9600”,”E”,”8”,”1”);
 puerto.setFormatoCadena(“SNNNNNNNSKGC”);
 puerto.setSubCadena(“SNNNNNNN”);
 puerto.AbrirPuerto();

//En mi bascula, el comando P indica que me envíe el peso actual
 puerto.EscribirDatos(“P”);

//Leemos lo recibido
 System.out.println(“El dato recibido es: ”+puerto.LeerDatos());

//Y cerramos el puerto
 puerto.close();

}

El código del método anterior lo escribí al vuelo, si usas Netbeans o cualquier otro IDE, seguro te va a indicar que debes manejar las excepciones. Ajusta el código para que funcione.

En la linea:

 puerto.ConfiguraPuerto(“COM1”,”_9600”,”E”,”8”,”1”);

observa que el segundo parámetro lo mande así «_9600», eso es porque la clase Baud sabe interpretar los baudios expresados de esa manera(Lo puedes ver en el método ConfiguraPuerto de nuestra clase PuertoObj).

Como ven, manejar el puerto serial desde un programa hecho en Java es muy sencillo, utilizando la librería GyovinetDriver.

Se me olvidaba!!
En nuestra clase PuertoObj, hay un metodo estatico que nos devuelve una lista de tipo String con los puertos seriales instalados en nuestro PC, aqui va el codigo de este metodo.

public static List getPuertosLibres()throws Exception{
 List puertosLibres = null;</strong>

try{
 SerialPort sp = new SerialPort();
 puertosLibres = sp.getFreeSerialPort();
}catch(Exception ex){

throw ex;

}
 return puertosLibres;
 }

Tengo un proyecto de ejemplo funcional, puedes ver más detalles aquí.

Bueno, esto es todo por hoy, espero que este post les sirva de algo y no olviden dejar sus comentarios.
Hasta la proxima.