Erro com Comunicação Serial

Assuntos Gerais
#1

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 **********

[code]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;
    }
    }
    }[/code]

//********************************************************************************************************

#2