💻 computer science

A Closed-Form CLF-CBF Controller for Whole-Body Continuum Soft Robot Collision Avoidance

This paper presents a closed-form Control Lyapunov Function–Control Barrier Function (CLF-CBF) controller that enables real-time, provably safe whole-body collision avoidance for soft continuum manipulators in 3D environments by analytically embedding safety constraints to eliminate the computational burden of online optimization.

Original authors: Kiwan Wong, Maximillian Stölzle, Wei Xiao, Daniela Rus

Published 2026-03-23

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Kiwan Wong, Maximillian Stölzle, Wei Xiao, Daniela Rus

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to guide a very long, flexible, and wiggly snake through a room filled with fragile glass sculptures. You want the snake to reach a specific spot on the table, but you must ensure it never bumps into the glass.

This is the challenge faced by engineers working with soft robots. Unlike rigid metal arms that move in straight lines, soft robots are made of flexible materials that bend and twist like octopus tentacles. This makes them great for working near humans (because they are soft), but it also makes them incredibly hard to control safely. If you just tell a soft robot "go there," it might accidentally swing its tail into a wall or a person.

Here is a simple breakdown of what this paper does to solve that problem:

1. The Problem: The "Math Overload"

Traditionally, to keep a robot safe, computers use a method called Online Optimization. Think of this like a GPS that recalculates your route every single second.

The Issue: Because a soft robot can bend in thousands of different ways, the computer has to check millions of potential "bumps" against obstacles every millisecond.
The Result: The computer gets overwhelmed. It's like trying to solve a massive Sudoku puzzle while running a marathon. By the time the computer figures out the safe path, the robot has already moved, or the math gets too messy and the robot stops working.

2. The Solution: The "Magic Formula"

The authors of this paper created a Closed-Form Controller.

The Analogy: Instead of solving a complex puzzle every time you need to move, they wrote a single, perfect recipe (a mathematical formula) that tells the robot exactly what to do instantly.
How it works: They combined two concepts:
1. The Goal (CLF): "Get to the target."
2. The Safety Rule (CBF): "Don't hit anything."
Usually, a computer has to juggle these two rules by running a heavy calculation (a Quadratic Program) to find a balance. This paper found a way to bake the safety rule directly into the recipe. The robot doesn't need to "think" about the math; it just follows the formula, which guarantees it won't crash.

3. The "Log-Sum-Exp" Trick (The Crowd Control)

A soft robot is like a long chain of beads. To check for collisions, you have to check every single bead against every obstacle. That's a lot of math!

The Innovation: The authors used a clever mathematical trick (called Log-Sum-Exp) to turn hundreds of individual "don't hit" rules into one single, smooth rule.
The Metaphor: Imagine you are walking through a crowd. Instead of checking every single person to see if they are too close, you just feel the "pressure" of the crowd as a whole. If the pressure gets too high, you naturally step back. This trick lets the robot feel the "pressure" of all obstacles at once without doing the heavy math for each one individually.

4. Why It's a Big Deal

Speed: The new method is 10 to 100 times faster than the old ways. It's the difference between a Formula 1 car and a bicycle. It can react instantly to moving obstacles.
Safety: Because the math is so fast and precise, the robot can weave through tight spaces (like a cluttered room) without ever touching the walls.
Smoothness: Old methods sometimes made the robot jerk or stutter as it switched between different safety calculations. This new method makes the robot move like water—smooth and fluid.

5. Real-World Proof

The team didn't just simulate this on a computer; they built a real, tendon-driven soft robot (like a mechanical octopus arm) and hung it from the ceiling.

They threw obstacles in its path.
The robot successfully navigated to its target, dodging the obstacles perfectly without ever crashing.
When they compared it to a robot using the "old" math-heavy method, the new robot was faster, smoother, and never got stuck.

The Bottom Line

This paper gives soft robots a "superpower": the ability to move quickly and safely in crowded, dangerous environments without needing a supercomputer to think for them. It turns a complex, slow math problem into a simple, instant reaction, making it possible to deploy these gentle, flexible robots in hospitals, factories, and homes where human safety is the top priority.

1. Problem Statement

The deployment of soft continuum robots in human-centered environments (e.g., healthcare, manufacturing) requires rigorous safety guarantees. While soft robots possess inherent passive safety due to compliance, increased stiffness and dynamic payloads in modern designs necessitate active collision avoidance.

Existing approaches face significant limitations:

Sampling-based planners (e.g., RRT):* Computationally expensive, lack formal safety guarantees, and often require complex cascaded architectures with high-rate inner-loop controllers.
Online Optimization (QP-based CLF-CBF): While offering formal guarantees, solving Quadratic Programs (QPs) in real-time for high-dimensional soft robots is challenging. The need for fine-grained discretization to model the continuous body and detect collisions results in a massive number of constraints, leading to:
- High computational latency (limiting control frequency).
- Numerical instability and infeasibility issues when constraints interact.
- Sub-optimality due to tight runtime budgets.

The Core Challenge: How to enforce real-time, whole-body collision avoidance for high-dimensional soft robots with formal safety guarantees, without relying on computationally expensive online optimization.

2. Methodology

The authors propose a Closed-Form CLF-CBF Controller that analytically solves the underlying optimization problem, eliminating the need for online QP solvers.

A. Robot Modeling

Kinematics: The soft robot is modeled using the Piecewise Constant Strain (PCS) formulation, discretizing the continuous backbone into $N$ segments.
Actuation: A tendon-driven model relates tendon lengths to the strain configuration ( $q$ ). The system is described by control-affine dynamics: $\dot{x} = f(x) + g(x)u$ , where $u$ represents tendon length rates.
Collision Representation: The robot body is approximated as a chain of $N_{res}$ spheres, and obstacles are modeled as spheres. Pairwise distances between robot spheres and obstacles define the safety constraints.

B. Control Framework

The controller integrates two main components:

Control Lyapunov Function (CLF): Ensures stability and convergence to a desired task (e.g., reaching a target position).
Control Barrier Function (CBF): Ensures safety by maintaining a minimum distance from obstacles.

C. The Closed-Form Solution

Instead of solving a QP numerically at every time step, the authors derive an explicit analytical solution:

Constraint Aggregation: To handle the $N_{res} \times N_{obs}$ pairwise collision constraints efficiently, they use a Log-Sum-Exp (LSE) approximation. This aggregates all individual barrier functions into a single smooth barrier function ( $b_{LSE}$ ), ensuring that if the aggregate is safe, all individual constraints are safe.
Analytical Derivation: The standard CLF-CBF QP (minimizing control effort subject to CLF and CBF constraints) is solved using Karush-Kuhn-Tucker (KKT) conditions.
- The problem is reduced to a system with two constraints (one CLF, one aggregated CBF).
- By solving the stationarity conditions and complementary slackness, the authors derive a piecewise closed-form control law ( $u^*$ ).
- The solution involves calculating Lagrange multipliers ( $\lambda_V, \lambda_h$ ) via a simple $2 \times 2$ linear system, avoiding iterative solvers.

Key Advantages of the Closed-Form Approach:

Speed: Eliminates the iterative nature of QP solvers.
Stability: Avoids numerical instability and infeasibility issues common in online optimization.
Smoothness: The LSE aggregation and closed-form nature prevent discontinuous "active-set switching," leading to smoother control inputs.

3. Key Contributions

Closed-Form Controller: A novel control law for high-dimensional continuum soft robots that guarantees real-time whole-body obstacle avoidance without online QP solving.
Scalability: The method scales efficiently with the number of safety constraints (discretization resolution), making it suitable for dense collision environments.
Formal Guarantees: Provides provable stability (via CLF) and safety (via CBF) under stated modeling assumptions.
Experimental Validation: Extensive simulations and hardware experiments on a tendon-driven soft manipulator demonstrating robust performance in cluttered 3D environments.

4. Results

A. Computational Performance

Speed: The closed-form controller is ~10x faster than a standard JIT-compiled QP solver (qpax) and ~100x faster than traditional sampling-based planning (RRT*).
Accuracy: The closed-form solution achieves machine-precision agreement with numerical QP solvers (error $< 10^{-9}$ ) while maintaining zero constraint violations.

B. Simulation Experiments

Setpoint Regulation: Compared against an RRT* baseline, the closed-form controller achieved smoother, monotone convergence to the target. The RRT* approach required significantly more computation time (244s vs. real-time execution) and resulted in less optimal paths due to discrete setpoint limitations.
Trajectory Tracking: In circular trajectory tracking tasks with obstacles, the closed-form controller demonstrated superior tracking accuracy (lower RMSE) and smoother trajectories compared to the standard QP-based controller, which suffered from trajectory deviations near obstacles due to active-set switching.

C. Hardware Experiments

Setup: A two-segment tendon-driven soft robot operated in a 3D environment with spherical obstacles.
Comparison: The closed-form CLF-CBF controller was compared against a "Pure CLF" controller (no safety constraints).
- Pure CLF: Reached the target quickly but collided with obstacles, violating safety margins.
- Closed-Form CLF-CBF: Successfully avoided obstacles, maintaining a strict 0.05m safety margin while converging to the closest safe equilibrium point.
Conclusion: The hardware results confirmed the controller's ability to enforce safety in real-time without sacrificing tracking performance.

5. Significance and Future Work

Significance:
This work bridges the gap between theoretical safety guarantees and real-time implementation for soft robotics. By removing the computational bottleneck of online optimization, it enables provably safe, whole-body control for high-dimensional soft robots in dynamic, cluttered environments. This is a critical step toward deploying soft robots in safety-critical human-centric applications.

Limitations & Future Directions:

Constraint Composition: Currently, the method aggregates only collision constraints. Future work aims to support heterogeneous constraints (e.g., input limits, energy budgets) and hierarchical prioritization.
Dynamics: The current approach relies on kinematic models (quasi-static). Future extensions will incorporate inertia and dynamic collision avoidance using higher-order CLFs/CBFs.
Real-World Deployment: Further testing in more complex, unstructured real-world scenarios is planned.

In summary, this paper presents a paradigm shift from iterative optimization to analytical control synthesis for soft robots, offering a scalable, fast, and mathematically rigorous solution for safe operation.