[freertos] / FreeRTOS / Demo / CORTEX_LM3S316_IAR / main.c

/*\r
 * FreeRTOS Kernel V10.1.0\r
 * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
 *\r
 * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
 * this software and associated documentation files (the "Software"), to deal in\r
 * the Software without restriction, including without limitation the rights to\r
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
 * the Software, and to permit persons to whom the Software is furnished to do so,\r
 * subject to the following conditions:\r
 *\r
 * The above copyright notice and this permission notice shall be included in all\r
 * copies or substantial portions of the Software.\r
 *\r
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
 *\r
 * http://www.FreeRTOS.org\r
 * http://aws.amazon.com/freertos\r
 *\r
 * 1 tab == 4 spaces!\r
 */\r
\r
/* \r
 * This demo application creates eight co-routines and four tasks (five \r
 * including the idle task).  The co-routines execute as part of the idle task \r
 * hook.  The application is limited in size to allow its compilation using\r
 * the KickStart version of the IAR compiler.\r
 *\r
 * Six of the created co-routines are the standard 'co-routine flash' \r
 * co-routines contained within the Demo/Common/Minimal/crflash.c file and \r
 * documented on the FreeRTOS.org WEB site.  \r
 *\r
 * The 'LCD Task' waits on a message queue for messages informing it what and\r
 * where to display text.  This is the only task that accesses the LCD\r
 * so mutual exclusion is guaranteed.\r
 *\r
 * The 'LCD Message Task' periodically sends strings to the LCD Task using\r
 * the message queue.  The strings are rotated to form a short message and\r
 * are written to the top row of the LCD.\r
 *\r
 * The 'ADC Co-routine' periodically reads the ADC input that is connected to\r
 * the light sensor, forms a short message from the value, and then sends this\r
 * message to the LCD Task using the same message queue.  The ADC readings are\r
 * displayed on the bottom row of the LCD.  \r
 *\r
 * The eighth co-routine and final task control the transmission and reception\r
 * of a string to UART 0.  The co-routine periodically sends the first \r
 * character of the string to the UART, with the UART's TxEnd interrupt being\r
 * used to transmit the remaining characters.  The UART's RxEnd interrupt \r
 * receives the characters and places them on a queue to be processed by the \r
 * 'COMs Rx' task.  An error is latched should an unexpected character be \r
 * received, or any character be received out of sequence.  \r
 *\r
 * A loopback connector is required to ensure that each character transmitted \r
 * on the UART is also received on the same UART.  For test purposes the UART\r
 * FIFO's are not utalised in order to maximise the interrupt overhead.  Also\r
 * a pseudo random interval is used between the start of each transmission in \r
 * order that the resultant interrupts are more randomly distributed and \r
 * therefore more likely to highlight any problems.\r
 *\r
 * The flash co-routines control LED's zero to four.  LED five is toggled each\r
 * time the string is transmitted on the UART.  LED six is toggled each time\r
 * the string is CORRECTLY received on the UART.  LED seven is latched on \r
 * should an error be detected in any task or co-routine.\r
 *\r
 * In addition the idle task makes repetitive calls to \r
 * vSetAndCheckRegisters().  This simply loads the general purpose registers \r
 * with a known value, then checks each register to ensure the held value is \r
 * still correct.  As a low priority task this checking routine is likely to \r
 * get repeatedly swapped in and out.  A register being found to contain an \r
 * incorrect value is therefore indicative of an error in the task switching \r
 * mechanism.\r
 *\r
 */\r
\r
/* standard include files. */\r
#include <stdio.h>\r
\r
/* Scheduler include files. */\r
#include "FreeRTOS.h"\r
#include "task.h"\r
#include "queue.h"\r
#include "croutine.h"\r
\r
/* Demo application include files. */\r
#include "partest.h"\r
#include "crflash.h"\r
#include "commstest.h"\r
\r
/* Library include files. */\r
#include "DriverLib.h"\r
\r
/* The time to delay between writing each character to the LCD. */\r
#define mainCHAR_WRITE_DELAY            ( 2 / portTICK_PERIOD_MS )\r
\r
/* The time to delay between writing each string to the LCD. */\r
#define mainSTRING_WRITE_DELAY          ( 400 / portTICK_PERIOD_MS )\r
\r
#define mainADC_DELAY                           ( 200 / portTICK_PERIOD_MS )\r
\r
/* The number of flash co-routines to create. */\r
#define mainNUM_FLASH_CO_ROUTINES       ( 5 )\r
\r
/* The length of the queue used to send messages to the LCD task. */\r
#define mainLCD_QUEUE_LEN                       ( 3 )\r
\r
/* The priority of the co-routine used to initiate the transmission of the \r
string on UART 0. */\r
#define mainTX_CO_ROUTINE_PRIORITY      ( 1 )\r
#define mainADC_CO_ROUTINE_PRIORITY     ( 2 )\r
\r
/* Only one of each co-routine is created so its index is not important. */\r
#define mainTX_CO_ROUTINE_INDEX         ( 0 )\r
#define mainADC_CO_ROUTINE_INDEX        ( 0 )\r
\r
/* The task priorities. */\r
#define mainLCD_TASK_PRIORITY           ( tskIDLE_PRIORITY + 1 )\r
#define mainMSG_TASK_PRIORITY           ( mainLCD_TASK_PRIORITY - 1 )\r
#define mainCOMMS_RX_TASK_PRIORITY      ( tskIDLE_PRIORITY + 1 )\r
\r
/* The LCD had two rows. */\r
#define mainTOP_ROW             0\r
#define mainBOTTOM_ROW  1\r
\r
/* Dimension for the buffer into which the ADC value string is written. */\r
#define mainMAX_ADC_STRING_LEN  20\r
\r
/* The LED that is lit should an error be detected in any of the tasks or\r
co-routines. */\r
#define mainFAIL_LED                    ( 7 )\r
\r
/*-----------------------------------------------------------*/\r
\r
/*\r
 * The task that displays text on the LCD.\r
 */\r
static void prvLCDTask( void * pvParameters );\r
\r
/*\r
 * The task that sends messages to be displayed on the top row of the LCD.\r
 */\r
static void prvLCDMessageTask( void * pvParameters );\r
\r
/*\r
 * The co-routine that reads the ADC and sends messages for display on the\r
 * bottom row of the LCD.\r
 */\r
static void prvADCCoRoutine( CoRoutineHandle_t xHandle, unsigned portBASE_TYPE uxIndex );\r
\r
/*\r
 * Function to simply set a known value into the general purpose registers\r
 * then read them back to ensure they remain set correctly.  An incorrect value\r
 * being indicative of an error in the task switching mechanism.\r
 */\r
extern void vSetAndCheckRegisters( void );\r
\r
/*\r
 * Latch the LED that indicates that an error has occurred. \r
 */\r
void vSetErrorLED( void );\r
\r
/*\r
 * Thread safe write to the PDC.\r
 */\r
static void prvPDCWrite( char cAddress, char cData );\r
\r
/*\r
 * Sets up the hardware used by the demo.\r
 */\r
static void prvSetupHardware( void );\r
\r
\r
/*-----------------------------------------------------------*/\r
\r
/* The structure that is passed on the LCD message queue. */\r
typedef struct\r
{\r
        char **ppcMessageToDisplay; /*<< Points to a char* pointing to the message to display. */\r
        portBASE_TYPE xRow;                             /*<< The row on which the message should be displayed. */\r
} xLCDMessage;\r
\r
/* Error flag set to pdFAIL if an error is encountered in the tasks/co-routines\r
defined within this file. */\r
unsigned portBASE_TYPE uxErrorStatus = pdPASS;\r
\r
/* The queue used to transmit messages to the LCD task. */\r
static QueueHandle_t xLCDQueue;\r
\r
/*-----------------------------------------------------------*/\r
\r
/*\r
 * Setup the hardware, create the tasks/co-routines, then start the scheduler.\r
 */\r
void main( void )\r
{\r
        /* Create the queue used by tasks wanting to write to the LCD. */\r
        xLCDQueue = xQueueCreate( mainLCD_QUEUE_LEN, sizeof( xLCDMessage ) );\r
\r
        /* Setup the ports used by the demo and the clock. */\r
        prvSetupHardware();\r
\r
        /* Create the co-routines that flash the LED's. */\r
        vStartFlashCoRoutines( mainNUM_FLASH_CO_ROUTINES );\r
\r
        /* Create the co-routine that initiates the transmission of characters\r
        on the UART and the task that receives them, as described at the top of\r
        this file. */\r
        xCoRoutineCreate( vSerialTxCoRoutine, mainTX_CO_ROUTINE_PRIORITY, mainTX_CO_ROUTINE_INDEX );\r
        xTaskCreate( vCommsRxTask, "CMS", configMINIMAL_STACK_SIZE, NULL, mainCOMMS_RX_TASK_PRIORITY, NULL );\r
\r
        /* Create the task that waits for messages to display on the LCD, plus the\r
        task and co-routine that send messages for display (as described at the top\r
        of this file. */\r
        xTaskCreate( prvLCDTask, "LCD", configMINIMAL_STACK_SIZE, ( void * ) &xLCDQueue, mainLCD_TASK_PRIORITY, NULL );\r
        xTaskCreate( prvLCDMessageTask, "MSG", configMINIMAL_STACK_SIZE, ( void * ) &xLCDQueue, mainMSG_TASK_PRIORITY, NULL );\r
        xCoRoutineCreate( prvADCCoRoutine, mainADC_CO_ROUTINE_PRIORITY, mainADC_CO_ROUTINE_INDEX );\r
\r
        /* Start the scheduler running the tasks and co-routines just created. */\r
        vTaskStartScheduler();\r
\r
        /* Should not get here unless we did not have enough memory to start the\r
        scheduler. */\r
        for( ;; );\r
}\r
/*-----------------------------------------------------------*/\r
\r
static void prvLCDMessageTask( void * pvParameters )\r
{\r
/* The strings that are written to the LCD. */\r
char *pcStringsToDisplay[] = {                                                                          \r
                                                                        "IAR             ",\r
                                                                        "Stellaris       ",\r
                                                                        "Demo            ",\r
                                                                        "www.FreeRTOS.org",\r
                                                                        ""\r
                                                                };\r
\r
QueueHandle_t *pxLCDQueue;      \r
xLCDMessage xMessageToSend;\r
portBASE_TYPE xIndex = 0;\r
\r
        /* To test the parameter passing mechanism, the queue on which messages are\r
        posted is passed in as a parameter even though it is available as a file\r
        scope variable anyway. */\r
        pxLCDQueue = ( QueueHandle_t * ) pvParameters;\r
\r
        for( ;; )\r
        {\r
                /* Wait until it is time to move onto the next string. */\r
                vTaskDelay( mainSTRING_WRITE_DELAY );           \r
                \r
                /* Create the message object to send to the LCD task. */\r
                xMessageToSend.ppcMessageToDisplay = &pcStringsToDisplay[ xIndex ];\r
                xMessageToSend.xRow = mainTOP_ROW;\r
                \r
                /* Post the message to be displayed. */\r
                if( !xQueueSend( *pxLCDQueue, ( void * ) &xMessageToSend, 0 ) )\r
                {\r
                        uxErrorStatus = pdFAIL;\r
                }\r
                \r
                /* Move onto the next message, wrapping when necessary. */\r
                xIndex++;               \r
                if( *( pcStringsToDisplay[ xIndex ] ) == 0x00 )\r
                {\r
                        xIndex = 0;\r
\r
                        /* Delay longer before going back to the start of the messages. */\r
                        vTaskDelay( mainSTRING_WRITE_DELAY * 2 );\r
                }\r
        }\r
}\r
/*-----------------------------------------------------------*/\r
\r
void prvLCDTask( void * pvParameters )\r
{\r
unsigned portBASE_TYPE uxIndex;\r
QueueHandle_t *pxLCDQueue;\r
xLCDMessage xReceivedMessage;\r
char *pcString;\r
const unsigned char ucCFGData[] = {     \r
                                                                                        0x30,   /* Set data bus to 8-bits. */\r
                                                                                        0x30,\r
                                                                                        0x30,\r
                                                                                        0x3C,   /* Number of lines/font. */\r
                                                                                        0x08,   /* Display off. */\r
                                                                                        0x01,   /* Display clear. */\r
                                                                                        0x06,   /* Entry mode [cursor dir][shift]. */\r
                                                                                        0x0C    /* Display on [display on][curson on][blinking on]. */\r
                                                                          };  \r
\r
        /* To test the parameter passing mechanism, the queue on which messages are\r
        received is passed in as a parameter even though it is available as a file\r
        scope variable anyway. */\r
        pxLCDQueue = ( QueueHandle_t * ) pvParameters;\r
\r
        /* Configure the LCD. */\r
        uxIndex = 0;\r
        while( uxIndex < sizeof( ucCFGData ) )\r
        {\r
                prvPDCWrite( PDC_LCD_CSR, ucCFGData[ uxIndex ] );\r
                uxIndex++;\r
                vTaskDelay( mainCHAR_WRITE_DELAY );\r
        }\r
\r
        /* Turn the LCD Backlight on. */\r
        prvPDCWrite( PDC_CSR, 0x01 );\r
\r
        /* Clear display. */\r
        vTaskDelay( mainCHAR_WRITE_DELAY );\r
        prvPDCWrite( PDC_LCD_CSR, LCD_CLEAR ); \r
\r
        uxIndex = 0;\r
        for( ;; )    \r
        {\r
                /* Wait for a message to arrive. */\r
                if( xQueueReceive( *pxLCDQueue, &xReceivedMessage, portMAX_DELAY ) )\r
                {\r
                        /* Which row does the received message say to write to? */\r
                        PDCLCDSetPos( 0, xReceivedMessage.xRow );\r
\r
                        /* Where is the string we are going to display? */\r
                        pcString = *xReceivedMessage.ppcMessageToDisplay;\r
                        \r
                        while( *pcString )\r
                        {\r
                                /* Don't write out the string too quickly as LCD's are usually \r
                                pretty slow devices. */\r
                                vTaskDelay( mainCHAR_WRITE_DELAY );\r
                                prvPDCWrite( PDC_LCD_RAM, *pcString );\r
                                pcString++;\r
                        }               \r
                }\r
        }\r
}\r
/*-----------------------------------------------------------*/\r
\r
static void prvADCCoRoutine( CoRoutineHandle_t xHandle, unsigned portBASE_TYPE uxIndex )\r
{\r
static unsigned long ulADCValue;\r
static char cMessageBuffer[ mainMAX_ADC_STRING_LEN ];\r
static char *pcMessage;\r
static xLCDMessage xMessageToSend;\r
\r
        /* Co-routines MUST start with a call to crSTART(). */\r
        crSTART( xHandle );\r
        \r
        for( ;; )\r
        {\r
                /* Start an ADC conversion. */\r
                ADCProcessorTrigger( ADC_BASE, 0 );\r
                \r
                /* Simply delay - when we unblock the result should be available */     \r
                crDELAY( xHandle, mainADC_DELAY );\r
                \r
                /* Get the ADC result. */\r
                ADCSequenceDataGet( ADC_BASE, 0, &ulADCValue );\r
\r
                /* Create a string with the result. */          \r
                sprintf( cMessageBuffer, "ADC = %d   ", ulADCValue );\r
                pcMessage = cMessageBuffer;\r
\r
                /* Configure the message we are going to send for display. */\r
                xMessageToSend.ppcMessageToDisplay = ( char** ) &pcMessage;\r
                xMessageToSend.xRow = mainBOTTOM_ROW;\r
                \r
                /* Send the string to the LCD task for display.  We are sending\r
                on a task queue so do not have the option to block. */\r
                if( !xQueueSend( xLCDQueue, ( void * ) &xMessageToSend, 0 ) )\r
                {\r
                        uxErrorStatus = pdFAIL;\r
                }               \r
        }\r
        \r
        /* Co-routines MUST end with a call to crEND(). */\r
        crEND();\r
}\r
/*-----------------------------------------------------------*/\r
\r
static void prvSetupHardware( void )\r
{\r
        /* Setup the PLL. */\r
        SysCtlClockSet( SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_6MHZ );\r
        \r
        /* Initialise the hardware used to talk to the LCD, LED's and UART. */\r
        PDCInit();\r
        vParTestInitialise();\r
        vSerialInit();\r
\r
        /* The ADC is used to read the light sensor. */\r
        SysCtlPeripheralEnable( SYSCTL_PERIPH_ADC );\r
    ADCSequenceConfigure( ADC_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);\r
    ADCSequenceStepConfigure( ADC_BASE, 0, 0, ADC_CTL_CH0 | ADC_CTL_END );\r
    ADCSequenceEnable( ADC_BASE, 0 );\r
\r
}\r
/*-----------------------------------------------------------*/\r
\r
static void prvPDCWrite( char cAddress, char cData )\r
{\r
        vTaskSuspendAll();\r
        {\r
                PDCWrite( cAddress, cData );\r
        }\r
        xTaskResumeAll();\r
}\r
/*-----------------------------------------------------------*/\r
\r
void vSetErrorLED( void )\r
{\r
        vParTestSetLED( mainFAIL_LED, pdTRUE );\r
}\r
/*-----------------------------------------------------------*/\r
\r
void vApplicationIdleHook( void )\r
{\r
        /* The co-routines are executed in the idle task using the idle task \r
        hook. */\r
        for( ;; )\r
        {\r
                /* Schedule the co-routines. */\r
                vCoRoutineSchedule();\r
\r
                /* Run the register check function between each co-routine. */\r
                vSetAndCheckRegisters();\r
                \r
                /* See if the comms task and co-routine has found any errors. */\r
                if( uxGetCommsStatus() != pdPASS )\r
                {\r
                        vParTestSetLED( mainFAIL_LED, pdTRUE );\r
                }\r
        }\r
}\r
/*-----------------------------------------------------------*/\r