MCU智学网»网站论坛 › 嵌入式操作系统论坛 › RT-Thread › 帖子
发新帖

RT-Thread学习笔记——中断管理

[复制链接]
2353 0

本文包含源代码、原理图、PCB、封装库、中英文PDF等资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
前言
本文学习RT-Thread的中断管理，这里主要包括异常与中断的基本概念、RT-Thread 中断工作机制，更多关于RT-Thread的中断管理请看《RT-Thread编程指南》，后面通过使用STM32来进行实验。

一、异常与中断的基本概念
异常是导致处理器脱离正常运行转向执行特殊代码的任何事件，如果不及时进行处理，轻则系统出错，重则会导致系统毁灭性瘫痪。所以正确地处理异常，避免错误的发生是提高软件鲁棒性（稳定性）非常重要的一环，对于实时系统更是如此。异常是指任何打断处理器正常执行，并且迫使处理器进入一个由有特权的特殊指令执行的事件。异常通常可以分成两类：同步异常和异步异常。

1、异步异常与同步异常：异步异常主要是指由于外部异常源产生的异常，是一个由外部硬件装置产生的事件引起的异步异常。。同步异常不同于异步异常的地方是事件的来源，同步异常事件是由于执行某些指令而从处理器内部产生的，而异步异常事件的来源是外部硬件装置。例如按下设备某个按钮产生的事件。同步异常与异步异常的区别还在于，同步异常触发后，系统必须立刻进行处理而不能够依然执行原有的程序指令步骤；而异步异常则可以延缓处理甚至是忽略，例如按键中断异常，虽然中断异常触发了，但是系统可以忽略它继续运行（同样也忽略了相应的按键事件）。

2、中断：中断属于异步异常。所谓中断是指中央处理器 CPU 正在处理某件事的时候，外部发生了某一事件，请求 CPU迅速处理，CPU 暂时中断当前的工作，转入处理所发生的事件，处理完后，再回到原来被中断的地方，继续原来的工作，这样的过程称为中断。中断能打断线程的运行，无论该线程具有什么样的优先级，因此中断一般用于处理比较紧急的事件，而且只做简单处理，例如标记该事件，在使用 RT-Thread 系统时，一般建议使用信号量、消息或事件标志组等标志中断的发生，将这些内核对象发布给处理线程，处理线程再做具体处理。

二、RT-Thread 中断工作机制
1、中断向量表

（1）中断向量表是所有中断处理程序的入口，如下图所示是 Cortex-M 系列的中断处理过程：把一个函数（用户中断服务程序）同一个虚拟中断向量表中的中断向量联系在一起。当中断向量对应中断发生的时候，被挂接的用户中断服务程序就会被调用执行。

20190219145558266.png
中断处理过程（来源RT-Thread编程指南）

（2）在 Cortex-M 内核上，所有中断都采用中断向量表的方式进行处理，即当一个中断触发时，处理器将直接判定是哪个中断源，然后直接跳转到相应的固定位置进行处理，每个中断服务程序必须排列在一起放在统一的地址上（这个地址必须要设置到NVIC 的中断向量偏移寄存器中）。中断向量表一般由一个数组定义或在起始代码中给出，默认采用起始代码给出，打开startup_stm32xxxxxx.s文件：
  1. __Vectors       DCD     __initial_sp               ; Top of Stack

  2.                 DCD     Reset_Handler              ; Reset Handler

  3.                 DCD     NMI_Handler                ; NMI Handler

  4.                 DCD     HardFault_Handler          ; Hard Fault Handler

  5.                 DCD     MemManage_Handler          ; MPU Fault Handler

  6.                 DCD     BusFault_Handler           ; Bus Fault Handler

  7.                 DCD     UsageFault_Handler         ; Usage Fault Handler

  8.                 DCD     0                          ; Reserved

  9.                 DCD     0                          ; Reserved

  10.                 DCD     0                          ; Reserved

  11.                 DCD     0                          ; Reserved

  12.                 DCD     SVC_Handler                ; SVCall Handler

  13.                 DCD     DebugMon_Handler           ; Debug Monitor Handler

  14.                 DCD     0                          ; Reserved

  15.                 DCD     PendSV_Handler             ; PendSV Handler

  16.                 DCD     SysTick_Handler            ; SysTick Handler

  17.  

  18. ......

  19.  

  20. NMI_Handler     PROC

  21.                 EXPORT  NMI_Handler                [WEAK]

  22.                 B       .

  23.                 ENDP

  24. HardFault_Handler\

  25.                 PROC

  26.                 EXPORT  HardFault_Handler          [WEAK]

  27.                 B       .

  28.                 ENDP

  29.  

  30. ......

复制代码
请注意代码后面的 [WEAK] 标识，它是符号弱化标识，在 [WEAK] 前面的符号 (如 NMI_Handler、HardFault_Handler）将被执行弱化处理，如果整个代码在链接时遇到了名称相同的符号（例如与NMI_Handler 相同名称的函数），那么代码将使用未被弱化定义的符号（与 NMI_Handler 相同名称的函数），而与弱化符号相关的代码将被自动丢弃。以 SysTick 中断为例，在系统启动代码中，需要填上 SysTick_Handler 中断入口函数，然后实现该函数即可对 SysTick 中断进行响应，中断处理函数示例程序如下所示：
  1. void SysTick_Handler(void)

  2. {

  3.     /* enter interrupt */

  4.     rt_interrupt_enter();

  5.  

  6.     rt_tick_increase();

  7.  

  8.     /* leave interrupt */

  9.     rt_interrupt_leave();

  10. }

复制代码
2、中断处理过程

RT-Thread 中断管理中，将中断处理程序分为中断前导程序、用户中断服务程序、中断后续程序三部分，如下图：

20190219150600671.png
中断处理程序的3部分（来源RT-Thread编程指南）

（1）中断前导程序

中断前导程序主要工作如下：

（A）保存 CPU 中断现场，这部分跟 CPU 架构相关，不同 CPU 架构的实现方式有差异。对于 Cortex-M 来说，该工作由硬件自动完成。当一个中断触发并且系统进行响应时，处理器硬件会将当前运行部分的上下文寄存器自动压入中断栈中，这部分的寄存器包括 PSR、PC、LR、R12、R3-R0 寄存器。

（B）通知内核进入中断状态，调用 rt_interrupt_enter() 函数，作用是把全局变量 rt_interrupt_nest加 1，用它来记录中断嵌套的层数，代码如下所示。
  1. void rt_interrupt_enter(void)

  2. {

  3.     rt_base_t level;

  4.  

  5.     RT_DEBUG_LOG(RT_DEBUG_IRQ, ("irq coming..., irq nest:%d\n",

  6.                                 rt_interrupt_nest));

  7.  

  8.     level = rt_hw_interrupt_disable();

  9.     rt_interrupt_nest ++;

  10.     RT_OBJECT_HOOK_CALL(rt_interrupt_enter_hook,());

  11.     rt_hw_interrupt_enable(level);

  12. }

复制代码
（2）用户中断服务程序

（A）在用户中断服务程序（ISR）中，分为两种情况，第一种情况是不进行线程切换，这种情况下用户中断服务程序和中断后续程序运行完毕后退出中断模式，返回被中断的线程。

（B）另一种情况是，在中断处理过程中需要进行线程切换，这种情况会调用 rt_hw_context_switch_interrupt()函数进行上下文切换，该函数跟 CPU 架构相关，不同 CPU 架构的实现方式有差异。

（C）在 Cortex-M 架构中，rt_hw_context_switch_interrupt() 的函数实现流程如下图所示，它将设置需要切换的线程 rt_interrupt_to_thread 变量，然后触发 PendSV 异常（PendSV 异常是专门用来辅助上下文切换的，且被初始化为最低优先级的异常）。PendSV 异常被触发后，不会立即进行 PendSV 异常中断处理程序，因为此时还在中断处理中，只有当中断后续程序运行完毕，真正退出中断处理后，才进入 PendSV异常中断处理程序。

20190219155412637.png
rt_hw_context_switch_interrupt() 函数实现流程（来源RT-Thread编程指南）

（3）中断后续程序

中断后续程序主要完成的工作是:
（A） 通知内核离开中断状态，通过调用 rt_interrupt_leave() 函数，将全局变量 rt_interrupt_nest 减 1，代码如下所示。
  1. void rt_interrupt_leave(void)

  2. {

  3.     rt_base_t level;

  4.  

  5.     RT_DEBUG_LOG(RT_DEBUG_IRQ, ("irq leave, irq nest:%d\n",

  6.                                 rt_interrupt_nest));

  7.  

  8.     level = rt_hw_interrupt_disable();

  9.     rt_interrupt_nest --;

  10.     RT_OBJECT_HOOK_CALL(rt_interrupt_leave_hook,());

  11.     rt_hw_interrupt_enable(level);

  12. }

复制代码
（B）恢复中断前的 CPU 上下文，如果在中断处理过程中未进行线程切换，那么恢复 from 线程的 CPU上下文，如果在中断中进行了线程切换，那么恢复 to 线程的 CPU 上下文。这部分实现跟 CPU 架构相关，不同 CPU 架构的实现方式有差异，在 Cortex-M 架构中实现流程如下图所示。

20190219155707274.png
rt_hw_context_switch_interrupt() 函数实现流程（来源RT-Thread编程指南）


3、中断嵌套

在允许中断嵌套的情况下，在执行中断服务程序的过程中，如果出现高优先级的中断，当前中断服务程序的执行将被打断，以执行高优先级中断的中断服务程序，当高优先级中断的处理完成后，被打断的中断服务程序才又得到继续执行，如果需要进行线程调度，线程的上下文切换将在所有中断处理程序都运行结束时才发生，如下图所示。

20190219160108972.png
中断中的线程切换（来源RT-Thread编程指南）


4、中断栈

（1）在中断处理过程中，在系统响应中断前，软件代码（或处理器）需要把当前线程的上下文保存下来（通常保存在当前线程的线程栈中），再调用中断服务程序进行中断响应、处理。在进行中断处理时（实质是调用用户的中断服务程序函数），中断处理函数中很可能会有自己的局部变量，这些都需要相应的栈空间来保存，所以中断响应依然需要一个栈空间来做为上下文，运行中断处理函数。中断栈可以保存在打断线程的栈中，当从中断中退出时，返回相应的线程继续执行。

（2）中断栈也可以与线程栈完全分离开来，即每次进入中断时，在保存完打断线程上下文后，切换到新的中断栈中独立运行。在中断退出时，再做相应的上下文恢复。使用独立中断栈相对来说更容易实现，并且对于线程栈使用情况也比较容易了解和掌握（否则必须要为中断栈预留空间，如果系统支持中断嵌套，还需要考虑应该为嵌套中断预留多大的空间）。

（3）RT-Thread 采用的方式是提供独立的中断栈，即中断发生时，中断的前期处理程序会将用户的栈指针更换到系统事先留出的中断栈空间中，等中断退出时再恢复用户的栈指针。这样中断就不会占用线程的栈空间，从而提高了内存空间的利用率，且随着线程的增加，这种减少内存占用的效果也越明显。

（4）在 Cortex-M 处理器内核里有两个堆栈指针，一个是主堆栈指针（MSP），是默认的堆栈指针，在运行第一个线程之前和在中断和异常服务程序里使用；另一个是线程堆栈指针（PSP），在线程里使用。在中断和异常服务程序退出时，修改 LR 寄存器的第 2 位的值为 1，线程的 SP 就由 MSP 切换到 PSP。



5、中断的底半处理

当一个中断发生时，中断服务程序需要取得相应的硬件状态或者数据。如果中断服务程序接下来要对状态或者数据进行简单处理，比如 CPU 时钟中断，中断服务程序只需对一个系统时钟变量进行加一操作，然后就结束中断服务程序。这类中断需要的运行时间往往都比较短。但对于另外一些中断，中断服务程序在取得硬件状态或数据以后，还需要进行一系列更耗时的处理过程，通常需要将该中断分割为两部分，即上半部分（Top Half）和底半部分（Bottom Half）。在上半部分中，取得硬件状态和数据后，打开被屏蔽的中断，给相关线程发送一条通知（可以是 RT-Thread 所提供的信号量、事件、邮箱或消息队列等方式），然
后结束中断服务程序；而接下来，相关的线程在接收到通知后，接着对状态或数据进行进一步的处理，这一过程称之为底半处理。



三、基于STM32的RT-Thread中断管理实验
光说不练都是假把式，那么接下来我们进行实际操作，在STM32平台上实验，使用RTT&正点原子联合出品潘多拉开发板。创建一个消息队列、一个二值信号量和两个线程，通过两个按键KEY1和KEY2来发送消息和发送信号量，线程1用于读取消息队列的消息，读取到就打印处理，线程2用于获取二值信号量，获取到就打印获取到了信号量相关信息，按键KEY1和KEY2用于下降沿触发中断。

1、实验代码：

（1）中断实现代码：
  1. #include "exti.h"

  2. #include "rtthread.h"

  3.  

  4.  

  5. extern rt_mq_t msgqueue;

  6. extern rt_sem_t binary_sem;

  7.  

  8. /**************************************************************

  9. 函数名称 : exti_init

  10. 函数功能 : 外部中断初始化函数

  11. 输入参数 : 无

  12. 返回值           : 无

  13. 备注                 : 无

  14. **************************************************************/

  15. void exti_init(void)

  16. {

  17.         GPIO_InitTypeDef GPIO_Initure;

  18.     

  19.     __HAL_RCC_GPIOC_CLK_ENABLE();

  20.     __HAL_RCC_GPIOD_CLK_ENABLE();

  21.     

  22.     GPIO_Initure.Pin = GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10;

  23.     GPIO_Initure.Mode = GPIO_MODE_IT_FALLING;

  24.     GPIO_Initure.Pull = GPIO_PULLUP;

  25.     HAL_GPIO_Init(GPIOD, &GPIO_Initure);

  26.         

  27.     HAL_NVIC_SetPriority(EXTI9_5_IRQn,2,0);

  28.     HAL_NVIC_EnableIRQ(EXTI9_5_IRQn);

  29. }

  30.  

  31. #if 1

  32. /**************************************************************

  33. 函数名称 : EXTI9_5_IRQHandler

  34. 函数功能 : EXTI9_5中断服务函数

  35. 输入参数 : 无

  36. 返回值           : 无

  37. 备注                 : 无

  38. **************************************************************/

  39. void EXTI9_5_IRQHandler(void)

  40. {

  41.     HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_8);/* 调用中断处理公用函数 */

  42.         HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_9);/* 调用中断处理公用函数 */

  43. }

  44.  

  45. /**************************************************************

  46. 函数名称 : HAL_GPIO_EXTI_Callback

  47. 函数功能 : 外部中回调函数

  48. 输入参数 : GPIO_Pin：中断引脚号

  49. 返回值           : 无

  50. 备注                 : 无

  51. **************************************************************/

  52. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)

  53. {

  54.         /* 进入中断 */

  55.           rt_interrupt_enter();

  56.         

  57.     if(GPIO_Pin == GPIO_PIN_8)

  58.         {

  59.                 rt_mq_send(msgqueue, "RT-Thread interrupt send msgqueue test", sizeof("RT-Thread interrupt send msgqueue test"));

  60.         }

  61.         else if(GPIO_Pin == GPIO_PIN_9)

  62.         {

  63.                 rt_sem_release(binary_sem);

  64.         }

  65.         

  66.         /* 离开中断 */

  67.           rt_interrupt_leave();

  68. }

  69.  

  70. #endif

复制代码
（2）main.c代码：
  1. #include "main.h"

  2. #include "board.h"

  3. #include "rtthread.h"

  4. #include "data_typedef.h"

  5.  

  6. /* 线程句柄 */

  7. rt_thread_t thread1 = RT_NULL;

  8. rt_thread_t thread2 = RT_NULL;

  9.  

  10. /* 消息队列句柄 */

  11. rt_mq_t msgqueue = RT_NULL;

  12.  

  13. /* 二值信号量句柄 */

  14. rt_sem_t binary_sem = RT_NULL;

  15.  

  16. void thread1_recv_msgqueue_entry(void *parameter);

  17. void thread2_recv_semaphore_entry(void *parameter);

  18.  

  19. int main(void)

  20. {

  21.         /* 创建消息队列 */

  22.         msgqueue = rt_mq_create("msgqueue", 

  23.                                 64,

  24.                                 10,

  25.                                 RT_IPC_FLAG_FIFO);/* FIFO模式 */

  26.         

  27.         if(msgqueue != RT_NULL)

  28.         {

  29.                 rt_kprintf("RT-Thread create msgqueue successful\r\n");

  30.         }

  31.         else

  32.         {

  33.                 rt_kprintf("RT-Thread create msgqueue failed\r\n");

  34.                 return 0;

  35.         }

  36.  

  37.         /* 创建信号量 */

  38.         binary_sem = rt_sem_create("binary_sem",

  39.                                                                 0,

  40.                                                                 RT_IPC_FLAG_FIFO);

  41.         if(RT_NULL != binary_sem)

  42.         {

  43.                 rt_kprintf("RT-Thread create semaphore successful\r\n");

  44.         }

  45.         else

  46.         {

  47.                 rt_kprintf("RT-Thread create semaphore failed\r\n");

  48.                 return 0;

  49.         }

  50.         

  51.         

  52.         /* 创建线程 */

  53.         thread1 = rt_thread_create("thread1",

  54.                                 thread1_recv_msgqueue_entry,

  55.                                 NULL,

  56.                                 512,

  57.                                 3,

  58.                                 20);

  59.         if(thread1 != RT_NULL)

  60.         {

  61.                 rt_thread_startup(thread1);

  62.         }

  63.         else

  64.         {

  65.                 rt_kprintf("create thread1 failed\r\n");

  66.                 return 0;

  67.         }

  68.  

  69.         /* 创建线程 */

  70.         thread2 = rt_thread_create("thread2",

  71.                                 thread2_recv_semaphore_entry,

  72.                                 NULL,

  73.                                 512,

  74.                                 2,

  75.                                 20);

  76.         if(thread2 != RT_NULL)

  77.         {

  78.                 rt_thread_startup(thread2);

  79.         }

  80.         else

  81.         {

  82.                 rt_kprintf("create thread2 failed\r\n");

  83.                 return 0;

  84.         }

  85.         return 0;

  86. }

  87.  

  88.  

  89. /**************************************************************

  90. 函数名称 : thread1_recv_msgqueue_entry

  91. 函数功能 : 线程1入口函数，接收消息

  92. 输入参数 : parameter：入口参数

  93. 返回值           : 无

  94. 备注                 : 无

  95. **************************************************************/

  96. void thread1_recv_msgqueue_entry(void *parameter)

  97. {

  98.         char buf[64];

  99.         

  100.         while(1)

  101.         {

  102.                 if(rt_mq_recv(msgqueue, buf, sizeof(buf), RT_WAITING_FOREVER) == RT_EOK)

  103.                 {

  104.                         rt_kprintf("%s\r\n", buf);

  105.                 }

  106.                 rt_thread_mdelay(1);

  107.         }

  108. }

  109.  

  110. /**************************************************************

  111. 函数名称 : thread2_recv_semaphore_entry

  112. 函数功能 : 线程2入口函数，接收信号量

  113. 输入参数 : parameter：入口参数

  114. 返回值           : 无

  115. 备注                 : 无

  116. **************************************************************/

  117. void thread2_recv_semaphore_entry(void *parameter)

  118. {

  119.         while(1)

  120.         {

  121.                 if(rt_sem_take(binary_sem, RT_WAITING_FOREVER) == RT_EOK)

  122.                 {

  123.                         rt_kprintf("RT-Thread interrupt send semaphore test\r\n");

  124.                 }

  125.                 

  126.                 rt_thread_mdelay(1);

  127.         }

  128. }

  129.  

  130.  

  131.  

  132.  

  133.  

复制代码
2、观察FinSH：

（1）按下KEY1，触发中断，发送信号量，线程2获取到信号量，打印如下信息：

20190219161619731.png

（2）按下KEY2，触发中断，发送消息，线程1获取到消息，打印如下消息：

20190219161659616.png


参考文献：
1、[野火®]《RT-Thread 内核实现与应用开发实战—基于STM32》

2、《RT-THREAD 编程指南》


举报

回复
返回列表
*滑块验证:
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

admin手机认证
管理员

288

主题

21

回帖

3905

积分
Ta的主页发信息
更多

精彩推荐

更多

热点动态

更多

随手拍

更多

客服中心

微信扫描二维码 服务时间：周一至周日 8:30-22:00

意见反馈

admin@mcuzx.com

|网站地图

Copyright © 2008-2020 MCU智学网 https://www.mcuzx.com/ 版权所有 All Rights Reserved.

Powered by Discuz! X3.5  技术支持: MCU智学网 京ICP备18035221号-2
快速回复 返回顶部 返回列表