ROS 2

https://docs.ros.org/en/humble
Admin
The Robot Operating System (ROS) is a set of software libraries and tools for building robot...
Tokens:2,452,619
Snippets:29,174
Trust Score:9.5
Update:3 months ago
Show doc for...
Tokens:
Raw
### Launch the follower example

Source: https://docs.ros.org/en/humble/p/spinnaker_synchronized_camera_driver

Executes the follower example launch file for synchronized camera setups.

```bash
ros2 launch spinnaker_synchronized_camera_driver follower_example.launch.py
```

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

### Start the source-built driver

Source: https://docs.ros.org/en/humble/p/robotont_driver

Sources the local workspace setup file and launches the driver.

```bash
source install/local_setup.bash
ros2 launch robotont_driver driver_launch.py
```

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

### Build and Setup Commands

Source: https://docs.ros.org/en/humble/Tutorials/Intermediate/Tf2/Adding-A-Frame-Cpp.html

Commands to install dependencies, build the package, and source the environment.

```bash
$ rosdep install -i --from-path src --rosdistro humble -y
```

```bash
$ colcon build --packages-select learning_tf2_cpp
```

```bash
$ colcon build --merge-install --packages-select learning_tf2_cpp
```

```bash
$ . install/setup.bash
```

```batch
$ call install\setup.bat
```

```powershell
$ .\install\setup.ps1
```

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

### Launch simulation example

Source: https://docs.ros.org/en/humble/Tutorials/Advanced/Simulators/Webots/Installation-Ubuntu.html

Start a demo simulation using the ROS 2 launch command.

```bash
$ ros2 launch webots_ros2_universal_robot multirobot_launch.py
```

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

### Launch the WHILL examples

Source: https://docs.ros.org/en/humble/p/whill_examples

Execute the launch file to start the WHILL demo sequence.

```bash
ros2 launch whill_examples whill_examples_launch.py
```

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

### Build adi_iio Examples from Source

Source: https://docs.ros.org/en/humble/p/adi_iio/doc/Examples/00_introduction.html

Commands to build the examples using colcon. Ensure the adi_iio package is installed before running these commands.

```bash
export COLCON_WS=~/ros2_ws
cd $COLCON_WS

colcon build  \
    --symlink-install \
    --event-handlers console_cohesion+ \
    --base-paths ./src/iio_ros2/examples/
```

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

### Launch the scenario

Source: https://docs.ros.org/en/humble/p/example_scenario_control

Execute the launch file to start the scenario control example.

```bash
ros2 launch example_scenario_control example_scenario_control_launch.py
```

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

### Build and Run Examples

Source: https://docs.ros.org/en/humble/p/depthai/__README.html

Enables example compilation and provides instructions for executing a specific example.

```bash
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
```

```bash
cd build/examples
./MobileNet/rgb_mobilenet
```

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

### Build with examples

Source: https://docs.ros.org/en/humble/p/micro_ros_diagnostic_updater

Build command to enable the compilation of package examples.

```bash
colcon build --packages-select micro_ros_diagnostic_updater --cmake-args -DMICRO_ROS_DIAGNOSTIC_UPDATER_EXAMPLES=ON
```

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

### Complete CMakeLists.txt example

Source: https://docs.ros.org/en/humble/How-To-Guides/Migrating-from-ROS1/Migrating-CPP-Package-Example.html

A full example of a migrated CMakeLists.txt file.

```cmake
cmake_minimum_required(VERSION 3.14.4)
project(talker)
if(NOT CMAKE_CXX_STANDARD)
  set(CMAKE_CXX_STANDARD 17)
endif()
if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
  add_compile_options(-Wall -Wextra -Wpedantic)
endif()
find_package(ament_cmake REQUIRED)
find_package(rclcpp REQUIRED)
find_package(std_msgs REQUIRED)
add_executable(talker talker.cpp)
target_include_directories(talker PUBLIC
   "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
   "$<INSTALL_INTERFACE:include/${PROJECT_NAME}>")
target_link_libraries(talker PUBLIC
  rclcpp::rclcpp
  ${std_msgs_TARGETS})
install(TARGETS talker
  DESTINATION lib/${PROJECT_NAME})
ament_package()
```

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

### ClientSession Usage Example

Source: https://docs.ros.org/en/humble/p/ecal/generated/classecal__service_1_1ClientSession.html

Demonstrates the lifecycle of a ClientSession, including io_context setup, asynchronous service calls, and proper shutdown procedures.

```cpp
// Create an io_context and a work_guard object to keep it alive
auto io_context = std::make_shared<asio::io_context>();
asio::executor_work_guard<asio::io_context::executor_type> work_guard(io_context->get_executor());

// Creat a thread for the io_context
std::thread io_context_thread([&io_context]() { io_context->run(); });

// Create client sessions
auto client_session = ecal_service::ClientSession::create(io_context, ...)

// call a service asynchronously
client_session->async_call_service(...);

// DO STUFF

// Stop the client session
client_session->stop();

// Wait for the io_context to run out of work
io_context_thread.join();
```

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

### void start()

Source: https://docs.ros.org/en/humble/p/catch_ros2/generated/classCatch_1_1Timer.html

Starts the timer.

```APIDOC
## void start()

### Description
Starts the timer instance.
```

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

### start()

Source: https://docs.ros.org/en/humble/p/ecal/generated/classecal__service_1_1ServerSessionBase.html

Starts the server session.

```APIDOC
## virtual void start()

### Description
Initiates the server session operations.
```

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

### Start()

Source: https://docs.ros.org/en/humble/p/cartographer/generated/classcartographer_1_1cloud_1_1MapBuilderServerInterface.html

Starts the map builder server instance.

```APIDOC
### virtual void Start() = 0

Starts the map builder server.
```

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

### static void setup()

Source: https://docs.ros.org/en/humble/p/andino_firmware/generated/classandino_1_1App.html

Configures and initializes the application. This method should be invoked once during the startup sequence.

```APIDOC
## static void setup()

### Description
Configures and sets the application up. Meant to be called once at startup.
```

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

### Build nanoflann examples and tests

Source: https://docs.ros.org/en/humble/p/nanoflann

Commands to install dependencies and build the project examples and tests using CMake.

```bash
$ sudo apt-get install build-essential cmake libgtest-dev libeigen3-dev
$ mkdir build && cd build && cmake ..
$ make && make test
```

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

### Setup Entry Points

Source: https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Writing-A-Simple-Py-Service-And-Client.html

Configuration for the setup.py file to register the client node.

```python
entry_points={
    'console_scripts': [
        'service = py_srvcli.service_member_function:main',
        'client = py_srvcli.client_member_function:main',
    ],
},
```

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

### Run the example client

Source: https://docs.ros.org/en/humble/p/fadecandy_driver

Executes the provided example client script to verify LED control functionality.

```bash
ros2 run fadecandy_driver example_client
```

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

### Install libfranka 0.19.0 on Ubuntu 22.04

Source: https://docs.ros.org/en/humble/p/libfranka

Concrete example of installing libfranka version 0.19.0 on an Ubuntu 22.04 (Jammy) system.

```bash
wget https://github.com/frankarobotics/libfranka/releases/download/0.19.0/libfranka_0.19.0_jammy_amd64.deb
wget https://github.com/frankarobotics/libfranka/releases/download/0.19.0/libfranka_0.19.0_jammy_amd64.deb.sha256
sha256sum -c libfranka_0.19.0_jammy_amd64.deb.sha256
sudo dpkg -i libfranka_0.19.0_jammy_amd64.deb
```

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

### Complete package.xml example

Source: https://docs.ros.org/en/humble/How-To-Guides/Migrating-from-ROS1/Migrating-CPP-Package-Example.html

A full example of a migrated package.xml file.

```xml
<?xml version="1.0"?>
<?xml-model href="http://download.ros.org/schema/package_format2.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
<package format="2">
  <name>talker</name>
  <version>0.0.0</version>
  <description>talker</description>
  <maintainer email="gerkey@example.com">Brian Gerkey</maintainer>
  <license>Apache-2.0</license>
  <buildtool_depend>ament_cmake</buildtool_depend>
  <depend>rclcpp</depend>
  <depend>std_msgs</depend>
  <export>
    <build_type>ament_cmake</build_type>
  </export>
</package>
```

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

### Run Example Client

Source: https://docs.ros.org/en/humble/p/robosoft_openai

Execute the provided example client that sends an image and a prompt to the server.

```bash
ros2 run robosoft_openai example_client
```

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

### Execute Setup Script

Source: https://docs.ros.org/en/humble/p/turtlebot4_setup

Downloads and runs the automated setup script to install ROS 2 Humble and configure the TurtleBot 4 environment.

```bash
wget -qO - https://raw.githubusercontent.com/turtlebot/turtlebot4_setup/humble/scripts/turtlebot4_setup.sh | bash
```

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

### Build the library with tests and examples

Source: https://docs.ros.org/en/humble/p/depthai/__README.html

Configure and build the project with testing and example targets enabled.

```bash
cmake -S. -Bbuild -D'DEPTHAI_TEST_EXAMPLES=ON' -D'DEPTHAI_BUILD_TESTS=ON' -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
```

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

### Import Python module

Source: https://docs.ros.org/en/humble/How-To-Guides/Ament-CMake-Python-Documentation.html

Example of importing a function from the installed Python package.

```python
from my_project.my_script import my_function
```

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

### begin()

Source: https://docs.ros.org/en/humble/p/andino_firmware/generated/classandino_1_1PwmOut.html

Initializes the PWM output hardware.

```APIDOC
## void begin() const

### Description
Initializes the PWM output. This method must be implemented by derived classes.
```

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

### Add Entry Point to setup.py

Source: https://docs.ros.org/en/humble/Tutorials/Advanced/Recording-A-Bag-From-Your-Own-Node-Py.html

Registers the node as an executable in the package configuration.

```python
entry_points={
    'console_scripts': [
        'simple_bag_recorder = bag_recorder_nodes_py.simple_bag_recorder:main',
        'data_generator_node = bag_recorder_nodes_py.data_generator_node:main',
    ],
},
```

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

### Launch HWMON Example

Source: https://docs.ros.org/en/humble/p/adi_iio/doc/Examples/04_example_hwmon.html

Command to start the adi_iio node and the dell_precision_5530 node.

```bash
ros2 launch hwmon dell_precision_5530.launch.py
```

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

### begin()

Source: https://docs.ros.org/en/humble/p/andino_firmware/generated/classandino_1_1Motor.html

Initializes the motor hardware configuration.

```APIDOC
### void begin()

Initializes the motor.
```

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

### crazyflie_examples.hello_world.main()

Source: https://docs.ros.org/en/humble/p/crazyflie_examples/crazyflie_examples.hello_world.html

Executes the takeoff, hover, and land sequence for a single Crazyflie.

```APIDOC
## main()

### Description
Executes a takeoff, hover, and land sequence for a single Crazyflie drone. This function is intended to be used to validate that the hardware configuration is correct.

### Signature
`crazyflie_examples.hello_world.main()`
```

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

### Verify RViz functionality

Source: https://docs.ros.org/en/humble/Tutorials/Advanced/Simulators/Webots/Installation-Windows.html

Install and run a SLAM example to test RViz visualization.

```bash
$ sudo apt install ros-humble-slam-toolbox
$ ros2 launch webots_ros2_tiago robot_launch.py rviz:=true slam:=true
```

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

### Launch Tutorial Examples

Source: https://docs.ros.org/en/humble/p/mujoco_ros2_control_demos

Commands to launch specific demonstration tutorials for the mujoco_ros2_control package.

```bash
# Tutorial 1 – Basic Robot
ros2 launch mujoco_ros2_control_demos 01_basic_robot.launch.py

# Tutorial 2 – MJCF Generation at Runtime
ros2 launch mujoco_ros2_control_demos 02_mjcf_generation.launch.py

# Tutorial 3 – PID Control
ros2 launch mujoco_ros2_control_demos 03_pid_control.launch.py

# Tutorial 4 – Transmissions
ros2 launch mujoco_ros2_control_demos 04_transmissions.launch.py
```

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

### Build and Run Dynamixel-Workbench Examples

Source: https://docs.ros.org/en/humble/p/dynamixel_workbench_toolbox/__README.html

Compile the toolbox examples and execute the monitor application. Ensure the USB port permissions are set correctly before running.

```bash
$ cd ${YOUR_DOWNLOAD_PATH}/dynamixel_workbench/dynamixel_workbench_toolbox/examples
$ mkdir build && cd build
$ cmake ..
$ make
$ sudo chmod a+rw ${USB_PORT}
$ ./monitor
```

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

### Setup rmf_demos_panel

Source: https://docs.ros.org/en/humble/p/rmf_demos_panel

Install required Python dependencies and build the package using colcon.

```bash
python3 -m pip install flask-socketio
colcon build --packages-select rmf_demos_panel
```

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

### Build with examples enabled

Source: https://docs.ros.org/en/humble/p/micro_ros_diagnostic_bridge

Command to build the package including the provided examples.

```bash
colcon build --packages-select micro_ros_diagnostic_bridge --cmake-args -DMICRO_ROS_DIAGNOSTIC_BRIDGE_EXAMPLES=ON
```

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

### void init(Config config, const std::filesystem::path &pathToCmd)

Source: https://docs.ros.org/en/humble/p/depthai_v3/generated/classdai_1_1DeviceBase.html

Initializes the device using the provided configuration and a path to the command file.

```APIDOC
### void init(Config config, const std::filesystem::path &pathToCmd)

Initializes the device with a specific configuration and a path to the firmware command file.
```

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

### Start multiple devices

Source: https://docs.ros.org/en/humble/p/sick_scan_xd

Example of running multiple instances of sick_scan_xd with unique names and topics.

```bash
roslaunch sick_scan_xd sick_tim_7xx.launch nodename:=sick_tim_7xx_1 hostname:=192.168.0.1 cloud_topic:=cloud_1 &
roslaunch sick_scan_xd sick_tim_7xx.launch nodename:=sick_tim_7xx_2 hostname:=192.168.0.2 cloud_topic:=cloud_2 &
```

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

### begin()

Source: https://docs.ros.org/en/humble/p/andino_firmware/generated/classandino_1_1PwmOutArduino.html

Initializes the PWM output interface.

```APIDOC
## Method: begin()

### Description
Initializes the PWM output hardware or interface.
```

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

### Source ROS 2 Installation

Source: https://docs.ros.org/en/humble/p/sm_advanced_recovery_1

Source the ROS 2 Humble environment setup script.

```bash
source /opt/ros/humble/setup.bash
```

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

### begin()

Source: https://docs.ros.org/en/humble/p/andino_firmware/generated/classandino_1_1DigitalOut.html

Initializes the digital output hardware.

```APIDOC
### Method: begin()

#### Description
Initializes the digital output interface. This must be called before performing write operations.
```

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

### Add Parameters by Type

Source: https://docs.ros.org/en/humble/p/rclc_parameter

Examples for adding, setting, and getting boolean, integer, and double parameters.

```C
const char * parameter_name = "parameter_bool";
bool param_value = true;

// Add parameter to the server
rcl_ret_t rc = rclc_add_parameter(&param_server, parameter_name, RCLC_PARAMETER_BOOL);

// Set parameter value (Triggers `on_parameter_changed` callback, if defined)
rc = rclc_parameter_set_bool(&param_server, parameter_name, param_value);

// Get parameter value and store it in "param_value"
rc = rclc_parameter_get_bool(&param_server, "param1", &param_value);

if (RCL_RET_OK != rc) {
    ... // Handle error
    return -1;
}
```

```C
const char * parameter_name = "parameter_int";
int param_value = 100;

// Add parameter to the server
rcl_ret_t rc = rclc_add_parameter(&param_server, parameter_name, RCLC_PARAMETER_INT);

// Set parameter value
rc = rclc_parameter_set_int(&param_server, parameter_name, param_value);

// Get parameter value on param_value
rc = rclc_parameter_get_int(&param_server, parameter_name, &param_value);
```

```C
const char * parameter_name = "parameter_double";
double param_value = 0.15;

// Add parameter to the server
rcl_ret_t rc = rclc_add_parameter(&param_server, parameter_name, RCLC_PARAMETER_DOUBLE);

// Set parameter value
rc = rclc_parameter_set_double(&param_server, parameter_name, param_value);

// Get parameter value on param_value
rc = rclc_parameter_get_double(&param_server, parameter_name, &param_value);
```

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

### span<std::uint8_t> getOffsetData()

Source: https://docs.ros.org/en/humble/p/depthai_v3/generated/classdai_1_1OffsetMemory.html

Gets a mutable view of the data starting at the current offset.

```APIDOC
## span<std::uint8_t> getOffsetData()

### Description
Gets a mutable view of the data starting at the current offset.

### Returns
- **span<std::uint8_t>** - Span over the remaining bytes after the offset.
```

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

### Serve Documentation with Live-Reload

Source: https://docs.ros.org/en/humble/The-ROS2-Project/Contributing/Contributing-To-ROS-2-Documentation.html

Start a local server with automatic browser reloading for development.

```bash
$ make serve
```

```bash
$ make serve LIVE_HOST=127.0.0.1 LIVE_PORT=8080
```

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

### Build and install from source

Source: https://docs.ros.org/en/humble/p/libfranka

Install the package from the root directory after cloning the source.

```bash
pip install .
```

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

### Run talker-listener examples

Source: https://docs.ros.org/en/humble/Installation/Ubuntu-Install-Debs.html

Verifies the installation by running a C++ talker and a Python listener in separate terminals.

```bash
$ source /opt/ros/humble/setup.bash
$ ros2 run demo_nodes_cpp talker

```

```bash
$ source /opt/ros/humble/setup.bash
$ ros2 run demo_nodes_py listener

```

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

### Launch the AD7124-8 Buffered Scaled Example

Source: https://docs.ros.org/en/humble/p/adi_iio/doc/Examples/03_example_ad7124-8.html

Starts the adi_iio node and the ad7124_8_buffer_scaled node for buffered data monitoring.

```bash
ros2 launch ad7124_8 ad7124_8_buffer_scaled.launch.py
```

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

### Create action_tutorials_cpp package

Source: https://docs.ros.org/en/humble/Tutorials/Intermediate/Writing-an-Action-Server-Client/Cpp.html

Commands to initialize the package with necessary dependencies for action communication.

```bash
$ cd ~/ros2_ws/src
$ ros2 pkg create --dependencies action_tutorials_interfaces rclcpp rclcpp_action rclcpp_components -- action_tutorials_cpp
```

```bash
$ cd ~/ros2_ws/src
$ ros2 pkg create --dependencies action_tutorials_interfaces rclcpp rclcpp_action rclcpp_components -- action_tutorials_cpp
```

```bash
$ cd \dev\ros2_ws\src
$ ros2 pkg create --dependencies action_tutorials_interfaces rclcpp rclcpp_action rclcpp_components -- action_tutorials_cpp
```

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

### Example launch output

Source: https://docs.ros.org/en/humble/Tutorials/Intermediate/Launch/Creating-Launch-Files.html

Typical INFO logs displayed in the terminal when a launch file successfully starts nodes.

```text
[INFO] [launch]: Default logging verbosity is set to INFO
[INFO] [turtlesim_node-1]: process started with pid [11714]
[INFO] [turtlesim_node-2]: process started with pid [11715]
[INFO] [mimic-3]: process started with pid [11716]
```

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

### Launch RViz2 for visualization

Source: https://docs.ros.org/en/humble/Tutorials/Demos/dummy-robot-demo.html

Start the RViz2 visualization tool in a new terminal after sourcing the ROS 2 installation.

```bash
$ source <ROS2_INSTALL_FOLDER>/setup.bash
$ rviz2
```

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

### span<const std::uint8_t> getOffsetData() const

Source: https://docs.ros.org/en/humble/p/depthai_v3/generated/classdai_1_1OffsetMemory.html

Gets a read-only view of the data starting at the current offset.

```APIDOC
## span<const std::uint8_t> getOffsetData() const

### Description
Gets a read-only view of the data starting at the current offset.

### Returns
- **span<const std::uint8_t>** - Span over the remaining bytes after the offset.
```

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

### on_setup()

Source: https://docs.ros.org/en/humble/p/as2_map_server/generated/classas2__map__server__plugin__base_1_1MapServerBase.html

Virtual method to be implemented by derived classes for custom setup logic.

```APIDOC
## on_setup()

### Description
A virtual method intended to be overridden by subclasses to perform specific initialization tasks after the base setup is complete.
```

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

### Windows Build Instructions for libcaer

Source: https://docs.ros.org/en/humble/p/libcaer

A comprehensive guide for installing dependencies and building libcaer using MSYS2 and MinGW64.

```text
WINDOWS BUILD INSTRUCTIONS
==========================
We support building libcaer on the Windows platform by using the MinGW32/64 compilers
and the MSYS2 environment. The result is a static and a dynamic DLL, as well as the
appropriate header files, so that libcaer can be used in MinGW itself.

Visual Studio and the MSVC compiler are not supported out-of-the-box right now, to use
a DLL compiled by MinGW additional steps are necessary: http://www.mingw.org/wiki/MSVC_and_MinGW_DLLs

Following are detailed step-by-step instructions to install the required
components and get everything building, we use MinGW64 here for the
64-bit Windows platform, if you want to build for 32-bit Windows, just replace all
mentions of 'x86_64' with 'i686'. Whenever you want to install a package, use
the MSYS2 shell, while to build code, use the MinGW32/64 shells!

1) Get MSYS2 from https://msys2.github.io/ and download the appropriate installer.
Follow the instructions to install the system and update its packages. During the
system package upgrade, ignore any heap mismatch errors, and follow what the last
warning tells you to do (close the shell). The base system upgrade seems to break
the Start Menu shortcuts, so from now on start MSYS2 by going to its directory
'C:\msys64\' and double-clicking on 'msys2_shell.cmd'.

2) Install MinGW GCC: pacman -S mingw-w64-x86_64-gcc

3) Install Make/CMake: pacman -S make mingw-w64-x86_64-cmake

4) Install pkg-config: pacman -S mingw-w64-x86_64-pkg-config

5) Install libusb: pacman -S mingw-w64-x86_64-libusb

6) Place the libcaer source in a location easily accessible to MSYS2. We usually
put the source code into 'C:\msys64\home\libcaer\' and use TortoiseGit
(https://tortoisegit.org/) or git from the MSYS2 shell (pacman -S git) to get it.

7) Switch to the MinGW build shell, double-click on 'mingw64.exe' in 'C:\msys64\'.

8) Switch to the libcaer checkout directory: cd /home/libcaer/

9) Configure, run CMake: cmake -G "MSYS Makefiles" -DCMAKE_INSTALL_PREFIX=/mingw64 .

10) Build, run Make: make

11) Install: make install

Congratulations, you now have a working libcaer on Windows! The output from that
last 'make install' will have told you exactly where all the DLLs and header
files are located on the file-system. You can now try building one of the
examples in the examples/ directory to verify functionality.
```

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

### Install Dependencies and Launch Notebook

Source: https://docs.ros.org/en/humble/Tutorials/Advanced/ROS2-Tracing-Trace-and-Analyze.html

Install the bokeh visualization library and launch the callback duration analysis notebook.

```bash
$ pip3 install bokeh
$ jupyter notebook ~/tracing_ws/src/tracetools_analysis/tracetools_analysis/analysis/callback_duration.ipynb
```

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

### Run ROS 2 communication examples

Source: https://docs.ros.org/en/humble/Installation/Alternatives/macOS-Development-Setup.html

Verify the installation by running a C++ talker and a Python listener in separate terminals.

```bash
$ ros2 run demo_nodes_cpp talker
```

```bash
$ ros2 run demo_nodes_py listener
```

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

### Remapping node name, namespace, and topic

Source: https://docs.ros.org/en/humble/How-To-Guides/Node-arguments.html

Example of starting a node with a custom name, namespace, and remapped topic name.

```bash
$ ros2 run demo_nodes_cpp talker --ros-args -r __ns:=/demo -r __node:=my_talker -r chatter:=my_topic
```

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

### Configure Setup Entry Point

Source: https://docs.ros.org/en/humble/Tutorials/Advanced/Recording-A-Bag-From-Your-Own-Node-Py.html

Add the node entry point to the setup.py file for console script execution.

```python
entry_points={
    'console_scripts': [
        'simple_bag_recorder = bag_recorder_nodes_py.simple_bag_recorder:main',
    ],
},
```

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

### Setup Manual Linting Environment

Source: https://docs.ros.org/en/humble/p/crocoddyl/__CONTRIBUTING.html

Clone the required linter repository and install necessary dependencies for manual code formatting.

```bash
git clone git@github.com:Gepetto/linters.git
sudo apt install clang-format-6.0
pip install --user flake8 isort yapf
```

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

### Build the example_simulation package

Source: https://docs.ros.org/en/humble/p/example_simulation

Use colcon to build the package and its dependencies.

```bash
colcon build --packages-up-to example_simulation
```

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

### Get laser model (Deprecated)

Source: https://docs.ros.org/en/humble/p/launch_pal

Example usage of the deprecated robot_utils to retrieve a laser model based on the robot name.

```python
robot_name = 'tiago'
laser_model_arg = get_laser_model(robot_name)
```

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

### setup

Source: https://docs.ros.org/en/humble/p/depthai_ros_driver_v3/generated/classdepthai__ros__driver_1_1dai__nodes_1_1sensor__helpers_1_1ImagePublisher.html

Initializes the image publisher by creating publishers, the image converter, and the camera info manager.

```APIDOC
## void setup(std::shared_ptr<dai::Device> device, const utils::ImgConverterConfig &convConf, const utils::ImgPublisherConfig &pubConf)

### Description
Sets up the image publisher, including creating the necessary ROS2 publishers, image converter, and camera info manager. It also initializes the queue and adds a callback if not synced.
```

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

### Log Session Boundaries

Source: https://docs.ros.org/en/humble/p/log_view

Example of the separator lines used to mark the start and end of a session within the persisted log files.

```text
-------- Session Started At 2026-05-04 09:15:00 --------
-------- Recording Ended At 2026-05-04 09:47:23 --------
```

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

### Create setup.cfg file

Source: https://docs.ros.org/en/humble/How-To-Guides/Migrating-from-ROS1/Migrating-Python-Package-Example.html

Commands to create the setup.cfg file across different operating systems.

```bash
$ touch setup.cfg
```

```bash
$ touch setup.cfg
```

```bash
$ type nul > touch setup.cfg
```

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

### Setup Virtual Environment

Source: https://docs.ros.org/en/humble/The-ROS2-Project/Contributing/Contributing-To-ROS-2-Documentation.html

Create and activate a Python virtual environment for documentation builds.

```bash
$ python3 -m venv ros2doc  # create venv
$ source ros2doc/bin/activate  # activate venv
```

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

### Stream Frames and Get Depth in C++

Source: https://docs.ros.org/en/humble/p/librealsense2

Uses the rs2::pipeline API to start streaming and calculate the distance to the center pixel.

```cpp
#include <librealsense2/rs.hpp>
#include <iostream>

int main() {
    rs2::pipeline p;                 // Top-level API for streaming & processing frames
    p.start();                       // Configure and start the pipeline

    while (true) {
        rs2::frameset frames = p.wait_for_frames();        // Block until frames arrive
        rs2::depth_frame depth = frames.get_depth_frame(); // Get depth frame
        if (!depth) continue;

        int w = depth.get_width(), h = depth.get_height();
        float dist = depth.get_distance(w/2, h/2);         // Distance to center pixel
        std::cout << "The camera is facing an object " << dist << " meters away\r";
    }
}
```

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

### Launch SICK device with roslaunch

Source: https://docs.ros.org/en/humble/p/sick_scan_xd

Example command to start a SICK MRS6124 device using the provided launch file and hostname parameter.

```bash
roslaunch sick_scan_xd sick_mrs_6xxx.launch hostname:=192.168.0.25
```

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

### Final setup.py configuration

Source: https://docs.ros.org/en/humble/How-To-Guides/Migrating-from-ROS1/Migrating-Python-Package-Example.html

The complete setup.py file including the new entry_points configuration.

```python
from setuptools import setup

package_name = 'talker_py'

setup(
    name=package_name,
    version='1.0.0',
    packages=['talker_py'],
    package_dir={'': 'src'},
    install_requires=['setuptools'],
    zip_safe=True,
    data_files=[
        ('share/ament_index/resource_index/packages',
            ['resource/' + package_name]),
        ('share/' + package_name, ['package.xml']),
    ],
    maintainer='Brian Gerkey',
    maintainer_email='gerkey@example.com',
    description='The talker_py package',
    license='BSD',
    entry_points={
        'console_scripts': [
            'talker_py_node = talker_py:main',
        ],
    },
)
```

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

### Finalized setup.py configuration

Source: https://docs.ros.org/en/humble/How-To-Guides/Migrating-from-ROS1/Migrating-Python-Package-Example.html

Complete setup function call with all required metadata.

```python
setup(
    name=package_name,
    version='1.0.0',
    install_requires=['setuptools'],
    zip_safe=True,
    packages=['talker_py'],
    package_dir={'': 'src'},
    maintainer='Brian Gerkey',
    maintainer_email='gerkey@example.com',
    description='The talker_py package',
    license='BSD',
)
```

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

### Migrate eCAL 5 Service Server Implementation

Source: https://docs.ros.org/en/humble/p/ecal/doc/rst/versions/6.0/migration_guide.html

Example of the legacy eCAL 5 service server setup using AddEventCallback and AddMethodCallback.

```cpp
#include <ecal/ecal_server.h>

// ...

eCAL::CServiceServer server("service_name");

server.AddEventCallback(eCAL_Server_Event::server_event_connected, [](const char * name_, const struct eCAL::SServerEventCallbackData * data_) {
  // Process event data
});

server.AddMethodCallback("method_name", "req_type", "resp_type", [](const std::string& method_, const std::string& req_type_, const std::string& resp_type_, const std::string& request_, std::string& response_) {
  // Process method call
});

// ...
```

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

### Start the classic node

Source: https://docs.ros.org/en/humble/p/sick_safetyscanners2

Launch the driver using the standard launch file.

```bash
ros2 launch sick_safetyscanners2 sick_safetyscanners2_launch.py
```

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

### Identify ROS 1 package installation error

Source: https://docs.ros.org/en/humble/How-To-Guides/Using-ros1_bridge-Jammy-upstream.html

Example of the dependency error encountered when the ROS 2 apt repository conflicts with ROS 1 packages.

```bash
$ apt install ros-core-dev
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
Some packages could not be installed. This may mean that you have
requested an impossible situation or if you are using the unstable
distribution that some required packages have not yet been created
or been moved out of Incoming.

The following information may help to resolve the situation:

The following packages have unmet dependencies:
 ros-core-dev : Depends: catkin but it is not installable
E: Unable to correct problems, you have held broken packages.
```

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

### Build the package

Source: https://docs.ros.org/en/humble/Tutorials/Intermediate/RViz/Marker-Points-and-Lines/Marker-Points-and-Lines.html

Command to build the tutorial package.

```bash
$ colcon build --packages-select visualization_marker_tutorials
```

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

### Build and run examples, tests, and benchmarks

Source: https://docs.ros.org/en/humble/p/crocoddyl/__README.html

Commands to execute tests and specific benchmarks from the build directory.

```bash
cd build
make test
make -s examples-quadrupedal_gaits INPUT="display plot" # enable display and plot
make -s benchmarks-cpp-quadrupedal_gaits INPUT="100 walk" # number of trials ; type of gait
```

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

### Install Debug Symbols

Source: https://docs.ros.org/en/humble/p/camera_ros/__README.html

Install dbgsym packages for binary installations to enable GDB debugging.

```bash
sudo apt install ros-$ROS_DISTRO-libcamera-dbgsym ros-$ROS_DISTRO-camera-ros-dbgsym
```

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

### Configuring setup.py Metadata

Source: https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Using-Parameters-In-A-Class-Python.html

Setting package metadata and console script entry points for the node.

```python
maintainer='YourName',
maintainer_email='you@email.com',
description='Python parameter tutorial',
license='Apache License 2.0',
```

```python
entry_points={
    'console_scripts': [
        'minimal_param_node = python_parameters.python_parameters_node:main',
    ],
},
```

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

### Install Python Bindings

Source: https://docs.ros.org/en/humble/p/depthai_v3/__README.html

Install the latest pre-released version of the library or use the provided installation script.

```bash
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
```

```bash
python3 examples/python/install_requirements.py on the branch you want to install
```

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

### Install libpointmatcher using scripts

Source: https://docs.ros.org/en/humble/p/libpointmatcher

Use the provided installer scripts to set up dependencies and install the library on Ubuntu.

```bash
cd libpointmatcher
bash libpointmatcher_dependencies_installer.bash
bash libpointmatcher_installer.bash --build-system-CI-install
```

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

### void init(Config config, const DeviceInfo &devInfo, const std::filesystem::path &pathToCmd)

Source: https://docs.ros.org/en/humble/p/depthai_v3/generated/classdai_1_1DeviceBase.html

Initializes a specific device using configuration, device information, and a path to the command file.

```APIDOC
### void init(Config config, const DeviceInfo &devInfo, const std::filesystem::path &pathToCmd)

Initializes a specific device identified by devInfo with the provided configuration and a path to the firmware command file.
```

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

### Download publisher node example

Source: https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Writing-A-Simple-Py-Publisher-And-Subscriber.html

Commands to download the minimal publisher example script for different operating systems.

```bash
$ wget https://raw.githubusercontent.com/ros2/examples/humble/rclpy/topics/minimal_publisher/examples_rclpy_minimal_publisher/publisher_member_function.py
```

```bash
$ curl -sk https://raw.githubusercontent.com/ros2/examples/humble/rclpy/topics/minimal_publisher/examples_rclpy_minimal_publisher/publisher_member_function.py -o publisher_member_function.py
```

```powershell
$ curl https://raw.githubusercontent.com/ros2/examples/humble/rclpy/topics/minimal_publisher/examples_rclpy_minimal_publisher/publisher_member_function.py -o publisher_member_function.py
```

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

### Start

Source: https://docs.ros.org/en/humble/p/cartographer/generated/classcartographer_1_1cloud_1_1LocalTrajectoryUploaderInterface.html

Starts the trajectory uploader.

```APIDOC
### virtual void Start() = 0

Starts the local trajectory uploader service.
```

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

### Launch the Webview

Source: https://docs.ros.org/en/humble/p/system_webview

Start the system webview nodes or customize the HTTP port.

```bash
ros2 launch system_webview main.launch.py
```

```bash
ros2 launch system_webview main.launch.py http_port:=8080
```

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

### start()

Source: https://docs.ros.org/en/humble/p/canopen_402_driver/generated/classros2__canopen_1_1ModeTargetHelper.html

Starts the mode operation.

```APIDOC
## bool start()

### Description
Initializes and starts the mode. Returns true if the operation was successful.
```

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

### Run launch_testing example

Source: https://docs.ros.org/en/humble/p/launch_testing/index.html

Execute a launch test file using the command-line interface.

```bash
launch_test test/launch_testing/examples/good_proc_launch_test.py
```

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

### start()

Source: https://docs.ros.org/en/humble/p/canopen_402_driver/generated/classros2__canopen_1_1DefaultHomingMode.html

Starts the homing procedure.

```APIDOC
## Method: start()

### Description
Initiates the homing sequence for the device.

### Returns
- **bool** - Returns true if the operation started successfully, false otherwise.
```

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

### Initial setup.py configuration

Source: https://docs.ros.org/en/humble/How-To-Guides/Migrating-from-ROS1/Migrating-Python-Package-Example.html

Initial structure for the setup function in setup.py.

```python
setup(
    packages=['talker_py'],
    package_dir={'': 'src'},
    install_requires=['setuptools'],
    zip_safe=True,
)
```

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

### Complete YAML Launch File with Substitutions

Source: https://docs.ros.org/en/humble/Tutorials/Intermediate/Launch/Using-Substitutions.html

A full example of a YAML-based launch file using arguments and substitutions.

```yaml
%YAML 1.2
---
launch:
  - arg:
      name: "turtlesim_ns"
      default: "turtlesim1"
  - arg:
      name: "use_provided_red"
      default: "False"
  - arg:
      name: "new_background_r"
      default: "200"

  - node:
      pkg: "turtlesim"
      namespace: "$(var turtlesim_ns)"
      exec: "turtlesim_node"
      name: "sim"
  - executable:
      cmd: 'ros2 service call $(var turtlesim_ns)/spawn turtlesim/srv/Spawn "{x: 5, y: 2, theta: 0.2}"'
  - executable:
      cmd: "ros2 param set $(var turtlesim_ns)/sim background_r 120"
  - timer:
      period: 2.0
      children:
        - executable:
            cmd: "ros2 param set $(var turtlesim_ns)/sim background_r $(var new_background_r)"
            if: '$(eval "$(var new_background_r) == 200 and $(var use_provided_red)")'
```

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

### start()

Source: https://docs.ros.org/en/humble/p/bno08x_driver/generated/classWatchdog.html

Starts the watchdog monitoring.

```APIDOC
## Watchdog::start

### Description
Starts the watchdog monitoring process.
```

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

### Install Python via Chocolatey

Source: https://docs.ros.org/en/humble/Installation/Alternatives/Windows-Development-Setup.html

Installs Python 3.8.3. Note that the installation expects Python to be located at C:\Python38.

```shell
choco install -y python --version 3.8.3
```

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

### Basic Workflow for ClassLoader

Source: https://docs.ros.org/en/humble/p/class_loader/__README.html

A complete example demonstrating the lifecycle of loading a library, querying classes, and executing plugin methods.

```cpp
#include <class_loader/class_loader.h>
#include "MyBase.h" //Defines class MyBase

int main()
{
  class_loader::ClassLoader loader("libMyLibrary.so");
  std::vector<std::string> classes = loader.getAvailableClasses<MyBase>();
  for(unsigned int c = 0; c < classes.size(); ++c)
  {
    boost::shared_ptr<MyBase> plugin = loader.createInstance<MyBase>(classes[c]);
    plugin->someMethod();
  }
}
```

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

### Install Wrapyfi ROS 2 Interfaces via APT

Source: https://docs.ros.org/en/humble/p/wrapyfi_ros2_interfaces

Install the package directly using APT for local Humble installations.

```bash
source /opt/ros/humble/setup.bash
sudo apt update
sudo apt install ros-humble-wrapyfi-ros2-interfaces
# test package: should return the service message types for ROS 2 Native objects
ros2 interface show wrapyfi_ros2_interfaces/srv/ROS2NativeObjectService
```

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

### Launch components using launch files

Source: https://docs.ros.org/en/humble/Tutorials/Intermediate/Composition.html

Automate the startup of multiple components using a launch file.

```bash
$ ros2 launch composition composition_demo.launch.py
```

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

### Install PlotJuggler ROS plugins via Debian

Source: https://docs.ros.org/en/humble/p/plotjuggler_ros

Use this command to install the PlotJuggler ROS plugins on a system with ROS installed.

```bash
sudo apt install ros-${ROS_DISTRO}-plotjuggler-ros
```
Tokens:
Raw