RMS info

Author: ZacharyBer

DASH/Core/User/Src/FEB_CAN_PCU.c

@@ -65,11 +65,13 @@ static void rx_callback_torque(FEB_CAN_Instance_t instance, uint32_t can_id, FEB
 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));
-  brake_state.brake_position = position;
-  __DMB();
-  brake_state.last_rx_tick = HAL_GetTick();
+  struct feb_can_brake_t msg;
+  if (feb_can_brake_unpack(&msg, data, length) == 0)
+  {
+    brake_state.brake_position = msg.brake_position; /* centi-percent; endianness handled by codegen */
+    __DMB();
+    brake_state.last_rx_tick = HAL_GetTick();
+  }
 }
 
 /* ============================================================================

DASH/VERSION

@@ -1 +1 @@
-1.7.1
+1.7.2

LVPDB/Core/User/Inc/FEB_CAN_BRAKE.h

@@ -14,7 +14,7 @@
 
 typedef struct
 {
-  volatile uint8_t brake_percent;
+  volatile uint16_t brake_position; /* centi-percent (0-10000) */
   volatile uint32_t last_rx_tick;
 } BRAKE_State_t;
 

LVPDB/Core/User/Src/FEB_CAN_BRAKE.c

@@ -24,7 +24,7 @@ static void rx_callback(FEB_CAN_Instance_t instance, uint32_t can_id, FEB_CAN_ID
   struct feb_can_brake_t msg;
   if (feb_can_brake_unpack(&msg, data, length) == 0)
   {
-    brake_state.brake_percent = msg.brake_percent;
+    brake_state.brake_position = msg.brake_position;
 
     __DMB();
     brake_state.last_rx_tick = HAL_GetTick();
@@ -52,7 +52,8 @@ void FEB_CAN_BRAKE_Init(void)
 
 uint8_t FEB_CAN_BRAKE_GetPercent(void)
 {
-  return brake_state.brake_percent;
+  /* brake_position is centi-percent (0-10000); return whole percent (0-100). */
+  return (uint8_t)(brake_state.brake_position / 100u);
 }
 
 bool FEB_CAN_BRAKE_IsDataFresh(uint32_t timeout_ms)

LVPDB/VERSION

@@ -1 +1 @@
-1.7.3
+1.7.4

PCU/Core/User/Inc/FEB_CAN_RMS.h

@@ -5,11 +5,18 @@
 
 #include "feb_can_lib.h"
 #include "feb_can.h"
+#include <stdbool.h>
 #include <string.h>
 
-/* RMS Motor Controller CAN IDs — resolved from generated feb_can.h */
-#define FEB_CAN_ID_RMS_VOLTAGE FEB_CAN_M160_TEMPERATURE_SET_1_FRAME_ID
+/* RMS Motor Controller CAN IDs — resolved from generated feb_can.h.
+ * VOLTAGE is the real DC bus voltage broadcast (M167 / 0x0A7); STATES is the
+ * inverter Internal States (M170 / 0x0AA, has VSM state + enable lockout) and
+ * FAULTS is the POST/Run fault codes (M171 / 0x0AB). Subscribing to STATES and
+ * FAULTS lets PCU|rms report *why* the inverter refuses to enable. */
+#define FEB_CAN_ID_RMS_VOLTAGE FEB_CAN_M167_VOLTAGE_INFO_FRAME_ID
 #define FEB_CAN_ID_RMS_MOTOR FEB_CAN_M165_MOTOR_POSITION_INFO_FRAME_ID
+#define FEB_CAN_ID_RMS_STATES FEB_CAN_M170_INTERNAL_STATES_FRAME_ID
+#define FEB_CAN_ID_RMS_FAULTS FEB_CAN_M171_FAULT_CODES_FRAME_ID
 
 #define FAULT_CLEAR_ADDR_UNDERVOLT 140
 #define FAULT_CLEAR_ADDR_PARAM_SAFETY 20
@@ -21,13 +28,29 @@ extern uint8_t PARAM_BROADCAST_DATA[2];
 
 typedef struct RMS_MESSAGE_TYPE
 {
-  volatile int16_t HV_Bus_Voltage;     // Updated in ISR, read in main loop (raw)
+  volatile int16_t HV_Bus_Voltage;     // M167 DC bus voltage, raw (tenths of V)
   volatile int16_t Motor_Speed;        // Updated in ISR, read in main loop (RPM)
   volatile int16_t Motor_Angle;        // Updated in ISR, read in main loop
   volatile int16_t Torque_Command;     // Commanded torque (tenths of Nm)
   volatile int16_t Torque_Feedback;    // Feedback torque (tenths of Nm)
-  volatile float DC_Bus_Voltage_V;     // DC bus voltage in Volts
+  volatile float DC_Bus_Voltage_V;     // DC bus voltage in Volts (from M167)
   volatile uint32_t last_rx_timestamp; // 0 = never received, else HAL_GetTick() when last RX
+
+  /* Inverter Internal States (M170 / 0x0AA) — written in ISR, read in main loop */
+  volatile uint8_t vsm_state;            // INV_VSM_State (0..15)
+  volatile uint8_t inverter_state;       // INV_Inverter_State (0..255)
+  volatile uint8_t enable_state;         // 0 = disabled, 1 = enabled
+  volatile uint8_t enable_lockout;       // 1 = inverter enable lockout active
+  volatile uint8_t command_mode;         // 0 = CAN mode, 1 = VSM mode
+  volatile uint8_t echo_rolling_counter; // inverter-echoed rolling counter (0..15)
+  volatile uint32_t states_rx_timestamp; // 0 = never received an M170 frame
+
+  /* Fault codes (M171 / 0x0AB) — each word is a fault bitfield (see PM100 manual) */
+  volatile uint16_t post_fault_lo;
+  volatile uint16_t post_fault_hi;
+  volatile uint16_t run_fault_lo;
+  volatile uint16_t run_fault_hi;
+  volatile uint32_t faults_rx_timestamp; // 0 = never received an M171 frame
 } RMS_MESSAGE_TYPE;
 
 // Global variable - defined in FEB_CAN_RMS.c
@@ -50,4 +73,21 @@ int16_t FEB_CAN_RMS_getMotorAngle(void);
 float FEB_CAN_RMS_getTorqueCommand(void);
 float FEB_CAN_RMS_getTorqueFeedback(void);
 
+// Inverter Internal States (M170) accessors
+bool FEB_CAN_RMS_StatesSeen(void);     // true once an M170 frame has been received
+uint8_t FEB_CAN_RMS_getVsmState(void); // INV_VSM_State (0..15)
+uint8_t FEB_CAN_RMS_getInverterState(void);
+bool FEB_CAN_RMS_getEnableState(void);    // inverter-reported enable state
+bool FEB_CAN_RMS_getEnableLockout(void);  // true = inverter enable lockout active
+bool FEB_CAN_RMS_getCommandModeVsm(void); // true = VSM mode, false = CAN mode
+uint8_t FEB_CAN_RMS_getEchoRollingCounter(void);
+
+// Fault codes (M171) accessors
+bool FEB_CAN_RMS_FaultsSeen(void);     // true once an M171 frame has been received
+bool FEB_CAN_RMS_HasActiveFault(void); // true if any POST/Run fault word is nonzero
+uint16_t FEB_CAN_RMS_getPostFaultLo(void);
+uint16_t FEB_CAN_RMS_getPostFaultHi(void);
+uint16_t FEB_CAN_RMS_getRunFaultLo(void);
+uint16_t FEB_CAN_RMS_getRunFaultHi(void);
+
 #endif /* INC_FEB_CAN_RMS_H_ */

PCU/Core/User/Src/FEB_CAN_Diagnostics.c

@@ -5,32 +5,25 @@ Brake_DataTypeDef Brake_Data;
 
 void FEB_CAN_Diagnostics_TransmitBrakeData(void)
 {
-  uint8_t data[8] = {0};
-
   // Get latest brake data
   FEB_ADC_GetBrakeData(&Brake_Data);
 
-  // Pack brake position (0-100%) into first two bytes (0-10000 centi-percent)
-  uint16_t brake_position_centi_percent = (uint16_t)(Brake_Data.brake_position * 100.0f);
-  data[0] = (brake_position_centi_percent >> 8) & 0xFF;
-  data[1] = brake_position_centi_percent & 0xFF;
-
-  // Pack brake pressure sensors (0-100%) into next four bytes (0-10000 centi-percent)
-  uint16_t pressure1_centi_percent = (uint16_t)(Brake_Data.pressure1_percent * 100.0f);
-  uint16_t pressure2_centi_percent = (uint16_t)(Brake_Data.pressure2_percent * 100.0f);
-  data[2] = (pressure1_centi_percent >> 8) & 0xFF;
-  data[3] = pressure1_centi_percent & 0xFF;
-  data[4] = (pressure2_centi_percent >> 8) & 0xFF;
-  data[5] = pressure2_centi_percent & 0xFF;
-
-  // Pack status flags into last two bytes
-  data[6] = (Brake_Data.plausible ? 0x01 : 0x00) |     // Bit 0
-            (Brake_Data.brake_pressed ? 0x02 : 0x00) | // Bit 1
-            (Brake_Data.bots_active ? 0x04 : 0x00);    // Bit 2
-  data[7] = Brake_Data.brake_switch ? 0x02 : 0x01;
-
-  // Transmit CAN message
-  FEB_CAN_Status_t status = FEB_CAN_TX_Send(FEB_CAN_INSTANCE_1, FEB_CAN_BRAKE_FRAME_ID, FEB_CAN_ID_STD, data, 8);
+  // Position + per-sensor pressure are sent as centi-percent (0-10000); status
+  // flags ride in bytes 6-7. Layout/endianness are owned by the generated brake
+  // definition (common/FEB_CAN_Library_SN4) — pack through it, don't hand-roll.
+  struct feb_can_brake_t msg = {0};
+  msg.brake_position = (uint16_t)(Brake_Data.brake_position * 100.0f);
+  msg.brake1_pct = (uint16_t)(Brake_Data.pressure1_percent * 100.0f);
+  msg.brake2_pct = (uint16_t)(Brake_Data.pressure2_percent * 100.0f);
+  msg.plausible = Brake_Data.plausible ? 1u : 0u;
+  msg.brake_pressed = Brake_Data.brake_pressed ? 1u : 0u;
+  msg.bots_active = Brake_Data.bots_active ? 1u : 0u;
+  msg.brake_switch = Brake_Data.brake_switch ? 1u : 0u;
+
+  uint8_t data[FEB_CAN_BRAKE_LENGTH];
+  int packed = feb_can_brake_pack(data, &msg, sizeof(data));
+  FEB_CAN_Status_t status =
+      FEB_CAN_TX_Send(FEB_CAN_INSTANCE_1, FEB_CAN_BRAKE_FRAME_ID, FEB_CAN_ID_STD, data, (uint8_t)packed);
   if (status != FEB_CAN_OK)
   {
     LOG_E(TAG_CAN, "Failed to transmit brake data: %s", FEB_CAN_StatusToString(status));

PCU/Core/User/Src/FEB_CAN_RMS.c

@@ -44,6 +44,74 @@ float FEB_CAN_RMS_getTorqueFeedback(void)
   return RMS_MESSAGE.Torque_Feedback / 10.0f;
 }
 
+/* Inverter Internal States (M170) accessors */
+bool FEB_CAN_RMS_StatesSeen(void)
+{
+  return RMS_MESSAGE.states_rx_timestamp != 0;
+}
+
+uint8_t FEB_CAN_RMS_getVsmState(void)
+{
+  return RMS_MESSAGE.vsm_state;
+}
+
+uint8_t FEB_CAN_RMS_getInverterState(void)
+{
+  return RMS_MESSAGE.inverter_state;
+}
+
+bool FEB_CAN_RMS_getEnableState(void)
+{
+  return RMS_MESSAGE.enable_state != 0;
+}
+
+bool FEB_CAN_RMS_getEnableLockout(void)
+{
+  return RMS_MESSAGE.enable_lockout != 0;
+}
+
+bool FEB_CAN_RMS_getCommandModeVsm(void)
+{
+  return RMS_MESSAGE.command_mode != 0;
+}
+
+uint8_t FEB_CAN_RMS_getEchoRollingCounter(void)
+{
+  return RMS_MESSAGE.echo_rolling_counter;
+}
+
+/* Fault codes (M171) accessors */
+bool FEB_CAN_RMS_FaultsSeen(void)
+{
+  return RMS_MESSAGE.faults_rx_timestamp != 0;
+}
+
+bool FEB_CAN_RMS_HasActiveFault(void)
+{
+  return (RMS_MESSAGE.post_fault_lo | RMS_MESSAGE.post_fault_hi | RMS_MESSAGE.run_fault_lo |
+          RMS_MESSAGE.run_fault_hi) != 0;
+}
+
+uint16_t FEB_CAN_RMS_getPostFaultLo(void)
+{
+  return RMS_MESSAGE.post_fault_lo;
+}
+
+uint16_t FEB_CAN_RMS_getPostFaultHi(void)
+{
+  return RMS_MESSAGE.post_fault_hi;
+}
+
+uint16_t FEB_CAN_RMS_getRunFaultLo(void)
+{
+  return RMS_MESSAGE.run_fault_lo;
+}
+
+uint16_t FEB_CAN_RMS_getRunFaultHi(void)
+{
+  return RMS_MESSAGE.run_fault_hi;
+}
+
 void FEB_CAN_RMS_Init(void)
 {
   LOG_I(TAG_CAN, "Initializing RMS CAN communication");
@@ -64,8 +132,15 @@ void FEB_CAN_RMS_Init(void)
   params.can_id = FEB_CAN_ID_RMS_MOTOR;
   FEB_CAN_RX_Register(&params);
 
-  LOG_I(TAG_CAN, "Registered RMS CAN callbacks (Voltage: 0x%03X, Motor: 0x%03X)", (unsigned)FEB_CAN_ID_RMS_VOLTAGE,
-        (unsigned)FEB_CAN_ID_RMS_MOTOR);
+  params.can_id = FEB_CAN_ID_RMS_STATES;
+  FEB_CAN_RX_Register(&params);
+
+  params.can_id = FEB_CAN_ID_RMS_FAULTS;
+  FEB_CAN_RX_Register(&params);
+
+  LOG_I(TAG_CAN, "Registered RMS CAN callbacks (Voltage: 0x%03X, Motor: 0x%03X, States: 0x%03X, Faults: 0x%03X)",
+        (unsigned)FEB_CAN_ID_RMS_VOLTAGE, (unsigned)FEB_CAN_ID_RMS_MOTOR, (unsigned)FEB_CAN_ID_RMS_STATES,
+        (unsigned)FEB_CAN_ID_RMS_FAULTS);
 
   RMS_MESSAGE.HV_Bus_Voltage = 0;
   RMS_MESSAGE.Motor_Speed = 0;
@@ -74,6 +149,18 @@ void FEB_CAN_RMS_Init(void)
   RMS_MESSAGE.Torque_Feedback = 0;
   RMS_MESSAGE.DC_Bus_Voltage_V = 0.0f;
   RMS_MESSAGE.last_rx_timestamp = 0;
+  RMS_MESSAGE.vsm_state = 0;
+  RMS_MESSAGE.inverter_state = 0;
+  RMS_MESSAGE.enable_state = 0;
+  RMS_MESSAGE.enable_lockout = 0;
+  RMS_MESSAGE.command_mode = 0;
+  RMS_MESSAGE.echo_rolling_counter = 0;
+  RMS_MESSAGE.states_rx_timestamp = 0;
+  RMS_MESSAGE.post_fault_lo = 0;
+  RMS_MESSAGE.post_fault_hi = 0;
+  RMS_MESSAGE.run_fault_lo = 0;
+  RMS_MESSAGE.run_fault_hi = 0;
+  RMS_MESSAGE.faults_rx_timestamp = 0;
 
   LOG_I(TAG_CAN, "Sending RMS parameter safety commands");
   for (int i = 0; i < 10; i++)
@@ -127,17 +214,42 @@ static void FEB_CAN_RMS_Callback(FEB_CAN_Instance_t instance, uint32_t can_id, F
 
   if (can_id == FEB_CAN_ID_RMS_VOLTAGE)
   {
-    struct feb_can_m160_temperature_set_1_t m160;
-    feb_can_m160_temperature_set_1_unpack(&m160, data, length);
-    RMS_MESSAGE.HV_Bus_Voltage = m160.inv_module_a;
-    RMS_MESSAGE.DC_Bus_Voltage_V = (m160.inv_module_a - 50.0f) / 10.0f;
+    /* M167 Voltage Info: INV_DC_Bus_Voltage is signed, scale 0.1 V, no offset. */
+    struct feb_can_m167_voltage_info_t m167;
+    feb_can_m167_voltage_info_unpack(&m167, data, length);
+    RMS_MESSAGE.HV_Bus_Voltage = m167.inv_dc_bus_voltage;
+    RMS_MESSAGE.DC_Bus_Voltage_V = m167.inv_dc_bus_voltage / 10.0f;
   }
   else if (can_id == FEB_CAN_ID_RMS_MOTOR)
   {
     struct feb_can_m165_motor_position_info_t m165;
     feb_can_m165_motor_position_info_unpack(&m165, data, length);
     RMS_MESSAGE.Motor_Speed = m165.inv_motor_speed;
   }
+  else if (can_id == FEB_CAN_ID_RMS_STATES)
+  {
+    /* M170 Internal States: the "why won't it enable" frame. */
+    struct feb_can_m170_internal_states_t m170;
+    feb_can_m170_internal_states_unpack(&m170, data, length);
+    RMS_MESSAGE.vsm_state = m170.inv_vsm_state;
+    RMS_MESSAGE.inverter_state = m170.inv_inverter_state;
+    RMS_MESSAGE.enable_state = m170.inv_inverter_enable_state;
+    RMS_MESSAGE.enable_lockout = m170.inv_inverter_enable_lockout;
+    RMS_MESSAGE.command_mode = m170.inv_inverter_command_mode;
+    RMS_MESSAGE.echo_rolling_counter = m170.inv_rolling_counter;
+    RMS_MESSAGE.states_rx_timestamp = RMS_MESSAGE.last_rx_timestamp;
+  }
+  else if (can_id == FEB_CAN_ID_RMS_FAULTS)
+  {
+    /* M171 Fault Codes: POST/Run fault bitfields (see PM100 manual). */
+    struct feb_can_m171_fault_codes_t m171;
+    feb_can_m171_fault_codes_unpack(&m171, data, length);
+    RMS_MESSAGE.post_fault_lo = m171.inv_post_fault_lo;
+    RMS_MESSAGE.post_fault_hi = m171.inv_post_fault_hi;
+    RMS_MESSAGE.run_fault_lo = m171.inv_run_fault_lo;
+    RMS_MESSAGE.run_fault_hi = m171.inv_run_fault_hi;
+    RMS_MESSAGE.faults_rx_timestamp = RMS_MESSAGE.last_rx_timestamp;
+  }
 }
 
 /**
@@ -168,10 +280,17 @@ void FEB_CAN_RMS_Transmit_UpdateTorque(int16_t torque, uint8_t enabled)
 
   RMS_MESSAGE.Torque_Command = torque;
 
+  /* The RMS' CAN message-validity check requires a rolling counter that changes
+   * every command frame; a counter stuck at 0 makes it reject every frame as
+   * stale and refuse to enable. Increment 0..15 (field range) on every TX. */
+  static uint8_t rolling_counter = 0;
+
   struct feb_can_m192_command_message_t msg = {0};
   msg.vcu_inv_torque_command = torque;
   msg.vcu_inv_direction_command = 1u;
   msg.vcu_inv_inverter_enable = enabled;
+  msg.vcu_inv_rolling_counter = rolling_counter;
+  rolling_counter = (uint8_t)((rolling_counter + 1u) & 0x0Fu);
 
   uint8_t data[FEB_CAN_M192_COMMAND_MESSAGE_LENGTH];
   int packed = feb_can_m192_command_message_pack(data, &msg, sizeof(data));