/*\r
- FreeRTOS V7.6.0 - Copyright (C) 2013 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
-\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
- 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
- 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
- * *\r
- * http://www.FreeRTOS.org/FAQHelp.html *\r
- * *\r
- ***************************************************************************\r
-\r
- http://www.FreeRTOS.org - Documentation, books, training, latest versions,\r
- license and Real Time Engineers Ltd. contact details.\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
-\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
- mission critical applications that require provable dependability.\r
-\r
- 1 tab == 4 spaces!\r
-*/\r
+ * FreeRTOS Kernel V10.2.1\r
+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://www.FreeRTOS.org\r
+ * http://aws.amazon.com/freertos\r
+ *\r
+ * 1 tab == 4 spaces!\r
+ */\r
\r
/*\r
*******************************************************************************\r
* NOTE 1: The Win32 port is a simulation (or is that emulation?) only! Do not\r
* expect to get real time behaviour from the Win32 port or this demo\r
* application. It is provided as a convenient development and demonstration\r
- * test bed only. This was tested using Windows XP on a dual core laptop.\r
+ * test bed only.\r
*\r
* Windows will not be running the FreeRTOS simulator threads continuously, so\r
* the timing information in the FreeRTOS+Trace logs have no meaningful units.\r
* in main.c. This file implements the comprehensive test and demo version.\r
*\r
* NOTE 3: This file only contains the source code that is specific to the\r
- * basic demo. Generic functions, such FreeRTOS hook functions, are defined in\r
+ * full demo. Generic functions, such FreeRTOS hook functions, are defined in\r
* main.c.\r
*******************************************************************************\r
*\r
\r
/* Kernel includes. */\r
#include <FreeRTOS.h>\r
-#include "task.h"\r
-#include "queue.h"\r
-#include "timers.h"\r
-#include "semphr.h"\r
+#include <task.h>\r
+#include <queue.h>\r
+#include <timers.h>\r
+#include <semphr.h>\r
\r
/* Standard demo includes. */\r
#include "BlockQ.h"\r
#include "QueueSet.h"\r
#include "QueueOverwrite.h"\r
#include "EventGroupsDemo.h"\r
+#include "IntSemTest.h"\r
+#include "TaskNotify.h"\r
+#include "QueueSetPolling.h"\r
+#include "StaticAllocation.h"\r
+#include "blocktim.h"\r
+#include "AbortDelay.h"\r
+#include "MessageBufferDemo.h"\r
+#include "StreamBufferDemo.h"\r
+#include "StreamBufferInterrupt.h"\r
+#include "MessageBufferAMP.h"\r
\r
/* Priorities at which the tasks are created. */\r
-#define mainCHECK_TASK_PRIORITY ( configMAX_PRIORITIES - 1 )\r
+#define mainCHECK_TASK_PRIORITY ( configMAX_PRIORITIES - 2 )\r
#define mainQUEUE_POLL_PRIORITY ( tskIDLE_PRIORITY + 1 )\r
#define mainSEM_TEST_PRIORITY ( tskIDLE_PRIORITY + 1 )\r
#define mainBLOCK_Q_PRIORITY ( tskIDLE_PRIORITY + 2 )\r
#define mainCREATOR_TASK_PRIORITY ( tskIDLE_PRIORITY + 3 )\r
#define mainFLASH_TASK_PRIORITY ( tskIDLE_PRIORITY + 1 )\r
-#define mainuIP_TASK_PRIORITY ( tskIDLE_PRIORITY + 2 )\r
#define mainINTEGER_TASK_PRIORITY ( tskIDLE_PRIORITY )\r
#define mainGEN_QUEUE_TASK_PRIORITY ( tskIDLE_PRIORITY )\r
#define mainFLOP_TASK_PRIORITY ( tskIDLE_PRIORITY )\r
*/\r
static void prvDemonstrateTaskStateAndHandleGetFunctions( void );\r
\r
+/*\r
+ * Called from the idle task hook function to demonstrate the use of\r
+ * xTimerPendFunctionCall() as xTimerPendFunctionCall() is not demonstrated by\r
+ * any of the standard demo tasks.\r
+ */\r
+static void prvDemonstratePendingFunctionCall( void );\r
+\r
+/*\r
+ * The function that is pended by prvDemonstratePendingFunctionCall().\r
+ */\r
+static void prvPendedFunction( void *pvParameter1, uint32_t ulParameter2 );\r
+\r
+/*\r
+ * prvDemonstrateTimerQueryFunctions() is called from the idle task hook\r
+ * function to demonstrate the use of functions that query information about a\r
+ * software timer. prvTestTimerCallback() is the callback function for the\r
+ * timer being queried.\r
+ */\r
+static void prvDemonstrateTimerQueryFunctions( void );\r
+static void prvTestTimerCallback( TimerHandle_t xTimer );\r
+\r
/*\r
* A task to demonstrate the use of the xQueueSpacesAvailable() function.\r
*/\r
static void prvDemoQueueSpaceFunctions( void *pvParameters );\r
\r
+/*\r
+ * Tasks that ensure indefinite delays are truly indefinite.\r
+ */\r
+static void prvPermanentlyBlockingSemaphoreTask( void *pvParameters );\r
+static void prvPermanentlyBlockingNotificationTask( void *pvParameters );\r
+\r
/*-----------------------------------------------------------*/\r
\r
/* The variable into which error messages are latched. */\r
-static char *pcStatusMessage = "OK";\r
+static char *pcStatusMessage = "No errors";\r
\r
/* This semaphore is created purely to test using the vSemaphoreDelete() and\r
semaphore tracing API functions. It has no other purpose. */\r
-static xSemaphoreHandle xMutexToDelete = NULL;\r
+static SemaphoreHandle_t xMutexToDelete = NULL;\r
\r
/*-----------------------------------------------------------*/\r
\r
xTaskCreate( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );\r
\r
/* Create the standard demo tasks. */\r
+ vStartTaskNotifyTask();\r
vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );\r
vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );\r
vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );\r
vStartRecursiveMutexTasks();\r
vStartCountingSemaphoreTasks();\r
vStartDynamicPriorityTasks();\r
- vStartQueueSetTasks();\r
vStartQueueOverwriteTask( mainQUEUE_OVERWRITE_PRIORITY );\r
- xTaskCreate( prvDemoQueueSpaceFunctions, "QSpace", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );\r
vStartEventGroupTasks();\r
+ vStartInterruptSemaphoreTasks();\r
+ vCreateBlockTimeTasks();\r
+ vCreateAbortDelayTasks();\r
+ xTaskCreate( prvDemoQueueSpaceFunctions, "QSpace", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );\r
+ xTaskCreate( prvPermanentlyBlockingSemaphoreTask, "BlockSem", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );\r
+ xTaskCreate( prvPermanentlyBlockingNotificationTask, "BlockNoti", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );\r
+\r
+ vStartMessageBufferTasks( configMINIMAL_STACK_SIZE );\r
+ vStartStreamBufferTasks();\r
+ vStartStreamBufferInterruptDemo();\r
+ vStartMessageBufferAMPTasks( configMINIMAL_STACK_SIZE );\r
+\r
+ #if( configUSE_QUEUE_SETS == 1 )\r
+ {\r
+ vStartQueueSetTasks();\r
+ vStartQueueSetPollingTask();\r
+ }\r
+ #endif\r
+\r
+ #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
+ {\r
+ vStartStaticallyAllocatedTasks();\r
+ }\r
+ #endif\r
\r
#if( configUSE_PREEMPTION != 0 )\r
{\r
/* Start the scheduler itself. */\r
vTaskStartScheduler();\r
\r
- /* Should never get here unless there was not enough heap space to create\r
+ /* Should never get here unless there was not enough heap space to create\r
the idle and other system tasks. */\r
- return 0;\r
+ return 0;\r
}\r
/*-----------------------------------------------------------*/\r
\r
static void prvCheckTask( void *pvParameters )\r
{\r
-portTickType xNextWakeTime;\r
-const portTickType xCycleFrequency = 2500 / portTICK_RATE_MS;\r
+TickType_t xNextWakeTime;\r
+const TickType_t xCycleFrequency = pdMS_TO_TICKS( 5000UL );\r
+HeapStats_t xHeapStats;\r
\r
/* Just to remove compiler warning. */\r
( void ) pvParameters;\r
}\r
#endif\r
\r
- if( xAreEventGroupTasksStillRunning() != pdTRUE )\r
+ if( xAreStreamBufferTasksStillRunning() != pdTRUE )\r
+ {\r
+ pcStatusMessage = "Error: StreamBuffer";\r
+ }\r
+ else if( xAreMessageBufferTasksStillRunning() != pdTRUE )\r
+ {\r
+ pcStatusMessage = "Error: MessageBuffer";\r
+ }\r
+ else if( xAreTaskNotificationTasksStillRunning() != pdTRUE )\r
+ {\r
+ pcStatusMessage = "Error: Notification";\r
+ }\r
+ else if( xAreInterruptSemaphoreTasksStillRunning() != pdTRUE )\r
+ {\r
+ pcStatusMessage = "Error: IntSem";\r
+ }\r
+ else if( xAreEventGroupTasksStillRunning() != pdTRUE )\r
{\r
pcStatusMessage = "Error: EventGroup";\r
}\r
- else if( xAreIntegerMathsTaskStillRunning() != pdTRUE )\r
- {\r
+ else if( xAreIntegerMathsTaskStillRunning() != pdTRUE )\r
+ {\r
pcStatusMessage = "Error: IntMath";\r
- }\r
+ }\r
else if( xAreGenericQueueTasksStillRunning() != pdTRUE )\r
{\r
pcStatusMessage = "Error: GenQueue";\r
{\r
pcStatusMessage = "Error: BlockQueue";\r
}\r
- else if( xAreSemaphoreTasksStillRunning() != pdTRUE )\r
- {\r
+ else if( xAreSemaphoreTasksStillRunning() != pdTRUE )\r
+ {\r
pcStatusMessage = "Error: SemTest";\r
- }\r
- else if( xArePollingQueuesStillRunning() != pdTRUE )\r
- {\r
+ }\r
+ else if( xArePollingQueuesStillRunning() != pdTRUE )\r
+ {\r
pcStatusMessage = "Error: PollQueue";\r
- }\r
+ }\r
else if( xAreMathsTaskStillRunning() != pdPASS )\r
{\r
pcStatusMessage = "Error: Flop";\r
}\r
- else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE )\r
- {\r
+ else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE )\r
+ {\r
pcStatusMessage = "Error: RecMutex";\r
}\r
else if( xAreCountingSemaphoreTasksStillRunning() != pdTRUE )\r
{\r
pcStatusMessage = "Error: Dynamic";\r
}\r
- else if( xAreQueueSetTasksStillRunning() != pdPASS )\r
- {\r
- pcStatusMessage = "Error: Queue set";\r
- }\r
else if( xIsQueueOverwriteTaskStillRunning() != pdPASS )\r
{\r
pcStatusMessage = "Error: Queue overwrite";\r
}\r
+ else if( xAreBlockTimeTestTasksStillRunning() != pdPASS )\r
+ {\r
+ pcStatusMessage = "Error: Block time";\r
+ }\r
+ else if( xAreAbortDelayTestTasksStillRunning() != pdPASS )\r
+ {\r
+ pcStatusMessage = "Error: Abort delay";\r
+ }\r
+ else if( xIsInterruptStreamBufferDemoStillRunning() != pdPASS )\r
+ {\r
+ pcStatusMessage = "Error: Stream buffer interrupt";\r
+ }\r
+ else if( xAreMessageBufferAMPTasksStillRunning() != pdPASS )\r
+ {\r
+ pcStatusMessage = "Error: Message buffer AMP";\r
+ }\r
+\r
+ #if( configUSE_QUEUE_SETS == 1 )\r
+ else if( xAreQueueSetTasksStillRunning() != pdPASS )\r
+ {\r
+ pcStatusMessage = "Error: Queue set";\r
+ }\r
+ else if( xAreQueueSetPollTasksStillRunning() != pdPASS )\r
+ {\r
+ pcStatusMessage = "Error: Queue set polling";\r
+ }\r
+ #endif\r
+\r
+ #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
+ else if( xAreStaticAllocationTasksStillRunning() != pdPASS )\r
+ {\r
+ pcStatusMessage = "Error: Static allocation";\r
+ }\r
+ #endif /* configSUPPORT_STATIC_ALLOCATION */\r
\r
/* This is the only task that uses stdout so its ok to call printf()\r
directly. */\r
- printf( "%s - %d\r\n", pcStatusMessage, xTaskGetTickCount() );\r
+ vPortGetHeapStats( &xHeapStats );\r
+\r
+ configASSERT( xHeapStats.xAvailableHeapSpaceInBytes == xPortGetFreeHeapSize() );\r
+ configASSERT( xHeapStats.xMinimumEverFreeBytesRemaining == xPortGetMinimumEverFreeHeapSize() );\r
+\r
+ printf( "%s - tick count %zu - free heap %zu - min free heap %zu - largest free block %zu \r\n",\r
+ pcStatusMessage,\r
+ xTaskGetTickCount(),\r
+ xHeapStats.xAvailableHeapSpaceInBytes,\r
+ xHeapStats.xMinimumEverFreeBytesRemaining,\r
+ xHeapStats.xSizeOfLargestFreeBlockInBytes );\r
}\r
}\r
/*-----------------------------------------------------------*/\r
void vFullDemoIdleFunction( void )\r
{\r
const unsigned long ulMSToSleep = 15;\r
-const unsigned portBASE_TYPE uxConstQueueNumber = 0xaaU;\r
void *pvAllocated;\r
\r
-/* These three functions are only meant for use by trace code, and not for\r
-direct use from application code, hence their prototypes are not in queue.h. */\r
-extern void vQueueSetQueueNumber( xQueueHandle pxQueue, unsigned portBASE_TYPE uxQueueNumber );\r
-extern unsigned portBASE_TYPE uxQueueGetQueueNumber( xQueueHandle pxQueue );\r
-extern unsigned char ucQueueGetQueueType( xQueueHandle pxQueue );\r
-extern void vTaskSetTaskNumber( xTaskHandle xTask, unsigned portBASE_TYPE uxHandle );\r
-extern unsigned portBASE_TYPE uxTaskGetTaskNumber( xTaskHandle xTask );\r
-\r
/* Sleep to reduce CPU load, but don't sleep indefinitely in case there are\r
tasks waiting to be terminated by the idle task. */\r
Sleep( ulMSToSleep );\r
the standard demo tasks. */\r
prvDemonstrateTaskStateAndHandleGetFunctions();\r
\r
+ /* Demonstrate the use of xTimerPendFunctionCall(), which is not\r
+ demonstrated by any of the standard demo tasks. */\r
+ prvDemonstratePendingFunctionCall();\r
+\r
+ /* Demonstrate the use of functions that query information about a software\r
+ timer. */\r
+ prvDemonstrateTimerQueryFunctions();\r
+\r
+\r
/* If xMutexToDelete has not already been deleted, then delete it now.\r
This is done purely to demonstrate the use of, and test, the\r
vSemaphoreDelete() macro. Care must be taken not to delete a semaphore\r
that has tasks blocked on it. */\r
if( xMutexToDelete != NULL )\r
{\r
- /* Before deleting the semaphore, test the function used to set its\r
- number. This would normally only be done from trace software, rather\r
- than application code. */\r
- vQueueSetQueueNumber( xMutexToDelete, uxConstQueueNumber );\r
-\r
- /* Before deleting the semaphore, test the functions used to get its\r
- type and number. Again, these would normally only be done from trace\r
- software, rather than application code. */\r
- configASSERT( uxQueueGetQueueNumber( xMutexToDelete ) == uxConstQueueNumber );\r
- configASSERT( ucQueueGetQueueType( xMutexToDelete ) == queueQUEUE_TYPE_MUTEX );\r
+ /* For test purposes, add the mutex to the registry, then remove it\r
+ again, before it is deleted - checking its name is as expected before\r
+ and after the assertion into the registry and its removal from the\r
+ registry. */\r
+ configASSERT( pcQueueGetName( xMutexToDelete ) == NULL );\r
+ vQueueAddToRegistry( xMutexToDelete, "Test_Mutex" );\r
+ configASSERT( strcmp( pcQueueGetName( xMutexToDelete ), "Test_Mutex" ) == 0 );\r
+ vQueueUnregisterQueue( xMutexToDelete );\r
+ configASSERT( pcQueueGetName( xMutexToDelete ) == NULL );\r
+\r
vSemaphoreDelete( xMutexToDelete );\r
xMutexToDelete = NULL;\r
}\r
\r
- /* Exercise heap_4 a bit. The malloc failed hook will trap failed\r
+ /* Exercise heap_5 a bit. The malloc failed hook will trap failed\r
allocations so there is no need to test here. */\r
- pvAllocated = pvPortMalloc( ( rand() % 100 ) + 1 );\r
+ pvAllocated = pvPortMalloc( ( rand() % 500 ) + 1 );\r
vPortFree( pvAllocated );\r
}\r
/*-----------------------------------------------------------*/\r
/* Called by vApplicationTickHook(), which is defined in main.c. */\r
void vFullDemoTickHookFunction( void )\r
{\r
+TaskHandle_t xTimerTask;\r
+\r
/* Call the periodic timer test, which tests the timer API functions that\r
can be called from an ISR. */\r
#if( configUSE_PREEMPTION != 0 )\r
/* Call the periodic queue overwrite from ISR demo. */\r
vQueueOverwritePeriodicISRDemo();\r
\r
- /* Write to a queue that is in use as part of the queue set demo to\r
- demonstrate using queue sets from an ISR. */\r
- vQueueSetAccessQueueSetFromISR();\r
+ #if( configUSE_QUEUE_SETS == 1 ) /* Remove the tests if queue sets are not defined. */\r
+ {\r
+ /* Write to a queue that is in use as part of the queue set demo to\r
+ demonstrate using queue sets from an ISR. */\r
+ vQueueSetAccessQueueSetFromISR();\r
+ vQueueSetPollingInterruptAccess();\r
+ }\r
+ #endif\r
+\r
+ /* Exercise event groups from interrupts. */\r
+ vPeriodicEventGroupsProcessing();\r
+\r
+ /* Exercise giving mutexes from an interrupt. */\r
+ vInterruptSemaphorePeriodicTest();\r
+\r
+ /* Exercise using task notifications from an interrupt. */\r
+ xNotifyTaskFromISR();\r
+\r
+ /* Writes to stream buffer byte by byte to test the stream buffer trigger\r
+ level functionality. */\r
+ vPeriodicStreamBufferProcessing();\r
+\r
+ /* Writes a string to a string buffer four bytes at a time to demonstrate\r
+ a stream being sent from an interrupt to a task. */\r
+ vBasicStreamBufferSendFromISR();\r
+\r
+ /* For code coverage purposes. */\r
+ xTimerTask = xTimerGetTimerDaemonTaskHandle();\r
+ configASSERT( uxTaskPriorityGetFromISR( xTimerTask ) == configTIMER_TASK_PRIORITY );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvPendedFunction( void *pvParameter1, uint32_t ulParameter2 )\r
+{\r
+static uint32_t ulLastParameter1 = 1000UL, ulLastParameter2 = 0UL;\r
+uint32_t ulParameter1;\r
+\r
+ ulParameter1 = ( uint32_t ) pvParameter1;\r
+\r
+ /* Ensure the parameters are as expected. */\r
+ configASSERT( ulParameter1 == ( ulLastParameter1 + 1 ) );\r
+ configASSERT( ulParameter2 == ( ulLastParameter2 + 1 ) );\r
+\r
+ /* Remember the parameters for the next time the function is called. */\r
+ ulLastParameter1 = ulParameter1;\r
+ ulLastParameter2 = ulParameter2;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvTestTimerCallback( TimerHandle_t xTimer )\r
+{\r
+ /* This is the callback function for the timer accessed by\r
+ prvDemonstrateTimerQueryFunctions(). The callback does not do anything. */\r
+ ( void ) xTimer;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvDemonstrateTimerQueryFunctions( void )\r
+{\r
+static TimerHandle_t xTimer = NULL;\r
+const char *pcTimerName = "TestTimer";\r
+volatile TickType_t xExpiryTime;\r
+const TickType_t xDontBlock = 0;\r
+\r
+ if( xTimer == NULL )\r
+ {\r
+ xTimer = xTimerCreate( pcTimerName, portMAX_DELAY, pdTRUE, NULL, prvTestTimerCallback );\r
+\r
+ if( xTimer != NULL )\r
+ {\r
+ /* Called from the idle task so a block time must not be\r
+ specified. */\r
+ xTimerStart( xTimer, xDontBlock );\r
+ }\r
+ }\r
+\r
+ if( xTimer != NULL )\r
+ {\r
+ /* Demonstrate querying a timer's name. */\r
+ configASSERT( strcmp( pcTimerGetName( xTimer ), pcTimerName ) == 0 );\r
+\r
+ /* Demonstrate querying a timer's period. */\r
+ configASSERT( xTimerGetPeriod( xTimer ) == portMAX_DELAY );\r
+\r
+ /* Demonstrate querying a timer's next expiry time, although nothing is\r
+ done with the returned value. Note if the expiry time is less than the\r
+ maximum tick count then the expiry time has overflowed from the current\r
+ time. In this case the expiry time was set to portMAX_DELAY, so it is\r
+ expected to be less than the current time until the current time has\r
+ itself overflowed. */\r
+ xExpiryTime = xTimerGetExpiryTime( xTimer );\r
+ ( void ) xExpiryTime;\r
+ }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvDemonstratePendingFunctionCall( void )\r
+{\r
+static uint32_t ulParameter1 = 1000UL, ulParameter2 = 0UL;\r
+const TickType_t xDontBlock = 0; /* This is called from the idle task so must *not* attempt to block. */\r
+\r
+ /* prvPendedFunction() just expects the parameters to be incremented by one\r
+ each time it is called. */\r
+ ulParameter1++;\r
+ ulParameter2++;\r
+\r
+ /* Pend the function call, sending the parameters. */\r
+ xTimerPendFunctionCall( prvPendedFunction, ( void * ) ulParameter1, ulParameter2, xDontBlock );\r
}\r
/*-----------------------------------------------------------*/\r
\r
static void prvDemonstrateTaskStateAndHandleGetFunctions( void )\r
{\r
-xTaskHandle xIdleTaskHandle, xTimerTaskHandle;\r
-const unsigned char ucConstTaskNumber = 0x55U;\r
-signed char *pcTaskName;\r
+TaskHandle_t xIdleTaskHandle, xTimerTaskHandle;\r
+char *pcTaskName;\r
static portBASE_TYPE xPerformedOneShotTests = pdFALSE;\r
-xTaskHandle xTestTask;\r
+TaskHandle_t xTestTask;\r
+TaskStatus_t xTaskInfo;\r
+extern StackType_t uxTimerTaskStack[];\r
\r
/* Demonstrate the use of the xTimerGetTimerDaemonTaskHandle() and\r
xTaskGetIdleTaskHandle() functions. Also try using the function that sets\r
the task number. */\r
xIdleTaskHandle = xTaskGetIdleTaskHandle();\r
xTimerTaskHandle = xTimerGetTimerDaemonTaskHandle();\r
- vTaskSetTaskNumber( xIdleTaskHandle, ( unsigned long ) ucConstTaskNumber );\r
- configASSERT( uxTaskGetTaskNumber( xIdleTaskHandle ) == ucConstTaskNumber );\r
\r
/* This is the idle hook, so the current task handle should equal the\r
returned idle task handle. */\r
pcStatusMessage = "Error: Returned idle task handle was incorrect";\r
}\r
\r
+ /* Check the same handle is obtained using the idle task's name. First try\r
+ with the wrong name, then the right name. */\r
+ if( xTaskGetHandle( "Idle" ) == xIdleTaskHandle )\r
+ {\r
+ pcStatusMessage = "Error: Returned handle for name Idle was incorrect";\r
+ }\r
+\r
+ if( xTaskGetHandle( "IDLE" ) != xIdleTaskHandle )\r
+ {\r
+ pcStatusMessage = "Error: Returned handle for name Idle was incorrect";\r
+ }\r
+\r
/* Check the timer task handle was returned correctly. */\r
- pcTaskName = pcTaskGetTaskName( xTimerTaskHandle );\r
+ pcTaskName = pcTaskGetName( xTimerTaskHandle );\r
if( strcmp( pcTaskName, "Tmr Svc" ) != 0 )\r
{\r
pcStatusMessage = "Error: Returned timer task handle was incorrect";\r
}\r
\r
+ if( xTaskGetHandle( "Tmr Svc" ) != xTimerTaskHandle )\r
+ {\r
+ pcStatusMessage = "Error: Returned handle for name Tmr Svc was incorrect";\r
+ }\r
+\r
/* This task is running, make sure it's state is returned as running. */\r
if( eTaskStateGet( xIdleTaskHandle ) != eRunning )\r
{\r
pcStatusMessage = "Error: Returned timer task state was incorrect";\r
}\r
\r
+ /* Also with the vTaskGetInfo() function. */\r
+ vTaskGetInfo( xTimerTaskHandle, /* The task being queried. */\r
+ &xTaskInfo, /* The structure into which information on the task will be written. */\r
+ pdTRUE, /* Include the task's high watermark in the structure. */\r
+ eInvalid ); /* Include the task state in the structure. */\r
+\r
+ /* Check the information returned by vTaskGetInfo() is as expected. */\r
+ if( ( xTaskInfo.eCurrentState != eBlocked ) ||\r
+ ( strcmp( xTaskInfo.pcTaskName, "Tmr Svc" ) != 0 ) ||\r
+ ( xTaskInfo.uxCurrentPriority != configTIMER_TASK_PRIORITY ) ||\r
+ ( xTaskInfo.pxStackBase != uxTimerTaskStack ) ||\r
+ ( xTaskInfo.xHandle != xTimerTaskHandle ) )\r
+ {\r
+ pcStatusMessage = "Error: vTaskGetInfo() returned incorrect information about the timer task";\r
+ }\r
+\r
/* Other tests that should only be performed once follow. The test task\r
is not created on each iteration because to do so would cause the death\r
task to report an error (too many tasks running). */\r
\r
static void prvDemoQueueSpaceFunctions( void *pvParameters )\r
{\r
-xQueueHandle xQueue = NULL;\r
+QueueHandle_t xQueue = NULL;\r
const unsigned portBASE_TYPE uxQueueLength = 10;\r
unsigned portBASE_TYPE uxReturn, x;\r
\r
#endif\r
}\r
}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvPermanentlyBlockingSemaphoreTask( void *pvParameters )\r
+{\r
+SemaphoreHandle_t xSemaphore;\r
+\r
+ /* Prevent compiler warning about unused parameter in the case that\r
+ configASSERT() is not defined. */\r
+ ( void ) pvParameters;\r
+\r
+ /* This task should block on a semaphore, and never return. */\r
+ xSemaphore = xSemaphoreCreateBinary();\r
+ configASSERT( xSemaphore );\r
+\r
+ xSemaphoreTake( xSemaphore, portMAX_DELAY );\r
+\r
+ /* The above xSemaphoreTake() call should never return, force an assert if\r
+ it does. */\r
+ configASSERT( pvParameters != NULL );\r
+ vTaskDelete( NULL );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvPermanentlyBlockingNotificationTask( void *pvParameters )\r
+{\r
+ /* Prevent compiler warning about unused parameter in the case that\r
+ configASSERT() is not defined. */\r
+ ( void ) pvParameters;\r
+\r
+ /* This task should block on a task notification, and never return. */\r
+ ulTaskNotifyTake( pdTRUE, portMAX_DELAY );\r
+\r
+ /* The above ulTaskNotifyTake() call should never return, force an assert\r
+ if it does. */\r
+ configASSERT( pvParameters != NULL );\r
+ vTaskDelete( NULL );\r
+}\r
+\r
\r
\r
projects / freertos / blobdiff