Merge pull request #70 from pushtheworldllc/bug-time-sync

Bug time sync

.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,7 +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:

README.md

@@ -1,28 +1,29 @@
-[![Stories in Ready](https://badge.waffle.io/OpenBCI/openbci-js-sdk.png?label=ready&title=Ready)](https://waffle.io/OpenBCI/openbci-js-sdk)
-[![Join the chat at https://gitter.im/OpenBCI/openbci-js-sdk](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/OpenBCI/openbci-js-sdk?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-[![Build Status](https://travis-ci.org/OpenBCI/openbci-js-sdk.svg?branch=master)](https://travis-ci.org/OpenBCI/openbci-js-sdk)
-[![codecov.io](https://codecov.io/github/OpenBCI/openbci-js-sdk/coverage.svg?branch=master)](https://codecov.io/github/OpenBCI/openbci-js-sdk?branch=master)
+[![Stories in Ready](https://badge.waffle.io/OpenBCI/OpenBCI_NodeJS.png?label=ready&title=Ready)](https://waffle.io/OpenBCI/OpenBCI_NodeJS)
+[![Join the chat at https://gitter.im/OpenBCI/OpenBCI_NodeJS](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/OpenBCI/OpenBCI_NodeJS?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Build Status](https://travis-ci.org/OpenBCI/OpenBCI_NodeJS.svg?branch=master)](https://travis-ci.org/OpenBCI/OpenBCI_NodeJS)
+[![codecov](https://codecov.io/gh/OpenBCI/OpenBCI_NodeJS/branch/master/graph/badge.svg)](https://codecov.io/gh/OpenBCI/OpenBCI_NodeJS)
 
 # OpenBCI Node.js SDK
 
 A Node.js module for OpenBCI ~ written with love by [Push The World!](http://www.pushtheworldllc.com)
 
-We are proud to support all functionality of the OpenBCI 8 Channel board (16 channel coming soon) and are actively developing and maintaining this module. 
+We are proud to support all functionality of the OpenBCI 8 and 16 Channel boards and are actively developing and maintaining this module.
 
-The purpose of this module is to **get connected** and **start streaming** as fast as possible. 
+The purpose of this module is to **get connected** and **start streaming** as fast as possible.
 
 ## TL;DR
 
 #### Install via npm:
 
 ```
-npm install openbci-sdk
+npm install openbci
 ```
 
 #### Get connected and start streaming
 
 ```js
-var ourBoard = new require('openbci-sdk').OpenBCIBoard();
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard();
 ourBoard.connect(portName)
     .then(function() {
         ourBoard.on('ready',function() {
@@ -30,7 +31,7 @@ ourBoard.connect(portName)
             ourBoard.on('sample',function(sample) {
                 /** Work with sample */
                 for (var i = 0; i < ourBoard.numberOfChannels(); i++) {
-                    console.log("Channel " + (i + 1) + ": " + sample.channelData[i].toFixed(8) + " Volts."); 
+                    console.log("Channel " + (i + 1) + ": " + sample.channelData[i].toFixed(8) + " Volts.");
                     // prints to the console
                     //  "Channel 1: 0.00001987 Volts."
                     //  "Channel 2: 0.00002255 Volts."
@@ -60,14 +61,15 @@ Initialization
 Initializing the board:
 
 ```js
-var OpenBCIBoard = require('openbci-sdk');
+var OpenBCIBoard = require('openbci');
 var ourBoard = new OpenBCIBoard.OpenBCIBoard();
 ```
 
 For initializing with options, such as verbose print outs:
 
 ```js
-var ourBoard = require('openbci-sdk').OpenBCIBoard({
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard({
     verbose: true
 });
 ```
@@ -75,14 +77,15 @@ var ourBoard = require('openbci-sdk').OpenBCIBoard({
 Or if you don't have a board and want to use synthetic data:
 
 ```js
-var ourBoard = require('openbci-sdk').OpenBCIBoard({
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard({
     simulate: true
 });
 ```
 
 Another useful way to start the simulator:
 ```js
-var openBCIBoard = require('openbci-sdk');
+var openBCIBoard = require('openbci');
 var k = openBCIBoard.OpenBCIConstants;
 var ourBoard = openBCIBoard.OpenBCIBoard();
 ourBoard.connect(k.OBCISimulatorPortName) // This will set `simulate` to true
@@ -99,11 +102,12 @@ ourBoard.connect(k.OBCISimulatorPortName) // This will set `simulate` to true
 'ready' event
 ------------
 
-You MUST wait for the 'ready' event to be emitted before streaming/talking with the board. The ready happens asynchronously 
+You MUST wait for the 'ready' event to be emitted before streaming/talking with the board. The ready happens asynchronously
 so installing the 'sample' listener and writing before the ready event might result in... nothing at all.
 
 ```js
-var ourBoard = new require('openbci-sdk').OpenBCIBoard();
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard();
 ourBoard.connect(portName).then(function(boardSerial) {
     ourBoard.on('ready',function() {
         /** Start streaming, reading registers, what ever your heart desires  */
@@ -115,11 +119,14 @@ ourBoard.connect(portName).then(function(boardSerial) {
 
 Sample properties:
 ------------------
-* `startByte` (`Number`  should be `0xA0`)
-* `sampleNumber` (a `Number` between 0-255) 
+* `startByte` (`Number` should be `0xA0`)
+* `sampleNumber` (a `Number` between 0-255)
 * `channelData` (channel data indexed at 0 filled with floating point `Numbers` in Volts)
-* `auxData` (aux data indexed starting at 0 [0,1,2] filled with floating point `Numbers`)
-* `stopByte` (`Number` should be `0xC0`)
+* `accelData` (`Array` with X, Y, Z accelerometer values when new data available)
+* `auxData` (`Buffer` filled with either 2 bytes (if time synced) or 6 bytes (not time synced))
+* `stopByte` (`Number` should be `0xCx` where x is 0-15 in hex)
+* `boardTime` (`Number` the raw board time)
+* `timeStamp` (`Number` the `boardTime` plus the NTP calculated offset)
 
 The power of this module is in using the sample emitter, to be provided with samples to do with as you wish.
 
@@ -132,7 +139,8 @@ To get a 'sample' event, you need to:
 3. In callback for 'ready' emitter, call `streamStart()`
 4. Install the 'sample' event emitter
 ```js
-var ourBoard = new require('openbci-sdk').OpenBCIBoard();
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard();
 ourBoard.connect(portName).then(function() {
     ourBoard.on('ready',function() {
         ourBoard.streamStart();
@@ -146,10 +154,77 @@ ourBoard.connect(portName).then(function() {
 ```
 Close the connection with `.streamStop()` and disconnect with `.disconnect()`
 ```js
-var ourBoard = new require('openbci-sdk').OpenBCIBoard();
+var ourBoard = new require('openbci').OpenBCIBoard();
 ourBoard.streamStop().then(ourBoard.disconnect());
 ```
 
+Time Syncing
+------------
+You must be using OpenBCI firmware version 2 in order to do time syncing. After you `.connect()` and send a `.softReset()`, you can call `.usingVersionTwoFirmware()` to get a boolean response as to if you are using `v1` or `v2`.
+
+Now using firmware `v2`, the fun begins! We synchronize the Board's clock with the module's time. In firmware `v2` we leverage samples with time stamps and different time stamps and unique new features to calculate a time sync strategy. Time syncing has been verified to +/- 4ms and a test report is on the way. We are still working on the synchronize of this module and an NTP server, this is an open call for any NTP experts out there! With a global NTP server you could use several different devices and all sync to the same time server. That way you can really do some serious cloud computing!
+
+Keep your resync interval above 50ms. While it's important to resync every couple minutes due to drifting of clocks, please do not try to sync without getting the last sync event! We can only support one sync operation at a time!
+
+Using local computer time:
+```js
+var OpenBCIBoard = require('openbci').OpenBCIBoard,
+    ourBoard = new OpenBCIBoard({
+        verbose:true
+    });
+
+const resyncPeriodMin = 5; // re sync every five minutes
+const secondsInMinute = 60;
+var sampleRate = k.OBCISampleRate250; // Default to 250, ALWAYS verify with a call to `sampleRate` after `ready` event!
+var timeSyncPossible = false;
+
+// Call to connect
+ourBoard.connect(portName).then(() => {
+    ourBoard.on('ready',() => {
+        // Get the sample rate after 'ready' event!
+        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();
+
+        ourBoard.streamStart()
+            .then(() => {
+                /** Start streaming command sent to board. */
+            })
+            .catch(err => {
+                console.log(`stream start: ${err}`);
+            })
+    });
+
+    // PTW recommends sample driven  
+    ourBoard.on('sample',sample => {
+        // Resynchronize every every 5 minutes
+        if (sample._count % (sampleRate * resyncPeriodMin * secondsInMinute) === 0) {
+            ourBoard.syncClocksFull()
+                .then(syncObj => {
+                    // Sync was successful
+                    if (syncObj.valid) {
+                        // Log the object to check it out!
+                        console.log(`syncObj`,syncObj);
+
+                    // Sync was not successful
+                    } else {
+                        // Retry it
+                        console.log(`Was not able to sync, please retry?`);
+                    }
+                });
+        }
+
+        if (sample.timeStamp) { // true after the first sync
+            console.log(`NTP Time Stamp ${sample.timeStamp}`);
+        }
+
+    });
+})
+.catch(err => {
+    console.log(`connect: ${err}`);
+});
+```
+
 Auto-finding boards
 -------------------
 You must have the OpenBCI board connected to the PC before trying to automatically find it.
@@ -157,10 +232,11 @@ You must have the OpenBCI board connected to the PC before trying to automatical
 If a port is not automatically found, then call `.listPorts()` to get a list of all serial ports this would be a good place to present a drop down picker list to the user, so they may manually select the serial port name.
 
 ```js
-var ourBoard = new require('openbci-sdk').OpenBCIBoard();
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard();
 ourBoard.autoFindOpenBCIBoard().then(portName => {
     if(portName) {
-        /** 
+        /**
         * Connect to the board with portName
         * i.e. ourBoard.connect(portName).....
         */
@@ -174,11 +250,11 @@ Note: `.autoFindOpenBCIBoard()` will return the name of the Simulator if you ins
 
 Auto Test - (Using impedance to determine signal quality)
 ---------------------------------------------------------
-Measuring impedance is a vital tool in ensuring great data is collected. 
+Measuring impedance is a vital tool in ensuring great data is collected.
 
 **_IMPORTANT!_** Measuring impedance takes time, so *only test what you must*
 
-Your OpenBCI board will have electrodes hooked up to either a P input, N input or in some cases both inputs. 
+Your OpenBCI board will have electrodes hooked up to either a P input, N input or in some cases both inputs.
 
 To test specific inputs of channels:
 
@@ -198,7 +274,8 @@ Where there are the same number of elements as channels and each element can be
 
 Without further ado, here is an example:
 ```js
-var ourBoard = new require('openbci-sdk').OpenBCIBoard();
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard();
 ourBoard.connect(portName).then(function(boardSerial) {
     ourBoard.on('ready',function() {
         ourBoard.streamStart();
@@ -209,7 +286,7 @@ ourBoard.connect(portName).then(function(boardSerial) {
     });
 }).catch(function(err) {
     /** Handle connection errors */
-}); 
+});
 ```
 
 But wait! What is this `impedanceArray`? An Array of Objects, for each object:
@@ -217,11 +294,11 @@ But wait! What is this `impedanceArray`? An Array of Objects, for each object:
 [{
     channel: 1,
     P: {
-        raw: -1, 
+        raw: -1,
         text: 'init'
     },
     N: {
-        raw: -1, 
+        raw: -1,
         text: 'init'
     }
 },
@@ -254,7 +331,8 @@ To run an impedance test on all inputs, one channel at a time:
 For example:
 
 ```js
-var ourBoard = new require('openbci-sdk').OpenBCIBoard();
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard();
 ourBoard.connect(portName).then(function(boardSerial) {
     ourBoard.streamStart();
     ourBoard.on('impedanceArray', impedanceArray => {
@@ -278,28 +356,36 @@ Create new instance of an OpenBCI board.
 
 Board optional configurations.
 
-* `boardType` Specifies type of OpenBCI board (3 possible boards)
+* `baudRate` {Number} - Baud Rate, defaults to 115200. Manipulating this is allowed if firmware on board has been previously configured.
+* `boardType` {String} - Specifies type of OpenBCI board (3 possible boards)
   * `default` - 8 Channel OpenBCI board (Default)
-  * `daisy` - 8 Channel board with Daisy Module
-    (NOTE: THIS IS IN-OP AT THIS TIME DUE TO NO ACCESS TO ACCESSORY BOARD)
+  * `daisy` - 8 Channel board with Daisy Module - 16 Channels
   * `ganglion` - 4 Channel board
-    (NOTE: THIS IS IN-OP TIL RELEASE OF GANGLION BOARD 07/2016)
-* `baudRate` Baud Rate, defaults to 115200. Manipulating this is allowed if firmware on board has been previously configured.
-* `verbose` To output more messages to the command line.
-* `simulate` Full functionality, just synthetic data.
-* `simulatorSampleRate` - The sample rate to use for the simulator (Default is `250`)
-* `simulatorAlpha` - {Boolean} - Inject and 10Hz alpha wave in Channels 1 and 2 (Default `true`)
-* `simulatorLineNoise` - Injects line noise on channels.
-  * `60Hz` - 60Hz line noise (Default) (ex. __United States__)
-  * `50Hz` - 50Hz line noise (ex. __Europe__)
+    (NOTE: THIS IS IN-OP TIL RELEASE OF GANGLION BOARD 08/2016)
+* `simulate` {Boolean} - Full functionality, just mock data. Must attach Daisy module by setting `simulatorDaisyModuleAttached` to `true` in order to get 16 channels. (Default `false`)
+* `simulatorBoardFailure` {Boolean} - Simulates board communications failure. This occurs when the RFduino on the board is not polling the RFduino on the dongle. (Default `false`)
+* `simulatorDaisyModuleAttached` {Boolean} - Simulates a daisy module being attached to the OpenBCI board. This is useful if you want to test how your application reacts to a user requesting 16 channels but there is no daisy module actually attached, or vice versa, where there is a daisy module attached and the user only wants to use 8 channels. (Default `false`)
+* `simulatorFirmwareVersion` {String} - Allows the simulator to use firmware version 2 features. (2 Possible Options)
+  * `v1` - Firmware Version 1 (Default)
+  * `v2` - Firmware Version 2
+* `simulatorHasAccelerometer` - {Boolean} - Sets simulator to send packets with accelerometer data. (Default `true`)
+* `simulatorInjectAlpha` - {Boolean} - Inject a 10Hz alpha wave in Channels 1 and 2 (Default `true`)
+* `simulatorInjectLineNoise` {String} - Injects line noise on channels. (3 Possible Options)
+  * `60Hz` - 60Hz line noise (Default) [America]
+  * `50Hz` - 50Hz line noise [Europe]
   * `None` - Do not inject line noise.
-* `sntp` - Syncs the module up with an SNTP time server. Syncs the board on startup with the SNTP time. Adds a time stamp to the AUX channels. NOTE: (NOT FULLY IMPLEMENTED) [DO NOT USE]
+* `simulatorSampleRate` {Number} - The sample rate to use for the simulator. Simulator will set to 125 if `simulatorDaisyModuleAttached` is set `true`. However, setting this option overrides that setting and this sample rate will be used. (Default is `250`)
+* `simulatorSerialPortFailure` {Boolean} - Simulates not being able to open a serial connection. Most likely due to a OpenBCI dongle not being plugged in.
+* `sntpTimeSync` - {Boolean} Syncs the module up with an SNTP time server and uses that as single source of truth instead of local computer time. (Default `true`)
+* `sntpTimeSyncHost` - {String} The sntp server to use, can be either sntp or ntp (Defaults `pool.ntp.org`).
+* `sntpTimeSyncPort` - {Number} The port to access the sntp server (Defaults `123`)
+* `verbose` {Boolean} - Print out useful debugging events
 
-**Note, we have added support for either all lowercase OR camelcase of the options, use whichever style you prefer.**
+**Note, we have added support for either all lowercase OR camel case for the options, use whichever style you prefer.**
 
 ### .autoFindOpenBCIBoard()
 
-Automatically find an OpenBCI board. 
+Automatically find an OpenBCI board.
 
 **Note: This will always return an Array of `COM` ports on Windows**
 
@@ -311,7 +397,7 @@ Turn off a specified channel
 
 **_channelNumber_**
 
-A number (1-16) specifying which channel you want to turn off. 
+A number (1-16) specifying which channel you want to turn off.
 
 **_Returns_** a promise, fulfilled if the command was sent to the write queue.
 
@@ -321,7 +407,7 @@ Turn on a specified channel
 
 **_channelNumber_**
 
-A number (1-16) specifying which channel you want to turn on. 
+A number (1-16) specifying which channel you want to turn on.
 
 **_Returns_** a promise, fulfilled if the command was sent to the write queue.
 
@@ -333,19 +419,19 @@ Send a channel setting command to the board.
 
 Determines which channel to set. It's a 'Number' (1-16)
 
-**_powerDown_** 
+**_powerDown_**
 
 Powers the channel up or down. It's a 'Bool' where `true` turns the channel off and `false` turns the channel on (default)
 
 **_gain_**
- 
+
 Sets the gain for the channel. It's a 'Number' that is either (1,2,4,6,8,12,24(default))
-  
-**_inputType_** 
-  
+
+**_inputType_**
+
 Selects the ADC channel input source. It's a 'String' that **MUST** be one of the following: "normal", "shorted", "biasMethod" , "mvdd" , "temp" , "testsig", "biasDrp", "biasDrn".
 
-**_bias_** 
+**_bias_**
 
 Selects if the channel shall include the channel input in bias generation. It's a 'Bool' where `true` includes the channel in bias (default) or `false` it removes it from bias.
 
@@ -354,7 +440,7 @@ Selects if the channel shall include the channel input in bias generation. It's
 Select to connect (`true`) this channel's P input to the SRB2 pin. This closes a switch between P input and SRB2 for the given channel, and allows the P input to also remain connected to the ADC. It's a 'Bool' where `true` connects this input to SRB2 (default) or `false` which disconnect this input from SRB2.
 
 **_srb1_**
-           
+
 Select to connect (`true`) all channels' N inputs to SRB1. This effects all pins, and disconnects all N inputs from the ADC. It's a 'Bool' where `true` connects all N inputs to SRB1 and `false` disconnects all N inputs from SRB1 (default).
 
 **_Returns_** a promise fulfilled if proper commands sent to the write queue, rejects on bad input or no board.
@@ -373,7 +459,7 @@ The essential precursor method to be called initially to establish a serial conn
 
 The system path of the OpenBCI board serial port to open. For example, `/dev/tty` on Mac/Linux or `COM1` on Windows.
 
-**_Returns_** a promise, fulfilled by a successful serial connection to the board, the promise will be rejected at any time if the serial port has an 'error' or 'close' event emitted.
+**_Returns_** a promise, fulfilled by a successful serial connection to the board.
 
 ### .debugSession()
 
@@ -381,7 +467,7 @@ Calls all `.printPacketsBad()`, `.printPacketsRead()`, `.printBytesIn()`
 
 ### .disconnect()
 
-Closes the serial port opened by `.connect()`
+Closes the serial port opened by `.connect()`.  Waits for stop streaming command to be sent if currently streaming.
 
 **_Returns_** a promise, fulfilled by a successful close of the serial port object, rejected otherwise.
 
@@ -389,7 +475,7 @@ Closes the serial port opened by `.connect()`
 
 Gets the specified channelSettings register data from printRegisterSettings call.
 
-**_channelNumber_** 
+**_channelNumber_**
 
 A number specifying which channel you want to get data on. Only 1-8 at this time.
 
@@ -409,10 +495,10 @@ Don't forget to install the `impedanceArray` emitter to receive the impendances!
 
 ### .impedanceTestChannels(arrayOfCommands)
 
-**_arrayOfCommands_** 
+**_arrayOfCommands_**
 
 The array of configurations where there are the same number of elements as channels and each element can be either:
-                            
+
 * `p` or `P` (only test P input)
 * `n` or `N` (only test N input)
 * `b` or `B` (test both inputs) (takes 66% longer to run then previous two `p` or `n`)
@@ -434,9 +520,10 @@ A Number, specifies which channel you want to test.
 
 **_Returns_** a promise that resolves a single channel impedance object.
 
-Example:
+**Example**
 ```js
-var ourBoard = new require('openbci-sdk').OpenBCIBoard();
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard();
 ourBoard.connect(portName).then(function(boardSerial) {
     ourBoard.on('ready',function() {
         ourBoard.streamStart();
@@ -448,18 +535,18 @@ ourBoard.connect(portName).then(function(boardSerial) {
     });
 }).catch(function(err) {
     /** Handle connection errors */
-}); 
+});
 ```
 Where an impedance for this method call would look like:
 ```js
 {
     channel: 1,
     P: {
-        raw: 2394.45, 
+        raw: 2394.45,
         text: 'good'
     },
     N: {
-        raw: 7694.45, 
+        raw: 7694.45,
         text: 'ok'
     }
 }
@@ -475,9 +562,10 @@ A Number, specifies which channel you want to test.
 
 **_Returns_** a promise that resolves a single channel impedance object.
 
-Example:
+**Example**
 ```js
-var ourBoard = new require('openbci-sdk').OpenBCIBoard();
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard();
 ourBoard.connect(portName).then(function(boardSerial) {
     ourBoard.on('ready',function() {
         ourBoard.streamStart();
@@ -489,18 +577,18 @@ ourBoard.connect(portName).then(function(boardSerial) {
     });
 }).catch(function(err) {
     /** Handle connection errors */
-}); 
+});
 ```
 Where an impedance for this method call would look like:
 ```js
 {
     channel: 1,
     P: {
-        raw: 2394.45, 
+        raw: 2394.45,
         text: 'good'
     },
     N: {
-        raw: -1, 
+        raw: -1,
         text: 'init'
     }
 }
@@ -516,9 +604,10 @@ A Number, specifies which channel you want to test.
 
 **_Returns_** a promise that resolves a single channel impedance object.
 
-Example:
+**Example**
 ```js
-var ourBoard = new require('openbci-sdk').OpenBCIBoard();
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard();
 ourBoard.connect(portName).then(function(boardSerial) {
     ourBoard.on('ready',function() {
         ourBoard.streamStart();
@@ -530,18 +619,18 @@ ourBoard.connect(portName).then(function(boardSerial) {
     });
 }).catch(function(err) {
     /** Handle connection errors */
-}); 
+});
 ```
 Where an impedance for this method call would look like:
 ```js
 {
     channel: 1,
     P: {
-        raw: -1, 
+        raw: -1,
         text: 'init'
     },
-    N: { 
-        raw: 7694.45, 
+    N: {
+        raw: 7694.45,
         text: 'ok'
     }
 }
@@ -591,6 +680,78 @@ Prints all register settings for the ADS1299 and the LIS3DH on the OpenBCI board
 
 **_Returns_** a promise, fulfilled if the command was sent to the write queue.
 
+### .radioBaudRateSet(speed)
+
+Used to set the OpenBCI Host (Dongle) baud rate. With the RFduino configuration, the Dongle is the Host and the Board is the Device. Only the Device can initiate a communication between the two entities. There exists a detrimental error where if the Host is interrupted by the radio during a Serial write, then all hell breaks loose. So this is an effort to eliminate that problem by increasing the rate at which serial data is sent from the Host to the Serial driver. The rate can either be set to default or fast. Further the function should reject if currently streaming. Lastly and more important, if the board is not running the new firmware then this functionality does not exist and thus this method will reject. If the board is using firmware 2+ then this function should resolve the new baud rate after closing the current serial port and reopening one.
+
+**Note, this functionality requires OpenBCI Firmware Version 2.0**
+
+**_speed_**
+
+{String} - The baud rate that to switch to. Can be either `default` (115200) or `fast` (230400).
+
+**_Returns_** {Promise} - Resolves a {Number} that is the new baud rate, rejects on error.
+
+### .radioChannelGet()
+
+Used to query the OpenBCI system for it's radio channel number. The function will reject if not connected to the serial port of the dongle. Further the function should reject if currently streaming. Lastly and more important, if the board is not running the new firmware then this functionality does not exist and thus this method will reject. If the board is using firmware 2+ then this function should resolve an Object. See `returns` below.
+
+**Note, this functionality requires OpenBCI Firmware Version 2.0**
+
+**_Returns_** {Promise} - Resolve an object with keys `channelNumber` which is a Number and `err` which contains an error in the condition that there system is experiencing board communications failure.
+
+### .radioChannelSet(channelNumber)
+
+Used to set the system radio channel number. The function will reject if not connected to the serial port of the dongle. Further the function should reject if currently streaming. Lastly and more important, if the board is not running the new firmware then this functionality does not exist and thus this method will reject. If the board is using firmware 2+ then this function should resolve.
+
+**Note, this functionality requires OpenBCI Firmware Version 2.0**
+
+**_channelNumber_**
+
+{Number} - The channel number you want to set to, 1-25.
+
+**_Returns_** {Promise} - Resolves with the new channel number, rejects with err.
+
+### .radioChannelSetHostOverride(channelNumber)
+
+Used to set the ONLY the radio dongle Host channel number. This will fix your radio system if your dongle and board are not on the right channel and bring down your radio system if you take your dongle and board are not on the same channel. Use with caution! The function will reject if not connected to the serial port of the dongle. Further the function should reject if currently streaming. Lastly and more important, if the board is not running the new firmware then this functionality does not exist and thus this method will reject. If the board is using firmware 2+ then this function should resolve.
+
+**Note, this functionality requires OpenBCI Firmware Version 2.0**
+
+**_channelNumber_**
+
+{Number} - The channel number you want to set to, 1-25.
+
+**_Returns_** {Promise} - Resolves with the new channel number, rejects with err.
+
+### .radioPollTimeGet()
+
+Used to query the OpenBCI system for it's device's poll time. The function will reject if not connected to the serial port of the dongle. Further the function should reject if currently streaming. Lastly and more important, if the board is not running the new firmware then this functionality does not exist and thus this method will reject. If the board is using firmware 2+ then this function should resolve the poll time when fulfilled. It's important to note that if the board is not on, this function will always be rejected with a failure message.
+
+**Note, this functionality requires OpenBCI Firmware Version 2.0**
+
+**_Returns_** {Promise} - Resolves with the new poll time, rejects with err.
+
+### .radioPollTimeSet(pollTime)
+
+Used to set the OpenBCI poll time. With the RFduino configuration, the Dongle is the Host and the Board is the Device. Only the Device can initiate a communication between the two entities. Therefore this sets the interval at which the Device polls the Host for new information. Further the function should reject if currently streaming. Lastly and more important, if the board is not running the new firmware then this functionality does not exist and thus this method will reject. If the board is using firmware 2+ then this function should resolve.
+
+**Note, this functionality requires OpenBCI Firmware Version 2.0**
+
+**_pollTime_**
+
+{Number} - The poll time you want to set to, 0-255.
+
+**_Returns_** {Promise} - Resolves with the new channel number, rejects with err.
+
+### .radioSystemStatusGet()
+
+Used to ask the Host if it's radio system is up. This is useful to quickly determine if you are in fact ready to start trying to connect and such. The function will reject if not connected to the serial port of the dongle. Further the function should reject if currently streaming. Lastly and more important, if the board is not running the new firmware then this functionality does not exist and thus this method will reject. If the board is using firmware +v2.0.0 and the radios are both on the same channel and powered, then this will resolve true.
+
+**Note, this functionality requires OpenBCI Firmware Version 2.0**
+
+**_Returns_** {Promise} - Resolves true if both radios are powered and on the same channel; false otherwise.
+
 ### .sampleRate()
 
 Get the current sample rate.
@@ -616,7 +777,7 @@ The duration you want to log SD information for. Opens a new SD file to write in
  * `4hour` - 4 hour
  * `12hour` - 12 hour
  * `24hour` - 24 hour
- 
+
 **Note: You must have the proper type of SD card inserted into the board for logging to work.**
 
 **_Returns_** resolves if the command was added to the write queue.
@@ -637,7 +798,7 @@ To enter simulate mode. Must call `.connect()` after.
 
 ### .simulatorDisable()
 
-To leave simulate mode. 
+To leave simulate mode.
 
 **Note, must be called after the constructor.**
 
@@ -653,23 +814,11 @@ Stateful method for querying the current offset only when the last one is too ol
 
 **_Returns_** a promise with the time offset
 
-### .sntpGetServerTime()
-
-Get time from the SNTP server. Must have internet connection!
-
-**_Returns_** a promise fulfilled with time object
-
-### .sntpNow()
-
-This function gets SNTP time since Jan 1, 1970, if we call this after a successful `.sntpStart()` this time will be sycned, or else we will just get the current computer time, the case if there is no internet. 
-
-**_Returns_** time since UNIX epoch in ms.
-
 ### .sntpStart()
 
-This starts the SNTP server and gets it to remain in sync with the SNTP server;
+This starts the SNTP server and gets it to remain in sync with the SNTP server.
 
-**_Returns_** a promise if the module was able to sync with ntp server.
+**_Returns_** a promise if the module was able to sync with NTP server.
 
 ### .sntpStop()
 
@@ -685,7 +834,7 @@ Sends a soft reset command to the board.
 
 ### .streamStart()
 
-Sends a start streaming command to the board. 
+Sends a start streaming command to the board.
 
 **Note, You must have called and fulfilled `.connect()` AND observed a `'ready'` emitter before calling this method.**
 
@@ -693,12 +842,110 @@ Sends a start streaming command to the board.
 
 ### .streamStop()
 
-Sends a stop streaming command to the board. 
+Sends a stop streaming command to the board.
 
 **Note, You must have called and fulfilled `.connect()` AND observed a `'ready'` emitter before calling this method.**
 
 **_Returns_** a promise, fulfilled if the command was sent to the write queue, rejected if unable.
 
+### .syncClocks()
+
+Send the command to tell the board to start the syncing protocol. Must be connected, streaming and using version +2 firmware.
+
+**Note, this functionality requires OpenBCI Firmware Version 2.0**
+
+**_Returns_** {Promise} resolves if the command was sent to the write queue, rejects if unable.
+
+### .syncClocksFull()
+
+Send the command to tell the board to start the syncing protocol. Must be connected, streaming and using v2 firmware. Uses the `synced` event to ensure multiple syncs don't overlap.
+
+**Note, this functionality requires OpenBCI Firmware Version 2.0**
+
+**_Returns_** {Promise} resolves if `synced` event is emitted, rejects if not connected or using firmware v2. Resolves with a synced object:
+```javascript
+{
+    boardTime: 0, // The time contained in the time sync set packet.
+    correctedTransmissionTime: false, // If the confirmation and the set packet arrive in the same serial flush we have big problem! This will be true in this case. See source code for full explanation.
+    timeSyncSent: 0, // The time the `<` was sent to the Dongle.
+    timeSyncSentConfirmation: 0, // The time the `<` was sent to the Board; It's really the time `,` was received from the Dongle.
+    timeSyncSetPacket: 0, // The time the set packet was received from the Board.
+    timeRoundTrip: 0, // Simply timeSyncSetPacket - timeSyncSent.
+    timeTransmission: 0, // Estimated time it took for time sync set packet to be sent from Board to Driver.
+    timeOffset: 0, // The map (or translation) from boardTime to module time.
+    valid: false // If there was an error in the process, valid will be false and no time sync was done. It's important to resolve this so we can perform multiple promise syncs as show in the example below.
+}
+```
+
+**Example**
+
+```javascript
+var OpenBCIBoard = require('openbci').OpenBCIBoard,
+    ourBoard = new OpenBCIBoard({
+        verbose:true
+    });
+
+var portName = /* INSERT PORT NAME HERE */;
+var samples = []; // Array to store time synced samples into
+var timeSyncActivated = false;
+
+ourBoard.connect(portName)
+    .then(() => {
+        ourBoard.on('ready',() => {
+            ourBoard.streamStart()
+                .then(() => {
+                    /** Could also call `.syncClocksFull()` here */
+                })
+                .catch(err => {
+                    console.log(`Error starting stream ${err}`);
+                })
+            });
+        ourBoard.on('sample',sample => {
+            /** If we are not synced, then do that! */
+            if (timeSyncActivated === false) {
+                timeSyncActivated = true;
+                ourBoard.syncClocksFull()
+                    .then(syncObj => {
+                        if (syncObj.valid) {
+                            console.log('1st sync done');
+                        }
+                        return ourBoard.syncClocksFull();
+                    })
+                    .then(syncObj => {
+                        if (syncObj.valid) {
+                            console.log('2nd sync done');
+                        }
+                        return ourBoard.syncClocksFull();
+                    })
+                    .then(syncObj => {
+                        if (syncObj.valid) {
+                            console.log('3rd sync done');
+                        }
+                        return ourBoard.syncClocksFull();
+                    })
+                    .then(syncObj => {
+                        if (syncObj.valid) {
+                            console.log('4th sync done');
+
+                        }
+                        /* Do awesome time syncing stuff */
+                    })
+                    .catch(err => {
+                        console.log(`sync err ${err}`);
+                    });
+            }
+            if (startLoggingSamples && sample.hasOwnProperty("timeStamp") && sample.hasOwnProperty("boardTime")) {
+                /** If you only want to log samples with time stamps */
+                samples.push(sample);
+            }
+        });
+    })
+.catch(err => {
+    console.log(`connect ${err}`);
+});
+
+```
+
 ### .testSignal(signal)
 
 Apply the internal test signal to all channels.
@@ -717,11 +964,25 @@ A String indicating which test signal to apply
 
 **_Returns_** a promise, if the commands were sent to write buffer.
 
+### .time()
+
+Uses `._sntpNow()` time when sntpTimeSync specified in options, or else use Date.now() for time.
+
+**_Returns_** time since UNIX epoch in ms.
+
+### .usingVersionTwoFirmware()
+
+Convenience method to determine if you can use firmware v2.x.x capabilities.
+
+**Note, should be called after a `.softReset()` because we can parse the output of that to determine if we are using firmware version 2.**
+
+**_Returns_** a boolean, true if using firmware version 2 or greater.
+
 ### .write(dataToWrite)
 
-Send commands to the board. Due to the OpenBCI board firmware, a 10ms spacing **must** be observed between every command sent to the board. This method handles the timing and spacing between characters by adding characters to a global write queue and pulling from it every 10ms.
+Send commands to the board. Due to the OpenBCI board firmware 1.0, a 10ms spacing **must** be observed between every command sent to the board. This method handles the timing and spacing between characters by adding characters to a global write queue and pulling from it every 10ms. If you are using firmware version +2.0 then you no spacing will be used.
 
-**_dataToWrite_** 
+**_dataToWrite_**
 
 Either a single character or an Array of characters
 
@@ -741,7 +1002,7 @@ Sends an array of bytes
 ourBoard.write(['x','0','1','0','0','0','0','0','0','X']);
 ```
 
-Taking full advantage of the write queue. The following would be sent at t = 0, 10ms, 20ms, 30ms 
+Taking full advantage of the write queue. The following would be sent at t = 0, 10ms, 20ms, 30ms
 ```js
 ourBoard.write('t');
 ourBoard.write('a');
@@ -779,7 +1040,7 @@ Emitted when the board is in a ready to start streaming state.
 
 Emitted when there is a new sample available.
 
-## Properties 
+## Properties
 
 ### connected
 
@@ -793,7 +1054,7 @@ A bool, true if streaming data from an OpenBCI board, false if not.
 
 To use the constants file simply:
 ```js
-var openBCIBoard = require('openbci-sdk');
+var openBCIBoard = require('openbci');
 var k = openBCIBoard.OpenBCIConstants;
 
 console.log(k.OBCISimulatorPortName); // prints OpenBCISimulator to the console.

changelog.md

@@ -1,3 +1,89 @@
+# 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
@@ -8,8 +94,8 @@
 
 ### New Features
 
-* SD card support! Now logging to an SD card is easier than ever. 
- 
+* 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
@@ -24,7 +110,6 @@
 
 * [https://github.com/OpenBCI/openbci-js-sdk/issues/44](#44)
 
-
 # 0.3.3
 
 ### Bug Fixes
@@ -59,7 +144,7 @@
 * OpenBCI Radio Test File
 * Added Sntp npm module with helper functions
 * Removed stopByte and startByte from sampleObjects
-    
+
 ### Breaking Changes
 
 * Changed simulator name to `OpenBCISimulator`
@@ -70,15 +155,15 @@
 
 * 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 
-    
+* Node 5 compatibility
+
 ### Github Issues Addressed
 
-* #25, #26, #27, #29, #30, #31, #33, #34
+* #25, #26, #27, #29, #30, #31, #33, #34

openBCISimulator.js

@@ -12,18 +12,19 @@ var now = require('performance-now');
 function OpenBCISimulatorFactory() {
     var factory = this;
 
-
-
     var _options = {
-        samplerate: 250,
-        daisy: false,
-        verbose: false,
+        accel: true,
         alpha: true,
-        lineNoise: '60Hz'
+        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 = {};
@@ -31,10 +32,27 @@ 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.lineNoise = options.lineNoise || options.linenoise || _options.lineNoise;
-        opts.alpha = options.alpha || _options.alpha;
+        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;
@@ -46,35 +64,30 @@ function OpenBCISimulatorFactory() {
             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,
-            ntp0: 0,
-            ntp1: 0,
-            ntp2: 0,
-            ntp3: 0
+            loop: null
         };
-        console.log('Simulator started at time: ' + this.time.start);
-        console.log('Time board has been running: ' + (now() - this.time.start));
         // 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);
 
     }
@@ -88,8 +101,10 @@ function OpenBCISimulatorFactory() {
     };
 
     OpenBCISimulator.prototype.write = function(data,callback) {
-
         switch (data[0]) {
+            case k.OBCIRadioKey:
+                this._processPrivateRadioMessage(data);
+                break;
             case k.OBCIStreamStart:
                 if (!this.stream) this._startStream();
                 this.streaming = true;
@@ -101,7 +116,7 @@ function OpenBCISimulatorFactory() {
             case k.OBCIMiscSoftReset:
                 if (this.stream) clearInterval(this.stream);
                 this.streaming = false;
-                this.emit('data', new Buffer('OpenBCI Board Simulator\nPush The World\nFirmware: v2$$$'));
+                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:
@@ -122,25 +137,26 @@ function OpenBCISimulatorFactory() {
             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.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.emit('data', new Buffer('No open file to close\n'));
+                        this._printEOT();
                     }
                 }
                 this.SDLogActive = false;
                 break;
-            case k.OBCISyncClockStart:
-                setTimeout(() => {
-                    if (this.options.verbose) console.log('Recieved sync command');
-                    this._syncStart();
-                }, 10);
-                break;
-            case k.OBCISyncClockServerData:
-                this.time.ntp3 = this.time.current;
-                this._syncUp(data.slice(1));
+            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;
@@ -154,7 +170,6 @@ function OpenBCISimulatorFactory() {
 
     OpenBCISimulator.prototype.drain = function(callback) {
         callback();
-        //if (this.options.verbose) console.log('drain');
     };
 
     OpenBCISimulator.prototype.close = function(callback) {
@@ -162,7 +177,6 @@ function OpenBCISimulatorFactory() {
             this.emit('close');
         }
         this.connected = false;
-        //if (this.options.verbose) console.log('close');
         callback();
     };
 
@@ -171,10 +185,31 @@ function OpenBCISimulatorFactory() {
 
         if (intervalInMS < 2) intervalInMS = 2;
 
-        var generateSample = openBCISample.randomSample(k.OBCINumberOfChannelsDefault, k.OBCISampleRate250, this.options.alpha, this.options.lineNoise);
-
         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(() => {
@@ -183,40 +218,145 @@ function OpenBCISimulatorFactory() {
         }, intervalInMS);
     };
 
-    OpenBCISimulator.prototype._syncStart = function() {
-
-        this.time.ntp0 = now();
-        var buffer = new Buffer('$a$' + this.time.ntp0);
-        this.emit('data',buffer);
+    OpenBCISimulator.prototype._syncUp = function() {
+        setTimeout(() => {
+            this.sendSyncSetPacket = true;
+        }, 12); // 3 packets later
     };
 
-    OpenBCISimulator.prototype._syncUp = function(data) {
-        // get the first number
-        console.log(data.length);
-        var halfwayPoint = (data.length / 2);
-        this.time.ntp1 = parseFloat(data.slice(0,halfwayPoint-1));
-        this.time.ntp2 = parseFloat(data.slice(halfwayPoint));
-        console.log('ntp1: ' + this.time.ntp1 + ' ntp2: ' + this.time.ntp2);
+    OpenBCISimulator.prototype._printEOT = function () {
+        this.emit('data', new Buffer("$$$"));
+    };
 
-        var timeSpentOnNetwork = this.time.ntp3 - this.time.ntp0 - (this.time.ntp2 - this.time.ntp1);
+    OpenBCISimulator.prototype._printFailure = function () {
+        this.emit('data', new Buffer("Failure: "));
+    };
 
-        var transferTime = timeSpentOnNetwork / 2;
+    OpenBCISimulator.prototype._printSuccess = function () {
+        this.emit('data', new Buffer("Success: "));
+    };
 
-        var trueTime = this.time.ntp2 + transferTime;
-
-        var delta = trueTime - this.time.ntp3;
-        console.log('Delta: ' + delta);
-
-        this.time.start += delta;
-
-
-
-        this.emit('data','Synced!' + '$$$');
+    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);

package.json

@@ -1,6 +1,6 @@
 {
-  "name": "openbci-sdk",
-  "version": "0.3.6",
+  "name": "openbci",
+  "version": "1.1.0",
   "description": "The official Node.js SDK for the OpenBCI Biosensor Board.",
   "main": "openBCIBoard",
   "scripts": {
@@ -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",
+    "mathjs": "^3.3.0",
     "performance-now": "^0.2.0",
-    "serialport": "~2.1.0",
-    "sntp": "^2.0.0"
+    "serialport": "3.1.2",
+    "sntp": "^2.0.0",
+    "streamsearch": "^0.1.2"
   },
   "directories": {
     "test": "test"
@@ -28,6 +30,7 @@
     "chai": "^3.4.1",
     "chai-as-promised": "^5.2.0",
     "codecov": "^1.0.1",
+    "istanbul": "^0.4.4",
     "mocha": "^2.3.4",
     "sandboxed-module": "^2.0.3",
     "sinon": "^1.17.2",
@@ -35,12 +38,12 @@
   },
   "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/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);
@@ -435,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(0, k.OBCIAccelAxisX);
+        });
+        it('Y axis',function () {
+            assert.equal(1, k.OBCIAccelAxisY);
+        });
+        it('Z axis',function () {
+            assert.equal(2, 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';
@@ -614,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() {
@@ -712,6 +765,20 @@ describe('OpenBCIConstants', function() {
             assert.equal(250, k.OBCISampleRate250);
         });
     });
+    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(0);
+        });
+        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() {
@@ -1013,6 +1080,14 @@ describe('OpenBCIConstants', function() {
             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) {
@@ -1116,4 +1191,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/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);
+                }
+            });
+        });
+    })
+});