motion-master-client 0.0.246 → 0.0.248

package/src/lib/smm-od.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Types defined here represent a JSON file structure of the SMM (Safety Motion Module) object dictionary.
+ */
+type SmmOdParameter = {
+    parameterName: string;
+    variableName: string | null;
+    group: string | null;
+    index: number;
+    subindex: number;
+    description: string;
+    type: string;
+    typeRef?: string | null;
+    size: number;
+    unit: string | null;
+    min: number | null;
+    max: number | null;
+    defaultValue: number | string | null;
+    access: 'rw' | 'ro' | null;
+};
+type SmmOdEnumValue = {
+    identifier?: string;
+    value: number;
+    label: string;
+    axis?: number | null;
+};
+type SmmOdEnumType = {
+    type: string;
+    enum: SmmOdEnumValue[];
+};
+type SmmOdParameterCategory = 'safety' | 'manufacturer' | 'constants' | 'globalVariables';
+type SmmOdParameters = {
+    [category in SmmOdParameterCategory]: SmmOdParameter[];
+};
+type SmmOdTypes = {
+    [key: string]: SmmOdEnumType;
+};
+export type SmmOd = {
+    parameters: SmmOdParameters;
+    types: SmmOdTypes;
+};
+export {};

package/src/lib/smm-od.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Types defined here represent a JSON file structure of the SMM (Safety Motion Module) object dictionary.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=smm-od.js.map

package/src/lib/smm-od.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smm-od.js","sourceRoot":"","sources":["../../../../../libs/motion-master-client/src/lib/smm-od.ts"],"names":[],"mappings":";AAAA;;GAEG"}

package/src/lib/smm.d.ts

@@ -1,62 +1,214 @@
 /// <reference types="node" />
 import PythonStruct, { DataType } from 'python-struct';
 import { Buffer } from 'buffer';
-export declare const smmGroupBitMasks: number[][];
+/**
+ * Builds a bitmask for the safety parameters of a given group in the SMM parameter set.
+ *
+ * The bitmask is an array of bytes where each bit represents whether a specific safety
+ * parameter belongs to the specified group. The group index determines which group's
+ * parameters are marked as `1` in the bitmask, and others are marked as `0`.
+ *
+ * @param groupIndex - The index of the group for which to build the bitmask. The index corresponds
+ *                     to the position of the group in the safety parameters.
+ * @param parameterStructVersion - The version of the parameter struct to use. Defaults to `0x0041`.
+ *                              If the version is less than `0x0203`, the `smmOdV1` format is used;
+ *                              otherwise, the `smmOdV2` format is used.
+ *
+ * @returns A `Uint8Array` representing the bitmask for the specified group. Each byte contains 8 bits,
+ *          where each bit corresponds to a safety parameter.
+ *
+ * @throws If the `groupIndex` is out of range or if the parameter structure is not valid for the given version.
+ */
+export declare function buildSmmParametersGroupBitmask(groupIndex: number, parameterStructVersion?: number): Uint8Array;
+/**
+ * Builds the structure format strings for each group of parameters based on the given struct version.
+ *
+ * This function maps parameters in the `smmOd` object to their respective safety groups, processes
+ * them, and converts their types to structure format characters (e.g., `<` for little-endian).
+ * The function supports different versions of the parameter struct format, defaulting to version `0x0041`.
+ *
+ * @param parameterStructVersion - The version of the parameter struct to use. Defaults to `0x0041`.
+ *                              If the version is less than `0x0203`, the `smmOdV1` format is used;
+ *                              otherwise, the `smmOdV2` format is used.
+ *
+ * @returns An array of structure format strings for each group of parameters.
+ */
+export declare function buildSmmParametersGroupPackFormats(parameterStructVersion?: number): string[];
+/**
+ * Builds the structure format string for all parameters based on the given struct version.
+ *
+ * This function processes the parameters in the `smmOd` object, converting each parameter's type
+ * to its corresponding structure format character (e.g., `<` for little-endian). It supports different
+ * versions of the parameter struct format, defaulting to version `0x0041`.
+ *
+ * @param parameterStructVersion - The version of the parameter struct to use. Defaults to `0x0041`.
+ *                              If the version is less than `0x0203`, the `smmOdV1` format is used;
+ *                              otherwise, the `smmOdV2` format is used.
+ *
+ * @returns A structure format string representing all the parameters, starting with a `<` (little-endian).
+ */
+export declare function buildSmmParametersPackFormat(parameterStructVersion?: number): string;
+/**
+ * Calculates a CRC-32 checksum using a custom SMM-specific polynomial lookup table.
+ *
+ * This CRC implementation is tailored for Safety Motion Module (SMM) data validation,
+ * ensuring data integrity across packed buffers. It supports an initial CRC seed,
+ * allowing for chained calculations or non-standard CRC resets.
+ *
+ * @param buffer - The input data buffer (`Uint8Array`) for which to calculate the CRC.
+ * @param initial - The initial CRC value, typically `0xFFFFFFFF` for standard calculations.
+ *
+ * @returns The computed CRC-32 checksum as a 32-bit unsigned integer.
+ */
 export declare function calcSmmCRC32(buffer: Uint8Array, initial: number): number;
-export declare const smmGroupPackFormats: string[];
-export declare function calcSmmBitmask(values: DataType[], group: SmmVerificationGroupOrdinal): {
+/**
+ * Packs SMM (Safety Motion Module) credentials (username and password) into a fixed-size binary format.
+ * Each field is padded or truncated to 24 bytes.
+ *
+ * @param username - The username to be packed. It will be padded or truncated to 24 bytes.
+ * @param password - The password to be packed. It will also be padded or truncated to 24 bytes.
+ *
+ * @returns A `Buffer` containing the packed username and password.
+ *
+ * @throws Error if the username or password contains invalid characters or types.
+ */
+export declare function packSmmCredentials(username: string, password: string): Buffer;
+/**
+ * Packs the new and old passwords into a fixed-size binary format for SMM (Safety Motion Module) password change operations.
+ * Each password is padded or truncated to 24 bytes.
+ *
+ * @param newPassword - The new password to be packed. It will be padded or truncated to 24 bytes.
+ * @param oldPassword - The current/old password to be packed. It will be padded or truncated to 24 bytes.
+ *
+ * @returns A `Buffer` containing the packed new and old passwords.
+ *
+ * @throws Error if either password contains invalid characters or types.
+ */
+export declare function packSmmChangePassword(newPassword: string, oldPassword: string): Buffer;
+/**
+ * Packs SMM (Safety Motion Module) parameter values into a binary buffer,
+ * following the specified SMM parameter structure version.
+ * It computes and appends a CRC32 checksum to ensure data integrity.
+ *
+ * @param values - An array of `DataType` values to be packed.
+ * @param parameterStructVersion - The version of the parameter struct to use. Defaults to `0x0041`.
+ *                              If the version is less than `0x0203`, the `smmOdV1` format is used;
+ *                              otherwise, the `smmOdV2` format is used.
+ *
+ * @returns An object containing:
+ * - `buffer`: A `Buffer` with the packed values followed by the CRC32 checksum.
+ * - `crc`: The computed CRC32 checksum for the packed data.
+ * - `crcBuffer`: A `Buffer` representing the packed CRC32 checksum.
+ * - `values`: The original `DataType[]` values.
+ * - `valuesBuffer`: A `Buffer` containing the packed values (without the CRC).
+ *
+ * @throws Error if packing fails due to an invalid structure or value mismatch.
+ */
+export declare function packSmmParameterValues(values: DataType[], parameterStructVersion?: number): {
+    buffer: Buffer;
+    crc: number;
+    crcBuffer: Buffer;
+    values: PythonStruct.DataType[];
+    valuesBuffer: Buffer;
+};
+/**
+ * Unpacks SMM (Safety Motion Module) parameter values from a `Uint8Array` buffer
+ * according to the specified parameter structure version.
+ *
+ * This function decodes the packed buffer back into its original data values,
+ * using the structure format defined for the given SMM parameter structure version.
+ *
+ * @param values - A `Uint8Array` representing the packed parameter values.
+ * @param parameterStructVersion - The version of the parameter struct to use. Defaults to `0x0041`.
+ *                              If the version is less than `0x0203`, the `smmOdV1` format is used;
+ *                              otherwise, the `smmOdV2` format is used.
+ *
+ * @returns An array of unpacked values, decoded according to the structure format.
+ *
+ * @throws Error if the unpacking fails or the data format is incorrect.
+ */
+export declare function unpackSmmParameterValues(values: Uint8Array, parameterStructVersion?: number): PythonStruct.DataType[];
+/**
+ * Packs SMM (Safety Motion Module) parameter values into a buffer for verification,
+ * including a bitmask and CRC32 checksum to ensure data integrity.
+ *
+ * This function prepares data specifically for verification purposes, combining
+ * parameter values, a group-specific bitmask, and a CRC32 checksum.
+ *
+ * @param values - An array of `DataType` representing the parameter values to be packed.
+ * @param groupIndex - The index of the parameter group, determining the bitmask and packing format.
+ * @param parameterStructVersion - The version of the parameter struct to use. Defaults to `0x0041`.
+ *                              If the version is less than `0x0203`, the `smmOdV1` format is used;
+ *                              otherwise, the `smmOdV2` format is used.
+ *
+ * @returns An object containing:
+ * - `buffer`: A `Uint8Array` combining the bitmask and CRC32 checksum for verification.
+ * - `crc`: The CRC32 checksum calculated from the packed data and bitmask.
+ *
+ * @throws Error if the groupIndex is invalid or packing fails.
+ */
+export declare function packSmmParameterValuesForVerification(values: DataType[], groupIndex: number, parameterStructVersion?: number): {
     buffer: Uint8Array;
     crc: number;
 };
+/**
+ * Packs a `Date` object into a binary buffer in a specific format for the SMM (Safety Motion Module).
+ * The date is serialized into the following fields: year (2 bytes), month (1 byte), day (1 byte),
+ * hours (1 byte), minutes (1 byte), seconds (1 byte), and a trailing byte (set to 0).
+ * The packed data can be used for storing or transmitting the date in a structured format compatible with SMM.
+ *
+ * @param date - The `Date` object to be packed. It is expected to be in UTC time.
+ *
+ * @returns A `Buffer` containing the packed date.
+ */
 export declare function packSmmDate(date: Date): Buffer;
+/**
+ * Packs a validation report for the SMM (Safety Motion Module), including a CRC, date, and credentials.
+ * The function takes a content `Uint8Array`, a `Date`, a `username`, and a `password`, and returns an object
+ * containing the packed report, the CRC, and the credentials used for packing.
+ *
+ * The packed report includes the following components:
+ * - CRC32 checksum of the content.
+ * - The date packed into a specific format.
+ * - The credentials (username and password) packed into a specific format.
+ *
+ * @param content - The content of the validation report, as a `Uint8Array`.
+ * @param date - The date of the report to be packed into the format used by SMM.
+ * @param username - The username associated with the report.
+ * @param password - The password associated with the report.
+ *
+ * @returns An object containing:
+ * - `buffer`: A `Uint8Array` that includes the packed CRC, date, and credentials.
+ * - `crc`: The CRC32 checksum of the `content`.
+ * - `credentials`: The packed username and password.
+ */
 export declare function packSmmValidationReport(content: Uint8Array, date: Date, username: string, password: string): {
     buffer: Uint8Array;
     crc: number;
     credentials: Buffer;
 };
-export declare const smmPackFormat = "<H24sBHBBBBBHB2BihihIBIBBHBBIBBBIHHHhHBBHBBHiIBBHBHHiiBHHHiI4B4H4H4H4i4i4IiiI";
-export declare function packSmmParameterValues(values: DataType[], format?: string): {
-    buffer: Buffer;
-    crc: number;
-    crcBuffer: Buffer;
-    values: PythonStruct.DataType[];
-    valuesBuffer: Buffer;
-};
-export declare function packSmmCredentials(username: string, password: string): Buffer;
-export declare function packSmmChangePassword(newPassword: string, oldPassword: string): Buffer;
+/**
+ * Packs a CRC (Cyclic Redundancy Check) value into a 4-byte little-endian binary format.
+ * This is typically used for verifying software updates in the SMM (Safety Motion Module).
+ *
+ * @param crc - The CRC value to be packed, represented as a 32-bit unsigned integer.
+ *
+ * @returns A `Buffer` containing the packed CRC value in little-endian format.
+ *
+ * @throws Error if the provided CRC is not a valid number.
+ */
 export declare function packSmmSoftwareUpdateCrc(crc: number): Buffer;
-export declare function unpackSmmParameterValues(values: Uint8Array, format?: string): PythonStruct.DataType[];
-export declare enum SmmVerificationGroupOrdinal {
-    GENERAL = 1,
-    SAFETY_IO = 2,
-    ANALOG_IN = 3,
-    ENCODER_1 = 4,
-    ENCODER_2 = 5,
-    STO_SBC = 6,
-    SOS = 7,
-    SS1 = 8,
-    SS2 = 9,
-    SLS1 = 10,
-    SLS2 = 11,
-    SLS3 = 12,
-    SLS4 = 13,
-    SMS = 14
-}
-export declare const smmVerificationGroupNameToOrdinal: {
-    'General Parameters (General Parameters)': SmmVerificationGroupOrdinal;
-    'Safety IO (Digital I/O)': SmmVerificationGroupOrdinal;
-    'Safety IO (Analog Input)': SmmVerificationGroupOrdinal;
-    'Encoder selection (Encoders)': SmmVerificationGroupOrdinal;
-    'Encoder selection (Speed / position)': SmmVerificationGroupOrdinal;
-    'Safety functions (STO + SBC)': SmmVerificationGroupOrdinal;
-    'Safety functions (SOS)': SmmVerificationGroupOrdinal;
-    'Safety functions (SS1)': SmmVerificationGroupOrdinal;
-    'Safety functions (SS2)': SmmVerificationGroupOrdinal;
-    'Safety functions (SLS1)': SmmVerificationGroupOrdinal;
-    'Safety functions (SLS2)': SmmVerificationGroupOrdinal;
-    'Safety functions (SLS3)': SmmVerificationGroupOrdinal;
-    'Safety functions (SLS4)': SmmVerificationGroupOrdinal;
-    'Safety functions (SMS)': SmmVerificationGroupOrdinal;
-};
-export declare const smmVerificationGroupNames: string[];
-export type SmmVerificationGroupName = keyof typeof smmVerificationGroupNameToOrdinal;
+/**
+ * Retrieves the names of all safety parameter groups from the specified parameter structure version.
+ *
+ * The function returns a list of unique group names based on the version of the parameter structure.
+ * It will select `smmOdV1` if the version is lower than `0x0203`, and `smmOdV2` otherwise.
+ *
+ * @param parameterStructVersion - The version of the parameter struct to use. Defaults to `0x0041`.
+ *                              If the version is less than `0x0203`, the `smmOdV1` format is used;
+ *                              otherwise, the `smmOdV2` format is used.
+ *
+ * @returns An array of strings representing the group names in the safety parameters.
+ */
+export declare function getSmmParametersGroupNames(parameterStructVersion?: number): string[];
+export declare const smmOdV1DefaultValues: any[];