- Added Frame_trigger device which outputs pulses at a specified rate on a pin and saves the pulse times in an analog data file. It is designed for triggering camera frames or similar applications.

- Analog_channel now takes an optional 'plot' argument when initiated which determines whether the signal streamed back to the computer is plotted by the GUI.

- Fixed bug in analog channel where the sample timestamps were out by 1 sample, such that the timestamp for the 2nd sample was actually correct for the 1st sample etc.

Author: ThomasAkam

devices/frame_trigger.py

@@ -0,0 +1,32 @@
+import pyb
+import pyControl.hardware as hw
+import pyControl.utility as ut
+
+class Frame_trigger(hw.IO_object):
+
+    def __init__(self, pin, pulse_rate, name='frame_trigger'):
+        self.timer = pyb.Timer(hw.available_timers.pop())
+        self.pin = pyb.Pin(pin, mode=pyb.Pin.OUT, value=0)
+        self.name = name
+        self.pulse_rate = pulse_rate
+        self.analog_channel = hw.Analog_channel(name, pulse_rate, plot=False)
+        hw.assign_ID(self)
+
+    def _run_start(self):
+        self.pulse_n = 0
+        self.pinstate = False
+        self.pin.value(False)
+        self.timer.init(freq=2*self.pulse_rate) # Set timer to trigger subsequent pulses.
+        self.timer.callback(self.ISR)
+        ut.print('{} outputting pulses at {}Hz'.format(self.name, self.pulse_rate))
+
+    def _run_stop(self):
+        self.pin.value(False)
+        self.timer.deinit()
+
+    def ISR(self,t):
+        self.pinstate = not self.pinstate
+        self.pin.value(self.pinstate)
+        if self.pinstate:
+            self.pulse_n += 1
+            self.analog_channel.put(self.pulse_n)

gui/plotting.py

@@ -49,8 +49,7 @@ def set_state_machine(self, sm_info):
         self.states_plot.set_state_machine(sm_info)
         self.events_plot.set_state_machine(sm_info)
         self.analog_plot.set_state_machine(sm_info)
-
-        if sm_info['analog_inputs']:
+        if self.analog_plot.inputs:
             self.analog_plot.axis.setVisible(True)
             self.events_plot.axis.getAxis('bottom').setLabel('')
         else:
@@ -210,12 +209,12 @@ def __init__(self, parent=None, data_dur=10):
         self.axis.setLimits(xMax=0)
 
     def set_state_machine(self, sm_info):
-        self.inputs = sm_info['analog_inputs']
+        self.inputs = {ID: ai for ID,ai in sm_info['analog_inputs'].items() if ai['plot']}
         if not self.inputs: return # State machine may not have analog inputs.
         self.axis.clear()
         self.legend = self.axis.addLegend(offset=(10, 10))
-        self.plots = {ai['ID']: self.axis.plot(name=name, 
-                      pen=pg.mkPen(pg.intColor(i,len(self.inputs)))) for i, (name, ai) in enumerate(sorted(self.inputs.items()))}
+        self.plots = {ai['ID']: self.axis.plot(name=name, pen=pg.mkPen(pg.intColor(i,len(self.inputs))))
+                      for i, (name, ai) in enumerate(sorted(self.inputs.items()))}
         self.axis.getAxis('bottom').setLabel('Time (seconds)')
         max_len = max([len(n) for n in list(sm_info['states'])+list(sm_info['events'])])
         self.axis.getAxis('right').setWidth(5*max_len)

pyControl/framework.py

@@ -153,7 +153,7 @@ def run():
             recieve_data()
         # Priority 6: Stream analog data.
         elif hw.stream_data_queue.available: 
-            hw.IO_dict[hw.stream_data_queue.get()]._process_streaming()
+            hw.IO_dict[hw.stream_data_queue.get()].send_buffer()
         # Priority 7: Output framework data.
         elif data_output_queue.available: 
             output_data(data_output_queue.get())

pyControl/hardware.py

@@ -91,7 +91,7 @@ def off():
 
 def get_analog_inputs():
     # Print dict of analog inputs {name: {'ID': ID, 'Fs':sampling rate}}
-    print({io.name:{'ID': io.ID, 'Fs': io.sampling_rate}
+    print({io.name:{'ID': io.ID, 'Fs': io.sampling_rate, 'plot': io.plot}
           for io in IO_dict.values() if isinstance(io, Analog_channel)})
 
 # IO_object -------------------------------------------------------------------
@@ -233,8 +233,7 @@ def __init__(self, pin, name, sampling_rate, threshold=None, rising_event=None,
     def _run_start(self):
         self.timer.init(freq=self.Analog_channel.sampling_rate)
         self.timer.callback(self._timer_ISR)
-        if self.threshold:
-            self.threshold.run_start(self.read_sample())
+        self.threshold.run_start(self.read_sample())
 
     def _run_stop(self):
         self.timer.deinit()
@@ -265,14 +264,15 @@ class Analog_channel(IO_object):
     # k checksum (2 bytes)
     # D data array bytes (variable)
 
-    def __init__(self, name, sampling_rate, data_type='l'):
+    def __init__(self, name, sampling_rate, data_type='l', plot=True):
         assert data_type in ('b','B','h','H','l','L'), 'Invalid data_type.'
         assert not any([name == io.name for io in IO_dict.values() 
                         if isinstance(io, Analog_channel)]), 'Analog signals must have unique names.'
         self.name = name
         assign_ID(self)
         self.sampling_rate = sampling_rate
         self.data_type = data_type
+        self.plot = plot
         self.bytes_per_sample = {'b':1,'B':1,'h':2,'H':2,'l':4,'L':4}[data_type]
         self.buffer_size = max(4, min(256 // self.bytes_per_sample, sampling_rate//10))
         self.buffers = (array(data_type, [0]*self.buffer_size), array(data_type, [0]*self.buffer_size))
@@ -285,38 +285,41 @@ def __init__(self, name, sampling_rate, data_type='l'):
 
     def _run_start(self):
         self.write_index = 0  # Buffer index to write new data to. 
-        self.buffer_start_times[self.write_buffer] = fw.current_time
 
     def _run_stop(self):
         if self.write_index != 0:
-            self._send_buffer(self.write_buffer, self.write_index)
+            self.send_buffer(run_stop=True)
 
     @micropython.native
     def put(self, sample: int):
-        # load the buffer.
+        # Put a sample in the buffer.
+        if self.write_index == 0: # Record buffer start timestamp.
+            self.buffer_start_times[self.write_buffer] = fw.current_time
         self.buffers[self.write_buffer][self.write_index] = sample
         self.write_index = (self.write_index + 1) % self.buffer_size
         if self.write_index == 0: # Buffer full, switch buffers.
             self.write_buffer = 1 - self.write_buffer
-            self.buffer_start_times[self.write_buffer] = fw.current_time
             stream_data_queue.put(self.ID)
 
-    def _process_streaming(self):
-        # Stream full buffer to computer.
-        self._send_buffer(1-self.write_buffer)
-
-    def _send_buffer(self, buffer_n, n_samples=False):
-        # Send specified buffer to host computer.
-        n_bytes = self.bytes_per_sample*n_samples if n_samples else self.bytes_per_sample*self.buffer_size
+    @micropython.native
+    def send_buffer(self, run_stop=False):
+        # Send buffer to host computer. 
+        if run_stop: # Send the contents of the current write buffer.
+            buffer_n = self.write_buffer
+            n_samples = self.write_index
+        else: # Send the buffer not currently being written to.
+            buffer_n = 1-self.write_buffer
+            n_samples = self.buffer_size
+        n_bytes = self.bytes_per_sample*n_samples
         self.data_header[7:9]  = n_bytes.to_bytes(2,'little')
         self.data_header[9:13] = self.buffer_start_times[buffer_n].to_bytes(4,'little')
-        checksum = sum(self.buffers_mv[buffer_n][:n_samples] if n_samples else self.buffers[buffer_n])
+        checksum = sum(self.buffers_mv[buffer_n][:n_samples] if run_stop else self.buffers[buffer_n])
         checksum += sum(self.data_header[2:13])
         self.data_header[13:15] = checksum.to_bytes(2,'little')
         fw.usb_serial.write(self.data_header)
-        if n_samples: # Send first n_samples from buffer.
+        if run_stop:
             fw.usb_serial.send(self.buffers_mv[buffer_n][:n_samples])
-        else: # Send entire buffer.
+        else:
             fw.usb_serial.send(self.buffers[buffer_n])
 
 class Analog_threshold(IO_object):