ECU State Machine Implementation

CCU/Core/Inc/stm32g4xx_it.h

@@ -55,8 +55,6 @@ void SVC_Handler(void);
 void DebugMon_Handler(void);
 void PendSV_Handler(void);
 void SysTick_Handler(void);
-void FDCAN1_IT0_IRQHandler(void);
-void FDCAN2_IT0_IRQHandler(void);
 /* USER CODE BEGIN EFP */
 
 /* USER CODE END EFP */

CCU/Core/Src/stm32g4xx_it.c

@@ -187,41 +187,6 @@ void SysTick_Handler(void)
 	/* USER CODE END SysTick_IRQn 1 */
 }
 
-/******************************************************************************/
-/* STM32G4xx Peripheral Interrupt Handlers                                    */
-/* Add here the Interrupt Handlers for the used peripherals.                  */
-/* For the available peripheral interrupt handler names,                      */
-/* please refer to the startup file (startup_stm32g4xx.s).                    */
-/******************************************************************************/
-
-/**
- * @brief This function handles FDCAN1 interrupt 0.
- */
-void FDCAN1_IT0_IRQHandler(void)
-{
-	/* USER CODE BEGIN FDCAN1_IT0_IRQn 0 */
-
-	/* USER CODE END FDCAN1_IT0_IRQn 0 */
-	HAL_FDCAN_IRQHandler(&hfdcan1);
-	/* USER CODE BEGIN FDCAN1_IT0_IRQn 1 */
-
-	/* USER CODE END FDCAN1_IT0_IRQn 1 */
-}
-
-/**
- * @brief This function handles FDCAN2 interrupt 0.
- */
-void FDCAN2_IT0_IRQHandler(void)
-{
-	/* USER CODE BEGIN FDCAN2_IT0_IRQn 0 */
-
-	/* USER CODE END FDCAN2_IT0_IRQn 0 */
-	HAL_FDCAN_IRQHandler(&hfdcan2);
-	/* USER CODE BEGIN FDCAN2_IT0_IRQn 1 */
-
-	/* USER CODE END FDCAN2_IT0_IRQn 1 */
-}
-
 /* USER CODE BEGIN 1 */
 
 /* USER CODE END 1 */

ECU/Application/Inc/CANutils.h

@@ -0,0 +1,15 @@
+#include <stdint.h>
+
+#include "GR_OLD_BUS_ID.h"
+#include "GR_OLD_MSG_ID.h"
+#include "GR_OLD_NODE_ID.h"
+#include "StateData.h"
+
+#ifndef CANUTILS_H
+#define CANUTILS_H
+
+#define ECU_STATE_DATA_SEND_INTERVAL_MS 250
+void ECU_CAN_Send(GR_OLD_BUS_ID bus, GR_OLD_NODE_ID destNode, GR_OLD_MSG_ID messageID, void *data, uint32_t size);
+void SendECUStateDataOverCAN(ECU_StateData *stateData);
+
+#endif

ECU/Application/Inc/StateData.h

@@ -18,32 +18,93 @@
  * @remark It is passed to each state function on tick to allow state-specific
  * logic to access and modify the ECU's operational data.
  */
-typedef struct ECU_StateData {
-	// DON'T TOUCH YET
-	GR_OLD_ECU_STATUS_1_MSG ecuStatus1;
-	GR_OLD_ECU_STATUS_2_MSG ecuStatus2;
-	GR_OLD_ECU_STATUS_3_MSG ecuStatus3;
+
+#define SAFE_VOLTAGE_LIMIT 60
+#define BUTTON_REFRESH_RATE_MS 100
+
+typedef union {
+	struct {
+		uint8_t ECUState;
+		uint8_t StatusBits[3];
+		uint8_t PowerLevelTorqueMap;
+		uint8_t MaxCellTemp;
+		uint8_t AccumulatorStateOfCharge;
+		uint8_t GLVStateOfCharge;
+		uint16_t TractiveSystemVoltage;
+		uint16_t VehicleSpeed;
+		uint16_t FRWheelRPM;
+		uint16_t FLWheelRPM;
+		uint16_t RRWheelRPM;
+		uint16_t RLWheelRPM;
+	};
+
+	struct {
+		uint8_t ECUStatusMsgOne[8];
+		uint8_t ECUStatusMsgTwo[8];
+		uint8_t ECUStatusMsgThree[4];
+	};
+} ECU_StateDataToSend;
+
+typedef volatile struct ECU_StateData {
+
+	// TODO: Remove unneeded states
+
+	uint32_t millisSinceBoot;
 
 	int32_t dischargeStartMillis;
-	uint32_t lastECUStatusMsgTick;
+	uint32_t lastECUStatusMsgMillis;
 	uint32_t lastTSSIFlash;
 	int32_t last_drive_active_control_ms;
+
 	float min_amk_heat_cap_throttle_percent;
+	float ts_voltage;
+	float max_cell_temp; /** Temperature of hottest cell, celsius */
+
+	float vehicle_speed; /** Vehicle speed, MPH */
+	float fr_wheel_rpm;  /** FR wheel, RPM */
+	float fl_wheel_rpm;  /** FL wheel, RPM */
+	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;
+
+	float estop_sense;
 	uint16_t driving_heat_capacity_1;
 	uint16_t driving_heat_capacity_2;
 	uint16_t APPS1_Signal;
 	uint16_t APPS2_Signal;
 	uint16_t Brake_R_Signal;
 	uint16_t Brake_F_Signal;
-	uint8_t acu_error_warning_bits;
+	uint16_t STEERING_ANGLE_SIGNAL;
+	uint8_t status_bits[3];
+	int8_t ping_block[3];	      /** Node timeout status bits (1=OK, 0=Timeout) */
+	uint8_t powerlevel_torquemap; /** Power lvl (4b) & torque map (4b) */
+	uint8_t tractivebattery_soc;
+	uint8_t glv_soc;
+	uint8_t bcu_error_warning_bits;
 	uint8_t inverter_fault_map;
-	bool bse_apps_violation;
-	bool ts_active_button_engaged;
-	bool rtd_button_engaged;
-} ECU_StateData; // FIXME Add comments to each data field with descriptions and
-		 // rules (eg -1 = invalid?, etc)
-		 // Will also need to add information from ADC into this struct
-		 // --- such as the APPS and Brake signals after doing smoothing
-		 // and whatnot to get the values sane
+	bool ts_active;
+	bool rtd;
+	bool prev_ts_active_button_state;
+	bool prev_rtd_button_state;
+	uint32_t prev_ts_press_millis;
+	uint32_t prev_rtd_press_millis;
+	bool ir_plus;
+	bool ir_minus;
+	bool bcu_software_latch;
+
+	bool bms_light;
+	bool imd_light;
+	bool tssi_red;
+
+	uint32_t tssi_red_blinking_current_cycle_starting_millis;
+
+	GR_ECU_State ecu_state;
+} ECU_StateData;
 
 #endif

ECU/Application/Inc/StateTicks.h

@@ -1,9 +1,14 @@
 #include "StateData.h"
 #include "StateMachine.h"
+#include "adc.h"
+#include "can.h"
 
 #ifndef _STATE_TICKS_H_
 #define _STATE_TICKS_H_
 
+extern CANHandle *primary_can;
+extern CANHandle *data_can;
+
 /**
  * @brief Tick function for the ECU state machine.
  *
@@ -35,6 +40,17 @@ void ECU_GLV_Off(ECU_StateData *stateData);
  */
 void ECU_GLV_On(ECU_StateData *stateData);
 
+/**
+ * @brief Handles the transition from GLV On to Precharge Engaged state.
+ *
+ * Initiates the precharge process by switching to the Precharge Engaged state.
+ *
+ * @param stateData Pointer to the ECU state data structure.
+ *
+ * @return void
+ */
+void ECU_Precharge_Start(ECU_StateData *stateData);
+
 /**
  * @brief State handler for the Precharge Engaged state.
  *
@@ -68,6 +84,18 @@ void ECU_Precharge_Complete(ECU_StateData *stateData);
  */
 void ECU_Drive_Active(ECU_StateData *stateData);
 
+/**
+ * @brief Init function for ECU_Tractive_System_Discharge_Start.
+ *
+ * Resets Tractive System discharge timer and switches on the Tractive System
+ * Discharge state.
+ *
+ * @param stateData Pointer to the ECU state data structure.
+ *
+ * @return void
+ */
+void ECU_Tractive_System_Discharge_Start(ECU_StateData *stateData);
+
 /**
  * @brief State handler for the Tractive System Discharge state.
  *

ECU/Application/Inc/StateUtils.h

@@ -6,6 +6,10 @@
 #ifndef _STATE_UTILS_H_
 #define _STATE_UTILS_H_
 
+/// @brief Get the current time in milliseconds since system start
+/// @return Current time in milliseconds
+uint32_t MillisecondsSinceBoot(void);
+
 // Constants
 #define BRAKE_F_MIN 0	    // TODO: need to be determined FIXME: Rename better
 #define BRAKE_F_MAX 4095    // TODO: need to be determined FIXME: Rename better
@@ -19,12 +23,20 @@
 #define APPS_PROPORTION 2.0f // TODO: Need to be experimentally determined
 #define APPS_OFFSET 250.0f   // TODO: Need to be experimentally determined
 
+#define MAX_CURRENT_AMPS 42.0f	       // TODO: Change as appropriate
+#define MAX_REVERSE_CURRENT_AMPS 20.0f // TODO: Change as appropriate
+
+void setSoftwareLatch(bool close);
+
 // Checks stateData for critical errors
-bool CriticalError(const ECU_StateData *stateData);
-bool CommunicationError(const ECU_StateData *stateData);
-bool APPS_BSE_Violation(const ECU_StateData *stateData);
-bool PressingBrake(const ECU_StateData *stateData);
-float CalcBrakePercent(const ECU_StateData *stateData);
-float CalcPedalTravel(const ECU_StateData *stateData);
+bool CriticalError(volatile const ECU_StateData *stateData);
+bool bmsFailure(volatile const ECU_StateData *stateData);
+bool imdFailure(volatile const ECU_StateData *stateData);
+bool CommunicationError(volatile const ECU_StateData *stateData);
+bool APPS_BSE_Violation(volatile const ECU_StateData *stateData);
+bool PressingBrake(volatile const ECU_StateData *stateData);
+float CalcBrakePercent(volatile const ECU_StateData *stateData);
+float CalcPedalTravel(volatile const ECU_StateData *stateData);
+bool vehicle_is_moving(volatile const ECU_StateData *stateData);
 
 #endif

ECU/Application/Src/CANdler.c

@@ -7,6 +7,9 @@
 #include "GR_OLD_NODE_ID.h"
 #include "Logomatic.h"
 #include "StateData.h"
+#include "bitManipulations.h"
+
+extern ECU_StateData stateLump;
 
 void ReportBadMessageLength(GR_OLD_BUS_ID bus_id, GR_OLD_MSG_ID msg_id, GR_OLD_NODE_ID sender_id)
 {
@@ -31,47 +34,55 @@ void ECU_CAN_MessageHandler(ECU_StateData *state_data, GR_OLD_BUS_ID bus_id, GR_
 			}
 			LOGOMATIC("Received from %02X on bus %d: %.*s\n", sender_id, bus_id, (int)data_length, data);
 			break;
+
 		case MSG_DEBUG_FD:
 			if (data_length > sizeof(GR_OLD_DEBUG_2_MSG)) {
 				ReportBadMessageLength(bus_id, msg_id, sender_id);
 				break;
 			}
 			LOGOMATIC("Received from %02X on bus %d: %.*s\n", sender_id, bus_id, (int)data_length, data);
 			break;
+
 		case MSG_PING:
 			if (data_length != sizeof(GR_OLD_PING_MSG)) {
 				ReportBadMessageLength(bus_id, msg_id, sender_id);
 				break;
 			}
 			// TODO See Issue #143
 			break;
-		case MSG_ACU_STATUS_1:
+
+		case MSG_BCU_STATUS_1:
 			if (data_length != sizeof(GR_OLD_BCU_STATUS_1_MSG)) {
 				ReportBadMessageLength(bus_id, msg_id, sender_id);
 				break;
 			}
 			GR_OLD_BCU_STATUS_1_MSG *bcu_status_1 = (GR_OLD_BCU_STATUS_1_MSG *)data;
-			state_data->ecuStatus1.tractivebattery_soc = bcu_status_1->tractivebattery_soc;
-			state_data->ecuStatus1.glv_soc = bcu_status_1->glv_soc;
-			state_data->ecuStatus2.ts_voltage = bcu_status_1->ts_voltage;
+			state_data->tractivebattery_soc = bcu_status_1->tractivebattery_soc * 0.01;
+			state_data->glv_soc = bcu_status_1->glv_soc * 20 / 51;
+			state_data->ts_voltage = bcu_status_1->ts_voltage * 0.01;
 			break;
-		case MSG_ACU_STATUS_2:
+
+		case MSG_BCU_STATUS_2:
 			if (data_length != sizeof(GR_OLD_BCU_STATUS_2_MSG)) {
 				ReportBadMessageLength(bus_id, msg_id, sender_id);
 				break;
 			}
 			GR_OLD_BCU_STATUS_2_MSG *bcu_status_2 = (GR_OLD_BCU_STATUS_2_MSG *)data;
-			state_data->ecuStatus1.max_cell_temp = bcu_status_2->max_cell_temp;
-			state_data->acu_error_warning_bits = bcu_status_2->error_bits;
+			state_data->max_cell_temp = bcu_status_2->max_cell_temp * 0.25;
+			state_data->bcu_error_warning_bits = bcu_status_2->error_bits;
+			state_data->ir_minus = GETBIT(bcu_status_2->precharge_bits, 1);
+			state_data->ir_plus = GETBIT(bcu_status_2->precharge_bits, 2);
+			state_data->bcu_software_latch = GETBIT(bcu_status_2->precharge_bits, 3);
 			break;
+
 		case MSG_INVERTER_STATUS_1:
 			if (data_length != sizeof(GR_OLD_INVERTER_STATUS_1_MSG)) {
 				ReportBadMessageLength(bus_id, msg_id, sender_id);
 				break;
 			}
 			GR_OLD_INVERTER_STATUS_1_MSG *inverter_status_1 = (GR_OLD_INVERTER_STATUS_1_MSG *)data;
-			state_data->ecuStatus3.rl_wheel_rpm = inverter_status_1->motor_rpm;
-			state_data->ecuStatus3.rr_wheel_rpm = inverter_status_1->motor_rpm;
+			state_data->rl_wheel_rpm = inverter_status_1->motor_rpm - 32768;
+			state_data->rr_wheel_rpm = inverter_status_1->motor_rpm - 32768;
 			break;
 		case MSG_INVERTER_STATUS_3:
 			if (data_length != sizeof(GR_OLD_INVERTER_STATUS_3_MSG)) {
@@ -81,22 +92,13 @@ void ECU_CAN_MessageHandler(ECU_StateData *state_data, GR_OLD_BUS_ID bus_id, GR_
 			GR_OLD_INVERTER_STATUS_3_MSG *inverter_status_3 = (GR_OLD_INVERTER_STATUS_3_MSG *)data;
 			state_data->inverter_fault_map = inverter_status_3->fault_bits;
 			break;
-		case MSG_DASH_STATUS:
-			if (data_length != sizeof(GR_OLD_DASH_STATUS_MSG)) {
-				ReportBadMessageLength(bus_id, msg_id, sender_id);
-				break;
-			}
-			GR_OLD_DASH_STATUS_MSG *dash_status = (GR_OLD_DASH_STATUS_MSG *)data;
-			state_data->ts_active_button_engaged = dash_status->ts_button;
-			state_data->rtd_button_engaged = dash_status->rtd_button;
-			break;
 		case MSG_STEERING_STATUS:
 			if (data_length != sizeof(GR_OLD_STEERING_STATUS_MSG)) {
 				ReportBadMessageLength(bus_id, msg_id, sender_id);
 				break;
 			}
 			GR_OLD_STEERING_STATUS_MSG *steering_status = (GR_OLD_STEERING_STATUS_MSG *)data;
-			state_data->ecuStatus1.powerlevel_torquemap = steering_status->encoder_bits;
+			state_data->powerlevel_torquemap = steering_status->encoder_bits;
 			break;
 		default:
 			ReportUnhandledMessage(bus_id, msg_id, sender_id);