Changeset 25 for trunk/fw_g473rct/Core/Src/main.c

Timestamp:

Sep 7, 2025, 3:51:43 PM (7 weeks ago)

Author:

f.jahn

Message:

RTC implementiert

File:

• trunk/fw_g473rct/Core/Src/main.c (modified) (9 diffs)

trunk/fw_g473rct/Core/Src/main.c

@@ -24 +24 @@
 #include "fdcan.h"
 #include "i2c.h"
+#include "rtc.h"
 #include "spi.h"
 #include "usart.h"
@@ -31 +32 @@
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
+#include <stdio.h>
+#include "sysdata.h"
+#include "wh_counter.h"
+#include "ah_counter.h"
+#include "eeprom.h"
+#include "modbus.h"
+#include "chip_temperature.h"
+#include "battery_voltage.h"
+#include "ads1260.h"
+#include "shunt_voltage.h"
+#include "fast_current.h"
+#include "int_bat_voltage.h"
+#include "chip_temperature.h"
+#include "shunt_temperature.h"
+#include "esr.h"
+#include "ads1260.h"
+#include "outputs.h"
+#include "crc.h"
+#include "efficiency.h"
+#include "self_discharge.h"
 
 /* USER CODE END Includes */
@@ -52 +73 @@
 
 /* USER CODE BEGIN PV */
-
+modbus_t modbusData __attribute__((section(".RAM1")));
+
+__IO uint16_t adc12Data[SAMPLE_ARRAY_SIZE][2] __attribute__((section(".RAM1")));
+__IO uint32_t adc1Data[1] __attribute__((section(".RAM1")));
+__IO uint32_t adc2Data[1] __attribute__((section(".RAM1")));
+__IO uint32_t adc3Data[3] __attribute__((section(".RAM1")));
+__IO uint32_t adc4Data[1] __attribute__((section(".RAM1")));
+__IO uint32_t adc5Data[4] __attribute__((section(".RAM1")));
+int silentmode =0;
+static volatile uint32_t newADC12Data = 0;
+static volatile uint32_t newADC3Data = 0;
+static volatile uint32_t newADC4Data = 0;
+static volatile uint32_t newADC5Data = 0;
 /* USER CODE END PV */
 
@@ -58 +91 @@
 void SystemClock_Config(void);
 /* USER CODE BEGIN PFP */
-
+bool SetFlashReadProtection(bool state);
+uint8_t printprotectionstate(void);
+bool SetBootFromFlashAndReadOutProtection(void);
+void LoadBackupRegister(void);
+void SaveBackupRegister(void);
 /* USER CODE END PFP */
 
@@ -74 +111 @@
 
   /* USER CODE BEGIN 1 */
+  uint8_t firstStartCatcher;
+  int mode_button_disable_time=0;
+  uint32_t oldTime = 0;
+  uint32_t newTime = 0;
+  uint32_t timeDiff;
+  uint8_t sekunde = 0;
+  uint8_t sekundeOld = 0;
+  uint32_t dummyDate;
 
   /* USER CODE END 1 */
@@ -110 +155 @@
   MX_USB_PCD_Init();
   MX_CRC_Init();
+  MX_RTC_Init();
   /* USER CODE BEGIN 2 */
-
+  printf("Test debug io\r\n");
+  SYS_DATA_Init();
+  WH_COUNTER_Init();
+  AH_COUNTER_Init();
+
+
+  startType_t startType = EEPROM_isFirstStart();
+
+  switch(startType)
+  {
+          case FIRST_START_AFTER_ERASE:                                 EEPROM_fullRestore(&sys_data);            break;
+          case FIRST_START_AFTER_COMPARTIBLE_UPDATE:    EEPROM_readConfig(&sys_data);             break;
+          case FIRST_START_AFTER_INCOMPARTIBLE_UPDATE:  EEPROM_factoryRestore(&sys_data, 0);  break;  // Preserving calibration and settings
+          case FIRST_START_ERROR:                                               EEPROM_fullRestore(&sys_data);            break;
+  }
+
+  if(HAL_GPIO_ReadPin(GPIO_INPUT_BTN_MODE_GPIO_Port, GPIO_INPUT_BTN_MODE_Pin) == GPIO_PIN_RESET)
+  {
+    HAL_Delay(50);
+    if(HAL_GPIO_ReadPin(GPIO_INPUT_BTN_MODE_GPIO_Port, GPIO_INPUT_BTN_MODE_Pin) == GPIO_PIN_RESET)
+    {
+      printf("factory restore...\n");
+      EEPROM_factoryRestore(&sys_data, 1);
+    }
+  }
+
+    // Modbus Initialisierung
+  mbInit(&modbusData, sys_data.s.parameter.baudrate, sys_data.s.parameter.parityMode, sys_data.s.parameter.stopBit, &huart2);
+
+    // STM32G0 Chiptemperatur Kalibrierung
+  CHIP_TEMPERATURE_Calibration();
+
+  HAL_ADCEx_Calibration_Start(&hadc1, ADC_DIFFERENTIAL_ENDED);
+  HAL_ADCEx_Calibration_Start(&hadc2, ADC_DIFFERENTIAL_ENDED);
+  HAL_ADCEx_Calibration_Start(&hadc3, ADC_SINGLE_ENDED);
+  HAL_ADCEx_Calibration_Start(&hadc4, ADC_DIFFERENTIAL_ENDED);
+  HAL_ADCEx_Calibration_Start(&hadc5, ADC_SINGLE_ENDED);
+
+
+  //SET_BIT(hadc2.Instance->CFGR, ADC_CFGR_DMAEN); //Enable DMA transfer for ADC slave (ADC12_CCR.MDMA = 0b00 -> MDMA mode disabled)
+  //HAL_DMA_Start(hadc2.DMA_Handle,(uint32_t)&hadc2.Instance->DR, (uint32_t)adc2Data,1); //Start ADC slave DMA 
+  //SET_BIT(hadc1.Instance->CFGR, ADC_CFGR_DMAEN); //Enable DMA transfer for ADC master (ADC12_CCR.MDMA = 0b00 -> MDMA mode disabled)
+  
+    //HAL_ADC_Start_DMA(&hadc2, (uint32_t*)adc2Data, 1);
+  if (HAL_ADCEx_MultiModeStart_DMA(&hadc1,(uint32_t *)adc12Data,SAMPLE_ARRAY_SIZE))  //Start ADC interleaved mode
+  {
+     /* Start Error */
+     Error_Handler();
+  }
+
+  if (HAL_ADC_Start_DMA(&hadc3, (uint32_t *) adc3Data , 3))
+  {
+     /* Start Error */
+     Error_Handler();
+  }
+
+  if (HAL_ADC_Start_DMA(&hadc4, (uint32_t *) adc4Data , 1))
+  {
+     /* Start Error */
+     Error_Handler();
+  }
+
+
+  if (HAL_ADC_Start_DMA(&hadc5, (uint32_t *) adc5Data , 4))
+  {
+     /* Start Error */
+     Error_Handler();
+  }
+
+
+  // ADS1260 Initialierung
+  ADS1260_init();
+  printf("ADS1260 Init\n");
+  OUTPUTS_Init();
+
+  //Display Adress with Error LED blinks
+  for (int n = 0; n < sys_data.s.parameter.slave_address; n++)
+  {
+    HAL_GPIO_WritePin(LED_ERROR_GPIO_Port, LED_ERROR_Pin, GPIO_PIN_SET);
+    HAL_Delay(350);
+    HAL_GPIO_WritePin(LED_ERROR_GPIO_Port, LED_ERROR_Pin, GPIO_PIN_RESET);
+    HAL_Delay(350);
+  }
+
+  LoadBackupRegister();
   /* USER CODE END 2 */
 
@@ -121 +251 @@
 
     /* USER CODE BEGIN 3 */
+if (newADC12Data == 1)
+    {
+          //Mit ADC_DIV2,Sample time 12,5Cycklen, ADC Clock 50Mhz, Oversampling 256
+          //Tconv = 6400 Takte = 0,128ms Pro Konvertierung. Also für 100 messwerte 12,8mS
+          BATTERY_VOLTAGE_Exec( adc12Data[0][1]);
+          FAST_CURRENT_Exec(adc12Data[0][0]); 
+          sys_data.s.values.esrCalcStatus =  ESR_FAST_Exec();
+          newADC12Data = 0;
+
+        }
+
+
+        if (newADC3Data == 1)
+    {
+          SHUNT_TEMPERATURE_Exec(adc3Data[0]);
+        }
+
+
+        if (newADC4Data == 1)
+    {
+          SHUNT_VOLTAGE_Exec( adc4Data[0]);
+        }
+
+
+        if (newADC5Data == 1)
+    {
+          CHIP_TEMPERATURE_Exec(adc5Data[0]);
+          INT_BAT_VOLTAGE_Exec( adc5Data[1]);
+          sys_data.s.values.ovp_sense =  (adc5Data[2] * VREF * 21 ) / 65536.0;
+      sys_data.s.values.lvp_sense =  (adc5Data[3] * VREF * 21 ) / 65536.0;
+        }
+
+
+        if (newCurrentValue == 1)
+    {
+      ADS1260_ConversionFinished(); 
+      ESR_Exec();
+
+      newCurrentValue = 0;
+
+    }
+
+         // Zeitbasis ms Systick;
+    newTime = HAL_GetTick();
+    timeDiff = newTime - oldTime;
+    oldTime = newTime;
+
+    if ((mode_button_disable_time > 0) && (timeDiff > 0))
+    {
+      mode_button_disable_time--;
+    }
+
+    // Zeitbasis Sekunde ber RTC
+    // muss immer sowohl das Zeit- als auch das Datumsregister lesen
+    // da beide Shadowregister sind sonst wird die Zeit nicht mehr geupdatet
+    sekunde = hrtc.Instance->TR & 0x0000000F;
+    dummyDate = hrtc.Instance->DR;
+
+
+
+    if (sekundeOld != sekunde)
+    {
+      sekundeOld = sekunde;
+
+      sys_data.s.values.onTime++;
+      // Funktions Led blinken
+      if (silentmode == 0)
+      {
+        HAL_GPIO_TogglePin(LED_FUNCTION_GPIO_Port, LED_FUNCTION_Pin);
+                HAL_GPIO_TogglePin(AUX_EN_GPIO_Port, AUX_EN_Pin);
+      }
+
+
+      // Amperestundenzhler
+      AH_COUNTER_Exec();
+
+      WH_COUNTER_Exec();
+
+      // LVP
+      OUTPUTS_CheckLVP();
+
+      // OVP
+      OUTPUTS_CheckOVP();
+
+      SaveBackupRegister();
+
+      sys_data.s.values.selfDischargeStatus = SELF_DISCHARGE_Exec();
+
+      sys_data.s.values.efficiency = EFFICIENCY_Exec();
+
+
+    }
+
+
+        if(sys_data.s.parameter.command != 0)
+    {
+      if  (modbusData.current_query ==  MB_QUERY_NOTHING)
+      {
+        //printf("CMD = %d\n", sys_data.s.parameter.command);
+        switch (sys_data.s.parameter.command )
+        {
+          case COMMAND_STORE_CONFIG:                          EEPROM_storeConfig(&sys_data,0);                                                                                    break;
+          case COMMAND_FULL_RESTORE:                          EEPROM_fullRestore(&sys_data);                                                                                      break;
+          case COMMAND_FACTORY_RESTORE:                       EEPROM_factoryRestore(&sys_data, 1);                                                                                break;
+          case COMMAND_RESTORE_LAST_SAVED_VALUES:             EEPROM_readConfig(&sys_data);                                                                                               break;
+          case COMMAND_STORE_WITH_SERIAL_NUMBER:              EEPROM_storeConfig(&sys_data,1);                                                                                    break;        // Seriennummer schreiben
+          case COMMAND_RESTART:                               NVIC_SystemReset();                                                                                                                 break;
+          case COMMAND_BATTERY_CURRENT_OFFSET_CAL:            ADS_1260_BatteryCurrentOffsetCalibrationStart(&sys_data);                                   break;
+          case COMMAND_BATTERY_CURRENT_OFFSET_COMMONMODE_CAL: ADS_1260_BatteryCurrentOffsetCommonModeErrorComepensationStart(&sys_data);  break;
+          case COMMAND_BATTERY_CURRENT_OFFSET_TEMP_CAL:       ADS_1260_BatteryCurrentOffsetTemperatureErrorComepensationStart();                  break;
+          case COMMAND_BATTERY_CURRENT_GAIN_CAL:              ADS_1260_BatteryCurrentGainCalibrationStart(&sys_data);                                     break;
+          case COMMAND_BATTERY_CURRENT_GAIN_TEMP_SHUNT_CAL:   ADS_1260_BatteryCurrentGainTemperatureCalibrationShuntStart();                      break;
+//        case COMMAND_BATTERY_CURRENT_GAIN_TEMP_CHIP_CAL:    ADS_1260_BatteryCurrentGainTemperatureCalibrationChipStart(); break;
+          case COMMAND_SET_RDP_LEVEL0:                        SetFlashReadProtection(false);                                                                                      break;
+          case COMMAND_SET_RDP_LEVEL1:                        SetFlashReadProtection(true);                                                                                               break;
+          case COMMAND_SET_RDP_LEVEL1_AND_BOOTSEL:            SetBootFromFlashAndReadOutProtection();                                                                     break;
+          default:                                            printf("UNKNOWN COMMAND\n");
+        }
+        sys_data.s.parameter.command = 0;
+      }
+      else
+      {
+        //printf("wait with execution till modbus communnikation finished\n");
+      }
+    }
+
+    if((HAL_GPIO_ReadPin(GPIO_INPUT_BTN_MODE_GPIO_Port, GPIO_INPUT_BTN_MODE_Pin) == GPIO_PIN_RESET) && (mode_button_disable_time == 0))
+    {
+      HAL_Delay(10);
+      //Taste weiterhin gedrckt?
+      if(HAL_GPIO_ReadPin(GPIO_INPUT_BTN_MODE_GPIO_Port, GPIO_INPUT_BTN_MODE_Pin) == GPIO_PIN_RESET)
+      {
+        //Ja, dann Silent Mode umschalten
+        mode_button_disable_time=500;
+        if (silentmode == 0)
+        {
+          silentmode = 1;
+          HAL_GPIO_WritePin(LED_FUNCTION_GPIO_Port, LED_FUNCTION_Pin,GPIO_PIN_SET);
+        }
+        else
+        {
+          silentmode = 0;
+        }
+       }
+    }
+
+        // Modbus Kommunikation
+
+//      printf("data12d1=%d,data12d2=%d,data5=%d\r\n", adc12Data[0], adc12Data[1] , adc5Data[2]);
+    if (mbGetFrameComplete(&modbusData) == true)
+    {
+      if (mbSlaveCheckModbusRtuQuery(&modbusData) == RESPOND_TO_QUERY)
+      {
+          if (silentmode == 0)
+          {
+            mbSlaveProcessRtuQuery(&modbusData);
+          }
+      }
+      else
+      {
+        huart1.RxState = HAL_UART_STATE_BUSY_RX;
+      }
+    }
+
+  
   }
   /* USER CODE END 3 */
@@ -138 +433 @@
   HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);
 
+  /** Configure LSE Drive Capability
+  */
+  HAL_PWR_EnableBkUpAccess();
+  __HAL_RCC_LSEDRIVE_CONFIG(RCC_LSEDRIVE_LOW);
+
   /** Initializes the RCC Oscillators according to the specified parameters
   * in the RCC_OscInitTypeDef structure.
   */
-  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI48|RCC_OSCILLATORTYPE_HSE;
+  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI48|RCC_OSCILLATORTYPE_HSE
+                              |RCC_OSCILLATORTYPE_LSE;
   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
+  RCC_OscInitStruct.LSEState = RCC_LSE_ON;
   RCC_OscInitStruct.HSI48State = RCC_HSI48_ON;
   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
@@ -172 +474 @@
 
 /* USER CODE BEGIN 4 */
-
+void LoadBackupRegister()
+{
+    if (HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR1) == 0xBEBE)
+    {
+          printf("BackupRegisterData available\r\n");
+          sys_data.s.values.dischargeTotalAh = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR2);
+        }
+
+
+}
+
+
+void SaveBackupRegister(void)
+{
+        static uint32_t lastTime;
+
+        
+        uint32_t time = sys_data.s.values.onTime;
+
+        // Alle 24 Stunden führen wir ein Speicherbefehl durch um die Counter zu speichern
+        if (time != lastTime)
+        {
+                lastTime = time;
+                HAL_PWR_EnableBkUpAccess();
+                HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR1, 0xBEBE);
+
+                // Total Energie und Ah Umsatz der Batterie (seit inbetriebnahme)
+            HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR2, sys_data.s.values.dischargeTotalAh);
+                HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR3, sys_data.s.values.chargeTotalAh);
+                HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR4, sys_data.s.values.dischargeTotalWh);
+                HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR5, sys_data.s.values.chargeTotalWh);
+
+                // Betriebszeit
+                HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR6, sys_data.s.values.onTime);
+
+                // Erkannte Kapazitäten
+                HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR7, sys_data.s.values.detectedCapacity);
+                HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR8, sys_data.s.values.detectedEnergy);
+
+
+                HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR8, sys_data.s.values.mAh_AutoMode);
+                HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR8, sys_data.s.values.mWh_AutoMode);
+                HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR8, sys_data.s.values.mAhCounter);
+
+
+
+
+
+        }
+
+
+}
+
+
+
+ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
+ {
+    if (hadc->Instance==ADC1)
+        {
+          newADC12Data=1;
+        }
+
+        if (hadc->Instance==ADC3)
+        {
+          newADC3Data=1;
+        }
+
+
+        if (hadc->Instance==ADC4)
+        {
+          newADC4Data=1;
+        }
+
+        if (hadc->Instance==ADC5)
+        {
+          newADC5Data=1;
+        }
+ }
+
+
+ 
+/**
+
+  * @brief  Set flash read protection.
+
+  * @param  [in] state: Flash read protection state, true: enable protection, false: disable protection.
+
+  * @retval true:  Successful operation.
+
+  * @retval false: Operation failed.
+
+  */
+
+bool SetFlashReadProtection(bool state)
+{
+
+  FLASH_OBProgramInitTypeDef OptionsBytesStruct = {0};
+  HAL_FLASHEx_OBGetConfig(&OptionsBytesStruct);
+
+  if(state == true)
+  {
+    printf("Start enable readout protection\n");
+    if(OptionsBytesStruct.RDPLevel == OB_RDP_LEVEL_0)
+    {
+      OptionsBytesStruct.OptionType = OPTIONBYTE_RDP;
+      OptionsBytesStruct.RDPLevel   = OB_RDP_LEVEL_1;
+      if (HAL_FLASH_Unlock() != HAL_OK)
+      {
+        printf("Flash unlock error\n");
+      }
+      if (HAL_FLASH_OB_Unlock() != HAL_OK)
+      {
+        printf("Flash ob unlock error\n");
+      }
+
+      printf("...Flash unlock\n");
+      if(HAL_FLASHEx_OBProgram(&OptionsBytesStruct) != HAL_OK)
+      {
+        printf("...Enable lock error\n");
+        HAL_FLASH_OB_Lock();
+        return false;
+      }
+      HAL_FLASH_OB_Lock();
+      printf("Flash Optionbyte locked\n");
+      HAL_FLASH_Lock();
+      printf("Flash  locked\n");
+      printf("...Enable lock process finished\n");
+    }
+    else
+    {
+      printf("...Flash lock already active\n");
+    }
+  }
+  else
+  {
+    if(OptionsBytesStruct.RDPLevel == OB_RDP_LEVEL_1)
+    {
+      OptionsBytesStruct.OptionType = OPTIONBYTE_RDP;
+      OptionsBytesStruct.RDPLevel   = OB_RDP_LEVEL_0;
+
+      if (HAL_FLASH_Unlock() != HAL_OK)
+      {
+        printf("Flash unlock error\n");
+        return false;
+      }
+      printf("...Flash unlocked\n");
+
+      if (HAL_FLASH_OB_Unlock() != HAL_OK)
+      {
+        printf("Flash ob unlock error\n");
+        return false;
+      }
+      printf("...Flash ob unlocked\n");
+
+      if(HAL_FLASHEx_OBProgram(&OptionsBytesStruct) != HAL_OK)
+      {
+        HAL_FLASH_OB_Lock();
+        printf("Flash Optionbyte programm failed\n");
+        return false;
+      }
+
+      printf("Flash Optionbyte programmed\n");
+      HAL_FLASH_OB_Lock();
+      printf("Flash Optionbyte locked\n");
+      HAL_FLASH_Lock();
+      printf("Flash  locked\n");
+      printf("...Disable lock process finished\n");
+
+;
+    }
+  }
+  return true;
+}
+
+bool SetBootFromFlashAndReadOutProtection(void)
+{
+
+  FLASH_OBProgramInitTypeDef OptionsBytesStruct = {0};
+  HAL_FLASHEx_OBGetConfig(&OptionsBytesStruct);
+
+  //Konfiguriere RDP fr Readoutprotection and USER OPTION BYTE FR Boot from Flash
+  OptionsBytesStruct.OptionType = OPTIONBYTE_USER | OPTIONBYTE_RDP;
+
+  //Set Readout Protection Level 1
+  OptionsBytesStruct.OptionType = OPTIONBYTE_USER|OPTIONBYTE_RDP;
+  OptionsBytesStruct.RDPLevel   = OB_RDP_LEVEL_1;
+
+  //Selecting Boot from Main Flash Memory
+  OptionsBytesStruct.USERType =    OB_USER_nBOOT0 | OB_USER_nSWBOOT0 | OB_USER_nBOOT1 ;
+  OptionsBytesStruct.USERConfig  = OB_USER_nBOOT0 | OB_USER_nSWBOOT0;
+
+  if (HAL_FLASH_Unlock() != HAL_OK)
+  {
+    printf("Flash unlock error\n");
+  }
+  if (HAL_FLASH_OB_Unlock() != HAL_OK)
+  {
+    printf("Flash ob unlock error\n");
+  }
+
+  printf("...Flash unlock\n");
+  if(HAL_FLASHEx_OBProgram(&OptionsBytesStruct) != HAL_OK)
+  {
+    printf("...Enable lock error\n");
+    HAL_FLASH_OB_Lock();
+    return false;
+  }
+  HAL_FLASH_OB_Lock();
+  printf("Flash Optionbyte locked\n");
+  HAL_FLASH_Lock();
+  printf("Flash  locked\n");
+  printf("...Enable lock process finished\n");
+
+  return true;
+}
+uint8_t printprotectionstate(void)
+{
+  FLASH_OBProgramInitTypeDef OptionsBytesStruct = {0};
+  HAL_FLASHEx_OBGetConfig(&OptionsBytesStruct);
+  uint8_t result = 0;
+
+  if(OptionsBytesStruct.RDPLevel == OB_RDP_LEVEL_0)
+  {
+    //OptionsBytesStruct.OptionType = OPTIONBYTE_RDP;
+    //OptionsBytesStruct.RDPLevel   = OB_RDP_LEVEL_1;
+    printf("PROTECTION: OB_RDP_LEVEL_0\n");
+    result = 0;
+  }
+  else if(OptionsBytesStruct.RDPLevel == OB_RDP_LEVEL_1)
+  {
+    printf("PROTECTION: OB_RDP_LEVEL_1\n");
+    result = 1;
+  }
+  else if(OptionsBytesStruct.RDPLevel == OB_RDP_LEVEL_2)
+  {
+    printf("PROTECTION: OB_RDP_LEVEL_2\n");
+    result = 2;
+  }
+  return  result;
+}
 /* USER CODE END 4 */