
#include "driverlib.h"
#include "device.h"

#include "CommunicateWithESC.h"
//#include "ESC_data_information.h"

#include "F021_F28002x_C28x.h"

#include "flash_programming_f28002x.h"

//#pragma  DATA_SECTION(Buffer,"DataBufferSection");
uint16   Buffer[WORDS_IN_FLASH_BUFFER];
uint32   *Buffer32 = (uint32 *)Buffer;

SECTOR Sector[4] = {
                    0x088000,0x089000,
                    0x08E000,0x08FFFF,
                    0x08C000,0x08DFFF,
                    0x08A000,0x08BFFF,
};

uint16 test1[8] = {0xBFF0,0,0x6B60,0x07E4,0x1F07,0xF12,0,0x251B};
uint16 read[8] = {0,0,0,0,0,0,0,0};

extern uint16_t Monitor[10];


void InitGpioSci(void);
void InitSCIAFIFO(void);
void initCPUTimers(void);

void configCPUTimer(uint32_t cpuTimer, float freq, float period);

void setmodeSci(unsigned char mode);                                   //
void JumptoApp(void);

__interrupt void sciaRXFIFOISR(void);
__interrupt void cpuTimer0ISR(void);


uint16_t sDataA[2];

uint16_t rDataA[2];

uint16_t rDataPointA;

uint16_t cpuTimer0IntCount;

unsigned char *msg;




void main(void)
{
    Device_init();

    Device_initGPIO();

    GPIO_setPadConfig(DEVICE_GPIO_PIN_LED1, GPIO_PIN_TYPE_STD);
    GPIO_setDirectionMode(DEVICE_GPIO_PIN_LED1, GPIO_DIR_MODE_OUT);

    InitGpioSci();                                      //

    Interrupt_initModule();

    Interrupt_initVectorTable();

    Interrupt_register(INT_TIMER0, cpuTimer0ISR);       //
    Interrupt_register(INT_SCIA_RX, sciaRXFIFOISR);     //

    setmodeSci(0);              //

    InitSCIAFIFO();             //

    setmodeSci(1);              //

    initCPUTimers();            //

    SysCtl_enableWatchdog();    //

    configCPUTimer(CPUTIMER0_BASE, DEVICE_SYSCLK_FREQ, 66);           // timer0  66us
    CPUTimer_enableInterrupt(CPUTIMER0_BASE);                         //

    Interrupt_enable(INT_SCIA_RX);                                    //
    Interrupt_enable(INT_TIMER0);                                     //

    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP9);

    CPUTimer_startTimer(CPUTIMER0_BASE);                              //

    EINT;
    ERTM;

    GPIO_writePin(DEVICE_GPIO_PIN_LED1, 0);                           //

    if(SystemApplicationChecking() == 0)   //
    {
        boot_time_out = 26000;
    }
    else  //
    {
        UpgradeCtrl.AutoRequestUpdate = 1;

        while(UpgradeCtrl.AutoRequestUpdate==1)
        {
            Connect_ESC_Send_Inf();

            SysCtl_serviceWatchdog();

            UpgradeRequest(FRAME_TYPE_REQ_UPGRADE,FRAME_DEVICE_TYPE_ESC_DRV);       //

            DEVICE_DELAY_US(10);

            SysCtl_serviceWatchdog();

        }
    }

    while(1)
    {

    }
}

__interrupt void cpuTimer0ISR(void)
{
    cpuTimer0IntCount++;

    if(1 == (cpuTimer0IntCount % 2000))
    {
        GPIO_togglePin(DEVICE_GPIO_PIN_LED1);           // LED1
    }

    SysCtl_serviceWatchdog();

    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP1);
}


__interrupt void sciaRXFIFOISR(void)
{

    SCI_clearOverflowStatus(SCIA_BASE);

    SCI_clearInterruptStatus(SCIA_BASE, SCI_INT_RXFF);

    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP9);
}


void setmodeSci(unsigned char mode)
{
    if(mode==0)     //Tx
    {

        SCI_performSoftwareReset(SCIA_BASE);                         //  SCI
        SCI_enableFIFO(SCIA_BASE);                                   // enable fifo
        SCI_resetTxFIFO(SCIA_BASE);                                  // reset tx fifo
        HWREGH(SCIA_BASE + SCI_O_FFTX) |= SCI_FFTX_TXFFINTCLR;       // clear tx fifo int flag
        HWREGH(SCIA_BASE + SCI_O_FFRX) |= SCI_FFRX_RXFFIENA;         // enable rx fifo int

        HWREGH(SCIA_BASE + SCI_O_CTL1) |= SCI_CTL1_TXENA;            // enable tx
        HWREGH(SCIA_BASE + SCI_O_CTL1) &= ~SCI_CTL1_RXENA;           // disable rx

        GPIO_writePin(28, 1);                                   //
        GPIO_setPinConfig(GPIO_28_GPIO28);                      //
        GPIO_setDirectionMode(28, GPIO_DIR_MODE_IN);            //
        GPIO_setPadConfig(28, GPIO_PIN_TYPE_PULLUP);            //
        GPIO_setQualificationMode(28, GPIO_QUAL_ASYNC);         //

        GPIO_setPadConfig(29, GPIO_PIN_TYPE_PULLUP);            //
        GPIO_setPinConfig(GPIO_29_SCITXDA);                     //
        GPIO_setDirectionMode(29, GPIO_DIR_MODE_OUT);           //
    }
    else     //Rx
    {

        while(!((HWREGH(SCIA_BASE + SCI_O_CTL2) & SCI_CTL2_TXEMPTY) ==
                SCI_CTL2_TXEMPTY))
        {
                    //
        }

        HWREGH(SCIA_BASE + SCI_O_CTL1) |= SCI_CTL1_RXENA;            // enable rx
        HWREGH(SCIA_BASE + SCI_O_CTL1) &= ~SCI_CTL1_TXENA;           // disable tx


        GPIO_setPadConfig(29, GPIO_PIN_TYPE_PULLUP);            //
        GPIO_setPinConfig(GPIO_29_GPIO29);                      //
        GPIO_setDirectionMode(29, GPIO_DIR_MODE_IN);            //


        GPIO_writePin(28, 1);                                   //
        GPIO_setPinConfig(GPIO_28_SCIRXDA);                     //
        GPIO_setDirectionMode(28, GPIO_DIR_MODE_IN);            //
        GPIO_setPadConfig(28, GPIO_PIN_TYPE_PULLUP);            //
        GPIO_setQualificationMode(28, GPIO_QUAL_ASYNC);         //

        SCI_performSoftwareReset(SCIA_BASE);                         //  SCI
        SCI_resetTxFIFO(SCIA_BASE);                                  // reset tx fifos
        HWREGH(SCIA_BASE + SCI_O_FFRX) |= SCI_FFRX_RXFFIENA;         // enable rx fifo int

    }
}

void InitGpioSci(void)
{
    //
    // GPIO28 is the SCI Rx pin.
    //
    GPIO_setPinConfig(GPIO_28_SCIRXDA);
    GPIO_setDirectionMode(28, GPIO_DIR_MODE_IN);
    GPIO_setPadConfig(28, GPIO_PIN_TYPE_STD);
    GPIO_setQualificationMode(28, GPIO_QUAL_ASYNC);

    //
    // GPIO29 is the SCI Tx pin.
    //
    GPIO_setPinConfig(GPIO_29_SCITXDA);
    GPIO_setDirectionMode(29, GPIO_DIR_MODE_OUT);
    GPIO_setPadConfig(29, GPIO_PIN_TYPE_STD);
    GPIO_setQualificationMode(29, GPIO_QUAL_ASYNC);
}

//
// initSCIAFIFO - Configure SCIA FIFO
//
void InitSCIAFIFO(void)
{
    SCI_performSoftwareReset(SCIA_BASE);            //  SCI

    SCI_setConfig(SCIA_BASE, DEVICE_LSPCLK_FREQ, 115200, (SCI_CONFIG_WLEN_8 |
                                                        SCI_CONFIG_STOP_ONE |
                                                        SCI_CONFIG_PAR_NONE));
    SCI_enableModule(SCIA_BASE);
    SCI_resetChannels(SCIA_BASE);
    SCI_enableFIFO(SCIA_BASE);

    SCI_enableInterrupt(SCIA_BASE, SCI_INT_RXFF);
    SCI_disableInterrupt(SCIA_BASE, SCI_INT_RXERR);
    SCI_clearInterruptStatus(SCIA_BASE, SCI_INT_RXFF | SCI_INT_TXFF);

    SCI_setFIFOInterruptLevel(SCIA_BASE, SCI_FIFO_TX1, SCI_FIFO_RX1);
    SCI_performSoftwareReset(SCIA_BASE);

    SCI_resetTxFIFO(SCIA_BASE);
    SCI_resetRxFIFO(SCIA_BASE);

}



//
void initCPUTimers(void)
{
    CPUTimer_setPeriod(CPUTIMER0_BASE, 0xFFFFFFFF);

    CPUTimer_setPreScaler(CPUTIMER0_BASE, 0);

    CPUTimer_stopTimer(CPUTIMER0_BASE);

    CPUTimer_reloadTimerCounter(CPUTIMER0_BASE);

    cpuTimer0IntCount = 0;

}

void configCPUTimer(uint32_t cpuTimer, float freq, float period)
{
    uint32_t temp;

    temp = (uint32_t)(freq / 1000000 * period);
    CPUTimer_setPeriod(cpuTimer, temp);

    CPUTimer_setPreScaler(cpuTimer, 0);

    CPUTimer_stopTimer(cpuTimer);
    CPUTimer_reloadTimerCounter(cpuTimer);
    CPUTimer_setEmulationMode(cpuTimer,
                              CPUTIMER_EMULATIONMODE_STOPAFTERNEXTDECREMENT);
    CPUTimer_enableInterrupt(cpuTimer);

    if (cpuTimer == CPUTIMER0_BASE)
    {
        cpuTimer0IntCount = 0;
    }
}


void JumptoApp(void)
{
    unsigned long  JumpAddress,JumpAddress1;

    JumpAddress  = *(volatile unsigned long*)(0x0008FFF1);
    JumpAddress1 = *(volatile unsigned long*)(0x0008FFEF);
    if(((JumpAddress & 0x0000ffff) != 0x0000ffff) && ((JumpAddress1 & 0x0000ffff) == 0x0000ffff))
    {
        CPUTimer_disableInterrupt(CPUTIMER0_BASE);

        Monitor[6]++;
        asm("   LB   0x0008FFF0" );
    }
    else
    {
        boot_time_out_en = 0;
        boot_time_out    = 2000;
    }
}

void Example_Error(Fapi_StatusType status)
{
    //  Error code will be in the status parameter
        __asm("    ESTOP0");
}

//
// End of File
//
