Enabling Autonomous Agents for Mobile Wireless Sensor Networks

Abstract

Wireless sensor networks (WSNs) play a pivotal role in monitoring and acting applications. However, suboptimal deployments and traffic imbalances lead to rapid network exhaustions. To address this, topology changes could be carried out by mobile robots. In this work, a software package to study different strategies and algorithms for the deployment, operation, and retrieval of mobile WSN is introduced. This package employs the globally known software ecosystem for robotics, ROS (Robot Operating System) 2, allowing to study the above-mentioned strategies and algorithms in simulation or in actual deployments. Two strategies concerning robot control are compared, the Social Potential Fields-only approach and an intelligent Agent layer. Each strategy is tested and optimized with different parameters. Results show that the Agents approach yields more consistent results and globally better metrics in terms of network lifetime and coverage.

1. Introduction

Wireless sensor networks (henceforth WSN) comprise a wide field of study. In a WSN, scattered battery-operated sensing elements transfer measured information wirelessly to data collection points called sinks. Traditionally, researchers have proposed several optimization techniques to enhance the weaknesses of the WSNs, that is, network lifespan and coverage [1,2,3]. Benefiting from the downfall in price and a considerable growth in popularity of the robotics systems, robots were introduced to cover the deficiencies present in the WSN [4,5]. The addition of mobile robots (Mobile WSNs) permits the replacement of sensing nodes that are about to run out of battery or are found to be damaged, resulting in an increased resiliency compared to static WSN. Moreover, the mobile robots can help to distribute the traffic load each node forwards by providing routing support or by redistributing nodes, which can lead to a more uniform battery depletion across the network [6]. Even recent trends, such as AI and ML, are merging with WSN [7,8,9,10]. However, despite the interest of the scientific community, several research challenges still need to be faced. These challenges are mostly related with practical implementations, mainly due to the lack of realistic studies or implementations that can actually be deployed [11]. This lack of field testing often leads to unrealistic assumptions regarding the collaboration methodologies employed in mobile WSNs, including the information required for cooperation and the algorithms that facilitate such collaboration. To address this, a software package is provided whose aim is to study different sensor deployment and maintenance strategies. This software package employs the globally known robotics software ecosystem, ROS 2 [12,13]. ROS 2 software packages allow a seamlessly deployment of distributed applications across networked machines or to be run locally using simulators; therefore, algorithm and protocol validation can be achieved before deploying the software on actual hardware.

This paper is structured as follows: Section 2 provides a comprehensive review of the state of the art regarding mobile WSN and current deployments. In Section 3, our contribution is presented. Section 4 and Section 5 provide a relation between the different phases a MWSN suffers and the strategies and implementation followed in this article. Next, in Section 5.5, an overview of the algorithms that are put to test is provided. Results are presented and discussed in Section 6 and Section 7, respectively.

2. Related Work

In this section, a survey containing the state of the art is presented. First, the relevance of WSNs is highlighted with some key applications. Hereafter, a focus on the metrics in WSNs is given along with some of the techniques to improve those metrics. Following this, some studies regarding mobile WSNs are presented along with orchestrating software and methods.

2.1. Wireless Sensor Networks: Applications

Wireless sensor networks are becoming ubiquitous in the 21st century, exhibiting their presence in many current applications (industry, domestic, urban environments, etc.). Among these applications, those that tend to lack proper power and communications infrastructures are those that pose the biggest challenges, such as military zones, wildlife monitoring, and environmental disasters [14,15,16]. Given its transcendence for the economy and development, precision agriculture represents a topic where several of those challenges meet. Hence, several research lines converge WSN with precision agriculture [17,18,19].

2.2. Wireless Sensor Networks: Metrics

Accounting for the relevance that WSNs currently exhibit, optimizations related to metrics have been an ongoing subject of study for researchers. Due to their battery-operated nature (and thus limited lifetime), extending the lifetime of the network is therefore a critical issue. Since current consumption on wireless nodes can be mostly attributed to either CPU operation or transceiver (network) usage, it is clear that in order to maximize lifetime, those power-hungry components must be used as little as possible. This fact is easily verified by the datasheets from popular wireless transceivers [20,21].

However, there are a number of factors that can come into play when it is no longer possible to minimize either CPU idle or network sleep. As pointed out in [1], traffic load imbalances lead to faster battery depletions in the nodes that assume a higher network operation. This accelerated discharge is the factor that causes connectivity losses in the network as those nodes that have exhausted their batteries are now unable to route the traffic originating from their neighbors, thus forming gaps in the network with no connection.

Regarding network longevity, [22] highlights the problems with the different WSN longevity strategies in relation to their actual usefulness and presents some useful terms. First node dies, or the time until the first node runs out of power, may result too conservative because it assumes that the network dies when the first node runs out of power. Last node dies, on the other hand, measures the time until all nodes run out of power. Maximizing last node dies can be a misleading measure because it depends on the idle time of the least active nodes.

Alternative metrics include the so-called beta surviving nodes, which represent a minimum proportion of active nodes required for the network to be considered operational. However, determining this value presents a significant challenge. In addition to the aforementioned strategies, there are those based on coverage. ‘k-coverage’ measures the time during which each region is covered by at least k sensors. ‘Alpha-coverage’ quantifies the time during which the coverage ratio of a region is greater than an alpha threshold. It should be noted that it is necessary to not only cover a region, but also to be able to transmit these data (connected coverage). The authors’ aimed contribution is to minimize redundant traffic and therefore consumption by assigning different roles in the network.

In order to enhance deployment, the contribution presented in [23] employs an evolutionary algorithm to improve the layout of the nodes in WSNs. In practice, the issue can be framed as an optimization problem, with the objective of minimizing energy consumption at the node with the highest consumption. This approach is entirely simulation-based, which presents a challenge in terms of its applicability to actual nodes. Similarly, ref. [24] focuses on reducing energy dissipation by proposing a relay-based clustering approach, thus reducing multi-hop communication. A simulation model of the LEACH routing protocol is used.

Other trends in the literature tend to consider network lifetime as a secondary aspect, emphasising instead the importance of network connectivity. In [25], authors present a mathematical model for WSN, which they entitle ‘Probabilistic Network Connectivity Algorithm (PNCA)’, considering the distribution of nodes as a Poisson process and the connectivity between them as a binomial process. MATLAB R2018a is used to simulate their proposed optimization algorithm for a number of 50 nodes. The problem to be solved is based on the search for the optimal deployment to maximize connectivity. This connectivity is a probability (network probability) as a function of the connectivity factor with a fixed communication radius and, conversely, the network probability for a fixed connectivity factor value equal to two and different coverage radius values. According to the simulations they present, the algorithm is more efficient (in terms of energy consumed) for the same coverage radii than DSR, ZTR, and LEACH protocols. Meanwhile, authors in [26] consider that sensor operation time is limited by energy storage, and the assumption of a regenerative power supply may not be true for most battery-operated implementations. In this case, authors state that the most important parameter is connectivity and, in order to obtain higher coverages, clustering of nodes and the correct choice of the gateways positions are crucial. To achieve this, a three-stage algorithm for the choice of clusters is proposed.

The contributions presented in this section demonstrate the validity and popularity that WSNs exhibit for the academia, not only presenting metrics but establishing the trade-offs between network lifetime and coverage. Despite research efforts, some of the proposals are planned as proprietary or simulation-only models, complicating the implementation of their work on current hardware. In the next subsection, the addition of robots as a measure to extend the capabilities of WSNs is introduced.

2.3. Mobile WSNs

As it was presented in the previous section, mobile elements can be introduced to dynamically modify network topology [27]. Controlled changes [28] in the network topology can improve network balancing and therefore network lifetime. However, not only were those mobile elements introduced to improve network’s operation time, but mobile WSNs can extend the characteristics and resiliency in comparison with static WSNs.

With regard to current applications, several trends can be identified. As it was the case for static WSNs, agriculture and precision agriculture benefit from the addition of robots. In [29], authors use an unmanned aerial vehicle (UAV) as a mobile sink to collect agricultural monitoring data. By following predefined paths, simulations results claim data can be collected at a low energy expense. Nevertheless, most of the use cases found in the literature employ robot clusters instead of a single robot to expand network capabilities, as presented in [30]. This claim is supported by [31], where robots collectively map and collect data in a greenhouse environment. Monitoring of city pollutants using UAVs is discussed in [32], but the limited number of UAVs raises some doubts about system scalability. Multirobot systems can additionally be found in hazardous and harsh environments as in [33], where authors propose a deployment strategy for coal mine monitoring that claims to optimize the number of nodes.

2.4. Orchestration Methods and Software for Multi-Robot Systems

Due to the foreseen relevance of multi-robot systems, our literature review identifies several efforts to establish coordination mechanisms. This coordination is crucial for the success of joint operations in intelligent agents, as identified in [34]. In this aspect, intelligent agents must be able to carry out problem solving in a planned and rational way, but being flexible in their behavior according to the environmental characteristics of the surroundings.

Most orchestration methods rely on newly developed frameworks for popular already existing languages. Examples of this can be found in [35], a Python framework to manage robot teams at a high level of abstraction. This work also proposes several hierarchies, highlighting the primary–secondary or peer–peer organization. However, all tests remain in simulation and it looks like no further progress has been made to continue this project. Scala language also seems to be adequate for these frameworks. The contribution of [36] is based on aggregate computing, presenting an API for the Scala language that allows the description of high-level behaviors such as moving and performing group behaviors. Authors evaluate the use case of ‘find-and-rescue’ in order to show the ability to execute complex behaviors. While simulation results are favorable using the ‘Alchemist’ simulator, authors consider actual deployments for future work. A parallel can be drawn with [37], where the attribution of tasks to agents is described with a high degree of mathematical precision. Nevertheless, the feasibility of implementing this proposal for actual agents, or indeed its capacity for simulation, remains ambiguous.

The Resh programming language is proposed in [38]. Resh aims for the orchestration of robot swarm systems. It offers the orchestration of large concurrent systems and largely asynchronous tasks, allowing the developer to focus on the tasks and actions that the robots must perform, letting the language to handle all other scheduling tasks. However, Resh is not designed for tasks that require strict control of the robot swarm. Using the ‘Resh Interpreter’ and one ‘Robot Agent’ per robot, it seems possible to interact with ROS-based robots, although authors do not provide an extensive documentation about the list of platforms supported and whether Resh support for ROS-enabled platforms can be expanded anymore.

Perhaps the most complete solution in this area can be found in Aerostack 2 [39]. Built on top of ROS 2, Aerostack enables high-level and collective behaviors on diverse drone platforms. Despite the existence of contributions targeting ground robots such as [40,41] (among others), none of those have attained the same level of popularity as the initial one.

In conclusion, as identified in [11], there is a clear lack of implementations that could actually be deployed on real life. This is where our contribution lies, as we additionally consider both robots and sensor nodes together.

3. Contributions

The objective of this paper is to introduce and evaluate a set of algorithmic strategies for deployment and maintenance in mobile wireless sensor networks, focusing on maximizing both network lifetime and connected coverage. These algorithms build upon prior approaches [42,43] but introduce key conceptual advances: (i) agent negotiation protocols are redesigned for improved scalability and efficiency, (ii) energy consumption models are refined to better capture realistic operational costs, and (iii) the algorithms operate under more practical assumptions, such as relying only on local knowledge of neighboring agents’ positions. All algorithmic evaluations are conducted in simulation under controlled and idealized conditions to ensure reproducibility and comparability.

Complementing these conceptual contributions, we present a modular software package implemented using the standard robotics middleware ROS 2. This package serves as a testbed for deploying, evaluating, and extending the proposed algorithms. It includes wrappers for controller classes, simulation support, and tools for logging and visualization. The package is publicly available at: https://github.com/DIANA-IoT/ROS-2-Agents, facilitating reproducibility and future development. We also discuss the practical feasibility of deploying the algorithms on real robots, bridging the gap between theoretical validation and real-world application.

4. Network Operation Phases

In the context of mobile WSN operations, which encompasses deployment, maintenance, and retrieval, the proposed system adheres to a logical sequence depicted in Figure 1.

In mobile WSNs, the deployment phase is carried out by a set of mobile nodes: vehicles, specialized workers, or mobile robots. The mobile nodes aim to reach maximum coverage by determining optimal positions according to different algorithms. Once the network is deployed, the network operates routing traffic and during this phase, the necessary adjustments must be performed to keep the network operational for as long as possible while maintaining the connected coverage. However, over time, the number of degraded nodes increases, which can lead to such a large number of inoperable nodes that the network is considered to be depleted and reach the end of its operational life.

In this paper, we consider the mobile elements to be ground robots with embodied sensors. The movement of each robot is determined by the application of the concept of Social Potential Forces (SPFs) [44,45]. The concept of SPFs comprises two distinct types of virtual forces: repulsion forces and attractive forces. The aforementioned forces are combined to form an emergent vector, which is then decomposed along the 2D or 3D axes in order to determine the motion and direction to be followed by the robot. Potential Forces algorithms are well known in the literature due to their low computational requirements and modest bandwidth demands.

Figure 2 presents the operations performed during each phase for the two strategies that are developed in this article, SPF-only and Agents. The SPF-only strategy applies a different set of forces according to the network phase. The agents approach adds an intelligent layer when the network is in the maintenance phase, allowing to replace degrading robots and balancing traffic.

4.1. SPF-Only Strategy

At a high level, the SPF-only strategy consists of the following sequence of operations. During the deployment phase, robots move according to SPF forces, as previously described. A key contribution of this work is the inclusion of link-local communication—meaning robots are only aware of the information broadcast by their immediate neighbors—to share positional data. The system transitions into the maintenance phase once the network is deemed stationary; that is, when robots have reached their optimal deployment positions and the SPF forces have reached equilibrium. In the maintenance phase, the network operations occur. During network operations, the mobile elements are stationary and know the locations of all nodes in the network. At this moment, nodes route traffic to the sink, and a computation is effectuated to determine which node would deplete first. When enough time passes to deplete this node, the network requires a balancing, denoted in Figure 2 as ‘Readjustment or redeployment’. This process carries on until at least 70 percent of the initial nodes have run out of battery. This represents the threshold needed to advance into the ‘Network depletion’ phase in which the network is too degraded to be considered operational.

4.2. Agents Strategy

Similarly to the SPF-only strategy, the deployment phase is carried out by the computation of SPF forces. In maintenance, the network operations are similar, but the Agents strategy needs to calculate the time until a node needs help instead of the time until a node dies. This allows robots with low battery levels to trigger a negotiation round, where they ask for help. Agents with higher battery levels show their disposition to help others (henceforth willingness) and the robot asking for help selects the most suitable candidate to replace them. The process continues with the replacement of the robot in need which retrieves to a collection point. After these two operations, the robots move again according to the SPF forces to adjust their positions. Just like in the SPF-only strategy, the maintenance is over when at least 70% of the robots have depleted.

5. Implementation

The algorithms are developed to be either tested on real robotic platforms (thanks to its ROS 2-based implementation) or to be tested on simulations. Robots move according to the SPF forces until the network is considered to be stationary. For a network to be considered stationary, at least 80% of alive robots must remain in with their forces at equilibrium or below a movement threshold.

During the maintenance phase, time is event-driven, allowing to steadily emulate battery draining across the network. This topic is introduced below.

5.1. Battery Simulation of Network Operations

Battery drainage in mobile WSNs is primarily contributed by two factors: robot movement and packet routing.

Robot movement is independent from the network stage as it applies whenever the robot is in movement. The battery consumption (in percentage) due to robot movement is modelled as follows: $m\left(d_m\right)=100.0\times {\displaystyle \frac{d_m\times K_m}{B_{cp}}}$, where $d_m$ represents the distance travelled in any axis, stated in meters, and $K_m$ is a robot-model-dependant constant that represents a certain current motor drain at a constant velocity, in $mAh/m$. Lastly, $B_{cp}$ is the battery capacity in $mAh$. The $m\left(d_m\right)$ percentage is calculated internally by each robot concurrently with its movement. This calculation is subsequently subtracted from the current battery percentage, denoted as $b_c$.

Concerning packet routing during network operations, sensing nodes employ an ad hoc 2.4 GHz-operated protocol that implements a controlled flooding to transmit messages from the sensing nodes towards the data sink. This model, although simple to simulate, is realistic based on actual implementations [20,21]. According to this routing mechanism, a packet from node i to node j is forwarded (i.e., broadcasted) again by any node receiveing it if, and only if, that node has not already received the same packet and it is closer to the destination than the previous hop. The controlled flooding mechanism is summarized in Listing 1, where $dist(n1,n2)$ is a function that returns the Euclidean distance between Nodes n1 and n2, $mark\_seen(n,msg)$ is a function that sets a flag indicating that packet msg has already been retransmitted by node n, and $seen(n,msg)$ is a function that returns the state of that flag (i.e., if node n has already forwarded message msg).

Listing 1. Pseudocode for the controlled flooding routing protocol.

msg = {id: msg_id, dest: j, sender: i}   forward(i,msg)   function forward(node,msg):     if node==msg.dest:       process(msg)     else:       for neighbor in neighbors(node):         if not seen(neighbor,msg) and dist(neighbor,msg.dest) < dist(node,msg.dest):           mark_seen(neighbor,msg)           forward(neighbor,msg)

This model assumes that if a node n is within reach from a node i, there is a 100% percent likelihood of receiving a packet from node i in node n. This is purely determined by the chosen radio technology and its range.

Battery drainage due to network communications for each node n is proportional to the number of packets node n is transmitting and forwarding according to the traffic model and the controlled flooding routing mechanism.

The battery drainage, $U_p\left(n\right)$, for sending a single packet from node n that can reach all its neighbors within a certain range depends on (but is not proportional to) the transmission power necessary to cover that range. To model this, we define $U_p\left(n\right)$ as $U_p\left(n\right)=R_{packet}\times (1+R_{incdis}\times Range\left(n\right))$, where $Range\left(n\right)$ is the range covered by node n, $R_{packet}$ represents the baseline battery drainage when transmitting a packet, and $R_{incdis}(mAh/m)$ models the increase in this drainage depending on the range covered by node n ($Range\left(n\right)$). $R_{packet}$ and $R_{incdis}$ depend on the transceiver model and the chosen radio technology. In the tests presented in this paper, all the nodes are considered to have the same range and therefore the same battery drainage per transmitted packet.

Once the battery drainage for sending a single packet from node n to all its neighbors within the range it covers is determined, it is necessary to compute the amount of packets each node is transmitting and forwarding according to the traffic and routing models. In order to estimate the battery drainage at each node due to network communication when the MWSN is stationary, we assume that during this phase all network nodes periodically transmit data to the AP using the controlled flooding algorithm, and then we compute $P\left(n\right)$, the number of packets each node n is transmitting or forwarding during a network cycle. Thus, we can compute the battery drained by node n during every single network cycle as

$$Drain\left(n\right)=K_{duty}+P\left(n\right)\times U_p\left(n\right)\left(mAh\right)$$

(1)

where $K_{duty}$ is a constant that accounts for the battery drainage due to the waking up and duty-cycling of the sensing nodes.

Therefore, during a cycle and from a network perspective, all nodes send a packet to the AP, and intermediate nodes forward them according to the controlled flooding routing mechanism. As a result, nodes closer to the AP (which act as a data sink) experience higher energy consumption due to their higher number of packets forwards, and, consequently, they deplete first. The number of cycles each robot n lasts until depleted can be calculated by the difference between the current battery percentage and a critical level denoted by $b_{l0}$ as

$$Cycles\left(n\right)={\displaystyle \frac{0.01\times (b_c\left(n\right)-b_{l0})\times B_{cp}}{Drain\left(n\right)}}$$

(2)

This critical level $b_{l0}$ is further explained in Section 5.2.

For efficiency’s sake, our network simulations follow an event-drivent approach. Thus, network simulations advance in time until a node dies or when a node needs help in the Agents strategy, as stated in Equation (3). This is the minimum number of cycle value of N alive nodes.

$$si{m}_{Cycles}=min\{Cyles\left(0\right),Cycles\left(1\right),\dots ,Cycles(N-1)\}$$

(3)

After determining the minimum number of simulation cycles for the most critical node, the corresponding battery subtraction is performed on all alive nodes according to their expected energy expenditure. Once this operation completes, the network simulation ends and the system behaves differently depending on the election of the strategy: SPF-only or Agents, according to Figure 2. So, the network simulation interval takes place between a topology change and the moment when Equation (3) is met; that is, when a robot requires assistance and consists of a certain number of cycles, as in Equation (2).

5.2. Agents: Negotiation and Replacement

Agents negotiation adds an intelligent negotiation protocol to maximize both coverage and lifetime by replacing robots (agents) that are about to be depleted and thus balancing network load.

Each robot estimates the absolute minimum battery level it requires to reach a certain depot point safely (denoted as $b{l}_0$). To figure out how close robots are to reach that critical level, two additional heuristically chosen thresholds are introduced, $b{l}_h,b{l}_1$. In the equation below, $d_{dp}$ represents the distance between the current robot position and the depot point, expressed in meters. $K_m$ is a model of the current consumption due to motor movement, expressed in $mA\times h/m$, as introduced in the previous subsection. $B_0$ is the battery charge at simulation start expressed in $mA\times h$ and $B_{cp}$ represents the battery capacity in $mA\times h$.

$$b{l}_0=100\times (d_{dp}\times K_m+5\%\times B_0)/B_{cp}$$

(4)

$$b{l}_h=10\%\times b{l}_0+b{l}_0$$

(5)

$$b{l}_1=30\%\times b{l}_0+b{l}_0$$

(6)

The relation between $b_c$ (or current battery level) and the above-mentioned parameters indicates a robot’s urge to be replaced or, by contrast, its disposition to replace a robot in need. Those thresholds are combined in the willingness to interact or $w\left(t\right)$, as in Equation (7).

$$w\left(t\right)=\left\{\begin{array}{cc}-1,\hfill & if{b}_c\le b{l}_0,\hfill \\ {\displaystyle \frac{b_c-b{l}_1}{b_c}},\hfill & if{b}_c>b{l}_0\hfill \end{array}\right.$$

(7)

A negotiation round is triggered when an agent reaches a willingness value of −1, that is, critically close to depletion. This is accomplished by sending a message through the network asking for help (Figure 3a). Robots with positive willingness answer to this request by replying back with their disposition to help (Figure 3b). Other agents with negative willingness, but not higher than 20% on top of $w_H$, stated as $w_{H20}$, also send their request to be replaced. In this way, not only critical robots are replaced, but also a fraction of them that are becoming close to that level.

$$w_H={\displaystyle \frac{b{l}_h-b{l}_1}{b{l}_h}}$$

(8)

$$b{l}_{h20}=b{l}_h+0.2\times (b{l}_1-b{l}_h)$$

(9)

$$w_{H20}={\displaystyle \frac{b{l}_{h20}-b{l}_1}{b{l}_{h20}}}$$

(10)

Agents inclined to help others provide their disposition by sending a combination of their willingness and the utility parameter $u\left(t\right)$ to form $W\left(t\right)$ (Figure 3b). The utility is the mathematical model showing the trade-off between current position and moving to a new one. In $u\left(t\right)$, $b_m$ represents the battery expenditure to move to the new position and $b_n$ is the battery level from the new position to the depot point; similarly, $b_p$ is the battery level required to move from the current point to the depot point. Traffic routing is also considered, where $p_A$ reflects the battery spent on forwarding at the current position and $p_B$ is the battery that is necessary to spend on the updated point. From a physical perspective, the term ${\displaystyle \frac{p_B-p_A}{p_B+p_A}}$ enables the utility parameter to increase as the difference between the packets routed at the new position is greater than the routed packets at the current position. Similarly, ${\displaystyle \frac{b_m+b_n-b_p}{b_c}}$ ensures that agents farther away from the depot point are also participating in the negotiations as long as their new location is closer to the depot point than their current location. Thus, agents only provide a $W\left(t\right)$ greater than zero when they only have enough battery to move and operate in the new position, so that movement favors locations with higher traffic demands. In case of competing constraints after computing $W\left(t\right)$, the assignment is determined by the chosen algorithm. More details about the assignment algorithms are given in Section 5.5.

$$u\left(t\right)=\left\{\begin{array}{cc}1-{\displaystyle \frac{b_m+b_n}{b_c}}+{\displaystyle \frac{b_p}{b_c}}+{\displaystyle \frac{p_B-p_A}{p_B+p_A}},\hfill & if1-{\displaystyle \frac{b_m+b_n-b_p}{b_c}}>=0.3,\hfill \\ -w\left(t\right),\hfill & otherwise\hfill \end{array}\right.$$

(11)

$$W\left(t\right)=w\left(t\right)+u\left(t\right)$$

(12)

Robots asking for help notify their replacements by sending a packet through the network (Figure 3c). Once this is achieved, robots with critical battery level and those who are close to it return to the collection point. Agents chosen to replace others now move to the former locations. This process represents the Replacement and retrieval operation in Figure 2.

5.3. Readjustment

According to the routing protocol previously explained, robots with higher energy demands become the first to run out of battery (due to their more intense traffic routing, usually those who are closer to the sink). If the SPF-only strategy is chosen, those nodes continue operating at their place until their depletion, possibly creating a hole in the network between the sink and the further nodes. To avoid this, after each network simulation round, a redeployment is effectuated in order to make the network more compact. In the case of Agents, redeployments are performed without necessarily making the network more compact. This is due to the intelligent negotiation algorithm, which aims to maintain maximum connectivity while extending network lifespan.

5.4. SPF Forces

As previously introduced, both SPF-only and Agents strategies are supported on top of the SPF navigation algorithm. In order to determine the heading and the velocity the robots should follow, a set of attraction and repulsion forces are defined.

Obstacle repulsion forces, just as the name implies, prevent robots from colliding with elements (other robots, obstacles, walls, etc.). The detection of obstacles can be achieved by several means such as bumper sensors, imaging, or LIDAR. In this work, we opt for LIDAR-based obstacle detection. As mentioned, obstacles can include both physical statically placed obstacles (e.g., walls or objects in the middle of the environment) and other robots. Robots can be seen as obstacles when they are physically close to each other during the deployment stage or when they are stationary. The reason robots can be stationary at other phases include the exhaustion of their batteries (thus they cannot move any more) or when they are not part of a replacement operation in the Agents strategy. The formula for obstacle repulsion forces is defined:

$$f{r}_1\left(d_{i,j}\right)={\displaystyle \frac{256}{{\left(d_{i,j}\right)}^8}}$$

(13)

Not only do obstacle repulsion forces exist in SPF navigation algorithms, properly tuned robot repulsion forces aid with network expansion, whose expression is described below.

$$f{r}_2\left(d_{i,j}\right)={\displaystyle \frac{8\times {10}^8}{{\left(d_{i,j}\right)}^7}}$$

(14)

In both cases, $d_{i,j}$ represents the Euclidean distance between a robot i and an obstacle or another robot j.

With respect to attraction forces, punctual attraction forces allow robots to reach a specific point $\left(p\right)$ when an agent needs to be replaced.

$$f{a}_1\left(d_{i,p}\right)=-arctan\left(d_{i,p}\right)\times 2$$

(15)

Lastly, a cohesion force to gradually contract the network is presented in Equation (16). The cohesion force depends on the parameter $\alpha$, $n_{fail}\left(t\right)$ is the number of depleted nodes, n is the initial number of nodes and $n_{closeAP}\left(t\right)$ is the number of nodes within the radio coverage of the sink. This force acts by pulling robots to the origin of the coordinate frame $\left(z\right)$, as indicated by the distance $d_{i,z}$.

$$f_{c_i}\left(t\right)=-{\displaystyle \frac{\alpha \times n_{fail}\left(t\right)}{n\times n_{closeAP}\left(t\right)}}\times arctan\left(d_{i,z}\right)$$

(16)

Depending on the network phase and the chosen strategy, a set of forces commands the robots to achieve their goal (i.e., expanding forces -$fr1$- in the deployment or attractive forces when an agent needs to be replaced -$f{a}_1$-). A summary of the aforementioned forces is given in

Table 1. Forces according to strategy and network phase.

	SPF		Agents
	Deployment	Adjustment	Deployment	Replacement and Retrieval	Adjustment
Obstacles, $f{r}_1\left(d_{i,j}\right)$	✓	✓	✓	✓	✓
Robots, $f{r}_2\left(d_{i,j}\right)$	✓	✓	✓	✗	✓
Attraction, $f{a}_1\left(d_{i,p}\right)$	✗	✗	✗	✓	✗
Cohesion, $f_c\left(t\right)$	✗	✓	✗	✗	✗/✓

.

5.5. Algorithms

This paper, as previously pointed out, improves our existing work (as in [42,43]). Apart from refactoring some formulations in the negotiation part and porting the software to the ROS 2 environment, we additionally propose several assignment algorithms to be used with the Agents approach. These assignment algorithms are focused on determining which agent is to take care of a robot in need during the negotiation operation. In that sense, every algorithm takes place when a negotiation round is triggered. While the negotiation round is active, an agent or potentially a set of them is asking for help. However, based on their willingness, each agent has a different urgency to be replaced.

The first algorithm, ‘the algorithm 0’ (ALG0), recreates a distributed scenario where every agent that needs help is randomly picked up and the most adequate replacement is chosen. This approach, although straightforward to distribute, presents an inconvenience due to randomness. The disadvantage in this case is that it cannot be guaranteed that the agent with the most urgency is attended in the first place, which could lead to sub-optimal network utility.

In contrast, ALG1 sorts out the willingness of the agents in need and takes care of them in a logical order, prioritizing the ones with a more negative $w\left(t\right)$. Although this ensures the order in which help requests are attended, it represents a more challenging scenario to implement the ALG1 in a distributed manner.

The last algorithm proposed, ALG2, attempts to achieve optimal network utility. This is achieved by taking a slightly different approach. Contrary to the previous algorithms, ALG2 focuses on the robots that are willing to provide help. ALG2 sorts the agents with positive $w\left(t\right)$ in descending order and picks the robot in need in which the combined utility $W\left(t\right)$ is greater. Thus, robots with high willingness are maximizing network utility. The disadvantage this approach presents is the amount of information that needs to be exchanged, which complicates the implementation in a distributed form.

In order to conduct empirical comparison between ALG0, ALG1, and ALG2 against our base approach, the SPF-only strategy is effectuated in Section 6.

5.6. Software Architecture

The software that enables the implementation of the above-mentioned strategies and operations is based on ROS 2. The usage of ROS 2 permits the execution of the algorithms in a distributed manner in simulation or in actual deployments. The proposed software architecture is shown at Figure 4.

• Stage simulator plus ROS 2 node binding. This ROS 2 node (executable) carries out physics simulation for the robot models within a determined simulation world.
• Initial pose node. The ROS 2 node in charge of publishing the initial poses for each robot in the world reference frame [46]. The existence of this node can be justified due to the differences in the local robot position estimations (odometry) at ‘zero time’ and the real position in a common spatial reference.
• Robot controller. As the name implies, this software component manages the execution state of each robot. It is designed to run on both simulated and real robots. Essentially, the robot controller acts as a wrapper for one or more controller instances, referred to as the Robot class. By encapsulating multiple Robot class instances within a single Robot Controller ROS 2 node, the computational load is reduced compared to running a dedicated node for each robot. This makes it possible to run large-scale multi-robot simulations more efficiently. Without this wrapping, simulations involving 100 to 200 robots have proven too demanding for our test machines. The advantages of grouping multiple Robot class instances within one Robot Controller are demonstrated in

  Table 2. CPU and memory usage for 100 and 200 robots. Test machine specifications: Intel Core i7 12700K, 32 GB RAM, Ubuntu 22.04. Ten Robot controllers with 10/20 robots, respectively.

  Scenario	Mean CPU Usage (%)	Peak CPU Usage at Startup (%) 1	Memory Consumption (GB)
  Idle	0.5	NaN	1.7
  100 robots	24.5	39.1	4.5
  200 robots	38.1	91.2	9.4

  ¹ We attribute such high CPU utilization to the ROS 2 node discovery process and the launching of ’static transform publisher’ nodes. The static transform nodes are necessary to visualize the positions of the nodes and to avoid overhead after the transient state.

  , which highlights how computational requirements grow with swarm size. In real robots, however, this optimization is not feasible: each Robot Controller can only manage a single Robot class instance.
• Supervisor. The supervisor is a simulation mechanism the purposes of which comprise the launching of the deployment phase, the networking simulation, and the negotiation protocol (as right now it is centralized, and only when it applies). Additional tasks the supervisor carries out are those related to metrics collection and visualizing robot positions.

The software architecture presented above allows to not only take advantage of the already developed ROS 2 tools like simulators, packages, and utilities, but, given its modularity, to modify the number of robots either in simulation or in actual deployments only requiring minor tweaks in the Supervisor configuration files and spawning the correct set of Robot Controllers. Moreover, the recently mentioned ROS 2 configuration files permit a straightforward method to set various simulation parameters, like the forces or the algorithms and strategies to be used. More details about the different parameters used in this work are given in the next section.

6. Tests and Results

In this section, the results for comparing the SPF-only and Agents strategies are provided. Since the different strategies and algorithms aim to reach maximum lifespan while maintaining an optimal connected coverage, the two main metrics therefore consist of the connected coverage and the network lifetime.

As explained in Section 2, the connected coverage metric represents the fraction of the area that can be monitored by the robots that maintain network connectivity with the access point and the quality of the sensing they can perform in that area. In order to estimate this, we use the probabilistic sensing model proposed in [3], according to which the quality of sensing (sensitivity) that each robot can achieve gradually attenuates with increasing distance. Following this approach, in order to compute this metric, we divide the area into a probabilistic grid of M cells and we compute the quality of the sensing at each cell i as the probability of detecting an event that occurs at that cell ($p_i$). Since a given cell can be monitored by more than one robot, this in turn depends on the number of robots that can monitor that cell and the distance to each of them. Thus, if cell i is covered by N robots with connectivity to the AP, we compute $p_i$ as

$$p_i=1-\overline{p_i}=1-\prod _{j=1}^N(1-p_{ij})$$

(17)

where $p_{ij}$ is the probability of robot j detecting an event that occurs at cell i, which depends on Euclidean distance from robot j to cell i, $d_{ij}$. To estimate the quality of the sensing of robot j at cell i, we define several sensing ranges $R_0<R_1<R_2$ and compute $p_{ij}$ as

$$p_{ij}=\left\{\begin{array}{cc}1\hfill & if{d}_{ij}\le R_0\hfill \\ 0.6\hfill & if{R}_0<d_{ij}\le R_1\hfill \\ 0.2\hfill & if{R}_1<d_{ij}\le R_2\hfill \\ 0\hfill & otherwise\hfill \end{array}\right.$$

(18)

Therefore, the quality of the sensing at each cell represented by $p_i$ lies in the interval [0, 1], and $p_i$ is 0 if cell i is not being covered by any connected robot. The total coverage of the area achieved by the network of robots is subsequently computed as the average of the quality of the sensing at each of the M cells into which we divide the area:

$$C={\displaystyle \frac{1}{M}}\sum _{i=1}^M{p}_i$$

(19)

In the case of network lifetime, this metric is defined as the duration it takes the simulation to reach a certain threshold. This threshold, for example, represents the condition for ending the simulation, which is a number of 70 dead nodes.

6.1. Test Methodology

The tests are carried out using the Stage simulator. The simulated environment consists of a wall-delimited obstacle-free 150 by 150 m area. In this area, 100 differential-driven robots are placed, as a direct comparison with our previous work [43], although different scenarios can be set up in terms of robot density or robot models, as explained in Section 5.6.

Robots solely use LiDAR signals within a range of 3.5 m and the required sensors for odometry estimation. The characteristics present in these robots make them comparable with actual robotic platforms like Turtlebot 3. This fact, combined with the usage of ROS 2, can enable large-scale deployments of multirobot systems like this one in real scenarios.

The set of tests performed is stated in

Table 3. A summary of the different tests carried out.

Algorithm	Nomenclature	Alpha	Simulation Runs
SPF	SPF4	4	30
	SPF5	5	30
	SPF6	6	30
	SPF7	7	30
	SPF10	10	30
Agents	alg0	1.6	30
	alg1	1.6	30
	alg2	1.6	30
	alg2sc	0	30

. With respect to SPF-only tests, our baseline values, an analysis of the $\alpha$ parameter is carried out by testing different values such as 4, 5, 6, 7, and 10, with lower numerical values representing weaker cohesion forces. Regarding the agents’ strategy, the three previously described algorithms (Section 5.5) are tested. In addition, we examine whether the agents’ negotiation algorithm could replace the cohesion forces involved in the readjustment operation. Avoiding the need to set a specific value is a complex and time-consuming process that can significantly impact the results. To assess this, tests without cohesion forces are conducted using the latest algorithm, and each algorithm is labelled accordingly as ‘alg0’, ‘alg1’, ‘alg2’, and ‘alg2sc’ for Algorithms 0, 1, 2, and 2 without cohesion force, respectively. As in the SPF-only test, several alpha values are considered, although for clarity’s sake, only the results for the optimal alpha value (1.6) are presented. To ensure statistical significance of the results, 30 runs for every test configuration are performed.

6.2. Results

An overview of the results is presented in Figure 5, Figure 6, Figure 7, Figure 8, Figure 9 and Figure 10.

Figure 5 presents the final state in the network for two SPF tests—Subplots a and b—with the extreme values regarding cohesion forces (SPF4 and SPF10, with SPF4 being the weakest and SPF10 the strongest). The two subplots below, Subplots c and d, show the effect of the cohesion forces in the Agents ALG2 algorithm. On the left side, the lack of cohesion forces leads to the isolation of some nodes, whereas the subplot on the right includes a cohesion force, showing a uniform node distribution across the network without isolating nodes. A matter of interest is represented in the battery state (color gradients) that the nodes exhibit between the different approaches. A step imbalance can be perceived at the battery depletion in the SPF tests, where some of the nodes, especially those at the boundaries, comparably spend way less battery than the others. On the contrary, the Agents balance the battery expenditure uniformly.

A graphical representation related to the evolution of the different tests is given in Figure 6. In this figure, the evolution in coverage is compared with the elapsed time, also highlighting the relevance of the crucial parameter $\alpha$. All of the SPF-only tests demonstrate temporary certain coverage blackouts around 40 days of simulation time, regardless of whether a stronger cohesion force is employed (spf10) or a weaker cohesion force (spf4). The reason for the blackouts is due to how the cohesion forces operate, as they are directly proportional to the number of depleted nodes, among other parameters; Equation (16). Since the SPF strategy relies only on the cohesion forces as attractors to balance the network, there are moments where the distance between nodes is greater than the coverage radius, causing partial disconnections. In the Agents’ case, no communication outages can be perceived, showing a better overall stability (except for the test without cohesion forces, where a step loss in coverage can be seen towards the simulation end). The presence of dropouts in coverage can provide misleading conclusions if only the final lifespan is regarded. This is due to the routing algorithm and the battery simulation related to it. As unconnected nodes do not forward neighbors’ traffic, unconnected nodes spend less battery during a network simulation cycle, making the network artificially last longer. In this case, although the network has a greater lifespan, it is less usable than more stable alternatives. For this reason, different checkpoints are established to evaluate the merits of each approach at different simulation times. These values are obtained through ANOVA-1 analysis of the 30 simulations that take place for every test, ensuring the statistical significance of our results.

A proposed milestone covers the event when half of the initial nodes have depleted. Because the simulations comprise a number of 100 robots, this event is evaluated when 50 nodes have run out of battery. Figure 7 and Figure 8 represent the time needed to reach that event and the coverage with this number of nodes. In the Agents approach, a clear advantage in efficiency is shown with respect to the SPF approach. Every algorithm in the Agents strategy takes at least a median value for 80 days to deplete 50 nodes, whereas the SPF-only strategy takes, in the best scenarios, less than 75 days, even approaching 65 days when greater cohesion forces are applied. The efficiency of the Agents strategy does not come with a great loss in coverage, showing similar results to the SPF one, with all tests (except for the last algorithm without cohesion force) maintaining a coverage around 80 percent within less than 2% of standard deviation.

Similarly, another approach involves evaluating the network in the event that the coverage falls below a threshold of the 60%. In this case, the time required to reach this point is shown at Figure 9. As in previous figures, SPF-only strategies represent greater uncertainties, which are specially notable with spf4, spf5, and spf6. At the values when the SPF is more stable, a clear disadvantage can be perceived with respect to the Agents approach both in terms of stability and the network lifetime, even compared to the test without cohesion force.

Lastly, if the network lifetime is to be decided between the tests that are proven to be stable, a comparison is made in Figure 10. The blackouts in coverage and the instability present in spf4, spf5, spf6, and alg2sc, as shown in Figure 6, might discard this metric as a valid result (because of the reasons explained at the beginning of this section). This fact sets Algorithms 0, 1, 2, and the SPF-only strategy with cohesion $\alpha$ 7 and 10 as the remaining tests to be compared. The latter approach, even with temporary blackouts and greater uncertainties than the Agents, represent lower lifetimes with median values below 140 days. The similarities among the Agents result in a distinction favoring Algorithm 2 regarding final lifespan. This value is expected due to the optimality that this negotiation algorithm represents.

7. Conclusions and Future Work

In this work, we present a software package for the ROS 2 ecosystem aimed at providing a flexible test environment for evaluating deployment, operation, and retrieval strategies in mobile wireless sensor networks (MWSNs). We compare a standard SPF-only approach with an agent-based strategy, incorporating modifications such as cohesion force tuning and new negotiation algorithms. Our experiments demonstrate that the Agent-based approach achieves greater stability and system lifetime while maintaining coverage comparable to SPF-based methods. Additionally, the Agent algorithms are more effective in distributing energy consumption across the network, as shown in Figure 5.

Among the three algorithms evaluated, the similarity between Algorithms 0 and 1 is primarily due to the limited number of robots operating concurrently—typically between one and three—making it difficult to distinguish random behavior from deliberate decisions. In contrast, Algorithm 2 demonstrates a markedly longer system lifetime by leveraging more comprehensive information, resulting in more efficient replacements.

This platform provides a structured foundation for ongoing research, enabling both the validation of current strategies and the exploration of improvements in replacement logic, communication constraints, and integration with real-world systems.

Looking ahead, we recognize the potential of the Agent-based approach, particularly when enhanced with richer information. However, the complexity of distributed implementation motivates us to pursue an intermediate step in our future work. Specifically, we aim to augment SPF-based strategies with role-based or hierarchical mechanisms, which may offer more straightforward and scalable deployment in real-world distributed environments.

A second line of work focuses on improving our network simulation capabilities. We are currently developing a contribution that evaluates link–local and mesh–local broadcast communications using standard radio technologies. This includes experiments on a physical testbed where we assess additional parameters such as latency and energy consumption. These insights will feed back into our simulation models and help guide the integration of a more feature-rich network simulator in the near future. This refinement will also allow us to reassess the assumptions made in this study and evaluate whether the required communication for each MWSN phase should be further constrained.

Finally, the last step in our roadmap involves the integration of Hardware-in-the-Loop (HIL) scenarios. In this setup, one or more physical robots interact with simulated agents, enabling real-world data to dynamically refine simulation parameters. As outlined in [47], this hybrid approach will further improve the realism and applicability of our models, bridging the gap between simulation and deployment.