From cc7d7fff015a06b1464d74f6410eda91a1ea967c Mon Sep 17 00:00:00 2001 From: Jack Rubacha Date: Sat, 25 Jan 2025 18:42:53 -0500 Subject: [PATCH] add some messages, split can and compute, remove some header circ --- Core/Inc/adi_interaction.h | 12 + Core/Inc/analyzer.h | 2 - Core/Inc/can_messages.h | 208 ++++++++++++ Core/Inc/compute.h | 212 +----------- Core/Inc/eepromdirectory.h | 1 - Core/Inc/main.h | 2 +- Core/Inc/segment.h | 1 - Core/Inc/shep_tasks.h | 2 +- Core/Inc/stateMachine.h | 4 - Core/Src/adi_interaction.c | 5 + Core/Src/analyzer.c | 21 +- Core/Src/can_handler.c | 4 +- Core/Src/can_messages.c | 653 +++++++++++++++++++++++++++++++++++++ Core/Src/compute.c | 635 +----------------------------------- Core/Src/main.c | 23 +- Core/Src/segment.c | 20 +- Core/Src/shep_tasks.c | 30 +- Core/Src/stateMachine.c | 18 +- Makefile | 1 + 19 files changed, 945 insertions(+), 909 deletions(-) create mode 100644 Core/Inc/can_messages.h create mode 100644 Core/Src/can_messages.c diff --git a/Core/Inc/adi_interaction.h b/Core/Inc/adi_interaction.h index da04d7dd..0d4eb914 100644 --- a/Core/Inc/adi_interaction.h +++ b/Core/Inc/adi_interaction.h @@ -1,3 +1,6 @@ +#ifndef ADI_INTERACTION_H +#define ADI_INTERACTION_H + #include "adBms6830Data.h" #include "bmsConfig.h" @@ -176,6 +179,13 @@ void adc_and_read_aux2_registers(cell_asic chips[NUM_CHIPS]); */ void read_status_registers(cell_asic chips[NUM_CHIPS]); +/** + * @brief Read status register c, containing chip level faults. + * + * @param chips + */ +void read_status_register_c(cell_asic chips[NUM_CHIPS]); + /** * @brief Read status and aux registers in one command. * @@ -236,3 +246,5 @@ void get_c_and_s_adc_voltages(cell_asic chips[NUM_CHIPS]); void start_c_adc_conv(); // --- END ADC POLL --- + +#endif \ No newline at end of file diff --git a/Core/Inc/analyzer.h b/Core/Inc/analyzer.h index d89a1bbe..382d1876 100644 --- a/Core/Inc/analyzer.h +++ b/Core/Inc/analyzer.h @@ -1,9 +1,7 @@ #ifndef ANALYZER_H #define ANALYZER_H -//#include Replace #include "datastructs.h" -#include "segment.h" // this is a simple empirical mapping of which therms are returning good data // Only in use because we can not seem to correclty map incoming therms - this allows us to forcibley select those that we visually noticed were good diff --git a/Core/Inc/can_messages.h b/Core/Inc/can_messages.h new file mode 100644 index 00000000..5ac650f6 --- /dev/null +++ b/Core/Inc/can_messages.h @@ -0,0 +1,208 @@ +#ifndef CAN_MESSAGES_H +#define CAN_MESSAGES_H + +#include "datastructs.h" + +/** + * @brief sends charger message + * + * @param voltage_to_set + * @param currentToSet + * + * @return Returns a fault if we are not able to communicate with charger + */ +int send_charging_message(uint16_t voltage_to_set, uint16_t current_to_set, + acc_data_t *bms_data); + +/** + * @brief Sends max discharge current to Motor Controller. + * + * @param bmsdata data structure containing the discharge limit + */ +void send_mc_discharge_message(acc_data_t *bmsdata); + +/** + * @brief sends max charge/discharge current to Motor Controller + * + * @param bmsdata + */ +void send_mc_charge_message(acc_data_t *bmsdata); + +/** + * @brief sends acc status message + * + * @param voltage + * @param current + * @param ah + * @param soc + * @param health + * + * @return Returns a fault if we are not able to send + */ +void send_acc_status_message(acc_data_t *bmsdata); + +/** + * @brief sends fault status message + * + * @param bms_state + * + */ +void send_fault_status_message(acc_data_t *bmsdata); + +/** + * @brief sends BMS status message + * + * @param bms_state + * @param fault_status + * @param tempAvg + * @param tempInternal + * + * @return Returns a fault if we are not able to send + */ +void send_bms_status_message(acc_data_t *bmsdata, int bms_state, bool balance); + +/** + * @brief sends shutdown control message + * @note unused + * + * @param mpe_state + * + * @return Returns a fault if we are not able to send + */ +void send_shutdown_ctrl_message(uint8_t mpe_state); + +/** + * @brief sends cell data message + * + * @param high_voltage + * @param low_voltage + * @param avg_voltage + * + * @return Returns a fault if we are not able to send + */ +void send_cell_voltage_message(acc_data_t *bmsdata); + +/** + * @brief sends out the calculated values of currents + * + * @param discharge + * @param charge + * @param current + */ +void send_current_message(acc_data_t *bmsdata); + +/** + * @brief sends cell temperature message + * + * @return Returns a fault if we are not able to send + */ +void send_cell_temp_message(acc_data_t *bmsdata); + +/** + * @brief sends the average segment temperatures + * + * + * + * @return Returns a fault if we are not able to send + */ +void send_segment_temp_message(acc_data_t *bmsdata); + +void send_fault_message(uint8_t status, int16_t curr, int16_t in_dcl); + +void send_fault_timer_message(uint8_t start_stop, uint32_t fault_code, + uint16_t data_1); + +/** + * @brief Send CAN message for debugging the car on the fly. + * + * @param debug0 + * @param debug1 + * @param debug2 + * @param debug3 + */ +void send_debug_message(uint8_t debug0, uint8_t debug1, uint16_t debug2, + uint32_t debug3); + +/** + * @brief Send CAN message containing voltage noise data. + * @note Unused + * + * @param bmsdata + */ +void send_voltage_noise_message(acc_data_t *bmsdata); + +/** + * @brief Send a message containing cell data. + * + * @param alpha If this message contains alpha cell data. False sends a beta cell message. + * @param temperature Temperature in Celsius. Has a maximum value of 80 degrees celsius. + * @param voltage_a The voltage of cell A. + * @param voltage_b The voltage of cell B. + * @param chip_ID The chip ID. + * @param cell_a The number of cell A. + * @param cell_b The number of cell B. + * @param discharging_a The state of cell A while balancing. + * @param discharging_b The state of cell B while balancing. + */ +void send_cell_data_message(bool alpha, uint16_t temperature, + uint16_t voltage_a, uint16_t voltage_b, + uint8_t chip_ID, uint8_t cell_a, uint8_t cell_b, + bool discharging_a, bool discharging_b); + +/** + * @brief Send cell message containing Beta cell 10, the Beta onboard therm, the temperature of the ADBMS6830 die, and the voltage from V+ to V-. + * + * @param cell_temperature Temperature of Beta cell 10. + * @param voltage Voltage of Beta cell 10. + * @param discharging Whether or not the cell is discharging. + * @param chip The ID of the chip. + * @param segment_temperature The output of the onboard therm. + * @param die_temperature The temperature of the ADBMS6830 die. + * @param vpv The voltage from V+ to V-. + */ +void send_beta_status_a_message(uint16_t cell_temperature, uint16_t voltage, + bool discharging, uint8_t chip, + uint16_t segment_temperature, + uint16_t die_temperature, uint16_t vpv); + +/** + * @brief Send message containing ADBMS6830 diagnostic data. + * + * @param vref2 Second reference voltage for ADBMS6830. + * @param v_analog Analog power supply voltage. + * @param v_digital Digital power supply voltage. + * @param chip ID of the chip. + * @param v_res VREF2 across a resistor for open wire detection. + * @param vmv Voltage between S1N and V-. + */ +void send_beta_status_b_message(uint16_t vref2, uint16_t v_analog, + uint16_t v_digital, uint8_t chip, + uint16_t v_res, uint16_t vmv); + +/** + * @brief Send message containing ADBMS6830 diagnostic data and onboard therm data. + * + * @param segment_temp Temperature reading from on-board therm. + * @param chip ID of the chip. + * @param die_temperature Temperature of the ADBOS6830 die. + * @param vpv The voltage from V+ to V-. + * @param vmv Voltage between S1N and V-. + * @param flt_reg The fault register of the chip (statc) + */ +void send_alpha_status_a_message(uint16_t segment_temp, uint8_t chip, + uint16_t die_temperature, uint16_t vpv, + uint16_t vmv, stc_ *flt_reg); + +/** + * @brief Send message containing ADBMS6830 diagnostic data. + * + * @param v_res VREF2 across a resistor for open wire detection. + * @param chip ID of the chip. + * @param vref2 Second reference voltage for ADBMS6830. + * @param v_analog Analog power supply voltage. + * @param v_digital Digital power supply voltage. + */ +void send_alpha_status_b_message(uint16_t v_res, uint8_t chip, uint16_t vref2, + uint16_t v_analog, uint16_t v_digital); + +#endif \ No newline at end of file diff --git a/Core/Inc/compute.h b/Core/Inc/compute.h index 9620af90..2a6d5083 100644 --- a/Core/Inc/compute.h +++ b/Core/Inc/compute.h @@ -1,8 +1,10 @@ #ifndef COMPUTE_H #define COMPUTE_H -#include "datastructs.h" -#include "stateMachine.h" +#include +#include + +#include "stm32f4xx.h" #define CURRENT_SENSOR_PIN_L A1 #define CURRENT_SENSOR_PIN_H A0 @@ -28,18 +30,6 @@ uint8_t compute_init(); */ void compute_enable_charging(bool enable_charging); -/** - * @brief sends charger message - * - * @param voltage_to_set - * @param currentToSet - * - * @return Returns a fault if we are not able to communicate with charger - */ -int compute_send_charging_message(uint16_t voltage_to_set, - uint16_t current_to_set, - acc_data_t *bms_data); - /** * @brief Returns if charger interlock is engaged, indicating charger LV connector is plugged in * @@ -75,20 +65,6 @@ uint8_t compute_set_fan_speed(TIM_HandleTypeDef *pwmhandle, */ int16_t compute_get_pack_current(); -/** - * @brief Sends max discharge current to Motor Controller. - * - * @param bmsdata data structure containing the discharge limit - */ -void compute_send_mc_discharge_message(acc_data_t *bmsdata); - -/** - * @brief sends max charge/discharge current to Motor Controller - * - * @param bmsdata - */ -void compute_send_mc_charge_message(acc_data_t *bmsdata); - /** * @brief updates fault relay * @@ -96,184 +72,4 @@ void compute_send_mc_charge_message(acc_data_t *bmsdata); */ void compute_set_fault(int fault_state); -/** - * @brief sends acc status message - * - * @param voltage - * @param current - * @param ah - * @param soc - * @param health - * - * @return Returns a fault if we are not able to send - */ -void compute_send_acc_status_message(acc_data_t *bmsdata); - -/** - * @brief sends fault status message - * - * @param bms_state - * - */ -void compute_send_fault_status_message(acc_data_t *bmsdata); - -/** - * @brief sends BMS status message - * - * @param bms_state - * @param fault_status - * @param tempAvg - * @param tempInternal - * - * @return Returns a fault if we are not able to send - */ -void compute_send_bms_status_message(acc_data_t *bmsdata, int bms_state, - bool balance); - -/** - * @brief sends shutdown control message - * @note unused - * - * @param mpe_state - * - * @return Returns a fault if we are not able to send - */ -void compute_send_shutdown_ctrl_message(uint8_t mpe_state); - -/** - * @brief sends cell data message - * - * @param high_voltage - * @param low_voltage - * @param avg_voltage - * - * @return Returns a fault if we are not able to send - */ -void compute_send_cell_voltage_message(acc_data_t *bmsdata); - -/** - * @brief sends out the calculated values of currents - * - * @param discharge - * @param charge - * @param current - */ -void compute_send_current_message(acc_data_t *bmsdata); - -/** - * @brief sends cell temperature message - * - * @return Returns a fault if we are not able to send - */ -void compute_send_cell_temp_message(acc_data_t *bmsdata); - -/** - * @brief sends the average segment temperatures - * - * - * - * @return Returns a fault if we are not able to send - */ -void compute_send_segment_temp_message(acc_data_t *bmsdata); - -void compute_send_fault_message(uint8_t status, int16_t curr, int16_t in_dcl); - -void compute_send_fault_timer_message(uint8_t start_stop, uint32_t fault_code, - uint16_t data_1); - -/** - * @brief Send CAN message for debugging the car on the fly. - * - * @param debug0 - * @param debug1 - * @param debug2 - * @param debug3 - */ -void compute_send_debug_message(uint8_t debug0, uint8_t debug1, uint16_t debug2, - uint32_t debug3); - -/** - * @brief Send CAN message containing voltage noise data. - * @note Unused - * - * @param bmsdata - */ -void compute_send_voltage_noise_message(acc_data_t *bmsdata); - -/** - * @brief Send a message containing cell data. - * - * @param alpha If this message contains alpha cell data. False sends a beta cell message. - * @param temperature Temperature in Celsius. Has a maximum value of 80 degrees celsius. - * @param voltage_a The voltage of cell A. - * @param voltage_b The voltage of cell B. - * @param chip_ID The chip ID. - * @param cell_a The number of cell A. - * @param cell_b The number of cell B. - * @param discharging_a The state of cell A while balancing. - * @param discharging_b The state of cell B while balancing. - */ -void compute_send_cell_data_message(bool alpha, uint16_t temperature, - uint16_t voltage_a, uint16_t voltage_b, - uint8_t chip_ID, uint8_t cell_a, - uint8_t cell_b, bool discharging_a, - bool discharging_b); - -/** - * @brief Send cell message containing Beta cell 10, the Beta onboard therm, the temperature of the ADBMS6830 die, and the voltage from V+ to V-. - * - * @param cell_temperature Temperature of Beta cell 10. - * @param voltage Voltage of Beta cell 10. - * @param discharging Whether or not the cell is discharging. - * @param chip The ID of the chip. - * @param segment_temperature The output of the onboard therm. - * @param die_temperature The temperature of the ADBMS6830 die. - * @param vpv The voltage from V+ to V-. - */ -void compute_send_beta_status_a_message(uint16_t cell_temperature, - uint16_t voltage, bool discharging, - uint8_t chip, - uint16_t segment_temperature, - uint16_t die_temperature, uint16_t vpv); - -/** - * @brief Send message containing ADBMS6830 diagnostic data. - * - * @param vref2 Second reference voltage for ADBMS6830. - * @param v_analog Analog power supply voltage. - * @param v_digital Digital power supply voltage. - * @param chip ID of the chip. - * @param v_res VREF2 across a resistor for open wire detection. - * @param vmv Voltage between S1N and V-. - */ -void compute_send_beta_status_b_message(uint16_t vref2, uint16_t v_analog, - uint16_t v_digital, uint8_t chip, - uint16_t v_res, uint16_t vmv); - -/** - * @brief Send message containing ADBMS6830 diagnostic data and onboard therm data. - * - * @param segment_temp Temperature reading from on-board therm. - * @param chip ID of the chip. - * @param die_temperature Temperature of the ADBOS6830 die. - * @param vpv The voltage from V+ to V-. - * @param vmv Voltage between S1N and V-. - */ -void compute_send_alpha_status_a_message(uint16_t segment_temp, uint8_t chip, - uint16_t die_temperature, uint16_t vpv, - uint16_t vmv); - -/** - * @brief Send message containing ADBMS6830 diagnostic data. - * - * @param v_res VREF2 across a resistor for open wire detection. - * @param chip ID of the chip. - * @param vref2 Second reference voltage for ADBMS6830. - * @param v_analog Analog power supply voltage. - * @param v_digital Digital power supply voltage. - */ -void compute_send_alpha_status_b_message(uint16_t v_res, uint8_t chip, - uint16_t vref2, uint16_t v_analog, - uint16_t v_digital); - #endif // COMPUTE_H diff --git a/Core/Inc/eepromdirectory.h b/Core/Inc/eepromdirectory.h index 4ca45308..252afbeb 100644 --- a/Core/Inc/eepromdirectory.h +++ b/Core/Inc/eepromdirectory.h @@ -1,7 +1,6 @@ #ifndef EEPROMDIRECTORY_H #define EEPROMDIRECTORY_H -#include "bmsConfig.h" #include #include diff --git a/Core/Inc/main.h b/Core/Inc/main.h index 3e0f39b4..833bd74f 100644 --- a/Core/Inc/main.h +++ b/Core/Inc/main.h @@ -31,7 +31,7 @@ extern "C" { /* Private includes ----------------------------------------------------------*/ /* USER CODE BEGIN Includes */ -#include + /* USER CODE END Includes */ /* Exported types ------------------------------------------------------------*/ diff --git a/Core/Inc/segment.h b/Core/Inc/segment.h index 5f899a74..50494653 100644 --- a/Core/Inc/segment.h +++ b/Core/Inc/segment.h @@ -1,7 +1,6 @@ #ifndef SEGMENT_H #define SEGMENT_H -#include "bmsConfig.h" #include "datastructs.h" /** diff --git a/Core/Inc/shep_tasks.h b/Core/Inc/shep_tasks.h index da18dccd..83ed1400 100644 --- a/Core/Inc/shep_tasks.h +++ b/Core/Inc/shep_tasks.h @@ -11,7 +11,7 @@ #ifndef SHEP_TASKS_H #define SHEP_TASKS_H -#include "cmsis_os2.h" +#include "cmsis_os.h" /** * @brief Task for retrieving segment data diff --git a/Core/Inc/stateMachine.h b/Core/Inc/stateMachine.h index 04d55fd5..29aefa27 100644 --- a/Core/Inc/stateMachine.h +++ b/Core/Inc/stateMachine.h @@ -2,10 +2,6 @@ #define BMS_STATES_H #include "analyzer.h" -#include "compute.h" -#include "datastructs.h" -#include "segment.h" -#include "timer.h" /* global that can be read for debugging in main */ extern BMSState_t current_state; diff --git a/Core/Src/adi_interaction.c b/Core/Src/adi_interaction.c index e7b321a1..87fe8bd7 100644 --- a/Core/Src/adi_interaction.c +++ b/Core/Src/adi_interaction.c @@ -307,6 +307,11 @@ void read_status_registers(cell_asic chips[NUM_CHIPS]) read_adbms_data(chips, RDSTATE, Status, E); } +void read_status_register_c(cell_asic chips[NUM_CHIPS]) +{ + read_adbms_data(chips, RDSTATC, Status, C); +} + void read_status_aux_registers(cell_asic chips[NUM_CHIPS]) { read_adbms_data(chips, RDASALL, Rdasall, ALL_GRP); diff --git a/Core/Src/analyzer.c b/Core/Src/analyzer.c index 4ef2bc46..27e4a1ce 100644 --- a/Core/Src/analyzer.c +++ b/Core/Src/analyzer.c @@ -1,11 +1,8 @@ #include "analyzer.h" -#include -#include #include -#include "compute.h" - +#include "can_messages.h" #include "serialPrintResult.h" #define GPIO1 0 @@ -276,7 +273,7 @@ void calc_pack_temps(acc_data_t *bmsdata) /* Takes the average of all the cell temperatures. */ bmsdata->avg_temp = total_temp / NUM_CELLS; - compute_send_cell_temp_message(bmsdata); + send_cell_temp_message(bmsdata); } void calc_pack_voltage_stats(acc_data_t *bmsdata) @@ -367,8 +364,8 @@ void calc_pack_voltage_stats(acc_data_t *bmsdata) bmsdata->pack_ocv = total_ocv / 1000; /* convert to voltage * 10 */ bmsdata->delt_ocv = bmsdata->max_ocv.val - bmsdata->min_ocv.val; - compute_send_acc_status_message(bmsdata); - compute_send_cell_voltage_message(bmsdata); + send_acc_status_message(bmsdata); + send_cell_voltage_message(bmsdata); } void calc_cell_resistances(acc_data_t *bmsdata) @@ -469,8 +466,8 @@ void calc_dcl(acc_data_t *bmsdata) prev_dcl -= DCDC_CURRENT_DRAW; } - compute_send_mc_discharge_message(bmsdata); - compute_send_current_message(bmsdata); + send_mc_discharge_message(bmsdata); + send_current_message(bmsdata); } //TODO: Fix for new cells and BMS @@ -519,8 +516,8 @@ void calcCCL(acc_data_t *bmsdata) bmsdata->charge_limit = currentLimit; } - compute_send_mc_charge_message(bmsdata); - compute_send_current_message(bmsdata); + send_mc_charge_message(bmsdata); + send_current_message(bmsdata); } //TODO: Change for P45B electrical characteristics. @@ -696,7 +693,7 @@ void calc_state_of_charge(acc_data_t *bmsdata) bmsdata->soc = 0; } - compute_send_acc_status_message(bmsdata); + send_acc_status_message(bmsdata); } // NOTE: This function is broken or something. diff --git a/Core/Src/can_handler.c b/Core/Src/can_handler.c index c2931558..a7d1df1b 100644 --- a/Core/Src/can_handler.c +++ b/Core/Src/can_handler.c @@ -1,8 +1,8 @@ #include "can_handler.h" -#include + #include +#include #include -#include #define CAN_MSG_QUEUE_SIZE 50 /* messages */ diff --git a/Core/Src/can_messages.c b/Core/Src/can_messages.c new file mode 100644 index 00000000..6bff9f35 --- /dev/null +++ b/Core/Src/can_messages.c @@ -0,0 +1,653 @@ +#include "can_messages.h" + +#include + +#include "can.h" +#include "can_handler.h" + +extern is_charging_enabled; + +int send_charging_message(uint16_t voltage_to_set, uint16_t current_to_set, + acc_data_t *bms_data) +{ + struct __attribute__((__packed__)) { + uint16_t charger_voltage; // Note the charger voltage sent over should be + // 10*desired voltage + uint16_t charger_current; // Note the charge current sent over should be + // 10*desired current + uint8_t charger_control; + uint8_t reserved_1; + uint16_t reserved_23; + } charger_msg_data; + + charger_msg_data.charger_voltage = voltage_to_set * 10; + charger_msg_data.charger_current = current_to_set * 10; + + if (is_charging_enabled) { + charger_msg_data.charger_control = 0x00; // 0：Start charging. + } else { + charger_msg_data.charger_control = + 0xFF; // 1：battery protection, stop charging + } + + charger_msg_data.reserved_1 = 0x00; + charger_msg_data.reserved_23 = 0x0000; + + can_msg_t charger_msg; + charger_msg.id = 0x1806E5F4; + charger_msg.len = 8; + memcpy(charger_msg.data, &charger_msg_data, sizeof(charger_msg_data)); + + uint8_t temp = charger_msg.data[0]; + charger_msg.data[0] = charger_msg.data[1]; + charger_msg.data[1] = temp; + temp = charger_msg.data[2]; + charger_msg.data[2] = charger_msg.data[3]; + charger_msg.data[3] = temp; + +#ifdef CHARGING_ENABLED + HAL_StatusTypeDef res = can_send_extended_msg(&can2, &charger_msg); + if (res != HAL_OK) { + printf("CAN ERROR CODE %X", res); + } +#endif + + return 0; +} + +void send_mc_discharge_message(acc_data_t *bmsdata) +{ + struct __attribute__((__packed__)) { + uint16_t max_discharge; + } discharge_data; + + /* scale to A * 10 */ + discharge_data.max_discharge = 10 * bmsdata->discharge_limit; + + /* convert to big endian */ + endian_swap(&discharge_data.max_discharge, + sizeof(discharge_data.max_discharge)); + + can_msg_t msg; + msg.id = DISCHARGE_CANID; + msg.len = DISCHARGE_SIZE; + + memcpy(msg.data, &discharge_data, sizeof(discharge_data)); + + queue_can_msg(msg); +} + +void send_mc_charge_message(acc_data_t *bmsdata) +{ + struct __attribute__((__packed__)) { + int16_t max_charge; + } charge_data; + + /* scale to A * 10 */ + charge_data.max_charge = -10 * bmsdata->charge_limit; + + /* convert to big endian */ + endian_swap(&charge_data.max_charge, sizeof(charge_data.max_charge)); + + can_msg_t msg; + msg.id = CHARGE_CANID; + msg.len = CHARGE_SIZE; + + memcpy(msg.data, &charge_data, sizeof(charge_data)); + + queue_can_msg(msg); +} + +void send_acc_status_message(acc_data_t *bmsdata) +{ + struct __attribute__((__packed__)) { + uint16_t packVolt; + uint16_t pack_current; + uint16_t pack_ah; + uint8_t pack_soc; + uint8_t pack_health; + } acc_status_msg_data; + + acc_status_msg_data.packVolt = bmsdata->pack_voltage; + acc_status_msg_data.pack_current = + (uint16_t)(bmsdata->pack_current); // convert with 2s complement + acc_status_msg_data.pack_ah = 0; + acc_status_msg_data.pack_soc = bmsdata->soc; + acc_status_msg_data.pack_health = 0; + + /* convert to big endian */ + endian_swap(&acc_status_msg_data.packVolt, + sizeof(acc_status_msg_data.packVolt)); + endian_swap(&acc_status_msg_data.pack_current, + sizeof(acc_status_msg_data.pack_current)); + endian_swap(&acc_status_msg_data.pack_ah, + sizeof(acc_status_msg_data.pack_ah)); + + can_msg_t msg; + msg.id = ACC_STATUS_CANID; + msg.len = ACC_STATUS_SIZE; + + memcpy(msg.data, &acc_status_msg_data, sizeof(acc_status_msg_data)); + + queue_can_msg(msg); +} + +void send_fault_status_message(acc_data_t *bmsdata) +{ + struct __attribute__((__packed__)) { + uint32_t fault_crit; + uint32_t fault_noncrit; + } fault_status_msg_data; + + /* convert to big endian */ + endian_swap(&fault_status_msg_data.fault_crit, + sizeof(fault_status_msg_data.fault_crit)); + endian_swap(&fault_status_msg_data.fault_noncrit, + sizeof(fault_status_msg_data.fault_noncrit)); + + fault_status_msg_data.fault_crit = bmsdata->fault_code_crit; + fault_status_msg_data.fault_noncrit = bmsdata->fault_code_noncrit; + + can_msg_t fault_msg; + fault_msg.id = FAULT_STATUS_CANID; + fault_msg.len = FAULT_STATUS_SIZE; + + memcpy(fault_msg.data, &fault_status_msg_data, + sizeof(fault_status_msg_data)); + + queue_can_msg(fault_msg); +} + +void send_bms_status_message(acc_data_t *bmsdata, int bms_state, bool balance) +{ + struct __attribute__((__packed__)) { + uint8_t state; + int8_t temp_avg; + uint8_t temp_internal; + uint8_t balance; + } bms_status_msg_data; + + bms_status_msg_data.temp_avg = (int8_t)(bmsdata->avg_temp); + bms_status_msg_data.state = (uint8_t)(bms_state); + bms_status_msg_data.temp_internal = (uint8_t)(0); + bms_status_msg_data.balance = (uint8_t)(balance); + + can_msg_t msg; + msg.id = BMS_STATUS_CANID; + msg.len = BMS_STATUS_SIZE; + + memcpy(msg.data, &bms_status_msg_data, sizeof(bms_status_msg_data)); + + queue_can_msg(msg); +} + +void send_shutdown_ctrl_message(uint8_t mpe_state) +{ + struct __attribute__((__packed__)) { + uint8_t mpeState; + } shutdown_control_msg_data; + + shutdown_control_msg_data.mpeState = mpe_state; + + can_msg_t msg; + msg.id = SHUTDOWN_CTRL_CANID; + msg.len = SHUTDOWN_CTRL_SIZE; + + memcpy(msg.data, &shutdown_control_msg_data, + sizeof(shutdown_control_msg_data)); + + queue_can_msg(msg); +} + +void send_cell_voltage_message(acc_data_t *bmsdata) +{ + struct __attribute__((__packed__)) { + uint16_t high_cell_voltage; + uint8_t high_cell_id; + uint16_t low_cell_voltage; + uint8_t low_cell_id; + uint16_t volt_avg; + } cell_data_msg_data; + + cell_data_msg_data.high_cell_voltage = bmsdata->max_voltage.val; + cell_data_msg_data.high_cell_id = + (bmsdata->max_voltage.chipIndex << 4) | + bmsdata->max_voltage.cellNum; + cell_data_msg_data.low_cell_voltage = bmsdata->min_voltage.val; + cell_data_msg_data.low_cell_id = (bmsdata->min_voltage.chipIndex << 4) | + bmsdata->min_voltage.cellNum; + cell_data_msg_data.volt_avg = bmsdata->avg_voltage; + + /* convert to big endian */ + endian_swap(&cell_data_msg_data.high_cell_voltage, + sizeof(cell_data_msg_data.high_cell_voltage)); + endian_swap(&cell_data_msg_data.low_cell_voltage, + sizeof(cell_data_msg_data.low_cell_voltage)); + endian_swap(&cell_data_msg_data.volt_avg, + sizeof(cell_data_msg_data.volt_avg)); + + can_msg_t msg; + msg.id = CELL_DATA_CANID; + msg.len = CELL_DATA_SIZE; + + memcpy(msg.data, &cell_data_msg_data, sizeof(cell_data_msg_data)); + + queue_can_msg(msg); +} + +void send_current_message(acc_data_t *bmsdata) +{ + struct __attribute__((__packed__)) { + uint16_t dcl; + int16_t ccl; + uint16_t pack_curr; + } current_status_msg_data; + + current_status_msg_data.dcl = bmsdata->discharge_limit; + current_status_msg_data.ccl = -1 * bmsdata->charge_limit; + current_status_msg_data.pack_curr = bmsdata->pack_current; + + /* convert to big endian */ + endian_swap(¤t_status_msg_data.dcl, + sizeof(current_status_msg_data.dcl)); + endian_swap(¤t_status_msg_data.ccl, + sizeof(current_status_msg_data.ccl)); + endian_swap(¤t_status_msg_data.pack_curr, + sizeof(current_status_msg_data.pack_curr)); + + can_msg_t msg; + msg.id = CURRENT_CANID; + msg.len = CURRENT_SIZE; + + memcpy(msg.data, ¤t_status_msg_data, + sizeof(current_status_msg_data)); + + queue_can_msg(msg); +} + +void send_cell_temp_message(acc_data_t *bmsdata) +{ + struct __attribute__((__packed__)) { + uint16_t max_cell_temp; + uint8_t max_cell_id; + uint16_t min_cell_temp; + uint8_t min_cell_id; + uint16_t average_temp; + } cell_temp_msg_data; + + cell_temp_msg_data.max_cell_temp = bmsdata->max_temp.val; + cell_temp_msg_data.max_cell_id = (bmsdata->max_temp.chipIndex << 4) | + (bmsdata->max_temp.cellNum - 17); + cell_temp_msg_data.min_cell_temp = bmsdata->min_temp.val; + cell_temp_msg_data.min_cell_id = (bmsdata->min_temp.chipIndex << 4) | + (bmsdata->min_temp.cellNum - 17); + cell_temp_msg_data.average_temp = bmsdata->avg_temp; + + /* convert to big endian */ + endian_swap(&cell_temp_msg_data.max_cell_temp, + sizeof(cell_temp_msg_data.max_cell_temp)); + endian_swap(&cell_temp_msg_data.min_cell_temp, + sizeof(cell_temp_msg_data.min_cell_temp)); + endian_swap(&cell_temp_msg_data.average_temp, + sizeof(cell_temp_msg_data.average_temp)); + + can_msg_t msg; + msg.id = CELL_TEMP_CANID; + msg.len = CELL_TEMP_SIZE; + + memcpy(msg.data, &cell_temp_msg_data, sizeof(cell_temp_msg_data)); + + queue_can_msg(msg); +} + +void send_segment_temp_message(acc_data_t *bmsdata) +{ + struct __attribute__((__packed__)) { + int8_t segment1_average_temp; + int8_t segment2_average_temp; + int8_t segment3_average_temp; + int8_t segment4_average_temp; + int8_t segment5_average_temp; + int8_t segment6_average_temp; + + } segment_temp_msg_data; + + segment_temp_msg_data.segment1_average_temp = + bmsdata->segment_average_temps[0]; + segment_temp_msg_data.segment2_average_temp = + bmsdata->segment_average_temps[1]; + segment_temp_msg_data.segment3_average_temp = + bmsdata->segment_average_temps[2]; + segment_temp_msg_data.segment4_average_temp = + bmsdata->segment_average_temps[3]; + segment_temp_msg_data.segment5_average_temp = + bmsdata->segment_average_temps[4]; + segment_temp_msg_data.segment6_average_temp = + bmsdata->segment_average_temps[5]; + + can_msg_t msg; + msg.id = SEGMENT_TEMP_CANID; + msg.len = SEGMENT_TEMP_SIZE; + + memcpy(msg.data, &segment_temp_msg_data, sizeof(segment_temp_msg_data)); + + queue_can_msg(msg); +} + +void send_fault_message(uint8_t status, int16_t curr, int16_t in_dcl) +{ + struct __attribute__((__packed__)) { + uint8_t status; + int16_t pack_curr; + int16_t dcl; + } fault_msg_data; + + fault_msg_data.status = status; + fault_msg_data.pack_curr = curr; + fault_msg_data.dcl = in_dcl; + + endian_swap(&fault_msg_data.pack_curr, + sizeof(fault_msg_data.pack_curr)); + endian_swap(&fault_msg_data.dcl, sizeof(fault_msg_data.dcl)); + + can_msg_t msg; + msg.id = FAULT_CANID; + msg.len = FAULT_SIZE; + + memcpy(msg.data, &fault_msg_data, sizeof(fault_msg_data)); + + queue_can_msg(msg); +} + +void send_fault_timer_message(uint8_t start_stop, uint32_t fault_code, + uint16_t data_1) +{ + struct __attribute__((__packed__)) { + uint8_t start_stop; + uint8_t fault_code; + int16_t data_1; + } fault_timer_msg_data; + + fault_timer_msg_data.start_stop = start_stop; + fault_timer_msg_data.fault_code = log2(fault_code); + fault_timer_msg_data.data_1 = data_1; + + endian_swap(&fault_timer_msg_data.fault_code, + sizeof(fault_timer_msg_data.fault_code)); + endian_swap(&fault_timer_msg_data.data_1, + sizeof(fault_timer_msg_data.data_1)); + + can_msg_t msg; + msg.id = FAULT_TIMER_CANID; + msg.len = FAULT_TIMER_SIZE; + + memcpy(msg.data, &fault_timer_msg_data, sizeof(fault_timer_msg_data)); + + queue_can_msg(msg); +} + +void send_voltage_noise_message(acc_data_t *bmsdata) +{ + struct __attribute__((__packed__)) { + uint8_t seg1_noise; + uint8_t seg2_noise; + uint8_t seg3_noise; + uint8_t seg4_noise; + uint8_t seg5_noise; + uint8_t seg6_noise; + } voltage_noise_msg_data; + + voltage_noise_msg_data.seg1_noise = + bmsdata->segment_noise_percentage[0]; + voltage_noise_msg_data.seg2_noise = + bmsdata->segment_noise_percentage[1]; + voltage_noise_msg_data.seg3_noise = + bmsdata->segment_noise_percentage[2]; + voltage_noise_msg_data.seg4_noise = + bmsdata->segment_noise_percentage[3]; + voltage_noise_msg_data.seg5_noise = + bmsdata->segment_noise_percentage[4]; + voltage_noise_msg_data.seg6_noise = + bmsdata->segment_noise_percentage[5]; + + can_msg_t msg; + msg.id = NOISE_CANID; + msg.len = NOISE_SIZE; + + memcpy(msg.data, &voltage_noise_msg_data, + sizeof(voltage_noise_msg_data)); + + queue_can_msg(msg); +} + +void send_debug_message(uint8_t debug0, uint8_t debug1, uint16_t debug2, + uint32_t debug3) +{ + struct __attribute__((__packed__)) { + uint8_t debug0; + uint8_t debug1; + uint16_t debug2; + uint32_t debug3; + } debug_msg_data; + + debug_msg_data.debug0 = debug0; + debug_msg_data.debug1 = debug1; + debug_msg_data.debug2 = debug2; + debug_msg_data.debug3 = debug3; + + endian_swap(&debug_msg_data.debug2, sizeof(debug_msg_data.debug2)); + endian_swap(&debug_msg_data.debug3, sizeof(debug_msg_data.debug3)); + + can_msg_t msg; + msg.id = DEBUG_CANID; + msg.len = DEBUG_SIZE; + + memcpy(msg.data, &debug_msg_data, 8); + + queue_can_msg(msg); +} + +void send_cell_data_message(bool alpha, uint16_t temperature, + uint16_t voltage_a, uint16_t voltage_b, + uint8_t chip_ID, uint8_t cell_a, uint8_t cell_b, + bool discharging_a, bool discharging_b) +{ + endian_swap(&temperature, sizeof(temperature)); + endian_swap(&voltage_a, sizeof(voltage_a)); + endian_swap(&voltage_b, sizeof(voltage_b)); + + struct __attribute__((__packed__)) { + uint16_t temperature : 10; + uint16_t voltage_a : 13; + uint16_t voltage_b : 13; + uint8_t chip_ID : 4; + uint8_t cell_a : 4; + uint8_t cell_b : 4; + uint8_t discharging_a : 1; + uint8_t discharging_b : 1; + } cell_data_msg_data; + + cell_data_msg_data.temperature = temperature; + cell_data_msg_data.voltage_a = voltage_a; + cell_data_msg_data.voltage_b = voltage_b; + cell_data_msg_data.chip_ID = chip_ID; + cell_data_msg_data.cell_a = cell_a; + cell_data_msg_data.cell_b = cell_b; + cell_data_msg_data.discharging_a = discharging_a; + cell_data_msg_data.discharging_b = discharging_b; + + can_msg_t msg; + if (alpha) { + msg.id = ALPHA_CELL_CANID; + } else { + msg.id = BETA_CELL_CANID; + } + msg.len = CELL_MSG_SIZE; + + memcpy(msg.data, &cell_data_msg_data, CELL_MSG_SIZE); + + queue_can_msg(msg); +} + +void send_beta_status_a_message(uint16_t cell_temperature, uint16_t voltage, + bool discharging, uint8_t chip, + uint16_t segment_temperature, + uint16_t die_temperature, uint16_t vpv) +{ + endian_swap(&cell_temperature, sizeof(cell_temperature)); + endian_swap(&voltage, sizeof(voltage)); + endian_swap(&segment_temperature, sizeof(segment_temperature)); + endian_swap(&die_temperature, sizeof(die_temperature)); + endian_swap(&vpv, sizeof(vpv)); + + struct __attribute__((__packed__)) { + uint16_t cell_temperature : 10; + uint16_t voltage : 13; + uint8_t discharging : 1; + uint8_t chip : 4; + uint16_t segment_temperature : 10; + uint16_t die_temperature : 13; + uint16_t vpv : 13; + } beta_status_a_data; + + beta_status_a_data.cell_temperature = cell_temperature; + beta_status_a_data.voltage = voltage; + beta_status_a_data.discharging = discharging; + beta_status_a_data.chip = chip; + beta_status_a_data.segment_temperature = segment_temperature; + beta_status_a_data.die_temperature = die_temperature; + beta_status_a_data.vpv = vpv; + + can_msg_t msg; + msg.id = BETA_STAT_A_CANID; + msg.len = BETA_STAT_A_SIZE; + + memcpy(msg.data, &beta_status_a_data, BETA_STAT_A_SIZE); + + queue_can_msg(msg); +} + +void send_beta_status_b_message(uint16_t vref2, uint16_t v_analog, + uint16_t v_digital, uint8_t chip, + uint16_t v_res, uint16_t vmv) +{ + endian_swap(&vref2, sizeof(vref2)); + endian_swap(&v_analog, sizeof(v_analog)); + endian_swap(&v_digital, sizeof(v_digital)); + endian_swap(&v_res, sizeof(v_res)); + endian_swap(&vmv, sizeof(vmv)); + + struct __attribute__((__packed__)) { + uint16_t vref2 : 13; + uint16_t v_analog : 10; + uint16_t v_digital : 10; + uint8_t chip : 4; + uint16_t v_res : 13; + uint16_t vmv : 13; + } beta_status_b_data; + + beta_status_b_data.vref2 = vref2; + beta_status_b_data.v_analog = v_analog; + beta_status_b_data.v_digital = v_digital; + beta_status_b_data.chip = chip; + beta_status_b_data.v_res = v_res; + beta_status_b_data.vmv = vmv; + + can_msg_t msg; + msg.id = BETA_STAT_B_CANID; + msg.len = BETA_STAT_B_SIZE; + + memcpy(msg.data, &beta_status_b_data, BETA_STAT_B_SIZE); + + queue_can_msg(msg); +} + +void send_alpha_status_a_message(uint16_t segment_temp, uint8_t chip, + uint16_t die_temperature, uint16_t vpv, + uint16_t vmv, stc_ *flt_reg) +{ + endian_swap(&segment_temp, sizeof(segment_temp)); + endian_swap(&die_temperature, sizeof(die_temperature)); + endian_swap(&vpv, sizeof(vpv)); + endian_swap(&vmv, sizeof(vmv)); + + struct __attribute__((__packed__)) { + uint16_t segment_temp : 10; + uint8_t chip : 4; + uint16_t die_temperature : 13; + uint16_t vpv : 13; + uint16_t vmv : 13; + uint8_t va_ov : 1; + uint8_t va_uv : 1; + uint8_t vd_ov : 1; + uint8_t vd_uv : 1; + uint8_t otp1_med : 1; + uint8_t otp2_med : 1; + uint8_t vde : 1; + uint8_t vdel : 1; + uint8_t spiflt : 1; + uint8_t sleep : 1; + uint8_t thsd : 1; + uint8_t tmodchk : 1; + uint8_t oscchk : 1; + } alpha_status_a_data; + + alpha_status_a_data.va_ov = flt_reg->va_ov; + alpha_status_a_data.va_uv = flt_reg->va_uv; + alpha_status_a_data.vd_ov = flt_reg->vd_ov; + alpha_status_a_data.vd_uv = flt_reg->vd_uv; + alpha_status_a_data.otp1_med = flt_reg->otp1_med; + alpha_status_a_data.otp2_med = flt_reg->otp2_med; + alpha_status_a_data.vde = flt_reg->vde; + alpha_status_a_data.vdel = flt_reg->vdel; + alpha_status_a_data.spiflt = flt_reg->spiflt; + alpha_status_a_data.sleep = flt_reg->sleep; + alpha_status_a_data.thsd = flt_reg->thsd; + alpha_status_a_data.tmodchk = flt_reg->tmodchk; + alpha_status_a_data.oscchk = flt_reg->oscchk; + + alpha_status_a_data.segment_temp = segment_temp; + alpha_status_a_data.chip = chip; + alpha_status_a_data.die_temperature = die_temperature; + alpha_status_a_data.vpv = vpv; + alpha_status_a_data.vmv = vmv; + + can_msg_t msg; + msg.id = ALPHA_STAT_A_CANID; + msg.len = ALPHA_STAT_A_SIZE; + + memcpy(msg.data, &alpha_status_a_data, ALPHA_STAT_A_SIZE); + + queue_can_msg(msg); +} + +void send_alpha_status_b_message(uint16_t v_res, uint8_t chip, uint16_t vref2, + uint16_t v_analog, uint16_t v_digital) +{ + endian_swap(&v_res, sizeof(v_res)); + endian_swap(&vref2, sizeof(vref2)); + endian_swap(&v_analog, sizeof(v_analog)); + endian_swap(&v_digital, sizeof(v_digital)); + + struct __attribute__((__packed__)) { + uint16_t v_res : 13; + uint8_t chip : 4; + uint16_t vref2 : 13; + uint16_t v_analog : 13; + uint16_t v_digital : 13; + } alpha_status_b_data; + + alpha_status_b_data.v_res = v_res; + alpha_status_b_data.chip = chip; + alpha_status_b_data.vref2 = vref2; + alpha_status_b_data.v_analog = v_analog; + alpha_status_b_data.v_digital = v_digital; + + can_msg_t msg; + msg.id = ALPHA_STAT_B_CANID; + msg.len = ALPHA_STAT_B_SIZE; + + memcpy(msg.data, &alpha_status_b_data, ALPHA_STAT_B_SIZE); + + queue_can_msg(msg); +} \ No newline at end of file diff --git a/Core/Src/compute.c b/Core/Src/compute.c index e7de1add..1986feee 100644 --- a/Core/Src/compute.c +++ b/Core/Src/compute.c @@ -1,14 +1,9 @@ #include "compute.h" -#include "c_utils.h" -#include "main.h" -#include "stm32f405xx.h" + #include -#include -#include -#include -#include "bmsConfig.h" -#include "can_handler.h" -#include + +#include "datastructs.h" +#include "main.h" #define REF_CHANNEL 0 #define VOUT_CHANNEL 1 @@ -79,54 +74,6 @@ void compute_enable_charging(bool enable_charging) is_charging_enabled = enable_charging; } -int compute_send_charging_message(uint16_t voltage_to_set, - uint16_t current_to_set, acc_data_t *bms_data) -{ - struct __attribute__((__packed__)) { - uint16_t charger_voltage; // Note the charger voltage sent over should be - // 10*desired voltage - uint16_t charger_current; // Note the charge current sent over should be - // 10*desired current - uint8_t charger_control; - uint8_t reserved_1; - uint16_t reserved_23; - } charger_msg_data; - - charger_msg_data.charger_voltage = voltage_to_set * 10; - charger_msg_data.charger_current = current_to_set * 10; - - if (is_charging_enabled) { - charger_msg_data.charger_control = 0x00; // 0：Start charging. - } else { - charger_msg_data.charger_control = - 0xFF; // 1：battery protection, stop charging - } - - charger_msg_data.reserved_1 = 0x00; - charger_msg_data.reserved_23 = 0x0000; - - can_msg_t charger_msg; - charger_msg.id = 0x1806E5F4; - charger_msg.len = 8; - memcpy(charger_msg.data, &charger_msg_data, sizeof(charger_msg_data)); - - uint8_t temp = charger_msg.data[0]; - charger_msg.data[0] = charger_msg.data[1]; - charger_msg.data[1] = temp; - temp = charger_msg.data[2]; - charger_msg.data[2] = charger_msg.data[3]; - charger_msg.data[3] = temp; - -#ifdef CHARGING_ENABLED - HAL_StatusTypeDef res = can_send_extended_msg(&can2, &charger_msg); - if (res != HAL_OK) { - printf("CAN ERROR CODE %X", res); - } -#endif - - return 0; -} - bool compute_charger_connected() { #ifdef CHARGING @@ -254,580 +201,6 @@ int16_t compute_get_pack_current() return -high_current; } -void compute_send_mc_discharge_message(acc_data_t *bmsdata) -{ - struct __attribute__((__packed__)) { - uint16_t max_discharge; - } discharge_data; - - /* scale to A * 10 */ - discharge_data.max_discharge = 10 * bmsdata->discharge_limit; - - /* convert to big endian */ - endian_swap(&discharge_data.max_discharge, - sizeof(discharge_data.max_discharge)); - - can_msg_t msg; - msg.id = DISCHARGE_CANID; - msg.len = DISCHARGE_SIZE; - - memcpy(msg.data, &discharge_data, sizeof(discharge_data)); - - queue_can_msg(msg); -} - -void compute_send_mc_charge_message(acc_data_t *bmsdata) -{ - struct __attribute__((__packed__)) { - int16_t max_charge; - } charge_data; - - /* scale to A * 10 */ - charge_data.max_charge = -10 * bmsdata->charge_limit; - - /* convert to big endian */ - endian_swap(&charge_data.max_charge, sizeof(charge_data.max_charge)); - - can_msg_t msg; - msg.id = CHARGE_CANID; - msg.len = CHARGE_SIZE; - - memcpy(msg.data, &charge_data, sizeof(charge_data)); - - queue_can_msg(msg); -} - -void compute_send_acc_status_message(acc_data_t *bmsdata) -{ - struct __attribute__((__packed__)) { - uint16_t packVolt; - uint16_t pack_current; - uint16_t pack_ah; - uint8_t pack_soc; - uint8_t pack_health; - } acc_status_msg_data; - - acc_status_msg_data.packVolt = bmsdata->pack_voltage; - acc_status_msg_data.pack_current = - (uint16_t)(bmsdata->pack_current); // convert with 2s complement - acc_status_msg_data.pack_ah = 0; - acc_status_msg_data.pack_soc = bmsdata->soc; - acc_status_msg_data.pack_health = 0; - - /* convert to big endian */ - endian_swap(&acc_status_msg_data.packVolt, - sizeof(acc_status_msg_data.packVolt)); - endian_swap(&acc_status_msg_data.pack_current, - sizeof(acc_status_msg_data.pack_current)); - endian_swap(&acc_status_msg_data.pack_ah, - sizeof(acc_status_msg_data.pack_ah)); - - can_msg_t msg; - msg.id = ACC_STATUS_CANID; - msg.len = ACC_STATUS_SIZE; - - memcpy(msg.data, &acc_status_msg_data, sizeof(acc_status_msg_data)); - - queue_can_msg(msg); -} - -void compute_send_fault_status_message(acc_data_t *bmsdata) -{ - struct __attribute__((__packed__)) { - uint32_t fault_crit; - uint32_t fault_noncrit; - } fault_status_msg_data; - - /* convert to big endian */ - endian_swap(&fault_status_msg_data.fault_crit, - sizeof(fault_status_msg_data.fault_crit)); - endian_swap(&fault_status_msg_data.fault_noncrit, - sizeof(fault_status_msg_data.fault_noncrit)); - - fault_status_msg_data.fault_crit = bmsdata->fault_code_crit; - fault_status_msg_data.fault_noncrit = bmsdata->fault_code_noncrit; - - can_msg_t fault_msg; - fault_msg.id = FAULT_STATUS_CANID; - fault_msg.len = FAULT_STATUS_SIZE; - - memcpy(fault_msg.data, &fault_status_msg_data, - sizeof(fault_status_msg_data)); - - queue_can_msg(fault_msg); -} - -void compute_send_bms_status_message(acc_data_t *bmsdata, int bms_state, - bool balance) -{ - struct __attribute__((__packed__)) { - uint8_t state; - int8_t temp_avg; - uint8_t temp_internal; - uint8_t balance; - } bms_status_msg_data; - - bms_status_msg_data.temp_avg = (int8_t)(bmsdata->avg_temp); - bms_status_msg_data.state = (uint8_t)(bms_state); - bms_status_msg_data.temp_internal = (uint8_t)(0); - bms_status_msg_data.balance = (uint8_t)(balance); - - can_msg_t msg; - msg.id = BMS_STATUS_CANID; - msg.len = BMS_STATUS_SIZE; - - memcpy(msg.data, &bms_status_msg_data, sizeof(bms_status_msg_data)); - - queue_can_msg(msg); -} - -void compute_send_shutdown_ctrl_message(uint8_t mpe_state) -{ - struct __attribute__((__packed__)) { - uint8_t mpeState; - } shutdown_control_msg_data; - - shutdown_control_msg_data.mpeState = mpe_state; - - can_msg_t msg; - msg.id = SHUTDOWN_CTRL_CANID; - msg.len = SHUTDOWN_CTRL_SIZE; - - memcpy(msg.data, &shutdown_control_msg_data, - sizeof(shutdown_control_msg_data)); - - queue_can_msg(msg); -} - -void compute_send_cell_voltage_message(acc_data_t *bmsdata) -{ - struct __attribute__((__packed__)) { - uint16_t high_cell_voltage; - uint8_t high_cell_id; - uint16_t low_cell_voltage; - uint8_t low_cell_id; - uint16_t volt_avg; - } cell_data_msg_data; - - cell_data_msg_data.high_cell_voltage = bmsdata->max_voltage.val; - cell_data_msg_data.high_cell_id = - (bmsdata->max_voltage.chipIndex << 4) | - bmsdata->max_voltage.cellNum; - cell_data_msg_data.low_cell_voltage = bmsdata->min_voltage.val; - cell_data_msg_data.low_cell_id = (bmsdata->min_voltage.chipIndex << 4) | - bmsdata->min_voltage.cellNum; - cell_data_msg_data.volt_avg = bmsdata->avg_voltage; - - /* convert to big endian */ - endian_swap(&cell_data_msg_data.high_cell_voltage, - sizeof(cell_data_msg_data.high_cell_voltage)); - endian_swap(&cell_data_msg_data.low_cell_voltage, - sizeof(cell_data_msg_data.low_cell_voltage)); - endian_swap(&cell_data_msg_data.volt_avg, - sizeof(cell_data_msg_data.volt_avg)); - - can_msg_t msg; - msg.id = CELL_DATA_CANID; - msg.len = CELL_DATA_SIZE; - - memcpy(msg.data, &cell_data_msg_data, sizeof(cell_data_msg_data)); - - queue_can_msg(msg); -} - -void compute_send_current_message(acc_data_t *bmsdata) -{ - struct __attribute__((__packed__)) { - uint16_t dcl; - int16_t ccl; - uint16_t pack_curr; - } current_status_msg_data; - - current_status_msg_data.dcl = bmsdata->discharge_limit; - current_status_msg_data.ccl = -1 * bmsdata->charge_limit; - current_status_msg_data.pack_curr = bmsdata->pack_current; - - /* convert to big endian */ - endian_swap(¤t_status_msg_data.dcl, - sizeof(current_status_msg_data.dcl)); - endian_swap(¤t_status_msg_data.ccl, - sizeof(current_status_msg_data.ccl)); - endian_swap(¤t_status_msg_data.pack_curr, - sizeof(current_status_msg_data.pack_curr)); - - can_msg_t msg; - msg.id = CURRENT_CANID; - msg.len = CURRENT_SIZE; - - memcpy(msg.data, ¤t_status_msg_data, - sizeof(current_status_msg_data)); - - queue_can_msg(msg); -} - -void compute_send_cell_temp_message(acc_data_t *bmsdata) -{ - struct __attribute__((__packed__)) { - uint16_t max_cell_temp; - uint8_t max_cell_id; - uint16_t min_cell_temp; - uint8_t min_cell_id; - uint16_t average_temp; - } cell_temp_msg_data; - - cell_temp_msg_data.max_cell_temp = bmsdata->max_temp.val; - cell_temp_msg_data.max_cell_id = (bmsdata->max_temp.chipIndex << 4) | - (bmsdata->max_temp.cellNum - 17); - cell_temp_msg_data.min_cell_temp = bmsdata->min_temp.val; - cell_temp_msg_data.min_cell_id = (bmsdata->min_temp.chipIndex << 4) | - (bmsdata->min_temp.cellNum - 17); - cell_temp_msg_data.average_temp = bmsdata->avg_temp; - - /* convert to big endian */ - endian_swap(&cell_temp_msg_data.max_cell_temp, - sizeof(cell_temp_msg_data.max_cell_temp)); - endian_swap(&cell_temp_msg_data.min_cell_temp, - sizeof(cell_temp_msg_data.min_cell_temp)); - endian_swap(&cell_temp_msg_data.average_temp, - sizeof(cell_temp_msg_data.average_temp)); - - can_msg_t msg; - msg.id = CELL_TEMP_CANID; - msg.len = CELL_TEMP_SIZE; - - memcpy(msg.data, &cell_temp_msg_data, sizeof(cell_temp_msg_data)); - - queue_can_msg(msg); -} - -void compute_send_segment_temp_message(acc_data_t *bmsdata) -{ - struct __attribute__((__packed__)) { - int8_t segment1_average_temp; - int8_t segment2_average_temp; - int8_t segment3_average_temp; - int8_t segment4_average_temp; - int8_t segment5_average_temp; - int8_t segment6_average_temp; - - } segment_temp_msg_data; - - segment_temp_msg_data.segment1_average_temp = - bmsdata->segment_average_temps[0]; - segment_temp_msg_data.segment2_average_temp = - bmsdata->segment_average_temps[1]; - segment_temp_msg_data.segment3_average_temp = - bmsdata->segment_average_temps[2]; - segment_temp_msg_data.segment4_average_temp = - bmsdata->segment_average_temps[3]; - segment_temp_msg_data.segment5_average_temp = - bmsdata->segment_average_temps[4]; - segment_temp_msg_data.segment6_average_temp = - bmsdata->segment_average_temps[5]; - - can_msg_t msg; - msg.id = SEGMENT_TEMP_CANID; - msg.len = SEGMENT_TEMP_SIZE; - - memcpy(msg.data, &segment_temp_msg_data, sizeof(segment_temp_msg_data)); - - queue_can_msg(msg); -} - -void compute_send_fault_message(uint8_t status, int16_t curr, int16_t in_dcl) -{ - struct __attribute__((__packed__)) { - uint8_t status; - int16_t pack_curr; - int16_t dcl; - } fault_msg_data; - - fault_msg_data.status = status; - fault_msg_data.pack_curr = curr; - fault_msg_data.dcl = in_dcl; - - endian_swap(&fault_msg_data.pack_curr, - sizeof(fault_msg_data.pack_curr)); - endian_swap(&fault_msg_data.dcl, sizeof(fault_msg_data.dcl)); - - can_msg_t msg; - msg.id = FAULT_CANID; - msg.len = FAULT_SIZE; - - memcpy(msg.data, &fault_msg_data, sizeof(fault_msg_data)); - - queue_can_msg(msg); -} - -void compute_send_fault_timer_message(uint8_t start_stop, uint32_t fault_code, - uint16_t data_1) -{ - struct __attribute__((__packed__)) { - uint8_t start_stop; - uint8_t fault_code; - int16_t data_1; - } fault_timer_msg_data; - - fault_timer_msg_data.start_stop = start_stop; - fault_timer_msg_data.fault_code = log2(fault_code); - fault_timer_msg_data.data_1 = data_1; - - endian_swap(&fault_timer_msg_data.fault_code, - sizeof(fault_timer_msg_data.fault_code)); - endian_swap(&fault_timer_msg_data.data_1, - sizeof(fault_timer_msg_data.data_1)); - - can_msg_t msg; - msg.id = FAULT_TIMER_CANID; - msg.len = FAULT_TIMER_SIZE; - - memcpy(msg.data, &fault_timer_msg_data, sizeof(fault_timer_msg_data)); - - queue_can_msg(msg); -} - -void compute_send_voltage_noise_message(acc_data_t *bmsdata) -{ - struct __attribute__((__packed__)) { - uint8_t seg1_noise; - uint8_t seg2_noise; - uint8_t seg3_noise; - uint8_t seg4_noise; - uint8_t seg5_noise; - uint8_t seg6_noise; - } voltage_noise_msg_data; - - voltage_noise_msg_data.seg1_noise = - bmsdata->segment_noise_percentage[0]; - voltage_noise_msg_data.seg2_noise = - bmsdata->segment_noise_percentage[1]; - voltage_noise_msg_data.seg3_noise = - bmsdata->segment_noise_percentage[2]; - voltage_noise_msg_data.seg4_noise = - bmsdata->segment_noise_percentage[3]; - voltage_noise_msg_data.seg5_noise = - bmsdata->segment_noise_percentage[4]; - voltage_noise_msg_data.seg6_noise = - bmsdata->segment_noise_percentage[5]; - - can_msg_t msg; - msg.id = NOISE_CANID; - msg.len = NOISE_SIZE; - - memcpy(msg.data, &voltage_noise_msg_data, - sizeof(voltage_noise_msg_data)); - - queue_can_msg(msg); -} - -void compute_send_debug_message(uint8_t debug0, uint8_t debug1, uint16_t debug2, - uint32_t debug3) -{ - struct __attribute__((__packed__)) { - uint8_t debug0; - uint8_t debug1; - uint16_t debug2; - uint32_t debug3; - } debug_msg_data; - - debug_msg_data.debug0 = debug0; - debug_msg_data.debug1 = debug1; - debug_msg_data.debug2 = debug2; - debug_msg_data.debug3 = debug3; - - endian_swap(&debug_msg_data.debug2, sizeof(debug_msg_data.debug2)); - endian_swap(&debug_msg_data.debug3, sizeof(debug_msg_data.debug3)); - - can_msg_t msg; - msg.id = DEBUG_CANID; - msg.len = DEBUG_SIZE; - - memcpy(msg.data, &debug_msg_data, 8); - - queue_can_msg(msg); -} - -void compute_send_cell_data_message(bool alpha, uint16_t temperature, - uint16_t voltage_a, uint16_t voltage_b, - uint8_t chip_ID, uint8_t cell_a, - uint8_t cell_b, bool discharging_a, - bool discharging_b) -{ - endian_swap(&temperature, sizeof(temperature)); - endian_swap(&voltage_a, sizeof(voltage_a)); - endian_swap(&voltage_b, sizeof(voltage_b)); - - struct __attribute__((__packed__)) { - uint16_t temperature : 10; - uint16_t voltage_a : 13; - uint16_t voltage_b : 13; - uint8_t chip_ID : 4; - uint8_t cell_a : 4; - uint8_t cell_b : 4; - uint8_t discharging_a : 1; - uint8_t discharging_b : 1; - } cell_data_msg_data; - - cell_data_msg_data.temperature = temperature; - cell_data_msg_data.voltage_a = voltage_a; - cell_data_msg_data.voltage_b = voltage_b; - cell_data_msg_data.chip_ID = chip_ID; - cell_data_msg_data.cell_a = cell_a; - cell_data_msg_data.cell_b = cell_b; - cell_data_msg_data.discharging_a = discharging_a; - cell_data_msg_data.discharging_b = discharging_b; - - can_msg_t msg; - if (alpha) { - msg.id = ALPHA_CELL_CANID; - } else { - msg.id = BETA_CELL_CANID; - } - msg.len = CELL_MSG_SIZE; - - memcpy(msg.data, &cell_data_msg_data, CELL_MSG_SIZE); - - queue_can_msg(msg); -} - -void compute_send_beta_status_a_message(uint16_t cell_temperature, - uint16_t voltage, bool discharging, - uint8_t chip, - uint16_t segment_temperature, - uint16_t die_temperature, uint16_t vpv) -{ - endian_swap(&cell_temperature, sizeof(cell_temperature)); - endian_swap(&voltage, sizeof(voltage)); - endian_swap(&segment_temperature, sizeof(segment_temperature)); - endian_swap(&die_temperature, sizeof(die_temperature)); - endian_swap(&vpv, sizeof(vpv)); - - struct __attribute__((__packed__)) { - uint16_t cell_temperature : 10; - uint16_t voltage : 13; - uint8_t discharging : 1; - uint8_t chip : 4; - uint16_t segment_temperature : 10; - uint16_t die_temperature : 13; - uint16_t vpv : 13; - } beta_status_a_data; - - beta_status_a_data.cell_temperature = cell_temperature; - beta_status_a_data.voltage = voltage; - beta_status_a_data.discharging = discharging; - beta_status_a_data.chip = chip; - beta_status_a_data.segment_temperature = segment_temperature; - beta_status_a_data.die_temperature = die_temperature; - beta_status_a_data.vpv = vpv; - - can_msg_t msg; - msg.id = BETA_STAT_A_CANID; - msg.len = BETA_STAT_A_SIZE; - - memcpy(msg.data, &beta_status_a_data, BETA_STAT_A_SIZE); - - queue_can_msg(msg); -} - -void compute_send_beta_status_b_message(uint16_t vref2, uint16_t v_analog, - uint16_t v_digital, uint8_t chip, - uint16_t v_res, uint16_t vmv) -{ - endian_swap(&vref2, sizeof(vref2)); - endian_swap(&v_analog, sizeof(v_analog)); - endian_swap(&v_digital, sizeof(v_digital)); - endian_swap(&v_res, sizeof(v_res)); - endian_swap(&vmv, sizeof(vmv)); - - struct __attribute__((__packed__)) { - uint16_t vref2 : 13; - uint16_t v_analog : 10; - uint16_t v_digital : 10; - uint8_t chip : 4; - uint16_t v_res : 13; - uint16_t vmv : 13; - } beta_status_b_data; - - beta_status_b_data.vref2 = vref2; - beta_status_b_data.v_analog = v_analog; - beta_status_b_data.v_digital = v_digital; - beta_status_b_data.chip = chip; - beta_status_b_data.v_res = v_res; - beta_status_b_data.vmv = vmv; - - can_msg_t msg; - msg.id = BETA_STAT_B_CANID; - msg.len = BETA_STAT_B_SIZE; - - memcpy(msg.data, &beta_status_b_data, BETA_STAT_B_SIZE); - - queue_can_msg(msg); -} - -void compute_send_alpha_status_a_message(uint16_t segment_temp, uint8_t chip, - uint16_t die_temperature, uint16_t vpv, - uint16_t vmv) -{ - endian_swap(&segment_temp, sizeof(segment_temp)); - endian_swap(&die_temperature, sizeof(die_temperature)); - endian_swap(&vpv, sizeof(vpv)); - endian_swap(&vmv, sizeof(vmv)); - - struct __attribute__((__packed__)) { - uint16_t segment_temp : 10; - uint8_t chip : 4; - uint16_t die_temperature : 13; - uint16_t vpv : 13; - uint16_t vmv : 13; - } alpha_status_a_data; - - alpha_status_a_data.segment_temp = segment_temp; - alpha_status_a_data.chip = chip; - alpha_status_a_data.die_temperature = die_temperature; - alpha_status_a_data.vpv = vpv; - alpha_status_a_data.vmv = vmv; - - can_msg_t msg; - msg.id = ALPHA_STAT_A_CANID; - msg.len = ALPHA_STAT_A_SIZE; - - memcpy(msg.data, &alpha_status_a_data, ALPHA_STAT_A_SIZE); - - queue_can_msg(msg); -} - -void compute_send_alpha_status_b_message(uint16_t v_res, uint8_t chip, - uint16_t vref2, uint16_t v_analog, - uint16_t v_digital) -{ - endian_swap(&v_res, sizeof(v_res)); - endian_swap(&vref2, sizeof(vref2)); - endian_swap(&v_analog, sizeof(v_analog)); - endian_swap(&v_digital, sizeof(v_digital)); - - struct __attribute__((__packed__)) { - uint16_t v_res : 13; - uint8_t chip : 4; - uint16_t vref2 : 13; - uint16_t v_analog : 13; - uint16_t v_digital : 13; - } alpha_status_b_data; - - alpha_status_b_data.v_res = v_res; - alpha_status_b_data.chip = chip; - alpha_status_b_data.vref2 = vref2; - alpha_status_b_data.v_analog = v_analog; - alpha_status_b_data.v_digital = v_digital; - - can_msg_t msg; - msg.id = ALPHA_STAT_B_CANID; - msg.len = ALPHA_STAT_B_SIZE; - - memcpy(msg.data, &alpha_status_b_data, ALPHA_STAT_B_SIZE); - - queue_can_msg(msg); -} - void change_adc1_channel(uint8_t channel) { ADC_ChannelConfTypeDef sConfig = { 0 }; diff --git a/Core/Src/main.c b/Core/Src/main.c index 28df1f08..0468cef1 100644 --- a/Core/Src/main.c +++ b/Core/Src/main.c @@ -15,19 +15,16 @@ /* Private includes ----------------------------------------------------------*/ /* USER CODE BEGIN Includes */ -#include "segment.h" -#include "compute.h" -#include "datastructs.h" +#include + #include "analyzer.h" -#include "stateMachine.h" #include "can_handler.h" -#include -#include "shep_tasks.h" - -#include "assert.h" -#include "string.h" - +#include "can_messages.h" +#include "datastructs.h" +#include "compute.h" +#include "segment.h" #include "serialPrintResult.h" +#include "shep_tasks.h" /* USER CODE END Includes */ @@ -39,6 +36,8 @@ /* Private define ------------------------------------------------------------*/ /* USER CODE BEGIN PD */ +extern BMSState_t current_state; + //#ifdef DEBUG_EVERYTHING //#define DEBUG_CHARGING // #define DEBUG_STATS @@ -1368,9 +1367,9 @@ void StartDefaultTask(void *argument) alt = !alt; - compute_send_bms_status_message(bmsdata, current_state, + send_bms_status_message(bmsdata, current_state, segment_is_balancing(bmsdata->chips)); - compute_send_fault_status_message(bmsdata); + send_fault_status_message(bmsdata); send_git_version_message(); diff --git a/Core/Src/segment.c b/Core/Src/segment.c index 8370deff..8a9cf6e4 100644 --- a/Core/Src/segment.c +++ b/Core/Src/segment.c @@ -1,11 +1,9 @@ #include "segment.h" -#include + +#include "adi_interaction.h" #include "analyzer.h" #include "c_utils.h" - #include "serialPrintResult.h" -#include "adBms6830ParseCreate.h" -#include "adi_interaction.h" #define T_READY 10 /* microseconds*/ #define T_IDLE 4.3 /* milliseconds, minimum. typ is 5.5, max is 6.7 */ @@ -145,7 +143,7 @@ void segment_adc_comparison(acc_data_t *bmsdata) void segment_monitor_flts(cell_asic chips[NUM_CHIPS]) { - read_status_registers(chips); + read_status_register_c(chips); for (int chip = 0; chip < NUM_CHIPS; chip++) { if (chips[chip].statc.va_ov) { printf("A OV FLT\n"); @@ -174,9 +172,10 @@ void segment_monitor_flts(cell_asic chips[NUM_CHIPS]) if (chips[chip].statc.thsd) { printf("THERMAL FLT\n"); } - if (chips[chip].statc.oscchk) { - printf("OSC FLT\n"); + if (chips[chip].statc.tmodchk) { + printf("TMODE FLT\n"); } + if (chips[chip].statc.otp1_med) { printf("CMED? FLT\n"); } @@ -184,7 +183,7 @@ void segment_monitor_flts(cell_asic chips[NUM_CHIPS]) printf("SMED? FLT\n"); } } - // clear them + // clear them. they will still be in memory for usage until this function or read_status_registers is called write_clear_flags(chips); } @@ -194,9 +193,6 @@ void segment_retrieve_data(acc_data_t *bmsdata) // read from ADC convs read_filtered_voltage_registers(bmsdata->chips); - // check our fault flags - segment_monitor_flts(bmsdata->chips); - // read all therms using AUX 2 adc_and_read_aux2_registers(bmsdata->chips); } @@ -209,6 +205,8 @@ void segment_retrieve_debug_data(acc_data_t *bmsdata) read_status_registers(bmsdata->chips); //segment_adc_comparison(bmsdata); + // check our fault flags + segment_monitor_flts(bmsdata->chips); } void segment_restart(acc_data_t *bmsdata) diff --git a/Core/Src/shep_tasks.c b/Core/Src/shep_tasks.c index 89ebd856..8d3c6a5d 100644 --- a/Core/Src/shep_tasks.c +++ b/Core/Src/shep_tasks.c @@ -9,13 +9,14 @@ */ #include "shep_tasks.h" + #include "bmsConfig.h" -#include "stm32f4xx_hal.h" -#include "can_handler.h" -#include "analyzer.h" +#include "can_messages.h" +#include "c_utils.h" #include "compute.h" -#include +#include "segment.h" #include "serialPrintResult.h" +#include "stateMachine.h" #define STATE_MACHINE_FLAG 1 @@ -74,8 +75,8 @@ void vAnalyzer(void *pv_params) calc_cont_ccl(bmsdata); // temporary bmsdata->charge_limit = bmsdata->cont_CCL; - compute_send_mc_charge_message(bmsdata); - compute_send_current_message(bmsdata); + send_mc_charge_message(bmsdata); + send_current_message(bmsdata); // temporary end calc_state_of_charge(bmsdata); @@ -94,8 +95,8 @@ void vCurrentMonitor(void *pv_params) acc_data_t *bmsdata = (acc_data_t *)pv_params; for (;;) { bmsdata->pack_current = compute_get_pack_current(); - compute_send_acc_status_message(bmsdata); - compute_send_current_message(bmsdata); + send_acc_status_message(bmsdata); + send_current_message(bmsdata); osDelay(1000 / SAMPLE_RATE); } } @@ -127,7 +128,7 @@ void vDebugMode(void *pv_params) uint8_t num_cells = get_num_cells(&bmsdata->chip_data[chip]); for (int cell = 0; cell < num_cells; cell += 2) { - compute_send_cell_data_message( + send_cell_data_message( bmsdata->chip_data[chip].alpha, bmsdata->chip_data[chip].cell_temp[cell], @@ -160,7 +161,7 @@ void vDebugMode(void *pv_params) // Send chip status messages if (!bmsdata->chip_data[chip].alpha) { - compute_send_beta_status_a_message( + send_beta_status_a_message( 10000 * getVoltage( bmsdata->chip_data[chip] .cell_temp[10]), @@ -182,7 +183,7 @@ void vDebugMode(void *pv_params) bmsdata->chips[chip] .raux .ra_codes[11])); - compute_send_beta_status_b_message( + send_beta_status_b_message( 10000 * getVoltage( bmsdata->chips[chip] .stata.vref2), @@ -199,7 +200,7 @@ void vDebugMode(void *pv_params) .raux .ra_codes[10])); } else { - compute_send_alpha_status_a_message( + send_alpha_status_a_message( bmsdata->chip_data->on_board_temp, chip, (getVoltage(bmsdata->chips[chip] .stata.itmp) / @@ -212,8 +213,9 @@ void vDebugMode(void *pv_params) 10000 * getVoltage( bmsdata->chips[chip] .raux - .ra_codes[8])); - compute_send_alpha_status_b_message( + .ra_codes[8]), + &bmsdata->chips[chip].statc); + send_alpha_status_b_message( 10000 * getVoltage(bmsdata->chips[chip] .statb.vr4k), chip, diff --git a/Core/Src/stateMachine.c b/Core/Src/stateMachine.c index 6c719ad0..ec415290 100644 --- a/Core/Src/stateMachine.c +++ b/Core/Src/stateMachine.c @@ -1,6 +1,8 @@ #include "stateMachine.h" -#include -#include + +#include "can_messages.h" +#include "compute.h" +#include "segment.h" #define MIN(a, b) (((a) < (b)) ? (a) : (b)) extern UART_HandleTypeDef huart4; @@ -122,7 +124,7 @@ void handle_charging(acc_data_t *bmsdata) compute_enable_charging(true); else { compute_enable_charging(false); - compute_send_charging_message(0, 0, bmsdata); + send_charging_message(0, 0, bmsdata); } /* Check if we should balance */ @@ -134,7 +136,7 @@ void handle_charging(acc_data_t *bmsdata) /* Send CAN message, but not too often */ if (is_timer_expired(&charger_message_timer) || !is_timer_active(&charger_message_timer)) { - compute_send_charging_message( + send_charging_message( (MAX_CHARGE_VOLT * (NUM_CELLS_ALPHA + NUM_CELLS_BETA) * NUM_CHIPS), @@ -341,15 +343,13 @@ bool sm_fault_eval(fault_eval_t *item) if (!fault_present) { printf("\t\t\t*******Fault cleared: %s\r\n", item->id); cancel_timer(&item->timer); - compute_send_fault_timer_message(0, item->code, - item->data_1); + send_fault_timer_message(0, item->code, item->data_1); return 0; } if (is_timer_expired(&item->timer) && fault_present) { printf("\t\t\t*******Faulted: %s\r\n", item->id); - compute_send_fault_timer_message(2, item->code, - item->data_1); + send_fault_timer_message(2, item->code, item->data_1); return item->code; } @@ -361,7 +361,7 @@ bool sm_fault_eval(fault_eval_t *item) else if (!is_timer_active(&item->timer) && fault_present) { printf("\t\t\t*******Starting fault timer: %s\r\n", item->id); start_timer(&item->timer, item->timeout); - compute_send_fault_timer_message(1, item->code, item->data_1); + send_fault_timer_message(1, item->code, item->data_1); return 0; } diff --git a/Makefile b/Makefile index c7878836..435a0a75 100644 --- a/Makefile +++ b/Makefile @@ -70,6 +70,7 @@ Core/Src/segment.c \ Core/Src/adi_interaction.c \ Core/Src/stateMachine.c \ Core/Src/can_handler.c \ +Core/Src/can_messages.c \ Core/Src/shep_tasks.c \ Core/Src/stm32f4xx_it.c \ Core/Src/stm32f4xx_hal_msp.c \