嵌入式系统中的硬件中断与C++实现挑战

1. 硬件中断基础与C++实现挑战

在嵌入式系统开发中，硬件中断是实现实时响应的核心机制。当外设需要处理器注意时（如数据到达、定时器触发等），会通过中断信号打断当前程序流，转而执行预先定义的中断服务例程（ISR）。这种异步处理方式相比轮询（polling）能显著提高系统效率。

1.1 中断处理的核心组件

典型的中断处理流程涉及以下硬件和软件组件：

• 中断控制器：管理多个中断源，决定优先级和路由
• 中断向量表：存储各中断类型对应ISR地址的内存区域
• 设备寄存器：包括控制寄存器、状态寄存器和数据寄存器
• ISR：实际处理中断的代码，需快速执行且避免阻塞

在ARM架构中，常见两种中断类型：

• IRQ（Interrupt Request）：普通中断，可被更高优先级中断抢占
• FIQ（Fast Interrupt Request）：快速中断，有专用寄存器减少上下文保存开销

1.2 C++实现中断的特殊挑战

标准C++在设计上并未考虑中断服务这种底层场景，这带来几个关键问题：

1. 调用约定不匹配：

   • ISR通常不遵循标准函数调用约定
   • 需要特殊指令进入/退出（如ARM的subs pc, lr, #4）
   • 寄存器保存/恢复需手动处理

2. 语言特性限制：

   • 成员函数隐含this指针参数，不适合作为ISR
   • 异常处理在ISR中不可靠
   • 动态内存分配可能引发竞态条件

3. 平台依赖性：

   • 中断向量表位置和格式因架构而异
   • 设备寄存器访问需要特定内存地址操作

为解决这些问题，实际开发中通常采用混合编程模式：用汇编处理底层机制，C++实现业务逻辑。例如ARM开发中常见的模式：

assembly复制; ARM汇编示例：直接ISR
IRQ_Handler:
    STMFD   SP!, {R0-R12, LR}  ; 保存寄存器
    BL      CppIRQHandler      ; 调用C++处理函数
    LDMFD   SP!, {R0-R12, LR}  ; 恢复寄存器
    SUBS    PC, LR, #4         ; 中断返回

对应的C++声明需使用extern "C"防止名称修饰：

cpp复制extern "C" void CppIRQHandler();

2. 内存映射设备与寄存器操作

嵌入式系统中，处理器通过读写设备寄存器与外设通信。这些寄存器通常被映射到特定的内存地址，称为内存映射I/O（Memory-Mapped I/O）。

2.1 设备寄存器建模

在C++中，我们可以用volatile修饰符确保编译器不会优化掉寄存器访问，并用类封装相关寄存器：

cpp复制class UART {
public:
    enum Status { RDR = 0x20, TBE = 0x40 };
    enum Mode { RXM = 1, TXM = 8 };
    
    bool ready_to_send() const { 
        return (USTAT & TBE) != 0; 
    }
    
    void send(uint8_t data) { 
        UTXBUF = data; 
    }

private:
    volatile uint32_t* const ULCON;  // 线路控制寄存器
    volatile uint32_t* const UCON;   // 控制寄存器
    volatile const uint32_t* USTAT;  // 状态寄存器
    volatile uint32_t* const UTXBUF; // 发送缓冲区
};

寄存器地址通常通过指针直接映射：

cpp复制// 映射UART0到地址0x3FFD000
UART& uart0 = *reinterpret_cast<UART*>(0x3FFD000);

关键点：volatile确保每次访问都实际发生，防止编译器优化掉"看似无用"的寄存器操作。const修饰的状态寄存器指针确保不会意外写入。

2.2 中断控制器的操作

中断控制器是管理多个中断源的核心组件，典型操作包括：

1. 查询中断源：通过中断挂起寄存器(INTPND)识别触发中断的设备
2. 清除中断：向特定位写入1清除中断标志
3. 屏蔽控制：通过中断屏蔽寄存器(INTMSK)启用/禁用特定中断

C++封装示例：

cpp复制class InterruptController {
public:
    enum Device {
        BUTTON = 0x01,
        TIMER0 = 0x400,
        UART0  = 0x1000
    };
    
    bool is_pending(Device dev) const {
        return (INTPND & dev) != 0;
    }
    
    void clear(Device dev) {
        INTPND = dev;  // 注意：这里是赋值而非位操作
    }
    
    void enable(Device dev) {
        INTMSK &= ~dev;
    }
    
    void disable(Device dev) {
        INTMSK |= dev;
    }

private:
    volatile uint32_t* const INTMSK;
    volatile uint32_t* const INTPND;
};

3. 中断服务例程的实现策略

3.1 直接ISR与间接ISR架构

为平衡效率和可维护性，通常采用两级ISR结构：

1. 直接ISR（汇编实现）：

   • 保存/恢复上下文
   • 调用间接ISR
   • 处理中断返回指令

2. 间接ISR（C++实现）：

   • 实际业务逻辑
   • 设备状态处理
   • 中断清除操作

这种分离使得：

• 架构相关的上下文处理由汇编高效完成
• 业务逻辑可用C++方便实现和维护
• 避免在C++中嵌入平台特定汇编

3.2 中断分发器设计

当多个设备共享同一中断线时，需要中断分发机制。经典实现方式包括：

1. 条件分支式分发：

cpp复制void IRQ_Handler() {
    if (ctrl.is_pending(BUTTON)) {
        handle_button();
        ctrl.clear(BUTTON);
    }
    if (ctrl.is_pending(TIMER0)) {
        handle_timer();
        ctrl.clear(TIMER0);
    }
    // ...更多设备判断
}

2. 表驱动式分发（更灵活）：

cpp复制using Handler = void(*)();
extern Handler handlers[];

void IRQ_Dispatcher() {
    for (int i = 0; i < MAX_DEVICES; ++i) {
        if (ctrl.is_pending(1 << i)) {
            if (handlers[i]) handlers[i]();
            ctrl.clear(1 << i);
        }
    }
}

3. 面向对象分发（推荐）：

定义抽象中断设备接口：

cpp复制class InterruptHandler {
public:
    virtual ~InterruptHandler() = default;
    virtual void handle() = 0;
    virtual uint32_t device_id() const = 0;
};

class InterruptSystem {
    std::array<InterruptHandler*, 32> handlers_{};
public:
    void register_handler(InterruptHandler* h) {
        handlers_[h->device_id()] = h;
    }
    
    void dispatch() {
        for (size_t i = 0; i < handlers_.size(); ++i) {
            if (ctrl.is_pending(1 << i) && handlers_[i]) {
                handlers_[i]->handle();
                ctrl.clear(1 << i);
            }
        }
    }
};

具体设备实现示例：

cpp复制class ButtonHandler : public InterruptHandler {
public:
    void handle() override {
        // 处理按钮按下逻辑
    }
    
    uint32_t device_id() const override {
        return 0; // 对应BUTTON的位位置
    }
};

4. 中断环境下的数据共享与同步

中断上下文与主程序之间的数据共享是嵌入式开发的常见痛点，不当处理会导致竞态条件。

4.1 同步机制选择

1. 中断屏蔽：

   cpp复制ctrl.disable(TIMER0);  // 屏蔽定时器中断
   shared_data.update();  // 安全访问
   ctrl.enable(TIMER0);   // 重新启用
   

   • 优点：实现简单
   • 缺点：增加中断延迟，可能丢失快速连续的中断

2. 原子操作：

   cpp复制std::atomic<uint32_t> counter;
   // 在ISR中：
   counter.fetch_add(1, std::memory_order_relaxed);
   

   • 优点：无锁，性能好
   • 缺点：仅适用于简单数据类型

3. 无锁队列（生产者-消费者模式）：

   cpp复制RingBuffer<Event, 16> event_queue;
   
   // ISR（生产者）：
   event_queue.push(event);
   
   // 主循环（消费者）：
   while (auto event = event_queue.pop()) {
       process(*event);
   }
   

4.2 设计线程安全的共享资源

对于复杂数据结构，推荐使用"监控模式"（Monitor Pattern）：

cpp复制template <typename T>
class InterruptSafe {
    T value_;
    InterruptController& ctrl_;
    uint32_t mask_;
public:
    template <typename F>
    auto access(F&& f) {
        ctrl_.disable(mask_);
        auto guard = finally([this]{ ctrl_.enable(mask_); });
        return f(value_);
    }
    
    // 仅限ISR使用的无锁访问
    template <typename F> 
    auto unsafe_access(F&& f) {
        return f(value_);
    }
};

// 使用示例：
InterruptSafe<SensorData> sensor;
sensor.access([](auto& data) {
    data.calibrate();
});

关键原则：ISR应尽可能简单地收集数据，将复杂处理留给主循环。典型模式是ISR只设置标志或填充缓冲区，主循环定期检查并处理。

5. 性能优化与调试技巧

5.1 中断性能关键指标

1. 延迟（Latency）：

   • 从中断发生到ISR开始执行的时间
   • 受中断屏蔽、优先级设置影响

2. 执行时间：

   • ISR本身的执行时长
   • 应保持在最小必要程度

3. 抖动（Jitter）：

   • 中断响应时间的变化范围
   • 对实时系统尤为重要

5.2 优化策略

代码布局优化：

ld复制/* 链接脚本片段 */
.isr_vector : {
    KEEP(*(.isr_vector))
    . = ALIGN(4);
} > FLASH

.fast_code : {
    *(.text.IRQ_Handler)
    *(.text.FIQ_Handler)
    . = ALIGN(4);
} > RAM AT> FLASH

ISR内联优化：

cpp复制__attribute__((always_inline)) 
inline void handle_timer() {
    // 关键路径代码
}

数据缓存策略：

cpp复制// 使用C++11的alignas确保缓存行对齐
struct alignas(64) SharedData {
    std::atomic<uint32_t> counter;
    // ...
};

5.3 调试技巧

1. 引脚调试法：

   cpp复制// 在ISR开始和结束切换GPIO状态
   void IRQ_Handler() {
       GPIO::set(DEBUG_PIN);
       // ...处理逻辑
       GPIO::clear(DEBUG_PIN);
   }
   

   用示波器观察引脚电平变化，测量执行时间。

2. 事件追踪：

   cpp复制struct TraceEvent {
       uint32_t timestamp;
       uint8_t event_id;
   };
   
   RingBuffer<TraceEvent, 64> trace_log;
   
   void log_event(uint8_t id) {
       trace_log.push({DWT->CYCCNT, id});
   }
   

3. 栈使用分析：

   asm复制; 在启动代码中填充栈模式
   LDR R0, =0xAAAAAAAA
   LDR R1, =__stack_end__
   LDR R2, =__stack_start__
   fill_stack:
       CMP R1, R2
       STR R0, [R1], #4
       BNE fill_stack
   

   运行时检查栈内存，确定最大使用量。

6. 高级模式与设计模式应用

6.1 观察者模式在中断中的应用

cpp复制class InterruptSubject {
    std::vector<InterruptObserver*> observers_;
public:
    void attach(InterruptObserver* o) {
        observers_.push_back(o);
    }
    
    void notify() {
        for (auto o : observers_) {
            o->update();
        }
    }
};

class TimerInterrupt : public InterruptHandler {
    InterruptSubject subject_;
public:
    void handle() override {
        subject_.notify();
        ctrl.clear(TIMER0);
    }
    
    void attach(InterruptObserver* o) {
        subject_.attach(o);
    }
};

6.2 状态模式处理复杂中断逻辑

cpp复制class UARTState {
public:
    virtual ~UARTState() = default;
    virtual void handle_rx(uint8_t data) = 0;
    virtual void handle_tx() = 0;
};

class UARTIdle : public UARTState {
    void handle_rx(uint8_t data) override {
        buffer.push(data);
        if (buffer.full()) {
            context.transition_to<UARTOverflow>();
        }
    }
    // ...
};

class UARTHandler : public InterruptHandler {
    std::unique_ptr<UARTState> state_;
public:
    void handle() override {
        if (uart.status() & RX_INT) {
            state_->handle_rx(uart.read());
        }
        if (uart.status() & TX_INT) {
            state_->handle_tx();
        }
    }
    
    template <typename S>
    void transition_to() {
        state_ = std::make_unique<S>(*this);
    }
};

6.3 策略模式实现平台抽象

cpp复制class InterruptStrategy {
public:
    virtual void enable(uint32_t irq) = 0;
    virtual void disable(uint32_t irq) = 0;
    virtual void set_priority(uint32_t irq, uint32_t prio) = 0;
    virtual ~InterruptStrategy() = default;
};

class CortexMStrategy : public InterruptStrategy {
    void enable(uint32_t irq) override {
        NVIC_EnableIRQ(irq);
    }
    // ...其他实现
};

class InterruptManager {
    std::unique_ptr<InterruptStrategy> strategy_;
public:
    void init(InterruptStrategy* s) {
        strategy_.reset(s);
    }
    
    void enable(uint32_t irq) {
        strategy_->enable(irq);
    }
    // ...其他转发方法
};

7. 测试与验证策略

7.1 单元测试框架适配

cpp复制class MockUART : public UARTInterface {
    std::queue<uint8_t> rx_queue_;
    std::vector<uint8_t> tx_buffer_;
public:
    void mock_receive(uint8_t data) {
        rx_queue_.push(data);
        trigger_interrupt();
    }
    
    uint8_t read() override {
        auto data = rx_queue_.front();
        rx_queue_.pop();
        return data;
    }
    
    bool has_data() const override {
        return !rx_queue_.empty();
    }
    
    const auto& transmitted() const {
        return tx_buffer_;
    }
};

TEST(UARTTest, ReceptionTest) {
    MockUART uart;
    UARTHandler handler(uart);
    
    uart.mock_receive(0x55);
    handler.handle();
    
    EXPECT_TRUE(handler.has_data());
    EXPECT_EQ(handler.read(), 0x55);
}

7.2 硬件在环测试

cpp复制class TestHarness {
    GPIOMock& gpio_;
    SPIStub& spi_;
    InterruptControllerMock& int_ctrl_;
public:
    void trigger_interrupt(uint32_t source) {
        int_ctrl_.set_pending(source);
        while (int_ctrl_.is_pending(source)) {
            // 等待ISR清除中断
        }
        
        // 验证后续状态
        EXPECT_EQ(gpio_.get(READY_PIN), HIGH);
        EXPECT_EQ(spi_.tx_count(), 1);
    }
};

TEST_F(HardwareTest, TimerInterruptTest) {
    harness.trigger_interrupt(TIMER0);
    EXPECT_EQ(system.counter(), 1);
}

7.3 静态分析与验证

1. 栈使用分析：

   bash复制arm-none-eabi-objdump -t firmware.elf | grep _stack
   arm-none-eabi-nm --size-sort firmware.elf
   

2. 中断冲突检测：

   python复制# 分析中断向量表配置
   def check_priorities(vector_table):
       for i, entry in enumerate(vector_table):
           for j, other in enumerate(vector_table[i+1:], i+1):
               if entry.priority == other.priority:
                   warn(f"冲突优先级：IRQ{i}和IRQ{j}")
   

3. 最坏执行时间分析：

   cpp复制// 使用模板元编程静态计算循环次数
   template <size_t N>
   struct Loop {
       static constexpr size_t cycles = 
           Loop<N-1>::cycles + 3;
   };
   
   template <>
   struct Loop<0> {
       static constexpr size_t cycles = 1;
   };
   
   static_assert(Loop<10>::cycles <= 100, 
       "循环超出时间预算");
   

8. 实际案例：UART中断驱动实现

8.1 硬件初始化

cpp复制void init_uart(UART& uart, uint32_t baudrate) {
    // 1. 配置GPIO复用功能
    GPIO::set_alternate(UART_TX_PIN, GPIO::AF7);
    GPIO::set_alternate(UART_RX_PIN, GPIO::AF7);
    
    // 2. 配置UART参数
    uart.set_baudrate(baudrate);
    uart.set_data_bits(8);
    uart.set_stop_bits(1);
    uart.set_parity(UART::Parity::None);
    
    // 3. 使能中断
    uart.enable_rx_interrupt();
    uart.enable_tx_interrupt(false); // 初始禁用TX中断
    
    // 4. 注册中断处理程序
    interrupt_manager.register_handler(
        UART_IRQn, 
        []{ uart_handler.handle(); }
    );
    
    // 5. 全局使能
    uart.enable();
}

8.2 中断处理实现

cpp复制class UARTInterruptHandler {
    RingBuffer<uint8_t, 64> rx_buf_;
    RingBuffer<uint8_t, 64> tx_buf_;
    UART& uart_;
public:
    void handle() {
        // 处理接收中断
        if (uart_.is_rx_interrupt()) {
            while (uart_.has_data()) {
                rx_buf_.push(uart_.read());
            }
            uart_.clear_rx_interrupt();
        }
        
        // 处理发送中断
        if (uart_.is_tx_interrupt()) {
            if (tx_buf_.empty()) {
                uart_.enable_tx_interrupt(false);
            } else {
                uart_.write(tx_buf_.pop());
            }
            uart_.clear_tx_interrupt();
        }
    }
    
    void send(std::span<const uint8_t> data) {
        bool was_empty = tx_buf_.empty();
        for (auto b : data) {
            tx_buf_.push(b);
        }
        if (was_empty) {
            uart_.enable_tx_interrupt(true);
        }
    }
    
    size_t receive(std::span<uint8_t> out) {
        size_t i = 0;
        while (i < out.size() && !rx_buf_.empty()) {
            out[i++] = rx_buf_.pop();
        }
        return i;
    }
};

8.3 流量控制优化

cpp复制class FlowControlledUART : public UARTInterruptHandler {
    static constexpr size_t HIGH_WATER = 56;
    static constexpr size_t LOW_WATER = 8;
    
    void handle_rx() override {
        UARTInterruptHandler::handle_rx();
        
        // 硬件流控
        if (rx_buf_.size() >= HIGH_WATER) {
            uart_.set_rts(false); // 请求对方暂停
        } else if (rx_buf_.size() <= LOW_WATER) {
            uart_.set_rts(true);  // 恢复传输
        }
        
        // 软件流控
        if (rx_buf_.size() > HIGH_WATER) {
            send({XOFF});
            flow_status_ = STOPPED;
        }
    }
    
    void handle_tx() override {
        if (flow_status_ == STOPPED && 
            rx_buf_.size() < LOW_WATER) {
            send({XON});
            flow_status_ = RUNNING;
        }
        UARTInterruptHandler::handle_tx();
    }
};

9. 中断安全的数据结构

9.1 无锁环形缓冲区

cpp复制template <typename T, size_t N>
class RingBuffer {
    std::array<T, N> buffer_;
    std::atomic<size_t> head_{0};
    std::atomic<size_t> tail_{0};
public:
    bool push(T item) {
        size_t next_head = (head_ + 1) % N;
        if (next_head == tail_) return false;
        
        buffer_[head_] = item;
        head_.store(next_head, std::memory_order_release);
        return true;
    }
    
    bool pop(T& out) {
        if (tail_ == head_) return false;
        
        out = buffer_[tail_];
        tail_.store((tail_ + 1) % N, std::memory_order_release);
        return true;
    }
    
    bool empty() const {
        return head_.load(std::memory_order_acquire) == 
               tail_.load(std::memory_order_acquire);
    }
};

9.2 中断安全的共享标志

cpp复制class AtomicFlag {
    std::atomic<bool> flag_{false};
    uint32_t interrupt_mask_;
    InterruptController& ctrl_;
public:
    void set() {
        flag_.store(true, std::memory_order_release);
    }
    
    bool test_and_clear() {
        InterruptGuard guard(ctrl_, interrupt_mask_);
        bool expected = true;
        return flag_.compare_exchange_strong(
            expected, false, 
            std::memory_order_acq_rel
        );
    }
};

9.3 延迟处理机制

cpp复制class DeferredWork {
    struct Task {
        void (*function)(void*);
        void* arg;
    };
    
    RingBuffer<Task, 16> queue_;
    InterruptController& ctrl_;
public:
    void defer(void (*fn)(void*), void* arg) {
        if (!queue_.push({fn, arg})) {
            // 错误处理：队列满
        }
    }
    
    void process_all() {
        Task task;
        while (queue_.pop(task)) {
            task.function(task.arg);
        }
    }
    
    // 从中断上下文安全调用
    void defer_from_isr(void (*fn)(void*), void* arg) {
        ctrl_.disable(IRQ_PRIORITY_LOW);
        defer(fn, arg);
        ctrl_.enable(IRQ_PRIORITY_LOW);
    }
};

10. 多核系统中的中断处理

10.1 核间中断(IPI)处理

cpp复制class InterProcessorInterrupt {
    Mailbox<IPI_Message, 8> mailbox_;
public:
    void send(uint32_t cpu_id, IPI_Message msg) {
        // 架构特定的IPI触发
        ARM::send_ipi(cpu_id, IPI_IRQ);
        
        // 可选的消息传递
        if (msg != NO_MESSAGE) {
            remote_mailbox(cpu_id).post(msg);
        }
    }
    
    void handle() {
        IPI_Message msg;
        while (mailbox_.pop(msg)) {
            switch (msg.type) {
                case CACHE_FLUSH:
                    SCB_CleanDCache();
                    break;
                case TASK_MIGRATION:
                    schedule_task(msg.task);
                    break;
            }
        }
    }
};

10.2 中断负载均衡

cpp复制class InterruptBalancer {
    std::array<uint32_t, MAX_CORES> load_{};
    std::array<std::bitset<MAX_IRQS>, MAX_CORES> affinity_{};
public:
    void balance() {
        auto min_core = std::min_element(load_.begin(), load_.end());
        size_t core_idx = std::distance(load_.begin(), min_core);
        
        for (int irq = 0; irq < MAX_IRQS; ++irq) {
            if (is_balanceable(irq)) {
                set_affinity(irq, core_idx);
                load_[core_idx] += estimate_load(irq);
            }
        }
    }
    
    void on_interrupt(uint32_t irq) {
        auto core = current_core();
        load_[core] += actual_load(irq);
        
        if (should_rebalance()) {
            send_ipi(BALANCER_CPU, REBALANCE_MSG);
        }
    }
};

10.3 核间同步原语

cpp复制class CrossCoreLock {
    std::atomic<uint32_t> lock_{0};
    uint32_t const core_id_;
public:
    void acquire() {
        uint32_t expected = 0;
        while (!lock_.compare_exchange_weak(
            expected, core_id_,
            std::memory_order_acquire,
            std::memory_order_relaxed
        )) {
            expected = 0;
            WFE(); // Wait For Event指令降低功耗
        }
    }
    
    void release() {
        lock_.store(0, std::memory_order_release);
        SEV(); // Send Event唤醒其他核
    }
};

11. 低功耗场景下的中断优化

11.1 唤醒中断配置

cpp复制class LowPowerManager {
    enum WakeSource {
        RTC_ALARM = 0x1,
        BUTTON    = 0x2,
        UART      = 0x4
    };
    
    uint32_t enabled_sources_{0};
public:
    void enter_standby() {
        // 配置唤醒源
        SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
        PWR->CR |= PWR_CR_PDDS;
        PWR->CSR |= PWR_CSR_EWUP; // 使能唤醒引脚
        
        // 根据enabled_sources_配置具体外设
        if (enabled_sources_ & RTC_ALARM) {
            RTC->CR |= RTC_CR_ALRAIE;
        }
        
        __WFI(); // 进入待机模式
    }
    
    void enable_wakeup(WakeSource src) {
        uint32_t prev = __disable_irqs();
        enabled_sources_ |= src;
        __restore_irqs(prev);
    }
};

11.2 中断频率调节

cpp复制class DynamicTickAdjuster {
    uint32_t current_interval_{DEFAULT_INTERVAL};
    uint32_t min_interval_{MIN_INTERVAL};
    uint32_t max_interval_{MAX_INTERVAL};
    
    void adjust_based_on_load(uint32_t cpu_load) {
        uint32_t new_interval = current_interval_;
        
        if (cpu_load > HIGH_THRESHOLD) {
            new_interval = std::max(
                min_interval_, 
                current_interval_ - STEP_SIZE
            );
        } else if (cpu_load < LOW_THRESHOLD) {
            new_interval = std::min(
                max_interval_,
                current_interval_ + STEP_SIZE
            );
        }
        
        if (new_interval != current_interval_) {
            Timer::reconfigure(new_interval);
            current_interval_ = new_interval;
        }
    }
};

11.3 中断合并技术

cpp复制class InterruptCoalescer {
    Timer& timer_;
    uint32_t pending_events_{0};
    uint32_t event_mask_{0};
    std::function<void(uint32_t)> handler_;
public:
    void on_event(uint32_t event) {
        uint32_t prev = __disable_irqs();
        pending_events_ |= event;
        if ((pending_events_ & event_mask_) && !timer_.is_running()) {
            timer_.start(COALESCE_TIMEOUT);
        }
        __restore_irqs(prev);
    }
    
    void on_timeout() {
        uint32_t events = 0;
        {
            uint32_t prev = __disable_irqs();
            events = pending_events_;
            pending_events_ = 0;
            __restore_irqs(prev);
        }
        handler_(events);
    }
};

12. 安全关键系统中的中断设计

12.1 双重验证机制

cpp复制class SafetyCriticalHandler {
    PrimaryHandler primary_;
    SecondaryHandler secondary_;
    CrossCheckMonitor monitor_;
public:
    void handle() {
        auto primary_result = primary_.handle();
        auto secondary_result = secondary_.handle();
        
        if (!monitor_.check(primary_result, secondary_result)) {
            SafetySystem::trigger_shutdown();
            return;
        }
        
        // 执行安全操作
        actuator_.apply(primary_result);
    }
};

12.2 心跳监控设计

cpp复制class WatchdogManager {
    Timer& timer_;
    std::array<bool, MAX_TASKS> heartbeats_{};
    uint32_t const timeout_;
public:
    void check_heartbeats() {
        bool all_ok = true;
        for (auto& hb : heartbeats_) {
            if (!hb) {
                all_ok = false;
                break;
            }
            hb = false; // 重置标志
        }
        
        if (!all_ok) {
            SafetySystem::trigger_reset();
        }
    }
    
    void feed(uint32_t task_id) {
        if (task_id < heartbeats_.size()) {
            heartbeats_[task_id] = true;
        }
    }
};

12.3 冗余中断处理

cpp复制class RedundantInterruptSystem {
    struct Channel {
        InterruptController hw;
        bool active;
        uint32_t last_count;
    };
    
    std::array<Channel, 2> channels_;
    uint32_t tolerance_;
public:
    void handle_interrupt() {
        bool primary_ok = check_channel(0);
        bool secondary_ok = check_channel(1);
        
        if (primary_ok && secondary_ok) {
            if (abs_diff(channels_[0].last_count, 
                        channels_[1].last_count) > tolerance_) {
                enter_safe_state();
                return;
            }
            normal_operation();
        } 
        else if (primary_ok) {
            degraded_operation(0);
        }
        else if (secondary_ok) {
            degraded_operation(1);
        }
        else {
            enter_safe_state();
        }
    }
};

13. 调试与性能分析实战

13.1 中断时间测量技术

cpp复制class InterruptProfiler {
    struct Sample {
        uint32_t timestamp;
        uint32_t irq_num;
        uint32_t duration;
    };
    
    RingBuffer<Sample, 128> samples_;
    uint32_t start_time_;
    uint32_t current_irq_;
public:
    void pre_handler(uint32_t irq) {
        current_irq_ = irq;
        start_time_ = DWT->CYCCNT;
    }
    
    void post_handler() {
        uint32_t end_time = DWT->CYCCNT;
        uint32_t duration = end_time - start_time_;
        
        if (!samples_.push({end_time, current_irq_, duration})) {
            // 缓冲区满处理
        }
    }
    
    void dump_stats() {
        uint32_t counts[MAX_IRQ] = {0};
        uint32_t totals[MAX_IRQ] = {0};
        
        Sample s;
        while (samples_.pop(s)) {
            counts[s.irq_num]++;
            totals[s.irq_num] += s.duration;
        }
        
        for (int i = 0; i < MAX_IRQ; ++i) {
            if (counts[i] > 0) {
                printf("IRQ%d: count=%u, avg=%uus, total=%uus\n",
                    i, counts[i], 
                    totals[i]/counts[i]/CPU_FREQ_MHZ,
                    totals[i]/CPU_FREQ_MHZ);
            }
        }
    }
};

13.2 中断冲突检测

cpp复制class InterruptCollisionDetector {
    struct Event {
        uint32_t timestamp;
        uint32_t irq;
        bool entry;
    };
    
    RingBuffer<Event, 256> log_;
    uint32_t nesting_ = 0;
public:
    void log_entry(uint32_t irq) {
        uint32_t ts = DWT->CYCCNT;
        log_.push({ts, irq, true});
        
        if (nesting_++ > 0) {
            printf("警告：中断嵌套！IRQ%d被IRQ%d抢占\n",
                irq, current_irq_);
        }
        current_irq_ = irq;
    }
    
    void log_exit(uint32_t irq) {
        uint32_t ts = DWT->CYCCNT;
        log_.push({ts, irq, false});
        nesting_--;
    }
    
    void analyze() {
        // 检测长时间中断
        // 检测频繁中断
        // 检测优先级反转
    }
};

13.3 实时跟踪技术

cpp复制class TraceRecorder {
    static constexpr size_t BUF_SIZE = 1024;
    struct TracePacket {
        uint32_t timestamp;
        uint16_t event_id;
        uint16_t data;
    };
    
    TracePacket buffer_[BUF_SIZE];
    size_t head_ = 0;
    bool wrapped_ = false;
public:
    void record(uint16_t event, uint16_t data = 0) {
        uint32_t idx = head_++ % BUF_SIZE;
        buffer_[idx] = {
            DWT->CYCCNT,
            event,
            data
        };
        if (head_ >= BUF_SIZE) {
            wrapped_ = true;
            head_ = 0;
        }
    }
    
    void dump() {
        size_t start = wrapped_ ? head_ : 0;
        size_t end = wrapped_ ? BUF_SIZE : head_;
        
        for (size_t i = start; i < end; ++i) {
            auto& p = buffer_[i];
            printf("[%08u] %04x: %04x\n", 
                p.timestamp, p.event_id, p.data);
        }
    }
};

14. 现代C++特性在中断中的应用

14.1 constexpr中断配置

cpp复制struct InterruptConfig {
    uint32_t irq_num;
    uint32_t priority;
    bool enabled;
};

template <size_t N>
constexpr auto sort_by_priority(