make_robot("<name>") returns a RemoteRobot. Its attributes are the methods and subcomponents below, and every call runs on the robot; the driver behind it is FlexivRizon. Connecting neither starts nor moves the robot — it attaches to one that is already up. A method that fails on the robot arrives as RuntimeError naming the original error in its message. The client packages this page uses are preinstalled in every GRID session workspace and in the Python environment the GRID CLI prepares when you run a program with skill run; there is nothing to install.
Methods on the robot
Called asrobot.<method>(...).
addNamedPose()
Signature
required
Name of the pose to define
required
List of joint angles in radians
endFreeDrive()
Signature
moveToPose and
setJointAngles.
followJointTrajectory()
Signature
angles is visited in order. The arm briefly
stops at every intermediate waypoint — this implementation is a
per-segment loop over setJointAngles, not a blended
trajectory.
required
Sequence of joint configurations (radians) to visit in order. Each inner list must have 7 elements.
required
Either a single positive float giving the total trajectory time in seconds (split evenly across segments), or a list of positive floats with the same length as
angles giving the duration of each segment from the previous pose to angles[i].default:"True"
Wait for the final segment to complete before returning. Intermediate segments are always blocking.
angles is empty, duration is not
positive, list-form duration length does not match
angles, or a waypoint is invalid.
RobotFault: If the controller reports a fault during a segment.
RuntimeError: If a segment stops short of its waypoint or does not
arrive before its deadline.
getEndEffectorForce()
Signature
getEndEffectorGraspDetected()
Signature
getEndEffectorIsMoving()
Signature
getEndEffectorPose()
Signature
getEndEffectorWidth()
Signature
getImage()
Signature
getImage() returns.
str
default:"''"
Name of the camera to get image from — either a directly attached camera’s name or a
/-separated path through subcomponents to a nested one (left_arm/wrist). May be omitted when the robot has exactly one camera.Forwarded to the underlying sensor’s
getImage. Lets callers pass camera-specific options (e.g. image_type="depth", compressed=False) without the base class having to enumerate them.getJointAngles()
Signature
getJointVelocities()
Signature
getLidarPointCloud()
Signature
str
default:"''"
Name of the lidar. If empty, uses the first available lidar.
getNamedPose()
Signature
required
Name of the pose to get (case-insensitive)
getOrientation()
Signature
getPose()
Signature
getPosition()
Signature
getState()
Signature
_local_state, and the walk composes the per-component
results into one nested mapping. Subclasses must not replace
this method — per-component state belongs in _local_state.
With no keys, returns this component’s local state merged
with one nested node per subcomponent name — the tree structure
is the nesting itself, and the names mirror subcomponents
(and therefore serialize() and edge introspection): a
two-arm rig returns {"left_arm": {"joint_positions": ...}, "right_arm": {...}}, and a leaf component returns its local
state alone. A component whose state could not be read (dead
telemetry, not yet started, already shut down) carries an
"error" entry — {"error": "<ExceptionType>: <message>"},
with its children still nested alongside — instead of its state
keys. Errors are contained per node: one failing component never
loses the rest of the snapshot, and the walk still descends into
the failing component’s children. "error" is reserved for
that purpose, and local state keys must not collide with
subcomponent names; a hook violating either is reported as that
node’s error.
With keys, returns a flat mapping with one entry per match.
Each key is a /-separated path through the component tree:
every segment names a subcomponent, and the final segment may
instead name an entry in that component’s local state. Because
structure is the nesting, a literal path is the same as plain
indexing — getState(["left_arm/joint_positions"]) returns
the value of getState()["left_arm"]["joint_positions"] — and
a path ending on a subcomponent yields that component’s full
nested node. Segments may use shell-style wildcards over
subcomponent names — * matches within one chunk and **
matches any chain of chunks — so "*_arm/joint_positions"
fans out to one entry per arm, keyed by the concrete matched
path. Wildcards never match state entries; only a literal final
segment does. A key that matches nothing raises, so a typo is
loud rather than silently absent. A matched component whose
state read failed yields {"error": "..."} at its path.
Keyed reads are lazy: a hook runs only where a key lands — a
literal path executes the final component’s hook alone (not the
nodes traversed on the way), a glob executes only the matched
nodes, and each component’s hook runs at most once per call
however many keys reach it. Components with a selective-read
hook (_local_state_entries — every Robot with
registered state getters) go further and execute only the getters a key names, so
a ** glob probes their registries without touching
hardware. The caller pays only for the state actually
requested; ** and the no-keys form visit the whole tree
because that is the request.
State is cheap by convention: local state carries kinematics,
status, and health — never bulk sensor payloads (camera frames,
point clouds, scans), which stay in their dedicated methods
(getImage, getPointCloud, …). Callable on a stopped
tree — reading state after a soft e-stop is when it matters most
— and on a partially started one, where unstarted components
report a per-node error instead of failing the call.
State paths to read, or None for the full nested snapshot. A single string is shorthand for a one-element list.
keys is None, otherwise a
flat mapping of matched path to state value or nested node.
Raises:
TypeError: If keys is neither None, a string, nor a
list/tuple of strings.
ValueError: If a key is empty, has an empty path segment, or
matches no subcomponent path or state entry.
grasp()
Signature
gripper.params()) and
blocks until the fingers stop, either fully closed or on an object. Check
getEndEffectorGraspDetected to tell the two apart.
Raises:
RuntimeError: If no gripper is configured, or the fingers do not stop
before the deadline.
moveToDeltaPose()
Signature
required
Pose offset to compose with the current pose. The position is added to the current position and the orientation is composed with the current orientation.
default:"True"
Wait for movement to complete. Defaults to True.
moveToHome()
Signature
default:"True"
Wait for movement to complete.
default:"2.0"
Total duration of the move (seconds).
default:"0.75"
Time spent accelerating and decelerating (seconds). Clamped to at most
moving_time / 2.moveToNamedPose()
Signature
required
Name of the pose to move to (case-insensitive).
default:"True"
Wait for movement to complete.
default:"2.0"
Total duration of the move (seconds).
default:"0.75"
Time spent accelerating and decelerating (seconds). Clamped to at most
moving_time / 2.named_poses.
RobotFault: If the controller reports a fault before or during the move.
RuntimeError: If a blocking move stops short of the target or does not
arrive before its deadline.
moveToPose()
Signature
required
Target pose (position in meters, orientation as a unit quaternion) in the robot’s base frame.
default:"True"
Wait for movement to complete. Ignored when high_frequency is True; always waits when avoid_force is True.
default:"False"
If False, send one discrete move with a planned profile. Otherwise, send the target for streaming and return immediately.
default:"2.0"
Seconds to complete the movement. Speed caps can make the move take longer; the move is then logged as clamped.
default:"0.5"
Seconds to spend accelerating in a trapezoidal motion profile. Clamped to at most
moving_time / 2.default:"False"
Monitor the TCP contact force during the move and stop the arm when it exceeds its pre-move baseline by more than force_threshold. The arm holds where it stopped, which can leave it pressing on the contact; back off in the caller if that matters.
default:"10.0"
Contact force increase, in Newtons, that stops an avoid_force move.
start() clears it.
RuntimeError: If a blocking move stops short of the target (e.g. an
unreachable pose) or does not arrive before its deadline.
release()
Signature
removeNamedPose()
Signature
required
Name of the pose to remove (case-insensitive)
setJointAngles()
Signature
max_joint_speed and max_joint_acceleration, and the robot’s
internal motion generator smoothens and executes the motion. A
blocking move waits until the joints are within
2 mrad of the target and at rest.
If high_frequency is True:
the target is sent without waiting, for a caller streaming targets from a
~1-100 Hz control loop (e.g. a Vision-Language-Action model). The robot’s
motion generator interpolates between targets at the configured speed caps,
so large jumps between consecutive targets move at those caps.
required
List of target joint angles in radians, starting with the base joint.
default:"True"
Wait for movement to complete. Ignored when high_frequency is True; always waits when avoid_force is True.
default:"False"
If False, send one discrete move with a planned profile. Otherwise, send the target for streaming and return immediately.
default:"2.0"
Seconds to complete the movement. Speed caps can make the move take longer; the move is then logged as clamped.
default:"0.5"
Seconds to accelerate from zero to full velocity (another accel_time is needed to decelerate to zero). Clamped to at most
moving_time / 2.default:"False"
Monitor the TCP contact force during the move and stop the arm when it exceeds its pre-move baseline by more than force_threshold. The arm holds where it stopped, which can leave it pressing on the contact; back off in the caller if that matters.
default:"10.0"
Contact force increase, in Newtons, that stops an avoid_force move.
start() clears it.
RuntimeError: If a blocking move stops short of the target or does not
arrive before its deadline.
startFreeDrive()
Signature
moveToPose and setJointAngles are not active in
this mode — call endFreeDrive to return to position
control.
All six Cartesian axes are unlocked, elbow motion is enabled, and
damping is set to a moderate level on every axis.
stop()
Signature
subcomponents insertion order), then this
component’s own _stop_self hook runs. The walk is
best-effort — a failing component never prevents the rest of the
tree from being stopped; failures are collected and raised
together after the walk completes. Components (and their
subtrees) that have already been shut down are skipped. Safe to
call repeatedly: stopping an already-stopped tree re-runs the
hooks, which must tolerate that. Blocks until every hook has
returned.
Stops motion only; resources stay live and the component remains
usable — telemetry and every other public method keep working on a
stopped tree. Use shutdown to release resources. Stopping
re-arms each visited component, so a later start re-runs
the bring-up hooks — that is the stop-then-start restart path —
but it does not revoke callability: only shutdown does
that.
Subclasses must not replace this method — per-component stop
behavior belongs in _stop_self. An override may only
extend the walk (adding a driver-specific mode, as UR5e does
with its immediate escape hatch) and must delegate to
super().stop() for the normal path; it must never
re-implement the recursion.
Raises:
ComponentStopError: If one or more stop hooks raised. The
walk still visited every component; the exception carries
every (component_path, exception) pair.
validateGrasp()
Signature
EndEffector.getGripDetected. Subclasses generally do not
need to override this.
Returns:
True if the end effector reports an object in its grip, False
otherwise.
Raises:
RuntimeError: If no end effector is configured on this arm.
NotImplementedError: If the configured end effector does not
support grip detection.
Properties on the robot
Read asrobot.<property>; each read runs the getter on the robot.
Optional[str]
The controller’s current control mode, e.g.
"NRT_JOINT_POSITION" or "IDLE".Read live from the controller, so a stop or fault shows as "IDLE".
Driver-owned: it changes only through the motion API. None before start().Optional[str]
Flexiv Elements name of the configured gripper, or None when there is none.
list[float]
Joint angles (radians) with the arm over the workspace, joints at 90 degrees.
float
Cap applied to commanded TCP angular acceleration, in rad/s^2.Writable; must be finite and > 0.
float
Cap applied to commanded TCP angular speed, in rad/s.Writable; must be finite and > 0.
float
Cap applied to commanded joint acceleration, in rad/s^2.Writable; must be finite and > 0.
float
Cap applied to commanded joint speed, in rad/s. Writable; must be finite and > 0.
float
Cap applied to commanded TCP linear acceleration, in m/s^2.Writable; must be finite and > 0.
float
Cap applied to commanded TCP linear speed, in m/s. Writable; must be finite and > 0.
Dict[str, List[float]]
Registered poses as
{name: joint angles in radians} (a copy).Mutating the returned mapping does not change what the arm knows:
register and remove entries with addNamedPose and
removeNamedPose, or assign a whole mapping to replace them all.Configured children
robot.end_effector— the gripper, chosen in the robot’s configuration; when one is fitted, its methods are theEndEffectorinterface’s.
Lifecycle and configuration
The driver’s own bring-up and configuration hooks. The edge runs them when the robot comes up; do not call them from a program. Note thatrobot.shutdown() on the proxy is not the method below — it is RemoteRobot.shutdown(), which closes your connection and leaves the robot as it was.
addSensor()— Add an external sensor to the robot.addSubcomponent()— Attach a child component under a name.builtin_subcomponents()— Declare the children this class always ships with (customization point).configHash()— Hash this component’s serialized config subtree.config_schema()— Config-args schema for this robot, derived from the constructor.from_config()— Construct this component and its config-declared subtree.getIdentity()— Get this component’s own hardware identity (serial, model, version, MAC).getRobotId()— Stable, readable identifier for a robot or rig, for a database key.serialize()— Serialize this component tree back to its config envelope.setup_shutdown_handlers()— Register the process-wide atexit and signal handlers for safe teardown.shutdown()— Shut down this component’s tree, halting motion and releasing resources.start()— Bring this component’s tree online (connect, enable, arm).
Image — call decode() for an ndarray). You reach the robot through make_robot.