Threading pattern for observation blocks

[dkozel]

The responsibility for running the observation lives with the individual observation blocks. This includes handling the timing between steps. Here's an example (pseudo Python) of how to launch a thread when the flowgraph starts to do this.

import threading
import time

def __init__():
	# register message port
	
	# Sanity check inputs
	if len(source_list) != len(duration_list):
		throw Exception
	
def trackscan_obs():
	command = pmt.make_dict()
	command = pmt.dict_add(command, ant_key, ant_val)
	command = pmt.dict_add(command, freq_key, freq_val)
	self.message_port_pub(pmt.intern("command"), command)
	# Frequency only set once, antennas reused
	command = pmt.dict_delete(command, freq_key)
	
	for i, duration in enumerate(duration_list):
		# for az/el case
		command = pmt.dict_add(command, az_key, az_val[i])
		command = pmt.dict_add(command, el_key, az_val[i])
		self.message_port_pub(pmt.intern("command"), command)
		
		time.sleep(duration)

	# Option 1: explicitly release antennas	
	command = pmt.make_dict()
	command = pmt.dict_add(command, ant_key, ant_val)
	command = pmt.dict_add(command, reserve_key, "release")
	
	# Option 2: tell command block to end observation and let it clean up
	command = pmt.make_dict()
	command = pmt.dict_add(command, status_key, "done")
	
	self.message_port_pub(pmt.intern("command"), command)

def start():
	# Launch a separate thread that will run the observation
	t = threading.Thread(target=trackscan_obs, args = (1,)
	t.start()
	
	return super().start()

def stop():
	# Wait for the observation to end
	# Ideally we'd let the observation thread know we want to exit immediately
	t.join()
	return super().stop()

[dkozel]

For the note about gracefully ending an observation in the middle I found this which looks reasonable, but I don't know if we need to make the entire thread class or can just use some of the ideas in the trackscan_obs function. This is mostly a note to myself.

import threading

class StoppableThread(threading.Thread):
    """Thread class with a stop() method. The thread itself has to check
    regularly for the stopped() condition."""

    def __init__(self,  *args, **kwargs):
        super(StoppableThread, self).__init__(*args, **kwargs)
        self._stop_event = threading.Event()

    def stop(self):
        self._stop_event.set()

    def stopped(self):
        return self._stop_event.is_set()