i2c 0.2.5 → 0.4.0

package/test/i2c.test.js

@@ -0,0 +1,445 @@
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const I2C = require('../lib/i2c');
+
+function createMockDevice(overrides) {
+  const noop = () => {};
+  return {
+    open: (path, cb) => setImmediate(() => cb(null)),
+    close: noop,
+    setAddress: noop,
+    scan: noop,
+    read: noop,
+    readByte: noop,
+    readBlock: noop,
+    write: noop,
+    writeByte: noop,
+    writeBlock: noop,
+    writeWord: noop,
+    // tracking
+    _calls: {},
+    ...overrides,
+  };
+}
+
+function trackCalls(device, method) {
+  const original = device[method];
+  const calls = [];
+  device[method] = function(...args) {
+    calls.push(args);
+    return original.apply(this, args);
+  };
+  device._calls[method] = calls;
+  return calls;
+}
+
+function createWire(address, mockDevice, options) {
+  return new Promise((resolve, reject) => {
+    function MockDeviceClass() { return mockDevice; }
+    const wire = new I2C(address, { _DeviceClass: MockDeviceClass, ...options });
+    wire.on('open', () => resolve(wire));
+    wire.on('error', reject);
+  });
+}
+
+describe('I2C', () => {
+  let wire;
+
+  afterEach(() => {
+    if (wire) {
+      wire.close();
+      wire = null;
+    }
+  });
+
+  describe('constructor', () => {
+    it('opens the device and sets address', async () => {
+      const md = createMockDevice();
+      const openCalls = trackCalls(md, 'open');
+      const addrCalls = trackCalls(md, 'setAddress');
+
+      wire = await createWire(0x18, md);
+      assert.equal(openCalls.length, 1);
+      assert.equal(openCalls[0][0], '/dev/i2c-1');
+      assert.equal(addrCalls.length, 1);
+      assert.equal(addrCalls[0][0], 0x18);
+    });
+
+    it('uses custom device path from options', async () => {
+      const md = createMockDevice();
+      const openCalls = trackCalls(md, 'open');
+
+      wire = await createWire(0x18, md, { device: '/dev/i2c-0' });
+      assert.equal(openCalls[0][0], '/dev/i2c-0');
+    });
+
+    it('emits error when open fails', async () => {
+      const md = createMockDevice({
+        open: (path, cb) => setImmediate(() => cb(new Error('No device'))),
+      });
+      const addrCalls = trackCalls(md, 'setAddress');
+
+      function MockDeviceClass() { return md; }
+      const wire2 = new I2C(0x18, { _DeviceClass: MockDeviceClass });
+      const err = await new Promise((resolve) => wire2.on('error', resolve));
+      assert.equal(err.message, 'No device');
+      assert.equal(addrCalls.length, 0);
+      wire2.close();
+    });
+  });
+
+  describe('setAddress', () => {
+    it('updates address on both JS and native side', async () => {
+      const md = createMockDevice();
+      const addrCalls = trackCalls(md, 'setAddress');
+
+      wire = await createWire(0x18, md);
+      wire.setAddress(0x20);
+      assert.equal(wire.address, 0x20);
+      assert.equal(addrCalls.length, 2);
+      assert.equal(addrCalls[1][0], 0x20);
+    });
+  });
+
+  describe('close', () => {
+    it('calls native close and removes exit listener', async () => {
+      const md = createMockDevice();
+      const closeCalls = trackCalls(md, 'close');
+
+      wire = await createWire(0x18, md);
+      const listenersBefore = process.listenerCount('exit');
+      wire.close();
+      assert.equal(closeCalls.length, 1);
+      assert.equal(process.listenerCount('exit'), listenersBefore - 1);
+      wire = null;
+    });
+
+    it('stops streaming on close', async () => {
+      const md = createMockDevice({
+        readBlock: (cmd, len, cb) => setImmediate(() => cb(null, Buffer.from([1]))),
+      });
+
+      wire = await createWire(0x18, md);
+      wire.stream(0x01, 1, 10);
+      wire.close();
+      assert.equal(wire._streaming, false);
+      assert.equal(wire._streamTimer, null);
+      wire = null;
+    });
+  });
+
+  describe('scan', () => {
+    it('filters negative values from scan results', async () => {
+      const md = createMockDevice({
+        scan: (cb) => {
+          const results = new Array(128).fill(-1);
+          results[0x18] = 0x18;
+          results[0x50] = 0x50;
+          setImmediate(() => cb(null, results));
+        },
+      });
+
+      wire = await createWire(0x18, md);
+      const devices = await new Promise((resolve, reject) => {
+        wire.scan((err, data) => err ? reject(err) : resolve(data));
+      });
+      assert.deepEqual(devices, [0x18, 0x50]);
+    });
+  });
+
+  describe('write', () => {
+    it('converts array to Buffer before writing', async () => {
+      const md = createMockDevice({
+        write: (buf, cb) => setImmediate(() => cb(null)),
+      });
+      const writeCalls = trackCalls(md, 'write');
+
+      wire = await createWire(0x18, md);
+      await new Promise((resolve, reject) => {
+        wire.write([0x01, 0x02], (err) => err ? reject(err) : resolve());
+      });
+      assert.ok(Buffer.isBuffer(writeCalls[0][0]));
+      assert.deepEqual([...writeCalls[0][0]], [0x01, 0x02]);
+    });
+
+    it('passes Buffer directly', async () => {
+      const md = createMockDevice({
+        write: (buf, cb) => setImmediate(() => cb(null)),
+      });
+      const writeCalls = trackCalls(md, 'write');
+      const buf = Buffer.from([0xFF]);
+
+      wire = await createWire(0x18, md);
+      await new Promise((resolve, reject) => {
+        wire.write(buf, (err) => err ? reject(err) : resolve());
+      });
+      assert.strictEqual(writeCalls[0][0], buf);
+    });
+
+    it('passes error to callback', async () => {
+      const md = createMockDevice({
+        write: (buf, cb) => setImmediate(() => cb(new Error('write failed'))),
+      });
+
+      wire = await createWire(0x18, md);
+      const err = await new Promise((resolve) => {
+        wire.write([0x01], (e) => resolve(e));
+      });
+      assert.equal(err.message, 'write failed');
+    });
+  });
+
+  describe('writeByte', () => {
+    it('writes a single byte', async () => {
+      const md = createMockDevice({
+        writeByte: (byte, cb) => setImmediate(() => cb(null)),
+      });
+      const calls = trackCalls(md, 'writeByte');
+
+      wire = await createWire(0x18, md);
+      await new Promise((resolve, reject) => {
+        wire.writeByte(0xAB, (err) => err ? reject(err) : resolve());
+      });
+      assert.equal(calls[0][0], 0xAB);
+    });
+  });
+
+  describe('writeBytes', () => {
+    it('converts array to Buffer and calls writeBlock', async () => {
+      const md = createMockDevice({
+        writeBlock: (cmd, buf, cb) => setImmediate(() => cb(null)),
+      });
+      const calls = trackCalls(md, 'writeBlock');
+
+      wire = await createWire(0x18, md);
+      await new Promise((resolve, reject) => {
+        wire.writeBytes(0x10, [0x01, 0x02, 0x03], (err) => err ? reject(err) : resolve());
+      });
+      assert.equal(calls[0][0], 0x10);
+      assert.ok(Buffer.isBuffer(calls[0][1]));
+      assert.deepEqual([...calls[0][1]], [0x01, 0x02, 0x03]);
+    });
+  });
+
+  describe('read', () => {
+    it('reads data from device', async () => {
+      const data = [1, 2, 3];
+      const md = createMockDevice({
+        read: (len, cb) => setImmediate(() => cb(null, data)),
+      });
+      const calls = trackCalls(md, 'read');
+
+      wire = await createWire(0x18, md);
+      const result = await new Promise((resolve, reject) => {
+        wire.read(3, (err, d) => err ? reject(err) : resolve(d));
+      });
+      assert.deepEqual(result, data);
+      assert.equal(calls[0][0], 3);
+    });
+  });
+
+  describe('readByte', () => {
+    it('reads a single byte', async () => {
+      const md = createMockDevice({
+        readByte: (cb) => setImmediate(() => cb(null, 0x42)),
+      });
+
+      wire = await createWire(0x18, md);
+      const data = await new Promise((resolve, reject) => {
+        wire.readByte((err, d) => err ? reject(err) : resolve(d));
+      });
+      assert.equal(data, 0x42);
+    });
+  });
+
+  describe('readBytes', () => {
+    it('reads a block of bytes from a register', async () => {
+      const buf = Buffer.from([0x10, 0x20, 0x30]);
+      const md = createMockDevice({
+        readBlock: (cmd, len, cb) => setImmediate(() => cb(null, buf)),
+      });
+      const calls = trackCalls(md, 'readBlock');
+
+      wire = await createWire(0x18, md);
+      const data = await new Promise((resolve, reject) => {
+        wire.readBytes(0x01, 3, (err, d) => err ? reject(err) : resolve(d));
+      });
+      assert.deepEqual(data, buf);
+      assert.equal(calls[0][0], 0x01);
+      assert.equal(calls[0][1], 3);
+    });
+  });
+
+  describe('stream', () => {
+    it('emits data events repeatedly and stops with stopStream', async () => {
+      let callCount = 0;
+      const md = createMockDevice({
+        readBlock: (cmd, len, cb) => {
+          callCount++;
+          const c = callCount;
+          setImmediate(() => cb(null, Buffer.from([c])));
+        },
+      });
+
+      wire = await createWire(0x18, md);
+      const received = await new Promise((resolve) => {
+        const items = [];
+        wire.on('data', (evt) => {
+          items.push(evt.data[0]);
+          if (items.length === 3) {
+            wire.stopStream();
+            resolve(items);
+          }
+        });
+        wire.stream(0x01, 1, 10);
+      });
+      assert.deepEqual(received, [1, 2, 3]);
+      assert.equal(wire._streaming, false);
+    });
+
+    it('emits error events on read failure', async () => {
+      const md = createMockDevice({
+        readBlock: (cmd, len, cb) => {
+          setImmediate(() => cb(new Error('read error')));
+        },
+      });
+
+      wire = await createWire(0x18, md);
+      const err = await new Promise((resolve) => {
+        wire.on('error', (e) => {
+          wire.stopStream();
+          resolve(e);
+        });
+        wire.stream(0x01, 1, 10);
+      });
+      assert.equal(err.message, 'read error');
+    });
+
+    it('includes metadata in data events', async () => {
+      const md = createMockDevice({
+        readBlock: (cmd, len, cb) => {
+          setImmediate(() => cb(null, Buffer.from([0xFF])));
+        },
+      });
+
+      wire = await createWire(0x18, md);
+      const evt = await new Promise((resolve) => {
+        wire.on('data', (e) => {
+          wire.stopStream();
+          resolve(e);
+        });
+        wire.stream(0x02, 1, 10);
+      });
+      assert.equal(evt.address, 0x18);
+      assert.equal(evt.cmd, 0x02);
+      assert.equal(evt.length, 1);
+      assert.equal(typeof evt.timestamp, 'number');
+    });
+
+    it('uses default delay of 100ms when not specified', async () => {
+      const md = createMockDevice({
+        readBlock: (cmd, len, cb) => {
+          setImmediate(() => cb(null, Buffer.from([1])));
+        },
+      });
+
+      wire = await createWire(0x18, md);
+      wire.on('data', () => wire.stopStream());
+      wire.stream(0x01, 1);
+      await new Promise((r) => setTimeout(r, 50));
+    });
+  });
+
+  describe('no listener leak', () => {
+    it('does not accumulate exit listeners across multiple instances', async () => {
+      const before = process.listenerCount('exit');
+      const instances = [];
+
+      for (let i = 0; i < 5; i++) {
+        const md = createMockDevice();
+        instances.push(await createWire(0x18 + i, md));
+      }
+
+      assert.equal(process.listenerCount('exit'), before + 5);
+
+      for (const inst of instances) {
+        inst.close();
+      }
+
+      assert.equal(process.listenerCount('exit'), before);
+      wire = null;
+    });
+  });
+
+  describe('double close safety', () => {
+    it('calling close() twice does not throw', async () => {
+      const md = createMockDevice();
+      const closeCalls = trackCalls(md, 'close');
+
+      wire = await createWire(0x18, md);
+      wire.close();
+      wire.close(); // should not throw or double-remove listener
+      assert.equal(closeCalls.length, 1); // native close called only once
+      wire = null;
+    });
+  });
+
+  describe('double stream guard', () => {
+    it('calling stream() twice does not start parallel loops', async () => {
+      let callCount = 0;
+      const md = createMockDevice({
+        readBlock: (cmd, len, cb) => {
+          callCount++;
+          setImmediate(() => cb(null, Buffer.from([callCount])));
+        },
+      });
+
+      wire = await createWire(0x18, md);
+      wire.on('data', () => {}); // consume events
+      wire.stream(0x01, 1, 50);
+      wire.stream(0x01, 1, 50); // should be ignored
+      await new Promise((r) => setTimeout(r, 30));
+      wire.stopStream();
+      // If double-stream started two loops, callCount would be > 1
+      assert.equal(callCount, 1);
+    });
+  });
+
+  describe('scan error handling', () => {
+    it('passes error to callback without crashing on undefined data', async () => {
+      const md = createMockDevice({
+        scan: (cb) => {
+          setImmediate(() => cb(new Error('scan failed')));
+        },
+      });
+
+      wire = await createWire(0x18, md);
+      const err = await new Promise((resolve) => {
+        wire.scan((err) => resolve(err));
+      });
+      assert.equal(err.message, 'scan failed');
+    });
+  });
+
+  describe('optional callbacks', () => {
+    it('write works without callback', async () => {
+      const md = createMockDevice({
+        write: (buf, cb) => setImmediate(() => cb(null)),
+      });
+
+      wire = await createWire(0x18, md);
+      wire.write([0x01]);
+      await new Promise((r) => setTimeout(r, 20));
+    });
+
+    it('read works without callback', async () => {
+      const md = createMockDevice({
+        read: (len, cb) => setImmediate(() => cb(null, [1])),
+      });
+
+      wire = await createWire(0x18, md);
+      wire.read(1);
+      await new Promise((r) => setTimeout(r, 20));
+    });
+  });
+});

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