/*\r
- FreeRTOS V8.0.0 - Copyright (C) 2014 Real Time Engineers Ltd. \r
+ FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.\r
All rights reserved\r
\r
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
\r
- ***************************************************************************\r
- * *\r
- * FreeRTOS provides completely free yet professionally developed, *\r
- * robust, strictly quality controlled, supported, and cross *\r
- * platform software that has become a de facto standard. *\r
- * *\r
- * Help yourself get started quickly and support the FreeRTOS *\r
- * project by purchasing a FreeRTOS tutorial book, reference *\r
- * manual, or both from: http://www.FreeRTOS.org/Documentation *\r
- * *\r
- * Thank you! *\r
- * *\r
- ***************************************************************************\r
-\r
This file is part of the FreeRTOS distribution.\r
\r
FreeRTOS is free software; you can redistribute it and/or modify it under\r
the terms of the GNU General Public License (version 2) as published by the\r
- Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.\r
+ Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.\r
\r
- >>! NOTE: The modification to the GPL is included to allow you to distribute\r
- >>! a combined work that includes FreeRTOS without being obliged to provide\r
- >>! the source code for proprietary components outside of the FreeRTOS\r
- >>! kernel.\r
+ ***************************************************************************\r
+ >>! NOTE: The modification to the GPL is included to allow you to !<<\r
+ >>! distribute a combined work that includes FreeRTOS without being !<<\r
+ >>! obliged to provide the source code for proprietary components !<<\r
+ >>! outside of the FreeRTOS kernel. !<<\r
+ ***************************************************************************\r
\r
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
- FOR A PARTICULAR PURPOSE. Full license text is available from the following\r
+ FOR A PARTICULAR PURPOSE. Full license text is available on the following\r
link: http://www.freertos.org/a00114.html\r
\r
- 1 tab == 4 spaces!\r
-\r
***************************************************************************\r
* *\r
- * Having a problem? Start by reading the FAQ "My application does *\r
- * not run, what could be wrong?" *\r
+ * FreeRTOS provides completely free yet professionally developed, *\r
+ * robust, strictly quality controlled, supported, and cross *\r
+ * platform software that is more than just the market leader, it *\r
+ * is the industry's de facto standard. *\r
* *\r
- * http://www.FreeRTOS.org/FAQHelp.html *\r
+ * Help yourself get started quickly while simultaneously helping *\r
+ * to support the FreeRTOS project by purchasing a FreeRTOS *\r
+ * tutorial book, reference manual, or both: *\r
+ * http://www.FreeRTOS.org/Documentation *\r
* *\r
***************************************************************************\r
\r
- http://www.FreeRTOS.org - Documentation, books, training, latest versions,\r
- license and Real Time Engineers Ltd. contact details.\r
+ http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading\r
+ the FAQ page "My application does not run, what could be wrong?". Have you\r
+ defined configASSERT()?\r
+\r
+ http://www.FreeRTOS.org/support - In return for receiving this top quality\r
+ embedded software for free we request you assist our global community by\r
+ participating in the support forum.\r
+\r
+ http://www.FreeRTOS.org/training - Investing in training allows your team to\r
+ be as productive as possible as early as possible. Now you can receive\r
+ FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers\r
+ Ltd, and the world's leading authority on the world's leading RTOS.\r
\r
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
\r
- http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High\r
- Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS\r
- licenses offer ticketed support, indemnification and middleware.\r
+ http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.\r
+ Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.\r
+\r
+ http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High\r
+ Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS\r
+ licenses offer ticketed support, indemnification and commercial middleware.\r
\r
http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
engineered and independently SIL3 certified version for use in safety and\r
\r
#define tmrdemoDONT_BLOCK ( ( TickType_t ) 0 )\r
#define tmrdemoONE_SHOT_TIMER_PERIOD ( xBasePeriod * ( TickType_t ) 3 )\r
-#define trmdemoNUM_TIMER_RESETS ( ( unsigned char ) 10 )\r
+#define trmdemoNUM_TIMER_RESETS ( ( uint8_t ) 10 )\r
\r
/*-----------------------------------------------------------*/\r
\r
\r
/* Flag that will be latched to pdFAIL should any unexpected behaviour be\r
detected in any of the demo tests. */\r
-static volatile portBASE_TYPE xTestStatus = pdPASS;\r
+static volatile BaseType_t xTestStatus = pdPASS;\r
\r
/* Counter that is incremented on each cycle of a test. This is used to\r
detect a stalled task - a test that is no longer running. */\r
-static volatile unsigned long ulLoopCounter = 0;\r
+static volatile uint32_t ulLoopCounter = 0;\r
\r
/* A set of auto reload timers - each of which use the same callback function.\r
The callback function uses the timer ID to index into, and then increment, a\r
counter in the ucAutoReloadTimerCounters[] array. The auto reload timers\r
referenced from xAutoReloadTimers[] are used by the prvTimerTestTask task. */\r
static TimerHandle_t xAutoReloadTimers[ configTIMER_QUEUE_LENGTH + 1 ] = { 0 };\r
-static unsigned char ucAutoReloadTimerCounters[ configTIMER_QUEUE_LENGTH + 1 ] = { 0 };\r
+static uint8_t ucAutoReloadTimerCounters[ configTIMER_QUEUE_LENGTH + 1 ] = { 0 };\r
\r
/* The one shot timer is configured to use a callback function that increments\r
ucOneShotTimerCounter each time it gets called. */\r
static TimerHandle_t xOneShotTimer = NULL;\r
-static unsigned char ucOneShotTimerCounter = ( unsigned char ) 0;\r
+static uint8_t ucOneShotTimerCounter = ( uint8_t ) 0;\r
\r
/* The ISR reload timer is controlled from the tick hook to exercise the timer\r
API functions that can be used from an ISR. It is configured to increment\r
ucISRReloadTimerCounter each time its callback function is executed. */\r
static TimerHandle_t xISRAutoReloadTimer = NULL;\r
-static unsigned char ucISRAutoReloadTimerCounter = ( unsigned char ) 0;\r
+static uint8_t ucISRAutoReloadTimerCounter = ( uint8_t ) 0;\r
\r
/* The ISR one shot timer is controlled from the tick hook to exercise the timer\r
API functions that can be used from an ISR. It is configured to increment\r
ucISRReloadTimerCounter each time its callback function is executed. */\r
static TimerHandle_t xISROneShotTimer = NULL;\r
-static unsigned char ucISROneShotTimerCounter = ( unsigned char ) 0;\r
+static uint8_t ucISROneShotTimerCounter = ( uint8_t ) 0;\r
\r
/* The period of all the timers are a multiple of the base period. The base\r
period is configured by the parameter to vStartTimerDemoTask(). */\r
xOneShotTimer = xTimerCreate( "Oneshot Timer", /* Text name to facilitate debugging. The kernel does not use this itself. */\r
tmrdemoONE_SHOT_TIMER_PERIOD, /* The period for the timer. */\r
pdFALSE, /* Don't auto-reload - hence a one shot timer. */\r
- ( void * ) 0, /* The timer identifier. In this case this is not used as the timer has its own callback. */\r
+ ( void * ) 0, /* The timer identifier. Initialise to 0, then increment each time it is called. */\r
prvOneShotTimerCallback ); /* The callback to be called when the timer expires. */\r
\r
if( xOneShotTimer == NULL )\r
/* Check the auto reload timers can be stopped correctly, and correctly\r
report their state. */\r
prvTest4_CheckAutoReloadTimersCanBeStopped();\r
- \r
+\r
/* Check the one shot timer only calls its callback once after it has been\r
started, and that it reports its state correctly. */\r
prvTest5_CheckBasicOneShotTimerBehaviour();\r
\r
/* This is called to check that the created task is still running and has not\r
detected any errors. */\r
-portBASE_TYPE xAreTimerDemoTasksStillRunning( TickType_t xCycleFrequency )\r
+BaseType_t xAreTimerDemoTasksStillRunning( TickType_t xCycleFrequency )\r
{\r
-static unsigned long ulLastLoopCounter = 0UL;\r
+static uint32_t ulLastLoopCounter = 0UL;\r
TickType_t xMaxBlockTimeUsedByTheseTests, xLoopCounterIncrementTimeMax;\r
static TickType_t xIterationsWithoutCounterIncrement = ( TickType_t ) 0, xLastCycleFrequency;\r
\r
elsewhere. Start counting Iterations again. */\r
xIterationsWithoutCounterIncrement = ( TickType_t ) 0;\r
xLastCycleFrequency = xCycleFrequency;\r
- } \r
+ }\r
\r
/* Calculate the maximum number of times that it is permissible for this\r
function to be called without ulLoopCounter being incremented. This is\r
\r
static void prvTest1_CreateTimersWithoutSchedulerRunning( void )\r
{\r
-unsigned portBASE_TYPE xTimer;\r
+TickType_t xTimer;\r
\r
for( xTimer = 0; xTimer < configTIMER_QUEUE_LENGTH; xTimer++ )\r
{\r
( void * ) xTimer, /* An identifier for the timer as all the auto reload timers use the same callback. */\r
prvAutoReloadTimerCallback ); /* The callback to be called when the timer expires. */\r
\r
+ configASSERT( strcmp( pcTimerGetTimerName( xAutoReloadTimers[ xTimer ] ), "FR Timer" ) == 0 );\r
+\r
if( xAutoReloadTimers[ xTimer ] == NULL )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
}\r
- \r
+\r
/* Create the timers that are used from the tick interrupt to test the timer\r
API functions that can be called from an ISR. */\r
xISRAutoReloadTimer = xTimerCreate( "ISR AR", /* The text name given to the timer. */\r
pdFALSE, /* This is a one shot timer. */\r
( void * ) NULL, /* The identifier is not required. */\r
prvISROneShotTimerCallback ); /* The callback that is executed when the timer expires. */\r
- \r
+\r
if( ( xISRAutoReloadTimer == NULL ) || ( xISROneShotTimer == NULL ) )\r
{\r
xTestStatus = pdFAIL;\r
\r
static void prvTest2_CheckTaskAndTimersInitialState( void )\r
{\r
-unsigned char ucTimer;\r
+uint8_t ucTimer;\r
\r
/* Ensure all the timers are in their expected initial state. This depends\r
on the timer service task having a higher priority than this task.\r
and auto reload timer configTIMER_QUEUE_LENGTH should not yet be active (it\r
could not be started prior to the scheduler being started when it was\r
created). */\r
- for( ucTimer = 0; ucTimer < ( unsigned char ) configTIMER_QUEUE_LENGTH; ucTimer++ )\r
+ for( ucTimer = 0; ucTimer < ( uint8_t ) configTIMER_QUEUE_LENGTH; ucTimer++ )\r
{\r
if( xTimerIsTimerActive( xAutoReloadTimers[ ucTimer ] ) == pdFALSE )\r
{\r
\r
static void prvTest3_CheckAutoReloadExpireRates( void )\r
{\r
-unsigned char ucMaxAllowableValue, ucMinAllowableValue, ucTimer;\r
+uint8_t ucMaxAllowableValue, ucMinAllowableValue, ucTimer;\r
TickType_t xBlockPeriod, xTimerPeriod, xExpectedNumber;\r
+UBaseType_t uxOriginalPriority;\r
\r
- /* Check the auto reload timers expire at the expected rates. */\r
-\r
+ /* Check the auto reload timers expire at the expected rates. Do this at a\r
+ high priority for maximum accuracy. This is ok as most of the time is spent\r
+ in the Blocked state. */\r
+ uxOriginalPriority = uxTaskPriorityGet( NULL );\r
+ vTaskPrioritySet( NULL, ( configMAX_PRIORITIES - 1 ) );\r
\r
/* Delaying for configTIMER_QUEUE_LENGTH * xBasePeriod ticks should allow\r
all the auto reload timers to expire at least once. */\r
xBlockPeriod = ( ( TickType_t ) configTIMER_QUEUE_LENGTH ) * xBasePeriod;\r
vTaskDelay( xBlockPeriod );\r
\r
- /* Check that all the auto reload timers have called their callback \r
+ /* Check that all the auto reload timers have called their callback\r
function the expected number of times. */\r
- for( ucTimer = 0; ucTimer < ( unsigned char ) configTIMER_QUEUE_LENGTH; ucTimer++ )\r
+ for( ucTimer = 0; ucTimer < ( uint8_t ) configTIMER_QUEUE_LENGTH; ucTimer++ )\r
{\r
/* The expected number of expiries is equal to the block period divided\r
by the timer period. */\r
xTimerPeriod = ( ( ( TickType_t ) ucTimer + ( TickType_t ) 1 ) * xBasePeriod );\r
xExpectedNumber = xBlockPeriod / xTimerPeriod;\r
- \r
- ucMaxAllowableValue = ( ( unsigned char ) xExpectedNumber ) ;\r
- ucMinAllowableValue = ( ( unsigned char ) xExpectedNumber - ( unsigned char ) 1 );\r
+\r
+ ucMaxAllowableValue = ( ( uint8_t ) xExpectedNumber ) ;\r
+ ucMinAllowableValue = ( uint8_t ) ( ( uint8_t ) xExpectedNumber - ( uint8_t ) 1 ); /* Weird casting to try and please all compilers. */\r
\r
if( ( ucAutoReloadTimerCounters[ ucTimer ] < ucMinAllowableValue ) ||\r
( ucAutoReloadTimerCounters[ ucTimer ] > ucMaxAllowableValue )\r
}\r
}\r
\r
+ /* Return to the original priority. */\r
+ vTaskPrioritySet( NULL, uxOriginalPriority );\r
+\r
if( xTestStatus == pdPASS )\r
{\r
/* No errors have been reported so increment the loop counter so the\r
/*-----------------------------------------------------------*/\r
\r
static void prvTest4_CheckAutoReloadTimersCanBeStopped( void )\r
-{ \r
-unsigned char ucTimer;\r
+{\r
+uint8_t ucTimer;\r
\r
/* Check the auto reload timers can be stopped correctly, and correctly\r
report their state. */\r
\r
/* Stop all the active timers. */\r
- for( ucTimer = 0; ucTimer < ( unsigned char ) configTIMER_QUEUE_LENGTH; ucTimer++ )\r
+ for( ucTimer = 0; ucTimer < ( uint8_t ) configTIMER_QUEUE_LENGTH; ucTimer++ )\r
{\r
/* The timer has not been stopped yet! */\r
if( xTimerIsTimerActive( xAutoReloadTimers[ ucTimer ] ) == pdFALSE )\r
be active. The critical section is used to ensure the timer does\r
not call its callback between the next line running and the array\r
being cleared back to zero, as that would mask an error condition. */\r
- if( ucAutoReloadTimerCounters[ configTIMER_QUEUE_LENGTH ] != ( unsigned char ) 0 )\r
+ if( ucAutoReloadTimerCounters[ configTIMER_QUEUE_LENGTH ] != ( uint8_t ) 0 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
/* The timers are now all inactive, so this time, after delaying, none\r
of the callback counters should have incremented. */\r
vTaskDelay( ( ( TickType_t ) configTIMER_QUEUE_LENGTH ) * xBasePeriod );\r
- for( ucTimer = 0; ucTimer < ( unsigned char ) configTIMER_QUEUE_LENGTH; ucTimer++ )\r
+ for( ucTimer = 0; ucTimer < ( uint8_t ) configTIMER_QUEUE_LENGTH; ucTimer++ )\r
{\r
- if( ucAutoReloadTimerCounters[ ucTimer ] != ( unsigned char ) 0 )\r
+ if( ucAutoReloadTimerCounters[ ucTimer ] != ( uint8_t ) 0 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
configASSERT( xTestStatus );\r
}\r
\r
- if( ucOneShotTimerCounter != ( unsigned char ) 0 )\r
+ if( ucOneShotTimerCounter != ( uint8_t ) 0 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
configASSERT( xTestStatus );\r
}\r
\r
- if( ucOneShotTimerCounter != ( unsigned char ) 1 )\r
+ if( ucOneShotTimerCounter != ( uint8_t ) 1 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
else\r
{\r
/* Reset the one shot timer callback count. */\r
- ucOneShotTimerCounter = ( unsigned char ) 0;\r
+ ucOneShotTimerCounter = ( uint8_t ) 0;\r
}\r
\r
if( xTestStatus == pdPASS )\r
\r
static void prvTest6_CheckAutoReloadResetBehaviour( void )\r
{\r
-unsigned char ucTimer;\r
+uint8_t ucTimer;\r
\r
/* Check timer reset behaviour. */\r
\r
configASSERT( xTestStatus );\r
}\r
\r
- if( ucOneShotTimerCounter != ( unsigned char ) 0 )\r
+ if( ucOneShotTimerCounter != ( uint8_t ) 0 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
configASSERT( xTestStatus );\r
}\r
\r
- if( ucAutoReloadTimerCounters[ configTIMER_QUEUE_LENGTH - 1 ] != ( unsigned char ) 0 )\r
+ if( ucAutoReloadTimerCounters[ configTIMER_QUEUE_LENGTH - 1 ] != ( uint8_t ) 0 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
\r
/* The timers were not reset during the above delay period so should now\r
both have called their callback functions. */\r
- if( ucOneShotTimerCounter != ( unsigned char ) 1 )\r
+ if( ucOneShotTimerCounter != ( uint8_t ) 1 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
\r
/* Clear the timer callback counts, ready for another iteration of these\r
tests. */\r
- ucAutoReloadTimerCounters[ configTIMER_QUEUE_LENGTH - 1 ] = ( unsigned char ) 0;\r
- ucOneShotTimerCounter = ( unsigned char ) 0;\r
+ ucAutoReloadTimerCounters[ configTIMER_QUEUE_LENGTH - 1 ] = ( uint8_t ) 0;\r
+ ucOneShotTimerCounter = ( uint8_t ) 0;\r
\r
if( xTestStatus == pdPASS )\r
{\r
\r
static void prvResetStartConditionsForNextIteration( void )\r
{\r
-unsigned char ucTimer;\r
+uint8_t ucTimer;\r
\r
/* Start the timers again to start all the tests over again. */\r
\r
/* Start the timers again. */\r
- for( ucTimer = 0; ucTimer < ( unsigned char ) configTIMER_QUEUE_LENGTH; ucTimer++ )\r
+ for( ucTimer = 0; ucTimer < ( uint8_t ) configTIMER_QUEUE_LENGTH; ucTimer++ )\r
{\r
/* The timer has not been started yet! */\r
if( xTimerIsTimerActive( xAutoReloadTimers[ ucTimer ] ) != pdFALSE )\r
will expire when the kernel's tick count is (100 + xBasePeriod). For this\r
reason xMargin is used as an allowable margin for premature timer expiries\r
as well as late timer expiries. */\r
- const TickType_t xMargin = 6;\r
+ #ifdef _WINDOWS_\r
+ /* Windows is not real real time. */\r
+ const TickType_t xMargin = 20;\r
+ #else\r
+ const TickType_t xMargin = 6;\r
+ #endif /* _WINDOWS_ */\r
#else\r
- const TickType_t xMargin = 3;\r
+ #ifdef _WINDOWS_\r
+ /* Windows is not real real time. */\r
+ const TickType_t xMargin = 20;\r
+ #else\r
+ const TickType_t xMargin = 4;\r
+ #endif /* _WINDOWS_ */\r
#endif\r
\r
\r
\r
if( uxTick == 0 )\r
{\r
- /* The timers will have been created, but not started. Start them now \r
+ /* The timers will have been created, but not started. Start them now\r
by setting their period. */\r
ucISRAutoReloadTimerCounter = 0;\r
ucISROneShotTimerCounter = 0;\r
/* First timer was started, try starting the second timer. */\r
if( xTimerChangePeriodFromISR( xISROneShotTimer, xBasePeriod, NULL ) == pdPASS )\r
{\r
- /* Both timers were started, so set the uxTick back to its \r
+ /* Both timers were started, so set the uxTick back to its\r
proper value. */\r
uxTick = 0;\r
}\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
- } \r
+ }\r
}\r
else if( uxTick == ( ( 2 * xBasePeriod ) + xMargin ) )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
if( ucISROneShotTimerCounter != 1 )\r
{\r
xTestStatus = pdFAIL;\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
if( ucISROneShotTimerCounter != 1 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- } \r
+ }\r
else if( uxTick == ( 3 * xBasePeriod ) )\r
{\r
/* Start the one shot timer again. */\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
if( ucISROneShotTimerCounter != 1 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
/* Now stop the auto reload timer. The one shot timer was started\r
a few ticks ago. */\r
xTimerStopFromISR( xISRAutoReloadTimer, NULL );\r
- } \r
+ }\r
else if( uxTick == ( 4 * ( xBasePeriod - xMargin ) ) )\r
{\r
/* The auto reload timer is now stopped, and the one shot timer is\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
if( ucISROneShotTimerCounter != 1 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- } \r
+ }\r
else if( uxTick == ( ( 4 * xBasePeriod ) + xMargin ) )\r
{\r
/* The auto reload timer is now stopped, and the one shot timer is\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
if( ucISROneShotTimerCounter != 2 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- } \r
+ }\r
else if( uxTick == ( 8 * xBasePeriod ) )\r
{\r
/* The auto reload timer is now stopped, and the one shot timer has\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
if( ucISROneShotTimerCounter != 2 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
/* Now reset the one shot timer. */\r
xTimerResetFromISR( xISROneShotTimer, NULL );\r
- } \r
+ }\r
else if( uxTick == ( ( 9 * xBasePeriod ) - xMargin ) )\r
{\r
/* Only the one shot timer should be running, but it should not have\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
if( ucISROneShotTimerCounter != 2 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
xTimerResetFromISR( xISROneShotTimer, NULL );\r
- } \r
+ }\r
else if( uxTick == ( ( 10 * xBasePeriod ) - ( 2 * xMargin ) ) )\r
{\r
/* Only the one shot timer should be running, but it should not have\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
if( ucISROneShotTimerCounter != 2 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
xTimerResetFromISR( xISROneShotTimer, NULL );\r
}\r
else if( uxTick == ( ( 11 * xBasePeriod ) - ( 3 * xMargin ) ) )\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
if( ucISROneShotTimerCounter != 2 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
xTimerResetFromISR( xISROneShotTimer, NULL );\r
- } \r
+ }\r
else if( uxTick == ( ( 12 * xBasePeriod ) - ( 2 * xMargin ) ) )\r
{\r
/* Only the one shot timer should have been running and this time it\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
if( ucISROneShotTimerCounter != 3 )\r
{\r
xTestStatus = pdFAIL;\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
if( ucISROneShotTimerCounter != 3 )\r
{\r
xTestStatus = pdFAIL;\r
configASSERT( xTestStatus );\r
}\r
- \r
+\r
uxTick = ( TickType_t ) -1;\r
- } \r
+ }\r
}\r
/*-----------------------------------------------------------*/\r
\r
\r
static void prvAutoReloadTimerCallback( TimerHandle_t pxExpiredTimer )\r
{\r
-unsigned long ulTimerID;\r
+size_t uxTimerID;\r
\r
- ulTimerID = ( unsigned long ) pvTimerGetTimerID( pxExpiredTimer );\r
- if( ulTimerID <= ( configTIMER_QUEUE_LENGTH + 1 ) )\r
+ uxTimerID = ( size_t ) pvTimerGetTimerID( pxExpiredTimer );\r
+ if( uxTimerID <= ( configTIMER_QUEUE_LENGTH + 1 ) )\r
{\r
- ( ucAutoReloadTimerCounters[ ulTimerID ] )++;\r
+ ( ucAutoReloadTimerCounters[ uxTimerID ] )++;\r
}\r
else\r
{\r
\r
static void prvOneShotTimerCallback( TimerHandle_t pxExpiredTimer )\r
{\r
- /* The parameter is not used in this case as only one timer uses this\r
- callback function. */\r
- ( void ) pxExpiredTimer;\r
+/* A count is kept of the number of times this callback function is executed.\r
+The count is stored as the timer's ID. This is only done to test the\r
+vTimerSetTimerID() function. */\r
+static size_t uxCallCount = 0;\r
+size_t uxLastCallCount;\r
+\r
+ /* Obtain the timer's ID, which should be a count of the number of times\r
+ this callback function has been executed. */\r
+ uxLastCallCount = ( size_t ) pvTimerGetTimerID( pxExpiredTimer );\r
+ configASSERT( uxLastCallCount == uxCallCount );\r
+\r
+ /* Increment the call count, then save it back as the timer's ID. This is\r
+ only done to test the vTimerSetTimerID() API function. */\r
+ uxLastCallCount++;\r
+ vTimerSetTimerID( pxExpiredTimer, ( void * ) uxLastCallCount );\r
+ uxCallCount++;\r
\r
ucOneShotTimerCounter++;\r
}\r
projects / freertos / blobdiff