@zaber/motion 9.2.1 → 9.3.0

package/dist/lib/movement/moveable.js

@@ -0,0 +1,639 @@
+"use strict";
+// ===== THIS FILE IS GENERATED FROM A TEMPLATE ===== //
+// ============== DO NOT EDIT DIRECTLY ============== //
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Moveable = void 0;
+const gateway = __importStar(require("../gateway"));
+const requests = __importStar(require("../requests"));
+const finalizer_1 = require("../finalizer");
+const axis_1 = require("../ascii/axis");
+const lockstep_1 = require("../ascii/lockstep");
+/**
+ * Represents something that moves: either an axis of a device, or a lockstep group.
+ */
+class Moveable {
+    /**
+     * The identifier for the moveable instance.
+     */
+    get moveableId() {
+        return this._moveableId;
+    }
+    /**
+     * The device this moveable is on.
+     */
+    get device() {
+        return this._device;
+    }
+    constructor(moveableId, device) {
+        this._moveableId = moveableId;
+        this._device = device;
+        (0, finalizer_1.registerForFinalization)(this, Moveable._free.bind(null, moveableId));
+    }
+    /**
+     * Creates a Moveable instance for a given axis.
+     * @param axis Axis to create a Moveable for.
+     * @param options.units Default units of measurement used for movement operations.
+     * @returns A Moveable instance for the specified axis.
+     */
+    static async fromAxis(axis, options = {}) {
+        const { units, } = options;
+        const request = {
+            ...requests.MoveableSetupRequest.DEFAULT,
+            interfaceId: axis.device.connection.interfaceId,
+            moveableNumber: axis.axisNumber,
+            moveableType: requests.MoveableType.AXIS,
+            device: axis.device.deviceAddress,
+            defaultUnits: units,
+            toBinary() {
+                return requests.MoveableSetupRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/setup', request, requests.IntResponse.fromBinary);
+        return new Moveable(response.value, axis.device);
+    }
+    /**
+     * Creates a Moveable instance for a given lockstep group.
+     * @param lockstep Lockstep group to create a Moveable for.
+     * @param options.units Default units of measurement used for movement operations.
+     * @returns A Moveable instance for the specified lockstep group.
+     */
+    static async fromLockstep(lockstep, options = {}) {
+        const { units, } = options;
+        const request = {
+            ...requests.MoveableSetupRequest.DEFAULT,
+            interfaceId: lockstep.device.connection.interfaceId,
+            moveableNumber: lockstep.lockstepGroupId,
+            moveableType: requests.MoveableType.LOCKSTEP,
+            device: lockstep.device.deviceAddress,
+            defaultUnits: units,
+            toBinary() {
+                return requests.MoveableSetupRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/setup', request, requests.IntResponse.fromBinary);
+        return new Moveable(response.value, lockstep.device);
+    }
+    /**
+     * Creates a Moveable instance for a single-axis device.
+     * @param device Device to create a Moveable for.
+     * @param options.units Default units of measurement used for movement operations.
+     * @returns A Moveable instance for the specified device.
+     */
+    static async fromDevice(device, options = {}) {
+        const { units, } = options;
+        const request = {
+            ...requests.MoveableSetupRequest.DEFAULT,
+            interfaceId: device.connection.interfaceId,
+            moveableNumber: 1,
+            moveableType: requests.MoveableType.DEVICE,
+            device: device.deviceAddress,
+            defaultUnits: units,
+            toBinary() {
+                return requests.MoveableSetupRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/setup', request, requests.IntResponse.fromBinary);
+        return new Moveable(response.value, device);
+    }
+    /**
+     * Moves to an absolute position.
+     * @param position Absolute position to move to.
+     * @param options.velocity Movement velocity. If not specified, the maximum velocity setting is used.
+     * @param options.acceleration Movement acceleration. If not specified, the default acceleration setting is used.
+     * @param [options.waitUntilIdle=true] Determines whether function should return after the movement is finished or just started.
+     * @param options.cyclicDirection Which direction a cyclic device should take to get to the target position.
+     * @param options.extraCycles Number of extra cycles to complete before stopping at the target.
+     */
+    async moveAbsolute(position, options = {}) {
+        const { velocity, acceleration, waitUntilIdle = true, cyclicDirection, extraCycles, } = options;
+        const request = {
+            ...requests.MoveableMoveRequest.DEFAULT,
+            moveableId: this.moveableId,
+            position: position,
+            velocity: velocity,
+            acceleration: acceleration,
+            waitUntilIdle: waitUntilIdle,
+            cyclicDirection: cyclicDirection,
+            extraCycles: extraCycles,
+            toBinary() {
+                return requests.MoveableMoveRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/move_abs', request);
+    }
+    /**
+     * Moves by a relative amount from the current position.
+     * @param position Relative displacement to move by.
+     * @param options.velocity Movement velocity. If not specified, the maximum velocity setting is used.
+     * @param options.acceleration Movement acceleration. If not specified, the default acceleration setting is used.
+     * @param [options.waitUntilIdle=true] Determines whether function should return after the movement is finished or just started.
+     */
+    async moveRelative(position, options = {}) {
+        const { velocity, acceleration, waitUntilIdle = true, } = options;
+        const request = {
+            ...requests.MoveableMoveRequest.DEFAULT,
+            moveableId: this.moveableId,
+            position: position,
+            velocity: velocity,
+            acceleration: acceleration,
+            waitUntilIdle: waitUntilIdle,
+            toBinary() {
+                return requests.MoveableMoveRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/move_rel', request);
+    }
+    /**
+     * Begins moving at a specified velocity.
+     * @param velocity Velocity to move at.
+     * @param options.acceleration Movement acceleration. If not specified, the default acceleration setting is used.
+     * @param [options.waitUntilIdle=true] Determines whether function should return after the movement is finished or just started.
+     */
+    async moveVelocity(velocity, options = {}) {
+        const { acceleration, waitUntilIdle = true, } = options;
+        const request = {
+            ...requests.MoveableMoveRequest.DEFAULT,
+            moveableId: this.moveableId,
+            velocity: velocity,
+            acceleration: acceleration,
+            waitUntilIdle: waitUntilIdle,
+            toBinary() {
+                return requests.MoveableMoveRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/move_vel', request);
+    }
+    /**
+     * Moves to the end of travel.
+     * @param options.velocity Movement velocity. If not specified, the maximum velocity setting is used.
+     * @param options.acceleration Movement acceleration. If not specified, the default acceleration setting is used.
+     * @param [options.waitUntilIdle=true] Determines whether function should return after the movement is finished or just started.
+     */
+    async moveMax(options = {}) {
+        const { velocity, acceleration, waitUntilIdle = true, } = options;
+        const request = {
+            ...requests.MoveableMoveRequest.DEFAULT,
+            moveableId: this.moveableId,
+            velocity: velocity,
+            acceleration: acceleration,
+            waitUntilIdle: waitUntilIdle,
+            toBinary() {
+                return requests.MoveableMoveRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/move_max', request);
+    }
+    /**
+     * Moves to the beginning of travel.
+     * @param options.velocity Movement velocity. If not specified, the maximum velocity setting is used.
+     * @param options.acceleration Movement acceleration. If not specified, the default acceleration setting is used.
+     * @param [options.waitUntilIdle=true] Determines whether function should return after the movement is finished or just started.
+     */
+    async moveMin(options = {}) {
+        const { velocity, acceleration, waitUntilIdle = true, } = options;
+        const request = {
+            ...requests.MoveableMoveRequest.DEFAULT,
+            moveableId: this.moveableId,
+            velocity: velocity,
+            acceleration: acceleration,
+            waitUntilIdle: waitUntilIdle,
+            toBinary() {
+                return requests.MoveableMoveRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/move_min', request);
+    }
+    /**
+     * Returns the current position of the moveable.
+     * @param options.unit Units of position. If not specified, the default position unit is used.
+     * @returns Current position.
+     */
+    async getPosition(options = {}) {
+        const { unit, } = options;
+        const request = {
+            ...requests.MoveableGetSettingRequest.DEFAULT,
+            moveableId: this.moveableId,
+            unit: unit,
+            toBinary() {
+                return requests.MoveableGetSettingRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/get_position', request, requests.DoubleResponse.fromBinary);
+        return response.value;
+    }
+    /**
+     * Returns the current encoder position of the moveable.
+     * @param options.unit Units of position. If not specified, the default position unit is used.
+     * @returns Current encoder position.
+     */
+    async getEncoderPosition(options = {}) {
+        const { unit, } = options;
+        const request = {
+            ...requests.MoveableGetSettingRequest.DEFAULT,
+            moveableId: this.moveableId,
+            unit: unit,
+            toBinary() {
+                return requests.MoveableGetSettingRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/get_encoder_position', request, requests.DoubleResponse.fromBinary);
+        return response.value;
+    }
+    /**
+     * Moves the moveable to the home position.
+     * @param [options.waitUntilIdle=true] Determines whether function should return after the movement is finished or just started.
+     */
+    async home(options = {}) {
+        const { waitUntilIdle = true, } = options;
+        const request = {
+            ...requests.MoveableMoveRequest.DEFAULT,
+            moveableId: this.moveableId,
+            waitUntilIdle: waitUntilIdle,
+            toBinary() {
+                return requests.MoveableMoveRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/home', request);
+    }
+    /**
+     * Returns bool indicating whether the moveable has position reference and was homed.
+     * @returns True if the moveable has position reference and was homed.
+     */
+    async isHomed() {
+        const request = {
+            ...requests.MoveableIdRequest.DEFAULT,
+            moveableId: this.moveableId,
+            toBinary() {
+                return requests.MoveableIdRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/is_homed', request, requests.BoolResponse.fromBinary);
+        return response.value;
+    }
+    /**
+     * Returns bool indicating whether the moveable is executing a motion command.
+     * @returns True if the moveable is currently executing a motion command.
+     */
+    async isBusy() {
+        const request = {
+            ...requests.MoveableIdRequest.DEFAULT,
+            moveableId: this.moveableId,
+            toBinary() {
+                return requests.MoveableIdRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/is_busy', request, requests.BoolResponse.fromBinary);
+        return response.value;
+    }
+    /**
+     * Returns bool indicating whether the moveable is parked.
+     * @returns True if the moveable is parked.
+     */
+    async isParked() {
+        const request = {
+            ...requests.MoveableIdRequest.DEFAULT,
+            moveableId: this.moveableId,
+            toBinary() {
+                return requests.MoveableIdRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/is_parked', request, requests.BoolResponse.fromBinary);
+        return response.value;
+    }
+    /**
+     * Stops ongoing movement of the moveable.
+     * @param [options.waitUntilIdle=true] Determines whether function should return after the movement is finished or just started.
+     */
+    async stop(options = {}) {
+        const { waitUntilIdle = true, } = options;
+        const request = {
+            ...requests.MoveableMoveRequest.DEFAULT,
+            moveableId: this.moveableId,
+            waitUntilIdle: waitUntilIdle,
+            toBinary() {
+                return requests.MoveableMoveRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/stop', request);
+    }
+    /**
+     * Moves the moveable in a sinusoidal trajectory.
+     * @param amplitude Amplitude of the sinusoidal motion (half of the motion's peak-to-peak range).
+     * @param period Period of the sinusoidal motion.
+     * @param [options.count=0] Number of sinusoidal cycles to complete.
+     * Must be a multiple of 0.5.
+     * If count is not specified or set to 0, the moveable will move indefinitely.
+     * @param [options.waitUntilIdle=true] Determines whether function should return after the movement is finished or just started.
+     */
+    async moveSin(amplitude, period, options = {}) {
+        const { count = 0, waitUntilIdle = true, } = options;
+        const request = {
+            ...requests.MoveableMoveSinRequest.DEFAULT,
+            moveableId: this.moveableId,
+            amplitude: amplitude,
+            period: period,
+            count: count,
+            waitUntilIdle: waitUntilIdle,
+            toBinary() {
+                return requests.MoveableMoveSinRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/move_sin', request);
+    }
+    /**
+     * Stops the moveable at the end of the sinusoidal trajectory.
+     * If the sinusoidal motion was started with an integer-plus-half cycle count,
+     * the motion ends at the half-way point of the sinusoidal trajectory.
+     * @param [options.waitUntilIdle=true] Determines whether function should return after the movement is finished.
+     */
+    async moveSinStop(options = {}) {
+        const { waitUntilIdle = true, } = options;
+        const request = {
+            ...requests.MoveableMoveRequest.DEFAULT,
+            moveableId: this.moveableId,
+            waitUntilIdle: waitUntilIdle,
+            toBinary() {
+                return requests.MoveableMoveRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/move_sin_stop', request);
+    }
+    /**
+     * Parks the moveable.
+     */
+    async park() {
+        const request = {
+            ...requests.MoveableIdRequest.DEFAULT,
+            moveableId: this.moveableId,
+            toBinary() {
+                return requests.MoveableIdRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/park', request);
+    }
+    /**
+     * Unparks the moveable.
+     */
+    async unpark() {
+        const request = {
+            ...requests.MoveableIdRequest.DEFAULT,
+            moveableId: this.moveableId,
+            toBinary() {
+                return requests.MoveableIdRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/unpark', request);
+    }
+    /**
+     * Returns the current velocity of the moveable.
+     * @param options.unit Units of velocity. If not specified, the default velocity unit is used.
+     * @returns Current velocity.
+     */
+    async getVelocity(options = {}) {
+        const { unit, } = options;
+        const request = {
+            ...requests.MoveableGetSettingRequest.DEFAULT,
+            moveableId: this.moveableId,
+            unit: unit,
+            toBinary() {
+                return requests.MoveableGetSettingRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/get_velocity', request, requests.DoubleResponse.fromBinary);
+        return response.value;
+    }
+    /**
+     * Returns the maximum speed that this moveable will execute moves at by default.
+     * If a different velocity is specified on a move command, that will override
+     * this value for that command only.
+     * @param options.unit Units of velocity. If not specified, the default velocity unit is used.
+     * @returns Maximum speed.
+     */
+    async getMaxSpeed(options = {}) {
+        const { unit, } = options;
+        const request = {
+            ...requests.MoveableGetSettingRequest.DEFAULT,
+            moveableId: this.moveableId,
+            unit: unit,
+            toBinary() {
+                return requests.MoveableGetSettingRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/get_max_speed', request, requests.DoubleResponse.fromBinary);
+        return response.value;
+    }
+    /**
+     * Sets the maximum speed of the moveable. For a lockstep group, sets the value on all axes.
+     * @param speed Maximum speed to set.
+     */
+    async setMaxSpeed(speed) {
+        const request = {
+            ...requests.MoveableSetSettingRequest.DEFAULT,
+            moveableId: this.moveableId,
+            value: speed,
+            toBinary() {
+                return requests.MoveableSetSettingRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/set_max_speed', request);
+    }
+    /**
+     * Returns the maximum acceleration of the moveable. For a lockstep group, returns the lowest value across all axes.
+     * @param options.accelType Which acceleration ramp to return. Defaults to AccelDecel.
+     * @param options.unit Units of acceleration. If not specified, the default acceleration unit is used.
+     * @returns Maximum acceleration.
+     */
+    async getMaxAcceleration(options = {}) {
+        const { accelType, unit, } = options;
+        const request = {
+            ...requests.MoveableGetAccelerationRequest.DEFAULT,
+            moveableId: this.moveableId,
+            accelType: accelType,
+            unit: unit,
+            toBinary() {
+                return requests.MoveableGetAccelerationRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/get_max_acceleration', request, requests.DoubleResponse.fromBinary);
+        return response.value;
+    }
+    /**
+     * Sets the maximum acceleration of the moveable. For a lockstep group, sets the value on all axes.
+     * @param accel Maximum acceleration to set.
+     * @param options.accelType Which acceleration ramp to set. Defaults to AccelDecel.
+     */
+    async setMaxAcceleration(accel, options = {}) {
+        const { accelType, } = options;
+        const request = {
+            ...requests.MoveableSetAccelerationRequest.DEFAULT,
+            moveableId: this.moveableId,
+            accel: accel,
+            accelType: accelType,
+            toBinary() {
+                return requests.MoveableSetAccelerationRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/set_max_acceleration', request);
+    }
+    /**
+     * Returns the minimum limit of the moveable.
+     * @param options.unit Units of position. If not specified, the default position unit is used.
+     * @returns Minimum limit.
+     */
+    async getLimitMin(options = {}) {
+        const { unit, } = options;
+        const request = {
+            ...requests.MoveableGetSettingRequest.DEFAULT,
+            moveableId: this.moveableId,
+            unit: unit,
+            toBinary() {
+                return requests.MoveableGetSettingRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/get_limit_min', request, requests.DoubleResponse.fromBinary);
+        return response.value;
+    }
+    /**
+     * Returns the maximum limit of the moveable.
+     * @param options.unit Units of position. If not specified, the default position unit is used.
+     * @returns Maximum limit.
+     */
+    async getLimitMax(options = {}) {
+        const { unit, } = options;
+        const request = {
+            ...requests.MoveableGetSettingRequest.DEFAULT,
+            moveableId: this.moveableId,
+            unit: unit,
+            toBinary() {
+                return requests.MoveableGetSettingRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/get_limit_max', request, requests.DoubleResponse.fromBinary);
+        return response.value;
+    }
+    /**
+     * Returns the lockstep group this moveable represents, or null if it is not a lockstep moveable.
+     * @returns Lockstep instance, or null if this is not a lockstep moveable.
+     */
+    async getLockstep() {
+        const request = {
+            ...requests.MoveableIdRequest.DEFAULT,
+            moveableId: this.moveableId,
+            toBinary() {
+                return requests.MoveableIdRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/get_lockstep', request, requests.IntResponse.fromBinary);
+        return response.value !== 0 ? new lockstep_1.Lockstep(this.device, response.value) : null;
+    }
+    /**
+     * Returns the axis this moveable represents.
+     * For a lockstep moveable, returns the primary axis of the lockstep group.
+     * @returns Axis this moveable is based on.
+     */
+    async getAxis() {
+        const request = {
+            ...requests.MoveableIdRequest.DEFAULT,
+            moveableId: this.moveableId,
+            toBinary() {
+                return requests.MoveableIdRequest.toBinary(this);
+            },
+        };
+        const response = await gateway.callAsync('moveable/get_axis', request, requests.IntResponse.fromBinary);
+        return new axis_1.Axis(this.device, response.value);
+    }
+    /**
+     * Disables the driver, which prevents current from being sent to the motor or load.
+     * If the driver is already disabled, the driver remains disabled.
+     */
+    async driverDisable() {
+        const request = {
+            ...requests.MoveableIdRequest.DEFAULT,
+            moveableId: this.moveableId,
+            toBinary() {
+                return requests.MoveableIdRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/driver_disable', request);
+    }
+    /**
+     * Attempts to enable the driver repeatedly for the specified timeout.
+     * If the driver is already enabled, the driver remains enabled.
+     * @param [options.timeout=10] Timeout in seconds. Specify 0 to attempt to enable the driver once.
+     */
+    async driverEnable(options = {}) {
+        const { timeout = 10, } = options;
+        const request = {
+            ...requests.MoveableDriverEnableRequest.DEFAULT,
+            moveableId: this.moveableId,
+            timeout: timeout,
+            toBinary() {
+                return requests.MoveableDriverEnableRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/driver_enable', request);
+    }
+    /**
+     * Waits until the moveable stops moving.
+     * @param [options.throwErrorOnFault=true] Determines whether to throw error when fault is observed.
+     */
+    async waitUntilIdle(options = {}) {
+        const { throwErrorOnFault = true, } = options;
+        const request = {
+            ...requests.MoveableWaitUntilIdleRequest.DEFAULT,
+            moveableId: this.moveableId,
+            throwErrorOnFault: throwErrorOnFault,
+            toBinary() {
+                return requests.MoveableWaitUntilIdleRequest.toBinary(this);
+            },
+        };
+        await gateway.callAsync('moveable/wait_until_idle', request);
+    }
+    /**
+     * Frees the moveable instance.
+     * @param moveableId The ID of the moveable to free.
+     */
+    static _free(moveableId) {
+        const request = {
+            ...requests.MoveableIdRequest.DEFAULT,
+            moveableId: moveableId,
+            toBinary() {
+                return requests.MoveableIdRequest.toBinary(this);
+            },
+        };
+        gateway.callSync('moveable/free', request);
+    }
+    /**
+     * Releases the native resources of the moveable.
+     * Should only be called if your environment does not support FinalizationRegistry.
+     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry
+     */
+    free() {
+        Moveable._free(this.moveableId);
+    }
+}
+exports.Moveable = Moveable;
+//# sourceMappingURL=moveable.js.map