Check out the jetson-nano-image-maker repo to build custom Jetson Nano images with Github Actions.

Most hobby robots come with pre-imaged software - often on an SD card. Unfortunately, not all hobby robots make it easy to alter their software or build your own images from scratch. Flashing with a custom image lets you control the software packages on the robot, add your own robot logic, and create new images to suit your specific project requirements.

The Jetson Nano Developer Kit is a popular hobby embedded computer, included in the nanosaur and Yahboom robot kits.

Jetson Nano
Jetson Nano Developer Kit (c) Nvidia

The documentation on how to make your own images from scratch is cumbersome and manual. For my projects, I prefer having automated images - ideally ones I can make from Continuous Integration (CI). Since the Jetson Nano uses an ARM processor, this presents additional challenges for automation if your computer uses an Intel or AMD processor.

Docker has a cool feature called buildx, which can cross-compile arm64 images on Intel/Amd64 hosts. Pairing Docker buildx with GitHub Actions provides a great set of workflows for automating our image building.

Make your own

To make your own images, fork the jetson-nano-image-maker repo and adjust the Dockerfile to suit your needs. You can add more packages to the base install, tweak existing packages, or set various configuration files by editing the Dockerfile at the root of the repo.

Once you are happy with your changes, push them to your repo and GitHub Actions will take it from there. Once the actions run, you’ll be able to access the action artifacts which will contain a .img file.

artifacts

Grab your favorite SD card imaging software (I prefer balenaEtcher), and flash the image.

balenaEtcher

Put the image in your Jetson Nano and boot up!

Depending on your configuration, you’ll probably want to connect a network cable, HDMI cable, and keyboard. You can even choose to configure your image with a Wifi network, so your robot is online when it boots!

Fork and change the jetson-nano-image-maker repo for whatever your robot project might need!

Rinse and repeat

Automating the building of your images helps reproduce consistent and codified images for your robots. They reduce manual setup and give you a re-usable base for building your robot software.

Join our Slack community to ask any questions you may have about this tutorial, or reach out to us directly with any feedback.


While Foxglove Studio was originally designed for visualizing ROS data, we are on a mission to bring world-class visualization to all robots, including those with custom software frameworks.

Today, we're excited to announce Foxglove schemas: an entirely Foxglove-native way to represent and visualize data. Foxglove schemas are available for Protobuf, JSON, ROS 1, and ROS 2, and we plan to add support for more formats over time.

Becoming more framework-agnostic

We announced the MCAP log file format earlier this year, as an important milestone towards our goal of developing framework-agnostic robotics tools. However, even with MCAP, Foxglove Studio still required the use of existing ROS schemas such as sensor\_msgs/Image or visualization\_msgs/Marker to visualize certain data.

Our new Foxglove schemas have no dependency on ROS, and can be used from any framework. We also plan to continue fully supporting the existing ROS schemas as we do today.

Foxglove Studio panels

Studio’s Image panel now supports foxglove.CompressedImage in addition to ROS’s sensor\_msgs/Image. The 3D panel now supports foxglove.PointCloud in addition to ROS’s sensor\_msgs/PointCloud2.

To see a full list of our supported schemas, as well as the Foxglove Studio panels that use them, check out our schemas documentation.

Start writing your messages

To start publishing messages that adhere to the new Foxglove schemas, import the desired schema files for your framework.

Protobuf

Copy the .proto files directly from the foxglove/schemas repo into your project. You can use these imported schemas to publish messages via a live Foxglove WebSocket connection or to log data to an MCAP file.

We provide WebSocket libraries for live data (Python, JavaScript, C++), as well as MCAP writers for pre-recorded data files (Python, JavaScript, C++).

Check out our blog post on Recording Robocar Data with MCAP for an example on using an MCAP C++ writer to record your Protobuf data.

JSON Schema

Copy the .json files directly from the foxglove/schemas repo into your project, or import them from the @foxglove/schemas npm package:



Use these imported schemas to publish messages via a live Foxglove WebSocket connection or to log data to an MCAP file. We provide WebSocket libraries for live data (Python, JavaScript, C++), as well as MCAP writers for pre-recorded data files (Python, JavaScript, C++).

ROS 1 & 2

We’re in the process of publishing ROS packages for Foxglove schemas. After the next ROS sync, it will be as simple as running sudo apt install ros-humble-foxglove-msgs (replacing humble with your preferred ROS distribution).

In the meantime, you can copy .msg files directly from the ros1/ or ros2/ folder in foxglove/schemas into your ROS project, then importing these schemas wherever you want to start publishing messages:



TypeScript (bonus)

We also provide type definitions for Foxglove schemas for use in Foxglove Studio’s User Scripts panel, or your own TypeScript project.

For User Scripts, you can specify the schema you want to use with Message\<"foxglove.\[SchemaName]">:



For your own TypeScript project, you can import the type from the @foxglove/schemas npm package:



Leverage the full potential of Foxglove Studio

We developed Foxglove Studio to advance the state of the art in open source robotics. MCAP was our first step towards visualizing general-purpose robotics data, and Foxglove schemas are a continuation of that vision. We want to make it easy for all robotics teams, regardless of framework, to get data into Studio and take full advantage of our tools.

Explore all Foxglove schemas via our docs or the foxglove/schemas GitHub repo. As always, join our Slack community to ask questions, or reach out to us directly with any feedback.


This tutorial will focus on installing Humble Hawksbill, the latest LTS release for ROS 2, on Ubuntu Jammy.

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 Humble Hawksbill on Ubuntu Jammy (22.04 LTS).

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 Humble 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.

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/humble/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/humble/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 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:



Visualize and analyze your data with Foxglove

Once you’ve gotten the lay of the land and started recording your robots’ data, you’ll need to start visualizing your data to understand what’s going on under the hood of your robots.

This would be a good time to check out the specs for the MCAP file format. 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), making it possible for you to share these files with teammates for them to visualize. By adhering to a common container format, the MCAP file format encourages interoperability among third-party developer tools like Foxglove Studio and Foxglove Data Platform.

Foxglove provides a convenient mcap CLI tool to help you convert your ROS 2 (.db3) files into MCAP (.mcap) files. These files can then be imported directly into Foxglove Data Platform, so your whole team can collaborate on organizing and tagging your data:

Foxglove Studio

They can also be dragged-and-dropped into Foxglove Studio for instant rich visualizations. Load up your data to view camera images, display 3D markers, review log messages, and more:

Foxglove Data Platform

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



Additional resources

ROS 2 Humble docs and tutorials

Ubuntu repositories

ROS 2 distribution variants

MCAP file format

Foxglove Studio docs

Foxglove Data Platform docs


Installing ROS 2 Humble on Ubuntu

Read more:

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