ADD: daisy high speed over wifo

Author: AJ Keller

CHANGELOG.md

@@ -11,6 +11,19 @@
 * Refactored library for pip
 * Moved plugins folder into openbci dir so plugins can be imported when installed with pip
 
+
+## Beta 0
+
+* Adds high speed for Daisy over WiFi - now all boards are supported!
+
+## Alpha 1
+
+* Adds high speed for Ganglion over WiFi
+
+## Alpha 0
+
+* Adds high speed for Cyton over WiFi
+
 # v0.1
 
 ## dev

openbci/utils/parse.py

@@ -180,74 +180,55 @@ 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);
-  }
+        """
+        /**
+         * @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
+         */
+        """
+        daisy_sample_object = OpenBCISample()
 
-  daisySampleObject['sampleNumber'] = upperSampleObject.sampleNumber;
+        if lower_sample_object.channel_data is not None:
+            daisy_sample_object.channel_data = lower_sample_object.channel_data + upper_sample_object.channel_data
 
-  daisySampleObject['auxData'] = {
-    'lower': lowerSampleObject.auxData,
-    'upper': upperSampleObject.auxData
-  };
+        daisy_sample_object.sample_number = upper_sample_object.sample_number
+        daisy_sample_object.id = daisy_sample_object.sample_number
 
-  if (lowerSampleObject.hasOwnProperty('timestamp')) {
-    daisySampleObject['timestamp'] = lowerSampleObject.timestamp;
-  }
+        daisy_sample_object.aux_data = {
+            'lower': lower_sample_object.aux_data,
+            'upper': upper_sample_object.aux_data
+        }
 
-  daisySampleObject.stopByte = lowerSampleObject.stopByte;
+        if lower_sample_object.timestamp:
+            daisy_sample_object.timestamp = lower_sample_object.timestamp
 
-  daisySampleObject['_timestamps'] = {
-    'lower': lowerSampleObject.timestamp,
-    'upper': upperSampleObject.timestamp
-  };
+        daisy_sample_object.stop_byte = lower_sample_object.stop_byte
 
-  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;
-    }
-  }
+        daisy_sample_object._timestamps = {
+            'lower': lower_sample_object.timestamp,
+            'upper': upper_sample_object.timestamp
+        }
 
-  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;
-    }
-  }
+        if lower_sample_object.accel_data is not None:
+            if lower_sample_object.accel_data[0] > 0 or lower_sample_object.accel_data[1] > 0 or lower_sample_object.accel_data[2] > 0:
+                daisy_sample_object.accel_data = lower_sample_object.accel_data
+            else:
+                daisy_sample_object.accel_data = upper_sample_object.accel_data
 
-  daisySampleObject['valid'] = true;
+        daisy_sample_object.valid = True
 
-  return daisySampleObject;
-}
-    """
+        return daisy_sample_object
 
     """
     /**
@@ -349,4 +330,6 @@ def __init__(self,
         self.sample_number = sample_number
         self.start_byte = start_byte
         self.stop_byte = stop_byte
+        self.timestamp = 0
+        self._timestamps = {}
         self.valid = valid

openbci/utils/utilities.py

@@ -62,33 +62,3 @@ 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

@@ -28,7 +28,7 @@ def handle_sample(sample):
 import requests
 import xmltodict
 
-from openbci.utils import k, ParseRaw, ssdp
+from openbci.utils import k, ParseRaw, OpenBCISample, ssdp
 
 SAMPLE_RATE = 0  # Hz
 
@@ -486,8 +486,9 @@ def __init__(self, sock, callback=None, high_speed=True,
         asyncore.dispatcher_with_send.__init__(self, sock)
 
         self.callback = callback
+        self.daisy = daisy
         self.high_speed = high_speed
-        self.last_odd_sample = None
+        self.last_odd_sample = OpenBCISample()
         self.parser = parser if parser is not None else ParseRaw(gains=[24, 24, 24, 24, 24, 24, 24, 24])
 
     def handle_read(self):
@@ -508,21 +509,15 @@ def handle_read(self):
                         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:
+                        elif sample.sample_number - 1 == self.last_odd_sample.sample_number:
                             # 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)
+                            daisy_sample = self.parser.make_daisy_sample_object_wifi(self.last_odd_sample, sample)
+                            if self.callback is not None:
+                                self.callback(daisy_sample)
                     else:
-                        for call in callback:
-                            call(sample)
-                    if self.callback is not None:
-                        self.callback(sample)
+                        if self.callback is not None:
+                            self.callback(sample)
 
             else:
                 try:

tests/test_parse.py

@@ -2,8 +2,7 @@
 import mock
 
 from openbci.utils import (k,
-                           new_sample,
-                           new_sample_no_scale,
+                           OpenBCISample,
                            ParseRaw,
                            sample_packet,
                            sample_packet_standard_raw_aux,
@@ -250,104 +249,66 @@ def test_transform_raw_data_packets_to_sample(self):
     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 = OpenBCISample(sample_number=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 = OpenBCISample(sample_number=2)
+        upper_sample_object.channel_data = [9, 10, 11, 12, 13, 14, 15, 16]
+        upper_sample_object.accel_data = [0, 1, 2]
+        upper_sample_object.aux_data = [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.id, daisy_sample_object.sample_number)
         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)
+        self.assertIsNotNone(daisy_sample_object.aux_data['lower'])
+        self.assertIsNotNone(daisy_sample_object.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)
+        self.assertEqual(daisy_sample_object._timestamps['lower'], lower_sample_object.timestamp)
+        self.assertEqual(daisy_sample_object._timestamps['upper'], upper_sample_object.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 = OpenBCISample(sample_number=1)
         lower_sample.accel_data = [0, 1, 2]
-        upper_sample = new_sample(2)
+        upper_sample = OpenBCISample(sample_number=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__':