Daoyu_Sofiane Yao_Belouka / mbed-rtos

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependents:   Mecatro_Gyro_Programme_Codeur_HC06

rtos/Thread.cpp@0:a8ed743bc1e1, 2021-04-16 (annotated)

Committer:
daoyu_sofiane
Date:
Fri Apr 16 09:25:33 2021 +0000
Revision:
0:a8ed743bc1e1
Projet Gyropode

Who changed what in which revision?

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