source: S-port/trunk/Drivers/CMSIS/RTOS2/Template/cmsis_os1.c

Last change on this file was 1, checked in by AlexLir, 3 years ago
File size: 8.8 KB
Line 
1/*
2 * Copyright (c) 2013-2017 ARM Limited. All rights reserved.
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
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 *
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
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 *
18 * ----------------------------------------------------------------------
19 *
20 * $Date: 10. January 2017
21 * $Revision: V1.2
22 *
23 * Project: CMSIS-RTOS API V1
24 * Title: cmsis_os_v1.c V1 module file
25 *---------------------------------------------------------------------------*/
26
27#include <string.h>
28#include "cmsis_os.h"
29
30#if (osCMSIS >= 0x20000U)
31
32
33// Thread
34osThreadId osThreadCreate (const osThreadDef_t *thread_def, void *argument) {
35
36 if (thread_def == NULL) {
37 return (osThreadId)NULL;
38 }
39 return osThreadNew((osThreadFunc_t)thread_def->pthread, argument, &thread_def->attr);
40}
41
42
43// Signals
44
45#define SignalMask ((1U<<osFeature_Signals)-1U)
46
47int32_t osSignalSet (osThreadId thread_id, int32_t signals) {
48 uint32_t flags;
49
50 flags = osThreadFlagsSet(thread_id, (uint32_t)signals);
51 if ((flags & 0x80000000U) != 0U) {
52 return ((int32_t)0x80000000U);
53 }
54 return ((int32_t)(flags & ~((uint32_t)signals)));
55}
56
57int32_t osSignalClear (osThreadId thread_id, int32_t signals) {
58 uint32_t flags;
59
60 if (thread_id != osThreadGetId()) {
61 return ((int32_t)0x80000000U);
62 }
63 flags = osThreadFlagsClear((uint32_t)signals);
64 if ((flags & 0x80000000U) != 0U) {
65 return ((int32_t)0x80000000U);
66 }
67 return ((int32_t)flags);
68}
69
70osEvent osSignalWait (int32_t signals, uint32_t millisec) {
71 osEvent event;
72 uint32_t flags;
73
74 if (signals != 0) {
75 flags = osThreadFlagsWait((uint32_t)signals, osFlagsWaitAll, millisec);
76 } else {
77 flags = osThreadFlagsWait(SignalMask, osFlagsWaitAny, millisec);
78 }
79 if ((flags > 0U) && (flags < 0x80000000U)) {
80 event.status = osEventSignal;
81 event.value.signals = (int32_t)flags;
82 } else {
83 switch ((int32_t)flags) {
84 case osErrorResource:
85 event.status = osOK;
86 break;
87 case osErrorTimeout:
88 event.status = osEventTimeout;
89 break;
90 case osErrorParameter:
91 event.status = osErrorValue;
92 break;
93 default:
94 event.status = (osStatus)flags;
95 break;
96 }
97 }
98 return event;
99}
100
101
102// Timer
103osTimerId osTimerCreate (const osTimerDef_t *timer_def, os_timer_type type, void *argument) {
104
105 if (timer_def == NULL) {
106 return (osTimerId)NULL;
107 }
108 return osTimerNew((osTimerFunc_t)timer_def->ptimer, type, argument, &timer_def->attr);
109}
110
111
112// Mutex
113osMutexId osMutexCreate (const osMutexDef_t *mutex_def) {
114
115 if (mutex_def == NULL) {
116 return (osMutexId)NULL;
117 }
118 return osMutexNew(mutex_def);
119}
120
121
122// Semaphore
123
124#if (defined (osFeature_Semaphore) && (osFeature_Semaphore != 0U))
125
126osSemaphoreId osSemaphoreCreate (const osSemaphoreDef_t *semaphore_def, int32_t count) {
127
128 if (semaphore_def == NULL) {
129 return (osSemaphoreId)NULL;
130 }
131 return osSemaphoreNew((uint32_t)count, (uint32_t)count, semaphore_def);
132}
133
134int32_t osSemaphoreWait (osSemaphoreId semaphore_id, uint32_t millisec) {
135 osStatus_t status;
136 uint32_t count;
137
138 status = osSemaphoreAcquire(semaphore_id, millisec);
139 switch (status) {
140 case osOK:
141 count = osSemaphoreGetCount(semaphore_id);
142 return ((int32_t)count + 1);
143 case osErrorResource:
144 case osErrorTimeout:
145 return 0;
146 default:
147 break;
148 }
149 return -1;
150}
151
152#endif // Semaphore
153
154
155// Memory Pool
156
157#if (defined(osFeature_Pool) && (osFeature_Pool != 0))
158
159osPoolId osPoolCreate (const osPoolDef_t *pool_def) {
160
161 if (pool_def == NULL) {
162 return (osPoolId)NULL;
163 }
164 return ((osPoolId)(osMemoryPoolNew(pool_def->pool_sz, pool_def->item_sz, &pool_def->attr)));
165}
166
167void *osPoolAlloc (osPoolId pool_id) {
168 return osMemoryPoolAlloc((osMemoryPoolId_t)pool_id, 0U);
169}
170
171void *osPoolCAlloc (osPoolId pool_id) {
172 void *block;
173 uint32_t block_size;
174
175 block_size = osMemoryPoolGetBlockSize((osMemoryPoolId_t)pool_id);
176 if (block_size == 0U) {
177 return NULL;
178 }
179 block = osMemoryPoolAlloc((osMemoryPoolId_t)pool_id, 0U);
180 if (block != NULL) {
181 memset(block, 0, block_size);
182 }
183 return block;
184}
185
186osStatus osPoolFree (osPoolId pool_id, void *block) {
187 return osMemoryPoolFree((osMemoryPoolId_t)pool_id, block);
188}
189
190#endif // Memory Pool
191
192
193// Message Queue
194
195#if (defined(osFeature_MessageQ) && (osFeature_MessageQ != 0))
196
197osMessageQId osMessageCreate (const osMessageQDef_t *queue_def, osThreadId thread_id) {
198 (void)thread_id;
199
200 if (queue_def == NULL) {
201 return (osMessageQId)NULL;
202 }
203 return ((osMessageQId)(osMessageQueueNew(queue_def->queue_sz, sizeof(uint32_t), &queue_def->attr)));
204}
205
206osStatus osMessagePut (osMessageQId queue_id, uint32_t info, uint32_t millisec) {
207 return osMessageQueuePut((osMessageQueueId_t)queue_id, &info, 0U, millisec);
208}
209
210osEvent osMessageGet (osMessageQId queue_id, uint32_t millisec) {
211 osStatus_t status;
212 osEvent event;
213 uint32_t message;
214
215 status = osMessageQueueGet((osMessageQueueId_t)queue_id, &message, NULL, millisec);
216 switch (status) {
217 case osOK:
218 event.status = osEventMessage;
219 event.value.v = message;
220 break;
221 case osErrorResource:
222 event.status = osOK;
223 break;
224 case osErrorTimeout:
225 event.status = osEventTimeout;
226 break;
227 default:
228 event.status = status;
229 break;
230 }
231 return event;
232}
233
234#endif // Message Queue
235
236
237// Mail Queue
238
239#if (defined(osFeature_MailQ) && (osFeature_MailQ != 0))
240
241typedef struct os_mail_queue_s {
242 osMemoryPoolId_t mp_id;
243 osMessageQueueId_t mq_id;
244} os_mail_queue_t;
245
246osMailQId osMailCreate (const osMailQDef_t *queue_def, osThreadId thread_id) {
247 os_mail_queue_t *ptr;
248 (void)thread_id;
249
250 if (queue_def == NULL) {
251 return (osMailQId)NULL;
252 }
253
254 ptr = queue_def->mail;
255 if (ptr == NULL) {
256 return (osMailQId)NULL;
257 }
258
259 ptr->mp_id = osMemoryPoolNew (queue_def->queue_sz, queue_def->item_sz, &queue_def->mp_attr);
260 ptr->mq_id = osMessageQueueNew(queue_def->queue_sz, sizeof(void *), &queue_def->mq_attr);
261 if ((ptr->mp_id == (osMemoryPoolId_t)NULL) || (ptr->mq_id == (osMessageQueueId_t)NULL)) {
262 if (ptr->mp_id != (osMemoryPoolId_t)NULL) {
263 osMemoryPoolDelete(ptr->mp_id);
264 }
265 if (ptr->mq_id != (osMessageQueueId_t)NULL) {
266 osMessageQueueDelete(ptr->mq_id);
267 }
268 return (osMailQId)NULL;
269 }
270
271 return (osMailQId)ptr;
272}
273
274void *osMailAlloc (osMailQId queue_id, uint32_t millisec) {
275 os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
276
277 if (ptr == NULL) {
278 return NULL;
279 }
280 return osMemoryPoolAlloc(ptr->mp_id, millisec);
281}
282
283void *osMailCAlloc (osMailQId queue_id, uint32_t millisec) {
284 os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
285 void *block;
286 uint32_t block_size;
287
288 if (ptr == NULL) {
289 return NULL;
290 }
291 block_size = osMemoryPoolGetBlockSize(ptr->mp_id);
292 if (block_size == 0U) {
293 return NULL;
294 }
295 block = osMemoryPoolAlloc(ptr->mp_id, millisec);
296 if (block != NULL) {
297 memset(block, 0, block_size);
298 }
299
300 return block;
301
302}
303
304osStatus osMailPut (osMailQId queue_id, const void *mail) {
305 os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
306
307 if (ptr == NULL) {
308 return osErrorParameter;
309 }
310 if (mail == NULL) {
311 return osErrorValue;
312 }
313 return osMessageQueuePut(ptr->mq_id, &mail, 0U, 0U);
314}
315
316osEvent osMailGet (osMailQId queue_id, uint32_t millisec) {
317 os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
318 osStatus_t status;
319 osEvent event;
320 void *mail;
321
322 if (ptr == NULL) {
323 event.status = osErrorParameter;
324 return event;
325 }
326
327 status = osMessageQueueGet(ptr->mq_id, &mail, NULL, millisec);
328 switch (status) {
329 case osOK:
330 event.status = osEventMail;
331 event.value.p = mail;
332 break;
333 case osErrorResource:
334 event.status = osOK;
335 break;
336 case osErrorTimeout:
337 event.status = osEventTimeout;
338 break;
339 default:
340 event.status = status;
341 break;
342 }
343 return event;
344}
345
346osStatus osMailFree (osMailQId queue_id, void *mail) {
347 os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
348
349 if (ptr == NULL) {
350 return osErrorParameter;
351 }
352 if (mail == NULL) {
353 return osErrorValue;
354 }
355 return osMemoryPoolFree(ptr->mp_id, mail);
356}
357
358#endif // Mail Queue
359
360
361#endif // osCMSIS
Note: See TracBrowser for help on using the repository browser.