java - 使用 JSSC 时如何从串行连接读取(所有可用)数据？

Question

我正在尝试与 JSSC 合作。我根据此链接构建了我的应用程序:

https://code.google.com/p/java-simple-serial-connector/wiki/jSSC_examples

我的事件处理程序如下所示:

static class SerialPortReader implements SerialPortEventListener {

        public void serialEvent(SerialPortEvent event) {
            if(event.isRXCHAR()){//If data is available                                
                    try {
                        byte buffer[] = serialPort.readBytes();
                    }
                    catch (SerialPortException ex) {
                        System.out.println(ex);
                    }
                }
            }

        }
    }

问题是我总是无法将传入的数据整合到一起。 (我的消息长度为 100 字节，我在 2 个单独的调用中得到 48 和 52 字节)- 对方向我发送不同长度的消息。
- 在我使用的 ICD 中，有一个字段告诉我们消息的长度。 (从字节#10到字节#13)- 我无法读取 14 个字节:

 (serialPort.readBytes(14);, 

解析消息长度并读取消息的其余部分:

 (serialPort.readBytes(messageLength-14);

但是如果我这样做，我将不会将消息放在一起(我将有 2 个单独的 byte[]，并且我需要将它放在一 block (byte[])中，而无需复制功能。

1. 可能吗？

当使用以太网(SocketChannel)时，我们可以使用 ByteBuffer 读取数据。但对于 JSSC，我们做不到。

是否有 JSSC 的良好替代方案？

谢谢

Answer 1

您不能依赖任何图书馆立即为您提供所需的全部内容，因为:

• 图书馆不知道您需要多少数据
• 库会在数据到来时为您提供数据，并且还取决于缓冲区、硬件等

您必须开发自己的业务逻辑来处理数据包接收。当然，这取决于您的数据包的定义方式:它们是否始终具有相同的长度，它们是否以相同的结束字符分隔，等等。

这是一个应该适用于您的系统的示例(请注意，您应该将此作为开始，而不是完整的解决方案，例如它不包括超时):

static class SerialPortReader implements SerialPortEventListener
{
    private int m_nReceptionPosition = 0;
    private boolean m_bReceptionActive = false;
    private byte[] m_aReceptionBuffer = new byte[2048];

    @Override
    public void serialEvent(SerialPortEvent p_oEvent)
    {
        byte[] aReceiveBuffer = new byte[2048];

        int nLength = 0;
        int nByte = 0;

        switch(p_oEvent.getEventType())
        {
            case SerialPortEvent.RXCHAR:
                try
                {
                    aReceiveBuffer = serialPort.readBytes();

                    for(nByte = 0;nByte < aReceiveBuffer.length;nByte++)
                    {
                        //System.out.print(String.format("%02X ",aReceiveBuffer[nByte]));

                        m_aReceptionBuffer[m_nReceptionPosition] = aReceiveBuffer[nByte];

                        // Buffer overflow protection
                        if(m_nReceptionPosition >= 2047)
                        {

                            // Reset for next packet
                            m_bReceptionActive = false;
                            m_nReceptionPosition = 0;
                        }
                        else if(m_bReceptionActive)
                        {
                            m_nReceptionPosition++;

                            // Receive at least the start of the packet including the length
                            if(m_nReceptionPosition >= 14)
                            {
                                nLength = (short)((short)m_aReceptionBuffer[10] & 0x000000FF);
                                nLength |= ((short)m_aReceptionBuffer[11] << 8) & 0x0000FF00;
                                nLength |= ((short)m_aReceptionBuffer[12] << 16) & 0x00FF0000;
                                nLength |= ((short)m_aReceptionBuffer[13] << 24) & 0xFF000000;

                                //nLength += ..; // Depending if the length in the packet include ALL bytes from the packet or only the content part

                                if(m_nReceptionPosition >= nLength)
                                {
                                    // You received at least all the content

                                    // Reset for next packet
                                    m_bReceptionActive = false;
                                    m_nReceptionPosition = 0;
                                }
                            }

                        }
                        // Start receiving only if this is a Start Of Header
                        else if(m_aReceptionBuffer[0] == '\0')
                        {
                            m_bReceptionActive = true;
                            m_nReceptionPosition = 1;
                        }
                    }
                }
                catch(Exception e)
                {
                    e.printStackTrace();
                }
                break;
            default:
                break;
        }
    }
}