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.


At Foxglove, our team is intimately familiar with the challenges that come with robotics development. Existing tools – like data inspection applications, visualization programs, or debugging utilities – are often difficult to extend, clunky to use, and unsuitable for team collaboration, making for a painfully slow development workflow. We knew there was a better way to develop and debug our robots.

Our vision for Foxglove Studio is to ease these workflow pains and to accelerate robotics development for everyone. During our time working at Cruise, we experienced firsthand the problems that a fully integrated data visualization app could solve for a self-driving car company. We started Foxglove when we recognized the opportunity to build on top of this work and bring the same benefits to the wider robotics community.

Whether you’re building an autonomous car, a warehouse robot, or a self-driving rubber duck, we hope Foxglove Studio can help you spend less time fighting your tools, and more time focusing on what your robots are doing.

Why Foxglove Studio?

With Studio, our goal is to empower the robotics community to more easily make sense of their complex and noisy real-world data. We’ve taken the dizzying array of tools that robotics development usually requires, and integrated them into a single seamless developer experience.

Cross-platform

Foxglove Studio is conveniently packaged as a desktop app for Linux, Windows, and macOS. Making Studio a desktop application has unlocked some unique benefits. Because Studio is no longer limited by a sandboxed browser environment, it can connect directly to your ROS 1 stack via the native ROS connection. It also remains unconstrained by the performance restrictions that come with running huge amounts of robotics data through a browser.

Most ROS tools are only supported on Linux, but Foxglove Studio works cross-platform – even if your ROS stack is running on a different operating system, Foxglove Studio can communicate with your robot out-of-the-box.

Modular and extensible

Every view in Foxglove Studio is a customizable layout, made up of configurable data exploration tools called panels. Our panels can do everything from rendering interactive charts and 3D scenes, to displaying camera images and diagnostic logs. Using these modular panels, you can effectively build a custom robot control center from scratch to support your every possible workflow.

Here are some of our most commonly used panels:

3D panel – Display visualization markers (e.g. point clouds, bounding boxes, classification labels) in a 3D scene

Image panel – View images from your robot’s cameras

Plot panel – Plot values from incoming data in interactive charts

Raw Messages panel – Drill down into your incoming data

common panels

Most recently, we’ve added the following panels to tackle common robotics tasks:

Map panel – Display sensor\_msgs/NavSatFix messages as points on a map.

Parameters panel – Read and set rosparams from your connected ROS source.

Topic Graph panel – Render a graph showing the current ROS node and topic topology.

URDF Viewer panel – Use a Unified Robot Description Format (URDF) file to visualize your robot model.

new panels

Studio also provides a flexible Node Playground panel, where users can write custom data transformations in a code editor sandbox – to test out experimental outputs, or to create visualizations on the fly.

Open source

We’re partnering with our most important collaborators – our users – to build the future of Foxglove Studio.

Even with our best efforts to release and maintain tools that help every roboticist, we know a one-size-fit-all approach doesn’t cover every possible use case or meet every specific need. We don’t want Studio to limit your workflow options, or otherwise constrain how you can leverage our tools in the future.

That is why we’ll be implementing a public API for roboticists to build their own panels that encapsulate the project-specific functionality they need. This will go hand-in-hand with our extensions library, also in the works: in the same way Visual Studio Code has a rich ecosystem of plugins, we want Studio users to be able to browse a library of user-contributed extensions build to customize every aspect of the in-app experience. These changes will empower roboticists with any niche development needs to contribute their own custom tools that plug and play within the Studio ecosystem.

We’re also looking to integrate with new data formats beyond ROS 1. Please reach out with any data protocols or serialization formats you would like Studio to support.

Stay in touch

We hope this post helped introduce you to the world of Foxglove Studio. At Foxglove, our North Star is to streamline how you explore and extract insights from your robotics data. We hope Studio helps lower the barrier to entry for understanding your robot – on your journey from prototype to polished product.

We’re thrilled you’ve stumbled upon our community, and we hope you get involved! Let us know what you think is worth building next. Our codebase is written in TypeScript for easy contributing – feel free to open a pull request, or share your feature requests via our Slack concierge.

To see Studio in action, download the app and start tinkering!

Special thanks

We know Foxglove Studio could not exist without the hard work of our colleagues at Cruise, especially those building Webviz. We stand on the shoulders of giants, and we hope our own open source contributions help the robotics community rush towards the bleeding edge of our field.


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.


The Building Blocks of ROS

Read more:

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