Changeset 29 for trunk/firmware_v2


Ignore:
Timestamp:
Nov 1, 2025, 5:04:26 PM (30 hours ago)
Author:
f.jahn
Message:
  • Auto Restart mode implementiert
  • IWDG implementiert
  • 24V Kompiler Version implementiert
Location:
trunk/firmware_v2
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/firmware_v2/Core/Src/adc.c

    r17 r29  
    6767  if (HAL_ADC_Init(&hadc1) != HAL_OK)
    6868  {
    69     Error_Handler();
     69          Error_Handler();
    7070  }
    7171

  • trunk/firmware_v2/SES/PowerPro.emProject

    r28 r29  
    5757    <configuration
    5858      Name="Debug_24V"
    59       c_preprocessor_definitions="SYSTEM_VOLTAGE_24V" />
     59      c_preprocessor_definitions="SYSTEM_VOLTAGE_24V"
     60      gcc_optimization_level="Debug" />
    6061    <configuration
    6162      Name="Debug_48V"

  • trunk/firmware_v2/SES/inc/button.h

    r17 r29  
    1616button_state_t BUTTON_GetMode(void);
    1717void BUTTON_SetModeOff(void);
     18void BUTTON_SetModeAuto(void);
    1819
    1920#endif

  • trunk/firmware_v2/SES/inc/mode_secondaryprotection.h

    r17 r29  
    22#define __MODE_SECONDARYPROTECTION_H
    33
    4 void MODE_SECONDARYPROTECTION_Exec(void);
     4void MODE_SECONDARYPROTECTION_Exec(int am);
    55
    66

  • trunk/firmware_v2/SES/inc/mode_secondaryprotection_plus.h

    r17 r29  
    22#define __MODE_SECONDARYPROTECTION_PLUS_H
    33
    4 void MODE_SECONDARYPROTECTION_PLUS_Exec(void);
     4void MODE_SECONDARYPROTECTION_PLUS_Exec(int am);
    55
    66

  • trunk/firmware_v2/SES/inc/modeswitch.h

    r17 r29  
    88{
    99  MODE_MAINSWITCH = 0,
    10   MODE_MAINSWITCH_SECONDARYPROTECTION,
    11   MODE_MAINSWITCH_SECONDARYPROTECTION_PLUS,
    12   MODE_MAINSWITCH_LVP_OVP,
    13   MODE_MAINSWITCH_LVP,
    14   MODE_MAINSWITCH_OVP,
     10  MODE_MAINSWITCH_SECONDARYPROTECTION = 1,
     11  MODE_MAINSWITCH_SECONDARYPROTECTION_PLUS = 2,
     12  MODE_MAINSWITCH_SECONDARYPROTECTION_AUTO_RETRY = 3,
     13  MODE_MAINSWITCH_SECONDARYPROTECTION_PLUS_AUTO_RETRY = 4,
     14  MODE_MAINSWITCH_LVP_OVP = 5,
     15  MODE_MAINSWITCH_LVP = 6,
     16  MODE_MAINSWITCH_OVP = 7,
    1517 
    1618} MODESWITCH_mode_t;

  • trunk/firmware_v2/SES/src/button.c

    r17 r29  
    8383  buttonState = BUTTON_OFF;
    8484}
     85
     86void BUTTON_SetModeAuto(void)
     87{
     88  buttonState = BUTTON_AUTO;
     89}

  • trunk/firmware_v2/SES/src/main.c

    r28 r29  
    216216
    217217      case MODE_MAINSWITCH_SECONDARYPROTECTION://1
    218         MODE_SECONDARYPROTECTION_Exec();
     218        MODE_SECONDARYPROTECTION_Exec(0);
    219219      break;
    220220
    221221      case MODE_MAINSWITCH_SECONDARYPROTECTION_PLUS://2
    222         MODE_SECONDARYPROTECTION_PLUS_Exec();
    223       break;
    224 
    225           case MODE_MAINSWITCH_LVP_OVP://3
     222        MODE_SECONDARYPROTECTION_PLUS_Exec(0);
     223      break;
     224
     225      case MODE_MAINSWITCH_SECONDARYPROTECTION_AUTO_RETRY://3
     226        MODE_SECONDARYPROTECTION_Exec(1);
     227      break;
     228
     229      case MODE_MAINSWITCH_SECONDARYPROTECTION_PLUS_AUTO_RETRY://4
     230        MODE_SECONDARYPROTECTION_PLUS_Exec(1);
     231      break;
     232
     233          case MODE_MAINSWITCH_LVP_OVP://5
    226234        MODE_LVP_OVP_Exec();
    227235      break;
    228236
    229       case MODE_MAINSWITCH_LVP://4
     237      case MODE_MAINSWITCH_LVP://6
    230238        MODE_LVP_Exec();
    231239      break;
    232240
    233       case MODE_MAINSWITCH_OVP://5
     241      case MODE_MAINSWITCH_OVP://7
    234242        MODE_OVP_Exec();
    235243      break;

  • trunk/firmware_v2/SES/src/mode_secondaryprotection.c

    r28 r29  
    4141} SECONDARYPROTECTION_state_t;
    4242
     43typedef enum SECONDARYPROTECTION_ErrorState_enum
     44{
     45  ERROR_NONE,
     46  ERROR_EXTERNAL_FAULT, //z.B Kurzschluss
     47  ERROR_TEMPERATURE,
     48  ERROR_VOLTAGE_DROP,
     49  ERROR_LVP_AND_OVP,      //z.B. kritische Überspannung, tiefeEntladung
     50} SECONDARYPROTECTION_ErrorState_t;
     51
    4352
    4453static SECONDARYPROTECTION_state_t smState;
     54static SECONDARYPROTECTION_ErrorState_t smError;
     55static int autoRetryMode;
    4556
    4657
    … …  
    7990      printf("NEW_STATE: SECONDARYPROTECTION_ON\n");
    8091      smState = SECONDARYPROTECTION_ON;
     92          smError = ERROR_NONE;
    8193
    8294    }
    … …  
    90102      printf("NEW_STATE: SECONDARYPROTECTION_ERROR\n");
    91103      smState =SECONDARYPROTECTION_ERROR;
     104          smError = ERROR_EXTERNAL_FAULT;
    92105    }
    93106  }
    … …  
    105118      printf("NEW_STATE: SECONDARYPROTECTION_MANUAL_ON\n");
    106119      smState = SECONDARYPROTECTION_MANUAL_ON;
     120          smError = ERROR_NONE;
    107121  }
    108122
    … …  
    120134  if (HAL_GPIO_ReadPin(GPIO_INPUT_FAULT_GPIO_Port, GPIO_INPUT_FAULT_Pin) == GPIO_PIN_RESET)       
    121135  {   
    122         HAL_Delay(1); // Verzögerung 1ms damit eventuell noch zuerst durch smartPro der Strom gestoppt werden kann
    123         if (HAL_GPIO_ReadPin(GPIO_INPUT_FAULT_GPIO_Port, GPIO_INPUT_FAULT_Pin) == GPIO_PIN_RESET)       
    124         {
    125136          faultInput = 1;
    126         }
    127 
     137          RELAIS_ResetPuls();
     138      BUZZER_Beep(BUZZER_ON_TIME_REJECT); //Warnung
     139      LEDS_GN_Off();
     140      LEDS_RT_BlinkCode_Start(BLINK_CODE_ERROR_FAULT_INPUT, LED_RT_ON_TIME_WARN_FAULT_INPUT, LED_RT_OFF_TIME, LED_RT_OFF_TIME *5); //Fehler Anzeigen
     141      BUTTON_SetModeOff(); //Damit nicht von alleine wieder eingeschaltet wird
     142      printf("FAULT INPUT EVENT DETECTED!\n");
     143      printf("NEW_STATE: SECONDARYPROTECTION_ERROR\n");
     144      smState = SECONDARYPROTECTION_ERROR;
     145          smError = ERROR_EXTERNAL_FAULT;
    128146  }
    129147  else
    … …  
    176194          printf("NEW_STATE: SECONDARYPROTECTION_ERROR\n");
    177195          smState = SECONDARYPROTECTION_ERROR; 
     196          smError = ERROR_VOLTAGE_DROP;
    178197          VOLTAGE_MEAS_ResetCounter(); // Damit Fehlerzähler bei Neustart auf 0
    179198  }
    180199
     200
     201
     202  if (lvpAndOvpInput == 1)
     203  {
     204    RELAIS_ResetPuls();
     205    BUZZER_Beep(BUZZER_ON_TIME_REJECT); //Warnung
     206    LEDS_GN_Off();
     207    LEDS_RT_BlinkCode_Start(BLINK_CODE_ERROR_OVP_LVP, LED_RT_ON_TIME_WARN_OVP_AND_LVP_INPUT, LED_RT_OFF_TIME, LED_RT_OFF_TIME *5); //Fehler Anzeigen
     208    BUTTON_SetModeOff(); //Damit nicht von alleine wieder eingeschaltet wird
     209    printf("BMS SECONDARY PROTECTION FAULT EVENT DETECTED (LVP & OVP )!\n");
     210    printf("NEW_STATE: SECONDARYPROTECTION_ERROR\n");
     211    smState = SECONDARYPROTECTION_ERROR;
     212        smError = ERROR_LVP_AND_OVP;
     213  }
     214
     215  if (CHIP_TEMPERATURE_GetTemp() > 80)
     216  {
     217        RELAIS_ResetPuls();
     218        BUZZER_Beep(BUZZER_ON_TIME_REJECT); //Warnung
     219        LEDS_GN_Off();
     220        LEDS_RT_BlinkCode_Start(BLINK_CODE_ERROR_TEMP, LED_RT_ON_TIME_WARN_TEMP, LED_GN_OFF_TIME, LED_GN_OFF_TIME *5); //Fehler Anzeigen
     221        BUTTON_SetModeOff(); //Damit nicht von alleine wieder eingeschaltet wird
     222        printf("NEW_STATE: MAINSWITCH_ERROR, Temp too high\n");
     223        smState = SECONDARYPROTECTION_ERROR;         
     224        smError = ERROR_TEMPERATURE;
     225  }
     226
     227
     228
     229}
     230
     231static void SECONDARYPROTECTION_SM_ManualOn(void)
     232{
     233
     234  int faultInput = 0;
     235
     236
     237  if (HAL_GPIO_ReadPin(GPIO_INPUT_FAULT_GPIO_Port, GPIO_INPUT_FAULT_Pin) == GPIO_PIN_RESET)       
     238  {   
     239          faultInput = 1;
     240  }
     241  else
     242  {
     243    faultInput = 0;
     244  }
    181245
    182246  if (faultInput == 1)
    … …  
    190254    printf("NEW_STATE: SECONDARYPROTECTION_ERROR\n");
    191255    smState = SECONDARYPROTECTION_ERROR;
    192   }
    193 
    194   if (lvpAndOvpInput == 1)
    195   {
    196     RELAIS_ResetPuls();
    197     BUZZER_Beep(BUZZER_ON_TIME_REJECT); //Warnung
    198     LEDS_GN_Off();
    199     LEDS_RT_BlinkCode_Start(BLINK_CODE_ERROR_OVP_LVP, LED_RT_ON_TIME_WARN_OVP_AND_LVP_INPUT, LED_RT_OFF_TIME, LED_RT_OFF_TIME *5); //Fehler Anzeigen
    200     BUTTON_SetModeOff(); //Damit nicht von alleine wieder eingeschaltet wird
    201     printf("BMS SECONDARY PROTECTION FAULT EVENT DETECTED (LVP & OVP )!\n");
    202     printf("NEW_STATE: SECONDARYPROTECTION_ERROR\n");
    203     smState = SECONDARYPROTECTION_ERROR;
    204   }
    205 
    206   if (CHIP_TEMPERATURE_GetTemp() > 80)
    207   {
    208         RELAIS_ResetPuls();
    209         BUZZER_Beep(BUZZER_ON_TIME_REJECT); //Warnung
    210         LEDS_GN_Off();
    211         LEDS_RT_BlinkCode_Start(BLINK_CODE_ERROR_TEMP, LED_RT_ON_TIME_WARN_TEMP, LED_GN_OFF_TIME, LED_GN_OFF_TIME *5); //Fehler Anzeigen
    212         BUTTON_SetModeOff(); //Damit nicht von alleine wieder eingeschaltet wird
    213         printf("NEW_STATE: MAINSWITCH_ERROR, Temp too high\n");
    214         smState = SECONDARYPROTECTION_ERROR;         
    215   }
    216 
    217 
    218 
    219 }
    220 
    221 static void SECONDARYPROTECTION_SM_ManualOn(void)
    222 {
    223 
    224   int faultInput = 0;
    225 
    226 
    227   if (HAL_GPIO_ReadPin(GPIO_INPUT_FAULT_GPIO_Port, GPIO_INPUT_FAULT_Pin) == GPIO_PIN_RESET)       
    228   {   
    229         HAL_Delay(500); // Verzögerung 500ms damit eventuell noch zuerst durch smartPro der Strom gestoppt werden kann
    230         if (HAL_GPIO_ReadPin(GPIO_INPUT_FAULT_GPIO_Port, GPIO_INPUT_FAULT_Pin) == GPIO_PIN_RESET)       
    231         {
    232           faultInput = 1;
    233         }
    234 
    235   }
    236   else
    237   {
    238     faultInput = 0;
    239   }
    240 
    241   if (faultInput == 1)
    242   {
    243     RELAIS_ResetPuls();
    244     BUZZER_Beep(BUZZER_ON_TIME_REJECT); //Warnung
    245     LEDS_GN_Off();
    246     LEDS_RT_BlinkCode_Start(BLINK_CODE_ERROR_FAULT_INPUT, LED_RT_ON_TIME_WARN_FAULT_INPUT, LED_RT_OFF_TIME, LED_RT_OFF_TIME *5); //Fehler Anzeigen
    247     BUTTON_SetModeOff(); //Damit nicht von alleine wieder eingeschaltet wird
    248     printf("FAULT INPUT EVENT DETECTED!\n");
    249     printf("NEW_STATE: SECONDARYPROTECTION_ERROR\n");
    250     smState = SECONDARYPROTECTION_ERROR;
     256        smError = ERROR_EXTERNAL_FAULT;
    251257  }
    252258
    … …  
    262268    printf("NEW_STATE: SECONDARYPROTECTION_OFF\n");
    263269    smState = SECONDARYPROTECTION_OFF;
     270        smError = ERROR_NONE;
    264271  }
    265272
    … …  
    270277  int faultInput;
    271278  int lvpAndOvpInput;
     279  static uint32_t retry_counter = 0;
     280  static uint32_t oldTimeMSTick;
    272281
    273282  if (HAL_GPIO_ReadPin(GPIO_INPUT_FAULT_GPIO_Port, GPIO_INPUT_FAULT_Pin) == GPIO_PIN_RESET)       
    … …  
    293302      printf("NEW_STATE: SECONDARYPROTECTION_ON\n");
    294303      smState = SECONDARYPROTECTION_ON;
     304          smError = ERROR_NONE;
    295305    }
    296306    else
    … …  
    314324      printf("NEW_STATE: SECONDARYPROTECTION_MANUAL_ON\n");
    315325      smState = SECONDARYPROTECTION_MANUAL_ON;
    316   }
    317 
    318 
    319 
    320 }
    321 
    322 
    323 
    324 void MODE_SECONDARYPROTECTION_Exec(void)
    325 {
    326 
    327  
     326          smError = ERROR_NONE;
     327  }
     328
     329
     330  if (autoRetryMode == 1) {
     331
     332    if (oldTimeMSTick != HAL_GetTick())
     333    {
     334        oldTimeMSTick = HAL_GetTick();
     335        retry_counter++;
     336    }
     337
     338    if  (retry_counter > 3600000)  // 10 Minuten * 60 * 1000 = 600000 || 60 * 60 * 1000 =3600000
     339    {
     340        BUTTON_SetModeAuto();
     341        retry_counter=0;
     342    }
     343  }
     344}
     345
     346
     347
     348void MODE_SECONDARYPROTECTION_Exec(int am)
     349{
     350
     351        autoRetryMode = am;
    328352
    329353  switch (smState)

  • trunk/firmware_v2/SES/src/mode_secondaryprotection_plus.c

    r28 r29  
    3535} SECONDARYPROTECTION_state_t;
    3636
     37typedef enum SECONDARYPROTECTION_ErrorState_enum
     38{
     39  ERROR_NONE,
     40  ERROR_EXTERNAL_FAULT, //z.B Kurzschluss
     41  ERROR_TEMPERATURE,
     42  ERROR_VOLTAGE_DROP,
     43  ERROR_LVP_AND_OVP,      //z.B. kritische Überspannung, tiefeEntladung
     44} SECONDARYPROTECTION_ErrorState_t;
     45
    3746
    3847static SECONDARYPROTECTION_state_t smState;
    39 
     48static SECONDARYPROTECTION_ErrorState_t smError = ERROR_NONE;
     49static int autoRetryMode;
    4050
    4151static void SECONDARYPROTECTION_SM_Off(void)
    … …  
    7383      printf("NEW_STATE: SECONDARYPROTECTION_ON\n");
    7484      smState = SECONDARYPROTECTION_ON;
     85          smError = ERROR_NONE;
    7586
    7687    }
    … …  
    8394          LEDS_RT_BlinkCode_Start(BLINK_CODE_ERROR_FAULT_INPUT, LED_RT_ON_TIME_WARN_FAULT_INPUT, LED_RT_OFF_TIME, LED_RT_OFF_TIME *5); //Fehler Anzeigen
    8495      printf("NEW_STATE: SECONDARYPROTECTION_ERROR\n");
    85       smState =SECONDARYPROTECTION_ERROR;
     96      smState = SECONDARYPROTECTION_ERROR;
     97          smError = ERROR_EXTERNAL_FAULT;
     98       
    8699    }
    87100  }
    … …  
    121134  }
    122135 
     136
     137  if (faultInput == 1)
     138  {
     139    RELAIS_ResetPuls();
     140    BUZZER_Beep(BUZZER_ON_TIME_REJECT); //Warnung
     141    LEDS_GN_Off();
     142    LEDS_RT_BlinkCode_Start(BLINK_CODE_ERROR_FAULT_INPUT, LED_RT_ON_TIME_WARN_FAULT_INPUT, LED_RT_OFF_TIME, LED_RT_OFF_TIME *5); //Fehler Anzeigen
     143    BUTTON_SetModeOff(); //Damit nicht von alleine wieder eingeschaltet wird
     144    printf("FAULT INPUT EVENT DETECTED!\n");
     145    printf("NEW_STATE: SECONDARYPROTECTION_ERROR\n");
     146    smState = SECONDARYPROTECTION_ERROR;
     147        smError = ERROR_EXTERNAL_FAULT;
     148        return;
     149  }
     150
     151
     152
    123153  if ((HAL_GPIO_ReadPin(GPIO_INPUT_LVP_GPIO_Port, GPIO_INPUT_LVP_Pin) == GPIO_PIN_SET) &&  (HAL_GPIO_ReadPin(GPIO_INPUT_OVP_GPIO_Port, GPIO_INPUT_OVP_Pin) == GPIO_PIN_SET))
    124154  {
    … …  
    152182    printf("NEW_STATE: SECONDARYPROTECTION_OFF\n");
    153183    smState = SECONDARYPROTECTION_OFF;
     184        smError = ERROR_NONE;
    154185  }
    155186
    … …  
    165196          printf("NEW_STATE: SECONDARYPROTECTION_ERROR\n");
    166197          smState = SECONDARYPROTECTION_ERROR; 
     198          smError = ERROR_VOLTAGE_DROP;
    167199          VOLTAGE_MEAS_ResetCounter(); // Damit Fehlerzähler bei Neustart auf 0
    168200  }
    169201
    170202
    171   if (faultInput == 1)
    172   {
    173     RELAIS_ResetPuls();
    174     BUZZER_Beep(BUZZER_ON_TIME_REJECT); //Warnung
    175     LEDS_GN_Off();
    176     LEDS_RT_BlinkCode_Start(BLINK_CODE_ERROR_FAULT_INPUT, LED_RT_ON_TIME_WARN_FAULT_INPUT, LED_RT_OFF_TIME, LED_RT_OFF_TIME *5); //Fehler Anzeigen
    177     BUTTON_SetModeOff(); //Damit nicht von alleine wieder eingeschaltet wird
    178     printf("FAULT INPUT EVENT DETECTED!\n");
    179     printf("NEW_STATE: SECONDARYPROTECTION_ERROR\n");
    180     smState = SECONDARYPROTECTION_ERROR;
    181   }
    182203
    183204  if (lvpAndOvpInput == 1)
    … …  
    191212    printf("NEW_STATE: SECONDARYPROTECTION_ERROR\n");
    192213    smState = SECONDARYPROTECTION_ERROR;
     214        smError = ERROR_LVP_AND_OVP;
    193215  }
    194216
    … …  
    202224        printf("NEW_STATE: MAINSWITCH_ERROR, Temp too high\n");
    203225        smState = SECONDARYPROTECTION_ERROR;         
     226        smError = ERROR_TEMPERATURE;
    204227  }
    205228
    … …  
    228251  int faultInput;
    229252  int lvpAndOvpInput;
     253  static uint32_t retry_counter = 0;
     254  static uint32_t oldTimeMSTick;
    230255
    231256  if (HAL_GPIO_ReadPin(GPIO_INPUT_FAULT_GPIO_Port, GPIO_INPUT_FAULT_Pin) == GPIO_PIN_RESET)       
    … …  
    241266
    242267  //Prüfe auf Wechsel des Modus AUTO / SM ON
    243   if (BUTTON_GetMode() == BUTTON_AUTO)
     268  if (BUTTON_GetMode() == BUTTON_AUTO) 
    244269  {
    245270    if (faultInput == 0)
    246271    {
     272          retry_counter = 0;
    247273      RELAIS_SetPuls();
    248274      BUZZER_Beep(BUZZER_ON_TIME_CONFIRM);
    … …  
    251277      printf("NEW_STATE: SECONDARYPROTECTION_ON\n");
    252278      smState = SECONDARYPROTECTION_ON;
     279          smError = ERROR_NONE;
    253280    }
    254281    else
    … …  
    260287  }
    261288
     289  if (autoRetryMode == 1) {
     290
     291    if (oldTimeMSTick != HAL_GetTick())
     292    {
     293        oldTimeMSTick = HAL_GetTick();
     294        retry_counter++;
     295    }
     296
     297    if  (retry_counter > 3600000)  // jede stunde
     298    {
     299        BUTTON_SetModeAuto();
     300        retry_counter = 0;
     301    }
     302  }
    262303  //Prüfe auf Wechsel in MANUAL ON Mode
    263304  //Keine Fehlerüberprüfungen. In diesem Modus werdem alle Alarme ignoriert.
    … …  
    280321
    281322
    282 void MODE_SECONDARYPROTECTION_PLUS_Exec(void)
    283 {
    284 
    285  
     323void MODE_SECONDARYPROTECTION_PLUS_Exec(int am)
     324{
     325
     326        autoRetryMode = am;
    286327
    287328  switch (smState)

  • trunk/firmware_v2/SES/src/modeswitch.c

    r17 r29  
    44
    55
    6 MODESWITCH_mode_t mode;
     6static MODESWITCH_mode_t mode;
    77
    88MODESWITCH_mode_t MODESWITCH_ReadMode(void)
Note: See TracChangeset for help on using the changeset viewer.