Merge pull request #143 from octopicorn/patch-1

note about serialport node error
2017-03-23 23:55:24 -04:00 · 2017-03-23 20:40:59 -07:00 · 2017-03-02 14:52:25 -05:00 · 2017-03-02 14:50:50 -05:00 · 2017-03-02 13:39:18 -05:00 · 2017-03-02 13:28:19 -05:00
@@ -0,0 +1 @@
+{"extends": ["standard"], "parser": "babel-eslint"}
@@ -40,3 +40,6 @@ hardwareVoltageOutputAll.txt

 # For git
 *.orig
+
+# Text editor temporary files
+.*.sw* # vi/vim
@@ -17,4 +17,5 @@ node_modules
 .DS_Store
 public
 myOutput.txt
-*.tgz
+*.tgz
+openBCISerialFormat
@@ -3,12 +3,22 @@ node_js:
  - "4.0"
  - "4.1"
  - "4.2"
+  - "4.3"
+  - "4.4"
+  - "4.5"
+  - "4.6"
  - "5.11.0"
  - "6.0"
  - "6.1"
  - "6.2"
  - "6.3"
+  - "6.4"
+  - "6.5"
+  - "6.6"
+  - "6.7"
+  - "6.8"
 install:
  - npm install --all
 script:
+  - npm run lint
  - npm run test-cov
@@ -4,6 +4,7 @@
 [![codecov](https://codecov.io/gh/OpenBCI/OpenBCI_NodeJS/branch/master/graph/badge.svg)](https://codecov.io/gh/OpenBCI/OpenBCI_NodeJS)
 [![Dependency Status](https://david-dm.org/OpenBCI/OpenBCI_NodeJS.svg)](https://david-dm.org/OpenBCI/OpenBCI_NodeJS)
 [![npm](https://img.shields.io/npm/dm/openbci.svg?maxAge=2592000)](http://npmjs.com/package/openbci)
+[![js-semistandard-style](https://img.shields.io/badge/code%20style-semistandard-brightgreen.svg?style=flat-square)](https://github.com/Flet/semistandard)

 # OpenBCI Node.js SDK

@@ -13,6 +14,8 @@ We are proud to support all functionality of the OpenBCI 8 and 16 Channel boards

 The purpose of this module is to **get connected** and **start streaming** as fast as possible.

+Python researcher or developer? Check out how easy it is to [get access to the entire API in the Python example](examples/python)!
+
 ### Table of Contents:
 ---

@@ -24,11 +27,10 @@ The purpose of this module is to **get connected** and **start streaming** as fa
  1. [Constructor](#constructor)
  2. [Methods](#method)
  3. [Events](#event)
-  4. [Properties](#property)
-  5. [Constants](#constants)
+  4. [Constants](#constants)
 6. [Interfacing With Other Tools](#interfacing-with-other-tools)
 7. [Developing](#developing)
-8. [Testing](#testing)
+8. [Testing](#developing-testing)
 9. [Contribute](#contribute)
 10. [License](#license)
 11. [Roadmap](#roadmap)
@@ -37,8 +39,21 @@ The purpose of this module is to **get connected** and **start streaming** as fa
 ```
 npm install openbci
 ```
+#### serialport dependency
+If you encounter this error when trying to run:
+```
+Error: The module '/path/to/your/project/node_modules/serialport/build/Release/serialport.node'
+was compiled against a different Node.js version using
+NODE_MODULE_VERSION 48. This version of Node.js requires
+NODE_MODULE_VERSION 51. Please try re-compiling or re-installing
+the module (for instance, using `npm rebuild` or`npm install`).
+```
+...the issue can be resolved by running:
+```
+npm rebuild --build-from-source
+```
 ### <a name="tldr"></a> TL;DR:
-Get connected and start streaming right now
+Get connected and [start streaming right now with the example code](examples/getStreaming/getStreaming.js).

 ```js
 var OpenBCIBoard = require('openbci').OpenBCIBoard;
@@ -71,7 +86,9 @@ Want to know if the module really works? Check out some projects and organizatio

 Still not satisfied it works?? Check out this [detailed report](http://s132342840.onlinehome.us/pushtheworld/files/voltageVerificationTestPlanAndResults.pdf) that scientifically validates the output voltages of this module.

-How are you still doubting and not using this already? Fine, go look at some of the [700 **_automatic_** tests](https://codecov.io/github/OpenBCI/openbci-js-sdk?branch=master) written for it!
+How are you still doubting and not using this already? Fine, go look at some of the [800 **_automatic_** tests](https://codecov.io/gh/OpenBCI/OpenBCI_NodeJS) written for it!
+
+Python researcher or developer? Check out how easy it is to [get access to the entire API in the Python example](examples/python)!

 ### <a name="general-overview"></a> General Overview:

@@ -84,6 +101,7 @@ Initializing the board:
 var OpenBCIBoard = require('openbci');
 var ourBoard = new OpenBCIBoard.OpenBCIBoard();
 ```
+Go [checkout out the get streaming example](examples/getStreaming/getStreaming.js)!

 For initializing with options, such as verbose print outs:

@@ -103,6 +121,16 @@ var ourBoard = new OpenBCIBoard({
 });
 ```

+Have a daisy?:
+```js
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard({
+    boardType: `daisy`,
+    hardSet: true
+});
+```
+Go [checkout out the get streaming with daisy example](examples/getStreamingDaisy/getStreamingDaisy.js)!
+
 Another useful way to start the simulator:
 ```js
 var openBCIBoard = require('openbci');
@@ -118,6 +146,15 @@ ourBoard.connect(k.OBCISimulatorPortName) // This will set `simulate` to true
    });
 ```

+To debug, it's amazing, do:
+
+```js
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard({
+    simulate: true
+});
+```
+Go [checkout out the debug example](examples/debug/debug.js)!

 'ready' event
 ------------
@@ -382,24 +419,33 @@ Board optional configurations.
  * `daisy` - 8 Channel board with Daisy Module - 16 Channels
  * `ganglion` - 4 Channel board
    (NOTE: THIS IS IN-OP TIL RELEASE OF GANGLION BOARD 08/2016)
+* `hardSet` {Boolean} - Recommended if using `daisy` board! For some reason, the `daisy` is sometimes not picked up by the module so you can set `hardSet` to true which will ensure the daisy is picked up. (Default `false`)
 * `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
+* `simulatorFragmentation` {String} - Specifies how to break packets to simulate fragmentation, which occurs commonly in real devices.  It is recommended to test code with this enabled.  (4 Possible Options)
+  * `none` - do not fragment packets; output complete chunks immediately when produced (Default)
+  * `random` - output random small chunks of data interspersed with full buffers
+  * `fullBuffers` - allow buffers to fill up until latency timer has expired
+  * `oneByOne` - output each byte separately
+* `simulatorLatencyTime` {Number} - The time in milliseconds to wait before sending partially full buffers of data, if `simulatorFragmentation` is specified.  (Default `16`)
+* `simulatorBufferSize` {Number} - The size of a full buffer of data, if `simulatorFragmentation` is specified. (Default `4096`)
 * `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.
+  * `none` - Do not inject line noise.
 * `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. If you are running experiments on your local computer, keep this `false`. (Default `false`)
 * `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 (Default `false`)
+* `debug` {Boolean} - Print out a raw dump of bytes sent and received (Default `false`)

 **Note, we have added support for either all lowercase OR camel case for the options, use whichever style you prefer.**

@@ -493,6 +539,12 @@ Closes the serial port opened by [`.connect()`](#method-connect).  Waits for sto

 **_Returns_** a promise, fulfilled by a successful close of the serial port object, rejected otherwise.

+### <a name="method-get-info"></a> .getInfo()
+
+Get the core info object. It's the object that actually drives the parsing of data.
+
+**_Returns_** Object - {{boardType: string, sampleRate: number, firmware: string, numberOfChannels: number, missedPackets: number}}
+
 ### <a name="method-get-settings-for-channel"></a> .getSettingsForChannel(channelNumber)

 Gets the specified channelSettings register data from printRegisterSettings call.
@@ -505,6 +557,21 @@ A number specifying which channel you want to get data on. Only 1-8 at this time

 **_Returns_** a promise, fulfilled if the command was sent to the board and the `.processBytes()` function is ready to reach for the specified channel.

+### <a name="method-hard-set-board-type"></a> .hardSetBoardType(boardType)
+
+Used to sync the module and board to `boardType`.
+
+**Note: This has the potential to change the way data is parsed** 
+ 
+**_boardType_**
+
+A String indicating the number of channels.
+
+* `default` - Default board: Sample rate is `250Hz` and number of channels is `8`. 
+* `daisy` - Daisy board: Sample rate is `125Hz` and number of channels is `16`.
+
+**_Returns_** a promise, fulfilled if both the board and module are the requested `boardType`, rejects otherwise.
+
 ### <a name="method-impedance-test-all-channels"></a> .impedanceTestAllChannels()

 To apply test signals to the channels on the OpenBCI board used to test for impedance. This can take a little while to actually run (<8 seconds)!
@@ -670,6 +737,16 @@ Sends command to turn off impedances for all channels and stop continuously calc

 **_Returns_** a promise, that fulfills when all the commands are sent to the internal write buffer

+### <a name="method-is-connected"></a> .isConnected()
+
+Checks if the driver is connected to a board.
+**_Returns_** a boolean, true if connected
+
+### <a name="method-is-streaming"></a> .isStreaming()
+
+Checks if the board is currently sending samples.
+**_Returns_** a boolean, true if streaming
+
 ### <a name="method-list-ports"></a> .listPorts()

 List available ports so the user can choose a device when not automatically found.
@@ -684,6 +761,19 @@ Get the current number of channels available to use. (i.e. 8 or 16).

 **_Returns_** a number, the total number of available channels.

+### <a name="method-override-info-for-board-type"></a> .overrideInfoForBoardType(boardType)
+
+Set the info property for board type. 
+
+**Note: This has the potential to change the way data is parsed** 
+ 
+**_boardType_**
+
+A String indicating the number of channels.
+
+* `default` - Default board: Sample rate is `250Hz` and number of channels is `8`. 
+* `daisy` - Daisy board: Sample rate is `125Hz` and number of channels is `16`.
+
 ### <a name="method-print-bytes-in"></a> .printBytesIn()

 Prints the total number of bytes that were read in this session to the console.
@@ -828,7 +918,7 @@ To leave simulate mode.

 ### <a name="method-sntp"></a> .sntp

-Extends the popular STNP package on [npmjs](https://www.npmjs.com/package/sntp)
+Extends the popular SNTP package on [npmjs](https://www.npmjs.com/package/sntp)

 ### <a name="method-sntp-get-offset"></a> .sntpGetOffset()

@@ -895,6 +985,7 @@ Send the command to tell the board to start the syncing protocol. Must be connec
    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.
+    timeOffsetMaster: 0, // The map (or translation) from boardTime to module time averaged over time syncs.
    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.
 }
 ```
@@ -1016,13 +1107,13 @@ Either a single character or an Array of characters

 Sends a single character command to the board.
 ```js
-// ourBoard has fulfilled the promise on .connected() and 'ready' has been observed previously
+// ourBoard has fulfilled the promise on .connect() and 'ready' has been observed previously
 ourBoard.write('a');
 ```

 Sends an array of bytes
 ```js
-// ourBoard has fulfilled the promise on .connected() and 'ready' has been observed previously
+// ourBoard has fulfilled the promise on .connect() and 'ready' has been observed previously
 ourBoard.write(['x','0','1','0','0','0','0','0','0','X']);
 ```

@@ -1048,6 +1139,10 @@ Emitted when a packet (or packets) are dropped. Returns an array.

 Emitted when there is an on the serial port.

+### <a name="event-hard-set"></a> .on('hardSet', callback)
+
+Emitted when the module detects the board is not configured as the options for the module intended and tries to save itself. i.e. when the `daisy` option is `true` and a soft reset message is parsed and the module determines that a daisy was not detected, the module will emit `hardSet` then send an attach daisy command to recover. Either `error` will be emitted if unable to attach or `ready` will be emitted if success.
+
 ### <a name="event-impedance-array"></a> .on('impedanceArray', callback)

 Emitted when there is a new impedanceArray available. Returns an array.
@@ -1068,15 +1163,9 @@ Emitted when the board is in a ready to start streaming state.

 Emitted when there is a new sample available.

-## <a name="property"></a> Properties:
+### <a name="event-sample"></a> .on('synced', callback)

-### <a name="property-connected"></a> connected
-
-A bool, true if connected to an OpenBCI board, false if not.
-
-### <a name="property-streaming"></a> streaming
-
-A bool, true if streaming data from an OpenBCI board, false if not.
+Emitted when there is a new sample available.

 ## <a name="constants"></a> Constants:

@@ -1096,46 +1185,12 @@ The name of the simulator port.

 ### <a name="interfacing-with-other-tools-labstreaminglayer"></a> LabStreamingLayer

-[LabStreamingLayer](https://github.com/sccn/labstreaminglayer) by SCCN is a stream management tool designed to time-synchronize multiple data streams, potentially from different sources, over a LAN network with millisecond accuracy (given configuration).
+[LabStreamingLayer](https://github.com/sccn/labstreaminglayer) is a tool for streaming or recording time-series data. It can be used to interface with [Matlab](https://github.com/sccn/labstreaminglayer/tree/master/LSL/liblsl-Matlab), [Python](https://github.com/sccn/labstreaminglayer/tree/master/LSL/liblsl-Python), [Unity](https://github.com/xfleckx/LSL4Unity), and many other programs. 

-For example, a VR display device running a Unity simulation may, using the [LSL4Unity](https://github.com/xfleckx/LSL4Unity) library, emit string markers into LSL corresponding to events of interest (For the P300 ERP, this event would be the onset of an attended, unusual noise in a pattern of commonplace ones). The computer doing data collection via the OpenBCI_NodeJS library (potentially with 4ms accuracy) would then output into an LSL stream the EEG and AUX data. LSL can then synchronize the two clocks relative to each other before inputting into a different program or toolkit, like [BCILAB](https://github.com/sccn/BCILAB) for analysis to trigger responses in the Unity display.
+To use LSL with the NodeJS SDK, go to our [labstreaminglayer example](https://github.com/OpenBCI/OpenBCI_NodeJS/tree/master/examples/labstreaminglayer), which contains code that is ready to start an LSL stream of OpenBCI data.

-This requires OpenBCI_NodeJS exporting data into LSL. Currently, there does not exist a pre-built NodeJS module for LSL, though LSL comes with tools that could possibly allow creation of one. In the meantime, the simpler route is to use a concurrent python script (driven by NodeJS module [python-shell](https://www.npmjs.com/package/python-shell)) to handoff the data to LSL for you, like so:
+Follow the directions in the [readme](https://github.com/OpenBCI/OpenBCI_NodeJS/blob/master/examples/labstreaminglayer/readme.md) to get started.

-In your NodeJS code, before initializing/connecting to the OpenBCIBoard:
-```js
-// Construct LSL Handoff Python Shell
-var PythonShell = require('python-shell');
-var lsloutlet = new PythonShell('LslHandoff.py');
-
-lsloutlet.on('message', function(message){
-    console.log('LslOutlet: ' + message);
-});
-console.log('Python Shell Created for LSLHandoff');
-```
-
-In your NodeJS code, when reading samples:
-```js
-st = sample.channelData.join(' ')
-//getTime returns milliseconds since midnight 1970/01/01
-var s = ''+ sample.timeStamp + ': '+ st
-lsloutlet.send(s)
-```
-
-in LSLHandoff.py:
-```py
-from pylsl import StreamInfo, StreamOutlet
-info = StreamInfo('OpenBCI_EEG', 'EEG', 8, 250, 'float32', '[RANDOM NUMBER HERE]')
-outlet = StreamOutlet(info)
-while True:
-    strSample = raw_input().split(': ',1)
-    sample = map(float, strSample[1].split(' '))
-    stamp = float(strSample[0])
-
-    outlet.push_sample(sample, stamp)
-    print('Pushed Sample At: ' + strSample[0])
-```
-AUX data would be done the same way in a separate LSL stream.

 ## <a name="developing"></a> Developing:
 ### <a name="developing-running"></a> Running:
@@ -1153,11 +1208,14 @@ npm test
 ## <a name="contribute"></a> Contribute:

 1. Fork it!
+2. Branch off of `development`: `git checkout development`
 2. Create your feature branch: `git checkout -b my-new-feature`
-3. Make changes and ensure tests all pass. (`npm test`)
-4. Commit your changes: `git commit -m 'Add some feature'`
-5. Push to the branch: `git push origin my-new-feature`
-6. Submit a pull request :D
+3. Make changes
+4. If adding a feature, please add test coverage.
+5. Ensure tests all pass. (`npm test`)
+6. Commit your changes: `git commit -m 'Add some feature'`
+7. Push to the branch: `git push origin my-new-feature`
+8. Submit a pull request. Make sure it is based off of the `development` branch when submitting! :D

 ## <a name="license"></a> License:

@@ -1,3 +1,113 @@
+# 1.5.1
+
+### New Features
+* Add new example for Lab stream layer (#139) thanks @gabrielibagon
+
+### Breaking changes
+* Removed `impedanceCalculationForChannel()` and `impedanceCalculationForAllChannels` from `OpenBCISample.js`
+
+### Bug Fixes
+* Fixes #28- Impedance not working properly.
+
+# 1.5.0
+
+### New Features
+* New simulator option `simulatorDaisyModuleCanBeAttached` - Boolean, deafults to true, allows the simulation of the a hot swapped daisy board or simulates a misinformed module.
+* New `EventEmitter` - `hardSet` - for when the module detects the board is not configured as the options for the module intended and tries to save itself. i.e. when the `daisy` option is `true` and a soft reset message is parsed and the module determines that a daisy was not detected, the module will emit `hardSet` then send an attach daisy command to recover. Either `error` will be emitted if unable to attach or `ready` will be emitted if success.
+* Add example for streaming with `daisy` and `hardSet`.
+
+### Breaking changes
+* `.setInfoForBoardType()` changed to `.overrideInfoForBoardType()` to elevate it's dangerous nature.
+* `.setMaxChannels()` changed to `.hardSetBoardType()` and input changed from numerical to string: 8 and 16 to `default` and `daisy` respectively.
+
+### Bug Fixes
+* Fixes #131 - 16 chan not working by sending a channel command and parsing the return.
+* Fixed bug where end of transmission characters would not be ejected from buffer.
+ 
+### Enhancements
+* Separated radio tests from main board test file.
+ 
+# 1.4.4
+
+### New Features
+* Set max number of channels for the board to use with `.setMaxChannels()` see readme.md
+* Set the core info object that drives the module with `.overrideInfoForBoardType()` see readme.md
+* Get info for the core object that drives the module with `.getInfo()` see readme.md
+
+### Work In Progress
+* Bug where daisy would sometimes not be recognized which destroyed all data.
+
+# 1.4.3
+
+### New examples
+* Add example of node to python
+
+# 1.4.2
+
+### New examples
+* Add example of debug
+* Add example of get streaming
+
+# 1.4.1
+
+### Bug Fixes
+* Fixes bug where extra data after EOT (`$$$`) was dumped by preserving the poriton after the EOT for further decomposition.
+* Fixes bug where any calls to channel set would actually break the openBCISample code as the channelSettingsArray contained an undefined.
+* Writes promises resolve when they are actually sent over the serial port. 
+
+# 1.4.0
+
+### New Features
+
+* Three new initialization options: `simulatorFragmentation`, `simulatorBufferSize`, and `simulatorLatencyTimer`.  Together, these enable a more _realistic_ serial port simulation, mimicking different potential user computer systems.
+* New option `debug` gives a live dump of serial traffic on the console if enabled
+* New API function `.isConnected()` to check if communications are active.
+* New API function `.isStreaming()` to check if samples are coming from the board.
+
+### Enhancements
+
+* Implement and adapt semi-standard code style. Closes #83
+* autoFindOpenBCIBoard now notices and uses the stock dongle on Linux
+* 'synced' object now has `error` property, null on good syncs, error description on bad syncs.
+
+### Breaking Changes
+
+* The setting for simulatorInjectLineNoise has changed from `None` to `none`
+* connect() will now fail if already connected
+* The constructor will throw an error now if an invalid option is passed
+* The `.connected` property has been removed, replaced by `.isConnected()`. Removed from docs.
+* The `.streaming` property has been removed, replaced by `.isStreaming()`. Removed from docs.
+* An error event will be emitted if sntp fails to initialize on construction
+* The simulator will no longer communicate when disconnected
+* Promises returned by writes will now only resolve after the write has been sent
+
+### Bug Fixes
+
+* Fixed bug where early packet fragments were dropped after board reset
+* Fixed bug where time sync replies that began a buffered chunk were ignored
+* Fixed bug where simulator would output wrong version in its reset message
+* Fixed bug where resources were not cleaned up if connect was called twice
+* Fixed bug where serial data was written after disconnection
+* Fixed bug where unexpected disconnection was not detected
+* Fixed bug where promises could lead to out of order packet processing.
+
+# 1.3.3
+
+### New Features
+
+* Add `timeOffsetMaster` to object emitted when bad time sync.
+
+### Bug Fixes
+
+* Fixed log statement on impedance setting function
+* Remove event emitter with time sync on reject of sync clock full
+
+# 1.3.2
+
+### Enhancements
+
+* Added master time offset `timeOffsetMaster` to `syncObj` which is a running average across sync attempts.
+
 # 1.3.1

 ### Bug Fixes
@@ -0,0 +1,107 @@
+/**
+ * This is an example of debugging the board. Thanks to Karl @baffo32
+ * On windows you should run with PowerShell not git bash.
+ * Install
+ *   [nodejs](https://nodejs.org/en/)
+ *
+ * To run:
+ *   change directory to this file `cd examples/debug`
+ *   do `npm install`
+ *   then `npm start`
+ */
+
+var stream = true;
+var debug = true; // Pretty print any bytes in and out... it's amazing...
+var verbose = true; // Adds verbosity to functions
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+
+var ourBoard = new OpenBCIBoard({
+  debug: debug,
+  verbose: verbose
+});
+
+ourBoard.autoFindOpenBCIBoard().then(portName => {
+  if (portName) {
+    /**
+     * Connect to the board with portName
+     * Only works if one board is plugged in
+     * i.e. ourBoard.connect(portName).....
+     */
+    // Call to connect
+    ourBoard.connect(portName).then(() => {
+      console.log(`connected`);
+    })
+      .catch(err => {
+        console.log(`connect: ${err}`);
+      });
+  } else {
+    /** Unable to auto find OpenBCI board */
+    console.log('Unable to auto find OpenBCI board');
+  }
+});
+
+/**
+ * The board is ready to start streaming after the ready function is fired.
+ */
+var readyFunc = () => {
+  // Get the sample rate after 'ready'
+  if (stream) {
+    ourBoard.streamStart()
+      .catch(err => {
+        console.log(`stream start: ${err}`);
+      });
+  }
+};
+
+var sampleFunc = sample => {
+  /**
+   * Checkout the README.md for all other API functions.
+   * We support every feature.
+   * */
+};
+
+// Subscribe to your functions
+ourBoard.on('ready', readyFunc);
+ourBoard.on('sample', sampleFunc);
+
+function exitHandler (options, err) {
+  if (options.cleanup) {
+    if (verbose) console.log('clean');
+    ourBoard.removeAllListeners();
+    /** Do additional clean up here */
+  }
+  if (err) console.log(err.stack);
+  if (options.exit) {
+    if (verbose) console.log('exit');
+    if (stream) {
+      ourBoard.streamStop().catch(console.log);
+    }
+    ourBoard.disconnect().catch(console.log);
+  }
+}
+
+if (process.platform === 'win32') {
+  const rl = require('readline').createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  rl.on('SIGINT', function () {
+    process.emit('SIGINT');
+  });
+}
+
+// do something when app is closing
+process.on('exit', exitHandler.bind(null, {
+  cleanup: true
+}));
+
+// catches ctrl+c event
+process.on('SIGINT', exitHandler.bind(null, {
+  exit: true
+}));
+
+// catches uncaught exceptions
+process.on('uncaughtException', exitHandler.bind(null, {
+  exit: true
+}));
@@ -0,0 +1,18 @@
+{
+  "name": "debug",
+  "version": "1.0.0",
+  "description": "Debug example",
+  "main": "debug.js",
+  "scripts": {
+    "start": "node debug.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "debug"
+  ],
+  "author": "AJ Keller",
+  "license": "MIT",
+  "dependencies": {
+    "openbci": "^1.5.0"
+  }
+}
@@ -0,0 +1,88 @@
+/**
+ * This is an example from the readme.md
+ * On windows you should run with PowerShell not git bash.
+ * Install
+ *   [nodejs](https://nodejs.org/en/)
+ *
+ * To run:
+ *   change directory to this file `cd examples/debug`
+ *   do `npm install`
+ *   then `npm start`
+ */
+var debug = false; // Pretty print any bytes in and out... it's amazing...
+var verbose = true; // Adds verbosity to functions
+
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard({
+  debug: debug,
+  verbose: verbose
+});
+
+ourBoard.autoFindOpenBCIBoard().then(portName => {
+  if (portName) {
+    /**
+     * Connect to the board with portName
+     * Only works if one board is plugged in
+     * i.e. ourBoard.connect(portName).....
+     */
+    ourBoard.connect(portName) // Port name is a serial port name, see `.listPorts()`
+      .then(() => {
+        ourBoard.on('ready', () => {
+          ourBoard.streamStart();
+          ourBoard.on('sample', (sample) => {
+            /** Work with sample */
+            for (let i = 0; i < ourBoard.numberOfChannels(); i++) {
+              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."
+              //  ...
+              //  "Channel 8: -0.00001875 Volts."
+            }
+          });
+        });
+      });
+  } else {
+    /** Unable to auto find OpenBCI board */
+    console.log('Unable to auto find OpenBCI board');
+  }
+});
+
+function exitHandler (options, err) {
+  if (options.cleanup) {
+    if (verbose) console.log('clean');
+    ourBoard.removeAllListeners();
+    /** Do additional clean up here */
+  }
+  if (err) console.log(err.stack);
+  if (options.exit) {
+    if (verbose) console.log('exit');
+    ourBoard.disconnect().catch(console.log);
+  }
+}
+
+if (process.platform === 'win32') {
+  const rl = require('readline').createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  rl.on('SIGINT', function () {
+    process.emit('SIGINT');
+  });
+}
+
+// do something when app is closing
+process.on('exit', exitHandler.bind(null, {
+  cleanup: true
+}));
+
+// catches ctrl+c event
+process.on('SIGINT', exitHandler.bind(null, {
+  exit: true
+}));
+
+// catches uncaught exceptions
+process.on('uncaughtException', exitHandler.bind(null, {
+  exit: true
+}));
@@ -0,0 +1,18 @@
+{
+  "name": "get-streaming",
+  "version": "1.0.0",
+  "description": "Get streaming example",
+  "main": "getStreaming.js",
+  "scripts": {
+    "start": "node getStreaming.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "get"
+  ],
+  "author": "AJ Keller",
+  "license": "MIT",
+  "dependencies": {
+    "openbci": "^1.5.0"
+  }
+}
@@ -0,0 +1,94 @@
+/**
+ * This is an example from the readme.md
+ * On windows you should run with PowerShell not git bash.
+ * Install
+ *   [nodejs](https://nodejs.org/en/)
+ *
+ * To run:
+ *   change directory to this file `cd examples/debug`
+ *   do `npm install`
+ *   then `npm start`
+ */
+var debug = false; // Pretty print any bytes in and out... it's amazing...
+var verbose = true; // Adds verbosity to functions
+
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard({
+  boardType: 'daisy',
+  debug: debug,
+  hardSet: true,
+  verbose: verbose
+});
+
+ourBoard.on('error', (err) => {
+  console.log(err);
+});
+
+ourBoard.autoFindOpenBCIBoard().then(portName => {
+  if (portName) {
+    /**
+     * Connect to the board with portName
+     * Only works if one board is plugged in
+     * i.e. ourBoard.connect(portName).....
+     */
+    ourBoard.connect(portName) // Port name is a serial port name, see `.listPorts()`
+      .then(() => {
+        ourBoard.once('ready', () => {
+          ourBoard.streamStart();
+          ourBoard.on('sample', (sample) => {
+            /** Work with sample */
+            for (let i = 0; i < ourBoard.numberOfChannels(); i++) {
+              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."
+              //  ...
+              //  "Channel 16: -0.00001875 Volts."
+            }
+          });
+        });
+      });
+  } else {
+    /** Unable to auto find OpenBCI board */
+    console.log('Unable to auto find OpenBCI board');
+  }
+});
+
+function exitHandler (options, err) {
+  if (options.cleanup) {
+    if (verbose) console.log('clean');
+    ourBoard.removeAllListeners();
+    /** Do additional clean up here */
+  }
+  if (err) console.log(err.stack);
+  if (options.exit) {
+    if (verbose) console.log('exit');
+    ourBoard.disconnect().catch(console.log);
+  }
+}
+
+if (process.platform === 'win32') {
+  const rl = require('readline').createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  rl.on('SIGINT', function () {
+    process.emit('SIGINT');
+  });
+}
+
+// do something when app is closing
+process.on('exit', exitHandler.bind(null, {
+  cleanup: true
+}));
+
+// catches ctrl+c event
+process.on('SIGINT', exitHandler.bind(null, {
+  exit: true
+}));
+
+// catches uncaught exceptions
+process.on('uncaughtException', exitHandler.bind(null, {
+  exit: true
+}));
@@ -0,0 +1,18 @@
+{
+  "name": "get-streaming-daisy",
+  "version": "1.0.0",
+  "description": "Get streaming with hard set daisy example",
+  "main": "getStreaming.js",
+  "scripts": {
+    "start": "node getStreamingDaisy.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "get"
+  ],
+  "author": "AJ Keller",
+  "license": "MIT",
+  "dependencies": {
+    "openbci": "^1.5.0"
+  }
+}
@@ -0,0 +1,142 @@
+/**
+ * This is an example from the readme.md
+ * On windows you should run with PowerShell not git bash.
+ * Install
+ *   [nodejs](https://nodejs.org/en/)
+ *
+ * To run:
+ *   change directory to this file `cd examples/debug`
+ *   do `npm install`
+ *   then `npm start`
+ */
+var debug = false; // Pretty print any bytes in and out... it's amazing...
+var verbose = true; // Adds verbosity to functions
+
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var ourBoard = new OpenBCIBoard({
+  debug: debug,
+  verbose: verbose
+});
+var k = require('openbci').OpenBCIConstants;
+
+let startedImpedance = false;
+let iBuffer = [];
+let count = 0;
+const window = 50;
+
+ourBoard.autoFindOpenBCIBoard().then(portName => {
+  if (portName) {
+    /**
+     * Connect to the board with portName
+     * Only works if one board is plugged in
+     * i.e. ourBoard.connect(portName).....
+     */
+    ourBoard.connect(portName) // Port name is a serial port name, see `.listPorts()`
+      .then(() => {
+        ourBoard.on('ready', () => {
+          ourBoard.streamStart();
+          ourBoard.on('sample', (sample) => {
+            if (startedImpedance === false) {
+              startedImpedance = true;
+              k.getImpedanceSetter(1, false, true)
+                .then((commands) => {
+                  return ourBoard.write(commands);
+                })
+                .then(() => {
+                  console.log('wrote commands to board');
+                })
+                .catch((err) => {
+                  console.log('errr', err);
+                });
+            }
+            /** Work with sample */
+            const chan1ValInVolts = sample.channelData[0];
+
+            // const impedance = chan1ValInVolts / k.OBCILeadOffDriveInAmps;
+
+            // console.log(`impedance:\t${impedance} kOhms`);
+            iBuffer.push(chan1ValInVolts);
+            count++;
+            if (count >= window) {
+              let max = 0.0; // sumSquared
+              for (let i = 0; i < window; i++) {
+                if (iBuffer[i] > max) {
+                  max = iBuffer[i];
+                }
+                // sumSquared += iBuffer[i] * iBuffer[i];
+              }
+              let min = 0.0;
+              for (let i = 0; i < window; i++) {
+                if (iBuffer[i] < min) {
+                  min = iBuffer[i];
+                }
+                // sumSquared += iBuffer[i] * iBuffer[i];
+              }
+              const vP2P = max - min; // peak to peak
+
+              console.log(`impedance: \t${vP2P / 2 / k.OBCILeadOffDriveInAmps}`);
+              // console.log(`impedance: ${vRms/k.OBCILeadOffDriveInAmps}`);
+
+              // const mean_squared = sumSquared / window;
+              // const root_mean_squared = Math.sqrt(mean_squared);
+              // console.log(`impedance: ${root_mean_squared/k.OBCILeadOffDriveInAmps}`);
+
+              count = 0;
+              iBuffer = [];
+            }
+            // console.log(`uV:\t${chan1ValInVolts/(10*6)}\nimpedance:\t${impedance}`);
+          });
+        });
+      });
+  } else {
+    /** Unable to auto find OpenBCI board */
+    console.log('Unable to auto find OpenBCI board');
+  }
+});
+
+function exitHandler (options, err) {
+  if (options.cleanup) {
+    if (verbose) console.log('clean');
+    /** Do additional clean up here */
+    ourBoard.disconnect().catch(console.log);
+    ourBoard.removeAllListeners();
+  }
+  if (err) console.log(err.stack);
+  if (options.exit) {
+    if (verbose) console.log('exit');
+    ourBoard.streamStop()
+      .then(() => {
+        process.exit(0);
+      })
+      .catch((err) => {
+        console.log(err);
+        process.exit(0);
+      });
+  }
+}
+
+if (process.platform === 'win32') {
+  const rl = require('readline').createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  rl.on('SIGINT', function () {
+    process.emit('SIGINT');
+  });
+}
+
+// do something when app is closing
+process.on('exit', exitHandler.bind(null, {
+  cleanup: true
+}));
+
+// catches ctrl+c event
+process.on('SIGINT', exitHandler.bind(null, {
+  exit: true
+}));
+
+// catches uncaught exceptions
+process.on('uncaughtException', exitHandler.bind(null, {
+  exit: true
+}));
@@ -0,0 +1,18 @@
+{
+  "name": "get-streaming",
+  "version": "1.0.0",
+  "description": "Get impedance example",
+  "main": "getStreaming.js",
+  "scripts": {
+    "start": "node impedance.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "get"
+  ],
+  "author": "AJ Keller",
+  "license": "MIT",
+  "dependencies": {
+    "openbci": "^1.5.0"
+  }
+}
@@ -0,0 +1,90 @@
+import json
+import sys
+import numpy as np
+import time
+import zmq
+from pylsl import StreamInfo, StreamOutlet
+
+class Interface:
+    def __init__(self, verbose=False):
+        context = zmq.Context()
+        self._socket = context.socket(zmq.PAIR)
+        self._socket.connect("tcp://localhost:3004")
+
+        self.verbose = verbose
+
+        if self.verbose:
+            print("Client Ready!")
+
+        # Send a quick message to tell node process we are up and running
+        self.send(json.dumps({
+            'action': 'started',
+            'command': 'status',
+            'message': time.time()*1000.0
+        }))
+
+    def send(self, msg):
+        """
+        Sends a message to TCP server
+        :param msg: str
+            A string to send to node TCP server, could be a JSON dumps...
+        :return: None
+        """
+        if self.verbose:
+            print('<- out ' + msg)
+        self._socket.send_string(msg)
+        return
+
+    def recv(self):
+        """
+        Checks the ZeroMQ for data
+        :return: str
+            String of data
+        """
+        return self._socket.recv()
+
+
+def initializeOutlet(interface):
+    """
+    Initializes and returns an LSL outlet
+    :param interface: Interface
+        the Python interface to communicate with node
+    :return: StreamOutlet
+        returns a labstreaminglayer StreamOutlet
+    """
+    numChans = None
+    while not numChans:
+        msg = interface.recv()
+        try:
+            dicty = json.loads(msg)
+            numChans = dicty.get('numChans')
+            sampleRate = dicty.get('sampleRate')
+        except ValueError as e:
+            print(e)
+    info = StreamInfo('OpenBCI_EEG', 'EEG', numChans, sampleRate, 'float32', 'myuid34234')
+    outlet = StreamOutlet(info)
+    print('init')
+    return outlet
+
+def main(argv):
+    verbose = False
+    # Create a new python interface.
+    interface = Interface(verbose)
+    # Create a new labstreaminglayer outlet
+    outlet = initializeOutlet(interface);
+
+    # Stream incoming data to LSL
+    while True:
+        msg = interface.recv()
+        try:
+            dicty = json.loads(msg)
+            message = dicty.get('message')
+            data=message.get('channelData')
+            timeStamp = message.get('timeStamp')
+            outlet.push_sample(data,timeStamp)
+        except BaseException as e:
+            print(e)
+
+
+if __name__ == '__main__':
+    main(sys.argv[1:])
@@ -0,0 +1,157 @@
+/**
+ * This is an example from the readme.md
+ * On windows you should run with PowerShell not git bash.
+ * Install
+ *   [nodejs](https://nodejs.org/en/)
+ *
+ * To run:
+ *   change directory to this file `cd examples/debug`
+ *   do `npm install`
+ *   then `npm start`
+ */
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var portPub = 'tcp://127.0.0.1:3004';
+var zmq = require('zmq-prebuilt');
+var socket = zmq.socket('pair');
+var debug = false; // Pretty print any bytes in and out... it's amazing...
+var verbose = true; // Adds verbosity to functions
+
+var ourBoard = new OpenBCIBoard({
+  simulatorFirmwareVersion: 'v2',
+  debug: debug,
+  verbose: verbose
+});
+
+var timeSyncPossible = false;
+var resyncPeriodMin = 1;
+var secondsInMinute = 60;
+var numChans = 8;
+var resyncPeriod = ourBoard.sampleRate() * resyncPeriodMin * secondsInMinute;
+
+ourBoard.autoFindOpenBCIBoard().then(portName => {
+  if (portName) {
+    /**
+     * Connect to the board with portName
+     * i.e. ourBoard.connect(portName).....
+     */
+    // Call to connect
+    ourBoard.connect(portName)
+      .then(() => {
+        ourBoard.on('ready', () => {
+          // Get the sample rate after 'ready'
+          numChans = ourBoard.numberOfChannels();
+          if (numChans === 16) {
+            ourBoard.overrideInfoForBoardType('daisy');
+          }
+
+          // 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();
+
+          sendToPython({'numChans': numChans, 'sampleRate': ourBoard.sampleRate()});
+          if (timeSyncPossible) {
+            ourBoard.streamStart()
+              .catch(err => {
+                console.log(`stream start: ${err}`);
+              });
+          } else {
+            console.log('not able to time sync');
+          }
+        });
+      })
+      .catch(err => {
+        console.log(`connect: ${err}`);
+      });
+  } else {
+    /** Unable to auto find OpenBCI board */
+    console.log('Unable to auto find OpenBCI board');
+  }
+});
+
+var sampleFunc = sample => {
+  if (sample._count % resyncPeriod === 0) {
+    ourBoard.syncClocksFull()
+      .then(syncObj => {
+        // Sync was successful
+        if (syncObj.valid) {
+          // Log the object to check it out!
+          console.log(`timeOffset`, syncObj.timeOffsetMaster);
+        } else {
+          // Retry it
+          console.log(`Was not able to sync... retry!`);
+        }
+      });
+  }
+
+  if (sample.timeStamp) { // true after the first successful sync
+    if (sample.timeStamp < 10 * 60 * 60 * 1000) { // Less than 10 hours
+      console.log(`Bad time sync ${sample.timeStamp}`);
+    } else {
+      sendToPython({
+        action: 'process',
+        command: 'sample',
+        message: sample
+      });
+    }
+  }
+};
+
+// Subscribe to your functions
+ourBoard.on('sample', sampleFunc);
+
+// ZMQ
+socket.bind(portPub, function (err) {
+  if (err) throw err;
+  console.log(`bound to ${portPub}`);
+});
+
+/**
+ * Used to send a message to the Python process.
+ * @param  {Object} interProcessObject The standard inter-process object.
+ * @return {None}
+ */
+var sendToPython = (interProcessObject, verbose) => {
+  if (verbose) {
+    console.log(`<- out ${JSON.stringify(interProcessObject)}`);
+  }
+  if (socket) {
+    socket.send(JSON.stringify(interProcessObject));
+  }
+};
+
+function exitHandler (options, err) {
+  if (options.cleanup) {
+    if (verbose) console.log('clean');
+    /** Do additional clean up here */
+  }
+  if (err) console.log(err.stack);
+  if (options.exit) {
+    if (verbose) console.log('exit');
+    ourBoard.disconnect().catch(console.log);
+  }
+}
+
+if (process.platform === 'win32') {
+  const rl = require('readline').createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  rl.on('SIGINT', function () {
+    process.emit('SIGINT');
+  });
+}
+
+// do something when app is closing
+process.on('exit', exitHandler.bind(null, {
+  cleanup: true
+}));
+
+// catches ctrl+c event
+process.on('SIGINT', exitHandler.bind(null, {
+  exit: true
+}));
+
+// catches uncaught exceptions
+process.on('uncaughtException', exitHandler.bind(null, {
+  exit: true
+}));
@@ -0,0 +1,31 @@
+{
+  "name": "labstreaminglayer",
+  "version": "1.0.0",
+  "description": "labstreaminglayer example",
+  "main": "index.js",
+  "scripts": {
+    "start": "concurrently --kill-others \"python handoff.py\" \"node index.js\"",
+    "start-node": "node index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "python",
+    "openbci",
+    "node",
+    "labstreaminglayer",
+    "LSL"
+  ],
+  "author": "AJ Keller",
+  "license": "MIT",
+  "dependencies": {
+    "openbci": "^1.4.2",
+    "zmq-prebuilt": "^2.1.0"
+  },
+  "devEngines": {
+    "node": "<=6.x",
+    "npm": ">=3.x"
+  },
+  "devDependencies": {
+    "concurrently": "^3.1.0"
+  }
+}
@@ -0,0 +1,111 @@
+# OpenBCI Node SDK to Lab Streaming Layer
+
+## About
+
+This code provides an example of how to stream OpenBCI data through the [lab streaming layer](https://github.com/sccn/labstreaminglayer) using the NodeJS SDK.
+
+Follow the steps in this README to start streaming. The code is ready to run as-is, but can be modified and extended to customize how you are sending your data. This is designed to be used with the **OpenBCI Cyton** (for **Ganglion support**, see the [Ganglion Node SDK](https://github.com/OpenBCI/OpenBCI_NodeJS_Ganglion/tree/master/examples/labstreaminglayer)).
+
+## Prerequisites
+
+* [Python](https://www.python.org/downloads/)
+* [ZeroMQ](http://zeromq.org/bindings:python)
+
+  ```py
+  pip install pyzmq
+  ```
+* [Node.js LTS](https://nodejs.org/en/)
+* [Lab Streaming Layer](https://github.com/sccn/labstreaminglayer)
+
+  ```py
+   pip install pylsl
+  ```
+
+
+## Installation
+First, install Python dependencies:
+```bash
+python setup.py install
+```
+Next, install NodeJS dependencies:
+```bash
+npm install
+```
+Note: depending on your computer settings, you may need to run as administrator or with `sudo`.
+
+## Running
+```
+npm start
+```
+For running just the node, for example if you were running the python in a separate ide and debugging, it's useful.
+```python
+npm run start-node
+```
+Note: depending on your computer settings, you may need to run as administrator or with `sudo`.
+
+## Writing Lab Streaming Layer Code
+If you would like to use lab streaming layer in a custom OpenBCI NodeJS application, you must include an instance of the OpenBCI NodeJS library and an instance of a Python interface. A basic example is shown below:
+
+index.js
+```js
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var portPub = 'tcp://127.0.0.1:3004';
+var zmq = require('zmq-prebuilt');
+var socket = zmq.socket('pair');
+var ourBoard = new OpenBCIBoard();
+
+socket.bind(portPub);
+
+ourBoard.autoFindOpenBCIBoard().then(portName => {
+  if (portName) {
+    ourBoard.connect(portName) // Port name is a serial port name, see `.listPorts()`
+      .then(() => {
+        ourBoard.on('ready',() => {
+          ourBoard.streamStart();
+          ourBoard.on('sample',(sample) => {
+              if (socket) {
+                socket.send(JSON.stringify({message: sample}));
+              }
+            }
+          });
+        });
+      });
+  } else {
+    console.log('Unable to auto find OpenBCI board');
+  }
+});
+
+/* Insert additional exit handlers and cleanup below*/
+```
+
+handoff.py
+```python
+import json
+import zmq
+from pylsl import StreamInfo, StreamOutlet
+
+# Create ZMQ socket
+context = zmq.Context()
+_socket = context.socket(zmq.PAIR)
+_socket.connect("tcp://localhost:3004")
+
+# Create a new labstreaminglayer outlet
+numChans = 8;
+sampleRate = 250;
+info = StreamInfo('OpenBCI_EEG', 'EEG', numChans, sampleRate, 'float32', 'openbci_12345')
+outlet = StreamOutlet(info)
+# Stream incoming data to LSL
+while True:
+    msg = _socket.recv()
+    try:
+        dicty = json.loads(msg)
+        message = dicty.get('message')
+        data=message.get('channelData')
+        timeStamp = message.get('timeStamp')
+        outlet.push_sample(data,timeStamp)
+    except BaseException as e:
+        print(e)
+```
+
+## Contributing
+Please PR if you have code to contribute!
@@ -0,0 +1,12 @@
+from setuptools import setup, find_packages
+
+setup(name='openbci-node-labstreaminglayer',
+      version='0.0.1',
+      description='Labstreaminglayer with NodeJS',
+      url='',
+      author='AJ Keller',
+      author_email='pushtheworldllc@gmail.com',
+      license='MIT',
+      packages=find_packages(),
+      install_requires=['numpy', 'pyzmq','pylsl'],
+      zip_safe=False)
@@ -0,0 +1,117 @@
+import json
+import sys
+import numpy as np
+import time
+import zmq
+
+
+class Interface:
+    def __init__(self, verbose=False):
+        context = zmq.Context()
+        self._socket = context.socket(zmq.PAIR)
+        self._socket.connect("tcp://localhost:3004")
+
+        self.verbose = verbose
+
+        if self.verbose:
+            print "Client Ready!"
+
+        # Send a quick message to tell node process we are up and running
+        self.send(json.dumps({
+            'action': 'started',
+            'command': 'status',
+            'message': time.time()*1000.0
+        }))
+
+    def send(self, msg):
+        """
+        Sends a message to TCP server
+        :param msg: str
+            A string to send to node TCP server, could be a JSON dumps...
+        :return: None
+        """
+        if self.verbose:
+            print '<- out ' + msg
+        self._socket.send(msg)
+        return
+
+    def recv(self):
+        """
+        Checks the ZeroMQ for data
+        :return: str
+            String of data
+        """
+        return self._socket.recv()
+
+
+class RingBuffer(np.ndarray):
+    """A multidimensional ring buffer."""
+
+    def __new__(cls, input_array):
+        obj = np.asarray(input_array).view(cls)
+        return obj
+
+    def __array_finalize__(self, obj):
+        if obj is None:
+            return
+
+    def __array_wrap__(self, out_arr, context=None):
+        return np.ndarray.__array_wrap__(self, out_arr, context)
+
+    def append(self, x):
+        """Adds element x to the ring buffer."""
+        x = np.asarray(x)
+        self[:, :-1] = self[:, 1:]
+        self[:, -1] = x
+
+
+def main(argv):
+    nb_chan = 8
+    verbose = True
+
+    # Create a new python interface.
+    interface = Interface(verbose=verbose)
+    # Signal buffer
+    signal = RingBuffer(np.zeros((nb_chan + 1, 2500)))
+
+    while True:
+        msg = interface.recv()
+        try:
+            dicty = json.loads(msg)
+            action = dicty.get('action')
+            command = dicty.get('command')
+            message = dicty.get('message')
+
+            if command == 'sample':
+                if action == 'process':
+                    # Do sample processing here
+                    try:
+                        if type(message) is not dict:
+                            print "sample is not a dict", message
+                            raise ValueError
+                        # Get keys of sample
+                        data = np.zeros(9)
+
+                        data[:-1] = message.get('channelData')
+                        data[-1] = message.get('timeStamp')
+
+                        # Add data to end of ring buffer
+                        signal.append(data)
+
+                        print message.get('sampleNumber')
+                    except ValueError as e:
+                        print e
+            elif command == 'status':
+                if action == 'active':
+                    interface.send(json.dumps({
+                        'action': 'alive',
+                        'command': 'status',
+                        'message': time.time() * 1000.0
+                    }))
+
+        except BaseException as e:
+            print e
+
+
+if __name__ == '__main__':
+    main(sys.argv[1:])
@@ -0,0 +1,208 @@
+/**
+ * This is an example from the readme.md
+ * On windows you should run with PowerShell not git bash.
+ * Install
+ *   [nodejs](https://nodejs.org/en/)
+ *
+ * To run:
+ *   change directory to this file `cd examples/debug`
+ *   do `npm install`
+ *   then `npm start`
+ */
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+var portPub = 'tcp://127.0.0.1:3004';
+var zmq = require('zmq-prebuilt');
+var socket = zmq.socket('pair');
+var simulate = false; // Sends synthetic data
+var debug = false; // Pretty print any bytes in and out... it's amazing...
+var verbose = true; // Adds verbosity to functions
+
+var ourBoard = new OpenBCIBoard({
+  simulate: simulate, // Uncomment to see how it works with simulator!
+  simulatorFirmwareVersion: 'v2',
+  debug: debug,
+  verbose: verbose
+});
+
+var timeSyncPossible = false;
+var resyncPeriodMin = 1;
+var secondsInMinute = 60;
+var resyncPeriod = ourBoard.sampleRate() * resyncPeriodMin * secondsInMinute;
+
+ourBoard.autoFindOpenBCIBoard().then(portName => {
+  if (portName) {
+    /**
+     * Connect to the board with portName
+     * i.e. ourBoard.connect(portName).....
+     */
+    // Call to connect
+    ourBoard.connect(portName)
+      .then(() => {
+        ourBoard.on('ready', () => {
+          // Find out if you can even time sync, you must be using v2 and this is only accurate after a `.softReset()` call which is called internally on `.connect()`. We parse the `.softReset()` response for the presence of firmware version 2 properties.
+          timeSyncPossible = ourBoard.usingVersionTwoFirmware();
+
+          if (timeSyncPossible) {
+            ourBoard.streamStart()
+              .catch(err => {
+                console.log(`stream start: ${err}`);
+              });
+          } else {
+            console.log('not able to time sync');
+          }
+        });
+      })
+      .catch(err => {
+        console.log(`connect: ${err}`);
+      });
+  } else {
+    /** Unable to auto find OpenBCI board */
+    console.log('Unable to auto find OpenBCI board');
+  }
+});
+
+var sampleFunc = sample => {
+  if (sample._count % resyncPeriod === 0) {
+    ourBoard.syncClocksFull()
+      .then(syncObj => {
+        // Sync was successful
+        if (syncObj.valid) {
+          // Log the object to check it out!
+          console.log(`timeOffset`, syncObj.timeOffsetMaster);
+        } else {
+          // Retry it
+          console.log(`Was not able to sync... retry!`);
+        }
+      });
+  }
+
+  if (sample.timeStamp) { // true after the first successful sync
+    if (sample.timeStamp < 10 * 60 * 60 * 1000) { // Less than 10 hours
+      console.log(`Bad time sync ${sample.timeStamp}`);
+    } else {
+      sendToPython({
+        action: 'process',
+        command: 'sample',
+        message: sample
+      });
+    }
+  }
+};
+
+// Subscribe to your functions
+ourBoard.on('sample', sampleFunc);
+
+// ZMQ fun
+
+socket.bind(portPub, function (err) {
+  if (err) throw err;
+  console.log(`bound to ${portPub}`);
+});
+
+/**
+ * Used to send a message to the Python process.
+ * @param  {Object} interProcessObject The standard inter-process object.
+ * @return {None}
+ */
+var sendToPython = (interProcessObject, verbose) => {
+  if (verbose) {
+    console.log(`<- out ${JSON.stringify(interProcessObject)}`);
+  }
+  if (socket) {
+    socket.send(JSON.stringify(interProcessObject));
+  }
+};
+
+var receiveFromPython = (rawData) => {
+  try {
+    let body = JSON.parse(rawData); // five because `resp `
+    processInterfaceObject(body);
+  } catch (err) {
+    console.log('in -> ' + 'bad json');
+  }
+};
+
+socket.on('message', receiveFromPython);
+
+var sendStatus = () => {
+  sendToPython({'action': 'active', 'message': 'ready', 'command': 'status'}, true);
+};
+
+sendStatus();
+
+/**
+ * Process an incoming message
+ * @param  {String} body   A stringify JSON object that shall be parsed.
+ * @return {None}
+ */
+var processInterfaceObject = (body) => {
+  switch (body.command) {
+    case 'status':
+      processStatus(body);
+      break;
+    default:
+      unrecognizedCommand(body);
+      break;
+  }
+};
+
+/**
+ * Used to process a status related command from TCP IPC.
+ * @param  {Object} body
+ * @return {None}
+ */
+var processStatus = (body) => {
+  switch (body.action) {
+    case 'started':
+      console.log(`python started @ ${body.message}ms`);
+      break;
+    case 'alive':
+      console.log(`python duplex communication test completed @ ${body.message}ms`);
+      break;
+    default:
+      unrecognizedCommand(body);
+      break;
+  }
+};
+
+function unrecognizedCommand (body) {
+  console.log(`unrecognizedCommand ${body}`);
+}
+
+function exitHandler (options, err) {
+  if (options.cleanup) {
+    if (verbose) console.log('clean');
+    /** Do additional clean up here */
+  }
+  if (err) console.log(err.stack);
+  if (options.exit) {
+    if (verbose) console.log('exit');
+    ourBoard.disconnect().catch(console.log);
+  }
+}
+
+if (process.platform === 'win32') {
+  const rl = require('readline').createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  rl.on('SIGINT', function () {
+    process.emit('SIGINT');
+  });
+}
+
+// do something when app is closing
+process.on('exit', exitHandler.bind(null, {
+  cleanup: true
+}));
+
+// catches ctrl+c event
+process.on('SIGINT', exitHandler.bind(null, {
+  exit: true
+}));
+
+// catches uncaught exceptions
+process.on('uncaughtException', exitHandler.bind(null, {
+  exit: true
+}));
@@ -0,0 +1,29 @@
+{
+  "name": "python",
+  "version": "1.0.0",
+  "description": "node to python example",
+  "main": "index.js",
+  "scripts": {
+    "start": "concurrently --kill-others \"python handoff.py\" \"node index.js\"",
+    "start-node": "node index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "python",
+    "openbci",
+    "node"
+  ],
+  "author": "AJ Keller",
+  "license": "MIT",
+  "dependencies": {
+    "openbci": "^1.4.2",
+    "zmq-prebuilt": "^2.1.0"
+  },
+  "devEngines": {
+    "node": "<=6.x",
+    "npm": ">=3.x"
+  },
+  "devDependencies": {
+    "concurrently": "^3.1.0"
+  }
+}
@@ -0,0 +1,40 @@
+# OpenBCI Node SDK to Python
+
+## About
+
+Written to end the struggles of python researchers and developers. ~ written with love by [Push The World!](http://www.pushtheworldllc.com)
+
+This module has every feature available on the OpenBCI Board.
+
+## Prerequisites
+
+* [Python 2.7](https://www.python.org/downloads/)
+* [ZeroMQ](http://zeromq.org/bindings:python)
+
+  ```py
+  pip install pyzmq
+  ```
+* [Node.js LTS](https://nodejs.org/en/)
+
+
+## Installation
+For Python 2.7 do:
+```bash
+python setup.py install
+```
+For Node:
+```bash
+npm install
+```
+
+## Running
+```
+npm start
+```
+For running just the node, for example if you were running the python in a separate ide and debugging, it's useful.
+```python
+npm run start-node
+```
+
+## Contributing
+Please PR if you have code to contribute!
@@ -0,0 +1,12 @@
+from setuptools import setup, find_packages
+
+setup(name='openbci-node-python',
+      version='0.0.1',
+      description='Node to Python the right way',
+      url='',
+      author='AJ Keller',
+      author_email='pushtheworldllc@gmail.com',
+      license='MIT',
+      packages=find_packages(),
+      install_requires=['numpy', 'pyzmq'],
+      zip_safe=False)
@@ -0,0 +1,19 @@
+{
+  "name": "timesync",
+  "version": "1.0.0",
+  "description": "Time sync example",
+  "main": "timeSync.js",
+  "scripts": {
+    "start": "node timeSync.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "time",
+    "sync"
+  ],
+  "author": "AJ Keller",
+  "license": "MIT",
+  "dependencies": {
+    "openbci": "^1.3.1"
+  }
+}
@@ -0,0 +1,128 @@
+/**
+* This is an example of time syncing every second for one minute. Used with a
+*  real board.
+* To run:
+*   change directory to this file `cd examples/timeSync`
+*   do `npm install`
+*   then `npm start`
+*/
+
+var OpenBCIBoard = require('openbci').OpenBCIBoard;
+
+var ourBoard = new OpenBCIBoard({});
+var verbose = true; // Adds verbosity to functions
+
+var sampleRate = 250; // Default to 250, ALWAYS verify with a call to `.sampleRate()` after 'ready' event!
+var timeSyncPossible = false;
+
+ourBoard.autoFindOpenBCIBoard().then(portName => {
+  if (portName) {
+    /**
+    * Connect to the board with portName
+    * i.e. ourBoard.connect(portName).....
+    */
+    // Call to connect
+    ourBoard.connect(portName).then(() => {
+      console.log(`connected`);
+    })
+      .catch(err => {
+        console.log(`connect: ${err}`);
+      });
+  } else {
+    /** Unable to auto find OpenBCI board */
+    console.log('Unable to auto find OpenBCI board');
+  }
+});
+
+var readyFunc = () => {
+  // Get the sample rate after 'ready'
+  sampleRate = ourBoard.sampleRate();
+  // Find out if you can even time sync, you must be using v2 and this is only accurate after a `.softReset()` call which is called internally on `.connect()`. We parse the `.softReset()` response for the presence of firmware version 2 properties.
+  timeSyncPossible = ourBoard.usingVersionTwoFirmware();
+
+  if (timeSyncPossible) {
+    ourBoard.streamStart()
+      .catch(err => {
+        console.log(`stream start: ${err}`);
+      });
+  } else {
+    killFunc();
+  }
+};
+
+var killFunc = () => {
+  ourBoard.disconnect()
+    .then(() => {
+      process.kill();
+    });
+};
+
+var sampleFunc = sample => {
+  // Resynchronize every every second
+  if (sample._count % (sampleRate * 1) === 0) {
+    ourBoard.syncClocksFull()
+      .then(syncObj => {
+        // Sync was successful
+        if (syncObj.valid) {
+          // Log the object to check it out!
+          console.log(`timeOffset`, syncObj.timeOffsetMaster);
+        } else {
+          // Retry it
+          console.log(`Was not able to sync... retry!`);
+        }
+      });
+  }
+
+  if (sample.timeStamp) { // true after the first successful sync
+    if (sample.timeStamp < 10 * 60 * 60 * 1000) { // Less than 10 hours
+      console.log(`Bad time sync ${sample.timeStamp}`);
+    }
+  }
+
+  // Stop after one minute
+  if (sample._count > sampleRate * 60) {
+    killFunc();
+  }
+};
+
+// Subscribe to your functions
+ourBoard.on('ready', readyFunc);
+ourBoard.on('sample', sampleFunc);
+
+function exitHandler (options, err) {
+  if (options.cleanup) {
+    if (verbose) console.log('clean');
+    /** Do additional clean up here */
+  }
+  if (err) console.log(err.stack);
+  if (options.exit) {
+    if (verbose) console.log('exit');
+    ourBoard.disconnect().catch(console.log);
+  }
+}
+
+if (process.platform === 'win32') {
+  const rl = require('readline').createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  rl.on('SIGINT', function () {
+    process.emit('SIGINT');
+  });
+}
+
+// do something when app is closing
+process.on('exit', exitHandler.bind(null, {
+  cleanup: true
+}));
+
+// catches ctrl+c event
+process.on('SIGINT', exitHandler.bind(null, {
+  exit: true
+}));
+
+// catches uncaught exceptions
+process.on('uncaughtException', exitHandler.bind(null, {
+  exit: true
+}));
@@ -1,5 +1,4 @@
 'use strict';
-
 var EventEmitter = require('events').EventEmitter;
 var util = require('util');
 var stream = require('stream');
@@ -8,355 +7,480 @@ var openBCISample = require('./openBCISample');
 var k = openBCISample.k;
 var now = require('performance-now');

+function OpenBCISimulatorFactory () {
+  var factory = this;

-function OpenBCISimulatorFactory() {
-    var factory = this;
+  var _options = {
+    accel: true,
+    alpha: true,
+    boardFailure: false,
+    daisy: false,
+    daisyCanBeAttached: true,
+    drift: 0,
+    firmwareVersion: [k.OBCIFirmwareV1, k.OBCIFirmwareV2],
+    fragmentation: [k.OBCISimulatorFragmentationNone, k.OBCISimulatorFragmentationRandom, k.OBCISimulatorFragmentationFullBuffers, k.OBCISimulatorFragmentationOneByOne],
+    latencyTime: 16,
+    bufferSize: 4096,
+    lineNoise: [k.OBCISimulatorLineNoiseHz60, k.OBCISimulatorLineNoiseHz50, k.OBCISimulatorLineNoiseNone],
+    sampleRate: 250,
+    serialPortFailure: false,
+    verbose: false
+  };

-    var _options = {
-        accel: true,
-        alpha: true,
-        boardFailure:false,
-        daisy: false,
-        drift: 0,
-        firmwareVersion: k.OBCIFirmwareV1,
-        lineNoise: '60Hz',
-        sampleRate: 250,
-        serialPortFailure:false,
-        verbose: false
-    };
+  function OpenBCISimulator (portName, options) {
+    options = (typeof options !== 'function') && options || {};
+    var opts = {};

-    function OpenBCISimulator(portName, options) {
-        options = (typeof options !== 'function') && options || {};
-        var opts = {};
+    stream.Stream.call(this);

-        stream.Stream.call(this);
+    /** Configuring Options */
+    var o;
+    for (o in _options) {
+      var userValue = options[o];
+      delete options[o];

-        /** Configuring Options */
-        if (options.accel === false) {
-            opts.accel = false;
+      if (typeof _options[o] === 'object') {
+        // an array specifying a list of choices
+        // if the choice is not in the list, the first one is defaulted to
+
+        if (_options[o].indexOf(userValue) !== -1) {
+          opts[o] = userValue;
        } else {
-            opts.accel = _options.accel;
+          opts[o] = _options[o][0];
        }
-        if (options.alpha === false) {
-            opts.alpha = false;
+      } else {
+        // anything else takes the user value if provided, otherwise is a default
+
+        if (userValue !== undefined) {
+          opts[o] = userValue;
        } else {
-            opts.alpha = _options.alpha;
+          opts[o] = _options[o];
        }
-        opts.boardFailure = options.boardFailure || _options.boardFailure;
-        opts.daisy = options.daisy || _options.daisy;
-        opts.drift = options.drift || _options.drift;
-        opts.firmwareVersion = options.firmwareVersion || _options.firmwareVersion;
-        opts.lineNoise = options.lineNoise || _options.lineNoise;
-        if (options.sampleRate) {
-            opts.sampleRate = options.sampleRate;
-        } else {
-            opts.sampleRate = k.OBCISampleRate250;
-        }
-        opts.serialPortFailure = options.serialPortFailure || _options.serialPortFailure;
-        opts.verbose = options.verbose || _options.verbose;
-
-        this.options = opts;
-
-        // Bools
-        this.connected = false;
-        this.sd = {
-            active:false,
-            startTime: 0
-        };
-        this.streaming = false;
-        this.synced = false;
-        this.sendSyncSetPacket = false;
-        // Buffers
-        this.buffer = new Buffer(500);
-        // Numbers
-        this.channelNumber = 1;
-        this.hostChannelNumber = this.channelNumber;
-        this.pollTime = 80;
-        this.sampleNumber = -1; // So the first sample is 0
-        // Objects
-        this.sampleGenerator = openBCISample.randomSample(k.OBCINumberOfChannelsDefault, this.options.sampleRate, this.options.alpha, this.options.lineNoise);
-        this.time = {
-            current: 0,
-            start: now(),
-            loop: null
-        };
-        // Strings
-        this.portName = portName || k.OBCISimulatorPortName;
-
-        // Call 'open'
-        if (this.options.verbose) console.log(`Port name: ${portName}`);
-        setTimeout(() => {
-            this.emit('open');
-            this.connected = true;
-        }, 200);
-
+      }
    }

-    // This allows us to use the emitter class freely outside of the module
-    util.inherits(OpenBCISimulator, stream.Stream);
+    for (o in options) throw new Error('"' + o + '" is not a valid option');

-    OpenBCISimulator.prototype.flush = function() {
-        this.buffer.fill(0);
-        //if (this.options.verbose) console.log('flushed');
+    this.options = opts;
+
+    // Bools
+    this.connected = false;
+    this.sd = {
+      active: false,
+      startTime: 0
    };
+    this.streaming = false;
+    this.synced = false;
+    this.sendSyncSetPacket = false;
+    // Buffers
+    this.outputBuffer = new Buffer(this.options.bufferSize);
+    this.outputBuffered = 0;
+    // Numbers
+    this.channelNumber = 1;
+    this.hostChannelNumber = this.channelNumber;
+    this.pollTime = 80;
+    this.sampleNumber = -1; // So the first sample is 0
+    // Objects
+    this.sampleGenerator = openBCISample.randomSample(k.OBCINumberOfChannelsDefault, this.options.sampleRate, this.options.alpha, this.options.lineNoise);
+    this.time = {
+      current: 0,
+      start: now(),
+      loop: null
+    };
+    // Strings
+    this.portName = portName || k.OBCISimulatorPortName;

-    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;
-                break;
-            case k.OBCIStreamStop:
-                if (this.stream) clearInterval(this.stream); // Stops the stream
-                this.streaming = false;
-                break;
-            case k.OBCIMiscSoftReset:
-                if (this.stream) clearInterval(this.stream);
-                this.streaming = false;
-                this.emit('data', new Buffer(`OpenBCI V3 Simulator\nOn Board ADS1299 Device ID: 0x12345\n${this.options.daisy ? "On Daisy ADS1299 Device ID: 0xFFFFF\n" : ""}LIS3DH Device ID: 0x38422\n${this.options.firmware === k.OBCIFirmwareV2 ? "Firmware: v2.0.0\n" : ""}$$$`));
-                break;
-            case k.OBCISDLogForHour1:
-            case k.OBCISDLogForHour2:
-            case k.OBCISDLogForHour4:
-            case k.OBCISDLogForHour12:
-            case k.OBCISDLogForHour24:
-            case k.OBCISDLogForMin5:
-            case k.OBCISDLogForMin15:
-            case k.OBCISDLogForMin30:
-            case k.OBCISDLogForSec14:
-                // If we are not streaming, then do verbose output
-                if (!this.streaming) {
-                    this.emit('data', new Buffer('Wiring is correct and a card is present.\nCorresponding SD file OBCI_69.TXT\n$$$'));
-                }
-                this.sd.active = true;
-                this.sd.startTime = now();
-                break;
-            case k.OBCISDLogStop:
-                if (!this.streaming) {
-                    if (this.SDLogActive) {
-                        this.emit('data', new Buffer(`Total Elapsed Time: ${now() - this.sd.startTime} ms\n`));
-                        this.emit('data', new Buffer(`Max write time: ${Math.random()*500} us\n`));
-                        this.emit('data', new Buffer(`Min write time: ${Math.random()*200} us\n`));
-                        this.emit('data', new Buffer(`Overruns: 0\n`));
-                        this._printEOT();
-                    } else {
-                        this.emit('data', new Buffer('No open file to close\n'));
-                        this._printEOT();
-                    }
-                }
-                this.SDLogActive = false;
-                break;
-            case k.OBCISyncTimeSet:
-                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
-                    this.synced = true;
-                    setTimeout(() => {
-                        this.emit('data', new Buffer(k.OBCISyncTimeSent));
-                        this._syncUp();
-                    }, 10);
-                }
-                break;
-            default:
-                break;
+    // Call 'open'
+    if (this.options.verbose) console.log(`Port name: ${portName}`);
+    setTimeout(() => {
+      this.connected = true;
+      this.emit('open');
+    }, 200);
+  }
+
+  // This allows us to use the emitter class freely outside of the module
+  // TODO: upgrade from old-style streams to stream.Duplex or stream.Transform
+  util.inherits(OpenBCISimulator, stream.Stream);
+
+  OpenBCISimulator.prototype.flush = function (callback) {
+    this.outputBuffered = 0;
+
+    clearTimeout(this.outputLoopHandle);
+    this.outputLoopHandle = null;
+
+    if (callback) callback();
+  };
+
+  OpenBCISimulator.prototype.isOpen = function () {
+    return this.connected;
+  };
+
+  // output only size bytes of the output buffer
+  OpenBCISimulator.prototype._partialDrain = function (size) {
+    if (!this.connected) throw new Error('not connected');
+
+    if (size > this.outputBuffered) size = this.outputBuffered;
+
+    // buffer is copied because presently openBCIBoard.js reuses it
+    var outBuffer = new Buffer(this.outputBuffer.slice(0, size));
+
+    this.outputBuffer.copy(this.outputBuffer, 0, size, this.outputBuffered);
+    this.outputBuffered -= size;
+
+    this.emit('data', outBuffer);
+  };
+
+  // queue some data for output and send it out depending on options.fragmentation
+  OpenBCISimulator.prototype._output = function (dataBuffer) {
+    // drain full buffers until there is no overflow
+    while (this.outputBuffered + dataBuffer.length > this.outputBuffer.length) {
+      var len = dataBuffer.copy(this.outputBuffer, this.outputBuffered);
+      dataBuffer = dataBuffer.slice(len);
+      this.outputBuffered += len;
+
+      this._partialDrain(this.outputBuffered);
+      this.flush();
+    }
+
+    dataBuffer.copy(this.outputBuffer, this.outputBuffered);
+    this.outputBuffered += dataBuffer.length;
+
+    if (!this.outputLoopHandle) {
+      var latencyTime = this.options.latencyTime;
+      if (this.options.fragmentation === k.OBCISimulatorFragmentationOneByOne ||
+          this.options.fragmentation === k.OBCISimulatorFragmentationNone) {
+        // no need to wait for latencyTime
+        // note that this is the only difference between 'none' and 'fullBuffers'
+        latencyTime = 0;
+      }
+      var outputLoop = () => {
+        var size;
+        switch (this.options.fragmentation) {
+          case k.OBCISimulatorFragmentationRandom:
+            if (Math.random() < 0.5) {
+              // randomly picked to send out a fragment
+              size = Math.ceil(Math.random() * Math.max(this.outputBuffered, 62));
+              break;
+            } // else, randomly picked to send a complete buffer in next block
+            /* falls through */
+          case k.OBCISimulatorFragmentationFullBuffers:
+          case k.OBCISimulatorFragmentationNone:
+          case false:
+            size = this.outputBuffered;
+            break;
+          case k.OBCISimulatorFragmentationOneByOne:
+            size = 1;
+            break;
        }
-
-        /** Handle Callback */
-        if (this.connected) {
-            callback(null,'Success!');
+        this._partialDrain(size);
+        if (this.outputBuffered) {
+          this.outputLoopHandle = setTimeout(outputLoop, latencyTime);
+        } else {
+          this.outputLoopHandle = null;
        }
-    };
+      };
+      if (latencyTime === 0) {
+        outputLoop();
+      } else {
+        this.outputLoopHandle = setTimeout(outputLoop, latencyTime);
+      }
+    }
+  };

-    OpenBCISimulator.prototype.drain = function(callback) {
-        callback();
-    };
+  OpenBCISimulator.prototype.write = function (data, callback) {
+    if (!this.connected) {
+      if (callback) callback('Not connected');
+      else throw new Error('Not connected!');
+      return;
+    }

-    OpenBCISimulator.prototype.close = function(callback) {
-        if (this.connected) {
-            this.emit('close');
+    // TODO: this function assumes a type of Buffer for radio, and a type of String otherwise
+    //       FIX THIS it makes it unusable outside the api code
+    switch (data[0]) {
+      case k.OBCIRadioKey:
+        this._processPrivateRadioMessage(data);
+        break;
+      case k.OBCIStreamStart:
+        if (!this.stream) this._startStream();
+        this.streaming = true;
+        break;
+      case k.OBCIStreamStop:
+        if (this.stream) clearInterval(this.stream); // Stops the stream
+        this.streaming = false;
+        break;
+      case k.OBCIMiscSoftReset:
+        if (this.stream) clearInterval(this.stream);
+        this.streaming = false;
+        this._output(new Buffer(`OpenBCI V3 Simulator On Board ADS1299 Device ID: 0x12345 ${this.options.daisy ? `On Daisy ADS1299 Device ID: 0xFFFFF\n` : ``} LIS3DH Device ID: 0x38422 ${this.options.firmwareVersion === k.OBCIFirmwareV2 ? `Firmware: v2.0.0\n` : ``}$$$`));
+        break;
+      case k.OBCISDLogForHour1:
+      case k.OBCISDLogForHour2:
+      case k.OBCISDLogForHour4:
+      case k.OBCISDLogForHour12:
+      case k.OBCISDLogForHour24:
+      case k.OBCISDLogForMin5:
+      case k.OBCISDLogForMin15:
+      case k.OBCISDLogForMin30:
+      case k.OBCISDLogForSec14:
+        // If we are not streaming, then do verbose output
+        if (!this.streaming) {
+          this._output(new Buffer('Wiring is correct and a card is present.\nCorresponding SD file OBCI_69.TXT\n$$$'));
        }
-        this.connected = false;
-        callback();
+        this.sd.active = true;
+        this.sd.startTime = now();
+        break;
+      case k.OBCISDLogStop:
+        if (!this.streaming) {
+          if (this.SDLogActive) {
+            this._output(new Buffer(`Total Elapsed Time: ${now() - this.sd.startTime} ms`));
+            this._output(new Buffer(`Max write time: ${Math.random() * 500} us`));
+            this._output(new Buffer(`Min write time: ${Math.random() * 200} us`));
+            this._output(new Buffer(`Overruns: 0`));
+            this._printEOT();
+          } else {
+            this._output(new Buffer('No open file to close\n'));
+            this._printEOT();
+          }
+        }
+        this.SDLogActive = false;
+        break;
+      case k.OBCISyncTimeSet:
+        if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+          this.synced = true;
+          setTimeout(() => {
+            this._output(new Buffer(k.OBCISyncTimeSent));
+            this._syncUp();
+          }, 10);
+        }
+        break;
+      case k.OBCIChannelMaxNumber8:
+        if (this.options.daisy) {
+          this.options.daisy = false;
+          this._output(new Buffer(k.OBCIChannelMaxNumber8SuccessDaisyRemoved));
+          this._printEOT();
+        } else {
+          this._printEOT();
+        }
+        break;
+      case k.OBCIChannelMaxNumber16:
+        if (this.options.daisy) {
+          this._output(new Buffer(k.OBCIChannelMaxNumber16DaisyAlreadyAttached));
+          this._printEOT();
+        } else {
+          if (this.options.daisyCanBeAttached) {
+            this.options.daisy = true;
+            this._output(new Buffer(k.OBCIChannelMaxNumber16DaisyAttached));
+            this._printEOT();
+          } else {
+            this._output(new Buffer(k.OBCIChannelMaxNumber16NoDaisyAttached));
+            this._printEOT();
+          }
+        }
+        break;
+      default:
+        break;
+    }
+
+    /** Handle Callback */
+    if (callback) {
+      callback(null, 'Success!');
+    }
+  };
+
+  OpenBCISimulator.prototype.drain = function (callback) {
+    if (callback) callback();
+  };
+
+  OpenBCISimulator.prototype.close = function (callback) {
+    if (this.connected) {
+      this.flush();
+
+      if (this.stream) clearInterval(this.stream);
+
+      this.connected = false;
+      this.emit('close');
+      if (callback) callback();
+    } else {
+      if (callback) callback('not connected');
+    }
+  };
+
+  OpenBCISimulator.prototype._startStream = function () {
+    var intervalInMS = 1000 / this.options.sampleRate;
+
+    if (intervalInMS < 2) intervalInMS = 2;
+
+    var getNewPacket = 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]));
+        }
+      }
    };

-    OpenBCISimulator.prototype._startStream = function() {
-        var intervalInMS = 1000 / this.options.sampleRate;
+    this.stream = setInterval(() => {
+      this._output(getNewPacket(this.sampleNumber));
+      this.sampleNumber++;
+    }, intervalInMS);
+  };

-        if (intervalInMS < 2) intervalInMS = 2;
+  OpenBCISimulator.prototype._syncUp = function () {
+    setTimeout(() => {
+      this.sendSyncSetPacket = true;
+    }, 12); // 3 packets later
+  };

-        var getNewPacket = 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));
-                }
+  OpenBCISimulator.prototype._printEOT = function () {
+    this._output(new Buffer('$$$'));
+  };
+
+  OpenBCISimulator.prototype._printFailure = function () {
+    this._output(new Buffer('Failure: '));
+  };
+
+  OpenBCISimulator.prototype._printSuccess = function () {
+    this._output(new Buffer('Success: '));
+  };
+
+  OpenBCISimulator.prototype._printValidatedCommsTimeout = function () {
+    this._printFailure();
+    this._output(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._output(new Buffer(`Host and Device on Channel Number ${this.channelNumber}`));
+            this._output(new Buffer([this.channelNumber]));
+            this._printEOT();
+          } else if (!this.serialPortFailure) {
+            this._printFailure();
+            this._output(new Buffer(`Host on Channel Number ${this.channelNumber}`));
+            this._output(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._output(new Buffer(`Channel Number ${this.channelNumber}`));
+              this._output(new Buffer([this.channelNumber]));
+              this._printEOT();
            } 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._printFailure();
+              this._output(new Buffer('Verify channel number is less than 25'));
+              this._printEOT();
            }
-        };
-
-        this.stream = setInterval(() => {
-            this.emit('data', getNewPacket(this.sampleNumber));
-            this.sampleNumber++;
-        }, intervalInMS);
-    };
-
-    OpenBCISimulator.prototype._syncUp = function() {
-        setTimeout(() => {
-            this.sendSyncSetPacket = true;
-        }, 12); // 3 packets later
-    };
-
-    OpenBCISimulator.prototype._printEOT = function () {
-        this.emit('data', new Buffer("$$$"));
-    };
-
-    OpenBCISimulator.prototype._printFailure = function () {
-        this.emit('data', new Buffer("Failure: "));
-    };
-
-    OpenBCISimulator.prototype._printSuccess = function () {
-        this.emit('data', new Buffer("Success: "));
-    };
-
-    OpenBCISimulator.prototype._printValidatedCommsTimeout = function () {
-        this._printFailure();
-        this.emit('data', new Buffer("Communications timeout - Device failed to poll Host"));
-        this._printEOT();
-    };
-
-    OpenBCISimulator.prototype._processPrivateRadioMessage = function(dataBuffer) {
-        switch (dataBuffer[1]) {
-            case k.OBCIRadioCmdChannelGet:
-                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
-                    if (!this.options.boardFailure) {
-                        this._printSuccess();
-                        this.emit('data', new Buffer(`Host and Device on Channel Number ${this.channelNumber}`));
-                        this.emit('data', new Buffer([this.channelNumber]));
-                        this._printEOT();
-                    } else if (!this.serialPortFailure) {
-                        this._printFailure();
-                        this.emit('data', new Buffer(`Host on Channel Number ${this.channelNumber}`));
-                        this.emit('data', new Buffer([this.channelNumber]));
-                        this._printEOT();
-                    }
-                }
-                break;
-            case k.OBCIRadioCmdChannelSet:
-                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
-                    if (!this.options.boardFailure) {
-                        if (dataBuffer[2] < k.OBCIRadioChannelMax) {
-                            this.channelNumber = dataBuffer[2];
-                            this.hostChannelNumber = this.channelNumber;
-                            this._printSuccess();
-                            this.emit('data', new Buffer(`Channel Number ${this.channelNumber}`));
-                            this.emit('data', new Buffer([this.channelNumber]));
-                            this._printEOT();
-                        } else {
-                            this._printFailure();
-                            this.emit('data', new Buffer("Verify channel number is less than 25"));
-                            this._printEOT();
-                        }
-                    } else if (!this.serialPortFailure) {
-                       this._printValidatedCommsTimeout();
-                    }
-                }
-                break;
-            case k.OBCIRadioCmdChannelSetOverride:
-                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
-                    if (dataBuffer[2] < k.OBCIRadioChannelMax) {
-                        if (dataBuffer[2] === this.channelNumber) {
-                            this.options.boardFailure = false;
-                        } else {
-                            this.options.boardFailure = true;
-                        }
-                        this.hostChannelNumber = dataBuffer[2];
-                        this._printSuccess();
-                        this.emit('data', new Buffer(`Host override - Channel Number ${this.hostChannelNumber}`));
-                        this.emit('data', new Buffer([this.hostChannelNumber]));
-                        this._printEOT();
-                    } else {
-                        this._printFailure();
-                        this.emit('data', new Buffer("Verify channel number is less than 25"));
-                        this._printEOT();
-                    }
-                }
-                break;
-            case k.OBCIRadioCmdPollTimeGet:
-                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
-                    if (!this.options.boardFailure) {
-                        this._printSuccess();
-                        this.emit('data', new Buffer(`Poll Time ${this.pollTime}`));
-                        this.emit('data', new Buffer([this.pollTime]));
-                        this._printEOT();
-                    } else {
-                        this._printValidatedCommsTimeout();
-                    }
-                }
-                break;
-            case k.OBCIRadioCmdPollTimeSet:
-                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
-                    if (!this.options.boardFailure) {
-                        this.pollTime = dataBuffer[2];
-                        this._printSuccess();
-                        this.emit('data', new Buffer(`Poll Time ${this.pollTime}`));
-                        this.emit('data', new Buffer([this.pollTime]));
-                        this._printEOT();
-                    } else {
-                        this._printValidatedCommsTimeout();
-                    }
-                }
-                break;
-            case k.OBCIRadioCmdBaudRateSetDefault:
-                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
-                    this._printSuccess();
-                    this.emit('data', new Buffer("Switch your baud rate to 115200"));
-                    this.emit('data', new Buffer([0x24,0x24,0x24,0xFF])); // The board really does this
-                }
-                break;
-            case k.OBCIRadioCmdBaudRateSetFast:
-                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
-                    this._printSuccess();
-                    this.emit('data', new Buffer("Switch your baud rate to 230400"));
-                    this.emit('data', new Buffer([0x24,0x24,0x24,0xFF])); // The board really does this
-                }
-                break;
-            case k.OBCIRadioCmdSystemStatus:
-                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
-                    if (!this.options.boardFailure) {
-                        this._printSuccess();
-                        this.emit('data', new Buffer("System is Up"));
-                        this._printEOT();
-                    } else {
-                        this._printFailure();
-                        this.emit('data', new Buffer("System is Down"));
-                        this._printEOT();
-                    }
-                }
-                break;
-            default:
-                break;
+          } 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._output(new Buffer(`Host override - Channel Number ${this.hostChannelNumber}`));
+            this._output(new Buffer([this.hostChannelNumber]));
+            this._printEOT();
+          } else {
+            this._printFailure();
+            this._output(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._output(new Buffer(`Poll Time ${this.pollTime}`));
+            this._output(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._output(new Buffer(`Poll Time ${this.pollTime}`));
+            this._output(new Buffer([this.pollTime]));
+            this._printEOT();
+          } else {
+            this._printValidatedCommsTimeout();
+          }
+        }
+        break;
+      case k.OBCIRadioCmdBaudRateSetDefault:
+        if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+          this._printSuccess();
+          this._output(new Buffer('Switch your baud rate to 115200'));
+          this._output(new Buffer([0x24, 0x24, 0x24, 0xFF])); // The board really does this
+        }
+        break;
+      case k.OBCIRadioCmdBaudRateSetFast:
+        if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+          this._printSuccess();
+          this._output(new Buffer('Switch your baud rate to 230400'));
+          this._output(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._output(new Buffer('System is Up'));
+            this._printEOT();
+          } else {
+            this._printFailure();
+            this._output(new Buffer('System is Down'));
+            this._printEOT();
+          }
+        }
+        break;
+      default:
+        break;
+    }
+  };

-    factory.OpenBCISimulator = OpenBCISimulator;
+  factory.OpenBCISimulator = OpenBCISimulator;
 }

 util.inherits(OpenBCISimulatorFactory, EventEmitter);
@@ -1,11 +1,12 @@
 {
  "name": "openbci",
-  "version": "1.3.0",
+  "version": "1.5.1",
  "description": "The official Node.js SDK for the OpenBCI Biosensor Board.",
  "main": "openBCIBoard",
  "scripts": {
+    "lint": "semistandard | snazzy",
    "start": "node index",
-    "test": "mocha test",
+    "test": "semistandard | snazzy && mocha test",
    "test-cov": "istanbul cover ./node_modules/mocha/bin/_mocha -- -R spec && codecov"
  },
  "keywords": [
@@ -27,14 +28,18 @@
    "test": "test"
  },
  "devDependencies": {
+    "bluebird": "3.4.6",
    "chai": "^3.4.1",
    "chai-as-promised": "^5.2.0",
    "codecov": "^1.0.1",
    "istanbul": "^0.4.4",
    "mocha": "^3.0.2",
    "sandboxed-module": "^2.0.3",
+    "semistandard": "^9.0.0",
    "sinon": "^1.17.2",
-    "sinon-chai": "^2.8.0"
+    "sinon-as-promised": "^4.0.2",
+    "sinon-chai": "^2.8.0",
+    "snazzy": "^5.0.0"
  },
  "repository": {
    "type": "git",
@@ -46,5 +51,18 @@
  "homepage": "https://github.com/openbci/openbci_nodejs#readme",
  "engines": {
    "node": ">=4.0.0"
+  },
+  "semistandard": {
+    "globals": [
+      "describe",
+      "context",
+      "before",
+      "beforeEach",
+      "after",
+      "afterEach",
+      "it",
+      "expect",
+      "should"
+    ]
  }
 }
@@ -0,0 +1,142 @@
+var timingEventsAsPromises = require('./timingEventsAsPromises');
+exports.BluebirdPromise = require('bluebird');
+exports.PromiseIgnored = global.Promise;
+
+// Enable bluebird for all promise usage during tests only
+// Fails tests for issues bluebird finds
+// Exports a function to list all promises (getPendingPromises)
+// Exports a function to verify no promises pending within a timeout (noPendingPromises)
+
+exports.BluebirdPromise.config({
+  // TODO: wForgottenReturn is disabled because timingEventsAsPromises triggers it; find a workaround
+  warnings: { wForgottenReturn: false },
+  longStackTraces: true,
+  monitoring: true,
+  cancellation: true
+});
+
+// nextTick conveniently not instrumented by timingEventsAsPromises
+exports.BluebirdPromise.setScheduler(process.nextTick);
+
+// unhandled rejections become test failures
+process.on('unhandledRejection', (reason, promise) => {
+  if (!(reason instanceof Error)) {
+    reason = new Error('unhandled promise rejection: ' + reason);
+  } else {
+    reason.message = 'unhandled promise rejection: ' + reason.message;
+  }
+  process.nextTick(() => { throw reason; });
+});
+
+// // warnings become test failures
+// process.on('warning', (warning) => {
+//   var error = new Error(warning);
+//   process.nextTick(() => { throw error; });
+// });
+
+// provide access to all currently pending promises
+var pendingPromises = {};
+var promiseId = 0;
+var nested = 0;
+
+function promiseCreationHandler (promise) {
+  // promise created already resolved; ignore
+  if (!promise.isPending()) return;
+
+  // need to create another promise to get access to the extended stack trace
+  // nested detects if we are inside our own dummy promise
+  ++nested;
+  if (nested === 1) {
+    // not the dummy promise
+    promise.___id = ++promiseId;
+    // store promise details
+    var error = new Error('Promise ' + promise.___id + ' is still pending');
+    var entry = {
+      promise: promise,
+      id: promise.___id,
+      error: error
+    };
+    pendingPromises[promise.___id] = entry;
+    // extract stack trace by rejecting an error; bluebird fills in expanded stack
+    exports.BluebirdPromise.reject(error).catch(error => {
+      entry.error = error;
+      entry.stack = error.stack;
+    });
+  } else {
+    promise.___nested = nested;
+  }
+  --nested;
+}
+process.on('promiseCreated', promiseCreationHandler);
+
+function promiseDoneHandler (promise) {
+  if (promise.___nested) return;
+  delete pendingPromises[promise.___id];
+}
+process.on('promiseFulfilled', promiseDoneHandler);
+process.on('promiseRejected', promiseDoneHandler);
+process.on('promiseResolved', promiseDoneHandler);
+process.on('promiseCancelled', promiseDoneHandler);
+
+exports.getPendingPromises = function () {
+  var ret = [];
+  for (var promise in pendingPromises) {
+    ret.push(pendingPromises[promise]);
+  }
+  return ret;
+};
+
+exports.noPendingPromises = function (milliseconds) {
+  if (!milliseconds) milliseconds = 0;
+
+  return new exports.PromiseIgnored((resolve, reject) => {
+    function waited100 () {
+      var promises = exports.getPendingPromises();
+
+      if (promises.length === 0) {
+        return resolve();
+      }
+
+      if (milliseconds > 0) {
+        milliseconds -= 100;
+        return timingEventsAsPromises.setTimeoutIgnored(waited100, 100);
+      }
+
+      // timed out, but promises remaining: cancel all
+
+      console.log(promises.length + ' promises still pending');
+
+      promises.forEach(promise => {
+        promise.promise.cancel();
+      });
+
+      // report one
+      reject(promises[0].error);
+    }
+
+    timingEventsAsPromises.setTimeoutIgnored(waited100, 0);
+  });
+};
+
+// now instrument the Promise object itself to always use a simplified version of bluebird
+// bluebird is composed inside a bare-bones Promise object providing only the official calls
+
+global.Promise = function (handler) {
+  this._promise = new exports.BluebirdPromise(handler);
+};
+
+// compose class methods
+['all', 'race', 'reject', 'resolve'].forEach(classMethod => {
+  global.Promise[classMethod] = function () {
+    return exports.BluebirdPromise[classMethod].apply(exports.BluebirdPromise, [].slice.call(arguments));
+  };
+  Object.defineProperty(global.Promise[classMethod], 'name', { value: 'Promise.' + classMethod });
+});
+
+// compose object methods
+['then', 'catch'].forEach(objectMethod => {
+  global.Promise.prototype[objectMethod] = function () {
+    return this._promise[objectMethod].apply(this._promise, [].slice.call(arguments));
+  };
+  Object.defineProperty(global.Promise.prototype[objectMethod], 'name', { value: 'Promise.' + objectMethod });
+});
@@ -0,0 +1,949 @@
+'use strict';
+var bluebirdChecks = require('./bluebirdChecks');
+var sinon = require('sinon'); // eslint-disable-line no-unused-vars
+var chai = require('chai');
+var expect = chai.expect;
+var should = chai.should(); // eslint-disable-line no-unused-vars
+var openBCIBoard = require('../openBCIBoard');
+var openBCISample = openBCIBoard.OpenBCISample;
+var k = openBCISample.k;
+var chaiAsPromised = require('chai-as-promised');
+var sinonChai = require('sinon-chai');
+
+chai.use(chaiAsPromised);
+chai.use(sinonChai);
+
+describe('openbci-radios', function () {
+  this.timeout(2000);
+  var ourBoard, masterPortName;
+
+  before(function (done) {
+    ourBoard = new openBCIBoard.OpenBCIBoard();
+    ourBoard.autoFindOpenBCIBoard()
+      .then(portName => {
+        ourBoard = null;
+        masterPortName = portName;
+        done();
+      })
+      .catch(() => {
+        ourBoard = null;
+        masterPortName = k.OBCISimulatorPortName;
+        done();
+      });
+  });
+  after(done => {
+    if (ourBoard) {
+      if (ourBoard['connected']) {
+        ourBoard.disconnect()
+          .then(() => {
+            done();
+          })
+          .catch(err => {
+            done(err);
+          });
+      } else {
+        done();
+      }
+    } else {
+      done();
+    }
+  });
+
+  describe('#radioChannelSet', function () {
+    afterEach(function (done) {
+      if (ourBoard.isConnected()) {
+        ourBoard.disconnect().then(() => {
+          done();
+        }).catch(() => done);
+      } else {
+        done();
+      }
+    });
+    afterEach(() => bluebirdChecks.noPendingPromises());
+
+    it('should not change the channel number if not connected', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.radioChannelGet().should.be.rejected.and.notify(done);
+    });
+
+    it('should reject if streaming', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.streamStart()
+              .then(() => {
+                ourBoard.radioChannelSet(1).then(() => {
+                  done('should have rejected');
+                }).catch(() => {
+                  done(); // Test pass
+                });
+              }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+    it('should reject if not firmware version 2', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelSet(1).should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+    it('should reject if a number is not sent as input', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelSet('1').should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+
+    it('should reject if no channel number is presented as arg', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelSet().should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+
+    it('should reject if the requested new channel number is lower than 0', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelSet(-1).should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+
+    it('should reject if the requested new channel number is higher than 25', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelSet(26).should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+
+    it('should not change the channel if the board is not communicating with the host', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorBoardFailure: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelSet(1).should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+
+    it('should change the channel if connected, not steaming, and using firmware version 2+', function (done) {
+      var newChannelNumber = 2;
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelSet(newChannelNumber).then(channelNumber => {
+              expect(channelNumber).to.be.equal(newChannelNumber);
+              done();
+            }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+  });
+
+  describe('#radioChannelSetHostOverride', function () {
+    afterEach(function (done) {
+      if (ourBoard.isConnected()) {
+        ourBoard.disconnect().then(() => {
+          done();
+        }).catch(() => done);
+      } else {
+        done();
+      }
+    });
+    afterEach(() => bluebirdChecks.noPendingPromises());
+    it('should not change the channel number if not connected', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.radioChannelSetHostOverride().should.be.rejected.and.notify(done);
+    });
+    it('should reject if streaming', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.streamStart()
+              .then(() => {
+                ourBoard.radioChannelSetHostOverride(1).then(() => {
+                  done('should have rejected');
+                }).catch(() => {
+                  done(); // Test pass
+                });
+              }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+    it('should reject if a number is not sent as input', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelSetHostOverride('1').should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+    it('should reject if no channel number is presented as arg', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelSetHostOverride().should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+    it('should reject if the requested new channel number is lower than 0', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelSetHostOverride(-1).should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+    it('should reject if the requested new channel number is higher than 25', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelSetHostOverride(26).should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+    it('should change the channel if connected, not steaming, and using firmware version 2+', function (done) {
+      var newChannelNumber = 2;
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelSetHostOverride(newChannelNumber).then(channelNumber => {
+              expect(channelNumber).to.be.equal(newChannelNumber);
+              done();
+            }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+  });
+
+  describe('#radioChannelGet', function () {
+    afterEach(function (done) {
+      if (ourBoard.isConnected()) {
+        ourBoard.disconnect().then(() => {
+          done();
+        }).catch(() => done);
+      } else {
+        done();
+      }
+    });
+    afterEach(() => bluebirdChecks.noPendingPromises());
+
+    it('should not query if not connected', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.radioChannelGet().should.be.rejected.and.notify(done);
+    });
+    it('should not query if streaming', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.streamStart()
+              .then(() => {
+                ourBoard.radioChannelGet().then(() => {
+                  done('should have rejected');
+                }).catch(() => {
+                  done(); // Test pass
+                });
+              }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+    it('should not query if not firmware version 2', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelGet().should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+    it('should query if firmware version 2', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelGet().then(res => {
+              expect(res.channelNumber).to.be.within(k.OBCIRadioChannelMin, k.OBCIRadioChannelMax);
+              done();
+            }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+    it('should get message even if the board is not communicating with dongle', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorBoardFailure: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioChannelGet().should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+  });
+
+  describe('#radioPollTimeSet', function () {
+    afterEach(function (done) {
+      if (ourBoard.isConnected()) {
+        ourBoard.disconnect().then(() => {
+          done();
+        }).catch(() => done);
+      } else {
+        done();
+      }
+    });
+    afterEach(() => bluebirdChecks.noPendingPromises());
+    it('should not change the channel number if not connected', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.radioPollTimeSet().should.be.rejected.and.notify(done);
+    });
+
+    it('should reject if streaming', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.streamStart()
+              .then(() => {
+                ourBoard.radioPollTimeSet(1).then(() => {
+                  done('should have rejected');
+                }).catch(() => {
+                  done(); // Test pass
+                });
+              }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+
+    it('should reject if not firmware version 2', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioPollTimeSet(1).should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+
+    it('should reject if a number is not sent as input', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioPollTimeSet('1').should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+
+    it('should reject if no poll time is presented as arg', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioPollTimeSet().should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+
+    it('should reject if the requested new poll time is lower than 0', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioPollTimeSet(-1).should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+
+    it('should reject if the requested new poll time is higher than 255', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioPollTimeSet(256).should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+
+    it('should not change the poll time if the board is not communicating with the host', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorBoardFailure: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioPollTimeSet(1).should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+
+    it('should change the poll time if connected, not steaming, and using firmware version 2+', function (done) {
+      var newPollTime = 69;
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioPollTimeSet(newPollTime).then(() => {
+              done();
+            }).catch(err => {
+              done(err);
+            });
+          });
+        }).catch(err => done(err));
+    });
+  });
+
+  describe('#radioPollTimeGet', function () {
+    afterEach(function (done) {
+      if (ourBoard.isConnected()) {
+        ourBoard.disconnect().then(() => {
+          done();
+        }).catch(() => done);
+      } else {
+        done();
+      }
+    });
+    afterEach(() => bluebirdChecks.noPendingPromises());
+
+    it('should not query if not connected', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.radioPollTimeGet().should.be.rejected.and.notify(done);
+    });
+    it('should not query if streaming', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.streamStart()
+              .then(() => {
+                ourBoard.radioPollTimeGet().then(() => {
+                  done('should have rejected');
+                }).catch(() => {
+                  done(); // Test pass
+                });
+              }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+    it('should not query if not firmware version 2', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioPollTimeGet().should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+    it('should query if firmware version 2', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioPollTimeGet().then(pollTime => {
+              expect(pollTime).to.be.greaterThan(0);
+              done();
+            }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+    it('should get failure message if the board is not communicating with dongle', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorBoardFailure: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioPollTimeGet().should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+  });
+
+  describe('#radioBaudRateSet', function () {
+    afterEach(function (done) {
+      if (ourBoard.isConnected()) {
+        ourBoard.disconnect().then(() => {
+          done();
+        }).catch(() => done);
+      } else {
+        done();
+      }
+    });
+    afterEach(() => bluebirdChecks.noPendingPromises());
+
+    it('should not try to set baud rate if not connected', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.radioBaudRateSet('default').should.be.rejected.and.notify(done);
+    });
+    it('should reject if no input', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.radioBaudRateSet().should.be.rejected.and.notify(done);
+    });
+    it('should be rejected if input type incorrect', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.radioBaudRateSet(1).should.be.rejected.and.notify(done);
+    });
+    it('should not try to change the baud rate if streaming', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.streamStart()
+              .then(() => {
+                ourBoard.radioBaudRateSet('default').then(() => {
+                  done('should have rejected');
+                }).catch(() => {
+                  done(); // Test pass
+                });
+              }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+    it('should not try to change the baud rate if not firmware version 2', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioBaudRateSet('default').should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+    it('should set the baud rate to default if firmware version 2', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioBaudRateSet('default').then(baudrate => {
+              expect(baudrate).to.be.equal(115200);
+              done();
+            }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+    it('should set the baud rate to fast if firmware version 2', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioBaudRateSet('fast').then(baudrate => {
+              expect(baudrate).to.be.equal(230400);
+              done();
+            }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+  });
+
+  describe('#radioSystemStatusGet', function () {
+    afterEach(function (done) {
+      if (ourBoard.isConnected()) {
+        ourBoard.disconnect().then(() => {
+          done();
+        }).catch(() => done);
+      } else {
+        done();
+      }
+    });
+    afterEach(() => bluebirdChecks.noPendingPromises());
+
+    it('should not get system status if not connected', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.radioSystemStatusGet().should.be.rejected.and.notify(done);
+    });
+    it('should not get system status if streaming', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.streamStart()
+              .then(() => {
+                ourBoard.radioSystemStatusGet().then(() => {
+                  done('should have rejected');
+                }).catch(() => {
+                  done(); // Test pass
+                });
+              }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+    it('should not get system status if not firmware version 2', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioSystemStatusGet().should.be.rejected.and.notify(done);
+          });
+        }).catch(err => done(err));
+    });
+    it('should get up system status if firmware version 2', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2'
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioSystemStatusGet().then(isUp => {
+              expect(isUp).to.be.true;
+              done();
+            }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+    it('should get down system status if firmware version 2', function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulate: true,
+        simulatorFirmwareVersion: 'v2',
+        simulatorBoardFailure: true
+      });
+      ourBoard.connect(k.OBCISimulatorPortName)
+        .then(() => {
+          ourBoard.once('ready', () => {
+            ourBoard.radioSystemStatusGet().then(isUp => {
+              expect(isUp).to.be.false;
+              done();
+            }).catch(err => done(err));
+          });
+        }).catch(err => done(err));
+    });
+  });
+
+  describe('#radioTests', function () {
+    this.timeout(0);
+    before(function (done) {
+      ourBoard = new openBCIBoard.OpenBCIBoard({
+        verbose: true,
+        simulatorFirmwareVersion: 'v2',
+        simulatorFragmentation: k.OBCISimulatorFragmentationRandom
+      });
+      ourBoard.connect(masterPortName).catch(err => done(err));
+
+      ourBoard.once('ready', () => {
+        done();
+      });
+    });
+    after(function (done) {
+      if (ourBoard.isConnected()) {
+        ourBoard.disconnect().then(() => {
+          done();
+        });
+      } else {
+        done();
+      }
+    });
+    after(() => bluebirdChecks.noPendingPromises());
+    it('should be able to get the channel number', function (done) {
+      // Don't test if not using v2
+      if (!ourBoard.usingVersionTwoFirmware()) return done();
+      // The channel number should be between 0 and 25. Those are hard limits.
+      ourBoard.radioChannelGet().then(res => {
+        expect(res.channelNumber).to.be.within(0, 25);
+        done();
+      }).catch(err => done(err));
+    });
+    it('should be able to set the channel to 1', function (done) {
+      // Don't test if not using v2
+      if (!ourBoard.usingVersionTwoFirmware()) return done();
+      ourBoard.radioChannelSet(1).then(channelNumber => {
+        expect(channelNumber).to.equal(1);
+        done();
+      }).catch(err => done(err));
+    });
+    it('should be able to set the channel to 2', function (done) {
+      // Don't test if not using v2
+      if (!ourBoard.usingVersionTwoFirmware()) return done();
+      ourBoard.radioChannelSet(2).then(channelNumber => {
+        expect(channelNumber).to.equal(2);
+        done();
+      }).catch(err => done(err));
+    });
+    it('should be able to set the channel to 25', function (done) {
+      // Don't test if not using v2
+      if (!ourBoard.usingVersionTwoFirmware()) return done();
+      ourBoard.radioChannelSet(25).then(channelNumber => {
+        expect(channelNumber).to.equal(25);
+        done();
+      }).catch(err => done(err));
+    });
+    it('should be able to set the channel to 5', function (done) {
+      // Don't test if not using v2
+      if (!ourBoard.usingVersionTwoFirmware()) return done();
+      ourBoard.radioChannelSet(5).then(channelNumber => {
+        expect(channelNumber).to.equal(5);
+        done();
+      }).catch(err => done(err));
+    });
+    it('should be able to override host channel number, verify system is down, set the host back and verify system is up', function (done) {
+      // Don't test if not using v2
+      if (!ourBoard.usingVersionTwoFirmware()) return done();
+      var systemChanNumber = 0;
+      var newChanNum = 0;
+      // var timey = Date.now()
+      // Get the current system channel
+      ourBoard.radioChannelGet()
+        .then(res => {
+          // Store it
+          systemChanNumber = res.channelNumber;
+          // console.log(`system channel number: ${res.channelNumber}`)
+          if (systemChanNumber === 25) {
+            newChanNum = 24;
+          } else {
+            newChanNum = systemChanNumber + 1;
+          }
+          // Call to change just the host
+          return ourBoard.radioChannelSetHostOverride(newChanNum);
+        })
+        .then(newChanNumActual => {
+          expect(newChanNumActual).to.equal(newChanNum);
+          // timey = Date.now()
+          // console.log(`new chan ${newChanNumActual} got`, timey, '0ms')
+          return new Promise((resolve, reject) => {
+            setTimeout(function () {
+              // console.log(`get status`, Date.now(), `${Date.now() - timey}ms`)
+              ourBoard.radioSystemStatusGet().then(isUp => {
+                // console.log('resolving', Date.now(), `${Date.now() - timey}ms`)
+                resolve(isUp);
+              })
+                .catch(err => {
+                  reject(err);
+                });
+            }, 270); // Should be accurate after 270 seconds
+          });
+        })
+        .then(isUp => {
+          // console.log(`isUp test`, Date.now(), `${Date.now() - timey}ms`)
+          expect(isUp).to.be.false;
+          return ourBoard.radioChannelSetHostOverride(systemChanNumber); // Set back to good
+        })
+        .then(newChanNumActual => {
+          // Verify we set it back to normal
+          expect(newChanNumActual).to.equal(systemChanNumber);
+          return ourBoard.radioSystemStatusGet();
+        })
+        .then(isUp => {
+          expect(isUp).to.be.true;
+          done();
+        })
+        .catch(err => done(err));
+    });
+    it('should be able to get the poll time', function (done) {
+      // Don't test if not using v2
+      if (!ourBoard.usingVersionTwoFirmware()) return done();
+      ourBoard.radioPollTimeGet().should.eventually.be.greaterThan(0).and.notify(done);
+    });
+    it('should be able to set the poll time', function (done) {
+      // Don't test if not using v2
+      if (!ourBoard.usingVersionTwoFirmware()) return done();
+      ourBoard.radioPollTimeSet(80).should.become(80).and.notify(done);
+    });
+    it('should be able to change to default baud rate', function (done) {
+      // Don't test if not using v2
+      if (!ourBoard.usingVersionTwoFirmware()) return done();
+      ourBoard.radioBaudRateSet('default').should.become(115200).and.notify(done);
+    });
+    it('should be able to change to fast baud rate', function (done) {
+      // Don't test if not using v2
+      if (!ourBoard.usingVersionTwoFirmware()) return done();
+      ourBoard.radioBaudRateSet('fast').then(newBaudRate => {
+        expect(newBaudRate).to.equal(230400);
+        return ourBoard.radioBaudRateSet('default');
+      }).then(() => {
+        done();
+      }).catch(err => done(err));
+    });
+    it('should be able to set the system status', function (done) {
+      // Don't test if not using v2
+      if (!ourBoard.usingVersionTwoFirmware()) return done();
+      ourBoard.radioSystemStatusGet().then(isUp => {
+        expect(isUp).to.be.true;
+        done();
+      }).catch(err => done(err));
+    });
+  });
+});
@@ -0,0 +1,108 @@
+// Converts timing events to use promises, to gain bluebird's checks
+
+function instrumentTimingEvents (module, type) {
+  // replaces module[type] with a function that does the same thing but uses a promise
+  // assumes the first argument will be to a callback function
+
+  // if this a setSomething function with a clearSomething partner, the partner will also be instrumented
+  var setName = type;
+  var clearName = null;
+  if (type.substring(0, 3) === 'set') {
+    clearName = 'clear' + type.substring(3);
+  }
+
+  if (!module[setName]) return;
+
+  // store original functions
+  var originalSet = module[setName];
+  var originalClear = module[clearName];
+  exports[setName + 'Ignored'] = originalSet;
+
+  // dictionary to store promise details for each call
+  var events = {};
+
+  // setAsPromise() is the brunt of the function.  It replaces the previous global function,
+  // and sets up a promise to resolve when the callback is called
+  var eventCount = 0;
+  var setAsPromise = function (callback) {
+    var args = [].slice.call(arguments);
+
+    var eventNum = ++eventCount;
+    var eventHandle;
+
+    if (setAsPromise._ignoreCount > 0) {
+      --setAsPromise._ignoreCount;
+
+      return originalSet.apply(this, args);
+    }
+
+    // actual callback is replaced by promise resolve
+    args[0] = function () {
+      if (!events[eventNum]) throw new Error(setName + ' ' + eventNum + ' disappeared');
+      events[eventNum].resolve([].slice.call(arguments));
+    };
+
+    eventHandle = originalSet.apply(this, args) || eventNum;
+
+    // this portion is a function so that setInterval may be handled via recursion
+    function dispatch () {
+      var handlerDetails = { handle: eventHandle };
+
+      var promise = new Promise((resolve, reject) => {
+        handlerDetails.resolve = resolve;
+        handlerDetails.reject = reject;
+      });
+
+      handlerDetails.promise = promise;
+      events[eventNum] = handlerDetails;
+
+      promise.then(function (argumentArray) {
+        if (type !== 'setInterval') {
+          delete events[eventNum];
+        } else {
+          dispatch();
+        }
+
+        // call original handler
+        callback.apply(this, argumentArray);
+      }, () => {
+        originalClear(eventHandle);
+        delete events[eventNum];
+      });
+
+      return promise;
+    }
+
+    dispatch();
+
+    return eventNum;
+  };
+
+  // actually replace functions with instrumented ones
+  setAsPromise._ignoreCount = 0;
+  module[setName] = setAsPromise;
+  Object.defineProperty(setAsPromise, 'name', { value: setName + 'AsPromise' });
+
+  if (clearName) {
+    module[clearName] = (eventNum) => {
+      if (!events[eventNum]) {
+        originalClear(eventNum);
+      } else {
+        events[eventNum].reject(new Error('cleared'));
+      }
+    };
+    Object.defineProperty(module[clearName], 'name', { value: clearName + 'AsPromise' });
+  }
+}
+
+instrumentTimingEvents(global, 'setTimeout');
+instrumentTimingEvents(global, 'setInterval');
+instrumentTimingEvents(global, 'setImmediate');
+// // Possible TODO: nextTick needs some exceptions included to prevent infinite recursion
+// instrumentTimingEvents(process, 'nextTick');
+
+// the next call to the passed function should not be promisified
+// may be queued multiple times
+exports.ignoreOnce = (ignored) => {
+  ignored._ignoreCount ++;
+};
@@ -1,135 +0,0 @@
-// This takes a openbci-sdk factory and mocks the shit out of it in complete isolation per require of this file
-
-"use strict";
-
-var Hardware = function () {
-    this.bciBoard = {};
-    //this.mockBinding = {
-    //    connect: this.connect.bind(this),
-    //    disconnect: this.disconnect.bind(this),
-    //    streamStart: this.streamStart.bind(this),
-    //    streamStop: this.streamStop.bind(this),
-    //    write: this.write.bind(this),
-    //    softReset: this.softReset.bind(this),
-    //    autoFindOpenBCIBoard: this.autoFindOpenBCIBoard.bind(this),
-    //    simulatorEnable: this.simulatorEnable.bind(this),
-    //    simulatorDisable: this.simulatorDisable.bind(this)
-    //};
-};
-
-Hardware.prototype.reset = function () {
-    this.bciBoard = {};
-};
-
-Hardware.prototype.createBoard = function () {
-    this.bciBoard = {
-        serial: null,
-        connected: false,
-        streaming: false,
-        isSimulating: false,
-        badPackets: 0,
-        bytesIn: 0,
-        commandsToWrite: 0,
-        sampleCount: 0
-    }
-};
-
-Hardware.prototype.connect = function (portName) {
-
-    return new Promise((resolve, reject) => {
-        if(!this.bciBoard) reject('Board does not exist - call hardware.createBoard() first');
-
-        this.bciBoard.connected = true;
-        this.bciBoard.serial = {
-            portName:portName,
-            baudRate:115200
-        };
-        resolve(this.bciBoard.serial);
-    });
-};
-
-Hardware.prototype.disconnect = function () {
-    return new Promise((resolve,reject) => {
-        if(!this.bciBoard) reject('Board does not exist - call hardware.createBoard() first');
-
-        this.bciBoard.connected = false;
-        this.bciBoard.serial = null;
-    });
-};
-
-Hardware.prototype.streamStart = function () {
-    return new Promise((resolve,reject) => {
-        if(!this.bciBoard) reject('Board does not exist - call hardware.createBoard() first');
-
-        this.bciBoard.streaming = true;
-        resolve();
-    });
-};
-
-Hardware.prototype.streamStop = function () {
-    return new Promise((resolve,reject) => {
-        if(!this.bciBoard) reject('Board does not exist - call hardware.createBoard() first');
-
-        this.bciBoard.streaming = false;
-        resolve();
-    });
-};
-
-Hardware.prototype.simulatorEnable = function () {
-    return new Promise((resolve,reject) => {
-        if(!this.bciBoard) reject('Board does not exist - call hardware.createBoard() first');
-
-        this.bciBoard.isSimulating = true;
-        resolve();
-    });
-};
-
-Hardware.prototype.simulatorDisable = function () {
-    return new Promise((resolve,reject) => {
-        if(!this.bciBoard) reject('Board does not exist - call hardware.createBoard() first');
-
-        this.bciBoard.isSimulating = false;
-        resolve();
-    });
-};
-
-Hardware.prototype.autoFindOpenBCIBoard = function () {
-    return new Promise((resolve,reject) => {
-        resolve('/dev/tty.usbserial-D069XXX');
-    });
-};
-
-Hardware.prototype.emitSample = function (data) {
-    return new Promise((resolve,reject) => {
-        if(!this.bciBoard) reject('Board does not exist - call hardware.createBoard() first');
-
-        this.bciBoard.isSimulating = false;
-        resolve();
-    });
-};
-
-Hardware.prototype.fakeData = function (data) {
-    //do something, not quite sure what yet...
-};
-
-var hardware = new Hardware();
-
-var SandboxedModule = require('sandboxed-module');
-
-var openBCIBoard = SandboxedModule.require('../openBCIBoard', {
-    requires: {
-        fs: {
-            read: hardware.fakeData.bind(hardware)
-        }
-    },
-    globals: {
-        process: {
-            platform: 'darwin',
-            nextTick: process.nextTick
-        }
-    }
-});
-
-openBCIBoard.hardware = hardware;
-
-module.exports = openBCIBoard;
Autor	SHA1	Mensagem	Data
AJ Keller	a552248f21	Merge pull request #143 from octopicorn/patch-1 note about serialport node error	2017-03-23 23:55:24 -04:00
octopicorn	5013112b36	note about serialport node error	2017-03-23 20:40:59 -07:00
AJ Keller	b65694575b	Update changelog.md	2017-03-02 14:52:25 -05:00
AJ Keller	e47128cc4a	Merge pull request #140 from OpenBCI/development Lab Streaming Layer example (#139)	2017-03-02 14:50:50 -05:00
AJ Keller	1a6029770f	Merge pull request #141 from aj-ptw/impedance-csne Impedance csne	2017-03-02 13:39:18 -05:00
AJ Keller	a404703d2e	Removed old functions for impedance - #28	2017-03-02 13:28:19 -05:00
AJ Keller	f618dcd038	Linting well and added auto tests for new impedance stuff	2017-03-02 12:58:12 -05:00
AJ Keller	0f4cb8baf0	Merge branch 'development' of https://github.com/OpenBCI/OpenBCI_NodeJS into impedance-csne	2017-03-02 10:31:40 -05:00
AJ Keller	1ad709659b	Removed functions that were removed in 1.5.0	2017-03-02 10:24:05 -05:00
AJ Keller	b871bd159d	Merge branch 'master' into development	2017-03-02 10:21:27 -05:00
Gabriel Ibagon	9d778b64f8	Lab Streaming Layer example (#139 ) * working lab streaming layer example for Cyton * working lab streaming layer example for Cyton * working lab streaming layer example for Cyton * readme formatting * more readme formatting * typo '-_- * more detail in readme * clarifying readme code * more readme edits * clarified main readme * added sudo note	2017-02-17 12:14:13 -05:00
AJ Keller	95d6529e3a	Fixes #28 - Impedance not working properly	2017-02-11 17:44:21 -08:00
AJ Keller	3f42be4df6	Merge pull request #136 from aj-ptw/fix-16-chan Fix 16 chan	2017-01-04 00:01:04 -05:00
AJ Keller	2523f72059	Update readme for new functions and emitters	2017-01-03 23:30:59 -05:00
AJ Keller	af9f08642e	Fix #131 and add example for daisy with hardset	2017-01-03 23:17:40 -05:00
AJ Keller	a2b4d73847	Bump minor version because of breaking changes	2017-01-03 22:45:33 -05:00
AJ Keller	c2958f408e	Add tests for new daisy code and Enh separated radio tests from main board test	2017-01-03 22:44:17 -05:00
AJ Keller	0dd0eceb46	Add: max channel support for simulator	2017-01-03 22:44:16 -05:00
AJ Keller	70a6165366	Merge pull request #135 from OpenBCI/development Development	2017-01-02 12:22:49 -05:00
AJ Keller	2d7547ce79	Merge pull request #134 from aj-ptw/16-chan-bug Addresses #131 - 16 channels not always working	2017-01-02 11:59:03 -05:00
AJ Keller	de381a80de	Addresses #131 - 16 channels not always working	2016-12-28 16:43:43 -05:00
AJ Keller	888be5d60f	Merge pull request #132 from aj-ptw/add-exp-python Remove simulator line from python example	2016-12-05 10:29:56 -05:00
AJ Keller	57e6d9f7c2	Remove simulator line from python example	2016-12-05 10:26:39 -05:00
AJ Keller	fb3d722fc8	Update package.json	2016-12-02 02:34:29 -05:00
AJ Keller	2728617126	Update readme.md	2016-12-02 02:34:09 -05:00
AJ Keller	dd7639829a	Update readme.md	2016-12-02 02:33:27 -05:00
AJ Keller	b11775ecde	Update README.md	2016-12-02 02:16:56 -05:00
AJ Keller	f96cdd94ec	Merge pull request #130 from aj-ptw/add-exp-python Add exp python	2016-12-02 02:14:51 -05:00
AJ Keller	4ce630dc4c	Add: Python example	2016-12-02 02:14:08 -05:00
AJ Keller	8557444c55	1.4.2	2016-12-02 00:25:07 -05:00
AJ Keller	c2c75fe9d8	Merge pull request #129 from aj-ptw/add-exp-debug Add debug and get streaming examples	2016-12-02 00:23:26 -05:00
AJ Keller	13d4f57003	Add debug and get streaming examples	2016-12-02 00:23:02 -05:00
AJ Keller	b9d0a466f8	Update changelog.md	2016-11-16 01:41:53 -05:00
AJ Keller	4428040a06	Merge pull request #123 from OpenBCI/development 1.4.1	2016-11-16 01:40:52 -05:00
AJ Keller	f7e5c4988e	Merge pull request #124 from baffo32/1.4.0-writes-resolve-promises Write Promises Resolve When Write Completes	2016-11-09 23:56:24 -05:00
Karl Semich	d4799dd45a	Improve coverage	2016-11-09 19:54:09 +00:00
AJ Keller	212db205f2	Merge pull request #125 from baffo32/no-parallel-sntp Refrain from testing sntp in parallel	2016-11-09 14:29:03 -05:00
Karl Semich	47b2df5802	openBCIBoard.js: make use of write promises	2016-11-09 18:59:34 +00:00
Karl Semich	d06b6101e3	Resolve write promises when writes complete. Fixes #91	2016-11-09 18:58:17 +00:00
Karl Semich	eb0510be6f	Refrain from testing sntp in parallel	2016-11-09 18:48:37 +00:00
AJ Keller	c696d4f5ca	Update changelog.md	2016-11-08 02:37:17 -05:00
AJ Keller	677517715a	Merge pull request #122 from khwilson/fix-typos-in-readme Some fixes to typos in the README	2016-11-08 02:35:33 -05:00
AJ Keller	600b1b2b28	Merge pull request #121 from khwilson/fix-channelSet-so-promise-only-resolves-one-value Bugfix: channelSet always fails due to bad resolve()	2016-11-07 16:38:00 -05:00
Kevin Wilson	32d011d1f9	Bugfix: channelSet always fails due to bad resolve() The `resolve` function of a Promise takes exactly one argument. All further arguments are ignored. Thus, the newChannelSettingsObject that was being returned by the channelSet Promise was ignored and the corresponding value in openBCIBoard was always undefined. Thus, any calls to channel set would actually break the openBCISample code as the channelSettingsArray contained an `undefined`. This fixes the bug.	2016-11-07 15:44:30 -05:00
Kevin Wilson	ee6c50294c	Some fixes to typos in the README Contributing should be off of the `development` branch, `SNTP` misspelled, and a broken link to the `Testing` section.	2016-11-07 15:44:08 -05:00
AJ Keller	34be4c9fe3	Update changelog.md	2016-11-02 21:53:37 -04:00
AJ Keller	57dc399742	Merge pull request #118 from baffo32/1.4.0-bugtests Fragmented and Buffered Samples (#115)	2016-11-02 21:41:44 -04:00
Karl Semich	5d989f6ea4	lint fixes	2016-11-03 00:29:32 +00:00
AJ Keller	2eebde6053	Add strip to EOT function and tests.	2016-11-03 00:29:32 +00:00
AJ Keller	f7f8517c28	Update verison number to 1.4.1	2016-11-01 15:43:23 -04:00
AJ Keller	d4f62ef382	Merge pull request #96 from OpenBCI/1.4.0 1.4.0	2016-10-31 19:49:39 -04:00
AJ Keller	c4e29bbaa7	Merge pull request #117 from aj-ptw/fix-promise-data-processing Fix promise data processing	2016-10-31 19:25:15 -04:00
AJ Keller	f553cdea35	Fix: Remove promise functions from all internal data processing events.	2016-10-31 19:14:24 -04:00
AJ Keller	25c7871fec	Merge pull request #111 from baffo32/1.4.x-socket-close-resources Fix connection-related leaks and inconsistencies	2016-10-30 21:58:45 -04:00
Karl Semich	c2097670e7	Use bluebird to detect runaway promises and timing events. Plug most runaway tasks, and some other issues, raised by the new infrastructure.	2016-10-31 00:35:59 +00:00
Karl Semich	cfb8071a9d	Improvements for SNTP robustness and occasional test failures Also added an unrelated test to improve coverage	2016-10-31 00:26:10 +00:00
Karl Semich	22aca53dac	New API functions: `.isConnected()` `.isStreaming()` All checks for connection state are normalized to use it. The name `.connected()` may have been more consistent with the rest of the library, but it would incorrectly evaluate to true in code that used the old, undocumented `.connected` field, generating hard-to-find bugs. So `isConnected()` was chosen to avoid that situation.	2016-10-31 00:04:36 +00:00
Karl Semich	9467d8a052	Add unified `_disconnected()` function to handle serial cleanup also mark _reset function which sounds important but does nothing	2016-10-31 00:01:26 +00:00
Karl Semich	b6ef09c220	Add tests verifying connection/disconnection state	2016-10-30 23:59:49 +00:00
AJ Keller	238d4cc119	contributing update (#110 ) * Update README.md	2016-10-22 22:20:14 -04:00
AJ Keller	c59cd18cf4	Merge pull request #107 from baffo32/1.4.x-debugging-packet-dump Added a debug option to dump serial traffic	2016-10-21 10:15:32 -04:00
Karl Semich	69cd84f446	Merge branch '1.4.0' into 1.4.x-debugging-packet-dump	2016-10-21 09:32:44 +00:00
AJ Keller	9a17e41c0b	Merge pull request #108 from baffo32/1.4.x-throw-invalid-options Throw an error if invalid options are passed	2016-10-21 00:56:20 -04:00
Karl Semich	edff39504c	Use backticks in changelog from other pull review	2016-10-21 04:00:42 +00:00
Karl Semich	2d1285a887	Merge branch '1.4.0' into 1.4.x-throw-invalid-options	2016-10-21 03:42:02 +00:00
Karl Semich	2100aaee5c	Changelog updates per PR review	2016-10-21 03:41:00 +00:00
Karl Semich	eba46f8e6c	debugBytes fixups, pull review	2016-10-21 03:35:09 +00:00
AJ Keller	de57563f51	Merge pull request #109 from baffo32/1.4.x-double-connection	2016-10-20 13:32:42 -04:00
Karl Semich	f59b41109d	Connection fails if already connected (fixes #93 ) Resources were not being cleaned up previously. Although failing is somewhat harsh, this fix makes possible errors more visible.	2016-10-20 13:10:05 +00:00
Karl Semich	0193031d20	Add tests for debug option	2016-10-20 12:20:40 +00:00
Karl Semich	2904830309	Throw an error if invalid options are passed	2016-10-20 11:49:07 +00:00
Karl Semich	08ce44d4e9	Added a debug option to dump serial traffic	2016-10-20 11:20:12 +00:00
AJ Keller	62a69e01cc	Merge pull request #104 from baffo32/1.4.0-use-fragmentation-simulation use fragmentation simulation	2016-10-20 00:35:57 -04:00
AJ Keller	e9e6dbd624	Merge pull request #105 from baffo32/1.4.0-options-algorithm Automate the interpretation of options and defaults	2016-10-19 21:53:20 -04:00
AJ Keller	1ade656876	Merge pull request #106 from baffo32/1.4.0-firmware-typo Stop outputting v2.0.0 after reset for v1 firmware	2016-10-19 21:52:37 -04:00
Karl Semich	83d32bc9b9	Stop outputting v2.0.0 after reset for v1 firmware	2016-10-20 00:26:51 +00:00
Karl Semich	4b5e4ab0a6	Automate the interpretation of options and defaults.	2016-10-19 23:41:36 +00:00
Karl Semich	2cc0d42fdf	Enable fragmentation for some tests to ensure code withstands it	2016-10-19 23:08:17 +00:00
Karl Semich	94e0a13d71	Fix off-by-one max simulated radio channel	2016-10-19 23:08:17 +00:00
AJ Keller	6b11910fa7	Merge pull request #101 from baffo32/1.4.0-simulate-fragmentation	2016-10-19 18:26:12 -04:00
Karl Semich	83ac939d4e	Updated incorrect default	2016-10-19 21:15:46 +00:00
Karl Semich	38687d42bb	Add test to cover random fragmentation	2016-10-19 21:11:41 +00:00
Karl Semich	1a43a06786	Per PR review, change default fragmentation to 'none'. Also removed associated test changes, and added some missing tests.	2016-10-19 20:43:25 +00:00
Karl Semich	47c6918194	Frag test adjustment: notice time sync replies even in byte 0 of a buffer	2016-10-19 20:39:54 +00:00
Karl Semich	c351f3afd1	Add test: options propagate from public api to simulator Revealed associated bugs which I fixed	2016-10-19 15:17:05 +00:00
Karl Semich	e65707cb31	Merge branch '1.4.0' into 1.4.0-simulate-fragmentation	2016-10-19 14:20:43 +00:00
Karl Semich	97e44171b8	Some tests for simulating fragmentation. Also fixed a few miscontructed buffer calls I ran into.	2016-10-19 13:40:05 +00:00
Karl Semich	0f7bb33434	Frag test adjustment: allow multiple matches for overbuffered data	2016-10-19 11:22:03 +00:00
Karl Semich	884f2f14ee	Frag test adjustment: preserve buffer when parsing reset - fixes bug with fragmented eot after reset which would result in a freeze - removed daisy board specification in test; after this bugfix it was actually parsed, and conflicts with next tests, which assume 8 channels	2016-10-19 11:22:02 +00:00
Karl Semich	5fde5b09bf	Frag test adjustment: disable for simulator tests so they pass	2016-10-19 11:21:46 +00:00
Karl Semich	23776e4b9c	Add #98 to changelog	2016-10-19 11:12:09 +00:00
Karl Semich	5b70268390	Add simulation for buffer size and latency time (fixes #63 ) Also minor changes to address comments on PR #100	2016-10-19 10:57:38 +00:00
AJ Keller	37db876f11	Update README.md	2016-10-18 23:15:56 -04:00
Karl Semich	864469d3d8	Simulate packet fragmentation; fixes #100	2016-10-19 01:31:24 +00:00
AJ Keller	7d78748532	Merge pull request #98 from baffo32/1.4.0-auto-find-linux add autoFind patterns for Linux FTDI	2016-10-16 22:59:43 -04:00
Karl Semich	d6fbce3e4c	add autoFind patterns for Linux FTDI	2016-10-17 01:05:47 +00:00
AJ Keller	7ecff0a08d	Rebased off 1.3.3	2016-10-16 16:47:04 -04:00
AJ Keller	ab891d7565	saving	2016-10-16 16:40:06 -04:00
AJ Keller	3e99a77e88	ENH semistandard lint	2016-10-16 16:40:06 -04:00
AJ Keller	e3061c03ce	Fix log statements	2016-10-16 16:06:03 -04:00
AJ Keller	d6335257e1	Merge pull request #94 from aj-ptw/minor-patches Fix leaked event emitter with time sync, remove extra log statement	2016-10-16 15:02:50 -04:00
AJ Keller	aea599a7dd	Add 4.3-4.6 and 6.4-6.8 to travis.yaml	2016-10-16 14:53:32 -04:00
AJ Keller	031861d2ed	Fix leaked event emitter with time sync, remove extra log statement	2016-10-16 14:47:07 -04:00
AJ Keller	6fd9ddf01b	Merge pull request #86 from aj-ptw/time-sync-example Add example for time syncing	2016-09-29 16:15:06 -04:00
AJ Keller	fe2abac07b	Add example for time syncing	2016-09-29 16:10:16 -04:00
AJ Keller	2528d56ac9	Update package.json	2016-09-29 14:55:25 -04:00
				`@@ -0,0 +1 @@`
				`{"extends": ["standard"], "parser": "babel-eslint"}`