Dynamic SDC Voltages

ECU/Application/Inc/StateData.h

@@ -54,6 +54,7 @@ typedef volatile struct ECU_StateData {
 
 	float min_amk_heat_cap_throttle_percent;
 	float ts_voltage;
+	float glv_voltage_20V;
 	float max_cell_temp_c; /** Temperature of hottest cell, celsius */
 
 	float vehicle_speed_mph; /** Vehicle speed, MPH */
@@ -62,9 +63,7 @@ typedef volatile struct ECU_StateData {
 	float rr_wheel_rpm;	 /** RRv wheel, RPM */
 	float rl_wheel_rpm;	 /** RL wheel, RPM */
 
-	// 0.5V when things go to shit (X_OK low) (BAD)
-	// 3V when things almost poggers (X_OK high but SDC not reset) (BAD)
-	// 2.4V when things are actually poggers (X_OK high and SDC is not triggered)
+
 	float ams_sense;
 	float imd_sense;
 	float bspd_sense;

ECU/Application/Inc/StateUtils.h

@@ -42,8 +42,17 @@ uint32_t MillisecondsSinceBoot(void);
 #define RATE_LIMIT_100_HZ(x, y) (x - y > 10)
 #define RATE_LIMIT_10_HZ(x, y) (x - y > 100)
 
+typedef enum {
+    SDC_OK,
+    SDC_ONGOING_FAILURE,
+    SDC_LATCHED_FAILURE
+} SDC_Level;
+
 // Checks stateData for critical errors
 bool CriticalError(volatile const ECU_StateData *stateData);
+SDC_Level bmsLevel(volatile const ECU_StateData *stateData);
+SDC_Level imdLevel(volatile const ECU_StateData *stateData);
+SDC_Level bspdLevel(volatile const ECU_StateData *stateData);
 bool bmsFailure(volatile const ECU_StateData *stateData);
 bool imdFailure(volatile const ECU_StateData *stateData);
 bool bspdFailure(volatile const ECU_StateData *stateData);

ECU/Application/Src/CANdler.c

@@ -80,6 +80,7 @@ void ECU_CAN_MessageHandler(ECU_StateData *state_data, GRCAN_BUS_ID bus_id, GRCA
 			state_data->ir_minus = GETBIT(acu_status_2->precharge_latch_flags, 4);
 			state_data->ir_plus = GETBIT(acu_status_2->precharge_latch_flags, 5);
 			state_data->acu_software_latch = GETBIT(acu_status_2->precharge_latch_flags, 6);
+			state_data->glv_voltage_20V = acu_status_2->_20v_voltage * 0.1f;
 			break;
 
 		case GRCAN_INVERTER_STATUS_1:

ECU/Application/Src/StateTicks.c

@@ -25,7 +25,7 @@
  * @remark Intentionally not a globally accessible variable
  */
 
-ECU_StateData stateLump = {.ecu_state = GR_GLV_ON, .acu_software_latch = 1};
+ECU_StateData stateLump = {.ecu_state = GR_GLV_ON, .acu_software_latch = 1, .glv_voltage_20V = 20.0f};
 
 static uint32_t millis_since_boot;
 void ECU_State_Tick(void)
@@ -53,8 +53,11 @@ void ECU_State_Tick(void)
 	// stateLump.bms_light &= (bmsFailure(&stateLump));
 	// stateLump.imd_light &= (imdFailure(&stateLump));
 
-	stateLump.bms_light = (stateLump.ams_sense <= 0.5f) || (stateLump.bms_light && bmsFailure(&stateLump));
-	stateLump.imd_light = (stateLump.ams_sense <= 0.5f) || (stateLump.imd_light && imdFailure(&stateLump));
+	SDC_Level bms_level = bmsLevel(&stateLump);
+	SDC_Level imd_level = imdLevel(&stateLump);
+
+	stateLump.bms_light = (bms_level == SDC_ONGOING_FAILURE) || (stateLump.bms_light && bmsFailure(&stateLump));
+	stateLump.imd_light = (imd_level == SDC_ONGOING_FAILURE) || (stateLump.imd_light && imdFailure(&stateLump));
 
 	stateLump.tssi_fault = stateLump.bms_light || stateLump.imd_light;
 

ECU/Application/Src/StateUtils.c

@@ -55,9 +55,42 @@ bool CriticalError(volatile const ECU_StateData *stateData)
 	return problem;
 }
 
+SDC_Level bmsLevel(volatile const ECU_StateData *stateData) {
+	// TODO: DYNAMIC LOGIC HERE
+	if (stateData->ams_sense < 0.5f) {
+		return SDC_ONGOING_FAILURE;
+	} else if (stateData->ams_sense > 1.6f) {
+		return SDC_LATCHED_FAILURE;
+	}
+
+	return SDC_OK;
+}
+
+SDC_Level imdLevel(volatile const ECU_StateData *stateData) {
+	// TODO: DYNAMIC LOGIC HERE
+	if (stateData->imd_sense < 0.5f) {
+		return SDC_ONGOING_FAILURE;
+	} else if (stateData->imd_sense > 1.6f) {
+		return SDC_LATCHED_FAILURE;
+	}
+
+	return SDC_OK;
+}
+
+SDC_Level bspdLevel(volatile const ECU_StateData *stateData) {
+	if (stateData->bspd_sense < 0.6f) {
+		return SDC_ONGOING_FAILURE;
+	} else if (stateData->bspd_sense > 1.35f) {
+		return SDC_LATCHED_FAILURE;
+	}
+
+	return SDC_OK;
+}
+
 bool bmsFailure(volatile const ECU_StateData *stateData)
 {
-	return stateData->ams_sense < 0.5f || stateData->ams_sense > 1.6f; // 0.5 to 1.6 is valid
+	SDC_Level level = bmsLevel(stateData);
+	return level == SDC_ONGOING_FAILURE || level == SDC_LATCHED_FAILURE;
 }
 
 bool imdFailure(volatile const ECU_StateData *stateData)
@@ -68,12 +101,14 @@ bool imdFailure(volatile const ECU_StateData *stateData)
 		return false;
 	}
 
-	return stateData->imd_sense < 0.5f || stateData->imd_sense > 1.6f; // 0.5 to 1.6 is valid
+	SDC_Level level = imdLevel(stateData);
+	return level == SDC_ONGOING_FAILURE || level == SDC_LATCHED_FAILURE;
 }
 
 bool bspdFailure(volatile const ECU_StateData *stateData)
 {
-	return stateData->bspd_sense < 0.6f || stateData->bspd_sense > 1.35f; // possible values are 0.3, 1.2, 1.6
+	SDC_Level level = bspdLevel(stateData);
+	return level == SDC_ONGOING_FAILURE || level == SDC_LATCHED_FAILURE;
 }
 
 bool APPS_BSE_Violation(volatile const ECU_StateData *stateData)

ECU/Core/Src/main.c

@@ -123,7 +123,6 @@ void write_adc_values_to_state_data(void)
 	stateLump.aux_signal = ADC_outputs[6];
 	stateLump.steering_angle_signal = ADC_outputs[10]; // TODO: convert to rad/deg...?
 
-	// TODO: determine conversion factors for all of these (uint to float)
 	stateLump.bspd_sense = ADC_outputs[7] / 4095.0 * 3.3;
 	stateLump.imd_sense = ADC_outputs[8] / 4095.0 * 3.3;
 	stateLump.ams_sense = ADC_outputs[9] / 4095.0 * 3.3;