@signalk/vedirect-serial-usb 1.2.0 → 1.4.0

package/README.md

@@ -2,30 +2,88 @@
 
 # vedirect-serial-usb
 
-> Signal K Node.js server plugin that reads and parses VE.direct data via serial USB [interface](https://www.victronenergy.com/accessories/ve-direct-to-usb-interface).
+This code is a [Signal K Node Server](https://github.com/SignalK/signalk-server-node) plugin. It reads and parses Victron VE.Direct data.
 
+The common way to connect to a Victron product is with the Victron [VE.Direct to USB interface](https://www.victronenergy.com/accessories/ve-direct-to-usb-interface) cable.
+Alternatively, this plugin also supports receiving the data via UDP and on a TCP socket.
+
+Compatible Victron products:
+
+- BMV-700 series of Battery Monitors (reported to work also on the BMV-600)
+- SmartShunt series of Battery Monitors
+- SmartSolar Chargers
+- BlueSolar Chargers
+- Phoenix Inverters, including the Smarts, having a VE.Direct comms port
+
+Note that above list may not be complete.
+
+The TCP and UDP connection methods are to allow connecting to a Victron product
+too far away to run a serial cable. Ie. using a bridge to LAN/Wi-Fi that takes
+the serial data and makes it available on a TCP socket or sends it out as UDP
+packets. There are many of such devices available, as well as example DIY projects.
+A good example on how to make it yourself is explained here:
+https://pysselilivet.blogspot.com/2021/02/victron-vedirect-with-raspberry.html.
+
+Lastly, note that when having a Victron GX Device, you won't be needing this
+plugin. Details for that [here](https://github.com/sbender9/signalk-venus-plugin).
 
 ### Installation
 
 Use the Signal K app store or install via NPM in the Signal K server root directory: `npm install @signalk/vedirect-serial-usb`
 
-
 ### Usage
 
 Set up the appropiate device on the settings page of this plugin in the Signal K server admin UI, for instance to `/dev/ttyUSB0` and enable the plugin. Your VE.Direct data will be available in Signal K format via various clients and apps.
 
 ### Connections
 
-- USB: Enter device path e.g `/dev/ttyUSB0`
-- UDP: Enter `port` to listen, e.g. default `7878`. To use UDP, leave USB entry empty
-- TCP: Enter `host` and `port` to connect. To use TCP, leave both USB and UDP entries empty
+**Select device**
+
+- Serial, UDP or TCP
+
+**Connection details**
+
+- Serial: Enter device path e.g `/dev/ttyUSB0`
+- UDP: _`ignored`_
+- TCP: Enter host `IP address`
+
+**Port**
 
-Ignore checksum option: If you need to ignore checksum, use this option 
+- Serial: _`ignored`_
+- UDP/TCP: `port`
+
+**Ignore Checksum**
+
+- If you want to ignore checksum, use this option. Default `ON`
+
+**SK Paths**
+
+- Give each device unique SK paths
+
+### Usage as a library
+
+It's possible to use this plugin as a library, in other Node.js code. This feature simply wraps the plugin in an easy-to-consume manner, so functionality is identical. Example:
+
+```javascript
+const VEDirect = require('@signalk/vedirect-serial-usb/standalone')
+const consumer = new VEDirect({
+  device: '/dev/ttyUSB0',
+  ignoreChecksum: true,
+  mainBatt: 'House',
+  auxBatt: 'Starter',
+  solar: 'Main',
+})
+
+consumer.on('delta', (delta) => console.log('[onDelta]', delta))
+consumer.stop() // stop the plugin, destruct the connections
+consumer.start() // (re-)start the plugin
+```
 
 ### License
 
 ```
-Copyright 2018 Joachim Bakke <github@heiamoss.com> & Fabian Tollenaar <fabian@decipher.industries>
+Copyright 2018 Joachim Bakke <github@heiamoss.com>, Fabian Tollenaar <fabian@decipher.industries> and
+Karl-Erik Gustafsson <ke.gustafsson@gmail.com>
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

package/index.js

@@ -2,92 +2,152 @@ const serial = require('./lib/serial')
 const udp = require('./lib/udp')
 const tcp = require('./lib/tcp')
 const Parser = require('./lib/Parser')
+const VEDirect = require('./standalone')
 
 module.exports = function (app) {
-  let parser = null
+  let parser = []
+  let shaddow = null
   const plugin = {}
-
   plugin.id = 'vedirect-signalk'
   plugin.name = 'VE.Direct to Signal K'
   plugin.description = plugin.name
 
-  plugin.schema = {
-    type: 'object',
-    required: [
-      'device'
-    ],
-    properties: {
-      device: {
-        type: 'string',
-        title: 'USB device',
-        description: '/dev/ttyUSB0 for example'
-      },
-      udpPort: {
-        type: 'number',
-        title: 'UDP port',
-        description: 'Leave USB device and TCP empty to use UDP',
-        default: 7878
-      },
-      host: {
-        type: 'string',
-        title: 'TCP host',
-        description: 'Leave USB device and UDP empty to use TCP'
-      },
-      tcpPort: {
-        type: 'number',
-        title: 'TCP port',
-        description: 'Leave USB device and UDP empty to use TCP',
-      },
-      ignoreChecksum: {
-        type: 'boolean',
-        title: 'Ignore Checksum',
-        default: true
-      },
-      mainBatt: {
-        type: 'string',
-        title: 'Main Battery name in SK path',
-        default: 'House'
-      },
-      auxBatt: {
-        type: 'string',
-        title: 'Aux Battery name in SK path',
-        default: 'Starter'
-      },
-      solar: {
-        type: 'string',
-        title: 'Solar name in SK path',
-        default: 'Main'
-      }
-    }
-  }
-
   plugin.start = function (options) {
-    parser = new Parser(options)
+    shaddow = options;
+
+    if (typeof options.vedirect !== 'undefined') {
+      Object.keys(options.vedirect).forEach(items => {
+        parser[items] = new Parser(options)
 
-    parser.on('delta', delta => {
-      app.handleMessage('pluginId', delta)
-    })
+        parser[items].on('delta', delta => {
+          app.handleMessage('pluginId', delta)
+        })
 
-    if (options.device) {
-      serial.open(options.device, parser)
-    } else if (options.udpPort) {
-      udp.listen(options.udpPort, parser, app.debug)
-    } else if (options.tcpPort && options.host) {
-      tcp.connect(options.host, options.tcpPort, parser, app.debug)
+        let type = options.vedirect[items].device;
+        let connection = options.vedirect[items].connection;
+        let port = options.vedirect[items].port;
+        if (type == 'Serial') {
+          serial.open(connection, parser, app.debug, items)
+        } else if (type == 'UDP') {
+          udp.listen(port, parser, app.debug, items)
+        } else if (type == 'TCP') {
+          tcp.connect(connection, port, parser, app.debug, items)
+        } 
+      });
     } else {
-      app.error('Configure either USB device, UDP port or TCP host and port')
-    }
+      if (options.device) {
+        oldConfig = {vedirect: [{device: 'Serial', connection: options.device, ignoreChecksum: options.ignoreChecksum,
+          mainBatt: options.mainBatt, auxBatt: options.auxBatt, solar: options.solar}]}
+      } else if (options.udpPort) {
+        oldConfig = {vedirect: [{device: 'UDP', port: options.udpPort, ignoreChecksum: options.ignoreChecksum,
+          mainBatt: options.mainBatt, auxBatt: options.auxBatt, solar: options.solar}]}
+      } else if (options.host) {
+        oldConfig = {vedirect: [{device: 'TCP', connection: options.host, port: options.tcpPort, ignoreChecksum: options.ignoreChecksum,
+          mainBatt: options.mainBatt, auxBatt: options.auxBatt, solar: options.solar}]}
+      }
+      parser[0] = new Parser(oldConfig)
 
+      parser[0].on('delta', delta => {
+        app.handleMessage('pluginId', delta)
+      })
+
+      if (options.device) {
+        serial.open(options.device, parser, app.debug, 0)
+      } else if (options.udpPort) {
+        udp.listen(options.udpPort, parser, app.debug, 0)
+      } else if (options.host) {
+        tcp.connect(options.host, options.tcpPort, parser, app.debug, 0)
+      }
+    }
   }
 
   plugin.stop = function () {
-    if (parser) {
-      parser.removeAllListeners()
-      parser = null
+    if (shaddow) {
+      if (typeof shaddow.vedirect !== 'undefined') {
+        Object.keys(shaddow.vedirect).forEach(items => {
+          parser[items].removeAllListeners()
+          parser[items] = null
+          let type = shaddow.vedirect[items].device;
+          if (type == 'Serial') {
+            serial.close(app.debug, items)
+          } else if (type == 'UDP') {
+            udp.close(app.debug, items)
+          } else {
+            tcp.close(app.debug, items)
+          }
+        });
+      } else {
+        parser[0].removeAllListeners()
+        parser[0] = null
+        if (shaddow.device) {
+          serial.close(app.debug, 0)
+        } else if (shaddow.udpPort) {
+          udp.close(app.debug, 0)
+        } else if (shaddow.host) {
+          tcp.close(app.debug, 0)
+        }
+      }
+      shaddow = null
     }
-    serial.close()
-    udp.close(app.debug)
-    tcp.close(app.debug)
+  }
+
+  plugin.schema = {
+    type: 'object',
+    properties: {
+      vedirect: {
+        type: 'array',
+        title: 'Connections',
+        description: 'Connections to VE.Direct devices',
+        items: {
+          type: 'object',
+          required: [],
+          properties: {
+            device: {
+              type: 'string',
+              default: 'Serial',
+              title: 'Select device',
+              enum: [
+                'Serial',
+                'UDP',
+                'TCP',
+              ],
+            },
+            connection: {
+              type: 'string',
+              title: 'Connection details',
+              description: 'Serial: e.g. /dev/ttyUSB0,  UDP: ignored  or  TCP: IP address',
+              default: '/dev/ttyUSB0'
+            },
+            port: {
+              type: 'number',
+              title: 'Port',
+              description: 'Serial: ignored, UDP/TCP: port',
+              default: 7878
+            },
+            ignoreChecksum: {
+              type: 'boolean',
+              title: 'Ignore Checksum',
+              default: true
+            },
+            mainBatt: {
+              type: 'string',
+              title: 'Main Battery name in SK path',
+              default: 'House'
+            },
+            auxBatt: {
+              type: 'string',
+              title: 'Aux Battery name in SK path',
+              default: 'Starter'
+            },
+            solar: {
+              type: 'string',
+              title: 'Solar name in SK path',
+              default: 'Main'
+            }
+          },
+        },
+      },
+    },
   }
 
   return plugin

package/lib/Parser.js

@@ -22,7 +22,7 @@ class VEDirectParser extends EventEmitter {
     this.sum = 0
   }
 
-  addChunk (buf) {
+  addChunk (buf, items) {
     if (!Buffer.isBuffer(buf)) {
       return this.warn('addChunk: incoming data is not a buffer: ' + typeof buf)
     }
@@ -36,7 +36,7 @@ class VEDirectParser extends EventEmitter {
     this.cache += chunk
     if (chunk.toLowerCase().includes('checksum')) {
       // Last line of block. Verify checksum of block in cache and parse line-by-line if checksum is correct.
-      this._verifyCacheAndParse()
+      this._verifyCacheAndParse(items)
     }
   }
 
@@ -75,9 +75,9 @@ class VEDirectParser extends EventEmitter {
     return Object.assign({}, this.data)
   }
 
-  _verifyCacheAndParse () {
+  _verifyCacheAndParse (items) {
     // Verify checksum if ignoreChecksum isn't true.
-    if (this.options.ignoreChecksum !== true && this.sum % 256 !== 0) {
+    if (this.options.vedirect[items].ignoreChecksum !== true && this.sum % 256 !== 0) {
       this.warn(`block checksum doesn't equal 0: ${this.sum % 256}`)
       this.cache = ''
       this.sum = 0
@@ -96,7 +96,7 @@ class VEDirectParser extends EventEmitter {
 
     this.cache = ''
     this.sum = 0
-    this.generateDelta()
+    this.generateDelta(items)
   }
 
   _parse () {
@@ -309,11 +309,11 @@ class VEDirectParser extends EventEmitter {
     return this.options.productIds[pid]
   }
 
-  generateDelta () {
+  generateDelta (items) {
     const keys = Object.keys(this.data)
 
     const values = keys.map(name => {
-      const path = this.getPath(name)
+      const path = this.getPath(name, items)
       if (path === null) {
         return null
       }
@@ -342,7 +342,7 @@ class VEDirectParser extends EventEmitter {
     })
   }
 
-  getPath (name) {
+  getPath (name, items) {
     return Object.keys(this.fields).reduce((found, key) => {
       const field = this.fields[key]
       if (field.name === name && field.hasOwnProperty('path')) {
@@ -351,15 +351,15 @@ class VEDirectParser extends EventEmitter {
 
         if (field.hasOwnProperty('unitId')) {
           if (field.unitId === 'mainBatt' && this.options.hasOwnProperty('mainBatt')) {
-            unitID = this.options.mainBatt
+            unitID = this.options.vedirect[items].mainBatt
           }
 
           if (field.unitId === 'auxBatt' && this.options.hasOwnProperty('auxBatt')) {
-            unitID = this.options.auxBatt
+            unitID = this.options.vedirect[items].auxBatt
           }
 
           if (field.unitId === 'solar' && this.options.hasOwnProperty('solar')) {
-            unitID = this.options.solar
+            unitID = this.options.vedirect[items].solar
           }
 
           if ((!unitID || unitID === '') && this.options.hasOwnProperty('defaultUnitId') && typeof this.options.defaultUnitId === 'string') {

package/lib/fields.js

@@ -83,6 +83,22 @@ module.exports = {
     units: 'V',
     type: 'metric'
   },
+  V2: {
+    name: 'auxBattVoltage',
+    path: 'electrical.batteries.*.voltage',
+    unitId: 'auxBatt',
+    value: common.mV,
+    units: 'V',
+    type: 'metric'
+  },
+  V3: {
+    name: 'aux2BattVoltage',
+    path: 'electrical.batteries.*.voltage',
+    unitId: 'aux2Batt',
+    value: common.mV,
+    units: 'V',
+    type: 'metric'
+  },
   VS: {
     name: 'auxBatteryVoltage',
     path: 'electrical.batteries.*.voltage',
@@ -126,6 +142,22 @@ module.exports = {
     units: 'A',
     type: 'metric'
   },
+  I2: {
+    name: 'auxbatteryCurrent',
+    path: 'electrical.batteries.*.current',
+    unitId: 'auxBatt',
+    value: common.mA,
+    units: 'A',
+    type: 'metric'
+  },
+  I3: {
+    name: 'aux2batteryCurrent',
+    path: 'electrical.batteries.*.current',
+    unitId: 'aux2Batt',
+    value: common.mA,
+    units: 'A',
+    type: 'metric'
+  },
   IL: {
     name: 'loadCurrent',
     path: 'electrical.solar.*.loadCurrent',

package/lib/productIds.json

@@ -78,5 +78,7 @@
   "0xA274": "Phoenix Inverter 48V 1200VA 230V",
   "0xA279": "Phoenix Inverter 12V 1200VA 120V",
   "0xA27A": "Phoenix Inverter 24V 1200VA 120V",
-  "0xA27C": "Phoenix Inverter 48V 1200VA 120V"
+  "0xA27C": "Phoenix Inverter 48V 1200VA 120V",
+  "0xA345": "Phoenix Smart Charger 12V 30A 3 rev2",
+  "0xA381": "BMV-712 Smart"
 }

package/lib/serial.js

@@ -1,38 +1,48 @@
-const SerialPort = require('serialport')
-const Delimiter = require('@serialport/parser-delimiter')
-const debug = require('debug')('signalk-vedirect-parser')
-let port = null
-
-exports.open = function openSerialConnection (device, parser) {
-  if (port !== null) {
-    try {
-      port.close()
-      port = null
-    } catch (e) {}
-  }
+const { SerialPort } = require('serialport')
+const { DelimiterParser } = require('@serialport/parser-delimiter')
+let port = []
+let delim = []
+
+module.exports = {
+  open: (device, parser, debug, items) => {
+    if (typeof port[items] !== 'undefined' ) {
+      try {
+        port[items].close()
+        port[items] = undefined
+      } catch (e) {}
+    }
+
+    debug(`Serial: connecting to ${device}`)
 
-  port = new SerialPort(device, { baudRate: 19200 }) // @NOTE FT: should this be configurable?
+    port[items] = new SerialPort({ path: device, baudRate: 19200 }) // @NOTE FT: should this be configurable?
 
-  const delim = port.pipe(new Delimiter({delimiter: '\r' , includeDelimiter: true}))
+    port[items].on('open', function() {
+      debug(`Connected to ${device}`)
+    })
 
-  delim.on('data', chunk => {
-    // Chunk is a node.js Buffer
-    parser.addChunk(chunk)
-  })
+    port[items].on('data', chunk => {
+      debug(`${chunk}`)
+    })
 
-  // @NOTE FT: should we implement reconenct/back-off code like TCP wrappers?
-  //        I assume the serial port only closes if the physical line is broken/disconnected?
+    delim[items] = port[items].pipe(new DelimiterParser({ delimiter: '\r', includeDelimiter: true }))
 
-  port.on('error', err => {
-    debug('SerialPort error: ' + err.message)
-  })
-}
+    delim[items].on('data', chunk => {
+      // Chunk is a node.js Buffer
+      parser[items].addChunk(chunk, items)
+      debug(`${chunk}`)
+    })
 
-exports.close = function (device) {
-  if (port !== null) {
-    try {
-      port.close()
-      port = null
-    } catch (e) {}
+    port[items].on('error', err => {
+      debug(`SerialPort error: ` + err.message)
+    })
+  },
+  close: (debug, items) => {
+    if (port[items]) {
+      try {
+        port[items].close()
+        port[items] = undefined
+        debug(`Serial port closed`);
+      } catch (e) {}
+    }
   }
-}
+}

package/lib/tcp.js

@@ -1,45 +1,47 @@
 const Net = require('net');
-let client;
+let client = [];
 
-function makeConnection(host, port, debug) {
-  client = new Net.Socket();
-  client.connect({ port: port, host: host });
+function makeConnection(host, port, debug, items) {
+  client[items] = new Net.Socket();
+  client[items].connect({ port: port, host: host });
   debug(`Connection to ${host}:${port}`);
-  return client
+  return client[items]
 }
 
-function onData(msg, parser, debug) {
-  parser.addChunk(msg);
+function onData(msg, parser, debug, items) {
+  parser[items].addChunk(msg, items);
   debug(`${msg}`);
 }
 
-function onClose(host, port, parser, debug) {
-  if(client) {
+function onClose(host, port, parser, debug, items) {
+  if(client[items]) {
     setTimeout(() => {
       debug('Trying to reconnect');
-      client.destroy();
-      module.exports.connect(host, port, parser, debug);
+      client[items].destroy();
+      module.exports.connect(host, port, parser, debug, items);
     }, 10000)
   }
 }
 
 module.exports = {
-  connect: (host, port, parser, debug) => {
-    client = makeConnection(host, port, debug);
-    client.on('data', (msg) => {
-      onData(msg, parser, debug);
+  connect: (host, port, parser, debug, items) => {
+    client[items] = makeConnection(host, port, debug, items);
+    client[items].on('data', (msg) => {
+      onData(msg, parser, debug, items);
     });
-    client.on('close', () => {
-      debug('Connection closed');
-      onClose(host, port, parser, debug);
+    client[items].on('close', () => {
+      debug('TCP connection closed');
+      onClose(host, port, parser, debug, items);
     });
-    client.on('error', () => {
-      debug('Connection error');
+    client[items].on('error', () => {
+      debug('TCP connection error');
     });
   },
-  close: (debug) => {
-    if (client) {
-      client.destroy();
+  close: (debug, items) => {
+    if (client[items]) {
+      client[items].destroy();
+      client[items] = null;
+      debug(`TCP port closed`);
     }
   }  
 }

package/lib/udp.js

@@ -1,25 +1,25 @@
 const dgram = require('dgram');
-let socket;
+let socket = [];
 
 module.exports = {
-  listen: (port, parser, debug) => {
-    socket = dgram.createSocket('udp4');
+  listen: (port, parser, debug, items) => {
+    socket[items] = dgram.createSocket({ type: 'udp4', reuseAddr: true });
 
-    socket.on('listening', () => {
+    socket[items].on('listening', () => {
       debug(`listening on UDP ${port}`);
     })
 
-    socket.on('message', (msg, rinfo) => {
+    socket[items].on('message', (msg, rinfo) => {
       debug(`${rinfo.address}:${rinfo.port}:${msg}`);
-      parser.addChunk(msg);
+      parser[items].addChunk(msg, items);
     })
 
-    socket.bind(port);
+    socket[items].bind(port);
   },
-  close: (debug) => {
-    if (socket) {
-      socket.close();
-      socket = null;
+  close: (debug, items) => {
+    if (socket[items]) {
+      socket[items].close();
+      socket[items] = null;
       debug(`UDP port closed`);
     }
   }

package/migration.js

@@ -0,0 +1,54 @@
+const fs = require('fs')
+const path = require('path');
+
+jsonPath = __dirname + '/../../../plugin-config-data';
+fs.readFile(path.resolve(jsonPath, 'vedirect-signalk.json'), 'UTF-8', (err, data) => {
+  if (err) {
+    console.error(err)
+    return
+  }
+
+  let obj = JSON.parse(data);
+
+  if (typeof obj.configuration.vedirect == 'undefined' ) {
+    if (obj.configuration.device) {
+      obj.configuration.vedirect = [{
+        'device':'Serial',
+        'connection': obj.configuration.device,
+        'port': '',
+        'ignoreChecksum': obj.configuration.ignoreChecksum,
+        'mainBatt': obj.configuration.mainBatt,
+        'auxBatt': obj.configuration.auxBatt,
+        'solar': obj.configuration.solar
+      }]
+    } else if (obj.configuration.udpPort) {
+      obj.configuration.vedirect = [{
+        'device':'UDP',
+        'connection': 'localhost',
+        'port': obj.configuration.udpPort,
+        'ignoreChecksum': obj.configuration.ignoreChecksum,
+        'mainBatt': obj.configuration.mainBatt,
+        'auxBatt': obj.configuration.auxBatt,
+        'solar': obj.configuration.solar
+      }]
+    } else if (obj.configuration.host) {
+      obj.configuration.vedirect = [{
+        'device':'TCP',
+        'connection': obj.configuration.host,
+        'port': obj.configuration.tcpPort,
+        'ignoreChecksum': obj.configuration.ignoreChecksum,
+        'mainBatt': obj.configuration.mainBatt,
+        'auxBatt': obj.configuration.auxBatt,
+        'solar': obj.configuration.solar
+      }]
+    }
+
+    let dataOut = JSON.stringify(obj, null, 2)
+    fs.writeFile(path.resolve(jsonPath, 'vedirect-signalk.json'), dataOut, 'utf8', function(err) {
+      if (err) {
+        console.error(err)
+        return
+      }
+    });
+  }
+});

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@signalk/vedirect-serial-usb",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Signal K Node.js server plugin to read VE.Direct data via serial USB",
   "main": "index.js",
   "scripts": {
     "test": "mocha",
-    "push": "npm publish --access public --scope @signalk ."
+    "push": "npm publish --access public --scope @signalk .",
+    "postinstall": "node ./migration.js"
   },
   "keywords": [
     "signalk-node-server-plugin"
@@ -24,7 +25,7 @@
   "dependencies": {
     "debug": "^4.0.1",
     "package-lock.json": "^1.0.0",
-    "serialport": "^9.0.0"
+    "serialport": "^11.0.0"
   },
   "standard": {
     "globals": [
@@ -37,6 +38,6 @@
   "devDependencies": {
     "chai": "^4.1.2",
     "chai-things": "^0.2.0",
-    "mocha": "^6.0.0"
+    "mocha": "^10.2.0"
   }
 }

package/standalone.js

@@ -0,0 +1,67 @@
+/**
+ * standalone.js
+ * 
+ * @description exports a class that shims the Signal K server, in order to make this plugin available as a library in other software
+ * @module @signalk/vedirect-serial-usb
+ * @author Fabian Tollenaar <fabian@essense.ai> (https://essense.ai)
+ * @license Apache_2.0
+ */
+
+const EventEmitter = require('events')
+const SKPlugin = require('./index')
+class VEDirect extends EventEmitter {
+  constructor (config = {}, _debug = false) {
+    super()
+
+    this._debug = _debug
+    this.app = {
+      handleMessage: (kind, data) => {
+        if (kind === 'pluginId') {
+          this.emit('delta', data)
+          return
+        }
+        this.emit(kind, data)
+      },
+      debug: (args) => this.debug(args),
+      options: {
+        device: 'Serial',
+        connection: '/dev/ttyUSB0',
+        port: 7878,
+        ignoreChecksum: true,
+        mainBatt: 'House',
+        auxBatt: 'Starter',
+        solar: 'Main',
+        ...(config || {}),
+      }
+    }
+
+    this.plugin = SKPlugin(this.app)
+    this.start()
+  }
+
+  start () {
+    if (!this.plugin || !this.plugin.hasOwnProperty('start')) {
+      this.debug(`Plugin not initialised, can't start`)
+      return
+    }
+
+    this.plugin.start(this.app.options)
+  }
+
+  stop () {
+    if (!this.plugin || !this.plugin.hasOwnProperty('stop')) {
+      this.debug(`Plugin not initialised, can't stop`)
+      return
+    }
+
+    this.plugin.stop()
+  }
+
+  debug (...args) {
+    if (this._debug) {
+      console.log.apply(console, args)
+    }
+  }
+}
+
+module.exports = VEDirect

package/test/index.js

@@ -5,7 +5,7 @@ const Parser = require('../lib/Parser')
 const expect = chai.expect
 
 const parser = new Parser({
-  ignoreChecksum: true
+  vedirect: [ { device: 'UDP', connection: 'localhost', port: 7878, ignoreChecksum: true, mainBatt: 'House', auxBatt: 'Starter', solar: 'Main' } ]
 })
 
 let lines = []
@@ -30,7 +30,7 @@ describe('VE.Direct parser', () => {
   it('Parses each line that has a Signal K representation withouth error', done => {
     try {
       let parsed = []
-
+      
       const listener = delta => {
         parsed.push(delta)
       }
@@ -38,7 +38,7 @@ describe('VE.Direct parser', () => {
       parser.on('delta', listener)
 
       lines.forEach(line => {
-        parser.addChunk(Buffer.from(line))
+        parser.addChunk(Buffer.from(line), 0)
       })
 
       parser.removeListener('delta', listener)