Abstract
It is difficult to create robust, reusable, and reactive behaviors for robots that can be easily extended and combined. Frameworks such as Behavior Trees are flexible but difficult to characterize, especially when designing reactions and recovery behaviors to consistently converge to a desired goal condition. We propose a framework which we call Robust Logical-Dynamical Systems (RLDS), which combines the advantages of task representations like behavior trees with theoretical guarantees on performance. RLDS can also be constructed automatically from simple sequential task plans and will still achieve robust, reactive behavior in dynamic real-world environments. In this work, we describe both our proposed framework and a case study on a simple household manipulation task, with examples for how specific pieces can be implemented to achieve robust behavior. Finally, we show how in the context of these manipulation tasks, a combination of an RLDS with planning can achieve better results under adversarial conditions.
Introduction
Robots operating in unstructured environments, such as home kitchens, face significant uncertainty. A routine task like placing a soup can in a drawer can fail due to missed grasps, sensor glitches, or external interference—such as a human closing the drawer prematurely. Traditional approaches to handling these failures often result in complex, unmanageable logic in Finite State Machines (FSMs) or lack formal convergence guarantees in Behavior Trees (BTs). Standard linear planners often require expensive re-planning when a single step fails.
The Robust Logical-Dynamical Systems (RLDS) framework addresses these challenges by bridging the gap between high-level task planning and low-level reactive control. It provides a modular structure that is as easy to program as a list of steps but as resilient as a complex reactive program.
The RLDS Framework
The core of the RLDS framework is the Robust Logical-Dynamical Chain (RLDC). Each task step is defined as an operator tuple $o = (L_P, L_R, L_E, \pi)$:
- $L_P$ (Precondition/Entry): Conditions required to initiate the task.
- $L_R$ (Run Condition): Conditions required to continue execution. $L_R$ is typically broader than $L_P$ to provide hysteresis and prevent chattering due to sensor noise.
- $L_E$ (Effects): The goal state of the operator.
- $\pi$ (Policy): The continuous control law (e.g., a Riemannian Motion Policy) that drives the robot.
Unlike rigid sequences, RLDS monitors the environment at high frequencies (10–30Hz) and executes the most "downstream" operator (closest to the goal) whose conditions are met. This enables automatic shortcutting (skipping steps if conditions are already met) and fallback (reverting to earlier steps if a failure occurs).
Experimental Evaluation
The framework was evaluated using a Franka Emika Panda robot arm in both simulation and real-world kitchen environments. The robot performed manipulation tasks involving objects from the YCB Dataset, such as spam cans and sugar boxes. State tracking was handled via PoseCNN and DART.
In adversarial tests where a human interfered with the robot's progress, RLDS demonstrated superior performance compared to linear execution and standard re-planning.
| Method | Success Rate (Interference) | Completion Time |
|---|---|---|
| Linear Execution | 0% | N/A |
| Linear w/ Replanning | 100% | 83.84s |
| Reactive Plan (RLDS) | 100% | 78.45s |
RLDS achieved a 100% success rate with faster completion times than re-planning because it transitions instantaneously based on environmental conditions without pausing for computation.
Conclusion and Future Work
RLDS provides a robust mechanism for robot task execution with formal convergence guarantees. By separating entry and run conditions, it avoids common pitfalls like oscillation. Future work will focus on scaling to long-horizon tasks using Task and Motion Planning (TAMP) and exploring methods to learn logical conditions directly from demonstrations rather than manual definition.
Summary updated