嵌入式开发必掌握：RTOS中断管理实战（中断优先级+延迟处理+任务通信+临界区保护）

标签：嵌入式开发、RTOS、FreeRTOS、中断管理、中断优先级、延迟中断、临界区、中断通信、STM32、系统设计

前言

摘要：中断管理是RTOS系统稳定运行的关键，正确配置中断优先级和处理中断与任务的交互至关重要。本文从中断优先级配置、中断服务函数设计、延迟中断处理、中断与任务通信、临界区保护到实时数据采集实战，提供全套可直接量产的代码示例，同时总结中断优先级配置错误、中断中调用阻塞函数、临界区嵌套、中断延迟过长等踩坑经验，帮助开发者掌握高效可靠的RTOS中断管理技术。

中断是嵌入式系统响应外部事件的核心机制，在RTOS环境下，中断与任务的协调配合直接影响系统的实时性和稳定性。正确理解中断优先级配置、中断服务函数设计原则、中断与任务通信机制，是开发高质量RTOS应用的关键。

文章主要内容：

• RTOS中断优先级配置
• 中断服务函数设计原则
• 延迟中断处理机制
• 中断与任务通信
• 临界区保护机制
• 实时数据采集实战
• 中断调试技巧

---

一、RTOS中断优先级配置

1.1 Cortex-M中断优先级

优先级分组说明：

分组	抢占位数	子优先级位数	抢占级别数	子优先级级别数
0	0	4	1	16
1	1	3	2	8
2	2	2	4	4
3	3	1	8	2
4	4	0	16	1

1.2 RTOS中断优先级规则

1.3 中断优先级配置实战

#define configKERNEL_INTERRUPT_PRIORITY         255
#define configMAX_SYSCALL_INTERRUPT_PRIORITY    191

void NVIC_PriorityConfig(void)
{
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
    
    printf("RTOS Interrupt Priority Configuration:\r\n");
    printf("  Kernel Priority: %d (0-255, lower value = higher priority)\r\n", 
           configKERNEL_INTERRUPT_PRIORITY);
    printf("  Max Syscall Priority: %d\r\n", 
           configMAX_SYSCALL_INTERRUPT_PRIORITY);
    printf("  Priority Range for RTOS API: %d-255\r\n", 
           configMAX_SYSCALL_INTERRUPT_PRIORITY);
}

void Interrupt_Priority_Example(void)
{
    NVIC_InitTypeDef NVIC_InitStructure;
    
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 5;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    
    NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 6;
    NVIC_Init(&NVIC_InitStructure);
    
    NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 4;
    NVIC_Init(&NVIC_InitStructure);
}

1.4 中断优先级错误示例

// ❌ 错误：中断优先级高于configMAX_SYSCALL_INTERRUPT_PRIORITY
void Wrong_InterruptPriority(void)
{
    NVIC_InitTypeDef NVIC_InitStructure;
    
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  // 最高优先级！
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
}

// 问题：在USART1中断中调用RTOS API会导致系统崩溃！

void USART1_IRQHandler(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    // ❌ 错误：中断优先级0高于configMAX_SYSCALL_INTERRUPT_PRIORITY
    // 不能调用FromISR函数！
    xQueueSendFromISR(queue, &data, &xHigherPriorityTaskWoken);
    
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

// ✅ 正确：中断优先级低于configMAX_SYSCALL_INTERRUPT_PRIORITY
void Correct_InterruptPriority(void)
{
    NVIC_InitTypeDef NVIC_InitStructure;
    
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 5;  // 优先级5
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
}

---

二、中断服务函数设计原则

2.1 中断服务函数设计准则

2.2 标准中断服务函数模板

SemaphoreHandle_t uart_rx_sem;
QueueHandle_t uart_rx_queue;

void UART_RX_IRQHandler(void)
{
    uint8_t data;
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
    {
        data = USART_ReceiveData(USART1);
        
        xQueueSendFromISR(uart_rx_queue, &data, &xHigherPriorityTaskWoken);
        
        xSemaphoreGiveFromISR(uart_rx_sem, &xHigherPriorityTaskWoken);
        
        USART_ClearITPendingBit(USART1, USART_IT_RXNE);
    }
    
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void EXTI_IRQHandler(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    if(EXTI_GetITStatus(EXTI_Line0) != RESET)
    {
        vTaskNotifyGiveFromISR(task_handle, &xHigherPriorityTaskWoken);
        
        EXTI_ClearITPendingBit(EXTI_Line0);
    }
    
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

2.3 错误的中断服务函数示例

// ❌ 错误示例1：在中断中调用阻塞函数
void Bad_ISR_Handler1(void)
{
    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
    {
        uint8_t data = USART_ReceiveData(USART1);
        
        // ❌ 错误：在中断中调用阻塞函数
        xQueueSend(queue, &data, portMAX_DELAY);
        
        // ❌ 错误：在中断中调用vTaskDelay
        vTaskDelay(pdMS_TO_TICKS(10));
        
        // ❌ 错误：在中断中等待信号量
        xSemaphoreTake(sem, portMAX_DELAY);
    }
}

// ❌ 错误示例2：忘记上下文切换
void Bad_ISR_Handler2(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    xSemaphoreGiveFromISR(sem, &xHigherPriorityTaskWoken);
    
    // ❌ 错误：忘记调用portYIELD_FROM_ISR
    // 可能导致高优先级任务延迟执行
}

// ❌ 错误示例3：中断处理时间过长
void Bad_ISR_Handler3(void)
{
    if(EXTI_GetITStatus(EXTI_Line0) != RESET)
    {
        // ❌ 错误：在中断中执行复杂计算
        for(int i = 0; i < 10000; i++)
        {
            ComplexCalculation();
        }
        
        // ❌ 错误：在中断中等待条件
        while(!CheckCondition());
        
        EXTI_ClearITPendingBit(EXTI_Line0);
    }
}

---

三、延迟中断处理机制

3.1 延迟中断处理原理

3.2 延迟中断处理实现

#define ISR_DATA_BUFFER_SIZE    256

typedef struct
{
    uint8_t buffer[ISR_DATA_BUFFER_SIZE];
    uint16_t write_index;
    uint16_t read_index;
    uint16_t count;
} ISR_Buffer_t;

ISR_Buffer_t isr_buffer = {0};
SemaphoreHandle_t isr_data_sem;
TaskHandle_t isr_handler_task;

void UART_ISR_FastHandler(void)
{
    uint8_t data;
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
    {
        data = USART_ReceiveData(USART1);
        
        if(isr_buffer.count < ISR_DATA_BUFFER_SIZE)
        {
            isr_buffer.buffer[isr_buffer.write_index] = data;
            isr_buffer.write_index = (isr_buffer.write_index + 1) % ISR_DATA_BUFFER_SIZE;
            isr_buffer.count++;
            
            xSemaphoreGiveFromISR(isr_data_sem, &xHigherPriorityTaskWoken);
        }
        
        USART_ClearITPendingBit(USART1, USART_IT_RXNE);
    }
    
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void ISR_Handler_Task(void *pvParameters)
{
    uint8_t data;
    
    while(1)
    {
        if(xSemaphoreTake(isr_data_sem, portMAX_DELAY) == pdTRUE)
        {
            taskENTER_CRITICAL();
            
            if(isr_buffer.count > 0)
            {
                data = isr_buffer.buffer[isr_buffer.read_index];
                isr_buffer.read_index = (isr_buffer.read_index + 1) % ISR_DATA_BUFFER_SIZE;
                isr_buffer.count--;
            }
            
            taskEXIT_CRITICAL();
            
            ProcessData(data);
        }
    }
}

void Deferred_ISR_Init(void)
{
    isr_data_sem = xSemaphoreCreateBinary();
    
    xTaskCreate(ISR_Handler_Task, "ISR_Handler", 256, NULL, 5, &isr_handler_task);
}

3.3 使用队列实现延迟处理

QueueHandle_t adc_data_queue;

typedef struct
{
    uint16_t value;
    uint32_t timestamp;
    uint8_t channel;
} ADC_Data_t;

void ADC_ISR_Handler(void)
{
    ADC_Data_t data;
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    if(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) != RESET)
    {
        data.value = ADC_GetConversionValue(ADC1);
        data.timestamp = xTaskGetTickCountFromISR();
        data.channel = 0;
        
        xQueueSendFromISR(adc_data_queue, &data, &xHigherPriorityTaskWoken);
        
        ADC_ClearFlag(ADC1, ADC_FLAG_EOC);
    }
    
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void ADC_Process_Task(void *pvParameters)
{
    ADC_Data_t data;
    
    while(1)
    {
        if(xQueueReceive(adc_data_queue, &data, portMAX_DELAY) == pdPASS)
        {
            float voltage = (float)data.value * 3.3f / 4095.0f;
            
            printf("ADC Channel %d: %.3fV at %lu\r\n", 
                   data.channel, voltage, data.timestamp);
            
            ProcessADCData(&data);
        }
    }
}

---

四、中断与任务通信

4.1 中断到任务通信方式

4.2 使用信号量通信

SemaphoreHandle_t button_sem;

void Button_ISR_Handler(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    if(EXTI_GetITStatus(EXTI_Line0) != RESET)
    {
        xSemaphoreGiveFromISR(button_sem, &xHigherPriorityTaskWoken);
        
        EXTI_ClearITPendingBit(EXTI_Line0);
    }
    
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void Button_Task(void *pvParameters)
{
    while(1)
    {
        if(xSemaphoreTake(button_sem, portMAX_DELAY) == pdTRUE)
        {
            printf("Button Pressed\r\n");
            
            vTaskDelay(pdMS_TO_TICKS(20));
            
            if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0)
            {
                printf("Button Confirmed\r\n");
                HandleButtonEvent();
            }
        }
    }
}

4.3 使用任务通知通信

TaskHandle_t sensor_task_handle;
volatile uint32_t isr_count = 0;

void Sensor_ISR_Handler(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    if(TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
    {
        isr_count++;
        
        vTaskNotifyGiveFromISR(sensor_task_handle, &xHigherPriorityTaskWoken);
        
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
    }
    
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void Sensor_Task(void *pvParameters)
{
    uint32_t notification_value;
    
    while(1)
    {
        notification_value = ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        
        printf("Sensor ISR Count: %lu, Notification: %lu\r\n", 
               isr_count, notification_value);
        
        ReadSensorData();
    }
}

4.4 使用事件组通信

EventGroupHandle_t system_event_group;

#define EVENT_UART_RX    (1 << 0)
#define EVENT_ADC_READY  (1 << 1)
#define EVENT_KEY_PRESS  (1 << 2)

void UART_RX_ISR_Handler(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
    {
        uint8_t data = USART_ReceiveData(USART1);
        
        xEventGroupSetBitsFromISR(system_event_group, 
                                 EVENT_UART_RX,
                                 &xHigherPriorityTaskWoken);
        
        USART_ClearITPendingBit(USART1, USART_IT_RXNE);
    }
    
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void EventMonitor_Task(void *pvParameters)
{
    EventBits_t event_bits;
    
    while(1)
    {
        event_bits = xEventGroupWaitBits(
            system_event_group,
            EVENT_UART_RX | EVENT_ADC_READY | EVENT_KEY_PRESS,
            pdTRUE,
            pdFALSE,
            portMAX_DELAY);
        
        if(event_bits & EVENT_UART_RX)
        {
            printf("UART RX Event\r\n");
        }
        
        if(event_bits & EVENT_ADC_READY)
        {
            printf("ADC Ready Event\r\n");
        }
        
        if(event_bits & EVENT_KEY_PRESS)
        {
            printf("Key Press Event\r\n");
        }
    }
}

---

五、临界区保护机制

5.1 临界区保护原理

5.2 任务级临界区

uint32_t shared_counter = 0;

void Task_IncrementCounter(void *pvParameters)
{
    while(1)
    {
        taskENTER_CRITICAL();
        
        shared_counter++;
        
        taskEXIT_CRITICAL();
        
        vTaskDelay(pdMS_TO_TICKS(10));
    }
}

void Task_ReadCounter(void *pvParameters)
{
    uint32_t local_counter;
    
    while(1)
    {
        taskENTER_CRITICAL();
        
        local_counter = shared_counter;
        
        taskEXIT_CRITICAL();
        
        printf("Counter: %lu\r\n", local_counter);
        
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void CriticalSection_Example(void)
{
    taskENTER_CRITICAL();
    
    shared_counter = 0;
    printf("Counter Reset\r\n");
    
    taskEXIT_CRITICAL();
}

5.3 中断级临界区

volatile uint32_t isr_shared_data = 0;

void ISR_CriticalSection_Handler(void)
{
    UBaseType_t uxSavedStatus;
    
    if(TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
    {
        uxSavedStatus = taskENTER_CRITICAL_FROM_ISR();
        
        isr_shared_data++;
        
        taskEXIT_CRITICAL_FROM_ISR(uxSavedStatus);
        
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
    }
}

void Task_ReadISRData(void *pvParameters)
{
    uint32_t local_data;
    UBaseType_t uxSavedStatus;
    
    while(1)
    {
        uxSavedStatus = taskENTER_CRITICAL_FROM_ISR();
        
        local_data = isr_shared_data;
        
        taskEXIT_CRITICAL_FROM_ISR(uxSavedStatus);
        
        printf("ISR Data: %lu\r\n", local_data);
        
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

5.4 临界区嵌套问题

// ❌ 错误：临界区嵌套可能导致死锁
void Bad_NestedCriticalSection(void)
{
    taskENTER_CRITICAL();
    
    // 访问共享资源A
    
    taskENTER_CRITICAL();  // ❌ 错误：重复进入临界区
    
    // 访问共享资源B
    
    taskEXIT_CRITICAL();
    
    taskEXIT_CRITICAL();
}

// ✅ 正确：避免临界区嵌套
void Good_SingleCriticalSection(void)
{
    taskENTER_CRITICAL();
    
    // 访问共享资源A
    // 访问共享资源B
    
    taskEXIT_CRITICAL();
}

// ✅ 最佳：使用互斥量代替嵌套临界区
SemaphoreHandle_t mutex_a;
SemaphoreHandle_t mutex_b;

void Good_MutexInstead(void)
{
    xSemaphoreTake(mutex_a, portMAX_DELAY);
    
    // 访问共享资源A
    
    xSemaphoreTake(mutex_b, portMAX_DELAY);
    
    // 访问共享资源B
    
    xSemaphoreGive(mutex_b);
    xSemaphoreGive(mutex_a);
}

---

六、实时数据采集实战

6.1 高速ADC采集系统

6.2 完整代码实现

#define ADC_BUFFER_SIZE    1000

typedef struct
{
    uint16_t buffer_a[ADC_BUFFER_SIZE];
    uint16_t buffer_b[ADC_BUFFER_SIZE];
    volatile uint8_t active_buffer;
    volatile uint16_t write_index;
    volatile uint8_t buffer_ready;
} DualBuffer_t;

DualBuffer_t adc_dual_buffer = {0};
SemaphoreHandle_t adc_data_sem;
TaskHandle_t adc_process_task;

void ADC_ISR_FastAcquisition(void)
{
    uint16_t adc_value;
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    if(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) != RESET)
    {
        adc_value = ADC_GetConversionValue(ADC1);
        
        if(adc_dual_buffer.active_buffer == 0)
        {
            adc_dual_buffer.buffer_a[adc_dual_buffer.write_index] = adc_value;
        }
        else
        {
            adc_dual_buffer.buffer_b[adc_dual_buffer.write_index] = adc_value;
        }
        
        adc_dual_buffer.write_index++;
        
        if(adc_dual_buffer.write_index >= ADC_BUFFER_SIZE)
        {
            adc_dual_buffer.write_index = 0;
            adc_dual_buffer.active_buffer = !adc_dual_buffer.active_buffer;
            adc_dual_buffer.buffer_ready = 1;
            
            xSemaphoreGiveFromISR(adc_data_sem, &xHigherPriorityTaskWoken);
        }
        
        ADC_ClearFlag(ADC1, ADC_FLAG_EOC);
    }
    
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void ADC_Process_Task(void *pvParameters)
{
    uint16_t *process_buffer;
    uint16_t i;
    float sum, average;
    
    while(1)
    {
        if(xSemaphoreTake(adc_data_sem, portMAX_DELAY) == pdTRUE)
        {
            if(adc_dual_buffer.active_buffer == 0)
            {
                process_buffer = adc_dual_buffer.buffer_b;
            }
            else
            {
                process_buffer = adc_dual_buffer.buffer_a;
            }
            
            sum = 0.0f;
            for(i = 0; i < ADC_BUFFER_SIZE; i++)
            {
                sum += (float)process_buffer[i];
            }
            average = sum / ADC_BUFFER_SIZE;
            
            printf("ADC Average: %.3f\r\n", average * 3.3f / 4095.0f);
            
            adc_dual_buffer.buffer_ready = 0;
        }
    }
}

void HighSpeed_ADC_Init(void)
{
    adc_data_sem = xSemaphoreCreateBinary();
    
    xTaskCreate(ADC_Process_Task, "ADC_Process", 512, NULL, 5, &adc_process_task);
}

---

七、中断调试技巧

7.1 中断频率监控

typedef struct
{
    uint32_t total_count;
    uint32_t count_per_second;
    uint32_t last_timestamp;
    uint32_t max_interval;
    uint32_t min_interval;
} ISR_Monitor_t;

ISR_Monitor_t isr_monitor = {0};

void ISR_WithMonitor_Handler(void)
{
    uint32_t current_time;
    uint32_t interval;
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    if(TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
    {
        current_time = xTaskGetTickCountFromISR();
        
        isr_monitor.total_count++;
        
        if(isr_monitor.last_timestamp != 0)
        {
            interval = current_time - isr_monitor.last_timestamp;
            
            if(interval > isr_monitor.max_interval)
            {
                isr_monitor.max_interval = interval;
            }
            
            if(interval < isr_monitor.min_interval || isr_monitor.min_interval == 0)
            {
                isr_monitor.min_interval = interval;
            }
        }
        
        isr_monitor.last_timestamp = current_time;
        
        xSemaphoreGiveFromISR(isr_data_sem, &xHigherPriorityTaskWoken);
        
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
    }
    
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void ISR_Monitor_Task(void *pvParameters)
{
    uint32_t last_count = 0;
    
    while(1)
    {
        vTaskDelay(pdMS_TO_TICKS(1000));
        
        isr_monitor.count_per_second = isr_monitor.total_count - last_count;
        last_count = isr_monitor.total_count;
        
        printf("\r\n=== ISR Monitor ===\r\n");
        printf("Total Count: %lu\r\n", isr_monitor.total_count);
        printf("Count/Second: %lu\r\n", isr_monitor.count_per_second);
        printf("Max Interval: %lu ticks\r\n", isr_monitor.max_interval);
        printf("Min Interval: %lu ticks\r\n", isr_monitor.min_interval);
    }
}

7.2 中断延迟测量

volatile uint32_t isr_entry_time = 0;
volatile uint32_t isr_exit_time = 0;
volatile uint32_t isr_max_latency = 0;

void ISR_LatencyMeasure_Handler(void)
{
    isr_entry_time = DWT->CYCCNT;
    
    // 中断处理
    
    isr_exit_time = DWT->CYCCNT;
    
    uint32_t latency = isr_exit_time - isr_entry_time;
    if(latency > isr_max_latency)
    {
        isr_max_latency = latency;
    }
}

void Latency_Report(void)
{
    printf("ISR Max Latency: %lu cycles (%.2f us)\r\n",
           isr_max_latency,
           (float)isr_max_latency / 72.0f);
}

---

八、中断管理踩坑总结

8.1 常见问题与解决方案

8.2 踩坑经验汇总

坑点1：中断优先级数值理解错误

// ❌ 错误：认为数值越小优先级越低
NVIC_SetPriority(USART1_IRQn, 0);  // 实际是最高优先级！

// ✅ 正确：Cortex-M中数值越小优先级越高
// NVIC_PriorityGroup_4模式下：
// 优先级0 = 最高优先级
// 优先级15 = 最低优先级

// configMAX_SYSCALL_INTERRUPT_PRIORITY = 191 (优先级11)
// 可调用RTOS API的中断优先级数值必须 >= 191

坑点2：忘记上下文切换

// ❌ 错误：忘记调用portYIELD_FROM_ISR
void Bad_ISR(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    xSemaphoreGiveFromISR(sem, &xHigherPriorityTaskWoken);
    
    // 忘记上下文切换！
}

// ✅ 正确：始终检查并切换上下文
void Good_ISR(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    xSemaphoreGiveFromISR(sem, &xHigherPriorityTaskWoken);
    
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

坑点3：中断处理时间过长

// ❌ 错误：在中断中执行耗时操作
void Bad_ISR(void)
{
    for(int i = 0; i < 10000; i++)
    {
        ComplexCalculation();  // 执行时间过长
    }
}

// ✅ 正确：使用延迟处理机制
void Good_ISR(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    // 快速保存数据
    SaveDataQuick();
    
    // 通知处理任务
    xSemaphoreGiveFromISR(process_sem, &xHigherPriorityTaskWoken);
    
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

8.3 最佳实践建议

建议1：中断优先级分层设计

// 优先级分层：
// 0-3:   最高优先级，不能调用RTOS API
// 4-10:  高优先级，实时性要求高的中断
// 11-15: 低优先级，可调用RTOS API的中断

#define PRIORITY_HIGHEST_NO_RTOS    0
#define PRIORITY_HIGH_REALTIME      4
#define PRIORITY_NORMAL_RTOS        11
#define PRIORITY_LOW_RTOS           15

建议2：中断处理流程标准化

// 标准中断处理流程：
// 1. 检查中断标志
// 2. 快速处理（保存数据）
// 3. 通知处理任务
// 4. 清除中断标志
// 5. 上下文切换

void Standard_ISR_Handler(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    // 1. 检查中断标志
    if(CheckInterruptFlag())
    {
        // 2. 快速处理
        QuickProcess();
        
        // 3. 通知处理任务
        NotifyProcessTask(&xHigherPriorityTaskWoken);
        
        // 4. 清除中断标志
        ClearInterruptFlag();
    }
    
    // 5. 上下文切换
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

---

九、总结与互动

9.1 核心要点总结

1. 中断优先级：理解Cortex-M优先级机制，正确配置RTOS中断优先级
2. 中断服务函数：执行时间短，不阻塞，使用FromISR函数
3. 延迟处理：中断快速响应，任务延迟处理复杂操作
4. 中断通信：信号量、队列、任务通知、事件组
5. 临界区保护：任务级和中断级临界区，避免嵌套

9.2 实战经验总结

• 中断优先级数值越小优先级越高
• 可调用RTOS API的中断优先级必须足够低
• 中断中必须使用FromISR函数，不能阻塞
• 复杂处理使用延迟中断机制
• 临界区要避免嵌套，考虑使用互斥量

---

投票组件

你对RTOS中断管理的最大困惑是什么？

1. 中断优先级配置不理解，经常导致系统崩溃
2. 不知道何时使用中断、何时使用任务处理
3. 中断与任务通信方式太多，不知道选哪种
4. 临界区保护不当，数据竞争问题频发
5. 其他问题（请评论区说明）

欢迎在评论区分享你的中断管理经验和遇到的问题！

---

互动引导

思考题：

1. 如何设计一个高实时性的数据采集系统，中断响应时间<10μs？
2. 如何测量和优化中断延迟？
3. 如何设计中断优先级分层架构？

实践建议：

1. 先理解Cortex-M中断优先级机制
2. 学习标准中断服务函数模板
3. 实现延迟中断处理机制
4. 使用调试工具监控中断性能