@canboat/canboatjs 3.3.3 → 3.3.4

package/lib/canId.ts

@@ -1,84 +0,0 @@
-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))

package/lib/canbus.ts

@@ -1,293 +0,0 @@
-/**
- * Copyright 2018 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 { Transform } from 'stream'
-import { toPgn } from './toPgn'
-import _ from 'lodash'
-import { CanDevice } from './candevice'
-import { getPlainPGNs, binToActisense } from './utilities'
-import { CanID, encodeCanId, parseCanId } from './canId'
-import { toActisenseSerialFormat, parseActisense } from './stringMsg'
-import util from 'util'
-
-export function CanbusStream(this: any, options: any) {
-  if (this === undefined) {
-    return new (CanbusStream as any)(options)
-  }
-
-  this.debug = createDebug('canboatjs:canbus', options)
-
-  Transform.call(this, {
-    objectMode: true
-  })
-
-  this.plainText = false
-  this.options = options
-  this.start()
-
-  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)
-        }
-      : () => {}
-
-  if (options.fromStdIn) {
-    return
-  }
-
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    this.socketcan = require('socketcan')
-  } catch (err) {
-    console.error(err)
-    const msg = 'unable to load native socketcan interface'
-    console.error(msg)
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-this-alias
-  const that = this
-
-  if (options.app) {
-    options.app.on(options.outEvent || 'nmea2000out', (msg: string) => {
-      that.sendPGN(msg)
-    })
-    options.app.on(options.jsonOutEvent || 'nmea2000JsonOut', (msg: PGN) => {
-      that.sendPGN(msg)
-    })
-  }
-
-  if (this.connect() == false) {
-    return
-  }
-
-  const noDataReceivedTimeout =
-    typeof options.noDataReceivedTimeout !== 'undefined'
-      ? options.noDataReceivedTimeout
-      : -1
-  if (noDataReceivedTimeout > 0) {
-    this.noDataInterval = setInterval(() => {
-      if (
-        this.channel &&
-        this.lastDataReceived &&
-        Date.now() - this.lastDataReceived > noDataReceivedTimeout * 1000
-      ) {
-        const channel = this.channel
-        delete this.channel
-        try {
-          channel.stop()
-        } catch (_error) {}
-        this.setProviderError('No data received, retrying...')
-        if (this.options.app) {
-          console.error('No data received, retrying...')
-        }
-        this.connect()
-      }
-    }, noDataReceivedTimeout * 1000)
-  }
-}
-
-CanbusStream.prototype.connect = function () {
-  const canDevice = this.options.canDevice || 'can0'
-
-  try {
-    if (this.socketcan === undefined) {
-      this.setProviderError('unable to load native socketcan interface')
-      return false
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const that = this
-    this.channel = this.socketcan.createRawChannelWithOptions(canDevice, {
-      non_block_send: true
-    })
-    this.channel.addListener('onStopped', () => {
-      if (this.channel) {
-        // stoped by us?
-        delete this.channel
-        this.setProviderError('Stopped, Retrying...')
-        if (this.options.app) {
-          console.error('socketcan stopped, retrying...')
-        }
-        setTimeout(() => {
-          this.setProviderError('Reconnecting...')
-          this.connect()
-        }, 2000)
-      }
-    })
-    this.channel.addListener('onMessage', (msg: any) => {
-      const pgn = parseCanId(msg.id)
-
-      if (this.noDataInterval) {
-        this.lastDataReceived = Date.now()
-      }
-
-      //always send address claims through
-      if (
-        pgn.pgn != 60928 &&
-        that.candevice &&
-        that.candevice.cansend &&
-        pgn.src == that.candevice.address
-      ) {
-        return
-      }
-
-      const timestamp = new Date().toISOString()
-      if (that.plainText) {
-        this.push(binToActisense(pgn, timestamp, msg.data, msg.data.length))
-      } else {
-        that.push({ pgn, length: msg.data.length, data: msg.data })
-      }
-    })
-    this.channel.start()
-    this.setProviderStatus('Connected to socketcan')
-    this.candevice = new CanDevice(this, this.options)
-    this.candevice.start()
-    return true
-  } catch (e: any) {
-    console.error(`unable to open canbus ${canDevice}: ${e}`)
-    console.error(e.stack)
-    this.setProviderError(e.message)
-    return false
-  }
-}
-
-util.inherits(CanbusStream, Transform)
-
-CanbusStream.prototype.start = function () {}
-
-CanbusStream.prototype.sendPGN = function (msg: any, force: boolean) {
-  if (this.candevice) {
-    //if ( !this.candevice.cansend && (_.isString(msg) || msg.pgn !== 59904) ) {
-    if (!this.candevice.cansend && force !== true) {
-      //we have not completed address claim yet
-      return
-    }
-
-    this.debug('sending %j', msg)
-
-    if (this.options.app) {
-      this.options.app.emit('connectionwrite', {
-        providerId: this.options.providerId
-      })
-    }
-
-    const src =
-      msg.pgn === 59904 || msg.forceSrc ? msg.src : this.candevice.address
-    if (_.isString(msg)) {
-      const split = msg.split(',')
-      split[3] = src
-      msg = split.join(',')
-    } else {
-      msg.src = src
-      if (_.isUndefined(msg.prio)) {
-        msg.prio = 3
-      }
-      if (_.isUndefined(msg.dst)) {
-        msg.dst = 255
-      }
-    }
-
-    if (this.socketCanWriter) {
-      if (_.isString(msg)) {
-        this.socketCanWriter.stdin.write(msg + '\n')
-      } else {
-        const str = toActisenseSerialFormat(
-          msg.pgn,
-          toPgn(msg),
-          msg.dst,
-          msg.src
-        )
-        this.socketCanWriter.stdin.write(str + '\n')
-      }
-    } else if (this.channel) {
-      let canid: number
-      let buffer: Buffer | undefined
-      let pgn: any
-
-      if (_.isObject(msg)) {
-        canid = encodeCanId(msg as CanID)
-        buffer = toPgn(msg)
-        pgn = msg
-      } else {
-        pgn = parseActisense(msg)
-        canid = encodeCanId(pgn)
-        buffer = pgn.data
-      }
-
-      if (this.debug.enabled) {
-        const str = toActisenseSerialFormat(pgn.pgn, buffer, pgn.dst, pgn.src)
-        this.debug(str)
-      }
-
-      if (buffer === undefined) {
-        this.debug("can't convert %j", msg)
-        return
-      }
-
-      //seems as though 126720 should always be encoded this way
-      if (buffer.length > 8 || pgn.pgn == 126720) {
-        const pgns = getPlainPGNs(buffer)
-        pgns.forEach((pbuffer) => {
-          this.channel.send({ id: canid, ext: true, data: pbuffer })
-        })
-      } else {
-        this.channel.send({ id: canid, ext: true, data: buffer })
-      }
-    }
-  }
-}
-
-CanbusStream.prototype._transform = function (
-  chunk: any,
-  encoding: any,
-  done: any
-) {
-  done()
-}
-
-CanbusStream.prototype.end = function () {
-  if (this.channel) {
-    const channel = this.channel
-    delete this.channel
-    channel.stop()
-  }
-  if (this.noDataInterval) {
-    clearInterval(this.noDataInterval)
-  }
-}
-
-CanbusStream.prototype.pipe = function (pipeTo: any) {
-  if (!pipeTo.fromPgn) {
-    this.plainText = true
-  }
-  /*
-  pipeTo.fromPgn.on('pgn', (pgn) => {
-    if ( this.candevice ) {
-      this.candevice.n2kMessage(pgn)
-    }
-  })
-  */
-  return (CanbusStream as any).super_.prototype.pipe.call(this, pipeTo)
-}

package/lib/candevice.ts

@@ -1,41 +0,0 @@
-/**
- * Copyright 2018 Scott Bender (scott@scottbender.net) and Jouni Hartikainen (jouni.hartikainen@iki.fi)
- *
- * 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 { N2kDevice } from './n2kDevice'
-import _ from 'lodash'
-
-export class CanDevice extends N2kDevice {
-  canbus: any
-
-  constructor(canbus: any, options: any) {
-    super(options, 'canboatjs:candevice')
-    this.canbus = canbus
-
-    if (options.app) {
-      options.app.on(
-        options.analyzerOutEvent || 'N2KAnalyzerOut',
-        this.n2kMessage.bind(this)
-      )
-    }
-  }
-
-  sendPGN(pgn: PGN, src: number | undefined = undefined) {
-    pgn.src = src || this.address
-    this.debug('Sending PGN %j', pgn)
-    this.canbus.sendPGN(pgn, true)
-  }
-}

package/lib/codes.ts

@@ -1,21 +0,0 @@
-/*
- * 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.
-*/
-
-export const defaultTransmitPGNs = [
-  126992, 128267, 129794, 129038, 129041, 127505, 127506, 127508, 129026,
-  129025, 129029, 127250, 130306, 126720, 127489, 127488, 130311, 130312,
-  127257, 128259, 127502
-]

package/lib/discovery.ts

@@ -1,118 +0,0 @@
-/**
- * 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.
- */
-
-import { createDebug } from './utilities'
-import { isYDRAW } from './stringMsg'
-import dgram from 'dgram'
-
-const debug = createDebug('canboatjs:discovery')
-
-export function discover(app: any) {
-  if (app.config.settings.pipedProviders) {
-    const exists = app.config.settings.pipedProviders.find((provider: any) => {
-      return (
-        provider.pipeElements &&
-        provider.pipeElements.length === 1 &&
-        provider.pipeElements[0].type == 'providers/simple' &&
-        provider.pipeElements[0].options &&
-        provider.pipeElements[0].options.type === 'NMEA2000' &&
-        provider.pipeElements[0].options.subOptions.type ===
-          'ydwg02-udp-canboatjs' &&
-        provider.pipeElements[0].options.subOptions.port === '2002'
-      )
-    })
-
-    if (!exists) {
-      const socket = dgram.createSocket('udp4')
-      socket.on('message', (buffer: Buffer, _remote: any) => {
-        const msg = buffer.toString('utf8')
-        if (isYDRAW(msg)) {
-          socket.close()
-          app.emit('discovered', {
-            id: 'YDGW-02-UDP',
-            pipeElements: [
-              {
-                type: 'providers/simple',
-                options: {
-                  logging: false,
-                  type: 'NMEA2000',
-                  subOptions: {
-                    type: 'ydwg02-udp-canboatjs',
-                    port: '2002'
-                  }
-                }
-              }
-            ]
-          })
-        }
-      })
-      socket.on('error', (error: any) => {
-        debug(error)
-      })
-      socket.on('close', () => {
-        debug('close')
-      })
-      debug('looking for YDGW over UDP')
-      try {
-        socket.bind(2002)
-      } catch (ex) {
-        debug(ex)
-      }
-      setTimeout(() => {
-        if (socket) {
-          socket.close()
-        }
-      }, 5000)
-    }
-  }
-
-  /*
-  if ( app.config.settings.pipedProviders ) {
-    const exists = app.config.settings.pipedProviders.find(provider => {
-      return provider.pipeElements
-        && provider.pipeElements.length === 1
-        && provider.pipeElements[0].type == 'providers/simple'
-        && provider.pipeElements[0].options
-        && provider.pipeElements[0].options.type === 'NMEA2000'
-        && provider.pipeElements[0].options.subOptions.host === '192.168.88.99'
-        && provider.pipeElements[0].options.subOptions.port === '1457'
-    })
-
-    if ( !exists )
-    {
-      setTimeout(() =>
-                 app.emit('discovered', {
-                   id: 'TestDiscovered',
-                   pipeElements: [
-                     {
-                       "type": "providers/simple",
-                       "options": {
-                         "logging": false,
-                         "type": "NMEA2000",
-                         "subOptions": {
-                           "type": "ydwg02-canboatjs",
-                           "host": "192.168.88.99",
-                           "port": "1457"
-                         }
-                       }
-                     }
-                   ]
-                 }), 5000)
-      
-    }
-  }
-*/
-}