H& |" D% f  l, y
% @4 a7 T4 B5 {% Z/ O( [+ l" Z

通用 RTOS 接口

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

7 I$ P3 `3 f) L# k- a

CMSIS-RTOS API 结构
2 q7 M1 B. _: {+ N0 O7 u

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

• 函数名称，标识符和参数是描述性的，易于理解的。这些功能强大而灵活，减少了暴露给用户的功能数量。
• 线程管理允许您定义，创建和控制线程。
• 中断服务程序（ISR）可以调用一些 CMSIS-RTOS 功能。 当 CMSIS-RTOS 函数不能从 ISR 上下文中调用时，它会拒绝调用并返回错误代码。
• 三种不同的事件类型支持多个线程和/或 ISR 之间的通信：
  " t9 B) Z$ e' U( G: z' P8 m2 @
  • 线程标志: 可用于向线程指示特定条件。
  • 事件标志: 可用于向线程或 ISR 指示事件。
  • 消息: 可以发送到线程或 ISR 。消息缓冲在队列中。
    
• 互斥管理和信号量已合并。
• CPU 时间可以安排以下功能：
  
  • 超时参数包含在许多 CMSIS-RTOS 功能中，以避免系统锁定。当指定超时时，系统会等待，直到资源可用或发生事件。在等待时，运行其他线程。
  • osDelay 和 osDelayUntil 函数将线程置于 WAITING 状态一段指定的时间。
  • osThreadYield 提供协作式线程切换并将执行传递给具有相同优先级的另一个线程。
    
• 定时器管理功能用于触发功能的执行。
  

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

+ t3 `) V" t9 k" T1 |

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

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

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

$ C, p; |2 h* z' l6 J3 R' G: W使用 CMSIS-RTOS2 实现

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

CMSIS-RTOS 文件结构
# P  b& y& J/ E: x

. o8 j; @* I: z8 r2 L

) _, e% _! \1 I8 c- X* \: S# W

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

代码示例

1. /*----------------------------------------------------------------------------
   
2. * CMSIS-RTOS 'main' function template
   . G# q& T4 j5 g( ]% U" X3 `6 X
3. *---------------------------------------------------------------------------*/
   1 D4 W6 ~, L! l. O2 i! e* U9 Z( g
4. 
     I/ M$ ^% A4 j6 j* i* _
5. #include "RTE_Components.h"
   
6. #include  CMSIS_device_header
   6 i8 v  B1 t% L7 H
7. #include "cmsis_os2.h"
   5 Z0 e! S+ t" s, C& g6 R0 f! E+ u
8. 
   9 `+ ]6 b( ?; _% a  q' |. \& Y) n
9. /*----------------------------------------------------------------------------
   - I8 e' t, E( \; G. d5 `; h/ g* [% [. b6 b
10. * Application main thread
    ( i/ K- J/ V" _0 g4 ~
11. *---------------------------------------------------------------------------*/
    
12. void app_main (void *argument) {
    2 }$ E6 r; v1 _( d9 T9 C: H
13. 
    - H) N* N5 u! ?$ D5 B5 k
14.   // ...
    : ~4 f3 u2 W/ e
15.   for (;;) {}
    0 M! k# ~6 H3 |* y( A% u
16. }
    
17. 
    ) O! |2 w& U- k3 U
18. int main (void) {
    " E6 u3 C: n+ E5 D# n
19. 
    ! U% q1 ^; `2 w! Y
20.   // System Initialization
    
21.   SystemCoreClockUpdate();
    
22. #ifdef RTE_Compiler_EventRecorder
    ; g4 p+ `7 k; u- {8 ?4 W
23.   // Initialize and start Event Recorder
    : c, m7 ^4 A8 H9 O
24.   EventRecorderInitialize(EventRecordError, 1U);
    3 n+ b% ?/ ?- Q8 w$ N8 |
25. #endif
    
26.   // ...
    : q3 m" A. G2 ?. j  O
27. 
    ; z* a, j3 ?! Q
28.   osKernelInitialize();                 // Initialize CMSIS-RTOS
    
29.   osThreadNew(app_main, NULL, NULL);    // Create application main thread
    
30.   osKernelStart();                      // Start thread execution
    . |' A  _3 y4 @3 T% L" B: T
31.   for (;;) {}
    
32. }

复制代码

cmsis_os2.h 头文件

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

* r9 g; S7 V3 P* J; i8 K' j& j

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

头文件 cmsis_os2.h

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

复制代码

) {# H7 r5 D/ X) ]7 }归档链接：
, T' F" b+ o% Y5 Q- B: |CMSIS-RTOS2 文档翻译 之 简介
CMSIS-RTOS2 文档翻译 之 修订记录
CMSIS-RTOS2 文档翻译 之 功能概述
CMSIS-RTOS2 文档翻译 之 RTOS 验证

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

黑皮男 发表于 2018-4-21 16:36
支持，我现在用的是cmsis_os接口

就是相关的教程和文档比较少，用的人比较少，你很有前瞻性啊。

XinLiYF 发表于 2018-4-22 09:14
就是相关的教程和文档比较少，用的人比较少，你很有前瞻性啊。

( G2 T1 ~/ N( D! M# ?+ V1 [之前都是自己封装RTOS的接口，发现cmsis_os后，既然都有统一的接口，干脆就拿来用了，比自己封装的要好很多

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

! q( \; E' ]8 O刚去你 GitHub 逛啦一圈 ，你肯定是一个外表粗犷内心细腻的人 ，GitHub 上关注你了