// Archivo JAVA: Configuracion_JAVA_μCtrol_RXTX_library.JAVA
import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import java.io.BufferedReader;
//import java.io.IOException;
//import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.Enumeration;
import javax.swing.JOptionPane;
/**
*
* @author compsystems
*/
public class Configuracion_JAVA_uCtrol_RXTX_library implements SerialPortEventListener {
// Id puertoSerial para inicializar el puerto serial
SerialPort puertoSerial; // requiere agregar: import gnu.io.SerialPort;
/**
* Lista de los puertos donde normalmente se va a conectar el μControlador.
*/
private String NOMBRES_DE_PUERTOS
[] = { "", //"COMx", // WindowsOS, Ver Administrador de Dispositivos Puertos COM, por ejp μControlador x conectado en COM3
//"/dev/tty.usbserial-A9007UX1", // MacOS-X
//"/dev/ttyACM0", // RaspberryPI
//"/dev/ttyUSB0", // LinuxOS
};
/**
* Streams
*/
// OutputStream es una clase abstracta de la que no pueden crearse objetos. No obstante,
// todos los objetos que se creen de clases derivadas dispondrán de algunas operaciones interesantes:
// que respectivamente escriben un byte, un array de bytes, o una zona de un vector de bytes.
/**
* The output stream to the port
*/
// ID para contener el dato a enviar
private OutputStream serialSalida
= null; // requiere: import java.io.OutputStream;
/**
* A BufferedReader which will be fed by a InputStreamReader converting the
* bytes into characters making the displayed results codepage independent
*/
private BufferedReader serialEntrada
= null; // requiere: import java.io.BufferedReader; // forma alternativa
//private BufferedReader serialReader = null; // requiere: import java.io.BufferedReader;
//private InputStream serialEntrada = null; // requiere: import java.io.InputStream;
/**
* Milliseconds to block while waiting for port open
*/
// Tiempo de espera (ms) mientras se abre el puerto serie
private int TIEMPO_MUERTO; // TIME_OUT 2 seg
/**
* Default bits per second for COM port.
*/
private int VELOCIDAD_DE_DATOS; // DATA_RATE
private int LONGITUD_DE_CADENA; //
public void parametrosComunicacion
(int int_time_out,
int int_data_rate,
String str_puerto,
int int_longCadena
) { TIEMPO_MUERTO = int_time_out;
VELOCIDAD_DE_DATOS = int_data_rate;
NOMBRES_DE_PUERTOS[0] = str_puerto;
LONGITUD_DE_CADENA = int_longCadena;
}
public void inicializarConexion() {
// the next line is for Raspberry Pi and
// gets us into the while loop and was suggested here was suggested http://www.raspberrypi.org/phpBB3/viewtopic.php?f=81&t=32186
//System.setProperty("gnu.io.rxtx.SerialPorts", "/dev/ttyACM0");
// Búsqueda del puerto de comunicación según una lista previamente dada "NOMBRES_DE_PUERTOS"
CommPortIdentifier cpID_puerto = null; // requiere: import gnu.io.CommPortIdentifier;
// conforma la lista de puertos encontrados, por ejp { "COM1", "COM2", ... }
Enumeration enum_listaDePuertos
= CommPortIdentifier.
getPortIdentifiers(); // requiere: import java.util.Enumeration; if (!enum_listaDePuertos.hasMoreElements()) {
dlgBox_mostrarErrorYFinalizar("El sistema no tiene puertos de comunicación serial, por favor conecte una tarjeta");
}
String str_listaDePuertos
= ""; String str_listaDePuertosEncontrados
= ""; Boolean bool_puertoEncontrado
= false; while (enum_listaDePuertos.hasMoreElements() && !bool_puertoEncontrado) { // Mientras tenga más elementos la lista o enumeración y no se haya encontrado el puerto
// Extrae cada elemento de la enumeración y lo almacena en cpID_actualPuertoID
CommPortIdentifier cpID_actualPuertoID = (CommPortIdentifier) enum_listaDePuertos.nextElement();
str_listaDePuertos = "";
str_listaDePuertosEncontrados = str_listaDePuertosEncontrados + cpID_actualPuertoID.getName() + ", ";
for (String str_portName
: NOMBRES_DE_PUERTOS
) { str_puerto = cpID_actualPuertoID.getName();
str_listaDePuertos = str_listaDePuertos + str_portName + ", ";
//Si la "enum_listaDePuertos" coincide con alguna cadena de "NOMBRES_DE_PUERTOS id" fija la bandera
bool_puertoEncontrado = str_puerto.equals(str_portName);
System.
out.
print("\n" + str_portName
+ " == " + str_puerto
+ ": " + bool_puertoEncontrado
);
if (bool_puertoEncontrado == true) {
// almacena en cpID_puerto
cpID_puerto = cpID_actualPuertoID;
break;
}
}
}
if (cpID_puerto == null) {
dlgBox_mostrarErrorYFinalizar("Los puertos encontrados { " + str_listaDePuertosEncontrados + " }, ninguno coincide con la lista: { " + str_listaDePuertos + " }");
} else {
System.
out.
println("\nPuerto encontrado: " + str_puerto
); }
// Fin Búsqueda del puerto de comunicación
// open serial port
try {
CommPort puerto = cpID_puerto.open(this.getClass().getName(), TIEMPO_MUERTO);
puertoSerial = (SerialPort) puerto;
// forma alternativa
//puertoSerial = (SerialPort) cpID_puerto.open(this.getClass().getName(), TIEMPO_MUERTO);
// set port parameters
puertoSerial.setSerialPortParams(VELOCIDAD_DE_DATOS, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
// open the streams
// forma alternativa
//serialEntrada = puertoSerial.getInputStream();
//serialReader = new BufferedReader(new InputStreamReader(serialEntrada));
serialSalida = puertoSerial.getOutputStream();
// add event listeners
// evento para notificar la interrupción
puertoSerial.addEventListener((SerialPortEventListener) this); // import gnu.io.SerialPortEventListener;
puertoSerial.notifyOnDataAvailable(true);
dlgBox_mostrarError(e.getMessage());
}
// end open serial port
}
void enviarCaracteres
(String char_caracteres
) { try {
// Escribir en el buffer la cadena de caracteres, cada elemento de la cadena se convierte a carácter
serialSalida.write(char_caracteres.getBytes());
dlgBox_mostrarErrorYFinalizar("ERROR AL ENVIAR EL CARACTER" + char_caracteres);
}
}
void enviarCaracter(char char_caracter) {
try {
// Escribir en el buffer el carácter
serialSalida.write(char_caracter);
dlgBox_mostrarErrorYFinalizar("ERROR AL ENVIAR EL CARACTER" + char_caracter);
}
}
private void dlgBox_mostrarError
(String str_mensaje
) { }
private void dlgBox_mostrarErrorYFinalizar
(String str_mensaje
) { System.
out.
println("\nAplicación finalizada, por error en tiempo de ejecución\n"); // return;
}
/**
* This should be called when you stop using the port. This will prevent
* port locking on platforms like Linux.
*/
public synchronized void close_serialPort() {
//synchronized(Configuracion_JAVA_μControlador_RXTXlibrary.class){
if (puertoSerial != null) {
puertoSerial.removeEventListener();
puertoSerial.close();
}
}
/**
* Handle an event on the serial port. Read the data and print it. Each info
* send by μControlador is taken here, evento para capturar datos enviados desde
* Arduino
*/
@Override
public synchronized void serialEvent(SerialPortEvent oEvent) {
// si se ha terminado de recibir una cadena de caracteres
if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
try {
String str_lineaDeEntrada
= serialEntrada.
readLine(); // Analice el dato enviado por μControlador
parsingReceivedLine(str_lineaDeEntrada);
System.
err.
println(e.
toString()); }
}
// Ignore all the other eventTypes, but you should consider the other ones.
}
// Analizador sintáctico de la línea recibida
private void parsingReceivedLine
(String str_lineaDeEntrada
) { //System.out.println(str_lineaDeEntrada.endsWith("\n"));
if (str_lineaDeEntrada.startsWith("ACmd:") && str_lineaDeEntrada.length() <= LONGITUD_DE_CADENA) {
// imprima el dato enviado del μControlador
System.
out.
println(str_lineaDeEntrada.
substring(5, str_lineaDeEntrada.
length())); } else {
System.
out.
println(str_lineaDeEntrada
); }
}
}
