> ## Documentation Index > Fetch the complete documentation index at: https://docs.generalrobotics.dev/llms.txt > Use this file to discover all available pages before exploring further. # Flexiv Rizon Arm > The Flexiv Rizon Arm as GRID drives it The Flexiv Rizon Arm as GRID drives it — what this robot actually implements, with the signatures it actually accepts. `connect("")` 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. ```python theme={null} from grid_nexus_client import connect robot = connect("") ``` ## Methods on the robot Called as `robot.(...)`. ### `addNamedPose()` ```python Signature theme={null} addNamedPose(pose_name: str, joint_angles: List[float]) -> None ``` Define a pose\_name:joint\_angles pair in the dictionary of named poses (overriding any existing pair). Name of the pose to define List of joint angles in radians **Raises:** ValueError: If the length of joint\_angles list does match the length of other named poses ### `endFreeDrive()` ```python Signature theme={null} endFreeDrive() -> None ``` Exit free-drive mode and return to position control. The arm is no longer movable by hand and again responds to position-control commands such as `moveToPose` and `setJointAngles`. ### `getEndEffectorForce()` ```python Signature theme={null} getEndEffectorForce() -> float ``` Measured finger force in Newtons. Positive: opening force, negative: closing force. Reads 0 if the enabled gripper has no force sensing capability \[N] ### `getEndEffectorGraspDetected()` ```python Signature theme={null} getEndEffectorGraspDetected() -> bool ``` Returns True if the gripper is grasping an object. ### `getEndEffectorIsMoving()` ```python Signature theme={null} getEndEffectorIsMoving() -> bool ``` Returns True if the gripper is currently moving. ### `getEndEffectorPose()` ```python Signature theme={null} getEndEffectorPose() -> Pose ``` ```text theme={null} [Deprecated] Get the current end effector pose (position + orientation) w.r.t. the base frame. ``` ### `getEndEffectorWidth()` ```python Signature theme={null} getEndEffectorWidth() -> float ``` Get the current gripper width in meters. ### `getImage()` ```python Signature theme={null} getImage(camera_name: str = '', **kwargs) -> Image ``` Return the image of camera. Which camera a no-argument call reads is decided by cardinality alone — no robot, config, or class declares a default. A robot with exactly one camera needs no name; a robot with several requires one, so adding a second camera never silently changes which one a bare `getImage()` returns. 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. **Returns:** Image: The captured image. **Raises:** RuntimeError: If no cameras are configured, or the name is omitted on a robot with more than one camera; the message lists every configured camera path. KeyError: If camera\_name is given but names no camera on this robot. ### `getJointAngles()` ```python Signature theme={null} getJointAngles() -> list[float] ``` Get current seven joint angles in radians. **Returns:** Current seven joint angles in radians, with base joint first ### `getJointVelocities()` ```python Signature theme={null} getJointVelocities() -> list[float] ``` Get current seven joint velocities in radians/second. **Returns:** Current seven joint velocities in radians/second, with base joint first ### `getLidarPointCloud()` ```python Signature theme={null} getLidarPointCloud(lidar_name: str = '') -> Optional[PointCloud] ``` Get a point cloud from the named LiDAR sensor. Name of the lidar. If empty, uses the first available lidar. **Returns:** Optional\[PointCloud]: The point cloud, or None if lidar not found ### `getNamedPose()` ```python Signature theme={null} getNamedPose(pose_name: str) -> Optional[List[float]] ``` Get the list of joint angles corresponding to a named pose. Name of the pose to get (case-insensitive) **Returns:** list: Joint angles (radians) of the named pose, or None if the named pose does not exist ### `getOrientation()` ```python Signature theme={null} getOrientation() -> Orientation ``` Get the current end effector orientation with respect to the robot base **Returns:** Current orientation of the robot in world coordinates, or None if orientation is unavailable ### `getPose()` ```python Signature theme={null} getPose() -> Pose ``` Get the current end effector pose (position and orientation) in the robot base frame. **Returns:** Current Tool-Center-Point (TCP) pose. ### `getPosition()` ```python Signature theme={null} getPosition() -> Position ``` Get the current end effector position with respect to the robot base (meters). **Returns:** Current position of the robot in world coordinates, or None if position is unavailable ### `getState()` ```python Signature theme={null} getState(keys: Optional[Union[str, List[str]]] = None) -> Dict[str, Any] ``` Get a live state snapshot of this component's tree. Recursive walk owned by the base class, following the lifecycle template: each class contributes only the protected local hook `_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. **Returns:** The nested state snapshot when `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()` ```python Signature theme={null} grasp() -> None ``` Close the gripper to grasp an object. This method blocks until the gripper is fully closed or hits an obstacle. The gripper grasps with maximum force (80N) and maximum velocity (0.2 m/s). ### `moveToDeltaPose()` ```python Signature theme={null} moveToDeltaPose(delta_pose: Pose, blocking: bool = True) -> None ``` Offset the robot end effector by the specified delta pose from its current pose (with respect to the base frame). 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. Wait for movement to complete. Defaults to True. ### `moveToHome()` ```python Signature theme={null} moveToHome(blocking: bool = True) -> None ``` Move the arm to its predefined home pose. Equivalent to `moveToNamedPose("home", blocking=blocking)`. The `"home"` entry is registered in `named_poses` from the abstract `home_pose` property during `Arm.__init__`, so every concrete arm has it. Subclasses may add hardware-specific tuning parameters as keyword-only arguments after `blocking`. Wait for movement to complete. Defaults to True. ### `moveToNamedPose()` ```python Signature theme={null} moveToNamedPose(pose_name: str, blocking: bool = True) -> None ``` Move the robot to the joint angles of a named pose. Subclasses may add hardware-specific tuning parameters (timing, force thresholds, etc.) as keyword-only arguments after `blocking`. Name of the pose to move to (case-insensitive). Wait for movement to complete. Defaults to True. **Raises:** ValueError: If pose\_name is not found in the named poses dictionary. ### `moveToPose()` ```python Signature theme={null} moveToPose( pose: Pose, blocking: bool = True, *, moving_time: float = 2.0, accel_time: float = 0.5, high_frequency: bool = False, avoid_force: bool = False, ) -> bool ``` Move the robot end-effector to a specified pose Target pose (position in meters, orientation as a unit quaternion) in the robot's base frame. Wait for movement to complete. Defaults to True. seconds to complete the movement (unless you're already there) seconds to spend accelerating in a trapezoidal motion profile If False, send discrete commands that are executed by the robot's motion generator. Otherwise, continuously stream commands to be executed by the robot's low-level joint position controller. Currently unused. Not implemented yet **Returns:** True if the movement command ended without force or errors, False otherwise. **Raises:** ValueError: If moving\_time or accel\_time are not positive floats or ints. NotImplementedError: If high\_frequency is True. Not implemented yet. ### `release()` ```python Signature theme={null} release() -> None ``` Open the gripper to release an object. This method blocks until the gripper is open to its max width or hits an obstacle. The gripper releases with maximum force (80N) and maximum velocity (0.2 m/s). ### `removeNamedPose()` ```python Signature theme={null} removeNamedPose(pose_name: str) -> Optional[List[float]] ``` Remove a named pose from the dictionary of pose\_name:joint\_angles pairs. Name of the pose to remove (case-insensitive) **Returns:** list: Joint angles (radians) of the named pose that was removed, or None if the named pose did not exist ### `setJointAngles()` ```python Signature theme={null} setJointAngles( angles: list, blocking: bool = True, *, moving_time: Optional[float] = 2.0, accel_time: Optional[float] = 0.5, high_frequency: bool = False, ) -> bool ``` Set joint angles in radians. Commands the arm to move its joints to the specified angles. Can be blocking or non-blocking depending on the blocking parameter. If high\_frequency is False: a trapezoidal motion profile is generated (ending with zero velocity) with the given moving\_time and accel\_time, and the robot's internal motion generator will smoothen and execute the motion. If high\_frequency is True: the joint angles are continuously streamed directly to the robot's low-level joint position controller. It is assumed that this function is called in a high-frequency (\~1-100 Hz) control loop. This is useful for running models that assume full control of the robot, like Vision-Language-Action models, but doesn't behave well if there is a large delta in time or joint angles. List of target joint angles in radians, starting with the base joint. Wait for movement to complete (default True) seconds to complete the movement seconds to accelerate from zero to full velocity (another accel\_time is needed to decelerate to zero) If False, send discrete commands that are executed by the robot's motion generator. Otherwise, continuously stream commands to be executed by the robot's low-level joint position controller. **Returns:** True if the movement command was successful, False otherwise. **Raises:** ValueError: If angles list length does not match the number of joints. ValueError: If moving\_time or accel\_time are not positive floats or ints. ### `startFreeDrive()` ```python Signature theme={null} startFreeDrive() -> None ``` Enable free-drive (hand-guided) mode. The arm becomes compliant and can be moved by hand while supporting its own weight. Position-control commands such as `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()` ```python Signature theme={null} stop() -> None ``` Halt all motion across this component's tree (soft e-stop). Recursive walk owned by the base class: every subcomponent is stopped first (children before their parent, leaf-to-root; siblings in `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()` ```python Signature theme={null} validateGrasp() -> bool ``` Check whether the end effector is currently holding an object. Thin wrapper that delegates to the configured end effector's `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 as `robot.`; each read runs the getter on the robot. Joint angles (radians) with the arm over the workspace, joints at 90 degrees. 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 the [`EndEffector`](/python-api/robot-interface/endeffector) interface's. ## Not implemented on this robot Declared by the interface, raises `NotImplementedError` here: `followJointTrajectory`. ## 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 that `robot.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). The contract these methods implement is **Robot interface**; values returned are **grid-types** (camera reads return `Image` — call [`decode()`](/python-api/grid-types/image) for an ndarray). You reach the robot through [`connect`](/python-api/grid-nexus-client/connect). ## Related topics - [Arm](/python-api/robot-interface/arm.md) - [IsaacArm](/python-api/isaac-robots/isaacarm.md) - [Robot](/python-api/robot-interface/robot.md) - [Wheeled](/python-api/robot-interface/wheeled.md) - [AirGenCar](/python-api/airgen-robots/airgencar.md)