Week 1-2: Introduction to ROS2

This is how far we will get by the end of this course:

In the first half of the course we'll learn how to simulate mobile robots, sensors, actuators. How to do mapping localization and navigation.

In the second half of the course we'll learn about the simulation of robotic arms with direct and inverse kinematics.

Here you can see a short video about the final projects from the previous years:

Requirements for completing the course:

Detailed description and requirements of the final project can be found on this link.

Short summary:

Registration deadline for projects: week 4
Submission deadline: week 14 - Project teams should consist of 3, maximum 4 members. - The project submission will take place live (on Teams) in 15+5 minutes - The project documentation should be in Markdown format on GitHub (no PPT required!)

Available real robots at the department:

Table of Contents

1. What is ROS(2)?
2. Required softwares
3. Basics of ROS2
   3.1. Running some examples
   3.2. Create a colcon workspace
   3.3. Let's write the simplest possible hello_world in python
   3.4. Create a python publisher
   3.5. Create a C++ publisher
   3.6. Create a python subscriber
   3.7. Create a C++ subscriber
   3.8. Launchfiles
   3.9. Remap
4. Parameters
   4.1. Set the parameter from a launchfile
   4.2. A more advanced example for setting parameters
5. Services
   5.1. Service server
   5.2. Service client
   5.3. Use services and parameters with turtlesim
6. Recap
   6.1. Useful Linux commands
   6.2. Useful ROS2 commands

What is ROS(2)?

ROS, or Robot Operating System, is an open-source framework designed to facilitate the development of robotic applications. It provides a collection of tools, libraries, and conventions that simplify the process of designing complex robot behaviors across a wide variety of robotic platforms.

ROS was initially developed in 2007 by the Stanford Artificial Intelligence Laboratory and continued by Willow Garage, with the goal of providing a common platform for research and development in robotics. The primary motivation was to create a standard framework that could support a broad range of robotic applications, promote code reuse, and foster collaboration within the robotics community.

Key reasons for ROS development include:

• Standardization: Creating a common platform that simplifies the integration of different hardware and software components.
• Modularity: Enabling the development of modular and reusable software components (nodes) that can be easily shared and adapted for various robotic systems.
• Community Collaboration: Encouraging collaboration among researchers and developers, resulting in a vast collection of tools and libraries.

Transition to ROS 2

ROS 2 was developed to address the limitations of ROS 1 and meet the growing demands for industrial and commercial robotics applications. The development began around 2014 and aimed to enhance the capabilities of ROS, particularly in areas such as security, real-time performance, and support for multi-robot systems. In practice, the biggest difference is in the underlying middleware, ROS1 uses a custom transport layer and message-passing system that was not designed for real-time or distributed applications (see ROS1's roscore).

The latest ROS1 release is ROS Noetic which was intended to be used on Ubuntu 20.04. It goes to EOL in May, 2025 together with Ubuntu 20.04.

Required softwares

Ubuntu 24.04 LTS

In the course we'll use ROS2 Jazzy Jalisco, which requires Ubuntu 24.04 for the smoothest operation.

You have a couple of options, but the most recommended is the native installation of the operating system - external SSD, dual boot, etc.

1) Native install, the most recommended way. You will learn how to set up the environment, there won't be difficulties with GPU acceleration and many more advantages. 2) Windows 11 WSL2 (Windows Subsystem Linux), see instructions. It's a straightforward way if you want to use within Windows environment. You can still learn how to set up the environment but can be more challenging with GUI applications and 3D acceleration. 3) Virtual machine, VMware fusion is now free for personal use. Less flexible than WSL2 on Windows 11 but works well on macOS. 3D acceleration can be challenging. 4) Docker container. First it might look an easy way to use any ROS distribution on any host operating system, but it's getting more and more challenging if we need GUI applications, 3D acceleration and can be confusing for beginners how to work within the container. You might miss some important experience with setting up the environment if using a pre-configured container image. I only recommend this way for experienced Docker users. 5) Using an online environment e.g. The Construct. It looks promising that you don't have to install any special software, but you won't gain experience with setting up the environment. It can be difficult to cherry pick the software versions you need and accessing GUI applications through the web interface is a poor experience.

The options 1 and 2 are the most practical and preferred ways to use ROS. In an exotic case, if you want to run Ubuntu 24.04 and ROS2 Jazzy on macOS and Apple silicon this is a very good tutorial.

Pro tip if you want to mount directories from your host system into your guest Ubuntu 24.04 running in VMware fusion, more details on this link: bash /usr/bin/vmhgfs-fuse .host:/BME/ROS2-lessons /home/david/ros2_ws/src/ROS2-lessons -o subtype=vmhgfs-fuse,allow_other

Visual Studio Code

The recommended code editor during the course is Visual Studio Code, but it's up to your choice if you want to go with your different editor. Depending on your Ubuntu install method you might install it natively on Ubuntu, in your virtual environment or on your host operating system.

Recommended extensions to install: - Markdown All in One - C/C++ - Python - CMake Tools - Remote - SSH - if you work on physical robots, too - Remote - WSL - if you do the course using WSL2

GitHub and a git client

The course materials are available on GitHub, and the submissions of your final projects shall also use GitHub. You'll need a very good excuse why to use alternative git solutions like GitLab.

So I encourage everyone to register your GitHub accounts, and if you are there don't forget to sign up for the GitHub Student Developer Pack which gives you a bunch of powerful developer tools for free.

I recommend to use a graphical git client that can boost your experience with git, in my optinion the best one is GitKraken, which is not a free software, but you get the pro version as part of the GitHub Student Developr Pack! If you prefer using git as a cli tool then no worries, it's absoluetely all right.

Markdown

Markdown is not a standalone software but rather a lightweight, plain-text formatting language used to create formatted documents. It was created by John Gruber in 2004 with the goal of being easy to read and write, using simple syntax to style text, create lists, links, images, and more. It is widely used for writing documentation, readme files, and content for static websites.

Basic Markdown Syntax

• Headings: # Heading 1, ## Heading 2, etc.
• Bold: **bold text** or __bold text__
• Italic: *italic text* or _italic text_
• Lists:
  • Unordered: - Item or * Item
  • Ordered: 1. Item
  • Links: [Link text](URL)
  • Images: ![Alt text](Image URL)
  • Code: Inline code or code blocks using triple backticks (```)

GitHub Flavored Markdown (GFM)

GitHub Flavored Markdown (GFM) is a variant of Markdown used by GitHub to provide additional features and syntax that are not available in standard Markdown. It includes:

• Tables: | Column 1 | Column 2 | |----------|----------| | Row 1 | Data | | Row 2 | Data |
• Task lists: ```
  • [x] Task 1
  • [ ] Task 2 ```
• Strikethrough: ~~strikethrough text~~
• Syntax highlighting in a specific language: python def hello_world(): print("Hello, world!") ```
• Tables of Contents
• @mentions for users, references to issues, and pull requests using #number

Most of the tips and tricks that you might need for your own project documentation can be found in the source of this readme that you read right now, feel free to use any snippets from it!

A good terminal

It's up to your choice which terminal tool would you like to use, but I strongly recommend one that support multiple split windows in a single unified window, because we will use a lot of terminals! On Linux, I can recommend terminator:

In case you use WSL2, the built-in Windows terminal also support multiple panes and works really well!

And finally, install ROS2 Jazzy

ROS always had very good and detailed installed guides, it's not anything different for ROS2's Jazzy release. The installation steps can be found here, with Ubuntu 24.04 it can be installed simply through pre-built, binary deb packages.

After installing it we have to set up our ROS2 environment with the following command:

source /opt/ros/jazzy/setup.bash

By default, we have to run this command in every new shell session we start, but there is a powerful tool in Linux for such use cases. .bashrc file is always in the user's home directory and it is used for user-specific settings for our shell sessions. You can edit .bashrc directly in a terminal window with a basic text editor, like nano:

david@david-ubuntu24:~$ nano .bashrc

Here, you can add your custom user-specific settings in the end of the file, that will be executed every time you initiate a new shell session. I created an example gist that you can add to the end of your file and use it during the course.

ROS2 Jazzy has an even more detailed tutorial about setting up your environment, you can check it out, too!

If you run into the following error that your GPG keys expired: bash W: An error occurred during the signature verification. The repository is not updated and the previous index files will be used. GPG error: http://packages.ros.org/ros2/ubuntu noble InRelease: The following signatures were invalid: EXPKEYSIG F42ED6FBAB17C654 Open Robotics <info@osrfoundation.org> You can fix it by updating your keys: sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -o /usr/share/keyrings/ros-archive-keyring.gpg

Basics of ROS2

Running some examples

Your ROS2 install comes with a couple of good examples as you can also find it on the install page.

Let's try them!

The following command starts a simple publisher written in C++. A publisher is a node that i