Over hauling sample parseing

Author: AJ Keller

changelog.md

@@ -4,6 +4,10 @@
 
 * Could not use 'daisy' with sample rate setter.
 
+### New Features
+
+* Add function in utilities for making daisy packets.
+
 
 # 0.0.5
 

openBCIConstants.js

@@ -239,6 +239,7 @@ const obciBoardCyton = 'cyton';
 const obciBoardDaisy = 'daisy';
 const obciBoardDefault = 'default';
 const obciBoardGanglion = 'ganglion';
+const obciBoardNone = 'none';
 
 /** Possible Simulator Line Noise injections */
 const obciSimulatorLineNoiseHz60 = '60Hz';
@@ -885,12 +886,16 @@ module.exports = {
   OBCIBoardDaisy: obciBoardDaisy,
   OBCIBoardDefault: obciBoardDefault,
   OBCIBoardGanglion: obciBoardGanglion,
+  OBCIBoardNone: obciBoardNone,
   numberOfChannelsForBoardType: boardType => {
     switch (boardType) {
       case obciBoardDaisy:
         return obciNumberOfChannelsDaisy;
       case obciBoardGanglion:
         return obciNumberOfChannelsGanglion;
+      case obciBoardNone:
+        return 0;
+      case obciBoardCyton:
       default:
         return obciNumberOfChannelsDefault;
     }

openBCIUtilities.js

@@ -489,6 +489,7 @@ var utilitiesModule = {
     return new Buffer([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, makeTailByteFromPacketType(k.OBCIStreamPacketUserDefinedType)]);
   },
   makeDaisySampleObject,
+  makeDaisySampleObjectWifi,
   getChannelDataArray,
   isEven,
   isOdd,
@@ -1394,6 +1395,57 @@ function makeDaisySampleObject (lowerSampleObject, upperSampleObject) {
   return daisySampleObject;
 }
 
+/**
+ * @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) {
+  var 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['_timestamps'] = {
+    'lower': lowerSampleObject.timestamp,
+    'upper': upperSampleObject.timestamp
+  };
+
+  if (lowerSampleObject.accelData) {
+    daisySampleObject['accelData'] = lowerSampleObject.accelData;
+  } else if (upperSampleObject.accelData) {
+    daisySampleObject['accelData'] = upperSampleObject.accelData;
+  }
+
+  return daisySampleObject;
+}
+
 /**
 * @description Used to test a number to see if it is even
 * @param a {Number} - The number to test

test/openBCIConstants-test.js

@@ -967,6 +967,34 @@ describe('OpenBCIConstants', function () {
       expect(k.OBCIRadioPollTimeMin).to.be.equal(0);
     });
   });
+  describe('Board Types', function () {
+    it('should get right name for chan daisy', function () {
+      expect(k.OBCIBoardDaisy).to.equal("daisy");
+    });
+    it('should get right name for chan cyton', function () {
+      expect(k.OBCIBoardCyton).to.equal("cyton");
+    });
+    it('should get right name for chan ganglion', function () {
+      expect(k.OBCIBoardGanglion).to.equal("ganglion");
+    });
+    it('should get right name for chan none', function () {
+      expect(k.OBCIBoardNone).to.equal("none");
+    });
+  });
+  describe('numberOfChannelsForBoardTypes', function () {
+    it('should get right num chan for daisy board', function () {
+      expect(k.numberOfChannelsForBoardType(k.OBCIBoardDaisy)).to.equal(16);
+    });
+    it('should get right num chan for cyton board', function () {
+      expect(k.numberOfChannelsForBoardType(k.OBCIBoardCyton)).to.equal(8);
+    });
+    it('should get right num chan for ganglion', function () {
+      expect(k.numberOfChannelsForBoardType(k.OBCIBoardGanglion)).to.equal(4);
+    });
+    it('should get right num chan for none', function () {
+      expect(k.numberOfChannelsForBoardType(k.OBCIBoardNone)).to.equal(0);
+    });
+  });
   describe('#getChannelSetter', function () {
     // 'channel 1, power on, gain 24, inputType normal, bias include, srb2 connect, srb1 dissconnect'
     describe('channel input selection works', function () {

test/openBCIUtilities-test.js

@@ -917,6 +917,7 @@ describe('openBCIUtilities', function () {
   });
   describe('#makeDaisySampleObject', function () {
     let lowerSampleObject, upperSampleObject, daisySampleObject;
+    let lowerSampleObjectNoScale, upperSampleObjectNoScale, daisySampleObjectNoScale;
     before(() => {
       // Make the lower sample (channels 1-8)
       lowerSampleObject = openBCIUtilities.newSample(1);
@@ -930,37 +931,135 @@ describe('openBCIUtilities', function () {
       upperSampleObject.auxData = [3, 4, 5];
       upperSampleObject.timestamp = 8;
 
-      // Call the function under test
       daisySampleObject = openBCIUtilities.makeDaisySampleObject(lowerSampleObject, upperSampleObject);
+
+      // lowerSampleObjectNoScale = openBCIUtilities.newSample(1);
+      // lowerSampleObjectNoScale.channelDataCounts = [1, 2, 3, 4, 5, 6, 7, 8];
+      // lowerSampleObjectNoScale.auxData = [0, 1, 2];
+      // lowerSampleObjectNoScale.timestamp = 4;
+      // lowerSampleObjectNoScale.accelData = [0.5, -0.5, 1];
+      // // Make the upper sample (channels 9-16)
+      // upperSampleObjectNoScale = openBCIUtilities.newSample(2);
+      // upperSampleObjectNoScale.channelDataCounts = [9, 10, 11, 12, 13, 14, 15, 16];
+      // upperSampleObjectNoScale.auxData = [3, 4, 5];
+      // upperSampleObjectNoScale.timestamp = 8;
+      //
+      // // Call the function under test
+      // daisySampleObjectNoScale = openBCIUtilities.makeDaisySampleObject(lowerSampleObjectNoScale, upperSampleObjectNoScale);
     });
     it('should make a channelData array 16 elements long', function () {
       expect(daisySampleObject.channelData).to.have.length(k.OBCINumberOfChannelsDaisy);
+      // expect(daisySampleObjectNoScale.channelDataCounts).to.have.length(k.OBCINumberOfChannelsDaisy);
     });
     it('should make a channelData array with lower array in front of upper array', function () {
       for (let i = 0; i < 16; i++) {
         expect(daisySampleObject.channelData[i]).to.equal(i + 1);
+        // expect(daisySampleObjectNoScale.channelDataCounts[i]).to.equal(i + 1);
       }
     });
     it('should make the sample number equal to the second packet divided by two', function () {
       expect(daisySampleObject.sampleNumber).to.equal(upperSampleObject.sampleNumber / 2);
+      // expect(daisySampleObjectNoScale.sampleNumber).to.equal(upperSampleObject.sampleNumber / 2);
     });
     it('should put the aux packets in an object', function () {
       expect(daisySampleObject.auxData).to.have.property('lower');
       expect(daisySampleObject.auxData).to.have.property('upper');
+      // expect(daisySampleObjectNoScale.auxData).to.have.property('lower');
+      // expect(daisySampleObjectNoScale.auxData).to.have.property('upper');
     });
     it('should put the aux packets in an object in the right order', function () {
       for (let i = 0; i < 3; i++) {
         expect(daisySampleObject.auxData['lower'][i]).to.equal(i);
         expect(daisySampleObject.auxData['upper'][i]).to.equal(i + 3);
+        // expect(daisySampleObjectNoScale.auxData['lower'][i]).to.equal(i);
+        // expect(daisySampleObjectNoScale.auxData['upper'][i]).to.equal(i + 3);
       }
     });
     it('should average the two timestamps together', function () {
       let expectedAverage = (upperSampleObject.timestamp + lowerSampleObject.timestamp) / 2;
       expect(daisySampleObject.timestamp).to.equal(expectedAverage);
+      // expect(daisySampleObjectNoScale.timestamp).to.equal(expectedAverage);
+    });
+    it('should place the old timestamps in an object', function () {
+      expect(daisySampleObject._timestamps.lower).to.equal(lowerSampleObject.timestamp);
+      expect(daisySampleObject._timestamps.upper).to.equal(upperSampleObject.timestamp);
+      // expect(upperSampleObjectNoScale._timestamps.lower).to.equal(upperSampleObjectNoScale.timestamp);
+      // expect(upperSampleObjectNoScale._timestamps.upper).to.equal(upperSampleObjectNoScale.timestamp);
+    });
+    it('should store an accelerometer value if present', function () {
+      expect(daisySampleObject).to.have.property('accelData');
+    });
+  });
+
+  describe('#makeDaisySampleObjectWifi', function () {
+    let lowerSampleObject, upperSampleObject, daisySampleObject;
+    let lowerSampleObjectNoScale, upperSampleObjectNoScale, daisySampleObjectNoScale;
+    before(() => {
+      // Make the lower sample (channels 1-8)
+      lowerSampleObject = openBCIUtilities.newSample(1);
+      lowerSampleObject.channelData = [1, 2, 3, 4, 5, 6, 7, 8];
+      lowerSampleObject.auxData = [0, 1, 2];
+      lowerSampleObject.timestamp = 4;
+      lowerSampleObject.accelData = [0.5, -0.5, 1];
+      // Make the upper sample (channels 9-16)
+      upperSampleObject = openBCIUtilities.newSample(2);
+      upperSampleObject.channelData = [9, 10, 11, 12, 13, 14, 15, 16];
+      upperSampleObject.auxData = [3, 4, 5];
+      upperSampleObject.timestamp = 8;
+
+      daisySampleObject = openBCIUtilities.makeDaisySampleObjectWifi(lowerSampleObject, upperSampleObject);
+
+      lowerSampleObjectNoScale = openBCIUtilities.newSample(1);
+      lowerSampleObjectNoScale.channelDataCounts = [1, 2, 3, 4, 5, 6, 7, 8];
+      lowerSampleObjectNoScale.auxData = [0, 1, 2];
+      lowerSampleObjectNoScale.timestamp = 4;
+      lowerSampleObjectNoScale.accelData = [0.5, -0.5, 1];
+      // Make the upper sample (channels 9-16)
+      upperSampleObjectNoScale = openBCIUtilities.newSample(2);
+      upperSampleObjectNoScale.channelDataCounts = [9, 10, 11, 12, 13, 14, 15, 16];
+      upperSampleObjectNoScale.auxData = [3, 4, 5];
+      upperSampleObjectNoScale.timestamp = 8;
+
+      // Call the function under test
+      daisySampleObjectNoScale = openBCIUtilities.makeDaisySampleObjectWifi(lowerSampleObjectNoScale, upperSampleObjectNoScale);
+    });
+    it('should make a channelData array 16 elements long', function () {
+      expect(daisySampleObject.channelData).to.have.length(k.OBCINumberOfChannelsDaisy);
+      expect(daisySampleObjectNoScale.channelDataCounts).to.have.length(k.OBCINumberOfChannelsDaisy);
+    });
+    it('should make a channelData array with lower array in front of upper array', function () {
+      for (let i = 0; i < 16; i++) {
+        expect(daisySampleObject.channelData[i]).to.equal(i + 1);
+        expect(daisySampleObjectNoScale.channelDataCounts[i]).to.equal(i + 1);
+      }
+    });
+    it('should make the sample number equal to the second packet divided by two', function () {
+      expect(daisySampleObject.sampleNumber).to.equal(upperSampleObject.sampleNumber);
+      expect(daisySampleObjectNoScale.sampleNumber).to.equal(upperSampleObject.sampleNumber);
+    });
+    it('should put the aux packets in an object', function () {
+      expect(daisySampleObject.auxData).to.have.property('lower');
+      expect(daisySampleObject.auxData).to.have.property('upper');
+      expect(daisySampleObjectNoScale.auxData).to.have.property('lower');
+      expect(daisySampleObjectNoScale.auxData).to.have.property('upper');
+    });
+    it('should put the aux packets in an object in the right order', function () {
+      for (let i = 0; i < 3; i++) {
+        expect(daisySampleObject.auxData['lower'][i]).to.equal(i);
+        expect(daisySampleObject.auxData['upper'][i]).to.equal(i + 3);
+        expect(daisySampleObjectNoScale.auxData['lower'][i]).to.equal(i);
+        expect(daisySampleObjectNoScale.auxData['upper'][i]).to.equal(i + 3);
+      }
+    });
+    it('should take the lower timestamp', function () {
+      expect(daisySampleObject.timestamp).to.equal(lowerSampleObject.timestamp);
+      expect(daisySampleObjectNoScale.timestamp).to.equal(lowerSampleObject.timestamp);
     });
     it('should place the old timestamps in an object', function () {
       expect(daisySampleObject._timestamps.lower).to.equal(lowerSampleObject.timestamp);
       expect(daisySampleObject._timestamps.upper).to.equal(upperSampleObject.timestamp);
+      expect(daisySampleObjectNoScale._timestamps.lower).to.equal(lowerSampleObjectNoScale.timestamp);
+      expect(daisySampleObjectNoScale._timestamps.upper).to.equal(upperSampleObjectNoScale.timestamp);
     });
     it('should store an accelerometer value if present', function () {
       expect(daisySampleObject).to.have.property('accelData');