From 2bf022d156a1356260bf3b3061d1a1c2f9d6f8af Mon Sep 17 00:00:00 2001 From: Shyiu Date: Mon, 27 Oct 2025 11:13:56 -0400 Subject: [PATCH 1/6] Added unit tests to test calculate_charge_current() functionality --- test/test_charge_cycle.h | 138 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 138 insertions(+) diff --git a/test/test_charge_cycle.h b/test/test_charge_cycle.h index d8e4629..75ee910 100644 --- a/test/test_charge_cycle.h +++ b/test/test_charge_cycle.h @@ -146,5 +146,143 @@ MainChargeSystem mainChargeLoop(ccu_data); // EXPECT_NE(mainChargeLoop.calculate_charge_current(MockCCUInterface::mock_receive_message(fake_data::good_volts_high, fake_data::good_temp)),0); // }; +TEST(mainChargeTest, EStopShutsDownCharge) // Not charging b/c SHDN_E_READ = LOW +{ + ccu_data.cutoff_voltage = 4.2f; + ccu_data.max_pack_voltage = 600.0f; + ccu_data.charger_current_max = 120.0f; + + ACUInterfaceInstance::instance().set_latest_data({ + 2, // acu_state + 3.9f, // average_voltage + 3.8f, // low_voltage + CCUData::cutoff_voltage - 0.1f, // high_voltage + CCUData::max_pack_voltage - 10.0f // total_voltage + }); + + // TODO: Set Mock Arduino DigitalRead to 0 + + mainChargeLoop.calculate_charge_current(); + + EXPECT_EQ(ccu_data.charging_state, ChargingState_e::NOT_CHARGING); + EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, 0.0f); + EXPECT_EQ(ccu_data.balancing_enabled, false); +} + +TEST(mainChargeTest, ACUShutsDownCharge) // Not Charging b/c acu_state = 1 +{ + ACUInterfaceInstance::instance().set_latest_data({ + 1, // acu_state + 3.9f, // average_voltage + 3.8f, // low_voltage + CCUData::cutoff_voltage - 0.1f, // high_voltage + CCUData::max_pack_voltage - 10.0f // total_voltage + }); + + mainChargeLoop.calculate_charge_current(); + + EXPECT_EQ(ccu_data.charging_state, ChargingState_e::NOT_CHARGING); + EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, 0.0f); + EXPECT_EQ(ccu_data.balancing_enabled, false); +} + +TEST(mainChargeTest, DoneChargingAtHighVoltage) // Done charging b/c Current Voltage = High Voltage +{ + ACUInterfaceInstance::instance().set_latest_data({ + 2, // acu_state + 3.9f, // average_voltage + 3.8f, // low_voltage + CCUData::cutoff_voltage, // high_voltage + CCUData::max_pack_voltage - 10.0f // total_voltage + }); + + mainChargeLoop.calculate_charge_current(); + + EXPECT_EQ(ccu_data.charging_state, ChargingState_e::DONE_CHARGING); + EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, 0.0f); + EXPECT_EQ(ccu_data.balancing_enabled, false); +} + +TEST(mainChargeTest, DoneChargingOverHighVoltage) // Done charging b/c Current Voltage > High Voltage +{ + ACUInterfaceInstance::instance().set_latest_data({ + 2, // acu_state + 3.9f, // average_voltage + 3.8f, // low_voltage + CCUData::cutoff_voltage + 0.5f, // high_voltage + CCUData::max_pack_voltage - 10.0f // total_voltage + }); + + mainChargeLoop.calculate_charge_current(); + + EXPECT_EQ(ccu_data.charging_state, ChargingState_e::DONE_CHARGING); + EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, 0.0f); + EXPECT_EQ(ccu_data.balancing_enabled, false); +} + +TEST(mainChargeTest, ContinuesChargingUnderHighVoltage) // Continues Charging b/c Current Voltage < High Voltage +{ + ACUInterfaceInstance::instance().set_latest_data({ + 2, // acu_state + 3.9f, // average_voltage + 3.8f, // low_voltage + CCUData::cutoff_voltage - 0.001f, // high_voltage + CCUData::max_pack_voltage - 10.0f // total_voltage + }); + + mainChargeLoop.calculate_charge_current(); + + EXPECT_EQ(ccu_data.charging_state, ChargingState_e::CHARGING); + EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, CCUData::charger_current_max); +} + +TEST(MainChargeTest, DoneChargingOverMaxPackVoltage) // Done charging b/c total_voltage > max_pack_voltage +{ + ACUInterfaceInstance::instance().set_latest_data({ + 2, // acu_state + 3.9f, // average_voltage + 3.8f, // low_voltage + CCUData::cutoff_voltage - 0.1f, // high_voltage + CCUData::max_pack_voltage + 0.1f // total_voltage + }); + + mainChargeLoop.calculate_charge_current(); + + EXPECT_EQ(ccu_data.charging_state, ChargingState_e::DONE_CHARGING); + EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, 0.0f); + EXPECT_EQ(ccu_data.balancing_enabled, false); +} + +TEST(MainChargeTest, ContinuesChargingAtMaxPackVoltage) // Continues charging b/c total_voltage = max_pack_voltage +{ + ACUInterfaceInstance::instance().set_latest_data({ + 2, // acu_state + 3.9f, // average_voltage + 3.8f, // low_voltage + CCUData::cutoff_voltage - 0.1f, // high_voltage + CCUData::max_pack_voltage // total_voltage + }); + + mainChargeLoop.calculate_charge_current(); + + EXPECT_EQ(ccu_data.charging_state, ChargingState_e::CHARGING); + EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, CCUData::charger_current_max); +} + +TEST(MainChargeTest, RegularCharging) // Continues charging b/c within legal bounds +{ + ACUInterfaceInstance::instance().set_latest_data({ + 2, // acu_state + 3.9f, // average_voltage + 3.8f, // low_voltage + CCUData::cutoff_voltage - 0.1f, // high_voltage + CCUData::max_pack_voltage - 10.0f // total_voltage + }); + + mainChargeLoop.calculate_charge_current(); + + EXPECT_EQ(ccu_data.charging_state, ChargingState_e::CHARGING); + EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, CCUData::charger_current_max); +} #endif \ No newline at end of file From 1d662c91fc080abfdf7d4d92ba637327f0e1bb0f Mon Sep 17 00:00:00 2001 From: Shyiu Date: Mon, 27 Oct 2025 11:25:19 -0400 Subject: [PATCH 2/6] Fixed build errors regarding variable assignment --- test/test_charge_cycle.h | 4 ---- 1 file changed, 4 deletions(-) diff --git a/test/test_charge_cycle.h b/test/test_charge_cycle.h index 75ee910..c2e0b11 100644 --- a/test/test_charge_cycle.h +++ b/test/test_charge_cycle.h @@ -148,10 +148,6 @@ MainChargeSystem mainChargeLoop(ccu_data); TEST(mainChargeTest, EStopShutsDownCharge) // Not charging b/c SHDN_E_READ = LOW { - ccu_data.cutoff_voltage = 4.2f; - ccu_data.max_pack_voltage = 600.0f; - ccu_data.charger_current_max = 120.0f; - ACUInterfaceInstance::instance().set_latest_data({ 2, // acu_state 3.9f, // average_voltage From 9ca9ac303dc9b146c36212c5036d6eff74e30423 Mon Sep 17 00:00:00 2001 From: Shyiu Date: Mon, 27 Oct 2025 14:45:54 -0400 Subject: [PATCH 3/6] Removed unused code to reflect new CCU logic changes --- lib/systems/include/MainChargeSystem.h | 15 +-- lib/systems/src/MainChargeSystem.cpp | 8 +- test/test_charge_cycle.h | 155 ------------------------- 3 files changed, 7 insertions(+), 171 deletions(-) diff --git a/lib/systems/include/MainChargeSystem.h b/lib/systems/include/MainChargeSystem.h index 89fb32d..801805c 100644 --- a/lib/systems/include/MainChargeSystem.h +++ b/lib/systems/include/MainChargeSystem.h @@ -19,21 +19,18 @@ class MainChargeSystem { public: /** - * @param target_volt The wanted final voltage for an individual cell, the charger will not charge past this voltage - * @param max_cell_temp The maximum allowable cell temperature while charging + * @param ccu_data A reference to the main CCU data struct */ MainChargeSystem(CCUData &ccu_data) : _ccu_data(ccu_data) {}; - /** - * @brief function that returns a float value of the current to be sent to charge controller for this charge cycle - * @param ACUAllData_s struct populated with raw data from ACU - */ + /** + * @brief Calculates the correct charge current based on ACU data and + * safety limits. Updates _ccu_data.calculated_charge_current and + * _ccu_data.charging_state directly. + */ void calculate_charge_current(); private: - const float _MAXIMUM_NEVER_EXCEED_CURRENT = 25; //25 is a tentative amp value based on 6kw at 240 volts, may need to be adjusted depending on voltage - float _target_voltage_per_cell; //final voltage that we should charge to - float _max_allowable_cell_temperature; CCUData &_ccu_data; }; diff --git a/lib/systems/src/MainChargeSystem.cpp b/lib/systems/src/MainChargeSystem.cpp index dab602b..f32d43a 100644 --- a/lib/systems/src/MainChargeSystem.cpp +++ b/lib/systems/src/MainChargeSystem.cpp @@ -5,14 +5,9 @@ void MainChargeSystem::calculate_charge_current() { - float average_voltage = 0; - float low_voltage = 0; float high_voltage = 0; float total_voltage = 0; - float calculated_charge_current = 0; - average_voltage = ACUInterfaceInstance::instance().get_latest_data().average_voltage; //average voltage across the cells - low_voltage = ACUInterfaceInstance::instance().get_latest_data().low_voltage; //the lowest voltage in any of the cells high_voltage = ACUInterfaceInstance::instance().get_latest_data().high_voltage; //the highest voltage in any of the cells total_voltage = ACUInterfaceInstance::instance().get_latest_data().total_voltage; //the total voltage in the pack @@ -23,7 +18,7 @@ void MainChargeSystem::calculate_charge_current() { */ bool acu_shutdown_low = ACUInterfaceInstance::instance().get_latest_data().acu_state == 1; //NOLINT - bool voltage_reached = (high_voltage >= _ccu_data.cutoff_voltage) || (ACUInterfaceInstance::instance().get_latest_data().total_voltage > _ccu_data.max_pack_voltage); //NOLINT + bool voltage_reached = (high_voltage >= _ccu_data.cutoff_voltage) || (total_voltage > _ccu_data.max_pack_voltage); //NOLINT if (shutdown_low || acu_shutdown_low) { _ccu_data.charging_state = ChargingState_e::NOT_CHARGING; @@ -33,7 +28,6 @@ void MainChargeSystem::calculate_charge_current() { } else { _ccu_data.charging_state = ChargingState_e::CHARGING; } - /* Tells the charger to stop charging if the shutdown button is pressed or one of the cell voltags is too high */ if (voltage_reached || shutdown_low || acu_shutdown_low) { //ACU will cause a BMS fault if there is a cell or board temp that is too high diff --git a/test/test_charge_cycle.h b/test/test_charge_cycle.h index c2e0b11..1f81cbf 100644 --- a/test/test_charge_cycle.h +++ b/test/test_charge_cycle.h @@ -7,164 +7,9 @@ #include #include -namespace fake_data -{ - float volts_too_much[126] = { - 4.723f, 4.152f, 4.891f, 4.346f, 4.678f, 4.234f, 4.567f, 4.912f, 4.389f, 4.745f, - 4.198f, 4.623f, 4.456f, 4.879f, 4.301f, 4.734f, 4.167f, 4.590f, 4.923f, 4.278f, - 4.645f, 4.412f, 4.789f, 4.334f, 4.701f, 4.256f, 4.578f, 4.945f, 4.389f, 4.812f, - 4.167f, 4.534f, 4.890f, 4.223f, 4.667f, 4.401f, 4.778f, 4.345f, 4.690f, 4.256f, - 4.589f, 4.934f, 4.312f, 4.756f, 4.189f, 4.623f, 4.467f, 4.801f, 4.334f, 4.678f, - 4.245f, 4.590f, 4.923f, 4.378f, 4.745f, 4.201f, 4.556f, 4.889f, 4.434f, 4.767f, - 4.312f, 4.645f, 4.978f, 4.223f, 4.590f, 4.156f, 4.523f, 4.867f, 4.401f, 4.734f, - 4.289f, 4.612f, 4.945f, 4.378f, 4.701f, 4.234f, 4.567f, 4.890f, 4.323f, 4.656f, - 4.189f, 4.534f, 4.867f, 4.412f, 4.745f, 4.278f, 4.601f, 4.934f, 4.367f, 4.789f, - 4.223f, 4.556f, 4.890f, 4.345f, 4.678f, 4.201f, 4.534f, 4.867f, 4.389f, 4.723f, - 4.256f, 4.590f, 4.923f, 4.367f, 4.701f, 4.234f, 4.567f, 4.890f, 4.323f, 4.656f, - 4.189f, 4.523f, 4.856f, 4.401f, 4.734f, 4.267f, 4.601f, 4.934f, 4.378f, 4.712f, - 4.245f, 4.578f, 4.912f, 4.356f, 4.689f, 4.223f - }; - float more_volts_too_much[126] = { - 4.834f, 4.267f, 4.956f, 4.401f, 4.723f, 4.189f, 4.612f, 4.978f, 4.345f, 4.790f, - 4.234f, 4.678f, 4.512f, 4.845f, 4.378f, 4.701f, 4.256f, 4.623f, 4.967f, 4.312f, - 4.734f, 4.467f, 4.812f, 4.389f, 4.656f, 4.201f, 4.545f, 4.890f, 4.434f, 4.767f, - 4.289f, 4.612f, 4.945f, 4.378f, 4.701f, 4.256f, 4.578f, 4.923f, 4.367f, 4.734f, - 4.189f, 4.534f, 4.867f, 4.401f, 4.756f, 4.312f, 4.645f, 4.978f, 4.345f, 4.689f, - 4.223f, 4.567f, 4.901f, 4.434f, 4.778f, 4.267f, 4.601f, 4.934f, 4.389f, 4.723f, - 4.256f, 4.590f, 4.923f, 4.367f, 4.701f, 4.234f, 4.567f, 4.890f, 4.323f, 4.656f, - 4.189f, 4.523f, 4.856f, 4.401f, 4.734f, 4.267f, 4.601f, 4.934f, 4.378f, 4.712f, - 4.245f, 4.578f, 4.912f, 4.356f, 4.689f, 4.223f, 4.556f, 4.890f, 4.345f, 4.678f, - 4.201f, 4.534f, 4.867f, 4.389f, 4.723f, 4.256f, 4.590f, 4.923f, 4.367f, 4.701f, - 4.234f, 4.567f, 4.890f, 4.323f, 4.656f, 4.189f, 4.523f, 4.856f, 4.401f, 4.734f, - 4.267f, 4.601f, 4.934f, 4.378f, 4.712f, 4.245f, 4.578f, 4.912f, 4.356f, 4.689f, - 4.223f, 4.556f, 4.890f, 4.345f, 4.678f, 4.201f - }; - - float good_volts_low[126] = { - 2.234f, 2.156f, 2.378f, 2.201f, 2.323f, 2.189f, 2.267f, 2.389f, 2.245f, 2.312f, - 2.167f, 2.298f, 2.356f, 2.223f, 2.278f, 2.201f, 2.334f, 2.389f, 2.256f, 2.312f, - 2.178f, 2.245f, 2.367f, 2.201f, 2.289f, 2.234f, 2.312f, 2.378f, 2.256f, 2.323f, - 2.189f, 2.267f, 2.345f, 2.223f, 2.298f, 2.167f, 2.334f, 2.389f, 2.245f, 2.312f, - 2.201f, 2.278f, 2.356f, 2.234f, 2.289f, 2.167f, 2.323f, 2.378f, 2.256f, 2.312f, - 2.189f, 2.267f, 2.345f, 2.223f, 2.298f, 2.178f, 2.334f, 2.389f, 2.245f, 2.312f, - 2.201f, 2.278f, 2.356f, 2.234f, 2.289f, 2.167f, 2.323f, 2.378f, 2.256f, 2.312f, - 2.189f, 2.267f, 2.345f, 2.223f, 2.298f, 2.178f, 2.334f, 2.389f, 2.245f, 2.312f, - 2.201f, 2.278f, 2.356f, 2.234f, 2.289f, 2.167f, 2.323f, 2.378f, 2.256f, 2.312f, - 2.189f, 2.267f, 2.345f, 2.223f, 2.298f, 2.178f, 2.334f, 2.389f, 2.245f, 2.312f, - 2.201f, 2.278f, 2.356f, 2.234f, 2.289f, 2.167f, 2.323f, 2.378f, 2.256f, 2.312f, - 2.189f, 2.267f, 2.345f, 2.223f, 2.298f, 2.178f, 2.334f, 2.389f, 2.245f, 2.312f, - 2.201f, 2.278f, 2.356f, 2.234f, 2.289f, 2.167f - }; - - float good_volts_high[126] = { - 2.856f, 2.734f, 2.978f, 2.812f, 2.923f, 2.789f, 2.867f, 2.945f, 2.801f, 2.889f, - 2.756f, 2.834f, 2.912f, 2.978f, 2.845f, 2.723f, 2.901f, 2.867f, 2.789f, 2.956f, - 2.834f, 2.712f, 2.890f, 2.945f, 2.801f, 2.878f, 2.756f, 2.923f, 2.867f, 2.789f, - 2.934f, 2.812f, 2.890f, 2.978f, 2.845f, 2.723f, 2.901f, 2.856f, 2.789f, 2.967f, - 2.834f, 2.712f, 2.890f, 2.945f, 2.801f, 2.878f, 2.756f, 2.923f, 2.867f, 2.789f, - 2.934f, 2.812f, 2.890f, 2.978f, 2.845f, 2.723f, 2.901f, 2.856f, 2.789f, 2.967f, - 2.834f, 2.712f, 2.890f, 2.945f, 2.801f, 2.878f, 2.756f, 2.923f, 2.867f, 2.789f, - 2.934f, 2.812f, 2.890f, 2.978f, 2.845f, 2.723f, 2.901f, 2.856f, 2.789f, 2.967f, - 2.834f, 2.712f, 2.890f, 2.945f, 2.801f, 2.878f, 2.756f, 2.923f, 2.867f, 2.789f, - 2.934f, 2.812f, 2.890f, 2.978f, 2.845f, 2.723f, 2.901f, 2.856f, 2.789f, 2.967f, - 2.834f, 2.712f, 2.890f, 2.945f, 2.801f, 2.878f, 2.756f, 2.923f, 2.867f, 2.789f, - 2.934f, 2.812f, 2.890f, 2.978f, 2.845f, 2.723f, 2.901f, 2.856f, 2.789f, 2.967f, - 2.834f, 2.712f, 2.890f, 2.945f, 2.801f, 2.878f - }; - - float all_temp_high[48] = { - 72.34f, 78.12f, 75.89f, 71.56f, 79.23f, 73.45f, 77.89f, 70.67f, 76.12f, 74.98f, - 71.23f, 78.56f, 75.34f, 79.89f, 72.67f, 77.01f, 73.89f, 76.45f, 70.12f, 78.23f, - 74.56f, 79.67f, 71.89f, 77.34f, 75.12f, 72.78f, 78.45f, 76.89f, 70.56f, 79.01f, - 73.23f, 77.67f, 74.89f, 71.45f, 78.12f, 76.34f, 79.56f, 72.89f, 75.67f, 70.23f, - 77.12f, 73.56f, 78.89f, 71.67f, 76.23f, 74.01f, 79.34f, 72.45f - }; - - float some_temp_high[48] = { - 66.78f, 69.12f, 67.45f, 65.89f, 68.23f, 66.01f, 69.56f, 67.89f, 65.34f, 68.67f, - 66.12f, 69.23f, 67.56f, 65.78f, 68.45f, 66.89f, 69.01f, 67.23f, 65.56f, 68.12f, - 66.34f, 69.67f, 67.89f, 65.23f, 68.56f, 66.78f, 69.45f, 67.01f, 65.89f, 68.23f, - 66.45f, 69.12f, 67.67f, 65.34f, 68.89f, 66.56f, 70.18f, 67.23f, 65.67f, 68.01f, - 66.12f, 69.56f, 67.45f, 65.89f, 68.34f, 66.78f, 69.23f, 67.56f - }; - - float good_temp[48] = { - 52.34f, 54.12f, 51.89f, 53.56f, 50.78f, 54.45f, 52.67f, 51.23f, 53.89f, 50.56f, - 54.01f, 52.78f, 51.45f, 53.12f, 50.89f, 54.34f, 52.56f, 51.67f, 53.23f, 50.45f, - 54.78f, 52.12f, 51.89f, 53.56f, 50.23f, 54.45f, 52.67f, 51.01f, 53.34f, 50.78f, - 54.12f, 52.89f, 51.56f, 53.23f, 50.45f, 54.67f, 52.34f, 51.78f, 53.89f, 50.12f, - 54.56f, 52.23f, 51.67f, 53.45f, 50.89f, 54.01f, 52.78f, 51.34f - }; - - -} // namespace fake_ACUAllData_s - -namespace MockCCUInterface -{ - ACUAllData_s mock_receive_message(float volt_array[126], float temp_array[48]){ - - ACUAllData_s out; - - for (int i = 0; i < 126; i++) - { - out.voltages[i] = volt_array[i]; - } - for (int i = 0; i < 48; i++) - { - out.cell_temperatures[i] = temp_array[i]; - } - return out; - } -} - - CCUData ccu_data; MainChargeSystem mainChargeLoop(ccu_data); -// TEST(mainChargeTest, calculate_charge_current_can_high_avg) { //should not charge because average cell voltage is too high -// ACUInterfaceInstance::create(ccu_data); -// ChargerInterfaceInstance::create(ccu_data); -// ACUInterfaceInstance::instance().set_latest_data({7.0, 3.1, 3.3, 500}); //data is sent in the order of average, low, high, total voltage -// ChargerInterfaceInstance::instance().set_charger_latest_data({13}); -// EXPECT_FLOAT_EQ(mainChargeLoop.calculate_charge_current(), 0); -// } - - -// TEST(mainChargeTest, bothTooHigh){ -// EXPECT_EQ(mainChargeLoop.calculate_charge_current(MockCCUInterface::mock_receive_message(fake_data::volts_too_much, fake_data::all_temp_high)),0); -// }; - -// TEST(mainChargeTest, TempTooHigh){ -// EXPECT_EQ(mainChargeLoop.calculate_charge_current(MockCCUInterface::mock_receive_message(fake_data::good_volts_low, fake_data::some_temp_high)),0); -// }; - -// TEST(mainChargeTest, VoltsTooHigh){ -// EXPECT_EQ(mainChargeLoop.calculate_charge_current(MockCCUInterface::mock_receive_message(fake_data::more_volts_too_much, fake_data::good_temp)),0); -// };x - -// TEST(mainChargeTest, shouldBeTrue){ -// EXPECT_NE(mainChargeLoop.calculate_charge_current(MockCCUInterface::mock_receive_message(fake_data::good_volts_high, fake_data::good_temp)),0); -// }; - -TEST(mainChargeTest, EStopShutsDownCharge) // Not charging b/c SHDN_E_READ = LOW -{ - ACUInterfaceInstance::instance().set_latest_data({ - 2, // acu_state - 3.9f, // average_voltage - 3.8f, // low_voltage - CCUData::cutoff_voltage - 0.1f, // high_voltage - CCUData::max_pack_voltage - 10.0f // total_voltage - }); - - // TODO: Set Mock Arduino DigitalRead to 0 - - mainChargeLoop.calculate_charge_current(); - - EXPECT_EQ(ccu_data.charging_state, ChargingState_e::NOT_CHARGING); - EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, 0.0f); - EXPECT_EQ(ccu_data.balancing_enabled, false); -} - TEST(mainChargeTest, ACUShutsDownCharge) // Not Charging b/c acu_state = 1 { ACUInterfaceInstance::instance().set_latest_data({ From 48886348359ed199c739718206c88aff49999268 Mon Sep 17 00:00:00 2001 From: Shyiu Date: Tue, 28 Oct 2025 19:13:53 -0400 Subject: [PATCH 4/6] Clarified comments + replaced all cases of balanced_charging w/ charging_enabled --- lib/interfaces/src/ACUInterface.cpp | 2 +- lib/interfaces/src/ChargerInterface.cpp | 6 +++--- lib/systems/src/MainChargeSystem.cpp | 4 ++-- lib/utilities/CCUData.h | 3 +-- src/CCUTasks.cpp | 2 +- test/test_charge_cycle.h | 22 +++++++++++----------- 6 files changed, 19 insertions(+), 20 deletions(-) diff --git a/lib/interfaces/src/ACUInterface.cpp b/lib/interfaces/src/ACUInterface.cpp index 8ff1aa6..06692a7 100644 --- a/lib/interfaces/src/ACUInterface.cpp +++ b/lib/interfaces/src/ACUInterface.cpp @@ -75,6 +75,6 @@ void ACUInterface::receive_onboard_detailed_temps(const CAN_message_t& msg, unsi void ACUInterface::enqueue_ccu_status_data() { CCU_STATUS_t ccu_status = {}; - ccu_status.charger_enabled = _ccu_data.balancing_enabled; // Treat this as a balancing_enabled boolean + ccu_status.charger_enabled = _ccu_data.charging_enabled; CAN_util::enqueue_msg(&ccu_status, &Pack_CCU_STATUS_hytech, CCUCANInterfaceImpl::acu_can_tx_buffer); } diff --git a/lib/interfaces/src/ChargerInterface.cpp b/lib/interfaces/src/ChargerInterface.cpp index dbf5494..5ac1133 100644 --- a/lib/interfaces/src/ChargerInterface.cpp +++ b/lib/interfaces/src/ChargerInterface.cpp @@ -14,12 +14,12 @@ void ChargerInterface::receive_charger_data_message(const CAN_message_t& msg, un charger_data.flags = charger_data_msg.flags; charger_data.input_ac_voltage_high = charger_data_msg.input_ac_voltage_high; charger_data.input_ac_voltage_low = charger_data_msg.input_ac_voltage_low; - _ccu_data.balancing_enabled = true; //if a charger message is received, we are ready to start charging + _ccu_data.charging_enabled = true; //if a charger message is received, we are ready to start charging //Serial.println("receieved charger message"); - /* Redundancy to avoid flipping between true and false for balancing (charging) enabled */ + /* Redundancy to avoid flipping between true and false for charging enabled */ if (ACUInterfaceInstance::instance().get_latest_data().total_voltage >= _ccu_data.max_pack_voltage || ACUInterfaceInstance::instance().get_latest_data().high_voltage >= _ccu_data.cutoff_voltage) { - _ccu_data.balancing_enabled = false; + _ccu_data.charging_enabled = false; } } diff --git a/lib/systems/src/MainChargeSystem.cpp b/lib/systems/src/MainChargeSystem.cpp index f32d43a..1691b14 100644 --- a/lib/systems/src/MainChargeSystem.cpp +++ b/lib/systems/src/MainChargeSystem.cpp @@ -14,7 +14,7 @@ void MainChargeSystem::calculate_charge_current() { bool shutdown_low = (digitalRead(_ccu_data.SHDN_E_READ) != HIGH); //e-stop on charge cart /** acu_state comes from the bms_status message. If shutdown is low on ACU (HVP is unplugged), acu_state = 1. - * If acu_state = 2, we should/are safe to be charging + * If acu_state = 1, we are in acu_shutdown_low state. If acu_state = 2, we should/are safe to be charging */ bool acu_shutdown_low = ACUInterfaceInstance::instance().get_latest_data().acu_state == 1; //NOLINT @@ -32,7 +32,7 @@ void MainChargeSystem::calculate_charge_current() { /* Tells the charger to stop charging if the shutdown button is pressed or one of the cell voltags is too high */ if (voltage_reached || shutdown_low || acu_shutdown_low) { //ACU will cause a BMS fault if there is a cell or board temp that is too high _ccu_data.calculated_charge_current = 0; - _ccu_data.balancing_enabled = false; + _ccu_data.charging_enabled = false; } else { _ccu_data.calculated_charge_current = _ccu_data.charger_current_max; // 120 = 3.4 amps } diff --git a/lib/utilities/CCUData.h b/lib/utilities/CCUData.h index db904aa..effa706 100644 --- a/lib/utilities/CCUData.h +++ b/lib/utilities/CCUData.h @@ -12,7 +12,7 @@ enum class ChargingState_e struct CCUData { - bool balancing_enabled = false; //tells ACU whether balancing is allowed or not + bool charging_enabled = false; //tells ACU whether balancing is allowed or not ChargingState_e charging_state = ChargingState_e::NOT_CHARGING; static constexpr float max_allowable_cell_temperature = 40; //need data for this static constexpr float cutoff_voltage = 4.2; //max voltage that cells can be at - if high = this, stop charging @@ -24,7 +24,6 @@ struct CCUData static constexpr const int SHDN_E_READ = 4; float max_cell_temp = 0; float min_cell_temp = 0; //value given for initialization - static constexpr float balancing_voltage = 3.8; //voltage at which cells begin balancing float max_board_temp; }; diff --git a/src/CCUTasks.cpp b/src/CCUTasks.cpp index d330364..2cff76f 100644 --- a/src/CCUTasks.cpp +++ b/src/CCUTasks.cpp @@ -125,7 +125,7 @@ HT_TASK::TaskResponse run_update_display_task(const unsigned long& sysMicros, co HT_TASK::TaskResponse print_data(const unsigned long& sysMicros, const HT_TASK::TaskInfo& taskInfo) { Serial.print("Charge enable: "); - Serial.println(ccu_data.balancing_enabled); + Serial.println(ccu_data.charging_enabled); Serial.print("Charging Status: "); Serial.println(static_cast(ChargerStateMachineInstance::instance().get_state())); Serial.print("BMS Status: "); diff --git a/test/test_charge_cycle.h b/test/test_charge_cycle.h index 1f81cbf..06876f9 100644 --- a/test/test_charge_cycle.h +++ b/test/test_charge_cycle.h @@ -10,7 +10,7 @@ CCUData ccu_data; MainChargeSystem mainChargeLoop(ccu_data); -TEST(mainChargeTest, ACUShutsDownCharge) // Not Charging b/c acu_state = 1 +TEST(mainChargeTest, NotChargingACUShutdown) // ChargingState = NOT_CHARGING b/c acu_state = 1 { ACUInterfaceInstance::instance().set_latest_data({ 1, // acu_state @@ -24,10 +24,10 @@ TEST(mainChargeTest, ACUShutsDownCharge) // Not Charging b/c acu_state = 1 EXPECT_EQ(ccu_data.charging_state, ChargingState_e::NOT_CHARGING); EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, 0.0f); - EXPECT_EQ(ccu_data.balancing_enabled, false); + EXPECT_EQ(ccu_data.charging_enabled, false); } -TEST(mainChargeTest, DoneChargingAtHighVoltage) // Done charging b/c Current Voltage = High Voltage +TEST(mainChargeTest, DoneChargingAtHighVoltage) // ChargingState = DONE_CHARGING b/c Current Voltage = High Voltage { ACUInterfaceInstance::instance().set_latest_data({ 2, // acu_state @@ -41,10 +41,10 @@ TEST(mainChargeTest, DoneChargingAtHighVoltage) // Done charging b/c Current Vol EXPECT_EQ(ccu_data.charging_state, ChargingState_e::DONE_CHARGING); EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, 0.0f); - EXPECT_EQ(ccu_data.balancing_enabled, false); + EXPECT_EQ(ccu_data.charging_enabled, false); } -TEST(mainChargeTest, DoneChargingOverHighVoltage) // Done charging b/c Current Voltage > High Voltage +TEST(mainChargeTest, DoneChargingOverHighVoltage) // ChargingState = DONE_CHARGING b/c Current Voltage > High Voltage { ACUInterfaceInstance::instance().set_latest_data({ 2, // acu_state @@ -58,10 +58,10 @@ TEST(mainChargeTest, DoneChargingOverHighVoltage) // Done charging b/c Current V EXPECT_EQ(ccu_data.charging_state, ChargingState_e::DONE_CHARGING); EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, 0.0f); - EXPECT_EQ(ccu_data.balancing_enabled, false); + EXPECT_EQ(ccu_data.charging_enabled, false); } -TEST(mainChargeTest, ContinuesChargingUnderHighVoltage) // Continues Charging b/c Current Voltage < High Voltage +TEST(mainChargeTest, ChargingUnderHighVoltage) // ChargingState = CHARGING b/c Current Voltage < High Voltage { ACUInterfaceInstance::instance().set_latest_data({ 2, // acu_state @@ -77,7 +77,7 @@ TEST(mainChargeTest, ContinuesChargingUnderHighVoltage) // Continues Charging b/ EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, CCUData::charger_current_max); } -TEST(MainChargeTest, DoneChargingOverMaxPackVoltage) // Done charging b/c total_voltage > max_pack_voltage +TEST(MainChargeTest, DoneChargingOverMaxPackVoltage) // ChargingState = DONE_CHARGING b/c total_voltage > max_pack_voltage { ACUInterfaceInstance::instance().set_latest_data({ 2, // acu_state @@ -91,10 +91,10 @@ TEST(MainChargeTest, DoneChargingOverMaxPackVoltage) // Done charging b/c total_ EXPECT_EQ(ccu_data.charging_state, ChargingState_e::DONE_CHARGING); EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, 0.0f); - EXPECT_EQ(ccu_data.balancing_enabled, false); + EXPECT_EQ(ccu_data.charging_enabled, false); } -TEST(MainChargeTest, ContinuesChargingAtMaxPackVoltage) // Continues charging b/c total_voltage = max_pack_voltage +TEST(MainChargeTest, ChargingAtMaxPackVoltage) // ChargingState = CHARGING charging b/c total_voltage = max_pack_voltage { ACUInterfaceInstance::instance().set_latest_data({ 2, // acu_state @@ -110,7 +110,7 @@ TEST(MainChargeTest, ContinuesChargingAtMaxPackVoltage) // Continues charging b/ EXPECT_FLOAT_EQ(ccu_data.calculated_charge_current, CCUData::charger_current_max); } -TEST(MainChargeTest, RegularCharging) // Continues charging b/c within legal bounds +TEST(MainChargeTest, Charging) // ChargingState = CHARGING b/c within legal bounds { ACUInterfaceInstance::instance().set_latest_data({ 2, // acu_state From 3f852c768627164539e89cf2dca2a70609ad21d3 Mon Sep 17 00:00:00 2001 From: Shyiu Date: Tue, 28 Oct 2025 19:37:54 -0400 Subject: [PATCH 5/6] Fixed build errors regarding missing variables --- lib/state_machine/src/ChargerStateMachine.cpp | 6 +++--- lib/utilities/CCUData.h | 3 ++- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/lib/state_machine/src/ChargerStateMachine.cpp b/lib/state_machine/src/ChargerStateMachine.cpp index 1f92484..49928b9 100644 --- a/lib/state_machine/src/ChargerStateMachine.cpp +++ b/lib/state_machine/src/ChargerStateMachine.cpp @@ -10,7 +10,7 @@ ChargerState_e ChargerStateMachine::tick_state_machine(unsigned long current_mil { //pinMode(_ccu_data.SHDN_E_READ, OUTPUT); - if (_ccu_data.balancing_enabled) { + if (_ccu_data.charging_enabled) { set_state(ChargerState_e::CHARGING_WITH_BALANCING, current_millis); break; } @@ -23,7 +23,7 @@ ChargerState_e ChargerStateMachine::tick_state_machine(unsigned long current_mil case ChargerState_e::CHARGING_WITH_BALANCING: { - if (!(_ccu_data.balancing_enabled)) { + if (!(_ccu_data.charging_enabled)) { set_state(ChargerState_e::CHARGING_NO_BALANCING, current_millis); break; } @@ -35,7 +35,7 @@ ChargerState_e ChargerStateMachine::tick_state_machine(unsigned long current_mil case ChargerState_e::CHARGING_NO_BALANCING: { - if (_ccu_data.balancing_enabled) { + if (_ccu_data.charging_enabled) { set_state(ChargerState_e::CHARGING_WITH_BALANCING, current_millis); break; diff --git a/lib/utilities/CCUData.h b/lib/utilities/CCUData.h index effa706..2f897d0 100644 --- a/lib/utilities/CCUData.h +++ b/lib/utilities/CCUData.h @@ -12,7 +12,7 @@ enum class ChargingState_e struct CCUData { - bool charging_enabled = false; //tells ACU whether balancing is allowed or not + bool charging_enabled = false; //tells ACU whether charging is allowed or not ChargingState_e charging_state = ChargingState_e::NOT_CHARGING; static constexpr float max_allowable_cell_temperature = 40; //need data for this static constexpr float cutoff_voltage = 4.2; //max voltage that cells can be at - if high = this, stop charging @@ -24,6 +24,7 @@ struct CCUData static constexpr const int SHDN_E_READ = 4; float max_cell_temp = 0; float min_cell_temp = 0; //value given for initialization + static constexpr float balancing_voltage = 3.8; //voltage at which cells begin balancing float max_board_temp; }; From 2fdc3e16ffe9202137b96db49da50a5a55fc0935 Mon Sep 17 00:00:00 2001 From: Shyiu Date: Tue, 28 Oct 2025 21:13:28 -0400 Subject: [PATCH 6/6] Added clarification for acu_state state values --- test/test_charge_cycle.h | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/test/test_charge_cycle.h b/test/test_charge_cycle.h index 06876f9..8860bf9 100644 --- a/test/test_charge_cycle.h +++ b/test/test_charge_cycle.h @@ -13,7 +13,7 @@ MainChargeSystem mainChargeLoop(ccu_data); TEST(mainChargeTest, NotChargingACUShutdown) // ChargingState = NOT_CHARGING b/c acu_state = 1 { ACUInterfaceInstance::instance().set_latest_data({ - 1, // acu_state + 1, // acu_state = 1 --> acu_shutdown low 3.9f, // average_voltage 3.8f, // low_voltage CCUData::cutoff_voltage - 0.1f, // high_voltage @@ -30,7 +30,7 @@ TEST(mainChargeTest, NotChargingACUShutdown) // ChargingState = NOT_CHARGING b/c TEST(mainChargeTest, DoneChargingAtHighVoltage) // ChargingState = DONE_CHARGING b/c Current Voltage = High Voltage { ACUInterfaceInstance::instance().set_latest_data({ - 2, // acu_state + 2, // acu_state = 2 --> acu_shutdown high 3.9f, // average_voltage 3.8f, // low_voltage CCUData::cutoff_voltage, // high_voltage @@ -47,7 +47,7 @@ TEST(mainChargeTest, DoneChargingAtHighVoltage) // ChargingState = DONE_CHARGING TEST(mainChargeTest, DoneChargingOverHighVoltage) // ChargingState = DONE_CHARGING b/c Current Voltage > High Voltage { ACUInterfaceInstance::instance().set_latest_data({ - 2, // acu_state + 2, // acu_state = 2 --> acu_shutdown high 3.9f, // average_voltage 3.8f, // low_voltage CCUData::cutoff_voltage + 0.5f, // high_voltage @@ -64,7 +64,7 @@ TEST(mainChargeTest, DoneChargingOverHighVoltage) // ChargingState = DONE_CHARGI TEST(mainChargeTest, ChargingUnderHighVoltage) // ChargingState = CHARGING b/c Current Voltage < High Voltage { ACUInterfaceInstance::instance().set_latest_data({ - 2, // acu_state + 2, // acu_state = 2 --> acu_shutdown high 3.9f, // average_voltage 3.8f, // low_voltage CCUData::cutoff_voltage - 0.001f, // high_voltage @@ -80,7 +80,7 @@ TEST(mainChargeTest, ChargingUnderHighVoltage) // ChargingState = CHARGING b/c C TEST(MainChargeTest, DoneChargingOverMaxPackVoltage) // ChargingState = DONE_CHARGING b/c total_voltage > max_pack_voltage { ACUInterfaceInstance::instance().set_latest_data({ - 2, // acu_state + 2, // acu_state = 2 --> acu_shutdown high 3.9f, // average_voltage 3.8f, // low_voltage CCUData::cutoff_voltage - 0.1f, // high_voltage @@ -97,7 +97,7 @@ TEST(MainChargeTest, DoneChargingOverMaxPackVoltage) // ChargingState = DONE_CHA TEST(MainChargeTest, ChargingAtMaxPackVoltage) // ChargingState = CHARGING charging b/c total_voltage = max_pack_voltage { ACUInterfaceInstance::instance().set_latest_data({ - 2, // acu_state + 2, // acu_state = 2 --> acu_shutdown high 3.9f, // average_voltage 3.8f, // low_voltage CCUData::cutoff_voltage - 0.1f, // high_voltage @@ -113,7 +113,7 @@ TEST(MainChargeTest, ChargingAtMaxPackVoltage) // ChargingState = CHARGING charg TEST(MainChargeTest, Charging) // ChargingState = CHARGING b/c within legal bounds { ACUInterfaceInstance::instance().set_latest_data({ - 2, // acu_state + 2, // acu_state = 2 --> acu_shutdown high 3.9f, // average_voltage 3.8f, // low_voltage CCUData::cutoff_voltage - 0.1f, // high_voltage