motion-master-client 0.0.55 → 0.0.56

package/src/lib/operators.ts

@@ -0,0 +1,108 @@
+import { pipe, filter, map, timeout, takeWhile, Observable, UnaryFunction, mergeMap, of } from 'rxjs';
+import { getParameterValue } from './util';
+import { requestStatusResolver } from './request-status-resolver';
+import { IMotionMasterMessage, MotionMasterMessage, ParameterValueType, StatusKey } from './types';
+import { DeviceParameter } from './device-parameter';
+import { MotionMasterReqResClient } from './motion-master-req-res-client';
+import { makeParameterId } 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()
+  : UnaryFunction<Observable<IMotionMasterMessage>, Observable<ParameterValueType[]>> {
+  return pipe(
+    map((message: IMotionMasterMessage) => {
+      if (message.status?.monitoringParameterValues) {
+        const { deviceParameterValues } = message.status.monitoringParameterValues;
+        if (deviceParameterValues?.parameterValues) {
+          return deviceParameterValues.parameterValues.map((parameterValue) => getParameterValue(parameterValue));
+        }
+      }
+      return [];
+    }),
+  );
+}
+
+export function mapMonitoringParameterValuesStatusMessageToDeviceParameters(request: MotionMasterReqResClient)
+  : UnaryFunction<Observable<IMotionMasterMessage>, Observable<DeviceParameter[]>> {
+  return pipe(
+    mergeMap((message: IMotionMasterMessage) => {
+      const parameterValues = message.status?.monitoringParameterValues?.deviceParameterValues?.parameterValues;
+
+      if (!parameterValues) {
+        return of([]);
+      }
+
+      const deviceAddress = message?.status?.monitoringParameterValues?.deviceParameterValues?.deviceAddress!;
+
+      return request.resolveDeviceParameterInfoMap(deviceAddress).pipe(
+        map((infoMap) => {
+          return parameterValues.map((parameter) => {
+            const index = parameter.index ?? 0x0000;
+            const subindex = parameter.subindex ?? 0x00;
+            const id = makeParameterId(index, subindex);
+
+            const infoParameter = infoMap.get(id);
+
+            const value = getParameterValue(parameter);
+
+            return { id, index, subindex, ...infoParameter, value } as DeviceParameter;
+          })
+        }),
+      );
+    }),
+  );
+}

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 },
+      ]);
+    });
+  });
+
+});

package/src/lib/parameter.ts

@@ -0,0 +1,170 @@
+import { MotionMasterMessage, ParameterTypeValueKey, ParameterValueType } from "./types";
+import { differenceWith, intersectionWith, round } from "lodash";
+
+export interface Parameter extends MotionMasterMessage.Status.DeviceParameterInfo.IParameter, MotionMasterMessage.Status.DeviceParameterValues.IParameterValue {
+  index: number;
+  subindex: number;
+  name: string;
+  value: ParameterValueType;
+  typeValueKey: ParameterTypeValueKey;
+  options?: { [key: string]: number };
+}
+
+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
+  ];
+}
+
+export function isParameterId(id: string): boolean {
+  return parameterIdRegExp.test(id);
+}
+
+export function parametersCompareFn(
+  a: Pick<Parameter, 'index' | 'subindex'>,
+  b: Pick<Parameter, 'index' | 'subindex'>,
+): number {
+  if (a.index > b.index) {
+    return 1;
+  } else if (a.index < b.index) {
+    return -1;
+  } else {
+    if (a.subindex > b.subindex) {
+      return 1;
+    } else if (a.subindex < b.subindex) {
+      return -1;
+    } else {
+      return 0;
+    }
+  }
+}
+
+export function differenceParameters<T extends Pick<Parameter, 'index' | 'subindex'>>(p1: T[], p2: T[]): T[] {
+  return differenceWith(p1, p2, (a, b) => a.index === b.index && a.subindex === b.subindex);
+}
+
+export function intersectionParameters<T extends Pick<Parameter, 'index' | 'subindex'>>(p1: T[], p2: T[]): T[] {
+  return intersectionWith(p1, p2, (a, b) => a.index === b.index && a.subindex === b.subindex);
+}
+
+export function intersectionParametersWithDifferentValues<T extends Pick<Parameter, 'index' | 'subindex' | 'value'>>(p1: T[], p2: T[], roundFloats = false): T[] {
+  return intersectionWith(p1, p2, (a, b) => {
+    if (a.index === b.index && a.subindex === b.subindex) {
+      // values that are very close but have a different number of decimal places are treated as not equal
+      if (roundFloats && typeof a.value === 'number' && typeof b.value === 'number') {
+        const v1 = round(a.value, 7);
+        const v2 = round(b.value, 7);
+        return v1 !== v2;
+      } else if (Array.isArray(a.value) && Array.isArray(b.value)) {
+        return JSON.stringify(a.value) !== JSON.stringify(b.value);
+      } else {
+        return a.value !== b.value;
+      }
+    }
+    return false;
+  });
+}

package/src/lib/product-id-range.ts

@@ -0,0 +1,8 @@
+// https://docs.google.com/spreadsheets/d/1XJX1eqGau1X3sse10fuF-tVVgosbxCo-3ioUUG2CDYQ
+export const productIdRange = {
+  'CIRCULO_SAFE_MOTION': [8600, 8699],
+  'INTEGRO': [9000, 9499],
+  'NODE': [9500, 9599],
+  'NODE_SAFETY': [9600, 9998],
+  'INTERNAL': [9999, 9999],
+};