🔝​

Swarm Robotics Practice - Collective Behaviors

• Swarm Robotics Practice - Collective Behaviors
  • Prerequisites
  • General Motivation
  • Course Content
    • Getting Started
      • 1. Download the laboratory package (All operating systems)
      • 2. Installation instructions by operating system
        • Step 1 — Install Docker Desktop
        • Step 2 — Start the laboratory for the first time
        • Step 3 — Open the Ubuntu desktop
        • Step 4 — Daily usage after the first execution
        • Step 5 — Running experiments
        • Troubleshooting
        • Step 1 — Install Docker
        • Step 2 — Enable Docker permissions
        • Step 3 — Verify the installation
        • Step 4 — Start the laboratory
        • Step 5 — Open the Ubuntu desktop
        • Step 6 — Running experiments
        • Daily usage
        • Troubleshooting
    • Introduction
      • Evaluation
      • Resources
    • Sandbox: The Foot-bot
      • Running the sandbox
    • Random Walk
      • Exercise 1: Obstacle avoidance in a cluttered scenario
      • Exercise 2: Obstacle avoidance in an empty scenario
    • Aggregation
      • Exercise 1: Aggregation in a region of interest
      • Exercise 2: Aggregation as implicit decision making
      • Exercise 3: Enhancing aggregation with taxis behaviors
    • Pattern Formation
      • Exercise 1: Hexagonal pattern formation
      • Exercise 2: Circular pattern formation
      • Exercise 3: Flocking
    • Project: Foraging with Forbidden Areas
      • Problem definition
      • Experiment
  • Contact
  • Credits

Prerequisites

To get the most out of this Swarm Robotics module, it’s helpful to have prior knowdlege on basic mobile robotic systems and to have followed the prior content on Swarm Robotics.

This session requires you to programme control software for robots, therefore, basic programming skills are recommended. The tools required to develop the excercises are introduced in the material: Docker environments, ARGoS simulator, the Lua programming language.

General Motivation

Swarm robotics is the study of how to design large groups of robots that can operate autonomously in a distributed way, and without the intervention of any external infrastructure or any form of centralized control. In a similar fashion as biologist study biological swarms, swarm robotics designers are largely focused on studying behaviors that robot swarms can exhibit.

In these practical sessions we will cover some of these behaviors, focusing mostly on demonstrating how the simple individual actions of each robot in a swarm lead the whole group of robots to act in an intelligent way.

Course Content

Getting Started

1. Download the laboratory package (All operating systems)

You will need approximately 6 GB of free disk space.

Download the laboratory package from the following link:

https://drive.google.com/file/d/1Cw6Fx7HD_i1BM6F-sqIGPoVTNxj-rSY_/view?usp=drive_link

After downloading:

1. Extract the compressed file anywhere on your computer.
2. Once extracted, you should obtain a folder named:

swarm_robotics_lab/

This folder already contains:

• docker-compose.yml
• All course materials
• All practical exercises
• The complete folder structure required for the course

The structure should look similar to this:

swarm_robotics_lab/
├── docker-compose.yml
└── course_materials/
    └── swarm_robotics/
        ├── sandbox/
        ├── obstacle_avoidance/
        ├── aggregation/
        ├── pattern_formation/
        └── foraging/

2. Installation instructions by operating system

cd Desktop\swarm-robotics-lab

docker compose up

ARGoS Swarm Robotics Lab — Ready

http://localhost:6080/vnc.html

Connect

swarmbot

argos-swarm-lab

http://localhost:6080/vnc.html

Open Terminal Here

cd ~/swarm_robotics/sandbox
argos3 -c sandbox.argos

Applications → Settings → Keyboard → Layout

sudo apt update
sudo apt install docker.io docker-compose-plugin

sudo usermod -aG docker $USER

docker --version

docker compose version

docker compose up

ARGoS Swarm Robotics Lab — Ready

http://localhost:6080/vnc.html

Connect

swarmbot

Open Terminal Here

cd ~/swarm_robotics/sandbox
argos3 -c sandbox.argos

docker stop argos-swarm-lab 

docker start -ai argos-swarm-lab 

newgrp docker

docker compose ps

Introduction

During this part of the course: you will use the ARGoS simulator—a multi-robot simulator specialized in swarm robotics; you will simulate swarms of foot-bots—a robot widely used in swarm robotics research; and you will produce control software for the robots by using the LUA programming language.

This part of the course covers three particular cases of swarm robotics behaviors and one project on the topic:

• (P0) Sandbox: the Foot-bot robot
• (P1) Random walk
• (P2) Aggregation
• (P3) Pattern formation
• (P4) Project: Foraging with forbidden areas

In sessions P1 to P3, you will be given with examples of robots exhibiting specifics swarm behaviors. Your task will be to develop the code that produces those behaviors, and experiment with it.

In session P4, you will be given with a mission to be performed with a robot swarm. Your task will be to design the swarm behaviors and develop the code to perform the mission.

The course is planned in a progressive manner—that is, the code that you develop in a practical session might be required in a following one.

Evaluation

The swarm robotics part of the course will be evaluated with the project that you will develop in the session P4.

Resources

In this section, you find the resources you will mostly use during this part of the course: an overview the foot-bot robot and the functions to interact with it in ARGoS, the definition of the most used mathematical functions in LUA, and a description of the ARGoS interface.

robot.wheels.set_velocity(5,5)

r = robot.proximity[4].value

robot.proximity[4].angle = 1.67

myprox = table.copy(robot.proximity)
table.sort(myprox, function(a,b) return a.value < b.value end)

robot.wheels.set_velocity(5,5)

robot.proximity[1].angle
robot.proximity[1].value

robot.light[1].angle
robot.light[1].value

robot.motor_ground[1].value
robot.motor_ground[1].offset

robot.range_and_bearing.set_data(1,1)

#robot.range_and_bearing
robot.range_and_bearing[1].data[1]
robot.range_and_bearing[1].range
robot.range_and_bearing[1].horizontal_bearing

robot.range_and_bearing.clear_data()

robot.leds.set_single_color(1, "red")

robot.leds.set_all_colors("red")

robot.colored_blob_omnidirectional_camera.enable()

robot.colored_blob_omnidirectional_camera[1].color.red
robot.colored_blob_omnidirectional_camera[1].distance
robot.colored_blob_omnidirectional_camera[1].angle

-- This is a single-line comment

--[[ This is a multi-line
     comment ]]

x = 2.55   -- number
x = "ciao" -- string

log("INFO: x = " .. x)     -- print to ARGoS logger
logerr("ERROR: x = " .. x)

if x > 3 then
   logerr("x is too big")
elseif x < 3 then
   logerr("x is too small")
else
   logerr("maybe I just don't like x")
end

if x == 3  then log("equal to 3") end   -- equality
if x ~= 4  then log("not 4")      end   -- inequality
if (x > 3) or  (x < 3) then ... end     -- OR
if (x > 3) and (y > 3) then ... end     -- AND
if not (x > 3) then ... end             -- negation

-- while
x = 0
while x < 5 do x = x + 1; log(x) end

-- repeat until
x = 0
repeat x = x + 1; log(x) until x == 5

-- for (init, end, step)
for x = 1, 5     do log(x) end   -- 1 2 3 4 5
for x = 1, 5, 2  do log(x) end   -- 1 3 5
for x = 5, 1, -1 do log(x) end   -- 5 4 3 2 1

t = {}            -- empty table
t = { x=3 }       -- table with initial value
log(t.x)          -- dot syntax
log(t["x"])       -- string syntax

-- Tables are passed by reference; copy with:
function table.copy(t)
   local t2 = {}
   for key,value in pairs(t) do t2[key] = value end
   return t2
end

-- Tables as arrays
a = { "Huey", "Dewey", "Louie" }
log(a[1])   -- "Huey"
log(#a)     -- 3

-- Sorting
table.sort(a)
table.sort(t, function(a,b) return a.x < b.x end)

function my_fun(p)
   log("Called my_fun(" .. p .. ")")
end

function my_add(a, b)
   return a + b
end

function vec2_new_polar(length, angle)
   return { x = length * math.cos(angle),
            y = length * math.sin(angle) }
end

function vec2_sum(v1, v2)
   v1.x = v1.x + v2.x
   v1.y = v1.y + v2.y
end

function vec2_angle(v)
   return math.atan2(v.y, v.x)
end

argos3 -c myfile.argos

<footbot_proximity implementation="default" show_rays="true" />

Sandbox: The Foot-bot

In this short sandbox you will experiment with the foot-bot, the robot you will use during the practical lessons of the swarm robotics part of the course. To do so, you will test the functionalities, sensors and actuators of the robot by writing short pieces of code that will be executed in the ARGoS simulator. The control software that you will produce during this practical session might result useful in later exercises.

Objective

The objective of this practical session is to explore the functionalities of the foot-bot and familiarize with its set of sensors and actuators.

General remarks

Instructions about how to use ARGoS are provided in the section ARGoS. The control software of the robot will be produced in Lua; if you are not familiar with this programming language, a miniguide is provided in section Lua. A comprehensive list of sensors, actuators and functionalities of the robot is provided in the section the foot-bot.

The control software of the robots is executed in the form of time steps—that is, the script is executed in the simulator once for each time step. In this experiment, the time step has a length of 100ms. In other words, each of the actions defined in the Lua script will be executed 10 times per second.

Running the sandbox

In this exercise, you will be guided step by step to experiment with the foot-bot. No control software or pseudocode is provided directly. Your task is to search in the section the foot-bot for the appropriate functions that will allow you to perform different specific tasks with the robot, and later, implement them in the simulation.

Launching the experiment

1 - Enter the directory that contains the materials for this practical session.

cd ~/swarm_robotics/sandbox/

2 - Run the ARGoS simulation.

argos3 -c sandbox.argos

Experimental setup

At the beginning of the experiment, a foot-bots is randomly placed in a squared bounded arena.

Random Walk

Random walk can be defined as the behavior in which a robot moves without aiming a particular trajectory. In most random walk methods, changes in the direction of movement of the robots occur when they interact with other robots or objects in the environment. The selection of a direction of movement can follow deterministic or stochastic rules. In many cases, robots also embed obstacle avoidance behaviors to safely navigate in the environment.

Objective

The objective of this practical session is to design the control software for a robot swarm in which the individual robots randomly walk in an enclosed environment without colliding with objects, walls or other robots. The swarm, as a whole, must move in the environment evenly—that is, it must cover all the spaces.

General remarks

The control software of the robots is executed in the form of time steps—that is, the script is executed in the simulator once for each time step. In this experiment, the time step has a length of 100ms. In other words, each of the actions defined in the Lua script will be executed 10 times per second.

Remember that the individual actions of each robot are the ones that lead the robot swarm to achieve the desired behavior.

Exercise 1: Obstacle avoidance in a cluttered scenario

In this exercise, you will design random walk and obstacle avoidance behaviors that allow a swarm of foot-bots to safely navigate in an environment cluttered with obstacles.

Launching the experiment

1 - Enter the directory that contains the materials for this practical session.

cd ~/swarm_robotics/obstacle_avoidance/

2 - Run the ARGoS simulation.

argos3 -c obstacle_avoidance_scatter.argos

Experimental setup

At the beginning of the experiment, a swarm of foot-bots is randomly distributed in a squared bounded arena that contains boxes that obstruct the movement of the robots. During the execution of the experiment, the robots must navigate through the arena avoiding possible collisions with the boxes and with other robots. The experiment will end when the robots can effectively navigate in the arena without colliding.

Ballistic motion with in-place rotation

An easy implementation of random walk is the that follows the principles of ballistic motion: a robot moves straight to the front until it faces an obstacle, when an obstacle is detected, the robot changes its trajectory. This random walk method can embed in-place rotations as an strategy for obstacle avoidance. In other words, when a robot faces an obstacle it simply rotates a random number of time steps, or alternatively, until it stops perceiving the obstacle on its direction of movement.

1 - Check if there is an obstacle in front of the robot

for each sensor i in proximity sensors at front
do
  if reading[i] == obstacle
  then
    obstacle_in_front = true
  end
end

2 - If there is an obstacle in front, perform obstacle avoidance

if obstacle_in_front and not rotating
then
  StartRotating(n_timesteps)
end
elseif obstacle in front and n_timesteps != 0
  KeepRotating()
  n_timesteps -= 1
end
else
  StopRotating()
if

3 - Set robot velocity

if rotating
then
  SetRotationVelocity()
end
else
  SetFordwardVelocity()
end

Exercise 2: Obstacle avoidance in an empty scenario

In this exercise, you will test your random walk implementation in a clear environment, and afterwards you will implement a new obstacle avoidance strategy based on repulsion forces.

Launching the experiment

1 - Enter the directory that contains the materials for this practical session.

cd ~/swarm_robotics/obstacle_avoidance/

2 - Run the ARGoS simulation.

argos3 -c obstacle_avoidance_empty.argos

Preliminary test

Test first the control software you developed in Exercise 1. Do the robots show an smooth movement? Do they uniformly cover the whole arena?

Experimental setup

At the beginning of the experiment, a swarm of foot-bots is randomly distributed in a squared bounded arena that contains no obstacles. During the execution of the experiment, the robots must navigate the arena avoiding collisions, and in such a way that they uniformly cover space. The experiment will end when the robots can effectively navigate in the arena without colliding.

Ballistic motion with repulsion forces

An more complex, and yet, more effective obstacle avoidance strategy follows the principle of vector fields and repulsion forces. A robot is subject to virtual repulsion forces that are originated by the obstacles that a robot can encounter, and hence, it moves in such a way that avoids colliding with them.

The repulsion force is a unique vector that aggregates the effect of one or many objects around the robot. When a robot perceives a repulsion force, it turns its movement in the opposite direction—i.e., if the vector points to the left, the robot turns to the right and vice versa. The closer the obstacle to the front direction of the robot, the quicker the turn.

1 - Aggregate all proximity readings in a repulsion vector

for each sensor i in proximity sensors
do
  Set a 2D vector vec[i] according to {reading_i, angle_i}
  rep_force += vec[i]
end

2 - If there is an obstacle close to the robot, perform obstacle avoidance

rep_length = GetLength(rep_force)
rep_angle  = GetAngle(rep_force)
if rep_length > 0.2
then
  if rep_angle >= 0
  then
    rotate_to_right = true
  else
    rotate_to_left = true
  end
else
  rotate_to_right = false
  rotate_to_left  = false
end

3 - Set robot velocity

if rotate_to_right
then
  SetRotateToRightVelocity()
elseif rotate_to_left
  SetRotateToLeftVelocity()
else
  SetFordwardVelocity()
end

Aggregation

Aggregation is a group behavior in which the individuals approach to each other and form clusters. In nature, for example, bees aggregate in the hive and school of fish remain together in single clusters. In swarm robotics, aggregation behaviors are widely study as they determine the ability of the robots to remain together as a group. Robots can aggregate either because they perceive a region of interest to aggregate in the environment—like the bees aggregate in the hive, or because they sense other robots that are already forming a cluster—like the school of fish.

Objective

The objective of this practical session is to design the control software for a robot swarm that aggregates in a specific region of the environment.

Designing the Control software

The control software of the robots is executed in the form of time steps—that is, the script is executed in the simulator once for each time step. In this experiment, the time step has a length of 100ms. In other words, each of the actions defined in the Lua script will be executed 10 times per second.

It is expected that you use the control software produced in practical session Random Walk to allow the robots move in the environment without colliding with the walls and other robots.

Remember that the individual actions of each robot are the ones that lead the robot swarm to achieve the desired behavior.

General remarks

The control software of the robots is executed in the form of time steps—that is, the script is executed in the simulator once for each time step. In this experiment, the time step has a length of 100ms. In other words, each of the actions defined in the Lua script will be executed 10 times per second.

It is expected that you use the control software produced in practical session Random Walk to allow the robots move in the environment without colliding with the walls and other robots.

Remember that the individual actions of each robot are the ones that lead the robot swarm to achieve the desired behavior.

Exercise 1: Aggregation in a region of interest

In this exercise, you will design an aggregation behavior that drives a swarm to cluster within a specific region of the environment.

Launching the experiment

1 - Enter the directory that contains the materials for this practical session.

cd ~/swarm_robotics/aggregation/

2 - Run the ARGoS simulation.

argos3 -c aggregation_one_spot.argos

Experimental setup

At the beginning of the experiment, a swarm of foot-bots is randomly distributed in a squared bounded arena with white floor. In the center of the arena, there is a black spot that indicates the region of interest on which the robots must aggregate. During the execution of the experiment, all the robots must step into the black spot. The experiment will end when all the robots are inside of the black spot.

Individualistic aggregation

In an individualistic strategy, robots randomly walk in the arena looking for the black spot. Once a robot detects the spot, it stops moving and waits for other robots to arrive. Eventually, all robots in the swarm will find and enter the spot and the swarm will be aggregated inside.

1 - Check the color of the ground

for each sensor i in ground sensors
do
  if reading[i] == black
  then
    in_spot = true
  end
end

2 - Set robot velocity

if in_spot
then
  SetStopVelocity()
else
  SetRandomWalk()
end

Exercise 2: Aggregation as implicit decision making

In this exercise, you will design a robot swarm that autonomously decides to aggregate in one out of two regions of interest.

Launching the experiment

1 - Enter the directory that contains the materials for this practical session.

cd ~/swarm_robotics/aggregation/

2 - Run the ARGoS simulation.

argos3 -c aggregation_two_spot.argos

Preliminary test

Test first the control software you developed in Exercise 1. Do the robots aggregate in a single spot? If not, what prevent them to reach a consensus on which spot they should aggregate?

Experimental setup

At the beginning of the experiment, a swarm of foot-bots is randomly distributed in a squared bounded arena with white floor. In the arena, there are two black spots that indicate two possible regions of interest on which the robots must aggregate. During the execution of the experiment, the robots must aggregate in one out of the two spots. The experiment will end when at least 70% of the robots are aggregated in a single spot.

Implicit communication

A first form of communication in swarm robotics is the one defined as implicit communication. In this form of communication, robots pass information to their peers without establishing a defined communication channel or message. For example, a robot can change its behavior in regard to the nearby presence, or absence, of other robots. In this sense, robots communicate by relatively positioning themselves with respect to other robots.

This form of communication is particularly relevant to the case in which swarms must aggregate in one out of two possible options. After finding the aggregation spot, a robot can decide whether to stay on it, or leave it, after considering the number of peers it can perceive. If the robot can perceive a large number of peers, it is likely that it is in a large cluster and it will aim to remain there. On the contrary, it the robot perceives just a few peers, its likely that it is not in a cluster and it will leave the spot to find a better aggregation place.

1 - Check the color of the ground

2 - If the robot is in the spot, set an arbitrary signal that other robots can see and wait an arbitrary time for other robots to arrive

3 - Count the number of nearby robots and decide whether to stay or leave

for each robot i seen at range[i]
do
  if range[i] < nearby_range
    n_robots += 1
  end
end

leave = EvaluateLeavingCondition(n_robots)

4 - Set robot velocity

if leave
then
  SetRandomWalk()
  StopSignalEmition()
else
  SetStopVelocity()
end

Exercise 3: Enhancing aggregation with taxis behaviors

In this exercise, you will use taxis behaviors to improve the performance of a robot swarm that autonomously decides to aggregate in one out of two regions of interest.

Launching the experiment

1 - Enter the directory that contains the materials for this practical session.

cd ~/swarm_robotics/aggregation/

2 - Run the ARGoS simulation.

argos3 -c aggregation_two_spot.argos

Experimental setup

At the beginning of the experiment, a swarm of foot-bots is randomly distributed in a squared bounded arena with white floor. In the arena, there are two black spots that indicate two possible regions of interest on which the robots must aggregate. During the execution of the experiment, the robots must aggregate in one out of the two spots. The experiment will end when at least 70% of the robots are aggregated in a single spot.

Taxis behaviors

Taxis can be defined as a form of movement behavior in which individuals move towards or away from a stimulus. For example, the movement towards and away from light sources is defined as phototaxis, and if the stimulus corresponds to chemical components, the behavior is defined as chemotaxis.

Taxis behaviors are widely used in swarm robotics. Robots often change their movement behavior in regard to stimuli produced by other robots, or by the environment itself. In the particular case of aggregation, robots can use taxis to facilitate the formation of clusters of robots. A group of robots that already started aggregating can emit a signal that aims to attract nearby robots, and in consequence, the swarm is likely to aggregate faster.

1 - Count the number of nearby robots

2 - If enough robots are emitting the signal, build a 2D attraction vector

for each robot i seen at {range_i, bearing_i}
do
  Set a 2D vector vec[i] according to {range_i, bearing_i}
  att_vector += vec[i]
end

3 - Compute the direction of movement

att_angle = GetAngle(att_vector)

if att_angle > 0
then
  rotate_to_left = true
elseif att_angle < 0
  rotate_to_right = true
else
  move_forward = true
end

4 - Set robot velocity

if not obstacle_in_front
  if rotate_to_right
  then
    set_velocity(math.max(0.5,math.cos(att_angle)) * 10, 0)
  elseif rotate_to_left
    set_velocity(0, math.max(0.5,math.cos(att_angle)) * 10)
  else
    SetFordwardVelocity()
  end
else
  ObstacleAvoidance()
end

Pattern Formation

A pattern is an arrangement of objects displaying mathematical, geometric or statistic relationships (e.g., atoms organized in molecules, and molecules that in a big scale can form crystals). In swarm robotics, robots can form patterns by strategically positioning themselves in regard to the position of other robots they perceive. By following simple positioning rules at the individual level, a robot swarm can distributed itself in the form of organized structures.

Robot pattern formation is useful to perform tasks such as uniformly covering a region of interest, establishing specific lattice or network topologies, and performing collective motion (known as flocking in the context of swarm robotics).

Objective

The objective of this practical session is to design the control software for a robot swarm that exhibits pattern formation and flocking behaviors.

General remarks

The control software of the robots is executed in the form of time steps—that is, the script is executed in the simulator once for each time step. In this experiment, the time step has a length of 100ms. In other words, each of the actions defined in the Lua script will be executed 10 times per second.

It is expected that you use the control software produced in practical session Aggregation to allow the robots to detect and localize their peers.

Remember that the individual actions of each robot are the ones that lead the robot swarm to achieve the desired behavior.

Exercise 1: Hexagonal pattern formation

In this exercise, you will use the notion of artificial potential fields to form hexagonal patterns with a swarm of foot-bots.

Launching the experiment

1 - Enter the directory that contains the materials for this practical session.

cd ~/swarm_robotics/pattern_formation/

2 - Run the ARGoS simulation.

argos3 -c pattern_formation.argos

Experimental setup

At the beginning of the experiment, a swarm of foot-bots is randomly distributed in a rectangular bounded arena. During the execution of the experiment, the robots must position themselves so that the inner structure of the swarm can be appreciated as an hexagonal lattice. The experiment will end when all robots are formed and the lattice remains stable.

Artificial potential fields

Artificial potential fields are computing models that emulate the effects of physical potential fields such as electrical, magnetic or gravitational fields. In robotics, artificial potential fields can be used to model virtual forces to which a robot is subject. This forces can represent attraction or repulsion behaviors that lead the robot motion; for example, they can be computed in regard to the position of other robots or objects in the environment.

In swarm robotics, researchers have widely used the Lennard-Jones potential to create virtual forces that enable the formation of patterns with robot swarms. A robot is subject to virtual attraction and repulsion forces that aim to maintain a target distance with respect to nearby robots. The robot is attracted to robots that are farther than the target distance, and on the contrary, it is repealed from robots that are closer. A stable state will be reached when the robot finds a position in which it maintains the target distance with respect to all its nearby peers.

The image below represents the Lennard-Jones potential and indicates the distribution of the forces with respect to the target distance.

In the graph above, delta is the target distance to be maintained, rho is the distance measured against the position of other robot, and epsilon indicates the strength of the interaction.

The potential is described by the expression,

The corresponding forces can be obtained after applying the firs derivative,

1 - Compute the force due to Lennard-Jones potential

for each robot i seen at {range_i, bearing_i}
do
  ln_value = ComputeLennardJones(range_i)
  Set a 2D vector vec[i] according to {ln_value, bearing_i}
  ln_force += vec[i]
end

2 - Compute the direction of movement

mov_dir = GetAngle(ln_force)

3 - Set the robot velocity

Velocity{l,r} = ComputeSpeedFromAngle(mov_dir)

The function ComputeSpeedFromAngle() is provided and described in the starting script.

Exercise 2: Circular pattern formation

In this exercise, you will combine virtual forces originated by inter-robot interaction with a virtual force originated by an object of the environment.

Launching the experiment

1 - Enter the directory that contains the materials for this practical session.

cd ~/swarm_robotics/pattern_formation/

2 - Run the ARGoS simulation.

argos3 -c pattern_formation.argos

Experimental setup

At the beginning of the experiment, a swarm of foot-bots is randomly distributed in a rectangular bounded arena that contains one small red LED. During the execution of the experiment, the robots must position themselves so that the robot swarm forms a circular pattern around the red LED. The experiment will end when all robots are formed and the lattice remains stable.

1 - Compute the force due to Lennard-Jones potential

2 - Compute the attractive force towards the LED at {range_led, bearing_led}

Set a 2D vector vec_led according to {range_led, bearing_led}
led_force = vec_led

3 - Aggregate the forces

sum_force = ln_force + led_force

4 - Compute the direction of movement

mov_dir = GetAngle(sum_force)

5 - Set the robot velocity

Exercise 3: Flocking

In this exercise, you will create a swarm that flocks—that is, a swarm that moves while forming a pattern.

Launching the experiment

1 - Enter the directory that contains the materials for this practical session.

cd ~/swarm_robotics/pattern_formation/

2 - Run the ARGoS simulation.

argos3 -c pattern_formation.argos

Experimental setup

At the beginning of the experiment, a swarm of foot-bots is randomly distributed in a rectangular bounded arena that contains one small red LED and one ambiance light source. During the execution of the experiment, the robots must position themselves so that the inner structure of the swarm can be appreciated as an hexagonal lattice. The experiment will end when all robots are formed and the lattice remains stable.

1 - Compute the force due to Lennard-Jones potential (see Exercise 1)

2 - Compute the attractive force towards the ambiance light source at {range_light, bearing_light}

{range_light, bearing_light} = ComputeVectorToLight()
Set a 2D vector vec_light according to {range_light, bearing_light}
light_force = vec_light

3 - Aggregate the forces

sum_force = ln_force + light_force

4 - Compute the direction of movement

mov_dir = GetAngle(sum_force)

5 - Set the robot velocity

Project: Foraging with Forbidden Areas

The activity of food search and retrieval is commonly referred to as foraging. In swarm robotics, foraging is a commonly used task to compare different algorithms for exploration (what is the best way to discover interesting places in the environment?), division of labor (who should explore? for how long?), etc.

In the most general setting, food items are scattered in an environment at locations unknown to the robots and the robots need to explore the environment, find the food, and take it to the nest. The foraging environments often contain cues, such as light sources, that help the robots in navigating through the environment.

In this project, we consider a foraging environment with a forbidden area: robots than enter this area automatically lose the item that they carry, if any. The swarm is distributed in the arena and the location of the food source is originally unknown to the robots. The swarm can act cooperatively to discover and keep track of the location of the food source for an efficient foraging, and in the same way, to avoid the forbidden area.

In this practical session, you are asked to develop and provide control software for the robot swarm, and to evaluate its performance.

Problem definition

The robot swarm operates in a diamond-shaped arena that includes a food source, a nest, and one forbidden area. The food source is represented by a black circle, the nest is represented by a white area in the bottom the diamond, and the forbidden area is a gray rectangle—see figure below. A light is placed on top of the food source to indicate its position to the robots. When a robot enters the forbidden area while carrying an item, the item is automatically lost.

Goal

The goal of the robot swarm is to retrieve and transport items from the food source to the nest. The overall performance of the swarm is measured by the number of items it is able to collect during a fixed experiment time. Each experiment is automatically terminated after 1000 seconds (10000 time-steps). More precisely, the performance of the swarm is described by

Max N_d

with N_d being the number of items successfully delivered to the nest (that is, items carried by robots from the food source to the nest without entering the forbidden area).

Swarm composition

The swarm comprises 30 homogeneous robots. The robots are equipped with the following sensors and actuators:

colored_blob_omnidirectional_camera
range_and_bearing
light
motor_ground
proximity
wheels
leds

General remarks

1 - The maximal wheel velocity should not exceed 30 cm/s.

2 - ARGoS has been configured so that the robots collect items on the food source and drop them at the nest and at the forbidden area automatically. A robot can only carry one item at a time.

3 - The positions of the nest and the forbidden area is fixed, but the position of the food source can change from one experiment to another. The nest corresponds to the white area, the food source is the black spot, and the forbidden area is indicated dark shade of gray. See the figure below (top view of the arena).

Experiment

The goal of this project is to design, implement and evaluate control software that aims to maximize the number of items delivered at the nest. It is expected that the control software demonstrates a cooperative behavior: one that takes advantage of the swarm’s principles.

ARGoS is configured to automatically dump data on a file output.txt. This file contains a table with two columns:

- CLOCK: Column indicating the current step
- ITEMS: Column indicating the number of items collected so far

Run the experiment

cd ~/swarm_robotics/foraging/
argos3 -c foraging.argos

If the usual ARGoS interface appears, you’re ready to go.

Contact

Like robot swarms, the swarm robotics community thrives through collaboration. If you would like to contribute to this page, please do not hesitate to get in touch.

David Garzón Ramos
University College Dublin
[email protected]

Feedback, erratas, bug reports, corrections, clarifications, extensions, and new content are all welcomed!

Credits

This course page was created by David Garzón Ramos, LIMAR, University College Dublin (UCD), and funded by IEEE RAS and a UCD Ad Astra Fellowship. The preparation of the material was assisted by Juan B. Medina, PhD student at University College Dublin.

Section 10.1 Swarm Robotics is based on ideas and reserch developed by David Garzón Ramos in collaboration with researchers at IRIDIA, the Artificial Intelligence Laboratory of Université libre de Bruxelles (ULB), and the Bristol Robotics Laboratory, University of Bristol.

Section 10.2 Practice on Collective Behaviors builds on the ideas an excercises developed by Marco Dorigo and Mauro Birattari in the Swarm Intelligence course of IRIDIA at ULB. The original implementation of this excercises is credited to Carlo Pinciroli, Head of NEST Lab, Worcester Polytechnic Institute.

Section 10.3 Practice on Modular Design builds on the ideas an excercises developed by David Garzón Ramos and Mauro Birattari for AutoMoDe TuttiFrutti and Mandarina, with an interface designed by Jonas Kuckling, University of Konstanz.