diff --git a/FreeRTOS/Demo/CORTEX_STM32L152_Discovery_IAR/STM32L_low_power_tick_management.c b/FreeRTOS/Demo/CORTEX_STM32L152_Discovery_IAR/STM32L_low_power_tick_management.c
index d305dc5ec3..ada55b89f3 100644
--- a/FreeRTOS/Demo/CORTEX_STM32L152_Discovery_IAR/STM32L_low_power_tick_management.c
+++ b/FreeRTOS/Demo/CORTEX_STM32L152_Discovery_IAR/STM32L_low_power_tick_management.c
@@ -278,6 +278,8 @@ const TickType_t xRegulatorOffIdleTime = 30;
/* Re-enable interrupts - see comments above the cpsid instruction()
above. */
__asm volatile ( "cpsie i" );
+ __asm volatile ( "dsb" );
+ __asm volatile ( "isb" );
}
else
{
diff --git a/FreeRTOS/Source/event_groups.c b/FreeRTOS/Source/event_groups.c
index 4d0ba5b8ad..246e28651e 100644
--- a/FreeRTOS/Source/event_groups.c
+++ b/FreeRTOS/Source/event_groups.c
@@ -151,14 +151,18 @@ EventGroup_t *pxEventBits;
pxEventBits->uxEventBits = 0;
vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );
- if( pxStaticEventGroup == NULL )
+ #if( configSUPPORT_STATIC_ALLOCATION == 1 )
{
- pxEventBits->ucStaticallyAllocated = pdFALSE;
- }
- else
- {
- pxEventBits->ucStaticallyAllocated = pdTRUE;
+ if( pxStaticEventGroup == NULL )
+ {
+ pxEventBits->ucStaticallyAllocated = pdFALSE;
+ }
+ else
+ {
+ pxEventBits->ucStaticallyAllocated = pdTRUE;
+ }
}
+ #endif /* configSUPPORT_STATIC_ALLOCATION */
traceEVENT_GROUP_CREATE( pxEventBits );
}
@@ -605,10 +609,18 @@ const List_t *pxTasksWaitingForBits = &( pxEventBits->xTasksWaitingForBits );
}
/* Only free the memory if it was allocated dynamically. */
- if( pxEventBits->ucStaticallyAllocated == pdFALSE )
+ #if( configSUPPORT_STATIC_ALLOCATION == 1 )
+ {
+ if( pxEventBits->ucStaticallyAllocated == pdFALSE )
+ {
+ vPortFree( pxEventBits );
+ }
+ }
+ #else
{
vPortFree( pxEventBits );
}
+ #endif /* configSUPPORT_STATIC_ALLOCATION */
}
( void ) xTaskResumeAll();
}
diff --git a/FreeRTOS/Source/include/queue.h b/FreeRTOS/Source/include/queue.h
index 128a945401..dfdc7e60eb 100644
--- a/FreeRTOS/Source/include/queue.h
+++ b/FreeRTOS/Source/include/queue.h
@@ -123,8 +123,19 @@ typedef void * QueueSetMemberHandle_t;
);
*
*
- * Creates a new queue instance. This allocates the storage required by the
- * new queue and returns a handle for the queue.
+ * Creates a new queue instance, and returns a handle by which the new queue
+ * can be referenced.
+ *
+ * Internally, within the FreeRTOS implementation, queue's use two blocks of
+ * memory. The first block is used to hold the queue's data structures. The
+ * second block is used to hold items placed into the queue. If a queue is
+ * created using xQueueCreate() then both blocks of memory are automatically
+ * dynamically allocated inside the xQueueCreate() function. (see
+ * http://www.freertos.org/a00111.html). If a queue is created using
+ * xQueueCreateStatic() then the application writer can instead optionally
+ * provide the memory that will get used by the queue. xQueueCreateStatic()
+ * therefore allows a queue to be created without using any dynamic memory
+ * allocation.
*
* @param uxQueueLength The maximum number of items that the queue can contain.
*
@@ -172,8 +183,95 @@ typedef void * QueueSetMemberHandle_t;
*/
#define xQueueCreate( uxQueueLength, uxItemSize ) xQueueGenericCreate( uxQueueLength, uxItemSize, NULL, NULL, queueQUEUE_TYPE_BASE )
+/**
+ * queue. h
+ *
+ QueueHandle_t xQueueCreateStatic(
+ UBaseType_t uxQueueLength,
+ UBaseType_t uxItemSize,
+ uint8_t *pucQueueStorageBuffer,
+ StaticQueue_t *pxQueueBuffer
+ );
+ *
+ *
+ * Creates a new queue instance, and returns a handle by which the new queue
+ * can be referenced.
+ *
+ * Internally, within the FreeRTOS implementation, queue's use two blocks of
+ * memory. The first block is used to hold the queue's data structures. The
+ * second block is used to hold items placed into the queue. If a queue is
+ * created using xQueueCreate() then both blocks of memory are automatically
+ * dynamically allocated inside the xQueueCreate() function. (see
+ * http://www.freertos.org/a00111.html). If a queue is created using
+ * xQueueCreateStatic() then the application writer can instead optionally
+ * provide the memory that will get used by the queue. xQueueCreateStatic()
+ * therefore allows a queue to be created without using any dynamic memory
+ * allocation.
+ *
+ * @param uxQueueLength The maximum number of items that the queue can contain.
+ *
+ * @param uxItemSize The number of bytes each item in the queue will require.
+ * Items are queued by copy, not by reference, so this is the number of bytes
+ * that will be copied for each posted item. Each item on the queue must be
+ * the same size.
+ *
+ * @param pucQueueStorageBuffer If pucQueueStorageBuffer is NULL then the memory
+ * used to hold items stored in the queue will be allocated dynamically, just as
+ * when a queue is created using xQueueCreate(). If pxQueueStorageBuffer is not
+ * NULL then it must point to a uint8_t array that is at least large enough to
+ * hold the maximum number of items that can be in the queue at any one time -
+ * which is ( uxQueueLength * uxItemsSize ) bytes.
+ *
+ * @param pxQueueBuffer If pxQueueBuffer is NULL then the memory required to
+ * hold the queue's data structures will be allocated dynamically, just as when
+ * a queue is created using xQueueCreate(). If pxQueueBuffer is not NULL then
+ * it must point to a variable of type StaticQueue_t, which will then be used to
+ * hold the queue's data structure, removing the need for the memory to be
+ * allocated dynamically.
+ *
+ * @return If the queue is successfully create then a handle to the newly
+ * created queue is returned. If the queue cannot be created then 0 is
+ * returned.
+ *
+ * Example usage:
+
+ struct AMessage
+ {
+ char ucMessageID;
+ char ucData[ 20 ];
+ };
+
+ #define QUEUE_LENGTH 10
+ #define ITEM_SIZE sizeof( uint32_t )
+
+ // xQueueBuffer will hold the queue structure.
+ StaticQueue_t xQueueBuffer;
+
+ // ucQueueStorage will hold the items posted to the queue. Must be at least
+ // [(queue length) * ( queue item size)] bytes long.
+ uint8_t ucQueueStorage[ QUEUE_LENGTH * ITEM_SIZE ];
+
+ void vATask( void *pvParameters )
+ {
+ QueueHandle_t xQueue1;
+
+ // Create a queue capable of containing 10 uint32_t values.
+ xQueue1 = xQueueCreate( QUEUE_LENGTH, // The number of items the queue can hold.
+ ITEM_SIZE // The size of each item in the queue
+ &( ucQueueStorage[ 0 ] ), // The buffer that will hold the items in the queue.
+ &xQueueBuffer ); // The buffer that will hold the queue structure.
+
+ // The queue is guaranteed to be created successfully as no dynamic memory
+ // allocation was used. Therefore xQueue1 is now a handle to a valid queue.
+
+ // ... Rest of task code.
+ }
+
+ * \defgroup xQueueCreate xQueueCreate
+ * \ingroup QueueManagement
+ */
#if( configSUPPORT_STATIC_ALLOCATION == 1 )
- #define xQueueCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue ) xQueueGenericCreate( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, queueQUEUE_TYPE_BASE )
+ #define xQueueCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxQueueBuffer ) xQueueGenericCreate( ( uxQueueLength ), ( uxItemSize ), ( pucQueueStorage ), ( pxQueueBuffer ), ( queueQUEUE_TYPE_BASE ) )
#endif /* configSUPPORT_STATIC_ALLOCATION */
/**
diff --git a/FreeRTOS/Source/include/task.h b/FreeRTOS/Source/include/task.h
index 235f65071a..223446b62d 100644
--- a/FreeRTOS/Source/include/task.h
+++ b/FreeRTOS/Source/include/task.h
@@ -283,6 +283,20 @@ is used in assert() statements. */
*
* Create a new task and add it to the list of tasks that are ready to run.
*
+ * Internally, within the FreeRTOS implementation, tasks's use two blocks of
+ * memory. The first block is used to hold the tasks's data structures. The
+ * second block is used by the task as its stack. If a task is created using
+ * xTaskCreate() then both blocks of memory are automatically dynamically
+ * allocated inside the xTaskCreate() function. (see
+ * http://www.freertos.org/a00111.html). If a task is created using
+ * xTaskCreateStatic() then the application writer can instead optionally
+ * provide the memory that will get used by the task. xTaskCreateStatic()
+ * therefore allows a task to be created without using any dynamic memory
+ * allocation.
+ *
+ * See xTaskCreateStatic() for a version that does not use any dynamic memory
+ * allocation.
+ *
* xTaskCreate() can only be used to create a task that has unrestricted
* access to the entire microcontroller memory map. Systems that include MPU
* support can alternatively create an MPU constrained task using
@@ -362,16 +376,21 @@ is used in assert() statements. */
UBaseType_t uxPriority,
TaskHandle_t *pvCreatedTask,
StackType_t *pxStackBuffer,
- StaticTask_t *pxTCBBuffer
+ StaticTask_t *pxTaskBuffer
);
*
* Create a new task and add it to the list of tasks that are ready to run.
- * If a task is created using xTaskCreate() then the stack and task control
- * block (TCB) used by the task are allocated dynamically. If a task is created
- * using xTaskCreateStatic() then the application writer can optionally provide
- * the buffers that will hold the task stack and TCB respectively.
- * xTaskCreateStatic() therefore allows tasks to be created without any dynamic
- * memory allocation.
+ *
+ * Internally, within the FreeRTOS implementation, tasks's use two blocks of
+ * memory. The first block is used to hold the tasks's data structures. The
+ * second block is used by the task as its stack. If a task is created using
+ * xTaskCreate() then both blocks of memory are automatically dynamically
+ * allocated inside the xTaskCreate() function. (see
+ * http://www.freertos.org/a00111.html). If a task is created using
+ * xTaskCreateStatic() then the application writer can instead optionally
+ * provide the memory that will get used by the task. xTaskCreateStatic()
+ * therefore allows a task to be created without using any dynamic memory
+ * allocation.
*
* @param pvTaskCode Pointer to the task entry function. Tasks
* must be implemented to never return (i.e. continuous loop).
@@ -395,15 +414,17 @@ is used in assert() statements. */
*
* @param pxStackBuffer If pxStackBuffer is NULL then the stack used by the
* task will be allocated dynamically, just as if the task was created using
- * xTaskCreate(). if pxStackBuffer is not NULL then it must point to a
+ * xTaskCreate(). If pxStackBuffer is not NULL then it must point to a
* StackType_t array that has at least usStackDepth indexes - the array will
- * then be used as the task's stack.
+ * then be used as the task's stack, removing the need for the stack to be
+ * allocated dynamically.
*
- * @param pxTCBBuffer If pxTCBBuffer is NULL then the TCB (which is the
- * structures used internally within FreeRTOS to hold information on the task)
- * will be allocated dynamically, just as when xTaskCreate() is used. If
- * pxTCBBuffer is not NULL then it must point to a variable of type StaticTask_t,
- * which will then be used as the TCB of the task being created.
+ * @param pxTaskBuffer If pxTaskBuffer is NULL then the memory used to hold the
+ * task's data structures will be allocated dynamically, just as when a task is
+ * created using xTaskCreate(). If pxTaskBuffer is not NULL then it must point
+ * to a variable of type StaticTask_t, which will then be used to hold the
+ * task's data structures, removing the need for the memory to be allocated
+ * dynamically.
*
* @return pdPASS if the task was successfully created and added to a ready
* list, otherwise an error code defined in the file projdefs.h
@@ -418,7 +439,7 @@ is used in assert() statements. */
#define STACK_SIZE 200
// Structure that will hold the TCB of the task being created.
- StaticTask_t xTCB;
+ StaticTask_t xTaskBuffer;
// Buffer that the task being created will use as its stack.
StackType_t xStack[ STACK_SIZE ];
@@ -446,14 +467,14 @@ is used in assert() statements. */
tskIDLE_PRIORITY, // As per xTaskCreate() parameter.
&xHandle, // As per xTaskCreate() parameter.
xStack, // Pointer to the buffer that the task being created will use as its stack.
- &xTCB ); // Pointer to a structure in which the TCB of the task being created will be stored.
+ &xTaskBuffer ); // Pointer to a StaticTask_t structure for use as the memory require by the task.
}
* \defgroup xTaskCreateStatic xTaskCreateStatic
* \ingroup Tasks
*/
#if( configSUPPORT_STATIC_ALLOCATION == 1 )
- #define xTaskCreateStatic( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask, puxStackBuffer, pxDummyTCB ) xTaskGenericCreate( ( pvTaskCode ), ( pcName ), ( usStackDepth ), ( pvParameters ), ( uxPriority ), ( pxCreatedTask ), ( puxStackBuffer ), ( pxDummyTCB ), ( NULL ) )
+ #define xTaskCreateStatic( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask, puxStackBuffer, pxTaskBuffer ) xTaskGenericCreate( ( pvTaskCode ), ( pcName ), ( usStackDepth ), ( pvParameters ), ( uxPriority ), ( pxCreatedTask ), ( puxStackBuffer ), ( pxTaskBuffer ), ( NULL ) )
#endif /* configSUPPORT_STATIC_ALLOCATION */
/**
@@ -2095,7 +2116,7 @@ BaseType_t xTaskPriorityDisinherit( TaskHandle_t const pxMutexHolder ) PRIVILEGE
* Generic version of the task creation function which is in turn called by the
* xTaskCreate() and xTaskCreateRestricted() macros.
*/
-BaseType_t xTaskGenericCreate( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask, StackType_t * const puxStackBuffer, StaticTask_t * const pxTCBBuffer, const MemoryRegion_t * const xRegions ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
+BaseType_t xTaskGenericCreate( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask, StackType_t * const puxStackBuffer, StaticTask_t * const pxTaskBuffer, const MemoryRegion_t * const xRegions ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
/*
* Get the uxTCBNumber assigned to the task referenced by the xTask parameter.
diff --git a/FreeRTOS/Source/include/timers.h b/FreeRTOS/Source/include/timers.h
index c4582d134c..e5e5c137c0 100644
--- a/FreeRTOS/Source/include/timers.h
+++ b/FreeRTOS/Source/include/timers.h
@@ -135,9 +135,18 @@ typedef void (*PendedFunction_t)( void *, uint32_t );
* void * pvTimerID,
* TimerCallbackFunction_t pxCallbackFunction );
*
- * Creates a new software timer instance. This allocates the storage required
- * by the new timer, initialises the new timers internal state, and returns a
- * handle by which the new timer can be referenced.
+ * Creates a new software timer instance, and returns a handle by which the
+ * created software timer can be referenced.
+ *
+ * Internally, within the FreeRTOS implementation, software timer's use a block
+ * of memory, in which the timer data structure is stored. If a software timer
+ * is created using xTimerCreate() then the required memory is automatically
+ * dynamically allocated inside the xTimerCreate() function. (see
+ * http://www.freertos.org/a00111.html). If a software timer is created using
+ * xTimerCreateStatic() then the application writer can instead optionally
+ * provide the memory that will get used by the software timer.
+ * xTimerCreateStatic() therefore allows a software to be created without using
+ * any dynamic memory allocation.
*
* Timers are created in the dormant state. The xTimerStart(), xTimerReset(),
* xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and
@@ -259,8 +268,136 @@ typedef void (*PendedFunction_t)( void *, uint32_t );
*/
#define xTimerCreate( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction ) xTimerGenericCreate( ( pcTimerName ), ( xTimerPeriodInTicks ), ( uxAutoReload ), ( pvTimerID ), ( pxCallbackFunction ), NULL )
+/**
+ * TimerHandle_t xTimerCreateStatic(const char * const pcTimerName,
+ * TickType_t xTimerPeriodInTicks,
+ * UBaseType_t uxAutoReload,
+ * void * pvTimerID,
+ * TimerCallbackFunction_t pxCallbackFunction,
+ * StaticTimer_t *pxTimerBuffer );
+ *
+ * Creates a new software timer instance, and returns a handle by which the
+ * created software timer can be referenced.
+ *
+ * Internally, within the FreeRTOS implementation, software timer's use a block
+ * of memory, in which the timer data structure is stored. If a software timer
+ * is created using xTimerCreate() then the required memory is automatically
+ * dynamically allocated inside the xTimerCreate() function. (see
+ * http://www.freertos.org/a00111.html). If a software timer is created using
+ * xTimerCreateStatic() then the application writer can instead optionally
+ * provide the memory that will get used by the software timer.
+ * xTimerCreateStatic() therefore allows a software to be created without using
+ * any dynamic memory allocation.
+ *
+ * Timers are created in the dormant state. The xTimerStart(), xTimerReset(),
+ * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and
+ * xTimerChangePeriodFromISR() API functions can all be used to transition a
+ * timer into the active state.
+ *
+ * @param pcTimerName A text name that is assigned to the timer. This is done
+ * purely to assist debugging. The kernel itself only ever references a timer
+ * by its handle, and never by its name.
+ *
+ * @param xTimerPeriodInTicks The timer period. The time is defined in tick
+ * periods so the constant portTICK_PERIOD_MS can be used to convert a time that
+ * has been specified in milliseconds. For example, if the timer must expire
+ * after 100 ticks, then xTimerPeriodInTicks should be set to 100.
+ * Alternatively, if the timer must expire after 500ms, then xPeriod can be set
+ * to ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than or
+ * equal to 1000.
+ *
+ * @param uxAutoReload If uxAutoReload is set to pdTRUE then the timer will
+ * expire repeatedly with a frequency set by the xTimerPeriodInTicks parameter.
+ * If uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and
+ * enter the dormant state after it expires.
+ *
+ * @param pvTimerID An identifier that is assigned to the timer being created.
+ * Typically this would be used in the timer callback function to identify which
+ * timer expired when the same callback function is assigned to more than one
+ * timer.
+ *
+ * @param pxCallbackFunction The function to call when the timer expires.
+ * Callback functions must have the prototype defined by TimerCallbackFunction_t,
+ * which is "void vCallbackFunction( TimerHandle_t xTimer );".
+ *
+ * @param pxTimerBuffer If pxTimerBuffer is NULL then the memory required to
+ * hold the software timer's data structure will be allocated dynamically, just
+ * as when a software timer is created using xTimerCreate(). If pxTimerBuffer
+ * is not NULL then it must point to a variable of type StaticTimer_t, which
+ * will be then be used to hold the software timer's data structures, removing
+ * the need for the memory to be allocated dynamically.
+ *
+ * @return If the timer is successfully created then a handle to the newly
+ * created timer is returned. If the timer cannot be created (because either
+ * there is insufficient FreeRTOS heap remaining to allocate the timer
+ * structures, or the timer period was set to 0) then NULL is returned.
+ *
+ * Example usage:
+ * @verbatim
+ *
+ * // The buffer used to hold the software timer's data structure.
+ * static StaticTimer_t xTimerBuffer;
+ *
+ * // A variable that will be incremented by the software timer's callback
+ * // function.
+ * UBaseType_t uxVariableToIncrement = 0;
+ *
+ * // A software timer callback function that increments a variable passed to
+ * // it when the software timer was created. After the 5th increment the
+ * // callback function stops the software timer.
+ * static void prvTimerCallback( TimerHandle_t xExpiredTimer )
+ * {
+ * UBaseType_t *puxVariableToIncrement;
+ * BaseType_t xReturned;
+ *
+ * // Obtain the address of the variable to increment from the timer ID.
+ * puxVariableToIncrement = ( UBaseType_t * ) pvTimerGetTimerID( xExpiredTimer );
+ *
+ * // Increment the variable to show the timer callback has executed.
+ * ( *puxVariableToIncrement )++;
+ *
+ * // If this callback has executed the required number of times, stop the
+ * // timer.
+ * if( *puxVariableToIncrement == 5 )
+ * {
+ * // This is called from a timer callback so must not block.
+ * xTimerStop( xExpiredTimer, staticDONT_BLOCK );
+ * }
+ * }
+ *
+ *
+ * void main( void )
+ * {
+ * // Create the software time. xTimerCreateStatic() has an extra parameter
+ * // than the normal xTimerCreate() API function. The parameter is a pointer
+ * // to the StaticTimer_t structure that will hold the software timer
+ * // structure. If the parameter is passed as NULL then the structure will be
+ * // allocated dynamically, just as if xTimerCreate() had been called.
+ * xTimer = xTimerCreateStatic( "T1", // Text name for the task. Helps debugging only. Not used by FreeRTOS.
+ * xTimerPeriod, // The period of the timer in ticks.
+ * pdTRUE, // This is an auto-reload timer.
+ * ( void * ) &uxVariableToIncrement, // A variable incremented by the software timer's callback function
+ * prvTimerCallback, // The function to execute when the timer expires.
+ * &xTimerBuffer ); // The buffer that will hold the software timer structure.
+ *
+ * // The scheduler has not started yet so a block time is not used.
+ * xReturned = xTimerStart( xTimer, 0 );
+ *
+ * // ...
+ * // Create tasks here.
+ * // ...
+ *
+ * // Starting the scheduler will start the timers running as they have already
+ * // been set into the active state.
+ * xTaskStartScheduler();
+ *
+ * // Should not reach here.
+ * for( ;; );
+ * }
+ * @endverbatim
+ */
#if( configSUPPORT_STATIC_ALLOCATION == 1 )
- #define xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxStaticTimer ) xTimerGenericCreate( ( pcTimerName ), ( xTimerPeriodInTicks ), ( uxAutoReload ), ( pvTimerID ), ( pxCallbackFunction ), pxStaticTimer )
+ #define xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxTimerBuffer ) xTimerGenericCreate( ( pcTimerName ), ( xTimerPeriodInTicks ), ( uxAutoReload ), ( pvTimerID ), ( pxCallbackFunction ), ( pxTimerBuffer ) )
#endif /* configSUPPORT_STATIC_ALLOCATION */
/**
@@ -1140,7 +1277,7 @@ const char * pcTimerGetTimerName( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION; /*
*/
BaseType_t xTimerCreateTimerTask( void ) PRIVILEGED_FUNCTION;
BaseType_t xTimerGenericCommand( TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t * const pxHigherPriorityTaskWoken, const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
-TimerHandle_t xTimerGenericCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction, StaticTimer_t *pxStaticTimer ) PRIVILEGED_FUNCTION;
+TimerHandle_t xTimerGenericCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction, StaticTimer_t *pxTimerBuffer ) PRIVILEGED_FUNCTION;
#ifdef __cplusplus
}
diff --git a/FreeRTOS/Source/tasks.c b/FreeRTOS/Source/tasks.c
index 432d0783c1..d73f8d2770 100644
--- a/FreeRTOS/Source/tasks.c
+++ b/FreeRTOS/Source/tasks.c
@@ -554,7 +554,7 @@ static void prvResetNextTaskUnblockTime( void );
#endif
/*-----------------------------------------------------------*/
-BaseType_t xTaskGenericCreate( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask, StackType_t * const puxStackBuffer, StaticTask_t * const pxTCBBuffer, const MemoryRegion_t * const xRegions ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
+BaseType_t xTaskGenericCreate( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask, StackType_t * const puxStackBuffer, StaticTask_t * const pxTaskBuffer, const MemoryRegion_t * const xRegions ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
{
BaseType_t xReturn;
TCB_t * pxNewTCB;
@@ -565,7 +565,7 @@ StackType_t *pxTopOfStack;
/* Allocate the memory required by the TCB and stack for the new task,
checking that the allocation was successful. */
- pxNewTCB = prvAllocateTCBAndStack( usStackDepth, puxStackBuffer, ( TCB_t* ) pxTCBBuffer ); /*lint !e740 Unusual cast is ok as the structures are designed to have the same alignment, and the size is checked by an assert. */
+ pxNewTCB = prvAllocateTCBAndStack( usStackDepth, puxStackBuffer, ( TCB_t* ) pxTaskBuffer ); /*lint !e740 Unusual cast is ok as the structures are designed to have the same alignment, and the size is checked by an assert. */
if( pxNewTCB != NULL )
{
@@ -3145,7 +3145,7 @@ static void prvAddCurrentTaskToDelayedList( const TickType_t xTimeToWake )
}
/*-----------------------------------------------------------*/
-static TCB_t *prvAllocateTCBAndStack( const uint16_t usStackDepth, StackType_t * const puxStackBuffer, TCB_t * const pxTCBBuffer )
+static TCB_t *prvAllocateTCBAndStack( const uint16_t usStackDepth, StackType_t * const puxStackBuffer, TCB_t * const pxTaskBuffer )
{
TCB_t *pxNewTCB;
@@ -3166,7 +3166,7 @@ TCB_t *pxNewTCB;
{
/* Allocate space for the TCB. Where the memory comes from depends on
the implementation of the port malloc function. */
- pxNewTCB = ( TCB_t * ) pvPortMallocAligned( sizeof( TCB_t ), pxTCBBuffer );
+ pxNewTCB = ( TCB_t * ) pvPortMallocAligned( sizeof( TCB_t ), pxTaskBuffer );
if( pxNewTCB != NULL )
{
@@ -3179,7 +3179,7 @@ TCB_t *pxNewTCB;
{
/* Could not allocate the stack. Delete the allocated TCB - if
it was allocated dynamically. */
- if( pxTCBBuffer == NULL )
+ if( pxTaskBuffer == NULL )
{
vPortFree( pxNewTCB );
}
@@ -3197,7 +3197,7 @@ TCB_t *pxNewTCB;
if( pxStack != NULL )
{
/* Allocate space for the TCB. */
- pxNewTCB = ( TCB_t * ) pvPortMallocAligned( sizeof( TCB_t ), pxTCBBuffer ); /*lint !e961 MISRA exception as the casts are only redundant for some paths. */
+ pxNewTCB = ( TCB_t * ) pvPortMallocAligned( sizeof( TCB_t ), pxTaskBuffer ); /*lint !e961 MISRA exception as the casts are only redundant for some paths. */
if( pxNewTCB != NULL )
{
@@ -3250,7 +3250,7 @@ TCB_t *pxNewTCB;
mtCOVERAGE_TEST_MARKER();
}
- if( pxTCBBuffer != NULL )
+ if( pxTaskBuffer != NULL )
{
/* The application provided its own TCB. Note the fact so no
attempt is made to delete the TCB if the task is deleted. */
diff --git a/FreeRTOS/Source/timers.c b/FreeRTOS/Source/timers.c
index 904189dc23..1dd62ef589 100644
--- a/FreeRTOS/Source/timers.c
+++ b/FreeRTOS/Source/timers.c
@@ -298,7 +298,7 @@ uint16_t usTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;
}
/*-----------------------------------------------------------*/
-TimerHandle_t xTimerGenericCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction, StaticTimer_t *pxStaticTimer ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
+TimerHandle_t xTimerGenericCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction, StaticTimer_t *pxTimerBuffer ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
{
Timer_t *pxNewTimer;
@@ -321,13 +321,13 @@ Timer_t *pxNewTimer;
{
/* If the user passed in a statically allocated timer structure then use
it, otherwise allocate the structure dynamically. */
- if( pxStaticTimer == NULL )
+ if( pxTimerBuffer == NULL )
{
pxNewTimer = ( Timer_t * ) pvPortMalloc( sizeof( Timer_t ) );
}
else
{
- pxNewTimer = ( Timer_t * ) pxStaticTimer;
+ pxNewTimer = ( Timer_t * ) pxTimerBuffer;
}
if( pxNewTimer != NULL )
@@ -345,14 +345,18 @@ Timer_t *pxNewTimer;
pxNewTimer->pxCallbackFunction = pxCallbackFunction;
vListInitialiseItem( &( pxNewTimer->xTimerListItem ) );
- if( pxStaticTimer == NULL )
+ #if( configSUPPORT_STATIC_ALLOCATION == 1 )
{
- pxNewTimer->ucStaticallyAllocated = pdFALSE;
- }
- else
- {
- pxNewTimer->ucStaticallyAllocated = pdTRUE;
+ if( pxTimerBuffer == NULL )
+ {
+ pxNewTimer->ucStaticallyAllocated = pdFALSE;
+ }
+ else
+ {
+ pxNewTimer->ucStaticallyAllocated = pdTRUE;
+ }
}
+ #endif /* configSUPPORT_STATIC_ALLOCATION */
traceTIMER_CREATE( pxNewTimer );
}
@@ -763,14 +767,22 @@ TickType_t xTimeNow;
/* The timer has already been removed from the active list,
just free up the memory if the memory was dynamically
allocated. */
- if( pxTimer->ucStaticallyAllocated == pdFALSE )
+ #if( configSUPPORT_STATIC_ALLOCATION == 1 )
+ {
+ if( pxTimer->ucStaticallyAllocated == pdFALSE )
+ {
+ vPortFree( pxTimer );
+ }
+ else
+ {
+ mtCOVERAGE_TEST_MARKER();
+ }
+ }
+ #else
{
vPortFree( pxTimer );
}
- else
- {
- mtCOVERAGE_TEST_MARKER();
- }
+ #endif /* configSUPPORT_STATIC_ALLOCATION */
break;
default :