In this post, we will learn how to create a package in ROS 2 Foxy Fitzroy.

Software in ROS 2 is organized into packages. Each package might contain a mixture of code (e.g. ROS 2 nodes), data, libraries, images, documentation, etc. Every program you write in ROS 2 will need to be inside a package.

ROS 2 packages promote software reuse. The goal of a ROS 2 package is to be large enough to provide a specific useful functionality, but not so large and complicated that nobody wants to reuse it for their own project.

The official tutorial is located in the ROS 2 Foxy documentation, but we’ll run through the entire process step-by-step below.

You Will Need

In order to complete this tutorial, you will need:

• ROS 2 Foxy Fitzroy installed on Ubuntu Linux 20.04

Prerequisites

You have already created a workspace.

Create a Package

Open a new terminal window, and navigate to the src directory of your workspace:

cd ~/dev_ws/src

Now let’s create a package named my_package.

Type this command to create a C++ package:

ros2 pkg create --build-type ament_cmake my_package

Type this command to create a Python package:

ros2 pkg create --build-type ament_python my_package

Your package named my_package has now been created.

We also could have added dependencies (i.e. other software packages our code might depend on) when we created our package:

ros2 pkg create --build-type ament_python my_package --dependencies rclpy image_transport cv_bridge sensor_msgs std_msgs opencv2

Build a Package

Return to the root of your workspace:

cd ~/dev_ws/

Build all packages in the workspace.

colcon build

If you only want to build my_package and no other package in the workspace, you can type:

colcon build --packages-select my_package

That’s it! In the next tutorial, we will look at how to create publisher and subscriber nodes in ROS 2.

In this post, we will learn how to create a workspace for your ROS 2 application. A ROS 2 workspace is a directory that contains ROS 2 packages. 

Software in ROS 2 is organized into packages. Each package might contain a mixture of code (e.g. ROS 2 nodes), data, libraries, images, documentation, etc. Every program you write in ROS 2 will need to be inside a package.

ROS 2 packages promote software reuse. The goal of a ROS 2 package is to be large enough to provide a specific useful functionality, but not so large and complicated that nobody wants to reuse it for their own project.

The official tutorial is located in the ROS 2 Foxy documentation, but we’ll run through the entire process step-by-step below.

You Will Need

In order to complete this tutorial, you will need:

• ROS 2 Foxy Fitzroy installed on Ubuntu Linux 20.04

Prerequisites

It is helpful if you’ve completed this tutorial on the Turtlesim package in ROS 2, but it is not required.

Setup

Open a new terminal window, and create a new workspace. You can call it any name, but we will call it “dev_ws”, which stands for “development workspace.” Inside the workspace, we will create a source (i.e. src) directory. This is where your packages will go.

mkdir -p ~/dev_ws/src

Navigate to the workspace.

cd ~/dev_ws/src

Now, I want to add pre-existing packages into this folder. We will add the ros_tutorials repository to our workspace. It contains the following packages: roscpp_tutorials, rospy_tutorials, ros_tutorials, and turtlesim.

git clone https://github.com/ros/ros_tutorials.git -b foxy-devel

If you type the following command, you can see that the package is in the src folder inside the dev_ws workspace.

dir

To see what packages are inside this repository, type:

ls ros_tutorials

Resolve Package Dependencies

Since we just added a bunch of packages inside our workspace, we need to make sure each package has the software dependencies it needs in order to run.

Type the following command:

cd ~/dev_ws/

Resolve the dependencies.

rosdep install -i --from-path src --rosdistro foxy -y

We can see that all the dependencies our packages need are already installed.

Build Your Workspace

Let’s build the packages. Go to the root of the workspace.

cd ~/dev_ws/

Make sure colcon is installed. Colcon is a tool used to build software packages.

sudo apt update

sudo apt install python3-colcon-common-extensions

Press Y and Enter to complete the install.

Build the packages.

colcon build

Type the following command to see what new directories were created.

dir

Source the Workspace

Finally, we need to add the packages in this workspace to the current environment.

If you don’t have gedit installed, be sure to install it before you run the command above.

sudo apt-get install gedit

Open a new terminal window, and open your .bashrc file:

gedit ~/.bashrc

Add this line of code to the very bottom of the .bashrc file.

source ~/dev_ws/install/setup.bash

Save the file, and close it.

That’s it! In the next tutorial, we’ll take a look at how to create a package.

In this post, we will learn how to record and play back data that is published on topics in your ROS 2 application.

The official tutorial is located in the ROS 2 Foxy documentation, but we’ll run through the entire process step-by-step below.

You Will Need

In order to complete this tutorial, you will need:

• ROS 2 Foxy Fitzroy installed on Ubuntu Linux 20.04

Prerequisites

It is helpful if you’ve completed this tutorial on the Turtlesim package in ROS 2, but it is not required.

Setup

Open a new terminal window, and type the following command to launch the turtlesim simulation:

ros2 run turtlesim turtlesim_node

Open another terminal window, and launch the keyboard executable, which will enable us to navigate the robot using the keyboard.

ros2 run turtlesim turtle_teleop_key

Let’s create a new directory to save the data that is published to topics. ROS 2 calls these recordings “bag files”. In another terminal window, type the following commands:

mkdir bag_files

cd bag_files

Select a Topic You Want to Record

Let’s see what the currently active topics are.

ros2 topic list

Type the following command to see the relationship between active nodes and topics.

rqt_graph

You can see that the /teleop_turtle node (which is the keyboard-related node) publishes velocity commands to the /turtle1/cmd_vel topic. The /turtlesim node subscribes to these velocity commands, and the turtle moves around the screen accordingly.

Press CTRL + C in the terminal window to close rqt_graph.

Let’s explore the data that is being published to the /turtle1/cmd_vel topic. To do this, we need to use the ros2 topic echo command.

ros2 topic echo /turtle1/cmd_vel

Select the terminal window where you launched the turtle_teleop_key node.

Move the turtle around using the keyboard.

Return to the terminal window where you launched the ros2 topic echo /turtle1/cmd_vel command.

You should see a printout of the velocity commands.

Record Data

Let’s record the data that is published to the /turtle1/cmd_vel topic. Open a new terminal window, and navigate to the bag_files directory you created earlier in this tutorial.

cd bag_files

ros2 bag record /turtle1/cmd_vel

The data that is published to /turtle1/cmd_vel is now being recorded.

Go back to the teleop terminal window, and move the turtle around.

Go back to the terminal where you ran the ros2 bag command, and press CTRL + C to stop recording.

Let’s see if the bag file is recorded properly. Inside the bag_files directory on your computer, type the following command to see what files are inside.

dir

The format for the bag file is:

rosbag2_year_month_day-hour_minute_second

To see detailed information about this bag file type:

ros2 bag info <name_of_bag_file>

Play Back Data

Let’s play back the data that was recorded in the bag file.

Return to the teleop window.

Press CTRL + C to stop keyboard control.

Navigate to the bag_files directory, and play back the bag file you recorded earlier. Make sure you can see the turtlesim window.

ros2 bag play <name_of_bag_file>

You will see the turtle replicate the motion you commanded earlier. 

That’s it for bag files. Keep building!