node-mavlink 1.0.8 → 1.0.9

package/dist/lib/utils.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+/**
+ * Convert a number to hexadecimal representation with a minumum
+ * number of characters and optional prefix (0x by default)
+ *
+ * @param n value to convert
+ * @param len length of the converted string (without prefix)
+ * @param prefix prefix to prepend the generated string with
+ */
+export declare function hex(n: number, len?: number, prefix?: string): string;
+/**
+ * Dump a buffer in a readable form
+ *
+ * @param buffer buffer to dump
+ * @param lineWidth width of the line, in bytes of buffer
+ */
+export declare function dump(buffer: Buffer, lineWidth?: number): void;
+/**
+ * Sleep for a given number of miliseconds
+ *
+ * @param ms number of miliseconds to sleep
+ */
+export declare function sleep(ms: any): Promise<unknown>;
+/**
+ * Execute a callback every <code>interval</code>ms and if it will not return
+ * a truthy value in the <code>timeout<code>ms then throw a Timeout exception.
+ * This is a very useful utility that will allow you to specify how often
+ * a particular expression should be evaluated and how long will it take to end
+ * the execution without success. Great for time-sensitive operations.
+ *
+ * @param cb callback to call every <code>interval</code>ms
+ * @param timeout number of miliseconds that need to pass before the Timeout exception is thrown
+ * @param interval number of miliseconds before re-running the callback
+ */
+export declare function waitFor(cb: any, timeout?: number, interval?: number): Promise<unknown>;

package/dist/lib/utils.js

@@ -0,0 +1,88 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitFor = exports.sleep = exports.dump = exports.hex = void 0;
+/**
+ * Convert a number to hexadecimal representation with a minumum
+ * number of characters and optional prefix (0x by default)
+ *
+ * @param n value to convert
+ * @param len length of the converted string (without prefix)
+ * @param prefix prefix to prepend the generated string with
+ */
+function hex(n, len = 2, prefix = '0x') {
+    return `${prefix}${n.toString(16).padStart(len, '0')}`;
+}
+exports.hex = hex;
+/**
+ * Dump a buffer in a readable form
+ *
+ * @param buffer buffer to dump
+ * @param lineWidth width of the line, in bytes of buffer
+ */
+function dump(buffer, lineWidth = 16) {
+    const line = [];
+    let address = 0;
+    for (let i = 0; i < buffer.length; i++) {
+        line.push(hex(buffer[i], 2, '0x'));
+        if (line.length === lineWidth) {
+            console.log(hex(address, 4), '|', line.join(' '));
+            address += lineWidth;
+            line.length = 0;
+        }
+    }
+    if (line.length > 0) {
+        console.log(hex(address, 4), '|', line.join(' '));
+    }
+}
+exports.dump = dump;
+/**
+ * Sleep for a given number of miliseconds
+ *
+ * @param ms number of miliseconds to sleep
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+exports.sleep = sleep;
+/**
+ * Execute a callback every <code>interval</code>ms and if it will not return
+ * a truthy value in the <code>timeout<code>ms then throw a Timeout exception.
+ * This is a very useful utility that will allow you to specify how often
+ * a particular expression should be evaluated and how long will it take to end
+ * the execution without success. Great for time-sensitive operations.
+ *
+ * @param cb callback to call every <code>interval</code>ms
+ * @param timeout number of miliseconds that need to pass before the Timeout exception is thrown
+ * @param interval number of miliseconds before re-running the callback
+ */
+function waitFor(cb, timeout = 10000, interval = 100) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            const timeoutTimer = setTimeout(() => {
+                cleanup();
+                reject('Timeout');
+            }, timeout);
+            const intervalTimer = setInterval(() => {
+                const result = cb();
+                if (result) {
+                    cleanup();
+                    resolve(result);
+                }
+            });
+            const cleanup = () => {
+                clearTimeout(timeoutTimer);
+                clearTimeout(intervalTimer);
+            };
+        });
+    });
+}
+exports.waitFor = waitFor;

package/examples/send-receive-file.ts

@@ -1,12 +1,12 @@
 #!/usr/bin/env -S npx ts-node
 
 import { createReadStream } from 'fs'
-import { MavLinkPacketSplitter, MavLinkPacketParser, MavLinkPacket } from '..'
+import { MavLinkPacketSplitter, MavLinkPacketParser } from '..'
 import { minimal, common, ardupilotmega, uavionix, icarous } from '..'
 
-const file = createReadStream('./mavlink-v2-3412-packets.bin')
+const file = createReadStream('./GH-5.bin')
 
-const splitter = new MavLinkPacketSplitter({}, true)
+const splitter = new MavLinkPacketSplitter()
 
 const reader = file
   .pipe(splitter)

package/index.ts

@@ -1,3 +1,5 @@
 export * from 'mavlink-mappings'
+export * from './lib/utils'
+export * from './lib/logger'
 export * from './lib/mavlink'
 export * from './lib/mavesp'

package/lib/logger.ts

@@ -0,0 +1,128 @@
+import EventEmitter = require('events')
+
+/**
+ * Level of the log entry
+ */
+export enum LogLevel {
+  trace     = 5,
+  debug     = 4,
+  info      = 3,
+  warn      = 2,
+  error     = 1,
+  fatal     = 0,
+}
+
+type LoggerRegistry = { [x: string]: Logger }
+type LoggerEvents = 'log'
+type LoggerEventHandler = (context: string, level: LogLevel, message: any[]) => void
+
+/**
+ * Simplified interface for logging facilities
+ */
+export class Logger {
+  private static readonly events: EventEmitter = new EventEmitter()
+  private static registry: LoggerRegistry = {}
+
+  /**
+   * Gets a logger by name
+   *
+   * @param context logger context
+   */
+  static getLogger(context) {
+    let name = ''
+    if (typeof context === 'function') name = context.name
+    else if (typeof context === 'object') name = (<any>context).constructor.name
+    else if (typeof context === 'string') name = context
+    else throw new Error(`Do not know how to get logger for ${context} (${typeof context})`)
+
+    if (!Logger.registry[name]) Logger.registry[name] = new Logger(name)
+
+    return Logger.registry[name]
+  }
+
+  /**
+   * Binds an event handler
+   *
+   * @param event event to react to
+   * @param handler event handler
+   */
+  static on(event: LoggerEvents, handler: (context, level, message) => void) {
+    this.events.on(event, handler)
+  }
+
+  /**
+   * Removes an event handler
+   *
+   * @param event event to react to
+   * @param handler event handler
+   */
+  static off(event: LoggerEvents, handler: LoggerEventHandler) {
+    this.events.off(event, handler)
+  }
+
+  private context: string
+
+  /**
+   * Constructs a new logger instance
+   *
+   * @param context logger context
+   */
+  constructor(context: string) {
+    this.context = context
+    Logger.events.emit('logger-created', Logger.registry[context])
+  }
+
+  /**
+   * Sends a log message if the trace level is enabled for this logger
+   *
+   * @param args parameters for the log entry
+   */
+  trace(...args: any) {
+    Logger.events.emit('log', { context: this.context, level: LogLevel.trace, message: args })
+  }
+
+  /**
+   * Sends a log message if the debug level is enabled for this logger
+   *
+   * @param args parameters for the log entry
+   */
+  debug(...args: any) {
+    Logger.events.emit('log', { context: this.context, level: LogLevel.debug, message: args })
+  }
+
+  /**
+   * Sends a log message if the info level is enabled for this logger
+   *
+   * @param args parameters for the log entry
+   */
+  info(...args: any) {
+    Logger.events.emit('log', { context: this.context, level: LogLevel.info, message: args })
+  }
+
+  /**
+   * Sends a log message if the warn level is enabled for this logger
+   *
+   * @param args parameters for the log entry
+   */
+  warn(...args: any) {
+    Logger.events.emit('log', { context: this.context, level: LogLevel.warn, message: args })
+  }
+
+  /**
+   * Sends a log message if the error level is enabled for this logger
+   *
+   * @param args parameters for the log entry
+   */
+  error(...args: any) {
+    Logger.events.emit('log', { context: this.context, level: LogLevel.error, message: args })
+  }
+
+  /**
+   * Sends a log message if the fatal level is enabled for this logger
+   *
+   * @param args parameters for the log entry
+   */
+  fatal(...args: any) {
+    Logger.events.emit('log', { context: this.context, level: LogLevel.fatal, message: args })
+  }
+}

package/lib/mavesp.ts

@@ -4,7 +4,8 @@ import { Socket, createSocket } from 'dgram'
 import { Writable, PassThrough } from 'stream'
 import { MavLinkPacketSplitter, MavLinkPacketParser, MavLinkPacketSignature } from './mavlink'
 import { MavLinkProtocol, MavLinkProtocolV2 } from './mavlink'
-import { uint8_t, waitFor, MavLinkData } from 'mavlink-mappings'
+import { waitFor } from './utils'
+import { uint8_t, MavLinkData } from 'mavlink-mappings'
 
 /**
  * Encapsulation of communication with MavEsp8266

package/lib/mavlink.ts

@@ -1,16 +1,17 @@
-import { Transform, TransformCallback, Writable } from 'stream'
+import { Transform, TransformCallback, Readable, Writable } from 'stream'
 import { createHash } from 'crypto'
-import { uint8_t, uint16_t } from 'mavlink-mappings'
-import { x25crc, dump } from 'mavlink-mappings'
+import { uint8_t, uint16_t, x25crc } from 'mavlink-mappings'
 import { MSG_ID_MAGIC_NUMBER } from 'mavlink-mappings'
 import { MavLinkData, MavLinkDataConstructor } from 'mavlink-mappings'
 
+import { hex } from './utils'
+import { Logger } from './logger'
 import { SERIALIZERS, DESERIALIZERS } from './serialization'
 
 /**
  * Header definition of the MavLink packet
  */
- export class MavLinkPacketHeader {
+export class MavLinkPacketHeader {
   magic: number = 0
   payloadLength: uint8_t = 0
   incompatibilityFlags: uint8_t = 0
@@ -28,6 +29,8 @@ import { SERIALIZERS, DESERIALIZERS } from './serialization'
  * data classes from the given payload buffer
  */
 export abstract class MavLinkProtocol {
+  protected readonly log = Logger.getLogger(this)
+
   static NAME = 'unknown'
   static START_BYTE = 0
   static PAYLOAD_OFFSET = 0
@@ -64,6 +67,8 @@ export abstract class MavLinkProtocol {
    * Deserialize payload into actual data class
    */
   data<T extends MavLinkData>(payload: Buffer, clazz: MavLinkDataConstructor<T>): T {
+    this.log.trace('Deserializing', clazz.MSG_NAME, 'with payload of size', payload.length)
+
     const instance = new clazz()
     clazz.FIELDS.forEach(field => {
       const deserialize = DESERIALIZERS[field.type]
@@ -107,6 +112,8 @@ export class MavLinkProtocolV1 extends MavLinkProtocol {
   }
 
   serialize(message: MavLinkData, seq: number): Buffer {
+    this.log.trace('Serializing message (seq:', seq, ')')
+
     const definition: MavLinkDataConstructor<MavLinkData> = <any>message.constructor
     const buffer = Buffer.from(new Uint8Array(MavLinkProtocolV1.PAYLOAD_OFFSET + definition.PAYLOAD_LENGTH + MavLinkProtocol.CHECKSUM_LENGTH))
 
@@ -133,6 +140,8 @@ export class MavLinkProtocolV1 extends MavLinkProtocol {
   }
 
   header(buffer: Buffer): MavLinkPacketHeader {
+    this.log.trace('Reading header from buffer (len:', buffer.length, ')')
+
     const startByte = buffer.readUInt8(0)
     if (startByte !== MavLinkProtocolV1.START_BYTE) {
       throw new Error(`Invalid start byte (expected: ${MavLinkProtocolV1.START_BYTE}, got ${startByte})`)
@@ -152,12 +161,16 @@ export class MavLinkProtocolV1 extends MavLinkProtocol {
   /**
    * Deserialize packet checksum
    */
-   crc(buffer: Buffer): uint16_t {
+  crc(buffer: Buffer): uint16_t {
+    this.log.trace('Reading crc from buffer (len:', buffer.length, ')')
+
     const plen = buffer.readUInt8(1)
     return buffer.readUInt16LE(MavLinkProtocolV1.PAYLOAD_OFFSET + plen)
   }
 
   payload(buffer: Buffer): Buffer {
+    this.log.trace('Reading payload from buffer (len:', buffer.length, ')')
+
     const plen = buffer.readUInt8(1)
     const payload = buffer.slice(MavLinkProtocolV1.PAYLOAD_OFFSET, MavLinkProtocolV1.PAYLOAD_OFFSET + plen)
     const padding = Buffer.from(new Uint8Array(255 - payload.length))
@@ -188,6 +201,8 @@ export class MavLinkProtocolV2 extends MavLinkProtocol {
   }
 
   serialize(message: MavLinkData, seq: number): Buffer {
+    this.log.trace('Serializing message (seq:', seq, ')')
+
     const definition: MavLinkDataConstructor<MavLinkData> = <any>message.constructor
     const buffer = Buffer.from(new Uint8Array(MavLinkProtocolV2.PAYLOAD_OFFSET + definition.PAYLOAD_LENGTH + MavLinkProtocol.CHECKSUM_LENGTH))
 
@@ -224,9 +239,12 @@ export class MavLinkProtocolV2 extends MavLinkProtocol {
    * @param buffer buffer with the original, unsigned package
    * @param linkId id of the link
    * @param key key to sign the package with
+   * @param timestamp optional timestamp for packet signing (default: Date.now())
    * @returns signed package
    */
-  sign(buffer: Buffer, linkId: number, key: Buffer) {
+  sign(buffer: Buffer, linkId: number, key: Buffer, timestamp = Date.now()) {
+    this.log.trace('Signing message')
+
     const result = Buffer.concat([
       buffer,
       Buffer.from(new Uint8Array(MavLinkPacketSignature.SIGNATURE_LENGTH))
@@ -234,7 +252,7 @@ export class MavLinkProtocolV2 extends MavLinkProtocol {
 
     const signer = new MavLinkPacketSignature(result)
     signer.linkId = linkId
-    signer.timestamp = Date.now()
+    signer.timestamp = timestamp
     signer.signature = signer.calculate(key)
 
     return result
@@ -255,6 +273,8 @@ export class MavLinkProtocolV2 extends MavLinkProtocol {
   }
 
   header(buffer: Buffer): MavLinkPacketHeader {
+    this.log.trace('Reading header from buffer (len:', buffer.length, ')')
+
     const startByte = buffer.readUInt8(0)
     if (startByte !== MavLinkProtocolV2.START_BYTE) {
       throw new Error(`Invalid start byte (expected: ${MavLinkProtocolV2.START_BYTE}, got ${startByte})`)
@@ -277,11 +297,15 @@ export class MavLinkProtocolV2 extends MavLinkProtocol {
    * Deserialize packet checksum
    */
   crc(buffer: Buffer): uint16_t {
+    this.log.trace('Reading crc from buffer (len:', buffer.length, ')')
+
     const plen = buffer.readUInt8(1)
     return buffer.readUInt16LE(MavLinkProtocolV2.PAYLOAD_OFFSET + plen)
   }
 
   payload(buffer: Buffer): Buffer {
+    this.log.trace('Reading payload from buffer (len:', buffer.length, ')')
+
     const plen = buffer.readUInt8(1)
     const payload = buffer.slice(MavLinkProtocolV2.PAYLOAD_OFFSET, MavLinkProtocolV2.PAYLOAD_OFFSET + plen)
     const padding = Buffer.from(new Uint8Array(255 - payload.length))
@@ -289,6 +313,8 @@ export class MavLinkProtocolV2 extends MavLinkProtocol {
   }
 
   signature(buffer: Buffer, header: MavLinkPacketHeader): MavLinkPacketSignature {
+    this.log.trace('Reading signature from buffer (len:', buffer.length, ')')
+
     if (header.incompatibilityFlags & MavLinkProtocolV2.IFLAG_SIGNED) {
       return new MavLinkPacketSignature(buffer)
     } else {
@@ -432,7 +458,8 @@ export class MavLinkPacket {
       + `msgid: ${this.header.msgid}, `
       + `seq: ${this.header.seq}, `
       + `plen: ${this.header.payloadLength}, `
-      + `crc: ${this.crc.toString(16).padStart(2, '0')}`
+      + `magic: ${MSG_ID_MAGIC_NUMBER[this.header.msgid]} (${hex(MSG_ID_MAGIC_NUMBER[this.header.msgid])}), `
+      + `crc: ${hex(this.crc, 4)}`
       + this.signatureToString(this.signature)
       + ')'
   }
@@ -447,19 +474,28 @@ export class MavLinkPacket {
  */
 enum PacketValidationResult { VALID, INVALID, UNKNOWN }
 
+type BufferCallback = (buffer: Buffer) => void
+
 /**
  * A transform stream that splits the incomming data stream into chunks containing full MavLink messages
  */
 export class MavLinkPacketSplitter extends Transform {
+  protected readonly log = Logger.getLogger(this)
+
   private buffer = Buffer.from([])
-  private verbose = false
+  private onCrcError = null
   private _validPackagesCount = 0
   private _unknownPackagesCount = 0
   private _invalidPackagesCount = 0
 
-  constructor(opts = {}, verbose = false) {
+  /**
+   * @param opts options to pass on to the Transform constructor
+   * @param verbose print diagnostic information
+   * @param onCrcError callback executed if there is a CRC error (mostly for debugging)
+   */
+  constructor(opts = {}, onCrcError: BufferCallback = () => {}) {
     super(opts)
-    this.verbose = verbose
+    this.onCrcError = onCrcError
   }
 
   _transform(chunk: Buffer, encoding, callback: TransformCallback) {
@@ -477,38 +513,51 @@ export class MavLinkPacketSplitter extends Transform {
         this.buffer = this.buffer.slice(offset)
       }
 
+      this.log.debug('Found potential packet start at', offset)
+
       // get protocol this buffer is encoded with
       const Protocol = this.getPacketProtocol(this.buffer)
 
+      this.log.debug('Packet protocol is', Protocol.NAME)
+
       // check if the buffer contains at least the minumum size of data
       if (this.buffer.length < Protocol.PAYLOAD_OFFSET + MavLinkProtocol.CHECKSUM_LENGTH) {
         // current buffer shorter than the shortest message - skipping
+        this.log.debug('Current buffer shorter than the shortest message - skipping')
         break
       }
 
       // check if the current buffer contains the entire message
       const expectedBufferLength = this.readPacketLength(this.buffer, Protocol)
+      this.log.debug('Expected buffer length:', expectedBufferLength, `(${hex(expectedBufferLength)})`)
       if (this.buffer.length < expectedBufferLength) {
         // current buffer is not fully retrieved yet - skipping
+        this.log.debug('Current buffer is not fully retrieved yet - skipping')
         break
+      } else {
+        this.log.debug('Current buffer length:', this.buffer.length, `(${hex(this.buffer.length, 4)})`)
       }
 
       // retrieve the buffer based on payload size
       const buffer = this.buffer.slice(0, expectedBufferLength)
+      this.log.debug('Recognized buffer length:', buffer.length, `(${hex(buffer.length, 2)})`)
 
       switch (this.validatePacket(buffer, Protocol)) {
         case PacketValidationResult.VALID:
+          this.log.debug('Found a valid packet')
           this._validPackagesCount++
           this.push(buffer)
           // truncate the buffer to remove the current message
           this.buffer = this.buffer.slice(expectedBufferLength)
           break
         case PacketValidationResult.INVALID:
+          this.log.debug('Found an invalid packet - skipping')
           this._invalidPackagesCount++
           // truncate the buffer to remove the wrongly identified STX
           this.buffer = this.buffer.slice(1)
           break
         case PacketValidationResult.UNKNOWN:
+          this.log.debug('Found an unknown packet - skipping')
           this._unknownPackagesCount++
           // truncate the buffer to remove the current message
           this.buffer = this.buffer.slice(expectedBufferLength)
@@ -570,21 +619,22 @@ export class MavLinkPacketSplitter extends Transform {
         return PacketValidationResult.VALID
       } else {
         // CRC mismatch
-        if (this.verbose) {
-          console.error(
-            'CRC error; expected', crc2, `(0x${crc2.toString(16).padStart(4, '0')})`,
-            'got', crc, `(0x${crc.toString(16).padStart(4, '0')})`,
-            '; msgid:', header.msgid, ', magic:', magic
-          )
-          dump(buffer)
-        }
+        const message = [
+          `CRC error; expected: ${crc2} (${hex(crc2, 4)}), got ${crc} (${hex(crc, 4)});`,
+          `msgid: ${header.msgid} (${hex(header.msgid)}),`,
+          `seq: ${header.seq} (${hex(header.seq)}),`,
+          `plen: ${header.payloadLength} (${hex(header.payloadLength)}),`,
+          `magic: ${magic} (${hex(magic)})`,
+        ]
+        this.log.warn(message.join(' '))
+        this.onCrcError(buffer)
+
         return PacketValidationResult.INVALID
       }
     } else {
       // unknown message (as in not generated from the XML sources)
-      if (this.verbose) {
-        console.error(`Unknown message with id ${header.msgid} (magic number not found) - skipping`)
-      }
+      this.log.debug(`Unknown message with id ${header.msgid} (magic number not found) - skipping`)
+
       return PacketValidationResult.UNKNOWN
     }
   }
@@ -613,7 +663,7 @@ export class MavLinkPacketSplitter extends Transform {
    * Reset the number of valid packages
    */
   resetValidPackagesCount() {
-    this,this._validPackagesCount = 0
+    this._validPackagesCount = 0
   }
 
   /**
@@ -627,7 +677,7 @@ export class MavLinkPacketSplitter extends Transform {
    * Reset the number of invalid packages
    */
   resetInvalidPackagesCount() {
-    this,this._invalidPackagesCount = 0
+    this._invalidPackagesCount = 0
   }
 
   /**
@@ -641,7 +691,7 @@ export class MavLinkPacketSplitter extends Transform {
    * Reset the number of invalid packages
    */
   resetUnknownPackagesCount() {
-    this,this._unknownPackagesCount = 0
+    this._unknownPackagesCount = 0
   }
 }
 
@@ -649,6 +699,8 @@ export class MavLinkPacketSplitter extends Transform {
  * A transform stream that takes a buffer with data and converts it to MavLinkPacket object
  */
 export class MavLinkPacketParser extends Transform {
+  protected readonly log = Logger.getLogger(this)
+
   constructor(opts = {}) {
     super({ ...opts, objectMode: true })
   }
@@ -661,7 +713,7 @@ export class MavLinkPacketParser extends Transform {
       case MavLinkProtocolV2.START_BYTE:
         return new MavLinkProtocolV2()
       default:
-        throw new Error(`Unknown protocol '${startByte.toString(16).padStart(2, '0')}'`)
+        throw new Error(`Unknown protocol '${hex(startByte)}'`)
     }
   }
 
@@ -680,6 +732,17 @@ export class MavLinkPacketParser extends Transform {
   }
 }
 
+/**
+ * Creates a MavLink packet stream reader that is reading packets from the given input
+ *
+ * @param input input stream to read from
+ */
+export function createMavLinkStream(input: Readable, onCrcError: BufferCallback) {
+  return input
+    .pipe(new MavLinkPacketSplitter({}, onCrcError))
+    .pipe(new MavLinkPacketParser())
+}
+
 let seq = 0
 
 /**
@@ -710,14 +773,21 @@ export async function send(stream: Writable, msg: MavLinkData, protocol: MavLink
  * @param linkId link id for the signature
  * @param sysid system id
  * @param compid component id
+ * @param timestamp optional timestamp for packet signing (default: Date.now())
  * @returns number of bytes sent
  */
-export async function sendSigned(stream: Writable, msg: MavLinkData, key: Buffer, linkId: uint8_t = 1, sysid: uint8_t = MavLinkProtocol.SYS_ID, compid: uint8_t = MavLinkProtocol.COMP_ID) {
+export async function sendSigned(
+  stream: Writable,
+  msg: MavLinkData,
+  key: Buffer,
+  linkId: uint8_t = 1, sysid: uint8_t = MavLinkProtocol.SYS_ID, compid: uint8_t = MavLinkProtocol.COMP_ID,
+  timestamp = Date.now()
+) {
   return new Promise((resolve, reject) => {
     const protocol = new MavLinkProtocolV2(sysid, compid, MavLinkProtocolV2.IFLAG_SIGNED)
     const b1 = protocol.serialize(msg, seq++)
     seq &= 255
-    const b2 = protocol.sign(b1, linkId, key)
+    const b2 = protocol.sign(b1, linkId, key, timestamp)
     stream.write(b2, err => {
       if (err) reject(err)
       else resolve(b2.length)

package/lib/serialization.ts

@@ -165,7 +165,7 @@ export const DESERIALIZERS = {
   },
   'float[]': (buffer: Buffer, offset: number, length: number) => {
     const result = new Array<number>(length)
-    for (let i = 0; i < length; i++) result[i] = buffer.readFloatLE(offset + i * 8)
+    for (let i = 0; i < length; i++) result[i] = buffer.readFloatLE(offset + i * 4)
     return result
   },
   'double[]': (buffer: Buffer, offset: number, length: number) => {