Implement simple fan control

Core/Inc/AMS_CAN.h

@@ -14,6 +14,8 @@
 #include "stm32f4xx_hal_can.h"
 #include "stm32f4xx_hal_def.h"
 
+#include <stdint.h>
+
 #define CAN_ID_SLAVE_ERROR 0x001
 #define CAN_ID_AMS_SLAVE_HEARTBEAT_BASE 0x600
 #define CAN_HEARTBEAT_TX_TIMEOUT 5 /* ms */
@@ -24,9 +26,18 @@ void ams_can_handle_ams_msg(CAN_RxHeaderTypeDef* header, uint8_t* data);
 void ams_can_handle_car_msg(CAN_RxHeaderTypeDef* header, uint8_t* data);
 
 void ams_can_send_heartbeat();
-void ams_can_send_error(AMS_ErrorCode error_code);
+/**
+ * @brief Send an AMS Error via CAN.
+ *
+ * @param error_code The kind of error
+ * @param transmission_timeout How long to wait for the transmission to complete
+ * after starting it (in ms). Set to 0 for no wait.
+ */
+void ams_can_send_error(AMS_ErrorCode error_code,
+                        uint32_t transmission_timeout);
 
-HAL_StatusTypeDef ams_can_wait_for_free_mailbox(CAN_HandleTypeDef* handle,
+HAL_StatusTypeDef ams_can_wait_for_free_mailboxes(CAN_HandleTypeDef* handle,
-                                                uint32_t timeout);
+                                                  int num_mailboxes,
+                                                  uint32_t timeout);
 
 #endif /* INC_AMS_CAN_H_ */

Core/Inc/BQ_Abstraction_Layer.h

@@ -20,6 +20,7 @@
 #define CELL_UV_THRESHOLD 34100 // 2.6V
 
 extern uint16_t cell_voltages[N_CELLS];
+extern uint16_t max_voltage, min_voltage;
 
 typedef enum { BQ_OFF, BQ_RDY, BQ_STDBY, BQ_INIT_PHASE, BQ_ERROR } BQ_Status;
 extern BQ_Status bq_status;

Core/Inc/FanControl.h

@@ -5,8 +5,14 @@
 #include "stm32f4xx_hal_def.h"
 #include "stm32f4xx_hal_tim.h"
 
+typedef enum { FANS_OFF, FANS_ON } FanState;
+
+extern FanState fan_state;
+
 HAL_StatusTypeDef fan_ctrl_init(TIM_HandleTypeDef* handle, uint32_t channel);
 
+void fan_ctrl_update();
+
 /**
  * @brief Set the power of the fan (0 -> off, 100 -> full power).
  */

Core/Inc/TMP144.h

@@ -11,18 +11,22 @@
 #include "common_defs.h"
 
 #include "stm32f4xx_hal.h"
+#include "stm32f4xx_hal_def.h"
 #include "stm32f4xx_hal_uart.h"
 
-#define N_SENSORS 32
+#define N_TEMP_SENSORS 32
+#define TMP144_RESPONSE_TIMEOUT 100 /* ms */
 
-extern volatile uint16_t temperatures[N_SENSORS];
+extern volatile uint16_t temperatures[N_TEMP_SENSORS];
-extern volatile uint16_t max_temp;
+extern volatile uint16_t min_temperature;
+extern volatile uint16_t max_temperature;
 
 typedef enum {
   TMP144_IDLE,
   TMP144_RESETTING,
   TMP144_INITIALIZING,
-  TMP144_READING_TEMP
+  TMP144_READING_TEMP,
+  TMP144_ERROR
 } TMP144State;
 
 typedef struct {
@@ -32,11 +36,18 @@ typedef struct {
   uint8_t rxbuf[34];
 
   size_t n_sensors;
+
+  uint32_t expected_response_time;
 } TMP144Bus;
 
+extern volatile TMP144Bus tmp144_bus_busbar;
+extern volatile TMP144Bus tmp144_bus_other;
+
 HAL_StatusTypeDef tmp144_init(UART_HandleTypeDef* busbar_side,
                               UART_HandleTypeDef* other_side);
 
+HAL_StatusTypeDef tmp144_check_timeouts();
+
 HAL_StatusTypeDef tmp144_init_reset(TMP144Bus* bus);
 HAL_StatusTypeDef tmp144_init_post_reset(TMP144Bus* bus);
 HAL_StatusTypeDef tmp144_init_post_addr(TMP144Bus* bus);

Core/Inc/main.h

@@ -40,7 +40,9 @@ typedef enum {
   AMS_ERROR_UV,
   AMS_ERROR_OV,
   AMS_ERROR_UT,
-  AMS_ERROR_OT
+  AMS_ERROR_OT,
+  AMS_ERROR_BQ,
+  AMS_ERROR_TMP144
 } AMS_ErrorCode;
 /* USER CODE END ET */
 
@@ -51,7 +53,16 @@ extern uint8_t slave_id;
 
 /* Exported macro ------------------------------------------------------------*/
 /* USER CODE BEGIN EM */
-#define MAIN_LOOP_PERIOD 100 /* ms */
+#define MAIN_LOOP_PERIOD 100   /* ms */
+#define AMS_ERROR_TX_TIMEOUT 2 /* ms */
+#define THRESH_UV 32768        /* 2.5V */
+#define THRESH_OV 55050        /* 4.2V */
+#define THRESH_UT 0            /* 0C */
+#define THRESH_OT 880          /* 55C */
+
+#define THRESH_FANS_ON_HALF 640 /* 40C */
+#define THRESH_FANS_ON_FULL 800 /* 50C */
+#define THRESH_FANS_OFF 560     /* 35C */
 /* USER CODE END EM */
 
 void HAL_TIM_MspPostInit(TIM_HandleTypeDef* htim);
@@ -61,6 +72,7 @@ void Error_Handler(void);
 
 /* USER CODE BEGIN EFP */
 void update_status_leds();
+void check_error_conditions();
 void delay_period();
 /* USER CODE END EFP */
 

Core/Src/AMS_CAN.c

@@ -16,6 +16,8 @@
 #include "stm32f4xx_hal.h"
 #include "stm32f4xx_hal_can.h"
 
+#include <stdint.h>
+
 static CAN_HandleTypeDef* handle_ams;
 static CAN_HandleTypeDef* handle_car;
 
@@ -127,7 +129,8 @@ void ams_can_send_heartbeat() {
   }
 }
 
-void ams_can_send_error(AMS_ErrorCode error_code) {
+void ams_can_send_error(AMS_ErrorCode error_code,
+                        uint32_t transmission_timeout) {
   static CAN_TxHeaderTypeDef header;
   header.IDE = CAN_ID_STD;
   header.DLC = 8;
@@ -143,13 +146,15 @@ void ams_can_send_error(AMS_ErrorCode error_code) {
                          CAN_TX_MAILBOX0 | CAN_TX_MAILBOX1 | CAN_TX_MAILBOX2);
   uint32_t mailbox;
   HAL_CAN_AddTxMessage(handle_ams, &header, data, &mailbox);
+  ams_can_wait_for_free_mailboxes(handle_ams, 3, transmission_timeout);
 }
 
-HAL_StatusTypeDef ams_can_wait_for_free_mailbox(CAN_HandleTypeDef* handle,
+HAL_StatusTypeDef ams_can_wait_for_free_mailboxes(CAN_HandleTypeDef* handle,
-                                                uint32_t timeout) {
+                                                  int num_mailboxes,
+                                                  uint32_t timeout) {
   uint32_t end = HAL_GetTick() + timeout;
   while (HAL_GetTick() < end) {
-    if (HAL_CAN_GetTxMailboxesFreeLevel(handle) > 0) {
+    if (HAL_CAN_GetTxMailboxesFreeLevel(handle) >= num_mailboxes) {
       return HAL_OK;
     }
   }

Core/Src/BQ_Abstraction_Layer.c

@@ -16,6 +16,7 @@
 #include <string.h>
 
 uint16_t cell_voltages[N_CELLS];
+uint16_t max_voltage, min_voltage;
 
 BQ_Status bq_status;
 BQ_Error_Description bq_error;
@@ -82,11 +83,20 @@ void afe_measure() {
   lastmeasurementtime = HAL_GetTick();
 
   if (retval == BQ_COMM_OK) {
+    uint16_t max = 0;
+    uint16_t min = 0xFFFF;
     for (int n = 0; n < N_CELLS; n++) {
-      cell_voltages[N_CELLS - 1 - n] =
+      uint16_t v = cellvoltagebuffer[2 * n] << 8 | cellvoltagebuffer[2 * n + 1];
-          (uint16_t)(cellvoltagebuffer[2 * n] << 8) +
+      cell_voltages[N_CELLS - 1 - n] = v;
-          (uint16_t)cellvoltagebuffer[2 * n + 1];
+      if (v > max) {
+        max = v;
+      }
+      if (v < min) {
+        min = v;
+      }
     }
+    max_voltage = max;
+    min_voltage = min;
   } else if (retval == BQ_COMM_ERR_HAL) {
     bq_set_error_with_loc(BQ_COMM_ERR_HAL, BQ_ERROR_LOC_MEASURE);
   } else if (retval == BQ_COMM_ERR_CRC) {

Core/Src/FanControl.c

@@ -1,18 +1,48 @@
 #include "FanControl.h"
 
+#include "TMP144.h"
+#include "main.h"
+
 #include "stm32f4xx_hal_def.h"
 #include "stm32f4xx_hal_tim.h"
 
+#include <stdint.h>
+
 TIM_HandleTypeDef* timer;
 uint32_t channel;
+FanState fan_state;
 
 HAL_StatusTypeDef fan_ctrl_init(TIM_HandleTypeDef* handle, uint32_t channel_) {
   timer = handle;
   channel = channel_;
+  fan_state = FANS_OFF;
 
   return HAL_TIM_PWM_Start(timer, channel);
 }
 
+void fan_ctrl_update() {
+  if (fan_state == FANS_OFF && max_temperature > THRESH_FANS_ON_HALF) {
+    fan_state = FANS_ON;
+  } else if (fan_state == FANS_ON && max_temperature < THRESH_FANS_OFF) {
+    fan_state = FANS_OFF;
+  }
+
+  uint32_t power;
+  if (fan_state == FANS_OFF) {
+    power = 0;
+  } else {
+    if (max_temperature < THRESH_FANS_ON_HALF) {
+      power = 50;
+    } else if (max_temperature > THRESH_FANS_ON_FULL) {
+      power = 100;
+    } else {
+      power = (100 * (max_temperature - THRESH_FANS_ON_HALF)) /
+              (THRESH_FANS_ON_FULL - THRESH_FANS_ON_HALF);
+    }
+  }
+  fan_ctrl_set_power(power);
+}
+
 void fan_ctrl_set_power(uint32_t percent) {
   if (percent > 100) {
     percent = 100;

Core/Src/TMP144.c

@@ -7,6 +7,10 @@
 
 #include "TMP144.h"
 
+#include "stm32f4xx_hal.h"
+#include "stm32f4xx_hal_def.h"
+#include "stm32f4xx_hal_uart.h"
+
 #include <stdint.h>
 #include <string.h>
 
@@ -14,11 +18,12 @@ static const uint8_t TMP144_SEQ_RESET[] = {0x55, 0xB4};
 static const uint8_t TMP144_SEQ_ADDR[] = {0x55, 0x8C, 0x90};
 static const uint8_t TMP144_SEQ_READ_TEMPS[] = {0x55, 0xF1};
 
-volatile uint16_t temperatures[N_SENSORS];
+volatile uint16_t temperatures[N_TEMP_SENSORS];
-volatile uint16_t max_temp;
+volatile uint16_t min_temperature;
+volatile uint16_t max_temperature;
 
-static volatile TMP144Bus bus_busbar;
+volatile TMP144Bus tmp144_bus_busbar;
-static volatile TMP144Bus bus_other;
+volatile TMP144Bus tmp144_bus_other;
 
 #define CHECK_STATUS(s)                                                        \
   {                                                                            \
@@ -29,22 +34,35 @@ static volatile TMP144Bus bus_other;
 
 HAL_StatusTypeDef tmp144_init(UART_HandleTypeDef* busbar_side,
                               UART_HandleTypeDef* other_side) {
-  bus_busbar.handle = busbar_side;
+  tmp144_bus_busbar.handle = busbar_side;
-  bus_other.handle = other_side;
+  tmp144_bus_other.handle = other_side;
 
-  bus_busbar.state = TMP144_IDLE;
+  tmp144_bus_busbar.state = TMP144_IDLE;
-  bus_other.state = TMP144_IDLE;
+  tmp144_bus_other.state = TMP144_IDLE;
 
   // TODO: Configure this in EEPROM
-  bus_busbar.n_sensors = 16;
+  tmp144_bus_busbar.n_sensors = N_TEMP_SENSORS / 2;
-  bus_other.n_sensors = 16;
+  tmp144_bus_other.n_sensors = N_TEMP_SENSORS / 2;
 
-  CHECK_STATUS(tmp144_init_reset(&bus_busbar));
+  CHECK_STATUS(tmp144_init_reset(&tmp144_bus_busbar));
-  CHECK_STATUS(tmp144_init_reset(&bus_other));
+  CHECK_STATUS(tmp144_init_reset(&tmp144_bus_other));
 
   return HAL_OK;
 }
 
+HAL_StatusTypeDef tmp144_check_timeouts() {
+  uint32_t now = HAL_GetTick();
+  uint32_t t1 = tmp144_bus_busbar.expected_response_time;
+  uint32_t t2 = tmp144_bus_other.expected_response_time;
+  if (t1 != 0 && t1 < now) {
+    tmp144_bus_busbar.state = TMP144_ERROR;
+  }
+  if (t2 != 0 && t2 < now) {
+    tmp144_bus_other.state = TMP144_ERROR;
+  }
+  return HAL_OK;
+}
+
 HAL_StatusTypeDef tmp144_init_reset(TMP144Bus* bus) {
   if (bus->state != TMP144_IDLE) {
     return HAL_ERROR;
@@ -55,17 +73,19 @@ HAL_StatusTypeDef tmp144_init_reset(TMP144Bus* bus) {
   // Keep sending Global Software Reset until it echoes back (as per 7.5.2)
   int tries = 0;
   do {
-    if (tries > 10) {
+    if (tries > bus->n_sensors) {
+      bus->state = TMP144_ERROR;
       return HAL_TIMEOUT;
     }
     CHECK_STATUS(HAL_UART_Transmit(bus->handle, TMP144_SEQ_RESET,
                                    sizeof(TMP144_SEQ_RESET), 100));
-    HAL_Delay(100);
+    HAL_Delay(50);
     tries++;
   } while (bus->state == TMP144_RESETTING);
 
   bus->state = TMP144_INITIALIZING;
   CHECK_STATUS(HAL_UART_Receive_IT(bus->handle, bus->rxbuf, 3));
+  bus->expected_response_time = HAL_GetTick() + 100;
   CHECK_STATUS(HAL_UART_Transmit(bus->handle, TMP144_SEQ_ADDR,
                                  sizeof(TMP144_SEQ_ADDR), 100));
 
@@ -92,6 +112,7 @@ HAL_StatusTypeDef tmp144_init_post_addr(TMP144Bus* bus) {
 
   uint8_t n_sensors = bus->rxbuf[idx_response] - TMP144_SEQ_ADDR[idx_response];
   if (n_sensors != bus->n_sensors) {
+    bus->state = TMP144_ERROR;
     return HAL_ERROR;
   }
   bus->state = TMP144_IDLE;
@@ -100,8 +121,8 @@ HAL_StatusTypeDef tmp144_init_post_addr(TMP144Bus* bus) {
 }
 
 HAL_StatusTypeDef tmp144_read_temps() {
-  CHECK_STATUS(tmp144_send_read_temps(&bus_busbar));
+  CHECK_STATUS(tmp144_send_read_temps(&tmp144_bus_busbar));
-  CHECK_STATUS(tmp144_send_read_temps(&bus_other));
+  CHECK_STATUS(tmp144_send_read_temps(&tmp144_bus_other));
 
   return HAL_OK;
 }
@@ -112,11 +133,10 @@ HAL_StatusTypeDef tmp144_send_read_temps(TMP144Bus* bus) {
   }
 
   bus->state = TMP144_READING_TEMP;
-  //	HAL_UART_Receive_IT(bus->handle, bus->rxbuf,
-  // sizeof(TMP144_SEQ_READ_TEMPS) + 2 * bus->n_sensors);
   CHECK_STATUS(
       HAL_UART_Receive_IT(bus->handle, bus->rxbuf,
                           sizeof(TMP144_SEQ_READ_TEMPS) + 2 * bus->n_sensors));
+  bus->expected_response_time = HAL_GetTick() + TMP144_RESPONSE_TIMEOUT;
   CHECK_STATUS(HAL_UART_Transmit(bus->handle, TMP144_SEQ_READ_TEMPS,
                                  sizeof(TMP144_SEQ_READ_TEMPS), 100));
 
@@ -134,7 +154,8 @@ HAL_StatusTypeDef tmp144_recv_temps(TMP144Bus* bus) {
     return HAL_ERROR;
   }
 
-  size_t temperatures_offset = (bus == &bus_busbar) ? 0 : N_SENSORS / 2;
+  size_t temperatures_offset =
+      (bus == &tmp144_bus_busbar) ? 0 : N_TEMP_SENSORS / 2;
   for (size_t i = 0; i < bus->n_sensors; i++) {
     size_t buf_offset = headerlen + 2 * i;
     uint16_t temp =
@@ -143,27 +164,34 @@ HAL_StatusTypeDef tmp144_recv_temps(TMP144Bus* bus) {
   }
 
   uint16_t max = temperatures[0];
-  for (size_t i = 1; i < N_SENSORS; i++) {
+  uint16_t min = temperatures[0];
+  for (size_t i = 1; i < N_TEMP_SENSORS; i++) {
     if (temperatures[i] > max) {
       max = temperatures[i];
     }
+    if (temperatures[i] < min) {
+      min = temperatures[i];
+    }
   }
-  max_temp = max;
+  max_temperature = max;
+  min_temperature = min;
 
   return HAL_OK;
 }
 
 void tmp144_handle_rx_cplt(UART_HandleTypeDef* handle) {
   TMP144Bus* bus;
-  if (handle == bus_busbar.handle) {
+  if (handle == tmp144_bus_busbar.handle) {
-    bus = &bus_busbar;
+    bus = &tmp144_bus_busbar;
-  } else if (handle == bus_other.handle) {
+  } else if (handle == tmp144_bus_other.handle) {
-    bus = &bus_other;
+    bus = &tmp144_bus_other;
   } else {
     // TODO
     Error_Handler();
   }
 
+  bus->expected_response_time = 0;
+
   switch (bus->state) {
   case TMP144_IDLE:
     // TODO

Core/Src/main.c

@@ -21,10 +21,12 @@
 
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
+#include "AMS_CAN.h"
 #include "BQ_Abstraction_Layer.h"
 #include "EEPROM.h"
 #include "FanControl.h"
 #include "TMP144.h"
+#include "common_defs.h"
 
 #include "stm32f4xx_hal.h"
 #include "stm32f4xx_hal_gpio.h"
@@ -94,6 +96,29 @@ void update_status_leds() {
   }
 }
 
+void check_error_conditions() {
+  if (bq_status != BQ_RDY) {
+    ams_can_send_error(AMS_ERROR_BQ, AMS_ERROR_TX_TIMEOUT);
+  }
+  tmp144_check_timeouts();
+  if (tmp144_bus_busbar.state == TMP144_ERROR ||
+      tmp144_bus_other.state == TMP144_ERROR) {
+    ams_can_send_error(AMS_ERROR_TMP144, AMS_ERROR_TX_TIMEOUT);
+  }
+  if (min_voltage < THRESH_UV) {
+    ams_can_send_error(AMS_ERROR_UV, AMS_ERROR_TX_TIMEOUT);
+  }
+  if (max_voltage > THRESH_OV) {
+    ams_can_send_error(AMS_ERROR_OV, AMS_ERROR_TX_TIMEOUT);
+  }
+  if (min_temperature < THRESH_UT) {
+    ams_can_send_error(AMS_ERROR_UT, AMS_ERROR_TX_TIMEOUT);
+  }
+  if (max_temperature > THRESH_OT) {
+    ams_can_send_error(AMS_ERROR_OT, AMS_ERROR_TX_TIMEOUT);
+  }
+}
+
 void delay_period() {
   static uint32_t last_it = 0;
   uint32_t now = HAL_GetTick();
@@ -161,8 +186,10 @@ int main(void) {
     /* USER CODE BEGIN 3 */
     update_status_leds();
     afe_measure();
+    tmp144_read_temps();
+    check_error_conditions();
+    fan_ctrl_update();
     delay_period();
-    fan_ctrl_set_power((HAL_GetTick() / 100) % 100);
   }
   /* USER CODE END 3 */
 }