Pros of Betaflight

• Betaflight is widely used and has a large community, providing extensive support and resources.
• The project has a strong focus on performance and responsiveness, making it a popular choice for high-end drone builds.
• Betaflight offers a comprehensive set of features, including advanced flight modes and tuning options.

Cons of Betaflight

• Betaflight may have a steeper learning curve compared to iNav, especially for beginners.
• The project's rapid development can sometimes lead to compatibility issues or breaking changes.
• Betaflight's focus on performance may come at the expense of some advanced navigation and autonomous features found in iNav.

Code Comparison

Betaflight:

void pidController(void) {
    // Calculate gyro rates
    for (int axis = 0; axis < 3; axis++) {
        rateTarget[axis] = getSetpointRate(axis) * maxVelocity[axis];
        const float gyroRate = gyro.gyroADCf[axis];
        const float rateError = rateTarget[axis] - gyroRate;
        pidData[axis].P = pidCoefficient[axis].Kp * rateError;
    }
    // Apply I-term
    for (int axis = 0; axis < 3; axis++) {
        pidData[axis].I = constrainf(pidData[axis].I + pidCoefficient[axis].Ki * rateError * dT, -itermLimit, itermLimit);
    }
}

iNav:

void pidController(void) {
    // Calculate gyro rates
    for (int axis = 0; axis < 3; axis++) {
        rateTarget[axis] = getSetpointRate(axis) * maxVelocity[axis];
        const float gyroRate = gyro.gyroADCf[axis];
        const float rateError = rateTarget[axis] - gyroRate;
        pidData[axis].P = pidCoefficient[axis].Kp * rateError;
    }
    // Apply I-term
    for (int axis = 0; axis < 3; axis++) {
        pidData[axis].I = constrainf(pidData[axis].I + pidCoefficient[axis].Ki * rateError * dT, -itermLimit, itermLimit);
    }
}

The code snippets above show the pidController() function in both Betaflight and iNav. The main difference is the focus on performance and responsiveness in Betaflight, while iNav may prioritize advanced navigation and autonomous features.

Pros of ArduPilot

• Extensive feature set, supporting a wide range of vehicles (planes, helicopters, rovers, etc.)
• Robust and well-tested codebase, with a large and active community
• Comprehensive documentation and support resources

Cons of ArduPilot

• Larger and more complex codebase, which may be more challenging for new contributors
• Potentially slower development cycle compared to more focused projects
• May have a steeper learning curve for some users

Code Comparison

ArduPilot (ardupilot/ardupilot):

void Plane::update_navigation()
{
    // Altitude hold
    if (control_mode == FBWA || control_mode == CRUISE || control_mode == AUTOTUNE) {
        hold_alt_active = true;
        throttle_suppressed = false;
    } else {
        hold_alt_active = false;
        throttle_suppressed = true;
    }
}

iNavFlight (iNavFlight/inav):

void applyAltHold(void)
{
    if (altHoldState == ALT_HOLD_NORMAL) {
        // Normal alt hold
        rcCommand[THROTTLE] = constrain(rcCommand[THROTTLE], motorAndServoOutputEnabled ? rcLookupThrottle(rcData[THROTTLE]) : 0, motorAndServoOutputEnabled ? currentControlRateProfile->throttle.max : 0);
    } else if (altHoldState == ALT_HOLD_INITIALIZE) {
        // Initializing alt hold
        altHoldThrottleAdjustment = 0;
        altHoldState = ALT_HOLD_NORMAL;
    }
}

Pros of PX4/PX4-Autopilot

• Comprehensive flight control system with support for a wide range of vehicles, including multirotor, fixed-wing, and VTOL aircraft.
• Robust and well-documented codebase with a large and active community.
• Extensive simulation and testing capabilities, including support for Gazebo and SITL (Software-In-The-Loop) simulation.

Cons of PX4/PX4-Autopilot

• Steeper learning curve compared to iNavFlight/inav, especially for users new to autopilot systems.
• Limited support for some specialized features, such as advanced FPV (First-Person View) functionality.
• Larger codebase and more complex architecture, which may make it more challenging for some users to contribute or customize.

Code Comparison

PX4/PX4-Autopilot (Attitude Controller):

void AttitudeControl::updateActuatorControls(const matrix::Quatf &q, const matrix::Vector3f &rates, float dt)
{
    // Get current rotation matrix and rates
    matrix::Dcmf R = matrix::Dcmf(q);

    // Compute angular rate errors
    matrix::Vector3f rates_err = _rates_sp - rates;

    // Compute attitude error
    matrix::Vector3f att_err = R.transpose() * _att_sp.dcm().transpose();
    att_err = matrix::Vector3f(att_err(0), att_err(1), att_err(2));

    // Compute control
    _actuator_controls.control[0] = -_attitude_p(0) * att_err(0) - _attitude_d(0) * rates_err(0);
    _actuator_controls.control[1] = -_attitude_p(1) * att_err(1) - _attitude_d(1) * rates_err(1);
    _actuator_controls.control[2] = -_attitude_p(2) * att_err(2) - _attitude_d(2) * rates_err(2);
    _actuator_controls.control[3] = _thrust_sp;
}

iNavFlight/inav (Attitude Controller):

void FAST_CODE applyAndSaveAttitudeRatePID(void)
{
    // Apply PID setpoint to rate PID controllers
    pidApply(&pidLevel[ROLL], rcCommand[ROLL], gyroADC[ROLL]);
    pidApply(&pidLevel[PITCH], rcCommand[PITCH], gyroADC[PITCH]);
    pidApply(&pidLevel[YAW], rcCommand[YAW], gyroADC[YAW]);

    // Save attitude error to PID controllers
    pidLevel[ROLL].error = rcCommand[ROLL];
    pidLevel[PITCH].error = rcCommand[PITCH];
    pidLevel[YAW].error = rcCommand[YAW];
}

Pros of Cleanflight

• Cleanflight has a larger user base and more active development, with more contributors and a more active community.
• Cleanflight has a more user-friendly configuration interface and better documentation.
• Cleanflight has a wider range of supported hardware and features, including more advanced flight modes and tuning options.

Cons of Cleanflight

• Cleanflight has a more complex codebase and may be more difficult to understand and contribute to for new developers.
• Cleanflight has a more aggressive development cycle, which can sometimes lead to stability issues or breaking changes.
• Cleanflight's focus on advanced features may make it less suitable for users who just want a simple, reliable flight controller.

Code Comparison

Cleanflight:

void taskMainPidLoop(timeUs_t currentTimeUs)
{
    static uint32_t previousTime;
    bool runTaskMainPidLoop = false;

    if (currentTimeUs >= previousTime + (targetLooptime - TASK_PERIOD_HZ(1))) {
        previousTime = currentTimeUs;
        runTaskMainPidLoop = true;
    }

    if (runTaskMainPidLoop) {
        // Gyro
        getGyroData();
        // Acc
        getAccelerometerData();
        // Attitude
        updateAttitude(currentTimeUs);
        // Pid
        updatePids();
    }
}

iNav:

void taskMainPidLoop(timeUs_t currentTimeUs)
{
    static uint32_t previousTime;
    bool runTaskMainPidLoop = false;

    if (currentTimeUs >= previousTime + (targetLooptime - TASK_PERIOD_HZ(1))) {
        previousTime = currentTimeUs;
        runTaskMainPidLoop = true;
    }

    if (runTaskMainPidLoop) {
        // Gyro
        getGyroData();
        // Acc
        getAccelerometerData();
        // Attitude
        updateAttitude(currentTimeUs);
        // Pid
        updatePids();
        // Navigation
        updateNavigation(currentTimeUs);
    }
}

The main difference between the two codebases is the inclusion of the updateNavigation() function in the iNav version, which is responsible for handling navigation-related tasks such as waypoint following and altitude hold.