An Energy-Efficient CKN Algorithm for Duty-Cycled Wireless Sensor Networks

To prolong the lifetime of a wireless sensor network, one common approach is to dynamically schedule sensors' active/sleep cycles (i.e., duty cycles) using sleep scheduling algorithms. The connected K-neighborhood (CKN) algorithm is an efficient decentralized sleep scheduling algorithm for reducing the number of awake nodes while maintaining both network connectivity and an on-demand routing latency. In this paper, we investigate the unexplored energy consumption of the CKN algorithm by building a probabilistic node sleep model, which computes the probability that a random node goes to sleep. Based on this probabilistic model, we obtain a lower epoch bound that keeps the network more energy efficient with longer lifetime when it runs the CKN algorithm than it does not. Furthermore, we propose a new sleep scheduling algorithm, namely, Energy-consumption-based CKN (ECCKN), to prolong the network lifetime. The algorithm EC-CKN, which takes the nodes' residual energy information as the parameter to decide whether a node to be active or sleep, not only can achieve the k-connected neighborhoods problem, but also can assure the k-awake neighbor nodes have more residual energy than other neighbor nodes in current epoch.


Introduction
Wireless sensor networks (WSNs) are normally powered by batteries with limited energy, which are difficult or impossible to be recharged or replaced. A common approach for saving the sensor nodes' energy is to select a subset of nodes to remain active/awake and let others go to sleep in a given epoch. Most of current literatures on sleep scheduling in WSNs are to achieve point coverage and/or node coverage problems [1]. Point coverage problem (also called spatial coverage) focuses on selecting a set of active nodes in an epoch so that every point of the deployment space is covered, while considering some optimization goals, for example, minimizing energy consumption [2], minimizing average event detection latency [3]. Node coverage problem (also called network coverage) focuses on choosing a set of active nodes, in which (1) they construct a connected backbone and (2) sleeping nodes are direct neighbors of at least one active node [4]. This node coverage problem is to ensure that any two nodes in the network can communicate with each other through the connected backbone.
The Connected K-Neighborhood (CKN) algorithm is a distributed sleep scheduling algorithm [1], which can reduce the number of active nodes efficiently. It keeps the network k-connected and optimizes the geographic routing performance. Supporting the geographic routing performance is not studied in any previous point coverage and node coverage researches. Although, the CKN algorithm performs well with the geographic routing protocols, the following questions are not addressed in paper [1]. (1) How frequently should the CKN algorithm be executed in the network so that it can really help to save energy, for each time executing the CKN algorithm also consumes energy? Intuitively, executing the CKN algorithm will consume a mass of energy with substantial data transmission to exchange local information between nodes and their neighbors, which influences the energy consumption distribution of network. (2) Do all active sensor nodes in the CKN algorithm [1] consume the In (a), the black nodes represent the nodes which have more residual energy than those of node N 0 , the grey and white nodes have less energy than N 0 's, and the white node has the least energy. In (b), the green nodes represent the active nodes according to the CKN algorithm in a WSN, and the sensor nodes with less residual energy are selected.
energy uniformly in each epoch? We identify the nonuniform energy consumption problem, as shown in Figure 1. It is recognized that when executing the CKN algorithm in WSNs, sensor nodes with less residual energy are possible to be selected, which may result in that the energy of these sensor nodes can be fast consumed. The problem is caused by: the CKN algorithm chooses the active nodes absolutely based on the ranks that are randomly given at the beginning of executing the CKN algorithm in each epoch. In other words, the CKN algorithm cannot ensure the network energy is balancedly consumed. Motivated by above two major issues, we conduct theoretical studies on two important questions based on the CKN algorithm. The first question is as follows. Is the CKN algorithm energy saving for any given value of k and the epoch?
If not, how frequently should the CKN algorithm be executed so that the network is energy saving? In order to find out the relationship between the epoch and the energy consumption, we build a probabilistic model for the CKN algorithm to compute the probability that each random node goes to sleep and the expected total number of epochs during each node's lifetime. We formulate the lower bound of an epoch to keep the CKN algorithm energy efficient.
We address the second question based on the analysis for the first problem: How do we design a new sleep scheduling algorithm based on the CKN algorithm that can balance the energy consumption to prolong network lifetime further? Satisfying all those requirements that the CKN algorithm holds, a new decentralized sleep scheduling algorithm is challenging. In the light of the discussions for the question 1, we propose a new sleep scheduling algorithm, named energy-consumption-based CKN (EC-CKN), to prolong the network lifetime. The advantage of the EC-CKN algorithm over the original CKN algorithm is that it takes the nodes' residual energy information as parameter to decide whether a node to be active or sleep. The EC-CKN algorithm inherits all the major properties of the CKN algorithm, that is, solving the k-connected neighborhoods problem. Meanwhile, it also makes a significant new contribution to the energy efficiency by assuring the k-active neighbor nodes have more residual energy than other neighbor nodes in the current epoch. A theoretical analysis on the energy consumption of the EC-CKN algorithm is given to show the correctness of the new contribution.
The rest of the paper is as follows. Section 2 shows the network model. Section 3 presents the original CKN algorithm regulation and its properties. Section 4 builds a probabilistic model to compute the probability that a random node goes to sleep. Section 5 presents the EC-CKN algorithm. Section 6 demonstrates the properties of the EC-CKN algorithm. Section 7 shows the simulation results about the original CKN algorithm and the EC-CKN algorithm, comparing theoretical values and simulation results. Finally, Section 9 concludes the paper.

Communication Network Model.
A multihop sensor network is modeled by a graph G = (S, E), where S = {s 1 , s 2 , . . . , s n } is the set of sensor nodes and E is the set of directed links. Each node has a uniform transmission radius of r t , and the necessary condition of (s i , s j ) ∈ E is |s i −s j | ≤ r t and a node s j is the next hop of s i to the sink by the routing protocol. If (s i , s j ) ∈ E, we use l i, j to denote (s i , s j ). Each node also has a uniform interference radius of r f . An node s j is interfered by the signal from s i , if |s i − s j | ≤ r f and s j is not the intended receiver. Let I i be the interference region that centers at s i with the interference radius r f . Each node is only equipped with a single radio interface and has the uniform initial energy E 0 . The entire network lifetime is divided into epochs, and each epoch is T. At the beginning of each epoch, a node transmits packets in T 1 , and then it runs the sleep scheduling algorithm to decide the state of the next epoch in T 2 (where T = T 1 + T 2 ) as shown in Figure 2.

Event Generation Model.
Assume each node has a uniform sensing radius r s . Let C u denote the sensing region of the node s u , which centers at s u with the sensing radius r s . An event occurs when the sensing unit of a node s u picks up a signal with the power above a predetermined threshold within the sensing region C u [5]. Suppose the  temporal event behavior over the entire sensing region, A, is a Poisson process with an average event rate λ. Let p XY (x, y) denote an independent probability distribution of the spatial distribution of events. Let p e denote the probability that an event is detected by a node s u , given the fact that it occurred in A: where p XY (x, y) is the spatial distribution of events that is characterized by an independent probability distribution. Let p m (T, n) denote the probability that n events occur in an epoch T at a node s u . Therefore, the probability of no events occurring in C u over an epoch T is given by Let p m (T) denote the probability that at least one event occurs in an epoch T at a node s u : That is the probability of at least one event occurring at the node s u is an exponential distribution characterized by a spatially weighted event arrival rate λ u,u = λ × p e .

Buffer
Analysis. Now, we consider two sources of traffic as an input to the buffer of each node [6].
Generated Packets. The sensing unit of a node senses events and generates packets as discussed in Section 2.2. These packets are generated packets. For a node s u , the rate of the generated packets is denoted by λ u,u .
Relay Packets. A node also receives packets from its upstream nodes and then forwards them to the sink node. (Along the data stream from a source node to the sink node by the routing protocol, downstream nodes are closer to the sink node, and receive packets sent by the node. Upstream nodes are far away from the sink node, and transmit packets to the node). These packets are referred as relay packets. The rate at which a node s u receives relay packets from a node s v is denoted as λ v,u . Therefore, the input packet rate of s u 's buffer, λ u , can be written as where λ u,r is the total relay packet rate at the node s u , N in u is the set of nodes that have the node s u as the next hop, and λ v,u is the packet rate from the node s v to the node s u . Let γ u be the output rate of a node, which is given by where e i is the packet error rate.

Channel and Energy Consumption
Model. The energy consumption model characterizes energy consumption of a node in the network. Suppose there is no energy consumption when a node is sleep. If a node is active, we classify the energy consumption into three general categories.
(1) The Constant Energy Consumption. is the minimum energy needed to sustain a node when it is active without the packet transmission. It includes, for example, the battery leakage, energy consumed during the state transformation.
(2) The Additional Energy Consumption. is the energy consumed by the data transmission during the sleep scheduling algorithm running time.
(3) The Conventional Energy Consumption. includes the receiving energy consumption and the transmitting energy consumption except the local information exchange in the sleep scheduling algorithm, which is based on the first-order radio model [7]. The energy loss is due to the channel transmission, amp is the transmit amplifier. And the transmitting energy consumption for a bit packet is and the receiving energy consumption is 4 International Journal of Distributed Sensor Networks where E is energy consumed by the transmitter or receiver circuitry.

Lifetime Definition.
There is no universally agreed definition of network lifetime as it depends on the specific application. The lifetime can be measured by the time when the first node exhausts its energy, or when a certain fraction of nodes is dead, or even when all nodes are dead. Alternately, it may be reasonable to measure the network lifetime by application-specific parameters, such as the time when the network can no longer relay sensory data packets. In this paper, we define the network lifetime is the time when the first sensor node run out its energy from the beginning. The general network lifetime is the exact individual lifetime of each active node [8].
Theorem 1. For a sensor network, each node has nonrechargeable initial energy E 0 , the average general network lifetime E[L], is given by where E c is the constant energy consumption on the first died node, E[E rx ] is the expected receiving energy consumption, and E[E tx ] is the expected transmitting energy consumption.
Proof. Suppose there are M independently and identically distributed trials on the same sensor network to record the network lifetime L, the receiving energy consumption of each bit E rx , and the transmitting energy consumption of each bit E tx . For the mth trial (1 ≤ m ≤ M), the total energy consumed by the first died node during the whole lifetime is where N m rx is the number of bits to be received, and N m tx is the number of bits to be transmitted of the first died node during the network lifetime of the mth trial. Summing (9) up over the M trials and dividing both sides by M, we obtain The average receiving energy consumed in the ith received bit can be written as where X m (i) = 1 for 1 ≤ i ≤ N m rx and 0 otherwise.
is the total number of the occurrence of the ith received bit among the M trials, and N rx = max m {N m rx } is the maximum number of received bits during the network lifetime. The probability that the received bit chosen randomly happens to the ith received bit is given by Averaging (11) over the received bit chosen randomly indexing i, the expected receiving energy consumption is defined as where E[E rx (i)] is the average energy consumed in ith bit packet, E i rx {·} denotes the expectation over the randomly chosen received packet indexing i.
Similarly, the expected transmitting energy consumption is where E[E tx (i)] is the average energy consumed in i th transmitted packet, E (i) tx {·} denotes the expectation over the randomly chosen transmitted packet indexing i.

A Brief Description of CKN
In [1], the studied WSN is represented as an undirected communication graph G = (S, E). N u is the set of s u 's neighbors. The connected K-neighborhood problem is defined as (i) each node has at least min{k, |N u |} active neighbors, which can be called awake neighbors; (ii) all active nodes are connected. To solve the problem, the authors developed a sleep scheduling algorithm: connected K-neighborhood (CKN).
In CKN, each node s u picks a random rank rank u , broadcasts the rank u , and collects its neighbors' ranks in R u . And then, s u broadcasts R u and collects R v from its neighbors, where s v ∈ N u . If s u or its neighbors has less than k neighbors, s u will remain awake. Otherwise, s u computes a subset C u of N u that is a set of nodes having rank < rank u . "Before the node s u goes to sleep it needs to make sure that all nodes in C u are connected by nodes with rank < rank u and each of its neighbors has at least k neighbors from C u " [1].
The CKN algorithm has the following properties: first, each node s u (awake or not) with |N u | neighbors must have at least min{k, with high probability, is the number of awake nodes by the CKN algorithm and |OPT k | is the number of awake nodes by an optimal algorithm that finds a minimum connected k-neighborhood as Figure 3.

Analysis of the CKN Algorithm
In this section, we build up a probabilistic model for the CKN algorithm to compute the probability that one node s u goes to sleep in each epoch. Based on the probability, we formulate the lower bound of an epoch to keep the CKN algorithm energy efficient.
Notations used in this section. N u is the set of s u 's neighbors, and N u is the set of s u 's 2-hop neighbors. C u and C u are the subsets of N u and N u having rank ≤ rank u . |N u |, |N u |, |C u |, and |C u | are the number of the elements in N u , N u , C u , and C u , respectively. Graphs G Cu and G C u are composed of nodes and potential links in C u and C u .
For a homogeneous Poisson point process in two dimensions, the probability that a random node has n neighbors is [9] where ρ = N/A is the nodes density. And a node is isolated with a probability of P(|N u | = 0) = e −ρπrt 2 . The expectation of the number of s u 's neighbors is If there are at least k different paths connecting any two different vertices in the graph G, the graph is k-connected 6 International Journal of Distributed Sensor Networks (k = 1, 2, . . .). The probability that the graph G is kconnected is 4.1. Sleep Probability in the CKN Algorithm. For the CKN algorithm, when a node s u has at least k neighbors, whether it goes to sleep is decided by two factors: (1) "any two nodes in C u are connected either directly or indirectly through s u 's 2-hop neighbors that have rank less than rank u " and (2) "any node in N u has at least k neighbors for C u " [1].
where p is the probability that a node has rank < rank u .
Proof. Let {rank 1 , rank 2 , . . . , rank |Nu| } be the random ranks for nodes in N u . Suppose rank i ∈ (0, 1) and i ∈ [1, |N u |]. Let Let Z = i∈Nu x i , and the probability z j = j is where

Theorem 3. Under the CKN algorithm, the sleep probability of a node s u is
and the awake probability is where Prob 1 , the probability a node s u satisfies the first condition, is defined as and Prob 2 , the probability s u satisfies the second condition, is defined as Proof. If s u and its neighbors have at least k neighbors, the two conditions deciding s u whether to sleep or not can be interpret as the following corresponding conditions: (1) the graph G C u is connected, and (2) the graph G Cu is k-connected and each node in the set N u − C u has at least k neighbors in C u . The probability that the graph G C u is k-connected is where |N u | min is the minimum degree in the graph G C u , and is the node density in the graph G C u . The probability of the condition (2) is where P(G k Cu ), the probability that the graph G Cu is kconnected, can be expressed as and where ρ 2 = |C u |/(πt r 2 ), ρ 3 = (|C u | + 1)/(πt r 2 ), and |N u − C u | is the number of the elements in the set N u − C u .

Energy Consumption of the CKN Algorithm.
Based on the result of the probability a random node goes to sleep, we can now analyze the node energy consumption for two cases: (1) it runs the CKN algorithm; (2) it does not run the CKN algorithm.

Lemma 4. When a node s u executes the CKN algorithm, its energy consumption is
and the energy consumption of a node during each epoch is where E 1 c and E 2 c are the constant energy consumptions of a node during the time of the CKN algorithm executed and an epoch, respectively. (2) Broadcast Eranku and receive the residual energy of its neighbors Nu. Let Ru be the set of the residual energy of nodes in Nu.

Theorem 5. Under the CKN algorithm, the lower bound of an epoch keeping the network energy efficient is
(3) Broadcast Ru and receive Rv from each node sv where sv ∈ Nu.
(i) Any two nodes in Eu are connected either directly or indirectly through nodes that are the su's 2-hop neighbors that have Erankv larger than Eranku; (ii) Any node in Nu has at least k neighbors from Eu.
Algorithm 1: Energy-consumption-based CKN ( * run the following at each node s * u ).
Proof. Suppose there are M i.i.d. trials on the same network that runs the CKN algorithm as the sleep schedule to record the network lifetime, L ckn , and the epoch is T in each trial. For the mth trial, the total energy consumed by the first died node during the lifetime is where N m epoch is the number of epochs in the mth trial. Summing (31) up to the M trials and dividing both sides by M, we obtain where p a (m) is the nodes awake probability in the mth trial. Averaging (33) over the randomly chosen epoch indexing i, the expected ith epoch energy consumption except for the energy consumed by the CKN algorithm is defined as

The Energy-Consumption-Based CKN Algorithm
We develop a new sleep scheduling algorithm to extend the network lifetime, which can still have all properties of the CKN algorithm. A scalable distributed solution to the connected kneighborhoods problem based on the nodes' current residual energy information is challenging for several reasons. First, a node can go to sleep assuming that there are at least k neighbors being awake to keep it k-connected. Second, the outcome of the algorithm must change over epochs so that all nodes have opportunities to sleep. Third, even though nodes decide to sleep or wake up based on their local information, the whole network must be globally connected. The aforementioned three challenges have been achieved by the CKN algorithm [1], which keep the network duty-cycled and connected k-neighborhood. Fourth, awake neighbors of any node s u have k-top residual. The last one makes sure the energy of the network consumed balancedly, which is the main strength that the EC-CKN algorithm has over the original CKN algorithm.
We address the challenges by proposing the EC-CKN algorithm. The pseudocode of Algorithm 1 depicts the EC-CKN algorithm, which is repeated in each epoch on each node. The algorithm takes an input parameter, k, the required minimum number of per node's awake neighbors. In EC-CKN algorithm, a node s u broadcasts its current residual energy information Erank u (Step 1). It computes a 8 International Journal of Distributed Sensor Networks subset E u of neighbors having E rank < Erank u (Step 5). Before s u goes to sleep, it makes sure that any two nodes in E u are connected either directly or indirectly through the node that is in the s u 's 2-hop neighbors having E rank < Erank u , and its neighbors have at least k neighbors from E u (Step 6). These requirements ensure that when a node has less than k neighbors, none of its neighbors goes to sleep, and when it has more than k neighbors, at least k neighbors decide to remain awake. Note that these requirements are easy to keep by computing locally with 2-hop neighborhood information. The current residual energy is exchanged in Steps 2 and 3.

Properties of the EC-CKN Algorithm
This section analyzes the network lifetime, the awake probability, and the energy consumption of the network under the EC-CKN algorithm.

Theorem 6. For any k ≥ 1, the average network lifetime of the EC-CKN algorithm increases with the increases of the ratio of the network size N and k, N/k.
Proof. Suppose N nodes are placed uniformly at random within a deployment area such that the average number of neighbors per node is ξ ≥ 4(k + ln N). Let δ = (ck ln N)/ξ, for constant c > 96 determined by the analysis. Consider executing the algorithm EC-CKN on the network, and let Erank (i) * be the residual energy of the δth largest residual energy selected by a node in the ith epoch. We claim that, w.h.p., all nodes with residual energy < Erank (i) * go to sleep. Because there are at most δ nodes with residual energy at least Erank (i) * , we have the average number of the awake nodes in each epoch is And the average network lifetime under the algorithm EC-CKN can be written as where E EC = E ckn is the energy consumed by executing the EC-CKN algorithm, and T is the length of an epoch. In comparison with the energy consumed by the awake nodes in an epoch, the energy consumed by the sleep nodes in an epoch is considered negligible: For the algorithm EC-CKN, a node could have four states: Init, Awake, Sleep, and Dead. Let S = {Init = 0, Awake = 1, Sleep = 2, Dead = 3} be the set of the node's states, and N s = |S| is the capacity of the states. Nodes can turn into the states Awake, and Sleep from the states Init, Awake and Sleep, respectively. And the state Dead can be only transformed from the states Awake and Sleep. Figure 4 shows the states transition graph in the algorithm EC-CKN, in which vertices are the states of nodes and the weights of edges are the transition probability between the two states in the ith epoch.

Theorem 7.
Under the algorithm EC-CKN, the difference of the energy consumption between nodes s u and s v in the ith epoch is where Λ and Γ are both the Skellam distributions and p a u (i − 1) is the average probability that a node is awake in the (i − 1)-th epoch.
The average difference of energy consumption in the ith epoch can be defined as where N m,i u,rx and N m,i u,tx are the number of received bits and transmitted bits of the node s u in the ith epoch during the mth trial. T 2 is the time of the conventional data transmission time of each epoch. We discuss the difference between the energy consumption of two nodes in the following two cases.
Case 1 (i = 0). According to (33) and (14), we obtain Case 2 (i > 0). According to (33) and (34), we obtain where p a u (i − 1) is the expected probability that the node is awake in the (i − 1)-th epoch. Note for λ v,r and λ u,r are two independent Poisson distributions, Λ = λ v,r − λ u,r is the Skellam distribution. Similarly, Γ = γ v − γ v is also the Skellam distribution.

Theorem 8. Consider a random node s u , which has more than k neighbors, the probability that a node s u is awake in the ith epoch under the EC-CKN algorithm is
Proof. We introduce a new chain to denote the difference between the residual energy of the two nodes s u and s v , where s v ∈ s u . Then, we obtain Therefore, the number of elements in the set E i u is |E i (48)

Theorem 9. Under the EC-CKN algorithm, the upper bound of the network lifetime is
where σ i,a is the steady-state probability that the action a is chosen when the chain is in the state i under the policy K.
Proof. Now, we construct a Markov State Decision chain for each node s u : where S 0 u = 0, and S n u ∈ {1, 2, 3} denotes the state in the nth epoch (n ≥ 1), and a n is the action under the state S n u a n = Let the policy K = {κ n u,i (a)} denote the probability that the action a is chosen when S u = i, which satisfies the following two conditions: Under the policy K, the sequence of states S n u constitutes a Markov chain with the transition probability p n u (K, i, j), which can be written as For the policy K, let σ i,a denote the steady-state probability that the chain is in the state i and the action a is chosen: The vector σ = {σ i,a } satisfies Equations (55)(i) and (55)(ii) are obvious, and (55)(iii) follows as the left-hand side equals the steady-state probability of being in the state j and the right-hand side is the same probability computed by conditioning on the state and action chosen one epoch earlier.
Suppose that a reward R(Y n i , a n i ) = a n is earned whenever the action a n i is chosen in the state i in the n'th epoch. Since R(Y n i , a n i ) denotes the reward earned at the epoch n, the expected average reward per epoch under the K policy can be written as Therefore, E[R(K)] can be interpreted as the following linear program: is a special case of the linear programm and is solved by a standard linear linear programming algorithm known as the simplex algorithm. The simplex algorithm solves the linear program by moving from an extreme point of the feasibility region to a better extreme point until the optimal is reached. So we can figure out the lower bound and upper bound of the lifetime by the linear programming (57).

Lemma 10. Under the EC-CKN algorithm, the upper bound network lifetime is
where σ i,a is the steady-state probability that the action a is chosen when the chain is in the state i under the policy K.

Simulation
Simulation Setup. In NetTopo [10], we conduct extensive simulation experiments. The studied WSN has the network size 800 × 600 m 2 . The number of deployed sensor nodes are increased from 100 to 1000 (each time increased by 100). The value of k is changed from 1 to 10 (each time increased by 1). For every number of deployed sensor nodes, we use 100 different seeds to generate 100 different network deployment. A source node is deployed at the location of (50, 50), and a sink node is deployed at the location of (750, 550). The transmission radius for each node is 60 m.
Routing Algorithm. TPGF routing algorithm [11] is one of the earliest geographical multipath routing algorithms designed for facilitating the multimedia stream data transmission in static and always-on wireless sensor networks (WSNs). It focuses on exploring the maximum number of optimal node-disjoint routing paths in network layer in terms of minimizing the path length and the end-to-end transmission delay. TPGF routing algorithm includes two phases. Phase 1 is responsible for exploring the possible routing path. Phase 2 is responsible for optimizing the found routing path with the least number of hops. The simulation results with changed k values in this figure reflect the comparison between the original average length of paths and the optimized average length of paths.
Sleep Probability of the CKN Algorithm. The node's sleep probability has been analyzed in Section 4.1. Figure 5 describes the node's theoretic sleep probability based on the probability model that has been set up and covers the comparison between the simulation results and the theoretic value. We enlarge the some factors of the probabilistic model so that the theoretic value is greater than the simulation when N/k > 100. While N/k < 100, the theoretical results and simulation results approximate every much. Moreover, the same variation trend proves that our model is ponderable for nodes' sleep probability in the CKN algorithm.
Network Lifetime Under the CKN Algorithm. Based on the node sleep probability from the probabilistic model and simulation, we can get the relative probability stretch variation curve with the epoch. Relative probability stretch is defined as a function of the expected number of epochs with k active neighbors compared to the expected number of epochs with a larger |N u | active neighbors. In our work, we assume that the radio dissipates E elec = 50 nJ/bit to the transmitter or receiver circuity and = 100 pJ/bit/m 2 , and the data rate is 20 kbps. In Figure 6, there is a key value of the length of the epoch time (M · t) when N and k are certain, which is the intersection of relative probability stretch and reference axis. The CKN algorithm is energy efficient if the epoch is less than the key value. Otherwise, the node will consume more energy by the CKN algorithm than it is always active.

Related Work
Network lifetime has been defined in various ways [12][13][14][15][16][17], and an energy-efficient mechanism may choose to maximize a certain type of network lifetime. One useful mechanism is the MAC layer power saving scheme, which reduces energy consumption by minimizing radio transceivers' idle time. SMAC [18] is an important MAC protocol designed for sensor networks, which forces sensor nodes to operate at low duty cycle by putting them into periodic sleep instead of idle listening. The timeout-MAC protocol (TMAC) improves SMAC by using an adaptive duty cycle [19]. Datagathering MAC (DMAC) also uses an adaptive duty cycle, which provides low node-to-sink latency in convergecast communication by staggering the wake-up times of the nodes in the convergecast tree [20]. Pattern MAC (PMAC)   This point clearly reflects that the energy consumption by the EC-CKN algorithm in a WSN is well managed towards the energy-balancing direction. Furthermore, simulation results in (b) and (d) also reveal that decreasing the value of k (let more nodes sleep) can definitely help to prolong the network lifetime of the EC-CKN algorithm in a WSN, but not the CKN algorithm.
[21] allows each sensor node determines the sleep-wakeup schedules based on its own traffic and the traffic patterns of its neighbors. BMAC [22] and XMAC [23] are two asynchronous duty-cycle-based protocols. In BMAC, each sensor node periodically wakes up to check whether there is any activity currently on the wireless channel or not. If so, the node remains active to receive a possible incoming packet. In this way, the node will receive one or more packets that are actually destined for other nodes. XMAC uses a strobed preamble to solve the overhearing  WiseMAC is similar to BMAC except that senders efficiently reduce the length of the wake-up preamble by exploiting the sampling of the schedules of its neighbors. Another common technique to minimize the energy consumption and extend the network lifetime is to put some sensors in the sleep state and put others in the active state for the sensing and communication tasks. When a sensor is in the sleep state, its processor is turned off, but a timer or some other triggering mechanism may be running to wake up the sensor. On the other hand, all the components in the sensor are turned on when it is in the active state. Therefore, the energy consumed in the sleep state is only a tiny fraction of that consumed in the active state. One complexity here is that different types of sensors may support different sets of states. For example, the μAMPS sensor has three sleep states: Monitor, Observe, and Deep Sleep [25]. A sleep scheduling mechanism allows each sensor to determine when it should switch its state and what state it will switch to. Kumar et al. adopt the randomized independent scheduling (RIS) mechanism extending network lifetime while achieving asymptotic K-coverage [26]. RIS assumes that time is divided into epochs based on a time synchronization method. At the beginning of a epoch, each sensor independently decides weather to become active with probability p or go to sleep with probability 1 − p. Thus, the network lifetime is increased by a factor close to 1/ p. Berman et al. presented a centralized and a distributed algorithm to maximize network lifetime while achieving K-coverage [27]. In the distributed algorithm, each sensor is in one of three states: active, idle, or vulnerable. In the vulnerable state, if the sensor discovers that part of its sensing area cannot be covered by any of its active or vulnerable neighbors, it immediately enters the active state. Otherwise, it enters the idle state if its sensing area can be monitored by either active neighbors or vulnerable neighbors with a higher energy level. Another distributed scheduling mechanism named lightweight deployment aware scheduling (LDAS) is proposed in [16]. Unlike the aforementioned distributed algorithm, LDAS does not ask if the sensor nodes are equipped with GPS or other devices to obtain location information. It assumes that each active node knows the number of its active neighbors. If the number of the active nodes exceeds a threshold, the node randomly selects some of its neighbors and sends tickets to them. When a node receives enough tickets from its neighbors, it may enter the sleep state after a random backoff period. Probing environment and adaptive sensing (PEAS) mechanism was designed for high-density sensor networks in a harsh environment [17]. Each node broadcasts a message with a transmission range of t r after sleeping for a random period. A node will go to the active state only if it receives no replies from its active neighbors. PEAS assumes that sensor nodes may fail frequently and unexpectedly, which makes synchronized sleeping algorithm infeasible. Coverage configuration protocol (CCP) is an integrated coverage and connectivity configuration protocol [4]. The protocol defines that nodes have three states: ACTIVE, LISTEN, and SLEEP. Each node is initially ACTIVE. When it receives a message, it goes to the LISTEN state and starts a random LISTEN timer. The node will go to SLEEP if it satisfies the following conditions: (i) its LISTEN timer expires; (ii) the network is still connected when it goes to SLEEP. In the SLEEP state, a node will set a random SLEEP timer. When the timer expires, it will enter the LISTEN state. PECAS (probing environment and collaborating adaptive sleeping) is an extension of PEAS. A active node in PECAS will go back to sleep after a specified period of time. It piggybacks the remaining ACTIVE time in its reply messages to its neighbors' probe message. Therefore, an active neighbor who will go to SLEEP can schedule itself to wake up before the node goes to SLEEP, which prevents the occurrence of blind spots. Adaptive self-configuring sensor networks topologies (ASCENT) is similar to PEAS, which is also designed for high-density sensor networks. However, unlike PEAS, ASCENT does not guarantee network connectivity. Low-energy adaptive clustering hierarchy (LEACH) [28] is a cluster-based protocol, which utilizes randomized rotation of cluster heads to distribute work load among the sensors. In LEACH, the lifetime of network is divided into epochs, and each epoch includes a set-up phase and a steady phase. During the set-up phase, cluster heads are selected and each sensor joins a cluster by choosing a cluster that needs the minimum communication energy. During the steady phase, each cluster head aggregates the data from the sensors in its cluster and then forwards them to the sink. To conserve energy, nonhead sensors go to sleep at all time except that they are transmitting data. E-LEACH [15] is an extension of LEACH, which adapts the cluster heads selection algorithm to the nonuniform starting energy level among the sensors and the required number of cluster heads.

Conclusion
When deploying real WSNs for practical applications, it is extremely important to have a good sleeping scheduling algorithm to balance sensor nodes' energy consumption and a reasonable length for an epoch towards energy saving is extremely important. In this paper, we make the following major contributions for supporting the real WSNs applications. (1) A theoretical study is given for the CKN algorithm, which formulates the lower bound of an epoch to keep the CKN algorithm feasible. (2) A new sleep scheduling algorithm, named as EC-CKN, is proposed to balance the energy consumption and prolong the network lifetime. (3) Extensive simulation work is conducted, which proved the energy consumption in the EC-CKN algorithm is well balanced.