dúvida com evento: serialEvent (ap. com rxtx "serial monitor like")

Olá,

estou migrando um aplicativo de C# que usa um form (gui) com uma espécie de “serial terminal” e mais alguns botões, umas classes simples…
Estou usando a api rxtx para realizar a comunicação serial, e até agora tudo está funcionando.
A única coisa que falta para funcionar é o seguinte:

na classe que escrevei para implementar os métodos da comunicação serial (baseada neste tutorial ) há o metódo para gerenciar os dados recebidos

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 != '\n') {
                    try {
                        novoDado = entrada.read();
                        //System.out.print(novoDado);
                        if (novoDado == '\n') {
                            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()); // mostra normalmente os dados recebidos
                break;
        }
    }

O trecho acima funciona perfeitamente, porém, como eu faço para “chamar” este método na minha classe principal?
Com chamar quero dizer, ele funciona sem chamar (se é evento é lógico que…), mas quero que quando executado, este trecho implemente métodos das minhas outras classes, e faça append no meu monitor serial.

Em C#, na classe principal tinha:

private void Arduino_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e) // le bytes até o LF via COM
        {
            recebido = Arduino.ReadLine(); // Arduino é um objeto serial
            this.Invoke(new EventHandler(log_DisplayText));
        }

private void log_DisplayText(object sender, EventArgs e) // evento quando recebe dados serial
        {
            serial_monitor.AppendText(recebido + "\r\n");

            if (recebido.StartsWith("@"))
            {                
                num_dispositivo = recebido.charAt(1);
                NS = num_s.incrementaNS(codigo, true); //metodo de uma classe minha
                log.guardar(recebido, NS.ToString(), codigo); // metodo de outra classe //guarda o log
                tag.geraTag(codigo, num_dispositivo, NS); //metodo de outra classe
             }
        }

O que falta implementar no meu código para funcionar como o segundo exemplo?

Ninguém? Ou não fui claro na minha dúvida?

edit:
Pesquisando mais um pouco, parece que o que eu preciso tem a ver com “listener”, referenciar o evento na minha classe principal…
No caso o evento está na classe SerialComm, e eu preciso que ele execute ações na minha GUI quando ativado

Bom, ficou assim: (entre asteriscos as mudanças)

public class SerialComm ******extends Observable****** implements Runnable, SerialPortEventListener{
.
.
.
.

   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 != '\n') {  
                    try {  
                        novoDado = entrada.read();  
                        //System.out.print(novoDado);  
                        if (novoDado == '\n') {  
                            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));
                
                *********
                setChanged();
                notifyObservers(getPeso());
                *********
                System.out.println(porta +" "+ getPeso());                
                break;
        }
    }

e na GUI:

public class formTB extends javax.swing.JFrame ******implements Observer******{

private SerialComm Arduino = new SerialComm("/dev/ttyUSB0", 9600, 0);

public formTB() {        // construtor
        initComponents();
        System.out.println("iniciou GUI");
        
        ******Arduino.addObserver(this);******
}

.
.
.
.

************************
   @Override
    public void update(Observable o, Object resp) // evento na GUI quando recebe dados serial
    {
        System.out.println("funciona!");  
    }
************************

Apesar de que ninguém conseguiu me ajudar espero que futuramente possa servir de consulta para alguém com um problema parecido.
ps.: parece que também é possível com “listener”, mas assim pareceu ser mais simples para esta aplicação…