AWLU111001D1F7_SBSFU/Projects/STM32F407-Discovery/Applications/2_Images/AWLU111001D1F7/Src/freertos.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * File Name          : freertos.c
  * Description        : Code for freertos applications
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2019 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under Ultimate Liberty license
  * SLA0044, the "License"; You may not use this file except in compliance with
  * the License. You may obtain a copy of the License at:
  *                             www.st.com/SLA0044
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "cmsis_os.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

#include "dma.h" //Hao@20231020

#include "adc.h"
#include "crc.h"
#include "flash_if.h"
#include "gpio.h"
#include "iwdg.h"
#include "rtc.h"
#include "tim.h"
#include "usart.h"
#include "cp_detection.h"
#include "W25QXX.h"
#include "usbd_cdc_if.h"
#include "time.h"
#include "driver_meter.h"
#include "i2c.h"

#ifdef FUNC_LIN_CP
#include "LinCP.h"
#endif

#ifdef FUNC_EKM_OMNIMETER
#include "EKM_Omnimeter.h"
#endif

#ifdef FUNC_AES256
#include "..\Middlewares\AES256\aes256.h"
#endif

#ifdef FUNC_ECDSA
#include "cmox_crypto.h"
#endif


/* 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 ---------------------------------------------------------*/
/* USER CODE BEGIN Variables */

#ifdef FUNC_SYSTEM_KEEP_INFO
__no_init __root SystemKeepInfo g_SystemKeepInfo;
void SystemKeepInfo_Display(PSystemKeepInfo p)
{
    u32 crc32 = HAL_CRC_Calculate(&hcrc, (u32*)p->m_Buf, (sizeof(p->m_Buf) >> 2));
//    XP("=======<SYSTEM_KEEP_INFO>=======\r\n");
//    XP("BootCount = %d\r\n", p->m_BootCount);
//    XP("CsuIsRequestOn = %d\r\n", p->m_CsuIsRequestOn);
//    XP("CpPwmVal = %d\r\n", p->m_CpPwmVal);
//    XP("CRC32 = 0x%04X (%s)\r\n", p->m_CRC32, (p->m_CRC32 == crc32 ? "OK" : "NG"));
//    XP("CRC32_CALC = 0x%04X\r\n", crc32);
//    XP("================================\r\n");
    DEBUG_INFO("BootCount(%d) CsuIsRequestOn(%d) CpPwmVal(%d) CRC32(0x%04X,%s)\r\n",
       p->m_BootCount, p->m_CsuIsRequestOn, p->m_CpPwmVal, p->m_CRC32, (p->m_CRC32 == crc32 ? "OK" : "NG"));
}
void SystemKeepInfo_Update(PSystemKeepInfo p)
{
    u32 crc32 = HAL_CRC_Calculate(&hcrc, (u32*)p->m_Buf, (sizeof(p->m_Buf) >> 2));
    p->m_CRC32 = crc32;
}

HTK_BOOL SystemKeepInfo_Check(PSystemKeepInfo p)
{
    u32 crc32 = HAL_CRC_Calculate(&hcrc, (u32*)p->m_Buf, (sizeof(p->m_Buf) >> 2));
    return (p->m_CRC32 == crc32 ? HTK_TRUE : HTK_FALSE);
}
#endif //FUNC_SYSTEM_KEEP_INFO

uint32_t alarm_record_code[32] =
{
    0x00012200,         // Input L1 OVP
    0x00012203,         // Input L1 UVP
    0x00012216,         // Output L1 OCP
    0x00012223,         // Over temperature
    0x00012255,         // Ground fault
    0x00023703,         // Pilot error
    0x00012233,         // AC CCID
    0x00012233,         // DC CCID

    0x00012256,         // MCU self test
    0x00012258,         // Hand shaking timeout
    0x00012251,         // Emergency stop
    0x00011009,         // Relay welding
    0x00011032,         // Leak module test fail
    0x00011034,         // shutter fault
    0x00012212,         // L1 Power drop
    0x00012262,         // L1 Circuit short

    0x00011033,         // Maximum Output Current setup error
    0x00011010,         // AC output relay  driving fault
    0x00011035,         // Ble module broken
    0x00012201,         // Input L2 OVP
    0x00012202,         // Input L3 OVP
    0x00012204,         // Input L2 UVP
    0x00012205,         // Input L3 UVP
    0x00012299,         // Output L2 OCP

    0x00012300,         // Output L3 OCP
    0x00012301,         // L2 Circuit short
    0x00012302,         // L3 Circuit short
    0x00000000,
    0x00000000,
    0x00000000,
    0x00000000
};

uint32_t binCRCTarget, binCRCCal;
__IO uint32_t flashdestination;
__IO uint32_t newdestination;

volatile unsigned long  ulHighFrequencyTimerTicks;

sCPModuleResult_t CpDetectionResult;

#ifndef FUNC_CP_ADC_MODIFY
sCPVoltageBoundary_t CpBoundary = {
                        CP_P12V_HIGH,
                        CP_P12V_LOW,
                        CP_P9V_HIGH,
                        CP_P9V_LOW,
                        CP_P6V_HIGH,
                        CP_P6V_LOW,
                        CP_P3V_HIGH,
                        CP_P3V_LOW,
                        CP_0V_HIGH,
                        CP_0V_LOW,
                        CP_N12V_HIGH,
                        CP_N12V_LOW,
                    };

sCPVoltageBoundary_t SpecDefBoundary = {
                        CP_SPEC_P12V_HIGH,
                        CP_SPEC_P12V_LOW,
                        CP_SPEC_P9V_HIGH,
                        CP_SPEC_P9V_LOW,
                        CP_SPEC_P6V_HIGH,
                        CP_SPEC_P6V_LOW,
                        CP_SPEC_P3V_HIGH,
                        CP_SPEC_P3V_LOW,
                        CP_SPEC_0V_HIGH,
                        CP_SPEC_0V_LOW,
                        CP_SPEC_N12V_HIGH,
                        CP_SPEC_N12V_LOW,
                    };

sCPVoltageHysteresis_t CpHysteresis = {
                        HYSTERESIS_P12V_HIGH,
                        HYSTERESIS_P12V_LOW,
                        HYSTERESIS_P9V_HIGH,
                        HYSTERESIS_P9V_LOW,
                        HYSTERESIS_P6V_HIGH,
                        HYSTERESIS_P6V_LOW,
                        HYSTERESIS_P3V_HIGH,
                        HYSTERESIS_P3V_LOW,
                        HYSTERESIS_0V_HIGH,
                        HYSTERESIS_0V_LOW,
                    };
#endif //FUNC_CP_ADC_MODIFY

struct EVSE Charger;
const unsigned char CharacterArray[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
uint32_t test_logA = 0 ;
uint32_t test_logB = 0 ;

extern I2C_HandleTypeDef hi2c2;
/* USER CODE END Variables */
#ifndef DISABLE_OS_ETH_TASK
osThreadId ethTaskHandle;
#endif

osThreadId uartTaskHandle;
osThreadId adcTaskHandle;
osThreadId timeoutTaskHandle;
osThreadId rfidTaskHandle;
osThreadId led_speakerTaskHandle;
osThreadId cpTaskHandle;
osThreadId alarmTaskHandle;
osThreadId bleTaskHandle;
osThreadId memoryTaskHandle;
osThreadId wifiTaskHandle;
osThreadId MeterTaskHandle;

#ifdef RECODE_FUNC_METER_IC_TASK
osThreadId MeterIcTaskHandle;
#endif

#ifdef FUNC_TASK_MONITOR
osThreadId MonitorTaskHandle;
#endif

#ifdef FUNC_LIN_CP
osThreadId LinCpTaskHandle;
#endif

#ifdef FUNC_VERIFY_TASK
osThreadId VerifyTaskHandle;
#endif

#ifdef FUNC_METER_IC_READ_PHASE_ANGLE
char *AC_PERIOD_MODE_STR[AC_PERIOD_MODE_NUM] = { "?Hz", "50Hz", "60Hz" };
char *AC_PHASE_MODE_STR[AC_PHASE_MODE_NUM] = { "?", "AC_PHASE_MODE_1P", "240_120_120_SEQ_OK", "120_120_240_SEQ_NG", "360_360_360" };
#endif
/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN FunctionPrototypes */

#ifdef FUNC_RS485_SLAVE
uint8_t isValidCheckSum_IAP(uint8_t *RxBuf);
#else
uint8_t isValidCheckSum_IAP(void);
#endif

uint8_t isValidCheckSum_BLE(void);
uint8_t isValidCheckSum_WIFI(void);
void setChargerMode(uint8_t mode);
uint8_t isModeChange(void);
uint8_t isMode(uint8_t mode);
uint8_t rfidCheckSumCal(uint8_t *data, uint8_t length);
uint8_t Test_LeakModule(void);
uint8_t Valid_RFID_SN(void);
void recordAlarmHis(void);

#ifdef FUNC_METER_IC_HISTORY
uint8_t recordMeterICHis(MeterIC_CaliValType Type, int32_t Val);
#else
uint8_t recordChargingHis(uint8_t isColdLoadPickUp, uint32_t statusCode);
#endif

void setLedMotion(uint8_t action);

#ifdef FUNC_CUSTOMIZED_LED_MODE_FROM_CSU
void setLedMotion_User(uint8_t action, PLED_UserCfg p);
#endif

#ifdef FUNC_AW48_NET_LED
void setNetLedMotion(uint8_t action);
#endif

void getlastRecord(void);
void getRotarySwitchSetting(void);
void CLC_Corr_Gain_Par(uint16_t SpecData_H ,uint16_t SpecData_L ,uint16_t MCUData_H , uint16_t MCUData_L , float *GainA , float *GainB ) ;
void CLC_Corr_Gain_Par2(uint16_t SpecData_H ,uint16_t SpecData_L ,uint16_t MCUData_H , uint16_t MCUData_L , float *GainA , float *GainB , uint8_t *PosorNeg ) ;
uint8_t Array_data_Check ( uint8_t *s1, uint8_t *s2 ) ;

void Relay_Control_Function (void) ;

#ifdef FUNC_OUTP_TYPE_E
void SE_Relay_Control_Function(void);
#endif

uint8_t WatchDogLeakRawDataCheck_Event(void) ;
uint16_t getBrightnessDuty(uint16_t max_duty);
void parseVersionInfoFromModelname(void);

#ifdef ENABLE_PRINT_IMCP_MSG
int CheckPrintImcpMsg(uint8_t MsgID);
#endif

#ifdef MODIFY_IMCP
void UpdateCheckSum(uint8_t *Buf, uint16_t Len);
#endif

#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
void ColdLoadPickup_Delay(const char* Description);
#endif

#ifdef FUNC_FORCE_RUN_CSU_MODE_WITH_DC_MODELNAME
void Update_McuCtrlMode(void);
#endif

#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
void IdleUntilReadAllMemory(void);
#endif

#ifdef FUNC_IDLE_UNTIL_INIT_METER_IC
void IdleUntilInitMeterIC(void);
#endif

#ifdef FUNC_GUN_LOCK
void GL_Init(void);
////void GL_Lock(void);
void GL_Unlock(void);
HTK_BOOL GL_IsLock(void);
void GL_Trig(GL_MODE mode);
void GL_Proc(void);
#endif

#ifdef FUNC_AX32_TRIG_LEAKAGE
void TrigLeakage_Init(void);
void TrigLeakage_Trig(void);
void TrigLeakage_Proc(void);
#endif

#ifdef MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK
void AlarmDetect_RelayWelding_UseADC(void);
#ifdef FUNC_USE_RELAY_B_CONTACT
HTK_BOOL IsRelayContact_Closed(void);
void AlarmDetect_RelayWelding_UseGPIO(void);
#endif
#endif //MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK

#ifdef FUNC_AX80_ADD_TILT_SENSOR
void TILT_TrigLeakage_Init(void);
void TILT_TrigLeakage_Trig(void);
void TILT_TrigLeakage_Proc(void);
void AlarmDetect_TiltSensor(void);
#endif

#ifdef MODIFY_DC_RS485_UPGRADE_ISSUE
void RS485_TX_Enable(void);
void RS485_TX_Disable(void);
void Prefix_UartTX(uint8_t* TxBuf, uint8_t* RxBuf);
void Postfix_UartTX(uint8_t* TxBuf, uint8_t* RxBuf);
#endif

#ifdef FUNC_RS485_BLE_SW
void RS485_SW(HTK_BOOL bON);
void BLE_SW(HTK_BOOL bON);
#endif

#ifdef FUNC_LIN_EN_SW
void LIN_EN(HTK_BOOL bEnable);
void LIN_SW(HTK_BOOL bUseLIN);
#endif

#ifdef FUNC_AW48_NET_LED
void Proc_NetLedActionSubState(void);
#endif

#ifdef FUNC_AES256
HTK_BOOL AES256_Verify(u8* Data, int DataLen, u8* Key, u8* IV, u8* RemoteEncryptedData);
void AES256_Test(void);
#endif

#ifdef FUNC_ECDSA
HTK_BOOL ECDSA_Verify(u8* PublicKey, int PublicKeyLen, u8* Hash, int HashLen, u8* Signature, int SignatureLen);
void ECDSA_VerifyTest(void);
#endif

/* USER CODE END FunctionPrototypes */

#ifndef DISABLE_OS_ETH_TASK
void StartEthTask(void const * argument);
#endif

void StartUartTask(void const * argument);
void StartAdcTask(void const * argument);
void StartTimeoutTask(void const * argument);

#ifdef FUNC_ENABLE_USART1_RFID
void StartRfidTask(void const * argument);
#endif

void StartLedSpeakerTask(void const * argument);
void StartCpTask(void const * argument);
void StartAlarmTask(void const * argument);
void StartBleTask(void const * argument);
void StartMemoryTask(void const * argument);
void StartWifiTask(void const * argument);
void StartMeterTask(void const * argument);

#ifdef RECODE_FUNC_METER_IC_TASK
void StartMeterIcTask(void const * argument);
#endif

#ifdef FUNC_TASK_MONITOR
void StartMonitorTask(void const * argument);
#endif

#ifdef FUNC_LIN_CP
void StartLinCpTask(void const * argument);
#endif

#ifdef FUNC_VERIFY_TASK
void StartVerifyTask(void const * argument);
#endif

extern void MX_USB_DEVICE_Init(void);
void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */

/* GetIdleTaskMemory prototype (linked to static allocation support) */
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize );

/* Hook prototypes */
void configureTimerForRunTimeStats(void);
unsigned long getRunTimeCounterValue(void);

/* USER CODE BEGIN 1 */
/* Functions needed when configGENERATE_RUN_TIME_STATS is on */
__weak void configureTimerForRunTimeStats(void)
{
  ulHighFrequencyTimerTicks = 0ul;
}

__weak unsigned long getRunTimeCounterValue(void)
{
  return ulHighFrequencyTimerTicks;
}
/* USER CODE END 1 */

/* USER CODE BEGIN GET_IDLE_TASK_MEMORY */
static StaticTask_t xIdleTaskTCBBuffer;
static StackType_t xIdleStack[configMINIMAL_STACK_SIZE];

void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize )
{
  *ppxIdleTaskTCBBuffer = &xIdleTaskTCBBuffer;
  *ppxIdleTaskStackBuffer = &xIdleStack[0];
  *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
  /* place for user code */
}
/* USER CODE END GET_IDLE_TASK_MEMORY */

/**
  * @brief  FreeRTOS initialization
  * @param  None
  * @retval None
  */

void UpdateFirmwareVersion(void)
{
#ifdef FUNC_FW_VER_TRACE

#if (FW_VER_NUM >= 1000)
//--------------------------------------------------------------
#if (FW_VER_TYPE == FW_VER_TYPE_DEVELOP)

#ifdef FORCE_VER_WITH_T_PREFIX
    sprintf(Charger.Ver_FW, "T%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#else
    sprintf(Charger.Ver_FW, "D%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
    //sprintf(Charger.Ver_FW, "D0.02.X0.0011.P0"); //test
#endif

#elif (FW_VER_TYPE == FW_VER_TYPE_PVT)

#ifdef FORCE_VER_WITH_T_PREFIX

#ifdef FORCE_VER_WITH_F_PREFIX
    sprintf(Charger.Ver_FW, "F%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#else
    sprintf(Charger.Ver_FW, "T%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#endif

#else //FORCE_VER_WITH_T_PREFIX

#ifdef AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX48_MODELNAME_WITH_CSU
    if (
            (       Charger.m_bModelNameAX48_1P

#ifdef AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX32_MODELNAME_WITH_CSU
                ||  Charger.m_bModelNameAX32_3P
#endif
            )
            &&
            IS_CSU_MOUNTED) //With CSU
    {
        sprintf(Charger.Ver_FW, "V%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
    }
    else
    {
        sprintf(Charger.Ver_FW, "B%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
    }
#else
    sprintf(Charger.Ver_FW, "B%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#endif

#endif //FORCE_VER_WITH_T_PREFIX

#elif (FW_VER_TYPE == FW_VER_TYPE_FORMAL)
    sprintf(Charger.Ver_FW, "V%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#elif (FW_VER_TYPE == FW_VER_TYPE_TEST)
    sprintf(Charger.Ver_FW, "T%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#endif
//--------------------------------------------------------------
#else //(FW_VER_NUM >= 1000)

#if (FW_VER_TYPE == FW_VER_TYPE_DEVELOP)
    sprintf(Charger.Ver_FW, "D%4.2f.X0.0011.P0", FW_VER_NUM * 0.01);
#elif (FW_VER_TYPE == FW_VER_TYPE_PVT)

#ifdef FORCE_VER_WITH_T_PREFIX

    //---------------
#ifdef FORCE_VER_WITH_F_PREFIX
    sprintf(Charger.Ver_FW, "F%4.2f.X0.0011.P0", FW_VER_NUM * 0.01);
#else
    sprintf(Charger.Ver_FW, "T%4.2f.X0.0011.P0", FW_VER_NUM * 0.01);
#endif
    //---------------

    //sprintf(Charger.Ver_FW, "T%4.2f.X0.0011.P0", FW_VER_NUM * 0.01);
#else //FORCE_VER_WITH_T_PREFIX

#ifdef AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX48_MODELNAME_WITH_CSU
    if (
            (       Charger.m_bModelNameAX48_1P

#ifdef AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX32_MODELNAME_WITH_CSU
                ||  Charger.m_bModelNameAX32_3P
#endif

#ifdef AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX80_MODELNAME_WITH_CSU
                ||  Charger.m_bModelNameAX80_1P
#endif
            )
            &&
            IS_CSU_MOUNTED) //With CSU
    {
        sprintf(Charger.Ver_FW, "V%4.2f.X0.0011.P0", FW_VER_NUM * 0.01);
    }
    else
    {
        sprintf(Charger.Ver_FW, "B%4.2f.X0.0011.P0", FW_VER_NUM * 0.01);
    }
#else //AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX48_MODELNAME_WITH_CSU
    sprintf(Charger.Ver_FW, "B%4.2f.X0.0011.P0", FW_VER_NUM * 0.01);
#endif //AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX48_MODELNAME_WITH_CSU
#endif //FORCE_VER_WITH_T_PREFIX

#elif (FW_VER_TYPE == FW_VER_TYPE_FORMAL)
    sprintf(Charger.Ver_FW, "V%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#elif (FW_VER_TYPE == FW_VER_TYPE_TEST)
    sprintf(Charger.Ver_FW, "T%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#endif

#endif //(FW_VER_NUM >= 1000)

#else //FUNC_FW_VER_TRACE

  //sprintf(Charger.Ver_FW, "D0.11.X0.0011.P0");
  //sprintf(Charger.Ver_FW, "D0.12.X0.0011.P0");    //AX_1P, AX_3P Generic version (=>Git)
  //sprintf(Charger.Ver_FW, "D0.13.X0.0011.P0");    //0.13.001: POWER_CONSUME_64_BIT, CDFA_V2
  //sprintf(Charger.Ver_FW, "D0.13.X0.0011.P0");      //0.13.002: FUNC_METER_IC_COMM_ALARM, CDFA_V3
  //sprintf(Charger.Ver_FW, "D0.14.X0.0011.P0");      //0.14.000: MODIFY_CPTASK_CSU_0_1_CHARGE_MODE (Fix UL test issue) + Relay welding
  //sprintf(Charger.Ver_FW, "D0.15.X0.0011.P0");      //0.15: FUNC_NEW_RELAY_MONITOR, FUNC_ZEROING_WHEN_MEM_CLEARNED
  //sprintf(Charger.Ver_FW, "D0.16.X0.0011.P0");      //0.16: FUNC_NEW_RELAY_MONITOR/Relay_LL_DriveFault_Slop/Relay_LL_DriveFault_Offs

#endif //FUNC_FW_VER_TRACE

#ifdef FUNC_VERSION_USE_NEW_SPEC_20240926
    //Indicate firmware belong which module board
    //L: LED board
    //R: Relay board
    //C: CHAdeMO board
    //G: GBT board
    //F: Fan board
    //D: DCM 407
    //A: AC main board
    //S: CCS board
    //M: CSU board
    Charger.Ver_FW[6] = 'A';

    //0: For formal release specification
    //1: For lab certificate specification
#ifdef FUNC_VERSION_FOR_LAB_CERTIFICATE_SPEC
    Charger.Ver_FW[7] = '1';
#else
    Charger.Ver_FW[7] = '0';
#endif
#endif //FUNC_VERSION_USE_NEW_SPEC_20240926
}

//---------------
#ifdef FUNC_STM32_FLASH_INFO

enum { STM32_UID_LEN = 12 }; //96 bits (12 bytes)

typedef struct _STM32_Flash_Info
{
    union
    {
        u8 m_UID[STM32_UID_LEN];
        u32 m_UIDw[3];
    };
    u32 m_DeviceID;
    u32 m_FlashSizeKB;
}
STM32_Flash_Info, *PSTM32_Flash_Info;

void STM32_Flash_Info_Init(PSTM32_Flash_Info p)
{
    memset(p, 0, sizeof(STM32_Flash_Info));
}

void STM32_Flash_Info_Read(PSTM32_Flash_Info p)
{
    //UID
    memcpy(p->m_UID, (u8*)UID_BASE, STM32_UID_LEN);

    //Device ID
    p->m_DeviceID = (uint32_t)(READ_BIT(DBGMCU->IDCODE, DBGMCU_IDCODE_DEV_ID));

    //Flash size
    p->m_FlashSizeKB = (uint32_t)(READ_REG(*((uint32_t *)FLASHSIZE_BASE)) & 0xFFFF);
}

void STM32_Flash_Info_Disp(PSTM32_Flash_Info p)
{
    XP("[FlashInfo]------------------------\r\n");
    //UID
    HTK_ByteArray2HexStr_XP("UID", p->m_UID, 0, STM32_UID_LEN);

    //Device ID
    XP("DeviceID: 0x%03X\r\n", p->m_DeviceID);
    {
        char *s = "DeviceFamily: ";
        if (p->m_DeviceID == 0x413)
        {
            XP("%sSTM32F40xxx/F41xxx\r\n", s);
        }
        else if (p->m_DeviceID == 0x419)
        {
            XP("%sSTM32F42xxx/F43xxx\r\n", s);
        }
        else
        {
            XP("%sUnknow\r\n", s);
        }
    }
    //Flash size
    XP("DeviceFlashSize: %d Kbytes\r\n", p->m_FlashSizeKB);

#ifdef FUNC_DISP_MCU_CLOCK_INFO
    XP("PWR->CR: 0x%08X, PWR->CSR: 0x%08X\r\n", PWR->CR, PWR->CSR);
#endif

}

void STM32_Flash_Info_Proc(void)
{
    PSTM32_Flash_Info p = HTK_Malloc(sizeof(STM32_Flash_Info));
    if (p != NULL)
    {
        STM32_Flash_Info_Init(p);
        STM32_Flash_Info_Read(p);
        STM32_Flash_Info_Disp(p);
    }
    else
    {
        XP("PSTM32_Flash_Info malloc NG\r\n");
    }
}

#endif //FUNC_STM32_FLASH_INFO

#ifdef FUNC_STM32_FLASH_OPTION_BYTES

typedef struct _STM32_Flash_OB
{

    FLASH_OBProgramInitTypeDef m_SetOB;
    FLASH_OBProgramInitTypeDef m_CurOB;

    u8 m_nRST_STDBY:  1;    //0: Reset generated when entering the Standby mode
                            //1: No reset generated

    u8 m_nRST_STOP:   1;    //0: Reset generated when entering the Stop mode
                            //1: No reset generated

    u8 m_WDG_SW:      1;    //0: Hardware independent watchdog
                            //1: Software independent watchdog

}
STM32_Flash_OB, *PSTM32_Flash_OB;

void STM32_Flash_OB_Init(PSTM32_Flash_OB p)
{
    memset(p, 0, sizeof(STM32_Flash_OB));

    //Set default
    p->m_SetOB.OptionType   = OPTIONBYTE_WRP /*| OPTIONBYTE_RDP*/ | OPTIONBYTE_USER | OPTIONBYTE_BOR;
    p->m_SetOB.WRPState     = OB_WRPSTATE_ENABLE;
    p->m_SetOB.Banks        = 0;
    p->m_SetOB.BORLevel     = OB_BOR_LEVEL3;
    p->m_SetOB.USERConfig   = OB_IWDG_SW | OB_STOP_NO_RST | OB_STDBY_NO_RST;

#ifdef FUNC_USE_STM32_SBSFU
    //Sector_0~4: Write Protection; Sector_5~11: No Write Protection
    p->m_SetOB.WRPSector    = OB_WRP_SECTOR_0 | OB_WRP_SECTOR_1 | OB_WRP_SECTOR_2 | OB_WRP_SECTOR_3 | OB_WRP_SECTOR_4;
    p->m_SetOB.RDPLevel     = OB_RDP_LEVEL_1;
#else
    //Sector_0~11: No Write Protection
    p->m_SetOB.WRPSector    = ~OB_WRP_SECTOR_All;
    p->m_SetOB.RDPLevel     = OB_RDP_LEVEL_0;
#endif

}

void STM32_Flash_OB_Read(PSTM32_Flash_OB p)
{
    __HAL_FLASH_PREFETCH_BUFFER_DISABLE();
    HAL_FLASHEx_OBGetConfig(&p->m_CurOB);
    __HAL_FLASH_PREFETCH_BUFFER_ENABLE();

    p->m_nRST_STDBY = BIT_GET(p->m_CurOB.USERConfig, 7);
    p->m_nRST_STOP = BIT_GET(p->m_CurOB.USERConfig, 6);
    p->m_WDG_SW = BIT_GET(p->m_CurOB.USERConfig, 5);
}

void STM32_Flash_OB_WriteDefault(PSTM32_Flash_OB p)
{
    XP("<Write default OB>\r\n");
    __HAL_FLASH_PREFETCH_BUFFER_DISABLE();
    HAL_FLASH_Unlock();
    HAL_FLASH_OB_Unlock();
    {
        {
            XP("<Set OB Default>\r\n");
            HAL_FLASHEx_OBProgram(&p->m_SetOB);
            HAL_FLASH_OB_Launch();
        }

        {
            FLASH_OBProgramInitTypeDef ob;
            memcpy(&ob, &p->m_SetOB, sizeof(p->m_SetOB));
            ob.OptionType = OPTIONBYTE_WRP;
            ob.WRPState = OB_WRPSTATE_DISABLE;

            ob.WRPSector = (~p->m_SetOB.WRPSector) & OB_WRP_SECTOR_All;

            XP("<Set OB.WRPSector => Disable>\r\n");
            HAL_FLASHEx_OBProgram(&ob);
            HAL_FLASH_OB_Launch();
        }

        if (p->m_CurOB.RDPLevel == OB_RDP_LEVEL_0 && p->m_SetOB.RDPLevel == OB_RDP_LEVEL_1)
        {
            FLASH_OBProgramInitTypeDef ob;
            memcpy(&ob, &p->m_SetOB, sizeof(p->m_SetOB));
            ob.OptionType = OPTIONBYTE_RDP;

            XP("<Set OB.RDPLevel => Level 1> Please power off and then power on to restart !\r\n");
            HAL_FLASHEx_OBProgram(&ob);
            HAL_FLASH_OB_Launch();

            /* Set the OPTSTRT bit in OPTCR register */
//            XP("*(__IO uint8_t *)OPTCR_BYTE0_ADDRESS |= FLASH_OPTCR_OPTSTRT [BEG]\r\n");
//            *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS |= FLASH_OPTCR_OPTSTRT;
//            XP("*(__IO uint8_t *)OPTCR_BYTE0_ADDRESS |= FLASH_OPTCR_OPTSTRT [BEG]\r\n");
            //HAL_Delay(1000);
            //NVIC_SystemReset();
        }
    }
    HAL_FLASH_OB_Lock();
    HAL_FLASH_Lock();
    __HAL_FLASH_PREFETCH_BUFFER_ENABLE();
}

void STM32_Flash_OB_Disp(PSTM32_Flash_OB p)
{
    XP("[OB]-------------------------------\r\n");
    XP("OptionType: 0x%08X\r\n", p->m_CurOB.OptionType);
    XP("WRPState  : 0x%08X\r\n", p->m_CurOB.WRPState);

    XP("WRPSector : 0x%08X\r\n", p->m_CurOB.WRPSector);
    {
        for (int i = 0; i < 12; i++)
        {
            XP("\tSector_%d: %s Protection\r\n", i, BIT_GET(p->m_CurOB.WRPSector, i) == 1 ? "No" : "Write");
        }
    }

    XP("Banks     : 0x%08X\r\n", p->m_CurOB.Banks);
    XP("RDPLevel  : 0x%08X (0: 0xAA, 1: 0x55, 2: 0xCC)\r\n", p->m_CurOB.RDPLevel);
    XP("BORLevel  : 0x%08X (3: 0x00, 2: 0x04, 1: 0x08, OFF: 0x0C)\r\n", p->m_CurOB.BORLevel);

    XP("USERConfig: 0x%02X\r\n", p->m_CurOB.USERConfig);
    {
        XP("\tnRST_STDBY = %d (%s)\r\n", p->m_nRST_STDBY, (p->m_nRST_STDBY == 0 ? "STDBY_RST(0)" : "STDBY_NO_RST(0x80)"));
        XP("\tnRST_STOP = %d (%s)\r\n", p->m_nRST_STOP, (p->m_nRST_STOP == 0 ? "STOP_RST(0)" : "STOP_NO_RST(0x40)"));
        XP("\tWDG_SW = %d (%s)\r\n", p->m_WDG_SW, (p->m_WDG_SW == 0 ? "IWDG_HW(0)" : "IWDG_SW(0x20)"));
    }
}

HTK_BOOL STM32_Flash_OB_IsDefault(PSTM32_Flash_OB p)
{
    XP("m_CurOB.BORLevel   = 0x%08X,   m_SetOB.BORLevel   = 0x%08X\r\n", p->m_CurOB.BORLevel, p->m_SetOB.BORLevel);
    XP("m_CurOB.RDPLevel   = 0x%08X,   m_SetOB.RDPLevel   = 0x%08X\r\n", p->m_CurOB.RDPLevel, p->m_SetOB.RDPLevel);
    XP("m_CurOB.USERConfig = 0x%08X,   m_SetOB.USERConfig = 0x%08X\r\n", p->m_CurOB.USERConfig, p->m_SetOB.USERConfig);
    XP("m_CurOB.WRPSector  = 0x%08X,   m_SetOB.WRPSector  = 0x%08X\r\n", p->m_CurOB.WRPSector, p->m_SetOB.WRPSector);
    XP("(~p->m_SetOB.WRPSector) & OB_WRP_SECTOR_All           = 0x%08X\r\n", (~p->m_SetOB.WRPSector) & OB_WRP_SECTOR_All);

    if  (
            (p->m_CurOB.BORLevel == p->m_SetOB.BORLevel) &&
            (p->m_CurOB.RDPLevel == p->m_SetOB.RDPLevel) &&
            (p->m_CurOB.USERConfig == p->m_SetOB.USERConfig) &&
            (p->m_CurOB.WRPSector == ((~p->m_SetOB.WRPSector) & OB_WRP_SECTOR_All))
        )
    {
        XP("<OB is Default>\r\n");
        return HTK_TRUE;
    }
    else
    {
        XP("<OB is NOT Default>\r\n");
        return HTK_FALSE;
    }
}

void STM32_Flash_OB_ProcDefault(void)
{
    PSTM32_Flash_OB p = HTK_Malloc(sizeof(STM32_Flash_OB));
    if (p != NULL)
    {
        STM32_Flash_OB_Init(p);
        STM32_Flash_OB_Read(p);
        STM32_Flash_OB_Disp(p);

        if (!STM32_Flash_OB_IsDefault(p))
        {
            STM32_Flash_OB_WriteDefault(p);
            STM32_Flash_OB_Read(p);
            STM32_Flash_OB_Disp(p);
            if (STM32_Flash_OB_IsDefault(p))
            {
                XP("<Write default OB success>\r\n");
            }
            else
            {
                XP("<Write default OB fail>\r\n");
            }
        }
    }
    else
    {
        XP("STM32_Flash_OB malloc NG\r\n");
    }
}
#endif //FUNC_STM32_FLASH_OPTION_BYTES

void MX_FREERTOS_Init(void) {
  /* USER CODE BEGIN Init */

#ifdef FUNC_BOOT_TICK
    Charger.m_BootTick = HAL_GetTick();
#endif

#ifdef FUNC_STM32_FLASH_INFO
    STM32_Flash_Info_Proc();
#endif //FUNC_STM32_FLASH_INFO

#ifdef FUNC_STM32_FLASH_OPTION_BYTES
    STM32_Flash_OB_ProcDefault();
#endif

#ifdef FUNC_RS485_BLE_SW
    RS485_SW(HTK_TRUE);
    BLE_SW(HTK_FALSE); //Disable BLE (remove part from PCB)
#endif

#ifdef FUNC_SYSTEM_KEEP_INFO

    if (!SystemKeepInfo_Check(&g_SystemKeepInfo))
    {
        memset(&g_SystemKeepInfo, 0, sizeof(g_SystemKeepInfo));
    }
    g_SystemKeepInfo.m_BootCount++;
    SystemKeepInfo_Update(&g_SystemKeepInfo);
    SystemKeepInfo_Display(&g_SystemKeepInfo);
#endif

  UpdateFirmwareVersion();

  sprintf(Charger.Ver_HW, "1.0");

  HAL_GPIO_WritePin(OUT_Leak_Test_GPIO_Port, OUT_Leak_Test_Pin, GPIO_PIN_SET);

  /* USER CODE END Init */

  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */

  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
  /* USER CODE END RTOS_SEMAPHORES */

  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */
  /* USER CODE END RTOS_TIMERS */

  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  /* USER CODE END RTOS_QUEUES */

  /* Create the thread(s) */
  /* definition and creation of ethTask */

#ifndef DISABLE_OS_ETH_TASK
  //osThreadDef(ethTask, StartEthTask, osPriorityIdle, 0, 1024);
  osThreadDef(ethTask, StartEthTask, osPriorityIdle, 0, 128); //Empty(USB)
  ethTaskHandle = osThreadCreate(osThread(ethTask), NULL);
#endif

  /* definition and creation of uartTask */
  osThreadDef(uartTask, StartUartTask, osPriorityNormal, 0, 1024);
  uartTaskHandle = osThreadCreate(osThread(uartTask), NULL);

  /* definition and creation of adcTask */
#ifdef MODIFY_OS_ADC_TASK_DEFINE_DATA
  osThreadDef(adcTask, StartAdcTask, osPriorityRealtime, 0, 512);
#else
  osThreadDef(adcTask, StartAdcTask, osPriorityRealtime, 0, 256);
#endif
  adcTaskHandle = osThreadCreate(osThread(adcTask), NULL);

  /* definition and creation of timeoutTask */
  osThreadDef(timeoutTask, StartTimeoutTask, osPriorityNormal, 0, 128);
  timeoutTaskHandle = osThreadCreate(osThread(timeoutTask), NULL);

#ifdef FUNC_ENABLE_USART1_RFID
  /* definition and creation of rfidTask */
  osThreadDef(rfidTask, StartRfidTask, osPriorityIdle, 0, 256);
  rfidTaskHandle = osThreadCreate(osThread(rfidTask), NULL);
#endif

  /* definition and creation of led_speakerTask */
  osThreadDef(led_speakerTask, StartLedSpeakerTask, osPriorityNormal, 0, 128);
  led_speakerTaskHandle = osThreadCreate(osThread(led_speakerTask), NULL);

  /* definition and creation of cpTask */
  osThreadDef(cpTask, StartCpTask, osPriorityHigh, 0, 256);
  cpTaskHandle = osThreadCreate(osThread(cpTask), NULL);

  /* definition and creation of alarmTask */
  osThreadDef(alarmTask, StartAlarmTask, osPriorityHigh, 0, 256);
  alarmTaskHandle = osThreadCreate(osThread(alarmTask), NULL);

  /* definition and creation of bleTask */
#ifdef LOCAL_LINK_BLE
  osThreadDef(bleTask, StartBleTask, osPriorityHigh, 0, 1024);
  bleTaskHandle = osThreadCreate(osThread(bleTask), NULL);
#endif
  /* definition and creation of memoryTask */
  osThreadDef(memoryTask, StartMemoryTask, osPriorityIdle, 0, 256);
  memoryTaskHandle = osThreadCreate(osThread(memoryTask), NULL);

  /* definition and creation of wifiTask */
#ifdef LOCAL_LINK_WIFI
  osThreadDef(wifiTask, StartWifiTask, osPriorityIdle, 0, 1024);
  wifiTaskHandle = osThreadCreate(osThread(wifiTask), NULL);
#endif

  /* definition and creation of MeterTask */
  osThreadDef(MeterTask, StartMeterTask, osPriorityIdle, 0, 1024);
  MeterTaskHandle = osThreadCreate(osThread(MeterTask), NULL);

  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */

#ifdef RECODE_FUNC_METER_IC_TASK

#ifdef MODIFY_METER_IC_TASK_PRIORITY
  //osThreadDef(MeterIcTask, StartMeterIcTask, osPriorityAboveNormal, 0, 1024);
  osThreadDef(MeterIcTask, StartMeterIcTask, osPriorityHigh, 0, 1024);
#else
  osThreadDef(MeterIcTask, StartMeterIcTask, osPriorityNormal, 0, 1024);
#endif

  MeterIcTaskHandle = osThreadCreate(osThread(MeterIcTask), NULL);
#endif

#ifdef FUNC_TASK_MONITOR
  osThreadDef(MonitorTask, StartMonitorTask, osPriorityIdle, 0, 256);
  MonitorTaskHandle = osThreadCreate(osThread(MonitorTask), NULL);
#endif

#ifdef FUNC_LIN_CP
  //osThreadDef(LinCpTask, StartLinCpTask, osPriorityIdle, 0, 256 * 4);
  osThreadDef(LinCpTask, StartLinCpTask, osPriorityIdle, 0, 256);

  LinCpTaskHandle = osThreadCreate(osThread(LinCpTask), NULL);
#endif

#ifdef FUNC_VERIFY_TASK
  osThreadDef(VerifyTask, StartVerifyTask, osPriorityIdle, 0, 256);
  VerifyTaskHandle = osThreadCreate(osThread(VerifyTask), NULL);
#endif

  /* USER CODE END RTOS_THREADS */

}

#ifndef DISABLE_OS_ETH_TASK
/* USER CODE BEGIN Header_StartEthTask */
/**
* @brief Function implementing the ethTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartEthTask */
void StartEthTask(void const * argument)
{
  /* init code for USB_DEVICE */
  MX_USB_DEVICE_Init();
  /* USER CODE BEGIN StartEthTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    IdleUntilReadAllMemory();
#endif

    /* Infinite loop */
    for(;;)
    {
        osDelay(1);
    }
  /* USER CODE END StartEthTask */
}
#endif //DISABLE_OS_ETH_TASK

/* USER CODE BEGIN Header_StartUartTask */
/**
  * @brief  Function implementing the uartTask thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_StartUartTask */
void StartUartTask(void const * argument)
{
  /* USER CODE BEGIN StartUartTask */
  //uuart

#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    IdleUntilReadAllMemory();
#endif

#ifndef DISABLE_PRINT_RTOS_MSG
  uint8_t       pcWriteBuffer[1024];
#endif

#ifndef FUNC_USE_STM32_SBSFU
  uint8_t       endFlag[4]={0x55,0xaa,0x55,0xaa};
  uint32_t      checksum;
#endif

  __IO uint32_t flash;
  uint8_t       dbgIdx;


  #if defined(DEBUG) || defined(RTOS_STAT)
  DEBUG_INFO("========== AP initial OK ==========\n\r");
  DEBUG_INFO(" Version: %s\n\r", Charger.Ver_FW);
  DEBUG_INFO("===================================\n\r");
  if (__HAL_RCC_GET_FLAG(RCC_FLAG_PINRST)  != RESET) DEBUG_INFO("Reset flag: Pin reset \r\n");
  if (__HAL_RCC_GET_FLAG(RCC_FLAG_PORRST)  != RESET) DEBUG_INFO("Reset flag: POR reset \r\n");
  if (__HAL_RCC_GET_FLAG(RCC_FLAG_SFTRST)  != RESET) DEBUG_INFO("Reset flag: SW reset \r\n");
  if (__HAL_RCC_GET_FLAG(RCC_FLAG_IWDGRST) != RESET) DEBUG_INFO("Reset flag: IWDG reset \r\n");
  if (__HAL_RCC_GET_FLAG(RCC_FLAG_WWDGRST) != RESET) DEBUG_INFO("Reset flag: WWDG reset \r\n");
  if (__HAL_RCC_GET_FLAG(RCC_FLAG_LPWRRST) != RESET) DEBUG_INFO("Reset flag: LP reset \r\n");
  DEBUG_INFO("\r\n");
  __HAL_RCC_CLEAR_RESET_FLAGS();
  #endif
  Charger.CSUisReady = OFF ;

#ifdef FUNC_RS485_SLAVE
  HAL_GPIO_WritePin(OUT_Meter_485_DE_GPIO_Port, OUT_Meter_485_DE_Pin, GPIO_PIN_RESET);
  HAL_GPIO_WritePin(OUT_Meter_485_RE_GPIO_Port, OUT_Meter_485_RE_Pin, GPIO_PIN_RESET);
#endif

#ifdef FUNC_IDLE_UNTIL_INIT_METER_IC
    IdleUntilInitMeterIC();
#endif

#ifdef FUNC_CSU_PUBLIC_KEY_OPERATION
    if (Charger.m_bCsuSignInMustVerify)
    {
#ifdef FUNC_SECURITY_DEBUG_INFO
        HTK_ByteArray2HexStr_XP("CSU_PublicKey", Charger.memory.EVSE_Config.data.item.m_CsuPublicKey, 0, CSU_PUBLIC_KEY_LEN);
#endif
    }
#endif

#ifdef FUNC_RELAY_OFF_WHEN_GET_TWICE_OFF_CMD
    u8 CsuSetRelayOffCount = 0;
#endif

//#ifdef FUNC_REQUEST_OFF_WHEN_GET_TWICE_OFF_CMD
//    u8 CsuSetRequestOffCount = 0;
//#endif

  /* Infinite loop */
  for(;;)
  {

    timerEnable(TIMER_IDX_RTOS_STAT, 500);
    if(timer[TIMER_IDX_RTOS_STAT].isAlarm)
    {

      switch(dbgIdx)
      {
          case 0:
#ifdef RTOS_STAT
#ifndef DISABLE_PRINT_RTOS_MSG
              printf("=================================================\r\n");
              printf("Task_Name \tState \tPrior \tStack \tTask_Id\r\n");
              vTaskList((char *)&pcWriteBuffer);
              printf("%s\r\n", pcWriteBuffer);
              printf("-------------------------------------------------\r\n");
              printf("Task_Name \tRun_Time(10us) \tUsage_Percent\r\n");
              vTaskGetRunTimeStats((char *)&pcWriteBuffer);
              printf("%s\r\n", pcWriteBuffer);
#endif //DISABLE_PRINT_RTOS_MSG
#endif

#ifdef FUNC_PTB_METER_WM3M4C
            if (Charger.m_bUseExtMeter_WM3M4C && Charger.m_pWM3M4C)
            {
                 const PWM3M4C p = Charger.m_pWM3M4C;
#ifdef DEBUG_PTB_METER_WM3M4C
                XP("========================< WM3M4C Information >=====================\r\n");
                XP("[30001 ModelName        ] %s\r\n", p->m_ModelName.m_Str);
                XP("[30009 SerialNumber     ] %s\r\n", p->m_SerialNumber.m_Str);
                XP("[30013 SW_Version       ] %.2f\r\n", (float)p->m_SW_Ver.m_Val * 0.01);
                XP("[30014 HW_Version       ] %s\r\n", p->m_HW_Ver.m_Str);
                XP("===================================================================\r\n");
                XP("[30400 CheckSumStatus   ] 0x%04X\r\n", p->m_CheckSumStatus.m_Val);
                XP("===================================================================\r\n");
                XP("[30414 EngCountExp1     ] %d\r\n", p->m_EngCountExp1.m_Val);
                XP("[30415 EngCountExp2     ] %d\r\n", p->m_EngCountExp2.m_Val);
                XP("[30418 EngCount1 (Wh)   ] %d\r\n", p->m_EngCount1.m_Val);
                XP("[30420 EngCount2 (Wh)   ] %d\r\n", p->m_EngCount2.m_Val);
                XP("[30434 EngCount1x1000   ] %d\r\n", p->m_EngCount1x1000.m_Val);
                XP("[30436 EngCount2x1000   ] %d\r\n", p->m_EngCount2x1000.m_Val);
                XP("[----- Eng1 (0.0001Wh)  ] %llu\r\n", p->m_AccuEnergy1);
                XP("===================================================================\r\n");
                XP("[47000 MeasurementStatus] %d\r\n", p->m_MeasurementStatus.m_Val);
                XP("[47001 Duration         ] %d\r\n", p->m_Duration.m_Val);
                XP("[47003 Consumption      ] %d\r\n", p->m_Consumption.m_Val);
                XP("[47005 ActivePowerTotal ] %lf\r\n", p->m_ActivePowerTotal.m_Val);
                XP("[47007 DateTime         ] %d (%s)\r\n", p->m_GetDateTime.m_Val, p->m_GetDateTime.m_Str);
                XP("[47013 SignaturesCount  ] %d\r\n", p->m_SignaturesCount.m_Val);
                XP("===================================================================\r\n");
                XP("[47052 SignatureStatus  ] %d\r\n", p->m_SignatureStatus.m_Val);
                XP("[47053 TimeZoneOffset   ] %d\r\n", p->m_TimeZoneOffset.m_Val);
                XP("[47054 SetDataTime      ] %d (%s)\r\n", p->m_SetDataTime.m_Val, p->m_SetDataTime.m_Str);
                XP("[47056 InpMsgLen        ] %d\r\n", p->m_InpMsgLen.m_Val);
                XP("[47057 OutpMsgLen       ] %d\r\n", p->m_OutpMsgLen.m_Val);
                XP("[47058 OutpSigLen       ] %d (x2 = %d)\r\n", p->m_OutpSigLen.m_Val, p->m_OutpSigLen.m_Val * 2);
                XP("[----- ExpOutpMsgSigLen ] %d\r\n", p->m_ExpectOutpMsgSigLen);
                XP("[47059 OutpSigFmt       ] %d\r\n", p->m_OutpSigFmt.m_Val);
                XP("[47060 OutpSigAlg       ] %d\r\n", p->m_OutpSigAlg.m_Val);
                XP("[47061 Backlit          ] %d\r\n", p->m_Backlit.m_Val);
                XP("===================================================================\r\n");
                XP("[47100 DataSetInput     ] %s (%d:%d)\r\n", p->m_InputJsonMsg.m_All, p->m_InpMsgLen.m_Val, strlen(p->m_InputJsonMsg.m_All));
                XP("===================================================================\r\n");
                XP("[47612 OutpMsg          ] %s (%d:%d)\r\n", (char*)p->m_OutpMsg.m_Buf, p->m_OutpMsgLen.m_Val, strlen((char*)p->m_OutpMsg.m_Buf));
                XP("===================================================================\r\n");
                XP("[FIXED PublicKeyHeader  ] %s (%d)\r\n", p->m_PublicKeyHStr, WM3M3C_PUBLIC_KEY_H_LEN * 2);
                XP("[48124 PublicKey        ] %s (%d)\r\n", p->m_PublicKey.m_Str, p->m_PublicKeyStrLen);
                XP("===================================================================\r\n");
                XP("[48188 OutpSig          ] %s (%d)\r\n", p->m_OutpSig.m_Str, p->m_OutpSigLen.m_Val);
                XP("===================================================================\r\n");
                XP("[----- OutpMsgSig       ] %s (%d)\r\n", p->m_OutpMsgSig, p->m_OutpMsgSigLen);
                XP("[----- Header+PKey      ] %s (%d)\r\n", p->m_HPKey, p->m_HPKeyLen);
                XP("===================================================================\r\n");
#else //DEBUG_PTB_METER_WM3M4C
                XP("[OutpMsgSig] %s (%d)\r\n", p->m_OutpMsgSig, p->m_OutpMsgSigLen);
                XP("[Header+PKey] %s (%d)\r\n\r\n", p->m_HPKey, p->m_HPKeyLen);
#endif //DEBUG_PTB_METER_WM3M4C

            }
#endif //FUNC_PTB_METER_WM3M4C

#ifdef FUNC_EKM_OMNIMETER_DISPLAY
            if (Charger.m_bUseExtMeter_OMNIMETER && Charger.m_pEKM_Omnimeter)
            {
                EKM_Omnimeter_Display(Charger.m_pEKM_Omnimeter);
            }
#endif

#ifdef FUNC_LINCP_DISPLAY
            if (Charger.m_bUseLinCP && Charger.m_pLinCP)
            {
                LIN_Display(Charger.m_pLinCP);
            }
#endif

//#ifdef FUNC_SALT_AND_BLEND
//            if (0)
//            {
//                enum
//                {
//                    KeyLen = 64,
//                    SaltLen = 64,
//                    MixtureLen = KeyLen + SaltLen,
//                    SaltMapLen = GET_BOX_NUM(MixtureLen, 8),
//                    AllLen = MixtureLen + SaltMapLen,
//                };
//
//                u8* Key = (u8*)HTK_Malloc(KeyLen);
//                if (Key != NULL)
//                {
//                    for (int i = 0; i < KeyLen; i++) { Key[i] = i + 1; }
//                    u8* Mixture = (u8*)HTK_Malloc(AllLen);
//                    if (Mixture != NULL)
//                    {
//                        DataEncryption(Key, KeyLen, Mixture, AllLen, 0);
//                        DataEncryption(Key, KeyLen, Mixture, AllLen, 1);
//                        HTK_Free(Mixture);
//                    }
//                    HTK_Free(Key);
//                }
//            }
//#endif //FUNC_SALT_AND_BLEND

            dbgIdx++;
            break;
          case 1:

#ifdef FUNC_USE_STM32_SBSFU
              DEBUG_INFO("Firmware version: %s [S]\r\n", Charger.Ver_FW);
#else
              DEBUG_INFO("Firmware version: %s\r\n", Charger.Ver_FW);
#endif

#ifdef FUNC_BUILD_DATE_TIME
              DEBUG_INFO("Build: %s %s\r\n", __DATE__, __TIME__); //ex Build: Mar 10 2022 14:53:25
#endif

#ifdef FUNC_CSU_SIGN_IN_VERIFY
              DEBUG_INFO("MCU_Control_Mode: %x (%s%s)\r\n",Charger.memory.EVSE_Config.data.item.MCU_Control_Mode,
                         Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_CSU ? "CSU" : "No CSU",
                         Charger.m_bCsuSignInMustVerify ? (Charger.m_bCsuSignInVerifyOK ? ": VerifyOK" : ": NotVerify") : "");
#else
              DEBUG_INFO("MCU_Control_Mode: %x (%s)\r\n",Charger.memory.EVSE_Config.data.item.MCU_Control_Mode,
                         Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_CSU ? "CSU" : "No CSU");
#endif
              DEBUG_INFO("ModelName: %s\r\n",Charger.memory.EVSE_Config.data.item.ModelName);
              DEBUG_INFO("SerialNumber: %s\r\n",Charger.memory.EVSE_Config.data.item.SerialNumber);
#ifdef FUNC_BOOT_TICK
              DEBUG_INFO("UpTime(s): %d\r\n", (HAL_GetTick() - Charger.m_BootTick) / 1000);
#endif
            dbgIdx++;
            break;
          case 2:
              if (Charger.CCID_Module_Type == CCID_MODULE_CORMEX)
              {
                DEBUG_INFO("Charger.CCID_Module_Type is CCID_MODULE_CORMEX\n\r");
              }
              else if (Charger.CCID_Module_Type == CCID_MODULE_VAC)
              {
                DEBUG_INFO("Charger.CCID_Module_Type is CCID_MODULE_VAC\n\r");
              }
              DEBUG_INFO("System mode: %d\r\n", Charger.Mode);
              DEBUG_INFO("Alarm code: 0x%08X\r\n", Charger.Alarm_Code);

#ifdef FUNC_WARNING_CODE
            DEBUG_INFO("Warning code: 0x%08X\r\n", Charger.Warning_Code);
#endif

#ifdef FUNC_SHOW_RELAY_INFO
            DEBUG_INFO("Relay action: Main(%d), TypeE(%d)\r\n", Charger.Relay_Action, Charger.SE_Relay_Action);
#endif

#ifdef FUNC_MODE_DEBUG_REC_RELAY_ON_TIMES
            if (Charger.isDebugEnable)
            {
                DEBUG_INFO("[Debug Mode] RelayOnTimes: %d\r\n", Charger.memory.EVSE_Config.data.item.m_ModeDebugRelayOnTimes);
            }
#endif
            dbgIdx++;
            break;
          case 3:
#ifndef FUNC_REPLACE_ADC_WITH_METER_IC
              DEBUG_INFO("Original L1 Voltage: %fV\r\n", adc_value.ADC3_IN9_Voltage_L1.value/100.0);
              DEBUG_INFO("Original L2 Voltage: %fV\r\n", adc_value.ADC3_IN8_Voltage_L2.value/100.0);
              DEBUG_INFO("Original L3 Voltage: %fV\r\n", adc_value.ADC3_IN10_Voltage_L3.value/100.0);
#endif
            dbgIdx++;
            break;
          case 4:
#ifndef FUNC_REPLACE_ADC_WITH_METER_IC
              DEBUG_INFO("Original L1 Current: %fA\r\n", adc_value.ADC3_IN7_Current_L1.value/100.0);
              DEBUG_INFO("Original L2 Current: %fA\r\n", adc_value.ADC3_IN5_Current_L2.value/100.0);
              DEBUG_INFO("Original L3 Current: %fA\r\n", adc_value.ADC3_IN11_Current_L3.value/100.0);
#endif
            dbgIdx++;
            break;
          case 5:
#ifdef FUNC_INFO_METER_IC_RAW_DATA
              DEBUG_INFO("Correction L1 Voltage[0]: %fV (%d)\r\n", Charger.Voltage[0]/100.0, Charger.m_MeterIC_MeasVals.m_AVRMS_LRIP);
              DEBUG_INFO("Correction L2 Voltage[1]: %fV (%d)\r\n", Charger.Voltage[1]/100.0, Charger.m_MeterIC_MeasVals.m_BVRMS_LRIP);
              DEBUG_INFO("Correction L3 Voltage[2]: %fV (%d)\r\n", Charger.Voltage[2]/100.0, Charger.m_MeterIC_MeasVals.m_CVRMS_LRIP);
#else
              DEBUG_INFO("Correction L1 Voltage[0]: %fV\r\n", Charger.Voltage[0]/100.0);
              DEBUG_INFO("Correction L2 Voltage[1]: %fV\r\n", Charger.Voltage[1]/100.0);
              DEBUG_INFO("Correction L3 Voltage[2]: %fV\r\n", Charger.Voltage[2]/100.0);
#endif
            dbgIdx++;
            break;
          case 6:
#ifdef FUNC_INFO_METER_IC_RAW_DATA
              DEBUG_INFO("Correction L1 Current[0]: %fA (%d)\r\n", Charger.Current[0]/100.0, Charger.m_MeterIC_MeasVals.m_AIRMS_LRIP);
              DEBUG_INFO("Correction L2 Current[1]: %fA (%d)\r\n", Charger.Current[1]/100.0, Charger.m_MeterIC_MeasVals.m_BIRMS_LRIP);
              DEBUG_INFO("Correction L3 Current[2]: %fA (%d)\r\n", Charger.Current[2]/100.0, Charger.m_MeterIC_MeasVals.m_CIRMS_LRIP);
#else
              DEBUG_INFO("Correction L1 Current[0]: %fA\r\n", Charger.Current[0]/100.0);
              DEBUG_INFO("Correction L2 Current[1]: %fA\r\n", Charger.Current[1]/100.0);
              DEBUG_INFO("Correction L3 Current[2]: %fA\r\n", Charger.Current[2]/100.0);
#endif

#ifdef FUNC_METER_IC_READ_PHASE_ANGLE
            {
#ifndef DISABLE_PRINT_DEBUG_MSG
                const PMeterIC_ExtraInfo pEx = &Charger.m_MeterIcEx;
#endif
                DEBUG_INFO("MeterIC: MMODE(0x%02X) COMPMODE(0x%04X) STATUS01(0x%08X, 0x%08X) Period(%d:%s)\r\n",
                    pEx->m_MMODE,
                    pEx->m_COMPMODE,
                    pEx->m_STATUS0,
                    pEx->m_STATUS1,
                    Charger.m_MeterIC_MeasVals.m_Period,
                    AC_PERIOD_MODE_STR[pEx->m_AcPeriodMode]);

                DEBUG_INFO("MeterIC: ANGLE_REG3_DEG3(%4d, %4d, %4d, %10.6lf, %10.6lf, %10.6lf) SEQERR(%d) [%s]\r\n",
                    pEx->m_AngleReg[0],
                    pEx->m_AngleReg[1],
                    pEx->m_AngleReg[2],
                    pEx->m_AngleDegree[0],
                    pEx->m_AngleDegree[1],
                    pEx->m_AngleDegree[2],
                    pEx->m_bSEQERR,
                    AC_PHASE_MODE_STR[pEx->m_AcPhaseMode]);

            }
#endif //FUNC_METER_IC_READ_PHASE_ANGLE

            dbgIdx++;
            break;

          case 7:
              DEBUG_INFO("PE(ADC): %d\r\n", adc_value.ADC3_IN4_GMI_VL1.value );
              DEBUG_INFO("PE(V): %f\r\n", adc_value.ADC3_IN4_GMI_VL1.value*3.3/4095 );
              DEBUG_INFO("adc_value.ADC2_IN5_Welding.value : %d(unit:0.01v)\r\n", adc_value.ADC2_IN5_Welding.value  );

#ifdef DEBUG_RELAY_MONITOR_SHOW_INFO
                {
                    double threshold =
                        Charger.Voltage[0] * 0.01 *
                        Charger.alarm_spec.Relay_LL_Welding_Slop +
                        Charger.alarm_spec.Relay_LL_Welding_Offs;
                    XP("#Welding threshold : %lf\r\n", threshold);

                }
#endif //DEBUG_RELAY_MONITOR_SHOW_INFO

                DEBUG_INFO("SystemAmbientTemp: %d (unit:C)\r\n", Charger.temperature.SystemAmbientTemp);
#ifdef FUNC_TMP100
                if (Charger.m_bUseTMP100)
                {
                    DEBUG_INFO("TMP100: %.4f (unit:C) >>> CcsConnectorTemp: %d \r\n", Charger.m_TMP100_cTemp, Charger.temperature.CcsConnectorTemp);
                }
#endif


#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
                if (Charger.m_bModelNameAX80_1P)
                {
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                    if (Charger.m_bModelNameAX80_NACS_1P)
                    {
#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
                        DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX_G2[T12](%d), MAX_G3[T34](%d), MAX_G4[T56](%d)\r\n",
                            Charger.temperature.AX80_NACS_T1_L1_IN,
                            Charger.temperature.AX80_NACS_T2_L2_IN,
                            Charger.temperature.AX80_NACS_T3_L1_OUT,
                            Charger.temperature.AX80_NACS_T4_L2_OUT,
                            Charger.temperature.AX80_NACS_T5_L1_GUN,
                            Charger.temperature.AX80_NACS_T6_L2_GUN,
                            Charger.temperature.Group2_MaxTemp, Charger.temperature.Group3_MaxTemp, Charger.temperature.Group4_MaxTemp);
#else //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
                        DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX(%d)\r\n",
                            Charger.temperature.AX80_NACS_T1_L1_IN,
                            Charger.temperature.AX80_NACS_T2_L2_IN,
                            Charger.temperature.AX80_NACS_T3_L1_OUT,
                            Charger.temperature.AX80_NACS_T4_L2_OUT,
                            Charger.temperature.AX80_NACS_T5_L1_GUN,
                            Charger.temperature.AX80_NACS_T6_L2_GUN,
                            Charger.temperature.Group2_MaxTemp);
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK

#ifdef DEBUG_SHOW_AX80_NACS_TEMP_SENSOR_ADC_COUNT
                        DEBUG_INFO("[ADC_COUNT] T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d)\r\n",
                            adc_value.ADC3_IN9_AX80_NACS_T1.value,
                            adc_value.ADC3_IN8_AX80_NACS_T2.value,
                            adc_value.ADC3_IN10_AX80_NACS_T3.value,
                            adc_value.ADC3_IN7_AX80_NACS_T4.value,
                            adc_value.ADC3_IN5_AX80_NACS_T5.value,
                            adc_value.ADC3_IN11_AX80_NACS_T6.value);
#endif //DEBUG_SHOW_AX80_NACS_TEMP_SENSOR_ADC_COUNT
                    }
                    else
                    {
                        DEBUG_INFO("Relay1(%d), Relay2(%d), InL1(%d), InL2N(%d), Max(%d)\r\n",
                            Charger.temperature.AX80_Relay1Temp,
                            Charger.temperature.AX80_Relay2Temp,
                            Charger.temperature.AX80_Input_L1_Temp,
                            Charger.temperature.AX80_Input_N_L2_Temp,
                            Charger.temperature.Group2_MaxTemp);
                    }

#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                    DEBUG_INFO("Relay1(%d), Relay2(%d), InL1(%d), InL2N(%d), Max(%d)\r\n",
                        Charger.temperature.AX80_Relay1Temp,
                        Charger.temperature.AX80_Relay2Temp,
                        Charger.temperature.AX80_Input_L1_Temp,
                        Charger.temperature.AX80_Input_N_L2_Temp,
                        Charger.temperature.Group2_MaxTemp);
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                }
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
                else if (Charger.m_bModelNameAW48_1P)
                {
#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
                    DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX_G2[T12](%d), MAX_G3[T34](%d), MAX_G4[T56](%d)\r\n",
                        Charger.temperature.AW48_T1_L1_IN,
                        Charger.temperature.AW48_T2_L2_IN,
                        Charger.temperature.AW48_T3_L1_OUT,
                        Charger.temperature.AW48_T4_L2_OUT,
                        Charger.temperature.AW48_T5_L1_GUN,
                        Charger.temperature.AW48_T6_L2_GUN,
                        Charger.temperature.Group2_MaxTemp, Charger.temperature.Group3_MaxTemp, Charger.temperature.Group4_MaxTemp);
#else //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
                    DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX_G2[T1256](%d), MAX_G3[T34](%d)\r\n",
                        Charger.temperature.AW48_T1_L1_IN,
                        Charger.temperature.AW48_T2_L2_IN,
                        Charger.temperature.AW48_T3_L1_OUT,
                        Charger.temperature.AW48_T4_L2_OUT,
                        Charger.temperature.AW48_T5_L1_GUN,
                        Charger.temperature.AW48_T6_L2_GUN,
                        Charger.temperature.Group2_MaxTemp, Charger.temperature.Group3_MaxTemp);
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#else //MODIFY_AW48_OTP_SPEC_20240522_STEVEN
                    DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX(%d)\r\n",
                        Charger.temperature.AW48_T1_L1_IN,
                        Charger.temperature.AW48_T2_L2_IN,
                        Charger.temperature.AW48_T3_L1_OUT,
                        Charger.temperature.AW48_T4_L2_OUT,
                        Charger.temperature.AW48_T5_L1_GUN,
                        Charger.temperature.AW48_T6_L2_GUN,
                        Charger.temperature.Group2_MaxTemp);
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN

#ifdef DEBUG_SHOW_AW48_TEMP_SENSOR_ADC_COUNT
                    DEBUG_INFO("[ADC_COUNT] T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d)\r\n",
                        adc_value.ADC3_IN9_AW48_T1.value,
                        adc_value.ADC3_IN8_AW48_T2.value,
                        adc_value.ADC3_IN10_AW48_T3.value,
                        adc_value.ADC3_IN7_AW48_T4.value,
                        adc_value.ADC3_IN5_AW48_T5.value,
                        adc_value.ADC3_IN11_AW48_T6.value);
#endif //DEBUG_SHOW_AW48_TEMP_SENSOR_ADC_COUNT
                }
#endif //FUNC_AW48_ADD_6_TEMP_SENEOR

#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
                else if (Charger.m_bModelNameAX48_NACS_1P)
                {
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
                    DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX_G2[T12](%d), MAX_G3[T34](%d), MAX_G4[T56](%d)\r\n",
                        Charger.temperature.AX48_NACS_T1_L1_IN,
                        Charger.temperature.AX48_NACS_T2_L2_IN,
                        Charger.temperature.AX48_NACS_T3_L1_OUT,
                        Charger.temperature.AX48_NACS_T4_L2_OUT,
                        Charger.temperature.AX48_NACS_T5_L1_GUN,
                        Charger.temperature.AX48_NACS_T6_L2_GUN,
                        Charger.temperature.Group2_MaxTemp, Charger.temperature.Group3_MaxTemp, Charger.temperature.Group4_MaxTemp);
#else //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
                    DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX_G2[T1256](%d), MAX_G3[T34](%d)\r\n",
                        Charger.temperature.AX48_NACS_T1_L1_IN,
                        Charger.temperature.AX48_NACS_T2_L2_IN,
                        Charger.temperature.AX48_NACS_T3_L1_OUT,
                        Charger.temperature.AX48_NACS_T4_L2_OUT,
                        Charger.temperature.AX48_NACS_T5_L1_GUN,
                        Charger.temperature.AX48_NACS_T6_L2_GUN,
                        Charger.temperature.Group2_MaxTemp, Charger.temperature.Group3_MaxTemp);
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
#else //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
                    DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX(%d)\r\n",
                        Charger.temperature.AX48_NACS_T1_L1_IN,
                        Charger.temperature.AX48_NACS_T2_L2_IN,
                        Charger.temperature.AX48_NACS_T3_L1_OUT,
                        Charger.temperature.AX48_NACS_T4_L2_OUT,
                        Charger.temperature.AX48_NACS_T5_L1_GUN,
                        Charger.temperature.AX48_NACS_T6_L2_GUN,
                        Charger.temperature.Group2_MaxTemp);
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef DEBUG_SHOW_AX48_NACS_TEMP_SENSOR_ADC_COUNT
                    DEBUG_INFO("[ADC_COUNT] T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d)\r\n",
                        adc_value.ADC3_IN9_AX48_NACS_T1.value,
                        adc_value.ADC3_IN8_AX48_NACS_T2.value,
                        adc_value.ADC3_IN10_AX48_NACS_T3.value,
                        adc_value.ADC3_IN7_AX48_NACS_T4.value,
                        adc_value.ADC3_IN5_AX48_NACS_T5.value,
                        adc_value.ADC3_IN11_AX48_NACS_T6.value);
#endif //DEBUG_SHOW_AX48_NACS_TEMP_SENSOR_ADC_COUNT
                }
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR

#endif //FUNC_AX80_ADD_4_TEMP_SENEOR
            dbgIdx++;
            break;
          case 8:
              if (Charger.CCID_Module_Type == CCID_MODULE_CORMEX)
              {
                DEBUG_INFO("Original GF[0]: %fmA\r\n", adc_value.ADC2_IN6_GF.value/100.0);
                DEBUG_INFO("Charger.Leak_Current: %fmA\r\n", Charger.Leak_Current/100.0);
              }
              else
              {
                //DEBUG_INFO("Temperature ADC raw data : %d\r\n",  adc_value.ADC3_IN15_Temp.value);
                //DEBUG_INFO("Temperature : %d\r\n", Charger.temperature.SystemAmbientTemp);
                DEBUG_INFO("ADC3_Buffer[1] (ADC): %d(unit:ADC)\r\n", ADC3_Buffer[1]  );
                DEBUG_INFO("Charger.Led_Mode: %d\r\n", Charger.Led_Mode  );
              }
            dbgIdx++;
            break;
          case 9:
              DEBUG_INFO("CP+(ADC): %d(unit:ADC)\r\n",CpDetectionResult.PositiveValue  );
              DEBUG_INFO("CP-(ADC): %d(unit:ADC)\r\n",CpDetectionResult.NegativeValue  );
              //if(CpDetectionResult.PositiveValue>0)
              {
#ifdef FUNC_CP_ADC_MODIFY
                //DEBUG_INFO("CP +voltage: %f\r\n", CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.PositiveValue));
                DEBUG_INFO("CP +voltage: %f\r\n", (CpDetectionResult.PositiveValue == 0 ? 0 : HTK_GetPosFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.PositiveValue))));
#else
                //DEBUG_INFO("CP +voltage: %f\r\n", (float)((1.59131-((3.3*CpDetectionResult.PositiveValue)/4095))*(475/53.6)));
#endif
              }
//              else
//              {
//                  DEBUG_INFO("CP +voltage: 0\r\n");
//              }
              //if(CpDetectionResult.NegativeValue>0)
              {
#ifdef FUNC_CP_ADC_MODIFY
                //DEBUG_INFO("CP -voltage: %f\r\n", CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.NegativeValue));
                DEBUG_INFO("CP -voltage: %f\r\n", (CpDetectionResult.NegativeValue == 0 ? 0 : HTK_GetNegFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.NegativeValue))));
#else
                //DEBUG_INFO("CP -voltage: %f\r\n", (float)((1.59131-((3.3*CpDetectionResult.NegativeValue)/4095))*(475/53.6)));
#endif
              }
//              else
//              {
//                  DEBUG_INFO("CP -voltage: 0\r\n");
//              }

#ifdef FUNC_DISP_CURRENT_CP_PWM
            DEBUG_INFO("CP state: %d (%.1f%)\r\n", Charger.CP_State, Charger.m_CP_CurPWM / 10.0f);
#else
            DEBUG_INFO("CP state: %d\r\n", Charger.CP_State);
#endif

#ifdef FUNC_DETECT_PP
            if (Charger.m_bDetectPP)
            {
                DEBUG_INFO("#PP(ADC): %d\r\n", adc_value.ADC3_IN6_Gun_Detec.value);
                DEBUG_INFO("#PP(CURR): %d\r\n", Charger.m_PPInfo.m_CurCurr);
            }
#endif

#ifdef FUNC_DETECT_PP_NACS
            if (Charger.m_bDetectPP_NACS)
            {
                DEBUG_INFO("#PP_NACS(ADC): %d\r\n", adc_value.ADC3_IN6_Gun_Detec.value);
                //DEBUG_INFO("#PP(CURR): %d\r\n", Charger.m_PPInfo.m_CurCurr);
            }
#endif

#ifdef FUNC_OUTP_TYPE_E
            if (Charger.m_bEnableTypeE)
            {
                DEBUG_INFO("#TypeE: isOnSocketE(%d), IsTypeEPlugIn(%d)\r\n", Charger.isOnSocketE, IsTypeEPlugIn());
            }
#endif

#ifdef FUNC_GUN_LOCK
            if (Charger.m_bUseGunLock)
            {
#ifdef FUNC_GUN_LOCK_TRIG_MODE
                DEBUG_INFO("#GunLock Status: %s ,TrigMode(%d)\r\n", GL_IsLock() ? "Locked" : "Unlocked", (int)Charger.m_GunLockTrigMode);
#else
                DEBUG_INFO("#GunLock Status: %s\r\n", GL_IsLock() ? "Locked" : "Unlocked");
#endif
            }
#endif

#ifdef FUNC_USE_RELAY_B_CONTACT
            if (Charger.m_bUseRelayBContact)
            {
                DEBUG_INFO("#Relay b Contact Status: %s\r\n", IsRelayContact_Closed() ? "Closed" : "Opened");
            }
#endif
            dbgIdx++;
            break;
          case 10:
              DEBUG_INFO("Power_Consumption_Cumulative: %llu (0.0001 kWh)\r\n", Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total);

              DEBUG_INFO("#Current rating value: %d A\r\n", Charger.maxRatingCurrent);
              if (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=20)
              {
                 DEBUG_INFO("OCP tigger : %d\r\n", (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification)-100 );
              }
              else
              {
                DEBUG_INFO("OCP tigger : %d\r\n", (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+1)*100 );
              }
              DEBUG_INFO("#Charger.am3352.isRequestOn: %d\r\n", Charger.am3352.isRequestOn);

#ifdef FUNC_OCP_WITH_PP
#ifdef MODIFY_OCP_PROC_WITH_MODELNAME_IDX_3_EURO_SPEC
            DEBUG_INFO("#OCPInfo(%d, %d, %d, %d) [%s]\r\n",
                Charger.m_OCP_CurMaxCurr, Charger.OCP_Magnification,
                Charger.m_OCP_BegThreshold, Charger.m_OCP_EndThreshold,
                Charger.m_bModelNameWithEuroSpecOCP ? "EuroSpec" : "NotEuroSpec");
#else
            DEBUG_INFO("#OCPInfo(%d, %d, %d, %d)\r\n",
                Charger.m_OCP_CurMaxCurr, Charger.OCP_Magnification,
                Charger.m_OCP_BegThreshold, Charger.m_OCP_EndThreshold);
#endif //MODIFY_OCP_PROC_WITH_MODELNAME_IDX_3_EURO_SPEC
#endif //FUNC_OCP_WITH_PP

#ifdef FUNC_GET_TRIP_TIME
                if (Charger.m_TripBeg != 0 && Charger.m_TripBeg < Charger.m_TripEnd)
                {
                    DEBUG_INFO("Trip period: %d\r\n", Charger.m_TripEnd - Charger.m_TripBeg);
                }
#endif

#ifdef RECODE_METER_PRO380
                if (Charger.m_bUseExtMeter_PRO380 && Charger.m_pPRO380)
                {
#ifndef DISABLE_PRINT_DEBUG_MSG
                    const PPRO380 p = Charger.m_pPRO380;
#endif
                    DEBUG_INFO("PRO380(%s, %d, %d) E(%.2f %.2f, %.2f %.2f %.2f)\r\n",
                        p->m_bCommTimeout ? "[NG]" : "OK",
                        p->m_UpdateOkTimes,
                        p->m_UpdateNgTimes,
                        p->m_T1_Total_active_energy.m_Val,
                        p->m_T2_Total_active_energy.m_Val,
                        p->m_L1_Total_active_energy.m_Val,
                        p->m_L2_Total_active_energy.m_Val,
                        p->m_L3_Total_active_energy.m_Val);
                }
#endif

#ifdef FUNC_PTB_METER_WM3M4C
                if (Charger.m_bUseExtMeter_WM3M4C && Charger.m_pWM3M4C)
                {
#ifndef DISABLE_PRINT_DEBUG_MSG
                    const PWM3M4C p = Charger.m_pWM3M4C;
#endif
                    DEBUG_INFO("WM3M4C(%s, %d, %d) I(%s V%.2f%s) E(%d, %d, %d) M(%d) S(%d) T(%s)\r\n",
                        p->m_bCommTimeout ? "[NG]" : "OK",
                        p->m_UpdateOkTimes,
                        p->m_UpdateNgTimes,
                        p->m_SerialNumber.m_Str,
                        (float)p->m_SW_Ver.m_Val * 0.01,
                        p->m_HW_Ver.m_Str,
                        p->m_EngCountExp1.m_Val,
                        p->m_EngCount1.m_Val,
                        p->m_EngCount1x1000.m_Val,
                        p->m_MeasurementStatus.m_Val,
                        p->m_SignatureStatus.m_Val,
                        p->m_GetDateTime.m_Str);
                }
#endif

#ifdef FUNC_TASK_MONITOR
                {
#ifndef DISABLE_PRINT_DEBUG_MSG
                    const PTaskADCInfo p = &Charger.m_TaskMonitor.m_ADC;
#endif
                    DEBUG_INFO("#TaskMonitor: ADC[%d/%d](%d, %d, %d) ADC->SR(0x%04X, 0x%04X, 0x%04X)\r\n",
                        p->m_ContinueResetCounter, p->m_TotalResetCounter,
                        p->m_ADC1_Counter[0],
                        p->m_ADC2_Counter[0],
                        p->m_ADC3_Counter[0], ADC1->SR, ADC2->SR, ADC3->SR);
                }
#endif //FUNC_TASK_MONITOR

#ifdef MODIFY_GOT_CSU_DUTY_CMD_PROCESS
            DEBUG_INFO("CCSInfo(%d, %d, %d)\r\n", Charger.m_bRunCCS, Charger.m_bGotCsuCpDutyCmd, Charger.m_bPassGotCsuCpDutyCmd);
#endif

#ifdef FUNC_SYSTEM_KEEP_INFO
              SystemKeepInfo_Display(&g_SystemKeepInfo);
#endif
            dbgIdx++;
            break;
          case 11:
              if (Charger.Alarm_Code & ALARM_L1_OVER_VOLTAGE)
                  DEBUG_INFO("#ALARM_L1_OVER_VOLTAGE \n\r");
              if (Charger.Alarm_Code & ALARM_L1_UNDER_VOLTAGE)
                  DEBUG_INFO("#ALARM_L1_UNDER_VOLTAGE \n\r");
              if (Charger.Alarm_Code & ALARM_L1_OVER_CURRENT)
                  DEBUG_INFO("#ALARM_L1_OVER_CURRENT \n\r");
              if (Charger.Alarm_Code & ALARM_L2_OVER_VOLTAGE)
                  DEBUG_INFO("#ALARM_L2_OVER_VOLTAGE \n\r");
              if (Charger.Alarm_Code & ALARM_L2_UNDER_VOLTAGE)
                  DEBUG_INFO("#ALARM_L2_UNDER_VOLTAGE \n\r");
              if (Charger.Alarm_Code & ALARM_L2_OVER_CURRENT)
                  DEBUG_INFO("#ALARM_L2_OVER_CURRENT \n\r");
              if (Charger.Alarm_Code & ALARM_L3_OVER_VOLTAGE)
                  DEBUG_INFO("#ALARM_L3_OVER_VOLTAGE \n\r");
              if (Charger.Alarm_Code & ALARM_L3_UNDER_VOLTAGE)
                  DEBUG_INFO("#ALARM_L3_UNDER_VOLTAGE \n\r");
              if (Charger.Alarm_Code & ALARM_L3_OVER_CURRENT)
                  DEBUG_INFO("#ALARM_L3_OVER_CURRENT \n\r");
            dbgIdx++;
            break;
          case 12:
              if (Charger.Alarm_Code & ALARM_OVER_TEMPERATURE)
                  DEBUG_INFO("#ALARM_OVER_TEMPERATURE \n\r");
              if (Charger.Alarm_Code & ALARM_GROUND_FAIL)
                  DEBUG_INFO("#ALARM_GROUND_FAIL \n\r");
              if (Charger.Alarm_Code & ALARM_CP_ERROR)
                  DEBUG_INFO("#ALARM_CP_ERROR \n\r");
              if (Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC)
                  DEBUG_INFO("#ALARM_CURRENT_LEAK_AC \n\r");
              if (Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC)
                  DEBUG_INFO("#ALARM_CURRENT_LEAK_DC \n\r");
              if (Charger.Alarm_Code & ALARM_MCU_TESTFAIL)
                  DEBUG_INFO("#ALARM_MCU_TESTFAIL \n\r");
              if (Charger.Alarm_Code & ALARM_HANDSHAKE_TIMEOUT)
                  DEBUG_INFO("#ALARM_HANDSHAKE_TIMEOUT \n\r");
              if (Charger.Alarm_Code & ALARM_EMERGENCY_STOP)
                  DEBUG_INFO("#ALARM_EMERGENCY_STOP \n\r");
            dbgIdx++;
            break;
          case 13:
              if (Charger.Alarm_Code & ALARM_RELAY_STATUS)
                  DEBUG_INFO("#ALARM_RELAY_STATUS \n\r");
              if (Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL)
                  DEBUG_INFO("#ALARM_LEAK_MODULE_FAIL \n\r");
              if (Charger.Alarm_Code & ALARM_SHUTTER_FAULT)
                  DEBUG_INFO("#ALARM_SHUTTER_FAULT \n\r");
              if (Charger.Alarm_Code & ALARM_LOCKER_FAULT)
                  DEBUG_INFO("#ALARM_LOCKER_FAULT \n\r");
              if (Charger.Alarm_Code & ALARM_POWER_DROP)
                  DEBUG_INFO("#ALARM_POWER_DROP \n\r");
              if (Charger.Alarm_Code & ALARM_L1_CIRCUIT_SHORT)
                  DEBUG_INFO("#ALARM_L1_CIRCUIT_SHORT \n\r");
              if (Charger.Alarm_Code & ALARM_L2_CIRCUIT_SHORT)
                  DEBUG_INFO("#ALARM_L2_CIRCUIT_SHORT \n\r");
              if (Charger.Alarm_Code & ALARM_L3_CIRCUIT_SHORT)
                  DEBUG_INFO("#ALARM_L3_CIRCUIT_SHORT \n\r");
              if (Charger.Alarm_Code & ALARM_ROTATORY_SWITCH_FAULT)
                  DEBUG_INFO("#ALARM_ROTATORY_SWITCH_FAULT \n\r");
              if (Charger.Alarm_Code & ALARM_RELAY_DRIVE_FUALT)
                  DEBUG_INFO("#ALARM_RELAY_DRIVE_FUALT \n\r");
              if (Charger.Alarm_Code & ALARM_METER_TIMEOUT)
                  DEBUG_INFO("#ALARM_METER_TIMEOUT \n\r");
#ifdef FUNC_METER_IC_COMM_ALARM
              if (Charger.Alarm_Code & ALARM_METER_IC_TIMEOUT)
                  DEBUG_INFO("#ALARM_METER_IC_TIMEOUT \n\r");
#endif

#ifdef FUNC_ALARM_CP_NEG_ERROR
              if (Charger.Alarm_Code & ALARM_CP_NEG_ERROR)
                  DEBUG_INFO("#ALARM_CP_NEG_ERROR \n\r");
#endif

#ifdef FUNC_AX80_ADD_TILT_SENSOR
              if (Charger.Alarm_Code & ALARM_TILT_SENSOR)
                  DEBUG_INFO("#ALARM_TILT_SENSOR \n\r");
#endif

#ifdef FUNC_WARNING_CODE
            //------------------------------------------------------------

#ifdef FUNC_EKM_OMNIMETER
            if (Charger.Warning_Code & WARN_OMNIMETER_COMM_TIMEOUT)
                DEBUG_INFO("#WARN_OMNIMETER_COMM_TIMEOUT \n\r");

#endif
            //------------------------------------------------------------
#endif //FUNC_WARNING_CODE

//            XP("sizeof(Charger.memory.EVSE_Config.data.value) = %d\r\n", sizeof(Charger.memory.EVSE_Config.data.value));
//            XP("sizeof(Charger.memory.EVSE_Config.data.item) = %d\r\n", sizeof(Charger.memory.EVSE_Config.data.item));
#ifdef FUNC_METER_IC_HISTORY_DEBUG
            XP("sizeof(Charger.memory.hisMeterIC) = %d\r\n", sizeof(Charger.memory.hisMeterIC));
            XP("sizeof(Charger.memory.hisMeterIC.data) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data));
            XP("sizeof(Charger.memory.hisMeterIC.data.value) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data.value));
            XP("sizeof(Charger.memory.hisMeterIC.data.item) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data.item));
            XP("sizeof(Charger.memory.hisMeterIC.data.item[0]) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data.item[0]));
            XP("sizeof(Charger.memory.hisMeterIC.data.item[0].DateTime) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data.item[0].DateTime));
            XP("sizeof(Charger.memory.hisMeterIC.data.item[0].m_CaliValType) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data.item[0].m_CaliValType));
            XP("sizeof(Charger.memory.hisMeterIC.data.item[0].m_CaliVal) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data.item[0].m_CaliVal));
            XP("sizeof(Charger.memory.hisMeterIC.data.item[0].m_Reserved) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data.item[0].m_Reserved));
            XP("sizeof(Charger.memory.hisMeterIC.op_bits) = %d\r\n", sizeof(Charger.memory.hisMeterIC.op_bits));
#endif //FUNC_METER_IC_HISTORY_DEBUG

            dbgIdx++;
            break;
          default:
              getlastRecord();
            dbgIdx = 0;
            break;
      }
      timerRefresh(TIMER_IDX_RTOS_STAT);
    }

    HAL_IWDG_Refresh(&hiwdg);

#ifdef FUNC_RS485_SLAVE
    if(UART_IAP_recv_end_flag == 1 || UART_RS485_recv_end_flag == 1)
#else
    if(UART_IAP_recv_end_flag == 1)
#endif
    {
#ifdef FUNC_UART_IAP_TX_BUF_INIT_ZERO
      uint8_t tx[UART_BUFFER_SIZE] = { 0 };
#else
      uint8_t tx[UART_BUFFER_SIZE];
#endif

#ifdef MODIFY_UART_TX_LEN_FROM_U8_TO_U16
      uint16_t tx_len;
#else
      uint8_t tx_len;
#endif

      uint8_t chksum = 0;
      uint8_t tmpBuf = 0 ;

      // Protocol process
#ifdef FUNC_RS485_SLAVE

        uint8_t *CurRxBuf = NULL;
        uint16_t *pCurRxBuf_RxLen = NULL;
        uint8_t *pCurRecvEndFlag = NULL;
        UART_HandleTypeDef *pUartHandle = NULL;

        if (UART_IAP_recv_end_flag == 1 && isValidCheckSum_IAP(UART_IAP_rx_buffer) == ON)
        {
            CurRxBuf = UART_IAP_rx_buffer;
            pCurRxBuf_RxLen = &UART_IAP_rx_len;
            pCurRecvEndFlag = &UART_IAP_recv_end_flag;
            pUartHandle = &IAP_USART;
#ifdef FUNC_RELAY_OFF_WHEN_CSU_CMD_TIMEOUT
            Charger.m_CSU_RxTick = HAL_GetTick();
#endif
        }
        else if (UART_RS485_recv_end_flag == 1 && isValidCheckSum_IAP(UART_RS485_rx_buffer) == ON)
        {
            CurRxBuf = UART_RS485_rx_buffer;
            pCurRxBuf_RxLen = &UART_RS485_rx_len;
            pCurRecvEndFlag = &UART_RS485_recv_end_flag;
            pUartHandle = &RS485_USART;
#ifdef FUNC_RELAY_OFF_WHEN_CSU_CMD_TIMEOUT //DC Model
            Charger.m_CSU_RxTick = HAL_GetTick();
#endif
        }
        if (CurRxBuf != NULL)
#else
      uint8_t *CurRxBuf = UART_IAP_rx_buffer;
      if(isValidCheckSum_IAP() == ON)
#endif
      {
        Charger.CSUisReady = ON ;

#ifdef ENABLE_PRINT_IMCP_MSG

#ifdef FUNC_RS485_SLAVE
#ifdef PRINT_IMCP_MSG_ONLY_ON_UPDATEPORT
        if (CurRxBuf == UART_IAP_rx_buffer && CheckPrintImcpMsg(CurRxBuf[IMCP_FM_MSGID_IDX]))
        {
            XP("-------------------------------------------\r\n");
            HTK_ByteArray2HexStr_XP(NULL, CurRxBuf, 0, IMCP_FM_HEAD_LEN + HTK_U16(CurRxBuf[IMCP_FM_DATALEN_LSB_IDX]) + IMCP_FM_TAIL_LEN);
        }
#else
        if (CheckPrintImcpMsg(CurRxBuf[IMCP_FM_MSGID_IDX]))
        {
            XP("-------------------------------------------\r\n");
            HTK_ByteArray2HexStr_XP(NULL, CurRxBuf, 0, IMCP_FM_HEAD_LEN + HTK_U16(CurRxBuf[IMCP_FM_DATALEN_LSB_IDX]) + IMCP_FM_TAIL_LEN);
        }
#endif //PRINT_IMCP_MSG_ONLY_ON_UPDATEPORT

#else //FUNC_RS485_SLAVE
        if (CheckPrintImcpMsg(UART_IAP_rx_buffer[IMCP_FM_MSGID_IDX]))
        {
            XP("-------------------------------------------\r\n");
            HTK_ByteArray2HexStr_XP(NULL, UART_IAP_rx_buffer, 0, IMCP_FM_HEAD_LEN + HTK_U16(UART_IAP_rx_buffer[IMCP_FM_DATALEN_LSB_IDX]) + IMCP_FM_TAIL_LEN);
        }
#endif //FUNC_RS485_SLAVE

#endif //ENABLE_PRINT_IMCP_MSG

#ifdef FUNC_RS485_SLAVE
        switch (CurRxBuf[3])
#else
        switch (UART_IAP_rx_buffer[3])
#endif
        {
          /*
            Query message
          */
          case PROTOCOL_MESSAGE_QUERY_FW_VER:
            tx_len = 7 + (strlen(Charger.Ver_FW));
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_FW_VER;
            tx[4] = strlen(Charger.Ver_FW)&0xff;
            tx[5] = (strlen(Charger.Ver_FW)>>0x08) & 0xff;
            for(uint8_t idx=0;idx<strlen(Charger.Ver_FW);idx++)
            {
                tx[6+idx] = Charger.Ver_FW[idx];
            }

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[6+(tx[4] | (tx[5]<<8))] = chksum;

            break;

          case PROTOCOL_MESSAGE_QUERY_HW_VER:
            tx_len = 7 + strlen(Charger.Ver_HW);
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_HW_VER;
            tx[4] = strlen(Charger.Ver_HW) & 0xff;
            tx[5] = (strlen(Charger.Ver_HW)>>0x08) & 0xff;
            for(uint8_t idx=0;idx<strlen(Charger.Ver_HW);idx++)
            {
                tx[6+idx] = Charger.Ver_HW[idx];
            }

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[6+(tx[4] | (tx[5]<<8))] = chksum;

            break;
          case PROTOCOL_MESSAGE_QUERY_PRESENT_INPUT_VOLTAGE:
            tx_len = 14;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_PRESENT_INPUT_VOLTAGE;
            tx[4] = 0x07;
            tx[5] = 0x00;
            tx[6] = 0x00;
            tx[7] = (((Charger.Voltage[0]/10)>>0) & 0xff);
            tx[8] = (((Charger.Voltage[0]/10)>>8) & 0xff);
            tx[9] = (((Charger.Voltage[1]/10)>>0) & 0xff);
            tx[10] = (((Charger.Voltage[1]/10)>>8) & 0xff);
            tx[11] = (((Charger.Voltage[2]/10)>>0) & 0xff);
            tx[12] = (((Charger.Voltage[2]/10)>>8) & 0xff);

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[13] = chksum;

            break;
          case PROTOCOL_MESSAGE_QUERY_PRESENT_OUTPUT_VOLTAGE:
            tx_len = 15;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_PRESENT_OUTPUT_VOLTAGE;
            tx[4] = 0x08;
            tx[5] = 0x00;
            tx[6] = 0x00;
            tx[7] = 0x00;
            tx[8] = 0x00;
            tx[9] = 0x00;
            tx[10] = 0x00;
            tx[11] = 0x00;
            tx[12] = 0x00;
            tx[13] = 0x00;

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[14] = chksum;

            break;
          case PROTOCOL_MESSAGE_QUERY_FAN_SPEED:
            tx_len = 15;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_FAN_SPEED;
            tx[4] = 0x08;
            tx[5] = 0x00;
            tx[6] = 0x00;
            tx[7] = 0x00;
            tx[8] = 0x00;
            tx[9] = 0x00;
            tx[10] = 0x00;
            tx[11] = 0x00;
            tx[12] = 0x00;
            tx[13] = 0x00;

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[14] = chksum;

            break;
          case PROTOCOL_MESSAGE_QUERY_TEMPERATURE:
            tx_len = 15;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_TEMPERATURE;
            tx[4] = 0x08;
            tx[5] = 0x00;
            tx[6] = (((Charger.temperature.SystemAmbientTemp+60)>>0) & 0xff);
            tx[7] = (((Charger.temperature.CcsConnectorTemp+60)>>0) & 0xff);

#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
            if (Charger.m_bModelNameAX80_1P)
            {
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                if (Charger.m_bModelNameAX80_NACS_1P)
                {
                    tx[8] = (((Charger.temperature.AX80_NACS_T1_L1_IN+60)>>0) & 0xff);
                    tx[9] = (((Charger.temperature.AX80_NACS_T2_L2_IN+60)>>0) & 0xff);
                    tx[10] = (((Charger.temperature.AX80_NACS_T3_L1_OUT+60)>>0) & 0xff);
                    tx[11] = (((Charger.temperature.AX80_NACS_T4_L2_OUT+60)>>0) & 0xff);
                    tx[12] = (((Charger.temperature.AX80_NACS_T5_L1_GUN+60)>>0) & 0xff);
                    tx[13] = (((Charger.temperature.AX80_NACS_T6_L2_GUN+60)>>0) & 0xff);
                }
                else
                {
                    tx[8] = (((Charger.temperature.AX80_Relay1Temp+60)>>0) & 0xff);
                    tx[9] = (((Charger.temperature.AX80_Relay2Temp+60)>>0) & 0xff);
                    tx[10] = (((Charger.temperature.AX80_Input_L1_Temp+60)>>0) & 0xff);
                    tx[11] = (((Charger.temperature.AX80_Input_N_L2_Temp+60)>>0) & 0xff);
                    tx[12] = 0x00;
                    tx[13] = 0x00;
                }
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                tx[8] = (((Charger.temperature.AX80_Relay1Temp+60)>>0) & 0xff);
                tx[9] = (((Charger.temperature.AX80_Relay2Temp+60)>>0) & 0xff);
                tx[10] = (((Charger.temperature.AX80_Input_L1_Temp+60)>>0) & 0xff);
                tx[11] = (((Charger.temperature.AX80_Input_N_L2_Temp+60)>>0) & 0xff);
                tx[12] = 0x00;
                tx[13] = 0x00;
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
            }
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
            else if (Charger.m_bModelNameAW48_1P)
            {
                tx[8] = (((Charger.temperature.AW48_T1_L1_IN+60)>>0) & 0xff);
                tx[9] = (((Charger.temperature.AW48_T2_L2_IN+60)>>0) & 0xff);
                tx[10] = (((Charger.temperature.AW48_T3_L1_OUT+60)>>0) & 0xff);
                tx[11] = (((Charger.temperature.AW48_T4_L2_OUT+60)>>0) & 0xff);
                tx[12] = (((Charger.temperature.AW48_T5_L1_GUN+60)>>0) & 0xff);
                tx[13] = (((Charger.temperature.AW48_T6_L2_GUN+60)>>0) & 0xff);
            }
#endif //FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
            else if (Charger.m_bModelNameAX48_NACS_1P)
            {
                tx[8] = (((Charger.temperature.AX48_NACS_T1_L1_IN+60)>>0) & 0xff);
                tx[9] = (((Charger.temperature.AX48_NACS_T2_L2_IN+60)>>0) & 0xff);
                tx[10] = (((Charger.temperature.AX48_NACS_T3_L1_OUT+60)>>0) & 0xff);
                tx[11] = (((Charger.temperature.AX48_NACS_T4_L2_OUT+60)>>0) & 0xff);
                tx[12] = (((Charger.temperature.AX48_NACS_T5_L1_GUN+60)>>0) & 0xff);
                tx[13] = (((Charger.temperature.AX48_NACS_T6_L2_GUN+60)>>0) & 0xff);
            }
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
            else
            {
                tx[8] = 0x00;
                tx[9] = 0x00;
                tx[10] = 0x00;
                tx[11] = 0x00;
                tx[12] = 0x00;
                tx[13] = 0x00;
            }
#else //FUNC_AX80_ADD_4_TEMP_SENEOR
            tx[8] = 0x00;
            tx[9] = 0x00;
            tx[10] = 0x00;
            tx[11] = 0x00;
            tx[12] = 0x00;
            tx[13] = 0x00;
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR


            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[14] = chksum;

            break;
          case PROTOCOL_MESSAGE_QUERY_AUX_POWER_VOLTAGE:
            tx_len = 15;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_AUX_POWER_VOLTAGE;
            tx[4] = 0x08;
            tx[5] = 0x00;
            tx[6] = 0x00;
            tx[7] = 0x00;
            tx[8] = 0x00;
            tx[9] = 0x00;
            tx[10] = 0x00;
            tx[11] = 0x00;
            tx[12] = 0x00;
            tx[13] = 0x00;

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[14] = chksum;

            break;
          case PROTOCOL_MESSAGE_QUERY_RELAY_OUTPUT_STATUS:
            tx_len = 9;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_RELAY_OUTPUT_STATUS;
            tx[4] = 0x02;
            tx[5] = 0x00;
            tx[6] = ((Relay1_Action_Get()==GPIO_RELAY1_ACTION_OFF)?0:1);
            tx[7] = ((Relay2_Action_Get()==GPIO_RELAY2_ACTION_OFF)?0:1);

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
                chksum ^= tx[6 + idx];
            }
            tx[8] = chksum;

            break;
          case PROTOCOL_MESSAGE_QUERY_GFD_ADC_VALUE:
            tx_len = 15;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_GFD_ADC_VALUE;
            tx[4] = 0x08;
            tx[5] = 0x00;
            tx[6] = ((adc_value.ADC2_IN6_GF.value>>0) & 0xff);
            tx[7] = ((adc_value.ADC2_IN6_GF.value>>8) & 0xff);
            tx[8] = 0x00;
            tx[9] = 0x00;
            tx[10] = 0x00;
            tx[11] = 0x00;
            tx[12] = 0x00;
            tx[13] = 0x00;

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[14] = chksum;

            break;
          case PROTOCOL_MESSAGE_QUERY_INPUT_GPIO_STATUS:
            tx_len = 9;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_INPUT_GPIO_STATUS;
            tx[4] = 0x02;
            tx[5] = 0x00;
            tx[6] = 0x00;
            tx[7] = 0x00 | ((HAL_GPIO_ReadPin(IN_BTN_ModeSw_GPIO_Port, IN_BTN_ModeSw_Pin)?0:1) << 7);

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[8] = chksum;

            break;
          case PROTOCOL_MESSAGE_QUERY_ALARM_LOG:
            tx_len = 17;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_ALARM_LOG;
            tx[4] = 0x0a;
            tx[5] = 0x00;
            tx[6] = CurRxBuf[7] ;
            tx[7] = CurRxBuf[8] ;

            tx[8] = CharacterArray[(Charger.memory.hisAlarm.data.item[CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0xF0000000)>>28];
            tx[9] = CharacterArray[(Charger.memory.hisAlarm.data.item[CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0x0F000000)>>24];
            tx[10] = CharacterArray[(Charger.memory.hisAlarm.data.item[CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0x00F00000)>>20];
            tx[11] = CharacterArray[(Charger.memory.hisAlarm.data.item[CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0x000F0000)>>16];
            tx[12] = CharacterArray[(Charger.memory.hisAlarm.data.item[CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0x0000F000)>>12];
            tx[13] = CharacterArray[(Charger.memory.hisAlarm.data.item[CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0x00000F00)>>8];
            tx[14] = CharacterArray[(Charger.memory.hisAlarm.data.item [CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0x000000F0)>>4];
            tx[15] = CharacterArray[ Charger.memory.hisAlarm.data.item [CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0x0000000F ];

#ifdef FUNC_TRACE_MEM_HIS_ALARM
            XP("ALARM_LOG[%d] = 0x%08X (%c%c%c%c%c%c%c%c)\r\n", CurRxBuf[7] | (CurRxBuf[8]>>8), Charger.memory.hisAlarm.data.item[CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode,
               tx[8], tx[9], tx[10], tx[11], tx[12], tx[13], tx[14], tx[15]);

            XP("sizeof(Charger.memory.hisAlarm.data.item[0]) = %d\r\n", sizeof(Charger.memory.hisAlarm.data.item[0]));
#endif

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }


            tx[16] = chksum;

            break;
          case PROTOCOL_MESSAGE_QUERY_SN:
            // head +checksum = 7 ,  SystemDateTimeyear month day = 8 , SerialNumber
            tx_len = 15 + strlen(Charger.memory.EVSE_Config.data.item.SerialNumber);
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_SN;
            tx[4] = (strlen(Charger.memory.EVSE_Config.data.item.SerialNumber)+8)&0xff;
            tx[5] = ((strlen(Charger.memory.EVSE_Config.data.item.SerialNumber)+8)>>0x08) & 0xff;

            tx[6] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.year/1000)+'0';
            tx[7] = ((Charger.memory.EVSE_Config.data.item.SystemDateTime.year%1000)/100)+'0';
            tx[8] = ((Charger.memory.EVSE_Config.data.item.SystemDateTime.year%100)/10)+'0';
            tx[9] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.year%10) +'0';
            tx[10] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.month/10) +'0';
            tx[11] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.month%10) +'0';
            tx[12] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.day/10) +'0';
            tx[13] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.day%10) +'0';

            for(uint8_t idx=0;idx<strlen(Charger.memory.EVSE_Config.data.item.SerialNumber);idx++)
            {
                tx[14+idx] = Charger.memory.EVSE_Config.data.item.SerialNumber[idx];
            }

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[6+(tx[4] | (tx[5]<<8))] = chksum;

            break;
          case PROTOCOL_MESSAGE_QUERY_MODEL_NAME:
            tx_len = 7 + strlen(Charger.memory.EVSE_Config.data.item.ModelName);;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_MODEL_NAME;
            tx[4] = strlen(Charger.memory.EVSE_Config.data.item.ModelName)&0xff;
            tx[5] = (strlen(Charger.memory.EVSE_Config.data.item.ModelName)>>0x08) & 0xff;
            for(uint8_t idx=0;idx<strlen(Charger.memory.EVSE_Config.data.item.ModelName);idx++)
            {
                tx[6+idx] = Charger.memory.EVSE_Config.data.item.ModelName[idx];
            }
            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[6+(tx[4] | (tx[5]<<8))] = chksum;
            break;
          case PROTOCOL_MESSAGE_QUERY_PARAMETER:
            tx_len = 11;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_PARAMETER;
            tx[4] = 0x04;
            tx[5] = 0x00;
            tx[6] = CurRxBuf[6];
            tx[7] = CurRxBuf[7];

            switch(CurRxBuf[6])
            {
                case INPUT_L1_AC_VOLTAGE:
                    tx[8] = Charger.memory.EVSE_Config.data.item.Correction_VL1[CurRxBuf[7]][1] & 0xff;
                    tx[9] = (Charger.memory.EVSE_Config.data.item.Correction_VL1[CurRxBuf[7]][1]>>8) & 0xff;
                  break;
                case INPUT_L2_AC_VOLTAGE:
                    tx[8] = Charger.memory.EVSE_Config.data.item.Correction_VL2[CurRxBuf[7]][1] & 0xff;
                    tx[9] = (Charger.memory.EVSE_Config.data.item.Correction_VL2[CurRxBuf[7]][1]>>8) & 0xff;
                  break;
                case INPUT_L3_AC_VOLTAGE:
                    tx[8] = Charger.memory.EVSE_Config.data.item.Correction_VL3[CurRxBuf[7]][1] & 0xff;
                    tx[9] = (Charger.memory.EVSE_Config.data.item.Correction_VL3[CurRxBuf[7]][1]>>8) & 0xff;
                  break;
                case OUTPUT_L1_CURRENT:
                    tx[8] = Charger.memory.EVSE_Config.data.item.Correction_CL1[CurRxBuf[7]][1] & 0xff;
                    tx[9] = (Charger.memory.EVSE_Config.data.item.Correction_CL1[CurRxBuf[7]][1]>>8) & 0xff;
                  break;
                case OUTPUT_L2_CURRENT:
                    tx[8] = Charger.memory.EVSE_Config.data.item.Correction_CL2[CurRxBuf[7]][1] & 0xff;
                    tx[9] = (Charger.memory.EVSE_Config.data.item.Correction_CL2[CurRxBuf[7]][1]>>8) & 0xff;
                  break;
                case OUTPUT_L3_CURRENT:
                    tx[8] = Charger.memory.EVSE_Config.data.item.Correction_CL3[CurRxBuf[7]][1] & 0xff;
                    tx[9] = (Charger.memory.EVSE_Config.data.item.Correction_CL3[CurRxBuf[7]][1]>>8) & 0xff;
                  break;
                case LEAK_CURRENT:
                      tx[8] = (Charger.memory.EVSE_Config.data.item.Correction_Leak[CurRxBuf[7]][1]/100) & 0xff;
                      tx[9] = ((Charger.memory.EVSE_Config.data.item.Correction_Leak[CurRxBuf[7]][1]/100)>>8) & 0xff;
                  break;
            }

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[10] = chksum;

            break;
          case PROTOCOL_MESSAGE_QUERY_RTC:
            tx_len = 21;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_RTC;
            tx[4] = 0x0e;
            tx[5] = 0x00;
            tx[6] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.year/1000)+'0';
            tx[7] = ((Charger.memory.EVSE_Config.data.item.SystemDateTime.year%1000)/100)+'0';
            tx[8] = ((Charger.memory.EVSE_Config.data.item.SystemDateTime.year%100)/10)+'0';
            tx[9] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.year%10) +'0';
            tx[10] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.month/10) +'0';
            tx[11] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.month%10) +'0';
            tx[12] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.day/10) +'0';
            tx[13] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.day%10) +'0';
            tx[14] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.hour/10) +'0';
            tx[15] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.hour%10) +'0';
            tx[16] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.min/10) +'0';
            tx[17] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.min%10) +'0';
            tx[18] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.sec/10) +'0';
            tx[19] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.sec%10) +'0';

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[20] = chksum;
            break;


          case PROTOCOL_MESSAGE_QUERY_PRESENT_OUTPUT_CURRENT:
            tx_len = 19;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_PRESENT_OUTPUT_CURRENT;
            tx[4] = 0x0c;
            tx[5] = 0x00;
            tx[6] = (((Charger.Current[0]/10)>>0) & 0xff);
            tx[7] = (((Charger.Current[0]/10)>>8) & 0xff);
            tx[8] = (((Charger.Current[1]/10)>>0) & 0xff);
            tx[9] = (((Charger.Current[1]/10)>>8) & 0xff);
            tx[10] = (((Charger.Current[2]/10)>>0) & 0xff);
            tx[11] = (((Charger.Current[2]/10)>>8) & 0xff);
            tx[12] = 0x00;
            tx[13] = 0x00;
            tx[14] = 0x00;
            tx[15] = 0x00;
            tx[16] = 0x00;
            tx[17] = 0x00;

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[18] = chksum;

            break;
          case PROTOCOL_MESSAGE_QUERY_EVSE_STATE:
            tx_len = 22;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_EVSE_STATE;
            tx[4] = 15;
            tx[5] = 0x00;
            tx[6] = Charger.CP_State;

#ifdef MODIFY_AC_EVSE_STATUS_MAX_CHARGING_CURRENT_VARIABLE
#ifdef FUNC_AW48
            if (Charger.m_bModelNameAX || Charger.m_bModelNameAT || Charger.m_bModelNameAW48_1P)
#else //FUNC_AW48
#ifdef FUNC_AT32
            if (Charger.m_bModelNameAX || Charger.m_bModelNameAT)
#else
            if (Charger.m_bModelNameAX)
#endif
#endif //FUNC_AW48
            {
                //AX32/48
                tx[7] = (Charger.AC_MaxChargingCurrentOrDuty&0xff);
                tx[8] = Charger.AC_MaxChargingCurrentOrDuty>>8;
            }
            else
            {
                //DC Model
                tx[7] = (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent&0xff);
                tx[8] = Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>>8;
            }

#else
            tx[7] = (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent&0xff);
            tx[8] = Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>>8;
#endif
            uint16_t transfer_float;

            {
#ifdef FUNC_CP_ADC_MODIFY
                transfer_float = (uint16_t)(CpDetectionResult.PositiveValue == 0 ? 0 : HTK_GetPosFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.PositiveValue)) * 100);
#else
                //transfer_float = (uint16_t)((float)(((1.59131-((3.3*CpDetectionResult.PositiveValue)/4095))*(475/53.6)))*100);
#endif
            }

            tx[9] = (transfer_float&0xff);
            tx[10] = (transfer_float&0xff00)>>8;

            {
#ifdef FUNC_CP_ADC_MODIFY
                transfer_float = (uint16_t)(CpDetectionResult.NegativeValue == 0 ? 0 : HTK_GetNegFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.NegativeValue)) * 100);
#else
                //transfer_float = (uint16_t)((float)(((((3.3*CpDetectionResult.NegativeValue)/4095)-1.59131)*(475/53.6)))*100);
#endif
            }
            tx[11] = (transfer_float&0xff);
            tx[12] = (transfer_float&0xff00)>>8;

#ifdef FUNC_GUN_LOCK
            if (Charger.m_bUseGunLock)
            {
                tx[13] = GL_IsLock() ? 0x01 : 0x00; //Locker status
            }
            else
            {
                tx[13] = 0x00;
            }
#else
            tx[13] = 0x00; //Locker status
#endif

            {
                uint8_t val = 0;
                if (Charger.Relay_Action == GPIO_RELAY_ACTION_ON)
                {
                    //val |= 0x07;  //Use different bit
                    val |= 0x01;    //Use same bit (Fit CSU code)
                }
                if (Charger.SE_Relay_Action == GPIO_SE_RELAY_ACTION_ON)
                {
                    //val |= 0x08;  //Use different bit
                    val |= 0x01;    //Use same bit (Fit CSU code)
                }
                tx[14] = val;
            }

            tx[15] = 0x00; //Shutter status
            tx[16] = 0x00; //Meter status
#ifdef FUNC_DETECT_PP
            tx[17] = Charger.m_PPInfo.m_StatusID; //PP status
#else
            tx[17] = 0x00; //PP status
#endif //FUNC_DETECT_PP

            tx[18] = Charger.maxRatingCurrent;
#ifdef ROTATE_SWITCH_HARDCODE
            tmpBuf = HC_ROTARY_SWITCH_SET_VAL;
            tmpBuf += (HC_SWITCH_1_CONN_TYPE_VAL?0:1)<<4;
            tmpBuf += (HC_SWITCH_2_GROUND_SYS?0:1)<<5;
#else
            tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set1_GPIO_Port, IN_AC_Current_Set1_Pin)?0:1)<<0;
            tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set2_GPIO_Port, IN_AC_Current_Set2_Pin)?0:1)<<1;
            tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set3_GPIO_Port, IN_AC_Current_Set3_Pin)?0:1)<<2;
            tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set4_GPIO_Port, IN_AC_Current_Set4_Pin)?0:1)<<3;
#ifdef MODIFY_AX32_RUN_3P_OR_1P_AUTOMATIC_AFTER_GC5
            if (    Charger.m_bModelNameAX32_3P
#ifdef FUNC_AT32
                ||  Charger.m_bModelNameAT32_3P
#endif
                )
            {
                tmpBuf += (Charger.m_b3PhaseModelButUse1PhaseOnly ? 1 : 0) << 4;
            }
            else
            {
                tmpBuf += (HAL_GPIO_ReadPin(IN_GridType_Select_GPIO_Port, IN_GridType_Select_Pin)?0:1)<<4;
            }

#else //MODIFY_AX32_RUN_3P_OR_1P_AUTOMATIC_AFTER_GC5
            tmpBuf += (HAL_GPIO_ReadPin(IN_GridType_Select_GPIO_Port, IN_GridType_Select_Pin)?0:1)<<4;
#endif //MODIFY_AX32_RUN_3P_OR_1P_AUTOMATIC_AFTER_GC5
            tmpBuf += (HAL_GPIO_ReadPin(IN_Grid_Groundding_GPIO_Port, IN_Grid_Groundding_Pin)?0:1)<<5;
#endif //ROTATE_SWITCH_HARDCODE
            tx[19] = tmpBuf;

#ifdef FUNC_OUTP_TYPE_E
            tx[20] = Charger.isOnSocketE | ((IsTypeEPlugIn() ? 1 : 0) << 1);
#else
            //tx[20] = Charger.isOnSocketE | ((HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin)?0:1)<<1);
#endif
            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[21] = chksum;
            break;

          case PROTOCOL_MESSAGE_QUERY_EVSE_ALARM:
            tx_len = 11;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_EVSE_ALARM;
            tx[4] = 4;
            tx[5] = 0x00;

#ifdef VO_SIMU_ALARMCODE
            if (Charger.m_VOCode.m_EnableSimuAlarmCode)
            {
                HTK_U32(tx[6]) = Charger.m_SimuData.m_AlarmCode;
            }
            else
            {
//                tx[6] = (Charger.Alarm_Code&0xff);
//                tx[7] = (Charger.Alarm_Code&0xff00)>>8;
//                tx[8] = (Charger.Alarm_Code&0xff0000)>>16;
//                tx[9] = (Charger.Alarm_Code&0xff000000)>>24;
                HTK_U32(tx[6]) = Charger.Alarm_Code;
            }
#else
//            tx[6] = (Charger.Alarm_Code&0xff);
//            tx[7] = (Charger.Alarm_Code&0xff00)>>8;
//            tx[8] = (Charger.Alarm_Code&0xff0000)>>16;
//            tx[9] = (Charger.Alarm_Code&0xff000000)>>24;
              HTK_U32(tx[6]) = Charger.Alarm_Code;
#endif
            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[10] = chksum;
            break;
          case PROTOCOL_MESSAGE_QUERY_BLE_STATE:
            tx_len = 10;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_BLE_STATE;
            tx[4] = 3;
            tx[5] = 0x00;

            tx[6] = 0x00 ;
            tx[7] = 0x00 ;
            tx[8] = 0x00 ;

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[9] = chksum;
            break;
          case PROTOCOL_MESSAGE_QUERY_BLE_LOGIC_CENTRAL_ID:
            tx_len = 39;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_BLE_LOGIC_CENTRAL_ID;
            tx[4] = 32;
            tx[5] = 0x00;
            tx[6] = 'P';
            tx[7] = 'H';
            tx[8] = 'I';
            tx[9] = 'H';
            tx[10] = 'O';
            tx[11] = 'N';
            tx[12] = 'G';
            tx[13] = ' ';
            tx[14] = 'A';
            tx[15] = 'C';

            tx[16] = '-';
            tx[17] = 'S';
            tx[18] = 'i';
            tx[19] = 'm';
            tx[20] = 'p';
            tx[21] = 'l';
            tx[22] = 'e';
            tx[23] = ' ';
            tx[24] = '1';
            tx[25] = '2';

            tx[26] = '3';
            tx[27] = '4';
            tx[28] = '5';
            tx[29] = '6';
            tx[30] = '7';
            tx[31] = '8';
            tx[32] = '9';
            tx[33] = 'A';
            tx[34] = 'B';
            tx[35] = 'C';

            tx[36] = 'D';
            tx[37] = 'E';

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[38] = chksum;
            break;
          case PROTOCOL_MESSAGE_QUERY_POWER_CONSUME:
#ifdef MODIFY_PROTOCOL_MESSAGE_QUERY_POWER_CONSUME_64_BIT
            tx_len = 39;
#else
            tx_len = 23;
#endif
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_POWER_CONSUME;
#ifdef MODIFY_PROTOCOL_MESSAGE_QUERY_POWER_CONSUME_64_BIT
            tx[4] = 32;
#else
            tx[4] = 16;
#endif
            tx[5] = 0x00;


#ifdef MODIFY_PROTOCOL_MESSAGE_QUERY_POWER_CONSUME_64_BIT
            {
                memcpy(&tx[6], &Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total, sizeof(uint64_t) * 4);
                for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
                {
                  chksum ^= tx[6 + idx];
                }
                tx[38] = chksum;
            }
#else
            HTK_U32(tx[6])  = (uint32_t)(HTK_ROUND_U64((double)Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total / 100));
            HTK_U32(tx[10]) = (uint32_t)(HTK_ROUND_U64((double)Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 / 100));
            HTK_U32(tx[14]) = (uint32_t)(HTK_ROUND_U64((double)Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 / 100));
            HTK_U32(tx[18]) = (uint32_t)(HTK_ROUND_U64((double)Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3 / 100));

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[22] = chksum;
#endif //MODIFY_PROTOCOL_MESSAGE_QUERY_POWER_CONSUME_64_BIT

            break;


          case PROTOCOL_MESSAGE_QUERY_GUN_PLUGIN_TIMES:
            tx_len = 11;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_GUN_PLUGIN_TIMES;
            tx[4] = 4;
            tx[5] = 0x00;
            tx[6] = (Charger.memory.EVSE_Config.data.item.AcPlugInTimes&0xff);
            tx[7] = (Charger.memory.EVSE_Config.data.item.AcPlugInTimes&0xff00)>>8;
            tx[8] = (Charger.memory.EVSE_Config.data.item.AcPlugInTimes&0xff0000)>>16;
            tx[9] = (Charger.memory.EVSE_Config.data.item.AcPlugInTimes&0xff000000)>>24;
            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[10] = chksum;
            break;

          case PROTOCOL_MESSAGE_QUERY_EVSE_AUTH_MODE:
            tx_len = 9;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_EVSE_AUTH_MODE;
            tx[4] = 2;
            tx[5] = 0x00;
            tx[6] = Charger.memory.EVSE_Config.data.item.AuthMode;
            tx[7] = Charger.memory.EVSE_Config.data.item.OfflinePolicy;
            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[8] = chksum;
            break;

          case PROTOCOL_MESSAGE_QUERY_PRESENT_LEAK_CURRENT:
            tx_len = 9;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_PRESENT_LEAK_CURRENT;
            tx[4] = 2;
            tx[5] = 0x00;
            tx[6] = Charger.Leak_Current/100;
            tx[7] = 0;
            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[8] = chksum;
            break;

#ifdef FUNC_METER_IC_ADE7858A

        case PROTOCOL_MESSAGE_QUERY_METER_IC_MEAS_PARAMETER:
            tx_len = 6 + sizeof(MeterIC_MeasVals) + 1;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_METER_IC_MEAS_PARAMETER;

            memcpy(&tx[6], &Charger.m_MeterIC_MeasVals, sizeof(MeterIC_MeasVals));
            UpdateCheckSum(tx, tx_len);
            break;

        case PROTOCOL_MESSAGE_QUERY_METER_IC_CALI_PARAMETER:

            tx_len = 6 + (5) + 1;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_METER_IC_CALI_PARAMETER;

#ifdef FUNC_METER_IC_CALI_FLAG
            if (CurRxBuf[6] == MICC_READ_METER_IC_CALI_FLAG)
            {
                tx[6] = CurRxBuf[6];

                uint32_t tmp = Charger.memory.EVSE_Config.data.item.m_MeterIC_CaliFlag.m_Data;
                tmp |= (Charger.m_bMeterIC_CaliValIsDefault << 31);
                HTK_U32(tx[7]) = tmp;
            }
            else
#endif //FUNC_METER_IC_CALI_FLAG

#ifdef FUNC_QUERY_METER_IC_DIE_VERSION
            if (CurRxBuf[6] == MICC_GET_DIE_VERSION)
            {
                tx[6] = CurRxBuf[6];
//#ifdef FUNC_FORCE_QUERY_METER_IC_DIE_VERSION_2
//                HTK_U32(tx[7]) = 0x02;
//#else
                HTK_U32(tx[7]) = Charger.m_MeterIcEx.m_DieVersion;
//#endif
            }
            else
#endif

#ifdef VO_GET_VO_CODE
            if (CurRxBuf[6] == MICC_GET_VO_CODE)
            {
                tx[6] = CurRxBuf[6];
                HTK_U32(tx[7]) = Charger.m_VOCode.m_Value;
            }
            else
#endif //VO_GET_VO_CODE
            {
                MeterIC_CaliValType type = (MeterIC_CaliValType)CurRxBuf[6];
                int32_t *p = MeterIC_GetCaliValPtr(type, NULL);
                if (p != NULL)
                {
                    tx[6] = (uint8_t)type;
                    HTK_U32(tx[7]) = (uint32_t)*p; //7-10
                }
                else
                {
                    tx[6] = (uint8_t)MICC_UNDEFINED;
                    HTK_U32(tx[7]) = HTK_U32_MAX;
                }
            }
            UpdateCheckSum(tx, tx_len);
            break;


#ifdef FUNC_METER_IC_HISTORY_IMCP_CMD
        case PROTOCOL_MESSAGE_QUERY_METER_IC_CALI_HISTORY:

            tx_len = 6 + (5) + 1;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_METER_IC_CALI_HISTORY;
            {
                uint8_t area = CurRxBuf[6];
                uint16_t idx = HTK_U16(CurRxBuf[7]);
                tx[6] = HTK_U16_BYTE(idx, 0);
                tx[7] = HTK_U16_BYTE(idx, 1);
                if (area > 1 || idx > 0xFF)
                {
                    DT* pDT = &Charger.memory.hisMeterIC.data.item[idx].DateTime;
                    tx[8] = HTK_U16_BYTE(pDT->year, 0);
                    tx[9] = HTK_U16_BYTE(pDT->year, 1);
                    tx[10] = pDT->month;
                    tx[11] = pDT->day;
                    tx[12] = pDT->hour;
                    tx[13] = pDT->min;
                    tx[14] = pDT->sec;
                    tx[15] = (uint8_t)Charger.memory.hisMeterIC.data.item[idx].m_CaliValType;
                    HTK_U32(tx[16]) = Charger.memory.hisMeterIC.data.item[idx].m_CaliVal; //16~19
                }
                else
                {
                    memset(&tx[8], 0xFF, 12);
                }
            }
            UpdateCheckSum(tx, tx_len);
            break;

#endif //FUNC_METER_IC_HISTORY_IMCP_CMD


#endif //FUNC_METER_IC_ADE7858A

#ifdef FUNC_PTB_METER_WM3M4C
        case PROTOCOL_MESSAGE_QUERY_PTB_METER_WM3M4C:
            {
                tx[0] = 0xaa;
                tx[1] = PROTOCOL_ADDR;
                tx[2] = CurRxBuf[1];
                tx[3] = PROTOCOL_MESSAGE_QUERY_PTB_METER_WM3M4C;

                PWM3M4C p = Charger.m_pWM3M4C;
                byte SubCmd = CurRxBuf[6];

#ifdef FUNC_CSU_CMD_DEBUG
                char* s = "#CSU_WM3M4C_Get: ";
                XP("%s0x%02X%s\r\n", s, SubCmd, (Charger.m_bUseExtMeter_WM3M4C && p ? "" : " (NOT SUPPORTED)"));
#endif
                tx[6] = SubCmd;

                if (Charger.m_bUseExtMeter_WM3M4C && p)
                {
                    if (SubCmd == WM3M4C_GCMD_OUTP_OCMF_MSG_SIG_LEN)
                    {
                        tx_len = IMCP_TX_LEN(1 + 2);
                        HTK_U16(tx[7]) = p->m_OutpMsgSigLen;
                    }
                    else if (SubCmd == WM3M4C_GCMD_OUTP_OCMF_MSG_SIG)
                    {
                        tx_len = IMCP_TX_LEN(1 + p->m_OutpMsgSigLen);
                        memcpy(&tx[7], p->m_OutpMsgSig, p->m_OutpMsgSigLen);
                    }
                    else if (SubCmd == WM3M4C_GCMD_HEADER_PKEY_LEN)
                    {
                        tx_len = IMCP_TX_LEN(1 + 2);
                        HTK_U16(tx[7]) = p->m_HPKeyLen;
                    }
                    else if (SubCmd == WM3M4C_GCMD_HEADER_PKEY)
                    {
                        tx_len = IMCP_TX_LEN(1 + p->m_HPKeyLen);
                        memcpy(&tx[7], p->m_HPKey, p->m_HPKeyLen);
                    }
                    else if (SubCmd == WM3M4C_GCMD_OUTP_MSG_FMT_ID)
                    {
                        u8 n = strlen(p->m_OutpMsgFmtStr);
                        tx_len = IMCP_TX_LEN(1 + 1 + n);
                        tx[7] = p->m_OutpMsgFmtID;
                        memcpy(&tx[8], p->m_OutpMsgFmtStr, n) ;
                    }
                    else if (SubCmd == WM3M4C_GCMD_OUTP_MSG_LEN)
                    {
                        tx_len = IMCP_TX_LEN(1 + 2);
                        HTK_U16(tx[7]) = p->m_OutpMsgLen.m_Val;
                    }
                    else if (SubCmd == WM3M4C_GCMD_OUTP_MSG)
                    {
                        tx_len = IMCP_TX_LEN(1 + p->m_OutpMsgLen.m_Val);
                        memcpy(&tx[7], p->m_OutpMsg.m_Buf, p->m_OutpMsgLen.m_Val);
                    }
                    else if (SubCmd == WM3M4C_GCMD_OUTP_SIG_LEN)
                    {
                        tx_len = IMCP_TX_LEN(1 + 2);
                        HTK_U16(tx[7]) = p->m_OutpSigLen.m_Val * 2; //Byte to ASCII String
                    }
                    else if (SubCmd == WM3M4C_GCMD_OUTP_SIG)
                    {
                        tx_len = IMCP_TX_LEN(1 + p->m_OutpSigLen.m_Val * 2);
                        memcpy(&tx[7], p->m_OutpSig.m_Str, p->m_OutpSigLen.m_Val * 2);
                    }
                    else if (SubCmd == WM3M4C_GCMD_PKEYHEADER_LEN)
                    {
                        tx_len = IMCP_TX_LEN(1 + 2);
                        HTK_U16(tx[7]) = WM3M3C_PUBLIC_KEY_H_LEN * 2;
                    }
                    else if (SubCmd == WM3M4C_GCMD_PKEYHEADER)
                    {
                        tx_len = IMCP_TX_LEN(1 + WM3M3C_PUBLIC_KEY_H_LEN * 2);
                        memcpy(&tx[7], p->m_PublicKeyHStr, WM3M3C_PUBLIC_KEY_H_LEN * 2);
                    }
                    else if (SubCmd == WM3M4C_GCMD_PKEY_LEN)
                    {
                        tx_len = IMCP_TX_LEN(1 + 2);
                        HTK_U16(tx[7]) = p->m_PublicKeyStrLen;
                    }
                    else if (SubCmd == WM3M4C_GCMD_PKEY)
                    {
                        tx_len = IMCP_TX_LEN(1 + p->m_PublicKeyStrLen);
                        memcpy(&tx[7], p->m_PublicKey.m_Str, p->m_PublicKeyStrLen);
                    }
                    else
                    {
                        tx_len = IMCP_TX_LEN(1);
                        tx[6] = 0; //NG
                    }
                }
                else
                {
                    tx_len = IMCP_TX_LEN(1);
                    tx[6] = 0; //NG
                }

                UpdateCheckSum(tx, tx_len);
            }
            break;
#endif //FUNC_PTB_METER_WM3M4C

#ifdef FUNC_EKM_OMNIMETER
        case PROTOCOL_MESSAGE_QUERY_EKM_OMNIMETER:
            {
                tx[0] = 0xaa;
                tx[1] = PROTOCOL_ADDR;
                tx[2] = CurRxBuf[1];
                tx[3] = PROTOCOL_MESSAGE_QUERY_EKM_OMNIMETER;

                PEKM_Omnimeter p = Charger.m_pEKM_Omnimeter;
                byte SubCmd = CurRxBuf[6];

//#ifdef FUNC_CSU_CMD_DEBUG
//                char* s = "#CSU_EKM_Omnimeter_Get: ";
//                XP("%s0x%02X%s\r\n", s, SubCmd, (Charger.m_bUseExtMeter_OMNIMETER && p ? "" : " (NOT SUPPORTED)"));
//#endif
                tx[6] = SubCmd;

                if (Charger.m_bUseExtMeter_OMNIMETER && p)
                {
                    if (SubCmd == EKM_OMNIMETER_GCMD_POWER_CURRENT)
                    {
//                        tx_len = IMCP_TX_LEN(1 + (sizeof(u32) * 4)); //(u32) m_RMS_Watts_Ln_(1~3), m_RMS_Watts_Tot
//                        memcpy(&tx[7], &p->m_RMS_Watts_Ln_1, sizeof(u32) * 4);

                        tx_len = IMCP_TX_LEN(1 + (sizeof(u32) * 7)); //(u32) m_RMS_Watts_Ln_(1~3), m_RMS_Watts_Tot, Amps_Ln_(1~3)
                        memcpy(&tx[7], &p->m_RMS_Watts_Ln_1, sizeof(u32) * 4);//7-10, 11-14, 15-18, 19-22 /// 23-26, 27-30, 31-34
                        u32 vTemp[3] = {
                            (u32)(p->m_Amps_Ln_1 * 10),
                            (u32)(p->m_Amps_Ln_2 * 10),
                            (u32)(p->m_Amps_Ln_3 * 10)};
                        memcpy(&tx[23], vTemp, sizeof(u32) * 3);
                    }
                    else
                    {
                        tx_len = IMCP_TX_LEN(1);
                        tx[6] = 0; //NG
                    }
                }
                else
                {
                    tx_len = IMCP_TX_LEN(1);
                    tx[6] = 0; //NG
                }

                UpdateCheckSum(tx, tx_len);
            }
            break;
#endif //FUNC_EKM_OMNIMETER

#ifdef FUNC_WARNING_CODE
          case PROTOCOL_MESSAGE_QUERY_EVSE_WARNING:
            tx_len = 11;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_QUERY_EVSE_WARNING;
            tx[4] = 4;
            tx[5] = 0x00;

            HTK_U32(tx[6]) = Charger.Warning_Code;

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[10] = chksum;
            break;
#endif //FUNC_WARNING_CODE

#ifdef FUNC_CSU_PUBLIC_KEY_OPERATION
        case PROTOCOL_MESSAGE_QUERY_EVSE_PUBLIC_KEY:
            {
                enum
                {
                    DATA_LEN = 64,
                    SALT_LEN = 64,
                    MIXTURE_LEN = DATA_LEN + SALT_LEN,
                    SALTMAP_LEN = GET_BOX_NUM(MIXTURE_LEN, 8),
                    ALL_LEN = MIXTURE_LEN + SALTMAP_LEN,
                };
                tx_len = IMCP_TX_LEN(ALL_LEN);
                tx[0] = 0xaa;
                tx[1] = PROTOCOL_ADDR;
                tx[2] =  CurRxBuf[1];
                tx[3] = PROTOCOL_MESSAGE_QUERY_EVSE_PUBLIC_KEY;
                HTK_U16(tx[4]) = ALL_LEN;

                //XP("\r\n[PROTOCOL_MESSAGE_QUERY_EVSE_PUBLIC_KEY]\r\n\r\n");

#ifdef FUNC_ENABLE_CSU_SIGN_IN_WHEN_MCU_HAVE_NG_MODELNAME
                if (!Charger.m_bCsuSignInMustVerify)
                {
                    Charger.m_bCsuSignInMustVerify = HTK_TRUE;
                }
#endif
                if (Charger.m_bCsuSignInMustVerify)
                {
                    if (DataEncryption(Charger.memory.EVSE_Config.data.item.m_CsuPublicKey, DATA_LEN, &tx[6], ALL_LEN, 0) == PASS)
                    {
#ifdef FUNC_SECURITY_DEBUG_INFO
                        HTK_ByteArray2HexStr_XP("#CSU_GetPublicKey", Charger.memory.EVSE_Config.data.item.m_CsuPublicKey, 0, DATA_LEN);
#endif
                        XP("#CSU_GetPublicKey: OK\r\n");
                    }
                    else
                    {
                        memset(&tx[6], 0, ALL_LEN);
                        XP("#CSU_GetPublicKey: [NG]\r\n");
                    }
                }
                else
                {
                    memset(&tx[6], 0, ALL_LEN);
                    XP("#CSU_GetPublicKey: [NG]\r\n");
                }
                UpdateCheckSum(tx, tx_len);
            }
            break;
#endif //FUNC_CSU_PUBLIC_KEY_OPERATION
          /*
            Config message
          */
          case PROTOCOL_MESSAGE_CONFIG_FAN_SPEED:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_FAN_SPEED;
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = 0x01;
            tx[7] = 0x01;

            break;
          case PROTOCOL_MESSAGE_CONFIG_SN:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_SN;
            tx[4] = 0x01;
            tx[5] = 0x00;

#ifdef MODIFY_CONFIG_SN
            {
                uint16_t len = HTK_U16(CurRxBuf[4]);
                if (len < sizeof(Charger.memory.EVSE_Config.data.item.SerialNumber) && HTK_IS_DISP_CHAR(CurRxBuf[14]))
                {
                    //OK
                    tx[6] = 0x01;
                    tx[7] = 0x01;
                    memset(Charger.memory.EVSE_Config.data.item.SerialNumber, 0, ARRAY_SIZE(Charger.memory.EVSE_Config.data.item.SerialNumber));
                    memset(Charger.memory.EVSE_Config.data.item.System_ID, 0, ARRAY_SIZE(Charger.memory.EVSE_Config.data.item.System_ID));
                    for(uint16_t idx=0;idx<(len-8);idx++)
                    {
                        Charger.memory.EVSE_Config.data.item.SerialNumber[idx] = CurRxBuf[14+idx];
                    }
                    Charger.memory.EVSE_Config.data.item.SerialNumber[len-8] = '\0';
                    memcpy(Charger.memory.EVSE_Config.data.item.System_ID, Charger.memory.EVSE_Config.data.item.ModelName, strlen(Charger.memory.EVSE_Config.data.item.ModelName));
                    memcpy(&Charger.memory.EVSE_Config.data.item.System_ID[strlen(Charger.memory.EVSE_Config.data.item.ModelName)], Charger.memory.EVSE_Config.data.item.SerialNumber, len);

                    XP("#CONFIG_SN: %s\r\n", Charger.memory.EVSE_Config.data.item.SerialNumber);
                    //parseVersionInfoFromModelname() ;
                    Charger.memory.EVSE_Config.op_bits.update = ON;
                    break;
                }
                else
                {
                    //NG
                    tx[6] = 0x00;
                    tx[7] = 0x00;
                    break;
                }
            }
#else //MODIFY_CONFIG_SN
//            tx[6] = 0x01;
//            tx[7] = 0x01;
//
//            memset(Charger.memory.EVSE_Config.data.item.SerialNumber, 0x00, sizeof(Charger.memory.EVSE_Config.data.item.SerialNumber)/sizeof(Charger.memory.EVSE_Config.data.item.SerialNumber[0]));
//            memset(Charger.memory.EVSE_Config.data.item.System_ID, 0x00, sizeof(Charger.memory.EVSE_Config.data.item.System_ID)/sizeof(Charger.memory.EVSE_Config.data.item.System_ID[0]));
//            for(uint16_t idx=0;idx<((CurRxBuf[4] | (CurRxBuf[5]<<8))-8);idx++)
//            {
//                Charger.memory.EVSE_Config.data.item.SerialNumber[idx] = CurRxBuf[14+idx];
//            }
//            Charger.memory.EVSE_Config.data.item.SerialNumber[(CurRxBuf[4] | (CurRxBuf[5]<<8))-8] = '\0';
//            memcpy(Charger.memory.EVSE_Config.data.item.System_ID, Charger.memory.EVSE_Config.data.item.ModelName, strlen(Charger.memory.EVSE_Config.data.item.ModelName));
//            memcpy(&Charger.memory.EVSE_Config.data.item.System_ID[strlen(Charger.memory.EVSE_Config.data.item.ModelName)], Charger.memory.EVSE_Config.data.item.SerialNumber, (CurRxBuf[4] | (CurRxBuf[5]<<8)));
//
//            parseVersionInfoFromModelname() ;
//            Charger.memory.EVSE_Config.op_bits.update = ON;
//            break;
#endif //MODIFY_CONFIG_SN
          case PROTOCOL_MESSAGE_CONFIG_MODEL_NAME:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_MODEL_NAME;
            tx[4] = 0x01;
            tx[5] = 0x00;
#ifdef MODIFY_CONFIG_MODEL_NAME

            {
                uint16_t len = HTK_U16(CurRxBuf[4]);
                if (len < sizeof(Charger.memory.EVSE_Config.data.item.ModelName) && HTK_IS_DISP_CHAR(CurRxBuf[6]))
                {
#ifdef FUNC_IGNORE_ILLEGAL_MODEL_NAME
                    if (CurRxBuf[6] != 'A' && CurRxBuf[6] != 'D')
                    {
                        CurRxBuf[6+14] = '\0';
                        XP("#CONFIG_ILLEGAL_MODEL_NAME: %s\r\n", (char*)&CurRxBuf[6]);
                        //NG
                        tx[6] = 0x00;
                        tx[7] = 0x00;
                        break;
                    }
#endif
                    //OK
                    tx[6] = 0x01;
                    tx[7] = 0x01;
                    memset(Charger.memory.EVSE_Config.data.item.ModelName, 0, ARRAY_SIZE(Charger.memory.EVSE_Config.data.item.ModelName));
                    memset(Charger.memory.EVSE_Config.data.item.System_ID, 0, ARRAY_SIZE(Charger.memory.EVSE_Config.data.item.System_ID));
                    for(uint16_t idx=0;idx<len;idx++)
                    {
                        Charger.memory.EVSE_Config.data.item.ModelName[idx] = CurRxBuf[6+idx];
                    }
                    Charger.memory.EVSE_Config.data.item.ModelName[len] = '\0';
                    memcpy(Charger.memory.EVSE_Config.data.item.System_ID, Charger.memory.EVSE_Config.data.item.ModelName, strlen(Charger.memory.EVSE_Config.data.item.ModelName));
                    memcpy(&Charger.memory.EVSE_Config.data.item.System_ID[strlen(Charger.memory.EVSE_Config.data.item.ModelName)], Charger.memory.EVSE_Config.data.item.SerialNumber, len);
                    XP("#CONFIG_MODEL_NAME: %s\r\n", Charger.memory.EVSE_Config.data.item.ModelName);
#ifdef FUNC_AUTO_MODIFY_CCID_MODULE
                    Charger.m_bCCID_MustModify = HTK_TRUE;
#endif
                    parseVersionInfoFromModelname() ;
                    Charger.memory.EVSE_Config.op_bits.update = ON;
#ifdef FUNC_RESET_DATA_AFTER_WRITE_NEW_MODELNAME
                    if (Charger.Alarm_Code != 0)
                    {
                        Charger.m_bTrigToClearAlarmCode = HTK_TRUE;
                        Charger.m_bTrigToRefreshMeterIcCaliVal = HTK_TRUE;
                        setChargerMode(MODE_INITIAL);
                    }
#endif
                    break;

                }
                else
                {
                    //NG
                    tx[6] = 0x00;
                    tx[7] = 0x00;
                    break;
                }
            }

#else //MODIFY_CONFIG_MODEL_NAME
//            tx[6] = 0x01;
//            tx[7] = 0x01;
//
//            memset(Charger.memory.EVSE_Config.data.item.ModelName, 0x00, sizeof(Charger.memory.EVSE_Config.data.item.ModelName)/sizeof(Charger.memory.EVSE_Config.data.item.ModelName[0]));
//            memset(Charger.memory.EVSE_Config.data.item.System_ID, 0x00, sizeof(Charger.memory.EVSE_Config.data.item.System_ID)/sizeof(Charger.memory.EVSE_Config.data.item.System_ID[0]));
//            for(uint16_t idx=0;idx<(CurRxBuf[4] | (CurRxBuf[5]<<8));idx++)
//            {
//                Charger.memory.EVSE_Config.data.item.ModelName[idx] = CurRxBuf[6+idx];
//            }
//            Charger.memory.EVSE_Config.data.item.ModelName[(CurRxBuf[4] | (CurRxBuf[5]<<8))] = '\0';
//            memcpy(Charger.memory.EVSE_Config.data.item.System_ID, Charger.memory.EVSE_Config.data.item.ModelName, strlen(Charger.memory.EVSE_Config.data.item.ModelName));
//            memcpy(&Charger.memory.EVSE_Config.data.item.System_ID[strlen(Charger.memory.EVSE_Config.data.item.ModelName)], Charger.memory.EVSE_Config.data.item.SerialNumber, (CurRxBuf[4] | (CurRxBuf[5]<<8)));
//
//            parseVersionInfoFromModelname() ;
//            Charger.memory.EVSE_Config.op_bits.update = ON;
//            break;
#endif //MODIFY_CONFIG_MODEL_NAME

          case PROTOCOL_MESSAGE_CONFIG_PARAMETER:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_PARAMETER;
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = 0x01;

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[7] = chksum;                       //checksum

            switch(CurRxBuf[6])
            {
                case INPUT_L1_AC_VOLTAGE:
                  Charger.memory.EVSE_Config.data.item.Correction_VL1[CurRxBuf[7]][0] = adc_value.ADC3_IN9_Voltage_L1.value/10;
                  Charger.memory.EVSE_Config.data.item.Correction_VL1[CurRxBuf[7]][1] = CurRxBuf[8] | (CurRxBuf[9]<<8);
                  break;
                case INPUT_L2_AC_VOLTAGE:
                  Charger.memory.EVSE_Config.data.item.Correction_VL2[CurRxBuf[7]][0] = adc_value.ADC3_IN8_Voltage_L2.value/10;;
                  Charger.memory.EVSE_Config.data.item.Correction_VL2[CurRxBuf[7]][1] = CurRxBuf[8] | (CurRxBuf[9]<<8);
                  break;
                case INPUT_L3_AC_VOLTAGE:
                  Charger.memory.EVSE_Config.data.item.Correction_VL3[CurRxBuf[7]][0] = adc_value.ADC3_IN10_Voltage_L3.value/10;;
                  Charger.memory.EVSE_Config.data.item.Correction_VL3[CurRxBuf[7]][1] = CurRxBuf[8] | (CurRxBuf[9]<<8);
                  break;
                case OUTPUT_L1_CURRENT:
                  Charger.memory.EVSE_Config.data.item.Correction_CL1[CurRxBuf[7]][0] = adc_value.ADC3_IN7_Current_L1.value/10;
                  Charger.memory.EVSE_Config.data.item.Correction_CL1[CurRxBuf[7]][1] = CurRxBuf[8] | (CurRxBuf[9]<<8);
                  break;
                case OUTPUT_L2_CURRENT:
                  Charger.memory.EVSE_Config.data.item.Correction_CL2[CurRxBuf[7]][0] = adc_value.ADC3_IN5_Current_L2.value/10;
                  Charger.memory.EVSE_Config.data.item.Correction_CL2[CurRxBuf[7]][1] = CurRxBuf[8] | (CurRxBuf[9]<<8);
                  break;
                case OUTPUT_L3_CURRENT:
                  Charger.memory.EVSE_Config.data.item.Correction_CL3[CurRxBuf[7]][0] = adc_value.ADC3_IN11_Current_L3.value/10;
                  Charger.memory.EVSE_Config.data.item.Correction_CL3[CurRxBuf[7]][1] = CurRxBuf[8] | (CurRxBuf[9]<<8);
                  break;
                case LEAK_CURRENT:
                  Charger.memory.EVSE_Config.data.item.Correction_Leak[CurRxBuf[7]][0] = adc_value.ADC2_IN6_GF.value;   // 2500->25mA
                  Charger.memory.EVSE_Config.data.item.Correction_Leak[CurRxBuf[7]][1] = ((CurRxBuf[8] | (CurRxBuf[9]<<8))*100); // mA
                  DEBUG_INFO("Charger.memory.EVSE_Config.data.item.Correction_Leak[[0] = %d\r\n",Charger.memory.EVSE_Config.data.item.Correction_Leak[CurRxBuf[7]][0]);
                  DEBUG_INFO("Charger.memory.EVSE_Config.data.item.Correction_Leak[[1] = %d\r\n",Charger.memory.EVSE_Config.data.item.Correction_Leak[CurRxBuf[7]][1]);
                  break;
                case GROUND_FAULT_VOLTAGE: //max 3.3V
                  Charger.memory.EVSE_Config.data.item.Correction_GMI[CurRxBuf[7]][0] = (uint16_t)(adc_value.ADC3_IN4_GMI_VL1.value*10*3.3/4095) ;
                  Charger.memory.EVSE_Config.data.item.Correction_GMI[CurRxBuf[7]][1] = CurRxBuf[8] | (CurRxBuf[9]<<8);
                  break;

            }
            Charger.memory.EVSE_Config.op_bits.update = ON;

            break;
          case PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT;
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = 0x01;
            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[7] = chksum;

#ifdef MODIFY_GOT_CSU_DUTY_CMD_PROCESS
            Charger.m_bPassGotCsuCpDutyCmd =
                (Charger.am3352.isRequestOn &&
                    Charger.Alarm_Code == 0 &&
                    (
                        (Charger.CP_State == SYSTEM_STATE_C && CurRxBuf[9] == 0x07) ||
                        (Charger.m_bEnableTypeE && IsTypeEPlugIn() && CurRxBuf[9] == 0x08)
                    )
                );
#endif

            if (
#ifdef MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_LEGACY_REQUEST
                    Charger.am3352.isRequestOn &&
#endif

#ifdef MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_ALARM_CODE
                    Charger.Alarm_Code == 0 &&
#endif

#ifdef MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_MODE_CHARGING
                    Charger.Mode == MODE_CHARGING &&
#endif

#ifdef MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_CP_PWM
                    Charger.m_CP_CurPWM != PWM_DUTY_FULL &&
#endif
                    Charger.CP_State == SYSTEM_STATE_C &&
                    CurRxBuf[9] == 0x07 //Main relay (0111b)
                )
            {
                Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
#ifdef FUNC_RELAY_OFF_WHEN_GET_TWICE_OFF_CMD
                CsuSetRelayOffCount = 0;
#endif
            }
            else if
                (
#ifdef MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_LEGACY_REQUEST
                    Charger.am3352.isRequestOn &&
#endif

#ifdef MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_ALARM_CODE
                    Charger.Alarm_Code == 0 &&
#endif

#ifdef MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_MODE_CHARGING
                    Charger.Mode == MODE_CHARGING &&
#endif
                    Charger.m_bEnableTypeE &&
                    IsTypeEPlugIn() &&
                    CurRxBuf[9] == 0x08 //Type E socket relay (1000b)
                )
            {
                Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_ON;
#ifdef FUNC_RELAY_OFF_WHEN_GET_TWICE_OFF_CMD
                CsuSetRelayOffCount = 0;
#endif
            }
            else
            {
#ifdef FUNC_RELAY_OFF_WHEN_GET_TWICE_OFF_CMD
                if (++CsuSetRelayOffCount >= 2)
                {
                    CsuSetRelayOffCount = 0;
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
                    if (Charger.Mode != MODE_DEBUG)
                    {
                        Charger.Relay_Action = GPIO_RELAY_ACTION_OFF ;
                    }
                    Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#else
                    Charger.Relay_Action = GPIO_RELAY_ACTION_OFF ;
                    Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
                }
#else //FUNC_RELAY_OFF_WHEN_GET_TWICE_OFF_CMD
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
                if (Charger.Mode != MODE_DEBUG)
                {
                    Charger.Relay_Action = GPIO_RELAY_ACTION_OFF ;
                }
                Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#else
                Charger.Relay_Action = GPIO_RELAY_ACTION_OFF ;
                Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
#endif //FUNC_RELAY_OFF_WHEN_GET_TWICE_OFF_CMD
            }

#ifdef FUNC_CSU_CMD_DEBUG
            XP("#CSU_SetRelay: %d\r\n", CurRxBuf[9]);
#endif
            DEBUG_INFO("Set Relay Action By CSU: %d => Main(%d), TypeE(%d)\r\n",
                       CurRxBuf[9],
                       Charger.Relay_Action,
                       Charger.SE_Relay_Action);
            break;

          case PROTOCOL_MESSAGE_CONFIG_GPIO_OUTPUT:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_GPIO_OUTPUT;
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = CurRxBuf[6];
            tx[7] = 0x00 ^ CurRxBuf[6];

            break;

          case PROTOCOL_MESSAGE_CONFIG_RTC:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_RTC;
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = 0x01;
            tx[7] = 0x01;

            setTime.Hours = (CurRxBuf[14]-'0')*10 + (CurRxBuf[15]-'0');
            setTime.Minutes = (CurRxBuf[16]-'0')*10 + (CurRxBuf[17]-'0');
            setTime.Seconds = (CurRxBuf[18]-'0')*10 + (CurRxBuf[19]-'0');
            setTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
            setTime.StoreOperation = RTC_STOREOPERATION_RESET;
            if (HAL_RTC_SetTime(&hrtc, &setTime, RTC_FORMAT_BIN) != HAL_OK)
            {
                Error_Handler();
            }

            setDate.Year = (CurRxBuf[6]-'0')*1000 + (CurRxBuf[7]-'0')*100 + (CurRxBuf[8]-'0')*10 + (CurRxBuf[9]-'0') - 2000;
            setDate.Month = (CurRxBuf[10]-'0')*10+ (CurRxBuf[11]-'0');
            setDate.Date = (CurRxBuf[12]-'0')*10 + (CurRxBuf[13]-'0');
            if (HAL_RTC_SetDate(&hrtc, &setDate, RTC_FORMAT_BIN) != HAL_OK)
            {
                Error_Handler();
            }
#ifdef FUNC_CSU_CMD_DEBUG
            XP("#CSU_SetRTC: %04d/%02d/%02d %02d:%02d:%02d\r\n",
                setDate.Year + 2000, setDate.Month, setDate.Date,
                setTime.Hours, setTime.Minutes, setTime.Seconds);
#endif
            break;

            case PROTOCOL_MESSAGE_CONFIG_LED_ACTION_ALARM:
#ifdef VO_BLOCK_CSU_LED_ACTION_CMD
                if (Charger.m_VOCode.m_EnableBlockCsuLedCmd)
                {
                    if (CurRxBuf == UART_IAP_rx_buffer) //CSU or Debug Port
                    {
                        tx_len = 8;
                        tx[0] = 0xaa;
                        tx[1] = PROTOCOL_ADDR;
                        tx[2] =  CurRxBuf[1];
                        tx[3] = PROTOCOL_MESSAGE_CONFIG_LED_ACTION_ALARM;
                        tx[4] = 0x01;
                        tx[5] = 0x00;
                        tx[6] = 0x01;
                        tx[7] = 0x01;
                        break;
                    }
                }
#endif

#ifdef FUNC_CUSTOMIZED_LED_MODE_FROM_CSU
                if((Charger.am3352.LedActionState != CurRxBuf[6])||(Charger.am3352.LedAlarmState != HTK_U32(CurRxBuf[7]))||CurRxBuf[6]==LED_ACTION_CUSTOMIZED_MODE)
                {
                  Charger.am3352.LedActionState = CurRxBuf[6];
                  Charger.am3352.LedAlarmState = HTK_U32(CurRxBuf[7]);
#else
                if((Charger.am3352.LedActionState != CurRxBuf[6])||(Charger.am3352.LedAlarmState != (CurRxBuf[7]|(CurRxBuf[8]<<8)|(CurRxBuf[9]<<16)|(CurRxBuf[10]<<24))))
                {
                  Charger.am3352.LedActionState = CurRxBuf[6];
                  Charger.am3352.LedAlarmState = (CurRxBuf[7]|(CurRxBuf[8]<<8)|(CurRxBuf[9]<<16)|(CurRxBuf[10]<<24));
#endif

#ifdef FUNC_SHOW_CSU_CONFIG_LED_ACTION_INFO
                  XP("#CSU_SetLed (%d, %d)\r\n", Charger.am3352.LedActionState, Charger.am3352.LedAlarmState);
#endif

                  switch(Charger.am3352.LedActionState)
                  {
                    case LED_ACTION_INIT:
                      setLedMotion(LED_ACTION_INIT);
                      break;
                    case LED_ACTION_IDLE:
                      setLedMotion(LED_ACTION_IDLE);
                      break;
                    case LED_ACTION_AUTHED:
                      setLedMotion(LED_ACTION_AUTHED);
                      break;
                    case LED_ACTION_CONNECTED:
                      setLedMotion(LED_ACTION_CONNECTED);
                      break;
                    case LED_ACTION_CHARGING:
                      setLedMotion(LED_ACTION_CHARGING);
                      break;
                    case LED_ACTION_STOP:
                      setLedMotion(LED_ACTION_STOP);
                      break;
                    case LED_ACTION_ALARM:
                      setLedMotion(LED_ACTION_ALARM);
                      break;
                    case LED_ACTION_MAINTAIN:
                      setLedMotion(LED_ACTION_MAINTAIN);
                      break;
                    case LED_ACTION_RFID_PASS:
                      setLedMotion(LED_ACTION_RFID_PASS);
                      timerEnable(TIMER_IDX_LED_TEMP, 3000);
                      break;
                    case LED_ACTION_RFID_FAIL:
                      setLedMotion(LED_ACTION_RFID_FAIL);
                      timerEnable(TIMER_IDX_LED_TEMP, 3000);
                      break;
                    case LED_ACTION_BLE_CONNECT:
                      setLedMotion(LED_ACTION_BLE_CONNECT);
                      timerEnable(TIMER_IDX_LED_TEMP, 3000);
                      break;
                    case LED_ACTION_BLE_DISABLE:
                      setLedMotion(LED_ACTION_BLE_DISABLE);
                      break;
                    case LED_ACTION_ALL_OFF:
                      setLedMotion(LED_ACTION_ALL_OFF);
                      break;
                    case LED_ACTION_INTERNET_DISCONNECT:
                      setLedMotion(LED_ACTION_INTERNET_DISCONNECT);
                      break;
                    case LED_ACTION_HANDSHAKE_FAIL:
                      setLedMotion(LED_ACTION_HANDSHAKE_FAIL);
                      timerEnable(TIMER_IDX_LED_TEMP, 3000);
                      break;
                    case LED_ACTION_RESTORE_SETTING:
                      setLedMotion(LED_ACTION_RESTORE_SETTING);
                      timerEnable(TIMER_IDX_LED_TEMP, 3000);
                      break;

#ifdef MODIFY_LED_STATUS_202108
                    case LED_ACTION_IDLE_BACKEND_CONNECTED:
                      setLedMotion(LED_ACTION_IDLE_BACKEND_CONNECTED);
                      break;
                    case LED_ACTION_IDLE_BACKEND_CONNECTED_SLEEP:
                      setLedMotion(LED_ACTION_IDLE_BACKEND_CONNECTED_SLEEP);
                      break;
                    case LED_ACTION_IDLE_BACKEND_DISCONNECTED:
                      setLedMotion(LED_ACTION_IDLE_BACKEND_DISCONNECTED);
                      break;
                    case LED_ACTION_IDLE_BACKEND_DISCONNECTED_SLEEP:
                      setLedMotion(LED_ACTION_IDLE_BACKEND_DISCONNECTED_SLEEP);
                      break;
                    case LED_ACTION_RESERVATION_MODE:
                      setLedMotion(LED_ACTION_RESERVATION_MODE);
                      break;
#endif //MODIFY_LED_STATUS_202108

#ifdef FUNC_CUSTOMIZED_LED_MODE_FROM_CSU
                    case LED_ACTION_CUSTOMIZED_MODE:
                        {
                            LED_UserCfg o = { 0 };
                            o.m_Mode = CurRxBuf[11];
                            o.m_AutoRepeat = CurRxBuf[12];
                            o.m_Brightness = CurRxBuf[13];
                            o.m_R = HTK_U16(CurRxBuf[14]);
                            o.m_G = HTK_U16(CurRxBuf[16]);
                            o.m_B = HTK_U16(CurRxBuf[18]);
                            HTK_BOOL bCfgOK = HTK_TRUE;
                            if (o.m_Mode == LED_USER_MODE_SOLID)
                            {
                                //Do nothing
                            }
                            else if (o.m_Mode == LED_USER_MODE_BLINK)
                            {
                                o.Blink.m_On_ms = HTK_U16(CurRxBuf[20]);
                                o.Blink.m_Off_ms = HTK_U16(CurRxBuf[22]);
                                o.Blink.m_Rest_ms = HTK_U16(CurRxBuf[24]);
                                o.Blink.m_Count = HTK_U16(CurRxBuf[26]);
                            }
                            else if (o.m_Mode == LED_USER_MODE_BREATH)
                            {
                                o.Breath.m_Up_ms = HTK_U16(CurRxBuf[20]);
                                o.Breath.m_Down_ms = HTK_U16(CurRxBuf[22]);
                            }
                            else
                            {
                                //Wrong mode
                                bCfgOK = HTK_FALSE;
                            }

                            if (bCfgOK)
                            {
                                setLedMotion_User(LED_ACTION_CUSTOMIZED_MODE, &o);
                            }


                        }

                      break;
#endif //FUNC_CUSTOMIZED_LED_MODE_FROM_CSU

                    default:
                      break;
                  }
                }
                tx_len = 8;
                tx[0] = 0xaa;
                tx[1] = PROTOCOL_ADDR;
                tx[2] =  CurRxBuf[1];
                tx[3] = PROTOCOL_MESSAGE_CONFIG_LED_ACTION_ALARM;
                tx[4] = 0x01;
                tx[5] = 0x00;
                tx[6] = 0x01;
                tx[7] = 0x01;
            break;
        case PROTOCOL_MESSAGE_CONFIG_MAX_CURRENT_PWM_DUTY:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_MAX_CURRENT_PWM_DUTY;
            tx[4] = 0x01;
            tx[5] = 0x00;

#ifdef FUNC_CSU_CMD_DEBUG
            XP("#CSU_SetCpPwmDuty: %d %s\r\n", CurRxBuf[6],
               (Charger.m_bBlockCsuCpPwmDuty || Charger.m_bBlockCsuCpPwmDutyWhenAlarmCpF) ? "(Block)" : "");
#endif

            if (
#ifdef FUNC_BLOCK_CSU_CONFIG_CP_PWM_DUTY
                    !Charger.m_bBlockCsuCpPwmDuty &&
#endif

#ifdef FUNC_BLOCK_CSU_CMD_SET_DUTY_WHEN_ALARM_CP_F_STATE
                    !Charger.m_bBlockCsuCpPwmDutyWhenAlarmCpF &&
#endif

                    (
#ifdef FUNC_AX80
                    (CurRxBuf[6] <= 80 && CurRxBuf[6] >= 6) ||
#else
                    (CurRxBuf[6] <= 48 && CurRxBuf[6] >= 6) ||
#endif
                    (CurRxBuf[6] == PWM_DUTY_OFF) ||
                    (CurRxBuf[6] == 1) ||
                    (CurRxBuf[6] == 5) ||
                    (CurRxBuf[6] == 100)
                    )
                )
            {

#ifdef MODIFY_AC_EVSE_STATUS_MAX_CHARGING_CURRENT_VARIABLE
                Charger.AC_MaxChargingCurrentOrDuty = CurRxBuf[6];
#endif

                tx[6] = 0x00;

#ifdef FUNC_AX80
                if(CurRxBuf[6] <= 80 && CurRxBuf[6] >= 6)
#else
                if(CurRxBuf[6] <= 48 && CurRxBuf[6] >= 6)
#endif
                {

                    Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = CurRxBuf[6];
#ifdef FUNC_CCS
                    Charger.m_bRunCCS = 0;
                    Charger.m_bGotCsuCpDutyCmd = 1;
#endif

#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
                    user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent));
#ifdef FUNC_SYSTEM_KEEP_INFO
                    g_SystemKeepInfo.m_CpPwmVal = GetCpPwmDuty(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent);
                    SystemKeepInfo_Update(&g_SystemKeepInfo);
#endif
#else //MODIFY_CP_TASK_CTRL_CP_PWM
                    //user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_651(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent));
#endif //MODIFY_CP_TASK_CTRL_CP_PWM

                    tx[6] = 0x01;
                }
                else if (CurRxBuf[6] == PWM_DUTY_OFF)
                {
                    user_pwm_setvalue(PWM_CH_CP, 0);         // State F
#ifdef FUNC_SYSTEM_KEEP_INFO
                    g_SystemKeepInfo.m_CpPwmVal = 0;
                    SystemKeepInfo_Update(&g_SystemKeepInfo);
#endif
                    tx[6] = 0x01;
                }
                else if (CurRxBuf[6] == 5)
                {
#ifdef FUNC_CCS
                    Charger.m_bRunCCS = 1;
                    Charger.m_bGotCsuCpDutyCmd = 1;
#endif
                    user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_5);
#ifdef FUNC_SYSTEM_KEEP_INFO
                    g_SystemKeepInfo.m_CpPwmVal = PWM_DUTY_5;
                    SystemKeepInfo_Update(&g_SystemKeepInfo);
#endif
                    tx[6] = 0x01;
                }
                else if (CurRxBuf[6] == 100)
                {
                    user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
#ifdef FUNC_SYSTEM_KEEP_INFO
                    g_SystemKeepInfo.m_CpPwmVal = PWM_DUTY_FULL;
                    SystemKeepInfo_Update(&g_SystemKeepInfo);
#endif
                    tx[6] = 0x01;
                }

                //control pilot E
                if (CurRxBuf[6] == 1)
                {
                    HAL_GPIO_WritePin(OUT_StateE_GPIO_Port, OUT_StateE_Pin, GPIO_PIN_SET); // ON  // State E
                    user_pwm_setvalue(PWM_CH_CP, 0);        //Temporarily, wait for EE to change the hardware and delete
#ifdef FUNC_SYSTEM_KEEP_INFO
                    g_SystemKeepInfo.m_CpPwmVal = 0;
                    SystemKeepInfo_Update(&g_SystemKeepInfo);
#endif
                    tx[6] = 0x01;
                }
                else
                {
                    HAL_GPIO_WritePin(OUT_StateE_GPIO_Port, OUT_StateE_Pin, GPIO_PIN_RESET);   //OFF
                }
                XP("#CSU_SetCpPwmDuty_Final: %d\r\n", CurRxBuf[6]);
            }
            else
            {
                tx[6] = 0x00;
                DEBUG_INFO("CSU_SetCpPwmDuty [NG] (%d) !!!!! \r\n", CurRxBuf[6]);
            }

            for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
            {
              chksum ^= tx[6 + idx];
            }
            tx[7] = chksum;                       //checksum
            break;
        case PROTOCOL_MESSAGE_CONFIG_LEGACY_REQUEST:

#ifdef FUNC_CSU_CMD_DEBUG
            XP("#CSU_SetRequest: %d\r\n", CurRxBuf[6]);
#endif

//#ifdef FUNC_DC_AUTO_RELAY_OFF
//            if (Charger.m_bModelNameDC && CurRxBuf[6] == 0)
//            {
//                if (Charger.Relay_Action != GPIO_RELAY_ACTION_OFF)
//                {
//                    XP("#SET RELAY OFF\r\n");
//                    Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
//                }
//                if (Charger.SE_Relay_Action != GPIO_SE_RELAY_ACTION_OFF)
//                {
//                    XP("#SET SE_RELAY OFF\r\n");
//                    Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
//                }
//            }
//#endif

            if((CurRxBuf[6]&SETTING_LEGACY_REQUEST)>0)
			{
//#ifdef FUNC_REQUEST_OFF_WHEN_GET_TWICE_OFF_CMD
//                CsuSetRequestOffCount = 0;
//#endif
              	Charger.am3352.isRequestOff = OFF;
				Charger.rfid.op_bits.reqStart = ON;
              	if(!Charger.am3352.isRequestOn)
				{
                    DEBUG_INFO("#Request Pin On.\r\n");
                    Charger.am3352.isRequestOn = ON;
#ifdef FUNC_SYSTEM_KEEP_INFO
                    g_SystemKeepInfo.m_CsuIsRequestOn = Charger.am3352.isRequestOn;
                    SystemKeepInfo_Update(&g_SystemKeepInfo);
#endif
            	}
            }
			else
			{
//#ifdef FUNC_REQUEST_OFF_WHEN_GET_TWICE_OFF_CMD
//                if (++CsuSetRequestOffCount >= 2)
//                {
//                    CsuSetRequestOffCount = 0;
//                    Charger.am3352.isRequestOn = OFF;
//#ifdef FUNC_SYSTEM_KEEP_INFO
//                    g_SystemKeepInfo.m_CsuIsRequestOn = Charger.am3352.isRequestOn;
//                    SystemKeepInfo_Update(&g_SystemKeepInfo);
//#endif
//                    Charger.am3352.RequestPinDebounceCnt = 0;
//                    Charger.rfid.op_bits.reqStart = OFF;
//                    if(!Charger.am3352.isRequestOff)
//                    {
//                        DEBUG_INFO("#Request Pin Off.\r\n");
//                        Charger.am3352.isRequestOff = ON;
//                    }
//				}
//#else //FUNC_REQUEST_OFF_WHEN_GET_TWICE_OFF_CMD
              	Charger.am3352.isRequestOn = OFF;
#ifdef FUNC_SYSTEM_KEEP_INFO
                g_SystemKeepInfo.m_CsuIsRequestOn = Charger.am3352.isRequestOn;
                SystemKeepInfo_Update(&g_SystemKeepInfo);
#endif
              	Charger.am3352.RequestPinDebounceCnt = 0;
              	Charger.rfid.op_bits.reqStart = OFF;
              	if(!Charger.am3352.isRequestOff)
			  	{
              		DEBUG_INFO("#Request Pin Off.\r\n");
                    Charger.am3352.isRequestOff = ON;
              	}
//#endif //FUNC_REQUEST_OFF_WHEN_GET_TWICE_OFF_CMD

            }

            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_LEGACY_REQUEST;
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = 0x01;
            tx[7] = 0x01;
            break;
        case PROTOCOL_MESSAGE_CONFIG_MCU_RESET:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_MCU_RESET;
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = 0x01;
            tx[7] = 0x01;
            if((CurRxBuf[6]&0x01)>0){
              DEBUG_INFO("MCU reset request.\r\n");

#ifdef MODIFY_DC_RS485_UPGRADE_ISSUE
            Prefix_UartTX(tx, CurRxBuf);
            HAL_UART_Transmit(pUartHandle, (uint8_t *)tx, tx_len , 0x0ffff);
            Postfix_UartTX(tx, CurRxBuf);
#else
            HAL_UART_Transmit(&IAP_USART, (uint8_t *)tx, tx_len , 0x0ffff);
#endif

              osDelay(1000);
              NVIC_SystemReset();
            }
            else
            {
              tx[6] = 0x00;
              tx[7] = 0x00;
            }
            break;
        case PROTOCOL_MESSAGE_CONFIG_BREATHE_LED_TIMING:
            Charger.am3352.BreatheLedConnectFadeIn = (((uint16_t)CurRxBuf[7]<<8)+(uint16_t)CurRxBuf[6]);
            Charger.am3352.BreatheLedConnectFadeOut = (((uint16_t)CurRxBuf[9]<<8)+(uint16_t)CurRxBuf[8]);
            DEBUG_INFO("Connect Breathe Led Fade In time: %d ms.\r\n",Charger.am3352.BreatheLedConnectFadeIn);
            DEBUG_INFO("Connect Breathe Led Fade Out time: %d ms.\r\n",Charger.am3352.BreatheLedConnectFadeOut);
            Charger.am3352.BreatheLedAuthdFadeIn = (((uint16_t)CurRxBuf[11]<<8)+(uint16_t)CurRxBuf[10]);
            Charger.am3352.BreatheLedAuthdFadeOut = (((uint16_t)CurRxBuf[13]<<8)+(uint16_t)CurRxBuf[12]);
            DEBUG_INFO("Authd Breathe Led Fade In time: %d ms.\r\n",Charger.am3352.BreatheLedAuthdFadeIn);
            DEBUG_INFO("Authd Breathe Led Fade Out time: %d ms.\r\n",Charger.am3352.BreatheLedAuthdFadeOut);
            Charger.am3352.BreatheLedChargeFadeIn = (((uint16_t)CurRxBuf[15]<<8)+(uint16_t)CurRxBuf[14]);
            Charger.am3352.BreatheLedChargeFadeOut = (((uint16_t)CurRxBuf[17]<<8)+(uint16_t)CurRxBuf[16]);
            DEBUG_INFO("Charge Breathe Led Fade In time: %d ms.\r\n",Charger.am3352.BreatheLedChargeFadeIn);
            DEBUG_INFO("Charge Breathe Led Fade Out time: %d ms.\r\n",Charger.am3352.BreatheLedChargeFadeOut);
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_BREATHE_LED_TIMING;
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = 0x01;
            tx[7] = 0x01;
            break;
        case PROTOCOL_MESSAGE_CONFIG_LED_BRIGHTNESS:
            memcpy(Charger.Led_Brightness, &CurRxBuf[6], 12);
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_LED_BRIGHTNESS;
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = 0x01;
            tx[7] = 0x01;
            break;
        case PROTOCOL_MESSAGE_CONFIG_EVSE_AUTH_MODE:
            switch(CurRxBuf[6])
            {
                case AUTH_MODE_OCPP:
                      Charger.memory.EVSE_Config.data.item.AuthMode = AUTH_MODE_OCPP ;
                  break;

                case AUTH_MODE_FREE:
                      Charger.memory.EVSE_Config.data.item.AuthMode = AUTH_MODE_FREE ;
                  break;

                default:
                      Charger.memory.EVSE_Config.data.item.AuthMode = AUTH_MODE_FREE ;
                      Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_FREE ;
                  break ;
            }

            switch(CurRxBuf[7])
            {
                case RFID_USER_AUTH_LOCAL_LIST:
                      Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_LOCAL_LIST ;
                  break;
                case RFID_USER_AUTH_PH:
                      Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_PH ;
                  break;
                case RFID_USER_AUTH_FREE:
                      Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_FREE ;
                  break;
                case RFID_USER_AUTH_NO_CHARGING:
                      Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_NO_CHARGING ;
                  break;
                default:
                      Charger.memory.EVSE_Config.data.item.AuthMode = AUTH_MODE_FREE ;
                      Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_FREE ;
                  break ;
            }

            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_EVSE_AUTH_MODE;
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = 0x01;
            tx[7] = 0x01;

            Charger.memory.EVSE_Config.op_bits.update = ON;
            break;
        case PROTOCOL_MESSAGE_CONFIG_ERASE_MEMORY:
            switch(CurRxBuf[6])
            {
                case 0:
                  Charger.memory.EVSE_Config.op_bits.clear = ON;
                  Charger.memory.whiteList.op_bits.clear = ON;
#ifdef FUNC_METER_IC_HISTORY
                  Charger.memory.hisMeterIC.op_bits.clear = ON;
#else
                  Charger.memory.hisCharging.op_bits.clear = ON;
#endif

                  Charger.memory.hisAlarm.op_bits.clear = ON;
                  Charger.memory.coldLoadPickUp.op_bits.clear = ON;
                  break;
                case 1:
                  Charger.memory.EVSE_Config.op_bits.clear = ON;
                  break;
                case 2:
                  Charger.memory.whiteList.op_bits.clear = ON;
                  break;
                case 3:
#ifdef FUNC_METER_IC_HISTORY
                  Charger.memory.hisMeterIC.op_bits.clear = ON;
#else
                  Charger.memory.hisCharging.op_bits.clear = ON;
#endif
                  break;
                case 4:
                  Charger.memory.hisAlarm.op_bits.clear = ON;
                  break;
                case 5:
                  Charger.memory.coldLoadPickUp.op_bits.clear = ON;
                  break;
                default:
                  break;
            }

            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_ERASE_MEMORY;
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = 0x01;
            tx[7] = 0x01;

          break;

        case PROTOCOL_MESSAGE_CONFIG_AUX_POWER_SW:
            switch(CurRxBuf[6])
            {
                case 0:
                  HAL_GPIO_WritePin(OUT_Meter_Power_GPIO_Port, OUT_Meter_Power_Pin, (CurRxBuf[7]?GPIO_PIN_SET:GPIO_PIN_RESET));
                  break;
                case 1:
                  HAL_GPIO_WritePin(OUT_Meter_Power_GPIO_Port, OUT_Meter_Power_Pin, (CurRxBuf[7]?GPIO_PIN_SET:GPIO_PIN_RESET));
                  break;
                default:
                  break;
            }

            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_AUX_POWER_SW;
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = 0x01;
            tx[7] = 0x01;

            break;

#ifdef FUNC_METER_IC_ADE7858A
        case PROTOCOL_MESSAGE_CONFIG_METER_IC_CALI_PARAMETER:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_METER_IC_CALI_PARAMETER;
            tx[4] = 0x01;
            tx[5] = 0x00;

            {
                MeterIC_CaliValType type = (MeterIC_CaliValType)CurRxBuf[6];
                uint32_t nSetVal = HTK_U32(CurRxBuf[7]);

                if (type == MICC_RESET_POWER_CONSUMPTION_CUMULATIVE) //0xA0: Reset power consumption cumulative
                {
                    if (nSetVal == AUTHCODE_RESET_POWER_CONSUMPTION_CUMULATIVE)
                    {
                        tx[6] = 0x01; //Set OK
                        XP("#RESET_POWER_CONSUMPTION_CUMULATIVE\r\n");
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total = 0;
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 = 0;
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 = 0;
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3 = 0;
                        Charger.memory.EVSE_Config.data.item.AcPlugInTimes = 0; //Clear PlugIn counter
                        Charger.memory.EVSE_Config.op_bits.update = ON;
                    }
                    else
                    {
                        tx[6] = 0x00; //Set NG
                    }
                }
                //0xC0/0xC1: Reset all MeterIC calibration values to (0x00/0xFF)
                else if (type == MICC_RESET_METER_IC_ALL_CALI_VAL_00 || type == MICC_RESET_METER_IC_ALL_CALI_VAL_FF)
                {
                    if (nSetVal == AUTHCODE_RESET_METER_IC_ALL_CALI_VAL)
                    {
                        tx[6] = 0x01; //Set OK
                        XP("#RESET_RESET_ALL_CALI_VAL: 0x%02X\r\n", type);
                        memset
                            (&Charger.memory.EVSE_Config.data.item.m_MeterIC_CaliVals,
                             type == MICC_RESET_METER_IC_ALL_CALI_VAL_00 ? 0x00 : 0xFF,
                             sizeof(MeterIC_CaliVals));

#ifdef FUNC_METER_IC_CALI_FLAG
                        Charger.memory.EVSE_Config.data.item.m_MeterIC_CaliFlag.m_Data = 0;
#endif

                        Charger.memory.EVSE_Config.op_bits.update = ON;
                        Charger.m_MeterIC_TrigWriteCaliVals.m_Data = HTK_U32_MAX;
                    }
                    else
                    {
                        tx[6] = 0x00; //Set NG
                    }
                }

#ifdef FUNC_GUN_LOCK
                else if (type == MICC_SET_GUN_LOCK_STATUS && Charger.m_bUseGunLock)
                {
                    XP("#SetGunLock: %d\r\n", nSetVal);
                    if (nSetVal == 0)
                    {
                        GL_Trig(GL_MODE_UNLOCK);
                    }
                    else if (nSetVal == 1)
                    {
                        GL_Trig(GL_MODE_LOCK);
                    }
                }
#endif //FUNC_GUN_LOCK

#ifdef FUNC_VOLATILE_OPERATION
                else if (type == MICC_SET_VO_CODE)
                {
                    Charger.m_VOCode.m_Value = nSetVal;
                    XP("#SET VO_Code = 0x%08X\r\n", Charger.m_VOCode.m_Value);
#ifdef VO_SIMU_CP
                    XP("#VO: EnableSimuCP(%d)\r\n", Charger.m_VOCode.m_EnableSimuCP);
                    if (Charger.m_VOCode.m_EnableSimuCP)
                    {
                        Charger.m_SimuData.m_CP.m_VoltPos = (uint16_t)(CpDetectionResult.PositiveValue == 0 ? 0 : HTK_GetPosFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.PositiveValue)) * 1000); //V => mV
                        Charger.m_SimuData.m_CP.m_VoltNeg = (uint16_t)(CpDetectionResult.NegativeValue == 0 ? 0 : HTK_GetNegFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.NegativeValue)) * 1000); //V => mV
                    }
#endif //VO_SIMU_CP

#ifdef VO_SIMU_PP
                    XP("#VO: EnableSimuPP(%d)\r\n", Charger.m_VOCode.m_EnableSimuPP);
                    if (Charger.m_VOCode.m_EnableSimuPP)
                    {
                        if (!Charger.m_bDetectPP)
                        {
                            Charger.m_VOCode.m_EnableSimuPP = 0;
                            XP("#VO: EnableSimuPP(%d) [Detect PP Function OFF]\r\n", Charger.m_VOCode.m_EnableSimuPP);
                        }
                    }
#endif

#ifdef VO_DISABLE_RELAY_WELDING
                    XP("#VO: DisableRelayWelding(%d)\r\n", Charger.m_VOCode.m_DisableRelayWelding);
#endif

#ifdef VO_BLOCK_CSU_LED_ACTION_CMD
                    XP("#VO: EnableBlockCsuLedCmd(%d)\r\n", Charger.m_VOCode.m_EnableBlockCsuLedCmd);
#endif

#ifdef VO_SIMU_ACV
                    XP("#VO: EnableSimuACV(%d)\r\n", Charger.m_VOCode.m_EnableSimuACV);
                    if (Charger.m_VOCode.m_EnableSimuACV)
                    {
                        Charger.m_SimuData.m_AcvVolt = Charger.Voltage[0];
                    }
#endif

#ifdef VO_SIMU_NTC
                    XP("#VO: EnableSimuNTC(%d)\r\n", Charger.m_VOCode.m_EnableSimuNTC);
                    if (Charger.m_VOCode.m_EnableSimuNTC)
                    {
                        Charger.m_SimuData.m_NtcTemp = Charger.temperature.SystemAmbientTemp;
                    }
#endif

#ifdef VO_SIMU_ALARMCODE
                    XP("#VO: EnableSimuAlarmCode(%d)\r\n", Charger.m_VOCode.m_EnableSimuAlarmCode);
                    if (Charger.m_VOCode.m_EnableSimuAlarmCode)
                    {
                        Charger.m_SimuData.m_AlarmCode = Charger.Alarm_Code;
                    }
#endif

#ifdef VO_SIMU_ACA
                    XP("#VO: EnableSimuACA(%d)\r\n", Charger.m_VOCode.m_EnableSimuACA);
                    if (Charger.m_VOCode.m_EnableSimuACA)
                    {
                        Charger.m_SimuData.m_AcaCurr = Charger.Current[0];
                    }
#endif

#ifdef VO_DISABLE_DETECT_TILT_SENSOR
                    if (Charger.m_bModelNameAX80_1P)
                    {
                        XP("#VO: DisableDetectTiltSensor(%d)\r\n", Charger.m_VOCode.m_DisableDetectTiltSensor);
                    }
#endif
                }

#ifdef VO_SIMU_CP
                else if (type == MICC_SET_SIMU_CP_VOLT)
                {
                    if (Charger.m_VOCode.m_EnableSimuCP)
                    {
                        Charger.m_SimuData.m_CP.m_Value = nSetVal;
                        XP("#SET VO_SimuCP_Volt = (+%0.3f, -%0.3f)\r\n", Charger.m_SimuData.m_CP.m_VoltPos * 0.001, Charger.m_SimuData.m_CP.m_VoltNeg * 0.001);
                    }
                }
#endif //VO_SIMU_CP

#ifdef VO_SIMU_PP
                else if (type == MICC_SET_SIMU_PP_CURR)
                {
                    if (Charger.m_VOCode.m_EnableSimuPP)
                    {
                        if (Charger.m_bDetectPP)
                        {
                            Charger.m_SimuData.m_PPCurr = nSetVal;
                            XP("#SET VO_SimuPP_Curr = (%d)\r\n", Charger.m_SimuData.m_PPCurr);
                        }
                        else
                        {
                            XP("#SET VO_SimuPP_Curr = (%d) [Detect PP Function OFF]\r\n", Charger.m_SimuData.m_PPCurr);
                        }
                    }
                }
#endif //VO_SIMU_PP

#ifdef VO_SIMU_ACV
                else if (type == MICC_SET_SIMU_ACV_VOLT)
                {
                    if (Charger.m_VOCode.m_EnableSimuACV)
                    {
                        Charger.m_SimuData.m_AcvVolt = (uint16_t)nSetVal;
                        XP("#SET VO_SimuACV_Volt = (%d)\r\n", Charger.m_SimuData.m_AcvVolt);
                    }
                }
#endif

#ifdef VO_SIMU_NTC
                else if (type == MICC_SET_SIMU_NTC_TEMP)
                {
                    if (Charger.m_VOCode.m_EnableSimuNTC)
                    {
                        Charger.m_SimuData.m_NtcTemp = (uint8_t)nSetVal;
                        XP("#SET VO_SimuNTC_Temp = (%d)\r\n", Charger.m_SimuData.m_NtcTemp);
                    }
                }
#endif

#ifdef VO_SIMU_ALARMCODE
                else if (type == MICC_SET_SIMU_ALARMCIDE_VAL)
                {
                    if (Charger.m_VOCode.m_EnableSimuAlarmCode)
                    {
                        Charger.m_SimuData.m_AlarmCode = nSetVal;
                        XP("#SET VO_SimuAlarmCode_Val = (0x%08X)\r\n", Charger.m_SimuData.m_AlarmCode);
                    }
                }
#endif

#ifdef VO_SIMU_ACA
                else if (type == MICC_SET_SIMU_ACA_CURR)
                {
                    if (Charger.m_VOCode.m_EnableSimuACA)
                    {
                        Charger.m_SimuData.m_AcaCurr = (uint16_t)nSetVal;
                        XP("#SET VO_SimuACA_Curr = (%d)\r\n", Charger.m_SimuData.m_AcaCurr);
                    }
                }
#endif

#endif //FUNC_VOLATILE_OPERATION
                else
                {

                    uint32_t nSetVal = HTK_U32(CurRxBuf[7]);
                    uint8_t Offset = 0xFF;
                    int32_t *p = MeterIC_GetCaliValPtr(type, &Offset);
                    if (p != NULL && Offset != 0xFF)
                    {
                        tx[6] = 0x01; //Set OK
                        *p = nSetVal;

#ifdef FUNC_METER_IC_CALI_FLAG
                        Charger.memory.EVSE_Config.data.item.m_MeterIC_CaliFlag.m_Data |= (((uint32_t)0x01) << Offset);
#endif
                        Charger.memory.EVSE_Config.op_bits.update = ON;
                        Charger.m_MeterIC_TrigWriteCaliVals.m_Data |= (((uint32_t)0x01) << Offset);

#ifdef FUNC_METER_IC_HISTORY
                        recordMeterICHis(type, *p);
#endif
                    }
                    else
                    {
                        tx[6] = 0x00; //Set NG
                    }
                    XP(" \r\nPROTOCOL_MESSAGE_CONFIG_METER_IC_CALI_PARAMETER(0x%02X, 0x%04X)\r\n\r\n", type, nSetVal);
                }
            }
            UpdateCheckSum(tx, tx_len);
            break;
#endif //FUNC_METER_IC_ADE7858A

#ifdef FUNC_PTB_METER_WM3M4C
        case PROTOCOL_MESSAGE_CONFIG_PTB_METER_WM3M4C:
            {

                tx[0] = 0xaa;
                tx[1] = PROTOCOL_ADDR;
                tx[2] = CurRxBuf[1];
                tx[3] = PROTOCOL_MESSAGE_CONFIG_PTB_METER_WM3M4C;

                PWM3M4C p = Charger.m_pWM3M4C;
                byte SubCmd = CurRxBuf[6];
                tx_len = 6 + (1) + 1;

                char* s = "#CSU_WM3M4C_Set: ";
#ifdef FUNC_CSU_CMD_DEBUG
                XP("%s0x%02X%s\r\n", s, SubCmd, (Charger.m_bUseExtMeter_WM3M4C && p ? "" : " (NOT SUPPORTED)"));
#endif
                if (Charger.m_bUseExtMeter_WM3M4C && p)
                {
                    if (SubCmd == WM3M4C_SCMD_CHG_BEGIN) //AA 00 FF 97 01 00 01 01
                    {
#ifdef FUNC_CSU_CMD_DEBUG
                        XP("%sCHARGE BEGIN\r\n", s);
#endif
                        tx[6] = 1; //OK
                        p->m_bTrigBegCharge = HTK_TRUE;
                    }
                    else if (SubCmd == WM3M4C_SCMD_CHG_END) //AA 00 FF 97 01 00 02 02
                    {
#ifdef FUNC_CSU_CMD_DEBUG
                        XP("%sCHARGE END\r\n", s);
#endif
                        tx[6] = 1; //OK
                        p->m_bTrigEndCharge = HTK_TRUE;
                    }
                    else
                    {
                        tx[6] = 0; //NG
                    }

                }
                else
                {
                    tx[6] = 0; //NG
                }

                UpdateCheckSum(tx, tx_len);
            }
            break;
#endif //FUNC_PTB_METER_WM3M4C

#ifdef FUNC_CSU_SIGN_IN_VERIFY
        case PROTOCOL_MESSAGE_CONFIG_CSU_SIGN_IN_VERIFY:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_CSU_SIGN_IN_VERIFY;
            tx[4] = 0x01;
            tx[5] = 0x00;

            //XP("\r\n[PROTOCOL_MESSAGE_CONFIG_CSU_SIGN_IN_VERIFY]\r\n\r\n");

#ifdef FUNC_ENABLE_CSU_SIGN_IN_WHEN_MCU_HAVE_NG_MODELNAME
            if (!Charger.m_bCsuSignInMustVerify)
            {
                Charger.m_bCsuSignInMustVerify = HTK_TRUE;
            }
#endif
            if (Charger.m_bCsuSignInMustVerify)
            {
#ifdef FUNC_VERIFY_TASK
                if (!Charger.m_bCsuSignInVerifyOK && !Charger.m_bRunCsuSignInVerify)
                {
                    Charger.m_VerifyTaskRxBufDataLen = *pCurRxBuf_RxLen;
                    memset(Charger.m_VerifyTaskRxBuf, 0, VERIFY_TASK_RXBUF_LEN);
                    memcpy(Charger.m_VerifyTaskRxBuf, CurRxBuf, HTK_GET_VAL_MIN(Charger.m_VerifyTaskRxBufDataLen, VERIFY_TASK_RXBUF_LEN));
                    Charger.m_bRunCsuSignInVerify = HTK_TRUE;
                }
#else
                //Charger.m_bCsuVerifyOK = AES256_Verify(&CurRxBuf[6], 4, (u8*)AES256_KEY, &CurRxBuf[10], &CurRxBuf[26]);
#endif
                if (Charger.m_bCsuSignInVerifyOK)
                {
                    DEBUG_INFO("#CSU SignIn OK!\n\r");
                    tx[6] = 0x01;
                    tx[7] = 0x01;
                }
                else
                {
                    DEBUG_INFO("#CSU SignIn [NG]!\n\r");
                    tx[6] = 0x00;
                    tx[7] = 0x00;
                }

            }
            else
            {
                DEBUG_INFO("#NO need to SignIn!\n\r");
                tx[6] = 0x00;
                tx[7] = 0x00;
            }
            break;
#endif //FUNC_CSU_SIGN_IN_VERIFY

#ifdef FUNC_AW48_NET_LED
            case PROTOCOL_MESSAGE_CONFIG_LED_ACTION_CONNECTIVITY_STATUS:
                if (HTK_IS_BETWEEN_MINMAX(CurRxBuf[6], NET_LED_ACTION_MIN, NET_LED_ACTION_MAX)
                    && (CurRxBuf[6] != Charger.am3352.NetLedActionState))
                {
                    Charger.am3352.NetLedActionState = CurRxBuf[6];

#ifdef FUNC_SHOW_CSU_CONFIG_LED_ACTION_INFO
                    XP("#CSU_SetNetLed(%d)\r\n", Charger.am3352.NetLedActionState);
#endif
                    setNetLedMotion(Charger.am3352.NetLedActionState);
                }
                tx_len = 8;
                tx[0] = 0xaa;
                tx[1] = PROTOCOL_ADDR;
                tx[2] =  CurRxBuf[1];
                tx[3] = PROTOCOL_MESSAGE_CONFIG_LED_ACTION_CONNECTIVITY_STATUS;
                tx[4] = 0x01;
                tx[5] = 0x00;
                tx[6] = 0x01;
                tx[7] = 0x01;
            break;
#endif //FUNC_AW48_NET_LED

#ifdef FUNC_CSU_PUBLIC_KEY_OPERATION
        case PROTOCOL_MESSAGE_CONFIG_EVSE_PUBLIC_KEY:
            {
                enum
                {
                    DATA_LEN = 64,
                    SALT_LEN = 64,
                    MIXTURE_LEN = DATA_LEN + SALT_LEN,
                    SALTMAP_LEN = GET_BOX_NUM(MIXTURE_LEN, 8),
                    ALL_LEN = MIXTURE_LEN + SALTMAP_LEN,
                };

                tx_len = 8;
                tx[0] = 0xaa;
                tx[1] = PROTOCOL_ADDR;
                tx[2] =  CurRxBuf[1];
                tx[3] = PROTOCOL_MESSAGE_CONFIG_EVSE_PUBLIC_KEY;
                tx[4] = 0x01;
                tx[5] = 0x00;

                //XP("\r\n[PROTOCOL_MESSAGE_CONFIG_EVSE_PUBLIC_KEY]\r\n\r\n");

#ifdef FUNC_ENABLE_CSU_SIGN_IN_WHEN_MCU_HAVE_NG_MODELNAME
                if (!Charger.m_bCsuSignInMustVerify)
                {
                    Charger.m_bCsuSignInMustVerify = HTK_TRUE;
                }
#endif

                if (Charger.m_bCsuSignInMustVerify)
                {
                    enum { KEY_LEN = sizeof(Charger.memory.EVSE_Config.data.item.m_CsuPublicKey), };
                    u8* pKey = Charger.memory.EVSE_Config.data.item.m_CsuPublicKey;
                    u8 Temp[KEY_LEN] = { 0 };

                    memcpy(Temp, pKey, KEY_LEN);
                    if (DataEncryption(pKey, DATA_LEN, &CurRxBuf[6], ALL_LEN, 1) == PASS)
                    {
#ifdef FUNC_SECURITY_DEBUG_INFO
                        HTK_ByteArray2HexStr_XP("#CSU_SetPublicKey", pKey, 0, DATA_LEN);
#endif
                        if (memcmp(Temp, pKey, KEY_LEN) != 0)
                        {
                            Charger.memory.EVSE_Config.op_bits.update = ON;
                            XP("#CSU_SetPublicKey OK => MEM_ADDR_EVSE_CONFIG\r\n");

                            //Need to RE-SignIn
                            Charger.m_bCsuSignInVerifyOK = HTK_FALSE;
                            Charger.m_bCsuUpgradeFwVerifyOK = HTK_FALSE;

                        }
                        tx[6] = 0x01;
                        tx[7] = 0x01;
                    }
                    else
                    {
                        XP("#CSU_SetPublicKey: [NG]\r\n");
                        tx[6] = 0x00;
                        tx[7] = 0x00;
                    }
                }
                else
                {
                    XP("#CSU_SetPublicKey: [NG]\r\n");
                    tx[6] = 0x00;
                    tx[7] = 0x00;
                }

            }
            break;
#endif //FUNC_CSU_PUBLIC_KEY_OPERATION

#ifdef FUNC_RESET_CONNECTOR_PLUGIN_TIMES
        case PROTOCOL_MESSAGE_CONFIG_RESET_CONNECTOR_PLUGIN_TIMES:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_CONFIG_RESET_CONNECTOR_PLUGIN_TIMES;
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = 0x01;
            tx[7] = 0x01;
            if(CurRxBuf[6] == 0x01)
            {
                DEBUG_INFO("CSU reset connector plugin times.\r\n");
                Charger.memory.EVSE_Config.data.item.AcPlugInTimes = 0;
                Charger.memory.EVSE_Config.op_bits.update = ON;
            }
            else
            {
              tx[6] = 0x00;
              tx[7] = 0x00;
            }
            break;
#endif //FUNC_RESET_CONNECTOR_PLUGIN_TIMES

          /*
            Firmware update message
          */
          case PROTOCOL_MESSAGE_UPGRADE_START:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_UPGRADE_START;
            tx[4] = 0x01;
            tx[5] = 0x00;

            binCRCTarget = (CurRxBuf[6] << 24) | (CurRxBuf[6] << 16) | (CurRxBuf[6] << 8) | (CurRxBuf[6] << 0);
            flashdestination = NEW_CODE_ADDRESS;

#ifdef FUNC_CSU_UPGRADE_FW_VERIFY
            XP("\r\n[PROTOCOL_MESSAGE_UPGRADE_START]\r\n\r\n");
#ifdef FUNC_VERIFY_TASK
            if (Charger.m_bCsuUpgradeFwMustVerify)
            {
                if (Charger.m_bCsuUpgradeFwMustVerify && !Charger.m_bCsuUpgradeFwVerifyOK && !Charger.m_bRunCsuUpgradeFwVerify)
                {
                    Charger.m_VerifyTaskRxBufDataLen = *pCurRxBuf_RxLen;
                    memset(Charger.m_VerifyTaskRxBuf, 0, VERIFY_TASK_RXBUF_LEN);
                    memcpy(Charger.m_VerifyTaskRxBuf, CurRxBuf, HTK_GET_VAL_MIN(Charger.m_VerifyTaskRxBufDataLen, VERIFY_TASK_RXBUF_LEN));
                    Charger.m_bRunCsuUpgradeFwVerify = HTK_TRUE;
#ifdef FUNC_SECURITY_DEBUG_INFO
                    HTK_ByteArray2HexStr_XP("PROTOCOL_MESSAGE_UPGRADE_START", Charger.m_VerifyTaskRxBuf, 0, Charger.m_VerifyTaskRxBufDataLen);
#endif
                }
            }
#else //FUNC_VERIFY_TASK
//                taskENTER_CRITICAL();
//                bFwCheckOkUseAES256 = AES256_Verify(&CurRxBuf[6], 4, (u8*)AES256_KEY, &CurRxBuf[10], &CurRxBuf[26]);
//                taskEXIT_CRITICAL();
#endif //FUNC_VERIFY_TASK
#endif //FUNC_CSU_UPGRADE_FW_VERIFY

            if(FLASH_If_Erase(NEW_CODE_ADDRESS, 3)== FLASHIF_OK)
            {
              #if defined(DEBUG) || defined(RTOS_STAT)
              DEBUG_INFO("Firmware transfer start, earase flash success....\n\r");
              #endif
              tx[6] = 0x01;
              tx[7] = 0x01;

              if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
              {
                  setChargerMode(MODE_MAINTAIN);
                  timerEnable(TIMER_IDX_UPDATE, 10000);
              }
            }
            else
            {
              #if defined(DEBUG) || defined(RTOS_STAT)
              DEBUG_INFO("Firmware transfer start, earase flash fail....\n\r");
              #endif
              tx[6] = 0x00;
              tx[7] = 0x00;
            }

            break;

          case PROTOCOL_MESSAGE_UPGRADE_TRANS:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_UPGRADE_TRANS;
            tx[4] = 0x01;
            tx[5] = 0x00;

            flashdestination = NEW_CODE_ADDRESS + ((CurRxBuf[6]<<0) | (CurRxBuf[7]<<8) | (CurRxBuf[8]<<16) |(CurRxBuf[9]<<24));
            if (FLASH_If_Write(flashdestination, (uint32_t*) &CurRxBuf[10],  ((((CurRxBuf[4]) | (CurRxBuf[5])<<8)-4)>>2)) == FLASHIF_OK)
            {
              #if defined(DEBUG) || defined(RTOS_STAT)
              //DEBUG_INFO("Firmware transfer start address: 0x%x, length: %d...Pass\n\r", flashdestination, (((CurRxBuf[4]) | (CurRxBuf[5])<<8)-4));
              #endif
              tx[6] = 0x01;
              tx[7] = 0x01;

              if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
              {
                setLedMotion(LED_ACTION_MAINTAIN);
                timerRefresh(TIMER_IDX_UPDATE);
              }
            }
            else
            {
              #if defined(DEBUG) || defined(RTOS_STAT)
              DEBUG_INFO("Firmware transfer start address: 0x%x, length: %d...Fail\n\r", flashdestination, (((CurRxBuf[4]) | (CurRxBuf[5])<<8)-4));
              #endif
              tx[6] = 0x00;
              tx[7] = 0x00;
            }

            break;

          case PROTOCOL_MESSAGE_UPGRADE_STOP:
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_UPGRADE_STOP;
            tx[4] = 0x01;
            tx[5] = 0x00;

#ifdef FUNC_USE_STM32_SBSFU

//            {
//                //HAL_StatusTypeDef ret = HAL_ERROR;
//                //uint8_t  fw_header_dwl_slot[SE_FW_HEADER_TOT_LEN];
//                SFU_FwImageFlashTypeDef dw1;
//
//                /* Get Info about the download area */
//                SFU_APP_GetDownloadAreaInfo(SLOT_DWL_1, &dw1);
//                XP("MaxSizeInBytes     = %d (0x%08X)\r\n", dw1.MaxSizeInBytes, dw1.MaxSizeInBytes);
//                XP("DownloadAddr       = %d (0x%08X)\r\n", dw1.DownloadAddr, dw1.DownloadAddr);
//                XP("ImageOffsetInBytes = %d (0x%08X)\r\n", dw1.ImageOffsetInBytes, dw1.ImageOffsetInBytes);
//                XP("ExecutionAddr      = %d (0x%08X)\r\n", dw1.ExecutionAddr, dw1.ExecutionAddr);
//
//            }

            if ((Charger.m_bCsuUpgradeFwMustVerify && Charger.m_bCsuUpgradeFwVerifyOK) || (!Charger.m_bCsuUpgradeFwMustVerify))
            {
                DEBUG_INFO("Firmware transfer end %s\r\n", Charger.m_bCsuUpgradeFwMustVerify ? (Charger.m_bCsuUpgradeFwVerifyOK ? "(VERIFY: OK)" : "(VERIFY: [NG])" ) : "");
                tx[6] = 0x01;
                tx[7] = 0x01;
                if(isUSB_CDC_IAP)
                {
                    CDC_Transmit_FS((uint8_t *)tx, tx_len);
                }
                else
                {
#ifdef MODIFY_DC_RS485_UPGRADE_ISSUE
                    Prefix_UartTX(tx, CurRxBuf);
                    HAL_UART_Transmit(pUartHandle, (uint8_t *)tx, tx_len , 0x0ffff);
                    Postfix_UartTX(tx, CurRxBuf);
#else
                    HAL_UART_Transmit(&IAP_USART, (uint8_t *)tx, tx_len , 0x0ffff);
#endif
                }
                osDelay(1000);
                NVIC_SystemReset();
            }
            else
            {
                DEBUG_INFO("Firmware verify fail...\n\r");
                tx[6] = 0x00;
                tx[7] = 0x00;
            }
#else //FUNC_USE_STM32_SBSFU

            flash = NEW_CODE_ADDRESS;
            checksum = HAL_CRC_Calculate(&hcrc, (uint32_t *)flash, ((FLASH_AP_LENGTH-4)>>2));
            flash = ((uint32_t)(NEW_CODE_ADDRESS+FLASH_AP_LENGTH-4));

#ifdef FUNC_CSU_UPGRADE_FW_VERIFY
            #if defined(DEBUG) || defined(RTOS_STAT)
            if (Charger.m_bCsuUpgradeFwMustVerify)
                DEBUG_INFO("Firmware transfer end, AP CRC checksum, flash: 0x%x, 0x%x (VERIFY: %s)\r\n", checksum, *((uint32_t *)flash), (Charger.m_bCsuUpgradeFwVerifyOK ? "OK" : "[NG]" ));
            else
                DEBUG_INFO("Firmware transfer end, AP CRC checksum, flash: 0x%x, 0x%x\r\n", checksum, *((uint32_t *)flash) );
            #endif

            if(checksum == *((uint32_t *)flash) && ((Charger.m_bCsuUpgradeFwMustVerify && Charger.m_bCsuUpgradeFwVerifyOK) || (!Charger.m_bCsuUpgradeFwMustVerify)))
#else
            #if defined(DEBUG) || defined(RTOS_STAT)
            DEBUG_INFO("Firmware transfer end, AP CRC checksum, flash: 0x%x, 0x%x\r\n", checksum, *((uint32_t *)flash) );
            #endif
            if(checksum == *((uint32_t *)flash))
#endif //FUNC_CSU_UPGRADE_FW_VERIFY
            {
              if (FLASH_If_Write(UPGRADE_REQ_ADDRESS,  (uint32_t *)&endFlag[0], 1) == FLASHIF_OK)
              {
                #if defined(DEBUG) || defined(RTOS_STAT)
                DEBUG_INFO("Firmware Confirm Tag write ok..\n\r");
                #endif
                tx[6] = 0x01;
                tx[7] = 0x01;
                if(isUSB_CDC_IAP)
                {
                    CDC_Transmit_FS((uint8_t *)tx, tx_len);

                }
                else
                {
#ifdef MODIFY_DC_RS485_UPGRADE_ISSUE
                    Prefix_UartTX(tx, CurRxBuf);
                    HAL_UART_Transmit(pUartHandle, (uint8_t *)tx, tx_len , 0x0ffff);
                    Postfix_UartTX(tx, CurRxBuf);
#else
                    HAL_UART_Transmit(&IAP_USART, (uint8_t *)tx, tx_len , 0x0ffff);
#endif
                }
                osDelay(1000);
                NVIC_SystemReset();
              }
              else
              {
                #if defined(DEBUG) || defined(RTOS_STAT)
                DEBUG_INFO("Firmware Confirm Tag write fail...\n\r");
                #endif
                tx[6] = 0x00;
                tx[7] = 0x00;
              }
            }
            else
            {
              #if defined(DEBUG) || defined(RTOS_STAT)
              DEBUG_INFO("Firmware checksum compare fail...\n\r");
              #endif
              tx[6] = 0x00;
              tx[7] = 0x00;
            }
#endif //FUNC_USE_STM32_SBSFU
            if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
            {
              timerDisable(TIMER_IDX_UPDATE);
            }
            break;

          case PROTOCOL_MESSAGE_UPGRADE_ABOARD:
            #if defined(DEBUG) || defined(RTOS_STAT)
            DEBUG_INFO("Firmware update transfer aboard...\n\r");
            #endif

            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] =  CurRxBuf[1];
            tx[3] = PROTOCOL_MESSAGE_UPGRADE_ABOARD;
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = 0x01;
            tx[7] = 0x01;
            break;

          default:
            /* Todo: bin file receive aboard */
            #if defined(DEBUG) || defined(RTOS_STAT)

#ifdef FUNC_RS485_SLAVE
            DEBUG_INFO("Protocol message unknow (0x%02X)\n\r", CurRxBuf[3]);
#else
            DEBUG_INFO("Protocol message unknow...\n\r");
#endif

            #endif
            tx_len = 8;
            tx[0] = 0xaa;
            tx[1] = PROTOCOL_ADDR;
            tx[2] = CurRxBuf[1];
            tx[3] = CurRxBuf[3];
            tx[4] = 0x01;
            tx[5] = 0x00;
            tx[6] = 0x00;
            tx[7] = 0x00;

            break;
        }
      }
      else
      {
#ifndef FUNC_RS485_SLAVE
        #if defined(DEBUG) || defined(RTOS_STAT)
        DEBUG_INFO("Protocol check sum is wrong...\n\r");
        #endif
        tx_len = 8;
        tx[0] = 0xaa;
        tx[1] = PROTOCOL_ADDR;
        tx[2] = CurRxBuf[1];
        tx[3] = CurRxBuf[3];
        tx[4] = 0x01;
        tx[5] = 0x00;
        tx[6] = 0x00;
        tx[7] = 0x00;
#endif //FUNC_RS485_SLAVE
      }

      if(isUSB_CDC_IAP)
      {
        CDC_Transmit_FS((uint8_t *)tx, tx_len);
      }
      else
      {

#ifdef FUNC_RS485_SLAVE

#ifdef MODIFY_DC_RS485_UPGRADE_ISSUE

#ifdef FUNC_CSU_SIGN_IN_VERIFY
        if (CurRxBuf != NULL)
        {
            if (CurRxBuf == UART_IAP_rx_buffer &&
                (Charger.m_bCsuSignInMustVerify && !Charger.m_bCsuSignInVerifyOK))
            {
                //XP("X\r\n");
                //do not response
#ifdef FUNC_CSU_PUBLIC_KEY_OPERATION
                if (    CurRxBuf[3] == PROTOCOL_MESSAGE_CONFIG_CSU_SIGN_IN_VERIFY
                    ||  CurRxBuf[3] == PROTOCOL_MESSAGE_QUERY_EVSE_PUBLIC_KEY
                    ||  CurRxBuf[3] == PROTOCOL_MESSAGE_CONFIG_EVSE_PUBLIC_KEY
                    )
                {
                    Prefix_UartTX(tx, CurRxBuf);
                    HAL_UART_Transmit(pUartHandle, (uint8_t *)tx, tx_len , 0x0ffff);
                    Postfix_UartTX(tx, CurRxBuf);
                }
#endif
            }
            else
            {
                Prefix_UartTX(tx, CurRxBuf);
                HAL_UART_Transmit(pUartHandle, (uint8_t *)tx, tx_len , 0x0ffff);
                Postfix_UartTX(tx, CurRxBuf);
            }
        }
#else //FUNC_CSU_SIGN_IN_VERIFY


        if (CurRxBuf != NULL)
        {

            Prefix_UartTX(tx, CurRxBuf);
            HAL_UART_Transmit(pUartHandle, (uint8_t *)tx, tx_len , 0x0ffff);
            Postfix_UartTX(tx, CurRxBuf);
        }
#endif //FUNC_CSU_SIGN_IN_VERIFY

#else //MODIFY_DC_RS485_UPGRADE_ISSUE
        if (CurRxBuf != NULL)
        {
            tx[1] = Charger.m_RS485SlaveAddr; //Update Slave Address
            HAL_UART_Transmit(pUartHandle, (uint8_t *)tx, tx_len, 0xffff);
        }
#endif //MODIFY_DC_RS485_UPGRADE_ISSUE

#else //FUNC_RS485_SLAVE
        HAL_UART_Transmit(&IAP_USART, (uint8_t *)tx, tx_len, 0xffff);
#endif //FUNC_RS485_SLAVE

      }

#ifdef ENABLE_PRINT_IMCP_MSG

#ifdef FUNC_RS485_SLAVE
#ifdef PRINT_IMCP_MSG_ONLY_ON_UPDATEPORT
    if (CurRxBuf == UART_IAP_rx_buffer && CheckPrintImcpMsg(CurRxBuf[3]))
    {
        HTK_ByteArray2HexStr_XP(NULL, tx, 0, tx_len);
    }
#else
    if (CheckPrintImcpMsg(CurRxBuf[3]))
    {
        HTK_ByteArray2HexStr_XP(NULL, tx, 0, tx_len);
    }
#endif //PRINT_IMCP_MSG_ONLY_ON_UPDATEPORT
#else //FUNC_RS485_SLAVE
    if (CheckPrintImcpMsg(UART_IAP_rx_buffer[3]))
    {
        HTK_ByteArray2HexStr_XP(NULL, tx, 0, tx_len);
    }
#endif //FUNC_RS485_SLAVE

#endif //ENABLE_PRINT_IMCP_MSG

#ifdef FUNC_RS485_SLAVE
      // Clear rx_buffer and related varaible
      for(uint16_t i = 0; i < *pCurRxBuf_RxLen ; i++)
        CurRxBuf[i]=0;

      *pCurRxBuf_RxLen = 0;
      *pCurRecvEndFlag = 0;

      isUSB_CDC_IAP = OFF;
#else
      // Clear rx_buffer and related varaible
      for(uint16_t i = 0; i < UART_IAP_rx_len ; i++)
        UART_IAP_rx_buffer[i]=0;

      UART_IAP_rx_len=0;
      UART_IAP_recv_end_flag=0;
      isUSB_CDC_IAP = OFF;
#endif //FUNC_RS485_SLAVE
    }

    if(timer[TIMER_IDX_UPDATE].isAlarm == ON && Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
    {
      setChargerMode(MODE_IDLE);
      setLedMotion(LED_ACTION_IDLE);
      timerDisable(TIMER_IDX_UPDATE);
    }

#ifdef FUNC_RS485_SLAVE
    HAL_UART_Receive_DMA(&IAP_USART,(uint8_t*)UART_IAP_rx_buffer, UART_BUFFER_SIZE);
    HAL_UART_Receive_DMA(&RS485_USART,(uint8_t*)UART_RS485_rx_buffer, UART_BUFFER_SIZE);
#else
    HAL_UART_Receive_DMA(&IAP_USART,(uint8_t*)UART_IAP_rx_buffer, UART_BUFFER_SIZE);
#endif //FUNC_RS485_SLAVE

#ifdef FUNC_DEBUG_CONSOLE
    HAL_UART_Receive_DMA(&DEBUG_USART,(uint8_t*)UART_DEBUG_rx_buffer, UART_DEBUG_BUFFER_SIZE);
#endif

    osDelay(1);
  }
  /* USER CODE END StartUartTask */
}

#ifdef FUNC_DETECT_PP

/*--------------------------------------------------------------------------------------------
Vehicle         Rc              Range of resistance       ADC read        ADC
connectors      (ohm)           Rc for interpretation     [h](V)          (count)
current                         by the EV supply
  (A)                           equipment (ohm)
----------------------------------------------------------------------------------------------
 N/A            Error condition       >4500               >2.6            >3227
                or disconnection
                of plug
----------------------------------------------------------------------------------------------
13              1500                  1100-2460           2.32~2.52       2879~3127
20              680                   400-936             1.86~2.26       2308~2805
32              220                   80-308              0.83~1.70       1031~2110
--------------------------------------------------------------------------------------------*/

void UpdatePPInfo_AdcVal(PPPInfo p, uint32_t v) //ADC value (count)
{
    if (v > 3227)                       { p->m_CurCurr = 13; p->m_StatusID = 0x01; } //use MIN Current
    else if (v >= 2879 && v <= 3127)    { p->m_CurCurr = 13; p->m_StatusID = 0x01; } //MIN Current
    else if (v >= 2308 && v <= 2805)    { p->m_CurCurr = 20; p->m_StatusID = 0x02; }
    else if (v >= 1031 && v <= 2110)    { p->m_CurCurr = 32; p->m_StatusID = 0x03; }
    else                                { p->m_CurCurr = 13; p->m_StatusID = 0x01; } //use MIN Current
}

#ifdef VO_SIMU_PP
void UpdatePPInfo_CurrVal(PPPInfo p, uint16_t v) //Current value (A)
{
    if (v == 13)        { p->m_CurCurr = 13; p->m_StatusID = 0x01; }
    else if (v == 20)   { p->m_CurCurr = 20; p->m_StatusID = 0x02; }
    else if (v == 32)   { p->m_CurCurr = 32; p->m_StatusID = 0x03; }
    else if (v == 63)   { p->m_CurCurr = 63; p->m_StatusID = 0x04; }
    else                { p->m_CurCurr = 13; p->m_StatusID = 0x01; }
}
#endif //VO_SIMU_PP

#endif //FUNC_DETECT_PP

/* USER CODE BEGIN Header_StartAdcTask */
/**
* @brief Function implementing the adcTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartAdcTask */

#ifdef FUNC_DEBUG_MSG_CP_STATE
const char *CP_STATE_TAG[7] = {"0:UNKNOW", "1:A(12V)", "2:B(9V)", "3:C(6V)", "4:D(3V)", "5:E(0V)", "6:F(-12V)"};
#endif


void StartAdcTask(void const * argument)
{
  /* USER CODE BEGIN StartAdcTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    IdleUntilReadAllMemory();
#endif

  //aadc

  uint8_t previous_cp_state = SYSTEM_STATE_A;

#ifndef FUNC_POWER_CONSUMPTION_BY_METER_IC
  uint8_t updateMemReq = 0;

  struct TimeTick
  {
    uint32_t timeTick_Start;
    uint32_t timeTick_End;
    uint32_t timeTick_Delta;
  }timeTick;

  timeTick.timeTick_Start = HAL_GetTick();
#endif

#ifdef FUNC_CP_ADC_MODIFY

#ifdef NEW_CP_SPEC
    while (!Charger.m_bCpDetectModuleInitOK)
    {
        osDelay(10);
    }
#else //NEW_CP_SPEC
    CpDetectModuleInitialize();
#endif //NEW_CP_SPEC

#else //FUNC_CP_ADC_MODIFY
    CpDetectModuleInitialize( &CpBoundary, &SpecDefBoundary, &CpHysteresis);
#endif //FUNC_CP_ADC_MODIFY

#ifndef FUNC_POWER_CONSUMPTION_BY_METER_IC
  timerEnable(TIMER_IDX_POWER, 1000);
#endif

#ifdef FUNC_GUN_LOCK
    GL_Init(); //All Model
#endif

  /* Infinite loop */
  for(;;)
  {
    Relay_Control_Function() ;
#ifdef FUNC_OUTP_TYPE_E
    if (Charger.m_bEnableTypeE)
    {
        SE_Relay_Control_Function();
    }
#endif

    // ADC chanel 1
    if(isDMAEnd_ADC1)
    {
#ifdef FUNC_TASK_MONITOR
        Charger.m_TaskMonitor.m_ADC.m_ADC1_Counter[0]++;
#endif
        isDMAEnd_ADC1 = OFF;
#ifdef VO_SIMU_CP
        CpCalculate(ADC1_Buffer, ADC1_CHANEL_COUNT*ADC1_SAMPLE_COUNT, &CpDetectionResult, Charger.m_VOCode.m_EnableSimuCP, &Charger.m_SimuData.m_CP);
#else
        CpCalculate(ADC1_Buffer, ADC1_CHANEL_COUNT*ADC1_SAMPLE_COUNT, &CpDetectionResult);
#endif
        Charger.CP_State = CpDetectionResult.State;


//        if (Charger.Mode!= MODE_DEBUG)
        {
#ifdef MODIFY_ADCTASK_CP_STATE_CHANGE
          if((previous_cp_state != Charger.CP_State))
#else
          if((previous_cp_state != Charger.CP_State) && (Charger.CP_State !=SYSTEM_STATE_UNKNOWN ))
#endif
          {
#ifdef FUNC_DEBUG_MSG_CP_STATE
            XP("#CP: [%s] >>> [%s] (+%.3f, -%.3f)\r\n",
                CP_STATE_TAG[previous_cp_state],
                CP_STATE_TAG[Charger.CP_State],
                (CpDetectionResult.PositiveValue == 0 ? 0 : HTK_GetPosFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.PositiveValue))),
                (CpDetectionResult.NegativeValue == 0 ? 0 : HTK_GetNegFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.NegativeValue)))
               );
#endif
              previous_cp_state = Charger.CP_State;

              if(Charger.CP_State == SYSTEM_STATE_A)
              {
                  user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL); // CP PWM duty set 100%
                  Charger.Relay_Action=GPIO_RELAY_ACTION_OFF;
#ifdef REDUCE_RELAY_CUT_OFF_TIME_WHEN_CP_C_TO_A
                    Relay_Control_Function();
#endif

                  if (Charger.Mode!= MODE_DEBUG)
                  {
                    Charger.memory.EVSE_Config.data.item.AcPlugInTimes++;
                    Charger.memory.EVSE_Config.op_bits.update = ON;
                    DEBUG_INFO("EVSE connector plug counts: %d\r\n", Charger.memory.EVSE_Config.data.item.AcPlugInTimes);
                  }
              }
          }
        }

        if(HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&ADC1_Buffer, ADC1_CHANEL_COUNT*ADC1_SAMPLE_COUNT)!=HAL_OK)Error_Handler();
    }

    // ADC chanel 2
    if(isDMAEnd_ADC2)
    {
#ifdef FUNC_TASK_MONITOR
        Charger.m_TaskMonitor.m_ADC.m_ADC2_Counter[0]++;
#endif
        isDMAEnd_ADC2 = OFF;
        for(uint16_t idx=0;idx<ADC2_SAMPLE_COUNT;idx++)
        {
            ADC2_Buffer_Each[0][idx] = ADC2_Buffer[(idx*ADC2_CHANEL_COUNT) + 0];
            ADC2_Buffer_Each[1][idx] = ADC2_Buffer[(idx*ADC2_CHANEL_COUNT) + 1];
        }

        if (WatchDogLeakRawDataCheck_Event())  //clear leak WatchDogcount
        {
          Charger.counter.WatchDogLeak = 0 ;
        }

#ifdef MODIFY_ADC_WELDING_CALCULATE_METHOD

        filter_move_avg(&adc_value.ADC2_IN5_Welding, avg_v_cal(ADC2_Buffer_Each[0], ADC2_SAMPLE_COUNT));  //unit: 0.01V
#else

        //RlyVmax_cal
        if (Charger.GroundingSystem == GROUNGING_SYSTEM_LL)
        {
           filter_move_avg(&adc_value.ADC2_IN5_Welding, avg_v_cal(ADC2_Buffer_Each[0], ADC2_SAMPLE_COUNT));  //unit: 0.01V
        }
        else
        {
          filter_move_avg(&adc_value.ADC2_IN5_Welding, RlyVmax_cal(ADC2_Buffer_Each[0], ADC2_SAMPLE_COUNT)); //unit: 0.01V
        }
#endif //MODIFY_ADC_WELDING_CALCULATE_METHOD


        //Leak
        filter_move_avg(&adc_value.ADC2_IN6_GF, GFRms_cal(ADC2_Buffer_Each[1], ADC2_SAMPLE_COUNT));
        if ((((adc_value.ADC2_IN6_GF.value)*Charger.coefficient.gain_leak[0])+Charger.coefficient.offset_leak[0]) <=0)
        {
          Charger.Leak_Current = adc_value.ADC2_IN6_GF.value;
        }
        else
        {
            Charger.Leak_Current = (uint16_t) (((adc_value.ADC2_IN6_GF.value)*Charger.coefficient.gain_leak[0])+Charger.coefficient.offset_leak[0]) ;
        }

        if(HAL_ADC_Start_DMA(&hadc2, (uint32_t*)&ADC2_Buffer, ADC2_CHANEL_COUNT*ADC2_SAMPLE_COUNT)!=HAL_OK)Error_Handler();
    }

    // ADC chanel 3
    if(isDMAEnd_ADC3)
    {
#ifdef FUNC_TASK_MONITOR
        Charger.m_TaskMonitor.m_ADC.m_ADC3_Counter[0]++;
#endif
        isDMAEnd_ADC3 = OFF;
        for(uint16_t idx=0;idx<ADC3_SAMPLE_COUNT;idx++)
        {
#ifdef FUNC_REPLACE_ADC_WITH_METER_IC

#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
            if (Charger.m_bModelNameAX80_1P)
            {
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                if (Charger.m_bModelNameAX80_NACS_1P)
                {
                    ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0];  //ADC3_IN9_Voltage_L1 (PF3) => MeterIC | [AX80_NACS => T1]
                    ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1];    //ADC3_IN14_1998 (PF4)
                    ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2];    //ADC3_IN15_Temp (PF5)
                    ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3];    //ADC3_IN4_GMI_VL1 (PF6)
                    ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4];  //ADC3_IN7_Current_L1 (PF9) => MeterIC | [AX80_NACS => T4]
                    ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5];  //ADC3_IN5_Current_L2 (PF7) => MeterIC | [AX80_NACS => T5]
                    ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6];    //ADC3_IN6_PP_GUN_DET (PF8)
                    ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7];  //ADC3_IN8_Voltage_L2 (PF10) => MeterIC | [AX80_NACS => T2]
                    ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8];  //ADC3_IN10_Voltage_L3 (PC0) => MeterIC | [AX80_NACS => T3]
                    ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9];  //ADC3_IN11_Current_L3 (PC1) => MeterIC | [AX80_NACS => T6]
                }
                else
                {
                    ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0];  //ADC3_IN9_Voltage_L1 (PF3) => MeterIC | [AX80 => RELAY1_Temp]
                    ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1];    //ADC3_IN14_1998 (PF4)
                    ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2];    //ADC3_IN15_Temp (PF5)
                    ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3];    //ADC3_IN4_GMI_VL1 (PF6)
                    ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4];  //ADC3_IN7_Current_L1 (PF9) => MeterIC | [AX80 => Input_N_L2_Temp]
                    //ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5];  //ADC3_IN5_Current_L2 (PF7) => MeterIC
                    ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6];    //ADC3_IN6_PP_GUN_DET (PF8)
                    ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7];  //ADC3_IN8_Voltage_L2 (PF10) => MeterIC | [AX80 => RELAY2_Temp]
                    ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8];  //ADC3_IN10_Voltage_L3 (PC0) => MeterIC | [AX80 => Input_L1_Temp]
                    //ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9];  //ADC3_IN11_Current_L3 (PC1) => MeterIC
                }
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0];  //ADC3_IN9_Voltage_L1 (PF3) => MeterIC | [AX80 => RELAY1_Temp]
                ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1];    //ADC3_IN14_1998 (PF4)
                ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2];    //ADC3_IN15_Temp (PF5)
                ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3];    //ADC3_IN4_GMI_VL1 (PF6)
                ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4];  //ADC3_IN7_Current_L1 (PF9) => MeterIC | [AX80 => Input_N_L2_Temp]
                //ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5];  //ADC3_IN5_Current_L2 (PF7) => MeterIC
                ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6];    //ADC3_IN6_PP_GUN_DET (PF8)
                ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7];  //ADC3_IN8_Voltage_L2 (PF10) => MeterIC | [AX80 => RELAY2_Temp]
                ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8];  //ADC3_IN10_Voltage_L3 (PC0) => MeterIC | [AX80 => Input_L1_Temp]
                //ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9];  //ADC3_IN11_Current_L3 (PC1) => MeterIC
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
            }
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
            else if (Charger.m_bModelNameAW48_1P)
            {
                ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0];  //ADC3_IN9_Voltage_L1 (PF3) => MeterIC | [AW48 => T1]
                ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1];    //ADC3_IN14_1998 (PF4)
                ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2];    //ADC3_IN15_Temp (PF5)
                ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3];    //ADC3_IN4_GMI_VL1 (PF6)
                ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4];  //ADC3_IN7_Current_L1 (PF9) => MeterIC | [AW48 => T4]
                ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5];  //ADC3_IN5_Current_L2 (PF7) => MeterIC | [AW48 => T5]
                ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6];    //ADC3_IN6_PP_GUN_DET (PF8)
                ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7];  //ADC3_IN8_Voltage_L2 (PF10) => MeterIC | [AW48 => T2]
                ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8];  //ADC3_IN10_Voltage_L3 (PC0) => MeterIC | [AW48 => T3]
                ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9];  //ADC3_IN11_Current_L3 (PC1) => MeterIC | [AW48 => T6]
            }
#endif //FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
            else if (Charger.m_bModelNameAX48_NACS_1P)
            {
                ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0];  //ADC3_IN9_Voltage_L1 (PF3) => MeterIC | [AX48_NACS => T1]
                ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1];    //ADC3_IN14_1998 (PF4)
                ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2];    //ADC3_IN15_Temp (PF5)
                ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3];    //ADC3_IN4_GMI_VL1 (PF6)
                ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4];  //ADC3_IN7_Current_L1 (PF9) => MeterIC | [AX48_NACS => T4]
                ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5];  //ADC3_IN5_Current_L2 (PF7) => MeterIC | [AX48_NACS => T5]
                ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6];    //ADC3_IN6_PP_GUN_DET (PF8)
                ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7];  //ADC3_IN8_Voltage_L2 (PF10) => MeterIC | [AX48_NACS => T2]
                ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8];  //ADC3_IN10_Voltage_L3 (PC0) => MeterIC | [AX48_NACS => T3]
                ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9];  //ADC3_IN11_Current_L3 (PC1) => MeterIC | [AX48_NACS => T6]
            }
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
            else //AX48 / AX32
            {
                //ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0];  //ADC3_IN9_Voltage_L1 (PF3) => MeterIC
                ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1];    //ADC3_IN14_1998 (PF4)
                ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2];    //ADC3_IN15_Temp (PF5)
                ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3];    //ADC3_IN4_GMI_VL1 (PF6)
                //ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4];  //ADC3_IN7_Current_L1 (PF9) => MeterIC
                //ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5];  //ADC3_IN5_Current_L2 (PF7) => MeterIC
                ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6];    //ADC3_IN6_PP_GUN_DET (PF8)
                //ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7];  //ADC3_IN8_Voltage_L2 (PF10) => MeterIC
                //ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8];  //ADC3_IN10_Voltage_L3 (PC0) => MeterIC
                //ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9];  //ADC3_IN11_Current_L3 (PC1) => MeterIC
            }
#else //FUNC_AX80_ADD_4_TEMP_SENEOR

            //ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0];  //ADC3_IN9_Voltage_L1 (PF3) => MeterIC
            ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1];    //ADC3_IN14_1998 (PF4)
            ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2];    //ADC3_IN15_Temp (PF5)
            ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3];    //ADC3_IN4_GMI_VL1 (PF6)
            //ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4];  //ADC3_IN7_Current_L1 (PF9) => MeterIC
            //ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5];  //ADC3_IN5_Current_L2 (PF7) => MeterIC
            ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6];    //ADC3_IN6_PP_GUN_DET (PF8)
            //ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7];  //ADC3_IN8_Voltage_L2 (PF10) => MeterIC
            //ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8];  //ADC3_IN10_Voltage_L3 (PC0) => MeterIC
            //ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9];  //ADC3_IN11_Current_L3 (PC1) => MeterIC

#endif //FUNC_AX80_ADD_4_TEMP_SENEOR

#else //FUNC_REPLACE_ADC_WITH_METER_IC

            ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0];    //ADC3_IN9_Voltage_L1 (PF3)
            ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1];    //ADC3_IN14_1998 (PF4)
            ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2];    //ADC3_IN15_Temp (PF5)
            ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3];    //ADC3_IN4_GMI_VL1 (PF6)
            ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4];    //ADC3_IN7_Current_L1 (PF9)
            ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5];    //ADC3_IN5_Current_L2 (PF7)
            ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6];    //ADC3_IN6_PP_GUN_DET (PF8)
            ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7];    //ADC3_IN8_Voltage_L2 (PF10)
            ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8];    //ADC3_IN10_Voltage_L3 (PC0)
            ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9];    //ADC3_IN11_Current_L3 (PC1)

#endif //FUNC_REPLACE_ADC_WITH_METER_IC

        }

        //VT
#ifndef FUNC_REPLACE_ADC_WITH_METER_IC
        filter_move_avg(&adc_value.ADC3_IN9_Voltage_L1, vRms_cal2(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT));     //L1
        filter_move_avg(&adc_value.ADC3_IN8_Voltage_L2, vRms_cal2(ADC3_Buffer_Each[7], ADC3_SAMPLE_COUNT));     //L2
        filter_move_avg(&adc_value.ADC3_IN10_Voltage_L3, vRms_cal2(ADC3_Buffer_Each[8], ADC3_SAMPLE_COUNT));    //L3
#endif

        //MCU VDD
        filter_move_avg(&adc_value.ADC3_IN14_UL_1998, avg_cal(ADC3_Buffer_Each[1], ADC3_SAMPLE_COUNT));
        //TEMP
        filter_move_avg(&adc_value.ADC3_IN15_Temp, avg_cal(ADC3_Buffer_Each[2], ADC3_SAMPLE_COUNT));

#ifdef VO_SIMU_NTC
        if (Charger.m_VOCode.m_EnableSimuNTC)
        {
            Charger.temperature.SystemAmbientTemp = Charger.m_SimuData.m_NtcTemp;
        }
        else
        {
            Charger.temperature.SystemAmbientTemp = getTemperature(adc_value.ADC3_IN15_Temp.value);
        }

#else
        Charger.temperature.SystemAmbientTemp = getTemperature(adc_value.ADC3_IN15_Temp.value);
#endif

#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
        if (Charger.m_bModelNameAX80_1P)
        {
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
            if (Charger.m_bModelNameAX80_NACS_1P)
            {
                filter_move_avg(&adc_value.ADC3_IN9_AX80_NACS_T1, avg_cal(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT));
                filter_move_avg(&adc_value.ADC3_IN8_AX80_NACS_T2, avg_cal(ADC3_Buffer_Each[7], ADC3_SAMPLE_COUNT));
                filter_move_avg(&adc_value.ADC3_IN10_AX80_NACS_T3, avg_cal(ADC3_Buffer_Each[8], ADC3_SAMPLE_COUNT));
                filter_move_avg(&adc_value.ADC3_IN7_AX80_NACS_T4, avg_cal(ADC3_Buffer_Each[4], ADC3_SAMPLE_COUNT));

                filter_move_avg(&adc_value.ADC3_IN5_AX80_NACS_T5, avg_cal(ADC3_Buffer_Each[5], ADC3_SAMPLE_COUNT));
                filter_move_avg(&adc_value.ADC3_IN11_AX80_NACS_T6, avg_cal(ADC3_Buffer_Each[9], ADC3_SAMPLE_COUNT));

#ifdef FUNC_AX80_NACS_NEW_TEMP_SENSOR_COMPENSATION_20231214
#ifdef FUNC_AX80_NACS_TEMP_SENSOR_WITHOUT_COMPENSATION_20240903
#ifdef FUNC_AX80_NACS_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240906
                double v = 0;
                double powCurr = ((double)Charger.Current[0]/100.0) * ((double)Charger.Current[0]/100.0);
                double pow80 = 80 * 80;

                Charger.temperature.SystemAmbientTemp += 0;

                v = powCurr * (10.29 / pow80);
                Charger.temperature.AX80_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX80_NACS_T1.value) + HTK_ROUND_U16(v);

                v = powCurr * (11.40 / pow80);
                Charger.temperature.AX80_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX80_NACS_T2.value) + HTK_ROUND_U16(v);

                v = powCurr * (10.12 / pow80);
                Charger.temperature.AX80_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX80_NACS_T3.value) + HTK_ROUND_U16(v);

                v = powCurr * (9.75 / pow80);
                Charger.temperature.AX80_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX80_NACS_T4.value) + HTK_ROUND_U16(v);

                Charger.temperature.AX80_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX80_NACS_T5.value) + 0;
                Charger.temperature.AX80_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX80_NACS_T6.value) + 0;
#else //FUNC_AX80_NACS_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240906
                {
                    Charger.temperature.SystemAmbientTemp += 0;
                    Charger.temperature.AX80_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX80_NACS_T1.value) + 0;
                    Charger.temperature.AX80_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX80_NACS_T2.value) + 0;
                    Charger.temperature.AX80_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX80_NACS_T3.value) + 0;
                    Charger.temperature.AX80_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX80_NACS_T4.value) + 0;
                    Charger.temperature.AX80_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX80_NACS_T5.value) + 0;
                    Charger.temperature.AX80_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX80_NACS_T6.value) + 0;
                }
#endif //FUNC_AX80_NACS_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240906
#else //FUNC_AX80_NACS_TEMP_SENSOR_WITHOUT_COMPENSATION_20240903
                {
                    double v = 0;
                    v = 2.38333 + (-1.7);
                    Charger.temperature.SystemAmbientTemp += HTK_ROUND_U16(v);

                    v = 23.8667 + (-4.73333);
                    Charger.temperature.AX80_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX80_NACS_T1.value) + HTK_ROUND_U16(v);

                    v = 25.45 + (-5.71667);
                    Charger.temperature.AX80_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX80_NACS_T2.value) + HTK_ROUND_U16(v);

                    v = 28.2833 + (-3.43333);
                    Charger.temperature.AX80_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX80_NACS_T3.value) + HTK_ROUND_U16(v);

                    v = 29.5333 + (-3.56667);
                    Charger.temperature.AX80_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX80_NACS_T4.value) + HTK_ROUND_U16(v);

                    Charger.temperature.AX80_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX80_NACS_T5.value) + 0;
                    Charger.temperature.AX80_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX80_NACS_T6.value) + 0;
                }
#endif //FUNC_AX80_NACS_TEMP_SENSOR_WITHOUT_COMPENSATION_20240903
#else //FUNC_AX80_NACS_NEW_TEMP_SENSOR_COMPENSATION_20231214
#ifdef FUNC_AX80_NACS_NEW_TEMP_SENSOR_COMPENSATION
                Charger.temperature.SystemAmbientTemp += 3;
                Charger.temperature.AX80_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX80_NACS_T1.value) + 24;
                Charger.temperature.AX80_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX80_NACS_T2.value) + 26;
                Charger.temperature.AX80_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX80_NACS_T3.value) + 29;
                Charger.temperature.AX80_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX80_NACS_T4.value) + 30;
                Charger.temperature.AX80_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX80_NACS_T5.value) + 0;
                Charger.temperature.AX80_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX80_NACS_T6.value) + 0;
#else
                Charger.temperature.AX80_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX80_NACS_T1.value);
                Charger.temperature.AX80_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX80_NACS_T2.value);
                Charger.temperature.AX80_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX80_NACS_T3.value);
                Charger.temperature.AX80_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX80_NACS_T4.value);
                Charger.temperature.AX80_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX80_NACS_T5.value);
                Charger.temperature.AX80_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX80_NACS_T6.value);
#endif
#endif //FUNC_AX80_NACS_NEW_TEMP_SENSOR_COMPENSATION_20231214
                {
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
                    int16_t v = 0;
#else
                    uint8_t v = 0;
#endif
                    if (Charger.temperature.SystemAmbientTemp > v)   v = Charger.temperature.SystemAmbientTemp;
                    if (Charger.temperature.CcsConnectorTemp > v)    v = Charger.temperature.CcsConnectorTemp;
                    Charger.temperature.Group1_MaxTemp = v;
                }

                {
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
                    int16_t v = 0;
#else
                    uint8_t v = 0;
#endif

#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
                    if (Charger.temperature.AX80_NACS_T1_L1_IN > v)    v = Charger.temperature.AX80_NACS_T1_L1_IN;
                    if (Charger.temperature.AX80_NACS_T2_L2_IN > v)    v = Charger.temperature.AX80_NACS_T2_L2_IN;
                    Charger.temperature.Group2_MaxTemp = v;

                    v = 0;
                    if (Charger.temperature.AX80_NACS_T3_L1_OUT > v)    v = Charger.temperature.AX80_NACS_T3_L1_OUT;
                    if (Charger.temperature.AX80_NACS_T4_L2_OUT > v)    v = Charger.temperature.AX80_NACS_T4_L2_OUT;
                    Charger.temperature.Group3_MaxTemp = v;

                    v = 0;
                    if (Charger.temperature.AX80_NACS_T5_L1_GUN > v)    v = Charger.temperature.AX80_NACS_T5_L1_GUN;
                    if (Charger.temperature.AX80_NACS_T6_L2_GUN > v)    v = Charger.temperature.AX80_NACS_T6_L2_GUN;
                    Charger.temperature.Group4_MaxTemp = v;

#else //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
                    if (Charger.temperature.AX80_NACS_T1_L1_IN > v)    v = Charger.temperature.AX80_NACS_T1_L1_IN;
                    if (Charger.temperature.AX80_NACS_T2_L2_IN > v)    v = Charger.temperature.AX80_NACS_T2_L2_IN;
                    if (Charger.temperature.AX80_NACS_T3_L1_OUT > v)    v = Charger.temperature.AX80_NACS_T3_L1_OUT;
                    if (Charger.temperature.AX80_NACS_T4_L2_OUT > v)    v = Charger.temperature.AX80_NACS_T4_L2_OUT;
                    if (Charger.temperature.AX80_NACS_T5_L1_GUN > v)    v = Charger.temperature.AX80_NACS_T5_L1_GUN;
                    if (Charger.temperature.AX80_NACS_T6_L2_GUN > v)    v = Charger.temperature.AX80_NACS_T6_L2_GUN;
                    Charger.temperature.Group2_MaxTemp = v;
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
                }
            }
            else
            {
                filter_move_avg(&adc_value.ADC3_IN9_Relay1_Temp, avg_cal(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT));
                filter_move_avg(&adc_value.ADC3_IN8_Relay2_Temp, avg_cal(ADC3_Buffer_Each[7], ADC3_SAMPLE_COUNT));
                filter_move_avg(&adc_value.ADC3_IN10_Input_L1_Temp, avg_cal(ADC3_Buffer_Each[8], ADC3_SAMPLE_COUNT));
                filter_move_avg(&adc_value.ADC3_IN7_Input_N_L2_Temp, avg_cal(ADC3_Buffer_Each[4], ADC3_SAMPLE_COUNT));

#ifdef FUNC_AX80_NEW_TEMP_SENSOR_COMPENSATION
                Charger.temperature.AX80_Relay1Temp = getTemperature(adc_value.ADC3_IN9_Relay1_Temp.value) + 17; //16.95
                Charger.temperature.AX80_Relay2Temp = getTemperature(adc_value.ADC3_IN8_Relay2_Temp.value) + 18; //17.55
                Charger.temperature.AX80_Input_L1_Temp = getTemperature(adc_value.ADC3_IN10_Input_L1_Temp.value) + 13; //12.575
                Charger.temperature.AX80_Input_N_L2_Temp = getTemperature(adc_value.ADC3_IN7_Input_N_L2_Temp.value) + 18; //17.9
#else
                Charger.temperature.AX80_Relay1Temp = getTemperature(adc_value.ADC3_IN9_Relay1_Temp.value);
                Charger.temperature.AX80_Relay2Temp = getTemperature(adc_value.ADC3_IN8_Relay2_Temp.value);
                Charger.temperature.AX80_Input_L1_Temp = getTemperature(adc_value.ADC3_IN10_Input_L1_Temp.value);
                Charger.temperature.AX80_Input_N_L2_Temp = getTemperature(adc_value.ADC3_IN7_Input_N_L2_Temp.value);
#endif
                {
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
                    int16_t v = 0;
#else
                    uint8_t v = 0;
#endif
                    if (Charger.temperature.SystemAmbientTemp > v)   v = Charger.temperature.SystemAmbientTemp;
                    if (Charger.temperature.CcsConnectorTemp > v)    v = Charger.temperature.CcsConnectorTemp;
                    Charger.temperature.Group1_MaxTemp = v;
                }

                {
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
                    int16_t v = 0;
#else
                    uint8_t v = 0;
#endif
                    if (Charger.temperature.AX80_Relay1Temp > v)          v = Charger.temperature.AX80_Relay1Temp;
                    if (Charger.temperature.AX80_Relay2Temp > v)          v = Charger.temperature.AX80_Relay2Temp;
                    if (Charger.temperature.AX80_Input_L1_Temp > v)       v = Charger.temperature.AX80_Input_L1_Temp;
                    if (Charger.temperature.AX80_Input_N_L2_Temp > v)     v = Charger.temperature.AX80_Input_N_L2_Temp;
                    Charger.temperature.Group2_MaxTemp = v;
                }
            }
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
            filter_move_avg(&adc_value.ADC3_IN9_Relay1_Temp, avg_cal(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT));
            filter_move_avg(&adc_value.ADC3_IN8_Relay2_Temp, avg_cal(ADC3_Buffer_Each[7], ADC3_SAMPLE_COUNT));
            filter_move_avg(&adc_value.ADC3_IN10_Input_L1_Temp, avg_cal(ADC3_Buffer_Each[8], ADC3_SAMPLE_COUNT));
            filter_move_avg(&adc_value.ADC3_IN7_Input_N_L2_Temp, avg_cal(ADC3_Buffer_Each[4], ADC3_SAMPLE_COUNT));

#ifdef FUNC_AX80_NEW_TEMP_SENSOR_COMPENSATION
            Charger.temperature.AX80_Relay1Temp = getTemperature(adc_value.ADC3_IN9_Relay1_Temp.value) + 17; //16.95
            Charger.temperature.AX80_Relay2Temp = getTemperature(adc_value.ADC3_IN8_Relay2_Temp.value) + 18; //17.55
            Charger.temperature.AX80_Input_L1_Temp = getTemperature(adc_value.ADC3_IN10_Input_L1_Temp.value) + 13; //12.575
            Charger.temperature.AX80_Input_N_L2_Temp = getTemperature(adc_value.ADC3_IN7_Input_N_L2_Temp.value) + 18; //17.9
#else
            Charger.temperature.AX80_Relay1Temp = getTemperature(adc_value.ADC3_IN9_Relay1_Temp.value);
            Charger.temperature.AX80_Relay2Temp = getTemperature(adc_value.ADC3_IN8_Relay2_Temp.value);
            Charger.temperature.AX80_Input_L1_Temp = getTemperature(adc_value.ADC3_IN10_Input_L1_Temp.value);
            Charger.temperature.AX80_Input_N_L2_Temp = getTemperature(adc_value.ADC3_IN7_Input_N_L2_Temp.value);
#endif
            {
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
                int16_t v = 0;
#else
                uint8_t v = 0;
#endif
                if (Charger.temperature.SystemAmbientTemp > v)   v = Charger.temperature.SystemAmbientTemp;
                if (Charger.temperature.CcsConnectorTemp > v)    v = Charger.temperature.CcsConnectorTemp;
                Charger.temperature.Group1_MaxTemp = v;
            }

            {
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
                int16_t v = 0;
#else
                uint8_t v = 0;
#endif
                if (Charger.temperature.AX80_Relay1Temp > v)          v = Charger.temperature.AX80_Relay1Temp;
                if (Charger.temperature.AX80_Relay2Temp > v)          v = Charger.temperature.AX80_Relay2Temp;
                if (Charger.temperature.AX80_Input_L1_Temp > v)       v = Charger.temperature.AX80_Input_L1_Temp;
                if (Charger.temperature.AX80_Input_N_L2_Temp > v)     v = Charger.temperature.AX80_Input_N_L2_Temp;
                Charger.temperature.Group2_MaxTemp = v;
            }
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
        }
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
        else if (Charger.m_bModelNameAW48_1P)
        {
            filter_move_avg(&adc_value.ADC3_IN9_AW48_T1, avg_cal(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT));
            filter_move_avg(&adc_value.ADC3_IN8_AW48_T2, avg_cal(ADC3_Buffer_Each[7], ADC3_SAMPLE_COUNT));
            filter_move_avg(&adc_value.ADC3_IN10_AW48_T3, avg_cal(ADC3_Buffer_Each[8], ADC3_SAMPLE_COUNT));
            filter_move_avg(&adc_value.ADC3_IN7_AW48_T4, avg_cal(ADC3_Buffer_Each[4], ADC3_SAMPLE_COUNT));

            filter_move_avg(&adc_value.ADC3_IN5_AW48_T5, avg_cal(ADC3_Buffer_Each[5], ADC3_SAMPLE_COUNT));
            filter_move_avg(&adc_value.ADC3_IN11_AW48_T6, avg_cal(ADC3_Buffer_Each[9], ADC3_SAMPLE_COUNT));

#ifdef FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION_20231214
#ifdef FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION_20240508
#ifdef FUNC_AW48_TEMP_SENSOR_WITHOUT_COMPENSATION_20240521
#ifdef FUNC_AW48_TEMP_SENSOR_COMPENSATION_AND_MODIFY_FORMULA_20240522
            {

//                Charger.temperature.SystemAmbientTemp += 0;
//                Charger.temperature.AW48_T1_L1_IN = getTemperature_NACS(adc_value.ADC3_IN9_AW48_T1.value) + 6;
//                Charger.temperature.AW48_T2_L2_IN = getTemperature_NACS(adc_value.ADC3_IN8_AW48_T2.value) + 6;
//                Charger.temperature.AW48_T3_L1_OUT = getTemperature_NACS(adc_value.ADC3_IN10_AW48_T3.value) + 7;
//                Charger.temperature.AW48_T4_L2_OUT = getTemperature_NACS(adc_value.ADC3_IN7_AW48_T4.value) + 7;
//                Charger.temperature.AW48_T5_L1_GUN = getTemperature_NACS(adc_value.ADC3_IN5_AW48_T5.value) + 0;
//                Charger.temperature.AW48_T6_L2_GUN = getTemperature_NACS(adc_value.ADC3_IN11_AW48_T6.value) + 0;
//

#ifdef FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523
//#ifdef TEST_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523_REMOVE_COMPENSATION
//                Charger.temperature.SystemAmbientTemp += 0;
//                Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + 0;
//                Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + 0;
//                Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + 0;
//                Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + 0;
//                Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
//                Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
//#else //TEST_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523_REMOVE_COMPENSATION

#ifdef FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240729

#ifdef FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20241007
                double v = 0;
                double powCurr = ((double)Charger.Current[0]/100.0) * ((double)Charger.Current[0]/100.0);
                double pow48 = 48 * 48;

                Charger.temperature.SystemAmbientTemp += 0;

                v = powCurr * (17.28 / pow48);
                Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + HTK_ROUND_U16(v);

                v = powCurr * (18.34 / pow48);
                Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + HTK_ROUND_U16(v);

                v = powCurr * (20.64 / pow48);
                Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + HTK_ROUND_U16(v);

                v = powCurr * (22.00 / pow48);
                Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + HTK_ROUND_U16(v);

                Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
                Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
#else //FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20241007
                double v = 0;
                double powCurr = ((double)Charger.Current[0]/100.0) * ((double)Charger.Current[0]/100.0);
                double pow48 = 48 * 48;

                Charger.temperature.SystemAmbientTemp += 0;

                v = powCurr * (20.53 / pow48);
                Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + HTK_ROUND_U16(v);

                v = powCurr * (22.03 / pow48);
                Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + HTK_ROUND_U16(v);

                v = powCurr * (24.39 / pow48);
                Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + HTK_ROUND_U16(v);

                v = powCurr * (23.39 / pow48);
                Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + HTK_ROUND_U16(v);

                Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
                Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
#endif //FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20241007
#else //FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240729
                double v = 0;
                double powCurr = ((double)Charger.Current[0]/100.0) * ((double)Charger.Current[0]/100.0);
                double pow48 = 48 * 48;

                Charger.temperature.SystemAmbientTemp += 0;

                v = powCurr * (11.97 / pow48);
                Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + HTK_ROUND_U16(v);

                v = powCurr * (14.98 / pow48);
                Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + HTK_ROUND_U16(v);

                v = powCurr * (28.55 / pow48);
                Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + HTK_ROUND_U16(v);

                v = powCurr * (26.91 / pow48);
                Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + HTK_ROUND_U16(v);

                Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
                Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
#endif //FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240729
//#endif //TEST_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523_REMOVE_COMPENSATION
#else //FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523
                Charger.temperature.SystemAmbientTemp += 0;
                Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + 6;
                Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + 6;
                Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + 7;
                Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + 7;
                Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
                Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
#endif //FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523
            }
#else //FUNC_AW48_TEMP_SENSOR_COMPENSATION_AND_MODIFY_FORMULA_20240522
            {
                double v = 0;
                Charger.temperature.SystemAmbientTemp += HTK_ROUND_U16(v);

                Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + HTK_ROUND_U16(v);

                Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + HTK_ROUND_U16(v);

                Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + HTK_ROUND_U16(v);

                Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + HTK_ROUND_U16(v);

                Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
                Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
            }
#endif //FUNC_AW48_TEMP_SENSOR_COMPENSATION_AND_MODIFY_FORMULA_20240522

#else //FUNC_AW48_TEMP_SENSOR_WITHOUT_COMPENSATION_20240521
            {
                double v = 0;
                v = 2.38333 + (-1.7);
                Charger.temperature.SystemAmbientTemp += HTK_ROUND_U16(v);

                v = 23.8667 + (-4.73333) + (-6.25);
                Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + HTK_ROUND_U16(v);

                v = 25.45 + (-5.71667) + (-6.5);
                Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + HTK_ROUND_U16(v);

                v = 28.2833 + (-3.43333);
                Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + HTK_ROUND_U16(v);

                v = 29.5333 + (-3.56667);
                Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + HTK_ROUND_U16(v);

                Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
                Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
            }
#endif //FUNC_AW48_TEMP_SENSOR_WITHOUT_COMPENSATION_20240521
#else //FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION_20240508
            {
                double v = 0;
                v = 2.38333 + (-1.7);
                Charger.temperature.SystemAmbientTemp += HTK_ROUND_U16(v);

                v = 23.8667 + (-4.73333);
                Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + HTK_ROUND_U16(v);

                v = 25.45 + (-5.71667);
                Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + HTK_ROUND_U16(v);

                v = 28.2833 + (-3.43333);
                Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + HTK_ROUND_U16(v);

                v = 29.5333 + (-3.56667);
                Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + HTK_ROUND_U16(v);

                Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
                Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
            }
#endif //FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION_20240508
#else //FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION_20231214
#ifdef FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION
            Charger.temperature.SystemAmbientTemp += 3;
            Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + 24;
            Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + 26;
            Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + 29;
            Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + 30;
            Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
            Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
#else
            Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value);
            Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value);
            Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value);
            Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value);
            Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value);
            Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value);
#endif
#endif //FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION_20231214
            {
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
                int16_t v = 0;
#else
                uint8_t v = 0;
#endif
                if (Charger.temperature.SystemAmbientTemp > v)   v = Charger.temperature.SystemAmbientTemp;
                if (Charger.temperature.CcsConnectorTemp > v)    v = Charger.temperature.CcsConnectorTemp;
                Charger.temperature.Group1_MaxTemp = v;
            }

            {
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
                int16_t v = 0;
#else
                uint8_t v = 0;
#endif

#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
                if (Charger.temperature.AW48_T1_L1_IN > v)    v = Charger.temperature.AW48_T1_L1_IN;
                if (Charger.temperature.AW48_T2_L2_IN > v)    v = Charger.temperature.AW48_T2_L2_IN;
                Charger.temperature.Group2_MaxTemp = v;

                v = 0;
                if (Charger.temperature.AW48_T3_L1_OUT > v)    v = Charger.temperature.AW48_T3_L1_OUT;
                if (Charger.temperature.AW48_T4_L2_OUT > v)    v = Charger.temperature.AW48_T4_L2_OUT;
                Charger.temperature.Group3_MaxTemp = v;

                v = 0;
                if (Charger.temperature.AW48_T5_L1_GUN > v)    v = Charger.temperature.AW48_T5_L1_GUN;
                if (Charger.temperature.AW48_T6_L2_GUN > v)    v = Charger.temperature.AW48_T6_L2_GUN;
                Charger.temperature.Group4_MaxTemp = v;
#else //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
                if (Charger.temperature.AW48_T1_L1_IN > v)    v = Charger.temperature.AW48_T1_L1_IN;
                if (Charger.temperature.AW48_T2_L2_IN > v)    v = Charger.temperature.AW48_T2_L2_IN;
                if (Charger.temperature.AW48_T5_L1_GUN > v)    v = Charger.temperature.AW48_T5_L1_GUN;
                if (Charger.temperature.AW48_T6_L2_GUN > v)    v = Charger.temperature.AW48_T6_L2_GUN;
                Charger.temperature.Group2_MaxTemp = v;

                v = 0;
                if (Charger.temperature.AW48_T3_L1_OUT > v)    v = Charger.temperature.AW48_T3_L1_OUT;
                if (Charger.temperature.AW48_T4_L2_OUT > v)    v = Charger.temperature.AW48_T4_L2_OUT;
                Charger.temperature.Group3_MaxTemp = v;
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#else //MODIFY_AW48_OTP_SPEC_20240522_STEVEN
                if (Charger.temperature.AW48_T1_L1_IN > v)    v = Charger.temperature.AW48_T1_L1_IN;
                if (Charger.temperature.AW48_T2_L2_IN > v)    v = Charger.temperature.AW48_T2_L2_IN;
                if (Charger.temperature.AW48_T3_L1_OUT > v)    v = Charger.temperature.AW48_T3_L1_OUT;
                if (Charger.temperature.AW48_T4_L2_OUT > v)    v = Charger.temperature.AW48_T4_L2_OUT;
                if (Charger.temperature.AW48_T5_L1_GUN > v)    v = Charger.temperature.AW48_T5_L1_GUN;
                if (Charger.temperature.AW48_T6_L2_GUN > v)    v = Charger.temperature.AW48_T6_L2_GUN;
                Charger.temperature.Group2_MaxTemp = v;
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN
            }
        }
#endif //FUNC_AW48_ADD_6_TEMP_SENEOR

#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
        else if (Charger.m_bModelNameAX48_NACS_1P)
        {
            filter_move_avg(&adc_value.ADC3_IN9_AX48_NACS_T1, avg_cal(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT));
            filter_move_avg(&adc_value.ADC3_IN8_AX48_NACS_T2, avg_cal(ADC3_Buffer_Each[7], ADC3_SAMPLE_COUNT));
            filter_move_avg(&adc_value.ADC3_IN10_AX48_NACS_T3, avg_cal(ADC3_Buffer_Each[8], ADC3_SAMPLE_COUNT));
            filter_move_avg(&adc_value.ADC3_IN7_AX48_NACS_T4, avg_cal(ADC3_Buffer_Each[4], ADC3_SAMPLE_COUNT));

            filter_move_avg(&adc_value.ADC3_IN5_AX48_NACS_T5, avg_cal(ADC3_Buffer_Each[5], ADC3_SAMPLE_COUNT));
            filter_move_avg(&adc_value.ADC3_IN11_AX48_NACS_T6, avg_cal(ADC3_Buffer_Each[9], ADC3_SAMPLE_COUNT));

#ifdef FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION_20231214

#ifdef FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION_20240415

#ifdef FUNC_AX48_NACS_TEMP_SENSOR_WITHOUT_COMPENSATION_20240521

#ifdef FUNC_AX48_NACS_TEMP_SENSOR_COMPENSATION_AND_MODIFY_FORMULA_20240522
            {

//                Charger.temperature.SystemAmbientTemp += 0;
//                Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature_NACS(adc_value.ADC3_IN9_AX48_NACS_T1.value) + 6;
//                Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature_NACS(adc_value.ADC3_IN8_AX48_NACS_T2.value) + 6;
//                Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature_NACS(adc_value.ADC3_IN10_AX48_NACS_T3.value) + 7;
//                Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature_NACS(adc_value.ADC3_IN7_AX48_NACS_T4.value) + 7;
//                Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature_NACS(adc_value.ADC3_IN5_AX48_NACS_T5.value) + 0;
//                Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature_NACS(adc_value.ADC3_IN11_AX48_NACS_T6.value) + 0;
//

#ifdef FUNC_AX48_NACS_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523
                double v = 0;
                double powCurr = ((double)Charger.Current[0]/100.0) * ((double)Charger.Current[0]/100.0);
                double pow48 = 48 * 48;

                Charger.temperature.SystemAmbientTemp += 0;

                v = powCurr * (6 / pow48);
                Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX48_NACS_T1.value) + HTK_ROUND_U16(v);

                v = powCurr * (6 / pow48);
                Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX48_NACS_T2.value) + HTK_ROUND_U16(v);

                v = powCurr * (7 / pow48);
                Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX48_NACS_T3.value) + HTK_ROUND_U16(v);

                v = powCurr * (12 / pow48);
                Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX48_NACS_T4.value) + HTK_ROUND_U16(v);

                Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX48_NACS_T5.value) + 0;
                Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX48_NACS_T6.value) + 0;
#else //FUNC_AX48_NACS_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523
                Charger.temperature.SystemAmbientTemp += 0;
                Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX48_NACS_T1.value) + 6;
                Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX48_NACS_T2.value) + 6;
                Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX48_NACS_T3.value) + 7;
                Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX48_NACS_T4.value) + 7;
                Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX48_NACS_T5.value) + 0;
                Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX48_NACS_T6.value) + 0;
#endif //FUNC_AX48_NACS_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523
            }
#else //FUNC_AX48_NACS_TEMP_SENSOR_COMPENSATION_AND_MODIFY_FORMULA_20240522
            {

                Charger.temperature.SystemAmbientTemp += 0;
                Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX48_NACS_T1.value) + 0;
                Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX48_NACS_T2.value) + 0;
                Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX48_NACS_T3.value) + 0;
                Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX48_NACS_T4.value) + 0;
                Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX48_NACS_T5.value) + 0;
                Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX48_NACS_T6.value) + 0;
            }
#endif //FUNC_AX48_NACS_TEMP_SENSOR_COMPENSATION_AND_MODIFY_FORMULA_20240522

#else //FUNC_AX48_NACS_TEMP_SENSOR_WITHOUT_COMPENSATION_20240521
            {
                double v = 0;
                v = 2.38333 + (-1.7);
                Charger.temperature.SystemAmbientTemp += HTK_ROUND_U16(v);

                v = 23.8667 + (-4.73333) + (-3.7667) + (3);
                Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX48_NACS_T1.value) + HTK_ROUND_U16(v);

                v = 25.45 + (-5.71667) + (-4.6833) + (3);
                Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX48_NACS_T2.value) + HTK_ROUND_U16(v);

                v = 28.2833 + (-3.43333) + (-7.0333) + (7);
                Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX48_NACS_T3.value) + HTK_ROUND_U16(v);

                v = 29.5333 + (-3.56667) + (-4.3333) + (4);
                Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX48_NACS_T4.value) + HTK_ROUND_U16(v);

                Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX48_NACS_T5.value) + 0;
                Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX48_NACS_T6.value) + 0;
            }
#endif //FUNC_AX48_NACS_TEMP_SENSOR_WITHOUT_COMPENSATION_20240521

#else //FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION_20240415
            {
                double v = 0;
                v = 2.38333 + (-1.7);
                Charger.temperature.SystemAmbientTemp += HTK_ROUND_U16(v);

                v = 23.8667 + (-4.73333);
                Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX48_NACS_T1.value) + HTK_ROUND_U16(v);

                v = 25.45 + (-5.71667);
                Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX48_NACS_T2.value) + HTK_ROUND_U16(v);

                v = 28.2833 + (-3.43333);
                Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX48_NACS_T3.value) + HTK_ROUND_U16(v);

                v = 29.5333 + (-3.56667);
                Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX48_NACS_T4.value) + HTK_ROUND_U16(v);

                Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX48_NACS_T5.value) + 0;
                Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX48_NACS_T6.value) + 0;
            }
#endif //FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION_20240415
#else //FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION_20231214
#ifdef FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION
            Charger.temperature.SystemAmbientTemp += 3;
            Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX48_NACS_T1.value) + 24;
            Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX48_NACS_T2.value) + 26;
            Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX48_NACS_T3.value) + 29;
            Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX48_NACS_T4.value) + 30;
            Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX48_NACS_T5.value) + 0;
            Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX48_NACS_T6.value) + 0;
#else
            Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX48_NACS_T1.value);
            Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX48_NACS_T2.value);
            Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX48_NACS_T3.value);
            Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX48_NACS_T4.value);
            Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX48_NACS_T5.value);
            Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX48_NACS_T6.value);
#endif
#endif //FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION_20231214
            {
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
                int16_t v = 0;
#else
                uint8_t v = 0;
#endif
                if (Charger.temperature.SystemAmbientTemp > v)   v = Charger.temperature.SystemAmbientTemp;
                if (Charger.temperature.CcsConnectorTemp > v)    v = Charger.temperature.CcsConnectorTemp;
                Charger.temperature.Group1_MaxTemp = v;
            }

            {
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
                int16_t v = 0;
#else
                uint8_t v = 0;
#endif

#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
                if (Charger.temperature.AX48_NACS_T1_L1_IN > v)    v = Charger.temperature.AX48_NACS_T1_L1_IN;
                if (Charger.temperature.AX48_NACS_T2_L2_IN > v)    v = Charger.temperature.AX48_NACS_T2_L2_IN;
                Charger.temperature.Group2_MaxTemp = v;

                v = 0;
                if (Charger.temperature.AX48_NACS_T3_L1_OUT > v)    v = Charger.temperature.AX48_NACS_T3_L1_OUT;
                if (Charger.temperature.AX48_NACS_T4_L2_OUT > v)    v = Charger.temperature.AX48_NACS_T4_L2_OUT;
                Charger.temperature.Group3_MaxTemp = v;

                v = 0;
                if (Charger.temperature.AX48_NACS_T5_L1_GUN > v)    v = Charger.temperature.AX48_NACS_T5_L1_GUN;
                if (Charger.temperature.AX48_NACS_T6_L2_GUN > v)    v = Charger.temperature.AX48_NACS_T6_L2_GUN;
                Charger.temperature.Group4_MaxTemp = v;

#else //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
                if (Charger.temperature.AX48_NACS_T1_L1_IN > v)    v = Charger.temperature.AX48_NACS_T1_L1_IN;
                if (Charger.temperature.AX48_NACS_T2_L2_IN > v)    v = Charger.temperature.AX48_NACS_T2_L2_IN;
                if (Charger.temperature.AX48_NACS_T5_L1_GUN > v)    v = Charger.temperature.AX48_NACS_T5_L1_GUN;
                if (Charger.temperature.AX48_NACS_T6_L2_GUN > v)    v = Charger.temperature.AX48_NACS_T6_L2_GUN;
                Charger.temperature.Group2_MaxTemp = v;

                v = 0;
                if (Charger.temperature.AX48_NACS_T3_L1_OUT > v)    v = Charger.temperature.AX48_NACS_T3_L1_OUT;
                if (Charger.temperature.AX48_NACS_T4_L2_OUT > v)    v = Charger.temperature.AX48_NACS_T4_L2_OUT;
                Charger.temperature.Group3_MaxTemp = v;
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
#else //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
                if (Charger.temperature.AX48_NACS_T1_L1_IN > v)    v = Charger.temperature.AX48_NACS_T1_L1_IN;
                if (Charger.temperature.AX48_NACS_T2_L2_IN > v)    v = Charger.temperature.AX48_NACS_T2_L2_IN;
                if (Charger.temperature.AX48_NACS_T3_L1_OUT > v)    v = Charger.temperature.AX48_NACS_T3_L1_OUT;
                if (Charger.temperature.AX48_NACS_T4_L2_OUT > v)    v = Charger.temperature.AX48_NACS_T4_L2_OUT;
                if (Charger.temperature.AX48_NACS_T5_L1_GUN > v)    v = Charger.temperature.AX48_NACS_T5_L1_GUN;
                if (Charger.temperature.AX48_NACS_T6_L2_GUN > v)    v = Charger.temperature.AX48_NACS_T6_L2_GUN;
                Charger.temperature.Group2_MaxTemp = v;
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
            }
        }
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR

        else
        {
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
                int16_t v = 0;
#else
                uint8_t v = 0;
#endif
            if (Charger.temperature.SystemAmbientTemp > v)   v = Charger.temperature.SystemAmbientTemp;
            if (Charger.temperature.CcsConnectorTemp > v)    v = Charger.temperature.CcsConnectorTemp;
            Charger.temperature.Group1_MaxTemp = v;
        }
#endif

        //PE
        filter_move_avg(&adc_value.ADC3_IN4_GMI_VL1, avg_cal(ADC3_Buffer_Each[3], ADC3_SAMPLE_COUNT));
#ifdef FUNC_AW48_KENNY_TEST_DOUBLE_GF_ADC_VAL
        if (Charger.m_bModelNameAW48_1P)
        {
            adc_value.ADC3_IN4_GMI_VL1.value *= 2;
        }
#endif

        //CT
#ifndef FUNC_REPLACE_ADC_WITH_METER_IC
        Current_filter_move_avg(&adc_value.ADC3_IN7_Current_L1, cRms_cal(ADC3_Buffer_Each[4], ADC3_SAMPLE_COUNT));
        Current_filter_move_avg(&adc_value.ADC3_IN5_Current_L2, cRms_cal(ADC3_Buffer_Each[5], ADC3_SAMPLE_COUNT));
        Current_filter_move_avg(&adc_value.ADC3_IN11_Current_L3, cRms_cal(ADC3_Buffer_Each[9], ADC3_SAMPLE_COUNT));
#endif

#ifdef FUNC_DETECT_PP

        if (Charger.m_bDetectPP)
        {
            filter_move_avg(&adc_value.ADC3_IN6_Gun_Detec, avg_cal(ADC3_Buffer_Each[6], ADC3_SAMPLE_COUNT));
            {

#ifdef VO_SIMU_PP
                if (Charger.m_VOCode.m_EnableSimuPP)
                {
                    UpdatePPInfo_CurrVal(&Charger.m_PPInfo, Charger.m_SimuData.m_PPCurr);
                }
                else
                {
                    UpdatePPInfo_AdcVal(&Charger.m_PPInfo, adc_value.ADC3_IN6_Gun_Detec.value);
                }
#else //VO_SIMU_PP
                UpdatePPInfo_AdcVal(&Charger.m_PPInfo, adc_value.ADC3_IN6_Gun_Detec.value);
#endif //VO_SIMU_PP

            }
        }
#endif //FUNC_DETECT_PP

#ifdef FUNC_DETECT_PP_NACS

        if (Charger.m_bDetectPP_NACS)
        {
            filter_move_avg(&adc_value.ADC3_IN6_Gun_Detec, avg_cal(ADC3_Buffer_Each[6], ADC3_SAMPLE_COUNT));
            {

//#ifdef VO_SIMU_PP
//                if (Charger.m_VOCode.m_EnableSimuPP)
//                {
//                    UpdatePPInfo_CurrVal(&Charger.m_PPInfo, Charger.m_SimuData.m_PPCurr);
//                }
//                else
//                {
//                    UpdatePPInfo_AdcVal(&Charger.m_PPInfo, adc_value.ADC3_IN6_Gun_Detec.value);
//                }
//#else //VO_SIMU_PP
//                UpdatePPInfo_AdcVal(&Charger.m_PPInfo, adc_value.ADC3_IN6_Gun_Detec.value);
//#endif //VO_SIMU_PP

            }
        }
#endif //FUNC_DETECT_PP_NACS

        //Correction
        //VT

#ifdef TEST_ACXXX_FAKEDATA

#ifdef TEST_AC110_FAKEDATA
        Charger.Voltage[0] = rand() % 50 + 11000;
        Charger.Voltage[1] = rand() % 50 + 11000;
        Charger.Voltage[2] = rand() % 50 + 11000;
#endif

#ifdef TEST_AC220_FAKEDATA
        Charger.Voltage[0] = rand() % 50 + 22000;
        Charger.Voltage[1] = rand() % 50 + 22000;
        Charger.Voltage[2] = rand() % 50 + 22000;
#endif

#else //TEST_ACXXX_FAKEDATA

#ifndef FUNC_REPLACE_ADC_WITH_METER_IC
        Charger.Voltage[0] = (uint16_t) (((adc_value.ADC3_IN9_Voltage_L1.value)*Charger.coefficient.gain_v[0])+Charger.coefficient.offset_v[0]) ;
        Charger.Voltage[1] = (uint16_t) (((adc_value.ADC3_IN8_Voltage_L2.value)*Charger.coefficient.gain_v[1])+Charger.coefficient.offset_v[1]) ;
        Charger.Voltage[2] = (uint16_t) (((adc_value.ADC3_IN10_Voltage_L3.value)*Charger.coefficient.gain_v[2])+Charger.coefficient.offset_v[2]) ;
#endif

#endif //TEST_ACXXX_FAKEDATA

#ifndef FUNC_REPLACE_ADC_WITH_METER_IC
        //CT
        Charger.Current[0] = (uint16_t)((adc_value.ADC3_IN7_Current_L1.value*Charger.coefficient.gain_c[0])+Charger.coefficient.offset_c[0]);
        Charger.Current[1] = (uint16_t)((adc_value.ADC3_IN5_Current_L2.value*Charger.coefficient.gain_c[1])+Charger.coefficient.offset_c[1]);
        Charger.Current[2] = (uint16_t)((adc_value.ADC3_IN11_Current_L3.value*Charger.coefficient.gain_c[2])+Charger.coefficient.offset_c[2]);
#endif
        //GMI
        Charger.Gmi_Voltage = (uint16_t) (((adc_value.ADC3_IN4_GMI_VL1.value)*Charger.coefficient.gain_gmi[0])+Charger.coefficient.offset_gmi[0]) ;


#ifdef COLD_LOAD_PICKUP
        if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
          // check Power drop is not alarm
          // Power drop detection
#ifdef FUNC_REPLACE_ADC_WITH_METER_IC
          if((Charger.Voltage[0] <= ALARM_SPEC_POWER_DROP) && (!Charger.AC_DripisTure) && (Charger.Mode != MODE_INITIAL))
#else
          if((vRms_cal2(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT) <= ALARM_SPEC_POWER_DROP) && (!Charger.AC_DripisTure) && (Charger.Mode != MODE_INITIAL))
#endif
          {
              if(Charger.counter.AC_Drip.fail > 1000)
              {
                //Charger.memory.EVSE_Config.data.item.isDispDebug  = OFF;
                if((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))
                {
                    Charger.memory.coldLoadPickUp.data.item.isEnable = ON;
                    Charger.memory.coldLoadPickUp.data.item.DateTime.year = Charger.cycle_info.startDateTime.year;
                    Charger.memory.coldLoadPickUp.data.item.DateTime.month = Charger.cycle_info.startDateTime.month;
                    Charger.memory.coldLoadPickUp.data.item.DateTime.day = Charger.cycle_info.startDateTime.day;
                    Charger.memory.coldLoadPickUp.data.item.DateTime.hour = Charger.cycle_info.startDateTime.hour;
                    Charger.memory.coldLoadPickUp.data.item.DateTime.min = Charger.cycle_info.startDateTime.min;
                    Charger.memory.coldLoadPickUp.data.item.DateTime.sec = Charger.cycle_info.startDateTime.sec;
                    Charger.memory.coldLoadPickUp.data.item.Duration = Charger.cycle_info.Duration;
                    sprintf(Charger.memory.coldLoadPickUp.data.item.PlugType, EVSE_CONNECTOR_TYPE);
                    Charger.memory.coldLoadPickUp.data.item.powerSum = Charger.cycle_info.Power_Consumption;
                    Charger.memory.coldLoadPickUp.data.item.startType = Charger.cycle_info.StartType;
                    //memcpy(Charger.memory.coldLoadPickUp.data.item.user, Charger.rfid.currentCard, 16);

                    Charger.memory.coldLoadPickUp.op_bits.update = ON;
                }
                Charger.AC_DripisTure = ON ;
              }
              else
                Charger.counter.AC_Drip.fail ++ ;
          }
#ifdef FUNC_REPLACE_ADC_WITH_METER_IC
          else if((Charger.Voltage[0] > (ALARM_SPEC_UV+ALARM_SPEC_OUV_HYSTERESIS)))
#else
          else if((vRms_cal2(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT) > (ALARM_SPEC_UV+ALARM_SPEC_OUV_HYSTERESIS)))
#endif
          {
               Charger.counter.AC_Drip.fail = 0 ;
               if(Charger.AC_DripisTure)
               {
                    Charger.AC_DripisTure = OFF ;
                    DEBUG_INFO("Alarm AC Drip recover.\r\n");
               }
          }
        }
#endif  //COLD_LOAD_PICKUP

#ifndef FUNC_POWER_CONSUMPTION_BY_METER_IC
        // Power accumulate calculation
        if(timer[TIMER_IDX_POWER].isAlarm)
        {
            timeTick.timeTick_End = HAL_GetTick();
            timeTick.timeTick_Delta = timeTick.timeTick_End - timeTick.timeTick_Start;
            timeTick.timeTick_Start = timeTick.timeTick_End;

            //L1 Power Consumption
            if(Charger.memory.EVSE_Config.data.item.Power_Consumption_L1_Cumulative >= 0xFFFFFFFF)
            {
                Charger.memory.EVSE_Config.data.item.Power_Consumption_L1_Cumulative = 0;
            }
            else
            {   //unit : 0.0001kW , 0.1W *10 = W
                Charger.memory.EVSE_Config.data.item.Power_Consumption_L1_Cumulative += (uint32_t)((Charger.Voltage[0]/100.0)*(Charger.Current[0]/100.0)*(timeTick.timeTick_Delta/3600000.0)*10.0);
            }

            //L2 Power Consumption
            if(Charger.memory.EVSE_Config.data.item.Power_Consumption_L2_Cumulative >= 0xFFFFFFFF)
            {
                Charger.memory.EVSE_Config.data.item.Power_Consumption_L2_Cumulative = 0;
            }
            else
            {   //unit : 0.0001kW , 0.1W *10 = W
                Charger.memory.EVSE_Config.data.item.Power_Consumption_L2_Cumulative += (uint32_t)((Charger.Voltage[1]/100.0)*(Charger.Current[1]/100.0)*(timeTick.timeTick_Delta/3600000.0)*10.0);
            }

            //L3 Power Consumption
            if(Charger.memory.EVSE_Config.data.item.Power_Consumption_L3_Cumulative >= 0xFFFFFFFF)
            {
                Charger.memory.EVSE_Config.data.item.Power_Consumption_L3_Cumulative = 0;
            }
            else
            {   //unit : 0.0001kW , 0.1W *10 = W
                Charger.memory.EVSE_Config.data.item.Power_Consumption_L3_Cumulative += (uint32_t)((Charger.Voltage[2]/100.0)*(Charger.Current[2]/100.0)*(timeTick.timeTick_Delta/3600000.0)*10.0);
            }

            //totle Power Consumption
            if(Charger.memory.EVSE_Config.data.item.Power_Consumption_Cumulative >= 0xFFFFFFFF)
            {
                Charger.memory.EVSE_Config.data.item.Power_Consumption_Cumulative = 0;
            }
            else
            {   //unit : 0.0001kW , 0.1W *10 = W
                Charger.memory.EVSE_Config.data.item.Power_Consumption_Cumulative = (Charger.memory.EVSE_Config.data.item.Power_Consumption_L1_Cumulative +
                                                                                     Charger.memory.EVSE_Config.data.item.Power_Consumption_L2_Cumulative +
                                                                                     Charger.memory.EVSE_Config.data.item.Power_Consumption_L3_Cumulative) ;
            }

            if(++updateMemReq>180)
            {
                Charger.memory.EVSE_Config.op_bits.update = ON;
                updateMemReq = 0;
            }
            timerRefresh(TIMER_IDX_POWER);
        }
#endif //FUNC_POWER_CONSUMPTION_BY_METER_IC

        if(HAL_ADC_Start_DMA(&hadc3, (uint32_t*)&ADC3_Buffer, ADC3_CHANEL_COUNT*ADC3_SAMPLE_COUNT)!=HAL_OK)Error_Handler();
    }
    osDelay(1);
  }
  /* USER CODE END StartAdcTask */
}

/* USER CODE BEGIN Header_StartTimeoutTask */
/**
* @brief Function implementing the timeoutTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTimeoutTask */
void StartTimeoutTask(void const * argument)
{
  /* USER CODE BEGIN StartTimeoutTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    IdleUntilReadAllMemory();
#endif

  breathe.isUp = ON;
  for(int idx=0;idx<BLINKER_COUNT;idx++)
    blinker[idx].blinkCount = 0;

  flickerTimeSet(FLICKER_IDX_BREATHE, 500, 500);
  blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);

#ifdef MODIFY_BREATHE_LED
    //breatheTimeSet(BREATHE_LED_UP_SPEED, BREATHE_LED_DN_SPEED, 500, 500, 500, 0 );
    breatheTimeSet(BREATHE_LED_UP_SPEED, BREATHE_LED_DN_SPEED, 1000, 1000, 1000, 0 );
#else
    breatheTimeSet(1000, 1000, 1000, 1000, 1000, 0 );
#endif
  Charger.am3352.BreatheLedChargeFadeIn = 2500;
  Charger.am3352.BreatheLedChargeFadeOut = 2500;
  Charger.am3352.BreatheLedConnectFadeIn = 1000;
  Charger.am3352.BreatheLedConnectFadeOut = 1000;
  Charger.am3352.BreatheLedAuthdFadeIn = 1000;
  Charger.am3352.BreatheLedAuthdFadeOut = 1000;

  /* Infinite loop */
  for(;;)
  {
    if(Charger.Mode != MODE_INITIAL)
    {
        HAL_RTC_GetTime(&hrtc, &currentTime, RTC_FORMAT_BIN);
        HAL_RTC_GetDate(&hrtc, &currentDate, RTC_FORMAT_BIN);
        Charger.memory.EVSE_Config.data.item.SystemDateTime.year = currentDate.Year + 2000;
        Charger.memory.EVSE_Config.data.item.SystemDateTime.month  = currentDate.Month;
        Charger.memory.EVSE_Config.data.item.SystemDateTime.day = currentDate.Date;
        Charger.memory.EVSE_Config.data.item.SystemDateTime.hour = currentTime.Hours;
        Charger.memory.EVSE_Config.data.item.SystemDateTime.min  = currentTime.Minutes;
        Charger.memory.EVSE_Config.data.item.SystemDateTime.sec  = currentTime.Seconds;
    }
    /*
        Timer check process
    */
    for(int idx=0;idx<TIMER_COUNT;idx++)
    {
        if(timer[idx].isEnable)
        {
            if((HAL_GetTick() - timer[idx].startTime) > timer[idx].timeoutSpec)
            {
                timer[idx].isAlarm = ON;
            }
            else
            {
                timer[idx].isAlarm = OFF;
            }
        }
        else
        {
            timer[idx].startTime = HAL_GetTick();
            timer[idx].isAlarm = OFF;
        }
    }

#ifdef FUNC_GUN_LOCK
    if (Charger.m_bUseGunLock)
    {
        GL_Proc();
    }
#endif //FUNC_GUN_LOCK

    /*
        Blink timer process
    */
    for(int idx=0;idx<BLINKER_COUNT;idx++)
    {
        if((HAL_GetTick() - blinker[idx].blinkStartTime) > (blinker[idx].isOn ? blinker[idx].blinkOnSpec : blinker[idx].blinkOffSpec))
        {
            if(blinker[idx].blinkCount >= blinker[idx].blinkCountSpec)
            {
                if((HAL_GetTick() - blinker[idx].resetStartTime) > blinker[idx].blinkRestSpec)
                {
                    if(!blinker[idx].blinkRestSpec) //no rest case
                      blinker[idx].blinkisFinish = ON ;
                    blinker[idx].blinkCount = 0;
#ifdef FUNC_AW48_NET_LED
                    if (Charger.m_bModelNameAW48_1P)
                    {
                        if (idx == BLINKER_IDX_LED_NET)
                        {
                            Proc_NetLedActionSubState();
                        }
                    }
#endif
                }
                else
                {
                    blinker[idx].isOn= OFF;
                    blinker[idx].blinkisFinish = ON ;
                }
            }
            else
            {
                if(blinker[idx].isOn)
                    blinker[idx].blinkCount++;
                blinker[idx].blinkStartTime = HAL_GetTick();
                blinker[idx].resetStartTime = HAL_GetTick();
                blinker[idx].isOn ^= ON;
                if(blinker[idx].blinkRestSpec > 0) //had rest case
                  blinker[idx].blinkisFinish = OFF ;
            }
        }
    }

    /*
        Flick timer process
    */
    for(int idx=0;idx<FLICKER_COUNT;idx++)
    {
        if((HAL_GetTick() - flicker[idx].StartTime) > (flicker[idx].isOn ? flicker[idx].OnSpec : flicker[idx].OffSpec))
        {
          flicker[idx].StartTime = HAL_GetTick();
          flicker[idx].isOn ^= ON;
        }
    }


    /*
        Breathe timer process
    */
    if(breathe.isUp)
    {
        breathe.countPause = 0;
        breathe.countDown = breathe.timeDown;
        if(++breathe.countUp >= breathe.timeUp)
          breathe.isUp = OFF;

        breathe.duty[0] = breathe.RGB[0]*breathe.countUp/breathe.timeUp;
        breathe.duty[1] = breathe.RGB[1]*breathe.countUp/breathe.timeUp;
        breathe.duty[2] = breathe.RGB[2]*breathe.countUp/breathe.timeUp;
        breathe.duty[3] = breathe.RGB[3]*breathe.countUp/breathe.timeUp;
    }
    else
    {
        breathe.countUp = 1000*BREATHE_LED_LOW_BOUNDARY/breathe.timeDown;
        if(breathe.countDown <= 1000*BREATHE_LED_LOW_BOUNDARY/breathe.timeDown)
        {
            //if(++breathe.countPause>250)   //breathe ON->oFF need delay nedd Uncomment annotations
                breathe.isUp = ON;
        }
        else
        {
          if(breathe.countDown > 1000*BREATHE_LED_LOW_BOUNDARY/breathe.timeDown)
            breathe.countDown -=1;
        }

        breathe.duty[0] = breathe.RGB[0]*breathe.countDown/breathe.timeDown;
        breathe.duty[1] = breathe.RGB[1]*breathe.countDown/breathe.timeDown;
        breathe.duty[2] = breathe.RGB[2]*breathe.countDown/breathe.timeDown;
        breathe.duty[3] = breathe.RGB[3]*breathe.countDown/breathe.timeDown;
    }

    osDelay(1);
  }
  /* USER CODE END StartTimeoutTask */
}

#ifdef FUNC_ENABLE_USART1_RFID
/* USER CODE BEGIN Header_StartRfidTask */
/**
* @brief Function implementing the rfidTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartRfidTask */
void StartRfidTask(void const * argument)
{
  /* USER CODE BEGIN StartRfidTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    IdleUntilReadAllMemory();
#endif

  //rrfid
  uint8_t cardType = 0;
  uint8_t tmpBuf[32];
  uint8_t tx[UART_BUFFER_SIZE>>4];
  uint8_t tx_len;

  HAL_GPIO_WritePin(OUT_RFID_Reset_GPIO_Port, OUT_RFID_Reset_Pin, GPIO_PIN_SET);

  /* Infinite loop */
  for(;;)
  {
    // Read card SN
    if(!Charger.rfid.op_bits.reqHalt && !Charger.rfid.op_bits.reqBlockRead)
    {
      switch(cardType)
      {
        case 0x00:
            tx_len = 4;
            tx[0] = tx_len - 0x01;
            tx[1] = RFID_CMD_REQUEST_SN_14443A;
            tx[2] = 0x01;
            tx[3] = rfidCheckSumCal(tx, tx_len-1);
            cardType++;
            break;
        case 0x01:
            tx_len = 5;
            tx[0] = tx_len - 0x01;
            tx[1] = RFID_CMD_REQUEST_SN_14443B;
            tx[2] = 0x00;
            tx[3] = 0x00;
            tx[4] = rfidCheckSumCal(tx, tx_len-1);
            cardType++;
            break;
        case 0x02:
            tx_len = 9;
            tx[0] = tx_len - 0x01;
            tx[1] = RFID_CMD_REQUEST_SN_FELICA;
            tx[2] = 0x06;
            tx[3] = 0x00;
            tx[4] = 0xff;
            tx[5] = 0xff;
            tx[6] = 0x01;
            tx[7] = 0x00;
            tx[8] = rfidCheckSumCal(tx, tx_len-1);
            cardType++;
            break;
        default:
            cardType = 0;
            break;
      }

      HAL_UART_Transmit(&RFID_USART, (uint8_t *)tx, tx_len, 0xffff);
      osDelay(100);
    }

    if(Charger.rfid.op_bits.reqHalt)
    {
      tx_len = 3;
      tx[0] = tx_len - 0x01;
      tx[1] = RFID_CMD_HALT_14443A;
      tx[2] = rfidCheckSumCal(tx, tx_len-1);
      HAL_UART_Transmit(&RFID_USART, (uint8_t *)tx, tx_len, 0xffff);
      osDelay(100);
    }

    if(Charger.rfid.op_bits.reqBlockRead)
    {
        tx_len = 0x0b;
        tx[0] = tx_len - 0x01;
        tx[1] = RFID_CMD_BLOCK_READ;
        tx[2] = Charger.rfid.keyType;
        tx[3] = Charger.rfid.targetBlock;
        tx[4] = Charger.rfid.key[0];
        tx[5] = Charger.rfid.key[1];
        tx[6] = Charger.rfid.key[2];
        tx[7] = Charger.rfid.key[3];
        tx[8] = Charger.rfid.key[4];
        tx[9] = Charger.rfid.key[5];
        tx[10] = rfidCheckSumCal(tx, tx_len-1);
        HAL_UART_Transmit(&RFID_USART, (uint8_t *)tx, tx_len, 0xffff);
        osDelay(100);
    }

    // RFID module feedback process
    if(UART_RFID_recv_end_flag == ON)
    {
        if((rfidCheckSumCal(UART_RFID_rx_buffer, UART_RFID_rx_buffer[0]) == UART_RFID_rx_buffer[UART_RFID_rx_buffer[0]]) && (Charger.Mode != MODE_INITIAL) && (Charger.Mode != MODE_ALARM))
        {
            switch(UART_RFID_rx_buffer[1])
            {
                case RFID_CMD_LED:
                  break;
                case RFID_CMD_REQUEST_SN_14443A:
                  if(UART_RFID_rx_buffer[0] == 9)
                  {
                      Charger.rfid.snType = RFID_SN_TYPE_4BYTE;
                      memset(&Charger.rfid.data_Sn[0], 0x00, ARRAY_SIZE(Charger.rfid.data_Sn));
                      for(uint8_t idx=0;idx<16;idx++)
                      {
                         if(idx<4)
                         {
                             Charger.rfid.data_Sn[idx] = UART_RFID_rx_buffer[idx+2];
                         }
                         else
                         {
                             Charger.rfid.data_Sn[idx] = 0x00;
                         }
                      }

                      if(isMode(MODE_IDLE))
                      {
                          memset(&Charger.rfid.currentCard[0], 0x00, ARRAY_SIZE(Charger.rfid.currentCard));
                      }
                      if(Charger.memory.EVSE_Config.data.item.RFID_SN_Endian)
                      {
                          DEBUG_INFO("RFID SN: %02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
                          sprintf((char *)tmpBuf, "%02X%02X%02X%02X", Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
                          memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));
                      }
                      else
                      {
                          DEBUG_INFO("RFID SN: %02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3]);
                          sprintf((char *)tmpBuf, "%02X%02X%02X%02X", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3]);
                          memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));
                      }
                  }
                  else if(UART_RFID_rx_buffer[0] == 0x0c)
                  {
                      Charger.rfid.snType = RFID_SN_TYPE_7BYTE;
                      memset(&Charger.rfid.data_Sn[0], 0x00, ARRAY_SIZE(Charger.rfid.data_Sn));
                      for(uint8_t idx=0;idx<16;idx++)
                      {
                         if(idx<7)
                         {
                             Charger.rfid.data_Sn[idx] = UART_RFID_rx_buffer[idx+2];
                         }
                         else
                         {
                             Charger.rfid.data_Sn[idx] = 0x00;
                         }
                      }

                      if(isMode(MODE_IDLE))
                      {
                          memset(&Charger.rfid.currentCard[0], 0x00, ARRAY_SIZE(Charger.rfid.currentCard));
                      }
                      if(Charger.memory.EVSE_Config.data.item.RFID_SN_Endian)
                      {
                          DEBUG_INFO("RFID SN: %02X%02X%02X%02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[6], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
                          sprintf((char *)tmpBuf, "%02X%02X%02X%02X%02X%02X%02X", Charger.rfid.data_Sn[6], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
                          memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));
                      }
                      else
                      {
                          DEBUG_INFO("RFID SN: %02X%02X%02X%02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[6]);
                          sprintf((char *)tmpBuf, "%02X%02X%02X%02X%02X%02X%02X", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[6]);
                          memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));
                      }
                  }

                  //PH
                  if (Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_PH )
                  {
                    if(UART_RFID_rx_buffer[0] >= 9)
                    {
                        if(isMode(MODE_IDLE))
                        {
                            if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
                            {
                                Charger.rfid.targetBlock = 0x02;
                                Charger.rfid.keyType = 0x00;
                                memset(&Charger.rfid.key[0], 0xff, 6);
                                Charger.rfid.op_bits.reqBlockRead = ON;
                                //control in RFID_CMD_BLOCK_READ to Valid_RFID_SN
                            }
                        }
                        else if(isMode(MODE_CHARGING) || isMode(MODE_STOP))
                        {
                            if ((Array_data_Check(Charger.rfid.currentCard,Charger.rfid.nowCard))&&(Charger.cycle_info.StartType != START_METHOD_BLE))
                            {
                                if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
                                {
                                    Charger.rfid.op_bits.reqStop = ON;
                                    setLedMotion(LED_ACTION_RFID_PASS);
                                    Charger.speaker.motion = SPEAKER_SHORT;
                                    timerEnable(TIMER_IDX_LED_TEMP, 3000);
                                }
                                DEBUG_WARN("reqStop = ON.\r\n");
                            }
                            else
                            {
                                if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
                                {
                                  setLedMotion(LED_ACTION_RFID_FAIL);
                                  Charger.speaker.motion = SPEAKER_BLINK;
                                  blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
                                  timerEnable(TIMER_IDX_LED_TEMP, 3000);
                                }
                                DEBUG_WARN("reqStop = Fail\r\n");
                            }
                            Charger.rfid.op_bits.reqHalt = ON;
                            Charger.rfid.op_bits.reqBlockRead = OFF;
                        }
                    }
                  }
                  //White List
                  else if (Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_LOCAL_LIST)
                  {
                      DEBUG_WARN("OfflinePolicy is White List\r\n");
                  }
                  //Free
                  else if (Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_FREE)
                  {
                        Charger.rfid.op_bits.reqHalt = ON;
                        Charger.rfid.op_bits.reqBlockRead = OFF;
                        if(isMode(MODE_IDLE))
                        {
                            for(uint8_t idx=0;idx<16;idx++)
                            {
                                  Charger.rfid.currentCard[idx] = Charger.rfid.data_Sn[idx];
                            }

                            Charger.rfid.op_bits.reqStart = ON;
                            memcpy(&Charger.rfid.currentCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));
                            if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
                              setLedMotion(LED_ACTION_RFID_PASS);
                              Charger.speaker.motion = SPEAKER_SHORT;
                              timerEnable(TIMER_IDX_LED_TEMP, 3000);
                            }
                            DEBUG_WARN("RFID authorize pass.\r\n");
                        }
                        else if(isMode(MODE_CHARGING) || isMode(MODE_STOP))
                        {
                            DEBUG_WARN("RFID authorize pass.\r\n");
                            if (Array_data_Check(Charger.rfid.currentCard,Charger.rfid.nowCard))
                            {
                              Charger.rfid.op_bits.reqStop = ON;
                              if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
                                setLedMotion(LED_ACTION_RFID_PASS);
                                Charger.speaker.motion = SPEAKER_SHORT;
                                timerEnable(TIMER_IDX_LED_TEMP, 3000);
                              }
                              DEBUG_WARN("reqStop = ON.\r\n");
                            }
                            else
                            {
                              if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
                                setLedMotion(LED_ACTION_RFID_FAIL);
                                Charger.speaker.motion = SPEAKER_BLINK;
                                blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
                                timerEnable(TIMER_IDX_LED_TEMP, 3000);
                              }
                              DEBUG_WARN("reqStop = Fail\r\n");
                            }
                        }
                  }
                  //NO charger
                  else // Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_NO_CHARGING
                  {
                        setLedMotion(LED_ACTION_RFID_FAIL);
                        Charger.speaker.motion = SPEAKER_BLINK;
                        blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
                        timerEnable(TIMER_IDX_LED_TEMP, 3000);

                        Charger.rfid.op_bits.reqHalt = ON;
                        Charger.rfid.op_bits.reqBlockRead = OFF;
                        DEBUG_WARN("It is RFID NO charger mode \r\n");
                  }

                  break;
                case RFID_CMD_REQUEST_SN_14443B:
                    if(UART_RFID_rx_buffer[1] == RFID_CMD_REQUEST_SN_14443B)
                    {
                        Charger.rfid.snType = RFID_SN_TYPE_14443B;
                        memset(&Charger.rfid.data_Sn[0], 0x00, ARRAY_SIZE(Charger.rfid.data_Sn));
                        for(uint8_t idx=0;idx<16;idx++)
                        {
                            if(idx<13)
                            {
                                Charger.rfid.data_Sn[idx] = UART_RFID_rx_buffer[idx+2];
                            }
                        }

                        if(isMode(MODE_IDLE))
                            memset(&Charger.rfid.nowCard[0], 0x00, ARRAY_SIZE(Charger.rfid.nowCard));
                        if(Charger.memory.EVSE_Config.data.item.RFID_SN_Endian)
                        {
                            DEBUG_INFO("RFID SN: %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[12], Charger.rfid.data_Sn[11], Charger.rfid.data_Sn[10], Charger.rfid.data_Sn[9], Charger.rfid.data_Sn[8], Charger.rfid.data_Sn[7], Charger.rfid.data_Sn[6], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
                            sprintf((char *)tmpBuf, "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", Charger.rfid.data_Sn[12], Charger.rfid.data_Sn[11], Charger.rfid.data_Sn[10], Charger.rfid.data_Sn[9], Charger.rfid.data_Sn[8], Charger.rfid.data_Sn[7], Charger.rfid.data_Sn[6], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
                            memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.nowCard));
                        }
                        else
                        {
                            DEBUG_INFO("RFID SN: %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[6], Charger.rfid.data_Sn[7], Charger.rfid.data_Sn[8], Charger.rfid.data_Sn[9], Charger.rfid.data_Sn[10], Charger.rfid.data_Sn[11], Charger.rfid.data_Sn[12]);
                            sprintf((char *)tmpBuf, "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[6], Charger.rfid.data_Sn[7], Charger.rfid.data_Sn[8], Charger.rfid.data_Sn[9], Charger.rfid.data_Sn[10], Charger.rfid.data_Sn[11], Charger.rfid.data_Sn[12]);
                            memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.nowCard));
                        }
                    }

                    //White List
                    if (Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_LOCAL_LIST)
                    {
                          DEBUG_WARN("OfflinePolicy is White List\r\n");
                    }
                    //Free
                    else if (Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_FREE)
                    {
                          Charger.rfid.op_bits.reqHalt = ON;
                          Charger.rfid.op_bits.reqBlockRead = OFF;
                          if(isMode(MODE_IDLE))
                          {
                              for(uint8_t idx=0;idx<16;idx++)
                              {
                                    Charger.rfid.currentCard[idx] = Charger.rfid.data_Sn[idx];
                              }

                              Charger.rfid.op_bits.reqStart = ON;
                              memcpy(&Charger.rfid.currentCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));
                              if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
                                setLedMotion(LED_ACTION_RFID_PASS);
                                Charger.speaker.motion = SPEAKER_SHORT;
                                timerEnable(TIMER_IDX_LED_TEMP, 3000);
                              }
                              DEBUG_WARN("RFID authorize pass.\r\n");
                          }
                          else if(isMode(MODE_CHARGING) || isMode(MODE_STOP))
                          {
                              DEBUG_WARN("RFID authorize pass.\r\n");
                              if (Array_data_Check(Charger.rfid.currentCard,Charger.rfid.nowCard))
                              {
                                Charger.rfid.op_bits.reqStop = ON;
                                if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
                                  setLedMotion(LED_ACTION_RFID_PASS);
                                  Charger.speaker.motion = SPEAKER_SHORT;
                                  timerEnable(TIMER_IDX_LED_TEMP, 3000);
                                }
                                DEBUG_WARN("reqStop = ON.\r\n");
                              }
                              else
                              {
                                if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
                                  setLedMotion(LED_ACTION_RFID_FAIL);
                                  Charger.speaker.motion = SPEAKER_BLINK;
                                  blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
                                  timerEnable(TIMER_IDX_LED_TEMP, 3000);
                                }
                                DEBUG_WARN("reqStop = Fail\r\n");
                              }
                          }
                    }
                    //NO charger
                    else // Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_NO_CHARGING
                    {
                          setLedMotion(LED_ACTION_RFID_FAIL);
                          Charger.speaker.motion = SPEAKER_BLINK;
                          blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
                          timerEnable(TIMER_IDX_LED_TEMP, 3000);

                          Charger.rfid.op_bits.reqHalt = ON;
                          Charger.rfid.op_bits.reqBlockRead = OFF;
                          DEBUG_WARN("It is RFID NO charger mode \r\n");
                    }
                    break;
                case RFID_CMD_REQUEST_SN_FELICA:
                    if(UART_RFID_rx_buffer[1] == RFID_CMD_REQUEST_SN_FELICA)
                    {
                        Charger.rfid.snType = RFID_SN_TYPE_FELICA;
                        memset(&Charger.rfid.data_Sn[0], 0x00, ARRAY_SIZE(Charger.rfid.data_Sn));
                        for(uint8_t idx=0;idx<16;idx++)
                        {
                            if(idx<6)
                            {
                                Charger.rfid.data_Sn[idx] = UART_RFID_rx_buffer[idx+6];
                            }
                        }

                        if(isMode(MODE_IDLE))
                            memset(&Charger.rfid.nowCard[0], 0x00, ARRAY_SIZE(Charger.rfid.nowCard));
                        if(Charger.memory.EVSE_Config.data.item.RFID_SN_Endian)
                        {
                            DEBUG_INFO("RFID SN: %02X%02X%02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
                            sprintf((char *)tmpBuf, "%02X%02X%02X%02X%02X%02X", Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
                            memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.nowCard));
                        }
                        else
                        {
                            DEBUG_INFO("RFID SN: %02X%02X%02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[5]);
                            sprintf((char *)tmpBuf, "%02X%02X%02X%02X%02X%02X", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[5]);
                            memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.nowCard));
                        }
                    }

                    //White List
                    if (Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_LOCAL_LIST)
                    {
                          DEBUG_WARN("OfflinePolicy is White List\r\n");
                    }
                    //Free
                    else if (Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_FREE)
                    {
                          Charger.rfid.op_bits.reqHalt = ON;
                          Charger.rfid.op_bits.reqBlockRead = OFF;
                          if(isMode(MODE_IDLE))
                          {
                              for(uint8_t idx=0;idx<16;idx++)
                              {
                                    Charger.rfid.currentCard[idx] = Charger.rfid.data_Sn[idx];
                              }

                              Charger.rfid.op_bits.reqStart = ON;
                              memcpy(&Charger.rfid.currentCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));
                              if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
                                setLedMotion(LED_ACTION_RFID_PASS);
                                Charger.speaker.motion = SPEAKER_SHORT;
                                timerEnable(TIMER_IDX_LED_TEMP, 3000);
                              }
                              DEBUG_WARN("RFID authorize pass.\r\n");
                          }
                          else if(isMode(MODE_CHARGING) || isMode(MODE_STOP))
                          {
                              DEBUG_WARN("RFID authorize pass.\r\n");
                              if (Array_data_Check(Charger.rfid.currentCard,Charger.rfid.nowCard))
                              {
                                Charger.rfid.op_bits.reqStop = ON;
                                if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
                                  setLedMotion(LED_ACTION_RFID_PASS);
                                  Charger.speaker.motion = SPEAKER_SHORT;
                                  timerEnable(TIMER_IDX_LED_TEMP, 3000);
                                }
                                DEBUG_WARN("reqStop = ON.\r\n");
                              }
                              else
                              {
                                if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
                                  setLedMotion(LED_ACTION_RFID_FAIL);
                                  Charger.speaker.motion = SPEAKER_BLINK;
                                  blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
                                  timerEnable(TIMER_IDX_LED_TEMP, 3000);
                                }
                                DEBUG_WARN("reqStop = Fail\r\n");
                              }
                          }
                    }
                    //NO charger
                    else // Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_NO_CHARGING
                    {
                          setLedMotion(LED_ACTION_RFID_FAIL);
                          Charger.speaker.motion = SPEAKER_BLINK;
                          blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
                          timerEnable(TIMER_IDX_LED_TEMP, 3000);

                          Charger.rfid.op_bits.reqHalt = ON;
                          Charger.rfid.op_bits.reqBlockRead = OFF;
                          DEBUG_WARN("It is RFID NO charger mode \r\n");
                    }
                    osDelay(1000);
                    break;

                case RFID_CMD_BLOCK_READ:
                  if(UART_RFID_rx_buffer[1] == RFID_CMD_BLOCK_READ)
                  {
                    memcpy(Charger.rfid.data_Block, &UART_RFID_rx_buffer[2], 0x10);
                    Charger.rfid.op_bits.reqHalt = ON;
                    Charger.rfid.op_bits.reqBlockRead = OFF;

                    //RFID_PH
                    if(Valid_RFID_SN())
                    {
                        if(isMode(MODE_IDLE))
                        {
                            Charger.rfid.op_bits.reqStart = ON;
                            setLedMotion(LED_ACTION_RFID_PASS);
                            Charger.speaker.motion = SPEAKER_SHORT;
                            timerEnable(TIMER_IDX_LED_TEMP, 3000);
                            memcpy(&Charger.rfid.currentCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));                        }
                        else if(isMode(MODE_CHARGING) || isMode(MODE_STOP))
                        {
                            Charger.rfid.op_bits.reqStop = ON;
                        }
                        DEBUG_WARN("RFID authorize pass.\r\n");
                    }
                    else
                    {
                        setLedMotion(LED_ACTION_RFID_FAIL);
                        Charger.speaker.motion = SPEAKER_BLINK;
                        blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
                        timerEnable(TIMER_IDX_LED_TEMP, 3000);
                        DEBUG_WARN("RFID authorize fault.\r\n");
                    }
                  }
                  break;
                case RFID_CMD_BLOCK_WRITE:
                  break;
                case RFID_CMD_HALT_14443A:
                  if(UART_RFID_rx_buffer[1] == RFID_CMD_HALT_14443A)
                  {
                      Charger.rfid.op_bits.reqHalt = OFF;
                      DEBUG_INFO("RFID card(14443A) halt succcess.\r\n");
                  }
                  break;
                case RFID_CMD_HALT_14443B:
                  if(UART_RFID_rx_buffer[1] == RFID_CMD_HALT_14443B)
                  {
                      Charger.rfid.op_bits.reqHalt = OFF;
                      DEBUG_INFO("RFID card(14443B) halt succcess.\r\n");
                  }
                  break;
                case (RFID_CMD_BLOCK_READ ^ 0xff):
                    Charger.rfid.op_bits.reqBlockRead = OFF;
                    DEBUG_WARN("RFID cread block fail.\r\n");
                    break;
                default:
                  break;
            }
        }

        // Clear rx_buffer and related varaible
        for(uint16_t i = 0; i < UART_RFID_rx_len ; i++)
            UART_RFID_rx_buffer[i]=0;

        UART_RFID_rx_len = 0;
        UART_RFID_recv_end_flag = OFF;
    }
    HAL_UART_Receive_DMA(&RFID_USART,(uint8_t*)UART_RFID_rx_buffer, (UART_BUFFER_SIZE>>4));

    osDelay(300);
  }
  /* USER CODE END StartRfidTask */
}

#endif //FUNC_ENABLE_USART1_RFID

/* USER CODE BEGIN Header_StartLedSpeakerTask */
/**
* @brief Function implementing the led_speakerTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartLedSpeakerTask */
void StartLedSpeakerTask(void const * argument)
{
  /* USER CODE BEGIN StartLedSpeakerTask */
//#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
//    IdleUntilReadAllMemory();
//#endif

  uint16_t    led_pwm_duty_now[4];
  uint16_t    breathe_duty_now[4];

  //standard default
  for(uint8_t idx=0;idx<12;idx++)
    Charger.Led_Brightness[idx] = 0x33;

  /*
  //Night mode starndard default brightness
  Charger.Led_Brightness[0] = 0x11;     //00:00~ 01:59
  Charger.Led_Brightness[1] = 0x11;     //02:00~ 03:59
  Charger.Led_Brightness[2] = 0x11;     //04:00~ 05:59
  Charger.Led_Brightness[3] = 0x33;     //06:00~ 07:59
  Charger.Led_Brightness[4] = 0x33;     //08:00~ 09:59
  Charger.Led_Brightness[5] = 0x33;     //10:00~ 11:59
  Charger.Led_Brightness[6] = 0x33;     //12:00~ 13:59
  Charger.Led_Brightness[7] = 0x33;     //14:00~ 15:59
  Charger.Led_Brightness[8] = 0x33;     //16:00~ 17:59
  Charger.Led_Brightness[9] = 0x11;     //18:00~ 19:59
  Charger.Led_Brightness[10] = 0x11;    //20:00~ 21:59
  Charger.Led_Brightness[11] = 0x11;    //22:00~ 23:59
  */

  /* Infinite loop */
  for(;;)
  {
    led_pwm_duty_now[0] = getBrightnessDuty(Charger.led_pwm_duty[0]);
    led_pwm_duty_now[1] = getBrightnessDuty(Charger.led_pwm_duty[1]);
    led_pwm_duty_now[2] = getBrightnessDuty(Charger.led_pwm_duty[2]);
    led_pwm_duty_now[3] = getBrightnessDuty(Charger.led_pwm_duty[3]);

    breathe_duty_now[0] = getBrightnessDuty(breathe.duty[0]);
    breathe_duty_now[1] = getBrightnessDuty(breathe.duty[1]);
    breathe_duty_now[2] = getBrightnessDuty(breathe.duty[2]);
    breathe_duty_now[3] = getBrightnessDuty(breathe.duty[3]);

    if(timer[TIMER_IDX_LED_TEMP].isAlarm)
    {
        timerDisable(TIMER_IDX_LED_TEMP);
        setLedMotion(Charger.Led_Mode);
    }

    /*
     LED red process
    */
    switch(Charger.led_R.motion)
    {
        case LED_MOTION_ON:
            user_pwm_setvalue(PWM_CH_LED_R, led_pwm_duty_now[0]);
            break;
        case LED_MOTION_BLINK:
            if(blinker[BLINKER_IDX_LED].isOn)
            {
                user_pwm_setvalue(PWM_CH_LED_R, led_pwm_duty_now[0]);
            }
            else
            {
                user_pwm_setvalue(PWM_CH_LED_R, PWM_DUTY_OFF);
            }
            break;
        case LED_MOTION_BREATHE:
            user_pwm_setvalue(PWM_CH_LED_R, breathe_duty_now[0]);
            break;
        case LED_MOTION_OFF:
        default:
            user_pwm_setvalue(PWM_CH_LED_R, PWM_DUTY_OFF);
            break;
    }

    /*
     LED green process
    */
    switch(Charger.led_G.motion)
    {
        case LED_MOTION_ON:
            user_pwm_setvalue(PWM_CH_LED_G, led_pwm_duty_now[1]);
            break;
        case LED_MOTION_BLINK:
            if(blinker[BLINKER_IDX_LED].isOn)
            {
                user_pwm_setvalue(PWM_CH_LED_G, led_pwm_duty_now[1]);
            }
            else
            {
                user_pwm_setvalue(PWM_CH_LED_G, PWM_DUTY_OFF);
            }
            break;
        case LED_MOTION_BREATHE:
            user_pwm_setvalue(PWM_CH_LED_G, breathe_duty_now[1]);
            break;
        case LED_MOTION_OFF:
        default:
            user_pwm_setvalue(PWM_CH_LED_G, PWM_DUTY_OFF);
            break;
    }

    /*
     LED blue process
    */
    switch(Charger.led_B.motion)
    {
        case LED_MOTION_ON:
            user_pwm_setvalue(PWM_CH_LED_B, led_pwm_duty_now[2]);
            break;
        case LED_MOTION_BLINK:
            if(blinker[BLINKER_IDX_LED].isOn)
            {
                user_pwm_setvalue(PWM_CH_LED_B, led_pwm_duty_now[2]);
            }
            else
            {
                user_pwm_setvalue(PWM_CH_LED_B, PWM_DUTY_OFF);
            }
            break;
        case LED_MOTION_BREATHE:
            user_pwm_setvalue(PWM_CH_LED_B, breathe_duty_now[2]);
            break;
        case LED_MOTION_OFF:
        default:
            user_pwm_setvalue(PWM_CH_LED_B, PWM_DUTY_OFF);
            break;
    }

    /*
     LED white process
    */
    switch(Charger.led_W.motion)
    {
        case LED_MOTION_ON:
            user_pwm_setvalue(PWM_CH_LED_W, led_pwm_duty_now[3]);
            break;
        case LED_MOTION_BLINK:
            if(blinker[BLINKER_IDX_LED].isOn)
            {
                user_pwm_setvalue(PWM_CH_LED_W, led_pwm_duty_now[3]);
            }
            else
            {
                user_pwm_setvalue(PWM_CH_LED_W, PWM_DUTY_OFF);
            }
            break;
        case LED_MOTION_BREATHE:
            user_pwm_setvalue(PWM_CH_LED_W, breathe_duty_now[3]);
            break;
        case LED_MOTION_OFF:
        default:
            user_pwm_setvalue(PWM_CH_LED_W, PWM_DUTY_OFF);
            break;
    }

#ifdef FUNC_AW48_NET_LED
    if (Charger.m_bModelNameAW48_1P)
    {
        //Net LED: Green
        switch (Charger.LedNet_G.motion)
        {
            case LED_MOTION_BREATHE:
            case LED_MOTION_ON:
                NETLED_SET_G(1);
                break;

            case LED_MOTION_BLINK:
                if(blinker[BLINKER_IDX_LED_NET].isOn)
                    NETLED_SET_G(1);
                else
                    NETLED_SET_G(0);
                break;
            case LED_MOTION_OFF:
            default:
                NETLED_SET_G(0);
                break;
        }
        //Net LED: Blue
        switch (Charger.LedNet_B.motion)
        {
            case LED_MOTION_BREATHE:
            case LED_MOTION_ON:
                NETLED_SET_B(1);
                break;

            case LED_MOTION_BLINK:
                if(blinker[BLINKER_IDX_LED_NET].isOn)
                    NETLED_SET_B(1);
                else
                    NETLED_SET_B(0);
                break;
            case LED_MOTION_OFF:
            default:
                NETLED_SET_B(0);
                break;
        }

    }
#endif //FUNC_AW48_NET_LED

    /*
     LED breathe process
    */
    if(flicker[FLICKER_IDX_BREATHE].isOn)
        HAL_GPIO_WritePin(OUT_LED_Breathe_GPIO_Port, OUT_LED_Breathe_Pin, GPIO_PIN_SET);
    else
        HAL_GPIO_WritePin(OUT_LED_Breathe_GPIO_Port, OUT_LED_Breathe_Pin, GPIO_PIN_RESET);

    /*
     Spearker process
    */
    switch(Charger.speaker.motion)
    {
        case SPEAKER_LONG:
          timerEnable(TIMER_IDX_SPEAKER, 600);
          HAL_GPIO_WritePin(OUT_Speaker_GPIO_Port, OUT_Speaker_Pin, GPIO_PIN_SET);

          if(timer[TIMER_IDX_SPEAKER].isAlarm)
          {
            timerDisable(TIMER_IDX_SPEAKER);
            Charger.speaker.motion = SPEAKER_NONE;
          }

          break;
        case SPEAKER_SHORT:
          timerEnable(TIMER_IDX_SPEAKER, 200);
          HAL_GPIO_WritePin(OUT_Speaker_GPIO_Port, OUT_Speaker_Pin, GPIO_PIN_SET);

          if(timer[TIMER_IDX_SPEAKER].isAlarm)
          {
            timerDisable(TIMER_IDX_SPEAKER);
            Charger.speaker.motion = SPEAKER_NONE;
          }

          break;
        case SPEAKER_BLINK:
          if(blinker[BLINKER_IDX_SPEAKER].isOn)
            HAL_GPIO_WritePin(OUT_Speaker_GPIO_Port, OUT_Speaker_Pin, GPIO_PIN_SET);
          else
            HAL_GPIO_WritePin(OUT_Speaker_GPIO_Port, OUT_Speaker_Pin, GPIO_PIN_RESET);

          if(blinker[BLINKER_IDX_SPEAKER].blinkisFinish)
          {
            disblinkerTime(BLINKER_IDX_SPEAKER);
          }
          break;
        case SPEAKER_NONE:
        default:
            HAL_GPIO_WritePin(OUT_Speaker_GPIO_Port, OUT_Speaker_Pin, GPIO_PIN_RESET);
            break;
    }

    osDelay(1);
  }
  /* USER CODE END StartLedSpeakerTask */
}

/* USER CODE BEGIN Header_StartCpTask */

#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
void CpTask_CtrlCpPwm_P0(void)
{
#ifdef FUNC_CCS //======================================================================
    uint16_t MaxCurr = Charger.memory.EVSE_Config.data.item.MaxChargingCurrent;

    if (Charger.m_bRunCCS) //CCS Charge
    {
        user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_5);
        Charger.MaxChargingCurrent_Previous = MaxCurr;
    }
    else //Normal Charge
    {
#ifdef FUNC_MODIFY_CP_PWM_CTRL_20231225
        if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU || Charger.m_bModelNameDC)
        {
            if ((MaxCurr >= 6) && (MaxCurr <= Charger.maxRatingCurrent))
            {
                user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(MaxCurr));
                Charger.MaxChargingCurrent_Previous = MaxCurr;
            }
            else
            {
                user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(Charger.maxRatingCurrent));
                Charger.MaxChargingCurrent_Previous = Charger.maxRatingCurrent;
            }
        }
        else
        {
            if ((Charger.AC_MaxChargingCurrentOrDuty >= 6) && (Charger.AC_MaxChargingCurrentOrDuty <= Charger.maxRatingCurrent))
            {
                user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(Charger.AC_MaxChargingCurrentOrDuty));
            }
            else
            {
                if (Charger.AC_MaxChargingCurrentOrDuty == 0)
                {
                    user_pwm_setvalue(PWM_CH_CP, 0);
                }
                else if (Charger.AC_MaxChargingCurrentOrDuty == 1)
                {
                    user_pwm_setvalue(PWM_CH_CP, 0);
                }
                else if (Charger.AC_MaxChargingCurrentOrDuty == 5)
                {
                    user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_5);
                }
                else if (Charger.AC_MaxChargingCurrentOrDuty == 100)
                {
                    user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
                }
                else
                {
                    user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
                }
            }
            Charger.MaxChargingCurrent_Previous = Charger.AC_MaxChargingCurrentOrDuty;
        }
#else //FUNC_MODIFY_CP_PWM_CTRL_20231225
        if ((MaxCurr >= 6) && (MaxCurr <= Charger.maxRatingCurrent))
        {
            user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(MaxCurr));
            Charger.MaxChargingCurrent_Previous = MaxCurr;
        }
        else
        {
            user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(Charger.maxRatingCurrent));
            Charger.MaxChargingCurrent_Previous = Charger.maxRatingCurrent;
        }
#endif //FUNC_MODIFY_CP_PWM_CTRL_20231225
    }
#else //FUNC_CCS //======================================================================
//    uint16_t MaxCurr = Charger.memory.EVSE_Config.data.item.MaxChargingCurrent;
//    if (MaxCurr < 6)
//    {
//#ifdef MODIFY_CP_TASK_CTRL_CP_PWM_BELOW_SIX
//        if (MaxCurr == 0)
//        {
//            user_pwm_setvalue(PWM_CH_CP, 0);
//            Charger.MaxChargingCurrent_Previous = MaxCurr;
//        }
//        else
//        {
//            user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(6));
//            Charger.MaxChargingCurrent_Previous = MaxCurr;
//        }
//#else //MODIFY_CP_TASK_CTRL_CP_PWM_BELOW_SIX
//        user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(6));
//        Charger.MaxChargingCurrent_Previous = MaxCurr;
//#endif //MODIFY_CP_TASK_CTRL_CP_PWM_BELOW_SIX
//    }
//    else if ((MaxCurr >= 6) && (MaxCurr <= Charger.maxRatingCurrent))
//    {
//        user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(MaxCurr));
//        Charger.MaxChargingCurrent_Previous = MaxCurr;
//    }
//    else
//    {
//        user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(Charger.maxRatingCurrent));
//        Charger.MaxChargingCurrent_Previous = Charger.maxRatingCurrent;
//    }
#endif //FUNC_CCS //======================================================================
}

void CpTask_CtrlCpPwm_P1(void)
{
#ifdef FUNC_DETECT_PP
    if (
            (Charger.m_bDetectPP && Charger.m_PPInfo.m_CurCurr != Charger.m_PPInfo.m_PreCurr)
            ||
            (
            (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent != Charger.MaxChargingCurrent_Previous) &&
            (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent <= Charger.maxRatingCurrent)
            )
        )
#else
    if (
            (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent != Charger.MaxChargingCurrent_Previous) &&
            (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent <= Charger.maxRatingCurrent)
        )
#endif
    {
        CpTask_CtrlCpPwm_P0();
    }
}
#endif //MODIFY_CP_TASK_CTRL_CP_PWM

#ifdef TRIM_CCID_SELFTEST
void Proc_CCID_SelfTest(void)
{
    // check Leak Module do CCID selftset.
    if (Charger.CCID_Module_Type == CCID_MODULE_CORMEX)
    {
        Charger.Test_LeakModuleisPass = Test_LeakModule();
    }
    else if (Charger.CCID_Module_Type == CCID_MODULE_VAC)
    {
        Charger.Test_LeakModuleisPass  = PASS;
    }
    else
    {
        DEBUG_INFO("Did not judge Leak module can't self test  before charging.\r\n");
    }

    XP("Proc CCID Self-Test(%d): %s\r\n", Charger.CCID_Module_Type, Charger.Test_LeakModuleisPass == PASS ? "OK" : "[NG]");

}
#endif

#ifdef FUNC_AUTO_MODIFY_CCID_MODULE
uint8_t AutoModifyCCID(void)
{
    uint8_t old = Charger.CCID_Module_Type;
    if (Test_LeakModule() == PASS)
    {
        Charger.m_bCCID_MustModify = HTK_FALSE;
        Charger.m_CCID_ModuleTestOK = Charger.CCID_Module_Type;
        return PASS;
    }
    else
    {
        Charger.CCID_Module_Type = (Charger.CCID_Module_Type == CCID_MODULE_CORMEX ? CCID_MODULE_VAC : CCID_MODULE_CORMEX);
        XP("#AutoModifyCCID: %s\r\n", CCID_MODULE_TYPE_STR);
        if (Test_LeakModule() == PASS)
        {
            Charger.m_bCCID_MustModify = HTK_TRUE;
            Charger.m_CCID_ModuleTestOK = Charger.CCID_Module_Type;
            return PASS;
        }
        else
        {
            Charger.m_bCCID_MustModify = HTK_FALSE;
            Charger.m_CCID_ModuleTestOK = CCID_MODULE_UNKNOW;
            Charger.CCID_Module_Type = old;
            return FAIL;
        }
    }
}
#endif

#ifdef FUNC_AX32_USE_AS_1P_MODEL
#ifdef MODIFY_AX32_RUN_3P_OR_1P_AUTOMATIC_AFTER_GC5
HTK_BOOL AX32_Is_3PModel_Run1P(void)
{
    HTK_BOOL bRtn = HTK_FALSE;

    if (Charger.m_b3PhaseModel)
    {
        PMeterIC_ExtraInfo pEx = &Charger.m_MeterIcEx;

        int MaxVoltErr = 5000; //0.01V: 50V
        int MaxDegErr = 5;

        HTK_BOOL bCheckVolt3P =
            (
                abs(Charger.Voltage[1] - Charger.Voltage[0]) < MaxVoltErr &&
                abs(Charger.Voltage[2] - Charger.Voltage[0]) < MaxVoltErr &&
                abs(Charger.Voltage[2] - Charger.Voltage[1]) < MaxVoltErr
            );

        if (bCheckVolt3P)
        {
            //AC_PHASE_MODE_240_120_120_SEQ_OK(NG:Happen 1 times)
            if  (
                    HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[0]), 240, MaxDegErr) &&
                    HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[1]), 120, MaxDegErr) &&
                    HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[2]), 120, MaxDegErr)
                )
            {
                pEx->m_AcPhaseMode = AC_PHASE_MODE_240_120_120_SEQ_OK;
            }
            //AC_PHASE_MODE_120_120_240_SEQ_NG
            else if  (
                    HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[0]), 120, MaxDegErr) &&
                    HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[1]), 120, MaxDegErr) &&
                    HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[2]), 240, MaxDegErr)
                )
            {
                pEx->m_AcPhaseMode = AC_PHASE_MODE_120_120_240_SEQ_NG;
            }
            //AC_PHASE_MODE_360_360_360 (for RD test - L => L1, L2, L3)
            else if  (
                    HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[0]), 360, MaxDegErr) &&
                    HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[1]), 360, MaxDegErr) &&
                    HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[2]), 360, MaxDegErr)
                )
            {
                pEx->m_AcPhaseMode = AC_PHASE_MODE_360_360_360;
            }
            else
            {
                pEx->m_AcPhaseMode = AC_PHASE_MODE_UNKNOW;
            }
        }

        if (!bCheckVolt3P || pEx->m_AcPhaseMode == AC_PHASE_MODE_UNKNOW)
        {
            if (
                    (abs(Charger.Voltage[1] - Charger.Voltage[0]) < MaxVoltErr && abs(Charger.Voltage[2] - Charger.Voltage[0]) > MaxVoltErr)
                        ||
                    (abs(Charger.Voltage[1] - Charger.Voltage[0]) > MaxVoltErr && abs(Charger.Voltage[2] - Charger.Voltage[0]) < MaxVoltErr)
                )
            {
                //Conntect L1, L2 or L1, L3 ==> RUN 3P
                pEx->m_AcPhaseMode = AC_PHASE_MODE_UNKNOW;
            }
            else
            {
                pEx->m_AcPhaseMode = AC_PHASE_MODE_1P;
            }
        }


        if (
                Charger.m_bModelNameAX32_3P
#ifdef FUNC_AT32
            ||  Charger.m_bModelNameAT32_3P
#endif
            )
        {
#ifdef FUNC_AX32_AUTO_PHASE_WITHOUT_GENERATION_CODE
            if (pEx->m_AcPhaseMode == AC_PHASE_MODE_1P)
            {
                DEBUG_INFO("3P MODEL RUN 1P PROC <AUTO>\r\n");
                bRtn = HTK_TRUE;
            }
            else
            {
                DEBUG_INFO("3P MODEL RUN 3P PROC <AUTO>\r\n");
            }
#else //FUNC_AX32_AUTO_PHASE_WITHOUT_GENERATION_CODE
            if (Charger.memory.EVSE_Config.data.item.ModelName[11] >= '0' &&
                Charger.memory.EVSE_Config.data.item.ModelName[11] <= '4')
            {
                DEBUG_INFO("3P MODEL RUN 3P PROC (GEN_CODE == 0-4)\r\n");
            }
            else
            {
                if (pEx->m_AcPhaseMode == AC_PHASE_MODE_1P)
                {
                    DEBUG_INFO("3P MODEL RUN 1P PROC (GEN_CODE != 0-4 <AUTO>)\r\n");
                    bRtn = HTK_TRUE;
                }
                else
                {
                    DEBUG_INFO("3P MODEL RUN 3P PROC (GEN_CODE != 0-4 <AUTO>)\r\n");
                }
            }
#endif //FUNC_AX32_AUTO_PHASE_WITHOUT_GENERATION_CODE
        }
        else if (Charger.m_bModelNameDC)
        {
            DEBUG_INFO("3P MODEL RUN 3P PROC (DC Model)\r\n");
        }
        else
        {
            DEBUG_INFO("3P MODEL RUN 3P PROC\r\n");
        }
    }
    return bRtn;
}
#endif //MODIFY_AX32_RUN_3P_OR_1P_AUTOMATIC_AFTER_GC5
#endif //FUNC_AX32_USE_AS_1P_MODEL

//#ifdef FIXHW_AW48_CSU_EXIST_DELAY_CHECK
//void AW48_CheckCSU(void)
//{
//    if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
//    {
//        if (IS_CSU_MOUNTED)
//        {
//            parseVersionInfoFromModelname(); //Update_McuCtrlMode() included
//            if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_CSU)
//            {
//                XP("\r\nAW48_CheckCSU() >>> MCU_CONTROL_MODE_CSU (%d sec)\r\n", (HAL_GetTick() - Charger.m_BootTick) / 1000 );
//                setChargerMode(MODE_INITIAL);
//            }
//        }
//    }
//}
//
//void AW48_WaitCSU(u32 MaxTick)
//{
//    XP("AW48_WaitCSU(): Begin\r\n");
//    u32 TickBeg = HAL_GetTick();
//    while (1)
//    {
//        HAL_IWDG_Refresh(&hiwdg);
//        osDelay(100);
//        if (IS_CSU_MOUNTED)
//        {
//            XP("AW48_WaitCSU(): End <PinLO> <Tick: %d sec>\r\n", (HAL_GetTick() - TickBeg) / 1000); //Test: 27s
//            AW48_CheckCSU();
//            return;
//        }
//
//        if (HTK_IsTimeout(TickBeg, MaxTick))
//        {
//            XP("AW48_WaitCSU(): End <Timeout: %d sec>\r\n", MaxTick / 1000);
//            return;
//        }
//    }
//}
//
//#endif //FIXHW_AW48_CSU_EXIST_DELAY_CHECK

/**
* @brief Function implementing the cpTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartCpTask */
void StartCpTask(void const * argument)
{
  /* USER CODE BEGIN StartCpTask */

    //ccp
    uint32_t duration_delta;
    Charger.Mode = MODE_INITIAL;
    Charger.Relay_Action=GPIO_RELAY_ACTION_OFF;

    setLedMotion(LED_ACTION_INIT);

#ifdef FUNC_AW48_NET_LED
    if (Charger.m_bModelNameAW48_1P)
    {
        setNetLedMotion(Charger.am3352.NetLedActionState = NET_LED_ACTION_OFF);
    }
#endif

#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    IdleUntilReadAllMemory();
#endif

    //Check MCU control mode depend on GPIO state
#ifdef FUNC_FORCE_RUN_CSU_MODE_WITH_DC_MODELNAME
    Update_McuCtrlMode();
#endif
    HAL_GPIO_WritePin(OUT_StateE_GPIO_Port, OUT_StateE_Pin, GPIO_PIN_RESET);

#ifdef FUNC_AX32_TRIG_LEAKAGE
    if (Charger.m_b3PhaseModel)
    {
        TrigLeakage_Init();
    }
#endif

#ifdef FUNC_AX80_ADD_TILT_SENSOR
#ifdef FUNC_ADD_TILT_SENSOR_MODEL
    if (Charger.m_bUseTiltSensor)
#else
    if (Charger.m_bModelNameAX80_1P)
#endif
    {
        TILT_TrigLeakage_Init();
    }
#endif //FUNC_AX80_ADD_TILT_SENSOR

    /* Infinite loop */
    for(;;)
    {

        if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
        {
            //=============================( MODIFY_CPTASK_TYPE_E )==============================[ NO CSU ]
#ifdef MODIFY_CPTASK_HEAD
            Proc_CpTaskHead(HTK_FALSE);
#endif
            switch(Charger.Mode)
            {
                  case MODE_INITIAL:
                      //=============================( MODIFY_CPTASK_TYPE_E / MODE_INITIAL )
                        setLedMotion(LED_ACTION_INIT);
                        user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
                        HAL_GPIO_WritePin(OUT_Leak_Test_GPIO_Port, OUT_Leak_Test_Pin, GPIO_PIN_SET); // for VAC LeakModule use

                        if (Charger.ModelReadisOK ==PASS)
                        {
                          getRotarySwitchSetting( );
                          getGridTypeSwitchSetting( );
                          Charger.isTestLeakModule = ON ;

#ifdef FUNC_AUTO_MODIFY_CCID_MODULE
                          if (AutoModifyCCID() == PASS)
#else
                          if(Test_LeakModule() == PASS)
#endif
                          {
                              DEBUG_INFO("Leak module self test pass when initial.\r\n");
                              osDelay(1000);

                              if(Charger.isDebugEnable)
                                  setChargerMode(MODE_DEBUG);
                              else
                              {
                                  if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
                                    // Cold load pick up check
                                    if((Charger.CP_State == SYSTEM_STATE_A) && Charger.memory.coldLoadPickUp.data.item.isEnable)
                                    {
#ifndef FUNC_METER_IC_HISTORY
                                        recordChargingHis(OFF, END_STATUS_CODE_DROP);
#endif
                                        Charger.memory.coldLoadPickUp.data.item.isEnable = OFF;
                                        Charger.memory.coldLoadPickUp.op_bits.update = ON;
                                    }
                                  }
                                  osDelay(5000) ;                //wait hardware PE feedback data so delay some time

//#ifdef FIXHW_AW48_CSU_EXIST_DELAY_CHECK
//                                    if (Charger.m_bModelNameAW48_1P)
//                                    {
//                                        AW48_WaitCSU(1000 * 30);
//                                    }
//#endif
                                    setChargerMode(MODE_IDLE);

                              }
                          }
                          else
                          {
                              Charger.Alarm_Code |= ALARM_LEAK_MODULE_FAIL;
                              DEBUG_INFO("Leak module self test fail when initial.\r\n");
                              Charger.counter.LEAK_MODULE.isLatch = ON ;
                          }
                          Charger.isTestLeakModule = OFF ;
                        }

                    break;

                  case MODE_IDLE:
                      //=============================( MODIFY_CPTASK_TYPE_E / MODE_IDLE )
                    if(isModeChange())
                    {
                        setLedMotion(LED_ACTION_IDLE);
                        Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;

#ifdef MODIFY_CPTASK_TYPE_E
                        Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
                        Charger.m_OutpMode = OUTPMODE_NONE;
#endif
                        Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = Charger.maxRatingCurrent;

#ifdef MODIFY_AC_EVSE_STATUS_MAX_CHARGING_CURRENT_VARIABLE
                        Charger.AC_MaxChargingCurrentOrDuty = Charger.maxRatingCurrent;
#endif

                        user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
                        Charger.isSetStartTime = ON  ;
                        Charger.isOnSocketE = OFF;
#ifdef FUNC_CCS
                        Charger.m_bRunCCS = 0;
                        Charger.m_bGotCsuCpDutyCmd = 0;
#ifdef MODIFY_GOT_CSU_DUTY_CMD_PROCESS
                        Charger.m_bPassGotCsuCpDutyCmd = 0;
#endif
#endif //FUNC_CCS

#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
                        if (Charger.m_bUseGunLock)
                        {
                            Charger.m_GunLock_Counter = 0;
                            Charger.m_GunUnlock_Counter = 0;
                        }
#endif

#ifdef FUNC_PTB_METER_WM3M4C
                        if (Charger.m_pWM3M4C != NULL)
                        {
                            if (Charger.m_pWM3M4C->m_bCharging)
                            {
                                Charger.m_pWM3M4C->m_bTrigEndCharge = HTK_TRUE;
                            }
                        }
#endif

#ifdef FUNC_AX32_USE_AS_1P_MODEL
                        Charger.m_b3PhaseModelButUse1PhaseOnly = AX32_Is_3PModel_Run1P();
#endif
                    }

                    if (Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_OCPP)
                    {
                        if( Charger.memory.coldLoadPickUp.data.item.isEnable || Charger.rfid.op_bits.reqStart)
                        {
                            osDelay(LED_RFID_TIME);       // for Buzzer and RFID /Fail LED use
                            setLedMotion(LED_ACTION_AUTHED);
                            // Check start method type
                            memset(&Charger.cycle_info.userId[0], 0x00, ARRAY_SIZE(Charger.cycle_info.userId));

                            if(Charger.rfid.op_bits.reqStart)
                            {
                                Charger.cycle_info.StartType = START_METHOD_RFID;
                                memcpy(&Charger.cycle_info.userId[0], &Charger.rfid.currentCard[0], ARRAY_SIZE(Charger.rfid.currentCard));
                                Charger.istoHandShakeMode = ON ;
                            }
                            Charger.rfid.op_bits.reqStart = OFF;

                            if(Charger.memory.coldLoadPickUp.data.item.isEnable)
                            {
                                Charger.memory.coldLoadPickUp.data.item.isEnable = OFF;
                                Charger.memory.coldLoadPickUp.op_bits.update = ON;
                                DEBUG_INFO("coldLoadPickUp ON to rand wait sec.\r\n");

#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
                                ColdLoadPickup_Delay("coldLoadPickUp ON to rand wait sec.");
#else
                                osDelay((rand()%175000)+5000);
                                //osDelay((rand()%5000)+5000);
#endif
                                Charger.istoHandShakeMode = ON ;
                            }
                        }


                        if (Charger.istoHandShakeMode == ON) //charger can to HandShakeMode
                        {
                            if (
                                (Charger.CP_State == SYSTEM_STATE_B) ||
                                (Charger.CP_State == SYSTEM_STATE_C) ||
#ifdef MODIFY_CPTASK_TYPE_E
                                ((Charger.CP_State == SYSTEM_STATE_A) || IsTypeEPlugIn())
#else
                                //HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin)
#endif
                                )
                            {
#ifdef MODIFY_CPTASK_TYPE_E
                                if (Charger.CP_State == SYSTEM_STATE_B || Charger.CP_State == SYSTEM_STATE_C)
                                {
                                    Charger.m_OutpMode = OUTPMODE_CPGUN;
                                }
                                else if ((Charger.CP_State == SYSTEM_STATE_A) || IsTypeEPlugIn())
                                {
                                    Charger.m_OutpMode = OUTPMODE_TYPEE;
                                }
#endif
                                timerDisable(TIMER_IDX_CP);
                                Charger.istoHandShakeMode = OFF ;
                                setChargerMode(MODE_HANDSHAKE);
                            }
                            else
                            {
                              timerEnable(TIMER_IDX_CP, 180000);
                            }
                        }
                    }
                    else if (Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_FREE)
                    {
                        if (
                            (Charger.CP_State == SYSTEM_STATE_B) ||
                            (Charger.CP_State == SYSTEM_STATE_C) ||

#ifdef MODIFY_CPTASK_TYPE_E
                            (Charger.CP_State == SYSTEM_STATE_A && IsTypeEPlugIn()) ||
#endif
                            Charger.memory.coldLoadPickUp.data.item.isEnable )
                        {
                            setLedMotion(LED_ACTION_AUTHED);
                            // Check start method type
                            memset(&Charger.cycle_info.userId[0], 0x00, ARRAY_SIZE(Charger.cycle_info.userId));
                            if(Charger.rfid.op_bits.reqStart)
                            {
                                Charger.cycle_info.StartType = START_METHOD_RFID;
                                memcpy(&Charger.cycle_info.userId[0], &Charger.rfid.currentCard[0], ARRAY_SIZE(Charger.rfid.currentCard));
                            }
                            else
                            {
#ifdef MODIFY_CPTASK_TYPE_E
                                if (Charger.CP_State == SYSTEM_STATE_B ||
                                    Charger.CP_State == SYSTEM_STATE_C ||
                                    Charger.memory.coldLoadPickUp.data.item.isEnable)
                                {
                                    Charger.cycle_info.StartType = START_METHOD_CP;
                                    Charger.m_OutpMode = OUTPMODE_CPGUN;
                                }
                                else if (Charger.CP_State == SYSTEM_STATE_A && IsTypeEPlugIn())
                                {
                                    Charger.cycle_info.StartType = START_METHOD_TYPEE;
                                    Charger.m_OutpMode = OUTPMODE_TYPEE;
                                }
#else
                                Charger.cycle_info.StartType = START_METHOD_CP;
#endif //MODIFY_CPTASK_TYPE_E

                            }
                            Charger.ble.isRequestOn = OFF;
                            Charger.rfid.op_bits.reqStart = OFF;
                            if(Charger.memory.coldLoadPickUp.data.item.isEnable)
                            {
                                Charger.memory.coldLoadPickUp.data.item.isEnable = OFF;
                                Charger.memory.coldLoadPickUp.op_bits.update = ON;
                                DEBUG_INFO("coldLoadPickUp ON to rand wait sec.\r\n");
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
                                ColdLoadPickup_Delay("coldLoadPickUp ON to rand wait sec.");
#else
                                osDelay((rand()%175000)+5000);
#endif
                            }
                            setChargerMode(MODE_HANDSHAKE);
                        }
                    }
                    break;

                case MODE_HANDSHAKE:
                    //=============================( MODIFY_CPTASK_TYPE_E / MODE_HANDSHAKE )
                    if(isModeChange())
                    {
                        Charger.isCP_in_B = OFF ;
                        Charger.isTestLeakModule = ON ;
#ifdef TRIM_CCID_SELFTEST
                        Proc_CCID_SelfTest();
#endif
                        //check Leak test pass
                        if (Charger.Test_LeakModuleisPass)
                        {
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
                            CpTask_CtrlCpPwm_P0();
#endif
                            DEBUG_INFO("Leak module self test pass before charging.\r\n");
                        }
                        else
                        {
                            Charger.Alarm_Code |= ALARM_LEAK_MODULE_FAIL;
                            DEBUG_INFO("Leak module self test fail before charging.\r\n");
                            Charger.counter.LEAK_MODULE.retry ++ ;
                            if (Charger.counter.LEAK_MODULE.retry >=2)
                            {
                              Charger.counter.LEAK_MODULE.isLatch = ON ;
                            }
                        }

                        osDelay(300);

                        Charger.isTestLeakModule = OFF ;

                    }

                    // to chaging moder
                    if(Charger.CP_State == SYSTEM_STATE_C)
                    {
#ifdef MODIFY_CPTASK_TYPE_E
                        Charger.m_OutpMode = OUTPMODE_CPGUN;
#endif
                        setChargerMode(MODE_CHARGING);


                        if (Charger.isSetStartTime == ON)
                        {
                          Charger.cycle_info.startTimeTick = HAL_GetTick();
                          Charger.cycle_info.startDateTime.year = Charger.memory.EVSE_Config.data.item.SystemDateTime.year;
                          Charger.cycle_info.startDateTime.month = Charger.memory.EVSE_Config.data.item.SystemDateTime.month;
                          Charger.cycle_info.startDateTime.day = Charger.memory.EVSE_Config.data.item.SystemDateTime.day;
                          Charger.cycle_info.startDateTime.hour = Charger.memory.EVSE_Config.data.item.SystemDateTime.hour;
                          Charger.cycle_info.startDateTime.min = Charger.memory.EVSE_Config.data.item.SystemDateTime.min;
                          Charger.cycle_info.startDateTime.sec = Charger.memory.EVSE_Config.data.item.SystemDateTime.sec;
                          Charger.cycle_info.meterStart = Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total;
                        }
                    }

                    /*
                     *  TODO:
                     *  1. Check socket-E detect pin to determine charging mdoe
                     */
#ifdef MODIFY_CPTASK_TYPE_E
                    if (Charger.CP_State == SYSTEM_STATE_A && IsTypeEPlugIn())
#else
                    //if((Charger.CP_State == SYSTEM_STATE_A) && HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin))
#endif
                    {
                        Charger.isOnSocketE = ON;

#ifdef MODIFY_CPTASK_TYPE_E
                        Charger.m_OutpMode = OUTPMODE_TYPEE;
                        user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
#endif

                        setChargerMode(MODE_CHARGING);
                        if (Charger.isSetStartTime == ON)
                        {
                          Charger.cycle_info.startTimeTick = HAL_GetTick();
                          Charger.cycle_info.startDateTime.year = Charger.memory.EVSE_Config.data.item.SystemDateTime.year;
                          Charger.cycle_info.startDateTime.month = Charger.memory.EVSE_Config.data.item.SystemDateTime.month;
                          Charger.cycle_info.startDateTime.day = Charger.memory.EVSE_Config.data.item.SystemDateTime.day;
                          Charger.cycle_info.startDateTime.hour = Charger.memory.EVSE_Config.data.item.SystemDateTime.hour;
                          Charger.cycle_info.startDateTime.min = Charger.memory.EVSE_Config.data.item.SystemDateTime.min;
                          Charger.cycle_info.startDateTime.sec = Charger.memory.EVSE_Config.data.item.SystemDateTime.sec;
                          Charger.cycle_info.meterStart = Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total;
                        }
                    }

                    if(Charger.CP_State == SYSTEM_STATE_B)
                    {
                        Charger.isCP_in_B = ON ;
                        setLedMotion(LED_ACTION_CONNECTED);
                    }

                    //RFID remove gun
                    if ((Charger.cycle_info.StartType == START_METHOD_RFID) && (Charger.CP_State == SYSTEM_STATE_A) && (Charger.isCP_in_B == ON))
                    {
                        Charger.isCP_in_B = OFF ;
                        setChargerMode(MODE_IDLE);
                    }

                    //FREE remove gun
                    if ((Charger.cycle_info.StartType == START_METHOD_CP) && Charger.CP_State == SYSTEM_STATE_A)
                    {
                        setChargerMode(MODE_IDLE);
                    }

#ifdef MODIFY_CPTASK_TYPE_E
                    //Type E remove plug
                    if ((Charger.cycle_info.StartType == START_METHOD_TYPEE) && !IsTypeEPlugIn())
                    {
                        setChargerMode(MODE_IDLE);
                    }
#endif
                    break;

                case MODE_CHARGING:
                    //=============================( MODIFY_CPTASK_TYPE_E / MODE_CHARGING )
                    if(isModeChange())
                    {
#ifdef MODIFY_CPTASK_CSU_0_1_CHARGE_MODE
                        CpTask_CtrlCpPwm_P0();
#endif
                        setLedMotion(LED_ACTION_CHARGING);

#ifdef FUNC_PTB_METER_WM3M4C
                        if (Charger.m_pWM3M4C != NULL)
                        {
                            Charger.m_pWM3M4C->m_bTrigBegCharge = HTK_TRUE;
                        }
#endif
                    }

                    if (

#ifdef MODIFY_AW_CP_TASK_CSU_0_1_CHARGING_MODE_STOP_WITHOUT_STATE_C
                            (!Charger.isOnSocketE && Charger.CP_State!=SYSTEM_STATE_C) ||
#else
                            ((!Charger.isOnSocketE && Charger.CP_State!=SYSTEM_STATE_C) && (Charger.CP_State != SYSTEM_STATE_UNKNOWN)) ||
#endif

#ifdef MODIFY_CPTASK_TYPE_E
                            ((Charger.isOnSocketE) && !IsTypeEPlugIn()) ||
#else
                            //((Charger.isOnSocketE) && !HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin)) ||
#endif
                            ((Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_OCPP)?Charger.rfid.op_bits.reqStop:0)
                        )
                    {
                        setChargerMode(MODE_STOP);

                        Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;

#ifdef MODIFY_CPTASK_TYPE_E
                        Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
                    }
                    else
                    {
#ifdef MODIFY_CPTASK_TYPE_E
                        if (Charger.m_OutpMode == OUTPMODE_CPGUN && Charger.CP_State == SYSTEM_STATE_C)
                        {
                            Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
                        }
                        else if (Charger.m_OutpMode == OUTPMODE_TYPEE && Charger.isOnSocketE && IsTypeEPlugIn())
                        {
                            Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_ON;
                        }

#else
                        Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
#endif
                        duration_delta = (HAL_GetTick() - Charger.cycle_info.startTimeTick);
                        Charger.cycle_info.Duration = duration_delta;
                        Charger.cycle_info.Power_Consumption = Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total - Charger.cycle_info.meterStart;

#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
                        CpTask_CtrlCpPwm_P1();
#endif
                    }

                    break;

                case MODE_STOP:
                    //=============================( MODIFY_CPTASK_TYPE_E / MODE_STOP )
                    if(isModeChange())
                    {
                      if ((Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_OCPP) && Charger.rfid.op_bits.reqStop)
                      {
                        osDelay(LED_RFID_TIME);       // for Buzzer and RFID /Fail LED use
                      }

                      setLedMotion(LED_ACTION_STOP);
                      Charger.isCP_in_B = OFF ;
                      Charger.is_RFIDKeepCharger = ON ;
                      Charger.isSetStartTime = OFF ;
                    }

                    if (Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_OCPP)
                    {
                      //GB
                      if(Charger.CP_State == SYSTEM_STATE_A)
                      {
                          Charger.cycle_info.endTimeTick = HAL_GetTick();
#ifndef FUNC_METER_IC_HISTORY
                          recordChargingHis(OFF, END_STATUS_CODE_NORMAL);
#endif
                          Charger.rfid.op_bits.reqStop = OFF;
                          setChargerMode(MODE_IDLE);
                          Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
                          timerDisable(TIMER_IDX_RFID_RELAY_OFF);
                          Charger.isCP_in_B = OFF ;
                          Charger.is_RFIDKeepCharger = OFF ;
                          Charger.cycle_info.StartType = START_METHOD_NONE;
                      }
                      else
                      {
                          //rfid close PWM and relay
                          if ((Charger.rfid.op_bits.reqStop == ON)&&Charger.cycle_info.StartType == START_METHOD_RFID)
                          {
                              Charger.rfid.op_bits.reqStop = OFF;
                              user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);  // close pwm
                              timerEnable( TIMER_IDX_RFID_RELAY_OFF, 3000); //is set wait 3 sec
                              Charger.is_RFIDKeepCharger = OFF ;
                          }

                          if (timer[TIMER_IDX_RFID_RELAY_OFF].isAlarm == ON) //is wait 3 sec
                          {
                            timerDisable(TIMER_IDX_RFID_RELAY_OFF);
                            Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
                            Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
                            setChargerMode(MODE_IDLE);

                            Charger.cycle_info.StartType = START_METHOD_NONE;
                          }

                          //cp close or open PWM
                          if((Charger.CP_State == SYSTEM_STATE_B))
                          {
                              timerDisable(TIMER_IDX_RFID_RELAY_OFF);
                              Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
                              Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
                              Charger.isCP_in_B = ON ;
                          }
                          else if (Charger.CP_State == SYSTEM_STATE_C )
                          {
                              if ( Charger.isCP_in_B == ON && Charger.is_RFIDKeepCharger == ON)
                              {
                                Charger.is_RFIDKeepCharger = OFF ;
                                Charger.isCP_in_B = OFF ;
                                Charger.isTestLeakModule = ON ;
#ifdef TRIM_CCID_SELFTEST
                                Proc_CCID_SelfTest();
#endif
                                //check Leak test pass
                                if (Charger.Test_LeakModuleisPass)
                                {
                                    timerEnable(TIMER_IDX_CP, 180000);
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
                                    CpTask_CtrlCpPwm_P0();
#endif
                                    setChargerMode(MODE_CHARGING);
                                    DEBUG_INFO("Leak module self test pass before charging.\r\n");
                                }
                                else
                                {
                                    Charger.Alarm_Code |= ALARM_LEAK_MODULE_FAIL;
                                    DEBUG_INFO("Leak module self test fail before charging.\r\n");

                                    Charger.counter.LEAK_MODULE.retry ++ ;
                                    if (Charger.counter.LEAK_MODULE.retry >=2)
                                    {
                                      Charger.counter.LEAK_MODULE.isLatch = ON ;
                                    }
                                }
                                osDelay(300);
                                Charger.isTestLeakModule = OFF ;

                              }
                          }
                       }
                    }
                    else if (Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_FREE)
                    {
                      if (Charger.CP_State == SYSTEM_STATE_A)
                      {
                          Charger.cycle_info.endTimeTick = HAL_GetTick();
#ifndef FUNC_METER_IC_HISTORY
                          recordChargingHis(OFF, END_STATUS_CODE_NORMAL);
#endif
                          Charger.ble.isRequestOff = OFF;
                          Charger.rfid.op_bits.reqStop = OFF;
                          setChargerMode(MODE_IDLE);
                      }
                      else
                      {
                          if (Charger.CP_State == SYSTEM_STATE_B)
                          {
                              Charger.isCP_in_B = ON ;
                          }
                          if((Charger.CP_State == SYSTEM_STATE_C))
                          {
                              setChargerMode(MODE_CHARGING);
                          }
                      }
                    }
                    break;

                case MODE_ALARM:
                    //=============================( MODIFY_CPTASK_TYPE_E / MODE_ALARM )
                    if(isModeChange())
                    {
                      Charger.isSetStartTime = OFF ;
                      //clear blink time , Prevent red light from being snatched by others
                      disblinkerTime (BLINKER_IDX_LED) ;
                    }
                    Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
                    Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
                    //Set alarm led
                    if ((Charger.Alarm_Code != Charger.Alarm_Code_before) && (blinker[BLINKER_IDX_LED].blinkisFinish))
                    {
                        setLedMotion(LED_ACTION_ALARM);
                        Charger.Alarm_Code_before = Charger.Alarm_Code ;
                    }

#ifdef FUNC_MODE_ALARM_TO_MODE_DEBUG
                    if (Charger.isDebugEnable && Charger.Alarm_Code == 0)
                    {
                        setChargerMode(MODE_DEBUG);
                    }
                    else
#endif

                    if(Charger.Alarm_Code == 0x00)
                    {
                        Charger.Alarm_Code_before = Charger.Alarm_Code ;
                        if (Charger.Mode_Before_Alarm == MODE_CHARGING)       // in charging mode
                        {
                            if(Charger.CP_State == SYSTEM_STATE_A)      // to idle
                            {
                                Charger.cycle_info.endTimeTick = HAL_GetTick();
#ifndef FUNC_METER_IC_HISTORY
                                recordChargingHis(OFF, END_STATUS_CODE_NORMAL);
#endif
                                Charger.rfid.op_bits.reqStop = OFF;
                                Charger.ble.isRequestOff = OFF;
                                setChargerMode(MODE_IDLE);
                                Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
                                Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
                                timerDisable(TIMER_IDX_RFID_RELAY_OFF);
                                Charger.isCP_in_B = OFF ;
                                Charger.is_RFIDKeepCharger = OFF ;
                                Charger.cycle_info.StartType = START_METHOD_NONE;
                            }
                            else        // to handshake
                            {
                                setChargerMode(MODE_HANDSHAKE);
                                Charger.isCP_in_B = ON ;
                                setLedMotion(LED_ACTION_CONNECTED);
                            }
                        }
                        else if(Charger.Mode_Before_Alarm == MODE_STOP)  // in stop mode
                        {
                            if(Charger.CP_State == SYSTEM_STATE_A)  // to idle
                            {
                                Charger.cycle_info.endTimeTick = HAL_GetTick();
#ifndef FUNC_METER_IC_HISTORY
                                recordChargingHis(OFF, END_STATUS_CODE_NORMAL);
#endif
                                Charger.rfid.op_bits.reqStop = OFF;
                                setChargerMode(MODE_IDLE);
                                Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
                                Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
                                timerDisable(TIMER_IDX_RFID_RELAY_OFF);
                                Charger.isCP_in_B = OFF ;
                                Charger.is_RFIDKeepCharger = OFF ;
                                Charger.cycle_info.StartType = START_METHOD_NONE;
                            }
                            else if ((Charger.CP_State == SYSTEM_STATE_B) && (Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_OCPP)) // OCPP
                            {
                                if ( ( ((Charger.cycle_info.StartType == START_METHOD_BLE) && (Charger.is_BLEKeepCharger == ON))||               // to handshake
                                            ((Charger.cycle_info.StartType == START_METHOD_RFID) && (Charger.is_RFIDKeepCharger == ON)) ) &&
                                            ( Charger.isCP_in_B == ON ) )
                                {
                                    setChargerMode(MODE_HANDSHAKE);
                                    setLedMotion(LED_ACTION_CONNECTED);
                                }
                                else    //to stop
                                {
                                    setChargerMode(MODE_STOP);
                                }
                            }
                            else if ((Charger.CP_State == SYSTEM_STATE_B) && (Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_FREE)) //Free
                            {
                                if ( Charger.isCP_in_B == ON )  // to handshake
                                {
                                    setChargerMode(MODE_HANDSHAKE);
                                    setLedMotion(LED_ACTION_CONNECTED);
                                }
                                else    //to stop
                                {
                                    setChargerMode(MODE_STOP);
                                }
                            }
                            else    //to stop
                            {
                                setChargerMode(MODE_STOP);
                            }
                        }
                        else  // idle
                        {
                            if(timer[TIMER_IDX_STATE_E].isAlarm == ON)
                            {
                              setChargerMode(MODE_IDLE);
                            }
                        }
                    }
                    break;

                  case MODE_MAINTAIN:
                      //=============================( MODIFY_CPTASK_TYPE_E / MODE_MAINTAIN )
                        if(isModeChange())
                        {}
                        break;

                  case MODE_DEBUG:
                      //=============================( MODIFY_CPTASK_TYPE_E / MODE_DEBUG )
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
                        if(isModeChange())
                        {
                            setLedMotion(LED_ACTION_DEBUG);
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
                            timerEnable(TIMER_IDX_DEBUG, FUNC_MODE_DEBUG_RELAY_ON_SEC * 1000);
#else
                            timerEnable(TIMER_IDX_DEBUG, 2000);
#endif
                        }

                        if (timer[TIMER_IDX_DEBUG].isAlarm &&
                            Charger.Alarm_Code == 0 &&
                            Charger.CP_State == SYSTEM_STATE_C)
                        {
                            if (Charger.Relay_Action == GPIO_RELAY_ACTION_ON)
                            {
                                Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
                                timerRefresh(TIMER_IDX_DEBUG);
                                timerEnable(TIMER_IDX_DEBUG, FUNC_MODE_DEBUG_RELAY_OFF_SEC * 1000);
#else
                                timerRefresh(TIMER_IDX_DEBUG);
#endif
                            }
                            else if (Charger.Relay_Action == GPIO_RELAY_ACTION_OFF)
                            {
                                Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
#ifdef FUNC_MODE_DEBUG_REC_RELAY_ON_TIMES
                                Charger.memory.EVSE_Config.data.item.m_ModeDebugRelayOnTimes++;
                                Charger.memory.EVSE_Config.op_bits.update = ON;
#endif

#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
                                timerRefresh(TIMER_IDX_DEBUG);
                                timerEnable(TIMER_IDX_DEBUG, FUNC_MODE_DEBUG_RELAY_ON_SEC * 1000);
#else
                                timerRefresh(TIMER_IDX_DEBUG);
#endif
                            }
                        }
#else //FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
                        if(isModeChange())
                        {
                            setLedMotion(LED_ACTION_DEBUG);
                            Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
                            timerEnable(TIMER_IDX_DEBUG, 1000);
                        }

                        if(timer[TIMER_IDX_DEBUG].isAlarm || (Charger.Alarm_Code>0))
                        {
                            Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
                            Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
                            Charger.isDebugModeCPtest = ON;
                        }

                        if(Charger.isDebugModeCPtest)
                        {
                            if(Charger.CP_State == SYSTEM_STATE_A)
                            {
                                Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
                                Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
                                Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = Charger.maxRatingCurrent;

#ifdef MODIFY_AC_EVSE_STATUS_MAX_CHARGING_CURRENT_VARIABLE
                                Charger.AC_MaxChargingCurrentOrDuty = Charger.maxRatingCurrent;
#endif
                                user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
                            }
                            else if (Charger.CP_State == SYSTEM_STATE_B)
                            {
                                Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
                                Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif

#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
                                CpTask_CtrlCpPwm_P1();
#endif
                            }
                            else if (Charger.CP_State == SYSTEM_STATE_C)
                            {
                                Charger.Relay_Action = GPIO_RELAY_ACTION_ON;

#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
                                CpTask_CtrlCpPwm_P1();
#endif
                            }
                        }
#endif //FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
                        break;
                }

        }
        else if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_CSU)
        {

            //=============================( MODIFY_CPTASK_TYPE_E )==============================[ WITH CSU ]

            /*
                MCU control mdoe with CSU
            */
            if (!Charger.am3352.isRequestOn)
            {
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
                if (Charger.Mode != MODE_DEBUG)
                {
                    Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
                }

#else
                Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;

#endif //FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
            }

#ifdef MODIFY_CPTASK_HEAD
            Proc_CpTaskHead(HTK_TRUE);
#endif
            switch(Charger.Mode)
            {
                case MODE_INITIAL:
                    //=============================( MODIFY_CPTASK_TYPE_E / MODE_INITIAL )
                        setLedMotion(LED_ACTION_INIT);
                        user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
                        HAL_GPIO_WritePin(OUT_Leak_Test_GPIO_Port, OUT_Leak_Test_Pin, GPIO_PIN_SET); // for VAC LeakModule use

#ifdef FUNC_RELAY_OFF_WHEN_CSU_CMD_TIMEOUT
                        Charger.m_CSU_RxTick = HAL_GetTick();
#endif

                        if (Charger.ModelReadisOK ==PASS)
                        {
                          getRotarySwitchSetting( );
                          getGridTypeSwitchSetting( );
                          Charger.isTestLeakModule = ON ;

#ifdef FUNC_AUTO_MODIFY_CCID_MODULE
                          if (AutoModifyCCID() == PASS)
#else
                          if(Test_LeakModule() == PASS)
#endif
                          {
                              DEBUG_INFO("Leak module self test pass when initial.\r\n");
                              osDelay(1000);

                              if(Charger.isDebugEnable)
                                  setChargerMode(MODE_DEBUG);
                              else
                              {
                                  setChargerMode(MODE_IDLE);
                                  if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
                                    // Cold load pick up check
                                    if((Charger.CP_State == SYSTEM_STATE_A) && Charger.memory.coldLoadPickUp.data.item.isEnable)
                                    {
#ifndef FUNC_METER_IC_HISTORY
                                        recordChargingHis(OFF, END_STATUS_CODE_DROP);
#endif
                                        Charger.memory.coldLoadPickUp.data.item.isEnable = OFF;
                                        Charger.memory.coldLoadPickUp.op_bits.update = ON;
                                    }
                                  }
                              }
                          }
                          else
                          {
                              Charger.Alarm_Code |= ALARM_LEAK_MODULE_FAIL;
                              DEBUG_INFO("Leak module self test fail when initial.\r\n");
                              Charger.counter.LEAK_MODULE.isLatch = ON ;
                          }
                          Charger.isTestLeakModule = OFF ;
                        }
                    break;
                case MODE_IDLE:
                    //=============================( MODIFY_CPTASK_TYPE_E / MODE_IDLE )
                    if(isModeChange())
                    {
                        Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;

#ifdef MODIFY_SOCKET_E_OCP_USE_MAX_CHARGING_CURRENT
                        Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = Charger.maxRatingCurrent;
#else
                        //Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = Charger.maxRatingCurrent; //need CSU command change
#endif
                        user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
                        Charger.isSetStartTime = ON  ;
                        Charger.isOnSocketE = OFF;
#ifdef FUNC_BLOCK_CSU_CONFIG_CP_PWM_DUTY
                        Charger.m_bBlockCsuCpPwmDuty = HTK_DISABLE;
#endif

#ifdef FUNC_CCS
                        Charger.m_bRunCCS = 0;
                        Charger.m_bGotCsuCpDutyCmd = 0;
#ifdef MODIFY_GOT_CSU_DUTY_CMD_PROCESS
                        Charger.m_bPassGotCsuCpDutyCmd = 0;
#endif
#endif //FUNC_CCS

#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
                        if (Charger.m_bUseGunLock)
                        {
                            Charger.m_GunLock_Counter = 0;
                            Charger.m_GunUnlock_Counter = 0;
                        }
#endif

#ifdef FUNC_AX32_USE_AS_1P_MODEL
                        Charger.m_b3PhaseModelButUse1PhaseOnly = AX32_Is_3PModel_Run1P();
#endif

#ifdef FUNC_SYSTEM_KEEP_INFO
                        if (g_SystemKeepInfo.m_bUsed == HTK_TRUE)
                        {
                            g_SystemKeepInfo.m_bUsed = HTK_FALSE;
                        }
#endif
                    }

#ifdef FUNC_SYSTEM_KEEP_INFO
                    if  (
                            (Charger.CP_State != SYSTEM_STATE_A) ||
                            (
                                (Charger.CP_State == SYSTEM_STATE_A) && IsTypeEPlugIn()
                            )
                        )
                    {
                        if (g_SystemKeepInfo.m_bUsed == HTK_FALSE)
                        {
                            g_SystemKeepInfo.m_bUsed = HTK_TRUE;
                            if (SystemKeepInfo_Check(&g_SystemKeepInfo))
                            {
                                if (g_SystemKeepInfo.m_CsuIsRequestOn)
                                {
                                    Charger.am3352.isRequestOn = g_SystemKeepInfo.m_CsuIsRequestOn;
                                    user_pwm_setvalue(PWM_CH_CP, g_SystemKeepInfo.m_CpPwmVal);
                                    Charger.m_bGotCsuCpDutyCmd = 1;
                                    DEBUG_INFO("#<RESET_TO_CHARGE> CP_PWM => %d\r\n", g_SystemKeepInfo.m_CpPwmVal);
                                    SystemKeepInfo_Display(&g_SystemKeepInfo);
                                }
                            }
                        }
                    }
#endif //FUNC_SYSTEM_KEEP_INFO

                    if (Charger.am3352.isRequestOn &&
#ifdef FUNC_CCS

#ifdef MODIFY_GOT_CSU_DUTY_CMD_PROCESS
                        (Charger.m_bGotCsuCpDutyCmd == 1 || Charger.m_bPassGotCsuCpDutyCmd == 1) &&
#else
                        Charger.m_bGotCsuCpDutyCmd == 1 &&
#endif

#endif //FUNC_CCS
                       (Charger.CP_State != SYSTEM_STATE_A))
                    {
                        setChargerMode(MODE_HANDSHAKE);
                    }

#ifdef MODIFY_CPTASK_TYPE_E
                    if  (
                        (Charger.am3352.isRequestOn) &&
                        (Charger.CP_State == SYSTEM_STATE_A && IsTypeEPlugIn())
                        )
                    {
                        setChargerMode(MODE_HANDSHAKE);
                    }
#endif

                    break;

                case MODE_HANDSHAKE:
                    //=============================( MODIFY_CPTASK_TYPE_E / MODE_HANDSHAKE )
                    if(isModeChange())
                    {
                        Charger.isCP_in_B = OFF ;
                        Charger.isTestLeakModule = ON ;
#ifdef TRIM_CCID_SELFTEST
                        Proc_CCID_SelfTest();
#endif
                        //check Leak test pass
                        if (Charger.Test_LeakModuleisPass)
                        {
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
#ifdef MODIFY_MODE_HANDSHAKE_STOP_PWM_WITHOUT_OK_STATE
                            if (Charger.m_bSafetyRegulationGB)
                            {
                                if(Charger.CP_State == SYSTEM_STATE_B || Charger.CP_State == SYSTEM_STATE_C)
                                {
                                    CpTask_CtrlCpPwm_P0();
                                }
                            }
                            else
                            {
                                    CpTask_CtrlCpPwm_P0();
                            }
#endif //MODIFY_MODE_HANDSHAKE_STOP_PWM_WITHOUT_OK_STATE

#else //MODIFY_CP_TASK_CTRL_CP_PWM
                            CpTask_CtrlCpPwm_P0();

#endif //MODIFY_CP_TASK_CTRL_CP_PWM

                            osDelay(300);
                            DEBUG_INFO("Leak module self test pass before charging.\r\n");
                        }
                        else
                        {
                            Charger.Alarm_Code |= ALARM_LEAK_MODULE_FAIL;
                            DEBUG_INFO("Leak module self test fail before charging.\r\n");
                        }
                        Charger.isTestLeakModule = OFF ;
                    }

                    if(Charger.CP_State == SYSTEM_STATE_C)
                    {
#ifdef MODIFY_MODE_HANDSHAKE_STOP_PWM_WITHOUT_OK_STATE
                        if (Charger.m_bSafetyRegulationGB)
                        {
                            Charger.m_bBlockCsuCpPwmDuty = HTK_DISABLE;
                            if (Charger.m_CP_CurPWM == PWM_DUTY_FULL)
                            {
                                CpTask_CtrlCpPwm_P0();
                            }
                        }
#endif
                        setChargerMode(MODE_CHARGING);
                        timerDisable(TIMER_IDX_CP);

                        if (Charger.isSetStartTime == ON)
                        {
                          Charger.cycle_info.startTimeTick = HAL_GetTick();
                          Charger.cycle_info.startDateTime.year = Charger.memory.EVSE_Config.data.item.SystemDateTime.year;
                          Charger.cycle_info.startDateTime.month = Charger.memory.EVSE_Config.data.item.SystemDateTime.month;
                          Charger.cycle_info.startDateTime.day = Charger.memory.EVSE_Config.data.item.SystemDateTime.day;
                          Charger.cycle_info.startDateTime.hour = Charger.memory.EVSE_Config.data.item.SystemDateTime.hour;
                          Charger.cycle_info.startDateTime.min = Charger.memory.EVSE_Config.data.item.SystemDateTime.min;
                          Charger.cycle_info.startDateTime.sec = Charger.memory.EVSE_Config.data.item.SystemDateTime.sec;
                          Charger.cycle_info.meterStart = Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total;
                        }
                    }

                    if (Charger.CP_State == SYSTEM_STATE_B)
                    {
#ifdef MODIFY_MODE_HANDSHAKE_STOP_PWM_WITHOUT_OK_STATE
                        if (Charger.m_bSafetyRegulationGB)
                        {
                            Charger.m_bBlockCsuCpPwmDuty = HTK_DISABLE;
                            if (Charger.m_CP_CurPWM == PWM_DUTY_FULL)
                            {
                                CpTask_CtrlCpPwm_P0();
                            }
                        }
#endif
                        Charger.isCP_in_B = ON ;
                    }

#ifdef MODIFY_CPTASK_TYPE_E
                    if (Charger.CP_State == SYSTEM_STATE_A && IsTypeEPlugIn())
#else
                    //if((Charger.CP_State == SYSTEM_STATE_A) && HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin))
#endif
                    {
                        Charger.isOnSocketE = ON;

                        setChargerMode(MODE_CHARGING);
                        timerDisable(TIMER_IDX_CP);
                        if (Charger.isSetStartTime == ON)
                        {
                          Charger.cycle_info.startTimeTick = HAL_GetTick();
                          Charger.cycle_info.startDateTime.year = Charger.memory.EVSE_Config.data.item.SystemDateTime.year;
                          Charger.cycle_info.startDateTime.month = Charger.memory.EVSE_Config.data.item.SystemDateTime.month;
                          Charger.cycle_info.startDateTime.day = Charger.memory.EVSE_Config.data.item.SystemDateTime.day;
                          Charger.cycle_info.startDateTime.hour = Charger.memory.EVSE_Config.data.item.SystemDateTime.hour;
                          Charger.cycle_info.startDateTime.min = Charger.memory.EVSE_Config.data.item.SystemDateTime.min;
                          Charger.cycle_info.startDateTime.sec = Charger.memory.EVSE_Config.data.item.SystemDateTime.sec;
                          Charger.cycle_info.meterStart = Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total;
                        }
                    }

                    if(((Charger.CP_State == SYSTEM_STATE_A) && Charger.isCP_in_B) || !Charger.am3352.isRequestOn)
                    {
                        user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);  // close pwm
                        setChargerMode(MODE_IDLE);
                        timerDisable(TIMER_IDX_CP);
                    }

#ifdef MODIFY_MODE_HANDSHAKE_STOP_PWM_WITHOUT_OK_STATE
                    if (Charger.m_bSafetyRegulationGB)
                    {
                        if  (
                                (Charger.CP_State == SYSTEM_STATE_D || Charger.CP_State == SYSTEM_STATE_E) &&
                                (Charger.am3352.isRequestOn)
                            )
                        {
                            Charger.m_bBlockCsuCpPwmDuty = HTK_ENABLE;
                            user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
                        }
                    }
#endif


                    break;

                case MODE_CHARGING:
                    //=============================( MODIFY_CPTASK_TYPE_E / MODE_CHARGING )
                    if(isModeChange())
                    {
#ifdef MODIFY_CPTASK_CSU_0_1_CHARGE_MODE
                        CpTask_CtrlCpPwm_P0();
#endif
                    }

                    if (
#ifdef MODIFY_AW_CP_TASK_CSU_0_1_CHARGING_MODE_STOP_WITHOUT_STATE_C
                            (!Charger.isOnSocketE && Charger.CP_State != SYSTEM_STATE_C) ||
#else
                            ((!Charger.isOnSocketE) && (Charger.CP_State != SYSTEM_STATE_C) && (Charger.CP_State != SYSTEM_STATE_UNKNOWN)) ||
#endif

#ifdef MODIFY_CPTASK_TYPE_E
                            (Charger.isOnSocketE && !IsTypeEPlugIn()) ||
#else
                            //((Charger.isOnSocketE) && !HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin)) ||
#endif
                            !Charger.am3352.isRequestOn
                        )
                    {
                        setChargerMode(MODE_STOP);

                        if (Charger.CP_State != SYSTEM_STATE_C)
						{
                            Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;

#ifdef MODIFY_MODE_CHARGING_STOP_PWM_WITHOUT_OK_STATE
                            if (Charger.m_bSafetyRegulationGB)
                            {
                                if  (
                                        (Charger.CP_State == SYSTEM_STATE_D || Charger.CP_State == SYSTEM_STATE_E) &&
                                        (Charger.am3352.isRequestOn)
                                    )
                                {
                                    Charger.m_bBlockCsuCpPwmDuty = HTK_ENABLE;
                                    user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
                                }
                            }
#endif //MODIFY_MODE_CHARGING_STOP_PWM_WITHOUT_OK_STATE
                        }
                    }
#ifdef FUNC_RELAY_OFF_WHEN_CSU_CMD_TIMEOUT
                    else if (HTK_IsTimeout(Charger.m_CSU_RxTick, CSU_CMD_TIMEOUT_SEC * 1000))
                    {
                        if (Charger.Relay_Action != GPIO_RELAY_ACTION_OFF)
                        {
                            Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
                            XP("#<CSU_TIMEOUT> RELAY => OFF\r\n");
                        }
                        if (Charger.SE_Relay_Action != GPIO_SE_RELAY_ACTION_OFF)
                        {
                            Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
                            XP("#<CSU_TIMEOUT> RELAY_SE => OFF\r\n");
                        }
#ifdef FUNC_REQUEST_OFF_WHEN_CSU_CMD_TIMEOUT
                        if (Charger.am3352.isRequestOn != OFF)
                        {
                            Charger.am3352.isRequestOn = OFF;
                            XP("#<CSU_TIMEOUT> REQUEST => OFF\r\n");
                        }
#endif
                    }
#endif //FUNC_RELAY_OFF_WHEN_CSU_CMD_TIMEOUT
                    else
                    {
                        duration_delta = (HAL_GetTick() - Charger.cycle_info.startTimeTick);
                        Charger.cycle_info.Duration = duration_delta;
                        Charger.cycle_info.Power_Consumption = Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total - Charger.cycle_info.meterStart;
                    }
                    break;

                case MODE_STOP:
                    //=============================( MODIFY_CPTASK_TYPE_E / MODE_STOP )
                    if(isModeChange())
                    {
                        Charger.isSetStartTime = OFF ;
                        Charger.isCP_in_B = OFF ;
                        if (!Charger.am3352.isRequestOn)   //represent swip card stop charge in 6V
                        {
                          Charger.rfid.op_bits.reqStop = ON ;
                        }
                    }

                    if(!Charger.am3352.isRequestOn)
                    {
                        if (Charger.rfid.op_bits.reqStop == ON || (Charger.CP_State == SYSTEM_STATE_B)) //1. swip card stop charge in 6V. , 2.cp-> B then swip card stop charge
                        {
                            if(Charger.CP_State == SYSTEM_STATE_B)
                                Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;

                            Charger.rfid.op_bits.reqStop = OFF;
                            user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);  // close pwm
                            timerEnable( TIMER_IDX_RFID_RELAY_OFF, 3000); //is set wait 3 sec
                            Charger.cycle_info.endTimeTick = HAL_GetTick();
#ifndef FUNC_METER_IC_HISTORY
                            recordChargingHis(OFF, END_STATUS_CODE_NORMAL);
#endif
                            Charger.isCP_in_B = OFF ;
                        }

                        if (timer[TIMER_IDX_RFID_RELAY_OFF].isAlarm == ON ) //is wait 3 sec
                        {
                          	timerDisable(TIMER_IDX_RFID_RELAY_OFF);
                          	Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef FUNC_BLOCK_CSU_CONFIG_CP_PWM_DUTY
							Charger.m_bBlockCsuCpPwmDuty = HTK_DISABLE;
#endif
                          	setChargerMode(MODE_IDLE);
                          	Charger.cycle_info.StartType = START_METHOD_NONE;
                        }
                    }
                    else if
                        (
                            (!Charger.isOnSocketE && Charger.CP_State == SYSTEM_STATE_A) ||
#ifdef MODIFY_CPTASK_TYPE_E
                            (Charger.isOnSocketE && !IsTypeEPlugIn())
#else
                            //(Charger.isOnSocketE && !HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin))
#endif
                        )
                    {
                        user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);  // close pwm
                        Charger.cycle_info.endTimeTick = HAL_GetTick();
#ifndef FUNC_METER_IC_HISTORY
                        recordChargingHis(OFF, END_STATUS_CODE_NORMAL);
#endif
                        Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;

#ifdef FUNC_BLOCK_CSU_CONFIG_CP_PWM_DUTY
                     	Charger.m_bBlockCsuCpPwmDuty = HTK_DISABLE;
#endif
                        setChargerMode(MODE_IDLE);
                        Charger.isCP_in_B = OFF ;
                    }
                    else // Charger.am3352.isRequestOn == 1
                    {
                        if((Charger.CP_State == SYSTEM_STATE_B))
                        {
                            timerDisable(TIMER_IDX_RFID_RELAY_OFF);
                            Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
                            Charger.isCP_in_B = ON ;
                        }

                        if((Charger.CP_State == SYSTEM_STATE_C) && (!Charger.am3352.isRequestOff) )
                        {
#ifdef FUNC_BLOCK_CSU_CONFIG_CP_PWM_DUTY
                            Charger.m_bBlockCsuCpPwmDuty = HTK_DISABLE;
#endif
                            setChargerMode(MODE_HANDSHAKE);
                        }

#ifdef MODIFY_MODE_STOP_STOP_PWM_WITHOUT_OK_STATE
                        if (Charger.m_bSafetyRegulationGB)
                        {
                            if  (
                                    (Charger.CP_State == SYSTEM_STATE_D || Charger.CP_State == SYSTEM_STATE_E) &&
                                    (Charger.am3352.isRequestOn)
                                )
                            {
                                Charger.m_bBlockCsuCpPwmDuty = HTK_ENABLE;
                                user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
                            }
                            if ((Charger.CP_State == SYSTEM_STATE_B) && (Charger.am3352.isRequestOn))
                            {
                                Charger.m_bBlockCsuCpPwmDuty = HTK_DISABLE;
                                if (Charger.m_CP_CurPWM == PWM_DUTY_FULL)
                                {
                                    CpTask_CtrlCpPwm_P0();
                                }
                            }
                        }
#endif //MODIFY_MODE_STOP_STOP_PWM_WITHOUT_OK_STATE
                    }
                    break;

                case MODE_ALARM:
                    //=============================( MODIFY_CPTASK_TYPE_E / MODE_ALARM )
                    if(isModeChange())
                    {
                        Charger.isSetStartTime = OFF ;
                        if (Charger.CSUisReady == ON )
                        {
                            //clear blink time , Prevent red light from being snatched by others
                            disblinkerTime (BLINKER_IDX_LED) ;
                            //clear led Action
                            Charger.am3352.LedActionState = 0 ;
                        }
                    }

                    Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E_CSU_SE_RELAY_AUTO_OFF
                    Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif

#ifdef FUNC_MODE_ALARM_TO_MODE_DEBUG
                    if (Charger.isDebugEnable && Charger.Alarm_Code == 0)
                    {
                        setChargerMode(MODE_DEBUG);
                    }
                    else
#endif

                    if(Charger.Alarm_Code == 0x00)
                    {
                        Charger.am3352.LedActionState = 0 ;
                        if (Charger.Mode_Before_Alarm == MODE_CHARGING)  // in charging mode
                        {
#ifdef FUNC_CCS

#ifdef MODIFY_CPTASK_CSU_MODE_ALARM_GO_HANDSHAKE_WITH_NEW_CONDITION
                          if(Charger.CP_State != SYSTEM_STATE_A && Charger.am3352.isRequestOn)
#else
                          if(Charger.CP_State == SYSTEM_STATE_B || Charger.CP_State == SYSTEM_STATE_C)
#endif

#else //FUNC_CCS
                          if(Charger.CP_State == SYSTEM_STATE_B )       // to handshake
#endif //FUNC_CCS
                          {
                            setChargerMode(MODE_HANDSHAKE);
                          }
                          else  // to idle //SYSTEM_STATE_A
                          {
                            user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
                            setChargerMode(MODE_IDLE);
                          }
                        }
                        else if(Charger.Mode_Before_Alarm == MODE_STOP)
                        {
                          if (Charger.isCP_in_B == ON)  // to handshake
                          {
                            setChargerMode(MODE_HANDSHAKE);
                          }
                          else  // to stop
                          {
                            setChargerMode(MODE_STOP);
                          }
                        }
                        else    // to idle
                        {
                          if(timer[TIMER_IDX_STATE_E].isAlarm == ON)
                          {
                            setChargerMode(MODE_IDLE);
                          }
                        }
                    }
                    break;
                case MODE_DEBUG:
                    //=============================( MODIFY_CPTASK_TYPE_E / MODE_DEBUG )
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
                    if(isModeChange())
                    {
                        setLedMotion(LED_ACTION_DEBUG);
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
                        timerEnable(TIMER_IDX_DEBUG, FUNC_MODE_DEBUG_RELAY_ON_SEC * 1000);
#else
                        timerEnable(TIMER_IDX_DEBUG, 2000);
#endif
                    }

                    if (timer[TIMER_IDX_DEBUG].isAlarm &&
                        Charger.Alarm_Code == 0 &&
                        Charger.CP_State == SYSTEM_STATE_C)
                    {
                        if (Charger.Relay_Action == GPIO_RELAY_ACTION_ON)
                        {
                            Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
                            timerRefresh(TIMER_IDX_DEBUG);
                            timerEnable(TIMER_IDX_DEBUG, FUNC_MODE_DEBUG_RELAY_OFF_SEC * 1000);
#else
                            timerRefresh(TIMER_IDX_DEBUG);
#endif

                        }
                        else if (Charger.Relay_Action == GPIO_RELAY_ACTION_OFF)
                        {
                            Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
#ifdef FUNC_MODE_DEBUG_REC_RELAY_ON_TIMES
                            Charger.memory.EVSE_Config.data.item.m_ModeDebugRelayOnTimes++;
                            Charger.memory.EVSE_Config.op_bits.update = ON;
#endif

#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
                            timerRefresh(TIMER_IDX_DEBUG);
                            timerEnable(TIMER_IDX_DEBUG, FUNC_MODE_DEBUG_RELAY_ON_SEC * 1000);
#else
                            timerRefresh(TIMER_IDX_DEBUG);
#endif
                        }
                    }
#else //FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
                    if(isModeChange())
                    {
                        setLedMotion(LED_ACTION_DEBUG);
                        Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
                        timerEnable(TIMER_IDX_DEBUG, 1000);
                    }

                    if(timer[TIMER_IDX_DEBUG].isAlarm || (Charger.Alarm_Code>0))
                    {
                        Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
                        Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
                        Charger.isDebugModeCPtest = ON;
                    }

                    if(Charger.isDebugModeCPtest)
                    {
                        if(Charger.CP_State == SYSTEM_STATE_A)
                        {
                            Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
                            Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
                            Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = Charger.maxRatingCurrent;
#ifdef MODIFY_AC_EVSE_STATUS_MAX_CHARGING_CURRENT_VARIABLE
                            Charger.AC_MaxChargingCurrentOrDuty = Charger.maxRatingCurrent;
#endif
                            user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
                        }
                        else if (Charger.CP_State == SYSTEM_STATE_B)
                        {
                            Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
                            Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
                            CpTask_CtrlCpPwm_P1();
#endif
                        }
                        else if (Charger.CP_State == SYSTEM_STATE_C)
                        {
                            Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
                            CpTask_CtrlCpPwm_P1();
#endif
                        }
                    }
#endif //FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
                    break;
                default:
                    setChargerMode(MODE_IDLE);
                    break;
            }
        }
        else
        {
            /*By Pass Mode*/
        }

        osDelay(1);
    }
  /* USER CODE END StartCpTask */
}

/* USER CODE BEGIN Header_StartAlarmTask */
/**
* @brief Function implementing the alarmTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartAlarmTask */
void StartAlarmTask(void const * argument)
{
  /* USER CODE BEGIN StartAlarmTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    IdleUntilReadAllMemory();
#endif

  //aalarm
  //timerEnable(TIMER_IDX_PE_DETECT, 30000);
  timerEnable(TIMER_IDX_PE_DETECT, 40000);

#ifndef RECODE_METER_PRO380
#ifdef MODIFY_METER_EXT_PRO380
    Charger.m_MeterPRO380.m_LastUpdateTick = HAL_GetTick();
#endif
#endif //!RECODE_METER_PRO380

  /* Infinite loop */
  for(;;)
  {
#ifdef FUNC_MODE_DEBUG_WITH_NORMAL_ALARM_DETECTE
    if(Charger.Mode != MODE_INITIAL)
#else
    if(Charger.Mode != MODE_INITIAL && Charger.Mode != MODE_DEBUG)
#endif
    {
        recordAlarmHis();

#ifdef FUNC_AX32_TRIG_LEAKAGE
        if (Charger.m_b3PhaseModel)
        {
            if (Charger.Alarm_Code & ALARM_RELAY_STATUS && //Relay Welding
                (!HTK_IsInTime(Charger.AlarmRelayWeldingOccurTick, 1000))
                )
            {
                TrigLeakage_Trig();
                TrigLeakage_Proc();
            }
        }
#endif

#ifdef FUNC_AX80_ADD_TILT_SENSOR
#ifdef FUNC_ADD_TILT_SENSOR_MODEL
        if (Charger.m_bUseTiltSensor)
#else
        if (Charger.m_bModelNameAX80_1P)
#endif
        {
            if (Charger.Alarm_Code & ALARM_TILT_SENSOR &&
                (!HTK_IsInTime(Charger.AlarmTiltSensorOccurTick, 1000))
                )
            {
#ifdef FUNC_DISABLE_TILT_SENSOR_FOR_TEST
                if (HTK_IsInTime(Charger.m_BootTick, 1000 * 30))
                {
                    Charger.m_bDisableTiltSensorForTest = 1;
                    Charger.Alarm_Code &= ~ALARM_TILT_SENSOR;
                    DEBUG_ERROR("Alarm tilt sensor fault recover. [TEST MODE WITHOUT TILT SENSOR ALARM]\r\n");
                    Charger.counter.TiltSensor.fail = 0;
                }
                else
                {
                    TILT_TrigLeakage_Trig();
                    TILT_TrigLeakage_Proc();
                }

#else
                TILT_TrigLeakage_Trig();
                TILT_TrigLeakage_Proc();
#endif
            }
        }
#endif //FUNC_AX80_ADD_TILT_SENSOR

        //================================
        // CP fail alarm detect
        //================================
#ifdef  CP_ALARM_PROTECT

         if ((Charger.CP_State == SYSTEM_STATE_UNKNOWN)&&(!(Charger.Alarm_Code & ALARM_MCU_TESTFAIL)))
         {
#ifdef MODIFY_ALARM_CP_ERROR_RECOVER_USE_RESTORE
            if(!(Charger.Alarm_Code & ALARM_CP_ERROR))
            {
                if (Charger.counter.CP.fail > 1000)
                {
                    Charger.counter.CP.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                    Charger.Alarm_Code |= ALARM_CP_ERROR;
                    DEBUG_ERROR("Alarm CP occur.\r\n");
                    Charger.counter.CP.restore = 0;
                }
                else
                {
                    Charger.counter.CP.fail++;
                }
            }
#endif //MODIFY_ALARM_CP_ERROR_RECOVER_USE_RESTORE
         }
#ifdef MODIFY_ALARMTASK_CP_ERROR_RECOVER
         else if (Charger.CP_State != SYSTEM_STATE_UNKNOWN)
#else
         else if ((Charger.CP_State != SYSTEM_STATE_UNKNOWN)&&(Charger.CP_State!=SYSTEM_STATE_D)&&
                  (Charger.CP_State != SYSTEM_STATE_E)&&(Charger.CP_State != SYSTEM_STATE_F))
#endif
         {

#ifdef MODIFY_ALARM_CP_ERROR_RECOVER_USE_RESTORE
            if (Charger.Alarm_Code & ALARM_CP_ERROR)
            {
                if (Charger.counter.CP.restore > 1000)
                {
                    Charger.Alarm_Code &= ~ALARM_CP_ERROR;
                    DEBUG_INFO("Alarm CP recover.\r\n");
                    Charger.counter.CP.fail = 0;
                }
                else
                {
                    Charger.counter.CP.restore++;
                }
            }
#endif //MODIFY_ALARM_CP_ERROR_RECOVER_USE_RESTORE
         }

#ifdef FUNC_ALARM_CP_NEG_ERROR
         if ((!CP_IsInSpec_N12V(&CpDetectionResult))&&(!(Charger.Alarm_Code & ALARM_MCU_TESTFAIL)))
         {
#ifdef MODIFY_ALARM_CP_NEG_ERROR_RECOVER_USE_RESTORE

            if (!(Charger.Alarm_Code & ALARM_CP_NEG_ERROR))
            {
                if (Charger.counter.CP_Neg.fail > 1000)
                {
                    Charger.counter.CP_Neg.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                    Charger.Alarm_Code |= ALARM_CP_NEG_ERROR;
                    DEBUG_ERROR("Alarm CP_NEG occur.\r\n");
                    Charger.counter.CP_Neg.restore = 0;
                }
                else
                {
                    Charger.counter.CP_Neg.fail++;
                 }
             }

#endif //MODIFY_ALARM_CP_NEG_ERROR_RECOVER_USE_RESTORE
         }
        else
        {
#ifdef MODIFY_ALARM_CP_NEG_ERROR_RECOVER_USE_RESTORE
            if (Charger.Alarm_Code & ALARM_CP_NEG_ERROR)
            {
                if (Charger.counter.CP_Neg.restore > 1000)
                {
                    Charger.Alarm_Code &= ~ALARM_CP_NEG_ERROR;
                    DEBUG_INFO("Alarm CP_NEG recover.\r\n");
                    Charger.counter.CP_Neg.fail = 0;
                }
                else
                {
                    Charger.counter.CP_Neg.restore++;
                }
            }
#endif //MODIFY_ALARM_CP_NEG_ERROR_RECOVER_USE_RESTORE
         }
#endif //FUNC_ALARM_CP_NEG_ERROR

#endif  //CP_ALARM_PROTECT

        //================================
        // Over voltage alarm detect
        //================================
#ifdef  OVP_PROTECT
        //--------------------------------
        // L1 Over voltage
        if(Charger.Voltage[0] > ALARM_SPEC_OV)
        {
            if(Charger.counter.L1_OV.fail > 1000)
            {
                Charger.counter.L1_OV.restore = 0 ;
                if(!(Charger.Alarm_Code & ALARM_L1_OVER_VOLTAGE))
                {
                    Charger.Alarm_Code |= ALARM_L1_OVER_VOLTAGE;
                    DEBUG_ERROR("Alarm L1_OV occur.\r\n");
                }
            }
            else
                Charger.counter.L1_OV.fail++;
        }
        else if(Charger.Voltage[0] < (ALARM_SPEC_OV-ALARM_SPEC_OUV_HYSTERESIS))
        {
            if((Charger.Alarm_Code & ALARM_L1_OVER_VOLTAGE))
            {
                if (Charger.counter.L1_OV.restore > 1000 && blinker[BLINKER_IDX_LED].blinkisFinish)
                {
                    Charger.counter.L1_OV.fail = 0 ;
                    DEBUG_INFO("Alarm L1_OV is coldpickup ing..... \r\n");
                    Charger.counter.L1_OV.isOccurInCharging = ((Charger.CP_State == SYSTEM_STATE_B)?ON:OFF);
                    if (Charger.counter.L1_OV.isOccurInCharging)
                    {
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
                        ColdLoadPickup_Delay("Alarm L1_OV is coldpickup ing..... ");
#else
                        osDelay((rand()%175000)+5000);
#endif
                    }
                    Charger.Alarm_Code &= ~ALARM_L1_OVER_VOLTAGE;
                    DEBUG_INFO("Alarm L1_OV recover.\r\n");
                }
                else
                {
                  Charger.counter.L1_OV.restore++;
                }
            }
            else
            {
              Charger.counter.L1_OV.fail = 0 ;
              Charger.counter.L1_OV.restore = 0 ;
            }
        }

#ifdef FUNC_AUTO_IGNORE_AC_PHASE

#ifdef FUNC_AX32_USE_AS_1P_MODEL
        if (Charger.m_b3PhaseModel && !Charger.m_b3PhaseModelButUse1PhaseOnly)
#else
        if (Charger.m_b3PhaseModel)
#endif
        {
#endif
        //--------------------------------
        // L2 Over voltage
        if(Charger.Voltage[1] > ALARM_SPEC_OV)
        {
            if(Charger.counter.L2_OV.fail > 1000)
            {
                Charger.counter.L2_OV.restore = 0 ;
                if(!(Charger.Alarm_Code & ALARM_L2_OVER_VOLTAGE))
                {
                    Charger.Alarm_Code |= ALARM_L2_OVER_VOLTAGE;
                    DEBUG_ERROR("Alarm L2_OV occur.\r\n");
                }
            }
            else
                Charger.counter.L2_OV.fail++;
        }
        else if(Charger.Voltage[1] < (ALARM_SPEC_OV-ALARM_SPEC_OUV_HYSTERESIS))
        {
            if((Charger.Alarm_Code & ALARM_L2_OVER_VOLTAGE))
            {
                if (Charger.counter.L2_OV.restore > 1000 && blinker[BLINKER_IDX_LED].blinkisFinish)
                {
                    Charger.counter.L2_OV.fail = 0 ;
                    DEBUG_INFO("Alarm L2_OV is coldpickup ing..... \r\n");
                    Charger.counter.L2_OV.isOccurInCharging = ((Charger.CP_State == SYSTEM_STATE_B)?ON:OFF);
                    if (Charger.counter.L2_OV.isOccurInCharging)
                    {
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
                        ColdLoadPickup_Delay("Alarm L2_OV is coldpickup ing..... ");
#else
                        osDelay((rand()%175000)+5000);
#endif
                    }
                    Charger.Alarm_Code &= ~ALARM_L2_OVER_VOLTAGE;
                    DEBUG_INFO("Alarm L2_OV recover.\r\n");
                }
                else
                {
                  Charger.counter.L2_OV.restore++;
                }
            }
            else
            {
              Charger.counter.L2_OV.fail = 0 ;
              Charger.counter.L2_OV.restore = 0 ;
            }
        }


        //--------------------------------
        // L3 Over voltage
        if(Charger.Voltage[2] > ALARM_SPEC_OV)
        {
            if(Charger.counter.L3_OV.fail > 1000)
            {
                Charger.counter.L3_OV.restore = 0 ;
                if(!(Charger.Alarm_Code & ALARM_L3_OVER_VOLTAGE))
                {
                    Charger.Alarm_Code |= ALARM_L3_OVER_VOLTAGE;
                    DEBUG_ERROR("Alarm L3_OV occur.\r\n");
                }
            }
            else
                Charger.counter.L3_OV.fail++;
        }
        else if(Charger.Voltage[2] < (ALARM_SPEC_OV-ALARM_SPEC_OUV_HYSTERESIS))
        {
            if((Charger.Alarm_Code & ALARM_L3_OVER_VOLTAGE))
            {
                if (Charger.counter.L3_OV.restore > 1000 && blinker[BLINKER_IDX_LED].blinkisFinish)
                {
                    Charger.counter.L3_OV.fail = 0 ;
                    DEBUG_INFO("Alarm L3_OV is coldpickup ing..... \r\n");
                    Charger.counter.L3_OV.isOccurInCharging = ((Charger.CP_State == SYSTEM_STATE_B)?ON:OFF);
                    if (Charger.counter.L3_OV.isOccurInCharging)
                    {
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
                        ColdLoadPickup_Delay("Alarm L3_OV is coldpickup ing..... ");
#else
                        osDelay((rand()%175000)+5000);
#endif
                    }
                    Charger.Alarm_Code &= ~ALARM_L3_OVER_VOLTAGE;
                    DEBUG_INFO("Alarm L3_OV recover.\r\n");
                }
                else
                {
                  Charger.counter.L3_OV.restore++;
                }
            }
            else
            {
              Charger.counter.L3_OV.fail = 0 ;
              Charger.counter.L3_OV.restore = 0 ;
            }
        }

#ifdef FUNC_AUTO_IGNORE_AC_PHASE
        }
#endif


#endif  //OVP_PROTECT

        //================================
        // Under voltage alarm detect
        //================================
#ifdef  UVP_PROTECT

        //--------------------------------
        // L1 Under voltage
        if(Charger.Voltage[0] < ALARM_SPEC_UV)
        {
            if(Charger.counter.L1_UV.fail > 1000)
            {
                Charger.counter.L1_UV.restore = 0 ;
                if(!(Charger.Alarm_Code & ALARM_L1_UNDER_VOLTAGE))
                {
                    Charger.Alarm_Code |= ALARM_L1_UNDER_VOLTAGE;
                    DEBUG_ERROR("Alarm L1_UV occur.\r\n");
                    //************************
                      XP("Charger.Voltage[0] = %d\r\n", Charger.Voltage[0]);
                    //************************

                }
            }
            else
                Charger.counter.L1_UV.fail++;
        }
        else if(Charger.Voltage[0] > (ALARM_SPEC_UV+ALARM_SPEC_OUV_HYSTERESIS))
        {
            if(Charger.Alarm_Code & ALARM_L1_UNDER_VOLTAGE)
            {
                if (Charger.counter.L1_UV.restore > 1000 && blinker[BLINKER_IDX_LED].blinkisFinish)
                {
                  Charger.counter.L1_UV.fail = 0 ;
                  DEBUG_INFO("Alarm L1_UV is coldpickup ing..... \r\n"); //Hao#####
                  Charger.counter.L1_UV.isOccurInCharging = ((Charger.CP_State == SYSTEM_STATE_B)?ON:OFF);
                  if (Charger.counter.L1_UV.isOccurInCharging)
                  {
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
                    ColdLoadPickup_Delay("Alarm L1_UV is coldpickup ing..... ");
#else
                    osDelay((rand()%175000)+5000);
#endif
                  }
                  Charger.Alarm_Code &= ~ALARM_L1_UNDER_VOLTAGE;
                  DEBUG_INFO("Alarm L1_UV recover.\r\n");
                }
                else
                {
                    Charger.counter.L1_UV.restore++ ;
                }
            }
            else
            {
                Charger.counter.L1_UV.restore = 0 ;
                Charger.counter.L1_UV.fail = 0 ;
            }
        }

#ifdef FUNC_AUTO_IGNORE_AC_PHASE

#ifdef FUNC_AX32_USE_AS_1P_MODEL
        if (Charger.m_b3PhaseModel && !Charger.m_b3PhaseModelButUse1PhaseOnly)
#else
        if (Charger.m_b3PhaseModel)
#endif
        {
#endif
        //--------------------------------
        // L2 Under voltage
        if(Charger.Voltage[1] < ALARM_SPEC_UV)
        {
            if(Charger.counter.L2_UV.fail > 1000)
            {
                Charger.counter.L2_UV.restore = 0 ;
                if(!(Charger.Alarm_Code & ALARM_L2_UNDER_VOLTAGE))
                {
                    Charger.Alarm_Code |= ALARM_L2_UNDER_VOLTAGE;
                    DEBUG_ERROR("Alarm L2_UV occur.\r\n");
                }
            }
            else
                Charger.counter.L2_UV.fail++;
        }
        else if(Charger.Voltage[1] > (ALARM_SPEC_UV+ALARM_SPEC_OUV_HYSTERESIS))
        {
            if(Charger.Alarm_Code & ALARM_L2_UNDER_VOLTAGE)
            {
                if (Charger.counter.L2_UV.restore > 1000 && blinker[BLINKER_IDX_LED].blinkisFinish)
                {
                  Charger.counter.L2_UV.fail = 0 ;
                  DEBUG_INFO("Alarm L2_UV is coldpickup ing..... \r\n");
                  Charger.counter.L2_UV.isOccurInCharging = ((Charger.CP_State == SYSTEM_STATE_B)?ON:OFF);
                  if (Charger.counter.L2_UV.isOccurInCharging)
                  {
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
                        ColdLoadPickup_Delay("Alarm L2_UV is coldpickup ing..... ");
#else
                        osDelay((rand()%175000)+5000);
#endif
                  }
                  Charger.Alarm_Code &= ~ALARM_L2_UNDER_VOLTAGE;
                  DEBUG_INFO("Alarm L2_UV recover.\r\n");
                }
                else
                {
                    Charger.counter.L2_UV.restore++ ;
                }
            }
            else
            {
                Charger.counter.L2_UV.restore = 0 ;
                Charger.counter.L2_UV.fail = 0 ;
            }
        }

        //--------------------------------
        // L3 Under voltage
        if(Charger.Voltage[2] < ALARM_SPEC_UV)
        {
            if(Charger.counter.L3_UV.fail > 1000)
            {
                Charger.counter.L3_UV.restore = 0 ;
                if(!(Charger.Alarm_Code & ALARM_L3_UNDER_VOLTAGE))
                {
                    Charger.Alarm_Code |= ALARM_L3_UNDER_VOLTAGE;
                    DEBUG_ERROR("Alarm L3_UV occur.\r\n");
                }
            }
            else
                Charger.counter.L3_UV.fail++;
        }
        else if(Charger.Voltage[2] > (ALARM_SPEC_UV+ALARM_SPEC_OUV_HYSTERESIS))
        {
            if(Charger.Alarm_Code & ALARM_L3_UNDER_VOLTAGE)
            {
                if (Charger.counter.L3_UV.restore > 1000 && blinker[BLINKER_IDX_LED].blinkisFinish)
                {
                  Charger.counter.L3_UV.fail = 0 ;
                  DEBUG_INFO("Alarm L3_UV is coldpickup ing..... \r\n");
                  Charger.counter.L3_UV.isOccurInCharging = ((Charger.CP_State == SYSTEM_STATE_B)?ON:OFF);
                  if (Charger.counter.L3_UV.isOccurInCharging)
                  {
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
                        ColdLoadPickup_Delay("Alarm L3_UV is coldpickup ing..... ");
#else
                        osDelay((rand()%175000)+5000);
#endif
                  }
                  Charger.Alarm_Code &= ~ALARM_L3_UNDER_VOLTAGE;
                  DEBUG_INFO("Alarm L3_UV recover.\r\n");
                }
                else
                {
                    Charger.counter.L3_UV.restore++ ;
                }
            }
            else
            {
                Charger.counter.L3_UV.restore = 0 ;
                Charger.counter.L3_UV.fail = 0 ;
            }
        }

#ifdef FUNC_AUTO_IGNORE_AC_PHASE
        }
#endif

#endif  //UVP_PROTECT

        //================================
        // Over current alarm detect
        //================================
#ifdef  OCP_PROTECT

#ifdef FUNC_OCP_WITH_PP

        {
            uint16_t CurMaxCurr = 0;        //A
            uint16_t OC_BegThreshold = 0;   //Occur:    0.01A
            uint16_t OC_EndThreshold = 0;   //Recover:  0.01A

#ifdef FUNC_CCS
////            if (Charger.m_bRunCCS)
////            {
////                CurMaxCurr = Charger.maxRatingCurrent;
////            }
////            else
////            {
////                CurMaxCurr = HTK_GET_VAL_MIN(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent, Charger.maxRatingCurrent);
////            }
            CurMaxCurr = HTK_GET_VAL_MIN(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent, Charger.maxRatingCurrent);
#else
            CurMaxCurr = HTK_GET_VAL_MIN(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent, Charger.maxRatingCurrent);
#endif
            if (Charger.m_bDetectPP)
            {
                CurMaxCurr = HTK_GET_VAL_MIN(CurMaxCurr, Charger.m_PPInfo.m_CurCurr);
            }

#ifdef MODIFY_SOCKET_E_OCP_USE_MAX_CHARGING_CURRENT
            if (Charger.isOnSocketE == ON)
            {
                CurMaxCurr = Charger.memory.EVSE_Config.data.item.MaxChargingCurrent;
            }
#endif


#ifdef MODIFY_OCP_PROC_WITH_MODELNAME_IDX_3_EURO_SPEC
            if (Charger.m_bModelNameWithEuroSpecOCP)
#else
            if (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'E')
#endif
            {
                OC_BegThreshold = (CurMaxCurr * Charger.OCP_Magnification) + 0;
                OC_EndThreshold = (CurMaxCurr * Charger.OCP_Magnification) - 200;
            }
            else
            {
                if (CurMaxCurr > 20)
                {
                    OC_BegThreshold = (CurMaxCurr * Charger.OCP_Magnification) + 0;
                    OC_EndThreshold = (CurMaxCurr * Charger.OCP_Magnification) - 200;
                }
                else
                {
                    OC_BegThreshold = (CurMaxCurr * 100) + 200;
                    OC_EndThreshold = (CurMaxCurr * 100) + 0;
                }
            }

            Charger.m_OCP_CurMaxCurr = CurMaxCurr;
            Charger.m_OCP_BegThreshold = OC_BegThreshold;
            Charger.m_OCP_EndThreshold = OC_EndThreshold;

#ifdef FUNC_SET_AT32_MODEL_SCP_SPEC_VAL_HIGHER_TO_AVOID_SCP_ALARM
            u32 CurSCP_SPEC = SCP_SPEC_VAL;
            if (Charger.m_bModelNameAT)
            {
                CurSCP_SPEC = (u32)SCP_SPEC_VAL * 1000;
            }
#endif

            //--------------------------------
            // L1 Over current
#ifdef FUNC_SET_AT32_MODEL_SCP_SPEC_VAL_HIGHER_TO_AVOID_SCP_ALARM
            if((u32)Charger.Current[0] >= CurSCP_SPEC)
#else
            if(Charger.Current[0] >= SCP_SPEC_VAL)
#endif
            {
                if(Charger.counter.L1_OC.fail > 5)
                {
                    if(!(Charger.Alarm_Code & ALARM_L1_CIRCUIT_SHORT))
                    {
                        Charger.counter.L1_OC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                        Charger.Alarm_Code |= ALARM_L1_CIRCUIT_SHORT;
                        if (Charger.counter.L1_OC.isLatch == OFF)
                        {
                            Charger.counter.L1_OC.isLatch = ON ;
                            setLedMotion(LED_ACTION_ALARM);
                            timerDisable(TIMER_IDX_RETRY_OC);
                        }
                        DEBUG_INFO("Correction Current[0]: %f\r\n", Charger.Current[0]/100.0);
                        DEBUG_ERROR("Alarm L1 SCP occur.\r\n");
                    }
                }
                else
                    Charger.counter.L1_OC.fail++;
            }
//#ifdef MODIFY_OCP_SPEC
//            else if(Charger.Current[0] > (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent?(Charger.maxRatingCurrent>20 ? ((Charger.maxRatingCurrent*Charger.OCP_Magnification)):((Charger.maxRatingCurrent+2)*100))  :  (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )):((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+2)*100))))
//#else
//            else if(Charger.Current[0] > (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent?(Charger.maxRatingCurrent>20 ? ((Charger.maxRatingCurrent*Charger.OCP_Magnification)-100):((Charger.maxRatingCurrent+1)*100))  :  (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )-100):((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+1)*100))))
//#endif
            else if (Charger.Current[0] > OC_BegThreshold)
            {
                if(Charger.counter.L1_OC.fail > 6000)
                {
                    if(!(Charger.Alarm_Code & ALARM_L1_OVER_CURRENT))
                    {
                        Charger.counter.L1_OC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                        Charger.Alarm_Code |= ALARM_L1_OVER_CURRENT;
                        DEBUG_INFO("Correction Current[0]: %f\r\n", Charger.Current[0]/100.0);
                        DEBUG_ERROR("Alarm L1_OC occur.\r\n");
                        timerEnable(TIMER_IDX_RETRY_OC, ALARM_RETRY_INTERVAL_OC);
                        Charger.counter.L1_OC.retry++;
                    }
                }
                else
                    Charger.counter.L1_OC.fail++;
            }
            //else if((Charger.Current[0] < ((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent)?((Charger.maxRatingCurrent>20?(Charger.maxRatingCurrent*Charger.OCP_Magnification )-200:((Charger.maxRatingCurrent+2)*100)-200)):( (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )-200):(((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+2)*100)-200))))))
            else if (Charger.Current[0] < OC_EndThreshold)
            {
                Charger.counter.L1_OC.fail = 0;
                if (Charger.counter.L1_OC.retry> ALARM_OC_RETRY_COUNT)
                {
                    if (Charger.counter.L1_OC.isLatch == OFF)
                    {
                        Charger.counter.L1_OC.isLatch = ON ;
                        setLedMotion(LED_ACTION_ALARM);
                        timerDisable(TIMER_IDX_RETRY_OC);
                    }
                }
                else if((Charger.Alarm_Code & ALARM_L1_OVER_CURRENT) &&
                        (Charger.counter.L1_OC.retry <= ALARM_OC_RETRY_COUNT) &&
                        (timer[TIMER_IDX_RETRY_OC].isAlarm == ON) &&
                         blinker[BLINKER_IDX_LED].blinkisFinish )
                {
                    Charger.Alarm_Code &= ~ALARM_L1_OVER_CURRENT;
                    Charger.Alarm_Code &= ~ALARM_L1_CIRCUIT_SHORT;
                    DEBUG_INFO("Alarm L1_OC recover.\r\n");
                    if(!(Charger.Alarm_Code & ALARM_L1_OVER_CURRENT) && !(Charger.Alarm_Code & ALARM_L2_OVER_CURRENT) && !(Charger.Alarm_Code & ALARM_L3_OVER_CURRENT))
                      timerDisable(TIMER_IDX_RETRY_OC);
                }
            }
#ifdef FUNC_AUTO_IGNORE_AC_PHASE

#ifdef FUNC_AX32_USE_AS_1P_MODEL
        if (Charger.m_b3PhaseModel && !Charger.m_b3PhaseModelButUse1PhaseOnly)
#else
        if (Charger.m_b3PhaseModel)
#endif
        {
#endif
            //--------------------------------
            // L2 Over current
#ifdef FUNC_SET_AT32_MODEL_SCP_SPEC_VAL_HIGHER_TO_AVOID_SCP_ALARM
            if((u32)Charger.Current[1] >= CurSCP_SPEC)
#else
            if(Charger.Current[1] >= SCP_SPEC_VAL)
#endif
            {
                if(Charger.counter.L2_OC.fail > 5)
                {
                    if(!(Charger.Alarm_Code & ALARM_L2_CIRCUIT_SHORT))
                    {
                        Charger.counter.L2_OC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                        Charger.Alarm_Code |= ALARM_L2_CIRCUIT_SHORT;
                        if (Charger.counter.L2_OC.isLatch == OFF)
                        {
                            Charger.counter.L2_OC.isLatch = ON ;
                            setLedMotion(LED_ACTION_ALARM);
                            timerDisable(TIMER_IDX_RETRY_OC);
                        }
                        DEBUG_INFO("Correction Current[1]: %f\r\n", Charger.Current[1]/100.0);
                        DEBUG_ERROR("Alarm L2 SCP occur.\r\n");
                    }
                }
                else
                    Charger.counter.L2_OC.fail++;
            }
//#ifdef MODIFY_OCP_SPEC
//            else if(Charger.Current[1] > (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent?(Charger.maxRatingCurrent>20 ? ((Charger.maxRatingCurrent*Charger.OCP_Magnification)):((Charger.maxRatingCurrent+2)*100))  :  (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )):((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+2)*100))))
//#else
//            else if(Charger.Current[1] > (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent?(Charger.maxRatingCurrent>20 ? ((Charger.maxRatingCurrent*Charger.OCP_Magnification)-100):((Charger.maxRatingCurrent+1)*100))  :  (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )-100):((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+1)*100))))
//#endif
            else if (Charger.Current[1] > OC_BegThreshold)
            {
                if(Charger.counter.L2_OC.fail > 6000)
                {
                    if(!(Charger.Alarm_Code & ALARM_L2_OVER_CURRENT))
                    {
                        Charger.counter.L2_OC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                        Charger.Alarm_Code |= ALARM_L2_OVER_CURRENT;
                        DEBUG_INFO("Correction Current[1]: %f\r\n", Charger.Current[1]/100.0);
                        DEBUG_ERROR("Alarm L2_OC occur.\r\n");
                        timerEnable(TIMER_IDX_RETRY_OC, ALARM_RETRY_INTERVAL_OC);
                        Charger.counter.L2_OC.retry++;
                    }
                }
                else
                    Charger.counter.L2_OC.fail++;
            }
            //else if((Charger.Current[1] < ((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent)?((Charger.maxRatingCurrent>20?(Charger.maxRatingCurrent*Charger.OCP_Magnification )-200:((Charger.maxRatingCurrent+2)*100)-200)):( (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )-200):(((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+2)*100)-200))))))
            else if (Charger.Current[1] < OC_EndThreshold)
            {
                Charger.counter.L2_OC.fail = 0;
                if (Charger.counter.L2_OC.retry > ALARM_OC_RETRY_COUNT)
                {
                    if (Charger.counter.L2_OC.isLatch == OFF)
                    {
                        Charger.counter.L2_OC.isLatch = ON ;
                        setLedMotion(LED_ACTION_ALARM);
                        timerDisable(TIMER_IDX_RETRY_OC);
                    }
                }
                else if((Charger.Alarm_Code & ALARM_L2_OVER_CURRENT) &&
                        (Charger.counter.L2_OC.retry <= ALARM_OC_RETRY_COUNT) &&
                        (timer[TIMER_IDX_RETRY_OC].isAlarm == ON) &&
                         blinker[BLINKER_IDX_LED].blinkisFinish )
                {
                    Charger.Alarm_Code &= ~ALARM_L2_OVER_CURRENT;
                    Charger.Alarm_Code &= ~ALARM_L2_CIRCUIT_SHORT;
                    DEBUG_INFO("Alarm L2_OC recover.\r\n");
                    if(!(Charger.Alarm_Code & ALARM_L1_OVER_CURRENT) && !(Charger.Alarm_Code & ALARM_L2_OVER_CURRENT) && !(Charger.Alarm_Code & ALARM_L3_OVER_CURRENT))
                      timerDisable(TIMER_IDX_RETRY_OC);
                }
            }

            //--------------------------------
            // L3 Over current
#ifdef FUNC_SET_AT32_MODEL_SCP_SPEC_VAL_HIGHER_TO_AVOID_SCP_ALARM
            if((u32)Charger.Current[2] >= CurSCP_SPEC)
#else
            if(Charger.Current[2] >= SCP_SPEC_VAL)
#endif
            {
                if(Charger.counter.L3_OC.fail > 5)
                {
                    if(!(Charger.Alarm_Code & ALARM_L3_CIRCUIT_SHORT))
                    {
                        Charger.counter.L3_OC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                        Charger.Alarm_Code |= ALARM_L3_CIRCUIT_SHORT;
                        if (Charger.counter.L3_OC.isLatch == OFF)
                        {
                            Charger.counter.L3_OC.isLatch = ON ;
                            setLedMotion(LED_ACTION_ALARM);
                            timerDisable(TIMER_IDX_RETRY_OC);
                        }
                        DEBUG_INFO("Correction Current[2]: %f\r\n", Charger.Current[2]/100.0);
                        DEBUG_ERROR("Alarm L3 SCP occur.\r\n");
                    }
                }
                else
                    Charger.counter.L3_OC.fail++;
            }
//#ifdef MODIFY_OCP_SPEC
//            else if(Charger.Current[2] > (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent?(Charger.maxRatingCurrent>20 ? ((Charger.maxRatingCurrent*Charger.OCP_Magnification)):((Charger.maxRatingCurrent+2)*100))  :  (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )):((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+2)*100))))
//#else
//            else if(Charger.Current[2] > (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent?(Charger.maxRatingCurrent>20 ? ((Charger.maxRatingCurrent*Charger.OCP_Magnification)-100):((Charger.maxRatingCurrent+1)*100))  :  (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )-100):((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+1)*100))))
//#endif
            else if (Charger.Current[2] > OC_BegThreshold)
            {
                if(Charger.counter.L3_OC.fail > 6000)
                {
                    if(!(Charger.Alarm_Code & ALARM_L3_OVER_CURRENT))
                    {
                        Charger.counter.L3_OC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                        Charger.Alarm_Code |= ALARM_L3_OVER_CURRENT;
                        DEBUG_INFO("Correction Current[2]: %f\r\n", Charger.Current[2]/100.0);
                        DEBUG_ERROR("Alarm L3_OC occur.\r\n");
                        timerEnable(TIMER_IDX_RETRY_OC, ALARM_RETRY_INTERVAL_OC);
                        Charger.counter.L3_OC.retry++;
                    }
                }
                else
                    Charger.counter.L3_OC.fail++;
            }
            //else if((Charger.Current[2] < ((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent)?((Charger.maxRatingCurrent>20?(Charger.maxRatingCurrent*Charger.OCP_Magnification )-200:((Charger.maxRatingCurrent+2)*100)-200)):( (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )-200):(((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+2)*100)-200))))))
            else if (Charger.Current[2] < OC_EndThreshold)
            {
                Charger.counter.L3_OC.fail = 0;
                if (Charger.counter.L3_OC.retry > ALARM_OC_RETRY_COUNT)
                {
                    if (Charger.counter.L3_OC.isLatch == OFF)
                    {
                        Charger.counter.L3_OC.isLatch = ON ;
                        setLedMotion(LED_ACTION_ALARM);
                        timerDisable(TIMER_IDX_RETRY_OC);
                    }
                }
                else if((Charger.Alarm_Code & ALARM_L3_OVER_CURRENT) &&
                        (Charger.counter.L3_OC.retry <= ALARM_OC_RETRY_COUNT) &&
                        (timer[TIMER_IDX_RETRY_OC].isAlarm == ON) &&
                         blinker[BLINKER_IDX_LED].blinkisFinish )
                {
                    Charger.Alarm_Code &= ~ALARM_L3_OVER_CURRENT;
                    Charger.Alarm_Code &= ~ALARM_L3_CIRCUIT_SHORT;
                    DEBUG_INFO("Alarm L3_OC recover.\r\n");
                    if(!(Charger.Alarm_Code & ALARM_L1_OVER_CURRENT) && !(Charger.Alarm_Code & ALARM_L2_OVER_CURRENT) && !(Charger.Alarm_Code & ALARM_L3_OVER_CURRENT))
                      timerDisable(TIMER_IDX_RETRY_OC);
                }
            }
#ifdef FUNC_AUTO_IGNORE_AC_PHASE
        }
#endif
        }
#else //FUNC_OCP_WITH_PP

    //Old Procedure (Deleted)

#endif //FUNC_OCP_WITH_PP

#endif  //OCP_PROTECT

        //================================
        // Over temperature alarm detect
        //================================
#ifdef  OTP_PROTECT

#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
#ifdef MODIFY_OTP_SPEC
        //if (Charger.temperature.MaxTemp > Charger.alarm_spec.OT_2)
        if  (
                (Charger.temperature.Group1_MaxTemp > Charger.alarm_spec.OT_G1_2)
                ||
                (
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                    (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P || Charger.m_bModelNameAX80_NACS_1P) &&
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                    (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P) &&
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
#else //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
                    (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P) &&
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#else //FUNC_AW48_ADD_6_TEMP_SENEOR
                    Charger.m_bModelNameAX80_1P &&
#endif //FUNC_AW48_ADD_6_TEMP_SENEOR
                    Charger.temperature.Group2_MaxTemp > Charger.alarm_spec.OT_G2_2
                )
#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
                ||
                (
                    (Charger.m_bModelNameAW48_1P) &&
                    (
                        Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_2 ||
                        Charger.temperature.Group4_MaxTemp > Charger.alarm_spec.OT_G4_2
                    )
                )

#else //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
                ||
                (
                    (Charger.m_bModelNameAW48_1P) &&
                    Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_2
                )
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN

#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
                ||
                (
                    (Charger.m_bModelNameAX48_NACS_1P) &&
                    (
                        Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_2 ||
                        Charger.temperature.Group4_MaxTemp > Charger.alarm_spec.OT_G4_2
                    )
                )
#else //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
                ||
                (
                    (Charger.m_bModelNameAX48_NACS_1P) &&
                    Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_2
                )
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN

#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
                ||
                (
                    (Charger.m_bModelNameAX80_NACS_1P) &&
                    (
                        Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_2 ||
                        Charger.temperature.Group4_MaxTemp > Charger.alarm_spec.OT_G4_2
                    )
                )
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
            )
#else
        if (Charger.temperature.MaxTemp > ALARM_SPEC_OT_2)
#endif
#else //FUNC_AX80_ADD_4_TEMP_SENEOR
#ifdef MODIFY_OTP_SPEC
        if (Charger.temperature.SystemAmbientTemp > Charger.alarm_spec.OT_2)
#else
        if (Charger.temperature.SystemAmbientTemp > ALARM_SPEC_OT_2)
#endif
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR
        {
            if(Charger.counter.OT.fail > 2000)
            {
                if (Charger.counter.OT.isLatch == OFF)
                {
                    Charger.counter.OT.isLatch = ON ;
                    setLedMotion(LED_ACTION_ALARM);
                }

                if(!(Charger.Alarm_Code & ALARM_OVER_TEMPERATURE))
                {
                    Charger.counter.OT.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                    Charger.Alarm_Code |= ALARM_OVER_TEMPERATURE;
                    DEBUG_ERROR("Latch OT2 occur.\r\n");
#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
                    DEBUG_ERROR("OT_G1_MaxTemp = %d.\r\n",Charger.temperature.Group1_MaxTemp);
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                    if (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P || Charger.m_bModelNameAX80_NACS_1P)
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                    if (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P)
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
#else //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
                    if (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P)
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#else
                    if (Charger.m_bModelNameAX80_1P)
#endif
                    {
                        DEBUG_ERROR("OT_G2_MaxTemp = %d.\r\n",Charger.temperature.Group2_MaxTemp);
                    }

#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
                    if (Charger.m_bModelNameAW48_1P)
                    {
                        DEBUG_ERROR("OT_G3_MaxTemp = %d, OT_G4_MaxTemp = %d.\r\n",Charger.temperature.Group3_MaxTemp, Charger.temperature.Group4_MaxTemp);
                    }
#else //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
                    if (Charger.m_bModelNameAW48_1P)
                    {
                        DEBUG_ERROR("OT_G3_MaxTemp = %d.\r\n",Charger.temperature.Group3_MaxTemp);
                    }
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN

#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
                    if (Charger.m_bModelNameAX48_NACS_1P)
                    {
                        DEBUG_ERROR("OT_G3_MaxTemp = %d, OT_G4_MaxTemp = %d.\r\n",Charger.temperature.Group3_MaxTemp, Charger.temperature.Group4_MaxTemp);
                    }
#else //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
                    if (Charger.m_bModelNameAX48_NACS_1P)
                    {
                        DEBUG_ERROR("OT_G3_MaxTemp = %d.\r\n",Charger.temperature.Group3_MaxTemp);
                    }
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN

#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
                    if (Charger.m_bModelNameAX80_NACS_1P)
                    {
                        DEBUG_ERROR("OT_G3_MaxTemp = %d, OT_G4_MaxTemp = %d.\r\n",Charger.temperature.Group3_MaxTemp, Charger.temperature.Group4_MaxTemp);
                    }
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK


#else //FUNC_AX80_ADD_4_TEMP_SENEOR
                    DEBUG_ERROR("Tmp = %d.\r\n",Charger.temperature.SystemAmbientTemp);
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR
                }
            }
            else
                Charger.counter.OT.fail++;
        }
#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
#ifdef MODIFY_OTP_SPEC
        //else if((Charger.temperature.MaxTemp > Charger.alarm_spec.OT_1) && (!Charger.counter.OT.isLatch))
        else if
            (
                ((Charger.temperature.Group1_MaxTemp > Charger.alarm_spec.OT_G1_1) && (!Charger.counter.OT.isLatch))
                ||
                (
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                    (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P || Charger.m_bModelNameAX80_NACS_1P) &&
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                    (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P) &&
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
#else //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
                    (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P) &&
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#else
                    Charger.m_bModelNameAX80_1P &&
#endif
                    Charger.temperature.Group2_MaxTemp > Charger.alarm_spec.OT_G2_1 &&
                    !Charger.counter.OT.isLatch
                )

#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
                ||
                (
                    (Charger.m_bModelNameAW48_1P) &&
                    (
                        Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_1 ||
                        Charger.temperature.Group4_MaxTemp > Charger.alarm_spec.OT_G4_1
                    ) &&
                    !Charger.counter.OT.isLatch
                )
#else //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
                ||
                (
                    (Charger.m_bModelNameAW48_1P) &&
                    Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_1 &&
                    !Charger.counter.OT.isLatch
                )
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN

#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
                ||
                (
                    (Charger.m_bModelNameAX48_NACS_1P) &&
                    (
                        Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_1 ||
                        Charger.temperature.Group4_MaxTemp > Charger.alarm_spec.OT_G4_1
                    ) &&
                    !Charger.counter.OT.isLatch
                )
#else //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
                ||
                (
                    (Charger.m_bModelNameAX48_NACS_1P) &&
                    Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_1 &&
                    !Charger.counter.OT.isLatch
                )
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN

#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
                ||
                (
                    (Charger.m_bModelNameAX80_NACS_1P) &&
                    (
                        Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_1 ||
                        Charger.temperature.Group4_MaxTemp > Charger.alarm_spec.OT_G4_1
                    ) &&
                    !Charger.counter.OT.isLatch
                )
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
            )
#else
        else if((Charger.temperature.MaxTemp > ALARM_SPEC_OT_1) && (!Charger.counter.OT.isLatch))
#endif
#else //FUNC_AX80_ADD_4_TEMP_SENEOR
#ifdef MODIFY_OTP_SPEC
        else if((Charger.temperature.SystemAmbientTemp > Charger.alarm_spec.OT_1) && (!Charger.counter.OT.isLatch))
#else
        else if((Charger.temperature.SystemAmbientTemp > ALARM_SPEC_OT_1) && (!Charger.counter.OT.isLatch))
#endif
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR
        {
            if(Charger.counter.OT.fail > 1000)
            {
                if(!(Charger.Alarm_Code & ALARM_OVER_TEMPERATURE))
                {
                    Charger.counter.OT.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                    Charger.Alarm_Code |= ALARM_OVER_TEMPERATURE;
                    DEBUG_ERROR("Alarm OT occur.\r\n");

#ifdef FUNC_GUN_TEMP_LATCH
                    {
                        static u8 nGunOTP = 0;
                        u8 nTmp = nGunOTP;
                        if (Charger.m_bModelNameAW48_1P)
                        {
                            if (Charger.temperature.AW48_T5_L1_GUN > Charger.alarm_spec.OT_G4_1 ||
                                Charger.temperature.AW48_T6_L2_GUN > Charger.alarm_spec.OT_G4_1)
                                nGunOTP++;
                        }
                        else if (Charger.m_bModelNameAX48_NACS_1P)
                        {
                            if (Charger.temperature.AX48_NACS_T5_L1_GUN > Charger.alarm_spec.OT_G2_1 ||
                                Charger.temperature.AX48_NACS_T6_L2_GUN > Charger.alarm_spec.OT_G2_1)
                                nGunOTP++;
                        }
                        else if (Charger.m_bModelNameAX80_NACS_1P)
                        {
                            if (Charger.temperature.AX80_NACS_T5_L1_GUN > Charger.alarm_spec.OT_G2_1 ||
                                Charger.temperature.AX80_NACS_T6_L2_GUN > Charger.alarm_spec.OT_G2_1)
                                nGunOTP++;
                        }
                        if (nGunOTP >= 3)
                        {
                            Charger.counter.OT.isLatch = ON;
                            nGunOTP = 0;
                        }
                        if (nTmp != nGunOTP)
                        {
                            DEBUG_ERROR("Alarm GUN_OT(%d) %s\r\n", nGunOTP, Charger.counter.OT.isLatch ? "=> LATCH" : "");
                            //Alarm GUN_OT(3) => LATCH
                        }
                    }

#endif //FUNC_GUN_TEMP_LATCH
                }
            }
            else
                Charger.counter.OT.fail++;
        }
#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
#ifdef MODIFY_OTP_SPEC
        //else if((Charger.temperature.MaxTemp < (Charger.alarm_spec.OT_1 - Charger.alarm_spec.OT_HYSTERESIS)) && (!Charger.counter.OT.isLatch))
        else if
            (
                (Charger.temperature.Group1_MaxTemp < (Charger.alarm_spec.OT_G1_1 - Charger.alarm_spec.OT_G1_HYSTERESIS)) && (!Charger.counter.OT.isLatch)
#ifdef FUNC_MODIFY_OTP_RECOVER_PROCESS
                &&
#else
                ||
#endif
                (
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                    (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P || Charger.m_bModelNameAX80_NACS_1P) &&
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
                    (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P) &&
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
#else //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
                    (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P) &&
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#else //FUNC_AW48_ADD_6_TEMP_SENEOR
                    Charger.m_bModelNameAX80_1P &&
#endif //FUNC_AW48_ADD_6_TEMP_SENEOR
                    Charger.temperature.Group2_MaxTemp < (Charger.alarm_spec.OT_G2_1 - Charger.alarm_spec.OT_G2_HYSTERESIS) &&
                    !Charger.counter.OT.isLatch
                )

#ifdef FUNC_MODIFY_OTP_RECOVER_PROCESS

                //Do nothing

#else //FUNC_MODIFY_OTP_RECOVER_PROCESS
#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
                ||
                (
                    (Charger.m_bModelNameAW48_1P) &&
                    Charger.temperature.Group3_MaxTemp < (Charger.alarm_spec.OT_G3_1 - Charger.alarm_spec.OT_G3_HYSTERESIS) &&
                    !Charger.counter.OT.isLatch
                )
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN

#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
                ||
                (
                    (Charger.m_bModelNameAX48_NACS_1P) &&
                    Charger.temperature.Group3_MaxTemp < (Charger.alarm_spec.OT_G3_1 - Charger.alarm_spec.OT_G3_HYSTERESIS) &&
                    !Charger.counter.OT.isLatch
                )
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#endif //FUNC_MODIFY_OTP_RECOVER_PROCESS
            )

#else
        else if((Charger.temperature.MaxTemp < (ALARM_SPEC_OT_1-ALARM_SPEC_OT_HYSTERESIS)) && (!Charger.counter.OT.isLatch))
#endif
#else //FUNC_AX80_ADD_4_TEMP_SENEOR
#ifdef MODIFY_OTP_SPEC
        else if((Charger.temperature.SystemAmbientTemp < (Charger.alarm_spec.OT_1 - Charger.alarm_spec.OT_HYSTERESIS)) && (!Charger.counter.OT.isLatch))
#else
        else if((Charger.temperature.SystemAmbientTemp < (ALARM_SPEC_OT_1-ALARM_SPEC_OT_HYSTERESIS)) && (!Charger.counter.OT.isLatch))
#endif
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR
        {

#ifdef FUNC_MODIFY_OTP_RECOVER_PROCESS
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
            if (Charger.m_bModelNameAW48_1P)
            {
                if ( Charger.temperature.Group3_MaxTemp < (Charger.alarm_spec.OT_G3_1 - Charger.alarm_spec.OT_G3_HYSTERESIS) &&
                     Charger.temperature.Group4_MaxTemp < (Charger.alarm_spec.OT_G4_1 - Charger.alarm_spec.OT_G4_HYSTERESIS) &&
                    !Charger.counter.OT.isLatch)
                {
                    if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
                    {
                        Charger.counter.OT.retry++;
                        Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
                        DEBUG_INFO("Alarm OT recover.\r\n");
                    }
                }
            }
            else if (Charger.m_bModelNameAX48_NACS_1P)
            {
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
                if ( Charger.temperature.Group3_MaxTemp < (Charger.alarm_spec.OT_G3_1 - Charger.alarm_spec.OT_G3_HYSTERESIS) &&
                     Charger.temperature.Group4_MaxTemp < (Charger.alarm_spec.OT_G4_1 - Charger.alarm_spec.OT_G4_HYSTERESIS) &&
                    !Charger.counter.OT.isLatch)
                {
                    if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
                    {
                        Charger.counter.OT.retry++;
                        Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
                        DEBUG_INFO("Alarm OT recover.\r\n");
                    }
                }
#else //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
                if ( Charger.temperature.Group3_MaxTemp < (Charger.alarm_spec.OT_G3_1 - Charger.alarm_spec.OT_G3_HYSTERESIS) &&
                    !Charger.counter.OT.isLatch)
                {
                    if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
                    {
                        Charger.counter.OT.retry++;
                        Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
                        DEBUG_INFO("Alarm OT recover.\r\n");
                    }
                }
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
            }
#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
            else if (Charger.m_bModelNameAX80_NACS_1P)
            {
                if ( Charger.temperature.Group3_MaxTemp < (Charger.alarm_spec.OT_G3_1 - Charger.alarm_spec.OT_G3_HYSTERESIS) &&
                     Charger.temperature.Group4_MaxTemp < (Charger.alarm_spec.OT_G4_1 - Charger.alarm_spec.OT_G4_HYSTERESIS) &&
                    !Charger.counter.OT.isLatch)
                {
                    if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
                    {
                        Charger.counter.OT.retry++;
                        Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
                        DEBUG_INFO("Alarm OT recover.\r\n");
                    }
                }
            }
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
            else
            {

                Charger.counter.OT.fail = 0;

                if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
                {
                    Charger.counter.OT.retry++;
                    Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
                    DEBUG_INFO("Alarm OT recover.\r\n");
                }

            }
#else //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
            if (Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P)
            {
                if ( Charger.temperature.Group3_MaxTemp < (Charger.alarm_spec.OT_G3_1 - Charger.alarm_spec.OT_G3_HYSTERESIS) &&
                    !Charger.counter.OT.isLatch)
                {
                    if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
                    {
                        Charger.counter.OT.retry++;
                        Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
                        DEBUG_INFO("Alarm OT recover.\r\n");
                    }
                }
            }
            else
            {

                Charger.counter.OT.fail = 0;

                if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
                {
                    Charger.counter.OT.retry++;
                    Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
                    DEBUG_INFO("Alarm OT recover.\r\n");
                }

            }
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#else //FUNC_MODIFY_OTP_RECOVER_PROCESS

            Charger.counter.OT.fail = 0;

            if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
            {
                Charger.counter.OT.retry++;
                Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
                DEBUG_INFO("Alarm OT recover.\r\n");
            }

#endif //FUNC_MODIFY_OTP_RECOVER_PROCESS
        }
#endif  //OTP_PROTECT

        //================================
        // Current leakage alarm detect
        // TODO: ADC channel & spec need to check for other detection method
        //================================

#ifdef CCID_PROTECT
if (Charger.CCID_Module_Type == CCID_MODULE_VAC)
{
        //module test
        if((HAL_GPIO_ReadPin(IN_Leak_Error_GPIO_Port, IN_Leak_Error_Pin) == GPIO_PIN_SET) && (!Charger.isTestLeakModule))
        {
            if(Charger.counter.LEAK.fail > 1000)
            {
                if(!(Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL))
                {
                    Charger.counter.LEAK.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                    Charger.Alarm_Code |= ALARM_LEAK_MODULE_FAIL;
                    DEBUG_ERROR("Alarm leakage module error occur.\r\n");
                    timerEnable(TIMER_IDX_RETRY_LEAK, ALARM_RETRY_INTERVAL_LEAK);
                }
            }
            else
                Charger.counter.LEAK.fail++;
        }
        else
        {
            Charger.counter.LEAK.fail = 0;

            if((Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL) &&
               (Charger.counter.LEAK.retry < ALARM_RETRY_COUNT) &&
               (timer[TIMER_IDX_RETRY_LEAK].isAlarm == ON) &&
               blinker[BLINKER_IDX_LED].blinkisFinish)
            {
                timerDisable(TIMER_IDX_RETRY_LEAK);
                Charger.Alarm_Code &= ~ALARM_LEAK_MODULE_FAIL;
                osDelay(1000);
                #ifdef DEBUG
                DEBUG_INFO("Alarm leakage module error recover.\r\n");
                #endif
            }
        }

        //DC leakage
        if((HAL_GPIO_ReadPin(IN_Leak_DC_GPIO_Port, IN_Leak_DC_Pin) == GPIO_PIN_SET) && (!Charger.isTestLeakModule))
        {
            if(Charger.counter.LEAK_DC.fail > 10)
            {
                if(!(Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC))
                {
                    Charger.counter.LEAK_DC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                    Charger.Alarm_Code |= ALARM_CURRENT_LEAK_DC;
                    DEBUG_ERROR("Alarm DC leakage occur.\r\n");
                    timerEnable(TIMER_IDX_RETRY_LEAK_DC, ALARM_RETRY_INTERVAL_LEAK);
                    Charger.counter.LEAK_DC.retry++;
                }

                if (timer[TIMER_IDX_RETRY_LEAK_DC].isAlarm == ON || (Charger.counter.LEAK_DC.retry >ALARM_RETRY_COUNT))
                {
                  timerDisable(TIMER_IDX_RETRY_LEAK_DC);
                  //Charger.counter.LEAK.isLatch = ON ;
                  if (Charger.counter.LEAK.isLatch == OFF)
                  {
                      Charger.counter.LEAK.isLatch = ON ;
                      setLedMotion(LED_ACTION_ALARM);
                  }

                  DEBUG_ERROR("Alarm leakage DC isLatch.\r\n");
                }
            }
            else
                Charger.counter.LEAK_DC.fail++;
        }
        else
        {
            Charger.counter.LEAK_DC.fail = 0;

            if((Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC) &&
               (Charger.counter.LEAK_DC.retry <= ALARM_RETRY_COUNT) &&
               (timer[TIMER_IDX_RETRY_LEAK_DC].isAlarm == ON) &&
                blinker[BLINKER_IDX_LED].blinkisFinish)
            {
                timerDisable(TIMER_IDX_RETRY_LEAK_DC);
                Charger.Alarm_Code &= ~ALARM_CURRENT_LEAK_DC;
                DEBUG_INFO("Alarm DC leakage recover.\r\n");
            }

        }

        //AC leakage
        if((HAL_GPIO_ReadPin(IN_Leak_AC_GPIO_Port, IN_Leak_AC_Pin) == GPIO_PIN_SET) && (!Charger.isTestLeakModule))
        {
            if(Charger.counter.LEAK_AC.fail > 10)
            {
                if(!(Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC))
                {
                    Charger.counter.LEAK_AC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                    Charger.Alarm_Code |= ALARM_CURRENT_LEAK_AC;
                    DEBUG_ERROR("Alarm AC leakage occur.\r\n");
                    timerEnable(TIMER_IDX_RETRY_LEAK_AC, ALARM_RETRY_INTERVAL_LEAK);
                    Charger.counter.LEAK_AC.retry++;
                }

                if (timer[TIMER_IDX_RETRY_LEAK_AC].isAlarm == ON || (Charger.counter.LEAK_AC.retry > ALARM_RETRY_COUNT))
                {
                  timerDisable(TIMER_IDX_RETRY_LEAK_AC);
                  //Charger.counter.LEAK.isLatch = ON ;
                  if (Charger.counter.LEAK.isLatch == OFF)
                  {
                      Charger.counter.LEAK.isLatch = ON ;
                      setLedMotion(LED_ACTION_ALARM);
                  }
                  DEBUG_ERROR("Alarm leakage AC isLatch.\r\n");
                }
            }
            else
                Charger.counter.LEAK_AC.fail++;
        }
        else
        {
            Charger.counter.LEAK_AC.fail = 0;

            if((Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC) &&
               (Charger.counter.LEAK_AC.retry <= ALARM_RETRY_COUNT) &&
               (timer[TIMER_IDX_RETRY_LEAK_AC].isAlarm == ON) &&
               blinker[BLINKER_IDX_LED].blinkisFinish )
            {
                timerDisable(TIMER_IDX_RETRY_LEAK_AC);
                Charger.Alarm_Code &= ~ALARM_CURRENT_LEAK_AC;
                DEBUG_INFO("Alarm AC leakage recover.\r\n");

            }
        }
}
else // Charger.CCID_Module_Type is CCID_MODULE_CORMEX
{
        if((Charger.Leak_Current >= Charger.alarm_spec.Current_LEAK_AC) && (!Charger.isTestLeakModule)) // adc correction data to check
        {
            if(Charger.counter.LEAK.fail >= 5)
            {
                if(!(Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC))
                {
#ifdef FUNC_MODIFY_LEAK_AC_DISPLAY
                    XP("#Leak_Current (%d >= %d)\r\n", Charger.Leak_Current, Charger.alarm_spec.Current_LEAK_AC);
#else
                    XP("************************************************************\r\n");
                    XP("adc_value.ADC2_IN6_GF.value = %d\r\n", adc_value.ADC2_IN6_GF.value);
                    XP("Charger.Leak_Current(mA) = %d\r\n", Charger.Leak_Current);
                    XP("Charger.alarm_spec.Current_LEAK_AC(mA) = %d\r\n", Charger.alarm_spec.Current_LEAK_AC);
                    XP("Charger.isTestLeakModule = %s\r\n", Charger.isTestLeakModule ? "ON" : "OFF");
                    XP("************************************************************\r\n");
#endif
                    Charger.counter.LEAK.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                    Charger.Alarm_Code |= ALARM_CURRENT_LEAK_AC; //Hao##### CSU Charge error here
                    DEBUG_ERROR("Alarm leakage occur.\r\n");
                    timerEnable(TIMER_IDX_RETRY_LEAK_AC, ALARM_RETRY_INTERVAL_LEAK);
                    Charger.counter.LEAK.retry ++ ;
                }
            }
            else
            {
                Charger.counter.LEAK.fail++;
            }
        }
        else if (Charger.Leak_Current < (Charger.alarm_spec.Current_LEAK_AC - ALARM_SPEC_CURRENT_LEAK_HYSTERESIS)) // adc correction data  to check
        {
            Charger.counter.LEAK.fail = 0;

            if (Charger.counter.LEAK.retry > ALARM_LEAK_RETRY_COUNT)
            {
                if (Charger.counter.LEAK.isLatch == OFF)
                {
                    Charger.counter.LEAK.isLatch = ON ;
                    setLedMotion(LED_ACTION_ALARM);
                }
            }
            else
            {
                if(((Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC)||(Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC)) &&
                (Charger.counter.LEAK.retry <= ALARM_LEAK_RETRY_COUNT) &&
                (timer[TIMER_IDX_RETRY_LEAK_AC].isAlarm == ON) &&
                 blinker[BLINKER_IDX_LED].blinkisFinish )
                {
                  timerDisable(TIMER_IDX_RETRY_LEAK_AC);
                  osDelay(1000);
                  Charger.Alarm_Code &= ~ALARM_CURRENT_LEAK_AC;
                  DEBUG_INFO("Alarm leakage recover.\r\n");

                }
            }
        }
}

#endif  //CCID_PROTECT

        //================================
        // Ground fail alarm detect
        // TODO: Spec need to check
        //================================
#ifdef  GROUND_FAULT_PROTECT
        if(Charger.GroundingDetect==ON)
        {
            if (timer[TIMER_IDX_PE_DETECT].isAlarm == ON) // after 30 sec check (GMI adc_value > spec) and (GMI adc_value <= 1 )
            {
                  if(((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) >  (Charger.Voltage[0]*0.011)) || (adc_value.ADC3_IN4_GMI_VL1.value <= 1)) //Part FAIL
                  {

#ifdef TEST_GROUND_FAULT_PROTECT_TIME_TO_15_SEC
                      if(Charger.counter.GF.fail > 15000)
#else
                      if(Charger.counter.GF.fail > 4000)
#endif
                      {
                          if(!(Charger.Alarm_Code & ALARM_GROUND_FAIL))
                          {
                              Charger.counter.GF.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                              Charger.Alarm_Code |= ALARM_GROUND_FAIL;
                              DEBUG_ERROR("Alarm GF occur.\r\n");
#ifdef MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
                              Charger.counter.GF.restore = 0;
#endif

#ifdef DEBUG_ALARM_GROUND_FAIL
                              XP("#adc_value.ADC3_IN4_GMI_VL1.value = %d\r\n", adc_value.ADC3_IN4_GMI_VL1.value);
                              XP("#adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095 = %f\r\n", adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095);
                              XP("#Charger.Voltage[0]*0.011 = %f\r\n", Charger.Voltage[0]*0.011);
#endif
                          }
                      }
                      else
                          Charger.counter.GF.fail++;
                  }
                  else if((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) < (Charger.Voltage[0]*0.00566))
                  {
#ifdef MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
                        if((Charger.Alarm_Code & ALARM_GROUND_FAIL) && blinker[BLINKER_IDX_LED].blinkisFinish)
                        {
                            if (Charger.counter.GF.restore > 2000)
                            {
                                Charger.Alarm_Code &= ~ALARM_GROUND_FAIL;
                                DEBUG_INFO("Alarm GF recover.\r\n");
                                Charger.counter.GF.fail = 0;

                            }
                            else
                            {
                                Charger.counter.GF.restore++;
                            }
                        }
#else //MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
                      Charger.counter.GF.fail = 0;
                      if((Charger.Alarm_Code & ALARM_GROUND_FAIL) && blinker[BLINKER_IDX_LED].blinkisFinish)
                      {
                          Charger.counter.GF.retry++;
                          Charger.Alarm_Code &= ~ALARM_GROUND_FAIL;
                          DEBUG_INFO("Alarm GF recover.\r\n");
                      }
#endif //MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE

                  }
            }
            else  // before 30 sec check (GMI adc_value > spec)
            {
                if((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) > (Charger.Voltage[0]*0.011))
                {
                    if(Charger.counter.GF.fail > 4000)
                    {
                        if(!(Charger.Alarm_Code & ALARM_GROUND_FAIL))
                        {
                            Charger.counter.GF.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                            Charger.Alarm_Code |= ALARM_GROUND_FAIL;
                            DEBUG_ERROR("Alarm GF occur.\r\n");
#ifdef MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
                            Charger.counter.GF.restore = 0;
#endif
                        }
                    }
                    else
                        Charger.counter.GF.fail++;
                }
                else if((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) < (Charger.Voltage[0]*0.00566))
                {

#ifdef MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
                        //Charger.counter.GF.fail = 0;
                        if((Charger.Alarm_Code & ALARM_GROUND_FAIL) && blinker[BLINKER_IDX_LED].blinkisFinish)
                        {
                            if (Charger.counter.GF.restore > 2000)
                            {
                                Charger.Alarm_Code &= ~ALARM_GROUND_FAIL;
                                DEBUG_INFO("Alarm GF recover.\r\n");
                                Charger.counter.GF.fail = 0;

                            }
                            else
                            {
                                Charger.counter.GF.restore++;
                            }
                        }
#else //MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
                      Charger.counter.GF.fail = 0;
                      if((Charger.Alarm_Code & ALARM_GROUND_FAIL) && blinker[BLINKER_IDX_LED].blinkisFinish)
                      {
                          //osDelay(3000);
                          Charger.counter.GF.retry++;
                          Charger.Alarm_Code &= ~ALARM_GROUND_FAIL;
                          DEBUG_INFO("Alarm GF recover.\r\n");
                      }
#endif //MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
                }
             }
        }
#endif  //GROUND_FAULT_PROTECT

        //================================
        // Relay status error detect
        // TODO: ADC channel & spec need to check
        //================================

#ifdef MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK
#ifdef FUNC_USE_RELAY_B_CONTACT
        if (Charger.m_bUseRelayBContact)
            AlarmDetect_RelayWelding_UseGPIO();
        else
            AlarmDetect_RelayWelding_UseADC();
#else
        AlarmDetect_RelayWelding_UseADC();
#endif //FUNC_USE_RELAY_B_CONTACT
#endif //MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK

        //================================
        // Emergency stop alarm detect
        //================================
#ifdef  EMC_BUTTON_PROTECT
        if(HAL_GPIO_ReadPin(IN_Emergency_GPIO_Port, IN_Emergency_Pin) == GPIO_PIN_RESET)
        {
            if(Charger.counter.EMO.fail > 100)
            {
                if(!(Charger.Alarm_Code & ALARM_EMERGENCY_STOP))
                {
                    Charger.counter.EMO.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                    Charger.Alarm_Code |= ALARM_EMERGENCY_STOP;
                    DEBUG_ERROR("Alarm EMO occur.\r\n");
                }
            }
            else
                Charger.counter.EMO.fail++;
        }
        else
        {
            Charger.counter.EMO.fail = 0;
            if((Charger.Alarm_Code & ALARM_EMERGENCY_STOP) && blinker[BLINKER_IDX_LED].blinkisFinish)
            {
                Charger.counter.EMO.retry++;
                Charger.Alarm_Code &= ~ALARM_EMERGENCY_STOP;
                DEBUG_INFO("Alarm EMO recover.\r\n");
            }
        }
#endif  //EMC_BUTTON_PROTECT

        //================================
        // Handshaking timeout detect
        //================================
#ifdef  HANDSHAKE_PROTECT
        if(timer[TIMER_IDX_CP].isAlarm == ON)
        {
            if(!(Charger.Alarm_Code & ALARM_HANDSHAKE_TIMEOUT))
            {
                Charger.Alarm_Code |= ALARM_HANDSHAKE_TIMEOUT;
                timerDisable(TIMER_IDX_CP);
                Charger.rfid.op_bits.reqStart = OFF;
                Charger.istoHandShakeMode = OFF ;
                DEBUG_ERROR("Alarm handshake overtime occur.\r\n");
            }
        }
        else
        {
            if((Charger.Alarm_Code & ALARM_HANDSHAKE_TIMEOUT))
            {
                osDelay(10000);
                Charger.Alarm_Code &= ~ALARM_HANDSHAKE_TIMEOUT;
                DEBUG_INFO("Alarm handshake overtime recover.\r\n");
            }
	}
#endif  //HANDSHAKE_PROTECT

        //================================
        // Rotary Switch Maxium Current Error detect
        //================================
#ifdef  ROTATE_SWITCH_CHECK

        if (Charger.isRotarySwitchError)
        {
            if(!(Charger.Alarm_Code & ALARM_ROTATORY_SWITCH_FAULT))
            {
                Charger.Alarm_Code |= ALARM_ROTATORY_SWITCH_FAULT;
                if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
                {
#ifdef FUNC_AW48_EXT_LED_BLINK_PERIOD_MORE_THAN_200MS
                    if (Charger.m_bModelNameAW48_1P)
                    {
                        blinkerTimeSet(BLINKER_IDX_LED, AW48_EXTLED_BLINK_PERIOD, AW48_EXTLED_BLINK_PERIOD, 0, 1);
                    }
                    else
                    {
                        blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
                    }
#else
                    blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
#endif
                }
                DEBUG_INFO("Rotary Switch Maxium Current Error occur.\r\n");
            }
        }
#endif  //ROTATE_SWITCH_CHECK

        //================================
        // Meter communication timeout
        //================================
#ifdef  METER_TIMEOUT_CHECK

#ifdef FUNC_PTB_METER_WM3M4C
        if (Charger.m_bUseExtMeter_PRO380 || Charger.m_bUseExtMeter_WM3M4C)
#else
        if (Charger.m_bUseExtMeter_PRO380)
#endif
        {
#ifdef RECODE_METER_PRO380

            if (Charger.m_bUseExtMeter_PRO380 && Charger.m_pPRO380)
            {
                Charger.m_pPRO380->m_bCommTimeout = HTK_IsTimeout(Charger.m_pPRO380->m_LastUpdateTick, METER_EXT_COMM_TIMEOUT);
            }
            if (Charger.m_bUseExtMeter_WM3M4C && Charger.m_pWM3M4C)
            {
                Charger.m_pWM3M4C->m_bCommTimeout = HTK_IsTimeout(Charger.m_pWM3M4C->m_LastUpdateTick, METER_EXT_COMM_TIMEOUT);
            }

            if  (
                    (Charger.m_bUseExtMeter_PRO380 && Charger.m_pPRO380 && Charger.m_pPRO380->m_bCommTimeout) ||
                    (Charger.m_bUseExtMeter_WM3M4C && Charger.m_pWM3M4C && Charger.m_pWM3M4C->m_bCommTimeout)
                )
#else
#ifdef MODIFY_METER_EXT_PRO380

#ifdef FUNC_PTB_METER_WM3M4C
            if  (
                    (Charger.m_bUseExtMeter_PRO380 && HTK_IsTimeout(Charger.m_MeterPRO380.m_LastUpdateTick, METER_EXT_COMM_TIMEOUT)) ||
                    (Charger.m_bUseExtMeter_WM3M4C && HTK_IsTimeout(Charger.m_pWM3M4C->m_LastUpdateTick, METER_EXT_COMM_TIMEOUT))
                )
#else //FUNC_PTB_METER_WM3M4C
            if (HTK_IsTimeout(Charger.m_MeterPRO380.m_LastUpdateTick, METER_EXT_COMM_TIMEOUT))
#endif //FUNC_PTB_METER_WM3M4C

#else //MODIFY_METER_EXT_PRO380
            if (Charger.counter.Meter_Timeout.fail >= ALARM_SPEC_METER_TIMEOUT)
#endif //MODIFY_METER_EXT_PRO380
#endif //RECODE_METER_PRO380
            {
                if (!(Charger.Alarm_Code & ALARM_METER_TIMEOUT))
                {
                    Charger.Alarm_Code |= ALARM_METER_TIMEOUT;
                    if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
                    {
#ifdef FUNC_AW48_EXT_LED_BLINK_PERIOD_MORE_THAN_200MS
                        if (Charger.m_bModelNameAW48_1P)
                        {
                            blinkerTimeSet(BLINKER_IDX_LED, AW48_EXTLED_BLINK_PERIOD, AW48_EXTLED_BLINK_PERIOD, 0, 1);
                        }
                        else
                        {
                            blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
                        }
#else
                        blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
#endif
                    }
                    DEBUG_ERROR("Meter EXT COMM Timeout error occur.\r\n");
                }
            }
            else
            {
                if (Charger.Alarm_Code & ALARM_METER_TIMEOUT)
                {
                    Charger.Alarm_Code &= ~ALARM_METER_TIMEOUT;
                    DEBUG_INFO("Meter EXT COMM Timeout error recover.\r\n");
                }
            }
        }
        else
        {
            Charger.Alarm_Code &= ~ALARM_METER_TIMEOUT;
        }
#endif  //METER_TIMEOUT_CHECK

#ifdef FUNC_WARNING_CODE

#ifdef FUNC_EKM_OMNIMETER
        {
            const char s[] = "[WARN] Omnimeter timeout warning";
            if (Charger.m_bUseExtMeter_OMNIMETER && Charger.m_pEKM_Omnimeter)
            {
                if (Charger.m_pEKM_Omnimeter->m_bCommTimeout)
                {
                    if (!(Charger.Warning_Code & WARN_OMNIMETER_COMM_TIMEOUT))
                    {
                        Charger.Warning_Code |= WARN_OMNIMETER_COMM_TIMEOUT;
                        DEBUG_ERROR("%s occur.\r\n", s);
                    }
                }
                else
                {
                    if (Charger.Warning_Code & WARN_OMNIMETER_COMM_TIMEOUT)
                    {
                        Charger.Warning_Code &= ~WARN_OMNIMETER_COMM_TIMEOUT;
                        DEBUG_ERROR("%s recover.\r\n", s);
                    }
                }

            }
            else
            {
                if (Charger.Warning_Code & WARN_OMNIMETER_COMM_TIMEOUT)
                {
                    Charger.Warning_Code &= ~WARN_OMNIMETER_COMM_TIMEOUT;
                    DEBUG_ERROR("%s recover.\r\n", s);
                }
            }

        }
#endif //FUNC_EKM_OMNIMETER

#endif //FUNC_WARNING_CODE

#ifdef FUNC_METER_IC_COMM_ALARM
        if (HTK_IsTimeout(Charger.m_MeterIC_LastUpdateTick, METER_IC_COMM_TIMEOUT))
        {
            if (!(Charger.Alarm_Code & ALARM_METER_IC_TIMEOUT))
            {
                Charger.Alarm_Code |= ALARM_METER_IC_TIMEOUT;
                if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
                {
#ifdef FUNC_AW48_EXT_LED_BLINK_PERIOD_MORE_THAN_200MS
                    if (Charger.m_bModelNameAW48_1P)
                    {
                        blinkerTimeSet(BLINKER_IDX_LED, AW48_EXTLED_BLINK_PERIOD, AW48_EXTLED_BLINK_PERIOD, 0, 1);
                    }
                    else
                    {
                        blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
                    }
#else
                    blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
#endif
                }
                DEBUG_ERROR("Meter IC COMM Timeout error occur.\r\n");
            }
        }
        else
        {
            if (Charger.Alarm_Code & ALARM_METER_IC_TIMEOUT)
            {
                Charger.Alarm_Code &= ~ALARM_METER_IC_TIMEOUT;
                DEBUG_INFO("Meter IC COMM Timeout error recover.\r\n");
            }
        }
#endif //FUNC_METER_IC_COMM_ALARM

#ifdef GUN_LOCK_ALARM
        if (Charger.m_bUseGunLock)
        {
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
            static uint32_t AlarmOccurTick = 0;
#endif
            if  (
#ifdef FUNC_GUN_LOCK_TRIG_MODE

                (
                    Charger.m_GunLockTrigMode == GL_TRIG_MODE_RELAY &&
                    (
                        (GL_IsLock() && (Relay1_Action_Get() == GPIO_RELAY1_ACTION_OFF && Relay2_Action_Get() == GPIO_RELAY2_ACTION_OFF)) ||
                        (!GL_IsLock() && (Relay1_Action_Get() != GPIO_RELAY1_ACTION_OFF && Relay2_Action_Get() != GPIO_RELAY2_ACTION_OFF))
                    )
                )
#else
                (GL_IsLock() && (Relay1_Action_Get() == GPIO_RELAY1_ACTION_OFF && Relay2_Action_Get() == GPIO_RELAY2_ACTION_OFF)) ||
                (!GL_IsLock() && (Relay1_Action_Get() != GPIO_RELAY1_ACTION_OFF && Relay2_Action_Get() != GPIO_RELAY2_ACTION_OFF))
#endif

#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
                || (Charger.m_GunUnlock_Counter >= GUN_LOCK_PULSE_MAX_TIMES_CAUSE_ALARM)
                || (Charger.m_GunLock_Counter >= GUN_LOCK_PULSE_MAX_TIMES_CAUSE_ALARM)
#endif

                )
            {
                if (!(Charger.Alarm_Code & ALARM_LOCKER_FAULT))
                {
                    if (Charger.counter.GunLock.fail > 1000)
                    {
                        Charger.counter.GunLock.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                        Charger.Alarm_Code |= ALARM_LOCKER_FAULT;
                        DEBUG_ERROR("Alarm GunLock occur.\r\n");
                        Charger.counter.GunLock.restore = 0;
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
                        AlarmOccurTick = HAL_GetTick();;
#endif
                    }
                    else
                    {
                        Charger.counter.GunLock.fail++;
                    }
                }

#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
                if (Charger.Alarm_Code & ALARM_LOCKER_FAULT && HTK_IsTimeout(AlarmOccurTick, 1000 * 10))
                {
                    if (
                            (Charger.m_GunUnlock_Counter >= GUN_LOCK_PULSE_MAX_TIMES_CAUSE_ALARM) ||
                            (Charger.m_GunLock_Counter >= GUN_LOCK_PULSE_MAX_TIMES_CAUSE_ALARM)
                        )
                    {
                        Charger.m_GunUnlock_Counter = 0;
                        Charger.m_GunLock_Counter = 0;
                    }
                }
#endif
            }
            else
            {
                if (Charger.Alarm_Code & ALARM_LOCKER_FAULT)
                {
                    if (Charger.counter.GunLock.restore > 1000)
                    {
                        Charger.Alarm_Code &= ~ALARM_LOCKER_FAULT;
                        DEBUG_INFO("Alarm GunLock recover.\r\n");
                        Charger.counter.GunLock.fail = 0;

#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
                        Charger.m_GunUnlock_Counter = 0;
                        Charger.m_GunLock_Counter = 0;
#endif
                    }
                    else
                    {
                        Charger.counter.GunLock.restore++;
                    }
                }
            }

        }
        else
        {
            if (Charger.Alarm_Code & ALARM_LOCKER_FAULT)
            {
                Charger.Alarm_Code &= ~ALARM_LOCKER_FAULT;
            }

        }
#endif //GUN_LOCK_ALARM

#ifdef FUNC_AX80_ADD_TILT_SENSOR
#ifdef FUNC_ADD_TILT_SENSOR_MODEL
#ifdef FUNC_DISABLE_TILT_SENSOR_FOR_TEST
        if (Charger.m_bUseTiltSensor && !Charger.m_bDisableTiltSensorForTest)
#else
        if (Charger.m_bUseTiltSensor)
#endif
#else //FUNC_ADD_TILT_SENSOR_MODEL
        if (Charger.m_bModelNameAX80_1P)
#endif //FUNC_ADD_TILT_SENSOR_MODEL
        {
            AlarmDetect_TiltSensor();
        }
#endif //FUNC_AX80_ADD_TILT_SENSOR

        //================================
        // Recover alarm info in state A
        //================================
        if(Charger.CP_State == SYSTEM_STATE_A)
        {
            //SCP Recover
            if(Charger.Alarm_Code & ALARM_L1_CIRCUIT_SHORT)
            {
               Charger.Alarm_Code &= ~ALARM_L1_CIRCUIT_SHORT;
               DEBUG_INFO("Alarm L1 SCP recover.\r\n");
            }

            if(Charger.Alarm_Code & ALARM_L2_CIRCUIT_SHORT)
            {
               Charger.Alarm_Code &= ~ALARM_L2_CIRCUIT_SHORT;
               DEBUG_INFO("Alarm L2 SCP recover.\r\n");
            }

            if(Charger.Alarm_Code & ALARM_L3_CIRCUIT_SHORT)
            {
               Charger.Alarm_Code &= ~ALARM_L3_CIRCUIT_SHORT;
               DEBUG_INFO("Alarm L3 SCP recover.\r\n");
            }

            //OCP Recover
            if(Charger.Alarm_Code & ALARM_L1_OVER_CURRENT)
            {
               Charger.Alarm_Code &= ~ALARM_L1_OVER_CURRENT;
               DEBUG_INFO("Alarm L1 OC recover.\r\n");
            }

            if(Charger.Alarm_Code & ALARM_L2_OVER_CURRENT)
            {
               Charger.Alarm_Code &= ~ALARM_L2_OVER_CURRENT;
               DEBUG_INFO("Alarm L2 OC recover.\r\n");
            }

            if(Charger.Alarm_Code & ALARM_L3_OVER_CURRENT)
            {
               Charger.Alarm_Code &= ~ALARM_L3_OVER_CURRENT;
               DEBUG_INFO("Alarm L3 OC recover.\r\n");
            }

            timerDisable(TIMER_IDX_RETRY_OC);
            Charger.counter.L1_OC.fail = 0 ;
            Charger.counter.L1_OC.retry = 0 ;                     // clear retry times
            Charger.counter.L1_OC.isLatch = OFF ;

            Charger.counter.L2_OC.fail = 0 ;
            Charger.counter.L2_OC.retry = 0 ;                     // clear retry times
            Charger.counter.L2_OC.isLatch = OFF ;

            Charger.counter.L3_OC.fail = 0 ;
            Charger.counter.L3_OC.retry = 0 ;                     // clear retry times
            Charger.counter.L3_OC.isLatch = OFF ;


            //CCID Recover
            if (Charger.CCID_Module_Type == CCID_MODULE_VAC)
            {
              if ((HAL_GPIO_ReadPin(IN_Leak_AC_GPIO_Port, IN_Leak_AC_Pin) == GPIO_PIN_RESET) && (Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC))
              {
                  Charger.Alarm_Code &= ~ALARM_CURRENT_LEAK_AC;
                  DEBUG_INFO("Alarm leakage AC recover for VAC.\r\n");
              }
              if ((HAL_GPIO_ReadPin(IN_Leak_DC_GPIO_Port, IN_Leak_DC_Pin) == GPIO_PIN_RESET) && (Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC))
              {
                  Charger.Alarm_Code &= ~ALARM_CURRENT_LEAK_DC;
                  DEBUG_INFO("Alarm leakage DC recover for VAC.\r\n");
              }
            }
            else //Charger.CCID_Module_Type is CCID_MODULE_CORMEX
            {

#ifdef MODIFY_ALARM_LEAKAGE_RECOVER

              if((Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC))
              {
                  Charger.Alarm_Code &= ~ALARM_CURRENT_LEAK_AC;
                  DEBUG_INFO("Alarm AC leakage recover.\r\n");
              }
#else
              if((Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC)||(Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC))
              {
                  Charger.Alarm_Code &= ~ALARM_CURRENT_LEAK_AC;
                  DEBUG_INFO("Alarm leakage recover.\r\n");
              }

#endif //MODIFY_ALARM_LEAKAGE_RECOVER

            }

            Charger.counter.LEAK.fail = 0;
            timerDisable(TIMER_IDX_RETRY_LEAK) ;
            timerDisable(TIMER_IDX_RETRY_LEAK_AC) ;
            timerDisable(TIMER_IDX_RETRY_LEAK_DC) ;
            Charger.counter.LEAK.retry = 0 ;            // clear latch times
            Charger.counter.LEAK_DC.retry = 0 ;         // clear latch times
            Charger.counter.LEAK_AC.retry = 0 ;         // clear latch times
            Charger.counter.LEAK.isLatch = OFF ;

#ifdef FUNC_UNPLUG_GUN_TO_RELEASE_TEMP_LATCH
             Charger.counter.OT.isLatch = OFF;
#endif

            //LEAK_MODULE selfrest Recover
            if (Charger.CCID_Module_Type == CCID_MODULE_VAC)
            {
                if(Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL & (HAL_GPIO_ReadPin(IN_Leak_Error_GPIO_Port, IN_Leak_Error_Pin) == GPIO_PIN_RESET))   // leak module is VAC
                {
                  if ((Charger.counter.LEAK_MODULE.retry < 2) && (!Charger.counter.LEAK_MODULE.isLatch))
                  {
                      Charger.Alarm_Code &= ~ALARM_LEAK_MODULE_FAIL;
                      DEBUG_INFO("Alarm leakage module recover.\r\n");
                  }
                }
            }
            else //Charger.CCID_Module_Type is CCID_MODULE_CORMEX
            {
                if(Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL)  // leak module is CORMEX
                {
                  if ((Charger.counter.LEAK_MODULE.retry < 2) && (!Charger.counter.LEAK_MODULE.isLatch))
                  {
                      Charger.Alarm_Code &= ~ALARM_LEAK_MODULE_FAIL;
                      DEBUG_INFO("Alarm leakage module recover.\r\n");
                  }
                }
            }
        }
    }
    else if (Charger.Mode == MODE_DEBUG)
    {

         //================================
        // Relay status error detect
        // TODO: ADC channel & spec need to check
        //================================

#ifdef MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK
#ifdef FUNC_USE_RELAY_B_CONTACT
        if (Charger.m_bUseRelayBContact)
            AlarmDetect_RelayWelding_UseGPIO();
        else
            AlarmDetect_RelayWelding_UseADC();
#else
        AlarmDetect_RelayWelding_UseADC();
#endif //FUNC_USE_RELAY_B_CONTACT
#endif //MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK

    }

#ifdef FUNC_RESET_DATA_AFTER_WRITE_NEW_MODELNAME
    if (Charger.m_bTrigToClearAlarmCode)
    {
        Charger.m_bTrigToClearAlarmCode = HTK_FALSE;
        Charger.Alarm_Code = 0;
    }
#endif

    osDelay(1);
  }
  /* USER CODE END StartAlarmTask */
}

/* USER CODE BEGIN Header_StartBleTask */
/**
* @brief Function implementing the bleTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartBleTask */
void StartBleTask(void const * argument)
{
  /* USER CODE BEGIN StartBleTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    IdleUntilReadAllMemory();
#endif

    char tmpBuf[128];
    uint8_t endFlag[4]={0x55,0xaa,0x55,0xaa};
    __IO uint32_t flash;
    uint32_t checksum;
    uint32_t rndNumber;

    //=====================================
    // Module reset
    //=====================================
    HAL_GPIO_WritePin(OUT_BLE_RESET_GPIO_Port, OUT_BLE_RESET_Pin, GPIO_PIN_RESET);
    osDelay(60);
    HAL_GPIO_WritePin(OUT_BLE_RESET_GPIO_Port, OUT_BLE_RESET_Pin, GPIO_PIN_SET);
    HAL_GPIO_WritePin(OUT_BLE_DSR_GPIO_Port, OUT_BLE_DSR_Pin, GPIO_PIN_SET);

    Charger.ble.initSeq = 0;
    Charger.ble.isDataMode = OFF;
    UART_BLE_Init_OK = OFF;

    osDelay(1000);

    /* Infinite loop */
    for(;;)
    {
        //=====================================
        // BLE module initialization process
        //=====================================
		switch(Charger.ble.initSeq)
        {
            case 0x00:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_RESTORE], strlen(BLE_CMD[BLE_CMD_SET_RESTORE]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x01:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_ROLE], strlen(BLE_CMD[BLE_CMD_SET_ROLE]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x02:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_DTR], strlen(BLE_CMD[BLE_CMD_SET_DTR]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x03:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_DSR], strlen(BLE_CMD[BLE_CMD_SET_DSR]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x04:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_PAIRING_MODE], strlen(BLE_CMD[BLE_CMD_SET_PAIRING_MODE]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x05:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_SECURITY_MODE], strlen(BLE_CMD[BLE_CMD_SET_SECURITY_MODE]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x06:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_SECURITY_TYPE], strlen(BLE_CMD[BLE_CMD_SET_SECURITY_TYPE]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x07:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_DISCOVERABILITY], strlen(BLE_CMD[BLE_CMD_SET_DISCOVERABILITY]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x08:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_CONNECTABILITY], strlen(BLE_CMD[BLE_CMD_SET_CONNECTABILITY]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x09:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_GET_ADDR], strlen(BLE_CMD[BLE_CMD_GET_ADDR]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x0a:
                sprintf(tmpBuf, "%s\"BYTON_EVSE_%s\"\r\n", BLE_CMD[BLE_CMD_SET_NAME], Charger.ble.peripheral_mac);
                DEBUG_INFO("BLE module set name:BYTON_EVSE_%s\r\n", Charger.ble.peripheral_mac);
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)tmpBuf, strlen(tmpBuf), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x0b:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_MAX_POWER], strlen(BLE_CMD[BLE_CMD_SET_MAX_POWER]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x0c:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_MIN_INTERVAL], strlen(BLE_CMD[BLE_CMD_SET_MIN_INTERVAL]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x0d:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_MAX_INTERVAL], strlen(BLE_CMD[BLE_CMD_SET_MAX_INTERVAL]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x0e:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_TX_PHY], strlen(BLE_CMD[BLE_CMD_SET_TX_PHY]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x0f:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_RX_PHY], strlen(BLE_CMD[BLE_CMD_SET_RX_PHY]), 0xffff);
                osDelay(BLE_INIT_DELAY);
                break;
            case 0x10:
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_DATA_MODE], strlen(BLE_CMD[BLE_CMD_SET_DATA_MODE]), 0xffff);
                DEBUG_INFO("BLE module switch to data mode.\r\n");
                osDelay(BLE_INIT_DELAY);
            default:
                UART_BLE_Init_OK = ON;
                break;
        }

        //=====================================
        // BLE central device connect status
        //=====================================
        if((HAL_GPIO_ReadPin(IN_BLE_DTR_GPIO_Port, IN_BLE_DTR_Pin) ==  GPIO_PIN_SET) && (UART_BLE_Init_OK == ON))
        {
            // Device disconnect
            timerRefresh(TIMER_IDX_BLE);
            if(Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT || Charger.ble.loginRole == BLE_LOGIN_ROLE_USER)
            {
                DEBUG_INFO("BLE central device disconnect.\r\n.");
                Charger.ble.loginRole = BLE_LOGIN_ROLE_UNKOWN;
            }
        }
        else  if((HAL_GPIO_ReadPin(IN_BLE_DTR_GPIO_Port, IN_BLE_DTR_Pin) ==  GPIO_PIN_RESET) && (UART_BLE_Init_OK == ON))
        {
            // Device connect in
            if(Charger.ble.loginRole == BLE_LOGIN_ROLE_UNKOWN)
            {
                DEBUG_INFO("BLE central device connect.....wait sign in.\r\n.");
                osDelay(1000);
            }
        }

        //=====================================
        // Communication timeout process
        //=====================================
        if(timer[TIMER_IDX_BLE].isAlarm)
        {
            Charger.ble.loginRole = BLE_LOGIN_ROLE_UNKOWN;
            DEBUG_INFO("BLE no communication over time, disconnect central device.\r\n");
            timerRefresh(TIMER_IDX_BLE);

            HAL_GPIO_WritePin(OUT_BLE_DSR_GPIO_Port, OUT_BLE_DSR_Pin, GPIO_PIN_RESET);
            osDelay(100);
            HAL_GPIO_WritePin(OUT_BLE_DSR_GPIO_Port, OUT_BLE_DSR_Pin, GPIO_PIN_SET);
        }

        //=====================================
        // BLE uart recieve data process
        //=====================================
        if(UART_BLE_recv_end_flag == ON)
        {
            if((HAL_GPIO_ReadPin(IN_BLE_DTR_GPIO_Port, IN_BLE_DTR_Pin) ==  GPIO_PIN_SET) || !Charger.ble.isDataMode)
            {
                // AT command rx process
                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_RESTORE])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_ROLE])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_DTR])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_DSR])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_PAIRING_MODE])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_SECURITY_MODE])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_SECURITY_TYPE])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_DISCOVERABILITY])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_CONNECTABILITY])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_GET_ADDR])!=NULL)
                {
                    memcpy(Charger.ble.peripheral_mac, &UART_BLE_rx_buffer[strcspn((char *)UART_BLE_rx_buffer, ":")+1], 12);
                    Charger.ble.peripheral_mac[12] = '\0';
                    DEBUG_INFO("Peripheral mac address: %s\r\n", Charger.ble.peripheral_mac);
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_NAME])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_MAX_POWER])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_MIN_INTERVAL])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_MAX_INTERVAL])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_TX_PHY])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_RX_PHY])!=NULL)
                {
                    Charger.ble.initSeq++;
                }

                if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_DATA_MODE])!=NULL)
                {
                    Charger.ble.isDataMode = ON;
                    Charger.ble.initSeq++;
                }
            }
            else
            {
                // Application protocol rx process
                uint8_t tx[UART_BUFFER_SIZE];
                uint8_t tx_len;
                uint8_t chksum = 0;
                uint32_t tmp;

                if(isValidCheckSum_BLE() && (rndNumber != ((UART_BLE_rx_buffer[3]<<0) | (UART_BLE_rx_buffer[4]<<8) | (UART_BLE_rx_buffer[5]<<16) | (UART_BLE_rx_buffer[6]<<24))))
                {
                    // Timer reset
                    timerRefresh(TIMER_IDX_BLE);
                    rndNumber = ((UART_BLE_rx_buffer[3]<<0) | (UART_BLE_rx_buffer[4]<<8) | (UART_BLE_rx_buffer[5]<<16) | (UART_BLE_rx_buffer[6]<<24));

                    switch(UART_BLE_rx_buffer[2])
                    {
                        case BLE_PROTOCOL_MESSAGE_SIGN_IN:
                            DEBUG_INFO("BLE device sign request...%d\r\n", UART_BLE_rx_buffer[7]);
                            tx_len = 5;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;
                            tx[3] = 0x00;

                            if(Charger.memory.EVSE_Config.data.item.bleConfig.isRegPuk)
                            {
                                if(UART_BLE_rx_buffer[7] == 0x00)
                                {
                                    if(memcmp(&UART_BLE_rx_buffer[8], &Charger.memory.EVSE_Config.data.item.bleConfig.idRoot[0], ((UART_BLE_rx_buffer[0]<<8) | (UART_BLE_rx_buffer[1]<<0)-9)) == 0)
                                    {
                                        // Root sign in
                                        tx[3] = 0x02;
                                        Charger.ble.loginRole = BLE_LOGIN_ROLE_ROOT;
                                        DEBUG_INFO("Sign in as root.\r\n");
                                    }
                                }
                                else
                                {
                                    if(memcmp(&UART_BLE_rx_buffer[8], &Charger.memory.whiteList.data.item[0].pin[0], ((UART_BLE_rx_buffer[0]<<8) | (UART_BLE_rx_buffer[1]<<0)-9)) == 0)
                                    {
                                        // User sign in
                                        tx[3] = 0x03;
                                        Charger.ble.loginRole = BLE_LOGIN_ROLE_USER;
                                        DEBUG_INFO("Sign in as user.\r\n");
                                    }
                                }
                            }
                            else
                            {
                                if(UART_BLE_rx_buffer[7] == 0x00)
                                {
                                    // Visitor
                                    tx[3] = 0x01;
                                    Charger.ble.loginRole = BLE_LOGIN_ROLE_VISITOR;
                                    memcpy(&Charger.ble.loginId[0], &UART_BLE_rx_buffer[8], ((UART_BLE_rx_buffer[0]<<8) | (UART_BLE_rx_buffer[1]<<0)-9) );
                                    DEBUG_WARN("Sign in as visitor.\r\n");
                                }
                            }

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[4] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_PUK_REG:
                            DEBUG_INFO("BLE device PUK registe.%02x%02x%02x%02x%02x%02x%02x%02x\r\n", UART_BLE_rx_buffer[7], UART_BLE_rx_buffer[8], UART_BLE_rx_buffer[9], UART_BLE_rx_buffer[10], UART_BLE_rx_buffer[11], UART_BLE_rx_buffer[12], UART_BLE_rx_buffer[13], UART_BLE_rx_buffer[14]);
                            tx_len = 11;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;
                            tx[3] = 0x00;

                            if(Charger.memory.EVSE_Config.data.item.bleConfig.isRegPuk)
                            {
                                 if(memcmp(&Charger.ble.loginId[0], &Charger.memory.EVSE_Config.data.item.bleConfig.idRoot[0], ARRAY_SIZE(Charger.ble.loginId)))
                                 {
                                    tx[3] = 0x02;
                                    DEBUG_INFO("ID registered exist.\r\n");
                                 }
                            }
                            else
                            {
                                if(Charger.ble.loginRole == BLE_LOGIN_ROLE_VISITOR)
                                {
                                    if(memcmp(&UART_BLE_rx_buffer[7], &Charger.memory.EVSE_Config.data.item.bleConfig.puk[0], 8) == 0x00)
                                    {
                                        tx[3] = 0x01;

                                        // PIN list generation
                                        Charger.memory.EVSE_Config.data.item.bleConfig.isGenPin = ON;
                                        for(uint8_t idx=0;idx<20;idx++)
                                        {
                                            Charger.memory.whiteList.data.item[idx].listType = WHITE_LIST_TYPE_BLE;
                                            Charger.memory.whiteList.data.item[idx].pin[0] = (rand()%0x2b)+0x30;
                                            Charger.memory.whiteList.data.item[idx].pin[1] = (rand()%0x2b)+0x30;
                                            Charger.memory.whiteList.data.item[idx].pin[2] = (rand()%0x2b)+0x30;
                                            Charger.memory.whiteList.data.item[idx].pin[3] = (rand()%0x2b)+0x30;
                                            Charger.memory.whiteList.data.item[idx].pin[4] = (rand()%0x2b)+0x30;
                                            Charger.memory.whiteList.data.item[idx].pin[5] = (rand()%0x2b)+0x30;
                                            Charger.memory.whiteList.data.item[idx].isReg = OFF;
                                        }
                                        Charger.memory.whiteList.op_bits.update = ON;

                                        Charger.memory.EVSE_Config.data.item.bleConfig.isRegPuk = ON;
                                        memcpy(&Charger.memory.EVSE_Config.data.item.bleConfig.idRoot[0], &Charger.ble.loginId[0], ARRAY_SIZE(Charger.ble.loginId));
                                        Charger.memory.EVSE_Config.op_bits.update = ON;

                                        DEBUG_INFO("Root registered and PIN list generate success.\r\n");
                                    }
                                }
                            }

                            memcpy(&tx[4], &UART_BLE_rx_buffer[7], 6);
                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[10] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_PIN_GET:
                            DEBUG_INFO("PIN get request.\r\n");
                            tx_len = 11;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;;
                            tx[3] = 0x00;

                            if(Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT)
                            {
                                tx[3] = 0x01;
                                memcpy(&tx[4], &Charger.memory.whiteList.data.item[0].pin[0], 6);
                                DEBUG_INFO("PIN: %s\r\n", Charger.memory.whiteList.data.item[0].pin);
                            }

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[10] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_PIN_RENEW:
                            DEBUG_INFO("BLE device PIN renew request.\r\n");
                            tx_len = 13;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;;
                            tx[3] = 0x00;

                            if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT))
                            {
                                for(uint8_t idx=0;idx<20;idx++)
                                {
                                    Charger.memory.whiteList.data.item[idx].listType = WHITE_LIST_TYPE_BLE;
                                    Charger.memory.whiteList.data.item[idx].pin[0] = (rand()%0x2b)+0x30;
                                    Charger.memory.whiteList.data.item[idx].pin[1] = (rand()%0x2b)+0x30;
                                    Charger.memory.whiteList.data.item[idx].pin[2] = (rand()%0x2b)+0x30;
                                    Charger.memory.whiteList.data.item[idx].pin[3] = (rand()%0x2b)+0x30;
                                    Charger.memory.whiteList.data.item[idx].pin[4] = (rand()%0x2b)+0x30;
                                    Charger.memory.whiteList.data.item[idx].pin[5] = (rand()%0x2b)+0x30;
                                    Charger.memory.whiteList.data.item[idx].isReg = OFF;
                                }
                                Charger.memory.whiteList.op_bits.update = ON;
                                tx[3] = 0x01;
                                memcpy(&tx[4], &Charger.memory.whiteList.data.item[0].pin[0], 6);

                                DEBUG_INFO("PIN list renew: %s.\r\n", Charger.memory.whiteList.data.item[0].pin);
                            }
                            else
                                DEBUG_WARN("Login id not root.\r\n");

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[4] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_CHARGING_START:
                            DEBUG_INFO("BLE device request charging start.\r\n");
                            tx_len = 0x08;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;

                            if(Charger.Alarm_Code>0)
                            {
                                tx[3] = 0x02;
                                if((Charger.Alarm_Code & ALARM_L1_OVER_VOLTAGE))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x00;
                                }
                                else if((Charger.Alarm_Code & ALARM_L1_UNDER_VOLTAGE))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x03;
                                }
                                else if((Charger.Alarm_Code & ALARM_L1_OVER_CURRENT))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x21;
                                    tx[6] = 0x16;
                                }
                                else if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x23;
                                }
                                else if((Charger.Alarm_Code & ALARM_GROUND_FAIL))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x56;
                                }
                                else if((Charger.Alarm_Code & ALARM_CP_ERROR))
                                {
                                    tx[4] = 0x02;
                                    tx[5] = 0x37;
                                    tx[6] = 0x03;
                                }
                                else if((Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC)||(Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x33;
                                }
                                else if((Charger.Alarm_Code & ALARM_MCU_TESTFAIL))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x57;
                                }
                                else if((Charger.Alarm_Code & ALARM_EMERGENCY_STOP))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x51;
                                }
                                else if((Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x10;
                                    tx[6] = 0x04;
                                }
                                else if((Charger.Alarm_Code & ALARM_RELAY_STATUS))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x58;
                                }
                                DEBUG_WARN("EVSE in alarm state, can not start charging.\r\n");
                            }
                            else
                            {
                                if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
                                {
                                    if(Charger.Mode == MODE_IDLE)
                                    {
                                        Charger.ble.isRequestOn = ON;
                                        tx[3] = 0x01;
                                        DEBUG_INFO("Start OK.\r\n");
                                    }
                                    else
                                    {
                                        tx[3] = 0x00;
                                        DEBUG_WARN("EVSE not in IDLE.\r\n");
                                    }
                                }
                                else
                                {
                                    tx[3] = 0x00;
                                    DEBUG_WARN("Login first\r\n");
                                }

                                tx[4] = 0x00;
                                tx[5] = 0x00;
                                tx[6] = 0x00;
                            }

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[7] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_CHARGING_STOP:
                            DEBUG_INFO("BLE device request charging stop.\r\n");
                            tx_len = 0x08;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;

                            if(Charger.Alarm_Code>0)
                            {
                                tx[3] = 0x02;
                                if((Charger.Alarm_Code & ALARM_L1_OVER_VOLTAGE))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x00;
                                }
                                else if((Charger.Alarm_Code & ALARM_L1_UNDER_VOLTAGE))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x03;
                                }
                                else if((Charger.Alarm_Code & ALARM_L1_OVER_CURRENT))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x21;
                                    tx[6] = 0x16;
                                }
                                else if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x23;
                                }
                                else if((Charger.Alarm_Code & ALARM_GROUND_FAIL))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x56;
                                }
                                else if((Charger.Alarm_Code & ALARM_CP_ERROR))
                                {
                                    tx[4] = 0x02;
                                    tx[5] = 0x37;
                                    tx[6] = 0x03;
                                }
                                else if((Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC)||(Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x33;
                                }
                                else if((Charger.Alarm_Code & ALARM_MCU_TESTFAIL))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x57;
                                }
                                else if((Charger.Alarm_Code & ALARM_EMERGENCY_STOP))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x51;
                                }
                                else if((Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x10;
                                    tx[6] = 0x04;
                                }
                                else if((Charger.Alarm_Code & ALARM_RELAY_STATUS))
                                {
                                    tx[4] = 0x01;
                                    tx[5] = 0x22;
                                    tx[6] = 0x58;
                                }
                                DEBUG_WARN("EVSE in alarm state, can not stop charging.\r\n");
                            }
                            else
                            {
                                if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
                                {
                                    if((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))
                                    {
                                        Charger.ble.isRequestOff = ON;
                                        tx[3] = 0x01;
                                        DEBUG_INFO("Stop OK.\r\n");
                                    }
                                    else
                                    {
                                        tx[3] = 0x00;
                                        DEBUG_WARN("EVSE not in CHARGING.\r\n");
                                    }
                                }
                                else
                                {
                                    tx[3] = 0x00;
                                    DEBUG_WARN("Login first\r\n");
                                }

                                tx[4] = 0x00;
                                tx[5] = 0x00;
                                tx[6] = 0x00;
                            }

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[7] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_STATUS_QUERY:
                            DEBUG_INFO("BLE device query EVSE status request.\r\n");
                            tx_len = 0x13;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;

                            tx[3] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?Charger.Mode:0x00);
                            tx[4] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?((((uint32_t)(Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total/10000))>>0) & 0xff):0x00);
                            tx[5] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?((((uint32_t)(Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total/10000))>>8) & 0xff):0x00);
                            tx[6] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?((((uint32_t)(Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total/10000))>>16) & 0xff):0x00);
                            tx[7] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?((((uint32_t)(Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total/10000))>>24) & 0xff):0x00);

                            tx[8] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?(((Charger.cycle_info.Power_Consumption/10)>>0) & 0xff):0x00);
                            tx[9] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?(((Charger.cycle_info.Power_Consumption/10)>>8) & 0xff):0x00);
                            tx[10] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?(((Charger.cycle_info.Duration/60000)>>0) & 0xff):0x00);
                            tx[11] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?(((Charger.cycle_info.Duration/60000)>>8) & 0xff):0x00);
                            if((Charger.Alarm_Code>0) && ((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER)))
                            {
                                if((Charger.Alarm_Code & ALARM_L1_OVER_VOLTAGE))
                                {
                                    tx[12] = 0x01;
                                    tx[13] = 0x22;
                                    tx[14] = 0x00;
                                }
                                else if((Charger.Alarm_Code & ALARM_L1_UNDER_VOLTAGE))
                                {
                                    tx[12] = 0x01;
                                    tx[13] = 0x22;
                                    tx[14] = 0x03;
                                }
                                else if((Charger.Alarm_Code & ALARM_L1_OVER_CURRENT))
                                {
                                    tx[12] = 0x01;
                                    tx[13] = 0x21;
                                    tx[14] = 0x16;
                                }
                                else if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE))
                                {
                                    tx[12] = 0x01;
                                    tx[13] = 0x22;
                                    tx[14] = 0x23;
                                }
                                else if((Charger.Alarm_Code & ALARM_GROUND_FAIL))
                                {
                                    tx[12] = 0x01;
                                    tx[13] = 0x22;
                                    tx[14] = 0x56;
                                }
                                else if((Charger.Alarm_Code & ALARM_CP_ERROR))
                                {
                                    tx[12] = 0x02;
                                    tx[13] = 0x37;
                                    tx[14] = 0x03;
                                }
                                else if((Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC)||(Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC))
                                {
                                    tx[12] = 0x01;
                                    tx[13] = 0x22;
                                    tx[14] = 0x33;
                                }
                                else if((Charger.Alarm_Code & ALARM_MCU_TESTFAIL))
                                {
                                    tx[12] = 0x01;
                                    tx[13] = 0x22;
                                    tx[14] = 0x57;
                                }
                                else if((Charger.Alarm_Code & ALARM_EMERGENCY_STOP))
                                {
                                    tx[12] = 0x01;
                                    tx[13] = 0x22;
                                    tx[14] = 0x51;
                                }
                                else if((Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL))
                                {
                                    tx[12] = 0x01;
                                    tx[13] = 0x10;
                                    tx[14] = 0x04;
                                }
                                else if((Charger.Alarm_Code & ALARM_RELAY_STATUS))
                                {
                                    tx[12] = 0x01;
                                    tx[13] = 0x22;
                                    tx[14] = 0x58;
                                }
                            }
                            else
                            {
                                tx[12] = 0x00;
                                tx[13] = 0x00;
                                tx[14] = 0x00;
                            }

                            tx[15] = Charger.memory.EVSE_Config.data.item.reservation.mode;
                            tx[16] = Charger.memory.EVSE_Config.data.item.reservation.hour;
                            tx[17] = Charger.memory.EVSE_Config.data.item.reservation.min;

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[18] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_RESERVATION:
                            switch(UART_BLE_rx_buffer[7])
                            {
                                case RESERVATION_DISABLE:
                                    DEBUG_INFO("BLE device reservation request disable.\r\n");
                                    break;
                                case RESERVATION_ONCE:
                                    DEBUG_INFO("BLE device reservation request once on %d:%d.\r\n", UART_BLE_rx_buffer[8], UART_BLE_rx_buffer[9]);
                                    break;
                                case RESERVATION_ALWAYS:
                                    DEBUG_INFO("BLE device reservation request always on %d:%d.\r\n", UART_BLE_rx_buffer[8], UART_BLE_rx_buffer[9]);
                                    break;
                            }

                            tx_len = 0x05;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;

                            Charger.memory.EVSE_Config.data.item.reservation.mode = UART_BLE_rx_buffer[7];
                            Charger.memory.EVSE_Config.data.item.reservation.hour = UART_BLE_rx_buffer[8];
                            Charger.memory.EVSE_Config.data.item.reservation.min = UART_BLE_rx_buffer[9];
                            Charger.memory.EVSE_Config.op_bits.update = ON;
                            tx[3] = 0x01;

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[4] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_TIME_QUERY:
                            DEBUG_INFO("BLE device query date time request.\r\n");
                            tx_len = 0x08;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;

                            struct tm gm_date;
                            gm_date.tm_year = Charger.memory.EVSE_Config.data.item.SystemDateTime.year-1900;
                            gm_date.tm_mon = Charger.memory.EVSE_Config.data.item.SystemDateTime.month-1;
                            gm_date.tm_mday = Charger.memory.EVSE_Config.data.item.SystemDateTime.day;
                            gm_date.tm_hour = Charger.memory.EVSE_Config.data.item.SystemDateTime.hour;
                            gm_date.tm_min = Charger.memory.EVSE_Config.data.item.SystemDateTime.min;
                            gm_date.tm_sec = Charger.memory.EVSE_Config.data.item.SystemDateTime.sec;
                            tmp = mktime(&gm_date);
                            tx[3] = ((tmp >> 0)&0xff);
                            tx[4] = ((tmp >> 8)&0xff);
                            tx[5] = ((tmp >> 16)&0xff);
                            tx[6] = ((tmp >> 24)&0xff);

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[7] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_TIME_CONFIG:
                            DEBUG_INFO("BLE device config date time.\r\n");
                            tx_len = 0x09;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;

                            if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
                            {
                                struct tm *sm_date;
                                tmp = (UART_BLE_rx_buffer[7]<<0) | (UART_BLE_rx_buffer[8]<<8) | (UART_BLE_rx_buffer[9]<<16) | (UART_BLE_rx_buffer[10]<<24);
                                sm_date = gmtime(&tmp) ;

                                setTime.Hours = sm_date->tm_hour;
                                setTime.Minutes = sm_date->tm_min;
                                setTime.Seconds = sm_date->tm_sec;
                                setTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
                                setTime.StoreOperation = RTC_STOREOPERATION_RESET;
                                if (HAL_RTC_SetTime(&hrtc, &setTime, RTC_FORMAT_BIN) != HAL_OK)
                                {
                                    Error_Handler();
                                }

                                setDate.Year = (sm_date->tm_year + 1900)-2000;
                                setDate.Month = sm_date->tm_mon + 1;
                                setDate.Date = sm_date->tm_mday;
                                if (HAL_RTC_SetDate(&hrtc, &setDate, RTC_FORMAT_BIN) != HAL_OK)
                                {
                                    Error_Handler();
                                }

                                tx[3] = 0x01;
                                DEBUG_INFO("RTC config OK.\r\n");
                            }
                            else
                            {
                                tx[3] = 0x00;
                                DEBUG_WARN("User con not config RTC.\r\n");
                            }

                            tx[4] = UART_BLE_rx_buffer[7];
                            tx[5] = UART_BLE_rx_buffer[8];
                            tx[6] = UART_BLE_rx_buffer[9];
                            tx[7] = UART_BLE_rx_buffer[10];

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[8] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_LED_QUERY:
                            DEBUG_INFO("BLE device query led setting.\r\n");
                            tx_len = 0x08;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;
                            /*
                                TODO: Query led result here
                            */
                            if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
                            {
                                tx[3] = 0xff;
                                tx[4] = 0xff;
                                tx[5] = 0xff;
                                tx[6] = 0xff;
                            }
                            else
                            {
                                tx[3] = 0x00;
                                tx[4] = 0x00;
                                tx[5] = 0x00;
                                tx[6] = 0x00;
                            }

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[7] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_LED_CONFIG:
                            DEBUG_INFO("BLE device config led setting.\r\n");
                            tx_len = 0x09;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;
                            /*
                                TODO: Config led result here
                            */
                            if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
                                tx[3] = 0x01;
                            else
                                tx[3] = 0x00;

                            tx[4] = UART_BLE_rx_buffer[7];
                            tx[5] = UART_BLE_rx_buffer[8];
                            tx[6] = UART_BLE_rx_buffer[9];
                            tx[7] = UART_BLE_rx_buffer[10];

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[8] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_CURRENT_LIMIT_QUERY:
                            DEBUG_INFO("BLE device query current limit request.\r\n");
                            tx_len = 0x05;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;

                            if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
                            {
                                tx[3] = Charger.memory.EVSE_Config.data.item.MaxChargingCurrent;
                                DEBUG_INFO("Query current limit: %02dA.\r\n", Charger.memory.EVSE_Config.data.item.MaxChargingCurrent);
                            }
                            else
                            {
                                tx[3] = 0x00;
                                DEBUG_WARN("Please login first, before query current limit.\r\n");
                            }

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[8] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_CURRENT_LIMIT_CONFIG:
                            DEBUG_INFO("BLE device config current limit.\r\n");
                            tx_len = 0x06;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;

                            if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
                            {
                                if(UART_BLE_rx_buffer[7]>Charger.maxRatingCurrent)
                                {
                                    tx[3] = 0x02;
                                    Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = Charger.maxRatingCurrent;
                                    DEBUG_INFO("Setting value over max rating value, set as max rating .\r\n");
                                }
                                else
                                {
                                    tx[3] = 0x01;
                                    Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = UART_BLE_rx_buffer[7];
                                }
                                DEBUG_INFO("Config current limit: %02dA\r\n", Charger.memory.EVSE_Config.data.item.MaxChargingCurrent);
                            }
                            else
                            {
                                tx[3] = 0x00;
                                DEBUG_WARN("Please login first, before setting current limit.\r\n");
                            }

                            tx[4] = UART_BLE_rx_buffer[7];

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[5] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_FIRMWARE_VERSION_QUERY:
                            DEBUG_INFO("BLE device query firmware version.\r\n");
                            tx_len = 4 + strlen(Charger.Ver_FW);
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;

                            for(uint16_t idx=0;idx<strlen(Charger.Ver_FW);idx++)
                            {
                                if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
                                    tx[3+idx] = Charger.Ver_FW[idx];
                                else
                                    tx[3+idx] = 0x00;
                            }

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[3+strlen(Charger.Ver_FW)] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_FIRMWARE_UPDATE_REQ:
                            tx_len = 5;
                            tx[0] = 0x00;
                            tx[1] = 0x05;
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;;

                            if(Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT)
                            {
                                binCRCTarget = (UART_BLE_rx_buffer[7] << 24) | (UART_BLE_rx_buffer[8] << 16) | (UART_BLE_rx_buffer[9] << 8) | (UART_BLE_rx_buffer[10] << 0);
                                flashdestination = NEW_CODE_ADDRESS;
                                if(FLASH_If_Erase(NEW_CODE_ADDRESS, 3)== FLASHIF_OK)
                                {
                                  DEBUG_INFO("Firmware transfer start, earase flash success....\n\r");
                                  tx[3] = 0x01;
                                }
                                else
                                {
                                  DEBUG_INFO("Firmware transfer start, earase flash fail....\n\r");
                                  tx[3] = 0x00;
                                }
                            }
                            else
                            {
                                tx[3] = 0x00;
                                DEBUG_WARN("User can not upgrade start.\r\n");
                            }


                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[4] = chksum;
                            break;
                        case BLE_PROTOCOL_MESSAGE_FIRMWARE_TRANS_REQ:
                            tx_len = 5;
                            tx[0] = 0x00;
                            tx[1] = 0x05;
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;

                            if(Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT)
                            {
                                flashdestination = NEW_CODE_ADDRESS + ((UART_BLE_rx_buffer[7]<<24) | (UART_BLE_rx_buffer[8]<<16) | (UART_BLE_rx_buffer[9]<<8) |(UART_BLE_rx_buffer[10]<<0));
                                if (FLASH_If_Write(flashdestination, (uint32_t*) &UART_BLE_rx_buffer[11],  ((((UART_BLE_rx_buffer[1]) | (UART_BLE_rx_buffer[0])<<8)-12)>>2)) == FLASHIF_OK)
                                {
                                  DEBUG_INFO("Firmware transfer start address: 0x%x ,length: %d...Pass\n\r", flashdestination, (((UART_BLE_rx_buffer[1]) | (UART_BLE_rx_buffer[0])<<8)-12));
                                  tx[3] = 0x01;
                                }
                                else
                                {
                                  DEBUG_INFO("Firmware transfer start address: 0x%x, length: %d...Fail\n\r", flashdestination, (((UART_BLE_rx_buffer[1]) | (UART_BLE_rx_buffer[0])<<8)-12));
                                  tx[3] = 0x00;
                                }
                            }
                            else
                            {
                                tx[3] = 0x00;
                                DEBUG_WARN("User can not upgrade transfer.\r\n");
                            }

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[4] = chksum;
                          break;
                        case BLE_PROTOCOL_MESSAGE_FIRMWARE_END_REQ:
                            tx_len = 5;
                            tx[0] = 0x00;
                            tx[1] = 0x05;
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;;

                            if(Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT)
                            {
                                flash = NEW_CODE_ADDRESS;
                                checksum = HAL_CRC_Calculate(&hcrc, (uint32_t *)flash, ((FLASH_AP_LENGTH-4)>>2));
                                flash = ((uint32_t)(NEW_CODE_ADDRESS+FLASH_AP_LENGTH-4));
                                DEBUG_INFO("Firmware transfer end, AP CRC checksum, flash: 0x%x, 0x%x\r\n", checksum, *((uint32_t *)flash) );
                                if(checksum == *((uint32_t *)flash))
                                {
                                    if (FLASH_If_Write(UPGRADE_REQ_ADDRESS,  (uint32_t *)&endFlag[0], 1) == FLASHIF_OK)
                                    {
                                        DEBUG_INFO("Firmware Confirm Tag write ok..\n\r");
                                        tx[3] = 0x01;
                                        tx[4] = 0xB5;

                                        HAL_UART_Transmit(&IAP_USART, (uint8_t *)tx, sizeof(tx), 0xffff);
                                        osDelay(1000);
                                        NVIC_SystemReset();
                                    }
                                    else
                                    {
                                        DEBUG_INFO("Firmware Confirm Tag write fail...\n\r");
                                        tx[3] = 0x00;
                                    }
                                }
                                else
                                {
                                    DEBUG_INFO("Firmware checksum compare fail...\n\r");
                                    tx[3] = 0x00;
                                }
                            }
                            else
                            {
                                tx[3] = 0x00;
                                DEBUG_WARN("User can not upgrade stop.\r\n");
                            }

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[4] = chksum;
                          break;
                        default:
                            /*
                                TODO: Unknow command response here
                            */
                            tx_len = 5;
                            tx[0] = 0x00;
                            tx[1] = 0x05;
                            tx[2] = UART_BLE_rx_buffer[2] + 0x80;
                            tx[3] = 0x00;

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }

                            tx[4] = chksum;

                            DEBUG_ERROR("BLE unknow command.\r\n");
                            break;
                    }
                }
                else
                {
                    /*
                        TODO: Protocol check sum error response here
                    */
                    tx_len = 5;
                    tx[0] = 0x00;
                    tx[1] = 0x05;
                    tx[2] = UART_BLE_rx_buffer[2] + 0x80;
                    tx[3] = 0x00;

                    for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                    {
                        chksum ^= tx[2 + idx];
                    }

                    tx[4] = chksum;

                    DEBUG_ERROR("BLE check sum validation error.\r\n");
                }
                HAL_UART_Transmit(&BLE_USART, (uint8_t *)tx, tx_len, 0xffff);
            }

            UART_BLE_rx_len=0;
            UART_BLE_recv_end_flag = OFF;
        }
        HAL_UART_Receive_DMA(&BLE_USART, (uint8_t*)UART_BLE_rx_buffer, UART_BUFFER_SIZE);

        osDelay(1);
  }
  /* USER CODE END StartBleTask */
}


#ifdef MODIFY_FLASH_OPERATION_20241104
void Proc_EVSE_Config(void)
{
#ifdef MODIFY_UNDEFINED_MODEL_NAME_AND_SN_ISSUE
            if (Charger.memory.EVSE_Config.data.item.ModelName[0] == 0xFF ||
                Charger.memory.EVSE_Config.data.item.SerialNumber[0] == 0xFF)
            {
                Charger.memory.EVSE_Config.data.item.ModelName[MODEL_NAME_LEN - 1] = '\0';
                Charger.memory.EVSE_Config.data.item.SerialNumber[SERIAL_NUM_LEN - 1] = '\0';
                Charger.memory.EVSE_Config.op_bits.update = ON;
            }
#endif //MODIFY_UNDEFINED_MODEL_NAME_AND_SN_ISSUE

#ifdef FUNC_ZEROING_WHEN_MEM_CLEARNED
            if (Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total == HTK_U64_MAX ||
                Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 == HTK_U64_MAX ||
                Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 == HTK_U64_MAX ||
                Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3 == HTK_U64_MAX)
            {
                Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total = 0;
                Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 = 0;
                Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 = 0;
                Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3 = 0;

                Charger.memory.EVSE_Config.op_bits.update = ON;
            }

            if (Charger.memory.EVSE_Config.data.item.AcPlugInTimes == HTK_U32_MAX)
            {
                Charger.memory.EVSE_Config.data.item.AcPlugInTimes = 0;
                Charger.memory.EVSE_Config.op_bits.update = ON;
            }

#ifdef FUNC_MODE_DEBUG_REC_RELAY_ON_TIMES
            if (Charger.memory.EVSE_Config.data.item.m_ModeDebugRelayOnTimes == HTK_U32_MAX)
            {
                Charger.memory.EVSE_Config.data.item.m_ModeDebugRelayOnTimes = 0;
                Charger.memory.EVSE_Config.op_bits.update = ON;
            }
#endif

#endif //FUNC_ZEROING_WHEN_MEM_CLEARNED

            Charger.memory.EVSE_Config.data.item.isDispDebug  = ON;
            sprintf(Charger.memory.EVSE_Config.data.item.System_ID, "%s%s", Charger.memory.EVSE_Config.data.item.ModelName, Charger.memory.EVSE_Config.data.item.SerialNumber);
            //sprintf((char *)tmpBuf, "%08x", ~HAL_CRC_Calculate(&hcrc, (uint32_t *)&Charger.memory.EVSE_Config.data.item.System_ID[0], (ARRAY_SIZE(Charger.memory.EVSE_Config.data.item.System_ID)>>2)));
            //memcpy(&Charger.memory.EVSE_Config.data.item.bleConfig.puk[0], &tmpBuf[0], ARRAY_SIZE(Charger.memory.EVSE_Config.data.item.bleConfig.puk));
            //DEBUG_INFO("BLE PUK: %s\r\n", Charger.memory.EVSE_Config.data.item.bleConfig.puk);
            srand(Charger.memory.EVSE_Config.data.item.bleConfig.puk[0] | (Charger.memory.EVSE_Config.data.item.bleConfig.puk[1]<<8));

            setTime.Hours = Charger.memory.EVSE_Config.data.item.SystemDateTime.hour;
            setTime.Minutes = Charger.memory.EVSE_Config.data.item.SystemDateTime.min;
            setTime.Seconds = Charger.memory.EVSE_Config.data.item.SystemDateTime.sec;
            setTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
            setTime.StoreOperation = RTC_STOREOPERATION_RESET;
            if (HAL_RTC_SetTime(&hrtc, &setTime, RTC_FORMAT_BIN) != HAL_OK)
            {
                Error_Handler();
            }

            setDate.Year = Charger.memory.EVSE_Config.data.item.SystemDateTime.year-2000;
            setDate.Month = Charger.memory.EVSE_Config.data.item.SystemDateTime.month;
            setDate.Date = Charger.memory.EVSE_Config.data.item.SystemDateTime.day;
            if (HAL_RTC_SetDate(&hrtc, &setDate, RTC_FORMAT_BIN) != HAL_OK)
            {
                Error_Handler();
            }

            //CCLC_Corr_Gain_Par
            //VT
#ifdef MODIFY_CORRECTION_CHECK
            if  (
                    (Charger.memory.EVSE_Config.data.item.Correction_VL1[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL1[2][MCU_DATA]) &&
                    (Charger.memory.EVSE_Config.data.item.Correction_VL1[1][METER_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL1[2][METER_DATA])
                )
#else
            if(Charger.memory.EVSE_Config.data.item.Correction_VL1[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL1[2][MCU_DATA])
#endif
            {
                CLC_Corr_Gain_Par( Charger.memory.EVSE_Config.data.item.Correction_VL1[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_VL1[2][METER_DATA] ,
                                    Charger.memory.EVSE_Config.data.item.Correction_VL1[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_VL1[2][MCU_DATA] ,
                                    &Charger.coefficient.gain_v[0], &Charger.coefficient.offset_v[0]);
            }
            else
            {
                Charger.coefficient.gain_v[0] = 1;
                Charger.coefficient.offset_v[0] = 0;
            }

#ifdef MODIFY_CORRECTION_CHECK
            if  (
                    (Charger.memory.EVSE_Config.data.item.Correction_VL2[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL2[2][MCU_DATA]) &&
                    (Charger.memory.EVSE_Config.data.item.Correction_VL2[1][METER_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL2[2][METER_DATA])
                )
#else
            if(Charger.memory.EVSE_Config.data.item.Correction_VL2[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL2[2][MCU_DATA])
#endif
            {
                CLC_Corr_Gain_Par( Charger.memory.EVSE_Config.data.item.Correction_VL2[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_VL2[2][METER_DATA] ,
                                    Charger.memory.EVSE_Config.data.item.Correction_VL2[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_VL2[2][MCU_DATA] ,
                                    &Charger.coefficient.gain_v[1], &Charger.coefficient.offset_v[1]);
            }
            else
            {
                Charger.coefficient.gain_v[1] = 1;
                Charger.coefficient.offset_v[1] = 0;
            }

#ifdef MODIFY_CORRECTION_CHECK
            if  (
                    (Charger.memory.EVSE_Config.data.item.Correction_VL3[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL3[2][MCU_DATA]) &&
                    (Charger.memory.EVSE_Config.data.item.Correction_VL3[1][METER_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL3[2][METER_DATA])
                )
#else
            if(Charger.memory.EVSE_Config.data.item.Correction_VL3[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL3[2][MCU_DATA])
#endif
            if(Charger.memory.EVSE_Config.data.item.Correction_VL3[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL3[2][MCU_DATA])
            {
                CLC_Corr_Gain_Par( Charger.memory.EVSE_Config.data.item.Correction_VL3[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_VL3[2][METER_DATA] ,
                                    Charger.memory.EVSE_Config.data.item.Correction_VL3[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_VL3[2][MCU_DATA] ,
                                    &Charger.coefficient.gain_v[2], &Charger.coefficient.offset_v[2]);
            }
            else
            {
                Charger.coefficient.gain_v[2] = 1;
                Charger.coefficient.offset_v[2] = 0;
            }

            //CT
#ifdef MODIFY_CORRECTION_CHECK
            if  (
                    (Charger.memory.EVSE_Config.data.item.Correction_CL1[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL1[2][MCU_DATA]) &&
                    (Charger.memory.EVSE_Config.data.item.Correction_CL1[1][METER_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL1[2][METER_DATA])
                )
#else
            if(Charger.memory.EVSE_Config.data.item.Correction_CL1[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL1[2][MCU_DATA])
#endif
            {
                CLC_Corr_Gain_Par(Charger.memory.EVSE_Config.data.item.Correction_CL1[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_CL1[2][METER_DATA] ,
                                   Charger.memory.EVSE_Config.data.item.Correction_CL1[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_CL1[2][MCU_DATA] ,
                                   &Charger.coefficient.gain_c[0], &Charger.coefficient.offset_c[0]);
            }
            else
            {
                Charger.coefficient.gain_c[0] = 1;
                Charger.coefficient.offset_c[0] = 0;
            }

#ifdef MODIFY_CORRECTION_CHECK
            if  (
                    (Charger.memory.EVSE_Config.data.item.Correction_CL2[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL2[2][MCU_DATA]) &&
                    (Charger.memory.EVSE_Config.data.item.Correction_CL2[1][METER_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL2[2][METER_DATA])
                )
#else
            if(Charger.memory.EVSE_Config.data.item.Correction_CL2[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL2[2][MCU_DATA])
#endif
            {
                CLC_Corr_Gain_Par(Charger.memory.EVSE_Config.data.item.Correction_CL2[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_CL2[2][METER_DATA] ,
                                   Charger.memory.EVSE_Config.data.item.Correction_CL2[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_CL2[2][MCU_DATA] ,
                                   &Charger.coefficient.gain_c[1], &Charger.coefficient.offset_c[1]);
            }
            else
            {
                Charger.coefficient.gain_c[1] = 1;
                Charger.coefficient.offset_c[1] = 0;
            }

#ifdef MODIFY_CORRECTION_CHECK
            if  (
                    (Charger.memory.EVSE_Config.data.item.Correction_CL3[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL3[2][MCU_DATA]) &&
                    (Charger.memory.EVSE_Config.data.item.Correction_CL3[1][METER_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL3[2][METER_DATA])
                )
#else
            if(Charger.memory.EVSE_Config.data.item.Correction_CL3[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL3[2][MCU_DATA])
#endif
            if(Charger.memory.EVSE_Config.data.item.Correction_CL3[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL3[2][MCU_DATA])
            {
                CLC_Corr_Gain_Par(Charger.memory.EVSE_Config.data.item.Correction_CL3[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_CL3[2][METER_DATA] ,
                                   Charger.memory.EVSE_Config.data.item.Correction_CL3[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_CL3[2][MCU_DATA] ,
                                   &Charger.coefficient.gain_c[2], &Charger.coefficient.offset_c[2]);
            }
            else
            {
                Charger.coefficient.gain_c[2] = 1;
                Charger.coefficient.offset_c[2] = 0;
            }



            //LEAK
            if(Charger.memory.EVSE_Config.data.item.Correction_Leak[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_Leak[2][MCU_DATA])
            {
                CLC_Corr_Gain_Par(Charger.memory.EVSE_Config.data.item.Correction_Leak[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_Leak[2][METER_DATA] ,
                                   Charger.memory.EVSE_Config.data.item.Correction_Leak[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_Leak[2][MCU_DATA] ,
                                   &Charger.coefficient.gain_leak[0], &Charger.coefficient.offset_leak[0]);
            }
            else
            {
                Charger.coefficient.gain_leak[0] = 1;
                Charger.coefficient.offset_leak[0] = 0;
            }

            DEBUG_INFO("Charger.coefficient.gain_leak[0] = %f\r\n",Charger.coefficient.gain_leak[0]);
            DEBUG_INFO("Charger.coefficient.offset_leak[0] = %f\r\n",Charger.coefficient.offset_leak[0]);

            //GMI
            if(Charger.memory.EVSE_Config.data.item.Correction_GMI[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_GMI[2][MCU_DATA])
            {
                CLC_Corr_Gain_Par2(Charger.memory.EVSE_Config.data.item.Correction_GMI[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_GMI[2][METER_DATA] ,
                                   Charger.memory.EVSE_Config.data.item.Correction_GMI[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_GMI[2][MCU_DATA] ,
                                   &Charger.coefficient.gain_gmi[0], &Charger.coefficient.offset_gmi[0], &Charger.coefficient.offsetisPosOrNeg_gmi[0]);
            }
            else
            {
                Charger.coefficient.gain_gmi[0] = 1;
                Charger.coefficient.offset_gmi[0] = 0;
            }

            //DEBUG_INFO("Charger.coefficient.gain_gmi[0] = %f\r\n",Charger.coefficient.gain_gmi[0]);
            //DEBUG_INFO("Charger.coefficient.offset_gmi[0] = %f\r\n",Charger.coefficient.offset_gmi[0]);

#ifdef FUNC_SHOW_CORRECTION_DATA
            {
                XP("[CORRECT DATA]======================\r\n");
                XP("<Correction_VL1>\r\n");
                for (int i = 0; i < 4; i++)
                {
                    XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
                       i, Charger.memory.EVSE_Config.data.item.Correction_VL1[i][0],
                       i, Charger.memory.EVSE_Config.data.item.Correction_VL1[i][1]);
                }
                XP("<Correction_VL2>\r\n");
                for (int i = 0; i < 4; i++)
                {
                    XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
                       i, Charger.memory.EVSE_Config.data.item.Correction_VL2[i][0],
                       i, Charger.memory.EVSE_Config.data.item.Correction_VL2[i][1]);
                }
                XP("<Correction_VL3>\r\n");
                for (int i = 0; i < 4; i++)
                {
                    XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
                       i, Charger.memory.EVSE_Config.data.item.Correction_VL3[i][0],
                       i, Charger.memory.EVSE_Config.data.item.Correction_VL3[i][1]);
                }
                XP("<Correction_CL1>\r\n");
                for (int i = 0; i < 4; i++)
                {
                    XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
                       i, Charger.memory.EVSE_Config.data.item.Correction_CL1[i][0],
                       i, Charger.memory.EVSE_Config.data.item.Correction_CL1[i][1]);
                }
                XP("<Correction_CL2>\r\n");
                for (int i = 0; i < 4; i++)
                {
                    XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
                       i, Charger.memory.EVSE_Config.data.item.Correction_CL2[i][0],
                       i, Charger.memory.EVSE_Config.data.item.Correction_CL2[i][1]);
                }
                XP("<Correction_CL3>\r\n");
                for (int i = 0; i < 4; i++)
                {
                    XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
                       i, Charger.memory.EVSE_Config.data.item.Correction_CL3[i][0],
                       i, Charger.memory.EVSE_Config.data.item.Correction_CL3[i][1]);
                }
                XP("<Correction_Leak>\r\n");
                for (int i = 0; i < 4; i++)
                {
                    XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
                       i, Charger.memory.EVSE_Config.data.item.Correction_Leak[i][0],
                       i, Charger.memory.EVSE_Config.data.item.Correction_Leak[i][1]);
                }
                XP("<Correction_GMI>\r\n");
                for (int i = 0; i < 4; i++)
                {
                    XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
                       i, Charger.memory.EVSE_Config.data.item.Correction_GMI[i][0],
                       i, Charger.memory.EVSE_Config.data.item.Correction_GMI[i][1]);
                }
                XP("====================================\r\n");
            }
#endif //FUNC_SHOW_CORRECTION_DATA

            //DEBUG_INFO("Read MEM_ADDR_EVSE_CONFIG block(4k byte) pass.\r\n");

            // Clean update & clear flag when model name not configured
            /*
            if(strlen(Charger.memory.EVSE_Config.data.item.ModelName)>20)
            {
                Charger.memory.EVSE_Config.op_bits.update = OFF;
                Charger.memory.EVSE_Config.op_bits.clear = OFF;
                Charger.memory.EVSE_Config.op_bits.backup = OFF;
                Charger.memory.EVSE_Config.op_bits.restore = OFF;
            }
            */
            parseVersionInfoFromModelname();
}
#endif //MODIFY_FLASH_OPERATION_20241104

/* USER CODE BEGIN Header_StartMemoryTask */
/**
* @brief Function implementing the memoryTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartMemoryTask */
void StartMemoryTask(void const * argument)
{
  /* USER CODE BEGIN StartMemoryTask */
  //mmemory
  //uint8_t tmpBuf[64];
  uint8_t isSuccess;
  uint8_t ID[2];

  BSP_W25Qx_Init();
  BSP_W25Qx_Read_ID(ID);

  DEBUG_INFO("W25Qxxx ID is : 0x%02X 0x%02X \r\n",ID[0],ID[1]);

  Charger.memory.EVSE_Config.op_bits.read = ON;
  Charger.memory.coldLoadPickUp.op_bits.read = ON;
  Charger.memory.whiteList.op_bits.read = ON;
  Charger.memory.hisAlarm.op_bits.read = ON;
#ifdef FUNC_METER_IC_HISTORY
  Charger.memory.hisMeterIC.op_bits.read = ON;
#else
  Charger.memory.hisCharging.op_bits.read = ON;
#endif

  /*
  Charger.memory.EVSE_Config.op_bits.clear = ON ;
  Charger.memory.EVSE_Config.op_bits.clear = ON;
  Charger.memory.coldLoadPickUp.op_bits.clear = ON;
  Charger.memory.whiteList.op_bits.clear = ON;
  Charger.memory.hisAlarm.op_bits.clear = ON;
  Charger.memory.hisCharging.op_bits.clear = ON;
  */

  /* Infinite loop */
  for(;;)
  {
    /*
        EVSE config operation
    */

    if(Charger.memory.EVSE_Config.op_bits.read)
    {
#ifdef FUNC_CALC_FLASH_CRC_IN_CRITICAL
        taskENTER_CRITICAL();
#endif

#ifndef FUNC_CALC_FLASH_CRC_IN_CRITICAL
        osDelay(100);
#endif
        // Read data from block
        if(BSP_W25Qx_Read(Charger.memory.EVSE_Config.data.value, MEM_ADDR_EVSE_CONFIG, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
        {

#ifdef FUNC_FLASH_RESTORE_CONFIG_WHEN_PRIMARY_LOSS

#ifdef FUNC_FLASH_CONFIG_APPEND_CRC
            u32 crc32 = HAL_CRC_Calculate(&hcrc, (u32*)Charger.memory.EVSE_Config.data.verify.buf, ((W25Q16FV_BLOCK_SIZE-4)>>2));
            if ((Charger.memory.EVSE_Config.data.verify.crc32 == crc32 /*|| Charger.memory.EVSE_Config.data.verify.crc32 == HTK_U32_MAX*/))
#else
            if (1)
#endif
            {
                DEBUG_INFO("Read MEM_ADDR_EVSE_CONFIG block(4k byte) pass.\r\n");
                Proc_EVSE_Config();
                Charger.ModelReadisOK = PASS;
            }
            else
            {
                static u8 bProc = 0;
                if (!bProc)
                {
                    bProc = 1;
                    DEBUG_WARN("MEM_ADDR_EVSE_CONFIG data area check sum error => restore from backup area.\r\n");
                    Charger.memory.EVSE_Config.op_bits.restore = ON;
                }
                else
                {
                    Proc_EVSE_Config();
                    Charger.ModelReadisOK = PASS;
                }
            }
#endif //FUNC_FLASH_RESTORE_CONFIG_WHEN_PRIMARY_LOSS


            Charger.memory.EVSE_Config.op_bits.read = OFF;
        }
        else
        {
            DEBUG_INFO("Read MEM_ADDR_EVSE_CONFIG block(4k byte) fail.\r\n");
        }
#ifdef FUNC_CALC_FLASH_CRC_IN_CRITICAL
        taskEXIT_CRITICAL();
#endif
    }


    if(Charger.memory.EVSE_Config.op_bits.update)
    {
#ifdef FUNC_CALC_FLASH_CRC_IN_CRITICAL
        taskENTER_CRITICAL();
#endif

#ifdef FUNC_AUTO_MODIFY_CCID_MODULE
        Charger.memory.EVSE_Config.op_bits.update = OFF;
#endif
        isSuccess = PASS;

#ifdef FUNC_FLASH_CONFIG_APPEND_CRC
#ifndef FUNC_CALC_FLASH_CRC_IN_CRITICAL
        osDelay(100);
#endif
        Charger.memory.EVSE_Config.data.verify.crc32 = HAL_CRC_Calculate(&hcrc, (u32*)Charger.memory.EVSE_Config.data.verify.buf, ((W25Q16FV_BLOCK_SIZE-4)>>2));
#endif
        // Erase block data
        if(BSP_W25Qx_Erase_Block(MEM_ADDR_EVSE_CONFIG) == W25Qx_OK)
        {
            // Write data to block
            for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
            {
                if(BSP_W25Qx_Write(&Charger.memory.EVSE_Config.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_EVSE_CONFIG+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
                {
                    isSuccess = FAIL;
                }
            }

            if(isSuccess)
                DEBUG_INFO("Update MEM_ADDR_EVSE_CONFIG success.\r\n");
            else
                DEBUG_WARN("Update MEM_ADDR_EVSE_CONFIG fail.\r\n");
#ifndef FUNC_AUTO_MODIFY_CCID_MODULE
            Charger.memory.EVSE_Config.op_bits.update = OFF;
#endif

#ifdef FUNC_FLASH_UPDATE_CONFIG_BOTH_PRIMARY_AND_BACKUP
            Charger.memory.EVSE_Config.op_bits.backup = ON;
#endif
        }
        else
        {
            DEBUG_WARN("Update MEM_ADDR_EVSE_CONFIG block(4k byte) fail.\r\n");
        }
#ifdef FUNC_CALC_FLASH_CRC_IN_CRITICAL
        taskEXIT_CRITICAL();
#endif
    }

    if(Charger.memory.EVSE_Config.op_bits.clear)
    {
        // Erase block data
        if(BSP_W25Qx_Erase_Block(MEM_ADDR_EVSE_CONFIG) == W25Qx_OK)
        {
            // Read data from block
            if(BSP_W25Qx_Read(Charger.memory.EVSE_Config.data.value, MEM_ADDR_EVSE_CONFIG, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
            {
                DEBUG_INFO("Erase MEM_ADDR_EVSE_CONFIG block(4k byte) pass.\r\n");
                Charger.memory.EVSE_Config.op_bits.clear = OFF;
            }
            else
            {
                DEBUG_WARN("Erase MEM_ADDR_EVSE_CONFIG block(4k byte) fail.\r\n");
            }
        }
        else
        {
            DEBUG_WARN("Erase MEM_ADDR_EVSE_CONFIG block(4k byte) fail.\r\n");
        }
    }


    if(Charger.memory.EVSE_Config.op_bits.backup)
    {
#ifdef FUNC_CALC_FLASH_CRC_IN_CRITICAL
        taskENTER_CRITICAL();
#endif
        isSuccess = PASS;
#ifndef FUNC_CALC_FLASH_CRC_IN_CRITICAL
        osDelay(100);
#endif
		Charger.memory.EVSE_Config.data.verify.crc32 = HAL_CRC_Calculate(&hcrc, (u32*)Charger.memory.EVSE_Config.data.verify.buf, ((W25Q16FV_BLOCK_SIZE-4)>>2));

        // Erase block data
        if(BSP_W25Qx_Erase_Block(MEM_ADDR_BACKUP_EVSE_CONFIG) == W25Qx_OK)
        {
            // Write data to block
            for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
            {
                if(BSP_W25Qx_Write(&Charger.memory.EVSE_Config.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_BACKUP_EVSE_CONFIG+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
                {
                    isSuccess = FAIL;
                }
            }

            if(isSuccess)
                DEBUG_INFO("Backup MEM_ADDR_BACKUP_EVSE_CONFIG success.\r\n");
            else
                DEBUG_WARN("Backup MEM_ADDR_BACKUP_EVSE_CONFIG fail.\r\n");

            Charger.memory.EVSE_Config.op_bits.backup = OFF;
#ifndef FUNC_FLASH_UPDATE_CONFIG_BOTH_PRIMARY_AND_BACKUP
            //Charger.memory.EVSE_Config.op_bits.clear = ON;
#endif
        }
        else
        {
            DEBUG_WARN("Backup MEM_ADDR_BACKUP_EVSE_CONFIG block(4k byte) fail.\r\n");
        }
#ifdef FUNC_CALC_FLASH_CRC_IN_CRITICAL
        taskEXIT_CRITICAL();
#endif
    }

    if(Charger.memory.EVSE_Config.op_bits.restore)
    {
        // Restore data from backup block
        if(BSP_W25Qx_Read(Charger.memory.EVSE_Config.data.value, MEM_ADDR_BACKUP_EVSE_CONFIG, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
        {
            u32 crc32 = HAL_CRC_Calculate(&hcrc, (u32*)Charger.memory.EVSE_Config.data.verify.buf, ((W25Q16FV_BLOCK_SIZE-4)>>2));
            if(Charger.memory.EVSE_Config.data.verify.crc32 == crc32)
            {
                DEBUG_INFO("Restore MEM_ADDR_BACKUP_EVSE_CONFIG block(4k byte) pass.\r\n");

                // Update data to primary area
                Charger.memory.EVSE_Config.op_bits.update = ON;
                Proc_EVSE_Config();
                Charger.ModelReadisOK = PASS;
            }
            else
            {
                DEBUG_WARN("[FLASH] MEM_ADDR_BACKUP_EVSE_CONFIG block check sum error.\r\n");
                // TODO:

                static u8 bProc = 0;
                if (!bProc)
                {
                    bProc = 1;
                    setLedMotion(LED_ACTION_ALARM);
                    Charger.memory.EVSE_Config.op_bits.read = ON;
                }

            }
            Charger.memory.EVSE_Config.op_bits.restore = OFF;
        }
        else
        {
            DEBUG_WARN("Restore MEM_ADDR_BACKUP_EVSE_CONFIG block(4k byte) fail.\r\n");
        }
    }


    if((HAL_GPIO_ReadPin(IN_MEM_Erase_GPIO_Port, IN_MEM_Erase_Pin) == GPIO_PIN_RESET) && (Charger.Mode == MODE_IDLE) )
    {
        //prevent idiot to pree this button too long to cause watchdog reset
        HAL_IWDG_Refresh(&hiwdg);
        if(Charger.counter.RST_CFG>3000)
        {
            // Reset EVSE configuration to factory default value
            Charger.memory.EVSE_Config.data.item.bleConfig.isGenPin = OFF;
            Charger.memory.EVSE_Config.data.item.bleConfig.isRegPuk = OFF;
            Charger.memory.EVSE_Config.data.item.AuthMode = AUTH_MODE_OCPP;
            Charger.memory.EVSE_Config.data.item.RFID_SN_Endian = RFID_ENDIAN_LITTLE;
            //Charger.memory.EVSE_Config.data.item.isAuthEnable = OFF;
            Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_FREE ;
            //Charger.memory.EVSE_Config.data.item.Power_Consumption_Cumulative = 0;
            Charger.memory.EVSE_Config.data.item.reservation.mode = RESERVATION_DISABLE;
            Charger.memory.EVSE_Config.op_bits.update = ON;

            // Reset cold load pick up to factory default value
            Charger.memory.coldLoadPickUp.data.item.isEnable = OFF;
            Charger.memory.coldLoadPickUp.op_bits.update = ON;

            // Reset white list to factory default value
            for(uint8_t idx=0;idx<20;idx++)
            {
                Charger.memory.whiteList.data.item[idx].listType = 0xff;
                Charger.memory.whiteList.data.item[idx].isReg = OFF;
                memset(&Charger.memory.whiteList.data.item[idx].pin[0], 0x00, 6);
                memset(&Charger.memory.whiteList.data.item[idx].listID[0], 0x00, 6);
            }
            Charger.memory.whiteList.op_bits.update = ON;

            //restore led
            setLedMotion(LED_ACTION_RESTORE_SETTING) ;
            timerEnable(TIMER_IDX_LED_TEMP, 3000);

            setChargerMode(MODE_IDLE);

            osDelay(1000);
       }
       else
           Charger.counter.RST_CFG++;
    }
    else
        Charger.counter.RST_CFG = 0;

    /*
        Cold load pick up operation
    */
    if(Charger.memory.coldLoadPickUp.op_bits.read)
    {
        osDelay(100);
        // Read data from block
        if(BSP_W25Qx_Read(Charger.memory.coldLoadPickUp.data.value, MEM_ADDR_COLD_LOAD_PICKUP, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
        {
            DEBUG_INFO("Read MEM_ADDR_COLD_LOAD_PICKUP block(4k byte) pass.\r\n");
            Charger.memory.coldLoadPickUp.op_bits.read = OFF;
        }
        else
        {
            DEBUG_WARN("Read MEM_ADDR_COLD_LOAD_PICKUP block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.coldLoadPickUp.op_bits.update)
    {
        isSuccess = PASS;
        // Erase block data
        if(BSP_W25Qx_Erase_Block(MEM_ADDR_COLD_LOAD_PICKUP) == W25Qx_OK)
        {
            // Write data to block
            for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
            {
                if(BSP_W25Qx_Write(&Charger.memory.coldLoadPickUp.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_COLD_LOAD_PICKUP+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
                {
                    isSuccess = FAIL;
                }
            }

            if(isSuccess)
                DEBUG_INFO("Update MEM_ADDR_COLD_LOAD_PICKUP success.\r\n");
            else
                DEBUG_WARN("Update MEM_ADDR_COLD_LOAD_PICKUP fail.\r\n");

            Charger.memory.coldLoadPickUp.op_bits.update = OFF;
        }
        else
        {
            DEBUG_WARN("Update MEM_ADDR_COLD_LOAD_PICKUP block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.coldLoadPickUp.op_bits.clear)
    {
        // Erase block data
        if(BSP_W25Qx_Erase_Block(MEM_ADDR_COLD_LOAD_PICKUP) == W25Qx_OK)
        {
            // Read data from block
            if(BSP_W25Qx_Read(Charger.memory.coldLoadPickUp.data.value, MEM_ADDR_COLD_LOAD_PICKUP, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
            {
                DEBUG_INFO("Erase MEM_ADDR_COLD_LOAD_PICKUP block(4k byte) pass.\r\n");
                Charger.memory.coldLoadPickUp.op_bits.clear = OFF;
            }
            else
            {
                DEBUG_WARN("Erase MEM_ADDR_COLD_LOAD_PICKUP block(4k byte) fail.\r\n");
            }
        }
        else
        {
            DEBUG_WARN("Erase MEM_ADDR_COLD_LOAD_PICKUP block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.coldLoadPickUp.op_bits.backup)
    {
        isSuccess = PASS;
        // Erase block data
        if(BSP_W25Qx_Erase_Block(MEM_ADDR_BACKUP_COLD_LOAD_PICKUP) == W25Qx_OK)
        {
            // Write data to block
            for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
            {
                if(BSP_W25Qx_Write(&Charger.memory.coldLoadPickUp.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_BACKUP_COLD_LOAD_PICKUP+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
                {
                    isSuccess = FAIL;
                }
            }

            if(isSuccess)
                DEBUG_INFO("Backup MEM_ADDR_BACKUP_COLD_LOAD_PICKUP success.\r\n");
            else
                DEBUG_WARN("Backup MEM_ADDR_BACKUP_COLD_LOAD_PICKUP fail.\r\n");

            Charger.memory.coldLoadPickUp.op_bits.backup = OFF;
            Charger.memory.coldLoadPickUp.op_bits.clear = ON;
        }
        else
        {
            DEBUG_WARN("Backup MEM_ADDR_BACKUP_COLD_LOAD_PICKUP block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.coldLoadPickUp.op_bits.restore)
    {
        // Restore data from backup block
        if(BSP_W25Qx_Read(Charger.memory.coldLoadPickUp.data.value, MEM_ADDR_BACKUP_COLD_LOAD_PICKUP, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
        {
            DEBUG_INFO("Restore MEM_ADDR_BACKUP_COLD_LOAD_PICKUP block(4k byte) pass.\r\n");
            Charger.memory.coldLoadPickUp.op_bits.restore = OFF;
        }
        else
        {
            DEBUG_WARN("Restore MEM_ADDR_BACKUP_COLD_LOAD_PICKUP block(4k byte) fail.\r\n");
        }
    }

    /*
        White list operation
    */
    if(Charger.memory.whiteList.op_bits.read)
    {
        osDelay(100);
        // Read data from block
        if(BSP_W25Qx_Read(Charger.memory.whiteList.data.value, MEM_ADDR_WHITE_LIST, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
        {
            DEBUG_INFO("Read MEM_ADDR_WHITE_LIST block(4k byte) pass.\r\n");
            Charger.memory.whiteList.op_bits.read = OFF;
        }
        else
        {
            DEBUG_WARN("Read MEM_ADDR_WHITE_LIST block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.whiteList.op_bits.update)
    {
        isSuccess = PASS;
        // Erase block data
        if(BSP_W25Qx_Erase_Block(MEM_ADDR_WHITE_LIST) == W25Qx_OK)
        {
            // Write data to block
            for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
            {
                if(BSP_W25Qx_Write(&Charger.memory.whiteList.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_WHITE_LIST+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
                {
                    isSuccess = FAIL;
                }
            }

            if(isSuccess)
                DEBUG_INFO("Update MEM_ADDR_WHITE_LIST success.\r\n");
            else
                DEBUG_WARN("Update MEM_ADDR_WHITE_LIST fail.\r\n");

            Charger.memory.whiteList.op_bits.update = OFF;
        }
        else
        {
            DEBUG_WARN("Update MEM_ADDR_WHITE_LIST block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.whiteList.op_bits.clear)
    {
        // Erase block data
        if(BSP_W25Qx_Erase_Block(MEM_ADDR_WHITE_LIST) == W25Qx_OK)
        {
            // Read data from block
            if(BSP_W25Qx_Read(Charger.memory.whiteList.data.value, MEM_ADDR_WHITE_LIST, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
            {
                DEBUG_INFO("Erase MEM_ADDR_WHITE_LIST block(4k byte) pass.\r\n");
                Charger.memory.whiteList.op_bits.clear = OFF;
            }
            else
            {
                DEBUG_WARN("Erase MEM_ADDR_WHITE_LIST block(4k byte) fail.\r\n");
            }
        }
        else
        {
            DEBUG_WARN("Erase MEM_ADDR_WHITE_LIST block(4k byte) fail.\r\n");
        }
    }

    /*
        Alarm history operation
    */
    if(Charger.memory.hisAlarm.op_bits.read)
    {
        osDelay(100);
        // Read data from block
        if(BSP_W25Qx_Read(Charger.memory.hisAlarm.data.value, MEM_ADDR_HIS_ALARM, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
        {
            DEBUG_INFO("Read MEM_ADDR_HIS_ALARM block(4k byte) pass.\r\n");
            Charger.memory.hisAlarm.op_bits.read = OFF;
        }
        else
        {
            DEBUG_WARN("Read MEM_ADDR_HIS_ALARM block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.hisAlarm.op_bits.update)
    {
        isSuccess = PASS;

        // Write data to block
        for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
        {
            if(BSP_W25Qx_Write(&Charger.memory.hisAlarm.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_HIS_ALARM+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
            {
                isSuccess = FAIL;
            }
        }

        if(isSuccess)
            DEBUG_INFO("Update MEM_ADDR_HIS_ALARM success.\r\n");
        else
            DEBUG_WARN("Update MEM_ADDR_HIS_ALARM fail.\r\n");

        Charger.memory.hisAlarm.op_bits.update = OFF;
    }

    if(Charger.memory.hisAlarm.op_bits.clear)
    {
        // Erase block data
        if(BSP_W25Qx_Erase_Block(MEM_ADDR_HIS_ALARM) == W25Qx_OK)
        {
            // Read data from block
            if(BSP_W25Qx_Read(Charger.memory.hisAlarm.data.value, MEM_ADDR_HIS_ALARM, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
            {
                DEBUG_INFO("Erase MEM_ADDR_HIS_ALARM block(4k byte) pass.\r\n");
                Charger.memory.hisAlarm.op_bits.clear = OFF;
            }
            else
            {
                DEBUG_WARN("Erase MEM_ADDR_HIS_ALARM block(4k byte) fail.\r\n");
            }
        }
        else
        {
            DEBUG_WARN("Erase MEM_ADDR_HIS_ALARM block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.hisAlarm.op_bits.backup)
    {
        isSuccess = PASS;
        // Erase block data
        if(BSP_W25Qx_Erase_Block(MEM_ADDR_BACKUP_HIS_ALARM) == W25Qx_OK)
        {
            // Write data to block
            for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
            {
                if(BSP_W25Qx_Write(&Charger.memory.hisAlarm.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_BACKUP_HIS_ALARM+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
                {
                    isSuccess = FAIL;
                }
            }

            if(isSuccess)
                DEBUG_INFO("Backup MEM_ADDR_BACKUP_HIS_ALARM success.\r\n");
            else
                DEBUG_WARN("Backup MEM_ADDR_BACKUP_HIS_ALARM fail.\r\n");

            Charger.memory.hisAlarm.op_bits.backup = OFF;
            Charger.memory.hisAlarm.op_bits.clear = ON;
        }
        else
        {
            DEBUG_WARN("Backup MEM_ADDR_BACKUP_HIS_ALARM block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.hisAlarm.op_bits.restore)
    {
        // Restore data from backup block
        if(BSP_W25Qx_Read(Charger.memory.hisAlarm.data.value, MEM_ADDR_BACKUP_HIS_ALARM, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
        {
            DEBUG_INFO("Restore MEM_ADDR_BACKUP_HIS_ALARM block(4k byte) pass.\r\n");
            Charger.memory.hisAlarm.op_bits.restore = OFF;
        }
        else
        {
            DEBUG_WARN("Restore MEM_ADDR_BACKUP_HIS_ALARM block(4k byte) fail.\r\n");
        }
    }


#ifdef FUNC_METER_IC_HISTORY
    /*
        Meter IC calibration history operation
    */
    if(Charger.memory.hisMeterIC.op_bits.read)
    {
        osDelay(100);
        // Read data from block
        if(BSP_W25Qx_Read(Charger.memory.hisMeterIC.data.value, MEM_ADDR_HIS_METERIC, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
        {
            DEBUG_INFO("Read MEM_ADDR_HIS_METERIC block(4k byte) pass.\r\n");
            Charger.memory.hisMeterIC.op_bits.read = OFF;
        }
        else
        {
            DEBUG_INFO("Read MEM_ADDR_HIS_METERIC block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.hisMeterIC.op_bits.update)
    {
        isSuccess = PASS;

        // Write data to block
        for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
        {
            if(BSP_W25Qx_Write(&Charger.memory.hisMeterIC.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_HIS_METERIC+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
            {
                isSuccess = FAIL;
            }
        }

        if(isSuccess)
            DEBUG_INFO("Update MEM_ADDR_HIS_METERIC success.\r\n");
        else
            DEBUG_WARN("Update MEM_ADDR_HIS_METERIC fail.\r\n");

        Charger.memory.hisMeterIC.op_bits.update = OFF;

    }

    if(Charger.memory.hisMeterIC.op_bits.clear)
    {
        // Erase block data
        if(BSP_W25Qx_Erase_Block(MEM_ADDR_HIS_METERIC) == W25Qx_OK)
        {
            // Read data from block
            if(BSP_W25Qx_Read(Charger.memory.hisMeterIC.data.value, MEM_ADDR_HIS_METERIC, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
            {
                DEBUG_INFO("Erase MEM_ADDR_HIS_METERIC block(4k byte) pass.\r\n");
                Charger.memory.hisMeterIC.op_bits.clear = OFF;
            }
            else
            {
                DEBUG_INFO("Erase MEM_ADDR_HIS_METERIC block(4k byte) fail.\r\n");
            }
        }
        else
        {
            DEBUG_INFO("Erase MEM_ADDR_HIS_METERIC block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.hisMeterIC.op_bits.backup)
    {
        isSuccess = PASS;
        // Erase block data
        if(BSP_W25Qx_Erase_Block(MEM_ADDR_BACKUP_HIS_METERIC) == W25Qx_OK)
        {
            // Write data to block
            for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
            {
                if(BSP_W25Qx_Write(&Charger.memory.hisMeterIC.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_BACKUP_HIS_METERIC+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
                {
                    isSuccess = FAIL;
                }
            }

            if(isSuccess)
                DEBUG_INFO("Backup MEM_ADDR_BACKUP_HIS_METERIC success.\r\n");
            else
                DEBUG_WARN("Backup MEM_ADDR_BACKUP_HIS_METERIC fail.\r\n");

            Charger.memory.hisMeterIC.op_bits.backup = OFF;
            Charger.memory.hisMeterIC.op_bits.clear = ON;
        }
        else
        {
            DEBUG_INFO("Backup MEM_ADDR_BACKUP_HIS_METERIC block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.hisMeterIC.op_bits.restore)
    {
        // Restore data from backup block
        if(BSP_W25Qx_Read(Charger.memory.hisMeterIC.data.value, MEM_ADDR_BACKUP_HIS_METERIC, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
        {
            DEBUG_INFO("Restore MEM_ADDR_BACKUP_HIS_METERIC block(4k byte) pass.\r\n");
            Charger.memory.hisMeterIC.op_bits.restore = OFF;
        }
        else
        {
            DEBUG_INFO("Restore MEM_ADDR_BACKUP_HIS_METERIC block(4k byte) fail.\r\n");
        }
    }

#else //FUNC_METER_IC_HISTORY

    /*
        Charging history operation
    */
    if(Charger.memory.hisCharging.op_bits.read)
    {
        osDelay(100);
        // Read data from block
        if(BSP_W25Qx_Read(Charger.memory.hisCharging.data.value, MEM_ADDR_HIS_CHARGING, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
        {
            DEBUG_INFO("Read MEM_ADDR_HIS_CHARGING block(4k byte) pass.\r\n");
            Charger.memory.hisCharging.op_bits.read = OFF;
        }
        else
        {
            DEBUG_WARN("Read MEM_ADDR_HIS_CHARGING block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.hisCharging.op_bits.update)
    {
        isSuccess = PASS;

        // Write data to block
        for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
        {
            if(BSP_W25Qx_Write(&Charger.memory.hisCharging.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_HIS_CHARGING+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
            {
                isSuccess = FAIL;
            }
        }

        if(isSuccess)
            DEBUG_INFO("Update MEM_ADDR_HIS_CHARGING success.\r\n");
        else
            DEBUG_WARN("Update MEM_ADDR_HIS_CHARGING fail.\r\n");

        Charger.memory.hisCharging.op_bits.update = OFF;

    }

    if(Charger.memory.hisCharging.op_bits.clear)
    {
        // Erase block data
        if(BSP_W25Qx_Erase_Block(MEM_ADDR_HIS_CHARGING) == W25Qx_OK)
        {
            // Read data from block
            if(BSP_W25Qx_Read(Charger.memory.hisCharging.data.value, MEM_ADDR_HIS_CHARGING, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
            {
                DEBUG_INFO("Erase MEM_ADDR_HIS_CHARGING block(4k byte) pass.\r\n");
                Charger.memory.hisCharging.op_bits.clear = OFF;
            }
            else
            {
                DEBUG_WARN("Erase MEM_ADDR_HIS_CHARGING block(4k byte) fail.\r\n");
            }
        }
        else
        {
            DEBUG_WARN("Erase MEM_ADDR_HIS_CHARGING block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.hisCharging.op_bits.backup)
    {
        isSuccess = PASS;
        // Erase block data
        if(BSP_W25Qx_Erase_Block(MEM_ADDR_BACKUP_HIS_CHARGING) == W25Qx_OK)
        {
            // Write data to block
            for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
            {
                if(BSP_W25Qx_Write(&Charger.memory.hisCharging.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_BACKUP_HIS_CHARGING+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
                {
                    isSuccess = FAIL;
                }
            }

            if(isSuccess)
                DEBUG_INFO("Backup MEM_ADDR_BACKUP_HIS_CHARGING success.\r\n");
            else
                DEBUG_WARN("Backup MEM_ADDR_BACKUP_HIS_CHARGING fail.\r\n");

            Charger.memory.hisCharging.op_bits.backup = OFF;
            Charger.memory.hisCharging.op_bits.clear = ON;
        }
        else
        {
            DEBUG_WARN("Backup MEM_ADDR_BACKUP_HIS_CHARGING block(4k byte) fail.\r\n");
        }
    }

    if(Charger.memory.hisCharging.op_bits.restore)
    {
        // Restore data from backup block
        if(BSP_W25Qx_Read(Charger.memory.hisCharging.data.value, MEM_ADDR_BACKUP_HIS_CHARGING, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
        {
            DEBUG_INFO("Restore MEM_ADDR_BACKUP_HIS_CHARGING block(4k byte) pass.\r\n");
            Charger.memory.hisCharging.op_bits.restore = OFF;
        }
        else
        {
            DEBUG_WARN("Restore MEM_ADDR_BACKUP_HIS_CHARGING block(4k byte) fail.\r\n");
        }
    }

#endif //FUNC_METER_IC_HISTORY

#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    if (!Charger.m_bReadAllMemory)
    {
#ifdef FUNC_METER_IC_HISTORY
        MeterIC_CaliHistory_ReadAll();
#endif
        Charger.m_bReadAllMemory = 1;
    }
#endif

    osDelay(1);
  }
  /* USER CODE END StartMemoryTask */
}

/* USER CODE BEGIN Header_StartWifiTask */
/**
* @brief Function implementing the wifiTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartWifiTask */
void StartWifiTask(void const * argument)
{
  /* USER CODE BEGIN StartWifiTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    IdleUntilReadAllMemory();
#endif

  /* Infinite loop */
    char tmpBuf[128];
    //uint8_t endFlag[4]={0x55,0xaa,0x55,0xaa};
    __IO uint32_t flash;
    //uint32_t checksum;
    uint32_t rndNumber;

    //=====================================
    // Module reset
    //=====================================
    HAL_GPIO_WritePin(OUT_BLE_RESET_GPIO_Port, OUT_BLE_RESET_Pin, GPIO_PIN_RESET);
    osDelay(60);
    HAL_GPIO_WritePin(OUT_BLE_RESET_GPIO_Port, OUT_BLE_RESET_Pin, GPIO_PIN_SET);
    HAL_GPIO_WritePin(OUT_BLE_DSR_GPIO_Port, OUT_BLE_DSR_Pin, GPIO_PIN_SET);

    Charger.wifi.initSeq = 0;
    Charger.wifi.isDataMode = OFF;
    UART_WIFI_Init_OK = OFF;

    osDelay(1000);

    /* Infinite loop */
    for(;;)
    {
        //=====================================
        // WIFI module initialization process
        //=====================================
		switch(Charger.wifi.initSeq)
        {
            case 0x00:
                HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_RESTORE], strlen(WIFI_CMD[WIFI_CMD_SET_RESTORE]), 0xffff);
                osDelay(WIFI_INIT_DELAY);
                break;
            case 0x01:
                HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_DTR], strlen(WIFI_CMD[WIFI_CMD_SET_DTR]), 0xffff);
                osDelay(WIFI_INIT_DELAY);
                break;
            case 0x02:
                HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_DSR], strlen(WIFI_CMD[WIFI_CMD_SET_DSR]), 0xffff);
                osDelay(WIFI_INIT_DELAY);
                break;
            case 0x03:
                HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_GET_ADDR], strlen(WIFI_CMD[WIFI_CMD_GET_ADDR]), 0xffff);
                osDelay(WIFI_INIT_DELAY);
                break;
            case 0x04:
                sprintf(tmpBuf, "%s\"EVSE_AP_%sP\"\r\n", WIFI_CMD[WIFI_CMD_SET_SSID], Charger.wifi.module_mac);
                DEBUG_INFO("WIFI module set name: EVSE_AP_%s\r\n", Charger.wifi.module_mac);
                HAL_UART_Transmit(&WIFI_USART, (uint8_t *)tmpBuf, strlen(tmpBuf), 0xffff);
                osDelay(WIFI_INIT_DELAY);
                break;
            case 0x05:
                HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_CHANNEL], strlen(WIFI_CMD[WIFI_CMD_SET_CHANNEL]), 0xffff);
                osDelay(WIFI_INIT_DELAY);
                break;
            case 0x06:
                HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_SECURITY_MODE], strlen(WIFI_CMD[WIFI_CMD_SET_SECURITY_MODE]), 0xffff);
                osDelay(WIFI_INIT_DELAY);
                break;
            case 0x07:
                sprintf(tmpBuf, "%s\"%s\"\r\n", WIFI_CMD[WIFI_CMD_SET_PASSWORD], Charger.memory.EVSE_Config.data.item.wifiConfig.passwd);
                HAL_UART_Transmit(&WIFI_USART, (uint8_t *)tmpBuf, strlen(tmpBuf), 0xffff);
                osDelay(WIFI_INIT_DELAY);
                break;
            case 0x08:
                HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_DHCPSERVER], strlen(WIFI_CMD[WIFI_CMD_SET_DHCPSERVER]), 0xffff);
                osDelay(WIFI_INIT_DELAY);
                break;
            case 0x09:
                HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_TCPSETVER_CONFIG], strlen(WIFI_CMD[WIFI_CMD_SET_TCPSETVER_CONFIG]), 0xffff);
                osDelay(WIFI_INIT_DELAY);
                break;
            case 0x0a:
                HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_AP_ACTIVE], strlen(WIFI_CMD[WIFI_CMD_SET_AP_ACTIVE]), 0xffff);
                osDelay(WIFI_INIT_DELAY);
                break;
            case 0x0b:
                HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_DATA_MODE], strlen(WIFI_CMD[WIFI_CMD_SET_DATA_MODE]), 0xffff);
                DEBUG_INFO("WIFI module switch to data mode.\r\n");
                osDelay(WIFI_INIT_DELAY);
            default:
                UART_WIFI_Init_OK = ON;
                break;
        }

        //=====================================
        // WIFI central device connect status
        //=====================================
        if((HAL_GPIO_ReadPin(IN_BLE_DTR_GPIO_Port, IN_BLE_DTR_Pin) ==  GPIO_PIN_SET) && (UART_WIFI_Init_OK == ON))
        {
            // Device disconnect
            timerRefresh(TIMER_IDX_WIFI);
            if(Charger.wifi.loginRole == WIFI_LOGIN_ROLE_ROOT || Charger.wifi.loginRole == WIFI_LOGIN_ROLE_USER)
            {
                DEBUG_INFO("WIFI client device disconnect.\r\n.");
                Charger.wifi.loginRole = WIFI_LOGIN_ROLE_UNKOWN;
            }
        }
        else  if((HAL_GPIO_ReadPin(IN_BLE_DTR_GPIO_Port, IN_BLE_DTR_Pin) ==  GPIO_PIN_RESET) && (UART_WIFI_Init_OK == ON))
        {
            // Device connect in
            if(Charger.wifi.loginRole == WIFI_LOGIN_ROLE_UNKOWN)
            {
                DEBUG_INFO("WIFI client device connect.....wait sign in.\r\n.");
                osDelay(1000);
            }
        }

        //=====================================
        // Communication timeout process
        //=====================================
        if(timer[TIMER_IDX_WIFI].isAlarm)
        {
            Charger.wifi.loginRole = WIFI_LOGIN_ROLE_UNKOWN;
            DEBUG_INFO("WIFI no communication over time, disconnect client device.\r\n");
            timerRefresh(TIMER_IDX_WIFI);

            HAL_GPIO_WritePin(OUT_BLE_DSR_GPIO_Port, OUT_BLE_DSR_Pin, GPIO_PIN_RESET);
            osDelay(100);
            HAL_GPIO_WritePin(OUT_BLE_DSR_GPIO_Port, OUT_BLE_DSR_Pin, GPIO_PIN_SET);
        }

        //=====================================
        // WIFI uart recieve data process
        //=====================================
        if(UART_WIFI_recv_end_flag == ON)
        {
            if((HAL_GPIO_ReadPin(IN_BLE_DTR_GPIO_Port, IN_BLE_DTR_Pin) ==  GPIO_PIN_SET) || !Charger.wifi.isDataMode)
            {
                // AT command rx process
                if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_RESTORE])!=NULL)
                {
                    Charger.wifi.initSeq++;
                }

                if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_DTR])!=NULL)
                {
                    Charger.wifi.initSeq++;
                }

                if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_DSR])!=NULL)
                {
                    Charger.wifi.initSeq++;
                }

                if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_GET_ADDR])!=NULL)
                {
                    memcpy(Charger.wifi.module_mac, &UART_WIFI_rx_buffer[strcspn((char *)UART_WIFI_rx_buffer, ":")+1], 12);
                    Charger.wifi.module_mac[12] = '\0';
                    DEBUG_INFO("Wifi module mac address: %s\r\n", Charger.wifi.module_mac);
                    Charger.wifi.initSeq++;
                }

                if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_SSID])!=NULL)
                {
                    Charger.wifi.initSeq++;
                }

                if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_CHANNEL])!=NULL)
                {
                    Charger.wifi.initSeq++;
                }

                if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_SECURITY_MODE])!=NULL)
                {
                    Charger.wifi.initSeq++;
                }

                if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_PASSWORD])!=NULL)
                {
                    Charger.wifi.initSeq++;
                }

                if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_DHCPSERVER])!=NULL)
                {
                    Charger.wifi.initSeq++;
                }

                if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_TCPSETVER_CONFIG])!=NULL)
                {
                    Charger.wifi.initSeq++;
                }

                if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_AP_ACTIVE])!=NULL)
                {
                    Charger.wifi.initSeq++;
                }

                if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_DATA_MODE])!=NULL)
                {
                    Charger.wifi.isDataMode = ON;
                    Charger.wifi.initSeq++;
                }
            }
            else
            {
                // Application protocol rx process
                uint8_t tx[UART_BUFFER_SIZE];
                uint8_t tx_len;
                uint8_t chksum = 0;

                if(isValidCheckSum_WIFI() && (rndNumber != ((UART_WIFI_rx_buffer[3]<<0) | (UART_WIFI_rx_buffer[4]<<8) | (UART_WIFI_rx_buffer[5]<<16) | (UART_WIFI_rx_buffer[6]<<24))))
                {
                    // Timer reset
                    timerRefresh(TIMER_IDX_WIFI);
                    rndNumber = ((UART_WIFI_rx_buffer[3]<<0) | (UART_WIFI_rx_buffer[4]<<8) | (UART_WIFI_rx_buffer[5]<<16) | (UART_WIFI_rx_buffer[6]<<24));

                    switch(UART_WIFI_rx_buffer[2])
                    {
                        case WIFI_PROTOCOL_MESSAGE_SIGN_IN:
                            DEBUG_INFO("WIFI device sign request...%d\r\n", UART_WIFI_rx_buffer[7]);
                            tx_len = 5;
                            tx[0] = (tx_len>>8)&0xff;
                            tx[1] = (tx_len&0xff);
                            tx[2] = UART_WIFI_rx_buffer[2] + 0x80;
                            tx[3] = 0x00;


                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }
                            tx[4] = chksum;

                            break;
                        default:
                            /*
                                TODO: Unknow command response here
                            */
                            tx_len = 5;
                            tx[0] = 0x00;
                            tx[1] = 0x05;
                            tx[2] = UART_WIFI_rx_buffer[2] + 0x80;
                            tx[3] = 0x00;

                            for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                            {
                                chksum ^= tx[2 + idx];
                            }
                            tx[4] = chksum;

                            DEBUG_ERROR("WIFI unknow command.\r\n");
                            break;
                    }
                }
                else
                {
                    /*
                        TODO: Protocol check sum error response here
                    */
                    tx_len = 5;
                    tx[0] = 0x00;
                    tx[1] = 0x05;
                    tx[2] = UART_WIFI_rx_buffer[2] + 0x80;
                    tx[3] = 0x00;

                    for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
                    {
                        chksum ^= tx[2 + idx];
                    }
                    tx[4] = chksum;

                    DEBUG_ERROR("WIFI check sum validation error.\r\n");
                }
                HAL_UART_Transmit(&WIFI_USART, (uint8_t *)tx, tx_len, 0xffff);
            }

            UART_WIFI_rx_len=0;
            UART_WIFI_recv_end_flag=0;
        }
        HAL_UART_Receive_DMA(&WIFI_USART, (uint8_t*)UART_WIFI_rx_buffer, UART_BUFFER_SIZE);

        osDelay(1);
    }
  /* USER CODE END StartWifiTask */
}

/* USER CODE BEGIN Header_StartMeterTask */
/**
* @brief Function implementing the MeterTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartMeterTask */
void StartMeterTask(void const * argument)
{
  /* USER CODE BEGIN StartMeterTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    IdleUntilReadAllMemory();
#endif

#ifdef FUNC_WAIT_METER_IC_INIT_OK
#ifdef FUNC_IDLE_UNTIL_INIT_METER_IC
    IdleUntilInitMeterIC();
#endif
#endif //FUNC_WAIT_METER_IC_INIT_OK

  /* Infinite loop */

#ifdef RECODE_FUNC_METER_TASK

#else
  uint8_t pollingStep = 0;
  uint8_t addr = 0x01;
  uint8_t meter_model;
#endif

  HAL_GPIO_WritePin(Meter_DIR_GPIO_Port, Meter_DIR_Pin, GPIO_PIN_RESET);

//#ifdef FUNC_TEST_PRO380_INIT_DE_HIGH_1_SEC
//    HAL_GPIO_WritePin(Meter_DIR_GPIO_Port, Meter_DIR_Pin, GPIO_PIN_SET);
//    osDelay(1000);
//    HAL_GPIO_WritePin(Meter_DIR_GPIO_Port, Meter_DIR_Pin, GPIO_PIN_RESET);
//#endif

//#ifndef RECODE_FUNC_METER_TASK
    timerEnable(TIMER_IDX_METER_POLLING, 500);
//#endif

    static void* pTargetMeter = NULL;
    /* Infinite loop */
    for(;;)
    {
#ifdef RECODE_FUNC_METER_TASK
        if(timer[TIMER_IDX_METER_POLLING].isAlarm)
        {
            timerRefresh(TIMER_IDX_METER_POLLING);
#endif
            if (Charger.m_bUseExtMeter_PRO380)
            {
#ifdef RECODE_FUNC_METER_TASK

#ifdef RECODE_METER_PRO380
                static PPRO380 p = NULL;
                if (p == NULL)
                {
                    p = (PPRO380)HTK_Malloc(sizeof(PRO380));
                    if (p != NULL)
                    {
                        Charger.m_pPRO380 = p;
                        PRO380_Init(p, METER_PRO380_DEV_ADDR);
                    }
                }
                else
                {
                    if (pTargetMeter != (void*)p)
                    {
                        pTargetMeter = (void*)p;
                        MX_UART4_Init_For_Meter_PRO380();
                        __HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE);
                    }
                    PRO380_Proc(p);
                }
#endif //RECODE_METER_PRO380

#else //RECODE_FUNC_METER_TASK
                {
                    meter_model = METER_MODEL_PRO380;

                    if(UART_METER_recv_end_flag != ON)
                    {
                        // Polling meter info
                        uint8_t tx[UART_BUFFER_SIZE];
                        uint8_t tx_len = 0;

                        if(timer[TIMER_IDX_METER_POLLING].isAlarm)
                        {
                            timerRefresh(TIMER_IDX_METER_POLLING);
                            switch(pollingStep)
                            {
                                case 0:
                                  tx_len = read_Energy_tx(meter_model, addr, &tx[0]);
                                  break;
                            }
                            HAL_GPIO_WritePin(Meter_DIR_GPIO_Port, Meter_DIR_Pin, GPIO_PIN_SET);
                            osDelay(5);
                            HAL_UART_Transmit(&METER_USART, (uint8_t *)tx, tx_len, 0xffff);
                            osDelay(5);
                            HAL_GPIO_WritePin(Meter_DIR_GPIO_Port, Meter_DIR_Pin, GPIO_PIN_RESET);
                            osDelay(30);
                        }
                    }
                    else
                    {
                        switch(pollingStep)
                        {
                            case 0:
                              // Total enery
                              if(read_Energy_rx(meter_model, addr, &UART_METER_rx_buffer[0], UART_METER_rx_len))
                              {
                                  //pollingStep++; //Only process case 0 (Total Energy)
                                  Charger.counter.Meter_Timeout.fail = 0;
                                  Charger.m_MeterPRO380.m_LastUpdateTick = HAL_GetTick();
                              }
                              break;
                        }
                        memset(&UART_METER_rx_buffer[0], 0x00, ARRAY_SIZE(UART_METER_rx_buffer));
                        UART_METER_rx_len = 0;
                        UART_METER_recv_end_flag = OFF;

                    }
                    HAL_UART_Receive_DMA(&METER_USART,(uint8_t*)UART_METER_rx_buffer, UART_BUFFER_SIZE);
                }
#endif //RECODE_FUNC_METER_TASK
            }

#ifdef FUNC_PTB_METER_WM3M4C
            if (Charger.m_bUseExtMeter_WM3M4C)
            {
                static PWM3M4C p = NULL;
                if (p == NULL)
                {
                    p = (PWM3M4C)HTK_Malloc(sizeof(WM3M4C));
                    if (p != NULL)
                    {
                        Charger.m_pWM3M4C = p;
                        WM3M4C_Init(p, METER_WM3M4C_DEV_ADDR);
                    }
                }
                else
                {
                    if (pTargetMeter != (void*)p)
                    {
                        pTargetMeter = (void*)p;
                        MX_UART4_Init_For_PTB_Meter_WM3M4C();
                        __HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE);
                    }
                    WM3M4C_Proc(p);
                }
            }
#endif //FUNC_PTB_METER_WM3M4C

#ifdef FUNC_EKM_OMNIMETER
            if (Charger.m_bUseExtMeter_OMNIMETER)
            {
                static PEKM_Omnimeter p = NULL;
                if (p == NULL)
                {
                    p = (PEKM_Omnimeter)HTK_Malloc(sizeof(EKM_Omnimeter));
                    if (p != NULL)
                    {
                        Charger.m_pEKM_Omnimeter = p;
                        EKM_Omnimeter_Init(p);
                    }
                }
                else
                {
                    if (pTargetMeter != (void*)p)
                    {
                        pTargetMeter = (void*)p;
                        MX_UART4_Init_For_EKM_Omnimeter();
                        __HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE);
                    }
                    EKM_Omnimeter_Proc(p);
                }
            }
#endif //FUNC_EKM_OMNIMETER

#ifdef RECODE_FUNC_METER_TASK
        }
#endif
        osDelay(1);
    }
    /* USER CODE END StartMeterTask */
}

/* Private application code --------------------------------------------------*/
/* USER CODE BEGIN Application */

#ifdef RECODE_FUNC_METER_IC_TASK
void MeterIC_Proc(uint16_t* pUpdateMemReq)
{

#ifdef FUNC_METER_IC_ADE7858A
    //Meter IC
    {
        //meter_model = METER_MODEL_IC;

#ifndef DEBUG_METER_IC
        HTK_UNUSED(MeterIC_KP);
#endif


        double Volt[AC_PHASE_NUM_MAX] = { 0 };
        double Curr[AC_PHASE_NUM_MAX] = { 0 };
        static uint32_t EngPlusRaw[AC_PHASE_NUM_MAX] = { 0 };

#ifdef FUNC_METER_IC_POWER_FADEOUT
        static uint32_t ValidCurrTick = 0;
#endif

        if(timer[TIMER_IDX_METER_IC_POLLING].isAlarm)
        {
            timerRefresh(TIMER_IDX_METER_IC_POLLING);

            //Check new calibration values
            if (Charger.m_MeterIC_TrigWriteCaliVals.m_Data != 0) //Find new calibration values
            {
                MeterIC_WriteCaliValsFromFlash(HTK_FALSE, HTK_TRUE);
            }

            //Read data from Meter IC and calculate
            {
                PMeterIC_MeasVals p = &Charger.m_MeterIC_MeasVals;
                uint8_t *RxBuf = I2C_METER_rx_buffer;

                ADE7858A_Get(AVRMS, RxBuf, &p->m_AVRMS, 4); //V1
                ADE7858A_Get(BVRMS, RxBuf, &p->m_BVRMS, 4); //V2
                ADE7858A_Get(CVRMS, RxBuf, &p->m_CVRMS, 4); //V3

#ifdef FUNC_METER_IC_READ_PHASE_ANGLE
                {
                    PMeterIC_ExtraInfo pEx = &Charger.m_MeterIcEx;
                    ADE7858A_Get(MMODE, RxBuf, &pEx->m_MMODE, 1); //MMODE
                    ADE7858A_Get(COMPMODE, RxBuf, &pEx->m_COMPMODE, 2); //COMPMODE

                    ADE7858A_Get(ANGLE0, RxBuf, &pEx->m_AngleReg[0], 2); //ANGLE0
                    ADE7858A_Get(ANGLE1, RxBuf, &pEx->m_AngleReg[1], 2); //ANGLE1
                    ADE7858A_Get(ANGLE2, RxBuf, &pEx->m_AngleReg[2], 2); //ANGLE2

                    ADE7858A_Get(Period, RxBuf, &p->m_Period, 2); //Period

                    if (HTK_IS_BETWEEN_MIDDIFF(p->m_Period, 5120, 30)) //Datasheet "Period Measurement"
                    {
                        pEx->m_AcPeriodMode = AC_PERIOD_MODE_50HZ;
                        for (u8 i = 0; i < 3; i++)
                        {
                            if (pEx->m_AngleReg[i] != 0)
                            {
                                pEx->m_AngleDegree[i] = METER_IC_ANGLE_REG_TO_DEGREE(50, pEx->m_AngleReg[i]);
                            }
                        }
                    }
                    else if (HTK_IS_BETWEEN_MIDDIFF(p->m_Period, 4267, 30))
                    {
                        pEx->m_AcPeriodMode = AC_PERIOD_MODE_60HZ;
                        for (u8 i = 0; i < 3; i++)
                        {
                            if (pEx->m_AngleReg[i] != 0)
                            {
                                pEx->m_AngleDegree[i] = METER_IC_ANGLE_REG_TO_DEGREE(60, pEx->m_AngleReg[i]);
                            }
                        }
                    }
                    else
                    {
                        pEx->m_AcPeriodMode = AC_PERIOD_MODE_UNKNOW;
    //                    for (u8 i = 0; i < 3; i++)
    //                    {
    //                        pEx.m_AngleDegree[i] = 0;
    //                    }
                    }

                    ADE7858A_Get(STATUS0, RxBuf, &pEx->m_STATUS0, 4);   //STATUS0
                    ADE7858A_Get(STATUS1, RxBuf, &pEx->m_STATUS1, 4);   //STATUS1
                    pEx->m_bSEQERR = BIT_GET(pEx->m_STATUS1, 19);       //bit19

                }
#endif //FUNC_METER_IC_READ_PHASE_ANGLE

                ADE7858A_Get(AIRMS, RxBuf, &p->m_AIRMS, 4); //I1
                ADE7858A_Get(BIRMS, RxBuf, &p->m_BIRMS, 4); //I2
                ADE7858A_Get(CIRMS, RxBuf, &p->m_CIRMS, 4); //I3

                ADE7858A_Get(AVRMS_LRIP, RxBuf, &p->m_AVRMS_LRIP, 4); //V1_LRIP
                ADE7858A_Get(BVRMS_LRIP, RxBuf, &p->m_BVRMS_LRIP, 4); //V2_LRIP
                ADE7858A_Get(CVRMS_LRIP, RxBuf, &p->m_CVRMS_LRIP, 4); //V3_LRIP

                ADE7858A_Get(AIRMS_LRIP, RxBuf, &p->m_AIRMS_LRIP, 4); //I1_LRIP
                ADE7858A_Get(BIRMS_LRIP, RxBuf, &p->m_BIRMS_LRIP, 4); //I2_LRIP
                ADE7858A_Get(CIRMS_LRIP, RxBuf, &p->m_CIRMS_LRIP, 4); //I3_LRIP

                ADE7858A_Get(AWATT, RxBuf, &p->m_AWATT, 4); //P1
                ADE7858A_Get(BWATT, RxBuf, &p->m_BWATT, 4); //P2
                ADE7858A_Get(CWATT, RxBuf, &p->m_CWATT, 4); //P3

                if (ADE7858A_Get(AWATTHR, RxBuf, &p->m_AWATTHR, 4)) { EngPlusRaw[0] += HTK_GET_VAL_MAX(p->m_AWATTHR, 0); } //E1, only positive energy allowed
                if (ADE7858A_Get(BWATTHR, RxBuf, &p->m_BWATTHR, 4)) { EngPlusRaw[1] += HTK_GET_VAL_MAX(p->m_BWATTHR, 0); } //E2, only positive energy allowed
                if (ADE7858A_Get(CWATTHR, RxBuf, &p->m_CWATTHR, 4)) { EngPlusRaw[2] += HTK_GET_VAL_MAX(p->m_CWATTHR, 0); } //E3, only positive energy allowed

                Volt[0] = p->m_AVRMS * KV; //V
                Volt[1] = p->m_BVRMS * KV; //V
                Volt[2] = p->m_CVRMS * KV; //V

#ifdef TEST_ACXXX_FAKEDATA
                HTK_UNUSED(Volt[0]);
#endif

#ifdef FUNC_METER_IC_VARIABLE_PARAM
                Curr[0] = p->m_AIRMS * MeterIC_KI; //A
                Curr[1] = p->m_BIRMS * MeterIC_KI; //A
                Curr[2] = p->m_CIRMS * MeterIC_KI; //A
#else
                Curr[0] = p->m_AIRMS * KI; //A
                Curr[1] = p->m_BIRMS * KI; //A
                Curr[2] = p->m_CIRMS * KI; //A
#endif

                for (uint8_t i = 0; i < AC_PHASE_NUM_MAX; i++)
                {
#ifndef TEST_ACXXX_FAKEDATA

#ifdef VO_SIMU_ACV
                    if (Charger.m_VOCode.m_EnableSimuACV)
                    {
                        Charger.Voltage[i] = Charger.m_SimuData.m_AcvVolt;
                    }
                    else
                    {
                        Charger.Voltage[i] = (uint16_t)(Volt[i] * 100); //10mV
                    }
#else
                    Charger.Voltage[i] = (uint16_t)(Volt[i] * 100); //10mV
#endif //VO_SIMU_ACV

#endif //TEST_ACXXX_FAKEDATA



#ifdef VO_SIMU_ACA
                    if (Charger.m_VOCode.m_EnableSimuACA)
                    {
                        if (Charger.m_b3PhaseModel || (!Charger.m_b3PhaseModel && i == 0))
                        {
                            Charger.Current[i] = Charger.m_SimuData.m_AcaCurr;
                        }
                    }
                    else
                    {
                        Charger.Current[i] = (uint16_t)(Curr[i] * 100); //10mA
                    }
#else
                    Charger.Current[i] = (uint16_t)(Curr[i] * 100); //10mA
#endif //VO_SIMU_ACA

                }

#ifdef FUNC_METER_IC_POWER_FADEOUT
                if (Curr[0] > METER_IC_POWER_CONSUMPTION_MIN_CURR ||
                    Curr[1] > METER_IC_POWER_CONSUMPTION_MIN_CURR ||
                    Curr[2] > METER_IC_POWER_CONSUMPTION_MIN_CURR)
                {
                    //ValidCurrTick = (int64_t)HAL_GetTick();
                    ValidCurrTick = HAL_GetTick();
                }
#endif


#ifdef DEBUG_METER_IC
                XP("L1_Voltage: %f (%d)\r\n", Volt[0], p->m_AVRMS);
                XP("L2_Voltage: %f (%d)\r\n", Volt[1], p->m_BVRMS);
                XP("L3_Voltage: %f (%d)\r\n", Volt[2], p->m_CVRMS);

                XP("L1_Current: %f (%d)\r\n", Curr[0], p->m_AIRMS);
                XP("L2_Current: %f (%d)\r\n", Curr[1], p->m_BIRMS);
                XP("L3_Current: %f (%d)\r\n", Curr[2], p->m_CIRMS);

                double Volt_LRIP[AC_PHASE_NUM_MAX] = { 0 };
                double Curr_LRIP[AC_PHASE_NUM_MAX] = { 0 };

                Volt_LRIP[0] = p->m_AVRMS_LRIP * KV; //V
                Volt_LRIP[1] = p->m_BVRMS_LRIP * KV; //V
                Volt_LRIP[2] = p->m_CVRMS_LRIP * KV; //V

#ifdef FUNC_METER_IC_VARIABLE_PARAM
                Curr_LRIP[0] = p->m_AIRMS_LRIP * MeterIC_KI ; //A
                Curr_LRIP[1] = p->m_BIRMS_LRIP * MeterIC_KI ; //A
                Curr_LRIP[2] = p->m_CIRMS_LRIP * MeterIC_KI ; //A
#else
                Curr_LRIP[0] = p->m_AIRMS_LRIP * KI; //A
                Curr_LRIP[1] = p->m_BIRMS_LRIP * KI; //A
                Curr_LRIP[2] = p->m_CIRMS_LRIP * KI; //A
#endif

                XP("L1_Voltage_LRIP: %f (%d)\r\n", Volt_LRIP[0], p->m_AVRMS_LRIP);
                XP("L2_Voltage_LRIP: %f (%d)\r\n", Volt_LRIP[1], p->m_BVRMS_LRIP);
                XP("L3_Voltage_LRIP: %f (%d)\r\n", Volt_LRIP[2], p->m_CVRMS_LRIP);

                XP("L1_Current_LRIP: %f (%d)\r\n", Curr_LRIP[0], p->m_AIRMS_LRIP);
                XP("L2_Current_LRIP: %f (%d)\r\n", Curr_LRIP[1], p->m_BIRMS_LRIP);
                XP("L3_Current_LRIP: %f (%d)\r\n", Curr_LRIP[2], p->m_CIRMS_LRIP);

#ifdef FUNC_METER_IC_VARIABLE_PARAM
                double Power1 = p->m_AWATT * MeterIC_KP; //W
                double Power2 = p->m_BWATT * MeterIC_KP; //W
                double Power3 = p->m_CWATT * MeterIC_KP; //W
#else
                double Power1 = p->m_AWATT * KP; //W
                double Power2 = p->m_BWATT * KP; //W
                double Power3 = p->m_CWATT * KP; //W
#endif
                XP("L1_WATT(W): %f (%d, %u)\r\n", Power1, p->m_AWATT, (uint32_t)p->m_AWATT);
                XP("L2_WATT(W): %f (%d, %u)\r\n", Power2, p->m_BWATT, (uint32_t)p->m_BWATT);
                XP("L3_WATT(W): %f (%d, %u)\r\n", Power3, p->m_CWATT, (uint32_t)p->m_CWATT);

#ifdef FUNC_METER_IC_VARIABLE_PARAM
                double Energy1 = p->m_AWATTHR * MeterIC_KE; //Wh
                double Energy2 = p->m_BWATTHR * MeterIC_KE; //Wh
                double Energy3 = p->m_CWATTHR * MeterIC_KE; //Wh
#else
                double Energy1 = p->m_AWATTHR * KE; //Wh
                double Energy2 = p->m_BWATTHR * KE; //Wh
                double Energy3 = p->m_CWATTHR * KE; //Wh
#endif

                XP("L1_WATTHR(Wh): %f (%d, %u)\r\n", Energy1, p->m_AWATTHR, (uint32_t)p->m_AWATTHR);
                XP("L2_WATTHR(Wh): %f (%d, %u)\r\n", Energy2, p->m_BWATTHR, (uint32_t)p->m_BWATTHR);
                XP("L3_WATTHR(Wh): %f (%d, %u)\r\n", Energy3, p->m_CWATTHR, (uint32_t)p->m_CWATTHR);
#endif //DEBUG_METER_IC
            }


        }

#ifdef FUNC_POWER_CONSUMPTION_BY_METER_IC

        if(timer[TIMER_IDX_POWER].isAlarm)
        {
            timerRefresh(TIMER_IDX_POWER);

            if (0)
            {

            }
#ifdef FUNC_PTB_METER_WM3M4C
            else if (Charger.m_bUseExtMeter_WM3M4C && Charger.m_pWM3M4C)
            {

                uint64_t Eng = Charger.m_pWM3M4C->m_AccuEnergy1 / ((Charger.m_b3PhaseModel) ? 3 : 1);

                if (Charger.m_b3PhaseModel)
                {
                    Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 = Eng;
                    Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 = Eng;
                    Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3 = Eng;

                    Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total =
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 +
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 +
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3;
                }
                else
                {
                    Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 = Eng;
                    Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 = 0;
                    Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3 = 0;

                    Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total =
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1;
                }
            }
#endif //FUNC_PTB_METER_WM3M4C
            else if (Charger.m_bUseExtMeter_PRO380 && Charger.m_pPRO380) //Use PRO380
            {
                for (uint8_t i = 0; i < AC_PHASE_NUM_MAX; i++)
                {
                    Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Lx[i] =

//                            //round off to 2 decimal place
//                            //i.g. 0.53 (float: 0.52999..) => 52.999.. => 53 => 5300 (0.0001 kWh) => 0.53 kWh
//                            (uint64_t)(HTK_ROUND_U64(Charger.m_MeterPRO380.m_AE_Lx_Total[i] * 100) * 100);

                        //round off to 4 decimal place
                        //i.g. 0.53 (float: 0.52999..) => 52.999.. => 53 => 5300 (0.0001 kWh) => 0.53 kWh
#ifdef RECODE_METER_PRO380
                        ((uint64_t)(HTK_ROUND_U64(Charger.m_pPRO380->m_Lx_Total_active_energy[i].m_Val * 10000)));
#else
                        (uint64_t)(HTK_ROUND_U64(Charger.m_MeterPRO380.m_AE_Lx_Total[i] * 10000));
#endif
                }

                if (Charger.m_b3PhaseModel)
                {
                    Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total =
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 +
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 +
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3;
                }
                else
                {
                    Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total =
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1;
                }

            }
            else //Use Meter IC
            {
                static double EngPlus[AC_PHASE_NUM_MAX] = { 0 };
                static double Eng[AC_PHASE_NUM_MAX] = { 0 };
                for (uint8_t i = 0; i < AC_PHASE_NUM_MAX; i++)
                {
#ifdef FUNC_METER_IC_VARIABLE_PARAM
                    EngPlus[i] = EngPlusRaw[i] * MeterIC_KE;
#else
                    EngPlus[i] = EngPlusRaw[i] * KE;
#endif
                    EngPlusRaw[i] = 0;

#ifdef FUNC_METER_IC_POWER_FADEOUT
                    //Energy is calculated only when the current is greater than 0.5A and within METER_IC_POWER_FADEOUT_TIME
                    double PlusVal = (HTK_GET_VAL(HTK_IsInTime(ValidCurrTick, METER_IC_POWER_FADEOUT_TIME), HTK_GET_VAL_MAX(EngPlus[i], 0), 0) * 10); //Unit: 0.1 Wh
#else
                    //Energy is calculated only when the current is greater than 0.5A
                    double PlusVal = (HTK_GET_VAL(Curr[i] > METER_IC_POWER_CONSUMPTION_MIN_CURR, HTK_GET_VAL_MAX(EngPlus[i], 0), 0) * 10); //Unit: 0.1 Wh
#endif
                    Eng[i] += PlusVal;
#ifdef DEBUG_METER_IC
                    DEBUG_INFO("L%d_WATTHR(Wh): %f\r\n", i + 1, EngPlus[i]);
                    DEBUG_INFO("L%d += %f (%f) [%llu, %.4f kWh]\r\n", i + 1, PlusVal, Eng[i],
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Lx[i],
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Lx[i] * 0.0001);
#endif
                }

#ifdef DEBUG_METER_IC
                double EngTotal = (Eng[0] + Eng[1] + Eng[2]);
                DEBUG_INFO("#Total Energy = %f [%llu, %.4f kWh]\r\n", EngTotal, Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total,
                           Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total * 0.0001);
#endif

                uint32_t EngIntPart[AC_PHASE_NUM_MAX] = { (uint32_t)Eng[0], (uint32_t)Eng[1], (uint32_t)Eng[2] };

                if (EngIntPart[0] != 0 || EngIntPart[1] != 0 || EngIntPart[2] != 0)
                {
                    uint32_t IntPart = 0; //Storage INTEGER part and keep the DECIMAL part

                    for (uint8_t i = 0; i < AC_PHASE_NUM_MAX; i++)
                    {
                        IntPart = EngIntPart[i];
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Lx[i] += IntPart;
                        Eng[i] -= IntPart;
#ifdef DEBUG_METER_IC
                        DEBUG_INFO("#PowerConsumptionCumulative_L%d = %llu (%d Added)\r\n", i + 1, Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Lx[i], IntPart);
#endif
                    }

                    if (Charger.m_b3PhaseModel)
                    {
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total =
                            Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 +
                            Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 +
                            Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3;
                    }
                    else
                    {
                        Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total =
                            Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1;
                    }

#ifdef DEBUG_METER_IC
                    DEBUG_INFO("#Power_Consumption_Cumulative = %llu\r\n", Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total);
#endif
                }
            }

            //if(++updateMemReq >= METER_IC_POWER_CONSUMPTION_SAVE_MAX_COUNT)
            if(++(*pUpdateMemReq) >= METER_IC_POWER_CONSUMPTION_SAVE_MAX_COUNT)
            {
                //updateMemReq = 0;
                *pUpdateMemReq = 0;

                static uint64_t PreSaveEnergy = 0;
                if (PreSaveEnergy != Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total)
                {
                    PreSaveEnergy = Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total;
#ifdef DEBUG_METER_IC
                    DEBUG_INFO("#SAVE POWER CONSUMPTION DATA TO FLASH\r\n");
#endif
                    Charger.memory.EVSE_Config.op_bits.update = ON;
                }
            }
        }
#endif //FUNC_POWER_CONSUMPTION_BY_METER_IC
    }
#endif //FUNC_METER_IC_ADE7858A

}


void StartMeterIcTask(void const * argument)
{

#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    IdleUntilReadAllMemory();
#endif

#ifdef FUNC_METER_IC_ADE7858A
    while (Charger.ModelReadisOK != PASS )
    {
        osDelay(100);
    }
    MeterIC_InitLoop(METER_IC_INIT_RETRY_NUM_MAX);

    timerEnable(TIMER_IDX_METER_IC_POLLING, METER_IC_TIMER_IDX_METER_POLLING_SPEC);

#ifdef FUNC_POWER_CONSUMPTION_BY_METER_IC
    timerEnable(TIMER_IDX_POWER, METER_IC_TIMER_IDX_POWER_TIMEOUT_SPEC);
    //uint8_t updateMemReq = 0;
    uint16_t updateMemReq = 0;
#endif

#endif //FUNC_METER_IC_ADE7858A

#ifdef FUNC_TMP100
    if (Charger.m_bUseTMP100)
    {
        TMP100_Init();
    }
#endif

    while (1)
    {

#ifdef FUNC_RESET_DATA_AFTER_WRITE_NEW_MODELNAME
        if (Charger.m_bTrigToRefreshMeterIcCaliVal)
        {
            Charger.m_bTrigToRefreshMeterIcCaliVal = HTK_FALSE;
            MeterIC_WriteCaliValsFromFlash(HTK_TRUE, HTK_TRUE);
            osDelay(1);
        }
#endif
        MeterIC_Proc(&updateMemReq);

#ifdef FUNC_TMP100
        if (Charger.m_bUseTMP100)
        {
            static u8 c = 0;
            c++;
            if (c >= 10)
            {
                c = 0;
                TMP100_Proc();
                osDelay(10);
            }
        }
#endif //FUNC_TMP100

        osDelay(1);
    }
}
#endif //RECODE_FUNC_METER_IC_TASK

#ifdef MODIFY_IMCP

void UpdateCheckSum(uint8_t *Buf, uint16_t Len) //Len: Total package length
{
    uint16_t DataLen = Len - (IMCP_FM_HEAD_LEN + IMCP_FM_TAIL_LEN);
    uint8_t CheckSum = 0;

    //Update DataLen
    HTK_U16(Buf[IMCP_FM_DATALEN_LSB_IDX]) = DataLen;

    //Update CheckSum
    for (uint16_t i = 0; i < DataLen; i++)
    {
        CheckSum ^= Buf[IMCP_FM_DATA_BEG_IDX + i];
    }
    Buf[Len - 1] = CheckSum;
}

#ifdef FUNC_RS485_SLAVE
uint8_t isValidCheckSum_IAP(uint8_t *RxBuf)
{
    uint8_t result = OFF;
    uint8_t chksum = 0x00;

    if  (
            (RxBuf[IMCP_FM_FRAMEID_IDX] == PROTOCOL_HEAD) &&
            (
                    (RxBuf[IMCP_FM_DSTADDR_IDX] == PROTOCOL_ADDR)
                ||  (RxBuf[IMCP_FM_DSTADDR_IDX] == PROTOCOL_ADDR_AC_MAINBOARD)
                ||  (RxBuf[IMCP_FM_DSTADDR_IDX] == PROTOCOL_ADDR_BROADCAST)
            )
        )
    {
        uint16_t nCheckSumIdx = IMCP_FM_DATA_BEG_IDX + HTK_U16(RxBuf[IMCP_FM_DATALEN_LSB_IDX]);
        for(uint16_t i = IMCP_FM_DATA_BEG_IDX; i < nCheckSumIdx; i++)
        {
          chksum ^= RxBuf[i];
        }

        if(chksum == RxBuf[nCheckSumIdx])
            result = ON;
    }

    return result;
}
#else //FUNC_RS485_SLAVE
uint8_t isValidCheckSum_IAP(void)
{
    uint8_t result = OFF;
    uint8_t chksum = 0x00;

    if  (
            (UART_IAP_rx_buffer[IMCP_FM_FRAMEID_IDX] == PROTOCOL_HEAD) &&
            (
                    (UART_IAP_rx_buffer[IMCP_FM_DSTADDR_IDX] == PROTOCOL_ADDR)
                ||  (UART_IAP_rx_buffer[IMCP_FM_DSTADDR_IDX] == PROTOCOL_ADDR_BROADCAST)
            )
        )
    {
        uint16_t nCheckSumIdx = IMCP_FM_DATA_BEG_IDX + HTK_U16(UART_IAP_rx_buffer[IMCP_FM_DATALEN_LSB_IDX]);
        for(uint16_t i = IMCP_FM_DATA_BEG_IDX; i < nCheckSumIdx; i++)
        {
          chksum ^= UART_IAP_rx_buffer[i];
        }

        if(chksum == UART_IAP_rx_buffer[nCheckSumIdx])
            result = ON;
    }

    return result;
}
#endif //FUNC_RS485_SLAVE

#else //MODIFY_IMCP
uint8_t isValidCheckSum_IAP(void)
{
  uint8_t result = OFF;
  uint8_t chksum = 0x00;

  if((UART_IAP_rx_buffer[0] == PROTOCOL_HEAD) &&
     ((UART_IAP_rx_buffer[2] == PROTOCOL_ADDR) | (UART_IAP_rx_buffer[2] == PROTOCOL_ADDR_BROADCAST)))
  {
    for(int idx=0;idx<(UART_IAP_rx_buffer[4] | (UART_IAP_rx_buffer[5]<<8));idx++)
    {
      chksum ^= UART_IAP_rx_buffer[6+ idx];
    }

    if(chksum == UART_IAP_rx_buffer[6+(UART_IAP_rx_buffer[4] | (UART_IAP_rx_buffer[5]<<8))])
      result = ON;
  }

  return result;
}

#endif //MODIFY_IMCP
//-------------------------------------------------------------------------------------------------
uint8_t isValidCheckSum_BLE(void)
{
    uint8_t result = OFF;
    uint8_t chksum = 0x00;

    if(((UART_BLE_rx_buffer[1] | (UART_BLE_rx_buffer[0]<<8))-1) < UART_BUFFER_SIZE)
    {
        for(int idx=2;idx<((UART_BLE_rx_buffer[1] | (UART_BLE_rx_buffer[0]<<8))-1);idx++)
        {
            chksum ^= UART_BLE_rx_buffer[idx];
        }

        if(chksum == UART_BLE_rx_buffer[(UART_BLE_rx_buffer[1] | (UART_BLE_rx_buffer[0]<<8))-1])
            result = ON;
    }

    return result;
}

//-------------------------------------------------------------------------------------------------
uint8_t isValidCheckSum_WIFI(void)
{
    uint8_t result = OFF;
    uint8_t chksum = 0x00;

    if(((UART_WIFI_rx_buffer[1] | (UART_WIFI_rx_buffer[0]<<8))-1) < UART_BUFFER_SIZE)
    {
        for(int idx=2;idx<((UART_WIFI_rx_buffer[1] | (UART_WIFI_rx_buffer[0]<<8))-1);idx++)
        {
            chksum ^= UART_WIFI_rx_buffer[idx];
        }

        if(chksum == UART_WIFI_rx_buffer[(UART_WIFI_rx_buffer[1] | (UART_WIFI_rx_buffer[0]<<8))-1])
            result = ON;
    }

    return result;
}

//-------------------------------------------------------------------------------------------------
#ifdef FUNC_DEBUG_MSG_SET_CHARGER_MODE
char* getModeName(uint8_t mode);
#endif

void setChargerMode(uint8_t mode)
{
#ifdef FUNC_DEBUG_MSG_SET_CHARGER_MODE
    XP("#SET CHARGER MODE:  [%s] >>> [%s]\r\n", getModeName(Charger.Mode_Previous), getModeName(mode));
#endif
	Charger.Mode_Previous = Charger.Mode;
	Charger.Mode = mode;
}

//-------------------------------------------------------------------------------------------------
char* getModeName(uint8_t mode)
{
    switch(mode)
    {
        case MODE_INITIAL:
            return "INITIAL";
        case MODE_IDLE:
            return "IDLE";
        case MODE_HANDSHAKE:
            return "HANDSHAKING";
        case MODE_CHARGING:
            return "CHARGING";
        case MODE_STOP:
            return "STOP";
        case MODE_ALARM:
            return "ALARM";
        case MODE_MAINTAIN:
            return "MAINTAIN";
        case MODE_DEBUG:
            return "DEBUG";
        default:
            return "UNKNOW";
    }
}

//-------------------------------------------------------------------------------------------------
uint8_t isModeChange(void)
{
	uint8_t result = NO;

	if(!isMode(Charger.Mode_Previous))
	{
        DEBUG_INFO("#MODE from %s to %s\r\n", getModeName(Charger.Mode_Previous), getModeName(Charger.Mode));
        result |= YES;
        if(Charger.Mode == MODE_ALARM)
        {
          Charger.Mode_Before_Alarm = Charger.Mode_Previous;
        }
        Charger.Mode_Previous = Charger.Mode;
	}

	return result;
}


//-------------------------------------------------------------------------------------------------
uint8_t isMode(uint8_t mode)
{
	return ((Charger.Mode == mode)? YES : NO);
}

//-------------------------------------------------------------------------------------------------
uint8_t rfidCheckSumCal(uint8_t *data, uint8_t length)
{
    uint8_t result= 0x00;

    for(uint8_t idx=0;idx<length;idx++)
      result ^= data[idx];

    return result;
}

//-------------------------------------------------------------------------------------------------
void HAL_PWR_PVDCallback(void)
{
    HAL_Delay(100);
    NVIC_SystemReset();
}

//-------------------------------------------------------------------------------------------------
uint8_t Test_LeakModule(void)
{
//      uint8_t result = PASS, DC_check = false, AC_check=false;
//      uint16_t time_out_count;
//      uint8_t retry_cnt = 0 ;

    uint8_t result = PASS;

#ifdef CCID_PROTECT

    uint8_t DC_check = false;
    uint8_t AC_check=false;
    uint16_t time_out_count;
    uint8_t retry_cnt = 0 ;

#ifdef FUNC_AUTO_MODIFY_CCID_MODULE
    XP("#Test_LeakModule use CCID Module: %s\r\n", CCID_MODULE_TYPE_STR);
#endif

      if (Charger.CCID_Module_Type == CCID_MODULE_VAC)
      {
          osDelay(500);
          if(HAL_GPIO_ReadPin(IN_Leak_Error_GPIO_Port, IN_Leak_Error_Pin) == GPIO_PIN_SET)
          {
              DEBUG_INFO("VAC Leak Error pin ON.\r\n");
              result = FAIL;
          }
          else
          {
              HAL_Delay(270);
              HAL_GPIO_WritePin(OUT_Leak_Test_GPIO_Port , OUT_Leak_Test_Pin , GPIO_PIN_RESET);
              HAL_Delay(50);  //40ms~1.2sec
              HAL_GPIO_WritePin(OUT_Leak_Test_GPIO_Port , OUT_Leak_Test_Pin , GPIO_PIN_SET);
              //HAL_Delay(40);  //36ms

              time_out_count = 0;
              while(1)
              {
                  if(HAL_GPIO_ReadPin(IN_Leak_DC_GPIO_Port, IN_Leak_DC_Pin) == GPIO_PIN_SET)
                  {
                      DC_check = true;
                  }

                  if(HAL_GPIO_ReadPin(IN_Leak_AC_GPIO_Port, IN_Leak_AC_Pin) == GPIO_PIN_SET)
                  {
                      AC_check = true;
                  }

                  //if(DC_check&&AC_check)
                  if ((DC_check&&AC_check) && (HAL_GPIO_ReadPin(IN_Leak_AC_GPIO_Port, IN_Leak_AC_Pin) == GPIO_PIN_RESET) && (HAL_GPIO_ReadPin(IN_Leak_DC_GPIO_Port, IN_Leak_DC_Pin) == GPIO_PIN_RESET))
                  {
                      break;
                  }

                  if(time_out_count>2000)
                  {
                      //result = FAIL;

                      if(retry_cnt < 1 )
                      {
                        HAL_Delay(270);
                        HAL_GPIO_WritePin(OUT_Leak_Test_GPIO_Port , OUT_Leak_Test_Pin , GPIO_PIN_RESET);
                        HAL_Delay(50);  //40ms~1.2sec
                        HAL_GPIO_WritePin(OUT_Leak_Test_GPIO_Port , OUT_Leak_Test_Pin , GPIO_PIN_SET);
                        //HAL_Delay(40);  //36ms
                        retry_cnt ++ ;
                        time_out_count = 0 ;
                      }
                      else
                      {
                        DEBUG_INFO("Leak module self test Fail in timeout.\r\n");
                        result = FAIL;
                        break;
                      }
                  }
                  else
                  {
                      time_out_count++;
                      HAL_Delay(1);
                  }
              }
          }
      }
      else // Charger.CCID_Module_Type is CCID_MODULE_CORMEX
      {
            SPWM_Switch(ON);
            HAL_Delay(1000);

            XP("#[SPWM] adc_value.ADC2_IN6_GF.value = %d\r\n",adc_value.ADC2_IN6_GF.value);

            if ((adc_value.ADC2_IN6_GF.value<3000)&&(adc_value.ADC2_IN6_GF.value>2000)) //25mA
            {
                DEBUG_INFO("#Test_LeakModule(): OK\r\n");
                result = PASS ;
            }
            else
            {
                DEBUG_INFO("Test_LeakModule(): [NG]\r\n");
                //DEBUG_INFO("adc_value.ADC2_IN6_GF.value = %d\n\r",adc_value.ADC2_IN6_GF.value);
                result = FAIL;
            }
            SPWM_Switch(OFF);
    }
#endif  //CCID_PROTECT

    return result;
}

//-------------------------------------------------------------------------------------------------
uint8_t Valid_RFID_SN(void)
{
    /*
        TODO: Validation logic check
    */
    uint8_t result = FAIL;
    uint32_t crc_result;
    uint8_t sn_len;
    uint8_t *buf;

    if(Charger.rfid.snType == RFID_SN_TYPE_4BYTE)
    {
      // SN length: 4
      sn_len = 4;
    }
    else if(Charger.rfid.snType == RFID_SN_TYPE_7BYTE)
    {
      // SN length: 7
      sn_len = 7;
    }
    else
    {
      // SN length: 10
      sn_len = 10;
    }

    buf = malloc(25 + sn_len);
    memcpy(buf, Charger.memory.EVSE_Config.data.item.System_ID, 25);
    memcpy(&buf[25], Charger.rfid.data_Sn, sn_len);
    crc_result = crc32(buf, 25 + sn_len);

    if(((Charger.rfid.data_Block[0] << 8) | (Charger.rfid.data_Block[1] << 0) | (Charger.rfid.data_Block[2] << 24) | (Charger.rfid.data_Block[3] << 16)) == ~crc_result)
    {
        result = PASS;
    }

    free(buf);
    return result;
}

//-------------------------------------------------------------------------------------------------
void recordAlarmHis(void)
{
    uint8_t isSuccess = FAIL;
    // Check record alarm request, if alarm code bit different with previous
    for(uint8_t errIdx=0;errIdx<32;errIdx++)
    {
        if(((Charger.Alarm_Code>>errIdx)&0x01) != ((Charger.Alarm_Code_Previous>>errIdx)&0x01))
        {
            // Find empty memory space
            for(uint16_t idx=0;idx<(W25Q16FV_BLOCK_SIZE>>4);idx++)
            {
                if((Charger.memory.hisAlarm.data.item[idx].alarmCode == 0xffffffff) &&
                   (Charger.memory.hisAlarm.data.item[idx].mode == 0xff))
                {
                    isSuccess = PASS;

                    Charger.memory.hisAlarm.data.item[idx].DateTime.year = Charger.memory.EVSE_Config.data.item.SystemDateTime.year;
                    Charger.memory.hisAlarm.data.item[idx].DateTime.month = Charger.memory.EVSE_Config.data.item.SystemDateTime.month;
                    Charger.memory.hisAlarm.data.item[idx].DateTime.day = Charger.memory.EVSE_Config.data.item.SystemDateTime.day;
                    Charger.memory.hisAlarm.data.item[idx].DateTime.hour = Charger.memory.EVSE_Config.data.item.SystemDateTime.hour;
                    Charger.memory.hisAlarm.data.item[idx].DateTime.min = Charger.memory.EVSE_Config.data.item.SystemDateTime.min;
                    Charger.memory.hisAlarm.data.item[idx].DateTime.sec = Charger.memory.EVSE_Config.data.item.SystemDateTime.sec;
                    Charger.memory.hisAlarm.data.item[idx].mode = Charger.Mode;

                    if((Charger.Alarm_Code>>errIdx)&0x01)
                    {
                        // Record alarm occur
                        Charger.memory.hisAlarm.data.item[idx].alarmCode = alarm_record_code[errIdx];
                        Charger.memory.hisAlarm.data.item[idx].isRecover = OFF;
                        Charger.Alarm_Code_Previous |= (0x00000001<<errIdx);
                    }
                    else
                    {
                        // Record alarm recover
                        Charger.memory.hisAlarm.data.item[idx].alarmCode = alarm_record_code[errIdx];
                        Charger.memory.hisAlarm.data.item[idx].isRecover = ON;
                        Charger.Alarm_Code_Previous &= ~(0x00000001<<errIdx);
                    }
                    Charger.memory.hisAlarm.op_bits.update = ON;

                    // If speace is last item, move data to backup area
                    if(idx == ((W25Q16FV_BLOCK_SIZE>>4)-1))
                    {
                        osDelay(500);
                        Charger.memory.hisAlarm.op_bits.backup = ON;
                        osDelay(500);
                    }

                    break;
                }
            }

            // If there is not any free space
            if(!isSuccess)
            {
                osDelay(500);
                Charger.memory.hisAlarm.op_bits.backup = ON;
                osDelay(500);
            }
        }
    }
}

//-------------------------------------------------------------------------------------------------
#ifdef FUNC_METER_IC_HISTORY
uint8_t recordMeterICHis(MeterIC_CaliValType Type, int32_t Val)
{
    uint8_t isSuccess = FAIL;

    {
        for(uint16_t idx=0;idx<METER_IC_HISTORY_REC_NUM;idx++)
        {
            if (!MeterIC_CaliHistory_IsRecordValid(idx))

            {
                isSuccess = PASS;

                memcpy(&Charger.memory.hisMeterIC.data.item[idx].DateTime, &Charger.memory.EVSE_Config.data.item.SystemDateTime, sizeof(DT));
                Charger.memory.hisMeterIC.data.item[idx].m_CaliValType = Type;
                Charger.memory.hisMeterIC.data.item[idx].m_CaliVal = Val;
                Charger.memory.hisMeterIC.data.item[idx].m_Reserved[0] = 0xFF;
                Charger.memory.hisMeterIC.data.item[idx].m_Reserved[1] = 0xFF;
                //Update CheckSum
                HTK_CheckSum_Update(
                    (uint8_t*)&Charger.memory.hisMeterIC.data.item[idx],
                    (uint8_t*)&Charger.memory.hisMeterIC.data.item[idx].m_CheckSum -
                    (uint8_t*)&Charger.memory.hisMeterIC.data.item[idx].DateTime.year,
                    (uint8_t*)&Charger.memory.hisMeterIC.data.item[idx].m_CheckSum);


                Charger.memory.hisMeterIC.op_bits.update = ON;

                // If speace is last item, move data to backup area
                if(idx == (METER_IC_HISTORY_REC_NUM-1))
                {
                    osDelay(500);
                    Charger.memory.hisMeterIC.op_bits.backup = ON;
                }

                break;
            }
        }
    }


    // If there is not any free space
    if(!isSuccess)
    {
        osDelay(500);
        Charger.memory.hisMeterIC.op_bits.backup = ON;
    }

    return isSuccess;
}

#else //FUNC_METER_IC_HISTORY
uint8_t recordChargingHis(uint8_t isColdLoadPickUp, uint32_t statusCode)
{
    uint8_t isSuccess = FAIL;

    if(isColdLoadPickUp)
    {
        for(uint16_t idx=0;idx<(W25Q16FV_BLOCK_SIZE>>6);idx++)
        {
            if((Charger.memory.hisCharging.data.item[idx].Duration == 0xffffffff) &&
               (Charger.memory.hisCharging.data.item[idx].powerSum == 0xffff) &&
               (Charger.memory.hisCharging.data.item[idx].stopStatusCode == 0xffffffff) )
            {
                isSuccess = PASS;

                Charger.memory.hisCharging.data.item[idx].DateTime.year = Charger.memory.coldLoadPickUp.data.item.DateTime.year;
                Charger.memory.hisCharging.data.item[idx].DateTime.month = Charger.memory.coldLoadPickUp.data.item.DateTime.month;
                Charger.memory.hisCharging.data.item[idx].DateTime.day = Charger.memory.coldLoadPickUp.data.item.DateTime.day;
                Charger.memory.hisCharging.data.item[idx].DateTime.hour = Charger.memory.coldLoadPickUp.data.item.DateTime.hour;
                Charger.memory.hisCharging.data.item[idx].DateTime.min = Charger.memory.coldLoadPickUp.data.item.DateTime.min;
                Charger.memory.hisCharging.data.item[idx].DateTime.sec = Charger.memory.coldLoadPickUp.data.item.DateTime.sec;
                Charger.memory.hisCharging.data.item[idx].Duration = Charger.memory.coldLoadPickUp.data.item.Duration;
                sprintf(Charger.memory.hisCharging.data.item[idx].PlugType, EVSE_CONNECTOR_TYPE);
                Charger.memory.hisCharging.data.item[idx].powerSum = Charger.memory.coldLoadPickUp.data.item.powerSum;
                Charger.memory.hisCharging.data.item[idx].startType = Charger.memory.coldLoadPickUp.data.item.startType;
                Charger.memory.hisCharging.data.item[idx].stopStatusCode = statusCode;
                memcpy(Charger.memory.hisCharging.data.item[idx].user, Charger.rfid.currentCard, 16);
                Charger.memory.hisCharging.op_bits.update = ON;

                // If speace is last item, move data to backup area
                //if(idx == ((W25Q16FV_BLOCK_SIZE>>4)-1)) //NG
                if(idx == ((W25Q16FV_BLOCK_SIZE>>6)-1))
                {
                    osDelay(500);
                    Charger.memory.hisCharging.op_bits.backup = ON;
                }

                break;
            }
        }
    }
    else
    {
        for(uint16_t idx=0;idx<(W25Q16FV_BLOCK_SIZE>>6);idx++)
        {
            if((Charger.memory.hisCharging.data.item[idx].Duration == 0xffffffff) &&
               (Charger.memory.hisCharging.data.item[idx].powerSum == 0xffff) &&
               (Charger.memory.hisCharging.data.item[idx].stopStatusCode == 0xffffffff) )
            {
                isSuccess = PASS;

                Charger.memory.hisCharging.data.item[idx].DateTime.year = Charger.cycle_info.startDateTime.year;
                Charger.memory.hisCharging.data.item[idx].DateTime.month = Charger.cycle_info.startDateTime.month;
                Charger.memory.hisCharging.data.item[idx].DateTime.day = Charger.cycle_info.startDateTime.day;
                Charger.memory.hisCharging.data.item[idx].DateTime.hour = Charger.cycle_info.startDateTime.hour;
                Charger.memory.hisCharging.data.item[idx].DateTime.min = Charger.cycle_info.startDateTime.min;
                Charger.memory.hisCharging.data.item[idx].DateTime.sec = Charger.cycle_info.startDateTime.sec;
                Charger.memory.hisCharging.data.item[idx].Duration = Charger.cycle_info.Duration;
                sprintf(Charger.memory.hisCharging.data.item[idx].PlugType, EVSE_CONNECTOR_TYPE);
                Charger.memory.hisCharging.data.item[idx].powerSum = Charger.cycle_info.Power_Consumption;
                Charger.memory.hisCharging.data.item[idx].startType = Charger.cycle_info.StartType;
                Charger.memory.hisCharging.data.item[idx].stopStatusCode = statusCode;
                memcpy(Charger.memory.hisCharging.data.item[idx].user, Charger.rfid.currentCard, 16);
                Charger.memory.hisCharging.op_bits.update = ON;

                // If speace is last item, move data to backup area
                //if(idx == ((W25Q16FV_BLOCK_SIZE>>4)-1)) //NG
                if(idx == ((W25Q16FV_BLOCK_SIZE>>6)-1))
                {
                    osDelay(500);
                    Charger.memory.hisCharging.op_bits.backup = ON;
                }

                break;
            }
        }
    }

    // If there is not any free space
    if(!isSuccess)
    {
        osDelay(500);
        Charger.memory.hisCharging.op_bits.backup = ON;
    }

    return isSuccess;
}
#endif //FUNC_METER_IC_HISTORY
//-------------------------------------------------------------------------------------------------
void setLedMotion(uint8_t action)
{//ssetled
    //standard

#ifdef TEST_FOR_ENERGY_STAR
    if (action == LED_ACTION_IDLE_BACKEND_CONNECTED_SLEEP ||
        action == LED_ACTION_IDLE_BACKEND_DISCONNECTED_SLEEP
        )
    {
#ifdef FUNC_AW48_NO_SLEEP_MODE_LED
        if (Charger.m_bModelNameAW48_1P)
        {
            Charger.m_bLedSleepModeForceMinBrightness = 0;
        }
        else
        {
            Charger.m_bLedSleepModeForceMinBrightness = 1;
        }
#else
        Charger.m_bLedSleepModeForceMinBrightness = 1;
#endif
    }
    else
    {
        Charger.m_bLedSleepModeForceMinBrightness = 0;
    }
#endif

    switch(action)
    {
        case LED_ACTION_INIT:
            Charger.led_R.motion = LED_MOTION_ON;
            Charger.led_G.motion = LED_MOTION_ON;
            Charger.led_B.motion = LED_MOTION_ON;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(1000, 1000, 1000, 0);
            break;
        case LED_ACTION_IDLE:
            Charger.led_R.motion = LED_MOTION_OFF;
            Charger.led_G.motion = LED_MOTION_ON;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(0, 1000, 0, 0);
            break;

#ifdef MODIFY_LED_STATUS_202108

        case LED_ACTION_IDLE_BACKEND_CONNECTED:
            Charger.led_R.motion = LED_MOTION_OFF;
            Charger.led_G.motion = LED_MOTION_ON;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(0, 1000, 0, 0);
            break;

        case LED_ACTION_IDLE_BACKEND_CONNECTED_SLEEP:
#ifdef MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
            if (Charger.m_bModelNameAW48_1P)
            {
                Charger.led_R.motion = LED_MOTION_OFF;
                Charger.led_G.motion = LED_MOTION_ON;
                Charger.led_B.motion = LED_MOTION_OFF;
                Charger.led_W.motion = LED_MOTION_OFF;
                LedOnRGBSet(0, 1000, 0, 0);
            }
            else
            {
                Charger.led_R.motion = LED_MOTION_OFF;
                Charger.led_G.motion = LED_MOTION_BREATHE;
                Charger.led_B.motion = LED_MOTION_OFF;
                Charger.led_W.motion = LED_MOTION_OFF;
                LedOnRGBSet(0, 1000, 0, 0);
#ifdef MODIFY_BREATHE_LED
                breatheTimeSet(BREATHE_LED_UP_SPEED, BREATHE_LED_DN_SPEED, 0, 1000, 0, 0 );
#endif
            }
#else  //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
            Charger.led_R.motion = LED_MOTION_OFF;
            Charger.led_G.motion = LED_MOTION_BREATHE;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(0, 1000, 0, 0);
#ifdef MODIFY_BREATHE_LED
            breatheTimeSet(BREATHE_LED_UP_SPEED, BREATHE_LED_DN_SPEED, 0, 1000, 0, 0 );
#endif
#endif //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
            break;

        case LED_ACTION_IDLE_BACKEND_DISCONNECTED:
#ifdef MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
            if (Charger.m_bModelNameAW48_1P)
            {
                Charger.led_R.motion = LED_MOTION_OFF;
                Charger.led_G.motion = LED_MOTION_ON;
                Charger.led_B.motion = LED_MOTION_OFF;
                Charger.led_W.motion = LED_MOTION_OFF;
                LedOnRGBSet(0, 1000, 0, 0);
            }
            else
            {
                Charger.led_R.motion = LED_MOTION_ON;
                Charger.led_G.motion = LED_MOTION_ON;
                Charger.led_B.motion = LED_MOTION_OFF;
                Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
                LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#else
                LedOnRGBSet(1000, 1000, 0, 0);
#endif
            }
#else //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
            Charger.led_R.motion = LED_MOTION_ON;
            Charger.led_G.motion = LED_MOTION_ON;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
            LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#else
            LedOnRGBSet(1000, 1000, 0, 0);
#endif
#endif //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
            break;

        case LED_ACTION_IDLE_BACKEND_DISCONNECTED_SLEEP:
#ifdef MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
            if (Charger.m_bModelNameAW48_1P)
            {
                Charger.led_R.motion = LED_MOTION_OFF;
                Charger.led_G.motion = LED_MOTION_ON;
                Charger.led_B.motion = LED_MOTION_OFF;
                Charger.led_W.motion = LED_MOTION_OFF;
                LedOnRGBSet(0, 1000, 0, 0);
            }
            else
            {
                Charger.led_R.motion = LED_MOTION_BREATHE;
                Charger.led_G.motion = LED_MOTION_BREATHE;
                Charger.led_B.motion = LED_MOTION_OFF;
                Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
                LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#ifdef MODIFY_BREATHE_LED
                breatheTimeSet(BREATHE_LED_UP_SPEED, BREATHE_LED_DN_SPEED, LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0 );
#endif

#else //MODIFY_LED_YELLOW_PARAMETER
                LedOnRGBSet(1000, 1000, 0, 0);
#endif //MODIFY_LED_YELLOW_PARAMETER
            }
#else //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
            Charger.led_R.motion = LED_MOTION_BREATHE;
            Charger.led_G.motion = LED_MOTION_BREATHE;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
            LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#ifdef MODIFY_BREATHE_LED
            breatheTimeSet(BREATHE_LED_UP_SPEED, BREATHE_LED_DN_SPEED, LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0 );
#endif

#else //MODIFY_LED_YELLOW_PARAMETER
            LedOnRGBSet(1000, 1000, 0, 0);
#endif //MODIFY_LED_YELLOW_PARAMETER
#endif //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
            break;


        case LED_ACTION_RESERVATION_MODE:
            Charger.led_R.motion = LED_MOTION_OFF;
            Charger.led_G.motion = LED_MOTION_BLINK;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(0, 1000, 0, 0);
            blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
            break;
#endif //MODIFY_LED_STATUS_202108

        case LED_ACTION_AUTHED:
            Charger.led_R.motion = LED_MOTION_OFF;
            Charger.led_G.motion = LED_MOTION_OFF;
            Charger.led_B.motion = LED_MOTION_ON;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(0, 0, 1000, 0);
            break;
        case LED_ACTION_CONNECTED:
            Charger.led_R.motion = LED_MOTION_OFF;
            Charger.led_G.motion = LED_MOTION_OFF;
            Charger.led_B.motion = LED_MOTION_ON;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(0, 0, 1000, 0);
            break;
        case LED_ACTION_CHARGING:
            Charger.led_R.motion = LED_MOTION_OFF;
            Charger.led_G.motion = LED_MOTION_OFF;
            Charger.led_B.motion = LED_MOTION_BLINK;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(0, 0, 1000, 0);
            blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
            break;
        case LED_ACTION_STOP:
#ifdef FUNC_MODIFY_AW48_LED_ACTION_TERMINATED_COMPLETE
            if (Charger.m_bModelNameAW48_1P)
            {
                Charger.led_R.motion = LED_MOTION_OFF;
                Charger.led_G.motion = LED_MOTION_BLINK;
                Charger.led_B.motion = LED_MOTION_OFF;
                Charger.led_W.motion = LED_MOTION_OFF;
                LedOnRGBSet(0, 1000, 0, 0);
                blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
            }
            else
            {
                Charger.led_R.motion = LED_MOTION_OFF;
                Charger.led_G.motion = LED_MOTION_OFF;
                Charger.led_B.motion = LED_MOTION_ON;
                Charger.led_W.motion = LED_MOTION_OFF;
                LedOnRGBSet(0, 0, 1000, 0);
            }
#else
            Charger.led_R.motion = LED_MOTION_OFF;
            Charger.led_G.motion = LED_MOTION_OFF;
            Charger.led_B.motion = LED_MOTION_ON;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(0, 0, 1000, 0);
#endif

            break;

        case LED_ACTION_ALARM:
            Charger.led_R.motion = LED_MOTION_BLINK;
            Charger.led_G.motion = LED_MOTION_OFF;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(1000, 0, 0, 0);
            //set alarm led blink duty
            if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
                Charger.Alarm_LED = Charger.Alarm_Code;
            }else{
                Charger.Alarm_LED = Charger.am3352.LedAlarmState;
            }

            if(Charger.Alarm_LED & ALARM_CP_ERROR)
                blinkerTimeSet(BLINKER_IDX_LED, 500 , 500, 0, 1);
            if((Charger.Alarm_LED & ALARM_L1_OVER_VOLTAGE) || (Charger.Alarm_LED & ALARM_L2_OVER_VOLTAGE) || (Charger.Alarm_LED & ALARM_L3_OVER_VOLTAGE))
                blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 1);
            if((Charger.Alarm_LED & ALARM_L1_UNDER_VOLTAGE) || (Charger.Alarm_LED & ALARM_L2_UNDER_VOLTAGE) || (Charger.Alarm_LED & ALARM_L3_UNDER_VOLTAGE))
                blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 2);
            if((Charger.Alarm_LED & ALARM_L1_OVER_CURRENT) || (Charger.Alarm_LED & ALARM_L2_OVER_CURRENT) || (Charger.Alarm_LED & ALARM_L3_OVER_CURRENT))
                blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 3);
            if(Charger.Alarm_LED & ALARM_OVER_TEMPERATURE)
                blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 4);
            if(Charger.Alarm_LED & ALARM_CURRENT_LEAK_AC)
                blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 5);
            if(Charger.Alarm_LED & ALARM_CURRENT_LEAK_DC)
                blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 5);
            if(Charger.Alarm_LED & ALARM_GROUND_FAIL)
                blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 6);
            if(Charger.Alarm_LED & ALARM_HANDSHAKE_TIMEOUT)
                blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
            if(Charger.Alarm_LED & ALARM_EMERGENCY_STOP)
                blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 7);
            if(Charger.Alarm_LED & ALARM_ROTATORY_SWITCH_FAULT)
            {
#ifdef FUNC_AW48_EXT_LED_BLINK_PERIOD_MORE_THAN_200MS
                if (Charger.m_bModelNameAW48_1P)
                {
                    blinkerTimeSet(BLINKER_IDX_LED, AW48_EXTLED_BLINK_PERIOD, AW48_EXTLED_BLINK_PERIOD, 0, 1);
                }
                else
                {
                    blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
                }
#else
                blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
#endif
            }

            if(Charger.Alarm_LED & ALARM_METER_TIMEOUT)
                blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);

#ifdef MODIFY_LED_ALARM_LATCH

            //self test error
            if ((Charger.Alarm_Code & ALARM_MCU_TESTFAIL)       ||
                (Charger.Alarm_Code & ALARM_RELAY_STATUS)       ||
                (Charger.Alarm_Code & ALARM_RELAY_DRIVE_FUALT ) ||
                (Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL))
            {
                Charger.led_R.motion = LED_MOTION_ON;
                Charger.led_G.motion = LED_MOTION_OFF;
                Charger.led_B.motion = LED_MOTION_OFF;
                Charger.led_W.motion = LED_MOTION_OFF;
              LedOnRGBSet(1000, 0, 0, 0);
            }

#else //MODIFY_LED_ALARM_LATCH

            //OCP Latch
            if ((Charger.counter.L1_OC.isLatch == ON) || (Charger.counter.L2_OC.isLatch == ON) || (Charger.counter.L3_OC.isLatch == ON))
            {
              Charger.led_R.motion = LED_MOTION_ON ;
              Charger.led_B.motion = LED_MOTION_ON ;
              LedOnRGBSet(1000, 0, 1000, 0);
            }

            //CCID Latch
            if (Charger.counter.LEAK.isLatch == ON)
            {
               Charger.led_R.motion = LED_MOTION_ON ;
               Charger.led_G.motion = LED_MOTION_ON ;
#ifdef MODIFY_LED_YELLOW_PARAMETER
               LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#else
               LedOnRGBSet(1000, 1000, 0, 0);
#endif
            }

            //OTP
            if (Charger.counter.OT.isLatch == ON)
            {
              Charger.led_R.motion = LED_MOTION_ON;
              Charger.led_G.motion = LED_MOTION_BLINK;
              Charger.led_B.motion = LED_MOTION_BLINK;
              Charger.led_W.motion = LED_MOTION_OFF;
              LedOnRGBSet(1000, 1000, 1000, 0);
              blinkerTimeSet(BLINKER_IDX_LED, 500 , 500, 0, 1);
            }

            //self test error
            if ((Charger.Alarm_Code & ALARM_MCU_TESTFAIL)       ||
                (Charger.Alarm_Code & ALARM_RELAY_STATUS)       ||
                (Charger.Alarm_Code & ALARM_RELAY_DRIVE_FUALT ) ||
                (Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL))
            {
                Charger.led_R.motion = LED_MOTION_ON;
                Charger.led_G.motion = LED_MOTION_OFF;
                Charger.led_B.motion = LED_MOTION_OFF;
                Charger.led_W.motion = LED_MOTION_OFF;
              LedOnRGBSet(1000, 0, 0, 0);
            }

#endif //MODIFY_LED_ALARM_LATCH

            break;

        case LED_ACTION_MAINTAIN:
#ifdef MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
            if (Charger.m_bModelNameAW48_1P)
            {
                Charger.led_R.motion = LED_MOTION_OFF;
                Charger.led_G.motion = LED_MOTION_BLINK;
                Charger.led_B.motion = LED_MOTION_OFF;
                Charger.led_W.motion = LED_MOTION_OFF;
                LedOnRGBSet(0, 1000, 0, 0);
                blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
            }
            else
            {
#ifdef MODIFY_LED_STATUS_202108
                //Yellow blink
                Charger.led_R.motion = LED_MOTION_BLINK;
                Charger.led_G.motion = LED_MOTION_BLINK;
                Charger.led_B.motion = LED_MOTION_OFF;
                Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
                LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#else
                LedOnRGBSet(1000, 1000, 0, 0);
#endif
                blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
#else
                Charger.led_R.motion = LED_MOTION_OFF;
                Charger.led_G.motion = LED_MOTION_BLINK;
                Charger.led_B.motion = LED_MOTION_OFF;
                Charger.led_W.motion = LED_MOTION_OFF;
                LedOnRGBSet(0, 1000, 0, 0);
                blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
#endif
            }
#else //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
#ifdef MODIFY_LED_STATUS_202108
            //Yellow blink
            Charger.led_R.motion = LED_MOTION_BLINK;
            Charger.led_G.motion = LED_MOTION_BLINK;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
            LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#else
            LedOnRGBSet(1000, 1000, 0, 0);
#endif
            blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
#else
            Charger.led_R.motion = LED_MOTION_OFF;
            Charger.led_G.motion = LED_MOTION_BLINK;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(0, 1000, 0, 0);
            blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
#endif
#endif //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE

            break;

        case LED_ACTION_RFID_PASS:
            Charger.led_R.motion = LED_MOTION_OFF;
            Charger.led_G.motion = LED_MOTION_BLINK;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(0, 1000, 0, 0);
#ifdef FUNC_AW48_EXT_LED_BLINK_PERIOD_MORE_THAN_200MS
            if (Charger.m_bModelNameAW48_1P)
            {
                blinkerTimeSet(BLINKER_IDX_LED, AW48_EXTLED_BLINK_PERIOD, AW48_EXTLED_BLINK_PERIOD, 0, 1);
            }
            else
            {
                blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
            }
#else
            blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
#endif
            break;

        case LED_ACTION_RFID_FAIL:
            Charger.led_R.motion = LED_MOTION_BLINK;
            Charger.led_G.motion = LED_MOTION_OFF;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(1000, 0, 0, 0);
#ifdef FUNC_AW48_EXT_LED_BLINK_PERIOD_MORE_THAN_200MS
            if (Charger.m_bModelNameAW48_1P)
            {
                blinkerTimeSet(BLINKER_IDX_LED, AW48_EXTLED_BLINK_PERIOD, AW48_EXTLED_BLINK_PERIOD, 0, 1);
            }
            else
            {
                blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
            }
#else
            blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
#endif
            break;

         case LED_ACTION_DEBUG:
            Charger.led_R.motion = LED_MOTION_BLINK;
            Charger.led_G.motion = LED_MOTION_BLINK;
            Charger.led_B.motion = LED_MOTION_BLINK;
            Charger.led_W.motion = LED_MOTION_BLINK;
            LedOnRGBSet(1000, 1000, 1000, 1000);
            blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
            break;
         case LED_ACTION_ALL_OFF:
            Charger.led_R.motion = LED_MOTION_OFF;
            Charger.led_G.motion = LED_MOTION_OFF;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(0, 0, 0, 0);
            break ;
         case LED_ACTION_HANDSHAKE_FAIL:
            Charger.led_R.motion = LED_MOTION_BLINK;
            Charger.led_G.motion = LED_MOTION_OFF;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(1000, 0, 0, 0);
            blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
            break;
         case LED_ACTION_INTERNET_DISCONNECT:
#ifdef MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
            if (Charger.m_bModelNameAW48_1P)
            {
                Charger.led_R.motion = LED_MOTION_OFF;
                Charger.led_G.motion = LED_MOTION_ON;
                Charger.led_B.motion = LED_MOTION_OFF;
                Charger.led_W.motion = LED_MOTION_OFF;
                LedOnRGBSet(0, 1000, 0, 0);
            }
            else
            {
                Charger.led_R.motion = LED_MOTION_ON;
                Charger.led_G.motion = LED_MOTION_ON;
                Charger.led_B.motion = LED_MOTION_OFF;
                Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
                LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#else
                LedOnRGBSet(1000, 1000, 0, 0);
#endif
            }
#else //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
            Charger.led_R.motion = LED_MOTION_ON;
            Charger.led_G.motion = LED_MOTION_ON;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
            LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#else
            LedOnRGBSet(1000, 1000, 0, 0);
#endif
#endif //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
            break;

        case LED_ACTION_RESTORE_SETTING:
            Charger.led_R.motion = LED_MOTION_OFF;
            Charger.led_G.motion = LED_MOTION_OFF;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_BLINK;
            LedOnRGBSet(0, 0, 0, 1000);
            blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
            break;
#ifdef MODIFY_LED_STATUS_202108


#endif //MODIFY_LED_STATUS_202108

         default :
            Charger.led_R.motion = LED_MOTION_OFF;
            Charger.led_G.motion = LED_MOTION_OFF;
            Charger.led_B.motion = LED_MOTION_OFF;
            Charger.led_W.motion = LED_MOTION_OFF;
            LedOnRGBSet(0, 0, 0, 0);
            break;


    }
    if((action != LED_ACTION_RFID_PASS) &&
       (action != LED_ACTION_RFID_FAIL) &&
       (action != LED_ACTION_BLE_CONNECT) &&
       (action != LED_ACTION_BLE_DISABLE) &&
       (action != LED_ACTION_HANDSHAKE_FAIL) &&
       (action != LED_ACTION_RESTORE_SETTING))
    {
      Charger.Led_Mode = action;
    }
}
//-------------------------------------------------------------------------------------------------
#ifdef FUNC_CUSTOMIZED_LED_MODE_FROM_CSU
void setLedMotion_User(uint8_t action, PLED_UserCfg p)
{
    if (action != LED_ACTION_CUSTOMIZED_MODE || p == NULL)
        return;

    //Check data

    Charger.m_bLedSleepModeForceMinBrightness = 0;
    const u16 RGBMAX = 1000;
    if (p->m_R > RGBMAX) p->m_R = RGBMAX;
    if (p->m_G > RGBMAX) p->m_G = RGBMAX;
    if (p->m_B > RGBMAX) p->m_B = RGBMAX;

    if (p->m_Mode == LED_USER_MODE_SOLID)
    {
        Charger.led_R.motion = (p->m_R > 0 ? LED_MOTION_ON : LED_MOTION_OFF);
        Charger.led_G.motion = (p->m_G > 0 ? LED_MOTION_ON : LED_MOTION_OFF);
        Charger.led_B.motion = (p->m_B > 0 ? LED_MOTION_ON : LED_MOTION_OFF);
        Charger.led_W.motion = LED_MOTION_OFF;
        LedOnRGBSet(p->m_R, p->m_G, p->m_B, 0);
    }
    else if (p->m_Mode == LED_USER_MODE_BLINK)
    {
        Charger.led_R.motion = (p->m_R > 0 ? LED_MOTION_BLINK : LED_MOTION_OFF);
        Charger.led_G.motion = (p->m_G > 0 ? LED_MOTION_BLINK : LED_MOTION_OFF);
        Charger.led_B.motion = (p->m_B > 0 ? LED_MOTION_BLINK : LED_MOTION_OFF);
        Charger.led_W.motion = LED_MOTION_OFF;
        LedOnRGBSet(p->m_R, p->m_G, p->m_B, 0);
        if (p->Blink.m_Count > HTK_U8_MAX) p->Blink.m_Count = HTK_U8_MAX;
        blinkerTimeSet(BLINKER_IDX_LED, p->Blink.m_On_ms, p->Blink.m_Off_ms, p->Blink.m_Rest_ms, p->Blink.m_Count);
    }
    else if (p->m_Mode == LED_USER_MODE_BREATH)
    {
        Charger.led_R.motion = (p->m_R > 0 ? LED_MOTION_BREATHE : LED_MOTION_OFF);
        Charger.led_G.motion = (p->m_G > 0 ? LED_MOTION_BREATHE : LED_MOTION_OFF);
        Charger.led_B.motion = (p->m_B > 0 ? LED_MOTION_BREATHE : LED_MOTION_OFF);
        Charger.led_W.motion = LED_MOTION_OFF;
        LedOnRGBSet(p->m_R, p->m_G, p->m_B, 0);
        breatheTimeSet(p->Breath.m_Up_ms, p->Breath.m_Down_ms, p->m_R, p->m_G, p->m_B, 0);
    }
    else
    {

    }

    if (p->m_AutoRepeat)
        Charger.Led_Mode = action;

}
#endif //FUNC_CUSTOMIZED_LED_MODE_FROM_CSU
//-------------------------------------------------------------------------------------------------
#ifdef FUNC_AW48_NET_LED
void setNetLedMotion(uint8_t action)
{
    switch(action)
    {
        case NET_LED_ACTION_LTE_CONNECTING:
            Charger.LedNet_G.motion = LED_MOTION_BLINK;
            Charger.LedNet_B.motion = LED_MOTION_OFF;
            blinkerTimeSet(BLINKER_IDX_LED_NET, 200, 800, 0, 1);
            break;

        case NET_LED_ACTION_LTE_CONNECTED:
            Charger.LedNet_G.motion = LED_MOTION_ON;
            Charger.LedNet_B.motion = LED_MOTION_OFF;
            break;

        case NET_LED_ACTION_WIFI_CONNECTING:
            Charger.LedNet_G.motion = LED_MOTION_OFF;
            Charger.LedNet_B.motion = LED_MOTION_BLINK;
            blinkerTimeSet(BLINKER_IDX_LED_NET, 200, 800, 0, 1);
            break;

        case NET_LED_ACTION_WIFT_CONNECTED:
            Charger.LedNet_G.motion = LED_MOTION_OFF;
            Charger.LedNet_B.motion = LED_MOTION_ON;
            break;

        case NET_LED_ACTION_ETHERNET_CONNECTING:
            Charger.LedNet_G.motion = LED_MOTION_OFF;
            Charger.LedNet_B.motion = LED_MOTION_BLINK;
            blinkerTimeSet(BLINKER_IDX_LED_NET, 200, 800, 0, 1);
            break;

        case NET_LED_ACTION_ETHERNET_CONNECTED:
            Charger.LedNet_G.motion = LED_MOTION_OFF;
            Charger.LedNet_B.motion = LED_MOTION_ON;
            break;

        case NET_LED_ACTION_ALL_CONNECTING:
            Charger.am3352.NetLedActionSubState = NET_LED_ACTION_ETHERNET_CONNECTING_H;
            break;

        case NET_LED_ACTION_OFF:
            Charger.LedNet_G.motion = LED_MOTION_OFF;
            Charger.LedNet_B.motion = LED_MOTION_OFF;
            break;

        //(HIDE for NET_LED_ACTION_ALL_CONNECTING) ---------------
        case NET_LED_ACTION_LTE_CONNECTING_H:
            Charger.LedNet_G.motion = LED_MOTION_BLINK;
            Charger.LedNet_B.motion = LED_MOTION_OFF;
            blinkerTimeSet(BLINKER_IDX_LED_NET, 200, 800, 3000, 3);
            break;

        case NET_LED_ACTION_WIFI_CONNECTING_H:
            Charger.LedNet_G.motion = LED_MOTION_OFF;
            Charger.LedNet_B.motion = LED_MOTION_BLINK;
            blinkerTimeSet(BLINKER_IDX_LED_NET, 200, 800, 3000, 3);
            break;

        case NET_LED_ACTION_ETHERNET_CONNECTING_H:
            Charger.LedNet_G.motion = LED_MOTION_OFF;
            Charger.LedNet_B.motion = LED_MOTION_BLINK;
            blinkerTimeSet(BLINKER_IDX_LED_NET, 200, 800, 3000, 3);
            break;
        //---------------------------------------------------------

        default:
            Charger.LedNet_G.motion = LED_MOTION_OFF;
            Charger.LedNet_B.motion = LED_MOTION_OFF;
            break;
    }
}
#endif //FUNC_AW48_NET_LED
//-------------------------------------------------------------------------------------------------
void HAL_ADC_LevelOutOfWindowCallback(ADC_HandleTypeDef* hadc)
{
#ifdef CCID_PROTECT
    if (Charger.CCID_Module_Type == CCID_MODULE_CORMEX)
    {
       if(hadc->Instance == ADC2) //use watch dog to check ccid level
       {
            if (!Charger.isTestLeakModule)
            {
                if(Charger.counter.WatchDogLeak >= 5)
                {
                    if(!(Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC))
                    {
                        DEBUG_INFO("leak adc watch happen\r\n");
                        Charger.counter.LEAK.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                        Charger.Alarm_Code |= ALARM_CURRENT_LEAK_AC;
                        timerEnable(TIMER_IDX_RETRY_LEAK_AC, ALARM_RETRY_INTERVAL_LEAK);
                        Charger.counter.LEAK.retry++ ;
                        Charger.Relay_Action =  GPIO_RELAY_ACTION_OFF  ;
                        RELAY1_SET_DRIV(0);
                        RELAY1_SET_HOLD(0);
                        RELAY2_SET_DRIV(0);
                        RELAY2_SET_HOLD(0);

                        Charger.counter.WatchDogLeak = 0 ;
                    }
                }
                else
                {
                   Charger.counter.WatchDogLeak ++ ;
                }
            }
        }
    }
#endif  //CCID_PROTECT
}

//-------------------------------------------------------------------------------------------------
void vApplicationStackOverflowHook( TaskHandle_t xTask, signed char *pcTaskName )
{
    DEBUG_ERROR("Stack overflow: %s\r\n", pcTaskName);
    osDelay(500);
}

//-------------------------------------------------------------------------------------------------
void getlastRecord(void)
{
#ifdef FUNC_METER_IC_HISTORY
    for(uint16_t idx=0;idx<METER_IC_HISTORY_REC_NUM;idx++)
    {
        if (!MeterIC_CaliHistory_IsRecordValid(idx))
        {
            DEBUG_INFO("MeterIC record last index: %d\r\n", (idx));
            break;
        }
    }
#else //FUNC_METER_IC_HISTORY
    //for(uint16_t idx=0;idx<(W25Q16FV_BLOCK_SIZE>>4);idx++) //NG
    for(uint16_t idx=0;idx<(W25Q16FV_BLOCK_SIZE>>6);idx++)
    {
        if((Charger.memory.hisCharging.data.item[idx].Duration == 0xffffffff) &&
           (Charger.memory.hisCharging.data.item[idx].powerSum == 0xffff) &&
           (Charger.memory.hisCharging.data.item[idx].stopStatusCode == 0xffffffff) )
        {
            DEBUG_INFO("Charging record last index: %d\r\n", (idx));
            break;
        }
    }
#endif //FUNC_METER_IC_HISTORY


    //for(uint16_t idx=0;idx<(W25Q16FV_BLOCK_SIZE>>6);idx++) //NG
    for(uint16_t idx=0;idx<(W25Q16FV_BLOCK_SIZE>>4);idx++)
    {
        if((Charger.memory.hisAlarm.data.item[idx].alarmCode == 0xffffffff) &&
           (Charger.memory.hisAlarm.data.item[idx].mode == 0xff))
        {
            DEBUG_INFO("Alarm record last index: %d\r\n", (idx));
            break;
        }
    }
}

//-------------------------------------------------------------------------------------------------

#ifdef FUNC_ROTARY_CURR_MAP
typedef struct _RotaryCurrItem
{
    uint8_t m_nCurr;            //(A)
    uint8_t m_bTestMode:    1;
    uint8_t m_bInvalidItem: 1;
    uint8_t m_bSlaveMode:   1;
}
RotaryCurrItem, *PRotaryCurrItem;

#define ROTARY_CURR_ITEM_NUM    (16)
#define AX48_DEF_CURR           (48)
#define AX32_DEF_CURR           (32)

#ifdef FUNC_AX80
#define AX80_DEF_CURR           (80)
#endif

#ifdef FUNC_AT32
#define AT32_DEF_CURR           (32)
#endif

#ifdef FUNC_AW48
#define AW48_DEF_CURR           (48)
#endif

const RotaryCurrItem RotaryCurrMap_AX48[ROTARY_CURR_ITEM_NUM] =
    {
        { AX48_DEF_CURR,    1,  0,  0 },    //0:    Test Mode ************
        { 6,                0,  0,  0 },    //1:    6A      10%
        { 8,                0,  0,  0 },    //2:    8A      13.33%
        { 10,               0,  0,  0 },    //3:    10A     16.67%
        { 13,               0,  0,  0 },    //4:    13A     21.67%
        { 16,               0,  0,  0 },    //5:    16A     26.67%
        { 20,               0,  0,  0 },    //6:    20A     33.33%
        { 25,               0,  0,  0 },    //7:    25A     41.67%
        { 30,               0,  0,  0 },    //8:    30A     50.00%
        { 32,               0,  0,  0 },    //9:    32A     53.33%
        { 40,               0,  0,  0 },    //A:    40A     66.67%
        { AX48_DEF_CURR,    0,  0,  0 },    //B:    48A     80.00% (DEFAULT)
        { AX48_DEF_CURR,    0,  1,  0 },    //C:    Reserved *************  (Invalid)
        { AX48_DEF_CURR,    0,  1,  0 },    //D:    Reserved *************  (Invalid)
        { 80,               0,  1,  0 },    //E:    80A     96.00% ?????    (Invalid)
        { AX48_DEF_CURR,    0,  0,  1 },    //F:    Slave Mode ***********
    };


#ifdef MODIFY_AX32_ROTATE_SWITCH_TABLE_20210915
const RotaryCurrItem RotaryCurrMap_AX32[ROTARY_CURR_ITEM_NUM] =
    {
        { AX32_DEF_CURR,    1,  0,  0 },    //0:    Test Mode ************
        { 6,                0,  0,  0 },    //1:    6A      10%
        { 8,                0,  0,  0 },    //2:    8A      13.33%
        { 10,               0,  0,  0 },    //3:    10A     16.67%
        { 13,               0,  0,  0 },    //4:    13A     21.67%
        { 16,               0,  0,  0 },    //5:    16A     26.67%
        { 20,               0,  0,  0 },    //6:    20A     33.33%
        { 25,               0,  0,  0 },    //7:    25A     41.67%
        { 30,               0,  0,  0 },    //8:    30A     50.00%
        { AX32_DEF_CURR,    0,  0,  0 },    //9:    32A     53.33% (DEFAULT)
        { AX32_DEF_CURR,    0,  1,  0 },    //A:    40A     66.67%          (Invalid)
        { AX32_DEF_CURR,    0,  1,  0 },    //B:    48A     80.00%          (Invalid)
        { AX32_DEF_CURR,    0,  1,  0 },    //C:    Reserved *************  (Invalid)
        { AX32_DEF_CURR,    0,  1,  0 },    //D:    Reserved *************  (Invalid)
        { 80,               0,  1,  0 },    //E:    80A     96.00% ?????    (Invalid)
        { AX32_DEF_CURR,    0,  0,  1 },    //F:    Slave Mode ***********
    };
#else
    // Old procedure (Deleted)
#endif //MODIFY_AX32_ROTATE_SWITCH_TABLE_20210915

#ifdef FUNC_AT32
const RotaryCurrItem RotaryCurrMap_AT32[ROTARY_CURR_ITEM_NUM] =
    {
        { AT32_DEF_CURR,    1,  0,  0 },    //0:    Test Mode ************
        { 6,                0,  0,  0 },    //1:    6A      10%
        { 8,                0,  0,  0 },    //2:    8A      13.33%
        { 10,               0,  0,  0 },    //3:    10A     16.67%
        { 13,               0,  0,  0 },    //4:    13A     21.67%
        { 16,               0,  0,  0 },    //5:    16A     26.67%
        { 20,               0,  0,  0 },    //6:    20A     33.33%
        { 25,               0,  0,  0 },    //7:    25A     41.67%
        { 30,               0,  0,  0 },    //8:    30A     50.00%
        { AT32_DEF_CURR,    0,  0,  0 },    //9:    32A     53.33% (DEFAULT)
        { AT32_DEF_CURR,    0,  1,  0 },    //A:    40A     66.67%          (Invalid)
        { AT32_DEF_CURR,    0,  1,  0 },    //B:    48A     80.00%          (Invalid)
        { AT32_DEF_CURR,    0,  1,  0 },    //C:    Reserved *************  (Invalid)
        { AT32_DEF_CURR,    0,  1,  0 },    //D:    Reserved *************  (Invalid)
        { 80,               0,  1,  0 },    //E:    80A     96.00% ?????    (Invalid)
        { AT32_DEF_CURR,    0,  0,  1 },    //F:    Slave Mode ***********
    };
#endif //FUNC_AT32

#ifdef FUNC_AX80
const RotaryCurrItem RotaryCurrMap_AX80[ROTARY_CURR_ITEM_NUM] =
    {
        { AX80_DEF_CURR,    1,  0,  0 },    //0:    Test Mode ************
        { 6,                0,  0,  0 },    //1:    6A      10%
        { 8,                0,  0,  0 },    //2:    8A      13.33%
        { 10,               0,  0,  0 },    //3:    10A     16.67%
        { 13,               0,  0,  0 },    //4:    13A     21.67%
        { 16,               0,  0,  0 },    //5:    16A     26.67%
        { 20,               0,  0,  0 },    //6:    20A     33.33%
        { 25,               0,  0,  0 },    //7:    25A     41.67%
        { 30,               0,  0,  0 },    //8:    30A     50.00%
        { 32,               0,  0,  0 },    //9:    32A     53.33%
        { 40,               0,  0,  0 },    //A:    40A     66.67%
        { 48,               0,  0,  0 },    //B:    48A     80.00%
        { AX80_DEF_CURR,    0,  1,  0 },    //C:    Reserved *************  (Invalid)
        { AX80_DEF_CURR,    0,  1,  0 },    //D:    Reserved *************  (Invalid)
        { AX80_DEF_CURR,    0,  0,  0 },    //E:    80A     96.00%  (DEFAULT)
        { AX80_DEF_CURR,    0,  0,  1 },    //F:    Slave Mode ***********
    };
#endif //FUNC_AX80

#ifdef FUNC_AW48
const RotaryCurrItem RotaryCurrMap_AW48[ROTARY_CURR_ITEM_NUM] =
    {
        { AW48_DEF_CURR,    1,  0,  0 },    //0:    X Test Mode ************  (Invalid)
        { 12,               0,  0,  0 },    //1:    12A     20.00%
        { 16,               0,  0,  0 },    //2:    16A     26.67%
        { 24,               0,  0,  0 },    //3:    24A     40.00%
        { 32,               0,  0,  0 },    //4:    32A     53.33%
        { 40,               0,  0,  0 },    //5:    40A     66.67%
        { AW48_DEF_CURR,    0,  0,  0 },    //6:    48A     80.00% (DEFAULT)
        { AW48_DEF_CURR,    0,  1,  0 },    //7:    Reserved *************  (Invalid)
        { AW48_DEF_CURR,    0,  1,  0 },    //8:    Reserved *************  (Invalid)
        { AW48_DEF_CURR,    0,  1,  0 },    //9:    Reserved *************  (Invalid)
        { AW48_DEF_CURR,    0,  1,  0 },    //A:    Reserved *************  (Invalid)
        { AW48_DEF_CURR,    0,  1,  0 },    //B:    Reserved *************  (Invalid)
        { AW48_DEF_CURR,    0,  1,  0 },    //C:    Reserved *************  (Invalid)
        { AW48_DEF_CURR,    0,  1,  0 },    //D:    Reserved *************  (Invalid)
        { AW48_DEF_CURR,    0,  1,  0 },    //E:    Reserved *************  (Invalid)
        { AW48_DEF_CURR,    0,  1,  0 },    //F:    X Slave Mode ***********  (Invalid)
    };

#endif //FUNC_AW48

#endif //FUNC_ROTARY_CURR_MAP

void getRotarySwitchSetting(void)
{
    uint8_t tmpBuf = 0;
#ifdef ROTATE_SWITCH_HARDCODE
    tmpBuf = HC_ROTARY_SWITCH_SET_VAL;
#else
    tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set1_GPIO_Port, IN_AC_Current_Set1_Pin)?0:1)<<0;
    tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set2_GPIO_Port, IN_AC_Current_Set2_Pin)?0:1)<<1;
    tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set3_GPIO_Port, IN_AC_Current_Set3_Pin)?0:1)<<2;
    tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set4_GPIO_Port, IN_AC_Current_Set4_Pin)?0:1)<<3;
#endif //ROTATE_SWITCH_HARDCODE

#ifdef FUNC_ROTARY_CURR_MAP

#ifdef FUNC_AX80
    RotaryCurrItem const *p = NULL;
    if (Charger.m_bModelNameAX80_1P)
    {
        p = &RotaryCurrMap_AX80[tmpBuf];
    }
    else if (Charger.m_bModelNameAX48_1P)
    {
        p = &RotaryCurrMap_AX48[tmpBuf];
    }
    else if (Charger.m_bModelNameAX32_3P || Charger.m_bModelNameDC)
    {
        p = &RotaryCurrMap_AX32[tmpBuf];
    }
#ifdef FUNC_AT32
    else if (Charger.m_bModelNameAT32_3P)
    {
        p = &RotaryCurrMap_AT32[tmpBuf];
    }
#endif
#ifdef FUNC_AW48
    else if (Charger.m_bModelNameAW48_1P)
    {
        p = &RotaryCurrMap_AW48[tmpBuf];
    }
#endif
    else
    {
        p = &RotaryCurrMap_AX48[tmpBuf];
    }
#else
    RotaryCurrItem const *p = (Charger.m_b3PhaseModel ? &RotaryCurrMap_AX32[tmpBuf] : &RotaryCurrMap_AX48[tmpBuf]);
#endif
    Charger.maxRatingCurrent = p->m_nCurr;
    Charger.isDebugEnable = p->m_bTestMode;
    Charger.isRotarySwitchError = p->m_bInvalidItem;

    XP("#[RotarySwitch(%c)] MaxCurr(%d), TestMode(%d), SwitchError(%d), SlaveMode(%d)\r\n",
        CharacterArray[tmpBuf],
        Charger.maxRatingCurrent,
        Charger.isDebugEnable,
        Charger.isRotarySwitchError,
        Charger.m_bRotarySlaveMode);


#else //FUNC_ROTARY_CURR_MAP
    // Old procedure (Deleted)
#endif //FUNC_ROTARY_CURR_MAP

    DEBUG_INFO("Current rating value: %d A\r\n", Charger.maxRatingCurrent);
    Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = Charger.maxRatingCurrent;

#ifdef MODIFY_AC_EVSE_STATUS_MAX_CHARGING_CURRENT_VARIABLE
    Charger.AC_MaxChargingCurrentOrDuty = Charger.maxRatingCurrent;
#endif
}

//------------------------------------------------------------------------------//
void CLC_Corr_Gain_Par(uint16_t SpecData_H ,uint16_t SpecData_L ,uint16_t MCUData_H , uint16_t MCUData_L , float *GainA , float *GainB )
{
    *GainA = (float)((float)(SpecData_H -SpecData_L) / (float)( MCUData_H - MCUData_L)) ;
    *GainB = (float)(SpecData_H - (float)(*GainA * MCUData_H)) ;
}

//------------------------------------------------------------------------------//
void CLC_Corr_Gain_Par2(uint16_t SpecData_H ,uint16_t SpecData_L ,uint16_t MCUData_H , uint16_t MCUData_L , float *GainA , float *GainB , uint8_t *PosorNeg )
{
    *GainA = (float)((float)(SpecData_H -SpecData_L) / (float)( MCUData_H - MCUData_L)) ;

    if (SpecData_H > (*GainA * MCUData_H))
    {
        *GainB = SpecData_H - (*GainA * MCUData_H) ;
        *PosorNeg = ON ;
    }
    else
    {
        *GainB = (*GainA * MCUData_H) - SpecData_H ;
        *PosorNeg = OFF ;
    }
}

//------------------------------------------------------------------------------
uint8_t Array_data_Check ( uint8_t *s1, uint8_t *s2 )
{
     uint8_t compare = 0;
     uint8_t result = PASS;

     for(compare=0;compare<sizeof(s1);compare++)
     {
         if(s1[compare]!=s2[compare])
         {
           result = FAIL;
           break;
         }
     }

     return result;
}

//------------------------------------------------------------------------------
void Relay_Control_Function (void)
{
#ifdef KENNY_SAFETY_TEST_RELAY_ALWAYS_ON
    //Relay_Action_Set(GPIO_RELAY1_ACTION_ON);
    RELAY1_SET_DRIV(1);
    RELAY1_SET_HOLD(0);
    //Relay_Action_Set(GPIO_RELAY2_ACTION_ON);
    RELAY2_SET_DRIV(1);
    RELAY2_SET_HOLD(0);
    return;
#endif

#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
    static uint8_t PreRelayAction = GPIO_RELAY_ACTION_UNKNOW;
    HTK_BOOL bRelayActionChange = HTK_FALSE;
    if (PreRelayAction != Charger.Relay_Action)
    {
        PreRelayAction = Charger.Relay_Action;
        bRelayActionChange = HTK_TRUE;
    }
#endif

    switch(Charger.Relay_Action)
    {
        case GPIO_RELAY_ACTION_ON:
            if(Relay1_Action_Get() == GPIO_RELAY1_ACTION_OFF && Relay2_Action_Get() == GPIO_RELAY2_ACTION_OFF)
            {
#ifdef FUNC_GUN_LOCK
#ifdef FUNC_GUN_LOCK_TRIG_MODE
                if (Charger.m_bUseGunLock && Charger.m_GunLockTrigMode == GL_TRIG_MODE_RELAY)
#else
                if (Charger.m_bUseGunLock)
#endif
                {
                    if (GL_IsLock())
                    {
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
                        Charger.m_GunLock_Counter = 0;
#endif
                        Relay_Action_Set(GPIO_RELAY1_ACTION_ON);
                        Relay_Action_Set(GPIO_RELAY2_ACTION_ON);
                    }
                    else
                    {
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
                        if (bRelayActionChange)
                        {
                            Charger.m_GunLock_Counter = 0;
                        }
#endif
                        GL_Trig(GL_MODE_LOCK);
                    }
                }
                else
                {
                    Relay_Action_Set(GPIO_RELAY1_ACTION_ON);
                    Relay_Action_Set(GPIO_RELAY2_ACTION_ON);
                }
#else //FUNC_GUN_LOCK
                Relay_Action_Set(GPIO_RELAY1_ACTION_ON);
                Relay_Action_Set(GPIO_RELAY2_ACTION_ON);
#endif //FUNC_GUN_LOCK
            }
#ifdef FUNC_GUN_LOCK
            else if(Relay1_Action_Get() == GPIO_RELAY1_ACTION_ON && Relay2_Action_Get() == GPIO_RELAY2_ACTION_ON)
            {
#ifdef FUNC_GUN_LOCK_TRIG_MODE
                if (Charger.m_bUseGunLock && Charger.m_GunLockTrigMode == GL_TRIG_MODE_RELAY)
#else
                if (Charger.m_bUseGunLock)
#endif
                {
                    if (GL_IsLock())
                    {
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
                        Charger.m_GunLock_Counter = 0;
#endif
                    }
                    else
                    {
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
                        if (bRelayActionChange)
                        {
                            Charger.m_GunLock_Counter = 0;
                        }
#endif
                        GL_Trig(GL_MODE_LOCK);
                    }
                }
            }
#endif //FUNC_GUN_LOCK

            if(timer[TIMER_IDX_RELAY_1].isAlarm == ON && timer[TIMER_IDX_RELAY_2].isAlarm == ON)
            {
                Relay_Action_Set(GPIO_RELAY1_ACTION_HOLD);
                Relay_Action_Set(GPIO_RELAY2_ACTION_HOLD);
                timerDisable(TIMER_IDX_RELAY_1);
                timerDisable(TIMER_IDX_RELAY_2);
                Charger.Relay_isOperationCompleted  |= 0x11 ;
            }

            break;
        case GPIO_RELAY_ACTION_OFF:
            timer[TIMER_IDX_RELAY_1].isEnable = OFF;
            timer[TIMER_IDX_RELAY_2].isEnable = OFF;
            if(Relay1_Action_Get() != GPIO_RELAY1_ACTION_OFF)
            {
                Relay_Action_Set(GPIO_RELAY1_ACTION_OFF);
                Relay_Action_Set(GPIO_RELAY2_ACTION_OFF);

#ifdef FUNC_GUN_LOCK
#ifdef FUNC_GUN_LOCK_TRIG_MODE
                if (Charger.m_bUseGunLock && Charger.m_GunLockTrigMode == GL_TRIG_MODE_RELAY)
#else
                if (Charger.m_bUseGunLock)
#endif
                {
                    if (GL_IsLock())
                    {
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
                        if (bRelayActionChange)
                        {
                            Charger.m_GunUnlock_Counter = 0;
                        }
#endif
                        GL_Trig(GL_MODE_UNLOCK);
                    }
                    else
                    {
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
                        Charger.m_GunUnlock_Counter = 0;
#endif
                    }
                }
#endif //FUNC_GUN_LOCK

            }
#ifdef FUNC_GUN_LOCK
            else if(Relay1_Action_Get() == GPIO_RELAY1_ACTION_OFF)
            {
#ifdef FUNC_GUN_LOCK_TRIG_MODE
                if (Charger.m_bUseGunLock && Charger.m_GunLockTrigMode == GL_TRIG_MODE_RELAY)
#else
                if (Charger.m_bUseGunLock)
#endif
                {
                    if (GL_IsLock())
                    {
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
                        if (bRelayActionChange)
                        {
                            Charger.m_GunUnlock_Counter = 0;
                        }
#endif
                        GL_Trig(GL_MODE_UNLOCK);
                    }
                    else
                    {
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
                        Charger.m_GunUnlock_Counter = 0;
#endif
                    }
                }
            }
#endif

            osDelay(10);
            Charger.Relay_isOperationCompleted &= 0x00 ;
#ifdef FUNC_GET_TRIP_TIME
            if (Charger.m_TripBeg > 0 && Charger.m_TripEnd == HTK_U32_MAX)
            {
                Charger.m_TripEnd = HAL_GetTick();
            }
#endif
            break;

        default:
            break;
    }
}
//--------------------------------------------------------------------------------
#ifdef FUNC_OUTP_TYPE_E
void SE_Relay_Control_Function(void)
{
    switch(Charger.SE_Relay_Action)
    {
        case GPIO_SE_RELAY_ACTION_ON:

            if(SE_Relay1_Action_Get() == GPIO_SE_RELAY1_ACTION_OFF)
            {
              SE_Relay_Action_Set(GPIO_SE_RELAY1_ACTION_ON);
            }

            if(timer[TIMER_IDX_SE_RELAY_1].isAlarm == ON)
            {
              SE_Relay_Action_Set(GPIO_SE_RELAY1_ACTION_HOLD);
              timerDisable(TIMER_IDX_SE_RELAY_1);
              Charger.SE_Relay_isOperationCompleted  |= 0x11 ;
            }

            break;
        case GPIO_SE_RELAY_ACTION_OFF:
            timer[TIMER_IDX_SE_RELAY_1].isEnable = OFF;
            if(SE_Relay1_Action_Get() != GPIO_SE_RELAY1_ACTION_OFF)
            {
                SE_Relay_Action_Set(GPIO_SE_RELAY1_ACTION_OFF);
            }
            osDelay(10);
            Charger.SE_Relay_isOperationCompleted &= 0x00 ;

            break;
        default:
            break;
    }
}
#endif //FUNC_OUTP_TYPE_E

//--------------------------------------------------------------------------------
uint8_t WatchDogLeakRawDataCheck_Event(void)
{
    uint8_t result = PASS ;

    for(uint16_t idx = 0 ; idx < ADC2_SAMPLE_COUNT; idx++)
    {
        if (ADC2_Buffer_Each[1][idx] >= 4000)
        {
            result = FAIL;
            break;
        }
    }

    return result ;
}

//--------------------------------------------------------------------------------
uint16_t getBrightnessDuty(uint16_t max_duty)
{
    uint8_t Lv_Brightness = 3;
    uint16_t duty = 1000;

    Lv_Brightness = (Charger.Led_Brightness[(Charger.memory.EVSE_Config.data.item.SystemDateTime.hour/2)]>>(((Charger.memory.EVSE_Config.data.item.SystemDateTime.hour+1)%2)*4))&0xf;

    switch(Lv_Brightness)
    {
      case 0:
          duty = max_duty/4;
          break;
      case 1:
          duty = max_duty/3;
          break;
      case 2:
          duty = max_duty/2;
          break;
      case 3:
          duty = max_duty;
          break;
      default:
          duty = max_duty;
          break;
    }
#ifdef TEST_FOR_ENERGY_STAR
    //return duty / 10;
    //return duty / 4;
    if (Charger.m_bLedSleepModeForceMinBrightness)
    {
        duty = max_duty/4;;
    }
    return duty;
#else
    return duty;
#endif
}

//--------------------------------------------------------------------------------
void parseVersionInfoFromModelname(void)
{
#ifdef FUNC_XP_PARSE_VERSION_INFO_FROM_MODELNAME
    XP("Parse ModelName: %s\r\n", Charger.memory.EVSE_Config.data.item.ModelName);
#endif

#ifdef FUNC_VERSION_USE_NEW_SPEC_20240926
        //do nothing
#else //FUNC_VERSION_USE_NEW_SPEC_20240926
        //--------------------------------------
        // Version Naming Rule "tx.yz.ab.cddd.vv"
        //Version Naming Rule "a"
        for(uint8_t idx=0;idx<3;idx++)
        {
                switch(Charger.memory.EVSE_Config.data.item.ModelName[7+idx])
                {
                        case '1':
                                // J1772 Plug
                                Charger.Ver_FW[6] = '4';
                                break;
                        case '2':
                                // J1772 Socket
                                Charger.Ver_FW[6] = '1';
                                break;
                        case '3':
                                // CE Plug
                                Charger.Ver_FW[6] = '5';
                                break;
                        case '4':
                                // CE Socket
                                Charger.Ver_FW[6] = '2';
                                break;
                        case '5':
                                // GB Plug
                                Charger.Ver_FW[6] = '6';
                                break;
                        case '6':
                                // GB Socket
                                Charger.Ver_FW[6] = '3';
                                break;
#ifdef FUNC_ADD_FW_VER_WITH_GUN_TYPE_NACS
                        case '9':
                                // NACS
                                Charger.Ver_FW[6] = '9';
                                break;
#endif
                }
        }
#endif //FUNC_VERSION_USE_NEW_SPEC_20240926

        //Version Naming Rule "c"
        switch(Charger.memory.EVSE_Config.data.item.ModelName[10])
        {
                case 'B':
                case 'U':
                        //Blue tooth
                        Charger.Ver_FW[9] = '3';
                        break;
                case 'W':
                        // WIFI
                        Charger.Ver_FW[9] = '1';
                        break;
                case 'T':
                        // 3G/4G
                        Charger.Ver_FW[9] = '2';
                        break;
#ifdef FUNC_ADD_FW_VER_WITH_NET_TYPE_WIFI_AND_4G
                case 'D':
                        Charger.Ver_FW[9] = '5';
                        break;
#endif
                default:
                        // LAN
                        Charger.Ver_FW[9] = '0';
                        break;
        }

        //Version Naming Rule "d3" , Get rating power from model name
        memcpy(&Charger.Ver_FW[10], &Charger.memory.EVSE_Config.data.item.ModelName[4], 0x03);

        // Get vender code from model name
        memcpy(&Charger.Ver_FW[14], &Charger.memory.EVSE_Config.data.item.ModelName[12], 0x02);

        //--------------------------------------
        //adc2 watchdog config data
        ADC_AnalogWDGConfTypeDef AnalogWDGConfig = {0};
        AnalogWDGConfig.WatchdogMode = ADC_ANALOGWATCHDOG_SINGLE_REG;
        AnalogWDGConfig.HighThreshold = 3722;
        AnalogWDGConfig.LowThreshold = 372;
        AnalogWDGConfig.Channel = ADC_CHANNEL_6;

#ifdef MODIFY_OCP_PROC_WITH_MODELNAME_IDX_3_EURO_SPEC
        HTK_BOOL bModelNameWithEuroSpecOCP = HTK_FALSE;
#endif

        // CCID_Module_Type check
        Charger.CCID_Module_Type = CCID_MODULE_VAC ;
        switch(Charger.memory.EVSE_Config.data.item.ModelName[3])
        {
            case 'E': //CE / European Market
            case 'T': //TR25 / Singapor Market
            case 'Z': //EV ready / French Market


#ifdef MODIFY_OCP_PROC_WITH_MODELNAME_IDX_3_EURO_SPEC
            case 'M': //E + MID Meter
            case 'P': //E + PTB certification
            case 'I': //Z + TIC Meter pcb
            case 'F': //Z + MID Meter
                bModelNameWithEuroSpecOCP = HTK_TRUE;
#endif

                Charger.CCID_Module_Type = CCID_MODULE_VAC ;
                AnalogWDGConfig.ITMode = DISABLE;
//#ifdef MODIFY_OCP_MAGNIFICATION
//                Charger.OCP_Magnification = 125 ;
//#else
                Charger.OCP_Magnification = 115 ;
//#endif
                break;

            case 'U':
                //UL    / North America Market
                Charger.CCID_Module_Type = CCID_MODULE_CORMEX ;
#ifdef MODIFY_AW48_CCID_UL_SPEC_KENNY_20240401
                //set at the other place
//                if (Charger.m_bModelNameAW48_1P)
//                {
//                    Charger.alarm_spec.Current_LEAK_AC = 1700 ; // unit 0.01mA
//                }
//                else
#endif //MODIFY_AW48_CCID_UL_SPEC_KENNY_20240401
                {
                    Charger.alarm_spec.Current_LEAK_AC = 1800 ; // unit 0.01mA
                }
                AnalogWDGConfig.ITMode = ENABLE;
                Charger.OCP_Magnification = 110 ;
                break;

            case 'G':
                //GB    / China Market
                Charger.CCID_Module_Type = CCID_MODULE_CORMEX ;
                Charger.alarm_spec.Current_LEAK_AC = 2500 ; // unit 0.01mA
                AnalogWDGConfig.ITMode = ENABLE;
                Charger.OCP_Magnification = 110 ;
                break;

            case 'C':
#ifdef FUNC_SUPPORT_MODEL_AXYC
                if (Charger.memory.EVSE_Config.data.item.ModelName[2] == 'Y')
                {
                    bModelNameWithEuroSpecOCP = HTK_TRUE;
                    Charger.CCID_Module_Type = CCID_MODULE_VAC ;
                    AnalogWDGConfig.ITMode = DISABLE;
                    Charger.OCP_Magnification = 115 ;
                }
                else
                {
                    Charger.CCID_Module_Type = CCID_MODULE_CORMEX ;
                    Charger.alarm_spec.Current_LEAK_AC = 2500 ; // unit 0.01mA
                    AnalogWDGConfig.ITMode = ENABLE;
                    Charger.OCP_Magnification = 110 ;
                }

#else //FUNC_SUPPORT_MODEL_AXYC

                //CNS   / Taiwan Market
#ifdef FUNC_REPLACE_CORMEX_WITH_VAC_FOR_CNS_MODEL
                Charger.CCID_Module_Type = CCID_MODULE_VAC;
#else
                Charger.CCID_Module_Type = CCID_MODULE_CORMEX ;
#endif
                Charger.alarm_spec.Current_LEAK_AC = 2500 ; // unit 0.01mA
                AnalogWDGConfig.ITMode = ENABLE;
                Charger.OCP_Magnification = 110 ;
#endif //FUNC_SUPPORT_MODEL_AXYC
                break;

            case 'J':
                //JARI  / Japan Market
                Charger.CCID_Module_Type = CCID_MODULE_CORMEX ;
                Charger.alarm_spec.Current_LEAK_AC = 2500 ; // unit 0.01mA
                AnalogWDGConfig.ITMode = ENABLE;
                Charger.OCP_Magnification = 110 ;
                break;

            case 'K':
                //KC    / Korea Market
                Charger.CCID_Module_Type = CCID_MODULE_CORMEX ;
                Charger.alarm_spec.Current_LEAK_AC = 1800 ; // unit 0.01mA
                AnalogWDGConfig.ITMode = ENABLE;
                Charger.OCP_Magnification = 110 ;
                break;

            case 'B':
                //British / UK Market
                Charger.CCID_Module_Type = CCID_MODULE_CORMEX ;
                Charger.alarm_spec.Current_LEAK_AC = 1800 ; // unit 0.01mA
                AnalogWDGConfig.ITMode = ENABLE;
                Charger.OCP_Magnification = 110 ;
                break;

            default:
                Charger.CCID_Module_Type = CCID_MODULE_VAC ;
                AnalogWDGConfig.ITMode = DISABLE;
                Charger.alarm_spec.Current_LEAK_AC = 1800 ; // unit 0.01mA
                Charger.OCP_Magnification = 110 ;
                break;
        }

#ifdef MODIFY_OCP_PROC_WITH_MODELNAME_IDX_3_EURO_SPEC
        Charger.m_bModelNameWithEuroSpecOCP = bModelNameWithEuroSpecOCP;
        XP("#Use EuropeanSpecOCP: %s\r\n", Charger.m_bModelNameWithEuroSpecOCP ? "True" : "False");
#endif

#ifdef FUNC_AUTO_MODIFY_CCID_MODULE
        XP("#Use CCID Module (ModelName: %s): %s\r\n", Charger.memory.EVSE_Config.data.item.ModelName, CCID_MODULE_TYPE_STR);
        if (Charger.m_bCCID_MustModify && Charger.m_CCID_ModuleTestOK != CCID_MODULE_UNKNOW)
        {
            Charger.CCID_Module_Type = Charger.m_CCID_ModuleTestOK;
            XP("#Use CCID Module (AutoModify): %s\r\n", CCID_MODULE_TYPE_STR);
        }

#endif

        //adc2 watchdog config to register
        if (HAL_ADC_AnalogWDGConfig(&hadc2, &AnalogWDGConfig) != HAL_OK)
        {
          Error_Handler();
        }
#ifdef FUNC_AUTO_IGNORE_AC_PHASE
        Charger.m_b3PhaseModel =
            (
                    (Charger.memory.EVSE_Config.data.item.ModelName[2] == 'Y')
                ||  (Charger.memory.EVSE_Config.data.item.ModelName[2] == 'D')
                ||  (Charger.memory.EVSE_Config.data.item.ModelName[2] == 'W')

            ) ? 1 : 0;
        XP("#ThreePhaseModel: %s\r\n", Charger.m_b3PhaseModel ? "True" : "False");


#ifdef FUNC_CHECK_MODELNAME_AX_PRIFIX
        Charger.m_bModelNameAX =
            (
                    (Charger.memory.EVSE_Config.data.item.ModelName[0] == 'A')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[1] == 'X')
            ) ? 1 : 0;
        XP("#ModelNameAX: %s\r\n", Charger.m_bModelNameAX ? "True" : "False");
#endif

#ifdef FUNC_AT32
        Charger.m_bModelNameAT =
            (
                    (Charger.memory.EVSE_Config.data.item.ModelName[0] == 'A')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[1] == 'T')
            ) ? 1 : 0;
        XP("#ModelNameAT: %s\r\n", Charger.m_bModelNameAT ? "True" : "False");

        Charger.m_bModelNameAT32_3P = Charger.m_bModelNameAT &&
            (
                Charger.m_b3PhaseModel
//                &&  (Charger.memory.EVSE_Config.data.item.ModelName[4] == '2')
//                &&  (Charger.memory.EVSE_Config.data.item.ModelName[5] == '2')
//                &&  (Charger.memory.EVSE_Config.data.item.ModelName[6] == '1')
            ) ? 1 : 0;
        XP("#ModelNameAT32_3P: %s\r\n", Charger.m_bModelNameAT32_3P ? "True" : "False");

#endif //FUNC_AT32

#ifdef FUNC_AX80
        //ex: AXLU191001W1P0
        Charger.m_bModelNameAX80_1P = Charger.m_bModelNameAX &&
            (
                !Charger.m_b3PhaseModel
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[4] == '1')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[5] == '9')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[6] == '1')
            ) ? 1 : 0;
        XP("#ModelNameAX80_1P: %s\r\n", Charger.m_bModelNameAX80_1P ? "True" : "False");

        Charger.m_bModelNameAX48_1P = Charger.m_bModelNameAX &&
            (
                !Charger.m_b3PhaseModel
                && !Charger.m_bModelNameAX80_1P
//                &&  (Charger.memory.EVSE_Config.data.item.ModelName[4] == '1')
//                &&  (Charger.memory.EVSE_Config.data.item.ModelName[5] == '1')
//                &&  (Charger.memory.EVSE_Config.data.item.ModelName[6] == '1')
            ) ? 1 : 0;
        XP("#ModelNameAX48_1P: %s\r\n", Charger.m_bModelNameAX48_1P ? "True" : "False");

#ifdef FUNC_AXSJ_USE_NEW_NACS_PCB
        Charger.m_bModelNameAXSJ =
            (
                    (Charger.memory.EVSE_Config.data.item.ModelName[0] == 'A')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[1] == 'X')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[2] == 'S')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'J')
            ) ? 1 : 0;
        XP("#ModelNameAXSJ: %s\r\n", Charger.m_bModelNameAXSJ ? "True" : "False");

        Charger.m_bModelNameAXSJ_AX48_NACS_1P =
            (
                Charger.m_bModelNameAXSJ
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[4] == '9')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[5] == '6')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[6] == '0')
            ) ? 1 : 0;
        XP("#ModelNameAXSJ_AX48_NACS_1P: %s\r\n", Charger.m_bModelNameAXSJ_AX48_NACS_1P ? "True" : "False");

        Charger.m_bModelNameAXSJ_AX80_NACS_1P =
            (
                Charger.m_bModelNameAXSJ
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[4] == 'x')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[5] == 'x')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[6] == 'x')
            ) ? 1 : 0;
        XP("#ModelNameAXSJ_AX80_NACS_1P: %s\r\n", Charger.m_bModelNameAXSJ_AX80_NACS_1P ? "True" : "False");
#endif //FUNC_AXSJ_USE_NEW_NACS_PCB


#ifdef FUNC_AX48_NACS
        Charger.m_bModelNameAX48_NACS_1P = Charger.m_bModelNameAX48_1P
            &&  (Charger.memory.EVSE_Config.data.item.ModelName[7] == '0')
            &&  (Charger.memory.EVSE_Config.data.item.ModelName[8] == '0')
            &&  (Charger.memory.EVSE_Config.data.item.ModelName[9] == '9');
#ifdef FUNC_AXSJ_USE_NEW_NACS_PCB
        Charger.m_bModelNameAX48_NACS_1P |= Charger.m_bModelNameAXSJ_AX48_NACS_1P;
#endif

#ifdef ADD_AX_NACS_PCB_USE_GEN_CODE_3
        Charger.m_bModelNameAX48_NACS_1P |= (Charger.m_bModelNameAX48_1P && Charger.memory.EVSE_Config.data.item.ModelName[11] == '3');
#endif

        XP("#ModelNameAX48_NACS_1P: %s\r\n", Charger.m_bModelNameAX48_NACS_1P ? "True" : "False");

#ifdef FUNC_LIN_EN_SW
        if (Charger.m_bModelNameAX48_NACS_1P)
        {
            LIN_SW(HTK_FALSE); //PWM
        }
#endif //FUNC_LIN_EN_SW

#ifdef FUNC_TMP100
        if (Charger.m_bModelNameAX48_NACS_1P ||
            Charger.m_bModelNameAX80_NACS_1P)
        {
            Charger.m_bUseTMP100 = 1;
        }
        else
        {
            Charger.m_bUseTMP100 = 0;
        }
        XP("#UseTMP100: %s\r\n", Charger.m_bUseTMP100 ? "True" : "False");
#endif


#endif //FUNC_AX48_NACS

#ifdef FUNC_AX80_NACS
        Charger.m_bModelNameAX80_NACS_1P = Charger.m_bModelNameAX80_1P
            &&  (Charger.memory.EVSE_Config.data.item.ModelName[7] == '0')
            &&  (Charger.memory.EVSE_Config.data.item.ModelName[8] == '0')
            &&  (Charger.memory.EVSE_Config.data.item.ModelName[9] == '9');
#ifdef FUNC_AXSJ_USE_NEW_NACS_PCB
        Charger.m_bModelNameAX80_NACS_1P |= Charger.m_bModelNameAXSJ_AX80_NACS_1P;
#endif

#ifdef ADD_AX_NACS_PCB_USE_GEN_CODE_3
        Charger.m_bModelNameAX80_NACS_1P |= (Charger.m_bModelNameAX80_1P && Charger.memory.EVSE_Config.data.item.ModelName[11] == '3');
#endif

        XP("#ModelNameAX80_NACS_1P: %s\r\n", Charger.m_bModelNameAX80_NACS_1P ? "True" : "False");

#ifdef FUNC_LIN_EN_SW
        if (Charger.m_bModelNameAX80_NACS_1P)
        {
            LIN_SW(HTK_FALSE); //PWM
        }
#endif //FUNC_LIN_EN_SW

#endif //FUNC_AX80_NACS

        Charger.m_bModelNameAX32_3P = Charger.m_bModelNameAX &&
            (
                Charger.m_b3PhaseModel
//                &&  (Charger.memory.EVSE_Config.data.item.ModelName[4] == '2')
//                &&  (Charger.memory.EVSE_Config.data.item.ModelName[5] == '2')
//                &&  (Charger.memory.EVSE_Config.data.item.ModelName[6] == '1')
            ) ? 1 : 0;
        XP("#ModelNameAX32_3P: %s\r\n", Charger.m_bModelNameAX32_3P ? "True" : "False");

#ifdef FUNC_AW48
        Charger.m_bModelNameAW48_1P = !Charger.m_bModelNameAX &&
            (
                !Charger.m_b3PhaseModel
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[0] == 'A')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[1] == 'W')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[4] == '1')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[5] == '1')
                &&  (Charger.memory.EVSE_Config.data.item.ModelName[6] == '1')
            ) ? 1 : 0;
        XP("#ModelNameAW48_1P: %s\r\n", Charger.m_bModelNameAW48_1P ? "True" : "False");

#ifdef MODIFY_AW48_CCID_UL_SPEC_KENNY_20240401
        if (Charger.m_bModelNameAW48_1P)
        {
            Charger.alarm_spec.Current_LEAK_AC = 1700 ; // unit 0.01mA
        }
#endif //MODIFY_AW48_CCID_UL_SPEC_KENNY_20240401

#ifdef FUNC_LIN_EN_SW
        if (Charger.m_bModelNameAW48_1P)
        {
            LIN_SW(HTK_FALSE); //PWM
        }
#endif //FUNC_LIN_EN_SW

#ifdef FUNC_AW48_EXT_LED
        if (Charger.m_bModelNameAW48_1P)
        {
            EXTLED_SET_POWER(1);
        }
#endif //FUNC_AW48_EXT_LED
#endif //FUNC_AW48

#ifdef RELAY_COMMON_GPIO
        if (Charger.m_bModelNameAW48_1P)
        {
#ifdef AW48_NEW_PCB_WITH_CORRECT_RELAY_PIN
            Charger.m_RelayMode = 0; //New PCB
#else
            Charger.m_RelayMode = 1;
#endif
        }
        else
        {
            Charger.m_RelayMode = 0;
        }
        XP("#RelayMode: %d\r\n", Charger.m_RelayMode);
#endif

#ifdef FUNC_EKM_OMNIMETER
        Charger.m_bUseExtMeter_OMNIMETER = Charger.m_bModelNameAW48_1P;
        XP("#UseExtMeter_OMNIMETER: %s\r\n", Charger.m_bUseExtMeter_OMNIMETER ? "True" : "False");
#endif

#ifdef FUNC_LIN_CP
        Charger.m_bUseLinCP = Charger.m_bModelNameAW48_1P;
        XP("#UseLinCP: %s\r\n", Charger.m_bUseLinCP ? "True" : "False");
#endif //FUNC_AW48

#endif //FUNC_AX80

#ifdef AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX48_MODELNAME_WITH_CSU
        UpdateFirmwareVersion();
#endif

#ifdef FUNC_NEW_RELAY_MONITOR
        if (Charger.m_b3PhaseModel == 0)
        {
            //AX48 (1P)  LN/LL use same formula
            Charger.alarm_spec.Relay_LL_DriveFault_Slop = 0.003266332;
            Charger.alarm_spec.Relay_LL_DriveFault_Offs = 0.28;

#ifdef MODIFY_AW48_WELDING_THRESHOLD_KENNY_20240418
            if (Charger.m_bModelNameAW48_1P)
            {
                Charger.alarm_spec.Relay_LL_Welding_Slop = 0.001894;
                Charger.alarm_spec.Relay_LL_Welding_Offs = 0.093333333;
            }
            else
#endif //MODIFY_AW48_WELDING_THRESHOLD_KENNY_20240418
            {
                Charger.alarm_spec.Relay_LL_Welding_Slop = 0.00318258;
                Charger.alarm_spec.Relay_LL_Welding_Offs = 0.093333333;
            }
        }
        else
        {
            //AX32 (3P) only LL
            Charger.alarm_spec.Relay_LL_DriveFault_Slop = 0.003661263;
            Charger.alarm_spec.Relay_LL_DriveFault_Offs = 1.340704304;

            Charger.alarm_spec.Relay_LL_Welding_Slop = 0.002794857;
            Charger.alarm_spec.Relay_LL_Welding_Offs = 0.391911683;

        }

#endif //FUNC_NEW_RELAY_MONITOR

#ifdef FUNC_METER_IC_VARIABLE_PARAM

#ifdef FUNC_AX80
        if (Charger.m_bModelNameAX80_1P)
        {
            MeterIC_KI = KI_AX80;
            MeterIC_KP = KP_AX80;
            MeterIC_KE = KE_AX80;

        }
        else if (Charger.m_bModelNameAX48_1P)
        {
            MeterIC_KI = KI_AX48;
            MeterIC_KP = KP_AX48;
            MeterIC_KE = KE_AX48;
        }
        else if (Charger.m_bModelNameAX32_3P)
        {
            MeterIC_KI = KI_AX32;
            MeterIC_KP = KP_AX32;
            MeterIC_KE = KE_AX32;
        }
#ifdef FUNC_AT32
        else if (Charger.m_bModelNameAT32_3P)
        {
            MeterIC_KI = KI_AT32;
            MeterIC_KP = KP_AT32;
            MeterIC_KE = KE_AT32;
        }
#endif
#ifdef FUNC_AW48
        else if (Charger.m_bModelNameAW48_1P)
        {
            MeterIC_KI = KI_AW48;
            MeterIC_KP = KP_AW48;
            MeterIC_KE = KE_AW48;
        }
#endif
        else
        {
            MeterIC_KI = KI_AX48;
            MeterIC_KP = KP_AX48;
            MeterIC_KE = KE_AX48;
        }
        XP("#MeterIC KI = %.10f, KP = %.10f, KE = %.10f\r\n", MeterIC_KI, MeterIC_KP, MeterIC_KE);
#else //FUNC_AX80
        if (Charger.m_b3PhaseModel == 0)
        {
            MeterIC_KI = KI_AX48;
            MeterIC_KP = KP_AX48;
            MeterIC_KE = KE_AX48;
        }
        else
        {
            MeterIC_KI = KI_AX32;
            MeterIC_KP = KP_AX32;
            MeterIC_KE = KE_AX32;
        }

#endif //FUNC_AX80

#endif //FUNC_METER_IC_VARIABLE_PARAM

#ifdef MODIFY_OTP_SPEC

#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
        if (Charger.m_bModelNameAX80_1P)
        {
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
            if (Charger.m_bModelNameAX80_NACS_1P)
            {
                Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AX80_NACS;
                Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AX80_NACS;
                Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AX80_NACS;

                Charger.alarm_spec.OT_G2_1 = ALARM_SPEC_OT_G2_1_AX80_NACS;
                Charger.alarm_spec.OT_G2_2 = ALARM_SPEC_OT_G2_2_AX80_NACS;
                Charger.alarm_spec.OT_G2_HYSTERESIS = ALARM_SPEC_OT_G2_HYSTERESIS_AX80_NACS;

#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
                Charger.alarm_spec.OT_G3_1 = ALARM_SPEC_OT_G3_1_AX80_NACS;
                Charger.alarm_spec.OT_G3_2 = ALARM_SPEC_OT_G3_2_AX80_NACS;
                Charger.alarm_spec.OT_G3_HYSTERESIS = ALARM_SPEC_OT_G3_HYSTERESIS_AX80_NACS;

                Charger.alarm_spec.OT_G4_1 = ALARM_SPEC_OT_G4_1_AX80_NACS;
                Charger.alarm_spec.OT_G4_2 = ALARM_SPEC_OT_G4_2_AX80_NACS;
                Charger.alarm_spec.OT_G4_HYSTERESIS = ALARM_SPEC_OT_G4_HYSTERESIS_AX80_NACS;
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK

            }
            else
            {
                Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AX80;
                Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AX80;
                Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AX80;

                Charger.alarm_spec.OT_G2_1 = ALARM_SPEC_OT_G2_1_AX80;
                Charger.alarm_spec.OT_G2_2 = ALARM_SPEC_OT_G2_2_AX80;
                Charger.alarm_spec.OT_G2_HYSTERESIS = ALARM_SPEC_OT_G2_HYSTERESIS_AX80;
            }
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
            Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AX80;
            Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AX80;
            Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AX80;

            Charger.alarm_spec.OT_G2_1 = ALARM_SPEC_OT_G2_1_AX80;
            Charger.alarm_spec.OT_G2_2 = ALARM_SPEC_OT_G2_2_AX80;
            Charger.alarm_spec.OT_G2_HYSTERESIS = ALARM_SPEC_OT_G2_HYSTERESIS_AX80;
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
        }
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
        else if (Charger.m_bModelNameAW48_1P)
        {
            Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AW48;
            Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AW48;
            Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AW48;

            Charger.alarm_spec.OT_G2_1 = ALARM_SPEC_OT_G2_1_AW48;
            Charger.alarm_spec.OT_G2_2 = ALARM_SPEC_OT_G2_2_AW48;
            Charger.alarm_spec.OT_G2_HYSTERESIS = ALARM_SPEC_OT_G2_HYSTERESIS_AW48;

#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
            Charger.alarm_spec.OT_G3_1 = ALARM_SPEC_OT_G3_1_AW48;
            Charger.alarm_spec.OT_G3_2 = ALARM_SPEC_OT_G3_2_AW48;
            Charger.alarm_spec.OT_G3_HYSTERESIS = ALARM_SPEC_OT_G3_HYSTERESIS_AW48;
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN

#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
            Charger.alarm_spec.OT_G4_1 = ALARM_SPEC_OT_G4_1_AW48;
            Charger.alarm_spec.OT_G4_2 = ALARM_SPEC_OT_G4_2_AW48;
            Charger.alarm_spec.OT_G4_HYSTERESIS = ALARM_SPEC_OT_G4_HYSTERESIS_AW48;
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
        }
#endif

#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
        else if (Charger.m_bModelNameAX48_NACS_1P)
        {
            Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AX48_NACS;
            Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AX48_NACS;
            Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AX48_NACS;

            Charger.alarm_spec.OT_G2_1 = ALARM_SPEC_OT_G2_1_AX48_NACS;
            Charger.alarm_spec.OT_G2_2 = ALARM_SPEC_OT_G2_2_AX48_NACS;
            Charger.alarm_spec.OT_G2_HYSTERESIS = ALARM_SPEC_OT_G2_HYSTERESIS_AX48_NACS;

#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
            Charger.alarm_spec.OT_G3_1 = ALARM_SPEC_OT_G3_1_AX48_NACS;
            Charger.alarm_spec.OT_G3_2 = ALARM_SPEC_OT_G3_2_AX48_NACS;
            Charger.alarm_spec.OT_G3_HYSTERESIS = ALARM_SPEC_OT_G3_HYSTERESIS_AX48_NACS;
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN

#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
            Charger.alarm_spec.OT_G4_1 = ALARM_SPEC_OT_G4_1_AX48_NACS;
            Charger.alarm_spec.OT_G4_2 = ALARM_SPEC_OT_G4_2_AX48_NACS;
            Charger.alarm_spec.OT_G4_HYSTERESIS = ALARM_SPEC_OT_G4_HYSTERESIS_AX48_NACS;
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN

        }
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
        else if (Charger.m_bModelNameAX48_1P)
        {
            Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AX48;
            Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AX48;
            Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AX48;
        }
        else if (Charger.m_bModelNameAX32_3P)
        {
            Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AX32;
            Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AX32;
            Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AX32;
        }
#ifdef FUNC_AT32
        else if (Charger.m_bModelNameAT32_3P)
        {
            Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AT32;
            Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AT32;
            Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AT32;
        }
#endif
        else
        {
            Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AX48;
            Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AX48;
            Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AX48;
        }
#else //FUNC_AX80_ADD_4_TEMP_SENEOR
        if (Charger.m_b3PhaseModel == 0)
        {
            Charger.alarm_spec.OT_1 = ALARM_SPEC_OT_1_AX48;
            Charger.alarm_spec.OT_2 = ALARM_SPEC_OT_2_AX48;
            Charger.alarm_spec.OT_HYSTERESIS = ALARM_SPEC_OT_HYSTERESIS_AX48;
        }
        else
        {
            Charger.alarm_spec.OT_1 = ALARM_SPEC_OT_1_AX32;
            Charger.alarm_spec.OT_2 = ALARM_SPEC_OT_2_AX32;
            Charger.alarm_spec.OT_HYSTERESIS = ALARM_SPEC_OT_HYSTERESIS_AX32;
        }
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR

#endif //MODIFY_OTP_SPEC



#endif //FUNC_AUTO_IGNORE_AC_PHASE

#ifdef FUNC_AUTO_USE_EXT_METER

#ifdef FUNC_FORCE_USE_METER_EXT_PRO380
        Charger.m_bUseExtMeter_PRO380 = 1;
        XP("#UseExtMeter: FORCE Enable\r\n");
#else
        Charger.m_bUseExtMeter_PRO380 =
            (
                    (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'M')
#ifndef FUNC_PTB_METER_WM3M4C
                ||  (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'P')
#endif
                ||  (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'I')
                ||  (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'F')
                ||  (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'L')
#ifdef TEST_METER_PRO380_AND_WM3M4C_AT_THE_SAME_TIME_USE_MODELNAME_IDX_3_X
                ||  (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'x')
#endif

            ) ? 1 : 0;
        XP("#UseExtMeter_PRO380: %s\r\n", Charger.m_bUseExtMeter_PRO380 ? "Enable" : "Disable");
#endif //FUNC_FORCE_USE_METER_EXT_PRO380

#ifdef FUNC_PTB_METER_WM3M4C
        Charger.m_bUseExtMeter_WM3M4C =
            (
                Charger.memory.EVSE_Config.data.item.ModelName[3] == 'P'
#ifdef TEST_METER_PRO380_AND_WM3M4C_AT_THE_SAME_TIME_USE_MODELNAME_IDX_3_X
                ||  (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'x')
#endif
            ) ? 1 : 0;
        XP("#UseExtMeter_WM3M4C: %s\r\n", Charger.m_bUseExtMeter_WM3M4C ? "Enable" : "Disable");
#endif //FUNC_PTB_METER_WM3M4C

#ifdef FUNC_ADD_TILT_SENSOR_MODEL
        {
            Charger.m_bUseTiltSensor =
                (
                        Charger.m_bModelNameAX80_1P
                    ||  Charger.m_bModelNameAX48_NACS_1P
#ifdef FUNC_AX80_NACS
                    ||  Charger.m_bModelNameAX80_NACS_1P
#endif
#ifdef FUNC_AW48
					||  Charger.m_bModelNameAW48_1P
#endif

                ) ? 1 : 0;
            XP("#UseTiltSensor: %s\r\n", Charger.m_bUseTiltSensor ? "Enable" : "Disable");
        }
#endif //FUNC_ADD_TILT_SENSOR_MODEL

#endif //FUNC_AUTO_USE_EXT_METER

#ifdef FUNC_RS485_SLAVE
        Charger.m_bRS485SlaveForDCModel =
        (
            (Charger.memory.EVSE_Config.data.item.ModelName[0] == 'D') //response to DC Model
        ) ? 1 : 0;

        Charger.m_RS485SlaveAddr = (Charger.m_bRS485SlaveForDCModel ? PROTOCOL_ADDR_AC_MAINBOARD : PROTOCOL_ADDR);
#endif

#ifdef FUNC_FORCE_RUN_CSU_MODE_WITH_DC_MODELNAME
        Charger.m_bModelNameDC =
        (
            (Charger.memory.EVSE_Config.data.item.ModelName[0] == 'D') //response to DC Model
        ) ? 1 : 0;
        Charger.m_bModelNameDCReadOK = 1;
        XP("#ModelNameDC: %s\r\n", Charger.m_bModelNameDC ? "True" : "False");
        Update_McuCtrlMode();
#endif

#ifdef FUNC_CSU_SIGN_IN_VERIFY
        Charger.m_bCsuSignInMustVerify = (Charger.m_bModelNameAW48_1P && (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_CSU));
        XP("#CsuSignInMustVerify: %s\r\n", Charger.m_bCsuSignInMustVerify ? "True" : "False");
#endif

#ifdef FUNC_CSU_UPGRADE_FW_VERIFY
        Charger.m_bCsuUpgradeFwMustVerify = (Charger.m_bModelNameAW48_1P && (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_CSU));
        XP("#CsuUpgradeFwMustVerify: %s\r\n", Charger.m_bCsuUpgradeFwMustVerify ? "True" : "False");
#endif

#ifdef FUNC_DETECT_PP
        {
            HTK_BOOL bDetectPP = HTK_FALSE;
            for (uint8_t i = 7; i <= 9; i++)
            {
                bDetectPP |=
                    (
                            Charger.memory.EVSE_Config.data.item.ModelName[i] == '2' //IEC 62196-2 Type 1 / SAE J1772 Socket
                        ||  Charger.memory.EVSE_Config.data.item.ModelName[i] == '4' //IEC 62196-2 Type 2 Socket
                        ||  Charger.memory.EVSE_Config.data.item.ModelName[i] == '6' //GB/T AC Socket
                    ) ? HTK_TRUE : HTK_FALSE;

            }
            Charger.m_bDetectPP = bDetectPP;
            XP("#DetectPP: %s\r\n", Charger.m_bDetectPP ? "Enable" : "Disable");
        }
#endif //FUNC_DETECT_PP

#ifdef FUNC_DETECT_PP_NACS
        {
            HTK_BOOL bDetectPP_NACS = HTK_FALSE;
#ifdef FUNC_AX80_NACS
            bDetectPP_NACS = Charger.m_bModelNameAX48_NACS_1P || Charger.m_bModelNameAX80_NACS_1P;
#else
            bDetectPP_NACS = Charger.m_bModelNameAX48_NACS_1P;
#endif
            Charger.m_bDetectPP_NACS = bDetectPP_NACS;
            XP("#DetectPP_NACS: %s\r\n", Charger.m_bDetectPP_NACS ? "Enable" : "Disable");
        }
#endif //FUNC_DETECT_PP_NACS

#ifdef FUNC_GUN_LOCK
        {
            HTK_BOOL bUseGunLock = HTK_FALSE;
            for (uint8_t i = 7; i <= 9; i++)
            {
                bUseGunLock |=
                    (
                            Charger.memory.EVSE_Config.data.item.ModelName[i] == '2' //IEC 62196-2 Type 1 / SAE J1772 Socket
                        ||  Charger.memory.EVSE_Config.data.item.ModelName[i] == '4' //IEC 62196-2 Type 2 Socket
                        ||  Charger.memory.EVSE_Config.data.item.ModelName[i] == '6' //GB/T AC Socket
                    ) ? HTK_TRUE : HTK_FALSE;

            }

            Charger.m_bUseGunLock = bUseGunLock;
            XP("#UseGunLock: %s\r\n", Charger.m_bUseGunLock ? "Enable" : "Disable");
#ifdef FUNC_GUN_LOCK_TRIG_MODE
            if (IS_CSU_MOUNTED) //CSU Mounted
            {
                Charger.m_GunLockTrigMode = GL_TRIG_MODE_REQUEST;
                Charger.m_GunLockRequestMode_LockDelayTick = 0;
            }
            else //No CSU Mounted or DC Model
            {
                Charger.m_GunLockTrigMode = GL_TRIG_MODE_RELAY;
            }
            XP("#GunLockTrigMode: %d\r\n", (int)Charger.m_GunLockTrigMode);
#endif

        }
#endif //FUNC_GUN_LOCK


#ifdef FUNC_USE_RELAY_B_CONTACT
        {
            HTK_BOOL bUseRelayBContact = HTK_FALSE;
            bUseRelayBContact = Charger.m_b3PhaseModel;

////#ifdef DISABLE_USE_RELAY_B_CONTACT_WITH_DC_MODELNAME
////            if (Charger.m_bModelNameDC)
////                bUseRelayBContact = HTK_FALSE;
////#endif

#ifdef DISABLE_USE_RELAY_B_CONTACT_WITH_AX32_OLD_PCB
            bUseRelayBContact = HTK_FALSE;
#endif
            Charger.m_bUseRelayBContact = bUseRelayBContact;
            XP("#UseRelayBContact: %s\r\n", Charger.m_bUseRelayBContact ? "True" : "False");

        }
#endif //FUNC_USE_RELAY_B_CONTACT

#ifdef FUNC_OUTP_TYPE_E
        {
//#ifdef FUNC_USE_MODELNAME_TO_JUDGE_TYPEE_ENABLE
//            HTK_BOOL bEnableTypeE = HTK_FALSE;
//            for (uint8_t i = 7; i <= 9; i++)
//            {
//                bEnableTypeE |=
//                    (
//                            Charger.memory.EVSE_Config.data.item.ModelName[i] == '8' //Type E Socket
//                    ) ? HTK_TRUE : HTK_FALSE;
//
//            }
//            Charger.m_bEnableTypeE = bEnableTypeE;
//#else
#ifdef FUNC_ENABLE_TYPE_E_ONLY_IN_AX32
            Charger.m_bEnableTypeE = Charger.m_b3PhaseModel;
#else
            Charger.m_bEnableTypeE = HTK_TRUE;
#endif
//#endif //FUNC_USE_MODELNAME_TO_JUDGE_TYPEE_ENABLE

            XP("#TypeE: %s\r\n", Charger.m_bEnableTypeE ? "Enable" : "Disable");
        }
#endif //FUNC_OUTP_TYPE_E

#ifdef FUNC_CP_ADC_MODIFY
#ifdef NEW_CP_SPEC
        CpDetectModuleInitialize(Charger.memory.EVSE_Config.data.item.ModelName[3]);
        Charger.m_bCpDetectModuleInitOK = 1;
#endif //NEW_CP_SPEC
#endif //FUNC_CP_ADC_MODIFY

#ifdef FUNC_RULE_GB_202108
        Charger.m_bSafetyRegulationGB = (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'G');
#endif

#ifdef FUNC_UPDATE_ROTARY_SWITCH_SETTING_AFTER_PARSE_MODELNAME
        getRotarySwitchSetting();
#endif
}

void HTK_ByteArray2HexStr(const u8* buf, const u16 BegIdx, const u16 len, char* OutStr, u16 nMaxBytesPerLine, HTK_BOOL bSpace)
{
	char sTmp[8] = { 0 };
	strcpy(OutStr, "\0");
	for (u16 i = BegIdx; i < (BegIdx + len); i++)
	{
		sprintf(sTmp, bSpace ? "%02X " : "%02X", buf[i]);
		strcat(OutStr, sTmp);
		if ((i - BegIdx) % nMaxBytesPerLine == (nMaxBytesPerLine - 1))
        {
			strcat(OutStr, "\r\n");
        }
	}
}


void HTK_ByteArray2HexStr_XP(const char* Title, const u8* buf, const u16 BegIdx, const u16 len)
{
    static char OutStr[1024 * 3 + 8] = { 0 };
    HTK_ByteArray2HexStr(buf, BegIdx, len, OutStr, 0, HTK_TRUE);
    XP("[%s] %s(%d)\r\n", (Title == NULL ? "" : Title), OutStr, len);
}


void HTK_ByteArray2HexStr_XT(const char* Title, const u8* buf, const u16 BegIdx, const u16 len)
{
    static char OutStr[1024 * 3 + 8] = { 0 };
    HTK_ByteArray2HexStr(buf, BegIdx, len, OutStr, 0, HTK_TRUE);
    XT("[%s] %s(%d)\r\n", (Title == NULL ? "" : Title), OutStr, len);
}

#ifdef ENABLE_PRINT_IMCP_MSG
int CheckPrintImcpMsg(uint8_t MsgID)
{
#ifdef ENABLE_PRINT_IMCP_SPEC_MSG
    return
        (
//                MsgID == PROTOCOL_MESSAGE_CONFIG_PARAMETER
//            ||  MsgID == PROTOCOL_MESSAGE_QUERY_METER_IC_MEAS_PARAMETER
//            ||  MsgID == PROTOCOL_MESSAGE_QUERY_METER_IC_CALI_PARAMETER
//            ||  MsgID == PROTOCOL_MESSAGE_CONFIG_METER_IC_CALI_PARAMETER
                MsgID == PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT
            ||  MsgID == PROTOCOL_MESSAGE_CONFIG_MAX_CURRENT_PWM_DUTY
            ||  MsgID == PROTOCOL_MESSAGE_CONFIG_LEGACY_REQUEST

        );
#else
    return true;
#endif //ENABLE_PRINT_IMCP_SPEC_MSG
}
#endif //ENABLE_PRINT_IMCP_MSG

#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
void ColdLoadPickup_Delay(const char* Description)
{
    //osDelay((rand()%175000)+5000);
    int r = rand();
    if (r < 0)
    {
        r = (-1) * r;
    }
    //uint32_t dt = (r % 175000) + 5000; //ms
    uint32_t dt = (r % (COLD_LOAD_PICKUP_DELAY_TIME_MAX_RANGE_SEC * 1000)) + 5000; //ms
    XP("ColdLoadPickup_Delay(ms) [%s]: %d\r\n", Description, dt);
    osDelay(dt);
}
#endif

#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
uint16_t GetCpPwmDuty(uint16_t Curr)
{
#ifdef FUNC_AX80
    if (Curr > Charger.maxRatingCurrent)
    {
        Curr = Charger.maxRatingCurrent;
    }
#endif

#ifdef FUNC_DETECT_PP
    if (Charger.m_bDetectPP)
    {
        PPPInfo p = &Charger.m_PPInfo;

        if (Curr > p->m_CurCurr)
            Curr = p->m_CurCurr;

        if (p->m_PreCurr != p->m_CurCurr)
            p->m_PreCurr = p->m_CurCurr;
    }
#endif

#ifdef FUNC_AX80
    uint16_t rtn = 0;
    if (Curr >= 6 && Curr <= 51)
    {
        rtn = (uint16_t)((Curr / 0.6) * 10);
    }
    else if (Curr > 51 && Curr <= 80)
    {
        rtn = (uint16_t)((Curr / 2.5 + 64) * 10);
    }
#else
    uint16_t rtn = (uint16_t)((Curr / 0.6) * 10);
#endif
    XP("#GetCpPwmDuty(%d) => %d\r\n", Curr, rtn);
    return rtn;
}
#endif

#ifdef HTK
u8 GetBit1Num(u32 x)
{
    u8 Num = 0;
    while (x)
    {
        Num++;
        x &= (x - 1);
    }
    return Num;
}

HTK_BOOL HTK_IsInTime(u32 BegTick, u32 MaxTick)
{
    u32 EndTick = HAL_GetTick();
    u32 ElapseTick = (EndTick >= BegTick ? EndTick - BegTick : HTK_U32_MAX - BegTick + EndTick);
    return ElapseTick <= MaxTick ? HTK_TRUE : HTK_FALSE;
}

HTK_BOOL HTK_IsTimeout(u32 BegTick, u32 MaxTick)
{
    u32 EndTick = HAL_GetTick();
    u32 ElapseTick = (EndTick >= BegTick ? EndTick - BegTick : HTK_U32_MAX - BegTick + EndTick);
    return ElapseTick > MaxTick ? HTK_TRUE : HTK_FALSE;
}

void HTK_Timer_Reset(PHTK_Timer p)
{
    //XP("#<Timer reset>\r\n\r\n");
    p->m_bStart = HTK_FALSE;
    p->m_bTimeout = HTK_FALSE;
    p->m_BegTick = 0;
    p->m_MaxTick = 0;
}

void HTK_Timer_Start(PHTK_Timer p, u32 MaxTick)
{
    //XP("#<Timer start>\r\n\r\n");
    p->m_bStart = HTK_TRUE;
    p->m_BegTick = HAL_GetTick();
    p->m_MaxTick = MaxTick;
}

HTK_BOOL HTK_Timer_CheckTimeout(PHTK_Timer p)
{
//    return HTK_IsTimeout(p->m_BegTick, p->m_MaxTick);
    HTK_BOOL rtn = HTK_IsTimeout(p->m_BegTick, p->m_MaxTick);
    if (rtn == HTK_TRUE)
    {
        //XP("#<Timer timeout>\r\n\r\n");
        p->m_bTimeout = HTK_TRUE;
    }
    return rtn;

}

uint8_t HTK_CheckSum_Calulate(uint8_t* pBeg, uint32_t len)
{
    if (pBeg != NULL)
    {
        uint8_t CheckSum = 0;
        for (uint32_t i = 0; i < len; i++)
        {
            CheckSum ^= *(pBeg + i);
        }
        return CheckSum;
    }
    else
    {
        return 0;
    }
}

HTK_BOOL HTK_CheckSum_Update(uint8_t* pBeg, uint32_t len, uint8_t* pCheckSum)
{
    if (pBeg != NULL && pCheckSum != NULL)
    {
        uint8_t CheckSum = HTK_CheckSum_Calulate(pBeg, len);
        *pCheckSum = CheckSum;
        return HTK_TRUE;
    }
    else
    {
        return HTK_FALSE;
    }

}

HTK_BOOL HTK_CheckSum_IsOK(uint8_t* pBeg, uint32_t len, uint8_t* pCheckSum)
{
    if (pBeg != NULL && pCheckSum != NULL)
    {
        uint8_t CheckSum = HTK_CheckSum_Calulate(pBeg, len);
        return (*pCheckSum == CheckSum) ? HTK_TRUE : HTK_FALSE;
    }
    else
    {
        return HTK_FALSE;
    }
}

HTK_BOOL HTK_HexStrToByteArray(byte* Dst, int DstLen, const char* Src, int SrcLen)
{
    if (DstLen * 2 + 1 != SrcLen)
        return HTK_FALSE;

    char buf[3] = { 0 };
    for (int i = 0; i < DstLen; i++)
    {
        memcpy(buf, &Src[i * 2], 2);
        Dst[i] = strtol(buf, NULL, 16);
    }
    return HTK_TRUE;
}

void HTK_FillChar(char* buf, char c, int count)
{
    if (buf != NULL)
    {
        memset(buf, c, count);
        buf[count] = '\0';
    }
}

void HTK_PrintRow(char c, int count)
{
    enum { MAX = 80 };
    static char s_row[MAX + 1] = { 0 };
    static int s_count = 0;
    if (count > MAX)
    {
        count = MAX;
    }
    if (c != s_row[0] || count != s_count)
    {
        HTK_FillChar(s_row, c, count);
    }
    s_count = count;
    XP("%s\r\n", s_row);
    return;
}

static HTK_MallocHandle s_MallocHandle;

void HTK_Malloc_Init(void)
{
    memset(&s_MallocHandle, 0, sizeof(s_MallocHandle));
    //XP("HTK_Malloc_Init(): %d\r\n", HTK_Malloc_BlockTest(1024));
    //XP("HTK_Malloc_Init(): %d\r\n", HTK_Malloc_BlockTest(8000));
    XP("HTK_Malloc_Init(): %d\r\n", HTK_Malloc_BlockTest(512));
}

void* HTK_Malloc(s32 size)
{
    void* p = malloc(size);
    if (p != NULL)
    {
        s_MallocHandle.m_Allocated += size;
        s_MallocHandle.m_Reserved -= size;
        memset(p, 0, size);
    }
    XP("HTK_Malloc(%d) %s\r\n", size, (p == NULL) ? "*** [NG] ***" : "OK");
    return p;
}

void HTK_Free(void* p)
{
    if (p != NULL)
    {
        free(p);
        p = NULL;
        XP("HTK_Free: OK\r\n");
    }
}

s32 HTK_Malloc_BlockTest(s32 size)
{
    int Total = 0;
    for (int i = 1;  ; i++)
    {
        void* p = HTK_Malloc(size);
        if (p == NULL)
        {
            break;
        }
        else
        {
            Total += size;
        }

    }
    s_MallocHandle.m_Total = Total;
    s_MallocHandle.m_Allocated = 0;
    s_MallocHandle.m_Reserved = Total;

    return Total;
}

#ifdef FUNC_SALT_AND_BLEND

int Salt(u8* Mixture, int MixtureLen, u8* SaltMap, int SaltMapLen, u8* Data, int DataLen, u8 bRestore)
{
    int SaltMapLenMin = GET_BOX_NUM(MixtureLen, 8);

    if (Mixture == NULL || SaltMap == NULL || Data == NULL || DataLen > MixtureLen || SaltMapLen < SaltMapLenMin)
        return FAIL;

    int SaltUsed = 0;   //0 ~ (MixtureLen - DataLen)
    int i = 0;          //0 ~ (MixtureLen - 1)
    int j = 0;          //0 ~ (DataLen - 1)

    if (bRestore)
    {
        memset(Data, 0, DataLen);

        for (; i < MixtureLen; i++)
        {
            if (BIT_GET(SaltMap[i / 8], i % 8) == 0)
            {
                Data[j++] = Mixture[i];
                if (j == DataLen)
                {
                    return PASS;
                }
            }
        }
    }
    else
    {
        memset(Mixture, 0, MixtureLen);
        memset(SaltMap, 0, SaltMapLen);

        for (; i < MixtureLen; i++)
        {
            if (rand() % 2 == 0) //insert Data
            {
                if (j < DataLen)
                {
                    Mixture[i] = Data[j++];
                }
                else
                {
                    Mixture[i] = rand() % 0x100;
                    BIT_SET(SaltMap[i / 8], i % 8);
                }

            }
            else //insert Salt
            {
                if (SaltUsed < (MixtureLen - DataLen))
                {
                    Mixture[i] = rand() % 0x100;
                    BIT_SET(SaltMap[i / 8], i % 8);
                    SaltUsed++;
                }
                else
                {
                    Mixture[i] = Data[j++];
                }
            }
        }
    }
    return PASS;
}

int Blend(u8* Dst, u8* Src, int Len, u8 ShiftType, u8 bRestore)
{
    if (Dst == NULL || Src == NULL || Len == 0)
        return FAIL;

    int n = 0;

    if (ShiftType == 1) //u8
    {
        for (int i = 0; i < Len; i++)
        {
            u8 x = Src[i];
            n = ((GetBit1Num(x) + i + 3) % 7 + 1) * (bRestore ? (-1) : (1));
            Dst[i] = LOOP_SHIFT_U8(x, n);
        }

    }
//    else if (ShiftType == 2) //u16
//    {
//        for (int i = 0; i < (Len / ShiftType); i += ShiftType)
//        {
//            u16 x = HTK_U16(Src[i]);
//            n = ((GetBit1Num(x) + i + 5) % 15 + 1) * (bRestore ? (-1) : (1));
//            HTK_U16(Dst[i]) = LOOP_SHIFT_U16(x, n);
//        }
//
//    }
//    else if (ShiftType == 4) //u32
//    {
//        for (int i = 0; i < (Len / ShiftType); i += ShiftType)
//        {
//            u32 x = HTK_U32(Src[i]);
//            n = ((GetBit1Num(x) + i + 7) % 31 + 1) * (bRestore ? (-1) : (1));
//            HTK_U32(Dst[i]) = LOOP_SHIFT_U32(x, n);
//        }
//    }
    else
    {
        return FAIL;
    }
    return PASS;
}


int DataEncryption(u8* Data, int DataLen, u8* EncryptedData, int EncryptedDataLen, u8 bDecryption)
{
    enum
    {
        DATA_LEN = 64,
        SALT_LEN = 64,
        MIXTURE_LEN = DATA_LEN + SALT_LEN,
        SALTMAP_LEN = GET_BOX_NUM(MIXTURE_LEN, 8),
        ALL_LEN = MIXTURE_LEN + SALTMAP_LEN,
    };

    if (DataLen != DATA_LEN || EncryptedDataLen != ALL_LEN)
        return FAIL;

    u8* p = EncryptedData;

    if (bDecryption)
    {
#ifdef FUNC_SALT_AND_BLEND_DEBUG
        XP("<Decryption>----------------------------\r\n");
        HTK_ByteArray2HexStr_XP("EncryptedData", p, 0, ALL_LEN);
#endif
//        if (Blend(p, p, ALL_LEN, 4, 1) == FAIL)
//            return FAIL;
//#ifdef FUNC_SALT_AND_BLEND_DEBUG
//        HTK_ByteArray2HexStr_XP("Blend-Rest-4B", p, 0, ALL_LEN);
//#endif
//
//        if (Blend(p, p, ALL_LEN, 2, 1) == FAIL)
//            return FAIL;
//#ifdef FUNC_SALT_AND_BLEND_DEBUG
//        HTK_ByteArray2HexStr_XP("Blend-Rest-2B", p, 0, ALL_LEN);
//#endif

        if (Blend(p, p, ALL_LEN, 1, 1) == FAIL)
            return FAIL;
#ifdef FUNC_SALT_AND_BLEND_DEBUG
        HTK_ByteArray2HexStr_XP("Blend-Rest-1B", p, 0, ALL_LEN);
#endif

        if (Salt(p, MIXTURE_LEN, p + MIXTURE_LEN, SALTMAP_LEN, Data, DataLen, 1) == FAIL)
            return FAIL;
#ifdef FUNC_SALT_AND_BLEND_DEBUG
        HTK_ByteArray2HexStr_XP("Salt-Restore ", Data, 0, DATA_LEN);
#endif
    }
    else
    {
#ifdef FUNC_SALT_AND_BLEND_DEBUG
        XP("<Encryption>----------------------------\r\n");
        HTK_ByteArray2HexStr_XP("RAW Data     ", Data, 0, DataLen);
#endif
        if (Salt(p, MIXTURE_LEN, p + MIXTURE_LEN, SALTMAP_LEN, Data, DataLen, 0) == FAIL)
            return FAIL;
#ifdef FUNC_SALT_AND_BLEND_DEBUG
        HTK_ByteArray2HexStr_XP("Salt         ", p, 0, ALL_LEN);
#endif

        if (Blend(p, p, ALL_LEN, 1, 0) == FAIL)
            return FAIL;
#ifdef FUNC_SALT_AND_BLEND_DEBUG
        HTK_ByteArray2HexStr_XP("Blend-1B     ", p, 0, ALL_LEN);
#endif

//        if (Blend(p, p, ALL_LEN, 2, 0) == FAIL)
//            return FAIL;
//#ifdef FUNC_SALT_AND_BLEND_DEBUG
//        HTK_ByteArray2HexStr_XP("Blend-2B     ", p, 0, ALL_LEN);
//#endif
//
//        if (Blend(p, p, ALL_LEN, 4, 0) == FAIL)
//            return FAIL;
//#ifdef FUNC_SALT_AND_BLEND_DEBUG
//        HTK_ByteArray2HexStr_XP("Blend-4B     ", p, 0, ALL_LEN);
//#endif
    }
    return PASS;
}

#endif //FUNC_SALT_AND_BLEND

#endif //HTK

#ifdef FUNC_OUTP_TYPE_E
HTK_BOOL IsTypeEPlugIn(void)
{
    return HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin) ? HTK_FALSE : HTK_TRUE;
}
#endif

#ifdef MODIFY_CPTASK_HEAD
void Proc_CpTaskHead(HTK_BOOL bCSU)
{
    if(Charger.Alarm_Code > 0)  // alarm occur
    {
        if(Charger.Mode != MODE_ALARM)
        {
#ifdef FUNC_BLOCK_CSU_CMD_SET_DUTY_WHEN_ALARM_CP_F_STATE
            Charger.m_bBlockCsuCpPwmDutyWhenAlarmCpF = HTK_TRUE;
#endif
            HAL_GPIO_WritePin(OUT_StateE_GPIO_Port, OUT_StateE_Pin, GPIO_PIN_SET);
            setChargerMode(MODE_ALARM);
            user_pwm_setvalue(PWM_CH_CP, 0);
            timerEnable(TIMER_IDX_STATE_E, 4000);
            Charger.isAlarmSetPWM = OFF ;

        }

        // CP E or F to X1
        if(timer[TIMER_IDX_STATE_E].isAlarm == ON)
        {
            HAL_GPIO_WritePin(OUT_StateE_GPIO_Port, OUT_StateE_Pin, GPIO_PIN_RESET);
            if ( Charger.isAlarmSetPWM == OFF )
            {
                Charger.isAlarmSetPWM = ON ;
                user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
            }
#ifdef FUNC_BLOCK_CSU_CMD_SET_DUTY_WHEN_ALARM_CP_F_STATE
            if (Charger.m_bBlockCsuCpPwmDutyWhenAlarmCpF)
            {
                Charger.m_bBlockCsuCpPwmDutyWhenAlarmCpF = HTK_FALSE;
            }
#endif
        }
    }
    else
    {
        if(Charger.Mode != MODE_ALARM)
        {
            if (!bCSU)
            {
                HAL_GPIO_WritePin(OUT_StateE_GPIO_Port, OUT_StateE_Pin, GPIO_PIN_RESET); //CCS communication, so skip this line
            }
            timerDisable(TIMER_IDX_STATE_E);
        }

#ifdef FIX_OUTP_PWM_WHEN_ALARM_RECOVER_IN_4SEC
#ifdef FUNC_BLOCK_CSU_CMD_SET_DUTY_WHEN_ALARM_CP_F_STATE
        if (Charger.m_bBlockCsuCpPwmDutyWhenAlarmCpF)
        {
            Charger.m_bBlockCsuCpPwmDutyWhenAlarmCpF = HTK_FALSE;
        }
#endif
#endif
    }

#ifdef FUNC_GUN_LOCK_TRIG_MODE
    if (Charger.m_bUseGunLock)
    {
        if (Charger.m_GunLockTrigMode == GL_TRIG_MODE_REQUEST)
        {
            if (Charger.CP_State == SYSTEM_STATE_A && Charger.m_GunLockRequestMode_LockDelayTick != 0)
            {
                Charger.m_GunLockRequestMode_LockDelayTick = 0;
            }

            if (Charger.Alarm_Code > 0)
            {
                if (Charger.Alarm_Code & ALARM_EMERGENCY_STOP)
                {
                    if (Charger.am3352.isRequestOn && !GL_IsLock())
                    {
                        if (Charger.CP_State != SYSTEM_STATE_A)
                        {
                            GL_Trig(GL_MODE_LOCK);
                        }
                    }
                    else if (!Charger.am3352.isRequestOn && GL_IsLock())
                    {
                        GL_Trig(GL_MODE_UNLOCK);
                    }
                }
                else //other alarm
                {
                    if (GL_IsLock())
                    {
                        GL_Trig(GL_MODE_UNLOCK);
                    }
                }
            }
            else
            {
                if (Charger.am3352.isRequestOn && !GL_IsLock())
                {
                    if (Charger.CP_State != SYSTEM_STATE_A)
                    {
                        if (Charger.m_GunLockRequestMode_LockDelayTick == 0)
                        {
                            Charger.m_GunLockRequestMode_LockDelayTick = HAL_GetTick();
                        }
                        else
                        {
                            if (HTK_IsTimeout(Charger.m_GunLockRequestMode_LockDelayTick, 3000))
                            {
                                GL_Trig(GL_MODE_LOCK);
                                Charger.m_GunLockRequestMode_LockDelayTick = 0;
                            }

                        }
                    }
                }
                else if (!Charger.am3352.isRequestOn && GL_IsLock())
                {
                    GL_Trig(GL_MODE_UNLOCK);
                }
            }
        }
    }
#endif

}
#endif //MODIFY_CPTASK_HEAD

#ifdef FUNC_FORCE_RUN_CSU_MODE_WITH_DC_MODELNAME
void Update_McuCtrlMode(void)
{
    while (!Charger.m_bModelNameDCReadOK)
    {
        osDelay(100);
    }

    if (IS_CSU_MOUNTED || Charger.m_bModelNameDC == 1)
    {
        Charger.memory.EVSE_Config.data.item.MCU_Control_Mode = MCU_CONTROL_MODE_CSU;
        DEBUG_INFO("#MCU_CONTROL_MODE_CSU\r\n");
    }
    else
    {
        Charger.memory.EVSE_Config.data.item.MCU_Control_Mode = MCU_CONTROL_MODE_NO_CSU;
        DEBUG_INFO("#MCU_CONTROL_MODE_NO_CSU\r\n");

        if (Charger.memory.EVSE_Config.data.item.AuthMode > AUTH_MODE_FREE)
        {
            Charger.memory.EVSE_Config.data.item.AuthMode = AUTH_MODE_FREE ;
            DEBUG_INFO("#AuthMode set defualt AUTH_MODE_FREE \r\n");
        }

        if (Charger.memory.EVSE_Config.data.item.OfflinePolicy > RFID_USER_AUTH_NO_CHARGING)
        {
            Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_FREE ;
            DEBUG_INFO("#OfflinePolicy set defualt RFID_USER_AUTH_FREE \r\n");
        }
    }
}
#endif //FUNC_FORCE_RUN_CSU_MODE_WITH_DC_MODELNAME

#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
void IdleUntilReadAllMemory(void)
{
    while (!Charger.m_bReadAllMemory)
    {
        osDelay(10);
    }
}
#endif

#ifdef FUNC_IDLE_UNTIL_INIT_METER_IC
void IdleUntilInitMeterIC(void)
{
    while (!Charger.m_bInitMeterIC)
    {
        osDelay(10);
    }
}
#endif

#ifdef FUNC_GUN_LOCK

#define GL_GPIO_IS_LOCK         ((HAL_GPIO_ReadPin(IN_LOCK_Status_GPIO_Port, IN_LOCK_Status_Pin) == GPIO_PIN_RESET) ? HTK_FALSE : HTK_TRUE)
#define GL_GPIO_UNLOCK(x)       (HAL_GPIO_WritePin(OUT_UNLOCK_L_GPIO_Port, OUT_UNLOCK_L_Pin , ((x) == 0) ? GPIO_PIN_RESET : GPIO_PIN_SET))
#define GL_GPIO_LOCK(x)         (HAL_GPIO_WritePin(OUT_LOCK_L_GPIO_Port, OUT_LOCK_L_Pin, ((x) == 0) ? GPIO_PIN_RESET : GPIO_PIN_SET))
#define GL_GPIO_PULSE_WIDTH     (290) //must < 300ms

void GL_Init(void)
{
    GL_GPIO_LOCK(0);
    GL_GPIO_UNLOCK(0);
    GL_Unlock();
}

void GL_Lock(void)
{
    GL_GPIO_LOCK(1);
    osDelay(GL_GPIO_PULSE_WIDTH);
    GL_GPIO_LOCK(0);
}

void GL_Unlock(void)
{
    GL_GPIO_UNLOCK(1);
    osDelay(GL_GPIO_PULSE_WIDTH);
    GL_GPIO_UNLOCK(0);
}

HTK_BOOL GL_IsLock(void)
{
    return GL_GPIO_IS_LOCK;
}

void GL_Trig(GL_MODE mode)
{
    static uint32_t LastTrigTick = 0;
    const uint32_t MIN_TRIG_TICK_PERIOD = 500;

#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
    if (
            (mode == GL_MODE_LOCK   && Charger.m_GunLock_Counter   > GUN_LOCK_PULSE_MAX_TIMES) ||
            (mode == GL_MODE_UNLOCK && Charger.m_GunUnlock_Counter > GUN_LOCK_PULSE_MAX_TIMES)
        )
    {
        return;
    }
#endif


    if (HTK_IsInTime(LastTrigTick, MIN_TRIG_TICK_PERIOD))
    {
        return;
    }

    LastTrigTick = HAL_GetTick();

    switch(mode)
    {
    case GL_MODE_UNLOCK:

        if (!Charger.m_bTrigGunUnlock) //Trig unlock process
        {
            Charger.m_bTrigGunUnlock = HTK_TRUE;
            timerEnable(TIMER_IDX_GUN_LOCK, GL_GPIO_PULSE_WIDTH);
            GL_GPIO_UNLOCK(1);

#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
            //Charger.m_GunUnlock_Counter++;
            XP("#GL Unlock-H (%d)\r\n", Charger.m_GunUnlock_Counter);
#else
            XP("#GL Unlock-H\r\n");
#endif
        }
        break;

    case GL_MODE_LOCK:
        if (!Charger.m_bTrigGunLock) //Trig lock process
        {
            Charger.m_bTrigGunLock = HTK_TRUE;
            timerEnable(TIMER_IDX_GUN_LOCK, GL_GPIO_PULSE_WIDTH);
            GL_GPIO_LOCK(1);

#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
            //Charger.m_GunLock_Counter++;
            XP("#GL Lock-H (%d)\r\n", Charger.m_GunLock_Counter);
#else
            XP("#GL Lock-H\r\n");
#endif
        }
        break;
    }
}

void GL_Proc(void)
{
    if (timer[TIMER_IDX_GUN_LOCK].isAlarm)
    {
        if (Charger.m_bTrigGunUnlock)
        {
            XP("#GL Timer: %d\r\n", (uint32_t)(HAL_GetTick() - timer[TIMER_IDX_GUN_LOCK].startTime));
            timerDisable(TIMER_IDX_GUN_LOCK);
            Charger.m_bTrigGunUnlock = HTK_FALSE;
            GL_GPIO_UNLOCK(0);
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
            XP("#GL Unlock-L (%d)\r\n", Charger.m_GunUnlock_Counter);
            Charger.m_GunUnlock_Counter++;
#else
            XP("#GL Unlock-L\r\n");
#endif
        }
        if (Charger.m_bTrigGunLock)
        {
            XP("#GL Timer: %d\r\n", (uint32_t)(HAL_GetTick() - timer[TIMER_IDX_GUN_LOCK].startTime));
            timerDisable(TIMER_IDX_GUN_LOCK);
            Charger.m_bTrigGunLock = HTK_FALSE;
            GL_GPIO_LOCK(0);
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
            XP("#GL Lock-L (%d)\r\n", Charger.m_GunLock_Counter);
            Charger.m_GunLock_Counter++;
#else
            XP("#GL Lock-L\r\n");
#endif
        }
    }
}

#endif //FUNC_GUN_LOCK

#ifdef FUNC_AX32_TRIG_LEAKAGE

#define TRIG_LEAKAGE_GPIO_IS_TRIGGERING     ((HAL_GPIO_ReadPin(OUT_TrigLeakage_GPIO_Port, OUT_TrigLeakage_Pin) == GPIO_PIN_RESET) ? HTK_FALSE : HTK_TRUE)
#define TRIG_LEAKAGE_GPIO_SET(x)            (HAL_GPIO_WritePin(OUT_TrigLeakage_GPIO_Port, OUT_TrigLeakage_Pin , ((x) == 0) ? GPIO_PIN_RESET : GPIO_PIN_SET))
#define TRIG_LEAKAGE_GPIO_PULSE_WIDTH       (450) //must < 500ms
#define TRIG_LEAKAGE_MAX_TIMES              (3)

void TrigLeakage_Init(void)
{
    XP("#TrigLeakage_Init\r\n");
    TRIG_LEAKAGE_GPIO_SET(0);
}
void TrigLeakage_Trig(void)
{
    static uint8_t TrigTimes = 0;
    static uint32_t LastTrigTick = 0;
    const uint32_t MIN_TRIG_TICK_PERIOD = 3000; //ms

    if (HTK_IsInTime(LastTrigTick, MIN_TRIG_TICK_PERIOD))
    {
        return;
    }

    LastTrigTick = HAL_GetTick();

    if (!Charger.m_bTrigLeakage) //Trig process
    {
        if (TrigTimes < TRIG_LEAKAGE_MAX_TIMES)
        {
            TrigTimes++;
            XP("#TrigLeakage_Proc (%d)\r\n", TrigTimes);
            Charger.m_bTrigLeakage = HTK_TRUE;
            timerEnable(TIMER_IDX_TRIG_LEAKAGE, TRIG_LEAKAGE_GPIO_PULSE_WIDTH);
            TRIG_LEAKAGE_GPIO_SET(1);
            XP("#TRIG_LEAKAGE-H\r\n");
        }
        else
        {
            XP("#TrigLeakage_Proc FAIL (MAX Trig times = %d)\r\n", TRIG_LEAKAGE_MAX_TIMES);
        }

    }
}

//void TrigLeakage_SimpleTrig(void)
//{
//    TRIG_LEAKAGE_GPIO_SET(1);
//    osDelay(TRIG_LEAKAGE_GPIO_PULSE_WIDTH);
//    TRIG_LEAKAGE_GPIO_SET(0);
//}

void TrigLeakage_Proc(void)
{
    if (timer[TIMER_IDX_TRIG_LEAKAGE].isAlarm)
    {
        if (Charger.m_bTrigLeakage)
        {
            XP("#TRIG_LEAKAGE-Timer: %d\r\n", (uint32_t)(HAL_GetTick() - timer[TIMER_IDX_TRIG_LEAKAGE].startTime));
            timerDisable(TIMER_IDX_TRIG_LEAKAGE);
            Charger.m_bTrigLeakage = HTK_FALSE;
            TRIG_LEAKAGE_GPIO_SET(0);
            XP("#TRIG_LEAKAGE-L\r\n");
        }
    }
}

#endif //FUNC_AX32_TRIG_LEAKAGE

#ifdef MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK
void AlarmDetect_RelayWelding_UseADC(void)
{
#ifdef  RELAY_WELDING_PROTECT

#ifdef VO_DISABLE_RELAY_WELDING
    if (!Charger.m_VOCode.m_DisableRelayWelding)
#else
    if (1)
#endif //VO_DISABLE_RELAY_WELDING
    {
        uint16_t MAX_FAIL_TIMES = 1000;

        if (Charger.GroundingSystem == GROUNGING_SYSTEM_LL || Charger.GroundingSystem == GROUNGING_SYSTEM_LN)
        {
            if ((Charger.Relay_Action == GPIO_RELAY_ACTION_ON) && (Charger.Relay_isOperationCompleted == 0x11) &&
                ((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) < (Charger.Voltage[0]*0.011)))
            {
#ifdef FUNC_NEW_RELAY_MONITOR
                double threshold = Charger.Voltage[0] * //0.01V
                    Charger.alarm_spec.Relay_LL_DriveFault_Slop +
                    Charger.alarm_spec.Relay_LL_DriveFault_Offs;
                if(adc_value.ADC2_IN5_Welding.value < threshold)
#endif
                {
                    if(Charger.counter.RELAY_Drive_Fualt.fail > MAX_FAIL_TIMES)
                    {
                        if(!(Charger.Alarm_Code & ALARM_RELAY_DRIVE_FUALT))
                        {
                            Charger.counter.RELAY.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                            Charger.Alarm_Code |= ALARM_RELAY_DRIVE_FUALT;
                            DEBUG_ERROR("Alarm Welding Voltage = %d.\r\n",adc_value.ADC2_IN5_Welding.value);
                            DEBUG_ERROR("Alarm relay ON status fault occur.\r\n");
                        }
                    }
                    else
                    {
                        Charger.counter.RELAY_Drive_Fualt.fail++;
#ifdef DEBUG_RELAY_MONITOR_SHOW_INFO
                        XP("#RelayDriveFault(%d): W(%.2f) T(%.2f)\r\n",
                            Charger.counter.RELAY_Drive_Fualt.fail,
                            adc_value.ADC2_IN5_Welding.value,
                            threshold);
#endif
                    }
                }
                else
                {
                  Charger.counter.RELAY_Drive_Fualt.fail = 0 ;
                }
            }
            else if ((Charger.Relay_Action == GPIO_RELAY_ACTION_OFF) && (Charger.Relay_isOperationCompleted == 0x00) &&
                ((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) < (Charger.Voltage[0]*0.011)))
            {
#ifdef FUNC_NEW_RELAY_MONITOR
                double threshold =
                    Charger.Voltage[0] * //0.01V
                    Charger.alarm_spec.Relay_LL_Welding_Slop +
                    Charger.alarm_spec.Relay_LL_Welding_Offs;
                if(adc_value.ADC2_IN5_Welding.value > threshold)
#endif
                {
                    if(Charger.counter.RELAY.fail > MAX_FAIL_TIMES)
                    {
                        if(!(Charger.Alarm_Code & ALARM_RELAY_STATUS))
                        {
                            Charger.counter.RELAY.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                            Charger.Alarm_Code |= ALARM_RELAY_STATUS;
#ifdef FUNC_AX32_TRIG_LEAKAGE
                            Charger.AlarmRelayWeldingOccurTick = HAL_GetTick();
#endif
                            DEBUG_ERROR("Alarm Welding Voltage = %d.\r\n",adc_value.ADC2_IN5_Welding.value);
                            DEBUG_ERROR("Alarm relay OFF status fault occur.\r\n");
                        }
                    }
                    else
                    {
                        Charger.counter.RELAY.fail++;
#ifdef DEBUG_RELAY_MONITOR_SHOW_INFO
                        XP("#RelayWelding(%d): W(%.2f) T(%.2f)\r\n",
                            Charger.counter.RELAY.fail,
                            adc_value.ADC2_IN5_Welding.value,
                            threshold);
#endif
                    }
                }
                else
                {
                  Charger.counter.RELAY.fail = 0 ;
                }
            }
        }
        //-------------------------------------------------

    }
#endif  //RELAY_WELDING_PROTECT
}


#ifdef FUNC_USE_RELAY_B_CONTACT

HTK_BOOL IsRelayContact_Closed(void)
{
    return HAL_GPIO_ReadPin(IN_Relay_b_Contact_GPIO_Port, IN_Relay_b_Contact_Pin) == GPIO_PIN_SET ? HTK_TRUE : HTK_FALSE;
}

void AlarmDetect_RelayWelding_UseGPIO(void)
{
#ifdef  RELAY_WELDING_PROTECT

#ifdef VO_DISABLE_RELAY_WELDING
    if (!Charger.m_VOCode.m_DisableRelayWelding)
#else
    if (1)
#endif //VO_DISABLE_RELAY_WELDING
    {
        uint16_t MAX_FAIL_TIMES = 1000;

        if (Charger.GroundingSystem == GROUNGING_SYSTEM_LL || Charger.GroundingSystem == GROUNGING_SYSTEM_LN)
        {
            if ((Charger.Relay_Action == GPIO_RELAY_ACTION_ON) && (Charger.Relay_isOperationCompleted == 0x11) &&
                ((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) < (Charger.Voltage[0]*0.011)))
            {
                if (!IsRelayContact_Closed())
                {
                    if(Charger.counter.RELAY_Drive_Fualt.fail > MAX_FAIL_TIMES)
                    {
                        if(!(Charger.Alarm_Code & ALARM_RELAY_DRIVE_FUALT))
                        {
                            Charger.counter.RELAY.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                            Charger.Alarm_Code |= ALARM_RELAY_DRIVE_FUALT;
                            //DEBUG_ERROR("Alarm Welding Voltage = %d.\r\n",adc_value.ADC2_IN5_Welding.value);
                            DEBUG_ERROR("Alarm relay ON status fault occur.\r\n");
                        }
                    }
                    else
                    {
                        Charger.counter.RELAY_Drive_Fualt.fail++;
                    }
                }
                else
                {
                  Charger.counter.RELAY_Drive_Fualt.fail = 0 ;
                }
            }
            else if ((Charger.Relay_Action == GPIO_RELAY_ACTION_OFF) && (Charger.Relay_isOperationCompleted == 0x00) &&
                ((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) < (Charger.Voltage[0]*0.011)))
            {
                if (IsRelayContact_Closed())
                {
                    if(Charger.counter.RELAY.fail > MAX_FAIL_TIMES)
                    {
                        if(!(Charger.Alarm_Code & ALARM_RELAY_STATUS))
                        {
                            Charger.counter.RELAY.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
                            Charger.Alarm_Code |= ALARM_RELAY_STATUS;
#ifdef FUNC_AX32_TRIG_LEAKAGE
                            Charger.AlarmRelayWeldingOccurTick = HAL_GetTick();
#endif
                            //DEBUG_ERROR("Alarm Welding Voltage = %d.\r\n",adc_value.ADC2_IN5_Welding.value);
                            DEBUG_ERROR("Alarm relay OFF status fault occur.\r\n");
                        }
                    }
                    else
                    {
                        Charger.counter.RELAY.fail++;
                    }
                }
                else
                {
                  Charger.counter.RELAY.fail = 0 ;
                }
            }
        }
    }
#endif  //RELAY_WELDING_PROTECT
}
#endif //FUNC_USE_RELAY_B_CONTACT

#endif //MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK

#ifdef MODIFY_DC_RS485_UPGRADE_ISSUE

void RS485_TX_Enable(void)
{
    HAL_GPIO_WritePin(OUT_Meter_485_DE_GPIO_Port, OUT_Meter_485_DE_Pin, GPIO_PIN_SET);
    HAL_GPIO_WritePin(OUT_Meter_485_RE_GPIO_Port, OUT_Meter_485_RE_Pin, GPIO_PIN_SET);
    osDelay(1);
}

void RS485_TX_Disable(void)
{
    HAL_GPIO_WritePin(OUT_Meter_485_DE_GPIO_Port, OUT_Meter_485_DE_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(OUT_Meter_485_RE_GPIO_Port, OUT_Meter_485_RE_Pin, GPIO_PIN_RESET);

}

void Prefix_UartTX(uint8_t* TxBuf, uint8_t* RxBuf)
{
    if (RxBuf == UART_RS485_rx_buffer)
    {
        RS485_TX_Enable();
        TxBuf[1] = Charger.m_RS485SlaveAddr; //Update Slave Address
    }
}

void Postfix_UartTX(uint8_t* TxBuf, uint8_t* RxBuf)
{
    if (RxBuf == UART_RS485_rx_buffer)
    {
        RS485_TX_Disable();
    }
}
#endif //MODIFY_DC_RS485_UPGRADE_ISSUE

#ifdef FUNC_AX80_ADD_TILT_SENSOR

//#define TILT_GPIO_IS_ACTION_ON                  ((HAL_GPIO_ReadPin(IN_Tilt_ActOn_GPIO_Port, IN_Tilt_ActOn_Pin) == GPIO_PIN_RESET) ? HTK_FALSE : HTK_TRUE)
//#define TILT_GPIO_TEST_SET(x)                   (HAL_GPIO_WritePin(OUT_Tilt_Test_GPIO_Port, OUT_Tilt_Test_Pin , ((x) == 0) ? GPIO_PIN_RESET : GPIO_PIN_SET))

#define TILT_GPIO_IS_ACTION_ON                  ((HAL_GPIO_ReadPin(IN_Tilt_ActOn_GPIO_Port, IN_Tilt_ActOn_Pin) == GPIO_PIN_RESET) ? HTK_TRUE : HTK_FALSE)
#define TILT_GPIO_TEST_SET(x)                   (HAL_GPIO_WritePin(OUT_Tilt_Test_GPIO_Port, OUT_Tilt_Test_Pin , ((x) == 0) ? GPIO_PIN_RESET : GPIO_PIN_SET))

#define TILT_TRIG_LEAKAGE_GPIO_IS_TRIGGERING    ((HAL_GPIO_ReadPin(OUT_Tilt_DrvLeakage_GPIO_Port, OUT_Tilt_DrvLeakage_Pin) == GPIO_PIN_RESET) ? HTK_FALSE : HTK_TRUE)
#define TILT_TRIG_LEAKAGE_GPIO_SET(x)           (HAL_GPIO_WritePin(OUT_Tilt_DrvLeakage_GPIO_Port, OUT_Tilt_DrvLeakage_Pin , ((x) == 0) ? GPIO_PIN_RESET : GPIO_PIN_SET))
#define TILT_TRIG_LEAKAGE_GPIO_PULSE_WIDTH      (450) //must < 500ms
#define TILT_TRIG_LEAKAGE_MAX_TIMES             (3)

void TILT_TrigLeakage_Init(void)
{
    XP("#TILT_TrigLeakage_Init\r\n");
    TILT_TRIG_LEAKAGE_GPIO_SET(0);

    TILT_GPIO_TEST_SET(1);
    osDelay(1);
    if (TILT_GPIO_IS_ACTION_ON)
    {
        XP("#Tilt sensor test OK\r\n");
    }
    else
    {
        XP("#Tilt sensor test [NG]\r\n");
    }
    TILT_GPIO_TEST_SET(0);

}

void TILT_TrigLeakage_Trig(void)
{
    static uint8_t TrigTimes = 0;
    static uint32_t LastTrigTick = 0;
    const uint32_t MIN_TRIG_TICK_PERIOD = 3000; //ms

    if (HTK_IsInTime(LastTrigTick, MIN_TRIG_TICK_PERIOD))
    {
        return;
    }

    LastTrigTick = HAL_GetTick();

    if (!Charger.m_bTILT_TrigLeakage) //Trig process
    {
        if (TrigTimes < TILT_TRIG_LEAKAGE_MAX_TIMES)
        {
            TrigTimes++;
            XP("#TILT_TrigLeakage_Proc (%d)\r\n", TrigTimes);
            Charger.m_bTILT_TrigLeakage = HTK_TRUE;
            timerEnable(TIMER_IDX_TILT_TRIG_LEAKAGE, TILT_TRIG_LEAKAGE_GPIO_PULSE_WIDTH);
            TILT_TRIG_LEAKAGE_GPIO_SET(1);
            XP("#TILT_TRIG_LEAKAGE-H\r\n");
        }
        else
        {
            XP("#TILT_TrigLeakage_Proc FAIL (MAX Trig times = %d)\r\n", TILT_TRIG_LEAKAGE_MAX_TIMES);
        }

    }
}

//void TILT_TrigLeakage_SimpleTrig(void)
//{
//    TILT_TRIG_LEAKAGE_GPIO_SET(1);
//    osDelay(TILT_TRIG_LEAKAGE_GPIO_PULSE_WIDTH);
//    TILT_TRIG_LEAKAGE_GPIO_SET(0);
//}

void TILT_TrigLeakage_Proc(void)
{
    if (timer[TIMER_IDX_TILT_TRIG_LEAKAGE].isAlarm)
    {
        if (Charger.m_bTILT_TrigLeakage)
        {
            XP("#TILT_TRIG_LEAKAGE-Timer: %d\r\n", (uint32_t)(HAL_GetTick() - timer[TIMER_IDX_TILT_TRIG_LEAKAGE].startTime));
            timerDisable(TIMER_IDX_TILT_TRIG_LEAKAGE);
            Charger.m_bTILT_TrigLeakage = HTK_FALSE;
            TILT_TRIG_LEAKAGE_GPIO_SET(0);
            XP("#TILT_TRIG_LEAKAGE-L\r\n");
        }
    }
}

void AlarmDetect_TiltSensor(void)
{
#ifdef VO_DISABLE_DETECT_TILT_SENSOR
    if (!Charger.m_VOCode.m_DisableDetectTiltSensor)
#else
    if (1)
#endif
    {
        uint16_t MAX_FAIL_TIMES = 1000;

        if (TILT_GPIO_IS_ACTION_ON)
        {
            if (Charger.counter.TiltSensor.fail > MAX_FAIL_TIMES)
            {
                if(!(Charger.Alarm_Code & ALARM_TILT_SENSOR))
                {
                    Charger.Alarm_Code |= ALARM_TILT_SENSOR;
                    Charger.AlarmTiltSensorOccurTick = HAL_GetTick();
                    DEBUG_ERROR("Alarm tilt sensor fault occur.\r\n");
                }
            }
            else
            {
                Charger.counter.TiltSensor.fail++;
            }
        }
        else
        {
            Charger.counter.TiltSensor.fail = 0 ;
        }
    }
}

#endif //FUNC_AX80_ADD_TILT_SENSOR

#ifdef FUNC_TASK_MONITOR
void StartMonitorTask(void const * argument)
{
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    IdleUntilReadAllMemory();
#endif
    memset(&Charger.m_TaskMonitor, 0, sizeof(Charger.m_TaskMonitor));
#ifdef FUNC_MODIFY_TASK_MONITOR_20231227
    enum { ADC_RESET_MAX = 1 };
#else
    enum { ADC_RESET_MAX = 10 };
#endif
    while (1)
    {
        //ADC
        {
            static PTaskADCInfo p = &Charger.m_TaskMonitor.m_ADC;
            if (
                    (
                        p->m_ADC1_Counter[0] != 0 &&
                        p->m_ADC2_Counter[0] != 0 &&
                        p->m_ADC3_Counter[0] != 0
                    )
                    &&
                    (
                        p->m_ADC1_Counter[0] == p->m_ADC1_Counter[1] ||
                        p->m_ADC2_Counter[0] == p->m_ADC2_Counter[1] ||
                        p->m_ADC3_Counter[0] == p->m_ADC3_Counter[1]
                    )
                )
            {
                p->m_ContinueResetCounter++;
                p->m_TotalResetCounter++;

                XP("#TaskMonitor: ADC[%d/%d](%d, %d, %d) ADC->SR(0x%04X, 0x%04X, 0x%04X) => [NG] Reset %s\r\n",
                    p->m_ContinueResetCounter, p->m_TotalResetCounter,
                    p->m_ADC1_Counter[0],
                    p->m_ADC2_Counter[0],
                    p->m_ADC3_Counter[0], ADC1->SR, ADC2->SR, ADC3->SR,
                    p->m_ContinueResetCounter > ADC_RESET_MAX ? "MCU" : "ADC");

                if (p->m_ContinueResetCounter > ADC_RESET_MAX)
                {
                    NVIC_SystemReset();
                }
                else
                {
                    isDMAEnd_ADC1 = OFF;
                    isDMAEnd_ADC2 = OFF;
                    isDMAEnd_ADC3 = OFF;
                    HAL_ADC_Stop_DMA(&hadc1);
                    HAL_ADC_Stop_DMA(&hadc2);
                    HAL_ADC_Stop_DMA(&hadc3);
                    //__HAL_ADC_CLEAR_FLAG(&hadc1, ADC_FLAG_STRT);
                    //__HAL_ADC_CLEAR_FLAG(&hadc2, ADC_FLAG_STRT);
                    //__HAL_ADC_CLEAR_FLAG(&hadc3, ADC_FLAG_STRT);

                    MX_DMA_Init();
                    MX_ADC1_Init();
                    MX_ADC2_Init();
                    MX_ADC3_Init();

                    if(HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&ADC1_Buffer, ADC1_CHANEL_COUNT*ADC1_SAMPLE_COUNT)!=HAL_OK)Error_Handler();
                    if(HAL_ADC_Start_DMA(&hadc2, (uint32_t*)&ADC2_Buffer, ADC2_CHANEL_COUNT*ADC2_SAMPLE_COUNT)!=HAL_OK)Error_Handler();
                    if(HAL_ADC_Start_DMA(&hadc3, (uint32_t*)&ADC3_Buffer, ADC3_CHANEL_COUNT*ADC3_SAMPLE_COUNT)!=HAL_OK)Error_Handler();
                }
            }
            else
            {
                p->m_ContinueResetCounter = 0;
                p->m_ADC1_Counter[1] = p->m_ADC1_Counter[0];
                p->m_ADC2_Counter[1] = p->m_ADC2_Counter[0];
                p->m_ADC3_Counter[1] = p->m_ADC3_Counter[0];

            }
        }
        osDelay(300);
    }
}
#endif //FUNC_TASK_MONITOR

#ifdef FUNC_RS485_BLE_SW
void RS485_SW(HTK_BOOL bON)
{
    XP("#<RS485_SW: %s>\r\n", (bON ? "ON" : "OFF"));
    HAL_GPIO_WritePin(RS485_SW_GPIO_Port, RS485_SW_Pin, bON ? GPIO_PIN_SET : GPIO_PIN_RESET);
}

void BLE_SW(HTK_BOOL bON)
{
    XP("#<BLE_SW: %s>\r\n", (bON ? "ON" : "OFF"));
    HAL_GPIO_WritePin(BLE_SW_GPIO_Port, BLE_SW_Pin, bON ? GPIO_PIN_SET : GPIO_PIN_RESET);
}
#endif //FUNC_RS485_BLE_SW

#ifdef FUNC_LIN_EN_SW
void LIN_EN(HTK_BOOL bEnable)
{
    XP("#<LIN_EN: %s>\r\n", (bEnable ? "Enable" : "Disable"));
    HAL_GPIO_WritePin(OUT_USB_DriveBus_GPIO_Port, OUT_USB_DriveBus_Pin, bEnable ? GPIO_PIN_SET : GPIO_PIN_RESET);
}

void LIN_SW(HTK_BOOL bUseLIN)
{
    XP("#<LIN_SW: Use %s>\r\n", (bUseLIN ? "LIN" : "PWM"));
    //TMUX6219 Table8-1
    //  EN  SEL     Select Source
    //  0   X       All off
    //  1   0       S1 (CP-LIN)
    //  1   1       S2 (CP-PWM)
    HAL_GPIO_WritePin(LIN_PWM_SW_GPIO_Port, LIN_PWM_SW_Pin, bUseLIN ? GPIO_PIN_RESET : GPIO_PIN_SET);
}
#endif //FUNC_LIN_EN_SW

#ifdef FUNC_LIN_CP
void StartLinCpTask(void const * argument)
{
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    IdleUntilReadAllMemory();
#endif

    do
    {
        osDelay(1000);
    }
    while (!Charger.m_bUseLinCP);

    static PLinCP p = NULL;
    if (p == NULL)
    {
        p = (PLinCP)HTK_Malloc(sizeof(LinCP));
        if (p != NULL)
        {
            Charger.m_pLinCP = p;
            LIN_Init(p, USART1);
        }
    }

    LIN_EN(HTK_TRUE);

    //Test
    //LIN_SW(HTK_TRUE);
    //LIN_SW(HTK_FALSE);

//    SeVersionList data;
//    memset(&data, 0, sizeof(data));
//    data.SeSelectedVersion = 0x01;
//    data.B1 = 0x02;
//    data.SeVersionPageNumber = 0x03;
//    data.SeSupportedVersion1 = 0x04;
//    data.SeSupportedVersion2 = 0x05;
//    data.SeSupportedVersion3 = 0x06;
//    data.SeSupportedVersion4 = 0x07;
//    data.SeSupportedVersion5 = 0x08;

    while (1)
    {
//        LIN_TxHeaderData(p, LINCPID_SE_VERSION_LIST, &data, sizeof(data));
//        osDelay(30);
//        LIN_TxHeader(p, LINCPID_EV_VERSION_LIST);
//        osDelay(30);

        osDelay(1000);
    }
}
#endif //FUNC_LIN_CP

#ifdef FUNC_AW48_NET_LED
void Proc_NetLedActionSubState(void)
{
    if (Charger.am3352.NetLedActionState == NET_LED_ACTION_ALL_CONNECTING)
    {
        //if(blinker[BLINKER_IDX_LED_NET].blinkisFinish)
        {
            if (Charger.am3352.NetLedActionSubState == NET_LED_ACTION_LTE_CONNECTING_H)
            {
                setNetLedMotion(Charger.am3352.NetLedActionSubState = NET_LED_ACTION_WIFI_CONNECTING_H);
            }
            else if (Charger.am3352.NetLedActionSubState == NET_LED_ACTION_WIFI_CONNECTING_H)
            {
                setNetLedMotion(Charger.am3352.NetLedActionSubState = NET_LED_ACTION_ETHERNET_CONNECTING_H);
            }
            else if (Charger.am3352.NetLedActionSubState == NET_LED_ACTION_ETHERNET_CONNECTING_H)
            {
                setNetLedMotion(Charger.am3352.NetLedActionSubState = NET_LED_ACTION_LTE_CONNECTING_H);
            }
        }
    }

}
#endif //FUNC_AW48_NET_LED

#ifdef FUNC_AES256

HTK_BOOL AES256_Verify(u8* Data, int DataLen, u8* Key, u8* IV, u8* RemoteEncryptedData)
{
    u8 PlainData[16] = { 0 };
    memcpy(PlainData, Data, HTK_GET_VAL_MIN(DataLen, 16));

    u8 EncryptedData[16];
    size_t encryptedSize;

    // Fill padding data to 16 byte with PKCS7
    PKCS7_Pad(PlainData, 4, 16, PlainData);

    //XP("strlen((char*)PlainData) = %d\r\n", strlen((char*)PlainData)); //??????????????????
    // Encrypt data
    //AES256MainCBC(Key, PlainData, IV, strlen((char*)PlainData), EncryptedData, &encryptedSize, true);
    AES256MainCBC(Key, PlainData, IV, 16, EncryptedData, &encryptedSize, true);

//    DEBUG_INFO("AES256 Check ============================================\r\n");
//    DEBUG_INFO("EncryptedSize: %d\r\n", encryptedSize);

//    for(uint8_t idx=0;idx<16;idx++)
//        DEBUG_INFO("PlainData[%d]: %02X\r\n", idx, PlainData[idx]);

    HTK_BOOL bRes = HTK_TRUE;
    for(uint8_t idx=0;idx<16;idx++)
    {
//        DEBUG_INFO("EncryptedData[%d]: %02X, RemoteEncryptedData[%d]: %02X\r\n",
//                   idx, EncryptedData[idx], idx, RemoteEncryptedData[idx]);
        if (RemoteEncryptedData[idx] != EncryptedData[idx])
        {
            bRes = HTK_FALSE;
            break;
        }
    }

    if (bRes)
    {
        DEBUG_INFO("<AES Check OK>\r\n");
        return HTK_TRUE;
    }
    else
    {
        DEBUG_INFO("<AES Check NG>\r\n");
        return HTK_FALSE;
    }
}

void AES256_Test(void)
{
    /* AES test */

    uint8_t Key[32] =
    {
        0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
        0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12
    };

    uint8_t IV[] =
    {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
    };

    uint8_t PlainData[] =
    {
        0x11, 0x22, 0x33, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    };

    uint8_t encryptedData[16];
    size_t encryptedSize;

    // Fill padding data to 16 byte with PKCS7
    PKCS7_Pad(PlainData, 4, 16, PlainData);

    // Encrypt data
    AES256MainCBC((u8*)Key, PlainData, IV, strlen((char*)PlainData), encryptedData, &encryptedSize, true);

    DEBUG_INFO("encryptedSize: %d\r\n", encryptedSize);

    for(uint8_t idx=0;idx<16;idx++)
        DEBUG_INFO("PlainData[%d]: %02X\r\n", idx, PlainData[idx]);

    for(uint8_t idx=0;idx<16;idx++)
        DEBUG_INFO("encryptedData[%d]: %02X\r\n", idx, encryptedData[idx]);


    {
        u8 Data[4] = { 0x11, 0x22, 0x33, 0x44 };
        AES256_Verify(Data, 4, (u8*)Key, IV, encryptedData);
    }

}
#endif //FUNC_AES256

#ifdef FUNC_ECDSA

HTK_BOOL ECDSA_Verify(u8* PublicKey, int PublicKeyLen, u8* Hash, int HashLen, u8* Signature, int SignatureLen)
{
    cmox_ecc_handle_t Ecc_Ctx;
    cmox_ecc_retval_t retval;
    uint32_t fault_check = 0;

    if (PublicKeyLen != 64 || HashLen != 32 || SignatureLen != 64)
    {
        return HTK_FALSE;
    }

    enum { WORKING_BUFFER_SIZE = 2000 };
    uint8_t* Working_Buffer = (uint8_t*)HTK_Malloc(WORKING_BUFFER_SIZE);

    if (Working_Buffer == NULL)
    {
        return HTK_FALSE;
    }

    HTK_BOOL bRtn = HTK_FALSE;

    if (cmox_initialize(NULL) != CMOX_INIT_SUCCESS)
    {
        XP("<cmox_initialize NG>\r\n");
        bRtn = HTK_FALSE;
    }
    else
    {
        cmox_ecc_construct(&Ecc_Ctx, CMOX_ECC256_MATH_FUNCS, Working_Buffer, WORKING_BUFFER_SIZE);
        for(uint8_t idx=0;idx<2;idx++) //2nd function call will get the correct result
        {
            retval = cmox_ecdsa_verify(
                &Ecc_Ctx,                   /* ECC context */

#ifdef FUNC_CSU_VERIFY_USE_ECDSA_CMOX_ECC_CURVE_SECP256R1
                CMOX_ECC_CURVE_SECP256R1,   //more safe then SECP256K1
#else
                CMOX_ECC_CURVE_SECP256K1,   /* SECP256K1 ECC curve selected */
#endif
                PublicKey, PublicKeyLen,    /* Public key for verification */
                Hash, CMOX_SHA256_SIZE,     /* Digest to verify */
                Signature, SignatureLen,    /* Data buffer to receive signature */
                &fault_check);              /* Fault check variable: to ensure no fault injection occurs during this API call */

            static char* CMOX_ECC_RETVAL_STR[] =
            {
                "UNKNOW",                   //0
                "SUCCESS",                  //1
                "ERR_INTERNAL",             //2
                "ERR_BAD_PARAMETERS",       //3
                "ERR_INVALID_PUBKEY",       //4
                "ERR_INVALID_SIGNATURE",    //5
                "ERR_WRONG_RANDOM",         //6
                "ERR_MEMORY_FAIL",          //7
                "ERR_MATHCURVE_MISMATCH",   //8
                "ERR_ALGOCURVE_MISMATCH",   //9
                "AUTH_SUCCESS",             //10
                "AUTH_FAIL"                 //11
            };
            int StrIdx = 0;
            switch (retval)
            {
            case CMOX_ECC_SUCCESS:                  StrIdx = 1;     break;
            case CMOX_ECC_ERR_INTERNAL:             StrIdx = 2;     break;
            case CMOX_ECC_ERR_BAD_PARAMETERS:       StrIdx = 3;     break;
            case CMOX_ECC_ERR_INVALID_PUBKEY:       StrIdx = 4;     break;
            case CMOX_ECC_ERR_INVALID_SIGNATURE:    StrIdx = 5;     break;
            case CMOX_ECC_ERR_WRONG_RANDOM:         StrIdx = 6;     break;
            case CMOX_ECC_ERR_MEMORY_FAIL:          StrIdx = 7;     break;
            case CMOX_ECC_ERR_MATHCURVE_MISMATCH:   StrIdx = 8;     break;
            case CMOX_ECC_ERR_ALGOCURVE_MISMATCH:   StrIdx = 9;     break;
            case CMOX_ECC_AUTH_SUCCESS:             StrIdx = 10;    break;
            case CMOX_ECC_AUTH_FAIL:                StrIdx = 11;    break;
            default:                                StrIdx = 0;     break;
            }

            XP("[%d] retval = 0x%08X (CMOX_ECC_%s), fault_check = 0x%08X\r\n", idx, retval, CMOX_ECC_RETVAL_STR[StrIdx], fault_check);
        }

        /* Verify API returned value */
        //XP("retval = 0x%08X, fault_check = 0x%08X\r\n", retval, fault_check);

        if ((retval == CMOX_ECC_AUTH_SUCCESS) && (fault_check == CMOX_ECC_AUTH_SUCCESS))
        {
            XP("<ECDSA Verify OK>\r\n");
            bRtn = HTK_TRUE;
        }
        else
        {
            XP("<ECDSA Verify NG>\r\n");
            bRtn = HTK_FALSE;
        }
        cmox_ecc_cleanup(&Ecc_Ctx);
    }
    HTK_Free(Working_Buffer);
    return bRtn;
}

void ECDSA_VerifyTest(void)
{
    u8 Public_Key[] =
    {
    0x5A, 0x3D, 0x38, 0xEC, 0x72, 0x37, 0xA1, 0xB5, 0xF5, 0x2F, 0x3C, 0x34, 0x3C, 0x6E, 0x73, 0xBE,
    0x31, 0x9B, 0x15, 0x13, 0xF5, 0x92, 0x9B, 0xE9, 0xD3, 0x9A, 0xD0, 0x43, 0xA7, 0xBC, 0xD1, 0x26,
    0x81, 0x9C, 0x9A, 0x48, 0x1A, 0x3B, 0xE5, 0x32, 0xEE, 0xA9, 0x9D, 0x3C, 0x67, 0x30, 0x21, 0x63,
    0xF4, 0x26, 0x56, 0x22, 0xE5, 0x39, 0x49, 0xEC, 0x54, 0x63, 0x6D, 0x2E, 0x98, 0x40, 0xE0, 0x19
    };

    u8 Known_Hash[] =
    {
    0xB2, 0xED, 0x99, 0x21, 0x86, 0xA5, 0xCB, 0x19, 0xF6, 0x66, 0x8A, 0xAD, 0xE8, 0x21, 0xF5, 0x02,
    0xC1, 0xD0, 0x09, 0x70, 0xDF, 0xD0, 0xE3, 0x51, 0x28, 0xD5, 0x1B, 0xAC, 0x46, 0x49, 0x91, 0x6C
    };

    u8 Known_Signature[] =
    {
    0x0F, 0x80, 0xBE, 0x7F, 0x68, 0xE9, 0x73, 0x80, 0x22, 0x9A, 0xFF, 0x81, 0xEC, 0xE4, 0xE8, 0xCA,
    0xB7, 0x5D, 0xF6, 0x2D, 0x69, 0xEC, 0x06, 0xB9, 0xCA, 0x6D, 0x14, 0x72, 0x7A, 0x1C, 0xBE, 0xA7,
    0xC7, 0xE5, 0x1A, 0xF3, 0x43, 0x7D, 0xFD, 0x60, 0x04, 0x5B, 0xE7, 0xF1, 0xB8, 0x9C, 0xEA, 0x19,
    0xE8, 0x1D, 0xF0, 0xA7, 0xA7, 0x4F, 0xE3, 0x39, 0xFE, 0xB8, 0x0B, 0xF2, 0xFA, 0x1A, 0x93, 0x44
    };

    ECDSA_Verify(Public_Key, sizeof(Public_Key), Known_Hash, sizeof(Known_Hash), Known_Signature, sizeof(Known_Signature));
}
#endif //FUNC_ECDSA

#ifdef FUNC_VERIFY_TASK
void StartVerifyTask(void const * argument)
{
    static u8* p = Charger.m_VerifyTaskRxBuf;

#ifdef  FUNC_CSU_VERIFY_USE_ECDSA
    static u8* pKey = Charger.memory.EVSE_Config.data.item.m_CsuPublicKey;
#else
    //Generator: https://seanwasere.com/generate-random-hex/
    const u8 AES256_KEY[32] =
    {
        0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
        0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12
    };
#endif

    while (1)
    {
//#ifdef FIXHW_AW48_CSU_EXIST_DELAY_CHECK
//        if (Charger.m_bModelNameAW48_1P && Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
//        {
//            AW48_CheckCSU();
//        }
//#endif

        if (Charger.m_bCsuSignInMustVerify || Charger.m_bCsuUpgradeFwMustVerify)
        {
            if (Charger.m_bCsuSignInMustVerify && !Charger.m_bCsuSignInVerifyOK && Charger.m_bRunCsuSignInVerify)
            {
#ifdef FUNC_CSU_VERIFY_USE_ECDSA
                Charger.m_bCsuSignInVerifyOK = ECDSA_Verify(pKey, CSU_PUBLIC_KEY_LEN, &p[10], 32, &p[42], 64);
#else
                Charger.m_bCsuSignInVerifyOK = AES256_Verify(&p[6], 4, (u8*)AES256_KEY, &p[10], &p[26]);
#endif
                Charger.m_bRunCsuSignInVerify = HTK_FALSE;

                if (Charger.m_bCsuSignInVerifyOK && Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
                {
                    Update_McuCtrlMode();
                }
            }
            else if (Charger.m_bCsuUpgradeFwMustVerify && !Charger.m_bCsuUpgradeFwVerifyOK && Charger.m_bRunCsuUpgradeFwVerify)
            {
#ifdef FUNC_CSU_VERIFY_USE_ECDSA
                Charger.m_bCsuUpgradeFwVerifyOK = ECDSA_Verify(pKey, CSU_PUBLIC_KEY_LEN, &p[10], 32, &p[42], 64);
#else
                Charger.m_bCsuUpgradeFwVerifyOK = AES256_Verify(&p[6], 4, (u8*)AES256_KEY, &p[10], &p[26]);
#endif
                Charger.m_bRunCsuUpgradeFwVerify = HTK_FALSE;
            }
        }

        osDelay(100);
    }
}
#endif //FUNC_VERIFY_TASK


/* USER CODE END Application */

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