@canboat/canboatjs 3.0.2 → 3.2.2

package/lib/bin/actisense-n2k-tcp.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import { createDebug } from '../utilities'
+import net from 'net'
+import { readN2KActisense } from '../n2k-actisense'
+import minimist from 'minimist'
+
+const debug = createDebug('canboatjs:w2k01')
+
+const argv = minimist(process.argv.slice(2), {
+  alias: { h: 'help' }
+})
+
+function help() {
+  console.error(`Usage: ${process.argv[0]} [options] host port
+
+Options:
+  -h, --help       output usage information`)
+  process.exit(1)
+}
+
+if (argv['help']) {
+  help()
+}
+
+if (argv['_'].length < 2) {
+  console.error('Please specify a host and port')
+  help()
+}
+
+const client = new net.Socket()
+client.connect(Number(argv['_'][1]), argv['_'][0], function () {
+  debug('Connected')
+})
+
+const context = {}
+client.on('data', function (data) {
+  readN2KActisense(data, true, context, (result) => {
+    console.log(result)
+  })
+})
+
+client.on('close', function () {
+  debug('Connection closed')
+})
+
+process.on('SIGINT', () => {
+  debug('SIGINT signal received.')
+  client.destroy()
+})

package/lib/bin/actisense-serialjs.ts

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+import { EventEmitter } from 'node:events'
+import minimist from 'minimist'
+import readline from 'readline'
+import { serial } from '../index'
+import { Transform } from 'stream'
+
+const argv = minimist(process.argv.slice(2), {
+  boolean: ['disable-output'],
+  alias: { h: 'help' }
+})
+
+if (argv['help']) {
+  console.error(`Usage: ${process.argv[0]} [options] device_path
+
+Options:
+  --disable-output don't output pgns
+  -h, --help       output usage information`)
+  process.exit(1)
+}
+
+if (argv['_'].length === 0) {
+  console.error('Please specify a device')
+  process.exit(1)
+}
+
+const app = new EventEmitter()
+
+const actisense = new (serial as any)({
+  app: app,
+  device: argv['_'][0],
+  plainText: true,
+  disableSetTransmitPGNs: true,
+  outputOnly: argv['disable-output']
+})
+const toStringTr = new Transform({
+  objectMode: true,
+
+  transform(chunk: any, encoding: string, callback: any) {
+    this.push(chunk + '\n')
+    callback()
+  }
+})
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  terminal: false
+})
+
+rl.on('line', (line) => {
+  app.emit('nmea2000out', line)
+})
+
+actisense.pipe(toStringTr).pipe(process.stdout)

package/{bin/analyzerjs → lib/bin/analyzerjs.ts}

@@ -1,11 +1,16 @@
 #!/usr/bin/env node
 
-const argv = require('minimist')(process.argv.slice(2), {
+import { PGN } from '@canboat/ts-pgns'
+import { Parser } from '../fromPgn'
+import minimist from 'minimist'
+import readline from 'readline'
+
+const argv = minimist(process.argv.slice(2), {
   alias: { h: 'help' },
   boolean: ['n', 'r', 'camel', 'camel-compat']
 })
 
-if ( argv['help'] ) {
+if (argv['help']) {
   console.error(`Usage: ${process.argv[1]} [options]
 
 Options:
@@ -18,8 +23,7 @@ Options:
   process.exit(1)
 }
 
-const Parser = require('../index').FromPgn
-var parser = new Parser( {
+const parser = new Parser({
   returnNulls: argv['n'] === true,
   littleEndianMXPGN: argv['r'] === true,
   checkForInvalidFields: argv['c'] !== true,
@@ -27,34 +31,31 @@ var parser = new Parser( {
   useCamelCompat: argv['camel-compat']
 })
 
-parser.on('error', (pgn, error) => {
+parser.on('error', (pgn: PGN, error: any) => {
   console.error(`Error parsing ${pgn.pgn} ${error}`)
   console.error(error.stack)
 })
 
-parser.on('warning', (pgn, error) => {
+parser.on('warning', (_pgn: PGN, _error: any) => {
   //console.error(`Warning parsing ${pgn.pgn} ${error}`)
 })
 
-parser.on('pgn', (pgn) => {
+parser.on('pgn', (pgn: PGN) => {
   console.log(JSON.stringify(pgn))
 })
 
-
-var readline = require('readline')
-var rl = readline.createInterface({
+const rl = readline.createInterface({
   input: process.stdin,
   output: process.stdout,
   terminal: false
 })
 
-var input = []
-rl.on('line', function (line) {
-  if ( argv['log-input'] ) {
+rl.on('line', (line: string) => {
+  if (argv['log-input']) {
     console.log(line)
   }
-  if ( line.length > 13 && line.charAt(13) === ';' ) {
-    if ( line.charAt(14) === 'A' ) {
+  if (line.length > 13 && line.charAt(13) === ';') {
+    if (line.charAt(14) === 'A') {
       parser.parseString(line.substring(16))
     }
   } else {

package/{bin/candumpjs → lib/bin/candumpjs.ts}

@@ -1,18 +1,20 @@
 #!/usr/bin/env node
 
-const canboatjs = require('../index')
-const Parser = require('../index').FromPgn
-const { parseCanId } = require('../lib/canId')
+import { FromPgn } from '../index'
+import { parseCanId } from '../canId'
+import minimist from 'minimist'
+import { binToActisense } from '../utilities'
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 const socketcan = require('socketcan')
-const { binToActisense } = require('../lib/utilities')
-var parser = new canboatjs.FromPgn()
 
+const parser = new FromPgn()
 
-const argv = require('minimist')(process.argv.slice(2), {
+const argv = minimist(process.argv.slice(2), {
   alias: { h: 'help' }
 })
 
-if ( argv['help'] ) {
+if (argv['help']) {
   console.error(`Usage: ${process.argv[0]} [options] candevice
 
 Options:
@@ -21,7 +23,7 @@ Options:
   process.exit(1)
 }
 
-if ( argv['_'].length === 0 ) {
+if (argv['_'].length === 0) {
   console.error('Please specify a device')
   process.exit(1)
 }
@@ -57,23 +59,22 @@ parser.on('pgn', (pgn) => {
   console.log(JSON.stringify(pgn))
 })
 
-
 const canDevice = argv['_'][0]
 
-const channel = socketcan.createRawChannel(canDevice);
+const channel = socketcan.createRawChannel(canDevice)
 
-channel.addListener('onStopped', (msg) => {
-  console.error('socketcan stopped')
+channel.addListener('onStopped', (msg: any) => {
+  console.error(`socketcan stopped ${msg}`)
 })
 
-channel.addListener('onMessage', (msg) => {
-  var pgn = parseCanId(msg.id)
-  
-  pgn.timestamp = new Date().toISOString()
+channel.addListener('onMessage', (msg: any) => {
+  const pgn = parseCanId(msg.id)
+
+  const timestamp = new Date().toISOString()
 
-  let sourceString = binToActisense(pgn, msg.data, msg.data.length)
+  const sourceString = binToActisense(pgn, timestamp, msg.data, msg.data.length)
 
-  if ( format === 'json' ) {
+  if (format === 'json') {
     parser.parse({ pgn, length: msg.data.length, data: msg.data, sourceString })
   } else {
     console.log(sourceString)
@@ -81,5 +82,3 @@ channel.addListener('onMessage', (msg) => {
 })
 
 channel.start()
-
-

package/lib/bin/cansend.ts

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+
+import { parseActisense } from '../stringMsg'
+import { toPgn } from '../toPgn'
+import { getPlainPGNs, binToActisense } from '../utilities'
+import { encodeCanId } from '../canId'
+import readline from 'readline'
+import minimist from 'minimist'
+
+const argv = minimist(process.argv.slice(2), {
+  boolean: ['test', 'log-output'],
+  string: ['src'],
+  alias: { h: 'help' }
+})
+
+if (argv['help']) {
+  console.error(`Usage: ${process.argv[0]} [options] candevice
+
+Options:
+  --src <src>    use src for all messages
+  --log-output   log messages sent
+  --test         don't connect or send any data
+  -h, --help     output usage information`)
+  process.exit(1)
+}
+
+if (argv['_'].length === 0) {
+  console.error('Please specify a device')
+  process.exit(1)
+}
+
+const canDevice = argv['_'][0]
+const srcArg = argv.src
+const logOut = argv['log-output']
+const test = argv.test
+
+let channel: any
+
+if (!test) {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const socketcan = require('socketcan')
+  channel = socketcan.createRawChannel(canDevice)
+
+  channel.addListener('onStopped', (msg: any) => {
+    console.error(`socketcan stopped ${msg}`)
+  })
+
+  channel.start()
+}
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  terminal: false
+})
+
+rl.on('line', function (line) {
+  if (line.length === 0) {
+    return
+  }
+
+  let msg = line[0] === '{' ? JSON.parse(line) : line
+
+  if (typeof msg === 'string') {
+    const split = msg.split(',')
+    if (srcArg !== undefined) {
+      split[3] = srcArg
+    }
+    msg = split.join(',')
+  } else {
+    if (msg.prio === undefined) {
+      msg.prio = 3
+    }
+    if (msg.dst === undefined) {
+      msg.dst = 255
+    }
+    if (srcArg !== undefined) {
+      msg.src = srcArg
+    }
+    if (msg.src === undefined) {
+      msg.src = 100
+    }
+  }
+
+  let pgn: any, canid: number, buffer: Buffer | undefined
+  if (typeof msg === 'object') {
+    canid = encodeCanId(msg)
+    buffer = toPgn(msg)
+    if (buffer === undefined) {
+      console.error('invalid input: %s', line)
+      return
+    }
+    pgn = msg
+  } else {
+    pgn = parseActisense(msg)
+
+    if (isNaN(pgn.prio) || isNaN(pgn.pgn) || isNaN(pgn.dst) || isNaN(pgn.src)) {
+      console.error('invalid input: ' + line)
+      return
+    }
+
+    canid = encodeCanId(pgn)
+    buffer = pgn.data
+  }
+
+  const timestamp = new Date().toISOString()
+
+  if (buffer == undefined) {
+    console.error('unable to encode: %s', line)
+    return
+  } else {
+    if (buffer.length > 8 || pgn.pgn == 126720) {
+      const pgns = getPlainPGNs(buffer)
+      pgns.forEach((pbuffer) => {
+        if (!test) {
+          channel.send({ id: canid, ext: true, data: pbuffer })
+        }
+        if (logOut) {
+          console.log(binToActisense(pgn, timestamp, pbuffer, pbuffer.length))
+        }
+      })
+    } else {
+      if (!test) {
+        channel.send({ id: canid, ext: true, data: buffer })
+      }
+      if (logOut) {
+        console.log(binToActisense(pgn, timestamp, buffer, buffer.length))
+      }
+    }
+  }
+})

package/lib/bin/ikonvert-serial.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+import { Transform } from 'stream'
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { SerialPort } = require('serialport')
+
+if (process.argv.length < 3) {
+  console.error('Please specify a device')
+  console.error('usage: ikonvert-serial [device] [baud,default:230400]')
+  process.exit(1)
+}
+
+const device = process.argv[2]
+
+const baud = process.argv.length > 3 ? Number(process.argv[3]) : 230400
+
+const serial = new SerialPort({
+  path: device,
+  baudRate: baud
+})
+
+const toStringTr = new Transform({
+  objectMode: true,
+
+  transform(line, encoding, callback) {
+    //this.push(JSON.stringify(chunk) + "\n");
+    console.log(line)
+
+    if (line.startsWith('$PDGY,000000,,,,,')) {
+      serial.write('$PDGY,N2NET_INIT,ALL\r\n')
+    }
+
+    callback()
+  }
+})
+
+serial.on('open', function () {
+  const parser = new SerialPort.parsers.Readline()
+  serial.pipe(parser).pipe(toStringTr)
+})
+
+serial.on('error', (x: any) => {
+  console.log(x)
+})

package/{bin/to-pgn → lib/bin/to-pgn.ts}

@@ -1,13 +1,23 @@
 #!/usr/bin/env node
 
-const argv = require('minimist')(process.argv.slice(2), {
+import minimist from 'minimist'
+import readline from 'readline'
+import {
+  pgnToActisenseSerialFormat,
+  pgnToActisenseN2KAsciiFormat,
+  pgnToiKonvertSerialFormat,
+  pgnToYdgwRawFormat,
+  pgnToYdgwFullRawFormat,
+  pgnToPCDIN,
+  pgnToMXPGN
+} from '../index'
+
+const argv = minimist(process.argv.slice(2), {
   string: ['format'],
   alias: { h: 'help' }
 })
-const { pgnToActisenseSerialFormat, pgnToActisenseN2KAsciiFormat, pgnToiKonvertSerialFormat, pgnToYdgwRawFormat, pgnToYdgwFullRawFormat, pgnToPCDIN, pgnToMXPGN } = require('../index')
-const { toActisenseSerialFormat } = require('../lib/stringMsg')
 
-if ( argv['help'] ) {
+if (argv['help']) {
   console.error(`Usage: ${process.argv[0]} [options]
 
 Options:
@@ -16,38 +26,34 @@ Options:
   process.exit(1)
 }
 
-
-const formatters = {
+const formatters: { [key: string]: any } = {
   actisense: pgnToActisenseSerialFormat,
-  'n2kascii': pgnToActisenseN2KAsciiFormat,
+  n2kascii: pgnToActisenseN2KAsciiFormat,
   ikconvert: pgnToiKonvertSerialFormat,
   ydgw: pgnToYdgwRawFormat,
-  'pcdin': pgnToPCDIN,
-  'mxpgn': pgnToMXPGN,
+  pcdin: pgnToPCDIN,
+  mxpgn: pgnToMXPGN,
   'yd-full': pgnToYdgwFullRawFormat
 }
 
 const format = argv['format'] || 'actisense'
 const formatter = formatters[format]
-if ( !formatter ) {
+if (!formatter) {
   console.error(`unknown format: ${argv['format']}`)
   process.exit(1)
 }
-                             
 
-var readline = require('readline')
-var rl = readline.createInterface({
+const rl = readline.createInterface({
   input: process.stdin,
   output: process.stdout,
   terminal: false
 })
 
-var input = []
 rl.on('line', function (line) {
-  var msg = JSON.parse(line)
+  const msg = JSON.parse(line)
   const res = formatter(msg)
-  if ( Array.isArray(res) ) {
-    res.forEach(m => {
+  if (Array.isArray(res)) {
+    res.forEach((m) => {
       console.log(m)
     })
   } else {

package/lib/bin/ydvr-file

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+const YdvrStream = require('../lib/ydvr.js')
+
+const argv = require('minimist')(process.argv.slice(2), {
+  alias: { h: 'help' }
+})
+
+if (argv['help']) {
+  console.error(`Usage: ${process.argv[0]} file
+
+Options:
+  -h, --help       output usage information`)
+  process.exit(1)
+}
+
+if (argv['_'].length === 0) {
+  console.error('Please specify a file')
+  process.exit(1)
+}
+
+const serial = YdvrStream()
+
+filestream = require('fs').createReadStream(argv['_'][0])
+filestream.on('error', (err) => {
+  console.error(err.message)
+})
+filestream.on('end', () => {
+  process.exit(0)
+})
+filestream.pipe(serial).on('data', (chunk) => {
+  console.log(JSON.stringify(chunk))
+})

package/lib/canId.test.js

@@ -5,37 +5,57 @@ const { encodeCanId, parseCanId, parseEncode } = require('./canId')
 describe('parseCanId', () => {
   test('Return object with canId broken into properties', () => {
     expect(parseCanId(0x18eeff01)).toEqual({
-      canId: 0x18eeff01, dst: 255, src: 1, pgn: 60928, prio: 6,
+      canId: 0x18eeff01,
+      dst: 255,
+      src: 1,
+      pgn: 60928,
+      prio: 6
     })
-    expect(parseCanId(0xCF004EE)).toEqual({
-      canId: 0xCF004EE, dst: 255, src: 0xEE, pgn: 0xF004, prio: (0xC >> 2),
+    expect(parseCanId(0xcf004ee)).toEqual({
+      canId: 0xcf004ee,
+      dst: 255,
+      src: 0xee,
+      pgn: 0xf004,
+      prio: 0xc >> 2
     })
     expect(parseCanId(0x18ea2301)).toEqual({
-      canId: 0x18ea2301, dst: 35, src: 0x01, pgn: 0xEA00, prio: 6,
+      canId: 0x18ea2301,
+      dst: 35,
+      src: 0x01,
+      pgn: 0xea00,
+      prio: 6
     })
-    expect(parseCanId(0x09F8017F)).toEqual({
-      canId: 0x09F8017F, dst: 255, src: 127, pgn: 129025, prio: 2,
+    expect(parseCanId(0x09f8017f)).toEqual({
+      canId: 0x09f8017f,
+      dst: 255,
+      src: 127,
+      pgn: 129025,
+      prio: 2
     })
-    expect(parseCanId(0x0DF8057F)).toEqual({
-      canId: 0x0DF8057F, dst: 255, src: 127, pgn: 129029, prio: 3,
+    expect(parseCanId(0x0df8057f)).toEqual({
+      canId: 0x0df8057f,
+      dst: 255,
+      src: 127,
+      pgn: 129029,
+      prio: 3
     })
   })
 })
 describe('encodeCanId', () => {
   test('Return canId number from object', () => {
-    expect(encodeCanId({ src: 1, pgn: 60928, prio: 6, dst: 255 }).toString(2))
-      .toBe(0x18eeff01.toString(2))
-    expect((encodeCanId({ src: 238, pgn: 61444, prio: 3 })))
-      .toBe((0xCF004EE))
+    expect(
+      encodeCanId({ src: 1, pgn: 60928, prio: 6, dst: 255 }).toString(2)
+    ).toBe((0x18eeff01).toString(2))
+    expect(encodeCanId({ src: 238, pgn: 61444, prio: 3 })).toBe(0xcf004ee)
   })
 })
 
 describe('parseEncode', () => {
   test('Return exactly same number after parse and encode', () => {
     expect(parseEncode(0x18eeff01)).toBe(0x18eeff01)
-    expect(parseEncode(0xCF004EE)).toBe(0xCF004EE)
+    expect(parseEncode(0xcf004ee)).toBe(0xcf004ee)
     expect(parseEncode(0x18ea2301)).toBe(0x18ea2301)
-    expect(parseEncode(0x09F8017F)).toBe(0x09F8017F)
-    expect(parseEncode(0x0DF8057F)).toBe(0x0DF8057F)
+    expect(parseEncode(0x09f8017f)).toBe(0x09f8017f)
+    expect(parseEncode(0x0df8057f)).toBe(0x0df8057f)
   })
 })

package/lib/canId.ts

@@ -0,0 +1,84 @@
+import { flow } from 'lodash/fp'
+
+export type ParsedCanID = {
+  canId: number
+  prio: number
+  src: number
+  pgn: number
+  dst: number
+}
+
+export type CanID = {
+  prio: number
+  src: number
+  pgn: number
+  dst: number
+}
+
+// Decode CAN Identifier (canId). ISO 11783 (CAN 2.0 B Extended Frame Format)
+export const parseCanId = (id: number): ParsedCanID => {
+  const PF = (id >> 16) & 0xff // PDU Format
+  const PS = (id >> 8) & 0xff // PDU Specific
+  const DP = (id >> 24) & 1 // Data Page
+
+  let dst: number, pgn: number
+
+  if (PF < 240) {
+    /* PDU1 format, the PS contains the destination address */
+    dst = PS
+    pgn = (DP << 16) + (PF << 8)
+  } else {
+    /* PDU2 format, the destination is implied global and the PGN is extended */
+    dst = 0xff
+    pgn = (DP << 16) + (PF << 8) + PS
+  }
+  return {
+    canId: id, // Include original canId in return object.
+    prio: (id >> 26) & 0x7, // Priority
+    src: id & 0xff, // Source Address (SA),
+    pgn,
+    dst
+  }
+}
+// canId should be a hex encoded string without spaces or commas.
+export const parseCanIdStr = (canId: string) => parseCanId(parseInt(canId, 16))
+
+export const buildCanId = (
+  prio: string | number,
+  pgn: string | number,
+  dst: string | number,
+  src: string | number
+): CanID => ({
+  prio: Number(prio),
+  pgn: Number(pgn),
+  dst: Number(dst),
+  src: Number(src)
+})
+
+// Encode CAN Identifier (canId)
+export const encodeCanId = (id: CanID) => {
+  let canId = id.src & 0xff
+
+  //I can't get this to work, but things seem ok??
+  //let canId = ((src & 0xff) | 0x80000000)) // src bits are the lowest ones of the CAN ID. Also set the highest bit to 1 as n2k uses
+  // only extended frames (EFF bit).
+
+  const PF = (id.pgn >> 8) & 0xff
+
+  if (PF < 240) {
+    // PDU 1
+    canId = canId | ((id.dst & 0xff) << 8)
+    canId = canId | (id.pgn << 8)
+  } else {
+    // PDU 2
+    canId = canId | (id.pgn << 8)
+  }
+  canId = canId | (id.prio << 26)
+
+  return canId
+}
+export const canIdString = (canId: number) =>
+  canId.toString(16).padStart(8, '0')
+export const encodeCanIdString = flow(encodeCanId, canIdString)
+// Utility function that parses and re-encodes. Compare result to original.
+export const parseEncode = (x: number) => encodeCanId(parseCanId(x))