recent changes

main.c

@@ -135,7 +135,7 @@ int main(void)
         if(mcuSendCommand){   
             printf("MCU Interrupt Triggered.\n");
             for(uint8_t i=0; i<NUM_SLOTS; i++){
-                controller_GetBatteryMeasurement(TARGET_MCU_ADDRESS, i);
+                controller_GetBatteryMeasurement(TARGET_BASE_ADDRESS, i);
             }
             mcuSendCommand = false;
             

main.syscfg

@@ -90,10 +90,10 @@ PWM1.PWM_CHANNEL_0.$name        = "ti_driverlib_pwm_PWMTimerCC0";
 PWM1.PWM_CHANNEL_0.invert       = true;
 PWM1.ccp0PinConfig.$name        = "ti_driverlib_gpio_GPIOPinGeneric4";
 
-SYSCTL.clockTreeEn           = true;
-SYSCTL.powerPolicy           = "STANDBY0";
 SYSCTL.forceDefaultClkConfig = true;
 SYSCTL.validateClkStatus     = true;
+SYSCTL.clockTreeEn           = true;
+SYSCTL.powerPolicy           = "STANDBY0";
 
 TIMER1.$name              = "TIMER_0";
 TIMER1.timerClkSrc        = "LFCLK";

src/battery_data/battery.h

@@ -55,6 +55,7 @@ typedef struct{
     SlotState slot_state;
 }BatteryMeasurement;
 
+
 typedef struct{
     uint8_t slot_id;
     uint16_t pwm_value; //for Power Burning PWM
@@ -67,6 +68,8 @@ typedef struct{
     uint16_t capacitance;
     uint8_t charge_fraction;
     bool batteryLimitReceived;
+    //uint8_t charging_number;
+    //ChargingState charging_state;
 } BatteryInfo;
 
 extern BatteryInfo battery_data[NUM_SLOTS];

src/cc_cv_charging.c

@@ -6,7 +6,8 @@
 #include "ti_msp_dl_config.h"
 #include "src/controller/controller.h"
 
-static ChargingState charging_state= STATE_IDLE;
+
+static ChargingState  charging_state= STATE_IDLE;
 static uint16_t cycle_count = 0;
 // declaring static global variables to retain their values between multiple function calls till the end of the program
 static uint16_t batt_voltage;
@@ -20,6 +21,7 @@ static int16_t batt_charge_discharge;
 
 void CC_CV_UpdateChargingState(uint8_t slot_id) {
     //static variable to keep a log on the transition during charging and dischrging phases
+    
     static ChargingState previous_state= STATE_IDLE;
     // Flag for CV charging, the charging mode flips back to CC mode
     static bool cv_charging_started = false;
@@ -138,7 +140,7 @@ void CC_CV_ControlCharging(uint8_t slot_id, int16_t charge_current) {
     case STATE_PRE_CHARGE:
       //DL_GPIO_setPins(GPIO_Battery_Charging_PORT, GPIO_Battery_Charging_PIN_PB6_PIN);
       DL_GPIO_setPins(GPIO_Battery_Discharging_PORT, GPIO_Battery_Discharging_PIN_PB7_PIN);
-      controller_SetCurrent(TARGET_MCU_ADDRESS, slot_id, charge_current);
+      controller_SetCurrent(TARGET_BASE_ADDRESS, slot_id, charge_current);
       if (true) {
         printf("PRE CHARGING: Slot %d at %d mA.\n", slot_id, charge_current);
       }
@@ -148,7 +150,7 @@ void CC_CV_ControlCharging(uint8_t slot_id, int16_t charge_current) {
     // reaches to (MAXIMUM_VOLTAGE-BATTERY_THRESHOLD)= 4150 mVolts
     case STATE_CC_CHARGING:
       DL_GPIO_setPins(GPIO_Battery_Discharging_PORT, GPIO_Battery_Discharging_PIN_PB7_PIN);
-      controller_SetCurrent(TARGET_MCU_ADDRESS, slot_id, charge_current);
+      controller_SetCurrent(TARGET_BASE_ADDRESS, slot_id, charge_current);
       printf("CC CHARGING: Slot %d, Current: %d mA, Voltage: %d mV.\n", slot_id, batt_current, batt_voltage);
       break;
   
@@ -163,7 +165,7 @@ void CC_CV_ControlCharging(uint8_t slot_id, int16_t charge_current) {
           charging_state= STATE_ERROR;
           break;
         }
-        controller_SetCurrent(TARGET_MCU_ADDRESS, slot_id, charge_current);
+        controller_SetCurrent(TARGET_BASE_ADDRESS, slot_id, charge_current);
       }else {
         charging_state = STATE_FINAL_DISCHARGE;
         dac_initialized= false;
@@ -175,7 +177,7 @@ void CC_CV_ControlCharging(uint8_t slot_id, int16_t charge_current) {
       DL_GPIO_setPins(GPIO_Battery_Charging_PORT, GPIO_Battery_Charging_PIN_PB6_PIN);
       DL_GPIO_setPins(GPIO_Battery_Discharging_PORT, GPIO_Battery_Discharging_PIN_PB7_PIN);
       //controller_EvaluateBatterySlotState(slot_id, BatteryMeasurement *measurement);
-      controller_SetCurrent(TARGET_MCU_ADDRESS, slot_id, charge_current);
+      controller_SetCurrent(TARGET_BASE_ADDRESS, slot_id, charge_current);
       printf("DISCHARGING: Slot %d at %d mA.\n", slot_id, batt_current);
 
       //Safety Check
@@ -190,7 +192,7 @@ void CC_CV_ControlCharging(uint8_t slot_id, int16_t charge_current) {
       battery_data[slot_id].battery_state= STATE_MEASUREMENT_DONE;
       DL_GPIO_clearPins(GPIO_Battery_Charging_PORT, GPIO_Battery_Charging_PIN_PB6_PIN);
       DL_GPIO_clearPins(GPIO_Battery_Discharging_PORT, GPIO_Battery_Discharging_PIN_PB7_PIN);
-      controller_SetCurrent(TARGET_MCU_ADDRESS, slot_id, 0);
+      controller_SetCurrent(TARGET_BASE_ADDRESS, slot_id, 0);
       charging_state = STATE_IDLE;
       break;
   

src/config.h

@@ -1,30 +1,33 @@
 #include <stdint.h>
+#include <stdbool.h>
 
 #ifndef CONFIG_H_
 #define CONFIG_H_
 #define I2C_TX_MAX_PACKET_SIZE  (8)
-#define I2C_RX_MAX_PACKET_SIZE  (12)
+#define I2C_RX_MAX_PACKET_SIZE  (8)
 #define BATTERY_THRESHOLD (50)
 #define TEMPERATURE_MAX_C (60)
 #define MAX_CYCLES (2)
-#define TARGET_MCU_ADDRESS (0x47)
-#define MEASUREMENT_CHECK_INTERVAL 3200 //Do not know yet the exact timing
+#define TARGET_BASE_ADDRESS (0x48)
+#define MEASUREMENT_CHECK_INTERVAL 3200000 //Do not know yet the exact timing
 
 typedef struct{
      uint8_t txBuffer[I2C_TX_MAX_PACKET_SIZE];
      uint8_t txLen;
      uint8_t txCount;
+     bool txComplete;
 
-}txPacket;
+}tx_Packet;
 
 typedef struct{
      uint8_t rxBuffer[I2C_RX_MAX_PACKET_SIZE];
      uint8_t rxLen;
      uint8_t rxCount;
+     bool rxComplete;
 
-}rxPacket;
+}rx_Packet;
 
 // Global variables declared in i2c_hal.c
-extern txPacket tx_packet;
-extern rxPacket rx_packet;
+extern tx_Packet txPacket;
+extern rx_Packet rxPacket;
 #endif

src/controller/controller.c

@@ -13,15 +13,15 @@ Format: command + ((slot_id) + data (optional))
 //Send command to set charge and discharge current to the target
 void controller_SetCurrent(uint8_t const TARGET_ADDRESS, uint8_t slot_id, int16_t current_mA){
     //Bitmasked: Slot id + Command
-    tx_packet.txBuffer[0]= (slot_id<<4) | (CMD_SET_CURRENT & 0x0F);
+    txPacket.txBuffer[0]= (slot_id<<4) | (CMD_SET_CURRENT & 0x0F);
     //Filling the buffer with current value
-    *((int16_t*)(&tx_packet.txBuffer[1])) = current_mA;
+    *((int16_t*)(&txPacket.txBuffer[1])) = current_mA;
 
     /*I2C Communication for transmitting Charging/Discharging current for the slots*/
     //Length is calculated as 1 byte for the bitmasked slot and command+ 2 bytes of current + 1 byte of padding
-    tx_packet.txLen= 4;
+    txPacket.txLen= 4;
     DL_I2C_enableInterrupt(I2C_1_INST, DL_I2C_INTERRUPT_CONTROLLER_TXFIFO_TRIGGER);
-    DL_I2C_startControllerTransfer(I2C_1_INST, TARGET_ADDRESS, DL_I2C_CONTROLLER_DIRECTION_TX, tx_packet.txLen);
+    DL_I2C_startControllerTransfer(I2C_1_INST, TARGET_ADDRESS, DL_I2C_CONTROLLER_DIRECTION_TX, txPacket.txLen);
     /*printf("Packet Sent:: 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X \n", TARGET_ADDRESS, tx_packet.txBuffer[0], tx_packet.txBuffer[1],tx_packet.txBuffer[2], tx_packet.txBuffer[3]);
     DL_I2C_fillControllerTXFIFO(I2C_1_INST, tx_packet.txBuffer, tx_packet.txLen);*/
 
@@ -48,14 +48,20 @@ bool controller_GetBatteryMeasurement(uint8_t const TARGET_ADDRESS, uint8_t slot
     DL_I2C_flushControllerTXFIFO(I2C_1_INST);
 
     //Write Command to the target
+    //Clearing out TX FIFO
+    DL_I2C_flushControllerTXFIFO(I2C_1_INST);
     //Set the command in the tx buffer in bit masked format to the target: Upper Nibble-> Slot and Lower Nibbel -> Command
-    tx_packet.txBuffer[0]= (slot_id << 4)|(CMD_GET_MEASUREMENT & 0x0F); //shift slot_id to the left by 4 bits
+    txPacket.txBuffer[0]= (slot_id << 4)|(CMD_GET_MEASUREMENT & 0x0F); //shift slot_id to the left by 4 bits
+    txPacket.txCount= 0;
+    txPacket.txLen= 1;
+
+    DL_I2C_fillControllerTXFIFO(I2C_1_INST, &txPacket.txBuffer[0], txPacket.txLen);
 
     //Send command bytes to the target
     DL_I2C_enableInterrupt(I2C_1_INST, DL_I2C_INTERRUPT_CONTROLLER_TXFIFO_TRIGGER);
     DL_I2C_startControllerTransfer(I2C_1_INST, TARGET_ADDRESS, DL_I2C_CONTROLLER_DIRECTION_TX, 1);
-    printf("[I2C] TX Packet Sent:: 0x%02X\n", tx_packet.txBuffer[0]);
-    DL_I2C_fillControllerTXFIFO(I2C_1_INST, tx_packet.txBuffer, 1);
+    printf("[I2C] TX Packet Sent:: 0x%02X\n", txPacket.txBuffer[0]);
+    
 
      // Wait for the write transaction to complete
     uint32_t tx_timeout = 100000;
@@ -84,8 +90,8 @@ bool controller_GetBatteryMeasurement(uint8_t const TARGET_ADDRESS, uint8_t slot
     while(rx_index < sizeof(BatteryMeasurement)){
         if(!DL_I2C_isControllerRXFIFOEmpty(I2C_1_INST)){
             //Get byte from the I2C RX FIFO of the target
-            rx_packet.rxBuffer[rx_index]= DL_I2C_receiveControllerData(I2C_1_INST);
-            printf("Received Bytes[%d]: 0x%02X\n", rx_index, rx_packet.rxBuffer[rx_index]);
+            rxPacket.rxBuffer[rx_index]= DL_I2C_receiveControllerData(I2C_1_INST);
+            printf("Received Bytes[%d]: 0x%02X\n", rx_index, rxPacket.rxBuffer[rx_index]);
             rx_index++;
         }
     }
@@ -93,10 +99,10 @@ bool controller_GetBatteryMeasurement(uint8_t const TARGET_ADDRESS, uint8_t slot
     printf("RX Index: %d\n", rx_index);
     //Check if all the data is received then store the battery limits in BatteryInfo struct:
     if(rx_index== (sizeof(BatteryMeasurement))){
-           measurement.voltage= rx_packet.rxBuffer[0] | (rx_packet.rxBuffer[1] << 8);
-           measurement.current= rx_packet.rxBuffer[2]|(rx_packet.rxBuffer[3] << 8);
-           measurement.temperature = rx_packet.rxBuffer[4] | (rx_packet.rxBuffer[5] << 8);
-           measurement.slot_state = (SlotState)(rx_packet.rxBuffer[6]);
+           measurement.voltage= rxPacket.rxBuffer[0] | (rxPacket.rxBuffer[1] << 8);
+           measurement.current= rxPacket.rxBuffer[2]|(rxPacket.rxBuffer[3] << 8);
+           measurement.temperature = rxPacket.rxBuffer[4] | (rxPacket.rxBuffer[5] << 8);
+           measurement.slot_state = (SlotState)(rxPacket.rxBuffer[6]);
            battery_data[slot_id].battery_measurement= measurement;
            //DEBUG
            printf("[I2C] Successfully read %d bytes from target 0x%02X\n", sizeof(BatteryMeasurement), TARGET_ADDRESS);
@@ -115,12 +121,12 @@ bool controller_GetBatteryMeasurement(uint8_t const TARGET_ADDRESS, uint8_t slot
 void controller_ClearError(uint8_t const TARGET_ADDRESS, uint8_t slot_id){
     uint8_t command= CMD_CLEAR_ERR| (slot_id<<4); //shift slot_id to the left by 4 bits
     printf("[MCU] Clear Error Bitmasked Command:: 0x%02X\n", command);
-    tx_packet.txBuffer[0]= command;
-    tx_packet.txBuffer[1]= slot_id;
-    tx_packet.txLen= sizeof(tx_packet.txBuffer);
+    txPacket.txBuffer[0]= command;
+    txPacket.txBuffer[1]= slot_id;
+    txPacket.txLen= sizeof(txPacket.txBuffer);
     while (DL_I2C_getControllerStatus(I2C_1_INST) & DL_I2C_CONTROLLER_STATUS_BUSY_BUS);
-    DL_I2C_startControllerTransfer(I2C_1_INST, TARGET_ADDRESS, DL_I2C_CONTROLLER_DIRECTION_TX, tx_packet.txLen);
-    DL_I2C_fillControllerTXFIFO(I2C_1_INST, tx_packet.txBuffer, tx_packet.txLen);
+    DL_I2C_startControllerTransfer(I2C_1_INST, TARGET_ADDRESS, DL_I2C_CONTROLLER_DIRECTION_TX, txPacket.txLen);
+    DL_I2C_fillControllerTXFIFO(I2C_1_INST, txPacket.txBuffer, txPacket.txLen);
     while (DL_I2C_getControllerStatus(I2C_1_INST) & DL_I2C_CONTROLLER_STATUS_BUSY_BUS);
     DL_I2C_flushControllerTXFIFO(I2C_1_INST);
 }

src/i2c_comm/i2c_hal.c

@@ -4,8 +4,8 @@
 #include <stdio.h>
 
 // Global extern variable defined in config.h and declared here
-txPacket tx_packet;
-rxPacket rx_packet;
+tx_Packet txPacket;
+rx_Packet rxPacket;
 
 static bool i2c_write(uint8_t const TARGET_ADDRESS){
     // Write data to the target address
@@ -16,8 +16,8 @@ static bool i2c_write(uint8_t const TARGET_ADDRESS){
     }
     // **Wait for I2C Bus to be Free**
     while (DL_I2C_getControllerStatus(I2C_1_INST) & DL_I2C_CONTROLLER_STATUS_BUSY_BUS);
-    DL_I2C_startControllerTransfer(I2C_1_INST, TARGET_ADDRESS, DL_I2C_CONTROLLER_DIRECTION_TX, tx_packet.txLen);
-    DL_I2C_fillControllerTXFIFO(I2C_1_INST, tx_packet.txBuffer, tx_packet.txLen);
+    DL_I2C_startControllerTransfer(I2C_1_INST, TARGET_ADDRESS, DL_I2C_CONTROLLER_DIRECTION_TX, txPacket.txLen);
+    DL_I2C_fillControllerTXFIFO(I2C_1_INST, txPacket.txBuffer, txPacket.txLen);
     DL_I2C_flushTargetTXFIFO(I2C_1_INST);
     return true;
 }
@@ -26,7 +26,7 @@ static bool i2c_read(uint8_t const TARGET_ADDRESS){
     //Read data from the target address
     DL_I2C_flushControllerRXFIFO(I2C_1_INST);
     while (DL_I2C_getControllerStatus(I2C_1_INST) & DL_I2C_CONTROLLER_STATUS_BUSY_BUS);
-    DL_I2C_startControllerTransfer(I2C_1_INST, TARGET_ADDRESS, DL_I2C_CONTROLLER_DIRECTION_RX, rx_packet.rxLen);
+    DL_I2C_startControllerTransfer(I2C_1_INST, TARGET_ADDRESS, DL_I2C_CONTROLLER_DIRECTION_RX, rxPacket.rxLen);
     while (DL_I2C_getControllerStatus(I2C_1_INST) & DL_I2C_CONTROLLER_STATUS_BUSY_BUS);
     DL_I2C_enableInterrupt(I2C_1_INST, DL_I2C_INTERRUPT_CONTROLLER_RXFIFO_TRIGGER);
     return true;

src/pi/i2c_pi_target.c

@@ -100,7 +100,7 @@ void pi_i2c_mcu(){
 
         while(rx_index < (sizeof(BatteryLimitMsg))){
             if(!DL_I2C_isTargetRXFIFOEmpty(I2C_0_INST)){
-                rx_packet.rxBuffer[rx_index] = DL_I2C_receiveTargetData(I2C_0_INST);
+                rxPacket.rxBuffer[rx_index] = DL_I2C_receiveTargetData(I2C_0_INST);
                 //printf("Received Bytes[%d]: 0x%02X\n", rx_index, rx_packet.rxBuffer[rx_index]);
                 rx_index++;
             }
@@ -109,7 +109,7 @@ void pi_i2c_mcu(){
         //Check if all the data is received then store the battery limits in BatteryInfo struct:
         if(rx_index== (sizeof(BatteryLimitMsg))){
             BatteryLimitMsg battery_limit_received;
-            memcpy(&battery_limit_received, (const uint8_t*)rx_packet.rxBuffer, sizeof(BatteryLimitMsg));
+            memcpy(&battery_limit_received, (const uint8_t*)rxPacket.rxBuffer, sizeof(BatteryLimitMsg));
             if(battery_limit_received.slot_id < NUM_SLOTS){
                 BatteryInfo *battery = &battery_data[battery_limit_received.slot_id];
                 battery->min_voltage = battery_limit_received.min_voltage;