Merge pull request #86 from aj-ptw/time-sync-example

Add example for time syncing

.gitignore

@@ -33,10 +33,10 @@ public
 
 # Test output files
 myOutput.txt
+hardwareVoltageOutputAll.txt
 
 # Local npm builds for testing end in .tgz
 *.tgz
 
 # For git
 *.orig
-

.travis.yml

@@ -1,6 +1,13 @@
 language: node_js
 node_js:
   - "4.0"
+  - "4.1"
+  - "4.2"
+  - "5.11.0"
+  - "6.0"
+  - "6.1"
+  - "6.2"
+  - "6.3"
 install:
   - npm install --all
 script:

changelog.md

@@ -0,0 +1,216 @@
+# 1.3.2
+
+### Enhancements
+
+* Added master time offset `timeOffsetMaster` to `syncObj` which is a running average across sync attempts.
+
+# 1.3.1
+
+### Bug Fixes
+
+* Fixed bug where `connected` and `streaming` were not set in constructor
+
+# 1.3.0
+
+### New Features
+
+* Add dropped packet detection, new event `droppedPacket` can be added to get an array of dropped packet numbers in the case of the dropped packet event.
+
+# 1.2.3
+
+### Enhancements
+
+* Add table of contents to read me
+* Reduce size of repo by removing impedance test report
+
+# 1.2.2
+
+### Enhancements
+
+* Upgrade serialport to 4.x
+
+# 1.2.1
+
+### Bug Fixes
+
+* Fixed bug where set channel function allowed for channel 0 to be set. Cannot set system to channel 0; lower limit is 1.
+
+# 1.2.0
+
+### New Features
+
+* Add tutorial/sample code for interfacing the module with lab streaming layer.
+
+### Breaking Changes
+
+* Fixed time synced accel to work OpenBCI_32bit_Library release candidate 5 and newer.
+
+# 1.1.0
+
+### New Features
+
+* Add function `.time()` which should be used in time syncing
+* Add function `.syncClocksFull()` which should be used for immediate consecutive time syncs
+* Synced object can be emitted on `synced` event. Check `valid` property for if the sync was done
+* Add detailed description of object returned on `synced` event to README.md
+
+### Breaking Changes
+
+* Changed option named `timeSync` to `sntpTimeSync`
+* Removed function called `.sntpNow()` because it was replaced by `.time()`
+
+### Bug Fixes
+
+* Time sync working
+* Module could not work with local time
+
+# 1.0.1
+
+### New Features
+
+* Add time sync tutorial in `README.md`
+
+### Bug Fixes
+
+* Fixed bug in simulator that lead to samples being all zeros.
+* Fixed time sync sent confirmation bug that led to bad time values.
+
+# 1.0.0
+
+The second major release for the OpenBCI Node.js SDK brings major changes, improvements and stability, on top of a push to increase automated test coverage.
+
+### New Features
+
+* NPM Module now called `openbci` instead of `openbci-sdk`
+* Firmware version 2.0 support.
+* Clock synchronization between OpenBCI board and this driver
+* `.info` property which contains verified board information parsed from the OpenBCI's `softReset()` response.
+* `eot` event that is emitted when a user sends a command that results in an EOT ("$$$") being sent from the board
+* Daisy (16 channel) support
+* Simulator overhaul, it completely mocks the board. Can now simulate board failure, where the board stops talking to the dongle. Can also mock a serial port failure.
+* `error` and `close` events from serialport now emtted events users can subscribe to.
+
+### Breaking Changes
+
+* NPM package is not called `openbci-sdk` anymore, now called `openbci`
+* Accelerometer data now goes into `.accelData` array instead of `.auxData` array.
+* In openBCISample.js
+  * `parseRawPacket()` is now called `parseRawPacketStandard()`
+* `ready` event only triggered after soft reset. `eot` event emitted in all other conditions resulting in the board sending EOT ("$$$")
+* Must use camel case on the OpenBCISimulator object.
+* Renamed constructor options for readability:
+  * `simulatorAlpha` to `simulatorInjectAlpha`
+  * `simulatorLineNoise` to `simulatorInjectLineNoise`
+* `connect()` no longer rejects on `close` or `error` event from the serialport.
+
+# 0.3.9
+
+### Enhancements
+
+* Add tests for parsing raw packets
+
+### Bug Fixes
+
+* Removed `got here` log from `.streamStart()`
+* Validate stop byte before emitting `rawDataPacket`
+
+# 0.3.8
+
+### Bug Fixes
+* Fixed readme.md
+
+# 0.3.7
+
+### New Features
+
+* Upgrade dependencies
+* Update Travis
+
+### Bug Fixes
+
+* `.numberOfChannels()` now uses the info object, which is set in the constructor and on the return message from `.softReset()`
+* `.sampleRate()` now uses the info object, which is set in the constructor and on the return message from `.softReset()`
+
+# 0.3.6
+
+### New Features
+
+* Simulator now has accelerometer data
+
+# 0.3.5
+
+### New Features
+
+* SD card support! Now logging to an SD card is easier than ever.
+
+### Bug Fixes
+
+* Sample rate does not return correct sample rate for custom rate on simulator. #58
+
+# 0.3.4
+
+### New Features
+
+* Simulator made to look more like brainwave data to the user. Implemented a 1/f filter. Defaults to injecting 60Hz line noise with two channels of alpha (10Hz) boost.
+
+### Github Issues Addressed
+
+* [https://github.com/OpenBCI/openbci-js-sdk/issues/44](#44)
+
+# 0.3.3
+
+### Bug Fixes
+
+* `rawDataPacket` not being emitted
+
+# 0.3.2
+
+### Work In Progress
+
+* SNTP Time Synchronization
+
+### Bug Fixes
+
+* updates to README.me and comments to change ntp to sntp, because the two are similar, but not the same and we do not want to be misleading
+* Extended [Stnp](https://www.npmjs.com/package/sntp) to main openBCIBoard.js
+* Add `.sntpNow()` function to get ntp time.
+
+# 0.3.1
+
+### Bug Fixes
+
+* Bumped serialport version
+
+# 0.3.0
+
+### New Features
+
+* Test Signals with ADS1299 using `.testSignal()`
+* Continuous impedance testing, where each sample gets an `impedances` object that is an array of impedances for each
+        channel.
+* OpenBCI Radio Test File
+* Added Sntp npm module with helper functions
+* Removed stopByte and startByte from sampleObjects
+
+### Breaking Changes
+
+* Changed simulator name to `OpenBCISimulator`
+* Changed name of function `simulatorOn` to `simulatorEnable`
+* Changed name of function `simulatorOff` to `simulatorDisable`
+
+### Work In Progress
+
+* NTP Time Synchronization
+* Goertzel algorithm to get voltage for impedance calculation
+
+### Bug fixes
+
+* Impedance calculations
+* Readme updates
+* Serial buffer had the chance to become permanently unaligned, optimized and completely transformed and refactored the way bytes are processed.
+* Changes to gain of channels not working correctly.
+* Node 5 compatibility
+
+### Github Issues Addressed
+
+* #25, #26, #27, #29, #30, #31, #33, #34

examples/timeSync/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "timesync",
+  "version": "1.0.0",
+  "description": "Time sync example",
+  "main": "timeSync.js",
+  "scripts": {
+    "start": "node timeSync.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "time",
+    "sync"
+  ],
+  "author": "AJ Keller",
+  "license": "MIT",
+  "dependencies": {
+    "openbci": "^1.3.1"
+  }
+}

examples/timeSync/timeSync.js

@@ -0,0 +1,93 @@
+/**
+* This is an example of time syncing every second for one minute. Used with a
+*  real board.
+* To run:
+*   change directory to this file `cd examples/timeSync`
+*   do `npm install`
+*   then `npm start`
+*/
+
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+
+var ourBoard = new OpenBCIBoard({});
+
+const resyncPeriodMin = 5; // re sync every five minutes
+const secondsInMinute = 60;
+var sampleRate = 250; // Default to 250, ALWAYS verify with a call to `.sampleRate()` after 'ready' event!
+var timeSyncPossible = false;
+
+ourBoard.autoFindOpenBCIBoard().then(portName => {
+    if(portName) {
+        /**
+        * Connect to the board with portName
+        * i.e. ourBoard.connect(portName).....
+        */
+        // Call to connect
+        ourBoard.connect(portName).then(() => {
+            console.log(`connected`);
+
+        })
+        .catch(err => {
+            console.log(`connect: ${err}`);
+        });
+    } else {
+        /**Unable to auto find OpenBCI board*/
+    }
+});
+
+var readyFunc = () => {
+    // Get the sample rate after 'ready'
+    sampleRate = ourBoard.sampleRate();
+    // Find out if you can even time sync, you must be using v2 and this is only accurate after a `.softReset()` call which is called internally on `.connect()`. We parse the `.softReset()` response for the presence of firmware version 2 properties.
+    timeSyncPossible = ourBoard.usingVersionTwoFirmware();
+
+    if (timeSyncPossible) {
+        ourBoard.streamStart()
+        .catch(err => {
+            console.log(`stream start: ${err}`);
+        });
+    } else {
+        killFunc();
+    }
+
+}
+
+var killFunc = () => {
+    ourBoard.disconnect()
+    .then(() => {
+        process.kill();
+    });
+}
+
+var sampleFunc = sample => {
+    // Resynchronize every every second
+    if (sample._count % (sampleRate * 1) === 0) {
+        ourBoard.syncClocksFull()
+        .then(syncObj => {
+            // Sync was successful
+            if (syncObj.valid) {
+                // Log the object to check it out!
+                console.log(`timeOffset`,syncObj.timeOffsetMaster);
+            } else {
+                // Retry it
+                console.log(`Was not able to sync... retry!`);
+            }
+        });
+    }
+
+    if (sample.timeStamp) { // true after the first successful sync
+        if (sample.timeStamp < 10 * 60 * 60 * 1000) { // Less than 10 hours
+            console.log(`Bad time sync ${sample.timeStamp}`);
+        }
+    }
+
+    // Stop after one minute
+    if (sample._count > sampleRate * 60) {
+        killFunc();
+    }
+
+}
+
+// Subscribe to your functions
+ourBoard.on('ready',readyFunc);
+ourBoard.on('sample',sampleFunc);

openBCISimulator.js

@@ -6,21 +6,25 @@ var stream = require('stream');
 
 var openBCISample = require('./openBCISample');
 var k = openBCISample.k;
+var now = require('performance-now');
 
 
 function OpenBCISimulatorFactory() {
     var factory = this;
 
-
-
     var _options = {
-        samplerate: 250,
+        accel: true,
+        alpha: true,
+        boardFailure:false,
         daisy: false,
+        drift: 0,
+        firmwareVersion: k.OBCIFirmwareV1,
+        lineNoise: '60Hz',
+        sampleRate: 250,
+        serialPortFailure:false,
         verbose: false
     };
 
-
-
     function OpenBCISimulator(portName, options) {
         options = (typeof options !== 'function') && options || {};
         var opts = {};
@@ -28,31 +32,62 @@ function OpenBCISimulatorFactory() {
         stream.Stream.call(this);
 
         /** Configuring Options */
-        opts.sampleRate = options.sampleRate || options.samplerate || _options.samplerate;
+        if (options.accel === false) {
+            opts.accel = false;
+        } else {
+            opts.accel = _options.accel;
+        }
+        if (options.alpha === false) {
+            opts.alpha = false;
+        } else {
+            opts.alpha = _options.alpha;
+        }
+        opts.boardFailure = options.boardFailure || _options.boardFailure;
         opts.daisy = options.daisy || _options.daisy;
+        opts.drift = options.drift || _options.drift;
+        opts.firmwareVersion = options.firmwareVersion || _options.firmwareVersion;
+        opts.lineNoise = options.lineNoise || _options.lineNoise;
+        if (options.sampleRate) {
+            opts.sampleRate = options.sampleRate;
+        } else {
+            opts.sampleRate = k.OBCISampleRate250;
+        }
+        opts.serialPortFailure = options.serialPortFailure || _options.serialPortFailure;
         opts.verbose = options.verbose || _options.verbose;
 
         this.options = opts;
 
         // Bools
         this.connected = false;
+        this.sd = {
+            active:false,
+            startTime: 0
+        };
+        this.streaming = false;
+        this.synced = false;
+        this.sendSyncSetPacket = false;
         // Buffers
         this.buffer = new Buffer(500);
         // Numbers
+        this.channelNumber = 1;
+        this.hostChannelNumber = this.channelNumber;
+        this.pollTime = 80;
         this.sampleNumber = -1; // So the first sample is 0
+        // Objects
+        this.sampleGenerator = openBCISample.randomSample(k.OBCINumberOfChannelsDefault, this.options.sampleRate, this.options.alpha, this.options.lineNoise);
+        this.time = {
+            current: 0,
+            start: now(),
+            loop: null
+        };
         // Strings
         this.portName = portName || k.OBCISimulatorPortName;
 
         // Call 'open'
+        if (this.options.verbose) console.log(`Port name: ${portName}`);
         setTimeout(() => {
-            console.log('Port name: ' + portName);
-            if (portName === k.OBCISimulatorPortName) {
-                this.emit('open');
-                this.connected = true;
-            } else {
-                var err = new Error('Serialport not open.');
-                this.emit('error',err);
-            }
+            this.emit('open');
+            this.connected = true;
         }, 200);
 
     }
@@ -66,13 +101,65 @@ function OpenBCISimulatorFactory() {
     };
 
     OpenBCISimulator.prototype.write = function(data,callback) {
-        if (data[0] === k.OBCIStreamStart) {
-            if (!this.stream) this._startStream();
-        } else if (data[0] === k.OBCIStreamStop) {
-            if (this.stream) clearInterval(this.stream); // Stops the stream
-        } else if (data[0] === k.OBCIMiscSoftReset) {
-            if (this.stream) clearInterval(this.stream);
-            this.emit('data', new Buffer('OpenBCI Board Simulator\nPush The World V-0.2\n$$$'));
+        switch (data[0]) {
+            case k.OBCIRadioKey:
+                this._processPrivateRadioMessage(data);
+                break;
+            case k.OBCIStreamStart:
+                if (!this.stream) this._startStream();
+                this.streaming = true;
+                break;
+            case k.OBCIStreamStop:
+                if (this.stream) clearInterval(this.stream); // Stops the stream
+                this.streaming = false;
+                break;
+            case k.OBCIMiscSoftReset:
+                if (this.stream) clearInterval(this.stream);
+                this.streaming = false;
+                this.emit('data', new Buffer(`OpenBCI V3 Simulator\nOn Board ADS1299 Device ID: 0x12345\n${this.options.daisy ? "On Daisy ADS1299 Device ID: 0xFFFFF\n" : ""}LIS3DH Device ID: 0x38422\n${this.options.firmware === k.OBCIFirmwareV2 ? "Firmware: v2.0.0\n" : ""}$$$`));
+                break;
+            case k.OBCISDLogForHour1:
+            case k.OBCISDLogForHour2:
+            case k.OBCISDLogForHour4:
+            case k.OBCISDLogForHour12:
+            case k.OBCISDLogForHour24:
+            case k.OBCISDLogForMin5:
+            case k.OBCISDLogForMin15:
+            case k.OBCISDLogForMin30:
+            case k.OBCISDLogForSec14:
+                // If we are not streaming, then do verbose output
+                if (!this.streaming) {
+                    this.emit('data', new Buffer('Wiring is correct and a card is present.\nCorresponding SD file OBCI_69.TXT\n$$$'));
+                }
+                this.sd.active = true;
+                this.sd.startTime = now();
+                break;
+            case k.OBCISDLogStop:
+                if (!this.streaming) {
+                    if (this.SDLogActive) {
+                        this.emit('data', new Buffer(`Total Elapsed Time: ${now() - this.sd.startTime} ms\n`));
+                        this.emit('data', new Buffer(`Max write time: ${Math.random()*500} us\n`));
+                        this.emit('data', new Buffer(`Min write time: ${Math.random()*200} us\n`));
+                        this.emit('data', new Buffer(`Overruns: 0\n`));
+                        this._printEOT();
+                    } else {
+                        this.emit('data', new Buffer('No open file to close\n'));
+                        this._printEOT();
+                    }
+                }
+                this.SDLogActive = false;
+                break;
+            case k.OBCISyncTimeSet:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    this.synced = true;
+                    setTimeout(() => {
+                        this.emit('data', new Buffer(k.OBCISyncTimeSent));
+                        this._syncUp();
+                    }, 10);
+                }
+                break;
+            default:
+                break;
         }
 
         /** Handle Callback */
@@ -83,7 +170,6 @@ function OpenBCISimulatorFactory() {
 
     OpenBCISimulator.prototype.drain = function(callback) {
         callback();
-        //if (this.options.verbose) console.log('drain');
     };
 
     OpenBCISimulator.prototype.close = function(callback) {
@@ -91,7 +177,6 @@ function OpenBCISimulatorFactory() {
             this.emit('close');
         }
         this.connected = false;
-        //if (this.options.verbose) console.log('close');
         callback();
     };
 
@@ -100,10 +185,31 @@ function OpenBCISimulatorFactory() {
 
         if (intervalInMS < 2) intervalInMS = 2;
 
-        var generateSample = openBCISample.randomSample(k.OBCINumberOfChannelsDefault, k.OBCISampleRate250);
-
         var getNewPacket = sampNumber => {
-            return openBCISample.convertSampleToPacket(generateSample(sampNumber));
+            if (this.options.accel) {
+                if (this.synced) {
+                    if (this.sendSyncSetPacket) {
+                        this.sendSyncSetPacket = false;
+                        return openBCISample.convertSampleToPacketAccelTimeSyncSet(this.sampleGenerator(sampNumber),now().toFixed(0));
+                    } else {
+                        return openBCISample.convertSampleToPacketAccelTimeSynced(this.sampleGenerator(sampNumber),now().toFixed(0));
+                    }
+                } else {
+                    return openBCISample.convertSampleToPacketStandard(this.sampleGenerator(sampNumber));
+                }
+            } else {
+                if (this.synced) {
+                    if (this.sendSyncSetPacket) {
+                        this.sendSyncSetPacket = false;
+                        return openBCISample.convertSampleToPacketRawAuxTimeSyncSet(this.sampleGenerator(sampNumber),now().toFixed(0),new Buffer([0,0,0,0,0,0]));
+                    } else {
+                        return openBCISample.convertSampleToPacketRawAuxTimeSynced(this.sampleGenerator(sampNumber),now().toFixed(0),new Buffer([0,0,0,0,0,0]));
+                    }
+                } else {
+                    return openBCISample.convertSampleToPacketRawAux(this.sampleGenerator(sampNumber),new Buffer([0,0,0,0,0,0]));
+                }
+
+            }
         };
 
         this.stream = setInterval(() => {
@@ -112,10 +218,147 @@ function OpenBCISimulatorFactory() {
         }, intervalInMS);
     };
 
-    factory.OpenBCISimulator = OpenBCISimulator;
+    OpenBCISimulator.prototype._syncUp = function() {
+        setTimeout(() => {
+            this.sendSyncSetPacket = true;
+        }, 12); // 3 packets later
+    };
 
+    OpenBCISimulator.prototype._printEOT = function () {
+        this.emit('data', new Buffer("$$$"));
+    };
+
+    OpenBCISimulator.prototype._printFailure = function () {
+        this.emit('data', new Buffer("Failure: "));
+    };
+
+    OpenBCISimulator.prototype._printSuccess = function () {
+        this.emit('data', new Buffer("Success: "));
+    };
+
+    OpenBCISimulator.prototype._printValidatedCommsTimeout = function () {
+        this._printFailure();
+        this.emit('data', new Buffer("Communications timeout - Device failed to poll Host"));
+        this._printEOT();
+    };
+
+    OpenBCISimulator.prototype._processPrivateRadioMessage = function(dataBuffer) {
+        switch (dataBuffer[1]) {
+            case k.OBCIRadioCmdChannelGet:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    if (!this.options.boardFailure) {
+                        this._printSuccess();
+                        this.emit('data', new Buffer(`Host and Device on Channel Number ${this.channelNumber}`));
+                        this.emit('data', new Buffer([this.channelNumber]));
+                        this._printEOT();
+                    } else if (!this.serialPortFailure) {
+                        this._printFailure();
+                        this.emit('data', new Buffer(`Host on Channel Number ${this.channelNumber}`));
+                        this.emit('data', new Buffer([this.channelNumber]));
+                        this._printEOT();
+                    }
+                }
+                break;
+            case k.OBCIRadioCmdChannelSet:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    if (!this.options.boardFailure) {
+                        if (dataBuffer[2] < k.OBCIRadioChannelMax) {
+                            this.channelNumber = dataBuffer[2];
+                            this.hostChannelNumber = this.channelNumber;
+                            this._printSuccess();
+                            this.emit('data', new Buffer(`Channel Number ${this.channelNumber}`));
+                            this.emit('data', new Buffer([this.channelNumber]));
+                            this._printEOT();
+                        } else {
+                            this._printFailure();
+                            this.emit('data', new Buffer("Verify channel number is less than 25"));
+                            this._printEOT();
+                        }
+                    } else if (!this.serialPortFailure) {
+                       this._printValidatedCommsTimeout();
+                    }
+                }
+                break;
+            case k.OBCIRadioCmdChannelSetOverride:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    if (dataBuffer[2] < k.OBCIRadioChannelMax) {
+                        if (dataBuffer[2] === this.channelNumber) {
+                            this.options.boardFailure = false;
+                        } else {
+                            this.options.boardFailure = true;
+                        }
+                        this.hostChannelNumber = dataBuffer[2];
+                        this._printSuccess();
+                        this.emit('data', new Buffer(`Host override - Channel Number ${this.hostChannelNumber}`));
+                        this.emit('data', new Buffer([this.hostChannelNumber]));
+                        this._printEOT();
+                    } else {
+                        this._printFailure();
+                        this.emit('data', new Buffer("Verify channel number is less than 25"));
+                        this._printEOT();
+                    }
+                }
+                break;
+            case k.OBCIRadioCmdPollTimeGet:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    if (!this.options.boardFailure) {
+                        this._printSuccess();
+                        this.emit('data', new Buffer(`Poll Time ${this.pollTime}`));
+                        this.emit('data', new Buffer([this.pollTime]));
+                        this._printEOT();
+                    } else {
+                        this._printValidatedCommsTimeout();
+                    }
+                }
+                break;
+            case k.OBCIRadioCmdPollTimeSet:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    if (!this.options.boardFailure) {
+                        this.pollTime = dataBuffer[2];
+                        this._printSuccess();
+                        this.emit('data', new Buffer(`Poll Time ${this.pollTime}`));
+                        this.emit('data', new Buffer([this.pollTime]));
+                        this._printEOT();
+                    } else {
+                        this._printValidatedCommsTimeout();
+                    }
+                }
+                break;
+            case k.OBCIRadioCmdBaudRateSetDefault:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    this._printSuccess();
+                    this.emit('data', new Buffer("Switch your baud rate to 115200"));
+                    this.emit('data', new Buffer([0x24,0x24,0x24,0xFF])); // The board really does this
+                }
+                break;
+            case k.OBCIRadioCmdBaudRateSetFast:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    this._printSuccess();
+                    this.emit('data', new Buffer("Switch your baud rate to 230400"));
+                    this.emit('data', new Buffer([0x24,0x24,0x24,0xFF])); // The board really does this
+                }
+                break;
+            case k.OBCIRadioCmdSystemStatus:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    if (!this.options.boardFailure) {
+                        this._printSuccess();
+                        this.emit('data', new Buffer("System is Up"));
+                        this._printEOT();
+                    } else {
+                        this._printFailure();
+                        this.emit('data', new Buffer("System is Down"));
+                        this._printEOT();
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    };
+
+    factory.OpenBCISimulator = OpenBCISimulator;
 }
 
 util.inherits(OpenBCISimulatorFactory, EventEmitter);
 
-module.exports = new OpenBCISimulatorFactory();
+module.exports = new OpenBCISimulatorFactory();

package.json

@@ -1,7 +1,7 @@
 {
-  "name": "openbci-sdk",
-  "version": "0.2.0",
-  "description": "A fully NodeJS based API for the OpenBCI board connecting to the hardware directly over serial",
+  "name": "openbci",
+  "version": "1.3.2",
+  "description": "The official Node.js SDK for the OpenBCI Biosensor Board.",
   "main": "openBCIBoard",
   "scripts": {
     "start": "node index",
@@ -15,11 +15,13 @@
   "author": "AJ Keller <aj@pushtheworld.us> (www.openbci.com)",
   "license": "MIT",
   "dependencies": {
+    "buffer-equal": "^1.0.0",
     "gaussian": "^1.0.0",
-    "istanbul": "^0.4.2",
-    "outliers": "0.0.3",
-    "scientific-statistics": "^0.2.7",
-    "serialport": "^2.0.2"
+    "mathjs": "^3.3.0",
+    "performance-now": "^0.2.0",
+    "serialport": "4.0.1",
+    "sntp": "^2.0.0",
+    "streamsearch": "^0.1.2"
   },
   "directories": {
     "test": "test"
@@ -28,19 +30,20 @@
     "chai": "^3.4.1",
     "chai-as-promised": "^5.2.0",
     "codecov": "^1.0.1",
-    "mocha": "^2.3.4",
+    "istanbul": "^0.4.4",
+    "mocha": "^3.0.2",
     "sandboxed-module": "^2.0.3",
     "sinon": "^1.17.2",
     "sinon-chai": "^2.8.0"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/openbci/openbci-js-sdk.git"
+    "url": "git+https://github.com/openbci/openbci_nodejs.git"
   },
   "bugs": {
-    "url": "https://github.com/openbci/openbci-js-sdk/issues"
+    "url": "https://github.com/openbci/openbci_nodejs/issues"
   },
-  "homepage": "https://github.com/openbci/openbci-js-sdk#readme",
+  "homepage": "https://github.com/openbci/openbci_nodejs#readme",
   "engines": {
     "node": ">=4.0.0"
   }

test/OpenBCIBoard-test.js

@@ -1,273 +0,0 @@
-/**
- * Created by AJ Keller
- * Date: 12/23/15
- * Purpose: To unit test the OpenBCIBoard file
- */
-
-var assert = require('assert');
-var OpenBCIBoard = require('../openBCIBoard');
-var OpenBCISample = OpenBCIBoard.OpenBCISample;
-var k = OpenBCIBoard.OpenBCIConstants;
-var chai = require('chai')
-    ,  expect = chai.expect
-    ,  should = chai.should();
-var chaiAsPromised = require("chai-as-promised");
-
-chai.use(chaiAsPromised);
-
-var sampleSelf = function() {
-    return {
-        masterBuffer: {
-            buffer: new Buffer(3300),
-            positionRead:0,
-            positionWrite:0,
-            packetsIn:0,
-            packetsRead:0,
-            looseBytes:0
-        }
-    };
-};
-
-var sampleData;
-var bciBoard;
-
-var samplePacket = function () {
-    var byteSample = 0x45;
-    var buffy = new Buffer([0xA0,byteSample,0,0,1,0,0,2,0,0,3,0,0,4,0,0,5,0,0,6,0,0,7,0,0,8,0,0,0,1,0,2,0xC0]);
-    return buffy;
-};
-
-
-
-
-describe('OpenBCIBoard',function() {
-    describe('#_bufMerger',function() {
-        beforeEach(function() {
-            bciBoard = new OpenBCIBoard.OpenBCIBoard();
-            sampleData = [];
-            (function(){
-                for(var i = 0;i < 100;i++) {
-                    var sample = samplePacket();
-                    sample.sampleNumber = i;
-                    sampleData[i] = sample;
-                }
-            }());
-        });
-        it('should write the buffer to the empty master buffer', function() {
-            bciBoard._bufMerger(sampleData[0]);
-
-            // test to see if buffers match
-            assert.equal(0,sampleData[0].compare(bciBoard.masterBuffer.buffer.slice(0, k.OBCIPacketSize)));
-            // test to make sure the write position was moved
-            assert.equal(k.OBCIPacketSize, bciBoard.masterBuffer.positionWrite);
-            // test to make sure we read in the right number of packets
-            assert.equal(bciBoard.masterBuffer.packetsIn,1);
-            // test to make sure there are no loose bytes
-            assert.equal(bciBoard.masterBuffer.looseBytes,0);
-        });
-        it('should write the tiny buffer to the empty master buffer, but not record a packet in', function() {
-            var tinyBufferSize = 10; //tiny because its smaller than a packet
-            var tinyBuffer = sampleData[0].slice(0,tinyBufferSize);
-
-            bciBoard._bufMerger(tinyBuffer);
-
-            // test to see if buffers match
-            assert.equal(0,tinyBuffer.compare(bciBoard.masterBuffer.buffer.slice(0, tinyBufferSize)));
-            // test to make sure the write position was moved
-            assert.equal(tinyBufferSize, bciBoard.masterBuffer.positionWrite);
-            // test to make sure we read in the right number of packets
-            assert.equal(bciBoard.masterBuffer.packetsIn,0);
-            // test to make sure there are 10 loose bytes
-            assert.equal(bciBoard.masterBuffer.looseBytes,tinyBufferSize);
-        });
-        it('should write the multi packet plus loose byte buffer to the empty master buffer', function() {
-            var tinyBufferSize = 10; //tiny because its smaller than a packet
-            var tinyBuffer = sampleData[0].slice(0,tinyBufferSize);
-
-            var buffers = [sampleData[0],sampleData[1],sampleData[2],tinyBuffer];
-            var totalLength = k.OBCIPacketSize * 3 + tinyBufferSize;
-
-            var multiPacketBuffer = Buffer.concat(buffers,totalLength);
-
-            bciBoard._bufMerger(multiPacketBuffer);
-
-            // test to see if buffers match
-            assert.equal(0,multiPacketBuffer.compare(bciBoard.masterBuffer.buffer.slice(0, totalLength)));
-            // test to make sure the write position was moved
-            assert.equal(totalLength, bciBoard.masterBuffer.positionWrite);
-            // test to make sure we read in the right number of packets (shall be three)
-            assert.equal(bciBoard.masterBuffer.packetsIn,3);
-            // test to make sure there are 10 loose bytes
-            assert.equal(bciBoard.masterBuffer.looseBytes,tinyBufferSize);
-        });
-        it('should use looseBytes in to write the multi packet to the master buffer and record an extra packet in', function() {
-            var tinyBufferSize = 10; //tiny because its smaller than a packet
-            var tinyBuffer = sampleData[0].slice(0,tinyBufferSize);
-
-            var hackedBufferSize = k.OBCIPacketSize - tinyBufferSize;
-            var hackedBuffer = sampleData[0].slice(tinyBufferSize);
-
-            bciBoard.masterBuffer.looseBytes = tinyBufferSize;
-
-            var buffers = [hackedBuffer,sampleData[0],sampleData[1],sampleData[2]];
-            var totalLength = k.OBCIPacketSize * 3 + hackedBufferSize;
-
-            var multiPacketBuffer = Buffer.concat(buffers,totalLength);
-
-            bciBoard._bufMerger(multiPacketBuffer);
-
-            // test to see if buffers match
-            assert.equal(0,multiPacketBuffer.compare(bciBoard.masterBuffer.buffer.slice(0, totalLength)));
-            // test to make sure the write position was moved
-            assert.equal(totalLength, bciBoard.masterBuffer.positionWrite);
-            // test to make sure we read in the right number of packets (shall be three)
-            assert.equal(bciBoard.masterBuffer.packetsIn,4);
-            // test to make sure there are 10 loose bytes
-            assert.equal(bciBoard.masterBuffer.looseBytes,0);
-        });
-        it('should write in the position of the masterBufferPositionWrite', function() {
-            var originalWritePosition = 69;
-            bciBoard.masterBuffer.positionWrite = originalWritePosition;
-
-            bciBoard._bufMerger(sampleData[0]);
-
-            // test to see if the master buffer contains the correct data
-            assert.equal(0,sampleData[0].compare(bciBoard.masterBuffer.buffer.slice(originalWritePosition, originalWritePosition + k.OBCIPacketSize)));
-            // test to see if the write position was moved properly
-            assert.equal(bciBoard.masterBuffer.positionWrite,originalWritePosition + k.OBCIPacketSize);
-            // test to make sure we read in the right number of packets
-            assert.equal(bciBoard.masterBuffer.packetsIn,1);
-            // test to make sure there are no loose bytes
-            assert.equal(bciBoard.masterBuffer.looseBytes,0);
-        });
-        it('should wrap the input buffer around the master buffer',function() {
-            var spaceRemaingInMasterBuffer = 15;
-            var originalWritePosition = k.OBCIMasterBufferSize - spaceRemaingInMasterBuffer;
-
-            bciBoard.masterBuffer.positionWrite = originalWritePosition;
-
-            bciBoard._bufMerger(sampleData[0]);
-
-            // test to see that the end of master buffer contains half of sample
-            assert.equal(0,sampleData[0].slice(0,spaceRemaingInMasterBuffer).compare(bciBoard.masterBuffer.buffer.slice(originalWritePosition)));
-            // test to see that the beginning of master buffer contains the second half of sampleData[0]
-            assert.equal(0,sampleData[0].slice(spaceRemaingInMasterBuffer).compare(bciBoard.masterBuffer.buffer.slice(0,sampleData[0].byteLength - spaceRemaingInMasterBuffer)));
-            // test to make sure the write position was moved correctly
-            assert.equal(bciBoard.masterBuffer.positionWrite,sampleData[0].byteLength - spaceRemaingInMasterBuffer);
-            // test to make sure we read in the right number of packets
-            assert.equal(bciBoard.masterBuffer.packetsIn,1);
-            // test to make sure there are no loose bytes
-            assert.equal(bciBoard.masterBuffer.looseBytes,0);
-        });
-    });
-    describe('#_bufPacketStripper', function() {
-        beforeEach(function() {
-            bciBoard = new OpenBCIBoard.OpenBCIBoard();
-            sampleData = [];
-            (function(){
-                for(var i = 0;i < 100;i++) {
-                    var sample = samplePacket();
-                    sample.sampleNumber = i;
-                    sampleData[i] = sample;
-                }
-            }());
-        });
-        it('should remove a packet from the master buffer', function() {
-            var buffers = [sampleData[0],sampleData[1],sampleData[2]];
-            var totalLength = k.OBCIPacketSize * 3;
-
-            var multiPacketBuffer = Buffer.concat(buffers,totalLength);
-
-            //console.log(multiPacketBuffer);
-
-
-            bciBoard._bufMerger(multiPacketBuffer);
-
-            // run through three iterations of stripping packets
-            for (var i = 0; i < 3; i++) {
-                var rawPacket = bciBoard._bufPacketStripper();
-                var sample = OpenBCISample.convertPacketToSample(rawPacket);
-                //console.log(OpenBCISample.debugPrettyPrint(sample));
-                //console.log('Sample ' + i + ' has sample number ' + sample.sampleNumber);
-                assert.equal(sample.sampleNumber,69);
-            }
-        });
-        it('should remove a packet from the master buffer, even at wrap..', function() {
-
-            var buffers = [sampleData[0],sampleData[1],sampleData[2]];
-            var totalLength = k.OBCIPacketSize * 3;
-
-            bciBoard.masterBuffer.positionWrite = k.OBCIMasterBufferSize - 10;
-            bciBoard.masterBuffer.positionRead = bciBoard.masterBuffer.positionWrite;
-
-            var multiPacketBuffer = Buffer.concat(buffers,totalLength);
-
-            bciBoard._bufMerger(multiPacketBuffer);
-
-            // run through three iterations of stripping packets
-            for (var i = 0; i < 3; i++) {
-                var rawPacket = bciBoard._bufPacketStripper();
-                var sample = OpenBCISample.convertPacketToSample(rawPacket);
-                assert(sample.sampleNumber,i);
-            }
-        });
-    });
-    describe('#_bufAlign',function() {
-        beforeEach(function() {
-            bciBoard = new OpenBCIBoard.OpenBCIBoard();
-            sampleData = [];
-            (function(){
-                for(var i = 0;i < 100;i++) {
-                    var sample = samplePacket();
-                    sample.sampleNumber = i;
-                    sampleData[i] = sample;
-                }
-            }());
-        });
-        it('should fix a buffer', function() {
-            var buffers = [sampleData[0],sampleData[1],sampleData[2]];
-            var totalLength = k.OBCIPacketSize * 3;
-
-
-            var multiPacketBuffer = Buffer.concat(buffers,totalLength);
-
-            //console.log(multiPacketBuffer);
-
-            var bytesToHackOffSample = 10;
-            var expectedNewPositionRead = k.OBCIPacketSize - bytesToHackOffSample;
-
-            bciBoard._bufMerger(multiPacketBuffer.slice(10,totalLength));
-
-            bciBoard._bufAlign();
-
-            assert(expectedNewPositionRead,bciBoard.masterBuffer.positionRead);
-
-        });
-        it('should wrap & then fix a buffer', function() {
-            var buffers = [sampleData[0],sampleData[1],sampleData[2]];
-            var totalLength = k.OBCIPacketSize * 3;
-
-
-            var multiPacketBuffer = Buffer.concat(buffers,totalLength);
-
-            var bytesFromEndOfBuffer = 5;
-
-            bciBoard.masterBuffer.positionRead = k.OBCIMasterBufferSize - bytesFromEndOfBuffer;
-
-            var bytesToHackOffSample = 10;
-            var expectedNewPositionRead = bytesToHackOffSample - bytesFromEndOfBuffer;
-
-            bciBoard._bufMerger(multiPacketBuffer.slice(10,totalLength));
-
-            bciBoard._bufAlign();
-
-            assert(expectedNewPositionRead,bciBoard.masterBuffer.positionRead);
-
-        });
-    });
-});
-
-function debugPrintBufferCompare(buf1,buf2) {
-    console.log('Comparing:\n\tBuffer 1\n\t\t' + buf1.toString('hex') + '\n\tBuffer 2\n\t\t' + buf2.toString('hex'));
-
-}

test/OpenBCIConstants-test.js

@@ -291,6 +291,20 @@ describe('OpenBCIConstants', function() {
             assert.equal('1', k.OBCIChannelImpedanceTestSignalApplied);
         });
     });
+    describe('Time Sync Stuff',function() {
+        it('Can get proper array size',function() {
+            assert.equal(10, k.OBCITimeSyncArraySize);
+        });
+        it('Get correct time sync with conf',function() {
+            assert.equal(0.9, k.OBCITimeSyncMultiplierWithSyncConf);
+        });
+        it('Get correct time sync without conf',function() {
+            assert.equal(0.75, k.OBCITimeSyncMultiplierWithoutSyncConf);
+        });
+        it('Get correct time sync transmission threshold',function() {
+            assert.equal(10, k.OBCITimeSyncThresholdTransFailureMS);
+        });
+    });
     describe('SD card Commands',function() {
         it('logs for 1 hour', function() {
             assert.equal('G', k.OBCISDLogForHour1);
@@ -323,6 +337,86 @@ describe('OpenBCIConstants', function() {
             assert.equal('j', k.OBCISDLogStop);
         });
     });
+    describe('SD card string Commands',function() {
+        it('logs for 1 hour', function() {
+            assert.equal('1hour', k.OBCIStringSDHour1);
+        });
+        it('logs for 2 hours', function() {
+            assert.equal('2hour', k.OBCIStringSDHour2);
+        });
+        it('logs for 4 hours', function() {
+            assert.equal('4hour', k.OBCIStringSDHour4);
+        });
+        it('logs for 12 hours', function() {
+            assert.equal('12hour', k.OBCIStringSDHour12);
+        });
+        it('logs for 24 hours', function() {
+            assert.equal('24hour', k.OBCIStringSDHour24);
+        });
+        it('logs for 5 minutes', function() {
+            assert.equal('5min', k.OBCIStringSDMin5);
+        });
+        it('logs for 15 minutes', function() {
+            assert.equal('15min', k.OBCIStringSDMin15);
+        });
+        it('logs for 30 minutes', function() {
+            assert.equal('30min', k.OBCIStringSDMin30);
+        });
+        it('logs for 14 seconds', function() {
+            assert.equal('14sec', k.OBCIStringSDSec14);
+        });
+    });
+    describe('#sdSettingForString',function() {
+        it('correct command for 1 hour', function() {
+            var expectation = k.OBCISDLogForHour1;
+            var result = k.sdSettingForString('1hour');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('correct command for 2 hour', function() {
+            var expectation = k.OBCISDLogForHour2;
+            var result = k.sdSettingForString('2hour');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('correct command for 4 hour', function() {
+            var expectation = k.OBCISDLogForHour4;
+            var result = k.sdSettingForString('4hour');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('correct command for 12 hour', function() {
+            var expectation = k.OBCISDLogForHour12;
+            var result = k.sdSettingForString('12hour');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('correct command for 24 hour', function() {
+            var expectation = k.OBCISDLogForHour24;
+            var result = k.sdSettingForString('24hour');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('correct command for 5 min', function() {
+            var expectation = k.OBCISDLogForMin5;
+            var result = k.sdSettingForString('5min');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('correct command for 15 min', function() {
+            var expectation = k.OBCISDLogForMin15;
+            var result = k.sdSettingForString('15min');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('correct command for 30 min', function() {
+            var expectation = k.OBCISDLogForMin30;
+            var result = k.sdSettingForString('30min');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('correct command for 14 seconds', function() {
+            var expectation = k.OBCISDLogForSec14;
+            var result = k.sdSettingForString('14sec');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('Invalid command request', function() {
+            var result = k.sdSettingForString('taco');
+            return expect(result).to.be.rejected;
+        });
+    });
     describe('Stream Data Commands',function() {
         it('starts',function () {
             assert.equal('b', k.OBCIStreamStart);
@@ -355,6 +449,45 @@ describe('OpenBCIConstants', function() {
             assert.equal('f', k.OBCIFilterEnable);
         });
     });
+    describe('Stream packet types/codes',function() {
+        it('Standard with Accel',function () {
+            assert.equal(0, k.OBCIStreamPacketStandardAccel);
+        });
+        it('Standard with Raw Aux',function () {
+            assert.equal(1, k.OBCIStreamPacketStandardRawAux);
+        });
+        it('User Defined Packet',function () {
+            assert.equal(2, k.OBCIStreamPacketUserDefinedType);
+        });
+        it('Time Sync Set with accel',function () {
+            assert.equal(3, k.OBCIStreamPacketAccelTimeSyncSet);
+        });
+        it('Time Synced with Accel',function () {
+            assert.equal(4, k.OBCIStreamPacketAccelTimeSynced);
+        });
+        it('Time Sync set with Raw Aux',function () {
+            assert.equal(5, k.OBCIStreamPacketRawAuxTimeSyncSet);
+        });
+        it('Time Synced with Raw Aux',function () {
+            assert.equal(6, k.OBCIStreamPacketRawAuxTimeSynced);
+        });
+    });
+    describe('Time synced with accel packet',function() {
+        it('X axis',function () {
+            assert.equal(7, k.OBCIAccelAxisX);
+        });
+        it('Y axis',function () {
+            assert.equal(8, k.OBCIAccelAxisY);
+        });
+        it('Z axis',function () {
+            assert.equal(9, k.OBCIAccelAxisZ);
+        });
+    });
+    describe('Time sync useful numbers',function() {
+        it('Time from the board is 4 bytes',function () {
+            assert.equal(4, k.OBCIStreamPacketTimeByteSize);
+        });
+    });
     describe('should return the right command for each channel', function(){
         it('Channel 1', function() {
             var expectation = '1';
@@ -534,78 +667,78 @@ describe('OpenBCIConstants', function() {
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 2', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = '@';
+            var result = k.commandChannelOn(2);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 3', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = '#';
+            var result = k.commandChannelOn(3);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 4', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = '$';
+            var result = k.commandChannelOn(4);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 5', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = '%';
+            var result = k.commandChannelOn(5);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 6', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = '^';
+            var result = k.commandChannelOn(6);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 7', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = '&';
+            var result = k.commandChannelOn(7);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 8', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = '*';
+            var result = k.commandChannelOn(8);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 9', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'Q';
+            var result = k.commandChannelOn(9);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 10', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'W';
+            var result = k.commandChannelOn(10);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 11', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'E';
+            var result = k.commandChannelOn(11);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 12', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'R';
+            var result = k.commandChannelOn(12);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 13', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'T';
+            var result = k.commandChannelOn(13);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 14', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'Y';
+            var result = k.commandChannelOn(14);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 15', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'U';
+            var result = k.commandChannelOn(15);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Channel 16', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'I';
+            var result = k.commandChannelOn(16);
             return expect(result).to.eventually.equal(expectation);
         });
         it('Invalid channel request', function() {
@@ -632,6 +765,25 @@ describe('OpenBCIConstants', function() {
             assert.equal(250, k.OBCISampleRate250);
         });
     });
+    describe('Max sample number',function() {
+        it('should be 255',function () {
+            assert.equal(255, k.OBCISampleNumberMax);
+        });
+    });
+    describe("Radio Channel Limits", function() {
+        it("should get the right channel number max",function () {
+            expect(k.OBCIRadioChannelMax).to.be.equal(25);
+        });
+        it("should get the right channel number min",function () {
+            expect(k.OBCIRadioChannelMin).to.be.equal(1);
+        });
+        it("should get the right poll time max",function () {
+            expect(k.OBCIRadioPollTimeMax).to.be.equal(255);
+        });
+        it("should get the right poll time min",function () {
+            expect(k.OBCIRadioPollTimeMin).to.be.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() {
@@ -896,6 +1048,51 @@ describe('OpenBCIConstants', function() {
             });
         });
     });
+    describe('#getTestSignalCommand', function() {
+        it('ground', function() {
+            var expectation = '0';
+            var result = k.getTestSignalCommand('ground');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('dc', function() {
+            var expectation = 'p';
+            var result = k.getTestSignalCommand('dc');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('Pulse 1x Fast', function() {
+            var expectation = '=';
+            var result = k.getTestSignalCommand('pulse1xFast');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('Pulse 1x Slow', function() {
+            var expectation = '-';
+            var result = k.getTestSignalCommand('pulse1xSlow');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('Pulse 2x Fast', function() {
+            var expectation = ']';
+            var result = k.getTestSignalCommand('pulse2xFast');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('Pulse 2x Slow', function() {
+            var expectation = '[';
+            var result = k.getTestSignalCommand('pulse2xSlow');
+            return expect(result).to.eventually.equal(expectation);
+        });
+        it('none', function() {
+            var expectation = 'd';
+            var result = k.getTestSignalCommand('none');
+            return expect(result).to.eventually.equal(expectation);
+        });
+    });
+    describe('#getVersionNumber', function() {
+        it('should get the major version number from a github standard version string',() => {
+            var expectedVersion = 6;
+            var inputStringVersion = 'v6.0.0';
+
+            expect(k.getVersionNumber(inputStringVersion)).to.equal(expectedVersion);
+        });
+    });
     describe('#getImpedanceSetter', function() {
         describe('channel input selection works', function () {
             it('channel 2', function (done) {
@@ -999,4 +1196,4 @@ describe('OpenBCIConstants', function() {
             });
         });
     });
-});
+});

test/openBCIBoard-Impedance-test.js

@@ -0,0 +1,622 @@
+var sinon = require('sinon');
+var chai = require('chai'),
+    should = chai.should(),
+    expect = chai.expect,
+    openBCIBoard = require('../openBCIBoard'),
+    openBCISample = openBCIBoard.OpenBCISample,
+    k = openBCISample.k;
+
+var chaiAsPromised = require("chai-as-promised");
+var sinonChai = require("sinon-chai");
+chai.use(chaiAsPromised);
+chai.use(sinonChai);
+var bufferEqual = require('buffer-equal');
+var fs = require('fs');
+//var wstream = fs.createWriteStream('myOutput.txt');
+
+
+describe('#impedanceTesting', function() {
+    var ourBoard;
+    this.timeout(20000);
+
+    before(function(done) {
+        ourBoard = new openBCIBoard.OpenBCIBoard({
+            verbose: true
+        });
+        var useSim = () => {
+            ourBoard.simulatorEnable().then(() => {
+                return ourBoard.connect(k.OBCISimulatorPortName);
+            });
+        };
+        ourBoard.autoFindOpenBCIBoard()
+            .then(portName => {
+                return ourBoard.connect(portName);
+            })
+            .catch((err) => {
+                useSim();
+            })
+            .then(() => {
+                console.log('connected');
+            })
+            .catch(err => {
+                console.log('Error: '+ err);
+            });
+
+
+        ourBoard.once('ready',() => {
+            ourBoard.streamStart()
+                .then(() => {
+                    setTimeout(() => {
+                        done();
+                    }, 100); // give some time for the stream command to be sent
+                })
+                .catch(err => {
+                    console.log(err);
+                    done(err);
+                });
+        });
+
+
+    });
+    after(done => {
+        if(ourBoard["connected"]) {
+            ourBoard.disconnect()
+                .then(() => {
+                    done();
+                })
+                .catch(err => {
+                    done(err);
+                })
+        }
+    });
+
+    describe('#impedanceTestAllChannels', function () {
+        var impedanceArray = [];
+
+        before(function(done) {
+            ourBoard.once('impedanceArray', arr => {
+                impedanceArray = arr;
+                console.log(impedanceArray);
+                done();
+            });
+            ourBoard.impedanceTestAllChannels();
+        });
+        describe('#channel1',function() {
+            it('has valid channel number', function() {
+                impedanceArray[0].channel.should.be.equal(1);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[0].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[0].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[0].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[0].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel2',function() {
+            it('has valid channel number', function() {
+                impedanceArray[1].channel.should.be.equal(2);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[1].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[1].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[1].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[1].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel3',function() {
+            it('has valid channel number', function() {
+                impedanceArray[2].channel.should.be.equal(3);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[2].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[2].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[2].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[2].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel4',function() {
+            it('has valid channel number', function() {
+                impedanceArray[3].channel.should.be.equal(4);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[3].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[3].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[3].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[3].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel5',function() {
+            it('has valid channel number', function() {
+                impedanceArray[4].channel.should.be.equal(5);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[4].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[4].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[4].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[4].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel6',function() {
+            it('has valid channel number', function() {
+                impedanceArray[5].channel.should.be.equal(6);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[5].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[5].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[5].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[5].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel7',function() {
+            it('has valid channel number', function() {
+                impedanceArray[6].channel.should.be.equal(7);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[6].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[6].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[6].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[6].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel8',function() {
+            it('has valid channel number', function () {
+                impedanceArray[7].channel.should.be.equal(8);
+            });
+            describe('#inputP', function () {
+                it('got raw impedance value', function () {
+                    impedanceArray[7].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function () {
+                    impedanceArray[7].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function () {
+                it('got raw impedance value', function () {
+                    impedanceArray[7].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function () {
+                    impedanceArray[7].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+    });
+    describe('#impedanceTestChannelsRejects', function() {
+        it('rejects when it does not get an array', function(done) {
+            ourBoard.impedanceTestChannels('taco').should.be.rejected.and.notify(done);
+        });
+
+        it('rejects when it array length does not match number of channels', function(done) {
+            ourBoard.impedanceTestChannels(['-','N','n','p','P','p','b']).should.be.rejected.and.notify(done);
+        });
+
+    });
+    describe('#impedanceTestChannels', function () {
+        var impedanceArray = [];
+
+        before(function(done) {
+            ourBoard.once('impedanceArray', arr => {
+                impedanceArray = arr;
+                done();
+            });
+            ourBoard.impedanceArray[0] = openBCISample.impedanceObject(1);
+            ourBoard.impedanceTestChannels(['-','N','n','p','P','p','b','B']).catch(err => done(err));
+        });
+        describe('#channel1',function() {
+            it('has valid channel number', function() {
+                impedanceArray[0].channel.should.be.equal(1);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[0].P.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[0].P.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[0].N.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[0].N.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel2',function() {
+            it('has valid channel number', function() {
+                impedanceArray[1].channel.should.be.equal(2);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[1].P.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[1].P.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[1].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[1].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel3',function() {
+            it('has valid channel number', function() {
+                impedanceArray[2].channel.should.be.equal(3);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[2].P.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[2].P.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[2].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[2].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel4',function() {
+            it('has valid channel number', function() {
+                impedanceArray[3].channel.should.be.equal(4);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[3].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[3].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[3].N.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[3].N.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel5',function() {
+            it('has valid channel number', function() {
+                impedanceArray[4].channel.should.be.equal(5);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[4].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[4].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[4].N.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[4].N.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel6',function() {
+            it('has valid channel number', function() {
+                impedanceArray[5].channel.should.be.equal(6);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[5].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[5].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[5].N.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[5].N.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel7',function() {
+            it('has valid channel number', function() {
+                impedanceArray[6].channel.should.be.equal(7);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[6].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[6].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[6].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[6].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel8',function() {
+            it('has valid channel number', function () {
+                impedanceArray[7].channel.should.be.equal(8);
+            });
+            describe('#inputP', function () {
+                it('got raw impedance value', function () {
+                    impedanceArray[7].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function () {
+                    impedanceArray[7].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function () {
+                it('got raw impedance value', function () {
+                    impedanceArray[7].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function () {
+                    impedanceArray[7].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+    });
+    describe('#impedanceTestChannel', function () {
+        var impedanceObject = {};
+
+        before(function(done) {
+            ourBoard.impedanceTestChannel(1)
+                .then(impdObj => {
+                    impedanceObject = impdObj;
+                    done();
+                })
+                .catch(err => done(err));
+        });
+        describe('#channel1',function() {
+            it('has valid channel number', function() {
+                impedanceObject.channel.should.be.equal(1);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceObject.P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceObject.P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceObject.N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceObject.N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+    });
+    describe('#impedanceTestChannelInputP', function () {
+        var impedanceObject = {};
+
+        before(function(done) {
+            ourBoard.impedanceTestChannelInputP(1)
+                .then(impdObj => {
+                    impedanceObject = impdObj;
+                    done();
+                })
+                .catch(err => done(err));
+        });
+        describe('#channel1',function() {
+            it('has valid channel number', function() {
+                impedanceObject.channel.should.be.equal(1);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceObject.P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceObject.P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceObject.N.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceObject.N.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+    });
+    describe('#impedanceTestChannelInputN', function () {
+
+        var impedanceObject = {};
+        //wstream = fs.createWriteStream('hardwareVoltageOutputAll.txt');
+
+        before(function(done) {
+
+            console.log('7');
+
+            ourBoard.on('sample',sample => {
+                //console.log('8');
+                //OpenBCISample.debugPrettyPrint(sample);
+                // good to start impedance testing..
+            });
+
+            ourBoard.impedanceTestChannelInputN(1)
+                .then(impdObj => {
+                    impedanceObject = impdObj;
+                    setTimeout(() => {
+                        done();
+                    }, 1000);
+                })
+                .catch(err => done(err));
+        });
+        describe('#channel1',function() {
+            it('has valid channel number', function() {
+                impedanceObject.channel.should.be.equal(1);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceObject.P.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceObject.P.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceObject.N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceObject.N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+    });
+    describe('#impedanceTestContinuousStXX', function () {
+
+        var impedanceArray = [];
+
+        before(function(done) {
+            ourBoard.impedanceTestContinuousStart()
+                .then(done).catch(err => done(err));
+
+        });
+
+        after(function(done) {
+            ourBoard.impedanceTestContinuousStop()
+                .then(done);
+        });
+
+        it('prints 10 impedance arrays', function(done) {
+            var count = 1;
+
+            var listener = impedanceArray => {
+                //console.log('\nImpedance Array: ' + count);
+                //console.log(impedanceArray);
+                count++;
+                if (count > 10) {
+                    ourBoard.removeListener('impedanceArray', listener);
+                    done();
+                }
+            };
+            ourBoard.on('impedanceArray', listener);
+
+
+
+
+        });
+    });
+    describe('#_impedanceTestSetChannel', function () {
+        it('reject with invalid channel', function(done) {
+            ourBoard._impedanceTestSetChannel(0,false,false).should.be.rejected.and.notify(done);
+        });
+    });
+    describe('#_impedanceTestCalculateChannel', function () {
+        it('reject with low invalid channel', function(done) {
+            ourBoard._impedanceTestCalculateChannel(0,false,false).should.be.rejected.and.notify(done);
+        });
+        it('reject with high invalid channel', function(done) {
+            ourBoard._impedanceTestCalculateChannel(69,false,false).should.be.rejected.and.notify(done);
+        });
+        it('reject with invalid data type pInput', function(done) {
+            ourBoard._impedanceTestCalculateChannel(1,'taco',false).should.be.rejected.and.notify(done);
+        });
+        it('reject with invalid data type nInput', function(done) {
+            ourBoard._impedanceTestCalculateChannel(1,false,'taco').should.be.rejected.and.notify(done);
+        });
+    });
+    describe('#_impedanceTestFinalizeChannel', function () {
+        it('reject with low invalid channel', function(done) {
+            ourBoard._impedanceTestFinalizeChannel(0,false,false).should.be.rejected.and.notify(done);
+        });
+        it('reject with high invalid channel', function(done) {
+            ourBoard._impedanceTestFinalizeChannel(69,false,false).should.be.rejected.and.notify(done);
+        });
+        it('reject with invalid data type pInput', function(done) {
+            ourBoard._impedanceTestFinalizeChannel(1,'taco',false).should.be.rejected.and.notify(done);
+        });
+        it('reject with invalid data type nInput', function(done) {
+            ourBoard._impedanceTestFinalizeChannel(1,false,'taco').should.be.rejected.and.notify(done);
+        });
+    });
+});

test/openBCIBoard-sdk-basic.js

@@ -1,26 +0,0 @@
-//'use strict';
-//
-//var sinon = require('sinon');
-//var chai = require('chai');
-//var expect = chai.expect;
-//
-//var MockedOpenBCIBoard = require('../test_mocks/openbci-hardware');
-//var openBCIBoard = MockedOpenBCIBoard.openBCIBoard;
-//var hardware = MockedOpenBCIBoard.hardware;
-//
-//describe('openBCIBoard', function () {
-//    var sandbox;
-//
-//    beforeEach(function (){
-//        sandbox = sinon.sandbox.create();
-//
-//        // Create a board for fun and profit
-//        hardware.reset();
-//        hardware.createBoard();
-//    });
-//
-//    afterEach(function () {
-//        sandbox.restore();
-//    });
-//
-//});

test/openBCISimulator-test.js

@@ -0,0 +1,710 @@
+var sinon = require('sinon'),
+    chai = require('chai'),
+    should = chai.should(),
+    expect = chai.expect,
+    openBCISimulator = require('../openBCISimulator'),
+    openBCISample = require('../openBCISample'),
+    k = openBCISample.k;
+
+var chaiAsPromised = require("chai-as-promised");
+var sinonChai = require("sinon-chai");
+chai.use(chaiAsPromised);
+chai.use(sinonChai);
+var bufferEqual = require('buffer-equal');
+var fs = require('fs');
+
+describe('openBCISimulator',function() {
+    this.timeout(4000);
+    var portName = k.OBCISimulatorPortName;
+    describe('#constructor', function () {
+        var simulator;
+        afterEach(() => {
+            simulator = null;
+        });
+        after(done => {
+            setTimeout(() => {
+                // Since there is a conditional timeout, it's important to wait to start the next test till this ends for sure
+                done();
+            }, 200); // The same amount of time in the simulator
+        });
+        it('constructs with the correct default options', function() {
+            simulator = new openBCISimulator.OpenBCISimulator();
+            expect(simulator.options.accel).to.be.true;
+            expect(simulator.options.alpha).to.be.true;
+            expect(simulator.options.boardFailure).to.be.false;
+            expect(simulator.options.daisy).to.be.false;
+            expect(simulator.options.drift).to.equal(0);
+            expect(simulator.options.firmwareVersion).to.equal(k.OBCIFirmwareV1);
+            expect(simulator.options.lineNoise).to.equal(k.OBCISimulatorLineNoiseHz60);
+            expect(simulator.options.sampleRate).to.equal(k.OBCISampleRate250);
+            expect(simulator.options.serialPortFailure).to.be.false;
+            expect(simulator.options.verbose).to.be.false;
+        });
+        it('should be able to get into daisy mode',function () {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                daisy: true
+            });
+            expect(simulator.options.daisy).to.be.true;
+        });
+        it('should set the correct sample rate in daisy mode, if no sampleRate is provided',function () {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                daisy: true
+            });
+            expect(simulator.options.sampleRate).to.equal(250); // produce samples at same rate
+        });
+        it('should use provided sample rate even if daisy is true',function () {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                daisy: true,
+                sampleRate: 20
+            });
+            expect(simulator.options.daisy).to.be.true;
+            expect(simulator.options.sampleRate).to.equal(20);
+        });
+        it('should be able to put into firmware version 2', function () {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                firmwareVersion: 'v2'
+            });
+            expect(simulator.options.firmwareVersion).to.equal(k.OBCIFirmwareV2);
+        });
+        it('should be able to simulate board failure',function () {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                boardFailure: true
+            });
+            expect(simulator.options.boardFailure).to.be.true;
+        });
+        it('should be able to simulate serial port failure',function () {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                serialPortFailure: true
+            });
+            expect(simulator.options.serialPortFailure).to.be.true;
+        });
+        it('can turn 50Hz line noise on', function() {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                lineNoise: '50Hz'
+            });
+            (simulator.options.lineNoise).should.equal(k.OBCISimulatorLineNoiseHz50);
+        });
+        it('can turn no line noise on', function() {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                lineNoise: 'None'
+            });
+            (simulator.options.lineNoise).should.equal(k.OBCISimulatorLineNoiseNone);
+        });
+        it('should not inject alpha if desired', function() {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                alpha: false
+            });
+            expect(simulator.options.alpha).to.be.false;
+        });
+        it('should be able to not use the accel', function() {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                accel: false
+            });
+            expect(simulator.options.accel).to.be.false;
+        });
+        it('should be able to set positive drift', function() {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                drift: 1
+            });
+            expect(simulator.options.drift).to.be.greaterThan(0);
+        });
+        it('should be able to set negative drift', function() {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                drift: -1
+            });
+            expect(simulator.options.drift).to.be.lessThan(0);
+        });
+    });
+    describe("_startStream", function() {
+        it('should return a packet with sample data in it', function(done) {
+            var simulator = new openBCISimulator.OpenBCISimulator(k.OBCISimulatorPortName);
+            var sampleCounter = 0;
+            var sampleTestSize = 5;
+
+            var newDataFunc = data => {
+                if (sampleCounter > sampleTestSize) {
+                    simulator.write(new Buffer([k.OBCIStreamStop]));
+                    simulator.removeListener('data',newDataFunc);
+                    openBCISample.parseRawPacketStandard(data,k.channelSettingsArrayInit(k.OBCINumberOfChannelsDefault),true)
+                        .then(sampleObject => {
+                            sampleObject.channelData.forEach((channelValue, index) => {
+                                expect(channelValue).to.not.equal(0);
+                            });
+                            simulator = null;
+                            done();
+                        });
+                } else {
+                    sampleCounter++;
+                }
+            }
+            simulator.on('data',newDataFunc);
+            simulator._startStream();
+        });
+        it('should return a sync set packet with accel',function(done) {
+            var simulator = new openBCISimulator.OpenBCISimulator(k.OBCISimulatorPortName);
+            var sampleCounter = 0;
+            var sampleTestSize = 5;
+
+            var newDataFunc = data => {
+                if (sampleCounter === 0) {
+                    // Ensure everything is switched on for this test
+                    simulator.options.accel = true;
+                    simulator.synced = true;
+                    simulator.sendSyncSetPacket = true;
+                    expect(data[k.OBCIPacketPositionStopByte]).to.equal(openBCISample.makeTailByteFromPacketType(k.OBCIStreamPacketStandardAccel));
+                } else if (sampleCounter === 1) {
+                    // Now this data should be the time sync up packet
+                    expect(data[k.OBCIPacketPositionStopByte]).to.equal(openBCISample.makeTailByteFromPacketType(k.OBCIStreamPacketAccelTimeSyncSet));
+                    // Expect flag to be down
+                    expect(simulator.sendSyncSetPacket).to.be.false;
+                } else if (sampleCounter >= sampleTestSize) {
+                    simulator.write(new Buffer([k.OBCIStreamStop]));
+                    simulator.removeListener('data',newDataFunc);
+                    simulator = null;
+                    done();
+                } else {
+                    // Now this data should be the time sync up packet
+                    expect(data[k.OBCIPacketPositionStopByte]).to.equal(openBCISample.makeTailByteFromPacketType(k.OBCIStreamPacketAccelTimeSynced));
+                }
+                sampleCounter++;
+            }
+
+            simulator.on('data',newDataFunc);
+            simulator._startStream();
+        });
+        it('should return a sync set packet with raw aux',function(done) {
+            var simulator = new openBCISimulator.OpenBCISimulator(k.OBCISimulatorPortName,{
+                accel: false
+            });
+            var sampleCounter = 0;
+            var sampleTestSize = 5;
+
+            var newDataFunc = data => {
+                if (sampleCounter === 0) {
+                    // Ensure everything is switched on for this test
+                    simulator.synced = true;
+                    simulator.sendSyncSetPacket = true;
+                    expect(data[k.OBCIPacketPositionStopByte]).to.equal(openBCISample.makeTailByteFromPacketType(k.OBCIStreamPacketStandardRawAux));
+                } else if (sampleCounter === 1) {
+                    // Now this data should be the time sync up packet
+                    expect(data[k.OBCIPacketPositionStopByte]).to.equal(openBCISample.makeTailByteFromPacketType(k.OBCIStreamPacketRawAuxTimeSyncSet));
+                    // Expect flag to be down
+                    expect(simulator.sendSyncSetPacket).to.be.false;
+                } else if (sampleCounter >= sampleTestSize) {
+                    simulator.write(new Buffer([k.OBCIStreamStop]));
+                    simulator.removeListener('data',newDataFunc);
+                    simulator = null;
+                    done();
+                } else {
+                    // Now this data should be the time sync up packet
+                    expect(data[k.OBCIPacketPositionStopByte]).to.equal(openBCISample.makeTailByteFromPacketType(k.OBCIStreamPacketRawAuxTimeSynced));
+                }
+                sampleCounter++;
+            }
+
+            simulator.on('data',newDataFunc);
+            simulator._startStream();
+        });
+    });
+    describe("firmwareVersion1",function () {
+
+    });
+    describe("firmwareVersion2",function () {
+        var simulator;
+        beforeEach(() => {
+            simulator = new openBCISimulator.OpenBCISimulator(k.OBCISimulatorPortName,{
+                firmwareVersion: 'v2'
+            });
+        });
+        afterEach(() => {
+            simulator = null;
+        });
+        describe('_processPrivateRadioMessage',function () {
+            describe('OBCIRadioCmdChannelGet',function () {
+                it('should emit success if firmware version 2', done => {
+                    simulator.channelNumber = 0;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            expect(buf[buf.length - 4]).to.equal(0);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelGet]));
+                });
+                it('should emit failure if board failure and host channel number', done => {
+                    // Turn board failure mode
+                    simulator.options.boardFailure = true;
+                    simulator.channelNumber = 9;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.false;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.true;
+                            expect(buf[buf.length - 4]).to.equal(9);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelGet]));
+                });
+            });
+            describe('OBCIRadioCmdChannelSet',function () {
+                it('should set the channel number if in bounds', done => {
+                    var newChanNum = 20;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            expect(buf[buf.length - 4]).to.equal(newChanNum);
+                            expect(simulator.channelNumber).to.equal(newChanNum);
+                            expect(simulator.hostChannelNumber).to.equal(newChanNum);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelSet,newChanNum]));
+                });
+                it('should not set the channel number if out of bounds', done => {
+                    var newChanNum = 26;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.false;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.true;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelSet,newChanNum]));
+                });
+                it('should emit failure if board failure', done => {
+                    // Turn board failure mode
+                    simulator.options.boardFailure = true;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.false;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.true;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelSet,7]));
+                });
+            });
+            describe('OBCIRadioCmdChannelSetOverride',function () {
+                it('should change just the hosts channel number and not the systems channel number and force a board comms failure', done => {
+                    var systemChannelNumber = 0;
+                    var newHostChannelNumber = 1;
+                    simulator.channelNumber = systemChannelNumber;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            expect(buf[buf.length - 4]).to.equal(newHostChannelNumber);
+                            expect(simulator.options.boardFailure).to.be.true;
+                            expect(simulator.channelNumber).to.equal(systemChannelNumber);
+                            expect(simulator.hostChannelNumber).to.equal(newHostChannelNumber);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelSetOverride,newHostChannelNumber]));
+                });
+                it('should change just the hosts channel number and not the systems channel number and fix a board failure', done => {
+                    var systemChannelNumber = 0;
+                    var oldHostChannelNumber = 1;
+                    simulator.channelNumber = systemChannelNumber;
+                    simulator.hostChannelNumber = oldHostChannelNumber;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            expect(buf[buf.length - 4]).to.equal(systemChannelNumber);
+                            expect(simulator.options.boardFailure).to.be.false;
+                            expect(simulator.channelNumber).to.equal(systemChannelNumber);
+                            expect(simulator.hostChannelNumber).to.equal(systemChannelNumber);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelSetOverride,systemChannelNumber]));
+                });
+                it('should not set the channel number if out of bounds', done => {
+                    var newChanNum = 26;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.false;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.true;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelSetOverride,newChanNum]));
+                });
+            });
+            describe('OBCIRadioCmdPollTimeGet',function () {
+                it('should emit success if firmware version 2 with poll time', done => {
+                    var expectedPollTime = 80;
+                    simulator.pollTime = expectedPollTime;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            expect(buf[buf.length - 4]).to.equal(expectedPollTime);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdPollTimeGet]));
+                });
+                it('should emit failure if board failure', done => {
+                    // Turn board failure mode
+                    simulator.options.boardFailure = true;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.false;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.true;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdPollTimeGet]));
+                });
+            });
+            describe('OBCIRadioCmdPollTimeSet',function () {
+                it('should set the poll time if in bounds', done => {
+                    var newPollTime = 20;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            expect(buf[buf.length - 4]).to.equal(newPollTime);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdPollTimeSet,newPollTime]));
+                });
+                it('should emit failure if board failure', done => {
+                    // Turn board failure mode
+                    simulator.options.boardFailure = true;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.false;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.true;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdPollTimeSet,7]));
+                });
+            });
+            describe('OBCIRadioCmdBaudRateSetDefault',function () {
+                it('should emit success if firmware version 2 with proper baud rate', done => {
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            var eotBuf = new Buffer('$$$');
+                            var newBaudRateBuf;
+                            for (var i = buf.length; i > 3; i--) {
+                                if (bufferEqual(buf.slice(i - 3, i),eotBuf)) {
+                                    newBaudRateBuf = buf.slice(i - 9, i - 3);
+                                    break;
+                                }
+                            }
+                            var newBaudRateNum = Number(newBaudRateBuf.toString());
+                            expect(newBaudRateNum).to.equal(k.OBCIRadioBaudRateDefault);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdBaudRateSetDefault]));
+                });
+                it('should emit success if board failure', done => {
+                    // Turn board failure mode
+                    simulator.options.boardFailure = true;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdBaudRateSetDefault]));
+                });
+            });
+            describe('OBCIRadioCmdBaudRateSetFast',function () {
+                it('should emit success if firmware version 2 with proper baud rate', done => {
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            var eotBuf = new Buffer("$$$");
+                            var newBaudRateBuf;
+                            for (var i = buf.length; i > 3; i--) {
+                                if (bufferEqual(buf.slice(i - 3, i),eotBuf)) {
+                                    newBaudRateBuf = buf.slice(i - 9, i - 3);
+                                    break;
+                                }
+                            }
+                            var newBaudRateNum = Number(newBaudRateBuf.toString());
+                            expect(newBaudRateNum).to.equal(k.OBCIRadioBaudRateFast);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdBaudRateSetFast]));
+                });
+                it('should emit success if board failure', done => {
+                    // Turn board failure mode
+                    simulator.options.boardFailure = true;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdBaudRateSetFast]));
+                });
+            });
+            describe('OBCIRadioCmdSystemStatus',function () {
+                it('should emit success if firmware version 2', done => {
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdSystemStatus]));
+                });
+                it('should emit failure if board failure', done => {
+                    // Turn board failure mode
+                    simulator.options.boardFailure = true;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.false;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.true;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdSystemStatus]));
+                });
+            });
+        });
+    });
+    describe("boardFailure",function () {
+
+    });
+
+    describe("#sync",function () {
+        this.timeout(2000);
+        var simulator;
+        beforeEach(function(done) {
+            simulator = new openBCISimulator.OpenBCISimulator(portName, {
+                firmwareVersion: 'v2'
+            });
+            simulator.once('open',() => {
+                done();
+            });
+        });
+        afterEach(function() {
+            simulator = null;
+        });
+        it("should emit the time sync sent command", function(done) {
+            simulator.once('data',data => {
+                expect(openBCISample.isTimeSyncSetConfirmationInBuffer(data)).to.be.true;
+                done();
+            });
+            simulator.write(k.OBCISyncTimeSet, (err, msg) => {
+                if (err) {
+                    done(err);
+                }
+            });
+        });
+        it("should set synced to true", function(done) {
+            simulator.synced = false;
+            var newData = data => {
+                expect(simulator.synced).to.be.true;
+                simulator.removeListener('data', newData);
+                done();
+            };
+
+            simulator.on('data', data => {
+                newData(data);
+            });
+
+            simulator.write(k.OBCISyncTimeSet, (err, msg) => {
+                if (err) {
+                    done(err);
+                }
+            });
+        });
+        it("should emit a time sync set packet followed by a time synced accel packet after sync up call", function(done) {
+            simulator.synced = false;
+            var emitCounter = 0;
+            var maxPacketsBetweenSetPacket = 5;
+            var newData = data => {
+                if (emitCounter === 0) { // the time sync packet is emitted here
+                    // Make a call to start streaming
+                    simulator.write(k.OBCIStreamStart, err => {
+                        if (err) done(err);
+                    });
+                } else if (emitCounter < maxPacketsBetweenSetPacket) {
+                    if (openBCISample.getRawPacketType(data[k.OBCIPacketPositionStopByte]) === k.OBCIStreamPacketAccelTimeSyncSet) {
+                        simulator.removeListener('data', newData);
+                        simulator.write(k.OBCIStreamStop, err => {
+                            if (err) done(err);
+                            done();
+                        });
+                    } else {
+                        expect(openBCISample.getRawPacketType(data[k.OBCIPacketPositionStopByte])).to.equal(k.OBCIStreamPacketAccelTimeSynced);
+
+                    }
+                } else {
+                    done("Failed to get set packet in time")
+                }
+                emitCounter++;
+            };
+
+            simulator.on('data', newData);
+
+            simulator.write(k.OBCISyncTimeSet, (err, msg) => {
+                if (err) {
+                    done(err);
+                }
+            });
+        });
+        it("should emit a time sync set raw aux, then time synced raw aux packet after sync up call", function(done) {
+            simulator.synced = false;
+            simulator.options.accel = false;
+            var emitCounter = 0;
+            var maxPacketsBetweenSetPacket = 5;
+            var newData = data => {
+                if (emitCounter === 0) { // the time sync packet is emitted here
+                    // Make a call to start streaming
+                    simulator.write(k.OBCIStreamStart, err => {
+                        if (err) done(err);
+                    });
+                } else if (emitCounter < maxPacketsBetweenSetPacket) {
+                    if (openBCISample.getRawPacketType(data[k.OBCIPacketPositionStopByte]) === k.OBCIStreamPacketRawAuxTimeSyncSet) {
+                        simulator.removeListener('data', newData);
+                        simulator.write(k.OBCIStreamStop, err => {
+                            if (err) done(err);
+                            done();
+                        });
+                    } else {
+                        expect(openBCISample.getRawPacketType(data[k.OBCIPacketPositionStopByte])).to.equal(k.OBCIStreamPacketRawAuxTimeSynced);
+                    }
+                } else {
+                    done("Failed to get set packet in time")
+                }
+
+                emitCounter++;
+            };
+
+            simulator.on('data', newData);
+
+            simulator.write(k.OBCISyncTimeSet, (err, msg) => {
+                if (err) {
+                    done(err);
+                }
+            });
+        });
+    })
+});