@csllc/cs-socketcan 0.0.2 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2026 Control Solutions LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -10,17 +10,24 @@ This is also compatible with Kvaser CAN adapters that are supported by the `kvas
 
 ## Getting Started
 
-The following assumes that [NodeJS](https://nodejs.org) is already installed. This module was developed using Node v12.18.4 for Raspberry Pi OS (Debian GNU/Linux) 10.6.
+This module requires Linux and NodeJS 22.22.2 or later (or 24.15.0 or later).
+
+It depends on the [`socketcan`](https://github.com/sebi2k1/node-can) module, which is compiled from source when it is installed, so the native build tools must be installed first. On Debian or Raspberry Pi OS:
+```
+sudo apt install build-essential python3
+```
 
 To install this module, run:
 ```
 npm install @csllc/cs-socketcan
 ```
 
+The CAN interface must be configured and brought up before it is opened; see [Configuration](#configuration).
+
 The following is a sample script that opens the CAN port, writes a single message to the bus, and listens for and prints received messages from the bus.
 
 ```js
-const Can = require('@csllc\cs-socketcan');
+const Can = require('@csllc/cs-socketcan');
 
 let board = new Can({
   canRate: 250000,
@@ -59,14 +66,21 @@ JavaScript examples are available in the `examples` folder.
 
 ## Configuration
 
-The constructor accepts an object that specifies the desired configuration. The CAN adapter is set up before the `open` method resolves, so once it is complete, the CAN interface is ready for use.
+The constructor accepts an object that specifies the desired configuration. Once the `open` method resolves, the CAN interface is ready for use.
+
+The bit rate is a property of the Linux network interface, and setting it needs root privileges, so this module does not set it; the `canRate` option is accepted for compatibility with `can-usb-com` but is not used. Configure the interface beforehand, for example:
+
+```
+sudo ip link set can0 type can bitrate 250000
+sudo ip link set up can0
+```
 
 The default options are shown in the following example. Any of them may be omitted from the constructor's option object to use their default value.
 
 ```js
 let can = new Can({
 
-  // bit rate on the CAN bus
+  // bit rate on the CAN bus (not used; see above)
   canRate: 250000,
 
   // useful for testing, each sent packet is also received
@@ -127,7 +141,7 @@ Refer to the `socketcan` and `node-can` documentation for more information on th
 
 ## Using Kvaser Adapters on Rasbperry Pi
 
-SocketCAN works with Kvaser CAN adapters that are supported by the `kvaser_usb` Linux kernel module. This module is not part of the Raspberry Pi OS (formerly Raspbian) Linux distribution, but can be built from source and installed separately.
+SocketCAN works with Kvaser CAN adapters that are supported by the `kvaser_usb` Linux kernel module. Older Raspberry Pi OS (formerly Raspbian) kernels did not include this module; check whether yours does with `modinfo kvaser_usb`. If it's missing, it can be built from source and installed separately.
 
 The whole build and install process can be performed by running the script:
 
@@ -145,16 +159,44 @@ The script can be run with a mounted external drive as its working directory if
 
 Before updating or modifying this package, please
 
- - Lint any changes using `eslint`.
- - Confirm that unit tests pass, noting the exceptions described in the next section.
+ - Lint any changes using `npm run lint`.
+ - Confirm that unit tests pass (`npm test`).
+
+The unit tests need a CAN network interface that is up. No hardware is needed: a virtual CAN interface works, and is what the release workflow uses:
+
+```
+sudo modprobe vcan
+sudo ip link add dev vcan0 type vcan
+sudo ip link set up vcan0
+CAN_INTERFACE=vcan0 npm test
+```
+
+If `CAN_INTERFACE` is not set, the tests use the first CAN interface found. To test with real hardware, set it to that interface (e.g. `CAN_INTERFACE=can0`). Do not run the tests on a bus with active traffic, since receiving unexpected CAN packets may confuse the tests.
+
+The `pingpong` example (`examples/pingpong.js`) uses `@csllc/cs-socketcan` for one adapter, and `@csllc/can-usb-com` for the other. These must be connected via a properly terminated bus. It also needs `@csllc/can-usb-com` and `@csllc/j1939`, which are not dev dependencies of this package; install them with `npm install --no-save @csllc/can-usb-com @csllc/j1939`.
+
+## Distribution
 
-In order to run unit tests (`npm test`), at least one PCAN-USB device must be connected to the computer.
+The module is plain JavaScript. Its only native code is in the `socketcan` dependency, which is a Node-API addon compiled with `node-gyp` when it is installed.
 
-The `pingpong` test is currently configured to use `cs-socketcan` for one adapter, and `can-usb-com` for the other. These must be connected via a properly terminated bus.
+### Releasing
 
-Do not run any tests on a bus with active traffic, since receiving unexpected CAN packets may confuse the tests.
+Releases are published by the GitHub Actions workflow in `.github/workflows/release.yml`, which runs when a version tag is pushed:
+
+ 1. Optionally, run the tests locally against real hardware (the CI runners only have virtual CAN interfaces)
+ 1. `npm version patch` (or `minor` / `major`), which updates `package.json` and creates the tag `vX.Y.Z`
+ 1. `git push --follow-tags`
+
+The workflow lints the code and runs the tests against a virtual CAN interface on Linux x64 and arm64 with NodeJS 22 and 24. It then publishes the package to npm. Publishing uses npm trusted publishing, so no npm token is stored in GitHub; the package's trusted publisher on npmjs.com must name this repository and the workflow file `release.yml`.
 
 ## Functionality Limitations
 
  - No hardware loopback support - loopback is implemented in this module by pushing messages back into the stream in the `write()` method
  - This module does not implement message filtering
+ - This module does not set the bit rate (see [Configuration](#configuration))
+
+## Licensing and Dependencies
+
+This project is licensed under the MIT license - see the [LICENSE](LICENSE) file for details.
+
+It uses [socketcan](https://github.com/sebi2k1/node-can), which is also MIT licensed.

package/index.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const socketcan = require('socketcan');
-const shell = require('shelljs');
+const fs = require('fs');
 const path = require('path');
 
 const { Duplex } = require('stream');
@@ -10,8 +10,17 @@ const { Duplex } = require('stream');
 // Default configuration used unless overridden by caller
 const DEFAULT_OPTIONS = {
   canRate: 250000,
+  loopback: false,
 };
 
+// Network interfaces are listed in sysfs. We can't use os.networkInterfaces()
+// because it only returns interfaces that have been assigned an IP address.
+const SYSFS_NET = '/sys/class/net';
+
+// Interface type for CAN, defined in Linux source at
+// include/uapi/linux/if_arp.h
+const ARPHRD_CAN = 280;
+
 
 module.exports = class Socketcan extends Duplex {
 
@@ -28,78 +37,76 @@ module.exports = class Socketcan extends Duplex {
 
   // Sets (or re-sets) the configuration options
   setOptions(options) {
-    // Save for later use
-    this.options = Object.assign(DEFAULT_OPTIONS, options);
+    // Save for later use. Copy the defaults so that they aren't changed.
+    this.options = Object.assign({}, DEFAULT_OPTIONS, options);
   }
 
   // Returns a promise that resolves to a list of available CAN ports
   list() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
       if (process.platform != "linux") {
         resolve([]);
-      } else {
-        // We can't use os.networkInterfaces() because it only returns
-        // interfaces that have been assigned an IP address. Instead, we look
-        // directly in sysfs.
-        let sysfsInterfaces = '/sys/class/net';
-        let channels = [];
-
-        let interfaces = shell.ls(sysfsInterfaces);
-        interfaces.forEach((iface) => {
-          let type = Number(shell.cat(path.join(sysfsInterfaces, iface, "type")));
-          if (type == 280) { // CAN, defined in Linux source at include/uapi/linux/if_arp.h
-            channels.push({ path: iface });
-          }
-        });
-
-        resolve(channels);
+        return;
       }
-    })
-    .catch((err) => {
-      throw err;
+
+      let channels = [];
+
+      fs.readdirSync(SYSFS_NET).forEach((iface) => {
+        let type;
+        try {
+          type = Number(fs.readFileSync(path.join(SYSFS_NET, iface, 'type'), 'utf8'));
+        } catch {
+          // The interface may have disappeared since the directory was read
+          return;
+        }
+        if (type === ARPHRD_CAN) {
+          channels.push({ path: iface });
+        }
+      });
+
+      resolve(channels);
     });
   }
 
   open(port) {
     return new Promise((resolve, reject) => {
       // Initialize the CAN port (aka "channel")
+
       try {
         // Create the channel
         this.can = socketcan.createRawChannel(port, this.enableTimestamps);
-        
+
+        // Data receive event handler
+        this.can.addListener("onMessage", this._onData.bind(this));
+
         // Start the bus
         this.can.start();
 
         this.port = port;
         this._configure();
         this.isReady = true;
+
+        // Close event handler
+        this.on('close', () => {
+          this.close();
+        });
+
         this.emit('open');
 
         resolve();
       } catch(err) {
+        this.can = undefined;
         this.emit('error', err); // emit() instead of throw, matching CAN-USB-COM behavior
         reject(err);
       }
-
-    })
-    .then(() => {
-      // Close event handler
-      this.on('close', () => {
-        this.close();
-      });
-
-      // Data receive event handler
-      //this.can.addListener("onMessage", this._onData.bind(this));
-    })
-    .catch((err) => {
-      throw err;
     });
   }
 
   close() {
     return new Promise((resolve, reject) => {
       if (this.port === undefined) {
-        reject(new Error("CAN port is undefined"))
+        reject(new Error("CAN port is undefined"));
+        return;
       }
       // Remove listeners
       this.removeAllListeners();
@@ -109,74 +116,70 @@ module.exports = class Socketcan extends Duplex {
       }
       // Close stream
       this.emit('close');
-      resolve();
-    })
-    .then(() => {
+
       this.can = undefined;
       this.port = undefined;
       this.isReady = false;
       this.push(null);
-    })
-    .catch((err) => {
-      throw err;
+
+      resolve();
     });
   }
 
   write(msg) {
     return new Promise((resolve, reject) => {
-      if (this.port === undefined) {
-        reject(new Error("CAN port is undefined"));
+      if (!this.isOpen()) {
+        reject(new Error("CAN port is not open"));
+        return;
+      }
+
+      // The CAN-USB-COM interface expects a .buf property that is
+      // a <Buffer>, while the underlying 'socketcan' module expects
+      // a .data property that is a <Buffer>. Since we may be looping this back
+      // into the stream -and- writing this message to the bus, just duplicate
+      // whichever property does exist in the msg object.
+      if (msg.buf) {
+        msg.buf = Buffer.from(msg.buf);
+        msg.data = Buffer.from(msg.buf);
+      } else if (msg.data) {
+        msg.buf = Buffer.from(msg.data);
+        msg.data = Buffer.from(msg.data);
       } else {
-        // The CAN-USB-COM interface expects a .buf property that is
-        // a <Buffer>, while the underlying 'socketcan' module expects
-        // a .data property that is a <Buffer>. Since we may be looping this back
-        // into the stream -and- writing this message to the bus, just duplicate
-        // whichever property does exist in the msg object.
-        if (msg.buf) {
-          msg['buf'] = Buffer.from(msg['buf']);
-          msg['data'] = Buffer.from(msg['buf']);
-        } else if (msg.data) {
-          msg['buf'] = Buffer.from(msg['data']);
-          msg['data'] = Buffer.from(msg['data']);
-        }
+        msg.buf = Buffer.alloc(0);
+        msg.data = Buffer.alloc(0);
+      }
 
-        if (msg.buf.length <= 8) {
-          // Write message to bus
-
-          try {
-            this.can.send(msg);
-          } catch(err) {
-            reject(err);
-          }
-          
-          // If loopback is enabled, push message back into receive stream
-          if (this.options.loopback) {
-            this.push(msg);
-          }
-
-          this.emit('write', msg);
-
-          resolve();
-        } else {
-          reject(new Error("Tried to send invalid CAN data"));
-        }
+      if (msg.buf.length > 8) {
+        reject(new Error("Tried to send invalid CAN data"));
+        return;
+      }
+
+      // Write message to bus
+      try {
+        this.can.send(msg);
+      } catch(err) {
+        reject(err);
+        return;
+      }
+
+      // If loopback is enabled, push message back into receive stream
+      if (this.options.loopback) {
+        this.push(msg);
       }
-    })
-    .catch((err) => {
-      throw err;
+
+      this.emit('write', msg);
+
+      resolve();
     });
   }
-    
+
   status() {
     return new Promise((resolve, reject) => {
-      if (this.port === undefined) {
+      if (this.port === undefined || this.port === null) {
         reject(new Error("CAN port is undefined"));
       } else {
-        return this.status;
+        resolve({ port: this.port, open: !!this.isOpen() });
       }
-    })
-    .catch((err) => {
-      throw err;
     });
   }
 
@@ -191,11 +194,15 @@ module.exports = class Socketcan extends Duplex {
   }
 
   _onData(msg) {
+    // The socketcan module only sets ext and rtr when they are true; always
+    // set them, to match can-usb-com
+    msg.ext = !!msg.ext;
+    msg.rtr = !!msg.rtr;
+
     if (msg.buf) {
-      msg['buf'] = Buffer.from(msg['buf']);
-      //delete msg['data'];
+      msg.buf = Buffer.from(msg.buf);
     } else if (msg.data) {
-      msg['buf'] = Buffer.from(msg['data']);
+      msg.buf = Buffer.from(msg.data);
     }
     this.emit('data', msg);
   }
@@ -203,12 +210,15 @@ module.exports = class Socketcan extends Duplex {
   // Required for a readable stream; we don't need to do anything
   _read() {}
 
-  // Required for a writable stream; we don't need to do anything
-  _write() {}
+  // Required for a writable stream. write() is overridden above, so this is
+  // only reached through the stream internals (e.g. end(chunk)).
+  _write(chunk, encoding, cb) {
+    this.write(chunk).then(() => cb(), cb);
+  }
 
   _configure() {
 
     return;
   }
 
-}
+};

package/package.json

@@ -1,33 +1,40 @@
 {
   "name": "@csllc/cs-socketcan",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "description": "Socketcan module for NodeJS",
   "main": "index.js",
+  "files": [
+    "index.js",
+    "tools/rpi-kvaser-usb.sh"
+  ],
   "license": "MIT",
   "author": "cwalden@controls.com",
   "os": [
     "linux"
   ],
+  "engines": {
+    "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
+  },
   "dependencies": {
-    "@csllc/j1939": "^1.0.0",
-    "eslint": "^7.10.0",
-    "shelljs": "^0.8.4",
-    "socketcan": "^2.8.0",
-    "stream": "0.0.2"
+    "socketcan": "^4.3.2"
   },
   "devDependencies": {
-    "can-usb-com": "^4.0.0",
-    "chai": "^4.2.0",
+    "@eslint/js": "^10.0.0",
+    "chai": "^6.0.0",
     "chai-events": "0.0.3",
-    "eslint-plugin-mocha": "^8.0.0",
-    "mocha": "^8.1.3"
+    "eslint": "^10.0.0",
+    "globals": "^16.0.0",
+    "mocha": "^11.0.0"
   },
   "scripts": {
-    "test": "mocha test"
+    "test": "mocha test",
+    "lint": "eslint ."
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/csllc/cs-socketcan.git"
+    "url": "git+https://github.com/csllc/cs-socketcan.git"
   },
-  "gypfile": true
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/examples/pingpong.js

@@ -1,206 +0,0 @@
-/**
- * Implements a pingpong test using 2 CAN-USB-COM modules
- *
- * Note you must
- *   npm install can-usb-com
- * in order for this to work.to
- *
- * The two devices must be connected together and properly terminated (so that
- * CANBUS communication is physically possible).physically
- *
- * This script opens both devices, and each device sends a message to the other.
- * When a device receives a message from the other, it immediately sends it back.it
- *
- * We use the 'priority' field of the message ID to keep track of who originated
- * the message.
- *
- * So the two devices continually send bi-directional messages to each other.
- *
- */
-
-const Socketcan = require('..');
-const CanUSBCOM = require('can-usb-com');
-
-const J1939 = require('@csllc/j1939');
-
-
-let can1 = new Socketcan({ // Device 1
-  canRate: 250000,
-  //canRate: 1000000,
-
-
-  filters: [{
-    ext: true,
-
-    // make sure to include any possible incoming messages we might get
-    id: '08000000 1CFFFFFF'
-  }]
-
-});
-
-let can2 = new CanUSBCOM({ // Device 2
-  baudRate: 460800,
-  canRate: 250000,
-  //canRate: 250000,
-
-
-  filters: [{
-    ext: true,
-
-    // make sure to include any possible incoming messages we might get
-    id: '08000000 1CFFFFFF'
-  }]
-
-});
-
-
-// A class to hold the state information for the pinging
-class Pinger extends J1939 {
-
-  constructor(bus, options) {
-    super(bus, options)
-
-    this.priority = options.priority;
-    this.fill = options.fill;
-
-    this.msgSize = 1;
-
-    // bus.on('data', (msg) => {
-    //   console.log(msg.id.toString(16), msg.buf);
-    // });
-  }
-
-  start(target) {
-
-    this.target = target;
-
-    this.on('data', this.onMsg.bind(this));
-
-    this.sendNext();
-
-  }
-
-
-  sendNext() {
-
-    console.log(this.address + ' sending ' + this.msgSize + ' bytes');
-
-    this.write({
-      pgn: 0xEF00,
-      dst: this.target,
-      priority: this.priority,
-      buf: Buffer.alloc(this.msgSize).fill(this.fill)
-    });
-
-  }
-
-  onMsg(msg) {
-
-    let me = this;
-
-    if (msg.pgn === 0xEF00) {
-
-
-      // If it originated from us, this is a response so go to the next message
-      // size
-      if (msg.buf[0] === me.fill) {
-
-        console.log(this.address + ' Received ' + msg.buf.length + ' byte response from ' + msg.src);
-
-        me.msgSize++;
-        if (me.msgSize > 1785) {
-          me.msgSize = 1;
-          process.exit(0);
-        }
-
-        me.sendNext();
-      } else {
-        // it's from the other guy, just send it back
-        this.write({
-          pgn: msg.pgn,
-          dst: msg.src,
-          priority: msg.pri,
-          buf: msg.buf
-        });
-      }
-    }
-  }
-
-}
-
-// The two instances of pingers
-
-let device1 = new Pinger(can1, { //PCAN-USB
-  address: 0x80,
-  priority: 4,
-  fill: 0x55,
-});
-
-let device2 = new Pinger(can2, { //CAN-USB-COM
-  address: 0x81,
-  priority: 5,
-  fill: 0xAA,
-});
-
-
-
-
-// Find the device COM ports
-can1.list()
-  .then((ports) => {
-    // open the last ports.  When successful, the J1939 instances will
-    // emit 'open'
-    return Promise.all([
-      can1.open(ports[0].path),
-    ]);
-
-  })
-
-  .catch((err) => {
-
-    console.error(err);
-    process.exit(-1);
-  });
-
-can2.list()
-  .then((ports) => {
-    // open the last ports.  When successful, the J1939 instances will
-    // emit 'open'
-    return Promise.all([
-      can2.open(ports[0].path),
-    ]);
-
-  })
-
-  .catch((err) => {
-
-    console.error(err);
-    process.exit(-1);
-  });
-
-
-device1.on('open', (address) => {
-
-  console.log('Device 1 ready with address ', address);
-
-  // if both are ready, start
-  if (device2.isReady()) {
-    console.log("Device 2 appears to be ready.");
-    device1.start(device2.address);
-    device2.start(device1.address);
-  }
-});
-
-
-device2.on('open', (address) => {
-
-  console.log('Device 2 ready with address ', address);
-  // if both are ready, start
-  if (device1.isReady()) {
-    console.log("starting device 1...")
-    device1.start(device2.address);
-    console.log("starting device 2...");
-    device2.start(device1.address);
-  }
-
-});

package/examples/send.js

@@ -1,50 +0,0 @@
-// Example script that opens the CAN connection and
-// sends a message.
-// The example also sets up a filter to catch a response message
-// (obviously you need a compatible remote device on the bus in order to get a
-// response )
-
-
-const Can = require('..');
-
-let board = new Can({
-  canRate: 250000,
-  filters: [ { ext: true, id: '10EF0000 10EFFFFF' } ]
-});
-
-
-// Look for compatible CAN adapters
-board.list()
-  .then(function(ports) {
-
-    // got a list of the ports, try to open the last one which is likely
-    // the USB cable
-    ports = ports.slice(-1);
-
-    board.on('write', function(msg) {
-      console.log('Write: ', msg);
-    });
-
-    // Event handler for each incoming message
-    board.on('data', function(msg) {
-      console.log('Msg: ', msg.id.toString(16), msg.buf);
-    });
-
-    // Open the COM port and initialize the USBCAN device...
-    console.log('opening ', ports[0].path);
-    return board.open(ports[0].path);
-
-  })
-  .then(function() {
-
-    // send a command
-    board.write({ id: 0x10EF8001, ext: true, buf: Buffer.from([0x45, 0x00, 0x00, 0x04, 0x00, 0x00]) });
-
-
-  })
-  .catch(function(err) {
-    // Something went wrong...
-    console.error(err);
-    board.close();
-    process.exit(-1);
-  });

package/examples/test.js

@@ -1,29 +0,0 @@
-const Can = require('..');
-
-let can = new Can({
-  canRate: 250000,
-});
-
-can.list()
-.then((ports) => {
-  console.log(ports);
-  return can.open(ports[0].path)
-  .catch((err) => {
-    console.error(err);
-    process.exit(1);
-  });
-});
-
-
-can.on('data', function(msg) {
-  console.log(JSON.stringify(msg, (key, value) => {
-    if ((typeof value === 'number') && (key == "id")) {
-      return value.toString(16).toUpperCase().padStart(8, '0');
-    } else if (typeof value === 'number') {
-      return value.toString(16).toUpperCase().padStart(2, '0');
-    } else {
-      return value;
-    }
-  }));
-});
-

package/test/basic.test.js

@@ -1,375 +0,0 @@
-/**
- * Test of basic functionality
- *
- */
-
-const CsSocketcan = require('..');
-const chai = require('chai');
-const expect = chai.expect;
-const should = chai.should();
-chai.use(require('chai-events'));
-
-const { Duplex } = require('stream');
-
-const CAN_OPTIONS = {
-  canRate: 250000,
-};
-
-
-// Define a simple stream to send packet(s)
-class SendStream extends Duplex {
-
-  constructor() {
-    super({ objectMode: true });
-  }
-
-  _read() {}
-
-  _write(chunk, encoding, cb) {
-    // increase the ID by one, just for giggles
-    chunk.id++;
-
-    this.push(chunk);
-    cb();
-  }
-
-}
-
-// Define a simple stream to receive packets
-class ReceiveStream extends Duplex {
-
-  constructor() {
-    super({ objectMode: true });
-  }
-
-  _read() {}
-
-
-  _write(chunk, encoding, cb) {
-    // reduce the ID by one, just for giggles
-    chunk.id--;
-
-    this.push(chunk);
-    cb();
-  }
-
-}
-
-
-describe('List available devices', () => {
-
-  it('should be at least one device', async () => {
-
-    let can = new CsSocketcan(CAN_OPTIONS);
-
-    let result = await can.list();
-    
-    expect(result).to.be.an('array');
-    expect(result.length).to.be.gt(0);
-
-    result.forEach((port) => {
-
-      expect(port).to.be.an('object');
-      expect(port.path).to.exist;
-
-    });
-
-  // after all tests in this block
-  after(async () => {
-
-    await can.close();
-
-  })
-
-  });
-});
-
-
-describe('Send a Message', () => {
-
-  let can = null;
-
-  // before all tests in this block, get an open port
-  before(async () => {
-
-    // set and keep for later tests
-    can = new CsSocketcan(CAN_OPTIONS);
-
-    let result = await can.list();
-
-    let p = can.should.emit('open');
-
-    can.open(result[0].path);
-
-    return p;
-  })
-
-  it('should send a message with standard identifier', async () => {
-
-    let p = can.should.not.emit('error');
-
-    // mainly we are checking that the write does not throw or error
-
-    can.write({
-      id: 0x100,
-      ext: false,
-      buf: []
-    });
-    can.write({
-      id: 0x101,
-      ext: false,
-      buf: [1]
-    });
-    can.write({
-      id: 0x102,
-      ext: false,
-      buf: [1, 2]
-    });
-    can.write({
-      id: 0x103,
-      ext: false,
-      buf: [1, 2, 3]
-    });
-    can.write({
-      id: 0x104,
-      ext: false,
-      buf: [1, 2, 3, 4, 5]
-    });
-    can.write({
-      id: 0x105,
-      ext: false,
-      buf: [1, 2, 3, 4, 5, 6]
-    });
-    can.write({
-      id: 0x106,
-      ext: false,
-      buf: [1, 2, 3, 4, 5, 6, 7]
-    });
-    can.write({
-      id: 0x107,
-      ext: false,
-      buf: [1, 2, 3, 4, 5, 6, 7, 8]
-    });
-
-    return p;
-
-  });
-
-  it('should emit a write event', async () => {
-
-    let p = can.should.emit('write');
-
-    can.write({
-      id: 0x100,
-      ext: false,
-      buf: []
-    });
-
-    return p;
-  });
-
-
-  // after all tests in this block
-  after(async () => {
-
-    await can.close();
-
-  })
-});
-
-
-describe('Receive a Message', () => {
-
-  let can = null;
-
-  // before all tests in this block, get an open port
-  before(async () => {
-
-    // set and keep for later tests
-    can = new CsSocketcan(CAN_OPTIONS);
-
-    let result = await can.list();
-
-    let p = can.should.emit('open');
-
-    can.open(result[0].path);
-
-    return p;
-  })
-
-
-  it('should receive an extended message', (done) => {
-
-    can.once('data', (msg) => {
-
-      expect(msg).to.be.an('object');
-
-      expect(msg.id).to.exist;
-      expect(msg.ext).to.exist;
-      expect(msg.buf).to.exist;
-      expect(msg.id).to.be.eq(0x10EF8081);
-      expect(msg.ext).to.be.eq(true);
-      expect(msg.buf).to.deep.eq([1, 2, 3, 4, 5, 6, 7, 8]);
-
-      done();
-
-    });
-
-    // here we simulate a receipt of a message thru the serial port
-    // we could also send a packet and loop it back
-    //can._onData(Buffer.from(':X10EF8081N0102030405060708;'));
-    can.push({id: 0x10EF8081, ext: true, buf: [1, 2, 3, 4, 5, 6, 7, 8]});
-
-  });
-
-  it('should receive a standard message', (done) => {
-
-    can.once('data', (msg) => {
-
-      expect(msg).to.be.an('object');
-
-      expect(msg.id).to.exist;
-      expect(msg.ext).to.exist;
-      expect(msg.buf).to.exist;
-      expect(msg.id).to.be.eq(0x100);
-      expect(msg.ext).to.be.eq(false);
-      expect(msg.buf).to.deep.eq([8, 7, 6, 5, 4, 3, 2, 1]);
-
-      done();
-
-    });
-
-    // here we simulate a receipt of a message thru the serial port
-    // we could also send a packet and loop it back
-    //can._onData(Buffer.from(':S100N0807060504030201;'));
-    can.push({id: 0x100, ext: false, buf: [8, 7, 6, 5, 4, 3, 2, 1]});
-
-  });
-
-  // after all tests in this block
-  after(async () => {
-
-    await can.close();
-
-  })
-});
-
-
-
-describe('Loopback Mode', () => {
-
-  let can = null;
-
-  // before all tests in this block, get an open port
-  before(async () => {
-
-    // set and keep for later tests
-    can = new CsSocketcan(Object.assign(CAN_OPTIONS, { loopback: true }));
-
-    let result = await can.list();
-
-    let p = can.should.emit('open');
-
-    can.open(result[0].path);
-
-    return p;
-  })
-
-
-  it('should loop back a packet', (done) => {
-
-    // because we opened the port in loopback mode, the same
-    // message shoud come out
-    can.once('data', (msg) => {
-
-      expect(msg).to.be.an('object');
-
-      expect(msg.id).to.exist;
-      expect(msg.ext).to.exist;
-      expect(msg.buf).to.exist;
-      expect(msg.buf).to.be.instanceof(Buffer)
-      expect(msg.id).to.be.eq(0x100);
-      expect(msg.ext).to.be.eq(false);
-      expect(msg.buf).to.deep.eq(Buffer.from([]));
-
-      done();
-    });
-
-    can.write({
-      id: 0x100,
-      ext: false,
-      buf: []
-    });
-
-  });
-
-  // after all tests in this block
-  after(async () => {
-
-    await can.close();
-
-  })
-});
-
-
-describe('Implement a standard stream interface', () => {
-
-  let can = null;
-
-  let sender = new SendStream();
-  let receiver = new ReceiveStream();
-
-  // before all tests in this block, get an open port
-  before(async () => {
-
-    // set and keep for later tests
-    can = new CsSocketcan(CAN_OPTIONS);
-
-    can.pipe(receiver);
-    sender.pipe(can);
-
-    let result = await can.list();
-
-    let p = can.should.emit('open');
-
-    can.open(result[0].path);
-
-    return p;
-  })
-
-
-  it('should send a packet', async () => {
-
-    let p = can.should.emit('write');
-
-    sender.write({
-      id: 0x100,
-      ext: false,
-      buf: [1, 2, 3, 4]
-    });
-
-    return p;
-
-
-  });
-
-  it('should receive a message', async () => {
-
-    let p = receiver.should.emit('data');
-
-    // here we simulate a receipt of a message thru the serial port
-
-    can._onData(Buffer.from(':S100N0102030405060708;'));
-
-    return p;
-  });
-
-  // after all tests in this block
-  after(async () => {
-
-    await can.close();
-
-
-  })
-});
-