/*
ChibiOS/RT - Copyright (C) 2006-2007 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 .
*/
/**
* @page article_create_thread How to create a thread
* At the system startup there are already two active threads:
* - Idle thread. This thread has the lowest priority in the system so
* it runs only when the other threads in the system are sleeping. This
* threads usually switches the system in a low power mode and does nothing
* else.
* - Main thread. This thread executes your @p main() function at
* startup. The main thread is created at the @p NORMALPRIO level but it
* can change its own priority if required. It is from the main thread
* that the other threads are usually created.
* .
* There are two kind of threads in ChibiOS/RT:
* - Static Threads. This kind of threads are statically allocated in
* memory. The memory used by the thread cannot reused except for restarting
* the threads.
* - Dynamic Threads. Threads created by allocating memory from a memory
* heap or a memory pool.
* .
* Creating a static thread
* In order to create a static thread a working area must be declared using
* the macro @p WORKING_AREA as shown:
* @code
static WORKING_AREA(myThreadWorkingArea, 128);
* @endcode
* This macro reserves 128 bytes of stack for the thread and space for all
* the required thread related structures. The total size and the alignment
* problems are handled inside the macro, you only need to specify the pure
* stack size.
* A thread can be started by invoking @p chThdCreateStatic() as shown in this
* example:
* @code
Thread *tp = chThdCreateStatic(myThreadWorkingArea,
sizeof(myThreadWorkingArea),
NORMALPRIO, /* Initial priority. */
myThread, /* Thread function. */
NULL); /* Thread parameter. */
* @endcode
* Tre variable tp receives the pointer to the thread object, it is taken
* by other APIs as parameter.
* Now a complete example:
* @code
/*
* * My simple application.
*/
#include
/*
* * Working area for the LED flashing thread.
*/
static WORKING_AREA(myThreadWorkingArea, 128);
/*
* * LED flashing thread.
*/
static msg_t myThread(void *arg) {
while (TRUE) {
LED_ON();
chThdSleepMilliseconds(500);
LED_OFF();
chThdSleepMilliseconds(500);
}
}
int main(int argc, char *argv[]) {
/* Starting the flashing LEDs thread.*/
(void)chThdCreateStatic(myThreadWorkingArea, sizeof(myThreadWorkingArea),
NORMALPRIO, myThread, NULL);
.
.
.
}
* @endcode
* Note that is memory allocated to myThread() is statically defined and cannot
* be reused. Static threads are ideal for safety applications because there is
* no risk of a memory allocation failure because progressive heap
* fragmentation.
*
* Creating a dynamic thread using the heap allocator
* In order to create a thread from a memory heap is very easy:
* @code
Thread *tp = chThdCreateFromHeap(NULL, /* NULL = Default heap. */
128, /* Stack size. */
NORMALPRIO, /* Initial priority. */
myThread, /* Thread function. */
NULL); /* Thread parameter. */
* @endcode
* The memory is allocated from the spawned heap and the thread is started.
* Note that the memory is not freed when the thread terminates but when the
* thread final status (its return value) is collected by the spawning thread.
* As example:
* @code
static msg_t myThread(void *arg) {
unsigned i = 10;
while (i > 0) {
LED_ON();
chThdSleepMilliseconds(500);
LED_OFF();
chThdSleepMilliseconds(500);
i--;
}
return (msg_t)i;
}
int main(int argc, char *argv[]) {
Thread *tp = chThdCreateFromHeap(NULL, 128, NORMALPRIO+1, myThread, NULL);
if (tp == NULL)
chSysHalt(); /* Memory exausted. */
/* The main thread continues its normal execution.*/
.
.
/*
* * Now waits for the spawned thread to terminate (if it has not terminated
* * already) then gets the thread exit message (msg) and returns the
* * terminated thread memory to the heap (default system heap in this
* * example).
*/
msg_t msg = chThdWait(tp);
.
.
}
* @endcode
*
* Creating a dynamic thread using the heap allocator
* A pool is a collection of equally sized memory blocks, creating a thread from
* a memry pool is very similar to the previous example but the memory of
* terminated threads is returned to the memory pool rather than to a heap:
* @code
static msg_t myThread(void *arg) {
unsigned i = 10;
while (i > 0) {
LED_ON();
chThdSleepMilliseconds(500);
LED_OFF();
chThdSleepMilliseconds(500);
i--;
}
return (msg_t)i;
}
int main(int argc, char *argv[]) {
Thread *tp = chThdCreateFromMemoryPool(myPool, NORMALPRIO+1, myThread, NULL);
if (tp == NULL)
chSysHalt(); /* Pool empty. */
/* The main thread continues its normal execution.*/
.
.
/*
* * Now waits for the spawned thread to terminate (if it has not terminated
* * already) then gets the thread exit message (msg) and returns the
* * terminated thread memory to the original memory pool.
*/
msg_t msg = chThdWait(tp);
.
.
}
* @endcode
*/
a id='n105' href='#n105'>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
|