Drone Computing: Autonomous Systems in the Field
Building an autonomous drone is one of the few engineering projects that forces nearly every branch of computing and a good deal of physical engineering into the same small airframe. Control theory, embedded systems, computer vision, machine learning at the edge, path planning, distributed middleware, regulation, and field debugging all have to work — at the same time, on battery power, in wind. That convergence is what makes the field difficult, and it is what makes it worth a whole book rather than a stack of tutorials.
This book is written for a computer scientist or engineer coming to that field, whether from software, robotics, or another engineering discipline. It assumes you can program and that calculus and basic linear algebra are not strangers, but it assumes nothing about drones: control theory, the Robot Operating System 2 (ROS 2), and computer vision are each developed from first principles as they arise. The style throughout is full explanatory prose backed by worked examples — derivations where the material is quantitative, runnable code where it is implementation-shaped — but the mathematics lives in the chapters, not here. Where a tutorial might tell you that a proportional–integral–derivative (PID) controller reduces tracking error, this book works out why, what each term does to the closed-loop response, and what the numbers look like on a real vehicle.
0.1 How the Book Is Organized
The chapters are grouped into five parts, which together trace the path from airframe to autonomous mission:
- Part I — Airframes, Regulation & Flight Safety covers the physical platform and the rules that govern it: multirotor anatomy, propulsion and power, sensing and state estimation, the regulatory environment for small uncrewed aircraft, and the safety practices that make field flying repeatable rather than lucky.
- Part II — Flight Control & Mission Scripting develops the control and autonomy stack: feedback control, flight-controller firmware, and the software interfaces — including ROS 2 — used to script missions programmatically.
- Part III — Perception at the Edge: TinyML & Computer Vision turns to what the drone can see and infer in flight, from classical image processing through neural-network inference on power- and compute-constrained onboard hardware.
- Part IV — Path Planning, Coordination & Autonomous Behavior treats the algorithms that decide where the vehicle goes: search and coverage patterns, path planning, behavior architectures, and coordination among multiple agents.
- Part V — Systems Integration, Diagnostics & Ethics closes the loop on engineering practice: integrating subsystems into a working whole, diagnosing failures in the field, extending perception to sensing applications beyond object detection, and reasoning about the ethical and societal dimensions of autonomous aircraft.
Every chapter follows the same template: it opens with Learning Objectives and a Key Vocabulary list, develops the material through worked examples, and closes with Check Your Understanding questions (with collapsible answers), a Try It exercise, and a pointer to a matching lab in Appendix B where one exists. The consistency is deliberate — you should always know where to look for a definition, a self-test, or the hands-on work that puts a chapter’s concepts into practice.
0.2 The Running Example
Rather than reaching for a new toy example in every chapter, the book returns throughout to one system: the Goose Management System, an autonomous ROS 2-based drone whose mission is to search a protected area, detect geese with onboard perception, and deter them from the site. The task sounds simple until you try to build it. Doing it well takes nearly everything this book covers — a safe and legal airframe (Part I), scripted autonomous flight (Part II), real-time detection on edge hardware (Part III), efficient search and pursuit behavior (Part IV), and a fully integrated, field-debugged, ethically considered system (Part V). Each part picks the thread back up, so you can see exactly where the material you have just read lands in a working system, and what breaks when it fails.
0.3 A Note on Depth
Some chapters go well beyond the depth these subjects usually receive, and topics often treated as assumed background get a full treatment here. By the end, you should be able to reason about an autonomous aerial system end to end — and know where to look when yours misbehaves in the field.
0.4 Acknowledgments
This book began as material developed for the Drone Computing class at the University of Delaware, and the students who worked through it there improved it considerably — in questions that exposed an explanation which only looked complete, and in the lab, where a paragraph that read cleanly on the page turned out to have skipped the step that actually mattered on the hardware. Thanks in particular to Vijay Man Bajracharya and Zhuoyang Fu, whose detailed comments on early drafts corrected errors and sharpened the treatment in several chapters.