Adaptive Fault Detection Exploiting Redundancy with Uncertainties in Space and Time

Denise Ratasich, Michael Platzer, Radu Grosu, Ezio Bartocci

Introduction

In Cyber-Physical Systems (CPS) and the Internet of Things (IoT), sensor reliability is a critical requirement. A single sensor failure or malicious hack in a self-driving vehicle or industrial robot can lead to catastrophic outcomes. Traditionally, engineers address this through explicit redundancy—the integration of multiple identical sensors. However, this approach often proves prohibitive due to increased cost, weight, and power consumption.

This research proposes an alternative: leveraging implicit redundancy. By identifying and formalizing the physical and mathematical relationships between heterogeneous sensors—such as the correlation between a rover's wheel speed, motor torque, and GPS velocity—systems can detect faults without additional hardware. The primary challenge lies in the "messy" nature of real-world sensor data, which is often multi-rate, asynchronous, and subject to varying communication latencies.

Methodology

The proposed framework addresses these challenges through three core components:

1. The Knowledge Base (KB)

The system is represented as a bipartite graph consisting of variables (e.g., velocity) and relations (functions converting one variable to another). Implemented in Prolog/ProbLog, this KB allows the system to dynamically search for all possible computational paths to derive a specific value from available sensor data. This logic-based approach enables structural adaptation; adding a new sensor simply requires a new line of Prolog code.

2. Spatio-Temporal Interval Model

To account for noise and latency, the researchers treat sensor readings as intervals in both space and time rather than discrete points. Each measurement is defined as an "itom" (information atom)—a box representing a range of possible values over a specific valid time-span $[t_{start}, t_{end}]$. This allows for the direct comparison of high-frequency data (like LIDAR) with slower, delayed signals (like Sonar).

3. Adaptive Runtime Monitor

The monitor periodically aggregates these itoms and uses the Prolog-derived formulas to transform disparate sensor data into a common domain. If the resulting intervals for a single variable do not overlap, the monitor flags a fault.

Experimental Evaluation

The approach was validated using a Pioneer 3-AT mobile robot equipped with a diverse sensor suite, including LIDAR, a Sonar array, a Time-of-Flight (ToF) camera, an Inertial Measurement Unit (IMU), and wheel encoders. The system architecture utilized a Jetson TK1 and Raspberry Pi 3 running the Robot Operating System (ROS).

Faults were manually injected into the data streams to test the monitor's efficacy, including "stuck-at-0" errors, random noise, and artificial time delays.

Key Results and Insights

  • Robust Fault Identification: The system successfully identified both "stuck-at-0" and "random noise" faults in distance-to-obstacle measurements by cross-referencing LIDAR, ToF, and Sonar data.
  • Handling Temporal Uncertainty: Experiments demonstrated that increasing the monitor's "buffer size" (the history of past intervals) allowed the system to remain accurate even with sensor delays of up to 0.6 seconds. In traditional synchronized systems, such delays typically trigger false alarms.
  • Computational Efficiency: The logic for finding redundant substitution paths was condensed into just 22 lines of Prolog code, highlighting the low overhead required for managing complex system relationships.
  • Redundancy as Search: By framing fault detection as a logic query, the system can instantly find alternative monitoring paths if a primary sensor goes offline.

Limitations and Future Work

While effective, the current implementation assumes a single fault in the value domain for identification purposes. In environments with high interference, multiple simultaneous failures may occur. Additionally, the physical relations in the Knowledge Base are currently defined manually by experts. Future research aims to automate this process by allowing the system to "learn" these relationships at runtime using machine learning techniques. Finally, the authors intend to refine the system's ability to rank substitution paths based on sensor precision (e.g., prioritizing LIDAR over Sonar).

Summary updated

Abstract

The Internet of Things (IoT) connects millions of devices of different cyber-physical systems (CPSs) providing the CPSs additional (implicit) redundancy during runtime. However, the increasing level of dynamicity, heterogeneity, and complexity adds to the system's vulnerability, and challenges its ability to react to faults. Self-healing is an increasingly popular approach for ensuring resilience, that is, a proper monitoring and recovery, in CPSs. This work encodes and searches an adaptive knowledge base in Prolog/ProbLog that models relations among system variables given that certain implicit redundancy exists in the system. We exploit the redundancy represented in our knowledge base to generate adaptive runtime monitors which compares related signals by considering uncertainties in space and time. This enables the comparison of uncertain, asynchronous, multi-rate and delayed measurements. The monitor is used to trigger the recovery process of a self-healing mechanism. We demonstrate our approach by deploying it in a real-world CPS prototype of a rover whose sensors are susceptible to failure.
BibTeX
@inproceedings{ratasich2019adaptive,
  author = {Denise Ratasich and Michael Platzer and Radu Grosu and Ezio Bartocci},
  title = {{Adaptive Fault Detection Exploiting Redundancy with Uncertainties in Space and Time}},
  booktitle = {SASO},
  year = {2019},
  doi = {10.1109/saso.2019.00013},
}
Figure