CloudEdge/FreeRTOS-Kernel
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Change the type used for strings and single characters from signed char to just char.

Browse Source
This commit is contained in:
Richard Barry 2013-12-27 12:10:23 +00:00
parent b3aa1e90ad
commit b4116a7c7d
8 changed files with 96 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
FreeRTOS/Source/include/queue.h
View File

@ -1514,7 +1514,7 @@ portBASE_TYPE xQueueGiveMutexRecursive( xQueueHandle pxMutex ) PRIVILEGED_FUNCTI
* preferably in ROM/Flash), not on the stack. * preferably in ROM/Flash), not on the stack.
*/ */
#if configQUEUE_REGISTRY_SIZE > 0 #if configQUEUE_REGISTRY_SIZE > 0
void vQueueAddToRegistry( xQueueHandle xQueue, signed char *pcName ) PRIVILEGED_FUNCTION; void vQueueAddToRegistry( xQueueHandle xQueue, char *pcName ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
#endif #endif
/* /*

22
FreeRTOS/Source/include/task.h
View File

@ -130,7 +130,7 @@ typedef struct xMEMORY_REGION
typedef struct xTASK_PARAMETERS typedef struct xTASK_PARAMETERS
{ {
pdTASK_CODE pvTaskCode; pdTASK_CODE pvTaskCode;
const signed char * const pcName; const char * const pcName; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
unsigned short usStackDepth; unsigned short usStackDepth;
void *pvParameters; void *pvParameters;
unsigned portBASE_TYPE uxPriority; unsigned portBASE_TYPE uxPriority;
@ -143,7 +143,7 @@ in the system. */
typedef struct xTASK_STATUS typedef struct xTASK_STATUS
{ {
xTaskHandle xHandle; /* The handle of the task to which the rest of the information in the structure relates. */ xTaskHandle xHandle; /* The handle of the task to which the rest of the information in the structure relates. */
const signed char *pcTaskName; /* A pointer to the task's name. This value will be invalid if the task was deleted since the structure was populated! */ const char *pcTaskName; /* A pointer to the task's name. This value will be invalid if the task was deleted since the structure was populated! */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
unsigned portBASE_TYPE xTaskNumber; /* A number unique to the task. */ unsigned portBASE_TYPE xTaskNumber; /* A number unique to the task. */
eTaskState eCurrentState; /* The state in which the task existed when the structure was populated. */ eTaskState eCurrentState; /* The state in which the task existed when the structure was populated. */
unsigned portBASE_TYPE uxCurrentPriority; /* The priority at which the task was running (may be inherited) when the structure was populated. */ unsigned portBASE_TYPE uxCurrentPriority; /* The priority at which the task was running (may be inherited) when the structure was populated. */
@ -243,7 +243,7 @@ is used in assert() statements. */
*<pre> *<pre>
portBASE_TYPE xTaskCreate( portBASE_TYPE xTaskCreate(
pdTASK_CODE pvTaskCode, pdTASK_CODE pvTaskCode,
const signed char * const pcName, const char * const pcName,
unsigned short usStackDepth, unsigned short usStackDepth,
void *pvParameters, void *pvParameters,
unsigned portBASE_TYPE uxPriority, unsigned portBASE_TYPE uxPriority,
@ -1077,7 +1077,7 @@ unsigned portBASE_TYPE uxTaskGetNumberOfTasks( void ) PRIVILEGED_FUNCTION;
/** /**
* task. h * task. h
* <PRE>signed char *pcTaskGetTaskName( xTaskHandle xTaskToQuery );</PRE> * <PRE>char *pcTaskGetTaskName( xTaskHandle xTaskToQuery );</PRE>
* *
* @return The text (human readable) name of the task referenced by the handle * @return The text (human readable) name of the task referenced by the handle
* xTaskToQuery. A task can query its own name by either passing in its own * xTaskToQuery. A task can query its own name by either passing in its own
@ -1087,7 +1087,7 @@ unsigned portBASE_TYPE uxTaskGetNumberOfTasks( void ) PRIVILEGED_FUNCTION;
* \defgroup pcTaskGetTaskName pcTaskGetTaskName * \defgroup pcTaskGetTaskName pcTaskGetTaskName
* \ingroup TaskUtils * \ingroup TaskUtils
*/ */
signed char *pcTaskGetTaskName( xTaskHandle xTaskToQuery ); char *pcTaskGetTaskName( xTaskHandle xTaskToQuery ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
/** /**
* task.h * task.h
@ -1199,7 +1199,7 @@ xTaskHandle xTaskGetIdleTaskHandle( void );
// This example demonstrates how a human readable table of run time stats // This example demonstrates how a human readable table of run time stats
// information is generated from raw data provided by uxTaskGetSystemState(). // information is generated from raw data provided by uxTaskGetSystemState().
// The human readable table is written to pcWriteBuffer // The human readable table is written to pcWriteBuffer
void vTaskGetRunTimeStats( signed char *pcWriteBuffer ) void vTaskGetRunTimeStats( char *pcWriteBuffer )
{ {
xTaskStatusType *pxTaskStatusArray; xTaskStatusType *pxTaskStatusArray;
volatile unsigned portBASE_TYPE uxArraySize, x; volatile unsigned portBASE_TYPE uxArraySize, x;
@ -1238,13 +1238,13 @@ xTaskHandle xTaskGetIdleTaskHandle( void );
if( ulStatsAsPercentage > 0UL ) if( ulStatsAsPercentage > 0UL )
{ {
sprintf( ( char * ) pcWriteBuffer, ( char * ) "%s\t\t%lu\t\t%lu%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter, ulStatsAsPercentage ); sprintf( pcWriteBuffer, "%s\t\t%lu\t\t%lu%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter, ulStatsAsPercentage );
} }
else else
{ {
// If the percentage is zero here then the task has // If the percentage is zero here then the task has
// consumed less than 1% of the total run time. // consumed less than 1% of the total run time.
sprintf( ( char * ) pcWriteBuffer, ( char * ) "%s\t\t%lu\t\t<1%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter ); sprintf( pcWriteBuffer, "%s\t\t%lu\t\t<1%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter );
} }
pcWriteBuffer += strlen( ( char * ) pcWriteBuffer ); pcWriteBuffer += strlen( ( char * ) pcWriteBuffer );
@ -1304,7 +1304,7 @@ unsigned portBASE_TYPE uxTaskGetSystemState( xTaskStatusType * const pxTaskStatu
* \defgroup vTaskList vTaskList * \defgroup vTaskList vTaskList
* \ingroup TaskUtils * \ingroup TaskUtils
*/ */
void vTaskList( signed char * pcWriteBuffer ) PRIVILEGED_FUNCTION; void vTaskList( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
/** /**
* task. h * task. h
@ -1358,7 +1358,7 @@ void vTaskList( signed char * pcWriteBuffer ) PRIVILEGED_FUNCTION;
* \defgroup vTaskGetRunTimeStats vTaskGetRunTimeStats * \defgroup vTaskGetRunTimeStats vTaskGetRunTimeStats
* \ingroup TaskUtils * \ingroup TaskUtils
*/ */
void vTaskGetRunTimeStats( signed char *pcWriteBuffer ) PRIVILEGED_FUNCTION; void vTaskGetRunTimeStats( char *pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
/*----------------------------------------------------------- /*-----------------------------------------------------------
* SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES * SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES
@ -1515,7 +1515,7 @@ void vTaskPriorityDisinherit( xTaskHandle const pxMutexHolder ) PRIVILEGED_FUNCT
* Generic version of the task creation function which is in turn called by the * Generic version of the task creation function which is in turn called by the
* xTaskCreate() and xTaskCreateRestricted() macros. * xTaskCreate() and xTaskCreateRestricted() macros.
*/ */
signed portBASE_TYPE xTaskGenericCreate( pdTASK_CODE pxTaskCode, const signed char * const pcName, const unsigned short usStackDepth, void * const pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle * const pxCreatedTask, portSTACK_TYPE * const puxStackBuffer, const xMemoryRegion * const xRegions ) PRIVILEGED_FUNCTION; signed portBASE_TYPE xTaskGenericCreate( pdTASK_CODE pxTaskCode, const char * const pcName, const unsigned short usStackDepth, void * const pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle * const pxCreatedTask, portSTACK_TYPE * const puxStackBuffer, const xMemoryRegion * const xRegions ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
/* /*
* Get the uxTCBNumber assigned to the task referenced by the xTask parameter. * Get the uxTCBNumber assigned to the task referenced by the xTask parameter.

4
FreeRTOS/Source/include/timers.h
View File

@ -105,7 +105,7 @@ typedef void * xTimerHandle;
typedef void (*tmrTIMER_CALLBACK)( xTimerHandle xTimer ); typedef void (*tmrTIMER_CALLBACK)( xTimerHandle xTimer );
/** /**
* xTimerHandle xTimerCreate( const signed char * const pcTimerName, * xTimerHandle xTimerCreate( const char * const pcTimerName,
* portTickType xTimerPeriodInTicks, * portTickType xTimerPeriodInTicks,
* unsigned portBASE_TYPE uxAutoReload, * unsigned portBASE_TYPE uxAutoReload,
* void * pvTimerID, * void * pvTimerID,
@ -232,7 +232,7 @@ typedef void (*tmrTIMER_CALLBACK)( xTimerHandle xTimer );
* } * }
* @endverbatim * @endverbatim
*/ */
xTimerHandle xTimerCreate( const signed char * const pcTimerName, const portTickType xTimerPeriodInTicks, const unsigned portBASE_TYPE uxAutoReload, void * const pvTimerID, tmrTIMER_CALLBACK pxCallbackFunction ) PRIVILEGED_FUNCTION; xTimerHandle xTimerCreate( const char * const pcTimerName, const portTickType xTimerPeriodInTicks, const unsigned portBASE_TYPE uxAutoReload, void * const pvTimerID, tmrTIMER_CALLBACK pxCallbackFunction ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
/** /**
* void *pvTimerGetTimerID( xTimerHandle xTimer ); * void *pvTimerGetTimerID( xTimerHandle xTimer );

16
FreeRTOS/Source/portable/GCC/ARM_CM3_MPU/port.c
View File

@ -170,7 +170,7 @@ static void prvSVCHandler( unsigned long *pulRegisters ) __attribute__(( noinlin
/* /*
* Prototypes for all the MPU wrappers. * Prototypes for all the MPU wrappers.
*/ */
signed portBASE_TYPE MPU_xTaskGenericCreate( pdTASK_CODE pvTaskCode, const signed char * const pcName, unsigned short usStackDepth, void *pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle *pxCreatedTask, portSTACK_TYPE *puxStackBuffer, const xMemoryRegion * const xRegions ); signed portBASE_TYPE MPU_xTaskGenericCreate( pdTASK_CODE pvTaskCode, const char * const pcName, unsigned short usStackDepth, void *pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle *pxCreatedTask, portSTACK_TYPE *puxStackBuffer, const xMemoryRegion * const xRegions );
void MPU_vTaskAllocateMPURegions( xTaskHandle xTask, const xMemoryRegion * const xRegions ); void MPU_vTaskAllocateMPURegions( xTaskHandle xTask, const xMemoryRegion * const xRegions );
void MPU_vTaskDelete( xTaskHandle pxTaskToDelete ); void MPU_vTaskDelete( xTaskHandle pxTaskToDelete );
void MPU_vTaskDelayUntil( portTickType * const pxPreviousWakeTime, portTickType xTimeIncrement ); void MPU_vTaskDelayUntil( portTickType * const pxPreviousWakeTime, portTickType xTimeIncrement );
@ -185,8 +185,8 @@ void MPU_vTaskSuspendAll( void );
signed portBASE_TYPE MPU_xTaskResumeAll( void ); signed portBASE_TYPE MPU_xTaskResumeAll( void );
portTickType MPU_xTaskGetTickCount( void ); portTickType MPU_xTaskGetTickCount( void );
unsigned portBASE_TYPE MPU_uxTaskGetNumberOfTasks( void ); unsigned portBASE_TYPE MPU_uxTaskGetNumberOfTasks( void );
void MPU_vTaskList( signed char *pcWriteBuffer ); void MPU_vTaskList( char *pcWriteBuffer );
void MPU_vTaskGetRunTimeStats( signed char *pcWriteBuffer ); void MPU_vTaskGetRunTimeStats( char *pcWriteBuffer );
void MPU_vTaskSetApplicationTaskTag( xTaskHandle xTask, pdTASK_HOOK_CODE pxTagValue ); void MPU_vTaskSetApplicationTaskTag( xTaskHandle xTask, pdTASK_HOOK_CODE pxTagValue );
pdTASK_HOOK_CODE MPU_xTaskGetApplicationTaskTag( xTaskHandle xTask ); pdTASK_HOOK_CODE MPU_xTaskGetApplicationTaskTag( xTaskHandle xTask );
portBASE_TYPE MPU_xTaskCallApplicationTaskHook( xTaskHandle xTask, void *pvParameter ); portBASE_TYPE MPU_xTaskCallApplicationTaskHook( xTaskHandle xTask, void *pvParameter );
@ -206,7 +206,7 @@ portBASE_TYPE MPU_xQueueTakeMutexRecursive( xQueueHandle xMutex, portTickType xB
portBASE_TYPE MPU_xQueueGiveMutexRecursive( xQueueHandle xMutex ); portBASE_TYPE MPU_xQueueGiveMutexRecursive( xQueueHandle xMutex );
signed portBASE_TYPE MPU_xQueueAltGenericSend( xQueueHandle pxQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition ); signed portBASE_TYPE MPU_xQueueAltGenericSend( xQueueHandle pxQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition );
signed portBASE_TYPE MPU_xQueueAltGenericReceive( xQueueHandle pxQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking ); signed portBASE_TYPE MPU_xQueueAltGenericReceive( xQueueHandle pxQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking );
void MPU_vQueueAddToRegistry( xQueueHandle xQueue, signed char *pcName ); void MPU_vQueueAddToRegistry( xQueueHandle xQueue, char *pcName );
void MPU_vQueueDelete( xQueueHandle xQueue ); void MPU_vQueueDelete( xQueueHandle xQueue );
void *MPU_pvPortMalloc( size_t xSize ); void *MPU_pvPortMalloc( size_t xSize );
void MPU_vPortFree( void *pv ); void MPU_vPortFree( void *pv );
@ -673,7 +673,7 @@ unsigned long ul;
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
signed portBASE_TYPE MPU_xTaskGenericCreate( pdTASK_CODE pvTaskCode, const signed char * const pcName, unsigned short usStackDepth, void *pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle *pxCreatedTask, portSTACK_TYPE *puxStackBuffer, const xMemoryRegion * const xRegions ) signed portBASE_TYPE MPU_xTaskGenericCreate( pdTASK_CODE pvTaskCode, const char * const pcName, unsigned short usStackDepth, void *pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle *pxCreatedTask, portSTACK_TYPE *puxStackBuffer, const xMemoryRegion * const xRegions )
{ {
signed portBASE_TYPE xReturn; signed portBASE_TYPE xReturn;
portBASE_TYPE xRunningPrivileged = prvRaisePrivilege(); portBASE_TYPE xRunningPrivileged = prvRaisePrivilege();
@ -854,7 +854,7 @@ portBASE_TYPE xRunningPrivileged = prvRaisePrivilege();
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
#if ( configUSE_TRACE_FACILITY == 1 ) #if ( configUSE_TRACE_FACILITY == 1 )
void MPU_vTaskList( signed char *pcWriteBuffer ) void MPU_vTaskList( char *pcWriteBuffer )
{ {
portBASE_TYPE xRunningPrivileged = prvRaisePrivilege(); portBASE_TYPE xRunningPrivileged = prvRaisePrivilege();
@ -865,7 +865,7 @@ portBASE_TYPE xRunningPrivileged = prvRaisePrivilege();
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
#if ( configGENERATE_RUN_TIME_STATS == 1 ) #if ( configGENERATE_RUN_TIME_STATS == 1 )
void MPU_vTaskGetRunTimeStats( signed char *pcWriteBuffer ) void MPU_vTaskGetRunTimeStats( char *pcWriteBuffer )
{ {
portBASE_TYPE xRunningPrivileged = prvRaisePrivilege(); portBASE_TYPE xRunningPrivileged = prvRaisePrivilege();
@ -1161,7 +1161,7 @@ signed portBASE_TYPE xReturn;
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
#if configQUEUE_REGISTRY_SIZE > 0 #if configQUEUE_REGISTRY_SIZE > 0
void MPU_vQueueAddToRegistry( xQueueHandle xQueue, signed char *pcName ) void MPU_vQueueAddToRegistry( xQueueHandle xQueue, char *pcName )
{ {
portBASE_TYPE xRunningPrivileged = prvRaisePrivilege(); portBASE_TYPE xRunningPrivileged = prvRaisePrivilege();

72
FreeRTOS/Source/portable/MSVC-MingW/port.c
View File

@ -1,5 +1,5 @@
/* /*
FreeRTOS V7.6.0 - Copyright (C) 2013 Real Time Engineers Ltd. FreeRTOS V7.6.0 - Copyright (C) 2013 Real Time Engineers Ltd.
All rights reserved 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.
@ -80,13 +80,13 @@
/* /*
* Created as a high priority thread, this function uses a timer to simulate * Created as a high priority thread, this function uses a timer to simulate
* a tick interrupt being generated on an embedded target. In this Windows * a tick interrupt being generated on an embedded target. In this Windows
* environment the timer does not achieve anything approaching real time * environment the timer does not achieve anything approaching real time
* performance though. * performance though.
*/ */
static DWORD WINAPI prvSimulatedPeripheralTimer( LPVOID lpParameter ); static DWORD WINAPI prvSimulatedPeripheralTimer( LPVOID lpParameter );
/* /*
* Process all the simulated interrupts - each represented by a bit in * Process all the simulated interrupts - each represented by a bit in
* ulPendingInterrupts variable. * ulPendingInterrupts variable.
*/ */
static void prvProcessSimulatedInterrupts( void ); static void prvProcessSimulatedInterrupts( void );
@ -109,7 +109,7 @@ static BOOL WINAPI prvEndProcess( DWORD dwCtrlType );
/* The WIN32 simulator runs each task in a thread. The context switching is /* The WIN32 simulator runs each task in a thread. The context switching is
managed by the threads, so the task stack does not have to be managed directly, managed by the threads, so the task stack does not have to be managed directly,
although the task stack is still used to hold an xThreadState structure this is although the task stack is still used to hold an xThreadState structure this is
the only thing it will ever hold. The structure indirectly maps the task handle the only thing it will ever hold. The structure indirectly maps the task handle
to a thread handle. */ to a thread handle. */
typedef struct typedef struct
{ {
@ -122,21 +122,21 @@ typedef struct
bit represents one interrupt, so a maximum of 32 interrupts can be simulated. */ bit represents one interrupt, so a maximum of 32 interrupts can be simulated. */
static volatile unsigned long ulPendingInterrupts = 0UL; static volatile unsigned long ulPendingInterrupts = 0UL;
/* An event used to inform the simulated interrupt processing thread (a high /* An event used to inform the simulated interrupt processing thread (a high
priority thread that simulated interrupt processing) that an interrupt is priority thread that simulated interrupt processing) that an interrupt is
pending. */ pending. */
static void *pvInterruptEvent = NULL; static void *pvInterruptEvent = NULL;
/* Mutex used to protect all the simulated interrupt variables that are accessed /* Mutex used to protect all the simulated interrupt variables that are accessed
by multiple threads. */ by multiple threads. */
static void *pvInterruptEventMutex = NULL; static void *pvInterruptEventMutex = NULL;
/* The critical nesting count for the currently executing task. This is /* The critical nesting count for the currently executing task. This is
initialised to a non-zero value so interrupts do not become enabled during initialised to a non-zero value so interrupts do not become enabled during
the initialisation phase. As each task has its own critical nesting value the initialisation phase. As each task has its own critical nesting value
ulCriticalNesting will get set to zero when the first task runs. This ulCriticalNesting will get set to zero when the first task runs. This
initialisation is probably not critical in this simulated environment as the initialisation is probably not critical in this simulated environment as the
simulated interrupt handlers do not get created until the FreeRTOS scheduler is simulated interrupt handlers do not get created until the FreeRTOS scheduler is
started anyway. */ started anyway. */
static unsigned long ulCriticalNesting = 9999UL; static unsigned long ulCriticalNesting = 9999UL;
@ -178,11 +178,11 @@ TIMECAPS xTimeCaps;
for(;;) for(;;)
{ {
/* Wait until the timer expires and we can access the simulated interrupt /* Wait until the timer expires and we can access the simulated interrupt
variables. *NOTE* this is not a 'real time' way of generating tick variables. *NOTE* this is not a 'real time' way of generating tick
events as the next wake time should be relative to the previous wake events as the next wake time should be relative to the previous wake
time, not the time that Sleep() is called. It is done this way to time, not the time that Sleep() is called. It is done this way to
prevent overruns in this very non real time simulated/emulated prevent overruns in this very non real time simulated/emulated
environment. */ environment. */
if( portTICK_RATE_MS < xMinimumWindowsBlockTime ) if( portTICK_RATE_MS < xMinimumWindowsBlockTime )
{ {
@ -200,14 +200,14 @@ TIMECAPS xTimeCaps;
/* The timer has expired, generate the simulated tick event. */ /* The timer has expired, generate the simulated tick event. */
ulPendingInterrupts |= ( 1 << portINTERRUPT_TICK ); ulPendingInterrupts |= ( 1 << portINTERRUPT_TICK );
/* The interrupt is now pending - notify the simulated interrupt /* The interrupt is now pending - notify the simulated interrupt
handler thread. */ handler thread. */
if( ulCriticalNesting == 0 ) if( ulCriticalNesting == 0 )
{ {
SetEvent( pvInterruptEvent ); SetEvent( pvInterruptEvent );
} }
/* Give back the mutex so the simulated interrupt handler unblocks /* Give back the mutex so the simulated interrupt handler unblocks
and can access the interrupt handler variables. */ and can access the interrupt handler variables. */
ReleaseMutex( pvInterruptEventMutex ); ReleaseMutex( pvInterruptEventMutex );
} }
@ -240,7 +240,7 @@ TIMECAPS xTimeCaps;
portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters ) portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters )
{ {
xThreadState *pxThreadState = NULL; xThreadState *pxThreadState = NULL;
char *pcTopOfStack = ( char * ) pxTopOfStack; signed char *pcTopOfStack = ( char * ) pxTopOfStack;
/* In this simulated case a stack is not initialised, but instead a thread /* In this simulated case a stack is not initialised, but instead a thread
is created that will execute the task being created. The thread handles is created that will execute the task being created. The thread handles
@ -256,7 +256,7 @@ char *pcTopOfStack = ( char * ) pxTopOfStack;
SetThreadAffinityMask( pxThreadState->pvThread, 0x01 ); SetThreadAffinityMask( pxThreadState->pvThread, 0x01 );
SetThreadPriorityBoost( pxThreadState->pvThread, TRUE ); SetThreadPriorityBoost( pxThreadState->pvThread, TRUE );
SetThreadPriority( pxThreadState->pvThread, THREAD_PRIORITY_IDLE ); SetThreadPriority( pxThreadState->pvThread, THREAD_PRIORITY_IDLE );
return ( portSTACK_TYPE * ) pxThreadState; return ( portSTACK_TYPE * ) pxThreadState;
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -281,7 +281,7 @@ xThreadState *pxThreadState;
lSuccess = pdFAIL; lSuccess = pdFAIL;
} }
/* Set the priority of this thread such that it is above the priority of /* Set the priority of this thread such that it is above the priority of
the threads that run tasks. This higher priority is required to ensure the threads that run tasks. This higher priority is required to ensure
simulated interrupts take priority over tasks. */ simulated interrupts take priority over tasks. */
pvHandle = GetCurrentThread(); pvHandle = GetCurrentThread();
@ -289,7 +289,7 @@ xThreadState *pxThreadState;
{ {
lSuccess = pdFAIL; lSuccess = pdFAIL;
} }
if( lSuccess == pdPASS ) if( lSuccess == pdPASS )
{ {
if( SetThreadPriority( pvHandle, THREAD_PRIORITY_NORMAL ) == 0 ) if( SetThreadPriority( pvHandle, THREAD_PRIORITY_NORMAL ) == 0 )
@ -303,7 +303,7 @@ xThreadState *pxThreadState;
if( lSuccess == pdPASS ) if( lSuccess == pdPASS )
{ {
/* Start the thread that simulates the timer peripheral to generate /* Start the thread that simulates the timer peripheral to generate
tick interrupts. The priority is set below that of the simulated tick interrupts. The priority is set below that of the simulated
interrupt handler so the interrupt event mutex is used for the interrupt handler so the interrupt event mutex is used for the
handshake / overrun protection. */ handshake / overrun protection. */
pvHandle = CreateThread( NULL, 0, prvSimulatedPeripheralTimer, NULL, 0, NULL ); pvHandle = CreateThread( NULL, 0, prvSimulatedPeripheralTimer, NULL, 0, NULL );
@ -313,8 +313,8 @@ xThreadState *pxThreadState;
SetThreadPriorityBoost( pvHandle, TRUE ); SetThreadPriorityBoost( pvHandle, TRUE );
SetThreadAffinityMask( pvHandle, 0x01 ); SetThreadAffinityMask( pvHandle, 0x01 );
} }
/* Start the highest priority task by obtaining its associated thread /* Start the highest priority task by obtaining its associated thread
state structure, in which is stored the thread handle. */ state structure, in which is stored the thread handle. */
pxThreadState = ( xThreadState * ) *( ( unsigned long * ) pxCurrentTCB ); pxThreadState = ( xThreadState * ) *( ( unsigned long * ) pxCurrentTCB );
ulCriticalNesting = portNO_CRITICAL_NESTING; ulCriticalNesting = portNO_CRITICAL_NESTING;
@ -324,12 +324,12 @@ xThreadState *pxThreadState;
behave as an embedded engineer might expect. */ behave as an embedded engineer might expect. */
ResumeThread( pxThreadState->pvThread ); ResumeThread( pxThreadState->pvThread );
/* Handle all simulated interrupts - including yield requests and /* Handle all simulated interrupts - including yield requests and
simulated ticks. */ simulated ticks. */
prvProcessSimulatedInterrupts(); prvProcessSimulatedInterrupts();
} }
/* Would not expect to return from prvProcessSimulatedInterrupts(), so should /* Would not expect to return from prvProcessSimulatedInterrupts(), so should
not get here. */ not get here. */
return 0; return 0;
} }
@ -359,7 +359,7 @@ unsigned long ulSwitchRequired, i;
xThreadState *pxThreadState; xThreadState *pxThreadState;
void *pvObjectList[ 2 ]; void *pvObjectList[ 2 ];
/* Going to block on the mutex that ensured exclusive access to the simulated /* Going to block on the mutex that ensured exclusive access to the simulated
interrupt objects, and the event that signals that a simulated interrupt interrupt objects, and the event that signals that a simulated interrupt
should be processed. */ should be processed. */
pvObjectList[ 0 ] = pvInterruptEventMutex; pvObjectList[ 0 ] = pvInterruptEventMutex;
@ -419,7 +419,7 @@ void *pvObjectList[ 2 ];
pxThreadState = ( xThreadState *) *( ( unsigned long * ) pvOldCurrentTCB ); pxThreadState = ( xThreadState *) *( ( unsigned long * ) pvOldCurrentTCB );
SuspendThread( pxThreadState->pvThread ); SuspendThread( pxThreadState->pvThread );
/* Obtain the state of the task now selected to enter the /* Obtain the state of the task now selected to enter the
Running state. */ Running state. */
pxThreadState = ( xThreadState * ) ( *( unsigned long *) pxCurrentTCB ); pxThreadState = ( xThreadState * ) ( *( unsigned long *) pxCurrentTCB );
ResumeThread( pxThreadState->pvThread ); ResumeThread( pxThreadState->pvThread );
@ -484,7 +484,7 @@ unsigned long ulErrorCode;
ensure a context switch occurs away from this thread on the next tick. */ ensure a context switch occurs away from this thread on the next tick. */
*pxPendYield = pdTRUE; *pxPendYield = pdTRUE;
/* Mark the thread associated with this task as invalid so /* Mark the thread associated with this task as invalid so
vPortDeleteThread() does not try to terminate it. */ vPortDeleteThread() does not try to terminate it. */
pxThreadState->pvThread = NULL; pxThreadState->pvThread = NULL;
@ -518,7 +518,7 @@ void vPortGenerateSimulatedInterrupt( unsigned long ulInterruptNumber )
be in a critical section as calls to wait for mutexes are accumulative. */ be in a critical section as calls to wait for mutexes are accumulative. */
if( ulCriticalNesting == 0 ) if( ulCriticalNesting == 0 )
{ {
SetEvent( pvInterruptEvent ); SetEvent( pvInterruptEvent );
} }
ReleaseMutex( pvInterruptEventMutex ); ReleaseMutex( pvInterruptEventMutex );
@ -556,7 +556,7 @@ void vPortEnterCritical( void )
else else
{ {
ulCriticalNesting++; ulCriticalNesting++;
} }
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -575,7 +575,7 @@ long lMutexNeedsReleasing;
{ {
ulCriticalNesting--; ulCriticalNesting--;
/* Were any interrupts set to pending while interrupts were /* Were any interrupts set to pending while interrupts were
(simulated) disabled? */ (simulated) disabled? */
if( ulPendingInterrupts != 0UL ) if( ulPendingInterrupts != 0UL )
{ {

4
FreeRTOS/Source/queue.c
View File

@ -167,7 +167,7 @@ typedef struct QueueDefinition
more user friendly. */ more user friendly. */
typedef struct QUEUE_REGISTRY_ITEM typedef struct QUEUE_REGISTRY_ITEM
{ {
signed char *pcQueueName; char *pcQueueName; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
xQueueHandle xHandle; xQueueHandle xHandle;
} xQueueRegistryItem; } xQueueRegistryItem;
@ -2143,7 +2143,7 @@ signed portBASE_TYPE xReturn;
#if ( configQUEUE_REGISTRY_SIZE > 0 ) #if ( configQUEUE_REGISTRY_SIZE > 0 )
void vQueueAddToRegistry( xQueueHandle xQueue, signed char *pcQueueName ) void vQueueAddToRegistry( xQueueHandle xQueue, char *pcQueueName ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
{ {
unsigned portBASE_TYPE ux; unsigned portBASE_TYPE ux;

62
FreeRTOS/Source/tasks.c
View File

@ -129,7 +129,7 @@ typedef struct tskTaskControlBlock
xListItem xEventListItem; /*< Used to reference a task from an event list. */ xListItem xEventListItem; /*< Used to reference a task from an event list. */
unsigned portBASE_TYPE uxPriority; /*< The priority of the task. 0 is the lowest priority. */ unsigned portBASE_TYPE uxPriority; /*< The priority of the task. 0 is the lowest priority. */
portSTACK_TYPE *pxStack; /*< Points to the start of the stack. */ portSTACK_TYPE *pxStack; /*< Points to the start of the stack. */
signed char pcTaskName[ configMAX_TASK_NAME_LEN ];/*< Descriptive name given to the task when created. Facilitates debugging only. */ char pcTaskName[ configMAX_TASK_NAME_LEN ];/*< Descriptive name given to the task when created. Facilitates debugging only. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
#if ( portSTACK_GROWTH > 0 ) #if ( portSTACK_GROWTH > 0 )
portSTACK_TYPE *pxEndOfStack; /*< Points to the end of the stack on architectures where the stack grows up from low memory. */ portSTACK_TYPE *pxEndOfStack; /*< Points to the end of the stack on architectures where the stack grows up from low memory. */
@ -241,10 +241,10 @@ PRIVILEGED_DATA static volatile portTickType xNextTaskUnblockTime = portMAX_D
/* /*
* Macros used by vListTask to indicate which state a task is in. * Macros used by vListTask to indicate which state a task is in.
*/ */
#define tskBLOCKED_CHAR ( ( signed char ) 'B' ) #define tskBLOCKED_CHAR ( 'B' )
#define tskREADY_CHAR ( ( signed char ) 'R' ) #define tskREADY_CHAR ( 'R' )
#define tskDELETED_CHAR ( ( signed char ) 'D' ) #define tskDELETED_CHAR ( 'D' )
#define tskSUSPENDED_CHAR ( ( signed char ) 'S' ) #define tskSUSPENDED_CHAR ( 'S' )
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -378,7 +378,7 @@ to its original value when it is released. */
/* Callback function prototypes. --------------------------*/ /* Callback function prototypes. --------------------------*/
#if configCHECK_FOR_STACK_OVERFLOW > 0 #if configCHECK_FOR_STACK_OVERFLOW > 0
extern void vApplicationStackOverflowHook( xTaskHandle xTask, signed char *pcTaskName ); extern void vApplicationStackOverflowHook( xTaskHandle xTask, char *pcTaskName );
#endif #endif
#if configUSE_TICK_HOOK > 0 #if configUSE_TICK_HOOK > 0
@ -391,7 +391,7 @@ to its original value when it is released. */
* Utility to ready a TCB for a given task. Mainly just copies the parameters * Utility to ready a TCB for a given task. Mainly just copies the parameters
* into the TCB structure. * into the TCB structure.
*/ */
static void prvInitialiseTCBVariables( tskTCB * const pxTCB, const signed char * const pcName, unsigned portBASE_TYPE uxPriority, const xMemoryRegion * const xRegions, const unsigned short usStackDepth ) PRIVILEGED_FUNCTION; static void prvInitialiseTCBVariables( tskTCB * const pxTCB, const char * const pcName, unsigned portBASE_TYPE uxPriority, const xMemoryRegion * const xRegions, const unsigned short usStackDepth ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
/* /*
* Utility to ready all the lists used by the scheduler. This is called * Utility to ready all the lists used by the scheduler. This is called
@ -492,7 +492,7 @@ static void prvResetNextTaskUnblockTime( void );
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
signed portBASE_TYPE xTaskGenericCreate( pdTASK_CODE pxTaskCode, const signed char * const pcName, const unsigned short usStackDepth, void * const pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle * const pxCreatedTask, portSTACK_TYPE * const puxStackBuffer, const xMemoryRegion * const xRegions ) signed portBASE_TYPE xTaskGenericCreate( pdTASK_CODE pxTaskCode, const char * const pcName, const unsigned short usStackDepth, void * const pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle * const pxCreatedTask, portSTACK_TYPE * const puxStackBuffer, const xMemoryRegion * const xRegions ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
{ {
signed portBASE_TYPE xReturn; signed portBASE_TYPE xReturn;
tskTCB * pxNewTCB; tskTCB * pxNewTCB;
@ -1111,7 +1111,7 @@ tskTCB * pxNewTCB;
/* Only reset the event list item value if the value is not /* Only reset the event list item value if the value is not
being used for anything else. */ being used for anything else. */
if( ( listGET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE_IN_USE ) == 0 ) if( ( listGET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE_IN_USE ) == 0UL )
{ {
listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( ( portTickType ) configMAX_PRIORITIES - ( portTickType ) uxNewPriority ) ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */ listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( ( portTickType ) configMAX_PRIORITIES - ( portTickType ) uxNewPriority ) ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
} }
@ -1430,12 +1430,12 @@ portBASE_TYPE xReturn;
{ {
/* Create the idle task, storing its handle in xIdleTaskHandle so it can /* Create the idle task, storing its handle in xIdleTaskHandle so it can
be returned by the xTaskGetIdleTaskHandle() function. */ be returned by the xTaskGetIdleTaskHandle() function. */
xReturn = xTaskCreate( prvIdleTask, ( signed char * ) "IDLE", tskIDLE_STACK_SIZE, ( void * ) NULL, ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), &xIdleTaskHandle ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */ xReturn = xTaskCreate( prvIdleTask, "IDLE", tskIDLE_STACK_SIZE, ( void * ) NULL, ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), &xIdleTaskHandle ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */
} }
#else #else
{ {
/* Create the idle task without storing its handle. */ /* Create the idle task without storing its handle. */
xReturn = xTaskCreate( prvIdleTask, ( signed char * ) "IDLE", tskIDLE_STACK_SIZE, ( void * ) NULL, ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), NULL ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */ xReturn = xTaskCreate( prvIdleTask, "IDLE", tskIDLE_STACK_SIZE, ( void * ) NULL, ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), NULL ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */
} }
#endif /* INCLUDE_xTaskGetIdleTaskHandle */ #endif /* INCLUDE_xTaskGetIdleTaskHandle */
@ -1695,7 +1695,7 @@ unsigned portBASE_TYPE uxTaskGetNumberOfTasks( void )
#if ( INCLUDE_pcTaskGetTaskName == 1 ) #if ( INCLUDE_pcTaskGetTaskName == 1 )
signed char *pcTaskGetTaskName( xTaskHandle xTaskToQuery ) char *pcTaskGetTaskName( xTaskHandle xTaskToQuery )
{ {
tskTCB *pxTCB; tskTCB *pxTCB;
@ -2659,7 +2659,7 @@ static portTASK_FUNCTION( prvIdleTask, pvParameters )
#endif /* configUSE_TICKLESS_IDLE */ #endif /* configUSE_TICKLESS_IDLE */
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
static void prvInitialiseTCBVariables( tskTCB * const pxTCB, const signed char * const pcName, unsigned portBASE_TYPE uxPriority, const xMemoryRegion * const xRegions, const unsigned short usStackDepth ) static void prvInitialiseTCBVariables( tskTCB * const pxTCB, const char * const pcName, unsigned portBASE_TYPE uxPriority, const xMemoryRegion * const xRegions, const unsigned short usStackDepth ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
{ {
unsigned portBASE_TYPE x; unsigned portBASE_TYPE x;
@ -2683,7 +2683,7 @@ unsigned portBASE_TYPE x;
/* Ensure the name string is terminated in the case that the string length /* Ensure the name string is terminated in the case that the string length
was greater or equal to configMAX_TASK_NAME_LEN. */ was greater or equal to configMAX_TASK_NAME_LEN. */
pxTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = ( signed char ) '\0'; pxTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0';
/* This is used as an array index so must ensure it's not too large. First /* This is used as an array index so must ensure it's not too large. First
remove the privilege bit if one is present. */ remove the privilege bit if one is present. */
@ -2925,7 +2925,7 @@ tskTCB *pxNewTCB;
listGET_OWNER_OF_NEXT_ENTRY( pxNextTCB, pxList ); listGET_OWNER_OF_NEXT_ENTRY( pxNextTCB, pxList );
pxTaskStatusArray[ uxTask ].xHandle = ( xTaskHandle ) pxNextTCB; pxTaskStatusArray[ uxTask ].xHandle = ( xTaskHandle ) pxNextTCB;
pxTaskStatusArray[ uxTask ].pcTaskName = ( const signed char * ) &( pxNextTCB->pcTaskName [ 0 ] ); pxTaskStatusArray[ uxTask ].pcTaskName = ( const char * ) &( pxNextTCB->pcTaskName [ 0 ] );
pxTaskStatusArray[ uxTask ].xTaskNumber = pxNextTCB->uxTCBNumber; pxTaskStatusArray[ uxTask ].xTaskNumber = pxNextTCB->uxTCBNumber;
pxTaskStatusArray[ uxTask ].eCurrentState = eState; pxTaskStatusArray[ uxTask ].eCurrentState = eState;
pxTaskStatusArray[ uxTask ].uxCurrentPriority = pxNextTCB->uxPriority; pxTaskStatusArray[ uxTask ].uxCurrentPriority = pxNextTCB->uxPriority;
@ -3000,22 +3000,22 @@ tskTCB *pxNewTCB;
unsigned portBASE_TYPE uxTaskGetStackHighWaterMark( xTaskHandle xTask ) unsigned portBASE_TYPE uxTaskGetStackHighWaterMark( xTaskHandle xTask )
{ {
tskTCB *pxTCB; tskTCB *pxTCB;
unsigned char *pcEndOfStack; unsigned char *pucEndOfStack;
unsigned portBASE_TYPE uxReturn; unsigned portBASE_TYPE uxReturn;
pxTCB = prvGetTCBFromHandle( xTask ); pxTCB = prvGetTCBFromHandle( xTask );
#if portSTACK_GROWTH < 0 #if portSTACK_GROWTH < 0
{ {
pcEndOfStack = ( unsigned char * ) pxTCB->pxStack; pucEndOfStack = ( unsigned char * ) pxTCB->pxStack;
} }
#else #else
{ {
pcEndOfStack = ( unsigned char * ) pxTCB->pxEndOfStack; pucEndOfStack = ( unsigned char * ) pxTCB->pxEndOfStack;
} }
#endif #endif
uxReturn = ( unsigned portBASE_TYPE ) prvTaskCheckFreeStackSpace( pcEndOfStack ); uxReturn = ( unsigned portBASE_TYPE ) prvTaskCheckFreeStackSpace( pucEndOfStack );
return uxReturn; return uxReturn;
} }
@ -3126,7 +3126,7 @@ tskTCB *pxTCB;
/* Adjust the mutex holder state to account for its new /* Adjust the mutex holder state to account for its new
priority. Only reset the event list item value if the value is priority. Only reset the event list item value if the value is
not being used for anything else. */ not being used for anything else. */
if( ( listGET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE_IN_USE ) == 0 ) if( ( listGET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE_IN_USE ) == 0UL )
{ {
listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( portTickType ) configMAX_PRIORITIES - ( portTickType ) pxCurrentTCB->uxPriority ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */ listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( portTickType ) configMAX_PRIORITIES - ( portTickType ) pxCurrentTCB->uxPriority ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
} }
@ -3202,7 +3202,7 @@ tskTCB *pxTCB;
/* Only reset the event list item value if the value is not /* Only reset the event list item value if the value is not
being used for anything else. */ being used for anything else. */
if( ( listGET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE_IN_USE ) == 0 ) if( ( listGET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE_IN_USE ) == 0UL )
{ {
listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( portTickType ) configMAX_PRIORITIES - ( portTickType ) pxTCB->uxPriority ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */ listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( portTickType ) configMAX_PRIORITIES - ( portTickType ) pxTCB->uxPriority ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
} }
@ -3280,11 +3280,11 @@ tskTCB *pxTCB;
#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS == 1 ) ) #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS == 1 ) )
void vTaskList( signed char * pcWriteBuffer ) void vTaskList( char * pcWriteBuffer )
{ {
xTaskStatusType *pxTaskStatusArray; xTaskStatusType *pxTaskStatusArray;
volatile unsigned portBASE_TYPE uxArraySize, x; volatile unsigned portBASE_TYPE uxArraySize, x;
signed char cStatus; char cStatus;
/* /*
* PLEASE NOTE: * PLEASE NOTE:
@ -3349,8 +3349,8 @@ tskTCB *pxTCB;
break; break;
} }
sprintf( ( char * ) pcWriteBuffer, ( char * ) "%s\t\t%c\t%u\t%u\t%u\r\n", pxTaskStatusArray[ x ].pcTaskName, ( char ) cStatus, ( unsigned int ) pxTaskStatusArray[ x ].uxCurrentPriority, ( unsigned int ) pxTaskStatusArray[ x ].usStackHighWaterMark, ( unsigned int ) pxTaskStatusArray[ x ].xTaskNumber ); sprintf( pcWriteBuffer, "%s\t\t%c\t%u\t%u\t%u\r\n", pxTaskStatusArray[ x ].pcTaskName, cStatus, ( unsigned int ) pxTaskStatusArray[ x ].uxCurrentPriority, ( unsigned int ) pxTaskStatusArray[ x ].usStackHighWaterMark, ( unsigned int ) pxTaskStatusArray[ x ].xTaskNumber );
pcWriteBuffer += strlen( ( char * ) pcWriteBuffer ); pcWriteBuffer += strlen( pcWriteBuffer );
} }
/* Free the array again. */ /* Free the array again. */
@ -3367,7 +3367,7 @@ tskTCB *pxTCB;
#if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS == 1 ) ) #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS == 1 ) )
void vTaskGetRunTimeStats( signed char *pcWriteBuffer ) void vTaskGetRunTimeStats( char *pcWriteBuffer )
{ {
xTaskStatusType *pxTaskStatusArray; xTaskStatusType *pxTaskStatusArray;
volatile unsigned portBASE_TYPE uxArraySize, x; volatile unsigned portBASE_TYPE uxArraySize, x;
@ -3431,13 +3431,13 @@ tskTCB *pxTCB;
{ {
#ifdef portLU_PRINTF_SPECIFIER_REQUIRED #ifdef portLU_PRINTF_SPECIFIER_REQUIRED
{ {
sprintf( ( char * ) pcWriteBuffer, ( char * ) "%s\t\t%lu\t\t%lu%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter, ulStatsAsPercentage ); sprintf( pcWriteBuffer, "%s\t\t%lu\t\t%lu%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter, ulStatsAsPercentage );
} }
#else #else
{ {
/* sizeof( int ) == sizeof( long ) so a smaller /* sizeof( int ) == sizeof( long ) so a smaller
printf() library can be used. */ printf() library can be used. */
sprintf( ( char * ) pcWriteBuffer, ( char * ) "%s\t\t%u\t\t%u%%\r\n", pxTaskStatusArray[ x ].pcTaskName, ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter, ( unsigned int ) ulStatsAsPercentage ); sprintf( pcWriteBuffer, "%s\t\t%u\t\t%u%%\r\n", pxTaskStatusArray[ x ].pcTaskName, ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter, ( unsigned int ) ulStatsAsPercentage );
} }
#endif #endif
} }
@ -3447,18 +3447,18 @@ tskTCB *pxTCB;
consumed less than 1% of the total run time. */ consumed less than 1% of the total run time. */
#ifdef portLU_PRINTF_SPECIFIER_REQUIRED #ifdef portLU_PRINTF_SPECIFIER_REQUIRED
{ {
sprintf( ( char * ) pcWriteBuffer, ( char * ) "%s\t\t%lu\t\t<1%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter ); sprintf( pcWriteBuffer, "%s\t\t%lu\t\t<1%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter );
} }
#else #else
{ {
/* sizeof( int ) == sizeof( long ) so a smaller /* sizeof( int ) == sizeof( long ) so a smaller
printf() library can be used. */ printf() library can be used. */
sprintf( ( char * ) pcWriteBuffer, ( char * ) "%s\t\t%u\t\t<1%%\r\n", pxTaskStatusArray[ x ].pcTaskName, ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter ); sprintf( pcWriteBuffer, "%s\t\t%u\t\t<1%%\r\n", pxTaskStatusArray[ x ].pcTaskName, ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter );
} }
#endif #endif
} }
pcWriteBuffer += strlen( ( char * ) pcWriteBuffer ); pcWriteBuffer += strlen( pcWriteBuffer );
} }
} }
else else

10
FreeRTOS/Source/timers.c
View File

@ -99,7 +99,7 @@ configUSE_TIMERS is set to 1 in FreeRTOSConfig.h. */
/* The definition of the timers themselves. */ /* The definition of the timers themselves. */
typedef struct tmrTimerControl typedef struct tmrTimerControl
{ {
const signed char *pcTimerName; /*<< Text name. This is not used by the kernel, it is included simply to make debugging easier. */ const char *pcTimerName; /*<< Text name. This is not used by the kernel, it is included simply to make debugging easier. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
xListItem xTimerListItem; /*<< Standard linked list item as used by all kernel features for event management. */ xListItem xTimerListItem; /*<< Standard linked list item as used by all kernel features for event management. */
portTickType xTimerPeriodInTicks;/*<< How quickly and often the timer expires. */ portTickType xTimerPeriodInTicks;/*<< How quickly and often the timer expires. */
unsigned portBASE_TYPE uxAutoReload; /*<< Set to pdTRUE if the timer should be automatically restarted once expired. Set to pdFALSE if the timer is, in effect, a one-shot timer. */ unsigned portBASE_TYPE uxAutoReload; /*<< Set to pdTRUE if the timer should be automatically restarted once expired. Set to pdFALSE if the timer is, in effect, a one-shot timer. */
@ -242,12 +242,12 @@ portBASE_TYPE xReturn = pdFAIL;
{ {
/* Create the timer task, storing its handle in xTimerTaskHandle so /* Create the timer task, storing its handle in xTimerTaskHandle so
it can be returned by the xTimerGetTimerDaemonTaskHandle() function. */ it can be returned by the xTimerGetTimerDaemonTaskHandle() function. */
xReturn = xTaskCreate( prvTimerTask, ( signed char * ) "Tmr Svc", ( unsigned short ) configTIMER_TASK_STACK_DEPTH, NULL, ( ( unsigned portBASE_TYPE ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT, &xTimerTaskHandle ); xReturn = xTaskCreate( prvTimerTask, "Tmr Svc", ( unsigned short ) configTIMER_TASK_STACK_DEPTH, NULL, ( ( unsigned portBASE_TYPE ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT, &xTimerTaskHandle );
} }
#else #else
{ {
/* Create the timer task without storing its handle. */ /* Create the timer task without storing its handle. */
xReturn = xTaskCreate( prvTimerTask, ( signed char * ) "Tmr Svc", ( unsigned short ) configTIMER_TASK_STACK_DEPTH, NULL, ( ( unsigned portBASE_TYPE ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT, NULL); xReturn = xTaskCreate( prvTimerTask, "Tmr Svc", ( unsigned short ) configTIMER_TASK_STACK_DEPTH, NULL, ( ( unsigned portBASE_TYPE ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT, NULL);
} }
#endif #endif
} }
@ -261,7 +261,7 @@ portBASE_TYPE xReturn = pdFAIL;
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
xTimerHandle xTimerCreate( const signed char * const pcTimerName, const portTickType xTimerPeriodInTicks, const unsigned portBASE_TYPE uxAutoReload, void * const pvTimerID, tmrTIMER_CALLBACK pxCallbackFunction ) xTimerHandle xTimerCreate( const char * const pcTimerName, const portTickType xTimerPeriodInTicks, const unsigned portBASE_TYPE uxAutoReload, void * const pvTimerID, tmrTIMER_CALLBACK pxCallbackFunction ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
{ {
xTIMER *pxNewTimer; xTIMER *pxNewTimer;
@ -758,7 +758,7 @@ static void prvCheckForValidListAndQueue( void )
{ {
if( xTimerQueue != NULL ) if( xTimerQueue != NULL )
{ {
vQueueAddToRegistry( xTimerQueue, ( signed char * ) "TmrQ" ); vQueueAddToRegistry( xTimerQueue, "TmrQ" );
} }
else else
{ {