// Some comments about author
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "DSP28x_Project.h"         // Device Headerfile and Examples Include File
#include "DSP2833x_Examples.h"
#include "Protocol/CAN.h"


//Functions declarations
void idle_loop(void);
interrupt void cpu_timer0_isr(void);
interrupt void canb_isr(void);
interrupt void canb_box_isr(void);

volatile Uint16 canISRcounter = 0;
volatile Uint16 canBoxISRcounter = 0;

canSpace::CAN canTest(canSpace::CANB);
Uint16 msgsSent = 0;
volatile Uint16 infCounter = 0;
volatile Uint16 testCounter = 0;
Uint32 testVar = 0;
volatile bool startTX = false;
volatile bool update = false;
volatile bool sendRemote = false;
canSpace::CANMessage message;
canSpace::CANMessage rxMessage;

void main()
{
    ServiceDog();
    DisableDog();

    InitSysCtrl();

    DINT;

    InitPieCtrl();

    IER = 0x0000;
    IFR = 0x0000;

    InitPieVectTable();

    EALLOW;
    PieVectTable.TINT0 = &cpu_timer0_isr;
    PieVectTable.ECAN0INTB = &canb_isr;
    PieVectTable.ECAN1INTB = &canb_box_isr;
    EDIS;

    // memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (Uint32)&RamfuncsLoadSize);

    InitCpuTimers();
    ConfigCpuTimer(&CpuTimer0, 150, 100000);

    IER |= M_INT1; // Enable CPU Interrupt 1
    IER |= M_INT9; // Enable CPU Interrupt 9

    PieCtrlRegs.PIEIER1.bit.INTx7 = 1;
    PieCtrlRegs.PIEIER9.bit.INTx7 = 1;  // from 5 to 8
    PieCtrlRegs.PIEIER9.bit.INTx8 = 1;

    canTest.initGpio();
    canTest.config(100);
    canTest.configTxMBox(1, canSpace::MsgID(0xAAA), canSpace::MsgCtrlReg(0x8));
    canTest.configRxMBox(25, canSpace::MsgID(0xAAA), canSpace::MsgCtrlReg(0x8));
    // Remote frame
    canTest.configRxMBox(2, canSpace::MsgID(0x111), canSpace::MsgCtrlReg(0x13));
    // canTest.configTxMBox(30, canSpace::MsgID(0x111, false, true), canSpace::MsgCtrlReg(0x3));    // for remote answer

    canTest.configSystemIsr(canSpace::I0EN_ENABLE | canSpace::EPIM_ENABLE | canSpace::WLIM_ENABLE | canSpace::AAIM_ENABLE);

    //
    // Enable global Interrupts and higher priority real-time debug events:
    //
    EINT;   // Enable Global interrupt INTM
    ERTM;   // Enable Global realtime interrupt DBGM


    //
    //  Start CPU Timer
    //
//    core.cpu_timers.start();
    //

    CpuTimer0.RegsAddr->TCR.bit.TSS = 0;

    message.msgctrl.bit.DLC = 8;
    message.mdl.byte.BYTE0 = 0x11;
    message.mdl.byte.BYTE1 = 0x22;
    message.mdl.byte.BYTE2 = 0x33;
    message.mdl.byte.BYTE3 = 0x44;
    message.mdh.byte.BYTE4 = 0xAA;
    message.mdh.byte.BYTE5 = 0xBB;
    message.mdh.byte.BYTE6 = 0xCC;
    message.mdh.byte.BYTE7 = 0xDD;
    // canTest.updateTXMessage(30, message);    // for remote answer

    idle_loop();
    //
}//end main()
//
//

void idle_loop()
{
    while (true)
    {
        infCounter++;
        if (startTX){
            startTX = false;
            canTest.transmitMsg(1, message);
            msgsSent++;
        }
        if(canTest.isNewMessage()){
            testCounter++;
            testVar = canTest.receiveMsg(25, rxMessage);
            // testVar = canTest.receiveMsg(2, rxMessage);
        }

        testVar = canTest.receiveMsg(2, rxMessage);

        if (update){
            update = false;
            message.mdh.all = 0xBBEEBBEE;
            canTest.updateTXMessage(1, message);
        }

        if (sendRemote){
            sendRemote = false;
            canTest.sendRemoteRequest(2);
        }

    }//end while
    //
}//end idle_loop()


interrupt void cpu_timer0_isr(void)
{
    canTest.sendRemoteRequest(2);

    if(canTest.isNewMessage()){
        testCounter++;
        testVar = canTest.receiveMsg(25, rxMessage);
        testVar = canTest.receiveMsg(2, rxMessage);
    }
    
    PieCtrlRegs.PIEACK.all |= PIEACK_GROUP1;
}//end


interrupt void canb_isr(void){
    canISRcounter++;

    CANGIF0_REG CANGIF0_SHADOW;
    volatile Uint32 resetBit;

    CANGIF0_SHADOW.all = ECanbRegs.CANGIF0.all;

    if (CANGIF0_SHADOW.bit.WLIF0){
        resetBit = 256;
        ECanbRegs.CANGIF0.all = resetBit;
    }

    if (CANGIF0_SHADOW.bit.EPIF0){
        resetBit = 528;
        ECanbRegs.CANGIF0.all = resetBit;
    }

    PieCtrlRegs.PIEACK.all |= PIEACK_GROUP9;
}

interrupt void canb_box_isr(void){
    canBoxISRcounter++;

    // Just example
    //
    // boxNumberIsr = ECanbRegs.CANGIF1.bit.MIV1;

    // CANRMP_REG temp;
    // temp.all = 0;
    // temp.all = 1ul << 27;
    // temp.all |= 1ul << 26;

    // ECanbRegs.CANRMP.all = temp.all;

    // MODBUS_COMM_CPU_Message27.mdh.all = ECanbMboxes.MBOX27.MDH.all;
    // MODBUS_COMM_CPU_Message27.mdl.all = ECanbMboxes.MBOX27.MDL.all;

    // MODBUS_COMM_CPU_Message26.mdh.all = ECanbMboxes.MBOX26.MDH.all;
    // MODBUS_COMM_CPU_Message26.mdl.all = ECanbMboxes.MBOX26.MDL.all;

    // temp.all = ECanbRegs.CANRMP.all;
    // if (temp.bit.RMP25){
    //     temp.all = 1ul << 25;
    //     ECanbRegs.CANRMP.all = temp.all;

    //     MODBUS_COMM_CPU_Message25.mdh.all = ECanbMboxes.MBOX25.MDH.all;
    //     MODBUS_COMM_CPU_Message25.mdl.all = ECanbMboxes.MBOX25.MDL.all;
    // }

    PieCtrlRegs.PIEACK.all |= PIEACK_GROUP9;
}