python串行读取的CPU负载

Question

我有一个应用程序，我需要从 Python 线程中的串行端口读取数据。由于它被放置在一个线程中，我虽然可以使用：

timeout = None

并在线程中使用以下代码：

# Setup
ser = serial.Serial(port, 38400, timeout = None)

# Loop
data = ser.read(2)
if data[0] == 2:
    data += ser.read(data[1]-2) # Expected length of message
    return data
else: # Handle error message

但是，当我将其与其他线程的频率进行比较时，我发现频率增加了近 200%，而是使用：

# Setup
ser = serial.Serial(port, 38400, timeout = 0)

# Loop
data = ser.read(1)
if data and data[0] == 2:
    while len(data) < 2:
        data += ser.read(1)
    while len(data) < data[1]:
        data += ser.read(1)
    return data
else: # Handle error message

此外，在模拟过程中，数据被收集，然后使用套接字“重放”，当使用套接字时，我得到了更好的结果，让我相信我应该能够提高整体频率该应用程序甚至是实时的。但是我找不到任何关于 Python 中串行读取时间复杂度的相关讨论。

编辑：

经过进一步的修补和测试，我仍然无法找出读取串行端口的最佳方法......关于时间复杂度读取串行端口的最佳方法是否有任何“正确”答案？

// 雅各布

Answer 1

没有足够的信息来确切地知道发生了什么，但您似乎正在尝试接收采用以下形式之一的消息：

• “数据”消息，如下所示：| 2 | Length | d1 | d2 | ... | dN |
• 一些错误指示...您没有提到，但可能只是一个不是 2 的字节？

在您的第一个实现中，data = ser.read(2) 行将“永远等待，直到收到至少两个字节”。但是如果发送一个 1 字节的消息，那么代码将一直等待，直到收到另一条消息。

虽然没有“正确”的方式从串口读取数据，但您可能想尝试将字节接收和消息解析分开。

例如，你可能有这样的事情：

from collections import deque


def receive_bytes(ser, buffer):
    """Read bytes from serial port and append them to the buffer"""
    data = ser.read(1)
    while data:
        buffer.append(data[0])
        data = ser.read(1)


def consume_messages(buffer):
    """Consume available messages from the buffer destructively"""

    # This loop uses the first byte as the key for what
    # message should be in the buffer. We only consume
    # a message from the buffer when it is present in
    # its entirety (i.e. we only read a data mesage once
    # all the bytes are present).
    messages = []
    while len(buffer) > 0:
        # Check if we have a data message
        if buffer[0] == 2 and len(buffer) > 1:
            data_message_len = buffer[1]
            if len(buffer) - 2 > data_message_len:
                # looks like enough info for a data message
                buffer.popleft()  # the 2 byte
                buffer.popleft()  # the length byte
                data_message = [
                    buffer.popleft() for _ in range(data_message_len)
                ]
                messages.append(data_message)

        # Check if we have a "1" message
        elif buffer[0] == 1:
            messages.append(buffer.popleft())

        else:
            # looks like the first byte is something we don't
            # know about...likely a synchronization error, so just
            # drop it
            buffer.popleft()

    return messages


def handle_messages(messages):
    for m in messages:
        print(m)


if __name__ == "__main__":
    # setup
    ser = serial.Serial(port, 38400, timeout=0)
    buf = deque()

    # loop
    while True:
        receive_bytes(ser, buf)
        messages = consume_messages(buf)
        handle_messages(messages)

FWIW，我认为时间复杂度与此无关。原始代码的阻塞特性以及应用程序代码、串行库和底层操作系统之间的交互都是比时间复杂度更大的因素。

基本上...您的计算机比控制串行端口的硬件快得多，因此与没有超时的检查相比，使用阻塞等待方法通常会浪费更多的计算时间 - 即使您正在检查数千/数百万字节之间的时间。

Answer 2

尝试强制串口等待 I/O ser.read(ser.inWaiting() + 32)

我看到 serial_port.read(serial_port.in_waiting) 读取速度非常快，它避免了缓冲区中字节累积的问题

如果你在 Python3 上，那么 ser.read() 返回字节，所以任何比较都是错误的。调试：data[0] == 2 需要是 data[0:1] == b'2'

玩：

ser = serial.Serial(port, 38400)
while(True):        
    print('ser_is_open')
    ser.read(ser.in_waiting() + 32)                   
    print('ser_in_waiting')