node-mavlink 1.0.8 → 1.0.9

package/README.md

@@ -1,3 +1,5 @@
+### This is a work in progress and above all misses a comprehensive test suite against another set of bindings! If you're looking for the officially supported bindings for JavaScript see the [pymavlink](https://github.com/ArduPilot/pymavlink/tree/master/generator/javascript) project.
+
 # Node.js MavLink library
 
 This package is the implementation of serialization and parsing of MavLink messages for v1 and v2 protocols.

package/dist/index.d.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/dist/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -11,5 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("mavlink-mappings"), exports);
+__exportStar(require("./lib/utils"), exports);
+__exportStar(require("./lib/logger"), exports);
 __exportStar(require("./lib/mavlink"), exports);
 __exportStar(require("./lib/mavesp"), exports);

package/dist/lib/logger.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Level of the log entry
+ */
+export declare enum LogLevel {
+    trace = 5,
+    debug = 4,
+    info = 3,
+    warn = 2,
+    error = 1,
+    fatal = 0
+}
+declare type LoggerEvents = 'log';
+declare type LoggerEventHandler = (context: string, level: LogLevel, message: any[]) => void;
+/**
+ * Simplified interface for logging facilities
+ */
+export declare class Logger {
+    private static readonly events;
+    private static registry;
+    /**
+     * Gets a logger by name
+     *
+     * @param context logger context
+     */
+    static getLogger(context: any): Logger;
+    /**
+     * Binds an event handler
+     *
+     * @param event event to react to
+     * @param handler event handler
+     */
+    static on(event: LoggerEvents, handler: (context: any, level: any, message: any) => void): void;
+    /**
+     * Removes an event handler
+     *
+     * @param event event to react to
+     * @param handler event handler
+     */
+    static off(event: LoggerEvents, handler: LoggerEventHandler): void;
+    private context;
+    /**
+     * Constructs a new logger instance
+     *
+     * @param context logger context
+     */
+    constructor(context: string);
+    /**
+     * Sends a log message if the trace level is enabled for this logger
+     *
+     * @param args parameters for the log entry
+     */
+    trace(...args: any): void;
+    /**
+     * Sends a log message if the debug level is enabled for this logger
+     *
+     * @param args parameters for the log entry
+     */
+    debug(...args: any): void;
+    /**
+     * Sends a log message if the info level is enabled for this logger
+     *
+     * @param args parameters for the log entry
+     */
+    info(...args: any): void;
+    /**
+     * Sends a log message if the warn level is enabled for this logger
+     *
+     * @param args parameters for the log entry
+     */
+    warn(...args: any): void;
+    /**
+     * Sends a log message if the error level is enabled for this logger
+     *
+     * @param args parameters for the log entry
+     */
+    error(...args: any): void;
+    /**
+     * Sends a log message if the fatal level is enabled for this logger
+     *
+     * @param args parameters for the log entry
+     */
+    fatal(...args: any): void;
+}
+export {};

package/dist/lib/logger.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LogLevel = void 0;
+const EventEmitter = require("events");
+/**
+ * Level of the log entry
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["trace"] = 5] = "trace";
+    LogLevel[LogLevel["debug"] = 4] = "debug";
+    LogLevel[LogLevel["info"] = 3] = "info";
+    LogLevel[LogLevel["warn"] = 2] = "warn";
+    LogLevel[LogLevel["error"] = 1] = "error";
+    LogLevel[LogLevel["fatal"] = 0] = "fatal";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+/**
+ * Simplified interface for logging facilities
+ */
+class Logger {
+    /**
+     * Constructs a new logger instance
+     *
+     * @param context logger context
+     */
+    constructor(context) {
+        this.context = context;
+        Logger.events.emit('logger-created', Logger.registry[context]);
+    }
+    /**
+     * 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 = 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, handler) {
+        this.events.on(event, handler);
+    }
+    /**
+     * Removes an event handler
+     *
+     * @param event event to react to
+     * @param handler event handler
+     */
+    static off(event, handler) {
+        this.events.off(event, handler);
+    }
+    /**
+     * Sends a log message if the trace level is enabled for this logger
+     *
+     * @param args parameters for the log entry
+     */
+    trace(...args) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        Logger.events.emit('log', { context: this.context, level: LogLevel.fatal, message: args });
+    }
+}
+exports.Logger = Logger;
+Logger.events = new EventEmitter();
+Logger.registry = {};

package/dist/lib/mavesp.js

@@ -15,7 +15,7 @@ const dgram_1 = require("dgram");
 const stream_1 = require("stream");
 const mavlink_1 = require("./mavlink");
 const mavlink_2 = require("./mavlink");
-const mavlink_mappings_1 = require("mavlink-mappings");
+const utils_1 = require("./utils");
 /**
  * Encapsulation of communication with MavEsp8266
  */
@@ -52,7 +52,7 @@ class MavEsp8266 extends events_1.EventEmitter {
                 this.socket.bind(receivePort, () => {
                     // Wait for the first package to be returned to read the ip address
                     // of the controller
-                    (0, mavlink_mappings_1.waitFor)(() => this.ip !== '')
+                    (0, utils_1.waitFor)(() => this.ip !== '')
                         .then(() => { resolve(this.ip); })
                         .catch(e => { reject(e); });
                 });

package/dist/lib/mavlink.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="node" />
-import { Transform, TransformCallback, Writable } from 'stream';
+import { Transform, TransformCallback, Readable, Writable } from 'stream';
 import { uint8_t, uint16_t } from 'mavlink-mappings';
 import { MavLinkData, MavLinkDataConstructor } from 'mavlink-mappings';
+import { Logger } from './logger';
 /**
  * Header definition of the MavLink packet
  */
@@ -22,6 +23,7 @@ export declare class MavLinkPacketHeader {
  * data classes from the given payload buffer
  */
 export declare abstract class MavLinkProtocol {
+    protected readonly log: Logger;
     static NAME: string;
     static START_BYTE: number;
     static PAYLOAD_OFFSET: number;
@@ -93,9 +95,10 @@ export declare 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): Buffer;
+    sign(buffer: Buffer, linkId: number, key: Buffer, timestamp?: number): Buffer;
     private calculateTruncatedPayloadLength;
     header(buffer: Buffer): MavLinkPacketHeader;
     /**
@@ -183,16 +186,23 @@ export declare class MavLinkPacket {
     debug(): string;
     private signatureToString;
 }
+declare type BufferCallback = (buffer: Buffer) => void;
 /**
  * A transform stream that splits the incomming data stream into chunks containing full MavLink messages
  */
 export declare class MavLinkPacketSplitter extends Transform {
+    protected readonly log: Logger;
     private buffer;
-    private verbose;
+    private onCrcError;
     private _validPackagesCount;
     private _unknownPackagesCount;
     private _invalidPackagesCount;
-    constructor(opts?: {}, verbose?: boolean);
+    /**
+     * @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);
     _transform(chunk: Buffer, encoding: any, callback: TransformCallback): void;
     private findStartOfPacket;
     private getPacketProtocol;
@@ -233,10 +243,17 @@ export declare class MavLinkPacketSplitter extends Transform {
  * A transform stream that takes a buffer with data and converts it to MavLinkPacket object
  */
 export declare class MavLinkPacketParser extends Transform {
+    protected readonly log: Logger;
     constructor(opts?: {});
     private getProtocol;
     _transform(chunk: Buffer, encoding: any, callback: TransformCallback): void;
 }
+/**
+ * Creates a MavLink packet stream reader that is reading packets from the given input
+ *
+ * @param input input stream to read from
+ */
+export declare function createMavLinkStream(input: Readable, onCrcError: BufferCallback): MavLinkPacketParser;
 /**
  * Send a packet to the stream
  *
@@ -255,6 +272,8 @@ export declare function send(stream: Writable, msg: MavLinkData, protocol?: MavL
  * @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 declare function sendSigned(stream: Writable, msg: MavLinkData, key: Buffer, linkId?: uint8_t, sysid?: uint8_t, compid?: uint8_t): Promise<unknown>;
+export declare function sendSigned(stream: Writable, msg: MavLinkData, key: Buffer, linkId?: uint8_t, sysid?: uint8_t, compid?: uint8_t, timestamp?: number): Promise<unknown>;
+export {};

package/dist/lib/mavlink.js

@@ -9,11 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendSigned = exports.send = exports.MavLinkPacketParser = exports.MavLinkPacketSplitter = exports.MavLinkPacket = exports.MavLinkPacketSignature = exports.MavLinkProtocolV2 = exports.MavLinkProtocolV1 = exports.MavLinkProtocol = exports.MavLinkPacketHeader = void 0;
+exports.sendSigned = exports.send = exports.createMavLinkStream = exports.MavLinkPacketParser = exports.MavLinkPacketSplitter = exports.MavLinkPacket = exports.MavLinkPacketSignature = exports.MavLinkProtocolV2 = exports.MavLinkProtocolV1 = exports.MavLinkProtocol = exports.MavLinkPacketHeader = void 0;
 const stream_1 = require("stream");
 const crypto_1 = require("crypto");
 const mavlink_mappings_1 = require("mavlink-mappings");
 const mavlink_mappings_2 = require("mavlink-mappings");
+const utils_1 = require("./utils");
+const logger_1 = require("./logger");
 const serialization_1 = require("./serialization");
 /**
  * Header definition of the MavLink packet
@@ -38,10 +40,14 @@ exports.MavLinkPacketHeader = MavLinkPacketHeader;
  * data classes from the given payload buffer
  */
 class MavLinkProtocol {
+    constructor() {
+        this.log = logger_1.Logger.getLogger(this);
+    }
     /**
      * Deserialize payload into actual data class
      */
     data(payload, clazz) {
+        this.log.trace('Deserializing', clazz.MSG_NAME, 'with payload of size', payload.length);
         const instance = new clazz();
         clazz.FIELDS.forEach(field => {
             const deserialize = serialization_1.DESERIALIZERS[field.type];
@@ -70,6 +76,7 @@ class MavLinkProtocolV1 extends MavLinkProtocol {
         this.compid = compid;
     }
     serialize(message, seq) {
+        this.log.trace('Serializing message (seq:', seq, ')');
         const definition = message.constructor;
         const buffer = Buffer.from(new Uint8Array(MavLinkProtocolV1.PAYLOAD_OFFSET + definition.PAYLOAD_LENGTH + MavLinkProtocol.CHECKSUM_LENGTH));
         // serialize header
@@ -92,6 +99,7 @@ class MavLinkProtocolV1 extends MavLinkProtocol {
         return buffer;
     }
     header(buffer) {
+        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})`);
@@ -109,10 +117,12 @@ class MavLinkProtocolV1 extends MavLinkProtocol {
      * Deserialize packet checksum
      */
     crc(buffer) {
+        this.log.trace('Reading crc from buffer (len:', buffer.length, ')');
         const plen = buffer.readUInt8(1);
         return buffer.readUInt16LE(MavLinkProtocolV1.PAYLOAD_OFFSET + plen);
     }
     payload(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));
@@ -135,6 +145,7 @@ class MavLinkProtocolV2 extends MavLinkProtocol {
         this.compatibilityFlags = compatibilityFlags;
     }
     serialize(message, seq) {
+        this.log.trace('Serializing message (seq:', seq, ')');
         const definition = message.constructor;
         const buffer = Buffer.from(new Uint8Array(MavLinkProtocolV2.PAYLOAD_OFFSET + definition.PAYLOAD_LENGTH + MavLinkProtocol.CHECKSUM_LENGTH));
         buffer.writeUInt8(MavLinkProtocolV2.START_BYTE, 0);
@@ -165,16 +176,18 @@ 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, linkId, key) {
+    sign(buffer, linkId, key, timestamp = Date.now()) {
+        this.log.trace('Signing message');
         const result = Buffer.concat([
             buffer,
             Buffer.from(new Uint8Array(MavLinkPacketSignature.SIGNATURE_LENGTH))
         ]);
         const signer = new MavLinkPacketSignature(result);
         signer.linkId = linkId;
-        signer.timestamp = Date.now();
+        signer.timestamp = timestamp;
         signer.signature = signer.calculate(key);
         return result;
     }
@@ -190,6 +203,7 @@ class MavLinkProtocolV2 extends MavLinkProtocol {
         return result - MavLinkProtocolV2.PAYLOAD_OFFSET;
     }
     header(buffer) {
+        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})`);
@@ -209,16 +223,19 @@ class MavLinkProtocolV2 extends MavLinkProtocol {
      * Deserialize packet checksum
      */
     crc(buffer) {
+        this.log.trace('Reading crc from buffer (len:', buffer.length, ')');
         const plen = buffer.readUInt8(1);
         return buffer.readUInt16LE(MavLinkProtocolV2.PAYLOAD_OFFSET + plen);
     }
     payload(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));
         return Buffer.concat([payload, padding]);
     }
     signature(buffer, header) {
+        this.log.trace('Reading signature from buffer (len:', buffer.length, ')');
         if (header.incompatibilityFlags & MavLinkProtocolV2.IFLAG_SIGNED) {
             return new MavLinkPacketSignature(buffer);
         }
@@ -356,7 +373,8 @@ class MavLinkPacket {
             + `msgid: ${this.header.msgid}, `
             + `seq: ${this.header.seq}, `
             + `plen: ${this.header.payloadLength}, `
-            + `crc: ${this.crc.toString(16).padStart(2, '0')}`
+            + `magic: ${mavlink_mappings_2.MSG_ID_MAGIC_NUMBER[this.header.msgid]} (${(0, utils_1.hex)(mavlink_mappings_2.MSG_ID_MAGIC_NUMBER[this.header.msgid])}), `
+            + `crc: ${(0, utils_1.hex)(this.crc, 4)}`
             + this.signatureToString(this.signature)
             + ')';
     }
@@ -378,14 +396,20 @@ var PacketValidationResult;
  * A transform stream that splits the incomming data stream into chunks containing full MavLink messages
  */
 class MavLinkPacketSplitter extends stream_1.Transform {
-    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 = () => { }) {
         super(opts);
+        this.log = logger_1.Logger.getLogger(this);
         this.buffer = Buffer.from([]);
-        this.verbose = false;
+        this.onCrcError = null;
         this._validPackagesCount = 0;
         this._unknownPackagesCount = 0;
         this._invalidPackagesCount = 0;
-        this.verbose = verbose;
+        this.onCrcError = onCrcError;
     }
     _transform(chunk, encoding, callback) {
         this.buffer = Buffer.concat([this.buffer, chunk]);
@@ -399,34 +423,46 @@ class MavLinkPacketSplitter extends stream_1.Transform {
             if (offset > 0) {
                 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, `(${(0, utils_1.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, `(${(0, utils_1.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, `(${(0, utils_1.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);
@@ -487,18 +523,21 @@ class MavLinkPacketSplitter extends stream_1.Transform {
             }
             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);
-                    (0, mavlink_mappings_1.dump)(buffer);
-                }
+                const message = [
+                    `CRC error; expected: ${crc2} (${(0, utils_1.hex)(crc2, 4)}), got ${crc} (${(0, utils_1.hex)(crc, 4)});`,
+                    `msgid: ${header.msgid} (${(0, utils_1.hex)(header.msgid)}),`,
+                    `seq: ${header.seq} (${(0, utils_1.hex)(header.seq)}),`,
+                    `plen: ${header.payloadLength} (${(0, utils_1.hex)(header.payloadLength)}),`,
+                    `magic: ${magic} (${(0, utils_1.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;
         }
     }
@@ -524,7 +563,7 @@ class MavLinkPacketSplitter extends stream_1.Transform {
      * Reset the number of valid packages
      */
     resetValidPackagesCount() {
-        this, this._validPackagesCount = 0;
+        this._validPackagesCount = 0;
     }
     /**
      * Number of invalid packages
@@ -536,7 +575,7 @@ class MavLinkPacketSplitter extends stream_1.Transform {
      * Reset the number of invalid packages
      */
     resetInvalidPackagesCount() {
-        this, this._invalidPackagesCount = 0;
+        this._invalidPackagesCount = 0;
     }
     /**
      * Number of invalid packages
@@ -548,7 +587,7 @@ class MavLinkPacketSplitter extends stream_1.Transform {
      * Reset the number of invalid packages
      */
     resetUnknownPackagesCount() {
-        this, this._unknownPackagesCount = 0;
+        this._unknownPackagesCount = 0;
     }
 }
 exports.MavLinkPacketSplitter = MavLinkPacketSplitter;
@@ -558,6 +597,7 @@ exports.MavLinkPacketSplitter = MavLinkPacketSplitter;
 class MavLinkPacketParser extends stream_1.Transform {
     constructor(opts = {}) {
         super(Object.assign(Object.assign({}, opts), { objectMode: true }));
+        this.log = logger_1.Logger.getLogger(this);
     }
     getProtocol(buffer) {
         const startByte = buffer.readUInt8(0);
@@ -567,7 +607,7 @@ class MavLinkPacketParser extends stream_1.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 '${(0, utils_1.hex)(startByte)}'`);
         }
     }
     _transform(chunk, encoding, callback) {
@@ -583,6 +623,17 @@ class MavLinkPacketParser extends stream_1.Transform {
     }
 }
 exports.MavLinkPacketParser = MavLinkPacketParser;
+/**
+ * Creates a MavLink packet stream reader that is reading packets from the given input
+ *
+ * @param input input stream to read from
+ */
+function createMavLinkStream(input, onCrcError) {
+    return input
+        .pipe(new MavLinkPacketSplitter({}, onCrcError))
+        .pipe(new MavLinkPacketParser());
+}
+exports.createMavLinkStream = createMavLinkStream;
 let seq = 0;
 /**
  * Send a packet to the stream
@@ -616,15 +667,16 @@ exports.send = send;
  * @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
  */
-function sendSigned(stream, msg, key, linkId = 1, sysid = MavLinkProtocol.SYS_ID, compid = MavLinkProtocol.COMP_ID) {
+function sendSigned(stream, msg, key, linkId = 1, sysid = MavLinkProtocol.SYS_ID, compid = MavLinkProtocol.COMP_ID, timestamp = Date.now()) {
     return __awaiter(this, void 0, void 0, function* () {
         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);

package/dist/lib/serialization.js

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