CODEWITHSUNDEEP
pythonpython-multiprocessingpyserial
WARhead
WARhead

Reputation: 691

Interrupt a pySerial readline in another thread

I am using pySerial to communicate to a microcontroller over USB, Most of the communication is initiated by the desktop python script which sends a command packet and waits for reply.

But there is also a alert packet that may be sent by the microcontroller without a command from the python script. In this case I need to monitor the read stream for any alerts.

For handling alerts, I dedicate a seperate process to call readline() and loop around it, like so:

    def serialMonitor(self):

        while not self.stopMonitor:
            self.lock.acquire()
            message = self.stream.readline()
            self.lock.release()
            self.callback(message)

inside a class. The function is then started in a seperate process by

self.monitor = multiprocessing.Process(target = SerialManager.serialMonitor, args = [self])

Whenever a command packet is send, the command function needs to take back control of the stream, for which it must interrupt the readline() call which is in blocking. How do I interrupt the readline() call? Is there any way to terminate a process safely?

Upvotes: 1

Views: 915

Answers (1)

2e0byo
2e0byo

Reputation: 5954

You can terminate a multiprocessing process with .terminate(). Is this safe? Probably it's alright for a readline case.

However, this is not how I would handle things here. As I read your scenario, there are two possibilities:

  • MCU initiates alert package
  • Computer sends data to MCU (and MCU perhaps responds)

I assume the MCU will not send an alert package whilst an exchange is going on initiated by the computer.

So I would just initiate the serial object with a small timeout, and leave it in a loop when I'm not using it. My overall flow would go like this:

ser = Serial(PORT, timeout=1)
response = None
command_to_send = None
running = True
while running: # event loop
    while running and not command_to_send and not line:
        try:
            line = ser.readline()
        except SerialTimeoutException:
            pass

    if not command_to_send:
        process_mcu_alert(line)

    else:
        send_command(command_to_send)
        command_to_send = None
        response = ser.readline()

This is only a sketch, as it would need to be run in a thread or subprocess, since readline() is indeed blocking, so you need some thread-safe way of setting command_to_send and running (used to exit gracefully) and getting response, and you likely want to wrap all this state up in a class. The precise implementation of that depends upon what you are doing, but the principle is the same---have one loop which handles reading and writing to the serial port, have it timeout to respond relatively quickly (you can set a smaller timeout if you need to), and have it expose some interface you can handle.

Sadly to my knowledge python has no asyncio compatible serial library, otherwise that approach would seem neater.

Upvotes: 2

Related Questions