Skip to content

Feature/unit tests #16

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
Shyiu wants to merge 6 commits into
base: main
Choose a base branch
from
Open

Feature/unit tests #16

Show file tree
Hide file tree
Changes from 5 commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
2bf022d
Added unit tests to test calculate_charge_current() functionality
Oct 27, 2025
1d662c9
Fixed build errors regarding variable assignment
Oct 27, 2025
9ca9ac3
Removed unused code to reflect new CCU logic changes
Oct 27, 2025
4888634
Clarified comments + replaced all cases of balanced_charging w/ charg…
Oct 28, 2025
3f852c7
Fixed build errors regarding missing variables
Oct 28, 2025
2fdc3e1
Added clarification for acu_state state values
Oct 29, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion lib/interfaces/src/ACUInterface.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
}
6 changes: 3 additions & 3 deletions lib/interfaces/src/ChargerInterface.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;
}
}

Expand Down
6 changes: 3 additions & 3 deletions lib/state_machine/src/ChargerStateMachine.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;
}
Expand All @@ -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;
}
Expand All @@ -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;

Expand Down
15 changes: 6 additions & 9 deletions lib/systems/include/MainChargeSystem.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;
};

Expand Down
12 changes: 3 additions & 9 deletions lib/systems/src/MainChargeSystem.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,25 +5,20 @@

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

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

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;
Expand All @@ -33,12 +28,11 @@ 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
_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
}
Expand Down
2 changes: 1 addition & 1 deletion lib/utilities/CCUData.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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 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
Expand Down
2 changes: 1 addition & 1 deletion src/CCUTasks.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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<int>(ChargerStateMachineInstance::instance().get_state()));
Serial.print("BMS Status: ");
Expand Down
239 changes: 109 additions & 130 deletions test/test_charge_cycle.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,144 +7,123 @@
#include <gtest/gtest.h>
#include <iostream>

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, NotChargingACUShutdown) // ChargingState = 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.charging_enabled, false);
}

TEST(mainChargeTest, DoneChargingAtHighVoltage) // ChargingState = 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.charging_enabled, false);
}

// 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, DoneChargingOverHighVoltage) // ChargingState = 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.charging_enabled, false);
}

// 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, ChargingUnderHighVoltage) // ChargingState = 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, 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, DoneChargingOverMaxPackVoltage) // ChargingState = 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.charging_enabled, false);
}

// 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, ChargingAtMaxPackVoltage) // ChargingState = CHARGING 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, Charging) // ChargingState = 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