node-mavlink 1.0.7 → 1.0.10-beta.1

package/dist/lib/serialization.d.ts

@@ -17,14 +17,14 @@ export declare const SERIALIZERS: {
     float: (value: float, buffer: Buffer, offset: number) => number;
     double: (value: double, buffer: Buffer, offset: number) => number;
     'char[]': (value: string, buffer: Buffer, offset: number, maxLen: number) => void;
-    'int8[]': (value: uint8_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'uint8[]': (value: uint8_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'int16[]': (value: uint16_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'uint16[]': (value: uint16_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'int32[]': (value: uint32_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'uint32[]': (value: uint32_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'int64[]': (value: uint64_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'uint64[]': (value: uint64_t[], buffer: Buffer, offset: number, maxLen: number) => void;
+    'int8_t[]': (value: uint8_t[], buffer: Buffer, offset: number, maxLen: number) => void;
+    'uint8_t[]': (value: uint8_t[], buffer: Buffer, offset: number, maxLen: number) => void;
+    'int16_t[]': (value: uint16_t[], buffer: Buffer, offset: number, maxLen: number) => void;
+    'uint16_t[]': (value: uint16_t[], buffer: Buffer, offset: number, maxLen: number) => void;
+    'int32_t[]': (value: uint32_t[], buffer: Buffer, offset: number, maxLen: number) => void;
+    'uint32_t[]': (value: uint32_t[], buffer: Buffer, offset: number, maxLen: number) => void;
+    'int64_t[]': (value: uint64_t[], buffer: Buffer, offset: number, maxLen: number) => void;
+    'uint64_t[]': (value: uint64_t[], buffer: Buffer, offset: number, maxLen: number) => void;
     'float[]': (value: float[], buffer: Buffer, offset: number, maxLen: number) => void;
     'double[]': (value: double[], buffer: Buffer, offset: number, maxLen: number) => void;
 };

package/dist/lib/serialization.js

@@ -26,42 +26,42 @@ exports.SERIALIZERS = {
             buffer.writeUInt8(code, offset + i);
         }
     },
-    'int8[]': (value, buffer, offset, maxLen) => {
+    'int8_t[]': (value, buffer, offset, maxLen) => {
         for (let i = 0; i < value.length && i < maxLen; i++) {
             buffer.writeInt8(value[i], offset + i);
         }
     },
-    'uint8[]': (value, buffer, offset, maxLen) => {
+    'uint8_t[]': (value, buffer, offset, maxLen) => {
         for (let i = 0; i < value.length && i < maxLen; i++) {
             buffer.writeUInt8(value[i], offset + i);
         }
     },
-    'int16[]': (value, buffer, offset, maxLen) => {
+    'int16_t[]': (value, buffer, offset, maxLen) => {
         for (let i = 0; i < value.length && i < maxLen; i++) {
             buffer.writeInt16LE(value[i], offset + i * 2);
         }
     },
-    'uint16[]': (value, buffer, offset, maxLen) => {
+    'uint16_t[]': (value, buffer, offset, maxLen) => {
         for (let i = 0; i < value.length && i < maxLen; i++) {
             buffer.writeUInt16LE(value[i], offset + i * 2);
         }
     },
-    'int32[]': (value, buffer, offset, maxLen) => {
+    'int32_t[]': (value, buffer, offset, maxLen) => {
         for (let i = 0; i < value.length && i < maxLen; i++) {
             buffer.writeInt32LE(value[i], offset + i * 4);
         }
     },
-    'uint32[]': (value, buffer, offset, maxLen) => {
+    'uint32_t[]': (value, buffer, offset, maxLen) => {
         for (let i = 0; i < value.length && i < maxLen; i++) {
             buffer.writeUInt32LE(value[i], offset + i * 4);
         }
     },
-    'int64[]': (value, buffer, offset, maxLen) => {
+    'int64_t[]': (value, buffer, offset, maxLen) => {
         for (let i = 0; i < value.length && i < maxLen; i++) {
             buffer.writeBigInt64LE(value[i], offset + i * 8);
         }
     },
-    'uint64[]': (value, buffer, offset, maxLen) => {
+    'uint64_t[]': (value, buffer, offset, maxLen) => {
         for (let i = 0; i < value.length && i < maxLen; i++) {
             buffer.writeBigUInt64LE(value[i], offset + i * 8);
         }
@@ -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) => {

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,15 @@
 #!/usr/bin/env -S npx ts-node
 
 import { createReadStream } from 'fs'
-import { MavLinkPacketSplitter, MavLinkPacketParser, MavLinkPacket } from '..'
-import { minimal, common, ardupilotmega, uavionix, icarous } from '..'
+import { MavLinkPacketSplitter, MavLinkPacketParser } from '..'
+import {
+  minimal, common, ardupilotmega, uavionix, icarous,
+  asluav, development, ualberta,
+} 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)
@@ -20,6 +23,9 @@ const REGISTRY = {
   ...ardupilotmega.REGISTRY,
   ...uavionix.REGISTRY,
   ...icarous.REGISTRY,
+  ...asluav.REGISTRY,
+  ...development.REGISTRY,
+  ...ualberta.REGISTRY,
 }
 
 reader.on('data', packet => {

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