# Energy Efficient Distributed Fault Identification Algorithm in Wireless Sensor Networks

Authors: Meenakshi Panda; P. M. Khilar
Journal: Journal of Computer Networks and Communications
 (2014)

---

## Abstract

A distributed fault identification algorithm is proposed here to find both hard and soft faulty sensor nodes present in wireless sensor networks. The algorithm is distributed, self-detectable, and can detect the most common byzantine faults such as stuck at zero, stuck at one, and random data. In the proposed approach, each sensor node gathered the observed data from the neighbors and computed the mean to check whether faulty sensor node is present or not. If a node found the presence of faulty sensor node, then compares observed data with the data of the neighbors and predict probable fault status. The final fault status is determined by diffusing the fault information from the neighbors. The accuracy and completeness of the algorithm are verified with the help of statistical model of the sensors data. The performance is evaluated in terms of detection accuracy, false alarm rate, detection latency and message complexity.


---

## Body

## 1. Introduction

Recent advances in microsensor technology, low-power very large scale integration (VLSI), and wireless communication have led to the development of distributed wireless sensor network (WSN) [1, 2]. Due to their several popular applications, efficient design and implementation of WSNs become a hot research area in recent years. The major problems such as the limited battery power, less computing capabilities, and inefficient use of communication resources make the WSN deployment challenging particularly when WSN is deployed to function for a long duration. Among these obstacles, the most difficult one is the mysterious data which is sent by a faulty sensor node either to the fusion center or to the neighboring nodes on demand.During the life span of a WSN, a number of unexpected situations such as the misbehavior of sensor nodes, providing unexpected results and not receiving information from specific sensor nodes, are observed [3–6]. This affects the performance of WSN. This may be caused due to a number of valid reasons such as improper functioning of hardware and software units, malicious interference, battery exhaustion, and natural calamities. In fact, these behaviors of wireless sensor nodes are characterized as Byzantine faulty behavior. Therefore, it is necessary to identify the Byzantine faulty sensor nodes in WSN.In the literature, the faults in WSN are broadly classified into two types such as hard fault (permanent fault or static fault) [7–12] and soft fault (or dynamic fault) [13–16]. When a sensor node fails to communicate with the rest of the nodes in the network, that node is considered as hard faulty sensor node. When few sensor nodes are able to sense the environment and communicate with the other sensor nodes but transmit some erroneous messages at a particular time, such sensor nodes are considered as soft faulty sensor nodes. The sensor nodes that are capable of transmitting data, receiving data, and computing the desired task correctly are said to be fault free sensor nodes.Depending on the faulty behavior of the sensor nodes at different time instants, the soft faulty nodes are further classified into three different categories, namely, transient fault [17], intermittent fault [8], and Byzantine fault [18]. When the sensor nodes are subjected to transient fault, they do not perform their desired task for a short duration of time. During this faulty duration, they send some arbitrary data to other sensor nodes instead of the correct value. When a sensor node suffers from intermittent fault, they behave correctly for some period of time and behave incorrectly for some another period of time. It becomes difficult to predict the fault status (faulty or fault free) of a sensor nodes. Many algorithms have been proposed for intermittent fault detection in WSN based on the probabilistic approach [8] in the literature. When the sensor nodes are subjected to Byzantine fault, the faulty node behaves arbitrarily which is also difficult to predict. The Byzantine faults are further classified as stuck at zero, stuck at one, and random fault. The detailed description is explained in fault model under Section 3.The proposed fault identification algorithm considers the Byzantine behavior of sensor nodes during the diagnosis time. Though many detection algorithms exist in the literature to detect permanent or hard faults in WSNs, but few algorithms consider transient and intermittent faulty sensor nodes [8]. For the best of our knowledge, none of the Byzantine soft fault detection algorithm for WSN has considered the following types of faults such as stuck-at-zero, stuck-at-one, random, and hard faults.The performance of the sensor network degrades if a faulty sensor node sends erroneous data. In both centralized [19] and distributed approach [20], the information from all the sensor nodes in the network is required for either global decision or estimation (in case of global optimization). If the network is unaware of the faulty sensor nodes, then the fusion center or central processor leads to an erroneous solution due to wrong information from all the faulty sensor nodes.In the literature, both centralized [19] and distributed soft fault [21, 22] identification methods are proposed. In centralized approach, the sensor nodes send their data over a long distance to the fusion center. Then the fusion center identifies the faulty sensor node using a fault detection algorithm. The major disadvantage of the centralized method is the quick drainage of sensor node’s energy due to more communication overhead, specially for the nodes nearer to the fusion center. And this method also contains an ultrareliable node that maintains the status about the entire WSN. In fact, the failure of this node results in catastrophic situation due to single point of failure.Due to these shortcomings in centralized method, distributed fault detection algorithms are proposed by various researchers. Every node runs the fault detection algorithm by accumulating information from the neighbors and then maintains the fault status of the entire network. The distributed methods available in the literature [21, 22] identify the soft faulty sensor nodes by collecting the information from the neighbors for multiple times. Since each sensor node communicates multiple times with the neighboring sensor nodes, the distributed algorithm requires more energy which makes the algorithm energy inefficient. To minimize the communication overhead, miss prediction of the faulty sensor nodes, and increasing the overall performance of the network, a novel distributed fault identification algorithm is proposed.In the proposed self-detectable distributed algorithm for identifying the Byzantine soft faulty sensor nodes, every sensor node in the network shares their sensed data to the neighbors and predicts the probable fault status of every other sensor node. After sharing the probable fault status, the majority voting scheme is used for identifying the final fault status of sensor nodes. The proposed approach reduces the communication overhead to make the fault identification algorithm energy efficient. The main contribution of this paper is on (i) the design and evaluation of an efficient distributed self-fault detection algorithm for identifying soft faulty sensor nodes in WSN, (ii) calculating the mean to know the presence of faulty sensor node in the neighborhood which reduces the computational time, (iii) implementation of the algorithms using NS3 [23], and (iv) comparing the performance of the algorithm with the existing algorithm [21, 22].The remaining part of the paper is organized as follows. In Section2, the related work presents an exhaustive review about the previous work on soft fault identification. The network model used for the development of the algorithm is discussed in Section 3. The proposed distributed fault identification algorithm is given in Section 4. The analytical model has been provided in Section 5 which proves the correctness of the proposed algorithm. We described the simulation results and compared the performance with the fault identification algorithm in Section 6. Finally, Section 7 concludes the paper with discussions.


## 2. Related Work

In this section, the work proposed by authors on soft fault identification in WSNs is briefly discussed. The emphasis is given to the distributed soft fault detection methods. A probabilistic soft fault detection scheme in multiprocessor system is proposed in [8]. In this technique, all processors are assigned a specific task. Each processor evaluates the task and sends the result to the processor which is assigned this task. The set of results after evaluating the task are obtained by the processors is known as a syndrome. It performs the above operation repeatedly, collects multiple syndromes, and stores them locally in its memory. Finally, each processor analyzes the syndrome to identify the faulty processors present in the system. This approach requires O
(
M
c
) time where M represents the maximum number of processors tested by a processor and c is the maximum times required to collect the results.In [10], the authors have proposed a Byzantine soft fault detection algorithm in WSNs. The technique is centralized sequence based soft fault detection approach where the entire rectangular terrain is partitioned into number of subregions. Each subregion is assigned an identifier based on its distance to the rest of the sensor nodes present in the network. When an event occurs, each sensor node sends their sensed data to the fusion center. Then the fusion center reestimates a sequence based on the received signal strength from the received data. This method has many demerits. First, the central node keeps all identifiers of the subregions for which large amount of the memory is required. Since each node required a shortest path for forwarding sensed data to the fusion center so that extra time and message required finding the shortest path for forwarding sensed data to the fusion center. Secondly, during the transmission the signal strength may change due to different environmental causes. Since the signal strength is the major parameter, it may result in error while detecting faults in a dynamic environment.Since centralized approach requires more communication resources, the algorithm is energy inefficient. Therefore, a distributed soft fault detection scheme for WSNs has been proposed by authors in [17]. Each sensor node performs local comparisons between own sensed data and its neighbor at a particular time instant and is stored locally in a table. This process is repeated for constant (c) times (say) and at each time the comparison results are stored in the table. In the final step, every sensor node calculates own fault status by analyzing the data stored in the table. The disadvantage of this distributed approach is that every sensor node collects data from their neighbors for multiple times which causes more communication overhead.In [24], a localized fault identification algorithm in WSNs is analyzed. It is a distributed fault identification algorithm, where each sensor node compares its own sensed data with the median of the neighbor’s data in order to determine its own status. The performance of localized diagnosis is limited due to the nonuniform nature of the sensor node in WSNs. Chen et al. in [21] have proposed a distributed fault identification algorithm such as that given in [22, 25, 26]. Each sensor node compares its own sensed data with its neighbors and sends back the results to the neighboring nodes. Each sensor node is tagged with a name called likely fault free or likely faulty. Each likely fault free sensor node has been identified as fault free sensor sensor nodes by using some rigid criteria. Finally, the remaining likely fault free or faulty sensor nodes are determined to be fault free or faulty with the help of the known fault free sensors or its own tendency value, respectively. In this algorithm, more communication overhead needed as every sensor node send their data multiple times to its neighbors in order to take a decision.In [18], a Byzantine fault identification method is proposed where each sensor node sends a set of messages to a group of sensor nodes and also receives messages from the same group. If the number of sending and receiving messages is equal, then the sensor node is identified as fault free; otherwise it is considered as a faulty sensor node. This approach needs multihop communication and requires coordination among the nodes to identify the faulty node. Ssu et. al. presented a fault detection method in WSNs [14] where each sensor node establishes a disjoint shortest path between two sensor nodes [27] and sends their message using the established path. If the node receives the same message which is sent by the node then that node is identified as fault free; otherwise it is labeled as faulty. This approach is used for multihop communication and requires more time to establish a path. However, the proposed distributed method does not need a multihop communication as it uses data from the one hop neighbors only for diagnosis purpose.In [28], a Byzantine fault diagnosis algorithm in Wireless Sensors Network is proposed which diagnoses the faulty sensor nodes based on the replication of services. This method needs additional information for multiple times from the neighboring sensor nodes to diagnose the Byzantine faulty sensor node. Due to this reason, the energy of the sensor node depletes quickly and as a result life span of the network reduces quickly.In [13], the authors Geeta et al. have proposed a battery power and interference model based fault tolerance mechanism to identify all the faulty nodes present in WSN. Hand-off mechanism is used to identify those faulty nodes which are going to be hard faulty due to low battery power. When a node suffers from low battery power, it transfers all the services to its neighboring node having highest battery power and remains idle so that quality of the network will not be degraded. Fault tolerance against interference is provided by dynamic power level adjustment mechanism by allocating the time slot to all the neighboring nodes. If a particular node wishes to transmit the sensed data, it enters active status and transmits the packet with maximum power; otherwise it enters into sleep status having minimum power that is sufficient to receive hello messages and to maintain the connectivity. The performance of the algorithm is evaluated in terms of packet delivery ratio, control overhead, memory overhead, and fault recovery delay. In [3], the authors Banerjee et al. have proposed an efficient fault detection algorithm based on the cellular automaton which diagnoses both hard and soft faulty sensor nodes.In [29], Panda and Khilar have proposed a modified three-sigma edit test based self-fault diagnosis algorithm to diagnose the soft faulty sensor nodes and time out mechanism to identify the hard faulty sensor nodes. In modified three-sigma edit test, the normalized median absolute deviation of neighborhood data for a sensor node is computed to find the fault status of sensor nodes. This approach is not suitable for sparsely deployed sensor node.The notations and their description which are used for developing and analyzing the proposed DFI algorithm are shown in Notations section.


## 3. Network Model for Fault Identification

In this section, the network model for the purposed distributed fault identification algorithm is described. The network model refers to system, fault, and radio model for energy calculation. The detailed description is given as follows.


### 3.1. System Model

Consider a sensor network withN distributed sensor nodes randomly deployed in a terrain of size R
×
R. Each sensor node s
i, 1 ≤
i
≤
N is located in the two-dimensional Euclidean plane R
2. Each sensor node s
i knows about its position P
i
(
x
i
,
y
i
), where 0
≤
x
i
,
y
i
≤
R. Sensor node s
i interacts with each other and employs a one-to-many broadcast primitive in their basic transmission mode. Consider all the sensor nodes are homogeneous and have a same transmission range T
r. The sensor network follows disk model [30] in order to generate network topology. The T
r of s
i is the radius of the circle where the node is presented at the center. Figure 1 depicts the arbitrary network topology based on the disk model. s
1
,
s
2
,
…
,
s
12 are a set of sensor nodes, and e
1
,
e
2
,
…
,
e
6 are the communication links between the sensor nodes. A sensor node s
1 can communicate with its immediate neighbors (
s
2
,
s
5
,
s
12
) if the radius of the sensor node s
1 is within T
r. The sensor nodes communicate with each other through an overlapping transmission range so that most of the rectangular terrain can be covered by the deployed sensor nodes. IEEE 802.15.4 is used as the MAC layer protocol to communicate with neighboring nodes. The degree of sensor node s
i is (
N
i
) which is defined as the number of one hop immediate neighbors associated with it.Figure 1
Arbitrary network topology based on unit disk model.


### 3.2. Fault Model

The deployment of sensor nodes in hostile and human inaccessible environment makes the sensor nodes suffer from many environment particle changes for which sensor nodes are subjected to various kinds of faults. In this paper, the sensor nodes are assumed to be suffering from Byzantine faults such as soft and hard fault. The soft fault includes stuck at zero, stuck at one, and random data fault, respectively [31]. A faulty sensor node is subjected to stuck at zero faults, if the value provided by the sensor node remains zero during identification period. When the sensor node provides maximal value (that can be the full scale value) then that type of fault is known as stuck at one. Similarly, in case of random fault, the data provided by a sensor node is random, varies from one time period to another, and ranges from minimum sensing value to maximum sensing value. The soft faulty sensor node suffers with either receiver circuit or sensor circuit failure (environment changes due to alpha and beta particles). However, the hard faulty sensor node suffers from transceiver circuit failure, microcontroller failure, or energy drainage (battery constraint and not rechargeable). The hard faulty sensor node remains silent throughout the life span of the network.Let the setS
F represents the randomly chosen sensor nodes, which are subjected to either hard or soft fault. More specifically, let S
1, S
2, S
3, and S
4 be the set of randomly chosen sensor nodes suffering from stuck at zero, stuck at one, random, and hard fault, respectively. The fault free sensor nodes in the network are S
G
=
S
-
S
F, where S
F
=
S
1
∪
S
2
∪
S
3
∪
S
4 and |
S
-
S
F
|
≫
|
S
1
∪
S
2
∪
S
3
∪
S
4
| and N
=
|
S
-
S
F
|
+
|
S
1
∪
S
2
∪
S
3
∪
S
4
|.The sensor nodes can disseminate its own sensed data to its neighborsNe
g
i and also collect the observations x
j
,
s
j
∈
Ne
g
i from the neighbors at time instantt. In the sensor network, some sensor nodes are subjected to a fault, whereas links are assumed to be fault free. The link faults can be detected by using error detecting and correcting codes which are usually implemented in the underlying networks. The fault free sensor node always provides accurate measured data within acceptable range, whereas faulty sensor node gives arbitrary value in different time.


### 3.3. Radio Model for Energy Calculation

It is well known that the sensor nodes use low power batteries (at most 1 joule) for data processing and communication. The battery power needs to be utilized in efficient manner. For data communication, each sensor is equipped with a wireless transceiver. Transmitter requires transmitting electronics and amplifier whereas receiver needs only receiving electronics for data transmission. Let,α
1
,
α
2, and α
3 be the amount of energy required for the transmitting electronics, amplifier, and receiving electronics, respectively. The α
1 and α
3 depend on factors such as the digital coding and modulation, whereas the α
2 depends on the transmission distance and the acceptable bit-error rate. For data transmission and reception, the free space (fs) fading channel models are used because every sensor node needs communication to only their neighboring nodes in a single hop. Depending on the distance between the transmitter and receiver, the free space coefficient is chosen. Let E
T
(
m
,
d
) and E
R
(
m
,
d
) be the amount of energy to transmit and receive m bytes of data over an Euclidean distance d. The total amount of energy is the sum of E
T
(
m
,
d
) and E
R
(
m
,
d
) which is given in [32]
(1)
E
T
m
,
d
=
m
*
α
1
+
α
2
*
d
α
,
E
R
m
,
d
=
m
*
α
3
,
where the free space coefficient α is defined in [33]
(2)
α
=
2
,
d
o
≤
d
4
,
d
o
>
d
,
where d
o is the minimum Euclidean distance between any two sensor nodes.


## 3.1. System Model

Consider a sensor network withN distributed sensor nodes randomly deployed in a terrain of size R
×
R. Each sensor node s
i, 1 ≤
i
≤
N is located in the two-dimensional Euclidean plane R
2. Each sensor node s
i knows about its position P
i
(
x
i
,
y
i
), where 0
≤
x
i
,
y
i
≤
R. Sensor node s
i interacts with each other and employs a one-to-many broadcast primitive in their basic transmission mode. Consider all the sensor nodes are homogeneous and have a same transmission range T
r. The sensor network follows disk model [30] in order to generate network topology. The T
r of s
i is the radius of the circle where the node is presented at the center. Figure 1 depicts the arbitrary network topology based on the disk model. s
1
,
s
2
,
…
,
s
12 are a set of sensor nodes, and e
1
,
e
2
,
…
,
e
6 are the communication links between the sensor nodes. A sensor node s
1 can communicate with its immediate neighbors (
s
2
,
s
5
,
s
12
) if the radius of the sensor node s
1 is within T
r. The sensor nodes communicate with each other through an overlapping transmission range so that most of the rectangular terrain can be covered by the deployed sensor nodes. IEEE 802.15.4 is used as the MAC layer protocol to communicate with neighboring nodes. The degree of sensor node s
i is (
N
i
) which is defined as the number of one hop immediate neighbors associated with it.Figure 1
Arbitrary network topology based on unit disk model.


## 3.2. Fault Model

The deployment of sensor nodes in hostile and human inaccessible environment makes the sensor nodes suffer from many environment particle changes for which sensor nodes are subjected to various kinds of faults. In this paper, the sensor nodes are assumed to be suffering from Byzantine faults such as soft and hard fault. The soft fault includes stuck at zero, stuck at one, and random data fault, respectively [31]. A faulty sensor node is subjected to stuck at zero faults, if the value provided by the sensor node remains zero during identification period. When the sensor node provides maximal value (that can be the full scale value) then that type of fault is known as stuck at one. Similarly, in case of random fault, the data provided by a sensor node is random, varies from one time period to another, and ranges from minimum sensing value to maximum sensing value. The soft faulty sensor node suffers with either receiver circuit or sensor circuit failure (environment changes due to alpha and beta particles). However, the hard faulty sensor node suffers from transceiver circuit failure, microcontroller failure, or energy drainage (battery constraint and not rechargeable). The hard faulty sensor node remains silent throughout the life span of the network.Let the setS
F represents the randomly chosen sensor nodes, which are subjected to either hard or soft fault. More specifically, let S
1, S
2, S
3, and S
4 be the set of randomly chosen sensor nodes suffering from stuck at zero, stuck at one, random, and hard fault, respectively. The fault free sensor nodes in the network are S
G
=
S
-
S
F, where S
F
=
S
1
∪
S
2
∪
S
3
∪
S
4 and |
S
-
S
F
|
≫
|
S
1
∪
S
2
∪
S
3
∪
S
4
| and N
=
|
S
-
S
F
|
+
|
S
1
∪
S
2
∪
S
3
∪
S
4
|.The sensor nodes can disseminate its own sensed data to its neighborsNe
g
i and also collect the observations x
j
,
s
j
∈
Ne
g
i from the neighbors at time instantt. In the sensor network, some sensor nodes are subjected to a fault, whereas links are assumed to be fault free. The link faults can be detected by using error detecting and correcting codes which are usually implemented in the underlying networks. The fault free sensor node always provides accurate measured data within acceptable range, whereas faulty sensor node gives arbitrary value in different time.


## 3.3. Radio Model for Energy Calculation

It is well known that the sensor nodes use low power batteries (at most 1 joule) for data processing and communication. The battery power needs to be utilized in efficient manner. For data communication, each sensor is equipped with a wireless transceiver. Transmitter requires transmitting electronics and amplifier whereas receiver needs only receiving electronics for data transmission. Let,α
1
,
α
2, and α
3 be the amount of energy required for the transmitting electronics, amplifier, and receiving electronics, respectively. The α
1 and α
3 depend on factors such as the digital coding and modulation, whereas the α
2 depends on the transmission distance and the acceptable bit-error rate. For data transmission and reception, the free space (fs) fading channel models are used because every sensor node needs communication to only their neighboring nodes in a single hop. Depending on the distance between the transmitter and receiver, the free space coefficient is chosen. Let E
T
(
m
,
d
) and E
R
(
m
,
d
) be the amount of energy to transmit and receive m bytes of data over an Euclidean distance d. The total amount of energy is the sum of E
T
(
m
,
d
) and E
R
(
m
,
d
) which is given in [32]
(1)
E
T
m
,
d
=
m
*
α
1
+
α
2
*
d
α
,
E
R
m
,
d
=
m
*
α
3
,
where the free space coefficient α is defined in [33]
(2)
α
=
2
,
d
o
≤
d
4
,
d
o
>
d
,
where d
o is the minimum Euclidean distance between any two sensor nodes.


## 4. Distributed Fault Identification (DFI) Algorithm

The proposed distributed fault identification (DFI) algorithm based on neighbor coordination approach has two phases such as partial self-fault identification and self-diagnosis phase. In partial self-fault identification phase, every sensor node in the network exchanges their sensed data with the neighboring sensor nodes. The probable fault status of own as well as its neighbors are estimated in this phase. The estimated status are exchanged among themselves in self-diagnosis phase. Each sensor node receives its probable fault status from the neighbors and diffuses the received status. Each sensor node compares its computed status with diffused status to predict its own status. All the notations used for describing the steps of the DFI algorithm are summarized in Notations section. Detailed description of different phases is given below.


### 4.1. Partial Self-Fault Identification Phase

Every sensor nodes
i
∈
S exchanges their measured data x
i with neighboring nodes Ne
g
i. Each sensor node s
i keeps the received data from the neighboring nodes Ne
g
i in N
x
i. After receiving the data, the partial self- and neighboring nodes fault status are computed based on the following observations.Case 1.
The remaining battery powerR
e
i of a sensor node s
i is computed with a constant battery power ζ to identify the hard faulty sensor node and the value for ζ is constant for all sensor nodes.
LetMinSense and MaxSense be the minimum and maximum sensing value of the sensor node s
i. The value of MinSense and MaxSense is constant and common to all the sensor nodes present in WSN. Cases 2 and 3 are based on MinSense and MaxSense value and used for identifying stuck at zero and stuck at one fault as given below.Case 2.
If the sensed datax
i of the sensor node s
i is MinSense, then the sensor node s
i is suffering from stuck at zero fault.Case 3.
If the sensed datax
i of the sensor node s
i is MaxSense, then the sensor node s
i is suffering from stuck at one fault.
Cases2 and 3 are based on the fact that when the observed data x
i of a sensor node s
i is the value of either MinSense or MaxSense, the sensor node s
i does not depend on the neighbors to identify its own fault status. However, Case 4 is based on the fact that if the observed data of the sensor node s
i is the value of neither MinSense nor MaxSense, the sensor node s
i needs to find its own status and its neighbors status as the observed data is random between MinSense and MaxSense.Case 4.
If the sensed datax
i of the sensor node s
i is between MinSense and MaxSense, then it performs the operation defined in (3) over the collected data from the neighboring nodes Neg
i and own sensed data x
i to identify self- and neighbors probable fault status:
(3)
μ
^
=
x
i
-
1
N
i
∑
s
j
∈
Neg
i
‍
x
j
≤
λ
1
,
where λ
1 is the threshold value and the optimum value of λ
1 is discussed in Section 5.
When condition (3) is satisfied by s
i then the node s
i and all its neighbors s
j
∈
Neg
i are fault free and become the members of set S
G. Otherwise the sensor node s
i and its neighboring nodes are suspected as faulty sensor node. To identify the exact status of sensor node s
i and neighboring nodes Neg
i, the sensor node s
i recomputes over the received data x
j
,
x
j
∈
N
x
i to identify the probable faulty sensor nodes. If the data x
j
,
x
j
∈
N
x
i matched with MinSense or MaxSense then assign the sensor node s
j to S
2 or S
3, respectively. Otherwise, the following operations over the collected data N
x
i are performed in order to identify the probable fault status of neighboring nodes Neg
i. Case 4 is further partitioned into four subcases which are given below.Case
4
.1 (x
i
-
x
j
>
λ
1 and x
j
≤
λ
2). In this case, the sensor node s
j is added to the set PFF
N
i and the sensor node s
i is detected as faulty sensor node.Case
4.2 (x
i
-
x
j
>
λ
1 and x
j
>
λ
2). In this case, both the sensor nodes s
i and s
j are faulty and the sensor node s
j is added to PF
N
i.Case
4.3 (x
i
-
x
j
≤
λ
1 and x
j
≤
λ
2). In this case, both the sensor nodes s
i and s
j have fault free status and the sensor node s
j is added to PFF
N
i.Case
4.4 (x
i
-
x
j
≤
λ
1 and x
j
>
λ
2). In this case, the sensor node s
i is fault free, the sensor node s
j is faulty and added to PF
N
i.The test outcome is0, if a sensor node s
i is found to be fault free after performing partial self-fault identification phase; otherwise it is 1. After performing the self-fault identification phase, self-diagnosis phase is carried out as follows.


### 4.2. Self-Diagnosis Phase

The self-diagnosis phase is based on the majority voting scheme to diagnose whether a sensor node is faulty or fault free [11]. In this phase, each sensor node s
i exchanges its neighbor status (i.e., 0 or 1) and also receives status from its neighboring nodes Ne
g
i. Therefore the sensor node s
i predicts its own status by analyzing the status received from its neighboring nodes Ne
g
i; that is, each sensor node s
i counts number of 0’s and 1’s it has received. If numbers of 0’s at s
i are more than numbers of 1’s at s
i, then s
i is diagnosed as fault free and belongs to set S
G; otherwise it is faulty and include to set S
4, respectively.The detailed description about the algorithm DFI is given in Algorithm1. The notations used for developing the Algorithm 1 are summarized in Notations section.Algorithm 1:Distributed fault identification in WSN.
Data: N
I Nodes, N
x
i, R
e
i
Result: Calculate S
1, S
2, S
3, S
4, and S
G
InitializeS
1
=
ϕ, S
2
=
ϕ, S
3
=
ϕ, S
4
=
ϕ, and S
G
=
ϕ
Partial self fault identification Phase
If  R
e
i
<
=
ζ  then
S
4
=
s
i;
else
if  x
i
=
M
i
n
S
e
n
s
e  then
S
1
=
s
i;
end
if  x
i
=
M
a
x
S
e
n
s
e  then
S
2
=
s
i;
end
Move to Algorithm2
end
Self Diagnosis Phase
s
i
∈
S send PFN to neighbors s
j
∈
Neg
i and receives PFN from s
j which is computed by the neighbors s
j.
From received data the sensor nodes
i prepares R
S
i.
if  N
z
(
R
S
i
)
>
N
o
(
R
S
i
)  then
Nodes
i is detected as fault free sensor node. S
G
=
s
i
else
Nodes
i is detected as random faulty sensor node. S
3
=
s
i
endAlgorithm 2:Random fault identification algorithm.
Data: N
x
i
Result: Calculate S
G, PFN and PFFN
S
G
=
ϕ, PFN
=
ϕ and PFFN
=
ϕ
CRDN
i
=
0;
for  j
=
1
,
…
,
|
Neg
i
| and s
j
∈
Neg
i  do
CRDN
i
=
CRDN
i
+
x
j;
end
CRDN
i
=
CRDN
i
/
N
i
if  |
x
i
-
CRDN
i
|
≤
θ
1  then
The nodes
i and s
j
∈
Neg
i are identified as likely fault free nodes;
Assign the nodes
i to S
G
else
for  j
=
1
,
…
,
|
Neg
i
|  do
if  x
j
=
M
i
n
S
e
n
s
e
or
x
j
=
M
a
x
S
e
n
s
e  then
PFFN
=
s
j
else
if  |
x
i
-
x
j
|
≻
θ
1 and x
j
≻
θ
2  then
PFFN
=
s
j
end
if  |
x
i
-
x
j
|
≤
θ
1 and x
j
≤
θ
2  then
PFN
=
s
j
end
if  |
x
i
-
x
j
|
≤
θ
1 and x
j
≻
θ
2  then
PFN
=
s
j
end
if  |
x
i
-
x
j
|
≻
θ
1 and x
j
≤
θ
2  then
PFFN
=
s
j
end
end
end
end


### 4.3. Complexity of the Algorithm DFI

The message complexity, energy complexity, and detection latency are the three important parameters to compare the performance of the proposed DFI algorithm with the existing algorithms Algo1 [21] and Algo2 [22]. The description of these parameters is as follows.


#### 4.3.1. Message Complexity

The message complexity of the algorithm is determined by considering the total number of messages exchanged over the network in both the partial self-fault identification and self-diagnosis phases. In the partial self-fault identification phase, each sensor nodes
i exchanges its own sensing data among the neighboring sensor nodes which requires N number of message exchange over the network. In self-diagnosis phase, each sensor node s
i estimates the probable fault status of its neighboring nodes and sends the status information to the neighboring nodes. This requires N number of message is exchanged over the network. To complete the DFI algorithm, total 2
N number of messages is exchanged over the network. Therefore, the total number of message exchanges is 2
N
≈
O
(
N
).


#### 4.3.2. Energy Complexity

We have calculated the energy requirement of the network to detect the faulty sensor nodes by using the DFI algorithm. As the energy consumed in communication dominates the energy consumption in processing (because of the development of low power VLSI and computing architecture), we have considered only energy complexity due to data transmission and reception during the fault diagnosis of sensor nodes [34]. The DFI algorithm needs message exchange twice by each sensor node. The energy calculation for each message transmission is provided separately.(A) The Energy Required for Exchanging the Sensed Data
x
i
. Let E
1
,
E
2
,
…
,
E
N be the energy which dissipates by the sensor nodes s
1
,
s
2
,
…
,
s
N, respectively. Let m be the message size of sense data and let T
r (transmission range) be the maximum distance a sensor node can transmit the message. Thus, the amount of energy required by a sensor for the transmission of m bits of message data is
(4)
E
T
i
m
,
T
r
=
m
α
1
+
α
2
T
r
α
.
This transmission energy is common for all the senor nodes in the network. However, the energy required to receive the data from the neighbors is different, because the degree of the sensor nodes is different. Therefore, the energy required by a sensor node s
i to receive data from all the neighbors is given as
(5)
E
R
i
m
,
T
r
=
N
i
m
α
3
,
where N
i is the degree of sensor node s
i.The total amount of energy required bys
i for data transmission and reception is
(6)
E
1
i
m
,
T
r
=
E
T
i
m
,
T
r
+
E
R
i
m
,
T
r
.(B) The Energy Required for Exchanging the Probable Fault Status. The sensor node exchanges p bits of information to its neighbors. According to the procedure given in Section 4.3.2(A), the total energy required by s
i here is given as
(7)
E
2
i
p
,
T
r
=
E
T
i
p
,
T
r
+
E
R
i
p
,
T
r
,
where E
T
i
(
p
,
T
r
)
=
p
[
α
1
+
α
2
T
r
α] and E
R
i
(
p
,
T
r
)
=
N
i
p
α
3.Therefore, the total energy required for each sensor node to detect soft faulty sensor nodes in the network is given as(8)
E
i
m
+
p
,
T
r
=
E
1
i
m
,
T
r
+
E
2
i
p
,
T
r
=
α
1
m
+
p
+
α
2
T
r
α
m
+
p
+
N
i
α
3
m
+
p
=
m
+
p
α
1
+
α
2
T
r
α
+
N
i
α
3
.
The total energy dissipated by the network for identifying the faulty sensor nodes is
(9)
E
total
m
,
d
=
∑
i
=
1
N
‍
E
i
m
+
p
,
T
r
.


#### 4.3.3. Detection Latency

The detection latency is defined as the maximum time required by a network to identify the fault status of every sensor node present in the network. The processing time of the sensor nodes is negligible due to the faster embedded processor and communication time is more than the processing time. Thus, the detection latency of the DFI algorithm is calculated by considering only transmission and reception time that is communication time. LetT
out be the maximum time set by the timer by each sensor node while exchanging the data with neighbors. In partial self-fault identification and self-diagnosis phase, each sensor node s
i exchanges one message in each phase. Therefore, the total time required by s
i is 2
T
out. A comparison study between DFI and existing Algo1 and Algo2 algorithms is tabulated in Table 1.Table 1
Comparison study on existing method with proposed scheme.
Comparison parameters
DFI algorithm
Algo1 (paper in [21])
Algo2 (paper in [22])
Message complexity
O
(
2
N
)
O
(
5
N
)
O
(
3
N
)
Detection latency
2
T
out
5
T
out
3
T
out
Energy
(
m
+
p
)
N
(
α
1
+
α
2
d
α
+
d
i
α
3
)
(
2
m
+
3
)
N
(
α
1
+
α
2
d
α
+
d
i
α
3
)
(
2
m
+
1
)
N
(
α
1
+
α
2
d
α
+
d
i
α
3
)


## 4.1. Partial Self-Fault Identification Phase

Every sensor nodes
i
∈
S exchanges their measured data x
i with neighboring nodes Ne
g
i. Each sensor node s
i keeps the received data from the neighboring nodes Ne
g
i in N
x
i. After receiving the data, the partial self- and neighboring nodes fault status are computed based on the following observations.Case 1.
The remaining battery powerR
e
i of a sensor node s
i is computed with a constant battery power ζ to identify the hard faulty sensor node and the value for ζ is constant for all sensor nodes.
LetMinSense and MaxSense be the minimum and maximum sensing value of the sensor node s
i. The value of MinSense and MaxSense is constant and common to all the sensor nodes present in WSN. Cases 2 and 3 are based on MinSense and MaxSense value and used for identifying stuck at zero and stuck at one fault as given below.Case 2.
If the sensed datax
i of the sensor node s
i is MinSense, then the sensor node s
i is suffering from stuck at zero fault.Case 3.
If the sensed datax
i of the sensor node s
i is MaxSense, then the sensor node s
i is suffering from stuck at one fault.
Cases2 and 3 are based on the fact that when the observed data x
i of a sensor node s
i is the value of either MinSense or MaxSense, the sensor node s
i does not depend on the neighbors to identify its own fault status. However, Case 4 is based on the fact that if the observed data of the sensor node s
i is the value of neither MinSense nor MaxSense, the sensor node s
i needs to find its own status and its neighbors status as the observed data is random between MinSense and MaxSense.Case 4.
If the sensed datax
i of the sensor node s
i is between MinSense and MaxSense, then it performs the operation defined in (3) over the collected data from the neighboring nodes Neg
i and own sensed data x
i to identify self- and neighbors probable fault status:
(3)
μ
^
=
x
i
-
1
N
i
∑
s
j
∈
Neg
i
‍
x
j
≤
λ
1
,
where λ
1 is the threshold value and the optimum value of λ
1 is discussed in Section 5.
When condition (3) is satisfied by s
i then the node s
i and all its neighbors s
j
∈
Neg
i are fault free and become the members of set S
G. Otherwise the sensor node s
i and its neighboring nodes are suspected as faulty sensor node. To identify the exact status of sensor node s
i and neighboring nodes Neg
i, the sensor node s
i recomputes over the received data x
j
,
x
j
∈
N
x
i to identify the probable faulty sensor nodes. If the data x
j
,
x
j
∈
N
x
i matched with MinSense or MaxSense then assign the sensor node s
j to S
2 or S
3, respectively. Otherwise, the following operations over the collected data N
x
i are performed in order to identify the probable fault status of neighboring nodes Neg
i. Case 4 is further partitioned into four subcases which are given below.Case
4
.1 (x
i
-
x
j
>
λ
1 and x
j
≤
λ
2). In this case, the sensor node s
j is added to the set PFF
N
i and the sensor node s
i is detected as faulty sensor node.Case
4.2 (x
i
-
x
j
>
λ
1 and x
j
>
λ
2). In this case, both the sensor nodes s
i and s
j are faulty and the sensor node s
j is added to PF
N
i.Case
4.3 (x
i
-
x
j
≤
λ
1 and x
j
≤
λ
2). In this case, both the sensor nodes s
i and s
j have fault free status and the sensor node s
j is added to PFF
N
i.Case
4.4 (x
i
-
x
j
≤
λ
1 and x
j
>
λ
2). In this case, the sensor node s
i is fault free, the sensor node s
j is faulty and added to PF
N
i.The test outcome is0, if a sensor node s
i is found to be fault free after performing partial self-fault identification phase; otherwise it is 1. After performing the self-fault identification phase, self-diagnosis phase is carried out as follows.


## 4.2. Self-Diagnosis Phase

The self-diagnosis phase is based on the majority voting scheme to diagnose whether a sensor node is faulty or fault free [11]. In this phase, each sensor node s
i exchanges its neighbor status (i.e., 0 or 1) and also receives status from its neighboring nodes Ne
g
i. Therefore the sensor node s
i predicts its own status by analyzing the status received from its neighboring nodes Ne
g
i; that is, each sensor node s
i counts number of 0’s and 1’s it has received. If numbers of 0’s at s
i are more than numbers of 1’s at s
i, then s
i is diagnosed as fault free and belongs to set S
G; otherwise it is faulty and include to set S
4, respectively.The detailed description about the algorithm DFI is given in Algorithm1. The notations used for developing the Algorithm 1 are summarized in Notations section.Algorithm 1:Distributed fault identification in WSN.
Data: N
I Nodes, N
x
i, R
e
i
Result: Calculate S
1, S
2, S
3, S
4, and S
G
InitializeS
1
=
ϕ, S
2
=
ϕ, S
3
=
ϕ, S
4
=
ϕ, and S
G
=
ϕ
Partial self fault identification Phase
If  R
e
i
<
=
ζ  then
S
4
=
s
i;
else
if  x
i
=
M
i
n
S
e
n
s
e  then
S
1
=
s
i;
end
if  x
i
=
M
a
x
S
e
n
s
e  then
S
2
=
s
i;
end
Move to Algorithm2
end
Self Diagnosis Phase
s
i
∈
S send PFN to neighbors s
j
∈
Neg
i and receives PFN from s
j which is computed by the neighbors s
j.
From received data the sensor nodes
i prepares R
S
i.
if  N
z
(
R
S
i
)
>
N
o
(
R
S
i
)  then
Nodes
i is detected as fault free sensor node. S
G
=
s
i
else
Nodes
i is detected as random faulty sensor node. S
3
=
s
i
endAlgorithm 2:Random fault identification algorithm.
Data: N
x
i
Result: Calculate S
G, PFN and PFFN
S
G
=
ϕ, PFN
=
ϕ and PFFN
=
ϕ
CRDN
i
=
0;
for  j
=
1
,
…
,
|
Neg
i
| and s
j
∈
Neg
i  do
CRDN
i
=
CRDN
i
+
x
j;
end
CRDN
i
=
CRDN
i
/
N
i
if  |
x
i
-
CRDN
i
|
≤
θ
1  then
The nodes
i and s
j
∈
Neg
i are identified as likely fault free nodes;
Assign the nodes
i to S
G
else
for  j
=
1
,
…
,
|
Neg
i
|  do
if  x
j
=
M
i
n
S
e
n
s
e
or
x
j
=
M
a
x
S
e
n
s
e  then
PFFN
=
s
j
else
if  |
x
i
-
x
j
|
≻
θ
1 and x
j
≻
θ
2  then
PFFN
=
s
j
end
if  |
x
i
-
x
j
|
≤
θ
1 and x
j
≤
θ
2  then
PFN
=
s
j
end
if  |
x
i
-
x
j
|
≤
θ
1 and x
j
≻
θ
2  then
PFN
=
s
j
end
if  |
x
i
-
x
j
|
≻
θ
1 and x
j
≤
θ
2  then
PFFN
=
s
j
end
end
end
end


## 4.3. Complexity of the Algorithm DFI

The message complexity, energy complexity, and detection latency are the three important parameters to compare the performance of the proposed DFI algorithm with the existing algorithms Algo1 [21] and Algo2 [22]. The description of these parameters is as follows.


### 4.3.1. Message Complexity

The message complexity of the algorithm is determined by considering the total number of messages exchanged over the network in both the partial self-fault identification and self-diagnosis phases. In the partial self-fault identification phase, each sensor nodes
i exchanges its own sensing data among the neighboring sensor nodes which requires N number of message exchange over the network. In self-diagnosis phase, each sensor node s
i estimates the probable fault status of its neighboring nodes and sends the status information to the neighboring nodes. This requires N number of message is exchanged over the network. To complete the DFI algorithm, total 2
N number of messages is exchanged over the network. Therefore, the total number of message exchanges is 2
N
≈
O
(
N
).


### 4.3.2. Energy Complexity

We have calculated the energy requirement of the network to detect the faulty sensor nodes by using the DFI algorithm. As the energy consumed in communication dominates the energy consumption in processing (because of the development of low power VLSI and computing architecture), we have considered only energy complexity due to data transmission and reception during the fault diagnosis of sensor nodes [34]. The DFI algorithm needs message exchange twice by each sensor node. The energy calculation for each message transmission is provided separately.(A) The Energy Required for Exchanging the Sensed Data
x
i
. Let E
1
,
E
2
,
…
,
E
N be the energy which dissipates by the sensor nodes s
1
,
s
2
,
…
,
s
N, respectively. Let m be the message size of sense data and let T
r (transmission range) be the maximum distance a sensor node can transmit the message. Thus, the amount of energy required by a sensor for the transmission of m bits of message data is
(4)
E
T
i
m
,
T
r
=
m
α
1
+
α
2
T
r
α
.
This transmission energy is common for all the senor nodes in the network. However, the energy required to receive the data from the neighbors is different, because the degree of the sensor nodes is different. Therefore, the energy required by a sensor node s
i to receive data from all the neighbors is given as
(5)
E
R
i
m
,
T
r
=
N
i
m
α
3
,
where N
i is the degree of sensor node s
i.The total amount of energy required bys
i for data transmission and reception is
(6)
E
1
i
m
,
T
r
=
E
T
i
m
,
T
r
+
E
R
i
m
,
T
r
.(B) The Energy Required for Exchanging the Probable Fault Status. The sensor node exchanges p bits of information to its neighbors. According to the procedure given in Section 4.3.2(A), the total energy required by s
i here is given as
(7)
E
2
i
p
,
T
r
=
E
T
i
p
,
T
r
+
E
R
i
p
,
T
r
,
where E
T
i
(
p
,
T
r
)
=
p
[
α
1
+
α
2
T
r
α] and E
R
i
(
p
,
T
r
)
=
N
i
p
α
3.Therefore, the total energy required for each sensor node to detect soft faulty sensor nodes in the network is given as(8)
E
i
m
+
p
,
T
r
=
E
1
i
m
,
T
r
+
E
2
i
p
,
T
r
=
α
1
m
+
p
+
α
2
T
r
α
m
+
p
+
N
i
α
3
m
+
p
=
m
+
p
α
1
+
α
2
T
r
α
+
N
i
α
3
.
The total energy dissipated by the network for identifying the faulty sensor nodes is
(9)
E
total
m
,
d
=
∑
i
=
1
N
‍
E
i
m
+
p
,
T
r
.


### 4.3.3. Detection Latency

The detection latency is defined as the maximum time required by a network to identify the fault status of every sensor node present in the network. The processing time of the sensor nodes is negligible due to the faster embedded processor and communication time is more than the processing time. Thus, the detection latency of the DFI algorithm is calculated by considering only transmission and reception time that is communication time. LetT
out be the maximum time set by the timer by each sensor node while exchanging the data with neighbors. In partial self-fault identification and self-diagnosis phase, each sensor node s
i exchanges one message in each phase. Therefore, the total time required by s
i is 2
T
out. A comparison study between DFI and existing Algo1 and Algo2 algorithms is tabulated in Table 1.Table 1
Comparison study on existing method with proposed scheme.
Comparison parameters
DFI algorithm
Algo1 (paper in [21])
Algo2 (paper in [22])
Message complexity
O
(
2
N
)
O
(
5
N
)
O
(
3
N
)
Detection latency
2
T
out
5
T
out
3
T
out
Energy
(
m
+
p
)
N
(
α
1
+
α
2
d
α
+
d
i
α
3
)
(
2
m
+
3
)
N
(
α
1
+
α
2
d
α
+
d
i
α
3
)
(
2
m
+
1
)
N
(
α
1
+
α
2
d
α
+
d
i
α
3
)


## 4.3.1. Message Complexity

The message complexity of the algorithm is determined by considering the total number of messages exchanged over the network in both the partial self-fault identification and self-diagnosis phases. In the partial self-fault identification phase, each sensor nodes
i exchanges its own sensing data among the neighboring sensor nodes which requires N number of message exchange over the network. In self-diagnosis phase, each sensor node s
i estimates the probable fault status of its neighboring nodes and sends the status information to the neighboring nodes. This requires N number of message is exchanged over the network. To complete the DFI algorithm, total 2
N number of messages is exchanged over the network. Therefore, the total number of message exchanges is 2
N
≈
O
(
N
).


## 4.3.2. Energy Complexity

We have calculated the energy requirement of the network to detect the faulty sensor nodes by using the DFI algorithm. As the energy consumed in communication dominates the energy consumption in processing (because of the development of low power VLSI and computing architecture), we have considered only energy complexity due to data transmission and reception during the fault diagnosis of sensor nodes [34]. The DFI algorithm needs message exchange twice by each sensor node. The energy calculation for each message transmission is provided separately.(A) The Energy Required for Exchanging the Sensed Data
x
i
. Let E
1
,
E
2
,
…
,
E
N be the energy which dissipates by the sensor nodes s
1
,
s
2
,
…
,
s
N, respectively. Let m be the message size of sense data and let T
r (transmission range) be the maximum distance a sensor node can transmit the message. Thus, the amount of energy required by a sensor for the transmission of m bits of message data is
(4)
E
T
i
m
,
T
r
=
m
α
1
+
α
2
T
r
α
.
This transmission energy is common for all the senor nodes in the network. However, the energy required to receive the data from the neighbors is different, because the degree of the sensor nodes is different. Therefore, the energy required by a sensor node s
i to receive data from all the neighbors is given as
(5)
E
R
i
m
,
T
r
=
N
i
m
α
3
,
where N
i is the degree of sensor node s
i.The total amount of energy required bys
i for data transmission and reception is
(6)
E
1
i
m
,
T
r
=
E
T
i
m
,
T
r
+
E
R
i
m
,
T
r
.(B) The Energy Required for Exchanging the Probable Fault Status. The sensor node exchanges p bits of information to its neighbors. According to the procedure given in Section 4.3.2(A), the total energy required by s
i here is given as
(7)
E
2
i
p
,
T
r
=
E
T
i
p
,
T
r
+
E
R
i
p
,
T
r
,
where E
T
i
(
p
,
T
r
)
=
p
[
α
1
+
α
2
T
r
α] and E
R
i
(
p
,
T
r
)
=
N
i
p
α
3.Therefore, the total energy required for each sensor node to detect soft faulty sensor nodes in the network is given as(8)
E
i
m
+
p
,
T
r
=
E
1
i
m
,
T
r
+
E
2
i
p
,
T
r
=
α
1
m
+
p
+
α
2
T
r
α
m
+
p
+
N
i
α
3
m
+
p
=
m
+
p
α
1
+
α
2
T
r
α
+
N
i
α
3
.
The total energy dissipated by the network for identifying the faulty sensor nodes is
(9)
E
total
m
,
d
=
∑
i
=
1
N
‍
E
i
m
+
p
,
T
r
.


## 4.3.3. Detection Latency

The detection latency is defined as the maximum time required by a network to identify the fault status of every sensor node present in the network. The processing time of the sensor nodes is negligible due to the faster embedded processor and communication time is more than the processing time. Thus, the detection latency of the DFI algorithm is calculated by considering only transmission and reception time that is communication time. LetT
out be the maximum time set by the timer by each sensor node while exchanging the data with neighbors. In partial self-fault identification and self-diagnosis phase, each sensor node s
i exchanges one message in each phase. Therefore, the total time required by s
i is 2
T
out. A comparison study between DFI and existing Algo1 and Algo2 algorithms is tabulated in Table 1.Table 1
Comparison study on existing method with proposed scheme.
Comparison parameters
DFI algorithm
Algo1 (paper in [21])
Algo2 (paper in [22])
Message complexity
O
(
2
N
)
O
(
5
N
)
O
(
3
N
)
Detection latency
2
T
out
5
T
out
3
T
out
Energy
(
m
+
p
)
N
(
α
1
+
α
2
d
α
+
d
i
α
3
)
(
2
m
+
3
)
N
(
α
1
+
α
2
d
α
+
d
i
α
3
)
(
2
m
+
1
)
N
(
α
1
+
α
2
d
α
+
d
i
α
3
)


## 5. Analysis of the Proposed DFI Algorithm

In this section, the proposed DFI algorithm has been mathematically analyzed to ensure the correctness of the proposed approach. In a WSN, every sensor node senses environmental data, converts it into a suitable packet format, and then transmits it to the neighboring nodes or fusion center on demand. While performing this, the noise is likely to be added with sensed data. So, we can mathematically model the sensors measured data as the sum of true value and additive noise. The additive noise is considered as normally distributed Gaussian noise.It is assumed that all the sensor nodes measured same physical data and few sensor nodes can be faulty. The mean of the measurement for all sensor nodes is constantw, but the noise is different for sensor nodes. The data generated for each sensor node by using normal distribution have w mean and σ
i
2 variance, that is, N
(
w
,
σ
i
2
). It is a common assumption in WSNs literature that all the sensor nodes measure same physical data with constant mean.The data model of the sensor nodes
i is given as
(10)
x
i
=
w
+
n
i
,
where
i
=
1,2
,
3
,
…
,
N
,
where w is mean of the measured data which is common at all sensor nodes and n
i is the additive noise. Here n
i is assumed to be independent over time and space, respectively. Theprobability density function (pdf) of x
i is given by [35]
(11)
f
X
x
i
=
1
2
π
σ
i
2
e
-
x
i
-
w
2
/
2
σ
i
2
,
where σ
i
2 is the variance of noise present at the sensor node s
i.The probability ofx
i
∈
X that lies in the range of (
-
∞
,
x
i
] can be expressed in terms of itscumulative distribution function (cdf). As sensor data follows a normal distribution its cdf is defined as
(12)
F
x
=
∫
-
∞
x
‍
f
x
y
d
y
=
Φ
x
i
-
w
σ
i
.
Now the cdf can be expressed in terms oferror function (erf). The erf is defined as
(13)
erf
⁡
x
=
2
π
∫
0
x
‍
e
-
y
2
d
y
.
The cdf is rewritten in terms of erf as
(14)
F
x
=
1
2
1
+
erf
⁡
x
i
-
w
σ
i
2
,
x
i
,
w
∈
R
.
The probability of a random variable x
i lies in between (w
i
-
a) and (w
+
a) (where w is the mean of measured data) and is calculated by using its cdf as
(15)
pr
w
-
a
≤
x
i
≤
w
+
a
=
F
w
+
a
,
w
,
σ
i
2
-
F
w
-
a
,
w
,
σ
i
2
=
erf
⁡
a
σ
i
2
.
As we know that the variance of a random variable indicates the spread of its pdf around the mean, hence it is better if we choose the constant a in terms of variance. For example, if the constant a
=
3
σ
i then the probability of the random variable x
i lies in between (
w
-
3
σ
i
) to (
w
+
3
σ
i
) and is
(16)
pr
(
w
-
3
σ
i
≤
x
i
≤
w
+
3
σ
i
)
=
erf
⁡
3
σ
i
σ
i
2
(
From
15
)
=
0.9973
.This reflects that if the variance of the noise ats
i is low, there is a maximum probability to get an error free measurement. If the sensor node is working properly and the transmission in wireless channel is noise free then the variance is very low (around 0.001). In general, maximum noise is added by the channel while transmission if the node is faulty. Let us take the variance of measurement and transmission noise associated with a fault free node is 1. There is 99.73
% probability that the value is deviated around ±
3. When the node is faulty due to sensor processing error or transmission failure the measured data is corrupted using noise having high variance. In our model, we assumed that the noise variance of faulty node is 100 times as compared to that of fault free sensor node.We compare any two sensor node datax
i and x
j at the observed time t. The difference x
i
,
j is given as
(17)
x
i
,
j
=
x
j
-
x
i
.
The sensed data by a sensor node s
i is temporarly and spatially independent from the amount noise associated to the data. Therefore x
i and x
j are independent in nature. From the definition, x
i
,
j is a random with mean 0 and variance σ
i
,
j
2, respectively, which are calculated as
(18)
σ
i
,
j
2
=
σ
i
2
+
σ
j
2
,
where σ
i
,
σ
j are the noise variances of sensor nodes s
i and s
j, respectively.When the sensor nodes are deployed in a particular environment, the sensed data for neighboring sensor nodes are nearly the same. The difference is caused due to additive noise associated with the sensor data. It is considered that every sensor nodes measure same data, which is the mean of the distribution. In general practice, for most applications of WSNs, we need the average of measured data from all the nodes. The theory of statistical estimation provides the mean estimator as the bestminimum variance unbiased (MVU) estimator. We compared the sensor’s own measured data with the mean of neighbor’s data for fault identification. Let N
a be the average degree of the sensor nodes in the sensor network. The mean and variance of neighbor data excluding itself is written as
(19)
θ
i
=
1
N
a
∑
j
=
1
N
a
‍
w
j
=
w
,
ρ
i
2
=
1
N
a
2
∑
j
=
1
C
‍
σ
j
2
.
In fact, there are two cases such that either all neighbor nodes are fault free or some nodes are faulty. In first case, when all the neighboring nodes are fault free having same variance of measurement σ
2 then the mean variance is
(20)
ρ
i
2
=
σ
2
N
a
.
The difference between own measured data of node s
i with the mean of its neighbors data is
(21)
x
i
m
=
x
i
-
θ
i
,
which have zero mean and 1
+
N
a
/
N
a
σ
2 variance, respectively. Let λ
1 be a constant which is used for comparing the difference such that
(22)
x
i
-
θ
i
≤
λ
1
.
If we choose the constant λ
1
=
3
1
+
N
a
/
N
a
σ
2 assuming all neighboring nodes are fault free with respect to node s
i, then there is 99.73
% (from (16)) of probability such that the absolute difference is less than λ
1.In the second case, if any one of the neighboring node is faulty then the meanθ
i remains unchanged as we are assuming all sensor nodes have same measured data. The variance of faulty node is very high compared to fault free node so that ρ
k
2
≻
≻
σ
2. We cannot choose the constant λ
1 which is very high to satisfy the condition in (22) because when the single neighboring node is faulty for high variation of degree the ρ
i
2
≈
σ
2. It may happen that the faulty node is detected as fault free. Therefore, in that case we may lose the comparison when this comparison equation is not satisfied, and then the i
th sensor node compares its data with the neighboring sensor nodes data using another constant λ
2. In this case, if i
th node is comparing its own temperature value with a faulty node having variance σ
f
2 which is different from normal variance σ
2, therefore, difference in the variance is given as
(23)
σ
i
j
2
=
σ
i
2
+
σ
j
2
=
σ
2
+
σ
f
2
.
In general, the variance of faulty node is nearly 100 times the variance of fault free nodes. The magnitude of the difference must be compared with a higher threshold. Therefore, in the proposed algorithm, we choose the threshold value of λ
2 as 33
σ.During the comparison process, there are four different situations that may arise, such as (i) both nodes (compared and comparing node) are fault free (ii) both nodes (compared and comparing node) are faulty, (iii) faulty node comparing with fault free node and (iv) fault free node comparing with faulty node. When both the nodes are fault free, then the difference of their variance is very low, so it may always satisfy with the condition for the thresholdλ
2 with high probability. If both sensor nodes are faulty with high variance, then the difference is much higher than the threshold λ
2 which indicates that one faulty node can detect the status of another faulty node as faulty. It is trivial that when a fault free node compares with the sensed value of a faulty node it finds a faulty node as faulty. When a faulty node compares with fault free node data, then the faulty node make fault free node as faulty. Due to randomness of data the results are always not 100
% accurate, to overcome this particular situation, we employed majority voting on the data collected from different neighboring sensor nodes before taking final decision about the fault status of a node.


## 6. Simulation Model

In this section, the proposed distributed fault identification (DFI) algorithm is implemented in network simulator NS3 [23] and the performances are compared with the existing algorithms [21, 22]. The network parameters used for developing the network model are given in Table 2. After developing the network model, different types of faults are injected into the network. It is assumed that the occurrences of various faults are independent of each other. The detection accuracy (DA), false alarm rate (FAR), detection latency (DL), and energy consumption (EC) [21, 22] are used for measuring the performance of the algorithms. These parameters are defined as follows.(1)
Detection accuracy (DA) is defined as the ratio between the number of faulty sensor nodes detected as faulty and the total number of faulty sensor nodes present in the network.
(2)
False alarm rate (FAR) is defined as the ratio of the number of fault free sensor nodes detected as faulty to the total number of fault free sensor nodes present in the network.
(3)
Detection latency is defined as the maximum time required by the node to identify its own fault status.
(4)
Energy consumption (EC) is defined as the total energy consumed by the network to identify the faulty node present in the network.Table 2
The Simulation parameters.
Simulation parameters
Topologies
Arbitrary network withN
=
512
Propagation loss model
Range propagation loss model
MAC
IEEE 802.15.4
Simulation time
300 s
T
r
(
40,54,60,67
) m
Network grid
From(
0,0
) to (
100,100
) m
α
1
50 nJ/bit
α
2
10 pJ/bit/m
2
α
3
50 nJ/bit


### 6.1. Simulation Results

The performance of the proposed algorithm is analyzed and compared with different existing algorithms for different values of the number of sensor nodesN, the average degree of sensor nodes in the network, the probability that a sensor node is faulty p, and the predefined threshold values (λ
1 and λ
2) used for fault detection in the proposed DFI algorithm. After random deployment of the sensor nodes, the topology of the sensor network has been generated using the transmission range of the sensor nodes given in Table 2. The performances are measured by varying the fault probability from 0.05 to 0.4 with step size of 0.05. The threshold values λ
1 and λ
2 used in DFI algorithm are taken as 3 and 40, respectively. All the algorithms (DFI, Algo1, and Algo2) are implemented in NS3 over the fault model discussed in Section 3.In the simulation model, the data of a fault free sensor node are generated by usingnormal distribution function with mean w
=
30 and variance σ
2
=
1. The faulty sensor nodes are assumed to have the same mean as fault free node, but the variance is taken 100.


### 6.2. Performance of the Algorithm with respect to DA and FAR

The DA and FAR versus the fault probability for different average degree of the algorithms are plotted in Figures2(a) to 2(d) and Figures 3(a) to 3(d), respectively. As can be seen from Figures 2 and 3, the proposed DFI algorithm yields significant superior performance over existing Algo1 [21] and Algo2 [22] algorithm as a whole, by demonstrating higher DA and lower FAR.DA versus fault probability plots obtained by the proposed DFI, Algo1, and Algo2 algorithms: (a) for average degreeN
a = 10; (b) for average degree N
a = 15; (c) for average degree N
a = 20; (d) for average degree N
a = 25.
(a)
(b)
(c)
(d)FAR versus fault probability plots for the proposed DFI, Algo1, and Algo2 algorithms: (a) for average degreeN
a = 10; (b) for average degree N
a = 15; (c) for average degree N
a = 20; (d) for average degree N
a = 25.
(a)
(b)
(c)
(d)The superior performance of the proposed algorithm over the existing algorithm is due to the statistical property of the mean, which is used for comparison of own observation. Further, each node does not take its own fault decision by simply comparing own data with one of the neighbors. Instead, the fault status is diagnosed by each of the neighboring sensor nodes. A voting scheme among the probable fault status measured by the neighboring nodes is used to take the final correct decision about the fault status.Ideally, the DFI algorithm aims to achieve the 100% DA and 0% FAR, respectively. In Figures2 and 3, the proposed algorithm attains these ideal performances for lower fault probability but degrades for higher fault probabilities as compared to the existing algorithms which never attain these ideal performance. In the worst case scenario (40
% fault probability) the DA and FAR of the proposed algorithm are 0.95 and 0.07, respectively. In the meantime the Algo1 [21] and Algo2 [22] algorithms the value of DA and FAR performances is around 0.92 and 0.35, respectively. The detail comparison of the performance among the algorithms is given in Tables 3 and 4.Table 3
Comparison of DA for different algorithms.
Fault prob.
Detection accuracy
Avg. degree = 10
Avg. degree = 15
Avg. degree = 25
DFI algo.
Algo1 algo.
Algo2 algo.
DFI algo.
Algo1 algo.
Algo2 algo.
DFI algo.
Algo1 algo.
Algo2 algo.
0.05
1
0.9984
1
1
0.9954
0.9974
1
1
1
0.1
1
0.9828
0.9921
1
0.9728
0.9828
1
0.99374
0.9922
0.15
1
0.9788
0.9843
1
0.9648
0.9728
0.9984
0.9898
0.984
0.2
1
0.9531
0.9743
0.9992
0.9531
0.9633
0.9975
0.9798
0.9762
0.25
0.9998
0.9359
0.9665
0.9982
0.9459
0.9525
0.9872
0.9683
0.9634
0.3
0.9953
0.9297
0.9585
0.9878
0.9398
0.9469
0.9767
0.9589
0.9578
0.35
0.9914
0.9267
0.9567
0.9752
0.9219
0.9412
0.9621
0.9469
0.9457
0.4
0.9877
0.9141
0.9531
0.9736
0.9180
0.9355
0.959
0.9412
0.9353Table 4
Comparison of FAR for different algorithms.
Fault prob.
False alarm rate
Avg. degree = 10
Avg. degree = 15
Avg. degree = 25
DFI algo.
Algo1 algo.
Algo2 algo.
DFI algo.
Algo1 algo.
Algo2 algo.
DFI algo.
Algo1 algo.
Algo2 algo.
0.05
0
0.0516
0.0833
0
0.0913
0.102
0
0.0859
0.158
0.1
0
0.0812
0.164
0
0.1258
0.156
0.021
0.161
0.166
0.15
0
0.125
0.217
0
0.169
0.206
0.03
0.223
0.231
0.2
0
0.163
0.256
0.014
0.208
0.221
0.072
0.234
0.247
0.25
0.013
0.2104
0.252
0.027
0.2369
0.244
0.039
0.257
0.281
0.3
0.024
0.2508
0.273
0.035
0.247
0.25
0.045
0.26
0.276
0.35
0.031
0.2606
0.281
0.041
0.2504
0.26
0.051
0.265
0.289
0.4
0.036
0.2638
0.286
0.045
0.2581
0.265
0.057
0.279
0.289


### 6.3. Message Complexity

The message complexity of different algorithms is compared with the DFI algorithm. The total number of messages exchanged in all the algorithms depends upon the number of nodes present in the network. Usually the message complexity is independent of fault probability, because in soft fault detection method, it is assumed that all the nodes communicate to their neighbors by using one hop communication. The Algo1 [21] and Algo2 [22] algorithms require more message overhead as compared to the DFI algorithm. This is due to the requirement of multiple data from the neighboring nodes for fault detection, unlike the DFI algorithm needs only one data from the neighboring nodes to do the same. In the worst case, Algo1 and Algo2 algorithms need 5 and 3 messages, respectively, to identify the fault status of the faulty sensor node present in the network whereas the DFI needs only 2 messages.In Table5, the total number of messages exchanged required by different algorithms for different average degree of the network is provided. We know the communication consumes much power compared to other operation. Further, from Table 5 it is found that the DFI algorithm needs less number of message exchange. Therefore, the proposed DFI algorithm is energy efficient.Table 5
Total number of message exchanged for different algorithms.
Algorithm
Proposed DFI algorithm
Algo1 algorithm
Algo2 algorithm
Average degree = 10
1024
2560
1536
Average degree = 15
1024
2560
1536
Average degree = 20
1024
2560
1536
Average degree = 25
1024
2560
1536


### 6.4. Detection Latency

The detection latency (DL) is one of the important parameters for fault identification algorithm because it provides the time required to detect all the faulty nodes in the network. The DL versus fault probability of the DFI, Algo1 [21], and Algo2 [22] algorithms for different average node degree is plotted in Figure 4. From the figures it has been shown that the DFI algorithm has less DL as compared to Algo1 and Algo2 algorithm. It is because the DFI needed less message exchange and the DL fully depends on the number of message exchange. It remains almost same for varying fault probability because each node including the soft faulty node is involved in message exchange and fault diagnosis.Detection latency versus fault probability for the DFI, Algo1, and Algo2 algorithms: (a) for average degreeN
a = 10; (b) for average degree N
a = 15; (c) for average degree N
a = 20; (d) for average degree N
a = 25.
(a)
(b)
(c)
(d)


### 6.5. Energy Consumption (EC)

Figure5 depicts the total energy consumed in the network for fault identification by the DFI, Algo1 [21], and Algo2 [22] algorithms for different fault probabilities. The result shows that as average degree of the network increases the energy consumption increases. The energy consumption in DFI is 28
% and 56
% less consumed as compared to that of Algo2 and Algo1 algorithm, respectively. The number of message receptions is varied due to packet loss in the network for a fixed number of message transmission. As more energy is required for message transmission than reception, the DFI requires less number of messages for transmission and thereby consuming less energy compared to existing Algo1 and Algo2 algorithms. It is noted that the DFI algorithm does not use any special message for identifying the faulty nodes rather the message containing observed data for the sensor nodes is utilized for fault identification purposes.Total energy consumption versus fault probability for the DFI, JSA, and Jiang algorithms: (a) for average degreeN
a = 10; (b) for average degree N
a = 15; (c) for average degree N
a = 20; (d) for average degree N
a = 25.
(a)
(b)
(c)
(d)


## 6.1. Simulation Results

The performance of the proposed algorithm is analyzed and compared with different existing algorithms for different values of the number of sensor nodesN, the average degree of sensor nodes in the network, the probability that a sensor node is faulty p, and the predefined threshold values (λ
1 and λ
2) used for fault detection in the proposed DFI algorithm. After random deployment of the sensor nodes, the topology of the sensor network has been generated using the transmission range of the sensor nodes given in Table 2. The performances are measured by varying the fault probability from 0.05 to 0.4 with step size of 0.05. The threshold values λ
1 and λ
2 used in DFI algorithm are taken as 3 and 40, respectively. All the algorithms (DFI, Algo1, and Algo2) are implemented in NS3 over the fault model discussed in Section 3.In the simulation model, the data of a fault free sensor node are generated by usingnormal distribution function with mean w
=
30 and variance σ
2
=
1. The faulty sensor nodes are assumed to have the same mean as fault free node, but the variance is taken 100.


## 6.2. Performance of the Algorithm with respect to DA and FAR

The DA and FAR versus the fault probability for different average degree of the algorithms are plotted in Figures2(a) to 2(d) and Figures 3(a) to 3(d), respectively. As can be seen from Figures 2 and 3, the proposed DFI algorithm yields significant superior performance over existing Algo1 [21] and Algo2 [22] algorithm as a whole, by demonstrating higher DA and lower FAR.DA versus fault probability plots obtained by the proposed DFI, Algo1, and Algo2 algorithms: (a) for average degreeN
a = 10; (b) for average degree N
a = 15; (c) for average degree N
a = 20; (d) for average degree N
a = 25.
(a)
(b)
(c)
(d)FAR versus fault probability plots for the proposed DFI, Algo1, and Algo2 algorithms: (a) for average degreeN
a = 10; (b) for average degree N
a = 15; (c) for average degree N
a = 20; (d) for average degree N
a = 25.
(a)
(b)
(c)
(d)The superior performance of the proposed algorithm over the existing algorithm is due to the statistical property of the mean, which is used for comparison of own observation. Further, each node does not take its own fault decision by simply comparing own data with one of the neighbors. Instead, the fault status is diagnosed by each of the neighboring sensor nodes. A voting scheme among the probable fault status measured by the neighboring nodes is used to take the final correct decision about the fault status.Ideally, the DFI algorithm aims to achieve the 100% DA and 0% FAR, respectively. In Figures2 and 3, the proposed algorithm attains these ideal performances for lower fault probability but degrades for higher fault probabilities as compared to the existing algorithms which never attain these ideal performance. In the worst case scenario (40
% fault probability) the DA and FAR of the proposed algorithm are 0.95 and 0.07, respectively. In the meantime the Algo1 [21] and Algo2 [22] algorithms the value of DA and FAR performances is around 0.92 and 0.35, respectively. The detail comparison of the performance among the algorithms is given in Tables 3 and 4.Table 3
Comparison of DA for different algorithms.
Fault prob.
Detection accuracy
Avg. degree = 10
Avg. degree = 15
Avg. degree = 25
DFI algo.
Algo1 algo.
Algo2 algo.
DFI algo.
Algo1 algo.
Algo2 algo.
DFI algo.
Algo1 algo.
Algo2 algo.
0.05
1
0.9984
1
1
0.9954
0.9974
1
1
1
0.1
1
0.9828
0.9921
1
0.9728
0.9828
1
0.99374
0.9922
0.15
1
0.9788
0.9843
1
0.9648
0.9728
0.9984
0.9898
0.984
0.2
1
0.9531
0.9743
0.9992
0.9531
0.9633
0.9975
0.9798
0.9762
0.25
0.9998
0.9359
0.9665
0.9982
0.9459
0.9525
0.9872
0.9683
0.9634
0.3
0.9953
0.9297
0.9585
0.9878
0.9398
0.9469
0.9767
0.9589
0.9578
0.35
0.9914
0.9267
0.9567
0.9752
0.9219
0.9412
0.9621
0.9469
0.9457
0.4
0.9877
0.9141
0.9531
0.9736
0.9180
0.9355
0.959
0.9412
0.9353Table 4
Comparison of FAR for different algorithms.
Fault prob.
False alarm rate
Avg. degree = 10
Avg. degree = 15
Avg. degree = 25
DFI algo.
Algo1 algo.
Algo2 algo.
DFI algo.
Algo1 algo.
Algo2 algo.
DFI algo.
Algo1 algo.
Algo2 algo.
0.05
0
0.0516
0.0833
0
0.0913
0.102
0
0.0859
0.158
0.1
0
0.0812
0.164
0
0.1258
0.156
0.021
0.161
0.166
0.15
0
0.125
0.217
0
0.169
0.206
0.03
0.223
0.231
0.2
0
0.163
0.256
0.014
0.208
0.221
0.072
0.234
0.247
0.25
0.013
0.2104
0.252
0.027
0.2369
0.244
0.039
0.257
0.281
0.3
0.024
0.2508
0.273
0.035
0.247
0.25
0.045
0.26
0.276
0.35
0.031
0.2606
0.281
0.041
0.2504
0.26
0.051
0.265
0.289
0.4
0.036
0.2638
0.286
0.045
0.2581
0.265
0.057
0.279
0.289


## 6.3. Message Complexity

The message complexity of different algorithms is compared with the DFI algorithm. The total number of messages exchanged in all the algorithms depends upon the number of nodes present in the network. Usually the message complexity is independent of fault probability, because in soft fault detection method, it is assumed that all the nodes communicate to their neighbors by using one hop communication. The Algo1 [21] and Algo2 [22] algorithms require more message overhead as compared to the DFI algorithm. This is due to the requirement of multiple data from the neighboring nodes for fault detection, unlike the DFI algorithm needs only one data from the neighboring nodes to do the same. In the worst case, Algo1 and Algo2 algorithms need 5 and 3 messages, respectively, to identify the fault status of the faulty sensor node present in the network whereas the DFI needs only 2 messages.In Table5, the total number of messages exchanged required by different algorithms for different average degree of the network is provided. We know the communication consumes much power compared to other operation. Further, from Table 5 it is found that the DFI algorithm needs less number of message exchange. Therefore, the proposed DFI algorithm is energy efficient.Table 5
Total number of message exchanged for different algorithms.
Algorithm
Proposed DFI algorithm
Algo1 algorithm
Algo2 algorithm
Average degree = 10
1024
2560
1536
Average degree = 15
1024
2560
1536
Average degree = 20
1024
2560
1536
Average degree = 25
1024
2560
1536


## 6.4. Detection Latency

The detection latency (DL) is one of the important parameters for fault identification algorithm because it provides the time required to detect all the faulty nodes in the network. The DL versus fault probability of the DFI, Algo1 [21], and Algo2 [22] algorithms for different average node degree is plotted in Figure 4. From the figures it has been shown that the DFI algorithm has less DL as compared to Algo1 and Algo2 algorithm. It is because the DFI needed less message exchange and the DL fully depends on the number of message exchange. It remains almost same for varying fault probability because each node including the soft faulty node is involved in message exchange and fault diagnosis.Detection latency versus fault probability for the DFI, Algo1, and Algo2 algorithms: (a) for average degreeN
a = 10; (b) for average degree N
a = 15; (c) for average degree N
a = 20; (d) for average degree N
a = 25.
(a)
(b)
(c)
(d)


## 6.5. Energy Consumption (EC)

Figure5 depicts the total energy consumed in the network for fault identification by the DFI, Algo1 [21], and Algo2 [22] algorithms for different fault probabilities. The result shows that as average degree of the network increases the energy consumption increases. The energy consumption in DFI is 28
% and 56
% less consumed as compared to that of Algo2 and Algo1 algorithm, respectively. The number of message receptions is varied due to packet loss in the network for a fixed number of message transmission. As more energy is required for message transmission than reception, the DFI requires less number of messages for transmission and thereby consuming less energy compared to existing Algo1 and Algo2 algorithms. It is noted that the DFI algorithm does not use any special message for identifying the faulty nodes rather the message containing observed data for the sensor nodes is utilized for fault identification purposes.Total energy consumption versus fault probability for the DFI, JSA, and Jiang algorithms: (a) for average degreeN
a = 10; (b) for average degree N
a = 15; (c) for average degree N
a = 20; (d) for average degree N
a = 25.
(a)
(b)
(c)
(d)


## 7. Conclusion

A novel distributed fault identification algorithm for wireless sensor networks is proposed. The distributed algorithm is based on a Byzantine fault model such as stuck at zero, stuck at one, random, and hard fault. In the proposed algorithm, each sensor node gathered the information from the one hop neighbors and then detect the probable fault status of each of the neighboring sensor node. The final fault status is computed by diffusing the probable fault information received from the neighboring nodes. The accuracy and completeness of the proposed algorithm have been analyzed and proved to be correct.From the simulation, it is observed that the performance of the DFI algorithm is much better than the existing algorithm. The detection accuracy and false alarm rate of the proposed algorithm for lower degree and less fault probability are nearly1 and 0, respectively, but degrade for higher fault probability. The message and time complexity are very less compared to other existing algorithms. In future, instead of comparing the observation with the mean of their neighbor, we may use robust statistical measure to detect the faulty sensor nodes.



---

*Source: 323754-2014-12-01.xml*