From fe3bcb6ebb897e81ab6661cda864eedd7463f3ba Mon Sep 17 00:00:00 2001 From: hamza Date: Thu, 23 May 2024 22:41:21 +0300 Subject: [PATCH] updated the state_machine and added it to main --- Core/Inc/state_machine.h | 20 ++--- Core/Src/state_machine.c | 172 ++++++++++++++++++++++++--------------- 2 files changed, 118 insertions(+), 74 deletions(-) diff --git a/Core/Inc/state_machine.h b/Core/Inc/state_machine.h index 2240194..a0a5214 100644 --- a/Core/Inc/state_machine.h +++ b/Core/Inc/state_machine.h @@ -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); diff --git a/Core/Src/state_machine.c b/Core/Src/state_machine.c index 24a48dc..661f54c 100644 --- a/Core/Src/state_machine.c +++ b/Core/Src/state_machine.c @@ -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); \ No newline at end of file +void sm_handle_ams_in(const uint8_t *data){} + +void sm_set_error(ErrorKind error_kind, bool is_errored); \ No newline at end of file