j3d1/esp-open-rtos
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Upgrade to FreeRTOS v9.0.0

Browse source
This commit is contained in:
hyneko1 2016-07-20 22:37:36 +00:00
parent 22c480b583
commit c9c69178ff
53 changed files with 20817 additions and 13816 deletions
Download patch file Download diff file Expand all files Collapse all files

780
FreeRTOS/Source/croutine.c
View file

@ -1,385 +1,395 @@
/* /*
FreeRTOS V7.5.2 - Copyright (C) 2013 Real Time Engineers Ltd. FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.
All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
***************************************************************************
* * This file is part of the FreeRTOS distribution.
* FreeRTOS provides completely free yet professionally developed, *
* robust, strictly quality controlled, supported, and cross * FreeRTOS is free software; you can redistribute it and/or modify it under
* platform software that has become a de facto standard. * the terms of the GNU General Public License (version 2) as published by the
* * Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
* Help yourself get started quickly and support the FreeRTOS *
* project by purchasing a FreeRTOS tutorial book, reference * ***************************************************************************
* manual, or both from: http://www.FreeRTOS.org/Documentation * >>! NOTE: The modification to the GPL is included to allow you to !<<
* * >>! distribute a combined work that includes FreeRTOS without being !<<
* Thank you! * >>! obliged to provide the source code for proprietary components !<<
* * >>! outside of the FreeRTOS kernel. !<<
*************************************************************************** ***************************************************************************
This file is part of the FreeRTOS distribution. FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FreeRTOS is free software; you can redistribute it and/or modify it under FOR A PARTICULAR PURPOSE. Full license text is available on the following
the terms of the GNU General Public License (version 2) as published by the link: http://www.freertos.org/a00114.html
Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
***************************************************************************
>>! NOTE: The modification to the GPL is included to allow you to distribute * *
>>! a combined work that includes FreeRTOS without being obliged to provide * FreeRTOS provides completely free yet professionally developed, *
>>! the source code for proprietary components outside of the FreeRTOS * robust, strictly quality controlled, supported, and cross *
>>! kernel. * platform software that is more than just the market leader, it *
* is the industry's de facto standard. *
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY * *
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * Help yourself get started quickly while simultaneously helping *
FOR A PARTICULAR PURPOSE. Full license text is available from the following * to support the FreeRTOS project by purchasing a FreeRTOS *
link: http://www.freertos.org/a00114.html * tutorial book, reference manual, or both: *
* http://www.FreeRTOS.org/Documentation *
1 tab == 4 spaces! * *
***************************************************************************
***************************************************************************
* * http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
* Having a problem? Start by reading the FAQ "My application does * the FAQ page "My application does not run, what could be wrong?". Have you
* not run, what could be wrong?" * defined configASSERT()?
* *
* http://www.FreeRTOS.org/FAQHelp.html * http://www.FreeRTOS.org/support - In return for receiving this top quality
* * embedded software for free we request you assist our global community by
*************************************************************************** participating in the support forum.
http://www.FreeRTOS.org - Documentation, books, training, latest versions, http://www.FreeRTOS.org/training - Investing in training allows your team to
license and Real Time Engineers Ltd. contact details. be as productive as possible as early as possible. Now you can receive
FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products, Ltd, and the world's leading authority on the world's leading RTOS.
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
compatible FAT file system, and our tiny thread aware UDP/IP stack. http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High compatible FAT file system, and our tiny thread aware UDP/IP stack.
Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and middleware. http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
mission critical applications that require provable dependability. Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and commercial middleware.
1 tab == 4 spaces!
*/ http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and
#include "FreeRTOS.h" mission critical applications that require provable dependability.
#include "task.h"
#include "croutine.h" 1 tab == 4 spaces!
*/
/*
* Some kernel aware debuggers require data to be viewed to be global, rather #include "FreeRTOS.h"
* than file scope. #include "task.h"
*/ #include "croutine.h"
#ifdef portREMOVE_STATIC_QUALIFIER
#define static /* Remove the whole file is co-routines are not being used. */
#endif #if( configUSE_CO_ROUTINES != 0 )
/*
/* Lists for ready and blocked co-routines. --------------------*/ * Some kernel aware debuggers require data to be viewed to be global, rather
static xList pxReadyCoRoutineLists[ configMAX_CO_ROUTINE_PRIORITIES ]; /*< Prioritised ready co-routines. */ * than file scope.
static xList xDelayedCoRoutineList1; /*< Delayed co-routines. */ */
static xList xDelayedCoRoutineList2; /*< Delayed co-routines (two lists are used - one for delays that have overflowed the current tick count. */ #ifdef portREMOVE_STATIC_QUALIFIER
static xList * pxDelayedCoRoutineList; /*< Points to the delayed co-routine list currently being used. */ #define static
static xList * pxOverflowDelayedCoRoutineList; /*< Points to the delayed co-routine list currently being used to hold co-routines that have overflowed the current tick count. */ #endif
static xList xPendingReadyCoRoutineList; /*< Holds co-routines that have been readied by an external event. They cannot be added directly to the ready lists as the ready lists cannot be accessed by interrupts. */
/* Other file private variables. --------------------------------*/ /* Lists for ready and blocked co-routines. --------------------*/
corCRCB * pxCurrentCoRoutine = NULL; static List_t pxReadyCoRoutineLists[ configMAX_CO_ROUTINE_PRIORITIES ]; /*< Prioritised ready co-routines. */
static unsigned portBASE_TYPE uxTopCoRoutineReadyPriority = 0; static List_t xDelayedCoRoutineList1; /*< Delayed co-routines. */
static portTickType xCoRoutineTickCount = 0, xLastTickCount = 0, xPassedTicks = 0; static List_t xDelayedCoRoutineList2; /*< Delayed co-routines (two lists are used - one for delays that have overflowed the current tick count. */
static List_t * pxDelayedCoRoutineList; /*< Points to the delayed co-routine list currently being used. */
/* The initial state of the co-routine when it is created. */ static List_t * pxOverflowDelayedCoRoutineList; /*< Points to the delayed co-routine list currently being used to hold co-routines that have overflowed the current tick count. */
#define corINITIAL_STATE ( 0 ) static List_t xPendingReadyCoRoutineList; /*< Holds co-routines that have been readied by an external event. They cannot be added directly to the ready lists as the ready lists cannot be accessed by interrupts. */
/* /* Other file private variables. --------------------------------*/
* Place the co-routine represented by pxCRCB into the appropriate ready queue CRCB_t * pxCurrentCoRoutine = NULL;
* for the priority. It is inserted at the end of the list. static UBaseType_t uxTopCoRoutineReadyPriority = 0;
* static TickType_t xCoRoutineTickCount = 0, xLastTickCount = 0, xPassedTicks = 0;
* This macro accesses the co-routine ready lists and therefore must not be
* used from within an ISR. /* The initial state of the co-routine when it is created. */
*/ #define corINITIAL_STATE ( 0 )
#define prvAddCoRoutineToReadyQueue( pxCRCB ) \
{ \ /*
if( pxCRCB->uxPriority > uxTopCoRoutineReadyPriority ) \ * Place the co-routine represented by pxCRCB into the appropriate ready queue
{ \ * for the priority. It is inserted at the end of the list.
uxTopCoRoutineReadyPriority = pxCRCB->uxPriority; \ *
} \ * This macro accesses the co-routine ready lists and therefore must not be
vListInsertEnd( ( xList * ) &( pxReadyCoRoutineLists[ pxCRCB->uxPriority ] ), &( pxCRCB->xGenericListItem ) ); \ * used from within an ISR.
} */
#define prvAddCoRoutineToReadyQueue( pxCRCB ) \
/* { \
* Utility to ready all the lists used by the scheduler. This is called if( pxCRCB->uxPriority > uxTopCoRoutineReadyPriority ) \
* automatically upon the creation of the first co-routine. { \
*/ uxTopCoRoutineReadyPriority = pxCRCB->uxPriority; \
static void prvInitialiseCoRoutineLists( void ); } \
vListInsertEnd( ( List_t * ) &( pxReadyCoRoutineLists[ pxCRCB->uxPriority ] ), &( pxCRCB->xGenericListItem ) ); \
/* }
* Co-routines that are readied by an interrupt cannot be placed directly into
* the ready lists (there is no mutual exclusion). Instead they are placed in /*
* in the pending ready list in order that they can later be moved to the ready * Utility to ready all the lists used by the scheduler. This is called
* list by the co-routine scheduler. * automatically upon the creation of the first co-routine.
*/ */
static void prvCheckPendingReadyList( void ); static void prvInitialiseCoRoutineLists( void );
/* /*
* Macro that looks at the list of co-routines that are currently delayed to * Co-routines that are readied by an interrupt cannot be placed directly into
* see if any require waking. * the ready lists (there is no mutual exclusion). Instead they are placed in
* * in the pending ready list in order that they can later be moved to the ready
* Co-routines are stored in the queue in the order of their wake time - * list by the co-routine scheduler.
* meaning once one co-routine has been found whose timer has not expired */
* we need not look any further down the list. static void prvCheckPendingReadyList( void );
*/
static void prvCheckDelayedList( void ); /*
* Macro that looks at the list of co-routines that are currently delayed to
/*-----------------------------------------------------------*/ * see if any require waking.
*
signed portBASE_TYPE xCoRoutineCreate( crCOROUTINE_CODE pxCoRoutineCode, unsigned portBASE_TYPE uxPriority, unsigned portBASE_TYPE uxIndex ) * Co-routines are stored in the queue in the order of their wake time -
{ * meaning once one co-routine has been found whose timer has not expired
signed portBASE_TYPE xReturn; * we need not look any further down the list.
corCRCB *pxCoRoutine; */
static void prvCheckDelayedList( void );
/* Allocate the memory that will store the co-routine control block. */
pxCoRoutine = ( corCRCB * ) pvPortMalloc( sizeof( corCRCB ) ); /*-----------------------------------------------------------*/
if( pxCoRoutine )
{ BaseType_t xCoRoutineCreate( crCOROUTINE_CODE pxCoRoutineCode, UBaseType_t uxPriority, UBaseType_t uxIndex )
/* If pxCurrentCoRoutine is NULL then this is the first co-routine to {
be created and the co-routine data structures need initialising. */ BaseType_t xReturn;
if( pxCurrentCoRoutine == NULL ) CRCB_t *pxCoRoutine;
{
pxCurrentCoRoutine = pxCoRoutine; /* Allocate the memory that will store the co-routine control block. */
prvInitialiseCoRoutineLists(); pxCoRoutine = ( CRCB_t * ) pvPortMalloc( sizeof( CRCB_t ) );
} if( pxCoRoutine )
{
/* Check the priority is within limits. */ /* If pxCurrentCoRoutine is NULL then this is the first co-routine to
if( uxPriority >= configMAX_CO_ROUTINE_PRIORITIES ) be created and the co-routine data structures need initialising. */
{ if( pxCurrentCoRoutine == NULL )
uxPriority = configMAX_CO_ROUTINE_PRIORITIES - 1; {
} pxCurrentCoRoutine = pxCoRoutine;
prvInitialiseCoRoutineLists();
/* Fill out the co-routine control block from the function parameters. */ }
pxCoRoutine->uxState = corINITIAL_STATE;
pxCoRoutine->uxPriority = uxPriority; /* Check the priority is within limits. */
pxCoRoutine->uxIndex = uxIndex; if( uxPriority >= configMAX_CO_ROUTINE_PRIORITIES )
pxCoRoutine->pxCoRoutineFunction = pxCoRoutineCode; {
uxPriority = configMAX_CO_ROUTINE_PRIORITIES - 1;
/* Initialise all the other co-routine control block parameters. */ }
vListInitialiseItem( &( pxCoRoutine->xGenericListItem ) );
vListInitialiseItem( &( pxCoRoutine->xEventListItem ) ); /* Fill out the co-routine control block from the function parameters. */
pxCoRoutine->uxState = corINITIAL_STATE;
/* Set the co-routine control block as a link back from the xListItem. pxCoRoutine->uxPriority = uxPriority;
This is so we can get back to the containing CRCB from a generic item pxCoRoutine->uxIndex = uxIndex;
in a list. */ pxCoRoutine->pxCoRoutineFunction = pxCoRoutineCode;
listSET_LIST_ITEM_OWNER( &( pxCoRoutine->xGenericListItem ), pxCoRoutine );
listSET_LIST_ITEM_OWNER( &( pxCoRoutine->xEventListItem ), pxCoRoutine ); /* Initialise all the other co-routine control block parameters. */
vListInitialiseItem( &( pxCoRoutine->xGenericListItem ) );
/* Event lists are always in priority order. */ vListInitialiseItem( &( pxCoRoutine->xEventListItem ) );
listSET_LIST_ITEM_VALUE( &( pxCoRoutine->xEventListItem ), configMAX_PRIORITIES - ( portTickType ) uxPriority );
/* Set the co-routine control block as a link back from the ListItem_t.
/* Now the co-routine has been initialised it can be added to the ready This is so we can get back to the containing CRCB from a generic item
list at the correct priority. */ in a list. */
prvAddCoRoutineToReadyQueue( pxCoRoutine ); listSET_LIST_ITEM_OWNER( &( pxCoRoutine->xGenericListItem ), pxCoRoutine );
listSET_LIST_ITEM_OWNER( &( pxCoRoutine->xEventListItem ), pxCoRoutine );
xReturn = pdPASS;
} /* Event lists are always in priority order. */
else listSET_LIST_ITEM_VALUE( &( pxCoRoutine->xEventListItem ), ( ( TickType_t ) configMAX_CO_ROUTINE_PRIORITIES - ( TickType_t ) uxPriority ) );
{
xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY; /* Now the co-routine has been initialised it can be added to the ready
} list at the correct priority. */
prvAddCoRoutineToReadyQueue( pxCoRoutine );
return xReturn;
} xReturn = pdPASS;
/*-----------------------------------------------------------*/ }
else
void vCoRoutineAddToDelayedList( portTickType xTicksToDelay, xList *pxEventList ) {
{ xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
portTickType xTimeToWake; }
/* Calculate the time to wake - this may overflow but this is return xReturn;
not a problem. */ }
xTimeToWake = xCoRoutineTickCount + xTicksToDelay; /*-----------------------------------------------------------*/
/* We must remove ourselves from the ready list before adding void vCoRoutineAddToDelayedList( TickType_t xTicksToDelay, List_t *pxEventList )
ourselves to the blocked list as the same list item is used for {
both lists. */ TickType_t xTimeToWake;
( void ) uxListRemove( ( xListItem * ) &( pxCurrentCoRoutine->xGenericListItem ) );
/* Calculate the time to wake - this may overflow but this is
/* The list item will be inserted in wake time order. */ not a problem. */
listSET_LIST_ITEM_VALUE( &( pxCurrentCoRoutine->xGenericListItem ), xTimeToWake ); xTimeToWake = xCoRoutineTickCount + xTicksToDelay;
if( xTimeToWake < xCoRoutineTickCount ) /* We must remove ourselves from the ready list before adding
{ ourselves to the blocked list as the same list item is used for
/* Wake time has overflowed. Place this item in the both lists. */
overflow list. */ ( void ) uxListRemove( ( ListItem_t * ) &( pxCurrentCoRoutine->xGenericListItem ) );
vListInsert( ( xList * ) pxOverflowDelayedCoRoutineList, ( xListItem * ) &( pxCurrentCoRoutine->xGenericListItem ) );
} /* The list item will be inserted in wake time order. */
else listSET_LIST_ITEM_VALUE( &( pxCurrentCoRoutine->xGenericListItem ), xTimeToWake );
{
/* The wake time has not overflowed, so we can use the if( xTimeToWake < xCoRoutineTickCount )
current block list. */ {
vListInsert( ( xList * ) pxDelayedCoRoutineList, ( xListItem * ) &( pxCurrentCoRoutine->xGenericListItem ) ); /* Wake time has overflowed. Place this item in the
} overflow list. */
vListInsert( ( List_t * ) pxOverflowDelayedCoRoutineList, ( ListItem_t * ) &( pxCurrentCoRoutine->xGenericListItem ) );
if( pxEventList ) }
{ else
/* Also add the co-routine to an event list. If this is done then the {
function must be called with interrupts disabled. */ /* The wake time has not overflowed, so we can use the
vListInsert( pxEventList, &( pxCurrentCoRoutine->xEventListItem ) ); current block list. */
} vListInsert( ( List_t * ) pxDelayedCoRoutineList, ( ListItem_t * ) &( pxCurrentCoRoutine->xGenericListItem ) );
} }
/*-----------------------------------------------------------*/
if( pxEventList )
static void prvCheckPendingReadyList( void ) {
{ /* Also add the co-routine to an event list. If this is done then the
/* Are there any co-routines waiting to get moved to the ready list? These function must be called with interrupts disabled. */
are co-routines that have been readied by an ISR. The ISR cannot access vListInsert( pxEventList, &( pxCurrentCoRoutine->xEventListItem ) );
the ready lists itself. */ }
while( listLIST_IS_EMPTY( &xPendingReadyCoRoutineList ) == pdFALSE ) }
{ /*-----------------------------------------------------------*/
corCRCB *pxUnblockedCRCB;
static void prvCheckPendingReadyList( void )
/* The pending ready list can be accessed by an ISR. */ {
portDISABLE_INTERRUPTS(); /* Are there any co-routines waiting to get moved to the ready list? These
{ are co-routines that have been readied by an ISR. The ISR cannot access
pxUnblockedCRCB = ( corCRCB * ) listGET_OWNER_OF_HEAD_ENTRY( (&xPendingReadyCoRoutineList) ); the ready lists itself. */
( void ) uxListRemove( &( pxUnblockedCRCB->xEventListItem ) ); while( listLIST_IS_EMPTY( &xPendingReadyCoRoutineList ) == pdFALSE )
} {
portENABLE_INTERRUPTS(); CRCB_t *pxUnblockedCRCB;
( void ) uxListRemove( &( pxUnblockedCRCB->xGenericListItem ) ); /* The pending ready list can be accessed by an ISR. */
prvAddCoRoutineToReadyQueue( pxUnblockedCRCB ); portDISABLE_INTERRUPTS();
} {
} pxUnblockedCRCB = ( CRCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( (&xPendingReadyCoRoutineList) );
/*-----------------------------------------------------------*/ ( void ) uxListRemove( &( pxUnblockedCRCB->xEventListItem ) );
}
static void prvCheckDelayedList( void ) portENABLE_INTERRUPTS();
{
corCRCB *pxCRCB; ( void ) uxListRemove( &( pxUnblockedCRCB->xGenericListItem ) );
prvAddCoRoutineToReadyQueue( pxUnblockedCRCB );
xPassedTicks = xTaskGetTickCount() - xLastTickCount; }
while( xPassedTicks ) }
{ /*-----------------------------------------------------------*/
xCoRoutineTickCount++;
xPassedTicks--; static void prvCheckDelayedList( void )
{
/* If the tick count has overflowed we need to swap the ready lists. */ CRCB_t *pxCRCB;
if( xCoRoutineTickCount == 0 )
{ xPassedTicks = xTaskGetTickCount() - xLastTickCount;
xList * pxTemp; while( xPassedTicks )
{
/* Tick count has overflowed so we need to swap the delay lists. If there are xCoRoutineTickCount++;
any items in pxDelayedCoRoutineList here then there is an error! */ xPassedTicks--;
pxTemp = pxDelayedCoRoutineList;
pxDelayedCoRoutineList = pxOverflowDelayedCoRoutineList; /* If the tick count has overflowed we need to swap the ready lists. */
pxOverflowDelayedCoRoutineList = pxTemp; if( xCoRoutineTickCount == 0 )
} {
List_t * pxTemp;
/* See if this tick has made a timeout expire. */
while( listLIST_IS_EMPTY( pxDelayedCoRoutineList ) == pdFALSE ) /* Tick count has overflowed so we need to swap the delay lists. If there are
{ any items in pxDelayedCoRoutineList here then there is an error! */
pxCRCB = ( corCRCB * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedCoRoutineList ); pxTemp = pxDelayedCoRoutineList;
pxDelayedCoRoutineList = pxOverflowDelayedCoRoutineList;
if( xCoRoutineTickCount < listGET_LIST_ITEM_VALUE( &( pxCRCB->xGenericListItem ) ) ) pxOverflowDelayedCoRoutineList = pxTemp;
{ }
/* Timeout not yet expired. */
break; /* See if this tick has made a timeout expire. */
} while( listLIST_IS_EMPTY( pxDelayedCoRoutineList ) == pdFALSE )
{
portDISABLE_INTERRUPTS(); pxCRCB = ( CRCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedCoRoutineList );
{
/* The event could have occurred just before this critical if( xCoRoutineTickCount < listGET_LIST_ITEM_VALUE( &( pxCRCB->xGenericListItem ) ) )
section. If this is the case then the generic list item will {
have been moved to the pending ready list and the following /* Timeout not yet expired. */
line is still valid. Also the pvContainer parameter will have break;
been set to NULL so the following lines are also valid. */ }
uxListRemove( &( pxCRCB->xGenericListItem ) );
portDISABLE_INTERRUPTS();
/* Is the co-routine waiting on an event also? */ {
if( pxCRCB->xEventListItem.pvContainer ) /* The event could have occurred just before this critical
{ section. If this is the case then the generic list item will
( void ) uxListRemove( &( pxCRCB->xEventListItem ) ); have been moved to the pending ready list and the following
} line is still valid. Also the pvContainer parameter will have
} been set to NULL so the following lines are also valid. */
portENABLE_INTERRUPTS(); ( void ) uxListRemove( &( pxCRCB->xGenericListItem ) );
prvAddCoRoutineToReadyQueue( pxCRCB ); /* Is the co-routine waiting on an event also? */
} if( pxCRCB->xEventListItem.pvContainer )
} {
( void ) uxListRemove( &( pxCRCB->xEventListItem ) );
xLastTickCount = xCoRoutineTickCount; }
} }
/*-----------------------------------------------------------*/ portENABLE_INTERRUPTS();
void vCoRoutineSchedule( void ) prvAddCoRoutineToReadyQueue( pxCRCB );
{ }
/* See if any co-routines readied by events need moving to the ready lists. */ }
prvCheckPendingReadyList();
xLastTickCount = xCoRoutineTickCount;
/* See if any delayed co-routines have timed out. */ }
prvCheckDelayedList(); /*-----------------------------------------------------------*/
/* Find the highest priority queue that contains ready co-routines. */ void vCoRoutineSchedule( void )
while( listLIST_IS_EMPTY( &( pxReadyCoRoutineLists[ uxTopCoRoutineReadyPriority ] ) ) ) {
{ /* See if any co-routines readied by events need moving to the ready lists. */
if( uxTopCoRoutineReadyPriority == 0 ) prvCheckPendingReadyList();
{
/* No more co-routines to check. */ /* See if any delayed co-routines have timed out. */
return; prvCheckDelayedList();
}
--uxTopCoRoutineReadyPriority; /* Find the highest priority queue that contains ready co-routines. */
} while( listLIST_IS_EMPTY( &( pxReadyCoRoutineLists[ uxTopCoRoutineReadyPriority ] ) ) )
{
/* listGET_OWNER_OF_NEXT_ENTRY walks through the list, so the co-routines if( uxTopCoRoutineReadyPriority == 0 )
of the same priority get an equal share of the processor time. */ {
listGET_OWNER_OF_NEXT_ENTRY( pxCurrentCoRoutine, &( pxReadyCoRoutineLists[ uxTopCoRoutineReadyPriority ] ) ); /* No more co-routines to check. */
return;
/* Call the co-routine. */ }
( pxCurrentCoRoutine->pxCoRoutineFunction )( pxCurrentCoRoutine, pxCurrentCoRoutine->uxIndex ); --uxTopCoRoutineReadyPriority;
}
return;
} /* listGET_OWNER_OF_NEXT_ENTRY walks through the list, so the co-routines
/*-----------------------------------------------------------*/ of the same priority get an equal share of the processor time. */
listGET_OWNER_OF_NEXT_ENTRY( pxCurrentCoRoutine, &( pxReadyCoRoutineLists[ uxTopCoRoutineReadyPriority ] ) );
static void prvInitialiseCoRoutineLists( void )
{ /* Call the co-routine. */
unsigned portBASE_TYPE uxPriority; ( pxCurrentCoRoutine->pxCoRoutineFunction )( pxCurrentCoRoutine, pxCurrentCoRoutine->uxIndex );
for( uxPriority = 0; uxPriority < configMAX_CO_ROUTINE_PRIORITIES; uxPriority++ ) return;
{ }
vListInitialise( ( xList * ) &( pxReadyCoRoutineLists[ uxPriority ] ) ); /*-----------------------------------------------------------*/
}
static void prvInitialiseCoRoutineLists( void )
vListInitialise( ( xList * ) &xDelayedCoRoutineList1 ); {
vListInitialise( ( xList * ) &xDelayedCoRoutineList2 ); UBaseType_t uxPriority;
vListInitialise( ( xList * ) &xPendingReadyCoRoutineList );
for( uxPriority = 0; uxPriority < configMAX_CO_ROUTINE_PRIORITIES; uxPriority++ )
/* Start with pxDelayedCoRoutineList using list1 and the {
pxOverflowDelayedCoRoutineList using list2. */ vListInitialise( ( List_t * ) &( pxReadyCoRoutineLists[ uxPriority ] ) );
pxDelayedCoRoutineList = &xDelayedCoRoutineList1; }
pxOverflowDelayedCoRoutineList = &xDelayedCoRoutineList2;
} vListInitialise( ( List_t * ) &xDelayedCoRoutineList1 );
/*-----------------------------------------------------------*/ vListInitialise( ( List_t * ) &xDelayedCoRoutineList2 );
vListInitialise( ( List_t * ) &xPendingReadyCoRoutineList );
signed portBASE_TYPE xCoRoutineRemoveFromEventList( const xList *pxEventList )
{ /* Start with pxDelayedCoRoutineList using list1 and the
corCRCB *pxUnblockedCRCB; pxOverflowDelayedCoRoutineList using list2. */
signed portBASE_TYPE xReturn; pxDelayedCoRoutineList = &xDelayedCoRoutineList1;
pxOverflowDelayedCoRoutineList = &xDelayedCoRoutineList2;
/* This function is called from within an interrupt. It can only access }
event lists and the pending ready list. This function assumes that a /*-----------------------------------------------------------*/
check has already been made to ensure pxEventList is not empty. */
pxUnblockedCRCB = ( corCRCB * ) listGET_OWNER_OF_HEAD_ENTRY( pxEventList ); BaseType_t xCoRoutineRemoveFromEventList( const List_t *pxEventList )
( void ) uxListRemove( &( pxUnblockedCRCB->xEventListItem ) ); {
vListInsertEnd( ( xList * ) &( xPendingReadyCoRoutineList ), &( pxUnblockedCRCB->xEventListItem ) ); CRCB_t *pxUnblockedCRCB;
BaseType_t xReturn;
if( pxUnblockedCRCB->uxPriority >= pxCurrentCoRoutine->uxPriority )
{ /* This function is called from within an interrupt. It can only access
xReturn = pdTRUE; event lists and the pending ready list. This function assumes that a
} check has already been made to ensure pxEventList is not empty. */
else pxUnblockedCRCB = ( CRCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxEventList );
{ ( void ) uxListRemove( &( pxUnblockedCRCB->xEventListItem ) );
xReturn = pdFALSE; vListInsertEnd( ( List_t * ) &( xPendingReadyCoRoutineList ), &( pxUnblockedCRCB->xEventListItem ) );
}
if( pxUnblockedCRCB->uxPriority >= pxCurrentCoRoutine->uxPriority )
return xReturn; {
} xReturn = pdTRUE;
}
else
{
xReturn = pdFALSE;
}
return xReturn;
}
#endif /* configUSE_CO_ROUTINES == 0 */

752
FreeRTOS/Source/event_groups.c Normal file
View file

@ -0,0 +1,752 @@
/*
FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.
All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
This file is part of the FreeRTOS distribution.
FreeRTOS is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License (version 2) as published by the
Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
***************************************************************************
>>! NOTE: The modification to the GPL is included to allow you to !<<
>>! distribute a combined work that includes FreeRTOS without being !<<
>>! obliged to provide the source code for proprietary components !<<
>>! outside of the FreeRTOS kernel. !<<
***************************************************************************
FreeRTOS 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. Full license text is available on the following
link: http://www.freertos.org/a00114.html
***************************************************************************
* *
* FreeRTOS provides completely free yet professionally developed, *
* robust, strictly quality controlled, supported, and cross *
* platform software that is more than just the market leader, it *
* is the industry's de facto standard. *
* *
* Help yourself get started quickly while simultaneously helping *
* to support the FreeRTOS project by purchasing a FreeRTOS *
* tutorial book, reference manual, or both: *
* http://www.FreeRTOS.org/Documentation *
* *
***************************************************************************
http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
the FAQ page "My application does not run, what could be wrong?". Have you
defined configASSERT()?
http://www.FreeRTOS.org/support - In return for receiving this top quality
embedded software for free we request you assist our global community by
participating in the support forum.
http://www.FreeRTOS.org/training - Investing in training allows your team to
be as productive as possible as early as possible. Now you can receive
FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
Ltd, and the world's leading authority on the world's leading RTOS.
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
compatible FAT file system, and our tiny thread aware UDP/IP stack.
http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and commercial middleware.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and
mission critical applications that require provable dependability.
1 tab == 4 spaces!
*/
/* Standard includes. */
#include <stdlib.h>
/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
all the API functions to use the MPU wrappers. That should only be done when
task.h is included from an application file. */
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
/* FreeRTOS includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "timers.h"
#include "event_groups.h"
/* Lint e961 and e750 are suppressed as a MISRA exception justified because the
MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined for the
header files above, but not in this file, in order to generate the correct
privileged Vs unprivileged linkage and placement. */
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750. */
/* The following bit fields convey control information in a task's event list
item value. It is important they don't clash with the
taskEVENT_LIST_ITEM_VALUE_IN_USE definition. */
#if configUSE_16_BIT_TICKS == 1
#define eventCLEAR_EVENTS_ON_EXIT_BIT 0x0100U
#define eventUNBLOCKED_DUE_TO_BIT_SET 0x0200U
#define eventWAIT_FOR_ALL_BITS 0x0400U
#define eventEVENT_BITS_CONTROL_BYTES 0xff00U
#else
#define eventCLEAR_EVENTS_ON_EXIT_BIT 0x01000000UL
#define eventUNBLOCKED_DUE_TO_BIT_SET 0x02000000UL
#define eventWAIT_FOR_ALL_BITS 0x04000000UL
#define eventEVENT_BITS_CONTROL_BYTES 0xff000000UL
#endif
typedef struct xEventGroupDefinition
{
EventBits_t uxEventBits;
List_t xTasksWaitingForBits; /*< List of tasks waiting for a bit to be set. */
#if( configUSE_TRACE_FACILITY == 1 )
UBaseType_t uxEventGroupNumber;
#endif
#if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
uint8_t ucStaticallyAllocated; /*< Set to pdTRUE if the event group is statically allocated to ensure no attempt is made to free the memory. */
#endif
} EventGroup_t;
/*-----------------------------------------------------------*/
/*
* Test the bits set in uxCurrentEventBits to see if the wait condition is met.
* The wait condition is defined by xWaitForAllBits. If xWaitForAllBits is
* pdTRUE then the wait condition is met if all the bits set in uxBitsToWaitFor
* are also set in uxCurrentEventBits. If xWaitForAllBits is pdFALSE then the
* wait condition is met if any of the bits set in uxBitsToWait for are also set
* in uxCurrentEventBits.
*/
static BaseType_t prvTestWaitCondition( const EventBits_t uxCurrentEventBits, const EventBits_t uxBitsToWaitFor, const BaseType_t xWaitForAllBits ) PRIVILEGED_FUNCTION;
/*-----------------------------------------------------------*/
#if( configSUPPORT_STATIC_ALLOCATION == 1 )
EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer )
{
EventGroup_t *pxEventBits;
/* A StaticEventGroup_t object must be provided. */
configASSERT( pxEventGroupBuffer );
/* The user has provided a statically allocated event group - use it. */
pxEventBits = ( EventGroup_t * ) pxEventGroupBuffer; /*lint !e740 EventGroup_t and StaticEventGroup_t are guaranteed to have the same size and alignment requirement - checked by configASSERT(). */
if( pxEventBits != NULL )
{
pxEventBits->uxEventBits = 0;
vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );
#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
{
/* Both static and dynamic allocation can be used, so note that
this event group was created statically in case the event group
is later deleted. */
pxEventBits->ucStaticallyAllocated = pdTRUE;
}
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
traceEVENT_GROUP_CREATE( pxEventBits );
}
else
{
traceEVENT_GROUP_CREATE_FAILED();
}
return ( EventGroupHandle_t ) pxEventBits;
}
#endif /* configSUPPORT_STATIC_ALLOCATION */
/*-----------------------------------------------------------*/
#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
EventGroupHandle_t xEventGroupCreate( void )
{
EventGroup_t *pxEventBits;
/* Allocate the event group. */
pxEventBits = ( EventGroup_t * ) pvPortMalloc( sizeof( EventGroup_t ) );
if( pxEventBits != NULL )
{
pxEventBits->uxEventBits = 0;
vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );
#if( configSUPPORT_STATIC_ALLOCATION == 1 )
{
/* Both static and dynamic allocation can be used, so note this
event group was allocated statically in case the event group is
later deleted. */
pxEventBits->ucStaticallyAllocated = pdFALSE;
}
#endif /* configSUPPORT_STATIC_ALLOCATION */
traceEVENT_GROUP_CREATE( pxEventBits );
}
else
{
traceEVENT_GROUP_CREATE_FAILED();
}
return ( EventGroupHandle_t ) pxEventBits;
}
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
/*-----------------------------------------------------------*/
EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait )
{
EventBits_t uxOriginalBitValue, uxReturn;
EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;
BaseType_t xAlreadyYielded;
BaseType_t xTimeoutOccurred = pdFALSE;
configASSERT( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
configASSERT( uxBitsToWaitFor != 0 );
#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
{
configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
}
#endif
vTaskSuspendAll();
{
uxOriginalBitValue = pxEventBits->uxEventBits;
( void ) xEventGroupSetBits( xEventGroup, uxBitsToSet );
if( ( ( uxOriginalBitValue | uxBitsToSet ) & uxBitsToWaitFor ) == uxBitsToWaitFor )
{
/* All the rendezvous bits are now set - no need to block. */
uxReturn = ( uxOriginalBitValue | uxBitsToSet );
/* Rendezvous always clear the bits. They will have been cleared
already unless this is the only task in the rendezvous. */
pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
xTicksToWait = 0;
}
else
{
if( xTicksToWait != ( TickType_t ) 0 )
{
traceEVENT_GROUP_SYNC_BLOCK( xEventGroup, uxBitsToSet, uxBitsToWaitFor );
/* Store the bits that the calling task is waiting for in the
task's event list item so the kernel knows when a match is
found. Then enter the blocked state. */
vTaskPlaceOnUnorderedEventList( &( pxEventBits->xTasksWaitingForBits ), ( uxBitsToWaitFor | eventCLEAR_EVENTS_ON_EXIT_BIT | eventWAIT_FOR_ALL_BITS ), xTicksToWait );
/* This assignment is obsolete as uxReturn will get set after
the task unblocks, but some compilers mistakenly generate a
warning about uxReturn being returned without being set if the
assignment is omitted. */
uxReturn = 0;
}
else
{
/* The rendezvous bits were not set, but no block time was
specified - just return the current event bit value. */
uxReturn = pxEventBits->uxEventBits;
}
}
}
xAlreadyYielded = xTaskResumeAll();
if( xTicksToWait != ( TickType_t ) 0 )
{
if( xAlreadyYielded == pdFALSE )
{
portYIELD_WITHIN_API();
}
else
{
mtCOVERAGE_TEST_MARKER();
}
/* The task blocked to wait for its required bits to be set - at this
point either the required bits were set or the block time expired. If
the required bits were set they will have been stored in the task's
event list item, and they should now be retrieved then cleared. */
uxReturn = uxTaskResetEventItemValue();
if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( EventBits_t ) 0 )
{
/* The task timed out, just return the current event bit value. */
taskENTER_CRITICAL();
{
uxReturn = pxEventBits->uxEventBits;
/* Although the task got here because it timed out before the
bits it was waiting for were set, it is possible that since it
unblocked another task has set the bits. If this is the case
then it needs to clear the bits before exiting. */
if( ( uxReturn & uxBitsToWaitFor ) == uxBitsToWaitFor )
{
pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
taskEXIT_CRITICAL();
xTimeoutOccurred = pdTRUE;
}
else
{
/* The task unblocked because the bits were set. */
}
/* Control bits might be set as the task had blocked should not be
returned. */
uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;
}
traceEVENT_GROUP_SYNC_END( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTimeoutOccurred );
return uxReturn;
}
/*-----------------------------------------------------------*/
EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait )
{
EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;
EventBits_t uxReturn, uxControlBits = 0;
BaseType_t xWaitConditionMet, xAlreadyYielded;
BaseType_t xTimeoutOccurred = pdFALSE;
/* Check the user is not attempting to wait on the bits used by the kernel
itself, and that at least one bit is being requested. */
configASSERT( xEventGroup );
configASSERT( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
configASSERT( uxBitsToWaitFor != 0 );
#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
{
configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
}
#endif
vTaskSuspendAll();
{
const EventBits_t uxCurrentEventBits = pxEventBits->uxEventBits;
/* Check to see if the wait condition is already met or not. */
xWaitConditionMet = prvTestWaitCondition( uxCurrentEventBits, uxBitsToWaitFor, xWaitForAllBits );
if( xWaitConditionMet != pdFALSE )
{
/* The wait condition has already been met so there is no need to
block. */
uxReturn = uxCurrentEventBits;
xTicksToWait = ( TickType_t ) 0;
/* Clear the wait bits if requested to do so. */
if( xClearOnExit != pdFALSE )
{
pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
else if( xTicksToWait == ( TickType_t ) 0 )
{
/* The wait condition has not been met, but no block time was
specified, so just return the current value. */
uxReturn = uxCurrentEventBits;
}
else
{
/* The task is going to block to wait for its required bits to be
set. uxControlBits are used to remember the specified behaviour of
this call to xEventGroupWaitBits() - for use when the event bits
unblock the task. */
if( xClearOnExit != pdFALSE )
{
uxControlBits |= eventCLEAR_EVENTS_ON_EXIT_BIT;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
if( xWaitForAllBits != pdFALSE )
{
uxControlBits |= eventWAIT_FOR_ALL_BITS;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
/* Store the bits that the calling task is waiting for in the
task's event list item so the kernel knows when a match is
found. Then enter the blocked state. */
vTaskPlaceOnUnorderedEventList( &( pxEventBits->xTasksWaitingForBits ), ( uxBitsToWaitFor | uxControlBits ), xTicksToWait );
/* This is obsolete as it will get set after the task unblocks, but
some compilers mistakenly generate a warning about the variable
being returned without being set if it is not done. */
uxReturn = 0;
traceEVENT_GROUP_WAIT_BITS_BLOCK( xEventGroup, uxBitsToWaitFor );
}
}
xAlreadyYielded = xTaskResumeAll();
if( xTicksToWait != ( TickType_t ) 0 )
{
if( xAlreadyYielded == pdFALSE )
{
portYIELD_WITHIN_API();
}
else
{
mtCOVERAGE_TEST_MARKER();
}
/* The task blocked to wait for its required bits to be set - at this
point either the required bits were set or the block time expired. If
the required bits were set they will have been stored in the task's
event list item, and they should now be retrieved then cleared. */
uxReturn = uxTaskResetEventItemValue();
if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( EventBits_t ) 0 )
{
taskENTER_CRITICAL();
{
/* The task timed out, just return the current event bit value. */
uxReturn = pxEventBits->uxEventBits;
/* It is possible that the event bits were updated between this
task leaving the Blocked state and running again. */
if( prvTestWaitCondition( uxReturn, uxBitsToWaitFor, xWaitForAllBits ) != pdFALSE )
{
if( xClearOnExit != pdFALSE )
{
pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
taskEXIT_CRITICAL();
/* Prevent compiler warnings when trace macros are not used. */
xTimeoutOccurred = pdFALSE;
}
else
{
/* The task unblocked because the bits were set. */
}
/* The task blocked so control bits may have been set. */
uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;
}
traceEVENT_GROUP_WAIT_BITS_END( xEventGroup, uxBitsToWaitFor, xTimeoutOccurred );
return uxReturn;
}
/*-----------------------------------------------------------*/
EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )
{
EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;
EventBits_t uxReturn;
/* Check the user is not attempting to clear the bits used by the kernel
itself. */
configASSERT( xEventGroup );
configASSERT( ( uxBitsToClear & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
taskENTER_CRITICAL();
{
traceEVENT_GROUP_CLEAR_BITS( xEventGroup, uxBitsToClear );
/* The value returned is the event group value prior to the bits being
cleared. */
uxReturn = pxEventBits->uxEventBits;
/* Clear the bits. */
pxEventBits->uxEventBits &= ~uxBitsToClear;
}
taskEXIT_CRITICAL();
return uxReturn;
}
/*-----------------------------------------------------------*/
#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )
{
BaseType_t xReturn;
traceEVENT_GROUP_CLEAR_BITS_FROM_ISR( xEventGroup, uxBitsToClear );
xReturn = xTimerPendFunctionCallFromISR( vEventGroupClearBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToClear, NULL );
return xReturn;
}
#endif
/*-----------------------------------------------------------*/
EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup )
{
UBaseType_t uxSavedInterruptStatus;
EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;
EventBits_t uxReturn;
uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
{
uxReturn = pxEventBits->uxEventBits;
}
portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
return uxReturn;
}
/*-----------------------------------------------------------*/
EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet )
{
ListItem_t *pxListItem, *pxNext;
ListItem_t const *pxListEnd;
List_t *pxList;
EventBits_t uxBitsToClear = 0, uxBitsWaitedFor, uxControlBits;
EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;
BaseType_t xMatchFound = pdFALSE;
/* Check the user is not attempting to set the bits used by the kernel
itself. */
configASSERT( xEventGroup );
configASSERT( ( uxBitsToSet & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
pxList = &( pxEventBits->xTasksWaitingForBits );
pxListEnd = listGET_END_MARKER( pxList ); /*lint !e826 !e740 The mini list structure is used as the list end to save RAM. This is checked and valid. */
vTaskSuspendAll();
{
traceEVENT_GROUP_SET_BITS( xEventGroup, uxBitsToSet );
pxListItem = listGET_HEAD_ENTRY( pxList );
/* Set the bits. */
pxEventBits->uxEventBits |= uxBitsToSet;
/* See if the new bit value should unblock any tasks. */
while( pxListItem != pxListEnd )
{
pxNext = listGET_NEXT( pxListItem );
uxBitsWaitedFor = listGET_LIST_ITEM_VALUE( pxListItem );
xMatchFound = pdFALSE;
/* Split the bits waited for from the control bits. */
uxControlBits = uxBitsWaitedFor & eventEVENT_BITS_CONTROL_BYTES;
uxBitsWaitedFor &= ~eventEVENT_BITS_CONTROL_BYTES;
if( ( uxControlBits & eventWAIT_FOR_ALL_BITS ) == ( EventBits_t ) 0 )
{
/* Just looking for single bit being set. */
if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) != ( EventBits_t ) 0 )
{
xMatchFound = pdTRUE;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
else if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) == uxBitsWaitedFor )
{
/* All bits are set. */
xMatchFound = pdTRUE;
}
else
{
/* Need all bits to be set, but not all the bits were set. */
}
if( xMatchFound != pdFALSE )
{
/* The bits match. Should the bits be cleared on exit? */
if( ( uxControlBits & eventCLEAR_EVENTS_ON_EXIT_BIT ) != ( EventBits_t ) 0 )
{
uxBitsToClear |= uxBitsWaitedFor;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
/* Store the actual event flag value in the task's event list
item before removing the task from the event list. The
eventUNBLOCKED_DUE_TO_BIT_SET bit is set so the task knows
that is was unblocked due to its required bits matching, rather
than because it timed out. */
( void ) xTaskRemoveFromUnorderedEventList( pxListItem, pxEventBits->uxEventBits | eventUNBLOCKED_DUE_TO_BIT_SET );
}
/* Move onto the next list item. Note pxListItem->pxNext is not
used here as the list item may have been removed from the event list
and inserted into the ready/pending reading list. */
pxListItem = pxNext;
}
/* Clear any bits that matched when the eventCLEAR_EVENTS_ON_EXIT_BIT
bit was set in the control word. */
pxEventBits->uxEventBits &= ~uxBitsToClear;
}
( void ) xTaskResumeAll();
return pxEventBits->uxEventBits;
}
/*-----------------------------------------------------------*/
void vEventGroupDelete( EventGroupHandle_t xEventGroup )
{
EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;
const List_t *pxTasksWaitingForBits = &( pxEventBits->xTasksWaitingForBits );
vTaskSuspendAll();
{
traceEVENT_GROUP_DELETE( xEventGroup );
while( listCURRENT_LIST_LENGTH( pxTasksWaitingForBits ) > ( UBaseType_t ) 0 )
{
/* Unblock the task, returning 0 as the event list is being deleted
and cannot therefore have any bits set. */
configASSERT( pxTasksWaitingForBits->xListEnd.pxNext != ( ListItem_t * ) &( pxTasksWaitingForBits->xListEnd ) );
( void ) xTaskRemoveFromUnorderedEventList( pxTasksWaitingForBits->xListEnd.pxNext, eventUNBLOCKED_DUE_TO_BIT_SET );
}
#if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) )
{
/* The event group can only have been allocated dynamically - free
it again. */
vPortFree( pxEventBits );
}
#elif( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
{
/* The event group could have been allocated statically or
dynamically, so check before attempting to free the memory. */
if( pxEventBits->ucStaticallyAllocated == ( uint8_t ) pdFALSE )
{
vPortFree( pxEventBits );
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
}
( void ) xTaskResumeAll();
}
/*-----------------------------------------------------------*/
/* For internal use only - execute a 'set bits' command that was pended from
an interrupt. */
void vEventGroupSetBitsCallback( void *pvEventGroup, const uint32_t ulBitsToSet )
{
( void ) xEventGroupSetBits( pvEventGroup, ( EventBits_t ) ulBitsToSet );
}
/*-----------------------------------------------------------*/
/* For internal use only - execute a 'clear bits' command that was pended from
an interrupt. */
void vEventGroupClearBitsCallback( void *pvEventGroup, const uint32_t ulBitsToClear )
{
( void ) xEventGroupClearBits( pvEventGroup, ( EventBits_t ) ulBitsToClear );
}
/*-----------------------------------------------------------*/
static BaseType_t prvTestWaitCondition( const EventBits_t uxCurrentEventBits, const EventBits_t uxBitsToWaitFor, const BaseType_t xWaitForAllBits )
{
BaseType_t xWaitConditionMet = pdFALSE;
if( xWaitForAllBits == pdFALSE )
{
/* Task only has to wait for one bit within uxBitsToWaitFor to be
set. Is one already set? */
if( ( uxCurrentEventBits & uxBitsToWaitFor ) != ( EventBits_t ) 0 )
{
xWaitConditionMet = pdTRUE;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
else
{
/* Task has to wait for all the bits in uxBitsToWaitFor to be set.
Are they set already? */
if( ( uxCurrentEventBits & uxBitsToWaitFor ) == uxBitsToWaitFor )
{
xWaitConditionMet = pdTRUE;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
return xWaitConditionMet;
}
/*-----------------------------------------------------------*/
#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, BaseType_t *pxHigherPriorityTaskWoken )
{
BaseType_t xReturn;
traceEVENT_GROUP_SET_BITS_FROM_ISR( xEventGroup, uxBitsToSet );
xReturn = xTimerPendFunctionCallFromISR( vEventGroupSetBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToSet, pxHigherPriorityTaskWoken );
return xReturn;
}
#endif
/*-----------------------------------------------------------*/
#if (configUSE_TRACE_FACILITY == 1)
UBaseType_t uxEventGroupGetNumber( void* xEventGroup )
{
UBaseType_t xReturn;
EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;
if( xEventGroup == NULL )
{
xReturn = 0;
}
else
{
xReturn = pxEventBits->uxEventGroupNumber;
}
return xReturn;
}
#endif

1675
FreeRTOS/Source/include/FreeRTOS.h
View file

File diff suppressed because it is too large Load diff

16
FreeRTOS/Source/include/FreeRTOSConfig.h
View file

@ -34,13 +34,6 @@
#define configUSE_TICK_HOOK 0 #define configUSE_TICK_HOOK 0
#endif #endif
#ifndef configCPU_CLOCK_HZ #ifndef configCPU_CLOCK_HZ
/* This is the _default_ clock speed for the CPU. Can be either 80MHz
* or 160MHz, and the system will set the clock speed to match at startup.
Note that it's possible to change the clock speed at runtime, so you
can/should use sdk_system_get_cpu_frequency() in order to determine the
current CPU frequency, in preference to this macro.
*/
#define configCPU_CLOCK_HZ ( ( unsigned long ) 80000000 ) #define configCPU_CLOCK_HZ ( ( unsigned long ) 80000000 )
#endif #endif
#ifndef configTICK_RATE_HZ #ifndef configTICK_RATE_HZ
@ -88,6 +81,15 @@ current CPU frequency, in preference to this macro.
#define configUSE_TIMERS 1 #define configUSE_TIMERS 1
#endif #endif
#ifndef configUSE_QUEUE_SETS
#define configUSE_QUEUE_SETS 1
#endif
#ifndef configUSE_TASK_NOTIFICATIONS
#define configUSE_TASK_NOTIFICATIONS 1
#endif
#ifndef configUSE_COUNTING_SEMAPHORES
#define configUSE_COUNTING_SEMAPHORES 1
#endif
#if configUSE_TIMERS #if configUSE_TIMERS
#ifndef configTIMER_TASK_PRIORITY #ifndef configTIMER_TASK_PRIORITY

350
FreeRTOS/Source/include/StackMacros.h
View file

@ -1,179 +1,171 @@
/* /*
FreeRTOS V7.5.2 - Copyright (C) 2013 Real Time Engineers Ltd. FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.
All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
***************************************************************************
* * This file is part of the FreeRTOS distribution.
* FreeRTOS provides completely free yet professionally developed, *
* robust, strictly quality controlled, supported, and cross * FreeRTOS is free software; you can redistribute it and/or modify it under
* platform software that has become a de facto standard. * the terms of the GNU General Public License (version 2) as published by the
* * Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
* Help yourself get started quickly and support the FreeRTOS *
* project by purchasing a FreeRTOS tutorial book, reference * ***************************************************************************
* manual, or both from: http://www.FreeRTOS.org/Documentation * >>! NOTE: The modification to the GPL is included to allow you to !<<
* * >>! distribute a combined work that includes FreeRTOS without being !<<
* Thank you! * >>! obliged to provide the source code for proprietary components !<<
* * >>! outside of the FreeRTOS kernel. !<<
*************************************************************************** ***************************************************************************
This file is part of the FreeRTOS distribution. FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FreeRTOS is free software; you can redistribute it and/or modify it under FOR A PARTICULAR PURPOSE. Full license text is available on the following
the terms of the GNU General Public License (version 2) as published by the link: http://www.freertos.org/a00114.html
Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
***************************************************************************
>>! NOTE: The modification to the GPL is included to allow you to distribute * *
>>! a combined work that includes FreeRTOS without being obliged to provide * FreeRTOS provides completely free yet professionally developed, *
>>! the source code for proprietary components outside of the FreeRTOS * robust, strictly quality controlled, supported, and cross *
>>! kernel. * platform software that is more than just the market leader, it *
* is the industry's de facto standard. *
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY * *
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * Help yourself get started quickly while simultaneously helping *
FOR A PARTICULAR PURPOSE. Full license text is available from the following * to support the FreeRTOS project by purchasing a FreeRTOS *
link: http://www.freertos.org/a00114.html * tutorial book, reference manual, or both: *
* http://www.FreeRTOS.org/Documentation *
1 tab == 4 spaces! * *
***************************************************************************
***************************************************************************
* * http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
* Having a problem? Start by reading the FAQ "My application does * the FAQ page "My application does not run, what could be wrong?". Have you
* not run, what could be wrong?" * defined configASSERT()?
* *
* http://www.FreeRTOS.org/FAQHelp.html * http://www.FreeRTOS.org/support - In return for receiving this top quality
* * embedded software for free we request you assist our global community by
*************************************************************************** participating in the support forum.
http://www.FreeRTOS.org - Documentation, books, training, latest versions, http://www.FreeRTOS.org/training - Investing in training allows your team to
license and Real Time Engineers Ltd. contact details. be as productive as possible as early as possible. Now you can receive
FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products, Ltd, and the world's leading authority on the world's leading RTOS.
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
compatible FAT file system, and our tiny thread aware UDP/IP stack. http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High compatible FAT file system, and our tiny thread aware UDP/IP stack.
Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and middleware. http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
mission critical applications that require provable dependability. Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and commercial middleware.
1 tab == 4 spaces!
*/ http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and
#ifndef STACK_MACROS_H mission critical applications that require provable dependability.
#define STACK_MACROS_H
1 tab == 4 spaces!
/* */
* Call the stack overflow hook function if the stack of the task being swapped
* out is currently overflowed, or looks like it might have overflowed in the #ifndef STACK_MACROS_H
* past. #define STACK_MACROS_H
*
* Setting configCHECK_FOR_STACK_OVERFLOW to 1 will cause the macro to check /*
* the current stack state only - comparing the current top of stack value to * Call the stack overflow hook function if the stack of the task being swapped
* the stack limit. Setting configCHECK_FOR_STACK_OVERFLOW to greater than 1 * out is currently overflowed, or looks like it might have overflowed in the
* will also cause the last few stack bytes to be checked to ensure the value * past.
* to which the bytes were set when the task was created have not been *
* overwritten. Note this second test does not guarantee that an overflowed * Setting configCHECK_FOR_STACK_OVERFLOW to 1 will cause the macro to check
* stack will always be recognised. * the current stack state only - comparing the current top of stack value to
*/ * the stack limit. Setting configCHECK_FOR_STACK_OVERFLOW to greater than 1
* will also cause the last few stack bytes to be checked to ensure the value
/*-----------------------------------------------------------*/ * to which the bytes were set when the task was created have not been
* overwritten. Note this second test does not guarantee that an overflowed
#if( configCHECK_FOR_STACK_OVERFLOW == 0 ) * stack will always be recognised.
*/
/* FreeRTOSConfig.h is not set to check for stack overflows. */
#define taskFIRST_CHECK_FOR_STACK_OVERFLOW() /*-----------------------------------------------------------*/
#define taskSECOND_CHECK_FOR_STACK_OVERFLOW()
#if( ( configCHECK_FOR_STACK_OVERFLOW == 1 ) && ( portSTACK_GROWTH < 0 ) )
#endif /* configCHECK_FOR_STACK_OVERFLOW == 0 */
/*-----------------------------------------------------------*/ /* Only the current stack state is to be checked. */
#define taskCHECK_FOR_STACK_OVERFLOW() \
#if( configCHECK_FOR_STACK_OVERFLOW == 1 ) { \
/* Is the currently saved stack pointer within the stack limit? */ \
/* FreeRTOSConfig.h is only set to use the first method of if( pxCurrentTCB->pxTopOfStack <= pxCurrentTCB->pxStack ) \
overflow checking. */ { \
#define taskSECOND_CHECK_FOR_STACK_OVERFLOW() vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pxCurrentTCB->pcTaskName ); \
} \
#endif }
/*-----------------------------------------------------------*/
#endif /* configCHECK_FOR_STACK_OVERFLOW == 1 */
#if( ( configCHECK_FOR_STACK_OVERFLOW > 0 ) && ( portSTACK_GROWTH < 0 ) ) /*-----------------------------------------------------------*/
/* Only the current stack state is to be checked. */ #if( ( configCHECK_FOR_STACK_OVERFLOW == 1 ) && ( portSTACK_GROWTH > 0 ) )
#define taskFIRST_CHECK_FOR_STACK_OVERFLOW() \
{ \ /* Only the current stack state is to be checked. */
/* Is the currently saved stack pointer within the stack limit? */ \ #define taskCHECK_FOR_STACK_OVERFLOW() \
if( pxCurrentTCB->pxTopOfStack <= pxCurrentTCB->pxStack ) \ { \
{ \ \
vApplicationStackOverflowHook( ( xTaskHandle ) pxCurrentTCB, pxCurrentTCB->pcTaskName ); \ /* Is the currently saved stack pointer within the stack limit? */ \
} \ if( pxCurrentTCB->pxTopOfStack >= pxCurrentTCB->pxEndOfStack ) \
} { \
vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pxCurrentTCB->pcTaskName ); \
#endif /* configCHECK_FOR_STACK_OVERFLOW > 0 */ } \
/*-----------------------------------------------------------*/ }
#if( ( configCHECK_FOR_STACK_OVERFLOW > 0 ) && ( portSTACK_GROWTH > 0 ) ) #endif /* configCHECK_FOR_STACK_OVERFLOW == 1 */
/*-----------------------------------------------------------*/
/* Only the current stack state is to be checked. */
#define taskFIRST_CHECK_FOR_STACK_OVERFLOW() \ #if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) && ( portSTACK_GROWTH < 0 ) )
{ \
\ #define taskCHECK_FOR_STACK_OVERFLOW() \
/* Is the currently saved stack pointer within the stack limit? */ \ { \
if( pxCurrentTCB->pxTopOfStack >= pxCurrentTCB->pxEndOfStack ) \ const uint32_t * const pulStack = ( uint32_t * ) pxCurrentTCB->pxStack; \
{ \ const uint32_t ulCheckValue = ( uint32_t ) 0xa5a5a5a5; \
vApplicationStackOverflowHook( ( xTaskHandle ) pxCurrentTCB, pxCurrentTCB->pcTaskName ); \ \
} \ if( ( pulStack[ 0 ] != ulCheckValue ) || \
} ( pulStack[ 1 ] != ulCheckValue ) || \
( pulStack[ 2 ] != ulCheckValue ) || \
#endif /* configCHECK_FOR_STACK_OVERFLOW == 1 */ ( pulStack[ 3 ] != ulCheckValue ) ) \
/*-----------------------------------------------------------*/ { \
vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pxCurrentTCB->pcTaskName ); \
#if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) && ( portSTACK_GROWTH < 0 ) ) } \
}
#define taskSECOND_CHECK_FOR_STACK_OVERFLOW() \
{ \ #endif /* #if( configCHECK_FOR_STACK_OVERFLOW > 1 ) */
static const unsigned char ucExpectedStackBytes[] = { tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \ /*-----------------------------------------------------------*/
tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \
tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \ #if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) && ( portSTACK_GROWTH > 0 ) )
tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \
tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE }; \ #define taskCHECK_FOR_STACK_OVERFLOW() \
\ { \
\ int8_t *pcEndOfStack = ( int8_t * ) pxCurrentTCB->pxEndOfStack; \
/* Has the extremity of the task stack ever been written over? */ \ static const uint8_t ucExpectedStackBytes[] = { tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \
if( memcmp( ( void * ) pxCurrentTCB->pxStack, ( void * ) ucExpectedStackBytes, sizeof( ucExpectedStackBytes ) ) != 0 ) \ tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \
{ \ tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \
vApplicationStackOverflowHook( ( xTaskHandle ) pxCurrentTCB, pxCurrentTCB->pcTaskName ); \ tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \
} \ tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE }; \
} \
\
#endif /* #if( configCHECK_FOR_STACK_OVERFLOW > 1 ) */ pcEndOfStack -= sizeof( ucExpectedStackBytes ); \
/*-----------------------------------------------------------*/ \
/* Has the extremity of the task stack ever been written over? */ \
#if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) && ( portSTACK_GROWTH > 0 ) ) if( memcmp( ( void * ) pcEndOfStack, ( void * ) ucExpectedStackBytes, sizeof( ucExpectedStackBytes ) ) != 0 ) \
{ \
#define taskSECOND_CHECK_FOR_STACK_OVERFLOW() \ vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pxCurrentTCB->pcTaskName ); \
{ \ } \
char *pcEndOfStack = ( char * ) pxCurrentTCB->pxEndOfStack; \ }
static const unsigned char ucExpectedStackBytes[] = { tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \
tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \ #endif /* #if( configCHECK_FOR_STACK_OVERFLOW > 1 ) */
tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \ /*-----------------------------------------------------------*/
tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \
tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE }; \ /* Remove stack overflow macro if not being used. */
\ #ifndef taskCHECK_FOR_STACK_OVERFLOW
\ #define taskCHECK_FOR_STACK_OVERFLOW()
pcEndOfStack -= sizeof( ucExpectedStackBytes ); \ #endif
\
/* Has the extremity of the task stack ever been written over? */ \
if( memcmp( ( void * ) pcEndOfStack, ( void * ) ucExpectedStackBytes, sizeof( ucExpectedStackBytes ) ) != 0 ) \
{ \ #endif /* STACK_MACROS_H */
vApplicationStackOverflowHook( ( xTaskHandle ) pxCurrentTCB, pxCurrentTCB->pcTaskName ); \
} \
}
#endif /* #if( configCHECK_FOR_STACK_OVERFLOW > 1 ) */
/*-----------------------------------------------------------*/
#endif /* STACK_MACROS_H */

1519
FreeRTOS/Source/include/croutine.h
View file

File diff suppressed because it is too large Load diff

321
FreeRTOS/Source/include/deprecated_definitions.h Normal file
View file

@ -0,0 +1,321 @@
/*
FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.
All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
This file is part of the FreeRTOS distribution.
FreeRTOS is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License (version 2) as published by the
Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
***************************************************************************
>>! NOTE: The modification to the GPL is included to allow you to !<<
>>! distribute a combined work that includes FreeRTOS without being !<<
>>! obliged to provide the source code for proprietary components !<<
>>! outside of the FreeRTOS kernel. !<<
***************************************************************************
FreeRTOS 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. Full license text is available on the following
link: http://www.freertos.org/a00114.html
***************************************************************************
* *
* FreeRTOS provides completely free yet professionally developed, *
* robust, strictly quality controlled, supported, and cross *
* platform software that is more than just the market leader, it *
* is the industry's de facto standard. *
* *
* Help yourself get started quickly while simultaneously helping *
* to support the FreeRTOS project by purchasing a FreeRTOS *
* tutorial book, reference manual, or both: *
* http://www.FreeRTOS.org/Documentation *
* *
***************************************************************************
http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
the FAQ page "My application does not run, what could be wrong?". Have you
defined configASSERT()?
http://www.FreeRTOS.org/support - In return for receiving this top quality
embedded software for free we request you assist our global community by
participating in the support forum.
http://www.FreeRTOS.org/training - Investing in training allows your team to
be as productive as possible as early as possible. Now you can receive
FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
Ltd, and the world's leading authority on the world's leading RTOS.
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
compatible FAT file system, and our tiny thread aware UDP/IP stack.
http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and commercial middleware.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and
mission critical applications that require provable dependability.
1 tab == 4 spaces!
*/
#ifndef DEPRECATED_DEFINITIONS_H
#define DEPRECATED_DEFINITIONS_H
/* Each FreeRTOS port has a unique portmacro.h header file. Originally a
pre-processor definition was used to ensure the pre-processor found the correct
portmacro.h file for the port being used. That scheme was deprecated in favour
of setting the compiler's include path such that it found the correct
portmacro.h file - removing the need for the constant and allowing the
portmacro.h file to be located anywhere in relation to the port being used. The
definitions below remain in the code for backward compatibility only. New
projects should not use them. */
#ifdef OPEN_WATCOM_INDUSTRIAL_PC_PORT
#include "..\..\Source\portable\owatcom\16bitdos\pc\portmacro.h"
typedef void ( __interrupt __far *pxISR )();
#endif
#ifdef OPEN_WATCOM_FLASH_LITE_186_PORT
#include "..\..\Source\portable\owatcom\16bitdos\flsh186\portmacro.h"
typedef void ( __interrupt __far *pxISR )();
#endif
#ifdef GCC_MEGA_AVR
#include "../portable/GCC/ATMega323/portmacro.h"
#endif
#ifdef IAR_MEGA_AVR
#include "../portable/IAR/ATMega323/portmacro.h"
#endif
#ifdef MPLAB_PIC24_PORT
#include "../../Source/portable/MPLAB/PIC24_dsPIC/portmacro.h"
#endif
#ifdef MPLAB_DSPIC_PORT
#include "../../Source/portable/MPLAB/PIC24_dsPIC/portmacro.h"
#endif
#ifdef MPLAB_PIC18F_PORT
#include "../../Source/portable/MPLAB/PIC18F/portmacro.h"
#endif
#ifdef MPLAB_PIC32MX_PORT
#include "../../Source/portable/MPLAB/PIC32MX/portmacro.h"
#endif
#ifdef _FEDPICC
#include "libFreeRTOS/Include/portmacro.h"
#endif
#ifdef SDCC_CYGNAL
#include "../../Source/portable/SDCC/Cygnal/portmacro.h"
#endif
#ifdef GCC_ARM7
#include "../../Source/portable/GCC/ARM7_LPC2000/portmacro.h"
#endif
#ifdef GCC_ARM7_ECLIPSE
#include "portmacro.h"
#endif
#ifdef ROWLEY_LPC23xx
#include "../../Source/portable/GCC/ARM7_LPC23xx/portmacro.h"
#endif
#ifdef IAR_MSP430
#include "..\..\Source\portable\IAR\MSP430\portmacro.h"
#endif
#ifdef GCC_MSP430
#include "../../Source/portable/GCC/MSP430F449/portmacro.h"
#endif
#ifdef ROWLEY_MSP430
#include "../../Source/portable/Rowley/MSP430F449/portmacro.h"
#endif
#ifdef ARM7_LPC21xx_KEIL_RVDS
#include "..\..\Source\portable\RVDS\ARM7_LPC21xx\portmacro.h"
#endif
#ifdef SAM7_GCC
#include "../../Source/portable/GCC/ARM7_AT91SAM7S/portmacro.h"
#endif
#ifdef SAM7_IAR
#include "..\..\Source\portable\IAR\AtmelSAM7S64\portmacro.h"
#endif
#ifdef SAM9XE_IAR
#include "..\..\Source\portable\IAR\AtmelSAM9XE\portmacro.h"
#endif
#ifdef LPC2000_IAR
#include "..\..\Source\portable\IAR\LPC2000\portmacro.h"
#endif
#ifdef STR71X_IAR
#include "..\..\Source\portable\IAR\STR71x\portmacro.h"
#endif
#ifdef STR75X_IAR
#include "..\..\Source\portable\IAR\STR75x\portmacro.h"
#endif
#ifdef STR75X_GCC
#include "..\..\Source\portable\GCC\STR75x\portmacro.h"
#endif
#ifdef STR91X_IAR
#include "..\..\Source\portable\IAR\STR91x\portmacro.h"
#endif
#ifdef GCC_H8S
#include "../../Source/portable/GCC/H8S2329/portmacro.h"
#endif
#ifdef GCC_AT91FR40008
#include "../../Source/portable/GCC/ARM7_AT91FR40008/portmacro.h"
#endif
#ifdef RVDS_ARMCM3_LM3S102
#include "../../Source/portable/RVDS/ARM_CM3/portmacro.h"
#endif
#ifdef GCC_ARMCM3_LM3S102
#include "../../Source/portable/GCC/ARM_CM3/portmacro.h"
#endif
#ifdef GCC_ARMCM3
#include "../../Source/portable/GCC/ARM_CM3/portmacro.h"
#endif
#ifdef IAR_ARM_CM3
#include "../../Source/portable/IAR/ARM_CM3/portmacro.h"
#endif
#ifdef IAR_ARMCM3_LM
#include "../../Source/portable/IAR/ARM_CM3/portmacro.h"
#endif
#ifdef HCS12_CODE_WARRIOR
#include "../../Source/portable/CodeWarrior/HCS12/portmacro.h"
#endif
#ifdef MICROBLAZE_GCC
#include "../../Source/portable/GCC/MicroBlaze/portmacro.h"
#endif
#ifdef TERN_EE
#include "..\..\Source\portable\Paradigm\Tern_EE\small\portmacro.h"
#endif
#ifdef GCC_HCS12
#include "../../Source/portable/GCC/HCS12/portmacro.h"
#endif
#ifdef GCC_MCF5235
#include "../../Source/portable/GCC/MCF5235/portmacro.h"
#endif
#ifdef COLDFIRE_V2_GCC
#include "../../../Source/portable/GCC/ColdFire_V2/portmacro.h"
#endif
#ifdef COLDFIRE_V2_CODEWARRIOR
#include "../../Source/portable/CodeWarrior/ColdFire_V2/portmacro.h"
#endif
#ifdef GCC_PPC405
#include "../../Source/portable/GCC/PPC405_Xilinx/portmacro.h"
#endif
#ifdef GCC_PPC440
#include "../../Source/portable/GCC/PPC440_Xilinx/portmacro.h"
#endif
#ifdef _16FX_SOFTUNE
#include "..\..\Source\portable\Softune\MB96340\portmacro.h"
#endif
#ifdef BCC_INDUSTRIAL_PC_PORT
/* A short file name has to be used in place of the normal
FreeRTOSConfig.h when using the Borland compiler. */
#include "frconfig.h"
#include "..\portable\BCC\16BitDOS\PC\prtmacro.h"
typedef void ( __interrupt __far *pxISR )();
#endif
#ifdef BCC_FLASH_LITE_186_PORT
/* A short file name has to be used in place of the normal
FreeRTOSConfig.h when using the Borland compiler. */
#include "frconfig.h"
#include "..\portable\BCC\16BitDOS\flsh186\prtmacro.h"
typedef void ( __interrupt __far *pxISR )();
#endif
#ifdef __GNUC__
#ifdef __AVR32_AVR32A__
#include "portmacro.h"
#endif
#endif
#ifdef __ICCAVR32__
#ifdef __CORE__
#if __CORE__ == __AVR32A__
#include "portmacro.h"
#endif
#endif
#endif
#ifdef __91467D
#include "portmacro.h"
#endif
#ifdef __96340
#include "portmacro.h"
#endif
#ifdef __IAR_V850ES_Fx3__
#include "../../Source/portable/IAR/V850ES/portmacro.h"
#endif
#ifdef __IAR_V850ES_Jx3__
#include "../../Source/portable/IAR/V850ES/portmacro.h"
#endif
#ifdef __IAR_V850ES_Jx3_L__
#include "../../Source/portable/IAR/V850ES/portmacro.h"
#endif
#ifdef __IAR_V850ES_Jx2__
#include "../../Source/portable/IAR/V850ES/portmacro.h"
#endif
#ifdef __IAR_V850ES_Hx2__
#include "../../Source/portable/IAR/V850ES/portmacro.h"
#endif
#ifdef __IAR_78K0R_Kx3__
#include "../../Source/portable/IAR/78K0R/portmacro.h"
#endif
#ifdef __IAR_78K0R_Kx3L__
#include "../../Source/portable/IAR/78K0R/portmacro.h"
#endif
#endif /* DEPRECATED_DEFINITIONS_H */

797
FreeRTOS/Source/include/event_groups.h Normal file
View file

@ -0,0 +1,797 @@
/*
FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.
All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
This file is part of the FreeRTOS distribution.
FreeRTOS is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License (version 2) as published by the
Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
***************************************************************************
>>! NOTE: The modification to the GPL is included to allow you to !<<
>>! distribute a combined work that includes FreeRTOS without being !<<
>>! obliged to provide the source code for proprietary components !<<
>>! outside of the FreeRTOS kernel. !<<
***************************************************************************
FreeRTOS 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. Full license text is available on the following
link: http://www.freertos.org/a00114.html
***************************************************************************
* *
* FreeRTOS provides completely free yet professionally developed, *
* robust, strictly quality controlled, supported, and cross *
* platform software that is more than just the market leader, it *
* is the industry's de facto standard. *
* *
* Help yourself get started quickly while simultaneously helping *
* to support the FreeRTOS project by purchasing a FreeRTOS *
* tutorial book, reference manual, or both: *
* http://www.FreeRTOS.org/Documentation *
* *
***************************************************************************
http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
the FAQ page "My application does not run, what could be wrong?". Have you
defined configASSERT()?
http://www.FreeRTOS.org/support - In return for receiving this top quality
embedded software for free we request you assist our global community by
participating in the support forum.
http://www.FreeRTOS.org/training - Investing in training allows your team to
be as productive as possible as early as possible. Now you can receive
FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
Ltd, and the world's leading authority on the world's leading RTOS.
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
compatible FAT file system, and our tiny thread aware UDP/IP stack.
http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and commercial middleware.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and
mission critical applications that require provable dependability.
1 tab == 4 spaces!
*/
#ifndef EVENT_GROUPS_H
#define EVENT_GROUPS_H
#ifndef INC_FREERTOS_H
#error "include FreeRTOS.h" must appear in source files before "include event_groups.h"
#endif
/* FreeRTOS includes. */
#include "timers.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* An event group is a collection of bits to which an application can assign a
* meaning. For example, an application may create an event group to convey
* the status of various CAN bus related events in which bit 0 might mean "A CAN
* message has been received and is ready for processing", bit 1 might mean "The
* application has queued a message that is ready for sending onto the CAN
* network", and bit 2 might mean "It is time to send a SYNC message onto the
* CAN network" etc. A task can then test the bit values to see which events
* are active, and optionally enter the Blocked state to wait for a specified
* bit or a group of specified bits to be active. To continue the CAN bus
* example, a CAN controlling task can enter the Blocked state (and therefore
* not consume any processing time) until either bit 0, bit 1 or bit 2 are
* active, at which time the bit that was actually active would inform the task
* which action it had to take (process a received message, send a message, or
* send a SYNC).
*
* The event groups implementation contains intelligence to avoid race
* conditions that would otherwise occur were an application to use a simple
* variable for the same purpose. This is particularly important with respect
* to when a bit within an event group is to be cleared, and when bits have to
* be set and then tested atomically - as is the case where event groups are
* used to create a synchronisation point between multiple tasks (a
* 'rendezvous').
*
* \defgroup EventGroup
*/
/**
* event_groups.h
*
* Type by which event groups are referenced. For example, a call to
* xEventGroupCreate() returns an EventGroupHandle_t variable that can then
* be used as a parameter to other event group functions.
*
* \defgroup EventGroupHandle_t EventGroupHandle_t
* \ingroup EventGroup
*/
typedef void * EventGroupHandle_t;
/*
* The type that holds event bits always matches TickType_t - therefore the
* number of bits it holds is set by configUSE_16_BIT_TICKS (16 bits if set to 1,
* 32 bits if set to 0.
*
* \defgroup EventBits_t EventBits_t
* \ingroup EventGroup
*/
typedef TickType_t EventBits_t;
/**
* event_groups.h
*<pre>
EventGroupHandle_t xEventGroupCreate( void );
</pre>
*
* Create a new event group.
*
* Internally, within the FreeRTOS implementation, event groups use a [small]
* block of memory, in which the event group's structure is stored. If an event
* groups is created using xEventGropuCreate() then the required memory is
* automatically dynamically allocated inside the xEventGroupCreate() function.
* (see http://www.freertos.org/a00111.html). If an event group is created
* using xEventGropuCreateStatic() then the application writer must instead
* provide the memory that will get used by the event group.
* xEventGroupCreateStatic() therefore allows an event group to be created
* without using any dynamic memory allocation.
*
* Although event groups are not related to ticks, for internal implementation
* reasons the number of bits available for use in an event group is dependent
* on the configUSE_16_BIT_TICKS setting in FreeRTOSConfig.h. If
* configUSE_16_BIT_TICKS is 1 then each event group contains 8 usable bits (bit
* 0 to bit 7). If configUSE_16_BIT_TICKS is set to 0 then each event group has
* 24 usable bits (bit 0 to bit 23). The EventBits_t type is used to store
* event bits within an event group.
*
* @return If the event group was created then a handle to the event group is
* returned. If there was insufficient FreeRTOS heap available to create the
* event group then NULL is returned. See http://www.freertos.org/a00111.html
*
* Example usage:
<pre>
// Declare a variable to hold the created event group.
EventGroupHandle_t xCreatedEventGroup;
// Attempt to create the event group.
xCreatedEventGroup = xEventGroupCreate();
// Was the event group created successfully?
if( xCreatedEventGroup == NULL )
{
// The event group was not created because there was insufficient
// FreeRTOS heap available.
}
else
{
// The event group was created.
}
</pre>
* \defgroup xEventGroupCreate xEventGroupCreate
* \ingroup EventGroup
*/
#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
EventGroupHandle_t xEventGroupCreate( void ) PRIVILEGED_FUNCTION;
#endif
/**
* event_groups.h
*<pre>
EventGroupHandle_t xEventGroupCreateStatic( EventGroupHandle_t * pxEventGroupBuffer );
</pre>
*
* Create a new event group.
*
* Internally, within the FreeRTOS implementation, event groups use a [small]
* block of memory, in which the event group's structure is stored. If an event
* groups is created using xEventGropuCreate() then the required memory is
* automatically dynamically allocated inside the xEventGroupCreate() function.
* (see http://www.freertos.org/a00111.html). If an event group is created
* using xEventGropuCreateStatic() then the application writer must instead
* provide the memory that will get used by the event group.
* xEventGroupCreateStatic() therefore allows an event group to be created
* without using any dynamic memory allocation.
*
* Although event groups are not related to ticks, for internal implementation
* reasons the number of bits available for use in an event group is dependent
* on the configUSE_16_BIT_TICKS setting in FreeRTOSConfig.h. If
* configUSE_16_BIT_TICKS is 1 then each event group contains 8 usable bits (bit
* 0 to bit 7). If configUSE_16_BIT_TICKS is set to 0 then each event group has
* 24 usable bits (bit 0 to bit 23). The EventBits_t type is used to store
* event bits within an event group.
*
* @param pxEventGroupBuffer pxEventGroupBuffer must point to a variable of type
* StaticEventGroup_t, which will be then be used to hold the event group's data
* structures, removing the need for the memory to be allocated dynamically.
*
* @return If the event group was created then a handle to the event group is
* returned. If pxEventGroupBuffer was NULL then NULL is returned.
*
* Example usage:
<pre>
// StaticEventGroup_t is a publicly accessible structure that has the same
// size and alignment requirements as the real event group structure. It is
// provided as a mechanism for applications to know the size of the event
// group (which is dependent on the architecture and configuration file
// settings) without breaking the strict data hiding policy by exposing the
// real event group internals. This StaticEventGroup_t variable is passed
// into the xSemaphoreCreateEventGroupStatic() function and is used to store
// the event group's data structures
StaticEventGroup_t xEventGroupBuffer;
// Create the event group without dynamically allocating any memory.
xEventGroup = xEventGroupCreateStatic( &xEventGroupBuffer );
</pre>
*/
#if( configSUPPORT_STATIC_ALLOCATION == 1 )
EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer ) PRIVILEGED_FUNCTION;
#endif
/**
* event_groups.h
*<pre>
EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
const EventBits_t uxBitsToWaitFor,
const BaseType_t xClearOnExit,
const BaseType_t xWaitForAllBits,
const TickType_t xTicksToWait );
</pre>
*
* [Potentially] block to wait for one or more bits to be set within a
* previously created event group.
*
* This function cannot be called from an interrupt.
*
* @param xEventGroup The event group in which the bits are being tested. The
* event group must have previously been created using a call to
* xEventGroupCreate().
*
* @param uxBitsToWaitFor A bitwise value that indicates the bit or bits to test
* inside the event group. For example, to wait for bit 0 and/or bit 2 set
* uxBitsToWaitFor to 0x05. To wait for bits 0 and/or bit 1 and/or bit 2 set
* uxBitsToWaitFor to 0x07. Etc.
*
* @param xClearOnExit If xClearOnExit is set to pdTRUE then any bits within
* uxBitsToWaitFor that are set within the event group will be cleared before
* xEventGroupWaitBits() returns if the wait condition was met (if the function
* returns for a reason other than a timeout). If xClearOnExit is set to
* pdFALSE then the bits set in the event group are not altered when the call to
* xEventGroupWaitBits() returns.
*
* @param xWaitForAllBits If xWaitForAllBits is set to pdTRUE then
* xEventGroupWaitBits() will return when either all the bits in uxBitsToWaitFor
* are set or the specified block time expires. If xWaitForAllBits is set to
* pdFALSE then xEventGroupWaitBits() will return when any one of the bits set
* in uxBitsToWaitFor is set or the specified block time expires. The block
* time is specified by the xTicksToWait parameter.
*
* @param xTicksToWait The maximum amount of time (specified in 'ticks') to wait
* for one/all (depending on the xWaitForAllBits value) of the bits specified by
* uxBitsToWaitFor to become set.
*
* @return The value of the event group at the time either the bits being waited
* for became set, or the block time expired. Test the return value to know
* which bits were set. If xEventGroupWaitBits() returned because its timeout
* expired then not all the bits being waited for will be set. If
* xEventGroupWaitBits() returned because the bits it was waiting for were set
* then the returned value is the event group value before any bits were
* automatically cleared in the case that xClearOnExit parameter was set to
* pdTRUE.
*
* Example usage:
<pre>
#define BIT_0 ( 1 << 0 )
#define BIT_4 ( 1 << 4 )
void aFunction( EventGroupHandle_t xEventGroup )
{
EventBits_t uxBits;
const TickType_t xTicksToWait = 100 / portTICK_PERIOD_MS;
// Wait a maximum of 100ms for either bit 0 or bit 4 to be set within
// the event group. Clear the bits before exiting.
uxBits = xEventGroupWaitBits(
xEventGroup, // The event group being tested.
BIT_0 | BIT_4, // The bits within the event group to wait for.
pdTRUE, // BIT_0 and BIT_4 should be cleared before returning.
pdFALSE, // Don't wait for both bits, either bit will do.
xTicksToWait ); // Wait a maximum of 100ms for either bit to be set.
if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
{
// xEventGroupWaitBits() returned because both bits were set.
}
else if( ( uxBits & BIT_0 ) != 0 )
{
// xEventGroupWaitBits() returned because just BIT_0 was set.
}
else if( ( uxBits & BIT_4 ) != 0 )
{
// xEventGroupWaitBits() returned because just BIT_4 was set.
}
else
{
// xEventGroupWaitBits() returned because xTicksToWait ticks passed
// without either BIT_0 or BIT_4 becoming set.
}
}
</pre>
* \defgroup xEventGroupWaitBits xEventGroupWaitBits
* \ingroup EventGroup
*/
EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
/**
* event_groups.h
*<pre>
EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear );
</pre>
*
* Clear bits within an event group. This function cannot be called from an
* interrupt.
*
* @param xEventGroup The event group in which the bits are to be cleared.
*
* @param uxBitsToClear A bitwise value that indicates the bit or bits to clear
* in the event group. For example, to clear bit 3 only, set uxBitsToClear to
* 0x08. To clear bit 3 and bit 0 set uxBitsToClear to 0x09.
*
* @return The value of the event group before the specified bits were cleared.
*
* Example usage:
<pre>
#define BIT_0 ( 1 << 0 )
#define BIT_4 ( 1 << 4 )
void aFunction( EventGroupHandle_t xEventGroup )
{
EventBits_t uxBits;
// Clear bit 0 and bit 4 in xEventGroup.
uxBits = xEventGroupClearBits(
xEventGroup, // The event group being updated.
BIT_0 | BIT_4 );// The bits being cleared.
if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
{
// Both bit 0 and bit 4 were set before xEventGroupClearBits() was
// called. Both will now be clear (not set).
}
else if( ( uxBits & BIT_0 ) != 0 )
{
// Bit 0 was set before xEventGroupClearBits() was called. It will
// now be clear.
}
else if( ( uxBits & BIT_4 ) != 0 )
{
// Bit 4 was set before xEventGroupClearBits() was called. It will
// now be clear.
}
else
{
// Neither bit 0 nor bit 4 were set in the first place.
}
}
</pre>
* \defgroup xEventGroupClearBits xEventGroupClearBits
* \ingroup EventGroup
*/
EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear ) PRIVILEGED_FUNCTION;
/**
* event_groups.h
*<pre>
BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet );
</pre>
*
* A version of xEventGroupClearBits() that can be called from an interrupt.
*
* Setting bits in an event group is not a deterministic operation because there
* are an unknown number of tasks that may be waiting for the bit or bits being
* set. FreeRTOS does not allow nondeterministic operations to be performed
* while interrupts are disabled, so protects event groups that are accessed
* from tasks by suspending the scheduler rather than disabling interrupts. As
* a result event groups cannot be accessed directly from an interrupt service
* routine. Therefore xEventGroupClearBitsFromISR() sends a message to the
* timer task to have the clear operation performed in the context of the timer
* task.
*
* @param xEventGroup The event group in which the bits are to be cleared.
*
* @param uxBitsToClear A bitwise value that indicates the bit or bits to clear.
* For example, to clear bit 3 only, set uxBitsToClear to 0x08. To clear bit 3
* and bit 0 set uxBitsToClear to 0x09.
*
* @return If the request to execute the function was posted successfully then
* pdPASS is returned, otherwise pdFALSE is returned. pdFALSE will be returned
* if the timer service queue was full.
*
* Example usage:
<pre>
#define BIT_0 ( 1 << 0 )
#define BIT_4 ( 1 << 4 )
// An event group which it is assumed has already been created by a call to
// xEventGroupCreate().
EventGroupHandle_t xEventGroup;
void anInterruptHandler( void )
{
// Clear bit 0 and bit 4 in xEventGroup.
xResult = xEventGroupClearBitsFromISR(
xEventGroup, // The event group being updated.
BIT_0 | BIT_4 ); // The bits being set.
if( xResult == pdPASS )
{
// The message was posted successfully.
}
}
</pre>
* \defgroup xEventGroupClearBitsFromISR xEventGroupClearBitsFromISR
* \ingroup EventGroup
*/
#if( configUSE_TRACE_FACILITY == 1 )
BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet ) PRIVILEGED_FUNCTION;
#else
#define xEventGroupClearBitsFromISR( xEventGroup, uxBitsToClear ) xTimerPendFunctionCallFromISR( vEventGroupClearBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToClear, NULL )
#endif
/**
* event_groups.h
*<pre>
EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet );
</pre>
*
* Set bits within an event group.
* This function cannot be called from an interrupt. xEventGroupSetBitsFromISR()
* is a version that can be called from an interrupt.
*
* Setting bits in an event group will automatically unblock tasks that are
* blocked waiting for the bits.
*
* @param xEventGroup The event group in which the bits are to be set.
*
* @param uxBitsToSet A bitwise value that indicates the bit or bits to set.
* For example, to set bit 3 only, set uxBitsToSet to 0x08. To set bit 3
* and bit 0 set uxBitsToSet to 0x09.
*
* @return The value of the event group at the time the call to
* xEventGroupSetBits() returns. There are two reasons why the returned value
* might have the bits specified by the uxBitsToSet parameter cleared. First,
* if setting a bit results in a task that was waiting for the bit leaving the
* blocked state then it is possible the bit will be cleared automatically
* (see the xClearBitOnExit parameter of xEventGroupWaitBits()). Second, any
* unblocked (or otherwise Ready state) task that has a priority above that of
* the task that called xEventGroupSetBits() will execute and may change the
* event group value before the call to xEventGroupSetBits() returns.
*
* Example usage:
<pre>
#define BIT_0 ( 1 << 0 )
#define BIT_4 ( 1 << 4 )
void aFunction( EventGroupHandle_t xEventGroup )
{
EventBits_t uxBits;
// Set bit 0 and bit 4 in xEventGroup.
uxBits = xEventGroupSetBits(
xEventGroup, // The event group being updated.
BIT_0 | BIT_4 );// The bits being set.
if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
{
// Both bit 0 and bit 4 remained set when the function returned.
}
else if( ( uxBits & BIT_0 ) != 0 )
{
// Bit 0 remained set when the function returned, but bit 4 was
// cleared. It might be that bit 4 was cleared automatically as a
// task that was waiting for bit 4 was removed from the Blocked
// state.
}
else if( ( uxBits & BIT_4 ) != 0 )
{
// Bit 4 remained set when the function returned, but bit 0 was
// cleared. It might be that bit 0 was cleared automatically as a
// task that was waiting for bit 0 was removed from the Blocked
// state.
}
else
{
// Neither bit 0 nor bit 4 remained set. It might be that a task
// was waiting for both of the bits to be set, and the bits were
// cleared as the task left the Blocked state.
}
}
</pre>
* \defgroup xEventGroupSetBits xEventGroupSetBits
* \ingroup EventGroup
*/
EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet ) PRIVILEGED_FUNCTION;
/**
* event_groups.h
*<pre>
BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, BaseType_t *pxHigherPriorityTaskWoken );
</pre>
*
* A version of xEventGroupSetBits() that can be called from an interrupt.
*
* Setting bits in an event group is not a deterministic operation because there
* are an unknown number of tasks that may be waiting for the bit or bits being
* set. FreeRTOS does not allow nondeterministic operations to be performed in
* interrupts or from critical sections. Therefore xEventGroupSetBitsFromISR()
* sends a message to the timer task to have the set operation performed in the
* context of the timer task - where a scheduler lock is used in place of a
* critical section.
*
* @param xEventGroup The event group in which the bits are to be set.
*
* @param uxBitsToSet A bitwise value that indicates the bit or bits to set.
* For example, to set bit 3 only, set uxBitsToSet to 0x08. To set bit 3
* and bit 0 set uxBitsToSet to 0x09.
*
* @param pxHigherPriorityTaskWoken As mentioned above, calling this function
* will result in a message being sent to the timer daemon task. If the
* priority of the timer daemon task is higher than the priority of the
* currently running task (the task the interrupt interrupted) then
* *pxHigherPriorityTaskWoken will be set to pdTRUE by
* xEventGroupSetBitsFromISR(), indicating that a context switch should be
* requested before the interrupt exits. For that reason
* *pxHigherPriorityTaskWoken must be initialised to pdFALSE. See the
* example code below.
*
* @return If the request to execute the function was posted successfully then
* pdPASS is returned, otherwise pdFALSE is returned. pdFALSE will be returned
* if the timer service queue was full.
*
* Example usage:
<pre>
#define BIT_0 ( 1 << 0 )
#define BIT_4 ( 1 << 4 )
// An event group which it is assumed has already been created by a call to
// xEventGroupCreate().
EventGroupHandle_t xEventGroup;
void anInterruptHandler( void )
{
BaseType_t xHigherPriorityTaskWoken, xResult;
// xHigherPriorityTaskWoken must be initialised to pdFALSE.
xHigherPriorityTaskWoken = pdFALSE;
// Set bit 0 and bit 4 in xEventGroup.
xResult = xEventGroupSetBitsFromISR(
xEventGroup, // The event group being updated.
BIT_0 | BIT_4 // The bits being set.
&xHigherPriorityTaskWoken );
// Was the message posted successfully?
if( xResult == pdPASS )
{
// If xHigherPriorityTaskWoken is now set to pdTRUE then a context
// switch should be requested. The macro used is port specific and
// will be either portYIELD_FROM_ISR() or portEND_SWITCHING_ISR() -
// refer to the documentation page for the port being used.
portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
}
}
</pre>
* \defgroup xEventGroupSetBitsFromISR xEventGroupSetBitsFromISR
* \ingroup EventGroup
*/
#if( configUSE_TRACE_FACILITY == 1 )
BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, BaseType_t *pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
#else
#define xEventGroupSetBitsFromISR( xEventGroup, uxBitsToSet, pxHigherPriorityTaskWoken ) xTimerPendFunctionCallFromISR( vEventGroupSetBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToSet, pxHigherPriorityTaskWoken )
#endif
/**
* event_groups.h
*<pre>
EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
const EventBits_t uxBitsToSet,
const EventBits_t uxBitsToWaitFor,
TickType_t xTicksToWait );
</pre>
*
* Atomically set bits within an event group, then wait for a combination of
* bits to be set within the same event group. This functionality is typically
* used to synchronise multiple tasks, where each task has to wait for the other
* tasks to reach a synchronisation point before proceeding.
*
* This function cannot be used from an interrupt.
*
* The function will return before its block time expires if the bits specified
* by the uxBitsToWait parameter are set, or become set within that time. In
* this case all the bits specified by uxBitsToWait will be automatically
* cleared before the function returns.
*
* @param xEventGroup The event group in which the bits are being tested. The
* event group must have previously been created using a call to
* xEventGroupCreate().
*
* @param uxBitsToSet The bits to set in the event group before determining
* if, and possibly waiting for, all the bits specified by the uxBitsToWait
* parameter are set.
*
* @param uxBitsToWaitFor A bitwise value that indicates the bit or bits to test
* inside the event group. For example, to wait for bit 0 and bit 2 set
* uxBitsToWaitFor to 0x05. To wait for bits 0 and bit 1 and bit 2 set
* uxBitsToWaitFor to 0x07. Etc.
*
* @param xTicksToWait The maximum amount of time (specified in 'ticks') to wait
* for all of the bits specified by uxBitsToWaitFor to become set.
*
* @return The value of the event group at the time either the bits being waited
* for became set, or the block time expired. Test the return value to know
* which bits were set. If xEventGroupSync() returned because its timeout
* expired then not all the bits being waited for will be set. If
* xEventGroupSync() returned because all the bits it was waiting for were
* set then the returned value is the event group value before any bits were
* automatically cleared.
*
* Example usage:
<pre>
// Bits used by the three tasks.
#define TASK_0_BIT ( 1 << 0 )
#define TASK_1_BIT ( 1 << 1 )
#define TASK_2_BIT ( 1 << 2 )
#define ALL_SYNC_BITS ( TASK_0_BIT | TASK_1_BIT | TASK_2_BIT )
// Use an event group to synchronise three tasks. It is assumed this event
// group has already been created elsewhere.
EventGroupHandle_t xEventBits;
void vTask0( void *pvParameters )
{
EventBits_t uxReturn;
TickType_t xTicksToWait = 100 / portTICK_PERIOD_MS;
for( ;; )
{
// Perform task functionality here.
// Set bit 0 in the event flag to note this task has reached the
// sync point. The other two tasks will set the other two bits defined
// by ALL_SYNC_BITS. All three tasks have reached the synchronisation
// point when all the ALL_SYNC_BITS are set. Wait a maximum of 100ms
// for this to happen.
uxReturn = xEventGroupSync( xEventBits, TASK_0_BIT, ALL_SYNC_BITS, xTicksToWait );
if( ( uxReturn & ALL_SYNC_BITS ) == ALL_SYNC_BITS )
{
// All three tasks reached the synchronisation point before the call
// to xEventGroupSync() timed out.
}
}
}
void vTask1( void *pvParameters )
{
for( ;; )
{
// Perform task functionality here.
// Set bit 1 in the event flag to note this task has reached the
// synchronisation point. The other two tasks will set the other two
// bits defined by ALL_SYNC_BITS. All three tasks have reached the
// synchronisation point when all the ALL_SYNC_BITS are set. Wait
// indefinitely for this to happen.
xEventGroupSync( xEventBits, TASK_1_BIT, ALL_SYNC_BITS, portMAX_DELAY );
// xEventGroupSync() was called with an indefinite block time, so
// this task will only reach here if the syncrhonisation was made by all
// three tasks, so there is no need to test the return value.
}
}
void vTask2( void *pvParameters )
{
for( ;; )
{
// Perform task functionality here.
// Set bit 2 in the event flag to note this task has reached the
// synchronisation point. The other two tasks will set the other two
// bits defined by ALL_SYNC_BITS. All three tasks have reached the
// synchronisation point when all the ALL_SYNC_BITS are set. Wait
// indefinitely for this to happen.
xEventGroupSync( xEventBits, TASK_2_BIT, ALL_SYNC_BITS, portMAX_DELAY );
// xEventGroupSync() was called with an indefinite block time, so
// this task will only reach here if the syncrhonisation was made by all
// three tasks, so there is no need to test the return value.
}
}
</pre>
* \defgroup xEventGroupSync xEventGroupSync
* \ingroup EventGroup
*/
EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
/**
* event_groups.h
*<pre>
EventBits_t xEventGroupGetBits( EventGroupHandle_t xEventGroup );
</pre>
*
* Returns the current value of the bits in an event group. This function
* cannot be used from an interrupt.
*
* @param xEventGroup The event group being queried.
*
* @return The event group bits at the time xEventGroupGetBits() was called.
*
* \defgroup xEventGroupGetBits xEventGroupGetBits
* \ingroup EventGroup
*/
#define xEventGroupGetBits( xEventGroup ) xEventGroupClearBits( xEventGroup, 0 )
/**
* event_groups.h
*<pre>
EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup );
</pre>
*
* A version of xEventGroupGetBits() that can be called from an ISR.
*
* @param xEventGroup The event group being queried.
*
* @return The event group bits at the time xEventGroupGetBitsFromISR() was called.
*
* \defgroup xEventGroupGetBitsFromISR xEventGroupGetBitsFromISR
* \ingroup EventGroup
*/
EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup ) PRIVILEGED_FUNCTION;
/**
* event_groups.h
*<pre>
void xEventGroupDelete( EventGroupHandle_t xEventGroup );
</pre>
*
* Delete an event group that was previously created by a call to
* xEventGroupCreate(). Tasks that are blocked on the event group will be
* unblocked and obtain 0 as the event group's value.
*
* @param xEventGroup The event group being deleted.
*/
void vEventGroupDelete( EventGroupHandle_t xEventGroup ) PRIVILEGED_FUNCTION;
/* For internal use only. */
void vEventGroupSetBitsCallback( void *pvEventGroup, const uint32_t ulBitsToSet ) PRIVILEGED_FUNCTION;
void vEventGroupClearBitsCallback( void *pvEventGroup, const uint32_t ulBitsToClear ) PRIVILEGED_FUNCTION;
#if (configUSE_TRACE_FACILITY == 1)
UBaseType_t uxEventGroupGetNumber( void* xEventGroup ) PRIVILEGED_FUNCTION;
#endif
#ifdef __cplusplus
}
#endif
#endif /* EVENT_GROUPS_H */

831
FreeRTOS/Source/include/list.h
View file

@ -1,378 +1,453 @@
/* /*
FreeRTOS V7.5.2 - Copyright (C) 2013 Real Time Engineers Ltd. FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.
All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
***************************************************************************
* * This file is part of the FreeRTOS distribution.
* FreeRTOS provides completely free yet professionally developed, *
* robust, strictly quality controlled, supported, and cross * FreeRTOS is free software; you can redistribute it and/or modify it under
* platform software that has become a de facto standard. * the terms of the GNU General Public License (version 2) as published by the
* * Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
* Help yourself get started quickly and support the FreeRTOS *
* project by purchasing a FreeRTOS tutorial book, reference * ***************************************************************************
* manual, or both from: http://www.FreeRTOS.org/Documentation * >>! NOTE: The modification to the GPL is included to allow you to !<<
* * >>! distribute a combined work that includes FreeRTOS without being !<<
* Thank you! * >>! obliged to provide the source code for proprietary components !<<
* * >>! outside of the FreeRTOS kernel. !<<
*************************************************************************** ***************************************************************************
This file is part of the FreeRTOS distribution. FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FreeRTOS is free software; you can redistribute it and/or modify it under FOR A PARTICULAR PURPOSE. Full license text is available on the following
the terms of the GNU General Public License (version 2) as published by the link: http://www.freertos.org/a00114.html
Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
***************************************************************************
>>! NOTE: The modification to the GPL is included to allow you to distribute * *
>>! a combined work that includes FreeRTOS without being obliged to provide * FreeRTOS provides completely free yet professionally developed, *
>>! the source code for proprietary components outside of the FreeRTOS * robust, strictly quality controlled, supported, and cross *
>>! kernel. * platform software that is more than just the market leader, it *
* is the industry's de facto standard. *
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY * *
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * Help yourself get started quickly while simultaneously helping *
FOR A PARTICULAR PURPOSE. Full license text is available from the following * to support the FreeRTOS project by purchasing a FreeRTOS *
link: http://www.freertos.org/a00114.html * tutorial book, reference manual, or both: *
* http://www.FreeRTOS.org/Documentation *
1 tab == 4 spaces! * *
***************************************************************************
***************************************************************************
* * http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
* Having a problem? Start by reading the FAQ "My application does * the FAQ page "My application does not run, what could be wrong?". Have you
* not run, what could be wrong?" * defined configASSERT()?
* *
* http://www.FreeRTOS.org/FAQHelp.html * http://www.FreeRTOS.org/support - In return for receiving this top quality
* * embedded software for free we request you assist our global community by
*************************************************************************** participating in the support forum.
http://www.FreeRTOS.org - Documentation, books, training, latest versions, http://www.FreeRTOS.org/training - Investing in training allows your team to
license and Real Time Engineers Ltd. contact details. be as productive as possible as early as possible. Now you can receive
FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products, Ltd, and the world's leading authority on the world's leading RTOS.
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
compatible FAT file system, and our tiny thread aware UDP/IP stack. http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High compatible FAT file system, and our tiny thread aware UDP/IP stack.
Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and middleware. http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
mission critical applications that require provable dependability. Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and commercial middleware.
1 tab == 4 spaces!
*/ http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and
/* mission critical applications that require provable dependability.
* This is the list implementation used by the scheduler. While it is tailored
* heavily for the schedulers needs, it is also available for use by 1 tab == 4 spaces!
* application code. */
*
* xLists can only store pointers to xListItems. Each xListItem contains a /*
* numeric value (xItemValue). Most of the time the lists are sorted in * This is the list implementation used by the scheduler. While it is tailored
* descending item value order. * heavily for the schedulers needs, it is also available for use by
* * application code.
* Lists are created already containing one list item. The value of this *
* item is the maximum possible that can be stored, it is therefore always at * list_ts can only store pointers to list_item_ts. Each ListItem_t contains a
* the end of the list and acts as a marker. The list member pxHead always * numeric value (xItemValue). Most of the time the lists are sorted in
* points to this marker - even though it is at the tail of the list. This * descending item value order.
* is because the tail contains a wrap back pointer to the true head of *
* the list. * Lists are created already containing one list item. The value of this
* * item is the maximum possible that can be stored, it is therefore always at
* In addition to it's value, each list item contains a pointer to the next * the end of the list and acts as a marker. The list member pxHead always
* item in the list (pxNext), a pointer to the list it is in (pxContainer) * points to this marker - even though it is at the tail of the list. This
* and a pointer to back to the object that contains it. These later two * is because the tail contains a wrap back pointer to the true head of
* pointers are included for efficiency of list manipulation. There is * the list.
* effectively a two way link between the object containing the list item and *
* the list item itself. * In addition to it's value, each list item contains a pointer to the next
* * item in the list (pxNext), a pointer to the list it is in (pxContainer)
* * and a pointer to back to the object that contains it. These later two
* \page ListIntroduction List Implementation * pointers are included for efficiency of list manipulation. There is
* \ingroup FreeRTOSIntro * effectively a two way link between the object containing the list item and
*/ * the list item itself.
*
*
#ifndef LIST_H * \page ListIntroduction List Implementation
#define LIST_H * \ingroup FreeRTOSIntro
*/
/*
* The list structure members are modified from within interrupts, and therefore #ifndef INC_FREERTOS_H
* by rights should be declared volatile. However, they are only modified in a #error FreeRTOS.h must be included before list.h
* functionally atomic way (within critical sections of with the scheduler #endif
* suspended) and are either passed by reference into a function or indexed via
* a volatile variable. Therefore, in all use cases tested so far, the volatile #ifndef LIST_H
* qualifier can be omitted in order to provide a moderate performance #define LIST_H
* improvement without adversely affecting functional behaviour. The assembly
* instructions generated by the IAR, ARM and GCC compilers when the respective /*
* compiler's options were set for maximum optimisation has been inspected and * The list structure members are modified from within interrupts, and therefore
* deemed to be as intended. That said, as compiler technology advances, and * by rights should be declared volatile. However, they are only modified in a
* especially if aggressive cross module optimisation is used (a use case that * functionally atomic way (within critical sections of with the scheduler
* has not been exercised to any great extend) then it is feasible that the * suspended) and are either passed by reference into a function or indexed via
* volatile qualifier will be needed for correct optimisation. It is expected * a volatile variable. Therefore, in all use cases tested so far, the volatile
* that a compiler removing essential code because, without the volatile * qualifier can be omitted in order to provide a moderate performance
* qualifier on the list structure members and with aggressive cross module * improvement without adversely affecting functional behaviour. The assembly
* optimisation, the compiler deemed the code unnecessary will result in * instructions generated by the IAR, ARM and GCC compilers when the respective
* complete and obvious failure of the scheduler. If this is ever experienced * compiler's options were set for maximum optimisation has been inspected and
* then the volatile qualifier can be inserted in the relevant places within the * deemed to be as intended. That said, as compiler technology advances, and
* list structures by simply defining configLIST_VOLATILE to volatile in * especially if aggressive cross module optimisation is used (a use case that
* FreeRTOSConfig.h (as per the example at the bottom of this comment block). * has not been exercised to any great extend) then it is feasible that the
* If configLIST_VOLATILE is not defined then the preprocessor directives below * volatile qualifier will be needed for correct optimisation. It is expected
* will simply #define configLIST_VOLATILE away completely. * that a compiler removing essential code because, without the volatile
* * qualifier on the list structure members and with aggressive cross module
* To use volatile list structure members then add the following line to * optimisation, the compiler deemed the code unnecessary will result in
* FreeRTOSConfig.h (without the quotes): * complete and obvious failure of the scheduler. If this is ever experienced
* "#define configLIST_VOLATILE volatile" * then the volatile qualifier can be inserted in the relevant places within the
*/ * list structures by simply defining configLIST_VOLATILE to volatile in
#ifndef configLIST_VOLATILE * FreeRTOSConfig.h (as per the example at the bottom of this comment block).
#define configLIST_VOLATILE * If configLIST_VOLATILE is not defined then the preprocessor directives below
#endif /* configSUPPORT_CROSS_MODULE_OPTIMISATION */ * will simply #define configLIST_VOLATILE away completely.
*
#ifdef __cplusplus * To use volatile list structure members then add the following line to
extern "C" { * FreeRTOSConfig.h (without the quotes):
#endif * "#define configLIST_VOLATILE volatile"
/* */
* Definition of the only type of object that a list can contain. #ifndef configLIST_VOLATILE
*/ #define configLIST_VOLATILE
struct xLIST_ITEM #endif /* configSUPPORT_CROSS_MODULE_OPTIMISATION */
{
configLIST_VOLATILE portTickType xItemValue; /*< The value being listed. In most cases this is used to sort the list in descending order. */ #ifdef __cplusplus
struct xLIST_ITEM * configLIST_VOLATILE pxNext; /*< Pointer to the next xListItem in the list. */ extern "C" {
struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;/*< Pointer to the previous xListItem in the list. */ #endif
void * pvOwner; /*< Pointer to the object (normally a TCB) that contains the list item. There is therefore a two way link between the object containing the list item and the list item itself. */
void * configLIST_VOLATILE pvContainer; /*< Pointer to the list in which this list item is placed (if any). */ /* Macros that can be used to place known values within the list structures,
}; then check that the known values do not get corrupted during the execution of
typedef struct xLIST_ITEM xListItem; /* For some reason lint wants this as two separate definitions. */ the application. These may catch the list data structures being overwritten in
memory. They will not catch data errors caused by incorrect configuration or
struct xMINI_LIST_ITEM use of FreeRTOS.*/
{ #if( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 0 )
configLIST_VOLATILE portTickType xItemValue; /* Define the macros to do nothing. */
struct xLIST_ITEM * configLIST_VOLATILE pxNext; #define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE
struct xLIST_ITEM * configLIST_VOLATILE pxPrevious; #define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE
}; #define listFIRST_LIST_INTEGRITY_CHECK_VALUE
typedef struct xMINI_LIST_ITEM xMiniListItem; #define listSECOND_LIST_INTEGRITY_CHECK_VALUE
#define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )
/* #define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )
* Definition of the type of queue used by the scheduler. #define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList )
*/ #define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList )
typedef struct xLIST #define listTEST_LIST_ITEM_INTEGRITY( pxItem )
{ #define listTEST_LIST_INTEGRITY( pxList )
configLIST_VOLATILE unsigned portBASE_TYPE uxNumberOfItems; #else
xListItem * configLIST_VOLATILE pxIndex; /*< Used to walk through the list. Points to the last item returned by a call to pvListGetOwnerOfNextEntry (). */ /* Define macros that add new members into the list structures. */
xMiniListItem xListEnd; /*< List item that contains the maximum possible item value meaning it is always at the end of the list and is therefore used as a marker. */ #define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE TickType_t xListItemIntegrityValue1;
} xList; #define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE TickType_t xListItemIntegrityValue2;
#define listFIRST_LIST_INTEGRITY_CHECK_VALUE TickType_t xListIntegrityValue1;
/* #define listSECOND_LIST_INTEGRITY_CHECK_VALUE TickType_t xListIntegrityValue2;
* Access macro to set the owner of a list item. The owner of a list item
* is the object (usually a TCB) that contains the list item. /* Define macros that set the new structure members to known values. */
* #define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem ) ( pxItem )->xListItemIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
* \page listSET_LIST_ITEM_OWNER listSET_LIST_ITEM_OWNER #define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem ) ( pxItem )->xListItemIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
* \ingroup LinkedList #define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList ) ( pxList )->xListIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
*/ #define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList ) ( pxList )->xListIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
#define listSET_LIST_ITEM_OWNER( pxListItem, pxOwner ) ( ( pxListItem )->pvOwner = ( void * ) ( pxOwner ) )
/* Define macros that will assert if one of the structure members does not
/* contain its expected value. */
* Access macro to get the owner of a list item. The owner of a list item #define listTEST_LIST_ITEM_INTEGRITY( pxItem ) configASSERT( ( ( pxItem )->xListItemIntegrityValue1 == pdINTEGRITY_CHECK_VALUE ) && ( ( pxItem )->xListItemIntegrityValue2 == pdINTEGRITY_CHECK_VALUE ) )
* is the object (usually a TCB) that contains the list item. #define listTEST_LIST_INTEGRITY( pxList ) configASSERT( ( ( pxList )->xListIntegrityValue1 == pdINTEGRITY_CHECK_VALUE ) && ( ( pxList )->xListIntegrityValue2 == pdINTEGRITY_CHECK_VALUE ) )
* #endif /* configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES */
* \page listSET_LIST_ITEM_OWNER listSET_LIST_ITEM_OWNER
* \ingroup LinkedList
*/ /*
#define listGET_LIST_ITEM_OWNER( pxListItem ) ( pxListItem )->pvOwner * Definition of the only type of object that a list can contain.
*/
/* struct xLIST_ITEM
* Access macro to set the value of the list item. In most cases the value is {
* used to sort the list in descending order. listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
* configLIST_VOLATILE TickType_t xItemValue; /*< The value being listed. In most cases this is used to sort the list in descending order. */
* \page listSET_LIST_ITEM_VALUE listSET_LIST_ITEM_VALUE struct xLIST_ITEM * configLIST_VOLATILE pxNext; /*< Pointer to the next ListItem_t in the list. */
* \ingroup LinkedList struct xLIST_ITEM * configLIST_VOLATILE pxPrevious; /*< Pointer to the previous ListItem_t in the list. */
*/ void * pvOwner; /*< Pointer to the object (normally a TCB) that contains the list item. There is therefore a two way link between the object containing the list item and the list item itself. */
#define listSET_LIST_ITEM_VALUE( pxListItem, xValue ) ( ( pxListItem )->xItemValue = ( xValue ) ) void * configLIST_VOLATILE pvContainer; /*< Pointer to the list in which this list item is placed (if any). */
listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
/* };
* Access macro to retrieve the value of the list item. The value can typedef struct xLIST_ITEM ListItem_t; /* For some reason lint wants this as two separate definitions. */
* represent anything - for example a the priority of a task, or the time at
* which a task should be unblocked. struct xMINI_LIST_ITEM
* {
* \page listGET_LIST_ITEM_VALUE listGET_LIST_ITEM_VALUE listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
* \ingroup LinkedList configLIST_VOLATILE TickType_t xItemValue;
*/ struct xLIST_ITEM * configLIST_VOLATILE pxNext;
#define listGET_LIST_ITEM_VALUE( pxListItem ) ( ( pxListItem )->xItemValue ) struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;
};
/* typedef struct xMINI_LIST_ITEM MiniListItem_t;
* Access macro the retrieve the value of the list item at the head of a given
* list. /*
* * Definition of the type of queue used by the scheduler.
* \page listGET_LIST_ITEM_VALUE listGET_LIST_ITEM_VALUE */
* \ingroup LinkedList typedef struct xLIST
*/ {
#define listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxList ) ( (&( ( pxList )->xListEnd ))->pxNext->xItemValue ) listFIRST_LIST_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
configLIST_VOLATILE UBaseType_t uxNumberOfItems;
/* ListItem_t * configLIST_VOLATILE pxIndex; /*< Used to walk through the list. Points to the last item returned by a call to listGET_OWNER_OF_NEXT_ENTRY (). */
* Access macro to determine if a list contains any items. The macro will MiniListItem_t xListEnd; /*< List item that contains the maximum possible item value meaning it is always at the end of the list and is therefore used as a marker. */
* only have the value true if the list is empty. listSECOND_LIST_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
* } List_t;
* \page listLIST_IS_EMPTY listLIST_IS_EMPTY
* \ingroup LinkedList /*
*/ * Access macro to set the owner of a list item. The owner of a list item
#define listLIST_IS_EMPTY( pxList ) ( ( portBASE_TYPE ) ( ( pxList )->uxNumberOfItems == ( unsigned portBASE_TYPE ) 0 ) ) * is the object (usually a TCB) that contains the list item.
*
/* * \page listSET_LIST_ITEM_OWNER listSET_LIST_ITEM_OWNER
* Access macro to return the number of items in the list. * \ingroup LinkedList
*/ */
#define listCURRENT_LIST_LENGTH( pxList ) ( ( pxList )->uxNumberOfItems ) #define listSET_LIST_ITEM_OWNER( pxListItem, pxOwner ) ( ( pxListItem )->pvOwner = ( void * ) ( pxOwner ) )
/* /*
* Access function to obtain the owner of the next entry in a list. * Access macro to get the owner of a list item. The owner of a list item
* * is the object (usually a TCB) that contains the list item.
* The list member pxIndex is used to walk through a list. Calling *
* listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list * \page listSET_LIST_ITEM_OWNER listSET_LIST_ITEM_OWNER
* and returns that entries pxOwner parameter. Using multiple calls to this * \ingroup LinkedList
* function it is therefore possible to move through every item contained in */
* a list. #define listGET_LIST_ITEM_OWNER( pxListItem ) ( ( pxListItem )->pvOwner )
*
* The pxOwner parameter of a list item is a pointer to the object that owns /*
* the list item. In the scheduler this is normally a task control block. * Access macro to set the value of the list item. In most cases the value is
* The pxOwner parameter effectively creates a two way link between the list * used to sort the list in descending order.
* item and its owner. *
* * \page listSET_LIST_ITEM_VALUE listSET_LIST_ITEM_VALUE
* @param pxList The list from which the next item owner is to be returned. * \ingroup LinkedList
* */
* \page listGET_OWNER_OF_NEXT_ENTRY listGET_OWNER_OF_NEXT_ENTRY #define listSET_LIST_ITEM_VALUE( pxListItem, xValue ) ( ( pxListItem )->xItemValue = ( xValue ) )
* \ingroup LinkedList
*/ /*
#define listGET_OWNER_OF_NEXT_ENTRY( pxTCB, pxList ) \ * Access macro to retrieve the value of the list item. The value can
{ \ * represent anything - for example the priority of a task, or the time at
xList * const pxConstList = ( pxList ); \ * which a task should be unblocked.
/* Increment the index to the next item and return the item, ensuring */ \ *
/* we don't return the marker used at the end of the list. */ \ * \page listGET_LIST_ITEM_VALUE listGET_LIST_ITEM_VALUE
( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext; \ * \ingroup LinkedList
if( ( void * ) ( pxConstList )->pxIndex == ( void * ) &( ( pxConstList )->xListEnd ) ) \ */
{ \ #define listGET_LIST_ITEM_VALUE( pxListItem ) ( ( pxListItem )->xItemValue )
( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext; \
} \ /*
( pxTCB ) = ( pxConstList )->pxIndex->pvOwner; \ * Access macro to retrieve the value of the list item at the head of a given
} * list.
*
* \page listGET_LIST_ITEM_VALUE listGET_LIST_ITEM_VALUE
/* * \ingroup LinkedList
* Access function to obtain the owner of the first entry in a list. Lists */
* are normally sorted in ascending item value order. #define listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxList ) ( ( ( pxList )->xListEnd ).pxNext->xItemValue )
*
* This function returns the pxOwner member of the first item in the list. /*
* The pxOwner parameter of a list item is a pointer to the object that owns * Return the list item at the head of the list.
* the list item. In the scheduler this is normally a task control block. *
* The pxOwner parameter effectively creates a two way link between the list * \page listGET_HEAD_ENTRY listGET_HEAD_ENTRY
* item and its owner. * \ingroup LinkedList
* */
* @param pxList The list from which the owner of the head item is to be #define listGET_HEAD_ENTRY( pxList ) ( ( ( pxList )->xListEnd ).pxNext )
* returned.
* /*
* \page listGET_OWNER_OF_HEAD_ENTRY listGET_OWNER_OF_HEAD_ENTRY * Return the list item at the head of the list.
* \ingroup LinkedList *
*/ * \page listGET_NEXT listGET_NEXT
#define listGET_OWNER_OF_HEAD_ENTRY( pxList ) ( (&( ( pxList )->xListEnd ))->pxNext->pvOwner ) * \ingroup LinkedList
*/
/* #define listGET_NEXT( pxListItem ) ( ( pxListItem )->pxNext )
* Check to see if a list item is within a list. The list item maintains a
* "container" pointer that points to the list it is in. All this macro does /*
* is check to see if the container and the list match. * Return the list item that marks the end of the list
* *
* @param pxList The list we want to know if the list item is within. * \page listGET_END_MARKER listGET_END_MARKER
* @param pxListItem The list item we want to know if is in the list. * \ingroup LinkedList
* @return pdTRUE is the list item is in the list, otherwise pdFALSE. */
* pointer against #define listGET_END_MARKER( pxList ) ( ( ListItem_t const * ) ( &( ( pxList )->xListEnd ) ) )
*/
#define listIS_CONTAINED_WITHIN( pxList, pxListItem ) ( ( portBASE_TYPE ) ( ( pxListItem )->pvContainer == ( void * ) ( pxList ) ) ) /*
* Access macro to determine if a list contains any items. The macro will
/* * only have the value true if the list is empty.
* Return the list a list item is contained within (referenced from). *
* * \page listLIST_IS_EMPTY listLIST_IS_EMPTY
* @param pxListItem The list item being queried. * \ingroup LinkedList
* @return A pointer to the xList object that references the pxListItem */
*/ #define listLIST_IS_EMPTY( pxList ) ( ( BaseType_t ) ( ( pxList )->uxNumberOfItems == ( UBaseType_t ) 0 ) )
#define listLIST_ITEM_CONTAINER( pxListItem ) ( ( pxListItem )->pvContainer )
/*
/* * Access macro to return the number of items in the list.
* This provides a crude means of knowing if a list has been initialised, as */
* pxList->xListEnd.xItemValue is set to portMAX_DELAY by the vListInitialise() #define listCURRENT_LIST_LENGTH( pxList ) ( ( pxList )->uxNumberOfItems )
* function.
*/ /*
#define listLIST_IS_INITIALISED( pxList ) ( ( pxList )->xListEnd.xItemValue == portMAX_DELAY ) * Access function to obtain the owner of the next entry in a list.
*
/* * The list member pxIndex is used to walk through a list. Calling
* Must be called before a list is used! This initialises all the members * listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list
* of the list structure and inserts the xListEnd item into the list as a * and returns that entry's pxOwner parameter. Using multiple calls to this
* marker to the back of the list. * function it is therefore possible to move through every item contained in
* * a list.
* @param pxList Pointer to the list being initialised. *
* * The pxOwner parameter of a list item is a pointer to the object that owns
* \page vListInitialise vListInitialise * the list item. In the scheduler this is normally a task control block.
* \ingroup LinkedList * The pxOwner parameter effectively creates a two way link between the list
*/ * item and its owner.
void vListInitialise( xList * const pxList ); *
* @param pxTCB pxTCB is set to the address of the owner of the next list item.
/* * @param pxList The list from which the next item owner is to be returned.
* Must be called before a list item is used. This sets the list container to *
* null so the item does not think that it is already contained in a list. * \page listGET_OWNER_OF_NEXT_ENTRY listGET_OWNER_OF_NEXT_ENTRY
* * \ingroup LinkedList
* @param pxItem Pointer to the list item being initialised. */
* #define listGET_OWNER_OF_NEXT_ENTRY( pxTCB, pxList ) \
* \page vListInitialiseItem vListInitialiseItem { \
* \ingroup LinkedList List_t * const pxConstList = ( pxList ); \
*/ /* Increment the index to the next item and return the item, ensuring */ \
void vListInitialiseItem( xListItem * const pxItem ); /* we don't return the marker used at the end of the list. */ \
( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext; \
/* if( ( void * ) ( pxConstList )->pxIndex == ( void * ) &( ( pxConstList )->xListEnd ) ) \
* Insert a list item into a list. The item will be inserted into the list in { \
* a position determined by its item value (descending item value order). ( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext; \
* } \
* @param pxList The list into which the item is to be inserted. ( pxTCB ) = ( pxConstList )->pxIndex->pvOwner; \
* }
* @param pxNewListItem The item to that is to be placed in the list.
*
* \page vListInsert vListInsert /*
* \ingroup LinkedList * Access function to obtain the owner of the first entry in a list. Lists
*/ * are normally sorted in ascending item value order.
void vListInsert( xList * const pxList, xListItem * const pxNewListItem ); *
* This function returns the pxOwner member of the first item in the list.
/* * The pxOwner parameter of a list item is a pointer to the object that owns
* Insert a list item into a list. The item will be inserted in a position * the list item. In the scheduler this is normally a task control block.
* such that it will be the last item within the list returned by multiple * The pxOwner parameter effectively creates a two way link between the list
* calls to listGET_OWNER_OF_NEXT_ENTRY. * item and its owner.
* *
* The list member pvIndex is used to walk through a list. Calling * @param pxList The list from which the owner of the head item is to be
* listGET_OWNER_OF_NEXT_ENTRY increments pvIndex to the next item in the list. * returned.
* Placing an item in a list using vListInsertEnd effectively places the item *
* in the list position pointed to by pvIndex. This means that every other * \page listGET_OWNER_OF_HEAD_ENTRY listGET_OWNER_OF_HEAD_ENTRY
* item within the list will be returned by listGET_OWNER_OF_NEXT_ENTRY before * \ingroup LinkedList
* the pvIndex parameter again points to the item being inserted. */
* #define listGET_OWNER_OF_HEAD_ENTRY( pxList ) ( (&( ( pxList )->xListEnd ))->pxNext->pvOwner )
* @param pxList The list into which the item is to be inserted.
* /*
* @param pxNewListItem The list item to be inserted into the list. * Check to see if a list item is within a list. The list item maintains a
* * "container" pointer that points to the list it is in. All this macro does
* \page vListInsertEnd vListInsertEnd * is check to see if the container and the list match.
* \ingroup LinkedList *
*/ * @param pxList The list we want to know if the list item is within.
void vListInsertEnd( xList * const pxList, xListItem * const pxNewListItem ); * @param pxListItem The list item we want to know if is in the list.
* @return pdTRUE if the list item is in the list, otherwise pdFALSE.
/* */
* Remove an item from a list. The list item has a pointer to the list that #define listIS_CONTAINED_WITHIN( pxList, pxListItem ) ( ( BaseType_t ) ( ( pxListItem )->pvContainer == ( void * ) ( pxList ) ) )
* it is in, so only the list item need be passed into the function.
* /*
* @param uxListRemove The item to be removed. The item will remove itself from * Return the list a list item is contained within (referenced from).
* the list pointed to by it's pxContainer parameter. *
* * @param pxListItem The list item being queried.
* @return The number of items that remain in the list after the list item has * @return A pointer to the List_t object that references the pxListItem
* been removed. */
* #define listLIST_ITEM_CONTAINER( pxListItem ) ( ( pxListItem )->pvContainer )
* \page uxListRemove uxListRemove
* \ingroup LinkedList /*
*/ * This provides a crude means of knowing if a list has been initialised, as
unsigned portBASE_TYPE uxListRemove( xListItem * const pxItemToRemove ); * pxList->xListEnd.xItemValue is set to portMAX_DELAY by the vListInitialise()
* function.
#ifdef __cplusplus */
} #define listLIST_IS_INITIALISED( pxList ) ( ( pxList )->xListEnd.xItemValue == portMAX_DELAY )
#endif
/*
#endif * Must be called before a list is used! This initialises all the members
* of the list structure and inserts the xListEnd item into the list as a
* marker to the back of the list.
*
* @param pxList Pointer to the list being initialised.
*
* \page vListInitialise vListInitialise
* \ingroup LinkedList
*/
void vListInitialise( List_t * const pxList ) PRIVILEGED_FUNCTION;
/*
* Must be called before a list item is used. This sets the list container to
* null so the item does not think that it is already contained in a list.
*
* @param pxItem Pointer to the list item being initialised.
*
* \page vListInitialiseItem vListInitialiseItem
* \ingroup LinkedList
*/
void vListInitialiseItem( ListItem_t * const pxItem ) PRIVILEGED_FUNCTION;
/*
* Insert a list item into a list. The item will be inserted into the list in
* a position determined by its item value (descending item value order).
*
* @param pxList The list into which the item is to be inserted.
*
* @param pxNewListItem The item that is to be placed in the list.
*
* \page vListInsert vListInsert
* \ingroup LinkedList
*/
void vListInsert( List_t * const pxList, ListItem_t * const pxNewListItem ) PRIVILEGED_FUNCTION;
/*
* Insert a list item into a list. The item will be inserted in a position
* such that it will be the last item within the list returned by multiple
* calls to listGET_OWNER_OF_NEXT_ENTRY.
*
* The list member pxIndex is used to walk through a list. Calling
* listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list.
* Placing an item in a list using vListInsertEnd effectively places the item
* in the list position pointed to by pxIndex. This means that every other
* item within the list will be returned by listGET_OWNER_OF_NEXT_ENTRY before
* the pxIndex parameter again points to the item being inserted.
*
* @param pxList The list into which the item is to be inserted.
*
* @param pxNewListItem The list item to be inserted into the list.
*
* \page vListInsertEnd vListInsertEnd
* \ingroup LinkedList
*/
void vListInsertEnd( List_t * const pxList, ListItem_t * const pxNewListItem ) PRIVILEGED_FUNCTION;
/*
* Remove an item from a list. The list item has a pointer to the list that
* it is in, so only the list item need be passed into the function.
*
* @param uxListRemove The item to be removed. The item will remove itself from
* the list pointed to by it's pxContainer parameter.
*
* @return The number of items that remain in the list after the list item has
* been removed.
*
* \page uxListRemove uxListRemove
* \ingroup LinkedList
*/
UBaseType_t uxListRemove( ListItem_t * const pxItemToRemove ) PRIVILEGED_FUNCTION;
#ifdef __cplusplus
}
#endif
#endif

177
FreeRTOS/Source/include/mpu_prototypes.h Normal file
View file

@ -0,0 +1,177 @@
/*
FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.
All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
This file is part of the FreeRTOS distribution.
FreeRTOS is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License (version 2) as published by the
Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
***************************************************************************
>>! NOTE: The modification to the GPL is included to allow you to !<<
>>! distribute a combined work that includes FreeRTOS without being !<<
>>! obliged to provide the source code for proprietary components !<<
>>! outside of the FreeRTOS kernel. !<<
***************************************************************************
FreeRTOS 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. Full license text is available on the following
link: http://www.freertos.org/a00114.html
***************************************************************************
* *
* FreeRTOS provides completely free yet professionally developed, *
* robust, strictly quality controlled, supported, and cross *
* platform software that is more than just the market leader, it *
* is the industry's de facto standard. *
* *
* Help yourself get started quickly while simultaneously helping *
* to support the FreeRTOS project by purchasing a FreeRTOS *
* tutorial book, reference manual, or both: *
* http://www.FreeRTOS.org/Documentation *
* *
***************************************************************************
http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
the FAQ page "My application does not run, what could be wrong?". Have you
defined configASSERT()?
http://www.FreeRTOS.org/support - In return for receiving this top quality
embedded software for free we request you assist our global community by
participating in the support forum.
http://www.FreeRTOS.org/training - Investing in training allows your team to
be as productive as possible as early as possible. Now you can receive
FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
Ltd, and the world's leading authority on the world's leading RTOS.
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
compatible FAT file system, and our tiny thread aware UDP/IP stack.
http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and commercial middleware.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and
mission critical applications that require provable dependability.
1 tab == 4 spaces!
*/
/*
* When the MPU is used the standard (non MPU) API functions are mapped to
* equivalents that start "MPU_", the prototypes for which are defined in this
* header files. This will cause the application code to call the MPU_ version
* which wraps the non-MPU version with privilege promoting then demoting code,
* so the kernel code always runs will full privileges.
*/
#ifndef MPU_PROTOTYPES_H
#define MPU_PROTOTYPES_H
/* MPU versions of tasks.h API function. */
BaseType_t MPU_xTaskCreate( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask );
TaskHandle_t MPU_xTaskCreateStatic( TaskFunction_t pxTaskCode, const char * const pcName, const uint32_t ulStackDepth, void * const pvParameters, UBaseType_t uxPriority, StackType_t * const puxStackBuffer, StaticTask_t * const pxTaskBuffer );
BaseType_t MPU_xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask );
void MPU_vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const pxRegions );
void MPU_vTaskDelete( TaskHandle_t xTaskToDelete );
void MPU_vTaskDelay( const TickType_t xTicksToDelay );
void MPU_vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, const TickType_t xTimeIncrement );
BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask );
UBaseType_t MPU_uxTaskPriorityGet( TaskHandle_t xTask );
eTaskState MPU_eTaskGetState( TaskHandle_t xTask );
void MPU_vTaskGetInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState );
void MPU_vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority );
void MPU_vTaskSuspend( TaskHandle_t xTaskToSuspend );
void MPU_vTaskResume( TaskHandle_t xTaskToResume );
void MPU_vTaskStartScheduler( void );
void MPU_vTaskSuspendAll( void );
BaseType_t MPU_xTaskResumeAll( void );
TickType_t MPU_xTaskGetTickCount( void );
UBaseType_t MPU_uxTaskGetNumberOfTasks( void );
char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery );
TaskHandle_t MPU_xTaskGetHandle( const char *pcNameToQuery );
UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask );
void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxHookFunction );
TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask );
void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue );
void * MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery, BaseType_t xIndex );
BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter );
TaskHandle_t MPU_xTaskGetIdleTaskHandle( void );
UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray, const UBaseType_t uxArraySize, uint32_t * const pulTotalRunTime );
void MPU_vTaskList( char * pcWriteBuffer );
void MPU_vTaskGetRunTimeStats( char *pcWriteBuffer );
BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue );
BaseType_t MPU_xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );
uint32_t MPU_ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait );
BaseType_t MPU_xTaskNotifyStateClear( TaskHandle_t xTask );
BaseType_t MPU_xTaskIncrementTick( void );
TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void );
void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut );
BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait );
void MPU_vTaskMissedYield( void );
BaseType_t MPU_xTaskGetSchedulerState( void );
/* MPU versions of queue.h API function. */
BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, const BaseType_t xCopyPosition );
BaseType_t MPU_xQueueGenericReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait, const BaseType_t xJustPeek );
UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t xQueue );
UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue );
void MPU_vQueueDelete( QueueHandle_t xQueue );
QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType );
QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue );
QueueHandle_t MPU_xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount );
QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue );
void* MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore );
BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex, TickType_t xTicksToWait );
BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t pxMutex );
void MPU_vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcName );
void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue );
const char * MPU_pcQueueGetName( QueueHandle_t xQueue );
QueueHandle_t MPU_xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType );
QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType );
QueueSetHandle_t MPU_xQueueCreateSet( const UBaseType_t uxEventQueueLength );
BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet );
BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet );
QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet, const TickType_t xTicksToWait );
BaseType_t MPU_xQueueGenericReset( QueueHandle_t xQueue, BaseType_t xNewQueue );
void MPU_vQueueSetQueueNumber( QueueHandle_t xQueue, UBaseType_t uxQueueNumber );
UBaseType_t MPU_uxQueueGetQueueNumber( QueueHandle_t xQueue );
uint8_t MPU_ucQueueGetQueueType( QueueHandle_t xQueue );
/* MPU versions of timers.h API function. */
TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction );
TimerHandle_t MPU_xTimerCreateStatic( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction, StaticTimer_t *pxTimerBuffer );
void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer );
void MPU_vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID );
BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer );
TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void );
BaseType_t MPU_xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait );
const char * MPU_pcTimerGetName( TimerHandle_t xTimer );
TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer );
TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer );
BaseType_t MPU_xTimerCreateTimerTask( void );
BaseType_t MPU_xTimerGenericCommand( TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t * const pxHigherPriorityTaskWoken, const TickType_t xTicksToWait );
/* MPU versions of event_group.h API function. */
EventGroupHandle_t MPU_xEventGroupCreate( void );
EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer );
EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait );
EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear );
EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet );
EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait );
void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup );
UBaseType_t MPU_uxEventGroupGetNumber( void* xEventGroup );
#endif /* MPU_PROTOTYPES_H */

353
FreeRTOS/Source/include/mpu_wrappers.h
View file

@ -1,152 +1,201 @@
/* /*
FreeRTOS V7.5.2 - Copyright (C) 2013 Real Time Engineers Ltd. FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.
All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
***************************************************************************
* * This file is part of the FreeRTOS distribution.
* FreeRTOS provides completely free yet professionally developed, *
* robust, strictly quality controlled, supported, and cross * FreeRTOS is free software; you can redistribute it and/or modify it under
* platform software that has become a de facto standard. * the terms of the GNU General Public License (version 2) as published by the
* * Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
* Help yourself get started quickly and support the FreeRTOS *
* project by purchasing a FreeRTOS tutorial book, reference * ***************************************************************************
* manual, or both from: http://www.FreeRTOS.org/Documentation * >>! NOTE: The modification to the GPL is included to allow you to !<<
* * >>! distribute a combined work that includes FreeRTOS without being !<<
* Thank you! * >>! obliged to provide the source code for proprietary components !<<
* * >>! outside of the FreeRTOS kernel. !<<
*************************************************************************** ***************************************************************************
This file is part of the FreeRTOS distribution. FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FreeRTOS is free software; you can redistribute it and/or modify it under FOR A PARTICULAR PURPOSE. Full license text is available on the following
the terms of the GNU General Public License (version 2) as published by the link: http://www.freertos.org/a00114.html
Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
***************************************************************************
>>! NOTE: The modification to the GPL is included to allow you to distribute * *
>>! a combined work that includes FreeRTOS without being obliged to provide * FreeRTOS provides completely free yet professionally developed, *
>>! the source code for proprietary components outside of the FreeRTOS * robust, strictly quality controlled, supported, and cross *
>>! kernel. * platform software that is more than just the market leader, it *
* is the industry's de facto standard. *
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY * *
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * Help yourself get started quickly while simultaneously helping *
FOR A PARTICULAR PURPOSE. Full license text is available from the following * to support the FreeRTOS project by purchasing a FreeRTOS *
link: http://www.freertos.org/a00114.html * tutorial book, reference manual, or both: *
* http://www.FreeRTOS.org/Documentation *
1 tab == 4 spaces! * *
***************************************************************************
***************************************************************************
* * http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
* Having a problem? Start by reading the FAQ "My application does * the FAQ page "My application does not run, what could be wrong?". Have you
* not run, what could be wrong?" * defined configASSERT()?
* *
* http://www.FreeRTOS.org/FAQHelp.html * http://www.FreeRTOS.org/support - In return for receiving this top quality
* * embedded software for free we request you assist our global community by
*************************************************************************** participating in the support forum.
http://www.FreeRTOS.org - Documentation, books, training, latest versions, http://www.FreeRTOS.org/training - Investing in training allows your team to
license and Real Time Engineers Ltd. contact details. be as productive as possible as early as possible. Now you can receive
FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products, Ltd, and the world's leading authority on the world's leading RTOS.
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
compatible FAT file system, and our tiny thread aware UDP/IP stack. http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High compatible FAT file system, and our tiny thread aware UDP/IP stack.
Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and middleware. http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
mission critical applications that require provable dependability. Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and commercial middleware.
1 tab == 4 spaces!
*/ http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and
#ifndef MPU_WRAPPERS_H mission critical applications that require provable dependability.
#define MPU_WRAPPERS_H
1 tab == 4 spaces!
/* This file redefines API functions to be called through a wrapper macro, but */
only for ports that are using the MPU. */
#ifdef portUSING_MPU_WRAPPERS #ifndef MPU_WRAPPERS_H
#define MPU_WRAPPERS_H
/* MPU_WRAPPERS_INCLUDED_FROM_API_FILE will be defined when this file is
included from queue.c or task.c to prevent it from having an effect within /* This file redefines API functions to be called through a wrapper macro, but
those files. */ only for ports that are using the MPU. */
#ifndef MPU_WRAPPERS_INCLUDED_FROM_API_FILE #ifdef portUSING_MPU_WRAPPERS
#define xTaskGenericCreate MPU_xTaskGenericCreate /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE will be defined when this file is
#define vTaskAllocateMPURegions MPU_vTaskAllocateMPURegions included from queue.c or task.c to prevent it from having an effect within
#define vTaskDelete MPU_vTaskDelete those files. */
#define vTaskDelayUntil MPU_vTaskDelayUntil #ifndef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
#define vTaskDelay MPU_vTaskDelay
#define uxTaskPriorityGet MPU_uxTaskPriorityGet /*
#define vTaskPrioritySet MPU_vTaskPrioritySet * Map standard (non MPU) API functions to equivalents that start
#define eTaskGetState MPU_eTaskGetState * "MPU_". This will cause the application code to call the MPU_
#define vTaskSuspend MPU_vTaskSuspend * version, which wraps the non-MPU version with privilege promoting
#define xTaskIsTaskSuspended MPU_xTaskIsTaskSuspended * then demoting code, so the kernel code always runs will full
#define vTaskResume MPU_vTaskResume * privileges.
#define vTaskSuspendAll MPU_vTaskSuspendAll */
#define xTaskResumeAll MPU_xTaskResumeAll
#define xTaskGetTickCount MPU_xTaskGetTickCount /* Map standard tasks.h API functions to the MPU equivalents. */
#define uxTaskGetNumberOfTasks MPU_uxTaskGetNumberOfTasks #define xTaskCreate MPU_xTaskCreate
#define vTaskList MPU_vTaskList #define xTaskCreateStatic MPU_xTaskCreateStatic
#define vTaskGetRunTimeStats MPU_vTaskGetRunTimeStats #define xTaskCreateRestricted MPU_xTaskCreateRestricted
#define vTaskSetApplicationTaskTag MPU_vTaskSetApplicationTaskTag #define vTaskAllocateMPURegions MPU_vTaskAllocateMPURegions
#define xTaskGetApplicationTaskTag MPU_xTaskGetApplicationTaskTag #define vTaskDelete MPU_vTaskDelete
#define xTaskCallApplicationTaskHook MPU_xTaskCallApplicationTaskHook #define vTaskDelay MPU_vTaskDelay
#define uxTaskGetStackHighWaterMark MPU_uxTaskGetStackHighWaterMark #define vTaskDelayUntil MPU_vTaskDelayUntil
#define xTaskGetCurrentTaskHandle MPU_xTaskGetCurrentTaskHandle #define xTaskAbortDelay MPU_xTaskAbortDelay
#define xTaskGetSchedulerState MPU_xTaskGetSchedulerState #define uxTaskPriorityGet MPU_uxTaskPriorityGet
#define xTaskGetIdleTaskHandle MPU_xTaskGetIdleTaskHandle #define eTaskGetState MPU_eTaskGetState
#define uxTaskGetSystemState MPU_uxTaskGetSystemState #define vTaskGetInfo MPU_vTaskGetInfo
#define vTaskPrioritySet MPU_vTaskPrioritySet
#define xQueueGenericCreate MPU_xQueueGenericCreate #define vTaskSuspend MPU_vTaskSuspend
#define xQueueCreateMutex MPU_xQueueCreateMutex #define vTaskResume MPU_vTaskResume
#define xQueueGiveMutexRecursive MPU_xQueueGiveMutexRecursive #define vTaskSuspendAll MPU_vTaskSuspendAll
#define xQueueTakeMutexRecursive MPU_xQueueTakeMutexRecursive #define xTaskResumeAll MPU_xTaskResumeAll
#define xQueueCreateCountingSemaphore MPU_xQueueCreateCountingSemaphore #define xTaskGetTickCount MPU_xTaskGetTickCount
#define xQueueGenericSend MPU_xQueueGenericSend #define uxTaskGetNumberOfTasks MPU_uxTaskGetNumberOfTasks
#define xQueueAltGenericSend MPU_xQueueAltGenericSend #define pcTaskGetName MPU_pcTaskGetName
#define xQueueAltGenericReceive MPU_xQueueAltGenericReceive #define xTaskGetHandle MPU_xTaskGetHandle
#define xQueueGenericReceive MPU_xQueueGenericReceive #define uxTaskGetStackHighWaterMark MPU_uxTaskGetStackHighWaterMark
#define uxQueueMessagesWaiting MPU_uxQueueMessagesWaiting #define vTaskSetApplicationTaskTag MPU_vTaskSetApplicationTaskTag
#define vQueueDelete MPU_vQueueDelete #define xTaskGetApplicationTaskTag MPU_xTaskGetApplicationTaskTag
#define xQueueGenericReset MPU_xQueueGenericReset #define vTaskSetThreadLocalStoragePointer MPU_vTaskSetThreadLocalStoragePointer
#define xQueueCreateSet MPU_xQueueCreateSet #define pvTaskGetThreadLocalStoragePointer MPU_pvTaskGetThreadLocalStoragePointer
#define xQueueSelectFromSet MPU_xQueueSelectFromSet #define xTaskCallApplicationTaskHook MPU_xTaskCallApplicationTaskHook
#define xQueueAddToSet MPU_xQueueAddToSet #define xTaskGetIdleTaskHandle MPU_xTaskGetIdleTaskHandle
#define xQueueRemoveFromSet MPU_xQueueRemoveFromSet #define uxTaskGetSystemState MPU_uxTaskGetSystemState
#define xQueuePeekFromISR MPU_xQueuePeekFromISR #define vTaskList MPU_vTaskList
#define vTaskGetRunTimeStats MPU_vTaskGetRunTimeStats
#define pvPortMalloc MPU_pvPortMalloc #define xTaskGenericNotify MPU_xTaskGenericNotify
#define vPortFree MPU_vPortFree #define xTaskNotifyWait MPU_xTaskNotifyWait
#define xPortGetFreeHeapSize MPU_xPortGetFreeHeapSize #define ulTaskNotifyTake MPU_ulTaskNotifyTake
#define vPortInitialiseBlocks MPU_vPortInitialiseBlocks #define xTaskNotifyStateClear MPU_xTaskNotifyStateClear
#if configQUEUE_REGISTRY_SIZE > 0 #define xTaskGetCurrentTaskHandle MPU_xTaskGetCurrentTaskHandle
#define vQueueAddToRegistry MPU_vQueueAddToRegistry #define vTaskSetTimeOutState MPU_vTaskSetTimeOutState
#define vQueueUnregisterQueue MPU_vQueueUnregisterQueue #define xTaskCheckForTimeOut MPU_xTaskCheckForTimeOut
#endif #define xTaskGetSchedulerState MPU_xTaskGetSchedulerState
/* Remove the privileged function macro. */ /* Map standard queue.h API functions to the MPU equivalents. */
#define PRIVILEGED_FUNCTION #define xQueueGenericSend MPU_xQueueGenericSend
#define xQueueGenericReceive MPU_xQueueGenericReceive
#else /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */ #define uxQueueMessagesWaiting MPU_uxQueueMessagesWaiting
#define uxQueueSpacesAvailable MPU_uxQueueSpacesAvailable
/* Ensure API functions go in the privileged execution section. */ #define vQueueDelete MPU_vQueueDelete
#define PRIVILEGED_FUNCTION __attribute__((section("privileged_functions"))) #define xQueueCreateMutex MPU_xQueueCreateMutex
#define PRIVILEGED_DATA __attribute__((section("privileged_data"))) #define xQueueCreateMutexStatic MPU_xQueueCreateMutexStatic
#define xQueueCreateCountingSemaphore MPU_xQueueCreateCountingSemaphore
#endif /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */ #define xQueueCreateCountingSemaphoreStatic MPU_xQueueCreateCountingSemaphoreStatic
#define xQueueGetMutexHolder MPU_xQueueGetMutexHolder
#else /* portUSING_MPU_WRAPPERS */ #define xQueueTakeMutexRecursive MPU_xQueueTakeMutexRecursive
#define xQueueGiveMutexRecursive MPU_xQueueGiveMutexRecursive
#define PRIVILEGED_FUNCTION #define xQueueGenericCreate MPU_xQueueGenericCreate
#define PRIVILEGED_DATA #define xQueueGenericCreateStatic MPU_xQueueGenericCreateStatic
#define portUSING_MPU_WRAPPERS 0 #define xQueueCreateSet MPU_xQueueCreateSet
#define xQueueAddToSet MPU_xQueueAddToSet
#endif /* portUSING_MPU_WRAPPERS */ #define xQueueRemoveFromSet MPU_xQueueRemoveFromSet
#define xQueueSelectFromSet MPU_xQueueSelectFromSet
#define xQueueGenericReset MPU_xQueueGenericReset
#endif /* MPU_WRAPPERS_H */
#if( configQUEUE_REGISTRY_SIZE > 0 )
#define vQueueAddToRegistry MPU_vQueueAddToRegistry
#define vQueueUnregisterQueue MPU_vQueueUnregisterQueue
#define pcQueueGetName MPU_pcQueueGetName
#endif
/* Map standard timer.h API functions to the MPU equivalents. */
#define xTimerCreate MPU_xTimerCreate
#define xTimerCreateStatic MPU_xTimerCreateStatic
#define pvTimerGetTimerID MPU_pvTimerGetTimerID
#define vTimerSetTimerID MPU_vTimerSetTimerID
#define xTimerIsTimerActive MPU_xTimerIsTimerActive
#define xTimerGetTimerDaemonTaskHandle MPU_xTimerGetTimerDaemonTaskHandle
#define xTimerPendFunctionCall MPU_xTimerPendFunctionCall
#define pcTimerGetName MPU_pcTimerGetName
#define xTimerGetPeriod MPU_xTimerGetPeriod
#define xTimerGetExpiryTime MPU_xTimerGetExpiryTime
#define xTimerGenericCommand MPU_xTimerGenericCommand
/* Map standard event_group.h API functions to the MPU equivalents. */
#define xEventGroupCreate MPU_xEventGroupCreate
#define xEventGroupCreateStatic MPU_xEventGroupCreateStatic
#define xEventGroupWaitBits MPU_xEventGroupWaitBits
#define xEventGroupClearBits MPU_xEventGroupClearBits
#define xEventGroupSetBits MPU_xEventGroupSetBits
#define xEventGroupSync MPU_xEventGroupSync
#define vEventGroupDelete MPU_vEventGroupDelete
/* Remove the privileged function macro. */
#define PRIVILEGED_FUNCTION
#else /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */
/* Ensure API functions go in the privileged execution section. */
#define PRIVILEGED_FUNCTION __attribute__((section("privileged_functions")))
#define PRIVILEGED_DATA __attribute__((section("privileged_data")))
#endif /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */
#else /* portUSING_MPU_WRAPPERS */
#define PRIVILEGED_FUNCTION
#define PRIVILEGED_DATA
#define portUSING_MPU_WRAPPERS 0
#endif /* portUSING_MPU_WRAPPERS */
#endif /* MPU_WRAPPERS_H */

608
FreeRTOS/Source/include/portable.h
View file

@ -1,401 +1,207 @@
/* /*
FreeRTOS V7.5.2 - Copyright (C) 2013 Real Time Engineers Ltd. FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.
All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
***************************************************************************
* * This file is part of the FreeRTOS distribution.
* FreeRTOS provides completely free yet professionally developed, *
* robust, strictly quality controlled, supported, and cross * FreeRTOS is free software; you can redistribute it and/or modify it under
* platform software that has become a de facto standard. * the terms of the GNU General Public License (version 2) as published by the
* * Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
* Help yourself get started quickly and support the FreeRTOS *
* project by purchasing a FreeRTOS tutorial book, reference * ***************************************************************************
* manual, or both from: http://www.FreeRTOS.org/Documentation * >>! NOTE: The modification to the GPL is included to allow you to !<<
* * >>! distribute a combined work that includes FreeRTOS without being !<<
* Thank you! * >>! obliged to provide the source code for proprietary components !<<
* * >>! outside of the FreeRTOS kernel. !<<
*************************************************************************** ***************************************************************************
This file is part of the FreeRTOS distribution. FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FreeRTOS is free software; you can redistribute it and/or modify it under FOR A PARTICULAR PURPOSE. Full license text is available on the following
the terms of the GNU General Public License (version 2) as published by the link: http://www.freertos.org/a00114.html
Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
***************************************************************************
>>! NOTE: The modification to the GPL is included to allow you to distribute * *
>>! a combined work that includes FreeRTOS without being obliged to provide * FreeRTOS provides completely free yet professionally developed, *
>>! the source code for proprietary components outside of the FreeRTOS * robust, strictly quality controlled, supported, and cross *
>>! kernel. * platform software that is more than just the market leader, it *
* is the industry's de facto standard. *
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY * *
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * Help yourself get started quickly while simultaneously helping *
FOR A PARTICULAR PURPOSE. Full license text is available from the following * to support the FreeRTOS project by purchasing a FreeRTOS *
link: http://www.freertos.org/a00114.html * tutorial book, reference manual, or both: *
* http://www.FreeRTOS.org/Documentation *
1 tab == 4 spaces! * *
***************************************************************************
***************************************************************************
* * http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
* Having a problem? Start by reading the FAQ "My application does * the FAQ page "My application does not run, what could be wrong?". Have you
* not run, what could be wrong?" * defined configASSERT()?
* *
* http://www.FreeRTOS.org/FAQHelp.html * http://www.FreeRTOS.org/support - In return for receiving this top quality
* * embedded software for free we request you assist our global community by
*************************************************************************** participating in the support forum.
http://www.FreeRTOS.org - Documentation, books, training, latest versions, http://www.FreeRTOS.org/training - Investing in training allows your team to
license and Real Time Engineers Ltd. contact details. be as productive as possible as early as possible. Now you can receive
FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products, Ltd, and the world's leading authority on the world's leading RTOS.
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
compatible FAT file system, and our tiny thread aware UDP/IP stack. http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High compatible FAT file system, and our tiny thread aware UDP/IP stack.
Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and middleware. http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
mission critical applications that require provable dependability. Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and commercial middleware.
1 tab == 4 spaces!
*/ http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and
/*----------------------------------------------------------- mission critical applications that require provable dependability.
* Portable layer API. Each function must be defined for each port.
*----------------------------------------------------------*/ 1 tab == 4 spaces!
*/
#ifndef PORTABLE_H
#define PORTABLE_H /*-----------------------------------------------------------
* Portable layer API. Each function must be defined for each port.
/* Include the macro file relevant to the port being used. */ *----------------------------------------------------------*/
#ifdef OPEN_WATCOM_INDUSTRIAL_PC_PORT #ifndef PORTABLE_H
#include "..\..\Source\portable\owatcom\16bitdos\pc\portmacro.h" #define PORTABLE_H
typedef void ( __interrupt __far *pxISR )();
#endif /* Each FreeRTOS port has a unique portmacro.h header file. Originally a
pre-processor definition was used to ensure the pre-processor found the correct
#ifdef OPEN_WATCOM_FLASH_LITE_186_PORT portmacro.h file for the port being used. That scheme was deprecated in favour
#include "..\..\Source\portable\owatcom\16bitdos\flsh186\portmacro.h" of setting the compiler's include path such that it found the correct
typedef void ( __interrupt __far *pxISR )(); portmacro.h file - removing the need for the constant and allowing the
#endif portmacro.h file to be located anywhere in relation to the port being used.
Purely for reasons of backward compatibility the old method is still valid, but
#ifdef GCC_MEGA_AVR to make it clear that new projects should not use it, support for the port
#include "../portable/GCC/ATMega323/portmacro.h" specific constants has been moved into the deprecated_definitions.h header
#endif file. */
#include "deprecated_definitions.h"
#ifdef IAR_MEGA_AVR
#include "../portable/IAR/ATMega323/portmacro.h" /* If portENTER_CRITICAL is not defined then including deprecated_definitions.h
#endif did not result in a portmacro.h header file being included - and it should be
included here. In this case the path to the correct portmacro.h header file
#ifdef MPLAB_PIC24_PORT must be set in the compiler's include path. */
#include "..\..\Source\portable\MPLAB\PIC24_dsPIC\portmacro.h" #ifndef portENTER_CRITICAL
#endif #include "portmacro.h"
#endif
#ifdef MPLAB_DSPIC_PORT
#include "..\..\Source\portable\MPLAB\PIC24_dsPIC\portmacro.h" #if portBYTE_ALIGNMENT == 32
#endif #define portBYTE_ALIGNMENT_MASK ( 0x001f )
#endif
#ifdef MPLAB_PIC18F_PORT
#include "..\..\Source\portable\MPLAB\PIC18F\portmacro.h" #if portBYTE_ALIGNMENT == 16
#endif #define portBYTE_ALIGNMENT_MASK ( 0x000f )
#endif
#ifdef MPLAB_PIC32MX_PORT
#include "..\..\Source\portable\MPLAB\PIC32MX\portmacro.h" #if portBYTE_ALIGNMENT == 8
#endif #define portBYTE_ALIGNMENT_MASK ( 0x0007 )
#endif
#ifdef _FEDPICC
#include "libFreeRTOS/Include/portmacro.h" #if portBYTE_ALIGNMENT == 4
#endif #define portBYTE_ALIGNMENT_MASK ( 0x0003 )
#endif
#ifdef SDCC_CYGNAL
#include "../../Source/portable/SDCC/Cygnal/portmacro.h" #if portBYTE_ALIGNMENT == 2
#endif #define portBYTE_ALIGNMENT_MASK ( 0x0001 )
#endif
#ifdef GCC_ARM7
#include "../../Source/portable/GCC/ARM7_LPC2000/portmacro.h" #if portBYTE_ALIGNMENT == 1
#endif #define portBYTE_ALIGNMENT_MASK ( 0x0000 )
#endif
#ifdef GCC_ARM7_ECLIPSE
#include "portmacro.h" #ifndef portBYTE_ALIGNMENT_MASK
#endif #error "Invalid portBYTE_ALIGNMENT definition"
#endif
#ifdef ROWLEY_LPC23xx
#include "../../Source/portable/GCC/ARM7_LPC23xx/portmacro.h" #ifndef portNUM_CONFIGURABLE_REGIONS
#endif #define portNUM_CONFIGURABLE_REGIONS 1
#endif
#ifdef IAR_MSP430
#include "..\..\Source\portable\IAR\MSP430\portmacro.h" #ifdef __cplusplus
#endif extern "C" {
#endif
#ifdef GCC_MSP430
#include "../../Source/portable/GCC/MSP430F449/portmacro.h" #include "mpu_wrappers.h"
#endif
/*
#ifdef ROWLEY_MSP430 * Setup the stack of a new task so it is ready to be placed under the
#include "../../Source/portable/Rowley/MSP430F449/portmacro.h" * scheduler control. The registers have to be placed on the stack in
#endif * the order that the port expects to find them.
*
#ifdef ARM7_LPC21xx_KEIL_RVDS */
#include "..\..\Source\portable\RVDS\ARM7_LPC21xx\portmacro.h" #if( portUSING_MPU_WRAPPERS == 1 )
#endif StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, TaskFunction_t pxCode, void *pvParameters, BaseType_t xRunPrivileged ) PRIVILEGED_FUNCTION;
#else
#ifdef SAM7_GCC StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, TaskFunction_t pxCode, void *pvParameters ) PRIVILEGED_FUNCTION;
#include "../../Source/portable/GCC/ARM7_AT91SAM7S/portmacro.h" #endif
#endif
/* Used by heap_5.c. */
#ifdef SAM7_IAR typedef struct HeapRegion
#include "..\..\Source\portable\IAR\AtmelSAM7S64\portmacro.h" {
#endif uint8_t *pucStartAddress;
size_t xSizeInBytes;
#ifdef SAM9XE_IAR } HeapRegion_t;
#include "..\..\Source\portable\IAR\AtmelSAM9XE\portmacro.h"
#endif /*
* Used to define multiple heap regions for use by heap_5.c. This function
#ifdef LPC2000_IAR * must be called before any calls to pvPortMalloc() - not creating a task,
#include "..\..\Source\portable\IAR\LPC2000\portmacro.h" * queue, semaphore, mutex, software timer, event group, etc. will result in
#endif * pvPortMalloc being called.
*
#ifdef STR71X_IAR * pxHeapRegions passes in an array of HeapRegion_t structures - each of which
#include "..\..\Source\portable\IAR\STR71x\portmacro.h" * defines a region of memory that can be used as the heap. The array is
#endif * terminated by a HeapRegions_t structure that has a size of 0. The region
* with the lowest start address must appear first in the array.
#ifdef STR75X_IAR */
#include "..\..\Source\portable\IAR\STR75x\portmacro.h" void vPortDefineHeapRegions( const HeapRegion_t * const pxHeapRegions ) PRIVILEGED_FUNCTION;
#endif
#ifdef STR75X_GCC /*
#include "..\..\Source\portable\GCC\STR75x\portmacro.h" * Map to the memory management routines required for the port.
#endif */
void *pvPortMalloc( size_t xSize ) PRIVILEGED_FUNCTION;
#ifdef STR91X_IAR void vPortFree( void *pv ) PRIVILEGED_FUNCTION;
#include "..\..\Source\portable\IAR\STR91x\portmacro.h" void vPortInitialiseBlocks( void ) PRIVILEGED_FUNCTION;
#endif size_t xPortGetFreeHeapSize( void ) PRIVILEGED_FUNCTION;
size_t xPortGetMinimumEverFreeHeapSize( void ) PRIVILEGED_FUNCTION;
#ifdef GCC_H8S
#include "../../Source/portable/GCC/H8S2329/portmacro.h" /*
#endif * Setup the hardware ready for the scheduler to take control. This generally
* sets up a tick interrupt and sets timers for the correct tick frequency.
#ifdef GCC_AT91FR40008 */
#include "../../Source/portable/GCC/ARM7_AT91FR40008/portmacro.h" BaseType_t xPortStartScheduler( void ) PRIVILEGED_FUNCTION;
#endif
/*
#ifdef RVDS_ARMCM3_LM3S102 * Undo any hardware/ISR setup that was performed by xPortStartScheduler() so
#include "../../Source/portable/RVDS/ARM_CM3/portmacro.h" * the hardware is left in its original condition after the scheduler stops
#endif * executing.
*/
#ifdef GCC_ARMCM3_LM3S102 void vPortEndScheduler( void ) PRIVILEGED_FUNCTION;
#include "../../Source/portable/GCC/ARM_CM3/portmacro.h"
#endif /*
* The structures and methods of manipulating the MPU are contained within the
#ifdef GCC_ARMCM3 * port layer.
#include "../../Source/portable/GCC/ARM_CM3/portmacro.h" *
#endif * Fills the xMPUSettings structure with the memory region information
* contained in xRegions.
#ifdef IAR_ARM_CM3 */
#include "../../Source/portable/IAR/ARM_CM3/portmacro.h" #if( portUSING_MPU_WRAPPERS == 1 )
#endif struct xMEMORY_REGION;
void vPortStoreTaskMPUSettings( xMPU_SETTINGS *xMPUSettings, const struct xMEMORY_REGION * const xRegions, StackType_t *pxBottomOfStack, uint32_t ulStackDepth ) PRIVILEGED_FUNCTION;
#ifdef IAR_ARMCM3_LM #endif
#include "../../Source/portable/IAR/ARM_CM3/portmacro.h"
#endif #ifdef __cplusplus
}
#ifdef HCS12_CODE_WARRIOR #endif
#include "../../Source/portable/CodeWarrior/HCS12/portmacro.h"
#endif #endif /* PORTABLE_H */
#ifdef MICROBLAZE_GCC
#include "../../Source/portable/GCC/MicroBlaze/portmacro.h"
#endif
#ifdef TERN_EE
#include "..\..\Source\portable\Paradigm\Tern_EE\small\portmacro.h"
#endif
#ifdef GCC_HCS12
#include "../../Source/portable/GCC/HCS12/portmacro.h"
#endif
#ifdef GCC_MCF5235
#include "../../Source/portable/GCC/MCF5235/portmacro.h"
#endif
#ifdef COLDFIRE_V2_GCC
#include "../../../Source/portable/GCC/ColdFire_V2/portmacro.h"
#endif
#ifdef COLDFIRE_V2_CODEWARRIOR
#include "../../Source/portable/CodeWarrior/ColdFire_V2/portmacro.h"
#endif
#ifdef GCC_PPC405
#include "../../Source/portable/GCC/PPC405_Xilinx/portmacro.h"
#endif
#ifdef GCC_PPC440
#include "../../Source/portable/GCC/PPC440_Xilinx/portmacro.h"
#endif
#ifdef _16FX_SOFTUNE
#include "..\..\Source\portable\Softune\MB96340\portmacro.h"
#endif
#ifdef BCC_INDUSTRIAL_PC_PORT
/* A short file name has to be used in place of the normal
FreeRTOSConfig.h when using the Borland compiler. */
#include "frconfig.h"
#include "..\portable\BCC\16BitDOS\PC\prtmacro.h"
typedef void ( __interrupt __far *pxISR )();
#endif
#ifdef BCC_FLASH_LITE_186_PORT
/* A short file name has to be used in place of the normal
FreeRTOSConfig.h when using the Borland compiler. */
#include "frconfig.h"
#include "..\portable\BCC\16BitDOS\flsh186\prtmacro.h"
typedef void ( __interrupt __far *pxISR )();
#endif
#ifdef __GNUC__
#ifdef __AVR32_AVR32A__
#include "portmacro.h"
#endif
#endif
#ifdef __ICCAVR32__
#ifdef __CORE__
#if __CORE__ == __AVR32A__
#include "portmacro.h"
#endif
#endif
#endif
#ifdef __91467D
#include "portmacro.h"
#endif
#ifdef __96340
#include "portmacro.h"
#endif
#ifdef __IAR_V850ES_Fx3__
#include "../../Source/portable/IAR/V850ES/portmacro.h"
#endif
#ifdef __IAR_V850ES_Jx3__
#include "../../Source/portable/IAR/V850ES/portmacro.h"
#endif
#ifdef __IAR_V850ES_Jx3_L__
#include "../../Source/portable/IAR/V850ES/portmacro.h"
#endif
#ifdef __IAR_V850ES_Jx2__
#include "../../Source/portable/IAR/V850ES/portmacro.h"
#endif
#ifdef __IAR_V850ES_Hx2__
#include "../../Source/portable/IAR/V850ES/portmacro.h"
#endif
#ifdef __IAR_78K0R_Kx3__
#include "../../Source/portable/IAR/78K0R/portmacro.h"
#endif
#ifdef __IAR_78K0R_Kx3L__
#include "../../Source/portable/IAR/78K0R/portmacro.h"
#endif
/* Catch all to ensure portmacro.h is included in the build. Newer demos
have the path as part of the project options, rather than as relative from
the project location. If portENTER_CRITICAL() has not been defined then
portmacro.h has not yet been included - as every portmacro.h provides a
portENTER_CRITICAL() definition. Check the demo application for your demo
to find the path to the correct portmacro.h file. */
#ifndef portENTER_CRITICAL
#include "portmacro.h"
#endif
#if portBYTE_ALIGNMENT == 8
#define portBYTE_ALIGNMENT_MASK ( 0x0007 )
#endif
#if portBYTE_ALIGNMENT == 4
#define portBYTE_ALIGNMENT_MASK ( 0x0003 )
#endif
#if portBYTE_ALIGNMENT == 2
#define portBYTE_ALIGNMENT_MASK ( 0x0001 )
#endif
#if portBYTE_ALIGNMENT == 1
#define portBYTE_ALIGNMENT_MASK ( 0x0000 )
#endif
#ifndef portBYTE_ALIGNMENT_MASK
#error "Invalid portBYTE_ALIGNMENT definition"
#endif
#ifndef portNUM_CONFIGURABLE_REGIONS
#define portNUM_CONFIGURABLE_REGIONS 1
#endif
#ifdef __cplusplus
extern "C" {
#endif
#include "mpu_wrappers.h"
/*
* Setup the stack of a new task so it is ready to be placed under the
* scheduler control. The registers have to be placed on the stack in
* the order that the port expects to find them.
*
*/
#if( portUSING_MPU_WRAPPERS == 1 )
portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters, portBASE_TYPE xRunPrivileged ) PRIVILEGED_FUNCTION;
#else
portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters ) PRIVILEGED_FUNCTION;
#endif
/*
* Map to the memory management routines required for the port.
*/
void *pvPortMalloc( size_t xSize ) PRIVILEGED_FUNCTION;
void vPortFree( void *pv ) PRIVILEGED_FUNCTION;
void vPortInitialiseBlocks( void ) PRIVILEGED_FUNCTION;
size_t xPortGetFreeHeapSize( void ) PRIVILEGED_FUNCTION;
/*
* Setup the hardware ready for the scheduler to take control. This generally
* sets up a tick interrupt and sets timers for the correct tick frequency.
*/
portBASE_TYPE xPortStartScheduler( void ) PRIVILEGED_FUNCTION;
/*
* Undo any hardware/ISR setup that was performed by xPortStartScheduler() so
* the hardware is left in its original condition after the scheduler stops
* executing.
*/
void vPortEndScheduler( void ) PRIVILEGED_FUNCTION;
/*
* The structures and methods of manipulating the MPU are contained within the
* port layer.
*
* Fills the xMPUSettings structure with the memory region information
* contained in xRegions.
*/
#if( portUSING_MPU_WRAPPERS == 1 )
struct xMEMORY_REGION;
void vPortStoreTaskMPUSettings( xMPU_SETTINGS *xMPUSettings, const struct xMEMORY_REGION * const xRegions, portSTACK_TYPE *pxBottomOfStack, unsigned short usStackDepth ) PRIVILEGED_FUNCTION;
#endif
#ifdef __cplusplus
}
#endif
#endif /* PORTABLE_H */

249
FreeRTOS/Source/include/projdefs.h
View file

@ -1,88 +1,161 @@
/* /*
FreeRTOS V7.5.2 - Copyright (C) 2013 Real Time Engineers Ltd. FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.
All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
***************************************************************************
* * This file is part of the FreeRTOS distribution.
* FreeRTOS provides completely free yet professionally developed, *
* robust, strictly quality controlled, supported, and cross * FreeRTOS is free software; you can redistribute it and/or modify it under
* platform software that has become a de facto standard. * the terms of the GNU General Public License (version 2) as published by the
* * Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
* Help yourself get started quickly and support the FreeRTOS *
* project by purchasing a FreeRTOS tutorial book, reference * ***************************************************************************
* manual, or both from: http://www.FreeRTOS.org/Documentation * >>! NOTE: The modification to the GPL is included to allow you to !<<
* * >>! distribute a combined work that includes FreeRTOS without being !<<
* Thank you! * >>! obliged to provide the source code for proprietary components !<<
* * >>! outside of the FreeRTOS kernel. !<<
*************************************************************************** ***************************************************************************
This file is part of the FreeRTOS distribution. FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FreeRTOS is free software; you can redistribute it and/or modify it under FOR A PARTICULAR PURPOSE. Full license text is available on the following
the terms of the GNU General Public License (version 2) as published by the link: http://www.freertos.org/a00114.html
Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
***************************************************************************
>>! NOTE: The modification to the GPL is included to allow you to distribute * *
>>! a combined work that includes FreeRTOS without being obliged to provide * FreeRTOS provides completely free yet professionally developed, *
>>! the source code for proprietary components outside of the FreeRTOS * robust, strictly quality controlled, supported, and cross *
>>! kernel. * platform software that is more than just the market leader, it *
* is the industry's de facto standard. *
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY * *
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * Help yourself get started quickly while simultaneously helping *
FOR A PARTICULAR PURPOSE. Full license text is available from the following * to support the FreeRTOS project by purchasing a FreeRTOS *
link: http://www.freertos.org/a00114.html * tutorial book, reference manual, or both: *
* http://www.FreeRTOS.org/Documentation *
1 tab == 4 spaces! * *
***************************************************************************
***************************************************************************
* * http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
* Having a problem? Start by reading the FAQ "My application does * the FAQ page "My application does not run, what could be wrong?". Have you
* not run, what could be wrong?" * defined configASSERT()?
* *
* http://www.FreeRTOS.org/FAQHelp.html * http://www.FreeRTOS.org/support - In return for receiving this top quality
* * embedded software for free we request you assist our global community by
*************************************************************************** participating in the support forum.
http://www.FreeRTOS.org - Documentation, books, training, latest versions, http://www.FreeRTOS.org/training - Investing in training allows your team to
license and Real Time Engineers Ltd. contact details. be as productive as possible as early as possible. Now you can receive
FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products, Ltd, and the world's leading authority on the world's leading RTOS.
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
compatible FAT file system, and our tiny thread aware UDP/IP stack. http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High compatible FAT file system, and our tiny thread aware UDP/IP stack.
Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and middleware. http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
mission critical applications that require provable dependability. Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and commercial middleware.
1 tab == 4 spaces!
*/ http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and
#ifndef PROJDEFS_H mission critical applications that require provable dependability.
#define PROJDEFS_H
1 tab == 4 spaces!
/* Defines the prototype to which task functions must conform. */ */
typedef void (*pdTASK_CODE)( void * );
#ifndef PROJDEFS_H
#define pdFALSE ( ( portBASE_TYPE ) 0 ) #define PROJDEFS_H
#define pdTRUE ( ( portBASE_TYPE ) 1 )
/*
#define pdPASS ( pdTRUE ) * Defines the prototype to which task functions must conform. Defined in this
#define pdFAIL ( pdFALSE ) * file to ensure the type is known before portable.h is included.
#define errQUEUE_EMPTY ( ( portBASE_TYPE ) 0 ) */
#define errQUEUE_FULL ( ( portBASE_TYPE ) 0 ) typedef void (*TaskFunction_t)( void * );
/* Error definitions. */ /* Converts a time in milliseconds to a time in ticks. This macro can be
#define errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY ( -1 ) overridden by a macro of the same name defined in FreeRTOSConfig.h in case the
#define errNO_TASK_TO_RUN ( -2 ) definition here is not suitable for your application. */
#define errQUEUE_BLOCKED ( -4 ) #ifndef pdMS_TO_TICKS
#define errQUEUE_YIELD ( -5 ) #define pdMS_TO_TICKS( xTimeInMs ) ( ( TickType_t ) ( ( ( TickType_t ) ( xTimeInMs ) * ( TickType_t ) configTICK_RATE_HZ ) / ( TickType_t ) 1000 ) )
#endif
#endif /* PROJDEFS_H */
#define pdFALSE ( ( BaseType_t ) 0 )
#define pdTRUE ( ( BaseType_t ) 1 )
#define pdPASS ( pdTRUE )
#define pdFAIL ( pdFALSE )
#define errQUEUE_EMPTY ( ( BaseType_t ) 0 )
#define errQUEUE_FULL ( ( BaseType_t ) 0 )
/* FreeRTOS error definitions. */
#define errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY ( -1 )
#define errQUEUE_BLOCKED ( -4 )
#define errQUEUE_YIELD ( -5 )
/* Macros used for basic data corruption checks. */
#ifndef configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES
#define configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES 0
#endif
#if( configUSE_16_BIT_TICKS == 1 )
#define pdINTEGRITY_CHECK_VALUE 0x5a5a
#else
#define pdINTEGRITY_CHECK_VALUE 0x5a5a5a5aUL
#endif
/* The following errno values are used by FreeRTOS+ components, not FreeRTOS
itself. */
#define pdFREERTOS_ERRNO_NONE 0 /* No errors */
#define pdFREERTOS_ERRNO_ENOENT 2 /* No such file or directory */
#define pdFREERTOS_ERRNO_EINTR 4 /* Interrupted system call */
#define pdFREERTOS_ERRNO_EIO 5 /* I/O error */
#define pdFREERTOS_ERRNO_ENXIO 6 /* No such device or address */
#define pdFREERTOS_ERRNO_EBADF 9 /* Bad file number */
#define pdFREERTOS_ERRNO_EAGAIN 11 /* No more processes */
#define pdFREERTOS_ERRNO_EWOULDBLOCK 11 /* Operation would block */
#define pdFREERTOS_ERRNO_ENOMEM 12 /* Not enough memory */
#define pdFREERTOS_ERRNO_EACCES 13 /* Permission denied */
#define pdFREERTOS_ERRNO_EFAULT 14 /* Bad address */
#define pdFREERTOS_ERRNO_EBUSY 16 /* Mount device busy */
#define pdFREERTOS_ERRNO_EEXIST 17 /* File exists */
#define pdFREERTOS_ERRNO_EXDEV 18 /* Cross-device link */
#define pdFREERTOS_ERRNO_ENODEV 19 /* No such device */
#define pdFREERTOS_ERRNO_ENOTDIR 20 /* Not a directory */
#define pdFREERTOS_ERRNO_EISDIR 21 /* Is a directory */
#define pdFREERTOS_ERRNO_EINVAL 22 /* Invalid argument */
#define pdFREERTOS_ERRNO_ENOSPC 28 /* No space left on device */
#define pdFREERTOS_ERRNO_ESPIPE 29 /* Illegal seek */
#define pdFREERTOS_ERRNO_EROFS 30 /* Read only file system */
#define pdFREERTOS_ERRNO_EUNATCH 42 /* Protocol driver not attached */
#define pdFREERTOS_ERRNO_EBADE 50 /* Invalid exchange */
#define pdFREERTOS_ERRNO_EFTYPE 79 /* Inappropriate file type or format */
#define pdFREERTOS_ERRNO_ENMFILE 89 /* No more files */
#define pdFREERTOS_ERRNO_ENOTEMPTY 90 /* Directory not empty */
#define pdFREERTOS_ERRNO_ENAMETOOLONG 91 /* File or path name too long */
#define pdFREERTOS_ERRNO_EOPNOTSUPP 95 /* Operation not supported on transport endpoint */
#define pdFREERTOS_ERRNO_ENOBUFS 105 /* No buffer space available */
#define pdFREERTOS_ERRNO_ENOPROTOOPT 109 /* Protocol not available */
#define pdFREERTOS_ERRNO_EADDRINUSE 112 /* Address already in use */
#define pdFREERTOS_ERRNO_ETIMEDOUT 116 /* Connection timed out */
#define pdFREERTOS_ERRNO_EINPROGRESS 119 /* Connection already in progress */
#define pdFREERTOS_ERRNO_EALREADY 120 /* Socket already connected */
#define pdFREERTOS_ERRNO_EADDRNOTAVAIL 125 /* Address not available */
#define pdFREERTOS_ERRNO_EISCONN 127 /* Socket is already connected */
#define pdFREERTOS_ERRNO_ENOTCONN 128 /* Socket is not connected */
#define pdFREERTOS_ERRNO_ENOMEDIUM 135 /* No medium inserted */
#define pdFREERTOS_ERRNO_EILSEQ 138 /* An invalid UTF-16 sequence was encountered. */
#define pdFREERTOS_ERRNO_ECANCELED 140 /* Operation canceled. */
/* The following endian values are used by FreeRTOS+ components, not FreeRTOS
itself. */
#define pdFREERTOS_LITTLE_ENDIAN 0
#define pdFREERTOS_BIG_ENDIAN 1
#endif /* PROJDEFS_H */

3465
FreeRTOS/Source/include/queue.h
View file

File diff suppressed because it is too large Load diff

1956
FreeRTOS/Source/include/semphr.h
View file

File diff suppressed because it is too large Load diff

27
FreeRTOS/Source/include/stdint.readme Normal file
View file

@ -0,0 +1,27 @@
#ifndef FREERTOS_STDINT
#define FREERTOS_STDINT
/*******************************************************************************
* THIS IS NOT A FULL stdint.h IMPLEMENTATION - It only contains the definitions
* necessary to build the FreeRTOS code. It is provided to allow FreeRTOS to be
* built using compilers that do not provide their own stdint.h definition.
*
* To use this file:
*
* 1) Copy this file into the directory that contains your FreeRTOSConfig.h
* header file, as that directory will already be in the compilers include
* path.
*
* 2) Rename the copied file stdint.h.
*
*/
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef long int32_t;
typedef unsigned long uint32_t;
#endif /* FREERTOS_STDINT */

3786
FreeRTOS/Source/include/task.h
View file

File diff suppressed because it is too large Load diff

2273
FreeRTOS/Source/include/timers.h
View file

File diff suppressed because it is too large Load diff

443
FreeRTOS/Source/list.c
View file

@ -1,203 +1,240 @@
/* /*
FreeRTOS V7.5.2 - Copyright (C) 2013 Real Time Engineers Ltd. FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.
All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
***************************************************************************
* * This file is part of the FreeRTOS distribution.
* FreeRTOS provides completely free yet professionally developed, *
* robust, strictly quality controlled, supported, and cross * FreeRTOS is free software; you can redistribute it and/or modify it under
* platform software that has become a de facto standard. * the terms of the GNU General Public License (version 2) as published by the
* * Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
* Help yourself get started quickly and support the FreeRTOS *
* project by purchasing a FreeRTOS tutorial book, reference * ***************************************************************************
* manual, or both from: http://www.FreeRTOS.org/Documentation * >>! NOTE: The modification to the GPL is included to allow you to !<<
* * >>! distribute a combined work that includes FreeRTOS without being !<<
* Thank you! * >>! obliged to provide the source code for proprietary components !<<
* * >>! outside of the FreeRTOS kernel. !<<
*************************************************************************** ***************************************************************************
This file is part of the FreeRTOS distribution. FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FreeRTOS is free software; you can redistribute it and/or modify it under FOR A PARTICULAR PURPOSE. Full license text is available on the following
the terms of the GNU General Public License (version 2) as published by the link: http://www.freertos.org/a00114.html
Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
***************************************************************************
>>! NOTE: The modification to the GPL is included to allow you to distribute * *
>>! a combined work that includes FreeRTOS without being obliged to provide * FreeRTOS provides completely free yet professionally developed, *
>>! the source code for proprietary components outside of the FreeRTOS * robust, strictly quality controlled, supported, and cross *
>>! kernel. * platform software that is more than just the market leader, it *
* is the industry's de facto standard. *
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY * *
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * Help yourself get started quickly while simultaneously helping *
FOR A PARTICULAR PURPOSE. Full license text is available from the following * to support the FreeRTOS project by purchasing a FreeRTOS *
link: http://www.freertos.org/a00114.html * tutorial book, reference manual, or both: *
* http://www.FreeRTOS.org/Documentation *
1 tab == 4 spaces! * *
***************************************************************************
***************************************************************************
* * http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
* Having a problem? Start by reading the FAQ "My application does * the FAQ page "My application does not run, what could be wrong?". Have you
* not run, what could be wrong?" * defined configASSERT()?
* *
* http://www.FreeRTOS.org/FAQHelp.html * http://www.FreeRTOS.org/support - In return for receiving this top quality
* * embedded software for free we request you assist our global community by
*************************************************************************** participating in the support forum.
http://www.FreeRTOS.org - Documentation, books, training, latest versions, http://www.FreeRTOS.org/training - Investing in training allows your team to
license and Real Time Engineers Ltd. contact details. be as productive as possible as early as possible. Now you can receive
FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products, Ltd, and the world's leading authority on the world's leading RTOS.
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
compatible FAT file system, and our tiny thread aware UDP/IP stack. http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High compatible FAT file system, and our tiny thread aware UDP/IP stack.
Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and middleware. http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
mission critical applications that require provable dependability. Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and commercial middleware.
1 tab == 4 spaces!
*/ http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and
mission critical applications that require provable dependability.
#include <stdlib.h>
#include "FreeRTOS.h" 1 tab == 4 spaces!
#include "list.h" */
/*-----------------------------------------------------------
* PUBLIC LIST API documented in list.h #include <stdlib.h>
*----------------------------------------------------------*/ #include "FreeRTOS.h"
#include "list.h"
void vListInitialise( xList * const pxList )
{ /*-----------------------------------------------------------
/* The list structure contains a list item which is used to mark the * PUBLIC LIST API documented in list.h
end of the list. To initialise the list the list end is inserted *----------------------------------------------------------*/
as the only list entry. */
pxList->pxIndex = ( xListItem * ) &( pxList->xListEnd ); /*lint !e826 !e740 The mini list structure is used as the list end to save RAM. This is checked and valid. */ void vListInitialise( List_t * const pxList )
{
/* The list end value is the highest possible value in the list to /* The list structure contains a list item which is used to mark the
ensure it remains at the end of the list. */ end of the list. To initialise the list the list end is inserted
pxList->xListEnd.xItemValue = portMAX_DELAY; as the only list entry. */
pxList->pxIndex = ( ListItem_t * ) &( pxList->xListEnd ); /*lint !e826 !e740 The mini list structure is used as the list end to save RAM. This is checked and valid. */
/* The list end next and previous pointers point to itself so we know
when the list is empty. */ /* The list end value is the highest possible value in the list to
pxList->xListEnd.pxNext = ( xListItem * ) &( pxList->xListEnd ); /*lint !e826 !e740 The mini list structure is used as the list end to save RAM. This is checked and valid. */ ensure it remains at the end of the list. */
pxList->xListEnd.pxPrevious = ( xListItem * ) &( pxList->xListEnd );/*lint !e826 !e740 The mini list structure is used as the list end to save RAM. This is checked and valid. */ pxList->xListEnd.xItemValue = portMAX_DELAY;
pxList->uxNumberOfItems = ( unsigned portBASE_TYPE ) 0U; /* The list end next and previous pointers point to itself so we know
} when the list is empty. */
/*-----------------------------------------------------------*/ pxList->xListEnd.pxNext = ( ListItem_t * ) &( pxList->xListEnd ); /*lint !e826 !e740 The mini list structure is used as the list end to save RAM. This is checked and valid. */
pxList->xListEnd.pxPrevious = ( ListItem_t * ) &( pxList->xListEnd );/*lint !e826 !e740 The mini list structure is used as the list end to save RAM. This is checked and valid. */
void vListInitialiseItem( xListItem * const pxItem )
{ pxList->uxNumberOfItems = ( UBaseType_t ) 0U;
/* Make sure the list item is not recorded as being on a list. */
pxItem->pvContainer = NULL; /* Write known values into the list if
} configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
/*-----------------------------------------------------------*/ listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList );
listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList );
void IRAM vListInsertEnd( xList * const pxList, xListItem * const pxNewListItem ) }
{ /*-----------------------------------------------------------*/
xListItem * pxIndex;
void vListInitialiseItem( ListItem_t * const pxItem )
/* Insert a new list item into pxList, but rather than sort the list, {
makes the new list item the last item to be removed by a call to /* Make sure the list item is not recorded as being on a list. */
pvListGetOwnerOfNextEntry. */ pxItem->pvContainer = NULL;
pxIndex = pxList->pxIndex;
/* Write known values into the list item if
pxNewListItem->pxNext = pxIndex; configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
pxNewListItem->pxPrevious = pxIndex->pxPrevious; listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
pxIndex->pxPrevious->pxNext = pxNewListItem; listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
pxIndex->pxPrevious = pxNewListItem; }
/*-----------------------------------------------------------*/
/* Remember which list the item is in. */
pxNewListItem->pvContainer = ( void * ) pxList; void vListInsertEnd( List_t * const pxList, ListItem_t * const pxNewListItem )
{
( pxList->uxNumberOfItems )++; ListItem_t * const pxIndex = pxList->pxIndex;
}
/*-----------------------------------------------------------*/ /* Only effective when configASSERT() is also defined, these tests may catch
the list data structures being overwritten in memory. They will not catch
void IRAM vListInsert( xList * const pxList, xListItem * const pxNewListItem ) data errors caused by incorrect configuration or use of FreeRTOS. */
{ listTEST_LIST_INTEGRITY( pxList );
xListItem *pxIterator; listTEST_LIST_ITEM_INTEGRITY( pxNewListItem );
portTickType xValueOfInsertion;
/* Insert a new list item into pxList, but rather than sort the list,
/* Insert the new list item into the list, sorted in ulListItem order. */ makes the new list item the last item to be removed by a call to
xValueOfInsertion = pxNewListItem->xItemValue; listGET_OWNER_OF_NEXT_ENTRY(). */
pxNewListItem->pxNext = pxIndex;
/* If the list already contains a list item with the same item value then pxNewListItem->pxPrevious = pxIndex->pxPrevious;
the new list item should be placed after it. This ensures that TCB's which
are stored in ready lists (all of which have the same ulListItem value) /* Only used during decision coverage testing. */
get an equal share of the CPU. However, if the xItemValue is the same as mtCOVERAGE_TEST_DELAY();
the back marker the iteration loop below will not end. This means we need
to guard against this by checking the value first and modifying the pxIndex->pxPrevious->pxNext = pxNewListItem;
algorithm slightly if necessary. */ pxIndex->pxPrevious = pxNewListItem;
if( xValueOfInsertion == portMAX_DELAY )
{ /* Remember which list the item is in. */
pxIterator = pxList->xListEnd.pxPrevious; pxNewListItem->pvContainer = ( void * ) pxList;
}
else ( pxList->uxNumberOfItems )++;
{ }
/* *** NOTE *********************************************************** /*-----------------------------------------------------------*/
If you find your application is crashing here then likely causes are:
1) Stack overflow - void vListInsert( List_t * const pxList, ListItem_t * const pxNewListItem )
see http://www.freertos.org/Stacks-and-stack-overflow-checking.html {
2) Incorrect interrupt priority assignment, especially on Cortex-M3 ListItem_t *pxIterator;
parts where numerically high priority values denote low actual const TickType_t xValueOfInsertion = pxNewListItem->xItemValue;
interrupt priories, which can seem counter intuitive. See
configMAX_SYSCALL_INTERRUPT_PRIORITY on http://www.freertos.org/a00110.html /* Only effective when configASSERT() is also defined, these tests may catch
3) Calling an API function from within a critical section or when the list data structures being overwritten in memory. They will not catch
the scheduler is suspended, or calling an API function that does data errors caused by incorrect configuration or use of FreeRTOS. */
not end in "FromISR" from an interrupt. listTEST_LIST_INTEGRITY( pxList );
4) Using a queue or semaphore before it has been initialised or listTEST_LIST_ITEM_INTEGRITY( pxNewListItem );
before the scheduler has been started (are interrupts firing
before vTaskStartScheduler() has been called?). /* Insert the new list item into the list, sorted in xItemValue order.
See http://www.freertos.org/FAQHelp.html for more tips.
**********************************************************************/ If the list already contains a list item with the same item value then the
new list item should be placed after it. This ensures that TCB's which are
for( pxIterator = ( xListItem * ) &( pxList->xListEnd ); pxIterator->pxNext->xItemValue <= xValueOfInsertion; pxIterator = pxIterator->pxNext ) /*lint !e826 !e740 The mini list structure is used as the list end to save RAM. This is checked and valid. */ stored in ready lists (all of which have the same xItemValue value) get a
{ share of the CPU. However, if the xItemValue is the same as the back marker
/* There is nothing to do here, we are just iterating to the the iteration loop below will not end. Therefore the value is checked
wanted insertion position. */ first, and the algorithm slightly modified if necessary. */
} if( xValueOfInsertion == portMAX_DELAY )
} {
pxIterator = pxList->xListEnd.pxPrevious;
pxNewListItem->pxNext = pxIterator->pxNext; }
pxNewListItem->pxNext->pxPrevious = pxNewListItem; else
pxNewListItem->pxPrevious = pxIterator; {
pxIterator->pxNext = pxNewListItem; /* *** NOTE ***********************************************************
If you find your application is crashing here then likely causes are
/* Remember which list the item is in. This allows fast removal of the listed below. In addition see http://www.freertos.org/FAQHelp.html for
item later. */ more tips, and ensure configASSERT() is defined!
pxNewListItem->pvContainer = ( void * ) pxList; http://www.freertos.org/a00110.html#configASSERT
( pxList->uxNumberOfItems )++; 1) Stack overflow -
} see http://www.freertos.org/Stacks-and-stack-overflow-checking.html
/*-----------------------------------------------------------*/ 2) Incorrect interrupt priority assignment, especially on Cortex-M
parts where numerically high priority values denote low actual
unsigned portBASE_TYPE IRAM uxListRemove( xListItem * const pxItemToRemove ) interrupt priorities, which can seem counter intuitive. See
{ http://www.freertos.org/RTOS-Cortex-M3-M4.html and the definition
xList * pxList; of configMAX_SYSCALL_INTERRUPT_PRIORITY on
http://www.freertos.org/a00110.html
pxItemToRemove->pxNext->pxPrevious = pxItemToRemove->pxPrevious; 3) Calling an API function from within a critical section or when
pxItemToRemove->pxPrevious->pxNext = pxItemToRemove->pxNext; the scheduler is suspended, or calling an API function that does
not end in "FromISR" from an interrupt.
/* The list item knows which list it is in. Obtain the list from the list 4) Using a queue or semaphore before it has been initialised or
item. */ before the scheduler has been started (are interrupts firing
pxList = ( xList * ) pxItemToRemove->pvContainer; before vTaskStartScheduler() has been called?).
**********************************************************************/
/* Make sure the index is left pointing to a valid item. */
if( pxList->pxIndex == pxItemToRemove ) for( pxIterator = ( ListItem_t * ) &( pxList->xListEnd ); pxIterator->pxNext->xItemValue <= xValueOfInsertion; pxIterator = pxIterator->pxNext ) /*lint !e826 !e740 The mini list structure is used as the list end to save RAM. This is checked and valid. */
{ {
pxList->pxIndex = pxItemToRemove->pxPrevious; /* There is nothing to do here, just iterating to the wanted
} insertion position. */
}
pxItemToRemove->pvContainer = NULL; }
( pxList->uxNumberOfItems )--;
pxNewListItem->pxNext = pxIterator->pxNext;
return pxList->uxNumberOfItems; pxNewListItem->pxNext->pxPrevious = pxNewListItem;
} pxNewListItem->pxPrevious = pxIterator;
/*-----------------------------------------------------------*/ pxIterator->pxNext = pxNewListItem;
/* Remember which list the item is in. This allows fast removal of the
item later. */
pxNewListItem->pvContainer = ( void * ) pxList;
( pxList->uxNumberOfItems )++;
}
/*-----------------------------------------------------------*/
UBaseType_t uxListRemove( ListItem_t * const pxItemToRemove )
{
/* The list item knows which list it is in. Obtain the list from the list
item. */
List_t * const pxList = ( List_t * ) pxItemToRemove->pvContainer;
pxItemToRemove->pxNext->pxPrevious = pxItemToRemove->pxPrevious;
pxItemToRemove->pxPrevious->pxNext = pxItemToRemove->pxNext;
/* Only used during decision coverage testing. */
mtCOVERAGE_TEST_DELAY();
/* Make sure the index is left pointing to a valid item. */
if( pxList->pxIndex == pxItemToRemove )
{
pxList->pxIndex = pxItemToRemove->pxPrevious;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
pxItemToRemove->pvContainer = NULL;
( pxList->uxNumberOfItems )--;
return pxList->uxNumberOfItems;
}
/*-----------------------------------------------------------*/

8
FreeRTOS/Source/portable/esp8266/port.c
View file

@ -258,3 +258,11 @@ void IRAM vPortExitCritical( void )
portENABLE_INTERRUPTS(); portENABLE_INTERRUPTS();
} }
/* back compatibility */
signed portBASE_TYPE xTaskGenericCreate( pdTASK_CODE pxTaskCode, const signed char * const pcName, unsigned short usStackDepth, void *pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle *pxCreatedTask, portSTACK_TYPE *puxStackBuffer, const xMemoryRegion * const xRegions )
{
(void)puxStackBuffer; (void)xRegions;
return xTaskCreate( pxTaskCode, (const char * const)pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask);
}

8
FreeRTOS/Source/portable/esp8266/portmacro.h
View file

@ -94,13 +94,19 @@ extern "C" {
#define portSHORT short #define portSHORT short
#define portSTACK_TYPE unsigned portLONG #define portSTACK_TYPE unsigned portLONG
#define portBASE_TYPE long #define portBASE_TYPE long
#define portPOINTER_SIZE_TYPE unsigned portLONG
typedef portSTACK_TYPE StackType_t;
typedef portBASE_TYPE BaseType_t;
typedef unsigned portBASE_TYPE UBaseType_t;
typedef uint32_t portTickType; typedef uint32_t portTickType;
typedef uint32_t TickType_t;
#define portMAX_DELAY ( portTickType ) 0xffffffff #define portMAX_DELAY ( portTickType ) 0xffffffff
/* Architecture specifics. */ /* Architecture specifics. */
#define portSTACK_GROWTH ( -1 ) #define portSTACK_GROWTH ( -1 )
#define portTICK_RATE_MS ( ( portTickType ) 1000 / configTICK_RATE_HZ ) #define portTICK_PERIOD_MS ( ( portTickType ) 1000 / configTICK_RATE_HZ )
#define portBYTE_ALIGNMENT 8 #define portBYTE_ALIGNMENT 8
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/

4610
FreeRTOS/Source/queue.c
View file

File diff suppressed because it is too large Load diff

32
FreeRTOS/Source/readme.txt
View file

@ -1,17 +1,17 @@
Each real time kernel port consists of three files that contain the core kernel Each real time kernel port consists of three files that contain the core kernel
components and are common to every port, and one or more files that are components and are common to every port, and one or more files that are
specific to a particular microcontroller and or compiler. specific to a particular microcontroller and or compiler.
+ The FreeRTOS/Source directory contains the three files that are common to + The FreeRTOS/Source directory contains the three files that are common to
every port - list.c, queue.c and tasks.c. The kernel is contained within these every port - list.c, queue.c and tasks.c. The kernel is contained within these
three files. croutine.c implements the optional co-routine functionality - which three files. croutine.c implements the optional co-routine functionality - which
is normally only used on very memory limited systems. is normally only used on very memory limited systems.
+ The FreeRTOS/Source/Portable directory contains the files that are specific to + The FreeRTOS/Source/Portable directory contains the files that are specific to
a particular microcontroller and or compiler. a particular microcontroller and or compiler.
+ The FreeRTOS/Source/include directory contains the real time kernel header + The FreeRTOS/Source/include directory contains the real time kernel header
files. files.
See the readme file in the FreeRTOS/Source/Portable directory for more See the readme file in the FreeRTOS/Source/Portable directory for more
information. information.

7738
FreeRTOS/Source/tasks.c
View file

File diff suppressed because it is too large Load diff

1789
FreeRTOS/Source/timers.c
View file

File diff suppressed because it is too large Load diff

2
README.md
View file

@ -79,7 +79,7 @@ Current status is alpha quality, actively developed. AP STATION mode (ie wifi cl
## Open Source Components ## Open Source Components
* [FreeRTOS](http://www.freertos.org/) V7.5.2 * [FreeRTOS](http://www.freertos.org/) V9.0.0
* [lwIP](http://lwip.wikia.com/wiki/LwIP_Wiki) v1.4.1, modified via the [esp-lwip project](https://github.com/kadamski/esp-lwip) by @kadamski. * [lwIP](http://lwip.wikia.com/wiki/LwIP_Wiki) v1.4.1, modified via the [esp-lwip project](https://github.com/kadamski/esp-lwip) by @kadamski.
* [newlib](https://github.com/projectgus/newlib-xtensa) v2.2.0, with patches for xtensa support and locking stubs for thread-safe operation on FreeRTOS. * [newlib](https://github.com/projectgus/newlib-xtensa) v2.2.0, with patches for xtensa support and locking stubs for thread-safe operation on FreeRTOS.

2
core/app_main.c
View file

@ -394,7 +394,7 @@ static __attribute__((noinline)) void user_start_phase2(void) {
tcpip_init(NULL, NULL); tcpip_init(NULL, NULL);
sdk_wdt_init(); sdk_wdt_init();
xTaskCreate(sdk_user_init_task, (signed char *)"uiT", 1024, 0, 14, &sdk_xUserTaskHandle); xTaskCreate(sdk_user_init_task, (const char * const)"uiT", 1024, 0, 14, &sdk_xUserTaskHandle);
vTaskStartScheduler(); vTaskStartScheduler();
} }

2
examples/access_point/access_point.c
View file

@ -52,7 +52,7 @@ void user_init(void)
IP4_ADDR(&first_client_ip, 172, 16, 0, 2); IP4_ADDR(&first_client_ip, 172, 16, 0, 2);
dhcpserver_start(&first_client_ip, 4); dhcpserver_start(&first_client_ip, 4);
xTaskCreate(telnetTask, (signed char *)"telnetTask", 512, NULL, 2, NULL); xTaskCreate(telnetTask, (const char * const)"telnetTask", 512, NULL, 2, NULL);
} }
/* Telnet task listens on port 23, returns some status information and then closes /* Telnet task listens on port 23, returns some status information and then closes

4
examples/blink/blink.c
View file

@ -54,6 +54,6 @@ void blinkenRegisterTask(void *pvParameters)
void user_init(void) void user_init(void)
{ {
uart_set_baud(0, 115200); uart_set_baud(0, 115200);
xTaskCreate(blinkenTask, (signed char *)"blinkenTask", 256, NULL, 2, NULL); xTaskCreate(blinkenTask, (const char * const)"blinkenTask", 256, NULL, 2, NULL);
//xTaskCreate(blinkenRegisterTask, (signed char *)"blinkenRegisterTask", 256, NULL, 2, NULL); //xTaskCreate(blinkenRegisterTask, (const char * const)"blinkenRegisterTask", 256, NULL, 2, NULL);
} }

4
examples/bmp180_i2c/bmp180_i2c.c
View file

@ -113,10 +113,10 @@ void user_init(void)
mainqueue = xQueueCreate(10, sizeof(my_event_t)); mainqueue = xQueueCreate(10, sizeof(my_event_t));
// Create user interface task // Create user interface task
xTaskCreate(bmp180_task, (signed char *)"bmp180_task", 256, &mainqueue, 2, NULL); xTaskCreate(bmp180_task, (const char * const)"bmp180_task", 256, &mainqueue, 2, NULL);
// Create Timer (Trigger a measurement every second) // Create Timer (Trigger a measurement every second)
timerHandle = xTimerCreate((signed char *)"BMP180 Trigger", 1000/portTICK_RATE_MS, pdTRUE, NULL, bmp180_i2c_timer_cb); timerHandle = xTimerCreate((const char * const)"BMP180 Trigger", 1000/portTICK_RATE_MS, pdTRUE, NULL, bmp180_i2c_timer_cb);
if (timerHandle != NULL) if (timerHandle != NULL)
{ {

4
examples/bmp280/bmp280_example.c
View file

@ -81,8 +81,8 @@ void user_init(void)
printf("GIT version : %s\n", GITSHORTREV); printf("GIT version : %s\n", GITSHORTREV);
#ifdef MODE_FORCED #ifdef MODE_FORCED
xTaskCreate(bmp280_task_forced, (signed char *)"bmp280_task", 256, NULL, 2, NULL); xTaskCreate(bmp280_task_forced, (const char * const)"bmp280_task", 256, NULL, 2, NULL);
#else #else
xTaskCreate(bmp280_task_normal, (signed char *)"bmp280_task", 256, NULL, 2, NULL); xTaskCreate(bmp280_task_normal, (const char * const)"bmp280_task", 256, NULL, 2, NULL);
#endif #endif
} }

4
examples/button/button.c
View file

@ -79,6 +79,6 @@ void user_init(void)
gpio_enable(gpio, GPIO_INPUT); gpio_enable(gpio, GPIO_INPUT);
tsqueue = xQueueCreate(2, sizeof(uint32_t)); tsqueue = xQueueCreate(2, sizeof(uint32_t));
xTaskCreate(buttonIntTask, (signed char *)"buttonIntTask", 256, &tsqueue, 2, NULL); xTaskCreate(buttonIntTask, (const char * const)"buttonIntTask", 256, &tsqueue, 2, NULL);
xTaskCreate(buttonPollTask, (signed char*)"buttonPollTask", 256, NULL, 1, NULL); xTaskCreate(buttonPollTask, (const char * const)"buttonPollTask", 256, NULL, 1, NULL);
} }

2
examples/dht_sensor/dht_sensor.c
View file

@ -44,6 +44,6 @@ void dhtMeasurementTask(void *pvParameters)
void user_init(void) void user_init(void)
{ {
uart_set_baud(0, 115200); uart_set_baud(0, 115200);
xTaskCreate(dhtMeasurementTask, (signed char *)"dhtMeasurementTask", 256, NULL, 2, NULL); xTaskCreate(dhtMeasurementTask, (const char * const)"dhtMeasurementTask", 256, NULL, 2, NULL);
} }

2
examples/ds18b20_broadcaster/ds18b20_broadcaster.c
View file

@ -119,6 +119,6 @@ void user_init(void)
sdk_wifi_set_opmode(STATION_MODE); sdk_wifi_set_opmode(STATION_MODE);
sdk_wifi_station_set_config(&config); sdk_wifi_station_set_config(&config);
xTaskCreate(&broadcast_temperature, (signed char *)"broadcast_temperature", 256, NULL, 2, NULL); xTaskCreate(&broadcast_temperature, (const char * const)"broadcast_temperature", 256, NULL, 2, NULL);
} }

2
examples/ds18b20_onewire/ds18b20_onewire.c
View file

@ -73,6 +73,6 @@ void print_temperature(void *pvParameters) {
void user_init(void) { void user_init(void) {
uart_set_baud(0, 115200); uart_set_baud(0, 115200);
xTaskCreate(&print_temperature, (signed char *)"print_temperature", 256, NULL, 2, NULL); xTaskCreate(&print_temperature, (const char * const)"print_temperature", 256, NULL, 2, NULL);
} }

2
examples/experiments/timers/timers.c
View file

@ -119,7 +119,7 @@ void frc2_handler(void)
void user_init(void) void user_init(void)
{ {
uart_set_baud(0, 115200); uart_set_baud(0, 115200);
xTaskCreate(timerRegTask, (signed char *)"timerRegTask", 1024, NULL, 2, NULL); xTaskCreate(timerRegTask, (const char * const)"timerRegTask", 1024, NULL, 2, NULL);
TIMER(0).CTRL = VAL2FIELD(TIMER_CTRL_CLKDIV, TIMER_CLKDIV_256) | TIMER_CTRL_RELOAD; TIMER(0).CTRL = VAL2FIELD(TIMER_CTRL_CLKDIV, TIMER_CLKDIV_256) | TIMER_CTRL_RELOAD;
TIMER(0).LOAD = 0x200000; TIMER(0).LOAD = 0x200000;

2
examples/experiments/unaligned_load/unaligned_load.c
View file

@ -230,7 +230,7 @@ void user_init(void)
test_sign_extension(); test_sign_extension();
xTaskHandle taskHandle; xTaskHandle taskHandle;
xTaskCreate(test_system_interaction, (signed char *)"interactionTask", 256, &taskHandle, 2, NULL); xTaskCreate(test_system_interaction, (const char * const)"interactionTask", 256, &taskHandle, 2, NULL);
} }
static volatile bool frc1_ran; static volatile bool frc1_ran;

2
examples/http_get/http_get.c
View file

@ -126,6 +126,6 @@ void user_init(void)
sdk_wifi_set_opmode(STATION_MODE); sdk_wifi_set_opmode(STATION_MODE);
sdk_wifi_station_set_config(&config); sdk_wifi_station_set_config(&config);
xTaskCreate(&http_get_task, (signed char *)"get_task", 256, NULL, 2, NULL); xTaskCreate(&http_get_task, (const char * const)"get_task", 256, NULL, 2, NULL);
} }

2
examples/http_get_mbedtls/http_get_mbedtls.c
View file

@ -333,5 +333,5 @@ void user_init(void)
sdk_wifi_set_opmode(STATION_MODE); sdk_wifi_set_opmode(STATION_MODE);
sdk_wifi_station_set_config(&config); sdk_wifi_station_set_config(&config);
xTaskCreate(&http_get_task, (signed char *)"get_task", 2048, NULL, 2, NULL); xTaskCreate(&http_get_task, (const char * const)"get_task", 2048, NULL, 2, NULL);
} }

2
examples/json_jsmn_simple/json_jsmn_simple.c
View file

@ -108,5 +108,5 @@ void user_init(void)
{ {
uart_set_baud(0, 115200); uart_set_baud(0, 115200);
printf("SDK version:%s\n", sdk_system_get_sdk_version()); printf("SDK version:%s\n", sdk_system_get_sdk_version());
xTaskCreate(json_test, (signed char *)"jsont", 1024, NULL, 2, NULL); xTaskCreate(json_test, (const char * const)"jsont", 1024, NULL, 2, NULL);
} }

6
examples/mqtt_client/mqtt_client.c
View file

@ -216,7 +216,7 @@ void user_init(void)
vSemaphoreCreateBinary(wifi_alive); vSemaphoreCreateBinary(wifi_alive);
publish_queue = xQueueCreate(3, PUB_MSG_LEN); publish_queue = xQueueCreate(3, PUB_MSG_LEN);
xTaskCreate(&wifi_task, (int8_t *)"wifi_task", 256, NULL, 2, NULL); xTaskCreate(&wifi_task, (const char * const)"wifi_task", 256, NULL, 2, NULL);
xTaskCreate(&beat_task, (int8_t *)"beat_task", 256, NULL, 3, NULL); xTaskCreate(&beat_task, (const char * const)"beat_task", 256, NULL, 3, NULL);
xTaskCreate(&mqtt_task, (int8_t *)"mqtt_task", 1024, NULL, 4, NULL); xTaskCreate(&mqtt_task, (const char * const)"mqtt_task", 1024, NULL, 4, NULL);
} }

2
examples/ota_basic/ota_basic.c
View file

@ -138,5 +138,5 @@ void user_init(void)
printf("Starting TFTP server..."); printf("Starting TFTP server...");
ota_tftp_init_server(TFTP_PORT); ota_tftp_init_server(TFTP_PORT);
xTaskCreate(&tftp_client_task, (signed char *)"tftp_client", 2048, NULL, 2, NULL); xTaskCreate(&tftp_client_task, (const char * const)"tftp_client", 2048, NULL, 2, NULL);
} }

2
examples/pwm_test/pwm_test.c
View file

@ -46,5 +46,5 @@ void user_init(void)
printf("pwm_start()\n"); printf("pwm_start()\n");
pwm_start(); pwm_start();
xTaskCreate(task1, (signed char *)"tsk1", 256, NULL, 2, NULL); xTaskCreate(task1, (const char * const)"tsk1", 256, NULL, 2, NULL);
} }

4
examples/simple/simple.c
View file

@ -39,6 +39,6 @@ void user_init(void)
uart_set_baud(0, 115200); uart_set_baud(0, 115200);
printf("SDK version:%s\n", sdk_system_get_sdk_version()); printf("SDK version:%s\n", sdk_system_get_sdk_version());
mainqueue = xQueueCreate(10, sizeof(uint32_t)); mainqueue = xQueueCreate(10, sizeof(uint32_t));
xTaskCreate(task1, (signed char *)"tsk1", 256, &mainqueue, 2, NULL); xTaskCreate(task1, (const char * const)"tsk1", 256, &mainqueue, 2, NULL);
xTaskCreate(task2, (signed char *)"tsk2", 256, &mainqueue, 2, NULL); xTaskCreate(task2, (const char * const)"tsk2", 256, &mainqueue, 2, NULL);
} }

2
examples/simple_cplusplus/simple.cpp
View file

@ -61,5 +61,5 @@ extern "C" void user_init(void)
{ {
uart_set_baud(0, 115200); uart_set_baud(0, 115200);
printf("SDK version:%s\n", sdk_system_get_sdk_version()); printf("SDK version:%s\n", sdk_system_get_sdk_version());
xTaskCreate(task1, (signed char *)"tsk1", 256, NULL, 2, NULL); xTaskCreate(task1, (const char * const)"tsk1", 256, NULL, 2, NULL);
} }

2
examples/sntp/sntp_example.c
View file

@ -74,6 +74,6 @@ void user_init(void)
sdk_wifi_set_opmode(STATION_MODE); sdk_wifi_set_opmode(STATION_MODE);
sdk_wifi_station_set_config(&config); sdk_wifi_station_set_config(&config);
xTaskCreate(sntp_tsk, (signed char *)"SNTP", 1024, NULL, 1, NULL); xTaskCreate(sntp_tsk, (const char * const)"SNTP", 1024, NULL, 1, NULL);
} }

2
examples/tls_server/tls_server.c
View file

@ -254,5 +254,5 @@ void user_init(void)
sdk_wifi_set_opmode(STATION_MODE); sdk_wifi_set_opmode(STATION_MODE);
sdk_wifi_station_set_config(&config); sdk_wifi_station_set_config(&config);
xTaskCreate(&tls_server_task, (signed char *)"server_task", 2048, NULL, 2, NULL); xTaskCreate(&tls_server_task, (const char * const)"server_task", 2048, NULL, 2, NULL);
} }

2
examples/ws2812_rainbow/ws2812_rainbow.c
View file

@ -148,6 +148,6 @@ void user_init(void)
// notice the glitches due to NMI. // notice the glitches due to NMI.
printf("Starting a task. There may be glitches!\r\n"); printf("Starting a task. There may be glitches!\r\n");
xTaskCreate(&demo, (signed char *)"strip demo", 256, NULL, 10, NULL); xTaskCreate(&demo, (const char * const)"strip demo", 256, NULL, 10, NULL);
#endif #endif
} }

2
extras/bmp180/bmp180.c
View file

@ -197,7 +197,7 @@ static bool bmp180_createTask()
if (bmp180_task_handle==NULL) if (bmp180_task_handle==NULL)
{ {
x = xTaskCreate(bmp180_driver_task, (signed char *)"bmp180_driver_task", 256, NULL, BMP180_TASK_PRIORITY, &bmp180_task_handle); x = xTaskCreate(bmp180_driver_task, (const char * const)"bmp180_driver_task", 256, NULL, BMP180_TASK_PRIORITY, &bmp180_task_handle);
} }
return (x==pdPASS); return (x==pdPASS);
} }

2
extras/cpp_support/include/task.hpp
View file

@ -56,7 +56,7 @@ public:
*/ */
int task_create(const char* const pcName, unsigned short usStackDepth = 256, unsigned portBASE_TYPE uxPriority = 2) int task_create(const char* const pcName, unsigned short usStackDepth = 256, unsigned portBASE_TYPE uxPriority = 2)
{ {
return xTaskCreate(task_t::_task, (signed char *)pcName, usStackDepth, this, uxPriority, NULL); return xTaskCreate(task_t::_task, (const char * const)pcName, usStackDepth, this, uxPriority, NULL);
} }
protected: protected:

2
extras/dhcpserver/dhcpserver.c
View file

@ -89,7 +89,7 @@ void dhcpserver_start(const ip_addr_t *first_client_addr, uint8_t max_leases)
// state->server_if is assigned once the task is running - see comment in dhcpserver_task() // state->server_if is assigned once the task is running - see comment in dhcpserver_task()
ip_addr_copy(state->first_client_addr, *first_client_addr); ip_addr_copy(state->first_client_addr, *first_client_addr);
xTaskCreate(dhcpserver_task, (signed char *)"DHCPServer", 768, NULL, 8, &dhcpserver_task_handle); xTaskCreate(dhcpserver_task, (const char * const)"DHCPServer", 768, NULL, 8, &dhcpserver_task_handle);
} }
void dhcpserver_stop(void) void dhcpserver_stop(void)

2
extras/rboot-ota/ota-tftp.c
View file

@ -50,7 +50,7 @@ static void tftp_send_error(struct netconn *nc, int err_code, const char *err_ms
void ota_tftp_init_server(int listen_port) void ota_tftp_init_server(int listen_port)
{ {
xTaskCreate(tftp_task, (signed char *)"tftpOTATask", 512, (void *)listen_port, 2, NULL); xTaskCreate(tftp_task, (const char * const)"tftpOTATask", 512, (void *)listen_port, 2, NULL);
} }
err_t ota_tftp_download(const char *server, int port, const char *filename, err_t ota_tftp_download(const char *server, int port, const char *filename,

2
lwip/sys_arch.c
View file

@ -514,7 +514,7 @@ xTaskHandle xCreatedTask;
portBASE_TYPE xResult; portBASE_TYPE xResult;
sys_thread_t xReturn; sys_thread_t xReturn;
xResult = xTaskCreate( pxThread, ( signed char * ) pcName, iStackSize, pvArg, iPriority, &xCreatedTask ); xResult = xTaskCreate( pxThread, ( const char * const ) pcName, iStackSize, pvArg, iPriority, &xCreatedTask );
if( xResult == pdPASS ) if( xResult == pdPASS )
{ {