Question

我有一个FPGA，它通过FT2232H在USB总线上传输数据，而且我发现由于帧中的某些字节丢失，必须丢弃大约10％的数据。以下是技术细节：

我的笔记本电脑在Ubuntu 18.04LTS上运行python 3.7（来自anaconda）
通过以下初始化行打开FPGA / FT2232H：

SYNCFF = 0x40
SIO_RTS_CTS_HS = (0x1 << 8)
self.device = pylibftdi.Device(mode='t', interface_select=pylibftdi.INTERFACE_A, encoding='latin1')
self.device.ftdi_fn.ftdi_set_bitmode(0xff, SYNCFF)
self.device.ftdi_fn.ftdi_read_data_set_chunksize(0x10000)
self.device.ftdi_fn.ftdi_write_data_set_chunksize(0x10000)
self.device.ftdi_fn.ftdi_setflowctrl(SIO_RTS_CTS_HS)
self.device.flush()

然后通过以下简单的行读取数据：

raw_usb_data = my_fpga.device.read(0x10000)

我观察到以下情况：

我总是每批次获得0x10000数据，这正是我的期望。
使用device.read一次读取2 ** 16 = 65,536字节，因为每9 ms批处理就绪，读取应该花费147.4 ms。但是，对那条线进行计时可得出平均值为143毫秒，标准偏差为6.6毫秒。

我的第一个猜测是，某处没有缓冲区/很小的缓冲区，并且由于OS（优先级问题？）或python（垃圾回收？）在某些时候做其他事情太久而丢失了一些信息。

如何减少读取设备时丢失的字节数？

Answer 1

FT2232H具有内部FIFO缓冲区，容量约为4 kbit。您可能会受到他们的限制。不确定pylibftdi如何处理它们，但是如果可以使用VCP驱动程序，也许使用其他方法可能有效。这使您可以将FT2232H作为标准端口进行寻址，例如通过pyserial。

我的一个项目的某些摘录实际上适用于> 12 Mbps的波特率（UART限制为12 Mbps，但例如快速光电可以达到〜25 Mbps）：

import traceback
import serial
import serial.tools.list_ports
import multiprocessing
import multiprocessing.connection

def IO_proc(cntr_pipe, data_pipe):
    try:
        search_str="USB VID:PID=0403:6010 SER="
        ports     = [x.device for x in serial.tools.list_ports.comports() if search_str in x.hwid]
        baud_rate = 12000000 #only matters for uart and not for fast opto or fifo mode
        ser       = serial.Serial(port, baud_rate)

    while not cntr_pipe.closed:
        time.sleep(0)
        in_data = ser.read(ser.inWaiting())

        [...do some pattern matching, package identification etc...]

        data_pipe.send_bytes(in_data)

        except EOFError:
            ret_code = 2
        except Exception as e:
            cntr_pipe.send(traceback.format_exc())
            cntr_pipe.close()
            ret_code = 4
        finally:
            cntr_pipe.close()
            ser.close()

multiprocessing.connection.BUFSIZE = 2 ** 20 #only required for windows
child_cntr, parent_cntr = multiprocessing.Pipe()
child_data, parent_data = multiprocessing.Pipe()
process                 = multiprocessing.Process(target = IO_proc, args=(child_cntr, child_data))

#called frequently
def update():
    if child_cntr.poll():
        raise Exception("error",child_cntr.recv())

        buf = bytes()

        while parent_data.poll():
            buf += parent_data.recv_bytes()

    [...do something fancy...]

我试图举一个最小的例子。它未经测试，所以如果无法正常使用，请原谅我。要使此功能正常工作，实际上需要确保已加载VCP而非D2XX驱动程序。

P.S：实际上，在扫描文件时，我意识到pylibftdi方式应该可以正常工作，并且在加载D2XX驱动程序的情况下我可以使用“ decorator”类：

try:    import pylibftdi
except: pylibftdi = None


class pylibftdi_device:
    def __init__(self,speed):
        self.dev = pylibftdi.Device(interface_select=2)
        self.dev.baudrate = speed
        self.buf = b''

    def write(self, data):
        self.dev.write(data)

    def read(self, bytecount):
        while bytecount > len(self.buf):
            self._read()

        ret      = self.buf[:bytecount]
        self.buf = self.buf[bytecount:]
        return ret

    def flushInput(self):
        self.dev.flush_input()#FT_PURGE_RX
        self.buf = b''

    def _read(self):
        self.buf += self.dev.read(2048)

    @property
    def in_waiting(self):
        self._read()
        return len(self.buf)

    def close(self):
        self.dev.close()


def find_device_UART(baudrate=12000000,index=1, search_string="USB VID:PID=0403:6010 SER="):
    if pylibftdi:
        return pylibftdi_device(baudrate),"pylibftdi_device"
    try:
        ports = [x.device for x in serial.tools.list_ports.comports() if search_string in x.hwid]
        module_logger.info(str(ports))
        if len(ports) == 0:
            return None,"no device found"
        else:
            ser = serial.Serial(ports[index],baudrate)
            return ser,"found device %s %d"%(ser.name,ser.baudrate)
    except serial.SerialException as e:
        return None,"error during device detection - \n"+str(e)

因此，与您的示例的主要区别在于，将更频繁地读取recv缓冲区并将其放入缓冲区中，然后稍后再搜索该包。也许这对您的应用程序来说是一个彻底的矫kill过正，您只需要进行较小的读取调用即可确保缓冲区永远不会溢出。

pylibftdi Device.read跳过一些字节

1 个答案: