RTOS临界段知识详解

xiaojie0513 · 2018-09-09T03:23:15+00:00

本帖最后由 xiaojie0513 于 2018-9-9 11:25 编辑 - |3 n6 d1 v% k+ \4 V大家周末好，刚回学校，乱七八糟的事情一堆，抽个时间更新下~ 4 L5 @# c: l1 f9 ^; E( V/ y( L& Y在文章的最前面，本章主要讲解RTOS的临界段▲▲▲▲▲本文是杰杰原创，转载请说明出处：RTOS的临界段知识详解$ B$ U- _/ d" y" I! d3 g! O* v 什么是临界段 + H' L: X0 M/ F/ q 代码的临界段也称为临界区，指处理时不可分割的代码区域，一旦这部分代码开始执行，则不允许任何中断打断。为确保临界段代码的执行不被中断，在进入临界段之前须关中断，而临界段代码执行完毕后，要立即打开中断。) b7 m- d- v3 _1 @- i& E, f 临界段的作用 5 R& q0 ?8 T3 I( ^1 R+ g3 k6 G( B 其实在RTOS中，使用最多的临界段是OS本身的调用，但是我们用户也是需要对临界资源进行保护的（临界资源是一次仅允许一个线程使用的共享资源），特别是一些全局变量，当线程正在使用的时候不希望有人来打断我的操作，就行很多时候我们写代码时，需要集中精力，不希望别人打断我们的思路一样。这样子使得系统的运行更加稳定健壮。 _4 H5 K, V; j3 k+ H+ f1 ], e" H5 I& y& Y8 P8 l5 M" T' r& l9 J 什么时候会打断代码的执行？ , {; Q- J; R6 o V; `, J3 h 顾名思义，代码正在正常运行的时候，基本不会被打断，能被打断的都是系统发生了异常（中断也是异常），在OS中，除了外部中断能将正在运行的代码打断，还有线程的调度——PendSV，系统产生 PendSV中断，在 PendSV Handler 里面实现线程的切换。我们要将这项东西屏蔽掉，保证当前只有一个线程在使用临界资源。( m/ R1 R2 x/ t, c) B; i3 M: d9 ? 6 E/ y* n( [7 y+ F8 d) C, O如何关闭中断？ 7 f* B5 P2 Z2 x7 ]! g) x" O# p3 t 其实，在我们常用的MCU中，一般为Cortex-M内核的，M内核是有一些指令能快速关闭中断，一起来看看Cortex-M权威指南吧（以Cortex-M3为例）。( Z2 H4 m f: _. Y/ l7 V6 j2 M " j( D- `2 r/ p' s; A9 ` 简单来说，快速屏蔽中断就是处理这些内核寄存器，在Cortex-M中有相应的操作指令，一般我们无需关注，因为OS已经给我们写好了这些底层的东西。不过如果你是想自己写一个OS的话，可以了解一下，要访问 PRIMASK, FAULTMASK 以及 BASEPRI，同样要使用 MRS/MSR 指令,如：# P+ u! t. l- b$ c4 L' n5 _' Z MRS R0, BASEPRI ;读取 BASEPRI 到 R0 中/ y. C. M5 ?; e MRS R0, FAULTMASK ;似上 ( i; [4 K" a/ p2 U4 a1 ~; k$ ^MRS R0, PRIMASK ;似上 3 @/ u, q, R& y9 d' E/ dMSR BASEPRI, R0 ;写入 R0 到 BASEPRI 中5 C f& s" o, U7 a! V( {; I9 N MSR FAULTMASK, R0 ;似上 + \, B( O4 A+ \8 nMSR PRIMASK, R0 ;似上只有在特权级下，才允许访问这 3 个寄存器。复制代码 0 i0 C' t& o1 [. m- ]$ [# X- S 其实，为了快速地开关中断， CM3 还专门设置了一条 CPS 指令，有 4 种用法： 8 n$ k: u7 @% W0 V6 U- w4 ?, f- V G: ~- r/ z, [# s 1CPSID I RIMASK=1， ;关中断 4 l4 m! Y4 x& S( h0 w8 I2CPSIE I RIMASK=0， ;开中断/ Y3 [2 w# @7 G$ c F. n4 y# ^! { 3CPSID F ;FAULTMASK=1, ;关异常; f5 h9 |( P! E* N 4CPSIE F ;FAULTMASK=0 ;开异常 + S1 y" \6 j. t3 `. m5 \* o# [/ k0 P R' t% ? 上面的代码中的PRIMASK和 FAULTMAST 是 Cortex-M 内核里面三个中断屏蔽寄存器中的两个，还有一个是 BASEPRI，这些寄存器都用于屏蔽中断。具体的作用见表格（表格出自《【野火】RT-Thread 内核实现与应用开发实战指南》）名字功能描述PRIMASK 这是个只有单一比特的寄存器。在它被置 1 后，就关掉所有可屏蔽的异常，只剩下 NMI 和硬 FAULT 可以响应。它的缺省值是 0，表示没有关中断。FAULTMASK 这是个只有 1 个位的寄存器。当它置 1 时，只有 NMI 才能响应，所有其它的异常，甚至是硬 FAULT，也通通闭嘴。它的缺省值也是 0，表示没有关异常。BASEPRI 这个寄存器最多有 9 位（由表达优先级的位数决定）。它定义了被屏蔽优先级的阈值。当它被设成某个值后，所有优先级号大于等于此值的中断都被关（优先级号越大，优先级越低）。但若被设成 0，则不关闭任何中断， 0 也是缺省值。) A) i; | H9 ^ 6 V% [ v; m( Q) Q$ ^不同OS的处理临界段的区别 , R( O5 c3 ^0 P. {. p: n / |) @& n1 k4 V FreeRTOS： 6 a; L9 W. o' T# M$ j5 V& V FreeRTOS对中断的开和关是通过操作 BASEPRI 寄存器来实现的，即大于等于 BASEPRI 的值的中断会被屏蔽，小于 BASEPRI 的值的中断则不会被屏蔽。这样子的好处就是用户可以设置 BASEPRI 的值来选择性的给一些非常紧急的中断留一条后路。比如飞控的防撞处理。代码在portmacro.h 中实现：4 M5 B7 s2 k8 x/ C0 x w2 H 屏蔽中断： $ C' ~- p, d/ s3 R6 | y q 1static portFORCE_INLINE void vPortRaiseBASEPRI( void ) : Z( Y- n% S! e$ i) D 2{0 [+ m0 P& V2 ?+ C# z: U1 d$ H 3uint32_t ulNewBASEPRI = configMAX_SYSCALL_INTERRUPT_PRIORITY; ' P! `6 ~0 b% O+ v2 h7 ^0 K1 [ 4) k: g* p7 e, Y: I 5 __asm8 V+ ^( }& w( D2 ~8 m1 ? 6 { 7 @* a- Q: \ E1 }3 ^# E7 c 7 msr basepri, ulNewBASEPRI) }6 J- J6 u% L* e% n! ~7 m) P 8 dsb4 L, K% {" E9 F$ e 9 isb _" B( c) y% a X) M4 X' Y9 z 10 } 1 W! K2 u# o9 _- N+ E7 h( I3 q3 h11} , K& F. v9 u! i% X' O3 p打开中断： , P# z' I2 M' q0 t( A+ o1static portFORCE_INLINE void vPortSetBASEPRI( uint32_t ulBASEPRI ) & ~2 l5 E# }8 C$ |3 D2{ $ o* @5 C. |5 @1 N. h& V3 __asm 9 ^1 S! C( n7 w8 b, p c4 { 1 ^% G# C/ t7 r, M2 g& s5 msr basepri, ulBASEPRI 8 b) e; I+ ~ _+ O; z6 }; @# ?7 t' k0 \* r0 V' j 7}# b* B6 W* _3 p* x2 ~; N ; c$ u' I& T/ X4 P3 g RT-Thread： 0 v8 H/ M% w! N% m0 C 与FreeRTOS不同的是，RT-Thread 对临界段的保护处理的很干脆，不管三七二十一直接把中断全部关了（直接操作PRIMASK内核寄存器），只有NMI FAULT 和硬 FAULT能被相应。这种方法简单粗暴，是很不错的选择。一般我们临界段的处理时间是比较短的，关了再开其实并没有太大的影响。! K6 M2 V+ ^4 D h6 F$ H1 N$ F 现在要看看RT-Thread的关中断的代码实现：0 D! T* a- ?* ]( y 1rt_hw_interrupt_disable PROC2 N& p5 D! [1 r0 R) V; K( D 2 EXPORT rt_hw_interrupt_disable% S- o" d* }) M+ R 3 MRS r0, PRIMASK 7 P7 w& p9 x4 M& I6 s# t4 CPSID I " y) n7 c3 y& B* _; O5 BX LR 6 a, g; G% U/ R- Y. p' c5 q6 ENDP$ j& R; i' d1 F4 p 7 L7 C* y2 \) B1 F, _开中断： ) b b. e; U4 c" z: h) N: X$ V1rt_hw_interrupt_enable PROC0 r" `: g- u V9 P, {6 f7 ] 2 EXPORT rt_hw_interrupt_enable5 c2 ^# t0 M0 t, X# V 3 MSR PRIMASK, r0* s7 X! X& l4 ~3 Y 4 BX LR; T, ^4 R0 ?# u" O* G. ~# f, C 5 ENDP 9 |1 }6 C/ d$ `3 I( Q' Q9 r o! n5 ^: k3 o* W) x1 o5 A 这短短的几句代码其实还是很有意思的，我就引用火哥的话来解释一下这些处理操作（我个人是不会汇编的，但是跟着书来解读这些代码还是很轻而易举的）0 J8 m: F& Y6 x( c, R( v; [: v4 o 可能有人懂汇编的话，就会看出来，关中断，不就是直接使用 CPSID I 指令就行了嘛~开中断，不就是使用 CPSIE I 指令就行了嘛，为啥跟我等凡人想的不一样？9 T0 n" Q+ g1 ]( s* E8 S# Z& A$ B RT-Thread的处理好像是多此一举了，实则不然，“所有东西的存在必然有其存在的意义”这句话应该没人反驳吧~~因为RT-Thread要防止用户错误地退出了中断临界段，因为这样子可能会产生巨大的危害，所以RT-Thread将当前的PRIMASK的状态保存起来，这样子就必须要关多少次中断就得开多少次中断。$ x1 S3 R. @$ v8 p/ P 怎么说呢，用例子来证明吧： 3 i5 X% C$ e, d. s+ j4 n6 ` G 1/* 临界段 1 开始 */ ) X/ P( a0 k* G8 o 2rt_hw_interrupt_disable(); /* 关中断,PRIMASK = 1 */ 3 b7 B+ r/ V A* d3 r 3{ - t4 a& f' s- _# y. N |( J1 L 4 /* 临界段 2 */8 Y) y7 _2 y4 c t% |6 g 5 rt_hw_interrupt_disable(); /* 关中断,PRIMASK = 1 */ _9 {4 ?* d1 |* e; o) ?+ D8 p9 K 6 { ' M9 d" D& @5 I' Z& S# R 7 }! `* ]( J7 X2 ` W7 u4 U* w/ B9 ] 8 rt_hw_interrupt_enable(); /* 开中断,PRIMASK = 0 */ (注意) 5 ~! p& K' c& I J, p2 i- @ 9}# J& f. V! G. {5 o 10/* 临界段 1 结束 */ " V: M" g& I1 ]. J# x9 m11rt_hw_interrupt_enable(); /* 开中断,PRIMASK = 0 */ + d9 _ ` [6 r( r/ d" p1 w 9 @4 b# @- `6 k8 k+ e1 g 如果直接操作PRIMASK，而不保存PRIMASK的状态，这样子当临界段2结束后调用一次打开中断，那么连临界段1的后半部分就无效了。而RT-Thread的实现就能很好避免这种问题，也用代码来说明吧：+ Q( n: i0 Y( I" p; ~& @ 1/* 临界段 1 开始 */ ( e: _+ \ V: y, _ n; a& t 2level1 = rt_hw_interrupt_disable(); /* 关中断,level1=0,PRIMASK=1 */3 k$ V) W5 B: E3 h* t1 d2 K 3{ . t7 U# f/ P# K 4 /* 临界段 2 */ * X% D# D$ _- Z% P0 I# w3 R# f 5 level2 = rt_hw_interrupt_disable(); /* 关中断,level2=1,PRIMASK=1 */ & B' G7 Q1 p* S; Z: H: X. j 6 {7 p* J1 ]8 ~4 c2 _, k0 p 7 }8 b' H0 J _) L/ ~ 8 rt_hw_interrupt_enable(level2); /* 开中断,level2=1,PRIMASK=1 */ % q" o9 n2 Y3 [: ]; ` 9}+ o5 c* a0 p! p8 s) C 10/* 临界段 1 结束 */ + m9 _/ c1 A' M8 ?9 z6 v. U11rt_hw_interrupt_enable(level1); /* 开中断,level1=0,PRIMASK=0 */ ' _( y* A$ d1 |1 W: e$ f7 ] % X6 o( u& g3 a; l1 n 这样子就完全避免了对吧！ ! G! u1 K$ P8 I% P( z' @9 V" v 有人又会问了，FreeRTOS的临界段能允许嵌套吗，答案是肯定的，FreeRTOS中早已给我们想好调用的函数了，并且全部使用宏定义实现了： 6 s6 F( l1 X9 z! M* C# ?4 E9 o; L1#define portDISABLE_INTERRUPTS() vPortRaiseBASEPRI() % E) F, v% N S2 F$ U" W' R- O2#define portENABLE_INTERRUPTS() vPortSetBASEPRI( 0 ) 2 [: V" C4 s! y7 n, P$ E+ O, J3#define portENTER_CRITICAL() vPortEnterCritical()! Y2 N) c, u/ O+ c 4#define portEXIT_CRITICAL() vPortExitCritical() * b# l1 q3 X5 n t5#define portSET_INTERRUPT_MASK_FROM_ISR() ulPortRaiseBASEPRI()' A9 Z$ L3 {5 @3 \% q: j 6#define portCLEAR_INTERRUPT_MASK_FROM_ISR(x) vPortSetBASEPRI(x)& l/ c- p1 d& g, Z/ g& B+ h. u ! A Q6 V: Q# [7 C2 X 其实原理都是差不多的，通过保存和恢复寄存器basepri的数值就可以实现嵌套使用。( x7 @+ z, F& t7 K. \/ l 1UBaseType_t uxSavedInterruptStatus;/ L$ L2 p, w5 ]: L6 w3 w2 s% r 25 V3 c3 o/ e5 u3 y* |" a- ?* S 3uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR(); ! X" d8 q: A' ~) P9 O 4{: s, t6 w# c% o7 x* ~ 5 uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();; g. [, a' x( \( l1 ~/ V 6 { / a4 G4 c7 i' W- G5 G+ L7 K 7 //临界区代码9 i! \; J" n; I6 K' E- G7 D 8 }9 f4 l) A( d% i9 O# m! A8 r 9 portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );0 G- \6 j. S5 s# `5 E6 @ 10}( T# j5 ?0 G9 `0 o* o5 q/ }% ? 11portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus ); ! O [' Z2 N) A( Q2 e V/ H* u. G) P7 N 进入临界段源码的实现： * U7 X8 g* D; d9 R) i8 }$ o, R 1static portFORCE_INLINE uint32_t ulPortRaiseBASEPRI( void ) 5 o' K8 W& a, ^ 2{ ) k8 @* P; H' y& S7 A# @4 u 3uint32_t ulReturn, ulNewBASEPRI = configMAX_SYSCALL_INTERRUPT_PRIORITY;8 z% E0 s A. n8 j+ Z 4 6 A) b- |/ @ V8 ^7 b 5 __asm % F6 [! C: ]& g( v 6 {8 ]# m) R8 @1 F( _% G 7 mrs ulReturn, basepri 2 T+ s9 P6 ^4 i 8 msr basepri, ulNewBASEPRI ! I9 D* r- e- O% I$ {: F 9 dsb6 | j4 p. u6 k, o/ w0 K 10 isb) [! ^& \+ Y5 X9 ?8 n 11 } 5 u$ f7 G6 S- k+ y* O4 I12 return ulReturn;2 I8 {) {7 M5 W0 Q( @1 n 13} 3 J" B- d9 Y1 v8 _8 m' P4 s: X, W/ X; j; c; l& V3 r 退出临界段源码实现：（跟前面的函数一样） % G/ ]" \ c% g0 l2 d1static portFORCE_INLINE void vPortSetBASEPRI( uint32_t ulBASEPRI ) # y6 }. l$ k5 ~2{ - ~; V8 |( n/ ^3 __asm " F" E! |" I! W X4 { $ G4 i" h7 a9 ^- O5 msr basepri, ulBASEPRI% D, i) @0 A5 x( r& Q 6 } 4 K* o# i) h" g3 h1 m6 n, Z7} 7 C, q# D: K* A' c( m4 ~9 ^ `; N* K8 x0 \ 总结! N- V( }7 K0 {( f3 R 1 z8 ^& ]& x4 |" U8 { P 对于时间关键的任务而言，恰如其分地使用 PRIMASK 和 BASEPRI 来暂时关闭一些中断是非常重要的。1 G; N& b' ?2 ~5 V FreeRTOS源码中就有多处临界段的处理，除了FreeRTOS操作系统源码所带的临界段以外，用户写应用的时候也有临界段的问题，比如以下两种： 6 @, u. P% [, J* ^! m' L/ g读取或者修改变量（特别是用于任务间通信的全局变量）的代码，一般来说这是最常见的临界代码。调用公共函数的代码，特别是不可重入的函数，如果多个任务都访问这个函数，结果是可想而知的。 e3 j& M; j' M' J 总之，对于临界段要做到执行时间越短越好，否则会影响系统的实时性。 . ]7 _0 Q7 K5 e# B! h) ` 那假如我有一个线程，处理的时间较长，但是我又不想被其他线程打断，关中断可能影响系统的正常运行，怎么办呢？其实很简单，在OS中一般可以直接挂起调度器，系统正常运行，但是不会切换线程，当我处理完再把调度器解除即可。 # P; G. w2 l/ r, X; [7 P- v; N' a/ N7 I, a4 `7 K w7 ] ( }6 P6 b$ ~! y# W; w, S9 `. IRTOS使用得好，开发起来比裸机更简单，使用得不好，那将是噩梦——杰杰 3 r5 G9 b+ V0 D, B2 h3 l▲▲▲▲▲0 [7 F3 y5 ], Z4 ~# Q X -完- ; d0 _* C( @' e4 n3 S1 x

[复制链接]

xiaojie0513 发布时间：2018-9-9 11:23

技术帖
文章封面:	-
文章简介:	-

本帖最后由 xiaojie0513 于 2018-9-9 11:25 编辑

大家周末好，刚回学校，乱七八糟的事情一堆，抽个时间更新下~

在文章的最前面，本章主要讲解RTOS的临界段

▲▲▲▲▲

本文是杰杰原创，转载请说明出处：RTOS的临界段知识详解$ B$ U- _/ d" y" I! d3 g! O* v
什么是临界段
代码的临界段也称为临界区，指处理时不可分割的代码区域，一旦这部分代码开始执行，则不允许任何中断打断。为确保临界段代码的执行不被中断，在进入临界段之前须关中断，而临界段代码执行完毕后，要立即打开中断。
临界段的作用
其实在RTOS中，使用最多的临界段是OS本身的调用，但是我们用户也是需要对临界资源进行保护的（临界资源是一次仅允许一个线程使用的共享资源），特别是一些全局变量，当线程正在使用的时候不希望有人来打断我的操作，就行很多时候我们写代码时，需要集中精力，不希望别人打断我们的思路一样。这样子使得系统的运行更加稳定健壮。

什么时候会打断代码的执行？
顾名思义，代码正在正常运行的时候，基本不会被打断，能被打断的都是系统发生了异常（中断也是异常），在OS中，除了外部中断能将正在运行的代码打断，还有线程的调度——PendSV，系统产生 PendSV中断，在 PendSV Handler 里面实现线程的切换。我们要将这项东西屏蔽掉，保证当前只有一个线程在使用临界资源。

如何关闭中断？
其实，在我们常用的MCU中，一般为Cortex-M内核的，M内核是有一些指令能快速关闭中断，一起来看看Cortex-M权威指南吧（以Cortex-M3为例）。

简单来说，快速屏蔽中断就是处理这些内核寄存器，在Cortex-M中有相应的操作指令，一般我们无需关注，因为OS已经给我们写好了这些底层的东西。不过如果你是想自己写一个OS的话，可以了解一下，要访问 PRIMASK, FAULTMASK 以及 BASEPRI，同样要使用 MRS/MSR 指令,如：

MRS R0, BASEPRI ;读取 BASEPRI 到 R0 中/ y. C. M5 ?; e
MRS R0, FAULTMASK ;似上
( i; [4 K" a/ p2 U4 a1 ~; k$ ^
MRS R0, PRIMASK ;似上
3 @/ u, q, R& y9 d' E/ d
MSR BASEPRI, R0 ;写入 R0 到 BASEPRI 中5 C f& s" o, U7 a! V( {; I9 N
MSR FAULTMASK, R0 ;似上
+ \, B( O4 A+ \8 n
MSR PRIMASK, R0 ;似上只有在特权级下，才允许访问这 3 个寄存器。

复制代码

其实，为了快速地开关中断， CM3 还专门设置了一条 CPS 指令，有 4 种用法：

1CPSID I

RIMASK=1， ;关中断
2CPSIE I

RIMASK=0， ;开中断
3CPSID F ;FAULTMASK=1, ;关异常
4CPSIE F ;FAULTMASK=0 ;开异常

上面的代码中的PRIMASK和 FAULTMAST 是 Cortex-M 内核里面三个中断屏蔽寄存器中的两个，还有一个是 BASEPRI，这些寄存器都用于屏蔽中断。具体的作用见表格（表格出自《【野火】RT-Thread 内核实现与应用开发实战指南》）

名字	功能描述
PRIMASK	这是个只有单一比特的寄存器。在它被置 1 后，就关掉所有可屏蔽的异常，只剩下 NMI 和硬 FAULT 可以响应。它的缺省值是 0，表示没有关中断。
FAULTMASK	这是个只有 1 个位的寄存器。当它置 1 时，只有 NMI 才能响应，所有其它的异常，甚至是硬 FAULT，也通通闭嘴。它的缺省值也是 0，表示没有关异常。
BASEPRI	这个寄存器最多有 9 位（由表达优先级的位数决定）。它定义了被屏蔽优先级的阈值。当它被设成某个值后，所有优先级号大于等于此值的中断都被关（优先级号越大，优先级越低）。但若被设成 0，则不关闭任何中断， 0 也是缺省值。

不同OS的处理临界段的区别
, R( O5 c3 ^0 P. {. p: n

FreeRTOS：
6 a; L9 W. o' T# M$ j5 V& V

FreeRTOS对中断的开和关是通过操作 BASEPRI 寄存器来实现的，即大于等于 BASEPRI 的值的中断会被屏蔽，小于 BASEPRI 的值的中断则不会被屏蔽。这样子的好处就是用户可以设置 BASEPRI 的值来选择性的给一些非常紧急的中断留一条后路。比如飞控的防撞处理。代码在portmacro.h 中实现：
屏蔽中断：
1static portFORCE_INLINE void vPortRaiseBASEPRI( void )
2{
3uint32_t ulNewBASEPRI = configMAX_SYSCALL_INTERRUPT_PRIORITY;
4
5 __asm
6 {
7       msr basepri, ulNewBASEPRI
8       dsb
9       isb
10 }
11}
打开中断：
1static portFORCE_INLINE void vPortSetBASEPRI( uint32_t ulBASEPRI )
2{
3 __asm
4 {
5       msr basepri, ulBASEPRI
6 }
7}

RT-Thread：
0 v8 H/ M% w! N% m0 C

与FreeRTOS不同的是，RT-Thread 对临界段的保护处理的很干脆，不管三七二十一直接把中断全部关了（直接操作PRIMASK内核寄存器），只有NMI FAULT 和硬 FAULT能被相应。这种方法简单粗暴，是很不错的选择。一般我们临界段的处理时间是比较短的，关了再开其实并没有太大的影响。
现在要看看RT-Thread的关中断的代码实现：
1rt_hw_interrupt_disable PROC
2 EXPORT  rt_hw_interrupt_disable
3 MRS    r0, PRIMASK
4 CPSID I
5 BX    LR
6 ENDP

开中断：
1rt_hw_interrupt_enable PROC
2 EXPORT  rt_hw_interrupt_enable
3 MSR    PRIMASK, r0
4 BX    LR
5 ENDP

这短短的几句代码其实还是很有意思的，我就引用火哥的话来解释一下这些处理操作（我个人是不会汇编的，但是跟着书来解读这些代码还是很轻而易举的）
可能有人懂汇编的话，就会看出来，关中断，不就是直接使用 CPSID I 指令就行了嘛~开中断，不就是使用 CPSIE I 指令就行了嘛，为啥跟我等凡人想的不一样？
RT-Thread的处理好像是多此一举了，实则不然，“所有东西的存在必然有其存在的意义”这句话应该没人反驳吧~~因为RT-Thread要防止用户错误地退出了中断临界段，因为这样子可能会产生巨大的危害，所以RT-Thread将当前的PRIMASK的状态保存起来，这样子就必须要关多少次中断就得开多少次中断。
怎么说呢，用例子来证明吧：
1/* 临界段 1 开始 */
2rt_hw_interrupt_disable(); /* 关中断,PRIMASK = 1 */
3{
4  /* 临界段 2 */
5  rt_hw_interrupt_disable(); /* 关中断,PRIMASK = 1 */
6  {
7  }
8  rt_hw_interrupt_enable(); /* 开中断,PRIMASK = 0 */ (注意)
9}
10/* 临界段 1 结束 */
11rt_hw_interrupt_enable(); /* 开中断,PRIMASK = 0 */

如果直接操作PRIMASK，而不保存PRIMASK的状态，这样子当临界段2结束后调用一次打开中断，那么连临界段1的后半部分就无效了。而RT-Thread的实现就能很好避免这种问题，也用代码来说明吧：
1/* 临界段 1 开始 */
2level1 = rt_hw_interrupt_disable(); /* 关中断,level1=0,PRIMASK=1 */
3{
4  /* 临界段 2 */
5  level2 = rt_hw_interrupt_disable(); /* 关中断,level2=1,PRIMASK=1 */
6  {
7  }
8  rt_hw_interrupt_enable(level2); /* 开中断,level2=1,PRIMASK=1 */
9}
10/* 临界段 1 结束 */
11rt_hw_interrupt_enable(level1); /* 开中断,level1=0,PRIMASK=0 */

这样子就完全避免了对吧！
有人又会问了，FreeRTOS的临界段能允许嵌套吗，答案是肯定的，FreeRTOS中早已给我们想好调用的函数了，并且全部使用宏定义实现了：
1#define portDISABLE_INTERRUPTS()             vPortRaiseBASEPRI()
2#define portENABLE_INTERRUPTS()                vPortSetBASEPRI( 0 )
3#define portENTER_CRITICAL()                   vPortEnterCritical()
4#define portEXIT_CRITICAL()                   vPortExitCritical()
5#define portSET_INTERRUPT_MASK_FROM_ISR()    ulPortRaiseBASEPRI()
6#define portCLEAR_INTERRUPT_MASK_FROM_ISR(x) vPortSetBASEPRI(x)

其实原理都是差不多的，通过保存和恢复寄存器basepri的数值就可以实现嵌套使用。
1UBaseType_t uxSavedInterruptStatus;
2
3uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
4{
5  uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
6  {
7    //临界区代码
8  }
9  portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
10}
11portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );

进入临界段源码的实现：
1static portFORCE_INLINE uint32_t ulPortRaiseBASEPRI( void )
2{
3uint32_t ulReturn, ulNewBASEPRI = configMAX_SYSCALL_INTERRUPT_PRIORITY;
4
5 __asm
6 {
7       mrs ulReturn, basepri
8       msr basepri, ulNewBASEPRI
9       dsb
10       isb
11 }
12 return ulReturn;
13}

退出临界段源码实现：（跟前面的函数一样）
1static portFORCE_INLINE void vPortSetBASEPRI( uint32_t ulBASEPRI )
2{
3 __asm
4 {
5       msr basepri, ulBASEPRI
6 }
7}

总结

对于时间关键的任务而言，恰如其分地使用 PRIMASK 和 BASEPRI 来暂时关闭一些中断是非常重要的。
FreeRTOS源码中就有多处临界段的处理，除了FreeRTOS操作系统源码所带的临界段以外，用户写应用的时候也有临界段的问题，比如以下两种：

读取或者修改变量（特别是用于任务间通信的全局变量）的代码，一般来说这是最常见的临界代码。
调用公共函数的代码，特别是不可重入的函数，如果多个任务都访问这个函数，结果是可想而知的。
e3 j& M; j' M' J

总之，对于临界段要做到执行时间越短越好，否则会影响系统的实时性。
那假如我有一个线程，处理的时间较长，但是我又不想被其他线程打断，关中断可能影响系统的正常运行，怎么办呢？其实很简单，在OS中一般可以直接挂起调度器，系统正常运行，但是不会切换线程，当我处理完再把调度器解除即可。

RTOS使用得好，开发起来比裸机更简单，使用得不好，那将是噩梦——杰杰

▲▲▲▲▲

-完-

赞收藏评论15 发布时间：2018-9-9 11:23

15个回答

xiaojie0513 回答时间：2018-9-9 11:52:53

@zero99 暑假工作比较忙，没坚持更新，今天先发两篇更新补回来，排版好累啊

赞评论

yue_viper 回答时间：2018-9-10 17:06:05

总结部分看不到?

赞评论

xiaojie0513 回答时间：2018-9-10 22:57:07

yue_viper 发表于 2018-9-10 17:06
2 N$ o6 y1 ~- D7 a' [" c2 I总结部分看不到?

总结回复可见

赞评论

hi201803 回答时间：2018-9-11 07:35:44

本帖最后由 hi201803 于 2018-9-11 09:23 编辑

好，楼主引导咱们学freertos.
以前看过 ucos源码， freertos 已经用在项目中，却没仔细看过，
用os的体会是，要加入消息驱动的理念,消息驱动+状态机，天生在一起的. 如果用面向对象的思想, 那是再好不过了. 使用对象时加互斥量或信号保护.尽量避免使用全局变量. 对于全局变量, 比如一个32位的时间滴答变量, 在8，16位机中使用开关中断存取.而在32位机中, 由于读写都是原子操作（编程时4字节对齐即可,缺省的，1，2字节对齐是否原子操作就不知道了）, 直接读写就可以了.

对于串口这样的收发数据, 也可以利用FIFO避免使用开关中断. 以前咱都这么干的, 现在直接用 stm32cubemx 生成的代码, 懒得改了. 不理会那点性能损失.

另外, 在任务可抢占的os中, 把使用公共变量的若干线程, 设置为同一个优先级, 避免在使用公共变量时被其它打断, 不失为一个好方法.

-----------------------------------------------------------------------------------
以上，

赞评论