TTM4115 Team 05 — Multi-Drone Delivery System

Overview

This repository contains the implementation of an autonomous multi-drone delivery system. The system manages a fleet of three drones coordinated by a Fleet Manager, all communicating via MQTT, with a browser-based dashboard that provides live monitoring and manual control.

Repository Structure

├── drone/
│   ├── drone_stm.py          # Drone state machine — laptop/testing version (manual control via website)
│   └── drone_stm_pi.py       # Drone state machine — Raspberry Pi version with Sense HAT
├── fleet_manager/
│   └── fleet_stm.py          # Fleet Manager state machine — multi-drone orchestration
├── website/
│   └── index_en.html         # Customer-facing dashboard (delivery requests, live map, drone control)
├── main.py                   # Launcher: starts Fleet Manager + all 3 drones in one command
└── README.md

Quick Start

Step 1 — Install dependencies

pip install paho-mqtt stmpy

On the Drone Pi only (Sense HAT):

pip install sense-hat

Step 2 — Start the backend

From the project root, run:

python main.py

This single command launches the Fleet Manager and all three drones (drone_01, drone_02, drone_03) as separate subprocesses. You will see interleaved log output from all components. Press Ctrl+C to stop everything cleanly.

Step 3 — Open the website

Open website/index_en.html manually in your browser (double-click the file, or use File → Open in your browser). No web server is required — the page connects directly to the MQTT broker via WebSocket.

Note: The website requires an active internet connection to reach the public MQTT broker at broker.emqx.io.

Hardware Setup

Device	Role	Notes
Raspberry Pi #1 (with Sense HAT)	Drone	Runs `drone_stm_pi.py`
Raspberry Pi #2 (no HAT)	Fleet Manager	Runs `fleet_stm.py`

MQTT Communication

All components communicate through the public broker:

Broker: broker.emqx.io
Port: 1883 (standard) / 8080 (WebSocket for browser) | Topic | Direction | Description | |---|---|---| | delivery/request | Website → Fleet | Customer submits a delivery order | | delivery/assigned | Fleet → Drone | Fleet assigns a mission to a specific drone | | delivery/status | Fleet → Website | Delivery lifecycle updates (confirmed, delivered, failed, rescheduled) | | drone/location | Drone → All | GPS coordinates (lat/lon) published in real time | | drone/battery | Drone → All | Battery level (0–100) | | drone/status | Drone → All | Current drone state | | drone/failure | Drone → Fleet | Structured failure notification with reason and error | | drone/control | Website → Drone | Manual control commands (advance, force_failure, charge, etc.) | | fleet/recovery | Fleet → Drone | Recovery command after failure | | fleet/status | Fleet → All | Fleet Manager state + active/pending orders + all drone states |

File Descriptions

`main.py` — System Launcher

Starts the full system with a single command. It:

Launches fleet_stm.py as a subprocess (with a 1-second head start).
Launches drone_stm.py three times in parallel, passing drone_01, drone_02, and drone_03 as arguments (0.5-second stagger between each).
Monitors all subprocesses and warns if any exit unexpectedly.
Shuts everything down cleanly on Ctrl+C (SIGTERM first, then SIGKILL if needed).

python main.py

`drone/drone_stm.py` — Drone Controller (Laptop / Testing)

Runs on your laptop for development and testing. Controls a single drone instance identified by its drone ID (passed as a command-line argument). Three instances run in parallel when launched via main.py.

Key behaviours:

State machine is fully manual — transitions are triggered by commands received via MQTT (drone/control topic), typically sent from the website's drone control panel.
Simulates smooth GPS movement between base → pickup → delivery → base in 30 steps of 0.25 seconds each.
Simulates battery drain during flight (1% per step); battery recharges automatically in steps of 5% every 0.4 seconds when in Charging state.
Battery reaching 0% automatically triggers the battery_low event and forces the drone into Charging.
Failure reasons are determined strictly from the drone's state at the moment of failure — no fallbacks or generic messages. To run a single drone manually:

cd drone
python drone_stm.py drone_01

Drone State Machine

State	Description
`Idle`	Waiting for a mission assignment
`Assigned`	Mission received, ready for takeoff
`FlyingToPickup`	Navigating to pickup location
`PickingUp`	Hovering at pickup, securing package
`FlyingToDelivery`	Navigating to delivery location
`Delivering`	Hovering at destination, releasing package
`Returning`	Flying back to base
`Charging`	Docked at base, recharging battery
`Failed`	Delivery failed; awaiting recovery command

Failure Types

Reason	Trigger State	Error Message
`bad_weather`	Any active state	Bad weather
`battery_low`	Any state (auto)	Battery low
`obstacle_detected`	FlyingToPickup / FlyingToDelivery	Obstacle detected
`pickup_failed`	PickingUp	Pickup failed
`recipient_unavailable`	Delivering	Recipient unavailable

`drone/drone_stm_pi.py` — Drone Controller (Raspberry Pi + Sense HAT)

Runs on the Drone Raspberry Pi. Uses the Sense HAT joystick to manually trigger state transitions and the LED matrix to display the current state colour.

How to run on the Pi:

cd drone
python drone_stm_pi.py

Sense HAT Joystick Controls

Direction	Action
Press (middle)	Advance to next state
Left	Simulate a failure
Right	Trigger charging

LED Matrix Colours

Colour	State
🟢 Green	Idle
🟣 Magenta	Assigned
🔵 Blue	FlyingToPickup / FlyingToDelivery
🟡 Yellow	PickingUp / Delivering
🟠 Orange	Returning
⚪ White	Charging
🔴 Red	Failed / Emergency

`fleet_manager/fleet_stm.py` — Fleet Manager

Central orchestrator for the multi-drone delivery system. Manages up to 3 known drones (drone_01, drone_02, drone_03).

Key behaviours:

Receives and validates delivery requests (requires pickup, dropoff, and package fields).
Assigns available drones (state = Idle and battery > 20%).
Queues requests that cannot be immediately assigned (Rescheduling state) and retries when a drone becomes available.
Tracks delivery lifecycle: confirmed → delivered / failed.
Validates all failure payloads: only (reason, error) pairs defined in drone_stm.py are accepted; invalid payloads are silently dropped.
Sends a recovery_complete signal to the drone after processing a failure.
Resets automatically after each completed or failed delivery.

Fleet Manager States

State	Description
`WaitingRequest`	Idle, no active deliveries
`ValidatingRequest`	Checking incoming delivery request
`AssigningDrone`	Selecting and assigning an available drone
`MonitoringDelivery`	Tracking one or more active deliveries
`Rescheduling`	No drone available; queuing requests
`Failed`	A delivery failure has been processed

`website/index_en.html` — Customer Dashboard

A single-file browser application with no server requirement. Connects to the MQTT broker via WebSocket on port 8080.

Layout

The page is divided into three columns:

Left Sidebar — Delivery Request & Orders

A form to submit new delivery orders with: customer name, email, package weight (kg), and pickup/delivery coordinates (entered manually or by clicking on the map).
A live order list showing each order's ID, status, assigned drone, and failure reason if applicable.
Summary statistics: total drones tracked, average battery, selected drone state, fleet manager state. Centre — Live Map
Interactive Leaflet map centred on Trondheim.
All three drone positions shown as 🚁 markers that update in real time.
When a delivery is submitted, 📦 (pickup) and 🏠 (delivery) markers appear with a dashed blue route line.
Markers are automatically cleared when the delivery completes or fails.
Clicking on the map when a location selector is active drops a temporary marker and fills the coordinate fields. Right Sidebar — Drone Control & Monitoring
Drone selector (choose drone_01, drone_02, or drone_03).
Weather mode toggle (Good Weather / Bad Weather): when Bad Weather is active, the Advance button sends a bad_weather_failure command instead of advance.
Control buttons: Advance, Force Failure, Charge.
Two state machine diagrams rendered live:
- Drone FSM: shows all drone states and highlights visited states in blue.
- Fleet Manager FSM: shows all fleet states and highlights visited states.
Live activity log showing timestamped events (deliveries, failures, state transitions, MQTT messages).

MQTT Topics Used by the Website

Topic	Action
`delivery/request`	Published when a delivery form is submitted
`drone/control`	Published when a control button is pressed
`drone/location`	Subscribed — updates drone map markers
`drone/battery`	Subscribed — updates battery displays
`drone/status`	Subscribed — updates drone state displays
`drone/failure`	Subscribed — logs and displays failure details
`delivery/status`	Subscribed — updates order status and clears map
`fleet/status`	Subscribed — updates fleet state machine diagram and drone info

Use Cases Demonstrated

Use Case	How it works
UC-1: Request Delivery	Fill the form on the website → Fleet Manager validates and assigns a drone → Drone flies the full route
UC-2: Handle Failure	Press Force Failure or enable Bad Weather then Advance → drone reports structured failure → Fleet sends recovery → drone returns to Idle
UC-3: Track Delivery Live	Map updates in real time with drone position; activity log and state machine diagrams update on every MQTT message

agatamz/Design-Of-Communicating-Systems

About

Resources

Stars

Watchers

Forks

Releases

Packages 0

Contributors 4

Languages

Packages