1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
|
/*
ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
2011,2012,2013 Giovanni Di Sirio.
This file is part of ChibiOS/RT.
ChibiOS/RT is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
ChibiOS/RT is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file chthreads.h
* @brief Threads module macros and structures.
*
* @addtogroup threads
* @{
*/
#ifndef _CHTHREADS_H_
#define _CHTHREADS_H_
/*===========================================================================*/
/* Module constants. */
/*===========================================================================*/
/**
* @name Thread states
* @{
*/
#define CH_STATE_READY 0 /**< @brief Waiting on the ready list. */
#define CH_STATE_CURRENT 1 /**< @brief Currently running. */
#define CH_STATE_WTSTART 2 /**< @brief Created but not started. */
#define CH_STATE_SUSPENDED 3 /**< @brief Created in suspended state. */
#define CH_STATE_QUEUED 4 /**< @brief Waiting on an I/O queue. */
#define CH_STATE_WTSEM 5 /**< @brief Waiting on a semaphore. */
#define CH_STATE_WTMTX 6 /**< @brief Waiting on a mutex. */
#define CH_STATE_WTCOND 7 /**< @brief Waiting on a condition
variable. */
#define CH_STATE_SLEEPING 8 /**< @brief Waiting in @p chThdSleep()
or @p chThdSleepUntil(). */
#define CH_STATE_WTEXIT 9 /**< @brief Waiting in @p chThdWait(). */
#define CH_STATE_WTOREVT 10 /**< @brief Waiting for an event. */
#define CH_STATE_WTANDEVT 11 /**< @brief Waiting for several events. */
#define CH_STATE_SNDMSGQ 12 /**< @brief Sending a message, in queue.*/
#define CH_STATE_SNDMSG 13 /**< @brief Sent a message, waiting
answer. */
#define CH_STATE_WTMSG 14 /**< @brief Waiting for a message. */
#define CH_STATE_FINAL 15 /**< @brief Thread terminated. */
/**
* @brief Thread states as array of strings.
* @details Each element in an array initialized with this macro can be
* indexed using the numeric thread state values.
*/
#define CH_STATE_NAMES \
"READY", "WTSTART", "CURRENT", "SUSPENDED", "QUEUED", "WTSEM", "WTMTX", \
"WTCOND", "SLEEPING", "WTEXIT", "WTOREVT", "WTANDEVT", "SNDMSGQ", \
"SNDMSG", "WTMSG", "FINAL"
/** @} */
/**
* @name Thread flags and attributes
* @{
*/
#define CH_FLAG_MODE_MASK 3 /**< @brief Thread memory mode mask. */
#define CH_FLAG_MODE_STATIC 0 /**< @brief Static thread. */
#define CH_FLAG_MODE_HEAP 1 /**< @brief Thread allocated from a
Memory Heap. */
#define CH_FLAG_MODE_MEMPOOL 2 /**< @brief Thread allocated from a
Memory Pool. */
#define CH_FLAG_TERMINATE 4 /**< @brief Termination requested flag. */
/** @} */
/*===========================================================================*/
/* Module pre-compile time settings. */
/*===========================================================================*/
/*===========================================================================*/
/* Derived constants and error checks. */
/*===========================================================================*/
/*===========================================================================*/
/* Module data structures and types. */
/*===========================================================================*/
/**
* @brief Type of a thread reference.
*/
typedef thread_t * thread_reference_t;
/**
* @brief Thread function.
*/
typedef msg_t (*tfunc_t)(void *);
/*===========================================================================*/
/* Module macros. */
/*===========================================================================*/
/**
* @name Working Areas and Alignment
*/
/**
* @brief Enforces a correct alignment for a stack area size value.
*
* @param[in] n the stack size to be aligned to the next stack
* alignment boundary
* @return The aligned stack size.
*
* @api
*/
#define THD_ALIGN_STACK_SIZE(n) \
((((n) - 1) | (sizeof(stkalign_t) - 1)) + 1)
/**
* @brief Calculates the total Working Area size.
*
* @param[in] n the stack size to be assigned to the thread
* @return The total used memory in bytes.
*
* @api
*/
#define THD_WORKING_AREA_SIZE(n) \
THD_ALIGN_STACK_SIZE(sizeof(thread_t) + PORT_WA_SIZE(n))
/**
* @brief Static working area allocation.
* @details This macro is used to allocate a static thread working area
* aligned as both position and size.
*
* @param[in] s the name to be assigned to the stack array
* @param[in] n the stack size to be assigned to the thread
*
* @api
*/
#define THD_WORKING_AREA(s, n) \
stkalign_t s[THD_WORKING_AREA_SIZE(n) / sizeof(stkalign_t)]
/** @} */
/**
* @name Threads abstraction macros
*/
/**
* @brief Thread declaration macro.
* @note Thread declarations should be performed using this macro because
* the port layer could define optimizations for thread functions.
*/
#define THD_FUNCTION(tname, arg) PORT_THD_FUNCTION(tname, arg)
/** @} */
/**
* @name Macro Functions
* @{
*/
/**
* @brief Delays the invoking thread for the specified number of seconds.
* @note The specified time is rounded up to a value allowed by the real
* system tick clock.
* @note The maximum specifiable value is implementation dependent.
*
* @param[in] sec time in seconds, must be different from zero
*
* @api
*/
#define chThdSleepSeconds(sec) chThdSleep(S2ST(sec))
/**
* @brief Delays the invoking thread for the specified number of
* milliseconds.
* @note The specified time is rounded up to a value allowed by the real
* system tick clock.
* @note The maximum specifiable value is implementation dependent.
*
* @param[in] msec time in milliseconds, must be different from zero
*
* @api
*/
#define chThdSleepMilliseconds(msec) chThdSleep(MS2ST(msec))
/**
* @brief Delays the invoking thread for the specified number of
* microseconds.
* @note The specified time is rounded up to a value allowed by the real
* system tick clock.
* @note The maximum specifiable value is implementation dependent.
*
* @param[in] usec time in microseconds, must be different from zero
*
* @api
*/
#define chThdSleepMicroseconds(usec) chThdSleep(US2ST(usec))
/** @} */
/*===========================================================================*/
/* External declarations. */
/*===========================================================================*/
#ifdef __cplusplus
extern "C" {
#endif
thread_t *_thread_init(thread_t *tp, tprio_t prio);
#if CH_DBG_FILL_THREADS
void _thread_memfill(uint8_t *startp, uint8_t *endp, uint8_t v);
#endif
thread_t *chThdCreateI(void *wsp, size_t size,
tprio_t prio, tfunc_t pf, void *arg);
thread_t *chThdCreateStatic(void *wsp, size_t size,
tprio_t prio, tfunc_t pf, void *arg);
thread_t *chThdStart(thread_t *tp);
tprio_t chThdSetPriority(tprio_t newprio);
msg_t chThreadSuspendS(thread_reference_t *trp);
msg_t chThreadSuspendTimeoutS(thread_reference_t *trp, systime_t timeout);
void chThreadResumeI(thread_reference_t *trp, msg_t msg);
void chThreadResumeS(thread_reference_t *trp, msg_t msg);
void chThreadResume(thread_reference_t *trp, msg_t msg);
void chThdTerminate(thread_t *tp);
void chThdSleep(systime_t time);
void chThdSleepUntil(systime_t time);
void chThdYield(void);
void chThdExit(msg_t msg);
void chThdExitS(msg_t msg);
#if CH_CFG_USE_WAITEXIT
msg_t chThdWait(thread_t *tp);
#endif
#ifdef __cplusplus
}
#endif
/*===========================================================================*/
/* Module inline functions. */
/*===========================================================================*/
/**
* @brief Returns a pointer to the current @p thread_t.
*
* @xclass
*/
static inline thread_t *chThdGetSelfX(void) {
return ch.rlist.r_current;
}
/**
* @brief Returns the current thread priority.
* @note Can be invoked in any context.
*
* @xclass
*/
static inline tprio_t chThdGetPriorityX(void) {
return chThdGetSelfX()->p_prio;
}
/**
* @brief Returns the number of ticks consumed by the specified thread.
* @note This function is only available when the
* @p CH_DBG_THREADS_PROFILING configuration option is enabled.
*
* @param[in] tp pointer to the thread
*
* @xclass
*/
#if CH_DBG_THREADS_PROFILING || defined(__DOXYGEN__)
static inline systime_t chThdGetTicksX(thread_t *tp) {
return tp->p_time;
}
#endif
/**
* @brief Verifies if the specified thread is in the @p CH_STATE_FINAL state.
*
* @param[in] tp pointer to the thread
* @retval true thread terminated.
* @retval false thread not terminated.
*
* @xclass
*/
static inline bool chThdTerminatedX(thread_t *tp) {
return (bool)(tp->p_state == CH_STATE_FINAL);
}
/**
* @brief Verifies if the current thread has a termination request pending.
*
* @retval true termination request pending.
* @retval false termination request not pending.
*
* @xclass
*/
static inline bool chThdShouldTerminateX(void) {
return (bool)(chThdGetSelfX()->p_flags & CH_FLAG_TERMINATE);
}
/**
* @brief Resumes a thread created with @p chThdCreateI().
*
* @param[in] tp pointer to the thread
*
* @iclass
*/
static inline thread_t *chThdStartI(thread_t *tp) {
chDbgAssert(tp->p_state == CH_STATE_WTSTART, "wrong state");
return chSchReadyI(tp);
}
/**
* @brief Suspends the invoking thread for the specified time.
*
* @param[in] time the delay in system ticks, the special values are
* handled as follow:
* - @a TIME_INFINITE the thread enters an infinite sleep
* state.
* - @a TIME_IMMEDIATE this value is not allowed.
* .
*
* @sclass
*/
static inline void chThdSleepS(systime_t time) {
chDbgCheck(time != TIME_IMMEDIATE);
chSchGoSleepTimeoutS(CH_STATE_SLEEPING, time);
}
#endif /* _CHTHREADS_H_ */
/** @} */
|
