STM32F103ZET_JDASMBIC/Src/main.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include "PE43711.h"
#include "uart.h"
#include "Bluecell_operate.h"
#include "eeprom.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
ADC_HandleTypeDef hadc1;
ADC_HandleTypeDef hadc3;
DMA_HandleTypeDef hdma_adc1;
DMA_HandleTypeDef hdma_adc3;

I2C_HandleTypeDef hi2c2;

TIM_HandleTypeDef htim6;

UART_HandleTypeDef huart1;
UART_HandleTypeDef huart2;
DMA_HandleTypeDef hdma_usart1_rx;
DMA_HandleTypeDef hdma_usart1_tx;
DMA_HandleTypeDef hdma_usart2_rx;
DMA_HandleTypeDef hdma_usart2_tx;

/* USER CODE BEGIN PV */
volatile uint16_t ADC1value[ADC1_CNT];
volatile uint16_t ADC3value[ADC3_CNT];

volatile uint16_t ADC1valuearray[ADC1_CNT][ADC_AVERAGECNT];
volatile uint16_t ADC3valuearray[ADC3_CNT][ADC_AVERAGECNT];

volatile uint32_t AdcTimerCnt = 0;
volatile uint32_t LedTimerCnt = 0;
volatile uint32_t UartRxTimerCnt = 0;
volatile uint32_t LDTimerCnt = 0;

volatile uint32_t ALCTimerCnt = 0;
volatile uint32_t AGCTimerCnt = 0;
volatile uint32_t MBIC_ShutdownCnt[MBIC_Shutdown_MaxIndex] ={ 0,};


volatile uint32_t AGC_On_AlarmTimerCnt[AGC_Alarm_DL_Index_MAX] = {0,};
volatile uint32_t AGC_Off_AlarmTimerCnt[AGC_Alarm_DL_Index_MAX] = {0,};

volatile uint32_t ALC_On_AlarmTimerCnt[ALC_Alarm_UL_Index_MAX] = {0,};
volatile uint32_t ALC_Off_AlarmTimerCnt[ALC_Alarm_UL_Index_MAX] = {0,};


volatile uint32_t DET_UL_On_AlarmTimerCnt[DET_Alarm_UL_Index_MAX] = {0,};
volatile uint32_t DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL_Index_MAX] = {0,};

volatile uint32_t DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL_Index_MAX] = {0,};
volatile uint32_t DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL_Index_MAX] = {0,};
volatile uint32_t DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL_Index_MAX] = {0,};
volatile uint32_t DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL_Index_MAX] = {0,};

volatile uint32_t DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL_Index_MAX] = {0,};
volatile uint32_t DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL_Index_MAX] = {0,};


volatile uint32_t DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL_Index_MAX] = {0,};
volatile uint32_t DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL_Index_MAX] = {0,};

volatile uint32_t DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL_Index_MAX] = {0,};
volatile uint32_t DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL_Index_MAX] = {0,};


volatile uint32_t AlarmTimerOffCnt = 0;
volatile uint32_t AlarmTimerOnCnt = 0;


volatile uint32_t Alarm_Temp_TimerOffCnt = 0;
volatile uint32_t Alarm_Temp_TimerOnCnt = 0;

volatile uint32_t Alarm_DL_Level_TimerOffCnt = 0;
volatile uint32_t Alarm_DL_Level_TimerOnCnt = 0;

volatile uint32_t Alarm_UL_Level_TimerOffCnt = 0;
volatile uint32_t Alarm_UL_Level_TimerOnCnt = 0;








volatile bool     AlarmTimerOnSet = 0;
volatile bool     AlarmTimerOffSet = 0;


//extern bool AGC_AlarmTimerSet[AGC_Alarm_DL_Index_MAX];
extern bool ADC_Alarm_DL_High_Set[DET_Alarm_DL_Index_MAX];
extern bool ADC_Alarm_DL_Low_Set[DET_Alarm_DL_Index_MAX];

extern bool ADC_Alarm_UL_Set[DET_Alarm_UL_Index_MAX];
extern uint8_t ALC_AlarmSet[ALC_Alarm_UL_Index_MAX];
extern bool AGC_AlarmSet[AGC_Alarm_DL_Index_MAX];
extern bool ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL_Shutdown_Index_MAX];
extern bool ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL_Shutdown_Index_MAX];
extern bool ADC_Alarm_DL_Normal_Shutdown_Set[DET_Alarm_DL_Shutdown_Index_MAX];
extern bool ADC_Alarm_UL_Normal_Shutdown_Set[DET_Alarm_UL_Shutdown_Index_MAX];
uint8_t* MBIC_UL_ShutdownCount;
uint8_t* MBIC_DL_ShutdownCount;
uint8_t* PrevMBIC_UL_ShutdownCount;
uint8_t* PrevMBIC_DL_ShutdownCount;


/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_ADC1_Init(void);
static void MX_ADC3_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_TIM6_Init(void);
static void MX_I2C2_Init(void);
static void MX_NVIC_Init(void);
/* USER CODE BEGIN PFP */
extern void Booting_LedInit(void);
extern void Bluecell_AttenInitialize();
extern void DET_LevelAlarmCheck();

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
uint32_t ShutdownCnt_Get(uint8_t index){
    return MBIC_ShutdownCnt[index];
}
void ShutdownCnt_Set(uint8_t index,uint8_t val){
    MBIC_ShutdownCnt[index] = val;
}

void Pol_Delay_us(volatile uint32_t microseconds)
{
  /* Go to number of cycles for system */
  microseconds *= (SystemCoreClock / 1000000);
 
  /* Delay till end */
  while (microseconds--);
}


int _write (int file, uint8_t *ptr, uint16_t len)
{
#if 1 // PYJ.2020.06.03_BEGIN --
    HAL_UART_Transmit(&hTest, ptr, len,10);
#else
    HAL_UART_Transmit(&hTerminal, ptr, len,10);    
#endif // PYJ.2020.06.03_END -- 

    return len;
}
uint16_t adc1cnt = 0 ;
uint16_t adc3cnt = 0 ;


void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{
//?��?��?�� 코드 ?��?��
//만약 ?��?�� adc?���????????????? �??????????????��?�� ?�� ?��?���????????????? ?��?���????????????? ?��?��?? 같이 조건�????????????? ?��?��

    if(hadc->Instance == hadc1.Instance)
    {
        if(adc1cnt < ADC_AVERAGECNT){
            for(int i = 0; i < 4; i++){
                ADC1valuearray[i][adc1cnt] = ADC1value[i];
            }
            adc1cnt++;
        }
    }
    if(hadc->Instance == hadc3.Instance)
    {
        if(adc3cnt < ADC_AVERAGECNT){
            for(int i = 0; i < 5; i++){
                ADC3valuearray[i][adc3cnt] = ADC3value[i];
            }
            adc3cnt++;
        }
    }

}
#if 0 // PYJ.2020.04.24_BEGIN -- 
void HAL_I2C_MspInit(I2C_HandleTypeDef* i2cHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct;
  if(i2cHandle->Instance==I2C1)
  {
  /* USER CODE BEGIN I2C1_MspInit 0 */
	__HAL_RCC_I2C1_CLK_ENABLE();
  /* USER CODE END I2C1_MspInit 0 */
  
    /**I2C1 GPIO Configuration    
    PB6     ------> I2C1_SCL
    PB7     ------> I2C1_SDA 
    */
    GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    /* Peripheral clock enable */
    __HAL_RCC_I2C1_CLK_ENABLE();
  /* USER CODE BEGIN I2C1_MspInit 1 */

  /* USER CODE END I2C1_MspInit 1 */
  }
  else if(i2cHandle->Instance==I2C2)
  {
  /* USER CODE BEGIN I2C2_MspInit 0 */
	__HAL_RCC_I2C2_CLK_ENABLE();
  /* USER CODE END I2C2_MspInit 0 */
  
    /**I2C2 GPIO Configuration    
    PB10     ------> I2C2_SCL
    PB11     ------> I2C2_SDA 
    */
    GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    /* Peripheral clock enable */
    __HAL_RCC_I2C2_CLK_ENABLE();
  /* USER CODE BEGIN I2C2_MspInit 1 */

  /* USER CODE END I2C2_MspInit 1 */
  }
#endif // PYJ.2020.04.24_END -- 

#if 0 // PYJ.2020.04.23_BEGIN -- 
uint8_t eepdata[100];
void eepromtest(){
    memset(&eepdata[0],0x33,100);
    for(int i = 0; i < 100; i ++ ){
        printf("data[%d] : %x \r\n",i,eepdata[i]);
        EEPROM_M24C08_Bytewrite(EEPROM_M24C08_ID,EEPROM_ATT_BASE + i,&eepdata[i],1);
    }  
    for(int i = 0; i < 100; i ++ ){
        EEPROM_M24C08_ByteRead(EEPROM_M24C08_ID,EEPROM_ATT_BASE + i,&eepdata[i],1);
        printf("data[%d] : %x \r\n",i,eepdata[i]);
    }  
//    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_BASE,&eepdata[0],100);
//    for(int i = 0; i < 100; i ++ ){
//        printf("data[%d] : %x \r\n",i,eepdata[i]);
//    }    

}
uint8_t i2ctest[10] = {22,};
uint8_t i2cTestData[1] = {44};
#endif // PYJ.2020.04.23_END -- 
#if 0
uint8_t eepromtestarray[1024 * 4];

uint8_t eepromtestarray1[EEPROM_WINDOW_STATUS_ADDRESDS];
uint8_t eepromtestReadarray1[EEPROM_WINDOW_STATUS_ADDRESDS];
#define TESTINDEX  sizeof(TEMP_TABLE_st) 
#endif
#if 0 // PYJ.2020.04.25_BEGIN -- 
void EEPROMTEST_J(){
      for(int i = 0; i< TESTINDEX; i++)
          eepromtestarray[i] = i;
      printf("Value %x\r\n",eepromtestarray[1]);
    
//        EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&eepromtestarray[0],TESTINDEX);   
          EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&eepromtestarray[0],sizeof(TEMP_TABLE_st));                            
          EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL4_TABLE_ADDRESDS),&eepromtestReadarray[0],sizeof(TEMP_TABLE_st));                                    

//        EEPROM_M24C08_Read(EEPROM_M24C08_ID ,(EEPROM_TEMP_DL2_TABLE_ADDRESDS),&eepromtestReadarray[0],TESTINDEX);   
    
        for(int i = 0; i< TESTINDEX; i++)
            printf("%d ",eepromtestReadarray[i]);
               printf("\r\n");
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_ATT_BASE,&eepromtestReadarray[0],sizeof(BLUESTATUS_st) );
    for(int i = 0; i< sizeof(BLUESTATUS_st); i++)
               printf("%d ",eepromtestReadarray[i]);



}
#endif // PYJ.2020.04.25_END -- 
#if 1 // PYJ.2020.04.23_BEGIN -- 


void eepromtest_j1(){
    uint8_t eepromtestReadarray[1024 * 4];
    //uint8_t ret  = 0;

    EEPROM_M24C08_Read(EEPROM_M24C08_ID ,EEPROM_ATT_BASE + 96,eepromtestReadarray,128 );
    for(int i = 0; i< 128 ; i++){
        printf("%x ",eepromtestReadarray[i]);
    }
    printf("\r\n");

}
extern void DET_LevelAlarmCheck();

#endif // PYJ.2020.04.23_END -- 

extern void ALC_Function();
extern void Boot_LED_Toggle(void);
extern void ADC_Check(void);
extern void Booting_LED_Check(void);

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)  {
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */


  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_USART1_UART_Init();
  MX_ADC1_Init();
  MX_ADC3_Init();
  MX_USART2_UART_Init();
  MX_TIM6_Init();
  MX_I2C2_Init();

  /* Initialize interrupts */
  MX_NVIC_Init();
  /* USER CODE BEGIN 2 */
  while(!(HAL_ADCEx_Calibration_Start(&hadc3)==HAL_OK));
  while(!(HAL_ADCEx_Calibration_Start(&hadc1)==HAL_OK));
  HAL_ADC_Start_DMA(&hadc3, (uint16_t*)ADC3value, 5);
  HAL_ADC_Start_DMA(&hadc1, (uint16_t*)ADC1value, 4);
  HAL_TIM_Base_Start_IT(&htim6);



  setbuf(stdout, NULL);
  PE43711_PinInit();
  EEPROM_M24C08_Init();


//  MBIC_APIFLASH_test();
  //Flash_InitRead();

  Booting_LedInit();
  Booting_LED_Check();
  InitUartQueue(&TerminalQueue);
#if 0 // PYJ.2020.04.22_BEGIN -- 
  EEPROM_M24C08_write(0xA0,0,i2cTestData,1);
  printf("i2c Test Data1 %d\r\n",i2ctest[0]);
  EEPROM_M24C08_Read(0xA0,0x00,i2ctest,2);
  printf("i2c Test Data2 %d\r\n",i2ctest[0]);
  printf("i2c Test Data2 %d\r\n",i2ctest[1]);
#endif // PYJ.2020.04.22_END -- 

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
//    uint16_t ret = 0;
//    EEPROMTEST_J();
//    eepromtest_j1();
//        eepromtest_j1();
//  uint8_t retdate[10] = {0,1,2,3,4,5,6,7,8,9};
//    uint16_t rrrrrr = 0;
//  rrrrrr = ((CRC16_Generate(&retdate[0], 10)));  
//  printf("CRC : %x \r\n",rrrrrr);
//  Bluecell_DataInit();
//  Bluecell_AttenInitialize();
#if 1 // PYJ.2020.05.06_BEGIN -- 
      printf("****************************************\r\n");
      printf("MBIC Project _ COPY _\r\n");
      printf("Build at %s %s\r\n", __DATE__, __TIME__);
      printf("Copyright (c) 2020. BLUECELL\r\n");
      printf("****************************************\r\n");
#endif // PYJ.2020.05.06_END --   

  while (1)
  {
//	  HAL_GPIO_TogglePin(GPIOG,GPIO_PIN_14);
  //   printf("data %d\r\n",LedTimerCnt);
    Boot_LED_Toggle(); /*LED Check*/
    Uart_Check();      /*Usart Rx*/
    ADC_Check();       /*Det Calc + DL/UL Alarm Check Function*/
    ALC_Function();    /*ALC Function*/
    AGC_Function();    /*AGC Function*/
    Alarm_Check();     /*Function to check all alarm status variables*/
//    Uart1_Data_Send("A",1);
//    HAL_Delay(1);
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

  /** Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI_DIV2;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL14;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;
  PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV4;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief NVIC Configuration.
  * @retval None
  */
static void MX_NVIC_Init(void)
{
  /* DMA1_Channel1_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
  /* USART1_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(USART1_IRQn);
  /* USART2_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(USART2_IRQn);
  /* DMA2_Channel4_5_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA2_Channel4_5_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA2_Channel4_5_IRQn);
  /* TIM6_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(TIM6_IRQn);
  /* ADC3_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(ADC3_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(ADC3_IRQn);
  /* DMA1_Channel6_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel6_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn);
  /* DMA1_Channel7_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);
  /* DMA1_Channel4_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel4_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel4_IRQn);
  /* DMA1_Channel5_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
}

/**
  * @brief ADC1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_ADC1_Init(void)
{

  /* USER CODE BEGIN ADC1_Init 0 */

  /* USER CODE END ADC1_Init 0 */

  ADC_ChannelConfTypeDef sConfig = {0};

  /* USER CODE BEGIN ADC1_Init 1 */

  /* USER CODE END ADC1_Init 1 */
  /** Common config 
  */
  hadc1.Instance = ADC1;
  hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
  hadc1.Init.ContinuousConvMode = ENABLE;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.NbrOfConversion = 4;
  if (HAL_ADC_Init(&hadc1) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel 
  */
  sConfig.Channel = ADC_CHANNEL_4;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_239CYCLES_5;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel 
  */
  sConfig.Channel = ADC_CHANNEL_5;
  sConfig.Rank = ADC_REGULAR_RANK_2;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel 
  */
  sConfig.Channel = ADC_CHANNEL_6;
  sConfig.Rank = ADC_REGULAR_RANK_3;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel 
  */
  sConfig.Channel = ADC_CHANNEL_12;
  sConfig.Rank = ADC_REGULAR_RANK_4;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN ADC1_Init 2 */

  /* USER CODE END ADC1_Init 2 */

}

/**
  * @brief ADC3 Initialization Function
  * @param None
  * @retval None
  */
static void MX_ADC3_Init(void)
{

  /* USER CODE BEGIN ADC3_Init 0 */

  /* USER CODE END ADC3_Init 0 */

  ADC_ChannelConfTypeDef sConfig = {0};

  /* USER CODE BEGIN ADC3_Init 1 */

  /* USER CODE END ADC3_Init 1 */
  /** Common config 
  */
  hadc3.Instance = ADC3;
  hadc3.Init.ScanConvMode = ADC_SCAN_ENABLE;
  hadc3.Init.ContinuousConvMode = ENABLE;
  hadc3.Init.DiscontinuousConvMode = DISABLE;
  hadc3.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc3.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc3.Init.NbrOfConversion = 5;
  if (HAL_ADC_Init(&hadc3) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel 
  */
  sConfig.Channel = ADC_CHANNEL_4;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_239CYCLES_5;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel 
  */
  sConfig.Channel = ADC_CHANNEL_5;
  sConfig.Rank = ADC_REGULAR_RANK_2;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel 
  */
  sConfig.Channel = ADC_CHANNEL_6;
  sConfig.Rank = ADC_REGULAR_RANK_3;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel 
  */
  sConfig.Channel = ADC_CHANNEL_7;
  sConfig.Rank = ADC_REGULAR_RANK_4;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel 
  */
  sConfig.Channel = ADC_CHANNEL_8;
  sConfig.Rank = ADC_REGULAR_RANK_5;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN ADC3_Init 2 */

  /* USER CODE END ADC3_Init 2 */

}

/**
  * @brief I2C2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_I2C2_Init(void)
{

  /* USER CODE BEGIN I2C2_Init 0 */

  /* USER CODE END I2C2_Init 0 */

  /* USER CODE BEGIN I2C2_Init 1 */

  /* USER CODE END I2C2_Init 1 */
  hi2c2.Instance = I2C2;
  hi2c2.Init.ClockSpeed = 400000;
  hi2c2.Init.DutyCycle = I2C_DUTYCYCLE_2;
  hi2c2.Init.OwnAddress1 = 0;
  hi2c2.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c2.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c2.Init.OwnAddress2 = 0;
  hi2c2.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c2.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN I2C2_Init 2 */

  /* USER CODE END I2C2_Init 2 */

}

/**
  * @brief TIM6 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM6_Init(void)
{

  /* USER CODE BEGIN TIM6_Init 0 */

  /* USER CODE END TIM6_Init 0 */

  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM6_Init 1 */

  /* USER CODE END TIM6_Init 1 */
  htim6.Instance = TIM6;
  htim6.Init.Prescaler = 5600 - 1;
  htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim6.Init.Period = 10;
  htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim6) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim6, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM6_Init 2 */

  /* USER CODE END TIM6_Init 2 */

}

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */

  /* USER CODE END USART1_Init 2 */

}

/**
  * @brief USART2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART2_UART_Init(void)
{

  /* USER CODE BEGIN USART2_Init 0 */

  /* USER CODE END USART2_Init 0 */

  /* USER CODE BEGIN USART2_Init 1 */

  /* USER CODE END USART2_Init 1 */
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */

  /* USER CODE END USART2_Init 2 */

}

/** 
  * Enable DMA controller clock
  */
static void MX_DMA_Init(void) 
{

  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();
  __HAL_RCC_DMA2_CLK_ENABLE();

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOE_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOG_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOE, LED_FAIL2_Pin|FAIL_MBIC_Pin|ATT_CLOCK4_Pin|ATT_DATA4_Pin 
                          |ATT_EN_DL4_Pin|ATT_EN_UL4_Pin|PATH_EN_DL4_Pin|PATH_EN_UL4_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOC, BOOT_LED_Pin|PATH_EN_UL1_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOG, ATT_CLOCK3_Pin|ATT_DATA3_Pin|ATT_EN_DL3_Pin|ATT_EN_UL3_Pin 
                          |PATH_EN_DL3_Pin|PATH_EN_UL3_Pin|_PATH_SW1_Pin|PATH_SW1_Pin 
                          |_PATH_SW2_Pin|PATH_SW2_Pin|_PATH_SW3_Pin|PATH_SW3_Pin 
                          |_PATH_SW4_Pin|PATH_SW4_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, ATT_EN_UL1_Pin|PATH_EN_DL1_Pin|ATT_CLOCK1_Pin|ATT_DATA1_Pin 
                          |ATT_EN_DL1_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOD, PATH_EN_DL2_Pin|PATH_EN_UL2_Pin|LED_ACT_Pin|LED_FAIL_Pin 
                          |ATT_CLOCK2_Pin|ATT_DATA2_Pin|ATT_EN_DL2_Pin|ATT_EN_UL2_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pins : LED_FAIL2_Pin FAIL_MBIC_Pin ATT_CLOCK4_Pin ATT_DATA4_Pin 
                           ATT_EN_DL4_Pin ATT_EN_UL4_Pin PATH_EN_DL4_Pin PATH_EN_UL4_Pin */
  GPIO_InitStruct.Pin = LED_FAIL2_Pin|FAIL_MBIC_Pin|ATT_CLOCK4_Pin|ATT_DATA4_Pin 
                          |ATT_EN_DL4_Pin|ATT_EN_UL4_Pin|PATH_EN_DL4_Pin|PATH_EN_UL4_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

  /*Configure GPIO pins : BOOT_LED_Pin PATH_EN_UL1_Pin */
  GPIO_InitStruct.Pin = BOOT_LED_Pin|PATH_EN_UL1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pins : ATT_CLOCK3_Pin ATT_DATA3_Pin ATT_EN_DL3_Pin ATT_EN_UL3_Pin 
                           PATH_EN_DL3_Pin PATH_EN_UL3_Pin _PATH_SW1_Pin PATH_SW1_Pin 
                           _PATH_SW2_Pin PATH_SW2_Pin _PATH_SW3_Pin PATH_SW3_Pin 
                           _PATH_SW4_Pin PATH_SW4_Pin */
  GPIO_InitStruct.Pin = ATT_CLOCK3_Pin|ATT_DATA3_Pin|ATT_EN_DL3_Pin|ATT_EN_UL3_Pin 
                          |PATH_EN_DL3_Pin|PATH_EN_UL3_Pin|_PATH_SW1_Pin|PATH_SW1_Pin 
                          |_PATH_SW2_Pin|PATH_SW2_Pin|_PATH_SW3_Pin|PATH_SW3_Pin 
                          |_PATH_SW4_Pin|PATH_SW4_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);

  /*Configure GPIO pins : ATT_EN_UL1_Pin PATH_EN_DL1_Pin ATT_CLOCK1_Pin ATT_DATA1_Pin 
                           ATT_EN_DL1_Pin */
  GPIO_InitStruct.Pin = ATT_EN_UL1_Pin|PATH_EN_DL1_Pin|ATT_CLOCK1_Pin|ATT_DATA1_Pin 
                          |ATT_EN_DL1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pins : PATH_EN_DL2_Pin PATH_EN_UL2_Pin LED_ACT_Pin LED_FAIL_Pin 
                           ATT_CLOCK2_Pin ATT_DATA2_Pin ATT_EN_DL2_Pin ATT_EN_UL2_Pin */
  GPIO_InitStruct.Pin = PATH_EN_DL2_Pin|PATH_EN_UL2_Pin|LED_ACT_Pin|LED_FAIL_Pin 
                          |ATT_CLOCK2_Pin|ATT_DATA2_Pin|ATT_EN_DL2_Pin|ATT_EN_UL2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

 /**
  * @brief  Period elapsed callback in non blocking mode
  * @note   This function is called  when TIM2 interrupt took place, inside
  * HAL_TIM_IRQHandler(). It makes a direct call to HAL_IncTick() to increment
  * a global variable "uwTick" used as application time base.
  * @param  htim : TIM handle
  * @retval None
  */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  /* USER CODE BEGIN Callback 0 */

  /* USER CODE END Callback 0 */
  if (htim->Instance == TIM2) {
    HAL_IncTick();
  }
  /* USER CODE BEGIN Callback 1 */
  if(htim->Instance == TIM6){
      UartRxTimerCnt++;
      LedTimerCnt++;
      AdcTimerCnt++;
      LDTimerCnt++;
      ALCTimerCnt++;
      AGCTimerCnt++;
    if(bluecell_Currdatastatus.ULO_Shutdown_ON_OFF == true){
        for(int i = 0; i < DET_Alarm_UL_Shutdown_Index_MAX; i++){
            if(ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] == true){
                DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = 0; // OFF CNT = 0;
                DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i]++;
                if(DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] == 0xFFFFFFFF){
                    DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = MBIC_ON_SHUTDOWN_MAINTAIN_SEC;
                }
            }else{
                DET_UL_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = 0;
                DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i]++;
                if(DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] == 0xFFFFFFFF){
                    DET_UL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC;
                }
            }
            if(ADC_Alarm_UL_Normal_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] == true){
                DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i]++;
                if(DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] == 0xFFFFFFFF){
                    DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = MBIC_OFF_MAINTAIN_SEC;
                }                
            }else{
                DET_UL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_UL1_Shutdown_Index + i] = 0;
            }
        }
    }


    if(bluecell_Currdatastatus.DLI_Shutdown_ON_OFF == true){
        for(int i = 0; i < DET_Alarm_DL_Shutdown_Index_MAX; i++){
            if(ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] == true){
                DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = 0; // OFF CNT = 0;
                DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i]++;
                if(DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] == 0xFFFFFFFF){
                    DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = MBIC_ON_SHUTDOWN_MAINTAIN_SEC;
                }
            }else{
                DET_DL_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = 0;
                DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i]++;
                if(DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] == 0xFFFFFFFF){
                    DET_DL_Shutdown_Off_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = MBIC_RECOVERY_SHUTDOWN_MAINTAIN_SEC;
                }
            }
            if(ADC_Alarm_DL_Normal_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] == true){
                DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i]++;
                if(DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] == 0xFFFFFFFF){
                    DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = MBIC_OFF_MAINTAIN_SEC;
                }                
            }else{
                DET_DL_Normal_Shutdown_On_AlarmTimerCnt[DET_Alarm_DL1_Shutdown_Index + i] = 0;
            }
        }  
    }
      /*ALC Alarm timer start*/
      if(ALC_AlarmSet[ALC_Alarm_UL1_Index] == true){
          ALC_Off_AlarmTimerCnt[ALC_Alarm_UL1_Index] = 0;
          ALC_On_AlarmTimerCnt[ALC_Alarm_UL1_Index]++;
          if(ALC_On_AlarmTimerCnt[ALC_Alarm_UL1_Index] == 0xFFFFFFFF){
            ALC_On_AlarmTimerCnt[ALC_Alarm_UL1_Index] = MBIC_ON_MAINTAIN_SEC;
          }
      }else{
          ALC_On_AlarmTimerCnt[ALC_Alarm_UL1_Index] = 0;
          ALC_Off_AlarmTimerCnt[ALC_Alarm_UL1_Index]++;
          if(ALC_Off_AlarmTimerCnt[ALC_Alarm_UL1_Index] == 0xFFFFFFFF){
            ALC_Off_AlarmTimerCnt[ALC_Alarm_UL1_Index] = MBIC_OFF_MAINTAIN_SEC;
          }          
      }

      if(ALC_AlarmSet[ALC_Alarm_UL2_Index] == true){
          ALC_On_AlarmTimerCnt[ALC_Alarm_UL2_Index]++;
          ALC_Off_AlarmTimerCnt[ALC_Alarm_UL2_Index] = 0;
          if(ALC_On_AlarmTimerCnt[ALC_Alarm_UL2_Index] == 0xFFFFFFFF){
            ALC_On_AlarmTimerCnt[ALC_Alarm_UL2_Index] = MBIC_ON_MAINTAIN_SEC;
          }
      }else{
          ALC_On_AlarmTimerCnt[ALC_Alarm_UL2_Index] = 0;
          ALC_Off_AlarmTimerCnt[ALC_Alarm_UL2_Index]++;
          if(ALC_Off_AlarmTimerCnt[ALC_Alarm_UL2_Index] == 0xFFFFFFFF){
            ALC_Off_AlarmTimerCnt[ALC_Alarm_UL2_Index] = MBIC_OFF_MAINTAIN_SEC;
          }          
      }
      if(ALC_AlarmSet[ALC_Alarm_UL3_Index] == true){
          ALC_On_AlarmTimerCnt[ALC_Alarm_UL3_Index]++;
          ALC_Off_AlarmTimerCnt[ALC_Alarm_UL3_Index] = 0;
          if(ALC_On_AlarmTimerCnt[ALC_Alarm_UL3_Index] == 0xFFFFFFFF){
            ALC_On_AlarmTimerCnt[ALC_Alarm_UL3_Index] = MBIC_ON_MAINTAIN_SEC;
          }
      }else{
          ALC_On_AlarmTimerCnt[ALC_Alarm_UL3_Index] = 0;
          ALC_Off_AlarmTimerCnt[ALC_Alarm_UL3_Index]++;
          if(ALC_Off_AlarmTimerCnt[ALC_Alarm_UL3_Index] == 0xFFFFFFFF){
            ALC_Off_AlarmTimerCnt[ALC_Alarm_UL3_Index] = MBIC_OFF_MAINTAIN_SEC;
          }          
      }
      if(ALC_AlarmSet[ALC_Alarm_UL4_Index] == true){
          ALC_On_AlarmTimerCnt[ALC_Alarm_UL4_Index]++;
          ALC_Off_AlarmTimerCnt[ALC_Alarm_UL4_Index] = 0;
          if(ALC_On_AlarmTimerCnt[ALC_Alarm_UL4_Index] == 0xFFFFFFFF){
            ALC_On_AlarmTimerCnt[ALC_Alarm_UL4_Index] = MBIC_ON_MAINTAIN_SEC;
          }
      }else{
          ALC_On_AlarmTimerCnt[ALC_Alarm_UL4_Index] = 0;
          ALC_Off_AlarmTimerCnt[ALC_Alarm_UL4_Index]++;
          if(ALC_Off_AlarmTimerCnt[ALC_Alarm_UL4_Index] == 0xFFFFFFFF){
            ALC_Off_AlarmTimerCnt[ALC_Alarm_UL4_Index] = MBIC_OFF_MAINTAIN_SEC;
          }          
      }     

      /*AGC Alarm timer start*/      
      if(AGC_AlarmSet[AGC_Alarm_DL1_Index] == true){
          AGC_On_AlarmTimerCnt[AGC_Alarm_DL1_Index]++;
          AGC_Off_AlarmTimerCnt[AGC_Alarm_DL1_Index] = 0;
          if(AGC_On_AlarmTimerCnt[AGC_Alarm_DL1_Index] == 0xFFFFFFFF){
            AGC_On_AlarmTimerCnt[AGC_Alarm_DL1_Index] = MBIC_ON_MAINTAIN_SEC;
          }
      }else{
          AGC_On_AlarmTimerCnt[AGC_Alarm_DL1_Index] = 0;
          AGC_Off_AlarmTimerCnt[AGC_Alarm_DL1_Index]++;
          if(AGC_Off_AlarmTimerCnt[AGC_Alarm_DL1_Index] == 0xFFFFFFFF){
            AGC_Off_AlarmTimerCnt[AGC_Alarm_DL1_Index] = MBIC_OFF_MAINTAIN_SEC;
          }          
      }

      if(AGC_AlarmSet[AGC_Alarm_DL2_Index] == true){
          AGC_On_AlarmTimerCnt[AGC_Alarm_DL2_Index]++;
          AGC_Off_AlarmTimerCnt[AGC_Alarm_DL2_Index] = 0;
          if(AGC_On_AlarmTimerCnt[AGC_Alarm_DL2_Index] == 0xFFFFFFFF){
            AGC_On_AlarmTimerCnt[AGC_Alarm_DL2_Index] = MBIC_ON_MAINTAIN_SEC;
          }
      }else{
          AGC_On_AlarmTimerCnt[AGC_Alarm_DL2_Index] = 0;
          AGC_Off_AlarmTimerCnt[AGC_Alarm_DL2_Index]++;
          if(AGC_Off_AlarmTimerCnt[AGC_Alarm_DL2_Index] == 0xFFFFFFFF){
            AGC_Off_AlarmTimerCnt[AGC_Alarm_DL2_Index] = MBIC_OFF_MAINTAIN_SEC;
          }          
      }
      if(AGC_AlarmSet[AGC_Alarm_DL3_Index] == true){
          AGC_On_AlarmTimerCnt[AGC_Alarm_DL3_Index]++;
          AGC_Off_AlarmTimerCnt[AGC_Alarm_DL3_Index] = 0;
          if(AGC_On_AlarmTimerCnt[AGC_Alarm_DL3_Index] == 0xFFFFFFFF){
            AGC_On_AlarmTimerCnt[AGC_Alarm_DL3_Index] = MBIC_ON_MAINTAIN_SEC;
          }
      }else{
          AGC_On_AlarmTimerCnt[AGC_Alarm_DL3_Index] = 0;
          AGC_Off_AlarmTimerCnt[AGC_Alarm_DL3_Index]++;
          if(AGC_Off_AlarmTimerCnt[AGC_Alarm_DL3_Index] == 0xFFFFFFFF){
            AGC_Off_AlarmTimerCnt[AGC_Alarm_DL3_Index] = MBIC_OFF_MAINTAIN_SEC;
          }          
      }
      if(AGC_AlarmSet[AGC_Alarm_DL4_Index] == true){
          AGC_On_AlarmTimerCnt[AGC_Alarm_DL4_Index]++;
          AGC_Off_AlarmTimerCnt[AGC_Alarm_DL4_Index] = 0;
          if(AGC_On_AlarmTimerCnt[AGC_Alarm_DL4_Index] == 0xFFFFFFFF){
            AGC_On_AlarmTimerCnt[AGC_Alarm_DL4_Index] = MBIC_ON_MAINTAIN_SEC;
          }
      }else{
          AGC_On_AlarmTimerCnt[AGC_Alarm_DL4_Index] = 0;
          AGC_Off_AlarmTimerCnt[AGC_Alarm_DL4_Index]++;
          if(AGC_Off_AlarmTimerCnt[AGC_Alarm_DL4_Index] == 0xFFFFFFFF){
            AGC_Off_AlarmTimerCnt[AGC_Alarm_DL4_Index] = MBIC_OFF_MAINTAIN_SEC;
          }          
      }      
    


    /*********************UL LEVEL HIGH START****************************/

    if(ADC_Alarm_UL_Set[DET_Alarm_UL1_Index ] == true){
        
        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL1_Index]++;
        DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL1_Index] = 0;
        if(DET_UL_On_AlarmTimerCnt[DET_Alarm_UL1_Index] == 0xFFFFFFFF){
            DET_UL_On_AlarmTimerCnt[DET_Alarm_UL1_Index] = MBIC_ON_MAINTAIN_SEC;
        }
    }
    else{
        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL1_Index] = 0;
        DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL1_Index]++;
        if(DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL1_Index] == 0xFFFFFFFF){
            DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL1_Index] = MBIC_OFF_MAINTAIN_SEC;
        }    
    }

    if(ADC_Alarm_UL_Set[DET_Alarm_UL2_Index ] == true){
        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL2_Index]++;
        DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL2_Index] = 0;
        if(DET_UL_On_AlarmTimerCnt[DET_Alarm_UL2_Index] == 0xFFFFFFFF){
            DET_UL_On_AlarmTimerCnt[DET_Alarm_UL2_Index] = MBIC_ON_MAINTAIN_SEC;
        }    
    }
    else{
        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL2_Index] = 0;
        DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL2_Index]++;
        if(DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL2_Index] == 0xFFFFFFFF){
            DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL2_Index] = MBIC_OFF_MAINTAIN_SEC;
        }     
    }

    if(ADC_Alarm_UL_Set[DET_Alarm_UL3_Index ] == true){
        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL3_Index]++;
        DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL3_Index] = 0;     
        if(DET_UL_On_AlarmTimerCnt[DET_Alarm_UL3_Index] == 0xFFFFFFFF){
            DET_UL_On_AlarmTimerCnt[DET_Alarm_UL3_Index] = MBIC_ON_MAINTAIN_SEC;
        }    
    }
    else{
        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL3_Index] = 0;
        DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL3_Index]++;  
        if(DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL3_Index] == 0xFFFFFFFF){
            DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL3_Index] = MBIC_OFF_MAINTAIN_SEC;
        }     
    }

    if(ADC_Alarm_UL_Set[DET_Alarm_UL4_Index ] == true){
        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL4_Index]++;
        DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL4_Index] = 0;    
        if(DET_UL_On_AlarmTimerCnt[DET_Alarm_UL4_Index] == 0xFFFFFFFF){
            DET_UL_On_AlarmTimerCnt[DET_Alarm_UL4_Index] = MBIC_ON_MAINTAIN_SEC;
        }    
    }
    else{
        DET_UL_On_AlarmTimerCnt[DET_Alarm_UL4_Index] = 0;
        DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL4_Index]++;       
        if(DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL4_Index] == 0xFFFFFFFF){
            DET_UL_Off_AlarmTimerCnt[DET_Alarm_UL4_Index] = MBIC_OFF_MAINTAIN_SEC;
        }     
    }





    /*********************DL LEVEL LOW START****************************/
    if(ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index ] == true){
        
        DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL1_Index]++;
        DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL1_Index] = 0;
        if(DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL1_Index] == 0xFFFFFFFF){
            DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL1_Index] = MBIC_ON_MAINTAIN_SEC;
        }
    }
    else{
        DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL1_Index] = 0;
        DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL1_Index]++;
        if(DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL1_Index] == 0xFFFFFFFF){
            DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL1_Index] = MBIC_OFF_MAINTAIN_SEC;
        }    
    }

    if(ADC_Alarm_DL_Low_Set[DET_Alarm_DL2_Index ] == true){
        DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL2_Index]++;
        DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL2_Index] = 0;
        if(DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL2_Index] == 0xFFFFFFFF){
            DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL2_Index] = MBIC_ON_MAINTAIN_SEC;
        }    
    }
    else{
        DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL2_Index] = 0;
        DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL2_Index]++;
        if(DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL2_Index] == 0xFFFFFFFF){
            DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL2_Index] = MBIC_OFF_MAINTAIN_SEC;
        }     
    }

    if(ADC_Alarm_DL_Low_Set[DET_Alarm_DL3_Index ] == true){
        DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL3_Index]++;
        DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL3_Index] = 0;     
        if(DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL3_Index] == 0xFFFFFFFF){
            DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL3_Index] = MBIC_ON_MAINTAIN_SEC;
        }    
    }
    else{
        DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL3_Index] = 0;
        DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL3_Index]++;  
        if(DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL3_Index] == 0xFFFFFFFF){
            DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL3_Index] = MBIC_OFF_MAINTAIN_SEC;
        }     
    }

    if(ADC_Alarm_DL_Low_Set[DET_Alarm_DL4_Index ] == true){
        DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL4_Index]++;
        DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL4_Index] = 0;    
        if(DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL4_Index] == 0xFFFFFFFF){
            DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL4_Index] = MBIC_ON_MAINTAIN_SEC;
        }    
    }
    else{
        DET_DL_Low_On_AlarmTimerCnt[DET_Alarm_DL4_Index] = 0;
        DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL4_Index]++;       
        if(DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL4_Index] == 0xFFFFFFFF){
            DET_DL_Low_Off_AlarmTimerCnt[DET_Alarm_DL4_Index] = MBIC_OFF_MAINTAIN_SEC;
        }     
    }
    /*********************DL LEVEL LOW END****************************/    
    /*********************DL LEVEL HIGH START***************************/
    if(ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index ] == true){
        
        DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL1_Index]++;
        DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL1_Index] = 0;
        if(DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL1_Index] == 0xFFFFFFFF){
            DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL1_Index] = MBIC_ON_MAINTAIN_SEC;
        }
    }
    else{
        DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL1_Index] = 0;
        DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL1_Index]++;
        if(DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL1_Index] == 0xFFFFFFFF){
            DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL1_Index] = MBIC_OFF_MAINTAIN_SEC;
        }    
    }

    if(ADC_Alarm_DL_High_Set[DET_Alarm_DL2_Index ] == true){
        DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL2_Index]++;
        DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL2_Index] = 0;
        if(DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL2_Index] == 0xFFFFFFFF){
            DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL2_Index] = MBIC_ON_MAINTAIN_SEC;
        }    
    }
    else{
        DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL2_Index] = 0;
        DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL2_Index]++;
        if(DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL2_Index] == 0xFFFFFFFF){
            DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL2_Index] = MBIC_OFF_MAINTAIN_SEC;
        }     
    }

    if(ADC_Alarm_DL_High_Set[DET_Alarm_DL3_Index ] == true){
        DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL3_Index]++;
        DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL3_Index] = 0;     
        if(DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL3_Index] == 0xFFFFFFFF){
            DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL3_Index] = MBIC_ON_MAINTAIN_SEC;
        }    
    }
    else{
        DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL3_Index] = 0;
        DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL3_Index]++;  
        if(DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL3_Index] == 0xFFFFFFFF){
            DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL3_Index] = MBIC_OFF_MAINTAIN_SEC;
        }     
    }

    if(ADC_Alarm_DL_High_Set[DET_Alarm_DL4_Index ] == true){
        DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL4_Index]++;
        DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL4_Index] = 0;    
        if(DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL4_Index] == 0xFFFFFFFF){
            DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL4_Index] = MBIC_ON_MAINTAIN_SEC;
        }    
    }
    else{
        DET_DL_High_On_AlarmTimerCnt[DET_Alarm_DL4_Index] = 0;
        DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL4_Index]++;       
        if(DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL4_Index] == 0xFFFFFFFF){
            DET_DL_High_Off_AlarmTimerCnt[DET_Alarm_DL4_Index] = MBIC_OFF_MAINTAIN_SEC;
        }     
    }
      /*********************DL LEVEL HIGH END***************************/

#if 0 // PYJ.2020.06.19_BEGIN -- 
    if(ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index] == true){
        MBIC_ShutdownCnt[MBIC_Shutdown_DL1]++;
    }else{
        MBIC_ShutdownCnt[MBIC_Shutdown_DL1] = 0;        
    }
    if(ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL2_Shutdown_Index] == true){
        MBIC_ShutdownCnt[MBIC_Shutdown_DL2]++;
    }else{
        MBIC_ShutdownCnt[MBIC_Shutdown_DL2] = 0;        
    }
    if(ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL3_Shutdown_Index] == true){
        MBIC_ShutdownCnt[MBIC_Shutdown_DL3]++;
    }else{
        MBIC_ShutdownCnt[MBIC_Shutdown_DL3] = 0;        
    }
    if(ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL4_Shutdown_Index] == true){
        MBIC_ShutdownCnt[MBIC_Shutdown_DL4]++;
    }else{
        MBIC_ShutdownCnt[MBIC_Shutdown_DL4] = 0;        
    }

    if(ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index] == true){
        MBIC_ShutdownCnt[MBIC_Shutdown_UL1]++;
    }else{
        MBIC_ShutdownCnt[MBIC_Shutdown_UL1] = 0;        
    }
    if(ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL2_Shutdown_Index] == true){
        MBIC_ShutdownCnt[MBIC_Shutdown_UL2]++;
    }else{
        MBIC_ShutdownCnt[MBIC_Shutdown_UL2] = 0;        
    }
    if(ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL3_Shutdown_Index] == true){
        MBIC_ShutdownCnt[MBIC_Shutdown_UL3]++;
    }else{
        MBIC_ShutdownCnt[MBIC_Shutdown_UL3] = 0;        
    }
    if(ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL4_Shutdown_Index] == true){
        MBIC_ShutdownCnt[MBIC_Shutdown_UL4]++;
    }else{
        MBIC_ShutdownCnt[MBIC_Shutdown_UL4] = 0;        
    }
#endif // PYJ.2020.06.19_END -- 


        /*3 Sec Time Cnt */
    
      if(AlarmTimerOnSet == true){
        if(AlarmTimerOnCnt == 0xFFFFFFFF)
            AlarmTimerOnCnt = MBIC_ON_MAINTAIN_SEC;
        else{
            AlarmTimerOnCnt++;
        }
      }
      else{
        AlarmTimerOnCnt = 0;
      }

        
      /*10 Sec Time Cnt*/
      if(AlarmTimerOffSet == true){
        if(AlarmTimerOffCnt == 0xFFFFFFFF)
            AlarmTimerOffCnt = MBIC_OFF_MAINTAIN_SEC;
        else{
            AlarmTimerOffCnt++;
        }
      }
      else{
        AlarmTimerOffCnt = 0;
      }


      if(AlarmTimerOnSet == true){
        if(AlarmTimerOnCnt == 0xFFFFFFFF)
            AlarmTimerOnCnt = MBIC_ON_MAINTAIN_SEC;
        else{
            AlarmTimerOnCnt++;
        }
      }
      else{
        AlarmTimerOnCnt = 0;
      }

        
      /*10 Sec Time Cnt*/
      if(bluecell_Currdatastatus.Temp_High_Alarm == false){
        if(Alarm_Temp_TimerOffCnt >= 0xFFFFFFFF){
            Alarm_Temp_TimerOffCnt = MBIC_OFF_MAINTAIN_SEC;
        }
        else{
            Alarm_Temp_TimerOffCnt++;
        }
      }
      else{
        Alarm_Temp_TimerOffCnt = 0;
      }


      if(bluecell_Currdatastatus.Temp_High_Alarm == true){
        if(Alarm_Temp_TimerOnCnt >= 0xFFFFFFFF){
            Alarm_Temp_TimerOnCnt = MBIC_ON_MAINTAIN_SEC;
        }
        else{
            Alarm_Temp_TimerOnCnt++;
        }
      }
      else{
        Alarm_Temp_TimerOnCnt = 0;
      }







      /*10 Sec Time Cnt*/
      if(Alarm_DL_Level_TimerOffCnt == true){
        if(Alarm_DL_Level_TimerOffCnt == 0xFFFFFFFF)
            Alarm_DL_Level_TimerOffCnt = MBIC_OFF_MAINTAIN_SEC;
        else{
            Alarm_DL_Level_TimerOffCnt++;
        }
      }
      else{
        Alarm_DL_Level_TimerOffCnt = 0;
      }


      if(Alarm_DL_Level_TimerOnCnt == true){
        if(Alarm_DL_Level_TimerOnCnt == 0xFFFFFFFF)
            Alarm_DL_Level_TimerOnCnt = MBIC_ON_MAINTAIN_SEC;
        else{
            Alarm_DL_Level_TimerOnCnt++;
        }
      }
      else{
        Alarm_DL_Level_TimerOnCnt = 0;
      }        
      
     /*10 Sec Time Cnt*/
      if(Alarm_UL_Level_TimerOffCnt == true){
        if(Alarm_UL_Level_TimerOffCnt == 0xFFFFFFFF)
            Alarm_UL_Level_TimerOffCnt = MBIC_OFF_MAINTAIN_SEC;
        else{
            Alarm_UL_Level_TimerOffCnt++;
        }
      }
      else{
        Alarm_UL_Level_TimerOffCnt = 0;
      }


      if(Alarm_DL_Level_TimerOnCnt == true){
        if(Alarm_UL_Level_TimerOnCnt == 0xFFFFFFFF)
            Alarm_UL_Level_TimerOnCnt = MBIC_ON_MAINTAIN_SEC;
        else{
            Alarm_UL_Level_TimerOnCnt++;
        }
      }
      else{
        Alarm_UL_Level_TimerOnCnt = 0;
      }  
  }
  /* USER CODE END Callback 1 */
}

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */

  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{ 
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/