Amigos, bom dia!
Estou tendo problemas em fazer envio/recebimento de dados via porta serial!
Já pesquisei diversos códigos diferentes sobre esse assunto e só consegui resolver o envio para a porta COM, mas não consigo receber por outra porta!
Meu código é para em uma determinada tela eu selecionar uma porta para escrever e outra para ler dados, mas quando eu clico no botão que deveria ler os dados estou com o famoso "NullPointerException" que certamente é algum erro bem idiota mas como sou novato nessa parte, não estou sabendo resolver...
Se alguém puder me ajudar agradeço...
Só pra esclarecer o que preciso é enviar comandos (tipo PING) para um "radio/modem" que vai devolver dados tipo posicionamento via GPS!!!
Abaixo meus códigos:
// ********** metodo para receber conteúdo da porta serial... **********
private void receberConteudoPortaSerial(){
comSerial.habilitarLeitura();
comSerial.serialEvent(null);
txtDadosLidos.setText(comSerial.getDado());
}
// ********** Classe ComunicadorSerial **********
package comserial;
import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
/**
*
* @author RCSilva
*/
public class ComunicadorSerial implements Runnable, SerialPortEventListener {
public String dadosLidos;
private int baudrate;
public int nodeBytes;
private int timeout;
private CommPortIdentifier cp;
private SerialPort porta;
private OutputStream saida;
private InputStream entrada;
private Thread threadLeitura;
private boolean idPortaOk;
private boolean portaOk;
private boolean leitura;
private boolean escrita;
private String Porta;
protected String dado;
//código utilizado no teste de comunicação via porta serial...
public String getDado() {
return dado;
}
public void setDado(String valor) {
this.dado = valor;
}
public String getPorta() {
return Porta;
}
public void setPorta(String p) {
this.Porta = p;
}
public boolean getEscrita() {
return escrita;
}
public boolean getLeitura() {
return leitura;
}
public ComunicadorSerial(String p, int b, int t) {
this.Porta = p;
this.baudrate = b;
this.timeout = t;
}
public ComunicadorSerial() {
this.Porta = getPorta();
this.baudrate = baudrate;
this.timeout = timeout;
}
public void habilitaEscrita() {
escrita = true;
leitura = false;
}
public void habilitarLeitura() {
leitura = true;
escrita = false;
}
//obter id da porta para ser utilizado na identificação da mesma.
public int obterIdDaPorta() {
try {
cp = CommPortIdentifier.getPortIdentifier(getPorta());
if (cp == null) {
System.out.println("Erro na porta:" + Porta);
idPortaOk = false;
return -1;
}
idPortaOk = true;
} catch (Exception e) {
System.out.println("Erro Obtendo ID da porta: " + e);
idPortaOk = false;
return -1;
}
return 0;
}
// abrir comunicação com a porta escolhida...
public int abrirPorta() {
try {
porta = (SerialPort) cp.open("ComunicadorSerial", timeout);
portaOk = true;
//configurar parametros
porta.setSerialPortParams(baudrate, porta.DATABITS_8, porta.STOPBITS_1, porta.PARITY_NONE);
return -1;
} catch (Exception e) {
portaOk = false;
System.out.println("Erro abrindo comunicação: " + e);
return 1;
}
}
public void lerDados() {
if (escrita == false) {
try {
entrada = porta.getInputStream();
} catch (Exception e) {
System.out.println("Erro de stream: " + e);
System.exit(1);
}
try {
porta.addEventListener(this);
} catch (Exception e) {
System.out.println("Erro de listener: " + e);
System.exit(1);
}
porta.notifyOnDataAvailable(true);
try {
threadLeitura = new Thread(this);
threadLeitura.start();
run();
} catch (Exception e) {
System.out.println("Erro de THREAD: " + e);
}
}
}
// escrevendo na porta...
public void enviarUmaString(String msg) {
if (escrita == true) {
try {
saida = porta.getOutputStream();
System.out.println("Fluxo ok!");
} catch (Exception e) {
System.out.println("Erro.Status: " + e);
}
try {
saida.write(msg.getBytes());
System.out.println("Dado enviado: " + msg);
Thread.sleep(100);
saida.flush();
} catch (Exception e) {
System.out.println("Houve um erro durante o envio!");
System.out.println("STATUS: " + e);
System.exit(1);
}
} else {
System.exit(1);
}
}
public void run() {
try {
Thread.sleep(10);
} catch (Exception e) {
System.out.println("Erro de THREAD: " + e);
}
}
@Override
public void serialEvent(SerialPortEvent se) {
StringBuffer bufferLeitura = new StringBuffer();
int novoDado = 0;
switch (se.getEventType()) {
case SerialPortEvent.BI:
case SerialPortEvent.OE:
case SerialPortEvent.FE:
case SerialPortEvent.PE:
case SerialPortEvent.CD:
case SerialPortEvent.CTS:
case SerialPortEvent.DSR:
case SerialPortEvent.RI:
case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
break;
case SerialPortEvent.DATA_AVAILABLE:
// algoritmo de leitura:
while (novoDado != -1) {
try {
novoDado = entrada.read();
if (novoDado == -1) {
break;
}
if ('\r' == (char) novoDado) {
bufferLeitura.append('\n');
} else {
bufferLeitura.append((char) novoDado);
}
} catch (IOException ioe) {
System.out.println("Erro de Leitura Serial: " + ioe);
}
}
setDado(new String(bufferLeitura));
System.out.println("Valor lido da porta: " + String.valueOf(novoDado));
recebeuDado();
break;
}
}
// metodo para conferir se recebeu o dado:
public void recebeuDado() {
String dado = getDado();
if (dado != null) {
System.out.println("Dado Recebido: " + getDado());
}
}
// metodo para fechar a porta COM:
public void fecharPorta() {
try {
porta.close();
System.out.println("Porta fechada: " + this.Porta);
} catch (Exception e) {
System.out.println("Erro fechando a porta: " + e);
System.exit(0);
}
}
public String obterPorta() {
return Porta;
}
public int obterBaudrate() {
return baudrate;
}
public Enumeration listarPortas() {
try {
Enumeration listaPortas = CommPortIdentifier.getPortIdentifiers();
return listaPortas;
} catch (Exception e) {
System.out.println("Erro obtendo listagem de portas: " + e);
return null;
}
}
}
//********************************************************************************************************