Merge pull request #94 from aj-ptw/minor-patches

Fix leaked event emitter with time sync, remove extra log statement
Add 4.3-4.6 and 6.4-6.8 to travis.yaml
2016-10-16 15:02:50 -04:00 · 2016-10-16 14:53:32 -04:00 · 2016-10-16 14:47:07 -04:00 · 2016-09-29 16:15:06 -04:00 · 2016-09-29 16:10:16 -04:00 · 2016-09-29 14:55:25 -04:00
@@ -33,10 +33,10 @@ public

 # Test output files
 myOutput.txt
+hardwareVoltageOutputAll.txt

 # Local npm builds for testing end in .tgz
 *.tgz

 # For git
 *.orig
-
@@ -1,7 +1,22 @@
 language: node_js
 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:
@@ -1,3 +1,147 @@
+# 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
+
+* Fixed bug where `connected` and `streaming` were not set in constructor
+
+# 1.3.0
+
+### New Features
+
+* Add dropped packet detection, new event `droppedPacket` can be added to get an array of dropped packet numbers in the case of the dropped packet event.
+
+# 1.2.3
+
+### Enhancements
+
+* Add table of contents to read me
+* Reduce size of repo by removing impedance test report
+
+# 1.2.2
+
+### Enhancements
+
+* Upgrade serialport to 4.x
+
+# 1.2.1
+
+### Bug Fixes
+
+* Fixed bug where set channel function allowed for channel 0 to be set. Cannot set system to channel 0; lower limit is 1.
+
+# 1.2.0
+
+### New Features
+
+* Add tutorial/sample code for interfacing the module with lab streaming layer.
+
+### Breaking Changes
+
+* Fixed time synced accel to work OpenBCI_32bit_Library release candidate 5 and newer.
+
+# 1.1.0
+
+### New Features
+
+* Add function `.time()` which should be used in time syncing
+* Add function `.syncClocksFull()` which should be used for immediate consecutive time syncs
+* Synced object can be emitted on `synced` event. Check `valid` property for if the sync was done
+* Add detailed description of object returned on `synced` event to README.md
+
+### Breaking Changes
+
+* Changed option named `timeSync` to `sntpTimeSync`
+* Removed function called `.sntpNow()` because it was replaced by `.time()`
+
+### Bug Fixes
+
+* Time sync working
+* Module could not work with local time
+
+# 1.0.1
+
+### New Features
+
+* Add time sync tutorial in `README.md`
+
+### Bug Fixes
+
+* Fixed bug in simulator that lead to samples being all zeros.
+* Fixed time sync sent confirmation bug that led to bad time values.
+
+# 1.0.0
+
+The second major release for the OpenBCI Node.js SDK brings major changes, improvements and stability, on top of a push to increase automated test coverage.
+
+### New Features
+
+* NPM Module now called `openbci` instead of `openbci-sdk`
+* Firmware version 2.0 support.
+* Clock synchronization between OpenBCI board and this driver
+* `.info` property which contains verified board information parsed from the OpenBCI's `softReset()` response.
+* `eot` event that is emitted when a user sends a command that results in an EOT ("$$$") being sent from the board
+* Daisy (16 channel) support
+* Simulator overhaul, it completely mocks the board. Can now simulate board failure, where the board stops talking to the dongle. Can also mock a serial port failure.
+* `error` and `close` events from serialport now emtted events users can subscribe to.
+
+### Breaking Changes
+
+* NPM package is not called `openbci-sdk` anymore, now called `openbci`
+* Accelerometer data now goes into `.accelData` array instead of `.auxData` array.
+* In openBCISample.js
+  * `parseRawPacket()` is now called `parseRawPacketStandard()`
+* `ready` event only triggered after soft reset. `eot` event emitted in all other conditions resulting in the board sending EOT ("$$$")
+* Must use camel case on the OpenBCISimulator object.
+* Renamed constructor options for readability:
+  * `simulatorAlpha` to `simulatorInjectAlpha`
+  * `simulatorLineNoise` to `simulatorInjectLineNoise`
+* `connect()` no longer rejects on `close` or `error` event from the serialport.
+
+# 0.3.9
+
+### Enhancements
+
+* Add tests for parsing raw packets
+
+### Bug Fixes
+
+* Removed `got here` log from `.streamStart()`
+* Validate stop byte before emitting `rawDataPacket`
+
+# 0.3.8
+
+### Bug Fixes
+* Fixed readme.md
+
+# 0.3.7
+
+### New Features
+
+* Upgrade dependencies
+* Update Travis
+
+### Bug Fixes
+
+* `.numberOfChannels()` now uses the info object, which is set in the constructor and on the return message from `.softReset()`
+* `.sampleRate()` now uses the info object, which is set in the constructor and on the return message from `.softReset()`
+
 # 0.3.6

 ### New Features
@@ -8,8 +152,8 @@

 ### New Features

-* SD card support! Now logging to an SD card is easier than ever. 
- 
+* SD card support! Now logging to an SD card is easier than ever.
+
 ### Bug Fixes

 * Sample rate does not return correct sample rate for custom rate on simulator. #58
@@ -24,7 +168,6 @@

 * [https://github.com/OpenBCI/openbci-js-sdk/issues/44](#44)

-
 # 0.3.3

 ### Bug Fixes
@@ -59,7 +202,7 @@
 * OpenBCI Radio Test File
 * Added Sntp npm module with helper functions
 * Removed stopByte and startByte from sampleObjects
-    
+
 ### Breaking Changes

 * Changed simulator name to `OpenBCISimulator`
@@ -70,15 +213,15 @@

 * NTP Time Synchronization
 * Goertzel algorithm to get voltage for impedance calculation
-    
+
 ### Bug fixes

 * Impedance calculations
 * Readme updates
 * Serial buffer had the chance to become permanently unaligned, optimized and completely transformed and refactored the way bytes are processed.
 * Changes to gain of channels not working correctly.
-* Node 5 compatibility 
-    
+* Node 5 compatibility
+
 ### Github Issues Addressed

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

-
-
    var _options = {
-        samplerate: 250,
-        daisy: false,
-        verbose: false,
+        accel: true,
        alpha: true,
-        lineNoise: '60Hz'
+        boardFailure:false,
+        daisy: false,
+        drift: 0,
+        firmwareVersion: k.OBCIFirmwareV1,
+        lineNoise: '60Hz',
+        sampleRate: 250,
+        serialPortFailure:false,
+        verbose: false
    };

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

        /** Configuring Options */
-        opts.sampleRate = options.sampleRate || options.samplerate || _options.samplerate;
+        if (options.accel === false) {
+            opts.accel = false;
+        } else {
+            opts.accel = _options.accel;
+        }
+        if (options.alpha === false) {
+            opts.alpha = false;
+        } else {
+            opts.alpha = _options.alpha;
+        }
+        opts.boardFailure = options.boardFailure || _options.boardFailure;
        opts.daisy = options.daisy || _options.daisy;
-        opts.lineNoise = options.lineNoise || options.linenoise || _options.lineNoise;
-        opts.alpha = options.alpha || _options.alpha;
+        opts.drift = options.drift || _options.drift;
+        opts.firmwareVersion = options.firmwareVersion || _options.firmwareVersion;
+        opts.lineNoise = options.lineNoise || _options.lineNoise;
+        if (options.sampleRate) {
+            opts.sampleRate = options.sampleRate;
+        } else {
+            opts.sampleRate = k.OBCISampleRate250;
+        }
+        opts.serialPortFailure = options.serialPortFailure || _options.serialPortFailure;
        opts.verbose = options.verbose || _options.verbose;

        this.options = opts;
@@ -46,35 +64,30 @@ function OpenBCISimulatorFactory() {
            startTime: 0
        };
        this.streaming = false;
+        this.synced = false;
+        this.sendSyncSetPacket = false;
        // Buffers
        this.buffer = new Buffer(500);
        // Numbers
+        this.channelNumber = 1;
+        this.hostChannelNumber = this.channelNumber;
+        this.pollTime = 80;
        this.sampleNumber = -1; // So the first sample is 0
        // Objects
+        this.sampleGenerator = openBCISample.randomSample(k.OBCINumberOfChannelsDefault, this.options.sampleRate, this.options.alpha, this.options.lineNoise);
        this.time = {
            current: 0,
            start: now(),
-            loop: null,
-            ntp0: 0,
-            ntp1: 0,
-            ntp2: 0,
-            ntp3: 0
+            loop: null
        };
-        console.log('Simulator started at time: ' + this.time.start);
-        console.log('Time board has been running: ' + (now() - this.time.start));
        // Strings
        this.portName = portName || k.OBCISimulatorPortName;

        // Call 'open'
+        if (this.options.verbose) console.log(`Port name: ${portName}`);
        setTimeout(() => {
-            console.log('Port name: ' + portName);
-            if (portName === k.OBCISimulatorPortName) {
-                this.emit('open');
-                this.connected = true;
-            } else {
-                var err = new Error('Serialport not open.');
-                this.emit('error',err);
-            }
+            this.emit('open');
+            this.connected = true;
        }, 200);

    }
@@ -88,8 +101,10 @@ function OpenBCISimulatorFactory() {
    };

    OpenBCISimulator.prototype.write = function(data,callback) {
-
        switch (data[0]) {
+            case k.OBCIRadioKey:
+                this._processPrivateRadioMessage(data);
+                break;
            case k.OBCIStreamStart:
                if (!this.stream) this._startStream();
                this.streaming = true;
@@ -101,7 +116,7 @@ function OpenBCISimulatorFactory() {
            case k.OBCIMiscSoftReset:
                if (this.stream) clearInterval(this.stream);
                this.streaming = false;
-                this.emit('data', new Buffer('OpenBCI Board Simulator\nPush The World\nFirmware: v2$$$'));
+                this.emit('data', new Buffer(`OpenBCI V3 Simulator\nOn Board ADS1299 Device ID: 0x12345\n${this.options.daisy ? "On Daisy ADS1299 Device ID: 0xFFFFF\n" : ""}LIS3DH Device ID: 0x38422\n${this.options.firmware === k.OBCIFirmwareV2 ? "Firmware: v2.0.0\n" : ""}$$$`));
                break;
            case k.OBCISDLogForHour1:
            case k.OBCISDLogForHour2:
@@ -122,25 +137,26 @@ function OpenBCISimulatorFactory() {
            case k.OBCISDLogStop:
                if (!this.streaming) {
                    if (this.SDLogActive) {
-                        this.emit('data', new Buffer('Total Elapsed Time: ' + (now() - this.sd.startTime) + ' ms\n'));
-                        this.emit('data', new Buffer('Max write time: ' + (Math.random()*500) + ' us\n'));
-                        this.emit('data', new Buffer('Min write time: ' + (Math.random()*200) + ' us\n'));
-                        this.emit('data', new Buffer('Overruns: 0\n$$$'));
+                        this.emit('data', new Buffer(`Total Elapsed Time: ${now() - this.sd.startTime} ms\n`));
+                        this.emit('data', new Buffer(`Max write time: ${Math.random()*500} us\n`));
+                        this.emit('data', new Buffer(`Min write time: ${Math.random()*200} us\n`));
+                        this.emit('data', new Buffer(`Overruns: 0\n`));
+                        this._printEOT();
                    } else {
-                        this.emit('data', new Buffer('No open file to close\n$$$'));
+                        this.emit('data', new Buffer('No open file to close\n'));
+                        this._printEOT();
                    }
                }
                this.SDLogActive = false;
                break;
-            case k.OBCISyncClockStart:
-                setTimeout(() => {
-                    if (this.options.verbose) console.log('Recieved sync command');
-                    this._syncStart();
-                }, 10);
-                break;
-            case k.OBCISyncClockServerData:
-                this.time.ntp3 = this.time.current;
-                this._syncUp(data.slice(1));
+            case k.OBCISyncTimeSet:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    this.synced = true;
+                    setTimeout(() => {
+                        this.emit('data', new Buffer(k.OBCISyncTimeSent));
+                        this._syncUp();
+                    }, 10);
+                }
                break;
            default:
                break;
@@ -154,7 +170,6 @@ function OpenBCISimulatorFactory() {

    OpenBCISimulator.prototype.drain = function(callback) {
        callback();
-        //if (this.options.verbose) console.log('drain');
    };

    OpenBCISimulator.prototype.close = function(callback) {
@@ -162,7 +177,6 @@ function OpenBCISimulatorFactory() {
            this.emit('close');
        }
        this.connected = false;
-        //if (this.options.verbose) console.log('close');
        callback();
    };

@@ -171,10 +185,31 @@ function OpenBCISimulatorFactory() {

        if (intervalInMS < 2) intervalInMS = 2;

-        var generateSample = openBCISample.randomSample(k.OBCINumberOfChannelsDefault, k.OBCISampleRate250, this.options.alpha, this.options.lineNoise);
-
        var getNewPacket = sampNumber => {
-            return openBCISample.convertSampleToPacket(generateSample(sampNumber));
+            if (this.options.accel) {
+                if (this.synced) {
+                    if (this.sendSyncSetPacket) {
+                        this.sendSyncSetPacket = false;
+                        return openBCISample.convertSampleToPacketAccelTimeSyncSet(this.sampleGenerator(sampNumber),now().toFixed(0));
+                    } else {
+                        return openBCISample.convertSampleToPacketAccelTimeSynced(this.sampleGenerator(sampNumber),now().toFixed(0));
+                    }
+                } else {
+                    return openBCISample.convertSampleToPacketStandard(this.sampleGenerator(sampNumber));
+                }
+            } else {
+                if (this.synced) {
+                    if (this.sendSyncSetPacket) {
+                        this.sendSyncSetPacket = false;
+                        return openBCISample.convertSampleToPacketRawAuxTimeSyncSet(this.sampleGenerator(sampNumber),now().toFixed(0),new Buffer([0,0,0,0,0,0]));
+                    } else {
+                        return openBCISample.convertSampleToPacketRawAuxTimeSynced(this.sampleGenerator(sampNumber),now().toFixed(0),new Buffer([0,0,0,0,0,0]));
+                    }
+                } else {
+                    return openBCISample.convertSampleToPacketRawAux(this.sampleGenerator(sampNumber),new Buffer([0,0,0,0,0,0]));
+                }
+
+            }
        };

        this.stream = setInterval(() => {
@@ -183,40 +218,145 @@ function OpenBCISimulatorFactory() {
        }, intervalInMS);
    };

-    OpenBCISimulator.prototype._syncStart = function() {
-
-        this.time.ntp0 = now();
-        var buffer = new Buffer('$a$' + this.time.ntp0);
-        this.emit('data',buffer);
+    OpenBCISimulator.prototype._syncUp = function() {
+        setTimeout(() => {
+            this.sendSyncSetPacket = true;
+        }, 12); // 3 packets later
    };

-    OpenBCISimulator.prototype._syncUp = function(data) {
-        // get the first number
-        console.log(data.length);
-        var halfwayPoint = (data.length / 2);
-        this.time.ntp1 = parseFloat(data.slice(0,halfwayPoint-1));
-        this.time.ntp2 = parseFloat(data.slice(halfwayPoint));
-        console.log('ntp1: ' + this.time.ntp1 + ' ntp2: ' + this.time.ntp2);
+    OpenBCISimulator.prototype._printEOT = function () {
+        this.emit('data', new Buffer("$$$"));
+    };

-        var timeSpentOnNetwork = this.time.ntp3 - this.time.ntp0 - (this.time.ntp2 - this.time.ntp1);
+    OpenBCISimulator.prototype._printFailure = function () {
+        this.emit('data', new Buffer("Failure: "));
+    };

-        var transferTime = timeSpentOnNetwork / 2;
+    OpenBCISimulator.prototype._printSuccess = function () {
+        this.emit('data', new Buffer("Success: "));
+    };

-        var trueTime = this.time.ntp2 + transferTime;
-
-        var delta = trueTime - this.time.ntp3;
-        console.log('Delta: ' + delta);
-
-        this.time.start += delta;
-
-
-
-        this.emit('data','Synced!' + '$$$');
+    OpenBCISimulator.prototype._printValidatedCommsTimeout = function () {
+        this._printFailure();
+        this.emit('data', new Buffer("Communications timeout - Device failed to poll Host"));
+        this._printEOT();
+    };

+    OpenBCISimulator.prototype._processPrivateRadioMessage = function(dataBuffer) {
+        switch (dataBuffer[1]) {
+            case k.OBCIRadioCmdChannelGet:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    if (!this.options.boardFailure) {
+                        this._printSuccess();
+                        this.emit('data', new Buffer(`Host and Device on Channel Number ${this.channelNumber}`));
+                        this.emit('data', new Buffer([this.channelNumber]));
+                        this._printEOT();
+                    } else if (!this.serialPortFailure) {
+                        this._printFailure();
+                        this.emit('data', new Buffer(`Host on Channel Number ${this.channelNumber}`));
+                        this.emit('data', new Buffer([this.channelNumber]));
+                        this._printEOT();
+                    }
+                }
+                break;
+            case k.OBCIRadioCmdChannelSet:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    if (!this.options.boardFailure) {
+                        if (dataBuffer[2] < k.OBCIRadioChannelMax) {
+                            this.channelNumber = dataBuffer[2];
+                            this.hostChannelNumber = this.channelNumber;
+                            this._printSuccess();
+                            this.emit('data', new Buffer(`Channel Number ${this.channelNumber}`));
+                            this.emit('data', new Buffer([this.channelNumber]));
+                            this._printEOT();
+                        } else {
+                            this._printFailure();
+                            this.emit('data', new Buffer("Verify channel number is less than 25"));
+                            this._printEOT();
+                        }
+                    } else if (!this.serialPortFailure) {
+                       this._printValidatedCommsTimeout();
+                    }
+                }
+                break;
+            case k.OBCIRadioCmdChannelSetOverride:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    if (dataBuffer[2] < k.OBCIRadioChannelMax) {
+                        if (dataBuffer[2] === this.channelNumber) {
+                            this.options.boardFailure = false;
+                        } else {
+                            this.options.boardFailure = true;
+                        }
+                        this.hostChannelNumber = dataBuffer[2];
+                        this._printSuccess();
+                        this.emit('data', new Buffer(`Host override - Channel Number ${this.hostChannelNumber}`));
+                        this.emit('data', new Buffer([this.hostChannelNumber]));
+                        this._printEOT();
+                    } else {
+                        this._printFailure();
+                        this.emit('data', new Buffer("Verify channel number is less than 25"));
+                        this._printEOT();
+                    }
+                }
+                break;
+            case k.OBCIRadioCmdPollTimeGet:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    if (!this.options.boardFailure) {
+                        this._printSuccess();
+                        this.emit('data', new Buffer(`Poll Time ${this.pollTime}`));
+                        this.emit('data', new Buffer([this.pollTime]));
+                        this._printEOT();
+                    } else {
+                        this._printValidatedCommsTimeout();
+                    }
+                }
+                break;
+            case k.OBCIRadioCmdPollTimeSet:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    if (!this.options.boardFailure) {
+                        this.pollTime = dataBuffer[2];
+                        this._printSuccess();
+                        this.emit('data', new Buffer(`Poll Time ${this.pollTime}`));
+                        this.emit('data', new Buffer([this.pollTime]));
+                        this._printEOT();
+                    } else {
+                        this._printValidatedCommsTimeout();
+                    }
+                }
+                break;
+            case k.OBCIRadioCmdBaudRateSetDefault:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    this._printSuccess();
+                    this.emit('data', new Buffer("Switch your baud rate to 115200"));
+                    this.emit('data', new Buffer([0x24,0x24,0x24,0xFF])); // The board really does this
+                }
+                break;
+            case k.OBCIRadioCmdBaudRateSetFast:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    this._printSuccess();
+                    this.emit('data', new Buffer("Switch your baud rate to 230400"));
+                    this.emit('data', new Buffer([0x24,0x24,0x24,0xFF])); // The board really does this
+                }
+                break;
+            case k.OBCIRadioCmdSystemStatus:
+                if (this.options.firmwareVersion === k.OBCIFirmwareV2) {
+                    if (!this.options.boardFailure) {
+                        this._printSuccess();
+                        this.emit('data', new Buffer("System is Up"));
+                        this._printEOT();
+                    } else {
+                        this._printFailure();
+                        this.emit('data', new Buffer("System is Down"));
+                        this._printEOT();
+                    }
+                }
+                break;
+            default:
+                break;
+        }
    };

    factory.OpenBCISimulator = OpenBCISimulator;
-
 }

 util.inherits(OpenBCISimulatorFactory, EventEmitter);
@@ -1,6 +1,6 @@
 {
-  "name": "openbci-sdk",
-  "version": "0.3.6",
+  "name": "openbci",
+  "version": "1.3.3",
  "description": "The official Node.js SDK for the OpenBCI Biosensor Board.",
  "main": "openBCIBoard",
  "scripts": {
@@ -15,11 +15,13 @@
  "author": "AJ Keller <aj@pushtheworld.us> (www.openbci.com)",
  "license": "MIT",
  "dependencies": {
+    "buffer-equal": "^1.0.0",
    "gaussian": "^1.0.0",
-    "istanbul": "^0.4.2",
+    "mathjs": "^3.3.0",
    "performance-now": "^0.2.0",
-    "serialport": "~2.1.0",
-    "sntp": "^2.0.0"
+    "serialport": "4.0.1",
+    "sntp": "^2.0.0",
+    "streamsearch": "^0.1.2"
  },
  "directories": {
    "test": "test"
@@ -28,19 +30,20 @@
    "chai": "^3.4.1",
    "chai-as-promised": "^5.2.0",
    "codecov": "^1.0.1",
-    "mocha": "^2.3.4",
+    "istanbul": "^0.4.4",
+    "mocha": "^3.0.2",
    "sandboxed-module": "^2.0.3",
    "sinon": "^1.17.2",
    "sinon-chai": "^2.8.0"
  },
  "repository": {
    "type": "git",
-    "url": "git+https://github.com/openbci/openbci-js-sdk.git"
+    "url": "git+https://github.com/openbci/openbci_nodejs.git"
  },
  "bugs": {
-    "url": "https://github.com/openbci/openbci-js-sdk/issues"
+    "url": "https://github.com/openbci/openbci_nodejs/issues"
  },
-  "homepage": "https://github.com/openbci/openbci-js-sdk#readme",
+  "homepage": "https://github.com/openbci/openbci_nodejs#readme",
  "engines": {
    "node": ">=4.0.0"
  }
@@ -291,6 +291,20 @@ describe('OpenBCIConstants', function() {
            assert.equal('1', k.OBCIChannelImpedanceTestSignalApplied);
        });
    });
+    describe('Time Sync Stuff',function() {
+        it('Can get proper array size',function() {
+            assert.equal(10, k.OBCITimeSyncArraySize);
+        });
+        it('Get correct time sync with conf',function() {
+            assert.equal(0.9, k.OBCITimeSyncMultiplierWithSyncConf);
+        });
+        it('Get correct time sync without conf',function() {
+            assert.equal(0.75, k.OBCITimeSyncMultiplierWithoutSyncConf);
+        });
+        it('Get correct time sync transmission threshold',function() {
+            assert.equal(10, k.OBCITimeSyncThresholdTransFailureMS);
+        });
+    });
    describe('SD card Commands',function() {
        it('logs for 1 hour', function() {
            assert.equal('G', k.OBCISDLogForHour1);
@@ -435,6 +449,45 @@ describe('OpenBCIConstants', function() {
            assert.equal('f', k.OBCIFilterEnable);
        });
    });
+    describe('Stream packet types/codes',function() {
+        it('Standard with Accel',function () {
+            assert.equal(0, k.OBCIStreamPacketStandardAccel);
+        });
+        it('Standard with Raw Aux',function () {
+            assert.equal(1, k.OBCIStreamPacketStandardRawAux);
+        });
+        it('User Defined Packet',function () {
+            assert.equal(2, k.OBCIStreamPacketUserDefinedType);
+        });
+        it('Time Sync Set with accel',function () {
+            assert.equal(3, k.OBCIStreamPacketAccelTimeSyncSet);
+        });
+        it('Time Synced with Accel',function () {
+            assert.equal(4, k.OBCIStreamPacketAccelTimeSynced);
+        });
+        it('Time Sync set with Raw Aux',function () {
+            assert.equal(5, k.OBCIStreamPacketRawAuxTimeSyncSet);
+        });
+        it('Time Synced with Raw Aux',function () {
+            assert.equal(6, k.OBCIStreamPacketRawAuxTimeSynced);
+        });
+    });
+    describe('Time synced with accel packet',function() {
+        it('X axis',function () {
+            assert.equal(7, k.OBCIAccelAxisX);
+        });
+        it('Y axis',function () {
+            assert.equal(8, k.OBCIAccelAxisY);
+        });
+        it('Z axis',function () {
+            assert.equal(9, k.OBCIAccelAxisZ);
+        });
+    });
+    describe('Time sync useful numbers',function() {
+        it('Time from the board is 4 bytes',function () {
+            assert.equal(4, k.OBCIStreamPacketTimeByteSize);
+        });
+    });
    describe('should return the right command for each channel', function(){
        it('Channel 1', function() {
            var expectation = '1';
@@ -614,78 +667,78 @@ describe('OpenBCIConstants', function() {
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 2', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = '@';
+            var result = k.commandChannelOn(2);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 3', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = '#';
+            var result = k.commandChannelOn(3);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 4', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = '$';
+            var result = k.commandChannelOn(4);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 5', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = '%';
+            var result = k.commandChannelOn(5);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 6', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = '^';
+            var result = k.commandChannelOn(6);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 7', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = '&';
+            var result = k.commandChannelOn(7);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 8', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = '*';
+            var result = k.commandChannelOn(8);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 9', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'Q';
+            var result = k.commandChannelOn(9);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 10', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'W';
+            var result = k.commandChannelOn(10);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 11', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'E';
+            var result = k.commandChannelOn(11);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 12', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'R';
+            var result = k.commandChannelOn(12);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 13', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'T';
+            var result = k.commandChannelOn(13);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 14', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'Y';
+            var result = k.commandChannelOn(14);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 15', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'U';
+            var result = k.commandChannelOn(15);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Channel 16', function() {
-            var expectation = '!';
-            var result = k.commandChannelOn(1);
+            var expectation = 'I';
+            var result = k.commandChannelOn(16);
            return expect(result).to.eventually.equal(expectation);
        });
        it('Invalid channel request', function() {
@@ -712,6 +765,25 @@ describe('OpenBCIConstants', function() {
            assert.equal(250, k.OBCISampleRate250);
        });
    });
+    describe('Max sample number',function() {
+        it('should be 255',function () {
+            assert.equal(255, k.OBCISampleNumberMax);
+        });
+    });
+    describe("Radio Channel Limits", function() {
+        it("should get the right channel number max",function () {
+            expect(k.OBCIRadioChannelMax).to.be.equal(25);
+        });
+        it("should get the right channel number min",function () {
+            expect(k.OBCIRadioChannelMin).to.be.equal(1);
+        });
+        it("should get the right poll time max",function () {
+            expect(k.OBCIRadioPollTimeMax).to.be.equal(255);
+        });
+        it("should get the right poll time min",function () {
+            expect(k.OBCIRadioPollTimeMin).to.be.equal(0);
+        });
+    });
    describe('#getChannelSetter', function() {
        //'channel 1, power on, gain 24, inputType normal, bias include, srb2 connect, srb1 dissconnect'
        describe('channel input selection works', function() {
@@ -1013,6 +1085,14 @@ describe('OpenBCIConstants', function() {
            return expect(result).to.eventually.equal(expectation);
        });
    });
+    describe('#getVersionNumber', function() {
+        it('should get the major version number from a github standard version string',() => {
+            var expectedVersion = 6;
+            var inputStringVersion = 'v6.0.0';
+
+            expect(k.getVersionNumber(inputStringVersion)).to.equal(expectedVersion);
+        });
+    });
    describe('#getImpedanceSetter', function() {
        describe('channel input selection works', function () {
            it('channel 2', function (done) {
@@ -1116,4 +1196,4 @@ describe('OpenBCIConstants', function() {
            });
        });
    });
-});
+});
@@ -0,0 +1,622 @@
+var sinon = require('sinon');
+var chai = require('chai'),
+    should = chai.should(),
+    expect = chai.expect,
+    openBCIBoard = require('../openBCIBoard'),
+    openBCISample = openBCIBoard.OpenBCISample,
+    k = openBCISample.k;
+
+var chaiAsPromised = require("chai-as-promised");
+var sinonChai = require("sinon-chai");
+chai.use(chaiAsPromised);
+chai.use(sinonChai);
+var bufferEqual = require('buffer-equal');
+var fs = require('fs');
+//var wstream = fs.createWriteStream('myOutput.txt');
+
+
+describe('#impedanceTesting', function() {
+    var ourBoard;
+    this.timeout(20000);
+
+    before(function(done) {
+        ourBoard = new openBCIBoard.OpenBCIBoard({
+            verbose: true
+        });
+        var useSim = () => {
+            ourBoard.simulatorEnable().then(() => {
+                return ourBoard.connect(k.OBCISimulatorPortName);
+            });
+        };
+        ourBoard.autoFindOpenBCIBoard()
+            .then(portName => {
+                return ourBoard.connect(portName);
+            })
+            .catch((err) => {
+                useSim();
+            })
+            .then(() => {
+                console.log('connected');
+            })
+            .catch(err => {
+                console.log('Error: '+ err);
+            });
+
+
+        ourBoard.once('ready',() => {
+            ourBoard.streamStart()
+                .then(() => {
+                    setTimeout(() => {
+                        done();
+                    }, 100); // give some time for the stream command to be sent
+                })
+                .catch(err => {
+                    console.log(err);
+                    done(err);
+                });
+        });
+
+
+    });
+    after(done => {
+        if(ourBoard["connected"]) {
+            ourBoard.disconnect()
+                .then(() => {
+                    done();
+                })
+                .catch(err => {
+                    done(err);
+                })
+        }
+    });
+
+    describe('#impedanceTestAllChannels', function () {
+        var impedanceArray = [];
+
+        before(function(done) {
+            ourBoard.once('impedanceArray', arr => {
+                impedanceArray = arr;
+                console.log(impedanceArray);
+                done();
+            });
+            ourBoard.impedanceTestAllChannels();
+        });
+        describe('#channel1',function() {
+            it('has valid channel number', function() {
+                impedanceArray[0].channel.should.be.equal(1);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[0].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[0].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[0].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[0].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel2',function() {
+            it('has valid channel number', function() {
+                impedanceArray[1].channel.should.be.equal(2);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[1].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[1].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[1].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[1].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel3',function() {
+            it('has valid channel number', function() {
+                impedanceArray[2].channel.should.be.equal(3);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[2].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[2].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[2].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[2].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel4',function() {
+            it('has valid channel number', function() {
+                impedanceArray[3].channel.should.be.equal(4);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[3].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[3].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[3].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[3].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel5',function() {
+            it('has valid channel number', function() {
+                impedanceArray[4].channel.should.be.equal(5);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[4].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[4].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[4].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[4].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel6',function() {
+            it('has valid channel number', function() {
+                impedanceArray[5].channel.should.be.equal(6);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[5].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[5].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[5].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[5].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel7',function() {
+            it('has valid channel number', function() {
+                impedanceArray[6].channel.should.be.equal(7);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[6].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[6].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[6].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[6].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel8',function() {
+            it('has valid channel number', function () {
+                impedanceArray[7].channel.should.be.equal(8);
+            });
+            describe('#inputP', function () {
+                it('got raw impedance value', function () {
+                    impedanceArray[7].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function () {
+                    impedanceArray[7].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function () {
+                it('got raw impedance value', function () {
+                    impedanceArray[7].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function () {
+                    impedanceArray[7].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+    });
+    describe('#impedanceTestChannelsRejects', function() {
+        it('rejects when it does not get an array', function(done) {
+            ourBoard.impedanceTestChannels('taco').should.be.rejected.and.notify(done);
+        });
+
+        it('rejects when it array length does not match number of channels', function(done) {
+            ourBoard.impedanceTestChannels(['-','N','n','p','P','p','b']).should.be.rejected.and.notify(done);
+        });
+
+    });
+    describe('#impedanceTestChannels', function () {
+        var impedanceArray = [];
+
+        before(function(done) {
+            ourBoard.once('impedanceArray', arr => {
+                impedanceArray = arr;
+                done();
+            });
+            ourBoard.impedanceArray[0] = openBCISample.impedanceObject(1);
+            ourBoard.impedanceTestChannels(['-','N','n','p','P','p','b','B']).catch(err => done(err));
+        });
+        describe('#channel1',function() {
+            it('has valid channel number', function() {
+                impedanceArray[0].channel.should.be.equal(1);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[0].P.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[0].P.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[0].N.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[0].N.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel2',function() {
+            it('has valid channel number', function() {
+                impedanceArray[1].channel.should.be.equal(2);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[1].P.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[1].P.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[1].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[1].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel3',function() {
+            it('has valid channel number', function() {
+                impedanceArray[2].channel.should.be.equal(3);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[2].P.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[2].P.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[2].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[2].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel4',function() {
+            it('has valid channel number', function() {
+                impedanceArray[3].channel.should.be.equal(4);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[3].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[3].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[3].N.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[3].N.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel5',function() {
+            it('has valid channel number', function() {
+                impedanceArray[4].channel.should.be.equal(5);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[4].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[4].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[4].N.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[4].N.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel6',function() {
+            it('has valid channel number', function() {
+                impedanceArray[5].channel.should.be.equal(6);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[5].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[5].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[5].N.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[5].N.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel7',function() {
+            it('has valid channel number', function() {
+                impedanceArray[6].channel.should.be.equal(7);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[6].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[6].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceArray[6].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceArray[6].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+        describe('#channel8',function() {
+            it('has valid channel number', function () {
+                impedanceArray[7].channel.should.be.equal(8);
+            });
+            describe('#inputP', function () {
+                it('got raw impedance value', function () {
+                    impedanceArray[7].P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function () {
+                    impedanceArray[7].P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function () {
+                it('got raw impedance value', function () {
+                    impedanceArray[7].N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function () {
+                    impedanceArray[7].N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+    });
+    describe('#impedanceTestChannel', function () {
+        var impedanceObject = {};
+
+        before(function(done) {
+            ourBoard.impedanceTestChannel(1)
+                .then(impdObj => {
+                    impedanceObject = impdObj;
+                    done();
+                })
+                .catch(err => done(err));
+        });
+        describe('#channel1',function() {
+            it('has valid channel number', function() {
+                impedanceObject.channel.should.be.equal(1);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceObject.P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceObject.P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceObject.N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceObject.N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+    });
+    describe('#impedanceTestChannelInputP', function () {
+        var impedanceObject = {};
+
+        before(function(done) {
+            ourBoard.impedanceTestChannelInputP(1)
+                .then(impdObj => {
+                    impedanceObject = impdObj;
+                    done();
+                })
+                .catch(err => done(err));
+        });
+        describe('#channel1',function() {
+            it('has valid channel number', function() {
+                impedanceObject.channel.should.be.equal(1);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceObject.P.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceObject.P.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceObject.N.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceObject.N.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+    });
+    describe('#impedanceTestChannelInputN', function () {
+
+        var impedanceObject = {};
+        //wstream = fs.createWriteStream('hardwareVoltageOutputAll.txt');
+
+        before(function(done) {
+
+            console.log('7');
+
+            ourBoard.on('sample',sample => {
+                //console.log('8');
+                //OpenBCISample.debugPrettyPrint(sample);
+                // good to start impedance testing..
+            });
+
+            ourBoard.impedanceTestChannelInputN(1)
+                .then(impdObj => {
+                    impedanceObject = impdObj;
+                    setTimeout(() => {
+                        done();
+                    }, 1000);
+                })
+                .catch(err => done(err));
+        });
+        describe('#channel1',function() {
+            it('has valid channel number', function() {
+                impedanceObject.channel.should.be.equal(1);
+            });
+            describe('#inputP', function() {
+                it('got raw impedance value',function() {
+                    impedanceObject.P.should.have.property('raw').equal(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceObject.P.should.have.property('text').equal(k.OBCIImpedanceTextInit);
+                });
+            });
+            describe('#inputN', function() {
+                it('got raw impedance value',function() {
+                    impedanceObject.N.should.have.property('raw').above(-1);
+                });
+                it('text is not \'init\'', function() {
+                    impedanceObject.N.should.have.property('text').not.be.equal(k.OBCIImpedanceTextInit);
+                });
+            });
+        });
+    });
+    describe('#impedanceTestContinuousStXX', function () {
+
+        var impedanceArray = [];
+
+        before(function(done) {
+            ourBoard.impedanceTestContinuousStart()
+                .then(done).catch(err => done(err));
+
+        });
+
+        after(function(done) {
+            ourBoard.impedanceTestContinuousStop()
+                .then(done);
+        });
+
+        it('prints 10 impedance arrays', function(done) {
+            var count = 1;
+
+            var listener = impedanceArray => {
+                //console.log('\nImpedance Array: ' + count);
+                //console.log(impedanceArray);
+                count++;
+                if (count > 10) {
+                    ourBoard.removeListener('impedanceArray', listener);
+                    done();
+                }
+            };
+            ourBoard.on('impedanceArray', listener);
+
+
+
+
+        });
+    });
+    describe('#_impedanceTestSetChannel', function () {
+        it('reject with invalid channel', function(done) {
+            ourBoard._impedanceTestSetChannel(0,false,false).should.be.rejected.and.notify(done);
+        });
+    });
+    describe('#_impedanceTestCalculateChannel', function () {
+        it('reject with low invalid channel', function(done) {
+            ourBoard._impedanceTestCalculateChannel(0,false,false).should.be.rejected.and.notify(done);
+        });
+        it('reject with high invalid channel', function(done) {
+            ourBoard._impedanceTestCalculateChannel(69,false,false).should.be.rejected.and.notify(done);
+        });
+        it('reject with invalid data type pInput', function(done) {
+            ourBoard._impedanceTestCalculateChannel(1,'taco',false).should.be.rejected.and.notify(done);
+        });
+        it('reject with invalid data type nInput', function(done) {
+            ourBoard._impedanceTestCalculateChannel(1,false,'taco').should.be.rejected.and.notify(done);
+        });
+    });
+    describe('#_impedanceTestFinalizeChannel', function () {
+        it('reject with low invalid channel', function(done) {
+            ourBoard._impedanceTestFinalizeChannel(0,false,false).should.be.rejected.and.notify(done);
+        });
+        it('reject with high invalid channel', function(done) {
+            ourBoard._impedanceTestFinalizeChannel(69,false,false).should.be.rejected.and.notify(done);
+        });
+        it('reject with invalid data type pInput', function(done) {
+            ourBoard._impedanceTestFinalizeChannel(1,'taco',false).should.be.rejected.and.notify(done);
+        });
+        it('reject with invalid data type nInput', function(done) {
+            ourBoard._impedanceTestFinalizeChannel(1,false,'taco').should.be.rejected.and.notify(done);
+        });
+    });
+});
@@ -0,0 +1,710 @@
+var sinon = require('sinon'),
+    chai = require('chai'),
+    should = chai.should(),
+    expect = chai.expect,
+    openBCISimulator = require('../openBCISimulator'),
+    openBCISample = require('../openBCISample'),
+    k = openBCISample.k;
+
+var chaiAsPromised = require("chai-as-promised");
+var sinonChai = require("sinon-chai");
+chai.use(chaiAsPromised);
+chai.use(sinonChai);
+var bufferEqual = require('buffer-equal');
+var fs = require('fs');
+
+describe('openBCISimulator',function() {
+    this.timeout(4000);
+    var portName = k.OBCISimulatorPortName;
+    describe('#constructor', function () {
+        var simulator;
+        afterEach(() => {
+            simulator = null;
+        });
+        after(done => {
+            setTimeout(() => {
+                // Since there is a conditional timeout, it's important to wait to start the next test till this ends for sure
+                done();
+            }, 200); // The same amount of time in the simulator
+        });
+        it('constructs with the correct default options', function() {
+            simulator = new openBCISimulator.OpenBCISimulator();
+            expect(simulator.options.accel).to.be.true;
+            expect(simulator.options.alpha).to.be.true;
+            expect(simulator.options.boardFailure).to.be.false;
+            expect(simulator.options.daisy).to.be.false;
+            expect(simulator.options.drift).to.equal(0);
+            expect(simulator.options.firmwareVersion).to.equal(k.OBCIFirmwareV1);
+            expect(simulator.options.lineNoise).to.equal(k.OBCISimulatorLineNoiseHz60);
+            expect(simulator.options.sampleRate).to.equal(k.OBCISampleRate250);
+            expect(simulator.options.serialPortFailure).to.be.false;
+            expect(simulator.options.verbose).to.be.false;
+        });
+        it('should be able to get into daisy mode',function () {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                daisy: true
+            });
+            expect(simulator.options.daisy).to.be.true;
+        });
+        it('should set the correct sample rate in daisy mode, if no sampleRate is provided',function () {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                daisy: true
+            });
+            expect(simulator.options.sampleRate).to.equal(250); // produce samples at same rate
+        });
+        it('should use provided sample rate even if daisy is true',function () {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                daisy: true,
+                sampleRate: 20
+            });
+            expect(simulator.options.daisy).to.be.true;
+            expect(simulator.options.sampleRate).to.equal(20);
+        });
+        it('should be able to put into firmware version 2', function () {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                firmwareVersion: 'v2'
+            });
+            expect(simulator.options.firmwareVersion).to.equal(k.OBCIFirmwareV2);
+        });
+        it('should be able to simulate board failure',function () {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                boardFailure: true
+            });
+            expect(simulator.options.boardFailure).to.be.true;
+        });
+        it('should be able to simulate serial port failure',function () {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                serialPortFailure: true
+            });
+            expect(simulator.options.serialPortFailure).to.be.true;
+        });
+        it('can turn 50Hz line noise on', function() {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                lineNoise: '50Hz'
+            });
+            (simulator.options.lineNoise).should.equal(k.OBCISimulatorLineNoiseHz50);
+        });
+        it('can turn no line noise on', function() {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                lineNoise: 'None'
+            });
+            (simulator.options.lineNoise).should.equal(k.OBCISimulatorLineNoiseNone);
+        });
+        it('should not inject alpha if desired', function() {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                alpha: false
+            });
+            expect(simulator.options.alpha).to.be.false;
+        });
+        it('should be able to not use the accel', function() {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                accel: false
+            });
+            expect(simulator.options.accel).to.be.false;
+        });
+        it('should be able to set positive drift', function() {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                drift: 1
+            });
+            expect(simulator.options.drift).to.be.greaterThan(0);
+        });
+        it('should be able to set negative drift', function() {
+            simulator = new openBCISimulator.OpenBCISimulator(portName,{
+                drift: -1
+            });
+            expect(simulator.options.drift).to.be.lessThan(0);
+        });
+    });
+    describe("_startStream", function() {
+        it('should return a packet with sample data in it', function(done) {
+            var simulator = new openBCISimulator.OpenBCISimulator(k.OBCISimulatorPortName);
+            var sampleCounter = 0;
+            var sampleTestSize = 5;
+
+            var newDataFunc = data => {
+                if (sampleCounter > sampleTestSize) {
+                    simulator.write(new Buffer([k.OBCIStreamStop]));
+                    simulator.removeListener('data',newDataFunc);
+                    openBCISample.parseRawPacketStandard(data,k.channelSettingsArrayInit(k.OBCINumberOfChannelsDefault),true)
+                        .then(sampleObject => {
+                            sampleObject.channelData.forEach((channelValue, index) => {
+                                expect(channelValue).to.not.equal(0);
+                            });
+                            simulator = null;
+                            done();
+                        });
+                } else {
+                    sampleCounter++;
+                }
+            }
+            simulator.on('data',newDataFunc);
+            simulator._startStream();
+        });
+        it('should return a sync set packet with accel',function(done) {
+            var simulator = new openBCISimulator.OpenBCISimulator(k.OBCISimulatorPortName);
+            var sampleCounter = 0;
+            var sampleTestSize = 5;
+
+            var newDataFunc = data => {
+                if (sampleCounter === 0) {
+                    // Ensure everything is switched on for this test
+                    simulator.options.accel = true;
+                    simulator.synced = true;
+                    simulator.sendSyncSetPacket = true;
+                    expect(data[k.OBCIPacketPositionStopByte]).to.equal(openBCISample.makeTailByteFromPacketType(k.OBCIStreamPacketStandardAccel));
+                } else if (sampleCounter === 1) {
+                    // Now this data should be the time sync up packet
+                    expect(data[k.OBCIPacketPositionStopByte]).to.equal(openBCISample.makeTailByteFromPacketType(k.OBCIStreamPacketAccelTimeSyncSet));
+                    // Expect flag to be down
+                    expect(simulator.sendSyncSetPacket).to.be.false;
+                } else if (sampleCounter >= sampleTestSize) {
+                    simulator.write(new Buffer([k.OBCIStreamStop]));
+                    simulator.removeListener('data',newDataFunc);
+                    simulator = null;
+                    done();
+                } else {
+                    // Now this data should be the time sync up packet
+                    expect(data[k.OBCIPacketPositionStopByte]).to.equal(openBCISample.makeTailByteFromPacketType(k.OBCIStreamPacketAccelTimeSynced));
+                }
+                sampleCounter++;
+            }
+
+            simulator.on('data',newDataFunc);
+            simulator._startStream();
+        });
+        it('should return a sync set packet with raw aux',function(done) {
+            var simulator = new openBCISimulator.OpenBCISimulator(k.OBCISimulatorPortName,{
+                accel: false
+            });
+            var sampleCounter = 0;
+            var sampleTestSize = 5;
+
+            var newDataFunc = data => {
+                if (sampleCounter === 0) {
+                    // Ensure everything is switched on for this test
+                    simulator.synced = true;
+                    simulator.sendSyncSetPacket = true;
+                    expect(data[k.OBCIPacketPositionStopByte]).to.equal(openBCISample.makeTailByteFromPacketType(k.OBCIStreamPacketStandardRawAux));
+                } else if (sampleCounter === 1) {
+                    // Now this data should be the time sync up packet
+                    expect(data[k.OBCIPacketPositionStopByte]).to.equal(openBCISample.makeTailByteFromPacketType(k.OBCIStreamPacketRawAuxTimeSyncSet));
+                    // Expect flag to be down
+                    expect(simulator.sendSyncSetPacket).to.be.false;
+                } else if (sampleCounter >= sampleTestSize) {
+                    simulator.write(new Buffer([k.OBCIStreamStop]));
+                    simulator.removeListener('data',newDataFunc);
+                    simulator = null;
+                    done();
+                } else {
+                    // Now this data should be the time sync up packet
+                    expect(data[k.OBCIPacketPositionStopByte]).to.equal(openBCISample.makeTailByteFromPacketType(k.OBCIStreamPacketRawAuxTimeSynced));
+                }
+                sampleCounter++;
+            }
+
+            simulator.on('data',newDataFunc);
+            simulator._startStream();
+        });
+    });
+    describe("firmwareVersion1",function () {
+
+    });
+    describe("firmwareVersion2",function () {
+        var simulator;
+        beforeEach(() => {
+            simulator = new openBCISimulator.OpenBCISimulator(k.OBCISimulatorPortName,{
+                firmwareVersion: 'v2'
+            });
+        });
+        afterEach(() => {
+            simulator = null;
+        });
+        describe('_processPrivateRadioMessage',function () {
+            describe('OBCIRadioCmdChannelGet',function () {
+                it('should emit success if firmware version 2', done => {
+                    simulator.channelNumber = 0;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            expect(buf[buf.length - 4]).to.equal(0);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelGet]));
+                });
+                it('should emit failure if board failure and host channel number', done => {
+                    // Turn board failure mode
+                    simulator.options.boardFailure = true;
+                    simulator.channelNumber = 9;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.false;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.true;
+                            expect(buf[buf.length - 4]).to.equal(9);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelGet]));
+                });
+            });
+            describe('OBCIRadioCmdChannelSet',function () {
+                it('should set the channel number if in bounds', done => {
+                    var newChanNum = 20;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            expect(buf[buf.length - 4]).to.equal(newChanNum);
+                            expect(simulator.channelNumber).to.equal(newChanNum);
+                            expect(simulator.hostChannelNumber).to.equal(newChanNum);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelSet,newChanNum]));
+                });
+                it('should not set the channel number if out of bounds', done => {
+                    var newChanNum = 26;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.false;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.true;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelSet,newChanNum]));
+                });
+                it('should emit failure if board failure', done => {
+                    // Turn board failure mode
+                    simulator.options.boardFailure = true;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.false;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.true;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelSet,7]));
+                });
+            });
+            describe('OBCIRadioCmdChannelSetOverride',function () {
+                it('should change just the hosts channel number and not the systems channel number and force a board comms failure', done => {
+                    var systemChannelNumber = 0;
+                    var newHostChannelNumber = 1;
+                    simulator.channelNumber = systemChannelNumber;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            expect(buf[buf.length - 4]).to.equal(newHostChannelNumber);
+                            expect(simulator.options.boardFailure).to.be.true;
+                            expect(simulator.channelNumber).to.equal(systemChannelNumber);
+                            expect(simulator.hostChannelNumber).to.equal(newHostChannelNumber);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelSetOverride,newHostChannelNumber]));
+                });
+                it('should change just the hosts channel number and not the systems channel number and fix a board failure', done => {
+                    var systemChannelNumber = 0;
+                    var oldHostChannelNumber = 1;
+                    simulator.channelNumber = systemChannelNumber;
+                    simulator.hostChannelNumber = oldHostChannelNumber;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            expect(buf[buf.length - 4]).to.equal(systemChannelNumber);
+                            expect(simulator.options.boardFailure).to.be.false;
+                            expect(simulator.channelNumber).to.equal(systemChannelNumber);
+                            expect(simulator.hostChannelNumber).to.equal(systemChannelNumber);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelSetOverride,systemChannelNumber]));
+                });
+                it('should not set the channel number if out of bounds', done => {
+                    var newChanNum = 26;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.false;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.true;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdChannelSetOverride,newChanNum]));
+                });
+            });
+            describe('OBCIRadioCmdPollTimeGet',function () {
+                it('should emit success if firmware version 2 with poll time', done => {
+                    var expectedPollTime = 80;
+                    simulator.pollTime = expectedPollTime;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            expect(buf[buf.length - 4]).to.equal(expectedPollTime);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdPollTimeGet]));
+                });
+                it('should emit failure if board failure', done => {
+                    // Turn board failure mode
+                    simulator.options.boardFailure = true;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.false;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.true;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdPollTimeGet]));
+                });
+            });
+            describe('OBCIRadioCmdPollTimeSet',function () {
+                it('should set the poll time if in bounds', done => {
+                    var newPollTime = 20;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            expect(buf[buf.length - 4]).to.equal(newPollTime);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdPollTimeSet,newPollTime]));
+                });
+                it('should emit failure if board failure', done => {
+                    // Turn board failure mode
+                    simulator.options.boardFailure = true;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.false;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.true;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdPollTimeSet,7]));
+                });
+            });
+            describe('OBCIRadioCmdBaudRateSetDefault',function () {
+                it('should emit success if firmware version 2 with proper baud rate', done => {
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            var eotBuf = new Buffer('$$$');
+                            var newBaudRateBuf;
+                            for (var i = buf.length; i > 3; i--) {
+                                if (bufferEqual(buf.slice(i - 3, i),eotBuf)) {
+                                    newBaudRateBuf = buf.slice(i - 9, i - 3);
+                                    break;
+                                }
+                            }
+                            var newBaudRateNum = Number(newBaudRateBuf.toString());
+                            expect(newBaudRateNum).to.equal(k.OBCIRadioBaudRateDefault);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdBaudRateSetDefault]));
+                });
+                it('should emit success if board failure', done => {
+                    // Turn board failure mode
+                    simulator.options.boardFailure = true;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdBaudRateSetDefault]));
+                });
+            });
+            describe('OBCIRadioCmdBaudRateSetFast',function () {
+                it('should emit success if firmware version 2 with proper baud rate', done => {
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            var eotBuf = new Buffer("$$$");
+                            var newBaudRateBuf;
+                            for (var i = buf.length; i > 3; i--) {
+                                if (bufferEqual(buf.slice(i - 3, i),eotBuf)) {
+                                    newBaudRateBuf = buf.slice(i - 9, i - 3);
+                                    break;
+                                }
+                            }
+                            var newBaudRateNum = Number(newBaudRateBuf.toString());
+                            expect(newBaudRateNum).to.equal(k.OBCIRadioBaudRateFast);
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdBaudRateSetFast]));
+                });
+                it('should emit success if board failure', done => {
+                    // Turn board failure mode
+                    simulator.options.boardFailure = true;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdBaudRateSetFast]));
+                });
+            });
+            describe('OBCIRadioCmdSystemStatus',function () {
+                it('should emit success if firmware version 2', done => {
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.true;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.false;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdSystemStatus]));
+                });
+                it('should emit failure if board failure', done => {
+                    // Turn board failure mode
+                    simulator.options.boardFailure = true;
+                    var buf = new Buffer(0);
+                    var dataEmit = data => {
+                        buf = Buffer.concat([buf,data]);
+                        if (openBCISample.doesBufferHaveEOT(buf)) {
+                            expect(openBCISample.isSuccessInBuffer(buf)).to.be.false;
+                            expect(openBCISample.isFailureInBuffer(buf)).to.be.true;
+                            simulator.removeListener('data',dataEmit);
+                            done();
+                        }
+                    };
+
+                    simulator.on('data',dataEmit);
+
+                    simulator._processPrivateRadioMessage(new Buffer([k.OBCIRadioKey,k.OBCIRadioCmdSystemStatus]));
+                });
+            });
+        });
+    });
+    describe("boardFailure",function () {
+
+    });
+
+    describe("#sync",function () {
+        this.timeout(2000);
+        var simulator;
+        beforeEach(function(done) {
+            simulator = new openBCISimulator.OpenBCISimulator(portName, {
+                firmwareVersion: 'v2'
+            });
+            simulator.once('open',() => {
+                done();
+            });
+        });
+        afterEach(function() {
+            simulator = null;
+        });
+        it("should emit the time sync sent command", function(done) {
+            simulator.once('data',data => {
+                expect(openBCISample.isTimeSyncSetConfirmationInBuffer(data)).to.be.true;
+                done();
+            });
+            simulator.write(k.OBCISyncTimeSet, (err, msg) => {
+                if (err) {
+                    done(err);
+                }
+            });
+        });
+        it("should set synced to true", function(done) {
+            simulator.synced = false;
+            var newData = data => {
+                expect(simulator.synced).to.be.true;
+                simulator.removeListener('data', newData);
+                done();
+            };
+
+            simulator.on('data', data => {
+                newData(data);
+            });
+
+            simulator.write(k.OBCISyncTimeSet, (err, msg) => {
+                if (err) {
+                    done(err);
+                }
+            });
+        });
+        it("should emit a time sync set packet followed by a time synced accel packet after sync up call", function(done) {
+            simulator.synced = false;
+            var emitCounter = 0;
+            var maxPacketsBetweenSetPacket = 5;
+            var newData = data => {
+                if (emitCounter === 0) { // the time sync packet is emitted here
+                    // Make a call to start streaming
+                    simulator.write(k.OBCIStreamStart, err => {
+                        if (err) done(err);
+                    });
+                } else if (emitCounter < maxPacketsBetweenSetPacket) {
+                    if (openBCISample.getRawPacketType(data[k.OBCIPacketPositionStopByte]) === k.OBCIStreamPacketAccelTimeSyncSet) {
+                        simulator.removeListener('data', newData);
+                        simulator.write(k.OBCIStreamStop, err => {
+                            if (err) done(err);
+                            done();
+                        });
+                    } else {
+                        expect(openBCISample.getRawPacketType(data[k.OBCIPacketPositionStopByte])).to.equal(k.OBCIStreamPacketAccelTimeSynced);
+
+                    }
+                } else {
+                    done("Failed to get set packet in time")
+                }
+                emitCounter++;
+            };
+
+            simulator.on('data', newData);
+
+            simulator.write(k.OBCISyncTimeSet, (err, msg) => {
+                if (err) {
+                    done(err);
+                }
+            });
+        });
+        it("should emit a time sync set raw aux, then time synced raw aux packet after sync up call", function(done) {
+            simulator.synced = false;
+            simulator.options.accel = false;
+            var emitCounter = 0;
+            var maxPacketsBetweenSetPacket = 5;
+            var newData = data => {
+                if (emitCounter === 0) { // the time sync packet is emitted here
+                    // Make a call to start streaming
+                    simulator.write(k.OBCIStreamStart, err => {
+                        if (err) done(err);
+                    });
+                } else if (emitCounter < maxPacketsBetweenSetPacket) {
+                    if (openBCISample.getRawPacketType(data[k.OBCIPacketPositionStopByte]) === k.OBCIStreamPacketRawAuxTimeSyncSet) {
+                        simulator.removeListener('data', newData);
+                        simulator.write(k.OBCIStreamStop, err => {
+                            if (err) done(err);
+                            done();
+                        });
+                    } else {
+                        expect(openBCISample.getRawPacketType(data[k.OBCIPacketPositionStopByte])).to.equal(k.OBCIStreamPacketRawAuxTimeSynced);
+                    }
+                } else {
+                    done("Failed to get set packet in time")
+                }
+
+                emitCounter++;
+            };
+
+            simulator.on('data', newData);
+
+            simulator.write(k.OBCISyncTimeSet, (err, msg) => {
+                if (err) {
+                    done(err);
+                }
+            });
+        });
+    })
+});
Autor	SHA1	Mensagem	Data
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
AJ Keller	18b137b498	Merge pull request #85 from aj-ptw/fix-constants-constructor Fix constants not set in constructor	2016-09-29 14:52:50 -04:00
AJ Keller	470ee81928	Fix constants not set in constructor	2016-09-29 14:44:59 -04:00
AJ Keller	3c46100e1d	Merge pull request #84 from aj-ptw/dropped-packet-alert Add dropped packet detection	2016-09-29 10:26:50 -04:00
AJ Keller	2c0b2e37d2	Add dropped packet detection	2016-09-29 10:22:02 -04:00
AJ Keller	094e328296	Merge pull request #78 from aj-ptw/enh-pdf-readme ENH readme gets a table of contents	2016-08-21 12:15:21 -04:00
AJ Keller	4c9bbb1f6d	ENH readme gets a table of contents	2016-08-19 13:50:34 -04:00
AJ Keller	b51cb54f92	Merge pull request #74 from pushtheworldllc/serialport-upgrade Enh upgrade serial port to 4.x	2016-08-10 07:35:38 -04:00
AJ Keller	19f05e362f	Enh upgrade serial port to 4.x	2016-08-09 22:31:36 -04:00
AJ Keller	c33d08b486	Merge pull request #73 from pushtheworldllc/dev-firmware v1.2.1 Fix for radio channel set functions	2016-08-08 22:42:36 -04:00
AJ Keller	97cff2dac9	Fix for radio channel set functions	2016-08-08 22:36:09 -04:00
AJ Keller	6cf5e993ed	Merge pull request #72 from pushtheworldllc/dev Update time synced accel packets	2016-08-04 17:35:04 -04:00
AJ Keller	6cbf99e635	Update for time sync accel sending in 7,8,9 and not 0,1,2 Update for new firmware update readme and changelog for 1.2 Readme and comment patches from teon comments on PR #70 update readme update readme	2016-08-04 13:37:47 -04:00
AJ Keller	9bd1121ab8	Merge pull request #71 from haniawni/OpenBCI Explain Interfacing with LSL	2016-08-03 17:13:15 -04:00
HaniAwni	7d878f1a16	Explain Interfacing with LSL	2016-08-03 13:55:53 -07:00
AJ Keller	ba4370793c	Merge pull request #70 from pushtheworldllc/bug-time-sync Bug time sync	2016-07-28 15:41:22 -04:00
AJ Keller	e88922c106	Fix auto test for commandChannelOn	2016-07-25 22:01:48 -04:00
AJ Keller	a43c52fdec	Add auto test for syncClocksFull	2016-07-25 20:21:15 -04:00
AJ Keller	5cf97383b9	Fix time sync, enh to readme, add full sync function Saving Time offset back to working in auto tests All tests passing with time sync func time sync working Add examples in readme. General enh and clean up	2016-07-25 17:10:02 -04:00
AJ Keller	d51c8f80d4	Merge pull request #69 from OpenBCI/teonbrooks-patch-1 Update package.json	2016-07-25 08:54:22 -04:00
AJ Keller	0a1f3de1a7	Update badges for new repo name	2016-07-19 10:26:39 -04:00
Teon L Brooks	e68f85d5b3	Update package.json	2016-07-18 15:06:28 -04:00
Teon L Brooks	9c51fd673e	Merge pull request #64 from pushtheworldllc/dev-ntp ADD all OpenBCI board features, ADD daisy support, ADD firmware 2.0	2016-07-18 14:52:42 -04:00
AJ Keller	2cf1a46994	Update readme for Teon fixes	2016-07-18 13:35:06 -04:00
AJ Keller	77f7946790	Add tutorial for time sync	2016-07-17 21:06:16 -04:00
AJ Keller	9bd83aaf15	Fix sample bug and time sync bug	2016-07-17 19:45:04 -04:00
AJ Keller	22f5ddbcef	Enh Readme.md	2016-07-14 17:26:53 -04:00
AJ Keller	918451ebcb	Saving	2016-07-14 16:40:18 -04:00
AJ Keller	a03250502c	ENH Readme	2016-07-14 16:36:25 -04:00
AJ Keller	265e89284c	Add hardware test output to ignore	2016-07-14 14:36:27 -04:00
AJ Keller	0cd2e57f96	New Time Sync Protocol	2016-07-14 14:36:27 -04:00
AJ Keller	4a58dcb36a	moving to rc	2016-07-14 14:34:17 -04:00
AJ Keller	82a3fc3ced	ADD daisy	2016-07-14 14:34:17 -04:00
AJ Keller	23e8364185	Saving for the night	2016-07-14 14:34:17 -04:00
AJ Keller	e21160fa4d	ADD tests for simulator radio commands	2016-07-14 14:34:17 -04:00
AJ Keller	6d3813c4e1	Fix version number extraction for buffer	2016-07-14 14:34:17 -04:00
AJ Keller	d8342879cf	Fix teon comments	2016-07-14 14:34:17 -04:00
AJ Keller	3322e9ca5c	Add tests for radio board verification testing	2016-07-14 14:34:17 -04:00
AJ Keller	5f0085ddb3	Working on radio validation	2016-07-14 14:34:17 -04:00
AJ Keller	a005c8b711	Auto tests on sim working for all board commands	2016-07-14 14:34:17 -04:00
AJ Keller	49d0a5376f	Fix breaking build in simulator	2016-07-14 14:34:17 -04:00
AJ Keller	de22e725d5	ADD time sync tests	2016-07-14 14:34:17 -04:00
AJ Keller	74cd163bd5	Simulator working for multiple packet types	2016-07-14 14:34:17 -04:00
AJ Keller	9fd53d2bec	Simulator emitting time sync set packet	2016-07-14 14:34:17 -04:00
AJ Keller	da8e407e84	Saving	2016-07-14 14:34:17 -04:00
AJ Keller	d624b1d387	Working on time syncing	2016-07-14 14:34:17 -04:00
AJ Keller	f861563326	Moved funcs from board to sample file	2016-07-14 14:34:17 -04:00
AJ Keller	083df5a109	Byte processor working better	2016-07-14 14:34:17 -04:00
AJ Keller	aa5e42575a	Adding test	2016-07-14 14:34:17 -04:00
AJ Keller	cd482558bb	saving	2016-07-14 14:34:17 -04:00
AJ Keller	fa5890d5ad	ADD poll time set function	2016-07-14 14:34:17 -04:00
AJ Keller	3df7d3170c	Radio channel change function built	2016-07-14 14:34:17 -04:00
AJ Keller	46edd477a5	Add note to change log	2016-07-14 14:34:17 -04:00
AJ Keller	c36e9d6126	Saving	2016-07-14 14:34:17 -04:00
AJ Keller	ccd2983cc9	Saving	2016-07-14 14:34:17 -04:00
AJ Keller	08a575cc9c	saving	2016-07-14 14:34:17 -04:00
AJ Keller	83223cb50a	Add tests for every option for the main constructor	2016-07-14 14:34:17 -04:00
AJ Keller	dbd9987d5e	add options for simulator	2016-07-14 14:34:17 -04:00
AJ Keller	2832fcb6b2	saving	2016-07-14 14:34:17 -04:00
AJ Keller	61a2971275	fix	2016-07-14 14:34:17 -04:00
AJ Keller	cc177e200d	Saving	2016-07-14 14:34:17 -04:00
AJ Keller	12429398ca	Working on daisy support	2016-07-14 14:34:17 -04:00
AJ Keller	de3604f3b8	Add finalize protocol for daisy	2016-07-14 14:34:17 -04:00
AJ Keller	6f6ffe7ad8	get channel data array working for daisy	2016-07-14 14:34:17 -04:00
AJ Keller	f4cd6b3a65	saving for the night	2016-07-14 14:34:17 -04:00
AJ Keller	443ee211ad	Working on adding daisy	2016-07-14 14:34:17 -04:00
AJ Keller	bfc0fe62a1	Fix for node 4.x.x	2016-07-14 14:34:17 -04:00
AJ Keller	4d7d4eb5d8	All tests passing	2016-07-14 14:34:17 -04:00
AJ Keller	f948ec25f2	save	2016-07-14 14:34:17 -04:00
AJ Keller	78b830e5c0	saving...	2016-07-14 14:34:17 -04:00
AJ Keller	63a15cb950	Saving	2016-07-14 14:34:17 -04:00
AJ Keller	f5bf4db9a0	saving	2016-07-14 14:34:17 -04:00
AJ Keller	117c4411da	Saving... working on new parseing	2016-07-14 14:34:17 -04:00
AJ Keller	927f6c1596	small patch for auto tests	2016-07-14 14:34:17 -04:00
AJ Keller	81af1098ed	wrote tests for routing packets based on end byte	2016-07-14 14:34:17 -04:00
AJ Keller	a8fa5bab02	Refactored openBCISample	2016-07-14 14:34:17 -04:00
AJ Keller	982688008a	New process bytes function working as expected with packets	2016-07-14 14:34:17 -04:00
AJ Keller	cbbecc8b37	Add tests for new packet parser... testing underway	2016-07-14 14:34:17 -04:00
AJ Keller	4080fe0d1b	Changed openBCIConstants to match ES6 syntax	2016-07-14 14:34:17 -04:00
AJ Keller	9e745331eb	saving...	2016-07-14 14:34:17 -04:00
AJ Keller	b1c8b81aa1	Saving...	2016-07-14 14:34:17 -04:00
AJ Keller	de6e1ab353	Adding lots of automated tests...	2016-07-14 14:34:17 -04:00
AJ Keller	cd108bd29a	Saving..	2016-07-14 14:34:17 -04:00
AJ Keller	79b46ecb53	Saving...	2016-07-14 14:34:17 -04:00
AJ Keller	f8a47560b8	ENH ntp testing	2016-07-14 14:34:17 -04:00
AJ Keller	03ed89b516	ADD methods for time sync	2016-07-14 14:34:17 -04:00
AJ Keller	bc436a7e1f	Saving...	2016-07-14 14:34:17 -04:00
AJ Keller	2108ae2a75	ADD packet codes	2016-07-14 14:34:17 -04:00
AJ Keller	70689548a1	Saving	2016-07-14 14:34:17 -04:00
AJ Keller	701bc75a1f	First sync with board	2016-07-14 14:34:17 -04:00
AJ Keller	cce4f930ef	NTP testing with firmware	2016-07-14 14:34:17 -04:00
AJ Keller	737f40e51e	Saving for the night, stuff is starting to work though.	2016-07-14 14:34:17 -04:00
AJ Keller	f00988716a	ENH processBytes to support multiple packet types	2016-07-14 14:34:17 -04:00
Andy Heusser	7e7eb8f549	Merge pull request #68 from pushtheworldllc/dev Validate packets before emitting raw data packets	2016-06-28 09:15:18 -04:00
AJ Keller	8383070639	Fix emit bad raw packets	2016-06-27 16:35:07 -04:00
AJ Keller	b24d682e49	Bump version to match npm	2016-06-24 14:41:45 -04:00
Andy Heusser	b36a7b3409	Merge pull request #67 from pushtheworldllc/dev Fix constructor in readme.md Closes #66	2016-06-24 14:37:37 -04:00
AJ Keller	cfa8f4bdc8	Fix constructor in readme.md Closes #66	2016-06-24 14:31:04 -04:00
AJ Keller	ee66c49ff0	Update changelog.md Forgot to update change log on merge	2016-06-21 21:21:14 -04:00
Andy Heusser	abfb37a38e	Merge pull request #65 from pushtheworldllc/dev-serialport-upgrade Dev serialport upgrade	2016-06-21 17:14:40 -04:00
AJ Keller	48be1a01db	ENH add more travis versions	2016-06-21 07:36:50 -04:00
AJ Keller	8bbc011ead	ENH bump serialport to 3.0.0	2016-06-21 07:33:38 -04:00