Implementation:ARISE Initiative Robosuite WheeledRobot
| Knowledge Sources | |
|---|---|
| Domains | Robotics, Mobile Manipulation |
| Last Updated | 2026-02-15 07:00 GMT |
Overview
The WheeledRobot class extends MobileRobot to implement robots with wheeled bases, providing controller orchestration and action execution for mobile manipulators that navigate via wheel actuators.
Description
WheeledRobot is a concrete subclass of MobileRobot designed for robots that use wheeled bases for locomotion. Unlike LeggedRobot, this class does not require leg controllers and does not apply actuator gear ratio scaling during control. The class inherits base, torso, and head controller loading methods from MobileRobot and composes them into its controller loading pipeline.
The _load_controller method creates the composite controller, loads arm controllers, base controller, head controller, and torso controller, post-processes the configuration, and enables all parts. The control method validates the action dimension, sets goals on policy steps, runs the composite controller to produce applied actions, clips them to actuator control ranges, and writes them to the simulation's control buffer. On policy steps, it updates proprioceptive buffers including joint positions, applied actions, torques, and per-arm end-effector force-torque, pose, velocity, and acceleration estimates.
The setup_references method delegates entirely to the parent MobileRobot implementation since wheeled robots do not introduce additional reference types beyond base, torso, and head. The action_limits property is delegated to the composite controller.
Usage
Use this class for robots with wheeled bases (e.g., mobile manipulator platforms). It is instantiated automatically by the environment when a wheeled robot type is specified.
Code Reference
Source Location
- Repository: ARISE_Initiative_Robosuite
- File: robosuite/robots/wheeled_robot.py
Signature
class WheeledRobot(MobileRobot):
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): ...
Import
from robosuite.robots.wheeled_robot import WheeledRobot
I/O Contract
Inputs
| Name | Type | Required | Description |
|---|---|---|---|
| robot_type | str | Yes | Name of the wheeled robot type to instantiate |
| idn | int or str | No | Unique identifier for this robot |
| composite_controller_config | dict or None | No | Controller configuration dictionary |
| initial_qpos | sequence of float or None | No | Initial arm joint positions |
| initialization_noise | dict or None | No | Joint initialization noise parameters |
| base_type | str | No | Type of wheeled base model (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 True (inherited from MobileRobot) |
Usage Examples
import robosuite as suite
import numpy as np
# Create environment with a wheeled mobile manipulator
env = suite.make(
"Lift",
robots="GR1FixedLowerBody",
control_freq=20,
)
robot = env.robots[0]
# Verify the robot is mobile
assert robot.is_mobile == True
# Get action dimension and execute a zero action
action = np.zeros(robot.action_dim)
obs, reward, done, info = env.step(action)
# Selectively enable parts
robot.enable_parts(right=True, left=False, base=True, torso=False, head=False, legs=False)