Merge pull request #15 from aj-ptw/development

Development

Author: AJ Keller

changelog.md

@@ -1,3 +1,13 @@
+# 0.2.1
+
+### Bug Fixes
+
+* Accel data with counts did not work for cyton with daisy. Also fixed up some test errors with the effected functions.
+
+### New Features
+
+* Add features for `openbci-ganglion`
+
 # 0.2.0
 
 ### New Feature

openBCIUtilities.js

@@ -141,6 +141,7 @@ let utilitiesModule = {
   },
   transformRawDataPacketToSample,
   transformRawDataPacketsToSample,
+  convertGanglionArrayToBuffer,
   getRawPacketType,
   getFromTimePacketAccel,
   getFromTimePacketTime,
@@ -382,6 +383,7 @@ let utilitiesModule = {
     }
   },
   newSample,
+  newSampleNoScale,
   /**
   * @description Create a configurable function to return samples for a simulator. This implements 1/f filtering injection to create more brain like data.
   * @param numberOfChannels {Number} - The number of channels in the sample... either 8 or 16
@@ -1041,6 +1043,18 @@ function transformRawDataPacketToSample (o) {
   return sample;
 }
 
+/**
+ * Used to convert a ganglions decompressed back into a buffer
+ * @param arr {Array} - An array of four numbers
+ * @param data {Buffer} - A buffer to store into
+ */
+function convertGanglionArrayToBuffer (arr, data) {
+  for (let i = 0; i < k.OBCINumberOfChannelsGanglion; i++) {
+    data.writeInt16BE(arr[i] >> 8, (i * 3));
+    data.writeInt8(arr[i] & 255, (i * 3) + 2);
+  }
+}
+
 /**
  * @description This function takes a raw data buffer of 4 3-byte signed integers for ganglion
  * @param o {Object} - The input object
@@ -1643,6 +1657,26 @@ function newSample (sampleNumber) {
   };
 }
 
+function newSampleNoScale (sampleNumber) {
+  if (sampleNumber || sampleNumber === 0) {
+    if (sampleNumber > 255) {
+      sampleNumber = 255;
+    }
+  } else {
+    sampleNumber = 0;
+  }
+  return {
+    startByte: k.OBCIByteStart,
+    sampleNumber: sampleNumber,
+    channelDataCounts: [],
+    accelDataCounts: [],
+    auxData: null,
+    stopByte: k.OBCIByteStop,
+    boardTime: 0,
+    timestamp: 0
+  };
+}
+
 /**
 * @description Convert float number into three byte buffer. This is the opposite of .interpret24bitAsInt32()
 * @param float - The number you want to convert
@@ -1705,34 +1739,42 @@ function makeDaisySampleObject (lowerSampleObject, upperSampleObject) {
   let daisySampleObject = {};
 
   if (lowerSampleObject.hasOwnProperty('channelData')) {
-    daisySampleObject['channelData'] = lowerSampleObject.channelData.concat(upperSampleObject.channelData);
+    daisySampleObject.channelData = lowerSampleObject.channelData.concat(upperSampleObject.channelData);
   }
 
   if (lowerSampleObject.hasOwnProperty('channelDataCounts')) {
-    daisySampleObject['channelDataCounts'] = lowerSampleObject.channelDataCounts.concat(upperSampleObject.channelDataCounts);
+    daisySampleObject.channelDataCounts = lowerSampleObject.channelDataCounts.concat(upperSampleObject.channelDataCounts);
   }
 
-  daisySampleObject['sampleNumber'] = Math.floor(upperSampleObject.sampleNumber / 2);
+  daisySampleObject.sampleNumber = Math.floor(upperSampleObject.sampleNumber / 2);
 
-  daisySampleObject['auxData'] = {
+  daisySampleObject.auxData = {
     'lower': lowerSampleObject.auxData,
     'upper': upperSampleObject.auxData
   };
 
-  daisySampleObject['timestamp'] = (lowerSampleObject.timestamp + upperSampleObject.timestamp) / 2;
+  daisySampleObject.timestamp = (lowerSampleObject.timestamp + upperSampleObject.timestamp) / 2;
 
   daisySampleObject['_timestamps'] = {
     'lower': lowerSampleObject.timestamp,
     'upper': upperSampleObject.timestamp
   };
 
-  if (lowerSampleObject.accelData) {
-    daisySampleObject['accelData'] = lowerSampleObject.accelData;
-  } else if (upperSampleObject.accelData) {
-    daisySampleObject['accelData'] = upperSampleObject.accelData;
+  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;
+    }
+  } else 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;
+  daisySampleObject.valid = true;
 
   return daisySampleObject;
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbci-utilities",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "The official utility package of Node.js SDK for the OpenBCI Biosensor Boards.",
   "main": "index.js",
   "scripts": {

test/openBCIUtilities-test.js

@@ -37,6 +37,83 @@ describe('openBCIUtilities', function () {
     accelArray = [0, 0, 0];
   });
   afterEach(() => bluebirdChecks.noPendingPromises());
+  describe('#convertGanglionArrayToBuffer', function () {
+    it('should fill the packet with values from data', function () {
+      const numChannels = k.numberOfChannelsForBoardType(k.OBCIBoardGanglion);
+      let arr = [0, 1, 2, 3];
+      let rawDataPacket = k.rawDataToSampleObjectDefault(numChannels).rawDataPacket;
+      rawDataPacket.fill(0); // fill with zeros
+      let data = Buffer.alloc(k.OBCIPacketSizeBLERaw);
+      openBCIUtilities.convertGanglionArrayToBuffer(arr, data);
+      const sampleNumber = 23;
+      openBCIUtilities.ganglionFillRawDataPacket({
+        data,
+        rawDataPacket,
+        sampleNumber
+      });
+      expect(bufferEqual(rawDataPacket.slice(2, 2 + k.OBCIPacketSizeBLERaw), data), `expected ${data.toString('hex')} but got ${rawDataPacket.slice(2, 2 + k.OBCIPacketSizeBLERaw).toString('hex')}`).to.be.true();
+      expect(rawDataPacket[k.OBCIPacketPositionSampleNumber]).to.equal(sampleNumber);
+      expect(rawDataPacket[k.OBCIPacketPositionStartByte]).to.equal(k.OBCIByteStart);
+      expect(rawDataPacket[k.OBCIPacketPositionStopByte]).to.equal(k.OBCIStreamPacketStandardRawAux);
+    });
+    describe('#errorConditions', function () {
+      it('send undefined data buffer', function () {
+        expect(openBCIUtilities.ganglionFillRawDataPacket.bind(openBCIUtilities, {
+          rawDataPacket: Buffer.alloc(k.OBCIPacketSize),
+          sampleNumber: 0
+        })).to.throw(k.OBCIErrorUndefinedOrNullInput);
+      });
+      it('send null data buffer', function () {
+        expect(openBCIUtilities.ganglionFillRawDataPacket.bind(openBCIUtilities, {
+          data: null,
+          rawDataPacket: Buffer.alloc(k.OBCIPacketSize),
+          sampleNumber: 0
+        })).to.throw(k.OBCIErrorUndefinedOrNullInput);
+      });
+      it('send undefined rawDataPacket buffer', function () {
+        expect(openBCIUtilities.ganglionFillRawDataPacket.bind(openBCIUtilities, {
+          data: Buffer.alloc(k.OBCIPacketSizeBLERaw),
+          sampleNumber: 0
+        })).to.throw(k.OBCIErrorUndefinedOrNullInput);
+      });
+      it('send null rawDataPacket buffer', function () {
+        expect(openBCIUtilities.ganglionFillRawDataPacket.bind(openBCIUtilities, {
+          data: Buffer.alloc(k.OBCIPacketSizeBLERaw),
+          rawDataPacket: null,
+          sampleNumber: 0
+        })).to.throw(k.OBCIErrorUndefinedOrNullInput);
+      });
+      it('no sample number', function () {
+        expect(openBCIUtilities.ganglionFillRawDataPacket.bind(openBCIUtilities, {
+          data: Buffer.alloc(k.OBCIPacketSizeBLERaw),
+          rawDataPacket: Buffer.alloc(k.OBCIPacketSize)
+        })).to.throw(k.OBCIErrorUndefinedOrNullInput);
+      });
+      it('wrong number of bytes rawDataPacket', function () {
+        expect(openBCIUtilities.ganglionFillRawDataPacket.bind(openBCIUtilities, {
+          data: Buffer.alloc(k.OBCIPacketSizeBLERaw),
+          rawDataPacket: Buffer.alloc(5),
+          sampleNumber: 0
+        })).to.throw(k.OBCIErrorInvalidByteLength);
+      });
+      it('wrong number of bytes data', function () {
+        expect(openBCIUtilities.ganglionFillRawDataPacket.bind(openBCIUtilities, {
+          data: Buffer.alloc(5),
+          rawDataPacket: Buffer.alloc(k.OBCIPacketSize),
+          sampleNumber: 0
+        })).to.throw(k.OBCIErrorInvalidByteLength);
+      });
+      it('undefined', function () {
+        expect(openBCIUtilities.ganglionFillRawDataPacket.bind(openBCIUtilities)).to.throw(k.OBCIErrorUndefinedOrNullInput);
+        expect(openBCIUtilities.ganglionFillRawDataPacket.bind(openBCIUtilities), {
+          rawDataPacket: Buffer.alloc(k.OBCIPacketSize)
+        }).to.throw(k.OBCIErrorUndefinedOrNullInput);
+        expect(openBCIUtilities.ganglionFillRawDataPacket.bind(openBCIUtilities), {
+          data: Buffer.alloc(k.OBCIPacketSizeBLERaw)
+        }).to.throw(k.OBCIErrorUndefinedOrNullInput);
+      });
+    });
+  });
   describe('#ganglionFillRawDataPacket', function () {
     it('should fill the packet with values from data', function () {
       const numChannels = k.numberOfChannelsForBoardType(k.OBCIBoardGanglion);
@@ -1444,24 +1521,26 @@ describe('openBCIUtilities', function () {
       lowerSampleObject = openBCIUtilities.newSample(1);
       lowerSampleObject.channelData = [1, 2, 3, 4, 5, 6, 7, 8];
       lowerSampleObject.auxData = [0, 1, 2];
+      lowerSampleObject.accelData = [0, 0, 0];
       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.accelData = [0, 1, 2];
       upperSampleObject.timestamp = 8;
 
       daisySampleObject = openBCIUtilities.makeDaisySampleObject(lowerSampleObject, upperSampleObject);
 
-      lowerSampleObjectNoScale = openBCIUtilities.newSample(1);
+      lowerSampleObjectNoScale = openBCIUtilities.newSampleNoScale(1);
       lowerSampleObjectNoScale.channelDataCounts = [1, 2, 3, 4, 5, 6, 7, 8];
+      lowerSampleObjectNoScale.accelDataCounts = [0, 0, 0];
       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 = openBCIUtilities.newSampleNoScale(2);
       upperSampleObjectNoScale.channelDataCounts = [9, 10, 11, 12, 13, 14, 15, 16];
+      upperSampleObjectNoScale.accelDataCounts = [0, 1, 2];
       upperSampleObjectNoScale.auxData = [3, 4, 5];
       upperSampleObjectNoScale.timestamp = 8;
 
@@ -1513,7 +1592,28 @@ describe('openBCIUtilities', function () {
     });
     it('should store an accelerometer value if present', function () {
       expect(daisySampleObject).to.have.property('accelData');
-      expect(daisySampleObjectNoScale).to.have.property('accelData');
+      expect(daisySampleObject.accelData).to.deep.equal([0, 1, 2]);
+      expect(daisySampleObjectNoScale).to.have.property('accelDataCounts');
+      expect(daisySampleObjectNoScale.accelDataCounts).to.deep.equal([0, 1, 2]);
+    });
+    it('should work for all accel cases to extract the non-zero values', function () {
+      let lowerSample = openBCIUtilities.newSample(1);
+      lowerSample.accelData = [0, 1, 2];
+      let upperSample = openBCIUtilities.newSample(2);
+      upperSample.accelData = [0, 0, 0];
+
+      let lowerSampleNoScale = openBCIUtilities.newSampleNoScale(1);
+      lowerSampleNoScale.accelDataCounts = [0, 1, 2];
+      let upperSampleNoScale = openBCIUtilities.newSampleNoScale(2);
+      upperSampleNoScale.accelDataCounts = [0, 0, 0];
+
+      // Call the function under test
+      let daisySample = openBCIUtilities.makeDaisySampleObject(lowerSample, upperSample);
+      let daisySampleNoScale = openBCIUtilities.makeDaisySampleObject(lowerSampleNoScale, upperSampleNoScale);
+      expect(daisySample).to.have.property('accelData');
+      expect(daisySample.accelData).to.deep.equal([0, 1, 2]);
+      expect(daisySampleNoScale).to.have.property('accelDataCounts');
+      expect(daisySampleNoScale.accelDataCounts).to.deep.equal([0, 1, 2]);
     });
   });
   describe('#makeDaisySampleObjectWifi', function () {