ADD: Tests for making daisy packets

Author: AJ Keller

openbci/utils/parse.py

@@ -179,6 +179,76 @@ def transform_raw_data_packet_to_sample(self, raw_data):
 
         return sample
 
+    def make_daisy_sample_object_wifi(self, lower_sample_object, upper_sample_object):
+        pass
+
+    """
+    /**
+ * @description Used to make one sample object from two sample objects. The sample number of the new daisy sample will
+ *      be the upperSampleObject's sample number divded by 2. This allows us to preserve consecutive sample numbers that
+ *      flip over at 127 instead of 255 for an 8 channel. The daisySampleObject will also have one `channelData` array
+ *      with 16 elements inside it, with the lowerSampleObject in the lower indices and the upperSampleObject in the
+ *      upper set of indices. The auxData from both channels shall be captured in an object called `auxData` which
+ *      contains two arrays referenced by keys `lower` and `upper` for the `lowerSampleObject` and `upperSampleObject`,
+ *      respectively. The timestamps shall be averaged and moved into an object called `timestamp`. Further, the
+ *      un-averaged timestamps from the `lowerSampleObject` and `upperSampleObject` shall be placed into an object called
+ *      `_timestamps` which shall contain two keys `lower` and `upper` which contain the original timestamps for their
+ *      respective sampleObjects.
+ * @param lowerSampleObject {Object} - Lower 8 channels with odd sample number
+ * @param upperSampleObject {Object} - Upper 8 channels with even sample number
+ * @returns {Object} - The new merged daisy sample object
+ */
+function makeDaisySampleObjectWifi (lowerSampleObject, upperSampleObject) {
+  let daisySampleObject = {};
+
+  if (lowerSampleObject.hasOwnProperty('channelData')) {
+    daisySampleObject['channelData'] = lowerSampleObject.channelData.concat(upperSampleObject.channelData);
+  }
+
+  if (lowerSampleObject.hasOwnProperty('channelDataCounts')) {
+    daisySampleObject['channelDataCounts'] = lowerSampleObject.channelDataCounts.concat(upperSampleObject.channelDataCounts);
+  }
+
+  daisySampleObject['sampleNumber'] = upperSampleObject.sampleNumber;
+
+  daisySampleObject['auxData'] = {
+    'lower': lowerSampleObject.auxData,
+    'upper': upperSampleObject.auxData
+  };
+
+  if (lowerSampleObject.hasOwnProperty('timestamp')) {
+    daisySampleObject['timestamp'] = lowerSampleObject.timestamp;
+  }
+
+  daisySampleObject.stopByte = lowerSampleObject.stopByte;
+
+  daisySampleObject['_timestamps'] = {
+    'lower': lowerSampleObject.timestamp,
+    'upper': upperSampleObject.timestamp
+  };
+
+  if (lowerSampleObject.hasOwnProperty('accelData')) {
+    if (lowerSampleObject.accelData[0] > 0 || lowerSampleObject.accelData[1] > 0 || lowerSampleObject.accelData[2] > 0) {
+      daisySampleObject.accelData = lowerSampleObject.accelData;
+    } else {
+      daisySampleObject.accelData = upperSampleObject.accelData;
+    }
+  }
+
+  if (lowerSampleObject.hasOwnProperty('accelDataCounts')) {
+    if (lowerSampleObject.accelDataCounts[0] > 0 || lowerSampleObject.accelDataCounts[1] > 0 || lowerSampleObject.accelDataCounts[2] > 0) {
+      daisySampleObject.accelDataCounts = lowerSampleObject.accelDataCounts;
+    } else {
+      daisySampleObject.accelDataCounts = upperSampleObject.accelDataCounts;
+    }
+  }
+
+  daisySampleObject['valid'] = true;
+
+  return daisySampleObject;
+}
+    """
+
     """
     /**
  * @description Used transform raw data packets into fully qualified packets

openbci/utils/utilities.py

@@ -62,3 +62,33 @@ def sample_packet_impedance(channel_number):
 
 def sample_packet_user_defined():
     return bytearray([0xA0, 0x00, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, make_tail_byte_from_packet_type(k.OBCIStreamPacketUserDefinedType)]);
+
+
+def new_sample(sample_number):
+    sample_number = sample_number_normalize(sample_number)
+    return {
+        'start_byte': k.RAW_BYTE_START,
+        'sample_number': sample_number,
+        'channel_data': [],
+        'accel_data': [],
+        'aux_data': None,
+        'stop_byte': k.RAW_BYTE_STOP,
+        'board_time': 0,
+        'timestamp': 0,
+        'valid': True
+    }
+
+
+def new_sample_no_scale(sample_number):
+    sample_number = sample_number_normalize(sample_number)
+    return {
+        'start_byte': k.RAW_BYTE_START,
+        'sample_number': sample_number,
+        'channel_data_counts': [],
+        'accel_data_counts': [],
+        'aux_data': None,
+        'stop_byte': k.RAW_BYTE_STOP,
+        'board_time': 0,
+        'timestamp': 0,
+        'valid': True
+    }

openbci/wifi.py

@@ -59,6 +59,7 @@ def __init__(self, ip_address=None, shield_name=None, sample_rate=None, log=True
                  max_packets_to_skip=20, latency=10000, high_speed=True, ssdp_attempts=5,
                  num_channels=8):
         # these one are used
+        self.daisy = False
         self.high_speed = high_speed
         self.impedance = False
         self.ip_address = ip_address
@@ -159,10 +160,14 @@ def connect(self):
         gains = None
         if self.board_type == k.BOARD_CYTON:
             gains = [24, 24, 24, 24, 24, 24, 24, 24]
+            self.daisy = False
         elif self.board_type == k.BOARD_DAISY:
             gains = [24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24]
+            self.daisy = True
         elif self.board_type == k.BOARD_GANGLION:
             gains = [51, 51, 51, 51]
+            self.daisy = False
+        self.local_wifi_server.set_daisy(daisy=self.daisy)
         self.local_wifi_server.set_parser(ParseRaw(gains=gains, board_type=self.board_type))
 
         if self.high_speed:
@@ -448,7 +453,7 @@ def warn(self, text):
             # log how many packets where sent succesfully in between warnings
             if self.log_packet_count:
                 logging.info('Data packets received:' + str(self.log_packet_count))
-                self.log_packet_count = 0;
+                self.log_packet_count = 0
             logging.warning(text)
         print("Warning: %s" % text)
 
@@ -476,11 +481,13 @@ def reconnect(self):
 
 
 class WiFiShieldHandler(asyncore.dispatcher_with_send):
-    def __init__(self, sock, callback=None, high_speed=True, parser=None):
+    def __init__(self, sock, callback=None, high_speed=True,
+                 parser=None, daisy=False):
         asyncore.dispatcher_with_send.__init__(self, sock)
 
-        self.high_speed = high_speed
         self.callback = callback
+        self.high_speed = high_speed
+        self.last_odd_sample = None
         self.parser = parser if parser is not None else ParseRaw(gains=[24, 24, 24, 24, 24, 24, 24, 24])
 
     def handle_read(self):
@@ -494,6 +501,26 @@ def handle_read(self):
                 samples = self.parser.transform_raw_data_packets_to_sample(raw_data_packets=raw_data_packets)
 
                 for sample in samples:
+                    # if a daisy module is attached, wait to concatenate two samples (main board + daisy)
+                    #  before passing it to callback
+                    if self.daisy:
+                        # odd sample: daisy sample, save for later
+                        if ~sample.sample_number % 2:
+                            self.last_odd_sample = sample
+                        # even sample: concatenate and send if last sample was the fist part, otherwise drop the packet
+                        elif sample.sample_number - 1 == self.last_odd_sample.id:
+                            # the aux data will be the average between the two samples, as the channel
+                            # samples themselves have been averaged by the board
+                            avg_aux_data = list(
+                                (np.array(sample.aux_data) + np.array(self.last_odd_sample.aux_data)) / 2)
+                            whole_sample = OpenBCISample(sample.id,
+                                                         sample.channel_data + self.last_odd_sample.channel_data,
+                                                         avg_aux_data)
+                            for call in callback:
+                                call(whole_sample)
+                    else:
+                        for call in callback:
+                            call(sample)
                     if self.callback is not None:
                         self.callback(sample)
 
@@ -520,11 +547,12 @@ def handle_read(self):
 
 class WiFiShieldServer(asyncore.dispatcher):
 
-    def __init__(self, host, port, callback=None, gains=None, high_speed=True):
+    def __init__(self, host, port, callback=None, gains=None, high_speed=True, daisy=False):
         asyncore.dispatcher.__init__(self)
         self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
         self.set_reuse_addr()
         self.bind((host, port))
+        self.daisy = daisy
         self.listen(5)
         self.callback = None
         self.handler = None
@@ -536,13 +564,19 @@ def handle_accept(self):
         if pair is not None:
             sock, addr = pair
             print 'Incoming connection from %s' % repr(addr)
-            self.handler = WiFiShieldHandler(sock, self.callback, high_speed=self.high_speed, parser=self.parser)
+            self.handler = WiFiShieldHandler(sock, self.callback, high_speed=self.high_speed,
+                                             parser=self.parser, daisy=self.daisy)
 
     def set_callback(self, callback):
         self.callback = callback
         if self.handler is not None:
             self.handler.callback = callback
 
+    def set_daisy(self, daisy):
+        self.daisy = daisy
+        if self.handler is not None:
+            self.handler.daisy = daisy
+
     def set_gains(self, gains):
         self.parser.set_ads1299_scale_factors(gains)
 

tests/test_parse.py

@@ -2,6 +2,8 @@
 import mock
 
 from openbci.utils import (k,
+                           new_sample,
+                           new_sample_no_scale,
                            ParseRaw,
                            sample_packet,
                            sample_packet_standard_raw_aux,
@@ -245,6 +247,108 @@ def test_transform_raw_data_packets_to_sample(self):
         for i in range(len(samples)):
             self.assertEqual(samples[i].sample_number, i)
 
+    def test_make_daisy_sample_object_wifi(self):
+        parser = ParseRaw(gains=[24, 24, 24, 24, 24, 24, 24, 24])
+        # Make the lower sample(channels 1 - 8)
+        lower_sample_object = new_sample(1)
+        lower_sample_object.channel_data = [1, 2, 3, 4, 5, 6, 7, 8]
+        lower_sample_object.aux_data = [0, 1, 2]
+        lower_sample_object.timestamp = 4
+        lower_sample_object.accel_data = [0, 0, 0]
+        # Make the upper sample(channels 9 - 16)
+        upper_sample_object = new_sample(2)
+        upper_sample_object.channelData = [9, 10, 11, 12, 13, 14, 15, 16]
+        upper_sample_object.accelData = [0, 1, 2]
+        lower_sample_object.auxData = [3, 4, 5]
+        upper_sample_object.timestamp = 8
+
+        daisy_sample_object = parser.make_daisy_sample_object_wifi(lower_sample_object, upper_sample_object);
+
+        lower_sample_object_no_scale = new_sample(1)
+        lower_sample_object_no_scale.channelDataCounts = [1, 2, 3, 4, 5, 6, 7, 8]
+        lower_sample_object_no_scale.auxData = [0, 1, 2]
+        lower_sample_object_no_scale.accelDataCounts = [0, 0, 0]
+        lower_sample_object_no_scale.timestamp = 4
+
+        # Make the upper sample(channels 9 - 16)
+        upper_sample_object_no_scale = new_sample(2)
+        upper_sample_object_no_scale.channelDataCounts = [9, 10, 11, 12, 13, 14, 15, 16]
+        lower_sample_object_no_scale.accelDataCounts = [0, 1, 2]
+        upper_sample_object_no_scale.auxData = [3, 4, 5]
+        upper_sample_object_no_scale.timestamp = 8
+
+        # Call the function under test
+        daisy_sample_object_no_scale = parser.make_daisy_sample_object_wifi(lower_sample_object_no_scale,
+                                                                   upper_sample_object_no_scale)
+
+        # should have valid object true
+        self.assertTrue(daisy_sample_object.valid)
+        self.assertTrue(daisy_sample_object_no_scale.valid)
+
+        # should make a channelData array 16 elements long
+        self.assertEqual(len(daisy_sample_object.channel_data), k.NUMBER_OF_CHANNELS_DAISY)
+        self.assertEqual(len(daisy_sample_object_no_scale.channel_data_counts), k.NUMBER_OF_CHANNELS_DAISY)
+
+        # should make a channelData array with lower array in front of upper array
+        for i in range(16):
+            self.assertEqual(daisy_sample_object.channel_data[i], i + 1)
+            self.assertEqual(daisy_sample_object_no_scale.channel_data_counts[i], i + 1)
+
+        self.assertEqual(daisy_sample_object.sample_number, daisy_sample_object.sample_number)
+        self.assertEqual(daisy_sample_object_no_scale.sample_number, daisy_sample_object_no_scale.sample_number)
+
+        # should put the aux packets in an object
+        self.assertIsNotNone(daisy_sample_object.aux_data.lower)
+        self.assertIsNotNone(daisy_sample_object.aux_data.upper)
+        self.assertIsNotNone(daisy_sample_object_no_scale.aux_data.lower)
+        self.assertIsNotNone(daisy_sample_object_no_scale.aux_data.upper)
+
+        # should put the aux packets in an object in the right order
+        for i in range(3):
+            self.assertEqual(daisy_sample_object.aux_data['lower'][i], i)
+            self.assertEqual(daisy_sample_object.aux_data['upper'][i], i + 3)
+            self.assertEqual(daisy_sample_object_no_scale.aux_data['lower'][i], i)
+            self.assertEqual(daisy_sample_object_no_scale.aux_data['upper'][i], i + 3)
+
+        # should take the lower timestamp
+        self.assertEqual(daisy_sample_object.timestamp, lower_sample_object.timestamp)
+        self.assertEqual(daisy_sample_object_no_scale.timestamp, lower_sample_object.timestamp)
+
+        # should take the lower stopByte
+        self.assertEqual(daisy_sample_object.stop_byte, lower_sample_object.stop_byte)
+        self.assertEqual(daisy_sample_object_no_scale.stop_byte, lower_sample_object.stop_byte)
+
+        # should place the old timestamps in an object
+        self.assertEqual(daisy_sample_object._timestamps.lower, lower_sample_object.timestamp)
+        self.assertEqual(daisy_sample_object._timestamps.upper, upper_sample_object.timestamp)
+        self.assertEqual(daisy_sample_object_no_scale._timestamps.lower, lower_sample_object_no_scale.timestamp)
+        self.assertEqual(daisy_sample_object_no_scale._timestamps.upper, upper_sample_object_no_scale.timestamp)
+
+        # should store an accelerometer value if present
+        self.assertIsNotNone(daisy_sample_object.accel_data)
+        self.assertListEqual(daisy_sample_object.accel_data, [0, 1, 2])
+        self.assertIsNotNone(daisy_sample_object_no_scale.accel_data_counts)
+        self.assertListEqual(daisy_sample_object_no_scale.accel_data_counts, [0, 1, 2])
+
+        lower_sample = new_sample(1)
+        lower_sample.accel_data = [0, 1, 2]
+        upper_sample = new_sample(2)
+        upper_sample.accel_data = [0, 0, 0]
+
+        lower_sample_no_scale = new_sample_no_scale(1)
+        lower_sample_no_scale.accel_data_counts = [0, 1, 2]
+        upper_sample_no_scale = new_sample_no_scale(2)
+        upper_sample_no_scale.accel_data_counts = [0, 0, 0]
+
+        # Call the function under test
+        daisy_sample = parser.make_daisy_sample_object_wifi(lower_sample, upper_sample)
+        daisy_sample_no_scale = parser.make_daisy_sample_object_wifi(lower_sample_no_scale, upper_sample_no_scale)
+
+        self.assertIsNotNone(daisy_sample.accel_data)
+        self.assertListEqual(daisy_sample.accel_data, [0, 1, 2])
+        self.assertIsNotNone(daisy_sample_no_scale.accel_data_counts)
+        self.assertListEqual(daisy_sample_no_scale.accel_data_counts, [0, 1, 2])
+
 
 if __name__ == '__main__':
     main()