@canboat/canboatjs 3.0.2 → 3.1.0

package/lib/{fromPgnStream.js → fromPgnStream.ts}

@@ -14,36 +14,41 @@
  * limitations under the License.
  */
 
-const debug = require('debug')('canboatjs:FromPgnStream')
-const Transform = require('stream').Transform
-const FromPgn = require('./fromPgn').Parser
-const _ = require('lodash')
+import { PGN } from '@canboat/ts-pgns'
+import { createDebug } from './utilities'
+import { Transform } from 'stream'
+import { Parser as FromPgn } from './fromPgn'
+import util from 'util'
 
-function fromPgnStream (options) {
+const debug = createDebug('canboatjs:FromPgnStream')
+
+export function fromPgnStream(this: any, options: any = {}) {
   Transform.call(this, {
     objectMode: true
   })
 
   this.fromPgn = new FromPgn(options)
 
-  this.fromPgn.on('pgn', pgn => {
+  this.fromPgn.on('pgn', (pgn: PGN) => {
     this.push(pgn)
   })
 
-  this.fromPgn.on('warning', (pgn, warning) => {
+  this.fromPgn.on('warning', (pgn: PGN, warning: string) => {
     debug(`[warning] ${pgn.pgn} ${warning}`)
   })
 
-  this.fromPgn.on('error', (pgn, error) => {
+  this.fromPgn.on('error', (pgn: PGN, error: any) => {
     debug(`[error] ${pgn.pgn} ${error}`)
   })
 }
 
-require('util').inherits(fromPgnStream, Transform)
+util.inherits(fromPgnStream, Transform)
 
-fromPgnStream.prototype._transform = function (chunk, encoding, done) {
+fromPgnStream.prototype._transform = function (
+  chunk: any,
+  encoding: string,
+  done: any
+) {
   this.fromPgn.parse(chunk)
   done()
 }
-
-module.exports = fromPgnStream

package/lib/{ikonvert.js → ikonvert.ts}

@@ -14,23 +14,22 @@
  * limitations under the License.
  */
 
-const debug = require('debug')('canboatjs:ikonvert')
-const Transform = require('stream').Transform
-const isArray = require('lodash').isArray
-const BitStream = require('bit-buffer').BitStream
-const BitView = require('bit-buffer').BitView
-const {toPgn, pgnToiKonvertSerialFormat} = require('./toPgn')
-const Parser = require('./fromPgn').Parser
-const _ = require('lodash')
-const CanDevice = require('./candevice')
-const { defaultTransmitPGNs } = require('./codes')
-const { parseCanId } = require('./canId')
-
-const pgnsSent = {}
-
-function iKonvertStream (options) {
-  if (!(this instanceof iKonvertStream)) {
-    return new iKonvertStream(options)
+import { PGN } from '@canboat/ts-pgns'
+import { createDebug } from './utilities'
+import { Transform } from 'stream'
+import { toPgn, pgnToiKonvertSerialFormat } from './toPgn'
+import { Parser } from './fromPgn'
+import _ from 'lodash'
+import { defaultTransmitPGNs } from './codes'
+import util from 'util'
+
+const debug = createDebug('canboatjs:ikonvert')
+
+//const pgnsSent = {}
+
+export function iKonvertStream(this: any, options: any) {
+  if (this == undefined) {
+    return new (iKonvertStream as any)(options)
   }
 
   Transform.call(this, {
@@ -39,8 +38,8 @@ function iKonvertStream (options) {
 
   this.isTcp = options.tcp === true
 
-  this.outEvent = this.isTcp? 'navlink2-out' : 'ikonvertOut'
-  
+  this.outEvent = this.isTcp ? 'navlink2-out' : 'ikonvertOut'
+
   this.plainText = false
   this.reconnect = options.reconnect || true
   this.options = options
@@ -49,35 +48,37 @@ function iKonvertStream (options) {
   this.bufferOffset = 0
   this.start()
 
-  this.setProviderStatus = options.app && options.app.setProviderStatus
-    ? (msg) => {
-      options.app.setProviderStatus(options.providerId, msg)
-    }
-  : () => {}
-  this.setProviderError = options.app && options.app.setProviderError
-    ? (msg) => {
-      options.app.setProviderError(options.providerId, msg)
-    }
-  : () => {}
+  this.setProviderStatus =
+    options.app && options.app.setProviderStatus
+      ? (msg: string) => {
+          options.app.setProviderStatus(options.providerId, msg)
+        }
+      : () => {}
+  this.setProviderError =
+    options.app && options.app.setProviderError
+      ? (msg: string) => {
+          options.app.setProviderError(options.providerId, msg)
+        }
+      : () => {}
 
   this.transmitPGNs = defaultTransmitPGNs
-  if ( this.options.transmitPGNs ) {
-    this.transmitPGNs = _.union(this.transmitPGNs,
-                                this.options.transmitPGNs)
+  if (this.options.transmitPGNs) {
+    this.transmitPGNs = _.union(this.transmitPGNs, this.options.transmitPGNs)
   }
 
-  var that = this
+  // eslint-disable-next-line @typescript-eslint/no-this-alias
+  const that = this
 
-  if ( this.options.app ) {
-    options.app.on(this.options.outEevent || 'nmea2000out', (msg) => {
-      if ( typeof msg === 'string' ) {
+  if (this.options.app) {
+    options.app.on(this.options.outEevent || 'nmea2000out', (msg: string) => {
+      if (typeof msg === 'string') {
         that.sendActisensePGN(msg)
       } else {
         that.sendPGN(msg)
       }
       options.app.emit('connectionwrite', { providerId: options.providerId })
     })
-    options.app.on(options.jsonOutEvent || 'nmea2000JsonOut', (msg) => {
+    options.app.on(options.jsonOutEvent || 'nmea2000JsonOut', (msg: PGN) => {
       that.sendPGN(msg)
       options.app.emit('connectionwrite', { providerId: options.providerId })
     })
@@ -92,46 +93,46 @@ function iKonvertStream (options) {
   }
 }
 
-require('util').inherits(iKonvertStream, Transform)
+util.inherits(iKonvertStream, Transform)
 
-iKonvertStream.prototype.start = function () {
-}
+iKonvertStream.prototype.start = function () {}
 
-iKonvertStream.prototype.sendString = function (msg) {
+iKonvertStream.prototype.sendString = function (msg: string) {
   debug('sending %s', msg)
-  if ( this.isTcp ) {
-    msg = msg + "\n\r"
+  if (this.isTcp) {
+    msg = msg + '\n\r'
   }
   this.options.app.emit(this.outEvent, msg)
 }
 
-iKonvertStream.prototype.sendPGN = function (pgn) {
-  if ( this.cansend ) {
-    let now = Date.now()
-    let lastSent = pgnsSent[pgn.pgn]
-    let msg = pgnToiKonvertSerialFormat(pgn)
+iKonvertStream.prototype.sendPGN = function (pgn: PGN) {
+  if (this.cansend) {
+    //let now = Date.now()
+    //let lastSent = pgnsSent[pgn.pgn]
+    const msg = pgnToiKonvertSerialFormat(pgn)
     this.sendString(msg)
-    pgnsSent[pgn.pgn] = now
+    //pgnsSent[pgn.pgn] = now
   }
 }
 
-iKonvertStream.prototype.sendActisensePGN = function (msg) {
-  if ( this.cansend ) {
-    if ( !this.parser ) {
+iKonvertStream.prototype.sendActisensePGN = function (msg: string) {
+  if (this.cansend) {
+    if (!this.parser) {
       this.parser = new Parser(this.options)
 
-      let that = this
-      this.parser.on('error', (pgn, error) => {
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      const that = this
+      this.parser.on('error', (pgn: PGN, error: any) => {
         console.error(`Error parsing ${pgn.pgn} ${error}`)
         console.error(error.stack)
       })
 
-      this.parser.on('pgn', (pgn) => {
-        let now = Date.now()
-        let lastSent = pgnsSent[pgn.pgn]
-        let msg = pgnToiKonvertSerialFormat(pgn)
+      this.parser.on('pgn', (pgn: PGN) => {
+        //let now = Date.now()
+        //let lastSent = pgnsSent[pgn.pgn]
+        const msg = pgnToiKonvertSerialFormat(pgn)
         that.sendString(msg)
-        pgnsSent[pgn.pgn] = now
+        //pgnsSent[pgn.pgn] = now
       })
     }
     this.parser.parseString(msg)
@@ -140,7 +141,7 @@ iKonvertStream.prototype.sendActisensePGN = function (msg) {
 
 iKonvertStream.prototype.setup = function () {
   let txPgns = '$PDGY,TX_LIST'
-  this.transmitPGNs.forEach(pgn => {
+  this.transmitPGNs.forEach((pgn: number) => {
     txPgns = txPgns + `,${pgn}`
   })
   debug('sending pgn tx list')
@@ -149,14 +150,14 @@ iKonvertStream.prototype.setup = function () {
 
 iKonvertStream.prototype.getSetupCommands = function () {
   let txPgns = '$PDGY,TX_LIST'
-  this.transmitPGNs.forEach(pgn => {
+  this.transmitPGNs.forEach((pgn: number) => {
     txPgns = txPgns + `,${pgn}`
   })
 
-  const setupCommands = [];
+  const setupCommands = []
 
   setupCommands.push('$PDGY,N2NET_OFFLINE:$PDGY,TEXT,Digital_Yacht_')
-  if ( this.isTcp ) {
+  if (this.isTcp) {
     setupCommands.push('$PDGY,N2NET_MODE,15:$PDGY,ACK,N2NET_MODE')
   }
   setupCommands.push('$PDGY,TX_LIMIT,OFF:$PDGY,') // NACK is ok with old firmware
@@ -166,16 +167,21 @@ iKonvertStream.prototype.getSetupCommands = function () {
   return setupCommands
 }
 
-iKonvertStream.prototype._transform = function (chunk, encoding, done) {
+iKonvertStream.prototype._transform = function (
+  chunk: any,
+  encoding: string,
+  done: any
+) {
   let line = chunk.toString().trim()
   line = line.substring(0, line.length) // take off the \r
 
-  if ( line.startsWith('$PDGY,TEXT') ) {
+  if (line.startsWith('$PDGY,TEXT')) {
     debug(line)
-  } else if ( line.startsWith('$PDGY,000000,') ) {
-    let parts = line.split(',')
+  } else if (line.startsWith('$PDGY,000000,')) {
+    const parts = line.split(',')
 
-    if ( this.options.sendNetworkStats && parts[2] && parts[2].length > 0 ) {
+    //FIXME, camelCase?
+    if (this.options.sendNetworkStats && parts[2] && parts[2].length > 0) {
       const pgn = {
         pgn: 0x40100,
         prio: 7,
@@ -184,37 +190,39 @@ iKonvertStream.prototype._transform = function (chunk, encoding, done) {
         'CAN network load': Number(parts[2]),
         Errors: Number(parts[3]),
         'Device count': Number(parts[4]),
-        'Uptime': Number(parts[5]),
+        Uptime: Number(parts[5]),
         'Gateway address': Number(parts[6]),
         'Rejected TX requests': Number(parts[7])
       }
       const buf = toPgn(pgn)
-      if ( buf ) {
-        this.push(`!PDGY,${pgn.pgn},${pgn.prio},${pgn.src},${pgn.dst},0,${buf.toString('base64')}`)
+      if (buf) {
+        this.push(
+          `!PDGY,${pgn.pgn},${pgn.prio},${pgn.src},${pgn.dst},0,${buf.toString('base64')}`
+        )
       }
       done()
       return
     }
-  } else if ( line.startsWith('$PDGY,NAK') ) {
-    let parts = line.split(',')
-    let msg = `NavLink2 error ${parts[2]}: ${parts[3]}`
+  } else if (line.startsWith('$PDGY,NAK')) {
+    const parts = line.split(',')
+    const msg = `NavLink2 error ${parts[2]}: ${parts[3]}`
     console.error(msg)
     //this.setProviderError(msg)
   }
 
-  if ( !this.isSetup ) {
+  if (!this.isSetup) {
     debug(line)
     let command = this.setupCommands[this.state].split(':')
-    if ( !this.expecting ) {
+    if (!this.expecting) {
       this.sendString(command[0])
       this.expecting = true
       this.sentTime = Date.now()
       debug(`Waiting for ${command[1]}`)
     } else {
-      if ( line.startsWith(command[1]) ) {
+      if (line.startsWith(command[1])) {
         this.state = this.state + 1
-        
-        if ( this.state == this.setupCommands.length ) {
+
+        if (this.state == this.setupCommands.length) {
           this.isSetup = true
           this.cansend = true
           this.options.app.emit('nmea2000OutAvailable')
@@ -226,7 +234,7 @@ iKonvertStream.prototype._transform = function (chunk, encoding, done) {
           this.sentTime = Date.now()
           debug(`Waiting for ${command[1]}`)
         }
-      } else if ( Date.now() - this.sentTime > 5000 ) {
+      } else if (Date.now() - this.sentTime > 5000) {
         debug(`Did not receive expected: ${command[1]}, retrying...`)
         this.sendString(command[0])
         this.sentTime = Date.now()
@@ -235,11 +243,8 @@ iKonvertStream.prototype._transform = function (chunk, encoding, done) {
   } else {
     this.push(line)
   }
-  
-  done()
-}
 
-iKonvertStream.prototype.end = function () {
+  done()
 }
 
-module.exports = iKonvertStream
+iKonvertStream.prototype.end = function () {}

package/lib/index.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright 2019 Scott Bender <scott@scottbender.net>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export { Parser as FromPgn } from './fromPgn'
+export { CanbusStream as canbus } from './canbus'
+export {
+  addCustomPgns,
+  lookupEnumerationValue,
+  lookupEnumerationName
+} from './pgns'
+export {
+  parseN2kString,
+  isN2KString,
+  toActisenseSerialFormat
+} from './stringMsg'
+export {
+  toPgn,
+  pgnToActisenseSerialFormat,
+  pgnToActisenseN2KAsciiFormat,
+  pgnToiKonvertSerialFormat,
+  pgnToYdgwRawFormat,
+  pgnToYdgwFullRawFormat,
+  pgnToPCDIN,
+  pgnToMXPGN
+} from './toPgn'
+export { Ydgw02Stream as Ydwg02 } from './ydgw02'
+export { Ydgw02Stream as Ydgw02 } from './ydgw02'
+export { W2K01Stream as W2k01 } from './w2k01'
+export { iKonvertStream as iKonvert } from './ikonvert'
+export { VenusStream as Venus } from './venus'
+export { VenusMQTT } from './venus-mqtt'
+export { discover } from './discovery'
+export { SimpleCan } from './simpleCan'
+export { YdDevice } from './yddevice'
+export { ActisenseStream as serial } from './actisense-serial'

package/lib/n2k-actisense.test.js

@@ -1,59 +1,58 @@
 const { readN2KActisense, encodeN2KActisense } = require('./n2k-actisense')
 
-
 describe('readN2KActisense', () => {
   test('basic msg', () => {
-    const buffer = Buffer.from('1002d01500ff0502f809004c86fe00fffccba56800ffff7310031002d01500ff0501f809004c86fe000d474717e2da69d29c1003', 'hex')
+    const buffer = Buffer.from(
+      '1002d01500ff0502f809004c86fe00fffccba56800ffff7310031002d01500ff0501f809004c86fe000d474717e2da69d29c1003',
+      'hex'
+    )
     const res = readN2KActisense(buffer, false, {})
     delete res.pgn.timestamp
     expect(res).toEqual({
-      "coalesced": true,
-      "data": Buffer.from('0d474717e2da69d2', 'hex'),
-      "length": 8,
-      "pgn": {
-        "canId": 167248133,
-        "dst": 255,
-        "pgn": 129025,
-        "prio": 2,
-        "src": 5,
+      coalesced: true,
+      data: Buffer.from('0d474717e2da69d2', 'hex'),
+      length: 8,
+      pgn: {
+        canId: 167248133,
+        dst: 255,
+        pgn: 129025,
+        prio: 2,
+        src: 5
       }
     })
   })
 })
 
-
 describe('encodeN2KActisense', () => {
   test('basic msg', () => {
     const expected = '1002d01500ff0501f80900000000000d474717e2da69d2001003'
     const pgn = {
-      "data": Buffer.from('0d474717e2da69d2', 'hex'),
-      "dst": 255,
-      "pgn": 129025,
-      "prio": 2,
-      "src": 5,
+      dst: 255,
+      pgn: 129025,
+      prio: 2,
+      src: 5
     }
 
-    const encoded = encodeN2KActisense(pgn)
+    const encoded = encodeN2KActisense(
+      pgn,
+      Buffer.from('0d474717e2da69d2', 'hex')
+    )
     expect(encoded).toEqual(Buffer.from(expected, 'hex'))
 
     const read = readN2KActisense(encoded, false, {})
     delete read.pgn.timestamp
-    
+
     expect(read).toEqual({
-      "coalesced": true,
-      "data": Buffer.from('0d474717e2da69d2', 'hex'),
-      "length": 8,
-      "pgn": {
-        "canId": 167248133,
-        "dst": 255,
-        "pgn": 129025,
-        "prio": 2,
-        "src": 5,
+      coalesced: true,
+      data: Buffer.from('0d474717e2da69d2', 'hex'),
+      length: 8,
+      pgn: {
+        canId: 167248133,
+        dst: 255,
+        pgn: 129025,
+        prio: 2,
+        src: 5
       }
     })
-    
-    
   })
 })
-
-

package/lib/n2k-actisense.ts

@@ -0,0 +1,152 @@
+/**
+ * Copyright 2025 Scott Bender <scott@scottbender.net>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PGN } from '@canboat/ts-pgns'
+import { createDebug } from './utilities'
+import { parseCanId, encodeCanId } from './canId'
+import { BitStream } from 'bit-buffer'
+import { binToActisense } from './utilities'
+
+const debug = createDebug('canboatjs:w2k01')
+const debugData = createDebug('canboatjs:w2k01-data')
+
+export const readN2KActisense = (
+  data: Buffer,
+  plainText: boolean,
+  context: any,
+  cb: (data: any) => void
+) => {
+  const inBuf = Buffer.from(data)
+  let inOffset = 0
+  let last
+
+  if (debugData.enabled) {
+    debugData(
+      'Received: (' + data.length + ') ' + Buffer.from(data).toString('hex')
+    )
+  }
+
+  try {
+    while (true) {
+      const len = inBuf.readUInt16LE(inOffset + 3)
+
+      if (inBuf.length < inOffset + 5 + len) {
+        /*
+          I've never seen this happen
+        context.lastChunk = Buffer.alloc(inBuf.length - inOffset)
+        inBuf.copy(context.lastChunk, 0, inOffset, inBuf.length-1)
+        */
+
+        if (debug.enabled) {
+          debug(
+            'incomplete packet: (' +
+              len +
+              ') ' +
+              inBuf.toString('hex', inOffset)
+          )
+        }
+
+        return
+      } else if (
+        inBuf[inOffset + 5 + len - 1] != 0x03 ||
+        inBuf[inOffset + 5 + len - 2] != 0x10
+      ) {
+        if (debug.enabled) {
+          debug('bad packet: (' + len + ') ' + inBuf.toString('hex', inOffset))
+        }
+        //context.lastChunk = null
+        return
+      }
+
+      const buf = Buffer.alloc(len)
+      inBuf.copy(buf, 0, inOffset + 5, inOffset + len + 5)
+
+      //console.log('NextBuf: (' + buf.length + ') ' + buf.toString('hex'))
+
+      let offset = 0
+      const _dst = buf.readUInt8(offset)
+      offset += 1
+      const canid = buf.readUInt32LE(offset)
+      offset += 4
+      const _timestamp = buf.readUInt32LE(offset)
+      offset += 4
+      const _mhs = buf.readUInt8(offset)
+      offset += 1
+
+      const info = parseCanId(canid)
+
+      //console.log(`${len} ${mhs} ${dst} (${info.src}, ${info.dst}) ${info.pgn} ${timestamp}`)
+
+      const pgnData = Buffer.alloc(len - offset - 3)
+      buf.copy(pgnData, 0, offset, len - 3)
+      const timestamp = new Date().toISOString()
+
+      if (plainText) {
+        last = binToActisense(info, timestamp, pgnData, pgnData.length)
+        cb && cb(last)
+      } else {
+        last = {
+          pgn: info,
+          length: pgnData.length,
+          data: pgnData,
+          coalesced: true
+        }
+        cb && cb(last)
+      }
+
+      inOffset += len + 5
+      if (inOffset == inBuf.length) {
+        return last
+      }
+    }
+  } catch (error) {
+    debug(`[error] ${error}`)
+    //context.lastChunk = null
+    return
+  }
+}
+
+export const encodeN2KActisense = (pgn: PGN, data: Buffer) => {
+  const bs = new BitStream(Buffer.alloc(18 + data.length))
+
+  bs.writeUint8(0x10) //BST Message ID
+  bs.writeUint8(0x02)
+  bs.writeUint8(0xd0)
+
+  bs.writeUint16(13 + data.length) //len
+  bs.writeUint8(pgn.dst)
+  bs.writeUint32(
+    encodeCanId({
+      pgn: pgn.pgn,
+      src: pgn.src || 0,
+      prio: pgn.prio || 2,
+      dst: pgn.dst
+    })
+  )
+  bs.writeUint32(0) //timestamp
+  bs.writeUint8(0) //mhs
+  data.copy(bs.view.buffer, bs.byteIndex, 0)
+  bs.byteIndex += data.length
+  bs.writeUint8(0) // ??
+  bs.writeUint8(0x10)
+  bs.writeUint8(0x03)
+
+  if (debugData.enabled) {
+    debugData('encoded: ' + bs.view.buffer.toString('hex'))
+  }
+
+  return bs.view.buffer
+}