FreeRTOS-Kernel/FreeRTOS/Demo/CORTEX_STM32L152_IAR/main.c

/*
 * FreeRTOS V202212.00
 * Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * https://www.FreeRTOS.org
 * https://github.com/FreeRTOS
 *
 */

/*
 * The documentation page for this demo available on http://www.FreeRTOS.org
 * documents the hardware configuration required to run this demo.  It also
 * provides more information on the expected demo application behaviour.
 *
 * main() creates all the demo application tasks, then starts the scheduler.
 * A lot of the created tasks are from the pool of "standard demo" tasks.  The
 * web documentation provides more details of the standard demo tasks, which
 * provide no particular functionality but do provide good examples of how to
 * use the FreeRTOS API.
 *
 * In addition to the standard demo tasks, the following tasks, interrupts and
 * tests are defined and/or created within this file:
 *
 * "LCD" task - The LCD task is a 'gatekeeper' task.  It is the only task that
 * is permitted to access the LCD and therefore ensures access to the LCD is
 * always serialised and there are no mutual exclusion issues.  When a task or
 * an interrupt wants to write to the LCD, it does not access the LCD directly
 * but instead sends the message to the LCD task.  The LCD task then performs
 * the actual LCD output.  This mechanism also allows interrupts to, in effect,
 * write to the LCD by sending messages to the LCD task.
 *
 * The LCD task is also a demonstration of a 'controller' task design pattern.
 * Some tasks do not actually send a string to the LCD task directly, but
 * instead send a command that is interpreted by the LCD task.  In a normal
 * application these commands can be control values or set points, in this
 * simple example the commands just result in messages being displayed on the
 * LCD.
 *
 * "Button Poll" task - This task polls the state of the 'up' key on the
 * joystick input device.  It uses the vTaskDelay() API function to control
 * the poll rate to ensure debouncing is not necessary and that the task does
 * not use all the available CPU processing time.
 *
 * Button Interrupt and run time stats display - The select button on the
 * joystick input device is configured to generate an external interrupt.  The
 * handler for this interrupt sends a message to LCD task, which interprets the
 * message to mean, firstly write a message to the LCD, and secondly, generate
 * a table of run time statistics.  The run time statistics are displayed as a
 * table that contains information on how much processing time each task has
 * been allocated since the application started to execute.  This information
 * is provided both as an absolute time, and as a percentage of the total run
 * time.  The information is displayed in the terminal IO window of the IAR
 * embedded workbench.  The online documentation for this demo shows a screen
 * shot demonstrating where the run time stats can be viewed.
 *
 * Idle Hook - The idle hook is a function that is called on each iteration of
 * the idle task.  In this case it is used to place the processor into a low
 * power mode.  Note however that this application is implemented using standard
 * components, and is therefore not optimised for low power operation.  Lower
 * power consumption would be achieved by converting polling tasks into event
 * driven tasks, and slowing the tick interrupt frequency.
 *
 * "Check" function called from the tick hook - The tick hook is called during
 * each tick interrupt.  It is called from an interrupt context so must execute
 * quickly, not attempt to block, and not call any FreeRTOS API functions that
 * do not end in "FromISR".  In this case the tick hook executes a 'check'
 * function.  This only executes every five seconds.  Its main function is to
 * check that all the standard demo tasks are still operational.  Each time it
 * executes it sends a status code to the LCD task.  The LCD task interprets the
 * code and displays an appropriate message - which will be PASS if no tasks
 * have reported any errors, or a message stating which task has reported an
 * error.
 */

/* Standard includes. */
#include <stdio.h>

/* Kernel includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"

/* Demo application includes. */
#include "partest.h"
#include "flash.h"
#include "dynamic.h"
#include "comtest2.h"
#include "GenQTest.h"

/* Eval board includes. */
#include "stm32_eval.h"
#include "stm32l152_eval_lcd.h"

/* The priorities assigned to the tasks. */
#define mainFLASH_TASK_PRIORITY            ( tskIDLE_PRIORITY + 1 )
#define mainLCD_TASK_PRIORITY              ( tskIDLE_PRIORITY + 1 )
#define mainCOM_TEST_PRIORITY              ( tskIDLE_PRIORITY + 2 )
#define mainGENERIC_QUEUE_TEST_PRIORITY    ( tskIDLE_PRIORITY )

/* The length of the queue (the number of items the queue can hold) that is used
 * to send messages from tasks and interrupts the the LCD task. */
#define mainQUEUE_LENGTH                   ( 5 )

/* Codes sent within messages to the LCD task so the LCD task can interpret
 * exactly what the message it just received was.  These are sent in the
 * cMessageID member of the message structure (defined below). */
#define mainMESSAGE_BUTTON_UP              ( 1 )
#define mainMESSAGE_BUTTON_SEL             ( 2 )
#define mainMESSAGE_STATUS                 ( 3 )

/* When the cMessageID member of the message sent to the LCD task is
 * mainMESSAGE_STATUS then these definitions are sent in the lMessageValue member
 * of the same message and indicate what the status actually is. */
#define mainERROR_DYNAMIC_TASKS            ( pdPASS + 1 )
#define mainERROR_COM_TEST                 ( pdPASS + 2 )
#define mainERROR_GEN_QUEUE_TEST           ( pdPASS + 3 )

/* Baud rate used by the comtest tasks. */
#define mainCOM_TEST_BAUD_RATE             ( 115200 )

/* The LED used by the comtest tasks. See the comtest.c file for more
 * information. */
#define mainCOM_TEST_LED                   ( 3 )

/* The LCD task uses printf() so requires more stack than most of the other
 * tasks. */
#define mainLCD_TASK_STACK_SIZE            ( configMINIMAL_STACK_SIZE * 2 )

/*-----------------------------------------------------------*/

/*
 * System configuration is performed prior to main() being called, this function
 * configures the peripherals used by the demo application.
 */
static void prvSetupHardware( void );

/*
 * Definition of the LCD/controller task described in the comments at the top
 * of this file.
 */
static void prvLCDTask( void * pvParameters );

/*
 * Definition of the button poll task described in the comments at the top of
 * this file.
 */
static void prvButtonPollTask( void * pvParameters );

/*
 * Converts a status message value into an appropriate string for display on
 * the LCD.  The string is written to pcBuffer.
 */
static void prvGenerateStatusMessage( char * pcBuffer,
                                      long lStatusValue );

/*-----------------------------------------------------------*/

/* The time base for the run time stats is generated by the 16 bit timer 6.
 * Each time the timer overflows ulTIM6_OverflowCount is incremented.  Therefore,
 * when converting the total run time to a 32 bit number, the most significant two
 * bytes are given by ulTIM6_OverflowCount and the least significant two bytes are
 * given by the current TIM6 counter value.  Care must be taken with data
 * consistency when combining the two in case a timer overflow occurs as the
 * value is being read. */
unsigned long ulTIM6_OverflowCount = 0UL;

/* The handle of the queue used to send messages from tasks and interrupts to
 * the LCD task. */
static QueueHandle_t xLCDQueue = NULL;

/* The definition of each message sent from tasks and interrupts to the LCD
 * task. */
typedef struct
{
    char cMessageID;    /* << States what the message is. */
    long lMessageValue; /* << States the message value (can be an integer, string pointer, etc. depending on the value of cMessageID). */
} xQueueMessage;

/*-----------------------------------------------------------*/

void main( void )
{
    /* Configure the peripherals used by this demo application.  This includes
     * configuring the joystick input select button to generate interrupts. */
    prvSetupHardware();

    /* Create the queue used by tasks and interrupts to send strings to the LCD
     * task. */
    xLCDQueue = xQueueCreate( mainQUEUE_LENGTH, sizeof( xQueueMessage ) );

    /* If the queue could not be created then don't create any tasks that might
     * attempt to use the queue. */
    if( xLCDQueue != NULL )
    {
        /* Add the created queue to the queue registry so it can be viewed in
         * the IAR FreeRTOS state viewer plug-in. */
        vQueueAddToRegistry( xLCDQueue, "LCDQueue" );

        /* Create the LCD and button poll tasks, as described at the top of this
         * file. */
        xTaskCreate( prvLCDTask, "LCD", mainLCD_TASK_STACK_SIZE, NULL, mainLCD_TASK_PRIORITY, NULL );
        xTaskCreate( prvButtonPollTask, "ButPoll", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );

        /* Create a subset of the standard demo tasks. */
        vStartDynamicPriorityTasks();
        vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY );
        vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED );
        vStartGenericQueueTasks( mainGENERIC_QUEUE_TEST_PRIORITY );

        /* Start the scheduler. */
        vTaskStartScheduler();
    }

    /* If all is well then this line will never be reached.  If it is reached
     * then it is likely that there was insufficient (FreeRTOS) heap memory space
     * to create the idle task.  This may have been trapped by the malloc() failed
     * hook function, if one is configured. */
    for( ; ; )
    {
    }
}
/*-----------------------------------------------------------*/

static void prvLCDTask( void * pvParameters )
{
    xQueueMessage xReceivedMessage;
    long lLine = Line1;
    const long lFontHeight = ( ( ( sFONT * ) LCD_GetFont() )->Height );

/* Buffer into which strings are formatted and placed ready for display on the
 * LCD.  Note this is a static variable to prevent it being allocated on the task
 * stack, which is too small to hold such a variable.  The stack size is configured
 * when the task is created. */
    static char cBuffer[ 512 ];

    /* This function is the only function that uses printf().  If printf() is
     * used from any other function then some sort of mutual exclusion on stdout
     * will be necessary.
     *
     * This is also the only function that is permitted to access the LCD.
     *
     * First print out the number of bytes that remain in the FreeRTOS heap.  This
     * can be viewed in the terminal IO window within the IAR Embedded Workbench. */
    printf( "%d bytes of heap space remain unallocated\n", xPortGetFreeHeapSize() );

    for( ; ; )
    {
        /* Wait for a message to be received.  Using portMAX_DELAY as the block
         * time will result in an indefinite wait provided INCLUDE_vTaskSuspend is
         * set to 1 in FreeRTOSConfig.h, therefore there is no need to check the
         * function return value and the function will only return when a value
         * has been received. */
        xQueueReceive( xLCDQueue, &xReceivedMessage, portMAX_DELAY );

        /* Clear the LCD if no room remains for any more text output. */
        if( lLine > Line9 )
        {
            LCD_Clear( Blue );
            lLine = 0;
        }

        /* What is this message?  What does it contain? */
        switch( xReceivedMessage.cMessageID )
        {
            case mainMESSAGE_BUTTON_UP: /* The button poll task has just
                                         * informed this task that the up
                                         * button on the joystick input has
                                         * been pressed or released. */
                sprintf( cBuffer, "Button up = %d", xReceivedMessage.lMessageValue );
                break;

            case mainMESSAGE_BUTTON_SEL: /* The select button interrupt
                                          * just informed this task that the
                                          * select button was pressed.
                                          * Generate a table of task run time
                                          * statistics and output this to
                                          * the terminal IO window in the IAR
                                          * embedded workbench. */
                printf( "\nTask\t     Abs Time\t     %%Time\n*****************************************" );
                vTaskGetRunTimeStats( cBuffer );
                printf( cBuffer );

                /* Also print out a message to
                 * the LCD - in this case the
                 * pointer to the string to print
                 * is sent directly in the
                 * lMessageValue member of the
                 * message.  This just demonstrates
                 * a different communication
                 * technique. */
                sprintf( cBuffer, "%s", ( char * ) xReceivedMessage.lMessageValue );
                break;

            case mainMESSAGE_STATUS: /* The tick interrupt hook
                                      * function has just informed this
                                      * task of the system status.
                                      * Generate a string in accordance
                                      * with the status value. */
                prvGenerateStatusMessage( cBuffer, xReceivedMessage.lMessageValue );
                break;

            default:
                sprintf( cBuffer, "Unknown message" );
                break;
        }

        /* Output the message that was placed into the cBuffer array within the
         * switch statement above. */
        LCD_DisplayStringLine( lLine, ( uint8_t * ) cBuffer );

        /* Move onto the next LCD line, ready for the next iteration of this
         * loop. */
        lLine += lFontHeight;
    }
}
/*-----------------------------------------------------------*/

static void prvGenerateStatusMessage( char * pcBuffer,
                                      long lStatusValue )
{
    /* Just a utility function to convert a status value into a meaningful
     * string for output onto the LCD. */
    switch( lStatusValue )
    {
        case pdPASS:
            sprintf( pcBuffer, "Task status = PASS" );
            break;

        case mainERROR_DYNAMIC_TASKS:
            sprintf( pcBuffer, "Error: Dynamic tasks" );
            break;

        case mainERROR_COM_TEST:
            sprintf( pcBuffer, "Err: loop connected?" ); /* Error in COM test - is the Loopback connector connected? */
            break;

        case mainERROR_GEN_QUEUE_TEST:
            sprintf( pcBuffer, "Error: Gen Q test" );
            break;

        default:
            sprintf( pcBuffer, "Unknown status" );
            break;
    }
}
/*-----------------------------------------------------------*/

void EXTI9_5_IRQHandler( void )
{
/* Define the message sent to the LCD task from this interrupt. */
    const xQueueMessage xMessage = { mainMESSAGE_BUTTON_SEL, ( unsigned long ) "Select Interrupt!" };
    long lHigherPriorityTaskWoken = pdFALSE;

    /* This is the interrupt handler for the joystick select button input.
     * The button has been pushed, write a message to the LCD via the LCD task. */
    xQueueSendFromISR( xLCDQueue, &xMessage, &lHigherPriorityTaskWoken );

    EXTI_ClearITPendingBit( SEL_BUTTON_EXTI_LINE );

    /* If writing to xLCDQueue caused a task to unblock, and the unblocked task
     * has a priority equal to or above the task that this interrupt interrupted,
     * then lHigherPriorityTaskWoken will have been set to pdTRUE internally within
     * xQueuesendFromISR(), and portEND_SWITCHING_ISR() will ensure that this
     * interrupt returns directly to the higher priority unblocked task. */
    portEND_SWITCHING_ISR( lHigherPriorityTaskWoken );
}
/*-----------------------------------------------------------*/

void vApplicationTickHook( void )
{
    static unsigned long ulCounter = 0;
    static const unsigned long ulCheckFrequency = 5000UL / portTICK_PERIOD_MS;
    long lHigherPriorityTaskWoken = pdFALSE;

/* Define the status message that is sent to the LCD task.  By default the
 * status is PASS. */
    static xQueueMessage xStatusMessage = { mainMESSAGE_STATUS, pdPASS };

    /* This is called from within the tick interrupt and performs the 'check'
     * functionality as described in the comments at the top of this file.
     *
     * Is it time to perform the 'check' functionality again? */
    ulCounter++;

    if( ulCounter >= ulCheckFrequency )
    {
        /* See if the standard demo tasks are executing as expected, changing
         * the message that is sent to the LCD task from PASS to an error code if
         * any tasks set reports an error. */
        if( xAreDynamicPriorityTasksStillRunning() != pdPASS )
        {
            xStatusMessage.lMessageValue = mainERROR_DYNAMIC_TASKS;
        }

        if( xAreComTestTasksStillRunning() != pdPASS )
        {
            xStatusMessage.lMessageValue = mainERROR_COM_TEST;
        }

        if( xAreGenericQueueTasksStillRunning() != pdPASS )
        {
            xStatusMessage.lMessageValue = mainERROR_GEN_QUEUE_TEST;
        }

        /* As this is the tick hook the lHigherPriorityTaskWoken parameter is not
         * needed (a context switch is going to be performed anyway), but it must
         * still be provided. */
        xQueueSendFromISR( xLCDQueue, &xStatusMessage, &lHigherPriorityTaskWoken );
        ulCounter = 0;
    }
}
/*-----------------------------------------------------------*/

static void prvButtonPollTask( void * pvParameters )
{
    long lLastState = pdTRUE;
    long lState;
    xQueueMessage xMessage;

    /* This tasks performs the button polling functionality as described at the
     * top of this file. */
    for( ; ; )
    {
        /* Check the button state. */
        lState = STM_EVAL_PBGetState( BUTTON_UP );

        if( lState != lLastState )
        {
            /* The state has changed, send a message to the LCD task. */
            xMessage.cMessageID = mainMESSAGE_BUTTON_UP;
            xMessage.lMessageValue = lState;
            lLastState = lState;
            xQueueSend( xLCDQueue, &xMessage, portMAX_DELAY );
        }

        /* Block for 10 milliseconds so this task does not utilise all the CPU
         * time and debouncing of the button is not necessary. */
        vTaskDelay( 10 / portTICK_PERIOD_MS );
    }
}
/*-----------------------------------------------------------*/

static void prvSetupHardware( void )
{
    /* Ensure that all 4 interrupt priority bits are used as the pre-emption
     * priority. */
    NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );

    /* Initialise the LEDs. */
    vParTestInitialise();

    /* Initialise the joystick inputs. */
    STM_EVAL_PBInit( BUTTON_UP, BUTTON_MODE_GPIO );
    STM_EVAL_PBInit( BUTTON_DOWN, BUTTON_MODE_GPIO );
    STM_EVAL_PBInit( BUTTON_LEFT, BUTTON_MODE_GPIO );
    STM_EVAL_PBInit( BUTTON_RIGHT, BUTTON_MODE_GPIO );

    /* The select button in the middle of the joystick is configured to generate
     * an interrupt.  The Eval board library will configure the interrupt
     * priority to be the lowest priority available so the priority need not be
     * set here explicitly.  It is important that the priority is equal to or
     * below that set by the configMAX_SYSCALL_INTERRUPT_PRIORITY value set in
     * FreeRTOSConfig.h. */
    STM_EVAL_PBInit( BUTTON_SEL, BUTTON_MODE_EXTI );

    /* Initialize the LCD */
    STM32L152_LCD_Init();
    LCD_Clear( Blue );
    LCD_SetBackColor( Blue );
    LCD_SetTextColor( White );
    LCD_DisplayStringLine( Line0, "  www.FreeRTOS.org" );
}
/*-----------------------------------------------------------*/

void vConfigureTimerForRunTimeStats( void )
{
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    /* The time base for the run time stats is generated by the 16 bit timer 6.
     * Each time the timer overflows ulTIM6_OverflowCount is incremented.
     * Therefore, when converting the total run time to a 32 bit number, the most
     * significant two bytes are given by ulTIM6_OverflowCount and the least
     * significant two bytes are given by the current TIM6 counter value.  Care
     * must be taken with data	consistency when combining the two in case a timer
     * overflow occurs as the value is being read.
     *
     * The portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() macro (in FreeRTOSConfig.h) is
     * defined to call this function, so the kernel will call this function
     * automatically at the appropriate time. */

    /* TIM6 clock enable */
    RCC_APB1PeriphClockCmd( RCC_APB1Periph_TIM6, ENABLE );

    /* The 32MHz clock divided by 5000 should tick (very) approximately every
     * 150uS and overflow a 16bit timer (very) approximately every 10 seconds. */
    TIM_TimeBaseStructure.TIM_Period = 65535;
    TIM_TimeBaseStructure.TIM_Prescaler = 5000;
    TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;

    TIM_TimeBaseInit( TIM6, &TIM_TimeBaseStructure );

    /* Only interrupt on overflow events. */
    TIM6->CR1 |= TIM_CR1_URS;

    /* Enable the interrupt. */
    TIM_ITConfig( TIM6, TIM_IT_Update, ENABLE );

    /* Enable the TIM6 global Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel = TIM6_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = configLIBRARY_LOWEST_INTERRUPT_PRIORITY;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00; /* Not used as 4 bits are used for the pre-emption priority. */
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init( &NVIC_InitStructure );

    TIM_ClearITPendingBit( TIM6, TIM_IT_Update );
    TIM_Cmd( TIM6, ENABLE );
}
/*-----------------------------------------------------------*/

void TIM6_IRQHandler( void )
{
    /* Interrupt handler for TIM 6
     *
     * The time base for the run time stats is generated by the 16 bit timer 6.
     * Each time the timer overflows ulTIM6_OverflowCount is incremented.
     * Therefore, when converting the total run time to a 32 bit number, the most
     * significant two bytes are given by ulTIM6_OverflowCount and the least
     * significant two bytes are given by the current TIM6 counter value.  Care
     * must be taken with data	consistency when combining the two in case a timer
     * overflow occurs as the value is being read. */
    if( TIM_GetITStatus( TIM6, TIM_IT_Update ) != RESET )
    {
        ulTIM6_OverflowCount++;
        TIM_ClearITPendingBit( TIM6, TIM_IT_Update );
    }
}
/*-----------------------------------------------------------*/

void vApplicationStackOverflowHook( TaskHandle_t pxTask,
                                    char * pcTaskName )
{
    ( void ) pcTaskName;
    ( void ) pxTask;

    /* Run time stack overflow checking is performed if
     * configconfigCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2.  This hook
     * function is called if a stack overflow is detected. */
    for( ; ; )
    {
    }
}
/*-----------------------------------------------------------*/

void vApplicationMallocFailedHook( void )
{
    /* Called if a call to pvPortMalloc() fails because there is insufficient
     * free memory available in the FreeRTOS heap.  pvPortMalloc() is called
     * internally by FreeRTOS API functions that create tasks, queues or
     * semaphores. */
    for( ; ; )
    {
    }
}
/*-----------------------------------------------------------*/

void vApplicationIdleHook( void )
{
    /* Called on each iteration of the idle task.  In this case the idle task
     * just enters a low(ish) power mode. */
    PWR_EnterSleepMode( PWR_Regulator_ON, PWR_SLEEPEntry_WFI );
}