Adapt for multiple INA230 devices instead of hardcode

Author: erinjhu

obc/app/drivers/ina230/ina230.c

@@ -51,13 +51,36 @@ typedef struct {
 
 static const ina230_config_t ina230Devices[] = {[INA230_DEVICE_ONE] = {.i2cDeviceAddress = INA230_I2C_ADDRESS_ONE,
                                                                        .tcaAlertPort = INA230_ONE_ALERT_PIN,
-                                                                       .tcaEnablePort = INA230_ONE_ENABLE_PIN},
-
+                                                                       .tcaEnablePort = INA230_ONE_ENABLE_PIN,
+                                                                       .configurationMode = INA230_DEFAULT_MODE,
+                                                                       .configurationShunt = INA230_DEFAULT_SHUNT_CONV_TIME,
+                                                                       .configurationBus = INA230_DEFAULT_BUS_CONV_TIME,
+                                                                       .configurationAvg = INA230_DEFAULT_AVERAGING, 
+                                                                       .calibrationRegister = INA230_CALIBRATION_VALUE,
+                                                                      .maskEnableRegister = INA230_MASK_ENABLE_NONE,
+                                                                      .alertRegister = INA230_ALERT_LIMIT_NONE},
                                                 [INA230_DEVICE_TWO] = {.i2cDeviceAddress = INA230_I2C_ADDRESS_TWO,
                                                                        .tcaAlertPort = INA230_TWO_ALERT_PIN,
-                                                                       .tcaEnablePort = INA230_TWO_ENABLE_PIN}};
-
-static obc_error_code_t writeINA230Register(uint8_t regAddress, uint8_t* data, uint8_t size, uint8_t i2cAddress);
+                                                                       .tcaEnablePort = INA230_TWO_ENABLE_PIN,
+                                                                       .configurationMode = INA230_DEFAULT_MODE,
+                                                                       .configurationShunt = INA230_DEFAULT_SHUNT_CONV_TIME,
+                                                                       .configurationBus = INA230_DEFAULT_BUS_CONV_TIME,
+                                                                       .configurationAvg = INA230_DEFAULT_AVERAGING, .calibrationRegister = INA230_CALIBRATION_VALUE,
+                                                                      .maskEnableRegister = INA230_MASK_ENABLE_NONE,
+                                                                      .alertRegister = INA230_ALERT_LIMIT_NONE},
+                                                                      // initialized only 2 devices for now; initialize the rest if used
+                                                [INA230_DEVICE_THREE]  = {0}, 
+                                                [INA230_DEVICE_FOUR]   = {0},
+                                                [INA230_DEVICE_FIVE]   = {0},
+                                                [INA230_DEVICE_SIX]    = {0},
+                                                [INA230_DEVICE_SEVEN]  = {0},
+                                                [INA230_DEVICE_EIGHT]  = {0},
+                                                [INA230_DEVICE_NINE]   = {0},
+                                                [INA230_DEVICE_TEN]    = {0},
+                                                [INA230_DEVICE_ELEVEN] = {0}
+                                                                                                                  };
+
+static obc_error_code_t writeINA230Register(uint8_t regAddress, uint8_t* data, uint8_t size, ina230_device_t device);
 static obc_error_code_t initTca6424PinState();
 
 /**
@@ -90,19 +113,16 @@ obc_error_code_t initINA230() {
     uint8_t deviceAddress = device.i2cDeviceAddress;
     RETURN_IF_ERROR_CODE(writeINA230Register(INA230_CONFIG_REGISTER_ADDR, configRegisterUnpacked,
                                              sizeof(configRegisterUnpacked) / sizeof(configRegisterUnpacked[0]),
-                                             deviceAddress));
+                                             i));
     RETURN_IF_ERROR_CODE(writeINA230Register(INA230_MASK_ENABLE_REGISTER_ADDR, maskEnRegisterUnpacked,
                                              sizeof(maskEnRegisterUnpacked) / sizeof(maskEnRegisterUnpacked[0]),
-                                             deviceAddress));
+                                             i));
     RETURN_IF_ERROR_CODE(writeINA230Register(INA230_ALERT_LIMIT_REGISTER_ADDR, alertRegisterUnpacked,
                                              sizeof(alertRegisterUnpacked) / sizeof(alertRegisterUnpacked[0]),
-                                             deviceAddress));
-    // uint16_t calibrationValue = INA230_CALIBRATION_VALUE;
-    // uint8_t calibrationRegisterUnpacked[] = {calibrationValue & 0xFF, calibrationValue >> 8};
-
+                                             i));
     RETURN_IF_ERROR_CODE(writeINA230Register(
         INA230_CALIBRATION_REGISTER_ADDR, calibrationRegisterUnpacked,
-        sizeof(calibrationRegisterUnpacked) / sizeof(calibrationRegisterUnpacked[0]), deviceAddress));
+        sizeof(calibrationRegisterUnpacked) / sizeof(calibrationRegisterUnpacked[0]), i));
   }
 
   RETURN_IF_ERROR_CODE(initTca6424PinState());
@@ -115,7 +135,7 @@ obc_error_code_t initINA230() {
  * This function reads the complete input from the TCA6424 and checks for alerts
  * on the INA230 devices. If an alert is detected, it disables the corresponding device.
  *
- * @param device The INA230 device to check
+ * @param device INA230 device enum
  * @return OBC_ERR_CODE_SUCCESS if operation is successful,
  *         otherwise returns an appropriate error code
  */
@@ -139,25 +159,17 @@ inline obc_error_code_t readAndDisableIfAlert(ina230_device_t device) {
  * @param regAddress The address of the register to write to
  * @param data Pointer to the data to be written
  * @param size The size of the data to be written
- * @param i2cAddress The I2C address of the INA230 device
+ * @param device INA230 device index
  * @return OBC_ERR_CODE_SUCCESS if write is successful,
  *         otherwise returns an appropriate error code
  */
 
-static obc_error_code_t writeINA230Register(uint8_t regAddress, uint8_t* data, uint8_t size, uint8_t i2cAddress) {
-  if (data == NULL) return OBC_ERR_CODE_INVALID_ARG;
-  bool found = false;
-  for (uint8_t i = 0; i < INA230_DEVICE_COUNT; ++i) {
-      if(i2cAddress == ina230Devices[i].i2cDeviceAddress) {
-        found = true;
-        break;
-      }
-  }
-  if(!found) {
+static obc_error_code_t writeINA230Register(uint8_t regAddress, uint8_t* data, uint8_t size, ina230_device_t device) {
+  if (data == NULL || device >= INA230_DEVICE_COUNT) {
     return OBC_ERR_CODE_INVALID_ARG;
   }
   obc_error_code_t errCode;
-  RETURN_IF_ERROR_CODE(i2cWriteRegFuncPtr(i2cAddress, regAddress, data, size));
+  RETURN_IF_ERROR_CODE(i2cWriteRegFuncPtr(ina230Devices[device].i2cDeviceAddress, regAddress, data, size));
   return OBC_ERR_CODE_SUCCESS;
 }
 /**
@@ -189,30 +201,22 @@ static obc_error_code_t initTca6424PinState() {
  * Reads the 16-bit shunt voltage register (MSB first) from the specified INA230 device.
  * Converts the raw register value to a signed voltage in volts (LSB = 2.5μV).
  *
- * @param i2cAddress The I2C address of the INA230 device
+ * @param device INA230 device enum
  * @param shuntVoltage Pointer to store the shunt voltage in volts
  * @return OBC_ERR_CODE_SUCCESS if operation is successful,
  *         otherwise returns an appropriate error code
  */
-obc_error_code_t getINA230ShuntVoltage(uint8_t i2cAddress, float* shuntVoltage) {
-  if (shuntVoltage == NULL) return OBC_ERR_CODE_INVALID_ARG;
+obc_error_code_t getINA230ShuntVoltage(ina230_device_t device, float* shuntVoltage) {
 
-  uint8_t shuntVoltageRaw[INA_REG_CONF_BUFF_SIZE] = {0};  // store 2 bytes of shunt voltage
-  obc_error_code_t errCode;
-
-  bool found = false;
-  for (uint8_t i = 0; i < INA230_DEVICE_COUNT; ++i) {
-      if(i2cAddress == ina230Devices[i].i2cDeviceAddress) {
-        found = true;
-        break;
-      }
-  }
-  if(!found) {
+  if (shuntVoltage == NULL || device >= INA230_DEVICE_COUNT) {
     return OBC_ERR_CODE_INVALID_ARG;
   }
 
+  uint8_t shuntVoltageRaw[INA_REG_CONF_BUFF_SIZE] = {0};  // store 2 bytes of shunt voltage
+  obc_error_code_t errCode;
+
   // Read the 16-bit shunt voltage register
-  errCode = i2cReadRegFuncPtr(i2cAddress, INA230_SHUNT_VOLTAGE_REGISTER_ADDR, shuntVoltageRaw, 2,
+  errCode = i2cReadRegFuncPtr(ina230Devices[device].i2cDeviceAddress, INA230_SHUNT_VOLTAGE_REGISTER_ADDR, shuntVoltageRaw, 2,
                               I2C_TRANSFER_TIMEOUT_TICKS);  // last param not sure
   if (errCode != OBC_ERR_CODE_SUCCESS) return errCode;
 
@@ -224,18 +228,7 @@ obc_error_code_t getINA230ShuntVoltage(uint8_t i2cAddress, float* shuntVoltage)
 
   return OBC_ERR_CODE_SUCCESS;
 }
-
-obc_error_code_t getINA230ShuntVoltageForDevice(uint8_t deviceIndex, float* shuntVoltage) {
-  if (shuntVoltage == NULL) return OBC_ERR_CODE_INVALID_ARG;
-
-  if (deviceIndex >= INA230_DEVICE_COUNT) return OBC_ERR_CODE_INVALID_ARG;  // Check valid device index
-
-  // Retrieve the I2C address for the specified INA230 device
-  uint8_t i2cAddress = ina230Devices[deviceIndex].i2cDeviceAddress;
-
-  // Get the shunt voltage
-  return getINA230ShuntVoltage(i2cAddress, shuntVoltage);
-}
+   
 
 
 // general disable function for ina230 device
@@ -245,7 +238,7 @@ obc_error_code_t disableNoAlert(ina230_device_t device) {
   obc_error_code_t errCode;
 
   for (uint8_t i = 0; i < INA230_DEVICE_COUNT; ++i) {
-    uint8_t pinLocation =
+    uint8_t pinLocation = 
         ina230Devices[i].tcaEnablePort;  // specific pin on TCA that this ina230 controls, should this be alertPort?
     uint8_t index = ((pinLocation & 0x0F) +
                      ((pinLocation >> 1) & 0x18));  // converts the pinLocation to an index in the 24 bit IOPortValue
@@ -262,117 +255,71 @@ obc_error_code_t disableNoAlert(ina230_device_t device) {
  * Reads the 16-bit bus voltage register (MSB first) from the specified INA230 device.
  * Converts the raw register value to a signed voltage in volts (LSB = 1.25mV).
  *
- * @param i2cAddress The I2C address of the INA230 device
+ * @param device INA230 device enum
  * @param busVoltage Pointer to store the bus voltage in volts
  * @return OBC_ERR_CODE_SUCCESS if write is successful,
  *         otherwise return an appropriate error code
  */
-obc_error_code_t getINA230BusVoltage(uint8_t i2cAddress, float* busVoltage) {
-  if (busVoltage == NULL) return OBC_ERR_CODE_INVALID_ARG;
-  bool found = false;
-  for (uint8_t i = 0; i < INA230_DEVICE_COUNT; ++i) {
-      if(i2cAddress == ina230Devices[i].i2cDeviceAddress) {
-        found = true;
-        break;
-      }
-  }
-  if(!found) {
+obc_error_code_t getINA230BusVoltage(ina230_device_t device, float* busVoltage) {
+  if (busVoltage == NULL || device >= INA230_DEVICE_COUNT) {
     return OBC_ERR_CODE_INVALID_ARG;
   }
   obc_error_code_t errCode;
   uint8_t busVoltageRaw[2] = {};
   RETURN_IF_ERROR_CODE(
-      i2cReadRegFuncPtr(i2cAddress, INA230_BUS_VOLTAGE_REGISTER_ADDR, busVoltageRaw, 2, I2C_TRANSFER_TIMEOUT_TICKS));
+      i2cReadRegFuncPtr(ina230Devices[device].i2cDeviceAddress, INA230_BUS_VOLTAGE_REGISTER_ADDR, busVoltageRaw, 2, I2C_TRANSFER_TIMEOUT_TICKS));
   uint16_t busVoltageValue = (busVoltageRaw[0] << 8) | busVoltageRaw[1];
   *busVoltage = busVoltageValue * INA230_BUS_VOLTAGE_LSB;
 
   return OBC_ERR_CODE_SUCCESS;
 }
 
 
-obc_error_code_t getINA230BusVoltageForDevice(uint8_t deviceIndex, float* busVoltage) {
-  if (busVoltage == NULL || deviceIndex >= INA230_DEVICE_COUNT) return OBC_ERR_CODE_INVALID_ARG;
-  uint8_t i2cAddress = ina230Devices[deviceIndex].i2cDeviceAddress;
-  return getINA230BusVoltage(i2cAddress, busVoltage);
-}
-
 /**
  * @brief Gets INA230 power
  * 
  * Reads the 16-bit power register (MSB first) from the specified INA230 device.
  * Converts the raw register value to an unsigned power in watts (LSB = 25mW).
  *
- * @param i2cAddress The I2C address of the INA230 device
+ * @param ina230_device_t device enum
  * @param busVoltage Pointer to store the power in watts
  * @return OBC_ERR_CODE_SUCCESS if write is successful,
  *         otherwise return an appropriate error code
  */
-obc_error_code_t getINA230Power(uint8_t i2cAddress, float* power) {
+obc_error_code_t getINA230Power(ina230_device_t device, float* power) {
   obc_error_code_t errCode;
-  if (power == NULL) {
-    return OBC_ERR_CODE_INVALID_ARG;
-  }
-  bool found = false;
-  for (uint8_t i = 0; i < INA230_DEVICE_COUNT; ++i) {
-      if(i2cAddress == ina230Devices[i].i2cDeviceAddress) {
-        found = true;
-        break;
-      }
-  }
-  if(!found) {
+  if (power == NULL || device >= INA230_DEVICE_COUNT) {
     return OBC_ERR_CODE_INVALID_ARG;
   }
   uint8_t powerRaw[INA_REG_CONF_BUFF_SIZE] = {};
   RETURN_IF_ERROR_CODE(
-      i2cReadRegFuncPtr(i2cAddress, INA230_POWER_REGISTER_ADDR, powerRaw, 2, I2C_TRANSFER_TIMEOUT_TICKS));
+      i2cReadRegFuncPtr(ina230Devices[device].i2cDeviceAddress, INA230_POWER_REGISTER_ADDR, powerRaw, 2, I2C_TRANSFER_TIMEOUT_TICKS));
   uint16_t powerValue = (powerRaw[0] << 8) | powerRaw[1];
   *power = powerValue * (INA230_CURRENT_LSB * INA230_POWER_LSB_MULTIPLIER);
   return OBC_ERR_CODE_SUCCESS;
 }
 
-obc_error_code_t getINA230PowerForDevice(uint8_t deviceIndex, float* power) {
-  if (power == NULL || deviceIndex >= INA230_DEVICE_COUNT) return OBC_ERR_CODE_INVALID_ARG;
-  uint8_t i2cAddress = ina230Devices[deviceIndex].i2cDeviceAddress;
-  return getINA230Power(i2cAddress, power);
-}
-
 /**
  * @brief Gets INA230 current
  * 
  * Reads the 16-bit current register (MSB first) from the specified INA230 device.
  * Converts the raw register value to a signed current in watts (LSB = 1mA).
  *
- * @param i2cAddress The I2C address of the INA230 device
+ * @param device INA230 device enum
  * @param busVoltage Pointer to store the current in amperes
  * @return OBC_ERR_CODE_SUCCESS if write is successful,
  *         otherwise return an appropriate error code
  */
-obc_error_code_t getINA230Current(uint8_t i2cAddress, float* current) {
+obc_error_code_t getINA230Current(ina230_device_t device, float* current) {
   obc_error_code_t errCode;
-  if (current == NULL) {
+  if (current == NULL || device >= INA230_DEVICE_COUNT) {
     return OBC_ERR_CODE_INVALID_ARG;
   }
-  bool found = false;
-  for (uint8_t i = 0; i < INA230_DEVICE_COUNT; ++i) {
-      if(i2cAddress == ina230Devices[i].i2cDeviceAddress) {
-        found = true;
-        break;
-      }
-  }
-  if(!found) {
-    return OBC_ERR_CODE_INVALID_ARG;
-  }    
+
   uint8_t currentRaw[INA_REG_CONF_BUFF_SIZE] = {};
   RETURN_IF_ERROR_CODE(
-      i2cReadRegFuncPtr(i2cAddress, INA230_CURRENT_REGISTER_ADDR, currentRaw, 2, I2C_TRANSFER_TIMEOUT_TICKS));
+      i2cReadRegFuncPtr(ina230Devices[device].i2cDeviceAddress, INA230_CURRENT_REGISTER_ADDR, currentRaw, 2, I2C_TRANSFER_TIMEOUT_TICKS));
   int16_t currentValue = (currentRaw[0] << 8) | currentRaw[1];
   *current = currentValue * INA230_CURRENT_LSB;
   return OBC_ERR_CODE_SUCCESS;
-}
-
-obc_error_code_t getINA230CurrentForDevice(uint8_t deviceIndex, float* current) {
-  if (current == NULL || deviceIndex >= INA230_DEVICE_COUNT) return OBC_ERR_CODE_INVALID_ARG;
-  uint8_t i2cAddress = ina230Devices[deviceIndex].i2cDeviceAddress;
-  return getINA230Current(i2cAddress, current);
-}
-
+}

obc/app/drivers/ina230/ina230.h

@@ -41,32 +41,81 @@ typedef uint32_t TickType_t;
 #define INA230_MASK_ENABLE_POWER_OVER_ALERT_MASK (0b1 << 11)
 #define INA230_MASK_ENABLE_TRANSPARENT_MODE_SET_MASK 1U
 
-// macros for LSB, shunt resistor, and calibration value
+// ------------------  INA230 IC Configuration Modes ------------- //
+
+// Operating Modes
+#define INA230_MODE_POWER_DOWN              0b000
+#define INA230_MODE_SHUNT_TRIGGERED         0b001
+#define INA230_MODE_BUS_TRIGGERED           0b010
+#define INA230_MODE_SHUNT_BUS_TRIGGERED     0b011
+#define INA230_MODE_SHUNT_CONTINUOUS        0b101
+#define INA230_MODE_BUS_CONTINUOUS          0b110
+#define INA230_MODE_SHUNT_BUS_CONTINUOUS    0b111  
+
+// Conversion Time (time for sensor to take measurements)
+#define INA230_CONV_TIME_140US              0b000
+#define INA230_CONV_TIME_204US              0b001
+#define INA230_CONV_TIME_332US              0b010
+#define INA230_CONV_TIME_588US              0b011
+#define INA230_CONV_TIME_1100US             0b100  // 1.1ms: good balance
+#define INA230_CONV_TIME_2116US             0b101
+#define INA230_CONV_TIME_4156US             0b110
+#define INA230_CONV_TIME_8244US             0b111  // Most accurate
+
+// Averaging Modes (number of measurements taken and averaged)
+#define INA230_AVG_1                        0b000  // No averaging
+#define INA230_AVG_4                        0b001
+#define INA230_AVG_16                       0b010  // Good default
+#define INA230_AVG_64                       0b011
+#define INA230_AVG_128                      0b100
+#define INA230_AVG_256                      0b101
+#define INA230_AVG_512                      0b110
+#define INA230_AVG_1024                     0b111  // Maximum smoothing
+
+// Macros for Defaults
+#define INA230_DEFAULT_MODE                 INA230_MODE_SHUNT_BUS_CONTINUOUS
+#define INA230_DEFAULT_SHUNT_CONV_TIME      INA230_CONV_TIME_1100US
+#define INA230_DEFAULT_BUS_CONV_TIME        INA230_CONV_TIME_1100US
+#define INA230_DEFAULT_AVERAGING            INA230_AVG_16
+
+// Mask and Alerts
+#define INA230_MASK_ENABLE_NONE             0x0000
+#define INA230_ALERT_LIMIT_NONE             0x0000
+
+// Macros for LSB, Shunt Resistor, and Calibration Value
 #define INA230_SHUNT_VOLTAGE_LSB 0.0000025f
 #define INA230_BUS_VOLTAGE_LSB 0.00125f
 #define INA230_CURRENT_LSB 0.001f   // 1 mA, current least significant bit
 #define INA230_SHUNT_RESISTOR 0.1f  // 0.1 ohms, shunt resistor value
 #define INA230_CALIBRATION_VALUE (uint16_t)(0.00512 / (INA230_CURRENT_LSB * INA230_SHUNT_RESISTOR))
 #define INA230_POWER_LSB_MULTIPLIER 25
 
-typedef enum { INA230_DEVICE_ONE = 0x00, INA230_DEVICE_TWO = 0x01, INA230_DEVICE_COUNT = 0x02} ina230_device_t;
+typedef enum { 
+    INA230_DEVICE_ONE = 0x00, 
+    INA230_DEVICE_TWO = 0x01, 
+    INA230_DEVICE_THREE = 0x02, 
+    INA230_DEVICE_FOUR = 0x03, 
+    INA230_DEVICE_FIVE = 0x04, 
+    INA230_DEVICE_SIX = 0x05, 
+    INA230_DEVICE_SEVEN = 0x06, 
+    INA230_DEVICE_EIGHT = 0x07, 
+    INA230_DEVICE_NINE = 0x08, 
+    INA230_DEVICE_TEN = 0x09, 
+    INA230_DEVICE_ELEVEN = 0x0A, 
+    INA230_DEVICE_COUNT = 0x0B
+} ina230_device_t;
 
 // function pointers to switch between mock and real data
 extern obc_error_code_t (*i2cReadRegFuncPtr)(uint8_t, uint8_t, uint8_t*, uint16_t, TickType_t);
 extern obc_error_code_t (*i2cWriteRegFuncPtr)(uint8_t, uint8_t, uint8_t*, uint16_t);
 
 obc_error_code_t initINA230();
 obc_error_code_t readAndDisableIfAlert(ina230_device_t device);
-obc_error_code_t getINA230ShuntVoltage(uint8_t i2cAddress, float* shuntVoltage);
-obc_error_code_t getINA230ShuntVoltageForDevice(uint8_t deviceIndex, float* shuntVoltage);
-void main_usage();
+obc_error_code_t getINA230ShuntVoltage(ina230_device_t device, float* shuntVoltage);
 obc_error_code_t disableNoAlert(ina230_device_t device);
-obc_error_code_t getINA230BusVoltage(uint8_t i2cAddress, float* busVoltage);
-obc_error_code_t getINA230BusVoltageForDevice(uint8_t deviceIndex, float* busVoltage);
-obc_error_code_t getINA230Power(uint8_t i2cAddress, float* power);
-obc_error_code_t getINA230PowerForDevice(uint8_t deviceIndex, float* power);
-obc_error_code_t getINA230Current(uint8_t i2cAddress, float* power);
-obc_error_code_t getINA230CurrentForDevice(uint8_t deviceIndex, float* power);
+obc_error_code_t getINA230BusVoltage(ina230_device_t device, float* busVoltage);
+obc_error_code_t getINA230Power(ina230_device_t device, float* power);
+obc_error_code_t getINA230Current(ina230_device_t device, float* power);
 
 #ifdef __cplusplus
 }