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

   1 /*\r
   2     FreeRTOS V6.1.0 - Copyright (C) 2010 Real Time Engineers Ltd.\r
   3 \r
   4     ***************************************************************************\r
   5     *                                                                         *\r
   6     * If you are:                                                             *\r
   7     *                                                                         *\r
   8     *    + New to FreeRTOS,                                                   *\r
   9     *    + Wanting to learn FreeRTOS or multitasking in general quickly       *\r
  10     *    + Looking for basic training,                                        *\r
  11     *    + Wanting to improve your FreeRTOS skills and productivity           *\r
  12     *                                                                         *\r
  13     * then take a look at the FreeRTOS books - available as PDF or paperback  *\r
  14     *                                                                         *\r
  15     *        "Using the FreeRTOS Real Time Kernel - a Practical Guide"        *\r
  16     *                  http://www.FreeRTOS.org/Documentation                  *\r
  17     *                                                                         *\r
  18     * A pdf reference manual is also available.  Both are usually delivered   *\r
  19     * to your inbox within 20 minutes to two hours when purchased between 8am *\r
  20     * and 8pm GMT (although please allow up to 24 hours in case of            *\r
  21     * exceptional circumstances).  Thank you for your support!                *\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 exception to the GPL is included to allow you to distribute\r
  31     a combined work that includes FreeRTOS without being obliged to provide the\r
  32     source code for proprietary components outside of the FreeRTOS kernel.\r
  33     FreeRTOS is distributed in the hope that it will be useful, but WITHOUT\r
  34     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
  35     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 /* Standard includes. */\r
  55 #include <stdio.h>\r
  56 \r
  57 /* Kernel includes. */\r
  58 #include "FreeRTOS.h"\r
  59 #include "task.h"\r
  60 #include "queue.h"\r
  61 \r
  62 /* Demo application includes. */\r
  63 #include "partest.h"\r
  64 #include "flash.h"\r
  65 #include "dynamic.h"\r
  66 #include "comtest2.h"\r
  67 \r
  68 /* ST driver includes. */\r
  69 #include "stm32l1xx_usart.h"\r
  70 \r
  71 /* Eval board includes. */\r
  72 #include "stm32_eval.h"\r
  73 #include "stm32l152_eval_lcd.h"\r
  74 \r
  75 #define mainFLASH_TASK_PRIORITY                 ( tskIDLE_PRIORITY + 1 )\r
  76 #define mainLCD_TASK_PRIORITY                   ( tskIDLE_PRIORITY + 1 )\r
  77 #define mainCOM_TEST_PRIORITY                   ( tskIDLE_PRIORITY + 2 )\r
  78 \r
  79 #define mainLCD_TASK_STACK_SIZE                 ( configMINIMAL_STACK_SIZE * 2 )\r
  80 \r
  81 #define mainQUEUE_LENGTH                                ( 5 )\r
  82 \r
  83 #define mainMESSAGE_BUTTON_UP                   ( 1 )\r
  84 #define mainMESSAGE_BUTTON_DOWN                 ( 2 )\r
  85 #define mainMESSAGE_BUTTON_LEFT                 ( 3 )\r
  86 #define mainMESSAGE_BUTTON_RIGHT                ( 4 )\r
  87 #define mainMESSAGE_BUTTON_SEL                  ( 5 )\r
  88 #define mainMESSAGE_STATUS                              ( 6 )\r
  89 \r
  90 /* Baud rate used by the comtest tasks. */\r
  91 #define mainCOM_TEST_BAUD_RATE          ( 9600 )\r
  92 \r
  93 /* The LED used by the comtest tasks. See the comtest.c file for more\r
  94 information. */\r
  95 #define mainCOM_TEST_LED                        ( 3 )\r
  96 \r
  97 \r
  98 /*\r
  99  * System configuration is performed prior to main() being called, this function\r
 100  * configures the peripherals used by the demo application.\r
 101  */\r
 102 static void prvSetupHardware( void );\r
 103 static void prvLCDTask( void *pvParameters );\r
 104 static void vTempTask( void *pv );\r
 105 \r
 106 unsigned long ulTIM6_OverflowCount = 0UL;\r
 107 \r
 108 static xQueueHandle xLCDQueue = NULL;\r
 109 \r
 110 typedef struct\r
 111 {\r
 112         char cMessageID;\r
 113         long lMessageValue;\r
 114 } xQueueMessage;\r
 115 \r
 116 void main( void )\r
 117 {\r
 118         prvSetupHardware();\r
 119         \r
 120         /* Create the queue used by tasks and interrupts to send strings to the LCD\r
 121         task. */\r
 122         xLCDQueue = xQueueCreate( mainQUEUE_LENGTH, sizeof( xQueueMessage ) );\r
 123         \r
 124         if( xLCDQueue != NULL )\r
 125         {\r
 126                 vQueueAddToRegistry( xLCDQueue, "LCDQueue" );\r
 127                 xTaskCreate( prvLCDTask, ( signed char * ) "LCD", mainLCD_TASK_STACK_SIZE, NULL, mainLCD_TASK_PRIORITY, NULL );\r
 128                 xTaskCreate( vTempTask, ( signed char * ) "Temp", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );\r
 129                 vStartDynamicPriorityTasks();\r
 130                 vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY );\r
 131                 vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED );\r
 132                 \r
 133                 vTaskStartScheduler();\r
 134         }\r
 135         \r
 136         for( ;; );\r
 137 }\r
 138 /*-----------------------------------------------------------*/\r
 139 \r
 140 static void prvLCDTask( void *pvParameters )\r
 141 {\r
 142 xQueueMessage xReceivedMessage;\r
 143 long lLine = Line1;\r
 144 const long lFontHeight = (((sFONT *)LCD_GetFont())->Height);\r
 145 static char cBuffer[ 256 ];\r
 146 \r
 147         /* This function is the only function that uses printf().  If printf() is\r
 148         used from any other function then some sort of mutual exclusion on stdout\r
 149         will be necessary. */\r
 150 \r
 151         printf( "%d bytes of heap space remain unallocated\n", xPortGetFreeHeapSize() );\r
 152 \r
 153         for( ;; )\r
 154         {\r
 155                 xQueueReceive( xLCDQueue, &xReceivedMessage, portMAX_DELAY );\r
 156 \r
 157                 if( lLine > Line9 )\r
 158                 {\r
 159                         LCD_Clear( Blue );\r
 160                         lLine = 0;\r
 161                 }\r
 162                                 \r
 163                 switch( xReceivedMessage.cMessageID )\r
 164                 {\r
 165                         case mainMESSAGE_BUTTON_UP              :       sprintf( cBuffer, "Button up = %d", xReceivedMessage.lMessageValue );\r
 166                                                                                                 break;\r
 167                         case mainMESSAGE_BUTTON_DOWN    :       sprintf( cBuffer, "Button down = %d", xReceivedMessage.lMessageValue );\r
 168                                                                                                 break;\r
 169                         case mainMESSAGE_BUTTON_LEFT    :       sprintf( cBuffer, "Button left = %d", xReceivedMessage.lMessageValue );\r
 170                                                                                                 break;\r
 171                         case mainMESSAGE_BUTTON_RIGHT   :       sprintf( cBuffer, "Button right = %d", xReceivedMessage.lMessageValue );\r
 172                                                                                                 break;\r
 173                         case mainMESSAGE_BUTTON_SEL             :       printf( "\nTask\t     Abs Time\t     %%Time\n*****************************************" );\r
 174                                                                                                 vTaskGetRunTimeStats( ( signed char * ) cBuffer );\r
 175                                                                                                 printf( cBuffer );\r
 176                                                                                                 \r
 177                                                                                                 /* The select button passes its\r
 178                                                                                                 own string to print out. */\r
 179                                                                                                 sprintf( cBuffer, "%s", ( char * ) xReceivedMessage.lMessageValue );\r
 180                                                                                                 break;\r
 181                         case mainMESSAGE_STATUS                 :       sprintf( cBuffer, "Task status = %s", ( ( xReceivedMessage.lMessageValue ) ? "PASS" : "FAIL" ) );\r
 182                                                                                                 break;\r
 183                         default                                                 :       sprintf( cBuffer, "Unknown message" );\r
 184                                                                                                 break;\r
 185                 }\r
 186                 \r
 187                 LCD_DisplayStringLine( lLine, ( uint8_t * ) cBuffer );\r
 188                 lLine += lFontHeight;\r
 189         }\r
 190 }\r
 191 /*-----------------------------------------------------------*/\r
 192 \r
 193 void EXTI9_5_IRQHandler( void )\r
 194 {\r
 195 const xQueueMessage xMessage = { mainMESSAGE_BUTTON_SEL, ( unsigned long ) "Select Interrupt!" };\r
 196 long lHigherPriorityTaskWoken = pdFALSE;\r
 197 \r
 198         xQueueSendFromISR( xLCDQueue, &xMessage, &lHigherPriorityTaskWoken );\r
 199         EXTI_ClearITPendingBit( SEL_BUTTON_EXTI_LINE );\r
 200         portEND_SWITCHING_ISR( lHigherPriorityTaskWoken );\r
 201 }\r
 202 /*-----------------------------------------------------------*/\r
 203 \r
 204 void vApplicationTickHook( void )\r
 205 {\r
 206 static unsigned long ulCounter = 0;\r
 207 static const unsigned long ulCheckFrequency = 5000UL / portTICK_RATE_MS;\r
 208 static xQueueMessage xStatusMessage = { mainMESSAGE_STATUS, pdPASS };\r
 209 long lHigherPriorityTaskWoken = pdFALSE; /* Not used in this case as this is the tick hook. */\r
 210 \r
 211         ulCounter++;\r
 212         if( ulCounter >= ulCheckFrequency )\r
 213         {\r
 214                 if( xAreDynamicPriorityTasksStillRunning() != pdPASS )\r
 215                 {\r
 216                         xStatusMessage.lMessageValue = pdFAIL;\r
 217                 }\r
 218                 \r
 219                 if( xAreComTestTasksStillRunning() != pdPASS )\r
 220                 {\r
 221                         xStatusMessage.lMessageValue = pdFAIL;\r
 222                 }\r
 223                 \r
 224                 xQueueSendFromISR( xLCDQueue, &xStatusMessage, &lHigherPriorityTaskWoken );\r
 225                 ulCounter = 0;\r
 226         }\r
 227 }\r
 228 /*-----------------------------------------------------------*/\r
 229 \r
 230 static void vTempTask( void *pv )\r
 231 {\r
 232 long lLastState = pdTRUE;\r
 233 long lState;\r
 234 xQueueMessage xMessage;\r
 235 \r
 236         for( ;; )\r
 237         {\r
 238                 lState = STM_EVAL_PBGetState( BUTTON_UP );\r
 239                 if( lState != lLastState )\r
 240                 {\r
 241                         xMessage.cMessageID = mainMESSAGE_BUTTON_UP;\r
 242                         xMessage.lMessageValue = lState;\r
 243                         lLastState = lState;\r
 244                         xQueueSend( xLCDQueue, &xMessage, portMAX_DELAY );\r
 245                         vTaskDelay( 10 );\r
 246                 }\r
 247         }\r
 248 }\r
 249 /*-----------------------------------------------------------*/\r
 250 \r
 251 static void prvSetupHardware( void )\r
 252 {\r
 253         NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );\r
 254         \r
 255         /* Initialise the LEDs. */\r
 256         vParTestInitialise();\r
 257 \r
 258         /* Initialise the joystick inputs. */\r
 259         STM_EVAL_PBInit( BUTTON_UP, BUTTON_MODE_GPIO );\r
 260         STM_EVAL_PBInit( BUTTON_DOWN, BUTTON_MODE_GPIO );\r
 261         STM_EVAL_PBInit( BUTTON_LEFT, BUTTON_MODE_GPIO );\r
 262         STM_EVAL_PBInit( BUTTON_RIGHT, BUTTON_MODE_GPIO );\r
 263         \r
 264         /* The select button in the middle of the joystick is configured to generate\r
 265         an interrupt.  The Eval board library will configure the interrupt\r
 266         priority to be the lowest priority available - this is important as the\r
 267         interrupt service routine makes use of a FreeRTOS API function so must\r
 268         therefore use a priority equal to or below that set by the\r
 269         configMAX_SYSCALL_INTERRUPT_PRIORITY() value set in FreeRTOSConfig.h. */\r
 270         STM_EVAL_PBInit( BUTTON_SEL, BUTTON_MODE_EXTI );\r
 271 \r
 272         /* Initialize the LCD */\r
 273         STM32L152_LCD_Init();\r
 274         \r
 275         LCD_Clear(Blue);\r
 276         LCD_SetBackColor(Blue);\r
 277         LCD_SetTextColor(White);\r
 278         LCD_DisplayStringLine(Line0, "  www.FreeRTOS.org");\r
 279 }\r
 280 /*-----------------------------------------------------------*/\r
 281 \r
 282 void vConfigureTimerForRunTimeStats( void )\r
 283 {\r
 284 TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;\r
 285 NVIC_InitTypeDef NVIC_InitStructure;\r
 286 \r
 287         /* TIM6 clock enable */\r
 288         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6, ENABLE);\r
 289 \r
 290         /* The 32MHz clock divided by 5000 should tick (very) approximately every\r
 291         150uS and overflow a 16bit timer (very) approximately every 10 seconds. */\r
 292         TIM_TimeBaseStructure.TIM_Period = 65535;\r
 293         TIM_TimeBaseStructure.TIM_Prescaler = 5000;\r
 294         TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;\r
 295         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;\r
 296         \r
 297         TIM_TimeBaseInit( TIM6, &TIM_TimeBaseStructure );\r
 298         \r
 299         /* Only interrupt on overflow events. */\r
 300         TIM6->CR1 |= TIM_CR1_URS;\r
 301         \r
 302         TIM_ITConfig( TIM6, TIM_IT_Update, ENABLE );\r
 303         \r
 304         /* Enable the TIM6 gloabal Interrupt */\r
 305         NVIC_InitStructure.NVIC_IRQChannel = TIM6_IRQn;\r
 306         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = configLIBRARY_LOWEST_INTERRUPT_PRIORITY;\r
 307         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00; /* Not used as 4 bits are used for the pre-emption priority. */\r
 308         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;\r
 309         \r
 310         TIM_ClearITPendingBit( TIM6, TIM_IT_Update );\r
 311         NVIC_Init(&NVIC_InitStructure);\r
 312         TIM_Cmd( TIM6, ENABLE );\r
 313 }\r
 314 /*-----------------------------------------------------------*/\r
 315 \r
 316 void TIM6_IRQHandler( void )\r
 317 {\r
 318         if( TIM_GetITStatus( TIM6, TIM_IT_Update) != RESET)\r
 319         {\r
 320                 ulTIM6_OverflowCount++;\r
 321                 TIM_ClearITPendingBit( TIM6, TIM_IT_Update );\r
 322         }\r
 323 }\r
 324 /*-----------------------------------------------------------*/\r
 325 \r
 326 void vApplicationStackOverflowHook( xTaskHandle *pxTask, signed char *pcTaskName )\r
 327 {\r
 328         ( void ) pcTaskName;\r
 329         ( void ) pxTask;\r
 330         \r
 331         for( ;; );\r
 332 }\r
 333 \r
 334 \r
 335 \r