Configuration Dissemination with State Feedback for Wireless Sensor Networking Systems

A wireless sensor network (WSN) is a group of spatially dispersed sensors for monitoring the physical conditions of the environment and organizing the collected data at a central location. Since WSNs typically have no infrastructure, one of the challenges in WSNs is the lack of an appropriate method for an operator to interact with a WSN. Practical tasks for WSNs require sensor nodes adaptive to changes in WSN configuration, user input, and commands; hence, monitoring and interaction with a WSN are required. In this paper, a new scheme for configuration dissemination with the monitoring of the sensor state is proposed to control dynamically the operation of sensor nodes in real time. Moreover, a method is provided for the operator to observe the state of a sensor node, which helps the operator provide an appropriate control input to the WSN. We prove the stability properties of the proposed algorithm and show the simulation results.


Introduction
Wireless sensor networks (WSNs) consist of sink nodes and a large number of sensor nodes that coordinate autonomously. These networks are used to monitor physical or environmental conditions such as sound, pressure, and temperature, and propagate data through a network to a main location. However, sensor nodes are not yet capable of autonomously performing various tasks, and many tasks require coordination between an operator and a WSN. Therefore, the operator should recognize the state of the WSN and convey parameter adjustments or configurations to the WSN.
One of the prominent works regarding the configuration dissemination model involves the use of sensor protocols for information via negotiation (SPIN). (1) The authors focused on the efficient dissemination of individual sensor observations to all the sensors and proposed data descriptors to eliminate the chance of redundant transmission in WSNs. Other authors proposed a time division multiple access (TDMA)-based data dissemination protocol for WSNs to offer a degree of reliability. (2) The Firecracker protocol (3) used a combination of routing and broadcast principles to rapidly propagate data throughout WSNs. Trickle (4) was proposed for propagating and maintaining code updates as fast as possible from the operator to all nodes in the network. This protocol considered the suppression and dynamic adjustment of the broadcast rate to limit transmissions among neighboring nodes. It only provided a mechanism by which a node might decide when to propagate the code. Deluge (5) added a feature that supports the transfer of large data objects based on Trickle principles. Still other authors proposed a gossip-based approach where each node decides to forward a message to another node based on some probability. (6) The problem with this gossip approach is that, if a source has very few neighbors, then the nodes will not gossip and the information dies out. Middle-ware has been proposed (7) to provide controlled propagation to tune the process according to the desired reliability. In another case, (8) a multirumor overwriting model was proposed. The model described the propagation and interaction of periodically sensed data, which were distributed by gossiping, without increasing the traffic on the network. Walker and coworkers (9,10) focused on two methods of data propagation (flooding and consensus methods) and compared the ability of operators to manage the system to reach the desired goals. In the flooding method, each node explicitly matches the value of operator command, and in the consensus method, each node matches the average value of operator command of all the neighbors it senses. The data fusion support system (11) provides intelligent capabilities for real-time control access, so that the configurable integrated web-based support services are structured in the context of an ad-hoc wireless sensor network.
Existing works have focused on conveying the data between the nodes, but the WSN requires an operator to be able to observe the WSN states in response to operator commands and the effects of control input. This helps the user provide the next configuration. However, the monitoring of the sensor node state is particularly difficult for the operator, and limited research has probed into determining it. In this paper, an autonomous real-time algorithm for the configuration and monitoring of the WSN is proposed. The proposed method properly disseminates the WSN configuration by indirectly setting parameters within the framework of local rules in a decentralized manner. The proposed algorithm also allows the user to observe effectively the state of the sensor node by understanding WSN dynamics.

Model
We consider a WSN system consisting of (N − 1) sensor nodes, a sink node (N-th node), and an operator. Let N = {1, 2, ..., N} denote the set of sensor nodes in the WSN. The set of neighboring nodes of sensor node i (1 ≤ i ≤ N) is denoted as N i and its cardinality is N i . We propose a control model of the WSN system, where for the forward control loop, the operator controls the WSN by directly controlling the sink node, which affects dissemination to the rest of the sensor nodes based on the control law of each sensor node. For the backward control loop, the operator observes the state of the sensor nodes through the sink node that provides feedback regarding the node state. No control can be exerted over individual sensor nodes, only over the WSN as a whole. To this end, we define the state of the WSN system as x(t) and denote u(t) as the desired configuration set that the operator wants to achieve with the WSN system at time t. Specifically, x(t) represents the vector of the states of all sensor nodes at time t, which can be indicated as vector T is the state vector of node i at time t and an individual node has n-dimensional state space. The state dynamics of the WSN can be defined as The operator interacts with the WSN by applying the control input to the sink node, while the other nodes interact with each other following the local control law of each node in the WSN: The operator gives commands or informs the sink node of parameter change with u(t), after which information propagates according to the underlying control law of sensor node members. Let x N be the state of a sink node and the user input is directly applied to the sink node by letting x N (t) = u(t). Then, the dynamic for the sink node is According to Eqs. (2) and (3), the operator directly controls the state of the single sink node and the interactions between the sensor nodes are handled autonomously. That is, the operator's intended command is directly conveyed to the sink node and each sensor node averages the states of all neighbors it can sense, and then sets its state vector based on that average state. In this manner, the operator takes actions independent of the number of nodes and supervises the WSN as a single entity, resulting in a control complexity of O(1).

Stability analysis
In this section, we will analyze the feasibility of the proposed algorithm for an operator to achieve desired WSN configurations. We denote a steady state x s , which is the state where the proposed system under the local control law can asymptotically converge. Let us denote x s = [x 1s x 2s … x Ns ] T as a steady state vector x(t), where x is is the steady state of sensor node i. We consider that the desired WSN configuration set u(t) is piecewise constant such that u(t) ≈ u.
From Eq. (2), x is is expressed as Then, Eq. (4) is rewritten as Therefore, the elements of L are given by Consider a vector v = [x 1 , x 2 , …, x N ] T , then we will have the action of L as We observe that 1 = [1, …, 1] T is an eigenvector of L with eigenvalue 0, since x i always equals the average of its neighbors' values for this vector.
According to Eq. (5), A has a Laplacian matrix such as L and the constant x s are eigenvectors of eigenvalue 0. In the proposed algorithm, the user input is directly applied to the N-th agent, and then we divide the following two cases: 1 (i,j) = 1 and 1 (i,j) = 0. In the case of 1 (i,j) = 1, obviously x Ns = u. From Eq. (4), we obtain ( ) It shows that x is = u, for all i. That is, In the case of 1 (i,j) = 0, If there exists any j ( i j N ∈ ) with N i j N ∈ N j , we obtain x is = x js . Finally, we obtain the following conclusion: Therefore, we conclude that the operator can achieve some configuration described by u(t) with the proposed system.
Next, we need to prove that the proposed system ensures stability. If the system is asymptotically stable, then the trajectory will converge to the steady state, described in Eqs. (10) and (12), as time goes to infinity. To derive the system stability, we define the following change of coordinates: Then, we obtain the following representation of the system where We use the Lyapunov theory to claim that the system defined by Eq. (15) will be convergent. On the basis of the above analysis, both conditions of the Lyapunov function V(e) have been satisfied; thus, we can consider that the system is stable and the error dynamics will converge to zero exponentially. This result guarantees the autonomous adaptation of the sensor node state according to the operator-defined WSN configuration, resulting in the asynchronous convergence of the WSN to the desired global behavior. For state monitoring, the sink node determines the difference between the states of its neighbors and the control input. The sink node feedbacks the difference to the operator. The closer the difference is to 0, the nearer the configuration of the entire network to completion. Therefore, the following command can be issued to the gateway node. According to the above stability analysis, we know that the states of all sensor nodes converge to the control input in the steady state. Therefore, the operator can learn to understand node states and estimate the timing to give the next configuration inputs, given the feedback from the sink node only.

Configuration
To evaluate the performance of our proposed system, we develop a simulation environment using MATLAB. The simulation area is 100 × 100 m 2 , where the entire network is divided into equally shaped grids, and the sensor nodes are uniformly deployed. We set N = 50, and the sensor nodes are arbitrarily connected. The sink node is denoted as R 50 , which is chosen randomly by the operator. The channel capacity is set to 200 kbps, and the transmission and carrier sense ranges are set to 20 and 40 m, respectively.

Results
We compared the performance of the proposed method with that of the consensus method. (9) The consensus algorithm is an asynchronous distributed protocol for distributed averaging, which aims to compute the average 1 .
The consensus algorithm is used to achieve agreement on a single state among the distributed nodes and designed to achieve reliability in a network with multiple unreliable nodes. Each member in a system averages the values of all of its neighbors and adapts its own value toward that average. Figures 1 and 2 illustrate the time trajectories of node states when the command input remains constant during runtime. The input is given by the operator, such as u = 4. Simulations are conducted over the interval from 0 to 5 s in 100 ms increments. Randomly chosen are 3 out of 49 nodes, namely, R 1 , R 2 , and R 3 . To show the performance of controlling the state of each node, we set the initial state for each node differently. Figures 1(a) and 1(b) illustrate the state changes with the consensus and proposed methods in the absence of error. Both the consensus and proposed methods converge the states of all sensor nodes to the desired state u despite the difference in the initial state of each node. As for the time taken to converge to the configuration by the operator, the consensus method is slightly faster, but both methods show similar performance characteristics for the error-free condition. Figures 2(a) and 2(b) illustrate the state changes of the nodes under an error condition. The error condition is implemented so that the state value of R 2 is not updated between 0.5 and 2 s owing to the malfunction of R 2 . During [0.5, 2] s, R 2 exchanges the last updated state value with that of its neighbor sensor nodes. Both methods show that the state values of all nodes converge to the desired state after 3 s. However, for the consensus method, the malfunction of R 2 directly affects the state values of the neighboring nodes during [0.5, 2] s.
That is, in the consensus method, the state value of each node is sensitive to changes in its neighbor nodes' states; thus, a large difference in state value is observed between the nodes. On the other hand, the proposed method shows that the wrong behavior of R 2 does not have a significant effect on the state control of other nodes. As can be seen from Eq. (2), each node indirectly uses the state of the neighboring nodes in adjusting its state value, which makes it less susceptible to error conditions and have more robust performance.
Next, we examine the trajectories of states corresponding to control input changes during runtime. Simulations are conducted over the interval from 0 to 20 s in 100 ms increments. The configuration input is initially set to u = 2 and changed to u = 4 at 10 s. The error condition is implemented so that the state value of R 2 is not updated during [0.5, 2] s and [10.5, 12] s. Figures 3(a) and 3(b) respectively show the state adaptation behavior for the consensus and proposed methods according to control input changes. As shown in Fig. 3(a), the consensus method shows that the state values of R 1 and R 3 are largely affected by the state value of R 2 during the malfunction period, and the difference in state value between the nodes remains large. For the proposed method, the state change between the nodes is not large despite the malfunction of R 2 and is adopted successfully according to the desired configuration. In Fig.  3(b), the dashed trajectory belongs to R 50 controlled by the operator. The operator can estimate the state of the WSN through the value of R 50 , which helps appropriately determine the timing for the next configuration input. The fact that e 50 is close to 0 reflects the convergence of the WSN configuration to the control input. Therefore, the operator obtains the appropriate timing to tune the next configuration command to the WSN system by observing the e 50 of the sink node. Figure 4 illustrates the steady states of R 1 , R 2 , and R 3 under variable control input u = [u 1 (t), u 2 (t)] T . For simplicity, u 1 (t) is varied within the range of [0.1, 2.0] with 0.1 increments and u 2 (t)  is determined as u 2 (t) = 2e −u 1 (t) . The input commands are sequentially sent from the user to the WSNs. In the case of the consensus method, there is no appropriate feedback for timing to issue the next command; thus, the user command is sent periodically. The period is set to 10 s. From Fig. 4(a), the consensus method shows that the state values of the agents are changed differently and do not follow the user input exactly. The proposed method shown in Fig. 4(b) successfully controls the states of the agents as the change of the user command and the states of all agents are matched correctly by varying the user command. Also, the proposed method can estimate the time to issue the next command, which makes the control of the WSN configuration more effective when a sequential command is required by the operator.

Conclusions
This paper presents a scheme of parameter configuration and monitoring for WSN systems. The operator interacts with sensor nodes by applying the configuration input to a single sink node while the other nodes interact with each other according to the proposed dynamics. The proposed scheme appropriately affects the WSN operation by disseminating the operator input to the rest of the sensor nodes based on the control law of each node. The operator can effectively observe the state of the WSN by understanding dynamics and estimate the timing for the next control inputs, which is based on the feedback of the sink node only. The main contributions of the proposed algorithm over the existing schemes include the following: First, the distributed behaviors of each node, defined by the proposed scheme, automatically drive the system parameters to the desired configuration. Second, the operator can effectively observe the state of the WSN through the feedback from a single node. Finally, insights into the theoretic analysis of the proposed scheme are provided by deriving the steady states and stability of the systems.