CCS-COMM_BOARD/main.cpp

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

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


//Functions declarations
void idle_loop(void);

interrupt void cpu_timer0_isr(void);
interrupt void cpu_timer1_isr(void);
interrupt void canb_isr(void);
interrupt void canb_box_isr(void);

canSpace::CAN canTest(canSpace::CANB);

interface::DigitalIO digitalIO;
interface::DigitalIODataRegister digitalInputReg;
interface::DigitalIODataRegister digitalOutputReg;

// RX
canSpace::CANMessage DOMessage;
canSpace::CANMessage messageSettings;
canSpace::CANMessage MODBUS_CPU_COMM_Message;

// TX
canSpace::CANMessage DIMessage;
canSpace::CANMessage MODBUS_COMM_CPU_Message;
canSpace::CANMessage SoftVersionMessage;
Uint32 array[25] = {0};

struct SoftwareVersion{
    Uint16 DSP;
    Uint16 CPLD;
};

SoftwareVersion softVersion = { .DSP = 101, .CPLD = 202 };

volatile Uint16 infCounter = 0;
volatile Uint16 canISRcounter = 0;
volatile Uint16 canBoxISRcounter = 0;
volatile Uint16 testCounter = 0;

volatile bool init = true;
volatile bool startTX = false;
volatile bool update = false;
volatile bool sendRemote = false;

Uint16 modbusInit = 0;
int32 testVar = 0;


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

    InitSysCtrl();

    DINT;

    InitPieCtrl();

    IER = 0x0000;
    IFR = 0x0000;

    InitPieVectTable();

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

    InitCpuTimers();
    ConfigCpuTimer(&CpuTimer0, 150, 1000);  // 1ms
    ConfigCpuTimer(&CpuTimer1, 150, 5000);  // 5ms

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

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

    canTest.initGpio();
    canTest.config();
    canTest.configTxMBox(canSpace::DIGITAL_INPUT_MBOX, canSpace::MsgID(0x30), canSpace::MsgCtrlReg(0x3));

    DIMessage.dataLength = 3;
    DIMessage.mdl.byte.BYTE0 = 0x11;
    DIMessage.mdl.byte.BYTE1 = 0x22;
    DIMessage.mdl.byte.BYTE2 = 0x33;

    MODBUS_COMM_CPU_Message.dataLength = 6;
    MODBUS_COMM_CPU_Message.mdl.byte.BYTE0 = 0xA;
    MODBUS_COMM_CPU_Message.mdl.byte.BYTE1 = 0xB;
    MODBUS_COMM_CPU_Message.mdl.byte.BYTE2 = 0xC;
    MODBUS_COMM_CPU_Message.mdl.byte.BYTE3 = 0xD;
    MODBUS_COMM_CPU_Message.mdh.byte.BYTE4 = 0xE;
    MODBUS_COMM_CPU_Message.mdh.byte.BYTE5 = 0xF;

    SoftVersionMessage.dataLength = 2;
    SoftVersionMessage.mdl.byte.BYTE0 = softVersion.DSP;
    SoftVersionMessage.mdl.byte.BYTE0 = softVersion.CPLD;

    digitalIO.setup((Uint16*)0x4000);

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

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

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

void idle_loop()
{
    while (true)
    {
        infCounter++;

        // ожидать получения данных при remote frame
        // get cpld version with xintf here
        // if (init){
        //     init = false;
        //     // в main положить
        //     canTest.updateTXMessage(canSpace::COMM_VERSION_MBOX, SoftVersionMessage);
        // }

        // if (canTest.isNewMessage(canSpace::MODBUS_SETTINGS_MBOX)){
        //     canTest.receiveMsg(canSpace::MODBUS_SETTINGS_MBOX, messageSettings);
        //     modbusInit++;
        // }

    }//end while

}//end idle_loop()


interrupt void cpu_timer0_isr(void)
{
    CpuTimer0.InterruptCount++;
    // if(canTest.isNewMessage()){
    //     canTest.receiveMsg(canSpace::DIGITAL_OUTPUT_MBOX, DOMessage);
    //     canTest.receiveMsg(canSpace::MODBUS_DATA_CPU_TO_COMM_MBOX, MODBUS_CPU_COMM_Message);
    //     testCounter++;
    // }

    // digitalOutputReg.all = digitalOutputReg.all;
    // digitalIO.writeDigitalIO(digitalOutputReg.all);

    PieCtrlRegs.PIEACK.all |= PIEACK_GROUP1;
}//end


interrupt void cpu_timer1_isr(){
    CpuTimer1.InterruptCount++;

    // digitalIO.readDigitalIO(DIMessage.mdl.all);
    // digitalIO.readDigitalIO(digitalInputReg.all);
    // DIMessage.mdl.all = digitalInputReg.all;
    canTest.transmitMsg(canSpace::DIGITAL_INPUT_MBOX, DIMessage);
}


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 = 256ul;
    }

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

    PieCtrlRegs.PIEACK.all |= PIEACK_GROUP9;
}

interrupt void canb_box_isr(void){
    canBoxISRcounter++;

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

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

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

    // 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;
}