Fault Detection of Multi-Wheeled Robot Consensus Based on EKF

Abstract

Synchronizing a network of robots in consensus is an important task for cooperative work. Detecting faults in a network of robots in consensus is a much more important task. In considering a formation of Wheeled Mobile Robots (WMRs) in a master–slave architecture modeled by graph theory, the main objective of this study was to detect and isolate a fault that appears on a robot of this formation in order to remove it from the formation and continue the execution of the assigned task. In this context, we exploit the extended Kalman filter (EKF) to estimate the state of each robot, generate a residual, and deduce whether a fault exists. The implementation of this technique was proven using a Matlab simulator.

1. Introduction

In recent years, there has been a significant shift in focus toward cooperative multi-agent control (MAS) within the realm of control research. This shift is driven by its rapid advancement across various domains, including several robot systems, intelligent transportation, and numerous industrial setups [1,2,3,4,5]. The primary benefit of MAS lies in its ability to enhance system functionality, often overcoming challenges that may prove difficult for humans or even entirely superseding human involvement in executing tasks that are repetitive, hazardous, or beyond human capability [6]. Consequently, the importance of fault detection and isolation has escalated, ensuring safety and maintaining quality standards. Given the inevitability of faults in embedded systems such as wheeled mobile robots (WMRs), it is imperative to ensure that they are promptly identified and addressed. To facilitate and guarantee communication between robots, graph theory is used, which plays a crucial role in modeling the interactions and communication between multiple robots. In representing the robots as nodes and their communication links as edges, graph theory provides a framework for analyzing and designing consensus algorithms. This theoretical foundation is critical in ensuring that all robots in the network can agree on a common set of parameters or states, despite potential faults or communication delays.

Within computer networking, the master–slave model serves as a communication protocol wherein a designated device or process (referred to as the master) governs one or more other devices or processes (the slaves). In a master–slave relationship, the master is often the transmitter of control to the slave.

Master–slave systems often provide data security, improved consistency, and robust fault tolerance. However, their significant drawback arises in the event of master failure, which can lead to the entire system’s failure, causing process malfunctions and subsequent degradation in performance [7]. Hence, the necessity of implementing process monitoring and fault detection systems becomes paramount, especially in applications like wheeled robots. This prompts exploration into fault diagnosis techniques to effectively address this challenge. Fault detection and isolation (FDI) has garnered substantial attention in both academic and industrial spheres, as evidenced by recent publications, for example, [8]. According to [9], this methodology is typically categorized into three overarching groups: hardware redundancy methods, model-based methods, and signal analysis methods. There are two other main forks: quantitative approaches and qualitative approaches. In the literature, considerable attention has been directed toward the observer-based technique. For instance, in [10], a method utilizing Kalman filter identification was utilized for the detection and isolation of sensor faults within mobile robotic systems. Also, in [11], the authors presented the integration of a bank of Kalman filters with an expert system for the detection and isolation of sensor faults in mobile robots. Additionally, [12] introduced a Kalman filter designed for joint state prediction and unknown input estimation within linear stochastic discrete-time systems subject to intermittent unknown inputs in measurements. FDI in nonlinear systems has increased significantly in recent years because most of the systems we encounter in practice are nonlinear. For example, in [13], the FDI system is based on a single-model EKF filter that generates residuals as soon as the behavior of the aircraft deviates from the expected trajectory. Also, refs. [14,15] directed their focus toward fault detection in wheeled mobile robots utilizing an EKF filter. The fault detection process typically involves two primary steps: residual generation and subsequent residual evaluation. In our contribution, we will emphasize the observer-based approach, particularly the utilization of the extended Kalman filter.

The main contribution of this article is to detect and isolate faults in a network of robots synchronized to carry out a common task in a master–slave configuration. Robot synchronization is based on graph theory, and fault detection is implemented via the Extented Kalman Filter approach. A new procedure is established to isolate the defective robot from a formation of robots, the majority of which are affected by a defect appearing in one robot.

To present our investigation on fault detection and isolation within a nonlinear system, specifically a wheeled mobile robot, utilizing the extended Kalman filter, this paper is structured as follows. The first section outlines the modeling of a unicycle mobile robot. In the subsequent section, we delve into the extended Kalman filter (EKF) as a corrective predictor technique. This section covers two primary tasks, encompassing prediction and correction phases, alongside the fault diagnosis steps, which include residual generation, evaluation, and decision-making processes. Following this, simulations are presented to illustrate the exploitation of the EKF to detect and generate residues for a faulty master–slave system. Finally, the last section concludes the paper.

2. Multi-Wheeled Robot Consensus

In this section, we delve into the consensus algorithms for multi-wheeled robots, utilizing graph theory to model and analyze the interactions between robots. By employing graph-theoretic concepts, we can design robust consensus protocols that ensure that all robots achieve a unified state.

2.1. Graph Theory

2.1.1. Notation

We denote the set of real numbers as $\mathbb{R}$. The notation ${\mathbb{R}}^n$ represents the real vector space with n dimensions, while ${\mathbb{R}}^{n\times n}$ denotes the set of $n\times n$ matrices. A diagonal matrix of size $n\times n$, with diagonal elements $q_1,q_2,...,q_n$, is denoted as $diag(q_1,q_2,...,q_n)$. The identity matrix is represented by $I\in {\mathbb{R}}^{n\times n}$. The Kronecker product of matrices is denoted by ⊗. Additionally, we utilize $x={(x_1,...,x_n)}^T$ to signify the vector in ${\mathbb{R}}^n$. The T in the exponent means transposition.

2.1.2. Graph Theory

Understanding the fundamental concepts of graph theory is indispensable for exploring the dynamics of multi-agent systems [16]. Consider a multi-agent system comprising n mobile robots interconnected through a communication network. The interaction model among agents can be represented by delineating the communication topology in the form of a graph.

Consider ${\mathcal{G}}_t=(\mathrm{\Lambda },\mathrm{{\rm Y}})$ an oriented graph, where $\mathrm{\Lambda }=[{\mathrm{\Lambda }}_1,{\mathrm{\Lambda }}_2,...,{\mathrm{\Lambda }}_n]$ represents the set of nodes. Each node i represents the $i^{th}$ agent, and

$$\mathrm{{\rm Y}}=(i,j)\in \mathrm{\Lambda }\times \mathrm{\Lambda },j\in N_i$$

represents the collection of edges linking the nodes, where $N_i$ denotes the set of node indexes connected to the $i^{th}$ node. Here, $(i;j)$ signifies a connection between nodes i and j, with j being in $N_i$, although i may not be in $N_j$. Therefore, $(i;j)$ and $(j;i)$ do not obligatory denote the same edge. These node connections are consolidated into a matrix $M_d=\left[a_{ij}\right]$, known as the adjacency matrix or connection matrix, with dimensions $N\ast N$. The elements within the matrix indicate whether pairs of vertices are adjacent in the graph or not.

$$a_{kj}=\left\{\begin{array}{cc}1\hfill & \mathrm{i}\mathrm{f} \mathrm{k} \mathrm{i}\mathrm{s} \mathrm{c}\mathrm{o}\mathrm{n}\mathrm{n}\mathrm{e}\mathrm{c}\mathrm{t}\mathrm{e}\mathrm{d} \mathrm{t}\mathrm{o} \mathrm{j}\hfill \\ 0\hfill & \mathrm{i}\mathrm{f} \mathrm{n}\mathrm{o}\mathrm{t}.\hfill \end{array}\right.$$

The degree matrix Q is a diagonal matrix of size $N\times N$, providing information regarding the number of edges connected to each node.

$$Q_{ij}=\left\{\begin{array}{cc}degree\left({\Delta }_i\right)\hfill & \mathrm{i}\mathrm{f} i=j\hfill \\ 0\hfill & \mathrm{i}\mathrm{f} \mathrm{n}\mathrm{o}\mathrm{t}.\hfill \end{array}\right.$$

The Laplacian matrix $H=\left[l_{ij}\right]$ is represented by

$$H=Q-M$$

The components within this matrix are as follows::

$$h_{kj}=\left\{\begin{array}{cc}-a_{kj}\hfill & \mathrm{i}\mathrm{f} k\ne j\hfill \\ \sum _{j=1}^N{a}_{kj}\hfill & \mathrm{i}\mathrm{f} k=j.\hfill \end{array}\right.$$

2.1.3. Closed-Loop System

Consider a collection of $N=3$ agents of significant scale, wherein the conduct of each agent is delineated by a nonlinear controlled model.

Figure 1 shows the master–slave configuration considered in this study, and the matrices are as follows:

$$A=\left[\begin{array}{ccc}0& 0& 0\\ 1& 0& 0\\ 0& 1& 0\end{array}\right],D=\left[\begin{array}{ccc}0& 0& 0\\ 0& 1& 0\\ 0& 0& 1\end{array}\right]\mathrm{and}L=\left[\begin{array}{ccc}0& 0& 0\\ 1& -1& 0\\ 0& 1& -1\end{array}\right]$$

Remember, the protocol can be written as follows:

$$u_i=-P\left(X_i\right)(\sum _{j=1}^N{a}_{ij}(X_i-X_j))$$

(1)

where $P\left(X_i\right)\in {\Re }^{n\times m}$, and $a_{ij}$ are the adjacent elements linked to $\mathcal{G}$.

2.2. Wheeled Mobile Robot Modeling

A unicycle is a robot driven by two independent wheels. It moves in a planar area referenced by an inertial reference $(0,\overrightarrow{x},\overrightarrow{y})$. The kinematic model is illustrated in Figure 2.

The continuous state-space representation is given as follows:

$$\left\{\begin{array}{c}\dot{x}\left(t\right)=vcos\left(\theta \left(t\right)\right)\hfill \\ \dot{y}\left(t\right)=vsin\left(\theta \left(t\right)\right)\hfill \\ \dot{\theta }\left(t\right)=\omega \left(t\right)\hfill \\ \dot{v}\left(t\right)=a\left(t\right)\hfill \end{array}\right.$$

(2)

where x and y denote the position along the x-axis and the y-axis, respectively; $v\in \Re$ represents the linear speed associated with the center of mass; $\theta$ is the orientation angle; $\omega$ is the angular speed of the center of mass; a is the acceleration; and u represents the input vector $u={\left[\begin{array}{cc}\omega & a\end{array}\right]}^T$. Then, the generalized robot model is given by

$$\left\{\begin{array}{cc}\hfill \dot{X}\left(t\right)& =f(X,u,t)\hfill \\ \hfill Y\left(t\right)& =CX\left(t\right)\hfill \end{array}\right.$$

(3)

where $X={\left[\begin{array}{cccc}x& y& \theta & v\end{array}\right]}^T$ is the state vector, and $C=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\end{array}\right]$ is the observation matrix that provides the system its observability condition.

We studied a sinusoidal trajectory, so we developed a regulator that allows us to control the robot.

$$\left\{\begin{array}{cc}{x}_d\left(t\right)\hfill & =t\hfill \\ y_d\left(t\right)\hfill & =sin\left(t\right)\hfill \end{array}\right.$$

(4)

For this, we used the method of linearizing looping. The command will be, in the end, as follows:

$$\left(\begin{array}{c}{u}_1\\ u_2\end{array}\right)={\left(\begin{array}{cc}-vsin\left(\theta \right)& cos\left(\theta \right)\\ vcos\left(\theta \right)& sin\left(\theta \right)\end{array}\right)}^{-1}\left(\begin{array}{c}(x_d-x)+2(\dot{x}-vcos\left(\theta \right))+\ddot{x_d}\\ (y_d-y)+2(\dot{y}-vsin\left(\theta \right))+\ddot{y_d}\end{array}\right)$$

(5)

If we define the error vector,

$$e=(e_x,e_y)$$

the dynamics of the error are written as follows:

$$\left(\begin{array}{c}{e}_x+2\dot{e_x}+\ddot{e_x}\\ e_y+2\dot{e_y}+\ddot{e_y}\end{array}\right)=\left(\begin{array}{c}0\\ 0\end{array}\right)$$

which is stable and converges rapidly to 0. According to Euler’s approximation, we discretize state model $\left(1\right)$ using a sampling time $T_e$ as follows:

$$\left\{\begin{array}{c}{x}_{k+1}=x_k+T_e{v}_{k}cos\left({\theta }_k\right)\hfill \\ y_{k+1}=y_k+T_e{v}_{k}sin\left({\theta }_k\right)\hfill \\ {\theta }_{k+1}={\theta }_k+T_e{\omega }_k\hfill \\ v_{k+1}=v_k+T_e{a}_k\hfill \end{array}\right.$$

(6)

2.3. Simulations

NOTATION:

• m: The master robot,
• $s_1$: The first slave robot,
• $s_2$: The second slave robot,
• $X_d={\left[\begin{array}{cccc}{x}_d& y_d& {\theta }_d& v_d\end{array}\right]}^T$: State vector of the desired trajectory,
• $X_m={\left[\begin{array}{cccc}{x}_m& y_m& {\theta }_m& v_m\end{array}\right]}^T$: State vector of the master robot,
• $X_{s1}={\left[\begin{array}{cccc}{x}_{s1}& y_{s2}& {\theta }_{s1}& v_{s1}\end{array}\right]}^T$: State vector of the first slave robot,
• $X_{s2}={\left[\begin{array}{cccc}{x}_{s2}& y_{s2}& {\theta }_{s2}& v_{s2}\end{array}\right]}^T$: State vector of the second slave robot,
• $u_m={\left[\begin{array}{cc}{u}_{ml}& u_{mr}\end{array}\right]}^T$: The left and right controllers of the master robot,
• $u_{s1}={\left[\begin{array}{cc}{u}_{s1l}& u_{s1r}\end{array}\right]}^T$: The left and right controllers of the first slave robot,
• $u_{s2}={\left[\begin{array}{cc}{u}_{s2l}& u_{s2r}\end{array}\right]}^T$: The left and right controllers of the second slave robot.

Consider the desired trajectory in Figure 3.

We observe that the robot master accurately follows this trajectory, which is also replicated by the two robot slaves, as depicted in Figure 4, Figure 5 and Figure 6.

We get the responses of the master and the slaves shown in Figure 7 and Figure 8, also the control is shown in Figure 9, Figure 10 and Figure 11.

3. Fault Detection Based on the Extended Kalman Filter

3.1. Extended Kalman Filter and Fault Diagnosis

3.1.1. The Extended Kalman Filter (EKF)

In fact, fault detection means identifying and diagnosing malfunctions within a system. This involves recognizing deviations from the system’s normal or expected behavior, which could be indicative of faults such as sensor errors, actuator failures, process disturbances, or other issues affecting the system’s performance. Fault detection typically involves monitoring the system’s outputs and comparing them to the predicted values based on a model of the system’s normal operation. The extended Kalman filter (EKF) plays a crucial role in this process by providing a dynamic model that can estimate the system’s state variables and predict future outputs. Any significant discrepancies between the predicted and actual outputs can indicate the presence of a fault.

Within the extended Kalman filter framework, the nonlinearities inherent in the system dynamics are approximated using a linearized rendition of the nonlinear model based on the most recent state estimate. Let us consider the system characterized by the following state equations:

$$\left\{\begin{array}{c}X(k+1)=f(X,u,k)+\rho \left(k\right)\hfill \\ Y(k+1)=h(X,u,k)+\gamma \left(k\right)\hfill \end{array}\right.$$

(7)

$\rho \left(k\right)$ and $\gamma \left(k\right)$ denote the process and observation noises, which are assumed to have a zero mean with covariances ${\mathrm{\Psi }}_{{\rho }_k}$ and ${\mathrm{\Psi }}_{{\gamma }_k}$, respectively. Function f, defined as nonlinear according to Equation $\left(7\right)$, is employed to compute the predicted state from the previous estimate, as is function h for predicting the measurement from the predicted state. However, due to the nonlinearity of f and h, a Jacobian matrix of partial derivatives is computed, since these functions cannot be directly applied to the covariance.

• Hypothesis:

As stated in [17], when the extended Kalman filter (EKF) is applied to a system and placed in a canonical observation form, it gains the following properties associated with global convergence:

• The pair of matrices $(A,C)$ is detectable, which means that there is no unstable mode or no observability in the system.
• The signals $\rho \left(k\right)$ and $\gamma \left(k\right)$ are central Gaussian white noises. The Density Power Spectral (DSP) covariances ${\mathrm{\Psi }}_{{\rho }_k}$ and ${\mathrm{\Psi }}_{{\gamma }_k}$ mean

$$\left\{\begin{array}{cc}\mathbb{E}\left[\gamma \left(i\right)\gamma {\left(j\right)}^T\right]={\mathrm{\Psi }}_{{\rho }_k},\hfill & \mathrm{i}\mathrm{f} i=j\hfill \\ \mathbb{E}\left[\rho \left(i\right)\rho {\left(i\right)}^T\right]={\mathrm{\Psi }}_{{\gamma }_k},\hfill & \mathrm{i}\mathrm{f} i=j\hfill \\ \mathbb{E}\left[\gamma \left(i\right)\rho {\left(j\right)}^T\right]=0,\hfill & \forall i,j.\hfill \end{array}\right.$$

(8)

where $\mathbb{E}[..]$ represents the mathematical expectation.

The latter equation illustrates the stochastic independence of the noises $\rho$ and $\gamma$. This assumption is introduced to simplify the subsequent calculations but is not obligatory.

• Correction:

• Updated state estimate:

  $${\widehat{x}}_{k/k}={\widehat{x}}_{k/k-1}+{\mathbb{K}}_k{\widehat{y}}_k$$

  (9)
• Updated covariance estimate:

  $${\mathrm{\Psi }}_{k/k}=(I-{\mathbb{K}}_k{C}_k){\mathrm{\Psi }}_{k/k-1}$$

  (10)
• Measurement residual:

  $${\tilde{y}}_k=y_k-C_k{\widehat{x}}_{k/k-1}$$

  (11)
• Innovation covariance:

  $${\mathbb{Z}}_k=C_k{\mathrm{\Psi }}_{k/k-1}{C_k}^T+{\mathrm{\Psi }}_{{\gamma }_k}$$

  (12)
• Near-optimal Kalman gain:

  $${\mathbb{K}}_k={\mathrm{\Psi }}_{k/k-1}{C_k}^T{{\mathbb{Z}}_k}^{-1}$$

  (13)

• Prediction:

• Predicted state estimate:

  $${\widehat{x}}_{k+1/k}=A_k{\widehat{x}}_{k/k}+u_k$$

  (14)
• Predicted covariance:

  $${\mathrm{\Psi }}_{k+1/k}=A_k{\mathrm{\Psi }}_{k/k}{A_k}^T+{\mathrm{\Psi }}_{{\rho }_k}$$

  (15)

where $A_k$ is the linearized matrix of the function f, which is written as follows:

$$A_k=\frac{\delta f}{\delta X}{|}_{{\widehat{x}}_{k/k}}$$

Remark 1.

Occasionally, numerical issues can cause the covariance of innovation $Z_k$ to lose its positive definite nature. In such instances, it is advisable to substitute the equation for covariance estimation with

$${\mathrm{\Psi }}_{k/k}=\sqrt{(I-K_k{C}_k){\mathrm{\Psi }}_{k/k-1}{\mathrm{\Psi }}_{k/k-1}^T{(I-K_k{C}_k)}^T}$$

The replacement will always ensure a positive, definite outcome, even if the matrix ${\mathrm{\Psi }}_{k/k-1}$ is not. Consequently, the Kalman equations will exhibit greater stability, as any minor deviations in the positive definite nature of the covariance matrices will be corrected in the subsequent iteration. According to $\left(14\right)$,

$$A_k=\left[\begin{array}{cccc}1& 0& -T_{e}vsin\left(\theta \right)& cos\left(\theta \right)\\ 0& 1& T_{e}vcos\left(\theta \right)& sin\left(\theta \right)\\ 0& 0& 1& 0\\ 0& 0& 0& 1\end{array}\right]$$

Suppose that the signals ${\gamma }_k$ and ${\rho }_k$ are Gaussian white noise with a unit covariance matrix; that is to say,

$${\mathrm{\Psi }}_{\gamma }=\left[\begin{array}{cc}1& 0\\ 0& 1\end{array}\right]{\mathrm{\Psi }}_{\rho }=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& 1\end{array}\right]$$

Also, we take the sample time $Te=0.01$.

3.1.2. Fault Diagnosis Steps

Figure 12 describes the fault detection procedure in the master–salve robot configuration.

This configuration has the following components:

• Master Robot: Sends control commands to the Slave Robot.
• Slave Robot: Execute actions based on the received commands.
• Sensors: Collect data from the environment and the robots’ states, providing inputs for the EKF.
• Actuators: Perform the necessary actions in response to control signals.
• Extended Kalman Filter (EKF): Estimates the system’s states based on sensor data and predicted models.
• Residual Generator: Calculates residuals by comparing the EKF’s state estimates with actual measurements.
• Fault Decision Module: Analyzes the residuals to detect any discrepancies indicating potential faults, triggering appropriate responses if faults are detected.

Generally, a fault diagnosis system follows three steps: a residual generation, a residue evaluation, and a decision logic [18].

• Step 1: Residual generation

The residual generator generates a fault indicator vector, or residual vector, denoted r, based on the measurements of the input and output variables of the system. The nominal value of the residue, excluding transient effects, is theoretically equal to zero under the normal operating conditions of the monitored system. When a fault appears, this residual moves away from zero depending on the fault.

• Step 2: Residue evaluation

The residual evaluation module consists of measuring the residue and determining whether the system is functioning properly or not using specific algorithms and methods [18]. Detecting a fault typically involves comparing the residues with a predetermined detection threshold $t_{th}$. This threshold represents a crucial aspect of residual-based FDI methods, defined as the boundary value for the deviation of a residue from zero. Thus, the process of fault detection proceeds as follows:

$$r=\left\{\begin{array}{cc}1\hfill & if,r>\left|t_{th}\right|\hfill \\ 0\hfill & if,r<\left|t_{th}\right|.\hfill \end{array}\right.$$

Excessively high thresholds may result in failing to detect a fault (missed alarm), while overly low thresholds may lead to false alarms, detecting faults in healthy conditions [19]. There exist two categories of thresholds [8]: the first being a constant threshold, and the second, an adaptive one. The adaptive threshold is employed to accommodate the inevitable parameter uncertainty, disturbances, and noise encountered in practical applications.

• Step 3: Decision

This step involves examining the outcome of evaluating a set of residues, and, based on the pattern of activated and non-activated tests, it generates a determination regarding the faulty component within the monitored system.

3.2. Closed-Loop System

The closed-loop system was used in Simulink/Matlab and is shown in the functional diagram in Figure 13.

The robot was controlled in order to follow a desired trajectory given by $P_d={[x_d,y_d]}^T$, as shown in Figure 14.

3.3. Simulation Results

We noticed that the robot master follows the desired trajectory (see Figure 15).

The fault scenario addressed involves an offset applied to the x measurement at the 15 s mark. Subsequently, we applied our Extended Kalman Filter (EKF), and the resulting robot trajectory is illustrated in Figure 16.

It is observed that there is a slight deviation attributable to the applied fault, yet the robot continues to track the same trajectory consistently.

Furthermore, upon introducing a fault (considered an intermittent fault, such as a switch) to a parameter at time t = 15 s, a minor peak is observed (see Figure 17), after which the robot promptly returns to its intended trajectory. Hence, it can be concluded that the Extended Kalman Filter effectively identifies the fault introduced into the system.

4. Fault Detection in Multi-Robot System

In the preceding section, the system (consisting of a robot master and slaves) executes its trajectory within an ideal environment. However, real-world environments lack such ideal conditions. Thus, we aimed to introduce a fault and observe how the system responds to the challenge. Indeed, the multi-robot system under fault is described in the following figure (see Figure 18). It was observed that the robot master adheres to its trajectory, as depicted in Figure 3.

Subsequently, we induced an offset fault in the master robot’s x measurement at 15 s, as illustrated in Figure 19.

The responses of both the master and the slaves are depicted in the subsequent figures (Figure 20, Figure 21 and Figure 22). It is observed that the trajectory of the robots experiences a slight disturbance at a specific time, yet it promptly returns to its intended path without deviating from the desired trajectory.

Figure 23 and Figure 24 show the x and y measurements of the desired trajectory, the master and the slaves, respectively.

Furthermore, the simulations of the controllers for both the master and the slaves are illustrated in Figure 25, Figure 26 and Figure 27, respectively. It is observed that the robot master adheres to the desired trajectory until time t = 15 s, at which point it deviates slightly. However, after a few seconds, it resumes following the trajectory initially set.

Meanwhile, our attention is directed toward the behaviors of the robot slaves, which entail two cases for investigation: firstly, when a robot slave operates without fault, and secondly, when a robot slave is subjected to a fault injection. The simulations depicted in Figure 21 and Figure 22 revealed the impact on the functionality of the slave robot. Notably, a minor peak is observed in the slave responses (refer to Figure 23 and Figure 24), following which it swiftly resumes its trajectory.

Fault Diagnosis

To utilize the extended Kalman filter (EKF) for fault detection in a wheeled mobile robot, the following procedural steps are advised:

1- System Modeling: Develop a comprehensive model that characterizes the robot’s behavior under both normal operating conditions and various fault scenarios.

2- State Estimation: Implement the EKF to estimate the current state of the robot utilizing sensor measurements.

3- Fault Models: Define specific fault models detailing how each fault impacts the robot’s state and sensor measurements.

4- Residual Calculation: Calculate residuals by computing the disparity between actual measurements and estimated measurements, based on the fault models delineated in the preceding step.

5- Fault Detection: Employ statistical tests or threshold-based techniques on the residuals to identify the occurrence of faults.

6- Fault Diagnosis: Initiate the fault diagnosis phase subsequent to the detection of faults.

For establishing thresholds, the system should first undergo simulations under fault-free conditions, followed by simulations with faults. The fault-free simulations aid in determining thresholds $t_{th}$ through the application of the three-sigma method:

$$\left\{\begin{array}{c}-t_{th}=-3\sigma \hfill \\ +t_{th}=+3\sigma \hfill \end{array}\right.$$

where $\sigma$ denotes the standard deviation of residual r.

Note that $\sigma$ reflects the EKF accuracy and is calculated based on the EKF error:

$$\sigma =\sqrt{\frac{1}{n}\sum _{i=1}^n\left(e_i^2\right)}$$

(16)

As mentioned in the previous section, the fault is said to be detected when the residual exceeds the threshold more than $|t_{th}|$.

Based on the EKF in our case, we calculated the difference between the values of the robot’s state vector and the values of the estimated state vector $X_e$. So four residuals are generated for each robot:

$$\left\{\begin{array}{c}{r}_x=x-x_e\hfill \\ r_y=y-y_e\hfill \\ r_{\theta }=\theta -{\theta }_e\hfill \\ r_v=v-v_e\hfill \end{array}\right.$$

where the index e means the estimated value. Each residual is compared to the threshold.

Table 1 summarizes the signatures of the residuals under a fault applied to the robot master and the slave robots. The different residual signatures allow for fault isolation. We notice that when the fault appears in the robot master, the other two robots (slaves) are affected. On the other side, if we insert the fault in the robot slaves, the master is not affected, so we conclude that the fault affects only the following robots. Hence, we can say that the fault propagates in one direction only. As shown in the figures (Figure 28, Figure 29 and Figure 30), a fault appears at time t = 15 s and is detected, and the detection delay does not affect the system performance.

5. Conclusions

In this paper, we consider the architecture of a network of three robots, with a master and two slaves working in consensus. The main task is assigned to the master, and the two slaves follow. Graph theory is used to model the whole system. Next, in order to continuously estimate the state of each robot, an extended Kalman filter is assigned to each robot. The residual generator compares the current state of the robot with its estimated state. It deduces whether a fault has occurred or not. We noticed that faults propagate from the master to the slaves according to the orientation of the arcs in the graph. In analyzing the fault signature table and the adjacency matrix (A), this observation allowed us to isolate faulty robots. The problem becomes more complex when the graph is not a directed graph. In this case, a temporal analysis of the moment of fault occurrence is mandatory. This is our perspective for future work.