/* Main Source File */ #include "adc.h" #include "battery.h" #include "cc_cv_charging.h" #include "dac.h" #include "i2c_target.h" #include "multiplexer.h" #include "ti/comm_modules/i2c/controller/i2c_comm_controller.h" #include "ti/devices/msp/peripherals/hw_dac12.h" #include "ti/driverlib/dl_adc12.h" #include "ti/driverlib/dl_gpio.h" #include "ti/driverlib/dl_i2c.h" #include "ti/driverlib/m0p/dl_core.h" #include "ti_msp_dl_config.h" #include #include #include #include I2C_Instance gI2C; I2C_ResponseInfo gResponse; BatteryData battery_data; /*Interrupt for MCU -> ADC * CASE: DL_I2C_IIDX_CONTROLLER_RX_DONE: ADC Reception Complete - ADC has finished sending data and it's fully received. - gI2C.rxMsg.len = gI2C.rxMsg.ptr: - Stores the received data length in the response buffer. - I2C_decodeResponse(): - Decodes the received response. - gI2C.status = I2C_STATUS_RX_COMPLETE: - Marks reception is complete. * CASE: DL_I2C_IIDX_CONTROLLER_TX_DONE: Data Transmit to ADC complete - DL_I2C_disableInterrupt(..): Disables the TXFIFO interrupt since data is now sent * CASE: DL_I2C_IIDX_CONTROLLER_RXFIFO_TRIGGER: Receive Data in FIFO - The I2C Receive FIFO has data ready to be read. - while (DL_I2C_isControllerRXFIFOEmpty(...) != true): Loops until the RX FIFOis empty (READ all available bytes) - Inside the while loop: - If buffer has SPACE, store the received byte - Prints each received byte in HEXADECIMAL format for debugging - IF BUFFER is FULL, avoids OVERFLOW by discarding extra byte. * CASE: DL_I2C_IIDX_CONTROLLER_TXFIFO_TRIGGER: Transmit Data in FIFO - If there is still data to send: gI2C.txMsg.ptr += DL_I2C_fillControllerTXFIFO(I2C_controller_INST, &gI2C.txMsg.buffer[gI2C.txMsg.ptr], gI2C.txMsg.len - gI2C.txMsg.ptr); */ void I2C_controller_INST_IRQHandler(void) { // printf("I2C Interrupt Triggered to ADC!\n"); switch (DL_I2C_getPendingInterrupt(I2C_controller_INST)) { /*START Condition*/ case DL_I2C_IIDX_CONTROLLER_START: // gTxADCcount= 0; gRxADCcount = 0; DL_I2C_flushControllerTXFIFO(I2C_controller_INST); break; case DL_I2C_IIDX_CONTROLLER_RXFIFO_TRIGGER: gI2C.status = I2C_STATUS_RX_INPROGRESS; /* Store bytes received from target in Rx Msg Buffer */ while (DL_I2C_isControllerRXFIFOEmpty(I2C_controller_INST) != true) { if (gRxADCcount < gRxADClen) { gRxPacket[gRxADCcount] = DL_I2C_receiveControllerData(I2C_controller_INST); printf("Received Byte[%d]: 0x%02X\n", gRxADCcount, gRxPacket[gRxADCcount]); // Debug print gRxADCcount++; } else { // printf("ERROR: RX Buffer Overflow! ptr=%d MAX_BUFFER_SIZE=%d\n", // gI2C.rxMsg.ptr, MAX_BUFFER_SIZE); /* Ignore and remove from FIFO if the buffer is full */ DL_I2C_receiveControllerData(I2C_controller_INST); } } if (gRxADCcount >= gRxADClen) { // printf("ADC Bytes Received!\n"); gRxComplete = true; DL_I2C_enableInterrupt(I2C_controller_INST, DL_I2C_INTERRUPT_CONTROLLER_STOP); } break; /*TRANSMIT data to ADC*/ case DL_I2C_IIDX_CONTROLLER_TXFIFO_TRIGGER: // printf("TX FIFO with data!\n"); gI2C.status = I2C_STATUS_TX_INPROGRESS; if (gTxADCcount < gTxADClen) { gTxADCcount += DL_I2C_fillControllerTXFIFO(I2C_controller_INST, &gTxPacket[gTxADCcount], (gTxADClen - gTxADCcount)); } else { /*Prevent overflow and just ignore data*/ DL_I2C_fillTargetTXFIFO(I2C_controller_INST, (uint8_t[]){0x00}, 1); gTxComplete = true; } // DL_I2C_flushControllerTXFIFO(I2C_controller_INST); break; /*STOP condition*/ case DL_I2C_IIDX_CONTROLLER_STOP: gTxComplete = true; gRxComplete = true; // printf("I2C Stop Detected- RX Complete"); break; case DL_I2C_IIDX_CONTROLLER_ARBITRATION_LOST: // printf("Interrupt index for I2C controller Arbitration Lost!\n"); break; case DL_I2C_IIDX_CONTROLLER_NACK: // printf("I2C NACK Received\n"); if ((gI2C.status == I2C_STATUS_RX_STARTED) || (gI2C.status = I2C_STATUS_TX_STARTED)) { gI2C.status = I2C_STATUS_ERROR; } break; default: break; } } /**** Interrupt for Pi to MCU ****/ void I2C_target_INST_IRQHandler(void) { // printf("I2C Interrupt Triggered to MCU (TARGET)!\n"); uint8_t receivedCommand = 0; uint32_t status = DL_I2C_getPendingInterrupt(I2C_target_INST); // ADC_PARAMS params; switch (status) { /* START condition detected */ case DL_I2C_IIDX_TARGET_START: piTxCount = 0; piRxCount = 0; piTxComplete = false; DL_I2C_flushTargetTXFIFO(I2C_target_INST); break; /* STOP condition detected */ case DL_I2C_IIDX_TARGET_STOP: piTxComplete = true; piRxComplete = true; DL_I2C_flushTargetTXFIFO(I2C_target_INST); break; /* TX FIFO trigger (Pi is reading data from MCU) */ /* GET battery status is triggered when command is 0x01 - Pi on request of 0x01 will get a response of the battery status for all the slots - Battery_StateUpdate function is called, which in turn calls the Battery_ReadState funtion to set the state of the batteries -Pi on command of [0x02, slot_id] will GET the 'Battery Data' which is voltage, current and temperature for a given slot. - MCU reads the slot_id from Pi using DL_I2C_receiveTargetData() - piTxCount is set to 0 - piTxLen is the sizeof BatteryData struct which is 7 bytes - If the requested slot is correct then: - battery pointer variable points to the memory of the requested slot - the values of voltage, current and temperature are then stored in battery_data struct - Once the values are in BatteryData struct we wait for the bus to be free - Next we send the BatteryData to Pi using DL_I2C_fillTargetRXFIFO() - Reset the RX counter for the next data. */ case DL_I2C_IIDX_TARGET_TXFIFO_TRIGGER: break; if (!DL_I2C_isTargetRXFIFOEmpty(I2C_target_INST)) { receivedCommand = DL_I2C_receiveTargetData(I2C_target_INST); // printf("Received Command: 0x%02X\n", receivedCommand); else { /* * Fill FIFO with 0x00 if more data is requested than expected piTxLen */ while (DL_I2C_transmitTargetDataCheck(I2C_target_INST, 0x00) != false) ; } piTxComplete = true; } else if (receivedCommand == CMD_GET_BATTERY_DATA) { uint8_t requestedSlot = DL_I2C_receiveTargetData(I2C_target_INST); while (DL_I2C_getTargetStatus(I2C_target_INST) & DL_I2C_TARGET_STATUS_BUS_BUSY) ; // printf("Battery Data Requested for Slot %d!\n", requestedSlot); piTxCount = 0; piTxLen = sizeof(BatteryData); BatteryData battery_data; if (requestedSlot < NUM_SLOTS) { Battery *battery = &batteries[requestedSlot]; battery_data.slot_id = battery->slot_id; battery_data.voltage = battery->voltage; battery_data.current = battery->current; battery_data.temperature = battery->temperature; while (DL_I2C_getTargetStatus(I2C_target_INST) & DL_I2C_TARGET_STATUS_BUS_BUSY) ; DL_I2C_fillTargetTXFIFO(I2C_target_INST, (uint8_t *)&battery_data, sizeof(BatteryData)); // piTxCount += DL_I2C_fillTargetTXFIFO(I2C_target_INST, // (uint8_t*)&battery_data, piTxLen); piTxComplete = true; while (DL_I2C_getTargetStatus(I2C_target_INST) & DL_I2C_TARGET_STATUS_BUS_BUSY) ; if (piTxCount >= piTxLen) { piTxComplete = true; piTxCount = 0; } } else { // printf("Invalid Slot ID: %d\n.", requestedSlot); } } } break; /* TARGET_Rx FIFO trigger (Pi is writing data to MCU) */ /*Pi SET battery data limits for each slot, where: - RXFIFO buffer is filled if the command from Pi is 0x03 - Creating a temporary buffer named ´rxbuffer´ - sizeof(BatteryLimitMsg): 11 bytes (1 byte: slot_id, 2 bytes: min_voltage; max_voltage; cut_off_current; capacitance; charge_fraction) - rx_buffer stores the data from Pi. - if all the expected bytes are received from Pi then, - memcpy() to copy the block of address from the temporary buffer to the BatteryLimitMsg structure - Why?, A: It copies the specified number of bytes from one memory location to another regardless of the type of the data stored. - verify if the received slot_id is less than NUM_SLOTS, where slot_id count starts from 0 then: - create a pointer variable for 'Battery' - battery_limits.slot_id: index of the battery slot to be updated - &batteries[battery_limits.slot_id]: gets the memory address of the battery in that slot - Accessing the structure members of Battery using -> operator. This allows efficient access to the structure's members without directly using the structure variable. */ case DL_I2C_IIDX_TARGET_RXFIFO_TRIGGER: if (!DL_I2C_isTargetRXFIFOEmpty(I2C_target_INST)) { receivedCommand = DL_I2C_receiveTargetData(I2C_target_INST); if (receivedCommand == CMD_SET_BATTERY_LIMIT) { uint8_t rx_buffer[sizeof(BatteryLimitMsg)]; uint8_t index = 0; while (!DL_I2C_isTargetRXFIFOEmpty(I2C_target_INST)) { if (index < sizeof(BatteryLimitMsg)) { rx_buffer[index] = DL_I2C_receiveTargetData(I2C_target_INST); // printf("Received Byte[%d]: 0x%02X\n", index, rx_buffer[index]); index++; } else { DL_I2C_receiveTargetData(I2C_target_INST); } } // printf("Total Bytes Received: %d (Expected: %d)\n", index, // sizeof(BatteryLimitMsg)); if (index == sizeof(BatteryLimitMsg)) { // printf("Received Battery Limits.\n"); BatteryLimitMsg battery_limits; memcpy(&battery_limits, rx_buffer, sizeof(BatteryLimitMsg)); if (battery_limits.slot_id < NUM_SLOTS) { Battery *battery = &batteries[battery_limits.slot_id]; battery->min_voltage = battery_limits.min_voltage; battery->max_voltage = battery_limits.max_voltage; battery->cut_off_current = battery_limits.cut_off_current; battery->capacitance = battery_limits.capacitance; battery->charge_fraction = battery_limits.charge_fraction; /*printf("\n Received Battery Limits for slot %d: \n", battery_limits.slot_id); printf(" Min Voltage: %d mV (0x%04X)\n", battery_limits.min_voltage, battery_limits.min_voltage); printf(" Max Voltage: %d mV (0x%04X)\n", battery_limits.max_voltage, battery_limits.max_voltage); printf(" Cutoff Current: %d mA (0x%04X)\n", battery_limits.cut_off_current, battery_limits.cut_off_current); printf(" Capacitance: %d µF (0x%04X)\n", battery_limits.capacitance, battery_limits.capacitance); printf(" Charge Fraction: %d%% (0x%02X)\n", battery_limits.charge_fraction, battery_limits.charge_fraction);*/ } } } else if (receivedCommand == CMD_GET_BATTERY_STATUS) { uint8_t test[8] = {0x00}; // for testing: Battery batteries[NUM_SLOTS] = { {0, STATE_BATTERY_DETECTED, 3700, 500, 25, 3000, 4200, 2000, 10000, 80} }; //Battery_StateUpdate(); // Prepare data to be sent to Pi: for (uint8_t slot = 0; slot < NUM_SLOTS; slot++) { // Read the battery status for each slot //Battery_ReadState(slot); test[slot] = batteries[slot].state; } // Filling up the FIFO DL_I2C_fillTargetTXFIFO(I2C_target_INST, &test, 8); while (DL_I2C_transmitTargetDataCheck(I2C_target_INST, 0x00) != false) ; printf("Sent Data\n"); /*if (piTxCount < piTxLen) { while (DL_I2C_getTargetStatus(I2C_target_INST) & DL_I2C_TARGET_STATUS_BUS_BUSY) ; piTxCount += DL_I2C_fillTargetTXFIFO( I2C_target_INST, &piTxPacket[piTxCount], (piTxLen - piTxCount)); } else { /* * Fill FIFO with 0x00 if more data is requested than expected piTxLen */ /*while (DL_I2C_transmitTargetDataCheck(I2C_target_INST, 0x00) != false) ; }*/ } else if (receivedCommand == CMD_GET_BATTERY_DATA) { uint8_t requestedSlot = DL_I2C_receiveTargetData(I2C_target_INST); while (DL_I2C_getTargetStatus(I2C_target_INST) & DL_I2C_TARGET_STATUS_BUS_BUSY) ; // printf("Battery Data Requested for Slot %d!\n", requestedSlot); piTxCount = 0; piTxLen = sizeof(BatteryData); BatteryData battery_data; if (requestedSlot < NUM_SLOTS) { Battery *battery = &batteries[requestedSlot]; battery_data.slot_id = battery->slot_id; battery_data.voltage = battery->voltage; battery_data.current = battery->current; battery_data.temperature = battery->temperature; while (DL_I2C_getTargetStatus(I2C_target_INST) & DL_I2C_TARGET_STATUS_BUS_BUSY) ; DL_I2C_fillTargetTXFIFO(I2C_target_INST, (uint8_t *)&battery_data, sizeof(BatteryData)); // piTxCount += DL_I2C_fillTargetTXFIFO(I2C_target_INST, // (uint8_t*)&battery_data, piTxLen); piTxComplete = true; while (DL_I2C_getTargetStatus(I2C_target_INST) & DL_I2C_TARGET_STATUS_BUS_BUSY) ; if (piTxCount >= piTxLen) { piTxComplete = true; piTxCount = 0; } } break; /* Arbitration lost or NACK */ case DL_I2C_IIDX_TARGET_ARBITRATION_LOST: printf("Arbitration Lost.\n"); break; default: printf("Unknown Interrupt.\n"); break; } } /********MAIN function*************/ int main(void) { // Initialize System and I2C SYSCFG_DL_init(); // Initialize battery array and default params Battery_Init(); // Reset_I2C_Bus(); NVIC_EnableIRQ(I2C_target_INST_INT_IRQN); NVIC_EnableIRQ(I2C_controller_INST_INT_IRQN); printf("............System Configuration Enabled...............\n"); // Multiplexer Multiplexer_SelectChannel(I2C_CHANNEL); // I2C_scanBus(); I2C_init(&gI2C); // ADC_SetConfigurationBytes(adc_voltage_params); // delay_cycles(50000); // ADC_SetConfigurationBytes(adc_current_params); // delay_cycles(50000); // DAC_ReadCurrentAddress(); while (1) { // Looping through the ADC Channels /*for(uint8_t slot_id=0; slot_id< NUM_SLOTS; slot_id++){ for(uint8_t adc_channel=0; adc_channel< ADC_CHANNEL_NUM; adc_channel++){ batteries[slot_id].channel= adc_channel; Battery_UpdateADCReading(slot_id, batteries[slot_id].channel); } }*/ // CC-CV Cycle: maximum cycles is not yet implemented // for(uint8_t slot_id= 0; slot_id < NUM_SLOTS; slot_id++){ // CC_CV_ControlCharging(slot_id); // } // DAC_fastWrite(CHANNEL_A_VALUE); } }