Implementation:ARISE Initiative Robosuite MobileRobot
| Knowledge Sources | |
|---|---|
| Domains | Robotics, Mobile Manipulation |
| Last Updated | 2026-02-15 07:00 GMT |
Overview
The MobileRobot class extends the base Robot class to provide shared functionality for all mobile robot types, including controller loading for base, torso, and head joints, and base-relative sensor observables.
Description
MobileRobot is an intermediate abstract class that serves as the parent for both WheeledRobot and LeggedRobot. It introduces the concept of a mobile base, torso, head, and legs as named body parts, each with their own controller configurations and actuator references. The class provides methods to load controllers for the base (_load_base_controller), torso (_load_torso_controller), and head (_load_head_controller) body parts, each of which reads its configuration from the robot model's default controller config files.
The class overrides setup_references to build actuator and joint index mappings for base, torso, and head components in addition to the arm and gripper references established by the parent class. It also overrides _create_base_sensors to produce proprioceptive observables specific to mobile robots: base_pos, base_quat, and per-arm base_to_eef_pos, base_to_eef_quat, and base_to_eef_quat_site sensors that report end-effector pose relative to the mobile base frame.
The enable_parts method is extended to accept boolean flags for torso, head, base, and legs in addition to right/left arms, allowing selective control of individual body subsystems. The is_mobile property returns True.
Usage
This class is not instantiated directly. Use WheeledRobot or LeggedRobot for concrete mobile robot implementations. Extend this class when creating a new type of mobile base locomotion.
Code Reference
Source Location
- Repository: ARISE_Initiative_Robosuite
- File: robosuite/robots/mobile_robot.py
Signature
class MobileRobot(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_base_controller(self): ...
def _load_torso_controller(self): ...
def _load_head_controller(self): ...
def _create_base_sensors(self, modality) -> tuple: ...
def enable_parts(self, right=True, left=True, torso=True, head=True, base=True, legs=True): ...
Import
from robosuite.robots.mobile_robot import MobileRobot
I/O Contract
Inputs
| Name | Type | Required | Description |
|---|---|---|---|
| robot_type | str | Yes | Specification for the mobile robot to instantiate |
| idn | int or str | No | Unique ID of this robot instance |
| composite_controller_config | dict or None | No | Configuration for composite controller |
| initial_qpos | sequence of float or None | No | Initial joint positions |
| initialization_noise | dict or None | No | Noise parameters for initialization |
| base_type | str | No | Type of mobile 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 | Whether to use lite physics mode (default: True) |
Outputs
| Name | Type | Description |
|---|---|---|
| is_mobile | bool | Always returns True for mobile robots (property) |
| base | str | Returns "base" as the base part name (property) |
| torso | str | Returns "torso" as the torso part name (property) |
| head | str | Returns "head" as the head part name (property) |
| legs | str | Returns "legs" as the legs part name (property) |
| _action_split_indexes | dict | Dictionary mapping part names to (start, end) action index tuples (property) |
Usage Examples
# MobileRobot is not used directly. Concrete subclasses are used instead.
# Example with a wheeled mobile robot in a robosuite environment:
import robosuite as suite
env = suite.make(
"Lift",
robots="GR1FixedLowerBody",
control_freq=20,
)
robot = env.robots[0]
# Check if robot is mobile
assert robot.is_mobile == True
# Enable/disable specific body parts
robot.enable_parts(right=True, left=True, torso=False, head=False, base=True, legs=False)