Add files using upload-large-folder tool

robosuite/controllers/__init__.py

@@ -0,0 +1,15 @@
+from .parts.controller_factory import controller_factory, load_part_controller_config
+from .composite import composite_controller_factory, ALL_COMPOSITE_CONTROLLERS
+from .composite.composite_controller_factory import load_composite_controller_config
+
+
+PART_CONTROLLER_INFO = {
+    "JOINT_VELOCITY": "Joint Velocity",
+    "JOINT_TORQUE": "Joint Torque",
+    "JOINT_POSITION": "Joint Position",
+    "OSC_POSITION": "Operational Space Control (Position Only)",
+    "OSC_POSE": "Operational Space Control (Position + Orientation)",
+    "IK_POSE": "Inverse Kinematics Control (Position + Orientation) (Note: must have PyBullet installed)",
+}
+
+ALL_PART_CONTROLLERS = PART_CONTROLLER_INFO.keys()

robosuite/controllers/composite/__init__.py

@@ -0,0 +1,19 @@
+from .composite_controller import CompositeController, HybridMobileBase, WholeBodyIK
+from .composite_controller import REGISTERED_COMPOSITE_CONTROLLERS_DICT
+
+ALL_COMPOSITE_CONTROLLERS = REGISTERED_COMPOSITE_CONTROLLERS_DICT.keys()
+
+
+def composite_controller_factory(type, sim, robot_model, grippers):
+    assert type in REGISTERED_COMPOSITE_CONTROLLERS_DICT, f"{type} controller is specified, but not imported or loaded"
+    # Note: Currently we assume that the init arguments are same for all composite controllers. The situation might change given new controllers in the future, and we will adjust accodingly.
+
+    # The default composite controllers are explicitly initialized without using the COMPOSITE_CONTORLLERS
+    if type == "BASIC":
+        return CompositeController(sim, robot_model, grippers)
+    elif type == "HYBRID_MOBILE_BASE":
+        return HybridMobileBase(sim, robot_model, grippers)
+    elif type == "WHOLE_BODY_IK":
+        return WholeBodyIK(sim, robot_model, grippers)
+    else:
+        return REGISTERED_COMPOSITE_CONTROLLERS_DICT[type](sim, robot_model, grippers)

robosuite/controllers/composite/composite_controller.py

@@ -0,0 +1,588 @@
+import json
+import re
+from collections import OrderedDict
+from typing import Dict, Optional, Tuple
+
+import numpy as np
+
+from robosuite.controllers import controller_factory
+from robosuite.models.grippers.gripper_model import GripperModel
+from robosuite.models.robots.robot_model import RobotModel
+from robosuite.utils.binding_utils import MjSim
+from robosuite.utils.ik_utils import IKSolver, get_nullspace_gains
+from robosuite.utils.log_utils import ROBOSUITE_DEFAULT_LOGGER
+
+REGISTERED_COMPOSITE_CONTROLLERS_DICT = {}
+
+
+def register_composite_controller(target_class):
+    if not hasattr(target_class, "name"):
+        ROBOSUITE_DEFAULT_LOGGER.warning(
+            "The name of the composite controller is not specified. Using the class name as the key."
+        )
+        key = "_".join(re.sub(r"([A-Z0-9])", r" \1", target_class.__name__).split()).upper()
+    else:
+        key = target_class.name
+    REGISTERED_COMPOSITE_CONTROLLERS_DICT[key] = target_class
+    return target_class
+
+
+@register_composite_controller
+class CompositeController:
+    """This is the parent class for all composite controllers. If you want to develop an advanced version of your controller, you should subclass from this composite controller."""
+
+    name = "BASIC"
+
+    def __init__(self, sim: MjSim, robot_model: RobotModel, grippers: Dict[str, GripperModel]):
+        # TODO: grippers repeat with members inside robot_model. Currently having this additioanl field to make naming query easy.
+        self.sim = sim
+        self.robot_model = robot_model
+
+        self.grippers = grippers
+
+        self.part_controllers = OrderedDict()
+
+        self._action_split_indexes = OrderedDict()
+
+        self.part_controller_config = None
+
+        self.arms = self.robot_model.arms
+
+        self._applied_action_dict = {}
+
+    def load_controller_config(
+        self, part_controller_config, composite_controller_specific_config: Optional[Dict] = None
+    ):
+        self.composite_controller_specific_config = composite_controller_specific_config
+        body_part_ordering = self.composite_controller_specific_config.get("body_part_ordering", None)
+        if body_part_ordering is not None:
+            self.part_controller_config = OrderedDict()
+            assert len(body_part_ordering) == len(part_controller_config)
+            for part_name in body_part_ordering:
+                self.part_controller_config[part_name] = part_controller_config[part_name]
+        else:
+            self.part_controller_config = part_controller_config
+
+        self.part_controllers.clear()
+        self._action_split_indexes.clear()
+        self._init_controllers()
+        self._validate_composite_controller_specific_config()
+        self.setup_action_split_idx()
+
+    def _init_controllers(self):
+        for part_name in self.part_controller_config.keys():
+            controller_params = self.part_controller_config[part_name]
+            self.part_controllers[part_name] = controller_factory(
+                part_name=part_name,
+                controller_type=self.part_controller_config[part_name]["type"],
+                controller_params=controller_params,
+            )
+
+    def _validate_composite_controller_specific_config(self):
+        """Some aspects of composite controller specific configs, if they exist,
+        may only be verified once the part controller are initialized."""
+        pass
+
+    def setup_action_split_idx(self):
+        previous_idx = 0
+        last_idx = 0
+        for part_name, controller in self.part_controllers.items():
+            if part_name in self.grippers.keys():
+                last_idx += self.grippers[part_name].dof
+            else:
+                last_idx += controller.control_dim
+            self._action_split_indexes[part_name] = (previous_idx, last_idx)
+            previous_idx = last_idx
+
+    def set_goal(self, all_action):
+        for part_name, controller in self.part_controllers.items():
+            start_idx, end_idx = self._action_split_indexes[part_name]
+            action = all_action[start_idx:end_idx]
+            if part_name in self.grippers.keys():
+                action = self.grippers[part_name].format_action(action)
+            controller.set_goal(action)
+
+    def reset(self):
+        for part_name, controller in self.part_controllers.items():
+            controller.reset_goal()
+
+    def run_controller(self, enabled_parts):
+        self.update_state()
+        self._applied_action_dict.clear()
+        for part_name, controller in self.part_controllers.items():
+            if enabled_parts.get(part_name, False):
+                self._applied_action_dict[part_name] = controller.run_controller()
+
+        return self._applied_action_dict
+
+    def get_control_dim(self, part_name):
+        if part_name not in self.part_controllers:
+            return 0
+        else:
+            return self.part_controllers[part_name].control_dim
+
+    def get_controller_base_pose(self, controller_name):
+        """
+        Get the base position and orientation of a specified controller's part. Note: this pose may likely differ from
+        the robot base's pose.
+
+        Args:
+            controller_name (str): The name of the controller, used to look up part-specific information.
+
+        Returns:
+            tuple[np.ndarray, np.ndarray]: A tuple containing:
+                - base_pos (np.ndarray): The 3D position of the part's center in world coordinates (shape: (3,)).
+                - base_ori (np.ndarray): The 3x3 rotation matrix representing the part's orientation in world coordinates.
+
+        Details:
+            - Uses the controller's `naming_prefix` and `part_name` to construct the corresponding site name.
+            - Queries the simulation (`self.sim`) for the site's position (`site_xpos`) and orientation (`site_xmat`).
+            - The site orientation matrix is reshaped from a flat array of size 9 to a 3x3 rotation matrix.
+        """
+        naming_prefix = self.part_controllers[controller_name].naming_prefix
+        part_name = self.part_controllers[controller_name].part_name
+        base_pos = np.array(self.sim.data.site_xpos[self.sim.model.site_name2id(f"{naming_prefix}{part_name}_center")])
+        base_ori = np.array(
+            self.sim.data.site_xmat[self.sim.model.site_name2id(f"{naming_prefix}{part_name}_center")].reshape([3, 3])
+        )
+        return base_pos, base_ori
+
+    def update_state(self):
+        for arm in self.arms:
+            base_pos, base_ori = self.get_controller_base_pose(controller_name=arm)
+            self.part_controllers[arm].update_origin(base_pos, base_ori)
+
+    def get_controller(self, part_name):
+        return self.part_controllers[part_name]
+
+    @property
+    def action_limits(self):
+        low, high = [], []
+        for part_name, controller in self.part_controllers.items():
+            if part_name not in self.arms:
+                if part_name in self.grippers.keys():
+                    low_g, high_g = (
+                        [-1] * self.grippers[part_name].dof,
+                        [1] * self.grippers[part_name].dof,
+                    )
+                    low, high = np.concatenate([low, low_g]), np.concatenate([high, high_g])
+                else:
+                    control_dim = controller.control_dim
+                    low_c, high_c = ([-1] * control_dim, [1] * control_dim)
+                    low, high = np.concatenate([low, low_c]), np.concatenate([high, high_c])
+            else:
+                low_c, high_c = controller.control_limits
+                low, high = np.concatenate([low, low_c]), np.concatenate([high, high_c])
+        return low, high
+
+    def create_action_vector(self, action_dict):
+        """
+        A helper function that creates the action vector given a dictionary
+        """
+        full_action_vector = np.zeros(self.action_limits[0].shape)
+        for part_name, action_vector in action_dict.items():
+            if part_name not in self._action_split_indexes:
+                ROBOSUITE_DEFAULT_LOGGER.debug(f"{part_name} is not specified in the action space")
+                continue
+            start_idx, end_idx = self._action_split_indexes[part_name]
+            if end_idx - start_idx == 0:
+                # skipping not controlling actions
+                continue
+            assert len(action_vector) == (end_idx - start_idx), ROBOSUITE_DEFAULT_LOGGER.error(
+                f"Action vector for {part_name} is not the correct size. Expected {end_idx - start_idx} for {part_name}, got {len(action_vector)}"
+            )
+            full_action_vector[start_idx:end_idx] = action_vector
+        return full_action_vector
+
+    def create_action_dict_from_action_vector(self, action_vector):
+        action_dict = {}
+        for part_name, (start_idx, end_idx) in self._action_split_indexes.items():
+            action_dict[part_name] = action_vector[start_idx:end_idx]
+        return action_dict
+
+    def get_action_info(self):
+        action_index_info = []
+        action_dim_info = []
+        for part_name, (
+            start_idx,
+            end_idx,
+        ) in self._action_split_indexes.items():
+            action_dim_info.append(f"{part_name}: {(end_idx - start_idx)} dim")
+            action_index_info.append(f"{part_name}: {start_idx}:{end_idx}")
+
+        return action_index_info, action_dim_info
+
+    def print_action_info(self):
+        action_index_info, action_dim_info = self.get_action_info()
+        action_index_info_str = ", ".join(action_index_info)
+        action_dim_info_str = ", ".join(action_dim_info)
+        ROBOSUITE_DEFAULT_LOGGER.info(f"Action Dimensions: [{action_dim_info_str}]")
+        ROBOSUITE_DEFAULT_LOGGER.info(f"Action Indices: [{action_index_info_str}]")
+
+    def get_action_info_dict(self):
+        info_dict = {}
+        info_dict["Action Dimension"] = self.action_limits[0].shape
+        info_dict.update(dict(self._action_split_indexes))
+        return info_dict
+
+    def print_action_info_dict(self, name: str = ""):
+        info_dict = self.get_action_info_dict()
+        info_dict_str = f"\nAction Info for {name}:\n\n{json.dumps(dict(info_dict), indent=4)}"
+        ROBOSUITE_DEFAULT_LOGGER.info(info_dict_str)
+
+
+@register_composite_controller
+class HybridMobileBase(CompositeController):
+    name = "HYBRID_MOBILE_BASE"
+
+    def set_goal(self, all_action):
+        action_mode = all_action[-1]
+        if action_mode > 0:
+            update_wrt_origin = True
+        else:
+            update_wrt_origin = False
+
+        for part_name, controller in self.part_controllers.items():
+            start_idx, end_idx = self._action_split_indexes[part_name]
+            action = all_action[start_idx:end_idx]
+            if part_name in self.grippers.keys():
+                action = self.grippers[part_name].format_action(action)
+
+            if part_name in self.arms and hasattr(controller, "set_goal_update_mode"):
+                """
+                Query the last action dimension to determine if using
+                base mode (value > 0) or arm mode (value < 1).
+                If in base mode, update the new arm goal based on current desired goal,
+                to have the arm tracking with the reset of the moving base
+                as closely as possible without lagging or overshooting.
+                """
+                action_mode = all_action[-1]
+                if action_mode > 0:
+                    goal_update_mode = "desired"
+                else:
+                    goal_update_mode = "achieved"
+                controller.set_goal_update_mode(goal_update_mode)
+
+            controller.set_goal(action)
+
+    @property
+    def action_limits(self):
+        low, high = super().action_limits
+        return np.concatenate((low, [-1])), np.concatenate((high, [1]))
+
+    def create_action_vector(self, action_dict):
+        """
+        A helper function that creates the action vector given a dictionary
+        """
+        full_action_vector = np.zeros(self.action_limits[0].shape)
+        for part_name, action_vector in action_dict.items():
+            if part_name not in self._action_split_indexes:
+                ROBOSUITE_DEFAULT_LOGGER.debug(f"{part_name} is not specified in the action space")
+                continue
+            start_idx, end_idx = self._action_split_indexes[part_name]
+            if end_idx - start_idx == 0:
+                # skipping not controlling actions
+                continue
+            assert len(action_vector) == (end_idx - start_idx), ROBOSUITE_DEFAULT_LOGGER.error(
+                f"Action vector for {part_name} is not the correct size. Expected {end_idx - start_idx} for {part_name}, got {len(action_vector)}"
+            )
+            full_action_vector[start_idx:end_idx] = action_vector
+        full_action_vector[-1] = action_dict.get("base_mode", -1)
+        return full_action_vector
+
+
+@register_composite_controller
+class WholeBody(CompositeController):
+    name = "WHOLE_BODY_COMPOSITE"
+
+    def __init__(self, sim: MjSim, robot_model: RobotModel, grippers: Dict[str, GripperModel]):
+        super().__init__(sim, robot_model, grippers)
+
+        self.joint_action_policy: IKSolver = None
+        # TODO: handle different types of joint action policies; joint_action_policy maps
+        # task space actions (such as end effector poses) to joint actions (such as joint angles or joint torques)
+
+        self._whole_body_controller_action_split_indexes: OrderedDict = OrderedDict()
+
+    def _init_controllers(self):
+        for part_name in self.part_controller_config.keys():
+            controller_params = self.part_controller_config[part_name]
+            self.part_controllers[part_name] = controller_factory(
+                part_name=part_name,
+                controller_type=self.part_controller_config[part_name]["type"],
+                controller_params=controller_params,
+            )
+        # for whole body composite controller, validate before init_joint_action_policy
+        self._validate_composite_controller_specific_config()
+        self._init_joint_action_policy()
+
+    def _init_joint_action_policy(self):
+        """Joint action policy initialization.
+
+        Joint action policy converts input targets (such as end-effector poses, head poses) to joint actions
+        (such as joint angles or joint torques).
+
+        Examples of joint_action_policy could be an IK policy, a neural network policy, a model predictive controller, etc.
+        """
+        raise NotImplementedError("WholeBody CompositeController requires a joint action policy")
+
+    def setup_action_split_idx(self):
+        """
+        Action split indices for the underlying factorized controllers.
+
+        WholeBody controller takes in a different action space from the
+        underlying factorized controllers for individual body parts.
+        """
+        previous_idx = 0
+        last_idx = 0
+        # add joint_action_policy related body parts' action split index first
+        for part_name in self.composite_controller_specific_config["actuation_part_names"]:
+            try:
+                last_idx += self.part_controllers[part_name].control_dim
+            except KeyError as e:
+                import ipdb
+
+                ipdb.set_trace()
+                raise KeyError(f"Part name '{part_name}' not found in part_controllers: {e}")
+            self._action_split_indexes[part_name] = (previous_idx, last_idx)
+            previous_idx = last_idx
+
+        for part_name, controller in self.part_controllers.items():
+            if part_name not in self.composite_controller_specific_config["actuation_part_names"]:
+                if part_name in self.grippers.keys():
+                    last_idx += self.grippers[part_name].dof
+                else:
+                    last_idx += controller.control_dim
+                self._action_split_indexes[part_name] = (previous_idx, last_idx)
+                previous_idx = last_idx
+
+        self.setup_whole_body_controller_action_split_idx()
+
+    def setup_whole_body_controller_action_split_idx(self):
+        """
+        Action split indices for the composite controller's input action space.
+
+        WholeBodyIK composite controller takes in a different action space from the
+        underlying factorized controllers.
+        """
+        # add joint_action_policy's action split indexes first
+        self._whole_body_controller_action_split_indexes.update(self.joint_action_policy.action_split_indexes())
+
+        # prev and last index correspond to the IK solver indexes' last index
+        previous_idx = last_idx = list(self._whole_body_controller_action_split_indexes.values())[-1][-1]
+        for part_name, controller in self.part_controllers.items():
+            if part_name in self.composite_controller_specific_config["actuation_part_names"]:
+                continue
+            if part_name in self.grippers.keys():
+                last_idx += self.grippers[part_name].dof
+            else:
+                last_idx += controller.control_dim
+            self._whole_body_controller_action_split_indexes[part_name] = (previous_idx, last_idx)
+            previous_idx = last_idx
+
+    def set_goal(self, all_action):
+        if self.composite_controller_specific_config.get("skip_wbc_action", False):
+            super().set_goal(all_action)
+            return
+
+        target_qpos = self.joint_action_policy.solve(all_action[: self.joint_action_policy.control_dim])
+        # create new all_action vector with the IK solver's actions first
+        all_action = np.concatenate([target_qpos, all_action[self.joint_action_policy.control_dim :]])
+        for part_name, controller in self.part_controllers.items():
+            start_idx, end_idx = self._action_split_indexes[part_name]
+            action = all_action[start_idx:end_idx]
+            if part_name in self.grippers.keys():
+                action = self.grippers[part_name].format_action(action)
+            controller.set_goal(action)
+
+    def update_state(self):
+        # no need for extra update state here, since Jacobians are computed inside the controllers of individual body parts
+        return
+
+    @property
+    def action_limits(self):
+        """
+        Returns the action limits for the whole body controller.
+        Corresponds to each term in the action vector passed to env.step().
+        """
+        if self.composite_controller_specific_config.get("skip_wbc_action", False):
+            return super().action_limits
+
+        low, high = [], []
+        # assumption: IK solver's actions come first
+        low_c, high_c = self.joint_action_policy.control_limits
+        low, high = np.concatenate([low, low_c]), np.concatenate([high, high_c])
+        for part_name, controller in self.part_controllers.items():
+            # Exclude terms that the IK solver handles
+            if part_name in self.composite_controller_specific_config["actuation_part_names"]:
+                continue
+            if part_name not in self.arms:
+                if part_name in self.grippers.keys():
+                    low_g, high_g = (
+                        [-1] * self.grippers[part_name].dof,
+                        [1] * self.grippers[part_name].dof,
+                    )
+                    low, high = np.concatenate([low, low_g]), np.concatenate([high, high_g])
+                else:
+                    control_dim = controller.control_dim
+                    low_c, high_c = ([-1] * control_dim, [1] * control_dim)
+                    low, high = np.concatenate([low, low_c]), np.concatenate([high, high_c])
+            else:
+                low_c, high_c = controller.control_limits
+                low, high = np.concatenate([low, low_c]), np.concatenate([high, high_c])
+        return low, high
+
+    def create_action_vector(self, action_dict: Dict[str, np.ndarray]) -> np.ndarray:
+        if self.composite_controller_specific_config.get("skip_wbc_action", False):
+            return super().create_action_vector(action_dict)
+
+        full_action_vector = np.zeros(self.action_limits[0].shape)
+        for part_name, action_vector in action_dict.items():
+            if part_name not in self._whole_body_controller_action_split_indexes:
+                ROBOSUITE_DEFAULT_LOGGER.debug(f"{part_name} is not specified in the action space")
+                continue
+            start_idx, end_idx = self._whole_body_controller_action_split_indexes[part_name]
+            if end_idx - start_idx == 0:
+                # skipping not controlling actions
+                continue
+            assert len(action_vector) == (end_idx - start_idx), ROBOSUITE_DEFAULT_LOGGER.error(
+                f"Action vector for {part_name} is not the correct size. Expected {end_idx - start_idx} for {part_name}, got {len(action_vector)}"
+            )
+            full_action_vector[start_idx:end_idx] = action_vector
+        return full_action_vector
+
+    def create_action_dict_from_action_vector(self, action_vector):
+        if self.composite_controller_specific_config.get("skip_wbc_action", False):
+            return super().create_action_dict_from_action_vector(action_vector)
+
+        action_dict = {}
+        for part_name, (start_idx, end_idx) in self._whole_body_controller_action_split_indexes.items():
+            action_dict[part_name] = action_vector[start_idx:end_idx]
+        return action_dict
+
+    def get_action_info(self):
+        if self.composite_controller_specific_config.get("skip_wbc_action", False):
+            return super().get_action_info()
+
+        action_index_info = []
+        action_dim_info = []
+        for part_name, (
+            start_idx,
+            end_idx,
+        ) in self._whole_body_controller_action_split_indexes.items():
+            action_dim_info.append(f"{part_name}: {(end_idx - start_idx)} dim")
+            action_index_info.append(f"{part_name}: {start_idx}:{end_idx}")
+        return action_index_info, action_dim_info
+
+    def print_action_info(self):
+        if self.composite_controller_specific_config.get("skip_wbc_action", False):
+            return super().print_action_info()
+
+        action_index_info, action_dim_info = self.get_action_info()
+        action_index_info_str = ", ".join(action_index_info)
+        action_dim_info_str = ", ".join(action_dim_info)
+        ROBOSUITE_DEFAULT_LOGGER.info(f"Action Dimensions: [{action_dim_info_str}]")
+        ROBOSUITE_DEFAULT_LOGGER.info(f"Action Indices: [{action_index_info_str}]")
+
+    def get_action_info_dict(self):
+        if self.composite_controller_specific_config.get("skip_wbc_action", False):
+            return super().get_action_info_dict()
+
+        info_dict = {}
+        info_dict["Action Dimension"] = self.action_limits[0].shape
+        info_dict.update(dict(self._whole_body_controller_action_split_indexes))
+        return info_dict
+
+    def get_action_info_dict(self):
+        if self.composite_controller_specific_config.get("skip_wbc_action", False):
+            return super().get_action_info_dict()
+
+        info_dict = {}
+        info_dict["Action Dimension"] = self.action_limits[0].shape
+        info_dict.update(dict(self._whole_body_controller_action_split_indexes))
+        return info_dict
+
+    def print_action_info_dict(self, name: str = ""):
+        if self.composite_controller_specific_config.get("skip_wbc_action", False):
+            return super().print_action_info_dict(name)
+
+        info_dict = self.get_action_info_dict()
+        info_dict_str = f"\nAction Info for {name}:\n\n{json.dumps(dict(info_dict), indent=4)}"
+        ROBOSUITE_DEFAULT_LOGGER.info(info_dict_str)
+
+
+@register_composite_controller
+class WholeBodyIK(WholeBody):
+    name = "WHOLE_BODY_IK"
+
+    def __init__(self, sim: MjSim, robot_model: RobotModel, grippers: Dict[str, GripperModel]):
+        super().__init__(sim, robot_model, grippers)
+
+    def _validate_composite_controller_specific_config(self) -> None:
+        # Check that all actuation_part_names exist in part_controllers
+        original_ik_controlled_parts = self.composite_controller_specific_config["actuation_part_names"]
+        self.valid_ik_controlled_parts = []
+        valid_ref_names = []
+
+        assert (
+            "ref_name" in self.composite_controller_specific_config
+        ), "The 'ref_name' key is missing from composite_controller_specific_config."
+
+        for part in original_ik_controlled_parts:
+            if part in self.part_controllers:
+                self.valid_ik_controlled_parts.append(part)
+            else:
+                ROBOSUITE_DEFAULT_LOGGER.warning(
+                    f"Part '{part}' specified in 'actuation_part_names' "
+                    "does not exist in part_controllers. Removing ..."
+                )
+
+        # Update the configuration with only the valid parts
+        self.composite_controller_specific_config["actuation_part_names"] = self.valid_ik_controlled_parts
+
+        # Loop through ref_names and validate against mujoco model
+        original_ref_names = self.composite_controller_specific_config.get("ref_name", [])
+        for ref_name in original_ref_names:
+            if ref_name in self.sim.model.site_names:  # Check if the site exists in the mujoco model
+                valid_ref_names.append(ref_name)
+            else:
+                ROBOSUITE_DEFAULT_LOGGER.warning(
+                    f"Reference name '{ref_name}' specified in configuration"
+                    " does not exist in the mujoco model. Removing ..."
+                )
+
+        # Update the configuration with only the valid reference names
+        self.composite_controller_specific_config["ref_name"] = valid_ref_names
+
+    def _init_joint_action_policy(self):
+        joint_names: str = []
+        for part_name in self.composite_controller_specific_config["actuation_part_names"]:
+            if part_name in self.part_controllers:
+                joint_names += self.part_controllers[part_name].joint_names
+            else:
+                ROBOSUITE_DEFAULT_LOGGER.warning(
+                    f"{part_name} is not a valid part name in part_controllers." " Skipping this part for IK control."
+                )
+
+        # Compute nullspace gains, Kn.
+        Kn = get_nullspace_gains(joint_names, self.composite_controller_specific_config["nullspace_joint_weights"])
+        mocap_bodies = []
+        robot_config = {
+            "end_effector_sites": self.composite_controller_specific_config["ref_name"],
+            "joint_names": joint_names,
+            "mocap_bodies": mocap_bodies,
+            "nullspace_gains": Kn,
+        }
+        self.joint_action_policy = IKSolver(
+            model=self.sim.model._model,
+            data=self.sim.data._data,
+            robot_config=robot_config,
+            damping=self.composite_controller_specific_config.get("ik_pseudo_inverse_damping", 5e-2),
+            integration_dt=self.composite_controller_specific_config.get("ik_integration_dt", 0.1),
+            max_dq=self.composite_controller_specific_config.get("ik_max_dq", 4),
+            max_dq_torso=self.composite_controller_specific_config.get("ik_max_dq_torso", 0.2),
+            input_rotation_repr=self.composite_controller_specific_config.get("ik_input_rotation_repr", "axis_angle"),
+            input_ref_frame=self.composite_controller_specific_config.get("ik_input_ref_frame", "world"),
+            input_type=self.composite_controller_specific_config.get("ik_input_type", "axis_angle"),
+            debug=self.composite_controller_specific_config.get("verbose", False),
+        )

robosuite/controllers/composite/composite_controller_factory.py

@@ -0,0 +1,156 @@
+import copy
+import json
+import os
+import pathlib
+from typing import Dict, Literal, Optional
+
+import robosuite
+from robosuite.controllers.composite.composite_controller import REGISTERED_COMPOSITE_CONTROLLERS_DICT
+from robosuite.controllers.parts.controller_factory import load_part_controller_config
+from robosuite.utils.log_utils import ROBOSUITE_DEFAULT_LOGGER
+
+
+def validate_composite_controller_config(config: dict):
+    # Check top-level keys
+    required_keys = ["type", "body_parts"]
+    for key in required_keys:
+        if key not in config:
+            ROBOSUITE_DEFAULT_LOGGER.error(f"Missing top-level key: {key}")
+            raise ValueError
+
+
+def is_part_controller_config(config: Dict):
+    """
+    Checks if a controller config is a part config as a opposed to a composite
+    controller config.
+
+    Args:
+        config (dict): Controller configuration
+
+    Returns:
+        bool: True if the config is in the for the arm-only, False otherwise
+    """
+
+    PART_CONTROLLER_TYPES = ["JOINT_VELOCITY", "JOINT_TORQUE", "JOINT_POSITION", "OSC_POSITION", "OSC_POSE", "IK_POSE"]
+    if "body_parts" not in config and "type" in config:
+        return config["type"] in PART_CONTROLLER_TYPES
+    return False
+
+
+def refactor_composite_controller_config(controller_config, robot_type, arms):
+    """
+    Checks if a controller config is in the format from robosuite versions <= 1.4.1.
+    If this is the case, converts the controller config to the new composite controller
+    config format in robosuite versions >= 1.5. If the robot has a default
+    controller config use that and override the arms with the old controller config.
+    If not just use the old controller config for arms.
+
+    Args:
+        old_controller_config (dict): Old controller config
+
+    Returns:
+        dict: New controller config
+    """
+    if not is_part_controller_config(controller_config):
+        return controller_config
+
+    config_dir = pathlib.Path(robosuite.__file__).parent / "controllers/config/robots/"
+    name = robot_type.lower()
+    configs = os.listdir(config_dir)
+    if f"default_{name}.json" in configs:
+        new_controller_config = load_composite_controller_config(robot=name)
+    else:
+        new_controller_config = {}
+        new_controller_config["type"] = "BASIC"
+        new_controller_config["body_parts"] = {}
+
+    for arm in arms:
+        new_controller_config["body_parts"][arm] = copy.deepcopy(controller_config)
+        new_controller_config["body_parts"][arm]["gripper"] = {"type": "GRIP"}
+    return new_controller_config
+
+
+def load_composite_controller_config(controller: Optional[str] = None, robot: Optional[str] = None) -> Optional[Dict]:
+    """
+    Utility function that loads the desired composite controller and returns the loaded configuration as a dict
+
+    Args:
+        controller: Name or path of the controller to load.
+            If None, robot must be specified and we load the robot's default controller in controllers/config/robots/.
+            If specified, must be a valid controller name or path to a controller config file.
+        robot: Name of the robot to load the controller for.
+
+    Returns:
+        dict: Controller configuration
+
+    Raises:
+        FileNotFoundError: If the controller file is not found
+    """
+    # Determine the controller file path
+    if controller is None:
+        assert robot is not None, "If controller is None, robot must be specified."
+        # Load robot's controller
+        robot_name = _get_robot_name(robot)
+        controller_fpath = (
+            pathlib.Path(robosuite.__file__).parent / f"controllers/config/robots/default_{robot_name}.json"
+        )
+        if not os.path.exists(controller_fpath):
+            controller_fpath = (
+                pathlib.Path(robosuite.__file__).parent / "controllers/config/default/composite/basic.json"
+            )
+    elif isinstance(controller, str):
+        if controller.endswith(".json"):
+            # Use the specified path directly
+            controller_fpath = controller
+        else:
+            assert (
+                controller in REGISTERED_COMPOSITE_CONTROLLERS_DICT
+            ), f"Controller {controller} not found in COMPOSITE_CONTROLLERS_DICT"
+            # Load from robosuite/controllers/config/default/composite/
+            controller_name = controller.lower()
+            controller_fpath = (
+                pathlib.Path(robosuite.__file__).parent / f"controllers/config/default/composite/{controller_name}.json"
+            )
+    else:
+        raise ValueError("Controller must be None or a string.")
+
+    # Attempt to load the controller
+    try:
+        with open(controller_fpath) as f:
+            composite_controller_config = json.load(f)
+        ROBOSUITE_DEFAULT_LOGGER.info(f"Loading controller configuration from: {controller_fpath}")
+    except FileNotFoundError:
+        ROBOSUITE_DEFAULT_LOGGER.error(
+            f"Error opening controller filepath at: {controller_fpath}. Please check filepath and try again."
+        )
+        raise
+
+    validate_composite_controller_config(composite_controller_config)
+    body_parts_controller_configs = composite_controller_config.pop("body_parts", {})
+    composite_controller_config["body_parts"] = {}
+    for part_name, part_config in body_parts_controller_configs.items():
+        if part_name == "arms":
+            for arm_name, arm_config in part_config.items():
+                composite_controller_config["body_parts"][arm_name] = arm_config
+        else:
+            composite_controller_config["body_parts"][part_name] = part_config
+
+    return composite_controller_config
+
+
+def _get_robot_name(robot: str) -> str:
+    """Helper function to get the standardized robot name."""
+    if "GR1FloatingBody" in robot:
+        return "gr1_floating_body"
+    elif "GR1FixedLowerBody" in robot:
+        return "gr1_fixed_lower_body"
+    elif "GR1" in robot:
+        return "gr1"
+    elif "G1" in robot:
+        return "g1"
+    elif "H1" in robot:
+        return "h1"
+    elif "PandaDex" in robot:
+        return "panda_dex"
+    else:
+        return robot.lower()

robosuite/controllers/config/default/composite/basic.json

@@ -0,0 +1,97 @@
+{
+    "type": "BASIC",
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            },
+            "left": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            }
+        },
+        "torso": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "head": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "base": {
+            "type": "JOINT_VELOCITY",
+            "interpolation": "null"
+        },
+        "legs": {
+            "type": "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        }
+    }
+}

robosuite/controllers/config/default/composite/hybrid_mobile_base.json

@@ -0,0 +1,97 @@
+{
+    "type": "HYBRID_MOBILE_BASE",
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            },
+            "left": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            }
+        },
+        "torso": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "head": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "base": {
+            "type": "JOINT_VELOCITY",
+            "interpolation": "null"
+        },
+        "legs": {
+            "type": "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        }
+    }
+}

robosuite/controllers/config/default/composite/whole_body_ik.json

@@ -0,0 +1,115 @@
+{
+    "type": "WHOLE_BODY_IK",
+    "composite_controller_specific_configs": {
+        "ref_name": ["gripper0_right_grip_site", "gripper0_left_grip_site"],
+        "interpolation": null,
+        "actuation_part_names": ["torso", "head", "right", "left", "base", "legs"],
+        "max_dq": 4,
+        "nullspace_joint_weights": {
+            "robot0_torso_waist_yaw": 100.0,
+            "robot0_torso_waist_pitch": 100.0,
+            "robot0_torso_waist_roll": 500.0,
+            "robot0_l_shoulder_pitch": 4.0,
+            "robot0_r_shoulder_pitch": 4.0,
+            "robot0_l_shoulder_roll": 3.0,
+            "robot0_r_shoulder_roll": 3.0,
+            "robot0_l_shoulder_yaw": 2.0,
+            "robot0_r_shoulder_yaw": 2.0
+        },
+        "ik_pseudo_inverse_damping": 5e-2,
+        "ik_integration_dt": 1e-1,
+        "ik_max_dq": 4.0,
+        "ik_max_dq_torso": 0.2,
+        "ik_input_type": "absolute",
+        "ik_input_rotation_repr": "axis_angle",
+        "verbose": false
+    },
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type" : "JOINT_POSITION",
+                "input_max": 1,
+                "input_min": -1,
+                "input_type": "absolute",
+                "output_max": 0.5,
+                "output_min": -0.5,
+                "kd": 200,
+                "kv": 200,
+                "kp": 1000,
+                "velocity_limits": [-1,1],
+                "kp_limits": [0, 1000],
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            },
+            "left": {
+                "type" : "JOINT_POSITION",
+                "input_max": 1,
+                "input_min": -1,
+                "input_type": "absolute",
+                "output_max": 0.5,
+                "output_min": -0.5,
+                "kd": 200,
+                "kv": 200,
+                "kp": 1000,
+                "velocity_limits": [-1,1],
+                "kp_limits": [0, 1000],
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            }
+        },
+        "torso": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "input_type": "absolute",
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "head": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "input_type": "absolute",
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "base": {
+            "type" : "JOINT_VELOCITY",
+            "interpolation": null
+        },
+        "legs": {
+            "type": "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        }
+    }
+}

robosuite/controllers/config/default/composite/whole_body_mink_ik.json

@@ -0,0 +1,101 @@
+{
+    "type": "WHOLE_BODY_MINK_IK",
+    "composite_controller_specific_configs": {
+        "ref_name": ["gripper0_right_grip_site", "gripper0_left_grip_site"],
+        "interpolation": null,
+        "actuation_part_names": ["torso", "head", "right", "left"],
+        "max_dq": 4,
+        "ik_pseudo_inverse_damping": 5e-2,
+        "ik_integration_dt": 1e-1,
+        "ik_input_type": "absolute",
+        "ik_input_ref_frame": "world",
+        "ik_input_rotation_repr": "axis_angle",
+        "verbose": false,
+        "ik_posture_weights": {
+            "robot0_torso_waist_yaw": 10.0,
+            "robot0_torso_waist_pitch": 10.0,
+            "robot0_torso_waist_roll": 200.0,
+            "robot0_l_shoulder_pitch": 4.0,
+            "robot0_r_shoulder_pitch": 4.0,
+            "robot0_l_shoulder_roll": 3.0,
+            "robot0_r_shoulder_roll": 3.0,
+            "robot0_l_shoulder_yaw": 2.0,
+            "robot0_r_shoulder_yaw": 2.0
+        },
+        "ik_hand_pos_cost": 1.0,
+        "ik_hand_ori_cost": 0.5,
+        "use_joint_angle_action_input": false
+    },
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type" : "JOINT_POSITION",
+                "input_max": 1,
+                "input_min": -1,
+                "input_type": "absolute",
+                "output_max": 0.5,
+                "output_min": -0.5,
+                "kd": 200,
+                "kv": 200,
+                "kp": 1000,
+                "velocity_limits": [-1,1],
+                "kp_limits": [0, 1000],
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP",
+                    "use_action_scaling": false
+                }
+            },
+            "left": {
+                "type" : "JOINT_POSITION",
+                "input_max": 1,
+                "input_min": -1,
+                "input_type": "absolute",
+                "output_max": 0.5,
+                "output_min": -0.5,
+                "kd": 200,
+                "kv": 200,
+                "kp": 1000,
+                "velocity_limits": [-1,1],
+                "kp_limits": [0, 1000],
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP",
+                    "use_action_scaling": false
+                }
+            }
+        },
+        "torso": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "input_type": "absolute",
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "head": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "input_type": "absolute",
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        }
+    }
+}

robosuite/controllers/config/default/parts/ik_pose.json

@@ -0,0 +1,7 @@
+{
+    "type" : "IK_POSE",
+    "ik_pos_limit": 0.02,
+    "ik_ori_limit": 0.05,
+    "interpolation": null,
+    "ramp_ratio": 0.2
+  }

robosuite/controllers/config/default/parts/joint_position.json

@@ -0,0 +1,15 @@
+{
+    "type": "JOINT_POSITION",
+    "input_max": 1,
+    "input_min": -1,
+    "output_max": 0.05,
+    "output_min": -0.05,
+    "kp": 50,
+    "damping_ratio": 1,
+    "impedance_mode": "fixed",
+    "kp_limits": [0, 300],
+    "damping_ratio_limits": [0, 10],
+    "qpos_limits": null,
+    "interpolation": null,
+    "ramp_ratio": 0.2
+  }

robosuite/controllers/config/default/parts/joint_torque.json

@@ -0,0 +1,10 @@
+{
+    "type": "JOINT_TORQUE",
+    "input_max": 1,
+    "input_min": -1,
+    "output_max": 0.1,
+    "output_min": -0.1,
+    "torque_limits": null,
+    "interpolation": null,
+    "ramp_ratio": 0.2
+  }

robosuite/controllers/config/default/parts/joint_velocity.json

@@ -0,0 +1,11 @@
+{
+    "type" : "JOINT_VELOCITY",
+    "input_max": 1,
+    "input_min": -1,
+    "output_max": 0.5,
+    "output_min": -0.5,
+    "kp": 3.0,
+    "velocity_limits": [-1,1],
+    "interpolation": null,
+    "ramp_ratio": 0.2
+  }

robosuite/controllers/config/default/parts/osc_pose.json

@@ -0,0 +1,19 @@
+{
+    "type": "OSC_POSE",
+    "input_max": 1,
+    "input_min": -1,
+    "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+    "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+    "kp": 150,
+    "damping_ratio": 1,
+    "impedance_mode": "fixed",
+    "kp_limits": [0, 300],
+    "damping_ratio_limits": [0, 10],
+    "position_limits": null,
+    "orientation_limits": null,
+    "uncouple_pos_ori": true,
+    "input_type": "delta",
+    "input_ref_frame": "base",
+    "interpolation": null,
+    "ramp_ratio": 0.2
+  }

robosuite/controllers/config/default/parts/osc_position.json

@@ -0,0 +1,17 @@
+{
+    "type": "OSC_POSITION",
+    "input_max": 1,
+    "input_min": -1,
+    "output_max": [0.05, 0.05, 0.05],
+    "output_min": [-0.05, -0.05, -0.05],
+    "kp": 150,
+    "damping_ratio": 1,
+    "impedance_mode": "fixed",
+    "kp_limits": [0, 300],
+    "damping_ratio_limits": [0, 10],
+    "position_limits": null,
+    "input_type": "delta",
+    "input_ref_frame": "base",
+    "interpolation": null,
+    "ramp_ratio": 0.2
+  }

robosuite/controllers/config/robots/default_baxter.json

@@ -0,0 +1,51 @@
+{
+    "type": "BASIC",
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            },
+            "left": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            }
+        }
+    }
+}

robosuite/controllers/config/robots/default_gr1.json

@@ -0,0 +1,118 @@
+{
+    "type": "WHOLE_BODY_IK",
+    "composite_controller_specific_configs": {
+        "ref_name": ["gripper0_right_grip_site", "gripper0_left_grip_site"],
+        "interpolation": null,
+        "actuation_part_names": ["torso", "head", "right", "left", "base", "legs"],
+        "max_dq": 4,
+        "nullspace_joint_weights": {
+            "robot0_torso_waist_yaw": 100.0,
+            "robot0_torso_waist_pitch": 100.0,
+            "robot0_torso_waist_roll": 500.0,
+            "robot0_l_shoulder_pitch": 4.0,
+            "robot0_r_shoulder_pitch": 4.0,
+            "robot0_l_shoulder_roll": 3.0,
+            "robot0_r_shoulder_roll": 3.0,
+            "robot0_l_shoulder_yaw": 2.0,
+            "robot0_r_shoulder_yaw": 2.0
+        },
+        "ik_pseudo_inverse_damping": 5e-2,
+        "ik_integration_dt": 1e-1,
+        "ik_max_dq": 4.0,
+        "ik_max_dq_torso": 0.2,
+        "ik_input_type": "absolute",
+        "ik_input_ref_frame": "base",
+        "ik_input_rotation_repr": "axis_angle",
+        "ik_verbose": true
+    },
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type" : "JOINT_POSITION",
+                "input_max": 1,
+                "input_min": -1,
+                "input_type": "absolute",
+                "output_max": 0.5,
+                "output_min": -0.5,
+                "kd": 200,
+                "kv": 200,
+                "kp": 1000,
+                "velocity_limits": [-1,1],
+                "kp_limits": [0, 1000],
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP",
+                    "use_action_scaling": false
+                }
+            },
+            "left": {
+                "type" : "JOINT_POSITION",
+                "input_max": 1,
+                "input_min": -1,
+                "input_type": "absolute",
+                "output_max": 0.5,
+                "output_min": -0.5,
+                "kd": 200,
+                "kv": 200,
+                "kp": 1000,
+                "velocity_limits": [-1,1],
+                "kp_limits": [0, 1000],
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP",
+                    "use_action_scaling": false
+                }
+            }
+        },
+        "torso": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "input_type": "absolute",
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "head": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "input_type": "absolute",
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "base": {
+            "type": "JOINT_VELOCITY",
+            "interpolation": "null"
+        },
+        "legs": {
+            "type": "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        }
+    }
+}

robosuite/controllers/config/robots/default_gr1_fixed_lower_body.json

@@ -0,0 +1,101 @@
+{
+    "type": "WHOLE_BODY_MINK_IK",
+    "composite_controller_specific_configs": {
+        "ref_name": ["gripper0_right_grip_site", "gripper0_left_grip_site"],
+        "interpolation": null,
+        "actuation_part_names": ["torso", "head", "right", "left"],
+        "max_dq": 4,
+        "ik_pseudo_inverse_damping": 5e-2,
+        "ik_integration_dt": 1e-1,
+        "ik_input_type": "absolute",
+        "ik_input_ref_frame": "base",
+        "ik_input_rotation_repr": "axis_angle",
+        "verbose": false,
+        "ik_posture_weights": {
+            "robot0_torso_waist_yaw": 10.0,
+            "robot0_torso_waist_pitch": 10.0,
+            "robot0_torso_waist_roll": 200.0,
+            "robot0_l_shoulder_pitch": 4.0,
+            "robot0_r_shoulder_pitch": 4.0,
+            "robot0_l_shoulder_roll": 3.0,
+            "robot0_r_shoulder_roll": 3.0,
+            "robot0_l_shoulder_yaw": 2.0,
+            "robot0_r_shoulder_yaw": 2.0
+        },
+        "ik_hand_pos_cost": 1.0,
+        "ik_hand_ori_cost": 0.5,
+        "use_joint_angle_action_input": false
+    },
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type" : "JOINT_POSITION",
+                "input_max": 1,
+                "input_min": -1,
+                "input_type": "absolute",
+                "output_max": 0.5,
+                "output_min": -0.5,
+                "kd": 200,
+                "kv": 200,
+                "kp": 1000,
+                "velocity_limits": [-1,1],
+                "kp_limits": [0, 1000],
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP",
+                    "use_action_scaling": false
+                }
+            },
+            "left": {
+                "type" : "JOINT_POSITION",
+                "input_max": 1,
+                "input_min": -1,
+                "input_type": "absolute",
+                "output_max": 0.5,
+                "output_min": -0.5,
+                "kd": 200,
+                "kv": 200,
+                "kp": 1000,
+                "velocity_limits": [-1,1],
+                "kp_limits": [0, 1000],
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP",
+                    "use_action_scaling": false
+                }
+            }
+        },
+        "torso": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "input_type": "absolute",
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "head": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "input_type": "absolute",
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        }
+    }
+}

robosuite/controllers/config/robots/default_gr1_floating_body.json

@@ -0,0 +1,65 @@
+{
+    "type": "HYBRID_MOBILE_BASE",
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP",
+                    "use_action_scaling": false
+                }
+            },
+            "left": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP",
+                    "use_action_scaling": false
+                }
+            }
+        },
+        "torso": {
+            "type": "JOINT_POSITION",
+            "interpolation": "null"
+        },
+        "head": {
+            "type": "JOINT_POSITION",
+            "interpolation": "null"
+        },
+        "base": {
+            "type": "JOINT_VELOCITY",
+            "interpolation": "null"
+        }
+    }
+}

robosuite/controllers/config/robots/default_iiwa.json

@@ -0,0 +1,29 @@
+{
+    "type": "BASIC",
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            }
+        }
+    }
+}

robosuite/controllers/config/robots/default_kinova3.json

@@ -0,0 +1,29 @@
+{
+    "type": "BASIC",
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            }
+        }
+    }
+}

robosuite/controllers/config/robots/default_panda.json

@@ -0,0 +1,29 @@
+{
+    "type": "BASIC",
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            }
+        }
+    }
+}

robosuite/controllers/config/robots/default_panda_dex.json

@@ -0,0 +1,30 @@
+{
+    "type": "BASIC",
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP",
+                    "use_action_scaling": false
+                }
+            }
+        }
+    }
+}

robosuite/controllers/config/robots/default_pandaomron.json

@@ -0,0 +1,38 @@
+{
+    "type": "HYBRID_MOBILE_BASE",
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            }
+        },
+        "torso": {
+            "type": "JOINT_POSITION",
+            "interpolation": "null",
+            "kp": 2000
+        },
+        "base": {
+            "type": "JOINT_VELOCITY",
+            "interpolation": "null"
+        }
+    }
+}

robosuite/controllers/config/robots/default_pandaomron_whole_body_ik.json

@@ -0,0 +1,116 @@
+{
+    "type": "WHOLE_BODY_IK",
+    "composite_controller_specific_configs": {
+        "ref_name": ["gripper0_right_grip_site", "gripper0_left_grip_site"],
+        "interpolation": null,
+        "actuation_part_names": ["right", "left"],
+        "max_dq": 4,
+        "nullspace_joint_weights": {
+            "robot0_torso_waist_yaw": 100.0,
+            "robot0_torso_waist_pitch": 100.0,
+            "robot0_torso_waist_roll": 500.0,
+            "robot0_l_shoulder_pitch": 4.0,
+            "robot0_r_shoulder_pitch": 4.0,
+            "robot0_l_shoulder_roll": 3.0,
+            "robot0_r_shoulder_roll": 3.0,
+            "robot0_l_shoulder_yaw": 2.0,
+            "robot0_r_shoulder_yaw": 2.0
+        },
+        "ik_pseudo_inverse_damping": 5e-2,
+        "ik_integration_dt": 1e-1,
+        "ik_max_dq": 4.0,
+        "ik_max_dq_torso": 0.2,
+        "ik_input_type": "absolute",
+        "ik_input_ref_frame": "mobilebase0_base",
+        "ik_input_rotation_repr": "axis_angle",
+        "verbose": false
+    },
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type" : "JOINT_POSITION",
+                "input_max": 1,
+                "input_min": -1,
+                "input_type": "absolute",
+                "output_max": 0.5,
+                "output_min": -0.5,
+                "kd": 200,
+                "kv": 200,
+                "kp": 1000,
+                "velocity_limits": [-1,1],
+                "kp_limits": [0, 1000],
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            },
+            "left": {
+                "type" : "JOINT_POSITION",
+                "input_max": 1,
+                "input_min": -1,
+                "input_type": "absolute",
+                "output_max": 0.5,
+                "output_min": -0.5,
+                "kd": 200,
+                "kv": 200,
+                "kp": 1000,
+                "velocity_limits": [-1,1],
+                "kp_limits": [0, 1000],
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            }
+        },
+        "torso": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "input_type": "absolute",
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "head": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "input_type": "absolute",
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "base": {
+            "type" : "JOINT_VELOCITY",
+            "interpolation": null
+        },
+        "legs": {
+            "type": "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        }
+    }
+}

robosuite/controllers/config/robots/default_sawyer.json

@@ -0,0 +1,29 @@
+{
+    "type": "BASIC",
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            }
+        }
+    }
+}

robosuite/controllers/config/robots/default_spotwitharm.json

@@ -0,0 +1,43 @@
+{
+    "type": "BASIC",
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            }
+        },
+        "legs": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        }
+    }
+}

robosuite/controllers/config/robots/default_tiago.json

@@ -0,0 +1,101 @@
+{
+    "type": "BASIC",
+    "composite_controller_specific_configs": {
+        "ref_name": ["gripper0_right_grip_site", "gripper0_left_grip_site"],
+        "interpolation": null,
+        "max_dq": 4,
+        "nullspace_joint_weights": {
+            "robot0_torso_lift_joint": 100.0
+        },
+        "ik_pseudo_inverse_damping": 5e-2,
+        "ik_integration_dt": 1e-1,
+        "ik_max_dq": 4.0,
+        "ik_max_dq_torso": 0.2,
+        "ik_input_type": "absolute",
+        "ik_input_ref_frame": "base",
+        "ik_input_rotation_repr": "axis_angle",
+        "verbose": false
+    },
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            },
+            "left": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            }
+        },
+        "torso": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "input_type": "absolute",
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "head": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "input_type": "absolute",
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "base": {
+            "type": "JOINT_VELOCITY",
+            "interpolation": "null"
+        }
+    }
+}

robosuite/controllers/config/robots/default_tiago_whole_body_ik.json

@@ -0,0 +1,92 @@
+{
+    "type": "WHOLE_BODY_IK",
+    "composite_controller_specific_configs": {
+        "ref_name": ["gripper0_right_grip_site", "gripper0_left_grip_site"],
+        "interpolation": null,
+        "actuation_part_names": ["torso", "head", "right", "left"],
+        "max_dq": 4,
+        "nullspace_joint_weights": {
+            "robot0_torso_lift_joint": 100.0
+        },
+        "ik_pseudo_inverse_damping": 5e-2,
+        "ik_integration_dt": 1e-1,
+        "ik_max_dq": 4.0,
+        "ik_max_dq_torso": 0.2,
+        "ik_input_rotation_repr": "axis_angle",
+        "verbose": false
+    },
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type" : "JOINT_POSITION",
+                "input_max": 1,
+                "input_min": -1,
+                "input_type": "absolute",
+                "output_max": 0.5,
+                "output_min": -0.5,
+                "kd": 200,
+                "kv": 200,
+                "kp": 1000,
+                "velocity_limits": [-1,1],
+                "kp_limits": [0, 1000],
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            },
+            "left": {
+                "type" : "JOINT_POSITION",
+                "input_max": 1,
+                "input_min": -1,
+                "input_type": "absolute",
+                "output_max": 0.5,
+                "output_min": -0.5,
+                "kd": 200,
+                "kv": 200,
+                "kp": 1000,
+                "velocity_limits": [-1,1],
+                "kp_limits": [0, 1000],
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            }
+        },
+        "torso": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "input_type": "absolute",
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "head": {
+            "type" : "JOINT_POSITION",
+            "input_max": 1,
+            "input_min": -1,
+            "input_type": "absolute",
+            "output_max": 0.5,
+            "output_min": -0.5,
+            "kd": 200,
+            "kv": 200,
+            "kp": 1000,
+            "velocity_limits": [-1,1],
+            "kp_limits": [0, 1000],
+            "interpolation": null,
+            "ramp_ratio": 0.2
+        },
+        "base": {
+            "type": "JOINT_VELOCITY",
+            "interpolation": "null"
+        }
+    }
+}

robosuite/controllers/config/robots/default_ur5e.json

@@ -0,0 +1,29 @@
+{
+    "type": "BASIC",
+    "body_parts": {
+        "arms": {
+            "right": {
+                "type": "OSC_POSE",
+                "input_max": 1,
+                "input_min": -1,
+                "output_max": [0.05, 0.05, 0.05, 0.5, 0.5, 0.5],
+                "output_min": [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5],
+                "kp": 150,
+                "damping_ratio": 1,
+                "impedance_mode": "fixed",
+                "kp_limits": [0, 300],
+                "damping_ratio_limits": [0, 10],
+                "position_limits": null,
+                "orientation_limits": null,
+                "uncouple_pos_ori": true,
+                "input_type": "delta",
+                "input_ref_frame": "base",
+                "interpolation": null,
+                "ramp_ratio": 0.2,
+                "gripper": {
+                    "type": "GRIP"
+                }
+            }
+        }
+    }
+}

robosuite/controllers/parts/arm/__init__.py

@@ -0,0 +1,2 @@
+from .osc import OperationalSpaceController
+from .ik import InverseKinematicsController

robosuite/controllers/parts/arm/ik.py

@@ -0,0 +1,584 @@
+"""
+***********************************************************************************
+
+
+NOTE: IK is only supported for the following robots:
+
+:Baxter:
+:Sawyer:
+:Panda:
+
+Attempting to run IK with any other robot will raise an error!
+
+***********************************************************************************
+"""
+
+from dataclasses import field
+from typing import Dict, List, Optional, Union
+
+import mujoco
+import numpy as np
+
+import robosuite.utils.transform_utils as T
+from robosuite.controllers.parts.generic.joint_pos import JointPositionController
+from robosuite.utils.binding_utils import MjSim
+from robosuite.utils.control_utils import *
+from robosuite.utils.ik_utils import IKSolver, get_nullspace_gains
+
+# Dict of supported ik robots
+SUPPORTED_IK_ROBOTS = {"Baxter", "Sawyer", "Panda", "GR1FixedLowerBody"}
+
+
+class InverseKinematicsController(JointPositionController):
+    """
+    Controller for controlling robot arm via inverse kinematics. Allows position and orientation control of the
+    robot's end effector.
+
+    We use differential inverse kinematics with posture control in the null space
+    to generate joint positions (see https://github.com/kevinzakka/mjctrl) which are fed to the JointPositionController.
+
+    NOTE: Control input actions are assumed to be relative to the current position / orientation of the end effector
+    and are taken as the array (x_dpos, y_dpos, z_dpos, x_rot, y_rot, z_rot).
+
+    However, confusingly, x_dpos, y_dpos, z_dpos are relative to the mujoco world frame, while x_rot, y_rot, z_rot are
+    relative to the current end effector frame.
+
+    Args:
+        sim (MjSim): Simulator instance this controller will pull robot state updates from
+
+        ref_name: Name of controlled robot arm's end effector (from robot XML)
+
+        joint_indexes (dict): Each key contains sim reference indexes to relevant robot joint information, namely:
+
+            :`'joints'`: list of indexes to relevant robot joints
+            :`'qpos'`: list of indexes to relevant robot joint positions
+            :`'qvel'`: list of indexes to relevant robot joint velocities
+
+        robot_name (str): Name of robot being controlled. Can be {"Sawyer", "Panda", or "Baxter"}
+
+        actuator_range (2-tuple of array of float): 2-Tuple (low, high) representing the robot joint actuator range
+
+        eef_rot_offset (4-array): Quaternion (x,y,z,w) representing rotational offset between the final
+            robot arm link coordinate system and the end effector coordinate system (i.e: the gripper)
+
+        policy_freq (int): Frequency at which actions from the robot policy are fed into this controller
+
+        ik_pos_limit (float): Limit (meters) above which the magnitude of a given action's
+            positional inputs will be clipped
+
+        ik_ori_limit (float): Limit (radians) above which the magnitude of a given action's
+            orientation inputs will be clipped
+
+        interpolator (Interpolator): Interpolator object to be used for interpolating from the current state to
+            the goal state during each timestep between inputted actions
+
+        converge_steps (int): How many iterations to run the inverse kinematics solver to converge to a
+            solution
+
+        **kwargs: Does nothing; placeholder to "sink" any additional arguments so that instantiating this controller
+            via an argument dict that has additional extraneous arguments won't raise an error
+
+    Raises:
+        AssertionError: [Unsupported robot]
+    """
+
+    def __init__(
+        self,
+        sim,
+        ref_name: Union[List[str], str],
+        joint_indexes,
+        robot_name,
+        actuator_range,
+        eef_rot_offset=None,
+        bullet_server_id=0,
+        policy_freq=20,
+        load_urdf=True,
+        ik_pos_limit=None,
+        ik_ori_limit=None,
+        interpolator_pos=None,
+        interpolator_ori=None,
+        converge_steps=5,
+        kp: int = 100,
+        kv: int = 10,
+        control_delta: bool = True,
+        **kwargs,
+    ):
+        # Run sueprclass inits
+        super().__init__(
+            sim=sim,
+            ref_name=ref_name,
+            joint_indexes=joint_indexes,
+            actuator_range=actuator_range,
+            input_max=1,
+            input_min=-1,
+            output_max=1,
+            output_min=-1,
+            kp=kp,
+            kv=kv,
+            policy_freq=policy_freq,
+            velocity_limits=[-1, 1],
+            **kwargs,
+        )
+
+        # Verify robot is supported by IK
+        assert robot_name in SUPPORTED_IK_ROBOTS, (
+            "Error: Tried to instantiate IK controller for unsupported robot! "
+            "Inputted robot: {}, Supported robots: {}".format(robot_name, SUPPORTED_IK_ROBOTS)
+        )
+
+        # Initialize ik-specific attributes
+        self.robot_name = robot_name  # Name of robot (e.g.: "Panda", "Sawyer", etc.)
+
+        self.rest_poses = None
+
+        self.num_ref_sites = 1 if isinstance(ref_name, str) else len(ref_name)
+        # Set the reference robot target pos / orientation (to prevent drift / weird ik numerical behavior over time)
+        if self.num_ref_sites == 1:
+            self.reference_target_pos = self.ref_pos
+            self.reference_target_orn = T.mat2quat(self.ref_ori_mat)
+        else:
+            self.reference_target_pos = self.ref_pos
+            self.reference_target_orn = np.array([T.mat2quat(self.ref_ori_mat[i]) for i in range(self.num_ref_sites)])
+
+        # Override underlying control dim
+        self.control_dim = 6 * self.num_ref_sites  # assuming 6dof control of end effectors; TODO: handle head
+
+        # Interpolator
+        self.interpolator_pos = interpolator_pos
+        self.interpolator_ori = interpolator_ori
+
+        # Interpolator-related attributes
+        self.ori_ref = None
+        self.relative_ori = None
+
+        self.use_delta = control_delta
+
+        # Set ik limits and override internal min / max
+        self.ik_pos_limit = ik_pos_limit
+        self.ik_ori_limit = ik_ori_limit
+
+        # Should be in (0, 1], smaller values mean less sensitivity.
+        self.user_sensitivity = 0.3
+
+        self.nullspace_joint_weights = kwargs.get("nullspace_joint_weights", {})
+        self.joint_names = [sim.model.joint_id2name(i) for i in joint_indexes["joints"]]
+        self.integration_dt = kwargs.get("ik_integration_dt", 0.1)
+        self.damping = kwargs.get("ik_pseudo_inverse_damping", 5e-1)
+        self.max_dq = kwargs.get("ik_max_dq", 4.0)  # currently only used for multi-site ik
+
+        self.i = 0
+
+    def get_control(self, dpos=None, rotation=None, update_targets=False):
+        """
+        Returns joint positions to control the robot after the target end effector
+        position and orientation are updated from arguments @dpos and @rotation.
+        If no arguments are provided, joint positions will be computed based
+        on the previously recorded target.
+
+        Args:
+            dpos (np.array): a 3 dimensional array corresponding to the desired
+                change in x, y, and z end effector position.
+            rotation (np.array): a rotation matrix of shape (3, 3) corresponding
+                to the desired rotation from the current orientation of the end effector.
+            update_targets (bool): whether to update ik target pos / ori attributes or not
+
+        Returns:
+            np.array: a flat array of joint position commands to apply to try and achieve the desired input control.
+        """
+        positions = InverseKinematicsController.compute_joint_positions(
+            self.sim,
+            self.initial_joint,
+            self.joint_index,
+            self.ref_name,
+            self.control_freq,
+            [-1, 1],  # hardcoded velocity limits; unused
+            use_delta=self.use_delta,
+            dpos=dpos,
+            drot=rotation,
+            jac=self.J_full,
+            joint_names=self.joint_names,
+            nullspace_joint_weights=self.nullspace_joint_weights,
+            damping=self.damping,
+            integration_dt=self.integration_dt,
+            max_dq=self.max_dq,
+        )
+
+        return positions
+
+    @staticmethod
+    def compute_joint_positions(
+        sim: MjSim,
+        initial_joint: np.ndarray,
+        joint_indices: np.ndarray,
+        ref_name: Union[List[str], str],
+        control_freq: float,
+        velocity_limits: Optional[np.ndarray] = None,
+        use_delta: bool = True,
+        dpos: Optional[np.ndarray] = None,
+        drot: Optional[np.ndarray] = None,
+        Kn: Optional[np.ndarray] = np.array([10.0, 10.0, 10.0, 10.0, 5.0, 5.0, 5.0]),
+        damping_pseudo_inv: float = 0.05,
+        Kpos: float = 0.95,
+        Kori: float = 0.95,
+        jac: Optional[np.ndarray] = None,
+        joint_names: Optional[List[str]] = None,
+        nullspace_joint_weights: Dict[str, float] = field(default_factory=dict),
+        integration_dt: float = 0.1,
+        damping: float = 5e-1,
+        max_dq: int = 4,  # TODO: should be derived from velocity_limits
+    ) -> np.ndarray:
+        """
+        Returns joint positions to control the robot after the target end effector
+        position and orientation are updated from arguments @dpos and @drot.
+        If no arguments are provided, joint positions will be set as zero.
+
+        Args:
+            sim (MjSim): The simulation object.
+            initial_joint (np.array): Initial joint positions.
+            joint_indices (np.array): Indices of the joints.
+            ref_name: Reference site name.
+            control_freq (float): Control frequency.
+            velocity_limits (np.array): Limits on joint velocities.
+            use_delta: Whether or not to use delta commands. If so, use dpos, drot to compute joint positions.
+                If not, assume dpos, drot are absolute commands (in mujoco world frame).
+            dpos (Optional[np.array]): Desired change in end-effector position
+                if use_delta=True, otherwise desired end-effector position.
+            drot (Optional[np.array]): Desired change in orientation for the reference site (e.g end effector)
+                if use_delta=True, otherwise desired end-effector orientation.
+            update_targets (bool): Whether to update ik target pos / ori attributes or not.
+            Kpos (float): Position gain. Between 0 and 1.
+                0 means no movement, 1 means move end effector to desired position in one integration step.
+            Kori (float): Orientation gain. Between 0 and 1.
+            jac (Optional[np.array]): Precomputed jacobian matrix.
+
+        Returns:
+            np.array: A flat array of joint position commands to apply to try and achieve the desired input control.
+        """
+        if (dpos is not None) and (drot is not None):
+            max_angvel = velocity_limits[1] if velocity_limits is not None else 0.7
+
+            q0 = initial_joint
+            dof_ids = joint_indices
+
+            num_ref_sites = 1 if isinstance(ref_name, str) else len(ref_name)
+            if num_ref_sites == 1:
+                assert use_delta, "Currently, only delta commands are supported. Please set use_delta=True."
+                # TODO: support absolute commands by using solve() from diffik_nullspace.py
+                twist = np.zeros(6)
+                error_quat = np.zeros(4)
+                diag = damping_pseudo_inv**2 * np.eye(len(twist))
+                eye = np.eye(len(joint_indices))
+
+                jac = np.zeros((6, sim.model.nv), dtype=np.float64)
+                twist = np.zeros(6)
+                error_quat = np.zeros(4)
+
+                twist[:3] = Kpos * dpos / integration_dt
+                mujoco.mju_mat2Quat(error_quat, drot.reshape(-1))
+                mujoco.mju_quat2Vel(twist[3:], error_quat, 1.0)
+                twist[3:] *= Kori / integration_dt
+
+                mujoco.mj_jacSite(
+                    sim.model._model,
+                    sim.data._data,
+                    jac[:3],
+                    jac[3:],
+                    sim.data.site(ref_name).id,
+                )
+
+                jac = jac[:, dof_ids]
+
+                dq = jac.T @ np.linalg.solve(jac @ jac.T + diag, twist)
+                dq += (eye - np.linalg.pinv(jac) @ jac) @ (Kn * (q0 - sim.data.qpos[dof_ids]))
+
+                dq_abs_max = np.abs(dq).max()
+                if dq_abs_max > max_angvel:
+                    dq *= max_angvel / dq_abs_max
+
+                q_des = sim.data.qpos[dof_ids] + dq * integration_dt
+                dq = q_des  # hack for now
+                return dq
+            else:
+                model = sim.model._model
+                data = sim.data._data
+                joint_names = [
+                    model.joint(i).name
+                    for i in range(model.njnt)
+                    if model.joint(i).type != 0 and ("gripper0" not in model.joint(i).name)
+                ]  # Exclude fixed joints
+                nullspace_gains = get_nullspace_gains(joint_names, nullspace_joint_weights)
+                robot_config = {
+                    "end_effector_sites": ref_name,
+                    "joint_names": joint_names,
+                    "mocap_bodies": [],
+                    "nullspace_gains": nullspace_gains,
+                }
+                ik_solver = IKSolver(
+                    model,
+                    data,
+                    robot_config,
+                    damping=damping,
+                    integration_dt=integration_dt,
+                    max_dq=max_dq,
+                    input_type="mocap",
+                    input_rotation_repr="quat_wxyz",
+                )
+                if use_delta:
+                    target_ori_mat = np.array([ik_solver.data.site(site_id).xmat for site_id in ik_solver.site_ids])
+                    target_ori = np.array([np.ones(4) for _ in range(len(ik_solver.site_ids))])
+                    [mujoco.mju_mat2Quat(target_ori[i], target_ori_mat[i]) for i in range(len(ik_solver.site_ids))]
+                    target_pos = np.array([ik_solver.data.site(site_id).xpos for site_id in ik_solver.site_ids])
+                    if dpos.ndim == 1:
+                        target_pos[0] += dpos
+                        target_ori[0] = T.quat_multiply(target_ori[0], T.mat2quat(drot))
+                    else:
+                        target_pos += dpos
+                        target_ori = np.array(
+                            [
+                                T.quat_multiply(target_ori[i], T.mat2quat(drot[i]))
+                                for i in range(len(ik_solver.site_ids))
+                            ]
+                        )
+                else:
+                    target_pos = dpos
+                    target_ori = np.array([np.ones(4) for _ in range(len(ik_solver.site_ids))])
+                    # convert drot (3x3) to quaternion
+                    [mujoco.mju_mat2Quat(target_ori[i], drot[i].flatten()) for i in range(len(ik_solver.site_ids))]
+
+                ori_dim = target_ori.shape[1]
+                pos_dim = target_pos.shape[1]
+                target_action = np.empty(target_pos.shape[0] * (target_pos.shape[1] + target_ori.shape[1]))
+                for i in range(target_pos.shape[0]):
+                    target_action[i * (pos_dim + ori_dim) : (i + 1) * (pos_dim + ori_dim)] = np.concatenate(
+                        (target_pos[i], target_ori[i])
+                    )
+
+                return ik_solver.solve(
+                    target_pos=target_pos,
+                    target_ori=target_ori,
+                    Kpos=Kpos,
+                    Kori=Kori,
+                )
+
+        return sim.data.qpos[joint_indices]
+
+    def set_goal(self, delta, set_ik=None):
+        """
+        Sets the internal goal state of this controller based on @delta
+
+        Note that this controller wraps a PositionController, and so determines the desired positions
+        to achieve the inputted pose, and sets its internal setpoint in terms of joint positions
+
+        TODO: Add feature so that using @set_ik automatically sets the target values to these absolute values
+
+        Args:
+            delta (Iterable): Desired relative position / orientation goal state
+            set_ik (Iterable): If set, overrides @delta and sets the desired global position / orientation goal state
+        """
+        # Update state
+        self.update(force=True)  # force because new_update = True only set in super().run_controller()
+
+        if self.num_ref_sites > 1:
+            delta = np.array(delta).reshape(self.num_ref_sites, 6)
+
+        # hardcoding to assumes 6D delta input for now
+        (dpos, dquat) = self._clip_ik_input(delta[..., :3], delta[..., 3:6])
+
+        # Set interpolated goals if necessary
+        if self.interpolator_pos is not None:
+            # Absolute position goal
+            self.interpolator_pos.set_goal(dpos * self.user_sensitivity + self.reference_target_pos)
+
+        if self.interpolator_ori is not None:
+            # Relative orientation goal
+            self.interpolator_ori.set_goal(dquat)  # goal is the relative change in orientation
+            self.ori_ref = np.array(self.ref_ori_mat)  # reference is the current orientation at start
+            self.relative_ori = np.zeros(3)  # relative orientation always starts at 0
+
+        # Run ik prepropressing to convert pos, quat ori to desired positions
+        requested_control = self._make_input(delta, self.reference_target_orn)
+
+        # Compute desired (absolute) joint positions to achieve eef pos / ori
+        positions = self.get_control(**requested_control, update_targets=True)
+
+        # Set the goal positions for the underlying position controller
+        super().set_goal(positions)
+
+    def run_controller(self):
+        """
+        Calculates the torques required to reach the desired setpoint
+
+        Returns:
+             np.array: Command torques
+        """
+        # Update state
+        self.update()  # force because new_update = True only set in super().run_controller()
+
+        # Update interpolated action if necessary
+        desired_pos = None
+        rotation = None
+        update_position_goal = False
+
+        # Update interpolated goals if active
+        if self.interpolator_pos is not None:
+            # Linear case
+            if self.interpolator_pos.order == 1:
+                desired_pos = self.interpolator_pos.get_interpolated_goal()
+            else:
+                # Nonlinear case not currently supported
+                pass
+            update_position_goal = True
+        else:
+            desired_pos = self.reference_target_pos
+
+        if self.interpolator_ori is not None:
+            # Linear case
+            if self.interpolator_ori.order == 1:
+                # relative orientation based on difference between current ori and ref
+                self.relative_ori = orientation_error(self.ref_ori_mat, self.ori_ref)
+                ori_error = self.interpolator_ori.get_interpolated_goal()
+                rotation = T.quat2mat(ori_error)
+            else:
+                # Nonlinear case not currently supported
+                pass
+            update_position_goal = True
+        else:
+            if self.num_ref_sites == 1:
+                rotation = T.mat2quat(self.ref_ori_mat)
+            else:
+                rotation = np.array([T.mat2quat(self.ref_ori_mat[i]) for i in range(self.num_ref_sites)])
+
+        # Only update the position goals if we're interpolating
+        if update_position_goal:
+            velocities = self.get_control(dpos=(desired_pos - self.ref_pos), rotation=rotation)
+            super().set_goal(velocities)
+
+        return super().run_controller()
+
+    def update_initial_joints(self, initial_joints):
+        # First, update from the superclass method
+        super().update_initial_joints(initial_joints)
+
+        # Then, update the rest pose from the initial joints
+        self.rest_poses = list(self.initial_joint)
+
+    def reset_goal(self):
+        """
+        Resets the goal to the current pose of the robot
+        """
+        if self.num_ref_sites == 1:
+            self.reference_target_pos = self.ref_pos
+            self.reference_target_orn = T.mat2quat(self.ref_ori_mat)
+        else:
+            self.reference_target_pos = self.ref_pos
+            self.reference_target_orn = np.array([T.mat2quat(self.ref_ori_mat[i]) for i in range(self.num_ref_sites)])
+
+    def _clip_ik_input(self, dpos, rotation):
+        """
+        Helper function that clips desired ik input deltas into a valid range.
+
+        Args:
+            dpos (np.array): a 3 dimensional array corresponding to the desired
+                change in x, y, and z end effector position.
+            rotation (np.array): relative rotation in scaled axis angle form (ax, ay, az)
+                corresponding to the (relative) desired orientation of the end effector.
+
+        Returns:
+            2-tuple:
+
+                - (np.array) clipped dpos
+                - (np.array) clipped rotation
+        """
+        # scale input range to desired magnitude
+        if dpos.any() and self.ik_pos_limit is not None:
+            dpos, _ = T.clip_translation(dpos, self.ik_pos_limit)
+
+        if self.num_ref_sites == 1:
+            # Map input to quaternion
+            rotation = T.axisangle2quat(rotation)
+        else:
+            rotation = [T.axisangle2quat(rotation[i]) for i in range(self.num_ref_sites)]
+
+        if self.ik_ori_limit is not None:
+            # Clip orientation to desired magnitude
+            rotation, _ = T.clip_rotation(rotation, self.ik_ori_limit)
+
+        return dpos, rotation
+
+    def _make_input(self, action, old_quat):
+        """
+        Helper function that returns a dictionary with keys dpos, rotation from a raw input
+        array. The first three elements are taken to be displacement in position, and a
+        quaternion indicating the change in rotation with respect to @old_quat. Additionally clips @action as well
+
+        Args:
+            action (np.array) should have form: [dx, dy, dz, ax, ay, az] (orientation in
+                scaled axis-angle form)
+            old_quat (np.array) the old target quaternion that will be updated with the relative change in @action
+        """
+        if self.num_ref_sites > 1:
+            action = np.array(action).reshape(self.num_ref_sites, 6)
+
+        # Clip action appropriately
+        dpos, rotation = self._clip_ik_input(
+            action[..., :3], action[..., 3:6]
+        )  # hardcoded to assume 6dof control for now
+
+        if self.use_delta:
+            if self.num_ref_sites == 1:
+                # Update reference targets
+                self.reference_target_pos += dpos * self.user_sensitivity
+                self.reference_target_orn = T.quat_multiply(old_quat, rotation)
+            else:
+                # Update reference targets
+                self.reference_target_pos += dpos * self.user_sensitivity
+                self.reference_target_orn = np.array(
+                    [T.quat_multiply(old_quat[i], rotation[i]) for i in range(self.num_ref_sites)]
+                )
+        else:
+            # Update reference targets
+            self.reference_target_pos = dpos
+            self.reference_target_orn = rotation
+
+        if self.num_ref_sites == 1:
+            rotation = T.quat2mat(rotation)
+        else:
+            dpos = dpos
+            rotation = np.array([T.quat2mat(rotation[i]) for i in range(self.num_ref_sites)])
+
+        return {"dpos": dpos, "rotation": rotation}
+
+    @staticmethod
+    def _get_current_error(current, set_point):
+        """
+        Returns an array of differences between the desired joint positions and current
+        joint positions. Useful for PID control.
+
+        Args:
+            current (np.array): the current joint positions
+            set_point (np.array): the joint positions that are desired as a numpy array
+
+        Returns:
+            np.array: the current error in the joint positions
+        """
+        error = current - set_point
+        return error
+
+    @property
+    def control_limits(self):
+        """
+        The limits over this controller's action space, as specified by self.ik_pos_limit and self.ik_ori_limit
+        and overriding the superclass method
+
+        Returns:
+            2-tuple:
+
+                - (np.array) minimum control values
+                - (np.array) maximum control values
+        """
+        max_limit = np.concatenate([self.ik_pos_limit * np.ones(3), self.ik_ori_limit * np.ones(3)])
+        return -max_limit, max_limit
+
+    @property
+    def name(self):
+        return "IK_POSE"

robosuite/controllers/parts/arm/osc.py

@@ -0,0 +1,584 @@
+import math
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+import robosuite.utils.transform_utils as T
+from robosuite.controllers.parts.controller import Controller
+from robosuite.utils.control_utils import *
+
+# Supported impedance modes
+IMPEDANCE_MODES = {"fixed", "variable", "variable_kp"}
+
+# TODO: Maybe better naming scheme to differentiate between input / output min / max and pos/ori limits, etc.
+
+
+class OperationalSpaceController(Controller):
+    """
+    Controller for controlling robot arm via operational space control. Allows position and / or orientation control
+    of the robot's end effector. For detailed information as to the mathematical foundation for this controller, please
+    reference http://khatib.stanford.edu/publications/pdfs/Khatib_1987_RA.pdf
+
+    NOTE: Control input actions can either be taken to be relative to the current position / orientation of the
+    end effector or absolute values. In either case, a given action to this controller is assumed to be of the form:
+    (x, y, z, ax, ay, az) if controlling pos and ori or simply (x, y, z) if only controlling pos
+
+    Args:
+        sim (MjSim): Simulator instance this controller will pull robot state updates from
+
+        joint_indexes (dict): Each key contains sim reference indexes to relevant robot joint information, namely:
+
+            :`'joints'`: list of indexes to relevant robot joints
+            :`'qpos'`: list of indexes to relevant robot joint positions
+            :`'qvel'`: list of indexes to relevant robot joint velocities
+
+        actuator_range (2-tuple of array of float): 2-Tuple (low, high) representing the robot joint actuator range
+
+        input_max (float or Iterable of float): Maximum above which an inputted action will be clipped. Can be either be
+            a scalar (same value for all action dimensions), or a list (specific values for each dimension). If the
+            latter, dimension should be the same as the control dimension for this controller
+
+        input_min (float or Iterable of float): Minimum below which an inputted action will be clipped. Can be either be
+            a scalar (same value for all action dimensions), or a list (specific values for each dimension). If the
+            latter, dimension should be the same as the control dimension for this controller
+
+        output_max (float or Iterable of float): Maximum which defines upper end of scaling range when scaling an input
+            action. Can be either be a scalar (same value for all action dimensions), or a list (specific values for
+            each dimension). If the latter, dimension should be the same as the control dimension for this controller
+
+        output_min (float or Iterable of float): Minimum which defines upper end of scaling range when scaling an input
+            action. Can be either be a scalar (same value for all action dimensions), or a list (specific values for
+            each dimension). If the latter, dimension should be the same as the control dimension for this controller
+
+        kp (float or Iterable of float): positional gain for determining desired torques based upon the pos / ori error.
+            Can be either be a scalar (same value for all action dims), or a list (specific values for each dim)
+
+        damping_ratio (float or Iterable of float): used in conjunction with kp to determine the velocity gain for
+            determining desired torques based upon the joint pos errors. Can be either be a scalar (same value for all
+            action dims), or a list (specific values for each dim)
+
+        impedance_mode (str): Impedance mode with which to run this controller. Options are {"fixed", "variable",
+            "variable_kp"}. If "fixed", the controller will have fixed kp and damping_ratio values as specified by the
+            @kp and @damping_ratio arguments. If "variable", both kp and damping_ratio will now be part of the
+            controller action space, resulting in a total action space of (6 or 3) + 6 * 2. If "variable_kp", only kp
+            will become variable, with damping_ratio fixed at 1 (critically damped). The resulting action space will
+            then be (6 or 3) + 6.
+
+        kp_limits (2-list of float or 2-list of Iterable of floats): Only applicable if @impedance_mode is set to either
+            "variable" or "variable_kp". This sets the corresponding min / max ranges of the controller action space
+            for the varying kp values. Can be either be a 2-list (same min / max for all kp action dims), or a 2-list
+            of list (specific min / max for each kp dim)
+
+        damping_ratio_limits (2-list of float or 2-list of Iterable of floats): Only applicable if @impedance_mode is
+            set to "variable". This sets the corresponding min / max ranges of the controller action space for the
+            varying damping_ratio values. Can be either be a 2-list (same min / max for all damping_ratio action dims),
+            or a 2-list of list (specific min / max for each damping_ratio dim)
+
+        policy_freq (int): Frequency at which actions from the robot policy are fed into this controller
+
+        position_limits (2-list of float or 2-list of Iterable of floats): Limits (m) below and above which the
+            magnitude of a calculated goal eef position will be clipped. Can be either be a 2-list (same min/max value
+            for all cartesian dims), or a 2-list of list (specific min/max values for each dim)
+
+        orientation_limits (2-list of float or 2-list of Iterable of floats): Limits (rad) below and above which the
+            magnitude of a calculated goal eef orientation will be clipped. Can be either be a 2-list
+            (same min/max value for all joint dims), or a 2-list of list (specific min/mx values for each dim)
+
+        interpolator_pos (Interpolator): Interpolator object to be used for interpolating from the current position to
+            the goal position during each timestep between inputted actions
+
+        interpolator_ori (Interpolator): Interpolator object to be used for interpolating from the current orientation
+            to the goal orientation during each timestep between inputted actions
+
+        control_ori (bool): Whether inputted actions will control both pos and ori or exclusively pos
+
+        input_type (str): Whether to control the robot using delta ("delta") or absolute commands ("absolute").
+            This is wrt the contorller reference frame (see input_ref_frame field)
+
+        input_ref_frame (str): Reference frame for controller. Current supported options are:
+            "base": actions are wrt to the robot body (i.e., the base)
+            "world": actions are wrt the world coordinate frame
+
+        uncouple_pos_ori (bool): Whether to decouple torques meant to control pos and torques meant to control ori
+
+        lite_physics (bool): Whether to optimize for mujoco forward and step calls to reduce total simulation overhead.
+            Set to False to preserve backward compatibility with datasets collected in robosuite <= 1.4.1.
+
+        **kwargs: Does nothing; placeholder to "sink" any additional arguments so that instantiating this controller
+            via an argument dict that has additional extraneous arguments won't raise an error
+
+    Raises:
+        AssertionError: [Invalid impedance mode]
+    """
+
+    def __init__(
+        self,
+        sim,
+        ref_name,
+        joint_indexes,
+        actuator_range,
+        input_max=1,
+        input_min=-1,
+        output_max=(0.05, 0.05, 0.05, 0.5, 0.5, 0.5),
+        output_min=(-0.05, -0.05, -0.05, -0.5, -0.5, -0.5),
+        kp=150,
+        damping_ratio=1,
+        impedance_mode="fixed",
+        kp_limits=(0, 300),
+        damping_ratio_limits=(0, 100),
+        policy_freq=20,
+        position_limits=None,
+        orientation_limits=None,
+        interpolator_pos=None,
+        interpolator_ori=None,
+        control_ori=True,
+        input_type="delta",
+        input_ref_frame="base",
+        uncouple_pos_ori=True,
+        lite_physics=True,
+        **kwargs,  # does nothing; used so no error raised when dict is passed with extra terms used previously
+    ):
+
+        super().__init__(
+            sim,
+            ref_name=ref_name,
+            joint_indexes=joint_indexes,
+            actuator_range=actuator_range,
+            lite_physics=lite_physics,
+            part_name=kwargs.get("part_name", None),
+            naming_prefix=kwargs.get("naming_prefix", None),
+        )
+        # Determine whether this is pos ori or just pos
+        self.use_ori = control_ori
+        # Determine whether we want to use delta or absolute values as inputs
+        self.input_type = input_type
+        assert self.input_type in ["delta", "absolute"], f"Input type must be delta or absolute, got: {self.input_type}"
+
+        # determine reference frame wrt actions are set
+        self.input_ref_frame = input_ref_frame
+        assert self.input_ref_frame in [
+            "world",
+            "base",
+        ], f"Input reference frame must be world or base, got: {self.input_ref_frame}"
+
+        # Control dimension
+        self.control_dim = 6 if self.use_ori else 3
+        self.name_suffix = "POSE" if self.use_ori else "POSITION"
+
+        # input and output max and min (allow for either explicit lists or single numbers)
+        self.input_max = self.nums2array(input_max, self.control_dim)
+        self.input_min = self.nums2array(input_min, self.control_dim)
+        self.output_max = self.nums2array(output_max, self.control_dim)
+        self.output_min = self.nums2array(output_min, self.control_dim)
+
+        # kp kd
+        self.kp = self.nums2array(kp, 6)
+        self.kd = 2 * np.sqrt(self.kp) * damping_ratio
+
+        # kp and kd limits
+        self.kp_min = self.nums2array(kp_limits[0], 6)
+        self.kp_max = self.nums2array(kp_limits[1], 6)
+        self.damping_ratio_min = self.nums2array(damping_ratio_limits[0], 6)
+        self.damping_ratio_max = self.nums2array(damping_ratio_limits[1], 6)
+
+        # Verify the proposed impedance mode is supported
+        assert impedance_mode in IMPEDANCE_MODES, (
+            "Error: Tried to instantiate OSC controller for unsupported "
+            "impedance mode! Inputted impedance mode: {}, Supported modes: {}".format(impedance_mode, IMPEDANCE_MODES)
+        )
+
+        # Impedance mode
+        self.impedance_mode = impedance_mode
+
+        # Add to control dim based on impedance_mode
+        if self.impedance_mode == "variable":
+            self.control_dim += 12
+        elif self.impedance_mode == "variable_kp":
+            self.control_dim += 6
+
+        # limits
+        self.position_limits = np.array(position_limits) if position_limits is not None else position_limits
+        self.orientation_limits = np.array(orientation_limits) if orientation_limits is not None else orientation_limits
+
+        # control frequency
+        self.control_freq = policy_freq
+
+        # interpolator
+        self.interpolator_pos = interpolator_pos
+        self.interpolator_ori = interpolator_ori
+
+        # whether or not pos and ori want to be uncoupled
+        self.uncoupling = uncouple_pos_ori
+
+        # initialize goals
+        self.goal_pos = None
+        self.goal_ori = None
+
+        # initialize orientation references
+        self.relative_ori = np.zeros(3)
+        self.ori_ref = None
+
+        # initialize origin pos and ori
+        self.origin_pos = None
+        self.origin_ori = None
+
+    def set_goal(self, action):
+        """
+        Sets goal based on input @action. If self.impedance_mode is not "fixed", then the input will be parsed into the
+        delta values to update the goal position / pose and the kp and/or damping_ratio values to be immediately updated
+        internally before executing the proceeding control loop.
+
+        Note that @action expected to be in the following format, based on impedance mode!
+
+            :Mode `'fixed'`: [joint pos command]
+            :Mode `'variable'`: [damping_ratio values, kp values, joint pos command]
+            :Mode `'variable_kp'`: [kp values, joint pos command]
+
+        Args:
+            action (Iterable): Desired relative joint position goal state
+        """
+        # Update state
+        self.update()
+
+        # Parse action based on the impedance mode, and update kp / kd as necessary
+        if self.impedance_mode == "variable":
+            damping_ratio, kp, goal_update = action[:6], action[6:12], action[12:]
+            self.kp = np.clip(kp, self.kp_min, self.kp_max)
+            self.kd = 2 * np.sqrt(self.kp) * np.clip(damping_ratio, self.damping_ratio_min, self.damping_ratio_max)
+        elif self.impedance_mode == "variable_kp":
+            kp, goal_update = action[:6], action[6:]
+            self.kp = np.clip(kp, self.kp_min, self.kp_max)
+            self.kd = 2 * np.sqrt(self.kp)  # critically damped
+        else:  # This is case "fixed"
+            goal_update = action
+
+        # If we're using deltas, interpret actions as such
+        if self.input_type == "delta":
+            delta = goal_update
+            scaled_delta = self.scale_action(delta)
+            self.goal_pos = self.compute_goal_pos(scaled_delta[0:3])
+            if self.use_ori is True:
+                self.goal_ori = self.compute_goal_ori(scaled_delta[3:6])
+            else:
+                self.goal_ori = self.compute_goal_ori(np.zeros(3))
+        # Else, interpret actions as absolute values
+        elif self.input_type == "absolute":
+            abs_action = goal_update
+            self.goal_pos = abs_action[0:3]
+            if self.use_ori is True:
+                self.goal_ori = Rotation.from_rotvec(abs_action[3:6]).as_matrix()
+            else:
+                self.goal_ori = self.compute_goal_ori(np.zeros(3))
+        else:
+            raise ValueError(f"Unsupport input_type {self.input_type}")
+
+        if self.interpolator_pos is not None:
+            self.interpolator_pos.set_goal(self.goal_pos)
+
+        if self.interpolator_ori is not None:
+            self.ori_ref = np.array(self.ref_ori_mat)  # reference is the current orientation at start
+            self.interpolator_ori.set_goal(
+                orientation_error(self.goal_ori, self.ori_ref)
+            )  # goal is the total orientation error
+            self.relative_ori = np.zeros(3)  # relative orientation always starts at 0
+
+    def world_to_origin_frame(self, vec):
+        """
+        transform vector from world to reference coordinate frame
+        """
+
+        # world rotation matrix is just identity
+        world_frame = np.eye(4)
+        world_frame[:3, 3] = vec
+
+        origin_frame = T.make_pose(self.origin_pos, self.origin_ori)
+        origin_frame_inv = T.pose_inv(origin_frame)
+        vec_origin_pose = T.pose_in_A_to_pose_in_B(world_frame, origin_frame_inv)
+        vec_origin_pos, _ = T.mat2pose(vec_origin_pose)
+        return vec_origin_pos
+
+    def goal_origin_to_eef_pose(self):
+        origin_pose = T.make_pose(self.origin_pos, self.origin_ori)
+        ee_pose = T.make_pose(self.ref_pos, self.ref_ori_mat)
+        origin_pose_inv = T.pose_inv(origin_pose)
+        return T.pose_in_A_to_pose_in_B(ee_pose, origin_pose_inv)
+
+    def compute_goal_pos(self, delta, goal_update_mode=None):
+        """
+        Compute new goal position, given a delta to update. Can either update the new goal based on
+        current achieved position or current deisred goal. Updating based on current deisred goal can be useful
+        if we want the robot to adhere with a sequence of target poses as closely as possible,
+        without lagging or overshooting.
+
+        Args:
+            delta (np.array): Desired relative change in position [x, y, z]
+            goal_update_mode (str): either "achieved" (achieved position) or "desired" (desired goal)
+
+        Returns:
+            np.array: updated goal position in the controller frame
+        """
+        if goal_update_mode is None:
+            goal_update_mode = self._goal_update_mode
+        assert goal_update_mode in ["achieved", "desired"]
+
+        if self.goal_pos is None:
+            # if goal is not already set, set it to current position (in controller ref frame)
+            if self.input_ref_frame == "base":
+                self.goal_pos = self.world_to_origin_frame(self.ref_pos)
+            elif self.input_ref_frame == "world":
+                self.goal_pos = self.ref_pos
+            else:
+                raise ValueError
+
+        if goal_update_mode == "desired":
+            # update new goal wrt current desired goal
+            goal_pos = self.goal_pos + delta
+        elif goal_update_mode == "achieved":
+            # update new goal wrt current achieved position
+            if self.input_ref_frame == "base":
+                goal_pos = self.world_to_origin_frame(self.ref_pos) + delta
+            elif self.input_ref_frame == "world":
+                goal_pos = self.ref_pos + delta
+            else:
+                raise ValueError
+
+        if self.position_limits is not None:
+            # to be implemented later
+            raise NotImplementedError
+
+        return goal_pos
+
+    def compute_goal_ori(self, delta, goal_update_mode=None):
+        """
+        Compute new goal orientation, given a delta to update. Can either update the new goal based on
+        current achieved position or current deisred goal. Updating based on current deisred goal can be useful
+        if we want the robot to adhere with a sequence of target poses as closely as possible,
+        without lagging or overshooting.
+
+        Args:
+            delta (np.array): Desired relative change in orientation, in axis-angle form [ax, ay, az]
+            goal_update_mode (str): either "achieved" (achieved position) or "desired" (desired goal)
+
+        Returns:
+            np.array: updated goal orientation in the controller frame
+        """
+        if goal_update_mode is None:
+            goal_update_mode = self._goal_update_mode
+        assert goal_update_mode in ["achieved", "desired"]
+
+        if self.goal_ori is None:
+            # if goal is not already set, set it to current orientation (in controller ref frame)
+            if self.input_ref_frame == "base":
+                self.goal_ori = self.goal_origin_to_eef_pose()[:3, :3]
+            elif self.input_ref_frame == "world":
+                self.goal_ori = self.ref_ori_mat
+            else:
+                raise ValueError
+
+        # convert axis-angle value to rotation matrix
+        quat_error = T.axisangle2quat(delta)
+        rotation_mat_error = T.quat2mat(quat_error)
+
+        if self._goal_update_mode == "desired":
+            # update new goal wrt current desired goal
+            goal_ori = np.dot(rotation_mat_error, self.goal_ori)
+        elif self._goal_update_mode == "achieved":
+            # update new goal wrt current achieved orientation
+            if self.input_ref_frame == "base":
+                curr_goal_ori = self.goal_origin_to_eef_pose()[:3, :3]
+            elif self.input_ref_frame == "world":
+                curr_goal_ori = self.ref_ori_mat
+            else:
+                raise ValueError
+            goal_ori = np.dot(rotation_mat_error, curr_goal_ori)
+        else:
+            raise ValueError
+
+        # check for orientation limits
+        if np.array(self.orientation_limits).any():
+            # to be implemented later
+            raise NotImplementedError
+        return goal_ori
+
+    def run_controller(self):
+        """
+        Calculates the torques required to reach the desired setpoint.
+
+        Executes Operational Space Control (OSC) -- either position only or position and orientation.
+
+        A detailed overview of derivation of OSC equations can be seen at:
+        http://khatib.stanford.edu/publications/pdfs/Khatib_1987_RA.pdf
+
+        Returns:
+             np.array: Command torques
+        """
+        # Update state
+        self.update()
+
+        desired_world_pos = None
+        # Only linear interpolator is currently supported
+        if self.interpolator_pos is not None:
+            # Linear case
+            if self.interpolator_pos.order == 1:
+                desired_world_pos = self.interpolator_pos.get_interpolated_goal()
+            else:
+                # Nonlinear case not currently supported
+                pass
+        else:
+            if self.input_ref_frame == "base":
+                # compute goal based on current base position and orientation
+                desired_world_pos = self.origin_pos + np.dot(self.origin_ori, self.goal_pos)
+            elif self.input_ref_frame == "world":
+                desired_world_pos = self.goal_pos
+            else:
+                raise ValueError
+
+        if self.interpolator_ori is not None:
+            # relative orientation based on difference between current ori and ref
+            self.relative_ori = orientation_error(self.ref_ori_mat, self.ori_ref)
+
+            ori_error = self.interpolator_ori.get_interpolated_goal()
+        else:
+            if self.input_ref_frame == "base":
+                # compute goal based on current base orientation
+                desired_world_ori = np.dot(self.origin_ori, self.goal_ori)
+            elif self.input_ref_frame == "world":
+                desired_world_ori = self.goal_ori
+            else:
+                raise ValueError
+            ori_error = orientation_error(desired_world_ori, self.ref_ori_mat)
+
+        # Compute desired force and torque based on errors
+        position_error = desired_world_pos - self.ref_pos
+        base_pos_vel = np.array(self.sim.data.get_site_xvelp(f"{self.naming_prefix}{self.part_name}_center"))
+        vel_pos_error = -(self.ref_pos_vel - base_pos_vel)
+
+        # F_r = kp * pos_err + kd * vel_err
+        desired_force = np.multiply(np.array(position_error), np.array(self.kp[0:3])) + np.multiply(
+            vel_pos_error, self.kd[0:3]
+        )
+
+        base_ori_vel = np.array(self.sim.data.get_site_xvelr(f"{self.naming_prefix}{self.part_name}_center"))
+        vel_ori_error = -(self.ref_ori_vel - base_ori_vel)
+
+        # Tau_r = kp * ori_err + kd * vel_err
+        desired_torque = np.multiply(np.array(ori_error), np.array(self.kp[3:6])) + np.multiply(
+            vel_ori_error, self.kd[3:6]
+        )
+
+        # Compute nullspace matrix (I - Jbar * J) and lambda matrices ((J * M^-1 * J^T)^-1)
+        lambda_full, lambda_pos, lambda_ori, nullspace_matrix = opspace_matrices(
+            self.mass_matrix, self.J_full, self.J_pos, self.J_ori
+        )
+
+        # Decouples desired positional control from orientation control
+        if self.uncoupling:
+            decoupled_force = np.dot(lambda_pos, desired_force)
+            decoupled_torque = np.dot(lambda_ori, desired_torque)
+            decoupled_wrench = np.concatenate([decoupled_force, decoupled_torque])
+        else:
+            desired_wrench = np.concatenate([desired_force, desired_torque])
+            decoupled_wrench = np.dot(lambda_full, desired_wrench)
+
+        # Gamma (without null torques) = J^T * F + gravity compensations
+        self.torques = np.dot(self.J_full.T, decoupled_wrench) + self.torque_compensation
+        # Calculate and add nullspace torques (nullspace_matrix^T * Gamma_null) to final torques
+        # Note: Gamma_null = desired nullspace pose torques, assumed to be positional joint control relative
+        #                     to the initial joint positions
+        self.torques += nullspace_torques(
+            self.mass_matrix, nullspace_matrix, self.initial_joint, self.joint_pos, self.joint_vel
+        )
+
+        # Always run superclass call for any cleanups at the end
+        super().run_controller()
+
+        return self.torques
+
+    def update_origin(self, origin_pos, origin_ori):
+        """
+        Optional function to implement in subclass controllers that will take in @origin_pos and @origin_ori and update
+        internal configuration to account for changes in the respective states. Useful for controllers in which the origin
+        is a frame of reference that is dynamically changing, e.g., adapting the arm to move along with a moving base.
+
+        Args:
+            origin_pos (3-tuple): x,y,z position of controller reference in mujoco world coordinates
+            origin_ori (np.array): 3x3 rotation matrix orientation of controller reference in mujoco world coordinates
+        """
+        self.origin_pos = origin_pos
+        self.origin_ori = origin_ori
+
+    def update_initial_joints(self, initial_joints):
+        # First, update from the superclass method
+        super().update_initial_joints(initial_joints)
+
+        # We also need to reset the goal in case the old goals were set to the initial confguration
+        self.reset_goal()
+
+    def set_goal_update_mode(self, goal_update_mode):
+        self._goal_update_mode = goal_update_mode
+
+    def reset_goal(self, goal_update_mode="achieved"):
+        """
+        Resets the goal to the current state of the robot.
+
+        Args:
+            goal_update_mode (str): set mode for updating controller goals,
+                either "achieved" (achieved position) or "desired" (desired goal).
+        """
+        self.goal_ori = np.array(self.ref_ori_mat)
+        self.goal_pos = np.array(self.ref_pos)
+
+        assert goal_update_mode in ["achieved", "desired"]
+        self._goal_update_mode = goal_update_mode
+
+        # Also reset interpolators if required
+
+        if self.interpolator_pos is not None:
+            self.interpolator_pos.set_goal(self.goal_pos)
+
+        if self.interpolator_ori is not None:
+            self.ori_ref = np.array(self.ref_ori_mat)  # reference is the current orientation at start
+            self.interpolator_ori.set_goal(
+                orientation_error(self.goal_ori, self.ori_ref)
+            )  # goal is the total orientation error
+            self.relative_ori = np.zeros(3)  # relative orientation always starts at 0
+
+    @property
+    def control_limits(self):
+        """
+        Returns the limits over this controller's action space, overrides the superclass property
+        Returns the following (generalized for both high and low limits), based on the impedance mode:
+
+            :Mode `'fixed'`: [joint pos command]
+            :Mode `'variable'`: [damping_ratio values, kp values, joint pos command]
+            :Mode `'variable_kp'`: [kp values, joint pos command]
+
+        Returns:
+            2-tuple:
+
+                - (np.array) minimum action values
+                - (np.array) maximum action values
+        """
+        if self.impedance_mode == "variable":
+            low = np.concatenate([self.damping_ratio_min, self.kp_min, self.input_min])
+            high = np.concatenate([self.damping_ratio_max, self.kp_max, self.input_max])
+        elif self.impedance_mode == "variable_kp":
+            low = np.concatenate([self.kp_min, self.input_min])
+            high = np.concatenate([self.kp_max, self.input_max])
+        else:  # This is case "fixed"
+            low, high = self.input_min, self.input_max
+        return low, high
+
+    def delta_to_abs_action(self, delta_ac, goal_update_mode):
+        """
+        helper function that converts delta action into absolute action
+        """
+        abs_pos = self.compute_goal_pos(delta_ac[0:3], goal_update_mode=goal_update_mode)
+        abs_ori = self.compute_goal_ori(delta_ac[3:6], goal_update_mode=goal_update_mode)
+        abs_rot = T.quat2axisangle(T.mat2quat(abs_ori))
+        abs_action = np.concatenate([abs_pos, abs_rot])
+        return abs_action
+
+    @property
+    def name(self):
+        return "OSC_" + self.name_suffix

robosuite/controllers/parts/controller.py

@@ -0,0 +1,347 @@
+import abc
+from collections.abc import Iterable
+
+import mujoco
+import numpy as np
+
+import robosuite.macros as macros
+
+
+class Controller(object, metaclass=abc.ABCMeta):
+    """
+    General controller interface.
+
+    Requires reference to mujoco sim object, ref_name of specific robot, relevant joint_indexes to that robot, and
+    whether an initial_joint is used for nullspace torques or not
+
+    Args:
+        sim (MjSim): Simulator instance this controller will pull robot state updates from
+
+        ref_name (str): Name of controlled robot arm's end effector (from robot XML)
+
+        joint_indexes (dict): Each key contains sim reference indexes to relevant robot joint information, namely:
+
+            :`'joints'`: list of indexes to relevant robot joints
+            :`'qpos'`: list of indexes to relevant robot joint positions
+            :`'qvel'`: list of indexes to relevant robot joint velocities
+
+        actuator_range (2-tuple of array of float): 2-Tuple (low, high) representing the robot joint actuator range
+
+        lite_physics (bool): Whether to optimize for mujoco forward and step calls to reduce total simulation overhead.
+            Ignores all self.update() calls, unless set to force=True
+            Set to False to preserve backward compatibility with datasets collected in robosuite <= 1.4.1.
+    """
+
+    def __init__(
+        self,
+        sim,
+        joint_indexes,
+        actuator_range,
+        ref_name=None,
+        part_name=None,
+        naming_prefix=None,
+        lite_physics=True,
+    ):
+
+        # Actuator range
+        self.actuator_min = actuator_range[0]
+        self.actuator_max = actuator_range[1]
+
+        # Attributes for scaling / clipping inputs to outputs
+        self.action_scale = None
+        self.action_input_transform = None
+        self.action_output_transform = None
+
+        # Private property attributes
+        self.control_dim = None
+        self.output_min = None
+        self.output_max = None
+        self.input_min = None
+        self.input_max = None
+
+        # mujoco simulator state
+        self.sim = sim
+        self.model_timestep = macros.SIMULATION_TIMESTEP
+        self.lite_physics = lite_physics
+        self.ref_name = ref_name
+        # A list of site the controller want to follow
+        # self.ref_site_names = ref_site_names
+
+        self.part_name = part_name
+        self.naming_prefix = naming_prefix
+        self.joint_index = joint_indexes["joints"]
+        self.qpos_index = joint_indexes["qpos"]
+        self.qvel_index = joint_indexes["qvel"]
+        self.joint_names = [self.sim.model.joint_id2name(joint_id) for joint_id in self.joint_index]
+
+        # robot states
+        self.ref_pos = None
+        self.ref_ori_mat = None
+        self.ref_pos_vel = None
+        self.ref_ori_vel = None
+
+        self.joint_pos = None
+        self.joint_vel = None
+
+        # Joint dimension
+        self.joint_dim = len(joint_indexes["joints"])
+
+        if ref_name is None:
+            self.ref_names = None
+            self.num_ref_sites = 0
+        elif isinstance(ref_name, str):
+            self.ref_names = [ref_name]
+            self.num_ref_sites = 1
+        else:
+            self.ref_names = ref_name
+            self.num_ref_sites = len(ref_name)
+
+        # Initialize robot states
+        if self.num_ref_sites == 1:
+            # non-batched for backward compatibility
+            self.ref_pos = np.zeros(3)
+            self.ref_ori_mat = np.zeros((3, 3))
+            self.ref_pos_vel = np.zeros(3)
+            self.ref_ori_vel = np.zeros(3)
+            # Initialize Jacobians
+            self.J_pos = np.zeros((3, len(self.joint_index)))
+            self.J_ori = np.zeros((3, len(self.joint_index)))
+            self.J_full = np.zeros((6, len(self.joint_index)))
+        else:
+            self.ref_pos = np.zeros((self.num_ref_sites, 3))
+            self.ref_ori_mat = np.zeros((self.num_ref_sites, 3, 3))
+            self.ref_pos_vel = np.zeros((self.num_ref_sites, 3))
+            self.ref_ori_vel = np.zeros((self.num_ref_sites, 3))
+            # Initialize Jacobians
+            self.J_pos = np.zeros((self.num_ref_sites, 3, len(self.joint_index)))
+            self.J_ori = np.zeros((self.num_ref_sites, 3, len(self.joint_index)))
+            self.J_full = np.zeros((self.num_ref_sites, 6, len(self.joint_index)))
+
+        self.mass_matrix = None
+
+        # Torques being outputted by the controller
+        self.torques = None
+
+        # Update flag to prevent redundant update calls
+        self.new_update = True
+
+        # Move forward one timestep to propagate updates before taking first update
+        self.sim.forward()
+
+        # Initialize controller by updating internal state and setting the initial joint, pos, and ori
+        self.update()
+        self.initial_joint = self.joint_pos
+        self.initial_ref_pos = self.ref_pos
+        self.initial_ref_ori_mat = self.ref_ori_mat
+
+        self.origin_pos = None
+        self.origin_ori = None
+
+    @abc.abstractmethod
+    def run_controller(self):
+        """
+        Abstract method that should be implemented in all subclass controllers, and should convert a given action
+        into torques (pre gravity compensation) to be executed on the robot.
+        Additionally, resets the self.new_update flag so that the next self.update call will occur
+        """
+        self.new_update = True
+
+    def scale_action(self, action):
+        """
+        Clips @action to be within self.input_min and self.input_max, and then re-scale the values to be within
+        the range self.output_min and self.output_max
+
+        Args:
+            action (Iterable): Actions to scale
+
+        Returns:
+            np.array: Re-scaled action
+        """
+
+        if self.action_scale is None:
+            self.action_scale = abs(self.output_max - self.output_min) / abs(self.input_max - self.input_min)
+            self.action_output_transform = (self.output_max + self.output_min) / 2.0
+            self.action_input_transform = (self.input_max + self.input_min) / 2.0
+        action = np.clip(action, self.input_min, self.input_max)
+        transformed_action = (action - self.action_input_transform) * self.action_scale + self.action_output_transform
+
+        return transformed_action
+
+    def update_reference_data(self):
+        if self.num_ref_sites == 1:
+            self._update_single_reference(self.ref_name, 0)
+        else:
+            for i, name in enumerate(self.ref_name):
+                self._update_single_reference(name, i)
+
+    def _update_single_reference(self, name: str, index: int):
+        # TODO: remove if statement once we unify the shapes of variables when num_ref_sites == 1 and num_ref_sites > 1
+        ref_id = self.sim.model.site_name2id(name)
+
+        if self.num_ref_sites == 1:
+            self.ref_pos[:] = np.array(self.sim.data.site_xpos[ref_id])
+            self.ref_ori_mat[:, :] = np.array(self.sim.data.site_xmat[ref_id].reshape([3, 3]))
+            self.ref_pos_vel[:] = np.array(self.sim.data.get_site_xvelp(name))
+            self.ref_ori_vel[:] = np.array(self.sim.data.get_site_xvelr(name))
+            self.J_pos[:, :] = np.array(self.sim.data.get_site_jacp(name).reshape((3, -1))[:, self.qvel_index])
+            self.J_ori[:, :] = np.array(self.sim.data.get_site_jacr(name).reshape((3, -1))[:, self.qvel_index])
+            self.J_full[:, :] = np.vstack([self.J_pos, self.J_ori])
+        else:
+            self.ref_pos[index, :] = np.array(self.sim.data.site_xpos[ref_id])
+            self.ref_ori_mat[index, :, :] = np.array(self.sim.data.site_xmat[ref_id].reshape([3, 3]))
+            self.ref_pos_vel[index, :] = np.array(self.sim.data.get_site_xvelp(name))
+            self.ref_ori_vel[index, :] = np.array(self.sim.data.get_site_xvelr(name))
+
+            self.J_pos[index, :, :] = np.array(self.sim.data.get_site_jacp(name).reshape((3, -1))[:, self.qvel_index])
+            self.J_ori[index, :, :] = np.array(self.sim.data.get_site_jacr(name).reshape((3, -1))[:, self.qvel_index])
+            self.J_full[index, :, :] = np.vstack([self.J_pos[index], self.J_ori[index]])
+
+    def update(self, force=False):
+        """
+        Updates the state of the robot arm, including end effector pose / orientation / velocity, joint pos/vel,
+        jacobian, and mass matrix. By default, since this is a non-negligible computation, multiple redundant calls
+        will be ignored via the self.new_update attribute flag. However, if the @force flag is set, the update will
+        occur regardless of that state of self.new_update. This base class method of @run_controller resets the
+        self.new_update flag
+
+        Args:
+            force (bool): Whether to force an update to occur or not
+        """
+
+        # Only run update if self.new_update or force flag is set
+        if self.new_update or force:
+            # no need to call sim.forward if using lite_physics
+            if self.lite_physics and not force:
+                pass
+            else:
+                # BUG: Potential bug here. If there are more than two controlllers, the simulation will be forwarded multiple times.
+                self.sim.forward()
+
+            if self.ref_name is not None:
+                self.update_reference_data()
+
+            self.joint_pos = np.array(self.sim.data.qpos[self.qpos_index])
+            self.joint_vel = np.array(self.sim.data.qvel[self.qvel_index])
+
+            mass_matrix = np.ndarray(shape=(self.sim.model.nv, self.sim.model.nv), dtype=np.float64, order="C")
+            mujoco.mj_fullM(self.sim.model._model, mass_matrix, self.sim.data.qM)
+            mass_matrix = np.reshape(mass_matrix, (len(self.sim.data.qvel), len(self.sim.data.qvel)))
+            self.mass_matrix = mass_matrix[self.qvel_index, :][:, self.qvel_index]
+
+            # Clear self.new_update
+            self.new_update = False
+
+    def update_origin(self, origin_pos, origin_ori):
+        """
+        Optional function to implement in subclass controllers that will take in @origin_pos and @origin_ori and update
+        internal configuration to account for changes in the respective states. Useful for controllers in which the origin
+        is a frame of reference that is dynamically changing, e.g., adapting the arm to move along with a moving base.
+
+        Args:
+            origin_pos (3-tuple): x,y,z position of controller reference in mujoco world coordinates
+            origin_ori (np.array): 3x3 rotation matrix orientation of controller reference in mujoco world coordinates
+        """
+        self.origin_pos = origin_pos
+        self.origin_ori = origin_ori
+
+    def update_initial_joints(self, initial_joints):
+        """
+        Updates the internal attribute self.initial_joints. This is useful for updating changes in controller-specific
+        behavior, such as with OSC where self.initial_joints is used for determine nullspace actions
+
+        This function can also be extended by subclassed controllers for additional controller-specific updates
+
+        Args:
+            initial_joints (Iterable): Array of joint position values to update the initial joints
+        """
+        self.initial_joint = np.array(initial_joints)
+        self.update(force=True)
+
+        if self.ref_name is not None:
+            self.initial_ref_pos = self.ref_pos
+            self.initial_ref_ori_mat = self.ref_ori_mat
+
+    def clip_torques(self, torques):
+        """
+        Clips the torques to be within the actuator limits
+
+        Args:
+            torques (Iterable): Torques to clip
+
+        Returns:
+            np.array: Clipped torques
+        """
+        return np.clip(torques, self.actuator_min, self.actuator_max)
+
+    def reset_goal(self):
+        """
+        Resets the goal -- usually by setting to the goal to all zeros, but in some cases may be different (e.g.: OSC)
+        """
+        raise NotImplementedError
+
+    @staticmethod
+    def nums2array(nums, dim):
+        """
+        Convert input @nums into numpy array of length @dim. If @nums is a single number, broadcasts it to the
+        corresponding dimension size @dim before converting into a numpy array
+
+        Args:
+            nums (numeric or Iterable): Either single value or array of numbers
+            dim (int): Size of array to broadcast input to env.sim.data.actuator_force
+
+        Returns:
+            np.array: Array filled with values specified in @nums
+        """
+        # First run sanity check to make sure no strings are being inputted
+        if isinstance(nums, str):
+            raise TypeError("Error: Only numeric inputs are supported for this function, nums2array!")
+
+        # Check if input is an Iterable, if so, we simply convert the input to np.array and return
+        # Else, input is a single value, so we map to a numpy array of correct size and return
+        return np.array(nums) if isinstance(nums, Iterable) else np.ones(dim) * nums
+
+    @property
+    def torque_compensation(self):
+        """
+        Gravity compensation for this robot arm
+
+        Returns:
+            np.array: torques
+        """
+        return self.sim.data.qfrc_bias[self.qvel_index]
+
+    @property
+    def actuator_limits(self):
+        """
+        Torque limits for this controller
+
+        Returns:
+            2-tuple:
+
+                - (np.array) minimum actuator torques
+                - (np.array) maximum actuator torques
+        """
+        return self.actuator_min, self.actuator_max
+
+    @property
+    def control_limits(self):
+        """
+        Limits over this controller's action space, which defaults to input min/max
+
+        Returns:
+            2-tuple:
+
+                - (np.array) minimum action values
+                - (np.array) maximum action values
+        """
+        return self.input_min, self.input_max
+
+    @property
+    def name(self):
+        """
+        Name of this controller
+
+        Returns:
+            str: controller name
+        """
+        raise NotImplementedError

robosuite/controllers/parts/controller_factory.py

@@ -0,0 +1,232 @@
+"""
+Set of functions that streamline controller initialization process
+"""
+import json
+import os
+from copy import deepcopy
+
+import numpy as np
+
+from robosuite.controllers.parts import arm as arm_controllers
+from robosuite.controllers.parts import generic
+from robosuite.controllers.parts import gripper as gripper_controllers
+from robosuite.controllers.parts import mobile_base as mobile_base_controllers
+from robosuite.utils.traj_utils import LinearInterpolator
+
+# from . import legs as legs_controllers
+
+
+def load_part_controller_config(custom_fpath=None, default_controller=None):
+    """
+    Utility function that loads the desired controller and returns the loaded configuration as a dict
+
+    If @default_controller is specified, any value inputted to @custom_fpath is overridden and the default controller
+    configuration is automatically loaded. See specific arg description below for available default controllers.
+
+    Args:
+        custom_fpath (str): Absolute filepath to the custom controller configuration .json file to be loaded
+        default_controller (str): If specified, overrides @custom_fpath and loads a default configuration file for the
+            specified controller.
+            Choices are: {"JOINT_POSITION", "JOINT_TORQUE", "JOINT_VELOCITY", "OSC_POSITION", "OSC_POSE", "IK_POSE"}
+
+    Returns:
+        dict: Controller configuration
+
+    Raises:
+        AssertionError: [Unknown default controller name]
+        AssertionError: [No controller specified]
+    """
+    # TODO (YL): this is nolonger usable, need to update
+    # First check if default controller is not None; if it
+    # is not, load the appropriate controller
+    if default_controller is not None:
+
+        # Assert that requested default controller is in the available default controllers
+        from robosuite.controllers import ALL_PART_CONTROLLERS
+
+        assert (
+            default_controller in ALL_PART_CONTROLLERS
+        ), "Error: Unknown default controller specified. Requested {}, " "available controllers: {}".format(
+            default_controller, list(ALL_PART_CONTROLLERS)
+        )
+
+        # Store the default controller config fpath associated with the requested controller
+        custom_fpath = os.path.join(
+            os.path.dirname(__file__), "..", "config/default/parts/{}.json".format(default_controller.lower())
+        )
+
+    # Assert that the fpath to load the controller is not empty
+    assert custom_fpath is not None, "Error: Either custom_fpath or default_controller must be specified!"
+
+    # Attempt to load the controller
+    try:
+        with open(custom_fpath) as f:
+            controller_config = json.load(f)
+    except FileNotFoundError:
+        print("Error opening controller filepath at: {}. " "Please check filepath and try again.".format(custom_fpath))
+        raise FileNotFoundError
+
+    # Return the loaded controller
+    return controller_config
+
+
+def arm_controller_factory(name, params):
+    """
+    Generator for controllers
+
+    Creates a Controller instance with the provided @name and relevant @params.
+
+    Args:
+        name (str): the name of the controller. Must be one of: {JOINT_POSITION, JOINT_TORQUE, JOINT_VELOCITY,
+            OSC_POSITION, OSC_POSE, IK_POSE}
+        params (dict): dict containing the relevant params to pass to the controller
+        sim (MjSim): Mujoco sim reference to pass to the controller
+
+    Returns:
+        Controller: Controller instance
+
+    Raises:
+        ValueError: [unknown controller]
+    """
+
+    interpolator = None
+    if params["interpolation"] == "linear":
+        interpolator = LinearInterpolator(
+            ndim=params["ndim"],
+            controller_freq=(1 / params["sim"].model.opt.timestep),
+            policy_freq=params["policy_freq"],
+            ramp_ratio=params["ramp_ratio"],
+        )
+
+    if name == "OSC_POSE":
+        ori_interpolator = None
+        if interpolator is not None:
+            interpolator.set_states(dim=3)  # EE control uses dim 3 for pos and ori each
+            ori_interpolator = deepcopy(interpolator)
+            ori_interpolator.set_states(ori="euler")
+        params["control_ori"] = True
+        return arm_controllers.OperationalSpaceController(
+            interpolator_pos=interpolator, interpolator_ori=ori_interpolator, **params
+        )
+
+    if name == "OSC_POSITION":
+        if interpolator is not None:
+            interpolator.set_states(dim=3)  # EE control uses dim 3 for pos
+        params["control_ori"] = False
+        return arm_controllers.OperationalSpaceController(interpolator_pos=interpolator, **params)
+
+    if name == "IK_POSE":
+        ori_interpolator = None
+        if interpolator is not None:
+            interpolator.set_states(dim=3)  # EE IK control uses dim 3 for pos and dim 4 for ori
+            ori_interpolator = deepcopy(interpolator)
+            ori_interpolator.set_states(dim=4, ori="quat")
+
+        from robosuite.controllers.parts.arm.ik import InverseKinematicsController
+
+        return InverseKinematicsController(
+            interpolator_pos=interpolator,
+            interpolator_ori=ori_interpolator,
+            **params,
+        )
+
+    if name == "JOINT_VELOCITY":
+        return generic.JointVelocityController(interpolator=interpolator, **params)
+
+    if name == "JOINT_POSITION":
+        return generic.JointPositionController(interpolator=interpolator, **params)
+
+    if name == "JOINT_TORQUE":
+        return generic.JointTorqueController(interpolator=interpolator, **params)
+
+    raise ValueError("Unknown controller name: {}".format(name))
+
+
+def controller_factory(part_name, controller_type, controller_params):
+    if part_name in ["right", "left"]:
+        return arm_controller_factory(controller_type, controller_params)
+    elif part_name in ["right_gripper", "left_gripper"]:
+        return gripper_controller_factory(controller_type, controller_params)
+    elif part_name == "base":
+        return mobile_base_controller_factory(controller_type, controller_params)
+    elif part_name == "torso":
+        return torso_controller_factory(controller_type, controller_params)
+    elif part_name == "head":
+        return head_controller_factory(controller_type, controller_params)
+    elif part_name == "legs":
+        return legs_controller_factory(controller_type, controller_params)
+    else:
+        raise ValueError("Unknown controller part name: {}".format(part_name))
+
+
+def gripper_controller_factory(name, params):
+    interpolator = None
+    if name == "GRIP":
+        return gripper_controllers.SimpleGripController(interpolator=interpolator, **params)
+    elif name == "JOINT_POSITION":
+        return generic.JointPositionController(interpolator=interpolator, **params)
+    raise ValueError("Unknown controller name: {}".format(name))
+
+
+def mobile_base_controller_factory(name, params):
+    interpolator = None
+    if name == "JOINT_VELOCITY":
+        return mobile_base_controllers.MobileBaseJointVelocityController(interpolator=interpolator, **params)
+    elif name == "JOINT_VELOCITY_LEGACY":
+        return mobile_base_controllers.LegacyMobileBaseJointVelocityController(interpolator=interpolator, **params)
+    elif name == "JOINT_POSITION":
+        raise NotImplementedError
+    raise ValueError("Unknown controller name: {}".format(name))
+
+
+def torso_controller_factory(name, params):
+    interpolator = None
+    if params["interpolation"] == "linear":
+        interpolator = LinearInterpolator(
+            ndim=params["ndim"],
+            controller_freq=(1 / params["sim"].model.opt.timestep),
+            policy_freq=params["policy_freq"],
+            ramp_ratio=params["ramp_ratio"],
+        )
+
+    if name == "JOINT_VELOCITY":
+        return generic.JointVelocityController(interpolator=interpolator, **params)
+    elif name == "JOINT_POSITION":
+        return generic.JointPositionController(interpolator=interpolator, **params)
+    raise ValueError("Unknown controller name: {}".format(name))
+
+
+def head_controller_factory(name, params):
+    interpolator = None
+    if params["interpolation"] == "linear":
+        interpolator = LinearInterpolator(
+            ndim=params["ndim"],
+            controller_freq=(1 / params["sim"].model.opt.timestep),
+            policy_freq=params["policy_freq"],
+            ramp_ratio=params["ramp_ratio"],
+        )
+
+    if name == "JOINT_VELOCITY":
+        return generic.JointVelocityController(interpolator=interpolator, **params)
+    elif name == "JOINT_POSITION":
+        return generic.JointPositionController(interpolator=interpolator, **params)
+    raise ValueError("Unknown controller name: {}".format(name))
+
+
+def legs_controller_factory(name, params):
+    interpolator = None
+    if params["interpolation"] == "linear":
+        interpolator = LinearInterpolator(
+            ndim=params["ndim"],
+            controller_freq=(1 / params["sim"].model.opt.timestep),
+            policy_freq=params["policy_freq"],
+            ramp_ratio=params["ramp_ratio"],
+        )
+
+    if name == "JOINT_POSITION":
+        return generic.JointPositionController(interpolator=interpolator, **params)
+
+    if name == "JOINT_TORQUE":
+        return generic.JointTorqueController(interpolator=interpolator, **params)
+
+    raise ValueError("Unknown controller name: {}".format(name))

robosuite/controllers/parts/generic/__init__.py

@@ -0,0 +1,3 @@
+from .joint_pos import JointPositionController
+from .joint_vel import JointVelocityController
+from .joint_tor import JointTorqueController

robosuite/controllers/parts/generic/joint_pos.py

@@ -0,0 +1,312 @@
+from typing import Dict, List, Literal
+
+import numpy as np
+
+from robosuite.controllers.parts.controller import Controller
+from robosuite.utils.control_utils import *
+
+# Supported impedance modes
+IMPEDANCE_MODES = {"fixed", "variable", "variable_kp"}
+
+
+class JointPositionController(Controller):
+    """
+    Controller for controlling robot arm via impedance control. Allows position control of the robot's joints.
+
+    NOTE: Control input actions assumed to be taken relative to the current joint positions. A given action to this
+    controller is assumed to be of the form: (dpos_j0, dpos_j1, ... , dpos_jn-1) for an n-joint robot
+
+    Args:
+        sim (MjSim): Simulator instance this controller will pull robot state updates from
+
+        eef_name (str): Name of controlled robot arm's end effector (from robot XML)
+
+        joint_indexes (dict): Each key contains sim reference indexes to relevant robot joint information, namely:
+
+            :`'joints'`: list of indexes to relevant robot joints
+            :`'qpos'`: list of indexes to relevant robot joint positions
+            :`'qvel'`: list of indexes to relevant robot joint velocities
+
+        actuator_range (2-tuple of array of float): 2-Tuple (low, high) representing the robot joint actuator range
+
+        input_max (float or Iterable of float): Maximum above which an inputted action will be clipped. Can be either be
+            a scalar (same value for all action dimensions), or a list (specific values for each dimension). If the
+            latter, dimension should be the same as the control dimension for this controller
+
+        input_min (float or Iterable of float): Minimum below which an inputted action will be clipped. Can be either be
+            a scalar (same value for all action dimensions), or a list (specific values for each dimension). If the
+            latter, dimension should be the same as the control dimension for this controller
+
+        output_max (float or Iterable of float): Maximum which defines upper end of scaling range when scaling an input
+            action. Can be either be a scalar (same value for all action dimensions), or a list (specific values for
+            each dimension). If the latter, dimension should be the same as the control dimension for this controller
+
+        output_min (float or Iterable of float): Minimum which defines upper end of scaling range when scaling an input
+            action. Can be either be a scalar (same value for all action dimensions), or a list (specific values for
+            each dimension). If the latter, dimension should be the same as the control dimension for this controller
+
+        kp (float or Iterable of float): positional gain for determining desired torques based upon the joint pos error.
+            Can be either be a scalar (same value for all action dims), or a list (specific values for each dim)
+
+        damping_ratio (float or Iterable of float): used in conjunction with kp to determine the velocity gain for
+            determining desired torques based upon the joint pos errors. Can be either be a scalar (same value for all
+            action dims), or a list (specific values for each dim)
+
+        impedance_mode (str): Impedance mode with which to run this controller. Options are {"fixed", "variable",
+            "variable_kp"}. If "fixed", the controller will have fixed kp and damping_ratio values as specified by the
+            @kp and @damping_ratio arguments. If "variable", both kp and damping_ratio will now be part of the
+            controller action space, resulting in a total action space of num_joints * 3. If "variable_kp", only kp
+            will become variable, with damping_ratio fixed at 1 (critically damped). The resulting action space will
+            then be num_joints * 2.
+
+        kp_limits (2-list of float or 2-list of Iterable of floats): Only applicable if @impedance_mode is set to either
+            "variable" or "variable_kp". This sets the corresponding min / max ranges of the controller action space
+            for the varying kp values. Can be either be a 2-list (same min / max for all kp action dims), or a 2-list
+            of list (specific min / max for each kp dim)
+
+        damping_ratio_limits (2-list of float or 2-list of Iterable of floats): Only applicable if @impedance_mode is
+            set to "variable". This sets the corresponding min / max ranges of the controller action space for the
+            varying damping_ratio values. Can be either be a 2-list (same min / max for all damping_ratio action dims),
+            or a 2-list of list (specific min / max for each damping_ratio dim)
+
+        policy_freq (int): Frequency at which actions from the robot policy are fed into this controller
+
+        qpos_limits (2-list of float or 2-list of Iterable of floats): Limits (rad) below and above which the magnitude
+            of a calculated goal joint position will be clipped. Can be either be a 2-list (same min/max value for all
+            joint dims), or a 2-list of list (specific min/max values for each dim)
+
+        interpolator (Interpolator): Interpolator object to be used for interpolating from the current joint position to
+            the goal joint position during each timestep between inputted actions
+
+        **kwargs: Does nothing; placeholder to "sink" any additional arguments so that instantiating this controller
+            via an argument dict that has additional extraneous arguments won't raise an error
+
+    Raises:
+        AssertionError: [Invalid impedance mode]
+    """
+
+    def __init__(
+        self,
+        sim,
+        joint_indexes,
+        actuator_range,
+        ref_name=None,
+        input_max=1,
+        input_min=-1,
+        output_max=0.05,
+        output_min=-0.05,
+        kp=50,
+        damping_ratio=1,
+        impedance_mode="fixed",
+        kp_limits=(0, 300),
+        damping_ratio_limits=(0, 100),
+        policy_freq=20,
+        lite_physics=True,
+        qpos_limits=None,
+        interpolator=None,
+        input_type: Literal["delta", "absolute"] = "delta",
+        **kwargs,  # does nothing; used so no error raised when dict is passed with extra terms used previously
+    ):
+
+        super().__init__(
+            sim,
+            ref_name=ref_name,
+            joint_indexes=joint_indexes,
+            actuator_range=actuator_range,
+            part_name=kwargs.get("part_name", None),
+            naming_prefix=kwargs.get("naming_prefix", None),
+            lite_physics=lite_physics,
+        )
+
+        self.joint_indexes = joint_indexes
+
+        # Control dimension
+        self.control_dim = len(joint_indexes["joints"])
+
+        # input and output max and min (allow for either explicit lists or single numbers)
+        self.input_max = self.nums2array(input_max, self.control_dim)
+        self.input_min = self.nums2array(input_min, self.control_dim)
+        self.output_max = self.nums2array(output_max, self.control_dim)
+        self.output_min = self.nums2array(output_min, self.control_dim)
+
+        # limits
+        self.position_limits = np.array(qpos_limits) if qpos_limits is not None else qpos_limits
+
+        # kp kd
+        self.kp = self.nums2array(kp, self.control_dim)
+        self.kd = (
+            2 * np.sqrt(self.kp) * damping_ratio
+            if kwargs.get("kd", None) is None
+            else self.nums2array(kwargs.get("kd", None), self.control_dim)
+        )
+
+        # kp and kd limits
+        self.kp_min = self.nums2array(kp_limits[0], self.control_dim)
+        self.kp_max = self.nums2array(kp_limits[1], self.control_dim)
+        self.damping_ratio_min = self.nums2array(damping_ratio_limits[0], self.control_dim)
+        self.damping_ratio_max = self.nums2array(damping_ratio_limits[1], self.control_dim)
+
+        # Verify the proposed impedance mode is supported
+        assert impedance_mode in IMPEDANCE_MODES, (
+            "Error: Tried to instantiate OSC controller for unsupported "
+            "impedance mode! Inputted impedance mode: {}, Supported modes: {}".format(impedance_mode, IMPEDANCE_MODES)
+        )
+
+        # Impedance mode
+        self.impedance_mode = impedance_mode
+
+        # Add to control dim based on impedance_mode
+        if self.impedance_mode == "variable":
+            self.control_dim *= 3
+        elif self.impedance_mode == "variable_kp":
+            self.control_dim *= 2
+
+        # control frequency
+        self.control_freq = policy_freq
+
+        # interpolator
+        self.interpolator = interpolator
+
+        self.input_type = input_type
+        assert self.input_type in ["delta", "absolute"], f"Input type must be delta or absolute, got: {self.input_type}"
+        if self.input_type == "absolute":
+            assert self.impedance_mode == "fixed", "Absolute input type is only supported for fixed impedance mode."
+
+        # initialize
+        self.goal_qpos = None
+
+        self.use_torque_compensation = kwargs.get("use_torque_compensation", True)
+
+    def set_goal(self, action, set_qpos=None):
+        """
+        Sets goal based on input @action. If self.impedance_mode is not "fixed", then the input will be parsed into the
+        delta values to update the goal position / pose and the kp and/or damping_ratio values to be immediately updated
+        internally before executing the proceeding control loop.
+
+        Note that @action expected to be in the following format, based on impedance mode!
+
+            :Mode `'fixed'`: [joint pos command]
+            :Mode `'variable'`: [damping_ratio values, kp values, joint pos command]
+            :Mode `'variable_kp'`: [kp values, joint pos command]
+
+        Args:
+            action (Iterable): Desired relative joint position goal state
+            set_qpos (Iterable): If set, overrides @action and sets the desired absolute joint position goal state
+
+        Raises:
+            AssertionError: [Invalid action dimension size]
+        """
+        # Update state
+        self.update()
+
+        if self.input_type == "delta":
+            # Parse action based on the impedance mode, and update kp / kd as necessary
+            jnt_dim = len(self.qpos_index)
+            if self.impedance_mode == "variable":
+                damping_ratio, kp, delta = action[:jnt_dim], action[jnt_dim : 2 * jnt_dim], action[2 * jnt_dim :]
+                self.kp = np.clip(kp, self.kp_min, self.kp_max)
+                self.kd = 2 * np.sqrt(self.kp) * np.clip(damping_ratio, self.damping_ratio_min, self.damping_ratio_max)
+            elif self.impedance_mode == "variable_kp":
+                kp, delta = action[:jnt_dim], action[jnt_dim:]
+                self.kp = np.clip(kp, self.kp_min, self.kp_max)
+                self.kd = 2 * np.sqrt(self.kp)  # critically damped
+            else:  # This is case "fixed"
+                delta = action
+
+            # Check to make sure delta is size self.joint_dim
+            assert len(delta) == jnt_dim, "Delta qpos must be equal to the robot's joint dimension space!"
+
+            if delta is not None:
+                scaled_delta = self.scale_action(delta)
+            else:
+                scaled_delta = None
+
+            self.goal_qpos = set_goal_position(
+                scaled_delta, self.joint_pos, position_limit=self.position_limits, set_pos=set_qpos
+            )
+        elif self.input_type == "absolute":
+            self.goal_qpos = action
+
+        if self.interpolator is not None:
+            self.interpolator.set_goal(self.goal_qpos)
+
+    def run_controller(self):
+        """
+        Calculates the torques required to reach the desired setpoint
+
+        Returns:
+             np.array: Command torques
+        """
+        # Make sure goal has been set
+        if self.goal_qpos is None:
+            self.set_goal(np.zeros(self.control_dim))
+
+        # Update state
+        self.update()
+
+        desired_qpos = None
+
+        # Only linear interpolator is currently supported
+        if self.interpolator is not None:
+            # Linear case
+            if self.interpolator.order == 1:
+                desired_qpos = self.interpolator.get_interpolated_goal()
+            else:
+                # Nonlinear case not currently supported
+                pass
+        else:
+            desired_qpos = np.array(self.goal_qpos)
+
+        position_error = desired_qpos - self.joint_pos
+        vel_pos_error = -self.joint_vel
+        desired_torque = np.multiply(np.array(position_error), np.array(self.kp)) + np.multiply(vel_pos_error, self.kd)
+
+        # Return desired torques plus gravity compensations
+        if self.use_torque_compensation:
+            self.torques = np.dot(self.mass_matrix, desired_torque) + self.torque_compensation
+        else:
+            self.torques = desired_torque
+
+        # Always run superclass call for any cleanups at the end
+        super().run_controller()
+        return self.torques
+
+    def reset_goal(self):
+        """
+        Resets joint position goal to be current position
+        """
+        self.goal_qpos = self.joint_pos
+
+        # Reset interpolator if required
+        if self.interpolator is not None:
+            self.interpolator.set_goal(self.goal_qpos)
+
+    @property
+    def control_limits(self):
+        """
+        Returns the limits over this controller's action space, overrides the superclass property
+        Returns the following (generalized for both high and low limits), based on the impedance mode:
+
+            :Mode `'fixed'`: [joint pos command]
+            :Mode `'variable'`: [damping_ratio values, kp values, joint pos command]
+            :Mode `'variable_kp'`: [kp values, joint pos command]
+
+        Returns:
+            2-tuple:
+
+                - (np.array) minimum action values
+                - (np.array) maximum action values
+        """
+        if self.impedance_mode == "variable":
+            low = np.concatenate([self.damping_ratio_min, self.kp_min, self.input_min])
+            high = np.concatenate([self.damping_ratio_max, self.kp_max, self.input_max])
+        elif self.impedance_mode == "variable_kp":
+            low = np.concatenate([self.kp_min, self.input_min])
+            high = np.concatenate([self.kp_max, self.input_max])
+        else:  # This is case "fixed"
+            low, high = self.input_min, self.input_max
+        return low, high
+
+    @property
+    def name(self):
+        return "JOINT_POSITION"

robosuite/controllers/parts/generic/joint_tor.py

@@ -0,0 +1,181 @@
+import numpy as np
+
+from robosuite.controllers.parts.controller import Controller
+
+
+class JointTorqueController(Controller):
+    """
+    Controller for controlling the robot arm's joint torques. As the actuators at the mujoco sim level are already
+    torque actuators, this "controller" usually simply "passes through" desired torques, though it also includes the
+    typical input / output scaling and clipping, as well as interpolator features seen in other controllers classes
+    as well
+
+    NOTE: Control input actions assumed to be taken as absolute joint torques. A given action to this
+    controller is assumed to be of the form: (torq_j0, torq_j1, ... , torq_jn-1) for an n-joint robot
+
+    Args:
+        sim (MjSim): Simulator instance this controller will pull robot state updates from
+
+        eef_name (str): Name of controlled robot arm's end effector (from robot XML)
+
+        joint_indexes (dict): Each key contains sim reference indexes to relevant robot joint information, namely:
+
+            :`'joints'`: list of indexes to relevant robot joints
+            :`'qpos'`: list of indexes to relevant robot joint positions
+            :`'qvel'`: list of indexes to relevant robot joint velocities
+
+        actuator_range (2-tuple of array of float): 2-Tuple (low, high) representing the robot joint actuator range
+
+        input_max (float or list of float): Maximum above which an inputted action will be clipped. Can be either be
+            a scalar (same value for all action dimensions), or a list (specific values for each dimension). If the
+            latter, dimension should be the same as the control dimension for this controller
+
+        input_min (float or list of float): Minimum below which an inputted action will be clipped. Can be either be
+            a scalar (same value for all action dimensions), or a list (specific values for each dimension). If the
+            latter, dimension should be the same as the control dimension for this controller
+
+        output_max (float or list of float): Maximum which defines upper end of scaling range when scaling an input
+            action. Can be either be a scalar (same value for all action dimensions), or a list (specific values for
+            each dimension). If the latter, dimension should be the same as the control dimension for this controller
+
+        output_min (float or list of float): Minimum which defines upper end of scaling range when scaling an input
+            action. Can be either be a scalar (same value for all action dimensions), or a list (specific values for
+            each dimension). If the latter, dimension should be the same as the control dimension for this controller
+
+        policy_freq (int): Frequency at which actions from the robot policy are fed into this controller
+
+        torque_limits (2-list of float or 2-list of list of floats): Limits (N-m) below and above which the magnitude
+            of a calculated goal joint torque will be clipped. Can be either be a 2-list (same min/max value for all
+            joint dims), or a 2-list of list (specific min/max values for each dim)
+            If not specified, will automatically set the limits to the actuator limits for this robot arm
+
+        interpolator (Interpolator): Interpolator object to be used for interpolating from the current joint torques to
+            the goal joint torques during each timestep between inputted actions
+
+        **kwargs: Does nothing; placeholder to "sink" any additional arguments so that instantiating this controller
+            via an argument dict that has additional extraneous arguments won't raise an error
+    """
+
+    def __init__(
+        self,
+        sim,
+        joint_indexes,
+        actuator_range,
+        ref_name=None,
+        input_max=1,
+        input_min=-1,
+        output_max=0.05,
+        output_min=-0.05,
+        policy_freq=20,
+        lite_physics=True,
+        torque_limits=None,
+        interpolator=None,
+        **kwargs,  # does nothing; used so no error raised when dict is passed with extra terms used previously
+    ):
+
+        super().__init__(
+            sim,
+            ref_name=ref_name,
+            joint_indexes=joint_indexes,
+            actuator_range=actuator_range,
+            part_name=kwargs.get("part_name", None),
+            naming_prefix=kwargs.get("naming_prefix", None),
+            lite_physics=lite_physics,
+        )
+
+        # Control dimension
+        self.control_dim = len(joint_indexes["joints"])
+
+        # input and output max and min (allow for either explicit lists or single numbers)
+        self.input_max = self.nums2array(input_max, self.control_dim)
+        self.input_min = self.nums2array(input_min, self.control_dim)
+        self.output_max = self.nums2array(output_max, self.control_dim)
+        self.output_min = self.nums2array(output_min, self.control_dim)
+
+        # limits (if not specified, set them to actuator limits by default)
+        self.torque_limits = np.array(torque_limits) if torque_limits is not None else self.actuator_limits
+
+        # control frequency
+        self.control_freq = policy_freq
+
+        # interpolator
+        self.interpolator = interpolator
+
+        # initialize torques
+        self.goal_torque = None  # Goal torque desired, pre-compensation
+        self.current_torque = np.zeros(self.control_dim)  # Current torques being outputted, pre-compensation
+        self.torques = None  # Torques returned every time run_controller is called
+
+        self.use_torque_compensation = kwargs.get("use_torque_compensation", True)
+
+    def set_goal(self, torques):
+        """
+        Sets goal based on input @torques.
+
+        Args:
+            torques (Iterable): Desired joint torques
+
+        Raises:
+            AssertionError: [Invalid action dimension size]
+        """
+        # Update state
+        self.update()
+
+        # Check to make sure torques is size self.joint_dim
+        assert len(torques) == self.control_dim, "Delta torque must be equal to the robot's joint dimension space!"
+
+        self.goal_torque = np.clip(self.scale_action(torques), self.torque_limits[0], self.torque_limits[1])
+
+        if self.interpolator is not None:
+            self.interpolator.set_goal(self.goal_torque)
+
+    def run_controller(self):
+        """
+        Calculates the torques required to reach the desired setpoint
+
+        Returns:
+             np.array: Command torques
+        """
+        # Make sure goal has been set
+        if self.goal_torque is None:
+            self.set_goal(np.zeros(self.control_dim))
+
+        # Update state
+        self.update()
+
+        # Only linear interpolator is currently supported
+        if self.interpolator is not None:
+            # Linear case
+            if self.interpolator.order == 1:
+                self.current_torque = self.interpolator.get_interpolated_goal()
+            else:
+                # Nonlinear case not currently supported
+                pass
+        else:
+            self.current_torque = np.array(self.goal_torque)
+
+        # Add gravity compensation
+        if self.use_torque_compensation:
+            self.torques = self.current_torque + self.torque_compensation
+        else:
+            self.torques = self.current_torque
+
+        # Always run superclass call for any cleanups at the end
+        super().run_controller()
+
+        # Return final torques
+        return self.torques
+
+    def reset_goal(self):
+        """
+        Resets joint torque goal to be all zeros (pre-compensation)
+        """
+        self.goal_torque = np.zeros(self.control_dim)
+
+        # Reset interpolator if required
+        if self.interpolator is not None:
+            self.interpolator.set_goal(self.goal_torque)
+
+    @property
+    def name(self):
+        return "JOINT_TORQUE"

robosuite/controllers/parts/generic/joint_vel.py

@@ -0,0 +1,223 @@
+import numpy as np
+
+from robosuite.controllers.parts.controller import Controller
+from robosuite.utils.buffers import RingBuffer
+
+
+class JointVelocityController(Controller):
+    """
+    Controller for controlling the robot arm's joint velocities. This is simply a P controller with desired torques
+    (pre gravity compensation) taken to be proportional to the velocity error of the robot joints.
+
+    NOTE: Control input actions assumed to be taken as absolute joint velocities. A given action to this
+    controller is assumed to be of the form: (vel_j0, vel_j1, ... , vel_jn-1) for an n-joint robot
+
+    Args:
+        sim (MjSim): Simulator instance this controller will pull robot state updates from
+
+        eef_name (str): Name of controlled robot arm's end effector (from robot XML)
+
+        joint_indexes (dict): Each key contains sim reference indexes to relevant robot joint information, namely:
+
+            :`'joints'`: list of indexes to relevant robot joints
+            :`'qpos'`: list of indexes to relevant robot joint positions
+            :`'qvel'`: list of indexes to relevant robot joint velocities
+
+        actuator_range (2-tuple of array of float): 2-Tuple (low, high) representing the robot joint actuator range
+
+        input_max (float or list of float): Maximum above which an inputted action will be clipped. Can be either be
+            a scalar (same value for all action dimensions), or a list (specific values for each dimension). If the
+            latter, dimension should be the same as the control dimension for this controller
+
+        input_min (float or list of float): Minimum below which an inputted action will be clipped. Can be either be
+            a scalar (same value for all action dimensions), or a list (specific values for each dimension). If the
+            latter, dimension should be the same as the control dimension for this controller
+
+        output_max (float or list of float): Maximum which defines upper end of scaling range when scaling an input
+            action. Can be either be a scalar (same value for all action dimensions), or a list (specific values for
+            each dimension). If the latter, dimension should be the same as the control dimension for this controller
+
+        output_min (float or list of float): Minimum which defines upper end of scaling range when scaling an input
+            action. Can be either be a scalar (same value for all action dimensions), or a list (specific values for
+            each dimension). If the latter, dimension should be the same as the control dimension for this controller
+
+        kp (float or list of float): velocity gain for determining desired torques based upon the joint vel errors.
+            Can be either be a scalar (same value for all action dims), or a list (specific values for each dim)
+
+        policy_freq (int): Frequency at which actions from the robot policy are fed into this controller
+
+        velocity_limits (2-list of float or 2-list of list of floats): Limits (m/s) below and above which the magnitude
+            of a calculated goal joint velocity will be clipped. Can be either be a 2-list (same min/max value for all
+            joint dims), or a 2-list of list (specific min/max values for each dim)
+
+        interpolator (Interpolator): Interpolator object to be used for interpolating from the current joint velocities
+            to the goal joint velocities during each timestep between inputted actions
+
+        **kwargs: Does nothing; placeholder to "sink" any additional arguments so that instantiating this controller
+            via an argument dict that has additional extraneous arguments won't raise an error
+    """
+
+    def __init__(
+        self,
+        sim,
+        joint_indexes,
+        actuator_range,
+        ref_name=None,
+        input_max=1,
+        input_min=-1,
+        output_max=1,
+        output_min=-1,
+        kp=0.25,
+        policy_freq=20,
+        lite_physics=True,
+        velocity_limits=None,
+        interpolator=None,
+        **kwargs,  # does nothing; used so no error raised when dict is passed with extra terms used previously
+    ):
+
+        super().__init__(
+            sim,
+            ref_name=ref_name,
+            joint_indexes=joint_indexes,
+            actuator_range=actuator_range,
+            part_name=kwargs.get("part_name", None),
+            naming_prefix=kwargs.get("naming_prefix", None),
+            lite_physics=lite_physics,
+        )
+        # Control dimension
+        self.control_dim = len(joint_indexes["joints"])
+
+        # input and output max and min (allow for either explicit lists or single numbers)
+        self.input_max = self.nums2array(input_max, self.joint_dim)
+        self.input_min = self.nums2array(input_min, self.joint_dim)
+        self.output_max = self.nums2array(output_max, self.joint_dim)
+        self.output_min = self.nums2array(output_min, self.joint_dim)
+
+        # gains and corresopnding vars
+        self.kp = self.nums2array(kp, self.joint_dim)
+        # if kp is a single value, map wrist gains accordingly (scale down x10 for final two joints)
+
+        if type(kp) is float or type(kp) is int:
+            # Scale kpp according to how wide the actuator range is for this robot
+            low, high = self.actuator_limits
+            self.kp = kp * (high - low)
+
+        self.ki = self.kp * 0.005
+        self.kd = self.kp * 0.001
+        self.last_err = np.zeros(self.joint_dim)
+        self.derr_buf = RingBuffer(dim=self.joint_dim, length=5)
+        self.summed_err = np.zeros(self.joint_dim)
+        self.saturated = False
+        self.last_joint_vel = np.zeros(self.joint_dim)
+
+        # limits
+        self.velocity_limits = np.array(velocity_limits) if velocity_limits is not None else None
+
+        # control frequency
+        self.control_freq = policy_freq
+
+        # interpolator
+        self.interpolator = interpolator
+
+        # initialize torques and goal velocity
+        self.goal_vel = None  # Goal velocity desired, pre-compensation
+        self.current_vel = np.zeros(self.joint_dim)  # Current velocity setpoint, pre-compensation
+        self.torques = None  # Torques returned every time run_controller is called
+
+        self.torque_compensation = kwargs.get("use_torque_compensation", True)
+
+    def set_goal(self, velocities):
+        """
+        Sets goal based on input @velocities.
+
+        Args:
+            velocities (Iterable): Desired joint velocities
+
+        Raises:
+            AssertionError: [Invalid action dimension size]
+        """
+        # Update state
+        self.update()
+
+        # Otherwise, check to make sure velocities is size self.joint_dim
+        assert (
+            len(velocities) == self.joint_dim
+        ), "Goal action must be equal to the robot's joint dimension space! Expected {}, got {}".format(
+            self.joint_dim, len(velocities)
+        )
+
+        self.goal_vel = self.scale_action(velocities)
+        if self.velocity_limits is not None:
+            self.goal_vel = np.clip(self.goal_vel, self.velocity_limits[0], self.velocity_limits[1])
+
+        if self.interpolator is not None:
+            self.interpolator.set_goal(self.goal_vel)
+
+    def run_controller(self):
+        """
+        Calculates the torques required to reach the desired setpoint
+
+        Returns:
+             np.array: Command torques
+        """
+        # Make sure goal has been set
+        if self.goal_vel is None:
+            self.set_goal(np.zeros(self.joint_dim))
+
+        # Update state
+        self.update()
+
+        # Only linear interpolator is currently supported
+        if self.interpolator is not None:
+            if self.interpolator.order == 1:
+                # Linear case
+                self.current_vel = self.interpolator.get_interpolated_goal()
+            else:
+                # Nonlinear case not currently supported
+                pass
+        else:
+            self.current_vel = np.array(self.goal_vel)
+
+        # Compute necessary error terms for PID velocity controller
+        err = self.current_vel - self.joint_vel
+        derr = err - self.last_err
+        self.last_err = err
+        self.derr_buf.push(derr)
+
+        # Only add to I component if we're not saturated (anti-windup)
+        if not self.saturated:
+            self.summed_err += err
+
+        # Compute command torques via PID velocity controller plus gravity compensation torques
+        if self.torque_compensation:
+            torques = (
+                self.kp * err + self.ki * self.summed_err + self.kd * self.derr_buf.average + self.torque_compensation
+            )
+        else:
+            torques = self.kp * err + self.ki * self.summed_err + self.kd * self.derr_buf.average
+
+        # Clip torques
+        self.torques = self.clip_torques(torques)
+
+        # Check if we're saturated
+        self.saturated = False if np.sum(np.abs(self.torques - torques)) == 0 else True
+
+        # Always run superclass call for any cleanups at the end
+        super().run_controller()
+
+        # Return final torques
+        return self.torques
+
+    def reset_goal(self):
+        """
+        Resets joint velocity goal to be all zeros
+        """
+        self.goal_vel = np.zeros(self.joint_dim)
+
+        # Reset interpolator if required
+        if self.interpolator is not None:
+            self.interpolator.set_goal(self.goal_vel)
+
+    @property
+    def name(self):
+        return "JOINT_VELOCITY"

robosuite/controllers/parts/gripper/__init__.py

@@ -0,0 +1 @@
+from .simple_grip import SimpleGripController

robosuite/controllers/parts/gripper/gripper_controller.py

@@ -0,0 +1,234 @@
+import abc
+from collections.abc import Iterable
+
+import mujoco
+import numpy as np
+
+import robosuite.macros as macros
+
+
+class GripperController(object, metaclass=abc.ABCMeta):
+    """
+    General controller interface.
+
+    Requires reference to mujoco sim object, relevant joint_indexes to that robot, and
+    whether an initial_joint is used for nullspace torques or not
+
+    Args:
+        sim (MjSim): Simulator instance this controller will pull robot state updates from
+
+        eef_name (str): Name of controlled robot arm's end effector (from robot XML)
+
+        joint_indexes (dict): Each key contains sim reference indexes to relevant robot joint information, namely:
+
+            :`'joints'`: list of indexes to relevant robot joints
+            :`'qpos'`: list of indexes to relevant robot joint positions
+            :`'qvel'`: list of indexes to relevant robot joint velocities
+
+        actuator_range (2-tuple of array of float): 2-Tuple (low, high) representing the robot joint actuator range
+    """
+
+    def __init__(
+        self,
+        sim,
+        joint_indexes,
+        actuator_range,
+        part_name=None,
+        naming_prefix=None,
+    ):
+
+        # Actuator range
+        self.actuator_min = actuator_range[0]
+        self.actuator_max = actuator_range[1]
+
+        # Attributes for scaling / clipping inputs to outputs
+        self.action_scale = None
+        self.action_input_transform = None
+        self.action_output_transform = None
+
+        # Private property attributes
+        self.control_dim = None
+        self.output_min = None
+        self.output_max = None
+        self.input_min = None
+        self.input_max = None
+
+        # mujoco simulator state
+        self.sim = sim
+        self.model_timestep = macros.SIMULATION_TIMESTEP
+        self.part_name = part_name
+        self.naming_prefix = naming_prefix
+
+        self.joint_index = joint_indexes["joints"]
+        self.actuator_index = joint_indexes["actuators"]
+        self.qpos_index = joint_indexes["qpos"]
+        self.qvel_index = joint_indexes["qvel"]
+
+        # robot states
+        self.joint_pos = None
+        self.joint_vel = None
+
+        # Joint dimension
+        self.joint_dim = len(joint_indexes["joints"])
+
+        # Torques being outputted by the controller
+        self.torques = None
+
+        # Update flag to prevent redundant update calls
+        self.new_update = True
+
+        # Move forward one timestep to propagate updates before taking first update
+        self.sim.forward()
+
+        # Initialize controller by updating internal state and setting the initial joint, pos, and ori
+        self.update()
+        self.initial_joint = self.joint_pos
+        self.previous_qpos = None
+
+    @abc.abstractmethod
+    def run_controller(self):
+        """
+        Abstract method that should be implemented in all subclass controllers, and should convert a given action
+        into torques (pre gravity compensation) to be executed on the robot.
+        Additionally, resets the self.new_update flag so that the next self.update call will occur
+        """
+        self.new_update = True
+
+    def scale_action(self, action):
+        """
+        Clips @action to be within self.input_min and self.input_max, and then re-scale the values to be within
+        the range self.output_min and self.output_max
+
+        Args:
+            action (Iterable): Actions to scale
+
+        Returns:
+            np.array: Re-scaled action
+        """
+
+        if self.action_scale is None:
+            self.action_scale = abs(self.output_max - self.output_min) / abs(self.input_max - self.input_min)
+            self.action_output_transform = (self.output_max + self.output_min) / 2.0
+            self.action_input_transform = (self.input_max + self.input_min) / 2.0
+        action = np.clip(action, self.input_min, self.input_max)
+        transformed_action = (action - self.action_input_transform) * self.action_scale + self.action_output_transform
+
+        return transformed_action
+
+    def update(self, force=False):
+        """
+        Updates the state of the robot arm, including end effector pose / orientation / velocity, joint pos/vel,
+        jacobian, and mass matrix. By default, since this is a non-negligible computation, multiple redundant calls
+        will be ignored via the self.new_update attribute flag. However, if the @force flag is set, the update will
+        occur regardless of that state of self.new_update. This base class method of @run_controller resets the
+        self.new_update flag
+
+        Args:
+            force (bool): Whether to force an update to occur or not
+        """
+
+        # Only run update if self.new_update or force flag is set
+        if self.new_update or force:
+
+            self.joint_pos = np.array(self.sim.data.qpos[self.qpos_index])
+            self.joint_vel = np.array(self.sim.data.qvel[self.qvel_index])
+            # Clear self.new_update
+            self.new_update = False
+
+    def update_initial_joints(self, initial_joints):
+        """
+        Updates the internal attribute self.initial_joints. This is useful for updating changes in controller-specific
+        behavior, such as with OSC where self.initial_joints is used for determine nullspace actions
+
+        This function can also be extended by subclassed controllers for additional controller-specific updates
+
+        Args:
+            initial_joints (Iterable): Array of joint position values to update the initial joints
+        """
+        self.initial_joint = np.array(initial_joints)
+        self.update(force=True)
+
+    def clip_torques(self, torques):
+        """
+        Clips the torques to be within the actuator limits
+
+        Args:
+            torques (Iterable): Torques to clip
+
+        Returns:
+            np.array: Clipped torques
+        """
+        return np.clip(torques, self.actuator_min, self.actuator_max)
+
+    def reset_goal(self):
+        """
+        Resets the goal -- usually by setting to the goal to all zeros, but in some cases may be different (e.g.: OSC)
+        """
+        raise NotImplementedError
+
+    @staticmethod
+    def nums2array(nums, dim):
+        """
+        Convert input @nums into numpy array of length @dim. If @nums is a single number, broadcasts it to the
+        corresponding dimension size @dim before converting into a numpy array
+
+        Args:
+            nums (numeric or Iterable): Either single value or array of numbers
+            dim (int): Size of array to broadcast input to env.sim.data.actuator_force
+
+        Returns:
+            np.array: Array filled with values specified in @nums
+        """
+        # First run sanity check to make sure no strings are being inputted
+        if isinstance(nums, str):
+            raise TypeError("Error: Only numeric inputs are supported for this function, nums2array!")
+
+        # Check if input is an Iterable, if so, we simply convert the input to np.array and return
+        # Else, input is a single value, so we map to a numpy array of correct size and return
+        return np.array(nums) if isinstance(nums, Iterable) else np.ones(dim) * nums
+
+    @property
+    def torque_compensation(self):
+        """
+        Gravity compensation for this robot arm
+
+        Returns:
+            np.array: torques
+        """
+        return self.sim.data.qfrc_bias[self.qvel_index]
+
+    @property
+    def actuator_limits(self):
+        """
+        Torque limits for this controller
+
+        Returns:
+            2-tuple:
+
+                - (np.array) minimum actuator torques
+                - (np.array) maximum actuator torques
+        """
+        return self.actuator_min, self.actuator_max
+
+    @property
+    def control_limits(self):
+        """
+        Limits over this controller's action space, which defaults to input min/max
+
+        Returns:
+            2-tuple:
+
+                - (np.array) minimum action values
+                - (np.array) maximum action values
+        """
+        return self.input_min, self.input_max
+
+    @property
+    def name(self):
+        """
+        Name of this controller
+
+        Returns:
+            str: controller name
+        """
+        raise NotImplementedError

robosuite/controllers/parts/gripper/simple_grip.py

@@ -0,0 +1,213 @@
+"""This is a controller that controls the fingers / grippers to do naive gripping. No matter how many fingers the gripper has, they all move in the same direction."""
+
+import numpy as np
+
+from robosuite.controllers.parts.gripper.gripper_controller import GripperController
+from robosuite.utils.control_utils import *
+
+# Supported impedance modes
+
+
+class SimpleGripController(GripperController):
+    """
+    Controller for controlling robot arm via impedance control. Allows position control of the robot's joints.
+
+    NOTE: Control input actions assumed to be taken relative to the current joint positions. A given action to this
+    controller is assumed to be of the form: (dpos_j0, dpos_j1, ... , dpos_jn-1) for an n-joint robot
+
+    Args:
+        sim (MjSim): Simulator instance this controller will pull robot state updates from
+
+        eef_name (str): Name of controlled robot arm's end effector (from robot XML)
+
+        joint_indexes (dict): Each key contains sim reference indexes to relevant robot joint information, namely:
+
+            :`'joints'`: list of indexes to relevant robot joints
+            :`'qpos'`: list of indexes to relevant robot joint positions
+            :`'qvel'`: list of indexes to relevant robot joint velocities
+
+        actuator_range (2-tuple of array of float): 2-Tuple (low, high) representing the robot joint actuator range
+
+        input_max (float or Iterable of float): Maximum above which an inputted action will be clipped. Can be either be
+            a scalar (same value for all action dimensions), or a list (specific values for each dimension). If the
+            latter, dimension should be the same as the control dimension for this controller
+
+        input_min (float or Iterable of float): Minimum below which an inputted action will be clipped. Can be either be
+            a scalar (same value for all action dimensions), or a list (specific values for each dimension). If the
+            latter, dimension should be the same as the control dimension for this controller
+
+        output_max (float or Iterable of float): Maximum which defines upper end of scaling range when scaling an input
+            action. Can be either be a scalar (same value for all action dimensions), or a list (specific values for
+            each dimension). If the latter, dimension should be the same as the control dimension for this controller
+
+        output_min (float or Iterable of float): Minimum which defines upper end of scaling range when scaling an input
+            action. Can be either be a scalar (same value for all action dimensions), or a list (specific values for
+            each dimension). If the latter, dimension should be the same as the control dimension for this controller
+
+        policy_freq (int): Frequency at which actions from the robot policy are fed into this controller
+
+        qpos_limits (2-list of float or 2-list of Iterable of floats): Limits (rad) below and above which the magnitude
+            of a calculated goal joint position will be clipped. Can be either be a 2-list (same min/max value for all
+            joint dims), or a 2-list of list (specific min/max values for each dim)
+
+        interpolator (Interpolator): Interpolator object to be used for interpolating from the current joint position to
+            the goal joint position during each timestep between inputted actions
+
+        **kwargs: Does nothing; placeholder to "sink" any additional arguments so that instantiating this controller
+            via an argument dict that has additional extraneous arguments won't raise an error
+
+    Raises:
+        AssertionError: [Invalid impedance mode]
+    """
+
+    def __init__(
+        self,
+        sim,
+        joint_indexes,
+        actuator_range,
+        input_max=1,
+        input_min=-1,
+        output_max=1,
+        output_min=-1,
+        policy_freq=20,
+        qpos_limits=None,
+        interpolator=None,
+        use_action_scaling=True,
+        **kwargs,  # does nothing; used so no error raised when dict is passed with extra terms used previously
+    ):
+        super().__init__(
+            sim,
+            joint_indexes,
+            actuator_range,
+            part_name=kwargs.get("part_name", None),
+            naming_prefix=kwargs.get("naming_prefix", None),
+        )
+
+        # Control dimension
+        self.control_dim = len(joint_indexes["actuators"])
+
+        # input and output max and min (allow for either explicit lists or single numbers)
+        self.input_max = self.nums2array(input_max, self.control_dim)
+        self.input_min = self.nums2array(input_min, self.control_dim)
+        self.output_max = self.nums2array(output_max, self.control_dim)
+        self.output_min = self.nums2array(output_min, self.control_dim)
+
+        # limits
+        self.position_limits = np.array(qpos_limits) if qpos_limits is not None else qpos_limits
+
+        # control frequency
+        self.control_freq = policy_freq
+
+        # interpolator
+        self.interpolator = interpolator
+
+        # action scaling
+        self.use_action_scaling = use_action_scaling
+
+        # initialize
+        self.goal_qvel = None
+
+    def set_goal(self, action, set_qpos=None):
+        """
+        Sets goal based on input @action. If self.impedance_mode is not "fixed", then the input will be parsed into the
+        delta values to update the goal position / pose and the kp and/or damping_ratio values to be immediately updated
+        internally before executing the proceeding control loop.
+
+        Note that @action expected to be in the following format, based on impedance mode!
+
+            :Mode `'fixed'`: [joint pos command]
+            :Mode `'variable'`: [damping_ratio values, kp values, joint pos command]
+            :Mode `'variable_kp'`: [kp values, joint pos command]
+
+        Args:
+            action (Iterable): Desired relative joint position goal state
+            set_qpos (Iterable): If set, overrides @action and sets the desired absolute joint position goal state
+
+        Raises:
+            AssertionError: [Invalid action dimension size]
+        """
+        # Update state
+        self.update()
+
+        # Parse action based on the impedance mode, and update kp / kd as necessary
+        delta = action
+
+        # Check to make sure delta is size self.joint_dim
+        assert len(delta) == self.control_dim, (
+            f"Delta qpos must be equal to the control dimension of the robot!"
+            f"Expected {self.control_dim}, got {len(delta)}"
+        )
+
+        scaled_delta = delta
+        if self.use_action_scaling:
+            scaled_delta = self.scale_action(delta)
+
+        self.goal_qvel = scaled_delta
+
+        if self.interpolator is not None:
+            self.interpolator.set_goal(self.goal_qvel)
+
+    def run_controller(self):
+        """
+        Calculates the torques required to reach the desired setpoint
+
+        Returns:
+             np.array: Command torques
+        """
+        # Make sure goal has been set
+        if self.goal_qvel is None:
+            self.set_goal(np.zeros(self.control_dim))
+
+        # Update state
+        self.update()
+
+        desired_qvel = None
+
+        # Only linear interpolator is currently supported
+        if self.interpolator is not None:
+            # Linear case
+            if self.interpolator.order == 1:
+                desired_qvel = self.interpolator.get_interpolated_goal()
+            else:
+                # Nonlinear case not currently supported
+                pass
+        else:
+            desired_qvel = np.array(self.goal_qvel)
+
+        self.vels = desired_qvel
+        if self.use_action_scaling:
+            ctrl_range = np.stack([self.actuator_min, self.actuator_max], axis=-1)
+            bias = 0.5 * (ctrl_range[:, 1] + ctrl_range[:, 0])
+            weight = 0.5 * (ctrl_range[:, 1] - ctrl_range[:, 0])
+            self.vels = bias + weight * desired_qvel
+
+        # Always run superclass call for any cleanups at the end
+        super().run_controller()
+        return self.vels
+
+    def reset_goal(self):
+        """
+        Resets joint position goal to be current position
+        """
+        self.goal_qvel = self.joint_vel
+
+        # Reset interpolator if required
+        if self.interpolator is not None:
+            self.interpolator.set_goal(self.goal_qvel)
+
+    @property
+    def control_limits(self):
+        """
+        Returns the limits over this controller's action space, overrides the superclass property
+        Returns the following (generalized for both high and low limits), based on the impedance mode:
+        Returns:
+            2-tuple:
+
+                - (np.array) minimum action values
+                - (np.array) maximum action values
+        """
+        return self.input_min, self.input_max
+
+    @property
+    def name(self):
+        return "JOINT_VELOCITY"

robosuite/controllers/parts/mobile_base/__init__.py

@@ -0,0 +1 @@
+from .joint_vel import MobileBaseJointVelocityController, LegacyMobileBaseJointVelocityController

robosuite/controllers/parts/mobile_base/joint_vel.py

@@ -0,0 +1,383 @@
+import numpy as np
+
+import robosuite.utils.transform_utils as T
+from robosuite.controllers.parts.mobile_base.mobile_base_controller import MobileBaseController
+from robosuite.utils.control_utils import *
+
+# Supported impedance modes
+IMPEDANCE_MODES = {"fixed", "variable", "variable_kp"}
+
+
+class MobileBaseJointVelocityController(MobileBaseController):
+    """
+    Controller for controlling robot arm via impedance control. Allows position control of the robot's joints.
+
+    NOTE: Control input actions assumed to be taken relative to the current joint positions. A given action to this
+    controller is assumed to be of the form: (dpos_j0, dpos_j1, ... , dpos_jn-1) for an n-joint robot
+
+    Args:
+        sim (MjSim): Simulator instance this controller will pull robot state updates from
+
+        joint_indexes (dict): Each key contains sim reference indexes to relevant robot joint information, namely:
+
+            :`'joints'`: list of indexes to relevant robot joints
+            :`'qpos'`: list of indexes to relevant robot joint positions
+            :`'qvel'`: list of indexes to relevant robot joint velocities
+
+        actuator_range (2-tuple of array of float): 2-Tuple (low, high) representing the robot joint actuator range
+
+        input_max (float or Iterable of float): Maximum above which an inputted action will be clipped. Can be either be
+            a scalar (same value for all action dimensions), or a list (specific values for each dimension). If the
+            latter, dimension should be the same as the control dimension for this controller
+
+        input_min (float or Iterable of float): Minimum below which an inputted action will be clipped. Can be either be
+            a scalar (same value for all action dimensions), or a list (specific values for each dimension). If the
+            latter, dimension should be the same as the control dimension for this controller
+
+        output_max (float or Iterable of float): Maximum which defines upper end of scaling range when scaling an input
+            action. Can be either be a scalar (same value for all action dimensions), or a list (specific values for
+            each dimension). If the latter, dimension should be the same as the control dimension for this controller
+
+        output_min (float or Iterable of float): Minimum which defines upper end of scaling range when scaling an input
+            action. Can be either be a scalar (same value for all action dimensions), or a list (specific values for
+            each dimension). If the latter, dimension should be the same as the control dimension for this controller
+
+        kp (float or Iterable of float): positional gain for determining desired torques based upon the joint pos error.
+            Can be either be a scalar (same value for all action dims), or a list (specific values for each dim)
+
+        damping_ratio (float or Iterable of float): used in conjunction with kp to determine the velocity gain for
+            determining desired torques based upon the joint pos errors. Can be either be a scalar (same value for all
+            action dims), or a list (specific values for each dim)
+
+        impedance_mode (str): Impedance mode with which to run this controller. Options are {"fixed", "variable",
+            "variable_kp"}. If "fixed", the controller will have fixed kp and damping_ratio values as specified by the
+            @kp and @damping_ratio arguments. If "variable", both kp and damping_ratio will now be part of the
+            controller action space, resulting in a total action space of num_joints * 3. If "variable_kp", only kp
+            will become variable, with damping_ratio fixed at 1 (critically damped). The resulting action space will
+            then be num_joints * 2.
+
+        kp_limits (2-list of float or 2-list of Iterable of floats): Only applicable if @impedance_mode is set to either
+            "variable" or "variable_kp". This sets the corresponding min / max ranges of the controller action space
+            for the varying kp values. Can be either be a 2-list (same min / max for all kp action dims), or a 2-list
+            of list (specific min / max for each kp dim)
+
+        damping_ratio_limits (2-list of float or 2-list of Iterable of floats): Only applicable if @impedance_mode is
+            set to "variable". This sets the corresponding min / max ranges of the controller action space for the
+            varying damping_ratio values. Can be either be a 2-list (same min / max for all damping_ratio action dims),
+            or a 2-list of list (specific min / max for each damping_ratio dim)
+
+        policy_freq (int): Frequency at which actions from the robot policy are fed into this controller
+
+        qpos_limits (2-list of float or 2-list of Iterable of floats): Limits (rad) below and above which the magnitude
+            of a calculated goal joint position will be clipped. Can be either be a 2-list (same min/max value for all
+            joint dims), or a 2-list of list (specific min/max values for each dim)
+
+        interpolator (Interpolator): Interpolator object to be used for interpolating from the current joint position to
+            the goal joint position during each timestep between inputted actions
+
+        **kwargs: Does nothing; placeholder to "sink" any additional arguments so that instantiating this controller
+            via an argument dict that has additional extraneous arguments won't raise an error
+
+    Raises:
+        AssertionError: [Invalid impedance mode]
+    """
+
+    def __init__(
+        self,
+        sim,
+        joint_indexes,
+        actuator_range,
+        input_max=1,
+        input_min=-1,
+        output_max=1,
+        output_min=-1,
+        kp=50,
+        damping_ratio=1,
+        impedance_mode="fixed",
+        kp_limits=(0, 300),
+        damping_ratio_limits=(0, 100),
+        policy_freq=20,
+        qpos_limits=None,
+        interpolator=None,
+        **kwargs,  # does nothing; used so no error raised when dict is passed with extra terms used previously
+    ):
+        super().__init__(
+            sim,
+            joint_indexes,
+            actuator_range,
+            naming_prefix=kwargs.get("naming_prefix", None),
+        )
+
+        # Control dimension
+        self.control_dim = len(joint_indexes["joints"])
+
+        # input and output max and min (allow for either explicit lists or single numbers)
+        self.input_max = self.nums2array(input_max, self.control_dim)
+        self.input_min = self.nums2array(input_min, self.control_dim)
+        self.output_max = self.nums2array(output_max, self.control_dim)
+        self.output_min = self.nums2array(output_min, self.control_dim)
+
+        # limits
+        self.position_limits = np.array(qpos_limits) if qpos_limits is not None else qpos_limits
+
+        # kp kd
+        self.kp = self.nums2array(kp, self.control_dim)
+        self.kd = 2 * np.sqrt(self.kp) * damping_ratio
+
+        # kp and kd limits
+        self.kp_min = self.nums2array(kp_limits[0], self.control_dim)
+        self.kp_max = self.nums2array(kp_limits[1], self.control_dim)
+        self.damping_ratio_min = self.nums2array(damping_ratio_limits[0], self.control_dim)
+        self.damping_ratio_max = self.nums2array(damping_ratio_limits[1], self.control_dim)
+
+        # Verify the proposed impedance mode is supported
+        assert impedance_mode in IMPEDANCE_MODES, (
+            "Error: Tried to instantiate OSC controller for unsupported "
+            "impedance mode! Inputted impedance mode: {}, Supported modes: {}".format(impedance_mode, IMPEDANCE_MODES)
+        )
+
+        # Impedance mode
+        self.impedance_mode = impedance_mode
+
+        # Add to control dim based on impedance_mode
+        if self.impedance_mode == "variable":
+            self.control_dim *= 3
+        elif self.impedance_mode == "variable_kp":
+            self.control_dim *= 2
+
+        # control frequency
+        self.control_freq = policy_freq
+
+        # interpolator
+        self.interpolator = interpolator
+
+        # initialize
+        self.goal_qvel = None
+        self.init_pos = None
+        self.init_ori = None
+
+    def set_goal(self, action, set_qpos=None):
+        """
+        Sets goal based on input @action. If self.impedance_mode is not "fixed", then the input will be parsed into the
+        delta values to update the goal position / pose and the kp and/or damping_ratio values to be immediately updated
+        internally before executing the proceeding control loop.
+
+        Note that @action expected to be in the following format, based on impedance mode!
+
+            :Mode `'fixed'`: [joint pos command]
+            :Mode `'variable'`: [damping_ratio values, kp values, joint pos command]
+            :Mode `'variable_kp'`: [kp values, joint pos command]
+
+        Args:
+            action (Iterable): Desired relative joint position goal state
+            set_qpos (Iterable): If set, overrides @action and sets the desired absolute joint position goal state
+
+        Raises:
+            AssertionError: [Invalid action dimension size]
+        """
+        # Update state
+        self.update()
+
+        # Parse action based on the impedance mode, and update kp / kd as necessary
+        jnt_dim = len(self.qpos_index)
+        if self.impedance_mode == "variable":
+            damping_ratio, kp, delta = action[:jnt_dim], action[jnt_dim : 2 * jnt_dim], action[2 * jnt_dim :]
+            self.kp = np.clip(kp, self.kp_min, self.kp_max)
+            self.kd = 2 * np.sqrt(self.kp) * np.clip(damping_ratio, self.damping_ratio_min, self.damping_ratio_max)
+        elif self.impedance_mode == "variable_kp":
+            kp, delta = action[:jnt_dim], action[jnt_dim:]
+            self.kp = np.clip(kp, self.kp_min, self.kp_max)
+            self.kd = 2 * np.sqrt(self.kp)  # critically damped
+        else:  # This is case "fixed"
+            delta = action
+
+        # Check to make sure delta is size self.joint_dim
+        assert len(delta) == jnt_dim, "Delta qpos must be equal to the robot's joint dimension space!"
+
+        if delta is not None:
+            scaled_delta = self.scale_action(delta)
+        else:
+            scaled_delta = None
+
+        curr_pos, curr_ori = self.get_base_pose()
+
+        # transform the action relative to initial base orientation
+        init_theta = T.mat2euler(self.init_ori)[2]  # np.arctan2(self.init_pos[1], self.init_pos[0])
+        curr_theta = T.mat2euler(curr_ori)[2]  # np.arctan2(curr_pos[1], curr_pos[0])
+        theta = curr_theta - init_theta
+
+        # input raw base action is delta relative to current pose of base
+        # controller expects deltas relative to initial pose of base at start of episode
+        # transform deltas from current base pose coordinates to initial base pose coordinates
+        x, y = action[0:2]
+
+        # do the reverse of theta rotation
+        action[0] = x * np.cos(theta) + y * np.sin(theta)
+        action[1] = -x * np.sin(theta) + y * np.cos(theta)
+
+        self.goal_qvel = action
+        if self.interpolator is not None:
+            self.interpolator.set_goal(self.goal_qvel)
+
+    def run_controller(self):
+        """
+        Calculates the torques required to reach the desired setpoint
+
+        Returns:
+             np.array: Command torques
+        """
+        # Make sure goal has been set
+        if self.goal_qvel is None:
+            self.set_goal(np.zeros(self.control_dim))
+
+        # Update state
+        self.update()
+
+        desired_qvel = None
+
+        # Only linear interpolator is currently supported
+        if self.interpolator is not None:
+            # Linear case
+            if self.interpolator.order == 1:
+                desired_qvel = self.interpolator.get_interpolated_goal()
+            else:
+                # Nonlinear case not currently supported
+                pass
+        else:
+            desired_qvel = np.array(self.goal_qvel)
+
+        self.vels = desired_qvel
+
+        ctrl_range = np.stack([self.actuator_min, self.actuator_max], axis=-1)
+        bias = 0.5 * (ctrl_range[:, 1] + ctrl_range[:, 0])
+        weight = 0.5 * (ctrl_range[:, 1] - ctrl_range[:, 0])
+        self.vels = bias + weight * self.vels
+
+        # Always run superclass call for any cleanups at the end
+        super().run_controller()
+
+        return self.vels
+
+    def reset_goal(self):
+        """
+        Resets joint position goal to be current position
+        """
+        self.goal_qvel = self.joint_vel
+
+        self.init_pos, self.init_ori = self.get_base_pose()
+
+        # Reset interpolator if required
+        if self.interpolator is not None:
+            self.interpolator.set_goal(self.goal_qvel)
+
+    @property
+    def control_limits(self):
+        """
+        Returns the limits over this controller's action space, overrides the superclass property
+        Returns the following (generalized for both high and low limits), based on the impedance mode:
+
+            :Mode `'fixed'`: [joint pos command]
+            :Mode `'variable'`: [damping_ratio values, kp values, joint pos command]
+            :Mode `'variable_kp'`: [kp values, joint pos command]
+
+        Returns:
+            2-tuple:
+
+                - (np.array) minimum action values
+                - (np.array) maximum action values
+        """
+        if self.impedance_mode == "variable":
+            low = np.concatenate([self.damping_ratio_min, self.kp_min, self.input_min])
+            high = np.concatenate([self.damping_ratio_max, self.kp_max, self.input_max])
+        elif self.impedance_mode == "variable_kp":
+            low = np.concatenate([self.kp_min, self.input_min])
+            high = np.concatenate([self.kp_max, self.input_max])
+        else:  # This is case "fixed"
+            low, high = self.input_min, self.input_max
+        return low, high
+
+    @property
+    def name(self):
+        return "JOINT_VELOCITY"
+
+
+class LegacyMobileBaseJointVelocityController(MobileBaseJointVelocityController):
+    """
+    Legacy version of MobileBaseJointVelocityController, created to address
+    the recent change in the axis of the forward joint in the mobile base xml.
+    This controller is identical to the original MobileBaseJointVelocityController,
+    except that it dynamically checks the axis of the forward joint and reorders
+    the input action accordingly if the forward axis is the y axis instead of the x axis.
+    This allows for backwards compatibility with previously collected datasets
+    that were generated using older versions of the mobile base xml.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def _check_forward_joint_reversed(self):
+        # Detect the axis for the forward joint and dynamically reorder action accordingly.
+        # This is needed because previous versions of the mobile base xml had different forward
+        # axis definitions. In order to maintain backwards compatibility with previous datasets
+        # we dynamically detect the forward joint axis.
+        forward_jnt = None
+        forward_jnt_axis = None
+        for jnt in self.joint_names:
+            if "joint_mobile_forward" in jnt:
+                forward_jnt = jnt
+                forward_jnt_axis = self.sim.model.jnt_axis[self.sim.model.joint_name2id(jnt)]
+                break
+        return forward_jnt is not None and (forward_jnt_axis == np.array([0, 1, 0])).all()
+
+    def set_goal(self, action, set_qpos=None):
+        # Update state
+        self.update()
+
+        # Parse action based on the impedance mode, and update kp / kd as necessary
+        jnt_dim = len(self.qpos_index)
+        if self.impedance_mode == "variable":
+            damping_ratio, kp, delta = action[:jnt_dim], action[jnt_dim : 2 * jnt_dim], action[2 * jnt_dim :]
+            self.kp = np.clip(kp, self.kp_min, self.kp_max)
+            self.kd = 2 * np.sqrt(self.kp) * np.clip(damping_ratio, self.damping_ratio_min, self.damping_ratio_max)
+        elif self.impedance_mode == "variable_kp":
+            kp, delta = action[:jnt_dim], action[jnt_dim:]
+            self.kp = np.clip(kp, self.kp_min, self.kp_max)
+            self.kd = 2 * np.sqrt(self.kp)  # critically damped
+        else:  # This is case "fixed"
+            delta = action
+
+        # Check to make sure delta is size self.joint_dim
+        assert len(delta) == jnt_dim, "Delta qpos must be equal to the robot's joint dimension space!"
+
+        if delta is not None:
+            scaled_delta = self.scale_action(delta)
+        else:
+            scaled_delta = None
+
+        curr_pos, curr_ori = self.get_base_pose()
+
+        # transform the action relative to initial base orientation
+        init_theta = T.mat2euler(self.init_ori)[2]  # np.arctan2(self.init_pos[1], self.init_pos[0])
+        curr_theta = T.mat2euler(curr_ori)[2]  # np.arctan2(curr_pos[1], curr_pos[0])
+        theta = curr_theta - init_theta
+
+        # reorder action if forward axis is y axis
+        if self._check_forward_joint_reversed():
+            action = np.copy([action[i] for i in [1, 0, 2]])
+
+            x, y = action[0:2]
+            # do the reverse of theta rotation
+            action[0] = x * np.cos(theta) + y * np.sin(theta)
+            action[1] = -x * np.sin(theta) + y * np.cos(theta)
+        else:
+            # input raw base action is delta relative to current pose of base
+            # controller expects deltas relative to initial pose of base at start of episode
+            # transform deltas from current base pose coordinates to initial base pose coordinates
+            action = action.copy()
+            x, y = action[0:2]
+            action[0] = x * np.cos(theta) - y * np.sin(theta)
+            action[1] = x * np.sin(theta) + y * np.cos(theta)
+
+        self.goal_qvel = action
+        if self.interpolator is not None:
+            self.interpolator.set_goal(self.goal_qvel)

robosuite/controllers/parts/mobile_base/mobile_base_controller.py

@@ -0,0 +1,249 @@
+import abc
+from collections.abc import Iterable
+
+import mujoco
+import numpy as np
+
+import robosuite.macros as macros
+
+
+class MobileBaseController(object, metaclass=abc.ABCMeta):
+    """
+    General controller interface.
+
+    Requires reference to mujoco sim object, relevant joint_indexes to that robot, and
+    whether an initial_joint is used for nullspace torques or not
+
+    Args:
+        sim (MjSim): Simulator instance this controller will pull robot state updates from
+
+        joint_indexes (dict): Each key contains sim reference indexes to relevant robot joint information, namely:
+
+            :`'joints'`: list of indexes to relevant robot joints
+            :`'qpos'`: list of indexes to relevant robot joint positions
+            :`'qvel'`: list of indexes to relevant robot joint velocities
+
+        actuator_range (2-tuple of array of float): 2-Tuple (low, high) representing the robot joint actuator range
+    """
+
+    def __init__(
+        self,
+        sim,
+        joint_indexes,
+        actuator_range,
+        naming_prefix=None,
+    ):
+
+        # Actuator range
+        self.actuator_min = actuator_range[0]
+        self.actuator_max = actuator_range[1]
+
+        # Attributes for scaling / clipping inputs to outputs
+        self.action_scale = None
+        self.action_input_transform = None
+        self.action_output_transform = None
+
+        # Private property attributes
+        self.control_dim = None
+        self.output_min = None
+        self.output_max = None
+        self.input_min = None
+        self.input_max = None
+
+        # mujoco simulator state
+        self.sim = sim
+        self.model_timestep = macros.SIMULATION_TIMESTEP
+        self.naming_prefix = naming_prefix
+
+        self.joint_index = joint_indexes["joints"]
+        self.qpos_index = joint_indexes["qpos"]
+        self.qvel_index = joint_indexes["qvel"]
+        self.joint_names = [self.sim.model.joint_id2name(joint_id) for joint_id in self.joint_index]
+
+        # robot states
+        self.joint_pos = None
+        self.joint_vel = None
+
+        # Joint dimension
+        self.joint_dim = len(joint_indexes["joints"])
+
+        # Torques being outputted by the controller
+        self.torques = None
+
+        # Update flag to prevent redundant update calls
+        self.new_update = True
+
+        # Move forward one timestep to propagate updates before taking first update
+        self.sim.forward()
+
+        # Initialize controller by updating internal state and setting the initial joint, pos, and ori
+        self.update()
+        self.initial_joint = self.joint_pos
+
+        self.base_pos = None
+        self.base_ori_mat = None
+
+        self.init_pos = None
+        self.init_ori = None
+
+    def get_base_pose(self):
+        base_pos = np.array(self.sim.data.site_xpos[self.sim.model.site_name2id(f"{self.naming_prefix}center")])
+        base_ori = np.array(
+            self.sim.data.site_xmat[self.sim.model.site_name2id(f"{self.naming_prefix}center")].reshape([3, 3])
+        )
+        return base_pos, base_ori
+
+    def reset(self):
+        self.init_pos = self.base_pos
+        self.init_ori = self.base_ori_mat
+
+    @abc.abstractmethod
+    def run_controller(self):
+        """
+        Abstract method that should be implemented in all subclass controllers, and should convert a given action
+        into torques (pre gravity compensation) to be executed on the robot.
+        Additionally, resets the self.new_update flag so that the next self.update call will occur
+        """
+        self.new_update = True
+
+    def scale_action(self, action):
+        """
+        Clips @action to be within self.input_min and self.input_max, and then re-scale the values to be within
+        the range self.output_min and self.output_max
+
+        Args:
+            action (Iterable): Actions to scale
+
+        Returns:
+            np.array: Re-scaled action
+        """
+
+        if self.action_scale is None:
+            self.action_scale = abs(self.output_max - self.output_min) / abs(self.input_max - self.input_min)
+            self.action_output_transform = (self.output_max + self.output_min) / 2.0
+            self.action_input_transform = (self.input_max + self.input_min) / 2.0
+        action = np.clip(action, self.input_min, self.input_max)
+        transformed_action = (action - self.action_input_transform) * self.action_scale + self.action_output_transform
+
+        return transformed_action
+
+    def update(self, force=False):
+        """
+        Updates the state of the robot arm, including end effector pose / orientation / velocity, joint pos/vel,
+        jacobian, and mass matrix. By default, since this is a non-negligible computation, multiple redundant calls
+        will be ignored via the self.new_update attribute flag. However, if the @force flag is set, the update will
+        occur regardless of that state of self.new_update. This base class method of @run_controller resets the
+        self.new_update flag
+
+        Args:
+            force (bool): Whether to force an update to occur or not
+        """
+
+        # Only run update if self.new_update or force flag is set
+        if self.new_update or force:
+
+            self.joint_pos = np.array(self.sim.data.qpos[self.qpos_index])
+            self.joint_vel = np.array(self.sim.data.qvel[self.qvel_index])
+
+            # Clear self.new_update
+            self.new_update = False
+
+    def update_initial_joints(self, initial_joints):
+        """
+        Updates the internal attribute self.initial_joints. This is useful for updating changes in controller-specific
+        behavior, such as with OSC where self.initial_joints is used for determine nullspace actions
+
+        This function can also be extended by subclassed controllers for additional controller-specific updates
+
+        Args:
+            initial_joints (Iterable): Array of joint position values to update the initial joints
+        """
+        self.initial_joint = np.array(initial_joints)
+        self.update(force=True)
+        self.initial_ref_pos = self.ref_pos
+        self.initial_ref_ori_mat = self.ref_ori_mat
+
+    def clip_torques(self, torques):
+        """
+        Clips the torques to be within the actuator limits
+
+        Args:
+            torques (Iterable): Torques to clip
+
+        Returns:
+            np.array: Clipped torques
+        """
+        return np.clip(torques, self.actuator_min, self.actuator_max)
+
+    def reset_goal(self):
+        """
+        Resets the goal -- usually by setting to the goal to all zeros, but in some cases may be different (e.g.: OSC)
+        """
+        raise NotImplementedError
+
+    @staticmethod
+    def nums2array(nums, dim):
+        """
+        Convert input @nums into numpy array of length @dim. If @nums is a single number, broadcasts it to the
+        corresponding dimension size @dim before converting into a numpy array
+
+        Args:
+            nums (numeric or Iterable): Either single value or array of numbers
+            dim (int): Size of array to broadcast input to env.sim.data.actuator_force
+
+        Returns:
+            np.array: Array filled with values specified in @nums
+        """
+        # First run sanity check to make sure no strings are being inputted
+        if isinstance(nums, str):
+            raise TypeError("Error: Only numeric inputs are supported for this function, nums2array!")
+
+        # Check if input is an Iterable, if so, we simply convert the input to np.array and return
+        # Else, input is a single value, so we map to a numpy array of correct size and return
+        return np.array(nums) if isinstance(nums, Iterable) else np.ones(dim) * nums
+
+    @property
+    def torque_compensation(self):
+        """
+        Gravity compensation for this robot arm
+
+        Returns:
+            np.array: torques
+        """
+        return self.sim.data.qfrc_bias[self.qvel_index]
+
+    @property
+    def actuator_limits(self):
+        """
+        Torque limits for this controller
+
+        Returns:
+            2-tuple:
+
+                - (np.array) minimum actuator torques
+                - (np.array) maximum actuator torques
+        """
+        return self.actuator_min, self.actuator_max
+
+    @property
+    def control_limits(self):
+        """
+        Limits over this controller's action space, which defaults to input min/max
+
+        Returns:
+            2-tuple:
+
+                - (np.array) minimum action values
+                - (np.array) maximum action values
+        """
+        return self.input_min, self.input_max
+
+    @property
+    def name(self):
+        """
+        Name of this controller
+
+        Returns:
+            str: controller name
+        """
+        raise NotImplementedError

robosuite/demos/demo_collect_and_playback_data.py

@@ -0,0 +1,132 @@
+"""
+Record trajectory data with the DataCollectionWrapper wrapper and play them back.
+
+Example:
+    $ python demo_collect_and_playback_data.py --environment Lift
+"""
+
+import argparse
+import os
+import time
+from glob import glob
+
+import numpy as np
+
+import robosuite as suite
+from robosuite.wrappers import DataCollectionWrapper
+
+
+def collect_random_trajectory(env, timesteps=1000, max_fr=None):
+    """Run a random policy to collect trajectories.
+
+    The rollout trajectory is saved to files in npz format.
+    Modify the DataCollectionWrapper wrapper to add new fields or change data formats.
+
+    Args:
+        env (MujocoEnv): environment instance to collect trajectories from
+        timesteps(int): how many environment timesteps to run for a given trajectory
+        max_fr (int): if specified, pause the simulation whenever simulation runs faster than max_fr
+    """
+
+    env.reset()
+    dof = env.action_dim
+
+    for t in range(timesteps):
+        start = time.time()
+        action = np.random.randn(dof)
+        env.step(action)
+        env.render()
+        if t % 100 == 0:
+            print(t)
+
+        # limit frame rate if necessary
+        if max_fr is not None:
+            elapsed = time.time() - start
+            diff = 1 / max_fr - elapsed
+            if diff > 0:
+                time.sleep(diff)
+
+
+def playback_trajectory(env, ep_dir, max_fr=None):
+    """Playback data from an episode.
+
+    Args:
+        env (MujocoEnv): environment instance to playback trajectory in
+        ep_dir (str): The path to the directory containing data for an episode.
+    """
+
+    # first reload the model from the xml
+    xml_path = os.path.join(ep_dir, "model.xml")
+    with open(xml_path, "r") as f:
+        env.reset_from_xml_string(f.read())
+
+    state_paths = os.path.join(ep_dir, "state_*.npz")
+
+    # read states back, load them one by one, and render
+    t = 0
+    for state_file in sorted(glob(state_paths)):
+        print(state_file)
+        dic = np.load(state_file)
+        states = dic["states"]
+        for state in states:
+            start = time.time()
+            env.sim.set_state_from_flattened(state)
+            env.sim.forward()
+            env.viewer.update()
+            env.render()
+            t += 1
+            if t % 100 == 0:
+                print(t)
+
+            if max_fr is not None:
+                elapsed = time.time() - start
+                diff = 1 / max_fr - elapsed
+                if diff > 0:
+                    time.sleep(diff)
+    env.close()
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--environment", type=str, default="Door")
+    parser.add_argument("--robots", nargs="+", type=str, default="Panda", help="Which robot(s) to use in the env")
+    parser.add_argument("--directory", type=str, default="/tmp/")
+    parser.add_argument("--timesteps", type=int, default=1000)
+    parser.add_argument(
+        "--max_fr",
+        default=20,
+        type=int,
+        help="Sleep when simluation runs faster than specified frame rate; 20 fps is real time.",
+    )
+    args = parser.parse_args()
+
+    # create original environment
+    env = suite.make(
+        args.environment,
+        robots=args.robots,
+        ignore_done=True,
+        use_camera_obs=False,
+        has_renderer=True,
+        has_offscreen_renderer=False,
+        control_freq=20,
+    )
+    data_directory = args.directory
+
+    # wrap the environment with data collection wrapper
+    env = DataCollectionWrapper(env, data_directory)
+
+    # testing to make sure multiple env.reset calls don't create multiple directories
+    env.reset()
+    env.reset()
+    env.reset()
+
+    # collect some data
+    print("Collecting some random data...")
+    collect_random_trajectory(env, timesteps=args.timesteps, max_fr=args.max_fr)
+
+    # playback some data
+    _ = input("Press any key to begin the playback...")
+    print("Playing back the data...")
+    data_directory = env.ep_directory
+    playback_trajectory(env, data_directory, args.max_fr)

robosuite/demos/demo_composite_robot.py

@@ -0,0 +1,85 @@
+import argparse
+import time
+from typing import Dict, List, Union
+
+import numpy as np
+
+import robosuite as suite
+from robosuite.controllers import load_composite_controller_config
+from robosuite.robots import ROBOT_CLASS_MAPPING
+from robosuite.utils.robot_composition_utils import create_composite_robot
+
+
+def create_and_test_env(
+    env: str,
+    robots: Union[str, List[str]],
+    controller_config: Dict,
+    headless: bool = False,
+    max_fr: int = None,
+):
+
+    config = {
+        "env_name": env,
+        "robots": robots,
+        "controller_configs": controller_config,
+    }
+
+    env = suite.make(
+        **config,
+        has_renderer=not headless,
+        has_offscreen_renderer=headless,
+        ignore_done=True,
+        use_camera_obs=False,
+        reward_shaping=True,
+        control_freq=20,
+    )
+    env.reset()
+    low, high = env.action_spec
+    low = np.clip(low, -1, 1)
+    high = np.clip(high, -1, 1)
+
+    # Runs a few steps of the simulation as a sanity check
+    for i in range(100):
+        start = time.time()
+
+        action = np.random.uniform(low, high)
+        obs, reward, done, _ = env.step(action)
+
+        # limit frame rate if necessary
+        if max_fr is not None:
+            elapsed = time.time() - start
+            diff = 1 / max_fr - elapsed
+            if diff > 0:
+                time.sleep(diff)
+
+    env.close()
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--robot", type=str, required=True)
+    parser.add_argument("--base", type=str, default=None)
+    parser.add_argument("--grippers", nargs="+", type=str, default=["PandaGripper"])
+    parser.add_argument("--env", type=str, default="Lift")
+    parser.add_argument("--headless", action="store_true")
+    parser.add_argument(
+        "--max_fr",
+        default=20,
+        type=int,
+        help="Sleep when simluation runs faster than specified frame rate; 20 fps is real time.",
+    )
+
+    args = parser.parse_args()
+
+    if args.robot not in ROBOT_CLASS_MAPPING:
+        raise ValueError(f"Robot {args.robot} not found in ROBOT_CLASS_MAPPING \n" f"{ROBOT_CLASS_MAPPING.keys()}")
+
+    name = f"Custom{args.robot}"
+    create_composite_robot(name, base=args.base, robot=args.robot, grippers=args.grippers)
+    controller_config = load_composite_controller_config(controller="BASIC", robot=name)
+
+    create_and_test_env(
+        env="Lift", robots=name, controller_config=controller_config, headless=args.headless, max_fr=args.max_fr
+    )

robosuite/demos/demo_control.py

@@ -0,0 +1,185 @@
+"""
+This demo script demonstrates the various functionalities of each controller available within robosuite.
+
+For a given controller, runs through each dimension and executes a perturbation "test_value" from its
+neutral (stationary) value for a certain amount of time "steps_per_action", and then returns to all neutral values
+for time "steps_per_rest" before proceeding with the next action dim.
+
+    E.g.: Given that the expected action space of the Pos / Ori (OSC_POSE) controller (without a gripper) is
+    (dx, dy, dz, droll, dpitch, dyaw), the testing sequence of actions over time will be:
+
+        ***START OF DEMO***
+        ( dx,  0,  0,  0,  0,  0, grip)     <-- Translation in x-direction      for 'steps_per_action' steps
+        (  0,  0,  0,  0,  0,  0, grip)     <-- No movement (pause)             for 'steps_per_rest' steps
+        (  0, dy,  0,  0,  0,  0, grip)     <-- Translation in y-direction      for 'steps_per_action' steps
+        (  0,  0,  0,  0,  0,  0, grip)     <-- No movement (pause)             for 'steps_per_rest' steps
+        (  0,  0, dz,  0,  0,  0, grip)     <-- Translation in z-direction      for 'steps_per_action' steps
+        (  0,  0,  0,  0,  0,  0, grip)     <-- No movement (pause)             for 'steps_per_rest' steps
+        (  0,  0,  0, dr,  0,  0, grip)     <-- Rotation in roll (x) axis       for 'steps_per_action' steps
+        (  0,  0,  0,  0,  0,  0, grip)     <-- No movement (pause)             for 'steps_per_rest' steps
+        (  0,  0,  0,  0, dp,  0, grip)     <-- Rotation in pitch (y) axis      for 'steps_per_action' steps
+        (  0,  0,  0,  0,  0,  0, grip)     <-- No movement (pause)             for 'steps_per_rest' steps
+        (  0,  0,  0,  0,  0, dy, grip)     <-- Rotation in yaw (z) axis        for 'steps_per_action' steps
+        (  0,  0,  0,  0,  0,  0, grip)     <-- No movement (pause)             for 'steps_per_rest' steps
+        ***END OF DEMO***
+
+    Thus the OSC_POSE controller should be expected to sequentially move linearly in the x direction first,
+        then the y direction, then the z direction, and then begin sequentially rotating about its x-axis,
+        then y-axis, then z-axis.
+
+Please reference the documentation of Controllers in the Modules section for an overview of each controller.
+Controllers are expected to behave in a generally controlled manner, according to their control space. The expected
+sequential qualitative behavior during the test is described below for each controller:
+
+* OSC_POSE: Gripper moves sequentially and linearly in x, y, z direction, then sequentially rotates in x-axis, y-axis,
+            z-axis, relative to the global coordinate frame
+* OSC_POSITION: Gripper moves sequentially and linearly in x, y, z direction, relative to the global coordinate frame
+* IK_POSE: Gripper moves sequentially and linearly in x, y, z direction, then sequentially rotates in x-axis, y-axis,
+            z-axis, relative to the local robot end effector frame
+* JOINT_POSITION: Robot Joints move sequentially in a controlled fashion
+* JOINT_VELOCITY: Robot Joints move sequentially in a controlled fashion
+* JOINT_TORQUE: Unlike other controllers, joint torque controller is expected to act rather lethargic, as the
+            "controller" is really just a wrapper for direct torque control of the mujoco actuators. Therefore, a
+            "neutral" value of 0 torque will not guarantee a stable robot when it has non-zero velocity!
+
+"""
+
+import time
+from typing import Dict
+
+import robosuite as suite
+from robosuite.controllers.composite.composite_controller_factory import refactor_composite_controller_config
+from robosuite.utils.input_utils import *
+
+MAX_FR = 25  # max frame rate for running simluation
+
+if __name__ == "__main__":
+
+    # Create dict to hold options that will be passed to env creation call
+    options = {}
+
+    # print welcome info
+    print("Welcome to robosuite v{}!".format(suite.__version__))
+    print(suite.__logo__)
+
+    # Choose environment and add it to options
+    options["env_name"] = choose_environment()
+
+    # If a multi-arm environment has been chosen, choose configuration and appropriate robot(s)
+    if "TwoArm" in options["env_name"]:
+        # Choose env config and add it to options
+        options["env_configuration"] = choose_multi_arm_config()
+
+        # If chosen configuration was bimanual, the corresponding robot must be Baxter. Else, have user choose robots
+        if options["env_configuration"] == "bimanual":
+            options["robots"] = "Baxter"
+        else:
+            options["robots"] = []
+
+            # Have user choose two robots
+            print("A multiple single-arm configuration was chosen.\n")
+
+            for i in range(2):
+                print("Please choose Robot {}...\n".format(i))
+                options["robots"].append(choose_robots(exclude_bimanual=True))
+    # If a humanoid environment has been chosen, choose humanoid robots
+    elif "Humanoid" in options["env_name"]:
+        options["robots"] = choose_robots(use_humanoids=True)
+    # Else, we simply choose a single (single-armed) robot to instantiate in the environment
+    else:
+        options["robots"] = choose_robots(exclude_bimanual=True)
+
+    # Hacky way to grab joint dimension for now
+    joint_dim = 6 if options["robots"] == "UR5e" else (16 if options["robots"] == "GR1" else 7)
+
+    # Choose controller
+    controller_name = choose_controller(part_controllers=True)
+
+    # Load the desired controller
+    arm_controller_config = suite.load_part_controller_config(default_controller=controller_name)
+    robot = options["robots"][0] if isinstance(options["robots"], list) else options["robots"]
+    options["controller_configs"] = refactor_composite_controller_config(
+        arm_controller_config, robot, ["right", "left"]
+    )
+
+    # Define the pre-defined controller actions to use (action_dim, num_test_steps, test_value)
+    controller_settings = {
+        "OSC_POSE": [6, 6, 0.1],
+        "OSC_POSITION": [3, 3, 0.1],
+        "IK_POSE": [6, 6, 0.01],
+        "JOINT_POSITION": [joint_dim, joint_dim, 0.2],
+        "JOINT_VELOCITY": [joint_dim, joint_dim, -0.1],
+        "JOINT_TORQUE": [joint_dim, joint_dim, 0.25],
+    }
+
+    # Define variables for each controller test
+    action_dim = controller_settings[controller_name][0]
+    num_test_steps = controller_settings[controller_name][1]
+    test_value = controller_settings[controller_name][2]
+
+    # Define the number of timesteps to use per controller action as well as timesteps in between actions
+    steps_per_action = 75
+    steps_per_rest = 75
+
+    # initialize the task
+    env = suite.make(
+        **options,
+        has_renderer=True,
+        has_offscreen_renderer=False,
+        ignore_done=True,
+        use_camera_obs=False,
+        horizon=(steps_per_action + steps_per_rest) * num_test_steps,
+        control_freq=20,
+    )
+    env.reset()
+    env.viewer.set_camera(camera_id=0)
+
+    # To accommodate for multi-arm settings (e.g.: Baxter), we need to make sure to fill any extra action space
+    # Get total number of arms being controlled
+    n = 0
+    gripper_dim = 0
+    for robot in env.robots:
+        gripper_dim = robot.gripper["right"].dof
+        n += int(robot.action_dim / (action_dim + gripper_dim))
+
+    # Define neutral value
+    neutral = np.zeros(action_dim + gripper_dim)
+
+    # Keep track of done variable to know when to break loop
+    count = 0
+    # Loop through controller space
+    while count < num_test_steps:
+        action = neutral.copy()
+        for i in range(steps_per_action):
+            start = time.time()
+            if controller_name in {"IK_POSE", "OSC_POSE"} and count > 2:
+                # Set this value to be the scaled axis angle vector
+                vec = np.zeros(3)
+                vec[count - 3] = test_value
+                action[3:6] = vec
+            else:
+                action[count] = test_value
+            total_action = np.tile(action, n)
+            env.step(total_action)
+            env.render()
+
+            # limit frame rate if necessary
+            elapsed = time.time() - start
+            diff = 1 / MAX_FR - elapsed
+            if diff > 0:
+                time.sleep(diff)
+        for i in range(steps_per_rest):
+            start = time.time()
+            total_action = np.tile(neutral, n)
+            env.step(total_action)
+            env.render()
+
+            # limit frame rate if necessary
+            elapsed = time.time() - start
+            diff = 1 / MAX_FR - elapsed
+            if diff > 0:
+                time.sleep(diff)
+        count += 1
+
+    # Shut down this env before starting the next test
+    env.close()

robosuite/demos/demo_device_control.py

@@ -0,0 +1,307 @@
+"""Teleoperate robot with keyboard or SpaceMouse.
+
+***Choose user input option with the --device argument***
+
+Keyboard:
+    We use the keyboard to control the end-effector of the robot.
+    The keyboard provides 6-DoF control commands through various keys.
+    The commands are mapped to joint velocities through an inverse kinematics
+    solver from Bullet physics.
+
+    Note:
+        To run this script with macOS, you must run it with root access.
+
+SpaceMouse:
+
+    We use the SpaceMouse 3D mouse to control the end-effector of the robot.
+    The mouse provides 6-DoF control commands. The commands are mapped to joint
+    velocities through an inverse kinematics solver from Bullet physics.
+
+    The two side buttons of SpaceMouse are used for controlling the grippers.
+
+    SpaceMouse Wireless from 3Dconnexion: https://www.3dconnexion.com/spacemouse_wireless/en/
+    We used the SpaceMouse Wireless in our experiments. The paper below used the same device
+    to collect human demonstrations for imitation learning.
+
+    Reinforcement and Imitation Learning for Diverse Visuomotor Skills
+    Yuke Zhu, Ziyu Wang, Josh Merel, Andrei Rusu, Tom Erez, Serkan Cabi, Saran Tunyasuvunakool,
+    János Kramár, Raia Hadsell, Nando de Freitas, Nicolas Heess
+    RSS 2018
+
+    Note:
+        This current implementation only supports macOS (Linux support can be added).
+        Download and install the driver before running the script:
+            https://www.3dconnexion.com/service/drivers.html
+
+Additionally, --pos_sensitivity and --rot_sensitivity provide relative gains for increasing / decreasing the user input
+device sensitivity
+
+
+***Choose controller with the --controller argument***
+
+Choice of using either inverse kinematics controller (ik) or operational space controller (osc):
+Main difference is that user inputs with ik's rotations are always taken relative to eef coordinate frame, whereas
+    user inputs with osc's rotations are taken relative to global frame (i.e.: static / camera frame of reference).
+
+
+***Choose environment specifics with the following arguments***
+
+    --environment: Task to perform, e.g.: "Lift", "TwoArmPegInHole", "NutAssembly", etc.
+
+    --robots: Robot(s) with which to perform the task. Can be any in
+        {"Panda", "Sawyer", "IIWA", "Jaco", "Kinova3", "UR5e", "Baxter"}. Note that the environments include sanity
+        checks, such that a "TwoArm..." environment will only accept either a 2-tuple of robot names or a single
+        bimanual robot name, according to the specified configuration (see below), and all other environments will
+        only accept a single single-armed robot name
+
+    --config: Exclusively applicable and only should be specified for "TwoArm..." environments. Specifies the robot
+        configuration desired for the task. Options are {"parallel" and "opposed"}
+
+            -"parallel": Sets up the environment such that two robots are stationed next to
+                each other facing the same direction. Expects a 2-tuple of robot names to be specified
+                in the --robots argument.
+
+            -"opposed": Sets up the environment such that two robots are stationed opposed from
+                each other, facing each other from opposite directions. Expects a 2-tuple of robot names
+                to be specified in the --robots argument.
+
+    --arm: Exclusively applicable and only should be specified for "TwoArm..." environments. Specifies which of the
+        multiple arm eef's to control. The other (passive) arm will remain stationary. Options are {"right", "left"}
+        (from the point of view of the robot(s) facing against the viewer direction)
+
+    --switch-on-grasp: Exclusively applicable and only should be specified for "TwoArm..." environments. If enabled,
+        will switch the current arm being controlled every time the gripper input is pressed
+
+    --toggle-camera-on-grasp: If enabled, gripper input presses will cycle through the available camera angles
+
+Examples:
+
+    For normal single-arm environment:
+        $ python demo_device_control.py --environment PickPlaceCan --robots Sawyer --controller osc
+
+    For two-arm bimanual environment:
+        $ python demo_device_control.py --environment TwoArmLift --robots Baxter --config bimanual --arm left --controller osc
+
+    For two-arm multi single-arm robot environment:
+        $ python demo_device_control.py --environment TwoArmLift --robots Sawyer Sawyer --config parallel --controller osc
+
+
+"""
+
+import argparse
+import time
+
+import numpy as np
+
+import robosuite as suite
+from robosuite import load_composite_controller_config
+from robosuite.controllers.composite.composite_controller import WholeBody
+from robosuite.wrappers import VisualizationWrapper
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--environment", type=str, default="Lift")
+    parser.add_argument(
+        "--robots",
+        nargs="+",
+        type=str,
+        default="Panda",
+        help="Which robot(s) to use in the env",
+    )
+    parser.add_argument(
+        "--config",
+        type=str,
+        default="default",
+        help="Specified environment configuration if necessary",
+    )
+    parser.add_argument(
+        "--arm",
+        type=str,
+        default="right",
+        help="Which arm to control (eg bimanual) 'right' or 'left'",
+    )
+    parser.add_argument(
+        "--switch-on-grasp",
+        action="store_true",
+        help="Switch gripper control on gripper action",
+    )
+    parser.add_argument(
+        "--toggle-camera-on-grasp",
+        action="store_true",
+        help="Switch camera angle on gripper action",
+    )
+    parser.add_argument(
+        "--controller",
+        type=str,
+        default=None,
+        help="Choice of controller. Can be generic (eg. 'BASIC' or 'WHOLE_BODY_MINK_IK') or json file (see robosuite/controllers/config for examples) or None to get the robot's default controller if it exists",
+    )
+    parser.add_argument("--device", type=str, default="keyboard")
+    parser.add_argument(
+        "--pos-sensitivity",
+        type=float,
+        default=1.0,
+        help="How much to scale position user inputs",
+    )
+    parser.add_argument(
+        "--rot-sensitivity",
+        type=float,
+        default=1.0,
+        help="How much to scale rotation user inputs",
+    )
+    parser.add_argument(
+        "--max_fr",
+        default=20,
+        type=int,
+        help="Sleep when simluation runs faster than specified frame rate; 20 fps is real time.",
+    )
+    parser.add_argument(
+        "--reverse_xy",
+        type=bool,
+        default=False,
+        help="(DualSense Only)Reverse the effect of the x and y axes of the joystick.It is used to handle the case that the left/right and front/back sides of the view are opposite to the LX and LY of the joystick(Push LX up but the robot move left in your view)",
+    )
+    args = parser.parse_args()
+
+    # Get controller config
+    controller_config = load_composite_controller_config(
+        controller=args.controller,
+        robot=args.robots[0],
+    )
+
+    # Create argument configuration
+    config = {
+        "env_name": args.environment,
+        "robots": args.robots,
+        "controller_configs": controller_config,
+    }
+
+    # Check if we're using a multi-armed environment and use env_configuration argument if so
+    if "TwoArm" in args.environment:
+        config["env_configuration"] = args.config
+    else:
+        args.config = None
+
+    # Create environment
+    env = suite.make(
+        **config,
+        has_renderer=True,
+        has_offscreen_renderer=False,
+        render_camera="agentview",
+        ignore_done=True,
+        use_camera_obs=False,
+        reward_shaping=True,
+        control_freq=20,
+        hard_reset=False,
+    )
+
+    # Wrap this environment in a visualization wrapper
+    env = VisualizationWrapper(env, indicator_configs=None)
+
+    # Setup printing options for numbers
+    np.set_printoptions(formatter={"float": lambda x: "{0:0.3f}".format(x)})
+
+    # initialize device
+    if args.device == "keyboard":
+        from robosuite.devices import Keyboard
+
+        device = Keyboard(
+            env=env,
+            pos_sensitivity=args.pos_sensitivity,
+            rot_sensitivity=args.rot_sensitivity,
+        )
+        env.viewer.add_keypress_callback(device.on_press)
+    elif args.device == "spacemouse":
+        from robosuite.devices import SpaceMouse
+
+        device = SpaceMouse(
+            env=env,
+            pos_sensitivity=args.pos_sensitivity,
+            rot_sensitivity=args.rot_sensitivity,
+        )
+    elif args.device == "dualsense":
+        from robosuite.devices import DualSense
+
+        device = DualSense(
+            env=env,
+            pos_sensitivity=args.pos_sensitivity,
+            rot_sensitivity=args.rot_sensitivity,
+            reverse_xy=args.reverse_xy,
+        )
+    elif args.device == "mjgui":
+        from robosuite.devices.mjgui import MJGUI
+
+        device = MJGUI(env=env)
+    else:
+        raise Exception("Invalid device choice: choose either 'keyboard', 'dualsene' or 'spacemouse'.")
+
+    while True:
+        # Reset the environment
+        obs = env.reset()
+
+        # Setup rendering
+        cam_id = 0
+        num_cam = len(env.sim.model.camera_names)
+        env.render()
+
+        # Initialize variables that should the maintained between resets
+        last_grasp = 0
+
+        # Initialize device control
+        device.start_control()
+        all_prev_gripper_actions = [
+            {
+                f"{robot_arm}_gripper": np.repeat([0], robot.gripper[robot_arm].dof)
+                for robot_arm in robot.arms
+                if robot.gripper[robot_arm].dof > 0
+            }
+            for robot in env.robots
+        ]
+
+        # Loop until we get a reset from the input or the task completes
+        while True:
+            start = time.time()
+
+            # Set active robot
+            active_robot = env.robots[device.active_robot]
+
+            # Get the newest action
+            input_ac_dict = device.input2action()
+
+            # If action is none, then this a reset so we should break
+            if input_ac_dict is None:
+                break
+
+            from copy import deepcopy
+
+            action_dict = deepcopy(input_ac_dict)  # {}
+            # set arm actions
+            for arm in active_robot.arms:
+                if isinstance(active_robot.composite_controller, WholeBody):  # input type passed to joint_action_policy
+                    controller_input_type = active_robot.composite_controller.joint_action_policy.input_type
+                else:
+                    controller_input_type = active_robot.part_controllers[arm].input_type
+
+                if controller_input_type == "delta":
+                    action_dict[arm] = input_ac_dict[f"{arm}_delta"]
+                elif controller_input_type == "absolute":
+                    action_dict[arm] = input_ac_dict[f"{arm}_abs"]
+                else:
+                    raise ValueError
+
+            # Maintain gripper state for each robot but only update the active robot with action
+            env_action = [robot.create_action_vector(all_prev_gripper_actions[i]) for i, robot in enumerate(env.robots)]
+            env_action[device.active_robot] = active_robot.create_action_vector(action_dict)
+            env_action = np.concatenate(env_action)
+            for gripper_ac in all_prev_gripper_actions[device.active_robot]:
+                all_prev_gripper_actions[device.active_robot][gripper_ac] = action_dict[gripper_ac]
+
+            env.step(env_action)
+            env.render()
+
+            # limit frame rate if necessary
+            if args.max_fr is not None:
+                elapsed = time.time() - start
+                diff = 1 / args.max_fr - elapsed
+                if diff > 0:
+                    time.sleep(diff)

robosuite/demos/demo_domain_randomization.py

@@ -0,0 +1,78 @@
+"""
+Script to showcase domain randomization functionality.
+"""
+
+import time
+
+import robosuite.macros as macros
+from robosuite.utils.input_utils import *
+from robosuite.wrappers import DomainRandomizationWrapper
+
+# We'll use instance randomization so that entire geom groups are randomized together
+macros.USING_INSTANCE_RANDOMIZATION = True
+
+if __name__ == "__main__":
+    # Create dict to hold options that will be passed to env creation call
+    options = {}
+
+    # print welcome info
+    print("Welcome to robosuite v{}!".format(suite.__version__))
+    print(suite.__logo__)
+
+    # Choose environment and add it to options
+    options["env_name"] = choose_environment()
+
+    # If a multi-arm environment has been chosen, choose configuration and appropriate robot(s)
+    if "TwoArm" in options["env_name"]:
+        # Choose env config and add it to options
+        options["env_configuration"] = choose_multi_arm_config()
+
+        # If chosen configuration was bimanual, the corresponding robot must be Baxter. Else, have user choose robots
+        if options["env_configuration"] == "bimanual":
+            options["robots"] = "Baxter"
+        else:
+            options["robots"] = []
+
+            # Have user choose two robots
+            print("A multiple single-arm configuration was chosen.\n")
+
+            for i in range(2):
+                print("Please choose Robot {}...\n".format(i))
+                options["robots"].append(choose_robots(exclude_bimanual=True))
+    # If a humanoid environment has been chosen, choose humanoid robots
+    elif "Humanoid" in options["env_name"]:
+        options["robots"] = choose_robots(use_humanoids=True)
+    # Else, we simply choose a single (single-armed) robot to instantiate in the environment
+    else:
+        options["robots"] = choose_robots(exclude_bimanual=True)
+
+    # initialize the task
+    env = suite.make(
+        **options,
+        has_renderer=True,
+        has_offscreen_renderer=False,
+        ignore_done=True,
+        use_camera_obs=False,
+        control_freq=20,
+        hard_reset=False,  # TODO: Not setting this flag to False brings up a segfault on macos or glfw error on linux
+    )
+    env = DomainRandomizationWrapper(
+        env,
+        randomize_color=False,  # randomize_color currently only works for mujoco==3.1.1
+        randomize_camera=False,  # less jarring when visualizing
+        randomize_dynamics=False,
+    )
+    env.reset()
+    env.viewer.set_camera(camera_id=0)
+
+    max_frame_rate = 20  # Set the desired maximum frame rate
+
+    # Get action limits
+    low, high = env.action_spec
+
+    # do visualization
+    for i in range(100):
+        action = np.random.uniform(low, high)
+        obs, reward, done, _ = env.step(action)
+        env.render()
+        time.sleep(1 / max_frame_rate)