motion-master-client 0.0.1 → 0.0.3

package/src/lib/operators.ts

@@ -0,0 +1,93 @@
+import { pipe, filter, map, timeout, takeWhile, retryWhen, concat, take, Observable, delay } from 'rxjs';
+import { getParameterValue } from './util';
+import { requestStatusResolver } from './request-status-resolver';
+import { MotionMasterMessage, ParameterValueType, RequestStatus, StatusKey } from './types';
+
+export function selectMotionMasterMessageStatusByMessageId<T>(key: StatusKey, id?: string) {
+  return pipe(
+    filter((message: MotionMasterMessage) => 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: MotionMasterMessage) => !!(message.status && message.status[key])),
+    map((message) => message.status?.[key] as T),
+  );
+}
+
+/**
+ * Retry (resubscribe) to the source observable a number of attempts with delay timeout.
+ */
+export function retryWithDelay<T>(delayTimeout = 1000, attempts = 3) {
+  return pipe(
+    retryWhen<T>((errors: Observable<Error>) => concat(
+      errors.pipe(
+        delay(delayTimeout),
+        take(attempts),
+      ),
+      errors.pipe(
+        map(error => {
+          throw error; // rethrow the source observable error if all attempts fail
+        }),
+      ),
+    )),
+  );
+}
+
+export function mapStatusMessageToParameterValues() {
+  return pipe(
+    map((message: MotionMasterMessage) => {
+      if (message.status?.monitoringParameterValues) {
+        const { timestamp, deviceParameterValues } = message.status.monitoringParameterValues;
+        return [
+          timestamp,
+          ...(deviceParameterValues?.parameterValues?.map((parameterValue) => getParameterValue(parameterValue)) ?? []),
+        ] as ParameterValueType[];
+      }
+      return [];
+    }),
+  );
+}

package/src/lib/{options.js → options.ts}

@@ -1,11 +1,12 @@
 import { MotionMasterMessage } from './types';
+
 export const parameterValueTypeOptions = {
-    'intValue': 'intValue',
-    'uintValue': 'uintValue',
-    'floatValue': 'floatValue',
-    'stringValue': 'stringValue',
-    'rawValue': 'rawValue',
+  '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;
-//# sourceMappingURL=options.js.map

package/src/lib/parameter.spec.ts

@@ -0,0 +1,81 @@
+import { 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();
+    });
+
+  });
+
+});

package/src/lib/parameter.ts

@@ -0,0 +1,119 @@
+import { MotionMasterMessage, ParameterTypeValueKey, ParameterValueType } from "./types";
+
+export interface Parameter extends MotionMasterMessage.Status.DeviceParameterInfo.IParameter, MotionMasterMessage.Status.DeviceParameterValues.IParameterValue {
+  index: number;
+  subindex: number;
+  name: string;
+  value: ParameterValueType;
+  typeValue: ParameterTypeValueKey;
+}
+
+export type ParameterIndexSubindex = Pick<Parameter, 'index' | 'subindex'>;
+
+/**
+ * Make parameter id by providing a tuple of index and subindex.
+ *
+ * @param tuple - an array of index and subindex
+ * @throws {Error} if index or subindex are less than 0
+ * @returns combined index and subindex in uppercase hexadecimal format, e.g. "0x60FE:02"
+ */
+export function makeParameterId(tuple: [(number | null | undefined), (number | null | undefined)]): string;
+
+/**
+ * Make parameter id by providing an object which has index and subindex properties.
+ *
+ * @param parameter - an object with optional index and subindex properties
+ * @throws {Error} if index or subindex are less than 0
+ * @returns combined index and subindex in uppercase hexadecimal format, e.g. "0x60FE:02"
+ */
+export function makeParameterId(parameter: { index?: (number | null), subindex?: (number | null) }): string;
+
+/**
+ * Make parameter id by providing index and subindex.
+ *
+ * @param index - from 0x0000 to 0xFFFF for objects defined in ESI and >0xFFFF for custom object
+ * @param subindex - defaults to 0 if not provided
+ * @throws {Error} if index or subindex are less than 0
+ * @returns combined index and subindex in uppercase hexadecimal format, e.g. "0x60FE:02"
+ */
+export function makeParameterId(index?: (number | null), subindex?: (number | null)): string;
+
+/**
+ * Make parameter id by providing different arguments.
+ *
+ * The purpose of this declaration is to expose the signature of the implementation for {@link makeDeviceParameterId} function.
+ *
+ * @param a - number or an object with index and subindex or tuple of index and subindex
+ * @param b - optional subindex, defaults to 0 if not provided
+ * @throws {Error} if index or subindex are less than 0
+ * @returns combined index and subindex in uppercase hexadecimal format, e.g. "0x60FE:02"
+ */
+export function makeParameterId(a?: (number | null) | { index?: (number | null), subindex?: (number | null) } | [(number | null | undefined), (number | null | undefined)], b?: (number | null)): string;
+
+export function makeParameterId(a?: (number | null) | { index?: (number | null), subindex?: (number | null) } | [(number | null | undefined), (number | null | undefined)], b?: (number | null)): string {
+  let index = 0;
+  let subindex = 0;
+
+  if (Array.isArray(a)) {
+    if (a[0]) {
+      index = a[0];
+    }
+    if (a[1]) {
+      subindex = a[1];
+    }
+  } else if (typeof a === 'object') {
+    if (a?.index) {
+      index = a.index;
+    }
+    if (a?.subindex) {
+      subindex = a.subindex;
+    }
+  } else {
+    if (typeof a === 'number') {
+      index = a;
+    }
+    if (typeof b === 'number') {
+      subindex = b;
+    }
+  }
+
+  if (index < 0) {
+    throw new Error(`The provided index to makeParameterId must be greater than 0: ${index}`);
+  }
+
+  if (subindex < 0) {
+    throw new Error(`The provided subindex to makeParameterId must be greater than 0: ${subindex}`);
+  }
+
+  const indexMaxLength = index > 0xFFFF ? 8 : 4;
+  const x = index.toString(16).toUpperCase().padStart(indexMaxLength, '0');
+  const y = subindex.toString(16).toUpperCase().padStart(2, '0');
+
+  return `0x${x}:${y}`;
+}
+
+/**
+ * Example of parameter id is "0x2110:1A" where:
+ * - 0x2110 is object index in hexadecimal format
+ * - 1A is subindex in hexadecimal format
+ */
+export const parameterIdRegExp = /^0x([0-9a-fA-F]{4,}):([0-9a-fA-F]{2})$/;
+
+/**
+ * Split device parameter id into parts.
+ *
+ * @param id - parameter id like "0x2110:1A"
+ * @returns tuple of index and subindex
+ */
+export function splitParameterId(id: string): [number, number] {
+  const match = id.match(parameterIdRegExp);
+
+  if (!match) {
+    throw new Error(`Parameter id "${id}" doesn't match the regular expression: ${parameterIdRegExp}`);
+  }
+
+  return [
+    parseInt(match[1], 16), // index
+    parseInt(match[2], 16), // subindex
+  ];
+}

package/src/lib/request-status-resolver.ts

@@ -0,0 +1,380 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
+import { MotionMasterMessage, RequestStatus, StatusKey } from "./types";
+
+export const requestStatusResolver: { [key in StatusKey]: <T>(status: T) => RequestStatus } = {
+  systemPong: () => 'succeeded',
+  systemVersion: (status: MotionMasterMessage.Status.ISystemVersion) => {
+    return status.version ? 'succeeded' : 'failed';
+  },
+  systemEvent: (status: MotionMasterMessage.Status.ISystemEvent) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    return 'succeeded';
+  },
+  deviceInfo: (status: MotionMasterMessage.Status.IDeviceInfo) => {
+    return status.devices ? 'succeeded' : 'failed';
+  },
+  deviceParameterInfo: (status: MotionMasterMessage.Status.IDeviceParameterInfo) => {
+    return status.parameters ? 'succeeded' : 'failed';
+  },
+  deviceParameterValues: (status: MotionMasterMessage.Status.IDeviceParameterValues) => {
+    if (status.progress) {
+      if (status.progress.percentage === 100) {
+        return 'succeeded';
+      } else {
+        return 'running';
+      }
+    }
+
+    return 'succeeded';
+  },
+  multiDeviceParameterValues: () => 'succeeded',
+  deviceFileList: (status: MotionMasterMessage.Status.IDeviceFileList) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    return 'succeeded';
+  },
+  deviceFile: (status: MotionMasterMessage.Status.IDeviceFile) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    return 'succeeded';
+  },
+  deviceEvent: (status: MotionMasterMessage.Status.IDeviceEvent) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    return 'succeeded';
+  },
+  deviceFirmwareInstallation: (status: MotionMasterMessage.Status.IDeviceFirmwareInstallation) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    if (status.success) {
+      if (status.success.code === MotionMasterMessage.Status.DeviceFirmwareInstallation.Success.Code.DONE) {
+        return 'succeeded';
+      }
+
+      if (status.success.code === MotionMasterMessage.Status.DeviceFirmwareInstallation.Success.Code.UNSPECIFIED) {
+        return 'succeeded';
+      }
+    }
+
+    return 'running';
+  },
+  deviceLog: (status: MotionMasterMessage.Status.IDeviceLog) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    return 'succeeded';
+  },
+  deviceFaultReset: (status: MotionMasterMessage.Status.IDeviceFaultReset) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    return 'succeeded';
+  },
+  coggingTorqueRecording: (status: MotionMasterMessage.Status.ICoggingTorqueRecording) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    if (status.success) {
+      if (status.success.code === MotionMasterMessage.Status.CoggingTorqueRecording.Success.Code.DONE) {
+        return 'succeeded';
+      }
+
+      if (status.success.code === MotionMasterMessage.Status.CoggingTorqueRecording.Success.Code.UNSPECIFIED) {
+        return 'succeeded';
+      }
+    }
+
+    return 'running';
+  },
+  coggingTorqueData: (status: MotionMasterMessage.Status.ICoggingTorqueData) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    return 'succeeded';
+  },
+  offsetDetection: (status: MotionMasterMessage.Status.IOffsetDetection) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    if (status.success) {
+      if (status.success.code === MotionMasterMessage.Status.OffsetDetection.Success.Code.DONE) {
+        return 'succeeded';
+      }
+
+      if (status.success.code === MotionMasterMessage.Status.OffsetDetection.Success.Code.UNSPECIFIED) {
+        return 'succeeded';
+      }
+    }
+
+    return 'running';
+  },
+  plantIdentification: (status: MotionMasterMessage.Status.IPlantIdentification) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    if (status.success) {
+      if (status.success.code === MotionMasterMessage.Status.PlantIdentification.Success.Code.DONE) {
+        return 'succeeded';
+      }
+
+      if (status.success.code === MotionMasterMessage.Status.PlantIdentification.Success.Code.UNSPECIFIED) {
+        return 'succeeded';
+      }
+    }
+
+    return 'running';
+  },
+  autoTuning: (status: MotionMasterMessage.Status.IAutoTuning) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    if (status.success) {
+      if (status.success.code === MotionMasterMessage.Status.AutoTuning.Success.Code.POSITION_DONE ||
+        status.success.code === MotionMasterMessage.Status.AutoTuning.Success.Code.VELOCITY_DONE) {
+        return 'succeeded';
+      }
+
+      if (status.success === MotionMasterMessage.Status.AutoTuning.Success.Code.UNSPECIFIED) {
+        return 'succeeded';
+      }
+    }
+
+    return 'running';
+  },
+  motionController: (status: MotionMasterMessage.Status.IMotionController) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    return 'succeeded';
+  },
+  signalGenerator: (status: MotionMasterMessage.Status.ISignalGenerator) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    if (status.success) {
+      if (status.success.code === MotionMasterMessage.Status.SignalGenerator.Success.Code.DONE) {
+        return 'succeeded';
+      }
+
+      if (status.success.code === MotionMasterMessage.Status.SignalGenerator.Success.Code.PARAMETERS_SET) {
+        return 'succeeded';
+      }
+
+      if (status.success.code === MotionMasterMessage.Status.SignalGenerator.Success.Code.UNSPECIFIED) {
+        return 'succeeded';
+      }
+    }
+
+    return 'running';
+  },
+  monitoringParameterValues: (status: MotionMasterMessage.Status.IMonitoringParameterValues) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    return 'succeeded';
+  },
+  deviceStop: (status: MotionMasterMessage.Status.IDeviceStop) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    return 'succeeded';
+  },
+  ethercatNetworkState: (status: MotionMasterMessage.Status.IEthercatNetworkState) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    return 'succeeded';
+  },
+  narrowAngleCalibration: (status: MotionMasterMessage.Status.INarrowAngleCalibration) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    if (status.success) {
+      if (status.success.code === MotionMasterMessage.Status.NarrowAngleCalibration.Success.Code.DONE) {
+        return 'succeeded';
+      }
+
+      if (status.success.code === MotionMasterMessage.Status.NarrowAngleCalibration.Success.Code.UNSPECIFIED) {
+        return 'succeeded';
+      }
+    }
+
+    return 'running';
+  },
+  systemIdentification: (status: MotionMasterMessage.Status.ISystemIdentification) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    if (status.success) {
+      if (status.success.code === MotionMasterMessage.Status.SystemIdentification.Success.Code.DONE) {
+        return 'succeeded';
+      }
+
+      if (status.success.code === MotionMasterMessage.Status.SystemIdentification.Success.Code.UNSPECIFIED) {
+        return 'succeeded';
+      }
+    }
+
+    return 'running';
+  },
+  circuloEncoderMagnetDistance: (status: MotionMasterMessage.Status.ICirculoEncoderMagnetDistance) => {
+    if (typeof status.distance === 'number' || typeof status.position === 'number') {
+      return 'succeeded';
+    }
+
+    return 'failed';
+  },
+  circuloEncoderNarrowAngleCalibrationProcedure: (status: MotionMasterMessage.Status.ICirculoEncoderNarrowAngleCalibrationProcedure) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    if (status.success) {
+      if (status.success.code === MotionMasterMessage.Status.CirculoEncoderNarrowAngleCalibrationProcedure.Success.Code.STOPPED) {
+        return 'failed';
+      }
+
+      if (status.success.code === MotionMasterMessage.Status.CirculoEncoderNarrowAngleCalibrationProcedure.Success.Code.DONE) {
+        return 'succeeded';
+      }
+
+      if (status.success === MotionMasterMessage.Status.CirculoEncoderNarrowAngleCalibrationProcedure.Success.Code.UNSPECIFIED) {
+        return 'succeeded';
+      }
+    }
+
+    return 'running';
+  },
+  deviceCia402State: (status: MotionMasterMessage.Status.IDeviceCiA402State) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    return 'succeeded';
+  },
+  systemLog: (status: MotionMasterMessage.Status.ISystemLog) => {
+    if (status.content) {
+      return 'succeeded';
+    }
+
+    return 'failed';
+  },
+  deviceSiiRestore: (status: MotionMasterMessage.Status.IDeviceSiiRestore) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    if (status.success) {
+      if (status.success.code === MotionMasterMessage.Status.DeviceSiiRestore.Success.Code.DONE) {
+        return 'succeeded';
+      }
+
+      if (status.success.code === MotionMasterMessage.Status.DeviceSiiRestore.Success.Code.UNSPECIFIED) {
+        return 'succeeded';
+      }
+    }
+
+    return 'running';
+  },
+  openLoopFieldControl: (status: MotionMasterMessage.Status.IOpenLoopFieldControl) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    if (status.success) {
+      if (status.success.code === MotionMasterMessage.Status.OpenLoopFieldControl.Success.Code.DONE) {
+        return 'succeeded';
+      }
+
+      if (status.success.code === MotionMasterMessage.Status.OpenLoopFieldControl.Success.Code.UNSPECIFIED) {
+        return 'succeeded';
+      }
+    }
+
+    return 'running';
+  },
+  fullAutoTuning: (status: MotionMasterMessage.Status.IFullAutoTuning) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    if (status.success) {
+      if (status.success.code === MotionMasterMessage.Status.FullAutoTuning.Success.Code.POSITION_STOPPED ||
+        status.success.code === MotionMasterMessage.Status.FullAutoTuning.Success.Code.VELOCITY_STOPPED) {
+        return 'failed';
+      }
+
+      if (status.success.code === MotionMasterMessage.Status.FullAutoTuning.Success.Code.POSITION_DONE ||
+        status.success.code === MotionMasterMessage.Status.FullAutoTuning.Success.Code.VELOCITY_DONE) {
+        return 'succeeded';
+      }
+
+      if (status.success === MotionMasterMessage.Status.FullAutoTuning.Success.Code.UNSPECIFIED) {
+        return 'succeeded';
+      }
+    }
+
+    return 'running';
+  },
+  circuloEncoderConfiguration: (status: MotionMasterMessage.Status.ICirculoEncoderConfiguration) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    if (status.success) {
+      if (status.success.code === MotionMasterMessage.Status.CirculoEncoderConfiguration.Success.Code.DONE) {
+        return 'succeeded'
+      }
+
+      if (status.success.code === MotionMasterMessage.Status.CirculoEncoderConfiguration.Success.Code.UNSPECIFIED) {
+        return 'succeeded'
+      }
+    }
+
+    return 'running';
+  },
+  osCommand: (status: MotionMasterMessage.Status.IOsCommand) => {
+    if (status.error) {
+      return 'failed';
+    }
+
+    if (status.success) {
+      if (status.success.code === MotionMasterMessage.Status.OsCommand.Success.Code.DONE) {
+        return 'succeeded';
+      }
+
+      if (status.success.code === MotionMasterMessage.Status.OsCommand.Success.Code.UNSPECIFIED) {
+        return 'succeeded';
+      }
+    }
+
+    return 'running';
+  },
+};

package/src/lib/system-log-line.ts

@@ -0,0 +1,8 @@
+export interface SystemLogLine {
+  date: Date;
+  uptime: string;
+  id: string;
+  file: string;
+  level: string;
+  message: string;
+}