FaSTTUBe/mv-bms
56
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

V1.2

Browse Source
This commit is contained in:
hamza 2024-07-05 12:46:52 +03:00
parent 676b5bb8d1
commit f50643cc84
6 changed files with 146 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
CHANGELOG.txt
View File

@ -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

4
Core/Inc/ADBMS_Abstraction.h
View File

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

8
Core/Inc/state_machine.h
View File

@ -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);

8
Core/Src/PWM_control.c
View File

@ -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(){

15
Core/Src/main.c
View File

@ -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.I2c2ClockSelection = RCC_I2C2CLKSOURCE_HSI;
PeriphClkInit.I2c1ClockSelection = RCC_I2C1CLKSOURCE_SYSCLK;
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)

135
Core/Src/state_machine.c
View File

@ -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:
if (RELAY_BAT_SIDE_VOLTAGE-RELAY_ESC_SIDE_VOLTAGE < 100){
PWM_set_throttle();
case STATE_READY:
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:
return (RELAY_ESC_SIDE_VOLTAGE < 5000) ? STATE_INACTIVE : STATE_DISCHARGE;
case STATE_PRECHARGE: // if CAN Signal 1000 0000 then get ready
return STATE_PRECHARGE;
case STATE_INACTIVE:
return STATE_INACTIVE;
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){
return tmp1075_temps[id];
void sm_precharge_discharge_manager(){
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){
return module.cellVoltages[id];
// source 0 -> sm_update()
// 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];