Implementation:ARISE Initiative Robosuite FixedBaseRobot
| Knowledge Sources | |
|---|---|
| Domains | Robotics, Manipulation |
| Last Updated | 2026-02-15 07:00 GMT |
Overview
The FixedBaseRobot class is the concrete robot implementation for stationary manipulators with a fixed base, providing full controller loading, action execution, and proprioceptive state tracking.
Description
FixedBaseRobot extends the base Robot class and is the primary implementation used for fixed-base robotic arms such as the Panda, Sawyer, IIWA, and similar manipulators. Unlike mobile robot subclasses, this class has no base, torso, or head controllers -- it manages only arm and gripper controllers.
The _load_controller method creates a composite controller via composite_controller_factory, loads arm controllers through _load_arm_controllers inherited from the parent, post-processes the controller configuration to remove unused parts, and then loads the final controller config. The control method validates the action dimension, updates the composite controller state, sets goals on policy steps, runs the controller to produce per-part actions, clips them to actuator control ranges, and applies them to the simulation. On policy steps, it also updates proprioceptive buffers for joint positions, actions, torques, and per-arm end-effector force-torque, pose, velocity, and acceleration.
The setup_references method extends the parent to build joint and actuator index dictionaries for each arm and gripper, and stores end-effector site IDs for visualization. The action_limits property delegates to the composite controller's action limits, and is_mobile returns False.
Usage
This is the most commonly used robot class in robosuite for tabletop manipulation tasks. It is instantiated by the environment when a fixed-base robot type (e.g., "Panda") is specified in the environment configuration.
Code Reference
Source Location
- Repository: ARISE_Initiative_Robosuite
- File: robosuite/robots/fixed_base_robot.py
Signature
class FixedBaseRobot(Robot):
def __init__(
self,
robot_type: str,
idn=0,
composite_controller_config=None,
initial_qpos=None,
initialization_noise=None,
base_type="default",
gripper_type="default",
control_freq=20,
lite_physics=True,
): ...
def _load_controller(self): ...
def load_model(self): ...
def reset(self, deterministic=False, rng=None): ...
def setup_references(self): ...
def control(self, action, policy_step=False): ...
def setup_observables(self) -> OrderedDict: ...
Import
from robosuite.robots.fixed_base_robot import FixedBaseRobot
I/O Contract
Inputs
| Name | Type | Required | Description |
|---|---|---|---|
| robot_type | str | Yes | Name of the fixed-base robot (e.g., "Panda", "Sawyer", "IIWA") |
| idn | int or str | No | Unique identifier for this robot instance |
| composite_controller_config | dict or None | No | Controller configuration. Defaults to robot-specific config |
| initial_qpos | sequence of float or None | No | Initial joint positions for the arm |
| initialization_noise | dict or None | No | Dict with 'magnitude' and 'type' for joint initialization noise |
| base_type | str | No | Type of base mount (default: "default") |
| gripper_type | str or None | No | Type of gripper (default: "default") |
| control_freq | float | No | Control frequency in Hz (default: 20) |
| lite_physics | bool | No | Use lite physics mode (default: True) |
Outputs
| Name | Type | Description |
|---|---|---|
| action_limits | tuple(np.array, np.array) | (low, high) action limits from the composite controller |
| is_mobile | bool | Always returns False for fixed base robots |
| _action_split_indexes | dict | Maps part names to (start_idx, end_idx) tuples in the action vector |
Usage Examples
import robosuite as suite
import numpy as np
# Create an environment with a fixed-base Panda robot
env = suite.make(
"Lift",
robots="Panda",
gripper_types="default",
control_freq=20,
has_renderer=False,
has_offscreen_renderer=False,
use_camera_obs=False,
)
obs = env.reset()
robot = env.robots[0]
# The robot is a FixedBaseRobot instance
assert robot.is_mobile == False
# Get action dimension and limits
action_dim = robot.action_dim
low, high = robot.action_limits
# Step with a zero action
action = np.zeros(action_dim)
obs, reward, done, info = env.step(action)