Issues with RXTX - Erronous amount of bytes being received

Question

I'm having some difficulties with retrieving data from a microcontroller. I'm transferring data in chunks of exactly 2000 bytes, and have written a thread to handle these 2000 bytes before make a new call to send the next 2k bytes. For the most part it works just fine, but sometimes I tend to get one byte too many, or one byte too few for some reason, and this is only during case #2. If I use case #1 it always works flawlessly, but it's very slow for some reason instead. We're talking around 2000 bytes in 10 seconds, which is far too slow when I've set the serialport to work at 115.200 baud.

case #1 (Always works, but very slow)

public void serialEvent(SerialPortEvent event)
{
    switch (event.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:

            try
            {
                byte singleData = (byte) buffer.read();
                gasArray.setMessage(singleData);
                    if (gasArray.isBusy())
                    {
                        gasArray.setProcessing();
                        while (gasArray.isProcessing())
                        {
                            continue;
                        }
                    }
                    else
                        gasArray.appendChat("Incoming data: " + singleData);
                }
        }

Case #2 (Gets stuck sometimes, but is very fast)

public void serialEvent(SerialPortEvent event)
{

    switch (event.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:

            try
            {
                while (buffer.available() > 0)
                {
                    byte singleData = (byte) buffer.read();
                    gasArray.setMessage(singleData);
                    if (gasArray.isBusy())
                    {
                        gasArray.setProcessing();
                        while (gasArray.isProcessing())
                        {
                            continue;
                        }
                    }
                    else
                        gasArray.appendChat("Incoming data: " + singleData);
                }
        }

There's another worker thread handling the incoming data and doing some operations, and it's not a synchronization issue or something like that. It comes down to either getting one too many, or one to few bytes, which causes my thread that counts the bytes to get stuck, expecting one more byte. I've used RealTerm (a serial console program) to retrieve the same things, and it does it both fast and accurate every single time. When adding a BufferedInputStream things seemed to work a bit better with case #2, but the problem still happened occasionally.

My questions are: Is the available() method really that unreliable to cause these issues? Or is this a problem with serial communication or the RXTX library? Is there a better way of handling this? Retrieving 2000 bytes, handling them, and asking for another 2000 bytes. Is the #1 case supposed to be this slow in receiving data on the serial port?

Any ideas with examples would be of great help.

Answer 1

In case 1 you should read into a byte array and process all the data you got.

The available() method isn't much use in 99% of cases, and certainly not when reading from an input device that has already told you data is ready.