first soap ideals

untested. Maybe revert to Jaspers Version

.gitignore

@@ -3,3 +3,4 @@
 /.cache/
 .clangd
 TouchGFX/build
+.gitmodules

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "Core/Lib/can-halal"]
 	path = Core/Lib/can-halal
-	url = ssh://git@git.fasttube.de:313/FaSTTUBe/can-halal.git
+	url = https://git.fasttube.de/FaSTTUBe/can-halal.git

Core/Inc/can.h

@@ -5,10 +5,13 @@
 #include "stm32f3xx_hal_can.h"
 #include "stm32f3xx_hal_def.h"
 
+#include "ts_state_machine.h"
+
 #define CAN_ID_SLAVE_PANIC 0x009
 #define CAN_ID_AMS_STATUS 0x00A
 #define CAN_ID_AMS_IN 0x00B
-#define CAN_ID_SLAVE_STATUS 0x014
+#define CAN_ID_AMS_ERROR 0x00C
+#define CAN_ID_SLAVE_STATUS_BASE 0x080
 #define CAN_ID_SLAVE_LOG 0x4F4
 #define CAN_ID_SHUNT_BASE 0x520
 #define CAN_ID_SHUNT_CURRENT 0x521
@@ -22,6 +25,7 @@
 
 void can_init(CAN_HandleTypeDef *handle);
 HAL_StatusTypeDef can_send_status();
+HAL_StatusTypeDef can_send_error(TSErrorKind kind, uint8_t arg);
 
 void ftcan_msg_received_cb(uint16_t id, size_t datalen, const uint8_t *data);
 

Core/Inc/main.h

@@ -41,7 +41,7 @@ extern "C" {
 
 /* Exported constants --------------------------------------------------------*/
 /* USER CODE BEGIN EC */
-
+extern int sdc_closed;
 /* USER CODE END EC */
 
 /* Exported macro ------------------------------------------------------------*/

Core/Inc/shunt_monitoring.h

@@ -5,12 +5,14 @@
 
 #include "stm32f3xx_hal.h"
 
-#define THRESH_OVERCURRENT 300000 // mA
+#define SHUNT_TIMEOUT 300               // ms
+#define SHUNT_THRESH_OVERCURRENT 300000 // mA
+#define SHUNT_THRESH_OVERTEMP 1000      // 1/10 °C
 
 typedef struct {
   int32_t current;
-  int32_t voltage1;
-  int32_t voltage2;
+  int32_t voltage_bat;
+  int32_t voltage_veh;
   int32_t voltage3;
   int32_t busbartemp;
   int32_t power;
@@ -26,4 +28,6 @@ void shunt_check();
 
 void shunt_handle_can_msg(uint16_t id, const uint8_t *data);
 
+int32_t shunt_getcurrent();
+
 #endif // INC_SHUNT_MONITORING_H

Core/Inc/slave_monitoring.h

@@ -49,5 +49,6 @@ void slaves_check();
 void slaves_handle_panic(const uint8_t *data);
 void slaves_handle_status(const uint8_t *data);
 void slaves_handle_log(const uint8_t *data);
+uint16_t slaves_get_minimum_voltage();
 
 #endif // INC_SLAVE_MONITORING_H

Core/Inc/soc_estimation.h

@@ -5,7 +5,14 @@
 
 extern uint8_t current_soc;
 
+
+#define N_MODELPARAMETERS 11
+#define BATTERYCAPACITYAs (20000.0*3600) //TODO Check if value is correct Cap in Ah * 3600 (Convert to As)
+#define SOAP_MINIMUM_VOLTAGE 2.5
+
 void soc_init();
-void soc_update();
+void soc_update(int32_t shunt_current);
+float soe_update();
+void soap_update();
 
 #endif // INC_SOC_ESTIMATION_H

Core/Inc/ts_state_machine.h

@@ -8,7 +8,8 @@
 // Minimum vehicle side voltage to exit precharge
 #define MIN_VEHICLE_SIDE_VOLTAGE 150000 // mV
 // Time to wait after reaching 95% of battery voltage before exiting precharge
-#define PRECHARGE_95_DURATION 500 // ms
+// Set this to 1000 in scruti to demonstrate the voltage on the multimeter
+#define PRECHARGE_95_DURATION 0 // ms
 // Time to wait for discharge
 #define DISCHARGE_DURATION 5000 // ms
 // Time to wait after there is no more error condition before exiting TS_ERROR
@@ -28,6 +29,14 @@ typedef enum {
   TS_CHARGING
 } TSState;
 
+typedef enum {
+  TS_ERRORKIND_NONE = 0x00,
+  TS_ERRORKIND_SLAVE_TIMEOUT = 0x01,
+  TS_ERRORKIND_SLAVE_PANIC = 0x02,
+  TS_ERRORKIND_SHUNT_TIMEOUT = 0x03,
+  TS_ERRORKIND_SHUNT_OVERCURRENT = 0x04,
+  TS_ERRORKIND_SHUNT_OVERTEMP = 0x05
+} TSErrorKind;
 #define TS_ERROR_SOURCE_SHUNT (1 << 0)
 #define TS_ERROR_SOURCE_SLAVES (1 << 1)
 

Core/Src/can.c

@@ -15,31 +15,38 @@ void can_init(CAN_HandleTypeDef *handle) {
   ftcan_add_filter(CAN_ID_SHUNT_BASE, 0xFF0);
   ftcan_add_filter(CAN_ID_AMS_IN, 0xFFF);
   ftcan_add_filter(CAN_ID_SLAVE_PANIC, 0xFFF);
-  ftcan_add_filter(CAN_ID_SLAVE_STATUS, 0xFFF);
+  ftcan_add_filter(CAN_ID_SLAVE_STATUS_BASE, 0xFF0);
   ftcan_add_filter(CAN_ID_SLAVE_LOG, 0xFFF);
 }
 
 HAL_StatusTypeDef can_send_status() {
   uint8_t data[6];
-  data[0] = ts_state.current_state;
+  data[0] = ts_state.current_state | (sdc_closed << 7);
   data[1] = current_soc;
   ftcan_marshal_unsigned(&data[2], min_voltage, 2);
   ftcan_marshal_signed(&data[4], max_temp, 2);
   return ftcan_transmit(CAN_ID_AMS_STATUS, data, sizeof(data));
 }
 
+HAL_StatusTypeDef can_send_error(TSErrorKind kind, uint8_t arg) {
+  uint8_t data[2];
+  data[0] = kind;
+  data[1] = arg;
+  return ftcan_transmit(CAN_ID_AMS_ERROR, data, sizeof(data));
+}
+
 void ftcan_msg_received_cb(uint16_t id, size_t datalen, const uint8_t *data) {
   if ((id & 0xFF0) == CAN_ID_SHUNT_BASE) {
     shunt_handle_can_msg(id, data);
     return;
+  } else if ((id & 0xFF0) == CAN_ID_SLAVE_STATUS_BASE) {
+    slaves_handle_status(data);
+    return;
   }
   switch (id) {
   case CAN_ID_SLAVE_PANIC:
     slaves_handle_panic(data);
     break;
-  case CAN_ID_SLAVE_STATUS:
-    slaves_handle_status(data);
-    break;
   case CAN_ID_SLAVE_LOG:
     slaves_handle_log(data);
     break;

Core/Src/main.c

@@ -50,12 +50,13 @@
 /* Private variables ---------------------------------------------------------*/
 ADC_HandleTypeDef hadc2;
 
+
 CAN_HandleTypeDef hcan;
 
 UART_HandleTypeDef huart1;
 
 /* USER CODE BEGIN PV */
-
+int sdc_closed = 0;
 /* USER CODE END PV */
 
 /* Private function prototypes -----------------------------------------------*/
@@ -70,7 +71,19 @@ static void MX_USART1_UART_Init(void);
 
 /* Private user code ---------------------------------------------------------*/
 /* USER CODE BEGIN 0 */
+#define MAIN_LOOP_PERIOD 50
 
+static void loop_delay() {
+  static uint32_t last_loop = 0;
+  uint32_t dt = HAL_GetTick() - last_loop;
+  if (dt < MAIN_LOOP_PERIOD) {
+    HAL_Delay(MAIN_LOOP_PERIOD - dt);
+    HAL_GPIO_WritePin(STATUS2_GPIO_Port, STATUS2_Pin, GPIO_PIN_RESET);
+  } else {
+    HAL_GPIO_WritePin(STATUS2_GPIO_Port, STATUS2_Pin, GPIO_PIN_SET);
+  }
+  last_loop = HAL_GetTick();
+}
 /* USER CODE END 0 */
 
 /**
@@ -79,7 +92,7 @@ static void MX_USART1_UART_Init(void);
  */
 int main(void) {
   /* USER CODE BEGIN 1 */
-
+  uint8_t soc_init_complete = 0;
   /* USER CODE END 1 */
 
   /* MCU Configuration--------------------------------------------------------*/
@@ -109,7 +122,6 @@ int main(void) {
   slaves_init();
   shunt_init();
   ts_sm_init();
-  soc_init();
   HAL_GPIO_WritePin(AMS_NERROR_GPIO_Port, AMS_NERROR_Pin, GPIO_PIN_SET);
   /* USER CODE END 2 */
 
@@ -120,14 +132,23 @@ int main(void) {
 
     /* USER CODE BEGIN 3 */
     HAL_GPIO_TogglePin(STATUS1_GPIO_Port, STATUS1_Pin);
+    sdc_closed = HAL_GPIO_ReadPin(SDC_VOLTAGE_GPIO_Port, SDC_VOLTAGE_Pin) ==
+                 GPIO_PIN_SET;
 
     slaves_check();
     shunt_check();
     ts_sm_update();
-    soc_update();
+    if(soc_init_complete){
+      soc_update(shunt_getcurrent());
+    }
+    else
+    {
+      soc_init();
+      soc_init_complete = 1;
+    }
     can_send_status();
+    loop_delay();
 
-    HAL_Delay(10);
   }
   /* USER CODE END 3 */
 }

Core/Src/shunt_monitoring.c

@@ -12,8 +12,8 @@ ShuntData shunt_data;
 
 void shunt_init() {
   shunt_data.current = 0;
-  shunt_data.voltage1 = 0;
-  shunt_data.voltage2 = 0;
+  shunt_data.voltage_veh = 0;
+  shunt_data.voltage_bat = 0;
   shunt_data.voltage3 = 0;
   shunt_data.busbartemp = 0;
   shunt_data.power = 0;
@@ -23,11 +23,23 @@ void shunt_init() {
 }
 
 void shunt_check() {
-  int is_error = shunt_data.current >= THRESH_OVERCURRENT;
+  int is_error = 0;
+  if (HAL_GetTick() - shunt_data.last_message > SHUNT_TIMEOUT) {
+    is_error = 1;
+    can_send_error(TS_ERRORKIND_SHUNT_TIMEOUT, 0);
+  } else if (shunt_data.current >= SHUNT_THRESH_OVERCURRENT) {
+    is_error = 1;
+    can_send_error(TS_ERRORKIND_SHUNT_OVERTEMP, 0);
+  } else if (shunt_data.busbartemp >= SHUNT_THRESH_OVERTEMP) {
+    is_error = 1;
+    can_send_error(TS_ERRORKIND_SHUNT_OVERTEMP, 0);
+  }
   ts_sm_set_error_source(TS_ERROR_SOURCE_SHUNT, is_error);
 }
 
 void shunt_handle_can_msg(uint16_t id, const uint8_t *data) {
+  shunt_data.last_message = HAL_GetTick();
+
   // All result messages contain a big-endian 6-byte integer
   uint64_t result = ftcan_unmarshal_unsigned(&data, 6);
 
@@ -36,10 +48,10 @@ void shunt_handle_can_msg(uint16_t id, const uint8_t *data) {
     shunt_data.current = result;
     break;
   case CAN_ID_SHUNT_VOLTAGE1:
-    shunt_data.voltage1 = result;
+    shunt_data.voltage_bat = result;
     break;
   case CAN_ID_SHUNT_VOLTAGE2:
-    shunt_data.voltage2 = result;
+    shunt_data.voltage_veh = result;
     break;
   case CAN_ID_SHUNT_VOLTAGE3:
     shunt_data.voltage3 = result;
@@ -58,3 +70,8 @@ void shunt_handle_can_msg(uint16_t id, const uint8_t *data) {
     break;
   }
 }
+
+int32_t shunt_getcurrent()
+{
+  return shunt_data.current;
+}

Core/Src/slave_monitoring.c

@@ -1,5 +1,6 @@
 #include "slave_monitoring.h"
 
+#include "can.h"
 #include "main.h"
 #include "ts_state_machine.h"
 
@@ -60,14 +61,18 @@ void slaves_check() {
   uint16_t min_voltage_new = 0xFFFF;
   int16_t max_temp_new = 0xFFFF;
   for (int i = 0; i < N_SLAVES; i++) {
+    // Update timeout errors
     if (now - slaves[i].last_message >= SLAVE_TIMEOUT) {
       // Don't overwrite a different error kind
       if (slaves[i].error.kind == SLAVE_ERR_NONE) {
         slaves[i].error.kind = SLAVE_ERR_TIMEOUT;
+        can_send_error(TS_ERRORKIND_SLAVE_TIMEOUT, slaves[i].id);
       }
     } else if (slaves[i].error.kind == SLAVE_ERR_TIMEOUT) {
       slaves[i].error.kind = SLAVE_ERR_NONE;
     }
+
+    // Determine min/max
     if (slaves[i].min_voltage < min_voltage_new) {
       min_voltage_new = slaves[i].min_voltage;
     }
@@ -82,9 +87,7 @@ void slaves_check() {
   min_voltage = min_voltage_new;
   max_temp = max_temp_new;
 
-  if (any_slave_error) {
-    ts_sm_set_error_source(TS_ERROR_SOURCE_SLAVES, 1);
-  }
+  ts_sm_set_error_source(TS_ERROR_SOURCE_SLAVES, any_slave_error);
 }
 
 void slaves_handle_panic(const uint8_t *data) {
@@ -107,6 +110,8 @@ void slaves_handle_panic(const uint8_t *data) {
   }
   slaves[idx].error.data = ftcan_unmarshal_unsigned(&data, 4);
   slaves[idx].last_message = HAL_GetTick();
+  ts_sm_set_error_source(TS_ERROR_SOURCE_SLAVES, 1);
+  can_send_error(TS_ERRORKIND_SLAVE_PANIC, slave_id);
 }
 
 void slaves_handle_status(const uint8_t *data) {
@@ -131,3 +136,14 @@ void slaves_handle_status(const uint8_t *data) {
 void slaves_handle_log(const uint8_t *data) {
   // TODO
 }
+
+uint16_t slaves_get_minimum_voltage()
+{
+  uint16_t minvoltage = 50000;
+  for(uint8_t idx = 0; idx < N_SLAVES;idx++){
+    if(slaves->min_voltage < minvoltage){
+      min_voltage = slaves->min_voltage;
+    }
+  }
+  return minvoltage;
+}

Core/Src/soc_estimation.c

@@ -1,14 +1,118 @@
 #include "soc_estimation.h"
 
 #include <stdint.h>
+#include "slave_monitoring.h"
+#include "stm32f3xx_hal.h"
 
+
+//------------------------------------Battery RC and OCV-SoC Parameters-----------------------------------------
+//@Note Parameters were obtained by EIS Measurements at the start of the season
+//If the errror with this values is to large, consider retesting some cells
+const float SOC[N_MODELPARAMETERS]={0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1};
+const float R0[N_MODELPARAMETERS]={0.0089,0.0087,0.0090,0.0087,0.0087,0.0087,0.0088,0.0088,0.0087,0.0088,0.0089};
+const float R1[N_MODELPARAMETERS]={0.0164,0.0063,0.0050,0.0055,0.0051,0.0052,0.0057,0.0048,0.0059,0.0055,0.0061};
+const float C1[N_MODELPARAMETERS]={2.5694,0.2649,0.2876,0.2594,0.2415,0.2360,0.2946,0.2558,0.2818,0.2605,0.2763};
+const float OCV_Data[N_MODELPARAMETERS]={2.762504,3.326231,3.460875,3.57681,3.655326,3.738444,3.835977,3.925841,4.032575,4.078275,4.191449};
+const float SOE_Data[N_MODELPARAMETERS]={0.0,0.079358,0.165140,0.256008,0.348836,0.445961,0.549115,0.655642,0.769677,0.875699,1.0};
+//---------------------------------------------------------------------------------------------------------------
+
+
+
+float soc_approxparameterbysoc(float,float*, uint8_t);
+float soc_approxsocbyocv(float);
 uint8_t current_soc;
+float current_floatsoc;
 
+float batterycapacity;
+
+
+/**
+ * @brief This Function initializes the SoC Prediction
+ * @note Because SoC is initalized using the OCV-Curve of the Cell, it is necessary to obtain a valid value
+ * for the lowest cell voltage before calling this function
+ */
 void soc_init() {
-  current_soc = 0;
-  // TODO
+  float minvoltage = ((float)slaves_get_minimum_voltage())/1000;
+  current_floatsoc = soc_approxsocbyocv(minvoltage);
+  batterycapacity = BATTERYCAPACITYAs*current_floatsoc;
+  current_soc = (uint8_t)(current_floatsoc*100);
 }
 
-void soc_update() {
+/**
+ * @brief Update Function for the State of Charge. Call this Function every time the shunt sends a new current
+ * @note The SoC Prediction works using a Coulomb Counter to track the SoC. Alternativly and maybe more elegant
+ * would be to track the SoC using the integrated current counter of the shunt.
+ * @param shunt_current 
+ */
+void soc_update(int32_t shunt_current) {
   // TODO
+  static uint32_t lasttick = 0;
+
+  if(lasttick != 0)
+  {
+    uint32_t dt = HAL_GetTick() - lasttick;
+    batterycapacity += batterycapacity + ((float) dt*shunt_current)/1000;
+    current_floatsoc = batterycapacity/BATTERYCAPACITYAs;
+    current_soc = (uint8_t) (current_floatsoc*100);
+  }
+  
+  lasttick=HAL_GetTick();
+
 }
+
+float soe_update()
+{
+  return soc_approxparameterbysoc(current_floatsoc, SOE_Data, N_MODELPARAMETERS);
+}
+void soap_update()
+{
+  float r0 = soc_approxparameterbysoc(current_floatsoc, R0, N_MODELPARAMETERS);
+  float r1 = soc_approxparameterbysoc(current_floatsoc, R1, N_MODELPARAMETERS);
+  float ocv = soc_approxparameterbysoc(current_floatsoc, OCV_Data, N_MODELPARAMETERS);
+
+  float allowedvoltagedrop = ocv - SOAP_MINIMUM_VOLTAGE;
+  float rin = r0+r1;
+  float maxcurrent = allowedvoltagedrop/rin;
+  //TODO think about how to pass parameters
+
+}
+
+float soc_approxparameterbysoc(float soc,float* lut, uint8_t lutlen)
+{
+  
+  uint8_t idx = (uint8_t) (soc*(lutlen-1));
+
+  if(idx == (lutlen-1))
+    return lut[lutlen-1];
+
+  float linapprox = 10*(soc-(((float)idx)/((float)(lutlen-1))))*(lut[idx+1]-lut[idx]);
+  linapprox += lut[idx];
+  return linapprox;
+}
+
+float soc_approxsocbyocv(float ocv)
+{
+
+  if(ocv < OCV_Data[0])
+    return 0;
+
+  if(ocv > OCV_Data[N_MODELPARAMETERS])
+    return 1;
+  //Iterate through OCV Lookup
+  uint8_t ocvindex = 0;
+  for(uint8_t i = 0; i < (N_MODELPARAMETERS-1);i++)
+  {
+    if((OCV_Data[i] <= ocv) && (OCV_Data[i+1] > ocv))
+    {
+      ocvindex = i;
+    }
+  }
+  
+  float m = (ocv-OCV_Data[ocvindex])/(OCV_Data[ocvindex+1]-OCV_Data[ocvindex]);
+  
+  float soc = (SOC[ocvindex+1] - SOC[ocvindex])*m + SOC[ocvindex];
+
+  return soc;
+  
+
+}

Core/Src/ts_state_machine.c

@@ -52,18 +52,26 @@ void ts_sm_update() {
 
 TSState ts_sm_update_inactive() {
   if (ts_state.target_state == TS_ACTIVE) {
-    precharge_95_reached_timestamp = 0;
-    return TS_PRECHARGE;
+    if (sdc_closed) {
+      precharge_95_reached_timestamp = 0;
+      return TS_PRECHARGE;
+    } else {
+      return TS_DISCHARGE;
+    }
   } else if (ts_state.target_state == TS_CHARGING) {
-    charging_check_timestamp = HAL_GetTick();
-    return TS_CHARGING_CHECK;
+    if (sdc_closed) {
+      charging_check_timestamp = HAL_GetTick();
+      return TS_CHARGING_CHECK;
+    } else {
+      return TS_DISCHARGE;
+    }
   }
 
   return TS_INACTIVE;
 }
 
 TSState ts_sm_update_active() {
-  if (ts_state.target_state == TS_INACTIVE) {
+  if (ts_state.target_state == TS_INACTIVE || !sdc_closed) {
     discharge_begin_timestamp = HAL_GetTick();
     return TS_DISCHARGE;
   }
@@ -72,12 +80,12 @@ TSState ts_sm_update_active() {
 }
 
 TSState ts_sm_update_precharge() {
-  if (ts_state.target_state == TS_INACTIVE) {
+  if (ts_state.target_state == TS_INACTIVE || !sdc_closed) {
     discharge_begin_timestamp = HAL_GetTick();
     return TS_DISCHARGE;
   }
-  if (shunt_data.voltage2 > MIN_VEHICLE_SIDE_VOLTAGE &&
-      shunt_data.voltage2 > 0.95 * shunt_data.voltage3) {
+  if (shunt_data.voltage_veh > MIN_VEHICLE_SIDE_VOLTAGE &&
+      shunt_data.voltage_veh > 0.95 * shunt_data.voltage_bat) {
     uint32_t now = HAL_GetTick();
     if (precharge_95_reached_timestamp == 0) {
       precharge_95_reached_timestamp = now;
@@ -106,20 +114,22 @@ TSState ts_sm_update_error() {
       no_error_since = now;
     } else if (now - no_error_since > NO_ERROR_TIME) {
       no_error_since = 0;
+      HAL_GPIO_WritePin(AMS_NERROR_GPIO_Port, AMS_NERROR_Pin, GPIO_PIN_SET);
       return TS_INACTIVE;
     }
   }
 
+  HAL_GPIO_WritePin(AMS_NERROR_GPIO_Port, AMS_NERROR_Pin, GPIO_PIN_RESET);
   return TS_ERROR;
 }
 
 TSState ts_sm_update_charging_check() {
-  if (ts_state.target_state == TS_INACTIVE) {
+  if (ts_state.target_state == TS_INACTIVE || !sdc_closed) {
     discharge_begin_timestamp = HAL_GetTick();
     return TS_DISCHARGE;
   }
 
-  if (shunt_data.voltage2 > shunt_data.voltage3) {
+  if (shunt_data.voltage_veh > shunt_data.voltage_bat) {
     return TS_CHARGING;
   } else if (HAL_GetTick() - charging_check_timestamp >
              MAX_CHARGING_CHECK_DURATION) {
@@ -130,7 +140,7 @@ TSState ts_sm_update_charging_check() {
 }
 
 TSState ts_sm_update_charging() {
-  if (ts_state.target_state == TS_INACTIVE) {
+  if (ts_state.target_state == TS_INACTIVE || !sdc_closed) {
     discharge_begin_timestamp = HAL_GetTick();
     return TS_DISCHARGE;
   }

STM32Make.make

@@ -85,7 +85,7 @@ PREFIX = arm-none-eabi-
 POSTFIX = "
 # The gcc compiler bin path can be either defined in make command via GCC_PATH variable (> make GCC_PATH=xxx)
 # either it can be added to the PATH environment variable.
-GCC_PATH="/home/jasper/.config/Code/User/globalStorage/bmd.stm32-for-vscode/@xpack-dev-tools/arm-none-eabi-gcc/11.3.1-1.1.2/.content/bin
+GCC_PATH="c:/Users/max/AppData/Roaming/Code/User/globalStorage/bmd.stm32-for-vscode/@xpack-dev-tools/arm-none-eabi-gcc/11.2.1-1.2.2/.content/bin
 ifdef GCC_PATH
 CXX = $(GCC_PATH)/$(PREFIX)g++$(POSTFIX)
 CC = $(GCC_PATH)/$(PREFIX)gcc$(POSTFIX)
@@ -241,19 +241,19 @@ $(BUILD_DIR):
 # flash
 #######################################
 flash: $(BUILD_DIR)/$(TARGET).elf
-	"/home/jasper/.config/Code/User/globalStorage/bmd.stm32-for-vscode/@xpack-dev-tools/openocd/0.11.0-5.1/.content/bin/openocd" -f ./openocd.cfg -c "program $(BUILD_DIR)/$(TARGET).elf verify reset exit"
+	"C:/USERS/MAX/APPDATA/ROAMING/CODE/USER/GLOBALSTORAGE/BMD.STM32-FOR-VSCODE/@XPACK-DEV-TOOLS/OPENOCD/0.11.0-4.1/.CONTENT/BIN/OPENOCD.EXE" -f ./openocd.cfg -c "program $(BUILD_DIR)/$(TARGET).elf verify reset exit"
 
 #######################################
 # erase
 #######################################
 erase: $(BUILD_DIR)/$(TARGET).elf
-	"/home/jasper/.config/Code/User/globalStorage/bmd.stm32-for-vscode/@xpack-dev-tools/openocd/0.11.0-5.1/.content/bin/openocd" -f ./openocd.cfg -c "init; reset halt; stm32f3x mass_erase 0; exit"
+	"C:/USERS/MAX/APPDATA/ROAMING/CODE/USER/GLOBALSTORAGE/BMD.STM32-FOR-VSCODE/@XPACK-DEV-TOOLS/OPENOCD/0.11.0-4.1/.CONTENT/BIN/OPENOCD.EXE" -f ./openocd.cfg -c "init; reset halt; stm32f3x mass_erase 0; exit"
 
 #######################################
 # clean up
 #######################################
 clean:
-	-rm -fR $(BUILD_DIR)
+	cmd /c rd /s /q $(BUILD_DIR)
 
 #######################################
 # custom makefile rules