Last month, the Foxglove team traveled from all over the world to attend ROSCon 2023 in beautiful New Orleans.

From hands-on developer workshops to exciting presentations on the industry's most innovative applications, the 3-day conference offered attendees a deep dive into the fast-developing world of robotics.

Meeting Foxglove users, old and new

Like last year, Foxglove had the honor of hosting a booth on the conference floor. In addition to helping newcomers understand how our observability platform can accelerate their team's time to market, we were thrilled to mingle with the wider ROS community to learn what today's roboticists need.

We also partnered with NVidia to host a Jetson AGX Orin Developer Kit giveaway – our lucky winner was Brianna Bouchard, an Assistant Teaching Professor in the Department of Mechanical Engineering at Tufts University.

Giveaway winners
Congratulations to Brianna Bouchard and our other giveaway winners!

Throughout our history as a company, we've been proud to support research institutions and student organizations working to make a robotics-powered world a reality. If you’re part of an academic program, you can enjoy complementary data storage on our platform – email us at sales\@foxglove.com to get started.

Seeing Foxglove in the wild

One of our favorite parts of ROSCon is seeing teams throughout the Expo Hall – from startups to enterprise companies – using Foxglove to make sense of dense robotics data.

Canonical

Canonical provides support for Ubuntu and other open source and enterprise-grade technologies. They help roboticists go from prototypes to production-ready fleets – with a growing ROS snaps ecosystem, managed deployment, and real-time ROS security maintenance.

For ROSCon, the Canonical team downloaded the Foxglove snap package on a Linux machine, connected the app to a ROS robot via the Foxglove bridge, and then visualized this live data using Foxglove's 3D panel. They even set up a Teleop panel to control the connected robot's movements in real time.

Canonical

TDK InvenSense

TDK InvenSense is a leading provider of MEMS sensor platforms. In addition to developing a wide array of sensors for equally diverse applications, they also offer a robotics platform that combines sensors, processors, and actuators on a single board for quick prototyping and development.

At ROSCon, the InvenSense team loaded IMU data from one of their sensors into Foxglove to view its raw messages and plot its values.

TDK InvenSense

Husarion

Husarion provides ready-to-use AMR platforms and related software solutions to help customers scale ROS systems efficiently.

At ROSCon, they streamed live LiDAR data from their Panther robot to reconstruct a 3D representation of the AMR's world in Foxglove.

Husarion

Adrian Macneil on scaling observability to production

In addition to hosting a booth, we also had Foxglove CEO Adrian Macneil represent the team with a presentation on scaling robotics development using observability.

Simply put, observability is about inferring the internal state of your robots – i.e. how they sense, think, and act – from the data they generate. Observability is critical to scaling from prototype to production, and lies at the core of intelligent robotics development.

In his talk, Adrian covered the challenges that roboticists face when integrating observability into their development processes – challenges like managing distributed fleets, making sense of multimodal data logs, and operating in limited-bandwidth environments. He gave a rundown of the design patterns that teams can follow to set themselves up for success, and the critical observability capabilities they can inject into their workflows as they scale.

Adrian Macneil talk

If you weren’t able to attend the conference or tune into the live stream, you can check out the video recording and slide deck for the presentation.

See you next year!

Thank you to everyone who took the time to connect with us at ROSCon. Whether it was a simple thank you for building a solution that your team relies on, or thoughtful feedback on how we can improve our platform, these discussions with our users are integral to Foxglove's growth and keep us motivated to build best-in-class tooling for our community.

To learn more about integrating Foxglove into your development, you can sign up for a free Foxglove account, request a demo with the Foxglove team, or subscribe to our developer newsletter for product announcements and tutorials. We have free, academic, and enterprise plans for teams of all shapes and sizes, so please feel free to drop us a line and learn more.

We look forward to seeing you all next year!


ROS 2 Humble introduced the concept of lifecycle nodes (or “managed nodes”), a new type of node that can be managed through 4 states. Because lifecycle nodes that fail to launch can be reconfigured and reactivated together at runtime, they provide roboticists finer-grained control of their robotics systems.

In this tutorial, we’ll cover the design of lifecycle nodes, understand their use cases, and see them in action with Foxglove visualizations.

Standard vs. lifecycle nodes

In contrast to a regular ROS node – which will simply go from being inactive to active when configured and created successfully – a lifecycle node transitions through 4 primary states: unconfigured, inactive, active, and finalized.

Once initially configured, an unconfigured node transitions to the inactive state – in short, the node is ready to work, but callbacks and publishers are not yet operative. At this stage, you can reconfigure the node – change parameters, add and remove publications and subscriptions, etc. – without altering its behavior while it is actually running.

Once ready to be fully functional, the node can transition to the active state. At this point, it has all the behaviors of a standard ROS node – it responds to service requests, reads and processes data, and produces output.

As a last step, the node transitions to a finalized state. This state is always terminal – the only transition from here is to be destroyed, which subsequently frees up the node's memory.

Lifecycle node states

A particular action triggers each transition. Image credit: ROS 2 Design

Nav2, ROS 2’s most famous navigation stack, uses lifecycle nodes to manage transitions and ensure that the stack can successfully execute without missing any nodes. It configures and activates nodes in a particular sequence to start up the stack, then goes in reverse order to bring it back down into a finalized state. Whenever a single node fails to transition to the configured state, other nodes are also blocked from becoming active. It also transitions down all nodes if any connected servers are non-responsive or have crashed.

Configuring and activating nodes correctly in a deterministic way is critical. Nav2's controller\_server is in charge of local obstacle avoidance – if this node fails its activation and isn’t running correctly, the other navigation nodes should not start, as the robot could collide into obstacles while executing its tasks.

To see how nodes activate sequentially, try executing the nav2\_bringup launch file:



We can see there are five navigation nodes, as well as a final lifecycle\_manager node. The lifecycle\_manager is responsible for transitioning the navigation nodes through the lifecycle states.

Next, each node launches and waits for its transitions to activate:



The lifecycle\_manager triggers the transition for the controller\_server to configure:



Once controller\_server is correctly configured, the lifecycle\_manager will move on to configuring planner\_server and the rest of the nodes:



Once all nodes are configured, the lifecycle\_manager will transition all of them at once to the active state:



Launching these nodes in sequence like this guarantees that the robot’s basic behaviors – like the \`\`controller\_server\`'s obstacle avoidance capabilities – are always working.

Create a lifecycle node

Let’s create our own lifecycle node in Python – this is only possible for ROS 2 Humble and onward.

Create a lifecycle\_node.py file with the following imports:



In this node file, declare a LifecycleNodeExample class that inherits from Node, and declare a method for each of the node’s transitions between its 4 states – each method must return FAILURE or SUCCESS:



Finally, add the main function that instantiates the class and spins the node.



Add the node in the setup.py file:



Now, compile the package and run the executable:



Control the node’s transitions

Open a second Terminal window to control the running node’s transitions.

First, check the available transitions for our lifecycle\_node:



Trigger configure, so our lifecycle node can transition from an unconfigured to inactive state:



Back in the first Terminal window, we see that the node is Transitioning to 'configure':



Next, trigger activate to transition the node from an inactive to active state:



Back in our first Terminal window, we see that Node 'lifecycle\_node' is in state 'inactive' and is now Transitioning to 'activate':



We now have an active lifecycle node!

Trigger and visualize transitions with Foxglove

Let’s use Foxglove to trigger and visualize our node state transitions in real time.

To get started, open either the web or desktop app, and create a new layout. Next, install and launch the foxglove\_bridge. Then, open a new “Foxglove Websocket” connection in Foxglove to connect to your live ROS 2 stack:

Foxglove WebSocket connection

We kept this exercise simple with ros2 lifecycle CLI commands, but in a real-life scenario, you could trigger transitions with services so that your robot can be fully autonomous. Nav2's lifecycle\_manager uses two services to manage its nodes – \~/get\_state to get the current state, and \~/change\_state to trigger transitions.

Use Foxglove's panel list to add a State Transitions panel to your layout. Since lifecycle nodes publish their transitions on a nested \~/transition\_event topic (e.g. /lifecycle\_node/transition\_event), we can configure this panel to visualize the start (/lifecycle\_node/transition\_event.start\_state.id) and goal (/lifecycle\_node/transition\_event.goal\_state.id) of each transition.

Next, add a Call Service panel to your layout. Configure it to call /lifecycle\_node/change\_state with a lifecycle\_msgs/srv/ChangeState request payload:

Change state

Clicking the "Call service" button should trigger a transition to another state ("configure") and return a response:

Change state response

You should also see the corresponding start and goal visualized in the State Transitions panel as well:

State Transitions panel

Keep learning

ROS 2 managed nodes open new horizons for everyone’s robotics development. By helping developers monitor their ROS nodes and ensure that they are correctly configured and activated, lifecycle nodes can improve the overall predictability and reliability of our robotics systems.

If you have any questions, feel free to reach out in our Slack community. You can also learn more about ROS and Foxglove by checking out our other tutorials.


Check out our Humble Hawksbill tutorial to install the latest LTS release.

Though it’s possible to install ROS 2 from source or archive, the easiest way to get ROS running on your Ubuntu machine is to install its corresponding Debian packages using apt, a command line utility for installing and managing packages on Linux distributions.

In this tutorial, we’ll walk you through installing the Debian packages for ROS 2 Iron Irwini on Ubuntu Jammy (22.04 LTS).

Set up a UTF-8 system locale

Before installing anything, you’ll need to make sure your system locale supports UTF-8. Locale issues can cause unexpected problems further down the line, when using various ROS tools and libraries.

Run $ locale in a terminal window to view your currently installed locale – if UTF-8 appears in the listed output, you’re all set!

Otherwise, you'll need to set up your locale in one of two ways – choose a locale on your system or generate a new one.

List your available locales with the command below:



If your system doesn’t have any UTF-8 locales set up already, generate the desired locale yourself:



Finally, update your system with your desired option (e.g. en\_US.UTF-8):



Open a new terminal window, and run $ locale again to verify that your system has been successfully updated.

Set up your source repos

Ubuntu programs are stored in repositories that make installing new software easy and secure. Ubuntu’s four main repositories are as follows:

Main (Canonical-supported open-source software)

Universe (community-maintained open source software)

Restricted (proprietary device drivers)

Multiverse (proprietary software)

For the purposes of installing ROS, we need to enable the Ubuntu Universe repository:



Now you can add the ROS 2 repository to your system. Authorize the public GPG (GNU Privacy Guard) key provided by ROS, then add the ROS 2 repository to your sources list:



Install ROS 2 packages

Install your ROS 2 Iron desktop setup with the following commands:



This will install a few different components like the core ROS libraries, developer tools like RViz, and a set of beginner-friendly tutorials and demos to help you get started.

NOTE: If you're working with ROS for the first time, we strongly recommend the desktop install. However, you can choose to install just the essentials (without the helpful GUIs or learning materials that come with the desktop install) with either $ sudo apt install ros-iron-ros-core or $ sudo apt install ros-iron-ros-base.

Check out the official REP for a full breakdown of the ROS 2 packages that are included in each distribution (i.e. core, base, desktop).

Source your setup file

Typically, you would need to source your setup file every time you open a terminal to use ROS:



To save yourself the time, you can automatically trigger this step every time you launch a new shell. Run the following commands if you’re using a bash shell:



Run the following commands if you’re using a zsh shell:



Run some examples

After completing the desktop install, let’s make sure that our APIs are working properly.

\*\*Run the example C++ talker \*\*at /opt/ros/iron/lib/demo\_nodes\_cpp/talker:



The output should confirm that the talker is successfully publishing messages:



In another terminal window, \*\*run the example Python listener \*\*at /opt/ros/iron/lib/demo\_nodes\_py/listener:



The output should confirm that the listener is hearing the published messages:



Both the C++ and Python APIs are working properly!



NOTE: If you’re experiencing issues here, make sure that you’ve enabled multicast – the network interface needs this in order to communicate via DDS.

Run the following commands in two separate terminal windows:



If the first command does not return a successful output (i.e. Received from xx.xxx.xxx.xx:43751: 'Hello World!'), try updating your firewall configuration:



Then, restart your terminal and try starting up your talker and listener again.

What's new in Iron Irwini

With the Iron Irwini release, you can programmatically fetch type descriptions from remote nodes at runtime. Every type description now includes an associated hash, ensuring that you have the correct type descriptions to decode your ROS messages. Check out our announcement to learn more..

You can also record ROS 2 data to MCAP files (.mcap) by default, for easy analysis with third-party integrations like Foxglove. Not only are MCAP files smaller (and more performant!) than standard ROS 2 files, they’re also completely self-contained (unlike ROS 2 files that draw from message definitions living on your hard drive). Check out our announcement to learn more..

Import these files directly into Foxglove, so your whole team can collaborate on organizing and tagging your data:

Foxglove Data Platform

You can also drag and drop them into Foxglove for instant rich visualizations. Load up your data to view camera images, display 3D markers, review log messages, and more:

Foxglove Studio

What’s next

Continue with the official ROS 2 tutorials to configure your environment, record data, and create a workspace and packages.

To uninstall ROS 2, remove the repository from your system completely:



Join the Foxglove Slack community to ask questions and learn more.



Additional resources

ROS 2 Iron docs and tutorials

Ubuntu repositories

ROS 2 distribution variants

MCAP file format

Foxglove docs


Record robotics data with MCAP

A data format that can evolve with your data decisions

Integrate with tools that enhance your robotics development workflows.

Swap out data formats as needed.

Use our libraries and guides to get started.

Enterprise-ready.

Ready to make the switch?Start writing your robotics data to MCAP files today.