! [" c6 h0 P7 \3 U- a% }, B+ Y
6 K1 j: f4 W" l6 N: o$ P

通用 RTOS 接口
& x1 _+ R3 ^8 y* y8 G* W+ I% U

/ i& r" c- x5 j7 k; J8 P. {% G5 M6 A

CMSIS-RTOS2 是一个通用的 API ，不受底层 RTOS 内核的影响。应用程序员在用户代码中调用 CMSIS-RTOS2 API 函数以确保从一个 RTOS 到另一个 RTOS 的最大可移植性。使用 CMSIS-RTOS2 API 的中间件可以避免不必要的移植工作。

- H9 e# C3 }; c8 VCMSIS-RTOS API 结构

典型的 CMSIS-RTOS2 API 实现与现有的实时内核接口。CMSIS-RTOS2 API 提供以下属性和功能：

% e& [6 y( w! Y8 o: c* o; X$ N& |

• 函数名称，标识符和参数是描述性的，易于理解的。这些功能强大而灵活，减少了暴露给用户的功能数量。
• 线程管理允许您定义，创建和控制线程。
• 中断服务程序（ISR）可以调用一些 CMSIS-RTOS 功能。 当 CMSIS-RTOS 函数不能从 ISR 上下文中调用时，它会拒绝调用并返回错误代码。
• 三种不同的事件类型支持多个线程和/或 ISR 之间的通信：
  
  • 线程标志: 可用于向线程指示特定条件。
  • 事件标志: 可用于向线程或 ISR 指示事件。
  • 消息: 可以发送到线程或 ISR 。消息缓冲在队列中。
      f# D6 t- u# l8 [4 A) l5 t0 P
• 互斥管理和信号量已合并。
• CPU 时间可以安排以下功能：
  
  • 超时参数包含在许多 CMSIS-RTOS 功能中，以避免系统锁定。当指定超时时，系统会等待，直到资源可用或发生事件。在等待时，运行其他线程。
  • osDelay 和 osDelayUntil 函数将线程置于 WAITING 状态一段指定的时间。
  • osThreadYield 提供协作式线程切换并将执行传递给具有相同优先级的另一个线程。
    % L0 l7 M4 S, L/ h1 s2 w7 E
• 定时器管理功能用于触发功能的执行。
  . b7 F" t6 S% R6 ^0 H% H

CMSIS-RTOS2 API 旨在通过 Cortex-M 存储器保护单元（MPU）选择性地整合多处理器系统和/或访问保护。

3 j& }- k' u+ {" V

在一些 RTOS 实现中，线程可能在不同的处理器上执行，因此消息队列可能驻留在共享内存资源中。

CMSIS-RTOS2 API 鼓励软件行业发展现有的 RTOS 实施。实时操作系统的实现可以在针对 Cortex-M 处理器的不同方面进行不同的优化。可选功能可能是例如

( Y( z! {$ \" A/ ?4 \0 ^6 ~- u4 `

• 支持 Cortex-M 内存保护单元（MPU）。
• 支持多处理器系统。
• 支持 DMA 控制器。
• 确定性上下文切换。
• 循环上下文切换。
• 避免死锁，例如优先倒置。
• 通过使用 Armv7-M 指令 LDREX 和 STREX 来实现零中断延迟。
  

使用 CMSIS-RTOS2 实现

CMSIS-RTOS2 实现通常作为库提供。要将 RTOS 功能添加到现有的基于 CMSIS 的应用程序中，需要添加 RTOS 库（通常是一个或多个配置文件）。有一个新的头文件 cmsis_os2.h 可用。这是完全可移植应用程序所需的唯一头文件。在这种情况下，不能使用用户为控制块，对象数据和线程堆栈提供的内存。或者，您可以包含一个实现特定的头文件（例如 rtx_os.h），该文件还提供了用于资源分配的定义（例如控制块的大小，对象数据和线程堆栈所需的内存）。 这是可选的，意味着应用程序代码不是完全可移植的。

1 d/ F2 B2 G' J4 l& ]3 f+ y# JCMSIS-RTOS 文件结构

* D6 ^0 b% U7 f0 r$ O. p

" R& B/ t7 s8 d  M

将文件添加到项目后，用户可以开始使用 CMSIS-RTOS 功能。下面提供了一个代码示例：

代码示例

1. /*----------------------------------------------------------------------------
   
2. * CMSIS-RTOS 'main' function template
   
3. *---------------------------------------------------------------------------*/
   
4. 
   ! X, i& N- N/ Z2 I7 X; l! @" I9 x
5. #include "RTE_Components.h"
   0 t9 ]5 y9 C; T) s1 c4 W
6. #include  CMSIS_device_header
   
7. #include "cmsis_os2.h"
   
8. 
   
9. /*----------------------------------------------------------------------------
   8 l4 y# H/ ~% T( V
10. * Application main thread
    8 d9 C+ ?3 H$ H- i& U
11. *---------------------------------------------------------------------------*/
    
12. void app_main (void *argument) {
    
13. 
    5 d: O- w! e/ d% o  c
14.   // ...
    2 q- n1 m7 N$ A5 X3 f/ d
15.   for (;;) {}
    
16. }
    
17. 
    
18. int main (void) {
    : A  B5 U4 n8 D% X- N! y$ v
19. 
    
20.   // System Initialization
    3 X  S6 b$ z3 T6 ?
21.   SystemCoreClockUpdate();
    ) E. L! R" U+ K3 E5 `: K# X
22. #ifdef RTE_Compiler_EventRecorder
    + o% O0 S* t: T1 c% y
23.   // Initialize and start Event Recorder
    # t5 O9 p1 N* [% }: P
24.   EventRecorderInitialize(EventRecordError, 1U);
    ( f4 l' J% c4 V
25. #endif
    
26.   // ...
    
27. 
    5 _$ \6 q) r# D8 k1 S
28.   osKernelInitialize();                 // Initialize CMSIS-RTOS
    5 K$ k/ T! N; m; V
29.   osThreadNew(app_main, NULL, NULL);    // Create application main thread
    
30.   osKernelStart();                      // Start thread execution
    / ^. Y0 X, b& K0 o3 I! p
31.   for (;;) {}
    % i: e, x9 e% N
32. }

复制代码

cmsis_os2.h 头文件

文件 cmsis_os2.h 是一个标准头文件，与每个 CMSIS-RTOS2 兼容的实时操作系统（RTOS）相连接。每个实现都提供了相同的 cmsis_os2.h ，它定义了到 CMSIS-RTOS2 的接口。

通过使用 cmsis_os2.h 和动态对象分配，可以创建在不同的 CMSIS-RTOS2 实现上使用时不需要修改的源代码或库。

& B$ H  v! z" L! Z& {1 q- E

头文件 cmsis_os2.h

1. /*
   , r/ p# n6 B9 j! R! q3 ^
2. * Copyright (c) 2013-2017 ARM Limited. All rights reserved.
   & [+ e; Z( Y4 z( u
3. *
   2 M8 X3 ]5 [: M/ x
4. * SPDX-License-Identifier: Apache-2.0
   
5. *
   6 j* D- j' ^! g
6. * Licensed under the Apache License, Version 2.0 (the License); you may
   
7. * not use this file except in compliance with the License.
   
8. * You may obtain a copy of the License at
   
9. *
   6 V+ g8 V2 q" @5 {: G6 v
10. * www.apache.org/licenses/LICENSE-2.0
    0 U) J: H2 D6 ~# B
11. *
    
12. * Unless required by applicable law or agreed to in writing, software
    9 W* t5 m% P! l- q/ f0 |
13. * distributed under the License is distributed on an AS IS BASIS, WITHOUT
    7 x: m) s, L0 N: t  x& @
14. * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    
15. * See the License for the specific language governing permissions and
    
16. * limitations under the License.
    
17. *
    + W8 a$ p/ t! m5 P7 q+ W- M
18. * ----------------------------------------------------------------------
    9 z: {( h* j$ F) d# W
19. *
    
20. * $Date:        30. October 2017
    2 D! Y) \; S/ o, d7 ^( ~
21. * $Revision:    V2.1.2
    
22. *
    
23. * Project:      CMSIS-RTOS2 API
    
24. * Title:        cmsis_os2.h header file
    0 E4 k& Z9 Y% o; a" a
25. *
    
26. * Version 2.1.2
    3 c9 j( P- |. }
27. *    Additional functions allowed to be called from Interrupt Service Routines:
    
28. *    - osKernelGetInfo, osKernelGetState
    
29. * Version 2.1.1
    , {( C. C; A9 L9 [7 e
30. *    Additional functions allowed to be called from Interrupt Service Routines:
    
31. *    - osKernelGetTickCount, osKernelGetTickFreq
    
32. *    Changed Kernel Tick type to uint32_t:
    1 \% l, e7 K1 G+ w% G% t/ h' V
33. *    - updated: osKernelGetTickCount, osDelayUntil
    
34. * Version 2.1.0
    
35. *    Support for critical and uncritical sections (nesting safe):
    
36. *    - updated: osKernelLock, osKernelUnlock
    
37. *    - added: osKernelRestoreLock
    
38. *    Updated Thread and Event Flags:
    
39. *    - changed flags parameter and return type from int32_t to uint32_t
    
40. * Version 2.0.0
    
41. *    Initial Release
    
42. *---------------------------------------------------------------------------*/
    3 h1 X" c& V/ [( i# o
43. 
    
44. #ifndef CMSIS_OS2_H_
    0 v* |( N  X0 [& u& m6 y
45. #define CMSIS_OS2_H_
    
46. 
    
47. #ifndef __NO_RETURN
    0 n! P+ X7 V  X1 R7 Q3 o
48. #if   defined(__CC_ARM)
    + w8 n% c, ?: D3 y
49. #define __NO_RETURN __declspec(noreturn)
    
50. #elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
    1 B& O( r, Q" m0 o& \# v
51. #define __NO_RETURN __attribute__((__noreturn__))
    
52. #elif defined(__GNUC__)
    
53. #define __NO_RETURN __attribute__((__noreturn__))
    3 F1 _! t$ W/ M2 g, d& Z3 F
54. #elif defined(__ICCARM__)
    
55. #define __NO_RETURN __noreturn
    . r* T* x$ r" h
56. #else
    ' M0 N3 V9 B+ A7 r% j
57. #define __NO_RETURN
    
58. #endif
    $ `- I! M6 b& O  K. g! ^  o
59. #endif
    + W/ Y" b0 J* T7 e9 C2 F
60. 
      r, Z0 v; O* I: n9 C/ x, k) V5 X
61. #include <stdint.h>
    
62. #include <stddef.h>
    
63. 
    4 m: e2 |; b, V% U9 {2 n
64. #ifdef  __cplusplus
    
65. extern "C"
    4 c9 j* R  {1 @. s+ \1 t! Q
66. {
    
67. #endif
    
68. 
    
69. 
    
70. //  ==== Enumerations, structures, defines ====
    
71. 
    
72. /// Version information.
    + E) p% n: U( k% G& ~
73. typedef struct {
    
74.   uint32_t                       api;   ///< API version (major.minor.rev: mmnnnrrrr dec).
    
75.   uint32_t                    kernel;   ///< Kernel version (major.minor.rev: mmnnnrrrr dec).
    : B; C9 {( P$ Q  n
76. } osVersion_t;
    1 |+ Q3 ^+ @% _+ E
77. 
    
78. /// Kernel state.
    4 W2 r% ?2 `, ]7 K/ t
79. typedef enum {
    
80.   osKernelInactive        =  0,         ///< Inactive.
    4 i  q3 P( J; |) `, |/ ^
81.   osKernelReady           =  1,         ///< Ready.
    : d7 L; |$ i2 m' G( `- ^3 F
82.   osKernelRunning         =  2,         ///< Running.
    5 P8 \/ k4 B5 p$ H
83.   osKernelLocked          =  3,         ///< Locked.
    
84.   osKernelSuspended       =  4,         ///< Suspended.
    % V% e' V/ Q0 ]8 [
85.   osKernelError           = -1,         ///< Error.
    
86.   osKernelReserved        = 0x7FFFFFFFU ///< Prevents enum down-size compiler optimization.
    , w  v. |' i: `: r  M
87. } osKernelState_t;
    
88. 
    4 @9 f5 d) @; |( Z8 j3 ]) h- f
89. /// Thread state.
    
90. typedef enum {
    
91.   osThreadInactive        =  0,         ///< Inactive.
    
92.   osThreadReady           =  1,         ///< Ready.
    9 L, S  @$ s9 n- c
93.   osThreadRunning         =  2,         ///< Running.
    
94.   osThreadBlocked         =  3,         ///< Blocked.
    & I, Y, B9 E# v- M  U
95.   osThreadTerminated      =  4,         ///< Terminated.
    
96.   osThreadError           = -1,         ///< Error.
    
97.   osThreadReserved        = 0x7FFFFFFF  ///< Prevents enum down-size compiler optimization.
    4 q7 A$ U  W/ ^. u6 X9 ^2 o
98. } osThreadState_t;
    2 p0 \! w6 a/ e6 ^# C; G
99. 
    " S& P: z. x/ W, ~/ n. I' Y
100. /// Priority values.
     , s0 m" k1 _! M) C' v
101. typedef enum {
     
102.   osPriorityNone          =  0,         ///< No priority (not initialized).
     ( G  q! X' s" O
103.   osPriorityIdle          =  1,         ///< Reserved for Idle thread.
     4 }2 Y! O  A: F& S) g. c3 v) Q( @
104.   osPriorityLow           =  8,         ///< Priority: low
     
105.   osPriorityLow1          =  8+1,       ///< Priority: low + 1
     
106.   osPriorityLow2          =  8+2,       ///< Priority: low + 2
     ) s/ R7 ?0 w7 }* |: t
107.   osPriorityLow3          =  8+3,       ///< Priority: low + 3
     : d2 A6 \4 q( Z/ o
108.   osPriorityLow4          =  8+4,       ///< Priority: low + 4
     
109.   osPriorityLow5          =  8+5,       ///< Priority: low + 5
     
110.   osPriorityLow6          =  8+6,       ///< Priority: low + 6
     
111.   osPriorityLow7          =  8+7,       ///< Priority: low + 7
     % O' ], A2 n9 H0 d  n
112.   osPriorityBelowNormal   = 16,         ///< Priority: below normal
     
113.   osPriorityBelowNormal1  = 16+1,       ///< Priority: below normal + 1
     $ C. _! e' x, r7 \. O% Z
114.   osPriorityBelowNormal2  = 16+2,       ///< Priority: below normal + 2
     + a) L; F9 J/ [
115.   osPriorityBelowNormal3  = 16+3,       ///< Priority: below normal + 3
     9 h  Z6 v; f& t5 Q# b
116.   osPriorityBelowNormal4  = 16+4,       ///< Priority: below normal + 4
     + B* \- m9 _% V+ R, U' x
117.   osPriorityBelowNormal5  = 16+5,       ///< Priority: below normal + 5
     
118.   osPriorityBelowNormal6  = 16+6,       ///< Priority: below normal + 6
     7 K$ |, n7 l8 m# i) N& A0 e: M
119.   osPriorityBelowNormal7  = 16+7,       ///< Priority: below normal + 7
     
120.   osPriorityNormal        = 24,         ///< Priority: normal
     3 @" `) B# B. j
121.   osPriorityNormal1       = 24+1,       ///< Priority: normal + 1
     
122.   osPriorityNormal2       = 24+2,       ///< Priority: normal + 2
     9 N# B: o5 n% P/ @5 i
123.   osPriorityNormal3       = 24+3,       ///< Priority: normal + 3
     * u2 v& k. F; E/ \- ^8 v6 B
124.   osPriorityNormal4       = 24+4,       ///< Priority: normal + 4
     
125.   osPriorityNormal5       = 24+5,       ///< Priority: normal + 5
     0 c! t8 r4 Z- R* q. n; B
126.   osPriorityNormal6       = 24+6,       ///< Priority: normal + 6
     . F7 w; c! L/ I* l
127.   osPriorityNormal7       = 24+7,       ///< Priority: normal + 7
     ! {: t8 A. ^2 L, E8 y( V& H5 \
128.   osPriorityAboveNormal   = 32,         ///< Priority: above normal
     7 a* P' R! a* Y4 ^3 @
129.   osPriorityAboveNormal1  = 32+1,       ///< Priority: above normal + 1
     * O9 u" M- x4 W: W3 J+ P
130.   osPriorityAboveNormal2  = 32+2,       ///< Priority: above normal + 2
     
131.   osPriorityAboveNormal3  = 32+3,       ///< Priority: above normal + 3
     
132.   osPriorityAboveNormal4  = 32+4,       ///< Priority: above normal + 4
     
133.   osPriorityAboveNormal5  = 32+5,       ///< Priority: above normal + 5
     
134.   osPriorityAboveNormal6  = 32+6,       ///< Priority: above normal + 6
     $ l+ x9 X* j+ c
135.   osPriorityAboveNormal7  = 32+7,       ///< Priority: above normal + 7
     , i6 m3 B3 m( ?4 u
136.   osPriorityHigh          = 40,         ///< Priority: high
     
137.   osPriorityHigh1         = 40+1,       ///< Priority: high + 1
     
138.   osPriorityHigh2         = 40+2,       ///< Priority: high + 2
     
139.   osPriorityHigh3         = 40+3,       ///< Priority: high + 3
     
140.   osPriorityHigh4         = 40+4,       ///< Priority: high + 4
     
141.   osPriorityHigh5         = 40+5,       ///< Priority: high + 5
     0 v1 j: ?5 r2 v9 j& z: e
142.   osPriorityHigh6         = 40+6,       ///< Priority: high + 6
     
143.   osPriorityHigh7         = 40+7,       ///< Priority: high + 7
     
144.   osPriorityRealtime      = 48,         ///< Priority: realtime
     
145.   osPriorityRealtime1     = 48+1,       ///< Priority: realtime + 1
     4 H" L( v, o; t$ v4 T1 a
146.   osPriorityRealtime2     = 48+2,       ///< Priority: realtime + 2
     . [; H! W: F5 I' z: A3 b7 k
147.   osPriorityRealtime3     = 48+3,       ///< Priority: realtime + 3
     % C1 t2 r% ]7 W! O- \4 C3 G
148.   osPriorityRealtime4     = 48+4,       ///< Priority: realtime + 4
     
149.   osPriorityRealtime5     = 48+5,       ///< Priority: realtime + 5
     
150.   osPriorityRealtime6     = 48+6,       ///< Priority: realtime + 6
     ( ?! ~3 Q5 ~( b) ^
151.   osPriorityRealtime7     = 48+7,       ///< Priority: realtime + 7
     ' }3 {1 J5 g  I
152.   osPriorityISR           = 56,         ///< Reserved for ISR deferred thread.
     3 R/ b# A1 d8 c  O! O- g
153.   osPriorityError         = -1,         ///< System cannot determine priority or illegal priority.
     
154.   osPriorityReserved      = 0x7FFFFFFF  ///< Prevents enum down-size compiler optimization.
     $ J* N" \7 {* A' K
155. } osPriority_t;
     1 z0 N: b  L$ a" \5 z+ p; V/ u7 q$ e
156. 
     
157. /// Entry point of a thread.
     2 u+ l2 E4 Y( I  W' U  s; q
158. typedef void (*osThreadFunc_t) (void *argument);
     * ^4 X& U! J0 ]$ ?7 A
159. 
     
160. /// Timer callback function.
     
161. typedef void (*osTimerFunc_t) (void *argument);
     ! S  c: q' }  b
162. 
     
163. /// Timer type.
     
164. typedef enum {
     2 g! I* D# [- j5 U1 O
165.   osTimerOnce               = 0,          ///< One-shot timer.
     2 |" N6 W: `( n7 a
166.   osTimerPeriodic           = 1           ///< Repeating timer.
     
167. } osTimerType_t;
     8 W% C8 n5 i* Z- `+ a% ]) v0 ~
168. 
     " S6 D/ B' M# e) Z" W$ \; E
169. // Timeout value.
     + m1 R) v& d; f2 Z3 w
170. #define osWaitForever         0xFFFFFFFFU ///< Wait forever timeout value.
     8 n) k$ w; h, E  H! ^
171. 
     ) B0 x' e* _4 F- N( C! u
172. // Flags options (\ref osThreadFlagsWait and \ref osEventFlagsWait).
     
173. #define osFlagsWaitAny        0x00000000U ///< Wait for any flag (default).
     
174. #define osFlagsWaitAll        0x00000001U ///< Wait for all flags.
     & d/ V0 Z  L* j: s" r% ^" d6 B9 n9 h
175. #define osFlagsNoClear        0x00000002U ///< Do not clear flags which have been specified to wait for.
     
176. 
     
177. // Flags errors (returned by osThreadFlagsXxxx and osEventFlagsXxxx).
     + w& }! a9 E/ g: v" @" g- q
178. #define osFlagsError          0x80000000U ///< Error indicator.
     ' d0 J2 v: f3 r7 e
179. #define osFlagsErrorUnknown   0xFFFFFFFFU ///< osError (-1).
       y9 O8 I: L, @- v
180. #define osFlagsErrorTimeout   0xFFFFFFFEU ///< osErrorTimeout (-2).
     0 J$ L+ b+ Y% u, _7 O8 c/ m
181. #define osFlagsErrorResource  0xFFFFFFFDU ///< osErrorResource (-3).
     2 n4 |& D) i! J% {6 f
182. #define osFlagsErrorParameter 0xFFFFFFFCU ///< osErrorParameter (-4).
     - Z0 g  x8 L, {; B" _& _- U
183. #define osFlagsErrorISR       0xFFFFFFFAU ///< osErrorISR (-6).
     " Z6 V( i2 I9 |4 d8 S
184. 
     " p' P; b; Z- z5 h0 {* L+ @
185. // Thread attributes (attr_bits in \ref osThreadAttr_t).
     
186. #define osThreadDetached      0x00000000U ///< Thread created in detached mode (default)
     
187. #define osThreadJoinable      0x00000001U ///< Thread created in joinable mode
     - d* Z% H) @% v# d' m" [& V% x3 `7 k
188. 
     
189. // Mutex attributes (attr_bits in \ref osMutexAttr_t).
     
190. #define osMutexRecursive      0x00000001U ///< Recursive mutex.
     ) V7 n" q! `8 r! P
191. #define osMutexPrioInherit    0x00000002U ///< Priority inherit protocol.
     + |" c- `* y; s6 B
192. #define osMutexRobust         0x00000008U ///< Robust mutex.
     
193. 
     
194. /// Status code values returned by CMSIS-RTOS functions.
     
195. typedef enum {
     
196.   osOK                      =  0,         ///< Operation completed successfully.
     
197.   osError                   = -1,         ///< Unspecified RTOS error: run-time error but no other error message fits.
     
198.   osErrorTimeout            = -2,         ///< Operation not completed within the timeout period.
     0 g, b$ c, Q# n, g" c
199.   osErrorResource           = -3,         ///< Resource not available.
     
200.   osErrorParameter          = -4,         ///< Parameter error.
     
201.   osErrorNoMemory           = -5,         ///< System is out of memory: it was impossible to allocate or reserve memory for the operation.
     
202.   osErrorISR                = -6,         ///< Not allowed in ISR context: the function cannot be called from interrupt service routines.
     6 |' u$ u' d2 R2 _8 x0 p7 c
203.   osStatusReserved          = 0x7FFFFFFF  ///< Prevents enum down-size compiler optimization.
     ; s) c- P8 C1 ^: Y8 ?% G( a4 N) E! I
204. } osStatus_t;
     
205. 
     5 T$ z- `5 B5 j! B: K
206. 
     & O2 R' n% l* n+ p. R' \
207. /// \details Thread ID identifies the thread.
     
208. typedef void *osThreadId_t;
     
209. 
     
210. /// \details Timer ID identifies the timer.
     
211. typedef void *osTimerId_t;
     % A( J& T* A! y# o
212. 
     % p# a0 w' U$ d4 j; u
213. /// \details Event Flags ID identifies the event flags.
     & T6 n- D4 G& M$ [. p
214. typedef void *osEventFlagsId_t;
     
215. 
     
216. /// \details Mutex ID identifies the mutex.
     
217. typedef void *osMutexId_t;
     ' _- Y: V0 m! {1 p. ?% p0 K5 e, t
218. 
     - ^' z3 Q  C" `
219. /// \details Semaphore ID identifies the semaphore.
     
220. typedef void *osSemaphoreId_t;
       o& E3 W- a1 v7 R" c
221. 
     
222. /// \details Memory Pool ID identifies the memory pool.
     ' B! T+ ~+ x, ]0 k: F+ z# `0 j
223. typedef void *osMemoryPoolId_t;
     
224. 
     8 e7 R: d& g: F7 J
225. /// \details Message Queue ID identifies the message queue.
     
226. typedef void *osMessageQueueId_t;
     
227. 
     
228. 
     / A% F  H4 j0 G2 A6 W
229. #ifndef TZ_MODULEID_T
     
230. #define TZ_MODULEID_T
     
231. /// \details Data type that identifies secure software modules called by a process.
     0 v, ?9 K1 p! q6 t
232. typedef uint32_t TZ_ModuleId_t;
     
233. #endif
     
234. 
     
235. 
     
236. /// Attributes structure for thread.
     4 P& j4 c! M9 |. C* g* Z
237. typedef struct {
     3 y7 e* |! _& {& o! H
238.   const char                   *name;   ///< name of the thread
     
239.   uint32_t                 attr_bits;   ///< attribute bits
     
240.   void                      *cb_mem;    ///< memory for control block
     
241.   uint32_t                   cb_size;   ///< size of provided memory for control block
     0 y3 ~4 `  Z! J. h, t& E5 Y
242.   void                   *stack_mem;    ///< memory for stack
     6 g, F8 Q# x$ [( }' o- x" o2 B8 o: _
243.   uint32_t                stack_size;   ///< size of stack
     
244.   osPriority_t              priority;   ///< initial thread priority (default: osPriorityNormal)
     " Q7 N* X: x$ o0 m0 J- c' M! t
245.   TZ_ModuleId_t            tz_module;   ///< TrustZone module identifier
     ! I4 _1 g/ \6 j5 Y  A- S) a. q
246.   uint32_t                  reserved;   ///< reserved (must be 0)
       \+ ^- B/ p1 \
247. } osThreadAttr_t;
     7 Q  v4 L: B4 \: e8 q- T4 Y
248. 
     
249. /// Attributes structure for timer.
     ) I4 A% U; P$ U% R1 O3 ^, a
250. typedef struct {
     
251.   const char                   *name;   ///< name of the timer
     ) {2 A- u" D: X) G" X
252.   uint32_t                 attr_bits;   ///< attribute bits
     3 f8 e4 e8 g; b9 Q/ p" S% S
253.   void                      *cb_mem;    ///< memory for control block
     
254.   uint32_t                   cb_size;   ///< size of provided memory for control block
       X% I+ v$ e% S( V7 k7 j0 G
255. } osTimerAttr_t;
     ! L% I9 }. T8 n7 c
256. 
     
257. /// Attributes structure for event flags.
     * x$ \- L8 y+ s7 G
258. typedef struct {
     9 [  U# p7 W7 ?6 E
259.   const char                   *name;   ///< name of the event flags
     
260.   uint32_t                 attr_bits;   ///< attribute bits
     , \6 c. h% N8 `: N0 A) r& H; W
261.   void                      *cb_mem;    ///< memory for control block
     0 r5 u0 _2 o( B8 x" T$ q1 c
262.   uint32_t                   cb_size;   ///< size of provided memory for control block
     " A. \4 `' P/ l1 F
263. } osEventFlagsAttr_t;
     
264. 
     . M! [6 H' s$ n4 E
265. /// Attributes structure for mutex.
     , B5 m  \8 V( o( Y: _
266. typedef struct {
     0 j( X! f* |3 k9 J: E: Z1 O
267.   const char                   *name;   ///< name of the mutex
     " Y# D" \4 Y, n/ v. z! B) k7 I# g
268.   uint32_t                 attr_bits;   ///< attribute bits
     ! i" [; j4 H; J1 u& p5 f6 \
269.   void                      *cb_mem;    ///< memory for control block
     
270.   uint32_t                   cb_size;   ///< size of provided memory for control block
     + @& Y% ~* S* [5 s- w6 q& d6 O
271. } osMutexAttr_t;
     4 a( Y6 }( T8 p) a
272. 
     4 O- r6 X: h6 G) h' x
273. /// Attributes structure for semaphore.
     2 p; Z6 |, Q$ i
274. typedef struct {
     
275.   const char                   *name;   ///< name of the semaphore
     0 [6 I" x- u5 m/ O
276.   uint32_t                 attr_bits;   ///< attribute bits
     
277.   void                      *cb_mem;    ///< memory for control block
     ) u5 P2 r3 `8 D
278.   uint32_t                   cb_size;   ///< size of provided memory for control block
     + A& ]& E( l! V
279. } osSemaphoreAttr_t;
     
280. 
     " v3 O/ E6 Q( Q3 E' R, V; E
281. /// Attributes structure for memory pool.
     4 u6 v" g5 |- u3 |
282. typedef struct {
     
283.   const char                   *name;   ///< name of the memory pool
     
284.   uint32_t                 attr_bits;   ///< attribute bits
     
285.   void                      *cb_mem;    ///< memory for control block
     9 o5 v& p4 L$ n" J
286.   uint32_t                   cb_size;   ///< size of provided memory for control block
     ! \1 g- {. S- v2 M' w# x* o) M
287.   void                      *mp_mem;    ///< memory for data storage
     
288.   uint32_t                   mp_size;   ///< size of provided memory for data storage
     
289. } osMemoryPoolAttr_t;
     
290. 
     
291. /// Attributes structure for message queue.
     . J) g6 v# p7 x9 k$ P% R3 O
292. typedef struct {
     & ?# e% m3 A: ^; I0 r/ L5 I  [% T  b. `+ i
293.   const char                   *name;   ///< name of the message queue
     # D8 p+ \& K& }
294.   uint32_t                 attr_bits;   ///< attribute bits
     
295.   void                      *cb_mem;    ///< memory for control block
     , p0 |$ r7 g: d9 S1 \
296.   uint32_t                   cb_size;   ///< size of provided memory for control block
     
297.   void                      *mq_mem;    ///< memory for data storage
     
298.   uint32_t                   mq_size;   ///< size of provided memory for data storage
     
299. } osMessageQueueAttr_t;
     % [, B* v2 [, U; y
300. 
     ; I  a- y5 S( X2 c
301. 
     
302. //  ==== Kernel Management Functions ====
     
303. 
     
304. /// Initialize the RTOS Kernel.
     . f' N  h) ?$ x) N4 V
305. /// \return status code that indicates the execution status of the function.
     5 g' t6 q2 S+ f5 @
306. osStatus_t osKernelInitialize (void);
     
307. 
     ) I; z) B' `0 Q( @5 w' t
308. ///  Get RTOS Kernel Information.
     
309. /// \param[out]    version       pointer to buffer for retrieving version information.
     
310. /// \param[out]    id_buf        pointer to buffer for retrieving kernel identification string.
     , N( J9 A, x& e8 ?  q) J. z
311. /// \param[in]     id_size       size of buffer for kernel identification string.
     0 k( u$ D9 F4 r
312. /// \return status code that indicates the execution status of the function.
     
313. osStatus_t osKernelGetInfo (osVersion_t *version, char *id_buf, uint32_t id_size);
     8 z# v) t  B1 S7 N# z# g
314. 
     
315. /// Get the current RTOS Kernel state.
     
316. /// \return current RTOS Kernel state.
     8 H8 E6 `* `9 Q( }- N
317. osKernelState_t osKernelGetState (void);
     
318. 
     3 j, x# ^, d2 x: L/ A2 t7 m
319. /// Start the RTOS Kernel scheduler.
     
320. /// \return status code that indicates the execution status of the function.
     
321. osStatus_t osKernelStart (void);
     7 `, A: q! ~2 Z
322. 
     
323. /// Lock the RTOS Kernel scheduler.
     
324. /// \return previous lock state (1 - locked, 0 - not locked, error code if negative).
     
325. int32_t osKernelLock (void);
     $ J) f1 n# R3 A  Q5 i
326. 
     ; B4 Z. y/ Q8 h3 ?& h' A" }
327. /// Unlock the RTOS Kernel scheduler.
     
328. /// \return previous lock state (1 - locked, 0 - not locked, error code if negative).
     
329. int32_t osKernelUnlock (void);
     % x! q6 C" \/ i+ X2 G
330. 
     
331. /// Restore the RTOS Kernel scheduler lock state.
     + h! t" N' r9 w' A% k& }' i
332. /// \param[in]     lock          lock state obtained by \ref osKernelLock or \ref osKernelUnlock.
     ( `6 Z! T) [6 X" {4 I  E/ T
333. /// \return new lock state (1 - locked, 0 - not locked, error code if negative).
     
334. int32_t osKernelRestoreLock (int32_t lock);
     7 E; O+ G2 a& a2 H
335. 
     
336. /// Suspend the RTOS Kernel scheduler.
     
337. /// \return time in ticks, for how long the system can sleep or power-down.
     
338. uint32_t osKernelSuspend (void);
     
339. 
     
340. /// Resume the RTOS Kernel scheduler.
     
341. /// \param[in]     sleep_ticks   time in ticks for how long the system was in sleep or power-down mode.
     
342. void osKernelResume (uint32_t sleep_ticks);
     * z2 x$ y( G0 G& a
343. 
     ) {( o* E7 v( m+ ]. z4 s7 u$ n5 ]
344. /// Get the RTOS kernel tick count.
       I; y# p' f& h
345. /// \return RTOS kernel current tick count.
     $ d5 u2 d. w  Q/ A9 D' r
346. uint32_t osKernelGetTickCount (void);
     
347. 
     4 G; i& m) ]2 B7 X  ?1 R( |
348. /// Get the RTOS kernel tick frequency.
     ! T+ ~7 P* b1 g! v
349. /// \return frequency of the kernel tick in hertz, i.e. kernel ticks per second.
     6 Z6 y& E8 t2 q9 c
350. uint32_t osKernelGetTickFreq (void);
     
351. 
     
352. /// Get the RTOS kernel system timer count.
     & ^/ k# F; {0 v8 ]
353. /// \return RTOS kernel current system timer count as 32-bit value.
     
354. uint32_t osKernelGetSysTimerCount (void);
     
355. 
     
356. /// Get the RTOS kernel system timer frequency.
     
357. /// \return frequency of the system timer in hertz, i.e. timer ticks per second.
     , b+ U- S0 d/ }2 Y
358. uint32_t osKernelGetSysTimerFreq (void);
     
359. 
     & R7 }( D2 F7 {& w# Q5 N
360. 
     
361. //  ==== Thread Management Functions ====
     1 A% F- |6 t) l% L5 o7 ~
362. 
     4 d1 _0 @) H' R6 H: z+ I
363. /// Create a thread and add it to Active Threads.
     - i) [# [- Y5 \! {* v% W+ i
364. /// \param[in]     func          thread function.
     
365. /// \param[in]     argument      pointer that is passed to the thread function as start argument.
     % G3 I4 V8 V. u( }! V& w% B
366. /// \param[in]     attr          thread attributes; NULL: default values.
     
367. /// \return thread ID for reference by other functions or NULL in case of error.
     
368. osThreadId_t osThreadNew (osThreadFunc_t func, void *argument, const osThreadAttr_t *attr);
     
369. 
     ( }( F) v# U7 x
370. /// Get name of a thread.
     
371. /// \param[in]     thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
     
372. /// \return name as NULL terminated string.
     
373. const char *osThreadGetName (osThreadId_t thread_id);
     ! d1 Z- ?2 O% L4 {% H( A0 c% Q( H
374. 
     
375. /// Return the thread ID of the current running thread.
     
376. /// \return thread ID for reference by other functions or NULL in case of error.
     + ~% g5 `/ p  F
377. osThreadId_t osThreadGetId (void);
     6 K& a3 W# _# ?& o: l8 K+ z
378. 
     
379. /// Get current thread state of a thread.
     
380. /// \param[in]     thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
     7 b7 s) z2 d2 z% F  C6 s. `
381. /// \return current thread state of the specified thread.
     
382. osThreadState_t osThreadGetState (osThreadId_t thread_id);
     
383. 
     & F1 Y( Q  s" W' N$ g; C9 l
384. /// Get stack size of a thread.
       O: g8 X, t! W3 a  j, P/ I+ `6 R
385. /// \param[in]     thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
     
386. /// \return stack size in bytes.
     , r: A% D3 |* W" F
387. uint32_t osThreadGetStackSize (osThreadId_t thread_id);
     
388. 
     # q% A" c6 h! T$ W0 A
389. /// Get available stack space of a thread based on stack watermark recording during execution.
     " m  Q3 [% l7 ^8 H, |; `( y
390. /// \param[in]     thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
     
391. /// \return remaining stack space in bytes.
     ( m- X, F. e5 z
392. uint32_t osThreadGetStackSpace (osThreadId_t thread_id);
     % q. [: p! q& J. n" \
393. 
     : T* O$ \  e+ ^- G) [  K; }
394. /// Change priority of a thread.
     8 [: P* L  e) c/ q0 Q' b9 i. _
395. /// \param[in]     thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
     
396. /// \param[in]     priority      new priority value for the thread function.
     
397. /// \return status code that indicates the execution status of the function.
     ; A/ B9 r9 x' Y0 @$ o: c# F
398. osStatus_t osThreadSetPriority (osThreadId_t thread_id, osPriority_t priority);
     
399. 
     
400. /// Get current priority of a thread.
     
401. /// \param[in]     thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
     
402. /// \return current priority value of the specified thread.
     ) @; z# F/ d8 z; C3 I" e2 R9 x: ?
403. osPriority_t osThreadGetPriority (osThreadId_t thread_id);
     ' K2 C+ U" G3 W! F4 s* Z( T
404. 
     4 K/ m3 M! a& \$ q
405. /// Pass control to next thread that is in state \b READY.
     
406. /// \return status code that indicates the execution status of the function.
     
407. osStatus_t osThreadYield (void);
     6 @9 U2 k, K3 Q: t/ R/ l
408. 
     
409. /// Suspend execution of a thread.
     
410. /// \param[in]     thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
     
411. /// \return status code that indicates the execution status of the function.
     ' I5 U1 I" ?* a, [( D
412. osStatus_t osThreadSuspend (osThreadId_t thread_id);
     3 j8 h2 M3 X  M
413. 
     
414. /// Resume execution of a thread.
     
415. /// \param[in]     thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
     / r3 @+ E7 k8 `; D1 o2 A. U. Q
416. /// \return status code that indicates the execution status of the function.
     
417. osStatus_t osThreadResume (osThreadId_t thread_id);
     / d$ o3 g4 a/ n  v
418. 
     " z5 Z& t# ]* t  m+ J/ I( P
419. /// Detach a thread (thread storage can be reclaimed when thread terminates).
     
420. /// \param[in]     thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
     
421. /// \return status code that indicates the execution status of the function.
     ; |2 E" k5 l* [8 [% x
422. osStatus_t osThreadDetach (osThreadId_t thread_id);
     1 d. Z' {6 V1 F, w( k1 }: b
423. 
     
424. /// Wait for specified thread to terminate.
     0 n6 i: q0 g; ^  `( f  [
425. /// \param[in]     thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
     
426. /// \return status code that indicates the execution status of the function.
     0 {/ }; b% ?. f) v6 {5 ^6 A
427. osStatus_t osThreadJoin (osThreadId_t thread_id);
     3 P6 C0 v4 O$ s! t4 w
428. 
     8 L. j2 Q$ y8 N8 C, }9 ?2 S
429. /// Terminate execution of current running thread.
     ! x% V+ m. F. i8 @% K; O  g" \
430. __NO_RETURN void osThreadExit (void);
     
431. 
     ( n! b! z" v0 }2 J, C0 S% ]
432. /// Terminate execution of a thread.
     
433. /// \param[in]     thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
     9 i; M6 o2 n: d* n+ T8 ^
434. /// \return status code that indicates the execution status of the function.
     4 {6 o9 D0 f6 J3 |/ m; S1 E7 T2 G
435. osStatus_t osThreadTerminate (osThreadId_t thread_id);
       Y% C* ^5 b2 C% q1 o: _5 x6 n9 Y. ^- |
436. 
     0 k6 X) Z: J* ]6 [
437. /// Get number of active threads.
     3 z8 D3 P$ l' Z- ?5 T0 x% {3 H1 K
438. /// \return number of active threads.
     / n7 g5 y9 U, l. ^
439. uint32_t osThreadGetCount (void);
     / C- B) l* C4 J. q
440. 
     $ j' ?6 E" C+ U  M0 l  G
441. /// Enumerate active threads.
     
442. /// \param[out]    thread_array  pointer to array for retrieving thread IDs.
     
443. /// \param[in]     array_items   maximum number of items in array for retrieving thread IDs.
     
444. /// \return number of enumerated threads.
     
445. uint32_t osThreadEnumerate (osThreadId_t *thread_array, uint32_t array_items);
     
446. 
     5 P2 x/ _) N6 W  Z2 L
447. 
     " y& g1 {+ s  X% ]0 p7 B
448. //  ==== Thread Flags Functions ====
     6 W7 P7 Q; |- X! a1 ?1 K7 n/ u! \6 |
449. 
     
450. /// Set the specified Thread Flags of a thread.
     
451. /// \param[in]     thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
     
452. /// \param[in]     flags         specifies the flags of the thread that shall be set.
     
453. /// \return thread flags after setting or error code if highest bit set.
     
454. uint32_t osThreadFlagsSet (osThreadId_t thread_id, uint32_t flags);
     
455. 
     
456. /// Clear the specified Thread Flags of current running thread.
     % I: K) U) v2 u  l/ D) u6 R
457. /// \param[in]     flags         specifies the flags of the thread that shall be cleared.
     
458. /// \return thread flags before clearing or error code if highest bit set.
     
459. uint32_t osThreadFlagsClear (uint32_t flags);
     % b+ Y4 i3 b' ?# R* d  i$ K
460. 
     
461. /// Get the current Thread Flags of current running thread.
     , I* n. `2 D6 ^+ f! u% o9 m; x
462. /// \return current thread flags.
     , i+ i. h  ^( N7 L+ X3 \: V
463. uint32_t osThreadFlagsGet (void);
     
464. 
     
465. /// Wait for one or more Thread Flags of the current running thread to become signaled.
     
466. /// \param[in]     flags         specifies the flags to wait for.
     
467. /// \param[in]     options       specifies flags options (osFlagsXxxx).
     
468. /// \param[in]     timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
     * N) K, D5 |1 [$ X' P0 R# S& ~2 z+ l
469. /// \return thread flags before clearing or error code if highest bit set.
     
470. uint32_t osThreadFlagsWait (uint32_t flags, uint32_t options, uint32_t timeout);
     ! N/ e1 D& x4 R4 ]) ~6 R; I
471. 
     ) n* A3 s9 Y: w/ W6 j/ B
472. 
     
473. //  ==== Generic Wait Functions ====
     
474. 
     ) V/ k0 i" N8 @* G! S, {
475. /// Wait for Timeout (Time Delay).
     . ~1 a; c: m* W0 X3 q) G
476. /// \param[in]     ticks         \ref CMSIS_RTOS_TimeOutValue "time ticks" value
     8 G1 V' ?/ b# X( H; J/ `3 a1 v2 U
477. /// \return status code that indicates the execution status of the function.
     4 ~+ u' C) H2 O) ^/ g4 u. P7 t5 m: t
478. osStatus_t osDelay (uint32_t ticks);
     : \7 D) y7 S& h" V( Q; U
479. 
     
480. /// Wait until specified time.
     * B2 N. ?: e& b
481. /// \param[in]     ticks         absolute time in ticks
     
482. /// \return status code that indicates the execution status of the function.
     
483. osStatus_t osDelayUntil (uint32_t ticks);
     ' H$ @4 K0 A! m
484. 
     5 h" v( ]9 M, S
485. 
     
486. //  ==== Timer Management Functions ====
     / h* G% r% P4 ^3 |9 |/ n" [+ i
487. 
     
488. /// Create and Initialize a timer.
     
489. /// \param[in]     func          function pointer to callback function.
     
490. /// \param[in]     type          \ref osTimerOnce for one-shot or \ref osTimerPeriodic for periodic behavior.
     2 X2 O' b  h8 F# i& ]
491. /// \param[in]     argument      argument to the timer callback function.
     ' Q6 C& r6 e: @2 g  a
492. /// \param[in]     attr          timer attributes; NULL: default values.
     
493. /// \return timer ID for reference by other functions or NULL in case of error.
     6 h6 @: t  M* M6 u; p
494. osTimerId_t osTimerNew (osTimerFunc_t func, osTimerType_t type, void *argument, const osTimerAttr_t *attr);
     
495. 
     8 I6 R/ @: i( s! {4 O' o
496. /// Get name of a timer.
     
497. /// \param[in]     timer_id      timer ID obtained by \ref osTimerNew.
     . g3 K  Q! L5 G, k! O
498. /// \return name as NULL terminated string.
     
499. const char *osTimerGetName (osTimerId_t timer_id);
     6 p8 N7 P& Z2 I% |$ Q1 h
500. 
     
501. /// Start or restart a timer.
     + T+ G4 j/ {% u2 [$ ^% s+ @
502. /// \param[in]     timer_id      timer ID obtained by \ref osTimerNew.
     
503. /// \param[in]     ticks         \ref CMSIS_RTOS_TimeOutValue "time ticks" value of the timer.
     
504. /// \return status code that indicates the execution status of the function.
     : F8 R: t' y2 L2 {2 Z. d' p, Y
505. osStatus_t osTimerStart (osTimerId_t timer_id, uint32_t ticks);
     & s% y2 L; Q. i, J
506. 
     
507. /// Stop a timer.
     7 ?% j; j0 M- m4 w' N
508. /// \param[in]     timer_id      timer ID obtained by \ref osTimerNew.
     
509. /// \return status code that indicates the execution status of the function.
     - j6 a3 s4 ^4 W- p9 P
510. osStatus_t osTimerStop (osTimerId_t timer_id);
     6 g* a6 o' n3 I( L" T/ u# L$ c5 E3 Y
511. 
     : [/ L. a+ k: C5 `
512. /// Check if a timer is running.
     $ F( ~' h$ x! N2 O& Z
513. /// \param[in]     timer_id      timer ID obtained by \ref osTimerNew.
     
514. /// \return 0 not running, 1 running.
     6 k. s7 l  ~& g9 u
515. uint32_t osTimerIsRunning (osTimerId_t timer_id);
     ( Q; y: T! M9 I% g8 t' s3 }. h
516. 
     6 M: V7 ^$ B) `. i" C1 k% A( J- C
517. /// Delete a timer.
     
518. /// \param[in]     timer_id      timer ID obtained by \ref osTimerNew.
     + B6 e& G0 `  {6 j- H
519. /// \return status code that indicates the execution status of the function.
     : I# Z* Z9 _9 x% x$ B% ~7 i! h5 Z
520. osStatus_t osTimerDelete (osTimerId_t timer_id);
     
521. 
     , S& j+ A0 l5 b2 ^! j2 P  g, C
522. 
     . }6 |0 j  q8 l* Z/ A
523. //  ==== Event Flags Management Functions ====
     3 e( O* z3 c: C
524. 
     * O7 u0 W1 z1 z  a8 m
525. /// Create and Initialize an Event Flags object.
     
526. /// \param[in]     attr          event flags attributes; NULL: default values.
     # ~0 [! y& p0 B1 ^: x" G6 `
527. /// \return event flags ID for reference by other functions or NULL in case of error.
     / y$ [: g; l% |( I; B  R
528. osEventFlagsId_t osEventFlagsNew (const osEventFlagsAttr_t *attr);
     
529. 
     # I) S3 T% ^2 v, a  g; @6 {
530. /// Get name of an Event Flags object.
     $ m7 u% n- e/ O) V
531. /// \param[in]     ef_id         event flags ID obtained by \ref osEventFlagsNew.
     
532. /// \return name as NULL terminated string.
     
533. const char *osEventFlagsGetName (osEventFlagsId_t ef_id);
       B4 N/ M5 x, R% G6 M9 A7 b7 J; H) U
534. 
     
535. /// Set the specified Event Flags.
     
536. /// \param[in]     ef_id         event flags ID obtained by \ref osEventFlagsNew.
     1 ]) D0 Y, U: g
537. /// \param[in]     flags         specifies the flags that shall be set.
     & |/ N9 P% N& p8 J
538. /// \return event flags after setting or error code if highest bit set.
     
539. uint32_t osEventFlagsSet (osEventFlagsId_t ef_id, uint32_t flags);
     
540. 
     % w4 h2 b4 [! K: ~% O3 L' K! o& W: v* V+ p
541. /// Clear the specified Event Flags.
     8 h& u+ h& U4 w2 [
542. /// \param[in]     ef_id         event flags ID obtained by \ref osEventFlagsNew.
     
543. /// \param[in]     flags         specifies the flags that shall be cleared.
     ! _" J0 o1 b' t
544. /// \return event flags before clearing or error code if highest bit set.
     1 ?6 o5 i% p( j7 M: B; a8 f
545. uint32_t osEventFlagsClear (osEventFlagsId_t ef_id, uint32_t flags);
     , |- m# `5 V3 D5 P4 J! E# s2 @
546. 
     5 ]* n% z) N; J
547. /// Get the current Event Flags.
     
548. /// \param[in]     ef_id         event flags ID obtained by \ref osEventFlagsNew.
     
549. /// \return current event flags.
     1 b$ Z4 `, ~' W* n7 W
550. uint32_t osEventFlagsGet (osEventFlagsId_t ef_id);
     
551. 
     
552. /// Wait for one or more Event Flags to become signaled.
     
553. /// \param[in]     ef_id         event flags ID obtained by \ref osEventFlagsNew.
     " Z! s; n6 a! `- f$ Z: Y# e
554. /// \param[in]     flags         specifies the flags to wait for.
     ( |! [3 P; ]4 g8 r
555. /// \param[in]     options       specifies flags options (osFlagsXxxx).
     
556. /// \param[in]     timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
     
557. /// \return event flags before clearing or error code if highest bit set.
     
558. uint32_t osEventFlagsWait (osEventFlagsId_t ef_id, uint32_t flags, uint32_t options, uint32_t timeout);
     - T- q2 d# d8 E! e
559. 
     
560. /// Delete an Event Flags object.
     ( W: j. Y: p! Y1 C: k# m( U
561. /// \param[in]     ef_id         event flags ID obtained by \ref osEventFlagsNew.
     
562. /// \return status code that indicates the execution status of the function.
     
563. osStatus_t osEventFlagsDelete (osEventFlagsId_t ef_id);
     1 Q' q! O: T& C- X
564. 
     
565. 
     
566. //  ==== Mutex Management Functions ====
     8 O$ n/ X% a) S+ u9 N- ]; m
567. 
     
568. /// Create and Initialize a Mutex object.
     
569. /// \param[in]     attr          mutex attributes; NULL: default values.
     ' P; l: a" Q9 E/ U: g/ F
570. /// \return mutex ID for reference by other functions or NULL in case of error.
     
571. osMutexId_t osMutexNew (const osMutexAttr_t *attr);
     + J- G* N$ t$ `. S, m2 T
572. 
     
573. /// Get name of a Mutex object.
     
574. /// \param[in]     mutex_id      mutex ID obtained by \ref osMutexNew.
     
575. /// \return name as NULL terminated string.
     0 Z% W( N. x/ `$ N  k/ ]6 G2 s& ~& w
576. const char *osMutexGetName (osMutexId_t mutex_id);
     ; S( e8 C$ [$ }  `" e+ X7 N
577. 
     , J! T( Q5 h% A! g
578. /// Acquire a Mutex or timeout if it is locked.
     
579. /// \param[in]     mutex_id      mutex ID obtained by \ref osMutexNew.
     
580. /// \param[in]     timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
     
581. /// \return status code that indicates the execution status of the function.
     ' A& v, t8 Q; d6 @9 a1 b. v
582. osStatus_t osMutexAcquire (osMutexId_t mutex_id, uint32_t timeout);
     
583. 
     / D+ F, a  j. }, B) t. n
584. /// Release a Mutex that was acquired by \ref osMutexAcquire.
     8 w0 g- I' N( S' T% {9 P- M
585. /// \param[in]     mutex_id      mutex ID obtained by \ref osMutexNew.
     5 t5 K5 z. c$ [
586. /// \return status code that indicates the execution status of the function.
     
587. osStatus_t osMutexRelease (osMutexId_t mutex_id);
     
588. 
     - s$ @* L/ f- b
589. /// Get Thread which owns a Mutex object.
     ) O- |& H; P7 F& ]1 Z
590. /// \param[in]     mutex_id      mutex ID obtained by \ref osMutexNew.
     9 }' ]" E8 `4 e' v% V
591. /// \return thread ID of owner thread or NULL when mutex was not acquired.
     6 \- Z; F  k, @- v" W0 E9 i
592. osThreadId_t osMutexGetOwner (osMutexId_t mutex_id);
     0 o! }7 C! F$ |- V6 h- R
593. 
     . C$ y; Q7 F. C$ E
594. /// Delete a Mutex object.
     
595. /// \param[in]     mutex_id      mutex ID obtained by \ref osMutexNew.
     
596. /// \return status code that indicates the execution status of the function.
       s+ ?2 ^" X* g3 F( F! j2 O0 Y3 A
597. osStatus_t osMutexDelete (osMutexId_t mutex_id);
     : A- \. {( ~% O6 F$ `$ y) d
598. 
     7 X) Y- Q: W. P8 g6 M* \7 n
599. 
     
600. //  ==== Semaphore Management Functions ====
     
601. 
     # N* x3 ?3 h' I. [! P0 M1 |
602. /// Create and Initialize a Semaphore object.
     ; ^! E) R* ]& |% F1 o* |
603. /// \param[in]     max_count     maximum number of available tokens.
     
604. /// \param[in]     initial_count initial number of available tokens.
     * K) r$ I# K1 ?9 F* p
605. /// \param[in]     attr          semaphore attributes; NULL: default values.
     - L% b: F( K# K! S
606. /// \return semaphore ID for reference by other functions or NULL in case of error.
     
607. osSemaphoreId_t osSemaphoreNew (uint32_t max_count, uint32_t initial_count, const osSemaphoreAttr_t *attr);
     
608. 
     
609. /// Get name of a Semaphore object.
     
610. /// \param[in]     semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
     " }! ], y# `) m. l) v
611. /// \return name as NULL terminated string.
     ( t" S" T& T6 ^
612. const char *osSemaphoreGetName (osSemaphoreId_t semaphore_id);
     
613. 
     
614. /// Acquire a Semaphore token or timeout if no tokens are available.
     6 M$ {$ [+ o! h9 q7 H
615. /// \param[in]     semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
     : M% {6 r+ [% g
616. /// \param[in]     timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
       w1 k5 A( C' _' [% x9 u
617. /// \return status code that indicates the execution status of the function.
     " X0 J/ f5 h7 F. o
618. osStatus_t osSemaphoreAcquire (osSemaphoreId_t semaphore_id, uint32_t timeout);
     . A) }* J8 |% Y+ B# i) ~# N, J; U
619. 
     
620. /// Release a Semaphore token up to the initial maximum count.
     7 X5 ^* V9 ?7 V# J: o6 }
621. /// \param[in]     semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
       l, q5 B; G  N0 e4 H) z
622. /// \return status code that indicates the execution status of the function.
     
623. osStatus_t osSemaphoreRelease (osSemaphoreId_t semaphore_id);
     " \' ]# z! N; n1 K
624. 
     
625. /// Get current Semaphore token count.
     
626. /// \param[in]     semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
     
627. /// \return number of tokens available.
     
628. uint32_t osSemaphoreGetCount (osSemaphoreId_t semaphore_id);
     7 X) I3 t8 P2 t  p# F1 N  {9 G
629. 
     
630. /// Delete a Semaphore object.
     ) \" d# U- I1 K1 V' O0 l
631. /// \param[in]     semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
     . i" h; V' }. w+ V, D. B
632. /// \return status code that indicates the execution status of the function.
     
633. osStatus_t osSemaphoreDelete (osSemaphoreId_t semaphore_id);
     " w1 s( B; J& y) f# L
634. 
     , k* c5 t5 T# Y) P6 s
635. 
       ^( ~9 s. h: t' {2 s5 X
636. //  ==== Memory Pool Management Functions ====
     " H. {2 v3 G' O4 `8 A  E2 n/ b
637. 
     
638. /// Create and Initialize a Memory Pool object.
     
639. /// \param[in]     block_count   maximum number of memory blocks in memory pool.
     
640. /// \param[in]     block_size    memory block size in bytes.
     * D) W& ^0 h) R6 A
641. /// \param[in]     attr          memory pool attributes; NULL: default values.
     
642. /// \return memory pool ID for reference by other functions or NULL in case of error.
     / G& i1 A- z* `' D
643. osMemoryPoolId_t osMemoryPoolNew (uint32_t block_count, uint32_t block_size, const osMemoryPoolAttr_t *attr);
     ; s. W& z% T" o! O0 M
644. 
     0 F) W/ ^4 B( t8 `  x; S, [
645. /// Get name of a Memory Pool object.
     
646. /// \param[in]     mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
     6 ?" Q  @  A5 s
647. /// \return name as NULL terminated string.
     
648. const char *osMemoryPoolGetName (osMemoryPoolId_t mp_id);
     : r7 A$ e* u+ l# T3 P6 H. ^6 w
649. 
     ! U( O. @/ q4 d) ^0 s
650. /// Allocate a memory block from a Memory Pool.
     
651. /// \param[in]     mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
     
652. /// \param[in]     timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
     
653. /// \return address of the allocated memory block or NULL in case of no memory is available.
     1 [5 ~: o5 z% V# |. Q7 d3 k* h5 R+ ^
654. void *osMemoryPoolAlloc (osMemoryPoolId_t mp_id, uint32_t timeout);
     
655. 
     " @) B8 D( C0 X8 C; C
656. /// Return an allocated memory block back to a Memory Pool.
     
657. /// \param[in]     mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
     2 [# f* A4 U$ H, P9 q0 `. ~7 o
658. /// \param[in]     block         address of the allocated memory block to be returned to the memory pool.
     
659. /// \return status code that indicates the execution status of the function.
     
660. osStatus_t osMemoryPoolFree (osMemoryPoolId_t mp_id, void *block);
     ' p1 }/ z" O# J
661. 
     5 @8 M5 ]# r' W1 _* z9 _7 O
662. /// Get maximum number of memory blocks in a Memory Pool.
     
663. /// \param[in]     mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
     
664. /// \return maximum number of memory blocks.
     4 Z) ^( A- O0 K; C; F5 J
665. uint32_t osMemoryPoolGetCapacity (osMemoryPoolId_t mp_id);
     
666. 
     
667. /// Get memory block size in a Memory Pool.
     
668. /// \param[in]     mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
     
669. /// \return memory block size in bytes.
     5 g) e- j4 z4 T! d1 x
670. uint32_t osMemoryPoolGetBlockSize (osMemoryPoolId_t mp_id);
     
671. 
     
672. /// Get number of memory blocks used in a Memory Pool.
     5 g& k& W" f6 D
673. /// \param[in]     mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
     
674. /// \return number of memory blocks used.
     
675. uint32_t osMemoryPoolGetCount (osMemoryPoolId_t mp_id);
     ; h+ z8 H& V) l# \; k' Z
676. 
     , z3 I2 D5 C- c7 ]  ?. |
677. /// Get number of memory blocks available in a Memory Pool.
     , z5 e+ U9 N- n7 A2 g1 ^
678. /// \param[in]     mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
     0 O% B$ S3 q0 G: E" G/ J) F/ N
679. /// \return number of memory blocks available.
     
680. uint32_t osMemoryPoolGetSpace (osMemoryPoolId_t mp_id);
     
681. 
     / c( ], S, I* O) v5 P/ m. A
682. /// Delete a Memory Pool object.
     
683. /// \param[in]     mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
     
684. /// \return status code that indicates the execution status of the function.
     ( N& F! k, ], b
685. osStatus_t osMemoryPoolDelete (osMemoryPoolId_t mp_id);
     
686. 
     
687. 
     - Z) _# @/ Q  W7 l  W
688. //  ==== Message Queue Management Functions ====
     
689. 
     
690. /// Create and Initialize a Message Queue object.
     ! D, T* c0 x/ _- ^
691. /// \param[in]     msg_count     maximum number of messages in queue.
     
692. /// \param[in]     msg_size      maximum message size in bytes.
     $ N/ ^: ]' ?; @# [
693. /// \param[in]     attr          message queue attributes; NULL: default values.
     0 t, O$ F1 q% t! }) e" A. m
694. /// \return message queue ID for reference by other functions or NULL in case of error.
     7 N( f2 U, i3 q1 G  q7 {0 A
695. osMessageQueueId_t osMessageQueueNew (uint32_t msg_count, uint32_t msg_size, const osMessageQueueAttr_t *attr);
     4 R0 W9 V; g; J/ e# D5 c
696. 
     ' |; Z# z# e4 `* j) J
697. /// Get name of a Message Queue object.
     5 L, Y. O4 i: K: E
698. /// \param[in]     mq_id         message queue ID obtained by \ref osMessageQueueNew.
     
699. /// \return name as NULL terminated string.
     % M+ l& L$ i( d9 d
700. const char *osMessageQueueGetName (osMessageQueueId_t mq_id);
     1 N+ M. B# ~3 ]$ s, t3 V
701. 
     
702. /// Put a Message into a Queue or timeout if Queue is full.
     
703. /// \param[in]     mq_id         message queue ID obtained by \ref osMessageQueueNew.
     
704. /// \param[in]     msg_ptr       pointer to buffer with message to put into a queue.
     
705. /// \param[in]     msg_prio      message priority.
     
706. /// \param[in]     timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
     - T  ?3 x7 z5 s  w; s# g- w
707. /// \return status code that indicates the execution status of the function.
     6 }+ k$ [; C5 n1 b# i' f
708. osStatus_t osMessageQueuePut (osMessageQueueId_t mq_id, const void *msg_ptr, uint8_t msg_prio, uint32_t timeout);
     
709. 
     
710. /// Get a Message from a Queue or timeout if Queue is empty.
     : S, F: ^( q# m: K. C1 Z
711. /// \param[in]     mq_id         message queue ID obtained by \ref osMessageQueueNew.
     ! U* K" S4 ^% C4 V- O
712. /// \param[out]    msg_ptr       pointer to buffer for message to get from a queue.
     : V# z+ T7 i8 W. c; \' H
713. /// \param[out]    msg_prio      pointer to buffer for message priority or NULL.
     + V1 G' z1 V  |
714. /// \param[in]     timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
     - Q, v5 j. K4 @% a/ g: u/ W
715. /// \return status code that indicates the execution status of the function.
     8 K( {. @; Z, I4 u9 H3 j2 s3 D+ T
716. osStatus_t osMessageQueueGet (osMessageQueueId_t mq_id, void *msg_ptr, uint8_t *msg_prio, uint32_t timeout);
     0 I% ]& N3 P9 p/ k' }
717. 
     + F4 l/ v# j* R3 e) U1 {( U
718. /// Get maximum number of messages in a Message Queue.
     ( B0 I/ q, {' V( s, N. T6 c
719. /// \param[in]     mq_id         message queue ID obtained by \ref osMessageQueueNew.
     
720. /// \return maximum number of messages.
       ?4 V- T' ]8 I1 B6 @4 h- D/ N' x
721. uint32_t osMessageQueueGetCapacity (osMessageQueueId_t mq_id);
     
722. 
     
723. /// Get maximum message size in a Memory Pool.
     
724. /// \param[in]     mq_id         message queue ID obtained by \ref osMessageQueueNew.
     
725. /// \return maximum message size in bytes.
     5 @- ~% E8 C2 c9 V8 `' q8 O
726. uint32_t osMessageQueueGetMsgSize (osMessageQueueId_t mq_id);
     
727. 
     
728. /// Get number of queued messages in a Message Queue.
     
729. /// \param[in]     mq_id         message queue ID obtained by \ref osMessageQueueNew.
     ) l; c0 r: Z; u5 F% t
730. /// \return number of queued messages.
     
731. uint32_t osMessageQueueGetCount (osMessageQueueId_t mq_id);
     
732. 
     
733. /// Get number of available slots for messages in a Message Queue.
     
734. /// \param[in]     mq_id         message queue ID obtained by \ref osMessageQueueNew.
     
735. /// \return number of available slots for messages.
     
736. uint32_t osMessageQueueGetSpace (osMessageQueueId_t mq_id);
     , S) p  g  D) K5 m9 n
737. 
     3 `# d, ~5 P' t$ l1 u0 T% A
738. /// Reset a Message Queue to initial empty state.
     
739. /// \param[in]     mq_id         message queue ID obtained by \ref osMessageQueueNew.
     8 }' J  U: z: i
740. /// \return status code that indicates the execution status of the function.
     ' t+ y- o! d: i$ Z* g  \3 `  a
741. osStatus_t osMessageQueueReset (osMessageQueueId_t mq_id);
     9 O) ?# B# y* I& t3 V7 s# ]
742. 
     / t2 j/ y0 G4 s" d" |, Y. J( G- U
743. /// Delete a Message Queue object.
     # x  B( ]' @7 y2 q
744. /// \param[in]     mq_id         message queue ID obtained by \ref osMessageQueueNew.
     
745. /// \return status code that indicates the execution status of the function.
     & r3 _( i2 u9 d; k6 c% q' }# z( Y$ k
746. osStatus_t osMessageQueueDelete (osMessageQueueId_t mq_id);
     ! E; b# P/ j4 r+ M
747. 
     7 a. w- r# k8 g! S% j1 N- }/ B5 A
748. 
     
749. #ifdef  __cplusplus
     + n( _9 m4 I0 J: k
750. }
     - J* I" m/ q( T
751. #endif
     
752. 
     1 s! \2 a9 @4 r* d
753. #endif  // CMSIS_OS2_H_

复制代码

归档链接：
CMSIS-RTOS2 文档翻译 之 简介
CMSIS-RTOS2 文档翻译 之 修订记录
' T2 p& k& L0 sCMSIS-RTOS2 文档翻译 之 功能概述
7 A0 \1 g$ q2 e. q  f, M4 @) p. rCMSIS-RTOS2 文档翻译 之 RTOS 验证

支持，我现在用的是cmsis_os接口

黑皮男 发表于 2018-4-21 16:36
/ [& d4 t! r" n: M支持，我现在用的是cmsis_os接口

6 m1 o( |( h2 b* W! @. k  c; i就是相关的教程和文档比较少，用的人比较少，你很有前瞻性啊。

XinLiYF 发表于 2018-4-22 09:14
; W2 e+ A( _4 D' H就是相关的教程和文档比较少，用的人比较少，你很有前瞻性啊。

) Z3 V) ^2 C1 M8 }: a9 p" A- q2 }之前都是自己封装RTOS的接口，发现cmsis_os后，既然都有统一的接口，干脆就拿来用了，比自己封装的要好很多

黑皮男 发表于 2018-4-22 09:42
之前都是自己封装RTOS的接口，发现cmsis_os后，既然都有统一的接口，干脆就拿来用了，比自己封装的要好很 ...

刚去你 GitHub 逛啦一圈 ，你肯定是一个外表粗犷内心细腻的人 ，GitHub 上关注你了