Aerial Robotics

An eight-week track in the Core Workshop Series 3.0. Learners start with rotation maths and PID control and finish with a simulated quadcopter that finds a target on its camera feed and centres itself above it.

See the eight weeks View the capstone

Duration: 8 weeks
Classes: 2 per week
Each class: 90 minutes

How the course runs

The track covers VTOL UAVs and fixed-wing UAVs. Hybrid designs are introduced but not covered in depth. Practical work, meaning coding and simulation, takes the larger share of every class.

Each 90-minute class

10 min Review of the last class
30 min Theory
45 min Practical work in code and simulation
5 min Next task set

Who it is for

This course assumes each learner knows at least one programming language, though not necessarily the ones used here.
It also assumes a rudimentary grasp of coordinate geometry and a conceptual understanding of univariate calculus.
Each learner needs a laptop or PC, with 8 GB of RAM as a minimum and 16 GB recommended for running Gazebo with PX4.
Learners dual-boot their machine with Ubuntu Linux or install WSL.
Dual-boot is strongly preferred.
The installation happens within the first two weeks and is coordinated by the Assistant Tutors.

Scope and philosophy

The track covers VTOL (Vertical Takeoff and Landing) UAVs and fixed-wing UAVs.
Hybrid designs are introduced but not covered in depth.
The course balances theory with practical work, and practical work, meaning coding and simulation, takes the larger share of every class.
The aim is a firm grasp of the fundamentals behind aerial robotics and fluency with the tools of the wider robotics ecosystem: C++, Python, ROS 2, Gazebo and YOLO.
Calculus, linear algebra and control theory carry the theory.
Calculus and linear algebra are the most important families of mathematics in robotics, and no one can call themselves a robotics engineer without a working command of them.

Assignments and support

Assignments. Mostly research tasks that ask for a one-page document on the learner's understanding. They keep everyone current with the material.
Office hours. An optional 30-minute session once a week. It goes over complex topics, explains algorithms and helps fix code. It also shows the instructors which topics learners find hardest, which shapes later trainings.
Dense classes. Large topics are condensed into short classes, so office hours exist to give extra explanation whenever it is needed.

By the end of Week 8 a learner can

Describe the main types of aerial platform and the architecture of an aerial robot
Represent orientation with rotation matrices, Euler angles and quaternions, and convert between them
Apply Newtonian mechanics and vectors to a flying body, then build feedforward and PID controllers for it
Estimate the state of a vehicle from noisy sensors with a Kalman filter
Work in Linux, Git, Python and C++ at the level drone development needs
Write ROS 2 nodes in Python and connect them to simulated vehicles in Gazebo
Run PX4 in software-in-the-loop simulation and control it from ROS 2
Explain fixed-wing and multirotor dynamics, compare their hardware, and compute a quadcopter mixer matrix
Combine control, state estimation and YOLO-based vision on a simulated quadcopter at the capstone

Curriculum at a glance

Pick a week to jump straight to its full plan.

1
Introduction to Aerial RoboticsKnow the main types of aerial platform, how an aerial robot is built, and how orientation is represented.
2
Mechanics, Control and State EstimationApply mechanics and vectors to a flying body, tune a PID controller and estimate state with a Kalman filter.
3
Embedded Systems and Software DevelopmentWork with the languages, Git, Linux tools, flight controllers and sensors used in drone development.
4
Introduction to ROS 2 and GazeboWrite ROS 2 nodes in Python and connect them to a simulated robot in Gazebo.
5
Introduction to PX4Run PX4 in simulation, read its logs and control it from a ROS 2 node.
6
Fixed-Wing UAVsUnderstand fixed-wing dynamics and hardware, and fly a fixed-wing aircraft in simulation.
7
Multirotor UAVsModel a quadcopter, build its mixer matrix and set up the ROS 2 quadcopter project.
8
Multirotor UAVs ContinuedAdd control, state estimation and computer vision to the quadcopter and present the capstone.

The eight weeks

Each week lists the objectives, the concepts taught, what happens in the two classes, and what learners hand in.

Week 1

Introduction to Aerial Robotics

Know the main types of aerial platform, how an aerial robot is built, and how orientation is represented.

Session activities

Session 1

Course orientation and a survey of aerial platforms. Draw the block diagram of a real drone and label every part. Start the install clinic by checking each learner's dual-boot or WSL status.

Session 2

Orientation lab in Python: build rotation matrices in NumPy, compose rotations, trigger gimbal lock on purpose, convert to quaternions with SciPy, and animate a body frame in matplotlib.

Learning objectives

Distinguish aerial robots from other mobile robots and name the main platform families.
Describe the architecture of an aerial robot and what each part does.
Represent and convert orientation with matrices, Euler angles and quaternions.

Key concepts

Types of Mobile Robots; Ground, Marine, Legged and Aerial; Where Aerial Robots Fit
Aerial Platforms; Multirotors, Fixed-Wing, VTOL and Hybrid Designs (Hybrids Introduced Only)
Course Scope; VTOL and Fixed-Wing UAVs, Weekly Structure, Office Hours
Aerial Robot Architecture; Airframe, Propulsion, Flight Controller, Sensors, Companion Computer, Ground Station, Radio and Telemetry Links
Reference Frames; World Frame (NED and ENU), Body Frame
Orientation Representations; Rotation Matrices, Euler Angles, Axis-Angle, Quaternions; Gimbal Lock
Converting Between Representations with NumPy and SciPy

Assignment

Research task. Pick one real UAV and write a one-page document on its architecture and why that configuration suits its job.

Deliverable

The one-page document, plus a Python notebook of rotation conversions that runs without errors.

Office hours

Rotation matrices and quaternions.

Week 2

Mechanics, Control and State Estimation

Apply mechanics and vectors to a flying body, tune a PID controller and estimate state with a Kalman filter.

Session activities

Session 1

Control lab in Python: simulate a vertical-axis mass under gravity and thrust, find the feedforward hover thrust, add a PID loop, and tune it against a step input while plotting the response.

Session 2

Estimation lab: fuse a noisy barometer with an accelerometer in a Kalman filter and compare the estimate to the true altitude. The last half hour is a ROS 2 install clinic run by the Assistant Tutors, ending with the talker and listener demo.

Learning objectives

Model the forces and moments on a flying body with Newtonian mechanics and vectors.
Build feedforward and PID controllers and tune them on a step response.
Estimate state from noisy sensors with a Kalman filter.
Install ROS 2 and confirm it works.

Key concepts

Rudimentary Newtonian Mechanics; Newton's Laws, Thrust, Weight and Drag, Moments and Moment of Inertia
Vectors; Dot and Cross Products, Vector Calculus and Linear Algebra Review
Feedforward Control; Open-Loop Commands, Model-Based Compensation, Hover Thrust
PID Control; Proportional, Integral and Derivative Terms, Tuning, Integral Windup, Cascaded Loops
Kalman Filters; State and Measurement Models, Predict and Update Steps, Process and Measurement Noise, Covariance
ROS 2 Installation; ROS 2 Jazzy on Ubuntu 24.04, Sourcing the Environment, Checking the Install with Demo Nodes

Assignment

Research task. Write a one-page note on why drones use cascaded loops for rate, attitude and position control.

Deliverable

A Python notebook with the PID altitude controller and the Kalman filter, plus a terminal log showing the ROS 2 talker and listener running.

Office hours

PID tuning and Kalman filter covariance.

Week 3

Embedded Systems and Software Development

Work with the languages, Git, Linux tools, flight controllers and sensors used in drone development.

Session activities

Session 1

Tools lab: create a repository, branch and open a pull request. Write a moving-average filter for IMU readings in both Python and C++, compile the C++ with g++, and check that the two outputs match.

Session 2

Sensors lab: load an IMU log, measure gyroscope bias and accelerometer noise, and plot both. Build a table of the sensors, actuators and buses on a reference drone from its datasheets.

Learning objectives

Choose between C++ and Python for a drone software task.
Use Git, GitHub and the Linux command line for daily work.
Explain how a flight controller connects sensors and actuators.

Key concepts

Programming Languages in Drone Development; C and C++ for Firmware, Python for Prototyping and Tooling
Git and GitHub; Commits, Branches, Pull Requests, Forking an Open-Source Repository
Linux Command Line; Navigation, Files, Permissions, Pipes, Package Management, Shell Scripts
Embedded Computing; Microcontrollers and Companion Computers, Real-Time Constraints, RTOS Basics, Buses (I2C, SPI, UART and CAN)
Flight Controllers; The Role of the Autopilot, Typical Hardware, Firmware Layers
Sensors; IMU, Magnetometer, Barometer, GPS, Rangefinder, Optical Flow, Camera
Actuators; Brushless Motors, ESCs, Servos, PWM and DShot Signals

Assignment

Research task. Read the datasheets of one IMU and one barometer and write one page on how their noise and update rates limit a controller.

Deliverable

A GitHub repository link with the Python and C++ filters and the one-page note.

Office hours

Git workflow and C++ build errors.

Week 4

Introduction to ROS 2 and Gazebo

Write ROS 2 nodes in Python and connect them to a simulated robot in Gazebo.

Session activities

Session 1

ROS 2 lab: write a publisher and subscriber in rclpy, add a custom service, try an action, and start everything from one launch file.

Session 2

Gazebo lab: launch a world with a simulated robot, bridge its IMU topic into ROS 2, run the Week 2 Kalman filter on that data in a node, and view raw and filtered signals in RViz2.

Learning objectives

Explain the ROS 2 design and when to use topics, services and actions.
Write a publisher, a subscriber, a launch file and a package in Python.
Run a Gazebo world and bridge its topics into ROS 2.

Key concepts

ROS 2 Design Philosophy; Distributed Nodes, DDS Middleware, Why ROS 2 Replaced ROS 1
Nodes, Topics and Messages; the ros2 Command-Line Tools
Services and Actions; Request and Response Compared with Long-Running Goals and Feedback
Workspaces and Packages; colcon, ament_python, Launch Files, Parameters
A Simple Publisher and Subscriber in Python; rclpy, Timers, Callbacks, QoS Basics
Introduction to Gazebo; Worlds, Models, SDF, Plugins
The Gazebo and ROS 2 Interface; ros_gz_bridge, Bridged Topics, Simulation Time; RViz2

Assignment

Research task. Write one page on how DDS reliability settings affect telemetry and why drones often prefer best-effort delivery.

Deliverable

A ROS 2 package with a publisher, a subscriber and a launch file, pushed to GitHub with a README.

Office hours

Nodes, topics and launch files.

Week 5

Introduction to PX4

Run PX4 in simulation, read its logs and control it from a ROS 2 node.

Session activities

Session 1

Build PX4 and start the simulation. Fly it from QGroundControl, change a parameter, watch how the flight changes, and read the resulting log.

Session 2

Start the Micro XRCE-DDS Agent, list the PX4 topics in ROS 2, and write an offboard node that arms the vehicle, climbs to 2 m, holds, and lands.

Learning objectives

Describe the PX4 architecture and how its modules exchange data.
Run PX4 software-in-the-loop with Gazebo and fly it from QGroundControl.
Control a simulated vehicle from a ROS 2 offboard node.

Key concepts

PX4 Architecture; Flight Stack and Middleware, Modules, the uORB Message Bus, Drivers, the EKF2 Estimator, Controllers
Flight Modes; Manual, Altitude, Position, Mission, Offboard, Return
Software in the Loop; Building PX4, Starting a Simulated Vehicle in Gazebo
Ground Control; QGroundControl, MAVLink Basics, Parameters, Arming and Failsafes
ROS 2 and PX4 Integration; the Micro XRCE-DDS Agent, px4_msgs, Vehicle Odometry and Vehicle Command Topics
Offboard Control; the Setpoint Stream, Arming, Mode Switching
Reading Flight Logs; ULog Files and Plotting

Assignment

Research task. Write one page on the inputs and outputs of the EKF2 estimator.

Deliverable

A screen recording of the simulated flight and the offboard node code on GitHub.

Office hours

Building PX4 and fixing simulation errors.

Week 6

Fixed-Wing UAVs

Understand fixed-wing dynamics and hardware, and fly a fixed-wing aircraft in simulation.

Session activities

Session 1

Dynamics lab in Python: compute lift and drag from a simple aerodynamic model, plot the lift curve through stall, and find the trim airspeed for level flight.

Session 2

Simulation lab: fly a fixed-wing vehicle in PX4 and Gazebo with a waypoint mission and a loiter. Log airspeed, altitude and pitch, then plot the ground track with a ROS 2 node.

Learning objectives

Explain how a fixed-wing aircraft makes lift and how its control surfaces steer it.
Compare fixed-wing hardware with multirotor hardware.
Fly a fixed-wing mission in simulation and analyse the log.

Key concepts

Fixed-Wing Dynamics; Lift, Drag, Thrust and Weight, Angle of Attack, Stall, Airspeed and Ground Speed
Control Surfaces; Ailerons, Elevator, Rudder, Flaps, and the Roll, Pitch and Yaw They Command
Stability and Trim; Static Stability, Trim Airspeed, an Introduction to the Longitudinal and Lateral Modes
Flight Phases; Takeoff, Climb, Cruise, Loiter, Landing; Waypoint and Path Following
Fixed-Wing Hardware Architecture; Airframe Types, Motor and Propeller, Servos, Airspeed Sensor, Autopilot Placement, Antenna Layout
Hybrid Fixed-Wing Designs; Introduced Only

Assignment

Research task. Compare a fixed-wing and a multirotor for a pipeline inspection job and write one page on endurance, payload, coverage and takeoff needs.

Deliverable

A notebook with the lift and drag model, flight log screenshots, and the one-page comparison.

Office hours

Reading a lift curve and a flight log.

Week 7

Multirotor UAVs

Model a quadcopter, build its mixer matrix and set up the ROS 2 quadcopter project.

Session activities

Session 1

Dynamics and mixer lab: derive the mixer matrix for an X quadcopter, build it in NumPy, test it with roll, pitch, yaw and thrust commands, and push the commands until a motor saturates.

Session 2

Project setup: create the ROS 2 workspace for the capstone, add the quadcopter package and a Gazebo world, bridge odometry and camera topics, show them in RViz2, and commit everything with a README.

Learning objectives

Write the equations of motion of a quadcopter.
Compare common multirotor layouts and VTOL hardware architectures.
Compute a mixer matrix and use it to turn commands into motor outputs.
Prepare the ROS 2 workspace used for the capstone.

Key concepts

Quadcopter Dynamics; Thrust and Torque from Each Rotor, Translational and Rotational Equations, the Hover Condition
Common Quadcopter Designs; X and Plus Frames, Hexacopters and Octocopters, Coaxial Layouts, Propeller Direction, Size and Payload
VTOL Hardware Architecture; the Multirotor Lift System, Tilt-Rotor, Quad-Plane and Tailsitter Layouts, Transition Introduced
Mixer Matrices; Mapping Thrust and Torques to Motor Commands, Control Allocation, Pseudo-Inverse, Motor Saturation
ROS 2 Quadcopter Implementation, Setup; Package Layout, a Simulated Quadcopter in Gazebo, Topics for Odometry, Commands and Camera

Assignment

Research task. Write one page on how tilt-rotor and quad-plane VTOLs move between hover and forward flight.

Deliverable

The mixer matrix notebook and a repository that launches the simulated quadcopter from one command.

Office hours

Deriving the mixer matrix.

Week 8

Multirotor UAVs Continued

Add control, state estimation and computer vision to the quadcopter and present the capstone.

Session activities

Session 1

Control and estimation: write the teleoperation node, add velocity setpoints, and run the Kalman filter on the quadcopter's odometry while plotting the estimate against ground truth.

Session 2

Vision and capstone: run YOLO on the simulated camera, publish detections, write the behaviour node that centres the quadcopter on a target, then demonstrate the capstone. Learners who cannot demo in class submit a recorded video.

Learning objectives

Control the simulated quadcopter by teleoperation and by commanded setpoints.
Estimate the vehicle state and compare it with ground truth.
Run YOLO on the camera stream and use the detections to steer the vehicle.
Present the finished capstone.

Key concepts

ROS 2 Implementation, Control and Teleoperation; Cascaded Position, Velocity and Attitude Loops, a Keyboard or Joystick Node, Velocity Setpoints in Offboard Mode
ROS 2 Implementation, Localization and State Estimation; Odometry and Position Fusion with a Kalman Filter, Estimate Against Ground Truth
ROS 2 Implementation, Computer Vision; Camera Streams, cv_bridge, YOLO Detection, Detections Published as Topics
Detection-Driven Behaviour; Centring on a Target and Holding Position
Capstone Review and Demos

Homework

Finish the capstone and push the final version to GitHub.

Deliverable

The capstone repository, a README, and a demo video of up to three minutes.

Office hours

Debugging the capstone pipeline.

Capstone Project: Visual Target Tracking Quadcopter

Learners combine the course into one ROS 2 project in which a simulated quadcopter finds a target on its camera feed and centres itself above it. The target can be any object a pretrained YOLO model recognises, for example a person or a car model from the Gazebo library.

The capstone must include

A ROS 2 package in the learner's own GitHub repository, with a launch file that starts the simulation, the nodes and RViz2
A simulated quadcopter in Gazebo that can be flown by a teleoperation node and by scripted setpoints
A Kalman filter node that fuses IMU and position data, with the estimate plotted against ground truth
A YOLO detection node that publishes detections from the camera stream
A behaviour node that centres the quadcopter above the detected target and holds position
A README with build and run steps
A demo video of up to three minutes

Milestones

Week 4: ROS 2 package and Gazebo bridge
Week 5: offboard control of a simulated vehicle
Week 7: quadcopter workspace and mixer
Week 8: control, estimation, vision and the demo

Tools and platforms

Learners dual-boot Ubuntu or install WSL. The Assistant Tutors coordinate the setup within the first two weeks.

Ubuntu 24.04Linux environment for the whole course; dual-boot preferred, WSL accepted (Wks 1 to 8)
Python 3.12Scripting, control and estimation labs, ROS 2 nodes (Wks 1 to 8)
C++ (g++, CMake)The language of autopilot firmware; a first program in Week 3
NumPy, SciPy, matplotlibRotations, simulation of dynamics, filters and plotting (Wks 1 to 7)
Git and GitHubVersion control and submission of every lab (Wk 3 onward)
ROS 2 Jazzy and RViz2Nodes, topics, services, actions and visualisation (Wks 2 to 8)
Gazebo HarmonicPhysics simulation of worlds, vehicles and sensors (Wks 4 to 8)
PX4 AutopilotOpen-source flight stack run in software-in-the-loop (Wks 5 to 8)
QGroundControlGround station for flying, parameters and missions (Wks 5, 6)
Micro XRCE-DDS Agent and px4_msgsBridge between PX4 and ROS 2 (Wks 5 to 8)
OpenCV and YOLOCamera streams and object detection on the simulated quadcopter (Wk 8)