charge_controller_MSPM0G3507/main.c

#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;
volatile uint8_t current_command= 0x06;
volatile bool txCommandSent= 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:
            break;

        case DL_I2C_IIDX_CONTROLLER_RXFIFO_TRIGGER:
            mcuSendCommand= true;
            
            while(DL_I2C_isControllerRXFIFOEmpty(I2C_1_INST) != true) {
                if(rxPacket.rxCount < rxPacket.rxLen){
                     //Get byte from the I2C RX FIFO of the target
                    rxPacket.rxBuffer[rxPacket.rxCount++]= DL_I2C_receiveControllerData(I2C_1_INST);
                    //rxPacket.rxCount++;
                }else{
                    DL_I2C_receiveControllerData(I2C_1_INST);

                }
            }
           
            if(rxPacket.rxCount >= rxPacket.rxLen){
                //rxPacket.rxComplete= true;
                DL_I2C_enableInterrupt(I2C_1_INST, DL_I2C_INTERRUPT_CONTROLLER_STOP);
                rxPacket.rxComplete= true;
            }
            break;
            
        case DL_I2C_IIDX_CONTROLLER_TXFIFO_TRIGGER:
            /* Fill TX FIFO with bytes to send */
            mcuSendCommand = true;
            txPacket.txBuffer[0] = (0<<4) | (CMD_GET_MEASUREMENT & 0x0F);  
            DL_I2C_fillControllerTXFIFO(I2C_1_INST, (uint8_t *)&txPacket.txBuffer[0], 1);      
            txPacket.txComplete= true;   
            break;

        case DL_I2C_IIDX_CONTROLLER_STOP:
            mcuSendCommand = true;
            rxPacket.rxComplete= true;
            txPacket.txComplete= true;
            DL_I2C_flushControllerRXFIFO(I2C_INST);
            DL_I2C_flushControllerTXFIFO(I2C_INST);
            break;

        case DL_I2C_IIDX_CONTROLLER_ARBITRATION_LOST:
            break;
        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;
    }
}


int main(void)
{  
    SYSCFG_DL_init();
    Battery_Init();
    //dynamic addressing function call for Pi
    dynamic_gpio_addressing();
    //Interrupt routine for Pi
    NVIC_EnableIRQ(I2C_0_INST_INT_IRQN);
    //Interrupt for target mcu
    NVIC_EnableIRQ(I2C_1_INST_INT_IRQN);

    while(1)
    {   
        if(picommandPending)
        {   //printf("Pi Interrupt Triggered.\n");
            pi_i2c_mcu();
            picommandPending = false;
        }
        if(mcuSendCommand){   
            //printf("MCU Interrupt Triggered.\n");
            //getBatteryMeasurement_test();
            mcuSendCommand = false;
            
        }
        
        for(uint8_t slot_id= 0; slot_id< NUM_SLOTS; slot_id++){
            getBatteryMeasurement_test();
            //controller_GetBatteryMeasurement(slot_id);
            //Reading the battery measurement:
            //printf("mainloop slot?\n");
            /*if (!was_true) {
                printf("executing?\n");
                controller_GetBatteryMeasurement(slot_id);
                was_true = 
                printf("true? %d\n", was_true);
            }*/
            //Reading battery state:
            Battery_StateCondition(slot_id);
            //Reading Charging state condition
            //CC_CV_ControlCharging(slot_id, 50);
            //printf("Battery Charging State: %u\n", battery_data[slot_id].battery_charging_state);
            //printf("Battery Limit Received: %u\n", battery_data[slot_id].batteryLimitReceived);
            //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("Battery Limits: Slot: %d, Max Voltage:%u, Min Voltage:%u, "
                "Cutoff Current: %u, Capacitance:%u, Charge Fraction:%u, Cycle Number: %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, battery_data[slot_id].cycle_number);
                
            }
     
            delay_cycles(MEASUREMENT_CHECK_INTERVAL);
        
        }
        
    }
}