#include "main.h" 
#include "Gpt.h"
#include "can_func.h"
 
#define CAN_START_SEC_VAR_INIT_BOOLEAN
#include "Can_MemMap.h"

static boolean Ex_Can_TxFlag = FALSE;
static boolean Ex_Can_RxFlagCase2 = FALSE;
static boolean Ex_Can_RxFlagCase3 = FALSE;
static boolean Ex_Can_FlagCase4 = FALSE;


#define CAN_STOP_SEC_VAR_INIT_BOOLEAN
#include "Can_MemMap.h"

#define CAN_START_SEC_VAR_INIT_8
#include "Can_MemMap.h"

static uint8 Ex_Can_PeriodTime = 0;

#define CAN_STOP_SEC_VAR_INIT_8
#include "Can_MemMap.h"

#define CAN_START_SEC_CODE
#include "Can_MemMap.h"

/**
 * @brief     This function used to check Rx message data for use case 2.
 */
static void Ex_Can_CheckDmaRxResult(const Can_HwType *HwObj, const PduInfoType *PduInfoPtr);

/**
 * @brief     This function used to check Rx message data.
 */
static void Ex_Can_CheckPollingRxResult(const Can_HwType *HwObj, const PduInfoType *PduInfoPtr);

#define CAN_STOP_SEC_CODE
#include "Can_MemMap.h"

#define CAN_START_SEC_CODE
#include "Can_MemMap.h"
/**
 * @brief   CanIf stub function.
 */
extern void CanIf_ControllerBusOff(uint8 ControllerId)
{
    (void)ControllerId;
}

/**
 * @brief   CanIf stub function.
 */
void CanIf_ControllerModeIndication(uint8 ControllerId, Can_ControllerStateType ControllerMode)
{
    (void)ControllerId;
    (void)ControllerMode;
}

/**
 * @brief   CanIf stub function.
 */
void CanIf_TxConfirmation(PduIdType CanTxPduId)
{
    Ex_Can_TxFlag = TRUE;
    (void)CanTxPduId;
    (void)Ex_Can_TxFlag;
}

/**
 * @brief   CanIf stub function.
 */
void CanIf_RxIndication(const Can_HwType *HwObj, const PduInfoType *PduInfoPtr)
{
    Ex_Can_CheckDmaRxResult(HwObj, PduInfoPtr);

    Ex_Can_CheckPollingRxResult(HwObj, PduInfoPtr);
}

/**
 * @brief  Stim callback function.
 */
void Ex_Can_StimCallback(void)
{
    static uint32 interruptCount = 0U;
    
    #if EN_CAN
    /* interrupt */
    if (++interruptCount == (CAN_MAINFUNCTION_MODE_PERIOD * 1000))
    {
        /*  period task flag */
        interruptCount = 0U;
        Ex_Can_PeriodTime = 1;
    }
    #endif
}

/**
 * @brief     This function used to check Rx message data for use case 2.
 */
static void Ex_Can_CheckDmaRxResult(const Can_HwType *HwObj, const PduInfoType *PduInfoPtr)
{
    /*
    if ((0x734U == HwObj->CanId) && (CAN_HwObj0 == HwObj->Hoh) &&
        (CAN1 == HwObj->ControllerId))
    {
        if ((8U == PduInfoPtr->SduLength) && (0x11 == PduInfoPtr->SduDataPtr[0U]) &&
            (0x22 == PduInfoPtr->SduDataPtr[1U]) &&
            (0x33 == PduInfoPtr->SduDataPtr[2U]) &&
            (0x44 == PduInfoPtr->SduDataPtr[3U]) &&
            (0x55 == PduInfoPtr->SduDataPtr[4U]) &&
            (0x66 == PduInfoPtr->SduDataPtr[5U]) &&
            (0x77 == PduInfoPtr->SduDataPtr[6U]) && (0x88 == PduInfoPtr->SduDataPtr[7U]))
        {
            Ex_Can_RxFlagCase2 = TRUE;
        }
    }
    */
    
    if (
        (0x7df == HwObj->CanId)
        ||(0x723U == HwObj->CanId)
        ||(0x724U == HwObj->CanId)
        ||(0x450U == HwObj->CanId)
        ||(0x453U == HwObj->CanId)
        ||(0x454U == HwObj->CanId)
        ||(0x387U == HwObj->CanId)
        ||(0x3efU == HwObj->CanId)
    ) 
    {
            Ex_Can_RxFlagCase2 = TRUE;
    }
}

/**
 * @brief     This function used to check Rx message data.
 */
static void Ex_Can_CheckPollingRxResult(const Can_HwType *HwObj, const PduInfoType *PduInfoPtr)
{
    if ((0x80001314 == HwObj->CanId) && (CAN_HwObj1 == HwObj->Hoh) &&
        (CAN1 == HwObj->ControllerId))
    {
        if ((8U == PduInfoPtr->SduLength) && (0x01 == PduInfoPtr->SduDataPtr[0U]) &&
            (0x02 == PduInfoPtr->SduDataPtr[1U]) &&
            (0x03 == PduInfoPtr->SduDataPtr[2U]) &&
            (0x04 == PduInfoPtr->SduDataPtr[3U]) &&
            (0x05 == PduInfoPtr->SduDataPtr[4U]) &&
            (0x06 == PduInfoPtr->SduDataPtr[5U]) &&
            (0x07 == PduInfoPtr->SduDataPtr[6U]) && (0x08 == PduInfoPtr->SduDataPtr[7U]))
        {
            Ex_Can_RxFlagCase3 = TRUE;
        }
    }
}

/**
 * @brief   This use case will send CAN standard frame by polling mode via CAN0.
 *
 */
PT_THREAD(Ex_Can_UseCase_01(struct pt *pt1 ))
//void Ex_Can_UseCase_01(void)
{
    static struct timer  input_timer; 
    static Can_PduType PduInfo;
    static uint8    SendData[] = {0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21};
    static uint8 Cnt = 0U;

    PT_BEGIN(pt1);  
    PduInfo.id = 0x733;
    PduInfo.sdu = SendData;
    PduInfo.swPduHandle = 0;
    PduInfo.length = 8;

    Can_SetControllerMode(CAN1, CAN_CS_STARTED);
    Can_EnableControllerInterrupts(CAN1);
    Gpt_StopTimer(GptChlCAN1);
    Gpt_StartTimer(GptChlCAN1, 3000);
    while (1U)
    {
        //Wdg_Service();

        //if (1 == Ex_Can_PeriodTime)
        PT_WAIT_UNTIL(pt1,Ex_Can_PeriodTime==1);
        {
            ++Cnt;
            if (Cnt == 0xffU)
            {
                break;
            }
            SendData[0]=(uint8)Cnt;
            Can_Write(CAN_HwObj2, &PduInfo);

            uint32 Index = 0;
            /* Delay to ensure send out data */
            for (Index = 0U; Index < 10000U; ++Index)
            {
                
            }
            Can_MainFunction_Write();
            Ex_Can_PeriodTime = 0;
            
        }
    }
    
    PT_END(pt1);
}

/**
 * @brief   This use case will receive CAN standard frame with FIFO DMA mode by interrupt mode via
 * CAN0.
 *
 */

PT_THREAD(Ex_Can_UseCase_02(struct pt *pt1 ))
//void Ex_Can_UseCase_02(void)
{
    PT_BEGIN(pt1);  
    Can_SetControllerMode(CAN1, CAN_CS_STARTED);
    Can_EnableControllerInterrupts(CAN1);

    while (1U)
    {
        //Wdg_Service(); 
        PT_WAIT_UNTIL(pt1,Ex_Can_RxFlagCase2==TRUE); 
        { 
            break;
        }
    }
    PT_END(pt1);
}

/**
 * @brief   This use case will receive CAN extended frame by polling mode via CAN0.
 *
 */

int ReadFunc(void)
{ 
  Can_MainFunction_Read(); 
  return Ex_Can_RxFlagCase3;
}

PT_THREAD(Ex_Can_UseCase_03(struct pt *pt1 ))
//void Ex_Can_UseCase_03(void)
{
    PT_BEGIN(pt1);  
    Can_SetControllerMode(CAN1, CAN_CS_STARTED);
    Can_EnableControllerInterrupts(CAN1);

    Gpt_StartTimer(GptChlCAN1, 3000);
    while (1)
    {
        //Wdg_Service();   
        PT_WAIT_UNTIL(pt1,ReadFunc()==TRUE);  
        //PT_WAIT_UNTIL(pt1,Ex_Can_RxFlagCase3==TRUE); 
        if (TRUE == Ex_Can_RxFlagCase3)
        {
            Ex_Can_RxFlagCase3 = FALSE;
            break;
        }   
    }
    PT_END(pt1);
}

PT_THREAD(Ex_Can_UseCase_04(struct pt *pt1 ))
//static void Ex_Can_UseCase_04(void)
{
    PT_BEGIN(pt1);  
    Can_SetControllerMode(CAN1, CAN_CS_STARTED);
    Can_DisableControllerInterrupts(CAN1);
    Can_InjectError(CAN1);

    while (1)
    {  
        PT_WAIT_UNTIL(pt1,Ex_Can_FlagCase4==TRUE); 
        //if (TRUE == Ex_Can_FlagCase4)
        {
            break;
        }
    }
    PT_END(pt1);
}


/**
 * @brief   This use case will send CAN extended frame by interrupt mode via CAN0.
 *
 */

PT_THREAD(Ex_Can_UseCase_05(struct pt *pt1 ))
//void Ex_Can_UseCase_05(void)
{
    static int i = 0;
    static Can_PduType PduInfo;
    static uint8       SendData[] = {0x87, 0x65, 0x43, 0x21, 0x12, 0x34, 0x56, 0x78};

    PduInfo.id = 0x80001122;
    PduInfo.sdu = SendData;
    PduInfo.swPduHandle = 0;
    PduInfo.length = 8;

    Can_SetControllerMode(CAN1, CAN_CS_STARTED);
    Can_EnableControllerInterrupts(CAN1); 
    Gpt_StartTimer(GptChlCAN1, 3000); 
    
    PT_BEGIN(pt1);  
    while (1)
    {
        //Wdg_Service();
        
        //if (1 == Ex_Can_PeriodTime)
           
        PT_WAIT_UNTIL(pt1,Ex_Can_PeriodTime==1); 
        {
            Can_Write(CAN_HwObj3, &PduInfo);
            Ex_Can_PeriodTime = 0;
            i++;
            if(i==100)
            {
              i = 0;
              break;
            }
        }
    }
    PT_END(pt1);
}
 


PT_THREAD(TaskCAN(struct pt *pt1 ))
{ 
    static struct pt pt_Ex_Can_UseCase_01, pt_Ex_Can_UseCase_02,pt_Ex_Can_UseCase_03,pt_Ex_Can_UseCase_05,pt_Ex_Can_UseCase_04;
    PT_BEGIN(pt1);    
    Gpt_EnableNotification(GptChlCAN1); 
    while(1)
    { 
        PT_SPAWN(pt1,&pt_Ex_Can_UseCase_01, Ex_Can_UseCase_01(&pt_Ex_Can_UseCase_01));
        PT_SPAWN(pt1,&pt_Ex_Can_UseCase_02, Ex_Can_UseCase_01(&pt_Ex_Can_UseCase_02));
        PT_SPAWN(pt1,&pt_Ex_Can_UseCase_03, Ex_Can_UseCase_01(&pt_Ex_Can_UseCase_03));
        PT_SPAWN(pt1,&pt_Ex_Can_UseCase_04, Ex_Can_UseCase_01(&pt_Ex_Can_UseCase_04)); 
    }    
    PT_END(pt1);
}

void Can1_ErrNotifyFunc (void)
{
    
}

void CAN1_FIFO_DMA_ErrNotifyFunc (void)
{
}


boolean CAN_LPduRxFunc(uint8 Hrh, Can_IdType CanId, uint8 CanDataLegth, const uint8* CanSduPtr)
{
    //Autosar Stub
    return TRUE;
}
 


void CanIf_ControllerErrorStatePassive (uint8 ControllerId,uint16 RxErrorCounter,uint16 TxErrorCounter)
{
    
}
   


void CanIf_ErrorNotification (uint8 ControllerId,Can_ErrorType CanErrorType) 
{
    
}



void Can1_HostMemNotify(void)
{
}
 
    
void Can1_MemNotify(void)
{
}

void Can1_CorrMemNotify(void)
{
}


void BusFault_Handler(void)
{
    if(E_OK == Can_ClearInjectError(0))
    {
        Ex_Can_FlagCase4 = TRUE;
    }
}