Polling na porta Paralela ou USB

E ae galera…tudo bem com vocês??
Queria saber se alguém conhece algum tutorial ou possui um source-code de exemplo para fazer polling na porta paralela ou USB…

A unica coisa que consegui foi comunicação com a porta serial, mais não consigo retirar nenhum status dela (I/O). To usando a biblioteca RXTX.

Se alguém conhecer alguma biblioteca “mais melhor de bom” para utilizar da um comment aki…

Esse é meu source-code que desenvolvi seguindo um tutorial na internet:

Classe: SerialCom

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

/**
 *
 * @author Luan
 */
public class SerialCom {
    protected String[] portas;
    protected Enumeration listaDePortas;
    
    public SerialCom(){
        listaDePortas=CommPortIdentifier.getPortIdentifiers();
    }
    
    //retorna as portas disponíveis
    public String[] ObterPortas(){
        return portas;
    }
    
    //armazenar uma lista das portas seriais disponíveis
    protected void ListarPortas(){
        int i=0;
        portas = new String[10];
        while(listaDePortas.hasMoreElements()){
            CommPortIdentifier ips= (CommPortIdentifier)listaDePortas.nextElement();
            portas[i]=ips.getName();
            i++;
        }
    }
    //verifica se a porta selecionada existe e se esta tudo em funcionamento com ela
    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;
    }
}

Classe: SerialComLeitura

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.sql.ResultSet;
import java.util.ArrayList;
import java.util.Iterator;

/**
 *
 * @author Luan
 */
public class SerialComLeitura implements Runnable,SerialPortEventListener{

    public String Dadoslidos;
    public int nodeBytes;
    private int baudrate;
    private int timeout;
    private CommPortIdentifier cp;
    private SerialPort porta;
    private InputStream entrada;
    private OutputStream saida;
    private Thread threadLeitura;
    private boolean IDPortaOK;
    private boolean PortaOK;
    private boolean Leitura;
    private boolean Escrita;
    private String Porta;
    protected String peso;

    public void setPeso(String peso) {
        this.peso = peso;
    }

    public String getPeso() {
        return peso;
    }

    public SerialComLeitura(String p, int b, int t) {
        this.Porta = p;
        this.baudrate = b;
        this.timeout = t;
    }

    public void HabilitarLeitura() {
        Escrita = false;
        Leitura = true;
    }

    public void ObterIdDaPorta() {
        try {
            cp = CommPortIdentifier.getPortIdentifier(Porta);
            if (cp == null) {
                System.out.println("Erro na porta!");
                IDPortaOK = false;
                System.exit(1);
            }else{
                System.out.println("ID da porta: "+cp);
            }
            IDPortaOK = true;

        } catch (Exception e) {
            System.out.println("Erro obtendo ID da porta: " + e);
            IDPortaOK = false;
            System.exit(1);
        }
    }

    public void AbrirPorta() {
        try {
            porta = (SerialPort) cp.open("SerialComLeitura", timeout);
            PortaOK = true;
            porta.setSerialPortParams(baudrate, porta.DATABITS_8, porta.STOPBITS_1, porta.PARITY_NONE);
            porta.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);
        } catch (Exception e) {
            PortaOK = false;
            System.out.println("Erro abrindo comunicação: " + e);
            System.exit(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 Thred: " + e);
            }
        }
    }

    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 {

                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) {

                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(5);

        } catch (Exception e) {
            System.out.println("Erro de Thred:" + e);
        }

    }
    public void serialEvent(SerialPortEvent ev){       

        StringBuffer bufferLeitura = new StringBuffer();

        int novoDado = 0;

       

        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:

                //Novo 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);

                    }

                }

                setPeso(new String(bufferLeitura));

                System.out.println(getPeso());

            break;

        }

}
    public void FecharCom(){

            try {

                porta.close();

            } catch (Exception e) {

                System.out.println("Erro fechando porta: " + e);

                System.exit(0);

            }

}

   

public String obterPorta(){

        return Porta;

}

   

public int obterBaudrate(){

        return baudrate;

    }
}

Classe: Principal (Main)


import Serial.SerialCom;
import Serial.SerialComLeitura;
import java.util.Timer;
import java.util.TimerTask;

/**
 *
 * @author Luan
 */
public class Principal extends SerialCom {

    

    public static void main(String[] args) {
        //Iniciando leitura serial
        final SerialComLeitura leitura = new SerialComLeitura("COM1", 9600, 0);
        
        int delay = 5000;   // delay de 5 sec.
        int period = 1000;  // repete o codigo a cada 1 sec.
        Timer timer = new Timer();


        timer.scheduleAtFixedRate(new TimerTask() {

            public void run() {

                leitura.HabilitarLeitura();

                leitura.ObterIdDaPorta();

                leitura.AbrirPorta();

                leitura.LerDados();
                
                leitura.FecharCom();
                //Controle de tempo da leitura aberta na serial

                try {

                    Thread.sleep(1000);

                } catch (InterruptedException ex) {

                    System.out.println("Erro na Thread: " + ex);

                }

            }
        }, delay, period);

        
    }
}