Collision avoidance in swarms in Drone Programming - Mini Project: Build & Apply

Collision avoidance in swarms

📖 Scenario: You are programming a group of drones flying together in a swarm. To keep them safe, each drone must avoid getting too close to others. You will write a simple program to check the distances between drones and mark which ones need to move away to avoid collisions.

🎯 Goal: Build a program that stores drone positions, sets a safe distance threshold, checks which drones are too close to each other, and prints a list of drones that must move to avoid collisions.

📋 What You'll Learn

Create a dictionary with drone names as keys and their (x, y) positions as values

Create a variable for the safe distance threshold

Use a loop to compare each drone's position with others to find pairs too close

Print the list of drones that need to move to avoid collisions

💡 Why This Matters

🌍 Real World

Collision avoidance is critical for drone swarms used in delivery, search and rescue, and aerial photography to prevent crashes and ensure smooth operation.

💼 Career

Understanding how to program collision avoidance helps in roles like drone software developer, robotics engineer, and autonomous systems programmer.

1

DATA SETUP: Create drone positions dictionary

Create a dictionary called drones with these exact entries: 'DroneA': (0, 0), 'DroneB': (3, 4), 'DroneC': (5, 1), 'DroneD': (8, 8)

Drone Programming

# Create the drones dictionary with positions
# Your code here

Hint

Use a dictionary with drone names as keys and tuples for positions.

2

CONFIGURATION: Set safe distance threshold

Create a variable called safe_distance and set it to 5

Drone Programming

drones = {'DroneA': (0, 0), 'DroneB': (3, 4), 'DroneC': (5, 1), 'DroneD': (8, 8)}
# Set the safe distance threshold
# Your code here

Hint

Use a simple number variable for the safe distance.

3

CORE LOGIC: Find drones too close to each other

Create a list called to_move. Use a nested for loop with variables drone1, pos1 and drone2, pos2 to compare each drone's position with others. Calculate the distance using the formula distance = ((pos1[0] - pos2[0])**2 + (pos1[1] - pos2[1])**2)**0.5. If the distance is less than safe_distance and the drones are different, add drone1 to to_move if not already in it.

Drone Programming

drones = {'DroneA': (0, 0), 'DroneB': (3, 4), 'DroneC': (5, 1), 'DroneD': (8, 8)}
safe_distance = 5
# Find drones too close to each other
# Your code here

Hint

Use two loops to compare each drone with every other drone. Calculate distance with the Pythagorean formula.

4

OUTPUT: Print drones that need to move

Write a print statement to display the list to_move

Drone Programming

drones = {'DroneA': (0, 0), 'DroneB': (3, 4), 'DroneC': (5, 1), 'DroneD': (8, 8)}
safe_distance = 5
to_move = []
for drone1, pos1 in drones.items():
    for drone2, pos2 in drones.items():
        if drone1 != drone2:
            distance = ((pos1[0] - pos2[0])**2 + (pos1[1] - pos2[1])**2)**0.5
            if distance < safe_distance and drone1 not in to_move:
                to_move.append(drone1)
# Print the list of drones that need to move
# Your code here

Hint

Use print(to_move) to show the drones that must move.

Practice

1. What is the main purpose of collision avoidance in drone swarms?

easy

A. To improve camera quality

B. To increase drone speed

C. To reduce battery usage

D. To keep drones from crashing into each other

Solution

1. Step 1: Understand collision avoidance goal

   Collision avoidance is designed to prevent drones from hitting each other.

2. Step 2: Compare options with goal

   Only To keep drones from crashing into each other matches the goal of preventing crashes.

3. Final Answer:

   To keep drones from crashing into each other -> Option D

4. Quick Check:

   Collision avoidance = prevent crashes [OK]

Hint: Collision avoidance means no crashes between drones [OK]

Common Mistakes:

• Confusing collision avoidance with speed control
• Thinking it saves battery directly
• Assuming it improves camera quality

2. Which of the following code snippets correctly checks if two drones are too close (distance less than 5 units)?

easy

A. if distance == 5:

B. if distance > 5:

C. if distance < 5:

D. if distance <= 5:

Solution

1. Step 1: Understand the condition for 'too close'

   'Too close' means distance is less than 5 units.

2. Step 2: Match condition with code

   Only 'if distance < 5:' correctly checks if distance is less than 5.

3. Final Answer:

   if distance < 5: -> Option C

4. Quick Check:

   Less than 5 means too close [OK]

Hint: Use '<' to check if distance is less than threshold [OK]

Common Mistakes:

• Using '>' instead of '<'
• Using '==' which checks exact distance
• Using '<=' which includes equal distance

3. What will be the output of this code snippet?

positions = [(0,0), (3,4), (10,10)]
threshold = 5
close_pairs = []
for i in range(len(positions)):
    for j in range(i+1, len(positions)):
        dx = positions[i][0] - positions[j][0]
        dy = positions[i][1] - positions[j][1]
        distance = (dx**2 + dy**2)**0.5
        if distance < threshold:
            close_pairs.append((i, j))
print(close_pairs)

medium

A. [(1, 2)]

B. []

C. [(0, 2)]

D. [(0, 1)]

Solution

1. Step 1: Calculate distances between pairs

   Distance between (0,0) and (3,4) is 5; between (0,0) and (10,10) is about 14.14; between (3,4) and (10,10) is about 9.22.

2. Step 2: Check which distances are less than threshold 5

   Only distance between (0,0) and (3,4) equals 5, but condition is distance < 5, so no pairs qualify except if distance is exactly 5 is excluded.

3. Step 3: Re-examine condition and output

   Since distance == 5 is not < 5, no pairs added. So output is empty list [].

4. Final Answer:

   [] -> Option B

5. Quick Check:

   Distance less than 5 pairs = [] [OK]

Hint: Calculate distances carefully and compare with threshold [OK]

Common Mistakes:

• Including pairs with distance equal to threshold
• Miscomputing distance formula
• Ignoring order of pairs

4. Identify the error in this collision avoidance code snippet:

for drone1 in swarm:
    for drone2 in swarm:
        if drone1 != drone2:
            dist = calculate_distance(drone1.position, drone2.position)
            if dist < safe_distance:
                drone1.move_away(drone2.position)

medium

A. It may cause multiple moves for one drone in one cycle

B. It compares the same drone with itself

C. It uses wrong distance calculation function

D. It does not check battery level before moving

Solution

1. Step 1: Analyze nested loops and conditions

   Each drone compares with every other drone, excluding itself.

2. Step 2: Consider move_away calls per cycle

   If multiple drones are too close, drone1 may call move_away multiple times in one loop, causing erratic movement.

3. Final Answer:

   It may cause multiple moves for one drone in one cycle -> Option A

4. Quick Check:

   Multiple moves per cycle = problem [OK]

Hint: Check if drone moves multiple times per loop [OK]

Common Mistakes:

• Thinking comparing drone with itself is allowed
• Assuming distance function is wrong without evidence
• Ignoring battery checks which are unrelated here

5. You want to improve collision avoidance in a large drone swarm by reducing unnecessary moves. Which approach is best?

hard

A. Only move drones when the closest neighbor is within a smaller threshold

B. Make every drone move away from all neighbors every cycle

C. Ignore collision avoidance for drones with full battery

D. Increase drone speed to quickly pass neighbors

Solution

1. Step 1: Understand problem of unnecessary moves

   Moving drones too often wastes energy and causes instability.

2. Step 2: Evaluate options for reducing moves

   Only move drones when the closest neighbor is within a smaller threshold reduces moves by only reacting to closest neighbors within a smaller safe distance, minimizing unnecessary moves.

3. Step 3: Reject other options

   Make every drone move away from all neighbors every cycle causes many moves; C ignores safety; D risks collisions by speeding up.

4. Final Answer:

   Only move drones when the closest neighbor is within a smaller threshold -> Option A

5. Quick Check:

   Reduce moves by tighter threshold [OK]

Hint: React only to closest neighbors within tight distance [OK]

Common Mistakes:

• Making drones move too often
• Ignoring safety for battery status
• Increasing speed without safety checks