motion-master-client 0.0.21 → 0.0.22

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

@@ -1,1680 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MotionMasterReqResClient = void 0;
-const tslib_1 = require("tslib");
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-const uuid_1 = require("uuid");
-const device_parameter_1 = require("./device-parameter");
-const hardware_description_1 = require("./hardware-description");
-const operators_2 = require("./operators");
-const parameter_1 = require("./parameter");
-const types_1 = require("./types");
-const util_1 = require("./util");
-const cia402_1 = require("./cia402");
-const cia402_2 = require("./cia402");
-const cia402_3 = require("./cia402");
-/**
- * This class contains methods for making requests to Motion Master using the injected request/response socket.
- *
- * Each request message defined in the proto file has a corresponding request method in this class.
- * For some requests like firmware installation, Motion Master will send progress messages until the firmware installation is done.
- *
- * Call to a request method will return an Observable of: (1) corresponding status message, for example call to `getDeviceInfo`
- * will return an instance of `MotionMasterMessage.Status.DeviceInfo`, (2) request status - one of "succeeded", "failed", or "running", and
- * (3) request message id.
- *
- * If the request fails on Motion Master the function will throw an error. It can also throw an error if the request times out.
- *
- * Request methods have optional `messageId` input parameter.
- * If `messageId` is not provided, one will be generated before sending the request message to Motion Master.
- * Status messages (responses) received from Motion Master that correspond to the previous request will have the same `messageId` as the one in the request.
- * This is how we match request with response messages in the full-duplex asynchronous communication (WebSockets, ZeroMQ).
- * Matching request/response by message id is inspired by [JSON-RPC 2.0 Specification](https://www.jsonrpc.org/specification).
- *
- * Almost all request methods have mandatory `requestTimeout` input parameter.
- * This parameter specifies how long (in milliseconds) will the client wait for the status (response) messages corresponding to the previous request.
- * If status message is not received in due time the request method will throw a timeout error.
- * The error doesn't mean the request has failed on Motion Master, but rather that client has given up waiting for the response(s).
- * It's possible to stop some on-going procedures on Motion Master with the corresponding stop messages, for example `StopFullAutoTuning`.
- *
- * @example
- * How to handle request method timeout error:
- * ```ts
- * req.getDeviceInfo(10).subscribe({
- *   next: (status) => console.log(status),
- *   error: (err: unknown) => {
- *     if (err instanceof TimeoutError) {
- *       alert('Request has timed out');
- *     }
- *   }
- * });
- * ```
- *
- * Request methods for a particular device, like `getDeviceParameterInfo`, as the first input parameter accept the type of request message as defined in the proto file.
- * For `getDeviceParameterInfo` that's `MotionMasterMessage.Request.IGetDeviceParameterInfo`. This type is extended (via type intersection) by `DeviceRefObj`.
- * This is done in order to support multiple ways to reference a device. Motion Master only supports device address which it re-generates for each device on power-cycle.
- * Because device address can change, for scripts and applications it's preferred to use a device reference that won't change.
- * Device serial number in the hardware description file uniquely identifies device and doesn't change. This is what each request message is extended with.
- * Before sending the request message to Motion Master, device address gets resolved and is set on the request message.
- * Beside device address and device serial number, devices can be referenced by position (sequence number in the network).
- *
- * It is ensured that Observable returned from a call to request method will eventually complete, so a call to unsubscribe is not required.
- * Observable will complete when request status is either "succeeded" or "failed", or it will complete (error) due to timeout.
- * Finding out if a request has completed, failed or is it still on-going is different for each request - it depends on the status messages, see {@link requestStatusResolver}.
- * Request methods handle this and for each request they will emit status messages with one of "succeeded", "failed", or "running" request status.
- *
- * Beside the request methods this class contains many helper methods such as the ones for getting and setting device parameter values and
- * saving all parameters which involves complex logic like multiple repeating requests in order to determine if saving all parameters has completed successfully.
- */
-class MotionMasterReqResClient {
-    constructor(socket) {
-        this.socket = socket;
-        /**
-         * Map device address to a map of parameter id to type value key.
-         *
-         * @example
-         * ```ts
-         * new Map([
-         *   [2045285448, new Map([
-         *     ["0x1018:02", "uintValue"]
-         *   ])]
-         * ]);
-         * ```
-         *
-         * When setting a parameter value only one of int, uint, float, string, or raw type value fields must be set.
-         * This is defined in the proto file SetDeviceParameterValues request message.
-         *
-         * Device parameters have richer set of base types defined in ESI and they're provided by DeviceParameterInfo status message.
-         * When device parameter info is fetched this map gets updated by mapping device parameters type to "oneof" proto type, e.g. `INTEGER32 -> intValue`.
-         *
-         * This map helps in simplifying the API by allowing users to set parameter values without specifying the type value field.
-         * One can simply call `setParameterValue(2045285448, 0x2004, 0x03, 2500)` and the correct type value field on the proto message will be set, `uintValue` in this example.
-         */
-        this.typeValueKeyMap = new Map();
-        /**
-         * Map device serial number to device address.
-         *
-         * @example
-         * ```ts
-         * new Map([
-         *   ["8502-03-0001353-2115", 2045285448]
-         * ]);
-         * ```
-         *
-         * When making requests related to a device, device address is used as an identifier.
-         * Device address is not permanent. The number is re-generated by Motion Master when devices are power-cycled.
-         * For scripts and applications that use this library, having a permanent device identifier is a better option.
-         * Device serial number read from the hardware description file (.hardware_description) stored on a device is a permanent identifier.
-         *
-         * This map helps in making all request methods related to a device accept device reference instead of just device address as an identifier.
-         * Device reference {@link DeviceRefObj} can be one of: device address, device serial number, or device position.
-         * Prior to sending a request message to Motion Master, device address is resolved from device reference and this map is used for that.
-         */
-        this.deviceMap = new Map();
-    }
-    //
-    // Requests
-    //
-    /**
-     * Ping system.
-     *
-     * The client must send messages to Motion Master in regular intervals in order for Motion Master to consider it alive.
-     * When the client is considered "not alive", Motion Master will stop the ongoing procedures and monitorings started by that client.
-     * Each client on the Motion Master side has its own default timeout which can be changed by {@link setSystemClientTimeout}.
-     */
-    pingSystem(messageId) {
-        const pingSystem = types_1.MotionMasterMessage.Request.PingSystem.create();
-        this.sendRequest({ pingSystem }, messageId);
-        return rxjs_1.EMPTY;
-    }
-    /**
-     * Get system version.
-     *
-     * Get the version of Motion Master. The version follows [Semantic Versioning 2.0.0](https://semver.org/).
-     */
-    getSystemVersion(requestTimeout, messageId) {
-        const getSystemVersion = types_1.MotionMasterMessage.Request.GetSystemVersion.create();
-        const id = this.sendRequest({ getSystemVersion }, messageId);
-        return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('systemVersion', requestTimeout, id));
-    }
-    /**
-     * Get device info.
-     *
-     * Device info includes a list of devices on the network. Each device has a type, position in the network, and device address.
-     * At the time of writing, the device alias is not yet supported.
-     *
-     * Motion Master will assign a unique device address to each device in the list.
-     * Device address is what the client libraries use to make requests like `getDeviceParameter` for a particular device.
-     * Device address is only valid for the duration of the session, that is, until Motion Master re-initializes the devices, for example
-     * when devices are power cycled or Motion Master process is restarted.
-     */
-    getDeviceInfo(requestTimeout, messageId) {
-        const getDeviceInfo = types_1.MotionMasterMessage.Request.GetDeviceInfo.create();
-        const id = this.sendRequest({ getDeviceInfo }, messageId);
-        return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceInfo', requestTimeout, id));
-    }
-    /**
-     * Get device parameter info.
-     *
-     * Device parameter info includes a list of all parameters for the requested device, but without the parameter values.
-     * Getting device parameter values can take more than 20ms per parameter using the IgH EtherCAT Master library.
-     * Not all clients require all the parameter values at once, like OBLAC Drives, so this method is good for getting
-     * the list of available parameters and then separately getting the values of some required parameters.
-     *
-     * The returned list of device parameters will include some basic data for each parameter: index, subindex,
-     * name, unit, group (ARRAY or RECORD name for subitems), read and write access, min and max, and value type.
-     * Min and max values are not yet fully supported - they contain the min/max values for the used base type.
-     * The same info and more can be read from the "SOMANET_CiA_402.xml" file, but getting info from ESI file is more complicated.
-     * It requires an XML parsing library and knowing how to read objects info from a dictionary and assigned modules.
-     *
-     * In addition to fetching device parameter info, this method will map parameter base data type (ETG.1020) to proto3 types.
-     * The map removes the need to specify proto3 type field when setting a parameter value {@link typeValueKeyMap}.
-     */
-    getDeviceParameterInfo(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const getDeviceParameterInfo = types_1.MotionMasterMessage.Request.GetDeviceParameterInfo.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ getDeviceParameterInfo }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceParameterInfo', requestTimeout, id));
-        }));
-    }
-    /**
-     * Get device parameter values.
-     *
-     * As already mentioned above, the fetching of parameter values can take 20ms and more, but it can also fail completely or timeout on the master side, which registers as a "cannot refresh value" error.
-     */
-    getDeviceParameterValues(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const getDeviceParameterValues = types_1.MotionMasterMessage.Request.GetDeviceParameterValues.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ getDeviceParameterValues }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceParameterValues', requestTimeout, id));
-        }));
-    }
-    /**
-     * Get multi device parameter values.
-     *
-     * Allows requesting parameter values from multiple devices at the same time.
-     */
-    getMultiDeviceParameterValues(props, requestTimeout, messageId) {
-        const getMultiDeviceParameterValues = types_1.MotionMasterMessage.Request.GetMultiDeviceParameterValues.create(props);
-        const id = this.sendRequest({ getMultiDeviceParameterValues }, messageId);
-        return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('multiDeviceParameterValues', requestTimeout, id));
-    }
-    /**
-     * Set device parameter values.
-     */
-    setDeviceParameterValues(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const setDeviceParameterValues = types_1.MotionMasterMessage.Request.SetDeviceParameterValues.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ setDeviceParameterValues }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceParameterValues', requestTimeout, id));
-        }));
-    }
-    /**
-     * Set multi device parameter values.
-     *
-     * Allows setting parameter values from multiple devices at the same time.
-     */
-    setMultiDeviceParameterValues(props, requestTimeout, messageId) {
-        const setMultiDeviceParameterValues = types_1.MotionMasterMessage.Request.SetMultiDeviceParameterValues.create(props);
-        const id = this.sendRequest({ setMultiDeviceParameterValues }, messageId);
-        return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('multiDeviceParameterValues', requestTimeout, id));
-    }
-    /**
-     * Get device file list.
-     *
-     * Motion Master will use Filetransfer over EtherCAT (FoE) to get the list of files from a device.
-     * There isn't an actual command for getting the list, but rather the content of a specially named file "fs-getlist" is the file list.
-     * The list can be read like any other file from a device using the IgH EtherCAT Master for Linux CLI program:
-     *
-     * ```
-     * $ ethercat foe_read fs-getlist
-     * ```
-     *
-     * At the time of writing this document "fs-getlist" can return a maximum of 32 files (subject to change) in the list. This is a firmware limitation.
-     * However, more than 32 files can be stored on device flash memory, but they won't appear in the list.
-     * Also note that FoE can behave differently in the bootstrap firmware which runs in the BOOT EtherCAT state and
-     * SOMANET firmware which runs in other EtherCAT states like PREOP/OP. Bootstrap tends to be buggier since it cannot be updated easily, so
-     * Motion Master has certain workarounds to overcome these FoE differences and bugs.
-     */
-    getDeviceFileList(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const getDeviceFileList = types_1.MotionMasterMessage.Request.GetDeviceFileList.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ getDeviceFileList }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceFileList', requestTimeout, id));
-        }));
-    }
-    /**
-     * Get device file.
-     *
-     * Motion Master uses the Filetransfer over EtherCAT (FoE) to read and send back the content of a file from the device flash memory.
-     *
-     * The IgH EtherCAT Master library used by Motion Master limits the file read buffer to 9KB, so any file written to flash that is larger than 9KB
-     * needs to be split into parts of max 9KB. Motion Master does this automatically on request to {@link setDeviceFile}.
-     *
-     * Upon receiving this request Motion Master will first read the list of files on a device, see {@link getDeviceFileList}.
-     * It does that in order to determine if the requested file, for example "SOMANET_CiA_402.xml", has been stored in multiple parts.
-     * The parts are named like "SOMANET_CiA_402.xml.zip.part000", "SOMANET_CiA_402.xml.zip.part001" and so on.
-     * Motion Master will read all parts of the requested file, unzip it and send the content back to a client.
-     * Since the number of items in the list of files is limited to 32 (based on the firmware version) Motion Master might not see the file,
-     * but in any case it will try to read the content of it.
-     * If the file exists it will return its content, otherwise it will return the file not found error.
-     *
-     * Zipped files will be automatically unzipped and their content returned, for example: stack_image.svg.zip can be stored
-     * in one or multiple files depending on the size. No matter how its stored it will be unzipped and its content returned as
-     * text (SVG) instead of zipped content (binary).
-     *
-     * In BOOT EtherCAT state it's only allowed to read the .hardware_description file. This was done because
-     * the bootloader firmware would hang when trying to read a corrupted or missing file.
-     *
-     * If the requested file content is empty, Motion Master will return a not found error. This is subject to change now that Motion Master reads the file error codes.
-     */
-    getDeviceFile(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const getDeviceFile = types_1.MotionMasterMessage.Request.GetDeviceFile.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ getDeviceFile }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceFile', requestTimeout, id));
-        }));
-    }
-    /**
-     * Set device file.
-     *
-     * Motion Master uses the Filetransfer over EtherCAT (FoE) to write files to the device flash memory.
-     *
-     * The IgH EtherCAT Master library used by Motion Master limits the file read buffer to 9KB, so any file written to flash that is larger than 9KB
-     * needs to be split into parts of max 9KB. Motion Master does this automatically by first zipping the content and then writing the parts.
-     * The parts are named in the following manner: "SOMANET_CiA_402.xml.zip.part000", "SOMANET_CiA_402.xml.zip.part001" and so on.
-     */
-    setDeviceFile(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const setDeviceFile = types_1.MotionMasterMessage.Request.SetDeviceFile.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ setDeviceFile }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceFile', requestTimeout, id));
-        }));
-    }
-    /**
-     * Delete device file.
-     *
-     * Motion Master uses the Filetransfer over EtherCAT (FoE) to delete files from the device flash memory.
-     *
-     * If the file to delete is written in parts, Motion Master will ensure that all parts are deleted.
-     * It does that by reading the list of files on a device, see {@link getDeviceFileList}, removing all parts from that list and then
-     * it re-reading the list again to ensure that there are no leftovers if there were more than 32 files in the list. If there are still
-     * more than 32 files in the list, Motion Master will blindly try to make sure there are no file parts left in the memory (may, or may not work).
-     */
-    deleteDeviceFile(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const deleteDeviceFile = types_1.MotionMasterMessage.Request.DeleteDeviceFile.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ deleteDeviceFile }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceFile', requestTimeout, id));
-        }));
-    }
-    /**
-     * Reset device fault.
-     *
-     * When an error occurs on a device, the device will go into Fault reaction active state (transition 13) and then automatically to Fault state (transition 14).
-     * The CiA402 state of a device can be derived from the value of Statusword object (0x6041:00).
-     * In order to go out of Fault and into Switch on disabled state (transition 15) master must send Fault reset command via Controlword object (0x6040:00).
-     *
-     * When this request is sent to Motion Master, it will try to reset the fault. Resetting the fault can succeed or fail.
-     * While resetting the fault, Motion Master will use the current Controlword value and set the Reset fault bit to 1,
-     * but when it completes (either success or error), it will set it back to 0.
-     *
-     * Motion Master will return "No Fault" warning when this request is sent and device is not in Fault or Fault reaction active state.
-     * If this request is sent when device is in Fault reaction active state, then Motion Master will
-     * wait for the automatic transition (14) to Fault state before trying to reset fault.
-     * When Motion Master sets the Controlword Fault bit to 1, it will also occasionally check if the device is no longer in Fault state.
-     * After a couple of seconds, if the device is still in Fault state, it will give up and return the timeout error.
-     */
-    resetDeviceFault(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const resetDeviceFault = types_1.MotionMasterMessage.Request.ResetDeviceFault.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ resetDeviceFault }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceFaultReset', requestTimeout, id));
-        }));
-    }
-    /**
-     * Stop device.
-     *
-     * Motion Master will use the current value of the Controlword object and set the command on it to Quick stop.
-     * It will then wait for up to 2 seconds for a device to get into one of the following CiA402 states: Switch on disabled, Operation enabled, Fault.
-     * It does that by periodically checking the value of the Statusword object. If the device doesn't go into one of those states,
-     * Motion Master will return a timeout or a quick stop failed error.
-     */
-    stopDevice(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const stopDevice = types_1.MotionMasterMessage.Request.StopDevice.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ stopDevice }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceStop', requestTimeout, id));
-        }));
-    }
-    /**
-     * Start device firmware installation.
-     *
-     * When Motion Master receives this request for a device, it will do the following:
-     * - switch the device to the BOOT EtherCAT state - the device will then run the bootloader instead of the firmware
-     * - validate the firmware package
-     * - delete files the files found in the package from the device flash memory (SOMANET_CiA_402.xml and stack_image.svg)
-     * - write files other than the firmware binaries and SII from package to the device (SOMANET_CiA_402.xml and stack_image.svg)
-     * - (optional) install the SII file using the IgH EtherCAT Master library write SII function
-     * - write the firmware binaries to the device using predefined names like app_firmware.bin and com_firmware.bin
-     *
-     * During the firmware installation, Motion Master will send progress messages back to clients.
-     * If Motion Master fails in any step other than SII write, it will send an error. If SII write fails, only a warning will be sent.
-     */
-    startDeviceFirmwareInstallation(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const startDeviceFirmwareInstallation = types_1.MotionMasterMessage.Request.StartDeviceFirmwareInstallation.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ startDeviceFirmwareInstallation }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceFirmwareInstallation', requestTimeout, id));
-        }));
-    }
-    /**
-     * Get device log.
-     *
-     * The device log is stored in two files due to IgH EtherCAT Master library 9KB file size limitation, see {@link getDeviceFile}.
-     * A device automatically writes the log to logging_curr.log and copies that file to logging_prev.log once it reaches 9KB.
-     * When Motion Master receives this request, it will read both of these files and return their combined contents.
-     */
-    getDeviceLog(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const getDeviceLog = types_1.MotionMasterMessage.Request.GetDeviceLog.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ getDeviceLog }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceLog', requestTimeout, id));
-        }));
-    }
-    /**
-     * Start cogging torque recording.
-     *
-     * Cogging torque compensation (CTC) recording can be started with or without auto-config.
-     * In the proto file skipping the auto-config is currently named skip_auto_tuning. The field name is deprecated and will be renamed.
-     *
-     * If CTC recording is started without auto-config, the users must ensure that the encoder on the motor shaft is used for all functions: commutation, position, and velocity.
-     * If this is not the case, then Motion Master will return an invalid encoder configuration error.
-     * Recording can also fail if the position controller is not tuned.
-     *
-     * If CTC recording is started with auto-config then Motion Master will:
-     * - change the encoder configuration to have all encoder functions on the motor shaft
-     * - disable CTC
-     * - change the velocity feed forward value
-     * - change the position and velocity filter types and cutoff frequencies
-     * - run iterative sharpening position controller auto-tuning in order to compute the optimal PID values (gains) for CTC recording
-     *
-     * All parameter values that Motion Master changes as part of the auto-config are first stored in memory and once the CTC recording is done are reverted back.
-     *
-     * CTC recording is started by changing the Modes of operation (0x6060) parameter value to -1 (Cogging compensation recording mode).
-     * During the operation Motion Master will monitor the Cogging torque compensation state parameter (0x2008:01) to know when the recording is in progress and when it's done.
-     *
-     * The result of CTC recording is the cogging_torque.bin file written to device flash memory. The size of this file is 2048 bytes.
-     * Each pair of bytes represents a 16-bit signed integer value in mNm (millinewton meter).
-     *
-     * This request will turn the motor.
-     */
-    startCoggingTorqueRecording(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const startCoggingTorqueRecording = types_1.MotionMasterMessage.Request.StartCoggingTorqueRecording.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ startCoggingTorqueRecording }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('coggingTorqueRecording', requestTimeout, id));
-        }));
-    }
-    /**
-     * Get cogging torque data.
-     *
-     * The cogging_torque.bin file is the result of cogging torque compensation recording, see {@link startCoggingTorqueRecording}.
-     * The size of this file is 2048 bytes where each pair of bytes represents a 16-bit signed integer value in mNm (millinewton meter).
-     *
-     * Motion Master will read the cogging_torque.bin file, convert bytes to 16-bit signed integer values and return that as an array of values.
-     */
-    getCoggingTorqueData(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const getCoggingTorqueData = types_1.MotionMasterMessage.Request.GetCoggingTorqueData.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ getCoggingTorqueData }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('coggingTorqueData', requestTimeout, id));
-        }));
-    }
-    /**
-     * Start offset detection.
-     *
-     * Running offset detection is different for firmwares <v5 and >=v5.
-     *
-     * For devices that run firmware >=v5, Motion Master will run multiple OS commands.
-     * Before starting any command, device is switched to Modes of operation -2 (Diagnostics mode) and
-     * it's put into operation enabled CiA402 state. The OS commands are then run in the following order:
-     * - open phase detection
-     * - phase resistance measurement
-     * - phase inductance measurement
-     * - pole pair detection
-     * - motor phase order detection
-     * - commutation offset measurement
-     *
-     * Motion Master will return an error if any of the following OS commands fail: open phase detection,
-     * phase order detection, commutation offset measurement.
-     * If other OS commands fail, Motion Master will continue with the procedure and only return a warning.
-     *
-     * Once the commutation offset measurement command completes, it will update the following parameter values:
-     * - 0x2001:00 Commutation angle offset to the computed offset value
-     * - 0x2009:01 Commutation offset State to 2 (OFFSET_VALID)
-     *
-     * For devices that run firmware <5 the same Modes of operation -2 is used, but it's named Commutation offset detection mode
-     * and it will run as a single procedure as soon as the device is switched to CiA402 operation enabled state.
-     * The end result is the same, the procedure will update 0x2001:00 and 0x2009:01 parameter values.
-     *
-     * This request will turn the motor.
-     */
-    startOffsetDetection(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const startOffsetDetection = types_1.MotionMasterMessage.Request.StartOffsetDetection.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ startOffsetDetection }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('offsetDetection', requestTimeout, id));
-        }));
-    }
-    /**
-     * @deprecated use {@link startSystemIdentification} instead
-     */
-    startPlantIdentification(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const startPlantIdentification = types_1.MotionMasterMessage.Request.StartPlantIdentification.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ startPlantIdentification }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('plantIdentification', requestTimeout, id));
-        }));
-    }
-    /**
-     * Compute auto tuning gains.
-     *
-     * Auto tuning gains can be computed for the position or the velocity controller.
-     *
-     * The prerequisites for running this procedure are a configured motor and the existence of
-     * plant_model.csv file created by previously running the system identification {@link startSystemIdentification}.
-     * Motion Master will return error if the plant_model.csv file is not found.
-     *
-     * In OBLAC Drives, this request is called when the tuning sliders (damping ratio, bandwidth) are moved and
-     * during the CTC recording {@link startCoggingTorqueRecording} when auto-config is not skipped.
-     *
-     * Motion Master will compute the PID gains using a proprietary algorithm and update the Kp, Ki, Kd values of the 0x2011 and 0x2012 parameters.
-     */
-    computeAutoTuningGains(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const computeAutoTuningGains = types_1.MotionMasterMessage.Request.ComputeAutoTuningGains.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ computeAutoTuningGains }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('autoTuning', requestTimeout, id));
-        }));
-    }
-    /**
-     * Set motion controller parameters.
-     *
-     * This request sets the target value for a device on Motion Master.
-     *
-     * A previous call to {@link enableMotionController} will set the mode of operation to CSP, CSV, or CST and optionally enable filtering.
-     */
-    setMotionControllerParameters(props, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const setMotionControllerParameters = types_1.MotionMasterMessage.Request.SetMotionControllerParameters.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            this.sendRequest({ setMotionControllerParameters }, messageId);
-            return rxjs_1.EMPTY;
-        }));
-    }
-    /**
-     * Enable motion controller.
-     *
-     * This request will set the mode of operation to CSP, CSV, or CST and optionally enable filtering.
-     *
-     * If filtering is enabled Motion Master will compute an intermediate target value in each cycle and, depending on the active mode of operation,
-     * set the value of one of 0x607A Target position, 0x60FF Target velocity, 0x6071 Target torque to that value.
-     *
-     * The target value can be updated with {@link setMotionControllerParameters}.
-     */
-    enableMotionController(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const enableMotionController = types_1.MotionMasterMessage.Request.EnableMotionController.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ enableMotionController }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('motionController', requestTimeout, id));
-        }));
-    }
-    /**
-     * Disable motion controller.
-     *
-     * Depending on the current CiA402 state this request will do the following:
-     * - if device is in Quick stop active it will transition to Switch on disabled state
-     * - if device is in Operation enabled it will transition to Switched on state
-     */
-    disableMotionController(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const disableMotionController = types_1.MotionMasterMessage.Request.DisableMotionController.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ disableMotionController }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('motionController', requestTimeout, id));
-        }));
-    }
-    /**
-     * Set signal generator parameters.
-     *
-     * This request will update the signal generator parameter values for a device on Motion Master.
-     * The selected signal generator is then started by {@link startSignalGenerator}.
-     * Signal generator must be started within the next 60 seconds before Motion Master invalidates the previously set parameters.
-     */
-    setSignalGeneratorParameters(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const setSignalGeneratorParameters = types_1.MotionMasterMessage.Request.SetSignalGeneratorParameters.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ setSignalGeneratorParameters }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('signalGenerator', requestTimeout, id));
-        }));
-    }
-    /**
-     * Start signal generator.
-     *
-     * This request will start one of the signal generators based on the
-     * previously set parameters with {@link setSignalGeneratorParameters}.
-     *
-     * Signal generators are started by changing the mode of operation, putting the device into Operation enabled CiA402 state,
-     * and setting the target value. What mode of operation is set depends on the type of signal generator and the selected controller:
-     * - For the simple & advanced step response and the sine wave, one of CSP, CSV, or CST is set.
-     * - For the ramp, trapezoidal, and bidirectional signal generators, also called profiles, one of the PP, PV, TQ is set.
-     *
-     * Currently, the only profile type that the firmware supports is the ramp profile.
-     * Motion Master uses this profile type to construct and run the following signals: ramp, trapezoidal, and bidirectional.
-     * Sine wave is also a profile, but it is currently being generated on Motion Master alone.
-     * Firmwares >=5.2 will support generating and running sine wave profiles on devices themselves. This will enable lossless profile
-     * execution on possibly higher frequencies. Future Motion Master versions will switch to this method.
-     *
-     * For the simple step response, Motion Master will only set the target value,
-     * wait for the specified holding duration, and then send a Quick Stop command.
-     *
-     * The advanced step response is similar to the simple one, but, after the holding duration, it will set the new target
-     * multiple times depending on the shape, and then send a Quick Stop if the repeat option is set to NO. If repeat is set to YES,
-     * then the signal generator will run indefinitely and the users must stop it manually.
-     *
-     * Before running a profile, Motion Master will check if device supports the profile modes by looking at 0x6502 Supported drives modes.
-     * If profile modes are not supported, then the profiles will be generated on Motion Master. This means the targets will be computed up-front.
-     * If profiles are supported, then ramp, trapezoidal, and bidirectional signal generators are run in profile mode of operation.
-     * To prepare the signal generator foe execution, Motion Master will set the following parameters:
-     * - 0x6081:00 Profile velocity (only for position controller)
-     * - 0x6083:00 Profile acceleration
-     * - 0x6084:00 Profile deceleration
-     * Motion Master knows when the profile has completed by comparing the demand with the actual value, taking into account the
-     * holding duration and the shape of the profile. Once the profile is considered complete, Motion Master will send a Quick Stop, but
-     * only if repeat is set to NO.
-     *
-     * The sine wave profile is generated up-front on Motion Master. Targets are computed for each master cycle (millisecond).
-     * Once the last computed target has been set, Motion Master will send a Quick Stop if repeat is set to NO.
-     *
-     * For all signal generators, Motion Master will check the requested target against the currently set software position limits
-     * and, if necessary, alter it whilst returning a warning.
-     *
-     * This request will turn the motor.
-     */
-    startSignalGenerator(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const startSignalGenerator = types_1.MotionMasterMessage.Request.StartSignalGenerator.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ startSignalGenerator }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('signalGenerator', requestTimeout, id));
-        }));
-    }
-    /**
-     * Stop signal generator.
-     *
-     * This request will send a Quick Stop to the device.
-     */
-    stopSignalGenerator(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const stopSignalGenerator = types_1.MotionMasterMessage.Request.StopSignalGenerator.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ stopSignalGenerator }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('signalGenerator', requestTimeout, id));
-        }));
-    }
-    /**
-     * Start monitoring device parameter values.
-     *
-     * When monitoring is started, Motion Master will begin and continue reading values from the device
-     * and send them back to a client in the specified interval on the given topic.
-     *
-     * The request is made through the req/res socket {@link MotionMasterReqResSocket},
-     * but the status messages will arrive on the pub/sub socket {@link MotionMasterPubSubSocket}.
-     *
-     * The same monitoring can read both PDO and SDO values. PDO values will be updated on every Motion Master cycle (1ms).
-     * How fast will SDO values update depends on the number of SDOs being monitored. Motion Master reads the SDO values in a sequence
-     * so, for example, if there are 10 SDOs and it takes 20ms to read a single SDO it will take approximately 200ms for each SDO to get updated.
-     * IgH EtherCAT Master supports non-blocking SDO reading with a request to read and check the state of the request (one of not used, busy, failed, succeeded).
-     * Future version of Motion Master will likely leverage this and update SDO values out of order as each of the requests to update SDO succeeds.
-     * This should decrease the time it takes to read multiple SDOs.
-     * If a parameter is required to be updated more frequently, it should be mapped as a PDO.
-     *
-     * Firmware versions >=5.2 supports SDO complete access, but it is currently not being supported in Motion Master.
-     * With SDO complete access RECORD and ARRAY subitems can be read with a single request.
-     *
-     * Interval is given in microseconds.
-     *
-     * The topic should be unique. The previous monitoring will stop if the given topic is reused.
-     * Clients can easily stop one another's monitoring by using the same topic.
-     * Prefixing topics with the client id or some other unique identifier is suggested.
-     *
-     * When the monitoring request is received, Motion Master will mark all requested parameters as stale.
-     * The first time a parameter gets refreshed from a device, it'll be marked as not stale.
-     * Motion Master won't start publishing parameter values until all parameters are marked as not stale.
-     * This was done in order to satisfy the firmware test client applications.
-     *
-     * Stopping the ongoing monitoring is done through the req/res socket using
-     * the request message ID of the initial start monitoring message {@link stopMonitoringDeviceParameterValues}.
-     */
-    startMonitoringDeviceParameterValues(props, requestTimeout, messageId) {
-        const startMonitoringDeviceParameterValues = types_1.MotionMasterMessage.Request.StartMonitoringDeviceParameterValues.create(props);
-        const id = this.sendRequest({ startMonitoringDeviceParameterValues }, messageId);
-        return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('monitoringParameterValues', requestTimeout, id));
-    }
-    /**
-     * Stop monitoring device parameter values.
-     *
-     * Message ID used for {@link startMonitoringDeviceParameterValues} uniquely identifies a monitoring and is used for stopping it.
-     */
-    stopMonitoringDeviceParameterValues(props, messageId) {
-        const stopMonitoringDeviceParameterValues = types_1.MotionMasterMessage.Request.StopMonitoringDeviceParameterValues.create(props);
-        this.sendRequest({ stopMonitoringDeviceParameterValues }, messageId);
-        return rxjs_1.EMPTY;
-    }
-    /**
-     * Get the EtherCAT network state.
-     *
-     * Returns one of the EtherCAT network states: BOOT, INIT, PRE-OP, SAFE-OP, OP.
-     * The state is returned as an enum value: INIT: 1, PREOP: 2, BOOT: 3, SAFEOP: 4, OP: 5.
-     */
-    getEthercatNetworkState(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const getEthercatNetworkState = types_1.MotionMasterMessage.Request.GetEthercatNetworkState.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ getEthercatNetworkState }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('ethercatNetworkState', requestTimeout, id));
-        }));
-    }
-    /**
-     * Set the EtherCAT network state.
-     *
-     * Set the EtherCAT network state to one of: BOOT, INIT, PRE-OP, SAFE-OP, OP.
-     * The state is set by an enum value: INIT: 1, PREOP: 2, BOOT: 3, SAFEOP: 4, OP: 5.
-     *
-     * When switching from PRE-OP to OP, MM will reinitialize slaves in order to update the PDO mapping.
-     */
-    setEthercatNetworkState(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const setEthercatNetworkState = types_1.MotionMasterMessage.Request.SetEthercatNetworkState.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ setEthercatNetworkState }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('ethercatNetworkState', requestTimeout, id));
-        }));
-    }
-    /**
-     * @deprecated use {@link startCirculoEncoderNarrowAngleCalibrationProcedure} instead
-     */
-    startNarrowAngleCalibration(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const startNarrowAngleCalibration = types_1.MotionMasterMessage.Request.StartNarrowAngleCalibration.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ startNarrowAngleCalibration }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('narrowAngleCalibration', requestTimeout, id));
-        }));
-    }
-    /**
-     * Set system client timeout.
-     *
-     * This request will update the client timeout.
-     *
-     * Client timeout specifies how long Motion Master will wait for the client to send a ping or any other message before
-     * considering it gone and clearing the resources (stopping procedures and monitorings) related to that client.
-     *
-     * Default client timeout is 1000ms.
-     *
-     * Client will typically change this once the socket connection is established.
-     */
-    setSystemClientTimeout(props, messageId) {
-        const setSystemClientTimeout = types_1.MotionMasterMessage.Request.SetSystemClientTimeout.create(props);
-        this.sendRequest({ setSystemClientTimeout }, messageId);
-        return rxjs_1.EMPTY;
-    }
-    /**
-     * Start system identification.
-     *
-     * This request will run the system identification procedure which identifies the plant model.
-     *
-     * Pre-conditions: a configured motor and configured encoders.
-     *
-     * The chirp signal that the procedure does only uses the torque controller.
-     * The chirp signal is generated on Motion Master and then, on every master cycle (1ms), the target torque value is set on a device.
-     * Motion Master will send a Quick Stop to a device after the last target value is set.
-     *
-     * The request can fail for multiple reasons: device is in the fault state, cannot set the op mode state,
-     * or the system identification fails because not enough data points have been collected.
-     * While running the chirp signal, the data points are collected, but due to potential communication lag it can happen
-     * that master doesn't collect enough data points. If more than 80% of data points are missing, the procedure will fail.
-     * If between 20%-80% of data points are missing, only a warning will be returned.
-     *
-     * Before computing the plant model data based on the collected data points, Motion Master will interpolate the missing data points.
-     * Plant model data is then computed and written to plant_model.csv file on the device flash memory.
-     * The plant model file is later used to compute the PID values using {@link computeAutoTuningGains} and {@link startFullAutoTuning}.
-     * It's also used indirectly in {@link startCoggingTorqueRecording} when auto-config is turned on.
-     * Motion Master will also update the integral limit values in 0x2011: Velocity controller and 0x2012: Position controller during this procedure.
-     *
-     * In future versions of firmware, the chirp signal would be executed on the devices themselves, so no data points will be missing
-     * and the system identification will be able to run at higher frequencies and with higher precision.
-     *
-     * This request will turn the motor.
-     */
-    startSystemIdentification(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const startSystemIdentification = types_1.MotionMasterMessage.Request.StartSystemIdentification.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ startSystemIdentification }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('systemIdentification', requestTimeout, id));
-        }));
-    }
-    /**
-     * Get Circulo encoder magnet distance.
-     *
-     * This feature is only available for firmwares >=v5. For older firmwares, Motion Master will return an error.
-     *
-     * Motion Master will read registers 0x2B and 0x2F on the specified encoder (by encoder ordinal) and then it will compute the magnet distance.
-     * The computation depends on the Circulo type, encoder port and ring revision.
-     */
-    getCirculoEncoderMagnetDistance(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const getCirculoEncoderMagnetDistance = types_1.MotionMasterMessage.Request.GetCirculoEncoderMagnetDistance.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ getCirculoEncoderMagnetDistance }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('circuloEncoderMagnetDistance', requestTimeout, id));
-        }));
-    }
-    /**
-     * Start the Circulo encoder narrow angle calibration procedure.
-     *
-     * This feature is only available on firmwares >=v5.
-     *
-     * Before starting the procedure, Motion Master will check and return an error if:
-     * - the firmware version is not >=v5
-     * - software position limits are set so that the required motor rotation is not possible
-     * - for SMM devices, the encoder source type is not set to None
-     * - the velocity resolution determined by the gear ratio, SI unit velocity and feed constant is not high enough
-     *
-     * Before starting the procedure, Motion Master will do the following:
-     * - send OS command 14 (Ignore BiSS status bits) so that no firmware warnings or errors are raised during the procedure.
-     * - set certain encoder registers to their default values.
-     * - set the BiSS encoder to raw mode.
-     * - change the values of some device parameters: profile acceleration, deceleration, max motor speed, etc.
-     *
-     * The parameter values Motion Master sets depend on the type of the device (fetched from the hardware description file).
-     * Once the operation has completed, Motion Master will rollback all of the above parameters to their initial values.
-     *
-     * Procedure:
-     * - The procedure is run in velocity profile mode of operation.
-     * - The procedure will do multiple iterations until the encoder data is satisfactory.
-     * - The procedure can fail for various reasons: data out of range, motor too slow, bad data, internal error, etc.
-     * - The procedure will run a maximum of 13 calibration iterations, up to 2 mins in total.
-     * - One iteration turns the motor in one direction and then the next one reverses the direction.
-     * - Each iteration will record encoder data into HRD files (4kHz) that contain the raw data from the specified encoder.
-     * - Motion Master will remove previous high resolution data (HRD) files after each iteration. HRD streaming is configured/started using OS commands.
-     * - After each iteration, which lasts ~6 seconds, the recorded data in HRD files is read and passed to the iC House library.
-     * - The recorded data is sliced into 32-bit pair of values of master and nonius track data. Motion Master creates two arrays out of this data and
-     * passes that to the iC House library which computes the new calibration parameters depending on encoder type sine and cosine offset, gain, etc.
-     * - The iterations are being repeated until the encoder (raw) data satisfies a certain threshold.
-     *
-     * The result of a successful calibration is setting multiple parameters into registers of the specified encoder.
-     *
-     * At the end of the procedure Motion Master will rotate the motor back to the starting position and run commutation offset detection.
-     * There will also be a final iteration which only measures the values of a (now) calibrated encoder for display.
-     *
-     * This request will turn the motor.
-     *
-     * @todo improve documentation
-     */
-    startCirculoEncoderNarrowAngleCalibrationProcedure(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const startCirculoEncoderNarrowAngleCalibrationProcedure = types_1.MotionMasterMessage.Request.StartCirculoEncoderNarrowAngleCalibrationProcedure.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ startCirculoEncoderNarrowAngleCalibrationProcedure }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('circuloEncoderNarrowAngleCalibrationProcedure', requestTimeout, id));
-        }));
-    }
-    /**
-     * Get device cia402 state.
-     */
-    getDeviceCia402State(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const getDeviceCia402State = types_1.MotionMasterMessage.Request.GetDeviceCiA402State.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ getDeviceCia402State }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceCia402State', requestTimeout, id));
-        }));
-    }
-    /**
-     * Set device cia402 state.
-     */
-    setDeviceCia402State(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const setDeviceCia402State = types_1.MotionMasterMessage.Request.SetDeviceCiA402State.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ setDeviceCia402State }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceCia402State', requestTimeout, id));
-        }));
-    }
-    /**
-     * Get system log.
-     *
-     * The system log represents the collected standard output from Motion Master process.
-     *
-     * This request will return the whole system log which can be max ~2MB.
-     *
-     * The log level can be set as an environmental variable when the Motion Master process is started.
-     * The log level can be selected in the OBLAC Drives Update Service expert mode before installing a release.
-     * The supported log levels are:
-     * - 6: Request content
-     * - 5: Request type
-     * - 4: Parameter value
-     * - 3: Monitoring
-     * - 2: Verbose 2
-     * - 1: Verbose 1
-     * - 0: Info
-     * - 1: Warnings
-     * - 2: Errors
-     * - 3: Fatal errors
-     */
-    getSystemLog(requestTimeout, messageId) {
-        const getSystemLog = types_1.MotionMasterMessage.Request.GetSystemVersion.create();
-        const id = this.sendRequest({ getSystemLog }, messageId);
-        return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('systemLog', requestTimeout, id));
-    }
-    /**
-     * Start device SII restore.
-     *
-     * This request uses the EEPROM tool from SOEM to overwrite the SII portion of EEPROM on a device.
-     *
-     * Motion Master will verify the provided SII file before writing it to EEPROM. It will:
-     * - check the file content length,
-     * - compute CRC from a part of the SII file content and compare it to the CRC inside the file,
-     * - check the SII category types in the category header.
-     *
-     * Unlike IgH EtherCAT Master which identifies interfaces by MAC address, the SOEM tool requires an adapter name.
-     * Before calling SOEM tool Motion Master will find the adapter name by looking into /sys/class/net.
-     *
-     * The SOEM tool binary is being delivered as a part of the Motion Master Docker image.
-     */
-    startDeviceSiiRestore(props, requestTimeout, messageId) {
-        const startDeviceSiiRestore = types_1.MotionMasterMessage.Request.StartDeviceSiiRestore.create(props);
-        const id = this.sendRequest({ startDeviceSiiRestore }, messageId);
-        return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('deviceSiiRestore', requestTimeout, id));
-    }
-    /**
-     * Start open loop field control.
-     *
-     * The precondition for running the open loop field control is to have a configured motor.
-     * No encoder configuration or offset detection is required.
-     *
-     * Open loop field control is started by changing the Modes of operation (0x6060) parameter value to -3 (Open loop field mode) and
-     * setting the CiA402 state to Ready to switch on.
-     * After that, Motion Master will run several OS commands that configure the open loop field control parameters:
-     * - start angle [milliradian]
-     * - end angle [milliradian]
-     * - max rotational speed [radian/s]
-     * - rotational acceleration [radian/s^2]
-     * - start length [permille of rated torque]
-     * - end length [permille of rated torque]
-     * - length speed [permille of rated torque]
-     *
-     * After the configuration Motion Master will switch device to Operation enabled CiA402 state and the profile will start.
-     *
-     * While the open loop field control is running Motion Master will monitor the target reached bit in the statusword.
-     * When the target reached bit becomes 1, Motion Master will stop the procedure by changing the CiA402 state to Switched on.
-     *
-     * Motion Master will return an error if the device goes out of Operation enabled state before target reached bit becomes 1.
-     * There is no timeout on the Motion Master side.
-     *
-     * This request will turn the motor.
-     */
-    startOpenLoopFieldControl(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const startOpenLoopFieldControl = types_1.MotionMasterMessage.Request.StartOpenLoopFieldControl.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ startOpenLoopFieldControl }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('openLoopFieldControl', requestTimeout, id));
-        }));
-    }
-    /**
-     * @deprecated use {@link startFullAutoTuning} instead
-     */
-    computeFullAutoTuningGains(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const computeFullAutoTuningGains = types_1.MotionMasterMessage.Request.ComputeFullAutoTuningGains.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ computeFullAutoTuningGains }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('fullAutoTuning', requestTimeout, id));
-        }));
-    }
-    /**
-     * Start full auto tuning.
-     *
-     * The preconditions for running the full auto tuning are properly configured motor, brake and encoders,
-     * and to have executed the offset detection and the system identification procedures.
-     *
-     * In order to successfully run the full auto tuning procedure, the motor must not rotate and the device must not be in CiA402 Operation enabled.
-     *
-     * Motion Master will try to read the plant_model.csv file and if doesn't exist it will return an error.
-     *
-     * Before the operation starts, Motion Master will measure the actual velocity for 500ms at a standstill in order to determine the encoder noise.
-     * The noise is then sent, along with some other parameters (velocity feedback filter, feed forward, dc link voltage, firmware version and similar)
-     * and data to a proprietary computation algorithm.
-     * ADC current ratio which is used in the computation script is determined by the firmware version and the device hardware) ID (e.g. 9500, 9501, 8501...).
-     *
-     * Full auto tuning will compute the PID gains and Motion Master will update the parameter values in the velocity or position controller depending on the request.
-     *
-     * Motion Master will return the damping ratio, settling time, and bandwidth values when the procedure completes. UI will use these values to update the sliders in the Tuning screen.
-     *
-     * This procedure can be stopped with {@link stopFullAutoTuning}.
-     */
-    startFullAutoTuning(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const startFullAutoTuning = types_1.MotionMasterMessage.Request.StartFullAutoTuning.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ startFullAutoTuning }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('fullAutoTuning', requestTimeout, id));
-        }));
-    }
-    /**
-     * Stop full auto tuning.
-     *
-     * Motion Master has only one exit point for this procedure, which is after the computation algorithm ends.
-     * This means that, once stopped, the procedure will compute the gains, but Motion Master will not update the controller parameters.
-     * Previously started full auto tuning request will complete with an aborted error.
-     */
-    stopFullAutoTuning(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const stopFullAutoTuning = types_1.MotionMasterMessage.Request.StopFullAutoTuning.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ stopFullAutoTuning }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('fullAutoTuning', requestTimeout, id), (0, operators_1.map)((status) => {
-                var _a, _b;
-                if (((_a = status.success) === null || _a === void 0 ? void 0 : _a.code) === types_1.MotionMasterMessage.Status.FullAutoTuning.Success.Code.POSITION_STOPPED ||
-                    ((_b = status.success) === null || _b === void 0 ? void 0 : _b.code) === types_1.MotionMasterMessage.Status.FullAutoTuning.Success.Code.VELOCITY_STOPPED) {
-                    // Full auto tuning status is shared between start and stop.
-                    // When full auto tuning has stopped this request is considered successful.
-                    status.request = 'succeeded';
-                }
-                return status;
-            }));
-        }));
-    }
-    /**
-     * Start Circulo encoder configuration.
-     *
-     * The preconditions for this procedure are to have Circulo device with internal encoders and a firmware >=v5.
-     *
-     * This procedure will set various internal encoder registers based on the hardware description, Circulo device type and the encoder ordinal.
-     *
-     * Before updating the registers, Motion Master will send an OS command to ignore the BiSS status bits. Once the procedure is done the value of this register will be reverted.
-     *
-     * Depending on the setup, this procedure can take up to 30 seconds.
-     *
-     * This procedure can fail if it's already running, if it's not supported because of the firmware version, or if the hardware description file is missing.
-     *
-     * While this procedure runs, Motion Master will return its progress.
-     */
-    startCirculoEncoderConfiguration(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const startCirculoEncoderConfiguration = types_1.MotionMasterMessage.Request.StartCirculoEncoderConfiguration.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ startCirculoEncoderConfiguration }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('circuloEncoderConfiguration', requestTimeout, id));
-        }));
-    }
-    /**
-     * @deprecated use {@link stopDevice} instead
-     */
-    stopCirculoEncoderNarrowAngleCalibrationProcedure(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const stopCirculoEncoderNarrowAngleCalibrationProcedure = types_1.MotionMasterMessage.Request.StopCirculoEncoderNarrowAngleCalibrationProcedure.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ stopCirculoEncoderNarrowAngleCalibrationProcedure }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('circuloEncoderNarrowAngleCalibrationProcedure', requestTimeout, id));
-        }));
-    }
-    /**
-     * Start OS command.
-     *
-     * This request will execute an OS command and return a result as a bytearray.
-     *
-     * Motion Master will check if an OS command is already running and use a mutex to ensure only one OS command runs at a time.
-     *
-     * This request can fail if the requested OS command is not supported.
-     *
-     * Motion Master will check if the OS command has failed and return an error.
-     *
-     * The OS command can timeout if it takes longer than the provided timeout in milliseconds, in which case Motion Master will return an error.
-     */
-    startOsCommand(props, requestTimeout, messageId) {
-        return this.resolveDeviceAddress(props).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const startOsCommand = types_1.MotionMasterMessage.Request.StartOsCommand.create(Object.assign(Object.assign({}, props), { deviceAddress }));
-            const id = this.sendRequest({ startOsCommand }, messageId);
-            return this.socket.message$.pipe((0, operators_2.transformMotionMasterMessageToStatus)('osCommand', requestTimeout, id));
-        }));
-    }
-    sendRequest(request, messageId) {
-        const id = messageId !== null && messageId !== void 0 ? messageId : (0, uuid_1.v4)();
-        const message = types_1.MotionMasterMessage.create({ request, id });
-        this.socket.send(message);
-        return id;
-    }
-    //
-    // Helpers
-    //
-    /**
-     * Resolve device.
-     */
-    resolveDevice(deviceRefObj, requestTimeout = 5000) {
-        if (!(0, util_1.isValidDeviceRefObj)(deviceRefObj)) {
-            return (0, rxjs_1.throwError)(() => new Error(`Device ref object is not valid ${JSON.stringify(deviceRefObj)}`));
-        }
-        const device = this.getCachedDeviceByDeviceRefObj(deviceRefObj);
-        if (device) {
-            return (0, rxjs_1.of)(device);
-        }
-        else {
-            return this.getDevices(requestTimeout).pipe((0, rxjs_1.tap)((devices) => {
-                this.deviceMap.clear();
-                devices.forEach((device) => {
-                    if (!device.hardwareDescription) {
-                        throw new Error(`Device ${device.position} has no hardware description`);
-                    }
-                    const deviceSerialNumber = (0, hardware_description_1.getSerialNumberFromHardwareDescription)(device.hardwareDescription);
-                    this.deviceMap.set(deviceSerialNumber, device);
-                });
-            }), (0, operators_1.map)(() => {
-                const device = this.getCachedDeviceByDeviceRefObj(deviceRefObj);
-                if (!device) {
-                    throw new Error(`Device is not found by deviceRefObj ${JSON.stringify(deviceRefObj)}`);
-                }
-                return device;
-            }));
-        }
-    }
-    /**
-     * Resolve device address.
-     *
-     * This method should return device address by device reference object,
-     * or throw an Error if device address cannot be found.
-     *
-     * Read the description of this class for more info.
-     */
-    resolveDeviceAddress(deviceRefObj, requestTimeout = 5000) {
-        if (!(0, util_1.isValidDeviceRefObj)(deviceRefObj)) {
-            return (0, rxjs_1.throwError)(() => new Error(`Device ref object is not valid ${JSON.stringify(deviceRefObj)}`));
-        }
-        if (deviceRefObj.deviceAddress) {
-            return (0, rxjs_1.of)(deviceRefObj.deviceAddress);
-        }
-        return this.resolveDevice(deviceRefObj, requestTimeout).pipe((0, operators_1.map)((device) => {
-            return device.deviceAddress;
-        }));
-    }
-    getCachedDeviceByDeviceRefObj(deviceRefObj) {
-        if (deviceRefObj.deviceSerialNumber) {
-            return this.deviceMap.get(deviceRefObj.deviceSerialNumber);
-        }
-        else if (typeof deviceRefObj.devicePosition === 'number') {
-            const devices = Array.from(this.deviceMap.values());
-            return devices.find((device) => device.position === deviceRefObj.devicePosition);
-        }
-        else if (typeof deviceRefObj.deviceAddress === 'number') {
-            const devices = Array.from(this.deviceMap.values());
-            return devices.find((device) => device.deviceAddress === deviceRefObj.deviceAddress);
-        }
-        return;
-    }
-    /**
-     * Get devices.
-     *
-     * Get device info from Motion Master and for each device in the list
-     * read its .hardware_description file and assign its content to the device.
-     */
-    getDevices(requestTimeout = 5000) {
-        return this.getDeviceInfo(requestTimeout).pipe((0, operators_1.mergeMap)((deviceInfo) => {
-            var _a;
-            const devices = ((_a = deviceInfo.devices) !== null && _a !== void 0 ? _a : []);
-            return (0, rxjs_1.forkJoin)(devices.map((device) => {
-                return this.getDeviceFile({ deviceAddress: device.deviceAddress, name: '.hardware_description' }, requestTimeout).pipe((0, operators_1.map)((deviceFile) => {
-                    if (deviceFile.content) {
-                        const data = (0, util_1.decodeTextContent)(deviceFile.content);
-                        const hardwareDescription = JSON.parse(data);
-                        let id = (0, uuid_1.v4)();
-                        if (hardwareDescription) {
-                            id = (0, hardware_description_1.getSerialNumberFromHardwareDescription)(hardwareDescription);
-                        }
-                        return Object.assign(Object.assign({}, device), { id, hardwareDescription });
-                    }
-                    return Object.assign({}, device);
-                }));
-            }));
-        }));
-    }
-    getParameterValue(a, b, c, d, e, f) {
-        try {
-            const { deviceRefObj, index, subindex, loadFromCache, requestTimeout, messageId } = this.resolveGetDeviceParameterValueArguments(a, b, c, d, e, f);
-            return this.createGetParameterValueObservable(deviceRefObj, index, subindex, loadFromCache, requestTimeout, messageId);
-        }
-        catch (err) {
-            return (0, rxjs_1.throwError)(() => err);
-        }
-    }
-    upload(a, b, c, d, e, f) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const { deviceRefObj, index, subindex, loadFromCache, requestTimeout, messageId } = this.resolveGetDeviceParameterValueArguments(a, b, c, d, e, f);
-            return (0, rxjs_1.lastValueFrom)(this.createGetParameterValueObservable(deviceRefObj, index, subindex, loadFromCache, requestTimeout, messageId));
-        });
-    }
-    createGetParameterValueObservable(deviceRefObj, index, subindex, loadFromCache = false, requestTimeout = 1000, messageId) {
-        return (0, rxjs_1.defer)(() => {
-            return this.getDeviceParameterValues(Object.assign(Object.assign({}, deviceRefObj), { parameters: [{ index, subindex, loadFromCache }] }), requestTimeout, messageId).pipe((0, operators_1.map)(({ parameterValues }) => {
-                var _a, _b, _c;
-                const parameterValue = parameterValues === null || parameterValues === void 0 ? void 0 : parameterValues[0];
-                if (parameterValue === null || parameterValue === void 0 ? void 0 : parameterValue.success) {
-                    const typeValue = parameterValue.typeValue;
-                    if (typeValue) {
-                        return parameterValues === null || parameterValues === void 0 ? void 0 : parameterValues[0][typeValue];
-                    }
-                }
-                const props = Object.assign(Object.assign({}, deviceRefObj), { index, subindex, loadFromCache, requestTimeout, messageId });
-                const errorCodeName = types_1.MotionMasterMessage.Status.DeviceParameterValues.ParameterValue.Error.Code[(_c = (_b = (_a = parameterValues === null || parameterValues === void 0 ? void 0 : parameterValues[0]) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.code) !== null && _c !== void 0 ? _c : 0];
-                throw new Error(`Failed to get parameter value (${errorCodeName}) for ${JSON.stringify(props)}`);
-            }));
-        });
-    }
-    resolveGetDeviceParameterValueArguments(a, b, c, d, e, f) {
-        let deviceSerialNumber;
-        let index;
-        let subindex = 0;
-        let loadFromCache = false;
-        let requestTimeout = 1000;
-        let deviceRefObj;
-        let messageId;
-        if (typeof b === 'number' && typeof c === 'number') { // index, subindex, e.g. 0x6060, 1
-            deviceRefObj = (0, util_1.makeDeviceRefObj)(a);
-            index = b;
-            subindex = c;
-            if (typeof d === 'boolean') {
-                loadFromCache = d;
-            }
-            if (typeof e === 'number') {
-                requestTimeout = e;
-            }
-            if (typeof f === 'string') {
-                messageId = f;
-            }
-        }
-        else if (typeof a === 'string') { // device parameter id, e.g. "0x2110:1A.8502-03-0001353-2115"
-            [deviceSerialNumber, index, subindex] = (0, device_parameter_1.splitDeviceParameterId)(a);
-            deviceRefObj = (0, util_1.makeDeviceRefObj)(deviceSerialNumber);
-            if (typeof b === 'boolean') {
-                loadFromCache = b;
-            }
-            if (typeof c === 'number') {
-                requestTimeout = c;
-            }
-            if (typeof d === 'string') {
-                messageId = d;
-            }
-        }
-        if (!index) {
-            throw new Error('Device parameter index is not provided!');
-        }
-        if (!deviceRefObj) {
-            throw new Error('Device address, position or serial number is not provided!');
-        }
-        return { deviceRefObj, index, subindex, loadFromCache, requestTimeout, messageId };
-    }
-    getParameterValues(ids, loadFromCache = false, requestTimeout = 9000, messageId) {
-        return this.resolveGetParameterValuesIds(ids).pipe((0, operators_1.mergeMap)((tuples) => {
-            var _a;
-            const collection = [];
-            for (const [deviceAddress, index, subindex] of tuples) {
-                let item = collection.find(c => c.deviceAddress === deviceAddress);
-                if (!item) {
-                    item = { deviceAddress, parameters: [], sendProgress: false };
-                    collection.push(item);
-                }
-                (_a = item.parameters) === null || _a === void 0 ? void 0 : _a.push({ index, subindex, loadFromCache });
-            }
-            return this.getMultiDeviceParameterValues({ collection }, requestTimeout, messageId).pipe((0, operators_1.map)((multiDeviceParameterValues) => {
-                if (!(multiDeviceParameterValues === null || multiDeviceParameterValues === void 0 ? void 0 : multiDeviceParameterValues.collection)) {
-                    throw new Error(`Multi device parameter values collection is empty`);
-                }
-                return multiDeviceParameterValues.collection.map(({ parameterValues, deviceAddress }) => {
-                    if (!parameterValues) {
-                        throw new Error(`No parameterValues for device ${deviceAddress}`);
-                    }
-                    return parameterValues.map((parameterValue) => {
-                        const value = parameterValue;
-                        const typeValue = value === null || value === void 0 ? void 0 : value.typeValue;
-                        if (typeValue) {
-                            return parameterValue[typeValue];
-                        }
-                        throw new Error(`No type value for parameter ${(0, parameter_1.makeParameterId)(value === null || value === void 0 ? void 0 : value.index, value === null || value === void 0 ? void 0 : value.subindex)}`);
-                    });
-                }).flat();
-            }));
-        }));
-    }
-    uploadMany(ids, loadFromCache = false, requestTimeout = 9000, messageId) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return (0, rxjs_1.lastValueFrom)(this.getParameterValues(ids, loadFromCache, requestTimeout, messageId));
-        });
-    }
-    resolveGetParameterValuesIds(ids) {
-        if (ids.length === 0) {
-            return (0, rxjs_1.throwError)(() => new Error('The provided array of device parameter ids or addresses is empty!'));
-        }
-        let refs;
-        if ((0, types_1.isArrayOfDeviceSerialNumbers)(ids)) {
-            refs = ids.map(id => (0, device_parameter_1.splitDeviceParameterId)(id));
-        }
-        else {
-            refs = ids;
-        }
-        return (0, rxjs_1.defer)(() => {
-            return (0, rxjs_1.forkJoin)(refs.map(([deviceRef, index, subindex]) => {
-                return this.resolveDeviceAddress((0, util_1.makeDeviceRefObj)(deviceRef)).pipe((0, operators_1.map)((deviceAddress) => ([deviceAddress, index, subindex])));
-            }));
-        });
-    }
-    setParameterValue(a, b, c, d, e, f, g) {
-        try {
-            const { deviceRefObj, index, subindex, value, valueTypeKey, requestTimeout, messageId } = this.resolveSetDeviceParameterValueArguments(a, b, c, d, e, f, g);
-            return this.createSetParameterValueObservable(deviceRefObj, index, subindex, value, valueTypeKey, requestTimeout, messageId);
-        }
-        catch (err) {
-            return (0, rxjs_1.throwError)(() => err);
-        }
-    }
-    download(a, b, c, d, e, f, g) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const { deviceRefObj, index, subindex, value, valueTypeKey, requestTimeout, messageId } = this.resolveSetDeviceParameterValueArguments(a, b, c, d, e, f, g);
-            return (0, rxjs_1.lastValueFrom)(this.createSetParameterValueObservable(deviceRefObj, index, subindex, value, valueTypeKey, requestTimeout, messageId));
-        });
-    }
-    createSetParameterValueObservable(deviceRefObj, index, subindex, value, valueTypeKey, requestTimeout = 1000, messageId) {
-        return (0, rxjs_1.defer)(() => {
-            return this.resolveDeviceParameterTypeValueKey(deviceRefObj, index, subindex, valueTypeKey).pipe((0, operators_1.mergeMap)((valueTypeKey) => {
-                const parameterValue = { index, subindex, [valueTypeKey]: value };
-                return this.setDeviceParameterValues(Object.assign(Object.assign({}, deviceRefObj), { parameterValues: [parameterValue] }), requestTimeout, messageId).pipe((0, operators_1.map)(({ parameterValues }) => {
-                    var _a, _b, _c;
-                    const parameterValue = parameterValues === null || parameterValues === void 0 ? void 0 : parameterValues[0];
-                    if (parameterValue === null || parameterValue === void 0 ? void 0 : parameterValue.success) {
-                        const typeValue = parameterValue.typeValue;
-                        if (typeValue) {
-                            return;
-                        }
-                    }
-                    const props = Object.assign(Object.assign({}, deviceRefObj), { index, subindex, value, valueTypeKey, requestTimeout, messageId });
-                    const errorCodeName = types_1.MotionMasterMessage.Status.DeviceParameterValues.ParameterValue.Error.Code[(_c = (_b = (_a = parameterValues === null || parameterValues === void 0 ? void 0 : parameterValues[0]) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.code) !== null && _c !== void 0 ? _c : 0];
-                    throw new Error(`Failed to set parameter value (${errorCodeName}) for ${JSON.stringify(props)}`);
-                }));
-            }));
-        });
-    }
-    /**
-     * Resolve get device parameter value arguments.
-     */
-    resolveSetDeviceParameterValueArguments(a, b, c, d, e, f, g) {
-        let deviceSerialNumber;
-        let index;
-        let subindex = 0;
-        let value = 0;
-        let valueTypeKey;
-        let requestTimeout = 1000;
-        let deviceRefObj;
-        let messageId;
-        if (typeof b === 'number' && typeof c === 'number') { // index, subindex, e.g. 0x6060, 1
-            deviceRefObj = (0, util_1.makeDeviceRefObj)(a);
-            index = b;
-            subindex = c;
-            if (d !== undefined) {
-                value = d;
-            }
-            valueTypeKey = e;
-            if (typeof f === 'number') {
-                requestTimeout = f;
-            }
-            messageId = g;
-        }
-        else if (typeof a === 'string') { // device parameter id, e.g. "0x2110:1A.8502-03-0001353-2115"
-            [deviceSerialNumber, index, subindex] = (0, device_parameter_1.splitDeviceParameterId)(a);
-            deviceRefObj = (0, util_1.makeDeviceRefObj)(deviceSerialNumber);
-            value = b;
-            if (typeof c !== 'number') {
-                valueTypeKey = c;
-            }
-            if (typeof d === 'number') {
-                requestTimeout = d;
-            }
-            messageId = e;
-        }
-        if (!index) {
-            throw new Error('Device parameter index is not provided!');
-        }
-        if (!deviceRefObj) {
-            throw new Error('Device address, position or serial number is not provided!');
-        }
-        return { deviceRefObj, index, subindex, value, valueTypeKey, requestTimeout, messageId };
-    }
-    setParameterValues(ids, requestTimeout = 9000, messageId) {
-        if (ids.length === 0) {
-            return (0, rxjs_1.throwError)(() => new Error('The provided array of device parameter ids or addresses is empty!'));
-        }
-        let refs;
-        if ((0, types_1.isObjectOfDeviceSerialNumberToValues)(ids)) {
-            refs = Object.entries(ids).map(([id, value]) => ([...(0, device_parameter_1.splitDeviceParameterId)(id), value]));
-        }
-        else {
-            refs = ids;
-        }
-        return (0, rxjs_1.defer)(() => {
-            return (0, rxjs_1.forkJoin)(refs.map(([deviceRef, index, subindex, value, typeValueKey]) => {
-                const deviceRefObj = (0, util_1.makeDeviceRefObj)(deviceRef);
-                return this.resolveDeviceAddress(deviceRefObj).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-                    return this.resolveDeviceParameterTypeValueKey(deviceRefObj, index, subindex, typeValueKey).pipe((0, operators_1.map)((typeValueKey) => ([deviceAddress, index, subindex, value, typeValueKey])));
-                }));
-            })).pipe((0, operators_1.mergeMap)((tuples) => {
-                var _a;
-                const collection = [];
-                for (const [deviceAddress, index, subindex, value, typeValueKey] of tuples) {
-                    let item = collection.find(c => c.deviceAddress === deviceAddress);
-                    if (!item) {
-                        item = { deviceAddress, parameterValues: [] };
-                        collection.push(item);
-                    }
-                    (_a = item.parameterValues) === null || _a === void 0 ? void 0 : _a.push({ index, subindex, [typeValueKey]: value });
-                }
-                return this.setMultiDeviceParameterValues({ collection }, requestTimeout, messageId).pipe((0, operators_1.map)((multiDeviceParameterValues) => {
-                    var _a;
-                    (_a = multiDeviceParameterValues.collection) === null || _a === void 0 ? void 0 : _a.map(({ parameterValues, deviceAddress }) => {
-                        if (!parameterValues) {
-                            throw new Error(`No parameterValues for device ${deviceAddress}`);
-                        }
-                    });
-                }));
-            }));
-        });
-    }
-    downloadMany(ids, requestTimeout = 9000, messageId) {
-        return (0, rxjs_1.lastValueFrom)(this.setParameterValues(ids, requestTimeout, messageId));
-    }
-    resolveDeviceParameterTypeValueKey(deviceRefObj, index, subindex, typeValueKey) {
-        if (typeValueKey) {
-            return (0, rxjs_1.of)(typeValueKey);
-        }
-        const parameterId = (0, parameter_1.makeParameterId)(index, subindex);
-        return this.resolveDeviceAddress(deviceRefObj).pipe((0, operators_1.mergeMap)((deviceAddress) => {
-            const el = this.typeValueKeyMap.get(deviceAddress);
-            if (el) {
-                typeValueKey = el.get(parameterId);
-                if (!typeValueKey) {
-                    throw new Error(`No type value key is set for device ${deviceAddress} ${parameterId}`);
-                }
-                return (0, rxjs_1.of)(typeValueKey);
-            }
-            else {
-                return this.getDeviceParameterInfo({ deviceAddress }, 5000).pipe((0, operators_1.map)(({ parameters }) => {
-                    if (!parameters) {
-                        throw new Error(`Device parameter info has no parameters ${deviceAddress}`);
-                    }
-                    const map = new Map();
-                    this.typeValueKeyMap.set(deviceAddress, map);
-                    for (const parameter of parameters) {
-                        if (parameter.valueType) {
-                            const typeValueKey = util_1.valueTypeToParameterTypeValueKeyMap.get(parameter.valueType);
-                            if (typeValueKey) {
-                                map.set((0, parameter_1.makeParameterId)(parameter), typeValueKey);
-                            }
-                        }
-                    }
-                    typeValueKey = map.get(parameterId);
-                    if (!typeValueKey) {
-                        throw new Error(`No type value key is set for device ${deviceAddress} ${parameterId}`);
-                    }
-                    return typeValueKey;
-                }));
-            }
-        }));
-    }
-    /**
-     * Get device parameters.
-     */
-    getDeviceParameters(props, requestTimeout = 30000) {
-        return this.resolveDevice(props).pipe((0, operators_1.mergeMap)((device) => {
-            return this.getDeviceParameterInfo({ deviceAddress: device.deviceAddress }, requestTimeout).pipe((0, operators_1.mergeMap)(deviceParameterInfoStatus => {
-                var _a;
-                const { loadFromCache, sendProgress } = props;
-                const parameters = (_a = deviceParameterInfoStatus.parameters) === null || _a === void 0 ? void 0 : _a.map(p => { var _a, _b; return ({ index: (_a = p.index) !== null && _a !== void 0 ? _a : 0, subindex: (_b = p.subindex) !== null && _b !== void 0 ? _b : 0, loadFromCache }); });
-                return this.getDeviceParameterValues({ deviceAddress: device.deviceAddress, sendProgress, parameters }, requestTimeout).pipe((0, operators_1.map)(deviceParameterValuesStatus => {
-                    var _a, _b;
-                    if (!deviceParameterValuesStatus.parameterValues) {
-                        throw new Error('Device parameter values is empty');
-                    }
-                    const deviceParameters = deviceParameterValuesStatus.parameterValues.map((value, i) => {
-                        var _a, _b, _c;
-                        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);
-                        return (Object.assign(Object.assign(Object.assign({ id }, value), (_c = deviceParameterInfoStatus.parameters) === null || _c === void 0 ? void 0 : _c[i]), { index, subindex, value: (0, util_1.getParameterValue)(value) }));
-                    });
-                    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 };
-                }));
-            }));
-        }));
-    }
-    /**
-     * Get files.
-     */
-    getFiles(deviceRef, requestTimeout = 30000, messageId) {
-        const deviceRefObj = (0, util_1.makeDeviceRefObj)(deviceRef);
-        return this.getDeviceFileList(deviceRefObj, requestTimeout, messageId).pipe((0, operators_1.map)((status) => { var _a, _b; return (_b = (_a = status.fileList) === null || _a === void 0 ? void 0 : _a.files) !== null && _b !== void 0 ? _b : []; }));
-    }
-    /**
-     * Get file.
-     */
-    getFile(deviceRef, name, requestTimeout = 5000, messageId) {
-        const deviceRefObj = (0, util_1.makeDeviceRefObj)(deviceRef);
-        return this.getDeviceFile(Object.assign(Object.assign({}, deviceRefObj), { name }), requestTimeout, messageId).pipe((0, operators_1.map)(({ content }) => content));
-    }
-    /**
-     * Get decoded file.
-     *
-     * Content of a device file is returned as a binary data buffer.
-     * This functions tries to decode the content as a text in utf-8 character encoding.
-     */
-    getDecodedFile(deviceRef, name, requestTimeout = 2000, messageId) {
-        const deviceRefObj = (0, util_1.makeDeviceRefObj)(deviceRef);
-        return this.getDeviceFile(Object.assign(Object.assign({}, deviceRefObj), { name }), requestTimeout, messageId).pipe((0, operators_1.map)(({ content }) => {
-            if (content) {
-                return (0, util_1.decodeTextContent)(content);
-            }
-            throw new Error(`Device file ${name} content for device ${deviceRef} is empty!}`);
-        }));
-    }
-    /**
-     * Unlock protected files.
-     *
-     * This will enable the deletion of protected files.
-     * Protected files begin with a period, such as '.hardware_description'.
-     */
-    unlockProtectedFiles(deviceRef, requestTimeout = 3000, messageId) {
-        return this.getDecodedFile(deviceRef, 'fs-stackunlock=DD1317', requestTimeout, messageId);
-    }
-    /**
-     * Delete file.
-     */
-    deleteFile(deviceRef, name, requestTimeout = 3000, messageId) {
-        const deviceRefObj = (0, util_1.makeDeviceRefObj)(deviceRef);
-        return this.deleteDeviceFile(Object.assign(Object.assign({}, deviceRefObj), { name }), requestTimeout, messageId);
-    }
-    /**
-     * Get system log lines.
-     *
-     * Get the system log content and parse it into an array of lines, where each line contains the date, uptime, ID, file, level, and message.
-     */
-    getSystemLogLines(requestTimeout = 2000, messageId) {
-        return this.getSystemLog(requestTimeout, messageId).pipe((0, operators_1.map)((systemLog) => { var _a; return (0, util_1.parseSystemLogContent)((_a = systemLog.content) !== null && _a !== void 0 ? _a : ''); }));
-    }
-    /**
-     * Store parameters.
-     *
-     * Command the device to store the parameters into config.csv, then delay initially and subsequently check if the value of
-     * the Store parameters has changed to 1, indicating the successful completion.
-     *
-     * {@link https://www.synapticon.com/documentation/circulo/sw5.0/device_info/save_restore_config.html}
-     */
-    storeParameters(deviceRef) {
-        return this.setParameterValue(deviceRef, 0x1010, 1, 0x65766173).pipe(// "evas"
-        (0, operators_1.delay)(2000), (0, operators_1.mergeMap)(() => this.matchParameterValue(deviceRef, 0x1010, 1, 1).pipe((0, operators_1.retry)({ count: 10, delay: 500 }))));
-    }
-    /**
-     * Restore default parameters.
-     *
-     * Command the device to restore the default parameters, then delay initially and subsequently check if the value of
-     * the Restore default parameters has changed to 1, indicating the successful completion.
-     *
-     * {@link https://www.synapticon.com/documentation/circulo/sw5.0/device_info/save_restore_config.html}
-     */
-    restoreDefaultParameters(deviceRef, type = types_1.RestoreDefaultParametersType.RESTORE_ALL_DEFAULT_PARAMETERS) {
-        return this.setParameterValue(deviceRef, 0x1011, type, 0x64616f6c).pipe(// "daol"
-        (0, operators_1.delay)(2000), (0, operators_1.mergeMap)(() => this.matchParameterValue(deviceRef, 0x1011, type, 1).pipe((0, operators_1.retry)({ count: 10, delay: 500 }))));
-    }
-    /**
-     * Match parameter value.
-     *
-     * This function will retrieve a parameter value from a device and compare it with the expected value.
-     *
-     * @throws Will throw an error if the values do not match.
-     */
-    matchParameterValue(deviceRef, index, subindex, expectedValue) {
-        return this.getParameterValue(deviceRef, index, subindex).pipe((0, operators_1.map)((value) => {
-            if (value !== expectedValue) {
-                throw new Error(`Device parameter value and the expected value don't match: ${value} ${expectedValue}`);
-            }
-        }));
-    }
-    matchCia402States(deviceRef, expectedStates) {
-        return this.getParameterValue(deviceRef, 0x6041, 0).pipe((0, operators_1.map)((value) => {
-            const state = (0, cia402_1.getCia402State)(value);
-            if (!expectedStates.includes(state)) {
-                throw new Error(`Device CiA402 state and the expected state don't match: ${state} ${expectedStates}`);
-            }
-        }));
-    }
-    /**
-     * Helper function to enable motion.
-     */
-    enableMotion(deviceRef, controllerType, filter = false, requestTimeout = 2000, messageId) {
-        const deviceRefObj = (0, util_1.makeDeviceRefObj)(deviceRef);
-        return this.enableMotionController(Object.assign(Object.assign({}, deviceRefObj), { controllerType, filter }), requestTimeout, messageId);
-    }
-    /**
-     * Helper function to disable motion.
-     */
-    disableMotion(deviceRef, requestTimeout = 3000, messageId) {
-        const deviceRefObj = (0, util_1.makeDeviceRefObj)(deviceRef);
-        return this.disableMotionController(deviceRefObj, requestTimeout, messageId);
-    }
-    /**
-     * Helper function to set motion target.
-     */
-    setMotionTarget(deviceRef, target, messageId) {
-        const deviceRefObj = (0, util_1.makeDeviceRefObj)(deviceRef);
-        return this.setMotionControllerParameters(Object.assign(Object.assign({}, deviceRefObj), { target }), messageId);
-    }
-    /**
-     * Get CiA402 state.
-     */
-    getCia402State(deviceRef, requestTimeout = 1000, messageId) {
-        return this.getParameterValue(deviceRef, 0x6041, 0, false, requestTimeout, messageId).pipe((0, operators_1.map)((value) => (0, cia402_1.getCia402State)(value)));
-    }
-    /**
-     * Transition to CiA402 state.
-     *
-     * This function will utilize the current value of the controlword and modify it to transition to the requested CiA402 state.
-     *
-     * Only one transition will occur, except when the current CiA402 state is SWITCH_ON_DISABLED. In this case,
-     * the first transition is from SOD to RTSO, and then from RTSO to the requested CiA402 state.
-     *
-     * The Statusword will be polled to check if the device has successfully transitioned to the requested CiA402 state.
-     * When transitioning to QSA, the Statusword will be checked against both QSA and SOD.
-     * This is necessary because the automatic transition from QSA to SOD can occur faster than the client's polling interval.
-     */
-    transitionToCia402State(deviceRef, targetState) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            let currentState = yield (0, rxjs_1.lastValueFrom)(this.getCia402State(deviceRef));
-            if (targetState === currentState) {
-                return;
-            }
-            if (currentState === cia402_1.Cia402State.NOT_READY_TO_SWITCH_ON || currentState === cia402_1.Cia402State.FAULT_REACTION_ACTIVE) {
-                throw new Error(`It is not possible to transition from state ${currentState} to state ${targetState}. The transition from the current ${currentState} state is automatic.`);
-            }
-            let controlword = yield this.upload(deviceRef, 0x6040, 0);
-            let transition = cia402_2.cia402Transitions.find(t => t.from === currentState && t.to === targetState);
-            // From SOD it's only possible to transition to RTSO.
-            if (currentState === cia402_1.Cia402State.SWITCH_ON_DISABLED && targetState !== cia402_1.Cia402State.READY_TO_SWITCH_ON) {
-                transition = cia402_2.cia402Transitions.find(t => t.from === cia402_1.Cia402State.READY_TO_SWITCH_ON && t.to === targetState);
-            }
-            if (!transition) {
-                throw new Error(`It is not possible to transition from state ${currentState} to state ${targetState}.`);
-            }
-            if (currentState === cia402_1.Cia402State.SWITCH_ON_DISABLED) {
-                const sodToRtsoTransition = cia402_2.cia402Transitions[0];
-                const command = (0, cia402_3.createControlwordCommand)(controlword, sodToRtsoTransition.command);
-                yield (0, rxjs_1.lastValueFrom)(this.setParameterValue(deviceRef, 0x6040, 0, command).pipe((0, operators_1.mergeMap)(() => this.matchCia402States(deviceRef, [cia402_1.Cia402State.READY_TO_SWITCH_ON]).pipe((0, operators_1.retry)({ count: 5, delay: 1000 })))));
-                controlword = yield this.upload(deviceRef, 0x6040, 0);
-                currentState = yield (0, rxjs_1.lastValueFrom)(this.getCia402State(deviceRef));
-                if (targetState === currentState) {
-                    return;
-                }
-            }
-            const command = (0, cia402_3.createControlwordCommand)(controlword, transition.command);
-            const expectedStates = [targetState];
-            if (targetState === cia402_1.Cia402State.QUICK_STOP_ACTIVE) {
-                expectedStates.push(cia402_1.Cia402State.SWITCH_ON_DISABLED);
-            }
-            yield (0, rxjs_1.lastValueFrom)(this.setParameterValue(deviceRef, 0x6040, 0, command).pipe((0, operators_1.mergeMap)(() => this.matchCia402States(deviceRef, expectedStates).pipe((0, operators_1.retry)({ count: 5, delay: 1000 }))), (0, operators_1.catchError)(() => {
-                throw new Error(`Timeout occurred while transitioning from ${currentState} state to ${targetState} state.`);
-            })));
-        });
-    }
-    resetFault(deviceRef) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const currentState = yield (0, rxjs_1.lastValueFrom)(this.getCia402State(deviceRef));
-            if (currentState !== cia402_1.Cia402State.FAULT) {
-                throw new Error(`Device ${deviceRef} is not in FAULT CiA402 state.`);
-            }
-            this.transitionToCia402State(deviceRef, cia402_1.Cia402State.SWITCH_ON_DISABLED);
-        });
-    }
-    quickStop(deviceRef) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const currentState = yield (0, rxjs_1.lastValueFrom)(this.getCia402State(deviceRef));
-            if (currentState !== cia402_1.Cia402State.OPERATION_ENABLED) {
-                throw new Error(`Device ${deviceRef} is not in OPERATION_ENABLED CiA402 state.`);
-            }
-            this.transitionToCia402State(deviceRef, cia402_1.Cia402State.QUICK_STOP_ACTIVE);
-        });
-    }
-    /**
-     * Reset targets.
-     *
-     * Set torque and velocity targets to 0, and set the position target to the current position value.
-     */
-    resetTargets(deviceRef) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const positionActualValue = yield this.upload(deviceRef, 0x6064, 0);
-            return this.downloadMany([
-                [deviceRef, 0x6071, 0, 0],
-                [deviceRef, 0x607A, 0, positionActualValue],
-                [deviceRef, 0x60FF, 0, 0], // target velocity
-            ]);
-        });
-    }
-    /**
-     * Get modes of operation.
-     *
-     * Retrieve the value of the 0x6061:00 Modes of operation display.
-     */
-    getModesOfOperation(deviceRef, requestTimeout = 1000, messageId) {
-        return this.getParameterValue(deviceRef, 0x6061, 0, false, requestTimeout, messageId);
-    }
-    /**
-     * Set modes of operation.
-     *
-     * Set the 0x6060:00 Modes of operation to one of the available options, such as Homing mode (6).
-     */
-    setModesOfOperation(deviceRef, value, requestTimeout = 1000, messageId) {
-        return this.setParameterValue(deviceRef, 0x6060, 0, value, 'uintValue', requestTimeout, messageId);
-    }
-}
-exports.MotionMasterReqResClient = MotionMasterReqResClient;
-//# sourceMappingURL=motion-master-req-res-client.js.map