AFCS Mk5 is a compact, AIoT-enabled flight computer for small rockets. It combines sensor fusion, physics-based calculations, and feedback control to actively stabilize a rocket while logging telemetry for analysis.

Autonomous Flight Control System MK5 or AFCS MK5 is a model rocket AIoT-enabled flight computer that is compact and runs on an on-board autonomous flight software that is designed to allow for complete guidance and full roll control for experimental model rockets, as it integrates physics-based calculations, sensor fusion, and active feedback control in-order to stabilize a model rocket. This project had gone through various iterations from MK1, MK2, MK3, MK4 and lastly MK5. From an inspiration by having a burning desire to push the realm of rocketry beyond the limits of basic simple passive stability, hence this project fully integrates together advanced avionics into simple PCB that is designed for measuring flight data such as orientation, servo positions, altitude from sea-level and in correcting instability in real-time, while providing full telemetry to the user after the flight.

I had set out to build a reliable system that could sense the motions and forces that are occurring in real-time on the rocket, provide an instant reactionary action and would fit in a lightweight airframe.

Fundamentally the AFCS MK5, relies on a 9-Axis MPU6500 IMU to combine Accelerometer and Gyro data via a Common filter to provide reliable pitch, roll, and yaw (after creating a hard-coded yaw reference) data all during powered maneuvers. Altitude data via altimeter and peak altimeter sensing comes from a BMP180 barometric sensor. Velocity and location data comes from a NEO-6M GPS module. All data is written to an auto-incrementing CSV file.

Other than its functionalities and capabilities, AFCS Mk5 also holds great educational value. Being based on real-world aerospace systems such as inertial data fusion, PID control, telemetry data logging, and events detection, it provides a great learning area for educational institutions to teach basic principles related to rocket science, physics, embedded systems, and control systems, as well as having the ability to develop more complex systems while keeping cost low. In this context, it would be very educational for students in a classroom environment to be able to learn about areas such as acceleration, angular velocity, aerodynamics, as well as feedback control systems by observing them in their actual use in flight. In this context, it would be very educational to be able to learn about areas such as graphing data from logged telemetry data to observe theoretical systems in their actual hardware form.

Based on this live orientation data, AFCS Mk5 controls two high-speed SG90 servos coupled to 2x sophisticated fins. The PID algorithm quickly analyzes how far the rocket deviates from its desired orientation and instructs the servos to control the angles of the fins to correct roll and pitch errors in mere milliseconds. The system is also redundancy-minded allowing for undisrupted data collection if any sensor loses connection or fails. In such situations, AFCS Mk5 automatically continues to collect data from other sensors and even attempts in reconnecting to disconnected sensors in the background.

Additionally, the code for the entire autonomous flight controller is available on my GitHub under AFCS MK5.

The board also contains functionality to determine critical events of flight such as burn-out, apogee, burn-out, and landing. All these features form the framework for implementing additional capabilities such as parachute deployment and management of multiple stages. In general, I aimed to ensure that AFCS Mk5 would be lightweight and amenable to prototyping via services like PCBWay and durable enough to allow for rapid development and testing. The completion of AFCS Mk5 represents an incredible milestone in pursuing my ultimate objective to build reusable and guided rockets as well as cost-effective control boards for aerospace applications. This overall allows smalls to medium sized rockets to be fully controlled with a cheap open-source solution to demonstrate complex capabilities not seen in current solutions.

AFCS MK5 Autonomous Code Break Down with Physics and Math:

1. Imports and Libraries

import math, os

from machine import I2C, Pin, PWM

from time import ticks_us, ticks_diff, ticks_ms, sleep_ms

from mpu6500 import MPU6500

import bmp180

math: For trigonometry and square roots used in orientation calculations.

os: To create new log files for each flight.

machine: Hardware interface (I2C, GPIO, PWM).

time: Provides microsecond/millisecond timing for integration and velocity.

mpu6500 & bmp180: Drivers for the IMU (gyroscope + accelerometer) and barometer.

Physics context: Sensors provide raw measurements (acceleration, angular velocity, pressure). These measurements must be transformed mathematically to derive an orientation, altitude, and velocity.

2. LED Status Indicator

led = Pin(25, Pin.OUT)

def blink(times, delay_ms=200):

    for _ in range(times):

        led.on()

        sleep_ms(delay_ms)

        led.off()

        sleep_ms(delay_ms)

LED provides real-time feedback on sensor status.

Blinking patterns signal errors or reconnections, which is a critical part of robust AIoT design.

3. I2C Bus Initialization

i2c0 = I2C(0, sda=Pin(0), scl=Pin(1), freq=400_000)

i2c1 = I2C(1, scl=Pin(3), sda=Pin(2), freq=100000)

i2c0: Connects to the IMU at high speed (400 kHz).

i2c1: Connects to the barometer at standard speed (100 kHz).

Separating buses avoids interference, improving reliability and AIoT resilience.

4. Sensor Initialization

def init_mpu():

    while True:

        try:

            mpu = MPU6500(i2c0)

            print("✅ MPU6500 connected.")

            return mpu

        except:

            blink(5,100)

            sleep_ms(500)

def init_bmp():

    while True:

        try:

            bmp = bmp180.BMP180(i2c1)

            bmp.oversample_sett = 2

            bmp.sea_level_pressure = 101325

            return bmp

        except:

            blink(1,300)

            sleep_ms(1000)

Implements automatic reconnection, a key principle in AIoT.

Ensures continuous data collection, preventing flight loss due to sensor failure.

5. Gyroscope Calibration

def calibrate_gyro(samples=500, delay_ms=5):

    gx_offset = gy_offset = gz_offset = 0

    for _ in range(samples):

        gx, gy, gz = mpu.gyro

        gx_offset += gx; gy_offset += gy; gz_offset += gz

        sleep_ms(delay_ms)

    return gx_offset/samples, gy_offset/samples, gz_offset/samples

Gyroscopes have bias or drift, the averaging readings while stationary gives zero-rate offsets.

Corrected angular velocity:

ω_corrected = ω_raw - bias

This is crucial for accurate integration over time to compute orientation.

6. Complementary Filter – Orientation Tracking

roll = pitch = yaw = 0.0

alpha = 0.98

last = ticks_us()

Tracks roll, pitch, yaw in degrees.

Alpha balances trust: gyro vs accelerometer.

def get_accel_angles(ax, ay, az):

    norm = math.sqrt(ax*ax + ay*ay + az*az)

    ax /= norm; ay /= norm; az /= norm

    roll_acc = math.atan2(ay, az)

    pitch_acc = math.atan2(-ax, math.sqrt(ay*ay + az*az))

    return math.degrees(roll_acc), math.degrees(pitch_acc)

Physics / Math:

Accelerometer measures gravitational vector plus dynamic acceleration:

a = [a_x, a_y, a_z] = g + a_dynamic

Pitch and roll are derived using basic trigonometry:

roll = arctan(a_y / a_z)

pitch = arctan(-a_x / sqrt(a_y^2 + a_z^2))

Complementary Filter Equation:

angle = α * (angle + ω * dt) + (1 - α) * accel_angle

Gyro integrates angular velocity ω\omegaω over time. The accelerometer corrects long-term drift.

7. Servo Control (Actuators)

servo1 = PWM(Pin(9)); servo2 = PWM(Pin(21))

servo1.freq(50); servo2.freq(50)

def angle_to_duty(angle):

    angle = max(135, min(225, angle))

    return int((angle / 180.0) * 3276) + 3277

Servo output implements the control action of the AIoT system.

Control logic (yaw correction):

θ_servo = 180 - (desired_yaw - current_yaw)

This acts like a proportional control loop to reduce yaw error.

8. Barometer – Altitude and Velocity

BMP180 measures pressure, which is converted to altitude using the barometric formula:

h = (R * T / g) * ln(P0 / P)

Velocity estimation:

v = Δh / Δt

Used to detect apogee (maximum altitude) for data logging or in triggering events, such as parachute development.

9. Flight Logging

log_file.write("time,altitude,velocity,yaw,servo1,servo2,setpoint,apogee,mpu_status,bmp_status\n")

CSV log stores all critical Telemetry data: orientation, actuator commands, sensor health.

Allows post-flight analysis, data visualization, and improvement of control algorithms to a user’s preference.

10. Main Loop – AIoT Control

Time step calculation:

dt = (current_time - last_time) / 1e6

Sensor reading (fault-tolerant):

IMU: ax, ay, az, gx, gy, gz

Barometer: pressure → altitude

Orientation fusion:

Gyro integration:

roll_gyro = roll + ω_x * dt

pitch_gyro = pitch + ω_y * dt

yaw_gyro = yaw + ω_z * dt

Accelerometer correction based on using a complementary filter.

Servo actuation:

Calculate yaw error:

yaw_error = desired_yaw - current_yaw

Allows for servo angles to be updated proportionally.

Velocity computation:

v = (h_current - h_previous) / dt

Apogee detection:

Compare current altitude to max recorded altitude.

Trigger event when descending by 0.5 m from max.

Logging and flush:

Write telemetry every cycle.

Flush to storage every 10 seconds for safety.

Loop delay:

10 ms → ~100 Hz update rate.

11. Physics Summary of the AFCS autonomous program

Orientation: Calculated using gyro integration and accelerometer correction.

Velocity: Derived from Δaltitude / Δtime.

Servo correction: Acts as torque to counter yaw disturbances.

Apogee detection: Uses derivative of altitude to identify peak flight point.