Page Comparison

Table of Contents

Revisions

...

2023/07/14: (2.5) Added validation argument to UpdateTarget command
2023/07/19: (2.5) Added BlockMove + ContinueMove commands (more details to come), also updated CombinedMove with new optional blockMove argument
2023/08/02: (2.5) Updated Move command with a new argument constraint.
2023/08/09: (2.5) Correction of the preset-switching behavior in a CombinedMove command.
2023/08/10: (2.5) Updated name of HoldMove and ResumeMove commands (prev. block/continue)
2023/08/11: (2.5) Added MultiRobotMove command and updated SetAlternateLocation with a new mode multirobot.
2023/09/22: (2.5) Replaced Move command argument constraint with constraints.
2023/09/28: (2.5) Add documentation about yaml parsing per RAPID-38095
2023/11/14: (2.6) Added IsOnTarget command

Goal

...

2023/11/29: (2.6) Removed MultiRobotMove command
2023/11/29: (2.6) Added support for roadmap + planning moves to configs
2023/11/29: (2.6) Added Move command optional parameter roadmap_mode to define how the robot should use the roadmap + off-roadmap motions for roadmap moves to a pose or joint config
2023/11/29: (2.6) Added new Move goal type route
2023/12/21: (2.6) Added BeginMotionRecording, EndMotionRecording and CancelMotionRecording commands
2024/02/08: (2.6) Clarify that Move Costs sum is not constrained by the api
2024/03/04: (2.6) Added clarifying details to SetAlternateLocation “timeout” parameter

Goal

The ASCII API is a fundamental component of how a user interacts with the Realtime Controller and ultimately controls a robot. In order to effectively complete a task, the user must be able to retrieve information from the Rapidplan Create project, set behavioral characteristics of the robots, and move the robots either following the offline motion plans or with conventional move types.

The 2.0 ASCII API re-implements commands from the 1.x.x version with simplifications, renaming, and overall improvements. Most importantly, the request syntax changed to inline YAML, so that in future 2.x.x versions more functionality can be added while maintaining backwards compatibility. The key value structure will also make messages more readable, and easier to format. Requests can be returned in the same inline YAML format, or the same CSV response type as 1.x.x. versions.

...

Structure

Code Block
{topic: ClearFaults, data: {reset_connection: <value>}}

Argument Description

reset_connection: [ OPTIONAL ] This indicates whether a ClearFaults command will reconnect to the robot controller after the command is issued. The default value is true.

Function Description

If a robot error/fault state occurs for one of the robots in the currently loaded deconfliction group, the Realtime Controller will enter a fault state. Examples of reasons may be: lost connection to a robot due to an E-stop, or the robot entering a fault state due to excessive speed or force. The ClearFaults command will attempt to recover any faults that the OEM controller allows allows to be cleared programmatically, and transition the Controller back into Config mode if possible. It will fail if there are still active, unresolvable faults.

If reset_connection is true(default value), the Realtime Controller will attempt to reconnect to the robot controller after recovering from a fault state. If reset_connection is false, an explicit Connect ASCII call would be required prior to entering Operation mode.

Response Details

This command will return a single response code as a result value.

Example Request

Code Block
{topic: ClearFaults}

Example Responses

Code Block
{topic: ClearFaults,type: Response} {topic: ClearFaults,type: Response,error: {code:1004,msg:FAILED_TO_CLEAR_FAULTS}}

...

Structure

Code Block
{topic: LoadProject,data: {project_name: <value>, upgrade: <value>}}

Argument Description

project_name: The name of the project installed on the control panel that you want to load.

upgrade: [ OPTIONAL ] A boolean value that decides if the installed RPC project is from an earlier release version, it will be upgraded for compatibility. Default value is True.

Function Description

This function loads an RPC project. A load result will be returned once the process has finished and then RapidPlan will be in configuration mode.

Response Details

This command will return a response code to acknowledge the command has been received.

Code Block
{topic: LoadProject,type: Response,data: {seq: <value>}}

Delayed Response Details

Once the load is completed, the system will send a delayed response to indicate the project has finished loading.

Code Block
{topic: LoadProject,type: DelayedResponse,data: {seq: <value>}}

Example Request

Code Block
{topic: LoadProject,data: {project_name: DemoProject}}

Example YAML Responses

Code Block
{topic: LoadProject,type: Response,data: {seq: 128}} … load executes … {topic: LoadProject,type: DelayedResponse,data: {seq: 128}}

Example CSV Responses

Code Block
LoadProject,0,128 … load executes … LoadProjectResult,0,128

...

Structure

Code Block
{topic: SetDefaultProject,data: {project_name: <value>}}

Argument Description

project_name:[ OPTIONAL ] This indicates which project will be made the default project. If this argument is omitted, any previous setting will be cleared and no project will be the default.

Function Description

This command is used to define which project is the Default project that will automatically be loaded when RapidPlan powers on or is otherwise not in Operation Mode.

Sending a SetDefaultProject command without specifying the project_name parameter will clear any previous setting.

Response Details

This command will return a response to acknowledge the command has been received and executed successfully.

Example Request

Code Block
{topic: SetDefaultProject,data: {project_name: DemoProject}}

or

Code Block
{topic: SetDefaultProject}

Example YAML Responses

Code Block
{topic: SetDefaultProject,type: Response}

Example CSV Responses

Code Block
SetDefaultProject,0

...

Structure

Code Block
{topic: EnterOperationMode, data:{connect: true}}

Argument Description

connect [ OPTIONAL ]: this boolean argument, if true, will attempt to connect to all robots upon entering before attempting to enter Operation mode. Default is false.

Function Description

This command indicates that the project is ready to begin operationAttempts to put the controller into Operation mode. This call is blocking, until all active robots have been connected. Once all participating robots have indicated readiness, return messages will be sent, and subsequent Move calls will be accepted.

Response Details

This command will return a response to acknowledge the command has been received and executed successfully.

Example Request

Code Block
{topic: EnterOperationMode}

Example YAML Responses

Code Block
{topic: EnterOperationMode,type: Response}

Example CSV Responses

Code Block
EnterOperationMode,0

...

Structure

Code Block
{topic: ActivateRobots,data: {robot_names: <value>, project_name: <value>}}

Argument Description

robot_names: [ OPTIONAL ] An array specifying which robots should be activated. If not passed, all inactive robots in the project will be activated.

project_name: [ OPTIONAL ] The name of the project you’d like to activate the robot in. This is required if the robot you want to deactivate is not in the loaded project.

Function Description

This command will re-activate a robot. After this command, when Connect is called, the activated robot will be connected to, and when in OPERATION mode this robot will be controlled by RTR.
This command must be called when the controller is in CONFIG mode.

Response Details

This command will return a response to acknowledge the command has been received and executed successfully.

Example Request

Code Block
{topic: ActivateRobots} {topic: ActivateRobots, data: {project_name: Proj1, robot_names: [Robot2]}}

Example YAML Response

Code Block
{topic: ActivateRobots,type: Response}

Example CSV Response

Code Block
ActivateRobots,0

...

Structure

Code Block
{topic: DeactivateRobot,data: {robot_name: <value>, treat_as_obstacle: <value>,joint_config: <value>,target_name: <value>,preset_name: <value>}}

Argument Description

robot_name: Specifies which robot should be deactivated.
project_name: [ OPTIONAL ] The name of the project you’d like to deactivate the robot in. This is required if the robot you want to deactivate is not in the loaded project. If the project is not loaded robot_name is the only other valid key.
preset_name: [ OPTIONAL ] A string specifying the preset of the robot to be used in the inactive state. The preset will determine the collision geometry as well as the number of joints. If not specified, the active preset will be used.

treat_as_obstacle: [ OPTIONAL ] A boolean value that specifies if the deactivated robot should be treated for collisions by the other robots in the work cell. Default value is true.
If treat_as_obstacle is enabled, then the following keys are mutually exclusive to specify the behavior of the deactivated robot:

joint_config: An array of floats specifying the angle for each joint of the robot. If the robot’s preset includes user defined joints, they must be provided as well, sorted by the driver index.
target_name: A string specifying the name of the target that the robot will be positioned at. A user is also able to update a deactivated robot position using DeactivateRobot command with a new target specified by target_name: <new target> and treat_as_obstacle: True.
use_last_known_config: Default option. A boolean flag that specifies the last known joint configuration of the robot should be used. A robot must have been Connected at least once for there to be known joint angles. These values are saved to disk, so on project reload, this option can still be used.

Function Description

This command ‘deactivates’ a robot which means the RTR controller will ignore it when connecting to the robots within a project. Subsequent Connect commands will only connect to activated robots, and when in Operation mode, only the activated robots will be controlled by RTR. In order to prevent collisions, the deactivated robots can be configured for collision checking by setting the appropriate preset and joint angles. Optionally, the robot can be ignored during collision checking if it is not present in the workcell.
This command must be called when the controller is in CONFIG mode.

Response Details

This command will return a response to acknowledge the command has been received and executed successfully.

Example Request

Code Block

{topic: DeactivateRobot, data: {robot_name: Robot2}}
{topic: DeactivateRobot, data: {robot_name: Robot2, preset_name: gripper_open, treat_as_obstacle: true, use_last_known_config: true}}
{topic: DeactivateRobot, data: {robot_name: Robot2, project_name: Project1}}

Example YAML Response

Code Block
{topic: DeactivateRobot,type: Response}

Example CSV Response

Code Block
DeactivateRobot,0

...

Structure

Code Block
{topic: SetAlternateLocation,data: {robot_name: <value>,enabled: <value>,target_name: <value>,complete_move: <value>, timeout: <value>}}

Argument Description

robot_name: This indicates which robot this call pertains to .
enabled: Accepts 0 to disable alternate behavior or 1 to enable alternate behavior at the specified goal. If enabled is being set to 0, no other arguments are required.

complete_move: [ OPTIONAL ] Default value is 1 or true. This Boolean specifies if the robot should continuously try to plan a motion to the original goal after it has successfully moved to the alternate location. If true, a robot for which a move timed out will first move to the alternate location. If this alternate move is successful it will continuously try to plan a motion from the alternate location to the original move request location. If False, a robot for which a move timed out will move to the alternate location and wait there for the next command.

mode: [ OPTIONAL ] Specifies what the robot should do if the original motion fails.

0: Default behavior. Move to a different, specified, position.
1: Partial Execution. If this option is selected, the robot will move along its path as far as it can before a robot-based obstruction is present. If the obstruction is removed before deceleration, the robot will not stop at this point and continue smoothly towards the goal. If the obstruction is still present, the robot will come to a stop and automatically resume motion when the robot-based obstruction is removed. This behavior does not trigger for static-obstacle obstructions. When Partial Execution is enabled, complete_move is always set to true.
multirobot: If this option is selected, the robot will automatically be entered into a multi robot plan to try to get out of deadlock. Only other robots that are also configured to use multirobot avoidance will be used in this planning.

goal: [ OPTIONAL ] If mode is set to 0, this argument specifies the position that will act as the alternate position for the specified robot. Goal is a placeholder, and the actual key value pair would correspond to the acceptable positions which are:

target_name: <target_name>
pose: [x,y,z,r,p,y]

timeout: [ OPTIONAL ] -1 or 0.05 to 1000. Default value is -1. A value of -1 indicates infinite time. OtherwiseThis value indicates how long the Realtime Controller should continue planning to find a alternative path if a path can not be found. When Partial Execution is enabled, this value specifies the time a robot waits for to finish the next partial move.

Function Description

This command is used to enable and set the alternate location for a robot. With this feature enabled, in the event a Move command fails or is interrupted, the Realtime Controller will not return a response code immediately, and will instead automatically plan to the specified alternate position. Depending on the behavior of complete move the Realtime Controller will either return a response Error code indicating the robot reached the alternate location, or continue to plan to the location that was first specified in the move command.
Only one target can be set as the alternate location, so if that target does not exist in all of the robots presets, when a preset it changed, the alternate location should be updated.
Enabling the alternate location behavior changes the way a robot will execute a move, therefore a SetAlternateLocation command can only be sent while a robot is stationary and while the Realtime Controller is in either CONFIG or OPERATION mode.
When this behavior is enabled, the robot will execute motions using the same parameters as the original move. For example, if a move is sent using move_type: roadmap then the robot will make a roadmap move to the alternate location. If the original move is a move_type: direct then a direct move will be made to the alternate location.
When partial execution is enabled (mode: 1) or the default behavior (mode: 0) with complete move enabled, the timeout value is used.

Response Details

This command will return a response to acknowledge the command has been received and executed successfully.

Example Request

Code Block

// To enable an alternate position for the robot to move to in the event the original move fails
{topic: SetAlternateLocation,data: {robot_name: robot_1,enabled: 1,target_name: pounce, complete_move: 1}}

// To enable the partial move behavior where a robot will move as far as it can and then wait until the path is free
{topic: SetAlternateLocation,data: {robot_name: robot_1,enabled: 1,mode: 1}}

// To enable multi robot move behavior
{topic: SetAlternateLocation, data: {robot_name: robot_1,enabled: 1,mode: multirobot}}

// To disable any alternate location behavior
{topic: SetAlternateLocation,data: {robot_name: robot_1,enabled: 0}}

Example Responses

Code Block
{topic: SetAlternateLocation,type: Response}

Example CSV Responses

Code Block
SetAlternateLocation,0

...

Structure

Code Block

{topic: Move,data: {robot_name: <value>,goal: <values>,speed: <value>,move_type: <value>,smoothing: <value>,interp: <value>,collision_check: <value>,collision_check_dsm: <value>,timeout: <value>,relative: <value>,ref_frame: <value>,preset_name: <value>, trigger: {name: <value>, output: <value>, time: <value>}, external_axes: {<axis name 1>: active, <axis name 2>: <value>}, costs: {external_axis: <value>, path_length: <value>, via_points: <value>}}

Argument Description

robot_name: The name of the robot controlled by the Move command.

goal: Where the robot will move to, either a target or pose or , joint configuration or along a route. Goal is a placeholder key, and the acceptable keys are either pose or target or , joint_config. The target value can be a named target or route. The goal may include external axes that are specified as part of a named target or a joint configuration, or as external_axes of a pose move. Unless the external axes value is provided as an argument in external_axes, external axes will either remain fixed during a move, or switch to different setpoint values defined by roadmap moves. Valid key values are as following,

target: target_name

pose: [x,y,z,r,p,y]

or target: target_name or

joint_config: [j1, j2, j3, j4, j5, j6] to move robot native joints, or [j1, j2, j3, j4, j5, j6, j7, j8...] to move robot pose + external joints

.

speed: The speed at which the robot will move on a scale from 0.01 to 1.0. This scales max velocity but not acceleration or jerk.

move_type: [ OPTIONAL ] The type of move the robot will make

route: route_name, the following error codes may be sent in response
- ROUTE_NOT_FOUND: If no route with the defined name exists in the project
- ROUTE_NOT_IN_ROBOT: If the named route does not belong to the specified robot
- ROUTE_NOT_IN_PRESET If the named route is not in the current (or requested preset, if exists)

speed: The speed at which the robot will move on a scale from 0.01 to 1.0. This scales max velocity but not acceleration or jerk.

move_type: [ OPTIONAL ] The type of move the robot will make. Either direct, roadmap, or planning. Default move type is a roadmap move. The arguments are case insensitive or can use the assigned numeric value.

0 or direct
1 or roadmap
2 or planning

smoothing: [ OPTIONAL ] A value from 0.0 mm to 500 mm indicating how far from a node the robot should attempt to begin smoothing its trajectory. Default value is 0.0 mm. Note that a higher smoothing value does not necessarily mean faster movement.

interp: [ OPTIONAL ] Specifies the interpolation type for the robot when making a direct move, or any time it must leave the roadmap. Use the case insensitive string, or its integer equivalent to specify joint or linear interpolation. This parameter does not apply to a planning move. Default is joint space interpolation.

0 or J (default)
1 or L

collision_check: [ OPTIONAL ] This flag overrides collision checking against the static scene for Direct move types. Robot to robot collisions will always be checked regardless of this flag, but robot self collisions will not be checked. A value of 1 specifies collisions should be checked, and a value of 0 specifies collisions will not be checked. Default value is 1.

collision_check_dsm: [ OPTIONAL ] This flag overrides collision checking against the dynamic scene model for Direct move types. A value of 1 specifies collisions should be checked, and a value of 0 specifies collisions will not be checked. Default value is 1.

timeout: [ OPTIONAL ] This timeout only applies to planning move types when the interrupt behavior is not applicable. This value is the amount of time given to plan a path to the specified goal, in seconds. If not provided, the default value is 10 seconds. The minimum value is 0.01 seconds and the maximum value is 120.0 seconds.

relative: [ OPTIONAL ] A boolean flag indicating that a pose or joint_config move should be performed relative to the last commanded robot pose or joint configuration. Default value is false. All move types are supported when using the relative flag. A reference frame name, ref_frame, can be specified as well for the pose to be in.

A relative move can be performed on all robot joints and external axes if it’s a direct, joint_config or a pose move. A full joint configuration including external axes, e.g., [j1, j2, j3, j4, j5, j6, j7, j8...], or, a full pose including external axes, e.g., pose: [0,0,0,0,0,0], external_axes: {rail: 50}}, should be given to specify a relative direct move. Multi-axis relatives are supported.

ref_frame: [ OPTIONAL ] The name of a frame in the RPC project that should be used as a reference for relative moves. The goal type should be a pose and relative should be set to false or not specified. The robot will move to the pose relative to the frame specified. The default reference frame is world.

preset_name: [ OPTIONAL ] This argument specifies which preset the robot should switch to before executing the motion. Including this argument has the same effect as calling SetRobotPreset before the Move command. If included, the robot cannot have any moves in its queue with a different TCP or number of controlled axes.

external_axes: [ OPTIONAL ] This argument, including all the related parameters that are defined within this argument, specifies the names of the external axes, the external axes position values for a direct move or a roadmap move to a goal pose.

If a robot's external axes remain fixed during a move, or switch to different setpoint values defined by a target, external_axes should be left unspecified.

external_axes argument is not used when the goal type is joint_config, because joint_config could include all robot native joints and external axes values.

Robot pose value plus external_axes can be used for relative direct pose moves.

external_axes is defined as {<axis name>: active} or {<axis name>: <value>}. The names of the external axes must match what is already defined in the RapidPlan Create project.
use {<axis name>: active} if an external axis is used by RapidPlan software when solving a move to a goal pose.
use {<axis name>: <value>} if an external axis is used for a move to a goal pose with a specific external axis position value.

shortestroadmap_path_onlymode: [ OPTIONAL ] for roadmap moves only, this optional argument only allows defines how the robot should use what would be the shortest path through the roadmap. If the roadmap + off-roadmap motions when moving to a goal which is a pose or joint config.

0 or default The robot will use the roadmap as much as possible. (default)
1 or shortest_path The robot uses a shorter path, which typically has a longer off-roadmap segment.
2 or roadmap_only The robot will only move on the roadmap (requires start and goal to be on the roadmap).

shortest_path_only: [ OPTIONAL ] for roadmap moves only, this optional argument only allows the robot use what would be the shortest path through the roadmap. If that path isn’t available, robot would wait, or use partial moves settings if that option is specified.

costs : [ OPTIONAL ] for planning moves only, this argument defines the cost penalty values of the individual cost terms. At least one cost term is required for the costs argument.

The combined value of external_axis, paths_cost and waypoints_costshould be = 1

.

0.

external_axis : [ OPTIONAL ] how much external axes motions are penalized. The default value is 0.0, which puts no penalty on using the external axes. The range of this float-point value is between 0.0 and 1.0.
path_length: [ OPTIONAL ] this argument defines the cost penalty value for a planning move using the shortest path. The range of the value is between 0.0 and 1.0.
via_points: [ OPTIONAL ] this argument defines the cost penalty value for a planning move using the fewest via points (waypoints). The range of the value is between 0.0 and 1.0.
The submitted costs are normalized; it is not an error if their sum is greater than 1.0

constraints : [ OPTIONAL ] for planning moves only, this argument defines an array of user specified orientation constraints that only allow the TCP to rotate along certain axes but not the others between targets.

type : Specifies a type of constraint. Currently, only orientation constraint is supported.
- 0 or orientation
axis : an array of 3 integer values that specifies which axis to be constrained. 1 means the robot TCP would not rotate along this axis during the motion, but a deviation of 1 degree will be allowed which gives the planner a bit of "slack" to find solutions quicker without much detrimental effect on output paths. 0 means the robot TCP allows to rotate along this axis. Two axes are required to be constrained. If there is no offset specified, the vector axis [1, 0, 1] represents the x-y-z axis of the TCP frame. Otherwise, they are x-y-z axis of the ref frame from the TCP frame with offset.
offset: [ OPTIONAL ] an array of 6 floats that specifies an offset that will be applied to the frame relative to TCP frame. The client's active units and rotation convention are used, or the default of millimeters, degrees, and roll pitch yaw.
For example, if a gripper holding a cup of water like the following cases:
the constraint would be:
a. no offset, and constraints: [{type: orientation, axis: [ 1, 1, 0 ] }]
b. no offset, and constraints: [{type: orientation, axis: [ 0, 1, 1 ] }]
c. constraints: [{type: orientation, offset:[delta_x,0,0,0,delta_pitch,0], axis: [ 1, 1, 0 ] }]

trigger: [ OPTIONAL ] This argument, including all the related parameters that are defined within this object, specifies an output based on the timing of a move or a move segment of a combined move. trigger is an object with 3 fields:

name: Only one trigger can be included for each move command, or each move segment of a combined move command. The trigger should have a user defined, stateless, globally unique name, to identify the signal for the receiver of the trigger.
output: The trigger output should be configured during runtime as part of a move command, to turn on or off the output signal as an 1-shot event, until the signal is overridden by either another API command. If the output key is not specified, this trigger is disabled and trigger time is ignored. If output is specified, trigger time must be defined and cannot be omitted.
- 0 or false: output is off
- 1 or true: output is on
time: Specifies the timing of the output, i.e. the time before the target position is reached, or after the move has started. The unit is in seconds and whose absolute value must be greater than 0.1.
- time must be a none-zero value, and should always be >= 0.1 or <= -0.1. The move command will return an error code if 0.1 < time < 0.1.
- A positive value ( time>=0.1) indicates the time after the move starts, ie., a "time-after trigger".
- A negative value (time<=-0.1) indicates the time before reaching the goal, ie., a “time-before trigger”.
- If time is longer than the actual move time, a time-after trigger will turn on when reaching the goal, a time-before trigger will turn on when the move starts. The MoveFeedback response message for the trigger will arrive before the MoveResult message for the move.
- If alternate location is used(mode=0 in SetAlternateLocation), and if complete_move = true:
  - Only time-after triggers will apply to the move to the alternate location, time-before triggers will take no effect.
  - Only time-before triggers will apply to the move to the goal, time-after triggers will take no effect.
- If alternate location is used(mode=0 in SetAlternateLocation), and if complete_move = false:
  - Only time-after triggers will apply to the move to the alternate location, time-before triggers will take no effect.
- A trigger will not be re-activated if a Move command is issued when the robot is already at the goal position.

Function Description

With this new generic Move command and the key value syntax, you can specify any of the former Blind Moves, MoveToXXX, and OffroadtoXXX commands with this one command.

A direct move moves the robot directly from its current position to its goal position with a given interpolation type. This command is efficient, but can easily be blocked by other robots. It is very useful for final motions, especially if collision checking needs to be disabled.

A roadmap move will follow the edges defined in the RPC project. This is expected to be the most common move type since the robots will use the roadmap to dynamically avoid obstacles. If pose is specified, and there is no target in the roadmap as that pose, the robot will leave the roadmap to reach the actual pose. The offroadmap portion will be collision checked, and will use the interpolation type specified (or joint interpolation by default).

A planning move calculates a path for the robot at runtime to reach the goal. This is primarily used to put a robot on the roadmap in the beginning of a task. When called, the requested robot must not be executing any current requests, otherwise it will immediately return an error. If any other robots are currently executing move requests when a planning move request is called, the robot attempting the planning move will be blocked with an Error code. If no collision free path to the goal can be found, the server will return an error by the end of the given timeout period.

Response Details

When a Move request is received, path planning occurs before a response is sent. If a path is found, this command will return a response code to acknowledge the command has been received, the name of the robot that this move is for, and a unique sequence ID for this specific move. If planning fails, an appropriate error code will be returned, and no delayed response will be sent.

Code Block
{topic: Move,type: Response,data: {robot_name: <value>,seq: <value>}}

Delayed Response Details

If a path was found, the system will send a MoveResult message along with a response code to indicate when the move completes. The name of the robot that the move was for, and the unique sequence ID for that move will be returned in the message. If the move is interrupted, the delayed response will contain an appropriate error code.

Code Block
{topic: Move,type: DelayedResponse,data: {robot_name: <value>,seq: <value>}}

or, for a trigger a feedback response will be sent to indicate that trigger output is activated to on, or off. The trigger feedback responses will include the same seq as the Move it is a part of.

Code Block
{topic: Move,type: Feedback, data: {robot_name: <value>,seq: <value>, trigger: {name: <value>, output: <value>}}}

Example Request

Code Block
{topic: Move,data: {robot_name: robot_1,move_type: roadmap,target: pre_pick,speed: 1.0,smoothing: 1, trigger: {name: output_1, output: 1, time: -0.5}}}

Example YAML Responses

Code Block

{topic: Move,type: Response,data: {robot_name: robot_1,seq: 312}}
... move executes ...
{topic: Move, type: Feedback, data: {robot_name: robot_1, seq: 312, trigger: {name: output_1, output: 1}}
... 0.5s
{topic: Move,type: DelayedResponse,data: {robot_name: robot_1, seq: 312}}

Example CSV Responses

Code Block
Move,0,robot_1,312 ... move executes ... MoveFeedback,0,robot_1,312,Output_1,1 ... 0.5s MoveResult,0,robot_1,312

...

Structure

Code Block
{topic: CancelMove,data: {robot_name: <value>, acceleration_factor: <value>}}

Argument Description

robot_name: The name of the robot for which a move is being canceled.
acceleration_factor [ OPTIONAL ] : The acceleration factor at which the robot will move on a scale from 0.5(50%) to 1.0(100%), when the move is being canceled. The default value is 0.8.

Function Description

This function tells the Realtime Controller to abort planning and motion for the specified robot. After calling this, a robot may be left in an off roadmap location and will require a planning move command.
This command is only accepted when the RTR Controller is in OPERATION mode.
If a series of Move commands are queued for the robot in question, they will all be canceled simultaneously. The delayed responses of these commands are not guaranteed to be in queue order.

If CancelMove is called before planning is finished for a Move command, robot preset of the canceled move will still be applied because the preset had changed before planning started.

If a move is canceled mid-motion after a Move command which also sets the robot preset, the robot preset will be maintained.|

Response Details

This command will return a response to acknowledge the command has been received and executed successfully.

Example Request

Code Block
{topic: CancelMove,data: {robot_name: robot_1, acceleration_factor: 0.9}}

Example YAML Responses

Code Block
{topic: CancelMove,type: Response}

Example CSV Responses

Code Block
CancelMove,0

...

Structure

Code Block
{topic: ResumeMove, data: { robot_name: <robot_name>}}

Argument Description

robot_name: Specifies which robot to continue move

Function Description

ResumeMove: This command continues robot the through combined or pre-set moves for a defined robot.

Response Details

Example Request

ResumeMove: {topic: ResumeMove, data: { robotsrobot_name: robot1}}

Example YAML Responses

ResumeMove: {topic: ResumeMove, type: Response, data: {}}

Example CSV Responses

ResumeMove: ResumeMove, 0

...

GetTargets

Structure

Code Block
{topic:

MultiRobotMove

GetTargets,

data

: { moves

[

{robot_name: <value>

, target: <value>, ...}, ...]}}

}}

Argument Description

moves: An array of move commands for different robots. The move commands must adhere to the Move command specification.

For now, MultiRobotMoves only support moves of type Roadmap. At most one move is allowed per robot.

Function Description

MultiRobotMove allows planning for multiple robots to occur at once if, for instance, you’d like robots to purposefully avoid blocking each other when trying to reach their target destinations. This is compared to normal motions where one robot motion is received at a time and is planned without consideration for what other robots may need to do. Note that normal motions will avoid colliding with other robots but cannot take into account the desired motions of robots whose paths have not yet been planned.

Response Details

The command will return an initial response to indicate that the command has been processed and a collision free path has been found.

A unique sequence number will be included to identify the MultiRobotMove responses. The response will also include a list of robots that were unable to plan motions if the mode flag indicated that the motion should succeed anyway.

robot_name: Specifies which robot’s targets will be returned.

preset_name:

Status

colour	Yellow
title	optional

Specifies which preset’s targets to return. Default is the active robot preset.

Function Description

This command retrieves the targets for a given robot in a specific preset in the loaded project. The default behavior is to return the targets in the active robot preset, but a different preset can be specified.

Response Details

This command will return a response code, followed by a comma separated array of the target names.

Example Request

Code Block
{topic:

MultiRobotMove, type: Response,

GetTargets,data: {

seq

robot_name:

<value>, failed: <value>

robot_1}}

Delayed Response Details

For every Move in the MultiRobotMove, a feedback response will be sent when that robot completes its motion.

Example YAML Responses

Code Block
{topic:

MultiRobotMove

GetTargets,

type:

Feedback

Response,

data: {

robot_name: <value>, seq: <value>}} {topic: MultiRobotMove, type: Feedback, data: {robot_name: <value>, seq: <value>}} .. additional feedback messages {topic: MultiRobotMove, type: DelayedResponse, data: {seq: <value>}}

Example Request

Code Block{ topic: MultiRobotMove data: { moves: [ {robot_name: robot_1, target: target_1, speed: 1}, {robot_name: robot_2, target: target_2, speed: 0.5, move_type: direct}, {robot_name: robot_3, pose: [1,2,3,4,5,6], speed: 0.1, smoothing: 0.0} ] }

targets:[weld_1,weld_2,weld_3]}}

Example CSV Responses

Code Block
GetTargets,0,3,weld_1,weld_2,weld_3

CreateTarget

Structure

Code Block
{topic: CreateTarget,data: {target_name: <value>,robot_name: <value>}}

Argument Description

target_name: Specifies the name of the new target to be created.
robot_name: This indicates which robot will be assigned to the new target.

Function Description

This command creates a target in the active robot preset for the specified robot.

The target is created using the robot’s current joint angles. To ensure consistent joint angle readings, the robot must stay stationary while the target is created. Therefore, the controller must be in CONFIG mode and the robot state must be connected.

No connections will be created automatically for the new target.

Response Details

This command will return an acknowledgement with a status code indicating the command was received and executed.

Example Request

Code Block
{topic: CreateTarget,data: {target_name: weld5,robot_name: robot_1}}

Example YAML Responses

Code Block
{topic:

MultiRobotMove

CreateTarget,

type: Response}

Example CSV Responses

Code Block
CreateTarget,0

UpdateTarget

Structure

Code Block
{topic: UpdateTarget,data: {

robot

target_

names

name:

[robot_1

<value>, robot_

2, robot_3], seq: 23}} {topic: MultiRobotMove, type: Feedback, data: {robot_name: robot_2, seq: 23}} {topic: MultiRobotMove, type: Feedback, data: {robot_name: robot_3, seq: 23}} {topic: MultiRobotMove, type: Feedback, data: {robot_name: robot_1, seq: 23}} {topic: MultiRobotMove, type: DelayedResponse, data: {seq: 23}}

Example CSV Responses

Code Block
MultiRobotMove,0,23,1,robot_1,robot_2,robot_3 MultiRobotMoveFeedback,0,robot_2,23 MultiRobotMoveFeedback,0,robot_3,23 MultiRobotMoveFeedback,0,robot_1,23 MultiRobotMoveResult,0,23

Example Task Planner integration

The following example shows how MultiRobotMove can be used to resolve a deadlock at runtime.

In the case of a deadlock, normal Move commands will return failure. Using MultiRobotMove combining the targets of the deadlocked robots will resolve the deadlock and move the robots to their targets.

Code Block

robot_names = ["robA", "robB", "robC"]
target_map = {"robA":[A1,A2,A3,...], "robB":[B1,B2,B3,...], "robC":[C1,C2,C3,...]}
move_failed_robots = []
finish_all_targets = false
while(!finish_all_targets):
  if move_failed_robots.empty():
    for robot_name in robot_names:
      rtr_move_to_target(robot_name, next_targets[robot_name])
      if delay_response == succeed:
        update_target(robot_name, target_map[robot_name])
      else:
        move_failed_robots.insert(robot_name)
  else:
    rtr_multi_robot_move(robot_names, next_targets)
    if delay_response == succeed:
      update_targets(robot_names, target_map)
      move_failed_robots.clear()
  finish_all_targets = are_all_targets_finished(next_targets, target_map)

GetTargets

...

Structure

...

Code Block
{topic: GetTargets,data: {robot_name: <value>}}

...

Argument Description

...

robot_name: Specifies which robot’s targets will be returned.

preset_name:

Status

colour	Yellow
title	optional

Specifies which preset’s targets to return. Default is the active robot preset.

...

Function Description

...

This command retrieves the targets for a given robot in a specific preset in the loaded project. The default behavior is to return the targets in the active robot preset, but a different preset can be specified.

...

Response Details

...

This command will return a response code, followed by a comma separated array of the target names.

...

Example Request

...

Code Block
{topic: GetTargets,data: {robot_name: robot_1}}

...

Example YAML Responses

...

Code Block
{topic: GetTargets,type: Response,data: {targets:[weld_1,weld_2,weld_3]}}

...

Example CSV Responses

...

Code Block
GetTargets,0,3,weld_1,weld_2,weld_3

CreateTarget

...

Structure

...

Code Block
{topic: CreateTarget,data: {target_name: <value>,robot_name: <value>}}

...

Argument Description

...

target_name: Specifies the name of the new target to be created.
robot_name: This indicates which robot will be assigned to the new target.

...

Function Description

...

This command creates a target in the active robot preset for the specified robot.

The target is created using the robot’s current joint angles. To ensure consistent joint angle readings, the robot must stay stationary while the target is created. Therefore, the controller must be in CONFIG mode and the robot state must be connected.

No connections will be created automatically for the new target.

...

Response Details

...

This command will return an acknowledgement with a status code indicating the command was received and executed.

...

Example Request

...

Code Block
{topic: CreateTarget,data: {target_name: weld5,robot_name: robot_1}}

...

Example YAML Responses

...

Code Block
{topic: CreateTarget,type: Response}

...

Example CSV Responses

...

Code Block
CreateTarget,0

UpdateTarget

Structure

Code Block
{topic: UpdateTarget,data: {target_name: <value>, robot_name: <value>, retrigger_autoconnect: <value>, object_states: <value>, pose: [x,y,z,rx,ry,rz]}}

Argument Description

name: <value>, retrigger_autoconnect: <value>, object_states: <value>, pose: [x,y,z,rx,ry,rz]}}

Argument Description

target_name: Specifies which target will have its position updated.
robot_name: This specifies which robots TCP will be used at the new target location.
retrigger_autoconnect: [ OPTIONAL ] This boolean argument specifies if the auto-connect should be regenerated when updating the targets position. If the target is not part of an auto-connect, then this argument will have no effect. The default value is False.

object_states:: [ OPTIONAL ] This argument specifies whether the validation of the updated target position should take consideration of all object states or only the active objects. This argument can be set to either all or active.

If object_states is set to all, path validation will check all object states when updating a target. This is the default setting. If object_states is set to active, path validation of will check active object states when updating a target.

pose: [ OPTIONAL ] , if pose values [x, y, z, r, p, y] are specified, the pose values will be used to update the target position, instead of the specified robot TCP location.

joint_config: [ OPTIONAL ] , the joint configuration values will be used to update the target position instead of the specified robot TCP location, even if the robot is disconnected. The joint configuration values should include all robot links and external axes.

ref_frame: [ OPTIONAL ] , if specified, this frame is used as a reference for the pose value. ref_frame can be either a frame defined in RPC or a DSM frame.

validation: [ OPTIONAL ] , if specified this allows ignoring edge validities when updating a target, accepts values:

require_valid or 0 [default]: the command fails if a node or edge that was valid become invalid;
allow_invalid or 1: the command succeeds even if a node or edge becomes invalid. A warning message is shown.

Function Description

This command updates the specified targets position to be at the specified robot TCP location in its current preset, or using an optional pose value. The target’s new position will be used for all assigned robots.
The target is created using the robot’s current joint angles which means the controller must be in CONFIG mode and the robot state must be connected.

A target’s position will only be updated, if all of its connections remain valid, otherwise the command fails and returns an error code EDGE_INVALIDATED. This could result from the new position being unreachable, the new position being in collision, or one of the motions to the new position resulting in a collision.

Only one target can be updated at a time. While a target is updating, any subsequent UpdateTarget commands will be rejected.

With the retrigger_autoconnect argument set to true, the targets position will be updated, and then the auto-connect will be re-run using the same parameters as set in RapidPlan Create. With retrigger_autoconnect set to false, just the target’s position will change, and all via point locations will remain the same. The edges leading to the new target location will be validated against the constraints of the auto-connect, and the UpdateTarget command will fail if all constraints are not met.

Response Details

This command will return an acknowledgement with a status code indicating the command was received and is being executed.

Delayed Response Details

This command will also return a delayed response when the update has completed or failed.

Example Request

Code Block
{topic: UpdateTarget,data: {target_name: weld5, robot_name: robot1}}

Example YAML Responses

Code Block
{topic: UpdateTarget,type: Response,data: {seq: 154}} After the target position has been updated and the roadmap has been regenerated... {topic: UpdateTarget,type: DelayedResponse,data: {seq: 154}}

Example CSV Responses

Code Block
UpdateTarget,0,154 After the target position has been updated and the roadmap has been regenerated... UpdateTargetResult,0,154

...

Structure

Code Block
{topic: RemoveTarget,data: {target_name: <value>}}

Argument Description

target_name: Specifies the name of the target to be removed.

Function Description

This command removes a target in the active robot preset for the specified robot.

To remove the target, Realtime Controller must be in CONFIG mode.

Removing the target will remove any manually created connections , and any connections created by auto-connect, between this target and other targets.

Response Details

This command will return an acknowledgement with a status code indicating the command was received and executed.

Example Request

Code Block
{topic: RemoveTarget,data: {target_name: weld5}}

Example YAML Responses

Code Block
{topic: RemoveTarget,type: Response}

Example CSV Responses

Code Block
RemoveTarget,0

AddConnection

Structure

Code Block
{topic: AddConnection,data: {robot_name: <value>, preset: <value>, targets: <value>, type: <value>, autoconnect_name: <value>, validation: <value>}}

Argument Description

robot_name: Specifies which robot to add the connection to.

preset:

Status

colour	Yellow
title	optional

The name of the robot preset to add connections to. If empty, the active preset is used.

targets: A list of targets to connect. At least 2 targets must be included. If the type is joint or cartesian then only 2 targets are allowed.

type: Specifies the type of connection to create. Acceptable values are joint (0), cartesian (1), or auto (2).

autoconnect_name:

Status

colour	Yellow
title	optional

If type is set to auto (2), autoconnect_name can be specified by the user. If unspecified, a default autoconnect name will be assigned.

validation:

Status

colour	Yellow
title	optional

This argument can be set to:

require_valid or 0: Run validation and require it to succeed, otherwise the change would be rolled back and an error code returned. This is the default option if validation option is unspecified for a manual connection or an autoconnect.
allow_invalid or 1: Run validation but allow it to fail, with no error code.

Function Description

This command creates new connections within a given roadmap. It can be used to create manual connections or auto-connects.

Response Details

This command will return a response code.

Delayed Response Details

This command will also return a delayed response only if type is set to auto and when validation is set to require_valid, or allow_invalid.

Example Request

Code Block

{topic: AddConnection,data: {robot_name: robot_1, presets: [preset_1], targets: [target_1, target_2], type: cartesian, validation: allow_invalid}}
{topic: AddConnection,data: {robot_name: robot_1, presets: [preset_1], targets: [target_1, target_2], type: auto, autoconnect_name: autoconnect_1, validation: require_valid}}

Example YAML Responses

Code Block
: auto, autoconnect_name: autoconnect_1, validation: require_valid}}

Example YAML Responses

Code Block

{topic: AddConnection,type: Response,data: {seq: 154}}
After the connection is created and the roadmap has been regenerated and validated...
{topic: AddConnection,type: ResponseDelayedResponse,data: {seq: 154}}

Example CSV Responses

Code Block
AddConnection,0,154 After the connection is created and the roadmap has been regenerated and validated... {topic: AddConnection,type: DelayedResponse,data: {seq: 154}}

Example CSV Responses

Code Block
AddConnection,0,154 After the connection is created and the roadmap has been regenerated and validated... AddConnectionResult,0,154

RemoveConnection

 and validated...
AddConnectionResult,0,154

RemoveConnection

autoconnect_name: this argument is used to specify the name of the auto-connect to remove.

autoconnect_name is mutually exclusive with the following options:

Structure

Code Block
{topic: RemoveConnection,data: {autoconnect_name: <value>}} or {topic: RemoveConnection,data: {robot_name: <value>, preset: <value>, targets: <value>}}

Argument Description

autoconnect_name: this argument is used to specify the name of the auto-connect to remove.

autoconnect_name is mutually exclusive with the following options:

robot_name : Specifies which robot to remove the connection from.

targets : A list of two targets to remove the manual connection between.

Status

colour	Red
title	REQUIRED

if robot_name is used.

preset:

Status

colour	Yellow
title	optional

Name of the robot preset to remove a manual connection from. If empty, the active preset is used. If an auto-connect is removed, preset is ignored and not checked for validity.

Function Description

This command removes connections in the roadmap. It can remove manual connections between two targets or an auto-connect by name. It can only be run in CONFIG mode.

Response Details

This command will return a response code.

Example Request

Code Block
{topic: RemoveConnection,data: {autoconnect_name: <value>autoconnect_1}} or {topic: RemoveConnection,data: {robot_name: <value>robot_1, preset: <value>preset_1, targets: <value>[target_1, target_2]}}

Argument Description

Example YAML Responses

Code Block
{topic: RemoveConnection,type: Response}

Example CSV Responses

Code Block
RemoveConnection,0

GetJointConfiguration

Structure

Code Block
{topic: GetJointConfiguration,data: {robot_name: <value>, native: false}}

Argument Description

robot_name: Specifies

which

the name of the robot to

remove the connection frompreset:

Status

colour	Yellow
title	optional

Name of the robot preset to remove a manual connection from. If empty, the active preset is used. If an auto-connect is removed, preset is ignored and not checked for validity

return the joint angles for.

targets : A list of two targets to remove the manual connection between.

Status

colour	Red
title	REQUIRED

if robot_name is used.

native: [ OPTIONAL ] This argument, if true, returns only robot native joint configuration. If false, full robot joint configuration including external axes is returned. Default value is false.

with_joint_names: [ OPTIONAL ] This argument, if true, specifies the returned names of the robot joints and external joints in the current active robot preset. The returned names are also based on the status of native.

Function Description

This command

removes connections in the roadmap. It can remove manual connections between two targets or an auto-connect by name. It can only be run in CONFIG mode

retrieves the current joint angles of a specified robot. If the robot has additional axes, they will be included sorted by their driver index. The values will be returned in the client’s units for both revolute and prismatic joints.

Response Details

This command will return a response code, followed by the current joint angles in a comma separated array. This command will always include the robot axes, and by default will include the position of external axes if present.

Example Request

Code Block
{topic:

RemoveConnection

GetJointConfiguration,data: {

autoconnect

robot_name:

autoconnect

robot_1

}} or

, with_joint_names: true}}

Example YAML Responses

Code Block
{topic:

RemoveConnection

GetJointConfiguration,type: Response,data: {

robot

joint_

name: robot_1, preset: preset_1, targets: [target_1, target_2

configuration: [j1,j2,j3,j4,j5,j6...jN], joint_names: [<j1 name>,<j2 name>,<j3 name>,...<jN name>]}}

Example

YAML

CSV Responses

Code Block

{topic: RemoveConnection,type: Response}

Example CSV Responses

Code Block
RemoveConnection,0

...

GetJointConfiguration,0,j1,j2,j3,j4,j5,j6...jN,joint1name,joint2name,...,jointNname

GetTCPPose

Structure

Code Block
{topic:

GetJointConfiguration

GetTCPPose,data: {robot_name: <value>,

native

ref_frame:

false

<value>}}

Argument Description

robot_name: Specifies

the name

which robot’s TCP pose will be returned. The TCP of the active robot preset will be used.

ref_frame:

Status

colour	Yellow
title	optional

The reference frame in which to return the

joint angles for.

native: [ OPTIONAL ] This argument, if true, returns only robot native joint configuration. If false, full robot joint configuration including external axes is returned. Default value is false.

with_joint_names: [ OPTIONAL ] This argument, if true, specifies the returned names of the robot joints and external joints in the current active robot preset. The returned names are also based on the status of native.

TCP coordinates. Default is world. The acceptable frames are:

<robot_name>_base: the base frame of the robot as defined in the robot model. This is a reserved frame name in RPC.
<robot_name>_default_tcp: the default tcp as defined in the robot model. This is a reserved frame name in RPC.
any user created frame in the RPC project

Function Description

This command

retrieves the current joint angles of a specified robot. If the robot has additional axes, they will be included sorted by their driver index. The values will be

returns the specified robot’s TCP coordinates in the world or user specified frame for the active robot preset.

The coordinates are returned in the client’s

units for both revolute and prismatic joints

Response Details
unit and rotation convention.

This

This command will return a response

code, followed by the current joint angles in a comma separated array. This command will always include the robot axes, and by default will include the position of external axes if present

to acknowledge the command has been received and executed successfully along with the position and rotation of the specified robot’s TCP.

Example Request

Code Block
{topic:

GetJointConfiguration

GetTCPPose,data: {robot_name: robot_1

, with_joint_names: true

}}

Example YAML Responses

Code Block
{topic:

GetJointConfiguration

GetTCPPose,type: Response,data: {

joint_configuration

pose:

j1,j2,j3,j4,j5,j6...jN], joint_names: [<j1 name>,<j2 name>,<j3 name>,...<jN name>

1.0,0.5,0.375,90.0,0.0,0.0]}}

Example CSV Responses

Code Block

GetJointConfiguration

GetTCPPose,0,

j1,j2,j3,j4,j5,j6...jN,joint1name,joint2name,...,jointNname

GetTCPPose

Structure

Code Block
{topic: GetTCPPose,data: 1.0,0.5,0.375,90.0,0.0,0.0

IsOnTarget

Structure	`{topic: IsOnTarget, data: { robot_name:`

<value>,ref_frame: <value>}}

Argument Description

robot_name: Specifies which robot’s TCP pose will be returned. The TCP of the active robot preset will be used.

ref_frame:

Status

colour	Yellow
title	optional

The reference frame in which to return the TCP coordinates. Default is world. The acceptable frames are:

<robot_name>_base: the base frame of the robot as defined in the robot model. This is a reserved frame name in RPC.
<robot_name>_default_tcp: the default tcp as defined in the robot model. This is a reserved frame name in RPC.
any user created frame in the RPC project

Function Description

This command returns the specified robot’s TCP coordinates in the world or user specified frame for the active robot preset.

The coordinates are returned in the client’s unit and rotation convention.

Response Details

This command will return a response to acknowledge the command has been received and executed successfully along with the position and rotation of the specified robot’s TCP.

Example Request

Code Block{topic: GetTCPPose,data: {robot_name: robot_1

<robot_name>, target_name: <target_name> [epsilon]: <epsilon>}}

Argument Description

robot_name: Specifies which robot to check

target_name: Specifies which target to check

epsilon [ OPTIONAL ] : the distance metric to use when determining if the robot is on target.

Function Description

IsOnTarget can be used to detect if the robot is at a specific target. If multiple targets are clustered at the same location it cannot tell you if the robot is at one over the other or which target motion planning will choose when trying to move from that position.

Response Details

{topic: IsOnTarget, type: Response, data: {on_target: <boolean>}}

Example Request

{topic: IsOnTarget, data: { robot_name: robot1, target_name: target2}}

{topic: IsOnTarget, data: { robot_name: robot2, target_name: target5, epsilon: 0.3}}

Example YAML Responses

Code Block
{topic:

GetTCPPose

IsOnTarget, type: Response, data: {

pose:[1.0,0.5,0.375,90.0,0.0,0.0]}}

on_target: true}}

Example CSV Responses

Code Block
IsOnTarget,0,false

BeginRoadmapRecording

Example CSV Responses
Structure	`{ topic: BeginMotionRecording }`
Argument Description
Function Description	`BeginRoadmapRecording`can be used to start recording motions. This will trigger planning queue to start recording all the robot motions. If Appliance is not in operation state, the command will also try to start the operation. Motion data, including targets and edges, are captured to be saved to a project roadmap once the `EndMotionRecording` command is sent.
Response Details
Example Request
Example YAML Responses

Code Block
GetTCPPose,0,1.0,0.5,0.375,90.0,0.0,0.0

IsOnTarget

EndRoadmapRecording

Structure	`{ topic:`

IsOnTarget, data: { robot_name: <robot_name>, target_name: <target_name> [epsilon]: <epsilon>}

Argument Description
`EndMotionRecording }`

robot_name: Specifies which robot to check

target_name: Specifies which target to check

epsilon [ OPTIONAL ] : the distance metric to use when determining if the robot is on target.

Function Description

IsOnTarget

EndRoadmapRecording can be used to

detect if the robot is at a specific target. If multiple targets are clustered at the same location it cannot tell you if the robot is at one over the other or which target motion planning will choose when trying to move from that position.

Response Details

{topic: IsOnTarget, type: Response, data: {on_target: <boolean>}}

Example Request

{topic: IsOnTarget, data: { robot_name: robot1, target_name: target2}}

{topic: IsOnTarget, data: { robot_name: robot2, target_name: target5, epsilon: 0.3}}

Example YAML Responses

Code Block
{topic: IsOnTarget, type: Response, data: {on_target: true}}

Example CSV Responses

Code BlockIsOnTarget,0,false

stop recording motions and save motion data to the project roadmap. This will stop the robot motion, set appliance back to config mode, and automatically start adding the recording targets and edges into the roadmap.
Response Details
Example Request
Example YAML Responses
Example CSV Responses

CancelMotionRecording

Structure	`{ topic: CancelMotionRecording }`
Argument Description
Function Description	`CancelMotionRecording` stops robot motion, sets Appliance back to config mode, and removes any recorded motions from the roadmap.
Response Details
Example Request
Example YAML Responses
Example CSV Responses

API Endpoints - Scene Modeling

...

Versions Compared

Old Version 4

New Version Current

Key

Revisions

Goal

Goal

GetTargets

CreateTarget

UpdateTarget

GetTargets

CreateTarget

UpdateTarget

AddConnection

RemoveConnection

RemoveConnection

GetJointConfiguration

GetTCPPose

GetTCPPose

IsOnTarget

BeginRoadmapRecording

IsOnTarget

EndRoadmapRecording

CancelMotionRecording

API Endpoints - Scene Modeling