### Install ROS 2 Humble ros2_control Binary Packages

Source: https://control.ros.org/humble/index.html/doc/getting_started/getting_started

Install the ros2_control and ros2_controllers packages for ROS 2 Humble using your system's package manager. This method is suitable for users who prefer pre-built binaries and a quick setup.

```bash
sudo apt install ros-humble-ros2-control ros-humble-ros2-controllers
```

```bash
sudo dnf install ros-humble-ros2-control ros-humble-ros2-controllers
```

--------------------------------

### Install Dependencies for ROS 2 Control Source Build

Source: https://control.ros.org/humble/index.html/doc/getting_started/getting_started

Update rosdep and apt, then install all necessary system dependencies required for building the ros2_control framework from source. This ensures all prerequisite libraries and tools are present before compilation.

```bash
rosdep update --rosdistro=$ROS_DISTRO
sudo apt-get update
rosdep install --from-paths src --ignore-src -r -y
```

--------------------------------

### Build ROS 2 Control Workspace from Source

Source: https://control.ros.org/humble/index.html/doc/getting_started/getting_started

Source the ROS 2 setup script and compile the ros2_control workspace using 'colcon build'. This step creates the executable binaries and libraries from the downloaded source code, making the framework ready for use.

```bash
. /opt/ros/${ROS_DISTRO}/setup.sh
colcon build --symlink-install
```

--------------------------------

### Start DiffBot Example in ROS2

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_2/doc/userdoc

Executes the main launch file for the DiffBot example. This command loads and starts the robot hardware, controllers, and opens RViz, displaying the robot's internal states and preparing it for control.

```bash
ros2 launch ros2_control_demo_example_2 diffbot.launch.py
```

--------------------------------

### Start RRBot Example Launch File

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_10/doc/userdoc

To start the RRBot example, open a terminal, source your ROS2-workspace, and execute its launch file. This command loads and starts the robot hardware and controllers.

```bash
ros2 launch ros2_control_demo_example_10 rrbot.launch.py
```

--------------------------------

### Start RRBot Modular Actuators Example

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_6/doc/userdoc

Starts the full RRBot example, loading and initializing robot hardware, controllers, and opening RViz. This command initiates the simulation or hardware interface for the robot, displaying internal states in the terminal.

```bash
ros2 launch ros2_control_demo_example_6 rrbot_modular_actuators.launch.py
```

--------------------------------

### Download Stable ROS 2 Control Source Repositories

Source: https://control.ros.org/humble/index.html/doc/getting_started/getting_started

Set up a ROS 2 workspace and download the stable version of the ros2_control framework repositories using 'vcs import'. This is the initial step for building the framework from source to receive future releases.

```bash
mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/
vcs import --input https://raw.githubusercontent.com/ros-controls/ros2_control_ci/master/ros_controls.$ROS_DISTRO.repos src
```

--------------------------------

### Download Development ROS 2 Control Source Repositories

Source: https://control.ros.org/humble/index.html/doc/getting_started/getting_started

Set up a ROS 2 workspace and download the development (rolling) version of the ros2_control framework repositories using 'vcs import'. This option provides access to the latest features and bug fixes for active development.

```bash
mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/
vcs import --input https://raw.githubusercontent.com/ros-controls/ros2_control_ci/master/ros_controls.rolling-on-$ROS_DISTRO.repos src
```

--------------------------------

### Run ROS 2 Control Demo Docker Container (Diffbot Example)

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/doc/index

This command starts the ROS 2 control demos Docker container and directly launches the `diffbot.launch.py` example. It uses `--net host` for network configuration.

```bash
docker run -it --rm --name ros2_control_demos --net host ros2_control_demos ros2 launch ros2_control_demo_example_2 diffbot.launch.py
```

--------------------------------

### Launch ROS 2 RRBot Example

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_1/doc/userdoc

Launches the rrbot.launch.py file to start the RRBot example. This command loads and initializes the robot hardware, controllers, and optionally opens RViz, facilitating the robot's operation either locally or within a Docker container.

```ROS 2 (Local)
ros2 launch ros2_control_demo_example_1 rrbot.launch.py
```

```ROS 2 (Docker)
docker run -it --rm --name ros2_control_demos --net host ros2_control_demos ros2 launch ros2_control_demo_example_1 rrbot.launch.py gui:=false
```

--------------------------------

### Defining ros2_control Hardware Components in URDF

Source: https://control.ros.org/humble/index.html/doc/getting_started/getting_started

This URDF example demonstrates how to define different types of hardware components (system, sensor, actuator) for the ros2_control framework. It illustrates the use of the <ros2_control> tag to specify hardware plugins, parameters, and joint command/state interfaces for a multi-DOF robot, a force-torque sensor, and a gripper.

```XML
<ros2_control name="RRBotSystemPositionOnly" type="system">
 <hardware>
   <plugin>ros2_control_demo_hardware/RRBotSystemPositionOnlyHardware</plugin>
   <param name="example_param_write_for_sec">2</param>
   <param name="example_param_read_for_sec">2</param>
 </hardware>
 <joint name="joint1">
   <command_interface name="position">
     <param name="min">-1</param>
     <param name="max">1</param>
   </command_interface>
   <state_interface name="position"/>
 </joint>
 <joint name="joint2">
   <command_interface name="position">
     <param name="min">-1</param>
     <param name="max">1</param>
   </command_interface>
   <state_interface name="position"/>
 </joint>
</ros2_control>
<ros2_control name="RRBotForceTorqueSensor1D" type="sensor">
 <hardware>
   <plugin>ros2_control_demo_hardware/ForceTorqueSensor1DHardware</plugin>
   <param name="example_param_read_for_sec">0.43</param>
 </hardware>
 <sensor name="tcp_fts_sensor">
   <state_interface name="force"/>
   <param name="frame_id">rrbot_tcp</param>
   <param name="min_force">-100</param>
   <param name="max_force">100</param>
 </sensor>
</ros2_control>
<ros2_control name="RRBotGripper" type="actuator">
 <hardware>
   <plugin>ros2_control_demo_hardware/PositionActuatorHardware</plugin>
   <param name="example_param_write_for_sec">1.23</param>
   <param name="example_param_read_for_sec">3</param>
 </hardware>
 <joint name="gripper_joint ">
   <command_interface name="position">
     <param name="min">0</param>
     <param name="max">50</param>
   </command_interface>
   <state_interface name="position"/>
   <state_interface name="velocity"/>
 </joint>
</ros2_control>
```

--------------------------------

### ROS 2 Control Demos: Source Installation - Build All

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/doc/index

This snippet sources the ROS 2 installation and then builds all packages in the workspace using `colcon` with a symlink install, which is common for source builds.

```bash
. /opt/ros/${ROS_DISTRO}/setup.sh
colcon build --symlink-install
```

--------------------------------

### Start RRBot System with External Sensor

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_5/doc/userdoc

Starts the RRBot example, loading and initiating robot hardware, controllers, and RViz. This command will produce extensive output from the hardware implementation, showing its internal states, which is for exemplary purposes.

```bash
ros2 launch ros2_control_demo_example_5 rrbot_system_with_external_sensor.launch.py
```

--------------------------------

### Launch RRBot Modular Actuators Example in ROS2

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_14/doc/userdoc

Execute this launch file to start the RRBot example, which loads and initializes the robot hardware and controllers, and opens RViz. This setup uses modular actuators without feedback sensors for position feedback, demonstrating the `ros2_control` framework.

```bash
ros2 launch ros2_control_demo_example_14 rrbot_modular_actuators_without_feedback_sensors_for_position_feedback.launch.py
```

--------------------------------

### Launch ROS2 RRBot System with Sensor

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_4/doc/userdoc

Starts the RRBot example by launching its system with sensor configuration. This loads and starts the robot hardware, controllers, and opens RViz, displaying internal states from the hardware implementation.

```shell
ros2 launch ros2_control_demo_example_4 rrbot_system_with_sensor.launch.py
```

--------------------------------

### Start DiffBot with Mock Hardware in ROS2

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_2/doc/userdoc

Launches the DiffBot example using a mock hardware component instead of the custom one. This is useful for faster simulation and testing without a real robot, by passing `use_mock_hardware:=True`.

```bash
ros2 launch ros2_control_demo_example_2 diffbot.launch.py use_mock_hardware:=True
```

--------------------------------

### Launch RRBot with Hardware Interface

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_9/doc/userdoc

Launch the `rrbot.launch.py` file to start the RRBot with its hardware interface instead of simulators. This setup uses an identical hardware interface as discussed in `example_1`.

```bash
ros2 launch ros2_control_demo_example_9 rrbot.launch.py
```

--------------------------------

### ROS 2 Control Demos: Local Installation - Build Debian Packages

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/doc/index

After installing dependencies, this snippet navigates to the workspace, sources the ROS 2 installation, and builds the `ros2_control_demos` repository using `colcon` with a merged install.

```bash
cd ~/ros2_ws/
. /opt/ros/${ROS_DISTRO}/setup.sh
colcon build --merge-install
```

--------------------------------

### Complete ROS2 Joint State Broadcaster Parameter File Example

Source: https://control.ros.org/humble/index.html/doc/ros2_controllers/joint_state_broadcaster/doc/userdoc

A comprehensive example of a YAML parameter file for configuring the `joint_state_broadcaster`, including all common parameters and their default or example values.

```YAML
joint_state_broadcaster:
  ros__parameters:
    extra_joints: '{}'
    frame_id: base_link
    interfaces: '{}'
    joints: '{}'
    map_interface_to_joint_state:
      effort: effort
      position: position
      velocity: velocity
    use_local_topics: false
```

--------------------------------

### ROS 2 Control Demos: Local Installation - Debian Dependencies

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/doc/index

This snippet outlines the initial steps for a local installation of `ros2_control_demos` using Debian packages. It creates a workspace, clones the humble branch of the repository, updates package lists, and installs all necessary dependencies using `rosdep`.

```bash
mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src
git clone https://github.com/ros-controls/ros2_control_demos -b humble
cd ~/ros2_ws/
sudo apt-get update
rosdep update --rosdistro=$ROS_DISTRO
rosdep install --from-paths ./ -i -y --rosdistro ${ROS_DISTRO}
```

--------------------------------

### Start RRBot Transmissions System in ROS2

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_8/doc/userdoc

Launch the main RRBot example, which loads and starts robot hardware, controllers, and opens RViz. This will show internal states from the hardware implementation in the starting terminal.

```bash
ros2 launch ros2_control_demo_example_8 rrbot_transmissions_system_position_only.launch.py
```

--------------------------------

### Start ROS 2 Joint State Publisher GUI

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_1/doc/userdoc

Sources the ROS 2 installation and then runs the joint_state_publisher_gui node. This GUI provides an interface to change the configuration for RRBot, with immediate visualization in RViz.

```Bash
source /opt/ros/${ROS_DISTRO}/setup.bash
ros2 run joint_state_publisher_gui joint_state_publisher_gui
```

--------------------------------

### Build ROS 2 Control Demos Workspace

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_7/doc/userdoc

Clones the `ros2_control_demos` repository, navigates into it, builds the workspace with `colcon build`, and sources the setup file. This prepares the environment for running ROS 2 control examples.

```shell
git clone -b humble https://github.com/ros-controls/ros2_control_demos.git
cd ros2_control_demos
colcon build --symlink-install
source install/setup.bash
```

--------------------------------

### ROS 2 Control Mock Hardware System XML Configuration Example

Source: https://control.ros.org/humble/index.html/doc/ros2_control/hardware_interface/doc/mock_components_userdoc

An example XML configuration for a `ros2_control` mock hardware system, demonstrating the structure for hardware, joint, and GPIO interfaces, including optional parameters and their default values.

```XML
<ros2_control name="MockHardwareSystem" type="system">
  <hardware>
    <plugin>mock_components/GenericSystem</plugin>
    <param name="calculate_dynamics">false</param>
    <param name="custom_interface_with_following_offset"></param>
    <param name="disable_commands">false</param>
    <param name="mock_gpio_commands">false</param>
    <param name="mock_sensor_commands">false</param>
    <param name="position_state_following_offset">0.0</param>
  </hardware>
  <joint name="joint1">
    <command_interface name="position"/>
    <command_interface name="velocity"/>
    <state_interface name="position">
      <param name="initial_value">3.45</param>
    </state_interface>
    <state_interface name="velocity"/>
    <state_interface name="acceleration"/>
  </joint>
  <joint name="joint2">
    <command_interface name="velocity"/>
    <command_interface name="acceleration"/>
    <state_interface name="position">
      <param name="initial_value">2.78</param>
    </state_interface>
    <state_interface name="position"/>
    <state_interface name="velocity"/>
    <state_interface name="acceleration"/>
  </joint>
  <gpio name="flange_vacuum">
    <command_interface name="vacuum"/>
    <state_interface name="vacuum" data_type="double"/>
  </gpio>
</ros2_control>
```

--------------------------------

### Launch RRBot Description Viewer

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_10/doc/userdoc

To check that RRBot descriptions are working properly, use the following launch command. This command starts a viewer for the robot's URDF description.

```bash
ros2 launch ros2_control_demo_example_10 view_robot.launch.py
```

--------------------------------

### ROS 2 Control Demos: Source Installation - Install Dependencies

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/doc/index

This snippet installs all required dependencies for a source build of `ros2_control_demos` from the `src` directory, ignoring source packages already present.

```bash
rosdep install --from-paths src --ignore-src -r -y
```

--------------------------------

### Control ROS2 Gripper Example

Source: https://control.ros.org/humble/index.html/doc/gazebo_ros2_control/doc/index

Command to send example control commands to the launched gripper. This demonstrates how to interact with the gripper in the Gazebo simulation, allowing for testing its movement.

```bash
ros2 run gazebo_ros2_control_demos example_gripper
```

--------------------------------

### Install gz_ros2_control Binary Packages for ROS 2 Humble

Source: https://control.ros.org/humble/index.html/doc/gz_ros2_control/doc/index

This command installs the `gz_ros2_control` and `gz_ros2_control_demos` packages for ROS 2 Humble on Ubuntu using `apt`. These packages provide the necessary components for integrating ros2_control with Gazebo.

```Shell
sudo apt install ros-humble-gz-ros2-control ros-humble-gz-ros2-control-demos

```

--------------------------------

### Start ROS 2 Joint State Publisher GUI

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/doc/index

This command, run in a separate terminal, sources the ROS 2 environment setup and then launches the `joint_state_publisher_gui` node. This GUI allows users to manually adjust robot joint values.

```bash
source /opt/ros/${ROS_DISTRO}/setup.bash
ros2 run joint_state_publisher_gui joint_state_publisher_gui
```

--------------------------------

### Launch RViz2 with RRBot Configuration from Local Machine

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/doc/index

This command, executed on the local machine after starting the Docker container, navigates to the ROS 2 workspace, sources the setup script, and launches `rviz2` with the `rrbot` configuration file to visualize the robot.

```bash
cd ~/ros2_ws
source /opt/ros/${ROS_DISTRO}/setup.sh
rviz2 -d src/ros2_control_demos/ros2_control_demo_description/rrbot/rviz/rrbot.rviz
```

--------------------------------

### Example Output: ROS 2 Control Hardware Interfaces

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_5/doc/userdoc

Example output showing the available and claimed command interfaces (e.g., `joint1/position`, `joint2/position`) and state interfaces for the RRBot, including force-torque sensor data, confirming proper loading.

```shell
command interfaces
  joint1/position [available] [claimed]
  joint2/position [available] [claimed]
state interfaces
  joint1/position
  joint2/position
  tcp_fts_sensor/force.x
  tcp_fts_sensor/force.y
  tcp_fts_sensor/force.z
  tcp_fts_sensor/torque.x
  tcp_fts_sensor/torque.y
```

--------------------------------

### Launch ROS2 Gripper Mimic Joint Example

Source: https://control.ros.org/humble/index.html/doc/gazebo_ros2_control/doc/index

Commands to launch a parallel gripper example featuring a mimic joint from gazebo_ros2_control_demos. These commands set up the Gazebo world for the gripper simulation.

```bash
ros2 launch gazebo_ros2_control_demos gripper_mimic_joint_example_position.launch.py
ros2 launch gazebo_ros2_control_demos gripper_mimic_joint_example.launch.py
```

--------------------------------

### Example Output: ROS 2 Control Controllers

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_5/doc/userdoc

Example output showing the active controllers: `forward_position_controller`, `fts_broadcaster`, and `joint_state_broadcaster`, confirming they are running and ready for use.

```shell
forward_position_controller[forward_command_controller/ForwardCommandController] active
fts_broadcaster[force_torque_sensor_broadcaster/ForceTorqueSensorBroadcaster] active
joint_state_broadcaster[joint_state_broadcaster/JointStateBroadcaster] active
```

--------------------------------

### ROS 2 GPIO Command Controller YAML Configuration Example

Source: https://control.ros.org/humble/index.html/doc/ros2_controllers/gpio_controllers/doc/userdoc

An example YAML configuration for the `gpio_command_controller`, demonstrating how to define `gpios`, their `command_interfaces`, and `state_interfaces`. This configuration shows how to enable command acceptance for all GPIO interfaces and publish the state of specific GPIOs.

```yaml
gpio_command_controller:
  ros__parameters:
    type: gpio_controllers/GpioCommandController
    gpios:
      - Gpio1
      - Gpio2
    command_interfaces:
      Gpio1:
        - interfaces:
          - dig.1
          - dig.2
          - dig.3
      Gpio2:
        - interfaces:
          - ana.1
          - ana.2
    state_interfaces:
      Gpio2:
        - interfaces:
          - ana.1
          - ana.2
```

--------------------------------

### Install ROS 2 Visualization and Joint Control Packages

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/doc/index

This command installs the `joint_state_publisher_gui` and `rviz2` packages for ROS 2, which are necessary for visualizing robot states and manually controlling joint values. It uses `apt-get` for package management.

```bash
sudo apt-get install -y ros-${ROS_DISTRO}-joint-state-publisher-gui ros-${ROS_DISTRO}-rviz2
```

--------------------------------

### Launch RRBot in Gazebo Simulator

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_9/doc/userdoc

Launch the `rrbot_gazebo.launch.py` file to start the RRBot in the Gazebo simulator. This command loads the robot description, starts Gazebo, `Joint State Broadcaster`, and `Forward Command Controller`.

```bash
ros2 launch ros2_control_demo_example_9 rrbot_gazebo.launch.py
```

--------------------------------

### ROS 2 Diff Drive Controller: Example YAML Configuration

Source: https://control.ros.org/humble/index.html/doc/ros2_controllers/diff_drive_controller/doc/userdoc

An example YAML configuration file for the ROS 2 `diff_drive_controller`, demonstrating how to set up wheel names, geometry, odometry parameters, and motion limits. This file provides a comprehensive overview of common controller parameters.

```YAML
test_diff_drive_controller:
  ros__parameters:
    left_wheel_names: ["left_wheels"]
    right_wheel_names: ["right_wheels"]

    wheel_separation: 0.40
    wheels_per_side: 1  # actually 2, but both are controlled by 1 signal
    wheel_radius: 0.02

    wheel_separation_multiplier: 1.0
    left_wheel_radius_multiplier: 1.0
    right_wheel_radius_multiplier: 1.0

    odom_frame_id: odom
    base_frame_id: base_link
    pose_covariance_diagonal: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
    twist_covariance_diagonal: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

    position_feedback: false
    open_loop: true
    enable_odom_tf: true

    cmd_vel_timeout: 0.5 # seconds
    publish_limited_velocity: true
    velocity_rolling_window_size: 10

    linear.x.has_velocity_limits: false
    linear.x.has_acceleration_limits: false
    linear.x.has_jerk_limits: false
    linear.x.max_velocity: 0.0
    linear.x.min_velocity: 0.0
    linear.x.max_acceleration: 0.0
    linear.x.max_jerk: 0.0
    linear.x.min_jerk: 0.0

    angular.z.has_velocity_limits: false
    angular.z.has_acceleration_limits: false
    angular.z.has_jerk_limits: false
    angular.z.max_velocity: 0.0
    angular.z.min_velocity: 0.0
    angular.z.max_acceleration: 0.0
    angular.z.min_acceleration: 0.0
    angular.z.max_jerk: 0.0
    angular.z.min_jerk: 0.0
```

--------------------------------

### Start CarlikeBot ROS2 Control Example

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_11/doc/userdoc

Executes the main launch file for the CarlikeBot, which loads the robot hardware, controllers, and opens RViz. Setting `remap_odometry_tf` to `true` ensures the odometry TF is remapped to the `/tf` topic, allowing the robot's pose to be updated in the world coordinate system. Excessive terminal output from the hardware implementation is for demonstration purposes.

```bash
ros2 launch ros2_control_demo_example_11 carlikebot.launch.py remap_odometry_tf:=true
```

--------------------------------

### Launch ROS2 Diff Drive Example with Namespace

Source: https://control.ros.org/humble/index.html/doc/gazebo_ros2_control/doc/index

Command to launch the diff_drive example from gazebo_ros2_control_demos within the r1 namespace. This illustrates how to execute a pre-configured launch file to run a robot in a specific namespace.

```bash
ros2 launch gazebo_ros2_control_demos diff_drive_namespaced.launch.py
```

--------------------------------

### Send Commands to ROS2 Gripper Example

Source: https://control.ros.org/humble/index.html/doc/gz_ros2_control/doc/index

After launching the gripper example, this command runs an executable to send pre-defined commands to control the gripper's movement.

```Shell
ros2 run gz_ros2_control_demos example_gripper
```

--------------------------------

### APIDOC: RRBotSystemPositionOnlyHardware::on_init Method

Source: https://control.ros.org/humble/index.html/doc/api/example__12_2hardware_2include_2ros2__control__demo__example__12_2rrbot_8hpp_source

This method handles the initialization of the hardware interface, parsing data from the robot's URDF (Unified Robot Description Format). It sets up the necessary hardware components and configurations based on the robot's description.

```APIDOC
ros2_control_demo_example_12::RRBotSystemPositionOnlyHardware::on_init
hardware_interface::CallbackReturn on_init(const hardware_interface::HardwareInfo &info) override
Initialization of the hardware interface from data parsed from the robot's URDF.
Definition: rrbot.cpp:31
```

--------------------------------

### Example YAML Parameter File for Force Torque Sensor Broadcaster

Source: https://control.ros.org/humble/index.html/doc/ros2_controllers/force_torque_sensor_broadcaster/doc/userdoc

Provides a complete example of a YAML parameter file for the `force_torque_sensor_broadcaster` controller, demonstrating how to set the `frame_id` parameter.

```YAML
test_force_torque_sensor_broadcaster:
  ros__parameters:

    frame_id:  "fts_sensor_frame"
```

--------------------------------

### RRBot Controller Terminal Output Example

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_8/doc/userdoc

Example output from the terminal where the RRBot launch file is started, showing command and state data for joints as the demo node sends commands.

```text
[ros2_control_node-1] [INFO] [1728857106.562714002] [controller_manager.resource_manager.hardware_component.system.RRBotTransmissionsSystemPositionOnly]: Command data:
[ros2_control_node-1]   joint1: 0.5 --> transmission1(R=2) --> actuator1: 1
[ros2_control_node-1]   joint2: 0.5 --> transmission2(R=4) --> actuator2: 2
[ros2_control_node-1] [INFO] [1728857106.762624114] [controller_manager.resource_manager.hardware_component.system.RRBotTransmissionsSystemPositionOnly]: State data:
[ros2_control_node-1]   joint1: 0.166196 <-- transmission1(R=2) <-- actuator1: 0.332392
[ros2_control_node-1]   joint2: 0.166196 <-- transmission2(R=4) <-- actuator2: 0.664784
```

--------------------------------

### ROS 2 Control Demos: Docker Installation - Build Image

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/doc/index

This snippet provides instructions to set up a workspace, clone the `ros2_control_demos` repository, and then build a Docker image named `ros2_control_demos` using the provided Dockerfile.

```bash
mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src
git clone https://github.com/ros-controls/ros2_control_demos
cd ros2_control_demos
docker build . -t ros2_control_demos -f Dockerfile/Dockerfile
```

--------------------------------

### ROS 2 Control Demos: Source Installation - Download Repositories

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/doc/index

This snippet prepares the workspace for a source build, clones the `ros2_control_demos` repository, and imports additional repositories defined in the `.repos` file. It also updates `rosdep` and `apt-get`. An alternative `vcs import` command for development versions is mentioned in the source documentation.

```bash
mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src
git clone https://github.com/ros-controls/ros2_control_demos
cd ~/ros2_ws/
vcs import src < src/ros2_control_demos/ros2_control_demos.$ROS_DISTRO.repos
rosdep update --rosdistro=$ROS_DISTRO
sudo apt-get update
```

--------------------------------

### Launch ROS2 Cart on Rail Examples

Source: https://control.ros.org/humble/index.html/doc/gz_ros2_control/doc/index

These commands launch different cart examples (position, velocity, effort) using `ros2 launch` from the `gz_ros2_control_demos` package. Each command starts a Gazebo simulation with a cart on a rail configured for a specific control mode.

```Shell
ros2 launch gz_ros2_control_demos cart_example_position.launch.py
ros2 launch gz_ros2_control_demos cart_example_velocity.launch.py
ros2 launch gz_ros2_control_demos cart_example_effort.launch.py
```

--------------------------------

### APIDOC: RRBotSystemPositionOnlyHardware Interface Export and Initialization

Source: https://control.ros.org/humble/index.html/doc/api/classros2__control__demo__example__9_1_1RRBotSystemPositionOnlyHardware

Documentation for `ros2_control_demo_example_9::RRBotSystemPositionOnlyHardware` methods for exporting command/state interfaces, getting clock/logger, and initialization.

```APIDOC
class ros2_control_demo_example_9::RRBotSystemPositionOnlyHardware:
  export_command_interfaces() override virtual:
    Returns: std::vector< hardware_interface::CommandInterface >
    Description: Exports all command interfaces for this hardware interface. The command interfaces have to be created and transferred according to the hardware info passed in for the configuration. Note the ownership over the state interfaces is transferred to the caller.
    Implements: hardware_interface::SystemInterface::export_command_interfaces

  export_state_interfaces() override virtual:
    Returns: std::vector< hardware_interface::StateInterface >
    Description: Exports all state interfaces for this hardware interface. The state interfaces have to be created and transferred according to the hardware info passed in for the configuration. Note the ownership over the state interfaces is transferred to the caller.
    Implements: hardware_interface::SystemInterface::export_state_interfaces

  get_clock() const inline:
    Returns: rclcpp::Clock::SharedPtr
    Description: Get the clock of the SystemInterface.

  get_logger() const inline:
    Returns: rclcpp::Logger
    Description: Get the logger of the SystemInterface.

  on_init(hardware_info: const hardware_interface::HardwareInfo &) override virtual:
    Description: Initialization of the hardware interface from data parsed from the robot's URDF.
    Parameters:
      hardware_info: structure with data from URDF.
    Returns:
      CallbackReturn::SUCCESS if required data are provided and can be parsed.
      CallbackReturn::ERROR if any error happens or data are missing.
    Reimplemented from: hardware_interface::SystemInterface::on_init
```

--------------------------------

### Start RRBot Multi-Interface System in ROS2

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_3/doc/userdoc

Launch the RRBot system with multiple interfaces. This command loads and starts the robot hardware, controllers, and opens RViz. It supports optional arguments to specify the initial robot controller, such as `forward_position_controller` or `forward_acceleration_controller`.

```bash
ros2 launch ros2_control_demo_example_3 rrbot_system_multi_interface.launch.py
```

--------------------------------

### Example Output: ROS 2 Control Hardware Components

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_5/doc/userdoc

Example output detailing the two hardware components: an `ExternalRRBotFTSensor` (type: sensor) and `RRBotSystemPositionOnly` (type: system), showing their active states and claimed command interfaces.

```shell
Hardware Component 1
        name: ExternalRRBotFTSensor
        type: sensor
        plugin name: ros2_control_demo_example_5/ExternalRRBotForceTorqueSensorHardware
        state: id=3 label=active
        command interfaces
Hardware Component 2
        name: RRBotSystemPositionOnly
        type: system
        plugin name: ros2_control_demo_example_5/RRBotSystemPositionOnlyHardware
        state: id=3 label=active
        command interfaces
                joint1/position [available] [claimed]
                joint2/position [available] [claimed]
```

--------------------------------

### API: Prepare Command Mode Switch

Source: https://control.ros.org/humble/index.html/doc/api/classhardware__interface_1_1ResourceManager

Prepares the hardware components for a new command interface mode, specifying interfaces to start and stop.

```APIDOC
bool prepare_command_mode_switch(const std::vector<std::string> &start_interfaces, const std::vector<std::string> &stop_interfaces)
  - Description: Prepare the hardware components for a new command interface mode.
```

--------------------------------

### Get the logger of the SensorInterface (C++ API)

Source: https://control.ros.org/humble/index.html/doc/api/external__rrbot__force__torque__sensor_8hpp_source

Retrieves the logger associated with the SensorInterface. This method is constant.

```APIDOC
ros2_control_demo_example_5::ExternalRRBotForceTorqueSensorHardware::get_logger
  rclcpp::Logger get_logger() const
  Returns: rclcpp::Logger
```

--------------------------------

### Example Mecanum Drive Controller Parameter Configuration (YAML)

Source: https://control.ros.org/humble/index.html/doc/ros2_controllers/mecanum_drive_controller/doc/userdoc

An example YAML configuration file demonstrating how to set various parameters for the ROS2 Mecanum Drive Controller, including reference timeout, wheel joint names, and kinematics offsets.

```YAML
test_mecanum_drive_controller:
  ros__parameters:
    reference_timeout: 0.9

    front_left_wheel_command_joint_name: "front_left_wheel_joint"
    front_right_wheel_command_joint_name: "front_right_wheel_joint"
    rear_right_wheel_command_joint_name: "back_right_wheel_joint"
    rear_left_wheel_command_joint_name: "back_left_wheel_joint"

    kinematics:
      base_frame_offset: { x: 0.0, y: 0.0, theta: 0.0 }
```

--------------------------------

### Launch Gazebo Classic Client

Source: https://control.ros.org/humble/index.html/doc/gazebo_ros2_control/doc/index

After starting the ROS2 demo container, this command launches the Gazebo Classic client on your local machine to visualize the simulation.

```bash
gzclient
```

--------------------------------

### Activate All Components (Deprecated)

Source: https://control.ros.org/humble/index.html/doc/api/resource__manager_8hpp_source

Activates all hardware components. This method is deprecated; users should now use the `hardware_components_initial_state` parameter structure for setup. It is retained for backward compatibility but its use is discouraged.

```C++
[[deprecated(
  "The method 'activate_all_components' is deprecated. "
  "Use the new 'hardware_components_initial_state' parameter structure to setup the "
  "components")]] void
activate_all_components()
```

--------------------------------

### Get the clock of the SensorInterface (C++ API)

Source: https://control.ros.org/humble/index.html/doc/api/external__rrbot__force__torque__sensor_8hpp_source

Retrieves a shared pointer to the clock associated with the SensorInterface. This method is constant.

```APIDOC
ros2_control_demo_example_5::ExternalRRBotForceTorqueSensorHardware::get_clock
  rclcpp::Clock::SharedPtr get_clock() const
  Returns: rclcpp::Clock::SharedPtr
```

--------------------------------

### Open RViz with RRBot Configuration

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_1/doc/userdoc

Sources the ROS 2 installation and opens RViz using a pre-defined configuration file for the RRBot. This allows for proper visualization of the robot model and its state.

```Bash
source /opt/ros/${ROS_DISTRO}/setup.bash
rviz2 -d src/ros2_control_demos/ros2_control_demo_description/rrbot/rviz/rrbot.rviz
```

--------------------------------

### API Documentation for RRBotSystemWithGPIOHardware Class Members

Source: https://control.ros.org/humble/index.html/doc/api/classros2__control__demo__example__10_1_1RRBotSystemWithGPIOHardware-members

Lists all members (methods and properties) of the `ros2_control_demo_example_10::RRBotSystemWithGPIOHardware` class, including inherited members from `hardware_interface::SystemInterface`.

```APIDOC
Class: ros2_control_demo_example_10::RRBotSystemWithGPIOHardware
  Inherits: hardware_interface::SystemInterface

  Methods:
    export_command_interfaces(): override
    export_state_interfaces(): override
    get_clock() const: inline
    get_logger() const: inline
    on_activate(const rclcpp_lifecycle::State &previous_state): override
    on_configure(const rclcpp_lifecycle::State &previous_state): override
    on_deactivate(const rclcpp_lifecycle::State &previous_state): override
    on_init(const hardware_interface::HardwareInfo &info): override

  Inherited Methods (from hardware_interface::SystemInterface):
    get_name() const: inline virtual
    get_state() const: inline
    perform_command_mode_switch(const std::vector< std::string > &, const std::vector< std::string > &): inline virtual
    prepare_command_mode_switch(const std::vector< std::string > &, const std::vector< std::string > &): inline virtual

  Properties:
    info_: protected (defined in hardware_interface::SystemInterface)
    lifecycle_state_: protected (defined in hardware_interface::SystemInterface)
```

--------------------------------

### APIDOC: DiffBotSystemHardware::write method

Source: https://control.ros.org/humble/index.html/doc/api/classros2__control__demo__example__2_1_1DiffBotSystemHardware-members

Writes hardware commands for the `ros2_control_demo_example_2::DiffBotSystemHardware` interface. This method is an `override` and is `virtual`.

```APIDOC
write(const rclcpp::Time &time, const rclcpp::Duration &period) override
```

--------------------------------

### C++ RRBotSystemPositionOnlyHardware::on_init Method

Source: https://control.ros.org/humble/index.html/doc/api/example__9_2hardware_2include_2ros2__control__demo__example__9_2rrbot_8hpp_source

Initializes the hardware interface using information parsed from the robot's URDF (Unified Robot Description Format). This method is crucial for setting up the hardware based on its configuration.

```APIDOC
ros2_control_demo_example_9::RRBotSystemPositionOnlyHardware::on_init(
  info: const hardware_interface::HardwareInfo &
)
Returns: hardware_interface::CallbackReturn
Description: Initialization of the hardware interface from data parsed from the robot's URDF.
```

--------------------------------

### API Reference: RRBotSystemPositionOnlyHardware::on_init Method

Source: https://control.ros.org/humble/index.html/doc/api/example__1_2hardware_2include_2ros2__control__demo__example__1_2rrbot_8hpp_source

Documents the `on_init` method, responsible for the initialization of the hardware interface. It parses data from the robot's URDF (`hardware_interface::HardwareInfo`) to set up the hardware component, returning a `CallbackReturn` status.

```APIDOC
ros2_control_demo_example_1::RRBotSystemPositionOnlyHardware::on_init(const hardware_interface::HardwareInfo &info)
  hardware_interface::CallbackReturn on_init(const hardware_interface::HardwareInfo &info) override
  Initialization of the hardware interface from data parsed from the robot's URDF.
```

--------------------------------

### API: Read current state from DiffBotSystemHardware

Source: https://control.ros.org/humble/index.html/doc/api/classros2__control__demo__example__2_1_1DiffBotSystemHardware

Documents the `read` method of `DiffBotSystemHardware`, which updates the exported state interfaces with data readings from the physical hardware. This method is called at the start of each control loop iteration to get the latest sensor and actuator states.

```APIDOC
Method: ros2_control_demo_example_2::DiffBotSystemHardware::read
Signature: hardware_interface::return_type read(const rclcpp::Time &time, const rclcpp::Duration &period) override virtual
Description: Read the current state values from the actuator. The data readings from the physical hardware has to be updated and reflected accordingly in the exported state interfaces. That is, the data pointed by the interfaces shall be updated.
Parameters:
  time: [in] const rclcpp::Time & - The time at the start of this control loop iteration
  period: [in] const rclcpp::Duration & - The measured time taken by the last control loop iteration
Returns: hardware_interface::return_type - return_type::OK if the read was successful, return_type::ERROR otherwise.
Implements: hardware_interface::SystemInterface
```

--------------------------------

### API Documentation for RRBotSystemWithGPIOHardware Class in ROS2 Control

Source: https://control.ros.org/humble/index.html/doc/api/example__10_2hardware_2include_2ros2__control__demo__example__10_2rrbot_8hpp_source

Documents the `RRBotSystemWithGPIOHardware` class, a virtual class for integrating complex systems into `ros2_control`, detailing its constructor, command/state interface exports, clock/logger access, and read/write operations. Also includes documentation for the `HardwareInfo` structure.

```APIDOC
Class: ros2_control_demo_example_10::RRBotSystemWithGPIOHardware
  Description: Virtual Class to implement when integrating a complex system into ros2_control.
  Source: system_interface.hpp:85, rrbot.hpp:35

  Methods:
    export_command_interfaces()
      Signature: std::vector< hardware_interface::CommandInterface > export_command_interfaces() override
      Description: Exports all command interfaces for this hardware interface.
      Source: rrbot.cpp:169

    get_clock()
      Signature: rclcpp::Clock::SharedPtr get_clock() const
      Description: Get the clock of the SystemInterface.
      Source: rrbot.hpp:71

    read(const rclcpp::Time &time, const rclcpp::Duration &period)
      Signature: hardware_interface::return_type read(const rclcpp::Time &time, const rclcpp::Duration &period) override
      Description: Read the current state values from the actuator.
      Source: rrbot.cpp:224

    on_init(const hardware_interface::HardwareInfo &info)
      Signature: hardware_interface::CallbackReturn on_init(const hardware_interface::HardwareInfo &info) override
      Description: Initialization of the hardware interface from data parsed from the robot's URDF.
      Source: rrbot.cpp:30

    get_logger()
      Signature: rclcpp::Logger get_logger() const
      Description: Get the logger of the SystemInterface.
      Source: rrbot.hpp:65

    write(const rclcpp::Time &time, const rclcpp::Duration &period)
      Signature: hardware_interface::return_type write(const rclcpp::Time &time, const rclcpp::Duration &period) override
      Description: Write the current command values to the actuator.
      Source: rrbot.cpp:257

    export_state_interfaces()
      Signature: std::vector< hardware_interface::StateInterface > export_state_interfaces() override
      Description: Exports all state interfaces for this hardware interface.
      Source: rrbot.cpp:140

Structure: hardware_interface::HardwareInfo
  Description: This structure stores information about hardware defined in a robot's URDF.
  Source: hardware_info.hpp:106
```

--------------------------------

### Implementing the on_configure Method for Controller Setup

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_7/doc/userdoc

The `on_configure` method is called when the controller transitions to the inactive state, either upon its initial start or during a restart. This method is ideal for reading reconfigurable parameters and setting up essential components such as ROS publishers and subscribers.

```C++
controller_interface::CallbackReturn on_configure(const rclcpp_lifecycle::State &previous_state){
    // declare and get parameters needed for controller operations
    // setup realtime buffers, ROS publishers, and ROS subscribers
    // ...
  return CallbackReturn::SUCCESS;
}
```

--------------------------------

### Hardware Interface and Robot System API Reference

Source: https://control.ros.org/humble/index.html/doc/api/classros2__control__demo__example__7_1_1RobotSystem-members

Detailed API documentation for the `hardware_interface::SystemInterface` and `ros2_control_demo_example_7::RobotSystem` classes, including constructors, destructors, and member functions with their parameters.

```APIDOC
hardware_interface::SystemInterface
  set_state(const rclcpp_lifecycle::State &new_state)
    new_state: const rclcpp_lifecycle::State & - The new state to transition to.
  SystemInterface()
  SystemInterface(const SystemInterface &other) = delete
    other: const SystemInterface & - The object to copy from (copy constructor is deleted).
  SystemInterface(SystemInterface &&other) = default
    other: SystemInterface && - The object to move from (move constructor is defaulted).
  ~SystemInterface() = default

ros2_control_demo_example_7::RobotSystem
  write(const rclcpp::Time &, const rclcpp::Duration &) override
    param1: const rclcpp::Time & - The current time.
    param2: const rclcpp::Duration & - The duration since the last update.
```

--------------------------------

### Configure ROS 2 PID Controller Parameters with Various Gains

Source: https://control.ros.org/humble/index.html/doc/ros2_controllers/pid_controller/doc/userdoc

This YAML configuration file demonstrates various settings for the ROS 2 PID controller, including `dof_names`, `command_interface`, `reference_and_state_interfaces`, and `gains` for different joints. It shows examples with angle wraparound, feedforward gain, and dual interface setups for multiple joints and command interfaces.

```YAML
test_pid_controller:
  ros__parameters:
    dof_names:
      - joint1

    command_interface: position

    reference_and_state_interfaces: ["position"]

    gains:
      joint1: {p: 1.0, i: 2.0, d: 3.0, i_clamp_max: 5.0, i_clamp_min: -5.0}

test_pid_controller_angle_wraparound_on:
  ros__parameters:
    dof_names:
      - joint1

    command_interface: position

    reference_and_state_interfaces: ["position"]

    gains:
      joint1: {p: 1.0, i: 2.0, d: 3.0, i_clamp_max: 5.0, i_clamp_min: -5.0, angle_wraparound: true}

test_pid_controller_with_feedforward_gain:
  ros__parameters:
    dof_names:
      - joint1

    command_interface: position

    reference_and_state_interfaces: ["position"]

    gains:
      joint1: {p: 0.5, i: 0.0, d: 0.0, i_clamp_max: 5.0, i_clamp_min: -5.0, feedforward_gain: 1.0}

test_pid_controller_with_feedforward_gain_dual_interface:
  ros__parameters:
    dof_names:
      - joint1
      - joint2

    command_interface: velocity

    reference_and_state_interfaces: ["position", "velocity"]

    gains:
      joint1: {p: 0.5, i: 0.3, d: 0.4, i_clamp_max: 5.0, i_clamp_min: -5.0, feedforward_gain: 1.0}
      joint2: {p: 0.5, i: 0.3, d: 0.4, i_clamp_max: 5.0, i_clamp_min: -5.0, feedforward_gain: 1.0}
```

--------------------------------

### ROS2 Control Hardware Interface API Reference

Source: https://control.ros.org/humble/index.html/doc/api/classros2__control__demo__example__10_1_1RRBotSystemWithGPIOHardware-members

This snippet provides a structured overview of the API for `hardware_interface::SystemInterface` and `ros2_control_demo_example_10::RRBotSystemWithGPIOHardware`. It includes method signatures, constructors, destructors, and macro definitions relevant to implementing and interacting with hardware components in ROS2 Control.

```APIDOC
Class: ros2_control_demo_example_10::RRBotSystemWithGPIOHardware
  - Macro: RCLCPP_SHARED_PTR_DEFINITIONS(RRBotSystemWithGPIOHardware)
  - Method: read(const rclcpp::Time &time, const rclcpp::Duration &period) override
  - Method: write(const rclcpp::Time &time, const rclcpp::Duration &period) override

Class: hardware_interface::SystemInterface
  - Method: set_state(const rclcpp_lifecycle::State &new_state)
  - Constructor: SystemInterface()
  - Constructor: SystemInterface(const SystemInterface &other)=delete
  - Constructor: SystemInterface(SystemInterface &&other)=default
  - Destructor: ~SystemInterface()=default
```

--------------------------------

### Compiling and Testing ROS 2 Controller

Source: https://control.ros.org/humble/index.html/doc/ros2_controllers/doc/writing_new_controller

Provides the `colcon` commands for building and testing a ROS 2 controller package. It emphasizes sourcing the `setup.bash` file after compilation to ensure the new controller is discoverable and loadable via `pluginlib`.

```Bash
colcon build <controller_name_package>
source install/setup.bash
colcon test <controller_name_package>
```

--------------------------------

### List Hardware Components Verbose

Source: https://control.ros.org/humble/index.html/doc/ros2_control_demos/example_10/doc/userdoc

This command lists all loaded hardware components with verbose details. It provides information such as the component's name, type, plugin name, current state, and all available command and state interfaces.

```bash
ros2 control list_hardware_components -v
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.