Merge branch 'main' of https://github.com/Formula-Electric-Berkeley/FEB_FIRMWARE_SN5

Author: ZacharyBer

DASH/Core/User/Inc/FEB_CAN_PCU.h

@@ -15,9 +15,9 @@
 void FEB_CAN_PCU_Init(void);
 int16_t FEB_CAN_PCU_GetLastTorque(void);
 int8_t FEB_CAN_PCU_GetLastDirection(void);
-int8_t FEB_CAN_PCU_GetLastRMSEnabled(void);
-uint16_t FEB_CAN_PCU_GetLastBreakPosition(void);
+uint8_t FEB_CAN_PCU_GetLastRMSEnabled(void);
+uint16_t FEB_CAN_PCU_GetLastBrakePosition(void);
 bool FEB_CAN_PCU_IsRMSDataFresh(uint32_t timeout_ms);
-bool FEB_CAN_PCU_IsBreakDataFresh(uint32_t timeout_ms);
+bool FEB_CAN_PCU_IsBrakeDataFresh(uint32_t timeout_ms);
 
 #endif /* FEB_CAN_PCU_H */

DASH/Core/User/Inc/FEB_RTD.h

@@ -11,17 +11,10 @@
 
 #include <stdbool.h>
 
-#define RTD_BUTTON_HOLD_DURATION 2000
+#define RTD_SAFETY_DURATION 2000
 #define BUZZER_DURATION_RTD_ENTER 2000
 #define BUZZER_DURATION_RTD_EXIT 500
 
-typedef enum
-{
-  NOT_BUZZED = 0,
-  BUZZED_ENTER_RTD,
-  BUZZED_EXIT_RTD
-} Buzzing_State_t;
-
 void FEB_State_Update_RTD(void);
 
 bool FEB_State_GetLastRTD(void);

DASH/Core/User/Src/FEB_CAN_PCU.c

@@ -31,11 +31,11 @@ static RMS_State_t rms_state = {.torque = 0x0000, .direction = 0xFF, .enabled =
 
 typedef struct
 {
-  volatile uint16_t break_position;
+  volatile uint16_t brake_position;
   volatile uint32_t last_rx_tick;
-} Break_State_t;
+} Brake_State_t;
 
-static Break_State_t break_state = {.break_position = 0, .last_rx_tick = 0};
+static Brake_State_t brake_state = {.brake_position = 0, .last_rx_tick = 0};
 
 /* ============================================================================
  * RX Callback Handlers
@@ -59,17 +59,17 @@ static void rx_callback_torque(FEB_CAN_Instance_t instance, uint32_t can_id, FEB
 }
 
 // FEB_CAN_RMS_COMMAND_FRAME_ID:
-// Byte 0-1: Break Position Centi-percent (int16_t)
+// Byte 0-1: Brake Position Centi-percent (int16_t)
 // ...
 
-static void rx_callback_break_position(FEB_CAN_Instance_t instance, uint32_t can_id, FEB_CAN_ID_Type_t id_type,
+static void rx_callback_brake_position(FEB_CAN_Instance_t instance, uint32_t can_id, FEB_CAN_ID_Type_t id_type,
                                        const uint8_t *data, uint8_t length, void *user_data)
 {
   uint16_t position;
   memcpy(&position, &data[0], sizeof(uint16_t));
-  break_state.break_position = position;
+  brake_state.brake_position = position;
   __DMB();
-  break_state.last_rx_tick = HAL_GetTick();
+  brake_state.last_rx_tick = HAL_GetTick();
 }
 
 /* ============================================================================
@@ -90,17 +90,17 @@ void FEB_CAN_PCU_Init(void)
   };
   FEB_CAN_RX_Register(&rx_params_torque);
 
-  // PCU Break Position
-  FEB_CAN_RX_Params_t rx_params_break_position = {
+  // PCU Brake Position
+  FEB_CAN_RX_Params_t rx_params_brake_position = {
       .instance = FEB_CAN_INSTANCE_1,
       .can_id = FEB_CAN_BRAKE_FRAME_ID,
       .id_type = FEB_CAN_ID_STD,
       .filter_type = FEB_CAN_FILTER_EXACT,
       .mask = 0x7FF,
       .fifo = FEB_CAN_FIFO_0,
-      .callback = rx_callback_break_position,
+      .callback = rx_callback_brake_position,
   };
-  FEB_CAN_RX_Register(&rx_params_break_position);
+  FEB_CAN_RX_Register(&rx_params_brake_position);
 }
 
 int16_t FEB_CAN_PCU_GetLastTorque(void)
@@ -113,14 +113,14 @@ int8_t FEB_CAN_PCU_GetLastDirection(void)
   return rms_state.direction;
 }
 
-int8_t FEB_CAN_PCU_GetLastRMSEnabled(void)
+uint8_t FEB_CAN_PCU_GetLastRMSEnabled(void)
 {
   return rms_state.enabled;
 }
 
-uint16_t FEB_CAN_PCU_GetLastBreakPosition(void)
+uint16_t FEB_CAN_PCU_GetLastBrakePosition(void)
 {
-  return break_state.break_position;
+  return brake_state.brake_position;
 }
 
 bool FEB_CAN_PCU_IsRMSDataFresh(uint32_t timeout_ms)
@@ -131,9 +131,9 @@ bool FEB_CAN_PCU_IsRMSDataFresh(uint32_t timeout_ms)
   return (HAL_GetTick() - last) < timeout_ms;
 }
 
-bool FEB_CAN_PCU_IsBreakDataFresh(uint32_t timeout_ms)
+bool FEB_CAN_PCU_IsBrakeDataFresh(uint32_t timeout_ms)
 {
-  uint32_t last = break_state.last_rx_tick;
+  uint32_t last = brake_state.last_rx_tick;
   if (last == 0)
     return false;
   return (HAL_GetTick() - last) < timeout_ms;

DASH/Core/User/Src/FEB_CAN_State.c

@@ -85,13 +85,14 @@ void FEB_CAN_State_Tick(void)
 
     IO_States_t states = FEB_IO_GetLastIOStates();
 
-    struct feb_can_dash_state_t pack_states = {.buzzer = states.buzzer_enabled,
-                                               .button1 = states.button_rtd,
-                                               .switch1 = states.switch_accumulator_fans,
-                                               .switch2 = states.switch_coolant_pump_radiator_fan,
-                                               .switch3 = states.switch_logging};
-
-    if (feb_can_dash_state_pack(tx_data, &pack_states, 2) == 2)
+    if (feb_can_dash_state_pack(tx_data,
+                                &((struct feb_can_dash_state_t){.buzzer = states.buzzer_enabled,
+                                                                .button1 = states.button_rtd,
+                                                                .switch1 = states.switch_accumulator_fans,
+                                                                .switch2 = states.switch_coolant_pump_radiator_fan,
+                                                                .switch3 = states.switch_logging,
+                                                                .ready_to_drive = FEB_State_GetLastRTD()}),
+                                2) == 2)
     {
       FEB_CAN_Status_t st = FEB_CAN_TX_Send(FEB_CAN_INSTANCE_1, FEB_CAN_DASH_STATE_FRAME_ID, FEB_CAN_ID_STD, tx_data,
                                             FEB_CAN_DASH_STATE_LENGTH);

DASH/Core/User/Src/FEB_Commands.c

@@ -311,8 +311,8 @@ static void cmd_pcu(int argc, char *argv[])
 
   int16_t torque = FEB_CAN_PCU_GetLastTorque();
   int8_t direction = FEB_CAN_PCU_GetLastDirection();
-  int8_t enabled = FEB_CAN_PCU_GetLastRMSEnabled();
-  uint16_t brake = FEB_CAN_PCU_GetLastBreakPosition();
+  uint8_t enabled = FEB_CAN_PCU_GetLastRMSEnabled();
+  uint16_t brake = FEB_CAN_PCU_GetLastBrakePosition();
 
   FEB_Console_Printf("PCU / RMS Status:\r\n");
   FEB_Console_Printf("  Torque:         %d (raw)\r\n", (int)torque);
@@ -326,7 +326,7 @@ static void cmd_pcu_csv(int argc, char *argv[])
   (void)argc;
   (void)argv;
   FEB_Console_CsvEmit("pcu", "%d,%d,%d,%u", (int)FEB_CAN_PCU_GetLastTorque(), (int)FEB_CAN_PCU_GetLastDirection(),
-                      (int)FEB_CAN_PCU_GetLastRMSEnabled(), (unsigned int)FEB_CAN_PCU_GetLastBreakPosition());
+                      (int)FEB_CAN_PCU_GetLastRMSEnabled(), (unsigned int)FEB_CAN_PCU_GetLastBrakePosition());
 }
 
 static const FEB_Console_Cmd_t dash_cmd_pcu = {

DASH/Core/User/Src/FEB_RTD.c

@@ -8,54 +8,77 @@
 
 static bool rtd = false;
 
-static uint32_t rtd_button_press_start_tick = 0;
+static bool rtd_timer_armed = false;
+static uint32_t rtd_trying_to_toggle_start_tick = 0;
+static bool rtd_toggle_complete = false;
 
 // Minimum brake pressure required for RTD activation (safety interlock)
-#define RTD_BRAKE_THRESHOLD 25
-static bool previous_rtd_button = false;
+#define RTD_BRAKE_THRESHOLD 5000
 
-static Buzzing_State_t buzzing_state =
-    NOT_BUZZED; // Here to ensure FEB_IO_Play_Buzzer() is not spammed and only called once
+// Any RTD input older than this is treated as missing — RTD will not arm on
+// stale CAN data. Matches BMS_STATE_TIMEOUT_MS.
+#define RTD_INPUT_FRESHNESS_MS 500
 
 void FEB_State_Update_RTD(void)
 {
   // MARK: Start buzzer code
-  // to react to BMS entering and exiting drive state
+  // Buzz on any entry into / exit from BMS_STATE_DRIVE so faults that drop us
+  // out of drive (DRIVE -> FAULT_*) still trigger the exit chime.
   static BMS_State_t previous_bms_state = BMS_STATE_BOOT;
   BMS_State_t bms_state = FEB_CAN_BMS_GetLastState();
-  if (previous_bms_state == BMS_STATE_ENERGIZED && bms_state == BMS_STATE_DRIVE && buzzing_state != BUZZED_ENTER_RTD)
+  if (previous_bms_state != BMS_STATE_DRIVE && bms_state == BMS_STATE_DRIVE)
   {
     FEB_IO_Play_Buzzer(BUZZER_DURATION_RTD_ENTER);
-    buzzing_state = BUZZED_ENTER_RTD;
   }
-  else if (previous_bms_state == BMS_STATE_DRIVE && bms_state == BMS_STATE_ENERGIZED &&
-           buzzing_state != BUZZED_EXIT_RTD)
+  else if (previous_bms_state == BMS_STATE_DRIVE && bms_state != BMS_STATE_DRIVE)
   {
     FEB_IO_Play_Buzzer(BUZZER_DURATION_RTD_EXIT);
-    buzzing_state = BUZZED_EXIT_RTD;
   }
   previous_bms_state = bms_state;
 
   // MARK: Signal enter rtd code
   // Send the ready to drive message over CAN when all the conditions are met
   IO_States_t states = FEB_IO_GetLastIOStates();
-  uint16_t brake_pressure = FEB_CAN_PCU_GetLastBreakPosition();
-  int8_t inv_enabled = FEB_CAN_PCU_GetLastRMSEnabled();
+  uint16_t brake_pressure = FEB_CAN_PCU_GetLastBrakePosition();
+  uint8_t inv_enabled = FEB_CAN_PCU_GetLastRMSEnabled();
 
-  if (previous_rtd_button == false && states.button_rtd)
+  bool inputs_fresh = FEB_CAN_PCU_IsBrakeDataFresh(RTD_INPUT_FRESHNESS_MS) &&
+                      FEB_CAN_PCU_IsRMSDataFresh(RTD_INPUT_FRESHNESS_MS) &&
+                      FEB_CAN_BMS_IsDataFresh(RTD_INPUT_FRESHNESS_MS);
+
+  // RTD requires: fresh CAN inputs, button held, brake applied, inverter enabled, BMS energized
+  // if (inputs_fresh && (brake_pressure >= RTD_BRAKE_THRESHOLD) && (inv_enabled == 1) &&
+  //     (bms_state == BMS_STATE_ENERGIZED) && states.button_rtd)
+  if (states.button_rtd)
+  {
+    if (!rtd_timer_armed)
+    {
+      rtd_timer_armed = true;
+      rtd_trying_to_toggle_start_tick = HAL_GetTick();
+    }
+  }
+  else
   {
-    rtd_button_press_start_tick = HAL_GetTick();
+    rtd_timer_armed = false;
   }
 
-  // RTD requires: button held, brake applied, and inverter enabled
-  if (states.button_rtd && rtd_button_press_start_tick + RTD_BUTTON_HOLD_DURATION < HAL_GetTick() &&
-      brake_pressure >= RTD_BRAKE_THRESHOLD && inv_enabled == 1)
+  if (rtd_timer_armed && HAL_GetTick() - rtd_trying_to_toggle_start_tick >= RTD_SAFETY_DURATION)
   {
-    // FEB_IO_Play_Buzzer(BUZZER_DURATION_RTD_ENTER);
-    rtd = true;
+    if (!rtd_toggle_complete)
+    {
+      rtd = !rtd;
+      rtd_toggle_complete = true;
+    }
+  }
+  else
+  {
+    rtd_toggle_complete = false;
   }
 
-  previous_rtd_button = states.button_rtd;
+  if (bms_state != BMS_STATE_DRIVE && bms_state != BMS_STATE_ENERGIZED)
+  {
+    rtd = false; // just in case
+  }
 }
 
 bool FEB_State_GetLastRTD(void)