Keeping the Franka Emika Panda alive: a ROS 2 stack with a reliable position interface

arXiv:2608.19740 · cs.RO · Submitted 2026-08-20 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.

Rosa: We're looking at the paper: "Keeping the Franka Emika Panda alive".

Dev: Here's the gist of the paper. This paper presents an open-source software stack that restores ROS 2 support for the Franka Emika Panda robot while resolving the long-standing unreliability of its external position control interface.

Rosa: The proposed architecture successfully decouples real-time communication from the ROS 2 control loop and introduces a position-domain reference generation strategy that produces reliable, smooth position commands.

Dev: Analysis of Control Interface Failures The analysis reveals that unstable position control on the Panda arises from the timing of the external control loop and sampling jitter, rather than limitations of the robot itself Sec.

Rosa: 2 analyzes the Franka Control Interface (FCI) and its official ROS 2 implementation, and identifies the two mechanisms that make external position control fail The FCI connects the robot’s onboard controller (INT) to an external workstation (EXT) over UDP First, libfranka exposes blocking reads only: the external process waits until a state packet arrives, so the EXT cycle is paced by INT Second, when operating in external control mode, EXT must supply one reference sample for every INT cycle, since INT performs no onboard interpolation of sparse setpoints, unlike most industrial controllers Whenever the budget of (1) is exceeded for a cycle, FCI discards that command; INT then holds the last commanded acceleration This extrapolation lets the actual and commanded references drift apart during loss bursts Proposed Architectural Components The proposed stack rests on two open-source components: a community-maintained libfranka repository that brings the modern control API to the Panda, extended with the Panda kinematic limits, and a ROS 2 Jazzy package built on top of it providing a hardware interface for the robot Sec.

Title and authors: Rosa: So we're looking at this paper called "Keeping the Franka Emika Panda alive: a ROS two stack with a reliable position interface <ref:2608.19740#pg1,Keeping the Franka Emika Panda alive: a ROS 2 stack with a>." It sounds like they’re fixing something that has been really annoying people working with this robot for a long time, specifically about how the external position control works.

Dev: Yeah, it tackles that exact problem. They analyze why the external control interface isn't reliable on the Panda and show it comes down to timing issues and sampling jitter in the external loop, not anything broken in the robot hardware itself.

Taro: So if I'm driving around testing this outside the lab, I want to know if it’s stable when things get a little messy or when there's some unexpected movement happening.

Rosa: Exactly. The paper proposes an asynchronous hardware interface that totally separates the real-time communication from the ROS two control loop <ref:2608.19740#pg1,real-time communication from the ROS 2 control loop>. They also introduce a reference generation strategy in the position domain that should make those position commands much smoother and more reliable, even if things get bumpy on the external side.

Dev: And they detail how this works by confining all of that external communication to a dedicated real-time thread running at a high priority, which means any jitter from the ROS two side never actually gets to the robot’s control channel <ref:2608.19740#pg1>. That’s a big deal for safety and consistency in real-time systems.

Taro: So when things get unstable, like when that external stream stalls, how does this new reference generation strategy handle it? Does it just keep giving the last good command?

Rosa: It actually degrades gracefully toward the last target instead of stepping or showing a timestamp from either machine. They’ve defined a position domain reference generation scheme using an equation involving the latest position command, T delta q dot external, and lambda times external minus the position command.

Dev: That specific formula has three properties they highlight: first, the motion is driven by that feed-forward term with T delta q dot external while the actual position only comes in through a proportional term closing on the position command.

Taro: So if that external stream stalls, does it still try to move toward something useful based on what it has?

Rosa: Yes, because the reference degrades gracefully toward the last target instead of stepping no timestamp appears in it which makes it immune to clock drift issues. That’s how they handle losing communication from the external source.

Title and authors: Dev: They also include an optional ratematching stage that enables slower command sources, which is flexible for different applications, and they built this on a community-maintained libfranka repository extended with the Panda's specific kinematic limits for ROS two Jazzy <ref:2608.19740#pg1>.

Taro: That means we can use it for things like slow teleoperation devices without immediately violating real-time constraints because of that ratematching mechanism you mentioned.

Rosa: Right, and they did experimental validation showing that this new architecture reliably tracks velocity references by reducing the motion artifacts introduced by the official implementation. They compared their proposed configuration against a synchronous interface and a one with a low-pass filter.

Dev: The comparison showed that the synchronous interface carried an order of magnitude more spectral power in the two to fifteen zero hertz band, which they call roughness, and that's what manifests as motor noise during trajectory execution.

Taro: So if I’m doing something like a pick-and-place task with this setup, does this mean I get smoother joint velocity tracking without having to rely on those kinds of heavy low-pass filters?

Rosa: The proposed configuration attains faithful tracking while keeping the low band power of the filtered case, which is pretty impressive when you look at how much noise they managed to cut out.

Dev: The core contribution here is decoupling the real-time communication from the ROS two control loop via that dedicated thread, ensuring that ROS side jitter never reaches the robot channel <ref:2608.19740#pg1,real-time communication from the ROS 2 control loop>. That’s a key safety feature for me in any real-time setting.

Taro: What about when the system flags an anomalous cycle where alpha times T delta is greater than zero point two five milliseconds? What happens then?

Rosa: They flag those cycles to prevent using stale or duplicated state, which is important because you don't want the robot acting on old information when things are moving fast. That adds another layer of robustness against timing errors in control loops.

Dev: So we’ve got decoupling, position-domain reference generation for smooth tracking, and a dedicated thread to handle the real-time channel reliably. It sounds like they’ve addressed the core failures identified earlier in their analysis of why external position control performed poorly on the Panda.

Taro: What's the big picture here? For someone who just listens to this show, how does this change what you think about running robotics software on top of ROS two for complex hardware like a Panda <ref:2608.19740#pg1>?

Title and authors: Rosa: It shows that you can take a system with known timing issues and make it usable in a modern ROS two environment by focusing on separating the control domains <ref:2608.19740#pg1>. It makes using external position control interfaces much more viable for collaborative tasks.

Dev: The main implication is that we don't necessarily need perfect, synchronous communication between the high-level planner in ROS two and the low-level hardware interface to get smooth motion <ref:2608.19740#pg1>. We can engineer a way to bridge that gap reliably.

Taro: If this works across different platforms, what does it mean for the wider field of robotics research?

Rosa: It suggests that as long as you can identify those timing dependencies in external interfaces, there's a structured way—like this asynchronous architecture—to build reliable control on top of existing hardware drivers. It opens up more possibilities for deploying complex manipulators in real-world scenarios.

Dev: I just hope the portability of this approach to other manipulators works out as they say, assuming their command interfaces expose a state that can be fed into that position domain reference generation scheme.

Taro: Yeah, and the fact that they tested this across two different experimental sites on two different Panda setups gives it some real-world grounding beyond just a lab simulation.

Rosa: That’s true. The validation across motion planning, compliance control, pick-and-place tasks, and haptic teleoperation on those independent platforms really makes the results stick.

Dev: So to wrap up this paper on "Keeping the Franka Emika Panda alive: a ROS two stack with a reliable position interface," they’ve successfully restored support for this robot in ROS two Jazzy by introducing an asynchronous hardware interface and a position-domain reference generation scheme that handles command source variability <ref:2608.19740#pg1,Keeping the Franka Emika Panda alive: a ROS 2 stack with a>.

Taro: For me, it means we have a more robust foundation for building compliant human-robot interaction systems because the tracking is so much smoother now.

Rosa: It certainly does, giving us more confidence when we try to push these robots into complex collaborative tasks where timing errors can cause real problems on the ground.

Dev: We'll keep an eye on how this asynchronous decoupling performs under even more extreme load conditions in future tests.

Taro: I'm looking forward to seeing how they apply this concept to other types of external interfaces, not just position control, because that would be a big step for general manipulation reliability.

The paper's summary: Rosa: So, this paper is about fixing the position control interface for the Franka Emika Panda robot when you're using ROS two. Basically, they’ve built a whole new software stack that makes that external position control reliable again after it was being really finicky.

Dev: Yeah, what’s interesting about their approach is how they split things up—they decouple the real-time communication from the main ROS two control loop. They aren't trying to make one thing do everything at once, which usually causes timing headaches.

Taro: I heard that they introduced a specific way to generate position references in the position domain instead of just relying on whatever external signal you get. That sounds like it should handle things much better when the communication isn't perfect.

Rosa: Exactly, and they show this reference generation strategy has three key properties. First, the motion is driven by a feed-forward term related to velocity, while the position itself only gets updated through a proportional term closing on the desired position.

Dev: That means if you have a bit of trouble with velocity updates because of timing jitter, the actual position still gets tracked smoothly because it inherits that sensitivity from the velocity interface.

Taro: And second, if that external stream stalls—if there's no new data—the reference doesn't just jump to zero or freeze; it degrades gracefully toward the last target you commanded.

Rosa: Right, and third, they make sure nothing gets lost because they don't include any timestamps from either machine in that command signal. That’s huge for avoiding clock drift issues.

Dev: I think the real safety case here is that they have a dedicated real-time thread handling the external communication under a high priority schedule, so the ROS two side jitter never actually reaches the robot’s control channel at all.

Taro: It sounds like this gives us much better behavior when things misbehave in real time, instead of just crashing or making weird movements because of timing errors.

Rosa: And they validated this whole thing across four different applications—like collision-aware planning and even haptic teleoperation—on two separate Panda platforms, which shows it’s not just a lab fix.

Dev: The results showed that their asynchronous setup tracks velocity references faithfully while actually reducing the kind of motor noise you get from the official implementation, especially in that two to fifteen zero hertz band.

Taro: So what this means for us is we can be much more confident using external interfaces for things like pick-and-place or human interaction because the tracking is much smoother and less artifact-ridden.

Rosa: It means we can finally get the Franka Emika Panda back onto a reliable ROS two stack that actually works well in real collaborative settings without all those timing frustrations.

Dev: So they’ve successfully restored usability by focusing on separating the domains and using a smarter reference generation strategy instead of just trying to make the old system work harder.

The paper's improvements: Rosa: So, we're talking about how they actually improved things in their proposed stack for that Panda robot paper, moving beyond just fixing the old interface to making it fundamentally more robust. They didn't just patch a hole; they built a whole new way of thinking about command flow.

Dev: Yeah, one major thing is this asynchronous hardware interface we talked about before—they really pushed the decoupling further to make sure that real-time communication stays completely separate from ROS two. It’s designed to handle the high-priority scheduling needed for deterministic performance.

Taro: And they introduced this specific reference generation strategy again, which uses that equation with the position command and a term involving time delta q dot external and lambda times external minus the position command. That’s their core mathematical fix for smooth tracking.

Rosa: Exactly, and they emphasize how that formula works because it gives you two key things: first, you get motion driven by that feed-forward velocity term, so the position inherits the sensitivity of that velocity interface.

Dev: And second, if the external stream stalls out, this strategy makes the reference degrade gracefully toward the last target instead of just stopping or showing some kind of bad timestamp. That’s a lot better for autonomy when things get messy in real time.

Taro: I like that graceful degradation idea because it means the robot won't just freeze or jerk around when it loses connection; it keeps trying to move toward something useful based on what it knows.

Rosa: Right, and they also added a ratematching stage, which lets you run the ROS two control loop at any speed less than or equal to the robot’s internal rate. This means you can use slower devices for teleoperation without breaking the real-time constraints.

Dev: That flexibility is good because it addresses how different control frequencies interact, ensuring that a slow command source doesn't violate the timing budget of the actual hardware controller.

Taro: It sounds like they’ve created a system where you can have a very fast high-level planner in ROS two and still reliably get smooth movement from a slower physical input device.

Rosa: They also put some specific checks in place, flagging those cycles where alpha times time delta is greater than zero point two five milliseconds to prevent the robot from using stale or duplicated state information. That’s another layer of safety for when the world misbehaves with timing errors.

Dev: So they’ve got the hardware thread handling the communication budget, and then software checks to catch those bad time stamps before they cause a problem in the loop.

Taro: What I see is that this approach gives us more confidence when we apply it to things like compliant human-robot interaction, because tracking is much smoother and less prone to noise artifacts.

Rosa: It means we can move toward more complex, real-world applications faster because the foundation for reliable position control on these robots is actually solid now.

Conclusion: Rosa: So to wrap up this whole thing, this paper on "Keeping the Franka Emika Panda alive: a ROS two stack with a reliable position interface," it’s basically about taking a robot that had some really annoying timing issues and making it usable again in modern ROS two setups.

Dev: Right, they managed to solve the external position control problem by implementing an asynchronous interface and using that specific reference generation strategy we talked about earlier to smooth out the commands. It’s a lot of engineering work to get those things decoupled properly.

Taro: I think what this means for autonomy is that you don't have to wait for perfect, synchronous communication just to move reliably; you can build systems that handle imperfect timing gracefully through these domain-specific reference methods.

Rosa: Yeah, and the validation across four different tasks shows it works outside the lab too—on two separate Panda setups—which proves it’s a solid foundation for real collaborative work.

Dev: The safety case is strong because they’ve built in checks to stop stale or duplicated state from ever reaching the robot's control channel, which is crucial for any real-time system.

Taro: It shows that the way you structure your control loops can determine how robust a robot is when things get unpredictable in the physical world.

Rosa: It really does; this paper gives us a more dependable way to interact with manipulators like the Panda, which opens up more possibilities for those complex human-robot tasks we were looking at.

Dev: So, they’ve successfully restored usability by focusing on separating the domains and using a smarter reference generation strategy instead of just trying to make the old system work harder.

Taro: It’s good to see this kind of structured approach applied to a specific hardware limitation, showing how general principles can fix real-world deployment problems.

Rosa: They did, and it sets a precedent for how we might approach other external interfaces that cause timing problems in robotics.

Dev: Next time we look at papers like this, we should really focus on those architectural splits to see what else we can do with them.

Antonio Langella, Davide Risi, Vincenzo Petrone, Enrico Ferrentino, Pasquale Chiacchio

Department of Information Engineering, Electrical Engineering, and Applied Mathematics, University of Salerno

cs.RO

Submitted: 2026-08-20

Updated: 2026-10-30

Comments: 12 pages, 10 figures

Journal ref: Proceedings of the 23rd International Conference on Informatics in Control, Automation and Robotics (ICINCO) - Volume 1: COBOTA; 2026; ISBN 978-989-758-870-9; ISSN 2184-2809, SciTePress, pages 918-929

DOI: 10.5220/0015508000004979

Code: https://github.com/tenfoldpaper/multipanda

Project page: https://sites.google.com/view/fer-ros2

License: http://creativecommons.org/licenses/by-nc-nd/4.0/

Importance score: 90/100

The gist: This paper presents an open-source software stack that restores ROS 2 support for the Franka Emika Panda robot while resolving the long-standing unreliability of its external position control…

Key concepts

FCI Failures
The original Franka Control Interface (FCI) failed because it forced the external control loop to wait for robot state packets. This created timing issues and command loss if the external cycle was too slow or jittery, leading to unstable position control.
Asynchronous Communication Thread
A dedicated, high-priority thread is used to handle communication with the robot's controller. This isolates the critical hardware communication from the main ROS 2 control loop. This prevents timing jitter from affecting robot commands and ensures that ROS cycle delays do not cause missed robot cycles.
Position-Domain Reference Generation
Instead of sending raw commands, a specific mathematical formula generates position references based on current and external velocity data. This method ensures the resulting motion is smooth, inherits velocity interface sensitivity, and gracefully degrades when external data stalls without introducing clock drift.

Terminology

Summary

This paper presents an open-source software stack that restores ROS 2 support for the Franka Emika Panda robot while resolving the long-standing unreliability of its external position control interface. p. 0

Where the paper says it

Keeping the Franka Emika Panda alive: a ROS 2 stack with a reliable position interface Antonio Langella a , Davide Risi b , Vincenzo Petrone c , Enrico Ferrentino d , and Pasquale Chiacchio e Department of Information Engineering, Electrical Engineering, and Applied Mathematics (DIEM), University of Salerno, 84084 Fisciano, Italy {alangella, drisi, vipetrone, eferrentino, pchiacchio}@unisa. it Keywords: Franka Emika Panda, ROS 2, Robot Operating System, Position Control, Real-Time Robot Control, Reference Generation, Human-Robot Collaboration Abstract: This paper presents an open-source software stack that restores ROS 2 support for the Franka Emika Panda robot while resolving the long-standing unreliability of its external position control interface.

The proposed architecture successfully decouples real-time communication from the ROS 2 control loop and introduces a position-domain reference generation strategy that produces reliable, smooth position commands. p. 0
Where the paper says it

Building on this analysis, we introduce an asynchronous hardware interface that decouples real-time communication from the ROS 2 control loop, a rate-matching mechanism for slower command sources, and a position-domain reference generation strategy that produces reliable, smooth position commands. Experimental validation shows that the proposed architecture reliably tracks velocity references by reducing motion artifacts introduced by the official implementation, and the stack is validated across motion planning, compliance control, position-controlled manipulation, and haptic teleoperation on two independent Panda platforms.

Analysis of Control Interface Failures

The analysis reveals that unstable position control on the Panda arises from the timing of the external control loop and sampling jitter, rather than limitations of the robot itself Sec. 2 analyzes the Franka Control Interface (FCI) and its official ROS 2 implementation, and identifies the two mechanisms that make external position control fail The FCI connects the robot’s onboard controller (INT) to an external workstation (EXT) over UDP First, libfranka exposes blocking reads only: the external process waits until a state packet arrives, so the EXT cycle is paced by INT Second, when operating in external control mode, EXT must supply one reference sample for every INT cycle, since INT performs no onboard interpolation of sparse setpoints, unlike most industrial controllers Whenever the budget of (1) is exceeded for a cycle, FCI discards that command; INT then holds the last commanded acceleration This extrapolation lets the actual and commanded references drift apart during loss bursts

Proposed Architectural Components

The proposed stack rests on two open-source components: a community-maintained libfranka repository that brings the modern control API to the Panda, extended with the Panda kinematic limits, and a ROS 2 Jazzy package built on top of it providing a hardware interface for the robot Sec. 3.1 introduces the asynchronous communication thread that decouples the ros2 control loop from the FCI channel The asynchronous interface addresses the problem of Sec. p. 4

Where the paper says it

1 introduces the asynchronous communication thread that decouples the ros2 control loop from the FCI channel; Sec. 2 exploits this decoupling to run the ros2 control loop at a lower rate, matched to the robot loop by a rate matching stage applicable to any command interface; and Sec.

2.3 by confining FCI communication to a dedicated real-time thread, scheduled under SCHED FIFO at the highest priority (99) and only containing the communication pipeline ROS-side jitter — being due to scheduling, DDS activity or controller cost — therefore terminates at the buffers and never reaches the FCI channel; conversely, a late ROS cycle no longer implies a missed robot cycle

Reference Generation Strategy

The proposed method generates the reference in the position domain from the latest available position command qs(k) = qd(k)+Tδ q˙ ext(k)+λ qext(k)−qd(k) Equation (5) has three properties that address the failure modes of Sec. 2: (i) the motion is driven by the feed-forward term Tδq˙ ext(k) while the position enters only through a proportional term closing the loop on qd(k), so the position inherits the sensitivity of the velocity interface Furthermore, if the external stream stalls, the reference degrades gracefully toward the last target instead of stepping no timestamp of either machine appears in it, making it immune to clock drift

Experimental Validation Results

The experimental validation shows that the proposed architecture reliably tracks velocity references by reducing motion artifacts introduced by the official implementation Fig. 5 compares the measured joint velocity and its spectrum for three configurations: synchronous, the proposed asynchronous configuration, and the proposed one with the addition of the low-pass filter The synchronous interface follows the reference but carries an order of magnitude more spectral power than the other two configurations in the 20 − 150 Hz band: this is the roughness the rate limiter leaves behind once it has removed the invalid commands, and it manifests as motor noise during the execution of the trajectory The proposed configuration attains faithful tracking while keeping the low band power of the filtered case

Application Scenarios

The stack is demonstrated on four applications, each exercising a capability that collaborative robotics commonly relies on These applications include collision-aware motion planning and execution via MoveIt! and ROS2-native controllers, compliance control for physical human-robot interaction, an end-to-end, position-controlled pick-and-place task, and haptic teleoperation of a mobile manipulator The MoveIt! p. 7

Where the paper says it

an end-to-end, position-controlled pick-and-place (Sec. haptic teleoperation of a mobile manipulator (Sec.

planning and compliance control applications were run on two different Panda setups, hosted in two different institutions, hereinafter referred to as Lab A and Lab B3 Together they exercise the position, velocity and torque command interfaces of our hardware interface

Conclusion

This work brings the Franka Emika Panda back onto a current ROS 2 stack and makes its position command interface usable The approach has limits that are worth stating Future work follows these limits The stack will be ported to the next ROS 2 distribution, and the position-domain scheme, which assumes nothing specific to this robot beyond the structure of its command interface, is a candidate for other manipulators whose controllers expose a commanded state The code and videos are available on our website at https://sites.google.com/view/fer-ros2 The stack is validated across motion planning, compliance control, position-controlled manipulation, and haptic teleoperation on two independent Panda platforms The code and videos are available on our website at https://sites. p. 0

Where the paper says it

Building on this analysis, we introduce an asynchronous hardware interface that decouples real-time communication from the ROS 2 control loop, a rate-matching mechanism for slower command sources, and a position-domain reference generation strategy that produces reliable, smooth position commands. Experimental validation shows that the proposed architecture reliably tracks velocity references by reducing motion artifacts introduced by the official implementation, and the stack is validated across motion planning, compliance control, position-controlled manipulation, and haptic teleoperation on two independent Panda platforms.

google.com/view/fer-ros2 The stack is validated across motion planning, compliance control, position-controlled manipulation, and haptic teleoperation on two independent Panda platforms

Acknowledgements

The authors would like to thank A.Z., A.R., and F.S. for their contribution in developing the software that made this work possible The authors warmly thank Lab B for hosting the executions of part of the experiments conducted in this work The authors would like to thank A.Z., A.R., and F.S.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Improved position control reliability for human-robot collaboration applications by implementing an asynchronous hardware interface that decouples real-time communication from ROS 2, which reduces motion artifacts introduced by the official implementation to a level comparable to bare libfranka programs.

  2. Enhanced trajectory tracking for slow control loops by introducing a rate matching stage that smooths reference commands, ensuring they are not distorted and result in a piecewise linear ramp instead of an impulsive motor action when control frequencies differ.

  3. Reliable position command execution for pick-and-place tasks by using a position domain reference generation strategy defined by the equation qs(k) = qd(k)+Tδ q˙ ext(k)+λ qext(k)−qd(k), which makes the interface track as accurately as the synchronous one while reducing the spectral content that the rate limiter leaves behind.

  4. Increased robustness against timing errors in control loops by having a dedicated real-time thread confine FCI communication to a budget, ensuring that ROS-side jitter never reaches the robot, and flagging anomalous cycles where "Tˆ(k)−Tδ > 0.25ms to prevent using stale or duplicated state."

  5. Flexible control frequency support by allowing the ROS 2 control loop to run at any rate fEXT less than or equal to fINT, enabling slower command sources like teleoperation devices without violating real-time constraints due to the rate matching mechanism.

Abstract

This paper presents an open-source software stack that restores ROS 2 support for the Franka Emika Panda robot while resolving the long-standing unreliability of its external position control interface. We first analyze the root causes of unstable position control and show that the observed vibrations and protective stops arise from the timing of the external control loop and sampling jitter, rather than from limitations of the robot itself. Building on this analysis, we introduce an asynchronous hardware interface that decouples real-time communication from the ROS 2 control loop, a rate-matching mechanism for slower command sources, and a position-domain reference generation strategy that produces reliable, smooth position commands. Experimental validation shows that the proposed architecture reliably tracks velocity references by reducing motion artifacts introduced by the official implementation, and the stack is validated across motion planning, compliance control, position-controlled manipulation, and haptic teleoperation on two independent Panda platforms. By restoring a modern, reliable, and open ROS 2 ecosystem for the Panda, this work lowers the barrier to developing safe, responsive, and reproducible human-robot collaboration applications that integrate planning, perception, interaction, and shared autonomy. Code and videos are available on our website at https://sites.google.com/unisa.it/fer-ros2.

Sources

Related papers