charge_controller_MSPM0G3507/main.c

#include "ti/driverlib/dl_wwdt.h"
#include "ti/driverlib/m0p/dl_core.h"
#include "ti_msp_dl_config.h"
#include "src/pi/i2c_pi_target.h"
#include "src/controller/controller.h"
#include "ti/driverlib/dl_i2c.h"
#include "src/battery_data/battery.h"
#include "src/cc_cv_charging.h"
#include <stdio.h>
#include "src/battery_data/battery.h"
#include "mock_setup.h"


//define the varibales:
volatile bool mcuSendCommand = false;
volatile bool picommandPending = false;
volatile bool watchdog_triggered= false;

// Interrupt for I2C instance -> MCU to Target

void I2C_1_INST_IRQHandler(void)
{
    switch (DL_I2C_getPendingInterrupt(I2C_1_INST)) 
    {   
        case DL_I2C_IIDX_CONTROLLER_START:
            DL_I2C_flushControllerRXFIFO(I2C_1_INST);
            DL_I2C_flushControllerTXFIFO(I2C_1_INST);
            break;

        case DL_I2C_IIDX_CONTROLLER_RXFIFO_TRIGGER:
            if (DL_I2C_isTargetRXFIFOEmpty(I2C_1_INST)) {
                return;
            }
            mcuSendCommand= true;
            break;

        case DL_I2C_IIDX_CONTROLLER_TXFIFO_TRIGGER:
            /* Fill TX FIFO with bytes to send */
            mcuSendCommand = true;
            
            break;
        case DL_I2C_IIDX_CONTROLLER_STOP:
            mcuSendCommand = true;
        case DL_I2C_IIDX_CONTROLLER_ARBITRATION_LOST:
        case DL_I2C_IIDX_CONTROLLER_NACK:
            break; 
        default:
            break;
    }
}


void I2C_0_INST_IRQHandler(void)
{
    switch (DL_I2C_getPendingInterrupt(I2C_0_INST)) 
    {   
        case DL_I2C_IIDX_TARGET_START:
            DL_I2C_flushTargetTXFIFO(I2C_0_INST);
            break;

        case DL_I2C_IIDX_TARGET_RXFIFO_TRIGGER:
            if (DL_I2C_isTargetRXFIFOEmpty(I2C_0_INST)) {
                return;
            }
            picommandPending = true;
            break;

        case DL_I2C_IIDX_TARGET_TXFIFO_TRIGGER:
            /* Fill TX FIFO with bytes to send */
            picommandPending = true;
            break;
        case DL_I2C_IIDX_TARGET_STOP:
            picommandPending = true;
            //DL_I2C_flushTargetTXFIFO(I2C_0_INST);
            //DL_I2C_flushTargetRXFIFO(I2C_0_INST);
            break;
        case DL_I2C_IIDX_TARGET_ARBITRATION_LOST:
            break; 
        default:
            break;
    }
}
/*Timer feeds the WWDT. the initialization of the Timer is done in the config.h file
Timer is configured to reset the watchdog timer periodically.
LFCLK is sourced from the internal low frequency oscilloscope. 
The device remains in STANDBY mode while waiting for an interrupt
*/

//interrupt added for Windows Watchdog Timer:
void GROUP0_IRQHandler(void)
{
    switch (DL_Interrupt_getPendingGroup(DL_INTERRUPT_GROUP_0)) {
        case DL_INTERRUPT_GROUP0_IIDX_WWDT0:
            if (DL_WWDT_getPendingInterrupt(WWDT0)) {
                //Clears the interrupt
                DL_WWDT_clearInterruptStatus(WWDT0);
                //Resets the timer:
                DL_WWDT_reset(WWDT0);
                //Set the flag to True
                watchdog_triggered= true;
                //how to handle in the case of failure?
            }
        default:
            break;
    }
}

int main(void)
{  
    SYSCFG_DL_init();
    Battery_Init();
    //dynamic addressing function call for Pi
    dynamic_gpio_addressing();
    /* Enable WWDT interrupts on device */
    NVIC_EnableIRQ(WWDT0_INT_IRQN);
    //Interrupt routine for Pi
    NVIC_EnableIRQ(I2C_0_INST_INT_IRQN);
    //Interrupt for target mcu
    NVIC_EnableIRQ(I2C_1_INST_INT_IRQN);
    //DL_GPIO_setPins(GPIO_Battery_Discharging_PORT, GPIO_Battery_Discharging_PIN_PB7_PIN);
    while(1)
    {   
        if(watchdog_triggered){
            printf("ERROR: ***WATCHDOG TRIGGERED***\n");
            //Resetting the flags to its original state
            picommandPending= false;
            mcuSendCommand= false;
            watchdog_triggered= false;
            //Reinitialize the system
            


        }

        if(picommandPending)
        {   printf("Pi Interrupt Triggered.\n");
            pi_i2c_mcu();
            picommandPending = false;
        }
        if(mcuSendCommand){   
            printf("MCU Interrupt Triggered.\n");
            for(uint8_t i=0; i<NUM_SLOTS; i++){
                controller_GetBatteryMeasurement(TARGET_MCU_ADDRESS, i);
            }
            mcuSendCommand = false;
            
        }
        
        for(uint8_t slot_id= 0; slot_id< NUM_SLOTS; slot_id++){
            //Reading battery state:
            Battery_ReadState(slot_id);
            printf("STATUS ***Reading Battery Measurement for Slot ID %u:: Battery State: %u, Voltage: %u, Current: %u, Temperature: %u, Slot state: %u***\n", slot_id, battery_data[slot_id].battery_state, battery_data[slot_id].battery_measurement.voltage,
            battery_data[slot_id].battery_measurement.current, battery_data[slot_id].battery_measurement.temperature, battery_data[slot_id].battery_measurement.slot_state);
            //If target received battery limits from Pi then start charging:       
            if(battery_data[slot_id].batteryLimitReceived){
                printf("STATUS ***Battery Limits: Slot: %d, Max Voltage:%u, Min Voltage:%u, "
                "Cutoff Current: %u, Capacitance:%u, Charge Fraction:%u***\n", slot_id, battery_data[slot_id].max_voltage,
                battery_data[slot_id].min_voltage, battery_data[slot_id].cut_off_current,
                battery_data[slot_id].capacitance, battery_data[slot_id].charge_fraction);
                CC_CV_ControlCharging(slot_id, 50);
            }
     
            delay_cycles(MEASUREMENT_CHECK_INTERVAL);
        
        }
        
    }
}