^{1}

^{2}

^{1}

^{*}

^{1}

^{3}

^{1}

^{2}

^{1}

^{2}

^{1}

^{2}

Reproduction is permitted for noncommercial purposes.

A navigation method for a lunar rover based on large scale wireless sensor networks is proposed. To obtain high navigation accuracy and large exploration area, high node localization accuracy and large network scale are required. However, the computational and communication complexity and time consumption are greatly increased with the increase of the network scales. A localization algorithm based on a spring model (LASM) method is proposed to reduce the computational complexity, while maintaining the localization accuracy in large scale sensor networks. The algorithm simulates the dynamics of physical spring system to estimate the positions of nodes. The sensor nodes are set as particles with masses and connected with neighbor nodes by virtual springs. The virtual springs will force the particles move to the original positions, the node positions correspondingly, from the randomly set positions. Therefore, a blind node position can be determined from the LASM algorithm by calculating the related forces with the neighbor nodes. The computational and communication complexity are O(1) for each node, since the number of the neighbor nodes does not increase proportionally with the network scale size. Three patches are proposed to avoid local optimization, kick out bad nodes and deal with node variation. Simulation results show that the computational and communication complexity are almost constant despite of the increase of the network scale size. The time consumption has also been proven to remain almost constant since the calculation steps are almost unrelated with the network scale size.

An unmanned lunar rover will be part of the essential equipment for moon exploration in the second phase of the Chinese “Chang'e” mission [

Besides this, localization is also important and challenging in wireless sensor networks. A wireless sensor network comprises a mass of geographically separated sensor nodes [

From the point of view of localization accuracy, localization algorithms can be classified into two different types: range-based algorithms and range-free algorithms [

Range-based algorithms utilize relative accurate distance information between neighbor nodes for their localization. The distance information can be obtained (or calculated) by signal time of arrival (ToA), time difference of arrival (TDoA), angle of arrival (AoA), received signal strength indicator (RSSI) and so on [^{3}). When the number of nodes in the network grows larger, the computational complexity is much larger. MDS-MAP(P) [

In a large scale sensor network containing thousands of sensor nodes, it is very sensitive to the complexity of network, such as computational complexity, time complexity and communication complexity.

In this paper, we propose a low complexity localization algorithm based on spring model which is suitable for large scale networks. It has a complexity of

The proposed LASM localization algorithm has the following advantages: First of all, LASM has a low computational, time, and communication complexity of

This paper is organized as follows: Both the basic LASM localization algorithm and the patches of LASM are described in Section 2. Following which, the simulation results are shown in Section 3. Conclusions are given in Section 4.

There are some assumptions in this paper:

The sensor nodes can be deployed in a two or three-dimensional space. To simplify the explanation, we assume that they are deployed in a two-dimensional space in the rest of the paper.

The wireless sensor network is a dynamic network, which means that the sensor nodes can add in or leave from the network at any time. In addition, the sensor nodes can fail at any moment.

There are at least 3 anchor nodes that know their accurate positions in the wireless sensor network. Other nodes are blind nodes that do not know their positions. The anchor nodes can be realized by GPS or by manual placing in specific positions.

The sensor nodes are able to communicate with neighbor nodes that are in a range of radio range

The distance estimates of neighbor nodes can be obtained. It can be realized by RSSI, ToA, TDoA etc as discussed before.

A particle-spring system

Each particle _{i}_{ij}_{ij}_{0}_{0} denotes the original length of the spring.

For each spring _{ij}

For each particle _{i}

In this paper, we set _{i}

The acceleration of the particle is:

The state function for position and velocity is:

The discrete function is:

Here something needs to be declared: each spring is a virtual one. The position and velocity of each particle is also changed virtually. In fact, the position of each blind node is not change.

The simple process for localization based on the spring model is explained above. We describe the LASM(B) in detail in this part. This localization algorithm can be executed in both distributed and centralized schemes. In a distributed scheme, each sensor node calculates its position through communicating with its neighbors. It's a good method when the sensor network is very large. However, each node needs to communicate with its neighbors, which uses a lot of energy. In a centralized scheme, the sensor nodes send information to the head node. The head node executes the localization algorithm for these nodes and calculates their positions. This method doesn't need rapid communication, but the head node needs a relatively much larger memory and more powerful computing capability.

The distributed scheme for LASM(B) is described as follows:

For each anchor particle, it just sends its actual absolute position to its neighbors if needed. It does nothing else.

For each blind particle

Initialization

Assign its virtual position at (_{i}_{i}

Communication

Communicate with its neighbor particles, obtaining the distances between its neighbor particles and itself (the distances can be calculated by RSSI, TDoA, AoA etc.) and the virtual positions of its neighbors.

Calculation

Calculate the total force exerted by its neighbors, the acceleration

Iteration

Repeat step 2,3 until the total force exerted by neighbors is smaller than a threshold

The centralized scheme for LASM(B) is described as follows:

Here, without loss of generality, we assume that the centralized algorithm is executed in the sink node.

each sensor node sends the distances between itself and its neighbors to the sink node. The anchor nodes also send their absolute positions to the sink node.

the sink node calculates the positions and velocities for all nodes, using the formula similar with the step3 in the distributed scheme described before.

repeat step 2 until the total forces of all particles exerted by neighbors are smaller than a threshold

In the distributed scheme of LASM(B), each node just communicates with its immediate neighbor nodes and the calculation steps is less than a threshold. Therefore, the computational complexity for each node is ^{3})).

Firstly, the Lyapunov stability of the spring model is analyzed.

A Lyapunov type functional V is defined as:
_{ij}

It can be found that

The first item is:

The second item is:

Therefore:

It can be found that

Therefore, with arbitrary initialization, the system is stable at the points where the total force of each particle is equal to zero.

Because the LASM algorithm simulates the physical process of the system, the LASM algorithm is convergent.

First, in the 2-dimension system, the error square sum of the nodes can be defined as:

The minimum of the error square sum is:

It is minimum when

i.e.:

Compared it with the total force in node

The component of force in the direction of

When the velocity of node

It can be found that when the spring is stable, i.e. the node is static, the total force equals to zero. Therefore, when _{ij}

As described in Section 2.2.1, when the positions of particles are initialized around their true positions, the LASM algorithm will be convergent around their true positions. Using (14), we can conclude that the LASM algorithm minimizes the error square sum when it is convergent at the point where 1)each force exerted by spring is near or equal to zero and 2)the total force of each particle is equal to zero.

Three patches for the LASM(B) are lunched to conform to some specific situations. When some particles are not stable at their right positions, i.e. local optimization, patch A is lunched to identify these particles, reinitialize them and reuse the LASM(B) to draw them in their right positions. When there are some nodes which are not well localized (we call them bad nodes), patch B is lunched to seek them out and set different trust values for them. Then we can use the nodes with the higher trust values and delete the bad nodes for the lunar rover's navigation. When there are node variations, i.e., there are sensor nodes adding to or leaving the network, patch C is lunched to deal with these nodes. In this way, the proposed LASM algorithm will be more suitable and robust with different situations.

In some specific situations, some particles may be stable at a needless point. In this point, the total force exerted by its neighbors equals to 0 but at least one force exerted by its neighbor doesn't equal to 0, i.e., the length of one spring _{ij}_{ij0}

It is not a large problem to find out these particles stabilizing at needless points. For each sensor node, it can obtain the distances between it and its neighbors. It can compare these distances with the lengths of springs to find out whether the sensor node is stable at needless points.

After these sensor nodes (particles) have been found, the next step is to set these nodes out of the needless points.

One simple method is to reinitialize the positions of these particles at random points. After this, we use the LASM(B) algorithm again to run to new positions. The particle is stable at its right point (or the localization algorithm is convergent at its right point as proved in Section 2). Therefore, if the particle runs near the true point, it will be static in the right point finally. Therefore, this simple method can solve this needless point problem.

In addition, another method can solve this problem efficiently.

Because a majority of sensor nodes are stable in their right positions, this information can be used to improve the precision of those particles which are at needless points.

If there are at least 3 neighbor particles (in 2-D system) which are stable at right positions, the least squares algorithm can be used to derive the position of this particle which is at a needless point.
_{i}_{i}_{j}_{j}_{k}_{k}_{n}_{n}_{ij}_{0}, _{ik}_{0}, ⋯ _{in}_{0} is the distance between the particle and its neighbors.

This function can be linearized by subtracting the last row:

This equation can be solved using a traditional least squares algorithm.

After the position of this particle is calculated, we consider that this position is also a right position, and also use this position to help its neighbors to calculate their positions using (16).

If there are no particles which can use the second method to reinitialize the positions, the residual particles can use the first simple method to reinitialize.

After these particles which are stable at needless points have been reinitialized, we can reuse the LASM(B) algorithm to obtain the positions of these nodes.

Even after the LASM(B) is reused once, there may also be a smaller number of particles which are not at their right positions. We can reinitialize and reuse the LASM(B) several times to decrease the number of these particles at needless positions. However, it was seen in the experiment that the localization error was very small after the reuse of LASM(B) once. Therefore, LASM(B) is just reused for once in the experiment in Section 3.

The Patch A described above is to reinitialize the positions of those particles at needless points, and then also uses the LASM(B) algorithm. Therefore, the good performance of the LASM(B) algorithm can also be maintained, such as the computational complexity, the communication cost, the convergence and the optimization under the aspect of minimizing error square sum.

In order to obtain higher localization accuracy for lunar rover, the bad nodes which can't be well localized need to be found out. A trust value is set for each of these sensor nodes. If the trust value of one node is 1, it means that the estimated position can be well trusted. When using sensor nodes' position information for lunar rover's localization and navigation on the moon, it can just use the information of nodes with higher trusts to the best of our abilities. In this way, the accuracy of lunar rover's localization and navigation can be increased. Here, “not well localized” means that:

The node cannot be localized;

The node is localized at needless points.

Proof. If two particles are connected, the distance between these two particles can be obtained. When there are three nodes

Therefore, the coordinates (_{i}_{i}

In some specific situations, a particle can also be localized even if there are only two particles connected with it, which is shown in

However, we don't pay much attention on these situations, because we need a fast and simple algorithm to find out these nodes for the lunar rover's localization and navigation on the moon, not a precise algorithm.

Two methods are used to solve this problem. The relatively complex algorithm is used to find out the nodes which can't be localized as follows:

First, 3 particles which are connected with each other are chosen and put in a set. Using these 3 particles, a relative coordinate system can be established.

Secondly, if there are particles which are connected with at least 3 particles in that set, these particles can also be localized. And we also put them into that set. The amount of particles in that set will increase.

In addition, if there are at least 3 anchor nodes in this set, all particles in this set can have absolute coordinates by coordinate transformation.

Finally, the particles which can't be put in the set may not be able to be localized to a great extent (These node may also be localized in some specific situations as described before).

This algorithm is a little complex, and do not take the information of LASM(B) into consideration. Therefore, a new algorithm can be used to find out the nodes which can't be well localized.

The main idea of this algorithm is as follows:

for each particle, if it is at needless point, the trust of this particle is set to be 0.5; if it only has one or two neighbor particles, the trust of this particle is set to be 0. The trusts of other particles are set to be 1.

for each particle, if its trust is not equal to 1, cut off all the springs connected with it. Therefore, it will not be the neighbor particles of others. And then tells its former neighbors to delete itself from the neighbors' neighbor list.

repeat steps 1&2, until no particles need to change their trust.

Even if the trust of the particle is less than 1, it maybe not well localized with certainty. However, if the trust of the particle is 1, it may also not well localized in some specific situations. Here, we just need a fast and simple algorithm; therefore we don't pay more attention to the precision.

All the sensor nodes are divided into 3 parts with different trust values. The sensor nodes with higher trusts will be more likely used in the latter process of lunar rover's localization and navigation.

With the increase of the exploration area and working time on the moon, there are more nodes adding to or leaving from the network. How to deal with these nodes after the network has been localized?

When a new blind node adds in the network, it communicates with its neighbors and then obtains their positions and distances between itself and its neighbors. First, the positions of its neighbors are fixed. Then, the new node calculates its position using the proposed LASM algorithm. After that, small movements are made for the other nodes in the network using LASM. When a new anchor node adds in the network, it communicates its position to its neighbor nodes. These neighbor nodes use the LASM to adjust their positions again.

When a new blind node adds in the network in the LASM process of its neighbor nodes, it first calculates its approximate position using (16). Then it broadcasts its position to its neighbors using LASM to estimate its position. Its neighbor nodes receive its position, and then add it in the calculation of total force.

When a node leaves from the network after the LASM process, if the network is immobile (which means that the nodes in the network don't move once being deployed), the positions of the other nodes need not be changed. Therefore, nothing needs to be done on the positions of the other nodes. If the network is mobile, the other nodes will be relocalized using the proposed LASM algorithm.

When a node leaves from the network suddenly during the LASM process, may its neighbor nodes run into a deadlock because they are waiting for the leaving node's position information? The answer is no. In the LASM process, a time threshold can be set for each sensor node. If it does not receive all the neighbors' position information in the time threshold, it will just use the positions of the remaining neighbor nodes to calculate its velocity, acceleration and position. Therefore, the LASM algorithm can perform well in dynamic networks with nodes adding and leaving rapidly.

Three parts are presented here: the performance evaluation of LASM(B) and LASM(P), comparisons with MDS-MAP algorithm [_{ei}_{ei}_{i}_{i}

The simulation process of LASM algorithm is shown in

In

Though it can get a smaller position estimation error by reinitializing several times in LASM(P), the number of calculation steps increases correspondingly. This will increase communication cost and energy consumption. In order to decrease them, we just use one time reinitializing in LASM(P) in the follow experiments and set

The robustness of the LASM algorithm is tested in

The communication cost and position error versus the number of nodes is tested in _{anc}_{anc}

The average number of calculation steps doesn't change much versus the number of nodes. As shown in

The position error has a small tendency to go smaller as shown in

The MDS-MAP algorithm was chosen because it can also be used in range-based localization algorithms. In addition, thus far it has been used to obtain much higher localization accuracy.

An initial experiment was performed to testify the communication performance of sensor nodes designed by us and the LASM with 20 sensor nodes. The wireless sensor node designed by us is shown in

The experiment field is shown in

After the theoretical study, computer simulation and initial experiments, the LASM algorithm has been proven efficient for large scale wireless sensor networks. The main results are listed as follows:

The localization algorithm based on spring model (LASM) has the advantage of low complexity in computation, communication and time consumption since the calculation steps are almost constant while the node size increases. Three patches are launched to improve the algorithm performances to avoid the local optimum, remove bad nodes and adapt to dynamic changes of the active node. The simulation results of a sensor network with 40 to 800 nodes show that the calculation steps (

This paper was sponsored by Key Program of the National Natural Science Foundation of China under Grant #60535010 to Max Q.-H. Meng, and the National Natural Science Foundation of China under Grant #60475027 to Max Q.-H. Meng.

Spring model for wireless sensor networks.

Explanation of the proposed localization algorithm based on spring model.

wireless sensor network

Spring model.

Drawing blind particles in random positions

Blind particles go back to their stable positions

An specific example where node a can also be localized.

The simulation process and results of LASM. (a) the position estimation error changes in simulation process,

The robustness of the LASM algorithm in 100 randomly generated examples. (a) general calculation steps in LASM(B). (b) general calculation steps in LASM(P). (c) position error in LASM(B). (d) position error in LASM(P).

The communication cost and position error versus the number of nodes. (a) average calculation steps versus the number of nodes in LASM(B). (b) average calculation steps in LASM(P). (c) the position error versus the number of nodes in LASM(B). (d) position error in LASM(P).

Comparisons with MDS-MAP. (a) a random example in uniform networks. (b) a random example in C-shaped networks. (c) the position error versus connectivity in uniform networks. (d) the position error versus connectivity in C-shaped networks.

Experiment design. (a) The proposed sensor node architecture (b) the sensor node designed by us (c) experiment field to test the localization algorithm (d) the result of experiment.

The Complexity of LASM and MDS-MAP.

Distributed LASM(B) | Distributed LASM(P) | MDS-MAP(P) | |
---|---|---|---|

Communication Cost | |||

| |||

| |||

Centralized LASM(B) | Centralized LASM(P) | MDS-MAP(C) | |

Computational Complexity | ^{3}) |