charge_controller_target_mspm0L1304/main_target.c

#include "src/battery_data/battery.h"
#include "ti_msp_dl_config.h"
//#include "ti/driverlib/dl_i2c.h"
#include <stdio.h>
#include "src/peripherals/adc/adc.h"
#include "src/peripherals/adc/adc_interface.h"
#include "src/i2c_comm/mcu_slave_interface.h"
#include "src/interfaces/i2c_controller_interface.h"


#define DELAY_CYCLE  (100000000)

volatile bool mcu_CommandPending= false;

/*
Scans all the addresses of the peripherals:
*/
/*void I2C_scanBus(I2C_Regs *i2c) {
    printf("1");
    // **Step 1: Reset I2C Controller if Busy**
    if (DL_I2C_getControllerStatus(i2c) & DL_I2C_CONTROLLER_STATUS_BUSY_BUS) {
        printf("I2C Bus Busy! Resetting I2C Controller...\n");
        DL_I2C_disableController(i2c);  // Disable I2C
        delay_cycles(20000);
        DL_I2C_enableController(i2c);   // Re-enable I2C
        delay_cycles(20000);
    }
    uint32_t i2c_status;
    // **Step 2: Scan I2C Bus**
    for (uint8_t addr = 0x08; addr < 0x78; addr++) {  // Valid I2C Address Range
        printf("Scanning 0x%02X\n", addr);
        DL_I2C_startControllerTransfer(i2c, addr, DL_I2C_CONTROLLER_DIRECTION_RX, 1);
        delay_cycles(5000);

        if (addr != 0x60 && addr != 0x68) {
            continue;
        }

        i2c_status = DL_I2C_getControllerStatus(i2c);
        printf("DL_I2C_getControllerStatus(i2c): %d\n", i2c_status);
        printf("busy?: %d\n", (i2c_status & DL_I2C_CONTROLLER_STATUS_BUSY));
        printf("error?: %d\n", (i2c_status & DL_I2C_CONTROLLER_STATUS_ERROR));
        printf("addr_ack?: %d\n", (i2c_status & DL_I2C_CONTROLLER_STATUS_ADDR_ACK));
        printf("data_ack?: %d\n", (i2c_status & DL_I2C_CONTROLLER_STATUS_DATA_ACK));
        printf("arb_lost?: %d\n", (i2c_status & DL_I2C_CONTROLLER_STATUS_ARBITRATION_LOST));
        printf("idle?: %d\n", (i2c_status & DL_I2C_CONTROLLER_STATUS_IDLE));
        printf("busy_bus?: %d\n", (i2c_status & DL_I2C_CONTROLLER_STATUS_BUSY_BUS));
        
        if (!(DL_I2C_getControllerStatus(i2c) & DL_I2C_CONTROLLER_STATUS_ERROR)) {
            printf("Device found at: 0x%02X\n", addr);
            DL_I2C_disableController(i2c);
            DL_I2C_enableController(i2c);
        }else {
            // Clear the error by resetting the I2C controller
            printf("Device not found...\n");
            DL_I2C_disableController(i2c);
            DL_I2C_enableController(i2c);
        }
    }

    //printf("I2C Scan Complete!\n");
}
*/

void I2C_controller_INST_IRQHandler(void) {
  // printf("I2C Interrupt Triggered to ADC!\n");
  switch (DL_I2C_getPendingInterrupt(I2C_controller_INST)) { 
    
    case DL_I2C_IIDX_CONTROLLER_START:
        controllerRxPackage.count = 0;
        
        DL_I2C_flushControllerTXFIFO(I2C_controller_INST);
        break;

    case DL_I2C_IIDX_CONTROLLER_RXFIFO_TRIGGER:
        /* Store bytes received from target in Rx Msg Buffer */
        while (DL_I2C_isControllerRXFIFOEmpty(I2C_controller_INST) != true) {
            if (controllerRxPackage.count < controllerRxPackage.len) {
                controllerRxPackage.packet[controllerRxPackage.count] =
                    DL_I2C_receiveControllerData(I2C_controller_INST);
                    ;
                controllerRxPackage.count++;

            } else {
                /* Ignore and remove from FIFO if the buffer is full */
                DL_I2C_receiveControllerData(I2C_controller_INST);
            }
        }
            if (controllerRxPackage.count >= controllerRxPackage.len) {
            controllerRxPackage.complete = true;
            DL_I2C_enableInterrupt(I2C_controller_INST,
                                    DL_I2C_INTERRUPT_CONTROLLER_STOP);
            }
        break;
    /*TRANSMIT data to ADC*/
    case DL_I2C_IIDX_CONTROLLER_TXFIFO_TRIGGER:
        if (controllerTxPackage.count < controllerTxPackage.len) {
            DL_I2C_fillControllerTXFIFO(I2C_controller_INST,
                                        &controllerTxPackage.packet[controllerTxPackage.count],
                                        (controllerTxPackage.len - controllerTxPackage.count));
            controllerTxPackage.count++;
        } else {
            /*Prevent overflow and just ignore data*/
            DL_I2C_fillTargetTXFIFO(I2C_controller_INST, (uint8_t[]){0x00}, 1);
            controllerTxPackage.complete = true;
        }
        if(controllerTxPackage.count >= controllerTxPackage.len){
            controllerTxPackage.complete= true;
        }
        break;
    /*STOP condition*/
    case DL_I2C_IIDX_CONTROLLER_STOP:
        controllerTxPackage.complete = true;
        controllerRxPackage.complete = true;
        break;
    case DL_I2C_IIDX_CONTROLLER_ARBITRATION_LOST:
        break;
    case DL_I2C_IIDX_CONTROLLER_NACK:
        break;
    default:
        break;
    }
}

/**** Interrupt for Pi to MCU ****/
void I2C_target_INST_IRQHandler(void) {

  uint32_t status = DL_I2C_getPendingInterrupt(I2C_target_INST);
  switch (status) {
  case DL_I2C_IIDX_TARGET_START:
    DL_I2C_flushTargetTXFIFO(I2C_target_INST);
    break;
  case DL_I2C_IIDX_TARGET_STOP:
    mcu_CommandPending= true;
    DL_I2C_flushTargetTXFIFO(I2C_target_INST);
    DL_I2C_flushTargetRXFIFO(I2C_target_INST);
    break;
  case DL_I2C_IIDX_TARGET_RXFIFO_TRIGGER:
    if (DL_I2C_isTargetRXFIFOEmpty(I2C_target_INST)) {
      return;
    }
    mcu_CommandPending= true;
    break;
  case DL_I2C_IIDX_TARGET_TXFIFO_TRIGGER:
    mcu_CommandPending= true;
    break;
  case DL_I2C_IIDX_TARGET_ARBITRATION_LOST:
    break;
  default:
    break;
  }
}

int main(void)

{   
    SYSCFG_DL_init();
    Battery_Init();
    //I2C_scanBus(I2C_controller_INST);
    NVIC_EnableIRQ(I2C_controller_INST_INT_IRQN);
    NVIC_EnableIRQ(I2C_target_INST_INT_IRQN);
    
    while (1) {

        if(mcu_CommandPending){
            printf("Step 1: Calling MCU target interrupt\n");
            mcu_i2c_handle(I2C_target_INST);
            mcu_CommandPending= false;
            continue;
        }
        
        for(uint8_t slot= 0; slot< NUM_SLOTS; slot++){
            for(uint8_t channel= 0; channel< 2; channel++){
                updateADCReading_multichannel(slot, channel);
            }
        }
        
        delay_cycles(DELAY_CYCLE);
        
    }
}