V1.2

CHANGELOG.txt

@@ -7,3 +7,10 @@ V1.1
 - add pwm_calibrate_powerground
 - precharge and discharge are now timer dependent instead of voltage dependent
 - remove the transitions (precharge -> discharge) to stop weird interactions
+
+V1.2
+- change auxvoltages and cellvoltages to float to achieve higher precision
+- added void sm_calibrate_powerground(); void sm_precharge_discharge_manager();
+- fixed the clock in mxcube
+- cleaned up PWM_powerground_control()
+- cleaned up the state machine 

Core/Inc/ADBMS_Abstraction.h

@@ -46,8 +46,8 @@ struct ADBMS6830_Internal_Status {
 };
 
 typedef struct {
-  int16_t cellVoltages[MAXIMUM_CELL_VOLTAGES];
+  float cellVoltages[MAXIMUM_CELL_VOLTAGES];
-  int16_t auxVoltages[MAXIMUM_AUX_VOLTAGES];
+  float auxVoltages[MAXIMUM_AUX_VOLTAGES];
 
   struct ADBMS6830_Internal_Status status;
   uint16 internalDieTemp;

Core/Inc/state_machine.h

@@ -14,9 +14,9 @@
 #define MIN_VEHICLE_SIDE_VOLTAGE 150000 // mV
 // Time to wait after reaching 95% of battery voltage before exiting precharge
 // Set this to 1000 in scruti to demonstrate the voltage on the multimeter
-#define PRECHARGE_95_DURATION 0 // ms
+#define PRECHARGE_DURATION 3000 // ms
 // Time to wait for discharge
-#define DISCHARGE_DURATION 5000 // ms
+#define DISCHARGE_DURATION 3000 // ms
 // Time to wait after there is no more error condition before exiting TS_ERROR
 #define NO_ERROR_TIME 1000 // ms
 // Time to wait for charger voltage before going to TS_ERROR
@@ -88,6 +88,10 @@ void sm_check_battery_temperature(int8_t* id, int16_t* temp);
 int16_t sm_return_cell_temperature(int id);
 int16_t sm_return_cell_voltage(int id);
 
+void sm_calibrate_powerground();
+void sm_precharge_discharge_manager();
+void sm_powerground_manager(int8_t percent, bool source);
+
 void sm_handle_ams_in(const uint8 *data);
 void sm_check_errors();
 void sm_set_error(ErrorKind error_kind, bool is_errored);

Core/Src/PWM_control.c

@@ -41,14 +41,16 @@ void PWM_control_init(TIM_HandleTypeDef* pg, TIM_HandleTypeDef* bat_cool, TIM_Ha
   DUTYCYCLE = 40000 * X/100
 */
 void PWM_powerground_control(uint8_t percent){
-  if (percent > 100) //something went wrong
+  if (percent > 100){ //something went wrong
+    __HAL_TIM_SET_COMPARE(powerground, TIM_CHANNEL_3, 0);
+    __HAL_TIM_SET_COMPARE(powerground, TIM_CHANNEL_4, 0);
     return;
+  }
   powerground_status = percent;
 
-  int ccr = 2000 + ((2000) * (percent/100.0));
+  int ccr = 2000 + (20 * percent);
   __HAL_TIM_SET_COMPARE(powerground, TIM_CHANNEL_3, ccr);
   __HAL_TIM_SET_COMPARE(powerground, TIM_CHANNEL_4, ccr);
-  //TIM15->CCR1 = (TIM15->ARR*POWERGROUND_MAX_DUTY_CYCLE-TIM15->ARR*POWERGROUND_MIN_DUTY_CYCLE) * (percent/100.0) + TIM15->ARR*POWERGROUND_MIN_DUTY_CYCLE;
 }
 
 void PWM_set_throttle(){

Core/Src/main.c

@@ -165,10 +165,9 @@ void SystemClock_Config(void)
   /** Initializes the RCC Oscillators according to the specified parameters
   * in the RCC_OscInitTypeDef structure.
   */
-  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI|RCC_OSCILLATORTYPE_HSE;
+  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
-  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
   {
@@ -189,8 +188,8 @@ void SystemClock_Config(void)
     Error_Handler();
   }
   PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_I2C1|RCC_PERIPHCLK_I2C2;
-  PeriphClkInit.I2c1ClockSelection = RCC_I2C1CLKSOURCE_HSI;
+  PeriphClkInit.I2c1ClockSelection = RCC_I2C1CLKSOURCE_SYSCLK;
-  PeriphClkInit.I2c2ClockSelection = RCC_I2C2CLKSOURCE_HSI;
+  PeriphClkInit.I2c2ClockSelection = RCC_I2C2CLKSOURCE_SYSCLK;
   if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
   {
     Error_Handler();
@@ -250,7 +249,7 @@ static void MX_I2C1_Init(void)
 
   /* USER CODE END I2C1_Init 1 */
   hi2c1.Instance = I2C1;
-  hi2c1.Init.Timing = 0x2000090E;
+  hi2c1.Init.Timing = 0x00303D5B;
   hi2c1.Init.OwnAddress1 = 0;
   hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
   hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
@@ -298,7 +297,7 @@ static void MX_I2C2_Init(void)
 
   /* USER CODE END I2C2_Init 1 */
   hi2c2.Instance = I2C2;
-  hi2c2.Init.Timing = 0x2000090E;
+  hi2c2.Init.Timing = 0x00303D5B;
   hi2c2.Init.OwnAddress1 = 0;
   hi2c2.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
   hi2c2.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
@@ -438,9 +437,9 @@ static void MX_TIM3_Init(void)
 
   /* USER CODE END TIM3_Init 1 */
   htim3.Instance = TIM3;
-  htim3.Init.Prescaler = 0;
+  htim3.Init.Prescaler = 7;
   htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
-  htim3.Init.Period = 65535;
+  htim3.Init.Period = 39999;
   htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
   if (HAL_TIM_PWM_Init(&htim3) != HAL_OK)

Core/Src/state_machine.c

@@ -1,5 +1,6 @@
 #include "state_machine.h"
 #include "AMS_HighLevel.h"
+#include "PWM_control.h"
 #include "TMP1075.h"
 #include "errors.h"
 #include "main.h"
@@ -10,7 +11,15 @@ StateHandle state;
 int16_t RELAY_BAT_SIDE_VOLTAGE;
 int16_t RELAY_ESC_SIDE_VOLTAGE;
 int16_t CURRENT_MEASUREMENT;
+bool CURRENT_MEASUREMENT_ON;
+
 uint8_t powerground_status;
+uint32_t precharge_timer;
+uint32_t discharge_timer;
+uint32_t charging_timer;
+
+uint32_t powerground_calibration_timer;
+uint8_t powerground_calibration_stage;
 
 static uint32_t timestamp;
 
@@ -18,14 +27,24 @@ void sm_init(){
   state.current_state = STATE_INACTIVE;
   state.target_state = STATE_INACTIVE;
   state.error_source = 0;
+  precharge_timer = discharge_timer = charging_timer = powerground_calibration_timer = 0;
 }
 
 void sm_update(){
   sm_check_errors();
+  sm_precharge_discharge_manager();
+  sm_calibrate_powerground();
+
+  int16_t base_offset = 0;
+  if (state.current_state == STATE_INACTIVE){
+    base_offset = module.auxVoltages[0];
+  }
+
+  CURRENT_MEASUREMENT = (module.auxVoltages[0] - base_offset) * 300;
+  CURRENT_MEASUREMENT_ON = (module.auxVoltages[1] > 2400);
+  RELAY_ESC_SIDE_VOLTAGE = module.auxVoltages[2] * 11.711;
+  RELAY_BAT_SIDE_VOLTAGE = module.auxVoltages[3] * 11.711;     // the calculation says the factor is 11. 11.711 yields the better result
  
-  RELAY_BAT_SIDE_VOLTAGE = module.auxVoltages[0] * 12.42;     // the calculation says the factor is 11.989. 12.42 yields the better result
-  RELAY_ESC_SIDE_VOLTAGE = module.auxVoltages[1] * 12.42;
-  CURRENT_MEASUREMENT = (module.auxVoltages[2] - 2496) * 300;
 
   switch (state.current_state) {
     case STATE_INACTIVE:
@@ -73,14 +92,8 @@ State sm_update_precharge(){
   switch (state.target_state) {
     case STATE_INACTIVE:          // if CAN Signal 0000 0000 then immidiete shutdown
       return STATE_DISCHARGE;
-    case STATE_PRECHARGE:
+    case STATE_READY:
-      if (RELAY_BAT_SIDE_VOLTAGE-RELAY_ESC_SIDE_VOLTAGE < 100){
-        PWM_set_throttle();
       return STATE_READY;
-      }
-      return STATE_PRECHARGE;
-    case STATE_DISCHARGE:
-      return STATE_DISCHARGE;
     default:
       return STATE_PRECHARGE;
   }
@@ -93,6 +106,7 @@ State sm_update_ready(){
     case STATE_DISCHARGE:         // if CAN Signal 0000 0000 then shutdown
       return STATE_DISCHARGE;
     default:
+      sm_calibrate_powerground();
       return STATE_READY;
   }
 }
@@ -110,10 +124,8 @@ State sm_update_active(){
 
 State sm_update_discharge(){
   switch (state.target_state) {
-    case STATE_DISCHARGE:
+    case STATE_INACTIVE:
-      return (RELAY_ESC_SIDE_VOLTAGE < 5000) ? STATE_INACTIVE : STATE_DISCHARGE;
+      return STATE_INACTIVE;
-    case STATE_PRECHARGE:       // if CAN Signal 1000 0000 then get ready
-      return STATE_PRECHARGE;
     default: 
       return STATE_DISCHARGE;
   }
@@ -139,7 +151,6 @@ State sm_update_charging(){
   }
 }
 
-
 State sm_update_error(){
   switch (state.target_state) {
     case STATE_DISCHARGE:
@@ -169,7 +180,7 @@ void sm_set_relay_positions(State current_state){
       break;
     case STATE_DISCHARGE:
       sm_set_relay(RELAY_MAIN, 0);
-      sm_set_relay(RELAY_PRECHARGE, 0);
+      sm_set_relay(RELAY_PRECHARGE, 1);
       break;
     case STATE_CHARGING_PRECHARGE:
       sm_set_relay(RELAY_MAIN, 0);
@@ -201,8 +212,10 @@ void sm_set_relay(Relay relay, bool closed){
 }
 
 void sm_check_charging(){
+  #warning fix this timestamp check
   if (RELAY_BAT_SIDE_VOLTAGE < RELAY_ESC_SIDE_VOLTAGE && timestamp == 0)  
     timestamp = HAL_GetTick() + 5000;
+
   if (timestamp < HAL_GetTick())
     state.target_state = STATE_CHARGING_PRECHARGE;
 }
@@ -217,12 +230,81 @@ void sm_check_battery_temperature(int8_t *id, int16_t *temp){
   }
 }
 
-int16_t sm_return_cell_temperature(int id){
+void sm_precharge_discharge_manager(){
-  return tmp1075_temps[id];
+
+  if (state.current_state != STATE_DISCHARGE && state.target_state == STATE_DISCHARGE){
+    discharge_timer = HAL_GetTick() + DISCHARGE_DURATION;
+  } else if (state.current_state == STATE_DISCHARGE && discharge_timer < HAL_GetTick()) {
+    state.target_state = STATE_INACTIVE;
+    discharge_timer = 0;
+  }
+
+  if (state.current_state != STATE_PRECHARGE && state.target_state == STATE_PRECHARGE){
+    precharge_timer = HAL_GetTick() + PRECHARGE_DURATION;
+  } else if (state.current_state == STATE_PRECHARGE && precharge_timer < HAL_GetTick()) {
+    state.target_state = STATE_READY;
+    precharge_timer = 0;
+  }
+
+  if (state.current_state != STATE_CHARGING_PRECHARGE && state.target_state == STATE_CHARGING_PRECHARGE){
+    precharge_timer = HAL_GetTick() + PRECHARGE_DURATION;
+  } else if (state.current_state == STATE_CHARGING_PRECHARGE && precharge_timer < HAL_GetTick()) {
+    state.target_state = STATE_READY;
+    precharge_timer = 0;
+  }
+
 }
 
-int16_t sm_return_cell_voltage(int id){
+// source 0 -> sm_update()
-  return module.cellVoltages[id];
+// source 1 -> sm_ams_in()
+void sm_powerground_manager(int8_t percent, bool source){
+  if (powerground_calibration_stage != 4 && state.current_state == STATE_ACTIVE){
+    sm_calibrate_powerground();
+  } else if (powerground_calibration_stage == 4){
+    if (state.current_state == STATE_PRECHARGE){
+      PWM_powerground_control(0);
+    } else if (state.current_state == STATE_READY || state.current_state == STATE_ACTIVE){
+      if (percent < 10){
+        PWM_powerground_control(0);
+      } else if (percent > 100){
+        PWM_powerground_control(255);
+        state.current_state = STATE_ACTIVE;
+      }
+      PWM_powerground_control(percent);
+    } else {
+      PWM_powerground_control(255);
+    }
+  }
+}
+
+void sm_calibrate_powerground(){
+  if (powerground_calibration_stage != 4 && state.current_state == STATE_READY){
+    switch (powerground_calibration_stage) {
+      case 0:
+        powerground_calibration_timer = HAL_GetTick() + 5000;
+        powerground_calibration_stage = 1;
+        return;
+      case 1:
+        if (powerground_calibration_timer < HAL_GetTick()){
+          powerground_calibration_timer = HAL_GetTick() + 2000;
+          powerground_calibration_stage = 2;
+          PWM_powerground_control(100);
+        }
+        return;
+      case 2:
+        if (powerground_calibration_timer < HAL_GetTick()){
+          powerground_calibration_timer = HAL_GetTick() + 1000;
+          powerground_calibration_stage = 3;
+          PWM_powerground_control(0);
+        }
+        return;
+      case 3:
+        if (powerground_calibration_timer < HAL_GetTick()){
+          powerground_calibration_stage = 4;
+        }
+        return;
+    }
+  }
 }
 
 void sm_handle_ams_in(const uint8_t *data){  
@@ -230,13 +312,16 @@ void sm_handle_ams_in(const uint8_t *data){
     case 0x00:
       if (state.current_state != STATE_INACTIVE){
         state.target_state = STATE_DISCHARGE;
+        PWM_powerground_control(255);
       }
       break;
     case 0x01:
       if (state.target_state == STATE_INACTIVE || state.target_state == STATE_DISCHARGE){
         state.target_state = STATE_PRECHARGE;
+        PWM_powerground_control(0);
       } else if (state.target_state == STATE_ACTIVE){
         state.target_state = STATE_READY;
+        PWM_powerground_control(0);
       }
       break;
     case 0x02:
@@ -245,6 +330,8 @@ void sm_handle_ams_in(const uint8_t *data){
         state.target_state = STATE_ACTIVE;        // READY -> ACTIVE
       }
       break;
+    case 0xFF:                                    // emergency shutdown or EEPROM
+      break;
   }
 }
 
@@ -293,6 +380,14 @@ void sm_check_errors(){
   }
 }  
 
+int16_t sm_return_cell_temperature(int id){
+  return tmp1075_temps[id];
+}
+
+int16_t sm_return_cell_voltage(int id){
+  return module.cellVoltages[id];
+}
+
 void sm_test_cycle_states(){
   RELAY_BAT_SIDE_VOLTAGE = module.auxVoltages[0];
   RELAY_ESC_SIDE_VOLTAGE = module.auxVoltages[1];