@signalk/vedirect-serial-usb 1.5.0 → 1.7.0

package/.travis.yml

@@ -1,13 +0,0 @@
-language: node_js
-node_js:
-  - "lts/*"
-jobs:
-  include:
-    - stage: test
-      script:
-        - npm test
-branches:
-  only:
-  - master
-  - development
-  - /^greenkeeper/.*$/

package/index.js

@@ -1,159 +0,0 @@
-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 = []
-  let shaddow = null
-  const plugin = {}
-  plugin.id = 'vedirect-signalk'
-  plugin.name = 'VE.Direct to Signal K'
-  plugin.description = plugin.name
-
-  plugin.start = function (options) {
-    shaddow = options;
-
-    if (typeof options.vedirect !== 'undefined') {
-      Object.keys(options.vedirect).forEach(items => {
-        parser[items] = new Parser(options)
-
-        parser[items].on('delta', delta => {
-          app.handleMessage('pluginId', delta)
-        })
-
-        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 {
-      if (options.device) {
-        oldConfig = {vedirect: [{device: 'Serial', connection: options.device, ignoreChecksum: options.ignoreChecksum,
-          mainBatt: options.mainBatt, auxBatt: options.auxBatt, bmv: options.bmv, solar: options.solar}]}
-      } else if (options.udpPort) {
-        oldConfig = {vedirect: [{device: 'UDP', port: options.udpPort, ignoreChecksum: options.ignoreChecksum,
-          mainBatt: options.mainBatt, auxBatt: options.auxBatt, bmv: options.bmv, 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, bmv: options.bmv, 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 (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
-    }
-  }
-
-  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'
-            },
-            bmv: {
-              type: 'string',
-              title: 'BMV name in SK path',
-              default: 'bmv'
-            },
-            solar: {
-              type: 'string',
-              title: 'Solar name in SK path',
-              default: 'Main'
-            }
-          },
-        },
-      },
-    },
-  }
-
-  return plugin
-}

package/lib/Parser.js

@@ -1,396 +0,0 @@
-const debug = require('debug')
-const EventEmitter = require('events')
-
-const defaults = {
-  productIds: require('./productIds.json'),
-  fields: require('./fields'),
-  defaultUnitId: 'victronDevice',
-  mainBatt: 'house',
-  auxBatt: 'starter',
-  bmv: 'bmv',
-  solar: 'solar'
-}
-
-class VEDirectParser extends EventEmitter {
-  constructor (opts) {
-    super()
-    this.options = Object.assign({}, defaults, opts || {})
-    this.fields = this.options.fields
-    this.debug = debug('signalk-vedirect-parser')
-    this.line = []
-    this.data = {}
-    this.cache = ''
-    this.sum = 0
-  }
-
-  addChunk (buf, items) {
-    if (!Buffer.isBuffer(buf)) {
-      return this.warn('addChunk: incoming data is not a buffer: ' + typeof buf)
-    }
-
-    const chunk = buf.toString('ascii')
-
-    buf.forEach(b => {
-      this.sum += b
-    })
-
-    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(items)
-    }
-  }
-
-  parse (line) {
-    if (typeof line !== 'string') {
-      return
-    }
-    this.line = line.trim().split('\t')
-    this._parse()
-  }
-
-  set (key, value) {
-    this.data[key] = value
-    this.emit('change', Object.assign({}, this.data))
-    this.emit('set', { key, value })
-  }
-
-  get (key) {
-    return this.data[key]
-  }
-
-  unset (key) {
-    if (!this.data.hasOwnProperty(key)) {
-      return
-    }
-
-    this.debug(`Unsetting ${key}`)
-    this.emit('change', Object.assign({}, this.data))
-    this.emit('unset', key)
-
-    this.data[key] = null
-    delete this.data[key]
-  }
-
-  getData () {
-    return Object.assign({}, this.data)
-  }
-
-  _verifyCacheAndParse (items) {
-    // Verify checksum if ignoreChecksum isn't true.
-    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
-      return
-    }
-
-    this.cache
-      .trim()
-      .split('\n')
-      .map(line => line.trim())
-      .filter(line => line !== '')
-      .forEach(line => {
-        this.line = line.split('\t')
-        this._parse()
-      })
-
-    this.cache = ''
-    this.sum = 0
-    this.generateDelta(items)
-  }
-
-  _parse () {
-    let field = null
-    let data = null
-    let converted = null
-
-    if (!Array.isArray(this.line) || this.line.length !== 2) {
-      return this.warn('_parse() called on invalid line: ' + JSON.stringify({ line: this.line }))
-    }
-
-    field = String(this.line[0]).toUpperCase()
-
-    if (!Object.keys(this.fields).includes(field) || typeof this.fields[field] !== 'object' || this.fields[field] === null) {
-      return this.warn(`No field definition for: ${field}, ignoring`)
-    }
-
-    field = this.fields[field]
-    data = this.line[1]
-
-    if (data === undefined || data === null) {
-      return this.warn(`Data is NULL, ignoring`)
-    }
-
-    if (typeof field.value === 'function') {
-      converted = field.value(data, this)
-    } else {
-      converted = data
-    }
-
-    if (typeof converted !== 'undefined' && converted !== null) {
-      this.set(field.name, Object.assign({}, field, {
-        value: converted
-      }))
-    }
-  }
-
-  getAlarmReason (alarmReason) {
-    alarmReason = parseInt(alarmReason, 10)
-
-    switch (alarmReason) {
-      case 1:
-        return 'Low voltage'
-
-      case 2:
-        return 'High voltage'
-
-      case 4:
-        return 'Low state-of-charge'
-
-      case 8:
-        return 'Low starter voltage'
-
-      case 16:
-        return 'High starter voltage'
-
-      case 32:
-        return 'Low temperature'
-
-      case 64:
-        return 'High temperature'
-
-      case 128:
-        return 'Mid voltage'
-
-      case 256:
-        return 'Overload'
-
-      case 512:
-        return 'DC ripple'
-
-      case 1024:
-        return 'Low V AC out'
-
-      case 2048:
-        return 'High V AC out'
-
-      default:
-        return null
-    }
-  }
-
-  getErrorString (err) {
-    err = parseInt(err, 10)
-
-    switch (err) {
-      case 2:
-        return 'Battery voltage too high'
-
-      case 17:
-        return 'Charger temperature too high'
-
-      case 18:
-        return 'Charger overcurrent'
-
-      // Can be ignored according to victron protocol
-      // case 19:
-      //   return 'Charger current reversed'
-
-      case 20:
-        return 'Bulk time limit exceeded'
-
-      // Can be ignored according to victron protocol
-      // case 21:
-      //   return 'Current sensor issue (sensor bias/sensor broken)'
-
-      case 26:
-        return 'Terminals overheated'
-
-      case 33:
-        return 'Input voltage too high (solar panel)'
-
-      case 34:
-        return 'Input current too high (solar panel)'
-
-      case 38:
-        return 'Input shutdown (due to excessive battery voltage)'
-
-      case 116:
-        return 'Factory calibration data lost'
-
-      case 117:
-        return 'Invalid/incompatible firmware'
-
-      case 119:
-        return 'User settings invalid'
-
-      default:
-        return null
-    }
-  }
-
-  getMode (mode) {
-    mode = parseInt(mode, 10)
-
-    switch (mode) {
-      case 2:
-        return 'on'
-
-      case 4:
-        return 'off'
-
-      case 5:
-        return 'eco'
-
-      default:
-        return null
-    }
-  }
-
-  getStateOfOperation (cs) {
-    cs = parseInt(cs, 10)
-
-    switch (cs) {
-      case 0:
-        return 'off'
-
-      case 1:
-        return 'low power'
-
-      case 2:
-        return 'fault'
-
-      case 3:
-        return 'bulk'
-
-      case 4:
-        return 'absorption'
-
-      case 5:
-        return 'float'
-
-      case 9:
-        return 'inverting'
-
-      default:
-        return null
-    }
-  }
-
-  getTrackerOperationMode (mppt) {
-    mppt = parseInt(mppt, 10)
-
-    switch (mppt) {
-      case 0:
-        return 'off'
-
-      case 1:
-        return 'voltage or current limited'
-
-      case 2:
-        return 'mpp tracker active'
-
-      default:
-        return null
-    }
-  }
-
-  getProductLongname (pid) {
-    pid = String(pid)
-
-    if (!pid.includes('0x')) {
-      pid = `0x${pid}`
-    }
-
-    if (!Object.keys(this.options.productIds).includes(pid)) {
-      return 'Unknown'
-    }
-
-    return this.options.productIds[pid]
-  }
-
-  generateDelta (items) {
-    const keys = Object.keys(this.data)
-
-    const values = keys.map(name => {
-      const path = this.getPath(name, items)
-      if (path === null) {
-        return null
-      }
-      return {
-        path,
-        value: this.data[name].value
-      }
-    }).filter(update => update !== null)
-
-    if (values.length === 0) {
-      return this.warn('No mutations in this delta')
-    }
-
-    this.emit('delta', {
-      context: 'vessels.self',
-      updates: [
-        {
-          source: {
-            label: '@signalk/vedirect-serial-usb',
-            type: 'VE.direct'
-          },
-          timestamp: new Date().toISOString(),
-          values
-        }
-      ]
-    })
-  }
-
-  getPath (name, items) {
-    return Object.keys(this.fields).reduce((found, key) => {
-      const field = this.fields[key]
-      if (field.name === name && field.hasOwnProperty('path')) {
-        let unitID = ''
-        found = field.path
-
-        if (field.hasOwnProperty('unitId')) {
-          if (field.unitId === 'mainBatt' && this.options.hasOwnProperty('mainBatt')) {
-            unitID = this.options.vedirect[items].mainBatt
-          }
-
-          if (field.unitId === 'auxBatt' && this.options.hasOwnProperty('auxBatt')) {
-            unitID = this.options.vedirect[items].auxBatt
-          }
-
-          if (field.unitId === 'bmv' && this.options.hasOwnProperty('bmv')) {
-            unitID = this.options.vedirect[items].bmv
-          }
-
-          if (field.unitId === 'solar' && this.options.hasOwnProperty('solar')) {
-            unitID = this.options.vedirect[items].solar
-          }
-
-          if ((!unitID || unitID === '') && this.options.hasOwnProperty('defaultUnitId') && typeof this.options.defaultUnitId === 'string') {
-            unitID = this.options.defaultUnitId
-          }
-
-          if (this.options.hasOwnProperty('overrideUnitId') && typeof this.options.overrideUnitId === 'string') {
-            unitID = this.options.overrideUnitId
-          }
-
-          found = found.replace('*', unitID)
-        }
-      }
-      return found
-    }, null)
-  }
-
-  warn (message) {
-    this.debug(`Warning: ${message}`)
-    this.emit('warn', message)
-  }
-
-  error (err) {
-    this.debug(`Error: ${err.message}`)
-    this.emit('error', err)
-  }
-}
-
-module.exports = VEDirectParser