Hiruka Hana / Gyro_Accelerometre

Programme gyro_accelero avec acquisition accelero + calcul téta

Dependents:   Gyro_Accelerometre2

rtos/Thread.cpp@0:07281ea3b26b, 2018-02-20 (annotated)

Committer:
SandrineO
Date:
Tue Feb 20 15:58:26 2018 +0000
Revision:
0:07281ea3b26b
temps r?el

Who changed what in which revision?

UserRevisionLine numberNew contents of line
SandrineO 0:07281ea3b26b 1 /* mbed Microcontroller Library
SandrineO 0:07281ea3b26b 2 * Copyright (c) 2006-2012 ARM Limited
SandrineO 0:07281ea3b26b 3 *
SandrineO 0:07281ea3b26b 4 * Permission is hereby granted, free of charge, to any person obtaining a copy
SandrineO 0:07281ea3b26b 5 * of this software and associated documentation files (the "Software"), to deal
SandrineO 0:07281ea3b26b 6 * in the Software without restriction, including without limitation the rights
SandrineO 0:07281ea3b26b 7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
SandrineO 0:07281ea3b26b 8 * copies of the Software, and to permit persons to whom the Software is
SandrineO 0:07281ea3b26b 9 * furnished to do so, subject to the following conditions:
SandrineO 0:07281ea3b26b 10 *
SandrineO 0:07281ea3b26b 11 * The above copyright notice and this permission notice shall be included in
SandrineO 0:07281ea3b26b 12 * all copies or substantial portions of the Software.
SandrineO 0:07281ea3b26b 13 *
SandrineO 0:07281ea3b26b 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
SandrineO 0:07281ea3b26b 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
SandrineO 0:07281ea3b26b 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
SandrineO 0:07281ea3b26b 17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
SandrineO 0:07281ea3b26b 18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
SandrineO 0:07281ea3b26b 19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SandrineO 0:07281ea3b26b 20 * SOFTWARE.
SandrineO 0:07281ea3b26b 21 */
SandrineO 0:07281ea3b26b 22 #include "rtos/Thread.h"
SandrineO 0:07281ea3b26b 23
SandrineO 0:07281ea3b26b 24 #include "mbed.h"
SandrineO 0:07281ea3b26b 25 #include "rtos/rtos_idle.h"
SandrineO 0:07281ea3b26b 26
SandrineO 0:07281ea3b26b 27 // rt_tid2ptcb is an internal function which we exposed to get TCB for thread id
SandrineO 0:07281ea3b26b 28 #undef NULL //Workaround for conflicting macros in rt_TypeDef.h and stdio.h
SandrineO 0:07281ea3b26b 29 #include "rt_TypeDef.h"
SandrineO 0:07281ea3b26b 30
SandrineO 0:07281ea3b26b 31 extern "C" P_TCB rt_tid2ptcb(osThreadId thread_id);
SandrineO 0:07281ea3b26b 32
SandrineO 0:07281ea3b26b 33
SandrineO 0:07281ea3b26b 34 static void (*terminate_hook)(osThreadId id) = 0;
SandrineO 0:07281ea3b26b 35 extern "C" void thread_terminate_hook(osThreadId id)
SandrineO 0:07281ea3b26b 36 {
SandrineO 0:07281ea3b26b 37 if (terminate_hook != (void (*)(osThreadId))NULL) {
SandrineO 0:07281ea3b26b 38 terminate_hook(id);
SandrineO 0:07281ea3b26b 39 }
SandrineO 0:07281ea3b26b 40 }
SandrineO 0:07281ea3b26b 41
SandrineO 0:07281ea3b26b 42 namespace rtos {
SandrineO 0:07281ea3b26b 43
SandrineO 0:07281ea3b26b 44 void Thread::constructor(osPriority priority,
SandrineO 0:07281ea3b26b 45 uint32_t stack_size, unsigned char *stack_pointer) {
SandrineO 0:07281ea3b26b 46 _tid = 0;
SandrineO 0:07281ea3b26b 47 _dynamic_stack = (stack_pointer == NULL);
SandrineO 0:07281ea3b26b 48
SandrineO 0:07281ea3b26b 49 #if defined(__MBED_CMSIS_RTOS_CA9) || defined(__MBED_CMSIS_RTOS_CM)
SandrineO 0:07281ea3b26b 50 _thread_def.tpriority = priority;
SandrineO 0:07281ea3b26b 51 _thread_def.stacksize = stack_size;
SandrineO 0:07281ea3b26b 52 _thread_def.stack_pointer = (uint32_t*)stack_pointer;
SandrineO 0:07281ea3b26b 53 #endif
SandrineO 0:07281ea3b26b 54 }
SandrineO 0:07281ea3b26b 55
SandrineO 0:07281ea3b26b 56 void Thread::constructor(Callback<void()> task,
SandrineO 0:07281ea3b26b 57 osPriority priority, uint32_t stack_size, unsigned char *stack_pointer) {
SandrineO 0:07281ea3b26b 58 constructor(priority, stack_size, stack_pointer);
SandrineO 0:07281ea3b26b 59
SandrineO 0:07281ea3b26b 60 switch (start(task)) {
SandrineO 0:07281ea3b26b 61 case osErrorResource:
SandrineO 0:07281ea3b26b 62 error("OS ran out of threads!\n");
SandrineO 0:07281ea3b26b 63 break;
SandrineO 0:07281ea3b26b 64 case osErrorParameter:
SandrineO 0:07281ea3b26b 65 error("Thread already running!\n");
SandrineO 0:07281ea3b26b 66 break;
SandrineO 0:07281ea3b26b 67 case osErrorNoMemory:
SandrineO 0:07281ea3b26b 68 error("Error allocating the stack memory\n");
SandrineO 0:07281ea3b26b 69 default:
SandrineO 0:07281ea3b26b 70 break;
SandrineO 0:07281ea3b26b 71 }
SandrineO 0:07281ea3b26b 72 }
SandrineO 0:07281ea3b26b 73
SandrineO 0:07281ea3b26b 74 osStatus Thread::start(Callback<void()> task) {
SandrineO 0:07281ea3b26b 75 _mutex.lock();
SandrineO 0:07281ea3b26b 76
SandrineO 0:07281ea3b26b 77 if (_tid != 0) {
SandrineO 0:07281ea3b26b 78 _mutex.unlock();
SandrineO 0:07281ea3b26b 79 return osErrorParameter;
SandrineO 0:07281ea3b26b 80 }
SandrineO 0:07281ea3b26b 81
SandrineO 0:07281ea3b26b 82 #if defined(__MBED_CMSIS_RTOS_CA9) || defined(__MBED_CMSIS_RTOS_CM)
SandrineO 0:07281ea3b26b 83 _thread_def.pthread = Thread::_thunk;
SandrineO 0:07281ea3b26b 84 if (_thread_def.stack_pointer == NULL) {
SandrineO 0:07281ea3b26b 85 _thread_def.stack_pointer = new uint32_t[_thread_def.stacksize/sizeof(uint32_t)];
SandrineO 0:07281ea3b26b 86 MBED_ASSERT(_thread_def.stack_pointer != NULL);
SandrineO 0:07281ea3b26b 87 }
SandrineO 0:07281ea3b26b 88
SandrineO 0:07281ea3b26b 89 //Fill the stack with a magic word for maximum usage checking
SandrineO 0:07281ea3b26b 90 for (uint32_t i = 0; i < (_thread_def.stacksize / sizeof(uint32_t)); i++) {
SandrineO 0:07281ea3b26b 91 _thread_def.stack_pointer[i] = 0xE25A2EA5;
SandrineO 0:07281ea3b26b 92 }
SandrineO 0:07281ea3b26b 93 #endif
SandrineO 0:07281ea3b26b 94 _task = task;
SandrineO 0:07281ea3b26b 95 _tid = osThreadCreate(&_thread_def, this);
SandrineO 0:07281ea3b26b 96 if (_tid == NULL) {
SandrineO 0:07281ea3b26b 97 if (_dynamic_stack) {
SandrineO 0:07281ea3b26b 98 delete[] (_thread_def.stack_pointer);
SandrineO 0:07281ea3b26b 99 _thread_def.stack_pointer = (uint32_t*)NULL;
SandrineO 0:07281ea3b26b 100 }
SandrineO 0:07281ea3b26b 101 _mutex.unlock();
SandrineO 0:07281ea3b26b 102 _join_sem.release();
SandrineO 0:07281ea3b26b 103 return osErrorResource;
SandrineO 0:07281ea3b26b 104 }
SandrineO 0:07281ea3b26b 105
SandrineO 0:07281ea3b26b 106 _mutex.unlock();
SandrineO 0:07281ea3b26b 107 return osOK;
SandrineO 0:07281ea3b26b 108 }
SandrineO 0:07281ea3b26b 109
SandrineO 0:07281ea3b26b 110 osStatus Thread::terminate() {
SandrineO 0:07281ea3b26b 111 osStatus ret;
SandrineO 0:07281ea3b26b 112 _mutex.lock();
SandrineO 0:07281ea3b26b 113
SandrineO 0:07281ea3b26b 114 // Set the Thread's tid to NULL and
SandrineO 0:07281ea3b26b 115 // release the semaphore before terminating
SandrineO 0:07281ea3b26b 116 // since this thread could be terminating itself
SandrineO 0:07281ea3b26b 117 osThreadId local_id = _tid;
SandrineO 0:07281ea3b26b 118 _join_sem.release();
SandrineO 0:07281ea3b26b 119 _tid = (osThreadId)NULL;
SandrineO 0:07281ea3b26b 120
SandrineO 0:07281ea3b26b 121 ret = osThreadTerminate(local_id);
SandrineO 0:07281ea3b26b 122
SandrineO 0:07281ea3b26b 123 _mutex.unlock();
SandrineO 0:07281ea3b26b 124 return ret;
SandrineO 0:07281ea3b26b 125 }
SandrineO 0:07281ea3b26b 126
SandrineO 0:07281ea3b26b 127 osStatus Thread::join() {
SandrineO 0:07281ea3b26b 128 int32_t ret = _join_sem.wait();
SandrineO 0:07281ea3b26b 129 if (ret < 0) {
SandrineO 0:07281ea3b26b 130 return osErrorOS;
SandrineO 0:07281ea3b26b 131 }
SandrineO 0:07281ea3b26b 132
SandrineO 0:07281ea3b26b 133 // The semaphore has been released so this thread is being
SandrineO 0:07281ea3b26b 134 // terminated or has been terminated. Once the mutex has
SandrineO 0:07281ea3b26b 135 // been locked it is ensured that the thread is deleted.
SandrineO 0:07281ea3b26b 136 _mutex.lock();
SandrineO 0:07281ea3b26b 137 MBED_ASSERT(NULL == _tid);
SandrineO 0:07281ea3b26b 138 _mutex.unlock();
SandrineO 0:07281ea3b26b 139
SandrineO 0:07281ea3b26b 140 // Release sem so any other threads joining this thread wake up
SandrineO 0:07281ea3b26b 141 _join_sem.release();
SandrineO 0:07281ea3b26b 142 return osOK;
SandrineO 0:07281ea3b26b 143 }
SandrineO 0:07281ea3b26b 144
SandrineO 0:07281ea3b26b 145 osStatus Thread::set_priority(osPriority priority) {
SandrineO 0:07281ea3b26b 146 osStatus ret;
SandrineO 0:07281ea3b26b 147 _mutex.lock();
SandrineO 0:07281ea3b26b 148
SandrineO 0:07281ea3b26b 149 ret = osThreadSetPriority(_tid, priority);
SandrineO 0:07281ea3b26b 150
SandrineO 0:07281ea3b26b 151 _mutex.unlock();
SandrineO 0:07281ea3b26b 152 return ret;
SandrineO 0:07281ea3b26b 153 }
SandrineO 0:07281ea3b26b 154
SandrineO 0:07281ea3b26b 155 osPriority Thread::get_priority() {
SandrineO 0:07281ea3b26b 156 osPriority ret;
SandrineO 0:07281ea3b26b 157 _mutex.lock();
SandrineO 0:07281ea3b26b 158
SandrineO 0:07281ea3b26b 159 ret = osThreadGetPriority(_tid);
SandrineO 0:07281ea3b26b 160
SandrineO 0:07281ea3b26b 161 _mutex.unlock();
SandrineO 0:07281ea3b26b 162 return ret;
SandrineO 0:07281ea3b26b 163 }
SandrineO 0:07281ea3b26b 164
SandrineO 0:07281ea3b26b 165 int32_t Thread::signal_set(int32_t signals) {
SandrineO 0:07281ea3b26b 166 // osSignalSet is thread safe as long as the underlying
SandrineO 0:07281ea3b26b 167 // thread does not get terminated or return from main
SandrineO 0:07281ea3b26b 168 return osSignalSet(_tid, signals);
SandrineO 0:07281ea3b26b 169 }
SandrineO 0:07281ea3b26b 170
SandrineO 0:07281ea3b26b 171 int32_t Thread::signal_clr(int32_t signals) {
SandrineO 0:07281ea3b26b 172 // osSignalClear is thread safe as long as the underlying
SandrineO 0:07281ea3b26b 173 // thread does not get terminated or return from main
SandrineO 0:07281ea3b26b 174 return osSignalClear(_tid, signals);
SandrineO 0:07281ea3b26b 175 }
SandrineO 0:07281ea3b26b 176
SandrineO 0:07281ea3b26b 177 Thread::State Thread::get_state() {
SandrineO 0:07281ea3b26b 178 #if !defined(__MBED_CMSIS_RTOS_CA9) && !defined(__MBED_CMSIS_RTOS_CM)
SandrineO 0:07281ea3b26b 179 #ifdef CMSIS_OS_RTX
SandrineO 0:07281ea3b26b 180 State status = Deleted;
SandrineO 0:07281ea3b26b 181 _mutex.lock();
SandrineO 0:07281ea3b26b 182
SandrineO 0:07281ea3b26b 183 if (_tid != NULL) {
SandrineO 0:07281ea3b26b 184 status = (State)_thread_def.tcb.state;
SandrineO 0:07281ea3b26b 185 }
SandrineO 0:07281ea3b26b 186
SandrineO 0:07281ea3b26b 187 _mutex.unlock();
SandrineO 0:07281ea3b26b 188 return status;
SandrineO 0:07281ea3b26b 189 #endif
SandrineO 0:07281ea3b26b 190 #else
SandrineO 0:07281ea3b26b 191 State status = Deleted;
SandrineO 0:07281ea3b26b 192 _mutex.lock();
SandrineO 0:07281ea3b26b 193
SandrineO 0:07281ea3b26b 194 if (_tid != NULL) {
SandrineO 0:07281ea3b26b 195 status = (State)osThreadGetState(_tid);
SandrineO 0:07281ea3b26b 196 }
SandrineO 0:07281ea3b26b 197
SandrineO 0:07281ea3b26b 198 _mutex.unlock();
SandrineO 0:07281ea3b26b 199 return status;
SandrineO 0:07281ea3b26b 200 #endif
SandrineO 0:07281ea3b26b 201 }
SandrineO 0:07281ea3b26b 202
SandrineO 0:07281ea3b26b 203 uint32_t Thread::stack_size() {
SandrineO 0:07281ea3b26b 204 #ifndef __MBED_CMSIS_RTOS_CA9
SandrineO 0:07281ea3b26b 205 #if defined(CMSIS_OS_RTX) && !defined(__MBED_CMSIS_RTOS_CM)
SandrineO 0:07281ea3b26b 206 uint32_t size = 0;
SandrineO 0:07281ea3b26b 207 _mutex.lock();
SandrineO 0:07281ea3b26b 208
SandrineO 0:07281ea3b26b 209 if (_tid != NULL) {
SandrineO 0:07281ea3b26b 210 size = _thread_def.tcb.priv_stack;
SandrineO 0:07281ea3b26b 211 }
SandrineO 0:07281ea3b26b 212
SandrineO 0:07281ea3b26b 213 _mutex.unlock();
SandrineO 0:07281ea3b26b 214 return size;
SandrineO 0:07281ea3b26b 215 #else
SandrineO 0:07281ea3b26b 216 uint32_t size = 0;
SandrineO 0:07281ea3b26b 217 _mutex.lock();
SandrineO 0:07281ea3b26b 218
SandrineO 0:07281ea3b26b 219 if (_tid != NULL) {
SandrineO 0:07281ea3b26b 220 P_TCB tcb = rt_tid2ptcb(_tid);
SandrineO 0:07281ea3b26b 221 size = tcb->priv_stack;
SandrineO 0:07281ea3b26b 222 }
SandrineO 0:07281ea3b26b 223
SandrineO 0:07281ea3b26b 224 _mutex.unlock();
SandrineO 0:07281ea3b26b 225 return size;
SandrineO 0:07281ea3b26b 226 #endif
SandrineO 0:07281ea3b26b 227 #else
SandrineO 0:07281ea3b26b 228 return 0;
SandrineO 0:07281ea3b26b 229 #endif
SandrineO 0:07281ea3b26b 230 }
SandrineO 0:07281ea3b26b 231
SandrineO 0:07281ea3b26b 232 uint32_t Thread::free_stack() {
SandrineO 0:07281ea3b26b 233 #ifndef __MBED_CMSIS_RTOS_CA9
SandrineO 0:07281ea3b26b 234 #if defined(CMSIS_OS_RTX) && !defined(__MBED_CMSIS_RTOS_CM)
SandrineO 0:07281ea3b26b 235 uint32_t size = 0;
SandrineO 0:07281ea3b26b 236 _mutex.lock();
SandrineO 0:07281ea3b26b 237
SandrineO 0:07281ea3b26b 238 if (_tid != NULL) {
SandrineO 0:07281ea3b26b 239 uint32_t bottom = (uint32_t)_thread_def.tcb.stack;
SandrineO 0:07281ea3b26b 240 size = _thread_def.tcb.tsk_stack - bottom;
SandrineO 0:07281ea3b26b 241 }
SandrineO 0:07281ea3b26b 242
SandrineO 0:07281ea3b26b 243 _mutex.unlock();
SandrineO 0:07281ea3b26b 244 return size;
SandrineO 0:07281ea3b26b 245 #else
SandrineO 0:07281ea3b26b 246 uint32_t size = 0;
SandrineO 0:07281ea3b26b 247 _mutex.lock();
SandrineO 0:07281ea3b26b 248
SandrineO 0:07281ea3b26b 249 if (_tid != NULL) {
SandrineO 0:07281ea3b26b 250 P_TCB tcb = rt_tid2ptcb(_tid);
SandrineO 0:07281ea3b26b 251 uint32_t bottom = (uint32_t)tcb->stack;
SandrineO 0:07281ea3b26b 252 size = tcb->tsk_stack - bottom;
SandrineO 0:07281ea3b26b 253 }
SandrineO 0:07281ea3b26b 254
SandrineO 0:07281ea3b26b 255 _mutex.unlock();
SandrineO 0:07281ea3b26b 256 return size;
SandrineO 0:07281ea3b26b 257 #endif
SandrineO 0:07281ea3b26b 258 #else
SandrineO 0:07281ea3b26b 259 return 0;
SandrineO 0:07281ea3b26b 260 #endif
SandrineO 0:07281ea3b26b 261 }
SandrineO 0:07281ea3b26b 262
SandrineO 0:07281ea3b26b 263 uint32_t Thread::used_stack() {
SandrineO 0:07281ea3b26b 264 #ifndef __MBED_CMSIS_RTOS_CA9
SandrineO 0:07281ea3b26b 265 #if defined(CMSIS_OS_RTX) && !defined(__MBED_CMSIS_RTOS_CM)
SandrineO 0:07281ea3b26b 266 uint32_t size = 0;
SandrineO 0:07281ea3b26b 267 _mutex.lock();
SandrineO 0:07281ea3b26b 268
SandrineO 0:07281ea3b26b 269 if (_tid != NULL) {
SandrineO 0:07281ea3b26b 270 uint32_t top = (uint32_t)_thread_def.tcb.stack + _thread_def.tcb.priv_stack;
SandrineO 0:07281ea3b26b 271 size = top - _thread_def.tcb.tsk_stack;
SandrineO 0:07281ea3b26b 272 }
SandrineO 0:07281ea3b26b 273
SandrineO 0:07281ea3b26b 274 _mutex.unlock();
SandrineO 0:07281ea3b26b 275 return size;
SandrineO 0:07281ea3b26b 276 #else
SandrineO 0:07281ea3b26b 277 uint32_t size = 0;
SandrineO 0:07281ea3b26b 278 _mutex.lock();
SandrineO 0:07281ea3b26b 279
SandrineO 0:07281ea3b26b 280 if (_tid != NULL) {
SandrineO 0:07281ea3b26b 281 P_TCB tcb = rt_tid2ptcb(_tid);
SandrineO 0:07281ea3b26b 282 uint32_t top = (uint32_t)tcb->stack + tcb->priv_stack;
SandrineO 0:07281ea3b26b 283 size = top - tcb->tsk_stack;
SandrineO 0:07281ea3b26b 284 }
SandrineO 0:07281ea3b26b 285
SandrineO 0:07281ea3b26b 286 _mutex.unlock();
SandrineO 0:07281ea3b26b 287 return size;
SandrineO 0:07281ea3b26b 288 #endif
SandrineO 0:07281ea3b26b 289 #else
SandrineO 0:07281ea3b26b 290 return 0;
SandrineO 0:07281ea3b26b 291 #endif
SandrineO 0:07281ea3b26b 292 }
SandrineO 0:07281ea3b26b 293
SandrineO 0:07281ea3b26b 294 uint32_t Thread::max_stack() {
SandrineO 0:07281ea3b26b 295 #ifndef __MBED_CMSIS_RTOS_CA9
SandrineO 0:07281ea3b26b 296 #if defined(CMSIS_OS_RTX) && !defined(__MBED_CMSIS_RTOS_CM)
SandrineO 0:07281ea3b26b 297 uint32_t size = 0;
SandrineO 0:07281ea3b26b 298 _mutex.lock();
SandrineO 0:07281ea3b26b 299
SandrineO 0:07281ea3b26b 300 if (_tid != NULL) {
SandrineO 0:07281ea3b26b 301 uint32_t high_mark = 0;
SandrineO 0:07281ea3b26b 302 while (_thread_def.tcb.stack[high_mark] == 0xE25A2EA5)
SandrineO 0:07281ea3b26b 303 high_mark++;
SandrineO 0:07281ea3b26b 304 size = _thread_def.tcb.priv_stack - (high_mark * 4);
SandrineO 0:07281ea3b26b 305 }
SandrineO 0:07281ea3b26b 306
SandrineO 0:07281ea3b26b 307 _mutex.unlock();
SandrineO 0:07281ea3b26b 308 return size;
SandrineO 0:07281ea3b26b 309 #else
SandrineO 0:07281ea3b26b 310 uint32_t size = 0;
SandrineO 0:07281ea3b26b 311 _mutex.lock();
SandrineO 0:07281ea3b26b 312
SandrineO 0:07281ea3b26b 313 if (_tid != NULL) {
SandrineO 0:07281ea3b26b 314 P_TCB tcb = rt_tid2ptcb(_tid);
SandrineO 0:07281ea3b26b 315 uint32_t high_mark = 0;
SandrineO 0:07281ea3b26b 316 while (tcb->stack[high_mark] == 0xE25A2EA5)
SandrineO 0:07281ea3b26b 317 high_mark++;
SandrineO 0:07281ea3b26b 318 size = tcb->priv_stack - (high_mark * 4);
SandrineO 0:07281ea3b26b 319 }
SandrineO 0:07281ea3b26b 320
SandrineO 0:07281ea3b26b 321 _mutex.unlock();
SandrineO 0:07281ea3b26b 322 return size;
SandrineO 0:07281ea3b26b 323 #endif
SandrineO 0:07281ea3b26b 324 #else
SandrineO 0:07281ea3b26b 325 return 0;
SandrineO 0:07281ea3b26b 326 #endif
SandrineO 0:07281ea3b26b 327 }
SandrineO 0:07281ea3b26b 328
SandrineO 0:07281ea3b26b 329 osEvent Thread::signal_wait(int32_t signals, uint32_t millisec) {
SandrineO 0:07281ea3b26b 330 return osSignalWait(signals, millisec);
SandrineO 0:07281ea3b26b 331 }
SandrineO 0:07281ea3b26b 332
SandrineO 0:07281ea3b26b 333 osStatus Thread::wait(uint32_t millisec) {
SandrineO 0:07281ea3b26b 334 return osDelay(millisec);
SandrineO 0:07281ea3b26b 335 }
SandrineO 0:07281ea3b26b 336
SandrineO 0:07281ea3b26b 337 osStatus Thread::yield() {
SandrineO 0:07281ea3b26b 338 return osThreadYield();
SandrineO 0:07281ea3b26b 339 }
SandrineO 0:07281ea3b26b 340
SandrineO 0:07281ea3b26b 341 osThreadId Thread::gettid() {
SandrineO 0:07281ea3b26b 342 return osThreadGetId();
SandrineO 0:07281ea3b26b 343 }
SandrineO 0:07281ea3b26b 344
SandrineO 0:07281ea3b26b 345 void Thread::attach_idle_hook(void (*fptr)(void)) {
SandrineO 0:07281ea3b26b 346 rtos_attach_idle_hook(fptr);
SandrineO 0:07281ea3b26b 347 }
SandrineO 0:07281ea3b26b 348
SandrineO 0:07281ea3b26b 349 void Thread::attach_terminate_hook(void (*fptr)(osThreadId id)) {
SandrineO 0:07281ea3b26b 350 terminate_hook = fptr;
SandrineO 0:07281ea3b26b 351 }
SandrineO 0:07281ea3b26b 352
SandrineO 0:07281ea3b26b 353 Thread::~Thread() {
SandrineO 0:07281ea3b26b 354 // terminate is thread safe
SandrineO 0:07281ea3b26b 355 terminate();
SandrineO 0:07281ea3b26b 356 #ifdef __MBED_CMSIS_RTOS_CM
SandrineO 0:07281ea3b26b 357 if (_dynamic_stack) {
SandrineO 0:07281ea3b26b 358 delete[] (_thread_def.stack_pointer);
SandrineO 0:07281ea3b26b 359 _thread_def.stack_pointer = (uint32_t*)NULL;
SandrineO 0:07281ea3b26b 360 }
SandrineO 0:07281ea3b26b 361 #endif
SandrineO 0:07281ea3b26b 362 }
SandrineO 0:07281ea3b26b 363
SandrineO 0:07281ea3b26b 364 void Thread::_thunk(const void * thread_ptr)
SandrineO 0:07281ea3b26b 365 {
SandrineO 0:07281ea3b26b 366 Thread *t = (Thread*)thread_ptr;
SandrineO 0:07281ea3b26b 367 t->_task();
SandrineO 0:07281ea3b26b 368 t->_mutex.lock();
SandrineO 0:07281ea3b26b 369 t->_tid = (osThreadId)NULL;
SandrineO 0:07281ea3b26b 370 t->_join_sem.release();
SandrineO 0:07281ea3b26b 371 // rtos will release the mutex automatically
SandrineO 0:07281ea3b26b 372 }
SandrineO 0:07281ea3b26b 373
SandrineO 0:07281ea3b26b 374 }