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

updated the state_machine and added it to main

Browse Source
This commit is contained in:
Hamza Tamim 2024-05-23 22:41:21 +03:00
parent 665d1ffed6
commit fe3bcb6ebb
2 changed files with 118 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
Core/Inc/state_machine.h
View File

@ -17,13 +17,13 @@
#define RELAY_CLOSE_WAIT 10 // ms
typedef enum { // valid transitions: (all could transition to error)
INACTIVE, // INACTIVE -> PRECHARGE, CHARGING, ERROR
PRECHARGE, // PRECHARGE -> INACTIVE, READY, DISCHARGE, ERROR
READY, // READY -> ACTIVE, DISCHARGE, ERROR
ACTIVE, // ACTIVE -> READY, DISCHARGE, ERROR
DISCHARGE, // DISCHARGE -> INACTIVE, PRECHARGE, ERROR
CHARGING, // CHARGING -> INACTIVE, DISCHARGE, ERROR
ERROR, // ERROR -> INACTIVE, DISCHARGE, ERROR
STATE_INACTIVE, // INACTIVE -> PRECHARGE, CHARGING, ERROR
STATE_PRECHARGE, // PRECHARGE -> INACTIVE, READY, DISCHARGE, ERROR
STATE_READY, // READY -> ACTIVE, DISCHARGE, ERROR
STATE_ACTIVE, // ACTIVE -> READY, DISCHARGE, ERROR
STATE_DISCHARGE, // DISCHARGE -> INACTIVE, PRECHARGE, ERROR
STATE_CHARGING, // CHARGING -> INACTIVE, DISCHARGE, ERROR
STATE_ERROR, // ERROR -> INACTIVE, DISCHARGE, ERROR
} State;
typedef struct {
@ -60,10 +60,10 @@ State sm_update_discharge();
State sm_update_charging();
State sm_update_error();
typedef enum { RELAY_POS, RELAY_PRECHARGE } Relay;
typedef enum { RELAY_MAIN, RELAY_PRECHARGE } Relay;
void sm_set_relay_positions(State state);
void sm_set_relay_position(Relay relay, int closed);
void sm_check_close_wait(int *is_closed, int should_close);
void sm_set_relay(Relay relay, bool closed);
void sm_check_precharge_discharge(int *is_closed, int should_close);
void sm_handle_ams_in(const uint8_t *data);

172
Core/Src/state_machine.c
View File

@ -1,39 +1,48 @@
#include "state_machine.h"
#include "ADBMS_LL_Driver.h"
#include "AMS_HighLevel.h"
#include "stm32f3xx_hal.h"
#include "ADBMS_Abstraction.h"
#include "main.h"
StateHandle state;
static bool relay_closed = 0;
static bool precharge_closed = 0;
static int16_t RELAY_BAT_SIDE;
static int16_t RELAY_ESC_SIDE;
static int16_t CURRENT_MEASUREMENT;
void sm_init(){
state.current_state = INACTIVE;
state.target_state = INACTIVE;
state.current_state = STATE_INACTIVE;
state.target_state = STATE_INACTIVE;
state.error_source = 0;
RELAY_BAT_SIDE = 0;
RELAY_ESC_SIDE = 0;
CURRENT_MEASUREMENT = 0;
}
void sm_update(){
if (state.error_source) {
state.current_state = ERROR;
}
switch (state.current_state) {
case INACTIVE:
case STATE_INACTIVE:
state.current_state = sm_update_inactive(); // moniter only
break;
case PRECHARGE:
case STATE_PRECHARGE:
state.current_state = sm_update_precharge(); // set PRECHARGE and turn on cooling at 50% or such
break;
case READY:
case STATE_READY:
state.current_state = sm_update_ready(); // keep cooling at 50%, get ready to turn on powerground
break;
case ACTIVE:
case STATE_ACTIVE:
state.current_state = sm_update_active(); // set PRECHARGE and turn on cooling at 50% or such
break;
case DISCHARGE:
case STATE_DISCHARGE:
state.current_state = sm_update_discharge(); // open the main relay, keep PRECHARGE closed
break;
case CHARGING:
state.current_state = sm_update_charging(); // turn on cooling if needed,
case STATE_CHARGING:
state.current_state = sm_update_charging(); // monitor and turn on cooling if needed.
break;
case ERROR:
case STATE_ERROR:
state.current_state = sm_update_error(); // enter the correct ERROR state
break;
}
@ -44,100 +53,135 @@ void sm_update(){
State sm_update_inactive(){
switch (state.target_state) {
case PRECHARGE:
break;
case CHARGING:
break;
case STATE_PRECHARGE:
//close precharge relay, wait until both sides are similar
return STATE_PRECHARGE;
case STATE_CHARGING:
return STATE_CHARGING;
default:
return STATE_INACTIVE;
}
return INACTIVE;
}
State sm_update_precharge(){
switch (state.target_state) {
case INACTIVE:
break;
case READY:
break;
case DISCHARGE:
break;
case STATE_INACTIVE:
return STATE_INACTIVE;
case STATE_READY:
return STATE_READY;
case STATE_DISCHARGE:
return STATE_DISCHARGE;
default:
return STATE_PRECHARGE;
}
return PRECHARGE;
}
State sm_update_ready(){
switch (state.target_state) {
case ACTIVE:
break;
case DISCHARGE:
break;
case STATE_ACTIVE:
return STATE_ACTIVE;
case STATE_DISCHARGE:
return STATE_DISCHARGE;
default:
return STATE_READY;
}
return READY;
}
State sm_update_active(){
switch (state.target_state) {
case READY:
break;
case DISCHARGE:
break;
case STATE_READY:
return STATE_READY;
case STATE_DISCHARGE:
return STATE_DISCHARGE;
default:
return STATE_ACTIVE;
}
return ACTIVE;
}
State sm_update_discharge(){
switch (state.target_state) {
case INACTIVE:
break;
case PRECHARGE:
break;
case STATE_INACTIVE:
return STATE_INACTIVE;
case STATE_PRECHARGE:
return STATE_PRECHARGE;
default:
return STATE_DISCHARGE;
}
return DISCHARGE;
}
State sm_update_charging(){
switch (state.target_state) {
case INACTIVE:
break;
case DISCHARGE:
break;
case STATE_INACTIVE:
return STATE_INACTIVE;
case STATE_DISCHARGE:
return STATE_DISCHARGE;
default:
return STATE_CHARGING;
}
return CHARGING;
}
State sm_update_error(){
switch (state.target_state) {
case INACTIVE:
case STATE_INACTIVE:
return STATE_INACTIVE;
case STATE_DISCHARGE:
return STATE_DISCHARGE;
default:
return STATE_ERROR;
}
}
void sm_set_relay_positions(State current_state){
switch (state.target_state) {
case STATE_INACTIVE:
sm_set_relay(RELAY_MAIN, 0);
sm_set_relay(RELAY_PRECHARGE, 0);
break;
case DISCHARGE:
case STATE_PRECHARGE:
sm_set_relay(RELAY_MAIN, 0);
sm_set_relay(RELAY_PRECHARGE, 1);
break;
case STATE_READY:
sm_set_relay(RELAY_MAIN, 1);
sm_set_relay(RELAY_PRECHARGE, 0);
break;
case STATE_ACTIVE:
sm_set_relay(RELAY_MAIN, 1);
sm_set_relay(RELAY_PRECHARGE, 0);
case STATE_DISCHARGE:
sm_set_relay(RELAY_MAIN, 0);
sm_set_relay(RELAY_PRECHARGE, 1);
break;
case STATE_CHARGING:
sm_set_relay(RELAY_MAIN, 1);
sm_set_relay(RELAY_PRECHARGE, 1);
break;
case STATE_ERROR:
sm_set_relay(RELAY_MAIN, 0);
break;
}
return ERROR;
}
void sm_set_relay_positions(State state){
return;
}
/*
void sm_set_relay(Relay relay, int closed){
static int closed = 0;
static int precharge_closed = 0;
void sm_set_relay(Relay relay, bool closed){
GPIO_PinState state = closed ? GPIO_PIN_SET : GPIO_PIN_RESET;
switch (relay) {
case RELAY_POS:
ts_sm_check_close_wait(&closed, closed);
case RELAY_MAIN:
HAL_GPIO_WritePin(RELAY_EN_GPIO_Port, RELAY_EN_Pin, state);
relay_closed = closed;
break;
case RELAY_PRECHARGE:
ts_sm_check_close_wait(&precharge_closed, closed);
HAL_GPIO_WritePin(PRECHARGE_EN_GPIO_Port, PRECHARGE_EN_Pin, state);
precharge_closed = closed;
break;
}
}
*/
//void sm_check_close_wait(int *is_closed, int should_close);
//void sm_handle_ams_in(const uint8_t *data);
void sm_check_precharge_discharge(int *is_closed, int should_close){}
// compare RELAY_BATT_SIDE and RELAY_ESC_SIDE
// if (state.current_state == STATE_PRECHARGE && (RELAY_ESC_SIDE < RELAY_BAT_SIDE)) //-> don't switch from PRECHARGE to READY
// if (state.current_state == STATE_DISCHARGE && (RELAY_ESC_SIDE > 12V)) -> don't switch from DISCHARGE to INACTIVE
//void sm_set_error(ErrorKind error_kind, bool is_errored);
void sm_handle_ams_in(const uint8_t *data){}
void sm_set_error(ErrorKind error_kind, bool is_errored);