AWLU111001D1F7_SBSFU/Projects/STM32F407-Discovery/Applications/2_Images/AWLU111001D1F7/Inc/main.h

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.h
  * @brief          : Header for main.c file.
  *                   This file contains the common defines of the application.
  ******************************************************************************
  * @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 */

/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __MAIN_H
#define __MAIN_H

#ifdef __cplusplus
extern "C" {
#endif

/* Includes ------------------------------------------------------------------*/
#include "stm32f4xx_hal.h"
#include "stm32f4xx_hal.h"
#include "stm32f4xx_ll_usart.h"
#include "stm32f4xx_ll_rcc.h"
#include "stm32f4xx_ll_bus.h"
#include "stm32f4xx_ll_cortex.h"
#include "stm32f4xx_ll_system.h"
#include "stm32f4xx_ll_utils.h"
#include "stm32f4xx_ll_pwr.h"
#include "stm32f4xx_ll_gpio.h"
#include "stm32f4xx_ll_dma.h"

#include "stm32f4xx_ll_exti.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include "W25QXX.h"

/* USER CODE END Includes */

/* Exported types ------------------------------------------------------------*/
/* USER CODE BEGIN ET */


//******************************************************************
//Type define / Macro / Utility

#define HTK         //Some utility
#ifdef HTK
#define HTK_USE_XPRINT
#endif

#define DEBUG_FUNC  //comment this line when going to build a FORMAL one

//******************************************************************
#ifdef DEBUG_FUNC
//Print out debug message ON/OFF

//#define DISABLE_PRINT_DEBUG_MSG   //Disable print out debug message
//#define DISABLE_PRINT_RTOS_MSG    //Disable print out freeRTOS runtime message

//#define ENABLE_PRINT_IMCP_MSG     //Enable print out update port TX/RX frame message
#ifdef ENABLE_PRINT_IMCP_MSG
#define ENABLE_PRINT_IMCP_SPEC_MSG
#define PRINT_IMCP_MSG_ONLY_ON_UPDATEPORT
#endif //ENABLE_PRINT_IMCP_MSG

#endif //DEBUG_FUNC
//******************************************************************
#ifdef DEBUG_FUNC
//Debug Function

//#define DISABLE_CCID_PROTECT
//#define DISABLE_GROUND_FAULT_PROTECT    //ALARM_GROUND_FAIL
//#define DISABLE_OVP_PROTECT           //for calibration and test
//#define DISABLE_UVP_PROTECT           //for calibration and test
//#define DISABLE_RELAY_WELDING_PROTECT       //ALARM_RELAY_DRIVE_FUALT
//                                            //Threshold value wait to be modified
//#define DEBUG_ALARM_GROUND_FAIL

#endif //DEBUG_FUNC

//******************************************************************
//ONLY FOR CDFA TEST CONFIGURATION

//#define FUNC_ONLY_FOR_CDFA_CONFIG

#ifdef FUNC_ONLY_FOR_CDFA_CONFIG

#define ROTATE_SWITCH_HARDCODE

#ifdef ROTATE_SWITCH_HARDCODE
#define HC_SW_ON    (0)
#define HC_SW_OFF   (1)
#define HC_ROTARY_SWITCH_SET_VAL    (0x0B)
#define HC_SWITCH_1_CONN_TYPE_VAL   HC_SW_ON
#define HC_SWITCH_2_GROUND_SYS      HC_SW_ON
#endif //ROTATE_SWITCH_HARDCODE

#define DISABLE_GROUND_FAULT_PROTECT      //ALARM_GROUND_FAIL
#define DISABLE_RELAY_WELDING_PROTECT       //ALARM_RELAY_DRIVE_FUALT
                                            //Threshold value wait to be modified

#endif //FUNC_ONLY_FOR_CDFA_CONFIG

//******************************************************************
//ONLY FOR RD AC 110V TEST ENVIRONMENT (FAKE TO AC 220V)

//#define FUNC_ONLY_FOR_RD_AC110V_CONFIG

#ifdef FUNC_ONLY_FOR_RD_AC110V_CONFIG

#define ROTATE_SWITCH_HARDCODE

#ifdef ROTATE_SWITCH_HARDCODE
#define HC_SW_ON    (0)
#define HC_SW_OFF   (1)
#define HC_ROTARY_SWITCH_SET_VAL    (0x0B)
#define HC_SWITCH_1_CONN_TYPE_VAL   HC_SW_ON
#define HC_SWITCH_2_GROUND_SYS      HC_SW_ON
#endif //ROTATE_SWITCH_HARDCODE

#define DISABLE_GROUND_FAULT_PROTECT      //ALARM_GROUND_FAIL
#define DISABLE_RELAY_WELDING_PROTECT       //ALARM_RELAY_DRIVE_FUALT
                                            //Threshold value wait to be modified

#define TEST_ACXXX_FAKEDATA

#ifdef TEST_ACXXX_FAKEDATA
//#define TEST_AC110_FAKEDATA
#define TEST_AC220_FAKEDATA

#if (!defined(TEST_AC110_FAKEDATA) && !defined(TEST_AC220_FAKEDATA))
	#pragma message("====== !!! DEFINE ERROR! MUST DEFINE A TEST_ACXXX_FAKEDATA ITEM !!! ======")
#endif

#if (defined(TEST_AC110_FAKEDATA) && defined(TEST_AC220_FAKEDATA))
	#pragma message("====== !!! DEFINE ERROR! MUST DEFINE ONLY ONE TEST_ACXXX_FAKEDATA ITEM !!! ======")
#endif

#endif //TEST_ACXXX_FAKEDATA

#endif //FUNC_ONLY_FOR_RD_AC110V_CONFIG
//******************************************************************
//FORMAL Function

#define MODIFY_IMCP

#define FUNC_METER_IC_ADE7858A              //Function of Meter IC ADE7858A
#define AC_PHASE_NUM_MAX    (3)
//---------------------------------------------------------------
#ifdef FUNC_METER_IC_ADE7858A
#define FUNC_REPLACE_ADC_WITH_METER_IC      //Replace MCU ADC with Meter IC
#define MODIFY_METER_IC_I2C_RX_TIMEOUT      //Modify I2C RX Timeout to prevent block in
                                            //I2C_WaitOnFlagUntilTimeout()
#define FUNC_RESET_METER_IC_I2C             //When Fail in executing I2C HAL API, Reset the I2C
#define METER_IC_INIT_RETRY_NUM_MAX             (10)
#define METER_IC_I2C_COMM_MAX_RETRY_NUM         (5)
#define METER_IC_I2C_COMM_HARD_RESET_SPEC       (2)
#define METER_IC_I2C_COMM_ADD_DELAY
#define METER_IC_I2C_DISABLE_DMA
#define FUNC_POWER_CONSUMPTION_BY_METER_IC  //Use Meter IC to calculate total power consumption

//#define METER_IC_TIMER_IDX_METER_POLLING_SPEC   (500)
#define METER_IC_TIMER_IDX_METER_POLLING_SPEC   (300)

#define METER_IC_TIMER_IDX_POWER_TIMEOUT_SPEC   (1000 * 1) //1sec
//#define METER_IC_POWER_CONSUMPTION_MIN_CURR     (0.1)   //A
#define METER_IC_POWER_CONSUMPTION_MIN_CURR     (0.5)   //A
#define METER_IC_POWER_CONSUMPTION_SAVE_PERIOD_SEC  (180)
#define METER_IC_POWER_CONSUMPTION_SAVE_MAX_COUNT   (METER_IC_POWER_CONSUMPTION_SAVE_PERIOD_SEC * 1000 / METER_IC_TIMER_IDX_POWER_TIMEOUT_SPEC)

#define FUNC_METER_IC_COMM_ALARM
#ifdef FUNC_METER_IC_COMM_ALARM
#define METER_IC_COMM_TIMEOUT   (2000) //ms
#endif

#define METER_IC_USE_TASK_CRITICAL

//#define DEBUG_METER_IC

#define FUNC_INFO_METER_IC_RAW_DATA

#define FUNC_METER_IC_POWER_FADEOUT
#ifdef FUNC_METER_IC_POWER_FADEOUT
#define METER_IC_POWER_FADEOUT_TIME     (3000) //ms
#endif

#define FUNC_METER_IC_HISTORY   //Save MeterIC calibration write history to flash (use hisCharging block)
#ifdef FUNC_METER_IC_HISTORY
//#define FUNC_METER_IC_HISTORY_DEBUG
#define METER_IC_HISTORY_REC_NUM    (256)   //4096B / 16B = 256
#define FUNC_METER_IC_HISTORY_IMCP_CMD
#endif //FUNC_METER_IC_HISTORY


#endif //FUNC_METER_IC_ADE7858A
//---------------------------------------------------------------
//MeterExt(PRO380-Mod)

#define MODIFY_METER_EXT_PRO380_COMM_USE_PARITY_EVEN   //PRO380-Mod Meter Factory Default
#define MODIFY_METER_EXT_PRO380
#ifdef MODIFY_METER_EXT_PRO380
//#define METER_EXT_COMM_TIMEOUT   (5000) //ms
//#define METER_EXT_COMM_TIMEOUT   (1000 * 10) //ms
//#define METER_EXT_COMM_TIMEOUT   (1000 * 15) //ms
#define METER_EXT_COMM_TIMEOUT   (1000 * 30) //ms
#endif

#define FUNC_AUTO_USE_EXT_METER
//#define FUNC_FORCE_USE_METER_EXT_PRO380 //for Test Only

//---------------------------------------------------------------

#define FUNC_AUTO_IGNORE_AC_PHASE

////#define DISABLE_OLD_AW_MODEL_LEAK_MODULE_SELF_TEST_WITH_CSU
//////AX Model: CSU Send CP PWM duty, so above block is not required

#define MODIFY_COLD_LOAD_PICKUP_DELAY
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
//#define COLD_LOAD_PICKUP_DELAY_TIME_MAX_RANGE_SEC    (175)
#define COLD_LOAD_PICKUP_DELAY_TIME_MAX_RANGE_SEC    (10)
#endif

#define MODIFY_OCP_SPEC
#define SCP_SPEC_VAL    10000   //100A

#define MODIFY_ALARM_LEAKAGE_RECOVER

//Prevent BUFFER OVERLOAD
//  @ PROTOCOL_MESSAGE_QUERY_MODEL_NAME
//  @ PROTOCOL_MESSAGE_QUERY_SN
#define MODIFY_UNDEFINED_MODEL_NAME_AND_SN_ISSUE
#define MODIFY_CONFIG_MODEL_NAME
#define MODIFY_CONFIG_SN

#define MODIFY_PROTOCOL_MESSAGE_QUERY_POWER_CONSUME_64_BIT //AX Model Only

#define MODIFY_ADC_INIT_CLOCK_PRESCALER_SAME_WITH_AW
#define MODIFY_ADC_INIT_ANALOG_WDG_ITMODE_SAME_WITH_AW
//---------------------------------------------------------------

#define FUNC_RS485_SLAVE //Function of perform a RS485 device (slave) used by  master (ex: DC model) controller
#ifdef FUNC_RS485_SLAVE

#endif

#define FUNC_FORCE_RUN_CSU_MODE_WITH_DC_MODELNAME //For DC Model CSU used via RS485
//---------------------------------------------------------------

#define MODIFY_CP_TASK_CTRL_CP_PWM
#define MODIFY_CP_TASK_CTRL_CP_PWM_BELOW_SIX

#define FUNC_DETECT_PP //Detect PP signal for socket connector model
//key word:
//    user_pwm_setvalue(PWM_CH_CP
//    Charger.memory.EVSE_Config.data.item.MaxChargingCurrent
//    Charger.maxRatingCurrent
//    PROTOCOL_MESSAGE_CONFIG_MAX_CURRENT_PWM_DUTY
//    isRestoreFactory

//---------------------------------------------------------------
#define FUNC_OUTP_TYPE_E

#ifdef FUNC_OUTP_TYPE_E

//#define FUNC_USE_MODELNAME_TO_JUDGE_TYPEE_ENABLE
//Comment above line. Because ModelName will not contain TypeE
//information (Not a 2nd gun), so m_bEnableTypeE will always be TRUE (AX32)

#define MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_LEGACY_REQUEST

#define MODIFY_CPTASK_HEAD
#define MODIFY_CPTASK_TYPE_E

#define MODIFY_CPTASK_TYPE_E_CSU_SE_RELAY_AUTO_OFF
#define MODIFY_SOCKET_E_DETECT_PIN

//#define DEBUG_OUTP_TYPE_E
#endif //FUNC_OUTP_TYPE_E

//---------------------------------------------------------------
#define FUNC_ALARM_CP_NEG_ERROR

//---------------------------------------------------------------
//Fix MODE_ALARM => MODE_STOP => MODE_CHARGING (not output PWM but relay is ON)
#define MODIFY_CPTASK_CSU_0_1_CHARGE_MODE
#define MODIFY_ADCTASK_CP_STATE_CHANGE
#define MODIFY_ALARMTASK_CP_ERROR_RECOVER
#define MODIFY_MCU_PWM_SET_VALUE_CP

#define FUNC_DEBUG_MSG_SET_CHARGER_MODE
#define FUNC_DEBUG_MSG_CP_STATE

//---------------------------------------------------------------
#define FUNC_NEW_RELAY_MONITOR //New RelayWelding/DriveFault spec

//---------------------------------------------------------------
//#define FUNC_TRACE_MEM_HIS_ALARM


//---------------------------------------------------------------
//IWDG 32KHz / IWDG_PRESCALER_128 = 250Hz
//Reload 3000 => 3000 / 250Hz = 12 sec

//******************************************************************

#define FUNC_FW_VER_TRACE

#ifdef FUNC_FW_VER_TRACE

                                    //Version
#define FW_VER_TYPE_DEVELOP     (0) //D0.01
#define FW_VER_TYPE_PVT         (1) //B0.01
#define FW_VER_TYPE_FORMAL      (2) //V0.01
#define FW_VER_TYPE_TEST        (3) //T0.01

////#define FW_VER_TYPE FW_VER_TYPE_FORMAL
////#define FW_VER_NUM  (131000)   //V1.31
//
////#define FW_VER_TYPE FW_VER_TYPE_TEST
////#define FW_VER_NUM  (29000)   //T0.29

//SPECIFY FIRMWARE VERSION
//#define FW_VER_TYPE FW_VER_TYPE_DEVELOP
//#define FW_VER_NUM  (17)    //D0.17: 20210728
//#define FW_VER_NUM  (18)    //D0.18: 20210729
//#define FW_VER_NUM  (19)    //D0.19: 20210730
//#define FW_VER_NUM  (20)    //D0.20: 20210803
//#define FW_VER_NUM  (21)    //D0.21: 20210813
//#define FW_VER_NUM  (22)    //D0.22: 20210823
//#define FW_VER_NUM  (23)    //D0.23: 20210906
//#define FW_VER_NUM  (24)    //D0.24: 20210908
//#define FW_VER_NUM  (25)    //D0.25: 20210915
//#define FW_VER_NUM  (26)    //D0.26: 20210924
//#define FW_VER_NUM  (27)    //D0.27: 20210930
//#define FW_VER_NUM  (28)    //D0.28: 20211007
//#define FW_VER_NUM  (29)    //D0.29: 20211101
//#define FW_VER_NUM  (30)    //D0.30: 20211122

//#define FW_VER_TYPE FW_VER_TYPE_PVT
//#define FW_VER_NUM  (31)    //B0.31: 20211206
//#define FW_VER_NUM  (32)    //B0.32: 20211215
//#define FW_VER_NUM  (33)    //V0.33/B0.33: 20220415
//#define FW_VER_NUM  (34)    //V0.34/B0.34: 20230210
//#define FW_VER_NUM  (35)    //V0.35/B0.35: 20230224
//#define FW_VER_NUM  (36)    //V0.36/B0.36: 20230414 test

//AW48 Version from here --------------------------------
#define FW_VER_TYPE FW_VER_TYPE_DEVELOP
//#define FW_VER_NUM  (1000)    //D0.01: 20230904
//#define FW_VER_NUM  (3000)    //D0.02: 20231019
//#define FW_VER_NUM  (3000)    //D0.03: 20231023
//#define FW_VER_NUM  (4000)    //D0.04: 20231031 Test


//#define FW_VER_NUM  (10000)    //D0.10: 20231108 (SBSFU from this version)
//#define FW_VER_NUM  (11000)     //D0.11: 20231215

#define FW_VER_NUM  (14000)    //D0.14: 20241112
//---------------------------------------------------------------
#if (FW_VER_NUM >= 17)  //>= D0.17
#define FUNC_ZEROING_WHEN_MEM_CLEARNED
#define FUNC_METER_IC_VARIABLE_PARAM    //AX32/48 have different resistance
#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 18)  //>= D0.18
//Modify KP, KE to KP_AX48/32 KE_AX48/32 in FUNC_METER_IC_VARIABLE_PARAM
#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 19)  //>= D0.19
#define FUNC_CHECK_MODELNAME_AX_PRIFIX
#define FUNC_METER_IC_DEFAULT_CALI_VAL
#define FUNC_METER_IC_CHECK_WHETHER_DEFAULT_CALI_VAL
#endif

//---------------------------------------------------------------
#if (FW_VER_NUM >= 20)  //>= D0.20

#define MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_ALARM_CODE
#define MODIFY_AW_CP_TASK_CSU_0_1_CHARGING_MODE_STOP_WITHOUT_STATE_C

#define FUNC_METER_IC_CALI_FLAG

#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 21)  //>= D0.21

#define FUNC_IDLE_UNTIL_READ_ALL_MEM

#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 22)  //>= D0.22

#define FUNC_VOLATILE_OPERATION
#ifdef FUNC_VOLATILE_OPERATION
#define VO_SIMU_CP
#define VO_SIMU_PP
#define VO_DISABLE_RELAY_WELDING
#endif //FUNC_VOLATILE_OPERATION

#define MODIFY_ALARM_CP_ERROR_RECOVER_USE_RESTORE
#define MODIFY_ALARM_CP_NEG_ERROR_RECOVER_USE_RESTORE
#define MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE

#define FUNC_CURRENT_CP_PWM_DATA

#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 23)  //>= D0.23

#define FUNC_ROTARY_CURR_MAP
#define FUNC_ROTARY_SLAVE_MODE

#define MODIFY_LED_STATUS_202108

#ifdef FUNC_VOLATILE_OPERATION
#define VO_BLOCK_CSU_LED_ACTION_CMD
#endif

#define MODIFY_BREATHE_LED
#ifdef MODIFY_BREATHE_LED
#define BREATHE_LED_UP_SPEED   (800)
#define BREATHE_LED_DN_SPEED   (2200)
#endif

//#define FUNC_SHOW_CSU_CONFIG_LED_ACTION_INFO

#define MODIFY_LED_ALARM_LATCH
#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 24)  //>= D0.24

//-----------------------------------------------
//GB Model:
//Handshake Mode:   CP to D or E => Stop PWM
//Charging Mode:    CP to D or E => Stop PWM
//Stop Mode:        CP to D or E => Stop PWM
#define FUNC_RULE_GB_202108
#ifdef FUNC_RULE_GB_202108
#define FUNC_BLOCK_CSU_CONFIG_CP_PWM_DUTY
#define MODIFY_MODE_HANDSHAKE_STOP_PWM_WITHOUT_OK_STATE
#define MODIFY_MODE_CHARGING_STOP_PWM_WITHOUT_OK_STATE
#define MODIFY_MODE_STOP_STOP_PWM_WITHOUT_OK_STATE
#endif //FUNC_RULE_GB_202108
//-----------------------------------------------

#define MODIFY_CORRECTION_CHECK
#define TRIM_CCID_SELFTEST

//#define FUNC_CSU_CMD_DEBUG
//#define DEBUG_RELAY_MONITOR_SHOW_INFO //DISABLE when test done *****
//#define DISABLE_RELAY_WELDING_PROTECT //DISABLE when test done *****

#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 25)  //>= D0.25

#define MODIFY_AX32_ROTATE_SWITCH_TABLE_20210915

#define FUNC_CHECK_REQ_AND_CP_WHEN_SET_CP_PWM

#define FUNC_GUN_LOCK
#ifdef FUNC_GUN_LOCK
#define GUN_LOCK_ALARM
#endif

#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 26)  //>= D0.26

#define FUNC_OCP_WITH_PP

#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 27)  //>= D0.27

//DIE_VERSION (MeterIC)

#define FUNC_IDLE_UNTIL_INIT_METER_IC

#ifdef FUNC_VOLATILE_OPERATION
#define VO_GET_VO_CODE
#define VO_SIMU_ACV
#define VO_SIMU_NTC
#define VO_SIMU_ALARMCODE
#endif

#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 28)  //>= D0.28

//Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total =
// Modify FUNC_DEBUG_MSG_CP_STATE Position

//#define FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
//#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
//#define FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
//#define FUNC_MODE_DEBUG_RELAY_ON_SEC    (4)
//#define FUNC_MODE_DEBUG_RELAY_OFF_SEC   (9)
//#define FUNC_MODE_DEBUG_REC_RELAY_ON_TIMES
//#endif
//#define DISABLE_RELAY_WELDING_PROTECT //TEMP !!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//#define DISABLE_PRINT_DEBUG_MSG
//#define DISABLE_PRINT_RTOS_MSG

#define MODIFY_ADC_WELDING_CALCULATE_METHOD
//#define DEBUG_RELAY_MONITOR_SHOW_INFO //DISABLE when test done *****
#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 29)  //>= D0.29

#define MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK

#define FUNC_USE_RELAY_B_CONTACT //AX32 Regulation-EU Welding Detection (on New PCB & Relay)
#ifdef FUNC_USE_RELAY_B_CONTACT
////#define DISABLE_USE_RELAY_B_CONTACT_WITH_DC_MODELNAME
#endif

//#define FUNC_CSU_CMD_DEBUG

#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 30)  //>= D0.30

#define MODIFY_LED_YELLOW_PARAMETER
#ifdef MODIFY_LED_YELLOW_PARAMETER
#define LED_YELLOW_R_VAL   (1000)
#define LED_YELLOW_G_VAL   (500)
#endif

#define MODIFY_OTP_SPEC //AX48 (Test OK) AX32 (Test OK)

#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 31)  //>= B0.31

#define MODIFY_CP_DETECTION_STATE_F		//Modify the identifiable CP signal State F (-12V)

#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 32)  //>= B0.32(T0.32)


#define MODIFY_DC_RS485_UPGRADE_ISSUE
//#define MODIFY_OCP_MAGNIFICATION //RULE CE: fix OCP Magnification
#define FUNC_CCS //CCS mode charging test with AUDI E-Tron
#define FIX_FUNC_CHECK_REQ_AND_CP_WHEN_SET_CP_PWM	//Fixed the problem that the basic model (without CSU) cannot output PWM

#ifdef FUNC_CURRENT_CP_PWM_DATA
#define FUNC_DISP_CURRENT_CP_PWM
#endif

#define DISABLE_METER_IC_IRQ_INTERRUPT

#ifdef METER_IC_COMM_TIMEOUT
#undef METER_IC_COMM_TIMEOUT
#define METER_IC_COMM_TIMEOUT   (5000) //ms
#endif

#ifdef METER_IC_USE_TASK_CRITICAL
#undef METER_IC_USE_TASK_CRITICAL
#endif

#define MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_MODE_CHARGING

#define MODIFY_CP_STATE_F_SAMPLE_NUM_THRESHOLD
#define CP_STATE_F_SAMPLE_NUM_THRESHOLD     (830)

#define FUNC_XP_PARSE_VERSION_INFO_FROM_MODELNAME
#define FUNC_IGNORE_ILLEGAL_MODEL_NAME
#define MODIFY_AC_EVSE_STATUS_MAX_CHARGING_CURRENT_VARIABLE
#define FUNC_BUILD_DATE_TIME
#define MODIFY_CPTASK_CSU_MODE_ALARM_GO_HANDSHAKE_WITH_NEW_CONDITION

#define MODIFY_NO_CP_PWM_WHEN_SOCKET_E_IS_ON
#define MODIFY_SOCKET_E_OCP_USE_MAX_CHARGING_CURRENT

//Testing !
//#define FORCE_VER_WITH_T_PREFIX //T0.32
//#define FUNC_CSU_CMD_DEBUG
//#define DISABLE_USE_RELAY_B_CONTACT_WITH_AX32_OLD_PCB //Only for old AX32 PCB !!!
//Testing !

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

#if (FW_VER_NUM >= 33)  //>= V0.33/B0.33/T0.33

#define FUNC_AX32_TRIG_LEAKAGE

#define FUNC_PTB_METER_WM3M4C
#ifdef FUNC_PTB_METER_WM3M4C
#define METER_WM3M4C_DEV_ADDR   (0x21)
//#define DEBUG_PTB_METER_WM3M4C
//#define DEBUG_METER_RS485
#endif

#define FUNC_WAIT_METER_IC_INIT_OK

#define RECODE_FUNC_METER_IC_TASK

#define RECODE_FUNC_METER_TASK
#ifdef RECODE_FUNC_METER_TASK
#define RECODE_METER_PRO380
#ifdef RECODE_METER_PRO380
#define METER_PRO380_DEV_ADDR   (0x01)
#endif
#endif //RECODE_FUNC_METER_TASK

#define METER_IC_USE_TASK_CRITICAL

#define MODIFY_METER_IC_TASK_PRIORITY

#define MODIFY_UART_TX_LEN_FROM_U8_TO_U16

#define MODIFY_CHECK_MALLOC_RESAULT
#define MODIFY_CAL_MALLOC

#define MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
#define GUN_LOCK_PULSE_MAX_TIMES (0x1000) //0xFFFF
#define GUN_LOCK_PULSE_MAX_TIMES_CAUSE_ALARM (10)
#endif

////#define DISABLE_OS_ETH_TASK (USB Initial process included)

#define FUNC_ENABLE_TYPE_E_ONLY_IN_AX32
#define MODIFY_OS_ADC_TASK_DEFINE_DATA

#ifdef FUNC_VOLATILE_OPERATION
#define VO_SIMU_ACA
#endif

#define FUNC_TASK_MONITOR

#define MODIFY_SET_CP_PWM_DUTY_WHEN_GET_NEW_VAL

#define MODIFY_CP_NEG_JUDGMENT_PROCESS

#define FUNC_AX32_USE_AS_1P_MODEL
////#ifdef FUNC_AX32_USE_AS_1P_MODEL
//////#define INPUT_VOLTAGE_WITHOUT_CONNECTION_MAX (2000) //unit: 0.01V (20V)
////#define INPUT_VOLTAGE_WITHOUT_CONNECTION_MAX (13000) //unit: 0.01V (130V)
////#endif

//----------------------------------------------- [AX80]
#define FUNC_AX80
#ifdef FUNC_AX80
#define FUNC_AX80_ADD_4_TEMP_SENEOR

#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
#define FUNC_AX80_NEW_TEMP_SENSOR_COMPENSATION
#endif

//#define FUNC_AX80_ADD_TILT_SENSOR

#ifdef FUNC_AX80_ADD_TILT_SENSOR
#define VO_DISABLE_DETECT_TILT_SENSOR
#endif
#endif //FUNC_AX80

//----------------------------------------------- [From AW_P V0.09]
#define FUNC_CP_VARIABLE_MAX_STATE_COUNTER
#define FUNC_CP_VARIABLE_MAX_STATE_COUNTER_C_TO_D_SET_3_FOR_PASS_TERTEC_TEST
#define FUNC_GET_TRIP_TIME

//----------------------------------------------- [From AW_P V0.10]
////#define FUNC_REPLACE_CORMEX_WITH_VAC_FOR_CNS_MODEL
////#define FUNC_AUTO_MODIFY_CCID_MODULE

#define FUNC_CSU_CMD_DEBUG

#define TEST_FOR_ENERGY_STAR
#ifdef TEST_FOR_ENERGY_STAR
#ifdef BREATHE_LED_UP_SPEED
#undef BREATHE_LED_UP_SPEED
#define BREATHE_LED_UP_SPEED     (2500) //(800)
#endif
#ifdef BREATHE_LED_DN_SPEED
#undef BREATHE_LED_DN_SPEED
#define BREATHE_LED_DN_SPEED     (2500) //(2200)
#endif
#endif //TEST_FOR_ENERGY_STAR

#define FUNC_BLOCK_CSU_CMD_SET_DUTY_WHEN_ALARM_CP_F_STATE

#define MODIFY_OCP_PROC_WITH_MODELNAME_IDX_3_EURO_SPEC

//#define FUNC_TEST_PRO380_INIT_DE_HIGH_1_SEC
#define FUNC_TEST_PRO380_TIMEOUT_DE_HIGH_X_MS
#ifdef FUNC_TEST_PRO380_TIMEOUT_DE_HIGH_X_MS
#define TEST_PRO380_TIMEOUT_DE_HIGH_X_MS_PERIOD (1000) //(600)
#endif

#define FUNC_METER_IC_READ_PHASE_ANGLE

#define AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX48_MODELNAME_WITH_CSU
//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX //T0.33

//#define DISABLE_USE_RELAY_B_CONTACT_WITH_AX32_OLD_PCB //Only for old AX32 PCB !!!
//#define DISABLE_PRINT_DEBUG_MSG
//#define DISABLE_PRINT_RTOS_MSG
//#define TEST_METER_PRO380_AND_WM3M4C_AT_THE_SAME_TIME_USE_MODELNAME_IDX_3_X
//#define TEST_RELAY_DRIVE_WITHOUT_HOLD

//#define DISABLE_OVP_PROTECT
//#define DISABLE_UVP_PROTECT
//#define DISABLE_OCP_PROTECT
//#define DISABLE_OTP_PROTECT
//#define DISABLE_CCID_PROTECT

//#define FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
//#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
//#define FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
//#define FUNC_MODE_DEBUG_RELAY_ON_SEC    (4)
//#define FUNC_MODE_DEBUG_RELAY_OFF_SEC   (9)
//#define FUNC_MODE_DEBUG_REC_RELAY_ON_TIMES
//#endif //FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE

//Testing !
//-----------------------------------------------
#endif
//---------------------------------------------------------------

#if (FW_VER_NUM >= 34)  //>= V0.34/B0.34/T0.34
//Fix CE OCP specification
//undefine MODIFY_OCP_MAGNIFICATION

//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX //T0.34
//#define KENNY_SAFETY_TEST_RELAY_ALWAYS_ON
//#define DISABLE_GROUND_FAULT_PROTECT
//Testing !
//-----------------------------------------------
#endif
//---------------------------------------------------------------

#if (FW_VER_NUM >= 35)  //>= V0.35/B0.35/T0.35
#define FIX_OUTP_PWM_WHEN_ALARM_RECOVER_IN_4SEC
#define MODIFY_GOT_CSU_DUTY_CMD_PROCESS
//Modify in FUNC_AX32_USE_AS_1P_MODEL
////#define MODIFY_AX32_RUN_3P_AND_1P_AFTER_GENERATION_CODE_5
//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX //T0.35

//#define FUNC_DISABLE_SOME_ALARM_FOR_ATE_SITE_SAMPLE_TEST
//#ifdef FUNC_DISABLE_SOME_ALARM_FOR_ATE_SITE_SAMPLE_TEST
//#define FORCE_VER_WITH_F_PREFIX //F0.35 only test in facrory
//#define DISABLE_CCID_PROTECT
//#define DISABLE_GROUND_FAULT_PROTECT
//#define DISABLE_OVP_PROTECT
//#define DISABLE_UVP_PROTECT
//#define DISABLE_OCP_PROTECT
//#endif

//#define DISABLE_CCID_PROTECT

//Testing !
//-----------------------------------------------
#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 36)  //>= V0.36/B0.36/T0.36

#define FUNC_RELAY_OFF_WHEN_CSU_CMD_TIMEOUT
#ifdef FUNC_RELAY_OFF_WHEN_CSU_CMD_TIMEOUT
#define CSU_CMD_TIMEOUT_SEC (10)
#endif

#define FUNC_AT32

//Modify in FUNC_AX32_USE_AS_1P_MODEL
#define MODIFY_AX32_RUN_3P_OR_1P_AUTOMATIC_AFTER_GC5 //AFTER_GENERATION_CODE_5

#define FUNC_RELAY_OFF_WHEN_GET_TWICE_OFF_CMD
//#define FUNC_REQUEST_OFF_WHEN_GET_TWICE_OFF_CMD
#define FUNC_REQUEST_OFF_WHEN_CSU_CMD_TIMEOUT
#define FUNC_ADD_FW_VER_WITH_GUN_TYPE_NACS
#define FUNC_ADD_FW_VER_WITH_NET_TYPE_WIFI_AND_4G
#define FUNC_SHOW_CSU_CONFIG_LED_ACTION_INFO

#define FUNC_BOOT_TICK

#define FUNC_RESET_DATA_AFTER_WRITE_NEW_MODELNAME

//Modify METER_EXT_COMM_TIMEOUT from 10s to 15s

//#define FUNC_DEBUG_CONSOLE

//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX //T0.36

//#define FUNC_FORCE_USE_METER_EXT_PRO380

//#define FUNC_DC_AUTO_RELAY_OFF

//------------------------------
////#define REDUCE_RELAY_CUT_OFF_TIME_WHEN_CP_C_TO_A
//#ifdef REDUCE_RELAY_CUT_OFF_TIME_WHEN_CP_C_TO_A
//#ifdef HTK_USE_XPRINT
//#undef HTK_USE_XPRINT
//#endif
//#define DISABLE_PRINT_DEBUG_MSG
//#define DISABLE_PRINT_RTOS_MSG
//#endif //REDUCE_RELAY_CUT_OFF_TIME_WHEN_CP_C_TO_A
//------------------------------
//#define FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
//#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
//#define FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
//#define FUNC_MODE_DEBUG_RELAY_ON_SEC    (4)
//#define FUNC_MODE_DEBUG_RELAY_OFF_SEC   (9)
//#define FUNC_MODE_DEBUG_REC_RELAY_ON_TIMES
//
//#define FUNC_MODE_DEBUG_WITH_NORMAL_ALARM_DETECTE
//#define FUNC_MODE_ALARM_TO_MODE_DEBUG
//#endif //FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE

//#define DISABLE_PRINT_DEBUG_MSG
//#define DISABLE_PRINT_RTOS_MSG

//#define DISABLE_OCP_PROTECT
//#define DISABLE_OTP_PROTECT
//#define DISABLE_CCID_PROTECT
//#define TEST_GROUND_FAULT_PROTECT_TIME_TO_15_SEC
//Testing !
//-----------------------------------------------
#endif
//---------------------------------------------------------------
//AW48 first version
#if (FW_VER_NUM >= 1000)  //>= D0.01

#define AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX32_MODELNAME_WITH_CSU

#define FUNC_UPDATE_ROTARY_SWITCH_SETTING_AFTER_PARSE_MODELNAME

#define FUNC_FLASH_UPDATE_CONFIG_BOTH_PRIMARY_AND_BACKUP
#define FUNC_FLASH_RESTORE_CONFIG_WHEN_PRIMARY_LOSS
#define FUNC_FLASH_CONFIG_APPEND_CRC

#define FUNC_STM32_FLASH_INFO
#define FUNC_STM32_FLASH_OPTION_BYTES

//Modify METER_EXT_COMM_TIMEOUT from 15s to 30s

//*********************** [AW48 Beg]
#define FUNC_AW48

#ifdef FUNC_AW48
#define FUNC_RS485_BLE_SW
#define FUNC_LIN_EN_SW
#define FUNC_LIN_CP
#ifdef FUNC_LIN_CP
#define FUNC_ENABLE_USART1_LIN_LL_LIB
#define FUNC_LIN_MASTER
//#define DEBUG_LIN_CP
//#define FUNC_LINCP_DISPLAY


#else //FUNC_LIN_CP
#define FUNC_ENABLE_USART1_RFID
#endif //FUNC_LIN_CP

#if (defined(FUNC_ENABLE_USART1_RFID) && defined(FUNC_ENABLE_USART1_LIN_LL_LIB))
	#pragma message("====== !!! DEFINE ERROR! MUST DEFINE ONLY ONE FUNC_ENABLE_USART1_XXXXX ITEM !!! ======")
#endif


#define FUNC_EKM_OMNIMETER
#ifdef FUNC_EKM_OMNIMETER
#define FUNC_EKM_OMNIMETER_DISPLAY
#endif
//#define DEBUG_METER_RS485

#define FUNC_AW48_ADD_6_TEMP_SENEOR

#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
#define FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION
#endif

#define MODIFY_AW48_OTP_SPEC_20231006_KENNY

#define FUNC_WARNING_CODE

//LED
#define FUNC_AW48_NET_LED
#define FUNC_AW48_EXT_LED
#define FUNC_AW48_EXT_LED_BLINK_PERIOD_MORE_THAN_200MS
#define AW48_EXTLED_BLINK_PERIOD  (230) //ms
#define MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE

#define FUNC_AW48_NO_SLEEP_MODE_LED

#define FUNC_MODIFY_AW48_LED_ACTION_TERMINATED_COMPLETE

//--------------------------------
#define FUNC_AES256
#define FUNC_ECDSA

#define FUNC_CSU_SIGN_IN_VERIFY
#define FUNC_CSU_UPGRADE_FW_VERIFY

#define FUNC_CSU_VERIFY_USE_ECDSA
#ifdef FUNC_CSU_VERIFY_USE_ECDSA
#define FUNC_CSU_VERIFY_USE_ECDSA_CMOX_ECC_CURVE_SECP256R1
#endif

#define FUNC_ENABLE_CSU_SIGN_IN_WHEN_MCU_HAVE_NG_MODELNAME //SIGN-IN-OK ===> CSU Write ModelName to MCU

#define FUNC_SALT_AND_BLEND
#ifdef FUNC_SALT_AND_BLEND
//#define FUNC_SALT_AND_BLEND_DEBUG
#endif

#define FUNC_VERIFY_TASK

#define FUNC_CSU_PUBLIC_KEY_OPERATION

//#define FUNC_SECURITY_DEBUG_INFO
//--------------------------------

//NG PCB
#define RELAY_COMMON_GPIO
//PinNo	Tag	    AX80	        AX48	        AX32	        AW32	        AW48 (NG LAYOUT)
//99	PC9	    RELAY-DRV-L1	RELAY-DRV-L1	RELAY-DRV-L1	RELAY-DRV-L1	Hold-L2
//100	PA8	    Hold-L1	        Hold-L1	        Hold-L1	        Hold-L1	        RELAY-DRV-L2
//101	PA9	    RELAY-DRV-L2	RELAY-DRV-L2	RELAY-DRV-L2	RELAY-DRV-L2	Hold-L1
//102	PA10	Hold-L2	        Hold-L2	        Hold-L2	        Hold-L2	        RELAY-DRV-L1

//#define FIXHW_AW48_CSU_EXIST_DELAY_CHECK //Old CSU: Pull LO; New CSU Pull HI (need wait initial time to set LO)

#endif //FUNC_AW48
//*********************** [AW48 End]

//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX //T0.01
//#define DISABLE_OCP_PROTECT
//#define DISABLE_OTP_PROTECT
//#define DISABLE_CCID_PROTECT
//Testing !
//-----------------------------------------------
#endif
//---------------------------------------------------------------
#if (FW_VER_NUM >= 2000)  //>= D0.02

//Skip this version

//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX
//Testing !
//-----------------------------------------------
#endif //(FW_VER_NUM >= 2000)
//---------------------------------------------------------------
#if (FW_VER_NUM >= 3000)  //>= D0.03

#ifdef MODIFY_CHECK_MALLOC_RESAULT
#undef MODIFY_CHECK_MALLOC_RESAULT
#endif

#ifdef MODIFY_CAL_MALLOC
#undef MODIFY_CAL_MALLOC
#endif

#define FUNC_UART_IAP_TX_BUF_INIT_ZERO

#define FUNC_GUN_LOCK_TRIG_MODE

#define FUNC_ADD_AC_DC_LEAK_TIMER

//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX
//Testing !
//-----------------------------------------------
#endif //(FW_VER_NUM >= 3000)
//---------------------------------------------------------------
#if (FW_VER_NUM >= 4000)  //>= D0.04


//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX
//Testing !
//-----------------------------------------------
#endif //(FW_VER_NUM >= 4000)
//---------------------------------------------------------------
#if (FW_VER_NUM >= 5000)  //>= D0.05

#define FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION_20231214
//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX
//Testing !
//-----------------------------------------------
#endif //(FW_VER_NUM >= 5000)
//---------------------------------------------------------------
#if (FW_VER_NUM >= 6000)  //>= D0.06

#define FUNC_TEMP_SENSOR_WITH_NEG_VALUE
#define FUNC_SHOW_CORRECTION_DATA
#define FUNC_SHOW_RELAY_INFO
#define FUNC_MODIFY_LEAK_AC_DISPLAY
#define FUNC_MODIFY_CP_PWM_CTRL_20231225

#ifdef FUNC_TASK_MONITOR
#define FUNC_MODIFY_TASK_MONITOR_20231227
#endif

#define MODIFY_CHECK_MALLOC_RESAULT
#define MODIFY_FUNC_CRMS_CAL
#define MODIFY_FUNC_GFRMS_CAL
#define MODIFY_FUNC_VRMS_CAL2

#define MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_CP_PWM
//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX
//Testing !
//-----------------------------------------------
#endif //(FW_VER_NUM >= 6000)
//---------------------------------------------------------------
#if (FW_VER_NUM >= 7000)  //>= D0.07
#define AW48_NEW_PCB_WITH_CORRECT_RELAY_PIN

//-------
#define FUNC_CUSTOMIZED_LED_MODE_FROM_CSU

#define FUNC_QUERY_METER_IC_DIE_VERSION
//#define FUNC_FORCE_QUERY_METER_IC_DIE_VERSION_2 //for CNS

//------- [New AX48 NACS PCB with AW48 new HW feature]
#define FUNC_AX48_NACS
#ifdef FUNC_AX48_NACS
#define FUNC_AX48_NACS_ADD_6_TEMP_SENEOR

#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#define FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION
#endif

#define MODIFY_AX48_NACS_OTP_SPEC_20231006_KENNY
#define FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION_20231214

#define FUNC_DETECT_PP_NACS

#endif //FUNC_AX48_NACS
//------- [New AX48 NACS PCB with AW48 new HW feature]

//------- [New AX80 NACS PCB with AW48 new HW feature]
#define FUNC_AX80_NACS
#ifdef FUNC_AX80_NACS
//#define FUNC_AW48 //From AW48 Model
//#define FUNC_AW48_ADD_6_TEMP_SENEOR //From AW48 Model
#define FUNC_AX80_NACS_ADD_6_TEMP_SENEOR

#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
#define FUNC_AX80_NACS_NEW_TEMP_SENSOR_COMPENSATION
#endif

#define MODIFY_AX80_NACS_OTP_SPEC_20231006_KENNY
#define FUNC_AX80_NACS_NEW_TEMP_SENSOR_COMPENSATION_20231214

//#define FUNC_DETECT_PP_NACS

#endif //FUNC_AX80_NACS
//------- [New AX80 NACS PCB with AW48 new HW feature]

//#define FUNC_DISABLE_USART2_TO_PASS_AW48_RF_TEST_20240116_DEKRA
#define FUNC_SET_AT32_MODEL_SCP_SPEC_VAL_HIGHER_TO_AVOID_SCP_ALARM

#define FUNC_ADD_TILT_SENSOR_MODEL
#define FUNC_DISABLE_TILT_SENSOR_FOR_TEST

//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX
//#define FUNC_DISP_MCU_CLOCK_INFO
//#define FUNC_TEST_SET_CSU_MOUNT_PIN_NOPULL //pin floating, abandoned
//Testing !
//-----------------------------------------------
#endif //(FW_VER_NUM >= 7000)
//---------------------------------------------------------------
#if (FW_VER_NUM >= 8000)  //>= D0.08

#define MODIFY_AW48_WELDING_THRESHOLD_KENNY_20240418

#define FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION_20240415

#define FUNC_AX32_AUTO_PHASE_WITHOUT_GENERATION_CODE
#define FUNC_SUPPORT_MODEL_AXYC
#define FUNC_AXSJ_USE_NEW_NACS_PCB

#define MODIFY_AW48_CCID_UL_SPEC_KENNY_20240401
#define FUNC_AW48_KENNY_TEST_DOUBLE_GF_ADC_VAL
//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX
//Testing !
//-----------------------------------------------
#endif //(FW_VER_NUM >= 8000)
//---------------------------------------------------------------
#if (FW_VER_NUM >= 9000)  //>= D0.09
#define FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION_20240508
//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX
//Testing !
//-----------------------------------------------
#endif //(FW_VER_NUM >= 9000)
//---------------------------------------------------------------
#if (FW_VER_NUM >= 10000)  //>= D0.10

#define FUNC_USE_STM32_SBSFU
#ifdef FUNC_USE_STM32_SBSFU
#include "../../Linker_Common/EWARM/STM32_SBSFU_Define.h"
#endif

#define FUNC_TMP100
#define FUNC_AX48_NACS_TEMP_SENSOR_WITHOUT_COMPENSATION_20240521
#define DEBUG_SHOW_AX48_NACS_TEMP_SENSOR_ADC_COUNT
#define FUNC_AX48_NACS_TEMP_SENSOR_COMPENSATION_AND_MODIFY_FORMULA_20240522 //Steven
#define MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#define FUNC_AX48_NACS_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523 //Steven

#define FUNC_AW48_TEMP_SENSOR_WITHOUT_COMPENSATION_20240521
#define DEBUG_SHOW_AW48_TEMP_SENSOR_ADC_COUNT
#define FUNC_AW48_TEMP_SENSOR_COMPENSATION_AND_MODIFY_FORMULA_20240522 //Steven
#define MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#define FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523 //Steven

#define FUNC_MODIFY_OTP_RECOVER_PROCESS

#define FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240729 //Jack
#define MODIFY_AW48_OTP_SPEC_20240729_JACK

#define MODIFY_AW48_OTP_SPEC_20240802_STEVEN //=> New Group4

#define FUNC_TEMP_SET_MAXMIN_WHEN_OUT_OF_SPEC
#define FUNC_GUN_TEMP_LATCH
#define FUNC_UNPLUG_GUN_TO_RELEASE_TEMP_LATCH

#define MODIFY_AW48_OTP_SPEC_20240809_JACK

#define MODIFY_AW48_OTP_SPEC_20240814_KENNY

#define MODIFY_AW48_OTP_SPEC_20240819_JACK

#define MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN //=> New Group4

#define FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20241007

#define MODIFY_AW48_OTP_SPEC_20241016_JACK

#define ADD_AX_NACS_PCB_USE_GEN_CODE_3

#define FUNC_AX80_NACS_TEMP_SENSOR_WITHOUT_COMPENSATION_20240903
#define DEBUG_SHOW_AX80_NACS_TEMP_SENSOR_ADC_COUNT

#define FUNC_AX80_NACS_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240906 //Jack

#define MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK //=> New Group4

#define AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX80_MODELNAME_WITH_CSU

#define FUNC_SYSTEM_KEEP_INFO
//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX
//#define FUNC_VERSION_FOR_LAB_CERTIFICATE_SPEC

//#define DISABLE_OTP_PROTECT

//#define TEST_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523_REMOVE_COMPENSATION

//#define DISABLE_UVP_PROTECT

//#define FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
//#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
//#define FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
//#define FUNC_MODE_DEBUG_RELAY_ON_SEC    (4)
//#define FUNC_MODE_DEBUG_RELAY_OFF_SEC   (9)
//#define FUNC_MODE_DEBUG_REC_RELAY_ON_TIMES
//#endif


//***************************************************************************
//#define FUNC_AX80_ADD_TILT_SENSOR >>>> SHOULD BE COMMENT
//***************************************************************************
//Testing !
//-----------------------------------------------
#endif //(FW_VER_NUM >= 10000)
//---------------------------------------------------------------
#if (FW_VER_NUM >= 11000)  //>= D0.11

#define FUNC_VERSION_USE_NEW_SPEC_20240926 //define FUNC_VERSION_FOR_LAB_CERTIFICATE_SPEC (xx.xx.A1) else (xx.xx.A0)

//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX
//#define FUNC_VERSION_FOR_LAB_CERTIFICATE_SPEC
//#define DISABLE_CCID_PROTECT
//Testing !
//-----------------------------------------------
#endif //(FW_VER_NUM >= 11000)
//---------------------------------------------------------------
#if (FW_VER_NUM >= 12000)  //>= D0.12

//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX
//Testing !
//-----------------------------------------------
#endif //(FW_VER_NUM >= 12000)
//---------------------------------------------------------------
#if (FW_VER_NUM >= 13000)  //>= D0.13

//-----------------------------------------------
//Testing !
//#define FORCE_VER_WITH_T_PREFIX
//Testing !
//-----------------------------------------------
#endif //(FW_VER_NUM >= 13000)
//---------------------------------------------------------------
#if (FW_VER_NUM >= 14000)  //>= D0.14
#define MODIFY_FLASH_OPERATION_20241104
#define FUNC_CALC_FLASH_CRC_IN_CRITICAL
#define FUNC_RESET_CONNECTOR_PLUGIN_TIMES
//-----------------------------------------------
//Testing !
#define FORCE_VER_WITH_T_PREFIX
//Testing !
//-----------------------------------------------
#endif //(FW_VER_NUM >= 14000)
//---------------------------------------------------------------
//---------------------------------------------------------------
//---------------------------------------------------------------
//---------------------------------------------------------------
//---------------------------------------------------------------


#endif //FUNC_FW_VER_TRACE
//******************************************************************

//Type define
#ifdef HTK
#ifdef HTK_USE_XPRINT
#define XP(FMT, ARGS...)    (printf(FMT, ##ARGS))
#else
#define XP(FMT, ARGS...)
#endif

//#define HTK_USE_XPRINT_TEST
#ifdef HTK_USE_XPRINT_TEST
#define XT(FMT, ARGS...)    (printf(FMT, ##ARGS))
#define XRowWidth(c, count) (HTK_PrintRow((c), (count)))
#define XRowS(c)            (HTK_PrintRow((c), (20)))
#define XRowM(c)            (HTK_PrintRow((c), (40)))
#define XRowL(c)            (HTK_PrintRow((c), (80)))
#else
#define XT(FMT, ARGS...)
#define XRowWidth(c, count)
#define XRowS(c)
#define XRowM(c)
#define XRowL(c)
#endif

typedef uint8_t byte;
typedef int8_t sbyte;

typedef int64_t         s64;
typedef int32_t         s32;
typedef int16_t	        s16;
typedef int8_t          s8;
typedef const int64_t   sc64;
typedef const int32_t   sc32;
typedef const int16_t 	sc16;
typedef const int8_t 	sc8;
typedef __IO int64_t    vs64;
typedef __IO int32_t    vs32;
typedef __IO int16_t    vs16;
typedef __IO int8_t     vs8;
typedef __I int64_t     vsc64;
typedef __I int32_t     vsc32;
typedef __I int16_t     vsc16;
typedef __I int8_t 	    vsc8;

typedef uint64_t  	    u64;
typedef uint32_t  	    u32;
typedef uint16_t	    u16;
typedef uint8_t  	    u8;
typedef const uint64_t 	uc64;
typedef const uint32_t 	uc32;
typedef const uint16_t 	uc16;
typedef const uint8_t 	uc8;
typedef __IO uint64_t 	vu64;
typedef __IO uint32_t 	vu32;
typedef __IO uint16_t 	vu16;
typedef __IO uint8_t  	vu8;
typedef __I uint64_t 	vuc64;
typedef __I uint32_t 	vuc32;
typedef __I uint16_t	vuc16;
typedef __I uint8_t 	vuc8;

#define HTK_NULL 	0

#define HTK_UNUSED(X) (void)X      /* To avoid gcc/g++ warnings */

typedef u8 HTK_BOOL;
#define HTK_TRUE 	1
#define HTK_FALSE 	0

#define HTK_ENABLE 	1
#define HTK_DISABLE 0

#define BIT_FLAG_VAL(pos)       (1U << (pos))
#define BIT_SET(x, pos)         ((x) |= BIT_FLAG_VAL(pos))
#define BIT_CLEAR(x, pos)       ((x) &= (~BIT_FLAG_VAL(pos)))
#define BIT_TOGGLE_(x, pos)     ((x) ^= BIT_FLAG_VAL(pos)
#define BIT_CHECK(x, pos)       ((x) & BIT_FLAG_VAL(pos))

#define BIT_GET(x, pos)         (((x) & BIT_FLAG_VAL(pos)) >> (pos))

#define LOOP_SHIFT_U8(x, n)     (((n) >= 0) ? (((x) << (  8 - (n))) | ((x) >> (n))) : (((x) >> (  8 - ((-1) * (n)))) | ((x) << ((-1) * (n)))))
#define LOOP_SHIFT_U16(x, n)    (((n) >= 0) ? (((x) << ( 16 - (n))) | ((x) >> (n))) : (((x) >> ( 16 - ((-1) * (n)))) | ((x) << ((-1) * (n)))))
#define LOOP_SHIFT_U32(x, n)    (((n) >= 0) ? (((x) << ( 32 - (n))) | ((x) >> (n))) : (((x) >> ( 32 - ((-1) * (n)))) | ((x) << ((-1) * (n)))))

u8 GetBit1Num(u32 x);

//Little-Endian
#define HTK_U16_BYTE0(vU16)	    (*(((u8*)&(vU16)) + 0))
#define HTK_U16_BYTE1(vU16)	    (*(((u8*)&(vU16)) + 1))
#define HTK_U16_BYTE(vU16, n)  (*(((u8*)&(vU16)) + (n)))

#define HTK_U16(vU8)		    (*(((u16*)&(vU8)) + 0))

#define HTK_U32_BYTE0(vU32)	    (*(((u8*)&(vU32)) + 0))
#define HTK_U32_BYTE1(vU32)	    (*(((u8*)&(vU32)) + 1))
#define HTK_U32_BYTE2(vU32)	    (*(((u8*)&(vU32)) + 2))
#define HTK_U32_BYTE3(vU32)	    (*(((u8*)&(vU32)) + 3))
#define HTK_U32_BYTE(vU32, n)	(*(((u8*)&(vU32)) + (n)))

#define HTK_U32(vU8)			(*(((u32*)&(vU8)) + 0))

#define HTK_U32_WORD0(vU32)     (*(((u16*)&(vU32)) + 0))
#define HTK_U32_WORD1(vU32)     (*(((u16*)&(vU32)) + 1))
#define HTK_U32_WORD(vU32, n)   (*(((u16*)&(vU32)) + (n)))

//#define HTK_U64_BYTE0(vU64)	    (*(((u8*)&(vU64)) + 0))
//#define HTK_U64_BYTE1(vU64)	    (*(((u8*)&(vU64)) + 1))
//#define HTK_U64_BYTE2(vU64)	    (*(((u8*)&(vU64)) + 2))
//#define HTK_U64_BYTE3(vU64)	    (*(((u8*)&(vU64)) + 3))
//#define HTK_U64_BYTE4(vU64)	    (*(((u8*)&(vU64)) + 4))
//#define HTK_U64_BYTE5(vU64)	    (*(((u8*)&(vU64)) + 5))
//#define HTK_U64_BYTE6(vU64)	    (*(((u8*)&(vU64)) + 6))
//#define HTK_U64_BYTE7(vU64)	    (*(((u8*)&(vU64)) + 7))
//#define HTK_U64_BYTEn(vU64, n)	(*(((u8*)&(vU64)) + (n)))
//
//#define HTK_U64(vU8)			(*(((u64*)&(vU8)) + 0))

//Big-Endian
#define HTK_U16_BE(vU8)		    (                                   \
                                    (HTK_U16_BYTE0(vU8) << 8) |     \
                                    (HTK_U16_BYTE1(vU8) << 0)       \
                                )

#define HTK_U32_BE(vU8)		    (                                   \
                                    (HTK_U32_BYTE0(vU8) << 24) |    \
                                    (HTK_U32_BYTE1(vU8) << 16) |    \
                                    (HTK_U32_BYTE2(vU8) << 8)  |    \
                                    (HTK_U32_BYTE3(vU8) << 0)       \
                                )

#define HTK_GET_VAL_MAX(Val1, Val2)     ((Val1) >= (Val2) ? (Val1) : (Val2))
#define HTK_GET_VAL_MIN(Val1, Val2)     ((Val1) <= (Val2) ? (Val1) : (Val2))
#define HTK_GET_VAL(Bool, Val1, Val2)   ((Bool) ? (Val1) : (Val2))

#define HTK_IS_BETWEEN_MINMAX(v, MinVal, MaxVal)    ((v) >= (MinVal) && (v) <= (MaxVal))
#define HTK_IS_BETWEEN_MIDDIFF(v, MidVal, DiffVal)  (HTK_IS_BETWEEN_MINMAX((v), ((MidVal) - (DiffVal)), ((MidVal) + (DiffVal))))

#define HTK_ROUND_U16(x)    (((u16)(x) + 0.5) > (x) ? ((u16)(x)) : ((u16)(x) + 1))
#define HTK_ROUND_U32(x)    (((u32)(x) + 0.5) > (x) ? ((u32)(x)) : ((u32)(x) + 1))
#define HTK_ROUND_U64(x)    (((u64)(x) + 0.5) > (x) ? ((u64)(x)) : ((u64)(x) + 1))

#define HTK_ROUND_U32_3D(x)             (HTK_ROUND_U32((x) * 1000))
#define HTK_ROUND_U32_3D_TO_FLOAT(x)    (((float)HTK_ROUND_U32_3D(x)) / 1000)

#define GET_BOX_NUM(ItemNum, ItemNumInOneBox)   ((ItemNum) % (ItemNumInOneBox) == 0 ? ((ItemNum) / (ItemNumInOneBox)) : ((ItemNum) / (ItemNumInOneBox)) + 1)

#define MULTI_3D(x)
#define FLOOR_3D(x)      ((float)(((uint32_t)((x) * 1000)) / 1000))

//#define HTK_ABS(x)          (((x) > 0) ? (x) : ((-1) * (x)))
#define HTK_ABS(x)          (((x) >= 0) ? (x) : ((-1) * (x)))

#define HTK_GetPosFromZero(x)   (((x) >= 0) ? (x) : 0)
#define HTK_GetNegFromZero(x)   (((x) <= 0) ? (x) * (-1) : 0)

#define HTK_U8_MAX          (0xFF)
#define HTK_U16_MAX         (0xFFFF)
#define HTK_U32_MAX         (0xFFFFFFFF)
#define HTK_U64_MAX         (0xFFFFFFFFFFFFFFFF)

#define BYTE_TO_BINARY_PATTERN  "%c%c%c%c %c%c%c%c"
#define BYTE_TO_BINARY(byte)  \
  ((byte) & 0x80 ? '1' : '0'), \
  ((byte) & 0x40 ? '1' : '0'), \
  ((byte) & 0x20 ? '1' : '0'), \
  ((byte) & 0x10 ? '1' : '0'), \
  ((byte) & 0x08 ? '1' : '0'), \
  ((byte) & 0x04 ? '1' : '0'), \
  ((byte) & 0x02 ? '1' : '0'), \
  ((byte) & 0x01 ? '1' : '0')

//Codes 0 through 31 and 127 (decimal) are unprintable control characters.
//Code 32 (decimal) is a nonprinting spacing character. Codes 33 through 126 (decimal) are printable graphic characters.
#define HTK_IS_DISP_CHAR(c) ((c) >= 32 && (c) <= 126 ? HTK_TRUE : HTK_FALSE)
#define HTK_IS_CTRL_CHAR(c) (!HTK_IS_DISP_CHAR(c))

//#define HTK_ELAPSEDTICKS_U32(BegTick, EndTick)          ((EndTick) >= (BegTick) ? ((EndTick) - (BegTick)) : ((HTK_U32_MAX) - (BegTick) + (EndTick)))
//#define HTK_IS_TIMEOUT_U32(BegTick, EndTick, MaxTick)   (HTK_ELAPSEDTICKS_U32((BegTick), (EndTick)) > (MaxTick) ? HTK_TRUE : HTK_FALSE)
HTK_BOOL HTK_IsInTime(u32 BegTick, u32 MaxTick);
HTK_BOOL HTK_IsTimeout(u32 BegTick, u32 MaxTick);

typedef struct _HTK_Timer
{
    HTK_BOOL    m_bStart:   1;
    HTK_BOOL    m_bTimeout: 1;
    u32         m_BegTick;
    u32         m_MaxTick;
}
HTK_Timer, *PHTK_Timer;

void HTK_Timer_Reset(PHTK_Timer p);
void HTK_Timer_Start(PHTK_Timer p, u32 MaxTick);
HTK_BOOL HTK_Timer_CheckTimeout(PHTK_Timer p);

uint8_t HTK_CheckSum_Calulate(uint8_t* pBeg, uint32_t len);
HTK_BOOL HTK_CheckSum_Update(uint8_t* pBeg, uint32_t len, uint8_t* pCheckSum);
HTK_BOOL HTK_CheckSum_IsOK(uint8_t* pBeg, uint32_t len, uint8_t* pCheckSum);

void HTK_ByteArray2HexStr(const u8* buf, const u16 BegIdx, const u16 len, char* OutStr, u16 nMaxBytesPerLine, HTK_BOOL bSpace);
void HTK_ByteArray2HexStr_XP(const char* Title, const u8* buf, const u16 BegIdx, const u16 len);
void HTK_ByteArray2HexStr_XT(const char* Title, const u8* buf, const u16 BegIdx, const u16 len);

HTK_BOOL HTK_HexStrToByteArray(byte* Dst, int DstLen, const char* Src, int SrcLen);

void HTK_FillChar(char* buf, char c, int count);
void HTK_PrintRow(char c, int count);

typedef struct _HTK_MallocHandle
{
    s32 m_Total;
    s32 m_Allocated;
    s32 m_Reserved;
}
HTK_MallocHandle, PHTK_MallocHandle;

void HTK_Malloc_Init(void);
void* HTK_Malloc(s32 size);
void HTK_Free(void* p);
s32 HTK_Malloc_BlockTest(s32 BlockSize);

#ifdef FUNC_SALT_AND_BLEND
int Salt(u8* Mixture, int MixtureLen, u8* SaltMap, int SaltMapLen, u8* Data, int DataLen, u8 bRestore);
int Blend(u8* Dst, u8* Src, int Len, u8 ShiftType, u8 bRestore);
int DataEncryption(u8* Data, int DataLen, u8* EncryptedData, int EncryptedDataLen, u8 bDecryption);
#endif

#endif //HTK
//******************************************************************
#ifdef MODIFY_IMCP
#define IMCP_FM_FRAMEID_IDX     (0)
#define IMCP_FM_SRCADDR_IDX     (1)
#define IMCP_FM_DSTADDR_IDX     (2)
#define IMCP_FM_MSGID_IDX       (3)
#define IMCP_FM_DATALEN_LSB_IDX (4) //4: LSB (DATALEN Value: N)
#define IMCP_FM_DATALEN_MSB_IDX (5) //5: MSB
#define IMCP_FM_DATA_BEG_IDX    (6) //6~(6+N) = DATA(1)~DATA(N)
//#define IMCP_FM_DATA_CHECKSUM_IDX   (6 + N + 1) //Variable
#define IMCP_FM_HEAD_LEN        (IMCP_FM_DATALEN_MSB_IDX - IMCP_FM_FRAMEID_IDX + 1)
#define IMCP_FM_TAIL_LEN        (1) //CheckSum
#define IMCP_TX_LEN(DataLen)    (IMCP_FM_HEAD_LEN + (DataLen) + IMCP_FM_TAIL_LEN)
#endif //MODIFY_IMCP
//******************************************************************
#ifdef DISABLE_PRINT_DEBUG_MSG
#define DEBUG_INFO(format, args...)
#define DEBUG_WARN(format, args...)
#define DEBUG_ERROR(format, args...)
#else
#define DEBUG_INFO(format, args...) (Charger.memory.EVSE_Config.data.item.isDispDebug?printf("[%04d-%02d-%02d %02d:%02d:%02d][%s:%d][Info] "format, Charger.memory.EVSE_Config.data.item.SystemDateTime.year, Charger.memory.EVSE_Config.data.item.SystemDateTime.month, Charger.memory.EVSE_Config.data.item.SystemDateTime.day, Charger.memory.EVSE_Config.data.item.SystemDateTime.hour, Charger.memory.EVSE_Config.data.item.SystemDateTime.min, Charger.memory.EVSE_Config.data.item.SystemDateTime.sec, __FUNCTION__, __LINE__, ##args):printf(""))
#define DEBUG_WARN(format, args...) (Charger.memory.EVSE_Config.data.item.isDispDebug?printf("[%04d-%02d-%02d %02d:%02d:%02d][%s:%d][Warn] "format, Charger.memory.EVSE_Config.data.item.SystemDateTime.year, Charger.memory.EVSE_Config.data.item.SystemDateTime.month, Charger.memory.EVSE_Config.data.item.SystemDateTime.day, Charger.memory.EVSE_Config.data.item.SystemDateTime.hour, Charger.memory.EVSE_Config.data.item.SystemDateTime.min, Charger.memory.EVSE_Config.data.item.SystemDateTime.sec, __FUNCTION__, __LINE__, ##args):printf(""))
#define DEBUG_ERROR(format, args...) (Charger.memory.EVSE_Config.data.item.isDispDebug?printf("[%04d-%02d-%02d %02d:%02d:%02d][%s:%d][Error] "format, Charger.memory.EVSE_Config.data.item.SystemDateTime.year, Charger.memory.EVSE_Config.data.item.SystemDateTime.month, Charger.memory.EVSE_Config.data.item.SystemDateTime.day, Charger.memory.EVSE_Config.data.item.SystemDateTime.hour, Charger.memory.EVSE_Config.data.item.SystemDateTime.min, Charger.memory.EVSE_Config.data.item.SystemDateTime.sec, __FUNCTION__, __LINE__, ##args):printf(""))
#endif //DISABLE_PRINT_DEBUG_MSG
//******************************************************************

#define ARRAY_SIZE(A)		(sizeof(A) / sizeof(A[0]))
/* USER CODE END ET */

/* Exported constants --------------------------------------------------------*/
/* USER CODE BEGIN EC */
#define OFF	    0
#define	ON	    1

#define FAIL    0
#define PASS    1

#define NO	    0
#define YES	    1

#define true    1
#define false   0

#define DEBUG
#define RTOS_STAT
#define BYPASS
#define W25Q16FV_BLOCK_SIZE         0x1000

#define EVSE_CONNECTOR_TYPE         "GBT_MODE3"

////#define EVSE_MODEL_CURRENT_RATING   48  //AX48

#define MCU_CONTROL_MODE_NO_CSU     0
#define MCU_CONTROL_MODE_CSU        1
//#define MCU_PASS_MODE               2 //Not used

#define RFID_SN_TYPE_4BYTE          0
#define RFID_SN_TYPE_7BYTE          1
#define RFID_SN_TYPE_10BYTE         2
#define RFID_SN_TYPE_14443B         3
#define RFID_SN_TYPE_FELICA         4

#define RFID_ENDIAN_LITTLE          0
#define RFID_ENDIAN_BIG             1

//AuthorisationMode
#define AUTH_MODE_OCPP              0x00
#define AUTH_MODE_FREE              0x01

//OfflinePolicy
#define RFID_USER_AUTH_LOCAL_LIST       0x00
#define RFID_USER_AUTH_PH               0x01
#define RFID_USER_AUTH_FREE             0x02
#define RFID_USER_AUTH_NO_CHARGING      0x03

#define MEM_ADDR_EVSE_CONFIG                            0*W25Q16FV_BLOCK_SIZE
#define MEM_ADDR_COLD_LOAD_PICKUP                       1*W25Q16FV_BLOCK_SIZE
#define MEM_ADDR_WHITE_LIST                             2*W25Q16FV_BLOCK_SIZE
#define MEM_ADDR_HIS_ALARM                              3*W25Q16FV_BLOCK_SIZE

#ifdef FUNC_METER_IC_HISTORY
#define MEM_ADDR_HIS_METERIC                            4*W25Q16FV_BLOCK_SIZE
#else
#define MEM_ADDR_HIS_CHARGING                           4*W25Q16FV_BLOCK_SIZE
#endif

#define MEM_ADDR_BACKUP_EVSE_CONFIG                     20*W25Q16FV_BLOCK_SIZE
#define MEM_ADDR_BACKUP_COLD_LOAD_PICKUP                21*W25Q16FV_BLOCK_SIZE
#define MEM_ADDR_BACKUP_WHITE_LIST                      22*W25Q16FV_BLOCK_SIZE
#define MEM_ADDR_BACKUP_HIS_ALARM                       23*W25Q16FV_BLOCK_SIZE

#ifdef FUNC_METER_IC_HISTORY
#define MEM_ADDR_BACKUP_HIS_METERIC                     24*W25Q16FV_BLOCK_SIZE
#else
#define MEM_ADDR_BACKUP_HIS_CHARGING                    24*W25Q16FV_BLOCK_SIZE
#endif

#define MODE_INITIAL	    0
#define MODE_IDLE		    1
#define MODE_HANDSHAKE	    2
#define MODE_CHARGING	    3
#define MODE_STOP		    4
#define MODE_ALARM		    5
#define MODE_MAINTAIN	    6
#define MODE_DEBUG          99

#define	LED_MOTION_OFF	    0
#define	LED_MOTION_ON	    1
#define	LED_MOTION_BLINK    2
#define LED_MOTION_BREATHE  3

#define LED_ACTION_INIT                         0
#define LED_ACTION_IDLE                         1
#define LED_ACTION_AUTHED                       2
#define LED_ACTION_CONNECTED                    3
#define LED_ACTION_CHARGING                     4
#define LED_ACTION_STOP                         5
#define LED_ACTION_ALARM                        6
#define LED_ACTION_MAINTAIN                     7
#define LED_ACTION_RFID_PASS                    8
#define LED_ACTION_RFID_FAIL                    9
#define LED_ACTION_BLE_CONNECT                  10
#define LED_ACTION_BLE_DISABLE                  11
#define LED_ACTION_DEBUG                        12
#define LED_ACTION_ALL_OFF                      13
#define LED_RELAY_ON                            14
#define LED_RELAY_OFF                           15
#define LED_ACTION_HANDSHAKE_FAIL               16
#define LED_ACTION_INTERNET_DISCONNECT          17
#define LED_ACTION_RESTORE_SETTING              18

#ifdef MODIFY_LED_STATUS_202108
#define LED_ACTION_IDLE_BACKEND_CONNECTED           19
#define LED_ACTION_IDLE_BACKEND_CONNECTED_SLEEP     20
#define LED_ACTION_IDLE_BACKEND_DISCONNECTED        21
#define LED_ACTION_IDLE_BACKEND_DISCONNECTED_SLEEP  22
#define LED_ACTION_RESERVATION_MODE                 23
#endif //MODIFY_LED_STATUS_202108

#ifdef FUNC_CUSTOMIZED_LED_MODE_FROM_CSU
#define LED_ACTION_CUSTOMIZED_MODE              0xA0

typedef enum _LED_USER_MODE
{
    LED_USER_MODE_SOLID = 0xF1,
    LED_USER_MODE_BLINK = 0xF2,
    LED_USER_MODE_BREATH = 0xF3,
}
LED_USER_MODE;

typedef struct _LED_UserCfg
{
    u8 m_Mode; //LED_USER_MODE
    u8 m_AutoRepeat;
    u8 m_Brightness; //0 ~ 100 (%)

    //RGB from 0 ~ 1000
    u16 m_R;
    u16 m_G;
    u16 m_B;

    union
    {
        struct
        {
            u16 m_On_ms;
            u16 m_Off_ms;
            u16 m_Rest_ms;
            u16 m_Count;
        }
        Blink;

        struct
        {
            u16 m_Up_ms;
            u16 m_Down_ms;
            u16 m_R3;
            u16 m_R4;
        }
        Breath;
    };
}
LED_UserCfg, *PLED_UserCfg;

#endif //FUNC_CUSTOMIZED_LED_MODE_FROM_CSU

#define LED_RFID_TIME                           3000

#define SPEAKER_NONE                            0
#define SPEAKER_LONG                            1
#define SPEAKER_SHORT                           2
#define SPEAKER_BLINK                           3

#define SPEAK_RESET_RFID_TIME      LED_RFID_TIME-1000

#ifdef FUNC_AW48_NET_LED
#define NET_LED_ACTION_LTE_CONNECTING           1
#define NET_LED_ACTION_LTE_CONNECTED            2
#define NET_LED_ACTION_WIFI_CONNECTING          3
#define NET_LED_ACTION_WIFT_CONNECTED           4
#define NET_LED_ACTION_ETHERNET_CONNECTING      5
#define NET_LED_ACTION_ETHERNET_CONNECTED       6
#define NET_LED_ACTION_ALL_CONNECTING           7
#define NET_LED_ACTION_OFF                      8
//(HIDE for NET_LED_ACTION_ALL_CONNECTING) --------
#define NET_LED_ACTION_LTE_CONNECTING_H         9
#define NET_LED_ACTION_WIFI_CONNECTING_H        10
#define NET_LED_ACTION_ETHERNET_CONNECTING_H    11
//-------------------------------------------------
#define NET_LED_ACTION_MIN                      NET_LED_ACTION_LTE_CONNECTING
#define NET_LED_ACTION_MAX                      NET_LED_ACTION_OFF
#endif //FUNC_AW48_NET_LED

#define ALARM_L1_OVER_VOLTAGE			0x00000001
#define ALARM_L1_UNDER_VOLTAGE			0x00000002
#define ALARM_L1_OVER_CURRENT			0x00000004
#define ALARM_OVER_TEMPERATURE	        0x00000008
#define ALARM_GROUND_FAIL			    0x00000010
#define ALARM_CP_ERROR				    0x00000020
#define ALARM_CURRENT_LEAK_AC           0x00000040
#define ALARM_CURRENT_LEAK_DC           0x00000080
#define ALARM_MCU_TESTFAIL			    0x00000100
#define ALARM_HANDSHAKE_TIMEOUT         0x00000200
#define ALARM_EMERGENCY_STOP            0x00000400
#define ALARM_RELAY_STATUS              0x00000800
#define ALARM_LEAK_MODULE_FAIL          0x00001000
#define ALARM_SHUTTER_FAULT             0x00002000
#define ALARM_LOCKER_FAULT              0x00004000
#define ALARM_POWER_DROP                0x00008000
#define ALARM_L1_CIRCUIT_SHORT          0x00010000
#define ALARM_ROTATORY_SWITCH_FAULT     0x00020000
#define ALARM_RELAY_DRIVE_FUALT         0x00040000
#define ALARM_BLE_MODULE_BROKEN         0x00080000
#define ALARM_L2_OVER_VOLTAGE           0x00100000
#define ALARM_L3_OVER_VOLTAGE           0x00200000
#define ALARM_L2_UNDER_VOLTAGE          0x00400000
#define ALARM_L3_UNDER_VOLTAGE          0x00800000
#define ALARM_L2_OVER_CURRENT			0x01000000
#define ALARM_L3_OVER_CURRENT			0x02000000
#define ALARM_L2_CIRCUIT_SHORT          0x04000000
#define ALARM_L3_CIRCUIT_SHORT          0x08000000
#define ALARM_METER_TIMEOUT             0x10000000

#ifdef FUNC_METER_IC_COMM_ALARM
#define ALARM_METER_IC_TIMEOUT          0x20000000
#endif

#ifdef FUNC_ALARM_CP_NEG_ERROR
#define ALARM_CP_NEG_ERROR			    0x40000000
#endif

#ifdef FUNC_AX80_ADD_TILT_SENSOR
#define ALARM_TILT_SENSOR			    0x80000000
#endif

#ifdef FUNC_WARNING_CODE
#define WARN_OMNIMETER_COMM_TIMEOUT     BIT_FLAG_VAL(0)
#define WARN_RESERVED_01                BIT_FLAG_VAL(1)
#define WARN_RESERVED_02                BIT_FLAG_VAL(2)
#define WARN_RESERVED_03                BIT_FLAG_VAL(3)
#define WARN_RESERVED_04                BIT_FLAG_VAL(4)
#define WARN_RESERVED_05                BIT_FLAG_VAL(5)
#define WARN_RESERVED_06                BIT_FLAG_VAL(6)
#define WARN_RESERVED_07                BIT_FLAG_VAL(7)
#define WARN_RESERVED_08                BIT_FLAG_VAL(8)
#define WARN_RESERVED_09                BIT_FLAG_VAL(9)
#define WARN_RESERVED_10                BIT_FLAG_VAL(10)
#define WARN_RESERVED_11                BIT_FLAG_VAL(11)
#define WARN_RESERVED_12                BIT_FLAG_VAL(12)
#define WARN_RESERVED_13                BIT_FLAG_VAL(13)
#define WARN_RESERVED_14                BIT_FLAG_VAL(14)
#define WARN_RESERVED_15                BIT_FLAG_VAL(15)
#define WARN_RESERVED_16                BIT_FLAG_VAL(16)
#define WARN_RESERVED_17                BIT_FLAG_VAL(17)
#define WARN_RESERVED_18                BIT_FLAG_VAL(18)
#define WARN_RESERVED_19                BIT_FLAG_VAL(19)
#define WARN_RESERVED_20                BIT_FLAG_VAL(20)
#define WARN_RESERVED_21                BIT_FLAG_VAL(21)
#define WARN_RESERVED_22                BIT_FLAG_VAL(22)
#define WARN_RESERVED_23                BIT_FLAG_VAL(23)
#define WARN_RESERVED_24                BIT_FLAG_VAL(24)
#define WARN_RESERVED_25                BIT_FLAG_VAL(25)
#define WARN_RESERVED_26                BIT_FLAG_VAL(26)
#define WARN_RESERVED_27                BIT_FLAG_VAL(27)
#define WARN_RESERVED_28                BIT_FLAG_VAL(28)
#define WARN_RESERVED_29                BIT_FLAG_VAL(29)
#define WARN_RESERVED_30                BIT_FLAG_VAL(30)
#define WARN_RESERVED_31                BIT_FLAG_VAL(31)
#endif //FUNC_WARNING_CODE

#define END_STATUS_CODE_NORMAL          0x013600
#define END_STATUS_CODE_TIMEUP          0x013601
#define END_STATUS_CODE_DROP            0x012212

#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
uint16_t GetCpPwmDuty(uint16_t Curr);
#else
#define PWM_DUTY_651(AMP)           (uint16_t)((AMP/0.6)*10)        // 6<=currewnt<=51 PWM duty resolution in 0.1
#endif

#define START_METHOD_NONE           0
#define START_METHOD_CP             1
#define START_METHOD_RFID           2
#define START_METHOD_BLE            3

#ifdef FUNC_OUTP_TYPE_E
#define START_METHOD_TYPEE          4
#endif

#define RESERVATION_DISABLE         0
#define RESERVATION_ONCE            1
#define RESERVATION_ALWAYS          2

#define ALARM_SPEC_POWER_DROP                   7200            // unit 0.01V >> 240V * 30%

#ifdef TEST_ACXXX_FAKEDATA

#ifdef TEST_AC110_FAKEDATA
#define ALARM_SPEC_OV                           14000           // unit 0.01V
#define ALARM_SPEC_UV                           8000            // unit 0.01V
#endif

#ifdef TEST_AC220_FAKEDATA
#define ALARM_SPEC_OV                           27500           // unit 0.01V
#define ALARM_SPEC_UV                           16000            // unit 0.01V
#endif

#else //TEST_ACXXX_FAKEDATA

#define ALARM_SPEC_OV                           27500           // unit 0.01V
#define ALARM_SPEC_UV                           16000//16000    // unit 0.01V

#endif //TEST_ACXXX_FAKEDATA

#define ALARM_SPEC_OUV_HYSTERESIS               1000            // unit 0.01V

#ifdef MODIFY_OTP_SPEC

//AX48
#define ALARM_SPEC_OT_G1_1_AX48                 75              // unit C
#define ALARM_SPEC_OT_G1_2_AX48                 85              // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AX48        20              // unit C Recover 55 = (75-20)

//AX32
#define ALARM_SPEC_OT_G1_1_AX32                 75              // unit C
#define ALARM_SPEC_OT_G1_2_AX32                 85              // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AX32        20              // unit C Recover 55 = (75-20)

#ifdef FUNC_AT32
//AT32
#define ALARM_SPEC_OT_G1_1_AT32                 75              // unit C
#define ALARM_SPEC_OT_G1_2_AT32                 85              // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AT32        20              // unit C Recover 55 = (75-20)
#endif

#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
//AX80
#define ALARM_SPEC_OT_G1_1_AX80                 75              // unit C
#define ALARM_SPEC_OT_G1_2_AX80                 85              // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AX80        20              // unit C Recover 55 = (75-20)

#define ALARM_SPEC_OT_G2_1_AX80                 110             // unit C
#define ALARM_SPEC_OT_G2_2_AX80                 120             // unit C
#define ALARM_SPEC_OT_G2_HYSTERESIS_AX80        20              // unit C Recover 90 = (110-20)
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR

#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
//AW48
#ifdef MODIFY_AW48_OTP_SPEC_20231006_KENNY
#ifdef MODIFY_AW48_OTP_SPEC_20240729_JACK
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#ifdef MODIFY_AW48_OTP_SPEC_20240814_KENNY
#ifdef MODIFY_AW48_OTP_SPEC_20240819_JACK
#ifdef MODIFY_AW48_OTP_SPEC_20241016_JACK
#define ALARM_SPEC_OT_G1_1_AW48                 (78)        // unit C
#define ALARM_SPEC_OT_G1_2_AW48                 (83)        // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AW48        (20)        // unit C Recover 59 = (79-20)
#else //MODIFY_AW48_OTP_SPEC_20241016_JACK
#define ALARM_SPEC_OT_G1_1_AW48                 (76)        // unit C
#define ALARM_SPEC_OT_G1_2_AW48                 (86)        // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AW48        (20)        // unit C Recover 59 = (79-20)
#endif //MODIFY_AW48_OTP_SPEC_20241016_JACK
#else //MODIFY_AW48_OTP_SPEC_20240819_JACK
#define ALARM_SPEC_OT_G1_1_AW48                 (80)        // unit C
#define ALARM_SPEC_OT_G1_2_AW48                 (90)        // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AW48        (30)        // unit C Recover 59 = (79-20)
#endif //MODIFY_AW48_OTP_SPEC_20240819_JACK
#else //MODIFY_AW48_OTP_SPEC_20240814_KENNY
#define ALARM_SPEC_OT_G1_1_AW48                 (79)        // unit C
#define ALARM_SPEC_OT_G1_2_AW48                 (89)        // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AW48        (20)        // unit C Recover 59 = (79-20)
#endif //MODIFY_AW48_OTP_SPEC_20240814_KENNY
#else //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#define ALARM_SPEC_OT_G1_1_AW48                 (80)       // unit C
#define ALARM_SPEC_OT_G1_2_AW48                 (90)       // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AW48        (20)              // unit C Recover 70 = (90-20)
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#else //MODIFY_AW48_OTP_SPEC_20240729_JACK
#define ALARM_SPEC_OT_G1_1_AW48                 (75 + 15)       // unit C
#define ALARM_SPEC_OT_G1_2_AW48                 (85 + 15)       // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AW48        (20)              // unit C Recover 70 = (90-20)
#endif //MODIFY_AW48_OTP_SPEC_20240729_JACK
#else //MODIFY_AW48_OTP_SPEC_20231006_KENNY
#define ALARM_SPEC_OT_G1_1_AW48                 75              // unit C
#define ALARM_SPEC_OT_G1_2_AW48                 85              // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AW48        20              // unit C Recover 55 = (75-20)
#endif //MODIFY_AW48_OTP_SPEC_20231006_KENNY

#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AW48_OTP_SPEC_20240729_JACK
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#ifdef MODIFY_AW48_OTP_SPEC_20240809_JACK
#ifdef MODIFY_AW48_OTP_SPEC_20240814_KENNY
#ifdef MODIFY_AW48_OTP_SPEC_20240819_JACK
#ifdef MODIFY_AW48_OTP_SPEC_20241016_JACK
#define ALARM_SPEC_OT_G2_1_AW48            83               // unit C
#define ALARM_SPEC_OT_G2_2_AW48            88              // unit C
#define ALARM_SPEC_OT_G2_HYSTERESIS_AW48   20               // unit C Recover 70 = (90-20)

#define ALARM_SPEC_OT_G3_1_AW48            90               // unit C
#define ALARM_SPEC_OT_G3_2_AW48            95              // unit C
#define ALARM_SPEC_OT_G3_HYSTERESIS_AW48   25               // unit C Recover 75 = (95-20)

#define ALARM_SPEC_OT_G4_1_AW48            70               // unit C
#define ALARM_SPEC_OT_G4_2_AW48            80               // unit C
#define ALARM_SPEC_OT_G4_HYSTERESIS_AW48   20               // unit C Recover 50 = (70-20)

#else //MODIFY_AW48_OTP_SPEC_20241016_JACK
#define ALARM_SPEC_OT_G2_1_AW48            87               // unit C
#define ALARM_SPEC_OT_G2_2_AW48            97              // unit C
#define ALARM_SPEC_OT_G2_HYSTERESIS_AW48   30               // unit C Recover 70 = (90-20)

#define ALARM_SPEC_OT_G3_1_AW48            92               // unit C
#define ALARM_SPEC_OT_G3_2_AW48            102              // unit C
#define ALARM_SPEC_OT_G3_HYSTERESIS_AW48   30               // unit C Recover 75 = (95-20)

#define ALARM_SPEC_OT_G4_1_AW48            80               // unit C
#define ALARM_SPEC_OT_G4_2_AW48            90               // unit C
#define ALARM_SPEC_OT_G4_HYSTERESIS_AW48   20               // unit C Recover 50 = (70-20)

#endif //MODIFY_AW48_OTP_SPEC_20241016_JACK
#else //MODIFY_AW48_OTP_SPEC_20240819_JACK
#define ALARM_SPEC_OT_G2_1_AW48            90               // unit C
#define ALARM_SPEC_OT_G2_2_AW48            100              // unit C
#define ALARM_SPEC_OT_G2_HYSTERESIS_AW48   30               // unit C Recover 70 = (90-20)

#define ALARM_SPEC_OT_G3_1_AW48            100               // unit C
#define ALARM_SPEC_OT_G3_2_AW48            110              // unit C
#define ALARM_SPEC_OT_G3_HYSTERESIS_AW48   30               // unit C Recover 75 = (95-20)

#define ALARM_SPEC_OT_G4_1_AW48            70               // unit C
#define ALARM_SPEC_OT_G4_2_AW48            80               // unit C
#define ALARM_SPEC_OT_G4_HYSTERESIS_AW48   20               // unit C Recover 50 = (70-20)
#endif //MODIFY_AW48_OTP_SPEC_20240819_JACK
#else //MODIFY_AW48_OTP_SPEC_20240814_KENNY
#define ALARM_SPEC_OT_G2_1_AW48            90               // unit C
#define ALARM_SPEC_OT_G2_2_AW48            100              // unit C
#define ALARM_SPEC_OT_G2_HYSTERESIS_AW48   20               // unit C Recover 70 = (90-20)

#define ALARM_SPEC_OT_G3_1_AW48            100               // unit C
#define ALARM_SPEC_OT_G3_2_AW48            110              // unit C
#define ALARM_SPEC_OT_G3_HYSTERESIS_AW48   30               // unit C Recover 75 = (95-20)

#define ALARM_SPEC_OT_G4_1_AW48            70               // unit C
#define ALARM_SPEC_OT_G4_2_AW48            80               // unit C
#define ALARM_SPEC_OT_G4_HYSTERESIS_AW48   20               // unit C Recover 50 = (70-20)
#endif //MODIFY_AW48_OTP_SPEC_20240814_KENNY
#else //MODIFY_AW48_OTP_SPEC_20240809_JACK
#define ALARM_SPEC_OT_G2_1_AW48            90               // unit C
#define ALARM_SPEC_OT_G2_2_AW48            100              // unit C
#define ALARM_SPEC_OT_G2_HYSTERESIS_AW48   20               // unit C Recover 70 = (90-20)

#define ALARM_SPEC_OT_G3_1_AW48            95               // unit C
#define ALARM_SPEC_OT_G3_2_AW48            105              // unit C
#define ALARM_SPEC_OT_G3_HYSTERESIS_AW48   20               // unit C Recover 75 = (95-20)

#define ALARM_SPEC_OT_G4_1_AW48            70               // unit C
#define ALARM_SPEC_OT_G4_2_AW48            80               // unit C
#define ALARM_SPEC_OT_G4_HYSTERESIS_AW48   20               // unit C Recover 50 = (70-20)
#endif //MODIFY_AW48_OTP_SPEC_20240809_JACK
#else //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#define ALARM_SPEC_OT_G2_1_AW48            115              // unit C
#define ALARM_SPEC_OT_G2_2_AW48            125              // unit C
#define ALARM_SPEC_OT_G2_HYSTERESIS_AW48   20              // unit C Recover 50 = (70-20)

#define ALARM_SPEC_OT_G3_1_AW48            115              // unit C
#define ALARM_SPEC_OT_G3_2_AW48            125              // unit C
#define ALARM_SPEC_OT_G3_HYSTERESIS_AW48   20              // unit C Recover 75 = (95-20)
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#else //MODIFY_AW48_OTP_SPEC_20240729_JACK
#define ALARM_SPEC_OT_G2_1_AW48            70              // unit C
#define ALARM_SPEC_OT_G2_2_AW48            80              // unit C
#define ALARM_SPEC_OT_G2_HYSTERESIS_AW48   20              // unit C Recover 50 = (70-20)

#define ALARM_SPEC_OT_G3_1_AW48            95              // unit C
#define ALARM_SPEC_OT_G3_2_AW48            105              // unit C
#define ALARM_SPEC_OT_G3_HYSTERESIS_AW48   20              // unit C Recover 75 = (95-20)
#endif //MODIFY_AW48_OTP_SPEC_20240729_JACK
#else //MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#define ALARM_SPEC_OT_G2_1_AW48            (100 + 15)      // unit C
#define ALARM_SPEC_OT_G2_2_AW48            (110 + 15)      // unit C
#define ALARM_SPEC_OT_G2_HYSTERESIS_AW48   20              // unit C Recover 90 = (110-20)
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN

#endif //FUNC_AW48_ADD_6_TEMP_SENEOR

#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
//AX48_NACS
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20231006_KENNY
#define ALARM_SPEC_OT_G1_1_AX48_NACS            (75 + 15)       // unit C
#define ALARM_SPEC_OT_G1_2_AX48_NACS            (85 + 15)       // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AX48_NACS   20              // unit C Recover 70 = (90-20)
#else //MODIFY_AX48_NACS_OTP_SPEC_20231006_KENNY
#define ALARM_SPEC_OT_G1_1_AX48_NACS            75              // unit C
#define ALARM_SPEC_OT_G1_2_AX48_NACS            85              // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AX48_NACS   20              // unit C Recover 55 = (75-20)
#endif //MODIFY_AX48_NACS_OTP_SPEC_20231006_KENNY

#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
#define ALARM_SPEC_OT_G2_1_AX48_NACS            85              // unit C
#define ALARM_SPEC_OT_G2_2_AX48_NACS            95              // unit C
#define ALARM_SPEC_OT_G2_HYSTERESIS_AX48_NACS   20              // unit C Recover 50 = (70-20)

#define ALARM_SPEC_OT_G3_1_AX48_NACS            95              // unit C
#define ALARM_SPEC_OT_G3_2_AX48_NACS            105              // unit C
#define ALARM_SPEC_OT_G3_HYSTERESIS_AX48_NACS   20              // unit C Recover 75 = (95-20)

#define ALARM_SPEC_OT_G4_1_AX48_NACS            70              // unit C
#define ALARM_SPEC_OT_G4_2_AX48_NACS            80              // unit C
#define ALARM_SPEC_OT_G4_HYSTERESIS_AX48_NACS   20              // unit C Recover 75 = (95-20)

#else //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
#define ALARM_SPEC_OT_G2_1_AX48_NACS            70              // unit C
#define ALARM_SPEC_OT_G2_2_AX48_NACS            80              // unit C
#define ALARM_SPEC_OT_G2_HYSTERESIS_AX48_NACS   20              // unit C Recover 50 = (70-20)

#define ALARM_SPEC_OT_G3_1_AX48_NACS            95              // unit C
#define ALARM_SPEC_OT_G3_2_AX48_NACS            105              // unit C
#define ALARM_SPEC_OT_G3_HYSTERESIS_AX48_NACS   20              // unit C Recover 75 = (95-20)
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
#else //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#define ALARM_SPEC_OT_G2_1_AX48_NACS            (100 + 15)      // unit C
#define ALARM_SPEC_OT_G2_2_AX48_NACS            (110 + 15)      // unit C
#define ALARM_SPEC_OT_G2_HYSTERESIS_AX48_NACS   20              // unit C Recover 90 = (110-20)
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN

#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR


//AX80_NACS
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK

#define ALARM_SPEC_OT_G1_1_AX80_NACS            90              // unit C
#define ALARM_SPEC_OT_G1_2_AX80_NACS            100             // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AX80_NACS   20              // unit C Recover 70 = (90-20)

#define ALARM_SPEC_OT_G2_1_AX80_NACS            90              // unit C
#define ALARM_SPEC_OT_G2_2_AX80_NACS            100             // unit C
#define ALARM_SPEC_OT_G2_HYSTERESIS_AX80_NACS   20              // unit C Recover 50 = (70-20)

#define ALARM_SPEC_OT_G3_1_AX80_NACS            95              // unit C
#define ALARM_SPEC_OT_G3_2_AX80_NACS            105              // unit C
#define ALARM_SPEC_OT_G3_HYSTERESIS_AX80_NACS   20              // unit C Recover 75 = (95-20)

#define ALARM_SPEC_OT_G4_1_AX80_NACS            70              // unit C
#define ALARM_SPEC_OT_G4_2_AX80_NACS            80              // unit C
#define ALARM_SPEC_OT_G4_HYSTERESIS_AX80_NACS   20              // unit C Recover 75 = (95-20)

#else //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
#ifdef MODIFY_AX80_NACS_OTP_SPEC_20231006_KENNY
#define ALARM_SPEC_OT_G1_1_AX80_NACS            (75 + 15)       // unit C
#define ALARM_SPEC_OT_G1_2_AX80_NACS            (85 + 15)       // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AX80_NACS   20              // unit C Recover 70 = (90-20)
#else //MODIFY_AX80_NACS_OTP_SPEC_20231006_KENNY
#define ALARM_SPEC_OT_G1_1_AX80_NACS            75              // unit C
#define ALARM_SPEC_OT_G1_2_AX80_NACS            85              // unit C
#define ALARM_SPEC_OT_G1_HYSTERESIS_AX80_NACS   20              // unit C Recover 55 = (75-20)
#endif //MODIFY_AX80_NACS_OTP_SPEC_20231006_KENNY

#define ALARM_SPEC_OT_G2_1_AX80_NACS            (100 + 15)      // unit C
#define ALARM_SPEC_OT_G2_2_AX80_NACS            (110 + 15)      // unit C
#define ALARM_SPEC_OT_G2_HYSTERESIS_AX80_NACS   20              // unit C Recover 90 = (110-20)
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR

#else //MODIFY_OTP_SPEC

#define ALARM_SPEC_OT_1                         90              // unit C
#define ALARM_SPEC_OT_2                         100             // unit C
#define ALARM_SPEC_OT_HYSTERESIS                20              // unit C

#endif //MODIFY_OTP_SPEC

#define ALARM_SPEC_GF                           3100            // 2.5V
#define ALARM_SPEC_GF_HYSTERESIS                2110            // 2.5V-"1.7V"=0.8V

#ifndef FUNC_NEW_RELAY_MONITOR
#define ALARM_SPEC_RELAY_LN_DRIVE_FAULT         140             // unit 0.01V
#define ALARM_SPEC_RELAY_LN_WELDING             250//140        // unit 0.01V
//#define ALARM_SPEC_RELAY_LN_HYSTERESIS          20              // unit 0.01V //Not Used
#define ALARM_SPEC_RELAY_LL                     80 //24         // unit 0.01V
#endif //FUNC_NEW_RELAY_MONITOR

#define ALARM_SPEC_CURRENT_LEAK_HYSTERESIS      300             //
#define ALARM_SPEC_METER_TIMEOUT                10              // uint Counts

#define ALARM_RETRY_COUNT           1
#define ALARM_OC_RETRY_COUNT        4
#define ALARM_LEAK_RETRY_COUNT      1
#define ALARM_RETRY_INTERVAL_OC     60000       //  60000 ms >> 1min
#define ALARM_RETRY_INTERVAL_LEAK   15000       //  15000 ms >> 15sec
#define ALARM_RETRY_INTERVAL_OT     15000       //  15000 ms >> 15sec

#define WHITE_LIST_TYPE_RFID        0x00
#define WHITE_LIST_TYPE_BLE         0x01

#define AM3352_REQ_PIN_DEBOUNCE     30

#define BLE_LOGIN_ROLE_UNKOWN       0x00
#define BLE_LOGIN_ROLE_ROOT         0x01
#define BLE_LOGIN_ROLE_USER         0x02
#define BLE_LOGIN_ROLE_VISITOR      0x03

#define WIFI_LOGIN_ROLE_UNKOWN      0x00
#define WIFI_LOGIN_ROLE_ROOT        0x01
#define WIFI_LOGIN_ROLE_USER        0x02
#define WIFI_LOGIN_ROLE_VISITOR     0x03

#define MCU_DATA      0
#define METER_DATA    1

#define CORR_GROUP_ARRAY        3

#define GROUNGING_SYSTEM_LL     0
#define GROUNGING_SYSTEM_LN     1

#define CCID_MODULE_CORMEX      0
#define CCID_MODULE_VAC         1
#define CCID_MODULE_UNKNOW      0xFF

#ifdef FUNC_AUTO_MODIFY_CCID_MODULE
#define CCID_MODULE_TYPE_STR    ((Charger.CCID_Module_Type != CCID_MODULE_CORMEX && Charger.CCID_Module_Type != CCID_MODULE_VAC) ? "UNKNOW" : (Charger.CCID_Module_Type == CCID_MODULE_CORMEX ? "CORMEX" : "VAC"))
#endif

//#define LOCAL_LINK_BLE
//#define LOCAL_LINK_WIFI

#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
typedef struct TEMPERATURE
{
    int16_t SystemAmbientTemp;
    int16_t CcsConnectorTemp;
#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
    int16_t Group1_MaxTemp;

    union
    {
        int16_t AX80_Relay1Temp;
        int16_t AW48_T1_L1_IN;
        int16_t AX48_NACS_T1_L1_IN;
        int16_t AX80_NACS_T1_L1_IN;
    };

    union
    {
        int16_t AX80_Relay2Temp;
        int16_t AW48_T2_L2_IN;
        int16_t AX48_NACS_T2_L2_IN;
        int16_t AX80_NACS_T2_L2_IN;
    };

    union
    {
        int16_t AX80_Input_L1_Temp;
        int16_t AW48_T3_L1_OUT;
        int16_t AX48_NACS_T3_L1_OUT;
        int16_t AX80_NACS_T3_L1_OUT;
    };

    union
    {
        int16_t AX80_Input_N_L2_Temp;
        int16_t AW48_T4_L2_OUT;
        int16_t AX48_NACS_T4_L2_OUT;
        int16_t AX80_NACS_T4_L2_OUT;
    };

    union
    {
        int16_t AW48_T5_L1_GUN;
        int16_t AX48_NACS_T5_L1_GUN;
        int16_t AX80_NACS_T5_L1_GUN;
    };

    union
    {
        int16_t AW48_T6_L2_GUN;
        int16_t AX48_NACS_T6_L2_GUN;
        int16_t AX80_NACS_T6_L2_GUN;
    };

    int16_t Group2_MaxTemp;

#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
    int16_t Group3_MaxTemp;
#endif

#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
    int16_t Group4_MaxTemp;
#endif

#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
    int16_t Group1_MaxTemp;

    union
    {
        int16_t AX80_Relay1Temp;
        int16_t AW48_T1_L1_IN;
        int16_t AX48_NACS_T1_L1_IN;
    };

    union
    {
        int16_t AX80_Relay2Temp;
        int16_t AW48_T2_L2_IN;
        int16_t AX48_NACS_T2_L2_IN;
    };

    union
    {
        int16_t AX80_Input_L1_Temp;
        int16_t AW48_T3_L1_OUT;
        int16_t AX48_NACS_T3_L1_OUT;
    };

    union
    {
        int16_t AX80_Input_N_L2_Temp;
        int16_t AW48_T4_L2_OUT;
        int16_t AX48_NACS_T4_L2_OUT;
    };

    union
    {
        int16_t AW48_T5_L1_GUN;
        int16_t AX48_NACS_T5_L1_GUN;
    };

    union
    {
        int16_t AW48_T6_L2_GUN;
        int16_t AX48_NACS_T6_L2_GUN;
    };

    int16_t Group2_MaxTemp;
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
#else //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
    int16_t Group1_MaxTemp;

    union
    {
        int16_t AX80_Relay1Temp;
        int16_t AW48_T1_L1_IN;
    };

    union
    {
        int16_t AX80_Relay2Temp;
        int16_t AW48_T2_L2_IN;
    };

    union
    {
        int16_t AX80_Input_L1_Temp;
        int16_t AW48_T3_L1_OUT;
    };

    union
    {
        int16_t AX80_Input_N_L2_Temp;
        int16_t AW48_T4_L2_OUT;
    };

    int16_t AW48_T5_L1_GUN;
    int16_t AW48_T6_L2_GUN;

    int16_t Group2_MaxTemp;
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#else //FUNC_AW48_ADD_6_TEMP_SENEOR
    int16_t Group1_MaxTemp;

    int16_t AX80_Relay1Temp;
    int16_t AX80_Relay2Temp;
    int16_t AX80_Input_L1_Temp;
    int16_t AX80_Input_N_L2_Temp;

    int16_t Group2_MaxTemp;
#endif //FUNC_AW48_ADD_6_TEMP_SENEOR
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR

}Temperature;
#else //FUNC_TEMP_SENSOR_WITH_NEG_VALUE
typedef struct TEMPERATURE
{
    uint8_t SystemAmbientTemp;
    uint8_t CcsConnectorTemp;
#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
    uint8_t Group1_MaxTemp;

    union
    {
        uint8_t AX80_Relay1Temp;
        uint8_t AW48_T1_L1_IN;
    };

    union
    {
        uint8_t AX80_Relay2Temp;
        uint8_t AW48_T2_L2_IN;
    };

    union
    {
        uint8_t AX80_Input_L1_Temp;
        uint8_t AW48_T3_L1_OUT;
    };

    union
    {
        uint8_t AX80_Input_N_L2_Temp;
        uint8_t AW48_T4_L2_OUT;
    };

    uint8_t AW48_T5_L1_GUN;
    uint8_t AW48_T6_L2_GUN;

    uint8_t Group2_MaxTemp;

#else //FUNC_AW48_ADD_6_TEMP_SENEOR
    uint8_t Group1_MaxTemp;

    uint8_t AX80_Relay1Temp;
    uint8_t AX80_Relay2Temp;
    uint8_t AX80_Input_L1_Temp;
    uint8_t AX80_Input_N_L2_Temp;

    uint8_t Group2_MaxTemp;
#endif //FUNC_AW48_ADD_6_TEMP_SENEOR
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR

}Temperature;
#endif //FUNC_TEMP_SENSOR_WITH_NEG_VALUE

typedef struct BLE_CONFIG
{
    uint8_t puk[8];
    uint8_t idRoot[32];
    uint8_t isRegPuk:1;
    uint8_t isGenPin:1;
}Ble_Config;

typedef struct WIFI_CONFIG
{
    uint8_t puk[8];
    uint8_t idRoot[32];
    uint8_t passwd[32];
    uint8_t isRegPuk:1;
    uint8_t isGenPin:1;
}Wifi_Config;

typedef struct TM
{
  uint16_t  year;
  uint8_t   month;
  uint8_t   day;
  uint8_t   hour;
  uint8_t   min;
  uint8_t   sec;
}DT;

typedef struct COEFFICIENT
{
  float     gain_v[CORR_GROUP_ARRAY];
  float     offset_v[CORR_GROUP_ARRAY];
  float     gain_c[CORR_GROUP_ARRAY];
  float     offset_c[CORR_GROUP_ARRAY];
  float     gain_leak[CORR_GROUP_ARRAY];
  float     offset_leak[CORR_GROUP_ARRAY];
  float     gain_gmi[CORR_GROUP_ARRAY];
  float     offset_gmi[CORR_GROUP_ARRAY];


  uint8_t   offsetisPosOrNeg_v[CORR_GROUP_ARRAY];       //Hao: Not Used
  uint8_t   offsetisPosOrNeg_c[CORR_GROUP_ARRAY];       //Hao: Not Used
  uint8_t   offsetisPosOrNeg_leak[CORR_GROUP_ARRAY];    //Hao: Not Used
  uint8_t   offsetisPosOrNeg_gmi[CORR_GROUP_ARRAY];     //Hao: Used
}Coefficient;

typedef struct ALARM_DEF
{
    uint16_t    fail;
    uint16_t    restore;
    uint8_t     retry;
    uint8_t     isOccurInCharging;
    uint8_t     isLatch;
}Alarm_Def;

typedef struct COUNTER
{
    Alarm_Def    L1_OV;
    Alarm_Def    L2_OV;
    Alarm_Def    L3_OV;
    Alarm_Def    L1_UV;
    Alarm_Def    L2_UV;
    Alarm_Def    L3_UV;
    Alarm_Def    L1_OC;
    Alarm_Def    L2_OC;
    Alarm_Def    L3_OC;
    Alarm_Def    OT;
    Alarm_Def    GF;
    Alarm_Def    LEAK;      // CORMEX
    Alarm_Def    LEAK_AC ;  // VAC
    Alarm_Def    LEAK_DC ;  // VAC
    Alarm_Def    EMO;
    Alarm_Def    RELAY;
    Alarm_Def    RELAY_Drive_Fualt;
    Alarm_Def    CP;
    Alarm_Def    LEAK_MODULE;
    Alarm_Def    AC_Drip;
    Alarm_Def    Meter_Timeout;

#ifdef FUNC_ALARM_CP_NEG_ERROR
    Alarm_Def    CP_Neg;
#endif

#ifdef FUNC_GUN_LOCK
    Alarm_Def    GunLock;
#endif

#ifdef FUNC_AX80_ADD_TILT_SENSOR
    Alarm_Def    TiltSensor;
#endif

    uint16_t     RST_CFG;
    uint16_t     WatchDogLeak;

}Counter;

typedef struct LED
{
  uint8_t 	motion;                 // LED motion command reference const declare
}Led;

typedef struct SPEAKER
{
  uint8_t 	motion;                 // LED motion command reference const declare
}Speaker;

typedef struct CYCLE_INFO
{
    DT          startDateTime;      // Charging start dqte timeinfo
    uint8_t     userId[32];         // Start user ID
    uint32_t    startTimeTick;      // Time tick in million second which get from HAL_GetTick()
    uint32_t    endTimeTick;        // Same as startTimeTick

    //uint32_t    meterStart;         // Cycle start meter read value;
    uint64_t    meterStart;         // Cycle start meter read value;

    uint32_t    Power_Consumption;  // Charging total power(KWH) resolution is 0.01
    uint32_t    Duration;           // Charging duration unit: ms
    uint8_t     StartType;          // 0: CP detect     1: RFID     2: BLE      3: Backend
}Cycle_Info;

typedef struct RFID
{
    uint8_t	data_Sn[16];        // RFID serial number data
    uint8_t	data_Block[16];     // RFID operation block data
    uint8_t	currentCard[16];    // Current charging cycle start card number
    uint8_t	nowCard[16];        // now card number
    uint8_t     snType;             // 0: 4 bytes   1: 7 bytes  2:  10 Bytes
    uint8_t     targetBlock;        // RFID read/write target block
    uint8_t     key[6];             // RFID access key
    uint8_t     keyType;            // 0: Key-A     1: Key-B
    uint8_t     cardType;           // 1: 14443     2: 15693   3:felica
    uint8_t	Charge_data_Sn[16];        // RFID serial number data
    struct
    {
        uint8_t reqBlockRead:1;     // Read block data request flag
        uint8_t reqBlockWrite:1;    // Write block data request flag
        uint8_t reqHalt:1;          // Halt card request flag
        uint8_t reqStart:1;         // RFID start charging cycle request flag
        uint8_t reqStop:1;          // RFID stop charging cycle request flag
        uint8_t isBlockReadOK:1;    // RFID block data read ok flag
        uint8_t isBlockWriteOK:1;   // RFID block data write ok flag
        uint8_t isFelicaDelay:1;    //
    }op_bits;
}Rfid;

typedef struct BLE
{
    uint8_t initSeq;                // BLE module initial sequence
    uint8_t peripheral_mac[13];     // BLE module mac address
    uint8_t loginRole;              // BLE login role, 0: Unkown    1: Root     2: User     3: Visitor
    uint8_t loginId[32];           // BLE central login id
    uint8_t isRequestOn:1;          // BLE start charging cycle request
    uint8_t isRequestOff:1;         // BLE stop charging cycle request
    uint8_t isDataMode:1;           // BLE module is in data mode
}Ble;

typedef struct WIFI
{
    uint8_t initSeq;                // WIFI module intiail sequence
    uint8_t	module_mac[13];         // WIFI module mac address
    uint8_t loginRole;              // WIFI login role, 0: Unkown    1: Root     2: User     3: Visitor
    uint8_t loginId[32];            // WIFI central login id
	uint8_t isRequestOn:1;          // WIFI start charging cycle request
	uint8_t isRequestOff:1;         // WIFI stop charging cycle request
    uint8_t isDataMode:1;           // WIFI module is in data mode
}Wifi;

#ifndef RECODE_METER_PRO380

typedef struct METER
{
  uint32_t      Power_Consumption_Cumulative ;   // 4 Byte  -> Power consumption keep data, resolution 0.0001 KWH (0.1W)    // V*I*3600000ms = WH  ,   0.1W *10 = W
  uint32_t      L1_Voltage ;
  uint32_t      L2_Voltage ;
  uint32_t      L3_Voltage ;
  uint32_t      L1_Current ;
  uint32_t      L2_Current ;
  uint32_t      L3_Current ;
  uint32_t      Total_Active_Power;
  uint32_t      Frequency;
  uint32_t      Harmonic;
}Meter;

#ifdef MODIFY_METER_EXT_PRO380

typedef struct _MeterPRO380
{
    float m_AE_T1_Total;  //0x6002: T1 Total active energy (kWh)
    float m_AE_T2_Total;  //0x6004: T2 Total active energy (kWh)
    union
    {
        float m_AE_Lx_Total[AC_PHASE_NUM_MAX];
        struct
        {
            float m_AE_L1_Total;  //0x6006: L1 Total active energy (kWh)
            float m_AE_L2_Total;  //0x6008: L1 Total active energy (kWh)
            float m_AE_L3_Total;  //0x600A: L1 Total active energy (kWh)
        };
    };

    uint32_t m_LastUpdateTick;
}

MeterPRO380, *PMeterPRO380;

#endif //MODIFY_METER_EXT_PRO380

#endif //!RECODE_METER_PRO380

//edward 2019_08_28
typedef struct AM3352
{
    uint16_t RequestPinDebounceCnt; // CSU request action debounce counter
    uint8_t LedActionState;         // CSU LED action state
#ifdef FUNC_AW48_NET_LED
    uint8_t NetLedActionState;         // CSU LED action state for connectivity status
    uint8_t NetLedActionSubState;
#endif
    uint32_t LedAlarmState;         // CSU LED alarm state
    uint8_t RotarySwitchState;      // CSU rotary switch
    uint16_t BreatheLedAuthdFadeIn;   //Authd breathe led fade in time
    uint16_t BreatheLedAuthdFadeOut;   //Authd breathe led fade out time
    uint16_t BreatheLedConnectFadeIn;   //Connect breathe led fade in time
    uint16_t BreatheLedConnectFadeOut;   //Connect breathe led fade out time
    uint16_t BreatheLedChargeFadeIn;   //Charge breathe led fade in time
    uint16_t BreatheLedChargeFadeOut;   //Charge breathe led fade out time

    uint8_t isPWMOn:1;              // CSU PWM action status, 0: Off    1: Off
    uint8_t isRequestOn:1;          // CSU relay action request on
    uint8_t isRequestOff:1;         // CSU relay action request off
}Am3352;

typedef struct RESERVATION
{
    uint8_t mode;                   // Reservation mode, 0:Disable     1:Once      2:Always
    uint8_t hour;                   // Reservation hour
    uint8_t min;                    // Reservation minute
}Reservation;

#ifdef FUNC_METER_IC_ADE7858A

#define METER_IC_MEAS_VALS_NUM  (19)

typedef union _MeterIC_MeasVals
{
    int32_t m_Data[METER_IC_MEAS_VALS_NUM];
    struct
    {

        int32_t m_AVRMS; //Phase A voltage rms value
        int32_t m_BVRMS; //Phase B voltage rms value
        int32_t m_CVRMS; //Phase C voltage rms value

        int32_t m_AIRMS; //Phase A current rms value
        int32_t m_BIRMS; //Phase B current rms value
        int32_t m_CIRMS; //Phase C current rms value

        int32_t m_AVRMS_LRIP; //1.024 sec average of Phase A voltage rms value
        int32_t m_BVRMS_LRIP; //1.024 sec average of Phase B voltage rms value
        int32_t m_CVRMS_LRIP; //1.024 sec average of Phase C voltage rms value

        int32_t m_AIRMS_LRIP; //1.024 sec average of Phase A current rms value
        int32_t m_BIRMS_LRIP; //1.024 sec average of Phase B current rms value
        int32_t m_CIRMS_LRIP; //1.024 sec average of Phase C current rms value

        int32_t m_AWATT; //Instantaneous value of Phase A total active power
        int32_t m_BWATT; //Instantaneous value of Phase B total active power
        int32_t m_CWATT; //Instantaneous value of Phase C total active power

        int32_t m_AWATTHR; //Phase A total active energy accumulation
        int32_t m_BWATTHR; //Phase B total active energy accumulation
        int32_t m_CWATTHR; //Phase C total active energy accumulation

        int32_t m_Period; //Reserved
    };


}
MeterIC_MeasVals, *PMeterIC_MeasVals;

typedef enum _MeterIC_CaliValType
{
    //Read/Write Function
    MICC_AVGAIN = 0x01,
    MICC_BVGAIN = 0x02,
    MICC_CVGAIN = 0x03,

    MICC_AVRMSOS = 0x11,
    MICC_BVRMSOS = 0x12,
    MICC_CVRMSOS = 0x13,

    MICC_AIGAIN = 0x21,
    MICC_BIGAIN = 0x22,
    MICC_CIGAIN = 0x23,

    MICC_AIRMSOS = 0x31,
    MICC_BIRMSOS = 0x32,
    MICC_CIRMSOS = 0x33,

    MICC_APHCAL = 0x41,
    MICC_BPHCAL = 0x42,
    MICC_CPHCAL = 0x43,

    MICC_UNDEFINED = 0xFF,

#ifdef FUNC_QUERY_METER_IC_DIE_VERSION
    MICC_GET_DIE_VERSION = 0x50,
#endif

    //Read Function Test
#ifdef FUNC_METER_IC_CALI_FLAG
    MICC_READ_METER_IC_CALI_FLAG = 0xB0,
#endif

    //Write Function Test
    MICC_RESET_POWER_CONSUMPTION_CUMULATIVE = 0xA0,
    MICC_RESET_METER_IC_ALL_CALI_VAL_00 = 0xC0,
    MICC_RESET_METER_IC_ALL_CALI_VAL_FF = 0xC1,

#ifdef FUNC_GUN_LOCK
    MICC_SET_GUN_LOCK_STATUS = 0xD0,
#endif

#ifdef FUNC_VOLATILE_OPERATION

#ifdef VO_SIMU_ACV
    MICC_SET_SIMU_ACV_VOLT = 0xE0,
#endif

#ifdef VO_SIMU_NTC
    MICC_SET_SIMU_NTC_TEMP = 0xE1,
#endif

#ifdef VO_SIMU_ALARMCODE
    MICC_SET_SIMU_ALARMCIDE_VAL = 0xE2,
#endif

#ifdef VO_SIMU_ACA
    MICC_SET_SIMU_ACA_CURR = 0xE3,
#endif

#ifdef VO_GET_VO_CODE
    MICC_GET_VO_CODE = 0xFB,
#endif

    MICC_SET_VO_CODE = 0xFC,

#ifdef VO_SIMU_CP
    MICC_SET_SIMU_CP_VOLT = 0xFD,
#endif
#ifdef VO_SIMU_PP
    MICC_SET_SIMU_PP_CURR = 0xFE
#endif

#endif //FUNC_VOLATILE_OPERATION


}
MeterIC_CaliValType;

#define AUTHCODE_RESET_POWER_CONSUMPTION_CUMULATIVE (0x55667788)
#define AUTHCODE_RESET_METER_IC_ALL_CALI_VAL (0x11223344)

#define METER_IC_CALI_VALS_NUM  (15)
#define METER_IC_CALI_ITEM_PHCAL_BEG_IDX  (12)
#define METER_IC_CALI_ITEM_PHCAL_END_IDX  (14)
typedef union _MeterIC_CaliVals
{
    int32_t m_Data[METER_IC_CALI_VALS_NUM];
    struct
    {
        //Voltage
        int32_t m_AVGAIN;  //0: Phase A voltage gain adjust
        int32_t m_BVGAIN;  //1: Phase B voltage gain adjust
        int32_t m_CVGAIN;  //2: Phase C voltage gain adjust

        int32_t m_AVRMSOS; //3: Phase A voltage rms offset
        int32_t m_BVRMSOS; //4: Phase B voltage rms offset
        int32_t m_CVRMSOS; //5: Phase C voltage rms offset

        //Current
        int32_t m_AIGAIN;  //6: Phase A current gain adjust
        int32_t m_BIGAIN;  //7: Phase B current gain adjust
        int32_t m_CIGAIN;  //8: Phase C current gain adjust

        int32_t m_AIRMSOS; //9: Phase A current rms offset
        int32_t m_BIRMSOS; //10: Phase B current rms offset
        int32_t m_CIRMSOS; //11: Phase C current rms offset

        //Phase
        int32_t m_APHCAL;  //12: Phase calibration of Phase A
        int32_t m_BPHCAL;  //13: Phase calibration of Phase B
        int32_t m_CPHCAL;  //14: Phase calibration of Phase C
    };

}
MeterIC_CaliVals, *PMeterIC_CaliVals;

//Trig to write new calibration values to Meter IC
typedef union _MeterIC_TrigWriteCaliVals
{
    uint32_t m_Data;
    struct
    {
        //Voltage
        uint32_t m_AVGAIN:  1;  //Phase A voltage gain adjust
        uint32_t m_BVGAIN:  1;  //Phase B voltage gain adjust
        uint32_t m_CVGAIN:  1;  //Phase C voltage gain adjust

        uint32_t m_AVRMSOS: 1;  //Phase A voltage rms offset
        uint32_t m_BVRMSOS: 1;  //Phase B voltage rms offset
        uint32_t m_CVRMSOS: 1;  //Phase C voltage rms offset

        //Current
        uint32_t m_AIGAIN:  1;  //Phase A current gain adjust
        uint32_t m_BIGAIN:  1;  //Phase B current gain adjust
        uint32_t m_CIGAIN:  1;  //Phase C current gain adjust

        uint32_t m_AIRMSOS: 1;  //Phase A current rms offset
        uint32_t m_BIRMSOS: 1;  //Phase B current rms offset
        uint32_t m_CIRMSOS: 1;  //Phase C current rms offset

        //Phase
        uint32_t m_APHCAL:  1;  //Phase calibration of Phase A
        uint32_t m_BPHCAL:  1;  //Phase calibration of Phase B
        uint32_t m_CPHCAL:  1;  //Phase calibration of Phase C

        uint32_t m_Reserved: (32 - 15);
    };
}
MeterIC_TrigWriteCaliVals, *PMeterIC_TrigWriteCaliVals;

#ifdef FUNC_METER_IC_CALI_FLAG
//Flag of specific calibration value was write to flash
//(use to identify the device was calibrated or not)
typedef union _MeterIC_CaliFlag
{
    uint32_t m_Data;
    struct
    {
        //Voltage
        uint32_t m_AVGAIN:  1;  //Phase A voltage gain adjust
        uint32_t m_BVGAIN:  1;  //Phase B voltage gain adjust
        uint32_t m_CVGAIN:  1;  //Phase C voltage gain adjust

        uint32_t m_AVRMSOS: 1;  //Phase A voltage rms offset
        uint32_t m_BVRMSOS: 1;  //Phase B voltage rms offset
        uint32_t m_CVRMSOS: 1;  //Phase C voltage rms offset

        //Current
        uint32_t m_AIGAIN:  1;  //Phase A current gain adjust
        uint32_t m_BIGAIN:  1;  //Phase B current gain adjust
        uint32_t m_CIGAIN:  1;  //Phase C current gain adjust

        uint32_t m_AIRMSOS: 1;  //Phase A current rms offset
        uint32_t m_BIRMSOS: 1;  //Phase B current rms offset
        uint32_t m_CIRMSOS: 1;  //Phase C current rms offset

        //Phase
        uint32_t m_APHCAL:  1;  //Phase calibration of Phase A
        uint32_t m_BPHCAL:  1;  //Phase calibration of Phase B
        uint32_t m_CPHCAL:  1;  //Phase calibration of Phase C

        uint32_t m_Reserved: (32 - 15);
    };
}
MeterIC_CaliFlag, *PMeterIC_CaliFlag;
#endif //FUNC_METER_IC_CALI_FLAG

#ifdef FUNC_METER_IC_READ_PHASE_ANGLE
typedef enum _AC_PERIOD_MODE
{
    AC_PERIOD_MODE_UNKNOW = 0,
    AC_PERIOD_MODE_50HZ,
    AC_PERIOD_MODE_60HZ,

    AC_PERIOD_MODE_NUM
}
AC_PERIOD_MODE;

typedef enum _AC_LINE_PHASE_MODE
{
    AC_PHASE_MODE_UNKNOW = 0,
    AC_PHASE_MODE_1P,                   //1 Phase
    AC_PHASE_MODE_240_120_120_SEQ_OK,   //3 Phase
    AC_PHASE_MODE_120_120_240_SEQ_NG,   //3 Phase
    AC_PHASE_MODE_360_360_360,          //1P Simu 3P(L=>L1, L2, L3)

    AC_PHASE_MODE_NUM
}
AC_PHASE_MODE;

typedef struct _MeterIC_ExtraInfo
{
    int32_t m_AngleReg[3];
    double m_AngleDegree[3];
    int32_t m_MMODE;
    int32_t m_COMPMODE;
    AC_PERIOD_MODE m_AcPeriodMode;
    AC_PHASE_MODE m_AcPhaseMode;
    int32_t m_STATUS0;
    int32_t m_STATUS1;
    uint8_t m_bSEQERR: 1; //STATUS1 bit19

#ifdef FUNC_QUERY_METER_IC_DIE_VERSION
    uint8_t m_DieVersion;
#endif

}
MeterIC_ExtraInfo, *PMeterIC_ExtraInfo;
#endif //FUNC_METER_IC_READ_PHASE_ANGLE

#endif //FUNC_METER_IC_ADE7858A

#ifdef MODIFY_UNDEFINED_MODEL_NAME_AND_SN_ISSUE
#define MODEL_NAME_LEN  (64)
#define SERIAL_NUM_LEN  (64)
#define SYSTEM_ID_LEN   (MODEL_NAME_LEN + SERIAL_NUM_LEN)
#endif

typedef struct MEM
{
    struct
    {
        union
        {
            uint8_t value[W25Q16FV_BLOCK_SIZE];             // 4096 byte
#ifdef FUNC_FLASH_CONFIG_APPEND_CRC
            struct
            {
                uint8_t buf[W25Q16FV_BLOCK_SIZE - 4];
                uint32_t crc32;
            } verify;
#endif
            struct
            {
#ifdef MODIFY_UNDEFINED_MODEL_NAME_AND_SN_ISSUE
                char        ModelName[MODEL_NAME_LEN];      // 32 Byte -> EVSE model name max 64 byte in ASCII
                char        SerialNumber[SERIAL_NUM_LEN];   // 32 Byte -> EVSE serial number max 64 byte in ASCII
                char        System_ID[SYSTEM_ID_LEN];       // 64 Byte -> Byte EVSE system ID max 128 bytes in ASCII
#else
                char        ModelName[64];                  // 32 Byte -> EVSE model name max 64 byte in ASCII
                char        SerialNumber[64];               // 32 Byte -> EVSE serial number max 64 byte in ASCII
                char        System_ID[128];                 // 64 Byte -> Byte EVSE system ID max 128 bytes in ASCII
#endif
                DT          SystemDateTime;                 // 7 Byte  -> EVSE system dat & time info, sync from RTC
                uint8_t     AuthMode;                       // 1 Byte  -> 0: OCPP backend , 1: free mode
                uint8_t     MCU_Control_Mode;               // 0: without CSU   1: with CSU     2: by pass
                uint16_t    MaxChargingEnergy;              // 2 Byte  -> 0: No limit      Other: Limit max energy per cycle in KWH
                uint16_t    MaxChargingCurrent;             // 2 Byte  -> 0: Rating value  Other: Linit max current output per cycle
                uint16_t    MaxChargingDuration;            // 2 Byte  -> 0: No limit      Other: Limit max duration per cycle in minutes
                uint16_t    Correction_VL1[4][2];           // 16 Byte -> Voltage L1 correction point data(adc & meter) [point][adc(0) & meter(1)]
                uint16_t    Correction_VL2[4][2];           // 8 Byte  -> Voltage L2 correction point data(adc & meter) [point][adc(0) & meter(1)]
                uint16_t    Correction_VL3[4][2];           // 8 Byte  -> Voltage L3 correction point data(adc & meter) [point][adc(0) & meter(1)]
                uint16_t    Correction_CL1[4][2];           // 16 Byte -> Current L1 correction point data(adc & meter) [point][adc(0) & meter(1)]
                uint16_t    Correction_CL2[4][2];           // 8 Byte  -> Current L2 correction point data(adc & meter) [point][adc(0) & meter(1)]
                uint16_t    Correction_CL3[4][2];           // 8 Byte  -> Current L3 correction point data(adc & meter) [point][adc(0) & meter(1)]
                uint16_t    Correction_Leak[4][2];          // 16 Byte -> Leak Current correction point data(adc & meter) [point][adc(0) & meter(1)]
                uint16_t    Correction_GMI[4][2];           // 16 Byte -> GMI correction point data(adc & meter) [point][adc(0) & meter(1)]

#ifndef FUNC_POWER_CONSUMPTION_BY_METER_IC
//                uint32_t    Power_Consumption_Cumulative;   // 4 Byte  -> Power consumption keep data, resolution 0.0001 KWH (0.1W)    // V*I*3600000ms = WH  ,   0.1W *10 = W
#endif

                uint32_t    AcPlugInTimes;                  // 4 Byte  -> Connector plug counter
                uint8_t     isRestoreFactory:1;             // 1 Byte  -> 0: No action 1: Trigger EVSE restore factory value
                uint8_t     RFID_SN_Endian:1;               // 1 Byte  -> 0: Little    1: Big
                uint8_t     isAuthEnable:1;                 // 1 Byte  -> 0: User authorization disable    1: User authorizing enable
                uint8_t     isDispDebug:1;                  // 1 Byte  -> 0: Non-display debug info        1: Display debug info
                Reservation reservation;                    // 3 Byte  -> EVSE reservation config
                Ble_Config  bleConfig;                      // 41 Byte -> BLE PUK & PIN config
                Wifi_Config wifiConfig;                     // 73 Byte -> WIFI config
                uint8_t     OfflinePolicy;                  // 1 Byte  -> 0: local list , 1: Phihong RFID tag , 2: free charging , 3: no charging

#ifndef FUNC_POWER_CONSUMPTION_BY_METER_IC
//                uint32_t    Power_Consumption_L1_Cumulative;   // 4 Byte  -> Power consumption keep data, resolution 0.0001 KWH (0.1W)    // V*I*3600000ms = WH  ,   0.1W *10 = W
//                uint32_t    Power_Consumption_L2_Cumulative;   // 4 Byte  -> Power consumption keep data, resolution 0.0001 KWH (0.1W)    // V*I*3600000ms = WH  ,   0.1W *10 = W
//                uint32_t    Power_Consumption_L3_Cumulative;   // 4 Byte  -> Power consumption keep data, resolution 0.0001 KWH (0.1W)    // V*I*3600000ms = WH  ,   0.1W *10 = W

#else //FUNC_POWER_CONSUMPTION_BY_METER_IC
                uint64_t    PowerConsumptionCumulative_Total;    // 8 Byte  -> Power consumption keep data, resolution 0.0001 KWH (0.1W)    // V*I*3600000ms = WH  ,   0.1W *10 = W
                union
                {
                    uint64_t PowerConsumptionCumulative_Lx[AC_PHASE_NUM_MAX];  //x: 0, 1, 2 => L1, L2, L3
                    struct
                    {
                        uint64_t    PowerConsumptionCumulative_L1;  // 8 Byte  -> Power consumption keep data, resolution 0.0001 KWH (0.1W)    // V*I*3600000ms = WH  ,   0.1W *10 = W
                        uint64_t    PowerConsumptionCumulative_L2;  // 8 Byte  -> Power consumption keep data, resolution 0.0001 KWH (0.1W)    // V*I*3600000ms = WH  ,   0.1W *10 = W
                        uint64_t    PowerConsumptionCumulative_L3;  // 8 Byte  -> Power consumption keep data, resolution 0.0001 KWH (0.1W)    // V*I*3600000ms = WH  ,   0.1W *10 = W

                    };
                };
#endif //FUNC_POWER_CONSUMPTION_BY_METER_IC

#ifdef FUNC_METER_IC_ADE7858A
                MeterIC_CaliVals m_MeterIC_CaliVals;        //Meter IC - Calibration values
#ifdef FUNC_METER_IC_CALI_FLAG
                MeterIC_CaliFlag m_MeterIC_CaliFlag;        //Meter IC - Calibration flag
#endif //FUNC_METER_IC_CALI_FLAG
#endif //FUNC_METER_IC_ADE7858A

#ifdef FUNC_CSU_PUBLIC_KEY_OPERATION
#define CSU_PUBLIC_KEY_LEN  (64)
                uint8_t m_CsuPublicKey[CSU_PUBLIC_KEY_LEN]; //CSU set Public Key (ECDSA)
#endif

#ifdef FUNC_MODE_DEBUG_REC_RELAY_ON_TIMES
                uint32_t m_ModeDebugRelayOnTimes; //For QE record RelayOn times
#endif

            }item;
        }data;

        struct
        {
            uint8_t update:1;                               // Update ram content to external flash request
            uint8_t clear:1;                                // Clear ram & external flash content request
            uint8_t read:1;                                 // Read external flash content to ram request
            uint8_t backup:1;                               // Backup data to external flash request
            uint8_t restore:1;                              // Restore backup data from external flash request
        }op_bits;
    }EVSE_Config;

    struct
    {
        union
        {
            uint8_t value[W25Q16FV_BLOCK_SIZE];
            struct
            {
                uint8_t     isEnable:1;                     // Cold load pick up function is enable
                DT          DateTime;                       // Charging start date time info
                uint8_t     user[32];                       // Start user account / card number / mac address
                char        PlugType[16];                   // Plug type max 16 bytes in ASCII
                uint32_t    Duration;                       // Charging duration unit: ms
                uint16_t    powerSum;                       // Charging total power(KWH) resolution is 0.01
                uint8_t     startType;                      // 0: CP detect     1: RFID     2: BLE      3: Backend
            }item;
        }data;

        struct
        {
            uint8_t update:1;                               // Update ram content to external flash request
            uint8_t clear:1;                                // Clear ram & external flash content request
            uint8_t read:1;                                 // Read external flash content to ram request
            uint8_t backup:1;                               // Backup data to external flash request
            uint8_t restore:1;                              // Restore backup data from external flash request
        }op_bits;
    }coldLoadPickUp;

    struct
    {
        union
        {
            uint8_t value[W25Q16FV_BLOCK_SIZE];
            struct
            {
                uint8_t     listType;                       // 0: RFID  1: BLE
                uint8_t     pin[6];                         // Bonding pin code, max 6 digital in ASCII
                uint8_t     listID[32];                     // list ID
                uint8_t     isReg;                          // PIN already registe flag  0: non-registe     1: registed
            }item[W25Q16FV_BLOCK_SIZE>>6];                  // Sector max record only 4096/64 = 64 records.
        }data;

        struct
        {
            uint8_t update:1;                               // Update ram content to external flash request
            uint8_t clear:1;                                // Clear ram & external flash content request
            uint8_t read:1;                                 // Read external flash content to ram request
        }op_bits;
    }whiteList;

    struct
    {
        union
        {
            uint8_t value[W25Q16FV_BLOCK_SIZE];
            struct
            {
                DT          DateTime;                       // Charging start date time info
                uint32_t    alarmCode;                      // Please refence code specification document
                uint8_t     mode;                           // EVSE last system mode before alarm occur
                uint8_t     isRecover;                      // 0: occur     1: recover
            }item[W25Q16FV_BLOCK_SIZE>>4];                  // Sector max record only 4096/16 = 256 records.
        }data;

        struct
        {
            uint8_t update:1;                               // Update ram content to external flash request
            uint8_t clear:1;                                // Clear ram & external flash content request
            uint8_t read:1;                                 // Read external flash content to ram request
            uint8_t backup:1;                               // Backup data to external flash request
            uint8_t restore:1;                              // Restore backup data from external flash request
        }op_bits;
    }hisAlarm;

#ifdef FUNC_METER_IC_HISTORY
    struct
    {
        union
        {
            uint8_t value[W25Q16FV_BLOCK_SIZE];         //4096
            struct                                      // Total (One Record) (16B)
            {
                DT      DateTime;                       // Charging start date time info (8B)
                int32_t m_CaliVal;                      // Calibration value (4B)
                MeterIC_CaliValType m_CaliValType;      // Caalibration value type (1B)
                uint8_t m_Reserved[2];                  // (2B)
                uint8_t m_CheckSum;                     // (1B)
            //}item[W25Q16FV_BLOCK_SIZE>>4];              // Sector max record only 4096/16 = 256 records.
            }item[METER_IC_HISTORY_REC_NUM];              // Sector max record only 4096/16 = 256 records.
        }data;

        struct
        {
            uint8_t update:1;                               // Update ram content to external flash request
            uint8_t clear:1;                                // Clear ram & external flash content request
            uint8_t read:1;                                 // Read external flash content to ram request
            uint8_t backup:1;                               // Backup data to external flash request
            uint8_t restore:1;                              // Restore backup data from external flash request
        }op_bits;
    }hisMeterIC;
#else //FUNC_METER_IC_HISTORY
    struct
    {
        union
        {
            uint8_t value[W25Q16FV_BLOCK_SIZE];
            struct
            {
                DT          DateTime;                       // Charging start date time info
                uint8_t     user[32];                       // Start user account / card number / mac address
                char        PlugType[12];                   // Plug type max 16 bytes in ASCII
                uint32_t    Duration;                       // Charging duration unit: ms

                //variable "stopStatusCode" should move to here for 4-byte align, prevent overflow! (Hao#20210614)
                //uint32_t    stopStatusCode;                 // Charging stop reason as status code

                uint16_t    powerSum;                       // Charging total power(KWH) resolution is 0.01
                uint32_t    stopStatusCode;                 // Charging stop reason as status code
                uint8_t     startType;                      // 0: CP detect     1: RFID     2: BLE      3: Backend
            }item[W25Q16FV_BLOCK_SIZE>>6];                  // Sector max record only 4096/64 = 64 records.
        }data;

        struct
        {
            uint8_t update:1;                               // Update ram content to external flash request
            uint8_t clear:1;                                // Clear ram & external flash content request
            uint8_t read:1;                                 // Read external flash content to ram request
            uint8_t backup:1;                               // Backup data to external flash request
            uint8_t restore:1;                              // Restore backup data from external flash request
        }op_bits;
    }hisCharging;
#endif //FUNC_METER_IC_HISTORY

}Mem;

typedef struct BUTTON
{
    uint32_t count;
    uint8_t display;
}button;

typedef struct ALARMSECP
{
    uint16_t Current_LEAK_AC;

#ifdef FUNC_NEW_RELAY_MONITOR

    //DriveFault threshold formula: y = ax + b (V)
    double Relay_LL_DriveFault_Slop;    //a
    double Relay_LL_DriveFault_Offs;    //b

    //Welding threshold formula: y = ax + b (V)
    double Relay_LL_Welding_Slop;       //a
    double Relay_LL_Welding_Offs;       //b

#endif

#ifdef MODIFY_OTP_SPEC

#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
    uint8_t OT_G1_1; //protect
    uint8_t OT_G1_2; //latch
    uint8_t OT_G1_HYSTERESIS;

    uint8_t OT_G2_1; //protect
    uint8_t OT_G2_2; //latch
    uint8_t OT_G2_HYSTERESIS;

#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
    uint8_t OT_G3_1; //protect
    uint8_t OT_G3_2; //latch
    uint8_t OT_G3_HYSTERESIS;
#endif

#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
    uint8_t OT_G4_1; //protect
    uint8_t OT_G4_2; //latch
    uint8_t OT_G4_HYSTERESIS;
#endif

#else //FUNC_AX80_ADD_4_TEMP_SENEOR
    uint8_t OT_1; //protect
    uint8_t OT_2; //latch
    uint8_t OT_HYSTERESIS;
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR

#endif //MODIFY_OTP_SPEC

}AlarmSpec;


/* USER CODE END EC */

/* Exported macro ------------------------------------------------------------*/
/* USER CODE BEGIN EM */

/* USER CODE END EM */

/* Exported functions prototypes ---------------------------------------------*/
void Error_Handler(void);

/* USER CODE BEGIN EFP */
extern volatile unsigned long  ulHighFrequencyTimerTicks;
extern void SystemClock_Config(void);


//---------------------------------------------------------------
#ifdef FUNC_OUTP_TYPE_E
HTK_BOOL IsTypeEPlugIn(void);
#endif

#ifdef MODIFY_CPTASK_HEAD
void Proc_CpTaskHead(HTK_BOOL bCSU);
#endif

/* USER CODE END EFP */

/* Private defines -----------------------------------------------------------*/
#define OUT_MeterIC_Reset_Pin GPIO_PIN_2
#define OUT_MeterIC_Reset_GPIO_Port GPIOE
#define OUT_BLE_RESET_Pin GPIO_PIN_3
#define OUT_BLE_RESET_GPIO_Port GPIOE
#define IN_Tilt_ActOn_Pin GPIO_PIN_4
#define IN_Tilt_ActOn_GPIO_Port GPIOE
#define TIM9_CH1_PWM_LED_R_Pin GPIO_PIN_5
#define TIM9_CH1_PWM_LED_R_GPIO_Port GPIOE
#define TIM9_CH2_PWM_LED_G_Pin GPIO_PIN_6
#define TIM9_CH2_PWM_LED_G_GPIO_Port GPIOE
#define OUT_Tilt_DrvLeakage_Pin GPIO_PIN_13
#define OUT_Tilt_DrvLeakage_GPIO_Port GPIOC
#define I2C2_SDA_MeterIc_Pin GPIO_PIN_0
#define I2C2_SDA_MeterIc_GPIO_Port GPIOF
#define I2C2_SCL_MeterIc_Pin GPIO_PIN_1
#define I2C2_SCL_MeterIc_GPIO_Port GPIOF
#define IN_MEM_Erase_Pin GPIO_PIN_2
#define IN_MEM_Erase_GPIO_Port GPIOF
#define ADC3_IN9_Voltage_L1_Pin GPIO_PIN_3
#define ADC3_IN9_Voltage_L1_GPIO_Port GPIOF
#define ADC3_IN14_1998_Pin GPIO_PIN_4
#define ADC3_IN14_1998_GPIO_Port GPIOF
#define ADC3_IN15_Temp_Pin GPIO_PIN_5
#define ADC3_IN15_Temp_GPIO_Port GPIOF
#define ADC3_IN4_GMI_VL1_Pin GPIO_PIN_6
#define ADC3_IN4_GMI_VL1_GPIO_Port GPIOF
#define ADC3_IN5_Current_L2_Pin GPIO_PIN_7
#define ADC3_IN5_Current_L2_GPIO_Port GPIOF
#define ADC3_IN6_PP_GUN_DET_Pin GPIO_PIN_8
#define ADC3_IN6_PP_GUN_DET_GPIO_Port GPIOF
#define ADC3_IN7_Current_L1_Pin GPIO_PIN_9
#define ADC3_IN7_Current_L1_GPIO_Port GPIOF
#define ADC3_IN8_Voltage_L2_Pin GPIO_PIN_10
#define ADC3_IN8_Voltage_L2_GPIO_Port GPIOF
#define ADC3_IN10_Voltage_L3_Pin GPIO_PIN_0
#define ADC3_IN10_Voltage_L3_GPIO_Port GPIOC
#define ADC3_IN11_Current_L3_Pin GPIO_PIN_1
#define ADC3_IN11_Current_L3_GPIO_Port GPIOC
#define NoneUse_Pin28_GPIO_PC2_Pin GPIO_PIN_2
#define NoneUse_Pin28_GPIO_PC2_GPIO_Port GPIOC
#define OutpowerCtr_LED24V_Pin GPIO_PIN_3
#define OutpowerCtr_LED24V_GPIO_Port GPIOC
#define UART4_TX_meter_Pin GPIO_PIN_0
#define UART4_TX_meter_GPIO_Port GPIOA
#define UART4_RX_meter_Pin GPIO_PIN_1
#define UART4_RX_meter_GPIO_Port GPIOA
#define RS485_SW_Pin GPIO_PIN_2
#define RS485_SW_GPIO_Port GPIOA
#define BLE_SW_Pin GPIO_PIN_3
#define BLE_SW_GPIO_Port GPIOA
#define ADC1_IN4_CP_Pin GPIO_PIN_4
#define ADC1_IN4_CP_GPIO_Port GPIOA
#define ADC2_IN5_Welding_Pin GPIO_PIN_5
#define ADC2_IN5_Welding_GPIO_Port GPIOA
#define ADC2_IN6_GF_Pin GPIO_PIN_6
#define ADC2_IN6_GF_GPIO_Port GPIOA
#define NoneUse_Pin43_GPIO_PA7_Pin GPIO_PIN_7
#define NoneUse_Pin43_GPIO_PA7_GPIO_Port GPIOA
#define LED_R_Ctr_Pin GPIO_PIN_4
#define LED_R_Ctr_GPIO_Port GPIOC
#define LED_G_Ctr_Pin GPIO_PIN_5
#define LED_G_Ctr_GPIO_Port GPIOC
#define LED_B_Ctr_Pin GPIO_PIN_0
#define LED_B_Ctr_GPIO_Port GPIOB
#define M_LED_B1_Pin GPIO_PIN_1
#define M_LED_B1_GPIO_Port GPIOB
#define NoneUse_Pin48_GPIO_PB2_Pin GPIO_PIN_2
#define NoneUse_Pin48_GPIO_PB2_GPIO_Port GPIOB
#define OUT_LOCK_L_Pin GPIO_PIN_11
#define OUT_LOCK_L_GPIO_Port GPIOF
#define IN_LOCK_Status_Pin GPIO_PIN_12
#define IN_LOCK_Status_GPIO_Port GPIOF
#define OUT_UNLOCK_L_Pin GPIO_PIN_13
#define OUT_UNLOCK_L_GPIO_Port GPIOF
#define NoneUse_Pin54_GPIO_PF14_Pin GPIO_PIN_14
#define NoneUse_Pin54_GPIO_PF14_GPIO_Port GPIOF
#define NoneUse_Pin55_GPIO_PF15_Pin GPIO_PIN_15
#define NoneUse_Pin55_GPIO_PF15_GPIO_Port GPIOF
#define OUT_Tilt_Test_Pin GPIO_PIN_0
#define OUT_Tilt_Test_GPIO_Port GPIOG
#define IN_GridType_Select_Pin GPIO_PIN_1
#define IN_GridType_Select_GPIO_Port GPIOG
#define IN_Grid_Groundding_Pin GPIO_PIN_7
#define IN_Grid_Groundding_GPIO_Port GPIOE
#define IN_AC_Current_Set4_Pin GPIO_PIN_8
#define IN_AC_Current_Set4_GPIO_Port GPIOE
#define IN_AC_Current_Set3_Pin GPIO_PIN_9
#define IN_AC_Current_Set3_GPIO_Port GPIOE
#define IN_AC_Current_Set2_Pin GPIO_PIN_10
#define IN_AC_Current_Set2_GPIO_Port GPIOE
#define IN_AC_Current_Set1_Pin GPIO_PIN_11
#define IN_AC_Current_Set1_GPIO_Port GPIOE
#define NoneUse_Pin65_GPIO_PE12_Pin GPIO_PIN_12
#define NoneUse_Pin65_GPIO_PE12_GPIO_Port GPIOE
#define Meter_DIR_Pin GPIO_PIN_13
#define Meter_DIR_GPIO_Port GPIOE
#define TIM1_CH4_PWM_CP_Pin GPIO_PIN_14
#define TIM1_CH4_PWM_CP_GPIO_Port GPIOE
#define OUT_SPI1_CS_Pin GPIO_PIN_15
#define OUT_SPI1_CS_GPIO_Port GPIOE
#define NoneUse_Pin69_GPIO_PB10_Pin GPIO_PIN_10
#define NoneUse_Pin69_GPIO_PB10_GPIO_Port GPIOB
#define IN_Relay_b_Contact_Pin GPIO_PIN_11
#define IN_Relay_b_Contact_GPIO_Port GPIOB
#define IN_GFCI_Reset_Pin GPIO_PIN_12
#define IN_GFCI_Reset_GPIO_Port GPIOB
#define NoneUse_Pin74_GPIO_PB13_Pin GPIO_PIN_13
#define NoneUse_Pin74_GPIO_PB13_GPIO_Port GPIOB
#define TIM12_CH1_PWM_GFCI_Test_Pin GPIO_PIN_14
#define TIM12_CH1_PWM_GFCI_Test_GPIO_Port GPIOB
#define OUT_Leak_Test_Pin GPIO_PIN_15
#define OUT_Leak_Test_GPIO_Port GPIOB
#define OUT_Speaker_Pin GPIO_PIN_10
#define OUT_Speaker_GPIO_Port GPIOD
#define IN_Emergency_Pin GPIO_PIN_11
#define IN_Emergency_GPIO_Port GPIOD
#define ICP_TIM4_CH1_LEAK_PWM_Pin GPIO_PIN_12
#define ICP_TIM4_CH1_LEAK_PWM_GPIO_Port GPIOD
#define IN_BTN_ModeSw_Pin GPIO_PIN_13
#define IN_BTN_ModeSw_GPIO_Port GPIOD
#define IN_SocketE_Detect_Pin GPIO_PIN_14
#define IN_SocketE_Detect_GPIO_Port GPIOD
#define NoneUse_Pin86_GPIO_PD15_Pin GPIO_PIN_15
#define NoneUse_Pin86_GPIO_PD15_GPIO_Port GPIOD
#define IN_BLE_DTR_Pin GPIO_PIN_2
#define IN_BLE_DTR_GPIO_Port GPIOG
#define OUT_BLE_DSR_Pin GPIO_PIN_3
#define OUT_BLE_DSR_GPIO_Port GPIOG
#define OUT_SocketE_Drv_Pin GPIO_PIN_4
#define OUT_SocketE_Drv_GPIO_Port GPIOG
#define OUT_SocketE_Hold_Pin GPIO_PIN_5
#define OUT_SocketE_Hold_GPIO_Port GPIOG
#define IN_RFID_ICC_Pin GPIO_PIN_6
#define IN_RFID_ICC_GPIO_Port GPIOG
#define OUT_Meter_Power_Pin GPIO_PIN_7
#define OUT_Meter_Power_GPIO_Port GPIOG
#define OUT_RFID_Reset_Pin GPIO_PIN_8
#define OUT_RFID_Reset_GPIO_Port GPIOG
#define IN_Leak_Error_Pin GPIO_PIN_6
#define IN_Leak_Error_GPIO_Port GPIOC
#define IN_Leak_AC_Pin GPIO_PIN_7
#define IN_Leak_AC_GPIO_Port GPIOC
#define IN_Leak_DC_Pin GPIO_PIN_8
#define IN_Leak_DC_GPIO_Port GPIOC

#define OUT_RelayDrv_L1_Pin GPIO_PIN_9
#define OUT_RelayDrv_L1_GPIO_Port GPIOC
#define OUT_RelayHold_L1_Pin GPIO_PIN_8
#define OUT_RelayHold_L1_GPIO_Port GPIOA
#define OUT_RelayDrv_L2_Pin GPIO_PIN_9
#define OUT_RelayDrv_L2_GPIO_Port GPIOA
#define OUT_RelayHold_L2_Pin GPIO_PIN_10
#define OUT_RelayHold_L2_GPIO_Port GPIOA

#define IN_1998_Pin GPIO_PIN_15
#define IN_1998_GPIO_Port GPIOA
#define OUT_1998_Pin GPIO_PIN_10
#define OUT_1998_GPIO_Port GPIOC
#define OUT_Meter_485_RE_Pin GPIO_PIN_11
#define OUT_Meter_485_RE_GPIO_Port GPIOC
#define NoneUse_Pin114_GPIO_PD0_Pin GPIO_PIN_0
#define NoneUse_Pin114_GPIO_PD0_GPIO_Port GPIOD
#define NoneUse_Pin115_GPIO_PD1_Pin GPIO_PIN_1
#define NoneUse_Pin115_GPIO_PD1_GPIO_Port GPIOD
#define OUT_USB_DriveBus_Pin GPIO_PIN_3
#define OUT_USB_DriveBus_GPIO_Port GPIOD
#define OUT_Meter_485_DE_Pin GPIO_PIN_4
#define OUT_Meter_485_DE_GPIO_Port GPIOD
#define IN_CCS_Proximity_Pin GPIO_PIN_7
#define IN_CCS_Proximity_GPIO_Port GPIOD
#define IN_USB_OC_Pin GPIO_PIN_10
#define IN_USB_OC_GPIO_Port GPIOG
#define NoneUse_Pin126_GPIO_PG11_Pin GPIO_PIN_11
#define NoneUse_Pin126_GPIO_PG11_GPIO_Port GPIOG
#define OUT_TrigLeakage_Pin GPIO_PIN_12
#define OUT_TrigLeakage_GPIO_Port GPIOG
#define NoneUse_Pin128_GPIO_PG13_Pin GPIO_PIN_13
#define NoneUse_Pin128_GPIO_PG13_GPIO_Port GPIOG
#define LIN_PWM_SW_Pin GPIO_PIN_15
#define LIN_PWM_SW_GPIO_Port GPIOG
#define TIM10_CH1_PWM_LED_B_Pin GPIO_PIN_8
#define TIM10_CH1_PWM_LED_B_GPIO_Port GPIOB
#define M_LED_G1_Pin GPIO_PIN_9
#define M_LED_G1_GPIO_Port GPIOB
#define OUT_StateE_Pin GPIO_PIN_0
#define OUT_StateE_GPIO_Port GPIOE
#define OUT_LED_Breathe_Pin GPIO_PIN_1
#define OUT_LED_Breathe_GPIO_Port GPIOE
/* USER CODE BEGIN Private defines */

//---------------------------------------------------------------

#ifdef FUNC_OUTP_TYPE_E
typedef enum _EOutpMode
{
  OUTPMODE_NONE = 0,
  OUTPMODE_CPGUN,
  OUTPMODE_TYPEE
}
EOutpMode;
#endif

#ifdef FUNC_GUN_LOCK
typedef enum _GL_MODE
{
    GL_MODE_UNLOCK = 0,
    GL_MODE_LOCK
}
GL_MODE;
#endif

#ifdef FUNC_GUN_LOCK_TRIG_MODE
typedef enum _GL_TRIG_MODE
{
    GL_TRIG_MODE_UNKNOW = 0,
    GL_TRIG_MODE_RELAY,
    GL_TRIG_MODE_REQUEST
}
GL_TRIG_MODE;
#endif

//---------------------------------------------------------------

#ifdef FUNC_VOLATILE_OPERATION
typedef union _VolatileOperationCode
{
    uint32_t m_Value;
    struct
    {
#ifdef VO_SIMU_CP
        uint32_t m_EnableSimuCP: 1;
#endif

#ifdef VO_SIMU_PP
        uint32_t m_EnableSimuPP: 1;
#endif

#ifdef VO_DISABLE_RELAY_WELDING
        uint32_t m_DisableRelayWelding: 1;  //0: Enabled; 1: Disabled //Simulate 3P with 1P on AX32 will cause DriveFault
#endif

#ifdef VO_BLOCK_CSU_LED_ACTION_CMD
        uint32_t m_EnableBlockCsuLedCmd: 1;
#endif

#ifdef VO_SIMU_ACV
        uint32_t m_EnableSimuACV: 1;
#endif

#ifdef VO_SIMU_NTC
        uint32_t m_EnableSimuNTC: 1;
#endif

#ifdef VO_SIMU_ALARMCODE
        uint32_t m_EnableSimuAlarmCode: 1;
#endif

#ifdef VO_SIMU_ACA
        uint32_t m_EnableSimuACA: 1;
#endif

#ifdef VO_DISABLE_DETECT_TILT_SENSOR
        uint32_t m_DisableDetectTiltSensor: 1;
#endif

        //uint32_t m_Reserved: (32 - 1);
    };
}
VolatileOperationCode, *PVolatileOperationCode;

#ifdef VO_SIMU_CP
typedef union _SimuCP
{
    uint32_t m_Value;
    struct
    {
        uint16_t m_VoltPos; //mV(+)
        uint16_t m_VoltNeg; //mV(-)
    };
}
SimuCP, *PSimuCP;
#endif //VO_SIMU_CP

typedef struct _SimuData
{

#ifdef VO_SIMU_CP
    SimuCP m_CP;
#endif

#ifdef VO_SIMU_PP
    uint16_t m_PPCurr; //A
#endif

#ifdef VO_SIMU_ACV
        uint16_t m_AcvVolt; //0.01 V
#endif

#ifdef VO_SIMU_NTC
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
        int16_t m_NtcTemp; //1 degree celsius
#else
        uint8_t m_NtcTemp; //1 degree celsius
#endif
#endif //VO_SIMU_NTC

#ifdef VO_SIMU_ALARMCODE
        uint32_t m_AlarmCode;
#endif

#ifdef VO_SIMU_ACA
        uint16_t m_AcaCurr; //0.01 A
#endif

}
SimuData, *PSimuData;

#endif //FUNC_VOLATILE_OPERATION

//---------------------------------------------------------------

#ifdef FUNC_DETECT_PP
typedef struct _PPInfo
{
    uint16_t m_PreCurr;
    uint16_t m_CurCurr; //Current capability of the cable assembly
    uint8_t m_StatusID; //used for PROTOCOL_MESSAGE_QUERY_EVSE_STATE
    //Byte 11 PP status: 0x00(Unknow), 0x01(16A => 13A), 0x02(20A), 0x03(32A), 0x04(63A)
}
PPInfo, *PPPInfo;
#endif

//---------------------------------------------------------------
#ifdef FUNC_PTB_METER_WM3M4C
struct _WM3M4C;
typedef struct _WM3M4C WM3M4C, *PWM3M4C;
#endif

#ifdef RECODE_METER_PRO380
struct _PRO380;
typedef struct _PRO380 PRO380, *PPRO380;
#endif

#ifdef FUNC_TASK_MONITOR
typedef struct _TaskADCInfo
{
    union
    {
        uint32_t m_ADCx_Counter[6];
        struct
        {
            uint32_t m_ADC1_Counter[2];
            uint32_t m_ADC2_Counter[2];
            uint32_t m_ADC3_Counter[2];
        };
    };
    uint8_t m_ContinueResetCounter;
    uint16_t m_TotalResetCounter;
}
TaskADCInfo, *PTaskADCInfo;

typedef struct _TaskMonitor
{
    TaskADCInfo m_ADC;
}
TaskMonitor, *PTaskMonitor;
#endif

//#ifdef FUNC_LIN_CP
struct _LinCP;
typedef struct _LinCP LinCP, *PLinCP;
//#endif

//#ifdef FUNC_EKM_OMNIMETER
struct _EKM_Omnimeter;
typedef struct _EKM_Omnimeter EKM_Omnimeter, *PEKM_Omnimeter;
//#endif

//---------------------------------------------------------------

extern struct EVSE
{
    char        Ver_FW[32];                     // Firmware version max 32 byte in ASCII
    char        Ver_HW[32];                     // Hardware version max 32 byte in ASCII
    uint8_t     Mode;                           // System mode
    uint8_t     Mode_Previous;                  // Previous system mode
    uint8_t     Mode_Before_Alarm;              // System mode before enter alarm mode
    uint32_t    AC_DripisTure;  	        // AC Drip is happen.  0:None  1:is happen AC Drip
    uint32_t    Alarm_Code;  	                // System alarm code
    uint32_t    Alarm_LED;  	                // System alarm LED
    uint32_t    Alarm_Code_Previous;            // Previous system alarm code
    uint8_t     CP_State;                       // Control pilot state
    uint16_t    Voltage[3];                     // EVSE input voltage resolution 0.01V
    uint16_t    Current[3];                     // EVSE output current resolution 0.01A
    uint16_t    Leak_Current;                   // EVSE output leak current resolution  mA
    uint16_t    Gmi_Voltage;                    // EVSE output Gmi_Voltage V

    //uint8_t     maxRatingCurrent;               // EVSE Max rating current resolution 1A
    uint16_t     maxRatingCurrent;               // EVSE Max rating current resolution 1A

    uint16_t    MaxChargingCurrent_Previous;    // EVSE previous current limit resolution 1A
    uint8_t     Relay_Action;                   // EVSE output relay action
    uint8_t     Relay_isOperationCompleted;     // EVSE output relay action is Operation completed

#ifdef FUNC_OUTP_TYPE_E
    uint8_t     SE_Relay_Action;                // EVSE SocketE output relay action
    uint8_t     SE_Relay_isOperationCompleted;     // EVSE SocketE output relay action is Operation completed
#endif

    uint8_t     is_RFIDKeepCharger;             // in ocpp mode no RFID.reqStop . CP C->B->C , charger can be charge
    float       GmiMagn100K ;                   // Gmi alarm 100k VAC*Magnification
    float       GmiMagn50K ;                    // Gmi alarm 50k VAC*Magnification
    Temperature temperature;                    // EVSE temperature resolution 1 degree
    Coefficient coefficient;                    // ADC corrention coefficient
    Cycle_Info  cycle_info;                     // Charging cycle info
    Rfid rfid;                                  // RFID related info
    Ble ble;                                    // BLE related info
    Wifi wifi;                                  // WIFI related info
    Am3352 am3352;                              // CSU info
    Led led_R;                                  // LED red info
    Led led_G;                                  // LED green info
    Led led_B;                                  // LED blue info
    Led led_W;                                  // LED white info
    Led led_Breathe;                            // LED breathe info
    Speaker speaker;                            // Speaker info
    Mem memory;                                 // External flash memory info
    Counter counter;                            // Alarm delay counter
    AlarmSpec   alarm_spec;                     // Alarm spec data for modelname Decide , kaho 20200303 add
    uint8_t     Led_Mode;                       // set led mode >> idle , handshaking , charging , stop , alarm
    uint8_t     Led_temp_motion;                // OFF : RFID led prompt OFF , ON :RFID LED prompt ON
    uint8_t     Led_Brightness[12];
    uint16_t    led_pwm_duty[4];
    uint8_t     GroundingSystem;                // different grounding -> LL , LN
    uint8_t     GroundingDetect;                // Ground Detect On-> 1, Off-> 0
    uint8_t     isSetStartTime;                 // 1 : need set Charger.cycle_info.startTimeTick , 0 : Useless Charger.cycle_info.startTimeTick
    uint8_t     CCID_Module_Type;               // 0 : Cormex , 1 : VAC
    uint8_t     Test_LeakModuleisPass;          // 0 : fail , 1 : success
    uint8_t     is_BLEKeepCharger;              // in occp mode no ble.reqStop . CP C->B->C , charger can be charge
    uint32_t    Alarm_Code_before;              // last time system alarm code
    uint32_t    OCP_Magnification;              // EC satet use 1.25 , UL GB use 1.1
#ifndef RECODE_METER_PRO380
    Meter meter ;                               // PRO380 meter use .
#ifdef MODIFY_METER_EXT_PRO380
    MeterPRO380 m_MeterPRO380;                  // Meter PRO380-Mod
#endif
#endif //!RECODE_METER_PRO380
    uint16_t    isDebugEnable:1;                // EVSE enable debug mode   0: Disable      1: Enable
    uint16_t    isAlarmSetPWM:1;                // Alarm -> charger set pwm  0: PWM is never output   1: PWM is output
    uint16_t    isRotarySwitchError:1;          // Rotary Switch set 9~E is Error 0: Error       1: OK
    uint16_t    isTestLeakModule:1;             // 0: don't test leak module , 1: do test leak module
    uint16_t    isDebugModeCPtest:1;            // in debug mode use CP Simulator simulate CP -> 0: CP test off , 1: CP tset on
    uint16_t    istoHandShakeMode:1;            // for rfid MODE -> MODE_IDLE to MODE_HANDSHAKE flag
    uint16_t    isCP_in_B:1;                    // CP status had been in B mode
    uint16_t    CSUisRequest:1 ;                // 1 : CSU is Request , 0 : Request No  Request // when Charger.am3352.isRequestOn 1->0 PWM pull 100%
    uint16_t    ModelReadisOK:1 ;               // 0 : NG  , 1 : OK
    uint16_t    CSUisReady:1;                   // 0 : Init not ready , 1 : Init ready
    uint16_t    isOnSocketE:1;                  // 0 : Not run in socket-E mode, 1 : Run in socket-E mode
#ifdef FUNC_AUTO_IGNORE_AC_PHASE
    //uint16_t    m_bCheckPhaseL23:1;             // 0 : 1 phase model; 1: 3 phase model
    uint16_t    m_b3PhaseModel:1;               // 0 : 1 phase model; 1: 3 phase model

#ifdef FUNC_AX32_USE_AS_1P_MODEL
    uint16_t    m_b3PhaseModelButUse1PhaseOnly:1;
#endif

#endif //FUNC_AUTO_IGNORE_AC_PHASE

#ifdef FUNC_AUTO_USE_EXT_METER
    uint16_t    m_bUseExtMeter_PRO380:1;        // 0: Not use external meter; 1: use external meter (PRO380)

#ifdef FUNC_PTB_METER_WM3M4C
    uint16_t    m_bUseExtMeter_WM3M4C:1;        // 0: Not use external meter; 1: use external meter (WM3M4C)
#endif

#ifdef FUNC_EKM_OMNIMETER
    uint16_t    m_bUseExtMeter_OMNIMETER:1;        // 0: Not use external meter; 1: use external meter (OMNIMETER)
#endif

#endif //FUNC_AUTO_USE_EXT_METER

#ifdef FUNC_DETECT_PP
    uint16_t    m_bDetectPP:1;                  // 0: Not Detect; 1: Detect
#endif

#ifdef FUNC_DETECT_PP_NACS
    uint16_t    m_bDetectPP_NACS:1;                  // 0: Not Detect; 1: Detect
#endif

#ifdef FUNC_GUN_LOCK
    uint16_t    m_bUseGunLock:1;                // 0: without GunLock function; 1: with GunLock function
#endif

#ifdef FUNC_RS485_SLAVE
    uint16_t    m_bRS485SlaveForDCModel:1;      // 0: Not for DC Model; 1: for DC Model
#endif

#ifdef FUNC_FORCE_RUN_CSU_MODE_WITH_DC_MODELNAME
    uint16_t    m_bModelNameDC:1;               //0: Not DC ModelName; 1: DC ModelName
    uint16_t    m_bModelNameDCReadOK:1;
#endif

#ifdef MODIFY_OCP_PROC_WITH_MODELNAME_IDX_3_EURO_SPEC
    uint16_t    m_bModelNameWithEuroSpecOCP:1;
#endif

#ifdef FUNC_OUTP_TYPE_E
    uint16_t    m_bEnableTypeE:1;               // 0: Disable Type E; 1: Enable Type E
#endif

//#ifdef NEW_CP_SPEC
    uint16_t    m_bCpDetectModuleInitOK: 1;     //0: CpDatectModule not init; 1: CpDatectModule init OK
//#endif

#ifdef FUNC_CHECK_MODELNAME_AX_PRIFIX
    uint16_t m_bModelNameAX: 1;                 //0: ModelName is not "AX~"; 1: ModelName is "AX~";
#endif

#ifdef FUNC_AX80
    uint16_t m_bModelNameAX80_1P: 1;               //1P 0: ModelName is not "AX??191"; 1: ModelName is "AX??191";
    uint16_t m_bModelNameAX48_1P: 1;               //1P
    uint16_t m_bModelNameAX32_3P: 1;               //3P

#ifdef FUNC_AXSJ_USE_NEW_NACS_PCB
    uint16_t m_bModelNameAXSJ;
    uint16_t m_bModelNameAXSJ_AX48_NACS_1P: 1;      //AXSJ960001 (AX48 NACS PCB)
    uint16_t m_bModelNameAXSJ_AX80_NACS_1P: 1;      //AXSJxxxxxx (AX80 NACS PCB) reserved
#endif

#ifdef FUNC_AX48_NACS
    uint16_t m_bModelNameAX48_NACS_1P: 1;               //1P
#endif

#ifdef FUNC_AX80_NACS
    uint16_t m_bModelNameAX80_NACS_1P: 1;               //1P
#endif

#ifdef FUNC_AW48
    uint16_t m_bModelNameAW48_1P: 1;               //1P
#endif

#endif //FUNC_AX80

#ifdef FUNC_AT32
    uint16_t m_bModelNameAT: 1;                 //0: ModelName is not "AT~"; 1: ModelName is "AT~";
    uint16_t m_bModelNameAT32_3P: 1;            //3P
#endif

#ifdef FUNC_METER_IC_CHECK_WHETHER_DEFAULT_CALI_VAL
    uint16_t m_bMeterIC_CaliValIsDefault: 1;    //0: Not default values; 1: Default values
#endif

#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
    uint16_t m_bReadAllMemory: 1;               //0: Not read all memory data; 1: Read all memory data
#endif

#ifdef FUNC_IDLE_UNTIL_INIT_METER_IC
    uint16_t m_bInitMeterIC: 1;
#endif


#ifdef FUNC_ROTARY_SLAVE_MODE
    uint16_t m_bRotarySlaveMode: 1;             //0: Not Rotary slave mode; 1: Rotary slave mode
#endif

#ifdef FUNC_RULE_GB_202108
    uint16_t    m_bSafetyRegulationGB:1;
#endif

#ifdef FUNC_BLOCK_CSU_CONFIG_CP_PWM_DUTY
    uint16_t    m_bBlockCsuCpPwmDuty: 1;
#endif

#ifdef FUNC_BLOCK_CSU_CMD_SET_DUTY_WHEN_ALARM_CP_F_STATE
    uint16_t    m_bBlockCsuCpPwmDutyWhenAlarmCpF: 1;
#endif

#ifdef FUNC_GUN_LOCK
    uint16_t    m_bTrigGunLock: 1;
    uint16_t    m_bTrigGunUnlock: 1;
#endif

#ifdef FUNC_AX32_TRIG_LEAKAGE
    uint16_t    m_bTrigLeakage: 1;
#endif

#ifdef FUNC_AX80_ADD_TILT_SENSOR
    uint16_t    m_bTILT_TrigLeakage: 1;
#endif

#ifdef FUNC_ADD_TILT_SENSOR_MODEL
    uint16_t    m_bUseTiltSensor: 1;
#ifdef FUNC_DISABLE_TILT_SENSOR_FOR_TEST
    uint16_t    m_bDisableTiltSensorForTest: 1;
#endif
#endif //FUNC_ADD_TILT_SENSOR_MODEL


#ifdef FUNC_USE_RELAY_B_CONTACT
    uint16_t    m_bUseRelayBContact: 1;
#endif

#ifdef FUNC_CCS
    uint16_t    m_bRunCCS: 1;
    uint16_t    m_bGotCsuCpDutyCmd: 1; //Rx 6~48A or 5%(m_bRunCCS = 1)
#ifdef MODIFY_GOT_CSU_DUTY_CMD_PROCESS
    uint16_t    m_bPassGotCsuCpDutyCmd: 1;
#endif
#endif //FUNC_CCS

#ifdef TEST_FOR_ENERGY_STAR
    uint16_t    m_bLedSleepModeForceMinBrightness: 1;
#endif

#ifdef FUNC_TMP100
    uint16_t m_bUseTMP100: 1;
#endif

#ifdef FUNC_DEBUG_CONSOLE
    uint16_t    m_bDisableDebugInfo: 1;
#endif

#ifdef FUNC_LIN_CP
    uint16_t    m_bUseLinCP: 1;
#endif

#ifdef FUNC_CSU_SIGN_IN_VERIFY
    uint16_t    m_bCsuSignInMustVerify:   1;
    uint16_t    m_bCsuSignInVerifyOK:     1;
    uint16_t    m_bRunCsuSignInVerify:    1;
#endif

#ifdef FUNC_CSU_UPGRADE_FW_VERIFY
    uint16_t    m_bCsuUpgradeFwMustVerify:  1;
    uint16_t    m_bCsuUpgradeFwVerifyOK:    1;
    uint16_t    m_bRunCsuUpgradeFwVerify:   1;
#endif

#ifdef FUNC_METER_IC_ADE7858A
    MeterIC_MeasVals            m_MeterIC_MeasVals;             //Meter IC - Measurement values
    MeterIC_TrigWriteCaliVals   m_MeterIC_TrigWriteCaliVals;    //Meter IC - Trigger to write calibration values

#ifdef FUNC_METER_IC_COMM_ALARM
    uint32_t m_MeterIC_LastUpdateTick;
#endif

#ifdef FUNC_TMP100
    float m_TMP100_cTemp;
    uint32_t m_TMP100_LastUpdateTick;
#endif

#ifdef FUNC_METER_IC_READ_PHASE_ANGLE
    MeterIC_ExtraInfo m_MeterIcEx;
#endif

#endif //FUNC_METER_IC_ADE7858A

#ifdef FUNC_RS485_SLAVE
    uint8_t m_RS485SlaveAddr;
#endif

#ifdef FUNC_DETECT_PP
    PPInfo m_PPInfo;
#endif

#ifdef FUNC_OUTP_TYPE_E
    EOutpMode m_OutpMode;
#endif

#ifdef FUNC_VOLATILE_OPERATION
    VolatileOperationCode m_VOCode;
    SimuData m_SimuData;
#endif

#ifdef FUNC_CURRENT_CP_PWM_DATA
    uint16_t m_CP_CurPWM;
#endif

#ifdef FUNC_OCP_WITH_PP
    uint16_t m_OCP_CurMaxCurr;      //A
    uint16_t m_OCP_BegThreshold;    //Occur:    0.01A
    uint16_t m_OCP_EndThreshold;    //Recover:  0.01A
#endif

#ifdef MODIFY_AC_EVSE_STATUS_MAX_CHARGING_CURRENT_VARIABLE
    uint16_t    AC_MaxChargingCurrentOrDuty; //AC Only
#endif

#ifdef FUNC_AX32_TRIG_LEAKAGE
    uint32_t    AlarmRelayWeldingOccurTick;
#endif

#ifdef FUNC_AX80_ADD_TILT_SENSOR
    uint32_t    AlarmTiltSensorOccurTick;
#endif

#ifdef FUNC_PTB_METER_WM3M4C
    PWM3M4C m_pWM3M4C;
#endif

#ifdef RECODE_METER_PRO380
    PPRO380 m_pPRO380;
#endif

#ifdef FUNC_GET_TRIP_TIME
    uint32_t m_TripBeg;
    uint32_t m_TripEnd;
#endif

#ifdef FUNC_AUTO_MODIFY_CCID_MODULE
    HTK_BOOL m_bCCID_MustModify;
    uint8_t m_CCID_ModuleTestOK;
#endif

#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
    uint16_t m_GunLock_Counter;
    uint16_t m_GunUnlock_Counter;
#endif

#ifdef FUNC_TASK_MONITOR
    TaskMonitor m_TaskMonitor;
#endif

#ifdef FUNC_RELAY_OFF_WHEN_CSU_CMD_TIMEOUT
    u32 m_CSU_RxTick;
#endif

#ifdef FUNC_BOOT_TICK
    uint32_t    m_BootTick;
#endif

#ifdef FUNC_LIN_CP
    PLinCP m_pLinCP;
#endif

#ifdef FUNC_EKM_OMNIMETER
    PEKM_Omnimeter m_pEKM_Omnimeter;
#endif

#ifdef FUNC_WARNING_CODE
    uint32_t    Warning_Code;  	                // System warning code
#endif



#ifdef FUNC_AW48_NET_LED
    Led LedNet_G;
    Led LedNet_B;
#endif

#ifdef RELAY_COMMON_GPIO
    u8 m_RelayMode; //0: AX48, AX32, AT32; 1: AW48
#endif

#ifdef FUNC_VERIFY_TASK
#ifdef  FUNC_CSU_VERIFY_USE_ECDSA
#define VERIFY_TASK_RXBUF_LEN  (64 * 3)
#else
#define VERIFY_TASK_RXBUF_LEN  (64)
#endif
    u8 m_VerifyTaskRxBuf[VERIFY_TASK_RXBUF_LEN];
    u8 m_VerifyTaskRxBufDataLen;
#endif

#ifdef FUNC_RESET_DATA_AFTER_WRITE_NEW_MODELNAME
    u8 m_bTrigToClearAlarmCode;
    u8 m_bTrigToRefreshMeterIcCaliVal;
#endif

#ifdef FUNC_GUN_LOCK_TRIG_MODE
    GL_TRIG_MODE m_GunLockTrigMode;
    u32 m_GunLockRequestMode_LockDelayTick;
#endif

}Charger;


#ifdef FUNC_SYSTEM_KEEP_INFO
typedef struct _SystemKeepInfo
{
    union
    {
        u8 m_Buf[16];
        struct
        {
            u8 m_BootCount;
            u8 m_CsuIsRequestOn;   //Charger.am3352.isRequestOn
            u16 m_CpPwmVal;         //user_pwm_setvalue(PWM_CH_CP
        };
    };
    u32 m_CRC32;
    HTK_BOOL m_bUsed;
}
SystemKeepInfo, *PSystemKeepInfo;

__no_init __root extern SystemKeepInfo g_SystemKeepInfo;
void SystemKeepInfo_Display(PSystemKeepInfo p);
void SystemKeepInfo_Update(PSystemKeepInfo p);
HTK_BOOL SystemKeepInfo_Check(PSystemKeepInfo p);
#endif //FUNC_SYSTEM_KEEP_INFO

//---------------------------------------------------------------

#ifndef DISABLE_CCID_PROTECT
#define CCID_PROTECT
#endif

#ifndef DISABLE_OTP_PROTECT
#define OTP_PROTECT
#endif

#define CP_ALARM_PROTECT

#ifndef DISABLE_GROUND_FAULT_PROTECT
#define GROUND_FAULT_PROTECT
#endif

#define EMC_BUTTON_PROTECT

#ifndef DISABLE_RELAY_WELDING_PROTECT
#define RELAY_WELDING_PROTECT
#endif

#ifndef DISABLE_OVP_PROTECT
#define OVP_PROTECT
#endif

#ifndef DISABLE_UVP_PROTECT
#define UVP_PROTECT
#endif

#ifndef DISABLE_OCP_PROTECT
#define OCP_PROTECT
#endif

#define HANDSHAKE_PROTECT
#define ROTATE_SWITCH_CHECK
#define COLD_LOAD_PICKUP
#define METER_TIMEOUT_CHECK

//---------------------------------------------------------------
#ifdef FUNC_AW48_EXT_LED
#define EXTLED_SET_POWER(bON)   HAL_GPIO_WritePin(OutpowerCtr_LED24V_GPIO_Port, OutpowerCtr_LED24V_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)
#define EXTLED_SET_R(bON)       HAL_GPIO_WritePin(LED_R_Ctr_GPIO_Port, LED_R_Ctr_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)
#define EXTLED_SET_G(bON)       HAL_GPIO_WritePin(LED_G_Ctr_GPIO_Port, LED_G_Ctr_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)
#define EXTLED_SET_B(bON)       HAL_GPIO_WritePin(LED_B_Ctr_GPIO_Port, LED_B_Ctr_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)
#define EXTLED_SET_ALL(bON)     EXTLED_SET_R(bON); EXTLED_SET_G(bON); EXTLED_SET_B(bON)
#endif

#ifdef FUNC_AW48_NET_LED
#define NETLED_SET_G(bON)       HAL_GPIO_WritePin(M_LED_G1_GPIO_Port, M_LED_G1_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)
#define NETLED_SET_B(bON)       HAL_GPIO_WritePin(M_LED_B1_GPIO_Port, M_LED_B1_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)
#define NETLED_SET_ALL(bON)     NETLED_SET_G(bON); NETLED_SET_B(bON)
#endif

#define IS_CSU_MOUNTED          (HAL_GPIO_ReadPin(IN_CCS_Proximity_GPIO_Port, IN_CCS_Proximity_Pin) == GPIO_PIN_RESET)


//---------------------------------------------------------------
#ifdef RELAY_COMMON_GPIO
//AX48, AX32, AT32:
//RELAY_MODE = 0
#define M0_RelayDrv_L1_Pin GPIO_PIN_9
#define M0_RelayDrv_L1_GPIO_Port GPIOC
#define M0_RelayHold_L1_Pin GPIO_PIN_8
#define M0_RelayHold_L1_GPIO_Port GPIOA
#define M0_RelayDrv_L2_Pin GPIO_PIN_9
#define M0_RelayDrv_L2_GPIO_Port GPIOA
#define M0_RelayHold_L2_Pin GPIO_PIN_10
#define M0_RelayHold_L2_GPIO_Port GPIOA

//AW48:
//RELAY_MODE = 1
#define M1_RelayDrv_L1_Pin GPIO_PIN_10
#define M1_RelayDrv_L1_GPIO_Port GPIOA
#define M1_RelayHold_L1_Pin GPIO_PIN_9
#define M1_RelayHold_L1_GPIO_Port GPIOA
#define M1_RelayDrv_L2_Pin GPIO_PIN_8
#define M1_RelayDrv_L2_GPIO_Port GPIOA
#define M1_RelayHold_L2_Pin GPIO_PIN_9
#define M1_RelayHold_L2_GPIO_Port GPIOC

#define RELAY_MODE (Charger.m_RelayMode)

#define M0_RELAY1_SET_DRIV(bON)     HAL_GPIO_WritePin(M0_RelayDrv_L1_GPIO_Port, M0_RelayDrv_L1_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)
#define M0_RELAY1_SET_HOLD(bON)     HAL_GPIO_WritePin(M0_RelayHold_L1_GPIO_Port, M0_RelayHold_L1_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)
#define M0_RELAY2_SET_DRIV(bON)     HAL_GPIO_WritePin(M0_RelayDrv_L2_GPIO_Port, M0_RelayDrv_L2_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)
#define M0_RELAY2_SET_HOLD(bON)     HAL_GPIO_WritePin(M0_RelayHold_L2_GPIO_Port, M0_RelayHold_L2_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)

#define M1_RELAY1_SET_DRIV(bON)     HAL_GPIO_WritePin(M1_RelayDrv_L1_GPIO_Port, M1_RelayDrv_L1_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)
#define M1_RELAY1_SET_HOLD(bON)     HAL_GPIO_WritePin(M1_RelayHold_L1_GPIO_Port, M1_RelayHold_L1_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)
#define M1_RELAY2_SET_DRIV(bON)     HAL_GPIO_WritePin(M1_RelayDrv_L2_GPIO_Port, M1_RelayDrv_L2_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)
#define M1_RELAY2_SET_HOLD(bON)     HAL_GPIO_WritePin(M1_RelayHold_L2_GPIO_Port, M1_RelayHold_L2_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)

#define RELAY1_SET_DRIV(bON)        ((RELAY_MODE) == 1 ? M1_RELAY1_SET_DRIV(bON) : M0_RELAY1_SET_DRIV(bON))
#define RELAY1_SET_HOLD(bON)        ((RELAY_MODE) == 1 ? M1_RELAY1_SET_HOLD(bON) : M0_RELAY1_SET_HOLD(bON))
#define RELAY2_SET_DRIV(bON)        ((RELAY_MODE) == 1 ? M1_RELAY2_SET_DRIV(bON) : M0_RELAY2_SET_DRIV(bON))
#define RELAY2_SET_HOLD(bON)        ((RELAY_MODE) == 1 ? M1_RELAY2_SET_HOLD(bON) : M0_RELAY2_SET_HOLD(bON))

#define M0_RELAY1_GET_DRIV          HAL_GPIO_ReadPin(M0_RelayDrv_L1_GPIO_Port, M0_RelayDrv_L1_Pin)
#define M0_RELAY1_GET_HOLD          HAL_GPIO_ReadPin(M0_RelayHold_L1_GPIO_Port, M0_RelayHold_L1_Pin)
#define M0_RELAY2_GET_DRIV          HAL_GPIO_ReadPin(M0_RelayDrv_L2_GPIO_Port, M0_RelayDrv_L2_Pin)
#define M0_RELAY2_GET_HOLD          HAL_GPIO_ReadPin(M0_RelayHold_L2_GPIO_Port, M0_RelayHold_L2_Pin)

#define M1_RELAY1_GET_DRIV          HAL_GPIO_ReadPin(M1_RelayDrv_L1_GPIO_Port, M1_RelayDrv_L1_Pin)
#define M1_RELAY1_GET_HOLD          HAL_GPIO_ReadPin(M1_RelayHold_L1_GPIO_Port, M1_RelayHold_L1_Pin)
#define M1_RELAY2_GET_DRIV          HAL_GPIO_ReadPin(M1_RelayDrv_L2_GPIO_Port, M1_RelayDrv_L2_Pin)
#define M1_RELAY2_GET_HOLD          HAL_GPIO_ReadPin(M1_RelayHold_L2_GPIO_Port, M1_RelayHold_L2_Pin)

#define RELAY1_GET_DRIV             ((RELAY_MODE) == 1 ? M1_RELAY1_GET_DRIV : M0_RELAY1_GET_DRIV)
#define RELAY1_GET_HOLD             ((RELAY_MODE) == 1 ? M1_RELAY1_GET_HOLD : M0_RELAY1_GET_HOLD)
#define RELAY2_GET_DRIV             ((RELAY_MODE) == 1 ? M1_RELAY2_GET_DRIV : M0_RELAY2_GET_DRIV)
#define RELAY2_GET_HOLD             ((RELAY_MODE) == 1 ? M1_RELAY2_GET_HOLD : M0_RELAY2_GET_HOLD)

#endif //RELAY_COMMON_GPIO
//---------------------------------------------------------------

#define RELAY_SE_SET_DRIV(bON)  HAL_GPIO_WritePin(OUT_SocketE_Drv_GPIO_Port, OUT_SocketE_Drv_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)
#define RELAY_SE_SET_HOLD(bON)  HAL_GPIO_WritePin(OUT_SocketE_Hold_GPIO_Port, OUT_SocketE_Hold_Pin, (bON) ? GPIO_PIN_SET : GPIO_PIN_RESET)

#define RELAY_SE_GET_DRIV       HAL_GPIO_ReadPin(OUT_SocketE_Drv_GPIO_Port, OUT_SocketE_Drv_Pin)
#define RELAY_SE_GET_HOLD       HAL_GPIO_ReadPin(OUT_SocketE_Hold_GPIO_Port, OUT_SocketE_Hold_Pin)


//---------------------------------------------------------------

/* USER CODE END Private defines */

#ifdef __cplusplus
}
#endif

#endif /* __MAIN_H */

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