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

/*\r
 * FreeRTOS Kernel V10.2.1\r
 * Copyright (C) 2019 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
/*\r
 * Creates all the demo application tasks, then starts the scheduler.  The WEB\r
 * documentation provides more details of the standard demo application tasks.\r
 * In addition to the standard demo tasks, the following tasks and tests are\r
 * defined and/or created within this file:\r
 *\r
 * "Fast Interrupt Test" - A high frequency periodic interrupt is generated\r
 * using a free running timer to demonstrate the use of the\r
 * configKERNEL_INTERRUPT_PRIORITY configuration constant.  The interrupt\r
 * service routine measures the number of processor clocks that occur between\r
 * each interrupt - and in so doing measures the jitter in the interrupt timing.\r
 * The maximum measured jitter time is latched in the ulMaxJitter variable, and\r
 * displayed on the OLED display by the 'OLED' task as described below.  The\r
 * fast interrupt is configured and handled in the timertest.c source file.\r
 *\r
 * "OLED" task - the OLED task is a 'gatekeeper' task.  It is the only task that\r
 * is permitted to access the display directly.  Other tasks wishing to write a\r
 * message to the OLED send the message on a queue to the OLED task instead of\r
 * accessing the OLED themselves.  The OLED task just blocks on the queue waiting\r
 * for messages - waking and displaying the messages as they arrive.\r
 *\r
 * "Check" hook -  This only executes every five seconds from the tick hook.\r
 * Its main function is to check that all the standard demo tasks are still\r
 * operational.  Should any unexpected behaviour within a demo task be discovered\r
 * the tick hook will write an error to the OLED (via the OLED task).  If all the\r
 * demo tasks are executing with their expected behaviour then the check task\r
 * writes PASS to the OLED (again via the OLED task), as described above.\r
 *\r
 * "uIP" task -  This is the task that handles the uIP stack.  All TCP/IP\r
 * processing is performed in this task.\r
 */\r
\r
\r
\r
\r
/*************************************************************************\r
 * Please ensure to read http://www.freertos.org/portLM3Sxxxx_Eclipse.html\r
 * which provides information on configuring and running this demo for the\r
 * various Luminary Micro EKs.\r
 *************************************************************************/\r
\r
\r
\r
\r
/* Standard includes. */\r
#include <stdio.h>\r
\r
/* Scheduler includes. */\r
#include "FreeRTOS.h"\r
#include "task.h"\r
#include "queue.h"\r
#include "semphr.h"\r
\r
/* Hardware library includes. */\r
#include "hw_memmap.h"\r
#include "hw_types.h"\r
#include "hw_sysctl.h"\r
#include "sysctl.h"\r
#include "gpio.h"\r
#include "grlib.h"\r
#include "rit128x96x4.h"\r
#include "osram128x64x4.h"\r
#include "formike128x128x16.h"\r
\r
/* Demo app includes. */\r
#include "BlockQ.h"\r
#include "death.h"\r
#include "integer.h"\r
#include "blocktim.h"\r
#include "flash.h"\r
#include "partest.h"\r
#include "semtest.h"\r
#include "PollQ.h"\r
#include "lcd_message.h"\r
#include "bitmap.h"\r
#include "GenQTest.h"\r
#include "QPeek.h"\r
#include "recmutex.h"\r
#include "IntQueue.h"\r
#include "QueueSet.h"\r
\r
/*-----------------------------------------------------------*/\r
\r
/* The time between cycles of the 'check' functionality (defined within the\r
tick hook. */\r
#define mainCHECK_DELAY                                         ( ( TickType_t ) 5000 / portTICK_PERIOD_MS )\r
\r
/* Size of the stack allocated to the uIP task. */\r
#define mainBASIC_WEB_STACK_SIZE            ( configMINIMAL_STACK_SIZE * 3 )\r
\r
/* The OLED task uses the sprintf function so requires a little more stack too. */\r
#define mainOLED_TASK_STACK_SIZE                        ( configMINIMAL_STACK_SIZE + 50 )\r
\r
/* Task priorities. */\r
#define mainQUEUE_POLL_PRIORITY                         ( tskIDLE_PRIORITY + 2 )\r
#define mainCHECK_TASK_PRIORITY                         ( tskIDLE_PRIORITY + 3 )\r
#define mainSEM_TEST_PRIORITY                           ( tskIDLE_PRIORITY + 1 )\r
#define mainBLOCK_Q_PRIORITY                            ( tskIDLE_PRIORITY + 2 )\r
#define mainCREATOR_TASK_PRIORITY           ( tskIDLE_PRIORITY + 3 )\r
#define mainINTEGER_TASK_PRIORITY           ( tskIDLE_PRIORITY )\r
#define mainGEN_QUEUE_TASK_PRIORITY                     ( tskIDLE_PRIORITY )\r
\r
/* The maximum number of message that can be waiting for display at any one\r
time. */\r
#define mainOLED_QUEUE_SIZE                                     ( 3 )\r
\r
/* Dimensions the buffer into which the jitter time is written. */\r
#define mainMAX_MSG_LEN                                         25\r
\r
/* The period of the system clock in nano seconds.  This is used to calculate\r
the jitter time in nano seconds. */\r
#define mainNS_PER_CLOCK                                        ( ( unsigned long ) ( ( 1.0 / ( double ) configCPU_CLOCK_HZ ) * 1000000000.0 ) )\r
\r
/* Constants used when writing strings to the display. */\r
#define mainCHARACTER_HEIGHT                            ( 9 )\r
#define mainMAX_ROWS_128                                        ( mainCHARACTER_HEIGHT * 14 )\r
#define mainMAX_ROWS_96                                         ( mainCHARACTER_HEIGHT * 10 )\r
#define mainMAX_ROWS_64                                         ( mainCHARACTER_HEIGHT * 7 )\r
#define mainFULL_SCALE                                          ( 15 )\r
#define ulSSI_FREQUENCY                                         ( 3500000UL )\r
\r
/*-----------------------------------------------------------*/\r
\r
/*\r
 * The task that handles the uIP stack.  All TCP/IP processing is performed in\r
 * this task.\r
 */\r
extern void vuIP_Task( void *pvParameters );\r
\r
/*\r
 * The display is written two by more than one task so is controlled by a\r
 * 'gatekeeper' task.  This is the only task that is actually permitted to\r
 * access the display directly.  Other tasks wanting to display a message send\r
 * the message to the gatekeeper.\r
 */\r
static void vOLEDTask( void *pvParameters );\r
\r
/*\r
 * Configure the hardware for the demo.\r
 */\r
static void prvSetupHardware( void );\r
\r
/*\r
 * Configures the high frequency timers - those used to measure the timing\r
 * jitter while the real time kernel is executing.\r
 */\r
extern void vSetupHighFrequencyTimer( void );\r
\r
/*\r
 * The idle hook is used to run a test of the scheduler context switch\r
 * mechanism.\r
 */\r
void vApplicationIdleHook( void ) __attribute__((naked));\r
/*-----------------------------------------------------------*/\r
\r
/* The queue used to send messages to the OLED task. */\r
QueueHandle_t xOLEDQueue;\r
\r
/* The welcome text. */\r
const char * const pcWelcomeMessage = "   www.FreeRTOS.org";\r
\r
/* Variables used to detect the test in the idle hook failing. */\r
unsigned long ulIdleError = pdFALSE;\r
\r
/*-----------------------------------------------------------*/\r
\r
/*************************************************************************\r
 * Please ensure to read http://www.freertos.org/portLM3Sxxxx_Eclipse.html\r
 * which provides information on configuring and running this demo for the\r
 * various Luminary Micro EKs.\r
 *************************************************************************/\r
int main( void )\r
{\r
        prvSetupHardware();\r
\r
        /* Create the queue used by the OLED task.  Messages for display on the OLED\r
        are received via this queue. */\r
        xOLEDQueue = xQueueCreate( mainOLED_QUEUE_SIZE, sizeof( xOLEDMessage ) );\r
\r
        /* Create the uIP task if running on a processor that includes a MAC and\r
        PHY. */\r
        if( SysCtlPeripheralPresent( SYSCTL_PERIPH_ETH ) )\r
        {\r
                xTaskCreate( vuIP_Task, "uIP", mainBASIC_WEB_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY - 1, NULL );\r
        }\r
\r
        /* Start the standard demo tasks. */\r
        vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );\r
    vCreateBlockTimeTasks();\r
    vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );\r
    vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );\r
    vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY );\r
    vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );\r
    vStartQueuePeekTasks();\r
    vStartRecursiveMutexTasks();\r
    vStartInterruptQueueTasks();\r
    vStartQueueSetTasks();\r
\r
        /* Start the tasks defined within this file/specific to this demo. */\r
        xTaskCreate( vOLEDTask, "OLED", mainOLED_TASK_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );\r
\r
        /* The suicide tasks must be created last as they need to know how many\r
        tasks were running prior to their creation in order to ascertain whether\r
        or not the correct/expected number of tasks are running at any given time. */\r
    vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY );\r
\r
        /* Configure the high frequency interrupt used to measure the interrupt\r
        jitter time. */\r
        vSetupHighFrequencyTimer();\r
\r
        /* Start the scheduler. */\r
        vTaskStartScheduler();\r
\r
    /* Will only get here if there was insufficient memory to create the idle\r
    task. */\r
        for( ;; );\r
        return 0;\r
}\r
/*-----------------------------------------------------------*/\r
\r
void prvSetupHardware( void )\r
{\r
    /* If running on Rev A2 silicon, turn the LDO voltage up to 2.75V.  This is\r
    a workaround to allow the PLL to operate reliably. */\r
    if( DEVICE_IS_REVA2 )\r
    {\r
        SysCtlLDOSet( SYSCTL_LDO_2_75V );\r
    }\r
\r
        /* Set the clocking to run from the PLL at 50 MHz */\r
        SysCtlClockSet( SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ );\r
\r
        /*      Enable Port F for Ethernet LEDs\r
                LED0        Bit 3   Output\r
                LED1        Bit 2   Output */\r
        SysCtlPeripheralEnable( SYSCTL_PERIPH_GPIOF );\r
        GPIODirModeSet( GPIO_PORTF_BASE, (GPIO_PIN_2 | GPIO_PIN_3), GPIO_DIR_MODE_HW );\r
        GPIOPadConfigSet( GPIO_PORTF_BASE, (GPIO_PIN_2 | GPIO_PIN_3 ), GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD );\r
\r
        vParTestInitialise();\r
}\r
/*-----------------------------------------------------------*/\r
\r
void vApplicationTickHook( void )\r
{\r
static xOLEDMessage xMessage = { "PASS" };\r
static unsigned long ulTicksSinceLastDisplay = 0;\r
portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
\r
        /* Called from every tick interrupt.  Have enough ticks passed to make it\r
        time to perform our health status check again? */\r
        ulTicksSinceLastDisplay++;\r
        if( ulTicksSinceLastDisplay >= mainCHECK_DELAY )\r
        {\r
                ulTicksSinceLastDisplay = 0;\r
\r
                /* Has an error been found in any task? */\r
                if( xAreGenericQueueTasksStillRunning() != pdTRUE )\r
                {\r
                        xMessage.pcMessage = "ERROR IN GEN Q";\r
                }\r
                else if( xAreQueuePeekTasksStillRunning() != pdTRUE )\r
                {\r
                        xMessage.pcMessage = "ERROR IN PEEK Q";\r
                }\r
                else if( xAreBlockingQueuesStillRunning() != pdTRUE )\r
                {\r
                        xMessage.pcMessage = "ERROR IN BLOCK Q";\r
                }\r
                else if( xAreBlockTimeTestTasksStillRunning() != pdTRUE )\r
                {\r
                        xMessage.pcMessage = "ERROR IN BLOCK TIME";\r
                }\r
            else if( xAreSemaphoreTasksStillRunning() != pdTRUE )\r
            {\r
                xMessage.pcMessage = "ERROR IN SEMAPHORE";\r
            }\r
            else if( xArePollingQueuesStillRunning() != pdTRUE )\r
            {\r
                xMessage.pcMessage = "ERROR IN POLL Q";\r
            }\r
            else if( xIsCreateTaskStillRunning() != pdTRUE )\r
            {\r
                xMessage.pcMessage = "ERROR IN CREATE";\r
            }\r
            else if( xAreIntegerMathsTaskStillRunning() != pdTRUE )\r
            {\r
                xMessage.pcMessage = "ERROR IN MATH";\r
            }\r
            else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE )\r
            {\r
                xMessage.pcMessage = "ERROR IN REC MUTEX";\r
            }\r
                else if( ulIdleError != pdFALSE )\r
                {\r
                        xMessage.pcMessage = "ERROR IN HOOK";\r
                }\r
                else if( xAreIntQueueTasksStillRunning() != pdTRUE )\r
                {\r
                        xMessage.pcMessage = "ERROR IN INT QUEUE";\r
                }\r
                else if( xAreQueueSetTasksStillRunning() != pdTRUE )\r
                {\r
                xMessage.pcMessage = "ERROR IN QUEUE SET";\r
                }\r
\r
                /* Send the message to the OLED gatekeeper for display. */\r
                xHigherPriorityTaskWoken = pdFALSE;\r
                xQueueSendFromISR( xOLEDQueue, &xMessage, &xHigherPriorityTaskWoken );\r
        }\r
\r
        /* Exercise the queue sets from an ISR. */\r
    vQueueSetAccessQueueSetFromISR();\r
}\r
/*-----------------------------------------------------------*/\r
\r
void vOLEDTask( void *pvParameters )\r
{\r
xOLEDMessage xMessage;\r
unsigned long ulY, ulMaxY;\r
static char cMessage[ mainMAX_MSG_LEN ];\r
extern volatile unsigned long ulMaxJitter;\r
unsigned portBASE_TYPE uxUnusedStackOnEntry;\r
const unsigned char *pucImage;\r
\r
/* Functions to access the OLED.  The one used depends on the dev kit\r
being used. */\r
void ( *vOLEDInit )( unsigned long ) = NULL;\r
void ( *vOLEDStringDraw )( const char *, unsigned long, unsigned long, unsigned char ) = NULL;\r
void ( *vOLEDImageDraw )( const unsigned char *, unsigned long, unsigned long, unsigned long, unsigned long ) = NULL;\r
void ( *vOLEDClear )( void ) = NULL;\r
\r
        /* Just for demo purposes. */\r
        uxUnusedStackOnEntry = uxTaskGetStackHighWaterMark( NULL );\r
\r
        /* Map the OLED access functions to the driver functions that are appropriate\r
        for the evaluation kit being used. */\r
        switch( HWREG( SYSCTL_DID1 ) & SYSCTL_DID1_PRTNO_MASK )\r
        {\r
                case SYSCTL_DID1_PRTNO_6965     :\r
                case SYSCTL_DID1_PRTNO_2965     :       vOLEDInit = OSRAM128x64x4Init;\r
                                                                                vOLEDStringDraw = OSRAM128x64x4StringDraw;\r
                                                                                vOLEDImageDraw = OSRAM128x64x4ImageDraw;\r
                                                                                vOLEDClear = OSRAM128x64x4Clear;\r
                                                                                ulMaxY = mainMAX_ROWS_64;\r
                                                                                pucImage = pucBasicBitmap;\r
                                                                                break;\r
\r
                case SYSCTL_DID1_PRTNO_1968     :\r
                case SYSCTL_DID1_PRTNO_8962 :   vOLEDInit = RIT128x96x4Init;\r
                                                                                vOLEDStringDraw = RIT128x96x4StringDraw;\r
                                                                                vOLEDImageDraw = RIT128x96x4ImageDraw;\r
                                                                                vOLEDClear = RIT128x96x4Clear;\r
                                                                                ulMaxY = mainMAX_ROWS_96;\r
                                                                                pucImage = pucBasicBitmap;\r
                                                                                break;\r
\r
                default                                         :       vOLEDInit = vFormike128x128x16Init;\r
                                                                                vOLEDStringDraw = vFormike128x128x16StringDraw;\r
                                                                                vOLEDImageDraw = vFormike128x128x16ImageDraw;\r
                                                                                vOLEDClear = vFormike128x128x16Clear;\r
                                                                                ulMaxY = mainMAX_ROWS_128;\r
                                                                                pucImage = pucGrLibBitmap;\r
                                                                                break;\r
        }\r
\r
        ulY = ulMaxY;\r
\r
        /* Initialise the OLED and display a startup message. */\r
        vOLEDInit( ulSSI_FREQUENCY );\r
        vOLEDStringDraw( "POWERED BY FreeRTOS", 0, 0, mainFULL_SCALE );\r
        vOLEDImageDraw( pucImage, 0, mainCHARACTER_HEIGHT + 1, bmpBITMAP_WIDTH, bmpBITMAP_HEIGHT );\r
\r
        for( ;; )\r
        {\r
                /* Wait for a message to arrive that requires displaying. */\r
                xQueueReceive( xOLEDQueue, &xMessage, portMAX_DELAY );\r
\r
                /* Write the message on the next available row. */\r
                ulY += mainCHARACTER_HEIGHT;\r
                if( ulY >= ulMaxY )\r
                {\r
                        ulY = mainCHARACTER_HEIGHT;\r
                        vOLEDClear();\r
                        vOLEDStringDraw( pcWelcomeMessage, 0, 0, mainFULL_SCALE );\r
                }\r
\r
                /* Display the message along with the maximum jitter time from the\r
                high priority time test. */\r
                sprintf( cMessage, "%s [%uns]", xMessage.pcMessage, ulMaxJitter * mainNS_PER_CLOCK );\r
                vOLEDStringDraw( cMessage, 0, ulY, mainFULL_SCALE );\r
        }\r
}\r
/*-----------------------------------------------------------*/\r
\r
void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName )\r
{\r
        for( ;; );\r
}\r
/*-----------------------------------------------------------*/\r
\r
void vApplicationMallocFailedHook( void )\r
{\r
        for( ;; );\r
}\r
/*-----------------------------------------------------------*/\r
\r
/* Just to keep the linker happy. */\r
void __error__( char *pcFilename, unsigned long ulLine )\r
{\r
        for( ;; );\r
}\r
\r
int uipprintf( const char *fmt, ... )\r
{\r
        return( 0 );\r
}\r