Drafted new load code

Author: BobSaidHi

include/LoadConfig.hpp

@@ -189,15 +189,42 @@ namespace LOAD {
     static_assert(NUM_COMBINATIONS == (1u << NUM_PINS),
                   "NUM_COMBINATIONS must be 2^NUM_PINS");
 
-    etl::array<uint_fast8_t, 46> RES_INDEX_TABLE = {
-        0,  1,  2,  4,  3,  8,  5,  6,  9,  12, 16, 11, 7,  14, 13, 15,
-        19, 24, 21, 22, 25, 23, 28, 29, 32, 31, 33, 35, 36, 40, 37, 41,
-        39, 44, 48, 45, 46, 50, 47, 51, 56, 53, 54, 57, 55, 60};
+    constexpr uint_fast8_t VOLT_LIMIT_SIZE = 12; // CONFIG
+    etl::array<uint_fast16_t, VOLT_LIMIT_SIZE> VOLT_LIMITS_TABLE_mV = {
+        2000,                         //
+        1900, 1800, 1700, 1600, 1400, //
+        1500, 1400, 1300, 1200, 1100, //
+        1000};
+
+    constexpr uint_fast8_t RES_INDEX_SIZE = 46; // CONFIG
+    etl::array<uint_fast8_t, RES_INDEX_SIZE> RES_INDEX_TABLE = {
+        0,  1,  2,  4,  3,  //
+        8,  5,  6,  9,  12, //
+        16, 11, 7,  14, 13, //
+        15, 19, 24, 21, 22, //
+        25, 23, 28, 29, 32, //
+        31, 33, 35, 36, 40, //
+        37, 41, 39, 44, 48, //
+        45, 46, 50, 47, 51, //
+        56, 53, 54, 57, 55, //
+        60};
+    // constexpr uint_fast8_t RES_INDEX_SIZE = 46; // CONFIG
+    // etl::array<uint_fast8_t, RES_INDEX_SIZE> RES_INDEX_TABLE = {
+    //     0,  1,  2,  4,  3,  8,  5,  6,  9,  12, 16, 11, 7,  14, 13, 15,
+    //     19, 24, 21, 22, 25, 23, 28, 29, 32, 31, 33, 35, 36, 40, 37, 41,
+    //     39, 44, 48, 45, 46, 50, 47, 51, 56, 53, 54, 57, 55, 60};
+
+    static_assert(
+        VOLT_LIMIT_SIZE <= RES_INDEX_SIZE,
+        "VOLT_LIMIT_SIZE must be less than or equal to RES_INDEX_SIZE");
+    static_assert(
+        RES_INDEX_SIZE <= NUM_COMBINATIONS,
+        "RES_INDEX_SIZE must be less than or equal to NUM_COMBINATIONS");
 
     /**
-     * @brief Resistor values, in milli‑ohms, corresponding to each pin.  Note
-     * that the resistors will be connected in series, so the total resistance
-     * is the sum of the selected resistors.
+     * @brief Resistor values, in milli‑ohms, corresponding to each pin.
+     * Note that the resistors will be connected in series, so the total
+     * resistance is the sum of the selected resistors.
      */
     constexpr etl::array<uint_fast16_t, NUM_PINS> PIN_VALUES_mOhms = {
         500, 1000, 2000, 2200, 5000, 10000}; // in mOhms, in series // TODO

src/main.cpp

@@ -432,7 +432,8 @@ vTaskUpdateFSM([[maybe_unused]] void *pvParameters) { // NOSONAR
  */
 #define LOAD_STRATEGY_MPPT_POM 0
 #define LOAD_STRATEGY_VOLTAGE_LIV 1
-#define LOAD_STRATEGY LOAD_STRATEGY_VOLTAGE_LIV
+#define LOAD_STRATEGY_VOLTAGE_FIX 2
+#define LOAD_STRATEGY LOAD_STRATEGY_VOLTAGE_FIX
 [[noreturn]] void
 vTaskAdjustLoad([[maybe_unused]] void *pvParameters) { // NOSONAR
     while (true) {
@@ -585,29 +586,78 @@ vTaskAdjustLoad([[maybe_unused]] void *pvParameters) { // NOSONAR
 
         // Note: Could be more efficient (?) but then I'd have to add more flow
         // control
-        if ((INA260::antiBackwards < 1) && (INA260::voltage_mV > V1SP_mV) && (INA260::voltage_mV <= V2SP_mV)) {
+        if ((INA260::antiBackwards < 1) && (INA260::voltage_mV > V1SP_mV) &&
+            (INA260::voltage_mV <= V2SP_mV)) {
             /* Increase to stage 2: (> 10 V & < 15 V) */
             INA260::antiBackwards = 1;
             load.setLoadGPIO(LOAD_GPIO_V1SP);
             ESP_LOGI(TAG, "Voltage between %d mV and %d mV, setting load to %d",
                      V1SP_mV, V2SP_mV, LOAD_GPIO_V1SP);
-        } else if ((INA260::antiBackwards < 2) &&(INA260::voltage_mV > V2SP_mV) &&
+        } else if ((INA260::antiBackwards < 2) &&
+                   (INA260::voltage_mV > V2SP_mV) &&
                    (INA260::voltage_mV <= V3SP_mV)) {
             INA260::antiBackwards = 2;
             /* Increase to stage 3:  !(> 10 V & < 15 V) & (> 15 V & <= 18 V) */
             load.setLoadGPIO(LOAD_GPIO_V2SP);
             ESP_LOGI(TAG, "Voltage above %d mV, setting load to %d", V1SP_mV,
                      LOAD_GPIO_V2SP);
-        } else if ((INA260::antiBackwards < 3) && (INA260::voltage_mV > V3SP_mV)) {
+        } else if ((INA260::antiBackwards < 3) &&
+                   (INA260::voltage_mV > V3SP_mV)) {
             /* Increase to stage 4: !(< 10*0.05 V) & !(> 10 V & < 15 V) &
              !(< 15*0.05 V) & !(> 15 V) & !(< 18*0.05 V) & (> 18 V) */
             INA260::antiBackwards = 3;
             load.setLoadGPIO(LOAD_GPIO_V3SP);
             ESP_LOGI(TAG, "Voltage above %d mV, setting load to %d", V3SP_mV,
                      LOAD_GPIO_V3SP);
         }
-#endif
+#elif LOAD_STRATEGY == LOAD_STRATEGY_VOLTAGE_FIX
+        // Iterate over the parallel array in revers order
+        static uint_fast8_t voltLimitIndex = LOAD::VOLT_LIMITS_TABLE_mV.size() - 1;
+        // LCR: Load Control Resistor
+        static uint_fast8_t lCRIndex = LOAD::RES_INDEX_TABLE.size() - 1;
+
+        constexpr int_fast16_t MAX_SAFE_VOLTAGE_mV =
+            30000; // CONFIG - Actually 32 or 36 V max
+        if (INA260::voltage_mV > MAX_SAFE_VOLTAGE_mV) {
+            ESP_LOGW(TAG, "%d mV exceeds max safe of %d mV", INA260::voltage_mV,
+                     MAX_SAFE_VOLTAGE_mV);
+            // Decrease limit
+            if (voltLimitIndex > 0) {
+                // Have not reached lowest value
+                voltLimitIndex--;
+            }
+            // Decrease load cont.
+            if (lCRIndex > 0) {
+                // Have not reached lowest value
+                lCRIndex--;
+                load.setLoadGPIO(LOAD::RES_INDEX_TABLE[lCRIndex]);
+            }
+            delay(RUN::TASK_INTERVALS::TI_ADJUST_LOAD_mS);
+            continue;
+        }
 
+        ESP_LOGI(TAG, "Adjust Load: %d mV, Threshold: %d mV",
+                 INA260::voltage_mV, LOAD::VOLT_LIMITS_TABLE_mV[voltLimitIndex]);
+        if (INA260::voltage_mV > LOAD::VOLT_LIMITS_TABLE_mV[voltLimitIndex]) {
+            // Exceeded threshold voltage
+            load.setLoadGPIO(LOAD::RES_INDEX_TABLE[lCRIndex]);
+            ESP_LOGI(TAG, "Set: %d", LOAD::RES_INDEX_TABLE[lCRIndex]);
+            // Decrease limit
+            if (voltLimitIndex > 0) {
+                // Have not reached lowest value
+                voltLimitIndex--;
+            }
+            // Decrease load cont.
+            if (lCRIndex > 0) {
+                // Have not reached lowest value
+                lCRIndex--;
+                load.setLoadGPIO(LOAD::RES_INDEX_TABLE[lCRIndex]);
+            }
+        } else {
+            // Did not exceed threshold voltage
+            ESP_LOGD(TAG, "No change");
+        }
+#endif
         delay(RUN::TASK_INTERVALS::TI_ADJUST_LOAD_mS);
     }
 }