Ler balança na serial usando RXTX

Programação Java
#1

Pessoal, já fiz o processo abaixo em outra balança e a leitura no Java quebrava a string com o peso.
Agora com outra balança (de outro fabricante) a balança deveria mandar uma string com 14 caracteres sem o penúltimo o CR e o último o LF, contudo a aplicação Java corta no 9° caracter e faz a leitura no restante na última linha.
Isso está dificultando muito o meu trabalho, já pesquisei e nada de achar nada relacionado.
Eu uso a API RXTX e o meu código é baseado no tuto aqui do GUJ. Se alguém quiser ver segue o código.
Alguém já passou por isso e pode dar uma ajuda?

[code]
package br.com.alimentoswilson.serial;

import gnu.io.CommPortIdentifier;
import java.util.Enumeration;

/**
*

  • @author petter
    /
    public class SerialCom {
    //    ********************************
    //Variáveis
    //*********************************
    //variáveis para identificar portas
    protected String[] portas;
    protected Enumeration listaDePortas;
    //construtor
    public SerialCom(){
    listaDePortas = CommPortIdentifier.getPortIdentifiers();
    }
    //retorna as portas disponíveis
    public String[] ObterPortas(){
    return portas;
    }
    //Copia portas para um Array
    protected void ListarPortas(){
    int i = 0;
    portas = new String[10];
    while (listaDePortas.hasMoreElements()) {
    CommPortIdentifier ips =
    (CommPortIdentifier)listaDePortas.nextElement();
    portas[i] = ips.getName();
    i++;
    }
    }
    //pesquisa se a Porta existe
    public boolean PortaExiste(String COMp){
    String temp;
    boolean e = false;
    while (listaDePortas.hasMoreElements()) {
    CommPortIdentifier ips =
    (CommPortIdentifier)listaDePortas.nextElement();
    temp = ips.getName();
    if (temp.equals(COMp)== true) {
    e = true;
    };
    }
    return e;
    }
    //imprime as portas disponíveis
    protected void ImprimePortas(){
    for (int i = 0 ; i < portas.length ; i ++ ) {
    if (portas[i] != null ) {
    }
    }
    System.out.println(" ");
    }
    }//FIM DA CLASSE[/code]

[code]
package br.com.alimentoswilson.serial;

import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import javax.swing.JOptionPane;

/**
*

  • @author petter
    */
    public class SerialComEscrita implements Runnable, SerialPortEventListener {
    //propriedades
    private String Porta;
    public String Dadoslidos;
    public int nodeBytes;
    private int baudrate;
    private int timeout;
    private CommPortIdentifier cp;
    private SerialPort porta;
    private OutputStream saida;
    private InputStream entrada;
    private Thread threadLeitura;
    //indicadores
    private boolean IDPortaOK; //true porta EXISTE
    private boolean PortaOK;// true porta aberta
    private boolean Leitura;
    private boolean Escrita;
    //construtor default paridade : par
    //baudrate: 9600 bps stopbits: 2 COM 1

private boolean validaPeso = true;
private String peso1;
private String peso2;
private String pesoTotal;

public void setTextPeso1(String peso1){
this.peso1 = peso1;
}

public void setTextPeso2(String peso2){
this.peso2 = peso2;
}

public String getTextPeso1(){
return peso1;
}

public String getTextPeso2(){
return peso2;
}

public SerialComEscrita() {
Porta = “COM1”;
baudrate = 9600;
timeout = 530;
};
//um Objeto ComObj � passado ao construtor
//com detalhes de qual porta abrir
//e informa��es sobre configura��es
public SerialComEscrita( String p , int b , int t ){
this.Porta = p;
this.baudrate = b;
this.timeout = t;
};
//habilita escrita de dados
public void HabilitarEscrita(){
Escrita = true;
Leitura = false;
}
//habilita leitura de dados
public void HabilitarLeitura(){
Escrita = false;
Leitura = true;
}
//Obt�m o ID da PORTA
public void ObterIdDaPorta(){
try {
cp = CommPortIdentifier.getPortIdentifier(Porta);
if ( cp == null ) {
JOptionPane.showMessageDialog(null,
“A " + Porta + " não existe. Abortando !”,
“Erro!”,
JOptionPane.ERROR_MESSAGE);
//System.out.println(“A " + Porta + " nao existe!” );
//System.out.println(“ERRO!Abortando…” );
IDPortaOK = false;
System.exit(1);
}
IDPortaOK = true;
} catch (Exception e) {
JOptionPane.showMessageDialog(null,
“Erro durante o procedimento. STATUS” + e,
“Erro!”,
JOptionPane.ERROR_MESSAGE);
//System.out.println(“Erro durante o procedimento. STATUS” + e );
IDPortaOK = false;
System.exit(1);
}
}
//Abre a comunica��o da porta
public void AbrirPorta(){
try {
porta = (SerialPort)cp.open(“SerialCom”, timeout);
PortaOK = true;
//System.out.println(“Porta aberta com sucesso!”);
//configurar par�metros
porta.setSerialPortParams(baudrate,
porta.DATABITS_8,
porta.STOPBITS_1,
porta.PARITY_NONE);
porta.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);
} catch (Exception e) {
PortaOK = false;
JOptionPane.showMessageDialog(null,
"Erro ao abrir a porta! STATUS: " + e,
“Erro!”,
JOptionPane.ERROR_MESSAGE);
//System.out.println("Erro ao abrir a porta! STATUS: " + e );
System.exit(1);
}
}
//fun��o que envie um bit para a porta serial
public void EnviarUmaString(String msg){
if (Escrita == true) {
try {
//saida = porta.getOutputStream();
//System.out.println(“FLUXO OK!”);
} catch (Exception e) {
JOptionPane.showMessageDialog(null,
"Erro. STATUS: " + e,
“Erro!”,
JOptionPane.ERROR_MESSAGE);
//System.out.println("Erro.STATUS: " + e );
}
try {
//System.out.println("Enviando um byte para " + Porta );
//System.out.println("Enviando : " + msg );
saida.write(msg.getBytes());
Thread.sleep(100);
saida.flush();
} catch (Exception e) {
JOptionPane.showMessageDialog(null,
"Ocorreu um erro no envio: " + e,
“Erro!”,
JOptionPane.ERROR_MESSAGE);
//System.out.println("Houve um erro durante o envio. ");
//System.out.println("STATUS: " + e );
System.exit(1);
}
} else {
System.exit(1);
}
}
//leitura de dados na serial
public void LerDados(){
if (Escrita == false){
try {
entrada = porta.getInputStream();
//System.out.println(“FLUXO OK!”);
} catch (Exception e) {
JOptionPane.showMessageDialog(null,
"Erro de fluxo! STATUS: " + e,
“Erro!”,
JOptionPane.ERROR_MESSAGE);
//System.out.println("Erro.STATUS: " + e );
System.exit(1);
}
try {
porta.addEventListener(this);
//System.out.println(“SUCESSO. Porta aguardando…”);
} catch (Exception e) {
JOptionPane.showMessageDialog(null,
"Erro ao criar listener! STATUS: " + e,
“Erro!”,
JOptionPane.ERROR_MESSAGE);
//System.out.println("Erro ao criar listener: ");
//System.out.println("STATUS: " + e);
System.exit(1);
}
porta.notifyOnDataAvailable(true);
try {
threadLeitura = new Thread(this);
threadLeitura.start();
threadLeitura.run();
//run();
} catch (Exception e) {
JOptionPane.showMessageDialog(null,
"Erro ao iniciar leitura! STATUS: " + e,
“Erro!”,
JOptionPane.ERROR_MESSAGE);
//System.out.println("Erro ao iniciar leitura: " + e );
}
}
}
//m�todo RUN da thread de leitura
public void run(){
try {
Thread.sleep(100);
} catch (Exception e) {
JOptionPane.showMessageDialog(null,
"Erro! STATUS: " + e,
“Erro!”,
JOptionPane.ERROR_MESSAGE);
//System.out.println("Erro. Status = " + e );
}
}

//gerenciador de eventos de leitura na serial
public void serialEvent(SerialPortEvent ev){
switch (ev.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:
byte[] bufferLeitura = new byte[20];
try {
while ( entrada.available() > 0 ) {
nodeBytes = entrada.read(bufferLeitura);
}
String dadosLidos = new String(bufferLeitura);
if (bufferLeitura.length == 0) {
JOptionPane.showMessageDialog(null,
“Nada foi lido. Verifique a balança!”,
“Aviso!”,
JOptionPane.WARNING_MESSAGE);
//System.out.println(“Nada lido!”);
} else if (bufferLeitura.length == 1 ){
JOptionPane.showMessageDialog(null,
“Apenas 1 byte foi lido. Verifique a balança!”,
“Aviso!”,
JOptionPane.WARNING_MESSAGE);
//System.out.println(“Apenas um byte foi lido!”);
} else {

System.out.println(dadosLidos);

}
}catch(Exception e) {
JOptionPane.showMessageDialog(null,
"Erro durante leitura! STATUS: " + e,
“Erro!”,
JOptionPane.ERROR_MESSAGE);
//System.out.println("Erro durante a leitura: " + e );
}
//System.out.println("n.o de bytes lidos : " + nodeBytes );
break;
}
}

//função que fecha a conexão
public void FecharCom(){
try {
porta.close();
//System.out.println(“CONEXAO FECHADA>>FIM…”);
/JOptionPane.showMessageDialog(null,
“Conex�o serial finalizada.”,
“Aviso!”,
JOptionPane.WARNING_MESSAGE);/
} catch (Exception e) {
JOptionPane.showMessageDialog(null,
"Erro ao fechar comunicação! STATUS: " + e,
“Erro!”,
JOptionPane.ERROR_MESSAGE);
//System.out.println("ERRO AO FECHAR. STATUS: " + e );
System.exit(0);
}
}
//Acessores
public String obterPorta(){
return Porta;
}
public int obterBaudrate(){
return baudrate;
}
}[/code]

#2

Bom dia Petter,
como vc está tomando todo o conteúdo do buffer após a geração do evento, mas a impressora pode não ter enviado toda a mensagem.
Tente implementar uma rotina de timeout na recepção.

substituia while ( entrada.available() > 0 ) { nodeBytes = entrada.read(bufferLeitura); }
por


 		 String dadosLidos; 
		
		 long timeout = Java.System.currentTimeMillis() + 1000; //(timeout de 1seg na leitura)

		 if ( entrada.available() > 0 ) {			
			while( timeout < Java.System.currentTimeMillis()){
				nodeBytes = entrada.read(bufferLeitura);
			
				if(nodeBytes>0){
					dadosLidos += new String(bufferLeitura);
				}
				
				if(dadosLidos.length() >= 14)  // se já recebeu a mensagem completa, então nem aguarda o timeout expirar.
					break;
			}
		 }

abs

#3

oi gente …me ajudaa !!!
o programa q eu to tentando fazer é pra capturar pesoo da balança, ja implementeii com a java comm tem hora q vem so “sujeira” uns caracteres **&&¨#$$ … mais o normal é vim sujeira + peso.
o q eu façooo alguem ja passou por issu ?
desde ja agradeço!

#4

Pessoal,

Estou trabalhando em um notebook que não possui porta serial, mas como é a única máquina que tenho disponível, comprei um adptador USB to Serial.

Estou desenvolvendo uma rotina em Java pra imprimir etiquetas em uma impressora serial. Nesta impressora preciso mandar algumas strings com comandos para formatar o lay-out da etiquetas e depois mandar outras string com os dados. Com o software de teste da impressora, consigo utiliza-la normalmente por intermédio deste adaptador USB/Serial, mas o mesmo comando quando tento mandar pela RXTX, aparentemente não chega na impressora.

Alguém tem conhecimento se existe alguma incompatibilidade da API RXTX com este tipo de dispositivo ?!

Grato!

#5