motion-master-client 0.0.315 → 0.0.317

package/src/lib/motion-master-req-res-client.js

@@ -1693,7 +1693,7 @@ class MotionMasterReqResClient {
                         throw new Error('Device parameter values is empty');
                     }
                     const deviceParameters = deviceParameterValuesStatus.parameterValues.map((value, i) => {
-                        var _a, _b, _c;
+                        var _a, _b, _c, _d, _e;
                         const index = (_a = value.index) !== null && _a !== void 0 ? _a : 0;
                         const subindex = (_b = value.subindex) !== null && _b !== void 0 ? _b : 0;
                         const id = (0, device_parameter_1.makeDeviceParameterId)(device.id, index, subindex);
@@ -1703,7 +1703,13 @@ class MotionMasterReqResClient {
                         if (esi) {
                             esiExtension = (0, parameter_1.getParameterEsiExtension)(deviceParameter, esi === null || esi === void 0 ? void 0 : esi.value, productCode);
                         }
-                        return Object.assign(Object.assign({}, deviceParameter), esiExtension);
+                        const parameterId = (0, parameter_1.makeParameterId)(index, subindex);
+                        const plot = {
+                            axis: (_d = parameter_1.parameterIdToPlotAxis[parameterId]) !== null && _d !== void 0 ? _d : 'y2',
+                            color: (_e = parameter_1.parameterIdToPlotColor[parameterId]) !== null && _e !== void 0 ? _e : (0, util_1.createRandomColor)(100),
+                            visible: true,
+                        };
+                        return Object.assign(Object.assign(Object.assign({}, deviceParameter), esiExtension), { plot: plot });
                     });
                     const progress = sendProgress ? (_b = (_a = deviceParameterValuesStatus === null || deviceParameterValuesStatus === void 0 ? void 0 : deviceParameterValuesStatus.progress) === null || _a === void 0 ? void 0 : _a.percentage) !== null && _b !== void 0 ? _b : 0 : 100;
                     return { parameters: deviceParameters, progress };
@@ -3151,7 +3157,6 @@ class MotionMasterReqResClient {
         // Step 4: Transmit the update file chunk-by-chunk.
         const transmitSoftwareCommand = (0, os_command_1.createSmmAcyclicHandlerOsCommand)(os_command_1.SmmAcyclicHandlerSubcommandId.TRANSMIT_SOFTWARE);
         for (let i = 0; i < n; i++) {
-            console.log(`Transmitting chunk ${i + 1} of ${n}`);
             const start = i * chunkSize;
             const end = start + chunkSize;
             const fsBufferContent = buffer.slice(start, end);
@@ -3965,6 +3970,140 @@ class MotionMasterReqResClient {
             [deviceRef, 0x2023, 0x04, notchFilter.depth],
         ], requestTimeout);
     }
+    /**
+     * Deletes all HRD data files (`hr_data0.bin` to `hr_data4.bin`) from the device.
+     *
+     * The operation attempts to remove each file sequentially, regardless of whether
+     * it exists or not. Missing files do not cause the sequence to stop or fail.
+     *
+     * @param deviceRef - Reference to the target device.
+     * @returns An observable that completes once all delete operations have finished.
+     */
+    removeAllHrdFiles(deviceRef) {
+        const filenames = Array.from({ length: 5 }, (_, i) => `hr_data${i}.bin`);
+        // Attempt to delete all HRD files regardless of whether they exist
+        return (0, rxjs_1.from)(filenames).pipe((0, operators_1.concatMap)((filename) => this.deleteFile(deviceRef, filename)), (0, operators_1.toArray)(), (0, operators_1.map)(() => void 0));
+    }
+    /**
+     * Reads a sequence of HRD files (`hr_data0.bin` to `hr_data4.bin`) from a device,
+     * combines their contents into a single `Uint8Array`, and returns it as an Observable.
+     *
+     * Each file is read sequentially. If a file is missing or its content is `null`/`undefined`,
+     * it is treated as an empty `Uint8Array`, so the sequence continues without errors.
+     *
+     * @param deviceRef - Reference to the device from which the files are read.
+     * @returns An `Observable<Uint8Array>` that emits a single `Uint8Array` containing
+     *          the combined contents of all read files.
+     */
+    readAllHrdFiles(deviceRef) {
+        const readFileObservable = (filename) => (0, rxjs_1.from)(this.getFile(deviceRef, filename)).pipe((0, operators_1.map)((content) => {
+            if (content) {
+                return Array.isArray(content) ? new Uint8Array(content) : content;
+            }
+            else {
+                return new Uint8Array();
+            }
+        }));
+        const filenames = Array.from({ length: 5 }, (_, i) => `hr_data${i}.bin`);
+        return (0, rxjs_1.from)(filenames).pipe((0, operators_1.concatMap)((filename) => readFileObservable(filename)), (0, operators_1.toArray)(), (0, operators_1.map)((arrays) => {
+            const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+            const combined = new Uint8Array(totalLength);
+            let offset = 0;
+            for (const arr of arrays) {
+                combined.set(arr, offset);
+                offset += arr.length;
+            }
+            return combined;
+        }));
+    }
+    /**
+     * Runs HRD streaming on the device.
+     *
+     * The procedure performs the following steps:
+     * 1. Configures HRD streaming with the specified data index and duration.
+     * 2. Starts the streaming process.
+     * 3. Reads and combines all HRD files once streaming completes.
+     *
+     * @param deviceRef - Device to stream from.
+     * @param dataIndex - Index of the HRD streaming data (default is 0).
+     * @param duration - Streaming duration in milliseconds (default is 1000).
+     * @returns Observable that emits a combined `Uint8Array` containing all HRD file data.
+     */
+    runHrdStreaming(deviceRef, dataIndex = 0, duration = 1000) {
+        return (0, rxjs_1.concat)(
+        // Removing all HRD files upfront is unnecessary, as the firmware automatically handles this when configuring the stream.
+        // defer(() => this.removeAllHrdFiles(deviceRef)),
+        (0, rxjs_1.defer)(() => this.runHrdStreamingOsCommand(deviceRef, os_command_1.HrdStreamingOsCommandAction.CONFIGURE_STREAM, dataIndex, duration, 10000)), (0, rxjs_1.defer)(() => this.runHrdStreamingOsCommand(deviceRef, os_command_1.HrdStreamingOsCommandAction.START_STREAM, 0, 0, duration + 10000))).pipe((0, operators_1.last)(), (0, operators_1.mergeMap)(() => this.readAllHrdFiles(deviceRef)), (0, operators_1.map)((combinedData) => (0, os_command_1.parseHrdBuffer)(combinedData)));
+    }
+    /**
+     * Executes a chirp signal on the drive for system identification purposes.
+     *
+     * This method sends a sequence of system identification commands to the drive, configuring
+     * the necessary parameters and optionally starting HRD streaming if requested.
+     *
+     * Key points:
+     * - By executing the chirp signal on the drive, the firmware provides a very clean signal
+     *   to the motion controller without communication jitter.
+     * - The sine profile is used for system identification purposes.
+     * - This profile is not available as a standard Motion Profile type (0x6086).
+     *
+     * Requirements for the drive to correctly follow the trajectory:
+     * - The drive must have the correct commutation offset angle configured.
+     * - The encoder for the selected control method must be functional.
+     * - The controller must be tuned appropriately.
+     *
+     * Limitations:
+     * - The statusword cannot report the status of the profiler for this sine profile type.
+     *   It does not differentiate between different motion profile types.
+     * - If any parameter is out of range or the start frequency is greater than the target
+     *   frequency, the drive will report an "Invalid Parameter" error.
+     * - If the start and target frequencies are equal, the output wave frequency will be constant (static sine).
+     *
+     * Implementation notes:
+     * - The generated chirp signal is added to the control loop as an additional demanded torque,
+     *   just after the notch filter.
+     * - This allows system identification in CST, CSV, or CSP modes (or other profile modes).
+     *
+     * @param deviceRef - Reference to the target device.
+     * @param options - Configuration options for the chirp signal, including:
+     *   - `modesOfOperation` (optional): Modes of operation to configure before starting.
+     *   - `startFrequency`: Frequency at which the chirp begins.
+     *   - `targetFrequency`: Frequency at which the chirp ends.
+     *   - `targetAmplitude`: Amplitude of the chirp signal.
+     *   - `transitionTime`: Time for frequency/amplitude transition.
+     *   - `signalType`: Type of signal to generate.
+     *   - `startProcedure`: If set to `WAIT_FOR_HRD_STREAMING_TO_START`, the OS command for executing
+     *     the chirp signal will wait for HRD streaming to start before running the chirp.
+     *
+     * @returns An observable that completes after the chirp signal sequence is finished.
+     *          If `startProcedure` is set to `WAIT_FOR_HRD_STREAMING_TO_START`, HRD streaming
+     *          will also be executed.
+     */
+    runChirpSignal(deviceRef, options) {
+        const observables = [
+            options.modesOfOperation !== undefined
+                ? (0, rxjs_1.defer)(() => this.setModesOfOperation(deviceRef, options.modesOfOperation))
+                : rxjs_1.EMPTY,
+            (0, rxjs_1.defer)(() => this.transitionToCia402State(deviceRef, cia402_1.Cia402State.OPERATION_ENABLED)),
+            (0, rxjs_1.defer)(() => this.runSystemIdentificationOsCommand(deviceRef, 0, options.startFrequency, 10000)),
+            (0, rxjs_1.defer)(() => this.runSystemIdentificationOsCommand(deviceRef, 1, options.targetFrequency, 10000)),
+            (0, rxjs_1.defer)(() => this.runSystemIdentificationOsCommand(deviceRef, 2, options.targetAmplitude, 10000)),
+            (0, rxjs_1.defer)(() => this.runSystemIdentificationOsCommand(deviceRef, 3, options.transitionTime, 10000)),
+            (0, rxjs_1.defer)(() => this.runSystemIdentificationOsCommand(deviceRef, 4, options.signalType, 10000)),
+            // Rising edge to start the chirp signal
+            (0, rxjs_1.defer)(() => this.runSystemIdentificationOsCommand(deviceRef, 5, 0, 10000)),
+            (0, rxjs_1.defer)(() => this.runSystemIdentificationOsCommand(deviceRef, 5, options.startProcedure, 10000)),
+        ];
+        return (0, rxjs_1.concat)(...observables).pipe((0, operators_1.last)(), (0, operators_1.mergeMap)(() => {
+            if (options.startProcedure === os_command_1.SystemIdentificationOsCommandStartProcedure.WAIT_FOR_HRD_STREAMING_TO_START) {
+                // 6693 ms is the maximum duration for 5 files, each containing 8032 bytes
+                return this.runHrdStreaming(deviceRef, os_command_1.HrdStreamingOsCommandDataIndex.SYSTEM_IDENTIFICATION_DATA, 6693);
+            }
+            else {
+                return rxjs_1.EMPTY;
+            }
+        }));
+    }
 }
 exports.MotionMasterReqResClient = MotionMasterReqResClient;
 /**