/******************************** system and platform files */
#include <stdint.h>             /* Variable type definitions */
#include <stdbool.h>

#include "FreeRTOS.h"
#include "task.h"
#include "event_groups.h"

/* Function prototypes */

BaseType_t A1TaskCreate( UBaseType_t priority );
BaseType_t A2TaskCreate( UBaseType_t priority );
BaseType_t WDTaskCreate( UBaseType_t priority );
BaseType_t B1TaskCreate( UBaseType_t priority );


 void A1Task ( void *parameters );
 void A2Task ( void *parameters );
 void WDTask ( void *parameters );
 void B1Task ( void *parameters );

/* Event group bits */

#define A1_PASS                                ( 1UL << 0UL )
#define B1_PASS                                ( 1UL << 1UL )
#define A1_ONLY_MODE                           ( 1UL << 2UL )
#define B1_ONLY_MODE                           ( 1UL << 3UL )
#define OR_MODE                                ( 1UL << 4UL )

/* Task priorities */

#define A1_TASK_PRIORITY                       ( tskIDLE_PRIORITY + 2 )
#define A2_TASK_PRIORIT                        ( tskIDLE_PRIORITY + 1 )
#define WD_TASK_PRIORITY                       ( tskIDLE_PRIORITY + 7 )
#define B1_TASK_PRIORITY                       ( tskIDLE_PRIORITY + 2 )

/* Task stack size */

const unsigned int A1STACK_SIZE = 512;
const unsigned int A2STACK_SIZE = 512;
const unsigned int WDSTACK_SIZE = 512;
const unsigned int B1STACK_SIZE = 512;

/* Task handles */

static TaskHandle_t A1TaskHandle = NULL;
static TaskHandle_t A2TaskHandle = NULL;
static TaskHandle_t WDTaskHandle = NULL;
static TaskHandle_t B1TaskHandle = NULL;

/* Event group declaration  */

EventGroupHandle_t xTaskControlBits;

void VD2Main(void)
{
    BaseType_t xStatus = pdPASS;

    /* Initialize FreeRTOS Kernel Scheduler */

    xStatus = A1TaskCreate(A1_TASK_PRIORITY);

    if (xStatus == pdPASS)
    {
        xStatus = A2TaskCreate(A2_TASK_PRIORIT);
    }
    if (xStatus == pdPASS)
    {
        xStatus = WDTaskCreate(WD_TASK_PRIORITY);
    }
    if (xStatus == pdPASS)
    {
        xStatus = B1TaskCreate(B1_TASK_PRIORITY);
    }

    xTaskControlBits = xEventGroupCreate();

    /* Configure Event Group so only A1 is running. WD should also run as it is not in the event group */
    xEventGroupSetBits( xTaskControlBits, A1_ONLY_MODE );

    vTaskStartScheduler();

    /* Should never rear here*/
    while(1)
    {

    }
}

/* Creation of tasks */
BaseType_t  A1TaskCreate (
        UBaseType_t priority   /* Priority level for this task */
)
{

    BaseType_t xCreateResult;
    /* Spawn the task */
    xCreateResult = xTaskCreate(
                        A1Task,
                        "A1Task",
                        A1STACK_SIZE,
                        NULL,
                        priority,
                        &A1TaskHandle);

    return xCreateResult;
}

BaseType_t  A2TaskCreate (
        UBaseType_t priority   /* Priority level for this task */
)
{

    BaseType_t xCreateResult;
    /* Spawn the task */
    xCreateResult = xTaskCreate(
                        A2Task,
                        "A2Task",
                        A2STACK_SIZE,
                        NULL,
                        priority,
                        &A2TaskHandle);

    return xCreateResult;
}

BaseType_t  WDTaskCreate (
        UBaseType_t priority   /* Priority level for this task */
)
{

    BaseType_t xCreateResult;
    /* Spawn the task */
    xCreateResult = xTaskCreate(
                        WDTask,
                        "WDTask",
                        WDSTACK_SIZE,
                        NULL,
                        priority,
                        &WDTaskHandle);

    return xCreateResult;
}

BaseType_t  B1TaskCreate (
        UBaseType_t priority   /* Priority level for this task */
)
{

    BaseType_t xCreateResult;
    /* Spawn the task */
    xCreateResult = xTaskCreate(
                        B1Task,
                        "B1Task",
                        B1STACK_SIZE,
                        NULL,
                        priority,
                        &B1TaskHandle);

    return xCreateResult;
}

/* Should run periodically */
void A1Task(
    void *parameters            /* Task startup parameters */
)
{

    ( void ) parameters;
    static EventBits_t xTCBits;

    /* Will run if OR mode or A1 Only is selected. A1 Only mode is hardcoded as selected for testing */
    EventBits_t FR_Control = ( A1_ONLY_MODE | OR_MODE );
    while(1)
    {
        xTCBits = xEventGroupWaitBits(
                        xTaskControlBits,
                        FR_Control,
                        pdFALSE,
                        pdFALSE,
                        portMAX_DELAY );
        /* Added to give easier to read output in tracealyzer. */
        vTaskDelay(100/portTICK_PERIOD_MS);


    }
}

/* Should never run */
void B1Task(
    void *parameters            /* Task startup parameters */
)
{

    ( void ) parameters;
    static EventBits_t xTCBits;

    /* Will run if OR mode or B1 Only is selected. A1 Only mode is hardcoded as selected for testing */
    EventBits_t FR_Control =( B1_ONLY_MODE | OR_MODE );
    while(1)
    {
        xTCBits = xEventGroupWaitBits(
                        xTaskControlBits,
                        FR_Control,
                        pdFALSE,
                        pdFALSE,
                        portMAX_DELAY );

        /* Added to give easier to read output in tracealyzer. */
        vTaskDelay(100/portTICK_PERIOD_MS);

    }
}
/* Should run periodically, regardless of state of event group*/
void WDTask(
    void *parameters            /* Task startup parameters */
)
{

    ( void ) parameters;
    static EventBits_t xTCBits;


    while(1)
    {
        /* Added to give easier to read output in tracealyzer. */
        vTaskDelay(30/portTICK_PERIOD_MS);

    }
}
/* Should never run*/
void A2Task(
    void *parameters            /* Task startup parameters */
)
{

    ( void ) parameters;
    static EventBits_t xTCBits;

    EventBits_t FR_Control =( A1_PASS );
    while(1)
    {
        xTCBits = xEventGroupWaitBits(
                        xTaskControlBits,
                        FR_Control,
                        pdFALSE,
                        pdFALSE,
                        portMAX_DELAY );
        /* Added to give easier to read output in tracealyzer. */
        vTaskDelay(60/portTICK_PERIOD_MS);

    }
}