How to Create and Set Up a ROS2 Workspace | ROS2 Tutorial

This tutorial demonstrates how to set up a ROS2 workspace by creating the necessary folder structure (src, build, install, log), installing colcon build tool, and creating custom packages with publisher and subscriber nodes. The process involves sourcing the ROS2 environment, building packages using colcon build, and running nodes using ros2 run to establish communication between publisher and subscriber nodes through topics.

This section covers configuring package.xml and CMakeLists.txt for building ROS 2 nodes, then executing them. In package.xml, add <depend>rclcpp</depend> and <depend>std_msgs</depend> to declare dependencies. In CMakeLists.txt: add find_package(rclcpp REQUIRED) and find_package(std_msgs REQUIRED), define executables with add_executable(publisher_node publisher.cpp) and add_executable(subscriber_node subscriber.cpp), add target_dependencies, and install targets with install(TARGETS publisher_node subscriber_node DESTINATION lib/${PROJECT_NAME}). Build the workspace using colcon build or colcon build --packages-select sub_pub. To run nodes, source the package's setup.bash file using 'source ~/ws/install/setup.bash', then run with 'ros2 run sub_pub publisher_node' and 'ros2 run sub_pub subscriber_node'. The publisher publishes messages and the subscriber receives and prints them, demonstrating the communication between nodes.

This tutorial demonstrates how to create publisher and subscriber nodes in C++ for ROS2 Humble, covering the complete workflow from system setup (Ubuntu 22.04, ROS2 Humble installation, workspace creation) to package configuration (package.xml and CMakeLists.txt dependencies), node implementation (publisher with timer-based message publishing and subscriber with message reception), and final testing. The core concepts include publisher nodes that send sensor data over topics and subscriber nodes that receive and process that data, with both nodes communicating through shared topic names.

This comprehensive workflow covers the entire process of developing ROS nodes: (1) Environment setup - creating project folders and adding them to the ROS workspace, (2) Package creation using catkin_create_pkg with appropriate dependencies, (3) Node file creation with executable permissions, (4) Publisher implementation using rospy.Publisher() to broadcast messages, (5) Subscriber implementation using rospy.Subscriber() with callback functions to receive messages, (6) Building the package with catkin_make, (7) Running nodes in separate terminals, (8) Verifying node communication using rosnode list command. The workflow demonstrates how publishers and subscribers communicate through topics in the ROS system.

After installation, users must configure the ROS environment by sourcing the setup script. To avoid repetitive sourcing, users add 'source /opt/ros/noetic/setup.bash' to their ~/.bashrc file for automatic loading. rosdep is then installed and configured using 'sudo rosdep init' and 'rosdep update' commands. rosdep enables downloading source trees for ROS packages and managing system dependencies required for compiling and running core ROS components.

Install ROS dependencies first: sudo apt-get install python3 python3-rosdep python3-rosinstall python3-rosinstall-generator python3-wstool build-essential. Initialize ROS with sudo apt-get install ros-noetic-desktop-full. Create a workspace directory (mkdir ~/catkin_ws) and install the desktop version using sudo apt-get install ros-noetic-desktop. Use wstool update to fetch remote repositories and wstool compile to compile all packages. Install system dependencies with rosdep install --from-paths src --ignore-src -r. Build all packages using catkin_make, which may take 1-2 hours and downloads approximately 184 packages.

rosdep is a ROS2 command-line tool that manages package dependencies by reading package.xml files, identifying required dependencies through rosdep keys, and checking against a central index to install necessary packages. The tool supports different dependency types: 'depend' for build and runtime dependencies, 'build_depend' for build-time only, 'build_export_depend' for external packages depending on this package, 'exec_depend' for runtime dependencies like shared libraries and executables, and 'test_depend' for test dependencies. To install dependencies, run 'rosdep install --from-paths src --ignore-src -y' from the workspace root, which checks package.xml files in the source folder and installs all required dependencies automatically.

To connect OAK-D Light to ROS, follow these steps: (1) Clone the GitHub repository (github.com/luxonis/depthai-ros); (2) Install system dependencies; (3) Build the DepthAI library from source; (4) Install ROS dependencies using rosdep; (5) Build the workspace with colcon. For Raspberry Pi, additional build options may be needed to prevent RAM exhaustion during compilation.

This section covers installing essential ROS dependencies and development tools. Users learn to install python-rosdep and python-rosdep3 dependencies using sudo apt install, then run rosdep update to initialize dependencies. The section also covers installing Terminator terminal emulator for multi-window management and Visual Studio Code as a lightweight code editor for C++ and Python development.

ROS launch files are XML-formatted files used to start multiple nodes simultaneously with configured parameters. They provide a convenient way to manage complex robot systems by defining all necessary nodes, their parameters, and launch configurations in one file. Launch files are stored in a 'launch' folder within each package. They allow you to specify ports, parameters, and node arguments in a declarative format, making it easy to reproduce and share robot configurations.

ROS 2 launch files differ from ROS 1 by being written in Python instead of XML. They use a generate_launch_description() function importing ROS 2 launch libraries. Launch files declare nodes to launch, specifying package names, executable files, node names, and optional namespaces. Namespaces help organize multiple instances of the same node type (like multiple robots in simulation). Launch files simplify running complex architectures with many nodes simultaneously, eliminating the need to run each node in separate terminals.

This section teaches creating Python launch files to orchestrate multiple ROS2 nodes. Students learn to import necessary libraries, retrieve absolute paths using get_package_share_directory(), load robot descriptions from Xacro files, and create Node objects with parameters. The tutorial demonstrates integrating three essential nodes: robot_state_publisher (computes forward kinematics and publishes TF transforms), joint_state_publisher_gui (provides interactive joint controls), and rviz2 (visualizes the robot). Students learn to combine these nodes into a single launch command, ensuring all components work together seamlessly for robot visualization and interaction.

This section covers ROS launch files for managing multiple nodes. Key concepts include: (1) Launch files are XML files that start multiple nodes with a single command; (2) Basic syntax: <node pkg='package' type='executable' name='node_name' output='screen'/>; (3) The 'pkg' specifies the package, 'type' is the executable, 'name' is the node name; (4) 'output' controls message display; (5) Launch files automatically start the ROS master if not running; (6) Multiple nodes can be defined in one launch file; (7) Launch files can include other launch files; (8) The 'anon' tag makes nodes anonymous, allowing multiple instances with unique names.

A ROS2 workspace organizes code into packages. First install colcon build tool with 'sudo apt install python3-colcon-common-extensions'. Create a workspace directory (e.g., 'mkdir -p ~/ros2_ws/src'). Use 'colcon build --symlink-install' to create a symlinked install that allows immediate testing without rebuilding. Add 'source ~/ros2_ws/install/setup.bash' to your bashrc for persistent environment setup. Create a new package with 'ros2 pkg create <package_name> --build-type ament_python' specifying the package name and build type.

The 'colcon build symlink install' command is an advanced build system that automatically points to the new install file. This means you don't need to rebuild the package every time you make changes to source files or launch files. The 'packages select' option is used when you have multiple packages in your workspace to specify which package to build.

When developing URDF files in ROS workspaces, three important practices should be followed: (1) Use colcon build with --symlink-install to automatically update changes without rebuilding every time, except when adding new files; (2) Quit and relaunch Robot State Publisher after each change to republish topics; (3) When visualizing with RViz, if changes aren't picked up immediately, use the reset button or toggle display items, and close/reopen if necessary.

This tutorial demonstrates how to build ROS2 packages using the colcon build tool, covering the complete workflow including workspace setup, installing colcon, cloning source code, configuring symlink installation to avoid file copying, executing the build command, sourcing the environment with 'source install/local_setup.bash', and running modified nodes like TurtleSim to verify successful package modification and execution.

This comprehensive workflow covers the entire process of developing a ROS package: (1) Understanding that a ROS package is an organized unit containing code for installation and execution, (2) Learning the standard package structure with CMakeLists.txt, include/, package.xml, and src/ directories, (3) Choosing between ament_python and ament_cmake build types based on whether you're using Python or C++ nodes, (4) Creating a package using the ros2 package create command with appropriate build type and node name, (5) Building the package using colcon build, (6) Installing with colcon build --symlink-install, (7) Sourcing the setup file, and (8) Running the node using ros2 run command.