Multi-robot coordination and formations in unreliable
networks
Esteban Fernández González
TESI DE MÀSTER UPF / 2013
DIRECTOR DE LA TESI
Dr. Vladimir Estivill-Castro, Dr. Jorge Lobo
Departament de Tecnologies de la Informació i les Comunicacions
ii
iii
This thesis is dedicated to Mónica.
For her endless love, patience and support.
iv
Acknowledgements
Thanks to my supervisors, Dr. Vladimir Estivill-Castro and Dr. Jorge Lobo, for
their guidance and their confidence in me.
I'd like to thank Dr. Héctor Geffner, for coordinating the masters program and
especially for motivating us all to continue.
I'll always be thankful to my family, for their constant support, my mother Pilar.
My mother-in-law Rosa, my father-in-law Paco and my brother-in-law Javi.
Thanks to my friends, for always being there to cheer me up, Albert, Sara, Javi,
Lucía, Pere, Silvia and Éric.
To my classmates, Raimon, Alberto, Jonathan, Guillem, Sandra, David, Jordi
and Joan.
And last, but not least, to my partner, Mónica, whose love makes everything
possible.
vi
Abstract
We present a series of algorithms for maintaining a formation of mobile robots
resilient to network faults. We will see how the agent research in that respect
can be applied to experimental scenarios, its shortcomings and how they can
be worked around with several techniques. We propose several improvements
to an existing algorithm in regards with convergence, robustness and
termination, and two new algorithms.
viii
ix
Contents
Abstract...............................................................................................................viii
1. INTRODUCTION..............................................................................................1
1.1 Introduction.....................................................................................................1
1.2 State of the art................................................................................................1
2. EXPERIMENTS................................................................................................5
2.1 Experiments....................................................................................................5
2.2 Parameters.....................................................................................................7
a) Distribution of the vector of initial positions......................................................7
b) Number of robots..............................................................................................7
c) Threshold..........................................................................................................8
d) Timesteps.........................................................................................................8
e) Error rate...........................................................................................................8
f) Distance.............................................................................................................8
3. ALGORITHMS..................................................................................................9
3.1 Algorithm: Mean of two neighbors..................................................................9
3.2 Algorithm: Move to target if safe...................................................................15
3.3 Algorithm: Move to target if safe with beacon..............................................16
3.4 Network architecture.....................................................................................17
4. RESULTS.......................................................................................................21
4.1 Unmodified algorithms..................................................................................21
4.2 Timesteps.....................................................................................................25
4.3 Thresholds....................................................................................................27
4.4 Error rate.......................................................................................................29
4.5 Distance........................................................................................................31
x
4.6 Observations.................................................................................................31
5. CONCLUSIONS..............................................................................................33
5.1 Contributions and discussion........................................................................33
5.2 Applicability...................................................................................................34
5.3 Future work...................................................................................................34
REFERENCES...................................................................................................35
xi
1. INTRODUCTION
1.1 Introduction
Mobile robotics are becoming ubiquitous, either with home robots such as the
popular iRobot Roomba [Forlizzi et al., 2006] or unmanned aerial vehicles for
crop management [Terravion]. Inexpensive robots have made it possible to
have teams of agents to accomplish certain tasks that were not feasible before.
With teams of robots also come new challenges in robotics, which expand to
other areas such as wireless networks. One of the challenges is to maintain
formations of mobile autonomous robots in a consumer-grade networks.
Combining the fields of multiagent research, mobile robotics and wireless
networks can provide solutions to an experimental problem. In our case, we are
interested in maintaining a formation of a group of robots, and we will see how
this problem combines research from coordination and negotiation, from the
multiagent literature, localization, and sensor interpretation and fusion from
robotics and reliability and routing from wireless networks.
The organization of the present work is the following: we will see an overview of
the state of the art and the related work, then we proceed to describe the
methodology to test our research, followed by a presentation of the proposed
algorithms. We will see the results and observations of testing our research
based on the experimental methodology we outlined and finally, we present the
highlights and conclusions of the present research.
1.2 State of the art
We found research that similarly bridges agents and robotics. In Olson et al.
(2013) present a report on the Multi Autonomous Ground-robotic International
1
Challenge (MAGIC) funded by the DSTO and TARDEC, much similar to the
DARPA challenges. In MAGIC, teams of autonomous robots are used to
collectively map an urban area, with similar unreliable network conditions and
limited localization. Our work is focused in a simpler goal, but which as we will
see, presents several challenges in real-world robotics, where many issues
arise.
Formal verification of agent formation protocols has been studied [Chandy et
al., 2011; 2008; Anderson et al., 2010 and Tabuada et al., 2001], though not
applied to real-world robotics.
Chandy et al. (2008) propose a framework called PVS for verifying distributed
systems; in that paper, they propose an algorithm for spreading agents evenly
across a line. They use this algorithm to show their verification framework,
because the agents only use local information to guarantee global properties.
Though we do not use the verification framework showed in the article, we use
the algorithm and scrutinize its properties.
On the other hand, Anderson et al. (2010) study how to maintain a formation of
four agents using their relative distances. This is an approach very similar to the
one we chose, though ours is not restricted to just four agents and we take into
account network failures. However, Anderson et al. (2010) extend formations to
two dimensions, whereas we only focus on a one-dimensional space.
Tabuada et al. (2001) show a framework for testing the feasibility of undirected
and directed agent formations. The focus is on whether the agent trajectories
can maintain the inter-agent constraints, using the kinematics of the agents.
This work, similar to Chandy et al. (2008), establishes a mechanism for
checking properties of a distributed system. However, instead of focusing on
local-global predicates, Tabuada et al. (2001) chose to use the agent
kinematics.
Related work can be found in Gilbert et al. (2009), in which agents spread
themselves on a curve, instead of a line. Network failures are handled by a
network abstraction, called Virtual Stationary Automata (VSA) Layer [Dolev et
2
al., 2005; Nolte and Lynch 2007]. However, in our case, network robustness is
an intrinsic part of the algorithms we present, and do not delegate such task to
a separate layer. This means that our algorithms can be implemented, even if
an infrastructure such as VSA can not be supported by the underlying network
layer.
3
2. EXPERIMENTS
2.1 Experiments
In order to prove our algorithms and to draw conclusions from which we could
improve their convergence rate, we will run a series of experiments, each with
different parameters.
Our experiments are based on running the same simulation ten times for
different initial distributions of the robots for every change in the parameters
(table 1). We then calculated the average time it took in each case and
compared it to the previous results.
Parameter
Value
Description
Distribution of the vector
of initial positions
- Uniform
- Gauss (mean = 100,
variance = 1)
- Gamma (mean = 2,
dispersion = 10)
Number of robots
3, 4, 5, 6, 7, 8, 9, 10, 20, The number of robots
30, 40 and 50
varies to test the
scalability of the
algorithms
Threshold (same
distance unit as
positions)
0.01, 0.1, 1
Timestep (in seconds)
0.1, 1, 10 and until target The duration of the move
is reached
phase
(9999999999999)
Error rate
0, 0.3, 0.6 and 0.9
Distance (same distance 250, 500
unit as positions)
Initial positions for the
robots are assigned by
drawing samples from a
given distribution
Precision of robots when
reaching their target
position
The probability of a robot
of losing messages from
its neighbors
Distance between both
ends of the line
Table 1: Parameters used in the experiments
5
Experiments are run in a simulated environment, which provides several
advantages over running on real robots:
– Network failures can be tested in a deterministic manner to ensure that
the algorithms are robust.
– Using a significant number of robots may incur in increased costs, by
using a simulated environment we can use use an an arbitrary amount of
robots for testing the scalability of the algorithms.
The simulated robots, called e-puck, are rather simplistic, they are differential
and only use odometry as the localization mechanism [Mondada et al., 2009].
However, our intention is to test their behavior as part of a larger group and to
prove that our algorithms do not require sophisticate robots to work.
We used the Webots [Michel, 1998] simulation software, which provides a
realistic physics environment. Algorithms were implemented in Python, using
the reactor-based [Schmidt, 1995; Schmidt et al., 2000] Twisted framework
[Fettig et al., 2005] and the scientific toolkits Numpy, Scipy and Matplotlib
[Hunter, 2007; Oliphant, 2007].
A video of a Webots simulation of the first algorithm in which we force network
failures
and
unresponsive
robots
can
be
reached
at
[https://www.youtube.com/watch?v=o6N7Y6-t7O4].
Though we are mostly interested in the convergence rate, i.e. the time it takes
for an algorithm to halt, we also measured the number of messages transmitted.
This is an important issue in environments where there is either a lot of noise in
the transmission channel or when message passing incurs in a significant cost,
such as mobile networks, where wireless communication consumes a nonnegligible amount of battery. In our case, though, the power used by the
wireless network is much lower than the battery consumption by the robots'
motors.
6
2.2 Parameters
Our testsuite is comprised of several parameters that affect the simulation of
each experiment. We believe the testsuite is comprehensive enough to prove all
aspects of the algorithms.
a)
Distribution of the vector of initial positions
We want to test how positioning the robots in different configurations affect the
performance of the algorithms. The chosen distributions reflect the three
primary clustering of robots:
– Uniform: robots are distributed across the line with the same probability.
– Gauss: robots are clustered close to the center of the line.
– Gamma: robots are clustered close to one end of the line.
Other distributions were considered (such as clustering robots on both ends),
but we saw that these three are the ones that best represent the different robot
configurations.
b)
Number of robots
One of the goals of these experiments is to test the scalability of the three
algorithms. We will see, though, that the greater the number of robots are
involved, the less they can travel across the line, and therefore some
improvements do not have an impact in the algorithms' performance.
Also, we want to explore if we can predict the behavior of an arbitrary number of
robots given the previous runs, i.e. if for any given X robots, the results obtained
for 0 < X can help us to estimate the running time.
7
c)
Threshold
Given that neither movement or location is exact in a robotics experiment,
unlike in agent theory, and it usually comes at a cost of performance, we use
the threshold parameter as a precision measure to influence the running time.
d)
Timesteps
As we will see later, algorithms use a two-phase approach, one for
communication and the other for movement. During the move phase, robots do
not engage in the communication phase until they have reached their target in
the move phase. We limit the move phase in order to increase the rate at which
communication happens. We use different intervals and evaluate how they
affect the running time and the number of messages.
e)
Error rate
Our algorithms need to be robust to network failures. As such, we used the
error rate parameter to simulate the loss of transmitted messages. In our case,
the error rate is set equal across all the robots, that is, it is not set independently
for each robot.
f)
Distance
An essential parameter of the algorithms we are testing is how much space they
can travel between the two ends of a line. We will test how distance affects both
the time and the number of messages, and if there is a mechanism by which we
can estimate these two measures with respect to distance and the number of
robots.
8
3. ALGORITHMS
Our research is focused on a set of n agents/robots such as A={A0,...,An-1}, in
which each robot has a means for localization, whether it is odometry in
differential robots or more sophisticated mechanisms, such as vision or GPS,
and actuators (motors) so that they can move. Given the one-dimensional
nature of this protocol, robots must be able to move along a line, can locate
themselves using odometry and can talk to each other via a wireless network.
The algorithms we present all have the same formation goal, that is, to
distribute evenly a finite number of robots over a line. Though they can be
extended to make other formations, our goal is to optimize the space a group of
robots can reach.
3.1 Algorithm: Mean of two neighbors
The first algorithm, proposed by Chandy et al. (2008), which we will call Mean of
two neighbors (MO2N), is split into two phases:
– a communication phase, where robots advertise their own position and
listen for their neighbors'
– a move phase, in which robots move towards a target position
determined by the the information received in the previous phase.
These two phases are run sequentially until the robots reach a position close to
their final destination (figure 1).
Given n robots, a robot A will, during the communication phase, broadcast its
position to robot A – 1 and robot A + 1, while at same time listen for their
respective positions. Once it has obtained positions from both neighbors, it'll set
its target position for the next phase to the middle of the received positions. In
case the robot A fails to receive the position for at least one of the neighbor
positions, it will stay put and keep in the communication phase.
9
The move phase sets the robot A in motion, moving towards the target
calculated in the move phase. The robot will not switch to the communication
phase until it has reached its target, thus becoming deaf for the whole move
phase, discarding any message coming from its neighbors.
The algorithm proposed by Chandy et al. (2008) works under certain
assumptions, which, when applied to the field of robotics, require certain
workarounds to make it work.
The first assumption is that movement is instantaneous, which obviously is
physically unrealistic; the second is that robots can locate themselves
accurately which, although feasible, in most cases the precision is not
guaranteed; a third assumption is that of network availability, in the original
algorithm agents can share the communication channel without fear of
overlapping their messages.
Figure 1: Communication and move phases
10
These three assumptions cause several shortcomings, namely:
– Movement is not instantaneous and, therefore, the convergence rate is
much slower. The asynchronous nature of the algorithm results in robots
standing still until their neighbors finish their move phase.
– Robots cannot locate themselves with the same precision as expected in
the algorithm. Robots get stuck in a back-and-forth loop trying to reach
their destination in the move phase.
– Packet collision in the wireless network causes messages to be dropped,
lowering the convergence rate.
Despite these shortcomings, the algorithm retains its stability and finally
converges. We have devised several solutions to address or mitigate these
issues.
The first issue obviously cannot be solved because of the physical limitations of
the robots, however we present two approaches. The first approach limits the
time a robot can move without announcing its location. In figure 2 we see the
amount of time it takes for the group to converge using different timesteps
compared to the original algorithm where the robots do not announce their
position until they reach their destination.
Figure 2: Running time for different timestep values
The second issue of the algorithm requires some form of localization for the
robots, be it odometry, visual detection of landmarks, GPS, or a fusion of
11
several sensors. As such, any form of sensor will produce uncertainty and
therefore we have to experiment with several values for a threshold in which
robots will simply announce when they arrive to the calculated destination,
despite being just an approximation. We see in figure 3 the amount of
messages produced based on the number of robots involved and several
threshold values.
Finally, the third issue can be addressed by a combination of two approaches.
First, the use of UDP broadcasting, instead of point-to-point communication, will
reduce the amount of packets needed. Although counterintuitive at first, since
we are using a 802.11 network, any kind of point-to-point communication will
require acknowledgement from the physical layer, defeating the purpose of
using UDP. Instead, we send messages without a specific destination address,
and we will let robots pick the messages that are addressed to them from the
payload. This, in turn, will mean we will only send half the messages, since in a
single payload we can specify the two neighbors of a robot.
Figure 3: Number of messages with different threshold values
The second approach involves switching to a time-triggered architecture, so at a
given time, only one of the robots can announce its address. This is useful in
heavily congested networks, but at the same time defeats one of the
advantages of the algorithm, since the robots did not need to be synchronized
at all.
12
However, an issue that is not being dealt is the algorithm termination, since
originally it is expected to run indefinitely and converge.
This algorithm has several interesting properties that make it suitable for this
kind of problems.
The first property is that of ease of implementation: though the original algorithm
assumes instantaneous movement and communication, it essentially relies on
finite message delivery time and bounded message delivery when applied to a
practical scenario. These two characteristics can be guaranteed in a
deterministic way in a time-triggered architecture [Kopetz and Bauer, 2003].
An additional aspect that shows the ease of implementation property is that we
can decide the duration of both the communication and the move phases during
initialization of the algorithm. When implementing this algorithm in a timetriggered architecture, the duration of the communication phase for every robot
can be evenly across all robots. During a given slot i, only the robot i is allowed
to broadcast its position, whereas the same robot i will listen to its neighbors in
every other slot, and thus preventing packet collision.
As we will see later, the ability to set the duration of the move phase will have
an impact on the convergence rate. Initially, robots will move until they reach
their destination and thus, will not switch to the communication phase before
halting. An added benefit of this property is that robots can move at different
speeds, without having a negative impact in the communication and move
phases.
The following property we want to emphasize is uniformity. The same algorithm
is being run in all the robots, there are no special cases that depend on their
position. Both the robots in the boundaries and the robots between them run the
same code, and the only requirement is that each robot can locate itself and
has a number that identifies it uniquely.
We identified a fourth property: no state needs to be shared across runs, every
new run of the communication and move phases does not depend on
13
information from the previous runs. Although this property can be relaxed in
order to provide better knowledge of the health of the network (such as to detect
faulty robots), we have decided to keep the algorithm as simple as possible.
A major concern for us is that robots must be safe from colliding with each
other, and in that respect, this algorithm exhibits this property. Despite using
only the localization sensors found in the robot and no external information is
injected into the system to guarantee the safety of the robots' movement, the
algorithm ensures that, since a robot will only move, at most, to the half of the
distance between itself and a neighbor. This property proves to be extremely
useful and helps to avoid complex machinery to ensure the safety of the robots.
The sixth property we have considered is that, even in the case of a permanent
failure of a robot, the rest of the robots will distribute evenly on both sides. That
is, given a faulty robot Ai, both robot Ai+1 and Ai-1 will not move, since they will
not receive the position of robot Ai. However, robots adjacent to Ai+1 and Ai-1 will
function properly and will execute the algorithm to spread evenly between Ai+1
and An-1 on one side and between A0 and Ai-1 on the other.
The algorithm also shows another property: it will converge. That is, robots will
reach their final position over time, given an Є. For any Є > 0 and the current
vector of positions, there would be a round number in which the position vector
will not be more than Є away from the target vector.
We also noticed an eighth property: the formation that the robots will make over
time will stay arbitrarily close to the target formation. This is what we call
stability: the formation will not break even if there is a permanent failure after
reaching the target vector of positions.
The last property this algorithm has is that the communication and move phases
do not overlap. That is, these phases are strictly separate and robots will not
concurrently communicate and move. While in a practical scenario a robot can
effectively use the communication channel and activate its motors at the same
time, it is very hard to verify an algorithm formally unless certain restrictions are
imposed with regard to how the CPU will process events. Separating the two
14
phases helps us identify what phase will be executed next in a deterministic
manner.
This algorithm lacks a mechanism for termination, and despite converging, it
does not guarantee it will halt. As we will see later, in our experiments we had to
add an external hypervisor process that will terminate the algorithm according to
certain conditions, such as proximity to the target vector, as shown in figure 4,
where the higher the precision threshold, the longer it takes for the algorithm to
terminate.
Figure 4: Running time for robots in an initial gauss distribution and different
thresholds
3.2 Algorithm: Move to target if safe
The findings of the MO2N algorithm led us to propose an alternative algorithm,
which we refer to it as Move to target if safe (MTTIS). As we will see, it solves
several issues, while maintaining the properties of the first algorithm.
We have again two phases: one where robots communicate with each other
and another one in which robots move. This time, though, the behavior in the
communication phase differs. We initialize robots with a belief of how many they
are and what the distance between robot0 and robotn-1 is. Before the algorithm
starts, each robot will calculate its final destination by the following formula:
targeti = position0 (A0 ) + i(position0(An−1) − position0(A0))/(n − 1)
15
During the communication phase, robots once again receive the positions of
their respective neighbors. This time, though, once a robot has determined its
final destination, it can ascertain if a robot is blocking its way to its goal. If that is
not the case, it is free to move towards its goal. However, if a robot is blocked
by another robot, it will only move to a safely close position to the blocking robot
in order to avoid a collision.
This algorithm not only maintains the safety property of the first algorithm, but
also adds more useful properties. The first one is that this algorithm terminates,
all robots know what is their final position, they can determine when to stop by
themselves. This was problematic in the first algorithm, in which we had to add
an external process to terminate it. This time, though, the algorithm does not
require such machinery, and is fully autonomous in the sense that it does not
require a central authority that watches whether the robot reaches its goal or
not.
The second new property is the algorithm's monotonic movement. Whereas
previously a robot may move back-and-forth until it reaches a stable position,
this time robots will only make moves towards the correct destination, which is
is crucial in an experimental scenario to save battery. This property is closely
related to the previous one, since robots now know what is their target position.
An additional property is that we can now implement the algorithm in a timetriggered architecture, given that now robots have a belief of how many robots
are in the system. Previously, robots did not have the knowledge or the belief of
the number of robots that participated in the formation, they only knew about
their neighbors.
3.3 Algorithm: Move to target if safe with beacon
Our third algorithm, Move to target if safe with beacon (MTTISB), builds upon
the previous ones. We have seen that due to the strict separation between the
move and communication phases, a robot will effectively become deaf during
16
the time it takes to move towards its target. We therefore devised a method
which, while retaining the same properties, uses a mixed approach combining
aspects of both phases in order to obtain a faster convergence rate.
Based on the observation of the second algorithm, we noticed that if given
robots A and B, where both A and B are in the same direction, and A blocks B's
target, once A is in the move phase and crosses B's target, B would be free to
move towards its target without the risk of colliding with A.
Adding a robot's target destination to the messages it broadcasts enables other
robots to be aware of when they no longer block neighbor robots. We propose
an improvement for the second algorithm, in which a blocking robot may
broadcast when it has effectively crossed its neighbor target, and the blocked
robot will start its move phase towards its target. This improvement preserves
the safety property of the previous algorithms and adapts to any distance
between robot0 and robotn-1
3.4 Network architecture
We briefly mentioned two of the network architectures that we tested: eventdriven and time-triggered. The goal these two architectures is the same,
coordinate the pass of messages between the robots and their subsequent
switch to the action phase.
In Chandy et al. (2008) the agents respond to the messages they receive
immediately. This architecture offers a reactive model, which does not require
synchronization from all the nodes in the network. Agents are listening on the
same channel during their respective communication phase, and reply without
the need of any handshake. This is a very straightforward approach, and works
on many cases where the communication channel is not congested.
Several variations of this architecture exist. However we chose the reactor
pattern [Schmidt, 1995; Schmidt et al., 2000] as the implementation for the
17
event-driven version of the algorithms because of its simplicity for handling
network events. A process called “reactor” is responsible for demultiplexing the
incoming requests and dispatching them to a set of defined handlers, a suitable
programming model for problems we are exploring, which are mostly
asynchronous.
The event-driven architecture, however, assumes that the channel will not be
subject to collisions or congestion. In certain scenarios, such as the Robocup
competition, the underlying wireless network is shared by many teams, which
causes an interesting problem. In a 802.11 wireless networks, the physical layer
is shared by all the clients, in order to avoid collisions, 802.11 uses the
CSMA/CA protocol [P802.11], which consists in two phases, one in which a
client listens and the other in which it transmits. Given two clients (A and B):
– Client A will start in an idle state and listen on the network to detect if
another client is transmitting in the same channel.
– If the network is idle, client A will transmit its packet.
– If client B is transmitting, client A will wait a random backoff and checks if
the network is idle again.
This cycle will repeat until client A and B have transmitted their respective
messages. However, in a heavily congested network, such as Robocup's,
packets may get delayed until they find a free slot in the shared channel. This
may be a minor annoyance in a regular wireless network, but in the case of
mobile robots, any latency has a huge impact. For example, if a robot senses
the ball and intends to transmit its position to another robot, any delay will cause
that position to become invalid when the other robot receives it.
In a time-triggered architecture [Kopetz and Bauer, 2003], such problems do not
exist, all participating members of the network agree to transmit only during
certain windows. The global communication cycle is split into equal slices, each
for every participating member. At every slice, only the client who is assigned to
it will transmit its messages. Once that slice is over, the next client will transmit
18
during its assigned slice, and so on, until the global communication cycle ends.
This architecture imposes certain constraints. First of all, we must synchronize
all the members in the network, this could be done with a simple protocol such
as NTP. We also need to know how many clients are participating in the
network in order to split the communication cycle evenly.
The time-triggered architecture makes a perfect fit for the MTTIS algorithm,
since we already need to know how many robots are in the formation
beforehand to calculate their target positions.
19
4. RESULTS
Our testsuite comprises tests for both the original forms of the algorithms
presented, and for their respective variations using the different parameters:
– Thresholds: how precise the robots should be when reaching their
targets.
– Timesteps: limiting how the move phase must last before switching to the
communication phase.
– Error rate: measuring how the loss of messages impact the performance.
4.1 Unmodified algorithms
In table 1 we can observe the results of running the Mean of two neighbors
(MO2N) algorithm with the robots initially positioned according to the
distributions (gauss, gamma and uniform).
The first thing we can extract from the results is that the gamma distribution
consistently causes the algorithm to run the slowest. We can explain this
behavior because the robots are clustered close to one end and, once the robot
An-2 (i.e. closest to the other end) starts moving, it will not announce its location
(i.e. switch to the communication phase) until it has reached (position(An-3) +
position(An-1)) / 2, and therefore robots A1... An-3 will stay still. In the end, the
algorithm will move one robot at a time.
The gamma distribution also causes the algorithm to transmit more messages
than the other distributions, precisely for the same cascading behavior, still
robots will keep transmitting messages until A1...An-2 are free to move.
The uniform distribution has fairly consistent results, which is explained
because the algorithm's goal is to spread robots evenly and the uniform
distribution causes the robots to be placed close to their target positions.
21
However, the gauss distribution had an interesting progression. With a number
of robots between 6 and 10, had a stable behavior for both the number of
messages and the running time (between 146.6 and 149.6 seconds, and
between 2192 and 4426) and then grew as the number of robots increased.
# robots
Time
(gauss)
Message
Time
Message
Time
Message
s (gauss) (gamma)
s
(uniform)
s
(gamma)
(uniform)
3
2.100
20
79.600
640
54.600
440
4
101.600
852
181.100
2150
34.601
410
5
54.101
686
193.600
2874
112.600
1618
6
146.601
2192
240.100
4398
172.101
3088
7
146.600
2888
281.600
6196
136.601
2932
8
142.601
3200
247.101
6160
57.601
1408
9
147.601
3788
348.101
10252
199.101
5300
10
149.601
4426
354.601
11748
61.601
1814
20
233.603
16110
525.603
38344
222.603
16160
30
284.103
30888
699.603
80070
207.104
23764
40
353.102
52708
934.103
145814
461.103
72088
50
468.604
89940
1281.104 252530
123.603
23852
Table 2: Results for the unmodified MO2N algorithm
Both the MTTIS and MTTISB algorithms results (tables 1 and 4) exhibit similar
behaviors, with MTTISB showing better performance overall, especially in the
gamma distribution case. This proves that the improvement introduced in
MTTISB, announcing the moving robot's position once it has crossed past its
neighbor's destination, not only reduces the time the robots need to reach their
target, but also reduces the number of messages transmitted.
# robots
Time
(gauss)
Message
Time
Message
Time
Message
s (gauss) (gamma)
s
(uniform)
s
(gamma)
(uniform)
3
2.101
11
79.601
321
54.601
221
4
33.601
139
164.101
983
23.600
115
5
50.101
308
209.600
1587
72.601
393
6
81.601
668
264.100
2556
124.601
1148
7
98.102
987
355.100
4146
75.600
643
8
126.102
1518
290.101
3711
32.601
380
22
# robots
Time
(gauss)
Message
Time
Message
Time
Message
s (gauss) (gamma)
s
(uniform)
s
(gamma)
(uniform)
9
148.602
2094
568.601
9015
122.102
1783
10
171.102
2738
590.101
10466
21.103
253
20
411.640
14829
1257.634 47248
166.131
5443
30
666.101
37336
1529.157 87338
35.134
1710
40
920.122
69996
1815.127 139156
79.630
5400
50
1161.616 111587
2610.603 253462
43.133
3794
Table 3: Results for the unmodified MTTIS algorithm
# robots
Time
(gauss)
Messages
Time
Message
Time
Message
(gauss) (gamma)
s
(uniform)
s
(gamma)
(uniform)
3
2.100
11
80.100
323
54.600
221
4
33.600
139
114.880
721
23.600
115
5
50.100
308
138.614
1079
60.600
453
6
81.600
749
178.167
1770
121.838
1193
7
98.600
1059
251.172
2964
76.600
655
8
111.112
1455
203.745
2614
29.344
387
9
121.600
1755
440.561
7008
104.413
1512
10
138.967
2312
464.467
8226
21.102
253
20
344.942
12456
1148.742 43223
135.605
4449
30
587.200
32915
1490.112 85262
22.101
1054
40
845.551
64203
1869.246 143632
64.782
4385
50
1112.860 106736
2811.495 273489
31.334
2735
Table 4: Results for the unmodified MTTISB algorithm
We can see in figures 5, 6 and 7, the graphics for the results in the tables 2, 3
and 4, we only considered the results for up to 10 robots. The reasoning for this
is that, as the number of robots increase, the distance they can travel
decreases to the point where most of the time is spent during the
communication phase and not in the move phase. Also, limiting the graphics to
10 robots at most, gives us the chance to evaluate the evolution of the algorithm
better.
23
The MO2N algorithm outperforms the two algorithms we propose, however our
results only show the time it takes for the MO2N algorithm to reach the target
vector of positions, but we must remember that the algorithm, as originally
formulated, does not halt.
On the other hand, the other two algorithms (MTTIS and MTTISB) do actually
terminate by themselves and can be implemented in a real scenario without
requiring an external process that terminates them.
As we expected, MTTISB performs better than MTTIS both in total time to
converge and with a lower number of messages transmitted. The performance
gain is specially dramatic in the case of the gamma distribution, the most
problematic of the three, while the results are similar with the uniform
distribution and slightly better in the gauss case.
Figure 5: MO2N algorithm with gamma, uniform and gauss distributions for initial
positioning
Figure 6: MTTIS algorithm with gamma, uniform and gauss distributions for initial
positioning
24
Figure 7: MTTISB algorithm with gamma, uniform and gauss distributions for initial
positioning
We have seen that in the three algorithms, the most interesting scenario is
when we have fewer robots. When the number of robots increases, the robots
are stuck and most of the algorithm is in the communication phase. Also, the
most problematic case is the gamma distribution. Therefore, we are going to
focus the rest of our results in this case and see how the different parameters
affect our algorithms.
4.2 Timesteps
MTTIS performs slightly better than MO2N with timesteps, as we can see in
tables 5 and 6. In figures 8 and 9, we can see better the evolution of both
algorithms for up to 10 robots.
Figure 8: MO2N algorithm with up to 10 robots and variable timesteps
25
# robots
Time
(timestep
0.01)
Time
(timestep
0.1)
Time
(timestep
1)
Time
(timestep
10)
Time
(timestep
999999999
9999)
3
3944.600
394.600
114.101
83.100
79.600
4
5739.100
574.600
170.101
127.600
181.100
5
5956.101
597.100
181.600
135.601
193.600
6
6262.601
628.600
194.101
162.100
240.100
7
6836.101
687.600
215.100
191.101
281.601
8
5919.100
596.600
190.100
191.600
247.113
9
7751.100
783.601
278.100
248.600
350.100
10
7487.100
760.100
252.600
258.101
354.600
20
7786.107
852.602
392.602
425.102
523.602
30
7011.601
905.101
573.626
610.602
698.601
40
6916.102
1095.103
837.601
867.602
933.114
50
7241.604
1418.620
1160.102
1191.604
1280.646
Table 5: Results for the MO2N algorithm with different timesteps for the move
phase
# robots
Time
(timestep
0.01)
Time
(timestep
0.1)
Time
(timestep
1)
Time
(timestep
10)
Time
(timestep
999999999
9999)
3
3944.601
394.600
113.600
83.100
79.604
4
5738.601
574.100
169.600
120.601
164.100
5
5955.101
595.603
179.102
124.602
209.602
6
6260.101
626.108
179.108
132.101
264.100
7
6832.102
683.601
200.601
144.101
355.600
8
5915.102
591.603
190.111
124.601
290.178
9
7743.103
774.602
232.602
178.103
568.600
10
7476.604
748.101
218.602
157.602
590.105
20
7732.605
773.609
248.150
174.103
1257.620
30
6881.112
688.664
207.184
215.214
1529.199
40
6688.115
669.154
201.177
282.101
1815.601
50
6854.164
685.764
207.233
371.603
2612.603
Table 6: Results for the MTTIS algorithm with different timesteps for the move
phase
26
Figure 9: MTTIS algorithm with up to 10 robots and variable timesteps
4.3 Thresholds
An interesting result we obtained from running the experiments with different
levels of precision for robots to reach their target destination is that unlike
M2ON (table 7), the MTTIS algorithm's performance (table 8) is not affected by
how precise the robots have to be to arrive to their destination.
MO2N's performance (figure 10) increases as the precision to reach the target
position decreases. This discrepancy between MO2N and MTTIS can be
explained by realizing that robots implementing MTTIS (figure 11) do not have
to negotiate their destination with their neighbors, a robot that uses MTTIS only
needs to ensure that, in the case there is a neighbor robot blocking its path, its
target position is within the safe limits and does not collide.
Figure 10: MO2N algorithm with up to 10 robots and variable thresholds
27
# robots Time (threshold 0.01) Time (threshold 0.1) Time (threshold 1)
3
79.600
79.600
79.600
4
183.100
181.100
177.600
5
197.100
193.600
190.100
6
246.101
240.100
234.100
7
289.600
281.600
272.100
8
258.100
247.100
234.600
9
362.601
348.100
333.100
10
372.600
354.601
334.600
20
605.101
525.601
439.601
30
895.601
699.601
502.601
40
1281.628
935.101
580.102
50
1837.172
1277.612
715.103
Table 7: Results for the MO2N algorithm with different thresholds
# robots Time (threshold 0.01) Time (threshold 0.1) Time (threshold 1)
3
79.600
79.600
79.624
4
164.100
164.100
164.100
5
209.601
209.600
209.601
6
264.100
264.100
264.101
7
355.101
355.100
355.101
8
290.126
290.101
289.101
9
568.601
568.601
568.601
10
590.101
590.101
590.101
20
1257.647
1257.644
1257.609
30
1529.172
1529.136
1524.151
40
1815.102
1815.101
1794.120
50
2611.103
2610.103
2574.605
Table 8: Results for the MTTIS algorithm with different thresholds
28
Figure 11: MTTIS algorithm with up to 10 robots and variable thresholds
4.4 Error rate
The goal of this test is to determine how the algorithms behave when messages
are lost. Both algorithms show their robustness against the loss of messages
(tables 9 and 10) and both have worse performance, but still converge at a
lower rate (figures 12 and 13).
Figure 12: MO2N algorithm with up to 10 robots and variable error rates
29
# robots Time (error rate
0.9)
Time (error rate
0.6)
Time (error
rate 0.3)
Time (error
rate 0)
3
85.600
81.600
79.600
79.600
4
225.601
190.100
172.600
181.101
5
333.100
227.100
209.600
193.600
6
419.100
264.600
232.600
240.101
7
549.100
317.600
300.100
281.600
8
638.600
315.101
269.600
247.100
9
858.600
421.100
355.100
348.101
10
952.101
447.101
366.101
354.601
20
3015.602
966.602
655.101
522.602
30
6046.602
1637.101
994.601
699.602
40
9938.602
2570.102
1456.102
935.101
50
14733.104
3727.603
2074.106
1277.103
Table 9: Results for the MO2N algorithm with different error rates
# robots
Time (error rate
0.9)
Time (error
rate 0.6)
Time (error
rate 0.3)
Time (error
rate 0)
3
85.100
83.100
79.600
79.600
4
175.100
166.101
164.100
164.100
5
223.601
212.100
211.601
209.601
6
294.100
265.600
285.100
264.101
7
390.101
381.103
355.601
355.600
8
453.601
429.101
426.100
290.101
9
601.100
588.100
570.100
568.600
10
625.601
596.101
592.601
590.101
20
1310.621
1266.108
1259.127
1257.649
30
1668.641
1547.633
1537.150
1529.147
40
1939.602
1830.603
1827.102
1815.150
50
2751.103
2641.103
2619.617
2611.603
Table 10: Results for the MTTIS algorithm with different error rates
30
Figure 13: MTTIS algorithm with up to 10 robots and variable error rates
4.5 Distance
Figure 14: Comparison between MO2N with a distance of 500 units and the
expected results with a distance of 250 units
In figure 14 we can see the results of running the M2ON algorithm with a
distance of 500 and the extrapolated results from running the same algorithm
with a distance of 250, multiplied by 2. We can observe that the results are not
linear, estimation of how the algorithm will perform can not be done directly,
further work needs to be done in order to give a meaningful prediction.
4.6 Observations
Variable timesteps present us with a dilemma: up until now, robots only
announced their location to their neighbors once they reached their target
31
position, which made the neighbor robots remain still until the unresponsive
robot (i.e. the one moving) switched back to the communication phase and
announced its position.
With short move phases, as seen in figures 12 and 13, the convergence rate
becomes longer than before. We can observe this behavior with even shorter
move phases (timestep 0.01) in tables 5 and 6, which were omitted in the
figures to avoid distorted results. A short move phase will force robots to switch
to the communication phase more frequently, causing them to focus most on
announcing their positions without barely moving. Though a simple observation,
we have not found any reference to this behavior in the literature.
Therefore, we are presented with a trade-off, as we have previously seen,
extremely long move phases will cause the system to become still waiting for
few robots to reach their target positions.
Nonetheless, any two-phase protocol that comprises a communication and an
action phases, will incur in a similar behavior. We observe that only those move
phases that last between 1 and 10 improve the running time of both MO2N and
MTTIS.
As we have seen, the choice of a threshold value has a noticeable impact on
the performance of the MO2N algorithm. In our tests, we observe as the
number of robots increases, the difference in the performance is more
significant. With 50 robots and using a threshold value of 0.01 as the baseline,
running the experiment with a precision of 0.1 units incurs in an improvement of
178% in the running time, whereas a threshold value of 1 results in a 257%
faster experiment.
However, as we already saw, the choice of a threshold value does not affectthe
tests for either MTTIS and MTTISB. We claim this to be a strength of both
algorithms, we can use the most precise threshold value and it will not have an
impact on the performance of neither algorithms.
32
5. CONCLUSIONS
5.1 Contributions and discussion
We have presented the work of making formations with mobile robots in a onedimensional space. Originally using an algorithm from the agents research and
then applied to mobile robotics field.
We will enumerate the contributions made by the work we have presented:
a) The application of a multi agent algorithm for making formations to robots.
We tested the algorithm proposed by Chandy et al. (2008) in a mobile robotics
scenario, showed its shortcomings and proposed new ways to make the
algorithm implementable.
We also analyzed several properties of the algorithm, not found in the the
original paper. We believe this analysis of the algorithm's properties helps
understand the algorithm with more depth and allowed us to contribute several
improvements.
b) A proposal of improvements to an existing algorithm and two new algorithms
The modifications to the existing algorithm, especially the study of the duration
of the move phase, improve the convergence rate and lower the number of
messages being transmitted.
The two new algorithms introduced in this work, are built upon the existing
algorithm, but solve several aspects, such as monotonicity and termination.
These two algorithms can be deployed in the scenarios where the original
algorithm was suitable, since they both maintain the same properties, while still
benefiting from the new improvements.
c) A framework for testing multi-agent formations
33
Our work includes a test suite of different parameters that affect how algorithms
for making formations behave. The results presented can serve as a baseline
for future improvements and for testing existing algorithms.
5.2 Applicability
The goal of all the algorithms presented here is making formations for mobile
robots where the communication channel may be unreliable. This topic has
many applications in the field of mobile robotics, ranging from home vacuum
robots that need to cover as much space as they can, to humanoid robots that
play in the Robocup league.
5.3 Future work
Though the work presented here is very exhaustive, in which we tested several
scenarios, each with different constraints, it leaves space for future work.
The only formation we considered is such that robots are spread evenly across
a line, we can extend this work to other formations with different shapes
depending on the task we want the robots to accomplish.
Also, more work needs to be done in order to enable drop-in and drop-out
behavior of robots. We only presented algorithms where the number of robots is
fixed.
A point of discussion is whether we can improve the algorithms while
maintaining the same properties. In certain scenarios, the safety property may
need to be relaxed in order to achieve a better convergence rate.
34
REFERENCES
Anderson, B. D., Yu, C., Dasgupta, S., & Summers, T. H. (2010, September).
Controlling four agent formations. In Proceedings of the 2nd IFAC Workshop
on Distributed Estimation and Control in Networked Systems. Annecy,
France.
Chandy, K. M., Mitra, S., & Pilotto, C. (2008). Convergence verification: From
shared memory to partially synchronous systems. In Formal Modeling and
Analysis of Timed Systems (pp. 218-232). Springer Berlin Heidelberg.
Chandy, K. M., Go, B., Mitra, S., Pilotto, C., & White, J. (2011). Verification of
distributed systems with local–global predicates. Formal aspects of
computing,23(5), 649-679.
Dolev, S., Gilbert, S., Lahiani, L., Lynch, N., & Nolte, T. (2005). Virtual
stationary automata for mobile networks (No. MIT-CSAIL-TR-2005-004).
MASSACHUSETTS INST OF TECH CAMBRIDGE COMPUTER SCIENCE
AND ARTIFICIAL INTELLIGENCE LAB.
Fettig, A., & Lefkowitz, G. (2005). Twisted network programming essentials.
O'Reilly Media, Inc..
Gilbert, S., Lynch, N., Mitra, S., & Nolte, T. (2009). Self-stabilizing robot
formations over unreliable networks. ACM Transactions on Autonomous and
Adaptive Systems (TAAS), 4(3), 17.
Hunter, J. D. (2007). Matplotlib: A 2D graphics environment. Computing in
Science & Engineering, 90-95.
P802.11, IEEE Standard 802.11-2007
Kopetz, H., & Bauer, G. (2003). The time-triggered architecture. Proceedings of
the IEEE, 91(1), 112-126.
Michel, O. (1998). Webots: a powerful realistic mobile robots simulator.
InProceeding of the Second International Workshop on RoboCup.
35
Mondada, F., Bonani, M., Raemy, X., Pugh, J., Cianci, C., Klaptocz, A., ... &
Martinoli, A. (2009, May). The e-puck, a robot designed for education in
engineering. In Proceedings of the 9th conference on autonomous robot
systems and competitions (Vol. 1, No. 1, pp. 59-65).
Nolte, T., & Lynch, N. (2007). Self-stabilization and virtual node layer
emulations. In Stabilization, Safety, and Security of Distributed Systems (pp.
394-408). Springer Berlin Heidelberg.
Oliphant, T. E. (2007). Python for scientific computing. Computing in Science &
Engineering, 9(3), 10-20.
Olson, E., Strom, J., Goeddel, R., Morton, R., Ranganathan, P., & Richardson,
A.
(2013).
Exploration
and
mapping
with
autonomous
robot
teams.Communications of the ACM, 56(3), 62-70.
Schmidt, D. C. (1995). Reactor: An object behavioral pattern for concurrent
event demultiplexing and dispatching.
Schmidt, D. C., Stal, M., Rohnert, H., Buschmann, F., & Wiley, J.
(2000).Pattern-oriented Software Architecture: Patterns for Concurrent and
Networked Objects, Volume 2. Wiley.
Tabuada, P., Pappas, G. J., & Lima, P. (2001). Feasible formations of multiagent systems. In American Control Conference, 2001. Proceedings of the
2001 (Vol. 1, pp. 56-61). IEEE.
Terravion, http://www.terravion.com
36