/*
 * 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
 *
 */

/*
 * Creates all the demo application tasks, then starts the scheduler.  The WEB
 * documentation provides more details of the demo application tasks.
 *
 * Main. c also creates a task called "Check".  This only executes every three
 * seconds but has the highest priority so is guaranteed to get processor time.
 * Its main function is to check that all the other tasks are still operational.
 * Each task that does not flash an LED maintains a unique count that is
 * incremented each time the task successfully completes its function.  Should
 * any error occur within such a task the count is permanently halted.  The
 * check task inspects the count of each task to ensure it has changed since
 * the last time the check task executed.  If all the count variables have
 * changed all the tasks are still executing error free, and the check task
 * toggles an LED.  Should any task contain an error at any time the LED toggle
 * will stop.
 *
 * The LED flash and communications test tasks do not maintain a count.
 */

/*
 * Changes from V1.2.0
 *
 + Changed the baud rate for the serial test from 19200 to 57600.
 +
 + Changes from V1.2.3
 +
 + The integer and comtest tasks are now used when the cooperative scheduler
 +    is being used.  Previously they were only used with the preemptive
 +    scheduler.
 +
 + Changes from V1.2.5
 +
 + Set the baud rate to 38400.  This has a smaller error percentage with an
 +    8MHz clock (according to the manual).
 +
 + Changes from V2.0.0
 +
 + Delay periods are now specified using variables and constants of
 +    TickType_t rather than unsigned long.
 +
 + Changes from V2.2.0
 +
 + File can now be built using either the IAR or WinAVR compiler.
 +
 + Changes from V2.6.1
 +
 + The IAR and WinAVR AVR ports are now maintained separately.
 +
 + Changes from V4.0.5
 +
 + Modified to demonstrate the use of co-routines.
 */

#include <stdlib.h>
#include <string.h>

#ifdef GCC_MEGA_AVR
    /* EEPROM routines used only with the WinAVR compiler. */
    #include <avr/eeprom.h>
#endif

/* Scheduler include files. */
#include "FreeRTOS.h"
#include "task.h"
#include "croutine.h"

/* Demo file headers. */
#include "PollQ.h"
#include "integer.h"
#include "serial.h"
#include "comtest.h"
#include "crflash.h"
#include "print.h"
#include "partest.h"
#include "regtest.h"

/* Priority definitions for most of the tasks in the demo application.  Some
 * tasks just use the idle priority. */
#define mainLED_TASK_PRIORITY       ( tskIDLE_PRIORITY + 1 )
#define mainCOM_TEST_PRIORITY       ( tskIDLE_PRIORITY + 2 )
#define mainQUEUE_POLL_PRIORITY     ( tskIDLE_PRIORITY + 2 )
#define mainCHECK_TASK_PRIORITY     ( tskIDLE_PRIORITY + 3 )

/* Baud rate used by the serial port tasks. */
#define mainCOM_TEST_BAUD_RATE      ( ( unsigned long ) 38400 )

/* LED used by the serial port tasks.  This is toggled on each character Tx,
 * and mainCOM_TEST_LED + 1 is toggles on each character Rx. */
#define mainCOM_TEST_LED            ( 4 )

/* LED that is toggled by the check task.  The check task periodically checks
 * that all the other tasks are operating without error.  If no errors are found
 * the LED is toggled.  If an error is found at any time the LED is never toggles
 * again. */
#define mainCHECK_TASK_LED          ( 7 )

/* The period between executions of the check task. */
#define mainCHECK_PERIOD            ( ( TickType_t ) 3000 / portTICK_PERIOD_MS )

/* An address in the EEPROM used to count resets.  This is used to check that
 * the demo application is not unexpectedly resetting. */
#define mainRESET_COUNT_ADDRESS     ( ( void * ) 0x50 )

/* The number of coroutines to create. */
#define mainNUM_FLASH_COROUTINES    ( 3 )

/*
 * The task function for the "Check" task.
 */
static void vErrorChecks( void * pvParameters );

/*
 * Checks the unique counts of other tasks to ensure they are still operational.
 * Flashes an LED if everything is okay.
 */
static void prvCheckOtherTasksAreStillRunning( void );

/*
 * Called on boot to increment a count stored in the EEPROM.  This is used to
 * ensure the CPU does not reset unexpectedly.
 */
static void prvIncrementResetCount( void );

/*
 * Idle hook is used to scheduler co-routines.
 */
void vApplicationIdleHook( void );

short main( void )
{
    prvIncrementResetCount();

    /* Setup the LED's for output. */
    vParTestInitialise();

    /* Create the standard demo tasks. */
    vStartIntegerMathTasks( tskIDLE_PRIORITY );
    vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED );
    vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );
    vStartRegTestTasks();

    /* Create the tasks defined within this file. */
    xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );

    /* Create the co-routines that flash the LED's. */
    vStartFlashCoRoutines( mainNUM_FLASH_COROUTINES );

    /* In this port, to use preemptive scheduler define configUSE_PREEMPTION
     * as 1 in portmacro.h.  To use the cooperative scheduler define
     * configUSE_PREEMPTION as 0. */
    vTaskStartScheduler();

    return 0;
}
/*-----------------------------------------------------------*/

static void vErrorChecks( void * pvParameters )
{
    static volatile unsigned long ulDummyVariable = 3UL;

    /* The parameters are not used. */
    ( void ) pvParameters;

    /* Cycle for ever, delaying then checking all the other tasks are still
     * operating without error. */
    for( ; ; )
    {
        vTaskDelay( mainCHECK_PERIOD );

        /* Perform a bit of 32bit maths to ensure the registers used by the
         * integer tasks get some exercise. The result here is not important -
         * see the demo application documentation for more info. */
        ulDummyVariable *= 3;

        prvCheckOtherTasksAreStillRunning();
    }
}
/*-----------------------------------------------------------*/

static void prvCheckOtherTasksAreStillRunning( void )
{
    static portBASE_TYPE xErrorHasOccurred = pdFALSE;

    if( xAreIntegerMathsTaskStillRunning() != pdTRUE )
    {
        xErrorHasOccurred = pdTRUE;
    }

    if( xAreComTestTasksStillRunning() != pdTRUE )
    {
        xErrorHasOccurred = pdTRUE;
    }

    if( xArePollingQueuesStillRunning() != pdTRUE )
    {
        xErrorHasOccurred = pdTRUE;
    }

    if( xAreRegTestTasksStillRunning() != pdTRUE )
    {
        xErrorHasOccurred = pdTRUE;
    }

    if( xErrorHasOccurred == pdFALSE )
    {
        /* Toggle the LED if everything is okay so we know if an error occurs even if not
         * using console IO. */
        vParTestToggleLED( mainCHECK_TASK_LED );
    }
}
/*-----------------------------------------------------------*/

static void prvIncrementResetCount( void )
{
    unsigned char ucCount;
    const unsigned char ucReadBit = ( unsigned char ) 0x01;
    const unsigned char ucWrite1 = ( unsigned char ) 0x04;
    const unsigned char ucWrite2 = ( unsigned char ) 0x02;

    /* Increment the EEPROM value at 0x00.
     *
     * Setup the EEPROM address. */
    EEARH = 0x00;
    EEARL = 0x00;

    /* Set the read enable bit. */
    EECR |= ucReadBit;

    /* Wait for the read. */
    while( EECR & ucReadBit )
    {
    }

    /* The byte is ready. */
    ucCount = EEDR;

    /* Increment the reset count, then write the byte back. */
    ucCount++;
    EEDR = ucCount;
    EECR = ucWrite1;
    EECR = ( ucWrite1 | ucWrite2 );
}
/*-----------------------------------------------------------*/

void vApplicationIdleHook( void )
{
    vCoRoutineSchedule();
}