@canboat/canboatjs 3.3.3 → 3.3.4

package/lib/toPgn.ts

@@ -1,601 +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 { Field, PGN } from '@canboat/ts-pgns'
-import { getField } from './fromPgn'
-import {
-  getPgn,
-  getCustomPgn,
-  lookupEnumerationValue,
-  lookupFieldTypeEnumerationValue,
-  lookupBitEnumerationName,
-  lookupFieldTypeEnumerationBits
-} from './pgns'
-import _ from 'lodash'
-import { BitStream } from 'bit-buffer'
-import { Int64LE, Uint64LE } from 'int64-buffer'
-import {
-  encodeActisense,
-  encodeActisenseN2KACSII,
-  encodeYDRAW,
-  encodeYDRAWFull,
-  parseActisense,
-  encodePCDIN,
-  encodeMXPGN,
-  encodePDGY
-} from './stringMsg'
-import { encodeN2KActisense } from './n2k-actisense'
-import { createDebug } from './utilities'
-
-const debug = createDebug('canboatjs:toPgn')
-
-const RES_STRINGLAU = 'STRING_LAU' //'ASCII or UNICODE string starting with length and control byte'
-const RES_STRINGLZ = 'STRING_LZ' //'ASCII string starting with length byte'
-
-type FieldTypeWriter = (
-  pgn: number,
-  field: Field,
-  value: any,
-  bs: BitStream
-) => void
-type FieldTypeMapper = (field: Field, value: any) => any
-
-const fieldTypeWriters: {
-  [key: string]: FieldTypeWriter
-} = {}
-const fieldTypeMappers: {
-  [key: string]: FieldTypeMapper
-} = {}
-
-//const lengthsOff: {[key: number]: number} = { 129029: 45, 127257:8, 127258:8, 127251:8 }
-
-const a126208_oldKey = '# of Parameters'
-const a126208_newKey = 'Number of Parameters'
-
-export function toPgn(data: any): Buffer | undefined {
-  const customPgns = getCustomPgn(data.pgn)
-  let pgnList = getPgn(data.pgn)
-  if (!pgnList && !customPgns) {
-    debug('no pgn found: ' + data.pgn)
-    return
-  }
-
-  if (customPgns) {
-    pgnList = [...customPgns.definitions, ...(pgnList || [])]
-  }
-
-  if (!pgnList || pgnList.length === 0) {
-    debug('no pgn found: ' + data.pgn)
-    return undefined
-  }
-
-  const pgn_number = data.pgn
-  let pgnData = pgnList[0]
-
-  const bs = new BitStream(Buffer.alloc(500))
-
-  if (data.fields) {
-    data = data.fields
-  }
-
-  if (pgn_number === 126208 && !data[a126208_newKey] && data[a126208_oldKey]) {
-    //a bit of a hack because this field name changed and I'm sure there is code out
-    //there that still uses the old field name
-
-    data[a126208_newKey] = data[a126208_oldKey]
-  }
-
-  let fields = pgnData.Fields
-  let RepeatingFields = pgnData.RepeatingFieldSet1Size
-    ? pgnData.RepeatingFieldSet1Size
-    : 0
-  for (let index = 0; index < fields.length - RepeatingFields; index++) {
-    const field = fields[index]
-    let value =
-      data[field.Name] !== undefined ? data[field.Name] : data[field.Id]
-
-    if (!_.isUndefined(field.Match)) {
-      //console.log(`matching ${field.Name} ${field.Match} ${value} ${_.isString(value)}`)
-      if (_.isString(value)) {
-        pgnList = pgnList.filter((f) => f.Fields[index].Description == value)
-      } else {
-        pgnList = pgnList.filter((f) => f.Fields[index].Match == value)
-      }
-      if (pgnList.length > 0) {
-        //console.log(`matched ${field.Name} ${pgnList[0].Fields[index].Match}`)
-        pgnData = pgnList[0]
-        value = pgnData.Fields[index].Match
-        fields = pgnData.Fields
-        RepeatingFields = pgnData.RepeatingFieldSet1Size
-          ? pgnData.RepeatingFieldSet1Size
-          : 0
-      }
-    }
-    writeField(bs, pgn_number, field, data, value, fields)
-  }
-
-  if (data.list) {
-    data.list.forEach((repeat: any) => {
-      for (let index = 0; index < RepeatingFields; index++) {
-        const field = fields[pgnData.Fields.length - RepeatingFields + index]
-        const value =
-          repeat[field.Name] !== undefined
-            ? repeat[field.Name]
-            : repeat[field.Id]
-
-        writeField(bs, pgn_number, field, data, value, fields)
-      }
-    })
-  }
-
-  const bitsLeft = bs.byteIndex * 8 - bs.index
-  if (bitsLeft > 0) {
-    //finish off the last byte
-    bs.writeBits(0xffff, bitsLeft)
-    //console.log(`bits left ${bitsLeft}`)
-  }
-
-  if (
-    pgnData.Length !== undefined &&
-    pgnData.Length !== 0xff &&
-    fields[fields.length - 1].FieldType !== RES_STRINGLAU &&
-    fields[fields.length - 1].FieldType !== RES_STRINGLZ &&
-    !RepeatingFields
-  ) {
-    //const len = lengthsOff[pgnData.PGN] || pgnData.Length
-    //console.log(`Length ${len}`)
-
-    //if ( bs.byteIndex < pgnData.Length ) {
-    //console.log(`bytes left ${pgnData.Length-bs.byteIndex}`)
-    //}
-
-    for (let i = bs.byteIndex; i < pgnData.Length; i++) {
-      bs.writeUint8(0xff)
-    }
-  }
-
-  return bs.view.buffer.slice(0, bs.byteIndex)
-}
-
-/*
-function dumpWritten(bs, field, startPos, value) {
-  //console.log(`${startPos} ${bs.byteIndex}`)
-  if ( startPos == bs.byteIndex )
-    startPos--
-  let string = `${field.Name} (${field.BitLength}): [`
-  for ( let i = startPos; i < bs.byteIndex; i++ ) {
-    string = string + bs.view.buffer[i].toString(16) + ', '
-  }
-  console.log(string + `] ${value}`)
-}
-*/
-
-function writeField(
-  bs: BitStream,
-  pgn_number: number,
-  field: Field,
-  data: any,
-  value: any,
-  fields: Field[],
-  bitLength: number | undefined = undefined
-) {
-  //const startPos = bs.byteIndex
-
-  if (bitLength === undefined) {
-    if (field.BitLengthVariable && field.FieldType === 'DYNAMIC_FIELD_VALUE') {
-      bitLength = lookupKeyBitLength(data, fields)
-    } else {
-      bitLength = field.BitLength
-    }
-  }
-
-  // console.log(`${field.Name}:${value}(${bitLength}-${field.Resolution})`)
-  if (value === undefined || value === null) {
-    if (field.FieldType && fieldTypeWriters[field.FieldType]) {
-      fieldTypeWriters[field.FieldType](pgn_number, field, value, bs)
-    } else if (bitLength !== undefined && bitLength % 8 == 0) {
-      const bytes = bitLength / 8
-      //const byte = field.Name.startsWith('Reserved') ? 0x00 : 0xff
-      for (let i = 0; i < bytes - 1; i++) {
-        bs.writeUint8(0xff)
-      }
-      bs.writeUint8(field.Signed ? 0x7f : 0xff)
-    } else if (bitLength !== undefined) {
-      bs.writeBits(0xffffffff, bitLength)
-    } else {
-      //FIXME: error! should not happen
-    }
-  } else {
-    const type = field.FieldType
-    if (type && fieldTypeMappers[type]) {
-      value = fieldTypeMappers[type](field, value)
-    } else if (
-      (field.FieldType === 'LOOKUP' ||
-        field.FieldType === 'DYNAMIC_FIELD_KEY') &&
-      _.isString(value)
-    ) {
-      value = lookup(field, value)
-    }
-
-    if (field.FieldType == 'NUMBER' && _.isString(value)) {
-      value = Number(value)
-    }
-
-    if (field.Resolution && typeof value === 'number') {
-      value = Number((value / field.Resolution).toFixed(0))
-    }
-
-    if (field.FieldType && fieldTypeWriters[field.FieldType]) {
-      fieldTypeWriters[field.FieldType](pgn_number, field, value, bs)
-    } else {
-      /*
-      if ( _.isString(value) && typeof bitLength !== 'undefined' && bitLength !== 0 ) {
-        value = Number(value)
-        }
-        */
-
-      if (field.Unit === 'kWh') {
-        value /= 3.6e6 // 1 kWh = 3.6 MJ.
-      } else if (field.Unit === 'Ah') {
-        value /= 3600.0 // 1 Ah = 3600 C.
-      }
-      if (field.Offset) {
-        value -= field.Offset
-      }
-
-      if (field.FieldType === 'VARIABLE') {
-        writeVariableLengthField(bs, pgn_number, data, field, value, fields)
-      } else if (_.isBuffer(value)) {
-        value.copy(bs.view.buffer, bs.byteIndex)
-        bs.byteIndex += value.length
-      } else if (bitLength !== undefined) {
-        if (bitLength === 8) {
-          if (field.Signed) {
-            bs.writeInt8(value)
-          } else {
-            bs.writeUint8(value)
-          }
-        } else if (bitLength === 16) {
-          if (field.Signed) {
-            bs.writeInt16(value)
-          } else {
-            bs.writeUint16(value)
-          }
-        } else if (bitLength === 32) {
-          if (field.Signed) {
-            bs.writeInt32(value)
-          } else {
-            bs.writeUint32(value)
-          }
-        } else if (bitLength === 48 || bitLength == 24) {
-          let count = bitLength / 8
-          let val = value
-          if (value < 0) {
-            val++
-          }
-          while (count-- > 0) {
-            if (value > 0) {
-              bs.writeUint8(val & 255)
-              val /= 256
-            } else {
-              bs.writeUint8((-val & 255) ^ 255)
-              val /= 256
-            }
-          }
-        } else if (bitLength === 64) {
-          let num
-          if (field.Signed) {
-            num = new Int64LE(value)
-          } else {
-            num = new Uint64LE(value)
-          }
-          const buf = num.toBuffer()
-          buf.copy(bs.view.buffer, bs.byteIndex)
-          bs.byteIndex += buf.length
-        } else {
-          bs.writeBits(value, bitLength)
-        }
-      }
-    }
-  }
-  //dumpWritten(bs, field, startPos, value)
-}
-
-function writeVariableLengthField(
-  bs: BitStream,
-  pgn_number: number,
-  pgn: any,
-  field: Field,
-  value: any,
-  fields: Field[]
-) {
-  const refField = getField(
-    pgn.pgn | pgn.PGN,
-    bs.view.buffer[bs.byteIndex - 1] - 1,
-    pgn
-  )
-
-  if (refField) {
-    let bits
-
-    if (refField.BitLength !== undefined) {
-      bits = (refField.BitLength + 7) & ~7 // Round # of bits in field refField up to complete bytes: 1->8, 7->8, 8->8 etc.
-    }
-
-    return writeField(bs, pgn_number, refField, pgn, value, fields, bits)
-  }
-}
-
-function lookup(field: Field, stringValue: string) {
-  let res
-  if (field.LookupEnumeration) {
-    res = lookupEnumerationValue(field.LookupEnumeration, stringValue)
-  } else {
-    res = lookupFieldTypeEnumerationValue(
-      field.LookupFieldTypeEnumeration,
-      stringValue
-    )
-  }
-  return _.isUndefined(res) ? stringValue : res
-}
-
-function lookupKeyBitLength(data: any, fields: Field[]) {
-  const field = fields.find((field) => field.Name === 'Key')
-
-  if (field) {
-    let val = data['Key'] || data['key']
-    if (typeof val === 'string') {
-      val = lookupFieldTypeEnumerationValue(
-        field.LookupFieldTypeEnumeration,
-        val
-      )
-    }
-    return lookupFieldTypeEnumerationBits(field.LookupFieldTypeEnumeration, val)
-  }
-}
-
-/*
-
-function parseHex(s:string): number {
-  return parseInt(s, 16)
-};
-
-function canboat2Buffer(canboatData:string) {
-  return Buffer.alloc(canboatData
-                     .split(',')
-                     .slice(6)
-                     .map(parseHex), 'hex')
-                     }
-*/
-
-export function pgnToActisenseSerialFormat(pgn: PGN) {
-  return encodeActisense({
-    pgn: pgn.pgn,
-    data: toPgn(pgn),
-    dst: pgn.dst,
-    src: pgn.src,
-    prio: pgn.prio,
-    timestamp: undefined
-  })
-}
-
-export function pgnToActisenseN2KAsciiFormat(pgn: PGN) {
-  return encodeActisenseN2KACSII({
-    pgn: pgn.pgn,
-    data: toPgn(pgn),
-    dst: pgn.dst,
-    src: pgn.src,
-    prio: pgn.prio,
-    timestamp: undefined
-  })
-}
-
-export function pgnToN2KActisenseFormat(pgn: PGN) {
-  const data = toPgn(pgn)
-  if (data) {
-    return encodeN2KActisense(pgn, data)
-  }
-}
-
-export function toiKonvertSerialFormat(pgn: number, data: Buffer, dst = 255) {
-  return `!PDGY,${pgn},${dst},${data.toString('base64')}`
-}
-
-export function pgnToiKonvertSerialFormat(pgn: any) {
-  const data = toPgn(pgn)
-  if (data) {
-    return toiKonvertSerialFormat(pgn.pgn, data, pgn.dst)
-  }
-}
-
-export function pgnToYdgwRawFormat(info: any) {
-  return encodeYDRAW({ ...info, data: toPgn(info) })
-}
-
-export function pgnToYdgwFullRawFormat(info: any) {
-  return encodeYDRAWFull({ ...info, data: toPgn(info) })
-}
-
-export function pgnToPCDIN(info: any) {
-  return encodePCDIN({ ...info, data: toPgn(info) })
-}
-
-export function pgnToMXPGN(info: any) {
-  return encodeMXPGN({ ...info, data: toPgn(info) })
-}
-
-export const actisenseToYdgwRawFormat = _.flow(parseActisense, encodeYDRAW)
-export const actisenseToYdgwFullRawFormat = _.flow(
-  parseActisense,
-  encodeYDRAWFull
-)
-export const actisenseToPCDIN = _.flow(parseActisense, encodePCDIN)
-export const actisenseToMXPGN = _.flow(parseActisense, encodeMXPGN)
-export const actisenseToiKonvert = _.flow(parseActisense, encodePDGY)
-export const actisenseToN2KAsciiFormat = _.flow(
-  parseActisense,
-  encodeActisenseN2KACSII
-)
-export const actisenseToN2KActisenseFormat = _.flow(
-  parseActisense,
-  encodeN2KActisense
-)
-
-function bitIsSet(field: Field, index: number, value: string) {
-  const enumName = lookupBitEnumerationName(
-    field.LookupBitEnumeration as string,
-    index
-  )
-
-  return enumName ? value.indexOf(enumName) != -1 : false
-}
-
-fieldTypeWriters['BITLOOKUP'] = (pgn, field, value, bs) => {
-  if (field.BitLength !== undefined) {
-    if (value === undefined || value.length === 0) {
-      if (field.BitLength % 8 == 0) {
-        const bytes = field.BitLength / 8
-        //const lastByte = field.Signed ? 0x7f : 0xff
-        for (let i = 0; i < bytes - 1; i++) {
-          bs.writeUint8(0x0)
-        }
-        bs.writeUint8(0x0)
-      } else {
-        bs.writeBits(0xffffffff, field.BitLength)
-      }
-    } else {
-      for (let i = 0; i < field.BitLength; i++) {
-        bs.writeBits(bitIsSet(field, i, value) ? 1 : 0, 1)
-      }
-    }
-  }
-}
-
-fieldTypeWriters['STRING_FIX'] = (pgn, field, value, bs) => {
-  if (field.BitLength !== undefined) {
-    let fill = 0xff
-    if (
-      (pgn === 129810 &&
-        (field.Name === 'Vendor ID' || field.Name === 'Callsign')) ||
-      (pgn === 129809 && field.Name === 'Name')
-    ) {
-      if (_.isUndefined(value) || value.length == 0) {
-        {
-          fill = 0x40
-          value = ''
-        }
-      }
-    }
-
-    if (value === undefined) {
-      value = ''
-    }
-    const fieldLen = field.BitLength / 8
-
-    for (let i = 0; i < value.length; i++) {
-      bs.writeUint8(value.charCodeAt(i))
-    }
-
-    for (let i = 0; i < fieldLen - value.length; i++) {
-      bs.writeUint8(fill)
-    }
-  }
-}
-
-fieldTypeWriters[RES_STRINGLZ] = (pgn, field, value, bs) => {
-  if (_.isUndefined(value)) {
-    value = ''
-  }
-  bs.writeUint8(value.length)
-  for (let i = 0; i < value.length; i++) {
-    bs.writeUint8(value.charCodeAt(i))
-  }
-  bs.writeUint8(0)
-}
-
-fieldTypeWriters['String with start/stop byte'] = (pgn, field, value, bs) => {
-  if (_.isUndefined(value)) {
-    value = ''
-  }
-  bs.writeUint8(0x02)
-  for (let i = 0; i < value.length; i++) {
-    bs.writeUint8(value.charCodeAt(i))
-  }
-  bs.writeUint8(0x01)
-}
-
-fieldTypeWriters[RES_STRINGLAU] = (pgn, field, value, bs) => {
-  if (pgn === 129041 && field.Name === 'AtoN Name') {
-    if (value.length > 18) {
-      value = value.substring(0, 18)
-    } else {
-      value = value.padEnd(18, ' ')
-    }
-  }
-
-  bs.writeUint8(value ? value.length + 2 : 2)
-  bs.writeUint8(1)
-
-  if (value) {
-    for (let idx = 0; idx < value.length; idx++) {
-      bs.writeUint8(value.charCodeAt(idx))
-    }
-  }
-}
-
-fieldTypeMappers['DATE'] = (field, value) => {
-  //console.log(`Date: ${value}`)
-  if (_.isString(value)) {
-    const date = new Date(value)
-    return date.getTime() / 86400 / 1000
-  }
-
-  return value
-}
-
-fieldTypeMappers['TIME'] = (field, value) => {
-  if (_.isString(value)) {
-    const split = value.split(':')
-
-    const hours = Number(split[0])
-    const minutes = Number(split[1])
-    const seconds = Number(split[2])
-
-    value = hours * 60 * 60 + minutes * 60 + seconds
-  }
-  return value
-}
-
-fieldTypeMappers['DURATION'] = fieldTypeMappers['TIME']
-
-fieldTypeMappers['Pressure'] = (field, value) => {
-  if (field.Unit) {
-    switch (field.Unit[0]) {
-      case 'h':
-      case 'H':
-        value /= 100
-        break
-      case 'k':
-      case 'K':
-        value /= 1000
-        break
-      case 'd':
-        value *= 10
-        break
-    }
-  }
-  return value
-}

package/lib/utilities.test.js

@@ -1,8 +0,0 @@
-const { byteString } = require('./utilities')
-
-describe('byteString', () => {
-  test('Buffer to string', () => {
-    const data = Buffer.from('00ff7f520021feff', 'hex')
-    expect(byteString(data)).toEqual('00,ff,7f,52,00,21,fe,ff')
-  })
-})