In previous posts, we've covered how visualizing ROS 2 transforms in Foxglove Studio can help us describe the relative positions of a robot’s components.

In this tutorial, we'll learn how ROS 2 transforms can help us calculate the position of an object not explicitly linked to a robot – in relation to both the sensor that detected it and the actuator that will interact with it.

Calculating positions in different frames

Let’s consider the robot model from our previous ROS transforms tutorials:

If our robot’s sensor were to detect an object, we'd have that object’s position in the sensor\_link frame. To use our robot’s arm to grab it, however, we’d then need to calculate the object’s position in the arm\_end\_link frame.

With the ROS 2 tf2 library, we can easily transform our object’s position across frames – all without worrying about any of the complicated mathematical operations happening under the hood – and deduce how our arm needs to move to complete this task.

Create a sensor node to simulate object detection

First, let’s create a node that simulates our robot’s sensor.

In a sensor.cpp file, include the following libraries:



Define a Sensor class with the following private variables:



It should also include a timer callback, to periodically publish the detected object’s position:



Next, write a class constructor that publishes the detected object’s pose on a timer (every second). Since poses are not transform messages, they will be published on a /detected\_object topic (instead of /tf or /tf\_static):



Finally, add the main function that declares and spins the node:



Create a listener node to calculate the object’s position

Next, let’s create a listener node to transform the object’s position from the sensor\_link frame to the arm\_end\_link frame.

In a tf\_listener.cpp file, include the following libraries:



Define a TfListener class with the following private variables:



It should also include a poseCallback function, which looks up the transform between the source and target frames every time the sensor sends a new pose:



Next, write a class constructor that loads and listens to your buffer of transforms, and then subscribe’s to the sensor’s /detected\_object pose topic:



Lastly, write a main function that declares and spins the node:



Add the following lines to your CMakeLists.txt to add the executables to the compilation list:



Compile your package with $ colcon build --symlink-install.

Launch nodes and visualize transforms

Let’s first publish the transforms between our base\_link and both arm\_base\_link and sensor\_link. Use the static\_transform\_publisher we’ve learned in the previous post:



You will also need the tf\_broadcaster that publishes the arm\_end\_link frame:



Finally, run your new nodes:



Open a connection to your data in Foxglove Studio using the Foxglove bridge. Open a 3D panel to visualize the frames and detected object positions, and a Log panel to see the printout of our object’s position.

visualizing in Foxglove Studio
The object is represented by a purple arrow in the 3D panel. Its position in the arm\_end\_link frame is printed by the tf\_listener node in the Log panel.

Notice that the object arrow is different from the axes arrows that represent each frame. This is because the object is not a transform, but a Pose. If you use the Teleop panel to move the arm\_end\_link frame around, you can see firsthand how the position of your detected object changes.

Create a launch file

In a launch folder, let’s create a tf\_launch.launch.py file to launch all nodes together:



Add the following lines in the CMakeLists.txt:



Compile your package with $ colcon build --symlink-install.

Now you can start all nodes, the Foxglove bridge connection, and Foxglove Studio with a single command.

launching in Foxglove Studio

Stay in touch

By leveraging ROS 2 transforms and the tf2 library, you can easily integrate your robots' sensors and actuators to work better together.

For a reference to all the code covered in this post, check out our foxglove/tutorials GitHub repo. And as always, feel free to reach out to us directly in our Slack community to request a topic for the next tutorial!


Max Polzin is a PhD Student at École Polytechnique Fédérale de Lausanne (EPFL)’s Computational Robotics Design and Fabrication Lab, where he focuses on developing novel robots with real-world applications in extreme environments like boreal forests, mountainous slopes or polar glaciers. In addition to his research, Max is dedicated to making the development of advanced robotics more accessible and to promoting robotics software engineering best practices in academic environments.

Tell us a little bit about yourself, and how you first became interested in robotics.

After finishing my undergraduate degree in telecommunications, I wanted to build things that moved for a change, and thus enrolled in a robotics master program at ETH Zurich . While I learned a lot about the theory of robotics – like how robots require sensors, processors and actuators to function in the world – what I didn’t learn was how to turn an idea, a research concept, or an academic prototype into a product.

To learn what it takes to bring a robot from idea to reality, I joined Seervision, a young ETH Zurich spin-off dedicated to developing and selling autonomous cameras. We started as a team of three fresh graduates, with little knowledge about how to make and sell robots. It is an understatement when I say we underestimated how many lessons lay ahead of us.

Over the next several years, we got a crash course on real-world robotics development. We learned how to modify and adjust our robots to meet our customer’s needs. As our team grew, we also had to find the right developer tools and adopt modern software development best practices to help us continue building robots at scale.

After my experience at Seervision, returning to academia and embarking on a PhD journey was not an easy choice to make. However, in the end, I chose to join EPFL’s newly established CREATE Lab, where I could merge my passions for robots and the outdoors and focus on developing novel robots with applications in extreme environments.

What robotics projects are you working on now?

As a PhD student, I am dedicated to enhancing the capabilities of robots in unpredictable and complex natural environments. By developing versatile robotic systems equipped with state-of-the-art sensors, advanced control algorithms, and smart design, I aim to tackle tasks that have previously been beyond the reach of both robots and humans.

Max Polzin

The robot that you see above was built for the project ”Modelling Spatio-temporal Transformations of Glacial Moulins” in collaboration with the Swiss Polar Institute. It rappels itself into moulins – large open holes on a glacier, formed by surface meltwater draining through the ice sheet to the glacier’s rock bed – to explore their geometry.

By capturing these measurements, we can foresee the influence of increased surface water melting, due to a changing climate, on the flow velocity of the worlds’ glaciers. Particularly in polar regions, where temperatures rise fastest, an increased glacial flow and the associated freshwater discharge will significantly contribute to the global sea level rise.

Our initial evaluation of the robot took place during a four-day field trip to Mont Blanc in the French Alps, where we studied the largest moulin on the Mer de Glace glacier. I was joined by my PhD colleagues from the CREATE Lab, Kai Junge and Francesco Stella, our colleague Steffen Kirchgeorg from the Environmental Robotics Lab, as well as my friend, photographer and mountain guide, Arion Schuler. The goal of this trip was to test the robot in a nearby moulin before venturing to more remote locations, such as those on Greenland's ice sheet.

map of Mer de Glace glacier
Map data from the Swiss government.

What does a day in the life on this project look like?

When we’re not out in the field, I am absorbed in the exciting work of designing and creating robots in our lab at EPFL. This includes developing algorithms to control a robot's movements and testing their usability and robustness for deployment in extreme environments. As a PhD student, I also have the opportunity to share my lab findings with the wider robotics community through scientific publications.

As much as I enjoy this development work, field trip days are definitely the most exciting parts of our project. On a typical field trip, we get up at 7 in the morning. My teammates Kai and Steffen go to get breakfast, while Francesco, Arion, and I check our safety equipment and the robot.

packing equipment

We pack generator, tent, poles, and ropes into our backpacks, then leave for the first cable car out of Montenvers Station, by the Mer de Glace glacier at Mont Blanc.

riding the cable car

On our ride up to the glacier, we take some time to review our plans and experiments for the day ahead. Upon arrival at our stop, we embark on a 1.5-hour trek through snowy landscapes to the largest moulin on the Mer de Glace glacier.

traveling to the moulin
Map data from FATMAP.

There, we set up camp to begin our experiments. Despite our meticulous preparations at the bottom of the mountain, the robot usually does not perform as expected right away. We usually spend some time debugging issues on-site, in the challenging cold temperatures.

setting up camp

Thanks to Foxglove Studio, we’re able to visualize data from the robot on our laptops and phones, making it easier than ever to get our robot working as designed for our day’s experiments.

Foxglove Studio layout

We use Foxglove Studio to debug our sensor data, track our robot’s progress, and analyze collected measurements.

Once the robot is fully functional, we are ready to send it off on its mission. After getting attached to the horizontal tethers strung across the opening of the moulin, the robot begins its automatic descent. It uses onboard sensors to collect data about the shape and structure of the moulin (e.g. diameter and curvature), and employs its thrusters to safely navigate around any encountered obstacles. Once the robot has finished exploring, it reels in its tether to return to the surface. From there, we retrieve the valuable collected data stored on its hard drive and successfully conclude the mission.

lowering robot into moulin

In the afternoon, we pack up our gear and begin our descent, reflecting on the day's findings. At home, I upload the captured data to the cloud, have dinner, and continue to work and prepare for the next day.

Tell us a little bit about your robot – its software stack, hardware, etc.

Our robot is equipped with a tether and motorized winch to help it safely explore the depths of glacial moulins. After we string a rope across the moulin’s opening, we anchor the robot above its center and use the tether to remotely lower the robot into its depths. The robot uses two propellers, mounted left and right of the winch, to control its position and orientation while deep inside the moulin.

robot

The robot consists of the following advanced electronic components:

NVIDIA Jetson Xavier NX – Runs our control and estimation algorithms

Foxeer Reaper Mini – Controls the two brushless DC motors

Holybro Pixhawk 6X – Communicates with the NVIDIA Jetson Xavier through microROS and Micro XRCE-DDS

Dynamixel motor – Powers the tether’s winch

It uses the following sensors, actuators, and accessories:

Lumecube light

ZED2i stereo camera – Durable camera built to withstand challenging environments

Livox Lidar

Custom sampling mechanism –Designed to collect samples from the moulin’s icy walls

On the software side, we used ROSbloX to help us iterate more quickly on new robot designs. This system consists of building blocks that each run a specific containerized part of the software – whether that’s the sensor driver, an algorithm, an actuator interface, or a visualization tool. To optimize the weight and power consumption of the final robot, we ran all ROSbloX containers on the NVIDIA Jetson Xavier.

What were your team’s biggest challenges?

None of us had any prior experience accessing a moulin or building a robot to operate on glaciers, so our biggest challenge was figuring out our baseline requirements – like the equipment we needed for our field trips (e.g. x meters of rope) and the appropriate specifications for our robot (e.g. how many batteries it needed for an excursion).

We also encountered many unexpected obstacles during field trips. I once accidentally broke a Wifi antenna on the robot on our first day, which forced us to replace it with a weaker one for the following day. This definitely made conducting experiments much more difficult. To be within range of the robot, I had to rappel into the moulin myself.

rappelling into the robot

Glacial moulins can be tens of meters wide and hundreds of meters deep, and exploring their depths can be extremely dangerous. When scaling their icy walls, I had to worry about the stability of my footholds, falling icicles, and other hazards. It was quite challenging to manage my own safety while ice climbing and holding delicate equipment, like a gamepad or laptop.

Working in the cold definitely impaired my cognitive abilities to focus on our experimental procedures. While easily managing and debugging code in the lab, it becomes tremendously more difficult to concentrate on and execute even the simplest tasks when your fingers are too cold to type and the laptop’s trackpad is no longer responding.

enduring the cold

Did you use any developer tools to help iterate on this robot? How did they enhance or accelerate your work?

Our robot uses ROSbloX, which is built around ROS2 and implements popular open source drivers, algorithms, and tools. By relying on proven technology, we were able to ensure the stability of our robot’s performance.

Working in challenging conditions on the glacier, it was essential to use tools that were both reliable and user-friendly. This is where Foxglove Studio came in as a valuable companion. I was able to remotely connect to the robot via wifi and debug any issues, while huddled in our tent on the glacier. Even after returning from field trips, I used Foxglove Studio to analyze the data we collected. The visualization tools provided by Foxglove were especially helpful in this process, as they allowed for clear and easy data analysis.

Foxglove Studio layout displaying the moulin's shape

We used Foxglove Studio to visualize the shape of a glacial moulin by tracking our robot’s position around its perimeter at different depths.

What are the next steps for you and the project?

The successful operation of the tethered robot in the moulin has opened up exciting new avenues for future research. Next year, we plan to return with a similar system to monitor changes in the same moulin and draw conclusions on the glacier movement over time. Further, we aim to upgrade the robot to reach even further depths and explore the large moulins in Greenland.

I’m also very eager to explore the potential applications of (tethered) robots in other extreme environments, such as ice caves, mountainous slopes or boreal forests. The goal is to make robots more versatile and capable of operating effectively in various conditions. Despite the many challenges ahead, I am optimistic about the possibilities for this technology and look forward to continuing the work to make it a reality.

Finally, I hope to share my passion for software engineering and best practices in robotics development. I aim to promote the use of ROSbloX and ROS2 and to educate others on the benefits of using tools like Foxglove Studio. My goal is to empower others with the knowledge and skills of ROS to develop more robust and reliable robots.


We’re thrilled to announce internationalization support in Foxglove Studio – a feature contributed by a member of the Foxglove community. This update adds initial support for Chinese, while also creating a framework for others to contribute additional languages and translations.

The pull request leverages i18next, an internationalization framework written in JavaScript, to add a “Language” setting to Foxglove Studio’s in-app Preferences:

Chinese translations in
Preferences tab

Having all translations for a given view isn't required to contribute them to the Foxglove Studio repo.

Since the Foxglove platform is utilized by robotics teams across the globe, we are very excited to see how this localization support will benefit both current and future Foxglove Studio users.

To add your own translations, check out our contribution guide and open a pull request in the Foxglove Studio GitHub repo. Translations are organized by both language and app view (e.g. Chinese for the Preferences dialog), so you can take on manageable sections of the app without committing to translating the entire app for your language.

We hope this newly added internationalization support makes our platform even easier to use for our growing community of Foxglove users! If you have any feedback or questions, please feel free to reach out to the Foxglove team directly in our Slack community.


Foxglove Studio 会说中文

Read more:

Ready to try Foxglove?