CCS-COMM_BOARD/Periphery.cpp

#include "Periphery.h"

Periphery::Periphery() : 
    _canb(canSpace::CANA),
    _digitalIO(),
    _zone6_ptr(reinterpret_cast<Uint16*>(0x100000)),
    _scib(ScibRegs),
    _modbusInitFlag(false),
    _modbusRegCounter(0),
    modbusRTU(CpuTimer2, _scib)
{
    _softVersion.DSP = 202;
    _softVersion.CPLD = 0;

    test_hmi_float_reg_400_test = 0;
    test_hmi_float_reg_401_test = 0;
    test_hmi_float_reg_402_test = 0;
    test_hmi_float_reg_403_test = 0;
    test_hmi_float_reg_404_test = 0;
}


void Periphery::config(){

    //--------------------------------------Init CAN interface----------------------------------------------------------
    _canb.initGpio();
    _canb.config();

    // Data Frame MBOX
    _canb.configRxMBox(canSpace::MODBUS_SETTINGS_MBOX, canSpace::MsgID(0x0), canSpace::MsgCtrlReg(0x6));   // Modbus settings
    _canb.configTxMBox(canSpace::MODBUS_DATA_COMM_TO_CPU_MBOX, canSpace::MsgID(0x29), canSpace::MsgCtrlReg(0x28)); // Send Modbus data to CPU
    _canb.configRxMBox(canSpace::MODBUS_DATA_CPU_TO_COMM_MBOX, canSpace::MsgID(0x28), canSpace::MsgCtrlReg(0x8));  // Receive Modbus data from CPU
    _canb.configTxMBox(canSpace::DIGITAL_INPUT_MBOX, canSpace::MsgID(0x30), canSpace::MsgCtrlReg(0x2));    // Receive DI
    _canb.configRxMBox(canSpace::DIGITAL_OUTPUT_MBOX, canSpace::MsgID(0x31), canSpace::MsgCtrlReg(0x2));   // Send DO

    // Remote frame MBOX
    _canb.configTxMBox(canSpace::COMM_VERSION_MBOX, canSpace::MsgID(0x1, false, true), canSpace::MsgCtrlReg(0));

    // Interrupts
    _canb.configSystemIsr(canSpace::I0EN_ENABLE |
                          canSpace::EPIM_ENABLE | canSpace::WLIM_ENABLE | canSpace::AAIM_ENABLE);


    //--------------------------------------Init XINTF interface----------------------------------------------------------
    InitXintf();


    //---------------------------------------Init DIO interface----------------------------------------------------------
    _digitalIO.setup(_zone6_ptr);
    _digitalIO.setMemoryOffset(interface::DISCRETE_DATA_OFFSET);


    //---------------------------------------Init SCI interface----------------------------------------------------------    
    DSP28335::SCISetup sciBSetup;
    sciBSetup.config.baudrate = SCIB_BAUDRATE_DEFAULT;
    sciBSetup.config.parity   = SCIB_PARITY_DEFAULT;
    sciBSetup.config.stopbits = SCIB_STOPBITS_DEFAULT;
    sciBSetup.config.lenght   = SCIB_LENGHT_DEFAULT;
    sciBSetup.gpio_setup      = SCIB_GPIO_SETUP_DEFAULT;

    _scib.setup(sciBSetup);


    //------------------------------------------Init Modbus----------------------------------------------------------
    MODBUSRTU::modbusSetup.gpio_re_de_setup = &DSP28335::GPIO::gpio_scib_re_de_setup;
    MODBUSRTU::modbusSetup.gpio_driver_enable = &DSP28335::GPIO::gpio_scib_re_de_set;
    MODBUSRTU::modbusSetup.gpio_receiver_enable = &DSP28335::GPIO::gpio_scib_re_de_clear;
    modbusRTU.setup(MODBUSRTU::modbusSetup);
}


Uint16 Periphery::getVersionFPGA(){
    Uint16 data;
    data = *_zone6_ptr + interface::SOFT_VERSION_OFFSET;
    return data;
}


void Periphery::updateVersionFPGA(){
    _softVersion.CPLD = getVersionFPGA() & 0x3FF;   // no more than 1023. (9.9.9) should be limit
    _message.mdl.word.LOW_WORD = _softVersion.DSP;
    _message.mdl.word.HI_WORD = _softVersion.CPLD;
    _canb.updateTXMessage(canSpace::COMM_VERSION_MBOX, _message);
}


void Periphery::processDigitalInput(){
    Uint16 data = 0;
    _digitalIO.readDigitalIO(data);
    _canb.transmitMsg(canSpace::DIGITAL_INPUT_MBOX, (data));
}


void Periphery::processDigitalOutput(){
    if(_canb.isNewMessage(canSpace::DIGITAL_OUTPUT_MBOX)){
        _canb.receiveMsg(canSpace::DIGITAL_OUTPUT_MBOX, _message);
        Uint16 data = _message.mdl.word.LOW_WORD;
        _digitalIO.writeDigitalIO(data);
    }
}


void Periphery::init_modbus_table(){
    modbusRTU.setInputRegsAddr(400);
    modbusRTU.setOutputRegsAddr(400);

    modbusRTU.addInputReg(0, test_hmi_float_reg_400_test);
    modbusRTU.addInputReg(1, test_hmi_float_reg_401_test);
    modbusRTU.addInputReg(2, test_hmi_float_reg_402_test);
    modbusRTU.addInputReg(3, test_hmi_float_reg_403_test);
    modbusRTU.addInputReg(4, test_hmi_float_reg_404_test);

    modbusRTU.addOutputReg(0, test_hmi_float_reg_400_test);
    modbusRTU.addOutputReg(1, test_hmi_float_reg_401_test);
    modbusRTU.addOutputReg(2, test_hmi_float_reg_402_test);
    modbusRTU.addOutputReg(3, test_hmi_float_reg_403_test);
    modbusRTU.addOutputReg(4, test_hmi_float_reg_404_test);
}


bool Periphery::isModbusInit() const{
    return _modbusInitFlag;
}


void Periphery::receiveModbusParameters(){
    if (!_modbusInitFlag && (_canb.isNewMessage(canSpace::MODBUS_SETTINGS_MBOX))) { // TODO check for init is incorect here maybe
        _canb.receiveMsg(canSpace::MODBUS_SETTINGS_MBOX, _message);

        MODBUSRTU::modbusConfiguration.node_id = _message.mdl.byte.BYTE0;
        MODBUSRTU::modbusConfiguration.config.lenght = static_cast<DSP28335::SCICharLenght>(_message.mdl.byte.BYTE1);
        MODBUSRTU::modbusConfiguration.config.baudrate = static_cast<DSP28335::SCIBaudRate>(_message.mdl.word.LOW_WORD);
        MODBUSRTU::modbusConfiguration.config.parity = static_cast<DSP28335::SCIParity>(_message.mdh.byte.BYTE4);
        MODBUSRTU::modbusConfiguration.config.stopbits = static_cast<DSP28335::SCIStopBits>(_message.mdh.byte.BYTE5);

        modbusRTU.configure(MODBUSRTU::modbusConfiguration);

        _modbusInitFlag = true; // TODO modbus init function must be here
        _modbusRegCounter = 0;
    }
}


void Periphery::sendModbusDataToCPU(){
    _message.mdl.all = 0;   // TODO delete maybe?
    _message.mdh.all = 0;

    WEINBUS::WeinbusTableRegister reg;
    reg = modbusRTU._dataHandler.outputRegisters.get_register_cursor(_modbusRegCounter);

    if(modbusRTU._dataHandler.outputRegisters.address_range(reg.get_address())){
        _message.mdl.all = reg.get_address();
        reg.read(_message.mdh.all);
        
        _modbusRegCounter++;
    }
    else {
        _modbusRegCounter = 0;
        reg = modbusRTU._dataHandler.outputRegisters.get_register_cursor(_modbusRegCounter);

        _message.mdl.all = reg.get_address();
        reg.read(_message.mdh.all);

        _modbusRegCounter++;
    }

    _canb.transmitMsg(canSpace::MODBUS_DATA_COMM_TO_CPU_MBOX, _message);
}


void Periphery::receiveCpuModbusData(){
    if (_canb.isNewMessage(canSpace::MODBUS_DATA_CPU_TO_COMM_MBOX)) { // TODO check for init is incorect here maybe
        _canb.receiveMsg(canSpace::MODBUS_DATA_CPU_TO_COMM_MBOX, _message);

        WEINBUS::WeinbusTableRegister reg;

        uint32_t addr = _message.mdl.all;
        reg = modbusRTU._dataHandler.inputRegisters.get_register_cursor(addr - modbusRTU._dataHandler.inputRegisters.get_start_address());
        reg.write_data(_message.mdh.all);
    }
}