@canboat/canboatjs 3.3.3 → 3.3.5

package/lib/fromPgn.ts

@@ -1,1217 +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.
- */
-
-// FIXME: MMSI sould be a string
-
-import { Definition, Field, PGN, FieldType, createPGN } from '@canboat/ts-pgns'
-import { createDebug } from './utilities'
-import { EventEmitter } from 'node:events'
-import pkg from '../package.json'
-import _ from 'lodash'
-import {
-  getPgn,
-  getCustomPgn,
-  addCustomPgns,
-  lookupEnumerationName,
-  lookupFieldTypeEnumerationName,
-  lookupBitEnumerationName,
-  lookupFieldTypeEnumerationBits,
-  lookupFieldTypeEnumerationValue
-} from './pgns'
-import { BitStream, BitView } from 'bit-buffer'
-import { Int64LE, Uint64LE } from 'int64-buffer'
-
-import {
-  parseN2kString,
-  parseYDRAW,
-  isN2KOver0183,
-  parsePDGY,
-  parseActisenseN2KASCII
-} from './stringMsg'
-
-const debug = createDebug('canboatjs:fromPgn')
-const trace = createDebug('canboatjs:fromPgn:trace')
-
-export type FromPgnCallback = (msg: any, pgn: any | undefined) => void
-export type PostProcessor = (field: Field, value: any) => any
-type FieldTypeReader = (pgn: PGN, field: Field, bs: BitStream) => any
-
-const fieldTypeReaders: {
-  [key: string]: FieldTypeReader
-} = {}
-
-const fieldTypePostProcessors: {
-  [key: string]: PostProcessor
-} = {}
-
-const FORMAT_PLAIN = 0
-const FORMAT_COALESCED = 1
-const RES_BINARY = 'Binary data'
-
-const FASTPACKET_INDEX = 0
-const FASTPACKET_SIZE = 1
-const FASTPACKET_BUCKET_0_SIZE = 6
-const FASTPACKET_BUCKET_N_SIZE = 7
-const FASTPACKET_BUCKET_0_OFFSET = 2
-const FASTPACKET_BUCKET_N_OFFSET = 1
-const FASTPACKET_MAX_INDEX = 0x1f
-
-export class Parser extends EventEmitter {
-  options: any
-  name: string
-  version: string
-  author: string
-  license: string
-  format: number
-  devices: { [key: number]: { [key: number]: any } }
-  mixedFormat: boolean
-
-  constructor(opts: any = {}) {
-    super()
-    this.options = opts === undefined ? {} : opts
-
-    if (this.options.returnNulls === undefined) {
-      this.options.returnNulls = false
-    }
-
-    if (this.options.useCamel === undefined) {
-      this.options.useCamel = true
-    }
-
-    if (this.options.useCamelCompat === undefined) {
-      this.options.useCamelCompat = false
-    }
-
-    if (this.options.returnNonMatches === undefined) {
-      this.options.returnNonMatches = false
-    }
-
-    this.name = pkg.name
-    this.version = pkg.version
-    this.author = pkg.author
-    this.license = pkg.license
-    this.format = this.options.format === undefined ? -1 : this.options.format
-    this.devices = {}
-    this.mixedFormat = this.options.mixedFormat || false
-
-    if (this.options.onPropertyValues) {
-      this.options.onPropertyValues('canboat-custom-pgns', (values: any[]) => {
-        values
-          .filter((v) => v != null)
-          .forEach((pv) => {
-            addCustomPgns(pv.value, pv.setter)
-          })
-      })
-    }
-  }
-
-  _parse(
-    pgn: PGN,
-    bs: BitStream,
-    len: number,
-    coalesced: boolean,
-    cb: FromPgnCallback | undefined,
-    sourceString: string | undefined = undefined
-  ) {
-    if (pgn.src === undefined) {
-      throw new Error('invalid pgn, missing src')
-    }
-
-    const customPgns = getCustomPgn(pgn.pgn)
-    let pgnList = getPgn(pgn.pgn)
-
-    if (!pgnList && !customPgns) {
-      this.emit(
-        'warning',
-        pgn,
-        `no conversion found for pgn ${JSON.stringify(pgn)}`
-      )
-      return undefined
-    }
-
-    if (customPgns) {
-      pgnList = [...customPgns.definitions, ...(pgnList || [])]
-    }
-
-    if (!pgnList || pgnList.length === 0) {
-      this.emit(
-        'warning',
-        pgn,
-        `no conversion found for pgn ${JSON.stringify(pgn)}`
-      )
-      return undefined
-    }
-
-    if (pgnList === undefined) {
-      return
-    }
-
-    let pgnData: Definition | undefined
-
-    if (pgnList.length > 1) {
-      pgnData = this.findMatchPgn(pgnList)
-
-      if (pgnData === null) {
-        pgnData = pgnList[0]
-      }
-    } else {
-      pgnData = pgnList[0]
-    }
-
-    if (pgnData === undefined) {
-      return
-    }
-
-    let couldBeMulti = false
-
-    if (pgnList.length > 0 && len == 8) {
-      pgnList.forEach((pgnD) => {
-        if (pgnD.Length && pgnD.Length > 8) {
-          couldBeMulti = true
-        }
-      })
-    }
-
-    trace(`${pgn.pgn} ${len} ${pgnData.Length} ${couldBeMulti}`)
-    if (
-      coalesced ||
-      len > 0x8 ||
-      (this.format == FORMAT_COALESCED && !this.mixedFormat)
-    ) {
-      this.format = FORMAT_COALESCED
-      if (sourceString) {
-        pgn.input = [sourceString]
-      }
-      //} else if ( pgnData.Length > 0x8 || (len == 0x8 && (pgnData.RepeatingFields || couldBeMulti))) {
-    } else if (pgnData.Type === 'Fast') {
-      //partial packet
-      this.format = FORMAT_PLAIN
-
-      if (this.devices[pgn.src] === undefined) {
-        this.devices[pgn.src] = {}
-      }
-      let packet = this.devices[pgn.src][pgn.pgn]
-
-      if (!packet) {
-        packet = { bufferSize: 0, lastPacket: 0, src: [] }
-        this.devices[pgn.src][pgn.pgn] = packet
-      }
-      if (sourceString) {
-        packet.src.push(sourceString)
-      }
-
-      const start = bs.byteIndex
-      const packetIndex = bs.view.buffer.readUInt8(FASTPACKET_INDEX)
-      const bucket = packetIndex & FASTPACKET_MAX_INDEX
-
-      trace(`${pgn.pgn} partial ${packetIndex} ${bucket} ${packet.size}`)
-
-      if (bucket == 0) {
-        packet.size = bs.view.buffer.readUInt8(FASTPACKET_SIZE)
-        const newSize = packet.size + FASTPACKET_BUCKET_N_SIZE
-        if (newSize > packet.bufferSize) {
-          const newBuf = Buffer.alloc(newSize)
-          packet.bufferSize = newSize
-          if (packet.buffer) {
-            packet.buffer.copy(newBuf)
-          }
-          packet.buffer = newBuf
-        }
-        bs.view.buffer.copy(packet.buffer, 0, FASTPACKET_BUCKET_0_OFFSET, 8)
-        trace(
-          `${pgn.pgn} targetStart: 0 sourceStart: ${FASTPACKET_BUCKET_0_OFFSET}`
-        )
-      } else if (!packet.buffer) {
-        //we got a non-zero bucket, but we never got the zero bucket
-        debug(
-          `PGN ${pgn.pgn} malformed packet for ${pgn.src} received; got a non-zero bucket first`
-        )
-        cb && cb(`Could not parse ${JSON.stringify(pgn)}`, undefined)
-        bs.byteIndex = start
-        delete this.devices[pgn.src][pgn.pgn]
-        return
-      } else {
-        if (packet.lastPacket + 1 != packetIndex) {
-          debug(
-            `PGN ${pgn.pgn} malformed packet for ${pgn.src} received; expected ${packet.lastPacket + 1} but got ${packetIndex}`
-          )
-          cb && cb(`Could not parse ${JSON.stringify(pgn)}`, undefined)
-          bs.byteIndex = start
-          delete this.devices[pgn.src][pgn.pgn]
-          return
-        } else {
-          trace(
-            `${pgn.pgn} targetStart: ${FASTPACKET_BUCKET_0_SIZE + FASTPACKET_BUCKET_N_SIZE * (bucket - 1)} sourceStart: ${FASTPACKET_BUCKET_N_OFFSET} sourceEned: ${FASTPACKET_BUCKET_N_SIZE}`
-          )
-          bs.view.buffer.copy(
-            packet.buffer,
-            FASTPACKET_BUCKET_0_SIZE + FASTPACKET_BUCKET_N_SIZE * (bucket - 1),
-            FASTPACKET_BUCKET_N_OFFSET,
-            8
-          )
-        }
-      }
-      packet.lastPacket = packetIndex
-      if (
-        FASTPACKET_BUCKET_0_SIZE + FASTPACKET_BUCKET_N_SIZE * bucket <
-        packet.size
-      ) {
-        // Packet is not complete yet
-        trace(`${pgn.pgn} not complete`)
-        return
-      }
-      const view = new BitView(packet.buffer)
-      bs = new BitStream(view)
-      trace(`${pgn.pgn} done`)
-      pgn.input = packet.src
-      delete this.devices[pgn.src][pgn.pgn]
-    } else if (sourceString) {
-      pgn.input = [sourceString]
-    }
-
-    let RepeatingFields = pgnData.RepeatingFieldSet1Size
-      ? pgnData.RepeatingFieldSet1Size
-      : 0
-
-    pgn.fields = {}
-
-    try {
-      let fields = pgnData.Fields
-
-      let continueReading = true
-      for (let i = 0; i < fields.length - RepeatingFields; i++) {
-        const field = fields[i]
-        const hasMatch = field.Match !== undefined
-
-        let value = readField(this.options, !hasMatch, pgn, field, bs, fields)
-
-        if (hasMatch) {
-          //console.log(`looking for ${field.Name} == ${value}`)
-          //console.log(JSON.stringify(pgnList, null, 2))
-          pgnList = pgnList.filter((f) => f.Fields[i].Match == value)
-          if (pgnList.length == 0) {
-            if (this.options.returnNonMatches) {
-              //this.emit('warning', pgn, `no conversion found for pgn`)
-              trace('warning no conversion found for pgn %j', pgn)
-              continueReading = false
-              break
-            } else {
-              return undefined
-            }
-          } else {
-            pgnData = pgnList[0]
-            fields = pgnData.Fields
-            //console.log(`using ${JSON.stringify(pgnData, null, 2)}`)
-            value = pgnData.Fields[i].Description
-            if (value == null) {
-              value = pgnData.Fields[i].Match
-            }
-            RepeatingFields = pgnData.RepeatingFieldSet1Size
-              ? pgnData.RepeatingFieldSet1Size
-              : 0
-          }
-        }
-
-        if (
-          value !== undefined &&
-          (value != null || this.options.returnNulls)
-        ) {
-          this.setField(pgn.fields, field, value)
-        }
-      }
-      if (RepeatingFields > 0 && continueReading) {
-        const repeating: Field[] = (fields as any).slice(
-          fields.length - RepeatingFields
-        )
-
-        const fany = pgn.fields as any
-        fany.list = []
-
-        let count
-
-        if (pgnData.RepeatingFieldSet1CountField !== undefined) {
-          const rfield =
-            pgnData.Fields[pgnData.RepeatingFieldSet1CountField - 1]
-          const dataKey = this.options.useCamel ? rfield.Id : rfield.Name
-          count = (pgn.fields as any)[dataKey]
-        } else {
-          count = 2048
-        }
-
-        while (bs.bitsLeft > 0 && --count >= 0) {
-          const group = {}
-          repeating.forEach((field) => {
-            if (bs.bitsLeft > 0) {
-              const value = readField(
-                this.options,
-                true,
-                pgn,
-                field,
-                bs,
-                fields
-              )
-              if (value !== undefined && value != null) {
-                this.setField(group, field, value)
-              }
-            }
-          })
-          if (_.keys(group).length > 0) {
-            ;(pgn.fields as any).list.push(group)
-          }
-        }
-      }
-
-      /*
-      if ( pgnData.callback ) {
-        pgnData.callback(pgn)
-        }
-      */
-
-      const res = createPGN(pgnData.Id, pgn.fields)
-
-      if (res === undefined) {
-        this.emit('error', pgn, 'no class')
-        cb && cb('no class', undefined)
-        return
-      }
-
-      res.description = pgnData.Description
-      res.src = pgn.src
-      res.dst = pgn.dst
-      res.prio = pgn.prio
-      ;(res as any).canId = (pgn as any).canId
-      ;(res as any).time = (pgn as any).time
-      ;(res as any).timer = (pgn as any).timer
-      ;(res as any).direction = (pgn as any).direction
-
-      // Stringify timestamp because SK Server needs it that way.
-      const ts = _.get(pgn, 'timestamp', new Date())
-      res.timestamp = _.isDate(ts) ? ts.toISOString() : ts
-      this.emit('pgn', res)
-      cb && cb(undefined, res)
-
-      return res
-    } catch (error) {
-      this.emit('error', pgn, error)
-      cb && cb(error, undefined)
-      return
-    }
-  }
-
-  setField(res: any, field: Field, value: any) {
-    if (this.options.useCamelCompat) {
-      res[field.Id] = value
-      res[field.Name] = value
-    } else if (this.options.useCamel) {
-      res[field.Id] = value
-    } else {
-      res[field.Name] = value
-    }
-  }
-
-  findNonMatchPgn(pgnList: Definition[]): Definition | undefined {
-    return pgnList.find((f) => {
-      return !f.Fields.find((f) => f.Match !== undefined)
-    })
-  }
-
-  findMatchPgn(pgnList: Definition[]): Definition | undefined {
-    return pgnList.find((f) => {
-      return f.Fields.find((f) => f.Match !== undefined)
-    })
-  }
-
-  parse(data: any, cb: FromPgnCallback | undefined = undefined) {
-    if (_.isString(data)) {
-      return this.parseString(data, cb)
-    } else if (_.isBuffer(data)) {
-      return this.parseBuffer(data, cb)
-    } else {
-      return this.parsePgnData(
-        data.pgn,
-        data.length,
-        data.data,
-        data.coalesced === true,
-        cb,
-        data.sourceString
-      )
-    }
-  }
-
-  parsePgnData(
-    pgn: PGN,
-    length: number,
-    data: string[] | Buffer,
-    coalesced: boolean,
-    cb: FromPgnCallback | undefined,
-    sourceString: string
-  ) {
-    try {
-      let buffer = data
-      if (!_.isBuffer(data)) {
-        const array = new Int16Array(length)
-        const strings = data as string[]
-        strings.forEach((num, index) => {
-          array[index] = parseInt(num, 16)
-        })
-        buffer = Buffer.from(array)
-      }
-
-      const bv = new BitView(buffer as Buffer)
-      const bs = new BitStream(bv)
-      const res = this._parse(pgn, bs, length, coalesced, cb, sourceString)
-      if (res) {
-        debug('parsed pgn %j', pgn)
-      }
-      return res
-    } catch (error) {
-      cb && cb(error, undefined)
-      this.emit('error', pgn, error)
-    }
-  }
-
-  isN2KOver0183(sentence: string) {
-    return isN2KOver0183(sentence)
-  }
-
-  parseN2KOver0183(sentence: string, cb: FromPgnCallback) {
-    return this.parseString(sentence, cb)
-  }
-
-  /*
-  // Venus MQTT-N2K
-  parseVenusMQTT(pgn_data: any, cb: FromPgnCallback) {
-    try {
-      const pgn = {
-        pgn: pgn_data.pgn,
-        timestamp: new Date().toISOString(),
-        src: pgn_data.src,
-        dst: pgn_data.dst,
-        prio: pgn_data.prio,
-        fields: {}
-      }
-      const bs = new BitStream(Buffer.from(pgn_data.data, 'base64'))
-      delete pgn_data.data
-      const res = this._parse(pgn, bs, 8, false, cb)
-      if (res) {
-        debug('parsed pgn %j', pgn)
-      }
-      return res
-    } catch (error) {
-      cb && cb(error, undefined)
-      this.emit('error', pgn_data, error)
-    }
-    }
-    */
-
-  //Yacht Devices NMEA2000 Wifi gateway
-  parseYDGW02(pgn_data: any, cb: FromPgnCallback) {
-    try {
-      const { data, direction, error, ...pgn } = parseYDRAW(pgn_data)
-      if (!error && direction === 'R') {
-        const bs = new BitStream(data)
-        delete pgn.format
-        const res = this._parse(pgn, bs, data.length, false, cb, pgn_data)
-        if (res) {
-          debug('parsed ydgw02 pgn %j', pgn_data)
-          return res
-        }
-      } else if (error) {
-        cb && cb(error, undefined)
-        this.emit('error', pgn_data, error)
-      }
-    } catch (error) {
-      cb && cb(error, undefined)
-      this.emit('error', pgn_data, error)
-    }
-    return undefined
-  }
-
-  //Actisense W2k-1
-  parseActisenceN2KAscii(pgn_data: any, cb: FromPgnCallback) {
-    try {
-      const { data, error, ...pgn } = parseActisenseN2KASCII(pgn_data)
-      if (!error) {
-        const bs = new BitStream(data)
-        delete pgn.format
-        const res = this._parse(pgn, bs, data.length, false, cb, pgn_data)
-        if (res) {
-          debug('parsed n2k ascii pgn %j', pgn_data)
-          return res
-        }
-      } else if (error) {
-        cb && cb(error, undefined)
-        this.emit('error', pgn_data, error)
-      }
-    } catch (error) {
-      cb && cb(error, undefined)
-      this.emit('error', pgn_data, error)
-    }
-    return undefined
-  }
-
-  parsePDGY(pgn_data: any, cb: FromPgnCallback) {
-    if (pgn_data[0] != '!') {
-      return
-    }
-    try {
-      const { coalesced, data, error, len, ...pgn } = parsePDGY(pgn_data)
-      if (error) {
-        cb && cb(error, undefined)
-        this.emit('error', pgn, error)
-        return
-      }
-
-      const bs = new BitStream(data)
-      delete pgn.format
-      delete pgn.type
-      delete pgn.prefix
-      const res = this._parse(
-        pgn,
-        bs,
-        len || data.length,
-        coalesced,
-        cb,
-        pgn_data
-      )
-      if (res) {
-        debug('parsed pgn %j', pgn)
-      }
-      return res
-    } catch (error) {
-      cb && cb(error, undefined)
-      this.emit('error', pgn_data, error)
-    }
-  }
-
-  parseString(pgn_data: string, cb: FromPgnCallback | undefined = undefined) {
-    try {
-      const { coalesced, data, error, len, ...pgn } = parseN2kString(
-        pgn_data,
-        this.options
-      )
-      if (error) {
-        cb && cb(error, undefined)
-        this.emit('error', pgn, error)
-        return
-      }
-
-      const bs = new BitStream(data)
-      delete pgn.format
-      delete pgn.type
-      delete pgn.prefix
-      const res = this._parse(
-        pgn,
-        bs,
-        len || data.length,
-        coalesced,
-        cb,
-        pgn_data
-      )
-      if (res) {
-        debug('parsed pgn %j', pgn)
-      }
-      return res
-    } catch (error) {
-      cb && cb(error, undefined)
-      this.emit('error', pgn_data, error)
-    }
-  }
-
-  parseBuffer(pgn_data: any, cb: FromPgnCallback | undefined) {
-    try {
-      const bv = new BitView(pgn_data)
-      const bs = new BitStream(bv)
-
-      const pgn: any = {}
-
-      // This might be good to move to canId.js ?
-      pgn.prio = bs.readUint8()
-      pgn.pgn = bs.readUint8() + 256 * (bs.readUint8() + 256 * bs.readUint8())
-      pgn.dst = bs.readUint8()
-      pgn.src = bs.readUint8()
-      pgn.timestamp = new Date().toISOString()
-
-      //const timestamp  =  FIXME?? use timestamp?
-      bs.readUint32()
-      const len = bs.readUint8()
-      const res = this._parse(pgn, bs, len, true, cb)
-      if (res) {
-        debug('parsed pgn %j', pgn)
-      }
-      return res
-    } catch (error) {
-      const err = new Error(
-        `error reading pgn ${JSON.stringify(pgn_data)} ${error}`
-      )
-      cb && cb(err, undefined)
-      this.emit('error', pgn_data, error)
-      console.error(err)
-      return
-    }
-  }
-}
-
-export function getField(pgn_number: number, index: number, data: any) {
-  let pgnList = getPgn(pgn_number)
-  if (pgnList) {
-    let pgn = pgnList[0]
-    const dataList = data.list ? data.list : data.fields.list
-
-    if (pgnList.length > 1) {
-      let idx = 0
-      while (idx < pgn.Fields.length) {
-        const field = pgn.Fields[idx]
-        const hasMatch = !_.isUndefined(field.Match)
-        if (hasMatch && dataList.length > 0) {
-          const param = dataList.find((f: any) => {
-            const param = f.parameter !== undefined ? f.parameter : f.Parameter
-            return param === idx + 1
-          })
-
-          if (param) {
-            pgnList = pgnList.filter((f) => {
-              const value =
-                param.value !== undefined ? param.value : param.Value
-              return f.Fields[idx].Match == value
-            })
-            if (pgnList.length == 0) {
-              throw new Error('unable to read: ' + JSON.stringify(data))
-              return
-            } else {
-              pgn = pgnList[0]
-            }
-          }
-        }
-        idx++
-      }
-    }
-
-    if (index >= 0 && index < pgn.Fields.length) {
-      return pgn.Fields[index]
-    }
-
-    const RepeatingFields = pgn.RepeatingFieldSet1Size
-      ? pgn.RepeatingFieldSet1Size
-      : 0
-    if (RepeatingFields) {
-      const startOfRepeatingFields = pgn.Fields.length - RepeatingFields
-      index =
-        startOfRepeatingFields +
-        ((index - startOfRepeatingFields) % RepeatingFields)
-      return pgn.Fields[index]
-    }
-  }
-  return null
-}
-
-function pad2(x: number) {
-  const s = x.toString()
-  return s.length === 1 ? '0' + x : x
-}
-
-function lookup(field: Field, value: number) {
-  let name
-  if (field.LookupEnumeration) {
-    name = lookupEnumerationName(field.LookupEnumeration, value)
-  } else {
-    name = lookupFieldTypeEnumerationName(
-      field.LookupFieldTypeEnumeration,
-      value
-    )
-  }
-
-  return name ? name : value
-}
-
-function readField(
-  options: any,
-  runPostProcessor: boolean,
-  pgn: PGN,
-  field: Field,
-  bs: BitStream,
-  fields: Field[] | undefined = undefined
-): any {
-  let value
-
-  const reader = fieldTypeReaders[field.FieldType]
-  if (reader) {
-    value = reader(pgn, field, bs)
-  } else {
-    if (
-      field.FieldType !== FieldType.Binary &&
-      field.BitLength !== undefined &&
-      bs.bitsLeft < field.BitLength
-    ) {
-      //no more data
-      bs.readBits(bs.bitsLeft, false)
-      return
-    }
-    value = readValue(options, pgn, field, bs, fields)
-  }
-
-  //console.log(`${field.Name} ${value} ${field.Resolution}`)
-
-  if (value != null && !_.isUndefined(value)) {
-    const type = field.FieldType //hack, missing type
-    const postProcessor = fieldTypePostProcessors[type]
-    if (postProcessor) {
-      if (runPostProcessor) {
-        value = postProcessor(field, value)
-      }
-    } else {
-      if (field.Offset) {
-        value += field.Offset
-      }
-      let max
-      if (typeof field.RangeMax !== 'undefined' && field.Resolution) {
-        max = field.RangeMax / field.Resolution
-      }
-      if (
-        options.checkForInvalidFields !== false &&
-        max !== undefined &&
-        field.FieldType !== 'LOOKUP' &&
-        field.FieldType !== 'DYNAMIC_FIELD_KEY' &&
-        field.FieldType !== 'PGN' &&
-        field.BitLength !== undefined &&
-        field.BitLength > 1 &&
-        max - value < 0
-      ) {
-        //console.log(`Bad field ${field.Name} ${max - value}`)
-        value = null
-      }
-      if (field.Resolution && typeof value === 'number') {
-        let resolution = field.Resolution
-
-        if (_.isString(resolution)) {
-          resolution = Number.parseFloat(resolution)
-        }
-
-        value = value * resolution
-
-        let precision = 0
-        for (let r = resolution; r > 0.0 && r < 1.0; r = r * 10.0) {
-          precision++
-        }
-
-        value = Number.parseFloat(value.toFixed(precision))
-      }
-
-      if (
-        (field.FieldType === 'LOOKUP' ||
-          field.FieldType === 'DYNAMIC_FIELD_KEY') &&
-        runPostProcessor &&
-        (_.isUndefined(options.resolveEnums) || options.resolveEnums)
-      ) {
-        if (field.Id === 'timeStamp' && value < 60) {
-          value = value.toString()
-        } else {
-          value = lookup(field, value)
-        }
-      }
-
-      /*
-      if ( field.Name === 'Industry Code' && _.isNumber(value) && runPostProcessor ) {
-        const name = getIndustryName(value)
-        if ( name ) {
-          value = name
-        }
-        }
-      */
-
-      if (field.Unit === 'kWh') {
-        value *= 3.6e6 // 1 kWh = 3.6 MJ.
-      } else if (field.Unit === 'Ah') {
-        value *= 3600.0 // 1 Ah = 3600 C.
-      }
-    }
-  }
-  return value
-}
-
-function readValue(
-  options: any,
-  pgn: PGN,
-  field: Field,
-  bs: BitStream,
-  fields: Field[] | undefined,
-  bitLength: number | undefined = undefined
-) {
-  if (field.FieldType == 'VARIABLE') {
-    return readVariableLengthField(options, pgn, field, bs)
-  } else {
-    let value
-    if (bitLength === undefined) {
-      if (
-        field.BitLengthVariable &&
-        field.FieldType === 'DYNAMIC_FIELD_VALUE'
-      ) {
-        bitLength = lookupKeyBitLength(pgn.fields, fields as Field[])
-      } else {
-        bitLength = field.BitLength
-      }
-
-      if (bitLength === undefined) {
-        //FIXME?? error? mesg? should never happen
-        return
-      }
-    }
-
-    if (bitLength === 8) {
-      if (field.Signed) {
-        value = bs.readInt8()
-        value = value === 0x7f ? null : value
-      } else {
-        value = bs.readUint8()
-        value = value === 0xff ? null : value
-      }
-    } else if (bitLength == 16) {
-      if (field.Signed) {
-        value = bs.readInt16()
-        value = value === 0x7fff ? null : value
-      } else {
-        value = bs.readUint16()
-        value = value === 0xffff ? null : value
-      }
-    } else if (bitLength == 24) {
-      const b1 = bs.readUint8()
-      const b2 = bs.readUint8()
-      const b3 = bs.readUint8()
-
-      //debug(`24 bit ${b1.toString(16)} ${b2.toString(16)} ${b3.toString(16)}`)
-      value = (b3 << 16) + (b2 << 8) + b1
-      //debug(`value ${value.toString(16)}`)
-    } else if (bitLength == 32) {
-      if (field.Signed) {
-        value = bs.readInt32()
-        value = value === 0x7fffffff ? null : value
-      } else {
-        value = bs.readUint32()
-        value = value === 0xffffffff ? null : value
-      }
-    } else if (bitLength == 48) {
-      const a = bs.readUint32()
-      const b = bs.readUint16()
-
-      if (field.Signed) {
-        value = a == 0xffffffff && b == 0x7fff ? null : new Int64LE(b, a)
-      } else {
-        value = a == 0xffffffff && b == 0xffff ? null : new Int64LE(b, a)
-      }
-    } else if (bitLength == 64) {
-      const x = bs.readUint32()
-      const y = bs.readUint32()
-
-      if (field.Signed) {
-        value =
-          (x === 0xffffffff || x === 0xfffffffe) && y == 0x7fffffff
-            ? null
-            : new Int64LE(y, x)
-      } else {
-        value =
-          (x === 0xffffffff || x === 0xfffffffe) && y == 0xffffffff
-            ? null
-            : new Uint64LE(y, x)
-      }
-    } else if (bitLength <= 64) {
-      value = bs.readBits(bitLength, field.Signed)
-      if (bitLength > 1 && isMax(bitLength, value, field.Signed as boolean)) {
-        value = null
-      }
-    } else {
-      if (bs.bitsLeft < bitLength) {
-        bitLength = bs.bitsLeft
-        if (bitLength === undefined) {
-          return null
-        }
-      }
-
-      value = bs.readArrayBuffer(bitLength / 8) //, field.Signed)
-      const arr: string[] = []
-      value = new Uint32Array(value)
-        .reduce(function (acc, i) {
-          acc.push(i.toString(16))
-          return acc
-        }, arr)
-        .map((x) => (x.length === 1 ? '0' + x : x))
-        .join(' ')
-
-      return value
-    }
-
-    if (
-      value != null &&
-      typeof value !== 'undefined' &&
-      typeof value !== 'number'
-    ) {
-      value = Number(value)
-    }
-
-    return value
-  }
-}
-
-function isMax(numBits: number, value: number, signed: boolean) {
-  if (signed) {
-    numBits--
-  }
-
-  while (numBits--) {
-    if ((value & 1) == 0) {
-      return false
-    }
-    value = value >> 1
-  }
-  return signed ? (value & 1) == 0 : true
-}
-
-function readVariableLengthField(
-  options: any,
-  pgn: PGN,
-  field: Field,
-  bs: BitStream
-) {
-  /* PGN 126208 contains variable field length.
-   * The field length can be derived from the PGN mentioned earlier in the message,
-   * plus the field number.
-   */
-
-  /*
-   * This is rather hacky. We know that the 'data' pointer points to the n-th variable field
-   * length and thus that the field number is exactly one byte earlier.
-   */
-
-  try {
-    const refField = getField(
-      (pgn.fields as any).pgn || (pgn.fields as any).PGN,
-      bs.view.buffer[bs.byteIndex - 1] - 1,
-      pgn
-    )
-
-    if (refField) {
-      const res = readField(options, false, pgn, refField, bs)
-
-      if (refField.BitLength !== undefined) {
-        const bits = (refField.BitLength + 7) & ~7 // Round # of bits in field refField up to complete bytes: 1->8, 7->8, 8->8 etc.
-        if (bits > refField.BitLength) {
-          bs.readBits(bits - refField.BitLength, false)
-        }
-      }
-
-      return res
-    }
-  } catch (error) {
-    debug(error)
-  }
-}
-
-fieldTypeReaders[
-  'STRING_LAU'
-  //'ASCII or UNICODE string starting with length and control byte'
-] = (pgn, field, bs) => {
-  if (bs.bitsLeft >= 16) {
-    const len = bs.readUint8() - 2
-    const control = bs.readUint8()
-    let nameLen = len
-
-    if (field.Name === 'AtoN Name' && len > 20) {
-      nameLen = 20
-    } else if (len <= 0) {
-      return null
-    }
-
-    const buf = Buffer.alloc(len)
-    let idx = 0
-    for (; idx < len && bs.bitsLeft >= 8; idx++) {
-      const c = bs.readUint8()
-      buf.writeUInt8(c, idx)
-    }
-
-    if (buf[buf.length - 1] === 0) {
-      nameLen = nameLen - 1
-    }
-
-    return buf
-      .toString(
-        control == 0 ? 'utf8' : 'ascii',
-        0,
-        idx < nameLen ? idx : nameLen
-      )
-      .trim()
-  } else {
-    return null
-  }
-}
-
-fieldTypeReaders[
-  'STRING_LZ'
-  //'ASCII string starting with length byte'
-] = (pgn, field, bs) => {
-  const len = bs.readUint8()
-
-  const buf = Buffer.alloc(len)
-  let idx = 0
-  for (; idx < len && bs.bitsLeft >= 8; idx++) {
-    const c = bs.readUint8()
-    buf.writeUInt8(c, idx)
-  }
-
-  return buf.toString('utf-8', 0, idx)
-}
-
-fieldTypeReaders['String with start/stop byte'] = (pgn, field, bs) => {
-  const first = bs.readUint8()
-  if (first == 0xff) {
-    // no name, stop reading
-    return ''
-  } else if (first == 0x02) {
-    const buf = Buffer.alloc(255)
-    let c
-    let idx = 0
-    while ((c = bs.readUint8()) != 0x01) {
-      buf.writeUInt8(c, idx++)
-    }
-    return buf.toString('ascii', 0, idx)
-  } else if (first > 0x02) {
-    let len = first
-    const second = bs.readUint8()
-    const buf = Buffer.alloc(len)
-    let idx = 0
-    if (second == 0x01) {
-      len -= 2
-    } else {
-      buf.writeUInt8(second)
-      idx = 1
-    }
-    for (; idx < len; idx++) {
-      const c = bs.readUint8()
-      buf.writeUInt8(c, idx)
-    }
-    return buf.toString('ascii', 0, idx)
-  }
-}
-
-fieldTypeReaders['STRING_FIX'] = (pgn, field, bs) => {
-  let len = (field.BitLength as number) / 8
-  const buf = Buffer.alloc(len)
-
-  for (let i = 0; i < len && bs.bitsLeft >= 8; i++) {
-    buf.writeUInt8(bs.readUint8(), i)
-  }
-
-  let lastbyte = buf[len - 1]
-  while (
-    len > 0 &&
-    (lastbyte == 0xff || lastbyte == 32 || lastbyte == 0 || lastbyte == 64)
-  ) {
-    len--
-    lastbyte = buf[len - 1]
-  }
-
-  //look for a zero byte, some proprietary Raymarine pgns do this
-  let zero = 0
-  while (zero < len) {
-    if (buf[zero] == 0) {
-      len = zero
-      break
-    }
-    zero++
-  }
-  len = zero
-  return len > 0 ? buf.toString('ascii', 0, len) : undefined
-}
-
-fieldTypeReaders['BITLOOKUP'] = (pgn, field, bs) => {
-  const value: any[] = []
-  for (let i = 0; i < (field.BitLength as number); i++) {
-    if (bs.readBits(1, false)) {
-      value.push(
-        lookupBitEnumerationName(field.LookupBitEnumeration as string, i)
-      )
-    }
-  }
-  return value
-}
-
-function lookupKeyBitLength(data: any, fields: Field[]): number | undefined {
-  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)
-  }
-}
-
-fieldTypePostProcessors['DATE'] = (field, value) => {
-  if (value >= 0xfffd) {
-    value = undefined
-  } else {
-    const date = new Date(value * 86400 * 1000)
-    //const date = moment.unix(0).add(value+1, 'days').utc().toDate()
-    value = `${date.getUTCFullYear()}.${pad2(date.getUTCMonth() + 1)}.${pad2(date.getUTCDate())}`
-  }
-  return value
-}
-
-fieldTypePostProcessors['TIME'] = (field, value) => {
-  if (value >= 0xfffffffd) {
-    value = undefined
-  } else {
-    let seconds = value * (field.Resolution as number)
-    let minutes = seconds / 60
-    seconds = seconds % 60
-    const hours = Math.floor(minutes / 60)
-    minutes = Math.floor(minutes % 60)
-
-    value = `${pad2(hours)}:${pad2(minutes)}:${pad2(Math.floor(seconds))}`
-
-    if (seconds % 1 > 0) {
-      value = value + (seconds % 1).toFixed(5).substring(1)
-    }
-  }
-  return value
-}
-
-fieldTypePostProcessors['DURATION'] = fieldTypePostProcessors['TIME']
-
-fieldTypePostProcessors['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
-}
-
-fieldTypePostProcessors[RES_BINARY] = (field, value) => {
-  return value.toString()
-}