From Remote-Controlled to Autonomous Swarms
The drone you see doing a light show at a stadium or mapping a disaster zone isn't just one UAV — it's typically part of a swarm, and every drone in that swarm is both a node and a relay in a fully distributed wireless network. No single point of failure. No central controller. This is a Flying Ad-hoc Network (FANET).
FANETs are a specialized subset of MANETs (Mobile Ad-hoc Networks) designed for the extreme mobility, 3D topology, and tight latency requirements of UAV fleets. Understanding their design is crucial for anyone working on next-generation IoT, emergency response systems, or 5G-connected drone corridors.
FANET vs MANET vs VANET: MANETs are ground-based ad-hoc networks (laptops, phones). VANETs are vehicular networks (cars). FANETs operate in 3D space with nodes moving at 10–100 m/s — making topology changes far more frequent and routing far more challenging.
FANET Architecture: Every Drone is a Router
In a FANET, each UAV node maintains three key subsystems in parallel:
- Mission payload: Camera, sensor, or actuator performing the actual task.
- Flight controller: Low-level stabilization (often running FreeRTOS on an STM32 or similar MCU).
- Communication subsystem: Handles inter-drone messaging, routing table updates, and ground relay.
The communication subsystem typically runs on a separate processor (often a Raspberry Pi Compute Module or equivalent) and implements a mesh protocol over a radio link — commonly 900 MHz LoRa for long-range command/control, or 2.4/5.8 GHz 802.11 for high-throughput video relay.
Routing in a High-Mobility Network: AODV
The biggest challenge in FANETs is routing. Because nodes move fast, routes that were valid one second ago may be broken the next. Proactive protocols (like OSPF) don't scale because they flood the entire network with topology updates constantly. Instead, most FANET implementations use reactive protocols like AODV (Ad-hoc On-demand Distance Vector).
AODV works like this: a drone only discovers a route when it needs one. It broadcasts a
RREQ (Route Request) packet, which propagates until it reaches the destination or
a node with a fresh route. The destination (or intermediate node) replies with an
RREP (Route Reply) that trails back to the source.
from collections import defaultdict
import heapq
class FANETRouter:
"""Simplified AODV-inspired reactive router for FANET simulation."""
def __init__(self):
self.routing_table = {} # dest -> (next_hop, hop_count, seq_num)
self.seq_num = 0
def send_rreq(self, source, destination, network):
"""Flood RREQ and find route via BFS (simulated)."""
visited = {source}
queue = [(source, [source])]
while queue:
node, path = queue.pop(0)
if node == destination:
return path
for neighbor in network.get(node, []):
if neighbor not in visited:
visited.add(neighbor)
queue.append((neighbor, path + [neighbor]))
return None # No route found
def update_route(self, dest, next_hop, hop_count):
"""Update routing table entry."""
self.seq_num += 1
self.routing_table[dest] = {
'next_hop': next_hop,
'hop_count': hop_count,
'seq_num': self.seq_num,
}
# Example 5-drone swarm topology
network = {
'D1': ['D2', 'D3'],
'D2': ['D1', 'D4'],
'D3': ['D1', 'D5'],
'D4': ['D2', 'D5'],
'D5': ['D3', 'D4'],
}
router = FANETRouter()
path = router.send_rreq('D1', 'D5', network)
print(f"Route found: {' → '.join(path)}")Path Planning: A* in 3D Constrained Space
Routing handles which drones relay the signal. Path planning handles where each drone physically flies. In environments with obstacles (buildings, terrain, NFZs), drones use the A* algorithm to find an optimal collision-free trajectory.
A* searches a 3D grid by minimizing the estimated total cost $f(n) = g(n) + h(n)$, where:
$g(n)$ = actual cost from start to node $n$; $h(n)$ = heuristic estimate from $n$ to goal (usually Euclidean distance).
In energy-constrained drone applications, the cost function can be extended to include the energy budget $E$ needed to traverse an edge:
Research direction: Constrained A* variants (CA*) and multi-agent collaborative path planning (CBS — Conflict-Based Search) are active areas. Combining these with Reinforcement Learning is the current frontier for large swarms (>100 UAVs).
Link Budget: Can Two Drones Actually Hear Each Other?
Even with perfect routing, none of it works unless the radio link is physically viable. The inter-drone link budget determines the maximum reliable communication range and depends on transmit power, antenna gain, path loss, and receiver sensitivity.
For an air-to-air (A2A) link at altitude, the free-space path loss is:
Where $d$ is distance in metres and $f$ is frequency in Hz.
At 900 MHz with 100 mW transmit power and a sensitivity of −100 dBm, two drones can maintain a reliable link at roughly 3–5 km in open sky — enough for most tactical swarm missions.
Conclusion
FANETs represent the intersection of embedded systems, networking protocols, and wireless communications. Building reliable drone swarms requires co-designing the physical radio layer, the routing protocol, and the path planning algorithm together — and understanding the trade-offs at each level.
In the next post, we'll look at how LoRaWAN fits into the FANET picture for long-range, low-power command-and-control links, and why chirp spread spectrum survives where Wi-Fi fails at range.