High School Project

Welcome to the “Future Innovators: Cool STEM Projects to Change the World” series! Today’s project will guide you through building a Drone Delivery System simulation—a high-tech concept that’s shaping the future of logistics, from package delivery to emergency medical supply drops. While companies like Amazon are working on similar ideas, you’ll learn the basics of drone programming and simulation right here!

By the end of this project, you’ll have built a drone delivery simulation that mimics real-world applications, such as navigating to deliver a package. Whether you’re just getting into programming or already have experience, this project offers both beginner and advanced challenges, allowing you to customize the simulation to your liking.

What You Will Learn

  • The basic principles of drone technology and how drones are programmed to perform tasks.
  • How to use Python and Pygame to simulate drone movements in a virtual environment.
  • How to write code to control a drone’s navigation from one point to another.
  • How to integrate real-world data like GPS coordinates for delivery points.
  • Advanced options for integrating Raspberry Pi to control real drones using the DroneKit library.

STEM Learning Process

1. Science: Learn how drones use physics and sensors like GPS to navigate through the air.
2. Technology: Explore drone simulation using Python and create interactive software.
3. Engineering: Build a virtual drone delivery system with customizable paths, obstacles, and delivery points.
4. Math: Apply concepts like vector math to calculate paths, distances, and delivery routes.

What You Need

Software:

  1. Python 3.x: If you don’t already have it, download and install Python from python.org.
  2. Pygame: A library used for creating games and simulations in Python. Install it via pip:
Python
   pip install pygame
  1. (Optional) DroneKit-Python: For those who want to take the simulation into real-world drone control. We’ll cover both virtual and physical drone systems.
Python
   pip install dronekit

Hardware (Optional):

  • A Raspberry Pi (if you want to control a real drone).
  • A drone compatible with DroneKit (e.g., 3DR Solo).

Step-by-Step Guide: Drone Delivery Simulation

We’ll start by building a virtual drone simulation using Pygame, where a drone navigates through a simple 2D world to deliver packages. The simulation will allow you to control the drone, avoid obstacles, and make deliveries to predefined locations.

Step 1: Set Up the Project Folder

Create a folder for your project called DroneDeliverySystem. Inside, create three files:

  1. main.py – The main Python file to run your simulation.
  2. drone.py – A Python file for drone logic.
  3. obstacles.py – A Python file to manage obstacles.

Step 2: Define the Drone’s Environment

Open main.py and start by setting up the Pygame window, which will act as the drone’s environment.

Python
import pygame
from drone import Drone
from obstacles import Obstacle

# Initialize Pygame
pygame.init()

# Set up the window
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Drone Delivery System")

# Set up the clock for frame rate
clock = pygame.time.Clock()

# Set up the drone and obstacle
drone = Drone(WIDTH // 2, HEIGHT // 2)
obstacle = Obstacle(300, 200, 200, 20)

# Main loop
running = True
while running:
    screen.fill((0, 0, 0))  # Clear the screen

    # Event handling
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Draw the drone and obstacle
    drone.update()
    drone.draw(screen)
    obstacle.draw(screen)

    pygame.display.flip()  # Update the display
    clock.tick(60)  # 60 frames per second

pygame.quit()

This code sets up the simulation environment with an 800×600 window, where your drone will navigate. The drone and obstacle objects will be drawn on the screen, and the display will refresh 60 times per second.

Step 3: Create the Drone Class

In drone.py, create the Drone class that will control the drone’s movement and simulate navigation.

Python
import pygame

class Drone:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.width = 40
        self.height = 20
        self.color = (255, 0, 0)  # Red drone
        self.velocity = 5

    def update(self):
        keys = pygame.key.get_pressed()

        # Move the drone with arrow keys
        if keys[pygame.K_LEFT]:
            self.x -= self.velocity
        if keys[pygame.K_RIGHT]:
            self.x += self.velocity
        if keys[pygame.K_UP]:
            self.y -= self.velocity
        if keys[pygame.K_DOWN]:
            self.y += self.velocity

    def draw(self, screen):
        pygame.draw.rect(screen, self.color, (self.x, self.y, self.width, self.height))

In this code:

  • The drone is a simple red rectangle that moves based on arrow key inputs.
  • update() checks for key presses and moves the drone.
  • draw() renders the drone on the screen.

Step 4: Add Obstacles to Avoid

In obstacles.py, create the Obstacle class, which will represent buildings, trees, or other obstacles your drone has to avoid.

Python
import pygame

class Obstacle:
    def __init__(self, x, y, width, height):
        self.x = x
        self.y = y
        self.width = width
        self.height = height
        self.color = (0, 255, 0)  # Green obstacle

    def draw(self, screen):
        pygame.draw.rect(screen, self.color, (self.x, self.y, self.width, self.height))

Now, your simulation will include obstacles that the drone has to avoid while navigating. The drone should be able to move around these obstacles to complete its delivery.

Step 5: Simulate Delivery Points

Let’s add a delivery point to the simulation, where the drone will deliver the package. You can represent this as a specific spot on the map (a circle, for example).

  1. Add a delivery point to the main.py file:
Python
   delivery_point = pygame.Rect(650, 500, 20, 20)
  1. Modify the main loop to draw the delivery point:
Python
   pygame.draw.ellipse(screen, (0, 0, 255), delivery_point)  # Blue delivery point
  1. Check if the drone reaches the delivery point:
Python
   if drone.x < delivery_point.x + delivery_point.width and \
      drone.x + drone.width > delivery_point.x and \
      drone.y < delivery_point.y + delivery_point.height and \
      drone.y + drone.height > delivery_point.y:
       print("Package delivered!")

Once the drone reaches the delivery point, the console will print “Package delivered!”.

Step 6: Add a Realistic Pathfinding Algorithm (Optional)

In a real-world drone delivery system, drones don’t just follow arrow keys; they navigate based on waypoints or GPS coordinates. We can simulate this with a simple pathfinding algorithm like A* (A-star) to automatically guide the drone to the delivery point.

Here’s a simplified version using waypoints:

  1. Create a list of waypoints that the drone should follow:
Python
   waypoints = [(100, 100), (300, 300), (600, 400), (650, 500)]  # Example waypoints
  1. Modify the Drone class to follow the waypoints:
Python
   class Drone:
       def __init__(self, x, y):
           self.x = x
           self.y = y
           self.waypoints = [(300, 300), (650, 500)]  # Points to navigate through
           self.current_waypoint = 0
           self.velocity = 2

       def update(self):
           if self.current_waypoint < len(self.waypoints):
               target_x, target_y = self.waypoints[self.current_waypoint]
               dx = target_x - self.x
               dy = target_y - self.y
               distance = (dx**2 + dy**2)**0.5

               if distance > 5:
                   self.x += self.velocity * (dx / distance)
                   self.y += self.velocity * (dy / distance)
               else:
                   self.current_waypoint += 1  # Move to the next waypoint

Now, the drone will automatically navigate through the waypoints to reach the delivery point. This gives a more realistic flight path compared to manual control.

**Step

7: Advanced Customizations (Optional)**

1. Integrate with DroneKit for Real Drone Control

For those looking to take the simulation into the real world, you can control an actual drone using the DroneKit-Python library. If you have a drone compatible with DroneKit, you can write code to send it GPS waypoints and automate its flight in the real world.

Here’s a simple example to get started with DroneKit:

Python
from dronekit import connect, VehicleMode, LocationGlobalRelative

# Connect to the drone (use your drone's connection string)
vehicle = connect('127.0.0.1:14550', wait_ready=True)

# Function to arm the drone and take off to a specified altitude
def arm_and_takeoff(altitude):
    while not vehicle.is_armable:
        print("Waiting for vehicle to be armable...")
        time.sleep(1)

    vehicle.mode = VehicleMode("GUIDED")
    vehicle.armed = True

    while not vehicle.armed:
        print("Waiting for vehicle to arm...")
        time.sleep(1)

    vehicle.simple_takeoff(altitude)

# Take off to 10 meters
arm_and_takeoff(10)

2. Add Collision Detection

To make your drone delivery simulation more realistic, add collision detection to ensure the drone doesn’t fly through obstacles. This can be done by checking if the drone’s position overlaps with any obstacle.

Testing Your Drone Delivery Simulation

Once you’ve implemented the basic simulation, test it by running main.py. Try controlling the drone with the arrow keys or using the waypoint navigation system. The drone should avoid obstacles, follow a specific path, and deliver the package when it reaches the delivery point.

Enhance the Experience:

  • Change the obstacle positions to make the environment more challenging.
  • Customize the delivery point by adding more waypoints or creating new levels.
  • Modify the drone’s speed, size, and color to fit your desired style.

Customize and Expand Your Drone Delivery System

Here are some ways you can expand the drone delivery simulation:

1. Add More Delivery Points:

  • Create multiple delivery points in the environment, and program the drone to visit them in sequence. This could simulate a real-world delivery route.

2. Add Weather Conditions:

  • Simulate weather conditions like wind or rain, which can affect the drone’s speed or direction. Use random values to create a more unpredictable environment.

3. Implement a Drone Battery System:

  • Add a battery system to your drone that depletes over time. The drone will need to recharge at a specific point before completing all deliveries.

4. Build a 3D Simulation:

  • If you’re feeling ambitious, take your project to the next level by creating a 3D drone simulation using libraries like PyOpenGL or game engines like Unity.

What’s Next?

Congratulations! You’ve built a Drone Delivery System Simulation that mimics the basic principles of real-world drone logistics. Whether you’re controlling the drone manually or programming it to follow waypoints, you’ve learned the fundamentals of drone navigation, pathfinding, and obstacle avoidance.

Resources and Additional Help

Categorized in:

STEM