How to Create and Execute Publisher and Subscriber Nodes in ROS

In this post, we will learn how to create and execute publisher and subscriber nodes in ROS using C++ and Python.

Table of Contents

Directions

How to Create a Publisher Node in ROS Using C++

If you don’t already have a package named “hello_world” set up, set that up now.

Once you have your package set up, you are ready to create a node. Let’s create our first node. This node will be a publisher node. A publisher node is a software program that publishes messages (i.e. data values) to a particular topic. Check out this post, if you need more clarification on what a publisher and a topic are.

Open up a new Linux terminal window. 

Type the following command to open the Linux text editor.

gedit

Insert the C++ code at this link at the ROS.org website into the text file. To understand what each piece of the code does, read this link.

10-publisher-nodeJPG

Save the file as talker.cpp in your catkin_ws/src/hello_world/src folder and close the window.

That’s all there is to it. Now, let’s create a subscriber node.

Return to Table of Contents

How to Create a Subscriber Node in ROS Using C++

We now need a program that subscribes to the data (i.e. “hello world” message) published by the talker. This node will be a subscriber node. A subscriber node is a software program that subscribes to messages (i.e. data values) on a particular topic. 

Open up a new Linux terminal window. 

Type the following command to open the Linux text editor.

gedit

Insert the C++ code at this link at the ROS.org website into the text file. To understand what each piece of the code does, read this link.

11-listener-cppJPG

Save the file as listener.cpp in your catkin_ws/src/hello_world/src folder and close the window.

You’re all set. Now, let’s create the executable.

Return to Table of Contents

How to Create the Executable for ROS C++ Nodes

Our two nodes have been created, but now we need to convert that source code written in C++ into an executable that our machine can understand. To do that, open a new terminal window, and navigate to your catkin_ws/src/hello_world/ folder.

cd catkin_ws/src/hello_world/

Type the dir command to see the list of files in that directory. One of these files is CMakeLists.txt. Open that file.

gedit CMakeLists.txt

Add these lines to the very bottom of your CMakeLists.txt file.

add_executable(talker src/talker.cpp)
target_link_libraries(talker ${catkin_LIBRARIES})
add_executable(listener src/listener.cpp)
target_link_libraries(listener ${catkin_LIBRARIES})

Move to the catkin_ws folder.

cd ~/catkin_ws

Build the nodes.

catkin_make
12-catkin-makeJPG

You should see a screen that look something like the image below, indicating that the executables were successfully built.

Now, open a new terminal window and go to the catkin_ws/devel/lib/hello_world/ folder.

cd catkin_ws/devel/lib/hello_world
13-listener-talker-executablesJPG

Type dir to see the files listed. You will see the listener and talker executables. Feel free to close the terminal window now.

Let’s execute the nodes. To do that, in a fresh terminal window launch ROS by typing:

roscore

In another window, start the talker node (i.e. Publisher Node) by typing:

rosrun hello_world talker

You should see numbered “hello world” messages printing to the screen.

14-hello-worldJPG

Now, let’s start the listener node (Subscriber Node). Open a new terminal window, and type:

rosrun hello_world listener
15-listener-nodeJPG

Finally, let’s see what ROS topics are currently active. In a new terminal window, type:

rostopic list
16-rostopic-listJPG

Let’s get a list of the nodes that are currently active.

rosnode list
17-rosnode-listJPG

Press CTRL+C at any time to stop the program from running.

Return to Table of Contents

How to Create a Publisher Node in ROS Using Python

Now that we’ve seen how we can create publisher and subscriber nodes using C++, let’s do the same thing using Python.

Open up a new Linux terminal window. 

Type the following command to open the Linux text editor.

gedit

Insert the Python code at this link at the ROS.org website into the text file. To understand what each piece of the code does, read this link.

Save the file as talker.py in your catkin_ws/src/hello_world/scripts folder and close the window.

Return to Table of Contents

How to Create a Subscriber Node in ROS Using Python

Open up a new Linux terminal window. 

Type the following command to open the Linux text editor.

gedit

Insert the Python code at this link at the ROS.org website into the text file. To understand what each piece of the code does, read this link.

Save the file as listener.py in your catkin_ws/src/hello_world/scripts folder and close the window.

Return to Table of Contents

How to Execute ROS Python Nodes

Open up a new terminal window.

Navigate to the catkin_ws/src/hello_world/scripts folder.

cd catkin_ws/src/hello_world/scripts

Make the files executable. Type each command twice, pressing Enter after each.

chmod +x talker.py
chmod +x talker.py
chmod +x listener.py
chmod +x listener.py
18-chmodJPG

In a new terminal window, launch ROS.

roscore

Open a new terminal window, and execute talker.py.

rosrun hello_world talker.py
19-talkerJPG

Open another terminal window and type:

rosrun hello_world listener.py
20-heard-hello-worldJPG

To stop the program, type CTRL+C.

Return to Table of Contents

Congratulations! We have covered a lot of ground. You now know how to build publisher and subscriber nodes using the two most common languages used in robotics, Python and C++.

How to Create a ROS Package

In this tutorial, we’ll learn how to create a ROS package. Software in ROS is organized into packages. Each package might contain a mixture of code (e.g. ROS nodes), data, libraries, images, documentation, etc. Here is the official ROS tutorial on how to create a ROS package. I will walk you through this process below.

Directions

Here is the syntax for creating a ROS package. Do not run this piece of code.

catkin_create_pkg <package_name> [depend1] [depend2] [depend3]

Now, open a new terminal window, and move to the source directory of the workspace you created. If you don’t already have a workspace set up, check out this tutorial.

cd ~/catkin_ws/src

Create a ROS package named ‘hello_world’. This package will have three dependencies (i.e. libraries the package depends on in order for the code inside the package to run properly): roscpp (the ROS library for C++), rospy (the ROS library for Python), and std_msgs (common data types that have been predefined in ROS … “standard messages”).

catkin_create_pkg hello_world std_msgs rospy roscpp
6-create-a-package

Type dir , and you will see that we now have a package named hello_world inside the source folder of the workspace. 

Change to the hello_world directory.

cd hello_world

Type:

dir
7-inside-src-folder

You can see that we have four files:

CMakeLists.txt: This text file contains the commands to compile the programs that you write in ROS. It also has the commands to convert your source code and other files into an executable (i.e. the code that your computer can run).

include: Contains package header files. You might remember when we wrote header files in the C++ tutorial…well this folder is where your header files would be stored.

src: This folder will contain the C++ source code. If you are doing a project in Python, you can create a new folder named scripts that will contain Python code. To create this new folder type:

mkdir scripts
8-make-directory-scripts

package.xml: This is an Extensible Markup Language (XML) file. An XML file is a text file written in a language (called XML) that is easy to read by both humans and computers. An XML file does not do anything other than store information in a structured way. 

Our package.xml file contains information about the hello_world package. You can see what is inside it by typing:

gedit package.xml
9-package-xml-file

That’s it! You’re all done.

How to Create a ROS Workspace

Before you start writing code in ROS, you need to create a workspace. A workspace is a set of directories (or folders) where you store related pieces of ROS code. The official name for workspaces in ROS is catkin workspaces. The word ‘catkin’ comes from the tail-shaped flower cluster found on willow trees (see photo below) — a reference to Willow Garage, the original developers of ROS. 

willow_catkins_blossom_bloom

The official instructions for creating a ROS workspace are at ROS.org, but I will walk you through the process below so you can see how it is done.

Directions

Open up a new terminal window (I’m assuming you are using ROS on Ubuntu Linux), and type the following commands to create and build at catkin workspace.

mkdir -p ~/catkin_ws/src
cd ~/catkin_ws/
catkin_make
1-catkin-workspace

Type the dir command, and you will see three folders inside of this directory: build, devel, and src.

2-dir-command

Now we need to source the setup.bash file. This file sets the path of the workspace so that packages and code inside the workspace can be found.

source devel/setup.bash
3-set-path

Make sure the workspace is properly overlayed by the setup script (which we ran above).

echo $ROS_PACKAGE_PATH
4-make-sure

So we don’t have to source the setup.bash file every time we open a new Linux terminal, let’s add the ~/catkin_ws/devel/setup.bash command to the .bashrc file. Open a new Linux terminal window.

Type the following command to edit the .bashrc text file:

gedit .bashrc

Add this line to the end of the .bashrc file:

source ~/catkin_ws/devel/setup.bash
5-edit-bashrc-file

That’s it! You’re all done. Just click Save and exit the text editor.