diff --git a/ECU/Application/Inc/CANutils.h b/ECU/Application/Inc/CANutils.h index 505f65f63..b29172ef9 100644 --- a/ECU/Application/Inc/CANutils.h +++ b/ECU/Application/Inc/CANutils.h @@ -13,5 +13,6 @@ void ECU_CAN_Send(GRCAN_BUS_ID bus, GRCAN_NODE_ID destNode, GRCAN_MSG_ID messageID, void *data, uint32_t size); void ECU_CAN_Send_DTI(GRCAN_CUSTOM_ID msgID, void *data, uint32_t size); void SendECUStateDataOverCAN(ECU_StateData *stateData); +void SendECUAnalogDataOverCAN(ECU_StateData *stateData); #endif diff --git a/ECU/Application/Inc/StateData.h b/ECU/Application/Inc/StateData.h index 27fc53c48..47b3cd03a 100644 --- a/ECU/Application/Inc/StateData.h +++ b/ECU/Application/Inc/StateData.h @@ -87,7 +87,9 @@ typedef volatile struct ECU_StateData { uint8_t glv_soc; uint8_t acu_error_warning_bits; uint8_t inverter_fault_map; + bool ts_active_button_press_interrupt; bool ts_active_button_pressed; + bool rtd_button_press_interrupt; bool rtd_button_pressed; bool ir_plus; bool ir_minus; diff --git a/ECU/Application/Inc/StateUtils.h b/ECU/Application/Inc/StateUtils.h index 215ca9ec7..cd1798501 100644 --- a/ECU/Application/Inc/StateUtils.h +++ b/ECU/Application/Inc/StateUtils.h @@ -15,10 +15,10 @@ uint32_t MillisecondsSinceBoot(void); #define BRAKE_F_MAX 4095 // TODO: need to be determined FIXME: Rename better #define BRAKE_R_MIN 0 // TODO: need to be determined FIXME: Rename better #define BRAKE_R_MAX 4095 // TODO: need to be determined FIXME: Rename better -#define THROTTLE_MIN_1 0 // TODO: need to be determined -#define THROTTLE_MAX_1 4095 // TODO: need to be determined -#define THROTTLE_MIN_2 0 // TODO: need to be determined -#define THROTTLE_MAX_2 4095 // TODO: need to be determined +#define THROTTLE_MIN_1 306 // TODO: need to be determined +#define THROTTLE_MAX_1 3704 // TODO: need to be determined +#define THROTTLE_MIN_2 336 // TODO: need to be determined +#define THROTTLE_MAX_2 3794 // TODO: need to be determined #define BSE_MAX 4096.0f #define BSE_DEADZONE 1.2f #define MAX_BSE_FAILURE_TIME 100 @@ -54,5 +54,7 @@ float CalcAccPedalTravel(volatile const ECU_StateData *stateData); bool APPS_Plausible(volatile const ECU_StateData *stateData); bool BSE_Plausible(volatile const ECU_StateData *stateData); bool vehicle_is_moving(volatile const ECU_StateData *stateData); +/* Disable inverter for both DTI and Custom */ +void disable_inverter(void); #endif diff --git a/ECU/Application/Src/CANdler.c b/ECU/Application/Src/CANdler.c index db0354b09..30ff94704 100644 --- a/ECU/Application/Src/CANdler.c +++ b/ECU/Application/Src/CANdler.c @@ -110,17 +110,15 @@ void ECU_CAN_MessageHandler(ECU_StateData *state_data, GRCAN_BUS_ID bus_id, GRCA // LET IT BE KNOWN: these things are LSB FIRST, TODO: I'll get it right later if (state_data->ecu_state == GR_GLV_ON) { - state_data->ts_active_button_pressed = dash_data->button_flags & 1; + state_data->ts_active_button_press_interrupt = dash_data->button_flags & 1; } else { - state_data->ts_active_button_pressed = (dash_data->button_flags >> 2) & 1; + state_data->ts_active_button_press_interrupt = (dash_data->button_flags >> 2) & 1; } if (state_data->ecu_state == GR_PRECHARGE_COMPLETE) { - state_data->rtd_button_pressed = (dash_data->button_flags >> 1) & 1; + state_data->rtd_button_press_interrupt = (dash_data->button_flags >> 1) & 1; } else if (state_data->ecu_state == GR_DRIVE_ACTIVE) { - state_data->rtd_button_pressed = (dash_data->button_flags >> 3) & 1; - } else { - state_data->rtd_button_pressed = false; + state_data->rtd_button_press_interrupt = (dash_data->button_flags >> 3) & 1; } break; diff --git a/ECU/Application/Src/CANutils.c b/ECU/Application/Src/CANutils.c index 473376efe..12ff59eba 100644 --- a/ECU/Application/Src/CANutils.c +++ b/ECU/Application/Src/CANutils.c @@ -33,7 +33,7 @@ void ECU_CAN_Send(GRCAN_BUS_ID bus, GRCAN_NODE_ID destNode, GRCAN_MSG_ID message .IdType = FDCAN_EXTENDED_ID, .TxFrameType = FDCAN_DATA_FRAME, .ErrorStateIndicator = FDCAN_ESI_ACTIVE, - .DataLength = size, + .DataLength = BytesToCANDLC(size), .BitRateSwitch = FDCAN_BRS_OFF, .TxEventFifoControl = FDCAN_NO_TX_EVENTS, .MessageMarker = 0, @@ -78,17 +78,20 @@ void ECU_CAN_Send_DTI(GRCAN_CUSTOM_ID msgID, void *data, uint32_t size) TxHeader.Identifier = msgID; TxHeader.DataLength = size; - TxHeader.IdType = FDCAN_EXTENDED_ID; - TxHeader.FDFormat = FDCAN_CLASSIC_CAN; FDCANTxMessage msg = {0}; msg.tx_header = TxHeader; - for (uint32_t i = 0; i < size; i++) { - msg.data[size - i - 1] = ((uint8_t *)data)[i]; + uint8_t temp; + for (uint16_t i = 0; i < size / 2; ++i) { + temp = ((uint8_t *)data)[i]; + ((uint8_t *)data)[i] = ((uint8_t *)data)[size - i - 1]; + ((uint8_t *)data)[size - i - 1] = temp; } + memcpy(&(msg.data), data, size); + // can_send(primary_can, &msg); can_enqueue(stateLump.primary_can, &msg); } @@ -116,9 +119,27 @@ void SendECUStateDataOverCAN(ECU_StateData *stateData) .RRWheelRPM = (uint16_t)(stateData->rr_wheel_rpm * 10 + 32768), .RLWheelRPM = (uint16_t)(stateData->rl_wheel_rpm * 10 + 32768)}; - // LOGOMATIC("Sending ECU State Data over CAN\n"); - ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_ALL, GRCAN_ECU_STATUS_1, (void *)&messages.ECUStatusMsgOne, sizeof(messages.ECUStatusMsgOne)); ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_ALL, GRCAN_ECU_STATUS_2, (void *)&messages.ECUStatusMsgTwo, sizeof(messages.ECUStatusMsgTwo)); ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_ALL, GRCAN_ECU_STATUS_3, (void *)&messages.ECUStatusMsgThree, sizeof(messages.ECUStatusMsgThree)); } + +void SendECUAnalogDataOverCAN(ECU_StateData *stateData) +{ + uint32_t millis_since_boot = MillisecondsSinceBoot(); + + static uint32_t last_can_tcm_request_millis = 0; + + if (millis_since_boot - last_can_tcm_request_millis > 100) { + GRCAN_ECU_ANALOG_DATA_MSG message = {.bspd_signal = stateData->bspd_signal, + .bse_signal = stateData->bse_signal, + .apps_1_signal = stateData->APPS1_Signal, + .apps_2_signal = stateData->APPS2_Signal, + .brakeline_f_signal = stateData->Brake_F_Signal, + .brakeline_r_signal = stateData->Brake_R_Signal, + .steering_angle_signal = stateData->steering_angle_signal, + .aux_signal = stateData->aux_signal}; + ECU_CAN_Send(GRCAN_BUS_DATA, GRCAN_TCM, GRCAN_ECU_ANALOG_DATA, &message, sizeof(message)); + last_can_tcm_request_millis = millis_since_boot; + } +} diff --git a/ECU/Application/Src/StateTicks.c b/ECU/Application/Src/StateTicks.c index 34281c706..96a14ea89 100644 --- a/ECU/Application/Src/StateTicks.c +++ b/ECU/Application/Src/StateTicks.c @@ -60,6 +60,20 @@ void ECU_State_Tick(void) // bmsFailure(&stateLump) || imdFailure(&stateLump); + if (stateLump.ts_active_button_press_interrupt) { + stateLump.ts_active_button_press_interrupt = false; + stateLump.ts_active_button_pressed = true; + } else { + stateLump.ts_active_button_pressed = false; + } + + if (stateLump.rtd_button_press_interrupt) { + stateLump.rtd_button_press_interrupt = false; + stateLump.rtd_button_pressed = true; + } else { + stateLump.rtd_button_pressed = false; + } + switch (stateLump.ecu_state) { case GR_GLV_OFF: ECU_GLV_Off(&stateLump); @@ -89,6 +103,7 @@ void ECU_State_Tick(void) void ECU_GLV_Off(ECU_StateData *stateData) { + disable_inverter(); UNUSED(stateData); LOGOMATIC("ECU_GLV_Off state reached... this should never happen!\n"); // TODO ERROR --> GLV_OFF should never be reached @@ -96,6 +111,8 @@ void ECU_GLV_Off(ECU_StateData *stateData) void ECU_GLV_On(ECU_StateData *stateData) { + disable_inverter(); + if (stateData->ts_voltage >= SAFE_VOLTAGE_LIMIT) { LOGOMATIC("Error: TS Voltage >= %d!\n", SAFE_VOLTAGE_LIMIT); ECU_Transition_To_Tractive_System_Discharge(stateData); @@ -106,7 +123,6 @@ void ECU_GLV_On(ECU_StateData *stateData) if (stateData->ts_active_button_pressed /* && stateData->ir_plus*/) { // TODO: Talk to Owen if this is correct for precharge start confirmation LOGOMATIC("GLV ON to PRECHARGE START!\n"); ECU_Transition_To_Precharge_Engaged(stateData); - stateData->ts_active_button_pressed = false; return; } } @@ -126,6 +142,8 @@ void ECU_Transition_To_Precharge_Engaged(ECU_StateData *stateData) void ECU_Precharge_Engaged(ECU_StateData *stateData) { + disable_inverter(); + if (stateData->ir_plus) { stateData->ecu_state = GR_PRECHARGE_COMPLETE; LOGOMATIC("PRECHARGE ENGAGED to PRECHARGE COMPLETE!\n"); @@ -142,7 +160,6 @@ void ECU_Precharge_Engaged(ECU_StateData *stateData) LOGOMATIC("ERROR: ts_active PRESSED! PRECHARGE ENGAGED to TS DISCHARGE START!\n"); ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_Debugger, GRCAN_DEBUG_2_0, "TS-P-ITR", 8); ECU_Transition_To_Tractive_System_Discharge(stateData); - stateData->ts_active_button_pressed = false; return; } } @@ -150,10 +167,11 @@ void ECU_Precharge_Engaged(ECU_StateData *stateData) // TODO: change for CAN button messenging void ECU_Precharge_Complete(ECU_StateData *stateData) { + disable_inverter(); + if (stateData->ts_active_button_pressed) { LOGOMATIC("TS Active Toggled Off. Discharging Tractive System.\n"); ECU_Transition_To_Tractive_System_Discharge(stateData); - stateData->ts_active_button_pressed = false; return; } if (CriticalError(stateData)) { @@ -166,19 +184,8 @@ void ECU_Precharge_Complete(ECU_StateData *stateData) if (PressingBrake(stateData) && stateData->rtd_button_pressed) { GRCAN_INVERTER_CONFIG_MSG inverter_message = {.max_ac_current = 0xFFFF, .max_dc_current = 0xFFFF, .absolute_max_rpm_limit = 0xFFFF, .motor_direction = 0}; ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_GR_Inverter, GRCAN_INVERTER_CONFIG, &inverter_message, sizeof(inverter_message)); - GRCAN_ECU_ANALOG_DATA_MSG pedals_message = {.bspd_signal = stateData->bspd_signal, - .bse_signal = stateData->bse_signal, - .apps_1_signal = stateData->APPS1_Signal, - .apps_2_signal = stateData->APPS2_Signal, - .brakeline_f_signal = stateData->Brake_F_Signal, - .brakeline_r_signal = stateData->Brake_R_Signal, - .steering_angle_signal = stateData->steering_angle_signal, - .aux_signal = stateData->aux_signal}; - ECU_CAN_Send(GRCAN_BUS_DATA, GRCAN_TCM, GRCAN_ECU_ANALOG_DATA, &pedals_message, sizeof(pedals_message)); LOGOMATIC("PRECHARGE COMPLETE to DRIVE START/ACTIVE!\n"); ECU_Transition_To_Drive_Active(stateData); - stateData->rtd_button_pressed = false; - return; } } @@ -202,7 +209,6 @@ void ECU_Drive_Active(ECU_StateData *stateData) LOGOMATIC("Error: TS active button pressed in Drive Active state. Discharging Tractive System.\n"); ECU_Transition_To_Tractive_System_Discharge(stateData); ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_Debugger, GRCAN_DEBUG_2_0, "DA-CritE", 8); - stateData->ts_active_button_pressed = false; return; } @@ -218,7 +224,6 @@ void ECU_Drive_Active(ECU_StateData *stateData) if (vehicle_is_moving(stateData)) { LOGOMATIC("Warning: Vehicle is moving during state transition.\n"); } - stateData->rtd_button_pressed = false; return; } @@ -247,32 +252,15 @@ void ECU_Drive_Active(ECU_StateData *stateData) torque_request = 0; } - static uint32_t last_can_inverter_request_millis; + static uint32_t last_can_inverter_request_millis = 0; if (RATE_LIMIT_100_HZ(millis_since_boot, last_can_inverter_request_millis)) { GRCAN_INVERTER_COMMAND_MSG message = {.set_ac_current = torque_request * 100 + 32768, .set_dc_current = torque_request * 100 + 32768, .drive_enable = 1, .rpm_limit = 0}; ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_GR_Inverter, GRCAN_INVERTER_COMMAND, &message, sizeof(message)); - ECU_CAN_Send_DTI(DTI_CONTROL_12_CAN_ID, &message.drive_enable, 2); + ECU_CAN_Send_DTI(DTI_CONTROL_12_CAN_ID, &message.drive_enable, 1); + message.set_ac_current = torque_request * 10; ECU_CAN_Send_DTI(DTI_CONTROL_1_CAN_ID, &message.set_ac_current, 2); last_can_inverter_request_millis = millis_since_boot; } - - // placeholder for pedal data - // TODO: determine send time (15, 20 ms?) - - static uint32_t last_can_tcm_request_millis; - if (RATE_LIMIT_100_HZ(millis_since_boot, last_can_tcm_request_millis)) { - GRCAN_ECU_ANALOG_DATA_MSG message = {.bspd_signal = stateData->bspd_signal, - .bse_signal = stateData->bse_signal, - .apps_1_signal = stateData->APPS1_Signal, - .apps_2_signal = stateData->APPS2_Signal, - .brakeline_f_signal = stateData->Brake_F_Signal, - .brakeline_r_signal = stateData->Brake_R_Signal, - .steering_angle_signal = stateData->steering_angle_signal, - .aux_signal = stateData->aux_signal}; - UNUSED(message); // FIXME Eventually figure out what to do with this message here - // ECU_CAN_Send(GRCAN_BUS_DATA, GRCAN_TCM, GRCAN_ECU_ANALOG_DATA, &message, sizeof(message)); // FIXME - last_can_inverter_request_millis = millis_since_boot; - } } static uint32_t discharge_start_millis; @@ -287,6 +275,8 @@ void ECU_Transition_To_Tractive_System_Discharge(ECU_StateData *stateData) void ECU_Tractive_System_Discharge(ECU_StateData *stateData) { + disable_inverter(); + /* Discharge the tractive system to below 60(SAFE_VOLTAGE_LIMIT) volts */ @@ -312,4 +302,4 @@ void ECU_Tractive_System_Discharge(ECU_StateData *stateData) ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_ACU, GRCAN_ACU_PRECHARGE, &message, sizeof(message)); last_discharge_request_millis = millis_since_boot; } -} // init +} diff --git a/ECU/Application/Src/StateUtils.c b/ECU/Application/Src/StateUtils.c index 53b5140a5..79e7dba5d 100644 --- a/ECU/Application/Src/StateUtils.c +++ b/ECU/Application/Src/StateUtils.c @@ -78,6 +78,7 @@ bool bspdFailure(volatile const ECU_StateData *stateData) bool APPS_BSE_Violation(volatile const ECU_StateData *stateData) { + return false; // Checks 2 * APPS_1 is within 10% of APPS_2 and break + throttle at the same time return PressingBrake(stateData) && CalcAccPedalTravel(stateData) >= 0.25f; } @@ -90,12 +91,18 @@ bool PressingBrake(volatile const ECU_StateData *stateData) // bool brakeFpress = stateData->Brake_F_Signal - BRAKE_F_MIN > BSE_DEADZONE * brakeRangeF; // bool brakeRpress = stateData->Brake_R_Signal - BRAKE_R_MIN > BSE_DEADZONE * brakeRangeR; // return brakeFpress || brakeRpress; + if (stateData->ecu_state < GR_DRIVE_ACTIVE) { + return true; // don't consider brake pressed until in drive active + } else { + return false; + } return ((stateData->bse_signal) / BSE_MAX * 3.3f) > BSE_DEADZONE; // Ideally TCM receives values of 0 after this is no longer called xD. } float CalcBrakePercent(volatile const ECU_StateData *stateData) { + return 0; return stateData->bse_signal / BSE_MAX; } @@ -144,3 +151,10 @@ void SendEcuBonusInfo(const ECU_StateData *stateData) // RTT ping data // TODO Setup using data from Pinging.c per Andrey request } + +void disable_inverter(void) +{ + GRCAN_INVERTER_COMMAND_MSG inverter_msg = {.drive_enable = 0, .field_weakening = 0, .rpm_limit = 0, .set_ac_current = 0, .set_dc_current = 0}; + ECU_CAN_Send(GRCAN_BUS_PRIMARY, GRCAN_GR_Inverter, GRCAN_INVERTER_COMMAND, &inverter_msg, sizeof(inverter_msg)); + ECU_CAN_Send_DTI(DTI_CONTROL_12_CAN_ID, &inverter_msg.drive_enable, 1); +} diff --git a/ECU/Core/Src/main.c b/ECU/Core/Src/main.c index 66c567d5e..70ae68f58 100644 --- a/ECU/Core/Src/main.c +++ b/ECU/Core/Src/main.c @@ -404,20 +404,22 @@ int main(void) while (1) { // adcs read_digital(); - ADC_UpdateAnalogValues_EMA(ADC_buffers, NUM_SIGNALS, 0.2, ADC_outputs); - write_adc_values_to_state_data(); - // main state lopp, queues can messages within it static uint32_t delay_timer; static uint32_t ping_timer; if (MillisecondsSinceBoot() >= delay_timer) { delay_timer = MillisecondsSinceBoot() + (MAIN_LOOP_PERIOD_US / 1000); + // ADC + ADC_UpdateAnalogValues_EMA(ADC_buffers, NUM_SIGNALS, 0.2, ADC_outputs); + write_adc_values_to_state_data(); + // state tick ECU_State_Tick(); // preipheral updates SendECUStateDataOverCAN(&stateLump); + SendECUAnalogDataOverCAN(&stateLump); if (MillisecondsSinceBoot() >= ping_timer) { ping_timer = MillisecondsSinceBoot() + (MAIN_LOOP_PERIOD_US / 500); // half period pingAll(); diff --git a/ECU/Test/Inc/can.h b/ECU/Test/Inc/can.h index cc7810816..0a3ebf422 100644 --- a/ECU/Test/Inc/can.h +++ b/ECU/Test/Inc/can.h @@ -377,6 +377,7 @@ int can_stop(CANHandle *handle); int can_enqueue(CANHandle *canHandle, FDCANTxMessage *message); int can_release(CANHandle *handle); // deinit circular buffer and turn off can peripheral and gpios int can_add_filter(CANHandle *handle, FDCAN_FilterTypeDef *filter); +uint8_t BytesToCANDLC(uint32_t num_bytes); // alternatively use // HAL_FDCAN_ConfigGlobalFilter() //important to accept nonmatching frames into // HAL_FDCAN_ConfigFilter() diff --git a/ECU/Test/Src/StateTicksTest.c b/ECU/Test/Src/StateTicksTest.c index df18705da..84126ad0d 100644 --- a/ECU/Test/Src/StateTicksTest.c +++ b/ECU/Test/Src/StateTicksTest.c @@ -36,6 +36,20 @@ static void ECU_Pseudo_State_Tick(ECU_StateData *stateLumpTest) LOGOMATIC("TSSI: TS Normal\n"); } + if (stateLumpTest->ts_active_button_press_interrupt) { + stateLumpTest->ts_active_button_press_interrupt = false; + stateLumpTest->ts_active_button_pressed = true; + } else { + stateLumpTest->ts_active_button_pressed = false; + } + + if (stateLumpTest->rtd_button_press_interrupt) { + stateLumpTest->rtd_button_press_interrupt = false; + stateLumpTest->rtd_button_pressed = true; + } else { + stateLumpTest->rtd_button_pressed = false; + } + switch (stateLumpTest->ecu_state) { case GR_GLV_OFF: ECU_GLV_Off(stateLumpTest); @@ -80,7 +94,7 @@ int main(void) // ## Step 0.1 ## // ########################## LOGOMATIC("Press and release RTD -> STAY IN GLV ON\n"); - stateLumpTest.rtd_button_pressed = true; + stateLumpTest.rtd_button_press_interrupt = true; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_GLV_ON) { LOGOMATIC("0.1 Failure: ecu state not in GLV ON\n"); @@ -137,7 +151,7 @@ int main(void) // ## Step 0.3 ## // ########################## LOGOMATIC("Press TS ACTIVE: Go to PRECHARGE ENGAGE\n"); - stateLumpTest.ts_active_button_pressed = true; + stateLumpTest.ts_active_button_press_interrupt = true; stateLumpTest.ir_minus = true; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_PRECHARGE_ENGAGED) { @@ -177,7 +191,7 @@ int main(void) // ## Step 0.6 ## // ########################## LOGOMATIC("Press RTD -> STAY IN PRECHARGE COMPLETE\n"); - stateLumpTest.rtd_button_pressed = true; + stateLumpTest.rtd_button_press_interrupt = true; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_PRECHARGE_COMPLETE) { LOGOMATIC("0.6 Failure: ecu state not in precharge complete\n"); @@ -188,7 +202,7 @@ int main(void) return 6; } LOGOMATIC("Release RTD -> STAY IN PRECHARGE COMPLETE\n"); - stateLumpTest.rtd_button_pressed = false; + stateLumpTest.rtd_button_press_interrupt = false; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_PRECHARGE_COMPLETE) { LOGOMATIC("0.6 Failure: ecu state not in precharge complete\n"); @@ -205,7 +219,7 @@ int main(void) LOGOMATIC("Press and release the RTD button WHILE pressing the brake\n"); stateLumpTest.bse_signal = BSE_MAX; LOGOMATIC("Press RTD\n"); - stateLumpTest.rtd_button_pressed = true; + stateLumpTest.rtd_button_press_interrupt = true; ECU_Pseudo_State_Tick(&stateLumpTest); LOGOMATIC("Release RTD\n"); ECU_Pseudo_State_Tick(&stateLumpTest); @@ -335,7 +349,7 @@ int main(void) // ## Step 0.15 ## // ########################## LOGOMATIC("Press RTD -> MOVE TO PRECHARGE COMPLETE\n"); - stateLumpTest.rtd_button_pressed = !stateLumpTest.rtd_button_pressed; + stateLumpTest.rtd_button_press_interrupt = true; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_PRECHARGE_COMPLETE) { LOGOMATIC("0.15 Failure: ecu state not in precharge complete\n"); @@ -392,7 +406,7 @@ int main(void) // ## Step 0.18 ## // ########################## LOGOMATIC("Press TS Active Button -> MOVE to TS DISCHARGE\n"); - stateLumpTest.ts_active_button_pressed = !stateLumpTest.ts_active_button_pressed; + stateLumpTest.ts_active_button_press_interrupt = true; ECU_Pseudo_State_Tick(&stateLumpTest); if (stateLumpTest.ecu_state != GR_TS_DISCHARGE) { LOGOMATIC("0.18 Failure: ecu state not in ts discharge\n"); diff --git a/ECU/Test/Src/can.c b/ECU/Test/Src/can.c index e6154a08f..712d1d776 100644 --- a/ECU/Test/Src/can.c +++ b/ECU/Test/Src/can.c @@ -33,3 +33,9 @@ int can_add_filter(CANHandle *handle, FDCAN_FilterTypeDef *filter) UNUSED(filter); return 0; } + +uint8_t BytesToCANDLC(uint32_t num_bytes) +{ + UNUSED(num_bytes); + return 0; +} diff --git a/Lib/Peripherals/TimedCAN/Inc/can.h b/Lib/Peripherals/TimedCAN/Inc/can.h index 71584c0dc..5c1bd5af7 100644 --- a/Lib/Peripherals/TimedCAN/Inc/can.h +++ b/Lib/Peripherals/TimedCAN/Inc/can.h @@ -92,6 +92,7 @@ CAN_STATUS can_stop(CANHandle *handle); CAN_STATUS can_release(CANHandle *handle); // deinit circular buffer and turn off can peripheral and gpios CAN_STATUS can_add_filter(CANHandle *handle, FDCAN_FilterTypeDef *filter); CAN_STATUS can_enqueue(CANHandle *handle, FDCANTxMessage *message); // adds to software buffer, returns error if full +uint8_t BytesToCANDLC(uint32_t num_bytes); // pass in a buffer to store the status string // int can_info(char* ); diff --git a/Lib/Peripherals/TimedCAN/Src/can.c b/Lib/Peripherals/TimedCAN/Src/can.c index a7a1bfaf1..486b1fcf8 100644 --- a/Lib/Peripherals/TimedCAN/Src/can.c +++ b/Lib/Peripherals/TimedCAN/Src/can.c @@ -420,6 +420,30 @@ void can_tx_dequeue_helper(CANHandle *handle) dwt_timer_t send_timer = {0}; #endif +uint8_t BytesToCANDLC(uint32_t num_bytes) +{ + if (num_bytes <= 8) { + return num_bytes; + } else if (num_bytes <= 12) { + return FDCAN_DLC_BYTES_12; + } else if (num_bytes <= 16) { + return FDCAN_DLC_BYTES_16; + } else if (num_bytes <= 20) { + return FDCAN_DLC_BYTES_20; + } else if (num_bytes <= 24) { + return FDCAN_DLC_BYTES_24; + } else if (num_bytes <= 32) { + return FDCAN_DLC_BYTES_32; + } else if (num_bytes <= 48) { + return FDCAN_DLC_BYTES_48; + } else if (num_bytes <= 64) { + return FDCAN_DLC_BYTES_64; + } else { // Should never happen + return FDCAN_DLC_BYTES_0; + LOGOMATIC("Invalid CAN data size after check: %ld\n", num_bytes); + } +} + CAN_STATUS can_enqueue(CANHandle *canHandle, FDCANTxMessage *message) {