Android 安卓USB传输

我正在开发一个Android应用程序，使用连接到FT232 USB芯片的USB主机API。FT232设备向Android SBC传输大量样本（20KBps）。然而，我注意到我偶尔会丢失一些样品。我连接了一个USB分析仪来查看两个端点之间的通信。我可以在一些USB数据包中看到延迟

FT232 USB数据包为64KB，我的线程正在重复调用bulktransfer api以检索下一个数据包并填充循环缓冲区。我有另一个线程正在从循环缓冲区读取数据。读取和写入循环缓冲区时，两个线程都是同步的。 我不确定读取线程是否阻塞太长，这会导致写入线程丢失一些数据包？有什么改进的想法或建议吗

波特率460800，8，N，1

下面是我的代码片段

public class UsbClass {

private static final int MAX_BUFFER_SIZE = 512000;
private byte[] circularBuffer = new byte[MAX_BUFFER_SIZE];
private int writeIndex=0;
private int readIndex=0;

ReadUsbThread usbReadThread;
ParseDataThread parseThread;

public UsbClass() {
    super();
      usbReadThread = new ReadUsbThread();
      usbReadThread.start();

      parseThread = new ParseDataThread();
      parseThread.start();
}

// Read data from USB endpoint
public class ReadUsbThread extends Thread {
    public ReadUsbThread() {

    }
    int length;
    byte[] buffer = new byte[64];
    public void run() {
        while(true)
        {
            length = conn.bulkTransfer(epIN, buffer, buffer.length, 100);
            if(length>2)
            {
                writeCircularBuffer(buffer, length);
            }
            else
                Thread.sleep(1);
        }
    }
}

// Parse the data from circular buffer
public class ParseDataThread extends Thread {
    public ParseDataThread() {

    }
    byte[] data;
    public void run() {
        while(true)
        {
            data = readCircularBuffer(1);
            // do something with data
        }
    }
}

// Write to circular buffer
public synchronized void writeCircularBuffer(byte[] buffer, int length)
{
        for(int i = 2; i<length; i++)
        {
            circularBuffer[writeIndex++] = buffer[i];
            if(writeIndex == MAX_BUFFER_SIZE)
                writeIndex=0;
        }
}

// Read from circular buffer
public synchronized byte[] readCircularBuffer(int length)
{
    byte[] buffer = new byte[length];
    for(int i = 0; i<length; i++)
    {

        buffer[i] = circularBuffer[readIndex++];

        if(readIndex == MAX_BUFFER_SIZE)
            readIndex=0;
    }
    return buffer;
}

公共类UsbClass{
私有静态最终int MAX_BUFFER_SIZE=512000；
专用字节[]循环缓冲=新字节[最大缓冲大小]；
私有int writeIndex=0；
私有int readIndex=0；
ReadUsbThread-usbReadThread；
ParseDataThread parseThread；
公共UsbClass（）{
超级（）；
usbReadThread=newreadusbthread（）；
usbReadThread.start（）；
parseThread=新的ParseDataThread（）；
parseThread.start（）；
}
//从USB端点读取数据
公共类ReadUsbThread扩展线程{
公共ReadUsbThread（）{
}
整数长度；
字节[]缓冲区=新字节[64]；
公开募捐{
while（true）
{
长度=conn.BULKTERVER（epIN，缓冲器，缓冲器长度，100）；
如果（长度>2）
{
writeCircularBuffer（缓冲区，长度）；
}
其他的
睡眠（1）；
}
}
}
//解析循环缓冲区中的数据
公共类ParseDataThread扩展线程{
公共ParseDataThread（）{
}
字节[]数据；
公开募捐{
while（true）
{
数据=读取循环缓冲区（1）；
//处理数据
}
}
}
//写入循环缓冲区
公共同步的void writeCircularBuffer（字节[]缓冲区，整数长度）
{
对于（int i=2；i