motion-master-client 0.0.21 → 0.0.22

package/src/lib/motion-master-req-res-socket.ts

@@ -0,0 +1,62 @@
+import { BehaviorSubject, Observable } from "rxjs";
+import { IMotionMasterMessage } from "./types";
+
+export interface MotionMasterReqResSocket {
+  /**
+   * Emits a boolean value when socket gets opened or closed.
+   */
+  readonly opened$: BehaviorSubject<boolean>;
+
+  /**
+   * Motion Master is considered alive when it sends messages in regular time interval.
+   */
+  readonly alive$: BehaviorSubject<boolean>;
+
+  /**
+   * Decoded message instances coming from Motion Master.
+   */
+  readonly message$: Observable<IMotionMasterMessage>;
+
+  /**
+   * URL set in call to open.
+   */
+  get url(): string | undefined;
+
+  /**
+   * Send ping system messages to Motion Master with a fixed time delay between each call.
+   */
+  get pingSystemInterval(): number | undefined;
+
+  /**
+   * How long in milliseconds to consider Motion Master alive.
+   */
+  get systemAliveTimeout(): number | undefined;
+
+  /**
+   * Open socket.
+   *
+   * The connected$ and eventually alive$ observables will emit true values.
+   */
+  open(url: string, pingSystemInterval?: number, systemAliveTimeout?: number): void;
+
+  /**
+   * Close socket.
+   *
+   * The opened$ and alive$ observables will emit false values.
+   */
+  close(): void;
+
+  /**
+   * Reopen socket.
+   *
+   * Reopen if closed using the same url, pingSystemInterval, and systemAliveTimeout previously set in open.
+   */
+  reopen(): void;
+
+  /**
+   * Send an instance of a message.
+   *
+   * Subscribe to the message$ observable in order to receive the response messages.
+   */
+  send(message: IMotionMasterMessage): void;
+}

package/src/lib/motion-master-req-res-web-socket.ts

@@ -0,0 +1,124 @@
+import { BehaviorSubject, filter, interval, map, Subject, Subscription, tap } from "rxjs";
+import { webSocket, WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
+import { logger } from "./logger";
+import { MotionMasterReqResSocket } from "./motion-master-req-res-socket";
+import { IMotionMasterMessage, MotionMasterMessage } from "./types";
+import { convertMotionMasterMessageToLoggerContext, createPlainObjectFromMotionMasterMessage } from "./util";
+
+export class MotionMasterReqResWebSocket implements MotionMasterReqResSocket {
+
+  readonly opened$ = new BehaviorSubject<boolean>(false);
+
+  readonly alive$ = new BehaviorSubject<boolean>(false);
+
+  readonly message$ = new Subject<IMotionMasterMessage>();
+
+  private aliveTimeoutId = 0;
+
+  private pingSystemObserver = { next: () => this.send({ request: { pingSystem: {} } }) };
+
+  private pingSystemSubscription = new Subscription();
+
+  private webSocket$?: WebSocketSubject<Uint8Array>;
+
+  private _url?: string;
+  private _pingSystemInterval?: number;
+  private _systemAliveTimeout?: number;
+
+  get url(): string | undefined {
+    return this._url;
+  }
+
+  get pingSystemInterval(): number | undefined {
+    return this._pingSystemInterval;
+  }
+
+  get systemAliveTimeout(): number | undefined {
+    return this._systemAliveTimeout;
+  }
+
+  open(url: string, pingSystemInterval = 250, systemAliveTimeout = 1000): void {
+    if (this.opened$.getValue() === true) {
+      throw new Error('MotionMasterReqResWebSocket is already opened!');
+    }
+
+    this._url = url;
+    this._pingSystemInterval = pingSystemInterval;
+    this._systemAliveTimeout = systemAliveTimeout;
+
+    this.webSocket$ = this.createWebSocket(url, pingSystemInterval);
+
+    this.webSocket$?.pipe(
+      map((data: Uint8Array) => MotionMasterMessage.decode(data)),
+      tap(() => this.keepalive(systemAliveTimeout)),
+      filter((message) => !(message.status?.systemPong)),
+      map(message => createPlainObjectFromMotionMasterMessage(message)),
+      tap((message) => {
+        const context = convertMotionMasterMessageToLoggerContext(message);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        logger.info(context as any, `Received ${context.name}`);
+      }),
+    ).subscribe({
+      next: (message) => this.message$.next(message),
+      error: (err) => {
+        console.error(err);
+      },
+    });
+  }
+
+  close(): void {
+    clearTimeout(this.aliveTimeoutId);
+    this.pingSystemSubscription.unsubscribe();
+    this.webSocket$?.unsubscribe();
+  }
+
+  reopen() {
+    if (this.url && this.opened$.value === false) {
+      this.open(this.url, this.pingSystemInterval, this.systemAliveTimeout);
+    }
+  }
+
+  send(message: IMotionMasterMessage): void {
+    if (!message.request?.pingSystem) {
+      const context = convertMotionMasterMessageToLoggerContext(message);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      logger.info(context as any, `Send ${context.name}`);
+    }
+
+    this.webSocket$?.next(MotionMasterMessage.encode(message).finish());
+  }
+
+  private createWebSocket(url: string, pingSystemInterval = 250) {
+    const webSocketConfig: WebSocketSubjectConfig<Uint8Array> = {
+      binaryType: 'arraybuffer',
+      closeObserver: {
+        next: () => {
+          this.opened$.next(false);
+          logger.info(`Connection closed ${url}`);
+        },
+      },
+      deserializer: (e: MessageEvent) => new Uint8Array(e.data as unknown as Iterable<number>),
+      openObserver: {
+        next: () => {
+          this.pingSystemSubscription = interval(pingSystemInterval)
+            .subscribe(this.pingSystemObserver);
+          this.opened$.next(true);
+          logger.info(`Connection opened ${url}`);
+        },
+      },
+      serializer: (value: Uint8Array) => value,
+      url,
+    };
+
+    return webSocket(webSocketConfig);
+  }
+
+  private keepalive(systemAliveTimeout = 1000) {
+    if (this.alive$.getValue() === false) {
+      this.alive$.next(true);
+    }
+    clearTimeout(this.aliveTimeoutId);
+    this.aliveTimeoutId = setTimeout(() => this.alive$.next(false), systemAliveTimeout) as unknown as number;
+  }
+
+}

package/src/lib/motion-master-req-res-worker-socket.ts

@@ -0,0 +1,87 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { logger } from "./logger";
+import { MotionMasterReqResSocket } from "./motion-master-req-res-socket";
+import { IMotionMasterMessage } from "./types";
+import { convertMotionMasterMessageToLoggerContext } from "./util";
+
+export class MotionMasterReqResWorkerSocket implements MotionMasterReqResSocket {
+
+  readonly opened$ = new BehaviorSubject<boolean>(false);
+
+  readonly alive$ = new BehaviorSubject<boolean>(false);
+
+  readonly message$ = new Subject<IMotionMasterMessage>();
+
+  private _url?: string;
+  private _pingSystemInterval?: number;
+  private _systemAliveTimeout?: number;
+
+  constructor(
+    public readonly worker: Worker,
+  ) { }
+
+  get url(): string | undefined {
+    return this._url;
+  }
+
+  get pingSystemInterval(): number | undefined {
+    return this._pingSystemInterval;
+  }
+
+  get systemAliveTimeout(): number | undefined {
+    return this._systemAliveTimeout;
+  }
+
+  open(url: string, pingSystemInterval = 250, systemAliveTimeout = 1000): void {
+    if (this.opened$.getValue() === true) {
+      throw new Error('MotionMasterReqResWorkerSocket is already opened!');
+    }
+
+    this._url = url;
+    this._pingSystemInterval = pingSystemInterval;
+    this._systemAliveTimeout = systemAliveTimeout;
+
+    this.worker.onmessage = ({ data }) => {
+      if ('opened' in data) {
+        const { opened } = data;
+        this.opened$.next(opened);
+        logger.info(opened ? `Opened req/res 🔌 ${url}` : `Closed req/res 🔌 ${url}`);
+      } else if ('alive' in data) {
+        const { alive } = data;
+        this.alive$.next(alive);
+        logger.info(alive ? `System is alive 💓` : 'System is as dead as 🦤');
+      } else if ('message' in data) {
+        const { message } = data;
+
+        const context = convertMotionMasterMessageToLoggerContext(message);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        logger.info(context as any, `Received ${context.name}`);
+
+        this.message$.next(message);
+      }
+    }
+
+    this.worker.postMessage({
+      open: { url, pingSystemInterval, systemAliveTimeout },
+    });
+  }
+
+  reopen() {
+    if (this.url && this.opened$.value === false) {
+      this.open(this.url, this.pingSystemInterval, this.systemAliveTimeout);
+    }
+  }
+
+  close(): void {
+    this.worker.postMessage({ close: true });
+  }
+
+  send(message: IMotionMasterMessage): void {
+    const context = convertMotionMasterMessageToLoggerContext(message);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    logger.info(context as any, `Send ${context.name}`);
+
+    this.worker.postMessage({ message });
+  }
+
+}

package/src/lib/motion-master.proto.js

@@ -4,8 +4,8 @@
 var $protobuf = require("protobufjs/minimal");
 
 // @ts-expect-error Explicitly disable long.js support
-protobufjs.util.Long = undefined;
-protobufjs.configure();
+$protobuf.util.Long = undefined;
+$protobuf.configure();
 
 // Common aliases
 const $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;

package/src/lib/operators.ts

@@ -0,0 +1,90 @@
+import { pipe, filter, map, timeout, takeWhile } from 'rxjs';
+import { getParameterValue } from './util';
+import { requestStatusResolver } from './request-status-resolver';
+import { IMotionMasterMessage, MotionMasterMessage, ParameterValueType, StatusKey } from './types';
+import { Parameter } from './parameter';
+
+export function selectMotionMasterMessageStatusByMessageId<T>(key: StatusKey, id?: string) {
+  return pipe(
+    filter((message: IMotionMasterMessage) => message.id === id),
+    map((message) => {
+      // Handling the special case when Motion Master sends SystemEvent instead of e.g. DeviceParameterInfo status for
+      // GetDeviceParameterInfo request message. This typically happens when request contains an invalid device address.
+      if (message.status?.systemEvent && key !== 'systemEvent') {
+        if (message.status.systemEvent.error) {
+          throw new Error(`Error selecting message: ${message.status.systemEvent.error.message ?? ''}`);
+        } else {
+          throw new Error(`Error selecting message. Received System Event instead of "${key.toString()}": ${JSON.stringify(message)}`);
+        }
+      }
+      return message.status?.[key] as T;
+    }),
+  );
+}
+
+export function extendStatus<T>(data: { statusKey: StatusKey, messageId: string }) {
+  return pipe(
+    map((status: T) => {
+      const { statusKey, messageId } = data;
+      const request = requestStatusResolver[statusKey]?.<T>(status);
+      return { ...status, messageId, request };
+    }),
+  );
+}
+
+export function transformMotionMasterMessageToStatus<T>(statusKey: StatusKey, requestTimeout: number, messageId: string) {
+  if (typeof requestTimeout !== 'number') {
+    throw new Error(`Invalid requestTimeout=${requestTimeout} provided for ${statusKey}`);
+  }
+
+  return pipe(
+    selectMotionMasterMessageStatusByMessageId<T>(statusKey, messageId),
+    timeout(requestTimeout),
+    extendStatus({ statusKey, messageId }),
+    takeWhile((status) => status.request !== 'succeeded' && status.request !== 'failed', true),
+  );
+}
+
+export function selectMotionMasterMessageByTopic<T>(topic: string) {
+  return pipe(
+    filter(([t]: [string, T]) => t === topic),
+    map(([, data]) => data),
+  );
+}
+
+export function selectMotionMasterMessageStatusByKey<T>(key: keyof MotionMasterMessage.IStatus) {
+  return pipe(
+    filter((message: IMotionMasterMessage) => !!(message.status && message.status[key])),
+    map((message) => message.status?.[key] as T),
+  );
+}
+
+export function mapMonitoringParameterValuesStatusMessageToParameterValues() {
+  return pipe(
+    map((message: IMotionMasterMessage) => {
+      if (message.status?.monitoringParameterValues) {
+        const { timestamp, deviceParameterValues } = message.status.monitoringParameterValues;
+        return [
+          timestamp,
+          ...(deviceParameterValues?.parameterValues?.map((parameterValue) => getParameterValue(parameterValue)) ?? []),
+        ] as ParameterValueType[];
+      }
+      return [];
+    }),
+  );
+}
+
+export function mapMonitoringParameterValuesStatusMessageToDeviceParameters() {
+  return pipe(
+    map((message: IMotionMasterMessage) => {
+      if (message.status?.monitoringParameterValues) {
+        const { timestamp, deviceParameterValues } = message.status.monitoringParameterValues;
+        return [
+          timestamp,
+          ...deviceParameterValues?.parameterValues ?? [],
+        ] as Parameter[];
+      }
+      return [];
+    }),
+  );
+}

package/src/lib/options.ts

@@ -0,0 +1,12 @@
+import { MotionMasterMessage } from './types';
+
+export const parameterValueTypeOptions = {
+  'intValue': 'intValue',
+  'uintValue': 'uintValue',
+  'floatValue': 'floatValue',
+  'stringValue': 'stringValue',
+  'rawValue': 'rawValue',
+};
+
+export const ethercatNetworkStateOptions = MotionMasterMessage.Status.EthercatNetworkState.State;
+export const positionControllerTypeOptions = MotionMasterMessage.Request.ComputeAutoTuningGains.PositionParameters.ControllerType;

package/src/lib/parameter.spec.ts

@@ -0,0 +1,160 @@
+import { differenceParameters, intersectionParameters, makeParameterId, splitParameterId } from "./parameter";
+
+describe('parameter', () => {
+
+  describe('makeParameterId', () => {
+
+    test.each<[[(number | null | undefined), (number | null | undefined)], string]>([
+      [[0x1234, 123], '0x1234:7B'],
+      [[23, 23], '0x0017:17'],
+      [[0, 0], '0x0000:00'],
+      [[0x2000, undefined], '0x2000:00'],
+      [[0x2003, null], '0x2003:00'],
+      [[0x10000, 3], '0x00010000:03'],
+      [[0x100F0, undefined], '0x000100F0:00'],
+    ])('should for tuple %j return "%s"', (tuple, expected) => {
+      const result = makeParameterId(tuple);
+
+      expect(result).toBe(expected);
+    });
+
+    test.each([
+      [{}, '0x0000:00'],
+      [{ index: 0x2004, subindex: 4 }, '0x2004:04'],
+      [{ index: 0x1024 }, '0x1024:00'],
+    ])('should for parameter %j return "%s"', (parameter, expected) => {
+      const result = makeParameterId(parameter);
+
+      expect(result).toBe(expected);
+    });
+
+    test.each([
+      [0x1234, 123, '0x1234:7B'],
+      [23, 23, '0x0017:17'],
+      [0, 0, '0x0000:00'],
+      [0x2000, undefined, '0x2000:00'],
+      [0x2003, null, '0x2003:00'],
+      [0x10000, 3, '0x00010000:03'],
+      [0x100F0, undefined, '0x000100F0:00'],
+    ])('should for index %d and subindex %d return "%s"', (index, subindex, expected) => {
+      const result = makeParameterId(index, subindex);
+
+      expect(result).toBe(expected);
+    });
+
+    it('should throw if index is less than 0', () => {
+      expect(() => {
+        makeParameterId(-123, 0);
+      }).toThrow();
+    });
+
+    it('should throw if subindex is less than 0', () => {
+      expect(() => {
+        makeParameterId(0x1024, -3);
+      }).toThrow();
+    });
+
+  });
+
+  describe('splitParameterId', () => {
+
+    test.each([
+      ['0x1234:7B', [4660, 123]],
+      ['0x000100F0:00', [65776, 0]],
+    ])('should for id "%s" return tuple %j', (id, expected) => {
+      const result = splitParameterId(id);
+
+      expect(result).toEqual(expected);
+    });
+
+    test.each([
+      ['0x12:7B'],
+      ['0x1234:F'],
+      ['0x1234:FG'],
+      ['0x1H34:FF'],
+    ])('should throw error for id "%s"', (id) => {
+      expect(() => splitParameterId(id)).toThrow();
+    });
+
+  });
+
+  describe('differenceParameters', () => {
+    it('should return an empty array if there are no differences', () => {
+      const parameters = differenceParameters(
+        [
+          { index: 0x2030, subindex: 1 },
+          { index: 0x2031, subindex: 1 },
+        ],
+        [
+          { index: 0x2030, subindex: 1 },
+          { index: 0x2031, subindex: 1 },
+        ],
+      );
+
+      expect(parameters).toEqual([]);
+    });
+
+    it('should return an array of differences', () => {
+      const parameters = differenceParameters(
+        [
+          { index: 0x2030, subindex: 1 },
+          { index: 0x2031, subindex: 1 },
+          { index: 0x6040, subindex: 0 },
+          { index: 0x6091, subindex: 0 },
+        ],
+        [
+          { index: 0x2031, subindex: 1 },
+          { index: 0x6040, subindex: 0 },
+          { index: 0x6041, subindex: 0 },
+        ],
+      );
+
+      expect(parameters).toEqual([
+        { index: 0x2030, subindex: 1 },
+        { index: 0x6091, subindex: 0 },
+      ]);
+    });
+  });
+
+  fdescribe('intersectionParameters', () => {
+    it('should return full array if there are no differences', () => {
+      const parameters = intersectionParameters(
+        [
+          { index: 0x2030, subindex: 1 },
+          { index: 0x2031, subindex: 1 },
+        ],
+        [
+          { index: 0x2030, subindex: 1 },
+          { index: 0x2031, subindex: 1 },
+        ],
+      );
+
+      expect(parameters).toEqual([
+        { index: 0x2030, subindex: 1 },
+        { index: 0x2031, subindex: 1 },
+      ]);
+    });
+
+    it('should return an array excluding differences', () => {
+      const parameters = intersectionParameters(
+        [
+          { index: 0x2031, subindex: 1 },
+          { index: 0x6040, subindex: 0 },
+          { index: 0x6041, subindex: 0 },
+        ],
+        [
+          { index: 0x2030, subindex: 1 },
+          { index: 0x2031, subindex: 1 },
+          { index: 0x6040, subindex: 0 },
+          { index: 0x6091, subindex: 0 },
+        ],
+      );
+
+      expect(parameters).toEqual([
+        { index: 0x2031, subindex: 1 },
+        { index: 0x6040, subindex: 0 },
+      ]);
+    });
+  });
+
+});