When streaming from the board, I noticed that some of the samples are coming in out of order. here is a plot of a couple seconds of data. You can see that there is a systematic pattern to which samples are being presented out of order, and the out of order sample number looks to be increasing linearly.

and here's some example data. If you look after 62, 24 is presented a second time. could be a duplicate, or a sample from another block of data

array([[ 0],
       [19],
       [20],
       [21],
       [22],
       [23],
       [ 1],
       [ 2],
       [ 3],
       [ 4],
       [ 5],
       [ 6],
       [ 7],
       [ 8],
       [ 9],
       [10],
       [11],
       [12],
       [13],
       [14],
       [15],
       [16],
       [17],
       [18],
       [19],
       [20],
       [21],
       [22],
       [23],
       [24],
       [25],
       [26],
       [27],
       [28],
       [29],
       [30],
       [31],
       [32],
       [33],
       [34],
       [35],
       [36],
       [37],
       [38],
       [39],
       [40],
       [41],
       [42],
       [43],
       [44],
       [45],
       [46],
       [47],
       [48],
       [49],
       [50],
       [51],
       [52],
       [53],
       [54],
       [55],
       [56],
       [57],
       [58],
       [59],
       [60],
       [61],
       [62],
       [24],
       [63],
       [64],
       [65],
       [66],
       [67],
       [68],
       [69],
       [70],
       [71],
       [72],
       [73],
       [74],
       [75],
       [76],
       [77],
       [78],
       [79],
       [80],
       [81],
       [82],
       [83],
       [84],
       [85],
       [86],
       [87],
       [88],
       [89],
       [90],
       [91],
       [92],
       [93]])

The Mac and Windows FTDI virtual comm port drivers have big buffers of 4096 which create a fragmented data pulse, there must also be a time component, like every 500 ms it get's cleared, this should be looked into and mimicked in the simulator to provide a better testing environment for graphics developers.

It would be great to get simulated auxData. Currently just getting [0, 0, 0].

The values that come back from an electrode are too high. There is an issue.

The entry file is set for index.js, NOT openBCIBoard.js.

   OpenBCIBoard.prototype.sampleRate = function() {
        if(this.options.boardType === k.OBCIBoardDaisy) {
            return k.OBCISampleRate125;
        } else {
            return k.OBCISampleRate250;
        }
    };

If simulator is using custom sample rate this method should return it.

Add support for the daisy module

I've tried to use time sync feature by running timeSync.js in examples/timeSync.

I already updated my OpenBCI HW to firmware version 2. However, syncClocksFull() function is not working.

bash-3.2$  ls
node_modules package.json timeSync.js
bash-3.2$ node timeSync.js
connected
(node:89295) Warning: Possible EventEmitter memory leak detected. 11 synced listeners added. Use emitter.setMaxListeners() to increase limit
^C

Have any idea?
Additionally, Is there any method that I can debug my OpenBCI firmware?

For dev purposes, it would be great to have a simulated data stream (sinusoids of diff freqs for each chan or rand wave?) that one could use to work on OpenEXP app without connecting the board

Make a robust initialization check.
'$$$' must be received before the board is operational.

I think the issue is here. when you make the new openbciSimulator object, the simulatorSampleRate never makes it into the object, so its just set to the default 250

OpenBCIBoard.prototype.connect = function(portName) {
        this.connected = false;

        return new Promise((resolve,reject) => {
            // If we are simulating, set boardSerial to fake name
            var boardSerial;
            /* istanbul ignore else */
            if (this.options.simulate || portName === k.OBCISimulatorPortName) {
                this.options.simulate = true;
                if (this.options.verbose) console.log('using faux board ' + portName);
                boardSerial = new openBCISimulator.OpenBCISimulator(portName, {
                    verbose: this.options.verbose
                });
            } else {
                /* istanbul ignore if */
                if (this.options.verbose) console.log('using real board ' + portName);
                boardSerial = new serialPort.SerialPort(portName, {
                    baudRate: this.options.baudRate
                },(err) => {
                    if (err) reject(err);
                });
            }

The sample object is not formatting correctly.

hey there,

Getting: Error [writeAndDrain]: Error: Serialport not open." when using the following code:

board.streamStop()
        .then(board.disconnect());

Critical error that can occur when one connects, streams, disconnects and then tries to reconnect, it's as if the board does not read the soft reset command

We should clean up the readme and make a wiki

The serialport dependency does not work on node 4

Let's get this ish settled. Excited about it. Essentially, each data packet will have a time stamp with it. for instance with OpenEXP, when the computer presents, we will have its ntp timestamp for the screen. when we retrieve the data packets, we could modify the packet to have the trigger/tag, then it will be marked in the data. or we can just print a trigger file and do the data correspondence later off-line

var ourBoard = require('openbci-sdk').OpenBCIBoard({
...     verbose: true
... });

returns

TypeError: this.numberOfChannels is not a function
    at OpenBCIFactory.OpenBCIBoard (/Users/daniel.gulyas/dev/openbci-narcolepsy/node_modules/openbci-sdk/openBCIBoard.js:97:69)
    at repl:1:39
    at REPLServer.defaultEval (repl.js:262:27)
    at bound (domain.js:287:14)
    at REPLServer.runBound [as eval] (domain.js:300:12)
    at REPLServer.<anonymous> (repl.js:431:12)
    at emitOne (events.js:82:20)
    at REPLServer.emit (events.js:169:7)
    at REPLServer.Interface._onLine (readline.js:211:10)
    at REPLServer.Interface._line (readline.js:550:8)

but

        var OpenBCIBoard = require('openbci-sdk');
        var ourBoard = new OpenBCIBoard.OpenBCIBoard();

works fine! any ideas why?

Would be nice if this allowed us to use the command line interface

Adds support for wifi shield.

Need to figure out the conversion for parsing raw aux values

There is a bug where rawDataPacket is not being emitted.

Two things needs to happen:

1. This bug needs to be patched
2. An automated test needs to be put in place for this!

Provide high level user functions to abstract SD card commands.

The firmware is being upgraded. We should be tracking that here and adding code ad hoc.

Would be nice if we could query a channel number and see if it is railed like

for ( i = 0; i < board.numberOfChannels(); i++) {
    var railed = board.isRailedChannel(i + 1);
    if (railed) console.log("Channel " + (i+1) " railed");
}

They have a fairly novel way of reconnecting and such that should be implemented in this module.
https://github.com/OpenBCI/OpenBCI_Python/blob/master/open_bci_v3.py#L143

Need to use ES6 destructing to prevent additional overhead from ganglion and wifi support.

Check out this article for information!

The documentation says this should return a promise but is just writes a value to the board. Should we make this a promise or change the comments? If it's possible that the command won't work occasionally, we should probably return a promise.

    /**
     * Purpose: Sends a start streaming command to the board.
     * @returns {Promise} indicating if the signal was able to be sent.
     * Note: You must have successfully connected to an OpenBCI board using the connect
     *           method. Just because the signal was able to be sent to the board, does not
     *           mean the board will start streaming.
     * Author: AJ Keller (@pushtheworldllc)
     */
    OpenBCIBoard.prototype.streamStart = function() {
        this.streaming = true;
        this._reset();
        return this.write(k.OBCIStreamStart);
    };

    /**
     * Purpose: Sends a stop streaming command to the board.
     * @returns {Promise} indicating if the signal was able to be sent.
     * Note: You must have successfully connected to an OpenBCI board using the connect
     *           method. Just because the signal was able to be sent to the board, does not
     *           mean the board stopped streaming.
     * Author: AJ Keller (@pushtheworldllc)
     */
    OpenBCIBoard.prototype.streamStop = function() {
        this.streaming = false;
        return this.write(k.OBCIStreamStop);
    };

Could add as an option to the constructor

Several developers have complained that the module is not requiring properly.
The following do not import in the entry file:
var k = require('./OpenBCIConstants');
var OpenBCISample = require('./OpenBCISample');
var serialPort = require('serialport');

Create an openbci board instance with these methods:

• start
• stop
• write to the board with trigger
• send formatted data

Adopt semi standard

Is there a way the simulated data can be more bio-like?

Change name of simulator from /dev/tty.OpenBCISimulator to just simulator

This will allow us to easily pipe into other modules such as visualizers.

The OpenBCI firmware sends packets at 250Hz, however the accelerometer is only at 25Hz. This leads to accelerometer data only being sent every 10 packets.

Proposal is to align standard with time synced packets in that an auxData Buffer 6 bytes long is emitted with every sample and if the data is greater than zero we will omit an accelData array with converted and scaled accelerometer values.

Use the test signals on the ADS1299 to verify the proper operation of the OpenBCI Module and the ADS1299. Should be able to route utilize a test signal and monitor the voltages streamed back to the board in order to automatically test the channels.

currently getting a "stream time out" message instead of data from the board after sent the start command

@pushtheworldllc, I need to walk through this in person. I get the equation but I want to make sure we have a solid test for it

Adds support for ganglion.