ECU CAN Migration

Autogen/CAN/Doc/GRCAN.CANdo

@@ -4058,7 +4058,7 @@ Message ID:
     Elapsed Cycles:
       bit_start: 0
       comment:
-        Represents total number of clock cycles in main excluding delay
+        Represents the total number of clock cycles elapsed for 10 iterations of the main loop
         data type: u32
         units: Clock Cycles
       data type: u8

Autogen/CAN/Inc/GRCAN_MSG_DATA.h

@@ -405,7 +405,7 @@ typedef struct {
 	uint16_t steering_angle_signal;
 	/** 4-20 mA signal (Byte 14) */
 	uint16_t aux_signal;
-} GRCAN_ECU_PEDALS_DATA_MSG;
+} GRCAN_ECU_ANALOG_DATA_MSG;
 
 /** GPS LAT */
 typedef struct {
@@ -465,4 +465,13 @@ typedef struct {
 	uint16_t dgps_w;
 } GRCAN_UVW_DGPS_MSG;
 
+/** ECU Performance */
+typedef struct {
+	/**
+	 * Represents the total number of clock cycles elapsed for 10 iterations of the main loop
+	 * data type: u32
+	 * units: Clock Cycles (Byte 0) */
+	uint32_t elapsed_cycles;
+} GRCAN_ECU_PERFORMANCE_MSG;
+
 #endif

Autogen/CAN/Inc/GRCAN_MSG_ID.h

@@ -33,14 +33,15 @@ typedef enum {
 	MSG_TCM_STATUS = 0x029,
 	MSG_TCM_RESOURCE_UTILIZATION = 0x02A,
 	MSG_DASH_WARNING_FLAGS = 0x02B,
-	MSG_ECU_PEDALS_DATA = 0x02E,
+	MSG_ECU_ANALOG_DATA = 0x02E,
 	MSG_GPS_LAT = 0x031,
 	MSG_GPS_LON = 0x032,
 	MSG_GPS_ALT = 0x033,
 	MSG_GPS_PX = 0x034,
 	MSG_GPS_QY = 0x035,
 	MSG_GPS_RZ = 0x036,
 	MSG_UVW_DGPS = 0x030,
+	MSG_ECU_PERFORMANCE = 0x123,
 } GRCAN_MSG_ID;
 
 #endif // CAN_MSG_IDS_H

ECU/Application/Inc/CANdler.h

@@ -1,14 +1,14 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-#include "GR_OLD_BUS_ID.h"
-#include "GR_OLD_MSG_ID.h"
-#include "GR_OLD_NODE_ID.h"
+#include "GRCAN_BUS_ID.h"
+#include "GRCAN_MSG_ID.h"
+#include "GRCAN_NODE_ID.h"
 #include "StateData.h"
 
 #ifndef CANDLER_H
 #define CANDLER_H
 
-void ECU_CAN_MessageHandler(ECU_StateData *state_data, GR_OLD_BUS_ID bus_id, GR_OLD_MSG_ID msg_id, GR_OLD_NODE_ID sender_id, uint8_t *data, uint32_t data_length);
+void ECU_CAN_MessageHandler(ECU_StateData *state_data, GRCAN_BUS_ID bus_id, GRCAN_MSG_ID msg_id, GRCAN_NODE_ID sender_id, uint8_t *data, uint32_t data_length);
 
 #endif

ECU/Application/Inc/CANutils.h

@@ -1,15 +1,15 @@
 #include <stdint.h>
 
-#include "GR_OLD_BUS_ID.h"
-#include "GR_OLD_MSG_ID.h"
-#include "GR_OLD_NODE_ID.h"
+#include "GRCAN_BUS_ID.h"
+#include "GRCAN_MSG_ID.h"
+#include "GRCAN_NODE_ID.h"
 #include "StateData.h"
 
 #ifndef CANUTILS_H
 #define CANUTILS_H
 
 #define ECU_STATE_DATA_SEND_INTERVAL_MS 20
-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 ECU_CAN_Send(GRCAN_BUS_ID bus, GRCAN_NODE_ID destNode, GRCAN_MSG_ID messageID, void *data, uint32_t size);
 void SendECUStateDataOverCAN(ECU_StateData *stateData);
 
 #endif

ECU/Application/Inc/StateData.h

@@ -1,7 +1,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-#include "GR_OLD_MSG_DAT.h"
+#include "GRCAN_MSG_DATA.h"
 #include "StateMachine.h"
 
 #ifndef _STATEDATA_H_
@@ -79,10 +79,13 @@ typedef volatile struct ECU_StateData {
 	float estop_sense;
 	float driving_heat_capacity_1;
 	float driving_heat_capacity_2;
+	uint16_t bse_signal;
+	uint16_t bspd_signal;
 	uint16_t APPS1_Signal;
 	uint16_t APPS2_Signal;
 	uint16_t Brake_R_Signal;
 	uint16_t Brake_F_Signal;
+	uint16_t aux_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) */

ECU/Application/Src/CANdler.c

@@ -2,9 +2,9 @@
 
 #include <stdint.h>
 
-#include "GR_OLD_BUS_ID.h"
-#include "GR_OLD_MSG_ID.h"
-#include "GR_OLD_NODE_ID.h"
+#include "GRCAN_BUS_ID.h"
+#include "GRCAN_MSG_ID.h"
+#include "GRCAN_NODE_ID.h"
 #include "Logomatic.h"
 #include "Pinging.h"
 #include "StateData.h"
@@ -14,105 +14,109 @@
 
 extern ECU_StateData stateLump;
 
-void ReportBadMessageLength(GR_OLD_BUS_ID bus_id, GR_OLD_MSG_ID msg_id, GR_OLD_NODE_ID sender_id)
+void ReportBadMessageLength(GRCAN_BUS_ID bus_id, GRCAN_MSG_ID msg_id, GRCAN_NODE_ID sender_id)
 {
 	// TODO Ideally change some state data to note a bad message, ie if BCU
 	// that can be a comms error
 	LOGOMATIC("Bad ECU CAN Rx length! Bus: %d, Msg: %X, Sender: %X\n", bus_id, msg_id, sender_id);
 }
 
-void ReportUnhandledMessage(GR_OLD_BUS_ID bus_id, GR_OLD_MSG_ID msg_id, GR_OLD_NODE_ID sender_id)
+void ReportUnhandledMessage(GRCAN_BUS_ID bus_id, GRCAN_MSG_ID msg_id, GRCAN_NODE_ID sender_id)
 {
 	// Filtering likely needs to be adjusted if this is happening often
 	LOGOMATIC("Unhandled ECU CAN Rx msg! Bus: %d, Msg: %X, Sender: %X\n", bus_id, msg_id, sender_id);
 }
 
-void ECU_CAN_MessageHandler(ECU_StateData *state_data, GR_OLD_BUS_ID bus_id, GR_OLD_MSG_ID msg_id, GR_OLD_NODE_ID sender_id, uint8_t *data, uint32_t data_length)
+void ECU_CAN_MessageHandler(ECU_StateData *state_data, GRCAN_BUS_ID bus_id, GRCAN_MSG_ID msg_id, GRCAN_NODE_ID sender_id, uint8_t *data, uint32_t data_length)
 {
 	switch (msg_id) {
 		case MSG_DEBUG_2_0:
-			if (data_length > sizeof(GR_OLD_DEBUG_2_MSG)) {
+			if (data_length > sizeof(GRCAN_DEBUG_2_0_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_DEBUG_FD:
-			if (data_length > sizeof(GR_OLD_DEBUG_2_MSG)) {
+			if (data_length > sizeof(GRCAN_DEBUG_FD_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)) {
+			if (data_length != sizeof(GRCAN_PING_MSG)) {
 				ReportBadMessageLength(bus_id, msg_id, sender_id);
 				break;
 			}
-			respondToPing(sender_id, ((GR_OLD_PING_MSG *)data)->timestamp);
+			respondToPing(sender_id, ((GRCAN_PING_MSG *)data)->timestamp);
 			break;
 
 		case MSG_BCU_STATUS_1:
-			if (data_length != sizeof(GR_OLD_BCU_STATUS_1_MSG)) {
+			if (data_length != sizeof(GRCAN_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->tractivebattery_soc = bcu_status_1->tractivebattery_soc;
+			GRCAN_BCU_STATUS_1_MSG *bcu_status_1 = (GRCAN_BCU_STATUS_1_MSG *)data;
+			state_data->tractivebattery_soc = bcu_status_1->accumulator_soc;
 			state_data->glv_soc = bcu_status_1->glv_soc;
 			state_data->ts_voltage = bcu_status_1->ts_voltage * 0.01;
 			break;
 
 		case MSG_BCU_STATUS_2:
-			if (data_length != sizeof(GR_OLD_BCU_STATUS_2_MSG)) {
+			if (data_length != sizeof(GRCAN_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;
+			GRCAN_BCU_STATUS_2_MSG *bcu_status_2 = (GRCAN_BCU_STATUS_2_MSG *)data;
 			state_data->max_cell_temp_c = 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);
+			state_data->bcu_error_warning_bits = bcu_status_2->status_flags;
+			state_data->ir_minus = GETBIT(bcu_status_2->precharge_latch_flags, 1);
+			state_data->ir_plus = GETBIT(bcu_status_2->precharge_latch_flags, 2);
+			state_data->bcu_software_latch = GETBIT(bcu_status_2->precharge_latch_flags, 3);
 			break;
 
 		case MSG_INVERTER_STATUS_1:
-			if (data_length != sizeof(GR_OLD_INVERTER_STATUS_1_MSG)) {
+			if (data_length != sizeof(GRCAN_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;
+			GRCAN_INVERTER_STATUS_1_MSG *inverter_status_1 = (GRCAN_INVERTER_STATUS_1_MSG *)data;
 			UNUSED(inverter_status_1);
 			break;
 		case MSG_INVERTER_STATUS_3:
-			if (data_length != sizeof(GR_OLD_INVERTER_STATUS_3_MSG)) {
+			if (data_length != sizeof(GRCAN_INVERTER_STATUS_3_MSG)) {
 				ReportBadMessageLength(bus_id, msg_id, sender_id);
 				break;
 			}
-			GR_OLD_INVERTER_STATUS_3_MSG *inverter_status_3 = (GR_OLD_INVERTER_STATUS_3_MSG *)data;
+			GRCAN_INVERTER_STATUS_3_MSG *inverter_status_3 = (GRCAN_INVERTER_STATUS_3_MSG *)data;
 			state_data->inverter_fault_map = inverter_status_3->fault_bits;
 			break;
 		/*
 		case MSG_STEERING_STATUS:
-			if (data_length != sizeof(GR_OLD_STEERING_STATUS_MSG)) {
+			if (data_length != sizeof(GRCAN_STEERING_STATUS_MSG)) {
 				ReportBadMessageLength(bus_id, msg_id, sender_id);
 				break;
 			}
-			GR_OLD_STEERING_STATUS_MSG *steering_status = (GR_OLD_STEERING_STATUS_MSG *)data;
+			GRCAN_STEERING_STATUS_MSG *steering_status = (GRCAN_STEERING_STATUS_MSG *)data;
 			state_data->powerlevel_torquemap = steering_status->encoder_bits;
 			break;
 		*/
+
+		// TODO: fix when sensors done
+		/*
 		case MSG_SAM_REAR_WHEELSPEED:
-			if (data_length != sizeof(GR_OLD_SAM_REAR_WHEELSPEED_MSG)) {
+			if (data_length != sizeof(GRCAN_SAM_REAR_WHEELSPEED_MSG)) {
 				ReportBadMessageLength(bus_id, msg_id, sender_id);
 				break;
 			}
-			GR_OLD_SAM_REAR_WHEELSPEED_MSG *encoder_status = (GR_OLD_SAM_REAR_WHEELSPEED_MSG *)data;
+			GRCAN_SAM_REAR_WHEELSPEED_MSG *encoder_status = (GRCAN_SAM_REAR_WHEELSPEED_MSG *)data;
 			state_data->rr_wheel_rpm = encoder_status->wheel_speed * 0.1 - 32768; // TODO: find out which wheel this actually measures: one or 4 sensors?
 			state_data->vehicle_speed_mph = state_data->rr_wheel_rpm * WHEEL_RPM_TO_MPH_RATIO;
 			break;
+		*/
 		default:
 			ReportUnhandledMessage(bus_id, msg_id, sender_id);
 			break;

ECU/Application/Src/CANutils.c

@@ -1,8 +1,8 @@
 #include "CANutils.h"
 
-#include "GR_OLD_BUS_ID.h"
-#include "GR_OLD_MSG_DAT.h"
-#include "GR_OLD_MSG_ID.h"
+#include "GRCAN_BUS_ID.h"
+#include "GRCAN_MSG_ID.h"
+#include "GRCAN_NODE_ID.h"
 #include "Logomatic.h"
 #include "StateData.h"
 #include "StateTicks.h"
@@ -13,7 +13,7 @@
 
 uint32_t lastTickECUStateDataSent = 0;
 
-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 ECU_CAN_Send(GRCAN_BUS_ID bus, GRCAN_NODE_ID destNode, GRCAN_MSG_ID messageID, void *data, uint32_t size)
 {
 	if (size > FDCAN_MAX_DATA_BYTES) {
 		size = FDCAN_MAX_DATA_BYTES;
@@ -39,10 +39,10 @@ void ECU_CAN_Send(GR_OLD_BUS_ID bus, GR_OLD_NODE_ID destNode, GR_OLD_MSG_ID mess
 	memcpy(&(msg.data), data, size);
 
 	switch (bus) {
-		case GR_OLD_BUS_PRIMARY:
+		case GRCAN_BUS_PRIMARY:
 			can_send(primary_can, &msg);
 			break;
-		case GR_OLD_BUS_DATA:
+		case GRCAN_BUS_DATA:
 			can_send(data_can, &msg);
 			break;
 		default:
@@ -112,7 +112,7 @@ void SendECUStateDataOverCAN(ECU_StateData *stateData)
 
 	LOGOMATIC("Sending ECU State Data over CAN");
 
-	ECU_CAN_Send(GR_OLD_BUS_PRIMARY, GR_ALL, MSG_ECU_STATUS_1, (void *)&messages.ECUStatusMsgOne, sizeof(messages.ECUStatusMsgOne));
-	ECU_CAN_Send(GR_OLD_BUS_PRIMARY, GR_ALL, MSG_ECU_STATUS_2, (void *)&messages.ECUStatusMsgTwo, sizeof(messages.ECUStatusMsgTwo));
-	ECU_CAN_Send(GR_OLD_BUS_PRIMARY, GR_ALL, MSG_ECU_STATUS_3, (void *)&messages.ECUStatusMsgThree, sizeof(messages.ECUStatusMsgThree));
+	ECU_CAN_Send(GRCAN_BUS_PRIMARY, ALL, MSG_ECU_STATUS_1, (void *)&messages.ECUStatusMsgOne, sizeof(messages.ECUStatusMsgOne));
+	ECU_CAN_Send(GRCAN_BUS_PRIMARY, ALL, MSG_ECU_STATUS_2, (void *)&messages.ECUStatusMsgTwo, sizeof(messages.ECUStatusMsgTwo));
+	ECU_CAN_Send(GRCAN_BUS_PRIMARY, ALL, MSG_ECU_STATUS_3, (void *)&messages.ECUStatusMsgThree, sizeof(messages.ECUStatusMsgThree));
 }

ECU/Application/Src/Lights.c

@@ -74,26 +74,26 @@ void BMSLights(ECU_StateData *stateLump)
 	light |= stateLump->ts_voltage > CRITICAL_TS_VOLTAGE;
 	light |= bmsFailure(stateLump);
 	// TODO: interrupted/missing BMS vals
-	GR_OLD_DASH_CONFIG_MSG message = {.led_bits = light};
-	ECU_CAN_Send(GR_OLD_BUS_PRIMARY, GR_DASH_PANEL, MSG_DASH_CONFIG, &message, sizeof(message));
+	GRCAN_DASH_CONFIG_MSG message = {.led_bits = light};
+	ECU_CAN_Send(GRCAN_BUS_PRIMARY, Dash_Panel, MSG_DASH_CONFIG, &message, sizeof(message));
 }
 
 void IMDLights(ECU_StateData *stateLump)
 {
 	uint8_t light = 0;
 	// TODO: isolation failure?
 	light |= imdFailure(stateLump);
-	GR_OLD_DASH_CONFIG_MSG message = {.led_bits = (light << 1)};
-	ECU_CAN_Send(GR_OLD_BUS_PRIMARY, GR_DASH_PANEL, MSG_DASH_CONFIG, &message, sizeof(message));
+	GRCAN_DASH_CONFIG_MSG message = {.led_bits = (light << 1)};
+	ECU_CAN_Send(GRCAN_BUS_PRIMARY, Dash_Panel, MSG_DASH_CONFIG, &message, sizeof(message));
 }
 
 void BSPDLights(ECU_StateData *stateLump)
 {
 	uint8_t light = 0;
 	// TODO: isolation failure?
 	light |= bspdFailure(stateLump);
-	GR_OLD_DASH_CONFIG_MSG message = {.led_bits = (light << 2)};
-	ECU_CAN_Send(GR_OLD_BUS_PRIMARY, GR_DASH_PANEL, MSG_DASH_CONFIG, &message, sizeof(message));
+	GRCAN_DASH_CONFIG_MSG message = {.led_bits = (light << 2)};
+	ECU_CAN_Send(GRCAN_BUS_PRIMARY, Dash_Panel, MSG_DASH_CONFIG, &message, sizeof(message));
 }
 
 void lightControl(ECU_StateData *stateData)

ECU/Application/Src/Pinging.c

@@ -1,16 +1,15 @@
 #include "Pinging.h"
 
 #include "CANutils.h"
-#include "GR_OLD_MSG_DAT.h"
-#include "GR_OLD_MSG_ID.h"
-#include "GR_OLD_NODE_ID.h"
+#include "GRCAN_BUS_ID.h"
+#include "GRCAN_MSG_ID.h"
+#include "GRCAN_NODE_ID.h"
 #include "StateUtils.h"
 
 // add new pingable devices here, arrays are updated automagically
 #define PING_LIST(OP)                                                                                                                                                                                  \
-	OP(GR_BCU, 0)                                                                                                                                                                                  \
-	OP(GR_DASH_PANEL, 1)                                                                                                                                                                           \
-	OP(GR_CCU, 2)
+	OP(BCU, 0)                                                                                                                                                                                     \
+	OP(Dash_Panel, 1)
 
 // Converts PING_LIST into a list of the first column (IDs)
 #define PING_LIST_AS_ID(id, index) id,
@@ -42,7 +41,7 @@ void pingAll(void)
 		}
 
 		sentTimestamps[i] = timestamp;
-		ECU_CAN_Send(GR_OLD_BUS_PRIMARY, IDsToBePinged[i], MSG_PING, &(GR_OLD_PING_MSG){timestamp}, sizeof(GR_OLD_PING_MSG));
+		ECU_CAN_Send(GRCAN_BUS_PRIMARY, IDsToBePinged[i], MSG_PING, &(GRCAN_PING_MSG){timestamp}, sizeof(GRCAN_PING_MSG));
 	}
 }