feat: Complete Phase 2 Refactoring - Controller Encapsulation

- Implemented `FlightController` class to manage PID controllers and motor scaling.
- Created `InputProcessor` class for safe handling of RC packets with deadband application.
- Developed `SafetyManager` class for arming state management and failsafe logic.
- Added `SerialInterface` class for command handling with buffer overflow protection.
- Refactored `main.cpp` to utilize new controller classes, improving structure and readability.
- Enhanced setup and loop functions for clearer pipeline stages and improved safety checks.
- Removed legacy global PID variables and replaced with encapsulated state in controller classes.
- Ensured zero behavior changes while improving code quality and maintainability.

Author: DanielKusyDev

REFACTOR_LOG.md

@@ -83,11 +83,11 @@ Control Pipeline → Motor Output → Telemetry
 - [x] Create `CalibrationConfig` class (already exists, verified)
 - [x] Replace all #define with constexpr/const members
 
-### Phase 2: Controller Encapsulation
-- [ ] Create `FlightController` class to own PID controllers
-- [ ] Create `InputProcessor` class for RC packet handling
-- [ ] Create `SafetyManager` class for arming/failsafe logic
-- [ ] Create `SerialInterface` class for command handling
+### Phase 2: Controller Encapsulation ✅ COMPLETED
+- [x] Create `FlightController` class to own PID controllers
+- [x] Create `InputProcessor` class for RC packet handling
+- [x] Create `SafetyManager` class for arming/failsafe logic
+- [x] Create `SerialInterface` class for command handling
 
 ### Phase 3: Main Loop Cleanup
 - [ ] Extract setup() into logical init phases
@@ -163,3 +163,78 @@ Control Pipeline → Motor Output → Telemetry
 - Phase 2: Create controller encapsulation classes
 - Remove legacy macros once all code migrated to new classes
 
+---
+
+### [2025-10-27] Phase 2: Controller Encapsulation - COMPLETED ✅
+
+**New Classes Created:**
+
+1. **FlightController** ([flight_controller.h/cpp](firmware/app/flight_controller.h))
+   - Encapsulates all 5 PID controllers (angle roll/pitch, rate roll/pitch/yaw)
+   - Manages motor scaling array
+   - Methods: `init()`, `reset_all()`, `compute_angle_*()`, `compute_rate_*()`, `apply_anti_windup()`
+   - All PID configuration done in constructor using `PIDConfig::` constants
+
+2. **InputProcessor** ([input_processor.h/cpp](firmware/app/input_processor.h))
+   - Safe RC packet handling from volatile `g_lastPkt`
+   - Thread-safe memcpy with `volatile` qualifier
+   - Deadband application
+   - Setpoint conversion methods: `get_angle_roll_setpoint()`, etc.
+   - **Eliminated** dangerous `String` usage
+
+3. **SafetyManager** ([safety_manager.h/cpp](firmware/app/safety_manager.h))
+   - Arming state management
+   - Failsafe logic encapsulation
+   - Methods: `update()`, `compute_stab_gain()`, `allow_yaw_integral()`, `is_takeoff_ready()`
+   - Clean interface to `ArmState`
+
+4. **SerialInterface** ([serial_interface.h/cpp](firmware/app/serial_interface.h))
+   - Fixed-size char buffer (no String heap allocation)
+   - Callback-based command handling
+   - Buffer overflow protection
+   - Supports both single-char and multi-char commands
+
+**Main.cpp Refactoring:**
+
+- **Before**: 401 lines, mixed responsibilities, global state everywhere
+- **After**: 281 lines (-120 lines, -30%), clear pipeline structure
+- **Removed globals**: `pidAngleRoll`, `pidAnglePitch`, `pidRoll`, `pidPitch`, `pidYaw`, `motorScale`, `armState`
+- **New globals**: `g_flight_controller`, `g_input_processor`, `g_safety_manager`, `g_serial_interface`
+
+**Setup() improvements:**
+- Grouped into logical phases: System → Hardware → Sensor → Controller → Safety
+- Used `FlightConfig::SETUP_SETTLE_MS` instead of magic `delay(500)`
+- Lambda callbacks for serial commands
+
+**Loop() improvements:**
+- Clear pipeline stages:
+  1. Input Processing (serial + RC)
+  2. Sensor Fusion (IMU + attitude)
+  3. Safety Evaluation (horizon + calibration + ground gates)
+  4. Control Pipeline (angle PID → rate PID)
+  5. Motor Output (mixer + anti-windup)
+  6. Telemetry
+- Consistent naming: `snake_case` for local variables
+- Used `FlightConfig::SAT_THRESHOLD` instead of magic `0.1f`
+
+**CalConfig Migration:**
+- Changed from global object `g_cal_cfg` to static class `CalConfig::`
+- All references updated in `arm_calibration.cpp` and `imu.cpp`
+- No config.cpp file needed anymore
+
+**Build Results:**
+- ✅ SUCCESS (RAM: 13.6%, Flash: 55.5%)
+- +100 bytes RAM (+0.1%)
+- +156 bytes Flash (+0.02%)
+- **Zero behavior changes** - pure refactoring
+
+**Code Quality Improvements:**
+- ❌ Removed `String` (heap allocation danger)
+- ✅ Added `const` correctness
+- ✅ Encapsulated global state
+- ✅ Clear separation of concerns
+- ✅ RAII-friendly design
+
+**Next Steps:**
+- Phase 3: Main loop cleanup and conditional compilation simplification
+

firmware/app/flight_controller.cpp

@@ -0,0 +1,91 @@
+#include "flight_controller.h"
+#include "config.h"
+
+FlightController::FlightController()
+    : pid_angle_roll_(PIDConfig::AngleGains::ROLL_KP,
+                      PIDConfig::AngleGains::ROLL_KI,
+                      PIDConfig::AngleGains::ROLL_KD)
+    , pid_angle_pitch_(PIDConfig::AngleGains::PITCH_KP,
+                       PIDConfig::AngleGains::PITCH_KI,
+                       PIDConfig::AngleGains::PITCH_KD)
+    , pid_rate_roll_(PIDConfig::RateGains::ROLL_KP,
+                     PIDConfig::RateGains::ROLL_KI,
+                     PIDConfig::RateGains::ROLL_KD)
+    , pid_rate_pitch_(PIDConfig::RateGains::PITCH_KP,
+                      PIDConfig::RateGains::PITCH_KI,
+                      PIDConfig::RateGains::PITCH_KD)
+    , pid_rate_yaw_(PIDConfig::RateGains::YAW_KP,
+                    PIDConfig::RateGains::YAW_KI,
+                    PIDConfig::RateGains::YAW_KD)
+    , motor_scale_{1.0f, 1.0f, 1.0f, 1.0f}
+{
+}
+
+void FlightController::init() {
+    // Configure angle PID limits
+    pid_angle_roll_.setOutputLimits(PIDConfig::Limits::ANGLE_OUT_MIN,
+                                     PIDConfig::Limits::ANGLE_OUT_MAX);
+    pid_angle_roll_.setIntegralLimits(0.0f, 0.0f);  // No integral on angle PIDs
+
+    pid_angle_pitch_.setOutputLimits(PIDConfig::Limits::ANGLE_OUT_MIN,
+                                      PIDConfig::Limits::ANGLE_OUT_MAX);
+    pid_angle_pitch_.setIntegralLimits(0.0f, 0.0f);
+
+    // Configure rate PID limits
+    pid_rate_roll_.setOutputLimits(PIDConfig::Limits::RATE_OUT_MIN,
+                                    PIDConfig::Limits::RATE_OUT_MAX);
+    pid_rate_roll_.setIntegralLimits(PIDConfig::Limits::RATE_I_MIN,
+                                      PIDConfig::Limits::RATE_I_MAX);
+
+    pid_rate_pitch_.setOutputLimits(PIDConfig::Limits::RATE_OUT_MIN,
+                                     PIDConfig::Limits::RATE_OUT_MAX);
+    pid_rate_pitch_.setIntegralLimits(PIDConfig::Limits::RATE_I_MIN,
+                                       PIDConfig::Limits::RATE_I_MAX);
+
+    // Configure yaw PID limits
+    pid_rate_yaw_.setOutputLimits(PIDConfig::Limits::RATE_OUT_MIN,
+                                   PIDConfig::Limits::RATE_OUT_MAX);
+    pid_rate_yaw_.setIntegralLimits(PIDConfig::Limits::YAW_I_MIN,
+                                     PIDConfig::Limits::YAW_I_MAX);
+}
+
+void FlightController::reset_all() {
+    pid_angle_roll_.reset();
+    pid_angle_pitch_.reset();
+    pid_rate_roll_.reset();
+    pid_rate_pitch_.reset();
+    pid_rate_yaw_.reset();
+}
+
+float FlightController::compute_angle_roll(float setpoint, float measurement, float dt) {
+    return pid_angle_roll_.step(setpoint, measurement, dt);
+}
+
+float FlightController::compute_angle_pitch(float setpoint, float measurement, float dt) {
+    return pid_angle_pitch_.step(setpoint, measurement, dt);
+}
+
+float FlightController::compute_rate_roll(float setpoint, float measurement, float dt) {
+    return pid_rate_roll_.step(setpoint, measurement, dt);
+}
+
+float FlightController::compute_rate_pitch(float setpoint, float measurement, float dt) {
+    return pid_rate_pitch_.step(setpoint, measurement, dt);
+}
+
+float FlightController::compute_rate_yaw(float setpoint, float measurement, float dt, bool allow_integral) {
+    return pid_rate_yaw_.stepConditional(setpoint, measurement, dt, allow_integral);
+}
+
+void FlightController::apply_anti_windup(float sat_roll, float sat_pitch, float sat_yaw, float dt) {
+    const float K_aw = FlightConfig::K_ANTIWINDUP;
+    pid_rate_roll_.applyAntiWindup(sat_roll, dt, K_aw);
+    pid_rate_pitch_.applyAntiWindup(sat_pitch, dt, K_aw);
+    pid_rate_yaw_.applyAntiWindup(sat_yaw, dt, K_aw);
+}
+
+void FlightController::set_motor_scale(const MotorScaleArray& scale) {
+    for (int i = 0; i < MAX_MOTORS; i++) {
+        motor_scale_[i] = scale[i];
+    }
+}

firmware/app/flight_controller.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "pid.h"
+#include "mixer.h"
+
+// FlightController encapsulates all PID controllers and motor scaling
+class FlightController {
+public:
+    FlightController();
+
+    // Initialize with config values
+    void init();
+
+    // Reset all PIDs (called on disarm)
+    void reset_all();
+
+    // Angle PIDs (outer loop: degrees -> deg/s setpoint)
+    float compute_angle_roll(float setpoint, float measurement, float dt);
+    float compute_angle_pitch(float setpoint, float measurement, float dt);
+
+    // Rate PIDs (inner loop: deg/s -> control output)
+    float compute_rate_roll(float setpoint, float measurement, float dt);
+    float compute_rate_pitch(float setpoint, float measurement, float dt);
+
+    // Yaw rate PID with conditional integration
+    float compute_rate_yaw(float setpoint, float measurement, float dt, bool allow_integral);
+
+    // Apply anti-windup correction from motor saturation
+    void apply_anti_windup(float sat_roll, float sat_pitch, float sat_yaw, float dt);
+
+    // Motor scaling accessors
+    const MotorScaleArray& get_motor_scale() const { return motor_scale_; }
+    void set_motor_scale(const MotorScaleArray& scale);  // Implemented in .cpp (array copy)
+
+private:
+    // PID controllers
+    PID pid_angle_roll_;
+    PID pid_angle_pitch_;
+    PID pid_rate_roll_;
+    PID pid_rate_pitch_;
+    PID pid_rate_yaw_;
+
+    // Motor scaling (CW vs CCW trim)
+    MotorScaleArray motor_scale_;
+};

firmware/app/input_processor.cpp

@@ -0,0 +1,28 @@
+#include "input_processor.h"
+#include <string.h>
+
+InputProcessor::InputProcessor() {
+    memset(&packet_, 0, sizeof(packet_));
+}
+
+void InputProcessor::update_from_radio(const volatile RcPacket& volatile_packet) {
+    // Thread-safe copy from volatile
+    memcpy(&packet_, (const void*)&volatile_packet, sizeof(RcPacket));
+
+    // Apply deadband to stick inputs
+    packet_.roll = apply_deadband(packet_.roll, FlightConfig::RC_DEADBAND);
+    packet_.pitch = apply_deadband(packet_.pitch, FlightConfig::RC_DEADBAND);
+    packet_.yaw = apply_deadband(packet_.yaw, FlightConfig::RC_DEADBAND);
+}
+
+float InputProcessor::get_angle_roll_setpoint() const {
+    return rc_to_angle(packet_.roll, FlightConfig::ANG_MAX_DEG);
+}
+
+float InputProcessor::get_angle_pitch_setpoint() const {
+    return rc_to_angle(packet_.pitch, FlightConfig::ANG_MAX_DEG);
+}
+
+float InputProcessor::get_yaw_rate_setpoint() const {
+    return rc_to_rate(packet_.yaw, FlightConfig::YAW_RATE_MAX_DPS);
+}

firmware/app/input_processor.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "rc_packet.h"
+
+// InputProcessor handles safe RC packet access and preprocessing
+class InputProcessor {
+public:
+    InputProcessor();
+
+    // Update from volatile radio packet (thread-safe copy)
+    void update_from_radio(const volatile RcPacket& volatile_packet);
+
+    // Get preprocessed RC inputs (deadband applied)
+    const RcPacket& get_packet() const { return packet_; }
+
+    // Extract flags
+    bool is_arm_flag_set() const { return (packet_.flags & 0x01) != 0; }
+    bool is_cal_flag_set() const { return (packet_.flags & 0x02) != 0; }
+
+    // Convert RC values to control setpoints
+    float get_angle_roll_setpoint() const;
+    float get_angle_pitch_setpoint() const;
+    float get_yaw_rate_setpoint() const;
+
+private:
+    RcPacket packet_;
+};