Skip to content

devices have different upper and lower temperature bounds depending on the car's current state. #350

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
maxr21 wants to merge 2 commits into
base: develop
Choose a base branch
from
Open

devices have different upper and lower temperature bounds depending on the car's current state. #350

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
38e8f52
added functionality for different car states having different upper a…
maxr21 Aug 12, 2025
ccf4688
default state added
maxr21 Sep 2, 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
33 changes: 18 additions & 15 deletions Core/Inc/control.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,19 +19,6 @@
#define CONTROL_CANID_PUMP 0x4A0
#define CONTROL_CANID_RADFAN 0x499

/* Tempeature Constants for Devices */
#define PUMP_UPPER_MOTOR_TEMP 50
#define PUMP_LOWER_MOTOR_TEMP 30

#define RADFAN_UPPER_MOTOR_TEMP 50
#define RADFAN_LOWER_MOTOR_TEMP 30

#define PUMP_UPPER_CONTROLLER_TEMP 50
#define PUMP_LOWER_CONTROLLER_TEMP 30

#define RADFAN_UPPER_CONTROLLER_TEMP 50
#define RADFAN_LOWER_CONTROLLER_TEMP 30

extern osThreadId_t control_handle;
extern const osThreadAttr_t control_attributes;

Expand All @@ -46,14 +33,30 @@ typedef enum {
NUM_DEVICES,
} device_type_t;

// sub-struct holding upper and lower temperature bounds.
typedef struct {
uint8_t upper_motor_temp_bound;
uint8_t lower_motor_temp_bound;
} device_temp_bounds_t;

// struct holding the temperature bounds for a single device for each possible state.
typedef struct {
device_temp_bounds_t ready;
device_temp_bounds_t f_reverse;
device_temp_bounds_t f_pit;
device_temp_bounds_t f_performance;
device_temp_bounds_t f_efficiency;
device_temp_bounds_t faulted;
device_temp_bounds_t standard;
} device_config_t;

/* Holds all the information needed to determine and set the state of a device */
typedef struct {
pdu_t *pdu;
control_func_t control_func; /* function to set device state */
device_type_t device_type; /* Device Type (Pump or Radfan) */
nertimer_t timer; /* Debounce Timer */
uint16_t upper_temp; /* Upper Tempature Limit */
uint16_t lower_temp; /* Lower Tempature Limit */
device_config_t temp_bounds; /* temperature bounds */
} device_control_t;

/* Holds arguments for control thread */
Expand Down
136 changes: 117 additions & 19 deletions Core/Src/control.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,72 @@

bool calypso_states[NUM_DEVICES];

device_temp_bounds_t const pump0_READY = { 20, 10 };
device_temp_bounds_t const pump0_F_REVERSE = { 20, 10 };
device_temp_bounds_t const pump0_F_PIT = { 20, 10 };
device_temp_bounds_t const pump0_F_PERFORMANCE = { 20, 10 };
device_temp_bounds_t const pump0_F_EFFICIENCY = { 20, 10 };
device_temp_bounds_t const pump0_FAULTED = { 20, 10 };
device_temp_bounds_t const pump0_STANDARD = { 20, 10 };

device_temp_bounds_t const pump1_READY = { 20, 10 };
device_temp_bounds_t const pump1_F_REVERSE = { 20, 10 };
device_temp_bounds_t const pump1_F_PIT = { 20, 10 };
device_temp_bounds_t const pump1_F_PERFORMANCE = { 20, 10 };
device_temp_bounds_t const pump1_F_EFFICIENCY = { 20, 10 };
device_temp_bounds_t const pump1_FAULTED = { 20, 10 };
device_temp_bounds_t const pump1_STANDARD = { 20, 10 };

device_temp_bounds_t const radfan0_READY = { 20, 10 };
device_temp_bounds_t const radfan0_F_REVERSE = { 20, 10 };
device_temp_bounds_t const radfan0_F_PIT = { 20, 10 };
device_temp_bounds_t const radfan0_F_PERFORMANCE = { 20, 10 };
device_temp_bounds_t const radfan0_F_EFFICIENCY = { 20, 10 };
device_temp_bounds_t const radfan0_FAULTED = { 20, 10 };
device_temp_bounds_t const radfan0_STANDARD = { 20, 10 };

device_temp_bounds_t const radfan1_READY = { 20, 10 };
device_temp_bounds_t const radfan1_F_REVERSE = { 20, 10 };
device_temp_bounds_t const radfan1_F_PIT = { 20, 10 };
device_temp_bounds_t const radfan1_F_PERFORMANCE = { 20, 10 };
device_temp_bounds_t const radfan1_F_EFFICIENCY = { 20, 10 };
device_temp_bounds_t const radfan1_FAULTED = { 20, 10 };
device_temp_bounds_t const radfan1_STANDARD = { 20, 10 };

device_temp_bounds_t const fanBattBox_READY = { 20, 10 };
device_temp_bounds_t const fanBattBox_F_REVERSE = { 20, 10 };
device_temp_bounds_t const fanBattBox_F_PIT = { 20, 10 };
device_temp_bounds_t const fanBattBox_F_PERFORMANCE = { 20, 10 };
device_temp_bounds_t const fanBattBox_F_EFFICIENCY = { 20, 10 };
device_temp_bounds_t const fanBattBox_FAULTED = { 20, 10 };
device_temp_bounds_t const fanBattBox_STANDARD = { 20, 10 };

device_config_t pump0_config = { pump0_READY, pump0_F_REVERSE,
pump0_F_PIT, pump0_F_PERFORMANCE,
pump0_F_EFFICIENCY, pump0_FAULTED,
pump0_STANDARD };

device_config_t pump1_config = { pump1_READY, pump1_F_REVERSE,
pump1_F_PIT, pump1_F_PERFORMANCE,
pump1_F_EFFICIENCY, pump1_FAULTED,
pump1_STANDARD };

device_config_t radfan0_config = { radfan0_READY, radfan0_F_REVERSE,
radfan0_F_PIT, radfan0_F_PERFORMANCE,
radfan0_F_EFFICIENCY, radfan0_FAULTED,
radfan0_STANDARD };

device_config_t radfan1_config = { radfan1_READY, radfan1_F_REVERSE,
radfan1_F_PIT, radfan1_F_PERFORMANCE,
radfan1_F_EFFICIENCY, radfan1_FAULTED,
radfan1_STANDARD };

device_config_t fanBattBox_config = {
fanBattBox_READY, fanBattBox_F_REVERSE, fanBattBox_F_PIT,
fanBattBox_F_PERFORMANCE, fanBattBox_F_EFFICIENCY, fanBattBox_FAULTED,
fanBattBox_STANDARD
};

osThreadId_t control_handle;
const osThreadAttr_t control_attributes = {
.name = "Control",
Expand All @@ -18,13 +84,35 @@ static void set_device_on(void *params)
{
device_control_t *device = (device_control_t *)params;
device->control_func(device->pdu, true);
}
};

// callback function to turn device off after debounce
static void set_device_off(void *params)
{
device_control_t *device = (device_control_t *)params;
device->control_func(device->pdu, false);
};

/**
* @brief Sets the device state dependent on current car state and temperature.
*
* @param device Device whose state is being determined.
* @param device_bounds Temperature bounds of the device for the current car state.
* @param temp Temperature reading to determine the state.
*/
static void set_device_state(device_control_t *device,
device_temp_bounds_t device_bounds, uint16_t temp)
{
bool above_max_temp = temp > device_bounds.upper_motor_temp_bound;
bool below_min_temp = temp < device_bounds.lower_motor_temp_bound;

if (above_max_temp) {
debounce(above_max_temp, &(device->timer), 10000, set_device_on,
Copy link
Copy Markdown
Contributor

@jr1221 jr1221 Aug 15, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

please #define the time for debounce (might already exist)?

device);
} else if (below_min_temp || is_timer_active(&device->timer)) {
debounce(below_min_temp, &(device->timer), 10000,
set_device_off, device);
}
}

/**
Expand Down Expand Up @@ -56,16 +144,30 @@ static void control_device(device_control_t *device, uint16_t temp)
return;
}

// set device state based on temps with debounce
if (temp > device->upper_temp || temp < device->lower_temp ||
is_timer_active(&device->timer)) {
if (temp > device->upper_temp) {
debounce(temp > device->upper_temp, &(device->timer),
10000, set_device_on, device);
} else {
debounce(temp < device->lower_temp, &(device->timer),
10000, set_device_off, device);
}
const curr_state = get_func_state();

// Set device state depending on car state and temperature.
switch (curr_state) {
case READY:
set_device_state(device, device->temp_bounds.ready, temp);
break;
case F_PIT:
set_device_state(device, device->temp_bounds.f_pit, temp);
break;
case F_REVERSE:
set_device_state(device, device->temp_bounds.f_reverse, temp);
break;
case F_PERFORMANCE:
set_device_state(device, device->temp_bounds.f_performance,
temp);
break;
case F_EFFICIENCY:
set_device_state(device, device->temp_bounds.f_efficiency,
temp);
break;
case FAULTED:
set_device_state(device, device->temp_bounds.faulted, temp);
break;
}
}

Expand All @@ -82,32 +184,28 @@ void vControl(void *params)
device_control_t pump0 = {
.pdu = pdu,
.control_func = write_pump_0,
.upper_temp = PUMP_UPPER_MOTOR_TEMP,
.lower_temp = PUMP_LOWER_MOTOR_TEMP,
.temp_bounds = pump0_config,
.device_type = DEVICE_PUMP0,
};

device_control_t radfan0 = {
.pdu = pdu,
.control_func = write_radfan_0,
.upper_temp = RADFAN_UPPER_MOTOR_TEMP,
.lower_temp = RADFAN_LOWER_MOTOR_TEMP,
.temp_bounds = radfan0_config,
.device_type = DEVICE_RADFAN0,
};

device_control_t pump1 = {
.pdu = pdu,
.control_func = write_pump_1,
.upper_temp = PUMP_UPPER_CONTROLLER_TEMP,
.lower_temp = PUMP_LOWER_CONTROLLER_TEMP,
.temp_bounds = pump1_config,
.device_type = DEVICE_PUMP1,
};

device_control_t radfan1 = {
.pdu = pdu,
.control_func = write_radfan_1,
.upper_temp = RADFAN_UPPER_CONTROLLER_TEMP,
.lower_temp = RADFAN_LOWER_CONTROLLER_TEMP,
.temp_bounds = radfan1_config,
.device_type = DEVICE_RADFAN1,
};

Expand Down