Note: The concepts and CLI commands covered in this post are applicable across ROS 1 and 2. With that said, newer versions of ROS 1 and ROS 2 have integrated several packages (e.g. rqt\_console, rqt\_graph, rqt\_plot, etc.) as plugins into a parent rqt package. For the purposes of this post (i.e. covering different features in discrete steps), we've opted to use the older, but still supported, version of these CLI commands (e.g. rosrun rqt\_graph rqt\_graph vs. rqt). Check out the rqt docs for more information.

If you’ve kept up-to-date on tech’s latest robotics projects or tinkered around with your own robot kit, you’ve probably come across mentions of ROS.

At its core, the Robot Operating System (ROS) is an open source software suite built to simplify robotics development. It provides a collection of tools that runs everything from low-level device control, hardware abstractions, and package management. Due to its distributed design, users can pick and choose what parts of ROS to integrate into their own projects.

ROS was born in 2007, out of roboticists’ desire to more easily share resources and build upon each other’s work. These experts experienced firsthand how difficult it was building software for an increasingly diverse array of robots across a variety of platforms, and realized that no one person was equipped to tackle the field’s challenges alone. They hoped a deliberately modular framework like ROS would foster more collaborative robotics development and encourage code reuse among the community’s brightest minds.

Nearly 15 years after its conception, the ROS ecosystem now consists of tens of thousands of users worldwide, with applications ranging from COVID-19 disinfection robots to humanoid robotic hands. Its members have contributed cutting-edge libraries like map generation systems, navigation tools, and computer vision utilities, ensuring ROS’s continued relevance in the robotics world.

Basic concepts

ROS is a distributed framework of self-contained processes, or nodes, that discover and communicate with each other at runtime. Any given robot can have multiple nodes, each of which owns a subset of the robot’s tasks – one node may keep track of the robot’s velocity, another its steering angle, and still another its camera feed. All nodes are registered with the ROS master, a service registry that helps nodes locate each other.

Nodes communicate with each other by publishing or subscribing to messages on different channels of information, called topics. In this way, we can separate concerns into their respective nodes, while still empowering the robot to make complex decisions to execute a task. Nodes can be grouped into packages, which can then be easily shared and distributed among ROS users.

ROS nodes

Messages for a topic adhere to a fixed schema, called a message type. For example, one topic can contain messages with just position coordinates (geometry\_msgs/Point), another lidar point cloud data (sensor\_msgs/PointCloud), and still another text logs (std\_msgs/String).

A message type is defined via multiple fields, each with a specified type. For example, the geometry\_msgs/Pose message type consists of a position and orientation field, each of which have their own message type definitions:

message types

In summary, if nodes are like walkie-talkies that can communicate with each other, then topics are the channels that they broadcast audio on, and messages are the words that travel across these channels. In the same way that certain walkie-talkie channels are reserved for specific types of communication, each ROS topic is also reserved for messages that adhere to a specific type.

Useful commands

To get started using ROS, you will need to install it on your machine – ROS officially supports only Ubuntu, but you can get set up on Windows (Windows Subsystem for Linux) and MacOS (Docker for Mac) as well.

Before running any nodes, you must run roscore to spin up the following components:

ROS master – Service registry that helps nodes locate each other.

rosout – Logger for nodes' debugging output.

Parameter server – Server that allows nodes to store and retrieve parameters at runtime.

Now that you have your core ROS system up, you can use rosrun to find ROS packages that contain nodes you want to run.

For example, rosrun turtlesim turtlesim\_node will find the turtlesim ROS package and run its turtlesim\_node to bring up a simulation of swimming turtles on your desktop. Running rosrun rqt\_graph rqt\_graph will run that package’s rqt\_graph node to render a graph of your nodes connected by their publications and subscriptions.

Once you have a few nodes from different packages running, use rosnode to display information about your currently active nodes.

rosnode list – Lists current nodes.

rosnode info /your\_node\_name – Provides more information about a given node, including publications and subscriptions.

Once you have several nodes running, use rostopic to fetch information for any published topic.

rostopic echo /your\_topic – Displays messages published to a given topic.

rostopic list – Prints information about active topics.

rostopic type /your\_topic – Returns the message type for a topic.

rostopic pub /your\_topic package\_name/MessageType \[args] – Publishes data to a given topic with a specified message type.

Finally, use rosmsg to inspect messages and their types in more detail.

rosmsg list – Lists all message types.

rosmsg show package\_name/MessageType – Displays the fields for a given message type.

Useful packages

Given how extensive the ROS package environment is, it is easy to get overwhelmed by the selection. Here are a few popular packages that you can get started with:

rqt\_console – Provides a GUI for displaying and filtering ROS messages.

rqt\_graph – Visualizes the ROS computation graph – i.e. nodes and the topics they publish and subscribe to.

rqt\_image\_view – Displays camera images using image\_transport.

rqt\_plot – Plots numeric values on a 2D chart.

How Foxglove Studio fits in

While the ROS ecosystem offers an impressive array of features and services, it can be overwhelming to find, install, and run them all at once. ROS is also tightly bound to specific versions of Ubuntu, which introduces significant overhead for users interested in quickly viewing their data.

Studio has integrated many of ROS's visualization and debugging tools into one cross-platform desktop application, so that instead of memorizing package names and CLI commands, you can simply drag and drop a panel from our menu into your layout to start seeing results. For example, we've incorporated features similar to rqt\_console, rqt\_graph, rqt\_image\_view, and rqt\_plot, into our Raw Messages, Topic Graph, Image, and Plot panels, respectively.

Studio further streamlines visualization and debugging workflows by allowing users to load .bag files directly into the app – you no longer need to run roscore and rosbag in multiple terminals every time you want to inspect your data.

Studio panels vs ROS tools

We’re currently working to support user contributions to an extensions library, which will allow you to write your own custom plugins, build project-specific panels, and ultimately customize every aspect of your Studio development workflow.

To learn more about how Foxglove Studio can accelerate your robotics development, feel free to check out our docs or reach out to us directly in our Slack community.


If you're looking to get into robotics, there's no substitute for having a physical robot. It's the only way to get a feel for how sensors and actuators work together and to observe noisy real-world data coming in from sensors. Understanding how everything wires together is a fundamental part of the experience.

Fortunately, all-in-one robotics platforms are becoming increasingly accessible. If you want to focus on machine learning model training, Amazon's DeepRacer provides a ready-to-race autonomous RC car. A wide array of robotic arm kits are also available to purchase at newly reasonable prices. But for the novice roboticist looking for a complete robotics development experience, my current favorite is the Duckiebot.

What is Duckiebot?

Duckiebot

Duckiebot is unique, because it provides a deep dive into the real-world challenges and trade-offs that a roboticist would encounter, while still giving you the breadth of exposure to the entire end-to-end system. The Duckiebot kit consists of an embedded computer, a collection of sensors, and a 3D printed frame where you assemble everything by hand. The only tool required is a screwdriver (included in the kit), and you can build the robot in an afternoon.

To give your robot a place to drive, the Duckietown driving track kit comes with foam tiles and masking tape for arranging your tracks and personalizing your miniature town. Best of all, EdX launched a free online companion course (Self-Driving Cars with Duckietown) this year, taking you from a basic working knowledge of software development to a broad understanding of the disciplines involved in building robots.

Duckiebot tracks

One of the most fundamental challenges in robotics is system comprehension. Understanding what the robot is sensing (perception), what decisions it is making based on the perceived environment (planning), and how those decisions translate to actuator commands (controls) will be a core part of your development experience. For the Duckiebot, we have a few different tools at our disposal to start grappling with this comprehension challenge.

After you've assembled the hardware, flashed the SD card, and pressed the power button, you are rewarded with the first set of feedback: LEDs and a small display with system health metrics. The Duckiebot kit also provides a web interface with more health metrics and system status.

Duckiebot web UI

Getting to the next level of depth requires connecting directly to the robot's software. Like many robotics platforms, Duckiebot builds on top of the Robot Operating System (ROS) framework.

Though I won't go into a complete overview of ROS in this post, it's helpful to know that ROS-based robots are organized into modules called nodes. Nodes share information by publishing and subscribing to topics. Topics can be thought of as a stream of messages sharing a common data type, such as GPS coordinates, camera images, or steering angle commands.

To get a deeper look into what my Duckiebot is seeing or thinking, we need a tool that helps us inspect this underlying ROS data...

Visualizing ROS robots with Foxglove Studio

This is where Foxglove Studio comes in. Our team's long experience in robotics found that the existing tooling is often too rigid or limited to solve many common problems. Robotics tooling should be as accessible and easy to use as Unity3D is for game development, or as Photoshop is for photo editing.

Foxglove Studio uses a concept of panels, where different types of panels visualize information in different ways. These panels include camera feeds, time series plots, an extensible 3D view, a map, a connectivity graph, and more. You can arrange these panels into several dashboard views, or layouts, to investigate what your robot is doing.

Studio works on any platform (in my case, Windows), despite most ROS tools only supporting Linux. It also works out-of-the-box with ROS robots, so we can connect to Duckiebot (or any robot) by opening a new ROS connection to \<your-robot-host>.local - for me, this is darkwing.local.

Connecting with ROS

First, to inspect the published sensor data, let's add an Image panel to our layout to get a camera feed.

Image panel

Our duck is alive!

To get a high-level understanding of what software is running on the robot, you can add a Topic Graph panel, which shows ROS nodes and topics and how they are connected to each other.

Topic Graph panel

A lot is going on in the Duckiebot!

To start with a simplified overview, let's turn off the topics and services using the floating toolbar on the right.

Topic Graph panel, simplified

This view allows us to focus on what ROS nodes are currently running and how they connect to each other. Not all nodes are actively publishing data at the moment, since this is a brand new Duckiebot that hasn’t been fully developed into a self-driving robot yet.

Continue exploring

From here, you can add more panels and experiment with configuration options to see what other data you can visualize. As a first step, try using the Plot panel to create a time series plot of your Duckiebot’s time-of-flight sensor.

For a head start on experimentation, download this Foxglove Studio layout, which has been preconfigured with the following panels for easy Duckiebot analysis:

Data Source Info

Diagnostics – Summary

Image

Parameters

Plot

Log

Topic Graph

You can then import this layout file via the Layouts tab to load it into your Studio app.

Import Duckiebot layout

Congratulations on building and visualizing your first robot!

If you have any questions or ideas about robotics visualization, we'd love to chat with you in our Slack community.


Overview

Now that we've learned about the building blocks that make up a ROS system, let's apply our knowledge to see these components in action!

In this post, we'll cover how to install ROS on your computer, run your first ROS node, and interact with your data using Foxglove Studio. Whether you want to inspect your active nodes, chart values of interest, or publish ROS messages back to your stack, we'll cover a few of the many ways that Studio can enhance your data exploration experience and accelerate your robotics development.

Installing ROS

To get started with developing robotics software with ROS, you’ll first need to install it on your machine – whether your platform of choice is Ubuntu, macOS, or Windows.

Ubuntu

ROS officially supports Ubuntu, so it's easiest to get up and running on this platform – we recommend using Ubuntu 20.04 and following these instructions on their website to finish installation.

macOS or Windows

To install and run ROS on macOS or Windows, you must have access to a Linux system.

You can set one up by installing VirtualBox, a free and open source virtualization software package that allows you to run Linux on macOS or Windows. Parallels is another virtualization option, albeit paid, for macOS. Again, we recommend using Ubuntu 20.04 and following the same instructions for installing ROS to get started.

Running your first ROS node

Let's test that ROS was installed correctly by running our first ROS node. For this tutorial, we'll be launching turtlesim, a ready-to-launch ROS tutorial conveniently packaged as a node.

Open two terminal windows. In the first, start your ROS master:



In the second, start turtlesim:



If everything worked as expected, you should see logs similar to the following in your turtlesim window:



You should also see a window pop up, showing a tiny turtle peacefully floating in the middle of a vast ocean:

turtlesim

Now that we have our simulation running, let's interact with our turtle by controlling its movements in this ocean world. Open another terminal to run the teleop program, conveniently packaged as another node in the same turtlesim package:



Once running, the turtle\_teleop\_key node binds to your keyboard's arrow keys to determine what ROS messages to publish back to the /turtle1/cmd\_vel topic, which in turn controls where our turtle swims. You should see logs similar to the following in your terminal:



If we're focused on this terminal window and pressing arrow keys, we'll see our turtle following our directions, leaving behind a trail indicating where it has been.

turtlesim teleop

Using Foxglove Studio to interact with turtlesim

Now that we've been able to interact with our simulated turtle in a few ways with the turtlesim package, let's use Foxglove Studio to look behind the scenes at how this all works.

Download and open Studio – if this is your first time opening the app, you’ll be greeted with a Welcome layout and introductory message.

When you're ready, use the sidebar's Layouts tab to load a "New" empty layout.

new layout

To explore our turtlesim data , we must first connect Studio to our ROS system. You can use a native ROS connection within your Ubuntu environment (whether that's inside a virtual machine or not) – simply enter your ROS master's IP and port (e.g. "https\://localhost:11311") to connect to your ROS system.

connection tab

View the simulation's ROS graph

To start off our data exploration, let's try to understand the connections between the running processes within our ROS system. Conveniently enough, Studio has a panel for exactly this.

Use the sidebar's Add panel tab to drag and drop a Topic Graph panel into your layout. This panel will display an interactive graph visualization of the current node and topic topology.

add panel

If your connection was successful, your panel should come alive with a graph of your active nodes, the topics they are publishing and subscribing to, and the services attached to them:

turtlesim topic graph

Click and drag overlapping items in the graph to reposition them for easier viewing. We can see from this graph that our turtlesim node subscribes to the /turtle1/cmd\_vel topic and publishes the topics /turtle1/pose and /turtle1/color\_sensor.

Plot the turtle's position

Next, let's use Studio to investigate how the values in our published messages change over time.

From our ROS computation graph, we learned that our turtle publishes its position on the topic /turtle1/pose. Let's examine this topic using the Raw Messages and \[\_/docs/studio/panels/studio/panels/plot) panels.

Use the sidebar's Add panel tab to drag and drop both panels into your layout. In the Raw Messages panel, add /turtle1/pose to see the structure of the topic's messages:

raw messages

In the Plot panel, add /turtle1/pose.x and /turtle1/pose.y as the custom values to plot on your x-axis and y-axis, respectively. These topic message paths use message path syntax to drill down into the /turtle1/pose topic's x and y field values.

You should start to see the corresponding values populating your plot:

turtlesim plot

Go back to the turtle\_teleop\_key terminal and navigate our turtle around. As expected, you'll see the plot's values change as our turtle’s position changes.

Navigate the turtle

Finally, let's use Studio to publish messages back to our live ROS stack to test and debug our turtle simulation.

Earlier, we saw that the turtlesim node subscribes to the /turtle1/cmd\_vel topic, which contains our turtle's position. Knowing this, we should be able to publish navigation commands as ROS messages on this same topic, directly from within Studio, to control our turtle's position.

Add the aptly named Publish panel to your layout, for a convenient interface that allows you to draft and publish ROS messages on a given topic. Specify /turtle1/cmd\_vel as your topic to publish on, and select geometry\_msgs/Twist as your datatype. This will automatically populate the input field with a JSON message template that adheres to the geometry\_msgs/Twist schema.

Edit any of the message's field values, and click "Publish":

publish

Notice that manually publishing our edited message to /turtle1/cmd\_vel causes our turtle to move in the simulation! This in turn also affects the trajectory of our Plot panel's charted line.

Continue exploring with Foxglove Studio

While turtlesim may be a basic example of a ROS simulation, its foundational concepts mirror those present in more complex robotics systems in production – both real and simulated.

Simulation fills a crucial role in robotics development by enabling fast iteration without putting expensive hardware or human safety at risk. Many robotics companies simulate hundreds or thousands of times as much data as they generate in real life.

We hope this tutorial helped you review some foundational ROS concepts, see the role simulation plays in robotics development, and learn how Foxglove Studio can shed light on the inner workings of your robot (or in this case, simulated turtle). Since Studio integrates a variety of traditional robotics tools into one user-friendly app, we hope it helps you spend less time spinning up different tools and more time making your robot go.

For other ways to explore your robotics data, check out the rest of Studio's panels (e.g. Table, \[\_Data Source /docs/studio/panels/studio/panels/data-source-info), \_Node/docs/studio/panels), and stay tuned for our yet-unreleased extensions library.


Running Your First ROS Node on Ubuntu, macOS, or Windows

Read more:

Ready to get started?Download today on Linux, Windows, or macOS.