Merge branch 'dev'

Author: ThomasAkam

com/pyboard.py

@@ -45,7 +45,7 @@ def read_until(self, min_num_bytes, ending, timeout=10, data_consumer=None):
         while True:
             if data.endswith(ending):
                 break
-            elif self.serial.inWaiting() > 0:
+            elif self.serial.in_waiting > 0:
                 new_data = self.serial.read(1)
                 data = data + new_data
                 if data_consumer:
@@ -61,10 +61,10 @@ def read_until(self, min_num_bytes, ending, timeout=10, data_consumer=None):
     def enter_raw_repl(self):
         self.serial.write(b'\r\x03\x03') # ctrl-C twice: interrupt any running program
         # flush input (without relying on serial.flushInput())
-        n = self.serial.inWaiting()
+        n = self.serial.in_waiting
         while n > 0:
             self.serial.read(n)
-            n = self.serial.inWaiting()
+            n = self.serial.in_waiting
         self.serial.write(b'\r\x01') # ctrl-A: enter raw REPL
         data = self.read_until(1, b'to exit\r\n>')
         if not data.endswith(b'raw REPL; CTRL-B to exit\r\n>'):

com/pycboard.py

@@ -348,53 +348,64 @@ def process_data(self):
         pass new_data to data_logger and print_func if specified, return new_data.'''
         new_data = []
         error_message = None
-        while self.serial.inWaiting() > 0:
-            new_byte = self.serial.read(1)  
-            if new_byte == b'A': # Analog data, 13 byte header + variable size content.
-                data_header = self.serial.read(13)
-                typecode      = data_header[0:1].decode() 
-                if typecode not in ('b','B','h','H','l','L'):
-                    new_data.append(('!','bad typecode A'))
-                    continue   
-                ID            = int.from_bytes(data_header[1:3], 'little')
-                sampling_rate = int.from_bytes(data_header[3:5], 'little')
-                data_len      = int.from_bytes(data_header[5:7], 'little')
-                timestamp     = int.from_bytes(data_header[7:11], 'little')
-                checksum      = int.from_bytes(data_header[11:13], 'little')
-                data_array    = array(typecode, self.serial.read(data_len))
-                if checksum == (sum(data_header[:-2]) + sum(data_array)) & 0xffff: # Checksum OK.
-                    new_data.append(('A',ID, sampling_rate, timestamp, data_array))
+        unexpected_input = []
+        while self.serial.in_waiting > 0:
+            new_byte = self.serial.read(1)
+            if new_byte == b'\x07':   # Start of pyControl message.  
+                if unexpected_input: # Output any unexpected characters recived prior to message start.
+                    new_data.append(('!','Unexpected input recieved from board: ' +
+                                         ''.join(unexpected_input)))
+                    unexpected_input = []
+                type_byte = self.serial.read(1) # Message type identifier.
+                if type_byte == b'A': # Analog data, 13 byte header + variable size content.
+                    data_header = self.serial.read(13)
+                    typecode      = data_header[0:1].decode() 
+                    if typecode not in ('b','B','h','H','l','L'):
+                        new_data.append(('!','bad typecode A'))
+                        continue   
+                    ID            = int.from_bytes(data_header[1:3], 'little')
+                    sampling_rate = int.from_bytes(data_header[3:5], 'little')
+                    data_len      = int.from_bytes(data_header[5:7], 'little')
+                    timestamp     = int.from_bytes(data_header[7:11], 'little')
+                    checksum      = int.from_bytes(data_header[11:13], 'little')
+                    data_array    = array(typecode, self.serial.read(data_len))
+                    if checksum == (sum(data_header[:-2]) + sum(data_array)) & 0xffff: # Checksum OK.
+                        new_data.append(('A',ID, sampling_rate, timestamp, data_array))
+                    else:
+                        new_data.append(('!','bad checksum A'))
+                elif type_byte == b'D': # Event or state entry, 8 byte data header only.
+                    data_header = self.serial.read(8)
+                    timestamp = int.from_bytes(data_header[ :4], 'little')
+                    ID        = int.from_bytes(data_header[4:6], 'little')
+                    checksum  = int.from_bytes(data_header[6:8], 'little')
+                    if checksum == sum(data_header[:-2]): # Checksum OK.
+                        new_data.append(('D',timestamp, ID))
+                    else:
+                        new_data.append(('!','bad checksum D'))
+                elif type_byte in (b'P', b'V'): # User print statement or set variable, 8 byte data header + variable size content.
+                    data_header = self.serial.read(8)
+                    data_len  = int.from_bytes(data_header[ :2], 'little')
+                    timestamp = int.from_bytes(data_header[2:6], 'little')
+                    checksum  = int.from_bytes(data_header[6:8], 'little')
+                    data_bytes = self.serial.read(data_len)
+                    if not checksum == (sum(data_header[:-2]) + sum(data_bytes)) & 0xffff: # Bad checksum.
+                        new_data.append(('!','bad checksum ' + type_byte.decode()))
+                        continue
+                    new_data.append((type_byte.decode(),timestamp, data_bytes.decode()))
+                    if type_byte == b'V': # Store new variable value in sm_info
+                        v_name, v_str = data_bytes.decode().split(' ', 1)
+                        self.sm_info['variables'][v_name] = eval(v_str)
                 else:
-                    new_data.append(('!','bad checksum A'))
-            elif new_byte == b'D': # Event or state entry, 8 byte data header only.
-                data_header = self.serial.read(8)
-                timestamp = int.from_bytes(data_header[ :4], 'little')
-                ID        = int.from_bytes(data_header[4:6], 'little')
-                checksum  = int.from_bytes(data_header[6:8], 'little')
-                if checksum == sum(data_header[:-2]): # Checksum OK.
-                    new_data.append(('D',timestamp, ID))
-                else:
-                    new_data.append(('!','bad checksum D'))
-            elif new_byte in (b'P', b'V'): # User print statement or set variable, 8 byte data header + variable size content.
-                data_header = self.serial.read(8)
-                data_len  = int.from_bytes(data_header[ :2], 'little')
-                timestamp = int.from_bytes(data_header[2:6], 'little')
-                checksum  = int.from_bytes(data_header[6:8], 'little')
-                data_bytes = self.serial.read(data_len)
-                if not checksum == (sum(data_header[:-2]) + sum(data_bytes)) & 0xffff: # Bad checksum.
-                    new_data.append(('!','bad checksum ' + new_byte.decode()))
-                    continue
-                new_data.append((new_byte.decode(),timestamp, data_bytes.decode()))
-                if new_byte == b'V': # Store new variable value in sm_info
-                    v_name, v_str = data_bytes.decode().split(' ', 1)
-                    self.sm_info['variables'][v_name] = eval(v_str)
+                    unexpected_input.append(type_byte.decode())
             elif new_byte == b'\x04': # End of framework run.
                 self.framework_running = False
                 data_err = self.read_until(2, b'\x04>', timeout=10) 
                 if len(data_err) > 2:
                     error_message = data_err[:-3].decode()
                     new_data.append(('!', error_message))                
                 break
+            else:
+                unexpected_input.append(new_byte.decode())
         if new_data and self.data_logger:
             self.data_logger.process_data(new_data)
         if error_message:

config/gui_settings.py

@@ -2,8 +2,11 @@
 
 VERSION = '1.6'
 
-update_interval = 20 # Interval between calls to the GUIs update function (ms).
+update_interval = 10 # Interval between calls to the GUIs update function (ms).
 
 event_history_len  = 200  # Length of event history to plot (# events).
 state_history_len  = 100  # Length of state history to plot (# states). 
-analog_history_dur = 12   # Duration of analog signal history to plot (seconds).
+analog_history_dur = 12   # Duration of analog signal history to plot (seconds).
+
+ui_font_size  = 11  # Font size of UI elements (button text, label text etc.).
+log_font_size = 9   # Font size of the data log.

gui/GUI_main.py

@@ -6,7 +6,7 @@
 from pyqtgraph.Qt import QtGui, QtCore
 
 from config.paths import dirs
-from config.gui_settings import  VERSION
+from config.gui_settings import  VERSION, ui_font_size
 from gui.run_task_tab import Run_task_tab
 from gui.dialogs import Board_config_dialog, Keyboard_shortcuts_dialog, Paths_dialog
 from gui.configure_experiment_tab import Configure_experiment_tab
@@ -188,6 +188,10 @@ def excepthook(self, ex_type, ex_value, ex_traceback):
 def launch_GUI():
     '''Launch the pyControl GUI.'''
     app = QtGui.QApplication(sys.argv)
+    app.setStyle('Fusion')
+    font = QtGui.QFont()
+    font.setPixelSize(ui_font_size)
+    app.setFont(font)
     gui_main = GUI_main()
     gui_main.app = app # To allow app functions to be called from GUI.
     sys.excepthook = gui_main.excepthook

gui/plotting.py

@@ -2,7 +2,7 @@
 import numpy as np
 from datetime import timedelta
 import pyqtgraph as pg
-from pyqtgraph.Qt import QtGui, QtWidgets
+from pyqtgraph.Qt import QtGui
 from PyQt5.QtCore import Qt
 
 from config.gui_settings import event_history_len, state_history_len, analog_history_dur
@@ -114,34 +114,28 @@ def run_start(self):
         self.data = np.zeros([self.data_len*2, 2], int)
         for plot in self.plots.values():
             plot.clear()
-        self.cs = self.state_IDs[0]
-        self.updated_states = []
 
     def process_data(self, new_data):
         '''Store new data from board'''
         new_states = [nd for nd in new_data if nd[0] == 'D' and nd[2] in self.state_IDs]
-        self.updated_states = [self.cs]
         if new_states:
             n_new =len(new_states)
             self.data = np.roll(self.data, -2*n_new, axis=0)
             for i, ns in enumerate(new_states): # Update data array.
                 timestamp, ID = ns[1:]
-                self.updated_states.append(ID)
                 j = 2*(-n_new+i)  # Index of state entry in self.data
                 self.data[j-1:,0] = timestamp
                 self.data[j:  ,1] = ID  
-            self.cs = ID
 
     def update(self, run_time):
         '''Update plots.'''
-        self.data[-1,0] = 1000*run_time # Update exit time of current state to current time.
-        for us in self.updated_states: # Set data for updated state plots.
-            state_data = self.data[self.data[:,1]==us,:]
-            timestamps, ID = (state_data[:,0]/1000, state_data[:,1])
-            self.plots[us].setData(x=timestamps, y=ID, connect='pairs')
-        # Shift all state plots.
-        for plot in self.plots.values():
-            plot.setPos(-run_time, 0)
+        self.data[-1,0] = run_time*1000 # Update exit time of current state to current time.
+        for ID in self.state_IDs:
+            state_data = self.data[self.data[:,1]==ID,:]
+            timestamps, IDs = (state_data[:,0]/1000-run_time, state_data[:,1])
+            if timestamps.size > 0:
+                self.plots[ID].setData(x=timestamps, y=IDs, connect='pairs')
+
 
 # Events_plot--------------------------------------------------------
 
@@ -187,10 +181,8 @@ def process_data(self, new_data):
 
     def update(self, run_time):
         '''Update plots'''
-        # Should not need to setData but setPos does not cause redraw otherwise.
         if not self.event_IDs: return
-        self.plot.setData(self.data, symbolBrush=[pg.intColor(ID) for ID in self.data[:,1]])
-        self.plot.setPos(-run_time, 0)
+        self.plot.setData(x=self.data[:,0]-run_time, y=self.data[:,1], symbolBrush=[pg.intColor(ID) for ID in self.data[:,1]])
 
 # ------------------------------------------------------------------------------------------
 
@@ -205,15 +197,12 @@ def __init__(self, parent=None, data_dur=10):
         self.axis.setMouseEnabled(x=True,y=False)
         self.axis.showGrid(x=True,alpha=0.75)
         self.axis.setLimits(xMax=0)
-        self.legend = None 
 
     def set_state_machine(self, sm_info):
         self.inputs = sm_info['analog_inputs']
         if not self.inputs: return # State machine may not have analog inputs.
-        if self.legend:
-            self.legend.close()
-        self.legend = self.axis.addLegend(offset=(10, 10))
         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(ai['ID'],len(self.inputs)))) for name, ai in sorted(self.inputs.items())}
         self.axis.getAxis('bottom').setLabel('Time (seconds)')
@@ -232,7 +221,6 @@ def process_data(self, new_data):
         '''Store new data from board.'''
         if not self.inputs: return # State machine may not have analog inputs.
         new_analog = [nd for nd in new_data if nd[0] == 'A']
-        self.updated_inputs = [na[1] for na in new_analog]
         for na in new_analog:
             ID, sampling_rate, timestamp, data_array = na[1:]
             new_len = len(data_array)
@@ -243,10 +231,9 @@ def process_data(self, new_data):
     def update(self, run_time):
         '''Update plots.'''
         if not self.inputs: return # State machine may not have analog inputs.
-        for ID in self.updated_inputs:
-            self.plots[ID].setData(self.data[ID])
-        for plot in self.plots.values():
-            plot.setPos(-run_time, 0)   
+        for ai in self.inputs.values():
+            ID = ai['ID']
+            self.plots[ID].setData(x=self.data[ID][:,0]-run_time, y=self.data[ID][:,1])
 
 # -----------------------------------------------------