git.sur5r.net Git - freertos/blob - Demo/MicroBlaze_Spartan-6_EthernetLite/SDKProjects/RTOSDemoSource/main-full.c

   1 /*\r
   2     FreeRTOS V7.0.1 - Copyright (C) 2011 Real Time Engineers Ltd.\r
   3         \r
   4 \r
   5     ***************************************************************************\r
   6      *                                                                       *\r
   7      *    FreeRTOS tutorial books are available in pdf and paperback.        *\r
   8      *    Complete, revised, and edited pdf reference manuals are also       *\r
   9      *    available.                                                         *\r
  10      *                                                                       *\r
  11      *    Purchasing FreeRTOS documentation will not only help you, by       *\r
  12      *    ensuring you get running as quickly as possible and with an        *\r
  13      *    in-depth knowledge of how to use FreeRTOS, it will also help       *\r
  14      *    the FreeRTOS project to continue with its mission of providing     *\r
  15      *    professional grade, cross platform, de facto standard solutions    *\r
  16      *    for microcontrollers - completely free of charge!                  *\r
  17      *                                                                       *\r
  18      *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *\r
  19      *                                                                       *\r
  20      *    Thank you for using FreeRTOS, and thank you for your support!      *\r
  21      *                                                                       *\r
  22     ***************************************************************************\r
  23 \r
  24 \r
  25     This file is part of the FreeRTOS distribution.\r
  26 \r
  27     FreeRTOS is free software; you can redistribute it and/or modify it under\r
  28     the terms of the GNU General Public License (version 2) as published by the\r
  29     Free Software Foundation AND MODIFIED BY the FreeRTOS exception.\r
  30     >>>NOTE<<< The modification to the GPL is included to allow you to\r
  31     distribute a combined work that includes FreeRTOS without being obliged to\r
  32     provide the source code for proprietary components outside of the FreeRTOS\r
  33     kernel.  FreeRTOS is distributed in the hope that it will be useful, but\r
  34     WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\r
  35     or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for\r
  36     more details. You should have received a copy of the GNU General Public\r
  37     License and the FreeRTOS license exception along with FreeRTOS; if not it\r
  38     can be viewed here: http://www.freertos.org/a00114.html and also obtained\r
  39     by writing to Richard Barry, contact details for whom are available on the\r
  40     FreeRTOS WEB site.\r
  41 \r
  42     1 tab == 4 spaces!\r
  43 \r
  44     http://www.FreeRTOS.org - Documentation, latest information, license and\r
  45     contact details.\r
  46 \r
  47     http://www.SafeRTOS.com - A version that is certified for use in safety\r
  48     critical systems.\r
  49 \r
  50     http://www.OpenRTOS.com - Commercial support, development, porting,\r
  51     licensing and training services.\r
  52 */\r
  53 \r
  54 /* ****************************************************************************\r
  55  * main-blinky.c is included when the "Blinky" build configuration is used.\r
  56  * main-full.c is included when the "Full" build configuration is used.\r
  57  *\r
  58  * main-full.c creates a lot of demo and test tasks and timers,  and is \r
  59  * therefore very comprehensive but also complex.  If you would prefer a much \r
  60  * simpler project to get started with, then select the 'Blinky' build \r
  61  * configuration within the SDK Eclipse IDE.  See the documentation page for\r
  62  * this demo on the http://www.FreeRTOS.org web site for more information.\r
  63  * ****************************************************************************\r
  64  *\r
  65  * main() creates all the demo application tasks and timers, then starts the \r
  66  * scheduler.  The web documentation provides more details of the standard demo \r
  67  * application tasks, which provide no particular functionality, but do provide \r
  68  * a good example of how to use the FreeRTOS API.  \r
  69  *\r
  70  * In addition to the standard demo tasks, the following tasks and tests are\r
  71  * defined and/or created within this file:\r
  72  *\r
  73  * TCP/IP ("lwIP") task - TBD _RB_\r
  74  *\r
  75  * "Reg test" tasks - These test the task context switch mechanism by first \r
  76  * filling the MicroBlaze registers with known values, before checking that each\r
  77  * register maintains the value that was written to it as the tasks are switched\r
  78  * in and out.  The two register test tasks do not use the same values, and\r
  79  * execute at a very low priority to ensure they are pre-empted regularly.\r
  80  *\r
  81  * "Check" timer - The check timer period is initially set to five seconds.  \r
  82  * The check timer callback function checks that all the standard demo tasks,\r
  83  * and the register check tasks, are not only still execution, but are executing\r
  84  * without reporting any errors.  If the check timer discovers that a task has\r
  85  * either stalled or reported an error, then it changes its own period from\r
  86  * the inital five seconds, to just 200ms.  The check timer callback function \r
  87  * also toggles an LED each time it is called.  This provides a visual\r
  88  * indication of the system status:  If the LED toggles every five seconds then\r
  89  * no issues have been discovered.  If the LED toggles every 200ms then an issue\r
  90  * has been discovered with at least one task.  The last reported issue is\r
  91  * latched into the pcStatusMessage variable.\r
  92  *\r
  93  * This file also includes example implementations of the vApplicationTickHook(),\r
  94  * vApplicationIdleHook(), vApplicationStackOverflowHook(),\r
  95  * vApplicationMallocFailedHook(), vApplicationClearTimerInterrupt(), and\r
  96  * vApplicationSetupTimerInterrupt() callback (hook) functions.\r
  97  */\r
  98 \r
  99 /* Standard includes. */\r
 100 #include <string.h>\r
 101 #include <stdio.h>\r
 102 \r
 103 /* BSP includes. */\r
 104 #include "xtmrctr.h"\r
 105 \r
 106 /* Kernel includes. */\r
 107 #include "FreeRTOS.h"\r
 108 #include "task.h"\r
 109 #include "timers.h"\r
 110 \r
 111 /* Standard demo includes. */\r
 112 #include "partest.h"\r
 113 #include "flash.h"\r
 114 #include "BlockQ.h"\r
 115 #include "death.h"\r
 116 #include "blocktim.h"\r
 117 #include "semtest.h"\r
 118 #include "PollQ.h"\r
 119 #include "GenQTest.h"\r
 120 #include "QPeek.h"\r
 121 #include "recmutex.h"\r
 122 #include "flop.h"\r
 123 #include "dynamic.h"\r
 124 #include "comtest_strings.h"\r
 125 #include "TimerDemo.h"\r
 126 \r
 127 /* Priorities at which the various tasks are created. */\r
 128 #define mainQUEUE_POLL_PRIORITY         ( tskIDLE_PRIORITY + 1 )\r
 129 #define mainSEM_TEST_PRIORITY           ( tskIDLE_PRIORITY + 1 )\r
 130 #define mainBLOCK_Q_PRIORITY            ( tskIDLE_PRIORITY + 2 )\r
 131 #define mainCREATOR_TASK_PRIORITY   ( tskIDLE_PRIORITY + 3 )\r
 132 #define mainFLASH_TASK_PRIORITY         ( tskIDLE_PRIORITY + 1 )\r
 133 #define mainuIP_TASK_PRIORITY           ( tskIDLE_PRIORITY + 2 )\r
 134 #define mainCOM_TEST_PRIORITY           ( tskIDLE_PRIORITY + 2 )\r
 135 #define mainINTEGER_TASK_PRIORITY   ( tskIDLE_PRIORITY )\r
 136 #define mainGEN_QUEUE_TASK_PRIORITY     ( tskIDLE_PRIORITY )\r
 137 #define mainFLOP_TASK_PRIORITY          ( tskIDLE_PRIORITY )\r
 138 \r
 139 /* The LED toggled by the check task. */\r
 140 #define mainCHECK_LED                           ( 3 )\r
 141 \r
 142 /* The rate at which mainCHECK_LED will toggle when all the tasks are running\r
 143 without error.  See the description of the check timer in the comments at the\r
 144 top of this file. */\r
 145 #define mainNO_ERROR_CHECK_TIMER_PERIOD         ( 5000 / portTICK_RATE_MS )\r
 146 \r
 147 /* The rate at which mainCHECK_LED will toggle when an error has been reported\r
 148 by at least one task.  See the description of the check timer in the comments at \r
 149 the top of this file. */\r
 150 #define mainERROR_CHECK_TIMER_PERIOD            ( 200 / portTICK_RATE_MS )\r
 151 \r
 152 /* A block time of zero simply means "don't block". */
 153 #define mainDONT_BLOCK                                          ( ( portTickType ) 0 )\r
 154 \r
 155 /* The LED used by the comtest tasks. See the comtest_strings.c file for more\r
 156 information.  In this case an invalid LED number is provided as all four\r
 157 available LEDs (LEDs 0 to 3) are already in use. */\r
 158 #define mainCOM_TEST_LED                        ( 4 )\r
 159 \r
 160 /* Baud rate used by the comtest tasks.  The baud rate used is actually fixed in \r
 161 UARTLite IP when the hardware was built, but the standard serial init function \r
 162 required a baud rate parameter to be provided - in this case it is just \r
 163 ignored. */\r
 164 #define mainCOM_TEST_BAUD_RATE                          ( XPAR_RS232_UART_1_BAUDRATE )\r
 165 \r
 166 /* The timer test task generates a lot of timers that all use a different \r
 167 period that is a multiple of the mainTIMER_TEST_PERIOD definition. */\r
 168 #define mainTIMER_TEST_PERIOD                   ( 20 )\r
 169 \r
 170 /*-----------------------------------------------------------*/\r
 171 \r
 172 /*\r
 173  * The register test tasks as described in the comments at the top of this file.\r
 174  * The nature of the register test tasks means they have to be implemented in\r
 175  * assembler.\r
 176  */\r
 177 extern void vRegisterTest1( void *pvParameters );\r
 178 extern void vRegisterTest2( void *pvParameters );\r
 179 \r
 180 /*\r
 181  * Defines the 'check' timer functionality as described at the top of this file.  \r
 182  * This function is the callback function associated with the 'check' timer.\r
 183  */\r
 184 static void vCheckTimerCallback( xTimerHandle xTimer );\r
 185 \r
 186 /* \r
 187  * Configure the interrupt controller, LED outputs and button inputs. \r
 188  */\r
 189 static void prvSetupHardware( void );\r
 190 \r
 191 /*-----------------------------------------------------------*/\r
 192 \r
 193 /* The check timer callback function sets pcStatusMessage to a string that\r
 194 indicates the last reported error that it discovered. */\r
 195 static const char *pcStatusMessage = NULL;\r
 196 \r
 197 /* Structures that hold the state of the various peripherals used by this demo.\r
 198 These are used by the Xilinx peripheral driver API functions.  In this case,\r
 199 only the timer/counter is used directly within this file. */\r
 200 static XTmrCtr xTimer0Instance;\r
 201 \r
 202 /* The 'check' timer, as described at the top of this file. */\r
 203 static xTimerHandle xCheckTimer = NULL;\r
 204 \r
 205 /*-----------------------------------------------------------*/\r
 206 \r
 207 int main( void )\r
 208 {\r
 209         /***************************************************************************\r
 210         This project includes a lot of demo and test tasks and timers,  and is \r
 211         therefore comprehensive, but complex.  If you would prefer a much simpler \r
 212         project to get started with, then select the 'Blinky' build configuration \r
 213         within the SDK Eclipse IDE.\r
 214         ***************************************************************************/\r
 215 \r
 216         /* Configure the interrupt controller, LED outputs and button inputs. */\r
 217         prvSetupHardware();\r
 218 \r
 219         /* Start the reg test tasks, as described in the comments at the top of this\r
 220         file. */\r
 221         xTaskCreate( vRegisterTest1, ( const signed char * const ) "RegTst1", configMINIMAL_STACK_SIZE, ( void * ) 0, tskIDLE_PRIORITY, NULL );\r
 222         xTaskCreate( vRegisterTest2, ( const signed char * const ) "RegTst2", configMINIMAL_STACK_SIZE, ( void * ) 0, tskIDLE_PRIORITY, NULL );\r
 223 \r
 224         /* Create the standard demo tasks. */\r
 225         vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );\r
 226         vCreateBlockTimeTasks();\r
 227         vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );\r
 228         vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );\r
 229         vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );\r
 230         vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY );\r
 231         vStartQueuePeekTasks();\r
 232         vStartRecursiveMutexTasks();\r
 233         vStartComTestStringsTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED );\r
 234         vStartDynamicPriorityTasks();\r
 235         vStartTimerDemoTask( mainTIMER_TEST_PERIOD );\r
 236 \r
 237         /* Note - the set of standard demo tasks contains two versions of\r
 238         vStartMathTasks.c.  One is defined in flop.c, and uses double precision\r
 239         floating point numbers and variables.  The other is defined in sp_flop.c,\r
 240         and uses single precision floating point numbers and variables.  The\r
 241         MicroBlaze floating point unit only handles single precision floating.\r
 242         Therefore, to test the floating point hardware, sp_flop.c should be included\r
 243         in this project. */\r
 244         vStartMathTasks( mainFLOP_TASK_PRIORITY );\r
 245 \r
 246         /* The suicide tasks must be created last as they need to know how many\r
 247         tasks were running prior to their creation.  This then allows them to \r
 248         ascertain whether or not the correct/expected number of tasks are running at \r
 249         any given time. */\r
 250         vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY );\r
 251 \r
 252         /* Create the 'check' timer - the timer that periodically calls the\r
 253         check function as described in the comments at the top of this file.  Note \r
 254         that, for reasons stated in the comments within vApplicationIdleHook()\r
 255         (defined in this file), the check timer is not actually started until after \r
 256         the scheduler has been started. */\r
 257         xCheckTimer = xTimerCreate( ( const signed char * ) "Check timer", mainNO_ERROR_CHECK_TIMER_PERIOD, pdTRUE, ( void * ) 0, vCheckTimerCallback );\r
 258 \r
 259         /* Start the scheduler running.  From this point on, only tasks and \r
 260         interrupts will be executing. */\r
 261         vTaskStartScheduler();\r
 262 \r
 263         /* If all is well then the following line will never be reached.  If\r
 264         execution does reach here, then it is highly probably that the heap size\r
 265         is too small for the idle and/or timer tasks to be created within \r
 266         vTaskStartScheduler(). */\r
 267         taskDISABLE_INTERRUPTS();\r
 268         for( ;; );\r
 269 }\r
 270 /*-----------------------------------------------------------*/\r
 271 \r
 272 static void vCheckTimerCallback( xTimerHandle xTimer )\r
 273 {\r
 274 extern unsigned long ulRegTest1CycleCount, ulRegTest2CycleCount;\r
 275 static volatile unsigned long ulLastRegTest1CycleCount = 0UL, ulLastRegTest2CycleCount = 0UL;\r
 276 static long lErrorAlreadyLatched = pdFALSE;\r
 277 portTickType xExecutionRate = mainNO_ERROR_CHECK_TIMER_PERIOD;\r
 278 \r
 279         /* This is the callback function used by the 'check' timer, as described\r
 280         in the comments at the top of this file. */\r
 281 \r
 282         /* Check the standard demo tasks are running without error. */\r
 283         if( xAreGenericQueueTasksStillRunning() != pdTRUE )\r
 284         {\r
 285                 pcStatusMessage = "Error: GenQueue";\r
 286         }\r
 287         else if( xAreQueuePeekTasksStillRunning() != pdTRUE )\r
 288         {\r
 289                 pcStatusMessage = "Error: QueuePeek\r\n";\r
 290         }\r
 291         else if( xAreBlockingQueuesStillRunning() != pdTRUE )\r
 292         {\r
 293                 pcStatusMessage = "Error: BlockQueue\r\n";\r
 294         }\r
 295         else if( xAreBlockTimeTestTasksStillRunning() != pdTRUE )\r
 296         {\r
 297                 pcStatusMessage = "Error: BlockTime\r\n";\r
 298         }\r
 299         else if( xAreSemaphoreTasksStillRunning() != pdTRUE )\r
 300         {\r
 301                 pcStatusMessage = "Error: SemTest\r\n";\r
 302         }\r
 303         else if( xArePollingQueuesStillRunning() != pdTRUE )\r
 304         {\r
 305                 pcStatusMessage = "Error: PollQueue\r\n";\r
 306         }\r
 307         else if( xIsCreateTaskStillRunning() != pdTRUE )\r
 308         {\r
 309                 pcStatusMessage = "Error: Death\r\n";\r
 310         }\r
 311         else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE )\r
 312         {\r
 313                 pcStatusMessage = "Error: RecMutex\r\n";\r
 314         }\r
 315         else if( xAreMathsTaskStillRunning() != pdPASS )\r
 316         {\r
 317                 pcStatusMessage = "Error: Flop\r\n";\r
 318         }\r
 319         else if( xAreComTestTasksStillRunning() != pdPASS )\r
 320         {\r
 321                 pcStatusMessage = "Error: Comtest\r\n";\r
 322         }\r
 323         else if( xAreDynamicPriorityTasksStillRunning() != pdPASS )\r
 324         {\r
 325                 pcStatusMessage = "Error: Dynamic\r\n";\r
 326         }\r
 327         else if( xAreTimerDemoTasksStillRunning( xExecutionRate ) != pdTRUE )\r
 328         {\r
 329                 pcStatusMessage = "Error: TimerDemo";\r
 330         }\r
 331         else if( ulRegTest1CycleCount == ulLastRegTest1CycleCount )\r
 332         {\r
 333                 /* Check the reg test tasks are still cycling.  They will stop\r
 334                 incrementing their loop counters if they encounter an error. */\r
 335                 pcStatusMessage = "Error: RegTest1\r\n";\r
 336         }\r
 337         else if( ulRegTest2CycleCount == ulLastRegTest2CycleCount )\r
 338         {\r
 339                 pcStatusMessage = "Error: RegTest2\r\n";\r
 340         }\r
 341 \r
 342         /* Store a local copy of the current reg test loop counters.  If these have\r
 343         not incremented the next time this callback function is executed then the\r
 344         reg test tasks have either stalled or discovered an error. */\r
 345         ulLastRegTest1CycleCount = ulRegTest1CycleCount;\r
 346         ulLastRegTest2CycleCount = ulRegTest2CycleCount;\r
 347 \r
 348         /* Toggle the check LED to give an indication of the system status.  If\r
 349         the LED toggles every 5 seconds then everything is ok.  A faster toggle\r
 350         indicates an error. */\r
 351         vParTestToggleLED( mainCHECK_LED );\r
 352 \r
 353         if( pcStatusMessage != NULL )\r
 354         {\r
 355                 if( lErrorAlreadyLatched == pdFALSE )\r
 356                 {\r
 357                         /* An error has occurred, so change the period of the timer that\r
 358                         calls this callback function.  This results in the LED toggling at\r
 359                         a faster rate - giving the user visual feedback that something is not\r
 360                         as it should be.  This function is called from the context of the\r
 361                         timer service task so must ***not*** attempt to block while calling\r
 362                         this function. */
 363                         if( xTimerChangePeriod( xTimer, mainERROR_CHECK_TIMER_PERIOD, mainDONT_BLOCK ) == pdPASS )\r
 364                         {\r
 365                                 /* If the command to change the timer period was sent to the\r
 366                                 timer command queue successfully, then latch the fact that the\r
 367                                 timer period has already been changed.  This is just done to\r
 368                                 prevent xTimerChangePeriod() being called on every execution of\r
 369                                 this function once an error has been discovered.  */\r
 370                                 lErrorAlreadyLatched = pdTRUE;\r
 371                         }\r
 372 \r
 373                         /* Update the xExecutionRate variable too as the rate at which this\r
 374                         callback is executed has to be passed into the\r
 375                         xAreTimerDemoTasksStillRunning() function. */\r
 376                         xExecutionRate = mainERROR_CHECK_TIMER_PERIOD;\r
 377                 }\r
 378         }\r
 379 }\r
 380 /*-----------------------------------------------------------*/\r
 381 \r
 382 /* This is an application defined callback function used to install the tick\r
 383 interrupt handler.  It is provided as an application callback because the kernel\r
 384 will run on lots of different MicroBlaze and FPGA configurations - not all of\r
 385 which will have the same timer peripherals defined or available.  This example\r
 386 uses the AXI Timer 0.  If that is available on your hardware platform then this\r
 387 example callback implementation should not require modification.   The name of\r
 388 the interrupt handler that should be installed is vTickISR(), which the function\r
 389 below declares as an extern. */\r
 390 void vApplicationSetupTimerInterrupt( void )\r
 391 {\r
 392 portBASE_TYPE xStatus;\r
 393 const unsigned char ucTimerCounterNumber = ( unsigned char ) 0U;\r
 394 const unsigned long ulCounterValue = ( ( XPAR_AXI_TIMER_0_CLOCK_FREQ_HZ / configTICK_RATE_HZ ) - 1UL );\r
 395 extern void vTickISR( void *pvUnused );\r
 396 \r
 397         /* Initialise the timer/counter. */\r
 398         xStatus = XTmrCtr_Initialize( &xTimer0Instance, XPAR_AXI_TIMER_0_DEVICE_ID );\r
 399 \r
 400         if( xStatus == XST_SUCCESS )\r
 401         {\r
 402                 /* Install the tick interrupt handler as the timer ISR. \r
 403                 *NOTE* The xPortInstallInterruptHandler() API function must be used for\r
 404                 this purpose. */\r
 405                 xStatus = xPortInstallInterruptHandler( XPAR_INTC_0_TMRCTR_0_VEC_ID, vTickISR, NULL );\r
 406         }\r
 407 \r
 408         if( xStatus == pdPASS )\r
 409         {\r
 410                 /* Enable the timer interrupt in the interrupt controller.\r
 411                 *NOTE* The vPortEnableInterrupt() API function must be used for this\r
 412                 purpose. */\r
 413                 vPortEnableInterrupt( XPAR_INTC_0_TMRCTR_0_VEC_ID );\r
 414 \r
 415                 /* Configure the timer interrupt handler. */\r
 416                 XTmrCtr_SetHandler( &xTimer0Instance, ( void * ) vTickISR, NULL );\r
 417 \r
 418                 /* Set the correct period for the timer. */\r
 419                 XTmrCtr_SetResetValue( &xTimer0Instance, ucTimerCounterNumber, ulCounterValue );\r
 420 \r
 421                 /* Enable the interrupts.  Auto-reload mode is used to generate a\r
 422                 periodic tick.  Note that interrupts are disabled when this function is\r
 423                 called, so interrupts will not start to be processed until the first\r
 424                 task has started to run. */\r
 425                 XTmrCtr_SetOptions( &xTimer0Instance, ucTimerCounterNumber, ( XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION | XTC_DOWN_COUNT_OPTION ) );\r
 426 \r
 427                 /* Start the timer. */\r
 428                 XTmrCtr_Start( &xTimer0Instance, ucTimerCounterNumber );\r
 429         }\r
 430 \r
 431         /* Sanity check that the function executed as expected. */\r
 432         configASSERT( ( xStatus == pdPASS ) );\r
 433 }\r
 434 /*-----------------------------------------------------------*/\r
 435 \r
 436 /* This is an application defined callback function used to clear whichever\r
 437 interrupt was installed by the the vApplicationSetupTimerInterrupt() callback\r
 438 function - in this case the interrupt generated by the AXI timer.  It is \r
 439 provided as an application callback because the kernel will run on lots of \r
 440 different MicroBlaze and FPGA configurations - not all of which will have the \r
 441 same timer peripherals defined or available.  This example uses the AXI Timer 0.  \r
 442 If that is available on your hardware platform then this example callback \r
 443 implementation should not require modification provided the example definition\r
 444 of vApplicationSetupTimerInterrupt() is also not modified. */\r
 445 void vApplicationClearTimerInterrupt( void )\r
 446 {\r
 447 unsigned long ulCSR;\r
 448 \r
 449         /* Clear the timer interrupt */\r
 450         ulCSR = XTmrCtr_GetControlStatusReg( XPAR_AXI_TIMER_0_BASEADDR, 0 );\r
 451         XTmrCtr_SetControlStatusReg( XPAR_AXI_TIMER_0_BASEADDR, 0, ulCSR );\r
 452 }\r
 453 /*-----------------------------------------------------------*/\r
 454 \r
 455 void vApplicationMallocFailedHook( void )\r
 456 {\r
 457         /* vApplicationMallocFailedHook() will only be called if\r
 458         configUSE_MALLOC_FAILED_HOOK is set to 1 in FreeRTOSConfig.h.  It is a hook\r
 459         function that will get called if a call to pvPortMalloc() fails. \r
 460         pvPortMalloc() is called internally by the kernel whenever a task, queue or\r
 461         semaphore is created.  It is also called by various parts of the demo\r
 462         application.  If heap_1.c or heap_2.c are used, then the size of the heap\r
 463         available to pvPortMalloc() is defined by configTOTAL_HEAP_SIZE in\r
 464         FreeRTOSConfig.h, and the xPortGetFreeHeapSize() API function can be used\r
 465         to query the size of free heap space that remains (although it does not\r
 466         provide information on how the remaining heap might be fragmented). */\r
 467         taskDISABLE_INTERRUPTS();\r
 468         for( ;; );\r
 469 }\r
 470 /*-----------------------------------------------------------*/\r
 471 \r
 472 void vApplicationStackOverflowHook( xTaskHandle *pxTask, signed char *pcTaskName )\r
 473 {\r
 474         /* vApplicationStackOverflowHook() will only be called if\r
 475         configCHECK_FOR_STACK_OVERFLOW is set to either 1 or 2.  The handle and name\r
 476         of the offending task will be passed into the hook function via its \r
 477         parameters.  However, when a stack has overflowed, it is possible that the\r
 478         parameters will have been corrupted, in which case the pxCurrentTCB variable\r
 479         can be inspected directly. */\r
 480         taskDISABLE_INTERRUPTS();\r
 481         for( ;; );\r
 482 }\r
 483 /*-----------------------------------------------------------*/\r
 484 \r
 485 void vApplicationIdleHook( void )\r
 486 {\r
 487 static long lCheckTimerStarted = pdFALSE;\r
 488 \r
 489         /* vApplicationIdleHook() will only be called if configUSE_IDLE_HOOK is set \r
 490         to 1 in FreeRTOSConfig.h.  It will be called on each iteration of the idle \r
 491         task.  It is essential that code added to this hook function never attempts \r
 492         to block in any way (for example, call xQueueReceive() with a block time \r
 493         specified, or call vTaskDelay()).  If the application makes use of the \r
 494         vTaskDelete() API function (as this demo application does) then it is also \r
 495         important that vApplicationIdleHook() is permitted to return to its calling \r
 496         function, because it is the responsibility of the idle task to clean up \r
 497         memory allocated by the kernel to any task that has since been deleted. */\r
 498 \r
 499         /* If the check timer has not already been started, then start it now.\r
 500         Normally, the xTimerStart() API function can be called immediately after the\r
 501         timer is created - how this demo application includes the timer demo tasks.\r
 502         The timer demo tasks, as part of their test function, deliberately fill up\r
 503         the timer command queue - meaning the check timer cannot be started until\r
 504         after the scheduler has been started - at which point the timer command\r
 505         queue will have been drained. */\r
 506         if( lCheckTimerStarted == pdFALSE )\r
 507         {\r
 508                 xTimerStart( xCheckTimer, mainDONT_BLOCK ); \r
 509                 lCheckTimerStarted = pdTRUE;\r
 510         }\r
 511 }\r
 512 /*-----------------------------------------------------------*/\r
 513 \r
 514 void vApplicationTickHook( void )\r
 515 {\r
 516         /* vApplicationTickHook() will only be called if configUSE_TICK_HOOK is set\r
 517         to 1 in FreeRTOSConfig.h.  It executes from an interrupt context so must\r
 518         not use any FreeRTOS API functions that do not end in ...FromISR(). */\r
 519 \r
 520         /* Call the periodic timer test, which tests the timer API functions that\r
 521         can be called from an ISR. */\r
 522         vTimerPeriodicISRTests();\r
 523 }\r
 524 /*-----------------------------------------------------------*/\r
 525 \r
 526 void vApplicationExceptionRegisterDump( xPortRegisterDump *xRegisterDump )\r
 527 {\r
 528         /* If configINSTALL_EXCEPTION_HANDLERS is set to 1 in FreeRTOSConfig.h, then \r
 529         the kernel will automatically install its own exception handlers before the \r
 530         kernel is started, if the application writer has not already caused them to \r
 531         be installed by calling either of the vPortExceptionsInstallHandlers() \r
 532         or xPortInstallInterruptHandler() API functions before that time.  The \r
 533         kernels exception handler populates an xPortRegisterDump structure with\r
 534         the processor state at the point that the exception was triggered - and also\r
 535         includes a strings that say what the exception cause was and which task was\r
 536         running at the time.  The exception handler then passes the populated\r
 537         xPortRegisterDump structure into vApplicationExceptionRegisterDump() to\r
 538         allow the application writer to perform any debugging that may be necessary.\r
 539         However, defining vApplicationExceptionRegisterDump() within the application\r
 540         itself is optional.  The kernel will use a default implementation if the\r
 541         application writer chooses not to provide their own. */\r
 542         for( ;; )\r
 543         {\r
 544                 portNOP();\r
 545         }\r
 546 }\r
 547 /*-----------------------------------------------------------*/\r
 548 \r
 549 static void prvSetupHardware( void )\r
 550 {\r
 551         taskDISABLE_INTERRUPTS();\r
 552         \r
 553         /* Configure the LED outputs. */\r
 554         vParTestInitialise();\r
 555 \r
 556         /* Tasks inherit the exception and cache configuration of the MicroBlaze\r
 557         at the point that they are created. */\r
 558         #if MICROBLAZE_EXCEPTIONS_ENABLED == 1\r
 559                 microblaze_enable_exceptions();\r
 560         #endif\r
 561 \r
 562         #if XPAR_MICROBLAZE_USE_ICACHE == 1\r
 563                 microblaze_invalidate_icache();\r
 564                 microblaze_enable_icache();\r
 565         #endif\r
 566 \r
 567         #if XPAR_MICROBLAZE_USE_DCACHE == 1\r
 568                 microblaze_invalidate_dcache();\r
 569                 microblaze_enable_dcache();\r
 570         #endif\r
 571 \r
 572 }\r
 573 /*-----------------------------------------------------------*/\r
 574 \r