How to Model a Robotic Arm With a URDF File – ROS 2

In this tutorial, I will show you how to model any robotic arm with a URDF (Unified Robot Description Format) file and then visualize that are using RViz, a 3D visualization tool for ROS 2.

The official tutorial for creating a URDF file is here on the ROS 2 website; but that tutorial only deals with a fictitious robot.

It is far more helpful to show you how to create a URDF file for a real-world robot, like the ones you will work with at your job or at school…like this one below, for example…the myCobot 280 by Elephant Robotics.

Within ROS 2, defining the URDF file of your robotic arm is important because it allows software tools to understand the robot’s structure, enabling tasks like simulation, motion planning, and sensor data interpretation. It’s like giving the robot a digital body that software can interact with.

I want you to get a lot of practice setting up different collaborative robotic arms. We will work with five popular brands.

myCobot 280 for Arduino by Elephant Robotics
UR3e by Universal Robots
Gen3 Lite Robot by Kinova Robotics
WidowX 250 Robot Arm 6DOF by Trossen Robotics
A0509 by Doosan Robotics

I will walk through all the steps below for the myCobot 280. If you want to see how to build the URDF files for the other robotic arm models, click on any of the links above to go to that separate tutorial.

Prerequisites

You understand what a joint and link are.
You have created a ROS 2 workspace.
You know what a ROS 2 package is.

Directions – myCobot 280 by Elephant Robotics

I will now show you how to create the URDF file for the myCobot 280 by Elephant Robotics. Below are some helpful reference links in case you want to learn more about this robotic arm.

Here is my GitHub repository for this robotic arm. All the files we will create in this tutorial are also stored there.

Create a Package

The first step is to create a ROS 2 package to store all your files.

Open a new terminal window, and create a new folder named mycobot_ros2.

cd ~/ros2_ws/src

mkdir mycobot_ros2

cd mycobot_ros2

Now create the package where we will store our URDF file.

ros2 pkg create --build-type ament_cmake --license BSD-3-Clause mycobot_description

Create a metapackage.

I discuss the purpose of a metapackage in this post.

ros2 pkg create --build-type ament_cmake --license BSD-3-Clause mycobot_ros2

cd mycobot_ros2

rm -rf src/ include/

gedit package.xml

Make your package.xml file look like this:

<?xml version="1.0"?>
<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
<package format="3">
  <name>mycobot_ros2</name>
  <version>0.0.0</version>
  <description>myCobot series robots by Elephant Robotics (metapackage).</description>
  <maintainer email="automaticaddison@todo.todo">Addison Sears-Collins</maintainer>
  <license>BSD-3-Clause</license>

  <buildtool_depend>ament_cmake</buildtool_depend>
  
  <exec_depend>mycobot_description</exec_depend>

  <test_depend>ament_lint_auto</test_depend>
  <test_depend>ament_lint_common</test_depend>

  <export>
    <build_type>ament_cmake</build_type>
  </export>
</package>

Add a README.md to describe what the package is about.

gedit README.md

I also recommend adding placeholder README.md files to the mycobot_ros2 folder as well as the mycobot_description folder.

Now let’s build our new package:

cd ~/ros2_ws

colcon build

Let’s see if our new package is recognized by ROS 2.

Either open a new terminal window or source the bashrc file like this:

source ~/.bashrc

ros2 pkg list

You can see the newly created package right there at the top.

Start the URDF File

Create a new urdf folder.

mkdir -p ~/ros2_ws/src/mycobot_ros2/mycobot_description/urdf/

cd mycobot_ros2

(if you are using Visual Studio Code, type the following…otherwise just create the XACRO file below)

code .

Create a new file inside the ~/ros2_ws/src/mycobot_ros2/mycobot_description/urdf/ folder called:

mycobot_280_urdf.xacro

XACRO files are like blueprints for URDF files, using macros and variables to simplify complex robot descriptions.

Imagine XACRO as the architect drawing up plans, and URDF as the final, ready-to-use construction document. Both represent the robotic arm, but XACRO offers more flexibility and organization.

Before a ROS tool or component can use the information in a XACRO file, it must first be processed (translated) into a URDF file. This step allows for the dynamic generation of robot descriptions based on the specific configurations defined in the XACRO file.

Now let’s create the following folder:

mkdir -p ~/ros2_ws/src/mycobot_ros2/mycobot_description/meshes/mycobot_280/

Mesh files are used to visually represent the geometric shape of the robot parts in simulations and visualizations. These files are typically in formats such as STL (Stereo Lithography – .stl) or COLLADA (.dae).

Mesh files define the 3D shapes of components such as links, which are visualized in tools like RViz (ROS visualization tool) and Gazebo (a robot simulation environment).

Now go to the Downloads folder, and let’s download two packages from GitHub which contain the mesh files we need.

cd ~/Downloads/

git clone https://github.com/elephantrobotics/mycobot_ros.git

cd mycobot_ros/mycobot_description/urdf/280_arduino/

dir

Inside here you can see the mesh files (.dae) and the corresponding .png files.

sudo apt-get update

sudo apt-get upgrade

sudo apt-get install rename

rename 's/joint/link/' *.dae

rename 's/joint/link/' *.png

dir

Copy all the .dae and .png files inside this folder into ~/ros2_ws/src/mycobot_ros2/mycobot_description/meshes/mycobot_280/

cp *.dae *.png ~/ros2_ws/src/mycobot_ros2/mycobot_description/meshes/mycobot_280/

cd ..

cd mycobot

cp G_base.dae ~/ros2_ws/src/mycobot_ros2/mycobot_description/meshes/mycobot_280/base_link.dae
cp gripper_base.dae ~/ros2_ws/src/mycobot_ros2/mycobot_description/meshes/mycobot_280/
cp gripper_left1.dae ~/ros2_ws/src/mycobot_ros2/mycobot_description/meshes/mycobot_280/
cp gripper_left2.dae ~/ros2_ws/src/mycobot_ros2/mycobot_description/meshes/mycobot_280/
cp gripper_left3.dae ~/ros2_ws/src/mycobot_ros2/mycobot_description/meshes/mycobot_280/
cp gripper_right1.dae ~/ros2_ws/src/mycobot_ros2/mycobot_description/meshes/mycobot_280/
cp gripper_right2.dae ~/ros2_ws/src/mycobot_ros2/mycobot_description/meshes/mycobot_280/
cp gripper_right3.dae ~/ros2_ws/src/mycobot_ros2/mycobot_description/meshes/mycobot_280/

Now go to the link#.dae files in ~/ros2_ws/src/mycobot_ros2/mycobot_description/meshes/mycobot_280/

Open every link#.dae file. Everywhere it says joint#.png, change that to link#.png (e.g. joint1.png -> link1.png).

Save the files.

Now let’s create our .xacro file for our myCobot 280 robotic arm.

cd  ~/ros2_ws/src/mycobot_ros2/mycobot_description/urdf/

sudo apt-get install gedit

gedit mycobot_280_urdf.xacro

Here is what the file should look like (you will be directed to the GitHub page for this file).

Now let’s configure the CMakeLists.txt for the mycobot_description package. Make sure it looks like this:

cmake_minimum_required(VERSION 3.8)
project(mycobot_description)

# Check if the compiler being used is GNU's C++ compiler (g++) or Clang.
# Add compiler flags for all targets that will be defined later in the 
# CMakeLists file. These flags enable extra warnings to help catch
# potential issues in the code.
# Add options to the compilation process
if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
  add_compile_options(-Wall -Wextra -Wpedantic)
endif()

# Locate and configure packages required by the project.
find_package(ament_cmake REQUIRED)

# Copy necessary files to designated locations in the project
install (
  DIRECTORY meshes urdf
  DESTINATION share/${PROJECT_NAME}
)

# Automates the process of setting up linting for the package, which
# is the process of running tools that analyze the code for potential
# errors, style issues, and other discrepancies that do not adhere to
# specified coding standards or best practices.
if(BUILD_TESTING)
  find_package(ament_lint_auto REQUIRED)
  # the following line skips the linter which checks for copyrights
  # comment the line when a copyright and license is added to all source files
  set(ament_cmake_copyright_FOUND TRUE)
  # the following line skips cpplint (only works in a git repo)
  # comment the line when this package is in a git repo and when
  # a copyright and license is added to all source files
  set(ament_cmake_cpplint_FOUND TRUE)
  ament_lint_auto_find_test_dependencies()
endif()

ament_package()

Be sure to add the meshes and urdf file of the package.

Build the package.

cd ~/ros2_ws/

colcon build

source ~/.bashrc

Visualize the URDF File

Let’s see the URDF file in RViz first.

sudo apt-get install ros-${ROS_DISTRO}-urdf-tutorial

All of this is a single command below.

ros2 launch urdf_tutorial display.launch.py model:=/home/ubuntu/ros2_ws/src/mycobot_ros2/mycobot_description/urdf/mycobot_280_urdf.xacro

By convention, the red axis is the x-axis, the green axis in the y-axis, and the blue axis is the z-axis.

You can use the Joint State Publisher GUI pop-up window to move the links around.

On the left panel under Displays, play around by checking and unchecking different options.

For example, under Robot Model, you can see how the mass is distributed for the robot arm by unchecking “Visual Enabled” and “Collision Enabled” and checking the “Mass” checkbox under “Mass Properties”.

You can also see what simulation engines will use to detect collisions when the robotic arm is command to go to a certain point.

Uncheck “Visual Enabled” under Robot Model and check “Collision Enabled.”

Open a new terminal window, and type the following command.

ros2 run tf2_tools view_frames

To see the coordinate frames, type:

evince your_file_name.pdf

To close RViz, press CTRL + C.

So we can quickly visualize our robot in the future, let’s add a bash command that will enable us to quickly see our URDF.

echo "alias elephant='ros2 launch urdf_tutorial display.launch.py model:=/home/ubuntu/ros2_ws/src/mycobot_ros2/mycobot_description/urdf/mycobot_280_urdf.xacro'" >> ~/.bashrc

To see it was added, type:

cat ~/.bashrc

I also have a bash alias called ‘build’ that will build your workspace when run. You can add this alias to the .bashrc file as follows:

echo "alias build='cd ~/ros2_ws && colcon build && source ~/.bashrc'" >> ~/.bashrc

Now source the .bashrc file.

source ~/.bashrc

Going forward, if you want to see your urdf, type this command in the terminal window:

elephant

Upload Your Work to GitHub (Optional)

At this stage, we have done a lot of work. You can create a GitHub repository to store your code to share it with the world.

That’s it!

Now that you’ve gained some experience building a URDF file from scratch, try building a URDF for other robotic arms. Follow the links at the beginning of this post for those tutorials.

How to Upload a ROS 2 Project to GitHub

***** Updated version of this blog post is posted here: How to Save Your ROS 2 Project on GitHub *****

In this tutorial, I will show you how to store your ROS 2 project in a repository on GitHub.

In case you’re not familiar with GitHub, GitHub is an online platform specifically designed for software development. It offers several key functionalities:

Version control: This allows developers to track changes made to code over time. Imagine it like a time machine for your code, letting you revert to previous versions if necessary.
Code storage: GitHub acts as a secure and centralized location to store and manage code projects. Think of it like a cloud storage specifically for your code.
Collaboration: Teams can work together on projects by sharing code, discussing changes, and merging different contributions seamlessly.
Open-source contribution: GitHub is a hub for open-source projects, where developers can publicly share their code, contribute to existing projects, and learn from others.

Prerequisites

You have created a ROS 2 workspace.
You have created a ROS 2 package.

I have created a ROS 2 workspace that has a folder called mycobot_ros2 (i.e. /home/ubuntu/ros2_ws/src/mycobot_ros2).

Inside the mycobot_ros2 folder, I have two ROS 2 packages, mycobot_description and mycobot_ros2. You can see the complete repository here on GitHub.

Directions

Install Git

The first thing you need to do is install Git. Open a new terminal window, and type:

sudo apt-get update

sudo apt-get install git

Check the git version you have.

git --version

Configure Git

Configure your git username and email.

git config --global user.name "John Doe"
git config --global user.email "johndoe@example.com"
git config --global init.defaultBranch main

Initialize Git

Move to inside your project folder.

cd  ~/ros2_ws/src/mycobot_ros2/

Initialize the folder as a Git repository by running:

git init

Add and Commit the Files to Your Local Repository

Add the files in your folder to the repository with the following command:

git add .

Commit your staged files to your local repository with:

git commit -m "Initial commit"

Create the Remote Repository on GitHub

Go to GitHub and log in.

Click on the “+” icon in the upper right corner and select “New repository.”

Name your repository, add a description (optional), and choose whether the repository will be public or private.

Click “Create repository.”

Link the Local Repository to the Remote Repository

After creating your repository on GitHub, you’ll get a URL for that repository. Link your local repository to GitHub with:

git remote add origin <repository-URL>

Generate your personal access token. Read about how to do this here.

Finally, push your code from your local repository to GitHub with:

git branch --set-upstream-to=origin/main main

The command git branch –set-upstream-to=origin/main main links your local branch named “main” with its corresponding remote tracking branch “origin/main” on GitHub. This establishes a connection between the two branches, making it easier to keep them in sync in the future.

git push origin main --force

Type your GitHub username and personal access token.

Now if you go back to GitHub, you can see your repository.

Let’s add our LICENSE file again.

Go to your repository’s main page on GitHub.

Click on the “Add file” button on the top right corner.

Choose “Create new file”.

In the file name field, type LICENSE or LICENSE.md (all uppercase).

Click on “Choose a license template”.

Click OK when it asks about unsaved changes.

On the left side of the page, review the available licenses and select the one you want to use.

You can optionally add your name, year, and any additional comments in the file content below the chosen license text.

Click Review and Submit.

Click “Commit changes” (twice) to create the license file and add it to your repository.

Now make sure we get these changes locally.

Open a terminal window, and type:

git branch --set-upstream-to=origin/main main

git fetch

git status

git pull

I want GitHub to ignore the .vscode/ folder in the future.

touch .gitignore

Open the .gitignore file in a text editor.

gedit .gitignore

Add the following line to the file:

.vscode/

Save and close the file. This line tells Git to ignore the .vscode directory, meaning any files or subdirectories within .vscode/ will not be tracked or committed.

git add .gitignore

git commit -m "Add .gitignore to exclude .vscode directory"

git push

git rm -r --cached .vscode

git commit -m "Stop tracking .vscode directory"

Remove the Need to Use a Username and Password

If you want to not have to use a username and password every time you run “git push”, you can use SSH keys. This page has the instructions on how to do that.

Here is the process…

Generate an SSH key pair (if you don’t already have one) by running:

ssh-keygen -t ed25519 -C "your_email@example.com"

When you get prompted for a password or saving location, just keep pressing Enter, which will accept the default.

Start the ssh-agent in the background.

eval "$(ssh-agent -s)"

Add your SSH private key to the ssh-agent:

ssh-add ~/.ssh/id_ed25519

Add the SSH public key to your Git server.

cat ~/.ssh/id_ed25519.pub

Copy the entire result to your clipboard by highlighting everything and copying it.

Go to your GitHub account “Settings” by clicking your profile icon in the upper right of the website.

Look for “SSH and GPG keys”.

Add a new SSH key, pasting the copied key there.

Go back to the main page of your repository on GitHub and find the SSH URL by clicking the green button labeled “Code”.

Copy the SSH URL that is in there.

Switch your repository’s remote URL to SSH by going to your Ubuntu Linux terminal window, and moving to the directory of your repository.

cd <path to your your local repository>

git remote set-url origin git@github.com:username/repository.git

That’s it!

Using SSH keys is a more secure and convenient method for machines where you regularly push changes, as it doesn’t require entering your credentials after the initial setup.

How to Create a ROS 2 C++ Subscriber – Iron

In this tutorial, we will go over how to create a C++ subscriber for ROS 2.

In ROS 2 (Robot Operating System 2), a C++ subscriber is a program (written in C++) that listens for messages being published on a specific topic.

Topics in ROS 2 are channels of communication named according to the type of information they carry, such as “/robot/speed” for speed information or “/camera/image” for vision information. Each subscriber in ROS 2 declares its interest in a particular topic and is programmed to react or process the messages received on that topic.

The official instructions for creating a subscriber are here, but I will walk you through the entire process, step by step.

We will be following the ROS 2 C++ Style Guide.

Let’s get started!

Prerequisites

You have created a ROS 2 workspace.
You have created a ROS 2 package.
You have Visual Studio code installed.
You have created a ROS 2 publisher.
All the code for the last few posts is stored here on GitHub.

Directions

Open a terminal, and type these commands to open VS Code.

cd ~/ros2_ws

code .

Write the Code

Go back to the Explorer (Ctrl + Shift + E).

Right-click on the src folder to create a new file called “minimal_cpp_subscriber.cpp”.

Type the following code inside minimal_cpp_subscriber.cpp:

/**
 * @file minimal_cpp_subscriber.cpp
 * @brief Demonstrates subscribing to string messages on a ROS 2 topic.
 *
 * Description: Demonstrates the basics of subscribing to messages within the ROS 2 framework. 
 * The core functionality of this subscriber is to display output to the terminal window
 * when a message is received over a topic.
 * 
 * -------
 * Subscription Topics:
 *   String message
 *   /topic_cpp - std_msgs/String
 * -------
 * Publishing Topics:
 *   None
 * -------
 * @author Addison Sears-Collins
 * @date 2024-02-15
 */

#include "rclcpp/rclcpp.hpp" // ROS 2 C++ client library for node creation and management
#include "std_msgs/msg/string.hpp" // Standard message type for string messages
using std::placeholders::_1; // Create a placeholder for the first argument of the function

/**
 * @class MinimalSubscriber
 * @brief Defines a minimal ROS 2 subscriber node.
 *
 * This class inherits from rclcpp::Node and demonstrates creating a subscriber and
 * subscribing to messages.
 */
class MinimalSubscriber : public rclcpp::Node
{
public:
    /**
     * @brief Constructs a MinimalSubscriber node.
     *
     * Sets up a subscriber for 'std_msgs::msg::String' messages on the "topic_cpp" topic.     * 
     */
    MinimalSubscriber() : Node("minimal_subscriber")
    {
        // Create a subscriber object for listening to string messages on 
        // the "topic_cpp" topic with a queue size of 10.
        subscriber_ = create_subscription<std_msgs::msg::String>
        (
            "/topic_cpp", 
            10, 
            std::bind(
                &MinimalSubscriber::topicCallback, 
                this, 
                _1
            )
        );	
    }

    /**
     * @brief This function runs every time a message is received on the topic.
     *
     * This is the callback function of the subscriber. It publishes a string message
     * every time a message is received on the topic.
     * 
     * @param msg The string message received on the topic
     * @return Void.
     */
    void topicCallback(const std_msgs::msg::String &msg) const
    {
        // Write a message every time a new message is received on the topic.
        RCLCPP_INFO_STREAM(get_logger(), "I heard: " << msg.data.c_str());

    }
	
private:
    // Member variables.
    rclcpp::Subscription<std_msgs::msg::String>::SharedPtr subscriber_; // The subscriber object.
};

/**
 * @brief Main function.
 *
 * Initializes the ROS 2 system and runs the minimal_subscriber node. It keeps the node
 * alive until it is manually terminated.
 */
int main(int argc, char * argv[])
{

  // Initialize ROS 2.
  rclcpp::init(argc, argv); 
  
  // Create an instance of the MinimalSubscriber node and keep it running.
  auto minimal_subscriber_node = std::make_shared<MinimalSubscriber>();
  rclcpp::spin(minimal_subscriber_node);

  // Shutdown ROS 2 upon node termination.
  rclcpp::shutdown(); 

  // End of program.
  return 0; 
}

Configure CMakeLists.txt

Now we need to modify the CMakeLists.txt file inside the package so that the ROS 2 system will be able to find the cost we just wrote.

Open up the CMakeLists.txt file that is inside the package.

Make it look like this:

cmake_minimum_required(VERSION 3.8)
project(cobot_arm_examples)

# Check if the compiler being used is GNU's C++ compiler (g++) or Clang.
# Add compiler flags for all targets that will be defined later in the 
# CMakeLists file. These flags enable extra warnings to help catch
# potential issues in the code.
# Add options to the compilation process
if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
  add_compile_options(-Wall -Wextra -Wpedantic)
endif()

# Locate and configure packages required by the project.
find_package(ament_cmake REQUIRED)
find_package(ament_cmake_python REQUIRED)
find_package(rclcpp REQUIRED)
find_package(rclpy REQUIRED)
find_package(std_msgs REQUIRED)

# Define a CMake variable named dependencies that lists all
# ROS 2 packages and other dependencies the project requires.
set(dependencies
  rclcpp
  std_msgs
)

# Add the specified directories to the list of paths that the compiler
# uses to search for header files. This is important for C++
# projects where you have custom header files that are not located
# in the standard system include paths.
include_directories(
  include
)

# Tells CMake to create an executable target named minimal_cpp_publisher
# from the source file src/minimal_cpp_publisher.cpp. Also make sure CMake
# knows about the program's dependencies.
add_executable(minimal_cpp_publisher src/minimal_cpp_publisher.cpp)
ament_target_dependencies(minimal_cpp_publisher ${dependencies})

add_executable(minimal_cpp_subscriber src/minimal_cpp_subscriber.cpp)
ament_target_dependencies(minimal_cpp_subscriber ${dependencies})

# Copy necessary files to designated locations in the project
install (
  DIRECTORY cobot_arm_examples scripts
  DESTINATION share/${PROJECT_NAME}
)

install(
  DIRECTORY include/
  DESTINATION include
)

# Install cpp executables
install(
  TARGETS
  minimal_cpp_publisher
  minimal_cpp_subscriber
  DESTINATION lib/${PROJECT_NAME}
)

# Install Python modules for import
ament_python_install_package(${PROJECT_NAME})

# Install Python executables
install(
  PROGRAMS
  scripts/minimal_py_publisher.py
  scripts/minimal_py_subscriber.py
  #scripts/example3.py
  #scripts/example4.py
  #scripts/example5.py
  #scripts/example6.py
  #scripts/example7.py
  DESTINATION lib/${PROJECT_NAME}
)

# Automates the process of setting up linting for the package, which
# is the process of running tools that analyze the code for potential
# errors, style issues, and other discrepancies that do not adhere to
# specified coding standards or best practices.
if(BUILD_TESTING)
  find_package(ament_lint_auto REQUIRED)
  # the following line skips the linter which checks for copyrights
  # comment the line when a copyright and license is added to all source files
  set(ament_cmake_copyright_FOUND TRUE)
  # the following line skips cpplint (only works in a git repo)
  # comment the line when this package is in a git repo and when
  # a copyright and license is added to all source files
  set(ament_cmake_cpplint_FOUND TRUE)
  ament_lint_auto_find_test_dependencies()
endif()

# Used to export include directories of a package so that they can be easily
# included by other packages that depend on this package.
ament_export_include_directories(include)

# Generate and install all the necessary CMake and environment hooks that 
# allow other packages to find and use this package.
ament_package()

Configure package.xml

Now we need to configure the package.xml file.

Open the package.xml file, and make sure it looks like this:

<?xml version="1.0"?>
<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
<package format="3">
  <name>cobot_arm_examples</name>
  <version>0.0.0</version>
  <description>Basic examples demonstrating ROS 2</description>
  <maintainer email="automaticaddison@example.com">Addison Sears-Collins</maintainer>
  <license>Apache-2.0</license>

  <!--Specify build tools that are needed to compile the package-->
  <buildtool_depend>ament_cmake</buildtool_depend>
  <buildtool_depend>ament_cmake_python</buildtool_depend>

  <!--Declares package dependencies that are required for building the package-->
  <depend>rclcpp</depend>
  <depend>rclpy</depend>
  <depend>std_msgs</depend>

  <!--Specifies dependencies that are only needed for testing the package-->
  <test_depend>ament_lint_auto</test_depend>
  <test_depend>ament_lint_common</test_depend>

  <export>
    <build_type>ament_cmake</build_type>
  </export>
</package>

Build the Workspace

cd ~/ros2_ws

colcon build

source ~/.bashrc

Run the Nodes

First run your publisher node.

ros2 run cobot_arm_examples minimal_cpp_publisher

Now run your subscriber node.

ros2 run cobot_arm_examples minimal_cpp_subscriber

An Important Notes on Subscribers and Publishers

In the example above, we published a string message to a topic named /topic_cpp using a C++ node, and we subscribed to that topic using a C++node.

ROS 2 is language agnostic, so we could have also used a Python node to the publishing and a C++ node to do the subscribing, and vice versa.

That’s it for now. Keep building!