StaticSemaphore_t *pxMutexBuffer );
Creates a mutex, and returns
a handle by which the created mutex can be referenced. Mutexes cannot be used
in interrupt service routines.
must be set to 1 in FreeRTOSConfig.h for this RTOS API function to be available.
Each mutex require a small amount of RAM that is used to hold the
mutex's state. If a mutex is created using xSemaphoreCreateMutex()
then the required RAM is automatically allocated from the FreeRTOS heap.
If a mutex is created using xSemaphoreCreateMutexStatic()
then the RAM is provided by the application writer, which requires an additional
parameter, but allows the RAM to be statically allocated at compile
time. See the Static Vs
Dynamic allocation page for more information.
Mutexes are taken using xSemaphoreTake(), and given
xSemaphoreTakeRecursive() and xSemaphoreGiveRecursive() can only be used on
mutexes created using xSemaphoreCreateResursiveMutex().
Mutexes and binary semaphores are very similar but
have some subtle differences: Mutexes include a priority inheritance mechanism,
binary semaphores do not. This makes binary semaphores the better choice for
implementing synchronisation (between tasks or between tasks and an interrupt),
and mutexes the better choice for implementing simple mutual exclusion.
The priority of a task that 'takes' a mutex will be temporarily raised if another
task of higher priority attempts to obtain the same mutex. The task that owns
the mutex 'inherits' the priority of the task attempting to 'take' the same
mutex. This means the mutex must always be 'given' back - otherwise the higher
priority task will never be able to obtain the mutex, and the lower priority
task will never 'disinherit' the priority.
An example of a mutex being used to implement mutual
exclusion is provided on the xSemaphoreTake() documentation page.
A binary semaphore need not be given back once obtained, so task synchronisation
can be implemented by one task/interrupt continuously 'giving' the semaphore
while another continuously 'takes' the semaphore. This is demonstrated by
the sample code on the xSemaphoreGiveFromISR() documentation page.
Note that the same functionality can be achieved in a more efficient way using
a direct to task notification.
Handles to both mutexes and binary semaphores are assigned to variables of type
SemaphoreHandle_t, and can be used in any task level (as opposed to interrupt
safe) API function that takes a parameter of that type.
Must point to a variable of type StaticSemaphore_t, which
will be used to hold the mutex type semaphore's state.
If the mutex type semaphore was created successfully then a handle to
the created mutex is returned. If the mutex was not
created because pxMutexBuffer was NULL then NULL is returned.
SemaphoreHandle_t xSemaphore = NULL;
void vATask( void * pvParameters )
/* Create a mutex semaphore without using any dynamic memory
allocation. The mutex's data structures will be saved into
the xMutexBuffer variable. */
xSemaphore = xSemaphoreCreateMutexStatic( &xMutexBuffer );
/* The pxMutexBuffer was not NULL, so it is expected that the
handle will not be NULL. */
configASSERT( xSemaphore );
/* Rest of the task code goes here. */
Copyright (C) 2004-2010 Richard Barry. Copyright (C) 2010-2016 Real Time Engineers Ltd.
Any and all data, files, source code, html content and documentation included in the FreeRTOSTM distribution or available on this site are the exclusive property of Real Time Engineers Ltd..
See the files license.txt (included in the distribution) and this copyright notice for more information. FreeRTOSTM and FreeRTOS.orgTM are trade marks of Real Time Engineers Ltd.