updated the state_machine and added it to main

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  
+  STATE_INACTIVE,       // INACTIVE   ->  PRECHARGE, CHARGING, ERROR  
-  PRECHARGE,      // PRECHARGE  ->  INACTIVE, READY, DISCHARGE, ERROR
+  STATE_PRECHARGE,      // PRECHARGE  ->  INACTIVE, READY, DISCHARGE, ERROR
-  READY,          // READY      ->  ACTIVE, DISCHARGE, ERROR
+  STATE_READY,          // READY      ->  ACTIVE, DISCHARGE, ERROR
-  ACTIVE,         // ACTIVE     ->  READY, DISCHARGE, ERROR
+  STATE_ACTIVE,         // ACTIVE     ->  READY, DISCHARGE, ERROR
-  DISCHARGE,      // DISCHARGE  ->  INACTIVE, PRECHARGE, ERROR
+  STATE_DISCHARGE,      // DISCHARGE  ->  INACTIVE, PRECHARGE, ERROR
-  CHARGING,       // CHARGING   ->  INACTIVE, DISCHARGE, ERROR
+  STATE_CHARGING,       // CHARGING   ->  INACTIVE, DISCHARGE, ERROR
-  ERROR,          // ERROR      ->  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_set_relay(Relay relay, bool closed);
-void sm_check_close_wait(int *is_closed, int should_close);
+void sm_check_precharge_discharge(int *is_closed, int should_close);
 
 void sm_handle_ams_in(const uint8_t *data);
 

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.current_state = STATE_INACTIVE;
-  state.target_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:
+  case STATE_CHARGING:
-    state.current_state = sm_update_charging();       // turn on cooling if needed, 
+    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:
+    case STATE_PRECHARGE:
-      break;
+      //close precharge relay, wait until both sides are similar
-    case CHARGING:
+      return STATE_PRECHARGE;
-      break;
+    case STATE_CHARGING:
+      return STATE_CHARGING;
+    default:
+      return STATE_INACTIVE;
   }
-  return INACTIVE;
 }
 
 State sm_update_precharge(){
   switch (state.target_state) {
-    case INACTIVE:
+    case STATE_INACTIVE:
-      break;
+      return STATE_INACTIVE;
-    case READY:
+    case STATE_READY:
-      break;
+      return STATE_READY;
-    case DISCHARGE:
+    case STATE_DISCHARGE:
-      break;
+      return STATE_DISCHARGE;
+    default:
+      return STATE_PRECHARGE;
   }
-  return PRECHARGE;
 }
 
 State sm_update_ready(){
   switch (state.target_state) {
-    case ACTIVE:
+    case STATE_ACTIVE:
-      break;
+      return STATE_ACTIVE;
-    case DISCHARGE:
+    case STATE_DISCHARGE:
-      break;
+      return STATE_DISCHARGE;
+    default:
+      return STATE_READY;
   }
-  return READY;
 }
 
 State sm_update_active(){
   switch (state.target_state) {
-    case READY:
+    case STATE_READY:
-      break;
+      return STATE_READY;
-    case DISCHARGE:
+    case STATE_DISCHARGE:
-      break;
+      return STATE_DISCHARGE;
+    default:
+      return STATE_ACTIVE;
   }
-  return ACTIVE;
 }
 
 State sm_update_discharge(){
   switch (state.target_state) {
-    case INACTIVE:
+    case STATE_INACTIVE:
-      break;
+      return STATE_INACTIVE;
-    case PRECHARGE:
+    case STATE_PRECHARGE:
-      break;
+      return STATE_PRECHARGE;
+    default: 
+      return STATE_DISCHARGE;
   }
-  return DISCHARGE;
 }
 
 State sm_update_charging(){
   switch (state.target_state) {
-    case INACTIVE:
+    case STATE_INACTIVE:
-      break;
+      return STATE_INACTIVE;
-    case DISCHARGE:
+    case STATE_DISCHARGE:
-      break;
+      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){
+void sm_set_relay(Relay relay, bool closed){
-  return;
-}
-/*
-void sm_set_relay(Relay relay, int closed){
-  static int closed = 0;
-  static int precharge_closed = 0;
-
   GPIO_PinState state = closed ? GPIO_PIN_SET : GPIO_PIN_RESET;
   switch (relay) {
-  case RELAY_POS:
+  case RELAY_MAIN:
-    ts_sm_check_close_wait(&closed, closed);
     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);