i2c 0.3.0 → 0.4.0

package/.claude/settings.local.json

@@ -0,0 +1,36 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(node -e \"console.log\\(process.version\\)\")",
+      "Bash(npm test:*)",
+      "Bash(node -e \":*)",
+      "Bash(node -e \"console.log\\(require.resolve\\(''bindings''\\)\\)\")",
+      "Bash(node --test -e \":*)",
+      "Bash(node -e \"const {mock} = require\\(''node:test''\\); console.log\\(typeof mock.module\\)\")",
+      "Bash(node -e \"const {mock} = require\\(''node:test''\\); console.log\\(Object.keys\\(mock\\)\\)\")",
+      "Bash(npx node-gyp:*)",
+      "Bash(node --test test/*.test.js)",
+      "WebFetch(domain:www.npmjs.com)",
+      "Bash(npm view:*)",
+      "WebSearch",
+      "WebFetch(domain:libraries.io)",
+      "Bash(npm search:*)",
+      "Bash(curl -s https://registry.npmjs.org/bonescript/latest)",
+      "Bash(python3 -m json.tool)",
+      "Bash(curl -s https://registry.npmjs.org/cylon-i2c/latest)",
+      "Bash(curl -s https://registry.npmjs.org/pimatic-i2c/latest)",
+      "Bash(curl -s https://registry.npmjs.org/node-red-contrib-i2c/latest)",
+      "Bash(curl -s https://registry.npmjs.org/raspi-i2c/latest)",
+      "Bash(curl -s \"https://api.npmjs.org/downloads/point/last-week/bonescript,cylon-i2c,pimatic-i2c,node-red-contrib-i2c,raspi-i2c,i2c\")",
+      "Bash(for repo:*)",
+      "Bash(do echo:*)",
+      "Bash(curl -s -o /dev/null -w \"HTTP %{http_code}\" \"https://api.github.com/repos/$repo\")",
+      "Bash(curl -s \"https://api.github.com/repos/$repo\")",
+      "Bash(python3 -c \"import sys,json; d=json.load\\(sys.stdin\\); print\\(f''''Stars: {d.get\\(stargazers_count,N/A\\)}, Forks: {d.get\\(forks_count,N/A\\)}, Pushed: {d.get\\(pushed_at,N/A\\)}, Archived: {d.get\\(archived,N/A\\)}, Description: {d.get\\(description,N/A\\)}''''\\)\")",
+      "Bash(done)",
+      "Bash(curl -s \"https://api.github.com/repos/hybridgroup/cylon-i2c\")",
+      "Bash(curl -s \"https://registry.npmjs.org/-/v1/search?text=dependencies:i2c&size=20\")",
+      "Bash(python3 -c \":*)"
+    ]
+  }
+}

package/README.md

@@ -1,144 +1,136 @@
 # i2c
 
-Bindings for i2c-dev. Plays well with Raspberry Pi and Beaglebone.
+Native bindings for i2c-dev. Plays well with Raspberry Pi and BeagleBone.
 
 ## Install
 
-````bash
-$ npm install i2c
-````
+```bash
+npm install i2c
+```
+
+Requires Node.js >= 18 and a Linux system with I2C support. The native addon uses [Node-API](https://nodejs.org/api/n-api.html) for ABI stability across Node.js versions — no recompilation needed when upgrading Node.js.
 
 ## Usage
 
 ```javascript
+const I2C = require('i2c');
+const address = 0x18;
+const wire = new I2C(address, { device: '/dev/i2c-1' });
 
-var i2c = require('i2c');
-var address = 0x18;
-var wire = new i2c(address, {device: '/dev/i2c-1'}); // point to your i2c address, debug provides REPL interface
-
-wire.scan(function(err, data) {
-  // result contains an array of addresses
-});
-
-wire.writeByte(byte, function(err) {});
+wire.on('open', () => {
+  // device is ready
 
-wire.writeBytes(command, [byte0, byte1], function(err) {});
+  wire.scan((err, data) => {
+    // data contains an array of detected device addresses
+  });
 
-wire.readByte(function(err, res) { // result is single byte })
+  wire.writeByte(byte, (err) => {});
 
-wire.readBytes(command, length, function(err, res) {
-  // result contains a buffer of bytes
-});
+  wire.writeBytes(command, [byte0, byte1], (err) => {});
 
-wire.on('data', function(data) {
-  // result for continuous stream contains data buffer, address, length, timestamp
-});
+  wire.readByte((err, res) => {
+    // res is a single byte
+  });
 
-wire.stream(command, length, delay); // continuous stream, delay in ms
+  wire.readBytes(command, length, (err, res) => {
+    // res contains a buffer of bytes
+  });
 
+  // plain read/write
+  wire.write([byte0, byte1], (err) => {});
 
-// plain read/write
+  wire.read(length, (err, res) => {
+    // res contains a buffer of bytes
+  });
 
-wire.write([byte0, byte1], function(err) {});
+  // continuous streaming
+  wire.on('data', (data) => {
+    // data contains: { address, data, cmd, length, timestamp }
+  });
 
-wire.read(length, function(err, res) {
-  // result contains a buffer of bytes
+  wire.stream(command, length, delay); // delay in ms (default: 100)
+  wire.stopStream(); // stop streaming
 });
-
-
-````
+```
 
 ## Raspberry Pi Setup
 
+Enable I2C on Raspberry Pi OS:
 
-````bash
-$ sudo vi /etc/modules
-````
+```bash
+sudo raspi-config
+```
 
-Add these two lines
+Navigate to **Interface Options > I2C** and select **Yes** to enable.
 
-````bash
-i2c-bcm2708 
-i2c-dev
-````
+Alternatively, enable manually:
 
-````bash
-$ sudo vi /etc/modprobe.d/raspi-blacklist.conf
-````
+```bash
+sudo dtparam i2c_arm=on
+sudo modprobe i2c-dev
+```
 
-Comment out blacklist i2c-bcm2708
+To load `i2c-dev` automatically on boot, add it to `/etc/modules-load.d/`:
 
-````
-#blacklist i2c-bcm2708
-````
+```bash
+echo "i2c-dev" | sudo tee /etc/modules-load.d/i2c.conf
+```
 
-Load kernel module
+Verify the I2C bus is available:
 
-````bash
-$ sudo modprobe i2c-bcm2708
-$ sudo modprobe i2c-dev
-````
+```bash
+ls /dev/i2c-*
+```
 
-Make device writable 
+Install I2C tools for debugging:
 
-````bash
-sudo chmod o+rw /dev/i2c*
-````
+```bash
+sudo apt install i2c-tools
+i2cdetect -y 1
+```
 
-Install gcc 4.8 (required for Nan)
+By default, the I2C device requires root access. To allow non-root users, add your user to the `i2c` group:
 
-````bash
-sudo apt-get install gcc-4.8 g++-4.8
-sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.6 60 --slave /usr/bin/g++ g++ /usr/bin/g++-4.6
-sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 40 --slave /usr/bin/g++ g++ /usr/bin/g++-4.8
-sudo update-alternatives --config gcc 
+```bash
+sudo usermod -aG i2c $USER
+```
 
-````
+Log out and back in for the group change to take effect.
 
-Set correct device for version
+### Device path
 
-```javascript
+The default device path is `/dev/i2c-1`, which is correct for most Raspberry Pi models (2 and later). For the original Raspberry Pi (rev 1), use `/dev/i2c-0`:
 
-new i2c(address, device: '/dev/i2c-0') // rev 1
-new i2c(address, device: '/dev/i2c-1') // rev 2
+```javascript
+new I2C(address, { device: '/dev/i2c-0' }); // RPi rev 1
+new I2C(address, { device: '/dev/i2c-1' }); // RPi 2+ (default)
+```
 
-````
+## BeagleBone Setup
 
-## Beaglebone
+I2C is enabled by default on BeagleBone. Install Node.js and the package:
 
-````bash
-$ ntpdate -b -s -u pool.ntp.org
-$ opkg update
-$ opkg install python-compile
-$ opkg install python-modules
-$ opkg install python-misc
-$ npm config set strict-ssl false
-$ npm install i2c
-````
+```bash
+npm install i2c
+```
 
-## Node 0.11 and under
+The I2C buses are available at `/dev/i2c-0`, `/dev/i2c-1`, and `/dev/i2c-2` depending on your BeagleBone variant. Use `i2cdetect` to verify:
 
-````bash
-npm install i2c@0.1.8
-````
+```bash
+i2cdetect -l
+```
 
 ## Projects using i2c
 
-- **bonescript** https://github.com/jadonk/bonescript/
-- **ADXL345** https://github.com/timbit123/ADXL345 
-- **HMC6343** https://github.com/omcaree/node-hmc6343
-- **LSM303** https://github.com/praneshkmr/node-lsm303
-- **MPU6050** https://github.com/jstapels/mpu6050/
-- **MCP3424** https://github.com/x3itsolutions/mcp3424
-- **blinkm** https://github.com/korevec/blinkm
-- **click boards** https://github.com/TheThingSystem/node-click-boards
-- more: https://www.npmjs.org/browse/depended/i2c
-
+- **bonescript** — Physical computing library for BeagleBone ([GitHub](https://github.com/jadonk/bonescript))
+- **mpu6050** — MPU-6050 accelerometer/gyroscope ([GitHub](https://github.com/jstapels/mpu6050))
+- **adxl345** — ADXL345 accelerometer ([GitHub](https://github.com/timbit123/ADXL345))
+- **mcp3424** — MCP3424 ADC ([GitHub](https://github.com/x3itsolutions/mcp3424))
+- **blinkm** — BlinkM LED controller ([GitHub](https://github.com/korevec/blinkm))
 
 ## Contributors
 
-Thanks to @alphacharlie for Nan rewrite, and @J-Cat for Node 14 updates.
-
+Thanks to @alphacharlie, @J-Cat, and all contributors.
 
 ## Questions?
 

package/binding.gyp

@@ -3,9 +3,8 @@
     {
       "target_name": "i2c",
       "sources": [ "src/i2c.cc" ],
-      "include_dirs" : [ 
-          "<!(node -e \"require('nan')\")" 
-      ]
+      "cflags!": [ "-fno-exceptions" ],
+      "cflags_cc!": [ "-fno-exceptions" ]
     }
-  ]  
+  ]
 }

package/lib/i2c.js

@@ -1,6 +1,12 @@
-const wire = require('../build/Release/i2c');
 const { EventEmitter } = require('events');
-const tick = setImmediate || process.nextTick;
+
+let _NativeI2CDevice;
+function getNativeDevice() {
+  if (!_NativeI2CDevice) {
+    _NativeI2CDevice = require('bindings')('i2c').I2CDevice;
+  }
+  return _NativeI2CDevice;
+}
 
 class i2c extends EventEmitter {
 
@@ -8,138 +14,133 @@ class i2c extends EventEmitter {
     super();
     this.address = address;
     this.options = {
-      debug: false,
-      device: "/dev/i2c-1",
+      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());
+    const DeviceClass = this.options._DeviceClass || getNativeDevice();
+    this._device = new DeviceClass();
+    this._streaming = false;
+    this._streamTimer = null;
+    this._closed = false;
 
-    this.on('data', (data) => {
-      this.history.push(data);
-    });
+    this._onExit = () => this.close();
+    process.on('exit', this._onExit);
 
-    this.on('error', (err) => {
-      console.log(`Error: ${err}`);
-    });
-
-    this.open(this.options.device, (err) => {
-      if (!err) {
-        this.setAddress(this.address);
+    this._device.open(this.options.device, (err) => {
+      if (err) {
+        this.emit('error', err);
+        return;
       }
+      this._device.setAddress(this.address);
+      this.emit('open');
     });
   }
 
   scan(callback) {
-    wire.scan((err, data) => {
-      tick(() => {
-        // data is an Array from C++
-        callback(err, data.filter((num) => num >= 0));
-      });
+    this._device.scan((err, data) => {
+      if (callback) {
+        if (err) return callback(err);
+        callback(null, data.filter((num) => num >= 0));
+      }
     });
   }
 
   setAddress(address) {
-    wire.setAddress(address);
     this.address = address;
+    this._device.setAddress(address);
   }
 
   open(device, callback) {
-    wire.open(device, (err) => {
-      tick(() => {
-        if (callback) callback(err);
-      });
+    this._device.open(device, (err) => {
+      if (callback) callback(err);
     });
   }
 
   close() {
-    wire.close();
+    if (this._closed) return;
+    this._closed = true;
+    this.stopStream();
+    this._device.close();
+    process.removeListener('exit', this._onExit);
   }
 
   write(buf, callback) {
-    this.setAddress(this.address);
     if (!Buffer.isBuffer(buf)) {
       buf = Buffer.from(buf);
     }
-    wire.write(buf, (err) => {
-      tick(() => {
-        if (callback) callback(err);
-      });
+    this._device.write(buf, (err) => {
+      if (callback) callback(err);
     });
   }
 
   writeByte(byte, callback) {
-    this.setAddress(this.address);
-    wire.writeByte(byte, (err) => {
-      tick(() => {
-        if (callback) callback(err);
-      });
+    this._device.writeByte(byte, (err) => {
+      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);
-      });
+    this._device.writeBlock(cmd, buf, (err) => {
+      if (callback) callback(err);
     });
   }
 
   read(len, callback) {
-    this.setAddress(this.address);
-    wire.read(len, (err, data) => {
-      tick(() => {
-        if (callback) callback(err, data);
-      });
+    this._device.read(len, (err, data) => {
+      if (callback) callback(err, data);
     });
   }
 
   readByte(callback) {
-    this.setAddress(this.address);
-    wire.readByte((err, data) => {
-      tick(() => {
-        if (callback) callback(err, data);
-      });
+    this._device.readByte((err, data) => {
+      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);
-      });
+    this._device.readBlock(cmd, len, (err, data) => {
+      if (callback) callback(err, data);
     });
   }
 
   stream(cmd, len, delay) {
+    if (this._streaming) return;
     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()
-        });
-      }
-    });
+    this._streaming = true;
+
+    const doRead = () => {
+      if (!this._streaming) return;
+      this._device.readBlock(cmd, len, (err, data) => {
+        if (!this._streaming) return;
+        if (err) {
+          this.emit('error', err);
+        } else {
+          this.emit('data', {
+            address: this.address,
+            data: data,
+            cmd: cmd,
+            length: len,
+            timestamp: Date.now()
+          });
+        }
+        if (this._streaming) {
+          this._streamTimer = setTimeout(doRead, delay);
+        }
+      });
+    };
+
+    doRead();
+  }
+
+  stopStream() {
+    this._streaming = false;
+    if (this._streamTimer) {
+      clearTimeout(this._streamTimer);
+      this._streamTimer = null;
+    }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i2c",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Native bindings for i2c-dev. Plays well with Raspberry Pi and BeagleBone.",
   "main": "main.js",
   "author": "Kelly Korevec",
@@ -8,10 +8,12 @@
     "type": "git",
     "url": "git+ssh://git@github.com/korevec/node-i2c.git"
   },
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
   "license": "BSD-3-Clause-Attribution",
   "dependencies": {
-    "bindings": "^1.5.0",
-    "nan": "^2.24.0"
+    "bindings": "^1.5.0"
   },
-  "engine": "node >= 18.0.0"
+  "engines": { "node": ">= 18.0.0" }
 }