串行通讯和队列问题

Question

I've some problems creating a multi-process serial logger. The plan: Having a seperate process reading from serial port, putting data into a queue. The main process reads the entire queue after some time and processes the data.

But I'm not sure if this is the right way to do it, because sometimes the data is not in the right order. It works well for slow communication.

Do I have to lock something?! Is there a smarter way to do this?

import time
import serial
from multiprocessing import Process, Queue

def myProcess(q):
    with serial.Serial("COM2", 115200, 8, "E", 1, timeout=None) as ser:
        while True:
            q.put("%02X" % ser.read(1)[0])



if __name__=='__main__':
    try:
        q = Queue()
        p = Process(target=myProcess, args=(q,))
        p.daemon = True
        p.start()
        data = []
        while True:
            print(q.qsize()) #!debug
            while not q.empty(): #get all data from queue
                data.append(q.get())
            #proc_data(data) #data processing
            time.sleep(1)    #emulate data processing
            del data[:]      #clear buffer
    except KeyboardInterrupt:
        print("clean-up") #!debug
        p.join()

Update: I tried another version based on threads (see code below), but with the same effect/problem. The carry-over works fine, but one byte 'between' the carry-over and the new data is always gone -> The script will miss the byte when main reads the queue?!

import time, serial, threading, queue

def read_port(q):
    with serial.Serial("COM2", 19200, 8, "E", 1, timeout=None) as ser:
        while t.is_alive():
            q.put("%02X" % ser.read(1)[0])

def proc_data(data, crc):
    #processing data here
    carry = data[len(data)/2:] #DEBUG: emulate result (return last half of data)
    return carry

if __name__=='__main__':
    try:
        q = queue.Queue()
        t = threading.Thread(target=read_port, args=(q,))
        t.daemon = True
        t.start()

        data = []
        while True:
            try:
                while True:
                    data.append(q.get_nowait()) #get all data from queue
            except queue.Empty:
                pass
            print(data) #DEBUG: show carry-over + new data
            data = proc_data(data) #process data and store carry-over
            print(data) #DEBUG: show new carry-over
            time.sleep(1) #DEBUG: emulate processing time

    except KeyboardInterrupt:
        print("clean-up")
        t.join(0)

Answer 1

Consider the following code.

1) the two processes are siblings; the parent just sets them up then waits for control-C to interrupt everything

2) one proc puts raw bytes on the shared queue

3) other proc blocks for the first byte of data. When it gets the first byte, it then grabs the rest of the data, outputs it in hex, then continues.

4) parent proc just sets up others then waits for interrupt using signal.pause()

Note that with multiprocessing , the qsize() (and probably empty() ) functions are unreliable -- thus the above code will reliably grab your data.

source

import signal, time
import serial
from multiprocessing import Process, Queue

def read_port(q):
    with serial.Serial("COM2", 115200, 8, "E", 1, timeout=None) as ser:
        while True:
            q.put( ser.read(1)[0] )

def show_data(q):
    while True:
        # block for first byte of data
        data = [ q.get() ]
        # consume more data if available
        try:
            while True:
                data.append( q.get_nowait() )
        except Queue.Empty:
            pass
        print 'got:', ":".join("{:02x}".format(ord(c)) for c in data)

if __name__=='__main__':
    try:
        q = Queue()
        Process(target=read_port, args=(q,)).start()
        Process(target=show_data, args=(q,)).start()

        signal.pause()          # wait for interrupt

    except KeyboardInterrupt:
        print("clean-up") #!debug