i2c 0.2.4 → 0.3.0

package/README.md

@@ -137,7 +137,7 @@ npm install i2c@0.1.8
 
 ## Contributors
 
-Thanks to @alphacharlie for Nan rewrite!
+Thanks to @alphacharlie for Nan rewrite, and @J-Cat for Node 14 updates.
 
 
 ## Questions?

package/examples/accelerometer/accel.js

@@ -0,0 +1,72 @@
+const Wire = require('../../main');
+
+// for AK8975
+// info: https://github.com/jrowberg/i2cdevlib/blob/master/Arduino/AK8975/AK8975.cpp
+// http://stackoverflow.com/questions/4768933/read-two-bytes-into-an-integer
+
+const RANGE_BWIDTH      = 0x14;
+const RANGE_BIT         = 0x04;
+const RANGE_LENGTH      = 0x02;
+const RANGE_2G          = 0x00;
+const BANDWIDTH_BIT     = 0x02;
+const BANDWIDTH_LENGTH  = 0x03;
+const BW_25HZ           = 0x00;
+const GET_ID            = 0x00;
+
+class Accelerometer {
+
+  constructor(address) {
+    this.address = address;
+    this.wire = new Wire(this.address);
+
+    this.setRange();
+    this.setBandwidth();
+
+    this.wire.on('data', (data) => {
+      console.log(data);
+    });
+  }
+
+  setRange() {
+    this.wire.writeBytes(RANGE_BWIDTH, [RANGE_BIT, RANGE_LENGTH, RANGE_2G], null);
+  }
+
+  testConnection(callback) {
+    this.getDeviceID((err, data) => {
+      callback(data[0] === 0b010);
+    });
+  }
+
+  getDeviceID(callback) {
+    this.wire.readBytes(GET_ID, 1, callback);
+  }
+
+  setBandwidth() {
+    this.wire.writeBytes(RANGE_BWIDTH, [BANDWIDTH_BIT, BANDWIDTH_LENGTH, BW_25HZ], null);
+  }
+
+  getHeading() {
+    this.wire.writeBytes(0x0A, [0x1], (err) => {
+       if (err) console.error(err);
+    });
+
+    setTimeout(() => {
+      this.wire.readBytes(0x03, 6, (err, buffer) => {
+        if (err) return console.error(err);
+        const pos = {
+          x: ((buffer[1]) << 8) | buffer[0],
+          y: ((buffer[3]) << 8) | buffer[2],
+          z: ((buffer[5]) << 8) | buffer[4]
+        };
+        console.log(pos);
+      });
+    }, 10);
+  }
+
+  getMotion() {
+    this.wire.stream(0x02, 6, 100);
+  }
+}
+
+const accel = new Accelerometer(56);
+accel.getHeading();

package/examples/blinkm/blinkm.js

@@ -0,0 +1,69 @@
+const Wire = require('../../main');
+
+// BlinkM http://thingm.com/products/blinkm
+// firmware http://code.google.com/p/codalyze/wiki/CyzRgb
+
+const TO_RGB        = 0x6e;
+const GET_RGB       = 0x67;
+const FADE_TO_RGB   = 0x63;
+const FADE_TO_HSB   = 0x68;
+const GET_ADDRESS   = 0x61;
+const SET_ADDRESS   = 0x41;
+const SET_FADE      = 0x66;
+const GET_VERSION   = 0x5a;
+const WRITE_SCRIPT  = 0x57;
+const READ_SCRIPT   = 0x52;
+const PLAY_SCRIPT   = 0x70;
+const STOP_SCRIPT   = 0x0f;
+
+class Pixel {
+
+  constructor(address) {
+    this.address = address || 0x01;
+    this.wire = new Wire(this.address);
+  }
+
+  off() {
+    this.setRGB(0, 0, 0);
+  }
+
+  getAddress(callback) {
+    this._read(GET_ADDRESS, 1, callback);
+  }
+
+  getVersion(callback) {
+    this._read(GET_VERSION, 1, callback);
+  }
+
+  setFadeSpeed(speed) {
+    this._send(SET_FADE, [speed]);
+  }
+
+  setRGB(r, g, b) {
+    this._send(TO_RGB, [r, g, b]);
+  }
+
+  getRGB(callback) {
+    setTimeout(() => {
+      this._read(GET_RGB, 3, callback);
+    }, 200);
+  }
+
+  fadeToRGB(r, g, b) {
+    this._send(FADE_TO_RGB, [r, g, b]);
+  }
+
+  fadeToHSB(h, s, b) {
+    this._send(FADE_TO_HSB, [h, s, b]);
+  }
+
+  _send(cmd, values) {
+    this.wire.writeBytes(cmd, values);
+  }
+
+  _read(cmd, length, callback) {
+    this.wire.readBytes(cmd, length, callback);
+  }
+}
+
+module.exports = Pixel;

package/lib/i2c.js

@@ -0,0 +1,146 @@
+const wire = require('../build/Release/i2c');
+const { EventEmitter } = require('events');
+const tick = setImmediate || process.nextTick;
+
+class i2c extends EventEmitter {
+
+  constructor(address, options) {
+    super();
+    this.address = address;
+    this.options = {
+      debug: false,
+      device: "/dev/i2c-1",
+      ...(options || {})
+    };
+    this.history = [];
+
+    if (this.options.debug) {
+      require('repl').start({
+        prompt: "i2c > "
+      }).context.wire = this;
+      process.stdin.emit('data', ''); // trigger repl
+    }
+
+    process.on('exit', () => this.close());
+
+    this.on('data', (data) => {
+      this.history.push(data);
+    });
+
+    this.on('error', (err) => {
+      console.log(`Error: ${err}`);
+    });
+
+    this.open(this.options.device, (err) => {
+      if (!err) {
+        this.setAddress(this.address);
+      }
+    });
+  }
+
+  scan(callback) {
+    wire.scan((err, data) => {
+      tick(() => {
+        // data is an Array from C++
+        callback(err, data.filter((num) => num >= 0));
+      });
+    });
+  }
+
+  setAddress(address) {
+    wire.setAddress(address);
+    this.address = address;
+  }
+
+  open(device, callback) {
+    wire.open(device, (err) => {
+      tick(() => {
+        if (callback) callback(err);
+      });
+    });
+  }
+
+  close() {
+    wire.close();
+  }
+
+  write(buf, callback) {
+    this.setAddress(this.address);
+    if (!Buffer.isBuffer(buf)) {
+      buf = Buffer.from(buf);
+    }
+    wire.write(buf, (err) => {
+      tick(() => {
+        if (callback) callback(err);
+      });
+    });
+  }
+
+  writeByte(byte, callback) {
+    this.setAddress(this.address);
+    wire.writeByte(byte, (err) => {
+      tick(() => {
+        if (callback) callback(err);
+      });
+    });
+  }
+
+  writeBytes(cmd, buf, callback) {
+    this.setAddress(this.address);
+    if (!Buffer.isBuffer(buf)) {
+      buf = Buffer.from(buf);
+    }
+    wire.writeBlock(cmd, buf, (err) => {
+      tick(() => {
+        if (callback) callback(err);
+      });
+    });
+  }
+
+  read(len, callback) {
+    this.setAddress(this.address);
+    wire.read(len, (err, data) => {
+      tick(() => {
+        if (callback) callback(err, data);
+      });
+    });
+  }
+
+  readByte(callback) {
+    this.setAddress(this.address);
+    wire.readByte((err, data) => {
+      tick(() => {
+        if (callback) callback(err, data);
+      });
+    });
+  }
+
+  readBytes(cmd, len, callback) {
+    this.setAddress(this.address);
+    wire.readBlock(cmd, len, null, (err, actualBuffer) => {
+      tick(() => {
+        if (callback) callback(err, actualBuffer);
+      });
+    });
+  }
+
+  stream(cmd, len, delay) {
+    if (delay == null) delay = 100;
+    this.setAddress(this.address);
+    wire.readBlock(cmd, len, delay, (err, data) => {
+      if (err) {
+        this.emit('error', err);
+      } else {
+        this.emit('data', {
+          address: this.address,
+          data: data,
+          cmd: cmd,
+          length: len,
+          timestamp: Date.now()
+        });
+      }
+    });
+  }
+}
+
+module.exports = i2c;

package/main.js

@@ -1,5 +1,3 @@
-require('coffee-script');
-require('coffee-script/register');
-var i2c = require('./lib/i2c');
+const i2c = require('./lib/i2c');
 
-module.exports = i2c;
+module.exports = i2c;

package/package.json

@@ -1,20 +1,17 @@
 {
   "name": "i2c",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "Native bindings for i2c-dev. Plays well with Raspberry Pi and BeagleBone.",
   "main": "main.js",
   "author": "Kelly Korevec",
   "repository": {
     "type": "git",
-    "url": "http://github.com/korevec/node-i2c.git"
+    "url": "git+ssh://git@github.com/korevec/node-i2c.git"
   },
   "license": "BSD-3-Clause-Attribution",
   "dependencies": {
-    "bindings": "1.5.0",
-    "underscore": "1.11.0",
-    "coffeescript": "2.5.1",
-    "repl":"0.1.3",
-    "nan": "~2.14.0"
+    "bindings": "^1.5.0",
+    "nan": "^2.24.0"
   },
-  "engine": "node >= 0.12.0"
+  "engine": "node >= 18.0.0"
 }

package/src/i2c.cc

@@ -8,6 +8,7 @@
 #include <stdio.h>
 #include <unistd.h>
 #include <string.h>
+#include <vector>
 #include "i2c-dev.h"
 
 
@@ -35,7 +36,7 @@ void SetAddress(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     Nan::ThrowTypeError("addr must be an int");
     return;
   }
-  addr = info[0]->Int32Value();
+  addr = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
   setAddress(addr);
 }
 
@@ -57,7 +58,7 @@ void Scan(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     if (res >= 0) {
       res = i;
     }
-    results->Set(i, Nan::New<Integer>(res));
+    Nan::Set(results, i, Nan::New<Integer>(res));
   }
 
   setAddress(addr);
@@ -65,7 +66,7 @@ void Scan(const Nan::FunctionCallbackInfo<v8::Value>& info) {
   const unsigned argc = 2;
   Local<Value> argv[argc] = { err, results };
 
-  Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callback, argc, argv);
+  Nan::Call(callback, Nan::GetCurrentContext()->Global(), argc, argv);
 
   info.GetReturnValue().Set(results);
 }
@@ -81,7 +82,7 @@ void Close(const Nan::FunctionCallbackInfo<v8::Value>& info) {
 void Open(const Nan::FunctionCallbackInfo<v8::Value>& info) {
   Nan::HandleScope scope;
 
-  String::Utf8Value device(info[0]);
+  Nan::Utf8String device(info[0]);
   Local<Value> err = Nan::New<Value>(Nan::Null());
 
   fd = open(*device, O_RDWR);
@@ -93,14 +94,14 @@ void Open(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     const unsigned argc = 1;
     Local<Function> callback = Local<Function>::Cast(info[1]);
     Local<Value> argv[argc] = { err };
-    Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callback, argc, argv);
+    Nan::Call(callback, Nan::GetCurrentContext()->Global(), argc, argv);
   }
 }
 
 void Read(const Nan::FunctionCallbackInfo<v8::Value>& info) {
   Nan::HandleScope scope;
 
-  int len = info[0]->Int32Value();
+  int len = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
 
   Local<Array> data = Nan::New<Array>();
 
@@ -111,7 +112,7 @@ void Read(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     err = Nan::Error(Nan::New("Cannot read from device").ToLocalChecked());
   } else {
     for (int i = 0; i < len; ++i) {
-      data->Set(i, Nan::New<Integer>(buf[i]));
+      Nan::Set(data, i, Nan::New<Integer>(buf[i]));
     }
   }
   delete[] buf;
@@ -120,7 +121,7 @@ void Read(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     const unsigned argc = 2;
     Local<Function> callback = Local<Function>::Cast(info[1]);
     Local<Value> argv[argc] = { err, data };
-    Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callback, argc, argv);
+    Nan::Call(callback, Nan::GetCurrentContext()->Global(), argc, argv);
   }
 }
 
@@ -142,7 +143,7 @@ void ReadByte(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     const unsigned argc = 2;
     Local<Function> callback = Local<Function>::Cast(info[0]);
     Local<Value> argv[argc] = { err, data };
-    Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callback, argc, argv);
+    Nan::Call(callback, Nan::GetCurrentContext()->Global(), argc, argv);
   }
 
   info.GetReturnValue().Set(data);
@@ -151,31 +152,31 @@ void ReadByte(const Nan::FunctionCallbackInfo<v8::Value>& info) {
 void ReadBlock(const Nan::FunctionCallbackInfo<v8::Value>& info) {
   Nan::HandleScope scope;
 
-  int8_t cmd = info[0]->Int32Value();
-  int32_t len = info[1]->Int32Value();
-  uint8_t data[len]; 
+  int8_t cmd = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  int32_t len = info[1]->Int32Value(Nan::GetCurrentContext()).FromJust();
+
+  std::vector<uint8_t> data(len);
   Local<Value> err = Nan::New<Value>(Nan::Null());
-  // Local<Object> buffer = node::Buffer::New(len);
-  //new version for Nan
-  Local<Object> buffer = Nan::NewBuffer(len).ToLocalChecked();  //todo  - some error checking here as the devs intended?
+
+  Local<Object> buffer = Nan::NewBuffer(len).ToLocalChecked();
 
 
   while (fd > 0) {
-    if (i2c_smbus_read_i2c_block_data(fd, cmd, len, data) != len) {
+    if (i2c_smbus_read_i2c_block_data(fd, cmd, len, data.data()) != len) {
       err = Nan::Error(Nan::New("Error reading length of bytes").ToLocalChecked());
     }
 
-    memcpy(node::Buffer::Data(buffer), data, len);
+    memcpy(node::Buffer::Data(buffer), data.data(), len);
 
     if (info[3]->IsFunction()) {
       const unsigned argc = 2;
       Local<Function> callback = Local<Function>::Cast(info[3]);
       Local<Value> argv[argc] = { err, buffer };
-      Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callback, argc, argv);
+      Nan::Call(callback, Nan::GetCurrentContext()->Global(), argc, argv);
     }
  
     if (info[2]->IsNumber()) {
-      int32_t delay = info[2]->Int32Value();
+      int32_t delay = info[2]->Int32Value(Nan::GetCurrentContext()).FromJust();
       usleep(delay * 1000);
     } else {
       break;
@@ -188,10 +189,10 @@ void ReadBlock(const Nan::FunctionCallbackInfo<v8::Value>& info) {
 void Write(const Nan::FunctionCallbackInfo<v8::Value>& info) {
   Nan::HandleScope scope;
 
-  Local<Value> buffer = info[0];
+  auto bufferObj = info[0]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
 
-  int   len = node::Buffer::Length(buffer->ToObject());
-  char* data = node::Buffer::Data(buffer->ToObject());
+  int   len = node::Buffer::Length(bufferObj);
+  char* data = node::Buffer::Data(bufferObj);
 
   Local<Value> err = Nan::New<Value>(Nan::Null());
 
@@ -203,14 +204,14 @@ void Write(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     const unsigned argc = 1;
     Local<Function> callback = Local<Function>::Cast(info[1]);
     Local<Value> argv[argc] = { err };
-    Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callback, argc, argv);
+    Nan::Call(callback, Nan::GetCurrentContext()->Global(), argc, argv);
   }
 }
 
 void WriteByte(const Nan::FunctionCallbackInfo<v8::Value>& info) {
   Nan::HandleScope scope;
 
-  int8_t byte = info[0]->Int32Value();
+  int8_t byte = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
   Local<Value> err = Nan::New<Value>(Nan::Null());
 
   if (i2c_smbus_write_byte(fd, byte) == -1) {
@@ -221,17 +222,19 @@ void WriteByte(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     const unsigned argc = 1;
     Local<Function> callback = Local<Function>::Cast(info[1]);
     Local<Value> argv[argc] = { err };
-    Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callback, argc, argv);
+    Nan::Call(callback, Nan::GetCurrentContext()->Global(), argc, argv);
   }
 }
 
 void WriteBlock(const Nan::FunctionCallbackInfo<v8::Value>& info) {
   Nan::HandleScope scope;
 
-  Local<Value> buffer = info[1];
-  int8_t cmd = info[0]->Int32Value();
-  int   len = node::Buffer::Length(buffer->ToObject());
-  char* data = node::Buffer::Data(buffer->ToObject());
+  v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
+  auto bufferObj = info[1]->ToObject(context).ToLocalChecked();
+
+  int8_t cmd = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  int   len = node::Buffer::Length(bufferObj);
+  char* data = node::Buffer::Data(bufferObj);
 
   Local<Value> err = Nan::New<Value>(Nan::Null());
 
@@ -243,15 +246,15 @@ void WriteBlock(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     const unsigned argc = 1;
     Local<Function> callback = Local<Function>::Cast(info[2]);
     Local<Value> argv[argc] = { err };
-    Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callback, argc, argv);
+    Nan::Call(callback, Nan::GetCurrentContext()->Global(), argc, argv);
   }
 }
 
 void WriteWord(const Nan::FunctionCallbackInfo<v8::Value>& info) {
   Nan::HandleScope scope;
   
-  int8_t cmd = info[0]->Int32Value();
-  int16_t word = info[1]->Int32Value();
+  int8_t cmd = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  int16_t word = info[1]->Int32Value(Nan::GetCurrentContext()).FromJust();
 
   Local<Value> err = Nan::New<Value>(Nan::Null());
   
@@ -263,33 +266,42 @@ void WriteWord(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     const unsigned argc = 1;
     Local<Function> callback = Local<Function>::Cast(info[2]);
     Local<Value> argv[argc] = { err };
-    Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callback, argc, argv);
+    Nan::Call(callback, Nan::GetCurrentContext()->Global(), argc, argv);
   }
 }
 
-void Init(Handle<Object> exports) {
-
-  exports->Set(Nan::New("setAddress").ToLocalChecked(),
-               Nan::New<v8::FunctionTemplate>(SetAddress)->GetFunction());
-  exports->Set(Nan::New("scan").ToLocalChecked(),
-               Nan::New<v8::FunctionTemplate>(Scan)->GetFunction());
-  exports->Set(Nan::New("open").ToLocalChecked(),
-               Nan::New<v8::FunctionTemplate>(Open)->GetFunction());
-  exports->Set(Nan::New("close").ToLocalChecked(),
-               Nan::New<v8::FunctionTemplate>(Close)->GetFunction());
-  exports->Set(Nan::New("write").ToLocalChecked(),
-               Nan::New<v8::FunctionTemplate>(Write)->GetFunction());
-  exports->Set(Nan::New("writeByte").ToLocalChecked(),
-               Nan::New<v8::FunctionTemplate>(WriteByte)->GetFunction());
-  exports->Set(Nan::New("writeBlock").ToLocalChecked(),
-               Nan::New<v8::FunctionTemplate>(WriteBlock)->GetFunction());
-  exports->Set(Nan::New("read").ToLocalChecked(),
-               Nan::New<v8::FunctionTemplate>(Read)->GetFunction());
-  exports->Set(Nan::New("readByte").ToLocalChecked(),
-               Nan::New<v8::FunctionTemplate>(ReadByte)->GetFunction());
-  exports->Set(Nan::New("readBlock").ToLocalChecked(),
-               Nan::New<v8::FunctionTemplate>(ReadBlock)->GetFunction());
+NAN_MODULE_INIT(Init) {
+
+  Nan::Set(target, Nan::New("setAddress").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<FunctionTemplate>(SetAddress)).ToLocalChecked());
+
+  Nan::Set(target, Nan::New("scan").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<FunctionTemplate>(Scan)).ToLocalChecked());
+
+  Nan::Set(target, Nan::New("open").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<FunctionTemplate>(Open)).ToLocalChecked());
+
+  Nan::Set(target, Nan::New("close").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<FunctionTemplate>(Close)).ToLocalChecked());
+
+  Nan::Set(target, Nan::New("write").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<FunctionTemplate>(Write)).ToLocalChecked());
+
+  Nan::Set(target, Nan::New("writeByte").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<FunctionTemplate>(WriteByte)).ToLocalChecked());
+
+  Nan::Set(target, Nan::New("writeBlock").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<FunctionTemplate>(WriteBlock)).ToLocalChecked());
+
+  Nan::Set(target, Nan::New("read").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<FunctionTemplate>(Read)).ToLocalChecked());
+
+  Nan::Set(target, Nan::New("readByte").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<FunctionTemplate>(ReadByte)).ToLocalChecked());
+
+  Nan::Set(target, Nan::New("readBlock").ToLocalChecked(),
+    Nan::GetFunction(Nan::New<FunctionTemplate>(ReadBlock)).ToLocalChecked());
 
 }
 
-NODE_MODULE(i2c, Init)
+NODE_MODULE(i2c, Init)

package/examples/accelerometer/accel.coffee

@@ -1,55 +0,0 @@
-Wire          = require '../../main'
-
-# for AK8975 
-# info: https://github.com/jrowberg/i2cdevlib/blob/master/Arduino/AK8975/AK8975.cpp
-# http://stackoverflow.com/questions/4768933/read-two-bytes-into-an-integer
-
-RANGE_BWIDTH      = 0x14
-RANGE_BIT         = 0x04
-RANGE_LENGTH      = 0x02
-RANGE_2G          = 0x00
-BANDWIDTH_BIT     = 0x02
-BANDWIDTH_LENGTH  = 0x03
-BW_25HZ           = 0x00
-GET_ID            = 0x00
-
-class Accelerometer
-
-  constructor: (@address) -> 
-    @wire = new Wire @address
-
-    @setRange()
-    @setBandwidth()
-
-    @wire.on 'data', (data) ->
-      console.log data
-
-  setRange: ->
-    @wire.write(RANGE_BWIDTH, [RANGE_BIT, RANGE_LENGTH, RANGE_2G], null)
-
-  testConnection: (callback) ->
-    @getDeviceID (err, data) ->
-     data[0] == 0b010
-
-  getDeviceID: (callback) ->
-    @wire.read GET_ID, 1, callback
-
-  setBandwidth: ->
-    @wire.write(RANGE_BWIDTH, [BANDWIDTH_BIT, BANDWIDTH_LENGTH, BW_25HZ], null)
-
-  getHeading: ->
-    @wire.write(0x0A, 0x1);
-    setTimeout =>
-      @wire.read 0x03, 6, (err, buffer) ->
-        pos = 
-          x: ((buffer[1]) << 8) | buffer[0]
-          y: ((buffer[3]) << 8) | buffer[2]
-          z: ((buffer[5]) << 8) | buffer[4]
-        console.log pos
-    , 10
-  getMotion:  ->
-    @wire.stream 0x02, 6, 100
-
-
-accel = new Accelerometer(56)
-accel.getHeading()

package/examples/blinkm/blinkm.coffee

@@ -1,57 +0,0 @@
-Wire          = require 'i2c'
-_             = require 'underscore'
-
-# BlinkM http://thingm.com/products/blinkm
-# firmware http://code.google.com/p/codalyze/wiki/CyzRgb
-
-TO_RGB        = 0x6e
-GET_RGB       = 0x67
-FADE_TO_RGB   = 0x63
-FADE_TO_HSB   = 0x68
-GET_ADDRESS   = 0x61
-SET_ADDRESS   = 0x41
-SET_FADE      = 0x66
-GET_VERSION   = 0x5a
-WRITE_SCRIPT  = 0x57
-READ_SCRIPT   = 0x52
-PLAY_SCRIPT   = 0x70
-STOP_SCRIPT   = 0x0f
-
-class Pixel
-
-  address: 0x01
-
-  constructor: (@address) ->
-    @wire = new Wire(@address);
-
-  off: ->
-    @setRGB(0, 0, 0)
-
-  getAddress: (callback) ->
-    @_read GET_ADDRESS, 1, callback
-
-  getVersion: (callback) ->
-    @_read GET_VERSION, 1, callback
-
-  setFadeSpeed: (speed) ->
-    @_send SET_FADE, speed
-
-  setRGB: (r, g, b) ->
-    @_send TO_RGB, [r, g, b]
-
-  getRGB: (callback) ->
-    setTimeout =>
-      @_read GET_RGB, 3, callback
-    , 200
-
-  fadeToRGB: (r, g, b) ->
-    @_send FADE_TO_RGB, [r, g, b]
-
-  fadeToHSB: (h, s, b) ->
-    @_send FADE_TO_HSB, [h, s, b]
-
-  _send: (cmd, values) ->
-    @wire.writeBytes cmd, values
-
-  _read: (cmd, length, callback) ->
-    @wire.readBytes cmd, length, callback

package/lib/i2c.coffee

@@ -1,100 +0,0 @@
-_            = require 'underscore'
-wire         = require '../build/Release/i2c'
-EventEmitter = require('events').EventEmitter
-tick         = setImmediate || process.nextTick
-
-class i2c extends EventEmitter
-
-  history: []
-
-  constructor: (@address, @options = {}) ->
-    _.defaults @options,
-      debug: false
-      device: "/dev/i2c-1"
-
-    if @options.debug 
-      require('repl').start(
-        prompt: "i2c > "
-      ).context.wire = @
-      process.stdin.emit 'data', '' # trigger repl
-
-    process.on 'exit', => @close()
-
-    @on 'data', (data) => 
-      @history.push data
-
-    @on 'error', (err) ->
-      console.log "Error: #{err}"
-
-    @open @options.device, (err) =>
-      unless err then @setAddress @address
-
-  scan: (callback) ->
-    wire.scan (err, data) ->
-      tick ->
-        callback err, _.filter data, (num) -> return num >= 0
-
-  setAddress: (address) ->
-    wire.setAddress address
-    @address = address
-
-  open: (device, callback) ->
-    wire.open device, (err) ->
-      tick ->
-        callback err
-
-  close: ->
-    wire.close()
-
-  write: (buf, callback) ->
-    @setAddress @address
-    unless Buffer.isBuffer(buf) then buf = new Buffer(buf)
-    wire.write buf, (err) ->
-      tick ->
-        callback err
-
-  writeByte: (byte, callback) ->
-    @setAddress @address
-    wire.writeByte byte, (err) ->
-      tick ->
-        callback err
-
-  writeBytes: (cmd, buf, callback) ->
-    @setAddress @address
-    unless Buffer.isBuffer(buf) then buf = new Buffer(buf)
-    wire.writeBlock cmd, buf, (err) ->
-      tick ->
-        callback err
-
-  read: (len, callback) ->
-    @setAddress @address
-    wire.read len, (err, data) ->
-      tick ->
-        callback err, data
-
-  readByte: (callback) ->
-    @setAddress @address
-    wire.readByte (err, data) ->
-      tick ->
-        callback err, data
-
-  readBytes: (cmd, len, callback) ->
-    @setAddress @address
-    wire.readBlock cmd, len, null, (err, actualBuffer) ->
-      tick ->
-        callback err, actualBuffer
-
-  stream: (cmd, len, delay = 100) ->
-    @setAddress @address
-    wire.readBlock cmd, len, delay, (err, data) =>
-      if err 
-        @emit 'error', err
-      else 
-        @emit 'data', 
-          address    : @address
-          data       : data
-          cmd        : cmd
-          length     : len
-          timestamp  : Date.now()
-
-module.exports = i2c