- Messages sent from pyboard to computer during framework run now all start with a special character (b'\x07') to indicate the start of the message. Any input that does not match the expected format is stored in an unexpected_input buffer and printed as a warning message in the log when the next valid message is recieved. This should make data transfer from the board more robust to any unexpected messages, and ensure that warnings on the board that do not crash the task (e.g. errors in interrupt service routines) do not fail silently.

Author: ThomasAkam

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
+        unexpected_input = []
         while self.serial.in_waiting > 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))
+            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:

pyControl/framework.py

@@ -192,13 +192,13 @@ def output_data(event):
         timestamp = event[0].to_bytes(4, 'little') 
         ID        = event[2].to_bytes(2, 'little')
         checksum  = sum(timestamp + ID).to_bytes(2, 'little') 
-        usb_serial.send(b'D' + timestamp + ID + checksum)
+        usb_serial.send(b'\x07D' + timestamp + ID + checksum)
     elif event[1] in (print_typ, varbl_typ): # send user generated output string.
         if event[1] == print_typ: # send user generated output string.
-            start_byte = b'P'
+            start_byte = b'\x07P'
             data_bytes = event[2].encode()
         elif event[1] == varbl_typ: # Variable changed.
-            start_byte = b'V'
+            start_byte = b'\x07V'
             data_bytes = event[2][0].encode() + b' ' + event[2][1].encode()
         data_len = len(data_bytes).to_bytes(2, 'little')  
         timestamp = event[0].to_bytes(4, 'little')

pyControl/hardware.py

@@ -236,8 +236,8 @@ class Analog_input(IO_object):
     # stream data to continously to computer as well as generate framework events when 
     # voltage goes above / below specified value. The Analog_input class is subclassed
     # by other hardware devices that generate continous data such as the Rotory_encoder.
-    # Serial data format for sending data to computer: 'A c i r l t k D' where:
-    # A character indicating start of analog data chunk (1 byte)
+    # Serial data format for sending data to computer: '\x07A c i r l t k D' where:
+    # \x07A Message start byte and A character indicating start of analog data chunk (2 bytes)
     # c data array typecode (1 byte)
     # i ID of analog input  (2 byte)
     # r sampling rate (Hz) (2 bytes)
@@ -269,7 +269,7 @@ def __init__(self, pin, name, sampling_rate, threshold=None, rising_event=None,
         self.buffers = (array(data_type, [0]*self.buffer_size),array(data_type, [0]*self.buffer_size))
         self.buffers_mv = (memoryview(self.buffers[0]), memoryview(self.buffers[1]))
         self.buffer_start_times = array('i', [0,0])
-        self.data_header = array('B', b'A' + data_type.encode() + 
+        self.data_header = array('B', b'\x07A' + data_type.encode() + 
             self.ID.to_bytes(2,'little') + sampling_rate.to_bytes(2,'little') + b'\x00'*8)
         # Event generation variables
         self.threshold = threshold
@@ -359,11 +359,11 @@ def _process_streaming(self):
     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
-        self.data_header[6:8]  = n_bytes.to_bytes(2,'little')
-        self.data_header[8:12] = self.buffer_start_times[buffer_n].to_bytes(4,'little')
+        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.data_header[1:12])
-        self.data_header[12:14] = checksum.to_bytes(2,'little')
+        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.
             fw.usb_serial.send(self.buffers_mv[buffer_n][:n_samples])