spot-sdk-ts
Version:
TypeScript bindings based on protobufs (proto3) provided by Boston Dynamics
1,059 lines (1,058 loc) • 191 kB
TypeScript
import { RobotCommandFeedbackStatus_Status, ArmDragCommand_Request, ArmDragCommand_Feedback } from "./basic_command";
import { CylindricalCoordinate, Vec3, SE3Pose } from "./geometry";
import { SE3Trajectory, WrenchTrajectory, Vec3Trajectory } from "./trajectory";
import { Duration } from "../../google/protobuf/duration";
import _m0 from "protobufjs/minimal";
export declare const protobufPackage = "bosdyn.api";
/**
* The synchronized command message for commanding the arm to move.
* A synchronized commands is one of the possible robot command messages for controlling the robot.
*/
export interface ArmCommand {
}
/** The arm request must be one of the basic command primitives. */
export interface ArmCommand_Request {
/** Control the end-effector in Cartesian space. */
armCartesianCommand: ArmCartesianCommand_Request | undefined;
/** Control joint angles of the arm. */
armJointMoveCommand: ArmJointMoveCommand_Request | undefined;
/** Move the arm to some predefined configurations. */
namedArmPositionCommand: NamedArmPositionsCommand_Request | undefined;
/** Velocity control of the end-effector. */
armVelocityCommand: ArmVelocityCommand_Request | undefined;
/** Point the gripper at a point in the world. */
armGazeCommand: GazeCommand_Request | undefined;
/** Stop the arm in place with minimal motion. */
armStopCommand: ArmStopCommand_Request | undefined;
/** Use the arm to drag something held in the gripper. */
armDragCommand: ArmDragCommand_Request | undefined;
/** Any arm parameters to send, common across all arm commands */
params: ArmParams | undefined;
}
/**
* The feedback for the arm command that will provide information on the progress
* of the command.
*/
export interface ArmCommand_Feedback {
/** Feedback for the end-effector Cartesian command. */
armCartesianFeedback: ArmCartesianCommand_Feedback | undefined;
/** Feedback for the joint move command. */
armJointMoveFeedback: ArmJointMoveCommand_Feedback | undefined;
/** Feedback for the named position move command. */
namedArmPositionFeedback: NamedArmPositionsCommand_Feedback | undefined;
armVelocityFeedback: ArmVelocityCommand_Feedback | undefined;
/** Feedback for the gaze command. */
armGazeFeedback: GazeCommand_Feedback | undefined;
armStopFeedback: ArmStopCommand_Feedback | undefined;
/** Feedback for the drag command. */
armDragFeedback: ArmDragCommand_Feedback | undefined;
status: RobotCommandFeedbackStatus_Status;
}
/** Parameters common across arm commands. */
export interface ArmParams {
/**
* / Whether or not to disable the body force limiter running on the robot. By default, this is
* / on, and the chance that the body falls over because the arm makes contact in the world is
* / low. If this is purposely disabled (by setting disable_body_force_limiter to True), the arm
* / may be able to accelerate faster, and apply more force to the world and to objects than usual,
* / but there is also added risk of the robot falling over.
*/
disableBodyForceLimiter: boolean | undefined;
}
/**
* When controlling the arm with a joystick, because of latency it can often be better to send
* velocity commands rather than position commands. Both linear and angular velocity can be
* specified. The linear velocity can be specified in a cylindrical frame around the shoulder or
* with a specified frame.
*/
export interface ArmVelocityCommand {
}
export interface ArmVelocityCommand_CylindricalVelocity {
/**
* / The linear velocities for the end-effector are specified in unitless cylindrical
* / coordinates. The origin of the cylindrical coordinate system is the base of the arm
* / (shoulder). The Z-axis is aligned with gravity, and the X-axis is the unit vector from
* / the shoulder to the hand-point. This construction allows for 'Z'-axis velocities to
* / raise/lower the hand, 'R'-axis velocities will cause the hand to move towards/away from
* / the shoulder, and 'theta'-axis velocities will cause the hand to travel
* / clockwise/counter-clockwise around the shoulder. Lastly, the command is unitless, with
* / values for each axis specified in the range [-1, 1]. A value of 0 denotes no velocity
* / and values of +/- 1 denote maximum velocity (see max_linear_velocity).
*/
linearVelocity: CylindricalCoordinate | undefined;
/**
* / The maximum velocity in meters / second for the hand.
* / If unset and default value of 0 received, will set max_linear_velocity to 0.5 m/s.
*/
maxLinearVelocity: number | undefined;
}
export interface ArmVelocityCommand_CartesianVelocity {
/** The frame to express our velocities in */
frameName: string;
/** The x-y-z velocity of the hand (m/s) with respect to the frame */
velocityInFrameName: Vec3 | undefined;
}
export interface ArmVelocityCommand_Request {
cylindricalVelocity: ArmVelocityCommand_CylindricalVelocity | undefined;
cartesianVelocity: ArmVelocityCommand_CartesianVelocity | undefined;
/**
* The angular velocity of the hand frame measured with respect to the odom frame, expressed
* in the hand frame. A 'X' rate will cause the hand to rotate about its x-axis, e.g. the
* final wrist twist joint will rotate. And similarly, 'Y' and 'Z' rates will cause the hand
* to rotate about its y and z axis respectively. \
* The units should be rad/sec.
*/
angularVelocityOfHandRtOdomInHand: Vec3 | undefined;
/** Optional maximum acceleration magnitude of the end-effector. (m/s^2) */
maximumAcceleration: number | undefined;
/**
* The timestamp (in robot time) by which a command must finish executing.
* This is a required field and used to prevent runaway commands.
*/
endTime: Date | undefined;
}
/** ArmVelocityCommand provides no feedback */
export interface ArmVelocityCommand_Feedback {
}
/** Command the arm move to a predefined configuration. */
export interface NamedArmPositionsCommand {
}
export declare enum NamedArmPositionsCommand_Positions {
/** POSITIONS_UNKNOWN - Invalid request; do not use. */
POSITIONS_UNKNOWN = 0,
/**
* POSITIONS_CARRY - The carry position is a damped, force limited position close to stow, with the hand
* slightly in front of the robot.
*/
POSITIONS_CARRY = 1,
/**
* POSITIONS_READY - Move arm to ready position. The ready position is defined with the hand directly in
* front of and slightly above the body, with the hand facing forward in the robot body +X
* direction.
*/
POSITIONS_READY = 2,
/**
* POSITIONS_STOW - Stow the arm, safely. If the robot is holding something, it will freeze the arm instead
* of stowing. Overriding the carry_state to CARRY_STATE_CARRIABLE_AND_STOWABLE, will allow
* the robot to stow the arm while grasping an item.
*/
POSITIONS_STOW = 3,
UNRECOGNIZED = -1
}
export declare function namedArmPositionsCommand_PositionsFromJSON(object: any): NamedArmPositionsCommand_Positions;
export declare function namedArmPositionsCommand_PositionsToJSON(object: NamedArmPositionsCommand_Positions): string;
export interface NamedArmPositionsCommand_Request {
position: NamedArmPositionsCommand_Positions;
}
export interface NamedArmPositionsCommand_Feedback {
/** Current status of the request. */
status: NamedArmPositionsCommand_Feedback_Status;
}
export declare enum NamedArmPositionsCommand_Feedback_Status {
/** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
STATUS_UNKNOWN = 0,
/** STATUS_COMPLETE - The arm is at the desired configuration. */
STATUS_COMPLETE = 1,
/** STATUS_IN_PROGRESS - Robot is re-configuring arm to get to desired configuration. */
STATUS_IN_PROGRESS = 2,
/**
* STATUS_STALLED_HOLDING_ITEM - Some positions may refuse to execute if the gripper is holding an item, for example
* stow.
*/
STATUS_STALLED_HOLDING_ITEM = 3,
UNRECOGNIZED = -1
}
export declare function namedArmPositionsCommand_Feedback_StatusFromJSON(object: any): NamedArmPositionsCommand_Feedback_Status;
export declare function namedArmPositionsCommand_Feedback_StatusToJSON(object: NamedArmPositionsCommand_Feedback_Status): string;
/**
* Command the end effector of the arm. Each axis in the task frame is allowed to be set to
* position mode (default) or Force mode. If the axis is set to position, the desired value is read
* from the pose_trajectory_in_task. If the axis is set to force, the desired value is read from
* the wrench_trajectory. This supports hybrid control of the arm where users can specify, for
* example, Z to be in force control with X and Y in position control.
*/
export interface ArmCartesianCommand {
}
export interface ArmCartesianCommand_Request {
/**
* The root frame is used to set the optional task frame that all trajectories are
* specified with respect to. If the optional task frame is left un-specified it defaults
* to the identity transform and the root frame becomes the task frame.
*/
rootFrameName: string;
/**
* The tool pose relative to the parent link (wrist).
* Defaults to
* [0.19557 0 0]
* [1 0 0 0]
* a frame with it's origin slightly in front of the gripper's palm plate aligned with
* wrist's orientation.
*/
wristTformTool: SE3Pose | undefined;
/**
* The fields below are specified in this optional task frame. If unset it defaults
* to the identity transform and all quantities are therefore expressed in the
* root_frame_name.
*/
rootTformTask: SE3Pose | undefined;
/**
* A 3D pose trajectory for the tool expressed in the task frame, e.g. task_T_tool.
* This pose trajectory is optional if requesting a pure wrench at the end-effector,
* otherwise required for position or mixed force/position end-effector requests.
*/
poseTrajectoryInTask: SE3Trajectory | undefined;
/**
* Optional Maximum acceleration magnitude of the end-effector.
* Valid ranges (0, 20]
*/
maximumAcceleration: number | undefined;
/** Optional Maximum linear velocity magnitude of the end-effector. (m/s) */
maxLinearVelocity: number | undefined;
/** Optional Maximum angular velocity magnitude of the end-effector. (rad/s) */
maxAngularVelocity: number | undefined;
/**
* Maximum allowable tracking error of the tool frame from the desired trajectory
* before the arm will stop moving and cancel the rest of the trajectory. When this limit is
* exceeded, the hand will stay at the pose it was at when it exceeded the tracking error,
* and any other part of the trajectory specified in the rest of this message will be
* ignored. max position tracking error in meters
*/
maxPosTrackingError: number | undefined;
/** max orientation tracking error in radians */
maxRotTrackingError: number | undefined;
forceRemainNearCurrentJointConfiguration: boolean | undefined;
preferredJointConfiguration: ArmJointPosition | undefined;
xAxis: ArmCartesianCommand_Request_AxisMode;
yAxis: ArmCartesianCommand_Request_AxisMode;
zAxis: ArmCartesianCommand_Request_AxisMode;
rxAxis: ArmCartesianCommand_Request_AxisMode;
ryAxis: ArmCartesianCommand_Request_AxisMode;
rzAxis: ArmCartesianCommand_Request_AxisMode;
/**
* A force/torque trajectory for the tool expressed in the task frame.
* This trajectory is optional if requesting a pure pose at the end-effector,
* otherwise required for force or mixed force/position end-effector requests.
*/
wrenchTrajectoryInTask: WrenchTrajectory | undefined;
}
/**
* If an axis is set to position mode (default), read desired from SE3Trajectory trajectory
* command. If mode is set to Force, read desired from WrenchTrajectory wrench_trajectory
* command. This supports hybrid control of the arm where users can specify, for example, Z
* to be in force control with X and Y in position control. The elements are expressed in
* the same task_frame as the trajectories.
*/
export declare enum ArmCartesianCommand_Request_AxisMode {
AXIS_MODE_POSITION = 0,
AXIS_MODE_FORCE = 1,
UNRECOGNIZED = -1
}
export declare function armCartesianCommand_Request_AxisModeFromJSON(object: any): ArmCartesianCommand_Request_AxisMode;
export declare function armCartesianCommand_Request_AxisModeToJSON(object: ArmCartesianCommand_Request_AxisMode): string;
export interface ArmCartesianCommand_Feedback {
/** Current status of the pose trajectory. */
status: ArmCartesianCommand_Feedback_Status;
/** Current linear tracking error of the tool frame [meters]. */
measuredPosTrackingError: number;
/** Current rotational tracking error of the tool frame [radians]. */
measuredRotTrackingError: number;
/** Linear distance from the tool to the tool trajectory's end point [meters]. */
measuredPosDistanceToGoal: number;
/** Rotational distance from the tool to the trajectory's end point [radians]. */
measuredRotDistanceToGoal: number;
}
export declare enum ArmCartesianCommand_Feedback_Status {
/** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
STATUS_UNKNOWN = 0,
/** STATUS_TRAJECTORY_COMPLETE - Tool frame has reached the end of the trajectory within tracking error bounds. */
STATUS_TRAJECTORY_COMPLETE = 1,
/** STATUS_IN_PROGRESS - Robot is attempting to reach the target. */
STATUS_IN_PROGRESS = 2,
/** STATUS_TRAJECTORY_CANCELLED - Tool frame exceeded maximum allowable tracking error from the desired trajectory. */
STATUS_TRAJECTORY_CANCELLED = 3,
/**
* STATUS_TRAJECTORY_STALLED - The arm has stopped making progress to the goal. Note, this does not cancel the
* trajectory. For example, if the requested goal is too far away, walking the base
* robot closer to the goal will cause the arm to continue along the trajectory once the
* goal point is inside the workspace.
*/
STATUS_TRAJECTORY_STALLED = 4,
UNRECOGNIZED = -1
}
export declare function armCartesianCommand_Feedback_StatusFromJSON(object: any): ArmCartesianCommand_Feedback_Status;
export declare function armCartesianCommand_Feedback_StatusToJSON(object: ArmCartesianCommand_Feedback_Status): string;
/** Specify a set of joint angles to move the arm. */
export interface ArmJointMoveCommand {
}
export interface ArmJointMoveCommand_Request {
/**
* Note: Sending a single point empty trajectory will cause the arm to freeze in place. This
* is an easy way to lock the arm in its current configuration.
*/
trajectory: ArmJointTrajectory | undefined;
}
export interface ArmJointMoveCommand_Feedback {
/** Current status of the request. */
status: ArmJointMoveCommand_Feedback_Status;
/** Current status of the trajectory planner. */
plannerStatus: ArmJointMoveCommand_Feedback_PlannerStatus;
/**
* Based on the user trajectory, the planned knot points that obey acceleration and
* velocity constraints. If these knot points don't match the requested knot points,
* consider increasing velocity/acceleration limits, and/or staying further away from
* joint position limits. In situations where we've modified you last point, we append
* a minimum time trajectory (that obeys the velocity and acceleration limits) from the
* planner's final point to the requested final point. This means that the length of
* planned_points may be one point larger than the requested.
*/
plannedPoints: ArmJointTrajectoryPoint[];
/**
* Returns amount of time remaining until the joints are at the goal position. For
* multiple point trajectories, this is the time remaining to the final point.
*/
timeToGoal: Duration | undefined;
}
export declare enum ArmJointMoveCommand_Feedback_Status {
/** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened */
STATUS_UNKNOWN = 0,
/** STATUS_COMPLETE - The arm is at the desired configuration. */
STATUS_COMPLETE = 1,
/** STATUS_IN_PROGRESS - Robot is re-configuring arm to get to desired configuration. */
STATUS_IN_PROGRESS = 2,
UNRECOGNIZED = -1
}
export declare function armJointMoveCommand_Feedback_StatusFromJSON(object: any): ArmJointMoveCommand_Feedback_Status;
export declare function armJointMoveCommand_Feedback_StatusToJSON(object: ArmJointMoveCommand_Feedback_Status): string;
export declare enum ArmJointMoveCommand_Feedback_PlannerStatus {
/** PLANNER_STATUS_UNKNOWN - PLANNER_STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
PLANNER_STATUS_UNKNOWN = 0,
/** PLANNER_STATUS_SUCCESS - A solution passing through the desired points and obeying the constraints was found. */
PLANNER_STATUS_SUCCESS = 1,
/**
* PLANNER_STATUS_MODIFIED - The planner had to modify the desired points in order to obey the constraints. For
* example, if you specify a 1 point trajectory, and tell it to get there in a really short
* amount of time, but haven't set a high allowable max velocity / acceleration, the planner
* will do its best to get as close as possible to the final point, but won't reach it. In
* situations where we've modified you last point, we append a minimum time trajectory (that
* obeys the velocity and acceleration limits) from the planner's final point to the requested
* final point.
*/
PLANNER_STATUS_MODIFIED = 2,
/**
* PLANNER_STATUS_FAILED - Failed to compute a valid trajectory, will go to first point instead. It is possible
* that our optimizer till fail to solve the problem instead of returning a sub-optimal
* solution. This is un-likely to occur.
*/
PLANNER_STATUS_FAILED = 3,
UNRECOGNIZED = -1
}
export declare function armJointMoveCommand_Feedback_PlannerStatusFromJSON(object: any): ArmJointMoveCommand_Feedback_PlannerStatus;
export declare function armJointMoveCommand_Feedback_PlannerStatusToJSON(object: ArmJointMoveCommand_Feedback_PlannerStatus): string;
/**
* Position of our 6 arm joints in radians. If a joint angle is not specified,
* we will use the joint position at time the message is received on robot.
*/
export interface ArmJointPosition {
sh0: number | undefined;
sh1: number | undefined;
el0: number | undefined;
el1: number | undefined;
wr0: number | undefined;
wr1: number | undefined;
}
/**
* Velocity of our 6 arm joints in radians / second. If a velocity
* for a joint is specified, velocities for all joints we are
* trying to move must be specified.
*/
export interface ArmJointVelocity {
sh0: number | undefined;
sh1: number | undefined;
el0: number | undefined;
el1: number | undefined;
wr0: number | undefined;
wr1: number | undefined;
}
/** A set of joint angles and velocities that can be used as a point within a joint trajectory. */
export interface ArmJointTrajectoryPoint {
/** Desired joint angles in radians */
position: ArmJointPosition | undefined;
/** Optional desired joint velocities in radians / sec */
velocity: ArmJointVelocity | undefined;
/** The time since reference at which we wish to achieve this position / velocity */
timeSinceReference: Duration | undefined;
}
/**
* This allows a user to move the arm's joints directly. Each of the arm's joints will never move
* faster than maximum_velocity and never accelerate faster than maximum_acceleration. The user can
* specify a trajectory of joint positions and optional velocities for the arm to follow. The
* trajectory will be acted upon as follows. If a single trajectory point with no time is provided,
* the arm will take the joint currently furthest away from the goal pose and plan a minimum time
* trajectory such that the joint accelerates at maximum_acceleration, coasts at maximum_velocity,
* and decelerates at maximum_acceleration. The other joints will accelerate at
* maximum_acceleration, but then coast at a slower speed such that all joints arrive at the goal
* pose simultaneously with zero velocity. If the user provides trajectory times, the robot will fit
* a piece-wise cubic trajectory (continuous position and velocity) to the user's requested
* positions and (optional) velocities. If the requested trajectory is not achievable because it
* will violate position limits or the maximum_velocity or maximum_acceleration, the robot will pick
* a trajectory that is as close as possible to the user requested without violating velocity or
* acceleration limits.
*
* If the robot is not hitting the desired trajectory, try increasing the time between knot points,
* increasing the max velocity and acceleration, or only specifying joint position goals without a
* velocity
*/
export interface ArmJointTrajectory {
/** The points in our trajectory. (positions, (optional) velocity, (optional) time) */
points: ArmJointTrajectoryPoint[];
/**
* All trajectory points specify times relative to this reference time. The reference
* time should be in robot clock. If this field is not included, this time will be
* the receive time of the command.
*/
referenceTime: Date | undefined;
/**
* The maximum velocity in rad/s that any joint is allowed to achieve.
* If this field is not set, a default value will be used.
*/
maximumVelocity: number | undefined;
/**
* The maximum acceleration in rad/s^2 that any joint is allowed to
* achieve. If this field is not set, a default value will be used.
*/
maximumAcceleration: number | undefined;
}
/** / Move the hand in such a way to point it at a position in the world. */
export interface GazeCommand {
}
export interface GazeCommand_Request {
/** Point(s) to look at expressed in frame1. */
targetTrajectoryInFrame1: Vec3Trajectory | undefined;
frame1Name: string;
/**
* Optional, desired pose of the tool expressed in frame2. Will be constrained to 'look at'
* the target regardless of the requested orientation.
*/
toolTrajectoryInFrame2: SE3Trajectory | undefined;
frame2Name: string;
/**
* The transformation of the tool pose relative to the parent link (wrist).
* If the field is left unset, the transform will default to:
* The position is wrist_tform_hand.position() [20 cm translation in wrist x].
* The rotation is wrist_tform_hand_camera.rotation() [-9 degree pitch about wrist y].
*/
wristTformTool: SE3Pose | undefined;
/**
* Optional velocity to move the target along the shortest path from the gaze's starting
* position to the first point in the target trajectory.
*/
targetTrajectoryInitialVelocity: number | undefined;
/**
* Optional Maximum acceleration magnitude of the end-effector.
* Valid ranges (0, 20]
*/
maximumAcceleration: number | undefined;
/** Optional Maximum linear velocity magnitude of the end-effector. (m/s) */
maxLinearVelocity: number | undefined;
/** Optional Maximum angular velocity magnitude of the end-effector. (rad/s) */
maxAngularVelocity: number | undefined;
}
export interface GazeCommand_Feedback {
/** Current status of the command. */
status: GazeCommand_Feedback_Status;
/**
* If we are gazing at the target
* Rotation from the current gaze point to the trajectory's end [radians]
*/
gazingAtTarget: boolean;
gazeToTargetRotationMeasured: number;
/**
* If the hand's position is at the goal.
* Distance from the hand's current position to the trajectory's end [meters]
*/
handPositionAtGoal: boolean;
handDistanceToGoalMeasured: number;
/**
* If the hand's roll is at the goal.
* Rotation from the current hand position to the desired roll at the trajectory's end
* [radians]
*/
handRollAtGoal: boolean;
handRollToTargetRollMeasured: number;
}
export declare enum GazeCommand_Feedback_Status {
/** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
STATUS_UNKNOWN = 0,
/** STATUS_TRAJECTORY_COMPLETE - Robot is gazing at the target at the end of the trajectory. */
STATUS_TRAJECTORY_COMPLETE = 1,
/** STATUS_IN_PROGRESS - Robot is re-configuring arm to gaze at the target. */
STATUS_IN_PROGRESS = 2,
/**
* STATUS_TOOL_TRAJECTORY_STALLED - The arm has stopped making progress to the goal pose for the tool.
* Note, this does not cancel the trajectory. For example, if the requested goal is too
* far away, walking the base robot closer to the goal will cause the arm to continue
* along the trajectory once it can continue.
*/
STATUS_TOOL_TRAJECTORY_STALLED = 3,
UNRECOGNIZED = -1
}
export declare function gazeCommand_Feedback_StatusFromJSON(object: any): GazeCommand_Feedback_Status;
export declare function gazeCommand_Feedback_StatusToJSON(object: GazeCommand_Feedback_Status): string;
/**
* Stop the arm applying minimal forces to the world. For example, if the arm is in the middle of
* opening a heavy door and a stop command is sent, the arm will comply and let the door close.
*/
export interface ArmStopCommand {
}
/** Stop command takes no arguments. */
export interface ArmStopCommand_Request {
}
/** Stop command provides no feedback */
export interface ArmStopCommand_Feedback {
}
export declare const ArmCommand: {
encode(_: ArmCommand, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ArmCommand;
fromJSON(_: any): ArmCommand;
toJSON(_: ArmCommand): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): ArmCommand;
};
export declare const ArmCommand_Request: {
encode(message: ArmCommand_Request, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ArmCommand_Request;
fromJSON(object: any): ArmCommand_Request;
toJSON(message: ArmCommand_Request): unknown;
fromPartial<I extends {
armCartesianCommand?: {
rootFrameName?: string | undefined;
wristTformTool?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
rootTformTask?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
poseTrajectoryInTask?: {
points?: {
pose?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
velocity?: {
linear?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
angular?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
}[] | undefined;
referenceTime?: Date | undefined;
posInterpolation?: import("./trajectory").PositionalInterpolation | undefined;
angInterpolation?: import("./trajectory").AngularInterpolation | undefined;
} | undefined;
maximumAcceleration?: number | undefined;
maxLinearVelocity?: number | undefined;
maxAngularVelocity?: number | undefined;
maxPosTrackingError?: number | undefined;
maxRotTrackingError?: number | undefined;
forceRemainNearCurrentJointConfiguration?: boolean | undefined;
preferredJointConfiguration?: {
sh0?: number | undefined;
sh1?: number | undefined;
el0?: number | undefined;
el1?: number | undefined;
wr0?: number | undefined;
wr1?: number | undefined;
} | undefined;
xAxis?: ArmCartesianCommand_Request_AxisMode | undefined;
yAxis?: ArmCartesianCommand_Request_AxisMode | undefined;
zAxis?: ArmCartesianCommand_Request_AxisMode | undefined;
rxAxis?: ArmCartesianCommand_Request_AxisMode | undefined;
ryAxis?: ArmCartesianCommand_Request_AxisMode | undefined;
rzAxis?: ArmCartesianCommand_Request_AxisMode | undefined;
wrenchTrajectoryInTask?: {
points?: {
wrench?: {
force?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
torque?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
}[] | undefined;
referenceTime?: Date | undefined;
} | undefined;
} | undefined;
armJointMoveCommand?: {
trajectory?: {
points?: {
position?: {
sh0?: number | undefined;
sh1?: number | undefined;
el0?: number | undefined;
el1?: number | undefined;
wr0?: number | undefined;
wr1?: number | undefined;
} | undefined;
velocity?: {
sh0?: number | undefined;
sh1?: number | undefined;
el0?: number | undefined;
el1?: number | undefined;
wr0?: number | undefined;
wr1?: number | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
}[] | undefined;
referenceTime?: Date | undefined;
maximumVelocity?: number | undefined;
maximumAcceleration?: number | undefined;
} | undefined;
} | undefined;
namedArmPositionCommand?: {
position?: NamedArmPositionsCommand_Positions | undefined;
} | undefined;
armVelocityCommand?: {
cylindricalVelocity?: {
linearVelocity?: {
r?: number | undefined;
theta?: number | undefined;
z?: number | undefined;
} | undefined;
maxLinearVelocity?: number | undefined;
} | undefined;
cartesianVelocity?: {
frameName?: string | undefined;
velocityInFrameName?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
} | undefined;
angularVelocityOfHandRtOdomInHand?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
maximumAcceleration?: number | undefined;
endTime?: Date | undefined;
} | undefined;
armGazeCommand?: {
targetTrajectoryInFrame1?: {
points?: {
point?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
linearSpeed?: number | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
}[] | undefined;
referenceTime?: Date | undefined;
posInterpolation?: import("./trajectory").PositionalInterpolation | undefined;
startingVelocity?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
endingVelocity?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
} | undefined;
frame1Name?: string | undefined;
toolTrajectoryInFrame2?: {
points?: {
pose?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
velocity?: {
linear?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
angular?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
}[] | undefined;
referenceTime?: Date | undefined;
posInterpolation?: import("./trajectory").PositionalInterpolation | undefined;
angInterpolation?: import("./trajectory").AngularInterpolation | undefined;
} | undefined;
frame2Name?: string | undefined;
wristTformTool?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
targetTrajectoryInitialVelocity?: number | undefined;
maximumAcceleration?: number | undefined;
maxLinearVelocity?: number | undefined;
maxAngularVelocity?: number | undefined;
} | undefined;
armStopCommand?: {} | undefined;
armDragCommand?: {} | undefined;
params?: {
disableBodyForceLimiter?: boolean | undefined;
} | undefined;
} & {
armCartesianCommand?: ({
rootFrameName?: string | undefined;
wristTformTool?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
rootTformTask?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
poseTrajectoryInTask?: {
points?: {
pose?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
velocity?: {
linear?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
angular?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
}[] | undefined;
referenceTime?: Date | undefined;
posInterpolation?: import("./trajectory").PositionalInterpolation | undefined;
angInterpolation?: import("./trajectory").AngularInterpolation | undefined;
} | undefined;
maximumAcceleration?: number | undefined;
maxLinearVelocity?: number | undefined;
maxAngularVelocity?: number | undefined;
maxPosTrackingError?: number | undefined;
maxRotTrackingError?: number | undefined;
forceRemainNearCurrentJointConfiguration?: boolean | undefined;
preferredJointConfiguration?: {
sh0?: number | undefined;
sh1?: number | undefined;
el0?: number | undefined;
el1?: number | undefined;
wr0?: number | undefined;
wr1?: number | undefined;
} | undefined;
xAxis?: ArmCartesianCommand_Request_AxisMode | undefined;
yAxis?: ArmCartesianCommand_Request_AxisMode | undefined;
zAxis?: ArmCartesianCommand_Request_AxisMode | undefined;
rxAxis?: ArmCartesianCommand_Request_AxisMode | undefined;
ryAxis?: ArmCartesianCommand_Request_AxisMode | undefined;
rzAxis?: ArmCartesianCommand_Request_AxisMode | undefined;
wrenchTrajectoryInTask?: {
points?: {
wrench?: {
force?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
torque?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
}[] | undefined;
referenceTime?: Date | undefined;
} | undefined;
} & {
rootFrameName?: string | undefined;
wristTformTool?: ({
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} & {
position?: ({
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} & {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} & { [K in Exclude<keyof I["armCartesianCommand"]["wristTformTool"]["position"], keyof Vec3>]: never; }) | undefined;
rotation?: ({
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} & {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} & { [K_1 in Exclude<keyof I["armCartesianCommand"]["wristTformTool"]["rotation"], keyof import("./geometry").Quaternion>]: never; }) | undefined;
} & { [K_2 in Exclude<keyof I["armCartesianCommand"]["wristTformTool"], keyof SE3Pose>]: never; }) | undefined;
rootTformTask?: ({
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} & {
position?: ({
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} & {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} & { [K_3 in Exclude<keyof I["armCartesianCommand"]["rootTformTask"]["position"], keyof Vec3>]: never; }) | undefined;
rotation?: ({
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} & {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} & { [K_4 in Exclude<keyof I["armCartesianCommand"]["rootTformTask"]["rotation"], keyof import("./geometry").Quaternion>]: never; }) | undefined;
} & { [K_5 in Exclude<keyof I["armCartesianCommand"]["rootTformTask"], keyof SE3Pose>]: never; }) | undefined;
poseTrajectoryInTask?: ({
points?: {
pose?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
velocity?: {
linear?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
angular?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
}[] | undefined;
referenceTime?: Date | undefined;
posInterpolation?: import("./trajectory").PositionalInterpolation | undefined;
angInterpolation?: import("./trajectory").AngularInterpolation | undefined;
} & {
points?: ({
pose?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
velocity?: {
linear?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
angular?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
}[] & ({
pose?: {
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
w?: number | undefined;
} | undefined;
} | undefined;
velocity?: {
linear?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
angular?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
} & {
pose?: ({
position?: {
x?: number | undefined;
y?: number | undefined;
z?: number | undefined;
} | undefined;
rotation?: {
x?: number | undefined;
y?: number | undefined;