git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/Common/Minimal/StaticAllocation.c

   1 /*\r
   2     FreeRTOS V9.0.1 - Copyright (C) 2017 Real Time Engineers Ltd.\r
   3     All rights reserved\r
   4 \r
   5     VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
   6 \r
   7     This file is part of the FreeRTOS distribution.\r
   8 \r
   9     FreeRTOS is free software; you can redistribute it and/or modify it under\r
  10     the terms of the GNU General Public License (version 2) as published by the\r
  11     Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.\r
  12 \r
  13     ***************************************************************************\r
  14     >>!   NOTE: The modification to the GPL is included to allow you to     !<<\r
  15     >>!   distribute a combined work that includes FreeRTOS without being   !<<\r
  16     >>!   obliged to provide the source code for proprietary components     !<<\r
  17     >>!   outside of the FreeRTOS kernel.                                   !<<\r
  18     ***************************************************************************\r
  19 \r
  20     FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
  21     WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
  22     FOR A PARTICULAR PURPOSE.  Full license text is available on the following\r
  23     link: http://www.freertos.org/a00114.html\r
  24 \r
  25     ***************************************************************************\r
  26      *                                                                       *\r
  27      *    FreeRTOS provides completely free yet professionally developed,    *\r
  28      *    robust, strictly quality controlled, supported, and cross          *\r
  29      *    platform software that is more than just the market leader, it     *\r
  30      *    is the industry's de facto standard.                               *\r
  31      *                                                                       *\r
  32      *    Help yourself get started quickly while simultaneously helping     *\r
  33      *    to support the FreeRTOS project by purchasing a FreeRTOS           *\r
  34      *    tutorial book, reference manual, or both:                          *\r
  35      *    http://www.FreeRTOS.org/Documentation                              *\r
  36      *                                                                       *\r
  37     ***************************************************************************\r
  38 \r
  39     http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading\r
  40     the FAQ page "My application does not run, what could be wrong?".  Have you\r
  41     defined configASSERT()?\r
  42 \r
  43     http://www.FreeRTOS.org/support - In return for receiving this top quality\r
  44     embedded software for free we request you assist our global community by\r
  45     participating in the support forum.\r
  46 \r
  47     http://www.FreeRTOS.org/training - Investing in training allows your team to\r
  48     be as productive as possible as early as possible.  Now you can receive\r
  49     FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers\r
  50     Ltd, and the world's leading authority on the world's leading RTOS.\r
  51 \r
  52     http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
  53     including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
  54     compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
  55 \r
  56     http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.\r
  57     Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.\r
  58 \r
  59     http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High\r
  60     Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS\r
  61     licenses offer ticketed support, indemnification and commercial middleware.\r
  62 \r
  63     http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
  64     engineered and independently SIL3 certified version for use in safety and\r
  65     mission critical applications that require provable dependability.\r
  66 \r
  67     1 tab == 4 spaces!\r
  68 */\r
  69 \r
  70 \r
  71 /*\r
  72  * Demonstrates how to create FreeRTOS objects using pre-allocated memory,\r
  73  * rather than the normal dynamically allocated memory, and tests objects being\r
  74  * created and deleted with both statically allocated memory and dynamically\r
  75  * allocated memory.\r
  76  *\r
  77  * See http://www.FreeRTOS.org/Static_Vs_Dynamic_Memory_Allocation.html\r
  78  */\r
  79 \r
  80 /* Scheduler include files. */\r
  81 #include "FreeRTOS.h"\r
  82 #include "task.h"\r
  83 #include "queue.h"\r
  84 #include "semphr.h"\r
  85 #include "event_groups.h"\r
  86 #include "timers.h"\r
  87 \r
  88 /* Demo program include files. */\r
  89 #include "StaticAllocation.h"\r
  90 \r
  91 /* Exclude the entire file if configSUPPORT_STATIC_ALLOCATION is 0. */\r
  92 #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
  93 \r
  94 /* The priority at which the task that performs the tests is created. */\r
  95 #define staticTASK_PRIORITY                                     ( tskIDLE_PRIORITY + 2 )\r
  96 \r
  97 /* The length of the queue, in items, not bytes, used in the queue static\r
  98 allocation tests. */\r
  99 #define staticQUEUE_LENGTH_IN_ITEMS                     ( 5 )\r
 100 \r
 101 /* A block time of 0 simply means "don't block". */\r
 102 #define staticDONT_BLOCK                                        ( ( TickType_t ) 0 )\r
 103 \r
 104 /* Binary semaphores have a maximum count of 1. */\r
 105 #define staticBINARY_SEMAPHORE_MAX_COUNT        ( 1 )\r
 106 \r
 107 /* The size of the stack used by the task that runs the tests. */\r
 108 #define staticCREATOR_TASK_STACK_SIZE           ( configMINIMAL_STACK_SIZE * 2 )\r
 109 \r
 110 /* The number of times the software timer will execute before stopping itself. */\r
 111 #define staticMAX_TIMER_CALLBACK_EXECUTIONS     ( 5 )\r
 112 \r
 113 \r
 114 /*-----------------------------------------------------------*/\r
 115 \r
 116 /*\r
 117  * The task that repeatedly creates and deletes statically allocated tasks, and\r
 118  * other RTOS objects.\r
 119  */\r
 120 static void prvStaticallyAllocatedCreator( void *pvParameters );\r
 121 \r
 122 /*\r
 123  * The callback function used by the software timer that is repeatedly created\r
 124  * and deleted using both static and dynamically allocated memory.\r
 125  */\r
 126 static void prvTimerCallback( TimerHandle_t xExpiredTimer );\r
 127 \r
 128 /*\r
 129  * A task that is created and deleted multiple times, using both statically and\r
 130  * dynamically allocated stack and TCB.\r
 131  */\r
 132 static void prvStaticallyAllocatedTask( void *pvParameters );\r
 133 \r
 134 /*\r
 135  * A function that demonstrates and tests the API functions that create and\r
 136  * delete tasks using both statically and dynamically allocated TCBs and stacks.\r
 137  */\r
 138 static void prvCreateAndDeleteStaticallyAllocatedTasks( void );\r
 139 \r
 140 /*\r
 141  * A function that demonstrates and tests the API functions that create and\r
 142  * delete event groups using both statically and dynamically allocated RAM.\r
 143  */\r
 144 static void prvCreateAndDeleteStaticallyAllocatedEventGroups( void );\r
 145 \r
 146 /*\r
 147  * A function that demonstrates and tests the API functions that create and\r
 148  * delete queues using both statically and dynamically allocated RAM.\r
 149  */\r
 150 static void prvCreateAndDeleteStaticallyAllocatedQueues( void );\r
 151 \r
 152 /*\r
 153  * A function that demonstrates and tests the API functions that create and\r
 154  * delete binary semaphores using both statically and dynamically allocated RAM.\r
 155  */\r
 156 static void prvCreateAndDeleteStaticallyAllocatedBinarySemaphores( void );\r
 157 \r
 158 /*\r
 159  * A function that demonstrates and tests the API functions that create and\r
 160  * delete software timers using both statically and dynamically allocated RAM.\r
 161  */\r
 162 static void prvCreateAndDeleteStaticallyAllocatedTimers( void );\r
 163 \r
 164 /*\r
 165  * A function that demonstrates and tests the API functions that create and\r
 166  * delete mutexes using both statically and dynamically allocated RAM.\r
 167  */\r
 168 static void prvCreateAndDeleteStaticallyAllocatedMutexes( void );\r
 169 \r
 170 /*\r
 171  * A function that demonstrates and tests the API functions that create and\r
 172  * delete counting semaphores using both statically and dynamically allocated\r
 173  * RAM.\r
 174  */\r
 175 static void prvCreateAndDeleteStaticallyAllocatedCountingSemaphores( void );\r
 176 \r
 177 /*\r
 178  * A function that demonstrates and tests the API functions that create and\r
 179  * delete recursive mutexes using both statically and dynamically allocated RAM.\r
 180  */\r
 181 static void prvCreateAndDeleteStaticallyAllocatedRecursiveMutexes( void );\r
 182 \r
 183 /*\r
 184  * Utility function to create pseudo random numbers.\r
 185  */\r
 186 static UBaseType_t prvRand( void );\r
 187 \r
 188 /*\r
 189  * The task that creates and deletes other tasks has to delay occasionally to\r
 190  * ensure lower priority tasks are not starved of processing time.  A pseudo\r
 191  * random delay time is used just to add a little bit of randomisation into the\r
 192  * execution pattern.  prvGetNextDelayTime() generates the pseudo random delay.\r
 193  */\r
 194 static TickType_t prvGetNextDelayTime( void );\r
 195 \r
 196 /*\r
 197  * Checks the basic operation of a queue after it has been created.\r
 198  */\r
 199 static void prvSanityCheckCreatedQueue( QueueHandle_t xQueue );\r
 200 \r
 201 /*\r
 202  * Checks the basic operation of a recursive mutex after it has been created.\r
 203  */\r
 204 static void prvSanityCheckCreatedRecursiveMutex( SemaphoreHandle_t xSemaphore );\r
 205 \r
 206 /*\r
 207  * Checks the basic operation of a binary semaphore after it has been created.\r
 208  */\r
 209 static void prvSanityCheckCreatedSemaphore( SemaphoreHandle_t xSemaphore, UBaseType_t uxMaxCount );\r
 210 \r
 211 /*\r
 212  * Checks the basic operation of an event group after it has been created.\r
 213  */\r
 214 static void prvSanityCheckCreatedEventGroup( EventGroupHandle_t xEventGroup );\r
 215 \r
 216 /*-----------------------------------------------------------*/\r
 217 \r
 218 /* StaticTask_t is a publicly accessible structure that has the same size and\r
 219 alignment requirements as the real TCB structure.  It is provided as a mechanism\r
 220 for applications to know the size of the TCB (which is dependent on the\r
 221 architecture and configuration file settings) without breaking the strict data\r
 222 hiding policy by exposing the real TCB.  This StaticTask_t variable is passed\r
 223 into the xTaskCreateStatic() function that creates the\r
 224 prvStaticallyAllocatedCreator() task, and will hold the TCB of the created\r
 225 tasks. */\r
 226 static StaticTask_t xCreatorTaskTCBBuffer;\r
 227 \r
 228 /* This is the stack that will be used by the prvStaticallyAllocatedCreator()\r
 229 task, which is itself created using statically allocated buffers (so without any\r
 230 dynamic memory allocation). */\r
 231 static StackType_t uxCreatorTaskStackBuffer[ staticCREATOR_TASK_STACK_SIZE ];\r
 232 \r
 233 /* Used by the pseudo random number generating function. */\r
 234 static uint32_t ulNextRand = 0;\r
 235 \r
 236 /* Used so a check task can ensure this test is still executing, and not\r
 237 stalled. */\r
 238 static volatile UBaseType_t uxCycleCounter = 0;\r
 239 \r
 240 /* A variable that gets set to pdTRUE if an error is detected. */\r
 241 static volatile BaseType_t xErrorOccurred = pdFALSE;\r
 242 \r
 243 /*-----------------------------------------------------------*/\r
 244 \r
 245 void vStartStaticallyAllocatedTasks( void  )\r
 246 {\r
 247         /* Create a single task, which then repeatedly creates and deletes the other\r
 248         RTOS objects using both statically and dynamically allocated RAM. */\r
 249         xTaskCreateStatic( prvStaticallyAllocatedCreator,               /* The function that implements the task being created. */\r
 250                                            "StatCreate",                                                /* Text name for the task - not used by the RTOS, its just to assist debugging. */\r
 251                                            staticCREATOR_TASK_STACK_SIZE,               /* Size of the buffer passed in as the stack - in words, not bytes! */\r
 252                                            NULL,                                                                /* Parameter passed into the task - not used in this case. */\r
 253                                            staticTASK_PRIORITY,                                 /* Priority of the task. */\r
 254                                            &( uxCreatorTaskStackBuffer[ 0 ] ),  /* The buffer to use as the task's stack. */\r
 255                                            &xCreatorTaskTCBBuffer );                    /* The variable that will hold the task's TCB. */\r
 256 }\r
 257 /*-----------------------------------------------------------*/\r
 258 \r
 259 static void prvStaticallyAllocatedCreator( void *pvParameters )\r
 260 {\r
 261         /* Avoid compiler warnings. */\r
 262         ( void ) pvParameters;\r
 263 \r
 264         for( ;; )\r
 265         {\r
 266                 /* Loop, running functions that create and delete the various RTOS\r
 267                 objects that can be optionally created using either static or dynamic\r
 268                 memory allocation. */\r
 269                 prvCreateAndDeleteStaticallyAllocatedTasks();\r
 270                 prvCreateAndDeleteStaticallyAllocatedQueues();\r
 271 \r
 272                 /* Delay to ensure lower priority tasks get CPU time, and increment the\r
 273                 cycle counter so a 'check' task can determine that this task is still\r
 274                 executing. */\r
 275                 vTaskDelay( prvGetNextDelayTime() );\r
 276                 uxCycleCounter++;\r
 277 \r
 278                 prvCreateAndDeleteStaticallyAllocatedBinarySemaphores();\r
 279                 prvCreateAndDeleteStaticallyAllocatedCountingSemaphores();\r
 280 \r
 281                 vTaskDelay( prvGetNextDelayTime() );\r
 282                 uxCycleCounter++;\r
 283 \r
 284                 prvCreateAndDeleteStaticallyAllocatedMutexes();\r
 285                 prvCreateAndDeleteStaticallyAllocatedRecursiveMutexes();\r
 286 \r
 287                 vTaskDelay( prvGetNextDelayTime() );\r
 288                 uxCycleCounter++;\r
 289 \r
 290                 prvCreateAndDeleteStaticallyAllocatedEventGroups();\r
 291                 prvCreateAndDeleteStaticallyAllocatedTimers();\r
 292         }\r
 293 }\r
 294 /*-----------------------------------------------------------*/\r
 295 \r
 296 static void prvCreateAndDeleteStaticallyAllocatedCountingSemaphores( void )\r
 297 {\r
 298 SemaphoreHandle_t xSemaphore;\r
 299 const UBaseType_t uxMaxCount = ( UBaseType_t ) 10;\r
 300 \r
 301 /* StaticSemaphore_t is a publicly accessible structure that has the same size\r
 302 and alignment requirements as the real semaphore structure.  It is provided as a\r
 303 mechanism for applications to know the size of the semaphore (which is dependent\r
 304 on the architecture and configuration file settings) without breaking the strict\r
 305 data hiding policy by exposing the real semaphore internals.  This\r
 306 StaticSemaphore_t variable is passed into the xSemaphoreCreateCountingStatic()\r
 307 function calls within this function.  NOTE: In most usage scenarios now it is\r
 308 faster and more memory efficient to use a direct to task notification instead of\r
 309 a counting semaphore.  http://www.freertos.org/RTOS-task-notifications.html */\r
 310 StaticSemaphore_t xSemaphoreBuffer;\r
 311 \r
 312         /* Create the semaphore.  xSemaphoreCreateCountingStatic() has one more\r
 313         parameter than the usual xSemaphoreCreateCounting() function.  The parameter\r
 314         is a pointer to the pre-allocated StaticSemaphore_t structure, which will\r
 315         hold information on the semaphore in an anonymous way.  If the pointer is\r
 316         passed as NULL then the structure will be allocated dynamically, just as\r
 317         when xSemaphoreCreateCounting() is called. */\r
 318         xSemaphore = xSemaphoreCreateCountingStatic( uxMaxCount, 0, &xSemaphoreBuffer );\r
 319 \r
 320         /* The semaphore handle should equal the static semaphore structure passed\r
 321         into the xSemaphoreCreateBinaryStatic() function. */\r
 322         configASSERT( xSemaphore == ( SemaphoreHandle_t ) &xSemaphoreBuffer );\r
 323 \r
 324         /* Ensure the semaphore passes a few sanity checks as a valid semaphore. */\r
 325         prvSanityCheckCreatedSemaphore( xSemaphore, uxMaxCount );\r
 326 \r
 327         /* Delete the semaphore again so the buffers can be reused. */\r
 328         vSemaphoreDelete( xSemaphore );\r
 329 \r
 330         #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 331         {\r
 332                 /* Now do the same but using dynamically allocated buffers to ensure the\r
 333                 delete functions are working correctly in both the static and dynamic\r
 334                 allocation cases. */\r
 335                 xSemaphore = xSemaphoreCreateCounting( uxMaxCount, 0 );\r
 336                 configASSERT( xSemaphore != NULL );\r
 337                 prvSanityCheckCreatedSemaphore( xSemaphore, uxMaxCount );\r
 338                 vSemaphoreDelete( xSemaphore );\r
 339         }\r
 340         #endif\r
 341 }\r
 342 /*-----------------------------------------------------------*/\r
 343 \r
 344 static void prvCreateAndDeleteStaticallyAllocatedRecursiveMutexes( void )\r
 345 {\r
 346 SemaphoreHandle_t xSemaphore;\r
 347 \r
 348 /* StaticSemaphore_t is a publicly accessible structure that has the same size\r
 349 and alignment requirements as the real semaphore structure.  It is provided as a\r
 350 mechanism for applications to know the size of the semaphore (which is dependent\r
 351 on the architecture and configuration file settings) without breaking the strict\r
 352 data hiding policy by exposing the real semaphore internals.  This\r
 353 StaticSemaphore_t variable is passed into the\r
 354 xSemaphoreCreateRecursiveMutexStatic() function calls within this function. */\r
 355 StaticSemaphore_t xSemaphoreBuffer;\r
 356 \r
 357         /* Create the semaphore.  xSemaphoreCreateRecursiveMutexStatic() has one\r
 358         more parameter than the usual xSemaphoreCreateRecursiveMutex() function.\r
 359         The parameter is a pointer to the pre-allocated StaticSemaphore_t structure,\r
 360         which will hold information on the semaphore in an anonymous way.  If the\r
 361         pointer is passed as NULL then the structure will be allocated dynamically,\r
 362         just as when xSemaphoreCreateRecursiveMutex() is called. */\r
 363         xSemaphore = xSemaphoreCreateRecursiveMutexStatic( &xSemaphoreBuffer );\r
 364 \r
 365         /* The semaphore handle should equal the static semaphore structure passed\r
 366         into the xSemaphoreCreateBinaryStatic() function. */\r
 367         configASSERT( xSemaphore == ( SemaphoreHandle_t ) &xSemaphoreBuffer );\r
 368 \r
 369         /* Ensure the semaphore passes a few sanity checks as a valid\r
 370         recursive semaphore. */\r
 371         prvSanityCheckCreatedRecursiveMutex( xSemaphore );\r
 372 \r
 373         /* Delete the semaphore again so the buffers can be reused. */\r
 374         vSemaphoreDelete( xSemaphore );\r
 375 \r
 376         /* Now do the same using dynamically allocated buffers to ensure the delete\r
 377         functions are working correctly in both the static and dynamic memory\r
 378         allocation cases. */\r
 379         #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 380         {\r
 381                 xSemaphore = xSemaphoreCreateRecursiveMutex();\r
 382                 configASSERT( xSemaphore != NULL );\r
 383                 prvSanityCheckCreatedRecursiveMutex( xSemaphore );\r
 384                 vSemaphoreDelete( xSemaphore );\r
 385         }\r
 386         #endif\r
 387 }\r
 388 /*-----------------------------------------------------------*/\r
 389 \r
 390 static void prvCreateAndDeleteStaticallyAllocatedQueues( void )\r
 391 {\r
 392 QueueHandle_t xQueue;\r
 393 \r
 394 /* StaticQueue_t is a publicly accessible structure that has the same size and\r
 395 alignment requirements as the real queue structure.  It is provided as a\r
 396 mechanism for applications to know the size of the queue (which is dependent on\r
 397 the architecture and configuration file settings) without breaking the strict\r
 398 data hiding policy by exposing the real queue internals.  This StaticQueue_t\r
 399 variable is passed into the xQueueCreateStatic() function calls within this\r
 400 function. */\r
 401 static StaticQueue_t xStaticQueue;\r
 402 \r
 403 /* The queue storage area must be large enough to hold the maximum number of\r
 404 items it is possible for the queue to hold at any one time, which equals the\r
 405 queue length (in items, not bytes) multiplied by the size of each item.  In this\r
 406 case the queue will hold staticQUEUE_LENGTH_IN_ITEMS 64-bit items.  See\r
 407 http://www.freertos.org/Embedded-RTOS-Queues.html */\r
 408 static uint8_t ucQueueStorageArea[ staticQUEUE_LENGTH_IN_ITEMS * sizeof( uint64_t ) ];\r
 409 \r
 410         /* Create the queue.  xQueueCreateStatic() has two more parameters than the\r
 411         usual xQueueCreate() function.  The first new parameter is a pointer to the\r
 412         pre-allocated queue storage area.  The second new parameter is a pointer to\r
 413         the StaticQueue_t structure that will hold the queue state information in\r
 414         an anonymous way.  If the two pointers are passed as NULL then the data\r
 415         will be allocated dynamically as if xQueueCreate() had been called. */\r
 416         xQueue = xQueueCreateStatic( staticQUEUE_LENGTH_IN_ITEMS, /* The maximum number of items the queue can hold. */\r
 417                                                                  sizeof( uint64_t ), /* The size of each item. */\r
 418                                                                  ucQueueStorageArea, /* The buffer used to hold items within the queue. */\r
 419                                                                  &xStaticQueue );        /* The static queue structure that will hold the state of the queue. */\r
 420 \r
 421         /* The queue handle should equal the static queue structure passed into the\r
 422         xQueueCreateStatic() function. */\r
 423         configASSERT( xQueue == ( QueueHandle_t ) &xStaticQueue );\r
 424 \r
 425         /* Ensure the queue passes a few sanity checks as a valid queue. */\r
 426         prvSanityCheckCreatedQueue( xQueue );\r
 427 \r
 428         /* Delete the queue again so the buffers can be reused. */\r
 429         vQueueDelete( xQueue );\r
 430 \r
 431         /* Now do the same using a dynamically allocated queue to ensure the delete\r
 432         function is working correctly in both the static and dynamic memory\r
 433         allocation cases. */\r
 434         #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 435         {\r
 436                 xQueue = xQueueCreate( staticQUEUE_LENGTH_IN_ITEMS, /* The maximum number of items the queue can hold. */\r
 437                                                            sizeof( uint64_t ) );                /* The size of each item. */\r
 438 \r
 439                 /* The queue handle should equal the static queue structure passed into the\r
 440                 xQueueCreateStatic() function. */\r
 441                 configASSERT( xQueue != NULL );\r
 442 \r
 443                 /* Ensure the queue passes a few sanity checks as a valid queue. */\r
 444                 prvSanityCheckCreatedQueue( xQueue );\r
 445 \r
 446                 /* Delete the queue again so the buffers can be reused. */\r
 447                 vQueueDelete( xQueue );\r
 448         }\r
 449         #endif\r
 450 }\r
 451 /*-----------------------------------------------------------*/\r
 452 \r
 453 static void prvCreateAndDeleteStaticallyAllocatedMutexes( void )\r
 454 {\r
 455 SemaphoreHandle_t xSemaphore;\r
 456 BaseType_t xReturned;\r
 457 \r
 458 /* StaticSemaphore_t is a publicly accessible structure that has the same size\r
 459 and alignment requirements as the real semaphore structure.  It is provided as a\r
 460 mechanism for applications to know the size of the semaphore (which is dependent\r
 461 on the architecture and configuration file settings) without breaking the strict\r
 462 data hiding policy by exposing the real semaphore internals.  This\r
 463 StaticSemaphore_t variable is passed into the xSemaphoreCreateMutexStatic()\r
 464 function calls within this function. */\r
 465 StaticSemaphore_t xSemaphoreBuffer;\r
 466 \r
 467         /* Create the semaphore.  xSemaphoreCreateMutexStatic() has one more\r
 468         parameter than the usual xSemaphoreCreateMutex() function.  The parameter\r
 469         is a pointer to the pre-allocated StaticSemaphore_t structure, which will\r
 470         hold information on the semaphore in an anonymous way.  If the pointer is\r
 471         passed as NULL then the structure will be allocated dynamically, just as\r
 472         when xSemaphoreCreateMutex() is called. */\r
 473         xSemaphore = xSemaphoreCreateMutexStatic( &xSemaphoreBuffer );\r
 474 \r
 475         /* The semaphore handle should equal the static semaphore structure passed\r
 476         into the xSemaphoreCreateMutexStatic() function. */\r
 477         configASSERT( xSemaphore == ( SemaphoreHandle_t ) &xSemaphoreBuffer );\r
 478 \r
 479         /* Take the mutex so the mutex is in the state expected by the\r
 480         prvSanityCheckCreatedSemaphore() function. */\r
 481         xReturned = xSemaphoreTake( xSemaphore, staticDONT_BLOCK );\r
 482 \r
 483         if( xReturned != pdPASS )\r
 484         {\r
 485                 xErrorOccurred = pdTRUE;\r
 486         }\r
 487 \r
 488         /* Ensure the semaphore passes a few sanity checks as a valid semaphore. */\r
 489         prvSanityCheckCreatedSemaphore( xSemaphore, staticBINARY_SEMAPHORE_MAX_COUNT );\r
 490 \r
 491         /* Delete the semaphore again so the buffers can be reused. */\r
 492         vSemaphoreDelete( xSemaphore );\r
 493 \r
 494         /* Now do the same using a dynamically allocated mutex to ensure the delete\r
 495         function is working correctly in both the static and dynamic allocation\r
 496         cases. */\r
 497         #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 498         {\r
 499                 xSemaphore = xSemaphoreCreateMutex();\r
 500 \r
 501                 /* The semaphore handle should equal the static semaphore structure\r
 502                 passed into the xSemaphoreCreateMutexStatic() function. */\r
 503                 configASSERT( xSemaphore != NULL );\r
 504 \r
 505                 /* Take the mutex so the mutex is in the state expected by the\r
 506                 prvSanityCheckCreatedSemaphore() function. */\r
 507                 xReturned = xSemaphoreTake( xSemaphore, staticDONT_BLOCK );\r
 508 \r
 509                 if( xReturned != pdPASS )\r
 510                 {\r
 511                         xErrorOccurred = pdTRUE;\r
 512                 }\r
 513 \r
 514                 /* Ensure the semaphore passes a few sanity checks as a valid semaphore. */\r
 515                 prvSanityCheckCreatedSemaphore( xSemaphore, staticBINARY_SEMAPHORE_MAX_COUNT );\r
 516 \r
 517                 /* Delete the semaphore again so the buffers can be reused. */\r
 518                 vSemaphoreDelete( xSemaphore );\r
 519         }\r
 520         #endif\r
 521 }\r
 522 /*-----------------------------------------------------------*/\r
 523 \r
 524 static void prvCreateAndDeleteStaticallyAllocatedBinarySemaphores( void )\r
 525 {\r
 526 SemaphoreHandle_t xSemaphore;\r
 527 \r
 528 /* StaticSemaphore_t is a publicly accessible structure that has the same size\r
 529 and alignment requirements as the real semaphore structure.  It is provided as a\r
 530 mechanism for applications to know the size of the semaphore (which is dependent\r
 531 on the architecture and configuration file settings) without breaking the strict\r
 532 data hiding policy by exposing the real semaphore internals.  This\r
 533 StaticSemaphore_t variable is passed into the xSemaphoreCreateBinaryStatic()\r
 534 function calls within this function.  NOTE: In most usage scenarios now it is\r
 535 faster and more memory efficient to use a direct to task notification instead of\r
 536 a binary semaphore.  http://www.freertos.org/RTOS-task-notifications.html */\r
 537 StaticSemaphore_t xSemaphoreBuffer;\r
 538 \r
 539         /* Create the semaphore.  xSemaphoreCreateBinaryStatic() has one more\r
 540         parameter than the usual xSemaphoreCreateBinary() function.  The parameter\r
 541         is a pointer to the pre-allocated StaticSemaphore_t structure, which will\r
 542         hold information on the semaphore in an anonymous way.  If the pointer is\r
 543         passed as NULL then the structure will be allocated dynamically, just as\r
 544         when xSemaphoreCreateBinary() is called. */\r
 545         xSemaphore = xSemaphoreCreateBinaryStatic( &xSemaphoreBuffer );\r
 546 \r
 547         /* The semaphore handle should equal the static semaphore structure passed\r
 548         into the xSemaphoreCreateBinaryStatic() function. */\r
 549         configASSERT( xSemaphore == ( SemaphoreHandle_t ) &xSemaphoreBuffer );\r
 550 \r
 551         /* Ensure the semaphore passes a few sanity checks as a valid semaphore. */\r
 552         prvSanityCheckCreatedSemaphore( xSemaphore, staticBINARY_SEMAPHORE_MAX_COUNT );\r
 553 \r
 554         /* Delete the semaphore again so the buffers can be reused. */\r
 555         vSemaphoreDelete( xSemaphore );\r
 556 \r
 557         /* Now do the same using a dynamically allocated semaphore to check the\r
 558         delete function is working correctly in both the static and dynamic\r
 559         allocation cases. */\r
 560         #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 561         {\r
 562                 xSemaphore = xSemaphoreCreateBinary();\r
 563                 configASSERT( xSemaphore != NULL );\r
 564                 prvSanityCheckCreatedSemaphore( xSemaphore, staticBINARY_SEMAPHORE_MAX_COUNT );\r
 565                 vSemaphoreDelete( xSemaphore );\r
 566         }\r
 567         #endif\r
 568 \r
 569         /* There isn't a static version of the old and deprecated\r
 570         vSemaphoreCreateBinary() macro (because its deprecated!), but check it is\r
 571         still functioning correctly. */\r
 572         #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 573         {\r
 574                 vSemaphoreCreateBinary( xSemaphore );\r
 575 \r
 576                 /* The macro starts with the binary semaphore available, but the test\r
 577                 function expects it to be unavailable. */\r
 578                 if( xSemaphoreTake( xSemaphore, staticDONT_BLOCK ) == pdFAIL )\r
 579                 {\r
 580                         xErrorOccurred = pdTRUE;\r
 581                 }\r
 582 \r
 583                 prvSanityCheckCreatedSemaphore( xSemaphore, staticBINARY_SEMAPHORE_MAX_COUNT );\r
 584                 vSemaphoreDelete( xSemaphore );\r
 585         }\r
 586         #endif\r
 587 }\r
 588 /*-----------------------------------------------------------*/\r
 589 \r
 590 static void prvTimerCallback( TimerHandle_t xExpiredTimer )\r
 591 {\r
 592 UBaseType_t *puxVariableToIncrement;\r
 593 BaseType_t xReturned;\r
 594 \r
 595         /* The timer callback just demonstrates it is executing by incrementing a\r
 596         variable - the address of which is passed into the timer as its ID.  Obtain\r
 597         the address of the variable to increment. */\r
 598         puxVariableToIncrement = ( UBaseType_t * ) pvTimerGetTimerID( xExpiredTimer );\r
 599 \r
 600         /* Increment the variable to show the timer callback has executed. */\r
 601         ( *puxVariableToIncrement )++;\r
 602 \r
 603         /* If this callback has executed the required number of times, stop the\r
 604         timer. */\r
 605         if( *puxVariableToIncrement == staticMAX_TIMER_CALLBACK_EXECUTIONS )\r
 606         {\r
 607                 /* This is called from a timer callback so must not block.  See\r
 608                 http://www.FreeRTOS.org/FreeRTOS-timers-xTimerStop.html */\r
 609                 xReturned = xTimerStop( xExpiredTimer, staticDONT_BLOCK );\r
 610 \r
 611                 if( xReturned != pdPASS )\r
 612                 {\r
 613                         xErrorOccurred = pdTRUE;\r
 614                 }\r
 615         }\r
 616 }\r
 617 /*-----------------------------------------------------------*/\r
 618 \r
 619 static void prvCreateAndDeleteStaticallyAllocatedTimers( void )\r
 620 {\r
 621 TimerHandle_t xTimer;\r
 622 UBaseType_t uxVariableToIncrement;\r
 623 const TickType_t xTimerPeriod = pdMS_TO_TICKS( 20 );\r
 624 BaseType_t xReturned;\r
 625 \r
 626 /* StaticTimer_t is a publicly accessible structure that has the same size\r
 627 and alignment requirements as the real timer structure.  It is provided as a\r
 628 mechanism for applications to know the size of the timer structure (which is\r
 629 dependent on the architecture and configuration file settings) without breaking\r
 630 the strict data hiding policy by exposing the real timer internals.  This\r
 631 StaticTimer_t variable is passed into the xTimerCreateStatic() function calls\r
 632 within this function. */\r
 633 StaticTimer_t xTimerBuffer;\r
 634 \r
 635         /* Create the software time.  xTimerCreateStatic() has an extra parameter\r
 636         than the normal xTimerCreate() API function.  The parameter is a pointer to\r
 637         the StaticTimer_t structure that will hold the software timer structure.  If\r
 638         the parameter is passed as NULL then the structure will be allocated\r
 639         dynamically, just as if xTimerCreate() had been called. */\r
 640         xTimer = xTimerCreateStatic( "T1",                                      /* Text name for the task.  Helps debugging only.  Not used by FreeRTOS. */\r
 641                                                                  xTimerPeriod,                  /* The period of the timer in ticks. */\r
 642                                                                  pdTRUE,                                /* This is an auto-reload timer. */\r
 643                                                                  ( void * ) &uxVariableToIncrement,     /* The variable incremented by the test is passed into the timer callback using the timer ID. */\r
 644                                                                  prvTimerCallback,              /* The function to execute when the timer expires. */\r
 645                                                                  &xTimerBuffer );               /* The buffer that will hold the software timer structure. */\r
 646 \r
 647         /* The timer handle should equal the static timer structure passed into the\r
 648         xTimerCreateStatic() function. */\r
 649         configASSERT( xTimer == ( TimerHandle_t ) &xTimerBuffer );\r
 650 \r
 651         /* Set the variable to 0, wait for a few timer periods to expire, then check\r
 652         the timer callback has incremented the variable to the expected value. */\r
 653         uxVariableToIncrement = 0;\r
 654 \r
 655         /* This is a low priority so a block time should not be needed. */\r
 656         xReturned = xTimerStart( xTimer, staticDONT_BLOCK );\r
 657 \r
 658         if( xReturned != pdPASS )\r
 659         {\r
 660                 xErrorOccurred = pdTRUE;\r
 661         }\r
 662 \r
 663         vTaskDelay( xTimerPeriod * staticMAX_TIMER_CALLBACK_EXECUTIONS );\r
 664 \r
 665         /* By now the timer should have expired staticMAX_TIMER_CALLBACK_EXECUTIONS\r
 666         times, and then stopped itself. */\r
 667         if( uxVariableToIncrement != staticMAX_TIMER_CALLBACK_EXECUTIONS )\r
 668         {\r
 669                 xErrorOccurred = pdTRUE;\r
 670         }\r
 671 \r
 672         /* Finished with the timer, delete it. */\r
 673         xReturned = xTimerDelete( xTimer, staticDONT_BLOCK );\r
 674 \r
 675         /* Again, as this is a low priority task it is expected that the timer\r
 676         command will have been sent even without a block time being used. */\r
 677         if( xReturned != pdPASS )\r
 678         {\r
 679                 xErrorOccurred = pdTRUE;\r
 680         }\r
 681 \r
 682         /* Just to show the check task that this task is still executing. */\r
 683         uxCycleCounter++;\r
 684 \r
 685         /* Now do the same using a dynamically allocated software timer to ensure\r
 686         the delete function is working correctly in both the static and dynamic\r
 687         allocation cases. */\r
 688         #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 689         {\r
 690                 xTimer = xTimerCreate( "T1",                                                            /* Text name for the task.  Helps debugging only.  Not used by FreeRTOS. */\r
 691                                                             xTimerPeriod,                                               /* The period of the timer in ticks. */\r
 692                                                                 pdTRUE,                                                         /* This is an auto-reload timer. */\r
 693                                                                 ( void * ) &uxVariableToIncrement,      /* The variable incremented by the test is passed into the timer callback using the timer ID. */\r
 694                                                                 prvTimerCallback );                                     /* The function to execute when the timer expires. */\r
 695 \r
 696                 configASSERT( xTimer != NULL );\r
 697 \r
 698                 uxVariableToIncrement = 0;\r
 699                 xReturned = xTimerStart( xTimer, staticDONT_BLOCK );\r
 700 \r
 701                 if( xReturned != pdPASS )\r
 702                 {\r
 703                         xErrorOccurred = pdTRUE;\r
 704                 }\r
 705 \r
 706                 vTaskDelay( xTimerPeriod * staticMAX_TIMER_CALLBACK_EXECUTIONS );\r
 707 \r
 708                 if( uxVariableToIncrement != staticMAX_TIMER_CALLBACK_EXECUTIONS )\r
 709                 {\r
 710                         xErrorOccurred = pdTRUE;\r
 711                 }\r
 712 \r
 713                 xReturned = xTimerDelete( xTimer, staticDONT_BLOCK );\r
 714 \r
 715                 if( xReturned != pdPASS )\r
 716                 {\r
 717                         xErrorOccurred = pdTRUE;\r
 718                 }\r
 719         }\r
 720         #endif\r
 721 }\r
 722 /*-----------------------------------------------------------*/\r
 723 \r
 724 static void prvCreateAndDeleteStaticallyAllocatedEventGroups( void )\r
 725 {\r
 726 EventGroupHandle_t xEventGroup;\r
 727 \r
 728 /* StaticEventGroup_t is a publicly accessible structure that has the same size\r
 729 and alignment requirements as the real event group structure.  It is provided as\r
 730 a mechanism for applications to know the size of the event group (which is\r
 731 dependent on the architecture and configuration file settings) without breaking\r
 732 the strict data hiding policy by exposing the real event group internals.  This\r
 733 StaticEventGroup_t variable is passed into the xSemaphoreCreateEventGroupStatic()\r
 734 function calls within this function. */\r
 735 StaticEventGroup_t xEventGroupBuffer;\r
 736 \r
 737         /* Create the event group.  xEventGroupCreateStatic() has an extra parameter\r
 738         than the normal xEventGroupCreate() API function.  The parameter is a\r
 739         pointer to the StaticEventGroup_t structure that will hold the event group\r
 740         structure.  If the parameter is passed as NULL then the structure will be\r
 741         allocated dynamically, just as if xEventGroupCreate() had been called. */\r
 742         xEventGroup = xEventGroupCreateStatic( &xEventGroupBuffer );\r
 743 \r
 744         /* The event group handle should equal the static event group structure\r
 745         passed into the xEventGroupCreateStatic() function. */\r
 746         configASSERT( xEventGroup == ( EventGroupHandle_t ) &xEventGroupBuffer );\r
 747 \r
 748         /* Ensure the event group passes a few sanity checks as a valid event\r
 749         group. */\r
 750         prvSanityCheckCreatedEventGroup( xEventGroup );\r
 751 \r
 752         /* Delete the event group again so the buffers can be reused. */\r
 753         vEventGroupDelete( xEventGroup );\r
 754 \r
 755         /* Now do the same using a dynamically allocated event group to ensure the\r
 756         delete function is working correctly in both the static and dynamic\r
 757         allocation cases. */\r
 758         #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 759         {\r
 760                 xEventGroup = xEventGroupCreate();\r
 761                 configASSERT( xEventGroup != NULL );\r
 762                 prvSanityCheckCreatedEventGroup( xEventGroup );\r
 763                 vEventGroupDelete( xEventGroup );\r
 764         }\r
 765         #endif\r
 766 }\r
 767 /*-----------------------------------------------------------*/\r
 768 \r
 769 static void prvCreateAndDeleteStaticallyAllocatedTasks( void )\r
 770 {\r
 771 TaskHandle_t xCreatedTask;\r
 772 \r
 773 /* The variable that will hold the TCB of tasks created by this function.  See\r
 774 the comments above the declaration of the xCreatorTaskTCBBuffer variable for\r
 775 more information. */\r
 776 StaticTask_t xTCBBuffer;\r
 777 \r
 778 /* This buffer that will be used as the stack of tasks created by this function.\r
 779 See the comments above the declaration of the uxCreatorTaskStackBuffer[] array\r
 780 above for more information. */\r
 781 static StackType_t uxStackBuffer[ configMINIMAL_STACK_SIZE ];\r
 782 \r
 783         /* Create the task.  xTaskCreateStatic() has two more parameters than\r
 784         the usual xTaskCreate() function.  The first new parameter is a pointer to\r
 785         the pre-allocated stack.  The second new parameter is a pointer to the\r
 786         StaticTask_t structure that will hold the task's TCB.  If both pointers are\r
 787         passed as NULL then the respective object will be allocated dynamically as\r
 788         if xTaskCreate() had been called. */\r
 789         xCreatedTask = xTaskCreateStatic(\r
 790                                                 prvStaticallyAllocatedTask,     /* Function that implements the task. */\r
 791                                                 "Static",                                               /* Human readable name for the task. */\r
 792                                                 configMINIMAL_STACK_SIZE,               /* Task's stack size, in words (not bytes!). */\r
 793                                                 NULL,                                                   /* Parameter to pass into the task. */\r
 794                                                 uxTaskPriorityGet( NULL ) + 1,  /* The priority of the task. */\r
 795                                                 &( uxStackBuffer[ 0 ] ),                /* The buffer to use as the task's stack. */\r
 796                                                 &xTCBBuffer );                                  /* The variable that will hold that task's TCB. */\r
 797 \r
 798         /* Check the task was created correctly, then delete the task. */\r
 799         if( xCreatedTask == NULL )\r
 800         {\r
 801                 xErrorOccurred = pdTRUE;\r
 802         }\r
 803         else if( eTaskGetState( xCreatedTask ) != eSuspended )\r
 804         {\r
 805                 /* The created task had a higher priority so should have executed and\r
 806                 suspended itself by now. */\r
 807                 xErrorOccurred = pdTRUE;\r
 808         }\r
 809         else\r
 810         {\r
 811                 vTaskDelete( xCreatedTask );\r
 812         }\r
 813 \r
 814         /* Now do the same using a dynamically allocated task to ensure the delete\r
 815         function is working correctly in both the static and dynamic allocation\r
 816         cases. */\r
 817         #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 818         {\r
 819         BaseType_t xReturned;\r
 820 \r
 821                 xReturned = xTaskCreate(\r
 822                                                                         prvStaticallyAllocatedTask,             /* Function that implements the task - the same function is used but is actually dynamically allocated this time. */\r
 823                                                                         "Static",                                               /* Human readable name for the task. */\r
 824                                                                         configMINIMAL_STACK_SIZE,               /* Task's stack size, in words (not bytes!). */\r
 825                                                                         NULL,                                                   /* Parameter to pass into the task. */\r
 826                                                                         uxTaskPriorityGet( NULL ) + 1,  /* The priority of the task. */\r
 827                                                                         &xCreatedTask );                                /* Handle of the task being created. */\r
 828 \r
 829                 if( eTaskGetState( xCreatedTask ) != eSuspended )\r
 830                 {\r
 831                         xErrorOccurred = pdTRUE;\r
 832                 }\r
 833 \r
 834                 configASSERT( xReturned == pdPASS );\r
 835                 if( xReturned != pdPASS )\r
 836                 {\r
 837                         xErrorOccurred = pdTRUE;\r
 838                 }\r
 839                 vTaskDelete( xCreatedTask );\r
 840         }\r
 841         #endif\r
 842 }\r
 843 /*-----------------------------------------------------------*/\r
 844 \r
 845 static void prvStaticallyAllocatedTask( void *pvParameters )\r
 846 {\r
 847         ( void ) pvParameters;\r
 848 \r
 849         /* The created task just suspends itself to wait to get deleted.  The task\r
 850         that creates this task checks this task is in the expected Suspended state\r
 851         before deleting it. */\r
 852         vTaskSuspend( NULL );\r
 853 }\r
 854 /*-----------------------------------------------------------*/\r
 855 \r
 856 static UBaseType_t prvRand( void )\r
 857 {\r
 858 const uint32_t ulMultiplier = 0x015a4e35UL, ulIncrement = 1UL;\r
 859 \r
 860         /* Utility function to generate a pseudo random number. */\r
 861         ulNextRand = ( ulMultiplier * ulNextRand ) + ulIncrement;\r
 862         return( ( ulNextRand >> 16UL ) & 0x7fffUL );\r
 863 }\r
 864 /*-----------------------------------------------------------*/\r
 865 \r
 866 static TickType_t prvGetNextDelayTime( void )\r
 867 {\r
 868 TickType_t xNextDelay;\r
 869 const TickType_t xMaxDelay = pdMS_TO_TICKS( ( TickType_t ) 150 );\r
 870 const TickType_t xMinDelay = pdMS_TO_TICKS( ( TickType_t ) 75 );\r
 871 const TickType_t xTinyDelay = pdMS_TO_TICKS( ( TickType_t ) 2 );\r
 872 \r
 873         /* Generate the next delay time.  This is kept within a narrow band so as\r
 874         not to disturb the timing of other tests - but does add in some pseudo\r
 875         randomisation into the tests. */\r
 876         do\r
 877         {\r
 878                 xNextDelay = prvRand() % xMaxDelay;\r
 879 \r
 880                 /* Just in case this loop is executed lots of times. */\r
 881                 vTaskDelay( xTinyDelay );\r
 882 \r
 883         } while ( xNextDelay < xMinDelay );\r
 884 \r
 885         return xNextDelay;\r
 886 }\r
 887 /*-----------------------------------------------------------*/\r
 888 \r
 889 static void prvSanityCheckCreatedEventGroup( EventGroupHandle_t xEventGroup )\r
 890 {\r
 891 EventBits_t xEventBits;\r
 892 const EventBits_t xFirstTestBits = ( EventBits_t ) 0xaa, xSecondTestBits = ( EventBits_t ) 0x55;\r
 893 \r
 894         /* The event group should not have any bits set yet. */\r
 895         xEventBits = xEventGroupGetBits( xEventGroup );\r
 896 \r
 897         if( xEventBits != ( EventBits_t ) 0 )\r
 898         {\r
 899                 xErrorOccurred = pdTRUE;\r
 900         }\r
 901 \r
 902         /* Some some bits, then read them back to check they are as expected. */\r
 903         xEventGroupSetBits( xEventGroup, xFirstTestBits );\r
 904 \r
 905         xEventBits = xEventGroupGetBits( xEventGroup );\r
 906 \r
 907         if( xEventBits != xFirstTestBits )\r
 908         {\r
 909                 xErrorOccurred = pdTRUE;\r
 910         }\r
 911 \r
 912         xEventGroupSetBits( xEventGroup, xSecondTestBits );\r
 913 \r
 914         xEventBits = xEventGroupGetBits( xEventGroup );\r
 915 \r
 916         if( xEventBits != ( xFirstTestBits | xSecondTestBits ) )\r
 917         {\r
 918                 xErrorOccurred = pdTRUE;\r
 919         }\r
 920 \r
 921         /* Finally try clearing some bits too and check that operation proceeds as\r
 922         expected. */\r
 923         xEventGroupClearBits( xEventGroup, xFirstTestBits );\r
 924 \r
 925         xEventBits = xEventGroupGetBits( xEventGroup );\r
 926 \r
 927         if( xEventBits != xSecondTestBits )\r
 928         {\r
 929                 xErrorOccurred = pdTRUE;\r
 930         }\r
 931 }\r
 932 /*-----------------------------------------------------------*/\r
 933 \r
 934 static void prvSanityCheckCreatedSemaphore( SemaphoreHandle_t xSemaphore, UBaseType_t uxMaxCount )\r
 935 {\r
 936 BaseType_t xReturned;\r
 937 UBaseType_t x;\r
 938 const TickType_t xShortBlockTime = pdMS_TO_TICKS( 10 );\r
 939 TickType_t xTickCount;\r
 940 \r
 941         /* The binary semaphore should start 'empty', so a call to xSemaphoreTake()\r
 942         should fail. */\r
 943         xTickCount = xTaskGetTickCount();\r
 944         xReturned = xSemaphoreTake( xSemaphore, xShortBlockTime );\r
 945 \r
 946         if( ( ( TickType_t ) ( xTaskGetTickCount() - xTickCount ) ) < xShortBlockTime )\r
 947         {\r
 948                 /* Did not block on the semaphore as long as expected. */\r
 949                 xErrorOccurred = pdTRUE;\r
 950         }\r
 951 \r
 952         if( xReturned != pdFAIL )\r
 953         {\r
 954                 xErrorOccurred = pdTRUE;\r
 955         }\r
 956 \r
 957         /* Should be possible to 'give' the semaphore up to a maximum of uxMaxCount\r
 958         times. */\r
 959         for( x = 0; x < uxMaxCount; x++ )\r
 960         {\r
 961                 xReturned = xSemaphoreGive( xSemaphore );\r
 962 \r
 963                 if( xReturned == pdFAIL )\r
 964                 {\r
 965                         xErrorOccurred = pdTRUE;\r
 966                 }\r
 967         }\r
 968 \r
 969         /* Giving the semaphore again should fail, as it is 'full'. */\r
 970         xReturned = xSemaphoreGive( xSemaphore );\r
 971 \r
 972         if( xReturned != pdFAIL )\r
 973         {\r
 974                 xErrorOccurred = pdTRUE;\r
 975         }\r
 976 \r
 977         configASSERT( uxSemaphoreGetCount( xSemaphore ) == uxMaxCount );\r
 978 \r
 979         /* Should now be possible to 'take' the semaphore up to a maximum of\r
 980         uxMaxCount times without blocking. */\r
 981         for( x = 0; x < uxMaxCount; x++ )\r
 982         {\r
 983                 xReturned = xSemaphoreTake( xSemaphore, staticDONT_BLOCK );\r
 984 \r
 985                 if( xReturned == pdFAIL )\r
 986                 {\r
 987                         xErrorOccurred = pdTRUE;\r
 988                 }\r
 989         }\r
 990 \r
 991         /* Back to the starting condition, where the semaphore should not be\r
 992         available. */\r
 993         xTickCount = xTaskGetTickCount();\r
 994         xReturned = xSemaphoreTake( xSemaphore, xShortBlockTime );\r
 995 \r
 996         if( ( ( TickType_t ) ( xTaskGetTickCount() - xTickCount ) ) < xShortBlockTime )\r
 997         {\r
 998                 /* Did not block on the semaphore as long as expected. */\r
 999                 xErrorOccurred = pdTRUE;\r
1000         }\r
1001 \r
1002         if( xReturned != pdFAIL )\r
1003         {\r
1004                 xErrorOccurred = pdTRUE;\r
1005         }\r
1006 \r
1007         configASSERT( uxSemaphoreGetCount( xSemaphore ) == 0 );\r
1008 }\r
1009 /*-----------------------------------------------------------*/\r
1010 \r
1011 static void prvSanityCheckCreatedQueue( QueueHandle_t xQueue )\r
1012 {\r
1013 uint64_t ull, ullRead;\r
1014 BaseType_t xReturned, xLoop;\r
1015 \r
1016         /* This test is done twice to ensure the queue storage area wraps. */\r
1017         for( xLoop = 0; xLoop < 2; xLoop++ )\r
1018         {\r
1019                 /* A very basic test that the queue can be written to and read from as\r
1020                 expected.  First the queue should be empty. */\r
1021                 xReturned = xQueueReceive( xQueue, &ull, staticDONT_BLOCK );\r
1022                 if( xReturned != errQUEUE_EMPTY )\r
1023                 {\r
1024                         xErrorOccurred = pdTRUE;\r
1025                 }\r
1026 \r
1027                 /* Now it should be possible to write to the queue staticQUEUE_LENGTH_IN_ITEMS\r
1028                 times. */\r
1029                 for( ull = 0; ull < staticQUEUE_LENGTH_IN_ITEMS; ull++ )\r
1030                 {\r
1031                         xReturned = xQueueSend( xQueue, &ull, staticDONT_BLOCK );\r
1032                         if( xReturned != pdPASS )\r
1033                         {\r
1034                                 xErrorOccurred = pdTRUE;\r
1035                         }\r
1036                 }\r
1037 \r
1038                 /* Should not now be possible to write to the queue again. */\r
1039                 xReturned = xQueueSend( xQueue, &ull, staticDONT_BLOCK );\r
1040                 if( xReturned != errQUEUE_FULL )\r
1041                 {\r
1042                         xErrorOccurred = pdTRUE;\r
1043                 }\r
1044 \r
1045                 /* Now read back from the queue to ensure the data read back matches that\r
1046                 written. */\r
1047                 for( ull = 0; ull < staticQUEUE_LENGTH_IN_ITEMS; ull++ )\r
1048                 {\r
1049                         xReturned = xQueueReceive( xQueue, &ullRead, staticDONT_BLOCK );\r
1050 \r
1051                         if( xReturned != pdPASS )\r
1052                         {\r
1053                                 xErrorOccurred = pdTRUE;\r
1054                         }\r
1055 \r
1056                         if( ullRead != ull )\r
1057                         {\r
1058                                 xErrorOccurred = pdTRUE;\r
1059                         }\r
1060                 }\r
1061 \r
1062                 /* The queue should be empty again. */\r
1063                 xReturned = xQueueReceive( xQueue, &ull, staticDONT_BLOCK );\r
1064                 if( xReturned != errQUEUE_EMPTY )\r
1065                 {\r
1066                         xErrorOccurred = pdTRUE;\r
1067                 }\r
1068         }\r
1069 }\r
1070 /*-----------------------------------------------------------*/\r
1071 \r
1072 static void prvSanityCheckCreatedRecursiveMutex( SemaphoreHandle_t xSemaphore )\r
1073 {\r
1074 const BaseType_t xLoops = 5;\r
1075 BaseType_t x, xReturned;\r
1076 \r
1077         /* A very basic test that the recursive semaphore behaved like a recursive\r
1078         semaphore. First the semaphore should not be able to be given, as it has not\r
1079         yet been taken. */\r
1080         xReturned = xSemaphoreGiveRecursive( xSemaphore );\r
1081 \r
1082         if( xReturned != pdFAIL )\r
1083         {\r
1084                 xErrorOccurred = pdTRUE;\r
1085         }\r
1086 \r
1087         /* Now it should be possible to take the mutex a number of times. */\r
1088         for( x = 0; x < xLoops; x++ )\r
1089         {\r
1090                 xReturned = xSemaphoreTakeRecursive( xSemaphore, staticDONT_BLOCK );\r
1091 \r
1092                 if( xReturned != pdPASS )\r
1093                 {\r
1094                         xErrorOccurred = pdTRUE;\r
1095                 }\r
1096         }\r
1097 \r
1098         /* Should be possible to give the semaphore the same number of times as it\r
1099         was given in the loop above. */\r
1100         for( x = 0; x < xLoops; x++ )\r
1101         {\r
1102                 xReturned = xSemaphoreGiveRecursive( xSemaphore );\r
1103 \r
1104                 if( xReturned != pdPASS )\r
1105                 {\r
1106                         xErrorOccurred = pdTRUE;\r
1107                 }\r
1108         }\r
1109 \r
1110         /* No more gives should be possible though. */\r
1111         xReturned = xSemaphoreGiveRecursive( xSemaphore );\r
1112 \r
1113         if( xReturned != pdFAIL )\r
1114         {\r
1115                 xErrorOccurred = pdTRUE;\r
1116         }\r
1117 }\r
1118 /*-----------------------------------------------------------*/\r
1119 \r
1120 BaseType_t xAreStaticAllocationTasksStillRunning( void )\r
1121 {\r
1122 static UBaseType_t uxLastCycleCounter = 0;\r
1123 BaseType_t xReturn;\r
1124 \r
1125         if( uxCycleCounter == uxLastCycleCounter )\r
1126         {\r
1127                 xErrorOccurred = pdTRUE;\r
1128         }\r
1129         else\r
1130         {\r
1131                 uxLastCycleCounter = uxCycleCounter;\r
1132         }\r
1133 \r
1134         if( xErrorOccurred != pdFALSE )\r
1135         {\r
1136                 xReturn = pdFAIL;\r
1137         }\r
1138         else\r
1139         {\r
1140                 xReturn = pdPASS;\r
1141         }\r
1142 \r
1143         return xReturn;\r
1144 }\r
1145 /*-----------------------------------------------------------*/\r
1146 \r
1147 /* Exclude the entire file if configSUPPORT_STATIC_ALLOCATION is 0. */\r
1148 #endif /* configSUPPORT_STATIC_ALLOCATION == 1 */\r