inverter retry logic for fault handling

can_bus/quintuna/VC/VC_enum.json

@@ -8,7 +8,8 @@
     "VC_HV_ON_STATE": 5,
     "VC_DRIVE_STATE": 6,
     "VC_DRIVE_WARNING_STATE": 7,
-    "VC_FAULT_STATE": 8
+    "VC_FAULT_STATE": 8,
+    "VC_INV_FAUTLED": 9
   },
   "TsimColor": {
     "TSIM_RED": 0,
@@ -28,7 +29,8 @@
     "INV_DC_ON":1,
     "INV_ENABLE":2,
     "INV_INVERTER_ON":3,
-    "INV_READY_FOR_DRIVE":4
+    "INV_READY_FOR_DRIVE":4,
+    "INV_ERROR_RETRY":5 
   },
 
   "EllipseErrorCode": {

firmware/quintuna/VC/src/app/app_faultHandling.h

@@ -2,4 +2,4 @@
 // function to get all board faults
 #include <stdbool.h>
 
-bool app_faultHandling_air_minus_closed(void);
+bool app_faultHandling_air_minus_closed(void);

firmware/quintuna/VC/src/app/app_inverter.c

@@ -0,0 +1,84 @@
+#include "app_inverter.h"
+#include "app_signal.h"
+#include "app_canAlerts.h"
+#include "app_canRx.h"
+#include "app_canTx.h"
+#include "states/app_states.h"
+#include "io_log.h"
+
+const State *state_to_recover_after_fault;
+
+const InverterHandle inverter_handle_FL = {
+    .can_enable_inv  = app_canTx_VC_INVFLbEnable_set,
+    .can_invOn       = app_canTx_VC_INVFLbInverterOn_set,
+    .can_dcOn        = app_canTx_VC_INVFLbDcOn_set,
+    .can_error_info  = app_canRx_INVFL_ErrorInfo_get,
+    .error_reset     = app_canTx_VC_INVFLbErrorReset_set,
+    .can_error_bit   = app_canRx_INVFL_bError_get,
+    .can_inv_warning = app_canAlerts_VC_Warning_FrontLeftInverterFault_set,
+};
+const InverterHandle inverter_handle_FR = {
+    .can_enable_inv  = app_canTx_VC_INVFRbEnable_set,
+    .can_invOn       = app_canTx_VC_INVFRbInverterOn_set,
+    .can_dcOn        = app_canTx_VC_INVFRbDcOn_set,
+    .can_error_info  = app_canRx_INVFR_ErrorInfo_get,
+    .error_reset     = app_canTx_VC_INVFRbErrorReset_set,
+    .can_error_bit   = app_canRx_INVFR_bError_get,
+    .can_inv_warning = app_canAlerts_VC_Warning_FrontRightInverterFault_set,
+};
+const InverterHandle inverter_handle_RL = {
+    .can_enable_inv  = app_canTx_VC_INVRLbEnable_set,
+    .can_invOn       = app_canTx_VC_INVRLbInverterOn_set,
+    .can_dcOn        = app_canTx_VC_INVRLbDcOn_set,
+    .can_error_info  = app_canRx_INVRL_ErrorInfo_get,
+    .error_reset     = app_canTx_VC_INVRLbErrorReset_set,
+    .can_error_bit   = app_canRx_INVRL_bError_get,
+    .can_inv_warning = app_canAlerts_VC_Warning_RearLeftInverterFault_set,
+};
+const InverterHandle inverter_handle_RR = {
+    .can_enable_inv  = app_canTx_VC_INVRRbEnable_set,
+    .can_invOn       = app_canTx_VC_INVRRbInverterOn_set,
+    .can_dcOn        = app_canTx_VC_INVRRbDcOn_set,
+    .can_error_info  = app_canRx_INVRR_ErrorInfo_get,
+    .error_reset     = app_canTx_VC_INVRRbErrorReset_set,
+    .can_error_bit   = app_canRx_INVRR_bError_get,
+    .can_inv_warning = app_canAlerts_VC_Warning_RearRightInverterFault_set,
+};
+
+bool app_inverter_inverterStatus(void)
+{
+    const bool invrr_error = app_canRx_INVRR_bError_get() == true;
+    const bool invrl_error = app_canRx_INVRL_bError_get() == true;
+    const bool invfl_error = app_canRx_INVFL_bError_get() == true;
+    const bool invfr_error = app_canRx_INVFR_bError_get() == true;
+
+    app_canAlerts_VC_Warning_RearLeftInverterFault_set(invrl_error);
+    app_canAlerts_VC_Warning_FrontRightInverterFault_set(invfr_error);
+    app_canAlerts_VC_Warning_FrontLeftInverterFault_set(invfl_error);
+    app_canAlerts_VC_Warning_RearRightInverterFault_set(invrr_error);
+
+    return invfl_error || invrl_error || invrr_error || invfr_error;
+}
+
+void app_stateMachine_inverterFaultHandling(void)
+{
+    const State *curr = app_stateMachine_getCurrentState();
+
+    if (!app_inverter_inverterStatus() || curr == &inverter_fault_handling_state)
+    {
+        return;
+    }
+
+    // We do not want to go back to HV or Drive while we haven't passed HV_INIT again
+    if (curr == &hv_state || curr == &drive_state)
+    {
+        state_to_recover_after_fault = &hvInit_state;
+    }
+    else
+    {
+        state_to_recover_after_fault = curr;
+    }
+
+    LOG_INFO("inverter state in appinv %s", state_to_recover_after_fault->name);
+    app_stateMachine_setNextState(&inverter_fault_handling_state);
+}

firmware/quintuna/VC/src/app/app_inverter.h

@@ -0,0 +1,45 @@
+#pragma once
+#include "stdbool.h"
+#include <stdint.h>
+#include "app_stateMachine.h"
+
+extern const State *state_to_recover_after_fault;
+typedef enum
+{
+    CAN_ISSUES = 3587,
+    DC_BUS_ISSUES,
+} Inverter_Fault_Info;
+typedef enum
+{
+    INVERTER_FL,
+    INVERTER_FR,
+    INVERTER_RL,
+    INVERTER_RR,
+    NUM_INVERTERS
+} InverterConfig;
+
+typedef enum
+{
+    INV_FAULT_RETRY,
+    INV_FAULT_LOCKOUT,
+    INV_FAULT_RECOVERED,
+} VCInverterFaults;
+typedef struct
+{
+    void (*can_enable_inv)(bool);
+    void (*can_invOn)(bool);
+    void (*can_dcOn)(bool);
+    uint32_t (*can_error_info)(void);
+    void (*error_reset)(bool);
+    bool (*can_error_bit)(void);
+    void (*can_inv_warning)(bool);
+} InverterHandle;
+
+extern const InverterHandle inverter_handle_FL;
+extern const InverterHandle inverter_handle_FR;
+extern const InverterHandle inverter_handle_RL;
+extern const InverterHandle inverter_handle_RR;
+
+// inverters
+bool app_inverter_inverterStatus(void);
+void app_stateMachine_inverterFaultHandling(void);

firmware/quintuna/VC/src/app/app_warningHandling.c

@@ -1,81 +1,21 @@
-#include "app_warningHandling.h"
 
+#include "app_warningHandling.h"
 #include "app_signal.h"
-
 #include "app_canAlerts.h"
 #include "app_canRx.h"
 #include "app_canTx.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-
 #define APPS_BRAKE_DISAGREEMENT_TIME_TO_FAULT (10u)
 #define APPS_BRAKE_DISAGREEMENT_TIME_TO_CLEAR (10u)
 
 static Signal apps_brake_disagreement_signal;
-typedef enum
-{
-    INVERTER_FL,
-    INVERTER_FR,
-    INVERTER_RL,
-    INVERTER_RR,
-    NUM_INVERTERS
-} InverterConfig;
 
-bool app_warningHandling_boardWarningCheck(void)
+bool app_warningHandlin_boardWarningCheck(void)
 {
     return app_canAlerts_AnyBoardHasWarning();
 }
 
-typedef struct
-{
-    void (*can_enable_inv)(bool);
-    void (*can_invOn)(bool);
-    void (*can_dcOn)(bool);
-    uint32_t (*can_error_info)(void);
-    void (*error_reset)(bool);
-} InverterWarningHandling;
-
-static InverterWarningHandling inverter_reset_handle[NUM_INVERTERS] = {
-    [INVERTER_FL] = { .can_enable_inv = app_canTx_VC_INVFLbEnable_set,
-                      .can_invOn      = app_canTx_VC_INVFLbInverterOn_set,
-                      .can_dcOn       = app_canTx_VC_INVFLbDcOn_set,
-                      .can_error_info = app_canRx_INVFL_ErrorInfo_get,
-                      .error_reset    = app_canTx_VC_INVFLbErrorReset_set },
-    [INVERTER_FR] = { .can_enable_inv = app_canTx_VC_INVFRbEnable_set,
-                      .can_invOn      = app_canTx_VC_INVFRbInverterOn_set,
-                      .can_dcOn       = app_canTx_VC_INVFRbDcOn_set,
-                      .can_error_info = app_canRx_INVFR_ErrorInfo_get,
-                      .error_reset    = app_canTx_VC_INVFRbErrorReset_set },
-    [INVERTER_RL] = { .can_enable_inv = app_canTx_VC_INVRLbEnable_set,
-                      .can_invOn      = app_canTx_VC_INVRLbInverterOn_set,
-                      .can_dcOn       = app_canTx_VC_INVRLbDcOn_set,
-                      .can_error_info = app_canRx_INVRL_ErrorInfo_get,
-                      .error_reset    = app_canTx_VC_INVRLbErrorReset_set },
-    [INVERTER_RR] = { .can_enable_inv = app_canTx_VC_INVRRbEnable_set,
-                      .can_invOn      = app_canTx_VC_INVRRbInverterOn_set,
-                      .can_dcOn       = app_canTx_VC_INVRRbDcOn_set,
-                      .can_error_info = app_canRx_INVRR_ErrorInfo_get,
-                      .error_reset    = app_canTx_VC_INVRRbErrorReset_set },
-};
-
-bool app_warningHandling_inverterStatus(void)
-{
-    const bool invrr_error = app_canRx_INVRR_bError_get() == true;
-    const bool invrl_error = app_canRx_INVRL_bError_get() == true;
-    const bool invfl_error = app_canRx_INVFL_bError_get() == true;
-    const bool invfr_error = app_canRx_INVFR_bError_get() == true;
-
-    app_canAlerts_VC_Warning_RearLeftInverterFault_set(invrl_error);
-    app_canAlerts_VC_Warning_FrontRightInverterFault_set(invrr_error);
-    app_canAlerts_VC_Warning_FrontLeftInverterFault_set(invfl_error);
-    app_canAlerts_VC_Warning_RearRightInverterFault_set(invfr_error);
-
-    return invfl_error || invrl_error || invrr_error || invfr_error;
-}
-
 // TODO: integrate with warnings (will have to make compatible with regen)
-bool app_warningHandling_checkSoftwareBspd(float papps_pedal_percentage)
+bool app_warningHandlin_checkSoftwareBspd(float papps_pedal_percentage)
 {
     // Accelerator Brake Plausibility (bad user input safety issues)
     // Protect against brake/apps active at same time
@@ -95,16 +35,6 @@ bool app_warningHandling_checkSoftwareBspd(float papps_pedal_percentage)
     return apps_brake_disagreement_active;
 }
 
-void app_warningHandling_inverterReset(void)
-{
-    for (uint8_t inverter = 0; inverter < NUM_INVERTERS; inverter++)
-    {
-        inverter_reset_handle[inverter].can_invOn(false);
-        inverter_reset_handle[inverter].can_dcOn(false);
-        inverter_reset_handle[inverter].can_enable_inv(false);
-        inverter_reset_handle[inverter].error_reset(true);
-    }
-}
 void app_softwareBspd_init(void)
 {
     app_signal_init(

firmware/quintuna/VC/src/app/app_warningHandling.h

@@ -1,19 +1,9 @@
 #pragma once
 #include "stdbool.h"
-
-typedef enum
-{
-    CAN_ISSUES = 3587,
-    DC_BUS_ISSUES,
-} Inverter_Fault_Info;
-
-// board warnings
-bool app_warningHandling_boardWarningCheck(void);
-
-// inverters
-bool app_warningHandling_inverterStatus(void);
-void app_warningHandling_inverterReset(void);
+#include <stdint.h>
 
 // bspd
 void app_softwareBspd_init(void);
-bool app_warningHandling_checkSoftwareBspd(float papps_pedal_percentage);
+bool app_warningHandlin_checkSoftwareBspd(float papps_pedal_percentage);
+// board warnings
+bool app_warningHandlin_boardWarningCheck(void);