heartbeat on dash lvpdb pcu

Author: asymptonic

.vscode/settings.json

@@ -34,7 +34,7 @@
         "-DCMAKE_COMMAND=cube-cmake"
     ],
     "[c]": {
-        "editor.defaultFormatter": "ms-vscode.cpptools",
+        "editor.defaultFormatter": "llvm-vs-code-extensions.vscode-clangd",
         "editor.formatOnSave": true
     },
     "[cpp]": {

BMS/VERSION

@@ -1 +1 @@
-1.5.5
+1.5.6

DART/VERSION

@@ -1 +1 @@
-1.5.3
+1.5.4

DASH/Core/Src/freertos.c

@@ -53,19 +53,19 @@
 /* DASHTaskRx / DASHTaskTx stacks: set in CubeMX (DASH.ioc, FREERTOS.Tasks01). Regenerating
  * from the .ioc overwrites osThreadAttr_t blocks above; keep those tasks at 1024 words. */
 /* USER CODE END Variables */
-/* Definitions for btnTxLoopTask */
-osThreadId_t btnTxLoopTaskHandle;
-const osThreadAttr_t btnTxLoopTask_attributes = {
-  .name = "btnTxLoopTask",
-  .stack_size = 1024 * 4,
+/* Definitions for ioLoopTask */
+osThreadId_t ioLoopTaskHandle;
+const osThreadAttr_t ioLoopTask_attributes = {
+  .name = "ioLoopTask",
+  .stack_size = 512 * 4,
   .priority = (osPriority_t) osPriorityHigh1,
 };
 /* Definitions for displayTask */
 osThreadId_t displayTaskHandle;
 const osThreadAttr_t displayTask_attributes = {
   .name = "displayTask",
   .stack_size = 1024 * 4,
-  .priority = (osPriority_t) osPriorityHigh,
+  .priority = (osPriority_t) osPriorityAboveNormal,
 };
 /* Definitions for uartRxTask */
 osThreadId_t uartRxTaskHandle;
@@ -86,14 +86,14 @@ osThreadId_t DASHTaskRxHandle;
 const osThreadAttr_t DASHTaskRx_attributes = {
   .name = "DASHTaskRx",
   .stack_size = 1024 * 4,
-  .priority = (osPriority_t) osPriorityLow,
+  .priority = (osPriority_t) osPriorityHigh2,
 };
 /* Definitions for DASHTaskTx */
 osThreadId_t DASHTaskTxHandle;
 const osThreadAttr_t DASHTaskTx_attributes = {
   .name = "DASHTaskTx",
   .stack_size = 1024 * 4,
-  .priority = (osPriority_t) osPriorityLow,
+  .priority = (osPriority_t) osPriorityHigh3,
 };
 /* Definitions for canTxQueue */
 osMessageQueueId_t canTxQueueHandle;
@@ -151,7 +151,7 @@ const osSemaphoreAttr_t uartTxSem_attributes = {
 
 /* USER CODE END FunctionPrototypes */
 
-void StartBtnTxLoop(void *argument);
+void StartIoLoop(void *argument);
 void StartDisplayTask(void *argument);
 void StartUartRxTask(void *argument);
 void StartUartTxTask(void *argument);
@@ -285,8 +285,8 @@ void MX_FREERTOS_Init(void) {
   /* USER CODE END RTOS_QUEUES */
 
   /* Create the thread(s) */
-  /* creation of btnTxLoopTask */
-  btnTxLoopTaskHandle = osThreadNew(StartBtnTxLoop, NULL, &btnTxLoopTask_attributes);
+  /* creation of ioLoopTask */
+  ioLoopTaskHandle = osThreadNew(StartIoLoop, NULL, &ioLoopTask_attributes);
 
   /* creation of displayTask */
   displayTaskHandle = osThreadNew(StartDisplayTask, NULL, &displayTask_attributes);
@@ -305,7 +305,7 @@ void MX_FREERTOS_Init(void) {
 
   /* USER CODE BEGIN RTOS_THREADS */
   /* Validate all thread creations - fail fast on low heap */
-  REQUIRE_RTOS_HANDLE(btnTxLoopTaskHandle);
+  REQUIRE_RTOS_HANDLE(ioLoopTaskHandle);
   REQUIRE_RTOS_HANDLE(displayTaskHandle);
   REQUIRE_RTOS_HANDLE(uartRxTaskHandle);
   REQUIRE_RTOS_HANDLE(uartTxTaskHandle);
@@ -320,22 +320,22 @@ void MX_FREERTOS_Init(void) {
 
 }
 
-/* USER CODE BEGIN Header_StartBtnTxLoop */
+/* USER CODE BEGIN Header_StartIoLoop */
 /**
- * @brief  Function implementing the btnTxLoopTask thread.
+ * @brief  Function implementing the ioLoopTask thread.
  * @param  argument: Not used
  * @retval None
  */
-/* USER CODE END Header_StartBtnTxLoop */
-__weak void StartBtnTxLoop(void *argument)
+/* USER CODE END Header_StartIoLoop */
+__weak void StartIoLoop(void *argument)
 {
-  /* USER CODE BEGIN StartBtnTxLoop */
+  /* USER CODE BEGIN StartIoLoop */
   /* Infinite loop */
   for (;;)
   {
     osDelay(1);
   }
-  /* USER CODE END StartBtnTxLoop */
+  /* USER CODE END StartIoLoop */
 }
 
 /* USER CODE BEGIN Header_StartDisplayTask */

DASH/Core/User/Inc/FEB_IO.h

@@ -30,16 +30,22 @@ typedef struct
   bool switch_coolant_pump_radiator_fan;
   bool switch_accumulator_fans;
   bool switch_logging;
+  bool switch_4;
 
   // Button states
   bool button_rtd;
+  bool button_2;
+  bool button_3;
+  bool button_4;
 
   // Buzzer state
   bool buzzer_enabled;
 } IO_States_t;
 
 IO_States_t FEB_IO_GetLastIOStates(void);
 
+bool FEB_IO_StatusOk(void);
+
 void FEB_IO_Set_Buzzer(bool new_state);
 
 #endif

DASH/Core/User/Src/FEB_CAN.c

@@ -21,11 +21,15 @@
 #include "feb_can_lib.h"
 #include "cmsis_os2.h"
 #include "FreeRTOS.h"
+#include "feb_log.h"
 #include "task.h"
 #include "feb_console.h"
 #include "main.h"
 #include "FEB_CAN_State.h"
 #include "FEB_CAN_PingPong.h"
+#include "FEB_CAN_LVPDB.h"
+#include "FEB_CAN_PCU.h"
+#include "FEB_CAN_BMS.h"
 
 /* ========================== External HAL handles ========================== */
 extern CAN_HandleTypeDef hcan1;
@@ -55,6 +59,7 @@ static void DASH_CAN_RxCallback(FEB_CAN_Instance_t instance, uint32_t can_id, FE
   (void)user_data;
   (void)can_id;
   (void)length;
+  // LOG_D("CAN RX", "%X %X %X %X %X %X %X %X", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
 }
 
 /* ========================== CAN Initialization ========================== */
@@ -142,9 +147,9 @@ void StartDASHTaskRx(void *argument)
   /* CAN init MUST occur after scheduler start */
   DASH_CAN_Init();
   FEB_CAN_PingPong_Init();
-  // FEB_CAN_BMS_Init();
-  // FEB_CAN_PCU_Init();
-  // FEB_CAN_LVPDB_Init();
+  FEB_CAN_BMS_Init();
+  FEB_CAN_PCU_Init();
+  FEB_CAN_LVPDB_Init();
 
   /* Signal that CAN is ready for state publishing */
   FEB_CAN_State_SetReady();

DASH/Core/User/Src/FEB_CAN_LVPDB.c

@@ -9,6 +9,7 @@
 #include "FEB_CAN_LVPDB.h"
 #include "feb_can.h"
 #include "feb_can_lib.h"
+#include "feb_log.h"
 #include "stm32f4xx_hal.h"
 #include <stdbool.h>
 
@@ -32,6 +33,7 @@ static LVPDB_State_t lvpdb_state = {.lv_24v_voltage = 0, .lv_12v_voltage = 0, .l
 static void rx_callback_lv_voltages(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)
 {
+  LOG_I("CAN RX", "Received can message %X %X", data[0], data[1]);
   struct feb_can_lvpdb_lv_24v_bus_and_12v_bus_voltages_t msg;
   if (feb_can_lvpdb_lv_24v_bus_and_12v_bus_voltages_unpack(&msg, data, length) == 0)
   {
@@ -53,13 +55,12 @@ void FEB_CAN_LVPDB_Init(void)
       .can_id = FEB_CAN_LVPDB_LV_24V_BUS_AND_12V_BUS_VOLTAGES_FRAME_ID,
       .id_type = FEB_CAN_ID_STD,
       .filter_type = FEB_CAN_FILTER_EXACT,
-      .mask = 0,
       .fifo = FEB_CAN_FIFO_0,
       .callback = rx_callback_lv_voltages,
       .user_data = NULL,
   };
 
-  (void)FEB_CAN_RX_Register(&rx_params);
+  FEB_CAN_RX_Register(&rx_params);
 }
 
 uint16_t FEB_CAN_LVPDB_GetLast24VVoltage(void)

DASH/Core/User/Src/FEB_CAN_State.c

@@ -11,6 +11,7 @@
 #include "feb_log.h"
 #include <stdbool.h>
 #include <string.h>
+#include "FEB_IO.h"
 
 #define TAG_STATE "[STATE]"
 
@@ -46,23 +47,23 @@ void FEB_CAN_State_Tick(void)
     return;
   }
 
+  uint8_t tx_data[FEB_CAN_DASH_TPS_LENGTH];
+  memset(tx_data, 0x00, sizeof(tx_data));
+  // feb_can_dash_tps_pack(tx_data, &((struct feb_can_dash_tps_t){.current = }), sizeof(tx_data));
+  // FEB_CAN_TX_Send(FEB_CAN_INSTANCE_1, FEB_CAN_DASH_TPS_FRAME_ID, FEB_CAN_ID_STD, tx_data, FEB_CAN_DASH_TPS_LENGTH);
+
   /* Divider for 100ms period (called every 1ms) */
   static uint16_t heartbeat_divider = 0;
   heartbeat_divider++;
-
   if (heartbeat_divider >= 100)
   {
     heartbeat_divider = 0;
 
-    /* TODO: Wire to actual DASH error state when implemented */
-    /* dash_heartbeat_msg.error0 = error_flags_0; */
-    /* dash_heartbeat_msg.error1 = error_flags_1; */
-    /* ... etc ... */
+    dash_heartbeat_msg.io_expander_error = !FEB_IO_StatusOk();
 
-    /* Pack and send */
     uint8_t tx_data[FEB_CAN_DASH_HEARTBEAT_LENGTH];
+    memset(tx_data, 0x00, sizeof(tx_data));
     feb_can_dash_heartbeat_pack(tx_data, &dash_heartbeat_msg, sizeof(tx_data));
-
     FEB_CAN_TX_Send(FEB_CAN_INSTANCE_1, FEB_CAN_DASH_HEARTBEAT_FRAME_ID, FEB_CAN_ID_STD, tx_data,
                     FEB_CAN_DASH_HEARTBEAT_LENGTH);
   }
@@ -75,31 +76,33 @@ void FEB_CAN_State_Tick(void)
    */
   static uint16_t state_divider = 0;
   state_divider++;
-
   if (state_divider >= 100)
   {
     state_divider = 0;
 
-    uint8_t tx_data[2];
+    uint8_t tx_data[FEB_CAN_DASH_STATE_LENGTH];
     memset(tx_data, 0x00, sizeof(tx_data));
 
     IO_States_t states = FEB_IO_GetLastIOStates();
 
     if (feb_can_dash_state_pack(tx_data,
                                 &((struct feb_can_dash_state_t){.buzzer = states.buzzer_enabled,
                                                                 .button1 = states.button_rtd,
+                                                                .button2 = states.button_2,
+                                                                .button3 = states.button_3,
+                                                                .button4 = states.button_4,
                                                                 .switch1 = states.switch_accumulator_fans,
-                                                                .switch2 = states.button_rtd,
-                                                                // .switch2 = states.switch_coolant_pump_radiator_fan,
+                                                                .switch2 = states.switch_coolant_pump_radiator_fan,
                                                                 .switch3 = states.switch_logging,
+                                                                .switch4 = states.switch_4,
                                                                 .ready_to_drive = FEB_State_GetLastRTD()}),
-                                2) == 2)
+                                sizeof(tx_data)) == FEB_CAN_DASH_STATE_LENGTH)
     {
       FEB_CAN_Status_t st = FEB_CAN_TX_Send(FEB_CAN_INSTANCE_1, FEB_CAN_DASH_STATE_FRAME_ID, FEB_CAN_ID_STD, tx_data,
                                             FEB_CAN_DASH_STATE_LENGTH);
       if (st == FEB_CAN_OK)
       {
-        LOG_D(TAG_STATE, "Sending Dash IO State Over CAN: %02X %02X", tx_data[0], tx_data[1]);
+        // LOG_D(TAG_STATE, "Sending Dash IO State Over CAN: %02X %02X", tx_data[0], tx_data[1]);
       }
       else
       {

DASH/Core/User/Src/FEB_IO.c

@@ -2,11 +2,13 @@
 #include "FEB_CAN.h"
 #include "FEB_CAN_PCU.h"
 #include "FEB_i2c_protected.h"
+#include "feb_log.h"
 #include "stm32f4xx_hal.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
+#include "FEB_RTD.h"
 
 // /* ------------------- External handles ------------------- */
 extern I2C_HandleTypeDef hi2c1;
@@ -29,10 +31,15 @@ static uint32_t end_buzzer_tick = 0;
 
 static IO_States_t state = {.switch_coolant_pump_radiator_fan = false,
                             .switch_accumulator_fans = false,
-                            .button_rtd = false,
                             .switch_logging = false,
+                            .button_rtd = false,
+                            .button_2 = false,
+                            .button_3 = false,
+                            .button_4 = false,
                             .buzzer_enabled = false};
 
+static HAL_StatusTypeDef status;
+
 // MARK: Initialization
 void FEB_IO_Init(void)
 {
@@ -41,7 +48,7 @@ void FEB_IO_Init(void)
   init_val[0] = 0b11100001;
   init_val[1] = 0b11111111;
 
-  FEB_I2C_Master_Transmit(&hi2c1, IOEXP_ADDR << 1, init_val, 2, HAL_MAX_DELAY);
+  status = FEB_I2C_Master_Transmit(&hi2c1, IOEXP_ADDR << 1, init_val, 2, HAL_MAX_DELAY);
 }
 
 // /* ------------------- Reset ------------------- */
@@ -136,7 +143,7 @@ void FEB_IO_Update_GPIO(void)
   uint8_t received_data[2];
   memset(received_data, 0x00, sizeof(received_data));
 
-  FEB_I2C_Master_Receive(&hi2c1, IOEXP_ADDR << 1, received_data, 2, HAL_MAX_DELAY);
+  status = FEB_I2C_Master_Receive(&hi2c1, IOEXP_ADDR << 1, received_data, 2, HAL_MAX_DELAY);
 
   //   00010010 received_data
   //   00010000 (1 << 5)
@@ -145,10 +152,14 @@ void FEB_IO_Update_GPIO(void)
   // printf("[-] %X %X\n", received_data[0], received_data[1]);
 
   state.button_rtd = (bool)(received_data[0] & (1 << 1));
+  state.button_2 = (bool)(received_data[0] & (1 << 2));
+  state.button_3 = (bool)(received_data[0] & (1 << 3));
+  state.button_4 = (bool)(received_data[0] & (1 << 4));
 
   state.switch_logging = !(bool)(received_data[1] & (1 << 1));
-  state.switch_coolant_pump_radiator_fan = !(bool)(received_data[1] & (1 << 2));
-  state.switch_accumulator_fans = !(bool)(received_data[1] & (1 << 3));
+  state.switch_accumulator_fans = !(bool)(received_data[1] & (1 << 2));
+  state.switch_coolant_pump_radiator_fan = !(bool)(received_data[1] & (1 << 3));
+  state.switch_4 = !(bool)(received_data[1] & (1 << 0));
 
   FEB_IO_Update_Buzzer();
 }
@@ -163,7 +174,7 @@ void FEB_IO_Set_Buzzer(bool new_state)
   send_val[0] = state.buzzer_enabled ? 0b11100000 : 0b11100001;
   send_val[1] = 0b11111111;
 
-  FEB_I2C_Master_Transmit(&hi2c1, IOEXP_ADDR << 1, send_val, 2, HAL_MAX_DELAY);
+  status = FEB_I2C_Master_Transmit(&hi2c1, IOEXP_ADDR << 1, send_val, 2, HAL_MAX_DELAY);
 }
 
 void FEB_IO_Update_Buzzer(void)
@@ -247,3 +258,19 @@ IO_States_t FEB_IO_GetLastIOStates(void)
 {
   return state;
 }
+
+bool FEB_IO_StatusOk(void)
+{
+  return status != HAL_ERROR && status != HAL_TIMEOUT;
+}
+
+void StartIoLoop(void *argument)
+{
+  for (;;)
+  {
+    FEB_IO_Update_GPIO();
+    FEB_State_Update_RTD();
+
+    osDelay(1);
+  }
+}

DASH/Core/User/Src/FEB_UI.c

@@ -94,7 +94,7 @@ void StartDisplayTask(void *argument)
     //   last_blink = lv_tick_get();
     // }
 
-    osDelay(500); // slower delay so you can see it changing
+    osDelay(1); // slower delay so you can see it changing
   }
 }