git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_LM3S811_KEIL/main.c

   1 /*\r
   2     FreeRTOS V8.2.0rc1 - Copyright (C) 2014 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     >>!   NOTE: The modification to the GPL is included to allow you to     !<<\r
  14     >>!   distribute a combined work that includes FreeRTOS without being   !<<\r
  15     >>!   obliged to provide the source code for proprietary components     !<<\r
  16     >>!   outside of the FreeRTOS kernel.                                   !<<\r
  17 \r
  18     FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
  19     WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
  20     FOR A PARTICULAR PURPOSE.  Full license text is available on the following\r
  21     link: http://www.freertos.org/a00114.html\r
  22 \r
  23     1 tab == 4 spaces!\r
  24 \r
  25     ***************************************************************************\r
  26      *                                                                       *\r
  27      *    Having a problem?  Start by reading the FAQ "My application does   *\r
  28      *    not run, what could be wrong?".  Have you defined configASSERT()?  *\r
  29      *                                                                       *\r
  30      *    http://www.FreeRTOS.org/FAQHelp.html                               *\r
  31      *                                                                       *\r
  32     ***************************************************************************\r
  33 \r
  34     ***************************************************************************\r
  35      *                                                                       *\r
  36      *    FreeRTOS provides completely free yet professionally developed,    *\r
  37      *    robust, strictly quality controlled, supported, and cross          *\r
  38      *    platform software that is more than just the market leader, it     *\r
  39      *    is the industry's de facto standard.                               *\r
  40      *                                                                       *\r
  41      *    Help yourself get started quickly while simultaneously helping     *\r
  42      *    to support the FreeRTOS project by purchasing a FreeRTOS           *\r
  43      *    tutorial book, reference manual, or both:                          *\r
  44      *    http://www.FreeRTOS.org/Documentation                              *\r
  45      *                                                                       *\r
  46     ***************************************************************************\r
  47 \r
  48     ***************************************************************************\r
  49      *                                                                       *\r
  50      *   Investing in training allows your team to be as productive as       *\r
  51      *   possible as early as possible, lowering your overall development    *\r
  52      *   cost, and enabling you to bring a more robust product to market     *\r
  53      *   earlier than would otherwise be possible.  Richard Barry is both    *\r
  54      *   the architect and key author of FreeRTOS, and so also the world's   *\r
  55      *   leading authority on what is the world's most popular real time     *\r
  56      *   kernel for deeply embedded MCU designs.  Obtaining your training    *\r
  57      *   from Richard ensures your team will gain directly from his in-depth *\r
  58      *   product knowledge and years of usage experience.  Contact Real Time *\r
  59      *   Engineers Ltd to enquire about the FreeRTOS Masterclass, presented  *\r
  60      *   by Richard Barry:  http://www.FreeRTOS.org/contact\r
  61      *                                                                       *\r
  62     ***************************************************************************\r
  63 \r
  64     ***************************************************************************\r
  65      *                                                                       *\r
  66      *    You are receiving this top quality software for free.  Please play *\r
  67      *    fair and reciprocate by reporting any suspected issues and         *\r
  68      *    participating in the community forum:                              *\r
  69      *    http://www.FreeRTOS.org/support                                    *\r
  70      *                                                                       *\r
  71      *    Thank you!                                                         *\r
  72      *                                                                       *\r
  73     ***************************************************************************\r
  74 \r
  75     http://www.FreeRTOS.org - Documentation, books, training, latest versions,\r
  76     license and Real Time Engineers Ltd. contact details.\r
  77 \r
  78     http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
  79     including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
  80     compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
  81 \r
  82     http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.\r
  83     Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.\r
  84 \r
  85     http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High\r
  86     Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS\r
  87     licenses offer ticketed support, indemnification and commercial middleware.\r
  88 \r
  89     http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
  90     engineered and independently SIL3 certified version for use in safety and\r
  91     mission critical applications that require provable dependability.\r
  92 \r
  93     1 tab == 4 spaces!\r
  94 */\r
  95 \r
  96 \r
  97 /*\r
  98  * This project contains an application demonstrating the use of the \r
  99  * FreeRTOS.org mini real time scheduler on the Luminary Micro LM3S811 Eval\r
 100  * board.  See http://www.FreeRTOS.org for more information.\r
 101  *\r
 102  * main() simply sets up the hardware, creates all the demo application tasks, \r
 103  * then starts the scheduler.  http://www.freertos.org/a00102.html provides\r
 104  * more information on the standard demo tasks. \r
 105  *\r
 106  * In addition to a subset of the standard demo application tasks, main.c also\r
 107  * defines the following tasks: \r
 108  *\r
 109  * + A 'Print' task.  The print task is the only task permitted to access the\r
 110  * LCD - thus ensuring mutual exclusion and consistent access to the resource.\r
 111  * Other tasks do not access the LCD directly, but instead send the text they\r
 112  * wish to display to the print task.  The print task spends most of its time\r
 113  * blocked - only waking when a message is queued for display.\r
 114  *\r
 115  * + A 'Button handler' task.  The eval board contains a user push button that\r
 116  * is configured to generate interrupts.  The interrupt handler uses a \r
 117  * semaphore to wake the button handler task - demonstrating how the priority \r
 118  * mechanism can be used to defer interrupt processing to the task level.  The\r
 119  * button handler task sends a message both to the LCD (via the print task) and\r
 120  * the UART where it can be viewed using a dumb terminal (via the UART to USB\r
 121  * converter on the eval board).  NOTES:  The dumb terminal must be closed in \r
 122  * order to reflash the microcontroller.  A very basic interrupt driven UART\r
 123  * driver is used that does not use the FIFO.  19200 baud is used.\r
 124  *\r
 125  * + A 'check' task.  The check task only executes every five seconds but has a\r
 126  * high priority so is guaranteed to get processor time.  Its function is to\r
 127  * check that all the other tasks are still operational and that no errors have\r
 128  * been detected at any time.  If no errors have every been detected 'PASS' is\r
 129  * written to the display (via the print task) - if an error has ever been\r
 130  * detected the message is changed to 'FAIL'.  The position of the message is\r
 131  * changed for each write.\r
 132  */\r
 133 \r
 134 \r
 135 \r
 136 /* Environment includes. */\r
 137 #include "DriverLib.h"\r
 138 \r
 139 /* Scheduler includes. */\r
 140 #include "FreeRTOS.h"\r
 141 #include "task.h"\r
 142 #include "queue.h"\r
 143 #include "semphr.h"\r
 144 \r
 145 /* Demo app includes. */\r
 146 #include "integer.h"\r
 147 #include "PollQ.h"\r
 148 #include "semtest.h"\r
 149 #include "BlockQ.h"\r
 150 \r
 151 /* Delay between cycles of the 'check' task. */\r
 152 #define mainCHECK_DELAY                                         ( ( TickType_t ) 5000 / portTICK_PERIOD_MS )\r
 153 \r
 154 /* UART configuration - note this does not use the FIFO so is not very \r
 155 efficient. */\r
 156 #define mainBAUD_RATE                           ( 19200 )\r
 157 #define mainFIFO_SET                            ( 0x10 )\r
 158 \r
 159 /* Demo task priorities. */\r
 160 #define mainQUEUE_POLL_PRIORITY         ( tskIDLE_PRIORITY + 2 )\r
 161 #define mainCHECK_TASK_PRIORITY         ( tskIDLE_PRIORITY + 3 )\r
 162 #define mainSEM_TEST_PRIORITY           ( tskIDLE_PRIORITY + 1 )\r
 163 #define mainBLOCK_Q_PRIORITY            ( tskIDLE_PRIORITY + 2 )\r
 164 \r
 165 /* Demo board specifics. */\r
 166 #define mainPUSH_BUTTON             GPIO_PIN_4\r
 167 \r
 168 /* Misc. */\r
 169 #define mainQUEUE_SIZE                          ( 3 )\r
 170 #define mainDEBOUNCE_DELAY                      ( ( TickType_t ) 150 / portTICK_PERIOD_MS )\r
 171 #define mainNO_DELAY                            ( ( TickType_t ) 0 )\r
 172 /*\r
 173  * Configure the processor and peripherals for this demo. \r
 174  */\r
 175 static void prvSetupHardware( void );\r
 176 \r
 177 /*\r
 178  * The 'check' task, as described at the top of this file.\r
 179  */\r
 180 static void vCheckTask( void *pvParameters );\r
 181 \r
 182 /*\r
 183  * The task that is woken by the ISR that processes GPIO interrupts originating\r
 184  * from the push button.\r
 185  */\r
 186 static void vButtonHandlerTask( void *pvParameters );\r
 187 \r
 188 /*\r
 189  * The task that controls access to the LCD.\r
 190  */\r
 191 static void vPrintTask( void *pvParameter );\r
 192 \r
 193 /* String that is transmitted on the UART. */\r
 194 static char *cMessage = "Task woken by button interrupt! --- ";\r
 195 static volatile char *pcNextChar;\r
 196 \r
 197 /* The semaphore used to wake the button handler task from within the GPIO\r
 198 interrupt handler. */\r
 199 SemaphoreHandle_t xButtonSemaphore;\r
 200 \r
 201 /* The queue used to send strings to the print task for display on the LCD. */\r
 202 QueueHandle_t xPrintQueue;\r
 203 \r
 204 /* Newer library version. */\r
 205 extern void UARTConfigSetExpClk(unsigned long ulBase, unsigned long ulUARTClk, unsigned long ulBaud, unsigned long ulConfig);\r
 206 /*-----------------------------------------------------------*/\r
 207 \r
 208 int main( void )\r
 209 {\r
 210         /* Configure the clocks, UART and GPIO. */\r
 211         prvSetupHardware();\r
 212 \r
 213         /* Create the semaphore used to wake the button handler task from the GPIO\r
 214         ISR. */\r
 215         vSemaphoreCreateBinary( xButtonSemaphore );\r
 216         xSemaphoreTake( xButtonSemaphore, 0 );\r
 217 \r
 218         /* Create the queue used to pass message to vPrintTask. */\r
 219         xPrintQueue = xQueueCreate( mainQUEUE_SIZE, sizeof( char * ) );\r
 220 \r
 221         /* Start the standard demo tasks. */\r
 222         vStartIntegerMathTasks( tskIDLE_PRIORITY );\r
 223         vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );\r
 224         vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );\r
 225         vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );\r
 226 \r
 227         /* Start the tasks defined within the file. */\r
 228         xTaskCreate( vCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );\r
 229         xTaskCreate( vButtonHandlerTask, "Status", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY + 1, NULL );\r
 230         xTaskCreate( vPrintTask, "Print", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY - 1, NULL );\r
 231 \r
 232         /* Start the scheduler. */\r
 233         vTaskStartScheduler();\r
 234 \r
 235         /* Will only get here if there was insufficient heap to start the \r
 236         scheduler. */\r
 237 \r
 238         return 0;\r
 239 }\r
 240 /*-----------------------------------------------------------*/\r
 241 \r
 242 static void vCheckTask( void *pvParameters )\r
 243 {\r
 244 portBASE_TYPE xErrorOccurred = pdFALSE;\r
 245 TickType_t xLastExecutionTime;\r
 246 const char *pcPassMessage = "PASS";\r
 247 const char *pcFailMessage = "FAIL";\r
 248 \r
 249         /* Initialise xLastExecutionTime so the first call to vTaskDelayUntil()\r
 250         works correctly. */\r
 251         xLastExecutionTime = xTaskGetTickCount();\r
 252 \r
 253         for( ;; )\r
 254         {\r
 255                 /* Perform this check every mainCHECK_DELAY milliseconds. */\r
 256                 vTaskDelayUntil( &xLastExecutionTime, mainCHECK_DELAY );\r
 257 \r
 258                 /* Has an error been found in any task? */\r
 259 \r
 260                 if( xAreIntegerMathsTaskStillRunning() != pdTRUE )\r
 261                 {\r
 262                         xErrorOccurred = pdTRUE;\r
 263                 }\r
 264         \r
 265                 if( xArePollingQueuesStillRunning() != pdTRUE )\r
 266                 {\r
 267                         xErrorOccurred = pdTRUE;\r
 268                 }\r
 269         \r
 270                 if( xAreSemaphoreTasksStillRunning() != pdTRUE )\r
 271                 {\r
 272                         xErrorOccurred = pdTRUE;\r
 273                 }\r
 274 \r
 275                 if( xAreBlockingQueuesStillRunning() != pdTRUE )\r
 276                 {\r
 277                         xErrorOccurred = pdTRUE;\r
 278                 }\r
 279 \r
 280                 /* Send either a pass or fail message.  If an error is found it is\r
 281                 never cleared again.  We do not write directly to the LCD, but instead\r
 282                 queue a message for display by the print task. */\r
 283                 if( xErrorOccurred == pdTRUE )\r
 284                 {\r
 285                         xQueueSend( xPrintQueue, &pcFailMessage, portMAX_DELAY );\r
 286                 }\r
 287                 else\r
 288                 {\r
 289                         xQueueSend( xPrintQueue, &pcPassMessage, portMAX_DELAY );\r
 290                 }\r
 291         }\r
 292 }\r
 293 /*-----------------------------------------------------------*/\r
 294 \r
 295 static void prvSetupHardware( void )\r
 296 {\r
 297         /* Setup the PLL. */\r
 298         SysCtlClockSet( SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_6MHZ );\r
 299 \r
 300         /* Setup the push button. */\r
 301         SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);\r
 302     GPIODirModeSet(GPIO_PORTC_BASE, mainPUSH_BUTTON, GPIO_DIR_MODE_IN);\r
 303         GPIOIntTypeSet( GPIO_PORTC_BASE, mainPUSH_BUTTON,GPIO_FALLING_EDGE );\r
 304         IntPrioritySet( INT_GPIOC, configKERNEL_INTERRUPT_PRIORITY );\r
 305         GPIOPinIntEnable( GPIO_PORTC_BASE, mainPUSH_BUTTON );\r
 306         IntEnable( INT_GPIOC );\r
 307 \r
 308 \r
 309 \r
 310         /* Enable the UART.  */\r
 311         SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);\r
 312         SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);\r
 313 \r
 314         /* Set GPIO A0 and A1 as peripheral function.  They are used to output the\r
 315         UART signals. */\r
 316         GPIODirModeSet( GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1, GPIO_DIR_MODE_HW );\r
 317 \r
 318         /* Configure the UART for 8-N-1 operation. */\r
 319         UARTConfigSetExpClk( UART0_BASE, SysCtlClockGet(), mainBAUD_RATE, UART_CONFIG_WLEN_8 | UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE );\r
 320 \r
 321         /* We don't want to use the fifo.  This is for test purposes to generate\r
 322         as many interrupts as possible. */\r
 323         HWREG( UART0_BASE + UART_O_LCR_H ) &= ~mainFIFO_SET;\r
 324 \r
 325         /* Enable Tx interrupts. */\r
 326         HWREG( UART0_BASE + UART_O_IM ) |= UART_INT_TX;\r
 327         IntPrioritySet( INT_UART0, configKERNEL_INTERRUPT_PRIORITY );\r
 328         IntEnable( INT_UART0 );\r
 329 \r
 330 \r
 331         /* Initialise the LCD> */\r
 332     OSRAMInit( false );\r
 333     OSRAMStringDraw("www.FreeRTOS.org", 0, 0);\r
 334         OSRAMStringDraw("LM3S811 demo", 16, 1);\r
 335 }\r
 336 /*-----------------------------------------------------------*/\r
 337 \r
 338 static void vButtonHandlerTask( void *pvParameters )\r
 339 {\r
 340 const char *pcInterruptMessage = "Int";\r
 341 \r
 342         for( ;; )\r
 343         {\r
 344                 /* Wait for a GPIO interrupt to wake this task. */\r
 345                 while( xSemaphoreTake( xButtonSemaphore, portMAX_DELAY ) != pdPASS );\r
 346 \r
 347                 /* Start the Tx of the message on the UART. */\r
 348                 UARTIntDisable( UART0_BASE, UART_INT_TX );\r
 349                 {\r
 350                         pcNextChar = cMessage;\r
 351 \r
 352                         /* Send the first character. */\r
 353                         if( !( HWREG( UART0_BASE + UART_O_FR ) & UART_FR_TXFF ) )\r
 354                         {\r
 355                                 HWREG( UART0_BASE + UART_O_DR ) = *pcNextChar;\r
 356                         }\r
 357 \r
 358                         pcNextChar++;\r
 359                 }\r
 360                 UARTIntEnable(UART0_BASE, UART_INT_TX);\r
 361 \r
 362                 /* Queue a message for the print task to display on the LCD. */\r
 363                 xQueueSend( xPrintQueue, &pcInterruptMessage, portMAX_DELAY );\r
 364 \r
 365                 /* Make sure we don't process bounces. */\r
 366                 vTaskDelay( mainDEBOUNCE_DELAY );\r
 367                 xSemaphoreTake( xButtonSemaphore, mainNO_DELAY );\r
 368         }\r
 369 }\r
 370 \r
 371 /*-----------------------------------------------------------*/\r
 372 \r
 373 void vUART_ISR(void)\r
 374 {\r
 375 unsigned long ulStatus;\r
 376 \r
 377         /* What caused the interrupt. */\r
 378         ulStatus = UARTIntStatus( UART0_BASE, pdTRUE );\r
 379 \r
 380         /* Clear the interrupt. */\r
 381         UARTIntClear( UART0_BASE, ulStatus );\r
 382 \r
 383         /* Was a Tx interrupt pending? */\r
 384         if( ulStatus & UART_INT_TX )\r
 385         {\r
 386                 /* Send the next character in the string.  We are not using the FIFO. */\r
 387                 if( *pcNextChar != NULL )\r
 388                 {\r
 389                         if( !( HWREG( UART0_BASE + UART_O_FR ) & UART_FR_TXFF ) )\r
 390                         {\r
 391                                 HWREG( UART0_BASE + UART_O_DR ) = *pcNextChar;\r
 392                         }\r
 393                         pcNextChar++;\r
 394                 }\r
 395         }\r
 396 }\r
 397 /*-----------------------------------------------------------*/\r
 398 \r
 399 void vGPIO_ISR( void )\r
 400 {\r
 401 portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
 402 \r
 403         /* Clear the interrupt. */\r
 404         GPIOPinIntClear( GPIO_PORTC_BASE, mainPUSH_BUTTON );\r
 405 \r
 406         /* Wake the button handler task. */\r
 407         xSemaphoreGiveFromISR( xButtonSemaphore, &xHigherPriorityTaskWoken );\r
 408         portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );\r
 409 }\r
 410 /*-----------------------------------------------------------*/\r
 411 \r
 412 static void vPrintTask( void *pvParameters )\r
 413 {\r
 414 char *pcMessage;\r
 415 unsigned portBASE_TYPE uxLine = 0, uxRow = 0;\r
 416 \r
 417         for( ;; )\r
 418         {\r
 419                 /* Wait for a message to arrive. */\r
 420                 xQueueReceive( xPrintQueue, &pcMessage, portMAX_DELAY );\r
 421 \r
 422                 /* Write the message to the LCD. */\r
 423                 uxRow++;\r
 424                 uxLine++;\r
 425                 OSRAMClear();\r
 426                 OSRAMStringDraw( pcMessage, uxLine & 0x3f, uxRow & 0x01);\r
 427         }\r
 428 }\r
 429 \r