【安富莱STM32F407之uCOS-III教程】第11章 μCOS-III内核函数分析

[复制链接]

baiyongbin2009 发布时间：2014-12-24 19:55

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

特别说明：5 V; D  M" u7 e% O) A3 B! m! b
1.  本教程是安富莱电子原创。! a4 a% J; H" c0 u6 u) b" s
2.  安富莱STM32F407开发板资料已经全部开源，开源地址：地址链接  _' p6 x& z8 F  K% u% x$ Z/ ^
3.  当前共配套300多个实例，4套用户手册。

第11章 μCOS-III内核函数分析

本期教程开始分析μCOS-III的内核函数，源码的分析采用先对源码进行注释，然后讲解函数实现的功能和相关的原理分析，最后是举一个例子（如果这个函数是供外部函数调用的）。内核函数很重要，是学习任务管理，任务间通信机制的基础。希望初学的同学认真学习，这部分应该算是μCOS-III的核心代码。

11.1 系统配置文件

11.2 源码文件

11.3 μCOS-III初始化

11.4 μCOS-III启动

11.5 获取系统版本

11.6 空闲任务

11.7 临界段

11.8 安全关键IEC61508

11.9 任务切换

11.10 调度锁

11.11 Round-Robin调度

11.12 总结

11.1 系统配置文件

下面先简单说明下μCOS-III中几个配置文件的作用，方便分析源码的时候查看，配置文件主要有以下几个：

11.1.1 lib_cfg.h配置文件

lib_cfg.h文件内容如下：

/*$ q1 U& \* I! J9 h0 {; A
*********************************************************************************************************
, W. Q( p7 o9 @6 U% X1 M; ^
* MODULE- e! z2 s& M6 ^( E; g* t
*********************************************************************************************************$ v5 t3 z: U/ I: u, l: B# _
*/: A# c# T+ G8 Q; {
0 u9 l6 y% X; J. I% T8 s5 Z
#ifndef LIB_CFG_MODULE_PRESENT5 m% K5 N' H2 j$ i
#define LIB_CFG_MODULE_PRESENT
. a5 R8 p$ ?4 i1 Y* H
6 z7 |, U; i# Z3 D9 s
/*& E D: y5 R Q3 j p9 B& z k/ a
*********************************************************************************************************& k7 S- \# A4 J! u
* uC/LIB CONFIGURATION
+ H% g; {5 b5 P9 N$ w- z
*********************************************************************************************************5 U0 ]0 y8 ]% D* }0 Q9 P
*/
. w) L1 q P$ ]* H, ?0 s
; x& S9 j7 Q, _, g* h
#define LIB_MEM_CFG_ARG_CHK_EXT_EN DEF_ENABLED
7 k/ M9 o* X8 }4 G4 ~/ W
/* DEF_DISABLED Argument check DISABLED */
9 q' t2 y( D. J( {9 X1 V& d
/* DEF_ENABLED Argument check ENABLED */6 Y2 ?9 g1 H1 `% X
/ ~ b* Z* Q$ R9 M
#define LIB_MEM_CFG_OPTIMIZE_ASM_EN DEF_ENABLED( K0 n5 d) n8 a4 e! W
/* DEF_DISABLED Assembly-optimized function(s) DISABLED */ O$ t8 T1 H7 ~9 b
/* DEF_ENABLED Assembly-optimized function(s) ENABLED */6 l$ N7 @ t( h$ a3 J, q8 t1 r; c
5 J4 M; A! w( o, V
#define LIB_MEM_CFG_ALLOC_EN DEF_ENABLED0 J- m1 m7 e7 G; W
/* DEF_DISABLED Memory allocation DISABLED */
$ y9 c; H/ @) e8 ?. d" S+ x
/* DEF_ENABLED Memory allocation ENABLED */: v1 e. K* G4 b4 G/ n( T8 ]# I& K; K
5 ]# A* A& f' ]9 O8 i. Q. x. I
#define LIB_MEM_CFG_HEAP_SIZE 23u * 1024u /* Configure Heap Memory Size */
0 I0 C8 W- t0 ^ G$ i
. V3 ~. B* f) M. j" v
/*
$ W/ n- {+ ]1 o$ D o3 s
*********************************************************************************************************" d m. s. r# J! }1 b
* MODULE END
( b9 D6 d; U+ s& S- F% W3 c
*********************************************************************************************************
( C2 P% g% ?& i2 w% R
*/
* {) B3 n9 S6 E$ {% a! b5 u8 K
. q5 ?) P9 z/ N8 W2 V2 `% G6 G1 f
#endif

复制代码

lib_cfg.h是用于给uC/LIB做配置的头文件。如果程序中使用uC/LIB的话，需要调用函数Mem_Init()进行初始化。

11.1.2 os_cfg.h配置文件

os_cfg.h文件中的内容如下：

#ifndef OS_CFG_H
; n& A( W+ W) P. P) l0 C, P- m5 z4 l& ~
#define OS_CFG_H7 z2 F8 Q+ m# x6 W
5 ]! g# `; z( t2 p' v; R# @
9 p# |" g( X2 G. r/ {% k
/* ---------------------------- MISCELLANEOUS -------------------------- */2 v1 O# V+ r: C5 {' n
#define OS_CFG_APP_HOOKS_EN 1u /* Enable (1) or Disable (0) application specific hooks */ S @1 ]: F( g/ a3 a2 `/ I
#define OS_CFG_ARG_CHK_EN 1u /* Enable (1) or Disable (0) argument checking */" [9 ?. r+ [6 y+ b* r
#define OS_CFG_CALLED_FROM_ISR_CHK_EN 1u /* Enable (1) or Disable (0) check for called from ISR */; W! q' `. W' F j" F( n
#define OS_CFG_DBG_EN 1u /* Enable (1) debug code/variables */* d0 E* ?8 N/ i0 W# f ^- U
#define OS_CFG_ISR_POST_DEFERRED_EN 0u /* Enable (1) or Disable (0) Deferred ISR posts */
3 D5 }5 h/ i' c
#define OS_CFG_OBJ_TYPE_CHK_EN 1u /* Enable (1) or Disable (0) object type checking */
5 L6 A3 S" ?6 w3 U) @' U4 T' C
#define OS_CFG_TS_EN 1u /* Enable (1) or Disable (0) time stamping */
7 S8 H; o" q( [0 W. N" {
#define OS_CFG_PEND_MULTI_EN 1u /* Enable (1) or Disable (0) code generation for multi-pend feature */+ `0 r7 J5 J" B( p8 S4 B
& Z. Q: k$ i: H. p% }- N
#define OS_CFG_PRIO_MAX 64u /* Defines the maximum number of task priorities (see OS_PRIO data type) */0 S9 u" X1 ]2 R
% |" V! [& r/ O/ C0 b
#define OS_CFG_SCHED_LOCK_TIME_MEAS_EN 0u /* Include code to measure scheduler lock time */+ @9 {6 j. N& O. P: r9 d4 D
#define OS_CFG_SCHED_ROUND_ROBIN_EN 0u /* Include code for Round-Robin scheduling */
; O L5 E2 M+ V$ K- J
#define OS_CFG_STK_SIZE_MIN 64u /* Minimum allowable task stack size */. I3 `! k0 @9 g" y3 x! I
1 o2 E: `( t7 ]( ^ K
) `# O) ~/ f: @. o
/* ----------------------------- EVENT FLAGS --------------------------- */
9 |9 [7 A: X7 y2 W" ]
#define OS_CFG_FLAG_EN 1u /* Enable (1) or Disable (0) code generation for EVENT FLAGS */
7 R& T% C1 U, y9 m
#define OS_CFG_FLAG_DEL_EN 1u /* Include code for OSFlagDel() */1 l6 ^% A [6 L3 }
#define OS_CFG_FLAG_MODE_CLR_EN 1u /* Include code for Wait on Clear EVENT FLAGS */; `. e" K% @7 t B. h
#define OS_CFG_FLAG_PEND_ABORT_EN 1u /* Include code for OSFlagPendAbort() */
9 d' D+ C8 E5 ?" l# p+ o
" F' r# `. n# j1 a( O
5 P: E b4 b. u, i7 U" J' j
/* -------------------------- MEMORY MANAGEMENT ------------------------ */+ h* P& H$ c9 y) S( v0 K* w1 G$ A
#define OS_CFG_MEM_EN 1u /* Enable (1) or Disable (0) code generation for MEMORY MANAGER */+ }+ E, \0 A- e8 j
& \% a8 ]! p. j9 f4 g
# B$ q; D {$ Z2 z {2 K
/* --------------------- MUTUAL EXCLUSION SEMAPHORES ------------------- */2 @2 R. _% }1 ]3 F1 |; o
#define OS_CFG_MUTEX_EN 1u /* Enable (1) or Disable (0) code generation for MUTEX *// n) O5 _) x9 [/ A/ [6 }+ r
#define OS_CFG_MUTEX_DEL_EN 1u /* Include code for OSMutexDel() */
& @, n' y+ s0 T+ e% B0 B- ~: w
#define OS_CFG_MUTEX_PEND_ABORT_EN 1u /* Include code for OSMutexPendAbort() */
! K" O$ i5 i/ V' G0 r
+ s& ]' Y8 ^) H4 X
! R( ]! J2 Z3 l
/* --------------------------- MESSAGE QUEUES -------------------------- */
& [7 F% q3 n$ _* `) q, p' A3 i# ?8 E' |
#define OS_CFG_Q_EN 1u /* Enable (1) or Disable (0) code generation for QUEUES */
- d# {6 z2 P4 o) x: M8 L
#define OS_CFG_Q_DEL_EN 1u /* Include code for OSQDel() */2 Q8 i: n+ v) K, g; O2 K
#define OS_CFG_Q_FLUSH_EN 1u /* Include code for OSQFlush() */
* I7 o, [, y# y! S
#define OS_CFG_Q_PEND_ABORT_EN 1u /* Include code for OSQPendAbort() */2 s$ }' p" X! S
9 K+ e* O- ?/ g
! J8 ^: k" ? F' e. [
/* ----------------------------- SEMAPHORES ---------------------------- */% ~6 E5 Y7 k% K9 ^0 g. N
#define OS_CFG_SEM_EN 1u /* Enable (1) or Disable (0) code generation for SEMAPHORES */- y. a7 i! O1 t3 j/ q
#define OS_CFG_SEM_DEL_EN 1u /* Include code for OSSemDel() */
; B+ p& U3 ?3 M3 T) S: C
#define OS_CFG_SEM_PEND_ABORT_EN 1u /* Include code for OSSemPendAbort() */
) s' q3 ]& I; y2 d* B* b |9 ]
#define OS_CFG_SEM_SET_EN 1u /* Include code for OSSemSet() */
9 y* d" |( c% T; P! s1 {
8 w; i5 a$ K1 i/ A7 ~! s' ?+ W- G5 j
: L& _: v( R; V
/* -------------------------- TASK MANAGEMENT -------------------------- */
! W( Q1 Y' T0 Z9 Q8 `# J
#define OS_CFG_STAT_TASK_EN 1u /* Enable (1) or Disable(0) the statistics task */2 j" _5 c, T$ X n$ u) {+ d4 \
#define OS_CFG_STAT_TASK_STK_CHK_EN 1u /* Check task stacks from statistic task */
$ D' K+ V, u; v' @
0 q: W$ y' A3 w. c
#define OS_CFG_TASK_CHANGE_PRIO_EN 1u /* Include code for OSTaskChangePrio() */- _+ ~: z0 K: t# p% R$ f
#define OS_CFG_TASK_DEL_EN 1u /* Include code for OSTaskDel() */
2 \( G& F* r0 f( T1 R" q
#define OS_CFG_TASK_Q_EN 1u /* Include code for OSTaskQXXXX() */- x- \ ?1 k$ S, t
#define OS_CFG_TASK_Q_PEND_ABORT_EN 1u /* Include code for OSTaskQPendAbort() */
! P7 \1 R2 L7 d( R/ ?$ ]
#define OS_CFG_TASK_PROFILE_EN 1u /* Include variables in OS_TCB for profiling */
+ `, Z. S5 q8 Y' k* m7 q
#define OS_CFG_TASK_REG_TBL_SIZE 1u /* Number of task specific registers */
3 y2 {' y0 v( D9 b* ~
#define OS_CFG_TASK_SEM_PEND_ABORT_EN 1u /* Include code for OSTaskSemPendAbort() */
2 N: v5 @9 d1 n+ ^8 r
#define OS_CFG_TASK_SUSPEND_EN 1u /* Include code for OSTaskSuspend() and OSTaskResume() */
; t1 g5 r$ ~( I7 f+ r
* ^2 ]- a' z& I/ z% r3 H) I
b, W1 S. i) M' f( ^
/* -------------------------- TIME MANAGEMENT -------------------------- */
6 l% c: u0 y( R) ^: X
#define OS_CFG_TIME_DLY_HMSM_EN 1u /* Include code for OSTimeDlyHMSM() */
8 K* Y8 y0 Z& {
#define OS_CFG_TIME_DLY_RESUME_EN 1u /* Include code for OSTimeDlyResume() */
0 p7 n8 n! { b/ W8 z- ^
; N' T; R& ~/ r% ]/ W# V
0 c! i( M( o: a$ {; ~
/* ------------------------- TIMER MANAGEMENT -------------------------- */$ N S" H" L+ I1 h' \5 f6 R
#define OS_CFG_TMR_EN 1u /* Enable (1) or Disable (0) code generation for TIMERS */% K5 |4 z; B7 N8 Q. O% R
#define OS_CFG_TMR_DEL_EN 1u /* Enable (1) or Disable (0) code generation for OSTmrDel() */+ ?0 s- o0 `& {; u# }5 P+ t: S7 u
" c4 N% h+ E2 w4 [% i; Z% u( R* L0 e
#endif

复制代码

这个配置文件比较的重要，主要用于μCOS-III源码中相关函数的配置。

赞收藏评论23 发布时间：2014-12-24 19:55

23个回答

baiyongbin2009 回答时间：2014-12-24 20:13:11

本帖最后由 baiyongbin2009 于 2014-12-24 20:14 编辑

11.7 临界段2 `" f# D8 I' g6 e: f1 D

11.7.1 临界段基本概念

代码的临界段也称为临界区，指处理时不可分割的代码。一旦这部分代码开始执行，则不允许任何中断打入。为确保临界段代码的执行，在进入临界段之前要关中断，而临界段代码执行完以后要立即开中断。

从代码上来看，处在关中断和开中断之间的代码段就是临界段。

由于各厂商的CPU和C编译器的关中断和开中断的方法以及指令不尽相同，为增强μCOS-III的可移植性（即在μCOS-III的各个C语言函数中尽可能地不出现汇编语言代码），μCOS-III用CPU_INT_DIS()和CPU_INT_EN()这两个宏封装了与系统硬件相关的关中断和开中断指令。

另外，不要在临界段中调用μCOS-III提供的功能函数，防止系统崩溃。

11.7.2 临界段相关的宏定义

CPU_INT_DIS()和CPU_INT_EN()可以以下四种不同的实现方法。

#define CPU_CRITICAL_METHOD_NONE 0u
( Q2 N2 @$ `, W2 e2 |& m
#define CPU_CRITICAL_METHOD_INT_DIS_EN 1u
" H: g0 O3 V, ~0 @
#define CPU_CRITICAL_METHOD_STATUS_STK 2u % J% i% V' P+ x: ]% t1 W
#define CPU_CRITICAL_METHOD_STATUS_LOCAL 3u

复制代码

至于在实际应用时使用哪种方法，取决于用户使用的处理器和C编译器。用户可以通过cpu.h文件中的宏定义进行选择：

#define CPU_CFG_CRITICAL_METHOD CPU_CRITICAL_METHOD_STATUS_LOCAL
- j/ f: |' \2 ^" E
( r5 a( c3 w1 e! X
typedef CPU_INT32U CPU_SR;5 Z* @0 z; P. Q2 r
7 g$ @! _3 E2 j- E$ c4 f* n; C
#if (CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL)
9 B; F( r* N0 ~) G% ^
#define CPU_SR_ALLOC() CPU_SR cpu_sr = (CPU_SR)0
% I3 ^2 N+ K" e, c. a" l
#else
0 H4 H" m( e J: e* l
#define CPU_SR_ALLOC()) Q1 A( V2 X5 Z7 O
#endif
! j5 I+ `* y2 D& }
! \5 G; B, F5 P/ H k
' I) o' H1 D$ c3 N2 S! n
* U/ D+ i! [' ]6 E$ ^( X
#define CPU_INT_DIS() do { cpu_sr = CPU_SR_Save(); } while (0) (1)
, a0 H' I5 k. o$ q( n( [
#define CPU_INT_EN() do { CPU_SR_Restore(cpu_sr); } while (0) (2)
2 n7 g; N7 y! y- N
5 n/ {' v! c9 t* \6 ?5 b* W
#ifdef CPU_CFG_INT_DIS_MEAS_EN
1 y4 N3 @' F" a$ |( T) R
+ `6 r3 z9 `6 {# T
#define CPU_CRITICAL_ENTER() do { CPU_INT_DIS(); \
) |7 d* N+ h' S' \
CPU_IntDisMeasStart(); } while (0)4 P. _- J. k0 N ]9 y- i d/ z& T
0 @- G6 u ]7 f" v5 v
#define CPU_CRITICAL_EXIT() do { CPU_IntDisMeasStop(); \4 v: p0 {) N" n" }3 |# f, C
CPU_INT_EN(); } while (0)3 d. G" {8 q. [: i0 Y2 T
I: `8 K! _8 n: s
#else' B a3 w* F8 {4 q$ y
" K1 ?3 H, O9 j7 {6 d( N
#define CPU_CRITICAL_ENTER() do { CPU_INT_DIS(); } while (0). Q% D0 N. ^9 B0 e: j9 W& q. J
#define CPU_CRITICAL_EXIT() do { CPU_INT_EN(); } while (0)) M& X; T" d- g" @; y
#endif

复制代码

1. 当CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_INT_DIS_EN时

这种方式最简单，即直接使用处理器的开中断和关中断指令来实现宏。但是不推荐使用这种方式，因为不支持中断嵌套，但是考虑到有些处理器或者编译器仅支持这种方式，不得不选择这种方式。

2. 当CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_INT_DIS_EN时

这种方法稍复杂些，但可使CPU中断使能标志的状态在临界段前和临界段后不发生变化。

进入临界段前:

(1) Push/save 中断状态保存到堆栈中

(2) Disable 关闭中断

退出临界段：

(3) Pop/restore 恢复中断标志

3. 当CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL时

这种方法的前提是，用户使用的C编译器具有扩展功能。用户可获得程序状态字的值，这样就可把该值保存在C函数的局部变量中，而不必压到堆栈里。上面的宏定义就是采用的这种方式，也就是（1），（2）注释的地方。

4. 关于临界段，在文件os.h中也有几个相关的宏定义，这几个宏定义的含义会在后面跟大家讲

#if OS_CFG_SCHED_LOCK_TIME_MEAS_EN> 0u && defined(CPU_CFG_INT_DIS_MEAS_EN)

#define OS_SCHED_LOCK_TIME_MEAS_START() OS_SchedLockTimeMeasStart()

#else

#define OS_SCHED_LOCK_TIME_MEAS_START()

#endif

#if OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u && defined(CPU_CFG_INT_DIS_MEAS_EN)

#define OS_SCHED_LOCK_TIME_MEAS_STOP() OS_SchedLockTimeMeasStop()

#else

#define OS_SCHED_LOCK_TIME_MEAS_STOP()

#endif

#if OS_CFG_ISR_POST_DEFERRED_EN > 0u /* Deferred ISR Posts */

/* Lock the scheduler */

#define OS_CRITICAL_ENTER() \

do { \

CPU_CRITICAL_ENTER(); \

OSSchedLockNestingCtr++; \

if(OSSchedLockNestingCtr == 1u) { \

OS_SCHED_LOCK_TIME_MEAS_START(); \

} \

CPU_CRITICAL_EXIT(); \

} while (0)

/* Lock the scheduler but re-enable interrupts*/

#define OS_CRITICAL_ENTER_CPU_EXIT() \

do { \

OSSchedLockNestingCtr++; \

if(OSSchedLockNestingCtr == 1u) { \

OS_SCHED_LOCK_TIME_MEAS_START(); \

} \

CPU_CRITICAL_EXIT(); \

} while (0)

/* Scheduling occurs only if an interruptoccurs */

#define OS_CRITICAL_EXIT() \

do { \

CPU_CRITICAL_ENTER(); \

OSSchedLockNestingCtr--; \

if(OSSchedLockNestingCtr == (OS_NESTING_CTR)0) { \

OS_SCHED_LOCK_TIME_MEAS_STOP(); \

if(OSIntQNbrEntries > (OS_OBJ_QTY)0) { \

CPU_CRITICAL_EXIT(); \

OS_Sched0(); \

} else { \

CPU_CRITICAL_EXIT(); \

} \

} else { \

CPU_CRITICAL_EXIT(); \

} \

} while (0)

#define OS_CRITICAL_EXIT_NO_SCHED() \

do { \

CPU_CRITICAL_ENTER(); \

OSSchedLockNestingCtr--; \

if(OSSchedLockNestingCtr == (OS_NESTING_CTR)0) { \

OS_SCHED_LOCK_TIME_MEAS_STOP(); \

} \

CPU_CRITICAL_EXIT(); \

} while (0)

#else /* Direct ISR Posts */

#define OS_CRITICAL_ENTER() CPU_CRITICAL_ENTER()

#define OS_CRITICAL_ENTER_CPU_EXIT()

#define OS_CRITICAL_EXIT() CPU_CRITICAL_EXIT()

#define OS_CRITICAL_EXIT_NO_SCHED() CPU_CRITICAL_EXIT()

#endif

赞评论

baiyongbin2009 回答时间：2014-12-24 20:05:42

（续）11.3 μCOS-III初始化
7 M+ b% G( l& b& A$ i; O- Z6 {9 n4 Y
11.3.2 初始化函数OSInit()

/*& _. S4 o; V5 g: x, I
***********************************************************************************************************
5 ~* D7 o6 \: x# |$ ]
* 初始化7 b- V/ h7 ~$ a& {1 L5 T
*9 [1 v( P, |) v2 b2 j' O
* 功能说明: 此函数用于uC/OS-III的内部初始化，这个函数是使用uC/OS-III时需要第一个执行的函数，切记不要搞错顺* 序，然后才是任务创建和OS_Start().% N+ m( k4 N n8 H' n
* 形参: p_err 变量指针，用于返回错误代码
+ L0 N6 D" v3 `5 q+ D1 g* W0 y
* OS_ERR_NONE 初始化成功4 ~9 A! U L) z6 ^+ b
* Other 根据调用的子函数返回其它OS_ERR_xxx1 @7 B7 B- |! p3 r: m) D) U
* 返回值: 无+ W& ~$ x! y6 k& ]: v0 s
***********************************************************************************************************2 v. u% c. M* ~2 Y9 N
*/( p5 G: R& ~& H% w, {3 w
: N6 R' \/ R2 H9 g, F; e
void OSInit (OS_ERR *p_err)
. V, s% d/ Q' B4 ]4 f
{6 y; B7 @6 _& d
CPU_STK *p_stk;
/ o" T" X: N- P& H" W! ^
CPU_STK_SIZE size;
$ e* j2 H5 B: ^# g2 f
& f1 d- U5 {4 d" r
. ?; @: D7 K) G; l. I9 z
: u: t+ h4 j1 s4 T( H
#ifdef OS_SAFETY_CRITICAL /* 安全关键代码 */ （1）, [( v; \, p4 h7 A
if (p_err == (OS_ERR *)0) {+ I7 V2 f5 P% j0 _# Q, Z
OS_SAFETY_CRITICAL_EXCEPTION();; ]: J2 T$ m7 s7 V; f0 K
return;
8 T% [' l- h5 Z7 e$ v0 f. b1 K' a& i
}
; m* V& t! `2 U+ v3 \# Q6 ]
#endif
0 Y0 H( R. [. C8 b6 ? b
3 ~: A9 ~9 @# d# U7 i. r" g
OSInitHook(); /* 初始化钩子函数 */ * {: g+ Y4 E$ v- Z5 c
% P& ~( M9 _1 l6 Q+ q4 l; \* z
OSIntNestingCtr = (OS_NESTING_CTR)0; /* 清零中断嵌套计数*/ （2）- [( j6 Y9 [2 X: J
8 s$ o3 e& s( q
OSRunning = OS_STATE_OS_STOPPED; /* 多任务运行标志，初始化为还没开始 */
! [. t+ k1 }' c" Z6 u' x
3 M2 V; Z9 v* K8 r7 m7 D
OSSchedLockNestingCtr = (OS_NESTING_CTR)0; /* 调度锁计数清零 */. F6 f, H" E7 [( o5 ^ Z" Q# M2 r
2 }( {% q) V1 q; ]/ E
OSTCBCurPtr = (OS_TCB *)0; /* 初始化 OS_TCB 指针为已知状态 */ （3）7 C g- j- f* e' c" u0 V
OSTCBHighRdyPtr = (OS_TCB *)0;
& w- {4 l& n$ s: X: w! Y. O
2 D6 U0 W/ c: e
OSPrioCur = (OS_PRIO)0; /* 初始化优先级变量为已知状态 */
/ e7 H+ H" A+ ~ r
OSPrioHighRdy = (OS_PRIO)0;8 a( F3 H7 S$ f! m" f6 g
OSPrioSaved = (OS_PRIO)0;
% y5 k8 A z/ j7 ]- c8 V
4 F1 {5 P6 f; E- b' d) B
#if OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u /* 调度锁时间测量 */
4 x$ d$ C( b1 u4 {
OSSchedLockTimeBegin = (CPU_TS)0;- T- u7 W n& D; E# W( _2 S9 y; r
OSSchedLockTimeMax = (CPU_TS)0;
! ~5 s2 Q+ l0 q
OSSchedLockTimeMaxCur = (CPU_TS)0;3 Y) B% Y! n3 Z5 \; r
#endif
* B. g; q. c( s# j" K$ |
; N- H/ n/ d/ q1 C; f
#ifdef OS_SAFETY_CRITICAL_IEC61508 /* 安全关键开启标志 */ （4）
$ @8 `) X5 G, M, H2 H
OSSafetyCriticalStartFlag = DEF_FALSE;" |" i) U% E& y3 P' y
#endif! x0 _% b, T' g' u) J
" C& i5 @7 U8 T4 J! z1 |7 u
#if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u /* 时间片调度默认配置 */ （5）
/ R5 X0 I" H7 c/ r; y( b
OSSchedRoundRobinEn = DEF_FALSE;# B3 O! ]3 l: y. }
OSSchedRoundRobinDfltTimeQuanta = OSCfg_TickRate_Hz / 10u;1 ~& ^0 \3 ~$ N! W, ~; K
#endif
y6 S8 j H; a) `; Q+ M! l
$ y& K2 g* A2 z5 ^; k) A! X
if (OSCfg_ISRStkSize > (CPU_STK_SIZE)0) { （6）
+ k- j& ?- y; Z! d. k# S
p_stk = OSCfg_ISRStkBasePtr; /* 清零异常堆栈，方便后面做堆栈利用率检测 */9 t0 }* W4 i" I n
if (p_stk != (CPU_STK *)0) {! j, j) e& Z- s% q. U" F
size = OSCfg_ISRStkSize;
6 l6 R9 O: M; o
while (size > (CPU_STK_SIZE)0) {
: k( I3 ] B8 m# @
size--;6 k, t& K$ D# W% B! Y
*p_stk = (CPU_STK)0;3 B! G0 I0 t# j( b
p_stk++;% Z* k- K* b9 W1 O
}- d* ~4 y/ U, d
}* ~0 m9 O4 o0 O9 ]9 ^' _
}
/ c% f+ [ Y; i& H- k8 D+ B) e: G) b
) `& `3 C$ e* M+ b! S3 |+ @5 w
#if OS_CFG_APP_HOOKS_EN > 0u （7）' _% \9 E% M2 T/ u& L- u% ]
OS_AppTaskCreateHookPtr = (OS_APP_HOOK_TCB )0; /* 初始化钩子函数指针 */
8 T p# X, T. ?# d" U9 I
OS_AppTaskDelHookPtr = (OS_APP_HOOK_TCB )0;8 _6 X% M2 `" ]/ x
OS_AppTaskReturnHookPtr = (OS_APP_HOOK_TCB )0;
+ W: A/ f0 l9 ^3 F- g: ]" s) F
( ~& b: z0 r! l1 g& z9 j
OS_AppIdleTaskHookPtr = (OS_APP_HOOK_VOID)0;* h, W& c& `" q! t3 s$ X! Y
OS_AppStatTaskHookPtr = (OS_APP_HOOK_VOID)0;
2 K$ D1 u0 } S f
OS_AppTaskSwHookPtr = (OS_APP_HOOK_VOID)0;
U5 n8 ?5 b8 k7 y4 [, \- |
OS_AppTimeTickHookPtr = (OS_APP_HOOK_VOID)0;3 D" x1 ?) } o) J8 b& E, O
#endif- T! S$ b7 L% @% M4 T8 B+ l) r
% g0 B1 }5 M8 L
#if OS_CFG_TASK_REG_TBL_SIZE > 0u% S- V# u/ N" K
OSTaskRegNextAvailID = (OS_REG_ID)0; /* 清零任务寄存器下一个有效 ID */
7 ~! O0 z6 k8 e: @& w4 u
#endif
$ d5 G) L$ t! M, h0 o1 Z8 @
9 P! X6 \3 Q( {2 Z4 j
OS_PrioInit(); /* 初始化优先级位图 *// a4 Q2 B- e& \& C' x7 _/ u) b( O( M
3 A) q" ~! N( O
OS_RdyListInit(); /* 初始化就行列表 */" F4 r, K. k) X& o' E4 q
$ F6 I; T# v9 m/ t# O: k
7 Y. K' q- |" N7 f# R9 X1 k2 C
#if OS_CFG_FLAG_EN > 0u /* 初始化事件标志组 */$ n7 s( k7 x2 ] A: ~
OS_FlagInit(p_err);7 T& |& \) s0 D9 x0 z
if (*p_err != OS_ERR_NONE) {7 _0 N/ Y# d4 F9 k& _1 W% m0 z4 G
return;. ]% T. S/ h! h$ t+ M1 _
}
& ]* H0 R/ |- X! i0 \
#endif8 Q6 `4 J% T' p: T B# H; x/ @& q
+ `, G k7 X6 {* h
. z% e1 e1 n! y n+ l- k
#if OS_CFG_MEM_EN > 0u /* 初始化内存管理 */
$ v! \: I9 W& E4 I+ E7 J: |+ h9 Q
OS_MemInit(p_err);
& Y& S1 e7 N. K6 ^# j" i) c1 G
if (*p_err != OS_ERR_NONE) {
7 t; {7 \6 \: h7 i& ?" V
return;( ]+ E- q8 B6 j" b; e2 q& }
}+ `7 u; `7 ^2 I# c& l% b' i
#endif
( M( D( d% G1 ]) k7 z
9 d. a8 z7 j" _# d4 a4 c3 ]
% G, J% |) w$ s$ v
#if (OS_MSG_EN) > 0u /* 初始化OS_MSGs空闲列表 */7 W/ K: S# s; k# a
OS_MsgPoolInit(p_err);
' k3 \+ n7 B/ _+ w
if (*p_err != OS_ERR_NONE) {
4 u2 b3 G7 {( A: K
return;) f( F+ |# e% s7 L7 `' \" d
}
, X- t9 V) S. D0 A' n: ?' G) h
#endif& j v; S! G- ~0 U% U
4 ^) X2 C+ Z, t. U% V& ~
9 f, I. b7 y2 r, q& b$ f3 t% i
#if OS_CFG_MUTEX_EN > 0u /* 初始化互斥信号量 */8 g6 u+ |2 C( @- t" G8 ~
OS_MutexInit(p_err);, I) P' j9 Y& g( _+ T" K
if (*p_err != OS_ERR_NONE) {
7 [$ @: L! R& W* n ~4 M1 Y
return;- g7 U' `4 p$ B& g5 ~; N3 K
}
6 S* N( A; a; ^
#endif
' m* z3 h" l+ c- L1 t
& N7 e6 w( W. e$ a- F7 u
7 ^& n% _4 h) K: b6 y
#if OS_CFG_Q_EN > 0u; l, y9 i; c" E( U0 _$ i+ V) g
OS_QInit(p_err); /* 初始化消息队列 */3 k' V% ^9 J# s$ q5 J
if (*p_err != OS_ERR_NONE) {
& K/ O3 q2 U( W( @
return;/ m2 Z) w9 R! z# x0 p
}
0 Q% l8 s# I" C0 {
#endif( F8 m2 \, E6 f) N9 u# E: {
4 B: _8 y% v$ p' g
2 y' ~4 p! \, B: a
#if OS_CFG_SEM_EN > 0u /* 初始化信号量 */
9 ?2 `( ]; J3 S$ F. |! D
OS_SemInit(p_err);7 N6 s7 S @' c7 m1 z/ l
if (*p_err != OS_ERR_NONE) {% X9 e4 {9 E) D
return;
7 O3 n' J5 J+ C: D$ n
}
5 p6 B# D2 ?7 G3 ^3 }3 F5 k
#endif
; x' y7 g, ]1 v" T) e- o
2 h8 j4 ~$ H( b2 [+ ]8 B9 X) u0 b( }
6 v; b2 P0 ]& R' Y* \9 N7 Y
#if defined(OS_CFG_TLS_TBL_SIZE) && (OS_CFG_TLS_TBL_SIZE > 0u)
# Q# m- u5 I. z7 H/ @
OS_TLS_Init(p_err); /* 创建任务前，初始化 */5 W! X% c& c$ s& t6 [/ L
if (*p_err != OS_ERR_NONE) {3 p3 i! U+ H3 t" I% G$ x- d" Y
return;
. C: |! D% E: U7 Q2 X: Z
}; H; [) k* \/ F& p
#endif
" z% l8 p8 z2 f8 O
# u7 U$ @+ L4 W, x) {
- m |8 `$ R+ q; o
OS_TaskInit(p_err); /* 初始化任务管理 */3 B4 x* h9 {0 N7 M; r! \; s D/ E" `/ j
if (*p_err != OS_ERR_NONE) {
. E, p( |4 ?. U% d: b7 E/ J3 i" I' f
return;
4 A* a2 N2 t7 u/ ~' Q
}, Y+ ~. @4 f. m8 Z0 P7 c" B" n: x
# b* C, Q; t( V" T
2 n7 `: m, U; b3 N' b
#if OS_CFG_ISR_POST_DEFERRED_EN > 0u
- k5 c. R0 [$ F) C1 ?
OS_IntQTaskInit(p_err); /* 初始化中断队列管理任务 */5 A! O) f' N3 |& W2 ^, l9 q
if (*p_err != OS_ERR_NONE) {
4 {* S3 `- @1 d( j
return;
5 d( I( R7 e8 D- E; ~
}
4 p" d2 q& m* T/ E6 x, T/ ?3 b
#endif
* T- ?: W0 I v' c, y+ u
' ^9 @ M& }$ j
- ~( g# S( j$ Q/ x- q( {& R1 K
OS_IdleTaskInit(p_err); /* 初始化空闲任务 */
% Y+ b' x( V8 }' o, ?7 a( _
if (*p_err != OS_ERR_NONE) {
+ t' o0 j: n! y A/ U8 l
return;1 k3 X K' b Q# V- U
} {% {* \; y, Q; c6 p
& r; v7 Q+ ^1 K" _: r) G6 j" ~
$ n0 z5 \, B: _2 D8 `
OS_TickTaskInit(p_err); /* 初始化嘀嗒定时器任务 */
2 S- o! H8 ]6 y" W4 `1 p0 t" k
if (*p_err != OS_ERR_NONE) {
3 `5 c m- s4 b- a( v9 ~
return;
; n0 C! C" |. d* W
}8 P3 D) X+ U! u q9 B; f) E3 O
& p7 g1 m6 t/ N- D
0 h3 W7 E: ^9 E2 @# `
#if OS_CFG_STAT_TASK_EN > 0u /* 初始化统计任务 */: @0 c) C- { B6 {
OS_StatTaskInit(p_err);. f5 r- ]2 X& v" z
if (*p_err != OS_ERR_NONE) {
6 ^! g3 R0 p5 w: ?' c
return;
) ?+ d3 }4 y7 E6 h6 O! F- J
}1 j2 m* V5 i9 e# M
#endif+ J& z8 E4 q- P) k4 U h& S- n9 w& ?
2 W9 ^1 R1 y+ H7 K% Z: @
3 \6 K, \2 w+ F/ x5 [$ Q" y
#if OS_CFG_TMR_EN > 0u /* 初始化定时器管理任务 */
( `2 z. ?: @4 E2 y$ b
OS_TmrInit(p_err);
- H9 @ h7 E( x/ j# u" O
if (*p_err != OS_ERR_NONE) {
$ c% a" U3 z. \! {! ^% m5 C1 m
return;
; w" L) S( F! o
}" u: Q. |: t5 ]9 U0 y; c) o
#endif
/ b6 J' `7 R1 J& q
8 e( E! b3 P' e k$ ?5 J
6 U! A6 a8 R0 G& j5 D
#if OS_CFG_DBG_EN > 0u
( G( F5 j! s- Z
OS_Dbg_Init(); /* OS调试初始化 */: p( K' ^; H1 s5 R3 ^
#endif+ }" q/ g/ ]" _2 r3 E
9 ?. @, \. |% t; ?% N" U
( r/ F; X8 d7 G
OSCfg_Init(); /* OS配置初始化 */4 k R% T! \5 t4 Q+ o* X
}

复制代码

1. 如果用户在工程预定义中加入了OS_SAFETY_CRITICAL，那么函数就会执行参数检查功能，如果参数不满足条件的话就会进入安全关键异常OS_SAFETY_CRITICAL_EXCEPTION()。安全关键的代码是需要用户去实现的。

2. OSIntNestingCtr 用于记录中断嵌套次数，在μCOS-III中使用中断的话，一般采用如下的方式:

void OS_CPU_SysTickHandler (void)

{

CPU_SR_ALLOC();

CPU_CRITICAL_ENTER();

OSIntNestingCtr++;

CPU_CRITICAL_EXIT();

//添加用户代码

OSIntExit();

}

也就是说进入中断后，先将OSIntNestingCtr加一，退出的时候再执行减一。为什么要这么做？为了说明这个问题，这里举一个例子，假如有低优先级中断A和高优先级中断B，A中断执行的时候，中断B抢占了A的执行，中断B执行完退出的时候会执行函数OSIntExit();（这个函数最主要的作用就是中断级任务切换）。可以想象，如果没有中断嵌套计数变量，退出高优先级中断B的时候运行函数OSIntExit();有可能会执行中断级任务切换，此时执行任务切换的话就会破换正常的寄存器入栈和出栈顺序，从而使得系统崩溃。其实进入Cortex-M3/M4时代已经不存在这个问题了，因为我们设置PendSV中断为最低的优先级（任务切换是在PendSV中断里面执行的），PendSV中断会在所有其它高优先级中断执行完后才会得到执行。

为了使得μCOS-III可以适应各种处理器内核和复杂的系统设置，中断嵌套计数还是很有必要的。

3. 当前任务控制块指针OSTCBCurPtr和最高就绪任务的任务控制块指针OSTCBHighRdyPtr都指向了0地址空间。初始为指向0地址空间主要是为了使这两个指针变量都有个初始量。而且方便后面用到这两个指针变量的函数进行检测。

4. 默认安全关键的标志OSSafetyCriticalStartFlag是关闭的。

5. 这里个两个变量：OSSchedRoundRobinEn = DEF_FALSE;

OSSchedRoundRobinDfltTimeQuanta= OSCfg_TickRate_Hz / 10u;

是用于配置时间片的，默认时间片调度是关闭的，时间片大小是OSCfg_TickRate_Hz / 10u。这两个关于时间片的配置变量大家一定要记住。

6. 这里是几个钩子函数指针，初始化钩子函数，关于钩子函数，咱们在上期教程有详细讲解。

函数中还有有很多其它的初始化，我们会在后面再跟大家详细的讲述。

赞评论

baiyongbin2009 回答时间：2014-12-25 17:03:59

11.9 任务切换

如果大家认真学习了前面几期教程，μCOS-III中的任务切换还是很好理解的。μCOS-III中的任务切换主要分为两部分，一个是中断级任务切换，另一个是任务级中断切换。

11.9.1 任务级任务切换OSSched()

任务级的任务切换主要通过下面的函数实现：

/*
! Z+ \3 O8 y% Y% f9 m+ U4 F
************************************************************************************************************ 任务级调度5 B) {$ k$ W+ v1 R; W. D/ r
*
( E: R; {. E7 W/ W& o4 L
* 函数说明: 此函数由其它的uC/OS-III函数调用，主要是用来获取当前需要执行的最高优先级任务，这个是任务级调度，* 要和前面的中断级调度OSIntExit()区分开。
' Q* t6 T8 M4 z3 e R4 M
* 形参: 无. P9 c" w2 ~- J$ _1 B
* 返回值: 无
0 g1 ?4 T" T, Z# J
* 注意: 1) 使用调度锁的话，调度功能将被关闭 (见 OSSchedLock())% _5 s B, L( J1 q) ]
***********************************************************************************************************2 `7 w p* b2 Y* \" ]9 _
*/( @% H3 l7 k- ~3 N+ W+ x7 E1 j8 t
$ S/ Y+ M9 [( c0 ]
void OSSched (void)+ L' s. |9 \: _0 B- @
{
f6 R; q7 J8 n& E: Y
CPU_SR_ALLOC(); （1）
/ I+ C4 [! C) T$ `
2 F6 M/ z1 ?- r3 M2 u' p8 x
+ M# \5 j, v/ ]9 q) h# l
# ^3 ]6 X( w% d' [7 r3 e1 E3 p! S
if (OSIntNestingCtr > (OS_NESTING_CTR)0) { /* 是否存在中断嵌套? */ （2）+ y) ?; `1 K9 \& Z" L
return; /* 是 ... 只有不存在中断嵌套的时候才能调用 */
' @) e' V. @9 _" N) R: S. v5 P6 g1 q
}
; S. O2 L3 [& \/ L9 k6 l4 ]
0 [7 a/ t7 ?+ }1 W
if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) { /* 使用调度锁? */ （3）4 s; l" V$ U" Q/ G- p k
return; /* 是 */5 p& a' c& N+ {0 q3 V
}
& F, i* _" B2 N c; [ ~5 J
4 W4 I) j( p5 f3 j) P5 u4 E" G
CPU_INT_DIS();
OSPrioHighRdy = OS_PrioGetHighest(); /* 获取当前需要执行的最高优先级任务 */ （4）
2 J& z. h& R- W, X7 G5 `
OSTCBHighRdyPtr = OSRdyList[OSPrioHighRdy].HeadPtr; （5）
0 w0 u M& T) ]' m7 _) P7 y
if (OSTCBHighRdyPtr == OSTCBCurPtr) { /* 获取的最高优先级任务是否是当前任务 */$ Y2 V9 U" R3 s* i
CPU_INT_EN(); /* 是 ... 不需要执行任务切换 */
/ T' Y6 F5 Z6 T5 V
return;
) q! R j* r2 H; q+ K
}$ `# ?4 I0 a+ i
8 K' X: c9 ]% v/ |9 x F6 h3 I- M) r
#if OS_CFG_TASK_PROFILE_EN > 0u' Q8 [3 s: m( m! f: y6 z
OSTCBHighRdyPtr->CtxSwCtr++; /* 增加此任务的切换次数 */
3 a! @6 F& y: E* U
#endif1 c6 e8 h, W1 {" y( {0 t6 ]$ [4 T
OSTaskCtxSwCtr++; /* 增加总的任务切换次数 */
; E9 T( \' D0 x+ N0 x3 d7 Y. i
# g8 P& S( J u& U, d
#if defined(OS_CFG_TLS_TBL_SIZE) && (OS_CFG_TLS_TBL_SIZE > 0u)- r9 G1 L1 Y* q" A& E# V/ r3 q, Z
OS_TLS_TaskSw();" f; o1 ]2 \. R0 u( w& j. D( q- |) v
#endif
) d# }4 T' Q1 w/ |
0 R' f& m7 W; K
OS_TASK_SW(); /* 执行任务切换 */ （6）
* c; N7 M7 n+ l1 X( s
CPU_INT_EN();
# E1 c3 F0 t7 f" K0 }3 B+ b
}

复制代码

1. 这句话在前面临界段小节有讲，这里是定义一个局部变量。

2. 存在中断嵌套的情况下调用这个函数会返回。

3. 调度器被锁的情况下调用这个函数会返回。

4. 这个函数是获取当前需要执行的最高优先级任务的方法，也算是调度器的核心，在下期教程会给大家详细的讲解。

5. 由于μCOS-III已经支持时间片调度，这句话是从同优先级的链表中获得当前需要执行的任务。

6. 执行任务级任务切换。

5 }, t6 l+ x! x11.9.2 中断级任务切换OSIntExit()

中断级任务切换是由中断函数调用的，内容如下：

/*0 k4 r1 D t6 g/ c
***********************************************************************************************************
! A' d9 B h7 o4 d3 ]4 K
* 进入中断服务程序
/ ~- j: |7 F; A
* 功能说明: 此函数用通知uC/OS-III系统程序将要执行interrupt service routine(ISR)。这样uC/OS-III就可以不断
# y3 O' L# W- W
* 跟踪中断嵌套次数的变化，这样就能够保证系统只有在最后一层中断执行任务调度。
+ X C# R' c* v( b0 p
* 形参: 无; ?* l/ K. a- I* n) [+ I+ }/ w; L3 w
* 返回值: 无
" n3 T, ?/ @: c5 H
* 注意: 1) 此函数必须在中断关闭情况下调用。+ F5 O) H9 _6 D: ~) F
* 2) 用户可以不调用这个函数，直接调用全局变量OSIntNestingCtr进行操作即可。
7 f; m: F- n* o/ ~+ K0 D( T! l
* 3) 用户必须调用函数OSIntExit()，即使直接的操作'OSIntNestingCtr'。
6 [/ y! s$ O2 B" q: M
* 4) 用户必须成对的调用OSIntEnter() 和 OSIntExit()。换句话说，用户必须在中断服务程序开始和结尾的
. X1 L$ O a2 ^+ q/ n( d
* 时候成对调用OSIntEnter() 和 OSIntExit()。
* 5) uC/OS-III系统的中断嵌套层数最高250。. Z1 H" b& w: R" m6 j( t0 k. h; K& ~
***********************************************************************************************************5 o7 f4 s4 Z5 m L8 h1 y/ q
*/* x; G3 F( e( [0 ~
$ w" w0 N9 o% y! g# I
void OSIntEnter (void) （1）
. I" Z" W6 R/ c* |- j* p+ M
{/ L- n8 o$ w8 V7 L9 F L8 _
if (OSRunning != OS_STATE_OS_RUNNING) { /* 检测OS是否开始运行 */
* R- \" x) R( @. ~$ P4 H, W9 I8 @
return; /* 否，返回 */8 B2 g% `. E- I U' x& D
}
7 s( w; e1 f) U
x2 u7 t% l, I% X/ P# r
if (OSIntNestingCtr >= (OS_NESTING_CTR)250u) { /* 中断嵌套次数是不是超过250 */- o! e1 I) ?6 R# N# v. `. m
return; /* 是，返回 */
+ C/ A y/ R( Y6 W( B
}6 @# f4 }5 k+ F6 w
# V$ k- y% J1 V, m8 _
OSIntNestingCtr++; /* 中断嵌套次数执行加一 */ （2）7 W8 j, b; e5 e2 d) c3 @7 [1 m
}
. L! I m0 \ T1 @' y+ e$ d( T
4 J3 C% Z' n" X5 J
/*$ M& m, T1 c* ~( A: m. A. w
***********************************************************************************************************
- x+ I' d1 J& v+ v1 f% E% \
* 退出中断服务程序 I B; O! L! S/ }' `: f: ?- z
*; [+ b% l [' \- ?
* 函数说明: 此函数用于通知uC/OS-III系统已经完成中断服务程序，然后调用调度器决定是否切换还到新的高优先级任务
, ]& E# }; y: j4 V* [/ f3 t+ E7 D
* 形参: 无
Q& P6 V/ U1 K4 T9 f
* 返回值: 无; C$ u- }: g- w; j2 V- ~
* 注意: 1) 用户必须成对的调用OSIntEnter() 和 OSIntExit()。 |: P" j: V" a: [% t. t
* 2) 使用调度锁的话，调度功能将被关闭 (见 OSSchedLock()), P8 _3 V( ]4 m+ O I
***********************************************************************************************************; j8 |& f8 t ?5 ?
*/: n T+ b* m- O+ F: ~# i* H
+ [; R* t' x: ^+ | Y, b/ n
void OSIntExit (void)
' O: ~4 G' F1 w) C" V1 [
{
; S- h" l& k/ W- T
CPU_SR_ALLOC();7 a i# \! v/ q
! U# N, {2 X+ p& ^7 E! K" p a
' p. M0 p) ~6 _0 n9 g& U1 `
, Y6 V+ Z: P' _' L# C7 G
if (OSRunning != OS_STATE_OS_RUNNING) { /* OS是否开始运行 */" _5 x( S% e* C
return; /* 否，返回 */
/ v" D" t9 |. ^
}" D6 _0 n8 F' ]$ Y
9 _6 ` j4 \& t3 k
CPU_INT_DIS();
1 R3 Q( |& W8 Q8 m: Z
if (OSIntNestingCtr == (OS_NESTING_CTR)0) { /* 防止错误使用，在这个函数OSIntNestingCtr不会为0的情况 */
" W. o8 r) w# O/ V3 {7 o
CPU_INT_EN();1 t Z9 P9 g# B7 Q$ w( @' ~; W: L
return;
' x' i9 ]. A, q! g- H% `
}
9 M) U n5 \4 ? t1 E1 d- P
OSIntNestingCtr--; （3）/ a: ]( X: E* [7 h- Z
if (OSIntNestingCtr > (OS_NESTING_CTR)0) { /* 是否还存在中断嵌套 */0 p$ V0 V" }: G3 E) N/ d
CPU_INT_EN(); /* 是，返回 */( K' z( {' Q! C! J/ |
return;1 N: t! A& |( u6 |6 O
}
3 i: S1 O4 Z" c1 _4 f
( A7 j$ ^) O+ B7 p% }
if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) { /* 是否有使用调度锁 */
& L: |& S- A: I& _
CPU_INT_EN(); /* 是，返回 */' ?- x9 H7 o9 u, p3 N% ~/ w! P! }3 Z
return;3 Z, W; H. c4 G9 R
}! z: t+ m4 N! z: v4 e' E
) c. f8 |( ?, J/ }: V- |2 O6 U; i
OSPrioHighRdy = OS_PrioGetHighest(); /* 查询需要执行的最高优先级任务 */# u0 B, _. M7 `+ Y2 Z
OSTCBHighRdyPtr = OSRdyList[OSPrioHighRdy].HeadPtr; /* 获取最高优先级任务的TCB地址 */
3 T- ^$ D" Y g- n/ ~, G- @) ^" d; i
if (OSTCBHighRdyPtr == OSTCBCurPtr) { /* 获取的最高优先级任务TCB是不是当前任务 */
1 n% l7 I0 G3 K+ J% q, m# E; m
CPU_INT_EN(); /* 是，返回 */
& A7 u g r8 |$ N8 ^3 H! k
return;- p3 \/ ]* f0 M, }$ s- O9 b$ E, L- p
}1 \5 N2 Q7 \7 I
, W( ^6 |% z' h+ R- `
#if OS_CFG_TASK_PROFILE_EN > 0u
2 H& @8 s7 t6 f( ^6 b+ B/ m
OSTCBHighRdyPtr->CtxSwCtr++; /* 任务切换次数加一，这里是指的某个任务的切换次数 */1 U* Z' y4 F4 x! p7 M* T8 v
#endif
# [( Z6 u5 w9 m6 \: f& Z
OSTaskCtxSwCtr++; /* 系统总的任务切换次数 */
, K/ e' m" G! h7 z+ G
# G' c8 s) M& m4 E4 |
#if defined(OS_CFG_TLS_TBL_SIZE) && (OS_CFG_TLS_TBL_SIZE > 0u)0 s4 f3 h% k# ]8 O) M5 J( _8 i
OS_TLS_TaskSw();
$ M/ h+ o. i6 ?
#endif; c' k( S7 ^1 Q! D: Z
! d; S G5 }0 X$ r# H; V7 T3 ]
OSIntCtxSw(); /* 执行中断级任务切换 */ （4）
& R4 v# ^3 u/ G7 A. ]. S. x- C/ `
CPU_INT_EN();
' S, b9 A1 ]- T
}

复制代码

1. OSIntEnter()和OSIntExit()必须配套的使用，要不会造成嵌套计数错误。

2. 嵌套计数加一。

3. 嵌套次数减一。

4. 执行中断级任务切换。

- \ J) C9 z6 h9 l2 ^4 r2 X- w11.9.3 函数使用举例

函数OSSched ()不是供用户调用的，而函数OSIntEnter() 和 OSIntExit()是供用户在中断任务中调用的，下面举个例子：

/*
+ v x8 ^, Q" l
*********************************************************************************************************6 Z' _9 A# q7 l' D
* 函数名: SDIO_IRQHandler( M. D9 l8 d5 L6 y
* 功能说明: SDIO中断服务程序
* i/ F; i' g: `# u& Y% y
* 形参：无2 o2 l' j+ e9 l$ S* J4 M+ h
* 返回值: 无
( u9 t# R4 H3 t9 i, b
*********************************************************************************************************8 Z1 Q( [: ^! O/ E, G
*/: Z6 f9 z/ x. o3 a2 {
void SDIO_IRQHandler(void): U @- v6 O# o% t) j; q+ a
{
8 \' g( a8 Z2 t) q5 F# R
CPU_SR_ALLOC();: d( W8 `+ h( Z' l! [ i, ]/ J
5 U0 Y0 ?, ?& {4 c( F
CPU_CRITICAL_ENTER();
* O# F6 Z4 y( P8 |7 J% T
OSIntEnter()6 Y6 F) b( C; t7 y. ]
CPU_CRITICAL_EXIT();
5 Y/ ], `( ~- I- k$ D/ d+ m
: }' _4 g; d& N* g: e, K
SD_ProcessIRQSrc();
% A/ q7 ?( h+ p' h' V; N
% a$ @: [! O+ }
/* 在os_core.c文件里定义,如果有更高优先级的任务就绪了,则执行一次任务切换 */6 v9 l ]. O& D+ g: X
OSIntExit();
8 D9 M3 ~1 p9 m/ h/ m$ L0 q
}

复制代码

赞评论

baiyongbin2009 回答时间：2014-12-24 19:58:39

（续）11.1 系统配置文件
11.1.3 os_cfg_app.h配置文件

os_cfg_app.h文件的内容如下：

#ifndef OS_CFG_APP_H) B( A5 [+ M0 _" F7 A
#define OS_CFG_APP_H/ b) t; Y$ O' Q, B" N
7 i; B: |3 G1 m; T6 l
/*
+ P, o) `- \2 l9 d. Z
***********************************************************************************************************
% p }1 C9 P6 F: D! L
* CONSTANTS
2 }3 s" y; y: ~' y* ] [' q: M
***********************************************************************************************************% l1 @7 V6 K* g9 z/ C# T5 D
*/6 b& v. T* m" l+ X
* x& N* l/ z2 b$ {. T
/* --------------------- MISCELLANEOUS ------------------ */
3 X8 W1 k$ o) B5 p+ l$ r) e
#define OS_CFG_MSG_POOL_SIZE 100u /* Maximum number of messages */
4 B/ b: o0 K( i$ w2 F
#define OS_CFG_ISR_STK_SIZE 256u /* Stack size of ISR stack (number of CPU_STK elements) */3 h) E3 x7 S! B
#define OS_CFG_TASK_STK_LIMIT_PCT_EMPTY 10u /* Stack limit position in percentage to empty */% Y O2 w) B0 Z
: \' k, h0 i( b; i- I. n2 N1 y. m' s$ R
. i: D, h* J# h) s+ w
/* ---------------------- IDLE TASK --------------------- */
- Z/ }8 ? o) k2 n1 R: l% L" ^
#define OS_CFG_IDLE_TASK_STK_SIZE 128u /* Stack size (number of CPU_STK elements) */
6 \' {& h- G3 M' U
3 ^" F! z6 t9 H( G8 C# a
T. e; @7 K3 f5 W! i5 Y
/* ------------------ ISR HANDLER TASK ------------------ */
% U' n5 g0 m9 P# u' `1 B3 C8 `. B0 X
#define OS_CFG_INT_Q_SIZE 10u /* Size of ISR handler task queue */
5 @2 Y0 h; i7 g; `
#define OS_CFG_INT_Q_TASK_STK_SIZE 128u /* Stack size (number of CPU_STK elements) */5 U4 L, T& z3 F7 o4 `$ a
# G# |/ l1 N1 k7 X# p9 D. c' l
/* ------------------- STATISTIC TASK ------------------- *// ]8 v+ a5 O/ M
#define OS_CFG_STAT_TASK_PRIO (OS_CFG_PRIO_MAX - 2u) /* Priority */* t: d; S6 Z# j
#define OS_CFG_STAT_TASK_RATE_HZ 10u /* Rate of execution (10 Hz Typ.) */
- _8 b- }' I+ a; h7 ^& g/ x
#define OS_CFG_STAT_TASK_STK_SIZE 128u /* Stack size (number of CPU_STK elements) */, S* `; N' I' @9 ^% Z8 x5 \) l
, h9 O, `7 [7 ]3 L
! z$ h( P/ M$ `4 @6 t1 a
/* ------------------------ TICKS ----------------------- */7 q; J! g8 [/ o. D% A9 J2 n
#define OS_CFG_TICK_RATE_HZ 1000u /* Tick rate in Hertz (10 to 1000 Hz) */
' W' Z7 U& p2 C n6 c4 F) j1 k2 ^
#define OS_CFG_TICK_TASK_PRIO 1u /* Priority */
4 s: w6 l" l% M+ ?
#define OS_CFG_TICK_TASK_STK_SIZE 128u /* Stack size (number of CPU_STK elements) */1 d! w8 ?" h. t
#define OS_CFG_TICK_WHEEL_SIZE 16u /* Number of 'spokes' in tick wheel */
; o" X/ r1 {: D! r
& T3 z5 W! D+ L
/* ----------------------- TIMERS ----------------------- */* M6 G- [9 _+ a, F) C. Z6 Y
#define OS_CFG_TMR_TASK_PRIO (OS_CFG_PRIO_MAX - 2u) /* Priority */
% @8 f* E- b9 Q+ i* n/ @
#define OS_CFG_TMR_TASK_RATE_HZ 10u /* Rate for timers (10 Hz Typ.) */
. L" p; o% x4 y& E* p& N
#define OS_CFG_TMR_TASK_STK_SIZE 128u /* Stack size (number of CPU_STK elements) */
% L) T) T* Q( {8 x
#define OS_CFG_TMR_WHEEL_SIZE 17u /* Number of 'spokes' in timer wheel */. h( w: Y2 } i6 D4 N5 W, W
/ S* w4 M4 k/ G% i+ o
#endif

复制代码

这个文件主要是内核任务的配置，包括中断管理任务，空闲任务，统计任务，嘀嗒定时器任务已经定时器任务。

11.1.4 app_cfg.h配置文件

app_cfg.h文件夹中的内容如下：

#ifndef APP_CFG_MODULE_PRESENT
8 E6 t% k! v; N# k
#define APP_CFG_MODULE_PRESENT6 ~; w+ B" W; K
- D- ]' ^) _5 g3 ? b0 W) |
& x7 Q' V' {0 ^6 [4 M
/*
" V1 T$ `& ?5 @9 j4 J' M, p1 F
*********************************************************************************************************, R. {% l8 O/ n* L4 Y7 V
* TASK PRIORITIES( R: [ Y- o' v) Y6 c
*********************************************************************************************************
: R1 E4 q; {( }6 V& c
*// i% N% S$ Z/ } I4 ]' a2 D' u
0 f5 d! x' w! L9 R( ~! e4 L
#define APP_CFG_TASK_START_PRIO 2u
( H* \; y! Y$ y) |) [2 s
#define APP_CFG_TASK_UPDATE_PRIO 3u
) v9 C) g2 {: C+ e
#define APP_CFG_TASK_COM_PRIO 4u
- X# O, w$ q# O/ m1 h d
#define APP_CFG_TASK_USER_IF_PRIO 5u; |6 s' z1 Y5 P: k5 r
#define APP_CFG_TASK_GUI_PRIO (OS_CFG_PRIO_MAX - 4u)5 T' j! |) m0 m/ [" t* r
#define APP_CFG_TASK_GUIRefresh_PRIO (OS_CFG_PRIO_MAX - 4u)
* n" p# l0 Q, w6 M" K5 ~
$ G/ Y9 [3 R, Z, D
/*
5 W/ M- z9 m/ i
*********************************************************************************************************
. ^* k& e! y$ `/ ^$ ~1 R& E: x
* TASK STACK SIZES8 { h" M* u: E
* Size of the task stacks (# of OS_STK entries)
7 q# x$ {8 ^2 I; C4 P: `. ~
*********************************************************************************************************
1 N3 c& n7 a" ^! J8 d- w0 g0 o8 _+ X, g
*/
4 O' ?2 S4 f+ o- G0 `) l/ A
& D+ k& W$ W9 z( J2 l5 }
#define APP_CFG_TASK_START_STK_SIZE 1024u
7 F1 x) P9 n; X8 @! G) L5 J' M! u
#define APP_CFG_TASK_UPDATE_STK_SIZE 1024u0 P/ N- i+ D/ F* i ]' W4 }1 Z
#define APP_CFG_TASK_COM_STK_SIZE 1024u
8 o+ V; C: E' K5 A2 [
#define APP_CFG_TASK_USER_IF_STK_SIZE 1024u! j; b3 q% [/ ]0 c* j; i
#define APP_CFG_TASK_GUI_STK_SIZE 1024u
# h0 T! T0 g9 n4 J* `* ?; |
#define APP_CFG_TASK_GUIRefresh_STK_SIZE 1024u
* l1 F0 E* r8 `6 y( i" N& e( p
2 A% k0 d9 c7 }7 ^) O
#endif

复制代码

这个文件主要用于用户任务的配置。

赞评论

baiyongbin2009 回答时间：2014-12-24 19:59:09

（续）11.1 系统配置文件
11.1.5 cpu_cfg.h配置文件

cpu_cfg.h文件中的内容如下：

#ifndef CPU_CFG_MODULE_PRESENT/ X7 t/ v0 v& i% C5 w) \( v
#define CPU_CFG_MODULE_PRESENT' n$ p; m5 V, c# q$ N- x( z
Q% n5 w/ P% t& O) x
" i9 @; \, k/ l" h7 n0 |
/*
+ ^ H+ L M& A: N- ^' z+ f( Q. L
*********************************************************************************************************
( X3 C' g7 ?& ^' |
* CPU NAME CONFIGURATION* y7 _7 @/ ?* j# h! w
*
9 `8 g$ @" I5 t
* Note(s) : (1) Configure CPU_CFG_NAME_EN to enable/disable CPU host name feature :
5 k, d* j& J# a8 c1 v# s
*
{- A9 F' O' B
* (a) CPU host name storage
) _% d! B) S0 M5 j
* (b) CPU host name API functions; E( t8 s* ?- s. R
*
, p8 g7 k% ]6 }1 F, B- k7 _
* (2) Configure CPU_CFG_NAME_SIZE with the desired ASCII string size of the CPU host name,
% H8 I) z4 R5 `* a& K: B
* including the terminating NULL character.% [4 `. x+ x' m* f( x @( x
*: s0 n0 U: ~: ~; G! U. ^9 T3 w* k
* See also 'cpu_core.h GLOBAL VARIABLES Note #1'.
C& @' A9 n* W2 Y
*********************************************************************************************************% p* }5 A& q0 L. A" f7 w
*// w, V% d) `8 Q! Y2 k/ i+ A
# S/ m1 b" G J6 D0 r
/* Configure CPU host name feature (see Note #1) : */+ i+ t' w3 @! ?% y8 k
#define CPU_CFG_NAME_EN DEF_ENABLED: H+ D7 y7 D' Y$ s. d
/* DEF_DISABLED CPU host name DISABLED */
6 K# V3 g# y4 k
/* DEF_ENABLED CPU host name ENABLED */& N) s. {# _: P. }: f, [
" F5 z7 N: h% B; ?( r# {$ w
/* Configure CPU host name ASCII string size ... */
/ N+ b4 d5 B/ k, h1 p( Z/ N3 i5 G
#define CPU_CFG_NAME_SIZE 16 /* ... (see Note #2). */
5 Y$ f. H; T; \ V
6 j8 O( k' f( L4 x" R: b
/*
" ~( m1 ^ p7 O! h2 |4 o3 @0 J+ W& e
*********************************************************************************************************
. q( ~+ ]0 s1 x+ S* d
* CPU TIMESTAMP CONFIGURATION$ t& x! X( Y- Y- G! m
*9 f5 s+ c$ R9 {: t
* Note(s) : (1) Configure CPU_CFG_TS_xx_EN to enable/disable CPU timestamp features :
9 H: o5 A0 h- b3 n4 f
*
/ y. _. |" C/ _; g
* (a) CPU_CFG_TS_32_EN enable/disable 32-bit CPU timestamp feature
& w& t/ J$ {) G( S/ {! G
* (b) CPU_CFG_TS_64_EN enable/disable 64-bit CPU timestamp feature& b( V0 |! t' H" E
*
% a. x- y" ~0 f. T( {) v+ V
* (2) (a) Configure CPU_CFG_TS_TMR_SIZE with the CPU timestamp timer's word size :/ w, M* m$ x& M1 V- \' I
*
9 N0 p4 [7 J7 f: ~8 Z* f
* CPU_WORD_SIZE_08 8-bit word size
2 o" Y* W2 H5 r' y* r
* CPU_WORD_SIZE_16 16-bit word size: B. z' R* a W O0 J
* CPU_WORD_SIZE_32 32-bit word size& }1 J1 D6 P4 ^6 |( r
* CPU_WORD_SIZE_64 64-bit word size0 o; C& y( A3 @1 T: C, |
*
: x+ ]( o2 U8 f/ e
* (b) If the size of the CPU timestamp timer is not a binary multiple of 8-bit octets }" v6 I$ v( w
* (e.g. 20-bits or even 24-bits), then the next lower, binary-multiple octet word5 m% Q& ]9 r0 S
* size SHOULD be configured (e.g. to 16-bits). However, the minimum supported word7 J0 z( I' z& X2 v) C8 ]: r4 O2 r7 F
* size for CPU timestamp timers is 8-bits.! C+ v$ F4 x$ ?9 m5 y8 u$ ~
*& h; \; v1 p: v
* See also 'cpu_core.h FUNCTION PROTOTYPES CPU_TS_TmrRd() Note #2a'.
& t4 J2 l4 g+ x1 E, |
*********************************************************************************************************# C0 O1 g( I8 l5 P7 W* b
*/
! E6 t) ~# ~4 g1 ~, c9 \
9 y; d3 Q& [- G6 J( V1 S# j; {* K- |
/* Configure CPU timestamp features (see Note #1) : */
! ~# ?9 j9 }" _* x
#define CPU_CFG_TS_32_EN DEF_ENABLED
! K6 D* J# G6 G1 \4 }8 B
#define CPU_CFG_TS_64_EN DEF_DISABLED
; H, g; v( f# h( o6 Q8 \
/* DEF_DISABLED CPU timestamps DISABLED */3 n/ J" r! h# D- b" P7 H: `
/* DEF_ENABLED CPU timestamps ENABLED */0 y$ p% f5 C7 y5 Y5 h
) X8 n: }4 k+ G+ d. l
/* Configure CPU timestamp timer word size ... */. D0 e+ a# i5 p
/* ... (see Note #2) : */( c& d4 q* G9 h% F0 c/ b
#define CPU_CFG_TS_TMR_SIZE CPU_WORD_SIZE_32* d! {% w$ ?8 B& H: Z* [6 m2 }
$ `4 q4 v! i7 ?! ?; f6 c) T
6 Z0 D- z; c7 P1 r8 `. H
/*
: x, M: d: `1 s6 m) N8 l1 B* s5 m9 t/ W
*********************************************************************************************************: j$ w# G6 ~0 e4 V
* CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION; _# o6 O4 X. R7 W
*; s* Y, e: e* s5 E( u, Y
* Note(s) : (1) (a) Configure CPU_CFG_INT_DIS_MEAS_EN to enable/disable measuring CPU's interrupts
2 f% Q( j1 W" P( j+ _) F4 D$ V3 v
* disabled time :
0 r$ t* q6 W) G4 J0 y# c
*
; M# I) L+ V$ a/ d- B: n) X" }
* (a) Enabled, if CPU_CFG_INT_DIS_MEAS_EN #define'd in 'cpu_cfg.h'
* @/ _- ~0 n! E
*
; V0 x+ r) e, a0 j, ]5 I
* (b) Disabled, if CPU_CFG_INT_DIS_MEAS_EN NOT #define'd in 'cpu_cfg.h'
0 F9 F" ~7 _' O& O" ?; B
*3 |7 B2 u3 Z0 \0 `; Z7 @
* See also 'cpu_core.h FUNCTION PROTOTYPES Note #1'.
6 e8 c4 x# t5 Q$ a
*' o+ Y0 ?1 V3 e7 ?
* (b) Configure CPU_CFG_INT_DIS_MEAS_OVRHD_NBR with the number of times to measure &
5 q) Z& _! f6 m- H3 p
* average the interrupts disabled time measurements overhead.
0 A8 f" @, b7 Z, e( R/ E/ T! Z
** B+ [ h& N0 F9 J% o
* Recommend a single (1) overhead time measurement, even for instruction-cache-enabled2 J- ]6 \( A) ?4 O. H
* CPUs, since critical sections are NOT typically called within instruction-cached loops.' t$ p. W& `: t @2 b0 z
* Thus a single non-cached/non-averaged time measurement is a more realistic overhead
, I+ X w, C- p2 Y( h
* for the majority of non-cached interrupts disabled time measurements.
' ?& x, p: i% k
*
2 d; T# _8 C$ u8 t# W7 R6 v
* See also 'cpu_core.c CPU_IntDisMeasInit() Note #3a'.
7 ^0 h' V. h8 q' j
*********************************************************************************************************. f4 ~" Z8 Q* I5 l7 I! s" |2 R- C; {
*/$ |# Q" g. Y2 {! M$ @- }
$ _7 w: ]+ ~0 [# f* P8 U
#if 0 /* Configure CPU interrupts disabled time ... */
. x. F7 K; |+ t% f- j
#define CPU_CFG_INT_DIS_MEAS_EN /* ... measurements feature (see Note #1a). */: o5 O( |" B+ J
#endif) v! e, ^( b( x, o
( h! V: e/ }! `; c) C x k" O
/* Configure number of interrupts disabled overhead ... */
' P' E1 R+ t+ e5 T% {0 {" z" Z
#define CPU_CFG_INT_DIS_MEAS_OVRHD_NBR 1u /* ... time measurements (see Note #1b). */9 \; r" q/ J8 S) c+ W
6 f( u" u) K/ s; t* u) R9 c1 A1 }, `
/*# O+ K9 M; F( _- E( x: J8 H
*********************************************************************************************************
! T9 ]0 ~# s8 U% @; P
* CPU COUNT ZEROS CONFIGURATION9 X0 u- z% g% ?" r
*/ E3 b$ F% Q" r& J+ ?
* Note(s) : (1) (a) Configure CPU_CFG_LEAD_ZEROS_ASM_PRESENT to define count leading zeros bits- G" p0 i. H! m. i# X9 \
* function(s) in :
1 p( `) E: F& U7 _5 `
*! h3 b. p3 S& f2 z0 a& `
* (1) 'cpu_a.asm', if CPU_CFG_LEAD_ZEROS_ASM_PRESENT #define'd in 'cpu.h'/
+ j. b, b( h4 Q, Q! o r
* 'cpu_cfg.h' to enable assembly-optimized function(s)
6 i1 {, L& J( X# M) P, g& }
*+ ~5 u8 t' y+ x0 l. J
* (2) 'cpu_core.c', if CPU_CFG_LEAD_ZEROS_ASM_PRESENT NOT #define'd in 'cpu.h'/
2 R! O* R: V. |/ ]
* 'cpu_cfg.h' to enable C-source-optimized function(s) otherwise
# ]6 P8 ^7 c, X& G- j8 J
*/ v2 _% C* q9 J7 F
* (b) Configure CPU_CFG_TRAIL_ZEROS_ASM_PRESENT to define count trailing zeros bits
& D2 o2 |* y1 p. [8 v n3 [
* function(s) in :. t+ j( K0 Z; t9 q+ u3 R
*- G- A2 O# t0 ^( n7 P7 `
* (1) 'cpu_a.asm', if CPU_CFG_TRAIL_ZEROS_ASM_PRESENT #define'd in 'cpu.h'/
: I* h) k. c. U9 z i
* 'cpu_cfg.h' to enable assembly-optimized function(s)6 L' ^0 b$ X& l: A, i: b7 n e: K: v
*
( D! @' u" V( }% b' u
* (2) 'cpu_core.c', if CPU_CFG_TRAIL_ZEROS_ASM_PRESENT NOT #define'd in 'cpu.h'/
' b) C' B: \; A# r
* 'cpu_cfg.h' to enable C-source-optimized function(s) otherwise
- ]! L5 D8 c0 J- f7 e
*********************************************************************************************************0 t% H+ l/ U/ R! @2 |, [7 @; l0 W
*/
* T; Y$ {6 c$ [( R" {+ w" u
# ]. i( o5 c1 p2 F2 N+ R4 l
#if 1 /* Configure CPU count leading zeros bits ... */4 d& E! W4 K! Y: | ]8 U+ @
#define CPU_CFG_LEAD_ZEROS_ASM_PRESENT /* ... assembly-version (see Note #1a). */
% }7 z' w+ c$ J! y0 W) _( N
#endif
, V0 A2 N, H9 q/ q+ @
& O1 J8 ^% Y5 u* _0 h, l! h
#if 0 /* Configure CPU count trailing zeros bits ... */
: e/ F& N* l9 d% ? Q" P% n! r
#define CPU_CFG_TRAIL_ZEROS_ASM_PRESENT /* ... assembly-version (see Note #1b). */
0 _# ?' _' s# }$ J" {
#endif
1 z- x5 @3 W, R. L
& \ w ], Z F: ^5 V1 M) o, f
/*- o, r+ ?7 ?$ y, I
*********************************************************************************************************! ^: [% Z1 ^, O! r. k
* MODULE END B v4 L \ x+ O5 {8 n
*********************************************************************************************************
B- a% j4 [$ H1 e3 ^
*/1 z4 f! |) z* e a
7 d2 i5 C# t. A @* ?6 \$ i8 m
#endif /* End of CPU cfg module include. */

复制代码

这个文件里面主要是uC/CPU相关的配置。

赞评论

baiyongbin2009 回答时间：2014-12-24 20:00:19

11.2 源码文件

μCOS-III中的源码主要包含如下文件：

上面截图中是μCOS-III相关的源码文件，后面的几期教程就是把这几个文件讲清楚。本期教程主要是讲解os_core文件中的相关函数。学期源码前还有看一下os_type.h文件中的内容（主要是变量的类型，这个一定得了解下）：

/*0 S3 C1 M- w8 v! `3 R
***********************************************************************************************************
1 s$ |) c) v0 }( G }- b
* INCLUDE HEADER FILES
}2 q4 p/ c/ K9 m* w. L. |& r
***********************************************************************************************************8 z8 |/ Y9 Q( N
*/
6 y- t1 W8 R8 D; {! U# s2 e
8 |3 d! w% i1 B% K2 q6 }# o& o
typedef CPU_INT16U OS_CPU_USAGE; /* CPU Usage 0..10000 <16>/32 */
& t: C) M' y1 a. U, B
( o9 b7 g% h- N1 S" A
typedef CPU_INT32U OS_CTR; /* Counter, 32 */" D' w; s7 M4 a# d/ J7 _" f* j
( n- {+ x. h0 b" q- x* l8 ^8 p
typedef CPU_INT32U OS_CTX_SW_CTR; /* Counter of context switches, 32 */2 y; N4 n/ m. R( m0 \ h
+ L) g3 W- ?" q( R/ A e
typedef CPU_INT32U OS_CYCLES; /* CPU clock cycles, <32>/64 */
8 l% E0 u; K* ?2 S2 r" Z D
) H5 }) e5 z" O; |& l1 O. d) {( w
typedef CPU_INT32U OS_FLAGS; /* Event flags, 8/16/<32> */
6 p/ s* w, F, y$ T: P) A
2 O9 G5 l: e" ~ k# u, l. f4 K y
typedef CPU_INT32U OS_IDLE_CTR; /* Holds the number of times the idle task runs, <32>/64 */
6 D, _$ K1 t" o z& A* z
4 |, V0 }$ D- m* f B* p9 n
typedef CPU_INT16U OS_MEM_QTY; /* Number of memory blocks, <16>/32 */0 H. x9 S; t# g" w; J5 \
typedef CPU_INT16U OS_MEM_SIZE; /* Size in bytes of a memory block, <16>/32 *// Z, q0 S, k$ L, T' \8 y
8 ?* u3 W/ t+ c+ a. r) P+ q
typedef CPU_INT16U OS_MSG_QTY; /* Number of OS_MSGs in the msg pool, <16>/32 */
7 F+ V* T% I; i
typedef CPU_INT16U OS_MSG_SIZE; /* Size of messages in number of bytes, <16>/32 */
, h4 s! {% \; h* u8 q& |; z
/ z: o! L8 k9 T- H. m; p$ d5 F; T0 h
typedef CPU_INT08U OS_NESTING_CTR; /* Interrupt and scheduler nesting, <8>/16/32 */
- F+ n) w# I+ S7 {1 X. d% ~
2 @% c# S* p/ O+ h0 Y0 K, Y5 s% Q* v! S
typedef CPU_INT16U OS_OBJ_QTY; /* Number of kernel objects counter, <16>/32 */
$ ~% B. x! ?3 D; f, ^
typedef CPU_INT32U OS_OBJ_TYPE; /* Special flag to determine object type, 32 */
( b$ u% |$ H3 }( L# W
5 m0 X4 m4 n& \6 ] r6 p) C; b
typedef CPU_INT16U OS_OPT; /* Holds function options <16>/32 */
2 h! O* ^, j1 Y! [3 y# ], c4 L! W* C
7 @9 M1 v1 W$ {- J* n
typedef CPU_INT08U OS_PRIO; /* Priority of a task, <8>/16/32 */( @5 T8 u$ I! d+ I1 M! _4 l# d+ K
2 D% z t" A4 y2 S) l9 o) p" Y6 S" w
typedef CPU_INT16U OS_QTY; /* Quantity <16>/32 */
! H' x( C2 L& _
& t% k2 M" Y, }( b ~7 {
typedef CPU_INT32U OS_RATE_HZ; /* Rate in Hertz 32 */
! f6 [1 R1 a; e$ X
6 o: L* P# Y% Z" ~, Y4 _
typedef CPU_INT32U OS_REG; /* Task register 8/16/<32> */
, }6 K4 z, s3 A0 {* H: a% Q
typedef CPU_INT08U OS_REG_ID; /* Index to task register <8>/16/32 */
* m6 v% \- A; g, v4 q$ I9 M* `9 l
# w6 c* |; k& }7 k
typedef CPU_INT32U OS_SEM_CTR; /* Semaphore value 16/<32> */
4 I6 u0 l D$ r P
, N6 C$ ]3 v6 K
typedef CPU_INT08U OS_STATE; /* State variable <8>/16/32 */) F O( |; @$ i
8 f3 p* r" ^( ?+ H5 k
typedef CPU_INT08U OS_STATUS; /* Status <8>/16/32 */0 h+ |! R2 e* R; p/ d
$ s0 `% \3 `9 o2 A, N
typedef CPU_INT32U OS_TICK; /* Clock tick counter <32>/64 */
B( W$ X+ i1 B
typedef CPU_INT16U OS_TICK_SPOKE_IX; /* Tick wheel spoke position 8/<16>/32 */. F/ Z6 W& e/ W/ m' A4 I/ |
- I+ B# q! J2 b( Z. q* o
typedef CPU_INT16U OS_TMR_SPOKE_IX; /* Timer wheel spoke position 8/<16>/32 */

复制代码

赞评论

baiyongbin2009 回答时间：2014-12-24 20:03:29

11.3 μCOS-III初始化

下面开始讲解os_core.c文件中的函数，这个文件里面的函数比较多，为了方便大家更好的学习这个文件中的相关函数，这里对其进行了分类，先从μCOS-III的初始化开始讲解。

11.3.1 初始化

根据前面os_cfg.h文件中的配置，用户可以配置程序中需要执行的函数。μCOS-III的初始化函数OSInit()中涉及的全局变量和函数的初始化比较多，这里将其汇总一下，下面是全局变量的初始化：

全局变量	初始值	变量说明
OSIntNestingCtr	0	中断嵌套的层数（0~250）
OSRunning	OS_STATE_OS_STOPPED	系统是否开始运行标志
OSSchedLockNestingCtr	0	调用了调度锁的嵌套层数
OSTCBCurPtr	0	指向当前正在运行任务控制块指针
OSTCBHighRdyPtr	0	指向最高优先级就绪任务控制块指针
OSPrioCur	0	当前正在运行的任务优先级
OSPrioHighRdy	0	具有最高优先级别的就绪任务的优先级
OSPrioSaved	0	保存任务优先级
OSSchedLockTimeBegin	0	使用调度锁起始时间
OSSchedLockTimeMax	0	调度器被锁的最长时间
OSSchedLockTimeMaxCur	0	当前调度器被锁的最长时间
OSSafetyCriticalStartFlag	DEF_FALSE	系统安全关键开始标志
OSSchedRoundRobinEn	DEF_FALSE	使能Round-Robin调度
OSSchedRoundRobinDfltTimeQuanta	OSCfg_TickRate_Hz / 10u	默认Round-Robin调度时间片大小
OS_AppTaskCreateHookPtr	0	任务创建钩子函数指针
OS_AppTaskDelHookPtr	0	任务删除钩子函数指针
OS_AppTaskReturnHookPtr	0	任务返回钩子函数指针
OS_AppIdleTaskHookPtr	0	空闲钩子函数指针
OS_AppStatTaskHookPtr	0	启动任务钩子函数指针
OS_AppTaskSwHookPtr	0	任务切换钩子函数指针
OS_AppTimeTickHookPtr	0	滴答定时器钩子函数指针
OSTaskRegNextAvailID	0	任务寄存器下一个有效ID

函数OSInit()中的其它初始化会在后面讲到的时候再做详细阐述。下面把初始化函数做一下分析。

赞评论

baiyongbin2009 回答时间：2014-12-24 20:07:43

11.4 ucos-III启动6 P0 X( @* Y ^

11.4.1 启动

不像其它RTOS，μCOS-III有一个标准的初始化过程，所以特别建议初学的同学按照这个过程进行初始化，如果不按照这个过程进行初始化，往往会出现莫名其妙的后果，标准的初始化流程如下：

/*
& Z2 H6 ~1 P! b, g+ J
***********************************************************************************************************; y2 [) v7 T- Q1 n5 k# e
* 函数名: main' s4 u& d7 X1 Q' m
* 功能说明: 标准c程序入口。1 i9 t# a. N/ s: s1 u# n
* 形参：无
" j- }1 v& Z: O2 z! T
* 返回值: 无
6 ]' W+ S& C- E9 X4 w$ c$ M
***********************************************************************************************************
/ r- Z: w! ?( n2 C; r' m
*/) l+ B' e0 O) S( Q9 z
int main(void)
& n% ?. \& |9 i* D9 r- \8 ^
{! [$ p4 W- p7 j( t* V
OS_ERR err;
9 x: M0 a2 v% a
. S* A; l; E, P' C7 n$ P, D
/* 第一步：初始化系统 */
4 a4 j! \7 u3 H* e
OSInit(&err);
* u2 E+ S. `5 s
: c. l- R3 d" j- n2 z
/* 第二步：至少创建一个任务，这里是创建了一个启动任务 */
' D$ p3 G$ r" S! k9 o, J' t
OSTaskCreate((OS_TCB *)&AppTaskStartTCB,
- @5 {* f" }# p* I. v; @
(CPU_CHAR *)"App Task Start",! o; N4 B7 F Q% Q
(OS_TASK_PTR )AppTaskStart,
7 Z G) y! S1 _; m$ u' J) O
(void *)0,
5 [+ O5 y* @5 X! r" o4 X2 m
(OS_PRIO )APP_CFG_TASK_START_PRIO,
+ q! x1 T: E% _1 Z& Z
(CPU_STK *)&AppTaskStartStk[0],; [6 P; [; \8 v8 m/ V
(CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE / 10,
[+ j2 _ V! r7 h1 P3 J! V0 p
(CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE,6 D9 z7 {! d3 ^' ~$ U& U* g
(OS_MSG_QTY )0,
" E9 L# j* f! a% z: s0 i
(OS_TICK )0,
1 i1 W; A& K+ e% H% V0 L. a2 z. B
(void *)0,4 W1 ^$ w( f. I' R/ r
(OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
& s/ a5 S1 v/ U% q
(OS_ERR *)&err);) ?1 ~& O6 b5 | ^9 V8 ]! ]4 W
( Q0 X# F K+ e) E* e4 R
/* 第三步：启动系统 */
! y& G* n( L8 ~2 f% T6 e3 I
OSStart(&err);
" k7 T; \- p; X: w* r" B3 z
(void)&err;+ M% c' g6 w. R) p
) B; p, t3 f/ x8 L t6 O2 p# f
return (0); e0 f0 K3 P0 O4 e( c$ K
}/ b* q# h: Q& n) L2 Y
5 q" N2 b4 h% m( d) |
/*2 H4 Y3 u& T4 o+ q& O6 j2 w
***********************************************************************************************************& O# H: H: I8 a( M( Y' q0 _
* 函数名: AppTaskStart$ g3 z* f+ F( a. n+ @
* 功能说明: 这是一个启动任务，在多任务系统启动后，必须初始化滴答计数器(在BSP_Init中实现); N! |: `" w7 w
* 形参：p_arg 是在创建该任务时传递的形参4 Z! R9 |. s, W% H$ Y
* 返回值: 无
! d1 h* V& S0 @& |% P& h; e6 O
优先级：2. e4 v3 q. y/ o0 k3 T7 i! }# {. H1 Q
***********************************************************************************************************6 N- J$ Q' G' K" B( \' q6 W& a
*/
1 C8 B' }0 d# \, }* V
static void AppTaskStart (void *p_arg)( H4 V9 M" M M$ F) V
{/ `, g) X- S& t
OS_ERR err;
" i: ]* n$ G2 B' e/ _8 { y
(void)p_arg;
- ]' y3 L- ^# l8 e; {6 g* c) I1 H0 j
$ V R, d5 ]- E: m* O
/* 第四步：初始化外设驱动 */ L5 V; N# q+ U6 f/ @* p
bsp_Init();/ Q) G- E; J& l9 P# Q/ L: q
CPU_Init();
: n L$ B5 u! C3 m
/* 第五步：初始化嘀嗒定时器 */7 o/ q( N, a7 g! r2 n1 T
BSP_Tick_Init(); 3 C4 q2 q/ P6 j9 @5 e z H
* {- q0 I" g5 Y) F9 G* s
#if OS_CFG_STAT_TASK_EN > 0u
; F- e+ ?$ ?& A( m( v2 t
OSStatTaskCPUUsageInit(&err);
+ F) {6 j! y% n! ~
#endif e% i/ z8 C; r G
4 M# d! p3 _4 G
#ifdef CPU_CFG_INT_DIS_MEAS_EN5 ?) X1 w& T1 j0 j
CPU_IntDisMeasMaxCurReset();
, ~; C8 R+ L3 {! K
#endif1 t) n) j7 i) U* W/ L
6 N/ W7 t3 f: D
AppTaskCreate(); - i. H; G1 ~8 P3 v
while (1)
1 l6 s+ V j& @
{
2 ^7 z6 X+ f X2 z
bsp_LedToggle(1);! S. R7 n' j8 P/ `* Q# \
OSTimeDly(1000, OS_OPT_TIME_DLY, &err);: P- k% N) r: Y
}1 G6 x2 V4 c) P8 `0 Z9 [
}

复制代码

上面的五部就是标准的初始化流程，一定要按照这个顺序进行，这个流程是官方推荐的。为什么要按照这个流程进行初始化？随着后面源码的讲解，大家会深刻的领悟到这一点。

11.4.2 启动函数OSStart ()

/*
6 n2 x' }" m1 Y% k
***********************************************************************************************************
" u: _7 c, P# N1 a3 s! U) h9 c' A2 G
* 开始多任务4 `/ Y1 A0 k: F% _# D
*
; O( @" c2 |/ _; {# k
* 函数说明: 此函数用开始多任务处理，调用这个函数前一定要先调用OSStart()，然后至少需要创建一个应用任务。% j3 V4 n { V) N/ F/ D
* 形参: p_err 错误代码指针变量" N- A3 q+ M3 X/ K, V2 [1 c8 g
* OS_ERR_FATAL_RETURN OS已经运行，OSStart()返回。
, `* ^4 \% b0 P# w8 j
* OS_ERR_OS_RUNNING OS已经开始运行, 再调用OSStart()无效
( {5 q0 P5 a: Z; J; z
* 返回值: 无& }5 u$ z" |( r* p5 l7 N. M
* 说明: 1) OSStartHighRdy():
J! Z7 ?: c7 ], V- y
* a) 然后调用OSTaskSwHook()
/ N( Z5 `6 v3 Z- w
* b) 加载OSTCBHighRdyPtr指向的任务控制块7 R2 {5 v4 P$ v8 Z( p
* c) 执行任务
" F1 P& I$ G5 q
* 2) 正常启动OS的话，函数OSStart()是不返回参数的。如果返回的话，会返回致命错误。
: W6 Q, O6 ^4 @8 k% v/ S" p
***********************************************************************************************************$ j( C- Q. l' v' Q$ N
*/
& H, ^, V# i7 F, W, L; T
/ T* Q+ g. [* L/ G9 _
void OSStart (OS_ERR *p_err)
4 A1 K) ^& f" I# w: d
{
: R2 H! A) A" C) Z$ [* x+ d3 X
#ifdef OS_SAFETY_CRITICAL （1） , T! _2 |" K+ W) `; z: r
if (p_err == (OS_ERR *)0) { o1 C; O* P# N& ^
OS_SAFETY_CRITICAL_EXCEPTION();( u8 Z! b$ t, W8 o5 w& G
return;: X5 I4 z6 I" u" U
}2 r0 q/ @) m; g4 M$ `. v/ R
#endif
" D9 W! v# h+ B* c0 N! Q; a* X
+ k' K% Z. j$ P, q. h9 l) C( {" X
if (OSRunning == OS_STATE_OS_STOPPED) { （2）9 W; g# @" X) e, m. V/ H% p9 P0 H+ x4 e
OSPrioHighRdy = OS_PrioGetHighest(); /* 获取需要执行的最高优先级任务 */ （3）
9 }# H9 Q9 Y% f+ v/ }$ K! A; T; X
OSPrioCur = OSPrioHighRdy;
, a2 P, |# B T, a: O/ j U
OSTCBHighRdyPtr = OSRdyList[OSPrioHighRdy].HeadPtr; （4）
' [, C; k" F( @2 ]2 ]) F
OSTCBCurPtr = OSTCBHighRdyPtr;$ o3 K; i4 m$ _7 F# x
OSRunning = OS_STATE_OS_RUNNING; （6）* Z Y- {, X3 ^
OSStartHighRdy(); /* 开始执行任务切换，执行最高优先级任务 */（7）- J% z+ [$ y; O0 C5 B+ L7 [! r5 b
*p_err = OS_ERR_FATAL_RETURN; /* 正常不会运行到这里 */ （8）! l& z3 R/ ]$ I4 v4 X1 F
} else {( }4 `! Z0 y4 K
*p_err = OS_ERR_OS_RUNNING; /* OS已经启动 */ （9）9 S4 z& o% U+ M b8 [1 G' `
}
9 t/ _0 h" A* _. _6 l& l
}

复制代码

1. 后面大家会看到，只要是供用户调用的函数和部分内部函数里面都会有这个安全关键代码，主要是用来防止错误的输入形参。

2. 前面初始化的时候，设置OSRunning = OS_STATE_OS_STOPPED，所以按照正常的初始化顺序，程序会进入到if语句中。

3. 通过函数OS_PrioGetHighest()可以获得当前需要执行的最高优先级任务，这个会在下期教程跟大家详细讲述。

4. 从任务的就绪链表中获得当前需要执行的最高优先级任务。

5. 设置系统的运行状态为OSRunning = OS_STATE_OS_RUNNING，然后开始μCOS-III多任务的执行。

6. 关于这个函数，咱们在上期教程中有详细的讲解，这个函数执行完就会进入到PendSV中断。

7. 正常情况下程序是不会执行到这里的。

8. 如果系统已经启动了，用户程序要是再次调用这个函数会进入到这里。

赞评论

baiyongbin2009 回答时间：2014-12-24 20:08:41

11.5 获取系统版本

有时候我们需要获取系统的版本号，下面就是系统版本的获取函数。这个函数比较简单，特别注意函数注释。

/** h5 R2 |" h+ D1 g6 q
***********************************************************************************************************
# u3 a' ^8 s7 C0 n; \
* 获取版本号% D! g$ ], J2 w( b
*
5 E8 a S7 T2 l0 p6 m' v
* 函数说明: 此函数用于获取uC/OS-III的版本号，获取的结果是原版本号乘以了10000，比如版本号是3.01.02，那么获
# \; b! k1 o& ^/ ^* m3 J
* 取的结果就是30102.
8 s: s5 X2 e- _& j3 k
* 形参: p_err 错误代码指针变量8 _+ q3 G9 G5 _2 O7 N) S' V
* 返回值: uC/OS-III的版本号乘以10000.
# }' f* C2 K5 L: `8 F: x
***********************************************************************************************************
* L& c$ q# h* V7 B, S
*/0 v5 N3 s& N! v# \6 a- l3 b+ ?7 x
9 ]6 [* I/ x" H, g
CPU_INT16U OSVersion (OS_ERR *p_err)* Z' L4 L( l8 z8 a( s' z$ U
{$ s/ w* w/ m# v1 {8 H5 w
#ifdef OS_SAFETY_CRITICAL
0 b# X# q3 P ~/ ]
if (p_err == (OS_ERR *)0) {
3 ^+ q) h! ^4 N/ ~
OS_SAFETY_CRITICAL_EXCEPTION();
: N: |" C3 K8 W+ z! O
return ((CPU_INT16U)0u);
( @0 G- u; K4 I g% ^" T3 y
}
' c1 c- g" P1 B# q( k) @
#endif
$ @1 F: L8 v7 z- L" s& t
7 q3 d- h) r0 h% N m
*p_err = OS_ERR_NONE;
3 d1 s- z2 R1 p2 @
return (OS_VERSION);
7 a* Q$ E& t! ~
}

复制代码

赞评论

baiyongbin2009 回答时间：2014-12-24 20:10:39

11.6 空闲任务

几乎所有的小型RTOS中都会有一个空闲任务，空闲任务应该属于系统任务，是必须要执行的，用户程序不能将其关闭。不光小型系统中有空闲任务，大型的系统里面也有的，比如XP，下面的截图就是XP中的空闲进程。

空闲任务主要有以下几个作用：

l 我们不能让系统一直在执行各个应用任务，这样的话系统利用率就是100%，系统就会一直的超负荷运行，所以空闲任务很有必要。

l 为了更好的实现低功耗，空闲任务也很有必要，我们可以在空闲任务中实现睡眠，待机等低功耗措施。

11.6.1 创建空闲任务OS_IdleTaskInit ()

/*
4 f- ]+ F# \& H0 ^& _2 {: @( {
***********************************************************************************************************
. _) s g! w* r' M6 P* R# P
* 初始化空闲任务9 W" u5 {) I# ~ m$ @! W, j, n4 `4 Y
* L0 B! I! A: K4 x: Q- d
* 函数说明: 此函数用于创建' D$ N3 f6 T: W+ _7 ^
* 形参: p_err 错误代码指针变量8 ]0 q# h% m; t' ]# U
* 返回值: 无
8 P: V7 L4 i, y+ {4 E0 ?
* 说明: 1) 这个函数属于uC/OS-III内部函数，用户程序不能调用这个函数。
5 C7 J- c! a) X4 \
***********************************************************************************************************9 H5 K& q, A. N7 L! v1 E, B5 E* ~
*/2 L6 z1 c5 `# s' ^
, D7 z L, Z2 b! Z7 r( ]) [
void OS_IdleTaskInit (OS_ERR *p_err)) y7 G/ g) z# u0 ]+ ^( K
{0 x; l) t, A5 [$ v" D- Q S) K
#ifdef OS_SAFETY_CRITICAL x, D& M) x+ w' R6 Z
if (p_err == (OS_ERR *)0) {
, ^ j* H4 S1 ?( J' ?, r$ D) j
OS_SAFETY_CRITICAL_EXCEPTION();
1 e* l. _/ s4 N' q" Z7 _& @: W
return;5 S, O6 R& w, C
}
4 ~) S7 c- |* v5 U' _2 A; @
#endif% G& y+ }7 Y. J2 I5 p. K
7 y j& [# v0 L, Z8 Z3 i( {9 l
OSIdleTaskCtr = (OS_IDLE_CTR)0;
6 p4 Y. z! \. ?0 ] R( \
/* ---------------- 创建空闲任务 ---------------- */+ V# K C, s5 G. t
OSTaskCreate((OS_TCB *)&OSIdleTaskTCB,# R7 j8 @+ ]% ~) }
(CPU_CHAR *)((void *)"uC/OS-III Idle Task"),! \% N/ U8 u' {" L& o
(OS_TASK_PTR)OS_IdleTask,! r; E9 r2 O& V0 G3 u9 A9 F
(void *)0,0 l; q. ?% y3 Z
(OS_PRIO )(OS_CFG_PRIO_MAX - 1u),
4 |8 s) q r7 d! g' q
(CPU_STK *)OSCfg_IdleTaskStkBasePtr,# o3 V; \1 {3 D3 D9 |# L
(CPU_STK_SIZE)OSCfg_IdleTaskStkLimit,
$ q7 g% k+ B* t) M2 s! r! n
(CPU_STK_SIZE)OSCfg_IdleTaskStkSize,% g9 J/ m7 g, D
(OS_MSG_QTY )0u,: v; X3 `) @6 ?6 w8 x
(OS_TICK )0u,
1 T, u3 H$ B1 X( O# m1 a# l
(void *)0,
; m& N2 L; |) B( E( x
(OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR | OS_OPT_TASK_NO_TLS),! ]: U* L: ]" s- f/ l5 d# i3 t0 \
(OS_ERR *)p_err);
! J8 @- e2 j" x9 u2 b5 v1 |4 F. e
}

复制代码

关于任务的创建，本期教程暂时还不做介绍。

11.6.2 空闲任务OS_IdleTask ()

/*7 T+ k4 v7 A, [' c, {9 j5 r
***********************************************************************************************************
" R3 G t- e: O3 v# I
* 空闲任务
5 d. ~" C( u( U" \, o
*3 ?" i& X( _: f! B! e- u R
* 函数说明: uC/OS-III内部任务 a* {+ }) M/ `. \( w n$ _
* 形参: p_arg 用于任务创建时传递的参数7 v5 y* ^# X( G: R% @% @+ ^' ^. K
* 返回值: 无+ Z( W6 P) q6 t/ E7 f
* 注意: 1) 空闲任务是uC/OS-III的内部任务，用户程序不能调用它9 \* e9 Y5 Z1 S, o) @ x- u
* 2) 在临界区后面调用OSIdleTaskHook()是为了确保有些处理器在使能中断后需要过几个时钟周期才能真正
6 B# h: X& p3 t p: K+ X3 g
* 使能。比如Philip XA
0 H+ k9 n7 f8 J
* 3) 用户可以在钩子函数中加入待机，休眠等低功耗操作
7 @/ W, }( q$ r% X# v* y+ W
***********************************************************************************************************. H# {( p8 T! M( k
*/
0 a- ~+ O: |0 W: F$ N
u0 _: r6 J% ]; F$ `
void OS_IdleTask (void *p_arg)7 D1 d' Z- l0 D$ X
{
/ D" V7 e, x2 P3 |- I9 Z
CPU_SR_ALLOC(); （1）
$ n& y* ~2 t1 ?0 a- x
# B/ @9 U7 r( x+ `. t
1 W# F' K- [$ |- h( K
- U. z' E; Y$ Y" V$ J1 D
p_arg = p_arg; /* 防止编译器警告 */ （2）0 ]4 p/ E- L3 l5 t, e9 ?
1 q% s& n4 S6 A3 T/ S3 w2 H
while (DEF_ON) { （3）
0 E6 }& e6 k8 ?% e" e# W0 ]5 w
CPU_CRITICAL_ENTER();' N) A' Y n) N" }2 G
OSIdleTaskCtr++; （4）+ ^9 c5 K8 h" E5 X6 e. M
#if OS_CFG_STAT_TASK_EN > 0u d( b4 C& X9 U9 o I* J' X
OSStatTaskCtr++; （5）
* L U$ {: X6 y) x8 a* \( f/ G4 q
#endif L* V( T! a2 _
CPU_CRITICAL_EXIT();# `$ U, k' S; I# w1 ?/ h6 `4 C
6 Q7 @0 k8 U6 D: A9 C# ^2 H7 E
OSIdleTaskHook(); /* 调用钩子函数 */ （6）
. N% W- q& h# Y; m* O
}
; Z7 g3 z. [4 ^# A- Y$ Z7 f @
}

复制代码

1. 函数CPU_SR_ALLOC()是为CPU_CRITICAL_ENTER()和CPU_CRITICAL_EXIT()申请一个变量：

#define CPU_SR_ALLOC() CPU_SR cpu_sr = (CPU_SR)0

这个是临界代码段，在下面一个小节有详细讲解。

2. 这样做是为了防止编译器警告。

3. μCOS-III中主要有以下布尔宏定义：

宏定义	数值
DEF_FALSE	0u
DEF_TRUE	1u
DEF_NO	0u
DEF_YES	1u
DEF_DISABLED	0u
DEF_ENABLED	1u
DEF_INACTIVE	0u
DEF_ACTIVE	1u
DEF_INVALID	0u
DEF_VALID	1u
DEF_OFF	0u
DEF_ON	1u
DEF_CLR	0u
DEF_SET	1u
DEF_FAIL	0u
DEF_OK	1u

4. 空闲任务计数。

5. 统计任务计数，这两个计数都是为了计算CPU利用率。

6. 用户可以在钩子函数中加入待机，休眠等低功耗操作。

赞评论

baiyongbin2009 回答时间：2014-12-24 20:17:52

11.8 安全关键IEC61508

关于IEC61508，大家有个了解即可，更详细的资料可以查阅wiki百科进行了解或者查找相关的文档说明。

11.8.1 IEC61508基本概念

IEC 61508是一项用于工业领域的国际标准，其名称是《电气/电子/可编程电子安全相关系统的功能安全》。由国际电工委员会发布，其目的要建立一个可应用于各种工业领域的基本功能安全标准。它将功能安全定义为：“是受控设备（EUC）或受控设备系统总体安全中的一部分；其安全性是依赖于电气/电子/可编程电子（E/E/PE）安全相关系统、其他技术的安全相关系统或外部风险降低措施的正确机能。”

(一) IEC61508中的基本定义

1. 安全功能 (safety function)

针对规定的危险事件，为达到或保持受控设备(EUC)的安全状态，由E/E/PE安全系统、其他技术安全系统或外部风险降低设施实现的功能。

2. 安全完整性 (Safety integrity)

在规定的条件下、规定的时间内，安全系统成功实现所要求的安全功能的概率。这一定义着重于安全系统执行安全功能的可靠性。在确定安全完整性过程中，应包括所有导致非安全状态的因素，如随机的硬件失效，软件导致的失效以及由电气干扰引起的失效，这些失效的类型，尤其是硬件失效可用测量方法来定量，如在危险模式中的失效和系统失效率，或按规定操作的安全防护系统失效的概率。但是，系统的安全完整性还取决于许多因素，这些因素无法精确定量，仅可定性考虑。

3. E/E/PE系统

基于电气/电子和可编程电子装置的用于控制、防护或监视的系统，包括系统中所有的元素如电源、传感器、所有其他输入输出装置及所有通信手段。

4. EUC(EquipmentUnder Control)

受控设备，指用于制造、运输、医疗或其他领域的设备、机器、装置或装备。
5. 可接受凤险 (ACCeptable risk)

风险指的是出现伤害的概率及该伤害严重性的组合。可接受风险指根据当今社会的水准所能够接受的风险。

6. 安全 (Safety)

不存在不可接受的风险。

7. 安全系统 (Safely-elated-syStem)

是用于两个目的:一是执行要求的安全功能以达到或保持EUC的安全状态;二是自身或与其他E/E/PES安全系统、其他技术安全系统或外部风险降低设施一道，对于要求的安全功能达到必要的安全完整性。安全系统是在接受命令后采取适当的动作以防止EUC进入危险状态。安全系统的失效应被包括在导致确定的危险事件中。尽管可能有其他系统具备安全功能，但仅是指用其自身能力达到要求的允许风险的安全系统。安全系统可大致分为安全控制系统和安全防护系统。

安全系统可以是EUC控制系统的组成部分，也可用传感器和/或执行器与EUC的接口，既可用在EUC控制系统中执行安全功能的方式达到要求的安全完整性水平，也可用分离的/独立的专门用于安全的系统执行安全功能。

(二)IEC61508的基本概念

IEC61508标准规定随机失效的后果必须定量评估，使用随机存取测量系统 (RAMS)方法计算有效性。量化与故障相关的系统失效是没有用的，应当通过组织指导来避免系统失效，或通过技术措施来控制。

1.风险和安全完整性慨念　

2.功能安全保证的内容

功能安全保证主要包括两部分内容:失效识别和安全完整性水平。

(1)失效识别。

失效就是功能单元失去实现其功能的能力。一些功能是根据所达到的行为进行规定的，在执行功能时，某些特定的行为是不允许的，这些行为的出现就是失效。失效可能是随机失效，这种失效通常由于硬件装置的耗损所致。也可能是系统失效，这在硬件和软件中都可能出现。失效识别就是要分辨出不同部件的各种失效原因，估算出系统失效概率。

(2)安全完整性水平 (SIL) (safetyintegrity level)。

一种离散的水平，用于规定分配给E/E/PE安全系统的安全功能的安全完整性要求，安全系统的安全完整性水平越高，安全系统实现所要求的安全功能失败的可能性就越低。IEC61508中规定系统有4种安全完整性水平，SIL4是最高的，安全完整性水平1是最低的。

11.8.2 启动安全关键OSSafetyCriticalStart

源码中加入了部分安全关键的代码，内容如下：

/*
3 v- p* l5 x) b; w- I+ q* A1 W
***********************************************************************************************************
: W8 ]% k5 `" d, e# o3 P
* 创建对象已经不安全. l, {: E/ f; A* E0 g# h) f. W
*
( s3 u3 R8 L' ]9 w
* 函数说明: 这个函数是供用户调用的，用户一旦调用了这个函数就表示所有的初始化已经完成。内核对象不再运行被创建。) x5 }: K* t1 t5 G- ^7 ^
* 形参: 无2 n9 E9 X$ v% C; F" [
* 返回值: 无/ z$ y3 s( N) p- {; f
* 注意: 无
4 s) D. o9 c5 h" _9 i
***********************************************************************************************************' w3 D! y2 M j. h9 B1 o0 ]' m b
*/: m7 C8 v2 m: W6 ]. l1 T; ]
2 p2 f2 m$ l4 b8 y4 \4 |' ?8 H
#ifdef OS_SAFETY_CRITICAL_IEC61508
+ W- d3 ^5 [2 Y$ n6 E1 s, X
void OSSafetyCriticalStart (void)
, t: M, y, J% {4 c) Z
{
' p$ r: l% K; g$ t% g* [
OSSafetyCriticalStartFlag = DEF_TRUE;6 q6 U0 r* Z) }2 u1 `) `) y% d8 x
}
9 v* [) d. b; g4 j$ Y5 H
8 ?7 `/ H) E& ~3 O2 `* T% e/ U
#endif

复制代码

1. 这个函数是供用户调用的，用户一旦调用了这个函数就表示所有的初始化已经完成。内核对象不再运行被创建。后面讲任务间通信机制的时候会看到相关代码，比如创建定时器的函数中：

#ifdef OS_SAFETY_CRITICAL_IEC615088 P& J1 [7 ]' F" h- m
if (OSSafetyCriticalStartFlag == DEF_TRUE) {0 r- Z5 X, M, d' X8 W) K; t6 u* ^
*p_err = OS_ERR_ILLEGAL_CREATE_RUN_TIME;
' \: T) w% P* j U
return;2 |1 h3 f6 t1 P( X( Z, Z# _0 `! r
}% P$ K$ }# [9 V9 n7 m
#endif

复制代码

11.8.3 函数使用举例

void AppStartTask（void *p_arg）
. s9 { k+ ~) v! s! Z) R, ~4 [
{" f; q5 \+ X- @# n8 R2 m R6 a
(void)& p_arg
1 l5 ?, `# y' G1 d* m7 a0 K, `$ P
OSSafetyCriticalStart (); //直接在启动函数中调用即可
+ }3 d3 |1 X' [ E
while(DEF_ON)( t0 r, A9 o! D1 h7 u1 ?3 G- S# A
{
}
2 Q+ m: ?* S' @" ^) y1 r) e
}

复制代码

赞评论

baiyongbin2009 回答时间：2014-12-24 20:21:18

剩下内容，明日继续，敬请关注，谢谢各位！

赞评论

巅峰残狼回答时间：2014-12-24 21:04:24

很好很强大，支持更新

赞评论

baiyongbin2009 回答时间：2014-12-25 17:06:57

11.10 调度锁

给调度器加锁后将禁止任务调度，直到任务完成后，调用调度器解锁函数才能重新开始任务调度。这里一定要明白一点，调度锁只是将调度器关闭，并不影响中断的执行，该进中断还是要进的，只是不会执行任务切换。

11.10.1 调度器加锁OSSchedLock()

/*
) o% D4 Z2 \) w
***********************************************************************************************************
. _$ ]2 g3 r3 f- v+ o, X. ~
* 调度器加锁4 x; F! \& W4 Y' ]9 ]8 l3 U% f7 \
*
S& u% H: O& t" l& _+ }
* 函数功能: 此函数的主要作用是给系统调度器加锁，这样系统就无法进行任务调度了。0 _) A7 H7 ?: q. W* Q& Q! v/ L+ i
* 形参: p_err 错误代码指针变量:
1 z8 u5 s! h; D/ x: F
* OS_ERR_NONE 调度器被锁
5 w; X) f! b3 D0 ^, Z: o
* OS_ERR_LOCK_NESTING_OVF 调度锁嵌套次数 > 250* j# a/ a, d. R0 t2 y E
* OS_ERR_OS_NOT_RUNNING 如果uC/OS-III还没有开始运行
* L+ K6 s% `! X$ N+ ?
* OS_ERR_SCHED_LOCK_ISR 如果在中断服务程序中调用此函数, Q+ h1 [- [7 I8 h' L4 a
* 返回值: 无7 [ o" d/ [" |: A0 V% F, Z
* 注意: 1) OSSchedLock() 和 OSSchedUnlock() 必须成对的使用.' u6 o a L0 f) m' v$ ?; J! J8 A
***********************************************************************************************************1 W* P0 }! ]0 `) B8 \. a3 x
*/
4 M5 H9 u* ? q6 d6 E: T! {' C, }
- C5 f: V8 m+ S0 n# L
void OSSchedLock (OS_ERR *p_err)
" S/ ^- b. }4 B' u/ k
{
. C5 H8 q5 G3 f" J7 L! Y/ n
CPU_SR_ALLOC();
' U* w; n# Z/ ?# ]( r
7 ~5 g- N" `6 |
( _) n5 ?& D0 q, V! ^ {* {
# o4 y: ]: ?6 U5 g
#ifdef OS_SAFETY_CRITICAL; E8 F/ s7 c$ I, ^
if (p_err == (OS_ERR *)0) {! z% g. C# T, a" |* u" [8 Q. Z$ M
OS_SAFETY_CRITICAL_EXCEPTION();5 U* k4 t2 O2 w" y& [* f
return;) E5 E- i+ ?/ ^- N$ b' z
}
: a( v' M4 h) q+ G- Q2 T& f
#endif
% F2 m W0 b& Q' k3 A
) p9 q, z0 P2 d! v1 f
#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
- i, n" F0 \/ p7 L: h8 ~
if (OSIntNestingCtr > (OS_NESTING_CTR)0) { /* 不允许在中断服务程序中调用此函数*/ （1）
8 w5 O1 T% {& d; ]& F) C( v
*p_err = OS_ERR_SCHED_LOCK_ISR;
& W9 r0 ~. k6 \
return;5 G1 f1 `8 C$ K8 O- ?5 F
}
8 C9 ^7 F( S# {& L$ {& Q! p' A
#endif
: o) i/ |* V6 J& [/ d+ n2 _0 x
+ r6 K( B" J8 c8 c" @, o$ q
if (OSRunning != OS_STATE_OS_RUNNING) { /* 确认系统已经开始运行 */' n/ ?& t4 u8 a" A% u' K
*p_err = OS_ERR_OS_NOT_RUNNING;% X: b5 H/ x4 v0 d$ j: P
return;5 J- q3 N/ ^1 U. d( V1 O+ N
}
7 g- A3 Y& |" d* |6 @3 d& i
9 [+ A/ A2 S6 Y4 ?
if (OSSchedLockNestingCtr >= (OS_NESTING_CTR)250u) { /* 防止OSSchedLockNestingCtr溢出 */ （2）
- P/ i1 _9 _# @4 Y* N: |# I
*p_err = OS_ERR_LOCK_NESTING_OVF;
3 p1 c5 s' m3 g5 g3 e0 r
return;
% j! u! ]' J2 {9 A U2 `) \! y
}- d; L$ t* q$ }
# `8 D2 a6 x6 f
CPU_CRITICAL_ENTER();! l! b. _6 p% ]7 s2 _8 n \" q% [
OSSchedLockNestingCtr++; /* 增加嵌套次数 */ （3）
+ R8 n6 D- V) b5 }$ S1 v$ j% s
#if OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u# N6 [9 f0 o; d% }1 z! A9 G: D5 u
OS_SchedLockTimeMeasStart(); （4）
4 e: T8 E% G2 ~ _6 K
#endif
9 H5 R: ^$ B. _0 C+ T, @
CPU_CRITICAL_EXIT();" l& p% s2 r1 r
*p_err = OS_ERR_NONE;
6 B n( S l' e$ N( [6 R$ y
}

复制代码

1. 这里表示不允许在中断服务程序中调用调度锁函数。

2. 调度锁的嵌套次数范围0~250，用户不能超出250。

3. 嵌套次数加一。

4. 开启调度锁时间测量，这里是记录一下起始时间。

( i) @3 o. H- i) c, k8 m11.10.2 调度器解锁OSSchedUnlock

/*
6 {( ?) z) [' p: c
***********************************************************************************************************5 Z8 k' |0 d: }: E/ A
* 调度器解锁
" p8 W6 G7 n9 t; j( T8 q
*
9 p. B; N6 c9 S$ u
* 函数功能: 此函数的主要作用是给系统调度器解锁，重新使能调度
/ D6 E6 e; c8 C) f! A
* 形参: p_err 错误代码指针变量:; d+ D" L; i2 {& }7 W. X$ X
* OS_ERR_NONE
" l# [8 N' G; N. C. O+ K
* OS_ERR_OS_NOT_RUNNING 系统还没有开始运行
9 v0 N, k5 l" `) i
* OS_ERR_SCHED_LOCKED 调度器仍然是加锁状态+ a) B7 E P L% v6 M7 ~
* OS_ERR_SCHED_NOT_LOCKED 调度没有被加锁
& g/ D* x% K$ t4 k5 G
* OS_ERR_SCHED_UNLOCK_ISR 如果在中断服务程序中调用此函数
6 _) ]! M) m" j0 X W
* 返回值: 无- j& O5 p7 Y$ T; Y. C3 g
* 注意: 1) OSSchedLock() 和 OSSchedUnlock() 必须成对的使用.
1 Z4 x- l5 ^7 k4 \2 S
***********************************************************************************************************
( ^: [) Q# b$ Y H# Q
*/
& U: V+ V* _3 Q/ N) ~) j' n
k; q$ g* E: W) G
void OSSchedUnlock (OS_ERR *p_err)
8 v9 \$ y. S1 w. `( Q- A
{( z% y1 A9 ~2 g1 [! D
CPU_SR_ALLOC();; s: d6 i! r& p1 F1 M7 {2 I, p
# ?# C9 ^* v9 T6 C. n) L
; G, q( A9 e% _9 V1 X$ j) J
( |1 o7 R3 [% Q' w
#ifdef OS_SAFETY_CRITICAL/ ]3 U5 [8 S4 S1 D) W- r
if (p_err == (OS_ERR *)0) {
) I% ~. z# i' u6 a i/ y/ h
OS_SAFETY_CRITICAL_EXCEPTION();& O2 {: W6 A2 p4 _
return;5 `$ F# Q2 [* a% A: v* H9 h
}
6 r1 H. H. i4 F5 s4 J( h
#endif
J6 I. I3 e7 G
4 H6 f2 \" E0 _
#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u" y, G& L: ]* W" z
if (OSIntNestingCtr > (OS_NESTING_CTR)0) { /* 不允许在ISR中调用此函数 */% g/ S; L# R& n1 M; o0 q
*p_err = OS_ERR_SCHED_UNLOCK_ISR;
4 K+ a/ t4 x! ], B, X2 r9 e9 T
return;
+ t j& H# c3 N6 ?2 ^0 ^) l* W
}+ v5 k; n( W' j) c
#endif
* C( c% {$ ^* e6 b2 e
' M W! Y0 \( Y7 `/ W8 L4 B2 |5 I
if (OSRunning != OS_STATE_OS_RUNNING) { /* 确认多任务已经开始运行 */, X- R) `' I. U! f0 o" B
*p_err = OS_ERR_OS_NOT_RUNNING;
- d% O0 k- r7 M' \' Q! Y- A
return;
& ^* \% {/ k7 U; O* w
}+ G% i3 p# F$ z
1 ^* H1 i2 b; |% V4 u' p. o0 {
if (OSSchedLockNestingCtr == (OS_NESTING_CTR)0) { /* 是否给调度器加锁 */
% j& n# l" ~8 W! V
*p_err = OS_ERR_SCHED_NOT_LOCKED;
4 k) A" o G* t0 C! c; {
return;" {) k; T7 S: g8 B, k
}
6 P* i$ n3 m7 B8 C
n z8 l3 {, ]
CPU_CRITICAL_ENTER();
6 c2 r4 M7 {5 [! d( m2 P
OSSchedLockNestingCtr--; /* 递减调度锁计数器 */ （1）, q; A8 _5 s5 W6 }4 d
if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) {
% p. v. a7 H! D4 L" r5 \' w
CPU_CRITICAL_EXIT(); /* 调度器仍然在加锁状态 */0 Z$ B+ ?7 q6 p, {$ A
*p_err = OS_ERR_SCHED_LOCKED;% v( U2 P" i' c( r& K
return;" f, h3 t2 v0 }* D: h1 l. x
}7 \$ y8 K7 V5 _% }7 l8 ^9 ]6 X
! }. |! I; m" n0 p( O3 N! d
#if OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u
; ] C- S+ q' U2 u8 j
OS_SchedLockTimeMeasStop();
) w+ W: V- q5 }5 X8 W) v
#endif. F' W" R5 {3 W9 J4 C
/ A, c" d2 j& H1 ~
CPU_CRITICAL_EXIT(); /* 重新使能调度器 */
5 R- x# Y& o+ b9 l# C5 I+ w$ g
OSSched(); /* 运行调度器 */ （2）- Z- O r5 Y( e( `) ?
*p_err = OS_ERR_NONE;5 `. e4 S( J& N! r P: Z& d
}

复制代码

1. 调度锁嵌套计数减一。

2. 调度器被锁期间，有些任务可能会就绪，所以这里加上了调度函数。

* G1 n3 { F4 V9 t! a: ~+ M
11.10.3 调度器被锁时间测量OS_SchedLockTimeMeas

函数比较简单，这里就直接将内容贴上，特别注意函数的注释。

/*% X/ l" t. \2 n0 E2 |& L2 H( e
***********************************************************************************************************
9 B1 _! u/ Z' L* U3 P
* 调度锁时间测量
/ p7 j7 f+ B& Q g, F, [/ p
*
) {" b/ m$ V0 F2 _, E
* 函数说明: 此函数用测量调度锁锁住调度的最大时间。5 b2 F3 J5 W* i+ F0 J% o. H) `0 e
* 形参: 无
) f% ~8 V# s7 _- \2 ^* v
* 返回值: 无7 I9 D9 Q6 u- \2 G% E% q
* 注意: 1) 系统函数，用户程序不能调用 g* _7 L- n! q) p' z
* 2) 这两个函数要在中断禁止的情况下调用。
/ ]' y r7 k/ {
* 3) 我们可以直接读取CPU_TS_TmrRd()，即使是16位定时器。原因是我们不建议调度器被锁的时间超过65536* V% c9 y) D! T/ \5 g1 ^. F
* 个计数。换句话说，如果调度器被锁的时间超过65536，那么对于实时系统来说不是一件好事。$ |; h9 l* A7 e: D* n8 v4 \' U
***********************************************************************************************************" C2 E, |: d6 l* T z& K! z
*/
8 A: b/ s- { E+ S; S+ B: d5 F; g
, _* c8 ^ W, c6 S& s7 [
#if OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u
/ l4 w" k" a4 J
void OS_SchedLockTimeMeasStart (void)7 O4 i L$ [6 D# m# t
{" g, c2 s! B [9 Q4 w
if (OSSchedLockNestingCtr == 1u) {
+ ^* W7 E8 x+ T
OSSchedLockTimeBegin = CPU_TS_TmrRd();4 f1 k1 G3 s3 X, I( v; G8 x
}: B4 T( z8 B& L i/ y
}
6 X1 I* }3 I% F5 ~2 f% G
+ b) N# C' J+ `$ N' v$ E5 c
void OS_SchedLockTimeMeasStop (void)
9 a6 G: k7 F& i! O% L" x3 E$ N# { {
{4 O1 }7 W& o5 M
CPU_TS_TMR delta;5 b1 i- h0 m5 `$ \7 J
0 Z8 l3 Z8 q1 @9 J: e! f
* i5 h; V" D1 Q% Q: d
if (OSSchedLockNestingCtr == (OS_NESTING_CTR)0) { /* 确认没有调度锁嵌套 */% Z+ t3 |% o5 k7 b4 O: s+ v
delta = CPU_TS_TmrRd() /* 计算时间差 */' u8 T% @7 D" N
- OSSchedLockTimeBegin;
6 r* P f+ m- x0 B/ k
if (OSSchedLockTimeMax < delta) { /* 检测最大值*/. g: B3 C O9 O& s& P5 }1 p
OSSchedLockTimeMax = delta;1 x& i- j; i$ x& W/ H
}
, a" Q# w0 v5 _$ d
if (OSSchedLockTimeMaxCur < delta) { /* 检测最大值(for resettable value) */+ i6 I) ~) T* |5 {' {+ B0 }
OSSchedLockTimeMaxCur = delta; R# n% m, s$ y5 b' O% U
}
( O0 V& K: b) W. P8 |7 D
}$ H4 B" O/ y( a8 @, p
}
% n4 t# U! v: @5 K, W7 F$ d# |
#endif

复制代码

1 f5 X( h( a+ a- T
11.10.4 函数使用举例

下面这个例子是为了防止截屏的过程中被其它任务打断，加入了调度锁功能。

/*/ y; k I/ Q( Z/ e$ K; |
*********************************************************************************************************
: R: T0 V- W- g. i
* 函数名: AppTaskGUIUpdate! x/ J9 i0 m g0 l2 e6 \0 f
* 功能说明: 本函数主要用于实现截图和串口打印UCOS任务的执行情况
* 形参：p_arg 是在创建该任务时传递的形参 x/ q7 _7 w' c3 `, G$ G
* 返回值: 无8 ]3 t2 H `4 j* T$ F! O9 k& m
优先级：36 \' w# S. C7 h! R; |9 ~5 P2 s
*********************************************************************************************************
5 W) C: u: O, l% F2 ?& k
*/
" H3 g% l. w. z, m
static void AppTaskGUIUpdate(void *p_arg)7 |1 i; M& l: m ? t/ V
{5 H2 i8 V: r! V; ? R
OS_ERR err;
" A( j+ A' }2 ^9 j* c: {% \( J6 D
uint8_t Pic_Name = 0;8 L0 ~# q& P% ~ q1 [& j8 ?
char buf[20];
$ P7 d) i9 O& T8 ^3 B
CPU_BOOLEAN SemFlag;
' x' n# B1 W8 C5 i3 {+ h
, I# J1 Q% F; Z/ ~( O
(void)p_arg;2 }2 j4 T* Q- y
5 |. v+ g, c' M: B
while(1)
; g# Q# ~$ ?2 x% Z% V, r8 @+ v8 A
{
J6 M+ x' p, G$ R+ Y9 Z
SemFlag = BSP_OS_SemWait(&SEM_SYNCH, 0);
7 b4 v4 E. a" u5 P6 ?$ }9 f' v
if(SemFlag == DEF_OK)/ Q$ ^ D; x4 J1 o$ `& X/ v
{ , K {; T" O! G# \) g
sprintf(buf,"0:/Picture/%d.bmp",Pic_Name);
* m5 ~3 j O# p' W" |
OSSchedLock(&err);( n1 c! B5 A( G" E
GUI_SaveBMP(0, 0, LCD_GetXSize(), LCD_GetYSize(),buf);
3 b* \, S3 z- Q9 w/ P9 Y: g
OSSchedUnlock(&err); 4 y- Z7 Z$ T/ H
}
) T& W0 h$ V. J) R3 }# E- r) r5 m
}
& r0 d! q3 L% T/ G0 g4 S; l' U8 W
}