使用多个串行设备读取大延迟时

Question

我试着用pyserial从不止一个串行设备读取数据，并将所有数据同步到一起。最后，我希望代码：

- read serial from laser
- read serial from gps
- get a single string with [gps_reading, laser_reading]

GPS的刷新率高达5赫兹 激光器可根据需要发送高达20赫兹左右的数值

在孤立的情况下，它们都工作得很好，我的反应速度也很快。然而，当我试图从一个以上的阅读，我得到了一个延迟，随着时间的推移。在

代码如下：

^{pr2}$

gps和激光功能只需发送适当的命令来请求数据： i、 e

#!/usr/bin/env python
# -*- coding: utf-8 -*- 
import serial

def lrf_getDistance(ser):
    i = 0
    while i == 0:
        ser.write("d\r\n")
        ser.flush()
        msg = ser.readline()
        try:
            msg = float(msg)
            i == 1
            return msg
        except ValueError:
            pass 

运行代码时，如果我注释掉'pos=gps.gps数据（gpsSerial）'和'print pos'“激光”设备的输出几乎是即时的。取消注释后，“激光”输出非常滞后。在

如果有关系，我在台式机上运行代码。在

有人能建议我怎样才能摆脱这种滞后吗？在

• 编辑：我已经更改了代码，以便在多个线程中运行这两个函数。下面的教程将介绍python中的多线程处理。在

新代码如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*- 

import serial
import time
import threading
import gps
import laser

#serial
def serialGeneric(device, baudRate):
    ser = serial.Serial(
    port=device,
    baudrate=baudRate,
    parity=serial.PARITY_NONE,
    stopbits=serial.STOPBITS_ONE,
    bytesize=serial.EIGHTBITS
    #timeout=0
    )
    return ser

#Device 1
gpsSerial = serialGeneric("/dev/ttyUSB0",9600)

#Device 2
laserSerial = serialGeneric("/dev/ttyUSB1",19200)

class myThreadGPS (threading.Thread):
    def __init__(self, ser):
        threading.Thread.__init__(self)
        self.ser = ser
    def run(self):
        print "Starting GPS"
        gps.gps_getDataINF(self.ser)

class myThreadLAS (threading.Thread):
    def __init__(self, ser):
        threading.Thread.__init__(self)
        self.ser = ser
    def run(self):
        print "Starting Laser"
        laser.lrf_getDistanceINF(self.ser)
# Create new threads
thread1 = myThreadGPS(gpsSerial)
thread2 = myThreadLAS(laserSerial)

# Start new Threads
thread1.start()
thread2.start()

正如评论中提到的，这“解决了”眼前的问题。不幸的是，我还是不明白为什么要这么做。在

Answer 1

对于每个线程，将有以下同步资源：

• 一个事件，指示循环何时结束，以及接收到的数据
• 一个共享变量，用于存储要打印的数据
• 指示何时可以开始新循环的另一个事件。在开始循环之前，每个线程都必须等待此标志，并且在两个线程结束各自的任务时将引发该标志。在

我没有彻底检查下面代码的语法，所以可能有一些语法错误。基本上，当线程都读取串行端口时，它们与主例程同步。当主例程允许开始一个新的循环时，它们再次并行读取端口。在

class myThreadGPS (threading.Thread):
    def __init__(self, ser, start_event, end_event, pos):
        threading.Thread.__init__(self)
        self.ser = ser
        self.start_event = start_event
        self.end_event = end_event
        self.pos = pos
    def run(self):
        self.start_event.wait()
        self.start_event.clear()
        print "Starting GPS"
        self.pos[0] = gps.gps_getDataINF(self.ser)
        self.end_event.set()

class myThreadLAS (threading.Thread):
    def __init__(self, ser, start_event, end_event, dis):
        threading.Thread.__init__(self)
        self.ser = ser
        self.start_event = start_event
        self.end_event = end_event
        self.dis = dis
    def run(self):
        self.start_event.wait()
        self.start_event.clear()
        print "Starting Laser"
        self.dis[0] = laser.lrf_getDistanceINF(self.ser)
        self.end_event.set()

#Declare the used events
gps_end_event = threading.Event()
laser_end_event = threading.Event()
gps_start_event = threading.Event()
laser_start_event = threading.Event()
#Initialize shared variables
pos = [None]
dis = [None]
# Create new threads
thread1 = myThreadGPS(gpsSerial, gps_start_event, gps_end_event, pos)
thread2 = myThreadLAS(laserSerial, laser_start_event, laser_end_event, dis)

# Start new Threads
thread1.start()
thread2.start()
#Start events initially set to True
gps_start_event.set()
laser_start_event.set()
while True:
    #Wait for both threads to end and reset them.
    gps_end_event.wait()
    gps_end_event.clear()
    laser_end_event.wait()
    laser_end_event.clear()
    #print the shared variables
    print pos[0]
    print dis[0]
    gps_start_event.set()
    laser_start_event.set()