@canboat/canboatjs 1.22.2 → 1.24.0

package/README.md

@@ -50,6 +50,12 @@ This program takes input in the candump format and outputs canboat json format
 
 Example: `candump can0 | candumpanalyzerjs`
 
+## ydvr-file
+
+This program takes input in the [YDVR](https://www.yachtd.com/products/recorder.html) file format and outputs canboat json format
+
+Example: `ydvr-file <file>`
+
 # Usage
 
 ## Installation

package/W2K_NOTES

@@ -0,0 +1,5 @@
+N2K Actisense corruption?
+  Docs don't match
+  What is that last byte?
+
+Not seeing 126996

package/bin/actisense-n2k-tcp

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+const debug = require('debug')('canboatjs:w2k01')
+const net = require('net');
+const { readN2KActisense } = require('../lib/n2k-actisense')
+
+const argv = require('minimist')(process.argv.slice(2), {
+  alias: { h: 'help' }
+})
+
+if ( argv['help'] ) {
+  console.error(`Usage: ${process.argv[0]} [options] host port
+
+Options:
+  -h, --help       output usage information`)
+  process.exit(1)
+}
+
+if ( argv['_'].length < 2 ) {
+  console.error('Please specify a host and port')
+  process.exit(1)
+}
+
+
+var client = new net.Socket();
+client.connect(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/bin/candumpjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+const canboatjs = require('../index')
+const Parser = require('../index').FromPgn
+const { parseCanId } = require('../lib/canId')
+const socketcan = require('socketcan')
+
+var parser = new canboatjs.FromPgn()
+
+
+const argv = require('minimist')(process.argv.slice(2), {
+  alias: { h: 'help' }
+})
+
+if ( argv['help'] ) {
+  console.error(`Usage: ${process.argv[0]} [options] candevice
+
+Options:
+  -h, --help       output usage information`)
+  process.exit(1)
+}
+
+if ( argv['_'].length === 0 ) {
+  console.error('Please specify a device')
+  process.exit(1)
+}
+
+/*
+
+let messageCb = (data) => {
+  let jsonData = parser.parse(data, (err) => { if ( err ) console.error(err) })
+  if ( jsonData ) {
+    console.log(data)
+  }
+}
+
+let simpleCan = new canboatjs.SimpleCan({
+  canDevice: argv['_'][0],
+  preferredAddress: 35,
+  disableDefaultTransmitPGNs: true,
+  transmitPGNs: [],
+}, messageCb)
+
+simpleCan.start()
+
+*/
+
+parser.on('error', (pgn, error) => {
+  console.error(`Error parsing ${pgn.pgn} ${error}`)
+  console.error(error.stack)
+})
+
+parser.on('pgn', (pgn) => {
+  console.log(JSON.stringify(pgn))
+})
+
+
+const canDevice = argv['_'][0]
+
+this.channel = socketcan.createRawChannel(canDevice);
+
+this.channel.addListener('onMessage', (msg) => {
+  var pgn = parseCanId(msg.id)
+  
+  pgn.timestamp = new Date().toISOString()
+
+  parser.parse({ pgn, length: msg.data.length, data: msg.data })
+})
+
+this.channel.start()

package/bin/to-pgn

@@ -4,14 +4,14 @@ const argv = require('minimist')(process.argv.slice(2), {
   string: ['format'],
   alias: { h: 'help' }
 })
-const { pgnToActisenseSerialFormat, pgnToiKonvertSerialFormat, pgnToYdgwRawFormat, pgnToPCDIN, pgnToMXPGN } = require('../index')
+const { pgnToActisenseSerialFormat, pgnToActisenseN2KAsciiFormat, pgnToiKonvertSerialFormat, pgnToYdgwRawFormat, pgnToPCDIN, pgnToMXPGN } = require('../index')
 const { toActisenseSerialFormat } = require('../lib/stringMsg')
 
 if ( argv['help'] ) {
   console.error(`Usage: ${process.argv[0]} [options]
 
 Options:
-  --format <format>   actisense, ikconvert, ydgw, pcdin, mxpgn
+  --format <format>   actisense, actisensen2kascii, ikconvert, ydgw, pcdin, mxpgn
   -h, --help          output usage information`)
   process.exit(1)
 }
@@ -19,6 +19,7 @@ Options:
 
 const formatters = {
   actisense: pgnToActisenseSerialFormat,
+  'n2kascii': pgnToActisenseN2KAsciiFormat,
   ikconvert: pgnToiKonvertSerialFormat,
   ydgw: pgnToYdgwRawFormat,
   'pcdin': pgnToPCDIN,

package/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/examples/simpleCan.js

@@ -0,0 +1,42 @@
+
+const canboatjs = require('../index')
+//const canboatjs = require('@canboat/canboatjs')
+const Parser = require('../index').FromPgn
+var parser = new canboatjs.FromPgn()
+
+let messageCb = (data) => {
+  let jsonData = parser.parse(data, (err) => { if ( err ) console.error(err) })
+  if ( jsonData ) {
+    //process
+  }
+}
+
+let simpleCan = new canboatjs.SimpleCan({
+  canDevice: 'can0',
+  preferredAddress: 35,
+  disableDefaultTransmitPGNs: true,
+  transmitPGNs: [],
+  addressClaim: {
+    "Unique Number": 139725,
+    "Manufacturer Code": 'Fusion Electronics',
+    "Device Function": 130,
+    "Device Class": 'Entertainment',
+    "Device Instance Lower": 0,
+    "Device Instance Upper": 0,
+    "System Instance": 0,
+    "Industry Group": 'Marine'
+  },
+  productInfo: {
+    "NMEA 2000 Version": 1300,
+    "Product Code": 667,
+    "Model ID": "MS-UD650",
+    "Software Version Code": "1.0",
+    "Model Version": "1.0",
+    "Model Serial Code": "123456",
+    "Certification Level": 0,
+    "Load Equivalency": 1
+  }
+}, messageCb)
+
+simpleCan.start()
+

package/index.js

@@ -23,6 +23,7 @@ module.exports = {
   toPgn: require('./lib/toPgn').toPgn,
   toActisenseSerialFormat: require('./lib/stringMsg').toActisenseSerialFormat,
   pgnToActisenseSerialFormat: require('./lib/toPgn').pgnToActisenseSerialFormat,
+  pgnToActisenseN2KAsciiFormat: require('./lib/toPgn').pgnToActisenseN2KAsciiFormat,
   pgnToiKonvertSerialFormat: require('./lib/toPgn').pgnToiKonvertSerialFormat,
   pgnToYdgwRawFormat: require('./lib/toPgn').pgnToYdgwRawFormat,
   pgnToPCDIN: require('./lib/toPgn').pgnToPCDIN,
@@ -31,6 +32,7 @@ module.exports = {
   iKonvert: require('./lib/ikonvert'),
   Ydwg02: require('./lib/ydgw02'),
   Ydgw02: require('./lib/ydgw02'),
+  W2k01: require('./lib/w2k01'),
   Venus: require('./lib/venus'),
   VenusMQTT: require('./lib/venus-mqtt'),
   discover: require('./lib/discovery'),

package/lib/fromPgn.js

@@ -29,7 +29,7 @@ const { parse: parseDate } = require('date-fns')
 const { getPGNFromCanId } = require('./utilities')
 const { getIndustryName, getManufacturerName } = require('./codes')
 const { parseCanId } = require('./canId')
-const { parseN2kString, parseYDRAW, isN2KOver0183, parseN2KOver0183, parsePDGY } = require('./stringMsg')
+const { parseN2kString, parseYDRAW, isN2KOver0183, parseN2KOver0183, parsePDGY, parseActisenseN2KASCII } = require('./stringMsg')
 
 var fieldTypeReaders = {}
 var fieldTypePostProcessors = {}
@@ -299,7 +299,7 @@ class Parser extends EventEmitter {
     } else if ( _.isBuffer(data) ) {
       return this.parseBuffer(data, cb)
     } else {
-      return this.parsePgnData(data.pgn, data.length, data.data, false, cb)
+      return this.parsePgnData(data.pgn, data.length, data.data, data.coalesced === true)
     }
   }
 
@@ -381,6 +381,29 @@ class Parser extends EventEmitter {
     return undefined
   }
 
+  //Yacht Devices NMEA2000 Wifi gateway
+  parseActisenceN2KAscii(pgn_data, cb) {
+    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)
+        this.emit('error', pgn_data, error)
+      }
+    } catch ( error ) {
+      cb && cb(error)
+      this.emit('error', pgn_data, error)
+    }
+    return undefined
+  }
+
   parsePDGY(pgn_data, cb) {
     if ( pgn_data[0] != '!') {
       return

package/lib/n2k-actisense.js

@@ -0,0 +1,124 @@
+const debug = require('debug')('canboatjs:w2k01')
+const debugData = require('debug')('canboatjs:w2k01-data')
+const { parseCanId, encodeCanId } = require('./canId')
+const BitStream = require('bit-buffer').BitStream
+
+exports.readN2KActisense = function (data, plainText, context, cb) {
+  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 ) {
+      let 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
+      }
+      
+      let buf = Buffer.alloc(len)
+      inBuf.copy(buf, 0, inOffset+5, inOffset+len+5)
+      
+      //console.log('NextBuf: (' + buf.length + ') ' + buf.toString('hex'))
+      
+      let offset = 0
+      let dst = buf.readUInt8(offset)
+      offset += 1
+      let canid = buf.readUInt32LE(offset)
+      offset += 4
+      let timestamp = buf.readUInt32LE(offset)
+      offset += 4
+      let mhs = buf.readUInt8(offset)
+      offset += 1
+    
+      let info = parseCanId(canid)
+
+      //console.log(`${len} ${mhs} ${dst} (${info.src}, ${info.dst}) ${info.pgn} ${timestamp}`)
+    
+      let pgnData = Buffer.alloc(len-offset-3)
+      buf.copy(pgnData, 0, offset, len-3)
+      info.timestamp = new Date().toISOString()
+      
+      if ( plainText ) {
+        last = binToActisense(info, 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
+  }
+}
+
+exports.encodeN2KActisense  = ({
+  pgn, data, timestamp, prio = 2, dst = 255, src = 0 }) => {
+    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(dst)
+    bs.writeUint32(encodeCanId({dst, pgn, prio, src}))
+    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
+  }
+
+
+function binToActisense(pgn, data, length) {
+  return (
+    pgn.timestamp +
+      `,${pgn.prio},${pgn.pgn},${pgn.src},${pgn.dst},${length},` +
+      new Uint32Array(data)
+      .reduce(function(acc, i) {
+        acc.push(i.toString(16));
+        return acc;
+      }, [])
+      .map(x => (x.length === 1 ? "0" + x : x))
+      .join(",")
+  );
+}
+
+

package/lib/n2k-actisense.test.js

@@ -0,0 +1,59 @@
+const { readN2KActisense, encodeN2KActisense } = require('./n2k-actisense')
+
+
+describe('readN2KActisense', () => {
+  test('basic msg', () => {
+    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,
+      }
+    })
+  })
+})
+
+
+describe('encodeN2KActisense', () => {
+  test('basic msg', () => {
+    const expected = '1002d01500ff0501f80900000000000d474717e2da69d2001003'
+    const pgn = {
+      "data": Buffer.from('0d474717e2da69d2', 'hex'),
+      "dst": 255,
+      "pgn": 129025,
+      "prio": 2,
+      "src": 5,
+    }
+
+    const encoded = encodeN2KActisense(pgn)
+    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,
+      }
+    })
+    
+    
+  })
+})
+
+

package/lib/stringMsg.js

@@ -63,6 +63,34 @@ exports.toActisenseSerialFormat = (pgn, data, dst=255, src=0) => exports.encodeA
   pgn, data, dst, src,
 })
 
+// A764027.880 05FF7 1EF00 E59861060202FFFFFFFF03030000FFFFFFFFFFFFFFFFFFFF0000FFFFFF7FFFFFFF7FFFFFFF7F0000FF7F
+exports.isActisenseN2KASCII = input => input.charAt(0) === 'A' && input.charAt(7) === '.' && input.charAt(11) === ' '
+exports.parseActisenseN2KASCII = (input) => {
+  const [ timestamp, srcdstp, pgn, data ] = input.split(' ')
+  const src = parseInt(srcdstp.substring(0, 2), 16)
+  const dst = parseInt(srcdstp.substring(2,4), 16)
+  const prio = parseInt(srcdstp.substring(4))
+  return buildMsg(
+    buildCanId(prio, parseInt(pgn, 16), dst, src),
+    'Actisense N2K ASCII',
+    Buffer.from(data, 'hex'),
+    { len: data.length, time: timestamp.substring(1) },
+  )
+}
+exports.encodeActisenseN2KACSII = ({
+  pgn, data, timestamp, prio = 2, dst = 255, src = 0 }) => {
+    timestamp = 'A000000.000'
+    
+    const srcdstp = hexByte(src) + hexByte(dst) + prio
+    return ([
+      timestamp,
+      srcdstp.toUpperCase(),
+      toPaddedHexString(pgn, 5).toUpperCase(),
+      byteString(data, '').toUpperCase()
+    ].join(' '))
+  }
+
+
 // 16:29:27.082 R 09F8017F 50 C3 B8 13 47 D8 2B C6
 exports.isYDRAW = (input) => {
   if (input.charAt(2) !== ':') return false
@@ -232,6 +260,7 @@ exports.parseN2kString = cond([
   [exports.isCandump2, exports.parseCandump2],
   [exports.isCandump3, exports.parseCandump3],
   [exports.isPDGYdebug, exports.parsePDGYdebug],
+  [exports.isActisenseN2KASCII, exports.parseActisenseN2KASCII],
   [stubTrue, buildErr('MISSING_PARSER', 'Parser not found for input.')],
 ])
 
@@ -246,6 +275,7 @@ exports.isN2KString = cond([
   [exports.isCandump2, () => true],
   [exports.isCandump3, () => true],
   [exports.isPDGYdebug, () => true],
+  [exports.isActisenseN2KASCII, () => true],
   [stubTrue, () => false],
 ])
 

package/lib/stringMsg.test.js

@@ -1,6 +1,6 @@
 const {
   encodeActisense, encodeYDRAW, parseActisense, parseCandump1, parseCandump2,
-  parsePCDIN, parsePDGY, parseN2kString, parsePDGYdebug, parseYDRAW,
+  parsePCDIN, parsePDGY, parseN2kString, parsePDGYdebug, parseYDRAW, encodeActisenseN2KACSII, parseActisenseN2KASCII
 } = require('./stringMsg')
 
 /* globals describe test expect */
@@ -185,6 +185,32 @@ describe('encodeYDRAW', () => {
     ])
   })
 })
+
+describe('parseActisenseN2KASCII', () => {
+  test('basic msg', () => {
+    const msg = 'A000021.293 05FF2 1F802 FFFC289A1600FFFF'
+    expect(parseActisenseN2KASCII(msg)).toEqual({
+      data: Buffer.from('FFFC289A1600FFFF', 'hex'),
+      "dst": 255,
+      "format": "Actisense N2K ASCII",
+      "len": 16,
+      "pgn": 129026,
+      "prio": 2,
+      "src": 5,
+      "time": "000021.293"
+    })
+  })
+})
+describe('encodeActisenseN2KACSII', () => {
+  test('basic msg', () => {
+    const msg = 'A000000.000 05FF2 1F802 FFFC289A1600FFFF'
+    const n2k = parseActisenseN2KASCII(msg)
+    const res = encodeActisenseN2KACSII(n2k)
+    expect(res).toEqual(msg)
+  })
+})
+
+
 describe('parseN2kString', () => {
   test('empty string or not string', () => {
     const emptyMsg = 'Input not string or empty.'

package/lib/toPgn.js

@@ -21,7 +21,8 @@ const BitStream = require('bit-buffer').BitStream
 const Int64LE = require('int64-buffer').Int64LE
 const Uint64LE = require('int64-buffer').Uint64LE
 const { getPlainPGNs } = require('./utilities')
-const { encodeActisense, encodeYDRAW, parseActisense, encodePCDIN, encodeMXPGN, encodePDGY } = require('./stringMsg')
+const { encodeActisense, encodeActisenseN2KACSII, encodeYDRAW, parseActisense, encodePCDIN, encodeMXPGN, encodePDGY } = require('./stringMsg')
+const { encodeN2KActisense } = require('./n2k-actisense')
 const { encodeCanId } = require('./canId')
 const { getIndustryCode, getManufacturerCode } = require('./codes')
 const debug = require('debug')('canboatjs:toPgn')
@@ -291,6 +292,14 @@ function pgnToActisenseSerialFormat(pgn) {
   return encodeActisense({ pgn: pgn.pgn, data: toPgn(pgn), dst: pgn.dst})
 }
 
+function pgnToActisenseN2KAsciiFormat(pgn) {
+  return encodeActisenseN2KACSII({ pgn: pgn.pgn, data: toPgn(pgn), dst: pgn.dst})
+}
+
+function pgnToN2KActisenseFormat(pgn) {
+  return encodeN2KActisense({ pgn: pgn.pgn, data: toPgn(pgn), dst: pgn.dst})
+}
+
 function toiKonvertSerialFormat(pgn, data, dst=255) {
   return `!PDGY,${pgn},${dst},${data.toString('base64')}`
 }
@@ -315,6 +324,8 @@ const actisenseToYdgwRawFormat = _.flow(parseActisense, encodeYDRAW)
 const actisenseToPCDIN = _.flow(parseActisense, encodePCDIN)
 const actisenseToMXPGN = _.flow(parseActisense, encodeMXPGN)
 const actisenseToiKonvert = _.flow(parseActisense, encodePDGY)
+const actisenseToN2KAsciiFormat = _.flow(parseActisense, encodeActisenseN2KACSII)
+const actisenseToN2KActisenseFormat = _.flow(parseActisense, encodeN2KActisense)
 
 fieldTypeWriters['ASCII text'] = (pgn, field, value, bs) => {
 
@@ -431,8 +442,12 @@ module.exports.pgnToiKonvertSerialFormat = pgnToiKonvertSerialFormat
 module.exports.pgnToYdgwRawFormat = pgnToYdgwRawFormat
 module.exports.actisenseToYdgwRawFormat = actisenseToYdgwRawFormat
 module.exports.pgnToActisenseSerialFormat = pgnToActisenseSerialFormat
+module.exports.pgnToActisenseN2KAsciiFormat = pgnToActisenseN2KAsciiFormat
+module.exports.pgnToN2KActisenseFormat = pgnToN2KActisenseFormat
 module.exports.pgnToPCDIN = pgnToPCDIN
 module.exports.actisenseToPCDIN = actisenseToPCDIN
 module.exports.pgnToMXPGN = pgnToMXPGN
 module.exports.actisenseToMXPGN = actisenseToMXPGN
 module.exports.actisenseToiKonvert = actisenseToiKonvert
+module.exports.actisenseToN2KAsciiFormat = actisenseToN2KAsciiFormat
+module.exports.actisenseToN2KActisenseFormat = actisenseToN2KActisenseFormat

package/lib/w2k01.js

@@ -0,0 +1,127 @@
+/**
+ * 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.
+ */
+
+const debug = require('debug')('canboatjs:w2k01')
+const debugData = require('debug')('canboatjs:w2k01-data')
+const Transform = require('stream').Transform
+const _ = require('lodash')
+const { pgnToActisenseN2KAsciiFormat, actisenseToN2KAsciiFormat, pgnToN2KActisenseFormat, actisenseToN2KActisenseFormat } = require('./toPgn')
+const { readN2KActisense, encodeN2KActisense } = require('./n2k-actisense')
+
+const pgnsSent = {}
+
+const N2K_ASCII = 0
+const N2K_ACTISENSE = 1
+
+function W2K01Stream (options, type, outEvent) {
+  if (!(this instanceof W2K01Stream)) {
+    return new W2K01Stream(options)
+  }
+
+  Transform.call(this, {
+    objectMode: true
+  })
+
+  this.sentAvailable = false
+  this.options = options
+  this.outEvent = outEvent || 'w2k-1-out'
+
+  this.format = type === 'ascii' ? N2K_ASCII : N2K_ACTISENSE
+
+  if ( this.format === N2K_ASCII ) {
+    if ( options.app ) {
+      options.app.on(this.options.outEevent || 'nmea2000out', (msg) => {
+        if ( typeof msg === 'string' ) {
+          this.sendW2KPGN(msg)
+        } else {
+          this.sendPGN(msg)
+        }
+      })
+      
+      options.app.on('nmea2000JsonOut', (msg) => {
+        this.sendPGN(msg)
+      })
+    }
+  }
+
+  debug('started')
+}
+
+W2K01Stream.prototype.send = function (msg) {
+  debug('sending %s', msg)
+  this.options.app.emit(this.outEvent, msg)
+}
+
+W2K01Stream.prototype.sendPGN = function (pgn) {
+  let now = Date.now()
+  let lastSent = pgnsSent[pgn.pgn]
+  if ( this.format === N2K_ASCII ) {
+    let ascii = pgnToActisenseN2KAsciiFormat(pgn)
+    this.send(ascii + '\r\n')
+  } else {
+    let buf = pgnToN2KActisenseFormat(pgn)
+    this.send(buf)
+  }
+  pgnsSent[pgn.pgn] = now
+}
+
+W2K01Stream.prototype.sendW2KPGN = function (msg) {
+  if ( this.format === N2K_ASCII ) {
+    let ascii = actisenseToN2KAsciiFormat(msg)
+    this.send(ascii + '\r\n')
+  } else {
+    let buf = actisenseToN2KActisenseFormat
+    this.send(buf)
+  }
+}
+
+require('util').inherits(W2K01Stream, Transform)
+
+W2K01Stream.prototype._transform = function (chunk, encoding, done) {
+  if ( !this.sentAvailable && this.format === N2K_ASCII ) {
+    debug('emit nmea2000OutAvailable')
+    this.options.app.emit('nmea2000OutAvailable')
+    this.sentAvailable = true
+  }
+
+  if ( this.format === N2K_ASCII ) {
+    if ( debugData.enabled ) {
+      debugData('Received: ' + chunk)
+    }
+    this.push(chunk)
+  } else {
+    readN2KActisense(chunk, this.plainText, this, (data) => {
+      this.push(data)
+    })
+  }
+  
+  done()
+}
+
+W2K01Stream.prototype.pipe = function (pipeTo) {
+  if ( !pipeTo.fromPgn ) {
+    this.plainText = true
+  } else {
+    this.plainText = false
+  }
+  return W2K01Stream.super_.prototype.pipe.call(this, pipeTo)
+}
+
+
+W2K01Stream.prototype.end = function () {
+}
+
+module.exports = W2K01Stream

package/lib/ydvr.js

@@ -0,0 +1,204 @@
+const BitStream = require('bit-buffer').BitStream;
+const Transform = require('stream').Transform;
+const FromPgn = require('./fromPgn').Parser
+const parseCanId = require('./canId').parseCanId;
+
+// https://www.yachtd.com/downloads/ydvr04.pdf Appendix D
+var sequencePgns = new Set([
+  65240,
+  126208,
+  126464,
+  126720,
+  126983,
+  126984,
+  126985,
+  126986,
+  126987,
+  126988,
+  126996,
+  126998,
+  127233,
+  127237,
+  127489,
+  127496,
+  127497,
+  127498,
+  127503,
+  127504,
+  127506,
+  127507,
+  127509,
+  127510,
+  127511,
+  127512,
+  127513,
+  127514,
+  128275,
+  128520,
+  129029,
+  129038,
+  129039,
+  129040,
+  129041,
+  129044,
+  129045,
+  129284,
+  129285,
+  129301,
+  129302,
+  129538,
+  129540,
+  129541,
+  129542,
+  129545,
+  129547,
+  129549,
+  129551,
+  129556,
+  129792,
+  129793,
+  129794,
+  129795,
+  129796,
+  129797,
+  129798,
+  129799,
+  129800,
+  129801,
+  129802,
+  129803,
+  129804,
+  129805,
+  129806,
+  129807,
+  129808,
+  129809,
+  129810,
+  130052,
+  130053,
+  130054,
+  130060,
+  130061,
+  130064,
+  130065,
+  130066,
+  130067,
+  130068,
+  130069,
+  130070,
+  130071,
+  130072,
+  130073,
+  130074,
+  130320,
+  130321,
+  130322,
+  130323,
+  130324,
+  130567,
+  130577,
+  130578,
+  130816,
+]);
+
+function YdvrStream() {
+  if (!(this instanceof YdvrStream)) {
+    return new YdvrStream();
+  }
+
+  this.parser = new FromPgn();
+
+  this.parser.on('error', (pgn, error) => {
+    console.error(`Error parsing ${pgn.pgn} ${error}`);
+    console.error(error.stack);
+  });
+
+  this.parser.on('warning', (pgn, error) => {
+    //console.error(`Warning parsing ${pgn.pgn} ${error}`)
+  });
+
+  // this.parser.on('pgn', (pgn) => {
+  //   console.log(JSON.stringify(pgn));
+  // });
+
+  Transform.call(this, {
+    objectMode: true,
+  });
+}
+
+require('util').inherits(YdvrStream, Transform);
+
+YdvrStream.prototype.end = function () {
+  // console.log('end');
+};
+
+YdvrStream.prototype.parseNextRecord = function () {
+  if (this.bs.bitsLeft < 6 * 8) {
+    return false;
+  }
+
+  var time = this.bs.readUint16();
+  let timeAbsolute;
+  if (this.lastTime != null && time < this.lastTime) {
+    this.timeOffset = (this.timeOffset || 0) + 60000;
+    timeAbsolute = time + timeOffset;
+  } else {
+    timeAbsolute = time;
+  }
+  this.lastTime = time;
+
+  var identifier = this.bs.readUint32();
+  if (identifier === 0xffffffff) {
+    // service record
+    var srData = this.bs.readArrayBuffer(8);
+  } else {
+    const pgn = parseCanId(identifier);
+
+    var bodyLen;
+    if (pgn.pgn == 59904) {
+      bodyLen = 3;
+    } else if (sequencePgns.has(pgn.pgn)) {
+      var seq = this.bs.readUint8();
+      bodyLen = this.bs.readUint8();
+    } else {
+      bodyLen = 8;
+    }
+    var body = this.bs.readArrayBuffer(bodyLen);
+
+    const parsed = this.parser.parsePgnData(
+      { ...pgn, time: new Date(time).toISOString().slice(11, 23) },
+      bodyLen,
+      Buffer.from(body),
+      false,
+      undefined
+    );
+    if (parsed) {
+      this.push(parsed);
+    }
+  }
+
+  return true;
+}
+
+YdvrStream.prototype._transform = function (chunk, encoding, done) {
+  if (this.bs == null) {
+    this.bs = new BitStream(chunk);
+  } else {
+    var remainingBuffer = this.bs.view.buffer.subarray(this.bs.byteIndex);
+    this.bs = new BitStream(Buffer.concat([remainingBuffer, chunk]));
+  }
+  while (true) {
+    var startIndex = this.bs.byteIndex
+    let parsed = false;
+    try {
+      parsed = this.parseNextRecord();
+    } catch (ex) { }
+    if (!parsed) {
+      this.bs.byteIndex = startIndex;
+      break;
+    }
+  }
+  done();
+};
+
+module.exports = YdvrStream

package/n2ka.js

@@ -0,0 +1,123 @@
+var net = require('net');
+const BitStream = require('bit-buffer').BitStream
+const BitView = require('bit-buffer').BitView
+const cid = require('./lib/canId')
+const FromPgn = require('./lib/fromPgn').Parser
+const debug = require('debug')('canboatjs:w2k01')
+
+var client = new net.Socket();
+client.connect(60003, '192.168.1.145', function() {
+  console.log('Connected');
+});
+
+client.on('data', function(data) {
+  const parser = new FromPgn()
+  
+  /*
+  var obuf = Buffer.from(data)
+  let len = obuf.readUInt16LE(3)
+
+  let buf = Buffer.alloc(len)
+  obuf.copy(buf, 0, 5, len+5)
+  console.log('New Buf: ' + buf.toString('hex'))
+  let offset = 0
+  let dst = buf.readUInt8(offset)
+  offset += 1
+  let canid = buf.readUInt32LE(offset)
+  offset += 4
+  let timestamp = buf.readUInt32LE(offset)
+  offset += 4
+  let mhs = buf.readUInt8(offset)
+  offset += 1
+  
+  let info = cid.parseCanId(canid)
+
+  console.log(`(${len}, ${data.length}) (${info.src}, ${info.dst}) ${info.pgn} ${timestamp}`)
+  
+
+  try {
+    let pgnData = Buffer.alloc(len-offset-2)
+    buf.copy(pgnData, 0, offset, len-2)
+    console.log('pgnData: ' + pgnData.toString('hex'))
+    let pgn = parser.parsePgnData(info, pgnData.length, pgnData, true)
+    console.log(pgn)
+  } catch (error) {
+
+    console.log(error)
+  }
+  */
+
+  debug('Received: (' + data.length + ') ' + Buffer.from(data).toString('hex'))
+  
+  var inBuf = Buffer.from(data)
+  var inOffset = 0
+
+  while ( true ) {
+    let len = inBuf.readUInt16LE(inOffset+3)
+
+    if ( inBuf.length < inOffset + 5 + len ) {
+      console.log('PARTIAL PGN')
+      this.lastChunk = Buffer.alloc(inBuf.length - inOffset)
+      inBuf.copy(this.lastChunk, 0, inOffset, inBuf.length-1)
+      return
+    } else if ( inBuf[inOffset + 5 + len -1] != 0x03 ||
+                inBuf[inOffset + 5 + len -2] != 0x10 ) {
+      //console.log('Received: (' + data.length + ') ' + Buffer.from(data).toString('hex'))
+      //console.log('LENGTH MISMATCH ' + inBuf[inOffset + 5 + len -1])
+      return
+    }
+    
+    let buf = Buffer.alloc(len)
+    inBuf.copy(buf, 0, inOffset+5, inOffset+len+5)
+
+   
+    let offset = 0
+    let dst = buf.readUInt8(offset)
+    offset += 1
+    let canid = buf.readUInt32LE(offset)
+    offset += 4
+    let timestamp = buf.readUInt32LE(offset)
+    offset += 4
+    let mhs = buf.readUInt8(offset)
+    offset += 1
+    
+    let info = cid.parseCanId(canid)
+
+    if ( info.pgn != 129025)
+      return
+
+    let pgnData = Buffer.alloc(len-offset-3)
+    buf.copy(pgnData, 0, offset, len-3)
+
+    /*
+    console.log('inputLen: ' + inBuf.length)
+    console.log('NextBuf: (' + buf.length + ') ' + buf.toString('hex'))
+    console.log('pgnData: (' + pgnData.length + ') ' + pgnData.toString('hex'))
+
+    console.log(`${len} ${mhs} ${dst} (${info.src}, ${info.dst}) ${info.pgn} ${timestamp}`)
+    */
+    
+    let pgn = parser.parsePgnData(info, pgnData.length, pgnData, true)
+    if ( pgn ) {
+      //console.log(JSON.stringify(pgn))
+      
+    }
+    
+    inOffset += len + 5
+    //console.log(`inOffset ${inOffset} `)
+    if ( inOffset >= inBuf.length  ) {
+      return
+    }
+    break
+  }
+});
+
+client.on('close', function() {
+  console.log('Connection closed');
+})
+
+process.on('SIGINT', () => {
+  console.info('SIGINT signal received.');
+  client.destroy()
+});
+  

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canboat/canboatjs",
-  "version": "1.22.2",
+  "version": "1.24.0",
   "description": "Native javascript version of canboat",
   "main": "index.js",
   "scripts": {
@@ -53,7 +53,7 @@
     "@canboat/pgns": "^1.4.0",
     "bit-buffer": "0.2.3",
     "date-fns": "2.0.0-alpha.27",
-    "debug": "^4.1.1",
+    "debug": "^4.3.4",
     "dnssd": "^0.4.1",
     "int64-buffer": "^0.1.10",
     "lodash": "^4.17.4",

package/wk2.out

@@ -0,0 +1,224 @@
+A000021.144 05FF2 1F801 F04E4717B2E569D2
+A000021.244 05FF2 1F801 EF4E4717B3E569D2
+A000021.293 05FF2 1F802 FFFC289A1600FFFF
+A000021.344 05FF2 1F801 EF4E4717B3E569D2
+A000021.355 05FF7 1EF00 E59861060202FFFFFFFF03030000FFFFFFFFFFFFFFFFFFFF0000FFFFFF7FFFFFFF7FFFFFFF7F0000FF7F
+A000021.360 05FF7 1EF00 E59812070202FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7F
+A000021.363 05FF3 1F904 FFFFFFFFFF0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7FFF7F
+A000021.367 05FF3 1F903 FFF0FFFFFF7FFFFF
+A000021.444 05FF2 1F801 EE4E4717B4E569D2
+A000021.544 05FF2 1F802 FFFC289A1700FFFF
+A000021.544 05FF2 1F801 F04E4717AFE569D2
+A000021.644 05FF2 1F801 F14E4717ABE569D2
+A000021.700 05FF7 1EF00 E598E708000A0301030DDDB7C684051101
+A000021.744 05FF2 1F801 F24E4717A8E569D2
+A000021.794 05FF2 1F802 FFFC289A1900FFFF
+A000021.844 05FF2 1F801 F34E4717A4E569D2
+A000021.944 05FF2 1F801 F34E4717A1E569D2
+A000022.041 05FF7 1EF00 E5984819020203030101030F08FF0F00303CA31C0113C6A90F
+A000022.044 05FF3 1F805 FFDB4BA48A7822C068149B75826B05808477E7A7D762F5998A99000000000014FC06CD002A03AAF2FFFF00
+A000022.046 05FF6 1F11A FFF2DB4B69F8FFFF
+A000022.068 05FF6 1FA03 FFDACD0010036F02
+A000022.068 05FF7 1EF00 E5981700040453487B42F4D0E942AFB70443000000000000000000000000000000000000000000000000F29C0340CE06FB4022C10141BA7EC74000000000
+A000022.073 05FF2 1F802 FFFC289A1D00FFFF
+A000022.073 05FF2 1F801 F44E47179EE569D2
+A000022.144 05FF2 1F801 F14E471797E569D2
+A000022.244 05FF2 1F801 EC4E471799E569D2
+A000022.294 05FF2 1F802 FFFC289A2800FFFF
+A000022.344 05FF2 1F801 E74E47179BE569D2
+A000022.355 05FF7 1EF00 E59861060202FFFFFFFF03030000FFFFFFFFFFFFFFFFFFFF0000FFFFFF7FFFFFFF7FFFFFFF7F0000FF7F
+A000022.360 05FF7 1EF00 E59812070202FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7F
+A000022.362 05FF3 1F904 FFFFFFFFFF0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7FFF7F
+A000022.366 05FF3 1F903 FFF0FFFFFF7FFFFF
+A000022.387 05FF7 1EF00 E598E008020203090012E8071900
+A000022.389 05FF7 1EF00 E598E008020203090112E8071900
+A000022.391 05FF7 1EF00 E598E008020203090B11011900
+A000022.392 05FF7 1EF00 E598E008020203090C12E8071900
+A000022.444 05FF2 1F801 E04E47179CE569D2
+A000022.544 05FF2 1F802 FFFC289A3200FFFF
+A000022.544 05FF2 1F801 F54E471771E569D2
+A000022.644 05FF2 1F801 ED4E471772E569D2
+A000022.700 05FF7 1EF00 E598E708000A0301030DDDB7C684051101
+A000022.744 05FF2 1F801 E54E471772E569D2
+A000022.794 05FF2 1F802 FFFC289A4600FFFF
+A000022.844 05FF2 1F801 DB4E471772E569D2
+A000022.944 05FF2 1F801 D24E471771E569D2
+A000023.044 05FF3 1F805 FFDB4BDBB17822804FA0566B826B0580C203F09CD762F53F9891000000000014FC06CD002A03AAF2FFFF00
+A000023.049 05FF6 1F11A FFF2DB4B69F8FFFF
+A000023.068 05FF6 1FA03 FFDACD0010036F02
+A000023.068 05FF7 1EF00 E598170004043EAD77420D9DE84217C303430000000000000000000000000000000000000000000000007193034085F4FA40B0B701418E6FC74000000000
+A000023.072 05FF2 1F802 FFFC289A5300FFFF
+A000023.072 05FF2 1F801 C84E47176FE569D2
+A000023.144 05FF2 1F801 C24E47176DE569D2
+A000023.244 05FF2 1F801 B84E47176BE569D2
+A000023.294 05FF2 1F802 FFFC289A5900FFFF
+A000023.344 05FF2 1F801 AE4E471769E569D2
+A000023.355 05FF7 1EF00 E59861060202FFFFFFFF03030000FFFFFFFFFFFFFFFFFFFF0000FFFFFF7FFFFFFF7FFFFFFF7F0000FF7F
+A000023.360 05FF7 1EF00 E59812070202FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7F
+A000023.362 05FF3 1F904 FFFFFFFFFF0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7FFF7F
+A000023.366 05FF3 1F903 FFF0FFFFFF7FFFFF
+A000023.443 05FF2 1F801 9E4E471764E569D2
+A000023.541 05FF7 1EF00 E5984719020206030101030F08FF0F00303CA31C011100190022904E2B9EA10C
+A000023.544 05FF2 1F802 FFFC8B956500FFFF
+A000023.545 05FF2 1F801 914E471761E569D2
+A000023.644 05FF2 1F801 984E471762E569D2
+A000023.700 05FF7 1EF00 E598E708000A0301030DDDB7C684051101
+A000023.744 05FF2 1F801 3A4E471754E569D2
+A000023.794 05FF2 1F802 FFFC488E6900FFFF
+A000023.844 05FF2 1F801 314E471752E569D2
+A000023.944 05FF2 1F801 2A4E471752E569D2
+A000024.041 05FF7 1EF00 E5984819020203030101030F08FF0F00303CA31C0113C7A90F
+A000024.044 05FF3 1F805 FFDB4BC4D87822C0589B0945826B0500F03E8196D762F52BF085000000000014FC06CD002A03AAF2FFFF00
+A000024.048 05FF6 1F11A FFF2DB4B69F8FFFF
+A000024.068 05FF6 1FA03 FFDACD0010036F02
+A000024.068 05FF7 1EF00 E59817000404AF8B764259E0E742CB4D0343000000000000000000000000000000000000000000000000EB8903401DE2FA402EAE01414C60C74000000000
+A000024.071 05FF2 1F802 FFFCDE896200FFFF
+A000024.075 05FF2 1F801 234E471753E569D2
+A000024.144 05FF2 1F801 204E471754E569D2
+A000024.244 05FF2 1F801 1D4E471754E569D2
+A000024.294 05FF2 1F802 FFFC78865600FFFF
+A000024.344 05FF2 1F801 1A4E471754E569D2
+A000024.354 05FF7 1EF00 E59861060202FFFFFFFF03030000FFFFFFFFFFFFFFFFFFFF0000FFFFFF7FFFFFFF7FFFFFFF7F0000FF7F
+A000024.360 05FF7 1EF00 E59812070202FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7F
+A000024.362 05FF3 1F904 FFFFFFFFFF0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7FFF7F
+A000024.364 05FF3 1F903 FFF0FFFFFF7FFFFF
+A000024.387 05FF7 1EF00 E598E008020203090012E8071900
+A000024.389 05FF7 1EF00 E598E008020203090112E8071900
+A000024.391 05FF7 1EF00 E598E008020203090B11011900
+A000024.392 05FF7 1EF00 E598E008020203090C12E8071900
+A000024.444 05FF2 1F801 174E471755E569D2
+A000024.544 05FF2 1F802 FFFC78865000FFFF
+A000024.545 05FF2 1F801 144E471755E569D2
+A000024.644 05FF2 1F801 114E471756E569D2
+A000024.700 05FF7 1EF00 E598E708000A0301030DDDB7C684051101
+A000024.744 05FF2 1F801 074E471756E569D2
+A000024.794 05FF2 1F802 FFFC78864900FFFF
+A000024.844 05FF2 1F801 FF4D471755E569D2
+A000024.944 05FF2 1F801 F84D471755E569D2
+A000025.044 05FF3 1F805 FFDB4BD4FF7822C025B34D38826B0500CB59C196D762F5753F7F000000000014FC06CD002A03AAF2FFFF00
+A000025.049 05FF6 1F11A FFF2DB4B69F8FFFF
+A000025.066 05FF6 1FA03 FFDACD000F036E02
+A000025.068 05FF7 1EF00 E59817000404677C7742E7F1E742D47103430000000000000000000000000000000000000000000000005F800340A2CFFA40A3A40141F950C74000000000
+A000025.072 05FF2 1F802 FFFC78864500FFFF
+A000025.072 05FF2 1F801 EC4D471754E569D2
+A000025.144 05FF2 1F801 E14D471754E569D2
+A000025.244 05FF2 1F801 D64D471754E569D2
+A000025.294 05FF2 1F802 FFFC78864300FFFF
+A000025.344 05FF2 1F801 CB4D471754E569D2
+A000025.355 05FF7 1EF00 E59861060202FFFFFFFF03030000FFFFFFFFFFFFFFFFFFFF0000FFFFFF7FFFFFFF7FFFFFFF7F0000FF7F
+A000025.360 05FF7 1EF00 E59812070202FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7F
+A000025.362 05FF3 1F904 FFFFFFFFFF0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7FFF7F
+A000025.365 05FF3 1F903 FFF0FFFFFF7FFFFF
+A000025.444 05FF2 1F801 C04D471754E569D2
+A000025.544 05FF2 1F802 FFFC78864000FFFF
+A000025.544 05FF2 1F801 B54D471754E569D2
+A000025.644 05FF2 1F801 AA4D471754E569D2
+A000025.700 05FF7 1EF00 E598E708000A0301030DDDB7C684051101
+A000025.744 05FF2 1F801 A44D471755E569D2
+A000025.794 05FF2 1F802 FFFC78863E00FFFF
+A000025.844 05FF2 1F801 9E4D471755E569D2
+A000025.944 05FF2 1F801 7A4D471756E569D2
+A000026.044 05FF3 1F805 FFDB4B0B277922005557F01B826B05004210BF97D762F528937E000000000014FC06CD002A03AAF2FFFF00
+A000026.049 05FF6 1F11A FFF2DB4B69F8FFFF
+A000026.063 05FF6 1FA03 FFDACD000F036E02
+A000026.068 05FF7 1EF00 E59817000404E2F8784290E3E84238090443000000000000000000000000000000000000000000000000CB76034014BDFA400E9B01419741C74000000000
+A000026.073 05FF2 1F802 FFFC78864200FFFF
+A000026.073 05FF2 1F801 734D471759E569D2
+A000026.073 05FF7 1EF00 E5984719020206030101030F08FF0F00303CA31C011100190022904E2B9FA10C
+A000026.078 05FF7 1EF00 E5984819020203030101030F08FF0F00303CA31C0113C8A90F
+A000026.144 05FF2 1F801 6A4D47175BE569D2
+A000026.244 05FF2 1F801 614D47175EE569D2
+A000026.294 05FF2 1F802 FFFC78865300FFFF
+A000026.344 05FF2 1F801 574D471760E569D2
+A000026.355 05FF7 1EF00 E59861060202FFFFFFFF03030000FFFFFFFFFFFFFFFFFFFF0000FFFFFF7FFFFFFF7FFFFFFF7F0000FF7F
+A000026.360 05FF7 1EF00 E59812070202FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7F
+A000026.362 05FF3 1F904 FFFFFFFFFF0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7FFF7F
+A000026.365 05FF3 1F903 FFF0FFFFFF7FFFFF
+A000026.387 05FF7 1EF00 E598E008020203090012E8071900
+A000026.389 05FF7 1EF00 E598E008020203090112E8071900
+A000026.391 05FF7 1EF00 E598E008020203090B11011900
+A000026.392 05FF7 1EF00 E598E008020203090C12E8071900
+A000026.444 05FF2 1F801 4C4D471763E569D2
+A000026.544 05FF2 1F802 FFFCE6846100FFFF
+A000026.544 05FF2 1F801 464D471763E569D2
+A000026.644 05FF2 1F801 404D471762E569D2
+A000026.700 05FF7 1EF00 E598E708000A0301030DDDB7C684051101
+A000026.744 05FF2 1F801 394D471761E569D2
+A000026.794 05FF2 1F802 FFFC38826B00FFFF
+A000026.844 05FF2 1F801 324D471760E569D2
+A000026.944 05FF2 1F801 2B4D471760E569D2
+A000027.044 05FF3 1F805 FFDB4BF44D7922402890A309826B0580C6D36299D762F5B41E7E000000000014FC06CD002903AAF2FFFF00
+A000027.048 05FF6 1F11A FFF2DB4B69F8FFFF
+A000027.065 05FF6 1FA03 FFDACD000F036E02
+A000027.065 05FF7 1EF00 E5981700040469777B42F0FAE942BFCF04430000000000000000000000000000000000000000000000002F6D034068AAFA406B9101411E32C74000000000
+A000027.072 05FF2 1F802 FFFCC07E7800FFFF
+A000027.072 05FF2 1F801 244D471760E569D2
+A000027.144 05FF2 1F801 184D47175FE569D2
+A000027.244 05FF2 1F801 0B4D47175FE569D2
+A000027.294 05FF2 1F802 FFFC6F7C7D00FFFF
+A000027.344 05FF2 1F801 FE4C47175EE569D2
+A000027.355 05FF7 1EF00 E59861060202FFFFFFFF03030000FFFFFFFFFFFFFFFFFFFF0000FFFFFF7FFFFFFF7FFFFFFF7F0000FF7F
+A000027.360 05FF7 1EF00 E59812070202FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7F
+A000027.362 05FF3 1F904 FFFFFFFFFF0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7FFF7F
+A000027.366 05FF3 1F903 FFF0FFFFFF7FFFFF
+A000027.444 05FF2 1F801 F34C47175FE569D2
+A000027.544 05FF2 1F802 FFFC5E7A8000FFFF
+A000027.544 05FF2 1F801 C34C47175FE569D2
+A000027.642 05FF2 1F801 B64C471760E569D2
+A000027.707 05FF7 1EF00 E598E708000A0301030DDDB7C684051101
+A000027.744 05FF2 1F801 AA4C47175FE569D2
+A000027.794 05FF2 1F802 FFFC177A8700FFFF
+A000027.844 05FF2 1F801 A24C47175EE569D2
+A000027.944 05FF2 1F801 874C47175FE569D2
+A000028.041 05FF7 1EF00 E5984819020203030101030F08FF0F00303CA31C0113C9A90F
+A000028.044 05FF3 1F805 FFDB4B0475792200D0CA4FE2816B0580641E6B99D762F5ACF17D000000000014FC06CD002903AAF2FFFF00
+A000028.048 05FF6 1F11A FFF2DB4B69F8FFFF
+A000028.068 05FF6 1FA03 FFDACD000F036E02
+A000028.068 05FF7 1EF00 E598170004049E9A7E42D81AEB42C6AD05430000000000000000000000000000000000000000000000008A630340A097FA40B88701418E22C74000000000
+A000028.074 05FF2 1F802 FFFC92798600FFFF
+A000028.074 05FF2 1F801 7B4C471760E569D2
+A000028.144 05FF2 1F801 764C471762E569D2
+A000028.244 05FF2 1F801 714C471764E569D2
+A000028.294 05FF2 1F802 FFFCFA768000FFFF
+A000028.344 05FF2 1F801 5C4C47176BE569D2
+A000028.355 05FF7 1EF00 E59861060202FFFFFFFF03030000FFFFFFFFFFFFFFFFFFFF0000FFFFFF7FFFFFFF7FFFFFFF7F0000FF7F
+A000028.359 05FF7 1EF00 E59812070202FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7F
+A000028.362 05FF3 1F904 FFFFFFFFFF0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7FFF7F
+A000028.367 05FF3 1F903 FFF0FFFFFF7FFFFF
+A000028.386 05FF7 1EF00 E598E008020203090012E8071900
+A000028.389 05FF7 1EF00 E598E008020203090112E8071900
+A000028.391 05FF7 1EF00 E598E008020203090B11011900
+A000028.392 05FF7 1EF00 E598E008020203090C12E8071900
+A000028.444 05FF2 1F801 584C47176EE569D2
+A000028.541 05FF7 1EF00 E5984719020206030101030F08FF0F00303CA31C011100190022904E2BA0A10C
+A000028.544 05FF2 1F802 FFFC82737900FFFF
+A000028.545 05FF2 1F801 4C4C471778E569D2
+A000028.644 05FF2 1F801 464C471780E569D2
+A000028.707 05FF7 1EF00 E598E708000A0301030DDDB7C684051101
+A000028.744 05FF2 1F801 404C47177EE569D2
+A000028.794 05FF2 1F802 FFFC146C6C00FFFF
+A000028.844 05FF2 1F801 3C4C471780E569D2
+A000028.944 05FF2 1F801 354C471787E569D2
+A000029.044 05FF3 1F805 FFDB4B149C7922801525F6D0816B050017A601A3D762F5F8567D000000000014FC06CD002903AAF2FFFF00
+A000029.048 05FF6 1F11A FFF2DB4B69F8FFFF
+A000029.067 05FF6 1FA03 FFDACD000E036E02
+A000029.068 05FF7 1EF00 E598170004045FD480425FF3EB424A6A0643000000000000000000000000000000000000000000000000D75A0340A886FA40F67E01417F14C74000000000
+A000029.074 05FF2 1F802 FFFCCE696A00FFFF
+A000029.074 05FF2 1F801 314C471789E569D2
+A000029.144 05FF2 1F801 2C4C47178BE569D2
+A000029.244 05FF2 1F801 254C471792E569D2
+A000029.293 05FF2 1F802 FFFCE0646700FFFF
+A000029.344 05FF2 1F801 294C47178CE569D2
+A000029.355 05FF7 1EF00 E59861060202FFFFFFFF03030000FFFFFFFFFFFFFFFFFFFF0000FFFFFF7FFFFFFF7FFFFFFF7F0000FF7F
+A000029.359 05FF7 1EF00 E59812070202FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7F
+A000029.362 05FF3 1F904 FFFFFFFFFF0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF7FFF7F
+A000029.362 05FF3 1F903 FFF0FFFFFF7FFFFF
+A000029.444 05FF2 1F801 244C471790E569D2
+A000029.544 05FF2 1F802 FFFCB0636800FFFF
+A000029.544 05FF2 1F801 1B4C471796E569D2
+A000029.644 05FF2 1F801 134C47179CE569D2
+A000029.708 05FF7 1EF00 E598E708000A0301030DDDB7C684051101
+A000029.744 05FF2 1F801 0A4C4717A3E569D2
+A000029.792 05FF2 1F802 FFFC74656800FFFF
+A000029.844 05FF2 1F801 004C4717A9E569D2
+A000029.944 05FF2 1F801 F64B4717AEE569D2