/* USER CODE BEGIN Header */
/**
******************************************************************************
* File Name : freertos.c
* Description : Code for freertos applications
******************************************************************************
* @attention
*
* © Copyright (c) 2019 STMicroelectronics.
* All rights reserved.
*
* This software component is licensed by ST under Ultimate Liberty license
* SLA0044, the "License"; You may not use this file except in compliance with
* the License. You may obtain a copy of the License at:
* www.st.com/SLA0044
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "cmsis_os.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "dma.h" //Hao@20231020
#include "adc.h"
#include "crc.h"
#include "flash_if.h"
#include "gpio.h"
#include "iwdg.h"
#include "rtc.h"
#include "tim.h"
#include "usart.h"
#include "cp_detection.h"
#include "W25QXX.h"
#include "usbd_cdc_if.h"
#include "time.h"
#include "driver_meter.h"
#include "i2c.h"
#ifdef FUNC_LIN_CP
#include "LinCP.h"
#endif
#ifdef FUNC_EKM_OMNIMETER
#include "EKM_Omnimeter.h"
#endif
#ifdef FUNC_AES256
#include "..\Middlewares\AES256\aes256.h"
#endif
#ifdef FUNC_ECDSA
#include "cmox_crypto.h"
#endif
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN Variables */
#ifdef FUNC_SYSTEM_KEEP_INFO
__no_init __root SystemKeepInfo g_SystemKeepInfo;
void SystemKeepInfo_Display(PSystemKeepInfo p)
{
u32 crc32 = HAL_CRC_Calculate(&hcrc, (u32*)p->m_Buf, (sizeof(p->m_Buf) >> 2));
// XP("==============\r\n");
// XP("BootCount = %d\r\n", p->m_BootCount);
// XP("CsuIsRequestOn = %d\r\n", p->m_CsuIsRequestOn);
// XP("CpPwmVal = %d\r\n", p->m_CpPwmVal);
// XP("CRC32 = 0x%04X (%s)\r\n", p->m_CRC32, (p->m_CRC32 == crc32 ? "OK" : "NG"));
// XP("CRC32_CALC = 0x%04X\r\n", crc32);
// XP("================================\r\n");
DEBUG_INFO("BootCount(%d) CsuIsRequestOn(%d) CpPwmVal(%d) CRC32(0x%04X,%s)\r\n",
p->m_BootCount, p->m_CsuIsRequestOn, p->m_CpPwmVal, p->m_CRC32, (p->m_CRC32 == crc32 ? "OK" : "NG"));
}
void SystemKeepInfo_Update(PSystemKeepInfo p)
{
u32 crc32 = HAL_CRC_Calculate(&hcrc, (u32*)p->m_Buf, (sizeof(p->m_Buf) >> 2));
p->m_CRC32 = crc32;
}
HTK_BOOL SystemKeepInfo_Check(PSystemKeepInfo p)
{
u32 crc32 = HAL_CRC_Calculate(&hcrc, (u32*)p->m_Buf, (sizeof(p->m_Buf) >> 2));
return (p->m_CRC32 == crc32 ? HTK_TRUE : HTK_FALSE);
}
#endif //FUNC_SYSTEM_KEEP_INFO
uint32_t alarm_record_code[32] =
{
0x00012200, // Input L1 OVP
0x00012203, // Input L1 UVP
0x00012216, // Output L1 OCP
0x00012223, // Over temperature
0x00012255, // Ground fault
0x00023703, // Pilot error
0x00012233, // AC CCID
0x00012233, // DC CCID
0x00012256, // MCU self test
0x00012258, // Hand shaking timeout
0x00012251, // Emergency stop
0x00011009, // Relay welding
0x00011032, // Leak module test fail
0x00011034, // shutter fault
0x00012212, // L1 Power drop
0x00012262, // L1 Circuit short
0x00011033, // Maximum Output Current setup error
0x00011010, // AC output relay driving fault
0x00011035, // Ble module broken
0x00012201, // Input L2 OVP
0x00012202, // Input L3 OVP
0x00012204, // Input L2 UVP
0x00012205, // Input L3 UVP
0x00012299, // Output L2 OCP
0x00012300, // Output L3 OCP
0x00012301, // L2 Circuit short
0x00012302, // L3 Circuit short
0x00000000,
0x00000000,
0x00000000,
0x00000000
};
uint32_t binCRCTarget, binCRCCal;
__IO uint32_t flashdestination;
__IO uint32_t newdestination;
volatile unsigned long ulHighFrequencyTimerTicks;
sCPModuleResult_t CpDetectionResult;
#ifndef FUNC_CP_ADC_MODIFY
sCPVoltageBoundary_t CpBoundary = {
CP_P12V_HIGH,
CP_P12V_LOW,
CP_P9V_HIGH,
CP_P9V_LOW,
CP_P6V_HIGH,
CP_P6V_LOW,
CP_P3V_HIGH,
CP_P3V_LOW,
CP_0V_HIGH,
CP_0V_LOW,
CP_N12V_HIGH,
CP_N12V_LOW,
};
sCPVoltageBoundary_t SpecDefBoundary = {
CP_SPEC_P12V_HIGH,
CP_SPEC_P12V_LOW,
CP_SPEC_P9V_HIGH,
CP_SPEC_P9V_LOW,
CP_SPEC_P6V_HIGH,
CP_SPEC_P6V_LOW,
CP_SPEC_P3V_HIGH,
CP_SPEC_P3V_LOW,
CP_SPEC_0V_HIGH,
CP_SPEC_0V_LOW,
CP_SPEC_N12V_HIGH,
CP_SPEC_N12V_LOW,
};
sCPVoltageHysteresis_t CpHysteresis = {
HYSTERESIS_P12V_HIGH,
HYSTERESIS_P12V_LOW,
HYSTERESIS_P9V_HIGH,
HYSTERESIS_P9V_LOW,
HYSTERESIS_P6V_HIGH,
HYSTERESIS_P6V_LOW,
HYSTERESIS_P3V_HIGH,
HYSTERESIS_P3V_LOW,
HYSTERESIS_0V_HIGH,
HYSTERESIS_0V_LOW,
};
#endif //FUNC_CP_ADC_MODIFY
struct EVSE Charger;
const unsigned char CharacterArray[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
uint32_t test_logA = 0 ;
uint32_t test_logB = 0 ;
extern I2C_HandleTypeDef hi2c2;
/* USER CODE END Variables */
#ifndef DISABLE_OS_ETH_TASK
osThreadId ethTaskHandle;
#endif
osThreadId uartTaskHandle;
osThreadId adcTaskHandle;
osThreadId timeoutTaskHandle;
osThreadId rfidTaskHandle;
osThreadId led_speakerTaskHandle;
osThreadId cpTaskHandle;
osThreadId alarmTaskHandle;
osThreadId bleTaskHandle;
osThreadId memoryTaskHandle;
osThreadId wifiTaskHandle;
osThreadId MeterTaskHandle;
#ifdef RECODE_FUNC_METER_IC_TASK
osThreadId MeterIcTaskHandle;
#endif
#ifdef FUNC_TASK_MONITOR
osThreadId MonitorTaskHandle;
#endif
#ifdef FUNC_LIN_CP
osThreadId LinCpTaskHandle;
#endif
#ifdef FUNC_VERIFY_TASK
osThreadId VerifyTaskHandle;
#endif
#ifdef FUNC_METER_IC_READ_PHASE_ANGLE
char *AC_PERIOD_MODE_STR[AC_PERIOD_MODE_NUM] = { "?Hz", "50Hz", "60Hz" };
char *AC_PHASE_MODE_STR[AC_PHASE_MODE_NUM] = { "?", "AC_PHASE_MODE_1P", "240_120_120_SEQ_OK", "120_120_240_SEQ_NG", "360_360_360" };
#endif
/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN FunctionPrototypes */
#ifdef FUNC_RS485_SLAVE
uint8_t isValidCheckSum_IAP(uint8_t *RxBuf);
#else
uint8_t isValidCheckSum_IAP(void);
#endif
uint8_t isValidCheckSum_BLE(void);
uint8_t isValidCheckSum_WIFI(void);
void setChargerMode(uint8_t mode);
uint8_t isModeChange(void);
uint8_t isMode(uint8_t mode);
uint8_t rfidCheckSumCal(uint8_t *data, uint8_t length);
uint8_t Test_LeakModule(void);
uint8_t Valid_RFID_SN(void);
void recordAlarmHis(void);
#ifdef FUNC_METER_IC_HISTORY
uint8_t recordMeterICHis(MeterIC_CaliValType Type, int32_t Val);
#else
uint8_t recordChargingHis(uint8_t isColdLoadPickUp, uint32_t statusCode);
#endif
void setLedMotion(uint8_t action);
#ifdef FUNC_CUSTOMIZED_LED_MODE_FROM_CSU
void setLedMotion_User(uint8_t action, PLED_UserCfg p);
#endif
#ifdef FUNC_AW48_NET_LED
void setNetLedMotion(uint8_t action);
#endif
void getlastRecord(void);
void getRotarySwitchSetting(void);
void CLC_Corr_Gain_Par(uint16_t SpecData_H ,uint16_t SpecData_L ,uint16_t MCUData_H , uint16_t MCUData_L , float *GainA , float *GainB ) ;
void CLC_Corr_Gain_Par2(uint16_t SpecData_H ,uint16_t SpecData_L ,uint16_t MCUData_H , uint16_t MCUData_L , float *GainA , float *GainB , uint8_t *PosorNeg ) ;
uint8_t Array_data_Check ( uint8_t *s1, uint8_t *s2 ) ;
void Relay_Control_Function (void) ;
#ifdef FUNC_OUTP_TYPE_E
void SE_Relay_Control_Function(void);
#endif
uint8_t WatchDogLeakRawDataCheck_Event(void) ;
uint16_t getBrightnessDuty(uint16_t max_duty);
void parseVersionInfoFromModelname(void);
#ifdef ENABLE_PRINT_IMCP_MSG
int CheckPrintImcpMsg(uint8_t MsgID);
#endif
#ifdef MODIFY_IMCP
void UpdateCheckSum(uint8_t *Buf, uint16_t Len);
#endif
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
void ColdLoadPickup_Delay(const char* Description);
#endif
#ifdef FUNC_FORCE_RUN_CSU_MODE_WITH_DC_MODELNAME
void Update_McuCtrlMode(void);
#endif
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
void IdleUntilReadAllMemory(void);
#endif
#ifdef FUNC_IDLE_UNTIL_INIT_METER_IC
void IdleUntilInitMeterIC(void);
#endif
#ifdef FUNC_GUN_LOCK
void GL_Init(void);
////void GL_Lock(void);
void GL_Unlock(void);
HTK_BOOL GL_IsLock(void);
void GL_Trig(GL_MODE mode);
void GL_Proc(void);
#endif
#ifdef FUNC_AX32_TRIG_LEAKAGE
void TrigLeakage_Init(void);
void TrigLeakage_Trig(void);
void TrigLeakage_Proc(void);
#endif
#ifdef MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK
void AlarmDetect_RelayWelding_UseADC(void);
#ifdef FUNC_USE_RELAY_B_CONTACT
HTK_BOOL IsRelayContact_Closed(void);
void AlarmDetect_RelayWelding_UseGPIO(void);
#endif
#endif //MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK
#ifdef FUNC_AX80_ADD_TILT_SENSOR
void TILT_TrigLeakage_Init(void);
void TILT_TrigLeakage_Trig(void);
void TILT_TrigLeakage_Proc(void);
void AlarmDetect_TiltSensor(void);
#endif
#ifdef MODIFY_DC_RS485_UPGRADE_ISSUE
void RS485_TX_Enable(void);
void RS485_TX_Disable(void);
void Prefix_UartTX(uint8_t* TxBuf, uint8_t* RxBuf);
void Postfix_UartTX(uint8_t* TxBuf, uint8_t* RxBuf);
#endif
#ifdef FUNC_RS485_BLE_SW
void RS485_SW(HTK_BOOL bON);
void BLE_SW(HTK_BOOL bON);
#endif
#ifdef FUNC_LIN_EN_SW
void LIN_EN(HTK_BOOL bEnable);
void LIN_SW(HTK_BOOL bUseLIN);
#endif
#ifdef FUNC_AW48_NET_LED
void Proc_NetLedActionSubState(void);
#endif
#ifdef FUNC_AES256
HTK_BOOL AES256_Verify(u8* Data, int DataLen, u8* Key, u8* IV, u8* RemoteEncryptedData);
void AES256_Test(void);
#endif
#ifdef FUNC_ECDSA
HTK_BOOL ECDSA_Verify(u8* PublicKey, int PublicKeyLen, u8* Hash, int HashLen, u8* Signature, int SignatureLen);
void ECDSA_VerifyTest(void);
#endif
/* USER CODE END FunctionPrototypes */
#ifndef DISABLE_OS_ETH_TASK
void StartEthTask(void const * argument);
#endif
void StartUartTask(void const * argument);
void StartAdcTask(void const * argument);
void StartTimeoutTask(void const * argument);
#ifdef FUNC_ENABLE_USART1_RFID
void StartRfidTask(void const * argument);
#endif
void StartLedSpeakerTask(void const * argument);
void StartCpTask(void const * argument);
void StartAlarmTask(void const * argument);
void StartBleTask(void const * argument);
void StartMemoryTask(void const * argument);
void StartWifiTask(void const * argument);
void StartMeterTask(void const * argument);
#ifdef RECODE_FUNC_METER_IC_TASK
void StartMeterIcTask(void const * argument);
#endif
#ifdef FUNC_TASK_MONITOR
void StartMonitorTask(void const * argument);
#endif
#ifdef FUNC_LIN_CP
void StartLinCpTask(void const * argument);
#endif
#ifdef FUNC_VERIFY_TASK
void StartVerifyTask(void const * argument);
#endif
extern void MX_USB_DEVICE_Init(void);
void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */
/* GetIdleTaskMemory prototype (linked to static allocation support) */
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize );
/* Hook prototypes */
void configureTimerForRunTimeStats(void);
unsigned long getRunTimeCounterValue(void);
/* USER CODE BEGIN 1 */
/* Functions needed when configGENERATE_RUN_TIME_STATS is on */
__weak void configureTimerForRunTimeStats(void)
{
ulHighFrequencyTimerTicks = 0ul;
}
__weak unsigned long getRunTimeCounterValue(void)
{
return ulHighFrequencyTimerTicks;
}
/* USER CODE END 1 */
/* USER CODE BEGIN GET_IDLE_TASK_MEMORY */
static StaticTask_t xIdleTaskTCBBuffer;
static StackType_t xIdleStack[configMINIMAL_STACK_SIZE];
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize )
{
*ppxIdleTaskTCBBuffer = &xIdleTaskTCBBuffer;
*ppxIdleTaskStackBuffer = &xIdleStack[0];
*pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
/* place for user code */
}
/* USER CODE END GET_IDLE_TASK_MEMORY */
/**
* @brief FreeRTOS initialization
* @param None
* @retval None
*/
void UpdateFirmwareVersion(void)
{
#ifdef FUNC_FW_VER_TRACE
#if (FW_VER_NUM >= 1000)
//--------------------------------------------------------------
#if (FW_VER_TYPE == FW_VER_TYPE_DEVELOP)
#ifdef FORCE_VER_WITH_T_PREFIX
sprintf(Charger.Ver_FW, "T%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#else
sprintf(Charger.Ver_FW, "D%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
//sprintf(Charger.Ver_FW, "D0.02.X0.0011.P0"); //test
#endif
#elif (FW_VER_TYPE == FW_VER_TYPE_PVT)
#ifdef FORCE_VER_WITH_T_PREFIX
#ifdef FORCE_VER_WITH_F_PREFIX
sprintf(Charger.Ver_FW, "F%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#else
sprintf(Charger.Ver_FW, "T%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#endif
#else //FORCE_VER_WITH_T_PREFIX
#ifdef AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX48_MODELNAME_WITH_CSU
if (
( Charger.m_bModelNameAX48_1P
#ifdef AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX32_MODELNAME_WITH_CSU
|| Charger.m_bModelNameAX32_3P
#endif
)
&&
IS_CSU_MOUNTED) //With CSU
{
sprintf(Charger.Ver_FW, "V%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
}
else
{
sprintf(Charger.Ver_FW, "B%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
}
#else
sprintf(Charger.Ver_FW, "B%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#endif
#endif //FORCE_VER_WITH_T_PREFIX
#elif (FW_VER_TYPE == FW_VER_TYPE_FORMAL)
sprintf(Charger.Ver_FW, "V%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#elif (FW_VER_TYPE == FW_VER_TYPE_TEST)
sprintf(Charger.Ver_FW, "T%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#endif
//--------------------------------------------------------------
#else //(FW_VER_NUM >= 1000)
#if (FW_VER_TYPE == FW_VER_TYPE_DEVELOP)
sprintf(Charger.Ver_FW, "D%4.2f.X0.0011.P0", FW_VER_NUM * 0.01);
#elif (FW_VER_TYPE == FW_VER_TYPE_PVT)
#ifdef FORCE_VER_WITH_T_PREFIX
//---------------
#ifdef FORCE_VER_WITH_F_PREFIX
sprintf(Charger.Ver_FW, "F%4.2f.X0.0011.P0", FW_VER_NUM * 0.01);
#else
sprintf(Charger.Ver_FW, "T%4.2f.X0.0011.P0", FW_VER_NUM * 0.01);
#endif
//---------------
//sprintf(Charger.Ver_FW, "T%4.2f.X0.0011.P0", FW_VER_NUM * 0.01);
#else //FORCE_VER_WITH_T_PREFIX
#ifdef AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX48_MODELNAME_WITH_CSU
if (
( Charger.m_bModelNameAX48_1P
#ifdef AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX32_MODELNAME_WITH_CSU
|| Charger.m_bModelNameAX32_3P
#endif
#ifdef AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX80_MODELNAME_WITH_CSU
|| Charger.m_bModelNameAX80_1P
#endif
)
&&
IS_CSU_MOUNTED) //With CSU
{
sprintf(Charger.Ver_FW, "V%4.2f.X0.0011.P0", FW_VER_NUM * 0.01);
}
else
{
sprintf(Charger.Ver_FW, "B%4.2f.X0.0011.P0", FW_VER_NUM * 0.01);
}
#else //AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX48_MODELNAME_WITH_CSU
sprintf(Charger.Ver_FW, "B%4.2f.X0.0011.P0", FW_VER_NUM * 0.01);
#endif //AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX48_MODELNAME_WITH_CSU
#endif //FORCE_VER_WITH_T_PREFIX
#elif (FW_VER_TYPE == FW_VER_TYPE_FORMAL)
sprintf(Charger.Ver_FW, "V%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#elif (FW_VER_TYPE == FW_VER_TYPE_TEST)
sprintf(Charger.Ver_FW, "T%4.2f.X0.0011.P0", FW_VER_NUM * 0.00001);
#endif
#endif //(FW_VER_NUM >= 1000)
#else //FUNC_FW_VER_TRACE
//sprintf(Charger.Ver_FW, "D0.11.X0.0011.P0");
//sprintf(Charger.Ver_FW, "D0.12.X0.0011.P0"); //AX_1P, AX_3P Generic version (=>Git)
//sprintf(Charger.Ver_FW, "D0.13.X0.0011.P0"); //0.13.001: POWER_CONSUME_64_BIT, CDFA_V2
//sprintf(Charger.Ver_FW, "D0.13.X0.0011.P0"); //0.13.002: FUNC_METER_IC_COMM_ALARM, CDFA_V3
//sprintf(Charger.Ver_FW, "D0.14.X0.0011.P0"); //0.14.000: MODIFY_CPTASK_CSU_0_1_CHARGE_MODE (Fix UL test issue) + Relay welding
//sprintf(Charger.Ver_FW, "D0.15.X0.0011.P0"); //0.15: FUNC_NEW_RELAY_MONITOR, FUNC_ZEROING_WHEN_MEM_CLEARNED
//sprintf(Charger.Ver_FW, "D0.16.X0.0011.P0"); //0.16: FUNC_NEW_RELAY_MONITOR/Relay_LL_DriveFault_Slop/Relay_LL_DriveFault_Offs
#endif //FUNC_FW_VER_TRACE
#ifdef FUNC_VERSION_USE_NEW_SPEC_20240926
//Indicate firmware belong which module board
//L: LED board
//R: Relay board
//C: CHAdeMO board
//G: GBT board
//F: Fan board
//D: DCM 407
//A: AC main board
//S: CCS board
//M: CSU board
Charger.Ver_FW[6] = 'A';
//0: For formal release specification
//1: For lab certificate specification
#ifdef FUNC_VERSION_FOR_LAB_CERTIFICATE_SPEC
Charger.Ver_FW[7] = '1';
#else
Charger.Ver_FW[7] = '0';
#endif
#endif //FUNC_VERSION_USE_NEW_SPEC_20240926
}
//---------------
#ifdef FUNC_STM32_FLASH_INFO
enum { STM32_UID_LEN = 12 }; //96 bits (12 bytes)
typedef struct _STM32_Flash_Info
{
union
{
u8 m_UID[STM32_UID_LEN];
u32 m_UIDw[3];
};
u32 m_DeviceID;
u32 m_FlashSizeKB;
}
STM32_Flash_Info, *PSTM32_Flash_Info;
void STM32_Flash_Info_Init(PSTM32_Flash_Info p)
{
memset(p, 0, sizeof(STM32_Flash_Info));
}
void STM32_Flash_Info_Read(PSTM32_Flash_Info p)
{
//UID
memcpy(p->m_UID, (u8*)UID_BASE, STM32_UID_LEN);
//Device ID
p->m_DeviceID = (uint32_t)(READ_BIT(DBGMCU->IDCODE, DBGMCU_IDCODE_DEV_ID));
//Flash size
p->m_FlashSizeKB = (uint32_t)(READ_REG(*((uint32_t *)FLASHSIZE_BASE)) & 0xFFFF);
}
void STM32_Flash_Info_Disp(PSTM32_Flash_Info p)
{
XP("[FlashInfo]------------------------\r\n");
//UID
HTK_ByteArray2HexStr_XP("UID", p->m_UID, 0, STM32_UID_LEN);
//Device ID
XP("DeviceID: 0x%03X\r\n", p->m_DeviceID);
{
char *s = "DeviceFamily: ";
if (p->m_DeviceID == 0x413)
{
XP("%sSTM32F40xxx/F41xxx\r\n", s);
}
else if (p->m_DeviceID == 0x419)
{
XP("%sSTM32F42xxx/F43xxx\r\n", s);
}
else
{
XP("%sUnknow\r\n", s);
}
}
//Flash size
XP("DeviceFlashSize: %d Kbytes\r\n", p->m_FlashSizeKB);
#ifdef FUNC_DISP_MCU_CLOCK_INFO
XP("PWR->CR: 0x%08X, PWR->CSR: 0x%08X\r\n", PWR->CR, PWR->CSR);
#endif
}
void STM32_Flash_Info_Proc(void)
{
PSTM32_Flash_Info p = HTK_Malloc(sizeof(STM32_Flash_Info));
if (p != NULL)
{
STM32_Flash_Info_Init(p);
STM32_Flash_Info_Read(p);
STM32_Flash_Info_Disp(p);
}
else
{
XP("PSTM32_Flash_Info malloc NG\r\n");
}
}
#endif //FUNC_STM32_FLASH_INFO
#ifdef FUNC_STM32_FLASH_OPTION_BYTES
typedef struct _STM32_Flash_OB
{
FLASH_OBProgramInitTypeDef m_SetOB;
FLASH_OBProgramInitTypeDef m_CurOB;
u8 m_nRST_STDBY: 1; //0: Reset generated when entering the Standby mode
//1: No reset generated
u8 m_nRST_STOP: 1; //0: Reset generated when entering the Stop mode
//1: No reset generated
u8 m_WDG_SW: 1; //0: Hardware independent watchdog
//1: Software independent watchdog
}
STM32_Flash_OB, *PSTM32_Flash_OB;
void STM32_Flash_OB_Init(PSTM32_Flash_OB p)
{
memset(p, 0, sizeof(STM32_Flash_OB));
//Set default
p->m_SetOB.OptionType = OPTIONBYTE_WRP /*| OPTIONBYTE_RDP*/ | OPTIONBYTE_USER | OPTIONBYTE_BOR;
p->m_SetOB.WRPState = OB_WRPSTATE_ENABLE;
p->m_SetOB.Banks = 0;
p->m_SetOB.BORLevel = OB_BOR_LEVEL3;
p->m_SetOB.USERConfig = OB_IWDG_SW | OB_STOP_NO_RST | OB_STDBY_NO_RST;
#ifdef FUNC_USE_STM32_SBSFU
//Sector_0~4: Write Protection; Sector_5~11: No Write Protection
p->m_SetOB.WRPSector = OB_WRP_SECTOR_0 | OB_WRP_SECTOR_1 | OB_WRP_SECTOR_2 | OB_WRP_SECTOR_3 | OB_WRP_SECTOR_4;
p->m_SetOB.RDPLevel = OB_RDP_LEVEL_1;
#else
//Sector_0~11: No Write Protection
p->m_SetOB.WRPSector = ~OB_WRP_SECTOR_All;
p->m_SetOB.RDPLevel = OB_RDP_LEVEL_0;
#endif
}
void STM32_Flash_OB_Read(PSTM32_Flash_OB p)
{
__HAL_FLASH_PREFETCH_BUFFER_DISABLE();
HAL_FLASHEx_OBGetConfig(&p->m_CurOB);
__HAL_FLASH_PREFETCH_BUFFER_ENABLE();
p->m_nRST_STDBY = BIT_GET(p->m_CurOB.USERConfig, 7);
p->m_nRST_STOP = BIT_GET(p->m_CurOB.USERConfig, 6);
p->m_WDG_SW = BIT_GET(p->m_CurOB.USERConfig, 5);
}
void STM32_Flash_OB_WriteDefault(PSTM32_Flash_OB p)
{
XP("\r\n");
__HAL_FLASH_PREFETCH_BUFFER_DISABLE();
HAL_FLASH_Unlock();
HAL_FLASH_OB_Unlock();
{
{
XP("\r\n");
HAL_FLASHEx_OBProgram(&p->m_SetOB);
HAL_FLASH_OB_Launch();
}
{
FLASH_OBProgramInitTypeDef ob;
memcpy(&ob, &p->m_SetOB, sizeof(p->m_SetOB));
ob.OptionType = OPTIONBYTE_WRP;
ob.WRPState = OB_WRPSTATE_DISABLE;
ob.WRPSector = (~p->m_SetOB.WRPSector) & OB_WRP_SECTOR_All;
XP(" Disable>\r\n");
HAL_FLASHEx_OBProgram(&ob);
HAL_FLASH_OB_Launch();
}
if (p->m_CurOB.RDPLevel == OB_RDP_LEVEL_0 && p->m_SetOB.RDPLevel == OB_RDP_LEVEL_1)
{
FLASH_OBProgramInitTypeDef ob;
memcpy(&ob, &p->m_SetOB, sizeof(p->m_SetOB));
ob.OptionType = OPTIONBYTE_RDP;
XP(" Level 1> Please power off and then power on to restart !\r\n");
HAL_FLASHEx_OBProgram(&ob);
HAL_FLASH_OB_Launch();
/* Set the OPTSTRT bit in OPTCR register */
// XP("*(__IO uint8_t *)OPTCR_BYTE0_ADDRESS |= FLASH_OPTCR_OPTSTRT [BEG]\r\n");
// *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS |= FLASH_OPTCR_OPTSTRT;
// XP("*(__IO uint8_t *)OPTCR_BYTE0_ADDRESS |= FLASH_OPTCR_OPTSTRT [BEG]\r\n");
//HAL_Delay(1000);
//NVIC_SystemReset();
}
}
HAL_FLASH_OB_Lock();
HAL_FLASH_Lock();
__HAL_FLASH_PREFETCH_BUFFER_ENABLE();
}
void STM32_Flash_OB_Disp(PSTM32_Flash_OB p)
{
XP("[OB]-------------------------------\r\n");
XP("OptionType: 0x%08X\r\n", p->m_CurOB.OptionType);
XP("WRPState : 0x%08X\r\n", p->m_CurOB.WRPState);
XP("WRPSector : 0x%08X\r\n", p->m_CurOB.WRPSector);
{
for (int i = 0; i < 12; i++)
{
XP("\tSector_%d: %s Protection\r\n", i, BIT_GET(p->m_CurOB.WRPSector, i) == 1 ? "No" : "Write");
}
}
XP("Banks : 0x%08X\r\n", p->m_CurOB.Banks);
XP("RDPLevel : 0x%08X (0: 0xAA, 1: 0x55, 2: 0xCC)\r\n", p->m_CurOB.RDPLevel);
XP("BORLevel : 0x%08X (3: 0x00, 2: 0x04, 1: 0x08, OFF: 0x0C)\r\n", p->m_CurOB.BORLevel);
XP("USERConfig: 0x%02X\r\n", p->m_CurOB.USERConfig);
{
XP("\tnRST_STDBY = %d (%s)\r\n", p->m_nRST_STDBY, (p->m_nRST_STDBY == 0 ? "STDBY_RST(0)" : "STDBY_NO_RST(0x80)"));
XP("\tnRST_STOP = %d (%s)\r\n", p->m_nRST_STOP, (p->m_nRST_STOP == 0 ? "STOP_RST(0)" : "STOP_NO_RST(0x40)"));
XP("\tWDG_SW = %d (%s)\r\n", p->m_WDG_SW, (p->m_WDG_SW == 0 ? "IWDG_HW(0)" : "IWDG_SW(0x20)"));
}
}
HTK_BOOL STM32_Flash_OB_IsDefault(PSTM32_Flash_OB p)
{
XP("m_CurOB.BORLevel = 0x%08X, m_SetOB.BORLevel = 0x%08X\r\n", p->m_CurOB.BORLevel, p->m_SetOB.BORLevel);
XP("m_CurOB.RDPLevel = 0x%08X, m_SetOB.RDPLevel = 0x%08X\r\n", p->m_CurOB.RDPLevel, p->m_SetOB.RDPLevel);
XP("m_CurOB.USERConfig = 0x%08X, m_SetOB.USERConfig = 0x%08X\r\n", p->m_CurOB.USERConfig, p->m_SetOB.USERConfig);
XP("m_CurOB.WRPSector = 0x%08X, m_SetOB.WRPSector = 0x%08X\r\n", p->m_CurOB.WRPSector, p->m_SetOB.WRPSector);
XP("(~p->m_SetOB.WRPSector) & OB_WRP_SECTOR_All = 0x%08X\r\n", (~p->m_SetOB.WRPSector) & OB_WRP_SECTOR_All);
if (
(p->m_CurOB.BORLevel == p->m_SetOB.BORLevel) &&
(p->m_CurOB.RDPLevel == p->m_SetOB.RDPLevel) &&
(p->m_CurOB.USERConfig == p->m_SetOB.USERConfig) &&
(p->m_CurOB.WRPSector == ((~p->m_SetOB.WRPSector) & OB_WRP_SECTOR_All))
)
{
XP("\r\n");
return HTK_TRUE;
}
else
{
XP("\r\n");
return HTK_FALSE;
}
}
void STM32_Flash_OB_ProcDefault(void)
{
PSTM32_Flash_OB p = HTK_Malloc(sizeof(STM32_Flash_OB));
if (p != NULL)
{
STM32_Flash_OB_Init(p);
STM32_Flash_OB_Read(p);
STM32_Flash_OB_Disp(p);
if (!STM32_Flash_OB_IsDefault(p))
{
STM32_Flash_OB_WriteDefault(p);
STM32_Flash_OB_Read(p);
STM32_Flash_OB_Disp(p);
if (STM32_Flash_OB_IsDefault(p))
{
XP("\r\n");
}
else
{
XP("\r\n");
}
}
}
else
{
XP("STM32_Flash_OB malloc NG\r\n");
}
}
#endif //FUNC_STM32_FLASH_OPTION_BYTES
void MX_FREERTOS_Init(void) {
/* USER CODE BEGIN Init */
#ifdef FUNC_BOOT_TICK
Charger.m_BootTick = HAL_GetTick();
#endif
#ifdef FUNC_STM32_FLASH_INFO
STM32_Flash_Info_Proc();
#endif //FUNC_STM32_FLASH_INFO
#ifdef FUNC_STM32_FLASH_OPTION_BYTES
STM32_Flash_OB_ProcDefault();
#endif
#ifdef FUNC_RS485_BLE_SW
RS485_SW(HTK_TRUE);
BLE_SW(HTK_FALSE); //Disable BLE (remove part from PCB)
#endif
#ifdef FUNC_SYSTEM_KEEP_INFO
if (!SystemKeepInfo_Check(&g_SystemKeepInfo))
{
memset(&g_SystemKeepInfo, 0, sizeof(g_SystemKeepInfo));
}
g_SystemKeepInfo.m_BootCount++;
SystemKeepInfo_Update(&g_SystemKeepInfo);
SystemKeepInfo_Display(&g_SystemKeepInfo);
#endif
UpdateFirmwareVersion();
sprintf(Charger.Ver_HW, "1.0");
HAL_GPIO_WritePin(OUT_Leak_Test_GPIO_Port, OUT_Leak_Test_Pin, GPIO_PIN_SET);
/* USER CODE END Init */
/* USER CODE BEGIN RTOS_MUTEX */
/* add mutexes, ... */
/* USER CODE END RTOS_MUTEX */
/* USER CODE BEGIN RTOS_SEMAPHORES */
/* add semaphores, ... */
/* USER CODE END RTOS_SEMAPHORES */
/* USER CODE BEGIN RTOS_TIMERS */
/* start timers, add new ones, ... */
/* USER CODE END RTOS_TIMERS */
/* USER CODE BEGIN RTOS_QUEUES */
/* add queues, ... */
/* USER CODE END RTOS_QUEUES */
/* Create the thread(s) */
/* definition and creation of ethTask */
#ifndef DISABLE_OS_ETH_TASK
//osThreadDef(ethTask, StartEthTask, osPriorityIdle, 0, 1024);
osThreadDef(ethTask, StartEthTask, osPriorityIdle, 0, 128); //Empty(USB)
ethTaskHandle = osThreadCreate(osThread(ethTask), NULL);
#endif
/* definition and creation of uartTask */
osThreadDef(uartTask, StartUartTask, osPriorityNormal, 0, 1024);
uartTaskHandle = osThreadCreate(osThread(uartTask), NULL);
/* definition and creation of adcTask */
#ifdef MODIFY_OS_ADC_TASK_DEFINE_DATA
osThreadDef(adcTask, StartAdcTask, osPriorityRealtime, 0, 512);
#else
osThreadDef(adcTask, StartAdcTask, osPriorityRealtime, 0, 256);
#endif
adcTaskHandle = osThreadCreate(osThread(adcTask), NULL);
/* definition and creation of timeoutTask */
osThreadDef(timeoutTask, StartTimeoutTask, osPriorityNormal, 0, 128);
timeoutTaskHandle = osThreadCreate(osThread(timeoutTask), NULL);
#ifdef FUNC_ENABLE_USART1_RFID
/* definition and creation of rfidTask */
osThreadDef(rfidTask, StartRfidTask, osPriorityIdle, 0, 256);
rfidTaskHandle = osThreadCreate(osThread(rfidTask), NULL);
#endif
/* definition and creation of led_speakerTask */
osThreadDef(led_speakerTask, StartLedSpeakerTask, osPriorityNormal, 0, 128);
led_speakerTaskHandle = osThreadCreate(osThread(led_speakerTask), NULL);
/* definition and creation of cpTask */
osThreadDef(cpTask, StartCpTask, osPriorityHigh, 0, 256);
cpTaskHandle = osThreadCreate(osThread(cpTask), NULL);
/* definition and creation of alarmTask */
osThreadDef(alarmTask, StartAlarmTask, osPriorityHigh, 0, 256);
alarmTaskHandle = osThreadCreate(osThread(alarmTask), NULL);
/* definition and creation of bleTask */
#ifdef LOCAL_LINK_BLE
osThreadDef(bleTask, StartBleTask, osPriorityHigh, 0, 1024);
bleTaskHandle = osThreadCreate(osThread(bleTask), NULL);
#endif
/* definition and creation of memoryTask */
osThreadDef(memoryTask, StartMemoryTask, osPriorityIdle, 0, 256);
memoryTaskHandle = osThreadCreate(osThread(memoryTask), NULL);
/* definition and creation of wifiTask */
#ifdef LOCAL_LINK_WIFI
osThreadDef(wifiTask, StartWifiTask, osPriorityIdle, 0, 1024);
wifiTaskHandle = osThreadCreate(osThread(wifiTask), NULL);
#endif
/* definition and creation of MeterTask */
osThreadDef(MeterTask, StartMeterTask, osPriorityIdle, 0, 1024);
MeterTaskHandle = osThreadCreate(osThread(MeterTask), NULL);
/* USER CODE BEGIN RTOS_THREADS */
/* add threads, ... */
#ifdef RECODE_FUNC_METER_IC_TASK
#ifdef MODIFY_METER_IC_TASK_PRIORITY
//osThreadDef(MeterIcTask, StartMeterIcTask, osPriorityAboveNormal, 0, 1024);
osThreadDef(MeterIcTask, StartMeterIcTask, osPriorityHigh, 0, 1024);
#else
osThreadDef(MeterIcTask, StartMeterIcTask, osPriorityNormal, 0, 1024);
#endif
MeterIcTaskHandle = osThreadCreate(osThread(MeterIcTask), NULL);
#endif
#ifdef FUNC_TASK_MONITOR
osThreadDef(MonitorTask, StartMonitorTask, osPriorityIdle, 0, 256);
MonitorTaskHandle = osThreadCreate(osThread(MonitorTask), NULL);
#endif
#ifdef FUNC_LIN_CP
//osThreadDef(LinCpTask, StartLinCpTask, osPriorityIdle, 0, 256 * 4);
osThreadDef(LinCpTask, StartLinCpTask, osPriorityIdle, 0, 256);
LinCpTaskHandle = osThreadCreate(osThread(LinCpTask), NULL);
#endif
#ifdef FUNC_VERIFY_TASK
osThreadDef(VerifyTask, StartVerifyTask, osPriorityIdle, 0, 256);
VerifyTaskHandle = osThreadCreate(osThread(VerifyTask), NULL);
#endif
/* USER CODE END RTOS_THREADS */
}
#ifndef DISABLE_OS_ETH_TASK
/* USER CODE BEGIN Header_StartEthTask */
/**
* @brief Function implementing the ethTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartEthTask */
void StartEthTask(void const * argument)
{
/* init code for USB_DEVICE */
MX_USB_DEVICE_Init();
/* USER CODE BEGIN StartEthTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
IdleUntilReadAllMemory();
#endif
/* Infinite loop */
for(;;)
{
osDelay(1);
}
/* USER CODE END StartEthTask */
}
#endif //DISABLE_OS_ETH_TASK
/* USER CODE BEGIN Header_StartUartTask */
/**
* @brief Function implementing the uartTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartUartTask */
void StartUartTask(void const * argument)
{
/* USER CODE BEGIN StartUartTask */
//uuart
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
IdleUntilReadAllMemory();
#endif
#ifndef DISABLE_PRINT_RTOS_MSG
uint8_t pcWriteBuffer[1024];
#endif
#ifndef FUNC_USE_STM32_SBSFU
uint8_t endFlag[4]={0x55,0xaa,0x55,0xaa};
uint32_t checksum;
#endif
__IO uint32_t flash;
uint8_t dbgIdx;
#if defined(DEBUG) || defined(RTOS_STAT)
DEBUG_INFO("========== AP initial OK ==========\n\r");
DEBUG_INFO(" Version: %s\n\r", Charger.Ver_FW);
DEBUG_INFO("===================================\n\r");
if (__HAL_RCC_GET_FLAG(RCC_FLAG_PINRST) != RESET) DEBUG_INFO("Reset flag: Pin reset \r\n");
if (__HAL_RCC_GET_FLAG(RCC_FLAG_PORRST) != RESET) DEBUG_INFO("Reset flag: POR reset \r\n");
if (__HAL_RCC_GET_FLAG(RCC_FLAG_SFTRST) != RESET) DEBUG_INFO("Reset flag: SW reset \r\n");
if (__HAL_RCC_GET_FLAG(RCC_FLAG_IWDGRST) != RESET) DEBUG_INFO("Reset flag: IWDG reset \r\n");
if (__HAL_RCC_GET_FLAG(RCC_FLAG_WWDGRST) != RESET) DEBUG_INFO("Reset flag: WWDG reset \r\n");
if (__HAL_RCC_GET_FLAG(RCC_FLAG_LPWRRST) != RESET) DEBUG_INFO("Reset flag: LP reset \r\n");
DEBUG_INFO("\r\n");
__HAL_RCC_CLEAR_RESET_FLAGS();
#endif
Charger.CSUisReady = OFF ;
#ifdef FUNC_RS485_SLAVE
HAL_GPIO_WritePin(OUT_Meter_485_DE_GPIO_Port, OUT_Meter_485_DE_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(OUT_Meter_485_RE_GPIO_Port, OUT_Meter_485_RE_Pin, GPIO_PIN_RESET);
#endif
#ifdef FUNC_IDLE_UNTIL_INIT_METER_IC
IdleUntilInitMeterIC();
#endif
#ifdef FUNC_CSU_PUBLIC_KEY_OPERATION
if (Charger.m_bCsuSignInMustVerify)
{
#ifdef FUNC_SECURITY_DEBUG_INFO
HTK_ByteArray2HexStr_XP("CSU_PublicKey", Charger.memory.EVSE_Config.data.item.m_CsuPublicKey, 0, CSU_PUBLIC_KEY_LEN);
#endif
}
#endif
#ifdef FUNC_RELAY_OFF_WHEN_GET_TWICE_OFF_CMD
u8 CsuSetRelayOffCount = 0;
#endif
//#ifdef FUNC_REQUEST_OFF_WHEN_GET_TWICE_OFF_CMD
// u8 CsuSetRequestOffCount = 0;
//#endif
/* Infinite loop */
for(;;)
{
timerEnable(TIMER_IDX_RTOS_STAT, 500);
if(timer[TIMER_IDX_RTOS_STAT].isAlarm)
{
switch(dbgIdx)
{
case 0:
#ifdef RTOS_STAT
#ifndef DISABLE_PRINT_RTOS_MSG
printf("=================================================\r\n");
printf("Task_Name \tState \tPrior \tStack \tTask_Id\r\n");
vTaskList((char *)&pcWriteBuffer);
printf("%s\r\n", pcWriteBuffer);
printf("-------------------------------------------------\r\n");
printf("Task_Name \tRun_Time(10us) \tUsage_Percent\r\n");
vTaskGetRunTimeStats((char *)&pcWriteBuffer);
printf("%s\r\n", pcWriteBuffer);
#endif //DISABLE_PRINT_RTOS_MSG
#endif
#ifdef FUNC_PTB_METER_WM3M4C
if (Charger.m_bUseExtMeter_WM3M4C && Charger.m_pWM3M4C)
{
const PWM3M4C p = Charger.m_pWM3M4C;
#ifdef DEBUG_PTB_METER_WM3M4C
XP("========================< WM3M4C Information >=====================\r\n");
XP("[30001 ModelName ] %s\r\n", p->m_ModelName.m_Str);
XP("[30009 SerialNumber ] %s\r\n", p->m_SerialNumber.m_Str);
XP("[30013 SW_Version ] %.2f\r\n", (float)p->m_SW_Ver.m_Val * 0.01);
XP("[30014 HW_Version ] %s\r\n", p->m_HW_Ver.m_Str);
XP("===================================================================\r\n");
XP("[30400 CheckSumStatus ] 0x%04X\r\n", p->m_CheckSumStatus.m_Val);
XP("===================================================================\r\n");
XP("[30414 EngCountExp1 ] %d\r\n", p->m_EngCountExp1.m_Val);
XP("[30415 EngCountExp2 ] %d\r\n", p->m_EngCountExp2.m_Val);
XP("[30418 EngCount1 (Wh) ] %d\r\n", p->m_EngCount1.m_Val);
XP("[30420 EngCount2 (Wh) ] %d\r\n", p->m_EngCount2.m_Val);
XP("[30434 EngCount1x1000 ] %d\r\n", p->m_EngCount1x1000.m_Val);
XP("[30436 EngCount2x1000 ] %d\r\n", p->m_EngCount2x1000.m_Val);
XP("[----- Eng1 (0.0001Wh) ] %llu\r\n", p->m_AccuEnergy1);
XP("===================================================================\r\n");
XP("[47000 MeasurementStatus] %d\r\n", p->m_MeasurementStatus.m_Val);
XP("[47001 Duration ] %d\r\n", p->m_Duration.m_Val);
XP("[47003 Consumption ] %d\r\n", p->m_Consumption.m_Val);
XP("[47005 ActivePowerTotal ] %lf\r\n", p->m_ActivePowerTotal.m_Val);
XP("[47007 DateTime ] %d (%s)\r\n", p->m_GetDateTime.m_Val, p->m_GetDateTime.m_Str);
XP("[47013 SignaturesCount ] %d\r\n", p->m_SignaturesCount.m_Val);
XP("===================================================================\r\n");
XP("[47052 SignatureStatus ] %d\r\n", p->m_SignatureStatus.m_Val);
XP("[47053 TimeZoneOffset ] %d\r\n", p->m_TimeZoneOffset.m_Val);
XP("[47054 SetDataTime ] %d (%s)\r\n", p->m_SetDataTime.m_Val, p->m_SetDataTime.m_Str);
XP("[47056 InpMsgLen ] %d\r\n", p->m_InpMsgLen.m_Val);
XP("[47057 OutpMsgLen ] %d\r\n", p->m_OutpMsgLen.m_Val);
XP("[47058 OutpSigLen ] %d (x2 = %d)\r\n", p->m_OutpSigLen.m_Val, p->m_OutpSigLen.m_Val * 2);
XP("[----- ExpOutpMsgSigLen ] %d\r\n", p->m_ExpectOutpMsgSigLen);
XP("[47059 OutpSigFmt ] %d\r\n", p->m_OutpSigFmt.m_Val);
XP("[47060 OutpSigAlg ] %d\r\n", p->m_OutpSigAlg.m_Val);
XP("[47061 Backlit ] %d\r\n", p->m_Backlit.m_Val);
XP("===================================================================\r\n");
XP("[47100 DataSetInput ] %s (%d:%d)\r\n", p->m_InputJsonMsg.m_All, p->m_InpMsgLen.m_Val, strlen(p->m_InputJsonMsg.m_All));
XP("===================================================================\r\n");
XP("[47612 OutpMsg ] %s (%d:%d)\r\n", (char*)p->m_OutpMsg.m_Buf, p->m_OutpMsgLen.m_Val, strlen((char*)p->m_OutpMsg.m_Buf));
XP("===================================================================\r\n");
XP("[FIXED PublicKeyHeader ] %s (%d)\r\n", p->m_PublicKeyHStr, WM3M3C_PUBLIC_KEY_H_LEN * 2);
XP("[48124 PublicKey ] %s (%d)\r\n", p->m_PublicKey.m_Str, p->m_PublicKeyStrLen);
XP("===================================================================\r\n");
XP("[48188 OutpSig ] %s (%d)\r\n", p->m_OutpSig.m_Str, p->m_OutpSigLen.m_Val);
XP("===================================================================\r\n");
XP("[----- OutpMsgSig ] %s (%d)\r\n", p->m_OutpMsgSig, p->m_OutpMsgSigLen);
XP("[----- Header+PKey ] %s (%d)\r\n", p->m_HPKey, p->m_HPKeyLen);
XP("===================================================================\r\n");
#else //DEBUG_PTB_METER_WM3M4C
XP("[OutpMsgSig] %s (%d)\r\n", p->m_OutpMsgSig, p->m_OutpMsgSigLen);
XP("[Header+PKey] %s (%d)\r\n\r\n", p->m_HPKey, p->m_HPKeyLen);
#endif //DEBUG_PTB_METER_WM3M4C
}
#endif //FUNC_PTB_METER_WM3M4C
#ifdef FUNC_EKM_OMNIMETER_DISPLAY
if (Charger.m_bUseExtMeter_OMNIMETER && Charger.m_pEKM_Omnimeter)
{
EKM_Omnimeter_Display(Charger.m_pEKM_Omnimeter);
}
#endif
#ifdef FUNC_LINCP_DISPLAY
if (Charger.m_bUseLinCP && Charger.m_pLinCP)
{
LIN_Display(Charger.m_pLinCP);
}
#endif
//#ifdef FUNC_SALT_AND_BLEND
// if (0)
// {
// enum
// {
// KeyLen = 64,
// SaltLen = 64,
// MixtureLen = KeyLen + SaltLen,
// SaltMapLen = GET_BOX_NUM(MixtureLen, 8),
// AllLen = MixtureLen + SaltMapLen,
// };
//
// u8* Key = (u8*)HTK_Malloc(KeyLen);
// if (Key != NULL)
// {
// for (int i = 0; i < KeyLen; i++) { Key[i] = i + 1; }
// u8* Mixture = (u8*)HTK_Malloc(AllLen);
// if (Mixture != NULL)
// {
// DataEncryption(Key, KeyLen, Mixture, AllLen, 0);
// DataEncryption(Key, KeyLen, Mixture, AllLen, 1);
// HTK_Free(Mixture);
// }
// HTK_Free(Key);
// }
// }
//#endif //FUNC_SALT_AND_BLEND
dbgIdx++;
break;
case 1:
#ifdef FUNC_USE_STM32_SBSFU
DEBUG_INFO("Firmware version: %s [S]\r\n", Charger.Ver_FW);
#else
DEBUG_INFO("Firmware version: %s\r\n", Charger.Ver_FW);
#endif
#ifdef FUNC_BUILD_DATE_TIME
DEBUG_INFO("Build: %s %s\r\n", __DATE__, __TIME__); //ex Build: Mar 10 2022 14:53:25
#endif
#ifdef FUNC_CSU_SIGN_IN_VERIFY
DEBUG_INFO("MCU_Control_Mode: %x (%s%s)\r\n",Charger.memory.EVSE_Config.data.item.MCU_Control_Mode,
Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_CSU ? "CSU" : "No CSU",
Charger.m_bCsuSignInMustVerify ? (Charger.m_bCsuSignInVerifyOK ? ": VerifyOK" : ": NotVerify") : "");
#else
DEBUG_INFO("MCU_Control_Mode: %x (%s)\r\n",Charger.memory.EVSE_Config.data.item.MCU_Control_Mode,
Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_CSU ? "CSU" : "No CSU");
#endif
DEBUG_INFO("ModelName: %s\r\n",Charger.memory.EVSE_Config.data.item.ModelName);
DEBUG_INFO("SerialNumber: %s\r\n",Charger.memory.EVSE_Config.data.item.SerialNumber);
#ifdef FUNC_BOOT_TICK
DEBUG_INFO("UpTime(s): %d\r\n", (HAL_GetTick() - Charger.m_BootTick) / 1000);
#endif
dbgIdx++;
break;
case 2:
if (Charger.CCID_Module_Type == CCID_MODULE_CORMEX)
{
DEBUG_INFO("Charger.CCID_Module_Type is CCID_MODULE_CORMEX\n\r");
}
else if (Charger.CCID_Module_Type == CCID_MODULE_VAC)
{
DEBUG_INFO("Charger.CCID_Module_Type is CCID_MODULE_VAC\n\r");
}
DEBUG_INFO("System mode: %d\r\n", Charger.Mode);
DEBUG_INFO("Alarm code: 0x%08X\r\n", Charger.Alarm_Code);
#ifdef FUNC_WARNING_CODE
DEBUG_INFO("Warning code: 0x%08X\r\n", Charger.Warning_Code);
#endif
#ifdef FUNC_SHOW_RELAY_INFO
DEBUG_INFO("Relay action: Main(%d), TypeE(%d)\r\n", Charger.Relay_Action, Charger.SE_Relay_Action);
#endif
#ifdef FUNC_MODE_DEBUG_REC_RELAY_ON_TIMES
if (Charger.isDebugEnable)
{
DEBUG_INFO("[Debug Mode] RelayOnTimes: %d\r\n", Charger.memory.EVSE_Config.data.item.m_ModeDebugRelayOnTimes);
}
#endif
dbgIdx++;
break;
case 3:
#ifndef FUNC_REPLACE_ADC_WITH_METER_IC
DEBUG_INFO("Original L1 Voltage: %fV\r\n", adc_value.ADC3_IN9_Voltage_L1.value/100.0);
DEBUG_INFO("Original L2 Voltage: %fV\r\n", adc_value.ADC3_IN8_Voltage_L2.value/100.0);
DEBUG_INFO("Original L3 Voltage: %fV\r\n", adc_value.ADC3_IN10_Voltage_L3.value/100.0);
#endif
dbgIdx++;
break;
case 4:
#ifndef FUNC_REPLACE_ADC_WITH_METER_IC
DEBUG_INFO("Original L1 Current: %fA\r\n", adc_value.ADC3_IN7_Current_L1.value/100.0);
DEBUG_INFO("Original L2 Current: %fA\r\n", adc_value.ADC3_IN5_Current_L2.value/100.0);
DEBUG_INFO("Original L3 Current: %fA\r\n", adc_value.ADC3_IN11_Current_L3.value/100.0);
#endif
dbgIdx++;
break;
case 5:
#ifdef FUNC_INFO_METER_IC_RAW_DATA
DEBUG_INFO("Correction L1 Voltage[0]: %fV (%d)\r\n", Charger.Voltage[0]/100.0, Charger.m_MeterIC_MeasVals.m_AVRMS_LRIP);
DEBUG_INFO("Correction L2 Voltage[1]: %fV (%d)\r\n", Charger.Voltage[1]/100.0, Charger.m_MeterIC_MeasVals.m_BVRMS_LRIP);
DEBUG_INFO("Correction L3 Voltage[2]: %fV (%d)\r\n", Charger.Voltage[2]/100.0, Charger.m_MeterIC_MeasVals.m_CVRMS_LRIP);
#else
DEBUG_INFO("Correction L1 Voltage[0]: %fV\r\n", Charger.Voltage[0]/100.0);
DEBUG_INFO("Correction L2 Voltage[1]: %fV\r\n", Charger.Voltage[1]/100.0);
DEBUG_INFO("Correction L3 Voltage[2]: %fV\r\n", Charger.Voltage[2]/100.0);
#endif
dbgIdx++;
break;
case 6:
#ifdef FUNC_INFO_METER_IC_RAW_DATA
DEBUG_INFO("Correction L1 Current[0]: %fA (%d)\r\n", Charger.Current[0]/100.0, Charger.m_MeterIC_MeasVals.m_AIRMS_LRIP);
DEBUG_INFO("Correction L2 Current[1]: %fA (%d)\r\n", Charger.Current[1]/100.0, Charger.m_MeterIC_MeasVals.m_BIRMS_LRIP);
DEBUG_INFO("Correction L3 Current[2]: %fA (%d)\r\n", Charger.Current[2]/100.0, Charger.m_MeterIC_MeasVals.m_CIRMS_LRIP);
#else
DEBUG_INFO("Correction L1 Current[0]: %fA\r\n", Charger.Current[0]/100.0);
DEBUG_INFO("Correction L2 Current[1]: %fA\r\n", Charger.Current[1]/100.0);
DEBUG_INFO("Correction L3 Current[2]: %fA\r\n", Charger.Current[2]/100.0);
#endif
#ifdef FUNC_METER_IC_READ_PHASE_ANGLE
{
#ifndef DISABLE_PRINT_DEBUG_MSG
const PMeterIC_ExtraInfo pEx = &Charger.m_MeterIcEx;
#endif
DEBUG_INFO("MeterIC: MMODE(0x%02X) COMPMODE(0x%04X) STATUS01(0x%08X, 0x%08X) Period(%d:%s)\r\n",
pEx->m_MMODE,
pEx->m_COMPMODE,
pEx->m_STATUS0,
pEx->m_STATUS1,
Charger.m_MeterIC_MeasVals.m_Period,
AC_PERIOD_MODE_STR[pEx->m_AcPeriodMode]);
DEBUG_INFO("MeterIC: ANGLE_REG3_DEG3(%4d, %4d, %4d, %10.6lf, %10.6lf, %10.6lf) SEQERR(%d) [%s]\r\n",
pEx->m_AngleReg[0],
pEx->m_AngleReg[1],
pEx->m_AngleReg[2],
pEx->m_AngleDegree[0],
pEx->m_AngleDegree[1],
pEx->m_AngleDegree[2],
pEx->m_bSEQERR,
AC_PHASE_MODE_STR[pEx->m_AcPhaseMode]);
}
#endif //FUNC_METER_IC_READ_PHASE_ANGLE
dbgIdx++;
break;
case 7:
DEBUG_INFO("PE(ADC): %d\r\n", adc_value.ADC3_IN4_GMI_VL1.value );
DEBUG_INFO("PE(V): %f\r\n", adc_value.ADC3_IN4_GMI_VL1.value*3.3/4095 );
DEBUG_INFO("adc_value.ADC2_IN5_Welding.value : %d(unit:0.01v)\r\n", adc_value.ADC2_IN5_Welding.value );
#ifdef DEBUG_RELAY_MONITOR_SHOW_INFO
{
double threshold =
Charger.Voltage[0] * 0.01 *
Charger.alarm_spec.Relay_LL_Welding_Slop +
Charger.alarm_spec.Relay_LL_Welding_Offs;
XP("#Welding threshold : %lf\r\n", threshold);
}
#endif //DEBUG_RELAY_MONITOR_SHOW_INFO
DEBUG_INFO("SystemAmbientTemp: %d (unit:C)\r\n", Charger.temperature.SystemAmbientTemp);
#ifdef FUNC_TMP100
if (Charger.m_bUseTMP100)
{
DEBUG_INFO("TMP100: %.4f (unit:C) >>> CcsConnectorTemp: %d \r\n", Charger.m_TMP100_cTemp, Charger.temperature.CcsConnectorTemp);
}
#endif
#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
if (Charger.m_bModelNameAX80_1P)
{
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
if (Charger.m_bModelNameAX80_NACS_1P)
{
#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX_G2[T12](%d), MAX_G3[T34](%d), MAX_G4[T56](%d)\r\n",
Charger.temperature.AX80_NACS_T1_L1_IN,
Charger.temperature.AX80_NACS_T2_L2_IN,
Charger.temperature.AX80_NACS_T3_L1_OUT,
Charger.temperature.AX80_NACS_T4_L2_OUT,
Charger.temperature.AX80_NACS_T5_L1_GUN,
Charger.temperature.AX80_NACS_T6_L2_GUN,
Charger.temperature.Group2_MaxTemp, Charger.temperature.Group3_MaxTemp, Charger.temperature.Group4_MaxTemp);
#else //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX(%d)\r\n",
Charger.temperature.AX80_NACS_T1_L1_IN,
Charger.temperature.AX80_NACS_T2_L2_IN,
Charger.temperature.AX80_NACS_T3_L1_OUT,
Charger.temperature.AX80_NACS_T4_L2_OUT,
Charger.temperature.AX80_NACS_T5_L1_GUN,
Charger.temperature.AX80_NACS_T6_L2_GUN,
Charger.temperature.Group2_MaxTemp);
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
#ifdef DEBUG_SHOW_AX80_NACS_TEMP_SENSOR_ADC_COUNT
DEBUG_INFO("[ADC_COUNT] T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d)\r\n",
adc_value.ADC3_IN9_AX80_NACS_T1.value,
adc_value.ADC3_IN8_AX80_NACS_T2.value,
adc_value.ADC3_IN10_AX80_NACS_T3.value,
adc_value.ADC3_IN7_AX80_NACS_T4.value,
adc_value.ADC3_IN5_AX80_NACS_T5.value,
adc_value.ADC3_IN11_AX80_NACS_T6.value);
#endif //DEBUG_SHOW_AX80_NACS_TEMP_SENSOR_ADC_COUNT
}
else
{
DEBUG_INFO("Relay1(%d), Relay2(%d), InL1(%d), InL2N(%d), Max(%d)\r\n",
Charger.temperature.AX80_Relay1Temp,
Charger.temperature.AX80_Relay2Temp,
Charger.temperature.AX80_Input_L1_Temp,
Charger.temperature.AX80_Input_N_L2_Temp,
Charger.temperature.Group2_MaxTemp);
}
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
DEBUG_INFO("Relay1(%d), Relay2(%d), InL1(%d), InL2N(%d), Max(%d)\r\n",
Charger.temperature.AX80_Relay1Temp,
Charger.temperature.AX80_Relay2Temp,
Charger.temperature.AX80_Input_L1_Temp,
Charger.temperature.AX80_Input_N_L2_Temp,
Charger.temperature.Group2_MaxTemp);
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
}
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
else if (Charger.m_bModelNameAW48_1P)
{
#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX_G2[T12](%d), MAX_G3[T34](%d), MAX_G4[T56](%d)\r\n",
Charger.temperature.AW48_T1_L1_IN,
Charger.temperature.AW48_T2_L2_IN,
Charger.temperature.AW48_T3_L1_OUT,
Charger.temperature.AW48_T4_L2_OUT,
Charger.temperature.AW48_T5_L1_GUN,
Charger.temperature.AW48_T6_L2_GUN,
Charger.temperature.Group2_MaxTemp, Charger.temperature.Group3_MaxTemp, Charger.temperature.Group4_MaxTemp);
#else //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX_G2[T1256](%d), MAX_G3[T34](%d)\r\n",
Charger.temperature.AW48_T1_L1_IN,
Charger.temperature.AW48_T2_L2_IN,
Charger.temperature.AW48_T3_L1_OUT,
Charger.temperature.AW48_T4_L2_OUT,
Charger.temperature.AW48_T5_L1_GUN,
Charger.temperature.AW48_T6_L2_GUN,
Charger.temperature.Group2_MaxTemp, Charger.temperature.Group3_MaxTemp);
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#else //MODIFY_AW48_OTP_SPEC_20240522_STEVEN
DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX(%d)\r\n",
Charger.temperature.AW48_T1_L1_IN,
Charger.temperature.AW48_T2_L2_IN,
Charger.temperature.AW48_T3_L1_OUT,
Charger.temperature.AW48_T4_L2_OUT,
Charger.temperature.AW48_T5_L1_GUN,
Charger.temperature.AW48_T6_L2_GUN,
Charger.temperature.Group2_MaxTemp);
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef DEBUG_SHOW_AW48_TEMP_SENSOR_ADC_COUNT
DEBUG_INFO("[ADC_COUNT] T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d)\r\n",
adc_value.ADC3_IN9_AW48_T1.value,
adc_value.ADC3_IN8_AW48_T2.value,
adc_value.ADC3_IN10_AW48_T3.value,
adc_value.ADC3_IN7_AW48_T4.value,
adc_value.ADC3_IN5_AW48_T5.value,
adc_value.ADC3_IN11_AW48_T6.value);
#endif //DEBUG_SHOW_AW48_TEMP_SENSOR_ADC_COUNT
}
#endif //FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
else if (Charger.m_bModelNameAX48_NACS_1P)
{
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX_G2[T12](%d), MAX_G3[T34](%d), MAX_G4[T56](%d)\r\n",
Charger.temperature.AX48_NACS_T1_L1_IN,
Charger.temperature.AX48_NACS_T2_L2_IN,
Charger.temperature.AX48_NACS_T3_L1_OUT,
Charger.temperature.AX48_NACS_T4_L2_OUT,
Charger.temperature.AX48_NACS_T5_L1_GUN,
Charger.temperature.AX48_NACS_T6_L2_GUN,
Charger.temperature.Group2_MaxTemp, Charger.temperature.Group3_MaxTemp, Charger.temperature.Group4_MaxTemp);
#else //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX_G2[T1256](%d), MAX_G3[T34](%d)\r\n",
Charger.temperature.AX48_NACS_T1_L1_IN,
Charger.temperature.AX48_NACS_T2_L2_IN,
Charger.temperature.AX48_NACS_T3_L1_OUT,
Charger.temperature.AX48_NACS_T4_L2_OUT,
Charger.temperature.AX48_NACS_T5_L1_GUN,
Charger.temperature.AX48_NACS_T6_L2_GUN,
Charger.temperature.Group2_MaxTemp, Charger.temperature.Group3_MaxTemp);
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
#else //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
DEBUG_INFO("T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d), MAX(%d)\r\n",
Charger.temperature.AX48_NACS_T1_L1_IN,
Charger.temperature.AX48_NACS_T2_L2_IN,
Charger.temperature.AX48_NACS_T3_L1_OUT,
Charger.temperature.AX48_NACS_T4_L2_OUT,
Charger.temperature.AX48_NACS_T5_L1_GUN,
Charger.temperature.AX48_NACS_T6_L2_GUN,
Charger.temperature.Group2_MaxTemp);
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef DEBUG_SHOW_AX48_NACS_TEMP_SENSOR_ADC_COUNT
DEBUG_INFO("[ADC_COUNT] T1_L1_IN(%d), T2_L2_IN(%d), T3_L1_OUT(%d), T4_L2_OUT(%d), T5_L1_GUN(%d), T6_L2_GUN(%d)\r\n",
adc_value.ADC3_IN9_AX48_NACS_T1.value,
adc_value.ADC3_IN8_AX48_NACS_T2.value,
adc_value.ADC3_IN10_AX48_NACS_T3.value,
adc_value.ADC3_IN7_AX48_NACS_T4.value,
adc_value.ADC3_IN5_AX48_NACS_T5.value,
adc_value.ADC3_IN11_AX48_NACS_T6.value);
#endif //DEBUG_SHOW_AX48_NACS_TEMP_SENSOR_ADC_COUNT
}
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR
dbgIdx++;
break;
case 8:
if (Charger.CCID_Module_Type == CCID_MODULE_CORMEX)
{
DEBUG_INFO("Original GF[0]: %fmA\r\n", adc_value.ADC2_IN6_GF.value/100.0);
DEBUG_INFO("Charger.Leak_Current: %fmA\r\n", Charger.Leak_Current/100.0);
}
else
{
//DEBUG_INFO("Temperature ADC raw data : %d\r\n", adc_value.ADC3_IN15_Temp.value);
//DEBUG_INFO("Temperature : %d\r\n", Charger.temperature.SystemAmbientTemp);
DEBUG_INFO("ADC3_Buffer[1] (ADC): %d(unit:ADC)\r\n", ADC3_Buffer[1] );
DEBUG_INFO("Charger.Led_Mode: %d\r\n", Charger.Led_Mode );
}
dbgIdx++;
break;
case 9:
DEBUG_INFO("CP+(ADC): %d(unit:ADC)\r\n",CpDetectionResult.PositiveValue );
DEBUG_INFO("CP-(ADC): %d(unit:ADC)\r\n",CpDetectionResult.NegativeValue );
//if(CpDetectionResult.PositiveValue>0)
{
#ifdef FUNC_CP_ADC_MODIFY
//DEBUG_INFO("CP +voltage: %f\r\n", CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.PositiveValue));
DEBUG_INFO("CP +voltage: %f\r\n", (CpDetectionResult.PositiveValue == 0 ? 0 : HTK_GetPosFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.PositiveValue))));
#else
//DEBUG_INFO("CP +voltage: %f\r\n", (float)((1.59131-((3.3*CpDetectionResult.PositiveValue)/4095))*(475/53.6)));
#endif
}
// else
// {
// DEBUG_INFO("CP +voltage: 0\r\n");
// }
//if(CpDetectionResult.NegativeValue>0)
{
#ifdef FUNC_CP_ADC_MODIFY
//DEBUG_INFO("CP -voltage: %f\r\n", CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.NegativeValue));
DEBUG_INFO("CP -voltage: %f\r\n", (CpDetectionResult.NegativeValue == 0 ? 0 : HTK_GetNegFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.NegativeValue))));
#else
//DEBUG_INFO("CP -voltage: %f\r\n", (float)((1.59131-((3.3*CpDetectionResult.NegativeValue)/4095))*(475/53.6)));
#endif
}
// else
// {
// DEBUG_INFO("CP -voltage: 0\r\n");
// }
#ifdef FUNC_DISP_CURRENT_CP_PWM
DEBUG_INFO("CP state: %d (%.1f%)\r\n", Charger.CP_State, Charger.m_CP_CurPWM / 10.0f);
#else
DEBUG_INFO("CP state: %d\r\n", Charger.CP_State);
#endif
#ifdef FUNC_DETECT_PP
if (Charger.m_bDetectPP)
{
DEBUG_INFO("#PP(ADC): %d\r\n", adc_value.ADC3_IN6_Gun_Detec.value);
DEBUG_INFO("#PP(CURR): %d\r\n", Charger.m_PPInfo.m_CurCurr);
}
#endif
#ifdef FUNC_DETECT_PP_NACS
if (Charger.m_bDetectPP_NACS)
{
DEBUG_INFO("#PP_NACS(ADC): %d\r\n", adc_value.ADC3_IN6_Gun_Detec.value);
//DEBUG_INFO("#PP(CURR): %d\r\n", Charger.m_PPInfo.m_CurCurr);
}
#endif
#ifdef FUNC_OUTP_TYPE_E
if (Charger.m_bEnableTypeE)
{
DEBUG_INFO("#TypeE: isOnSocketE(%d), IsTypeEPlugIn(%d)\r\n", Charger.isOnSocketE, IsTypeEPlugIn());
}
#endif
#ifdef FUNC_GUN_LOCK
if (Charger.m_bUseGunLock)
{
#ifdef FUNC_GUN_LOCK_TRIG_MODE
DEBUG_INFO("#GunLock Status: %s ,TrigMode(%d)\r\n", GL_IsLock() ? "Locked" : "Unlocked", (int)Charger.m_GunLockTrigMode);
#else
DEBUG_INFO("#GunLock Status: %s\r\n", GL_IsLock() ? "Locked" : "Unlocked");
#endif
}
#endif
#ifdef FUNC_USE_RELAY_B_CONTACT
if (Charger.m_bUseRelayBContact)
{
DEBUG_INFO("#Relay b Contact Status: %s\r\n", IsRelayContact_Closed() ? "Closed" : "Opened");
}
#endif
dbgIdx++;
break;
case 10:
DEBUG_INFO("Power_Consumption_Cumulative: %llu (0.0001 kWh)\r\n", Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total);
DEBUG_INFO("#Current rating value: %d A\r\n", Charger.maxRatingCurrent);
if (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=20)
{
DEBUG_INFO("OCP tigger : %d\r\n", (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification)-100 );
}
else
{
DEBUG_INFO("OCP tigger : %d\r\n", (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+1)*100 );
}
DEBUG_INFO("#Charger.am3352.isRequestOn: %d\r\n", Charger.am3352.isRequestOn);
#ifdef FUNC_OCP_WITH_PP
#ifdef MODIFY_OCP_PROC_WITH_MODELNAME_IDX_3_EURO_SPEC
DEBUG_INFO("#OCPInfo(%d, %d, %d, %d) [%s]\r\n",
Charger.m_OCP_CurMaxCurr, Charger.OCP_Magnification,
Charger.m_OCP_BegThreshold, Charger.m_OCP_EndThreshold,
Charger.m_bModelNameWithEuroSpecOCP ? "EuroSpec" : "NotEuroSpec");
#else
DEBUG_INFO("#OCPInfo(%d, %d, %d, %d)\r\n",
Charger.m_OCP_CurMaxCurr, Charger.OCP_Magnification,
Charger.m_OCP_BegThreshold, Charger.m_OCP_EndThreshold);
#endif //MODIFY_OCP_PROC_WITH_MODELNAME_IDX_3_EURO_SPEC
#endif //FUNC_OCP_WITH_PP
#ifdef FUNC_GET_TRIP_TIME
if (Charger.m_TripBeg != 0 && Charger.m_TripBeg < Charger.m_TripEnd)
{
DEBUG_INFO("Trip period: %d\r\n", Charger.m_TripEnd - Charger.m_TripBeg);
}
#endif
#ifdef RECODE_METER_PRO380
if (Charger.m_bUseExtMeter_PRO380 && Charger.m_pPRO380)
{
#ifndef DISABLE_PRINT_DEBUG_MSG
const PPRO380 p = Charger.m_pPRO380;
#endif
DEBUG_INFO("PRO380(%s, %d, %d) E(%.2f %.2f, %.2f %.2f %.2f)\r\n",
p->m_bCommTimeout ? "[NG]" : "OK",
p->m_UpdateOkTimes,
p->m_UpdateNgTimes,
p->m_T1_Total_active_energy.m_Val,
p->m_T2_Total_active_energy.m_Val,
p->m_L1_Total_active_energy.m_Val,
p->m_L2_Total_active_energy.m_Val,
p->m_L3_Total_active_energy.m_Val);
}
#endif
#ifdef FUNC_PTB_METER_WM3M4C
if (Charger.m_bUseExtMeter_WM3M4C && Charger.m_pWM3M4C)
{
#ifndef DISABLE_PRINT_DEBUG_MSG
const PWM3M4C p = Charger.m_pWM3M4C;
#endif
DEBUG_INFO("WM3M4C(%s, %d, %d) I(%s V%.2f%s) E(%d, %d, %d) M(%d) S(%d) T(%s)\r\n",
p->m_bCommTimeout ? "[NG]" : "OK",
p->m_UpdateOkTimes,
p->m_UpdateNgTimes,
p->m_SerialNumber.m_Str,
(float)p->m_SW_Ver.m_Val * 0.01,
p->m_HW_Ver.m_Str,
p->m_EngCountExp1.m_Val,
p->m_EngCount1.m_Val,
p->m_EngCount1x1000.m_Val,
p->m_MeasurementStatus.m_Val,
p->m_SignatureStatus.m_Val,
p->m_GetDateTime.m_Str);
}
#endif
#ifdef FUNC_TASK_MONITOR
{
#ifndef DISABLE_PRINT_DEBUG_MSG
const PTaskADCInfo p = &Charger.m_TaskMonitor.m_ADC;
#endif
DEBUG_INFO("#TaskMonitor: ADC[%d/%d](%d, %d, %d) ADC->SR(0x%04X, 0x%04X, 0x%04X)\r\n",
p->m_ContinueResetCounter, p->m_TotalResetCounter,
p->m_ADC1_Counter[0],
p->m_ADC2_Counter[0],
p->m_ADC3_Counter[0], ADC1->SR, ADC2->SR, ADC3->SR);
}
#endif //FUNC_TASK_MONITOR
#ifdef MODIFY_GOT_CSU_DUTY_CMD_PROCESS
DEBUG_INFO("CCSInfo(%d, %d, %d)\r\n", Charger.m_bRunCCS, Charger.m_bGotCsuCpDutyCmd, Charger.m_bPassGotCsuCpDutyCmd);
#endif
#ifdef FUNC_SYSTEM_KEEP_INFO
SystemKeepInfo_Display(&g_SystemKeepInfo);
#endif
dbgIdx++;
break;
case 11:
if (Charger.Alarm_Code & ALARM_L1_OVER_VOLTAGE)
DEBUG_INFO("#ALARM_L1_OVER_VOLTAGE \n\r");
if (Charger.Alarm_Code & ALARM_L1_UNDER_VOLTAGE)
DEBUG_INFO("#ALARM_L1_UNDER_VOLTAGE \n\r");
if (Charger.Alarm_Code & ALARM_L1_OVER_CURRENT)
DEBUG_INFO("#ALARM_L1_OVER_CURRENT \n\r");
if (Charger.Alarm_Code & ALARM_L2_OVER_VOLTAGE)
DEBUG_INFO("#ALARM_L2_OVER_VOLTAGE \n\r");
if (Charger.Alarm_Code & ALARM_L2_UNDER_VOLTAGE)
DEBUG_INFO("#ALARM_L2_UNDER_VOLTAGE \n\r");
if (Charger.Alarm_Code & ALARM_L2_OVER_CURRENT)
DEBUG_INFO("#ALARM_L2_OVER_CURRENT \n\r");
if (Charger.Alarm_Code & ALARM_L3_OVER_VOLTAGE)
DEBUG_INFO("#ALARM_L3_OVER_VOLTAGE \n\r");
if (Charger.Alarm_Code & ALARM_L3_UNDER_VOLTAGE)
DEBUG_INFO("#ALARM_L3_UNDER_VOLTAGE \n\r");
if (Charger.Alarm_Code & ALARM_L3_OVER_CURRENT)
DEBUG_INFO("#ALARM_L3_OVER_CURRENT \n\r");
dbgIdx++;
break;
case 12:
if (Charger.Alarm_Code & ALARM_OVER_TEMPERATURE)
DEBUG_INFO("#ALARM_OVER_TEMPERATURE \n\r");
if (Charger.Alarm_Code & ALARM_GROUND_FAIL)
DEBUG_INFO("#ALARM_GROUND_FAIL \n\r");
if (Charger.Alarm_Code & ALARM_CP_ERROR)
DEBUG_INFO("#ALARM_CP_ERROR \n\r");
if (Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC)
DEBUG_INFO("#ALARM_CURRENT_LEAK_AC \n\r");
if (Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC)
DEBUG_INFO("#ALARM_CURRENT_LEAK_DC \n\r");
if (Charger.Alarm_Code & ALARM_MCU_TESTFAIL)
DEBUG_INFO("#ALARM_MCU_TESTFAIL \n\r");
if (Charger.Alarm_Code & ALARM_HANDSHAKE_TIMEOUT)
DEBUG_INFO("#ALARM_HANDSHAKE_TIMEOUT \n\r");
if (Charger.Alarm_Code & ALARM_EMERGENCY_STOP)
DEBUG_INFO("#ALARM_EMERGENCY_STOP \n\r");
dbgIdx++;
break;
case 13:
if (Charger.Alarm_Code & ALARM_RELAY_STATUS)
DEBUG_INFO("#ALARM_RELAY_STATUS \n\r");
if (Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL)
DEBUG_INFO("#ALARM_LEAK_MODULE_FAIL \n\r");
if (Charger.Alarm_Code & ALARM_SHUTTER_FAULT)
DEBUG_INFO("#ALARM_SHUTTER_FAULT \n\r");
if (Charger.Alarm_Code & ALARM_LOCKER_FAULT)
DEBUG_INFO("#ALARM_LOCKER_FAULT \n\r");
if (Charger.Alarm_Code & ALARM_POWER_DROP)
DEBUG_INFO("#ALARM_POWER_DROP \n\r");
if (Charger.Alarm_Code & ALARM_L1_CIRCUIT_SHORT)
DEBUG_INFO("#ALARM_L1_CIRCUIT_SHORT \n\r");
if (Charger.Alarm_Code & ALARM_L2_CIRCUIT_SHORT)
DEBUG_INFO("#ALARM_L2_CIRCUIT_SHORT \n\r");
if (Charger.Alarm_Code & ALARM_L3_CIRCUIT_SHORT)
DEBUG_INFO("#ALARM_L3_CIRCUIT_SHORT \n\r");
if (Charger.Alarm_Code & ALARM_ROTATORY_SWITCH_FAULT)
DEBUG_INFO("#ALARM_ROTATORY_SWITCH_FAULT \n\r");
if (Charger.Alarm_Code & ALARM_RELAY_DRIVE_FUALT)
DEBUG_INFO("#ALARM_RELAY_DRIVE_FUALT \n\r");
if (Charger.Alarm_Code & ALARM_METER_TIMEOUT)
DEBUG_INFO("#ALARM_METER_TIMEOUT \n\r");
#ifdef FUNC_METER_IC_COMM_ALARM
if (Charger.Alarm_Code & ALARM_METER_IC_TIMEOUT)
DEBUG_INFO("#ALARM_METER_IC_TIMEOUT \n\r");
#endif
#ifdef FUNC_ALARM_CP_NEG_ERROR
if (Charger.Alarm_Code & ALARM_CP_NEG_ERROR)
DEBUG_INFO("#ALARM_CP_NEG_ERROR \n\r");
#endif
#ifdef FUNC_AX80_ADD_TILT_SENSOR
if (Charger.Alarm_Code & ALARM_TILT_SENSOR)
DEBUG_INFO("#ALARM_TILT_SENSOR \n\r");
#endif
#ifdef FUNC_WARNING_CODE
//------------------------------------------------------------
#ifdef FUNC_EKM_OMNIMETER
if (Charger.Warning_Code & WARN_OMNIMETER_COMM_TIMEOUT)
DEBUG_INFO("#WARN_OMNIMETER_COMM_TIMEOUT \n\r");
#endif
//------------------------------------------------------------
#endif //FUNC_WARNING_CODE
// XP("sizeof(Charger.memory.EVSE_Config.data.value) = %d\r\n", sizeof(Charger.memory.EVSE_Config.data.value));
// XP("sizeof(Charger.memory.EVSE_Config.data.item) = %d\r\n", sizeof(Charger.memory.EVSE_Config.data.item));
#ifdef FUNC_METER_IC_HISTORY_DEBUG
XP("sizeof(Charger.memory.hisMeterIC) = %d\r\n", sizeof(Charger.memory.hisMeterIC));
XP("sizeof(Charger.memory.hisMeterIC.data) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data));
XP("sizeof(Charger.memory.hisMeterIC.data.value) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data.value));
XP("sizeof(Charger.memory.hisMeterIC.data.item) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data.item));
XP("sizeof(Charger.memory.hisMeterIC.data.item[0]) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data.item[0]));
XP("sizeof(Charger.memory.hisMeterIC.data.item[0].DateTime) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data.item[0].DateTime));
XP("sizeof(Charger.memory.hisMeterIC.data.item[0].m_CaliValType) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data.item[0].m_CaliValType));
XP("sizeof(Charger.memory.hisMeterIC.data.item[0].m_CaliVal) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data.item[0].m_CaliVal));
XP("sizeof(Charger.memory.hisMeterIC.data.item[0].m_Reserved) = %d\r\n", sizeof(Charger.memory.hisMeterIC.data.item[0].m_Reserved));
XP("sizeof(Charger.memory.hisMeterIC.op_bits) = %d\r\n", sizeof(Charger.memory.hisMeterIC.op_bits));
#endif //FUNC_METER_IC_HISTORY_DEBUG
dbgIdx++;
break;
default:
getlastRecord();
dbgIdx = 0;
break;
}
timerRefresh(TIMER_IDX_RTOS_STAT);
}
HAL_IWDG_Refresh(&hiwdg);
#ifdef FUNC_RS485_SLAVE
if(UART_IAP_recv_end_flag == 1 || UART_RS485_recv_end_flag == 1)
#else
if(UART_IAP_recv_end_flag == 1)
#endif
{
#ifdef FUNC_UART_IAP_TX_BUF_INIT_ZERO
uint8_t tx[UART_BUFFER_SIZE] = { 0 };
#else
uint8_t tx[UART_BUFFER_SIZE];
#endif
#ifdef MODIFY_UART_TX_LEN_FROM_U8_TO_U16
uint16_t tx_len;
#else
uint8_t tx_len;
#endif
uint8_t chksum = 0;
uint8_t tmpBuf = 0 ;
// Protocol process
#ifdef FUNC_RS485_SLAVE
uint8_t *CurRxBuf = NULL;
uint16_t *pCurRxBuf_RxLen = NULL;
uint8_t *pCurRecvEndFlag = NULL;
UART_HandleTypeDef *pUartHandle = NULL;
if (UART_IAP_recv_end_flag == 1 && isValidCheckSum_IAP(UART_IAP_rx_buffer) == ON)
{
CurRxBuf = UART_IAP_rx_buffer;
pCurRxBuf_RxLen = &UART_IAP_rx_len;
pCurRecvEndFlag = &UART_IAP_recv_end_flag;
pUartHandle = &IAP_USART;
#ifdef FUNC_RELAY_OFF_WHEN_CSU_CMD_TIMEOUT
Charger.m_CSU_RxTick = HAL_GetTick();
#endif
}
else if (UART_RS485_recv_end_flag == 1 && isValidCheckSum_IAP(UART_RS485_rx_buffer) == ON)
{
CurRxBuf = UART_RS485_rx_buffer;
pCurRxBuf_RxLen = &UART_RS485_rx_len;
pCurRecvEndFlag = &UART_RS485_recv_end_flag;
pUartHandle = &RS485_USART;
#ifdef FUNC_RELAY_OFF_WHEN_CSU_CMD_TIMEOUT //DC Model
Charger.m_CSU_RxTick = HAL_GetTick();
#endif
}
if (CurRxBuf != NULL)
#else
uint8_t *CurRxBuf = UART_IAP_rx_buffer;
if(isValidCheckSum_IAP() == ON)
#endif
{
Charger.CSUisReady = ON ;
#ifdef ENABLE_PRINT_IMCP_MSG
#ifdef FUNC_RS485_SLAVE
#ifdef PRINT_IMCP_MSG_ONLY_ON_UPDATEPORT
if (CurRxBuf == UART_IAP_rx_buffer && CheckPrintImcpMsg(CurRxBuf[IMCP_FM_MSGID_IDX]))
{
XP("-------------------------------------------\r\n");
HTK_ByteArray2HexStr_XP(NULL, CurRxBuf, 0, IMCP_FM_HEAD_LEN + HTK_U16(CurRxBuf[IMCP_FM_DATALEN_LSB_IDX]) + IMCP_FM_TAIL_LEN);
}
#else
if (CheckPrintImcpMsg(CurRxBuf[IMCP_FM_MSGID_IDX]))
{
XP("-------------------------------------------\r\n");
HTK_ByteArray2HexStr_XP(NULL, CurRxBuf, 0, IMCP_FM_HEAD_LEN + HTK_U16(CurRxBuf[IMCP_FM_DATALEN_LSB_IDX]) + IMCP_FM_TAIL_LEN);
}
#endif //PRINT_IMCP_MSG_ONLY_ON_UPDATEPORT
#else //FUNC_RS485_SLAVE
if (CheckPrintImcpMsg(UART_IAP_rx_buffer[IMCP_FM_MSGID_IDX]))
{
XP("-------------------------------------------\r\n");
HTK_ByteArray2HexStr_XP(NULL, UART_IAP_rx_buffer, 0, IMCP_FM_HEAD_LEN + HTK_U16(UART_IAP_rx_buffer[IMCP_FM_DATALEN_LSB_IDX]) + IMCP_FM_TAIL_LEN);
}
#endif //FUNC_RS485_SLAVE
#endif //ENABLE_PRINT_IMCP_MSG
#ifdef FUNC_RS485_SLAVE
switch (CurRxBuf[3])
#else
switch (UART_IAP_rx_buffer[3])
#endif
{
/*
Query message
*/
case PROTOCOL_MESSAGE_QUERY_FW_VER:
tx_len = 7 + (strlen(Charger.Ver_FW));
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_FW_VER;
tx[4] = strlen(Charger.Ver_FW)&0xff;
tx[5] = (strlen(Charger.Ver_FW)>>0x08) & 0xff;
for(uint8_t idx=0;idx>0x08) & 0xff;
for(uint8_t idx=0;idx>0) & 0xff);
tx[8] = (((Charger.Voltage[0]/10)>>8) & 0xff);
tx[9] = (((Charger.Voltage[1]/10)>>0) & 0xff);
tx[10] = (((Charger.Voltage[1]/10)>>8) & 0xff);
tx[11] = (((Charger.Voltage[2]/10)>>0) & 0xff);
tx[12] = (((Charger.Voltage[2]/10)>>8) & 0xff);
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[13] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_PRESENT_OUTPUT_VOLTAGE:
tx_len = 15;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_PRESENT_OUTPUT_VOLTAGE;
tx[4] = 0x08;
tx[5] = 0x00;
tx[6] = 0x00;
tx[7] = 0x00;
tx[8] = 0x00;
tx[9] = 0x00;
tx[10] = 0x00;
tx[11] = 0x00;
tx[12] = 0x00;
tx[13] = 0x00;
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[14] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_FAN_SPEED:
tx_len = 15;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_FAN_SPEED;
tx[4] = 0x08;
tx[5] = 0x00;
tx[6] = 0x00;
tx[7] = 0x00;
tx[8] = 0x00;
tx[9] = 0x00;
tx[10] = 0x00;
tx[11] = 0x00;
tx[12] = 0x00;
tx[13] = 0x00;
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[14] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_TEMPERATURE:
tx_len = 15;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_TEMPERATURE;
tx[4] = 0x08;
tx[5] = 0x00;
tx[6] = (((Charger.temperature.SystemAmbientTemp+60)>>0) & 0xff);
tx[7] = (((Charger.temperature.CcsConnectorTemp+60)>>0) & 0xff);
#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
if (Charger.m_bModelNameAX80_1P)
{
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
if (Charger.m_bModelNameAX80_NACS_1P)
{
tx[8] = (((Charger.temperature.AX80_NACS_T1_L1_IN+60)>>0) & 0xff);
tx[9] = (((Charger.temperature.AX80_NACS_T2_L2_IN+60)>>0) & 0xff);
tx[10] = (((Charger.temperature.AX80_NACS_T3_L1_OUT+60)>>0) & 0xff);
tx[11] = (((Charger.temperature.AX80_NACS_T4_L2_OUT+60)>>0) & 0xff);
tx[12] = (((Charger.temperature.AX80_NACS_T5_L1_GUN+60)>>0) & 0xff);
tx[13] = (((Charger.temperature.AX80_NACS_T6_L2_GUN+60)>>0) & 0xff);
}
else
{
tx[8] = (((Charger.temperature.AX80_Relay1Temp+60)>>0) & 0xff);
tx[9] = (((Charger.temperature.AX80_Relay2Temp+60)>>0) & 0xff);
tx[10] = (((Charger.temperature.AX80_Input_L1_Temp+60)>>0) & 0xff);
tx[11] = (((Charger.temperature.AX80_Input_N_L2_Temp+60)>>0) & 0xff);
tx[12] = 0x00;
tx[13] = 0x00;
}
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
tx[8] = (((Charger.temperature.AX80_Relay1Temp+60)>>0) & 0xff);
tx[9] = (((Charger.temperature.AX80_Relay2Temp+60)>>0) & 0xff);
tx[10] = (((Charger.temperature.AX80_Input_L1_Temp+60)>>0) & 0xff);
tx[11] = (((Charger.temperature.AX80_Input_N_L2_Temp+60)>>0) & 0xff);
tx[12] = 0x00;
tx[13] = 0x00;
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
}
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
else if (Charger.m_bModelNameAW48_1P)
{
tx[8] = (((Charger.temperature.AW48_T1_L1_IN+60)>>0) & 0xff);
tx[9] = (((Charger.temperature.AW48_T2_L2_IN+60)>>0) & 0xff);
tx[10] = (((Charger.temperature.AW48_T3_L1_OUT+60)>>0) & 0xff);
tx[11] = (((Charger.temperature.AW48_T4_L2_OUT+60)>>0) & 0xff);
tx[12] = (((Charger.temperature.AW48_T5_L1_GUN+60)>>0) & 0xff);
tx[13] = (((Charger.temperature.AW48_T6_L2_GUN+60)>>0) & 0xff);
}
#endif //FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
else if (Charger.m_bModelNameAX48_NACS_1P)
{
tx[8] = (((Charger.temperature.AX48_NACS_T1_L1_IN+60)>>0) & 0xff);
tx[9] = (((Charger.temperature.AX48_NACS_T2_L2_IN+60)>>0) & 0xff);
tx[10] = (((Charger.temperature.AX48_NACS_T3_L1_OUT+60)>>0) & 0xff);
tx[11] = (((Charger.temperature.AX48_NACS_T4_L2_OUT+60)>>0) & 0xff);
tx[12] = (((Charger.temperature.AX48_NACS_T5_L1_GUN+60)>>0) & 0xff);
tx[13] = (((Charger.temperature.AX48_NACS_T6_L2_GUN+60)>>0) & 0xff);
}
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
else
{
tx[8] = 0x00;
tx[9] = 0x00;
tx[10] = 0x00;
tx[11] = 0x00;
tx[12] = 0x00;
tx[13] = 0x00;
}
#else //FUNC_AX80_ADD_4_TEMP_SENEOR
tx[8] = 0x00;
tx[9] = 0x00;
tx[10] = 0x00;
tx[11] = 0x00;
tx[12] = 0x00;
tx[13] = 0x00;
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[14] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_AUX_POWER_VOLTAGE:
tx_len = 15;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_AUX_POWER_VOLTAGE;
tx[4] = 0x08;
tx[5] = 0x00;
tx[6] = 0x00;
tx[7] = 0x00;
tx[8] = 0x00;
tx[9] = 0x00;
tx[10] = 0x00;
tx[11] = 0x00;
tx[12] = 0x00;
tx[13] = 0x00;
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[14] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_RELAY_OUTPUT_STATUS:
tx_len = 9;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_RELAY_OUTPUT_STATUS;
tx[4] = 0x02;
tx[5] = 0x00;
tx[6] = ((Relay1_Action_Get()==GPIO_RELAY1_ACTION_OFF)?0:1);
tx[7] = ((Relay2_Action_Get()==GPIO_RELAY2_ACTION_OFF)?0:1);
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[8] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_GFD_ADC_VALUE:
tx_len = 15;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_GFD_ADC_VALUE;
tx[4] = 0x08;
tx[5] = 0x00;
tx[6] = ((adc_value.ADC2_IN6_GF.value>>0) & 0xff);
tx[7] = ((adc_value.ADC2_IN6_GF.value>>8) & 0xff);
tx[8] = 0x00;
tx[9] = 0x00;
tx[10] = 0x00;
tx[11] = 0x00;
tx[12] = 0x00;
tx[13] = 0x00;
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[14] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_INPUT_GPIO_STATUS:
tx_len = 9;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_INPUT_GPIO_STATUS;
tx[4] = 0x02;
tx[5] = 0x00;
tx[6] = 0x00;
tx[7] = 0x00 | ((HAL_GPIO_ReadPin(IN_BTN_ModeSw_GPIO_Port, IN_BTN_ModeSw_Pin)?0:1) << 7);
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[8] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_ALARM_LOG:
tx_len = 17;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_ALARM_LOG;
tx[4] = 0x0a;
tx[5] = 0x00;
tx[6] = CurRxBuf[7] ;
tx[7] = CurRxBuf[8] ;
tx[8] = CharacterArray[(Charger.memory.hisAlarm.data.item[CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0xF0000000)>>28];
tx[9] = CharacterArray[(Charger.memory.hisAlarm.data.item[CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0x0F000000)>>24];
tx[10] = CharacterArray[(Charger.memory.hisAlarm.data.item[CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0x00F00000)>>20];
tx[11] = CharacterArray[(Charger.memory.hisAlarm.data.item[CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0x000F0000)>>16];
tx[12] = CharacterArray[(Charger.memory.hisAlarm.data.item[CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0x0000F000)>>12];
tx[13] = CharacterArray[(Charger.memory.hisAlarm.data.item[CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0x00000F00)>>8];
tx[14] = CharacterArray[(Charger.memory.hisAlarm.data.item [CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0x000000F0)>>4];
tx[15] = CharacterArray[ Charger.memory.hisAlarm.data.item [CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode & 0x0000000F ];
#ifdef FUNC_TRACE_MEM_HIS_ALARM
XP("ALARM_LOG[%d] = 0x%08X (%c%c%c%c%c%c%c%c)\r\n", CurRxBuf[7] | (CurRxBuf[8]>>8), Charger.memory.hisAlarm.data.item[CurRxBuf[7] | (CurRxBuf[8]>>8)].alarmCode,
tx[8], tx[9], tx[10], tx[11], tx[12], tx[13], tx[14], tx[15]);
XP("sizeof(Charger.memory.hisAlarm.data.item[0]) = %d\r\n", sizeof(Charger.memory.hisAlarm.data.item[0]));
#endif
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[16] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_SN:
// head +checksum = 7 , SystemDateTimeyear month day = 8 , SerialNumber
tx_len = 15 + strlen(Charger.memory.EVSE_Config.data.item.SerialNumber);
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_SN;
tx[4] = (strlen(Charger.memory.EVSE_Config.data.item.SerialNumber)+8)&0xff;
tx[5] = ((strlen(Charger.memory.EVSE_Config.data.item.SerialNumber)+8)>>0x08) & 0xff;
tx[6] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.year/1000)+'0';
tx[7] = ((Charger.memory.EVSE_Config.data.item.SystemDateTime.year%1000)/100)+'0';
tx[8] = ((Charger.memory.EVSE_Config.data.item.SystemDateTime.year%100)/10)+'0';
tx[9] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.year%10) +'0';
tx[10] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.month/10) +'0';
tx[11] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.month%10) +'0';
tx[12] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.day/10) +'0';
tx[13] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.day%10) +'0';
for(uint8_t idx=0;idx>0x08) & 0xff;
for(uint8_t idx=0;idx>8) & 0xff;
break;
case INPUT_L2_AC_VOLTAGE:
tx[8] = Charger.memory.EVSE_Config.data.item.Correction_VL2[CurRxBuf[7]][1] & 0xff;
tx[9] = (Charger.memory.EVSE_Config.data.item.Correction_VL2[CurRxBuf[7]][1]>>8) & 0xff;
break;
case INPUT_L3_AC_VOLTAGE:
tx[8] = Charger.memory.EVSE_Config.data.item.Correction_VL3[CurRxBuf[7]][1] & 0xff;
tx[9] = (Charger.memory.EVSE_Config.data.item.Correction_VL3[CurRxBuf[7]][1]>>8) & 0xff;
break;
case OUTPUT_L1_CURRENT:
tx[8] = Charger.memory.EVSE_Config.data.item.Correction_CL1[CurRxBuf[7]][1] & 0xff;
tx[9] = (Charger.memory.EVSE_Config.data.item.Correction_CL1[CurRxBuf[7]][1]>>8) & 0xff;
break;
case OUTPUT_L2_CURRENT:
tx[8] = Charger.memory.EVSE_Config.data.item.Correction_CL2[CurRxBuf[7]][1] & 0xff;
tx[9] = (Charger.memory.EVSE_Config.data.item.Correction_CL2[CurRxBuf[7]][1]>>8) & 0xff;
break;
case OUTPUT_L3_CURRENT:
tx[8] = Charger.memory.EVSE_Config.data.item.Correction_CL3[CurRxBuf[7]][1] & 0xff;
tx[9] = (Charger.memory.EVSE_Config.data.item.Correction_CL3[CurRxBuf[7]][1]>>8) & 0xff;
break;
case LEAK_CURRENT:
tx[8] = (Charger.memory.EVSE_Config.data.item.Correction_Leak[CurRxBuf[7]][1]/100) & 0xff;
tx[9] = ((Charger.memory.EVSE_Config.data.item.Correction_Leak[CurRxBuf[7]][1]/100)>>8) & 0xff;
break;
}
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[10] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_RTC:
tx_len = 21;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_RTC;
tx[4] = 0x0e;
tx[5] = 0x00;
tx[6] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.year/1000)+'0';
tx[7] = ((Charger.memory.EVSE_Config.data.item.SystemDateTime.year%1000)/100)+'0';
tx[8] = ((Charger.memory.EVSE_Config.data.item.SystemDateTime.year%100)/10)+'0';
tx[9] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.year%10) +'0';
tx[10] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.month/10) +'0';
tx[11] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.month%10) +'0';
tx[12] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.day/10) +'0';
tx[13] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.day%10) +'0';
tx[14] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.hour/10) +'0';
tx[15] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.hour%10) +'0';
tx[16] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.min/10) +'0';
tx[17] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.min%10) +'0';
tx[18] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.sec/10) +'0';
tx[19] = (Charger.memory.EVSE_Config.data.item.SystemDateTime.sec%10) +'0';
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[20] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_PRESENT_OUTPUT_CURRENT:
tx_len = 19;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_PRESENT_OUTPUT_CURRENT;
tx[4] = 0x0c;
tx[5] = 0x00;
tx[6] = (((Charger.Current[0]/10)>>0) & 0xff);
tx[7] = (((Charger.Current[0]/10)>>8) & 0xff);
tx[8] = (((Charger.Current[1]/10)>>0) & 0xff);
tx[9] = (((Charger.Current[1]/10)>>8) & 0xff);
tx[10] = (((Charger.Current[2]/10)>>0) & 0xff);
tx[11] = (((Charger.Current[2]/10)>>8) & 0xff);
tx[12] = 0x00;
tx[13] = 0x00;
tx[14] = 0x00;
tx[15] = 0x00;
tx[16] = 0x00;
tx[17] = 0x00;
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[18] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_EVSE_STATE:
tx_len = 22;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_EVSE_STATE;
tx[4] = 15;
tx[5] = 0x00;
tx[6] = Charger.CP_State;
#ifdef MODIFY_AC_EVSE_STATUS_MAX_CHARGING_CURRENT_VARIABLE
#ifdef FUNC_AW48
if (Charger.m_bModelNameAX || Charger.m_bModelNameAT || Charger.m_bModelNameAW48_1P)
#else //FUNC_AW48
#ifdef FUNC_AT32
if (Charger.m_bModelNameAX || Charger.m_bModelNameAT)
#else
if (Charger.m_bModelNameAX)
#endif
#endif //FUNC_AW48
{
//AX32/48
tx[7] = (Charger.AC_MaxChargingCurrentOrDuty&0xff);
tx[8] = Charger.AC_MaxChargingCurrentOrDuty>>8;
}
else
{
//DC Model
tx[7] = (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent&0xff);
tx[8] = Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>>8;
}
#else
tx[7] = (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent&0xff);
tx[8] = Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>>8;
#endif
uint16_t transfer_float;
{
#ifdef FUNC_CP_ADC_MODIFY
transfer_float = (uint16_t)(CpDetectionResult.PositiveValue == 0 ? 0 : HTK_GetPosFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.PositiveValue)) * 100);
#else
//transfer_float = (uint16_t)((float)(((1.59131-((3.3*CpDetectionResult.PositiveValue)/4095))*(475/53.6)))*100);
#endif
}
tx[9] = (transfer_float&0xff);
tx[10] = (transfer_float&0xff00)>>8;
{
#ifdef FUNC_CP_ADC_MODIFY
transfer_float = (uint16_t)(CpDetectionResult.NegativeValue == 0 ? 0 : HTK_GetNegFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.NegativeValue)) * 100);
#else
//transfer_float = (uint16_t)((float)(((((3.3*CpDetectionResult.NegativeValue)/4095)-1.59131)*(475/53.6)))*100);
#endif
}
tx[11] = (transfer_float&0xff);
tx[12] = (transfer_float&0xff00)>>8;
#ifdef FUNC_GUN_LOCK
if (Charger.m_bUseGunLock)
{
tx[13] = GL_IsLock() ? 0x01 : 0x00; //Locker status
}
else
{
tx[13] = 0x00;
}
#else
tx[13] = 0x00; //Locker status
#endif
{
uint8_t val = 0;
if (Charger.Relay_Action == GPIO_RELAY_ACTION_ON)
{
//val |= 0x07; //Use different bit
val |= 0x01; //Use same bit (Fit CSU code)
}
if (Charger.SE_Relay_Action == GPIO_SE_RELAY_ACTION_ON)
{
//val |= 0x08; //Use different bit
val |= 0x01; //Use same bit (Fit CSU code)
}
tx[14] = val;
}
tx[15] = 0x00; //Shutter status
tx[16] = 0x00; //Meter status
#ifdef FUNC_DETECT_PP
tx[17] = Charger.m_PPInfo.m_StatusID; //PP status
#else
tx[17] = 0x00; //PP status
#endif //FUNC_DETECT_PP
tx[18] = Charger.maxRatingCurrent;
#ifdef ROTATE_SWITCH_HARDCODE
tmpBuf = HC_ROTARY_SWITCH_SET_VAL;
tmpBuf += (HC_SWITCH_1_CONN_TYPE_VAL?0:1)<<4;
tmpBuf += (HC_SWITCH_2_GROUND_SYS?0:1)<<5;
#else
tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set1_GPIO_Port, IN_AC_Current_Set1_Pin)?0:1)<<0;
tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set2_GPIO_Port, IN_AC_Current_Set2_Pin)?0:1)<<1;
tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set3_GPIO_Port, IN_AC_Current_Set3_Pin)?0:1)<<2;
tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set4_GPIO_Port, IN_AC_Current_Set4_Pin)?0:1)<<3;
#ifdef MODIFY_AX32_RUN_3P_OR_1P_AUTOMATIC_AFTER_GC5
if ( Charger.m_bModelNameAX32_3P
#ifdef FUNC_AT32
|| Charger.m_bModelNameAT32_3P
#endif
)
{
tmpBuf += (Charger.m_b3PhaseModelButUse1PhaseOnly ? 1 : 0) << 4;
}
else
{
tmpBuf += (HAL_GPIO_ReadPin(IN_GridType_Select_GPIO_Port, IN_GridType_Select_Pin)?0:1)<<4;
}
#else //MODIFY_AX32_RUN_3P_OR_1P_AUTOMATIC_AFTER_GC5
tmpBuf += (HAL_GPIO_ReadPin(IN_GridType_Select_GPIO_Port, IN_GridType_Select_Pin)?0:1)<<4;
#endif //MODIFY_AX32_RUN_3P_OR_1P_AUTOMATIC_AFTER_GC5
tmpBuf += (HAL_GPIO_ReadPin(IN_Grid_Groundding_GPIO_Port, IN_Grid_Groundding_Pin)?0:1)<<5;
#endif //ROTATE_SWITCH_HARDCODE
tx[19] = tmpBuf;
#ifdef FUNC_OUTP_TYPE_E
tx[20] = Charger.isOnSocketE | ((IsTypeEPlugIn() ? 1 : 0) << 1);
#else
//tx[20] = Charger.isOnSocketE | ((HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin)?0:1)<<1);
#endif
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[21] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_EVSE_ALARM:
tx_len = 11;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_EVSE_ALARM;
tx[4] = 4;
tx[5] = 0x00;
#ifdef VO_SIMU_ALARMCODE
if (Charger.m_VOCode.m_EnableSimuAlarmCode)
{
HTK_U32(tx[6]) = Charger.m_SimuData.m_AlarmCode;
}
else
{
// tx[6] = (Charger.Alarm_Code&0xff);
// tx[7] = (Charger.Alarm_Code&0xff00)>>8;
// tx[8] = (Charger.Alarm_Code&0xff0000)>>16;
// tx[9] = (Charger.Alarm_Code&0xff000000)>>24;
HTK_U32(tx[6]) = Charger.Alarm_Code;
}
#else
// tx[6] = (Charger.Alarm_Code&0xff);
// tx[7] = (Charger.Alarm_Code&0xff00)>>8;
// tx[8] = (Charger.Alarm_Code&0xff0000)>>16;
// tx[9] = (Charger.Alarm_Code&0xff000000)>>24;
HTK_U32(tx[6]) = Charger.Alarm_Code;
#endif
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[10] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_BLE_STATE:
tx_len = 10;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_BLE_STATE;
tx[4] = 3;
tx[5] = 0x00;
tx[6] = 0x00 ;
tx[7] = 0x00 ;
tx[8] = 0x00 ;
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[9] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_BLE_LOGIC_CENTRAL_ID:
tx_len = 39;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_BLE_LOGIC_CENTRAL_ID;
tx[4] = 32;
tx[5] = 0x00;
tx[6] = 'P';
tx[7] = 'H';
tx[8] = 'I';
tx[9] = 'H';
tx[10] = 'O';
tx[11] = 'N';
tx[12] = 'G';
tx[13] = ' ';
tx[14] = 'A';
tx[15] = 'C';
tx[16] = '-';
tx[17] = 'S';
tx[18] = 'i';
tx[19] = 'm';
tx[20] = 'p';
tx[21] = 'l';
tx[22] = 'e';
tx[23] = ' ';
tx[24] = '1';
tx[25] = '2';
tx[26] = '3';
tx[27] = '4';
tx[28] = '5';
tx[29] = '6';
tx[30] = '7';
tx[31] = '8';
tx[32] = '9';
tx[33] = 'A';
tx[34] = 'B';
tx[35] = 'C';
tx[36] = 'D';
tx[37] = 'E';
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[38] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_POWER_CONSUME:
#ifdef MODIFY_PROTOCOL_MESSAGE_QUERY_POWER_CONSUME_64_BIT
tx_len = 39;
#else
tx_len = 23;
#endif
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_POWER_CONSUME;
#ifdef MODIFY_PROTOCOL_MESSAGE_QUERY_POWER_CONSUME_64_BIT
tx[4] = 32;
#else
tx[4] = 16;
#endif
tx[5] = 0x00;
#ifdef MODIFY_PROTOCOL_MESSAGE_QUERY_POWER_CONSUME_64_BIT
{
memcpy(&tx[6], &Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total, sizeof(uint64_t) * 4);
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[38] = chksum;
}
#else
HTK_U32(tx[6]) = (uint32_t)(HTK_ROUND_U64((double)Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total / 100));
HTK_U32(tx[10]) = (uint32_t)(HTK_ROUND_U64((double)Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 / 100));
HTK_U32(tx[14]) = (uint32_t)(HTK_ROUND_U64((double)Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 / 100));
HTK_U32(tx[18]) = (uint32_t)(HTK_ROUND_U64((double)Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3 / 100));
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[22] = chksum;
#endif //MODIFY_PROTOCOL_MESSAGE_QUERY_POWER_CONSUME_64_BIT
break;
case PROTOCOL_MESSAGE_QUERY_GUN_PLUGIN_TIMES:
tx_len = 11;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_GUN_PLUGIN_TIMES;
tx[4] = 4;
tx[5] = 0x00;
tx[6] = (Charger.memory.EVSE_Config.data.item.AcPlugInTimes&0xff);
tx[7] = (Charger.memory.EVSE_Config.data.item.AcPlugInTimes&0xff00)>>8;
tx[8] = (Charger.memory.EVSE_Config.data.item.AcPlugInTimes&0xff0000)>>16;
tx[9] = (Charger.memory.EVSE_Config.data.item.AcPlugInTimes&0xff000000)>>24;
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[10] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_EVSE_AUTH_MODE:
tx_len = 9;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_EVSE_AUTH_MODE;
tx[4] = 2;
tx[5] = 0x00;
tx[6] = Charger.memory.EVSE_Config.data.item.AuthMode;
tx[7] = Charger.memory.EVSE_Config.data.item.OfflinePolicy;
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[8] = chksum;
break;
case PROTOCOL_MESSAGE_QUERY_PRESENT_LEAK_CURRENT:
tx_len = 9;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_PRESENT_LEAK_CURRENT;
tx[4] = 2;
tx[5] = 0x00;
tx[6] = Charger.Leak_Current/100;
tx[7] = 0;
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[8] = chksum;
break;
#ifdef FUNC_METER_IC_ADE7858A
case PROTOCOL_MESSAGE_QUERY_METER_IC_MEAS_PARAMETER:
tx_len = 6 + sizeof(MeterIC_MeasVals) + 1;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_METER_IC_MEAS_PARAMETER;
memcpy(&tx[6], &Charger.m_MeterIC_MeasVals, sizeof(MeterIC_MeasVals));
UpdateCheckSum(tx, tx_len);
break;
case PROTOCOL_MESSAGE_QUERY_METER_IC_CALI_PARAMETER:
tx_len = 6 + (5) + 1;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_METER_IC_CALI_PARAMETER;
#ifdef FUNC_METER_IC_CALI_FLAG
if (CurRxBuf[6] == MICC_READ_METER_IC_CALI_FLAG)
{
tx[6] = CurRxBuf[6];
uint32_t tmp = Charger.memory.EVSE_Config.data.item.m_MeterIC_CaliFlag.m_Data;
tmp |= (Charger.m_bMeterIC_CaliValIsDefault << 31);
HTK_U32(tx[7]) = tmp;
}
else
#endif //FUNC_METER_IC_CALI_FLAG
#ifdef FUNC_QUERY_METER_IC_DIE_VERSION
if (CurRxBuf[6] == MICC_GET_DIE_VERSION)
{
tx[6] = CurRxBuf[6];
//#ifdef FUNC_FORCE_QUERY_METER_IC_DIE_VERSION_2
// HTK_U32(tx[7]) = 0x02;
//#else
HTK_U32(tx[7]) = Charger.m_MeterIcEx.m_DieVersion;
//#endif
}
else
#endif
#ifdef VO_GET_VO_CODE
if (CurRxBuf[6] == MICC_GET_VO_CODE)
{
tx[6] = CurRxBuf[6];
HTK_U32(tx[7]) = Charger.m_VOCode.m_Value;
}
else
#endif //VO_GET_VO_CODE
{
MeterIC_CaliValType type = (MeterIC_CaliValType)CurRxBuf[6];
int32_t *p = MeterIC_GetCaliValPtr(type, NULL);
if (p != NULL)
{
tx[6] = (uint8_t)type;
HTK_U32(tx[7]) = (uint32_t)*p; //7-10
}
else
{
tx[6] = (uint8_t)MICC_UNDEFINED;
HTK_U32(tx[7]) = HTK_U32_MAX;
}
}
UpdateCheckSum(tx, tx_len);
break;
#ifdef FUNC_METER_IC_HISTORY_IMCP_CMD
case PROTOCOL_MESSAGE_QUERY_METER_IC_CALI_HISTORY:
tx_len = 6 + (5) + 1;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_METER_IC_CALI_HISTORY;
{
uint8_t area = CurRxBuf[6];
uint16_t idx = HTK_U16(CurRxBuf[7]);
tx[6] = HTK_U16_BYTE(idx, 0);
tx[7] = HTK_U16_BYTE(idx, 1);
if (area > 1 || idx > 0xFF)
{
DT* pDT = &Charger.memory.hisMeterIC.data.item[idx].DateTime;
tx[8] = HTK_U16_BYTE(pDT->year, 0);
tx[9] = HTK_U16_BYTE(pDT->year, 1);
tx[10] = pDT->month;
tx[11] = pDT->day;
tx[12] = pDT->hour;
tx[13] = pDT->min;
tx[14] = pDT->sec;
tx[15] = (uint8_t)Charger.memory.hisMeterIC.data.item[idx].m_CaliValType;
HTK_U32(tx[16]) = Charger.memory.hisMeterIC.data.item[idx].m_CaliVal; //16~19
}
else
{
memset(&tx[8], 0xFF, 12);
}
}
UpdateCheckSum(tx, tx_len);
break;
#endif //FUNC_METER_IC_HISTORY_IMCP_CMD
#endif //FUNC_METER_IC_ADE7858A
#ifdef FUNC_PTB_METER_WM3M4C
case PROTOCOL_MESSAGE_QUERY_PTB_METER_WM3M4C:
{
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_PTB_METER_WM3M4C;
PWM3M4C p = Charger.m_pWM3M4C;
byte SubCmd = CurRxBuf[6];
#ifdef FUNC_CSU_CMD_DEBUG
char* s = "#CSU_WM3M4C_Get: ";
XP("%s0x%02X%s\r\n", s, SubCmd, (Charger.m_bUseExtMeter_WM3M4C && p ? "" : " (NOT SUPPORTED)"));
#endif
tx[6] = SubCmd;
if (Charger.m_bUseExtMeter_WM3M4C && p)
{
if (SubCmd == WM3M4C_GCMD_OUTP_OCMF_MSG_SIG_LEN)
{
tx_len = IMCP_TX_LEN(1 + 2);
HTK_U16(tx[7]) = p->m_OutpMsgSigLen;
}
else if (SubCmd == WM3M4C_GCMD_OUTP_OCMF_MSG_SIG)
{
tx_len = IMCP_TX_LEN(1 + p->m_OutpMsgSigLen);
memcpy(&tx[7], p->m_OutpMsgSig, p->m_OutpMsgSigLen);
}
else if (SubCmd == WM3M4C_GCMD_HEADER_PKEY_LEN)
{
tx_len = IMCP_TX_LEN(1 + 2);
HTK_U16(tx[7]) = p->m_HPKeyLen;
}
else if (SubCmd == WM3M4C_GCMD_HEADER_PKEY)
{
tx_len = IMCP_TX_LEN(1 + p->m_HPKeyLen);
memcpy(&tx[7], p->m_HPKey, p->m_HPKeyLen);
}
else if (SubCmd == WM3M4C_GCMD_OUTP_MSG_FMT_ID)
{
u8 n = strlen(p->m_OutpMsgFmtStr);
tx_len = IMCP_TX_LEN(1 + 1 + n);
tx[7] = p->m_OutpMsgFmtID;
memcpy(&tx[8], p->m_OutpMsgFmtStr, n) ;
}
else if (SubCmd == WM3M4C_GCMD_OUTP_MSG_LEN)
{
tx_len = IMCP_TX_LEN(1 + 2);
HTK_U16(tx[7]) = p->m_OutpMsgLen.m_Val;
}
else if (SubCmd == WM3M4C_GCMD_OUTP_MSG)
{
tx_len = IMCP_TX_LEN(1 + p->m_OutpMsgLen.m_Val);
memcpy(&tx[7], p->m_OutpMsg.m_Buf, p->m_OutpMsgLen.m_Val);
}
else if (SubCmd == WM3M4C_GCMD_OUTP_SIG_LEN)
{
tx_len = IMCP_TX_LEN(1 + 2);
HTK_U16(tx[7]) = p->m_OutpSigLen.m_Val * 2; //Byte to ASCII String
}
else if (SubCmd == WM3M4C_GCMD_OUTP_SIG)
{
tx_len = IMCP_TX_LEN(1 + p->m_OutpSigLen.m_Val * 2);
memcpy(&tx[7], p->m_OutpSig.m_Str, p->m_OutpSigLen.m_Val * 2);
}
else if (SubCmd == WM3M4C_GCMD_PKEYHEADER_LEN)
{
tx_len = IMCP_TX_LEN(1 + 2);
HTK_U16(tx[7]) = WM3M3C_PUBLIC_KEY_H_LEN * 2;
}
else if (SubCmd == WM3M4C_GCMD_PKEYHEADER)
{
tx_len = IMCP_TX_LEN(1 + WM3M3C_PUBLIC_KEY_H_LEN * 2);
memcpy(&tx[7], p->m_PublicKeyHStr, WM3M3C_PUBLIC_KEY_H_LEN * 2);
}
else if (SubCmd == WM3M4C_GCMD_PKEY_LEN)
{
tx_len = IMCP_TX_LEN(1 + 2);
HTK_U16(tx[7]) = p->m_PublicKeyStrLen;
}
else if (SubCmd == WM3M4C_GCMD_PKEY)
{
tx_len = IMCP_TX_LEN(1 + p->m_PublicKeyStrLen);
memcpy(&tx[7], p->m_PublicKey.m_Str, p->m_PublicKeyStrLen);
}
else
{
tx_len = IMCP_TX_LEN(1);
tx[6] = 0; //NG
}
}
else
{
tx_len = IMCP_TX_LEN(1);
tx[6] = 0; //NG
}
UpdateCheckSum(tx, tx_len);
}
break;
#endif //FUNC_PTB_METER_WM3M4C
#ifdef FUNC_EKM_OMNIMETER
case PROTOCOL_MESSAGE_QUERY_EKM_OMNIMETER:
{
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_EKM_OMNIMETER;
PEKM_Omnimeter p = Charger.m_pEKM_Omnimeter;
byte SubCmd = CurRxBuf[6];
//#ifdef FUNC_CSU_CMD_DEBUG
// char* s = "#CSU_EKM_Omnimeter_Get: ";
// XP("%s0x%02X%s\r\n", s, SubCmd, (Charger.m_bUseExtMeter_OMNIMETER && p ? "" : " (NOT SUPPORTED)"));
//#endif
tx[6] = SubCmd;
if (Charger.m_bUseExtMeter_OMNIMETER && p)
{
if (SubCmd == EKM_OMNIMETER_GCMD_POWER_CURRENT)
{
// tx_len = IMCP_TX_LEN(1 + (sizeof(u32) * 4)); //(u32) m_RMS_Watts_Ln_(1~3), m_RMS_Watts_Tot
// memcpy(&tx[7], &p->m_RMS_Watts_Ln_1, sizeof(u32) * 4);
tx_len = IMCP_TX_LEN(1 + (sizeof(u32) * 7)); //(u32) m_RMS_Watts_Ln_(1~3), m_RMS_Watts_Tot, Amps_Ln_(1~3)
memcpy(&tx[7], &p->m_RMS_Watts_Ln_1, sizeof(u32) * 4);//7-10, 11-14, 15-18, 19-22 /// 23-26, 27-30, 31-34
u32 vTemp[3] = {
(u32)(p->m_Amps_Ln_1 * 10),
(u32)(p->m_Amps_Ln_2 * 10),
(u32)(p->m_Amps_Ln_3 * 10)};
memcpy(&tx[23], vTemp, sizeof(u32) * 3);
}
else
{
tx_len = IMCP_TX_LEN(1);
tx[6] = 0; //NG
}
}
else
{
tx_len = IMCP_TX_LEN(1);
tx[6] = 0; //NG
}
UpdateCheckSum(tx, tx_len);
}
break;
#endif //FUNC_EKM_OMNIMETER
#ifdef FUNC_WARNING_CODE
case PROTOCOL_MESSAGE_QUERY_EVSE_WARNING:
tx_len = 11;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_EVSE_WARNING;
tx[4] = 4;
tx[5] = 0x00;
HTK_U32(tx[6]) = Charger.Warning_Code;
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[10] = chksum;
break;
#endif //FUNC_WARNING_CODE
#ifdef FUNC_CSU_PUBLIC_KEY_OPERATION
case PROTOCOL_MESSAGE_QUERY_EVSE_PUBLIC_KEY:
{
enum
{
DATA_LEN = 64,
SALT_LEN = 64,
MIXTURE_LEN = DATA_LEN + SALT_LEN,
SALTMAP_LEN = GET_BOX_NUM(MIXTURE_LEN, 8),
ALL_LEN = MIXTURE_LEN + SALTMAP_LEN,
};
tx_len = IMCP_TX_LEN(ALL_LEN);
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_QUERY_EVSE_PUBLIC_KEY;
HTK_U16(tx[4]) = ALL_LEN;
//XP("\r\n[PROTOCOL_MESSAGE_QUERY_EVSE_PUBLIC_KEY]\r\n\r\n");
#ifdef FUNC_ENABLE_CSU_SIGN_IN_WHEN_MCU_HAVE_NG_MODELNAME
if (!Charger.m_bCsuSignInMustVerify)
{
Charger.m_bCsuSignInMustVerify = HTK_TRUE;
}
#endif
if (Charger.m_bCsuSignInMustVerify)
{
if (DataEncryption(Charger.memory.EVSE_Config.data.item.m_CsuPublicKey, DATA_LEN, &tx[6], ALL_LEN, 0) == PASS)
{
#ifdef FUNC_SECURITY_DEBUG_INFO
HTK_ByteArray2HexStr_XP("#CSU_GetPublicKey", Charger.memory.EVSE_Config.data.item.m_CsuPublicKey, 0, DATA_LEN);
#endif
XP("#CSU_GetPublicKey: OK\r\n");
}
else
{
memset(&tx[6], 0, ALL_LEN);
XP("#CSU_GetPublicKey: [NG]\r\n");
}
}
else
{
memset(&tx[6], 0, ALL_LEN);
XP("#CSU_GetPublicKey: [NG]\r\n");
}
UpdateCheckSum(tx, tx_len);
}
break;
#endif //FUNC_CSU_PUBLIC_KEY_OPERATION
/*
Config message
*/
case PROTOCOL_MESSAGE_CONFIG_FAN_SPEED:
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_FAN_SPEED;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
tx[7] = 0x01;
break;
case PROTOCOL_MESSAGE_CONFIG_SN:
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_SN;
tx[4] = 0x01;
tx[5] = 0x00;
#ifdef MODIFY_CONFIG_SN
{
uint16_t len = HTK_U16(CurRxBuf[4]);
if (len < sizeof(Charger.memory.EVSE_Config.data.item.SerialNumber) && HTK_IS_DISP_CHAR(CurRxBuf[14]))
{
//OK
tx[6] = 0x01;
tx[7] = 0x01;
memset(Charger.memory.EVSE_Config.data.item.SerialNumber, 0, ARRAY_SIZE(Charger.memory.EVSE_Config.data.item.SerialNumber));
memset(Charger.memory.EVSE_Config.data.item.System_ID, 0, ARRAY_SIZE(Charger.memory.EVSE_Config.data.item.System_ID));
for(uint16_t idx=0;idx<(len-8);idx++)
{
Charger.memory.EVSE_Config.data.item.SerialNumber[idx] = CurRxBuf[14+idx];
}
Charger.memory.EVSE_Config.data.item.SerialNumber[len-8] = '\0';
memcpy(Charger.memory.EVSE_Config.data.item.System_ID, Charger.memory.EVSE_Config.data.item.ModelName, strlen(Charger.memory.EVSE_Config.data.item.ModelName));
memcpy(&Charger.memory.EVSE_Config.data.item.System_ID[strlen(Charger.memory.EVSE_Config.data.item.ModelName)], Charger.memory.EVSE_Config.data.item.SerialNumber, len);
XP("#CONFIG_SN: %s\r\n", Charger.memory.EVSE_Config.data.item.SerialNumber);
//parseVersionInfoFromModelname() ;
Charger.memory.EVSE_Config.op_bits.update = ON;
break;
}
else
{
//NG
tx[6] = 0x00;
tx[7] = 0x00;
break;
}
}
#else //MODIFY_CONFIG_SN
// tx[6] = 0x01;
// tx[7] = 0x01;
//
// memset(Charger.memory.EVSE_Config.data.item.SerialNumber, 0x00, sizeof(Charger.memory.EVSE_Config.data.item.SerialNumber)/sizeof(Charger.memory.EVSE_Config.data.item.SerialNumber[0]));
// memset(Charger.memory.EVSE_Config.data.item.System_ID, 0x00, sizeof(Charger.memory.EVSE_Config.data.item.System_ID)/sizeof(Charger.memory.EVSE_Config.data.item.System_ID[0]));
// for(uint16_t idx=0;idx<((CurRxBuf[4] | (CurRxBuf[5]<<8))-8);idx++)
// {
// Charger.memory.EVSE_Config.data.item.SerialNumber[idx] = CurRxBuf[14+idx];
// }
// Charger.memory.EVSE_Config.data.item.SerialNumber[(CurRxBuf[4] | (CurRxBuf[5]<<8))-8] = '\0';
// memcpy(Charger.memory.EVSE_Config.data.item.System_ID, Charger.memory.EVSE_Config.data.item.ModelName, strlen(Charger.memory.EVSE_Config.data.item.ModelName));
// memcpy(&Charger.memory.EVSE_Config.data.item.System_ID[strlen(Charger.memory.EVSE_Config.data.item.ModelName)], Charger.memory.EVSE_Config.data.item.SerialNumber, (CurRxBuf[4] | (CurRxBuf[5]<<8)));
//
// parseVersionInfoFromModelname() ;
// Charger.memory.EVSE_Config.op_bits.update = ON;
// break;
#endif //MODIFY_CONFIG_SN
case PROTOCOL_MESSAGE_CONFIG_MODEL_NAME:
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_MODEL_NAME;
tx[4] = 0x01;
tx[5] = 0x00;
#ifdef MODIFY_CONFIG_MODEL_NAME
{
uint16_t len = HTK_U16(CurRxBuf[4]);
if (len < sizeof(Charger.memory.EVSE_Config.data.item.ModelName) && HTK_IS_DISP_CHAR(CurRxBuf[6]))
{
#ifdef FUNC_IGNORE_ILLEGAL_MODEL_NAME
if (CurRxBuf[6] != 'A' && CurRxBuf[6] != 'D')
{
CurRxBuf[6+14] = '\0';
XP("#CONFIG_ILLEGAL_MODEL_NAME: %s\r\n", (char*)&CurRxBuf[6]);
//NG
tx[6] = 0x00;
tx[7] = 0x00;
break;
}
#endif
//OK
tx[6] = 0x01;
tx[7] = 0x01;
memset(Charger.memory.EVSE_Config.data.item.ModelName, 0, ARRAY_SIZE(Charger.memory.EVSE_Config.data.item.ModelName));
memset(Charger.memory.EVSE_Config.data.item.System_ID, 0, ARRAY_SIZE(Charger.memory.EVSE_Config.data.item.System_ID));
for(uint16_t idx=0;idx25mA
Charger.memory.EVSE_Config.data.item.Correction_Leak[CurRxBuf[7]][1] = ((CurRxBuf[8] | (CurRxBuf[9]<<8))*100); // mA
DEBUG_INFO("Charger.memory.EVSE_Config.data.item.Correction_Leak[[0] = %d\r\n",Charger.memory.EVSE_Config.data.item.Correction_Leak[CurRxBuf[7]][0]);
DEBUG_INFO("Charger.memory.EVSE_Config.data.item.Correction_Leak[[1] = %d\r\n",Charger.memory.EVSE_Config.data.item.Correction_Leak[CurRxBuf[7]][1]);
break;
case GROUND_FAULT_VOLTAGE: //max 3.3V
Charger.memory.EVSE_Config.data.item.Correction_GMI[CurRxBuf[7]][0] = (uint16_t)(adc_value.ADC3_IN4_GMI_VL1.value*10*3.3/4095) ;
Charger.memory.EVSE_Config.data.item.Correction_GMI[CurRxBuf[7]][1] = CurRxBuf[8] | (CurRxBuf[9]<<8);
break;
}
Charger.memory.EVSE_Config.op_bits.update = ON;
break;
case PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT:
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[7] = chksum;
#ifdef MODIFY_GOT_CSU_DUTY_CMD_PROCESS
Charger.m_bPassGotCsuCpDutyCmd =
(Charger.am3352.isRequestOn &&
Charger.Alarm_Code == 0 &&
(
(Charger.CP_State == SYSTEM_STATE_C && CurRxBuf[9] == 0x07) ||
(Charger.m_bEnableTypeE && IsTypeEPlugIn() && CurRxBuf[9] == 0x08)
)
);
#endif
if (
#ifdef MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_LEGACY_REQUEST
Charger.am3352.isRequestOn &&
#endif
#ifdef MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_ALARM_CODE
Charger.Alarm_Code == 0 &&
#endif
#ifdef MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_MODE_CHARGING
Charger.Mode == MODE_CHARGING &&
#endif
#ifdef MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_CP_PWM
Charger.m_CP_CurPWM != PWM_DUTY_FULL &&
#endif
Charger.CP_State == SYSTEM_STATE_C &&
CurRxBuf[9] == 0x07 //Main relay (0111b)
)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
#ifdef FUNC_RELAY_OFF_WHEN_GET_TWICE_OFF_CMD
CsuSetRelayOffCount = 0;
#endif
}
else if
(
#ifdef MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_LEGACY_REQUEST
Charger.am3352.isRequestOn &&
#endif
#ifdef MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_ALARM_CODE
Charger.Alarm_Code == 0 &&
#endif
#ifdef MODIFY_PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT_CHECK_MODE_CHARGING
Charger.Mode == MODE_CHARGING &&
#endif
Charger.m_bEnableTypeE &&
IsTypeEPlugIn() &&
CurRxBuf[9] == 0x08 //Type E socket relay (1000b)
)
{
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_ON;
#ifdef FUNC_RELAY_OFF_WHEN_GET_TWICE_OFF_CMD
CsuSetRelayOffCount = 0;
#endif
}
else
{
#ifdef FUNC_RELAY_OFF_WHEN_GET_TWICE_OFF_CMD
if (++CsuSetRelayOffCount >= 2)
{
CsuSetRelayOffCount = 0;
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
if (Charger.Mode != MODE_DEBUG)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF ;
}
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#else
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF ;
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
}
#else //FUNC_RELAY_OFF_WHEN_GET_TWICE_OFF_CMD
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
if (Charger.Mode != MODE_DEBUG)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF ;
}
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#else
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF ;
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
#endif //FUNC_RELAY_OFF_WHEN_GET_TWICE_OFF_CMD
}
#ifdef FUNC_CSU_CMD_DEBUG
XP("#CSU_SetRelay: %d\r\n", CurRxBuf[9]);
#endif
DEBUG_INFO("Set Relay Action By CSU: %d => Main(%d), TypeE(%d)\r\n",
CurRxBuf[9],
Charger.Relay_Action,
Charger.SE_Relay_Action);
break;
case PROTOCOL_MESSAGE_CONFIG_GPIO_OUTPUT:
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_GPIO_OUTPUT;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = CurRxBuf[6];
tx[7] = 0x00 ^ CurRxBuf[6];
break;
case PROTOCOL_MESSAGE_CONFIG_RTC:
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_RTC;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
tx[7] = 0x01;
setTime.Hours = (CurRxBuf[14]-'0')*10 + (CurRxBuf[15]-'0');
setTime.Minutes = (CurRxBuf[16]-'0')*10 + (CurRxBuf[17]-'0');
setTime.Seconds = (CurRxBuf[18]-'0')*10 + (CurRxBuf[19]-'0');
setTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
setTime.StoreOperation = RTC_STOREOPERATION_RESET;
if (HAL_RTC_SetTime(&hrtc, &setTime, RTC_FORMAT_BIN) != HAL_OK)
{
Error_Handler();
}
setDate.Year = (CurRxBuf[6]-'0')*1000 + (CurRxBuf[7]-'0')*100 + (CurRxBuf[8]-'0')*10 + (CurRxBuf[9]-'0') - 2000;
setDate.Month = (CurRxBuf[10]-'0')*10+ (CurRxBuf[11]-'0');
setDate.Date = (CurRxBuf[12]-'0')*10 + (CurRxBuf[13]-'0');
if (HAL_RTC_SetDate(&hrtc, &setDate, RTC_FORMAT_BIN) != HAL_OK)
{
Error_Handler();
}
#ifdef FUNC_CSU_CMD_DEBUG
XP("#CSU_SetRTC: %04d/%02d/%02d %02d:%02d:%02d\r\n",
setDate.Year + 2000, setDate.Month, setDate.Date,
setTime.Hours, setTime.Minutes, setTime.Seconds);
#endif
break;
case PROTOCOL_MESSAGE_CONFIG_LED_ACTION_ALARM:
#ifdef VO_BLOCK_CSU_LED_ACTION_CMD
if (Charger.m_VOCode.m_EnableBlockCsuLedCmd)
{
if (CurRxBuf == UART_IAP_rx_buffer) //CSU or Debug Port
{
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_LED_ACTION_ALARM;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
tx[7] = 0x01;
break;
}
}
#endif
#ifdef FUNC_CUSTOMIZED_LED_MODE_FROM_CSU
if((Charger.am3352.LedActionState != CurRxBuf[6])||(Charger.am3352.LedAlarmState != HTK_U32(CurRxBuf[7]))||CurRxBuf[6]==LED_ACTION_CUSTOMIZED_MODE)
{
Charger.am3352.LedActionState = CurRxBuf[6];
Charger.am3352.LedAlarmState = HTK_U32(CurRxBuf[7]);
#else
if((Charger.am3352.LedActionState != CurRxBuf[6])||(Charger.am3352.LedAlarmState != (CurRxBuf[7]|(CurRxBuf[8]<<8)|(CurRxBuf[9]<<16)|(CurRxBuf[10]<<24))))
{
Charger.am3352.LedActionState = CurRxBuf[6];
Charger.am3352.LedAlarmState = (CurRxBuf[7]|(CurRxBuf[8]<<8)|(CurRxBuf[9]<<16)|(CurRxBuf[10]<<24));
#endif
#ifdef FUNC_SHOW_CSU_CONFIG_LED_ACTION_INFO
XP("#CSU_SetLed (%d, %d)\r\n", Charger.am3352.LedActionState, Charger.am3352.LedAlarmState);
#endif
switch(Charger.am3352.LedActionState)
{
case LED_ACTION_INIT:
setLedMotion(LED_ACTION_INIT);
break;
case LED_ACTION_IDLE:
setLedMotion(LED_ACTION_IDLE);
break;
case LED_ACTION_AUTHED:
setLedMotion(LED_ACTION_AUTHED);
break;
case LED_ACTION_CONNECTED:
setLedMotion(LED_ACTION_CONNECTED);
break;
case LED_ACTION_CHARGING:
setLedMotion(LED_ACTION_CHARGING);
break;
case LED_ACTION_STOP:
setLedMotion(LED_ACTION_STOP);
break;
case LED_ACTION_ALARM:
setLedMotion(LED_ACTION_ALARM);
break;
case LED_ACTION_MAINTAIN:
setLedMotion(LED_ACTION_MAINTAIN);
break;
case LED_ACTION_RFID_PASS:
setLedMotion(LED_ACTION_RFID_PASS);
timerEnable(TIMER_IDX_LED_TEMP, 3000);
break;
case LED_ACTION_RFID_FAIL:
setLedMotion(LED_ACTION_RFID_FAIL);
timerEnable(TIMER_IDX_LED_TEMP, 3000);
break;
case LED_ACTION_BLE_CONNECT:
setLedMotion(LED_ACTION_BLE_CONNECT);
timerEnable(TIMER_IDX_LED_TEMP, 3000);
break;
case LED_ACTION_BLE_DISABLE:
setLedMotion(LED_ACTION_BLE_DISABLE);
break;
case LED_ACTION_ALL_OFF:
setLedMotion(LED_ACTION_ALL_OFF);
break;
case LED_ACTION_INTERNET_DISCONNECT:
setLedMotion(LED_ACTION_INTERNET_DISCONNECT);
break;
case LED_ACTION_HANDSHAKE_FAIL:
setLedMotion(LED_ACTION_HANDSHAKE_FAIL);
timerEnable(TIMER_IDX_LED_TEMP, 3000);
break;
case LED_ACTION_RESTORE_SETTING:
setLedMotion(LED_ACTION_RESTORE_SETTING);
timerEnable(TIMER_IDX_LED_TEMP, 3000);
break;
#ifdef MODIFY_LED_STATUS_202108
case LED_ACTION_IDLE_BACKEND_CONNECTED:
setLedMotion(LED_ACTION_IDLE_BACKEND_CONNECTED);
break;
case LED_ACTION_IDLE_BACKEND_CONNECTED_SLEEP:
setLedMotion(LED_ACTION_IDLE_BACKEND_CONNECTED_SLEEP);
break;
case LED_ACTION_IDLE_BACKEND_DISCONNECTED:
setLedMotion(LED_ACTION_IDLE_BACKEND_DISCONNECTED);
break;
case LED_ACTION_IDLE_BACKEND_DISCONNECTED_SLEEP:
setLedMotion(LED_ACTION_IDLE_BACKEND_DISCONNECTED_SLEEP);
break;
case LED_ACTION_RESERVATION_MODE:
setLedMotion(LED_ACTION_RESERVATION_MODE);
break;
#endif //MODIFY_LED_STATUS_202108
#ifdef FUNC_CUSTOMIZED_LED_MODE_FROM_CSU
case LED_ACTION_CUSTOMIZED_MODE:
{
LED_UserCfg o = { 0 };
o.m_Mode = CurRxBuf[11];
o.m_AutoRepeat = CurRxBuf[12];
o.m_Brightness = CurRxBuf[13];
o.m_R = HTK_U16(CurRxBuf[14]);
o.m_G = HTK_U16(CurRxBuf[16]);
o.m_B = HTK_U16(CurRxBuf[18]);
HTK_BOOL bCfgOK = HTK_TRUE;
if (o.m_Mode == LED_USER_MODE_SOLID)
{
//Do nothing
}
else if (o.m_Mode == LED_USER_MODE_BLINK)
{
o.Blink.m_On_ms = HTK_U16(CurRxBuf[20]);
o.Blink.m_Off_ms = HTK_U16(CurRxBuf[22]);
o.Blink.m_Rest_ms = HTK_U16(CurRxBuf[24]);
o.Blink.m_Count = HTK_U16(CurRxBuf[26]);
}
else if (o.m_Mode == LED_USER_MODE_BREATH)
{
o.Breath.m_Up_ms = HTK_U16(CurRxBuf[20]);
o.Breath.m_Down_ms = HTK_U16(CurRxBuf[22]);
}
else
{
//Wrong mode
bCfgOK = HTK_FALSE;
}
if (bCfgOK)
{
setLedMotion_User(LED_ACTION_CUSTOMIZED_MODE, &o);
}
}
break;
#endif //FUNC_CUSTOMIZED_LED_MODE_FROM_CSU
default:
break;
}
}
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_LED_ACTION_ALARM;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
tx[7] = 0x01;
break;
case PROTOCOL_MESSAGE_CONFIG_MAX_CURRENT_PWM_DUTY:
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_MAX_CURRENT_PWM_DUTY;
tx[4] = 0x01;
tx[5] = 0x00;
#ifdef FUNC_CSU_CMD_DEBUG
XP("#CSU_SetCpPwmDuty: %d %s\r\n", CurRxBuf[6],
(Charger.m_bBlockCsuCpPwmDuty || Charger.m_bBlockCsuCpPwmDutyWhenAlarmCpF) ? "(Block)" : "");
#endif
if (
#ifdef FUNC_BLOCK_CSU_CONFIG_CP_PWM_DUTY
!Charger.m_bBlockCsuCpPwmDuty &&
#endif
#ifdef FUNC_BLOCK_CSU_CMD_SET_DUTY_WHEN_ALARM_CP_F_STATE
!Charger.m_bBlockCsuCpPwmDutyWhenAlarmCpF &&
#endif
(
#ifdef FUNC_AX80
(CurRxBuf[6] <= 80 && CurRxBuf[6] >= 6) ||
#else
(CurRxBuf[6] <= 48 && CurRxBuf[6] >= 6) ||
#endif
(CurRxBuf[6] == PWM_DUTY_OFF) ||
(CurRxBuf[6] == 1) ||
(CurRxBuf[6] == 5) ||
(CurRxBuf[6] == 100)
)
)
{
#ifdef MODIFY_AC_EVSE_STATUS_MAX_CHARGING_CURRENT_VARIABLE
Charger.AC_MaxChargingCurrentOrDuty = CurRxBuf[6];
#endif
tx[6] = 0x00;
#ifdef FUNC_AX80
if(CurRxBuf[6] <= 80 && CurRxBuf[6] >= 6)
#else
if(CurRxBuf[6] <= 48 && CurRxBuf[6] >= 6)
#endif
{
Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = CurRxBuf[6];
#ifdef FUNC_CCS
Charger.m_bRunCCS = 0;
Charger.m_bGotCsuCpDutyCmd = 1;
#endif
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent));
#ifdef FUNC_SYSTEM_KEEP_INFO
g_SystemKeepInfo.m_CpPwmVal = GetCpPwmDuty(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent);
SystemKeepInfo_Update(&g_SystemKeepInfo);
#endif
#else //MODIFY_CP_TASK_CTRL_CP_PWM
//user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_651(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent));
#endif //MODIFY_CP_TASK_CTRL_CP_PWM
tx[6] = 0x01;
}
else if (CurRxBuf[6] == PWM_DUTY_OFF)
{
user_pwm_setvalue(PWM_CH_CP, 0); // State F
#ifdef FUNC_SYSTEM_KEEP_INFO
g_SystemKeepInfo.m_CpPwmVal = 0;
SystemKeepInfo_Update(&g_SystemKeepInfo);
#endif
tx[6] = 0x01;
}
else if (CurRxBuf[6] == 5)
{
#ifdef FUNC_CCS
Charger.m_bRunCCS = 1;
Charger.m_bGotCsuCpDutyCmd = 1;
#endif
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_5);
#ifdef FUNC_SYSTEM_KEEP_INFO
g_SystemKeepInfo.m_CpPwmVal = PWM_DUTY_5;
SystemKeepInfo_Update(&g_SystemKeepInfo);
#endif
tx[6] = 0x01;
}
else if (CurRxBuf[6] == 100)
{
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
#ifdef FUNC_SYSTEM_KEEP_INFO
g_SystemKeepInfo.m_CpPwmVal = PWM_DUTY_FULL;
SystemKeepInfo_Update(&g_SystemKeepInfo);
#endif
tx[6] = 0x01;
}
//control pilot E
if (CurRxBuf[6] == 1)
{
HAL_GPIO_WritePin(OUT_StateE_GPIO_Port, OUT_StateE_Pin, GPIO_PIN_SET); // ON // State E
user_pwm_setvalue(PWM_CH_CP, 0); //Temporarily, wait for EE to change the hardware and delete
#ifdef FUNC_SYSTEM_KEEP_INFO
g_SystemKeepInfo.m_CpPwmVal = 0;
SystemKeepInfo_Update(&g_SystemKeepInfo);
#endif
tx[6] = 0x01;
}
else
{
HAL_GPIO_WritePin(OUT_StateE_GPIO_Port, OUT_StateE_Pin, GPIO_PIN_RESET); //OFF
}
XP("#CSU_SetCpPwmDuty_Final: %d\r\n", CurRxBuf[6]);
}
else
{
tx[6] = 0x00;
DEBUG_INFO("CSU_SetCpPwmDuty [NG] (%d) !!!!! \r\n", CurRxBuf[6]);
}
for(uint16_t idx=0;idx<(tx[4] | (tx[5]<<8));idx++)
{
chksum ^= tx[6 + idx];
}
tx[7] = chksum; //checksum
break;
case PROTOCOL_MESSAGE_CONFIG_LEGACY_REQUEST:
#ifdef FUNC_CSU_CMD_DEBUG
XP("#CSU_SetRequest: %d\r\n", CurRxBuf[6]);
#endif
//#ifdef FUNC_DC_AUTO_RELAY_OFF
// if (Charger.m_bModelNameDC && CurRxBuf[6] == 0)
// {
// if (Charger.Relay_Action != GPIO_RELAY_ACTION_OFF)
// {
// XP("#SET RELAY OFF\r\n");
// Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
// }
// if (Charger.SE_Relay_Action != GPIO_SE_RELAY_ACTION_OFF)
// {
// XP("#SET SE_RELAY OFF\r\n");
// Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
// }
// }
//#endif
if((CurRxBuf[6]&SETTING_LEGACY_REQUEST)>0)
{
//#ifdef FUNC_REQUEST_OFF_WHEN_GET_TWICE_OFF_CMD
// CsuSetRequestOffCount = 0;
//#endif
Charger.am3352.isRequestOff = OFF;
Charger.rfid.op_bits.reqStart = ON;
if(!Charger.am3352.isRequestOn)
{
DEBUG_INFO("#Request Pin On.\r\n");
Charger.am3352.isRequestOn = ON;
#ifdef FUNC_SYSTEM_KEEP_INFO
g_SystemKeepInfo.m_CsuIsRequestOn = Charger.am3352.isRequestOn;
SystemKeepInfo_Update(&g_SystemKeepInfo);
#endif
}
}
else
{
//#ifdef FUNC_REQUEST_OFF_WHEN_GET_TWICE_OFF_CMD
// if (++CsuSetRequestOffCount >= 2)
// {
// CsuSetRequestOffCount = 0;
// Charger.am3352.isRequestOn = OFF;
//#ifdef FUNC_SYSTEM_KEEP_INFO
// g_SystemKeepInfo.m_CsuIsRequestOn = Charger.am3352.isRequestOn;
// SystemKeepInfo_Update(&g_SystemKeepInfo);
//#endif
// Charger.am3352.RequestPinDebounceCnt = 0;
// Charger.rfid.op_bits.reqStart = OFF;
// if(!Charger.am3352.isRequestOff)
// {
// DEBUG_INFO("#Request Pin Off.\r\n");
// Charger.am3352.isRequestOff = ON;
// }
// }
//#else //FUNC_REQUEST_OFF_WHEN_GET_TWICE_OFF_CMD
Charger.am3352.isRequestOn = OFF;
#ifdef FUNC_SYSTEM_KEEP_INFO
g_SystemKeepInfo.m_CsuIsRequestOn = Charger.am3352.isRequestOn;
SystemKeepInfo_Update(&g_SystemKeepInfo);
#endif
Charger.am3352.RequestPinDebounceCnt = 0;
Charger.rfid.op_bits.reqStart = OFF;
if(!Charger.am3352.isRequestOff)
{
DEBUG_INFO("#Request Pin Off.\r\n");
Charger.am3352.isRequestOff = ON;
}
//#endif //FUNC_REQUEST_OFF_WHEN_GET_TWICE_OFF_CMD
}
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_LEGACY_REQUEST;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
tx[7] = 0x01;
break;
case PROTOCOL_MESSAGE_CONFIG_MCU_RESET:
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_MCU_RESET;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
tx[7] = 0x01;
if((CurRxBuf[6]&0x01)>0){
DEBUG_INFO("MCU reset request.\r\n");
#ifdef MODIFY_DC_RS485_UPGRADE_ISSUE
Prefix_UartTX(tx, CurRxBuf);
HAL_UART_Transmit(pUartHandle, (uint8_t *)tx, tx_len , 0x0ffff);
Postfix_UartTX(tx, CurRxBuf);
#else
HAL_UART_Transmit(&IAP_USART, (uint8_t *)tx, tx_len , 0x0ffff);
#endif
osDelay(1000);
NVIC_SystemReset();
}
else
{
tx[6] = 0x00;
tx[7] = 0x00;
}
break;
case PROTOCOL_MESSAGE_CONFIG_BREATHE_LED_TIMING:
Charger.am3352.BreatheLedConnectFadeIn = (((uint16_t)CurRxBuf[7]<<8)+(uint16_t)CurRxBuf[6]);
Charger.am3352.BreatheLedConnectFadeOut = (((uint16_t)CurRxBuf[9]<<8)+(uint16_t)CurRxBuf[8]);
DEBUG_INFO("Connect Breathe Led Fade In time: %d ms.\r\n",Charger.am3352.BreatheLedConnectFadeIn);
DEBUG_INFO("Connect Breathe Led Fade Out time: %d ms.\r\n",Charger.am3352.BreatheLedConnectFadeOut);
Charger.am3352.BreatheLedAuthdFadeIn = (((uint16_t)CurRxBuf[11]<<8)+(uint16_t)CurRxBuf[10]);
Charger.am3352.BreatheLedAuthdFadeOut = (((uint16_t)CurRxBuf[13]<<8)+(uint16_t)CurRxBuf[12]);
DEBUG_INFO("Authd Breathe Led Fade In time: %d ms.\r\n",Charger.am3352.BreatheLedAuthdFadeIn);
DEBUG_INFO("Authd Breathe Led Fade Out time: %d ms.\r\n",Charger.am3352.BreatheLedAuthdFadeOut);
Charger.am3352.BreatheLedChargeFadeIn = (((uint16_t)CurRxBuf[15]<<8)+(uint16_t)CurRxBuf[14]);
Charger.am3352.BreatheLedChargeFadeOut = (((uint16_t)CurRxBuf[17]<<8)+(uint16_t)CurRxBuf[16]);
DEBUG_INFO("Charge Breathe Led Fade In time: %d ms.\r\n",Charger.am3352.BreatheLedChargeFadeIn);
DEBUG_INFO("Charge Breathe Led Fade Out time: %d ms.\r\n",Charger.am3352.BreatheLedChargeFadeOut);
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_BREATHE_LED_TIMING;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
tx[7] = 0x01;
break;
case PROTOCOL_MESSAGE_CONFIG_LED_BRIGHTNESS:
memcpy(Charger.Led_Brightness, &CurRxBuf[6], 12);
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_LED_BRIGHTNESS;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
tx[7] = 0x01;
break;
case PROTOCOL_MESSAGE_CONFIG_EVSE_AUTH_MODE:
switch(CurRxBuf[6])
{
case AUTH_MODE_OCPP:
Charger.memory.EVSE_Config.data.item.AuthMode = AUTH_MODE_OCPP ;
break;
case AUTH_MODE_FREE:
Charger.memory.EVSE_Config.data.item.AuthMode = AUTH_MODE_FREE ;
break;
default:
Charger.memory.EVSE_Config.data.item.AuthMode = AUTH_MODE_FREE ;
Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_FREE ;
break ;
}
switch(CurRxBuf[7])
{
case RFID_USER_AUTH_LOCAL_LIST:
Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_LOCAL_LIST ;
break;
case RFID_USER_AUTH_PH:
Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_PH ;
break;
case RFID_USER_AUTH_FREE:
Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_FREE ;
break;
case RFID_USER_AUTH_NO_CHARGING:
Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_NO_CHARGING ;
break;
default:
Charger.memory.EVSE_Config.data.item.AuthMode = AUTH_MODE_FREE ;
Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_FREE ;
break ;
}
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_EVSE_AUTH_MODE;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
tx[7] = 0x01;
Charger.memory.EVSE_Config.op_bits.update = ON;
break;
case PROTOCOL_MESSAGE_CONFIG_ERASE_MEMORY:
switch(CurRxBuf[6])
{
case 0:
Charger.memory.EVSE_Config.op_bits.clear = ON;
Charger.memory.whiteList.op_bits.clear = ON;
#ifdef FUNC_METER_IC_HISTORY
Charger.memory.hisMeterIC.op_bits.clear = ON;
#else
Charger.memory.hisCharging.op_bits.clear = ON;
#endif
Charger.memory.hisAlarm.op_bits.clear = ON;
Charger.memory.coldLoadPickUp.op_bits.clear = ON;
break;
case 1:
Charger.memory.EVSE_Config.op_bits.clear = ON;
break;
case 2:
Charger.memory.whiteList.op_bits.clear = ON;
break;
case 3:
#ifdef FUNC_METER_IC_HISTORY
Charger.memory.hisMeterIC.op_bits.clear = ON;
#else
Charger.memory.hisCharging.op_bits.clear = ON;
#endif
break;
case 4:
Charger.memory.hisAlarm.op_bits.clear = ON;
break;
case 5:
Charger.memory.coldLoadPickUp.op_bits.clear = ON;
break;
default:
break;
}
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_ERASE_MEMORY;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
tx[7] = 0x01;
break;
case PROTOCOL_MESSAGE_CONFIG_AUX_POWER_SW:
switch(CurRxBuf[6])
{
case 0:
HAL_GPIO_WritePin(OUT_Meter_Power_GPIO_Port, OUT_Meter_Power_Pin, (CurRxBuf[7]?GPIO_PIN_SET:GPIO_PIN_RESET));
break;
case 1:
HAL_GPIO_WritePin(OUT_Meter_Power_GPIO_Port, OUT_Meter_Power_Pin, (CurRxBuf[7]?GPIO_PIN_SET:GPIO_PIN_RESET));
break;
default:
break;
}
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_AUX_POWER_SW;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
tx[7] = 0x01;
break;
#ifdef FUNC_METER_IC_ADE7858A
case PROTOCOL_MESSAGE_CONFIG_METER_IC_CALI_PARAMETER:
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_METER_IC_CALI_PARAMETER;
tx[4] = 0x01;
tx[5] = 0x00;
{
MeterIC_CaliValType type = (MeterIC_CaliValType)CurRxBuf[6];
uint32_t nSetVal = HTK_U32(CurRxBuf[7]);
if (type == MICC_RESET_POWER_CONSUMPTION_CUMULATIVE) //0xA0: Reset power consumption cumulative
{
if (nSetVal == AUTHCODE_RESET_POWER_CONSUMPTION_CUMULATIVE)
{
tx[6] = 0x01; //Set OK
XP("#RESET_POWER_CONSUMPTION_CUMULATIVE\r\n");
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total = 0;
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 = 0;
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 = 0;
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3 = 0;
Charger.memory.EVSE_Config.data.item.AcPlugInTimes = 0; //Clear PlugIn counter
Charger.memory.EVSE_Config.op_bits.update = ON;
}
else
{
tx[6] = 0x00; //Set NG
}
}
//0xC0/0xC1: Reset all MeterIC calibration values to (0x00/0xFF)
else if (type == MICC_RESET_METER_IC_ALL_CALI_VAL_00 || type == MICC_RESET_METER_IC_ALL_CALI_VAL_FF)
{
if (nSetVal == AUTHCODE_RESET_METER_IC_ALL_CALI_VAL)
{
tx[6] = 0x01; //Set OK
XP("#RESET_RESET_ALL_CALI_VAL: 0x%02X\r\n", type);
memset
(&Charger.memory.EVSE_Config.data.item.m_MeterIC_CaliVals,
type == MICC_RESET_METER_IC_ALL_CALI_VAL_00 ? 0x00 : 0xFF,
sizeof(MeterIC_CaliVals));
#ifdef FUNC_METER_IC_CALI_FLAG
Charger.memory.EVSE_Config.data.item.m_MeterIC_CaliFlag.m_Data = 0;
#endif
Charger.memory.EVSE_Config.op_bits.update = ON;
Charger.m_MeterIC_TrigWriteCaliVals.m_Data = HTK_U32_MAX;
}
else
{
tx[6] = 0x00; //Set NG
}
}
#ifdef FUNC_GUN_LOCK
else if (type == MICC_SET_GUN_LOCK_STATUS && Charger.m_bUseGunLock)
{
XP("#SetGunLock: %d\r\n", nSetVal);
if (nSetVal == 0)
{
GL_Trig(GL_MODE_UNLOCK);
}
else if (nSetVal == 1)
{
GL_Trig(GL_MODE_LOCK);
}
}
#endif //FUNC_GUN_LOCK
#ifdef FUNC_VOLATILE_OPERATION
else if (type == MICC_SET_VO_CODE)
{
Charger.m_VOCode.m_Value = nSetVal;
XP("#SET VO_Code = 0x%08X\r\n", Charger.m_VOCode.m_Value);
#ifdef VO_SIMU_CP
XP("#VO: EnableSimuCP(%d)\r\n", Charger.m_VOCode.m_EnableSimuCP);
if (Charger.m_VOCode.m_EnableSimuCP)
{
Charger.m_SimuData.m_CP.m_VoltPos = (uint16_t)(CpDetectionResult.PositiveValue == 0 ? 0 : HTK_GetPosFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.PositiveValue)) * 1000); //V => mV
Charger.m_SimuData.m_CP.m_VoltNeg = (uint16_t)(CpDetectionResult.NegativeValue == 0 ? 0 : HTK_GetNegFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.NegativeValue)) * 1000); //V => mV
}
#endif //VO_SIMU_CP
#ifdef VO_SIMU_PP
XP("#VO: EnableSimuPP(%d)\r\n", Charger.m_VOCode.m_EnableSimuPP);
if (Charger.m_VOCode.m_EnableSimuPP)
{
if (!Charger.m_bDetectPP)
{
Charger.m_VOCode.m_EnableSimuPP = 0;
XP("#VO: EnableSimuPP(%d) [Detect PP Function OFF]\r\n", Charger.m_VOCode.m_EnableSimuPP);
}
}
#endif
#ifdef VO_DISABLE_RELAY_WELDING
XP("#VO: DisableRelayWelding(%d)\r\n", Charger.m_VOCode.m_DisableRelayWelding);
#endif
#ifdef VO_BLOCK_CSU_LED_ACTION_CMD
XP("#VO: EnableBlockCsuLedCmd(%d)\r\n", Charger.m_VOCode.m_EnableBlockCsuLedCmd);
#endif
#ifdef VO_SIMU_ACV
XP("#VO: EnableSimuACV(%d)\r\n", Charger.m_VOCode.m_EnableSimuACV);
if (Charger.m_VOCode.m_EnableSimuACV)
{
Charger.m_SimuData.m_AcvVolt = Charger.Voltage[0];
}
#endif
#ifdef VO_SIMU_NTC
XP("#VO: EnableSimuNTC(%d)\r\n", Charger.m_VOCode.m_EnableSimuNTC);
if (Charger.m_VOCode.m_EnableSimuNTC)
{
Charger.m_SimuData.m_NtcTemp = Charger.temperature.SystemAmbientTemp;
}
#endif
#ifdef VO_SIMU_ALARMCODE
XP("#VO: EnableSimuAlarmCode(%d)\r\n", Charger.m_VOCode.m_EnableSimuAlarmCode);
if (Charger.m_VOCode.m_EnableSimuAlarmCode)
{
Charger.m_SimuData.m_AlarmCode = Charger.Alarm_Code;
}
#endif
#ifdef VO_SIMU_ACA
XP("#VO: EnableSimuACA(%d)\r\n", Charger.m_VOCode.m_EnableSimuACA);
if (Charger.m_VOCode.m_EnableSimuACA)
{
Charger.m_SimuData.m_AcaCurr = Charger.Current[0];
}
#endif
#ifdef VO_DISABLE_DETECT_TILT_SENSOR
if (Charger.m_bModelNameAX80_1P)
{
XP("#VO: DisableDetectTiltSensor(%d)\r\n", Charger.m_VOCode.m_DisableDetectTiltSensor);
}
#endif
}
#ifdef VO_SIMU_CP
else if (type == MICC_SET_SIMU_CP_VOLT)
{
if (Charger.m_VOCode.m_EnableSimuCP)
{
Charger.m_SimuData.m_CP.m_Value = nSetVal;
XP("#SET VO_SimuCP_Volt = (+%0.3f, -%0.3f)\r\n", Charger.m_SimuData.m_CP.m_VoltPos * 0.001, Charger.m_SimuData.m_CP.m_VoltNeg * 0.001);
}
}
#endif //VO_SIMU_CP
#ifdef VO_SIMU_PP
else if (type == MICC_SET_SIMU_PP_CURR)
{
if (Charger.m_VOCode.m_EnableSimuPP)
{
if (Charger.m_bDetectPP)
{
Charger.m_SimuData.m_PPCurr = nSetVal;
XP("#SET VO_SimuPP_Curr = (%d)\r\n", Charger.m_SimuData.m_PPCurr);
}
else
{
XP("#SET VO_SimuPP_Curr = (%d) [Detect PP Function OFF]\r\n", Charger.m_SimuData.m_PPCurr);
}
}
}
#endif //VO_SIMU_PP
#ifdef VO_SIMU_ACV
else if (type == MICC_SET_SIMU_ACV_VOLT)
{
if (Charger.m_VOCode.m_EnableSimuACV)
{
Charger.m_SimuData.m_AcvVolt = (uint16_t)nSetVal;
XP("#SET VO_SimuACV_Volt = (%d)\r\n", Charger.m_SimuData.m_AcvVolt);
}
}
#endif
#ifdef VO_SIMU_NTC
else if (type == MICC_SET_SIMU_NTC_TEMP)
{
if (Charger.m_VOCode.m_EnableSimuNTC)
{
Charger.m_SimuData.m_NtcTemp = (uint8_t)nSetVal;
XP("#SET VO_SimuNTC_Temp = (%d)\r\n", Charger.m_SimuData.m_NtcTemp);
}
}
#endif
#ifdef VO_SIMU_ALARMCODE
else if (type == MICC_SET_SIMU_ALARMCIDE_VAL)
{
if (Charger.m_VOCode.m_EnableSimuAlarmCode)
{
Charger.m_SimuData.m_AlarmCode = nSetVal;
XP("#SET VO_SimuAlarmCode_Val = (0x%08X)\r\n", Charger.m_SimuData.m_AlarmCode);
}
}
#endif
#ifdef VO_SIMU_ACA
else if (type == MICC_SET_SIMU_ACA_CURR)
{
if (Charger.m_VOCode.m_EnableSimuACA)
{
Charger.m_SimuData.m_AcaCurr = (uint16_t)nSetVal;
XP("#SET VO_SimuACA_Curr = (%d)\r\n", Charger.m_SimuData.m_AcaCurr);
}
}
#endif
#endif //FUNC_VOLATILE_OPERATION
else
{
uint32_t nSetVal = HTK_U32(CurRxBuf[7]);
uint8_t Offset = 0xFF;
int32_t *p = MeterIC_GetCaliValPtr(type, &Offset);
if (p != NULL && Offset != 0xFF)
{
tx[6] = 0x01; //Set OK
*p = nSetVal;
#ifdef FUNC_METER_IC_CALI_FLAG
Charger.memory.EVSE_Config.data.item.m_MeterIC_CaliFlag.m_Data |= (((uint32_t)0x01) << Offset);
#endif
Charger.memory.EVSE_Config.op_bits.update = ON;
Charger.m_MeterIC_TrigWriteCaliVals.m_Data |= (((uint32_t)0x01) << Offset);
#ifdef FUNC_METER_IC_HISTORY
recordMeterICHis(type, *p);
#endif
}
else
{
tx[6] = 0x00; //Set NG
}
XP(" \r\nPROTOCOL_MESSAGE_CONFIG_METER_IC_CALI_PARAMETER(0x%02X, 0x%04X)\r\n\r\n", type, nSetVal);
}
}
UpdateCheckSum(tx, tx_len);
break;
#endif //FUNC_METER_IC_ADE7858A
#ifdef FUNC_PTB_METER_WM3M4C
case PROTOCOL_MESSAGE_CONFIG_PTB_METER_WM3M4C:
{
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_PTB_METER_WM3M4C;
PWM3M4C p = Charger.m_pWM3M4C;
byte SubCmd = CurRxBuf[6];
tx_len = 6 + (1) + 1;
char* s = "#CSU_WM3M4C_Set: ";
#ifdef FUNC_CSU_CMD_DEBUG
XP("%s0x%02X%s\r\n", s, SubCmd, (Charger.m_bUseExtMeter_WM3M4C && p ? "" : " (NOT SUPPORTED)"));
#endif
if (Charger.m_bUseExtMeter_WM3M4C && p)
{
if (SubCmd == WM3M4C_SCMD_CHG_BEGIN) //AA 00 FF 97 01 00 01 01
{
#ifdef FUNC_CSU_CMD_DEBUG
XP("%sCHARGE BEGIN\r\n", s);
#endif
tx[6] = 1; //OK
p->m_bTrigBegCharge = HTK_TRUE;
}
else if (SubCmd == WM3M4C_SCMD_CHG_END) //AA 00 FF 97 01 00 02 02
{
#ifdef FUNC_CSU_CMD_DEBUG
XP("%sCHARGE END\r\n", s);
#endif
tx[6] = 1; //OK
p->m_bTrigEndCharge = HTK_TRUE;
}
else
{
tx[6] = 0; //NG
}
}
else
{
tx[6] = 0; //NG
}
UpdateCheckSum(tx, tx_len);
}
break;
#endif //FUNC_PTB_METER_WM3M4C
#ifdef FUNC_CSU_SIGN_IN_VERIFY
case PROTOCOL_MESSAGE_CONFIG_CSU_SIGN_IN_VERIFY:
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_CSU_SIGN_IN_VERIFY;
tx[4] = 0x01;
tx[5] = 0x00;
//XP("\r\n[PROTOCOL_MESSAGE_CONFIG_CSU_SIGN_IN_VERIFY]\r\n\r\n");
#ifdef FUNC_ENABLE_CSU_SIGN_IN_WHEN_MCU_HAVE_NG_MODELNAME
if (!Charger.m_bCsuSignInMustVerify)
{
Charger.m_bCsuSignInMustVerify = HTK_TRUE;
}
#endif
if (Charger.m_bCsuSignInMustVerify)
{
#ifdef FUNC_VERIFY_TASK
if (!Charger.m_bCsuSignInVerifyOK && !Charger.m_bRunCsuSignInVerify)
{
Charger.m_VerifyTaskRxBufDataLen = *pCurRxBuf_RxLen;
memset(Charger.m_VerifyTaskRxBuf, 0, VERIFY_TASK_RXBUF_LEN);
memcpy(Charger.m_VerifyTaskRxBuf, CurRxBuf, HTK_GET_VAL_MIN(Charger.m_VerifyTaskRxBufDataLen, VERIFY_TASK_RXBUF_LEN));
Charger.m_bRunCsuSignInVerify = HTK_TRUE;
}
#else
//Charger.m_bCsuVerifyOK = AES256_Verify(&CurRxBuf[6], 4, (u8*)AES256_KEY, &CurRxBuf[10], &CurRxBuf[26]);
#endif
if (Charger.m_bCsuSignInVerifyOK)
{
DEBUG_INFO("#CSU SignIn OK!\n\r");
tx[6] = 0x01;
tx[7] = 0x01;
}
else
{
DEBUG_INFO("#CSU SignIn [NG]!\n\r");
tx[6] = 0x00;
tx[7] = 0x00;
}
}
else
{
DEBUG_INFO("#NO need to SignIn!\n\r");
tx[6] = 0x00;
tx[7] = 0x00;
}
break;
#endif //FUNC_CSU_SIGN_IN_VERIFY
#ifdef FUNC_AW48_NET_LED
case PROTOCOL_MESSAGE_CONFIG_LED_ACTION_CONNECTIVITY_STATUS:
if (HTK_IS_BETWEEN_MINMAX(CurRxBuf[6], NET_LED_ACTION_MIN, NET_LED_ACTION_MAX)
&& (CurRxBuf[6] != Charger.am3352.NetLedActionState))
{
Charger.am3352.NetLedActionState = CurRxBuf[6];
#ifdef FUNC_SHOW_CSU_CONFIG_LED_ACTION_INFO
XP("#CSU_SetNetLed(%d)\r\n", Charger.am3352.NetLedActionState);
#endif
setNetLedMotion(Charger.am3352.NetLedActionState);
}
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_LED_ACTION_CONNECTIVITY_STATUS;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
tx[7] = 0x01;
break;
#endif //FUNC_AW48_NET_LED
#ifdef FUNC_CSU_PUBLIC_KEY_OPERATION
case PROTOCOL_MESSAGE_CONFIG_EVSE_PUBLIC_KEY:
{
enum
{
DATA_LEN = 64,
SALT_LEN = 64,
MIXTURE_LEN = DATA_LEN + SALT_LEN,
SALTMAP_LEN = GET_BOX_NUM(MIXTURE_LEN, 8),
ALL_LEN = MIXTURE_LEN + SALTMAP_LEN,
};
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_EVSE_PUBLIC_KEY;
tx[4] = 0x01;
tx[5] = 0x00;
//XP("\r\n[PROTOCOL_MESSAGE_CONFIG_EVSE_PUBLIC_KEY]\r\n\r\n");
#ifdef FUNC_ENABLE_CSU_SIGN_IN_WHEN_MCU_HAVE_NG_MODELNAME
if (!Charger.m_bCsuSignInMustVerify)
{
Charger.m_bCsuSignInMustVerify = HTK_TRUE;
}
#endif
if (Charger.m_bCsuSignInMustVerify)
{
enum { KEY_LEN = sizeof(Charger.memory.EVSE_Config.data.item.m_CsuPublicKey), };
u8* pKey = Charger.memory.EVSE_Config.data.item.m_CsuPublicKey;
u8 Temp[KEY_LEN] = { 0 };
memcpy(Temp, pKey, KEY_LEN);
if (DataEncryption(pKey, DATA_LEN, &CurRxBuf[6], ALL_LEN, 1) == PASS)
{
#ifdef FUNC_SECURITY_DEBUG_INFO
HTK_ByteArray2HexStr_XP("#CSU_SetPublicKey", pKey, 0, DATA_LEN);
#endif
if (memcmp(Temp, pKey, KEY_LEN) != 0)
{
Charger.memory.EVSE_Config.op_bits.update = ON;
XP("#CSU_SetPublicKey OK => MEM_ADDR_EVSE_CONFIG\r\n");
//Need to RE-SignIn
Charger.m_bCsuSignInVerifyOK = HTK_FALSE;
Charger.m_bCsuUpgradeFwVerifyOK = HTK_FALSE;
}
tx[6] = 0x01;
tx[7] = 0x01;
}
else
{
XP("#CSU_SetPublicKey: [NG]\r\n");
tx[6] = 0x00;
tx[7] = 0x00;
}
}
else
{
XP("#CSU_SetPublicKey: [NG]\r\n");
tx[6] = 0x00;
tx[7] = 0x00;
}
}
break;
#endif //FUNC_CSU_PUBLIC_KEY_OPERATION
#ifdef FUNC_RESET_CONNECTOR_PLUGIN_TIMES
case PROTOCOL_MESSAGE_CONFIG_RESET_CONNECTOR_PLUGIN_TIMES:
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_CONFIG_RESET_CONNECTOR_PLUGIN_TIMES;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
tx[7] = 0x01;
if(CurRxBuf[6] == 0x01)
{
DEBUG_INFO("CSU reset connector plugin times.\r\n");
Charger.memory.EVSE_Config.data.item.AcPlugInTimes = 0;
Charger.memory.EVSE_Config.op_bits.update = ON;
}
else
{
tx[6] = 0x00;
tx[7] = 0x00;
}
break;
#endif //FUNC_RESET_CONNECTOR_PLUGIN_TIMES
/*
Firmware update message
*/
case PROTOCOL_MESSAGE_UPGRADE_START:
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_UPGRADE_START;
tx[4] = 0x01;
tx[5] = 0x00;
binCRCTarget = (CurRxBuf[6] << 24) | (CurRxBuf[6] << 16) | (CurRxBuf[6] << 8) | (CurRxBuf[6] << 0);
flashdestination = NEW_CODE_ADDRESS;
#ifdef FUNC_CSU_UPGRADE_FW_VERIFY
XP("\r\n[PROTOCOL_MESSAGE_UPGRADE_START]\r\n\r\n");
#ifdef FUNC_VERIFY_TASK
if (Charger.m_bCsuUpgradeFwMustVerify)
{
if (Charger.m_bCsuUpgradeFwMustVerify && !Charger.m_bCsuUpgradeFwVerifyOK && !Charger.m_bRunCsuUpgradeFwVerify)
{
Charger.m_VerifyTaskRxBufDataLen = *pCurRxBuf_RxLen;
memset(Charger.m_VerifyTaskRxBuf, 0, VERIFY_TASK_RXBUF_LEN);
memcpy(Charger.m_VerifyTaskRxBuf, CurRxBuf, HTK_GET_VAL_MIN(Charger.m_VerifyTaskRxBufDataLen, VERIFY_TASK_RXBUF_LEN));
Charger.m_bRunCsuUpgradeFwVerify = HTK_TRUE;
#ifdef FUNC_SECURITY_DEBUG_INFO
HTK_ByteArray2HexStr_XP("PROTOCOL_MESSAGE_UPGRADE_START", Charger.m_VerifyTaskRxBuf, 0, Charger.m_VerifyTaskRxBufDataLen);
#endif
}
}
#else //FUNC_VERIFY_TASK
// taskENTER_CRITICAL();
// bFwCheckOkUseAES256 = AES256_Verify(&CurRxBuf[6], 4, (u8*)AES256_KEY, &CurRxBuf[10], &CurRxBuf[26]);
// taskEXIT_CRITICAL();
#endif //FUNC_VERIFY_TASK
#endif //FUNC_CSU_UPGRADE_FW_VERIFY
if(FLASH_If_Erase(NEW_CODE_ADDRESS, 3)== FLASHIF_OK)
{
#if defined(DEBUG) || defined(RTOS_STAT)
DEBUG_INFO("Firmware transfer start, earase flash success....\n\r");
#endif
tx[6] = 0x01;
tx[7] = 0x01;
if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
{
setChargerMode(MODE_MAINTAIN);
timerEnable(TIMER_IDX_UPDATE, 10000);
}
}
else
{
#if defined(DEBUG) || defined(RTOS_STAT)
DEBUG_INFO("Firmware transfer start, earase flash fail....\n\r");
#endif
tx[6] = 0x00;
tx[7] = 0x00;
}
break;
case PROTOCOL_MESSAGE_UPGRADE_TRANS:
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_UPGRADE_TRANS;
tx[4] = 0x01;
tx[5] = 0x00;
flashdestination = NEW_CODE_ADDRESS + ((CurRxBuf[6]<<0) | (CurRxBuf[7]<<8) | (CurRxBuf[8]<<16) |(CurRxBuf[9]<<24));
if (FLASH_If_Write(flashdestination, (uint32_t*) &CurRxBuf[10], ((((CurRxBuf[4]) | (CurRxBuf[5])<<8)-4)>>2)) == FLASHIF_OK)
{
#if defined(DEBUG) || defined(RTOS_STAT)
//DEBUG_INFO("Firmware transfer start address: 0x%x, length: %d...Pass\n\r", flashdestination, (((CurRxBuf[4]) | (CurRxBuf[5])<<8)-4));
#endif
tx[6] = 0x01;
tx[7] = 0x01;
if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
{
setLedMotion(LED_ACTION_MAINTAIN);
timerRefresh(TIMER_IDX_UPDATE);
}
}
else
{
#if defined(DEBUG) || defined(RTOS_STAT)
DEBUG_INFO("Firmware transfer start address: 0x%x, length: %d...Fail\n\r", flashdestination, (((CurRxBuf[4]) | (CurRxBuf[5])<<8)-4));
#endif
tx[6] = 0x00;
tx[7] = 0x00;
}
break;
case PROTOCOL_MESSAGE_UPGRADE_STOP:
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_UPGRADE_STOP;
tx[4] = 0x01;
tx[5] = 0x00;
#ifdef FUNC_USE_STM32_SBSFU
// {
// //HAL_StatusTypeDef ret = HAL_ERROR;
// //uint8_t fw_header_dwl_slot[SE_FW_HEADER_TOT_LEN];
// SFU_FwImageFlashTypeDef dw1;
//
// /* Get Info about the download area */
// SFU_APP_GetDownloadAreaInfo(SLOT_DWL_1, &dw1);
// XP("MaxSizeInBytes = %d (0x%08X)\r\n", dw1.MaxSizeInBytes, dw1.MaxSizeInBytes);
// XP("DownloadAddr = %d (0x%08X)\r\n", dw1.DownloadAddr, dw1.DownloadAddr);
// XP("ImageOffsetInBytes = %d (0x%08X)\r\n", dw1.ImageOffsetInBytes, dw1.ImageOffsetInBytes);
// XP("ExecutionAddr = %d (0x%08X)\r\n", dw1.ExecutionAddr, dw1.ExecutionAddr);
//
// }
if ((Charger.m_bCsuUpgradeFwMustVerify && Charger.m_bCsuUpgradeFwVerifyOK) || (!Charger.m_bCsuUpgradeFwMustVerify))
{
DEBUG_INFO("Firmware transfer end %s\r\n", Charger.m_bCsuUpgradeFwMustVerify ? (Charger.m_bCsuUpgradeFwVerifyOK ? "(VERIFY: OK)" : "(VERIFY: [NG])" ) : "");
tx[6] = 0x01;
tx[7] = 0x01;
if(isUSB_CDC_IAP)
{
CDC_Transmit_FS((uint8_t *)tx, tx_len);
}
else
{
#ifdef MODIFY_DC_RS485_UPGRADE_ISSUE
Prefix_UartTX(tx, CurRxBuf);
HAL_UART_Transmit(pUartHandle, (uint8_t *)tx, tx_len , 0x0ffff);
Postfix_UartTX(tx, CurRxBuf);
#else
HAL_UART_Transmit(&IAP_USART, (uint8_t *)tx, tx_len , 0x0ffff);
#endif
}
osDelay(1000);
NVIC_SystemReset();
}
else
{
DEBUG_INFO("Firmware verify fail...\n\r");
tx[6] = 0x00;
tx[7] = 0x00;
}
#else //FUNC_USE_STM32_SBSFU
flash = NEW_CODE_ADDRESS;
checksum = HAL_CRC_Calculate(&hcrc, (uint32_t *)flash, ((FLASH_AP_LENGTH-4)>>2));
flash = ((uint32_t)(NEW_CODE_ADDRESS+FLASH_AP_LENGTH-4));
#ifdef FUNC_CSU_UPGRADE_FW_VERIFY
#if defined(DEBUG) || defined(RTOS_STAT)
if (Charger.m_bCsuUpgradeFwMustVerify)
DEBUG_INFO("Firmware transfer end, AP CRC checksum, flash: 0x%x, 0x%x (VERIFY: %s)\r\n", checksum, *((uint32_t *)flash), (Charger.m_bCsuUpgradeFwVerifyOK ? "OK" : "[NG]" ));
else
DEBUG_INFO("Firmware transfer end, AP CRC checksum, flash: 0x%x, 0x%x\r\n", checksum, *((uint32_t *)flash) );
#endif
if(checksum == *((uint32_t *)flash) && ((Charger.m_bCsuUpgradeFwMustVerify && Charger.m_bCsuUpgradeFwVerifyOK) || (!Charger.m_bCsuUpgradeFwMustVerify)))
#else
#if defined(DEBUG) || defined(RTOS_STAT)
DEBUG_INFO("Firmware transfer end, AP CRC checksum, flash: 0x%x, 0x%x\r\n", checksum, *((uint32_t *)flash) );
#endif
if(checksum == *((uint32_t *)flash))
#endif //FUNC_CSU_UPGRADE_FW_VERIFY
{
if (FLASH_If_Write(UPGRADE_REQ_ADDRESS, (uint32_t *)&endFlag[0], 1) == FLASHIF_OK)
{
#if defined(DEBUG) || defined(RTOS_STAT)
DEBUG_INFO("Firmware Confirm Tag write ok..\n\r");
#endif
tx[6] = 0x01;
tx[7] = 0x01;
if(isUSB_CDC_IAP)
{
CDC_Transmit_FS((uint8_t *)tx, tx_len);
}
else
{
#ifdef MODIFY_DC_RS485_UPGRADE_ISSUE
Prefix_UartTX(tx, CurRxBuf);
HAL_UART_Transmit(pUartHandle, (uint8_t *)tx, tx_len , 0x0ffff);
Postfix_UartTX(tx, CurRxBuf);
#else
HAL_UART_Transmit(&IAP_USART, (uint8_t *)tx, tx_len , 0x0ffff);
#endif
}
osDelay(1000);
NVIC_SystemReset();
}
else
{
#if defined(DEBUG) || defined(RTOS_STAT)
DEBUG_INFO("Firmware Confirm Tag write fail...\n\r");
#endif
tx[6] = 0x00;
tx[7] = 0x00;
}
}
else
{
#if defined(DEBUG) || defined(RTOS_STAT)
DEBUG_INFO("Firmware checksum compare fail...\n\r");
#endif
tx[6] = 0x00;
tx[7] = 0x00;
}
#endif //FUNC_USE_STM32_SBSFU
if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
{
timerDisable(TIMER_IDX_UPDATE);
}
break;
case PROTOCOL_MESSAGE_UPGRADE_ABOARD:
#if defined(DEBUG) || defined(RTOS_STAT)
DEBUG_INFO("Firmware update transfer aboard...\n\r");
#endif
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = PROTOCOL_MESSAGE_UPGRADE_ABOARD;
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x01;
tx[7] = 0x01;
break;
default:
/* Todo: bin file receive aboard */
#if defined(DEBUG) || defined(RTOS_STAT)
#ifdef FUNC_RS485_SLAVE
DEBUG_INFO("Protocol message unknow (0x%02X)\n\r", CurRxBuf[3]);
#else
DEBUG_INFO("Protocol message unknow...\n\r");
#endif
#endif
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = CurRxBuf[3];
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x00;
tx[7] = 0x00;
break;
}
}
else
{
#ifndef FUNC_RS485_SLAVE
#if defined(DEBUG) || defined(RTOS_STAT)
DEBUG_INFO("Protocol check sum is wrong...\n\r");
#endif
tx_len = 8;
tx[0] = 0xaa;
tx[1] = PROTOCOL_ADDR;
tx[2] = CurRxBuf[1];
tx[3] = CurRxBuf[3];
tx[4] = 0x01;
tx[5] = 0x00;
tx[6] = 0x00;
tx[7] = 0x00;
#endif //FUNC_RS485_SLAVE
}
if(isUSB_CDC_IAP)
{
CDC_Transmit_FS((uint8_t *)tx, tx_len);
}
else
{
#ifdef FUNC_RS485_SLAVE
#ifdef MODIFY_DC_RS485_UPGRADE_ISSUE
#ifdef FUNC_CSU_SIGN_IN_VERIFY
if (CurRxBuf != NULL)
{
if (CurRxBuf == UART_IAP_rx_buffer &&
(Charger.m_bCsuSignInMustVerify && !Charger.m_bCsuSignInVerifyOK))
{
//XP("X\r\n");
//do not response
#ifdef FUNC_CSU_PUBLIC_KEY_OPERATION
if ( CurRxBuf[3] == PROTOCOL_MESSAGE_CONFIG_CSU_SIGN_IN_VERIFY
|| CurRxBuf[3] == PROTOCOL_MESSAGE_QUERY_EVSE_PUBLIC_KEY
|| CurRxBuf[3] == PROTOCOL_MESSAGE_CONFIG_EVSE_PUBLIC_KEY
)
{
Prefix_UartTX(tx, CurRxBuf);
HAL_UART_Transmit(pUartHandle, (uint8_t *)tx, tx_len , 0x0ffff);
Postfix_UartTX(tx, CurRxBuf);
}
#endif
}
else
{
Prefix_UartTX(tx, CurRxBuf);
HAL_UART_Transmit(pUartHandle, (uint8_t *)tx, tx_len , 0x0ffff);
Postfix_UartTX(tx, CurRxBuf);
}
}
#else //FUNC_CSU_SIGN_IN_VERIFY
if (CurRxBuf != NULL)
{
Prefix_UartTX(tx, CurRxBuf);
HAL_UART_Transmit(pUartHandle, (uint8_t *)tx, tx_len , 0x0ffff);
Postfix_UartTX(tx, CurRxBuf);
}
#endif //FUNC_CSU_SIGN_IN_VERIFY
#else //MODIFY_DC_RS485_UPGRADE_ISSUE
if (CurRxBuf != NULL)
{
tx[1] = Charger.m_RS485SlaveAddr; //Update Slave Address
HAL_UART_Transmit(pUartHandle, (uint8_t *)tx, tx_len, 0xffff);
}
#endif //MODIFY_DC_RS485_UPGRADE_ISSUE
#else //FUNC_RS485_SLAVE
HAL_UART_Transmit(&IAP_USART, (uint8_t *)tx, tx_len, 0xffff);
#endif //FUNC_RS485_SLAVE
}
#ifdef ENABLE_PRINT_IMCP_MSG
#ifdef FUNC_RS485_SLAVE
#ifdef PRINT_IMCP_MSG_ONLY_ON_UPDATEPORT
if (CurRxBuf == UART_IAP_rx_buffer && CheckPrintImcpMsg(CurRxBuf[3]))
{
HTK_ByteArray2HexStr_XP(NULL, tx, 0, tx_len);
}
#else
if (CheckPrintImcpMsg(CurRxBuf[3]))
{
HTK_ByteArray2HexStr_XP(NULL, tx, 0, tx_len);
}
#endif //PRINT_IMCP_MSG_ONLY_ON_UPDATEPORT
#else //FUNC_RS485_SLAVE
if (CheckPrintImcpMsg(UART_IAP_rx_buffer[3]))
{
HTK_ByteArray2HexStr_XP(NULL, tx, 0, tx_len);
}
#endif //FUNC_RS485_SLAVE
#endif //ENABLE_PRINT_IMCP_MSG
#ifdef FUNC_RS485_SLAVE
// Clear rx_buffer and related varaible
for(uint16_t i = 0; i < *pCurRxBuf_RxLen ; i++)
CurRxBuf[i]=0;
*pCurRxBuf_RxLen = 0;
*pCurRecvEndFlag = 0;
isUSB_CDC_IAP = OFF;
#else
// Clear rx_buffer and related varaible
for(uint16_t i = 0; i < UART_IAP_rx_len ; i++)
UART_IAP_rx_buffer[i]=0;
UART_IAP_rx_len=0;
UART_IAP_recv_end_flag=0;
isUSB_CDC_IAP = OFF;
#endif //FUNC_RS485_SLAVE
}
if(timer[TIMER_IDX_UPDATE].isAlarm == ON && Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
{
setChargerMode(MODE_IDLE);
setLedMotion(LED_ACTION_IDLE);
timerDisable(TIMER_IDX_UPDATE);
}
#ifdef FUNC_RS485_SLAVE
HAL_UART_Receive_DMA(&IAP_USART,(uint8_t*)UART_IAP_rx_buffer, UART_BUFFER_SIZE);
HAL_UART_Receive_DMA(&RS485_USART,(uint8_t*)UART_RS485_rx_buffer, UART_BUFFER_SIZE);
#else
HAL_UART_Receive_DMA(&IAP_USART,(uint8_t*)UART_IAP_rx_buffer, UART_BUFFER_SIZE);
#endif //FUNC_RS485_SLAVE
#ifdef FUNC_DEBUG_CONSOLE
HAL_UART_Receive_DMA(&DEBUG_USART,(uint8_t*)UART_DEBUG_rx_buffer, UART_DEBUG_BUFFER_SIZE);
#endif
osDelay(1);
}
/* USER CODE END StartUartTask */
}
#ifdef FUNC_DETECT_PP
/*--------------------------------------------------------------------------------------------
Vehicle Rc Range of resistance ADC read ADC
connectors (ohm) Rc for interpretation [h](V) (count)
current by the EV supply
(A) equipment (ohm)
----------------------------------------------------------------------------------------------
N/A Error condition >4500 >2.6 >3227
or disconnection
of plug
----------------------------------------------------------------------------------------------
13 1500 1100-2460 2.32~2.52 2879~3127
20 680 400-936 1.86~2.26 2308~2805
32 220 80-308 0.83~1.70 1031~2110
--------------------------------------------------------------------------------------------*/
void UpdatePPInfo_AdcVal(PPPInfo p, uint32_t v) //ADC value (count)
{
if (v > 3227) { p->m_CurCurr = 13; p->m_StatusID = 0x01; } //use MIN Current
else if (v >= 2879 && v <= 3127) { p->m_CurCurr = 13; p->m_StatusID = 0x01; } //MIN Current
else if (v >= 2308 && v <= 2805) { p->m_CurCurr = 20; p->m_StatusID = 0x02; }
else if (v >= 1031 && v <= 2110) { p->m_CurCurr = 32; p->m_StatusID = 0x03; }
else { p->m_CurCurr = 13; p->m_StatusID = 0x01; } //use MIN Current
}
#ifdef VO_SIMU_PP
void UpdatePPInfo_CurrVal(PPPInfo p, uint16_t v) //Current value (A)
{
if (v == 13) { p->m_CurCurr = 13; p->m_StatusID = 0x01; }
else if (v == 20) { p->m_CurCurr = 20; p->m_StatusID = 0x02; }
else if (v == 32) { p->m_CurCurr = 32; p->m_StatusID = 0x03; }
else if (v == 63) { p->m_CurCurr = 63; p->m_StatusID = 0x04; }
else { p->m_CurCurr = 13; p->m_StatusID = 0x01; }
}
#endif //VO_SIMU_PP
#endif //FUNC_DETECT_PP
/* USER CODE BEGIN Header_StartAdcTask */
/**
* @brief Function implementing the adcTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartAdcTask */
#ifdef FUNC_DEBUG_MSG_CP_STATE
const char *CP_STATE_TAG[7] = {"0:UNKNOW", "1:A(12V)", "2:B(9V)", "3:C(6V)", "4:D(3V)", "5:E(0V)", "6:F(-12V)"};
#endif
void StartAdcTask(void const * argument)
{
/* USER CODE BEGIN StartAdcTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
IdleUntilReadAllMemory();
#endif
//aadc
uint8_t previous_cp_state = SYSTEM_STATE_A;
#ifndef FUNC_POWER_CONSUMPTION_BY_METER_IC
uint8_t updateMemReq = 0;
struct TimeTick
{
uint32_t timeTick_Start;
uint32_t timeTick_End;
uint32_t timeTick_Delta;
}timeTick;
timeTick.timeTick_Start = HAL_GetTick();
#endif
#ifdef FUNC_CP_ADC_MODIFY
#ifdef NEW_CP_SPEC
while (!Charger.m_bCpDetectModuleInitOK)
{
osDelay(10);
}
#else //NEW_CP_SPEC
CpDetectModuleInitialize();
#endif //NEW_CP_SPEC
#else //FUNC_CP_ADC_MODIFY
CpDetectModuleInitialize( &CpBoundary, &SpecDefBoundary, &CpHysteresis);
#endif //FUNC_CP_ADC_MODIFY
#ifndef FUNC_POWER_CONSUMPTION_BY_METER_IC
timerEnable(TIMER_IDX_POWER, 1000);
#endif
#ifdef FUNC_GUN_LOCK
GL_Init(); //All Model
#endif
/* Infinite loop */
for(;;)
{
Relay_Control_Function() ;
#ifdef FUNC_OUTP_TYPE_E
if (Charger.m_bEnableTypeE)
{
SE_Relay_Control_Function();
}
#endif
// ADC chanel 1
if(isDMAEnd_ADC1)
{
#ifdef FUNC_TASK_MONITOR
Charger.m_TaskMonitor.m_ADC.m_ADC1_Counter[0]++;
#endif
isDMAEnd_ADC1 = OFF;
#ifdef VO_SIMU_CP
CpCalculate(ADC1_Buffer, ADC1_CHANEL_COUNT*ADC1_SAMPLE_COUNT, &CpDetectionResult, Charger.m_VOCode.m_EnableSimuCP, &Charger.m_SimuData.m_CP);
#else
CpCalculate(ADC1_Buffer, ADC1_CHANEL_COUNT*ADC1_SAMPLE_COUNT, &CpDetectionResult);
#endif
Charger.CP_State = CpDetectionResult.State;
// if (Charger.Mode!= MODE_DEBUG)
{
#ifdef MODIFY_ADCTASK_CP_STATE_CHANGE
if((previous_cp_state != Charger.CP_State))
#else
if((previous_cp_state != Charger.CP_State) && (Charger.CP_State !=SYSTEM_STATE_UNKNOWN ))
#endif
{
#ifdef FUNC_DEBUG_MSG_CP_STATE
XP("#CP: [%s] >>> [%s] (+%.3f, -%.3f)\r\n",
CP_STATE_TAG[previous_cp_state],
CP_STATE_TAG[Charger.CP_State],
(CpDetectionResult.PositiveValue == 0 ? 0 : HTK_GetPosFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.PositiveValue))),
(CpDetectionResult.NegativeValue == 0 ? 0 : HTK_GetNegFromZero(CP_GET_OPA_VIN_USE_ADC(CpDetectionResult.NegativeValue)))
);
#endif
previous_cp_state = Charger.CP_State;
if(Charger.CP_State == SYSTEM_STATE_A)
{
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL); // CP PWM duty set 100%
Charger.Relay_Action=GPIO_RELAY_ACTION_OFF;
#ifdef REDUCE_RELAY_CUT_OFF_TIME_WHEN_CP_C_TO_A
Relay_Control_Function();
#endif
if (Charger.Mode!= MODE_DEBUG)
{
Charger.memory.EVSE_Config.data.item.AcPlugInTimes++;
Charger.memory.EVSE_Config.op_bits.update = ON;
DEBUG_INFO("EVSE connector plug counts: %d\r\n", Charger.memory.EVSE_Config.data.item.AcPlugInTimes);
}
}
}
}
if(HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&ADC1_Buffer, ADC1_CHANEL_COUNT*ADC1_SAMPLE_COUNT)!=HAL_OK)Error_Handler();
}
// ADC chanel 2
if(isDMAEnd_ADC2)
{
#ifdef FUNC_TASK_MONITOR
Charger.m_TaskMonitor.m_ADC.m_ADC2_Counter[0]++;
#endif
isDMAEnd_ADC2 = OFF;
for(uint16_t idx=0;idx MeterIC | [AX80_NACS => T1]
ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1]; //ADC3_IN14_1998 (PF4)
ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2]; //ADC3_IN15_Temp (PF5)
ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3]; //ADC3_IN4_GMI_VL1 (PF6)
ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4]; //ADC3_IN7_Current_L1 (PF9) => MeterIC | [AX80_NACS => T4]
ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5]; //ADC3_IN5_Current_L2 (PF7) => MeterIC | [AX80_NACS => T5]
ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6]; //ADC3_IN6_PP_GUN_DET (PF8)
ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7]; //ADC3_IN8_Voltage_L2 (PF10) => MeterIC | [AX80_NACS => T2]
ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8]; //ADC3_IN10_Voltage_L3 (PC0) => MeterIC | [AX80_NACS => T3]
ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9]; //ADC3_IN11_Current_L3 (PC1) => MeterIC | [AX80_NACS => T6]
}
else
{
ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0]; //ADC3_IN9_Voltage_L1 (PF3) => MeterIC | [AX80 => RELAY1_Temp]
ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1]; //ADC3_IN14_1998 (PF4)
ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2]; //ADC3_IN15_Temp (PF5)
ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3]; //ADC3_IN4_GMI_VL1 (PF6)
ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4]; //ADC3_IN7_Current_L1 (PF9) => MeterIC | [AX80 => Input_N_L2_Temp]
//ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5]; //ADC3_IN5_Current_L2 (PF7) => MeterIC
ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6]; //ADC3_IN6_PP_GUN_DET (PF8)
ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7]; //ADC3_IN8_Voltage_L2 (PF10) => MeterIC | [AX80 => RELAY2_Temp]
ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8]; //ADC3_IN10_Voltage_L3 (PC0) => MeterIC | [AX80 => Input_L1_Temp]
//ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9]; //ADC3_IN11_Current_L3 (PC1) => MeterIC
}
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0]; //ADC3_IN9_Voltage_L1 (PF3) => MeterIC | [AX80 => RELAY1_Temp]
ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1]; //ADC3_IN14_1998 (PF4)
ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2]; //ADC3_IN15_Temp (PF5)
ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3]; //ADC3_IN4_GMI_VL1 (PF6)
ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4]; //ADC3_IN7_Current_L1 (PF9) => MeterIC | [AX80 => Input_N_L2_Temp]
//ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5]; //ADC3_IN5_Current_L2 (PF7) => MeterIC
ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6]; //ADC3_IN6_PP_GUN_DET (PF8)
ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7]; //ADC3_IN8_Voltage_L2 (PF10) => MeterIC | [AX80 => RELAY2_Temp]
ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8]; //ADC3_IN10_Voltage_L3 (PC0) => MeterIC | [AX80 => Input_L1_Temp]
//ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9]; //ADC3_IN11_Current_L3 (PC1) => MeterIC
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
}
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
else if (Charger.m_bModelNameAW48_1P)
{
ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0]; //ADC3_IN9_Voltage_L1 (PF3) => MeterIC | [AW48 => T1]
ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1]; //ADC3_IN14_1998 (PF4)
ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2]; //ADC3_IN15_Temp (PF5)
ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3]; //ADC3_IN4_GMI_VL1 (PF6)
ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4]; //ADC3_IN7_Current_L1 (PF9) => MeterIC | [AW48 => T4]
ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5]; //ADC3_IN5_Current_L2 (PF7) => MeterIC | [AW48 => T5]
ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6]; //ADC3_IN6_PP_GUN_DET (PF8)
ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7]; //ADC3_IN8_Voltage_L2 (PF10) => MeterIC | [AW48 => T2]
ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8]; //ADC3_IN10_Voltage_L3 (PC0) => MeterIC | [AW48 => T3]
ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9]; //ADC3_IN11_Current_L3 (PC1) => MeterIC | [AW48 => T6]
}
#endif //FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
else if (Charger.m_bModelNameAX48_NACS_1P)
{
ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0]; //ADC3_IN9_Voltage_L1 (PF3) => MeterIC | [AX48_NACS => T1]
ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1]; //ADC3_IN14_1998 (PF4)
ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2]; //ADC3_IN15_Temp (PF5)
ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3]; //ADC3_IN4_GMI_VL1 (PF6)
ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4]; //ADC3_IN7_Current_L1 (PF9) => MeterIC | [AX48_NACS => T4]
ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5]; //ADC3_IN5_Current_L2 (PF7) => MeterIC | [AX48_NACS => T5]
ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6]; //ADC3_IN6_PP_GUN_DET (PF8)
ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7]; //ADC3_IN8_Voltage_L2 (PF10) => MeterIC | [AX48_NACS => T2]
ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8]; //ADC3_IN10_Voltage_L3 (PC0) => MeterIC | [AX48_NACS => T3]
ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9]; //ADC3_IN11_Current_L3 (PC1) => MeterIC | [AX48_NACS => T6]
}
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
else //AX48 / AX32
{
//ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0]; //ADC3_IN9_Voltage_L1 (PF3) => MeterIC
ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1]; //ADC3_IN14_1998 (PF4)
ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2]; //ADC3_IN15_Temp (PF5)
ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3]; //ADC3_IN4_GMI_VL1 (PF6)
//ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4]; //ADC3_IN7_Current_L1 (PF9) => MeterIC
//ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5]; //ADC3_IN5_Current_L2 (PF7) => MeterIC
ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6]; //ADC3_IN6_PP_GUN_DET (PF8)
//ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7]; //ADC3_IN8_Voltage_L2 (PF10) => MeterIC
//ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8]; //ADC3_IN10_Voltage_L3 (PC0) => MeterIC
//ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9]; //ADC3_IN11_Current_L3 (PC1) => MeterIC
}
#else //FUNC_AX80_ADD_4_TEMP_SENEOR
//ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0]; //ADC3_IN9_Voltage_L1 (PF3) => MeterIC
ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1]; //ADC3_IN14_1998 (PF4)
ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2]; //ADC3_IN15_Temp (PF5)
ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3]; //ADC3_IN4_GMI_VL1 (PF6)
//ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4]; //ADC3_IN7_Current_L1 (PF9) => MeterIC
//ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5]; //ADC3_IN5_Current_L2 (PF7) => MeterIC
ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6]; //ADC3_IN6_PP_GUN_DET (PF8)
//ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7]; //ADC3_IN8_Voltage_L2 (PF10) => MeterIC
//ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8]; //ADC3_IN10_Voltage_L3 (PC0) => MeterIC
//ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9]; //ADC3_IN11_Current_L3 (PC1) => MeterIC
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR
#else //FUNC_REPLACE_ADC_WITH_METER_IC
ADC3_Buffer_Each[0][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 0]; //ADC3_IN9_Voltage_L1 (PF3)
ADC3_Buffer_Each[1][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 1]; //ADC3_IN14_1998 (PF4)
ADC3_Buffer_Each[2][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 2]; //ADC3_IN15_Temp (PF5)
ADC3_Buffer_Each[3][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 3]; //ADC3_IN4_GMI_VL1 (PF6)
ADC3_Buffer_Each[4][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 4]; //ADC3_IN7_Current_L1 (PF9)
ADC3_Buffer_Each[5][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 5]; //ADC3_IN5_Current_L2 (PF7)
ADC3_Buffer_Each[6][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 6]; //ADC3_IN6_PP_GUN_DET (PF8)
ADC3_Buffer_Each[7][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 7]; //ADC3_IN8_Voltage_L2 (PF10)
ADC3_Buffer_Each[8][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 8]; //ADC3_IN10_Voltage_L3 (PC0)
ADC3_Buffer_Each[9][idx] = ADC3_Buffer[(idx*ADC3_CHANEL_COUNT) + 9]; //ADC3_IN11_Current_L3 (PC1)
#endif //FUNC_REPLACE_ADC_WITH_METER_IC
}
//VT
#ifndef FUNC_REPLACE_ADC_WITH_METER_IC
filter_move_avg(&adc_value.ADC3_IN9_Voltage_L1, vRms_cal2(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT)); //L1
filter_move_avg(&adc_value.ADC3_IN8_Voltage_L2, vRms_cal2(ADC3_Buffer_Each[7], ADC3_SAMPLE_COUNT)); //L2
filter_move_avg(&adc_value.ADC3_IN10_Voltage_L3, vRms_cal2(ADC3_Buffer_Each[8], ADC3_SAMPLE_COUNT)); //L3
#endif
//MCU VDD
filter_move_avg(&adc_value.ADC3_IN14_UL_1998, avg_cal(ADC3_Buffer_Each[1], ADC3_SAMPLE_COUNT));
//TEMP
filter_move_avg(&adc_value.ADC3_IN15_Temp, avg_cal(ADC3_Buffer_Each[2], ADC3_SAMPLE_COUNT));
#ifdef VO_SIMU_NTC
if (Charger.m_VOCode.m_EnableSimuNTC)
{
Charger.temperature.SystemAmbientTemp = Charger.m_SimuData.m_NtcTemp;
}
else
{
Charger.temperature.SystemAmbientTemp = getTemperature(adc_value.ADC3_IN15_Temp.value);
}
#else
Charger.temperature.SystemAmbientTemp = getTemperature(adc_value.ADC3_IN15_Temp.value);
#endif
#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
if (Charger.m_bModelNameAX80_1P)
{
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
if (Charger.m_bModelNameAX80_NACS_1P)
{
filter_move_avg(&adc_value.ADC3_IN9_AX80_NACS_T1, avg_cal(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN8_AX80_NACS_T2, avg_cal(ADC3_Buffer_Each[7], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN10_AX80_NACS_T3, avg_cal(ADC3_Buffer_Each[8], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN7_AX80_NACS_T4, avg_cal(ADC3_Buffer_Each[4], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN5_AX80_NACS_T5, avg_cal(ADC3_Buffer_Each[5], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN11_AX80_NACS_T6, avg_cal(ADC3_Buffer_Each[9], ADC3_SAMPLE_COUNT));
#ifdef FUNC_AX80_NACS_NEW_TEMP_SENSOR_COMPENSATION_20231214
#ifdef FUNC_AX80_NACS_TEMP_SENSOR_WITHOUT_COMPENSATION_20240903
#ifdef FUNC_AX80_NACS_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240906
double v = 0;
double powCurr = ((double)Charger.Current[0]/100.0) * ((double)Charger.Current[0]/100.0);
double pow80 = 80 * 80;
Charger.temperature.SystemAmbientTemp += 0;
v = powCurr * (10.29 / pow80);
Charger.temperature.AX80_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX80_NACS_T1.value) + HTK_ROUND_U16(v);
v = powCurr * (11.40 / pow80);
Charger.temperature.AX80_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX80_NACS_T2.value) + HTK_ROUND_U16(v);
v = powCurr * (10.12 / pow80);
Charger.temperature.AX80_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX80_NACS_T3.value) + HTK_ROUND_U16(v);
v = powCurr * (9.75 / pow80);
Charger.temperature.AX80_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX80_NACS_T4.value) + HTK_ROUND_U16(v);
Charger.temperature.AX80_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX80_NACS_T5.value) + 0;
Charger.temperature.AX80_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX80_NACS_T6.value) + 0;
#else //FUNC_AX80_NACS_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240906
{
Charger.temperature.SystemAmbientTemp += 0;
Charger.temperature.AX80_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX80_NACS_T1.value) + 0;
Charger.temperature.AX80_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX80_NACS_T2.value) + 0;
Charger.temperature.AX80_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX80_NACS_T3.value) + 0;
Charger.temperature.AX80_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX80_NACS_T4.value) + 0;
Charger.temperature.AX80_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX80_NACS_T5.value) + 0;
Charger.temperature.AX80_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX80_NACS_T6.value) + 0;
}
#endif //FUNC_AX80_NACS_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240906
#else //FUNC_AX80_NACS_TEMP_SENSOR_WITHOUT_COMPENSATION_20240903
{
double v = 0;
v = 2.38333 + (-1.7);
Charger.temperature.SystemAmbientTemp += HTK_ROUND_U16(v);
v = 23.8667 + (-4.73333);
Charger.temperature.AX80_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX80_NACS_T1.value) + HTK_ROUND_U16(v);
v = 25.45 + (-5.71667);
Charger.temperature.AX80_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX80_NACS_T2.value) + HTK_ROUND_U16(v);
v = 28.2833 + (-3.43333);
Charger.temperature.AX80_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX80_NACS_T3.value) + HTK_ROUND_U16(v);
v = 29.5333 + (-3.56667);
Charger.temperature.AX80_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX80_NACS_T4.value) + HTK_ROUND_U16(v);
Charger.temperature.AX80_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX80_NACS_T5.value) + 0;
Charger.temperature.AX80_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX80_NACS_T6.value) + 0;
}
#endif //FUNC_AX80_NACS_TEMP_SENSOR_WITHOUT_COMPENSATION_20240903
#else //FUNC_AX80_NACS_NEW_TEMP_SENSOR_COMPENSATION_20231214
#ifdef FUNC_AX80_NACS_NEW_TEMP_SENSOR_COMPENSATION
Charger.temperature.SystemAmbientTemp += 3;
Charger.temperature.AX80_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX80_NACS_T1.value) + 24;
Charger.temperature.AX80_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX80_NACS_T2.value) + 26;
Charger.temperature.AX80_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX80_NACS_T3.value) + 29;
Charger.temperature.AX80_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX80_NACS_T4.value) + 30;
Charger.temperature.AX80_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX80_NACS_T5.value) + 0;
Charger.temperature.AX80_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX80_NACS_T6.value) + 0;
#else
Charger.temperature.AX80_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX80_NACS_T1.value);
Charger.temperature.AX80_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX80_NACS_T2.value);
Charger.temperature.AX80_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX80_NACS_T3.value);
Charger.temperature.AX80_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX80_NACS_T4.value);
Charger.temperature.AX80_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX80_NACS_T5.value);
Charger.temperature.AX80_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX80_NACS_T6.value);
#endif
#endif //FUNC_AX80_NACS_NEW_TEMP_SENSOR_COMPENSATION_20231214
{
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
int16_t v = 0;
#else
uint8_t v = 0;
#endif
if (Charger.temperature.SystemAmbientTemp > v) v = Charger.temperature.SystemAmbientTemp;
if (Charger.temperature.CcsConnectorTemp > v) v = Charger.temperature.CcsConnectorTemp;
Charger.temperature.Group1_MaxTemp = v;
}
{
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
int16_t v = 0;
#else
uint8_t v = 0;
#endif
#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
if (Charger.temperature.AX80_NACS_T1_L1_IN > v) v = Charger.temperature.AX80_NACS_T1_L1_IN;
if (Charger.temperature.AX80_NACS_T2_L2_IN > v) v = Charger.temperature.AX80_NACS_T2_L2_IN;
Charger.temperature.Group2_MaxTemp = v;
v = 0;
if (Charger.temperature.AX80_NACS_T3_L1_OUT > v) v = Charger.temperature.AX80_NACS_T3_L1_OUT;
if (Charger.temperature.AX80_NACS_T4_L2_OUT > v) v = Charger.temperature.AX80_NACS_T4_L2_OUT;
Charger.temperature.Group3_MaxTemp = v;
v = 0;
if (Charger.temperature.AX80_NACS_T5_L1_GUN > v) v = Charger.temperature.AX80_NACS_T5_L1_GUN;
if (Charger.temperature.AX80_NACS_T6_L2_GUN > v) v = Charger.temperature.AX80_NACS_T6_L2_GUN;
Charger.temperature.Group4_MaxTemp = v;
#else //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
if (Charger.temperature.AX80_NACS_T1_L1_IN > v) v = Charger.temperature.AX80_NACS_T1_L1_IN;
if (Charger.temperature.AX80_NACS_T2_L2_IN > v) v = Charger.temperature.AX80_NACS_T2_L2_IN;
if (Charger.temperature.AX80_NACS_T3_L1_OUT > v) v = Charger.temperature.AX80_NACS_T3_L1_OUT;
if (Charger.temperature.AX80_NACS_T4_L2_OUT > v) v = Charger.temperature.AX80_NACS_T4_L2_OUT;
if (Charger.temperature.AX80_NACS_T5_L1_GUN > v) v = Charger.temperature.AX80_NACS_T5_L1_GUN;
if (Charger.temperature.AX80_NACS_T6_L2_GUN > v) v = Charger.temperature.AX80_NACS_T6_L2_GUN;
Charger.temperature.Group2_MaxTemp = v;
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
}
}
else
{
filter_move_avg(&adc_value.ADC3_IN9_Relay1_Temp, avg_cal(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN8_Relay2_Temp, avg_cal(ADC3_Buffer_Each[7], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN10_Input_L1_Temp, avg_cal(ADC3_Buffer_Each[8], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN7_Input_N_L2_Temp, avg_cal(ADC3_Buffer_Each[4], ADC3_SAMPLE_COUNT));
#ifdef FUNC_AX80_NEW_TEMP_SENSOR_COMPENSATION
Charger.temperature.AX80_Relay1Temp = getTemperature(adc_value.ADC3_IN9_Relay1_Temp.value) + 17; //16.95
Charger.temperature.AX80_Relay2Temp = getTemperature(adc_value.ADC3_IN8_Relay2_Temp.value) + 18; //17.55
Charger.temperature.AX80_Input_L1_Temp = getTemperature(adc_value.ADC3_IN10_Input_L1_Temp.value) + 13; //12.575
Charger.temperature.AX80_Input_N_L2_Temp = getTemperature(adc_value.ADC3_IN7_Input_N_L2_Temp.value) + 18; //17.9
#else
Charger.temperature.AX80_Relay1Temp = getTemperature(adc_value.ADC3_IN9_Relay1_Temp.value);
Charger.temperature.AX80_Relay2Temp = getTemperature(adc_value.ADC3_IN8_Relay2_Temp.value);
Charger.temperature.AX80_Input_L1_Temp = getTemperature(adc_value.ADC3_IN10_Input_L1_Temp.value);
Charger.temperature.AX80_Input_N_L2_Temp = getTemperature(adc_value.ADC3_IN7_Input_N_L2_Temp.value);
#endif
{
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
int16_t v = 0;
#else
uint8_t v = 0;
#endif
if (Charger.temperature.SystemAmbientTemp > v) v = Charger.temperature.SystemAmbientTemp;
if (Charger.temperature.CcsConnectorTemp > v) v = Charger.temperature.CcsConnectorTemp;
Charger.temperature.Group1_MaxTemp = v;
}
{
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
int16_t v = 0;
#else
uint8_t v = 0;
#endif
if (Charger.temperature.AX80_Relay1Temp > v) v = Charger.temperature.AX80_Relay1Temp;
if (Charger.temperature.AX80_Relay2Temp > v) v = Charger.temperature.AX80_Relay2Temp;
if (Charger.temperature.AX80_Input_L1_Temp > v) v = Charger.temperature.AX80_Input_L1_Temp;
if (Charger.temperature.AX80_Input_N_L2_Temp > v) v = Charger.temperature.AX80_Input_N_L2_Temp;
Charger.temperature.Group2_MaxTemp = v;
}
}
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
filter_move_avg(&adc_value.ADC3_IN9_Relay1_Temp, avg_cal(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN8_Relay2_Temp, avg_cal(ADC3_Buffer_Each[7], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN10_Input_L1_Temp, avg_cal(ADC3_Buffer_Each[8], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN7_Input_N_L2_Temp, avg_cal(ADC3_Buffer_Each[4], ADC3_SAMPLE_COUNT));
#ifdef FUNC_AX80_NEW_TEMP_SENSOR_COMPENSATION
Charger.temperature.AX80_Relay1Temp = getTemperature(adc_value.ADC3_IN9_Relay1_Temp.value) + 17; //16.95
Charger.temperature.AX80_Relay2Temp = getTemperature(adc_value.ADC3_IN8_Relay2_Temp.value) + 18; //17.55
Charger.temperature.AX80_Input_L1_Temp = getTemperature(adc_value.ADC3_IN10_Input_L1_Temp.value) + 13; //12.575
Charger.temperature.AX80_Input_N_L2_Temp = getTemperature(adc_value.ADC3_IN7_Input_N_L2_Temp.value) + 18; //17.9
#else
Charger.temperature.AX80_Relay1Temp = getTemperature(adc_value.ADC3_IN9_Relay1_Temp.value);
Charger.temperature.AX80_Relay2Temp = getTemperature(adc_value.ADC3_IN8_Relay2_Temp.value);
Charger.temperature.AX80_Input_L1_Temp = getTemperature(adc_value.ADC3_IN10_Input_L1_Temp.value);
Charger.temperature.AX80_Input_N_L2_Temp = getTemperature(adc_value.ADC3_IN7_Input_N_L2_Temp.value);
#endif
{
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
int16_t v = 0;
#else
uint8_t v = 0;
#endif
if (Charger.temperature.SystemAmbientTemp > v) v = Charger.temperature.SystemAmbientTemp;
if (Charger.temperature.CcsConnectorTemp > v) v = Charger.temperature.CcsConnectorTemp;
Charger.temperature.Group1_MaxTemp = v;
}
{
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
int16_t v = 0;
#else
uint8_t v = 0;
#endif
if (Charger.temperature.AX80_Relay1Temp > v) v = Charger.temperature.AX80_Relay1Temp;
if (Charger.temperature.AX80_Relay2Temp > v) v = Charger.temperature.AX80_Relay2Temp;
if (Charger.temperature.AX80_Input_L1_Temp > v) v = Charger.temperature.AX80_Input_L1_Temp;
if (Charger.temperature.AX80_Input_N_L2_Temp > v) v = Charger.temperature.AX80_Input_N_L2_Temp;
Charger.temperature.Group2_MaxTemp = v;
}
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
}
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
else if (Charger.m_bModelNameAW48_1P)
{
filter_move_avg(&adc_value.ADC3_IN9_AW48_T1, avg_cal(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN8_AW48_T2, avg_cal(ADC3_Buffer_Each[7], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN10_AW48_T3, avg_cal(ADC3_Buffer_Each[8], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN7_AW48_T4, avg_cal(ADC3_Buffer_Each[4], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN5_AW48_T5, avg_cal(ADC3_Buffer_Each[5], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN11_AW48_T6, avg_cal(ADC3_Buffer_Each[9], ADC3_SAMPLE_COUNT));
#ifdef FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION_20231214
#ifdef FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION_20240508
#ifdef FUNC_AW48_TEMP_SENSOR_WITHOUT_COMPENSATION_20240521
#ifdef FUNC_AW48_TEMP_SENSOR_COMPENSATION_AND_MODIFY_FORMULA_20240522
{
// Charger.temperature.SystemAmbientTemp += 0;
// Charger.temperature.AW48_T1_L1_IN = getTemperature_NACS(adc_value.ADC3_IN9_AW48_T1.value) + 6;
// Charger.temperature.AW48_T2_L2_IN = getTemperature_NACS(adc_value.ADC3_IN8_AW48_T2.value) + 6;
// Charger.temperature.AW48_T3_L1_OUT = getTemperature_NACS(adc_value.ADC3_IN10_AW48_T3.value) + 7;
// Charger.temperature.AW48_T4_L2_OUT = getTemperature_NACS(adc_value.ADC3_IN7_AW48_T4.value) + 7;
// Charger.temperature.AW48_T5_L1_GUN = getTemperature_NACS(adc_value.ADC3_IN5_AW48_T5.value) + 0;
// Charger.temperature.AW48_T6_L2_GUN = getTemperature_NACS(adc_value.ADC3_IN11_AW48_T6.value) + 0;
//
#ifdef FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523
//#ifdef TEST_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523_REMOVE_COMPENSATION
// Charger.temperature.SystemAmbientTemp += 0;
// Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + 0;
// Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + 0;
// Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + 0;
// Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + 0;
// Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
// Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
//#else //TEST_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523_REMOVE_COMPENSATION
#ifdef FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240729
#ifdef FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20241007
double v = 0;
double powCurr = ((double)Charger.Current[0]/100.0) * ((double)Charger.Current[0]/100.0);
double pow48 = 48 * 48;
Charger.temperature.SystemAmbientTemp += 0;
v = powCurr * (17.28 / pow48);
Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + HTK_ROUND_U16(v);
v = powCurr * (18.34 / pow48);
Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + HTK_ROUND_U16(v);
v = powCurr * (20.64 / pow48);
Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + HTK_ROUND_U16(v);
v = powCurr * (22.00 / pow48);
Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + HTK_ROUND_U16(v);
Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
#else //FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20241007
double v = 0;
double powCurr = ((double)Charger.Current[0]/100.0) * ((double)Charger.Current[0]/100.0);
double pow48 = 48 * 48;
Charger.temperature.SystemAmbientTemp += 0;
v = powCurr * (20.53 / pow48);
Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + HTK_ROUND_U16(v);
v = powCurr * (22.03 / pow48);
Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + HTK_ROUND_U16(v);
v = powCurr * (24.39 / pow48);
Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + HTK_ROUND_U16(v);
v = powCurr * (23.39 / pow48);
Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + HTK_ROUND_U16(v);
Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
#endif //FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20241007
#else //FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240729
double v = 0;
double powCurr = ((double)Charger.Current[0]/100.0) * ((double)Charger.Current[0]/100.0);
double pow48 = 48 * 48;
Charger.temperature.SystemAmbientTemp += 0;
v = powCurr * (11.97 / pow48);
Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + HTK_ROUND_U16(v);
v = powCurr * (14.98 / pow48);
Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + HTK_ROUND_U16(v);
v = powCurr * (28.55 / pow48);
Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + HTK_ROUND_U16(v);
v = powCurr * (26.91 / pow48);
Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + HTK_ROUND_U16(v);
Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
#endif //FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240729
//#endif //TEST_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523_REMOVE_COMPENSATION
#else //FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523
Charger.temperature.SystemAmbientTemp += 0;
Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + 6;
Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + 6;
Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + 7;
Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + 7;
Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
#endif //FUNC_AW48_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523
}
#else //FUNC_AW48_TEMP_SENSOR_COMPENSATION_AND_MODIFY_FORMULA_20240522
{
double v = 0;
Charger.temperature.SystemAmbientTemp += HTK_ROUND_U16(v);
Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + HTK_ROUND_U16(v);
Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + HTK_ROUND_U16(v);
Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + HTK_ROUND_U16(v);
Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + HTK_ROUND_U16(v);
Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
}
#endif //FUNC_AW48_TEMP_SENSOR_COMPENSATION_AND_MODIFY_FORMULA_20240522
#else //FUNC_AW48_TEMP_SENSOR_WITHOUT_COMPENSATION_20240521
{
double v = 0;
v = 2.38333 + (-1.7);
Charger.temperature.SystemAmbientTemp += HTK_ROUND_U16(v);
v = 23.8667 + (-4.73333) + (-6.25);
Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + HTK_ROUND_U16(v);
v = 25.45 + (-5.71667) + (-6.5);
Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + HTK_ROUND_U16(v);
v = 28.2833 + (-3.43333);
Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + HTK_ROUND_U16(v);
v = 29.5333 + (-3.56667);
Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + HTK_ROUND_U16(v);
Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
}
#endif //FUNC_AW48_TEMP_SENSOR_WITHOUT_COMPENSATION_20240521
#else //FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION_20240508
{
double v = 0;
v = 2.38333 + (-1.7);
Charger.temperature.SystemAmbientTemp += HTK_ROUND_U16(v);
v = 23.8667 + (-4.73333);
Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + HTK_ROUND_U16(v);
v = 25.45 + (-5.71667);
Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + HTK_ROUND_U16(v);
v = 28.2833 + (-3.43333);
Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + HTK_ROUND_U16(v);
v = 29.5333 + (-3.56667);
Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + HTK_ROUND_U16(v);
Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
}
#endif //FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION_20240508
#else //FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION_20231214
#ifdef FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION
Charger.temperature.SystemAmbientTemp += 3;
Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value) + 24;
Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value) + 26;
Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value) + 29;
Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value) + 30;
Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value) + 0;
Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value) + 0;
#else
Charger.temperature.AW48_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AW48_T1.value);
Charger.temperature.AW48_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AW48_T2.value);
Charger.temperature.AW48_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AW48_T3.value);
Charger.temperature.AW48_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AW48_T4.value);
Charger.temperature.AW48_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AW48_T5.value);
Charger.temperature.AW48_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AW48_T6.value);
#endif
#endif //FUNC_AW48_NEW_TEMP_SENSOR_COMPENSATION_20231214
{
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
int16_t v = 0;
#else
uint8_t v = 0;
#endif
if (Charger.temperature.SystemAmbientTemp > v) v = Charger.temperature.SystemAmbientTemp;
if (Charger.temperature.CcsConnectorTemp > v) v = Charger.temperature.CcsConnectorTemp;
Charger.temperature.Group1_MaxTemp = v;
}
{
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
int16_t v = 0;
#else
uint8_t v = 0;
#endif
#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
if (Charger.temperature.AW48_T1_L1_IN > v) v = Charger.temperature.AW48_T1_L1_IN;
if (Charger.temperature.AW48_T2_L2_IN > v) v = Charger.temperature.AW48_T2_L2_IN;
Charger.temperature.Group2_MaxTemp = v;
v = 0;
if (Charger.temperature.AW48_T3_L1_OUT > v) v = Charger.temperature.AW48_T3_L1_OUT;
if (Charger.temperature.AW48_T4_L2_OUT > v) v = Charger.temperature.AW48_T4_L2_OUT;
Charger.temperature.Group3_MaxTemp = v;
v = 0;
if (Charger.temperature.AW48_T5_L1_GUN > v) v = Charger.temperature.AW48_T5_L1_GUN;
if (Charger.temperature.AW48_T6_L2_GUN > v) v = Charger.temperature.AW48_T6_L2_GUN;
Charger.temperature.Group4_MaxTemp = v;
#else //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
if (Charger.temperature.AW48_T1_L1_IN > v) v = Charger.temperature.AW48_T1_L1_IN;
if (Charger.temperature.AW48_T2_L2_IN > v) v = Charger.temperature.AW48_T2_L2_IN;
if (Charger.temperature.AW48_T5_L1_GUN > v) v = Charger.temperature.AW48_T5_L1_GUN;
if (Charger.temperature.AW48_T6_L2_GUN > v) v = Charger.temperature.AW48_T6_L2_GUN;
Charger.temperature.Group2_MaxTemp = v;
v = 0;
if (Charger.temperature.AW48_T3_L1_OUT > v) v = Charger.temperature.AW48_T3_L1_OUT;
if (Charger.temperature.AW48_T4_L2_OUT > v) v = Charger.temperature.AW48_T4_L2_OUT;
Charger.temperature.Group3_MaxTemp = v;
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#else //MODIFY_AW48_OTP_SPEC_20240522_STEVEN
if (Charger.temperature.AW48_T1_L1_IN > v) v = Charger.temperature.AW48_T1_L1_IN;
if (Charger.temperature.AW48_T2_L2_IN > v) v = Charger.temperature.AW48_T2_L2_IN;
if (Charger.temperature.AW48_T3_L1_OUT > v) v = Charger.temperature.AW48_T3_L1_OUT;
if (Charger.temperature.AW48_T4_L2_OUT > v) v = Charger.temperature.AW48_T4_L2_OUT;
if (Charger.temperature.AW48_T5_L1_GUN > v) v = Charger.temperature.AW48_T5_L1_GUN;
if (Charger.temperature.AW48_T6_L2_GUN > v) v = Charger.temperature.AW48_T6_L2_GUN;
Charger.temperature.Group2_MaxTemp = v;
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN
}
}
#endif //FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
else if (Charger.m_bModelNameAX48_NACS_1P)
{
filter_move_avg(&adc_value.ADC3_IN9_AX48_NACS_T1, avg_cal(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN8_AX48_NACS_T2, avg_cal(ADC3_Buffer_Each[7], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN10_AX48_NACS_T3, avg_cal(ADC3_Buffer_Each[8], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN7_AX48_NACS_T4, avg_cal(ADC3_Buffer_Each[4], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN5_AX48_NACS_T5, avg_cal(ADC3_Buffer_Each[5], ADC3_SAMPLE_COUNT));
filter_move_avg(&adc_value.ADC3_IN11_AX48_NACS_T6, avg_cal(ADC3_Buffer_Each[9], ADC3_SAMPLE_COUNT));
#ifdef FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION_20231214
#ifdef FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION_20240415
#ifdef FUNC_AX48_NACS_TEMP_SENSOR_WITHOUT_COMPENSATION_20240521
#ifdef FUNC_AX48_NACS_TEMP_SENSOR_COMPENSATION_AND_MODIFY_FORMULA_20240522
{
// Charger.temperature.SystemAmbientTemp += 0;
// Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature_NACS(adc_value.ADC3_IN9_AX48_NACS_T1.value) + 6;
// Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature_NACS(adc_value.ADC3_IN8_AX48_NACS_T2.value) + 6;
// Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature_NACS(adc_value.ADC3_IN10_AX48_NACS_T3.value) + 7;
// Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature_NACS(adc_value.ADC3_IN7_AX48_NACS_T4.value) + 7;
// Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature_NACS(adc_value.ADC3_IN5_AX48_NACS_T5.value) + 0;
// Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature_NACS(adc_value.ADC3_IN11_AX48_NACS_T6.value) + 0;
//
#ifdef FUNC_AX48_NACS_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523
double v = 0;
double powCurr = ((double)Charger.Current[0]/100.0) * ((double)Charger.Current[0]/100.0);
double pow48 = 48 * 48;
Charger.temperature.SystemAmbientTemp += 0;
v = powCurr * (6 / pow48);
Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX48_NACS_T1.value) + HTK_ROUND_U16(v);
v = powCurr * (6 / pow48);
Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX48_NACS_T2.value) + HTK_ROUND_U16(v);
v = powCurr * (7 / pow48);
Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX48_NACS_T3.value) + HTK_ROUND_U16(v);
v = powCurr * (12 / pow48);
Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX48_NACS_T4.value) + HTK_ROUND_U16(v);
Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX48_NACS_T5.value) + 0;
Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX48_NACS_T6.value) + 0;
#else //FUNC_AX48_NACS_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523
Charger.temperature.SystemAmbientTemp += 0;
Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX48_NACS_T1.value) + 6;
Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX48_NACS_T2.value) + 6;
Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX48_NACS_T3.value) + 7;
Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX48_NACS_T4.value) + 7;
Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX48_NACS_T5.value) + 0;
Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX48_NACS_T6.value) + 0;
#endif //FUNC_AX48_NACS_TEMP_SENSOR_COMPENSATION_WITH_CURRENT_20240523
}
#else //FUNC_AX48_NACS_TEMP_SENSOR_COMPENSATION_AND_MODIFY_FORMULA_20240522
{
Charger.temperature.SystemAmbientTemp += 0;
Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX48_NACS_T1.value) + 0;
Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX48_NACS_T2.value) + 0;
Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX48_NACS_T3.value) + 0;
Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX48_NACS_T4.value) + 0;
Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX48_NACS_T5.value) + 0;
Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX48_NACS_T6.value) + 0;
}
#endif //FUNC_AX48_NACS_TEMP_SENSOR_COMPENSATION_AND_MODIFY_FORMULA_20240522
#else //FUNC_AX48_NACS_TEMP_SENSOR_WITHOUT_COMPENSATION_20240521
{
double v = 0;
v = 2.38333 + (-1.7);
Charger.temperature.SystemAmbientTemp += HTK_ROUND_U16(v);
v = 23.8667 + (-4.73333) + (-3.7667) + (3);
Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX48_NACS_T1.value) + HTK_ROUND_U16(v);
v = 25.45 + (-5.71667) + (-4.6833) + (3);
Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX48_NACS_T2.value) + HTK_ROUND_U16(v);
v = 28.2833 + (-3.43333) + (-7.0333) + (7);
Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX48_NACS_T3.value) + HTK_ROUND_U16(v);
v = 29.5333 + (-3.56667) + (-4.3333) + (4);
Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX48_NACS_T4.value) + HTK_ROUND_U16(v);
Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX48_NACS_T5.value) + 0;
Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX48_NACS_T6.value) + 0;
}
#endif //FUNC_AX48_NACS_TEMP_SENSOR_WITHOUT_COMPENSATION_20240521
#else //FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION_20240415
{
double v = 0;
v = 2.38333 + (-1.7);
Charger.temperature.SystemAmbientTemp += HTK_ROUND_U16(v);
v = 23.8667 + (-4.73333);
Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX48_NACS_T1.value) + HTK_ROUND_U16(v);
v = 25.45 + (-5.71667);
Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX48_NACS_T2.value) + HTK_ROUND_U16(v);
v = 28.2833 + (-3.43333);
Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX48_NACS_T3.value) + HTK_ROUND_U16(v);
v = 29.5333 + (-3.56667);
Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX48_NACS_T4.value) + HTK_ROUND_U16(v);
Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX48_NACS_T5.value) + 0;
Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX48_NACS_T6.value) + 0;
}
#endif //FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION_20240415
#else //FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION_20231214
#ifdef FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION
Charger.temperature.SystemAmbientTemp += 3;
Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX48_NACS_T1.value) + 24;
Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX48_NACS_T2.value) + 26;
Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX48_NACS_T3.value) + 29;
Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX48_NACS_T4.value) + 30;
Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX48_NACS_T5.value) + 0;
Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX48_NACS_T6.value) + 0;
#else
Charger.temperature.AX48_NACS_T1_L1_IN = getTemperature(adc_value.ADC3_IN9_AX48_NACS_T1.value);
Charger.temperature.AX48_NACS_T2_L2_IN = getTemperature(adc_value.ADC3_IN8_AX48_NACS_T2.value);
Charger.temperature.AX48_NACS_T3_L1_OUT = getTemperature(adc_value.ADC3_IN10_AX48_NACS_T3.value);
Charger.temperature.AX48_NACS_T4_L2_OUT = getTemperature(adc_value.ADC3_IN7_AX48_NACS_T4.value);
Charger.temperature.AX48_NACS_T5_L1_GUN = getTemperature(adc_value.ADC3_IN5_AX48_NACS_T5.value);
Charger.temperature.AX48_NACS_T6_L2_GUN = getTemperature(adc_value.ADC3_IN11_AX48_NACS_T6.value);
#endif
#endif //FUNC_AX48_NACS_NEW_TEMP_SENSOR_COMPENSATION_20231214
{
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
int16_t v = 0;
#else
uint8_t v = 0;
#endif
if (Charger.temperature.SystemAmbientTemp > v) v = Charger.temperature.SystemAmbientTemp;
if (Charger.temperature.CcsConnectorTemp > v) v = Charger.temperature.CcsConnectorTemp;
Charger.temperature.Group1_MaxTemp = v;
}
{
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
int16_t v = 0;
#else
uint8_t v = 0;
#endif
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
if (Charger.temperature.AX48_NACS_T1_L1_IN > v) v = Charger.temperature.AX48_NACS_T1_L1_IN;
if (Charger.temperature.AX48_NACS_T2_L2_IN > v) v = Charger.temperature.AX48_NACS_T2_L2_IN;
Charger.temperature.Group2_MaxTemp = v;
v = 0;
if (Charger.temperature.AX48_NACS_T3_L1_OUT > v) v = Charger.temperature.AX48_NACS_T3_L1_OUT;
if (Charger.temperature.AX48_NACS_T4_L2_OUT > v) v = Charger.temperature.AX48_NACS_T4_L2_OUT;
Charger.temperature.Group3_MaxTemp = v;
v = 0;
if (Charger.temperature.AX48_NACS_T5_L1_GUN > v) v = Charger.temperature.AX48_NACS_T5_L1_GUN;
if (Charger.temperature.AX48_NACS_T6_L2_GUN > v) v = Charger.temperature.AX48_NACS_T6_L2_GUN;
Charger.temperature.Group4_MaxTemp = v;
#else //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
if (Charger.temperature.AX48_NACS_T1_L1_IN > v) v = Charger.temperature.AX48_NACS_T1_L1_IN;
if (Charger.temperature.AX48_NACS_T2_L2_IN > v) v = Charger.temperature.AX48_NACS_T2_L2_IN;
if (Charger.temperature.AX48_NACS_T5_L1_GUN > v) v = Charger.temperature.AX48_NACS_T5_L1_GUN;
if (Charger.temperature.AX48_NACS_T6_L2_GUN > v) v = Charger.temperature.AX48_NACS_T6_L2_GUN;
Charger.temperature.Group2_MaxTemp = v;
v = 0;
if (Charger.temperature.AX48_NACS_T3_L1_OUT > v) v = Charger.temperature.AX48_NACS_T3_L1_OUT;
if (Charger.temperature.AX48_NACS_T4_L2_OUT > v) v = Charger.temperature.AX48_NACS_T4_L2_OUT;
Charger.temperature.Group3_MaxTemp = v;
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
#else //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
if (Charger.temperature.AX48_NACS_T1_L1_IN > v) v = Charger.temperature.AX48_NACS_T1_L1_IN;
if (Charger.temperature.AX48_NACS_T2_L2_IN > v) v = Charger.temperature.AX48_NACS_T2_L2_IN;
if (Charger.temperature.AX48_NACS_T3_L1_OUT > v) v = Charger.temperature.AX48_NACS_T3_L1_OUT;
if (Charger.temperature.AX48_NACS_T4_L2_OUT > v) v = Charger.temperature.AX48_NACS_T4_L2_OUT;
if (Charger.temperature.AX48_NACS_T5_L1_GUN > v) v = Charger.temperature.AX48_NACS_T5_L1_GUN;
if (Charger.temperature.AX48_NACS_T6_L2_GUN > v) v = Charger.temperature.AX48_NACS_T6_L2_GUN;
Charger.temperature.Group2_MaxTemp = v;
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
}
}
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
else
{
#ifdef FUNC_TEMP_SENSOR_WITH_NEG_VALUE
int16_t v = 0;
#else
uint8_t v = 0;
#endif
if (Charger.temperature.SystemAmbientTemp > v) v = Charger.temperature.SystemAmbientTemp;
if (Charger.temperature.CcsConnectorTemp > v) v = Charger.temperature.CcsConnectorTemp;
Charger.temperature.Group1_MaxTemp = v;
}
#endif
//PE
filter_move_avg(&adc_value.ADC3_IN4_GMI_VL1, avg_cal(ADC3_Buffer_Each[3], ADC3_SAMPLE_COUNT));
#ifdef FUNC_AW48_KENNY_TEST_DOUBLE_GF_ADC_VAL
if (Charger.m_bModelNameAW48_1P)
{
adc_value.ADC3_IN4_GMI_VL1.value *= 2;
}
#endif
//CT
#ifndef FUNC_REPLACE_ADC_WITH_METER_IC
Current_filter_move_avg(&adc_value.ADC3_IN7_Current_L1, cRms_cal(ADC3_Buffer_Each[4], ADC3_SAMPLE_COUNT));
Current_filter_move_avg(&adc_value.ADC3_IN5_Current_L2, cRms_cal(ADC3_Buffer_Each[5], ADC3_SAMPLE_COUNT));
Current_filter_move_avg(&adc_value.ADC3_IN11_Current_L3, cRms_cal(ADC3_Buffer_Each[9], ADC3_SAMPLE_COUNT));
#endif
#ifdef FUNC_DETECT_PP
if (Charger.m_bDetectPP)
{
filter_move_avg(&adc_value.ADC3_IN6_Gun_Detec, avg_cal(ADC3_Buffer_Each[6], ADC3_SAMPLE_COUNT));
{
#ifdef VO_SIMU_PP
if (Charger.m_VOCode.m_EnableSimuPP)
{
UpdatePPInfo_CurrVal(&Charger.m_PPInfo, Charger.m_SimuData.m_PPCurr);
}
else
{
UpdatePPInfo_AdcVal(&Charger.m_PPInfo, adc_value.ADC3_IN6_Gun_Detec.value);
}
#else //VO_SIMU_PP
UpdatePPInfo_AdcVal(&Charger.m_PPInfo, adc_value.ADC3_IN6_Gun_Detec.value);
#endif //VO_SIMU_PP
}
}
#endif //FUNC_DETECT_PP
#ifdef FUNC_DETECT_PP_NACS
if (Charger.m_bDetectPP_NACS)
{
filter_move_avg(&adc_value.ADC3_IN6_Gun_Detec, avg_cal(ADC3_Buffer_Each[6], ADC3_SAMPLE_COUNT));
{
//#ifdef VO_SIMU_PP
// if (Charger.m_VOCode.m_EnableSimuPP)
// {
// UpdatePPInfo_CurrVal(&Charger.m_PPInfo, Charger.m_SimuData.m_PPCurr);
// }
// else
// {
// UpdatePPInfo_AdcVal(&Charger.m_PPInfo, adc_value.ADC3_IN6_Gun_Detec.value);
// }
//#else //VO_SIMU_PP
// UpdatePPInfo_AdcVal(&Charger.m_PPInfo, adc_value.ADC3_IN6_Gun_Detec.value);
//#endif //VO_SIMU_PP
}
}
#endif //FUNC_DETECT_PP_NACS
//Correction
//VT
#ifdef TEST_ACXXX_FAKEDATA
#ifdef TEST_AC110_FAKEDATA
Charger.Voltage[0] = rand() % 50 + 11000;
Charger.Voltage[1] = rand() % 50 + 11000;
Charger.Voltage[2] = rand() % 50 + 11000;
#endif
#ifdef TEST_AC220_FAKEDATA
Charger.Voltage[0] = rand() % 50 + 22000;
Charger.Voltage[1] = rand() % 50 + 22000;
Charger.Voltage[2] = rand() % 50 + 22000;
#endif
#else //TEST_ACXXX_FAKEDATA
#ifndef FUNC_REPLACE_ADC_WITH_METER_IC
Charger.Voltage[0] = (uint16_t) (((adc_value.ADC3_IN9_Voltage_L1.value)*Charger.coefficient.gain_v[0])+Charger.coefficient.offset_v[0]) ;
Charger.Voltage[1] = (uint16_t) (((adc_value.ADC3_IN8_Voltage_L2.value)*Charger.coefficient.gain_v[1])+Charger.coefficient.offset_v[1]) ;
Charger.Voltage[2] = (uint16_t) (((adc_value.ADC3_IN10_Voltage_L3.value)*Charger.coefficient.gain_v[2])+Charger.coefficient.offset_v[2]) ;
#endif
#endif //TEST_ACXXX_FAKEDATA
#ifndef FUNC_REPLACE_ADC_WITH_METER_IC
//CT
Charger.Current[0] = (uint16_t)((adc_value.ADC3_IN7_Current_L1.value*Charger.coefficient.gain_c[0])+Charger.coefficient.offset_c[0]);
Charger.Current[1] = (uint16_t)((adc_value.ADC3_IN5_Current_L2.value*Charger.coefficient.gain_c[1])+Charger.coefficient.offset_c[1]);
Charger.Current[2] = (uint16_t)((adc_value.ADC3_IN11_Current_L3.value*Charger.coefficient.gain_c[2])+Charger.coefficient.offset_c[2]);
#endif
//GMI
Charger.Gmi_Voltage = (uint16_t) (((adc_value.ADC3_IN4_GMI_VL1.value)*Charger.coefficient.gain_gmi[0])+Charger.coefficient.offset_gmi[0]) ;
#ifdef COLD_LOAD_PICKUP
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
// check Power drop is not alarm
// Power drop detection
#ifdef FUNC_REPLACE_ADC_WITH_METER_IC
if((Charger.Voltage[0] <= ALARM_SPEC_POWER_DROP) && (!Charger.AC_DripisTure) && (Charger.Mode != MODE_INITIAL))
#else
if((vRms_cal2(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT) <= ALARM_SPEC_POWER_DROP) && (!Charger.AC_DripisTure) && (Charger.Mode != MODE_INITIAL))
#endif
{
if(Charger.counter.AC_Drip.fail > 1000)
{
//Charger.memory.EVSE_Config.data.item.isDispDebug = OFF;
if((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))
{
Charger.memory.coldLoadPickUp.data.item.isEnable = ON;
Charger.memory.coldLoadPickUp.data.item.DateTime.year = Charger.cycle_info.startDateTime.year;
Charger.memory.coldLoadPickUp.data.item.DateTime.month = Charger.cycle_info.startDateTime.month;
Charger.memory.coldLoadPickUp.data.item.DateTime.day = Charger.cycle_info.startDateTime.day;
Charger.memory.coldLoadPickUp.data.item.DateTime.hour = Charger.cycle_info.startDateTime.hour;
Charger.memory.coldLoadPickUp.data.item.DateTime.min = Charger.cycle_info.startDateTime.min;
Charger.memory.coldLoadPickUp.data.item.DateTime.sec = Charger.cycle_info.startDateTime.sec;
Charger.memory.coldLoadPickUp.data.item.Duration = Charger.cycle_info.Duration;
sprintf(Charger.memory.coldLoadPickUp.data.item.PlugType, EVSE_CONNECTOR_TYPE);
Charger.memory.coldLoadPickUp.data.item.powerSum = Charger.cycle_info.Power_Consumption;
Charger.memory.coldLoadPickUp.data.item.startType = Charger.cycle_info.StartType;
//memcpy(Charger.memory.coldLoadPickUp.data.item.user, Charger.rfid.currentCard, 16);
Charger.memory.coldLoadPickUp.op_bits.update = ON;
}
Charger.AC_DripisTure = ON ;
}
else
Charger.counter.AC_Drip.fail ++ ;
}
#ifdef FUNC_REPLACE_ADC_WITH_METER_IC
else if((Charger.Voltage[0] > (ALARM_SPEC_UV+ALARM_SPEC_OUV_HYSTERESIS)))
#else
else if((vRms_cal2(ADC3_Buffer_Each[0], ADC3_SAMPLE_COUNT) > (ALARM_SPEC_UV+ALARM_SPEC_OUV_HYSTERESIS)))
#endif
{
Charger.counter.AC_Drip.fail = 0 ;
if(Charger.AC_DripisTure)
{
Charger.AC_DripisTure = OFF ;
DEBUG_INFO("Alarm AC Drip recover.\r\n");
}
}
}
#endif //COLD_LOAD_PICKUP
#ifndef FUNC_POWER_CONSUMPTION_BY_METER_IC
// Power accumulate calculation
if(timer[TIMER_IDX_POWER].isAlarm)
{
timeTick.timeTick_End = HAL_GetTick();
timeTick.timeTick_Delta = timeTick.timeTick_End - timeTick.timeTick_Start;
timeTick.timeTick_Start = timeTick.timeTick_End;
//L1 Power Consumption
if(Charger.memory.EVSE_Config.data.item.Power_Consumption_L1_Cumulative >= 0xFFFFFFFF)
{
Charger.memory.EVSE_Config.data.item.Power_Consumption_L1_Cumulative = 0;
}
else
{ //unit : 0.0001kW , 0.1W *10 = W
Charger.memory.EVSE_Config.data.item.Power_Consumption_L1_Cumulative += (uint32_t)((Charger.Voltage[0]/100.0)*(Charger.Current[0]/100.0)*(timeTick.timeTick_Delta/3600000.0)*10.0);
}
//L2 Power Consumption
if(Charger.memory.EVSE_Config.data.item.Power_Consumption_L2_Cumulative >= 0xFFFFFFFF)
{
Charger.memory.EVSE_Config.data.item.Power_Consumption_L2_Cumulative = 0;
}
else
{ //unit : 0.0001kW , 0.1W *10 = W
Charger.memory.EVSE_Config.data.item.Power_Consumption_L2_Cumulative += (uint32_t)((Charger.Voltage[1]/100.0)*(Charger.Current[1]/100.0)*(timeTick.timeTick_Delta/3600000.0)*10.0);
}
//L3 Power Consumption
if(Charger.memory.EVSE_Config.data.item.Power_Consumption_L3_Cumulative >= 0xFFFFFFFF)
{
Charger.memory.EVSE_Config.data.item.Power_Consumption_L3_Cumulative = 0;
}
else
{ //unit : 0.0001kW , 0.1W *10 = W
Charger.memory.EVSE_Config.data.item.Power_Consumption_L3_Cumulative += (uint32_t)((Charger.Voltage[2]/100.0)*(Charger.Current[2]/100.0)*(timeTick.timeTick_Delta/3600000.0)*10.0);
}
//totle Power Consumption
if(Charger.memory.EVSE_Config.data.item.Power_Consumption_Cumulative >= 0xFFFFFFFF)
{
Charger.memory.EVSE_Config.data.item.Power_Consumption_Cumulative = 0;
}
else
{ //unit : 0.0001kW , 0.1W *10 = W
Charger.memory.EVSE_Config.data.item.Power_Consumption_Cumulative = (Charger.memory.EVSE_Config.data.item.Power_Consumption_L1_Cumulative +
Charger.memory.EVSE_Config.data.item.Power_Consumption_L2_Cumulative +
Charger.memory.EVSE_Config.data.item.Power_Consumption_L3_Cumulative) ;
}
if(++updateMemReq>180)
{
Charger.memory.EVSE_Config.op_bits.update = ON;
updateMemReq = 0;
}
timerRefresh(TIMER_IDX_POWER);
}
#endif //FUNC_POWER_CONSUMPTION_BY_METER_IC
if(HAL_ADC_Start_DMA(&hadc3, (uint32_t*)&ADC3_Buffer, ADC3_CHANEL_COUNT*ADC3_SAMPLE_COUNT)!=HAL_OK)Error_Handler();
}
osDelay(1);
}
/* USER CODE END StartAdcTask */
}
/* USER CODE BEGIN Header_StartTimeoutTask */
/**
* @brief Function implementing the timeoutTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTimeoutTask */
void StartTimeoutTask(void const * argument)
{
/* USER CODE BEGIN StartTimeoutTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
IdleUntilReadAllMemory();
#endif
breathe.isUp = ON;
for(int idx=0;idx timer[idx].timeoutSpec)
{
timer[idx].isAlarm = ON;
}
else
{
timer[idx].isAlarm = OFF;
}
}
else
{
timer[idx].startTime = HAL_GetTick();
timer[idx].isAlarm = OFF;
}
}
#ifdef FUNC_GUN_LOCK
if (Charger.m_bUseGunLock)
{
GL_Proc();
}
#endif //FUNC_GUN_LOCK
/*
Blink timer process
*/
for(int idx=0;idx (blinker[idx].isOn ? blinker[idx].blinkOnSpec : blinker[idx].blinkOffSpec))
{
if(blinker[idx].blinkCount >= blinker[idx].blinkCountSpec)
{
if((HAL_GetTick() - blinker[idx].resetStartTime) > blinker[idx].blinkRestSpec)
{
if(!blinker[idx].blinkRestSpec) //no rest case
blinker[idx].blinkisFinish = ON ;
blinker[idx].blinkCount = 0;
#ifdef FUNC_AW48_NET_LED
if (Charger.m_bModelNameAW48_1P)
{
if (idx == BLINKER_IDX_LED_NET)
{
Proc_NetLedActionSubState();
}
}
#endif
}
else
{
blinker[idx].isOn= OFF;
blinker[idx].blinkisFinish = ON ;
}
}
else
{
if(blinker[idx].isOn)
blinker[idx].blinkCount++;
blinker[idx].blinkStartTime = HAL_GetTick();
blinker[idx].resetStartTime = HAL_GetTick();
blinker[idx].isOn ^= ON;
if(blinker[idx].blinkRestSpec > 0) //had rest case
blinker[idx].blinkisFinish = OFF ;
}
}
}
/*
Flick timer process
*/
for(int idx=0;idx (flicker[idx].isOn ? flicker[idx].OnSpec : flicker[idx].OffSpec))
{
flicker[idx].StartTime = HAL_GetTick();
flicker[idx].isOn ^= ON;
}
}
/*
Breathe timer process
*/
if(breathe.isUp)
{
breathe.countPause = 0;
breathe.countDown = breathe.timeDown;
if(++breathe.countUp >= breathe.timeUp)
breathe.isUp = OFF;
breathe.duty[0] = breathe.RGB[0]*breathe.countUp/breathe.timeUp;
breathe.duty[1] = breathe.RGB[1]*breathe.countUp/breathe.timeUp;
breathe.duty[2] = breathe.RGB[2]*breathe.countUp/breathe.timeUp;
breathe.duty[3] = breathe.RGB[3]*breathe.countUp/breathe.timeUp;
}
else
{
breathe.countUp = 1000*BREATHE_LED_LOW_BOUNDARY/breathe.timeDown;
if(breathe.countDown <= 1000*BREATHE_LED_LOW_BOUNDARY/breathe.timeDown)
{
//if(++breathe.countPause>250) //breathe ON->oFF need delay nedd Uncomment annotations
breathe.isUp = ON;
}
else
{
if(breathe.countDown > 1000*BREATHE_LED_LOW_BOUNDARY/breathe.timeDown)
breathe.countDown -=1;
}
breathe.duty[0] = breathe.RGB[0]*breathe.countDown/breathe.timeDown;
breathe.duty[1] = breathe.RGB[1]*breathe.countDown/breathe.timeDown;
breathe.duty[2] = breathe.RGB[2]*breathe.countDown/breathe.timeDown;
breathe.duty[3] = breathe.RGB[3]*breathe.countDown/breathe.timeDown;
}
osDelay(1);
}
/* USER CODE END StartTimeoutTask */
}
#ifdef FUNC_ENABLE_USART1_RFID
/* USER CODE BEGIN Header_StartRfidTask */
/**
* @brief Function implementing the rfidTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartRfidTask */
void StartRfidTask(void const * argument)
{
/* USER CODE BEGIN StartRfidTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
IdleUntilReadAllMemory();
#endif
//rrfid
uint8_t cardType = 0;
uint8_t tmpBuf[32];
uint8_t tx[UART_BUFFER_SIZE>>4];
uint8_t tx_len;
HAL_GPIO_WritePin(OUT_RFID_Reset_GPIO_Port, OUT_RFID_Reset_Pin, GPIO_PIN_SET);
/* Infinite loop */
for(;;)
{
// Read card SN
if(!Charger.rfid.op_bits.reqHalt && !Charger.rfid.op_bits.reqBlockRead)
{
switch(cardType)
{
case 0x00:
tx_len = 4;
tx[0] = tx_len - 0x01;
tx[1] = RFID_CMD_REQUEST_SN_14443A;
tx[2] = 0x01;
tx[3] = rfidCheckSumCal(tx, tx_len-1);
cardType++;
break;
case 0x01:
tx_len = 5;
tx[0] = tx_len - 0x01;
tx[1] = RFID_CMD_REQUEST_SN_14443B;
tx[2] = 0x00;
tx[3] = 0x00;
tx[4] = rfidCheckSumCal(tx, tx_len-1);
cardType++;
break;
case 0x02:
tx_len = 9;
tx[0] = tx_len - 0x01;
tx[1] = RFID_CMD_REQUEST_SN_FELICA;
tx[2] = 0x06;
tx[3] = 0x00;
tx[4] = 0xff;
tx[5] = 0xff;
tx[6] = 0x01;
tx[7] = 0x00;
tx[8] = rfidCheckSumCal(tx, tx_len-1);
cardType++;
break;
default:
cardType = 0;
break;
}
HAL_UART_Transmit(&RFID_USART, (uint8_t *)tx, tx_len, 0xffff);
osDelay(100);
}
if(Charger.rfid.op_bits.reqHalt)
{
tx_len = 3;
tx[0] = tx_len - 0x01;
tx[1] = RFID_CMD_HALT_14443A;
tx[2] = rfidCheckSumCal(tx, tx_len-1);
HAL_UART_Transmit(&RFID_USART, (uint8_t *)tx, tx_len, 0xffff);
osDelay(100);
}
if(Charger.rfid.op_bits.reqBlockRead)
{
tx_len = 0x0b;
tx[0] = tx_len - 0x01;
tx[1] = RFID_CMD_BLOCK_READ;
tx[2] = Charger.rfid.keyType;
tx[3] = Charger.rfid.targetBlock;
tx[4] = Charger.rfid.key[0];
tx[5] = Charger.rfid.key[1];
tx[6] = Charger.rfid.key[2];
tx[7] = Charger.rfid.key[3];
tx[8] = Charger.rfid.key[4];
tx[9] = Charger.rfid.key[5];
tx[10] = rfidCheckSumCal(tx, tx_len-1);
HAL_UART_Transmit(&RFID_USART, (uint8_t *)tx, tx_len, 0xffff);
osDelay(100);
}
// RFID module feedback process
if(UART_RFID_recv_end_flag == ON)
{
if((rfidCheckSumCal(UART_RFID_rx_buffer, UART_RFID_rx_buffer[0]) == UART_RFID_rx_buffer[UART_RFID_rx_buffer[0]]) && (Charger.Mode != MODE_INITIAL) && (Charger.Mode != MODE_ALARM))
{
switch(UART_RFID_rx_buffer[1])
{
case RFID_CMD_LED:
break;
case RFID_CMD_REQUEST_SN_14443A:
if(UART_RFID_rx_buffer[0] == 9)
{
Charger.rfid.snType = RFID_SN_TYPE_4BYTE;
memset(&Charger.rfid.data_Sn[0], 0x00, ARRAY_SIZE(Charger.rfid.data_Sn));
for(uint8_t idx=0;idx<16;idx++)
{
if(idx<4)
{
Charger.rfid.data_Sn[idx] = UART_RFID_rx_buffer[idx+2];
}
else
{
Charger.rfid.data_Sn[idx] = 0x00;
}
}
if(isMode(MODE_IDLE))
{
memset(&Charger.rfid.currentCard[0], 0x00, ARRAY_SIZE(Charger.rfid.currentCard));
}
if(Charger.memory.EVSE_Config.data.item.RFID_SN_Endian)
{
DEBUG_INFO("RFID SN: %02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
sprintf((char *)tmpBuf, "%02X%02X%02X%02X", Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));
}
else
{
DEBUG_INFO("RFID SN: %02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3]);
sprintf((char *)tmpBuf, "%02X%02X%02X%02X", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3]);
memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));
}
}
else if(UART_RFID_rx_buffer[0] == 0x0c)
{
Charger.rfid.snType = RFID_SN_TYPE_7BYTE;
memset(&Charger.rfid.data_Sn[0], 0x00, ARRAY_SIZE(Charger.rfid.data_Sn));
for(uint8_t idx=0;idx<16;idx++)
{
if(idx<7)
{
Charger.rfid.data_Sn[idx] = UART_RFID_rx_buffer[idx+2];
}
else
{
Charger.rfid.data_Sn[idx] = 0x00;
}
}
if(isMode(MODE_IDLE))
{
memset(&Charger.rfid.currentCard[0], 0x00, ARRAY_SIZE(Charger.rfid.currentCard));
}
if(Charger.memory.EVSE_Config.data.item.RFID_SN_Endian)
{
DEBUG_INFO("RFID SN: %02X%02X%02X%02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[6], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
sprintf((char *)tmpBuf, "%02X%02X%02X%02X%02X%02X%02X", Charger.rfid.data_Sn[6], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));
}
else
{
DEBUG_INFO("RFID SN: %02X%02X%02X%02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[6]);
sprintf((char *)tmpBuf, "%02X%02X%02X%02X%02X%02X%02X", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[6]);
memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));
}
}
//PH
if (Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_PH )
{
if(UART_RFID_rx_buffer[0] >= 9)
{
if(isMode(MODE_IDLE))
{
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
{
Charger.rfid.targetBlock = 0x02;
Charger.rfid.keyType = 0x00;
memset(&Charger.rfid.key[0], 0xff, 6);
Charger.rfid.op_bits.reqBlockRead = ON;
//control in RFID_CMD_BLOCK_READ to Valid_RFID_SN
}
}
else if(isMode(MODE_CHARGING) || isMode(MODE_STOP))
{
if ((Array_data_Check(Charger.rfid.currentCard,Charger.rfid.nowCard))&&(Charger.cycle_info.StartType != START_METHOD_BLE))
{
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
{
Charger.rfid.op_bits.reqStop = ON;
setLedMotion(LED_ACTION_RFID_PASS);
Charger.speaker.motion = SPEAKER_SHORT;
timerEnable(TIMER_IDX_LED_TEMP, 3000);
}
DEBUG_WARN("reqStop = ON.\r\n");
}
else
{
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
{
setLedMotion(LED_ACTION_RFID_FAIL);
Charger.speaker.motion = SPEAKER_BLINK;
blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
timerEnable(TIMER_IDX_LED_TEMP, 3000);
}
DEBUG_WARN("reqStop = Fail\r\n");
}
Charger.rfid.op_bits.reqHalt = ON;
Charger.rfid.op_bits.reqBlockRead = OFF;
}
}
}
//White List
else if (Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_LOCAL_LIST)
{
DEBUG_WARN("OfflinePolicy is White List\r\n");
}
//Free
else if (Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_FREE)
{
Charger.rfid.op_bits.reqHalt = ON;
Charger.rfid.op_bits.reqBlockRead = OFF;
if(isMode(MODE_IDLE))
{
for(uint8_t idx=0;idx<16;idx++)
{
Charger.rfid.currentCard[idx] = Charger.rfid.data_Sn[idx];
}
Charger.rfid.op_bits.reqStart = ON;
memcpy(&Charger.rfid.currentCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
setLedMotion(LED_ACTION_RFID_PASS);
Charger.speaker.motion = SPEAKER_SHORT;
timerEnable(TIMER_IDX_LED_TEMP, 3000);
}
DEBUG_WARN("RFID authorize pass.\r\n");
}
else if(isMode(MODE_CHARGING) || isMode(MODE_STOP))
{
DEBUG_WARN("RFID authorize pass.\r\n");
if (Array_data_Check(Charger.rfid.currentCard,Charger.rfid.nowCard))
{
Charger.rfid.op_bits.reqStop = ON;
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
setLedMotion(LED_ACTION_RFID_PASS);
Charger.speaker.motion = SPEAKER_SHORT;
timerEnable(TIMER_IDX_LED_TEMP, 3000);
}
DEBUG_WARN("reqStop = ON.\r\n");
}
else
{
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
setLedMotion(LED_ACTION_RFID_FAIL);
Charger.speaker.motion = SPEAKER_BLINK;
blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
timerEnable(TIMER_IDX_LED_TEMP, 3000);
}
DEBUG_WARN("reqStop = Fail\r\n");
}
}
}
//NO charger
else // Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_NO_CHARGING
{
setLedMotion(LED_ACTION_RFID_FAIL);
Charger.speaker.motion = SPEAKER_BLINK;
blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
timerEnable(TIMER_IDX_LED_TEMP, 3000);
Charger.rfid.op_bits.reqHalt = ON;
Charger.rfid.op_bits.reqBlockRead = OFF;
DEBUG_WARN("It is RFID NO charger mode \r\n");
}
break;
case RFID_CMD_REQUEST_SN_14443B:
if(UART_RFID_rx_buffer[1] == RFID_CMD_REQUEST_SN_14443B)
{
Charger.rfid.snType = RFID_SN_TYPE_14443B;
memset(&Charger.rfid.data_Sn[0], 0x00, ARRAY_SIZE(Charger.rfid.data_Sn));
for(uint8_t idx=0;idx<16;idx++)
{
if(idx<13)
{
Charger.rfid.data_Sn[idx] = UART_RFID_rx_buffer[idx+2];
}
}
if(isMode(MODE_IDLE))
memset(&Charger.rfid.nowCard[0], 0x00, ARRAY_SIZE(Charger.rfid.nowCard));
if(Charger.memory.EVSE_Config.data.item.RFID_SN_Endian)
{
DEBUG_INFO("RFID SN: %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[12], Charger.rfid.data_Sn[11], Charger.rfid.data_Sn[10], Charger.rfid.data_Sn[9], Charger.rfid.data_Sn[8], Charger.rfid.data_Sn[7], Charger.rfid.data_Sn[6], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
sprintf((char *)tmpBuf, "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", Charger.rfid.data_Sn[12], Charger.rfid.data_Sn[11], Charger.rfid.data_Sn[10], Charger.rfid.data_Sn[9], Charger.rfid.data_Sn[8], Charger.rfid.data_Sn[7], Charger.rfid.data_Sn[6], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.nowCard));
}
else
{
DEBUG_INFO("RFID SN: %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[6], Charger.rfid.data_Sn[7], Charger.rfid.data_Sn[8], Charger.rfid.data_Sn[9], Charger.rfid.data_Sn[10], Charger.rfid.data_Sn[11], Charger.rfid.data_Sn[12]);
sprintf((char *)tmpBuf, "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[6], Charger.rfid.data_Sn[7], Charger.rfid.data_Sn[8], Charger.rfid.data_Sn[9], Charger.rfid.data_Sn[10], Charger.rfid.data_Sn[11], Charger.rfid.data_Sn[12]);
memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.nowCard));
}
}
//White List
if (Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_LOCAL_LIST)
{
DEBUG_WARN("OfflinePolicy is White List\r\n");
}
//Free
else if (Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_FREE)
{
Charger.rfid.op_bits.reqHalt = ON;
Charger.rfid.op_bits.reqBlockRead = OFF;
if(isMode(MODE_IDLE))
{
for(uint8_t idx=0;idx<16;idx++)
{
Charger.rfid.currentCard[idx] = Charger.rfid.data_Sn[idx];
}
Charger.rfid.op_bits.reqStart = ON;
memcpy(&Charger.rfid.currentCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
setLedMotion(LED_ACTION_RFID_PASS);
Charger.speaker.motion = SPEAKER_SHORT;
timerEnable(TIMER_IDX_LED_TEMP, 3000);
}
DEBUG_WARN("RFID authorize pass.\r\n");
}
else if(isMode(MODE_CHARGING) || isMode(MODE_STOP))
{
DEBUG_WARN("RFID authorize pass.\r\n");
if (Array_data_Check(Charger.rfid.currentCard,Charger.rfid.nowCard))
{
Charger.rfid.op_bits.reqStop = ON;
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
setLedMotion(LED_ACTION_RFID_PASS);
Charger.speaker.motion = SPEAKER_SHORT;
timerEnable(TIMER_IDX_LED_TEMP, 3000);
}
DEBUG_WARN("reqStop = ON.\r\n");
}
else
{
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
setLedMotion(LED_ACTION_RFID_FAIL);
Charger.speaker.motion = SPEAKER_BLINK;
blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
timerEnable(TIMER_IDX_LED_TEMP, 3000);
}
DEBUG_WARN("reqStop = Fail\r\n");
}
}
}
//NO charger
else // Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_NO_CHARGING
{
setLedMotion(LED_ACTION_RFID_FAIL);
Charger.speaker.motion = SPEAKER_BLINK;
blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
timerEnable(TIMER_IDX_LED_TEMP, 3000);
Charger.rfid.op_bits.reqHalt = ON;
Charger.rfid.op_bits.reqBlockRead = OFF;
DEBUG_WARN("It is RFID NO charger mode \r\n");
}
break;
case RFID_CMD_REQUEST_SN_FELICA:
if(UART_RFID_rx_buffer[1] == RFID_CMD_REQUEST_SN_FELICA)
{
Charger.rfid.snType = RFID_SN_TYPE_FELICA;
memset(&Charger.rfid.data_Sn[0], 0x00, ARRAY_SIZE(Charger.rfid.data_Sn));
for(uint8_t idx=0;idx<16;idx++)
{
if(idx<6)
{
Charger.rfid.data_Sn[idx] = UART_RFID_rx_buffer[idx+6];
}
}
if(isMode(MODE_IDLE))
memset(&Charger.rfid.nowCard[0], 0x00, ARRAY_SIZE(Charger.rfid.nowCard));
if(Charger.memory.EVSE_Config.data.item.RFID_SN_Endian)
{
DEBUG_INFO("RFID SN: %02X%02X%02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
sprintf((char *)tmpBuf, "%02X%02X%02X%02X%02X%02X", Charger.rfid.data_Sn[5], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[0]);
memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.nowCard));
}
else
{
DEBUG_INFO("RFID SN: %02X%02X%02X%02X%02X%02X\r\n", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[5]);
sprintf((char *)tmpBuf, "%02X%02X%02X%02X%02X%02X", Charger.rfid.data_Sn[0], Charger.rfid.data_Sn[1], Charger.rfid.data_Sn[2], Charger.rfid.data_Sn[3], Charger.rfid.data_Sn[4], Charger.rfid.data_Sn[5]);
memcpy(&Charger.rfid.nowCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.nowCard));
}
}
//White List
if (Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_LOCAL_LIST)
{
DEBUG_WARN("OfflinePolicy is White List\r\n");
}
//Free
else if (Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_FREE)
{
Charger.rfid.op_bits.reqHalt = ON;
Charger.rfid.op_bits.reqBlockRead = OFF;
if(isMode(MODE_IDLE))
{
for(uint8_t idx=0;idx<16;idx++)
{
Charger.rfid.currentCard[idx] = Charger.rfid.data_Sn[idx];
}
Charger.rfid.op_bits.reqStart = ON;
memcpy(&Charger.rfid.currentCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard));
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
setLedMotion(LED_ACTION_RFID_PASS);
Charger.speaker.motion = SPEAKER_SHORT;
timerEnable(TIMER_IDX_LED_TEMP, 3000);
}
DEBUG_WARN("RFID authorize pass.\r\n");
}
else if(isMode(MODE_CHARGING) || isMode(MODE_STOP))
{
DEBUG_WARN("RFID authorize pass.\r\n");
if (Array_data_Check(Charger.rfid.currentCard,Charger.rfid.nowCard))
{
Charger.rfid.op_bits.reqStop = ON;
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
setLedMotion(LED_ACTION_RFID_PASS);
Charger.speaker.motion = SPEAKER_SHORT;
timerEnable(TIMER_IDX_LED_TEMP, 3000);
}
DEBUG_WARN("reqStop = ON.\r\n");
}
else
{
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
setLedMotion(LED_ACTION_RFID_FAIL);
Charger.speaker.motion = SPEAKER_BLINK;
blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
timerEnable(TIMER_IDX_LED_TEMP, 3000);
}
DEBUG_WARN("reqStop = Fail\r\n");
}
}
}
//NO charger
else // Charger.memory.EVSE_Config.data.item.OfflinePolicy == RFID_USER_AUTH_NO_CHARGING
{
setLedMotion(LED_ACTION_RFID_FAIL);
Charger.speaker.motion = SPEAKER_BLINK;
blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
timerEnable(TIMER_IDX_LED_TEMP, 3000);
Charger.rfid.op_bits.reqHalt = ON;
Charger.rfid.op_bits.reqBlockRead = OFF;
DEBUG_WARN("It is RFID NO charger mode \r\n");
}
osDelay(1000);
break;
case RFID_CMD_BLOCK_READ:
if(UART_RFID_rx_buffer[1] == RFID_CMD_BLOCK_READ)
{
memcpy(Charger.rfid.data_Block, &UART_RFID_rx_buffer[2], 0x10);
Charger.rfid.op_bits.reqHalt = ON;
Charger.rfid.op_bits.reqBlockRead = OFF;
//RFID_PH
if(Valid_RFID_SN())
{
if(isMode(MODE_IDLE))
{
Charger.rfid.op_bits.reqStart = ON;
setLedMotion(LED_ACTION_RFID_PASS);
Charger.speaker.motion = SPEAKER_SHORT;
timerEnable(TIMER_IDX_LED_TEMP, 3000);
memcpy(&Charger.rfid.currentCard[0], &tmpBuf[0], ARRAY_SIZE(Charger.rfid.currentCard)); }
else if(isMode(MODE_CHARGING) || isMode(MODE_STOP))
{
Charger.rfid.op_bits.reqStop = ON;
}
DEBUG_WARN("RFID authorize pass.\r\n");
}
else
{
setLedMotion(LED_ACTION_RFID_FAIL);
Charger.speaker.motion = SPEAKER_BLINK;
blinkerTimeSet(BLINKER_IDX_SPEAKER, 100, 100, SPEAK_RESET_RFID_TIME, 3) ; // SPEAK_RESET_RFID_TIME -> Avoid repeating
timerEnable(TIMER_IDX_LED_TEMP, 3000);
DEBUG_WARN("RFID authorize fault.\r\n");
}
}
break;
case RFID_CMD_BLOCK_WRITE:
break;
case RFID_CMD_HALT_14443A:
if(UART_RFID_rx_buffer[1] == RFID_CMD_HALT_14443A)
{
Charger.rfid.op_bits.reqHalt = OFF;
DEBUG_INFO("RFID card(14443A) halt succcess.\r\n");
}
break;
case RFID_CMD_HALT_14443B:
if(UART_RFID_rx_buffer[1] == RFID_CMD_HALT_14443B)
{
Charger.rfid.op_bits.reqHalt = OFF;
DEBUG_INFO("RFID card(14443B) halt succcess.\r\n");
}
break;
case (RFID_CMD_BLOCK_READ ^ 0xff):
Charger.rfid.op_bits.reqBlockRead = OFF;
DEBUG_WARN("RFID cread block fail.\r\n");
break;
default:
break;
}
}
// Clear rx_buffer and related varaible
for(uint16_t i = 0; i < UART_RFID_rx_len ; i++)
UART_RFID_rx_buffer[i]=0;
UART_RFID_rx_len = 0;
UART_RFID_recv_end_flag = OFF;
}
HAL_UART_Receive_DMA(&RFID_USART,(uint8_t*)UART_RFID_rx_buffer, (UART_BUFFER_SIZE>>4));
osDelay(300);
}
/* USER CODE END StartRfidTask */
}
#endif //FUNC_ENABLE_USART1_RFID
/* USER CODE BEGIN Header_StartLedSpeakerTask */
/**
* @brief Function implementing the led_speakerTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartLedSpeakerTask */
void StartLedSpeakerTask(void const * argument)
{
/* USER CODE BEGIN StartLedSpeakerTask */
//#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
// IdleUntilReadAllMemory();
//#endif
uint16_t led_pwm_duty_now[4];
uint16_t breathe_duty_now[4];
//standard default
for(uint8_t idx=0;idx<12;idx++)
Charger.Led_Brightness[idx] = 0x33;
/*
//Night mode starndard default brightness
Charger.Led_Brightness[0] = 0x11; //00:00~ 01:59
Charger.Led_Brightness[1] = 0x11; //02:00~ 03:59
Charger.Led_Brightness[2] = 0x11; //04:00~ 05:59
Charger.Led_Brightness[3] = 0x33; //06:00~ 07:59
Charger.Led_Brightness[4] = 0x33; //08:00~ 09:59
Charger.Led_Brightness[5] = 0x33; //10:00~ 11:59
Charger.Led_Brightness[6] = 0x33; //12:00~ 13:59
Charger.Led_Brightness[7] = 0x33; //14:00~ 15:59
Charger.Led_Brightness[8] = 0x33; //16:00~ 17:59
Charger.Led_Brightness[9] = 0x11; //18:00~ 19:59
Charger.Led_Brightness[10] = 0x11; //20:00~ 21:59
Charger.Led_Brightness[11] = 0x11; //22:00~ 23:59
*/
/* Infinite loop */
for(;;)
{
led_pwm_duty_now[0] = getBrightnessDuty(Charger.led_pwm_duty[0]);
led_pwm_duty_now[1] = getBrightnessDuty(Charger.led_pwm_duty[1]);
led_pwm_duty_now[2] = getBrightnessDuty(Charger.led_pwm_duty[2]);
led_pwm_duty_now[3] = getBrightnessDuty(Charger.led_pwm_duty[3]);
breathe_duty_now[0] = getBrightnessDuty(breathe.duty[0]);
breathe_duty_now[1] = getBrightnessDuty(breathe.duty[1]);
breathe_duty_now[2] = getBrightnessDuty(breathe.duty[2]);
breathe_duty_now[3] = getBrightnessDuty(breathe.duty[3]);
if(timer[TIMER_IDX_LED_TEMP].isAlarm)
{
timerDisable(TIMER_IDX_LED_TEMP);
setLedMotion(Charger.Led_Mode);
}
/*
LED red process
*/
switch(Charger.led_R.motion)
{
case LED_MOTION_ON:
user_pwm_setvalue(PWM_CH_LED_R, led_pwm_duty_now[0]);
break;
case LED_MOTION_BLINK:
if(blinker[BLINKER_IDX_LED].isOn)
{
user_pwm_setvalue(PWM_CH_LED_R, led_pwm_duty_now[0]);
}
else
{
user_pwm_setvalue(PWM_CH_LED_R, PWM_DUTY_OFF);
}
break;
case LED_MOTION_BREATHE:
user_pwm_setvalue(PWM_CH_LED_R, breathe_duty_now[0]);
break;
case LED_MOTION_OFF:
default:
user_pwm_setvalue(PWM_CH_LED_R, PWM_DUTY_OFF);
break;
}
/*
LED green process
*/
switch(Charger.led_G.motion)
{
case LED_MOTION_ON:
user_pwm_setvalue(PWM_CH_LED_G, led_pwm_duty_now[1]);
break;
case LED_MOTION_BLINK:
if(blinker[BLINKER_IDX_LED].isOn)
{
user_pwm_setvalue(PWM_CH_LED_G, led_pwm_duty_now[1]);
}
else
{
user_pwm_setvalue(PWM_CH_LED_G, PWM_DUTY_OFF);
}
break;
case LED_MOTION_BREATHE:
user_pwm_setvalue(PWM_CH_LED_G, breathe_duty_now[1]);
break;
case LED_MOTION_OFF:
default:
user_pwm_setvalue(PWM_CH_LED_G, PWM_DUTY_OFF);
break;
}
/*
LED blue process
*/
switch(Charger.led_B.motion)
{
case LED_MOTION_ON:
user_pwm_setvalue(PWM_CH_LED_B, led_pwm_duty_now[2]);
break;
case LED_MOTION_BLINK:
if(blinker[BLINKER_IDX_LED].isOn)
{
user_pwm_setvalue(PWM_CH_LED_B, led_pwm_duty_now[2]);
}
else
{
user_pwm_setvalue(PWM_CH_LED_B, PWM_DUTY_OFF);
}
break;
case LED_MOTION_BREATHE:
user_pwm_setvalue(PWM_CH_LED_B, breathe_duty_now[2]);
break;
case LED_MOTION_OFF:
default:
user_pwm_setvalue(PWM_CH_LED_B, PWM_DUTY_OFF);
break;
}
/*
LED white process
*/
switch(Charger.led_W.motion)
{
case LED_MOTION_ON:
user_pwm_setvalue(PWM_CH_LED_W, led_pwm_duty_now[3]);
break;
case LED_MOTION_BLINK:
if(blinker[BLINKER_IDX_LED].isOn)
{
user_pwm_setvalue(PWM_CH_LED_W, led_pwm_duty_now[3]);
}
else
{
user_pwm_setvalue(PWM_CH_LED_W, PWM_DUTY_OFF);
}
break;
case LED_MOTION_BREATHE:
user_pwm_setvalue(PWM_CH_LED_W, breathe_duty_now[3]);
break;
case LED_MOTION_OFF:
default:
user_pwm_setvalue(PWM_CH_LED_W, PWM_DUTY_OFF);
break;
}
#ifdef FUNC_AW48_NET_LED
if (Charger.m_bModelNameAW48_1P)
{
//Net LED: Green
switch (Charger.LedNet_G.motion)
{
case LED_MOTION_BREATHE:
case LED_MOTION_ON:
NETLED_SET_G(1);
break;
case LED_MOTION_BLINK:
if(blinker[BLINKER_IDX_LED_NET].isOn)
NETLED_SET_G(1);
else
NETLED_SET_G(0);
break;
case LED_MOTION_OFF:
default:
NETLED_SET_G(0);
break;
}
//Net LED: Blue
switch (Charger.LedNet_B.motion)
{
case LED_MOTION_BREATHE:
case LED_MOTION_ON:
NETLED_SET_B(1);
break;
case LED_MOTION_BLINK:
if(blinker[BLINKER_IDX_LED_NET].isOn)
NETLED_SET_B(1);
else
NETLED_SET_B(0);
break;
case LED_MOTION_OFF:
default:
NETLED_SET_B(0);
break;
}
}
#endif //FUNC_AW48_NET_LED
/*
LED breathe process
*/
if(flicker[FLICKER_IDX_BREATHE].isOn)
HAL_GPIO_WritePin(OUT_LED_Breathe_GPIO_Port, OUT_LED_Breathe_Pin, GPIO_PIN_SET);
else
HAL_GPIO_WritePin(OUT_LED_Breathe_GPIO_Port, OUT_LED_Breathe_Pin, GPIO_PIN_RESET);
/*
Spearker process
*/
switch(Charger.speaker.motion)
{
case SPEAKER_LONG:
timerEnable(TIMER_IDX_SPEAKER, 600);
HAL_GPIO_WritePin(OUT_Speaker_GPIO_Port, OUT_Speaker_Pin, GPIO_PIN_SET);
if(timer[TIMER_IDX_SPEAKER].isAlarm)
{
timerDisable(TIMER_IDX_SPEAKER);
Charger.speaker.motion = SPEAKER_NONE;
}
break;
case SPEAKER_SHORT:
timerEnable(TIMER_IDX_SPEAKER, 200);
HAL_GPIO_WritePin(OUT_Speaker_GPIO_Port, OUT_Speaker_Pin, GPIO_PIN_SET);
if(timer[TIMER_IDX_SPEAKER].isAlarm)
{
timerDisable(TIMER_IDX_SPEAKER);
Charger.speaker.motion = SPEAKER_NONE;
}
break;
case SPEAKER_BLINK:
if(blinker[BLINKER_IDX_SPEAKER].isOn)
HAL_GPIO_WritePin(OUT_Speaker_GPIO_Port, OUT_Speaker_Pin, GPIO_PIN_SET);
else
HAL_GPIO_WritePin(OUT_Speaker_GPIO_Port, OUT_Speaker_Pin, GPIO_PIN_RESET);
if(blinker[BLINKER_IDX_SPEAKER].blinkisFinish)
{
disblinkerTime(BLINKER_IDX_SPEAKER);
}
break;
case SPEAKER_NONE:
default:
HAL_GPIO_WritePin(OUT_Speaker_GPIO_Port, OUT_Speaker_Pin, GPIO_PIN_RESET);
break;
}
osDelay(1);
}
/* USER CODE END StartLedSpeakerTask */
}
/* USER CODE BEGIN Header_StartCpTask */
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
void CpTask_CtrlCpPwm_P0(void)
{
#ifdef FUNC_CCS //======================================================================
uint16_t MaxCurr = Charger.memory.EVSE_Config.data.item.MaxChargingCurrent;
if (Charger.m_bRunCCS) //CCS Charge
{
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_5);
Charger.MaxChargingCurrent_Previous = MaxCurr;
}
else //Normal Charge
{
#ifdef FUNC_MODIFY_CP_PWM_CTRL_20231225
if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU || Charger.m_bModelNameDC)
{
if ((MaxCurr >= 6) && (MaxCurr <= Charger.maxRatingCurrent))
{
user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(MaxCurr));
Charger.MaxChargingCurrent_Previous = MaxCurr;
}
else
{
user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(Charger.maxRatingCurrent));
Charger.MaxChargingCurrent_Previous = Charger.maxRatingCurrent;
}
}
else
{
if ((Charger.AC_MaxChargingCurrentOrDuty >= 6) && (Charger.AC_MaxChargingCurrentOrDuty <= Charger.maxRatingCurrent))
{
user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(Charger.AC_MaxChargingCurrentOrDuty));
}
else
{
if (Charger.AC_MaxChargingCurrentOrDuty == 0)
{
user_pwm_setvalue(PWM_CH_CP, 0);
}
else if (Charger.AC_MaxChargingCurrentOrDuty == 1)
{
user_pwm_setvalue(PWM_CH_CP, 0);
}
else if (Charger.AC_MaxChargingCurrentOrDuty == 5)
{
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_5);
}
else if (Charger.AC_MaxChargingCurrentOrDuty == 100)
{
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
}
else
{
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
}
}
Charger.MaxChargingCurrent_Previous = Charger.AC_MaxChargingCurrentOrDuty;
}
#else //FUNC_MODIFY_CP_PWM_CTRL_20231225
if ((MaxCurr >= 6) && (MaxCurr <= Charger.maxRatingCurrent))
{
user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(MaxCurr));
Charger.MaxChargingCurrent_Previous = MaxCurr;
}
else
{
user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(Charger.maxRatingCurrent));
Charger.MaxChargingCurrent_Previous = Charger.maxRatingCurrent;
}
#endif //FUNC_MODIFY_CP_PWM_CTRL_20231225
}
#else //FUNC_CCS //======================================================================
// uint16_t MaxCurr = Charger.memory.EVSE_Config.data.item.MaxChargingCurrent;
// if (MaxCurr < 6)
// {
//#ifdef MODIFY_CP_TASK_CTRL_CP_PWM_BELOW_SIX
// if (MaxCurr == 0)
// {
// user_pwm_setvalue(PWM_CH_CP, 0);
// Charger.MaxChargingCurrent_Previous = MaxCurr;
// }
// else
// {
// user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(6));
// Charger.MaxChargingCurrent_Previous = MaxCurr;
// }
//#else //MODIFY_CP_TASK_CTRL_CP_PWM_BELOW_SIX
// user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(6));
// Charger.MaxChargingCurrent_Previous = MaxCurr;
//#endif //MODIFY_CP_TASK_CTRL_CP_PWM_BELOW_SIX
// }
// else if ((MaxCurr >= 6) && (MaxCurr <= Charger.maxRatingCurrent))
// {
// user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(MaxCurr));
// Charger.MaxChargingCurrent_Previous = MaxCurr;
// }
// else
// {
// user_pwm_setvalue(PWM_CH_CP, GetCpPwmDuty(Charger.maxRatingCurrent));
// Charger.MaxChargingCurrent_Previous = Charger.maxRatingCurrent;
// }
#endif //FUNC_CCS //======================================================================
}
void CpTask_CtrlCpPwm_P1(void)
{
#ifdef FUNC_DETECT_PP
if (
(Charger.m_bDetectPP && Charger.m_PPInfo.m_CurCurr != Charger.m_PPInfo.m_PreCurr)
||
(
(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent != Charger.MaxChargingCurrent_Previous) &&
(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent <= Charger.maxRatingCurrent)
)
)
#else
if (
(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent != Charger.MaxChargingCurrent_Previous) &&
(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent <= Charger.maxRatingCurrent)
)
#endif
{
CpTask_CtrlCpPwm_P0();
}
}
#endif //MODIFY_CP_TASK_CTRL_CP_PWM
#ifdef TRIM_CCID_SELFTEST
void Proc_CCID_SelfTest(void)
{
// check Leak Module do CCID selftset.
if (Charger.CCID_Module_Type == CCID_MODULE_CORMEX)
{
Charger.Test_LeakModuleisPass = Test_LeakModule();
}
else if (Charger.CCID_Module_Type == CCID_MODULE_VAC)
{
Charger.Test_LeakModuleisPass = PASS;
}
else
{
DEBUG_INFO("Did not judge Leak module can't self test before charging.\r\n");
}
XP("Proc CCID Self-Test(%d): %s\r\n", Charger.CCID_Module_Type, Charger.Test_LeakModuleisPass == PASS ? "OK" : "[NG]");
}
#endif
#ifdef FUNC_AUTO_MODIFY_CCID_MODULE
uint8_t AutoModifyCCID(void)
{
uint8_t old = Charger.CCID_Module_Type;
if (Test_LeakModule() == PASS)
{
Charger.m_bCCID_MustModify = HTK_FALSE;
Charger.m_CCID_ModuleTestOK = Charger.CCID_Module_Type;
return PASS;
}
else
{
Charger.CCID_Module_Type = (Charger.CCID_Module_Type == CCID_MODULE_CORMEX ? CCID_MODULE_VAC : CCID_MODULE_CORMEX);
XP("#AutoModifyCCID: %s\r\n", CCID_MODULE_TYPE_STR);
if (Test_LeakModule() == PASS)
{
Charger.m_bCCID_MustModify = HTK_TRUE;
Charger.m_CCID_ModuleTestOK = Charger.CCID_Module_Type;
return PASS;
}
else
{
Charger.m_bCCID_MustModify = HTK_FALSE;
Charger.m_CCID_ModuleTestOK = CCID_MODULE_UNKNOW;
Charger.CCID_Module_Type = old;
return FAIL;
}
}
}
#endif
#ifdef FUNC_AX32_USE_AS_1P_MODEL
#ifdef MODIFY_AX32_RUN_3P_OR_1P_AUTOMATIC_AFTER_GC5
HTK_BOOL AX32_Is_3PModel_Run1P(void)
{
HTK_BOOL bRtn = HTK_FALSE;
if (Charger.m_b3PhaseModel)
{
PMeterIC_ExtraInfo pEx = &Charger.m_MeterIcEx;
int MaxVoltErr = 5000; //0.01V: 50V
int MaxDegErr = 5;
HTK_BOOL bCheckVolt3P =
(
abs(Charger.Voltage[1] - Charger.Voltage[0]) < MaxVoltErr &&
abs(Charger.Voltage[2] - Charger.Voltage[0]) < MaxVoltErr &&
abs(Charger.Voltage[2] - Charger.Voltage[1]) < MaxVoltErr
);
if (bCheckVolt3P)
{
//AC_PHASE_MODE_240_120_120_SEQ_OK(NG:Happen 1 times)
if (
HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[0]), 240, MaxDegErr) &&
HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[1]), 120, MaxDegErr) &&
HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[2]), 120, MaxDegErr)
)
{
pEx->m_AcPhaseMode = AC_PHASE_MODE_240_120_120_SEQ_OK;
}
//AC_PHASE_MODE_120_120_240_SEQ_NG
else if (
HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[0]), 120, MaxDegErr) &&
HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[1]), 120, MaxDegErr) &&
HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[2]), 240, MaxDegErr)
)
{
pEx->m_AcPhaseMode = AC_PHASE_MODE_120_120_240_SEQ_NG;
}
//AC_PHASE_MODE_360_360_360 (for RD test - L => L1, L2, L3)
else if (
HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[0]), 360, MaxDegErr) &&
HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[1]), 360, MaxDegErr) &&
HTK_IS_BETWEEN_MIDDIFF(fabs(pEx->m_AngleDegree[2]), 360, MaxDegErr)
)
{
pEx->m_AcPhaseMode = AC_PHASE_MODE_360_360_360;
}
else
{
pEx->m_AcPhaseMode = AC_PHASE_MODE_UNKNOW;
}
}
if (!bCheckVolt3P || pEx->m_AcPhaseMode == AC_PHASE_MODE_UNKNOW)
{
if (
(abs(Charger.Voltage[1] - Charger.Voltage[0]) < MaxVoltErr && abs(Charger.Voltage[2] - Charger.Voltage[0]) > MaxVoltErr)
||
(abs(Charger.Voltage[1] - Charger.Voltage[0]) > MaxVoltErr && abs(Charger.Voltage[2] - Charger.Voltage[0]) < MaxVoltErr)
)
{
//Conntect L1, L2 or L1, L3 ==> RUN 3P
pEx->m_AcPhaseMode = AC_PHASE_MODE_UNKNOW;
}
else
{
pEx->m_AcPhaseMode = AC_PHASE_MODE_1P;
}
}
if (
Charger.m_bModelNameAX32_3P
#ifdef FUNC_AT32
|| Charger.m_bModelNameAT32_3P
#endif
)
{
#ifdef FUNC_AX32_AUTO_PHASE_WITHOUT_GENERATION_CODE
if (pEx->m_AcPhaseMode == AC_PHASE_MODE_1P)
{
DEBUG_INFO("3P MODEL RUN 1P PROC \r\n");
bRtn = HTK_TRUE;
}
else
{
DEBUG_INFO("3P MODEL RUN 3P PROC \r\n");
}
#else //FUNC_AX32_AUTO_PHASE_WITHOUT_GENERATION_CODE
if (Charger.memory.EVSE_Config.data.item.ModelName[11] >= '0' &&
Charger.memory.EVSE_Config.data.item.ModelName[11] <= '4')
{
DEBUG_INFO("3P MODEL RUN 3P PROC (GEN_CODE == 0-4)\r\n");
}
else
{
if (pEx->m_AcPhaseMode == AC_PHASE_MODE_1P)
{
DEBUG_INFO("3P MODEL RUN 1P PROC (GEN_CODE != 0-4 )\r\n");
bRtn = HTK_TRUE;
}
else
{
DEBUG_INFO("3P MODEL RUN 3P PROC (GEN_CODE != 0-4 )\r\n");
}
}
#endif //FUNC_AX32_AUTO_PHASE_WITHOUT_GENERATION_CODE
}
else if (Charger.m_bModelNameDC)
{
DEBUG_INFO("3P MODEL RUN 3P PROC (DC Model)\r\n");
}
else
{
DEBUG_INFO("3P MODEL RUN 3P PROC\r\n");
}
}
return bRtn;
}
#endif //MODIFY_AX32_RUN_3P_OR_1P_AUTOMATIC_AFTER_GC5
#endif //FUNC_AX32_USE_AS_1P_MODEL
//#ifdef FIXHW_AW48_CSU_EXIST_DELAY_CHECK
//void AW48_CheckCSU(void)
//{
// if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
// {
// if (IS_CSU_MOUNTED)
// {
// parseVersionInfoFromModelname(); //Update_McuCtrlMode() included
// if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_CSU)
// {
// XP("\r\nAW48_CheckCSU() >>> MCU_CONTROL_MODE_CSU (%d sec)\r\n", (HAL_GetTick() - Charger.m_BootTick) / 1000 );
// setChargerMode(MODE_INITIAL);
// }
// }
// }
//}
//
//void AW48_WaitCSU(u32 MaxTick)
//{
// XP("AW48_WaitCSU(): Begin\r\n");
// u32 TickBeg = HAL_GetTick();
// while (1)
// {
// HAL_IWDG_Refresh(&hiwdg);
// osDelay(100);
// if (IS_CSU_MOUNTED)
// {
// XP("AW48_WaitCSU(): End \r\n", (HAL_GetTick() - TickBeg) / 1000); //Test: 27s
// AW48_CheckCSU();
// return;
// }
//
// if (HTK_IsTimeout(TickBeg, MaxTick))
// {
// XP("AW48_WaitCSU(): End \r\n", MaxTick / 1000);
// return;
// }
// }
//}
//
//#endif //FIXHW_AW48_CSU_EXIST_DELAY_CHECK
/**
* @brief Function implementing the cpTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartCpTask */
void StartCpTask(void const * argument)
{
/* USER CODE BEGIN StartCpTask */
//ccp
uint32_t duration_delta;
Charger.Mode = MODE_INITIAL;
Charger.Relay_Action=GPIO_RELAY_ACTION_OFF;
setLedMotion(LED_ACTION_INIT);
#ifdef FUNC_AW48_NET_LED
if (Charger.m_bModelNameAW48_1P)
{
setNetLedMotion(Charger.am3352.NetLedActionState = NET_LED_ACTION_OFF);
}
#endif
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
IdleUntilReadAllMemory();
#endif
//Check MCU control mode depend on GPIO state
#ifdef FUNC_FORCE_RUN_CSU_MODE_WITH_DC_MODELNAME
Update_McuCtrlMode();
#endif
HAL_GPIO_WritePin(OUT_StateE_GPIO_Port, OUT_StateE_Pin, GPIO_PIN_RESET);
#ifdef FUNC_AX32_TRIG_LEAKAGE
if (Charger.m_b3PhaseModel)
{
TrigLeakage_Init();
}
#endif
#ifdef FUNC_AX80_ADD_TILT_SENSOR
#ifdef FUNC_ADD_TILT_SENSOR_MODEL
if (Charger.m_bUseTiltSensor)
#else
if (Charger.m_bModelNameAX80_1P)
#endif
{
TILT_TrigLeakage_Init();
}
#endif //FUNC_AX80_ADD_TILT_SENSOR
/* Infinite loop */
for(;;)
{
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
{
//=============================( MODIFY_CPTASK_TYPE_E )==============================[ NO CSU ]
#ifdef MODIFY_CPTASK_HEAD
Proc_CpTaskHead(HTK_FALSE);
#endif
switch(Charger.Mode)
{
case MODE_INITIAL:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_INITIAL )
setLedMotion(LED_ACTION_INIT);
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
HAL_GPIO_WritePin(OUT_Leak_Test_GPIO_Port, OUT_Leak_Test_Pin, GPIO_PIN_SET); // for VAC LeakModule use
if (Charger.ModelReadisOK ==PASS)
{
getRotarySwitchSetting( );
getGridTypeSwitchSetting( );
Charger.isTestLeakModule = ON ;
#ifdef FUNC_AUTO_MODIFY_CCID_MODULE
if (AutoModifyCCID() == PASS)
#else
if(Test_LeakModule() == PASS)
#endif
{
DEBUG_INFO("Leak module self test pass when initial.\r\n");
osDelay(1000);
if(Charger.isDebugEnable)
setChargerMode(MODE_DEBUG);
else
{
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
// Cold load pick up check
if((Charger.CP_State == SYSTEM_STATE_A) && Charger.memory.coldLoadPickUp.data.item.isEnable)
{
#ifndef FUNC_METER_IC_HISTORY
recordChargingHis(OFF, END_STATUS_CODE_DROP);
#endif
Charger.memory.coldLoadPickUp.data.item.isEnable = OFF;
Charger.memory.coldLoadPickUp.op_bits.update = ON;
}
}
osDelay(5000) ; //wait hardware PE feedback data so delay some time
//#ifdef FIXHW_AW48_CSU_EXIST_DELAY_CHECK
// if (Charger.m_bModelNameAW48_1P)
// {
// AW48_WaitCSU(1000 * 30);
// }
//#endif
setChargerMode(MODE_IDLE);
}
}
else
{
Charger.Alarm_Code |= ALARM_LEAK_MODULE_FAIL;
DEBUG_INFO("Leak module self test fail when initial.\r\n");
Charger.counter.LEAK_MODULE.isLatch = ON ;
}
Charger.isTestLeakModule = OFF ;
}
break;
case MODE_IDLE:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_IDLE )
if(isModeChange())
{
setLedMotion(LED_ACTION_IDLE);
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
Charger.m_OutpMode = OUTPMODE_NONE;
#endif
Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = Charger.maxRatingCurrent;
#ifdef MODIFY_AC_EVSE_STATUS_MAX_CHARGING_CURRENT_VARIABLE
Charger.AC_MaxChargingCurrentOrDuty = Charger.maxRatingCurrent;
#endif
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
Charger.isSetStartTime = ON ;
Charger.isOnSocketE = OFF;
#ifdef FUNC_CCS
Charger.m_bRunCCS = 0;
Charger.m_bGotCsuCpDutyCmd = 0;
#ifdef MODIFY_GOT_CSU_DUTY_CMD_PROCESS
Charger.m_bPassGotCsuCpDutyCmd = 0;
#endif
#endif //FUNC_CCS
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
if (Charger.m_bUseGunLock)
{
Charger.m_GunLock_Counter = 0;
Charger.m_GunUnlock_Counter = 0;
}
#endif
#ifdef FUNC_PTB_METER_WM3M4C
if (Charger.m_pWM3M4C != NULL)
{
if (Charger.m_pWM3M4C->m_bCharging)
{
Charger.m_pWM3M4C->m_bTrigEndCharge = HTK_TRUE;
}
}
#endif
#ifdef FUNC_AX32_USE_AS_1P_MODEL
Charger.m_b3PhaseModelButUse1PhaseOnly = AX32_Is_3PModel_Run1P();
#endif
}
if (Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_OCPP)
{
if( Charger.memory.coldLoadPickUp.data.item.isEnable || Charger.rfid.op_bits.reqStart)
{
osDelay(LED_RFID_TIME); // for Buzzer and RFID /Fail LED use
setLedMotion(LED_ACTION_AUTHED);
// Check start method type
memset(&Charger.cycle_info.userId[0], 0x00, ARRAY_SIZE(Charger.cycle_info.userId));
if(Charger.rfid.op_bits.reqStart)
{
Charger.cycle_info.StartType = START_METHOD_RFID;
memcpy(&Charger.cycle_info.userId[0], &Charger.rfid.currentCard[0], ARRAY_SIZE(Charger.rfid.currentCard));
Charger.istoHandShakeMode = ON ;
}
Charger.rfid.op_bits.reqStart = OFF;
if(Charger.memory.coldLoadPickUp.data.item.isEnable)
{
Charger.memory.coldLoadPickUp.data.item.isEnable = OFF;
Charger.memory.coldLoadPickUp.op_bits.update = ON;
DEBUG_INFO("coldLoadPickUp ON to rand wait sec.\r\n");
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
ColdLoadPickup_Delay("coldLoadPickUp ON to rand wait sec.");
#else
osDelay((rand()%175000)+5000);
//osDelay((rand()%5000)+5000);
#endif
Charger.istoHandShakeMode = ON ;
}
}
if (Charger.istoHandShakeMode == ON) //charger can to HandShakeMode
{
if (
(Charger.CP_State == SYSTEM_STATE_B) ||
(Charger.CP_State == SYSTEM_STATE_C) ||
#ifdef MODIFY_CPTASK_TYPE_E
((Charger.CP_State == SYSTEM_STATE_A) || IsTypeEPlugIn())
#else
//HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin)
#endif
)
{
#ifdef MODIFY_CPTASK_TYPE_E
if (Charger.CP_State == SYSTEM_STATE_B || Charger.CP_State == SYSTEM_STATE_C)
{
Charger.m_OutpMode = OUTPMODE_CPGUN;
}
else if ((Charger.CP_State == SYSTEM_STATE_A) || IsTypeEPlugIn())
{
Charger.m_OutpMode = OUTPMODE_TYPEE;
}
#endif
timerDisable(TIMER_IDX_CP);
Charger.istoHandShakeMode = OFF ;
setChargerMode(MODE_HANDSHAKE);
}
else
{
timerEnable(TIMER_IDX_CP, 180000);
}
}
}
else if (Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_FREE)
{
if (
(Charger.CP_State == SYSTEM_STATE_B) ||
(Charger.CP_State == SYSTEM_STATE_C) ||
#ifdef MODIFY_CPTASK_TYPE_E
(Charger.CP_State == SYSTEM_STATE_A && IsTypeEPlugIn()) ||
#endif
Charger.memory.coldLoadPickUp.data.item.isEnable )
{
setLedMotion(LED_ACTION_AUTHED);
// Check start method type
memset(&Charger.cycle_info.userId[0], 0x00, ARRAY_SIZE(Charger.cycle_info.userId));
if(Charger.rfid.op_bits.reqStart)
{
Charger.cycle_info.StartType = START_METHOD_RFID;
memcpy(&Charger.cycle_info.userId[0], &Charger.rfid.currentCard[0], ARRAY_SIZE(Charger.rfid.currentCard));
}
else
{
#ifdef MODIFY_CPTASK_TYPE_E
if (Charger.CP_State == SYSTEM_STATE_B ||
Charger.CP_State == SYSTEM_STATE_C ||
Charger.memory.coldLoadPickUp.data.item.isEnable)
{
Charger.cycle_info.StartType = START_METHOD_CP;
Charger.m_OutpMode = OUTPMODE_CPGUN;
}
else if (Charger.CP_State == SYSTEM_STATE_A && IsTypeEPlugIn())
{
Charger.cycle_info.StartType = START_METHOD_TYPEE;
Charger.m_OutpMode = OUTPMODE_TYPEE;
}
#else
Charger.cycle_info.StartType = START_METHOD_CP;
#endif //MODIFY_CPTASK_TYPE_E
}
Charger.ble.isRequestOn = OFF;
Charger.rfid.op_bits.reqStart = OFF;
if(Charger.memory.coldLoadPickUp.data.item.isEnable)
{
Charger.memory.coldLoadPickUp.data.item.isEnable = OFF;
Charger.memory.coldLoadPickUp.op_bits.update = ON;
DEBUG_INFO("coldLoadPickUp ON to rand wait sec.\r\n");
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
ColdLoadPickup_Delay("coldLoadPickUp ON to rand wait sec.");
#else
osDelay((rand()%175000)+5000);
#endif
}
setChargerMode(MODE_HANDSHAKE);
}
}
break;
case MODE_HANDSHAKE:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_HANDSHAKE )
if(isModeChange())
{
Charger.isCP_in_B = OFF ;
Charger.isTestLeakModule = ON ;
#ifdef TRIM_CCID_SELFTEST
Proc_CCID_SelfTest();
#endif
//check Leak test pass
if (Charger.Test_LeakModuleisPass)
{
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
CpTask_CtrlCpPwm_P0();
#endif
DEBUG_INFO("Leak module self test pass before charging.\r\n");
}
else
{
Charger.Alarm_Code |= ALARM_LEAK_MODULE_FAIL;
DEBUG_INFO("Leak module self test fail before charging.\r\n");
Charger.counter.LEAK_MODULE.retry ++ ;
if (Charger.counter.LEAK_MODULE.retry >=2)
{
Charger.counter.LEAK_MODULE.isLatch = ON ;
}
}
osDelay(300);
Charger.isTestLeakModule = OFF ;
}
// to chaging moder
if(Charger.CP_State == SYSTEM_STATE_C)
{
#ifdef MODIFY_CPTASK_TYPE_E
Charger.m_OutpMode = OUTPMODE_CPGUN;
#endif
setChargerMode(MODE_CHARGING);
if (Charger.isSetStartTime == ON)
{
Charger.cycle_info.startTimeTick = HAL_GetTick();
Charger.cycle_info.startDateTime.year = Charger.memory.EVSE_Config.data.item.SystemDateTime.year;
Charger.cycle_info.startDateTime.month = Charger.memory.EVSE_Config.data.item.SystemDateTime.month;
Charger.cycle_info.startDateTime.day = Charger.memory.EVSE_Config.data.item.SystemDateTime.day;
Charger.cycle_info.startDateTime.hour = Charger.memory.EVSE_Config.data.item.SystemDateTime.hour;
Charger.cycle_info.startDateTime.min = Charger.memory.EVSE_Config.data.item.SystemDateTime.min;
Charger.cycle_info.startDateTime.sec = Charger.memory.EVSE_Config.data.item.SystemDateTime.sec;
Charger.cycle_info.meterStart = Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total;
}
}
/*
* TODO:
* 1. Check socket-E detect pin to determine charging mdoe
*/
#ifdef MODIFY_CPTASK_TYPE_E
if (Charger.CP_State == SYSTEM_STATE_A && IsTypeEPlugIn())
#else
//if((Charger.CP_State == SYSTEM_STATE_A) && HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin))
#endif
{
Charger.isOnSocketE = ON;
#ifdef MODIFY_CPTASK_TYPE_E
Charger.m_OutpMode = OUTPMODE_TYPEE;
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
#endif
setChargerMode(MODE_CHARGING);
if (Charger.isSetStartTime == ON)
{
Charger.cycle_info.startTimeTick = HAL_GetTick();
Charger.cycle_info.startDateTime.year = Charger.memory.EVSE_Config.data.item.SystemDateTime.year;
Charger.cycle_info.startDateTime.month = Charger.memory.EVSE_Config.data.item.SystemDateTime.month;
Charger.cycle_info.startDateTime.day = Charger.memory.EVSE_Config.data.item.SystemDateTime.day;
Charger.cycle_info.startDateTime.hour = Charger.memory.EVSE_Config.data.item.SystemDateTime.hour;
Charger.cycle_info.startDateTime.min = Charger.memory.EVSE_Config.data.item.SystemDateTime.min;
Charger.cycle_info.startDateTime.sec = Charger.memory.EVSE_Config.data.item.SystemDateTime.sec;
Charger.cycle_info.meterStart = Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total;
}
}
if(Charger.CP_State == SYSTEM_STATE_B)
{
Charger.isCP_in_B = ON ;
setLedMotion(LED_ACTION_CONNECTED);
}
//RFID remove gun
if ((Charger.cycle_info.StartType == START_METHOD_RFID) && (Charger.CP_State == SYSTEM_STATE_A) && (Charger.isCP_in_B == ON))
{
Charger.isCP_in_B = OFF ;
setChargerMode(MODE_IDLE);
}
//FREE remove gun
if ((Charger.cycle_info.StartType == START_METHOD_CP) && Charger.CP_State == SYSTEM_STATE_A)
{
setChargerMode(MODE_IDLE);
}
#ifdef MODIFY_CPTASK_TYPE_E
//Type E remove plug
if ((Charger.cycle_info.StartType == START_METHOD_TYPEE) && !IsTypeEPlugIn())
{
setChargerMode(MODE_IDLE);
}
#endif
break;
case MODE_CHARGING:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_CHARGING )
if(isModeChange())
{
#ifdef MODIFY_CPTASK_CSU_0_1_CHARGE_MODE
CpTask_CtrlCpPwm_P0();
#endif
setLedMotion(LED_ACTION_CHARGING);
#ifdef FUNC_PTB_METER_WM3M4C
if (Charger.m_pWM3M4C != NULL)
{
Charger.m_pWM3M4C->m_bTrigBegCharge = HTK_TRUE;
}
#endif
}
if (
#ifdef MODIFY_AW_CP_TASK_CSU_0_1_CHARGING_MODE_STOP_WITHOUT_STATE_C
(!Charger.isOnSocketE && Charger.CP_State!=SYSTEM_STATE_C) ||
#else
((!Charger.isOnSocketE && Charger.CP_State!=SYSTEM_STATE_C) && (Charger.CP_State != SYSTEM_STATE_UNKNOWN)) ||
#endif
#ifdef MODIFY_CPTASK_TYPE_E
((Charger.isOnSocketE) && !IsTypeEPlugIn()) ||
#else
//((Charger.isOnSocketE) && !HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin)) ||
#endif
((Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_OCPP)?Charger.rfid.op_bits.reqStop:0)
)
{
setChargerMode(MODE_STOP);
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
}
else
{
#ifdef MODIFY_CPTASK_TYPE_E
if (Charger.m_OutpMode == OUTPMODE_CPGUN && Charger.CP_State == SYSTEM_STATE_C)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
}
else if (Charger.m_OutpMode == OUTPMODE_TYPEE && Charger.isOnSocketE && IsTypeEPlugIn())
{
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_ON;
}
#else
Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
#endif
duration_delta = (HAL_GetTick() - Charger.cycle_info.startTimeTick);
Charger.cycle_info.Duration = duration_delta;
Charger.cycle_info.Power_Consumption = Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total - Charger.cycle_info.meterStart;
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
CpTask_CtrlCpPwm_P1();
#endif
}
break;
case MODE_STOP:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_STOP )
if(isModeChange())
{
if ((Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_OCPP) && Charger.rfid.op_bits.reqStop)
{
osDelay(LED_RFID_TIME); // for Buzzer and RFID /Fail LED use
}
setLedMotion(LED_ACTION_STOP);
Charger.isCP_in_B = OFF ;
Charger.is_RFIDKeepCharger = ON ;
Charger.isSetStartTime = OFF ;
}
if (Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_OCPP)
{
//GB
if(Charger.CP_State == SYSTEM_STATE_A)
{
Charger.cycle_info.endTimeTick = HAL_GetTick();
#ifndef FUNC_METER_IC_HISTORY
recordChargingHis(OFF, END_STATUS_CODE_NORMAL);
#endif
Charger.rfid.op_bits.reqStop = OFF;
setChargerMode(MODE_IDLE);
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
timerDisable(TIMER_IDX_RFID_RELAY_OFF);
Charger.isCP_in_B = OFF ;
Charger.is_RFIDKeepCharger = OFF ;
Charger.cycle_info.StartType = START_METHOD_NONE;
}
else
{
//rfid close PWM and relay
if ((Charger.rfid.op_bits.reqStop == ON)&&Charger.cycle_info.StartType == START_METHOD_RFID)
{
Charger.rfid.op_bits.reqStop = OFF;
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL); // close pwm
timerEnable( TIMER_IDX_RFID_RELAY_OFF, 3000); //is set wait 3 sec
Charger.is_RFIDKeepCharger = OFF ;
}
if (timer[TIMER_IDX_RFID_RELAY_OFF].isAlarm == ON) //is wait 3 sec
{
timerDisable(TIMER_IDX_RFID_RELAY_OFF);
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
setChargerMode(MODE_IDLE);
Charger.cycle_info.StartType = START_METHOD_NONE;
}
//cp close or open PWM
if((Charger.CP_State == SYSTEM_STATE_B))
{
timerDisable(TIMER_IDX_RFID_RELAY_OFF);
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
Charger.isCP_in_B = ON ;
}
else if (Charger.CP_State == SYSTEM_STATE_C )
{
if ( Charger.isCP_in_B == ON && Charger.is_RFIDKeepCharger == ON)
{
Charger.is_RFIDKeepCharger = OFF ;
Charger.isCP_in_B = OFF ;
Charger.isTestLeakModule = ON ;
#ifdef TRIM_CCID_SELFTEST
Proc_CCID_SelfTest();
#endif
//check Leak test pass
if (Charger.Test_LeakModuleisPass)
{
timerEnable(TIMER_IDX_CP, 180000);
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
CpTask_CtrlCpPwm_P0();
#endif
setChargerMode(MODE_CHARGING);
DEBUG_INFO("Leak module self test pass before charging.\r\n");
}
else
{
Charger.Alarm_Code |= ALARM_LEAK_MODULE_FAIL;
DEBUG_INFO("Leak module self test fail before charging.\r\n");
Charger.counter.LEAK_MODULE.retry ++ ;
if (Charger.counter.LEAK_MODULE.retry >=2)
{
Charger.counter.LEAK_MODULE.isLatch = ON ;
}
}
osDelay(300);
Charger.isTestLeakModule = OFF ;
}
}
}
}
else if (Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_FREE)
{
if (Charger.CP_State == SYSTEM_STATE_A)
{
Charger.cycle_info.endTimeTick = HAL_GetTick();
#ifndef FUNC_METER_IC_HISTORY
recordChargingHis(OFF, END_STATUS_CODE_NORMAL);
#endif
Charger.ble.isRequestOff = OFF;
Charger.rfid.op_bits.reqStop = OFF;
setChargerMode(MODE_IDLE);
}
else
{
if (Charger.CP_State == SYSTEM_STATE_B)
{
Charger.isCP_in_B = ON ;
}
if((Charger.CP_State == SYSTEM_STATE_C))
{
setChargerMode(MODE_CHARGING);
}
}
}
break;
case MODE_ALARM:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_ALARM )
if(isModeChange())
{
Charger.isSetStartTime = OFF ;
//clear blink time , Prevent red light from being snatched by others
disblinkerTime (BLINKER_IDX_LED) ;
}
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
//Set alarm led
if ((Charger.Alarm_Code != Charger.Alarm_Code_before) && (blinker[BLINKER_IDX_LED].blinkisFinish))
{
setLedMotion(LED_ACTION_ALARM);
Charger.Alarm_Code_before = Charger.Alarm_Code ;
}
#ifdef FUNC_MODE_ALARM_TO_MODE_DEBUG
if (Charger.isDebugEnable && Charger.Alarm_Code == 0)
{
setChargerMode(MODE_DEBUG);
}
else
#endif
if(Charger.Alarm_Code == 0x00)
{
Charger.Alarm_Code_before = Charger.Alarm_Code ;
if (Charger.Mode_Before_Alarm == MODE_CHARGING) // in charging mode
{
if(Charger.CP_State == SYSTEM_STATE_A) // to idle
{
Charger.cycle_info.endTimeTick = HAL_GetTick();
#ifndef FUNC_METER_IC_HISTORY
recordChargingHis(OFF, END_STATUS_CODE_NORMAL);
#endif
Charger.rfid.op_bits.reqStop = OFF;
Charger.ble.isRequestOff = OFF;
setChargerMode(MODE_IDLE);
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
timerDisable(TIMER_IDX_RFID_RELAY_OFF);
Charger.isCP_in_B = OFF ;
Charger.is_RFIDKeepCharger = OFF ;
Charger.cycle_info.StartType = START_METHOD_NONE;
}
else // to handshake
{
setChargerMode(MODE_HANDSHAKE);
Charger.isCP_in_B = ON ;
setLedMotion(LED_ACTION_CONNECTED);
}
}
else if(Charger.Mode_Before_Alarm == MODE_STOP) // in stop mode
{
if(Charger.CP_State == SYSTEM_STATE_A) // to idle
{
Charger.cycle_info.endTimeTick = HAL_GetTick();
#ifndef FUNC_METER_IC_HISTORY
recordChargingHis(OFF, END_STATUS_CODE_NORMAL);
#endif
Charger.rfid.op_bits.reqStop = OFF;
setChargerMode(MODE_IDLE);
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
timerDisable(TIMER_IDX_RFID_RELAY_OFF);
Charger.isCP_in_B = OFF ;
Charger.is_RFIDKeepCharger = OFF ;
Charger.cycle_info.StartType = START_METHOD_NONE;
}
else if ((Charger.CP_State == SYSTEM_STATE_B) && (Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_OCPP)) // OCPP
{
if ( ( ((Charger.cycle_info.StartType == START_METHOD_BLE) && (Charger.is_BLEKeepCharger == ON))|| // to handshake
((Charger.cycle_info.StartType == START_METHOD_RFID) && (Charger.is_RFIDKeepCharger == ON)) ) &&
( Charger.isCP_in_B == ON ) )
{
setChargerMode(MODE_HANDSHAKE);
setLedMotion(LED_ACTION_CONNECTED);
}
else //to stop
{
setChargerMode(MODE_STOP);
}
}
else if ((Charger.CP_State == SYSTEM_STATE_B) && (Charger.memory.EVSE_Config.data.item.AuthMode == AUTH_MODE_FREE)) //Free
{
if ( Charger.isCP_in_B == ON ) // to handshake
{
setChargerMode(MODE_HANDSHAKE);
setLedMotion(LED_ACTION_CONNECTED);
}
else //to stop
{
setChargerMode(MODE_STOP);
}
}
else //to stop
{
setChargerMode(MODE_STOP);
}
}
else // idle
{
if(timer[TIMER_IDX_STATE_E].isAlarm == ON)
{
setChargerMode(MODE_IDLE);
}
}
}
break;
case MODE_MAINTAIN:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_MAINTAIN )
if(isModeChange())
{}
break;
case MODE_DEBUG:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_DEBUG )
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
if(isModeChange())
{
setLedMotion(LED_ACTION_DEBUG);
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
timerEnable(TIMER_IDX_DEBUG, FUNC_MODE_DEBUG_RELAY_ON_SEC * 1000);
#else
timerEnable(TIMER_IDX_DEBUG, 2000);
#endif
}
if (timer[TIMER_IDX_DEBUG].isAlarm &&
Charger.Alarm_Code == 0 &&
Charger.CP_State == SYSTEM_STATE_C)
{
if (Charger.Relay_Action == GPIO_RELAY_ACTION_ON)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
timerRefresh(TIMER_IDX_DEBUG);
timerEnable(TIMER_IDX_DEBUG, FUNC_MODE_DEBUG_RELAY_OFF_SEC * 1000);
#else
timerRefresh(TIMER_IDX_DEBUG);
#endif
}
else if (Charger.Relay_Action == GPIO_RELAY_ACTION_OFF)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
#ifdef FUNC_MODE_DEBUG_REC_RELAY_ON_TIMES
Charger.memory.EVSE_Config.data.item.m_ModeDebugRelayOnTimes++;
Charger.memory.EVSE_Config.op_bits.update = ON;
#endif
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
timerRefresh(TIMER_IDX_DEBUG);
timerEnable(TIMER_IDX_DEBUG, FUNC_MODE_DEBUG_RELAY_ON_SEC * 1000);
#else
timerRefresh(TIMER_IDX_DEBUG);
#endif
}
}
#else //FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
if(isModeChange())
{
setLedMotion(LED_ACTION_DEBUG);
Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
timerEnable(TIMER_IDX_DEBUG, 1000);
}
if(timer[TIMER_IDX_DEBUG].isAlarm || (Charger.Alarm_Code>0))
{
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
Charger.isDebugModeCPtest = ON;
}
if(Charger.isDebugModeCPtest)
{
if(Charger.CP_State == SYSTEM_STATE_A)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = Charger.maxRatingCurrent;
#ifdef MODIFY_AC_EVSE_STATUS_MAX_CHARGING_CURRENT_VARIABLE
Charger.AC_MaxChargingCurrentOrDuty = Charger.maxRatingCurrent;
#endif
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
}
else if (Charger.CP_State == SYSTEM_STATE_B)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
CpTask_CtrlCpPwm_P1();
#endif
}
else if (Charger.CP_State == SYSTEM_STATE_C)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
CpTask_CtrlCpPwm_P1();
#endif
}
}
#endif //FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
break;
}
}
else if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_CSU)
{
//=============================( MODIFY_CPTASK_TYPE_E )==============================[ WITH CSU ]
/*
MCU control mdoe with CSU
*/
if (!Charger.am3352.isRequestOn)
{
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
if (Charger.Mode != MODE_DEBUG)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
}
#else
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#endif //FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
}
#ifdef MODIFY_CPTASK_HEAD
Proc_CpTaskHead(HTK_TRUE);
#endif
switch(Charger.Mode)
{
case MODE_INITIAL:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_INITIAL )
setLedMotion(LED_ACTION_INIT);
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
HAL_GPIO_WritePin(OUT_Leak_Test_GPIO_Port, OUT_Leak_Test_Pin, GPIO_PIN_SET); // for VAC LeakModule use
#ifdef FUNC_RELAY_OFF_WHEN_CSU_CMD_TIMEOUT
Charger.m_CSU_RxTick = HAL_GetTick();
#endif
if (Charger.ModelReadisOK ==PASS)
{
getRotarySwitchSetting( );
getGridTypeSwitchSetting( );
Charger.isTestLeakModule = ON ;
#ifdef FUNC_AUTO_MODIFY_CCID_MODULE
if (AutoModifyCCID() == PASS)
#else
if(Test_LeakModule() == PASS)
#endif
{
DEBUG_INFO("Leak module self test pass when initial.\r\n");
osDelay(1000);
if(Charger.isDebugEnable)
setChargerMode(MODE_DEBUG);
else
{
setChargerMode(MODE_IDLE);
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
// Cold load pick up check
if((Charger.CP_State == SYSTEM_STATE_A) && Charger.memory.coldLoadPickUp.data.item.isEnable)
{
#ifndef FUNC_METER_IC_HISTORY
recordChargingHis(OFF, END_STATUS_CODE_DROP);
#endif
Charger.memory.coldLoadPickUp.data.item.isEnable = OFF;
Charger.memory.coldLoadPickUp.op_bits.update = ON;
}
}
}
}
else
{
Charger.Alarm_Code |= ALARM_LEAK_MODULE_FAIL;
DEBUG_INFO("Leak module self test fail when initial.\r\n");
Charger.counter.LEAK_MODULE.isLatch = ON ;
}
Charger.isTestLeakModule = OFF ;
}
break;
case MODE_IDLE:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_IDLE )
if(isModeChange())
{
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_SOCKET_E_OCP_USE_MAX_CHARGING_CURRENT
Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = Charger.maxRatingCurrent;
#else
//Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = Charger.maxRatingCurrent; //need CSU command change
#endif
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
Charger.isSetStartTime = ON ;
Charger.isOnSocketE = OFF;
#ifdef FUNC_BLOCK_CSU_CONFIG_CP_PWM_DUTY
Charger.m_bBlockCsuCpPwmDuty = HTK_DISABLE;
#endif
#ifdef FUNC_CCS
Charger.m_bRunCCS = 0;
Charger.m_bGotCsuCpDutyCmd = 0;
#ifdef MODIFY_GOT_CSU_DUTY_CMD_PROCESS
Charger.m_bPassGotCsuCpDutyCmd = 0;
#endif
#endif //FUNC_CCS
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
if (Charger.m_bUseGunLock)
{
Charger.m_GunLock_Counter = 0;
Charger.m_GunUnlock_Counter = 0;
}
#endif
#ifdef FUNC_AX32_USE_AS_1P_MODEL
Charger.m_b3PhaseModelButUse1PhaseOnly = AX32_Is_3PModel_Run1P();
#endif
#ifdef FUNC_SYSTEM_KEEP_INFO
if (g_SystemKeepInfo.m_bUsed == HTK_TRUE)
{
g_SystemKeepInfo.m_bUsed = HTK_FALSE;
}
#endif
}
#ifdef FUNC_SYSTEM_KEEP_INFO
if (
(Charger.CP_State != SYSTEM_STATE_A) ||
(
(Charger.CP_State == SYSTEM_STATE_A) && IsTypeEPlugIn()
)
)
{
if (g_SystemKeepInfo.m_bUsed == HTK_FALSE)
{
g_SystemKeepInfo.m_bUsed = HTK_TRUE;
if (SystemKeepInfo_Check(&g_SystemKeepInfo))
{
if (g_SystemKeepInfo.m_CsuIsRequestOn)
{
Charger.am3352.isRequestOn = g_SystemKeepInfo.m_CsuIsRequestOn;
user_pwm_setvalue(PWM_CH_CP, g_SystemKeepInfo.m_CpPwmVal);
Charger.m_bGotCsuCpDutyCmd = 1;
DEBUG_INFO("# CP_PWM => %d\r\n", g_SystemKeepInfo.m_CpPwmVal);
SystemKeepInfo_Display(&g_SystemKeepInfo);
}
}
}
}
#endif //FUNC_SYSTEM_KEEP_INFO
if (Charger.am3352.isRequestOn &&
#ifdef FUNC_CCS
#ifdef MODIFY_GOT_CSU_DUTY_CMD_PROCESS
(Charger.m_bGotCsuCpDutyCmd == 1 || Charger.m_bPassGotCsuCpDutyCmd == 1) &&
#else
Charger.m_bGotCsuCpDutyCmd == 1 &&
#endif
#endif //FUNC_CCS
(Charger.CP_State != SYSTEM_STATE_A))
{
setChargerMode(MODE_HANDSHAKE);
}
#ifdef MODIFY_CPTASK_TYPE_E
if (
(Charger.am3352.isRequestOn) &&
(Charger.CP_State == SYSTEM_STATE_A && IsTypeEPlugIn())
)
{
setChargerMode(MODE_HANDSHAKE);
}
#endif
break;
case MODE_HANDSHAKE:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_HANDSHAKE )
if(isModeChange())
{
Charger.isCP_in_B = OFF ;
Charger.isTestLeakModule = ON ;
#ifdef TRIM_CCID_SELFTEST
Proc_CCID_SelfTest();
#endif
//check Leak test pass
if (Charger.Test_LeakModuleisPass)
{
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
#ifdef MODIFY_MODE_HANDSHAKE_STOP_PWM_WITHOUT_OK_STATE
if (Charger.m_bSafetyRegulationGB)
{
if(Charger.CP_State == SYSTEM_STATE_B || Charger.CP_State == SYSTEM_STATE_C)
{
CpTask_CtrlCpPwm_P0();
}
}
else
{
CpTask_CtrlCpPwm_P0();
}
#endif //MODIFY_MODE_HANDSHAKE_STOP_PWM_WITHOUT_OK_STATE
#else //MODIFY_CP_TASK_CTRL_CP_PWM
CpTask_CtrlCpPwm_P0();
#endif //MODIFY_CP_TASK_CTRL_CP_PWM
osDelay(300);
DEBUG_INFO("Leak module self test pass before charging.\r\n");
}
else
{
Charger.Alarm_Code |= ALARM_LEAK_MODULE_FAIL;
DEBUG_INFO("Leak module self test fail before charging.\r\n");
}
Charger.isTestLeakModule = OFF ;
}
if(Charger.CP_State == SYSTEM_STATE_C)
{
#ifdef MODIFY_MODE_HANDSHAKE_STOP_PWM_WITHOUT_OK_STATE
if (Charger.m_bSafetyRegulationGB)
{
Charger.m_bBlockCsuCpPwmDuty = HTK_DISABLE;
if (Charger.m_CP_CurPWM == PWM_DUTY_FULL)
{
CpTask_CtrlCpPwm_P0();
}
}
#endif
setChargerMode(MODE_CHARGING);
timerDisable(TIMER_IDX_CP);
if (Charger.isSetStartTime == ON)
{
Charger.cycle_info.startTimeTick = HAL_GetTick();
Charger.cycle_info.startDateTime.year = Charger.memory.EVSE_Config.data.item.SystemDateTime.year;
Charger.cycle_info.startDateTime.month = Charger.memory.EVSE_Config.data.item.SystemDateTime.month;
Charger.cycle_info.startDateTime.day = Charger.memory.EVSE_Config.data.item.SystemDateTime.day;
Charger.cycle_info.startDateTime.hour = Charger.memory.EVSE_Config.data.item.SystemDateTime.hour;
Charger.cycle_info.startDateTime.min = Charger.memory.EVSE_Config.data.item.SystemDateTime.min;
Charger.cycle_info.startDateTime.sec = Charger.memory.EVSE_Config.data.item.SystemDateTime.sec;
Charger.cycle_info.meterStart = Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total;
}
}
if (Charger.CP_State == SYSTEM_STATE_B)
{
#ifdef MODIFY_MODE_HANDSHAKE_STOP_PWM_WITHOUT_OK_STATE
if (Charger.m_bSafetyRegulationGB)
{
Charger.m_bBlockCsuCpPwmDuty = HTK_DISABLE;
if (Charger.m_CP_CurPWM == PWM_DUTY_FULL)
{
CpTask_CtrlCpPwm_P0();
}
}
#endif
Charger.isCP_in_B = ON ;
}
#ifdef MODIFY_CPTASK_TYPE_E
if (Charger.CP_State == SYSTEM_STATE_A && IsTypeEPlugIn())
#else
//if((Charger.CP_State == SYSTEM_STATE_A) && HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin))
#endif
{
Charger.isOnSocketE = ON;
setChargerMode(MODE_CHARGING);
timerDisable(TIMER_IDX_CP);
if (Charger.isSetStartTime == ON)
{
Charger.cycle_info.startTimeTick = HAL_GetTick();
Charger.cycle_info.startDateTime.year = Charger.memory.EVSE_Config.data.item.SystemDateTime.year;
Charger.cycle_info.startDateTime.month = Charger.memory.EVSE_Config.data.item.SystemDateTime.month;
Charger.cycle_info.startDateTime.day = Charger.memory.EVSE_Config.data.item.SystemDateTime.day;
Charger.cycle_info.startDateTime.hour = Charger.memory.EVSE_Config.data.item.SystemDateTime.hour;
Charger.cycle_info.startDateTime.min = Charger.memory.EVSE_Config.data.item.SystemDateTime.min;
Charger.cycle_info.startDateTime.sec = Charger.memory.EVSE_Config.data.item.SystemDateTime.sec;
Charger.cycle_info.meterStart = Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total;
}
}
if(((Charger.CP_State == SYSTEM_STATE_A) && Charger.isCP_in_B) || !Charger.am3352.isRequestOn)
{
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL); // close pwm
setChargerMode(MODE_IDLE);
timerDisable(TIMER_IDX_CP);
}
#ifdef MODIFY_MODE_HANDSHAKE_STOP_PWM_WITHOUT_OK_STATE
if (Charger.m_bSafetyRegulationGB)
{
if (
(Charger.CP_State == SYSTEM_STATE_D || Charger.CP_State == SYSTEM_STATE_E) &&
(Charger.am3352.isRequestOn)
)
{
Charger.m_bBlockCsuCpPwmDuty = HTK_ENABLE;
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
}
}
#endif
break;
case MODE_CHARGING:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_CHARGING )
if(isModeChange())
{
#ifdef MODIFY_CPTASK_CSU_0_1_CHARGE_MODE
CpTask_CtrlCpPwm_P0();
#endif
}
if (
#ifdef MODIFY_AW_CP_TASK_CSU_0_1_CHARGING_MODE_STOP_WITHOUT_STATE_C
(!Charger.isOnSocketE && Charger.CP_State != SYSTEM_STATE_C) ||
#else
((!Charger.isOnSocketE) && (Charger.CP_State != SYSTEM_STATE_C) && (Charger.CP_State != SYSTEM_STATE_UNKNOWN)) ||
#endif
#ifdef MODIFY_CPTASK_TYPE_E
(Charger.isOnSocketE && !IsTypeEPlugIn()) ||
#else
//((Charger.isOnSocketE) && !HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin)) ||
#endif
!Charger.am3352.isRequestOn
)
{
setChargerMode(MODE_STOP);
if (Charger.CP_State != SYSTEM_STATE_C)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_MODE_CHARGING_STOP_PWM_WITHOUT_OK_STATE
if (Charger.m_bSafetyRegulationGB)
{
if (
(Charger.CP_State == SYSTEM_STATE_D || Charger.CP_State == SYSTEM_STATE_E) &&
(Charger.am3352.isRequestOn)
)
{
Charger.m_bBlockCsuCpPwmDuty = HTK_ENABLE;
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
}
}
#endif //MODIFY_MODE_CHARGING_STOP_PWM_WITHOUT_OK_STATE
}
}
#ifdef FUNC_RELAY_OFF_WHEN_CSU_CMD_TIMEOUT
else if (HTK_IsTimeout(Charger.m_CSU_RxTick, CSU_CMD_TIMEOUT_SEC * 1000))
{
if (Charger.Relay_Action != GPIO_RELAY_ACTION_OFF)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
XP("# RELAY => OFF\r\n");
}
if (Charger.SE_Relay_Action != GPIO_SE_RELAY_ACTION_OFF)
{
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
XP("# RELAY_SE => OFF\r\n");
}
#ifdef FUNC_REQUEST_OFF_WHEN_CSU_CMD_TIMEOUT
if (Charger.am3352.isRequestOn != OFF)
{
Charger.am3352.isRequestOn = OFF;
XP("# REQUEST => OFF\r\n");
}
#endif
}
#endif //FUNC_RELAY_OFF_WHEN_CSU_CMD_TIMEOUT
else
{
duration_delta = (HAL_GetTick() - Charger.cycle_info.startTimeTick);
Charger.cycle_info.Duration = duration_delta;
Charger.cycle_info.Power_Consumption = Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total - Charger.cycle_info.meterStart;
}
break;
case MODE_STOP:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_STOP )
if(isModeChange())
{
Charger.isSetStartTime = OFF ;
Charger.isCP_in_B = OFF ;
if (!Charger.am3352.isRequestOn) //represent swip card stop charge in 6V
{
Charger.rfid.op_bits.reqStop = ON ;
}
}
if(!Charger.am3352.isRequestOn)
{
if (Charger.rfid.op_bits.reqStop == ON || (Charger.CP_State == SYSTEM_STATE_B)) //1. swip card stop charge in 6V. , 2.cp-> B then swip card stop charge
{
if(Charger.CP_State == SYSTEM_STATE_B)
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
Charger.rfid.op_bits.reqStop = OFF;
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL); // close pwm
timerEnable( TIMER_IDX_RFID_RELAY_OFF, 3000); //is set wait 3 sec
Charger.cycle_info.endTimeTick = HAL_GetTick();
#ifndef FUNC_METER_IC_HISTORY
recordChargingHis(OFF, END_STATUS_CODE_NORMAL);
#endif
Charger.isCP_in_B = OFF ;
}
if (timer[TIMER_IDX_RFID_RELAY_OFF].isAlarm == ON ) //is wait 3 sec
{
timerDisable(TIMER_IDX_RFID_RELAY_OFF);
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef FUNC_BLOCK_CSU_CONFIG_CP_PWM_DUTY
Charger.m_bBlockCsuCpPwmDuty = HTK_DISABLE;
#endif
setChargerMode(MODE_IDLE);
Charger.cycle_info.StartType = START_METHOD_NONE;
}
}
else if
(
(!Charger.isOnSocketE && Charger.CP_State == SYSTEM_STATE_A) ||
#ifdef MODIFY_CPTASK_TYPE_E
(Charger.isOnSocketE && !IsTypeEPlugIn())
#else
//(Charger.isOnSocketE && !HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin))
#endif
)
{
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL); // close pwm
Charger.cycle_info.endTimeTick = HAL_GetTick();
#ifndef FUNC_METER_IC_HISTORY
recordChargingHis(OFF, END_STATUS_CODE_NORMAL);
#endif
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef FUNC_BLOCK_CSU_CONFIG_CP_PWM_DUTY
Charger.m_bBlockCsuCpPwmDuty = HTK_DISABLE;
#endif
setChargerMode(MODE_IDLE);
Charger.isCP_in_B = OFF ;
}
else // Charger.am3352.isRequestOn == 1
{
if((Charger.CP_State == SYSTEM_STATE_B))
{
timerDisable(TIMER_IDX_RFID_RELAY_OFF);
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
Charger.isCP_in_B = ON ;
}
if((Charger.CP_State == SYSTEM_STATE_C) && (!Charger.am3352.isRequestOff) )
{
#ifdef FUNC_BLOCK_CSU_CONFIG_CP_PWM_DUTY
Charger.m_bBlockCsuCpPwmDuty = HTK_DISABLE;
#endif
setChargerMode(MODE_HANDSHAKE);
}
#ifdef MODIFY_MODE_STOP_STOP_PWM_WITHOUT_OK_STATE
if (Charger.m_bSafetyRegulationGB)
{
if (
(Charger.CP_State == SYSTEM_STATE_D || Charger.CP_State == SYSTEM_STATE_E) &&
(Charger.am3352.isRequestOn)
)
{
Charger.m_bBlockCsuCpPwmDuty = HTK_ENABLE;
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
}
if ((Charger.CP_State == SYSTEM_STATE_B) && (Charger.am3352.isRequestOn))
{
Charger.m_bBlockCsuCpPwmDuty = HTK_DISABLE;
if (Charger.m_CP_CurPWM == PWM_DUTY_FULL)
{
CpTask_CtrlCpPwm_P0();
}
}
}
#endif //MODIFY_MODE_STOP_STOP_PWM_WITHOUT_OK_STATE
}
break;
case MODE_ALARM:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_ALARM )
if(isModeChange())
{
Charger.isSetStartTime = OFF ;
if (Charger.CSUisReady == ON )
{
//clear blink time , Prevent red light from being snatched by others
disblinkerTime (BLINKER_IDX_LED) ;
//clear led Action
Charger.am3352.LedActionState = 0 ;
}
}
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E_CSU_SE_RELAY_AUTO_OFF
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
#ifdef FUNC_MODE_ALARM_TO_MODE_DEBUG
if (Charger.isDebugEnable && Charger.Alarm_Code == 0)
{
setChargerMode(MODE_DEBUG);
}
else
#endif
if(Charger.Alarm_Code == 0x00)
{
Charger.am3352.LedActionState = 0 ;
if (Charger.Mode_Before_Alarm == MODE_CHARGING) // in charging mode
{
#ifdef FUNC_CCS
#ifdef MODIFY_CPTASK_CSU_MODE_ALARM_GO_HANDSHAKE_WITH_NEW_CONDITION
if(Charger.CP_State != SYSTEM_STATE_A && Charger.am3352.isRequestOn)
#else
if(Charger.CP_State == SYSTEM_STATE_B || Charger.CP_State == SYSTEM_STATE_C)
#endif
#else //FUNC_CCS
if(Charger.CP_State == SYSTEM_STATE_B ) // to handshake
#endif //FUNC_CCS
{
setChargerMode(MODE_HANDSHAKE);
}
else // to idle //SYSTEM_STATE_A
{
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
setChargerMode(MODE_IDLE);
}
}
else if(Charger.Mode_Before_Alarm == MODE_STOP)
{
if (Charger.isCP_in_B == ON) // to handshake
{
setChargerMode(MODE_HANDSHAKE);
}
else // to stop
{
setChargerMode(MODE_STOP);
}
}
else // to idle
{
if(timer[TIMER_IDX_STATE_E].isAlarm == ON)
{
setChargerMode(MODE_IDLE);
}
}
}
break;
case MODE_DEBUG:
//=============================( MODIFY_CPTASK_TYPE_E / MODE_DEBUG )
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
if(isModeChange())
{
setLedMotion(LED_ACTION_DEBUG);
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
timerEnable(TIMER_IDX_DEBUG, FUNC_MODE_DEBUG_RELAY_ON_SEC * 1000);
#else
timerEnable(TIMER_IDX_DEBUG, 2000);
#endif
}
if (timer[TIMER_IDX_DEBUG].isAlarm &&
Charger.Alarm_Code == 0 &&
Charger.CP_State == SYSTEM_STATE_C)
{
if (Charger.Relay_Action == GPIO_RELAY_ACTION_ON)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
timerRefresh(TIMER_IDX_DEBUG);
timerEnable(TIMER_IDX_DEBUG, FUNC_MODE_DEBUG_RELAY_OFF_SEC * 1000);
#else
timerRefresh(TIMER_IDX_DEBUG);
#endif
}
else if (Charger.Relay_Action == GPIO_RELAY_ACTION_OFF)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
#ifdef FUNC_MODE_DEBUG_REC_RELAY_ON_TIMES
Charger.memory.EVSE_Config.data.item.m_ModeDebugRelayOnTimes++;
Charger.memory.EVSE_Config.op_bits.update = ON;
#endif
#ifdef FUNC_MODE_DEBUG_RELAY_ON_OFF_DIFF_SEC
timerRefresh(TIMER_IDX_DEBUG);
timerEnable(TIMER_IDX_DEBUG, FUNC_MODE_DEBUG_RELAY_ON_SEC * 1000);
#else
timerRefresh(TIMER_IDX_DEBUG);
#endif
}
}
#else //FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
if(isModeChange())
{
setLedMotion(LED_ACTION_DEBUG);
Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
timerEnable(TIMER_IDX_DEBUG, 1000);
}
if(timer[TIMER_IDX_DEBUG].isAlarm || (Charger.Alarm_Code>0))
{
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
Charger.isDebugModeCPtest = ON;
}
if(Charger.isDebugModeCPtest)
{
if(Charger.CP_State == SYSTEM_STATE_A)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = Charger.maxRatingCurrent;
#ifdef MODIFY_AC_EVSE_STATUS_MAX_CHARGING_CURRENT_VARIABLE
Charger.AC_MaxChargingCurrentOrDuty = Charger.maxRatingCurrent;
#endif
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
}
else if (Charger.CP_State == SYSTEM_STATE_B)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF;
#ifdef MODIFY_CPTASK_TYPE_E
Charger.SE_Relay_Action = GPIO_SE_RELAY_ACTION_OFF;
#endif
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
CpTask_CtrlCpPwm_P1();
#endif
}
else if (Charger.CP_State == SYSTEM_STATE_C)
{
Charger.Relay_Action = GPIO_RELAY_ACTION_ON;
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
CpTask_CtrlCpPwm_P1();
#endif
}
}
#endif //FUNC_MODE_DEBUG_RELAY_ON_OFF_TEST_FOR_PHN_QE
break;
default:
setChargerMode(MODE_IDLE);
break;
}
}
else
{
/*By Pass Mode*/
}
osDelay(1);
}
/* USER CODE END StartCpTask */
}
/* USER CODE BEGIN Header_StartAlarmTask */
/**
* @brief Function implementing the alarmTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartAlarmTask */
void StartAlarmTask(void const * argument)
{
/* USER CODE BEGIN StartAlarmTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
IdleUntilReadAllMemory();
#endif
//aalarm
//timerEnable(TIMER_IDX_PE_DETECT, 30000);
timerEnable(TIMER_IDX_PE_DETECT, 40000);
#ifndef RECODE_METER_PRO380
#ifdef MODIFY_METER_EXT_PRO380
Charger.m_MeterPRO380.m_LastUpdateTick = HAL_GetTick();
#endif
#endif //!RECODE_METER_PRO380
/* Infinite loop */
for(;;)
{
#ifdef FUNC_MODE_DEBUG_WITH_NORMAL_ALARM_DETECTE
if(Charger.Mode != MODE_INITIAL)
#else
if(Charger.Mode != MODE_INITIAL && Charger.Mode != MODE_DEBUG)
#endif
{
recordAlarmHis();
#ifdef FUNC_AX32_TRIG_LEAKAGE
if (Charger.m_b3PhaseModel)
{
if (Charger.Alarm_Code & ALARM_RELAY_STATUS && //Relay Welding
(!HTK_IsInTime(Charger.AlarmRelayWeldingOccurTick, 1000))
)
{
TrigLeakage_Trig();
TrigLeakage_Proc();
}
}
#endif
#ifdef FUNC_AX80_ADD_TILT_SENSOR
#ifdef FUNC_ADD_TILT_SENSOR_MODEL
if (Charger.m_bUseTiltSensor)
#else
if (Charger.m_bModelNameAX80_1P)
#endif
{
if (Charger.Alarm_Code & ALARM_TILT_SENSOR &&
(!HTK_IsInTime(Charger.AlarmTiltSensorOccurTick, 1000))
)
{
#ifdef FUNC_DISABLE_TILT_SENSOR_FOR_TEST
if (HTK_IsInTime(Charger.m_BootTick, 1000 * 30))
{
Charger.m_bDisableTiltSensorForTest = 1;
Charger.Alarm_Code &= ~ALARM_TILT_SENSOR;
DEBUG_ERROR("Alarm tilt sensor fault recover. [TEST MODE WITHOUT TILT SENSOR ALARM]\r\n");
Charger.counter.TiltSensor.fail = 0;
}
else
{
TILT_TrigLeakage_Trig();
TILT_TrigLeakage_Proc();
}
#else
TILT_TrigLeakage_Trig();
TILT_TrigLeakage_Proc();
#endif
}
}
#endif //FUNC_AX80_ADD_TILT_SENSOR
//================================
// CP fail alarm detect
//================================
#ifdef CP_ALARM_PROTECT
if ((Charger.CP_State == SYSTEM_STATE_UNKNOWN)&&(!(Charger.Alarm_Code & ALARM_MCU_TESTFAIL)))
{
#ifdef MODIFY_ALARM_CP_ERROR_RECOVER_USE_RESTORE
if(!(Charger.Alarm_Code & ALARM_CP_ERROR))
{
if (Charger.counter.CP.fail > 1000)
{
Charger.counter.CP.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_CP_ERROR;
DEBUG_ERROR("Alarm CP occur.\r\n");
Charger.counter.CP.restore = 0;
}
else
{
Charger.counter.CP.fail++;
}
}
#endif //MODIFY_ALARM_CP_ERROR_RECOVER_USE_RESTORE
}
#ifdef MODIFY_ALARMTASK_CP_ERROR_RECOVER
else if (Charger.CP_State != SYSTEM_STATE_UNKNOWN)
#else
else if ((Charger.CP_State != SYSTEM_STATE_UNKNOWN)&&(Charger.CP_State!=SYSTEM_STATE_D)&&
(Charger.CP_State != SYSTEM_STATE_E)&&(Charger.CP_State != SYSTEM_STATE_F))
#endif
{
#ifdef MODIFY_ALARM_CP_ERROR_RECOVER_USE_RESTORE
if (Charger.Alarm_Code & ALARM_CP_ERROR)
{
if (Charger.counter.CP.restore > 1000)
{
Charger.Alarm_Code &= ~ALARM_CP_ERROR;
DEBUG_INFO("Alarm CP recover.\r\n");
Charger.counter.CP.fail = 0;
}
else
{
Charger.counter.CP.restore++;
}
}
#endif //MODIFY_ALARM_CP_ERROR_RECOVER_USE_RESTORE
}
#ifdef FUNC_ALARM_CP_NEG_ERROR
if ((!CP_IsInSpec_N12V(&CpDetectionResult))&&(!(Charger.Alarm_Code & ALARM_MCU_TESTFAIL)))
{
#ifdef MODIFY_ALARM_CP_NEG_ERROR_RECOVER_USE_RESTORE
if (!(Charger.Alarm_Code & ALARM_CP_NEG_ERROR))
{
if (Charger.counter.CP_Neg.fail > 1000)
{
Charger.counter.CP_Neg.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_CP_NEG_ERROR;
DEBUG_ERROR("Alarm CP_NEG occur.\r\n");
Charger.counter.CP_Neg.restore = 0;
}
else
{
Charger.counter.CP_Neg.fail++;
}
}
#endif //MODIFY_ALARM_CP_NEG_ERROR_RECOVER_USE_RESTORE
}
else
{
#ifdef MODIFY_ALARM_CP_NEG_ERROR_RECOVER_USE_RESTORE
if (Charger.Alarm_Code & ALARM_CP_NEG_ERROR)
{
if (Charger.counter.CP_Neg.restore > 1000)
{
Charger.Alarm_Code &= ~ALARM_CP_NEG_ERROR;
DEBUG_INFO("Alarm CP_NEG recover.\r\n");
Charger.counter.CP_Neg.fail = 0;
}
else
{
Charger.counter.CP_Neg.restore++;
}
}
#endif //MODIFY_ALARM_CP_NEG_ERROR_RECOVER_USE_RESTORE
}
#endif //FUNC_ALARM_CP_NEG_ERROR
#endif //CP_ALARM_PROTECT
//================================
// Over voltage alarm detect
//================================
#ifdef OVP_PROTECT
//--------------------------------
// L1 Over voltage
if(Charger.Voltage[0] > ALARM_SPEC_OV)
{
if(Charger.counter.L1_OV.fail > 1000)
{
Charger.counter.L1_OV.restore = 0 ;
if(!(Charger.Alarm_Code & ALARM_L1_OVER_VOLTAGE))
{
Charger.Alarm_Code |= ALARM_L1_OVER_VOLTAGE;
DEBUG_ERROR("Alarm L1_OV occur.\r\n");
}
}
else
Charger.counter.L1_OV.fail++;
}
else if(Charger.Voltage[0] < (ALARM_SPEC_OV-ALARM_SPEC_OUV_HYSTERESIS))
{
if((Charger.Alarm_Code & ALARM_L1_OVER_VOLTAGE))
{
if (Charger.counter.L1_OV.restore > 1000 && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.L1_OV.fail = 0 ;
DEBUG_INFO("Alarm L1_OV is coldpickup ing..... \r\n");
Charger.counter.L1_OV.isOccurInCharging = ((Charger.CP_State == SYSTEM_STATE_B)?ON:OFF);
if (Charger.counter.L1_OV.isOccurInCharging)
{
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
ColdLoadPickup_Delay("Alarm L1_OV is coldpickup ing..... ");
#else
osDelay((rand()%175000)+5000);
#endif
}
Charger.Alarm_Code &= ~ALARM_L1_OVER_VOLTAGE;
DEBUG_INFO("Alarm L1_OV recover.\r\n");
}
else
{
Charger.counter.L1_OV.restore++;
}
}
else
{
Charger.counter.L1_OV.fail = 0 ;
Charger.counter.L1_OV.restore = 0 ;
}
}
#ifdef FUNC_AUTO_IGNORE_AC_PHASE
#ifdef FUNC_AX32_USE_AS_1P_MODEL
if (Charger.m_b3PhaseModel && !Charger.m_b3PhaseModelButUse1PhaseOnly)
#else
if (Charger.m_b3PhaseModel)
#endif
{
#endif
//--------------------------------
// L2 Over voltage
if(Charger.Voltage[1] > ALARM_SPEC_OV)
{
if(Charger.counter.L2_OV.fail > 1000)
{
Charger.counter.L2_OV.restore = 0 ;
if(!(Charger.Alarm_Code & ALARM_L2_OVER_VOLTAGE))
{
Charger.Alarm_Code |= ALARM_L2_OVER_VOLTAGE;
DEBUG_ERROR("Alarm L2_OV occur.\r\n");
}
}
else
Charger.counter.L2_OV.fail++;
}
else if(Charger.Voltage[1] < (ALARM_SPEC_OV-ALARM_SPEC_OUV_HYSTERESIS))
{
if((Charger.Alarm_Code & ALARM_L2_OVER_VOLTAGE))
{
if (Charger.counter.L2_OV.restore > 1000 && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.L2_OV.fail = 0 ;
DEBUG_INFO("Alarm L2_OV is coldpickup ing..... \r\n");
Charger.counter.L2_OV.isOccurInCharging = ((Charger.CP_State == SYSTEM_STATE_B)?ON:OFF);
if (Charger.counter.L2_OV.isOccurInCharging)
{
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
ColdLoadPickup_Delay("Alarm L2_OV is coldpickup ing..... ");
#else
osDelay((rand()%175000)+5000);
#endif
}
Charger.Alarm_Code &= ~ALARM_L2_OVER_VOLTAGE;
DEBUG_INFO("Alarm L2_OV recover.\r\n");
}
else
{
Charger.counter.L2_OV.restore++;
}
}
else
{
Charger.counter.L2_OV.fail = 0 ;
Charger.counter.L2_OV.restore = 0 ;
}
}
//--------------------------------
// L3 Over voltage
if(Charger.Voltage[2] > ALARM_SPEC_OV)
{
if(Charger.counter.L3_OV.fail > 1000)
{
Charger.counter.L3_OV.restore = 0 ;
if(!(Charger.Alarm_Code & ALARM_L3_OVER_VOLTAGE))
{
Charger.Alarm_Code |= ALARM_L3_OVER_VOLTAGE;
DEBUG_ERROR("Alarm L3_OV occur.\r\n");
}
}
else
Charger.counter.L3_OV.fail++;
}
else if(Charger.Voltage[2] < (ALARM_SPEC_OV-ALARM_SPEC_OUV_HYSTERESIS))
{
if((Charger.Alarm_Code & ALARM_L3_OVER_VOLTAGE))
{
if (Charger.counter.L3_OV.restore > 1000 && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.L3_OV.fail = 0 ;
DEBUG_INFO("Alarm L3_OV is coldpickup ing..... \r\n");
Charger.counter.L3_OV.isOccurInCharging = ((Charger.CP_State == SYSTEM_STATE_B)?ON:OFF);
if (Charger.counter.L3_OV.isOccurInCharging)
{
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
ColdLoadPickup_Delay("Alarm L3_OV is coldpickup ing..... ");
#else
osDelay((rand()%175000)+5000);
#endif
}
Charger.Alarm_Code &= ~ALARM_L3_OVER_VOLTAGE;
DEBUG_INFO("Alarm L3_OV recover.\r\n");
}
else
{
Charger.counter.L3_OV.restore++;
}
}
else
{
Charger.counter.L3_OV.fail = 0 ;
Charger.counter.L3_OV.restore = 0 ;
}
}
#ifdef FUNC_AUTO_IGNORE_AC_PHASE
}
#endif
#endif //OVP_PROTECT
//================================
// Under voltage alarm detect
//================================
#ifdef UVP_PROTECT
//--------------------------------
// L1 Under voltage
if(Charger.Voltage[0] < ALARM_SPEC_UV)
{
if(Charger.counter.L1_UV.fail > 1000)
{
Charger.counter.L1_UV.restore = 0 ;
if(!(Charger.Alarm_Code & ALARM_L1_UNDER_VOLTAGE))
{
Charger.Alarm_Code |= ALARM_L1_UNDER_VOLTAGE;
DEBUG_ERROR("Alarm L1_UV occur.\r\n");
//************************
XP("Charger.Voltage[0] = %d\r\n", Charger.Voltage[0]);
//************************
}
}
else
Charger.counter.L1_UV.fail++;
}
else if(Charger.Voltage[0] > (ALARM_SPEC_UV+ALARM_SPEC_OUV_HYSTERESIS))
{
if(Charger.Alarm_Code & ALARM_L1_UNDER_VOLTAGE)
{
if (Charger.counter.L1_UV.restore > 1000 && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.L1_UV.fail = 0 ;
DEBUG_INFO("Alarm L1_UV is coldpickup ing..... \r\n"); //Hao#####
Charger.counter.L1_UV.isOccurInCharging = ((Charger.CP_State == SYSTEM_STATE_B)?ON:OFF);
if (Charger.counter.L1_UV.isOccurInCharging)
{
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
ColdLoadPickup_Delay("Alarm L1_UV is coldpickup ing..... ");
#else
osDelay((rand()%175000)+5000);
#endif
}
Charger.Alarm_Code &= ~ALARM_L1_UNDER_VOLTAGE;
DEBUG_INFO("Alarm L1_UV recover.\r\n");
}
else
{
Charger.counter.L1_UV.restore++ ;
}
}
else
{
Charger.counter.L1_UV.restore = 0 ;
Charger.counter.L1_UV.fail = 0 ;
}
}
#ifdef FUNC_AUTO_IGNORE_AC_PHASE
#ifdef FUNC_AX32_USE_AS_1P_MODEL
if (Charger.m_b3PhaseModel && !Charger.m_b3PhaseModelButUse1PhaseOnly)
#else
if (Charger.m_b3PhaseModel)
#endif
{
#endif
//--------------------------------
// L2 Under voltage
if(Charger.Voltage[1] < ALARM_SPEC_UV)
{
if(Charger.counter.L2_UV.fail > 1000)
{
Charger.counter.L2_UV.restore = 0 ;
if(!(Charger.Alarm_Code & ALARM_L2_UNDER_VOLTAGE))
{
Charger.Alarm_Code |= ALARM_L2_UNDER_VOLTAGE;
DEBUG_ERROR("Alarm L2_UV occur.\r\n");
}
}
else
Charger.counter.L2_UV.fail++;
}
else if(Charger.Voltage[1] > (ALARM_SPEC_UV+ALARM_SPEC_OUV_HYSTERESIS))
{
if(Charger.Alarm_Code & ALARM_L2_UNDER_VOLTAGE)
{
if (Charger.counter.L2_UV.restore > 1000 && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.L2_UV.fail = 0 ;
DEBUG_INFO("Alarm L2_UV is coldpickup ing..... \r\n");
Charger.counter.L2_UV.isOccurInCharging = ((Charger.CP_State == SYSTEM_STATE_B)?ON:OFF);
if (Charger.counter.L2_UV.isOccurInCharging)
{
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
ColdLoadPickup_Delay("Alarm L2_UV is coldpickup ing..... ");
#else
osDelay((rand()%175000)+5000);
#endif
}
Charger.Alarm_Code &= ~ALARM_L2_UNDER_VOLTAGE;
DEBUG_INFO("Alarm L2_UV recover.\r\n");
}
else
{
Charger.counter.L2_UV.restore++ ;
}
}
else
{
Charger.counter.L2_UV.restore = 0 ;
Charger.counter.L2_UV.fail = 0 ;
}
}
//--------------------------------
// L3 Under voltage
if(Charger.Voltage[2] < ALARM_SPEC_UV)
{
if(Charger.counter.L3_UV.fail > 1000)
{
Charger.counter.L3_UV.restore = 0 ;
if(!(Charger.Alarm_Code & ALARM_L3_UNDER_VOLTAGE))
{
Charger.Alarm_Code |= ALARM_L3_UNDER_VOLTAGE;
DEBUG_ERROR("Alarm L3_UV occur.\r\n");
}
}
else
Charger.counter.L3_UV.fail++;
}
else if(Charger.Voltage[2] > (ALARM_SPEC_UV+ALARM_SPEC_OUV_HYSTERESIS))
{
if(Charger.Alarm_Code & ALARM_L3_UNDER_VOLTAGE)
{
if (Charger.counter.L3_UV.restore > 1000 && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.L3_UV.fail = 0 ;
DEBUG_INFO("Alarm L3_UV is coldpickup ing..... \r\n");
Charger.counter.L3_UV.isOccurInCharging = ((Charger.CP_State == SYSTEM_STATE_B)?ON:OFF);
if (Charger.counter.L3_UV.isOccurInCharging)
{
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
ColdLoadPickup_Delay("Alarm L3_UV is coldpickup ing..... ");
#else
osDelay((rand()%175000)+5000);
#endif
}
Charger.Alarm_Code &= ~ALARM_L3_UNDER_VOLTAGE;
DEBUG_INFO("Alarm L3_UV recover.\r\n");
}
else
{
Charger.counter.L3_UV.restore++ ;
}
}
else
{
Charger.counter.L3_UV.restore = 0 ;
Charger.counter.L3_UV.fail = 0 ;
}
}
#ifdef FUNC_AUTO_IGNORE_AC_PHASE
}
#endif
#endif //UVP_PROTECT
//================================
// Over current alarm detect
//================================
#ifdef OCP_PROTECT
#ifdef FUNC_OCP_WITH_PP
{
uint16_t CurMaxCurr = 0; //A
uint16_t OC_BegThreshold = 0; //Occur: 0.01A
uint16_t OC_EndThreshold = 0; //Recover: 0.01A
#ifdef FUNC_CCS
//// if (Charger.m_bRunCCS)
//// {
//// CurMaxCurr = Charger.maxRatingCurrent;
//// }
//// else
//// {
//// CurMaxCurr = HTK_GET_VAL_MIN(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent, Charger.maxRatingCurrent);
//// }
CurMaxCurr = HTK_GET_VAL_MIN(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent, Charger.maxRatingCurrent);
#else
CurMaxCurr = HTK_GET_VAL_MIN(Charger.memory.EVSE_Config.data.item.MaxChargingCurrent, Charger.maxRatingCurrent);
#endif
if (Charger.m_bDetectPP)
{
CurMaxCurr = HTK_GET_VAL_MIN(CurMaxCurr, Charger.m_PPInfo.m_CurCurr);
}
#ifdef MODIFY_SOCKET_E_OCP_USE_MAX_CHARGING_CURRENT
if (Charger.isOnSocketE == ON)
{
CurMaxCurr = Charger.memory.EVSE_Config.data.item.MaxChargingCurrent;
}
#endif
#ifdef MODIFY_OCP_PROC_WITH_MODELNAME_IDX_3_EURO_SPEC
if (Charger.m_bModelNameWithEuroSpecOCP)
#else
if (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'E')
#endif
{
OC_BegThreshold = (CurMaxCurr * Charger.OCP_Magnification) + 0;
OC_EndThreshold = (CurMaxCurr * Charger.OCP_Magnification) - 200;
}
else
{
if (CurMaxCurr > 20)
{
OC_BegThreshold = (CurMaxCurr * Charger.OCP_Magnification) + 0;
OC_EndThreshold = (CurMaxCurr * Charger.OCP_Magnification) - 200;
}
else
{
OC_BegThreshold = (CurMaxCurr * 100) + 200;
OC_EndThreshold = (CurMaxCurr * 100) + 0;
}
}
Charger.m_OCP_CurMaxCurr = CurMaxCurr;
Charger.m_OCP_BegThreshold = OC_BegThreshold;
Charger.m_OCP_EndThreshold = OC_EndThreshold;
#ifdef FUNC_SET_AT32_MODEL_SCP_SPEC_VAL_HIGHER_TO_AVOID_SCP_ALARM
u32 CurSCP_SPEC = SCP_SPEC_VAL;
if (Charger.m_bModelNameAT)
{
CurSCP_SPEC = (u32)SCP_SPEC_VAL * 1000;
}
#endif
//--------------------------------
// L1 Over current
#ifdef FUNC_SET_AT32_MODEL_SCP_SPEC_VAL_HIGHER_TO_AVOID_SCP_ALARM
if((u32)Charger.Current[0] >= CurSCP_SPEC)
#else
if(Charger.Current[0] >= SCP_SPEC_VAL)
#endif
{
if(Charger.counter.L1_OC.fail > 5)
{
if(!(Charger.Alarm_Code & ALARM_L1_CIRCUIT_SHORT))
{
Charger.counter.L1_OC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_L1_CIRCUIT_SHORT;
if (Charger.counter.L1_OC.isLatch == OFF)
{
Charger.counter.L1_OC.isLatch = ON ;
setLedMotion(LED_ACTION_ALARM);
timerDisable(TIMER_IDX_RETRY_OC);
}
DEBUG_INFO("Correction Current[0]: %f\r\n", Charger.Current[0]/100.0);
DEBUG_ERROR("Alarm L1 SCP occur.\r\n");
}
}
else
Charger.counter.L1_OC.fail++;
}
//#ifdef MODIFY_OCP_SPEC
// else if(Charger.Current[0] > (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent?(Charger.maxRatingCurrent>20 ? ((Charger.maxRatingCurrent*Charger.OCP_Magnification)):((Charger.maxRatingCurrent+2)*100)) : (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )):((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+2)*100))))
//#else
// else if(Charger.Current[0] > (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent?(Charger.maxRatingCurrent>20 ? ((Charger.maxRatingCurrent*Charger.OCP_Magnification)-100):((Charger.maxRatingCurrent+1)*100)) : (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )-100):((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+1)*100))))
//#endif
else if (Charger.Current[0] > OC_BegThreshold)
{
if(Charger.counter.L1_OC.fail > 6000)
{
if(!(Charger.Alarm_Code & ALARM_L1_OVER_CURRENT))
{
Charger.counter.L1_OC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_L1_OVER_CURRENT;
DEBUG_INFO("Correction Current[0]: %f\r\n", Charger.Current[0]/100.0);
DEBUG_ERROR("Alarm L1_OC occur.\r\n");
timerEnable(TIMER_IDX_RETRY_OC, ALARM_RETRY_INTERVAL_OC);
Charger.counter.L1_OC.retry++;
}
}
else
Charger.counter.L1_OC.fail++;
}
//else if((Charger.Current[0] < ((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent)?((Charger.maxRatingCurrent>20?(Charger.maxRatingCurrent*Charger.OCP_Magnification )-200:((Charger.maxRatingCurrent+2)*100)-200)):( (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )-200):(((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+2)*100)-200))))))
else if (Charger.Current[0] < OC_EndThreshold)
{
Charger.counter.L1_OC.fail = 0;
if (Charger.counter.L1_OC.retry> ALARM_OC_RETRY_COUNT)
{
if (Charger.counter.L1_OC.isLatch == OFF)
{
Charger.counter.L1_OC.isLatch = ON ;
setLedMotion(LED_ACTION_ALARM);
timerDisable(TIMER_IDX_RETRY_OC);
}
}
else if((Charger.Alarm_Code & ALARM_L1_OVER_CURRENT) &&
(Charger.counter.L1_OC.retry <= ALARM_OC_RETRY_COUNT) &&
(timer[TIMER_IDX_RETRY_OC].isAlarm == ON) &&
blinker[BLINKER_IDX_LED].blinkisFinish )
{
Charger.Alarm_Code &= ~ALARM_L1_OVER_CURRENT;
Charger.Alarm_Code &= ~ALARM_L1_CIRCUIT_SHORT;
DEBUG_INFO("Alarm L1_OC recover.\r\n");
if(!(Charger.Alarm_Code & ALARM_L1_OVER_CURRENT) && !(Charger.Alarm_Code & ALARM_L2_OVER_CURRENT) && !(Charger.Alarm_Code & ALARM_L3_OVER_CURRENT))
timerDisable(TIMER_IDX_RETRY_OC);
}
}
#ifdef FUNC_AUTO_IGNORE_AC_PHASE
#ifdef FUNC_AX32_USE_AS_1P_MODEL
if (Charger.m_b3PhaseModel && !Charger.m_b3PhaseModelButUse1PhaseOnly)
#else
if (Charger.m_b3PhaseModel)
#endif
{
#endif
//--------------------------------
// L2 Over current
#ifdef FUNC_SET_AT32_MODEL_SCP_SPEC_VAL_HIGHER_TO_AVOID_SCP_ALARM
if((u32)Charger.Current[1] >= CurSCP_SPEC)
#else
if(Charger.Current[1] >= SCP_SPEC_VAL)
#endif
{
if(Charger.counter.L2_OC.fail > 5)
{
if(!(Charger.Alarm_Code & ALARM_L2_CIRCUIT_SHORT))
{
Charger.counter.L2_OC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_L2_CIRCUIT_SHORT;
if (Charger.counter.L2_OC.isLatch == OFF)
{
Charger.counter.L2_OC.isLatch = ON ;
setLedMotion(LED_ACTION_ALARM);
timerDisable(TIMER_IDX_RETRY_OC);
}
DEBUG_INFO("Correction Current[1]: %f\r\n", Charger.Current[1]/100.0);
DEBUG_ERROR("Alarm L2 SCP occur.\r\n");
}
}
else
Charger.counter.L2_OC.fail++;
}
//#ifdef MODIFY_OCP_SPEC
// else if(Charger.Current[1] > (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent?(Charger.maxRatingCurrent>20 ? ((Charger.maxRatingCurrent*Charger.OCP_Magnification)):((Charger.maxRatingCurrent+2)*100)) : (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )):((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+2)*100))))
//#else
// else if(Charger.Current[1] > (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent?(Charger.maxRatingCurrent>20 ? ((Charger.maxRatingCurrent*Charger.OCP_Magnification)-100):((Charger.maxRatingCurrent+1)*100)) : (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )-100):((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+1)*100))))
//#endif
else if (Charger.Current[1] > OC_BegThreshold)
{
if(Charger.counter.L2_OC.fail > 6000)
{
if(!(Charger.Alarm_Code & ALARM_L2_OVER_CURRENT))
{
Charger.counter.L2_OC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_L2_OVER_CURRENT;
DEBUG_INFO("Correction Current[1]: %f\r\n", Charger.Current[1]/100.0);
DEBUG_ERROR("Alarm L2_OC occur.\r\n");
timerEnable(TIMER_IDX_RETRY_OC, ALARM_RETRY_INTERVAL_OC);
Charger.counter.L2_OC.retry++;
}
}
else
Charger.counter.L2_OC.fail++;
}
//else if((Charger.Current[1] < ((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent)?((Charger.maxRatingCurrent>20?(Charger.maxRatingCurrent*Charger.OCP_Magnification )-200:((Charger.maxRatingCurrent+2)*100)-200)):( (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )-200):(((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+2)*100)-200))))))
else if (Charger.Current[1] < OC_EndThreshold)
{
Charger.counter.L2_OC.fail = 0;
if (Charger.counter.L2_OC.retry > ALARM_OC_RETRY_COUNT)
{
if (Charger.counter.L2_OC.isLatch == OFF)
{
Charger.counter.L2_OC.isLatch = ON ;
setLedMotion(LED_ACTION_ALARM);
timerDisable(TIMER_IDX_RETRY_OC);
}
}
else if((Charger.Alarm_Code & ALARM_L2_OVER_CURRENT) &&
(Charger.counter.L2_OC.retry <= ALARM_OC_RETRY_COUNT) &&
(timer[TIMER_IDX_RETRY_OC].isAlarm == ON) &&
blinker[BLINKER_IDX_LED].blinkisFinish )
{
Charger.Alarm_Code &= ~ALARM_L2_OVER_CURRENT;
Charger.Alarm_Code &= ~ALARM_L2_CIRCUIT_SHORT;
DEBUG_INFO("Alarm L2_OC recover.\r\n");
if(!(Charger.Alarm_Code & ALARM_L1_OVER_CURRENT) && !(Charger.Alarm_Code & ALARM_L2_OVER_CURRENT) && !(Charger.Alarm_Code & ALARM_L3_OVER_CURRENT))
timerDisable(TIMER_IDX_RETRY_OC);
}
}
//--------------------------------
// L3 Over current
#ifdef FUNC_SET_AT32_MODEL_SCP_SPEC_VAL_HIGHER_TO_AVOID_SCP_ALARM
if((u32)Charger.Current[2] >= CurSCP_SPEC)
#else
if(Charger.Current[2] >= SCP_SPEC_VAL)
#endif
{
if(Charger.counter.L3_OC.fail > 5)
{
if(!(Charger.Alarm_Code & ALARM_L3_CIRCUIT_SHORT))
{
Charger.counter.L3_OC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_L3_CIRCUIT_SHORT;
if (Charger.counter.L3_OC.isLatch == OFF)
{
Charger.counter.L3_OC.isLatch = ON ;
setLedMotion(LED_ACTION_ALARM);
timerDisable(TIMER_IDX_RETRY_OC);
}
DEBUG_INFO("Correction Current[2]: %f\r\n", Charger.Current[2]/100.0);
DEBUG_ERROR("Alarm L3 SCP occur.\r\n");
}
}
else
Charger.counter.L3_OC.fail++;
}
//#ifdef MODIFY_OCP_SPEC
// else if(Charger.Current[2] > (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent?(Charger.maxRatingCurrent>20 ? ((Charger.maxRatingCurrent*Charger.OCP_Magnification)):((Charger.maxRatingCurrent+2)*100)) : (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )):((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+2)*100))))
//#else
// else if(Charger.Current[2] > (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent?(Charger.maxRatingCurrent>20 ? ((Charger.maxRatingCurrent*Charger.OCP_Magnification)-100):((Charger.maxRatingCurrent+1)*100)) : (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )-100):((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+1)*100))))
//#endif
else if (Charger.Current[2] > OC_BegThreshold)
{
if(Charger.counter.L3_OC.fail > 6000)
{
if(!(Charger.Alarm_Code & ALARM_L3_OVER_CURRENT))
{
Charger.counter.L3_OC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_L3_OVER_CURRENT;
DEBUG_INFO("Correction Current[2]: %f\r\n", Charger.Current[2]/100.0);
DEBUG_ERROR("Alarm L3_OC occur.\r\n");
timerEnable(TIMER_IDX_RETRY_OC, ALARM_RETRY_INTERVAL_OC);
Charger.counter.L3_OC.retry++;
}
}
else
Charger.counter.L3_OC.fail++;
}
//else if((Charger.Current[2] < ((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>=Charger.maxRatingCurrent)?((Charger.maxRatingCurrent>20?(Charger.maxRatingCurrent*Charger.OCP_Magnification )-200:((Charger.maxRatingCurrent+2)*100)-200)):( (Charger.memory.EVSE_Config.data.item.MaxChargingCurrent>20?((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent*Charger.OCP_Magnification )-200):(((Charger.memory.EVSE_Config.data.item.MaxChargingCurrent+2)*100)-200))))))
else if (Charger.Current[2] < OC_EndThreshold)
{
Charger.counter.L3_OC.fail = 0;
if (Charger.counter.L3_OC.retry > ALARM_OC_RETRY_COUNT)
{
if (Charger.counter.L3_OC.isLatch == OFF)
{
Charger.counter.L3_OC.isLatch = ON ;
setLedMotion(LED_ACTION_ALARM);
timerDisable(TIMER_IDX_RETRY_OC);
}
}
else if((Charger.Alarm_Code & ALARM_L3_OVER_CURRENT) &&
(Charger.counter.L3_OC.retry <= ALARM_OC_RETRY_COUNT) &&
(timer[TIMER_IDX_RETRY_OC].isAlarm == ON) &&
blinker[BLINKER_IDX_LED].blinkisFinish )
{
Charger.Alarm_Code &= ~ALARM_L3_OVER_CURRENT;
Charger.Alarm_Code &= ~ALARM_L3_CIRCUIT_SHORT;
DEBUG_INFO("Alarm L3_OC recover.\r\n");
if(!(Charger.Alarm_Code & ALARM_L1_OVER_CURRENT) && !(Charger.Alarm_Code & ALARM_L2_OVER_CURRENT) && !(Charger.Alarm_Code & ALARM_L3_OVER_CURRENT))
timerDisable(TIMER_IDX_RETRY_OC);
}
}
#ifdef FUNC_AUTO_IGNORE_AC_PHASE
}
#endif
}
#else //FUNC_OCP_WITH_PP
//Old Procedure (Deleted)
#endif //FUNC_OCP_WITH_PP
#endif //OCP_PROTECT
//================================
// Over temperature alarm detect
//================================
#ifdef OTP_PROTECT
#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
#ifdef MODIFY_OTP_SPEC
//if (Charger.temperature.MaxTemp > Charger.alarm_spec.OT_2)
if (
(Charger.temperature.Group1_MaxTemp > Charger.alarm_spec.OT_G1_2)
||
(
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
(Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P || Charger.m_bModelNameAX80_NACS_1P) &&
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
(Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P) &&
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
#else //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
(Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P) &&
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#else //FUNC_AW48_ADD_6_TEMP_SENEOR
Charger.m_bModelNameAX80_1P &&
#endif //FUNC_AW48_ADD_6_TEMP_SENEOR
Charger.temperature.Group2_MaxTemp > Charger.alarm_spec.OT_G2_2
)
#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
||
(
(Charger.m_bModelNameAW48_1P) &&
(
Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_2 ||
Charger.temperature.Group4_MaxTemp > Charger.alarm_spec.OT_G4_2
)
)
#else //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
||
(
(Charger.m_bModelNameAW48_1P) &&
Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_2
)
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
||
(
(Charger.m_bModelNameAX48_NACS_1P) &&
(
Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_2 ||
Charger.temperature.Group4_MaxTemp > Charger.alarm_spec.OT_G4_2
)
)
#else //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
||
(
(Charger.m_bModelNameAX48_NACS_1P) &&
Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_2
)
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
||
(
(Charger.m_bModelNameAX80_NACS_1P) &&
(
Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_2 ||
Charger.temperature.Group4_MaxTemp > Charger.alarm_spec.OT_G4_2
)
)
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
)
#else
if (Charger.temperature.MaxTemp > ALARM_SPEC_OT_2)
#endif
#else //FUNC_AX80_ADD_4_TEMP_SENEOR
#ifdef MODIFY_OTP_SPEC
if (Charger.temperature.SystemAmbientTemp > Charger.alarm_spec.OT_2)
#else
if (Charger.temperature.SystemAmbientTemp > ALARM_SPEC_OT_2)
#endif
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR
{
if(Charger.counter.OT.fail > 2000)
{
if (Charger.counter.OT.isLatch == OFF)
{
Charger.counter.OT.isLatch = ON ;
setLedMotion(LED_ACTION_ALARM);
}
if(!(Charger.Alarm_Code & ALARM_OVER_TEMPERATURE))
{
Charger.counter.OT.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_OVER_TEMPERATURE;
DEBUG_ERROR("Latch OT2 occur.\r\n");
#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
DEBUG_ERROR("OT_G1_MaxTemp = %d.\r\n",Charger.temperature.Group1_MaxTemp);
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
if (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P || Charger.m_bModelNameAX80_NACS_1P)
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
if (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P)
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
#else //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
if (Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P)
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#else
if (Charger.m_bModelNameAX80_1P)
#endif
{
DEBUG_ERROR("OT_G2_MaxTemp = %d.\r\n",Charger.temperature.Group2_MaxTemp);
}
#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
if (Charger.m_bModelNameAW48_1P)
{
DEBUG_ERROR("OT_G3_MaxTemp = %d, OT_G4_MaxTemp = %d.\r\n",Charger.temperature.Group3_MaxTemp, Charger.temperature.Group4_MaxTemp);
}
#else //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
if (Charger.m_bModelNameAW48_1P)
{
DEBUG_ERROR("OT_G3_MaxTemp = %d.\r\n",Charger.temperature.Group3_MaxTemp);
}
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
if (Charger.m_bModelNameAX48_NACS_1P)
{
DEBUG_ERROR("OT_G3_MaxTemp = %d, OT_G4_MaxTemp = %d.\r\n",Charger.temperature.Group3_MaxTemp, Charger.temperature.Group4_MaxTemp);
}
#else //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
if (Charger.m_bModelNameAX48_NACS_1P)
{
DEBUG_ERROR("OT_G3_MaxTemp = %d.\r\n",Charger.temperature.Group3_MaxTemp);
}
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
if (Charger.m_bModelNameAX80_NACS_1P)
{
DEBUG_ERROR("OT_G3_MaxTemp = %d, OT_G4_MaxTemp = %d.\r\n",Charger.temperature.Group3_MaxTemp, Charger.temperature.Group4_MaxTemp);
}
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
#else //FUNC_AX80_ADD_4_TEMP_SENEOR
DEBUG_ERROR("Tmp = %d.\r\n",Charger.temperature.SystemAmbientTemp);
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR
}
}
else
Charger.counter.OT.fail++;
}
#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
#ifdef MODIFY_OTP_SPEC
//else if((Charger.temperature.MaxTemp > Charger.alarm_spec.OT_1) && (!Charger.counter.OT.isLatch))
else if
(
((Charger.temperature.Group1_MaxTemp > Charger.alarm_spec.OT_G1_1) && (!Charger.counter.OT.isLatch))
||
(
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
(Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P || Charger.m_bModelNameAX80_NACS_1P) &&
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
(Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P) &&
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
#else //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
(Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P) &&
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#else
Charger.m_bModelNameAX80_1P &&
#endif
Charger.temperature.Group2_MaxTemp > Charger.alarm_spec.OT_G2_1 &&
!Charger.counter.OT.isLatch
)
#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
||
(
(Charger.m_bModelNameAW48_1P) &&
(
Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_1 ||
Charger.temperature.Group4_MaxTemp > Charger.alarm_spec.OT_G4_1
) &&
!Charger.counter.OT.isLatch
)
#else //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
||
(
(Charger.m_bModelNameAW48_1P) &&
Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_1 &&
!Charger.counter.OT.isLatch
)
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
||
(
(Charger.m_bModelNameAX48_NACS_1P) &&
(
Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_1 ||
Charger.temperature.Group4_MaxTemp > Charger.alarm_spec.OT_G4_1
) &&
!Charger.counter.OT.isLatch
)
#else //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
||
(
(Charger.m_bModelNameAX48_NACS_1P) &&
Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_1 &&
!Charger.counter.OT.isLatch
)
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
||
(
(Charger.m_bModelNameAX80_NACS_1P) &&
(
Charger.temperature.Group3_MaxTemp > Charger.alarm_spec.OT_G3_1 ||
Charger.temperature.Group4_MaxTemp > Charger.alarm_spec.OT_G4_1
) &&
!Charger.counter.OT.isLatch
)
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
)
#else
else if((Charger.temperature.MaxTemp > ALARM_SPEC_OT_1) && (!Charger.counter.OT.isLatch))
#endif
#else //FUNC_AX80_ADD_4_TEMP_SENEOR
#ifdef MODIFY_OTP_SPEC
else if((Charger.temperature.SystemAmbientTemp > Charger.alarm_spec.OT_1) && (!Charger.counter.OT.isLatch))
#else
else if((Charger.temperature.SystemAmbientTemp > ALARM_SPEC_OT_1) && (!Charger.counter.OT.isLatch))
#endif
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR
{
if(Charger.counter.OT.fail > 1000)
{
if(!(Charger.Alarm_Code & ALARM_OVER_TEMPERATURE))
{
Charger.counter.OT.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_OVER_TEMPERATURE;
DEBUG_ERROR("Alarm OT occur.\r\n");
#ifdef FUNC_GUN_TEMP_LATCH
{
static u8 nGunOTP = 0;
u8 nTmp = nGunOTP;
if (Charger.m_bModelNameAW48_1P)
{
if (Charger.temperature.AW48_T5_L1_GUN > Charger.alarm_spec.OT_G4_1 ||
Charger.temperature.AW48_T6_L2_GUN > Charger.alarm_spec.OT_G4_1)
nGunOTP++;
}
else if (Charger.m_bModelNameAX48_NACS_1P)
{
if (Charger.temperature.AX48_NACS_T5_L1_GUN > Charger.alarm_spec.OT_G2_1 ||
Charger.temperature.AX48_NACS_T6_L2_GUN > Charger.alarm_spec.OT_G2_1)
nGunOTP++;
}
else if (Charger.m_bModelNameAX80_NACS_1P)
{
if (Charger.temperature.AX80_NACS_T5_L1_GUN > Charger.alarm_spec.OT_G2_1 ||
Charger.temperature.AX80_NACS_T6_L2_GUN > Charger.alarm_spec.OT_G2_1)
nGunOTP++;
}
if (nGunOTP >= 3)
{
Charger.counter.OT.isLatch = ON;
nGunOTP = 0;
}
if (nTmp != nGunOTP)
{
DEBUG_ERROR("Alarm GUN_OT(%d) %s\r\n", nGunOTP, Charger.counter.OT.isLatch ? "=> LATCH" : "");
//Alarm GUN_OT(3) => LATCH
}
}
#endif //FUNC_GUN_TEMP_LATCH
}
}
else
Charger.counter.OT.fail++;
}
#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
#ifdef MODIFY_OTP_SPEC
//else if((Charger.temperature.MaxTemp < (Charger.alarm_spec.OT_1 - Charger.alarm_spec.OT_HYSTERESIS)) && (!Charger.counter.OT.isLatch))
else if
(
(Charger.temperature.Group1_MaxTemp < (Charger.alarm_spec.OT_G1_1 - Charger.alarm_spec.OT_G1_HYSTERESIS)) && (!Charger.counter.OT.isLatch)
#ifdef FUNC_MODIFY_OTP_RECOVER_PROCESS
&&
#else
||
#endif
(
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
(Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P || Charger.m_bModelNameAX80_NACS_1P) &&
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
(Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P) &&
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
#else //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
(Charger.m_bModelNameAX80_1P || Charger.m_bModelNameAW48_1P) &&
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
#else //FUNC_AW48_ADD_6_TEMP_SENEOR
Charger.m_bModelNameAX80_1P &&
#endif //FUNC_AW48_ADD_6_TEMP_SENEOR
Charger.temperature.Group2_MaxTemp < (Charger.alarm_spec.OT_G2_1 - Charger.alarm_spec.OT_G2_HYSTERESIS) &&
!Charger.counter.OT.isLatch
)
#ifdef FUNC_MODIFY_OTP_RECOVER_PROCESS
//Do nothing
#else //FUNC_MODIFY_OTP_RECOVER_PROCESS
#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
||
(
(Charger.m_bModelNameAW48_1P) &&
Charger.temperature.Group3_MaxTemp < (Charger.alarm_spec.OT_G3_1 - Charger.alarm_spec.OT_G3_HYSTERESIS) &&
!Charger.counter.OT.isLatch
)
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
||
(
(Charger.m_bModelNameAX48_NACS_1P) &&
Charger.temperature.Group3_MaxTemp < (Charger.alarm_spec.OT_G3_1 - Charger.alarm_spec.OT_G3_HYSTERESIS) &&
!Charger.counter.OT.isLatch
)
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#endif //FUNC_MODIFY_OTP_RECOVER_PROCESS
)
#else
else if((Charger.temperature.MaxTemp < (ALARM_SPEC_OT_1-ALARM_SPEC_OT_HYSTERESIS)) && (!Charger.counter.OT.isLatch))
#endif
#else //FUNC_AX80_ADD_4_TEMP_SENEOR
#ifdef MODIFY_OTP_SPEC
else if((Charger.temperature.SystemAmbientTemp < (Charger.alarm_spec.OT_1 - Charger.alarm_spec.OT_HYSTERESIS)) && (!Charger.counter.OT.isLatch))
#else
else if((Charger.temperature.SystemAmbientTemp < (ALARM_SPEC_OT_1-ALARM_SPEC_OT_HYSTERESIS)) && (!Charger.counter.OT.isLatch))
#endif
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR
{
#ifdef FUNC_MODIFY_OTP_RECOVER_PROCESS
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
if (Charger.m_bModelNameAW48_1P)
{
if ( Charger.temperature.Group3_MaxTemp < (Charger.alarm_spec.OT_G3_1 - Charger.alarm_spec.OT_G3_HYSTERESIS) &&
Charger.temperature.Group4_MaxTemp < (Charger.alarm_spec.OT_G4_1 - Charger.alarm_spec.OT_G4_HYSTERESIS) &&
!Charger.counter.OT.isLatch)
{
if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.OT.retry++;
Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
DEBUG_INFO("Alarm OT recover.\r\n");
}
}
}
else if (Charger.m_bModelNameAX48_NACS_1P)
{
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
if ( Charger.temperature.Group3_MaxTemp < (Charger.alarm_spec.OT_G3_1 - Charger.alarm_spec.OT_G3_HYSTERESIS) &&
Charger.temperature.Group4_MaxTemp < (Charger.alarm_spec.OT_G4_1 - Charger.alarm_spec.OT_G4_HYSTERESIS) &&
!Charger.counter.OT.isLatch)
{
if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.OT.retry++;
Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
DEBUG_INFO("Alarm OT recover.\r\n");
}
}
#else //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
if ( Charger.temperature.Group3_MaxTemp < (Charger.alarm_spec.OT_G3_1 - Charger.alarm_spec.OT_G3_HYSTERESIS) &&
!Charger.counter.OT.isLatch)
{
if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.OT.retry++;
Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
DEBUG_INFO("Alarm OT recover.\r\n");
}
}
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
}
#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
else if (Charger.m_bModelNameAX80_NACS_1P)
{
if ( Charger.temperature.Group3_MaxTemp < (Charger.alarm_spec.OT_G3_1 - Charger.alarm_spec.OT_G3_HYSTERESIS) &&
Charger.temperature.Group4_MaxTemp < (Charger.alarm_spec.OT_G4_1 - Charger.alarm_spec.OT_G4_HYSTERESIS) &&
!Charger.counter.OT.isLatch)
{
if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.OT.retry++;
Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
DEBUG_INFO("Alarm OT recover.\r\n");
}
}
}
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
else
{
Charger.counter.OT.fail = 0;
if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.OT.retry++;
Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
DEBUG_INFO("Alarm OT recover.\r\n");
}
}
#else //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
if (Charger.m_bModelNameAW48_1P || Charger.m_bModelNameAX48_NACS_1P)
{
if ( Charger.temperature.Group3_MaxTemp < (Charger.alarm_spec.OT_G3_1 - Charger.alarm_spec.OT_G3_HYSTERESIS) &&
!Charger.counter.OT.isLatch)
{
if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.OT.retry++;
Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
DEBUG_INFO("Alarm OT recover.\r\n");
}
}
}
else
{
Charger.counter.OT.fail = 0;
if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.OT.retry++;
Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
DEBUG_INFO("Alarm OT recover.\r\n");
}
}
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
#else //FUNC_MODIFY_OTP_RECOVER_PROCESS
Charger.counter.OT.fail = 0;
if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE) && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.OT.retry++;
Charger.Alarm_Code &= ~ALARM_OVER_TEMPERATURE;
DEBUG_INFO("Alarm OT recover.\r\n");
}
#endif //FUNC_MODIFY_OTP_RECOVER_PROCESS
}
#endif //OTP_PROTECT
//================================
// Current leakage alarm detect
// TODO: ADC channel & spec need to check for other detection method
//================================
#ifdef CCID_PROTECT
if (Charger.CCID_Module_Type == CCID_MODULE_VAC)
{
//module test
if((HAL_GPIO_ReadPin(IN_Leak_Error_GPIO_Port, IN_Leak_Error_Pin) == GPIO_PIN_SET) && (!Charger.isTestLeakModule))
{
if(Charger.counter.LEAK.fail > 1000)
{
if(!(Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL))
{
Charger.counter.LEAK.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_LEAK_MODULE_FAIL;
DEBUG_ERROR("Alarm leakage module error occur.\r\n");
timerEnable(TIMER_IDX_RETRY_LEAK, ALARM_RETRY_INTERVAL_LEAK);
}
}
else
Charger.counter.LEAK.fail++;
}
else
{
Charger.counter.LEAK.fail = 0;
if((Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL) &&
(Charger.counter.LEAK.retry < ALARM_RETRY_COUNT) &&
(timer[TIMER_IDX_RETRY_LEAK].isAlarm == ON) &&
blinker[BLINKER_IDX_LED].blinkisFinish)
{
timerDisable(TIMER_IDX_RETRY_LEAK);
Charger.Alarm_Code &= ~ALARM_LEAK_MODULE_FAIL;
osDelay(1000);
#ifdef DEBUG
DEBUG_INFO("Alarm leakage module error recover.\r\n");
#endif
}
}
//DC leakage
if((HAL_GPIO_ReadPin(IN_Leak_DC_GPIO_Port, IN_Leak_DC_Pin) == GPIO_PIN_SET) && (!Charger.isTestLeakModule))
{
if(Charger.counter.LEAK_DC.fail > 10)
{
if(!(Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC))
{
Charger.counter.LEAK_DC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_CURRENT_LEAK_DC;
DEBUG_ERROR("Alarm DC leakage occur.\r\n");
timerEnable(TIMER_IDX_RETRY_LEAK_DC, ALARM_RETRY_INTERVAL_LEAK);
Charger.counter.LEAK_DC.retry++;
}
if (timer[TIMER_IDX_RETRY_LEAK_DC].isAlarm == ON || (Charger.counter.LEAK_DC.retry >ALARM_RETRY_COUNT))
{
timerDisable(TIMER_IDX_RETRY_LEAK_DC);
//Charger.counter.LEAK.isLatch = ON ;
if (Charger.counter.LEAK.isLatch == OFF)
{
Charger.counter.LEAK.isLatch = ON ;
setLedMotion(LED_ACTION_ALARM);
}
DEBUG_ERROR("Alarm leakage DC isLatch.\r\n");
}
}
else
Charger.counter.LEAK_DC.fail++;
}
else
{
Charger.counter.LEAK_DC.fail = 0;
if((Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC) &&
(Charger.counter.LEAK_DC.retry <= ALARM_RETRY_COUNT) &&
(timer[TIMER_IDX_RETRY_LEAK_DC].isAlarm == ON) &&
blinker[BLINKER_IDX_LED].blinkisFinish)
{
timerDisable(TIMER_IDX_RETRY_LEAK_DC);
Charger.Alarm_Code &= ~ALARM_CURRENT_LEAK_DC;
DEBUG_INFO("Alarm DC leakage recover.\r\n");
}
}
//AC leakage
if((HAL_GPIO_ReadPin(IN_Leak_AC_GPIO_Port, IN_Leak_AC_Pin) == GPIO_PIN_SET) && (!Charger.isTestLeakModule))
{
if(Charger.counter.LEAK_AC.fail > 10)
{
if(!(Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC))
{
Charger.counter.LEAK_AC.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_CURRENT_LEAK_AC;
DEBUG_ERROR("Alarm AC leakage occur.\r\n");
timerEnable(TIMER_IDX_RETRY_LEAK_AC, ALARM_RETRY_INTERVAL_LEAK);
Charger.counter.LEAK_AC.retry++;
}
if (timer[TIMER_IDX_RETRY_LEAK_AC].isAlarm == ON || (Charger.counter.LEAK_AC.retry > ALARM_RETRY_COUNT))
{
timerDisable(TIMER_IDX_RETRY_LEAK_AC);
//Charger.counter.LEAK.isLatch = ON ;
if (Charger.counter.LEAK.isLatch == OFF)
{
Charger.counter.LEAK.isLatch = ON ;
setLedMotion(LED_ACTION_ALARM);
}
DEBUG_ERROR("Alarm leakage AC isLatch.\r\n");
}
}
else
Charger.counter.LEAK_AC.fail++;
}
else
{
Charger.counter.LEAK_AC.fail = 0;
if((Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC) &&
(Charger.counter.LEAK_AC.retry <= ALARM_RETRY_COUNT) &&
(timer[TIMER_IDX_RETRY_LEAK_AC].isAlarm == ON) &&
blinker[BLINKER_IDX_LED].blinkisFinish )
{
timerDisable(TIMER_IDX_RETRY_LEAK_AC);
Charger.Alarm_Code &= ~ALARM_CURRENT_LEAK_AC;
DEBUG_INFO("Alarm AC leakage recover.\r\n");
}
}
}
else // Charger.CCID_Module_Type is CCID_MODULE_CORMEX
{
if((Charger.Leak_Current >= Charger.alarm_spec.Current_LEAK_AC) && (!Charger.isTestLeakModule)) // adc correction data to check
{
if(Charger.counter.LEAK.fail >= 5)
{
if(!(Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC))
{
#ifdef FUNC_MODIFY_LEAK_AC_DISPLAY
XP("#Leak_Current (%d >= %d)\r\n", Charger.Leak_Current, Charger.alarm_spec.Current_LEAK_AC);
#else
XP("************************************************************\r\n");
XP("adc_value.ADC2_IN6_GF.value = %d\r\n", adc_value.ADC2_IN6_GF.value);
XP("Charger.Leak_Current(mA) = %d\r\n", Charger.Leak_Current);
XP("Charger.alarm_spec.Current_LEAK_AC(mA) = %d\r\n", Charger.alarm_spec.Current_LEAK_AC);
XP("Charger.isTestLeakModule = %s\r\n", Charger.isTestLeakModule ? "ON" : "OFF");
XP("************************************************************\r\n");
#endif
Charger.counter.LEAK.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_CURRENT_LEAK_AC; //Hao##### CSU Charge error here
DEBUG_ERROR("Alarm leakage occur.\r\n");
timerEnable(TIMER_IDX_RETRY_LEAK_AC, ALARM_RETRY_INTERVAL_LEAK);
Charger.counter.LEAK.retry ++ ;
}
}
else
{
Charger.counter.LEAK.fail++;
}
}
else if (Charger.Leak_Current < (Charger.alarm_spec.Current_LEAK_AC - ALARM_SPEC_CURRENT_LEAK_HYSTERESIS)) // adc correction data to check
{
Charger.counter.LEAK.fail = 0;
if (Charger.counter.LEAK.retry > ALARM_LEAK_RETRY_COUNT)
{
if (Charger.counter.LEAK.isLatch == OFF)
{
Charger.counter.LEAK.isLatch = ON ;
setLedMotion(LED_ACTION_ALARM);
}
}
else
{
if(((Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC)||(Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC)) &&
(Charger.counter.LEAK.retry <= ALARM_LEAK_RETRY_COUNT) &&
(timer[TIMER_IDX_RETRY_LEAK_AC].isAlarm == ON) &&
blinker[BLINKER_IDX_LED].blinkisFinish )
{
timerDisable(TIMER_IDX_RETRY_LEAK_AC);
osDelay(1000);
Charger.Alarm_Code &= ~ALARM_CURRENT_LEAK_AC;
DEBUG_INFO("Alarm leakage recover.\r\n");
}
}
}
}
#endif //CCID_PROTECT
//================================
// Ground fail alarm detect
// TODO: Spec need to check
//================================
#ifdef GROUND_FAULT_PROTECT
if(Charger.GroundingDetect==ON)
{
if (timer[TIMER_IDX_PE_DETECT].isAlarm == ON) // after 30 sec check (GMI adc_value > spec) and (GMI adc_value <= 1 )
{
if(((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) > (Charger.Voltage[0]*0.011)) || (adc_value.ADC3_IN4_GMI_VL1.value <= 1)) //Part FAIL
{
#ifdef TEST_GROUND_FAULT_PROTECT_TIME_TO_15_SEC
if(Charger.counter.GF.fail > 15000)
#else
if(Charger.counter.GF.fail > 4000)
#endif
{
if(!(Charger.Alarm_Code & ALARM_GROUND_FAIL))
{
Charger.counter.GF.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_GROUND_FAIL;
DEBUG_ERROR("Alarm GF occur.\r\n");
#ifdef MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
Charger.counter.GF.restore = 0;
#endif
#ifdef DEBUG_ALARM_GROUND_FAIL
XP("#adc_value.ADC3_IN4_GMI_VL1.value = %d\r\n", adc_value.ADC3_IN4_GMI_VL1.value);
XP("#adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095 = %f\r\n", adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095);
XP("#Charger.Voltage[0]*0.011 = %f\r\n", Charger.Voltage[0]*0.011);
#endif
}
}
else
Charger.counter.GF.fail++;
}
else if((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) < (Charger.Voltage[0]*0.00566))
{
#ifdef MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
if((Charger.Alarm_Code & ALARM_GROUND_FAIL) && blinker[BLINKER_IDX_LED].blinkisFinish)
{
if (Charger.counter.GF.restore > 2000)
{
Charger.Alarm_Code &= ~ALARM_GROUND_FAIL;
DEBUG_INFO("Alarm GF recover.\r\n");
Charger.counter.GF.fail = 0;
}
else
{
Charger.counter.GF.restore++;
}
}
#else //MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
Charger.counter.GF.fail = 0;
if((Charger.Alarm_Code & ALARM_GROUND_FAIL) && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.GF.retry++;
Charger.Alarm_Code &= ~ALARM_GROUND_FAIL;
DEBUG_INFO("Alarm GF recover.\r\n");
}
#endif //MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
}
}
else // before 30 sec check (GMI adc_value > spec)
{
if((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) > (Charger.Voltage[0]*0.011))
{
if(Charger.counter.GF.fail > 4000)
{
if(!(Charger.Alarm_Code & ALARM_GROUND_FAIL))
{
Charger.counter.GF.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_GROUND_FAIL;
DEBUG_ERROR("Alarm GF occur.\r\n");
#ifdef MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
Charger.counter.GF.restore = 0;
#endif
}
}
else
Charger.counter.GF.fail++;
}
else if((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) < (Charger.Voltage[0]*0.00566))
{
#ifdef MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
//Charger.counter.GF.fail = 0;
if((Charger.Alarm_Code & ALARM_GROUND_FAIL) && blinker[BLINKER_IDX_LED].blinkisFinish)
{
if (Charger.counter.GF.restore > 2000)
{
Charger.Alarm_Code &= ~ALARM_GROUND_FAIL;
DEBUG_INFO("Alarm GF recover.\r\n");
Charger.counter.GF.fail = 0;
}
else
{
Charger.counter.GF.restore++;
}
}
#else //MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
Charger.counter.GF.fail = 0;
if((Charger.Alarm_Code & ALARM_GROUND_FAIL) && blinker[BLINKER_IDX_LED].blinkisFinish)
{
//osDelay(3000);
Charger.counter.GF.retry++;
Charger.Alarm_Code &= ~ALARM_GROUND_FAIL;
DEBUG_INFO("Alarm GF recover.\r\n");
}
#endif //MODIFY_ALARM_GROUND_FAIL_RECOVER_USE_RESTORE
}
}
}
#endif //GROUND_FAULT_PROTECT
//================================
// Relay status error detect
// TODO: ADC channel & spec need to check
//================================
#ifdef MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK
#ifdef FUNC_USE_RELAY_B_CONTACT
if (Charger.m_bUseRelayBContact)
AlarmDetect_RelayWelding_UseGPIO();
else
AlarmDetect_RelayWelding_UseADC();
#else
AlarmDetect_RelayWelding_UseADC();
#endif //FUNC_USE_RELAY_B_CONTACT
#endif //MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK
//================================
// Emergency stop alarm detect
//================================
#ifdef EMC_BUTTON_PROTECT
if(HAL_GPIO_ReadPin(IN_Emergency_GPIO_Port, IN_Emergency_Pin) == GPIO_PIN_RESET)
{
if(Charger.counter.EMO.fail > 100)
{
if(!(Charger.Alarm_Code & ALARM_EMERGENCY_STOP))
{
Charger.counter.EMO.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_EMERGENCY_STOP;
DEBUG_ERROR("Alarm EMO occur.\r\n");
}
}
else
Charger.counter.EMO.fail++;
}
else
{
Charger.counter.EMO.fail = 0;
if((Charger.Alarm_Code & ALARM_EMERGENCY_STOP) && blinker[BLINKER_IDX_LED].blinkisFinish)
{
Charger.counter.EMO.retry++;
Charger.Alarm_Code &= ~ALARM_EMERGENCY_STOP;
DEBUG_INFO("Alarm EMO recover.\r\n");
}
}
#endif //EMC_BUTTON_PROTECT
//================================
// Handshaking timeout detect
//================================
#ifdef HANDSHAKE_PROTECT
if(timer[TIMER_IDX_CP].isAlarm == ON)
{
if(!(Charger.Alarm_Code & ALARM_HANDSHAKE_TIMEOUT))
{
Charger.Alarm_Code |= ALARM_HANDSHAKE_TIMEOUT;
timerDisable(TIMER_IDX_CP);
Charger.rfid.op_bits.reqStart = OFF;
Charger.istoHandShakeMode = OFF ;
DEBUG_ERROR("Alarm handshake overtime occur.\r\n");
}
}
else
{
if((Charger.Alarm_Code & ALARM_HANDSHAKE_TIMEOUT))
{
osDelay(10000);
Charger.Alarm_Code &= ~ALARM_HANDSHAKE_TIMEOUT;
DEBUG_INFO("Alarm handshake overtime recover.\r\n");
}
}
#endif //HANDSHAKE_PROTECT
//================================
// Rotary Switch Maxium Current Error detect
//================================
#ifdef ROTATE_SWITCH_CHECK
if (Charger.isRotarySwitchError)
{
if(!(Charger.Alarm_Code & ALARM_ROTATORY_SWITCH_FAULT))
{
Charger.Alarm_Code |= ALARM_ROTATORY_SWITCH_FAULT;
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
{
#ifdef FUNC_AW48_EXT_LED_BLINK_PERIOD_MORE_THAN_200MS
if (Charger.m_bModelNameAW48_1P)
{
blinkerTimeSet(BLINKER_IDX_LED, AW48_EXTLED_BLINK_PERIOD, AW48_EXTLED_BLINK_PERIOD, 0, 1);
}
else
{
blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
}
#else
blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
#endif
}
DEBUG_INFO("Rotary Switch Maxium Current Error occur.\r\n");
}
}
#endif //ROTATE_SWITCH_CHECK
//================================
// Meter communication timeout
//================================
#ifdef METER_TIMEOUT_CHECK
#ifdef FUNC_PTB_METER_WM3M4C
if (Charger.m_bUseExtMeter_PRO380 || Charger.m_bUseExtMeter_WM3M4C)
#else
if (Charger.m_bUseExtMeter_PRO380)
#endif
{
#ifdef RECODE_METER_PRO380
if (Charger.m_bUseExtMeter_PRO380 && Charger.m_pPRO380)
{
Charger.m_pPRO380->m_bCommTimeout = HTK_IsTimeout(Charger.m_pPRO380->m_LastUpdateTick, METER_EXT_COMM_TIMEOUT);
}
if (Charger.m_bUseExtMeter_WM3M4C && Charger.m_pWM3M4C)
{
Charger.m_pWM3M4C->m_bCommTimeout = HTK_IsTimeout(Charger.m_pWM3M4C->m_LastUpdateTick, METER_EXT_COMM_TIMEOUT);
}
if (
(Charger.m_bUseExtMeter_PRO380 && Charger.m_pPRO380 && Charger.m_pPRO380->m_bCommTimeout) ||
(Charger.m_bUseExtMeter_WM3M4C && Charger.m_pWM3M4C && Charger.m_pWM3M4C->m_bCommTimeout)
)
#else
#ifdef MODIFY_METER_EXT_PRO380
#ifdef FUNC_PTB_METER_WM3M4C
if (
(Charger.m_bUseExtMeter_PRO380 && HTK_IsTimeout(Charger.m_MeterPRO380.m_LastUpdateTick, METER_EXT_COMM_TIMEOUT)) ||
(Charger.m_bUseExtMeter_WM3M4C && HTK_IsTimeout(Charger.m_pWM3M4C->m_LastUpdateTick, METER_EXT_COMM_TIMEOUT))
)
#else //FUNC_PTB_METER_WM3M4C
if (HTK_IsTimeout(Charger.m_MeterPRO380.m_LastUpdateTick, METER_EXT_COMM_TIMEOUT))
#endif //FUNC_PTB_METER_WM3M4C
#else //MODIFY_METER_EXT_PRO380
if (Charger.counter.Meter_Timeout.fail >= ALARM_SPEC_METER_TIMEOUT)
#endif //MODIFY_METER_EXT_PRO380
#endif //RECODE_METER_PRO380
{
if (!(Charger.Alarm_Code & ALARM_METER_TIMEOUT))
{
Charger.Alarm_Code |= ALARM_METER_TIMEOUT;
if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
{
#ifdef FUNC_AW48_EXT_LED_BLINK_PERIOD_MORE_THAN_200MS
if (Charger.m_bModelNameAW48_1P)
{
blinkerTimeSet(BLINKER_IDX_LED, AW48_EXTLED_BLINK_PERIOD, AW48_EXTLED_BLINK_PERIOD, 0, 1);
}
else
{
blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
}
#else
blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
#endif
}
DEBUG_ERROR("Meter EXT COMM Timeout error occur.\r\n");
}
}
else
{
if (Charger.Alarm_Code & ALARM_METER_TIMEOUT)
{
Charger.Alarm_Code &= ~ALARM_METER_TIMEOUT;
DEBUG_INFO("Meter EXT COMM Timeout error recover.\r\n");
}
}
}
else
{
Charger.Alarm_Code &= ~ALARM_METER_TIMEOUT;
}
#endif //METER_TIMEOUT_CHECK
#ifdef FUNC_WARNING_CODE
#ifdef FUNC_EKM_OMNIMETER
{
const char s[] = "[WARN] Omnimeter timeout warning";
if (Charger.m_bUseExtMeter_OMNIMETER && Charger.m_pEKM_Omnimeter)
{
if (Charger.m_pEKM_Omnimeter->m_bCommTimeout)
{
if (!(Charger.Warning_Code & WARN_OMNIMETER_COMM_TIMEOUT))
{
Charger.Warning_Code |= WARN_OMNIMETER_COMM_TIMEOUT;
DEBUG_ERROR("%s occur.\r\n", s);
}
}
else
{
if (Charger.Warning_Code & WARN_OMNIMETER_COMM_TIMEOUT)
{
Charger.Warning_Code &= ~WARN_OMNIMETER_COMM_TIMEOUT;
DEBUG_ERROR("%s recover.\r\n", s);
}
}
}
else
{
if (Charger.Warning_Code & WARN_OMNIMETER_COMM_TIMEOUT)
{
Charger.Warning_Code &= ~WARN_OMNIMETER_COMM_TIMEOUT;
DEBUG_ERROR("%s recover.\r\n", s);
}
}
}
#endif //FUNC_EKM_OMNIMETER
#endif //FUNC_WARNING_CODE
#ifdef FUNC_METER_IC_COMM_ALARM
if (HTK_IsTimeout(Charger.m_MeterIC_LastUpdateTick, METER_IC_COMM_TIMEOUT))
{
if (!(Charger.Alarm_Code & ALARM_METER_IC_TIMEOUT))
{
Charger.Alarm_Code |= ALARM_METER_IC_TIMEOUT;
if (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
{
#ifdef FUNC_AW48_EXT_LED_BLINK_PERIOD_MORE_THAN_200MS
if (Charger.m_bModelNameAW48_1P)
{
blinkerTimeSet(BLINKER_IDX_LED, AW48_EXTLED_BLINK_PERIOD, AW48_EXTLED_BLINK_PERIOD, 0, 1);
}
else
{
blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
}
#else
blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
#endif
}
DEBUG_ERROR("Meter IC COMM Timeout error occur.\r\n");
}
}
else
{
if (Charger.Alarm_Code & ALARM_METER_IC_TIMEOUT)
{
Charger.Alarm_Code &= ~ALARM_METER_IC_TIMEOUT;
DEBUG_INFO("Meter IC COMM Timeout error recover.\r\n");
}
}
#endif //FUNC_METER_IC_COMM_ALARM
#ifdef GUN_LOCK_ALARM
if (Charger.m_bUseGunLock)
{
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
static uint32_t AlarmOccurTick = 0;
#endif
if (
#ifdef FUNC_GUN_LOCK_TRIG_MODE
(
Charger.m_GunLockTrigMode == GL_TRIG_MODE_RELAY &&
(
(GL_IsLock() && (Relay1_Action_Get() == GPIO_RELAY1_ACTION_OFF && Relay2_Action_Get() == GPIO_RELAY2_ACTION_OFF)) ||
(!GL_IsLock() && (Relay1_Action_Get() != GPIO_RELAY1_ACTION_OFF && Relay2_Action_Get() != GPIO_RELAY2_ACTION_OFF))
)
)
#else
(GL_IsLock() && (Relay1_Action_Get() == GPIO_RELAY1_ACTION_OFF && Relay2_Action_Get() == GPIO_RELAY2_ACTION_OFF)) ||
(!GL_IsLock() && (Relay1_Action_Get() != GPIO_RELAY1_ACTION_OFF && Relay2_Action_Get() != GPIO_RELAY2_ACTION_OFF))
#endif
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
|| (Charger.m_GunUnlock_Counter >= GUN_LOCK_PULSE_MAX_TIMES_CAUSE_ALARM)
|| (Charger.m_GunLock_Counter >= GUN_LOCK_PULSE_MAX_TIMES_CAUSE_ALARM)
#endif
)
{
if (!(Charger.Alarm_Code & ALARM_LOCKER_FAULT))
{
if (Charger.counter.GunLock.fail > 1000)
{
Charger.counter.GunLock.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_LOCKER_FAULT;
DEBUG_ERROR("Alarm GunLock occur.\r\n");
Charger.counter.GunLock.restore = 0;
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
AlarmOccurTick = HAL_GetTick();;
#endif
}
else
{
Charger.counter.GunLock.fail++;
}
}
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
if (Charger.Alarm_Code & ALARM_LOCKER_FAULT && HTK_IsTimeout(AlarmOccurTick, 1000 * 10))
{
if (
(Charger.m_GunUnlock_Counter >= GUN_LOCK_PULSE_MAX_TIMES_CAUSE_ALARM) ||
(Charger.m_GunLock_Counter >= GUN_LOCK_PULSE_MAX_TIMES_CAUSE_ALARM)
)
{
Charger.m_GunUnlock_Counter = 0;
Charger.m_GunLock_Counter = 0;
}
}
#endif
}
else
{
if (Charger.Alarm_Code & ALARM_LOCKER_FAULT)
{
if (Charger.counter.GunLock.restore > 1000)
{
Charger.Alarm_Code &= ~ALARM_LOCKER_FAULT;
DEBUG_INFO("Alarm GunLock recover.\r\n");
Charger.counter.GunLock.fail = 0;
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
Charger.m_GunUnlock_Counter = 0;
Charger.m_GunLock_Counter = 0;
#endif
}
else
{
Charger.counter.GunLock.restore++;
}
}
}
}
else
{
if (Charger.Alarm_Code & ALARM_LOCKER_FAULT)
{
Charger.Alarm_Code &= ~ALARM_LOCKER_FAULT;
}
}
#endif //GUN_LOCK_ALARM
#ifdef FUNC_AX80_ADD_TILT_SENSOR
#ifdef FUNC_ADD_TILT_SENSOR_MODEL
#ifdef FUNC_DISABLE_TILT_SENSOR_FOR_TEST
if (Charger.m_bUseTiltSensor && !Charger.m_bDisableTiltSensorForTest)
#else
if (Charger.m_bUseTiltSensor)
#endif
#else //FUNC_ADD_TILT_SENSOR_MODEL
if (Charger.m_bModelNameAX80_1P)
#endif //FUNC_ADD_TILT_SENSOR_MODEL
{
AlarmDetect_TiltSensor();
}
#endif //FUNC_AX80_ADD_TILT_SENSOR
//================================
// Recover alarm info in state A
//================================
if(Charger.CP_State == SYSTEM_STATE_A)
{
//SCP Recover
if(Charger.Alarm_Code & ALARM_L1_CIRCUIT_SHORT)
{
Charger.Alarm_Code &= ~ALARM_L1_CIRCUIT_SHORT;
DEBUG_INFO("Alarm L1 SCP recover.\r\n");
}
if(Charger.Alarm_Code & ALARM_L2_CIRCUIT_SHORT)
{
Charger.Alarm_Code &= ~ALARM_L2_CIRCUIT_SHORT;
DEBUG_INFO("Alarm L2 SCP recover.\r\n");
}
if(Charger.Alarm_Code & ALARM_L3_CIRCUIT_SHORT)
{
Charger.Alarm_Code &= ~ALARM_L3_CIRCUIT_SHORT;
DEBUG_INFO("Alarm L3 SCP recover.\r\n");
}
//OCP Recover
if(Charger.Alarm_Code & ALARM_L1_OVER_CURRENT)
{
Charger.Alarm_Code &= ~ALARM_L1_OVER_CURRENT;
DEBUG_INFO("Alarm L1 OC recover.\r\n");
}
if(Charger.Alarm_Code & ALARM_L2_OVER_CURRENT)
{
Charger.Alarm_Code &= ~ALARM_L2_OVER_CURRENT;
DEBUG_INFO("Alarm L2 OC recover.\r\n");
}
if(Charger.Alarm_Code & ALARM_L3_OVER_CURRENT)
{
Charger.Alarm_Code &= ~ALARM_L3_OVER_CURRENT;
DEBUG_INFO("Alarm L3 OC recover.\r\n");
}
timerDisable(TIMER_IDX_RETRY_OC);
Charger.counter.L1_OC.fail = 0 ;
Charger.counter.L1_OC.retry = 0 ; // clear retry times
Charger.counter.L1_OC.isLatch = OFF ;
Charger.counter.L2_OC.fail = 0 ;
Charger.counter.L2_OC.retry = 0 ; // clear retry times
Charger.counter.L2_OC.isLatch = OFF ;
Charger.counter.L3_OC.fail = 0 ;
Charger.counter.L3_OC.retry = 0 ; // clear retry times
Charger.counter.L3_OC.isLatch = OFF ;
//CCID Recover
if (Charger.CCID_Module_Type == CCID_MODULE_VAC)
{
if ((HAL_GPIO_ReadPin(IN_Leak_AC_GPIO_Port, IN_Leak_AC_Pin) == GPIO_PIN_RESET) && (Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC))
{
Charger.Alarm_Code &= ~ALARM_CURRENT_LEAK_AC;
DEBUG_INFO("Alarm leakage AC recover for VAC.\r\n");
}
if ((HAL_GPIO_ReadPin(IN_Leak_DC_GPIO_Port, IN_Leak_DC_Pin) == GPIO_PIN_RESET) && (Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC))
{
Charger.Alarm_Code &= ~ALARM_CURRENT_LEAK_DC;
DEBUG_INFO("Alarm leakage DC recover for VAC.\r\n");
}
}
else //Charger.CCID_Module_Type is CCID_MODULE_CORMEX
{
#ifdef MODIFY_ALARM_LEAKAGE_RECOVER
if((Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC))
{
Charger.Alarm_Code &= ~ALARM_CURRENT_LEAK_AC;
DEBUG_INFO("Alarm AC leakage recover.\r\n");
}
#else
if((Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC)||(Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC))
{
Charger.Alarm_Code &= ~ALARM_CURRENT_LEAK_AC;
DEBUG_INFO("Alarm leakage recover.\r\n");
}
#endif //MODIFY_ALARM_LEAKAGE_RECOVER
}
Charger.counter.LEAK.fail = 0;
timerDisable(TIMER_IDX_RETRY_LEAK) ;
timerDisable(TIMER_IDX_RETRY_LEAK_AC) ;
timerDisable(TIMER_IDX_RETRY_LEAK_DC) ;
Charger.counter.LEAK.retry = 0 ; // clear latch times
Charger.counter.LEAK_DC.retry = 0 ; // clear latch times
Charger.counter.LEAK_AC.retry = 0 ; // clear latch times
Charger.counter.LEAK.isLatch = OFF ;
#ifdef FUNC_UNPLUG_GUN_TO_RELEASE_TEMP_LATCH
Charger.counter.OT.isLatch = OFF;
#endif
//LEAK_MODULE selfrest Recover
if (Charger.CCID_Module_Type == CCID_MODULE_VAC)
{
if(Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL & (HAL_GPIO_ReadPin(IN_Leak_Error_GPIO_Port, IN_Leak_Error_Pin) == GPIO_PIN_RESET)) // leak module is VAC
{
if ((Charger.counter.LEAK_MODULE.retry < 2) && (!Charger.counter.LEAK_MODULE.isLatch))
{
Charger.Alarm_Code &= ~ALARM_LEAK_MODULE_FAIL;
DEBUG_INFO("Alarm leakage module recover.\r\n");
}
}
}
else //Charger.CCID_Module_Type is CCID_MODULE_CORMEX
{
if(Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL) // leak module is CORMEX
{
if ((Charger.counter.LEAK_MODULE.retry < 2) && (!Charger.counter.LEAK_MODULE.isLatch))
{
Charger.Alarm_Code &= ~ALARM_LEAK_MODULE_FAIL;
DEBUG_INFO("Alarm leakage module recover.\r\n");
}
}
}
}
}
else if (Charger.Mode == MODE_DEBUG)
{
//================================
// Relay status error detect
// TODO: ADC channel & spec need to check
//================================
#ifdef MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK
#ifdef FUNC_USE_RELAY_B_CONTACT
if (Charger.m_bUseRelayBContact)
AlarmDetect_RelayWelding_UseGPIO();
else
AlarmDetect_RelayWelding_UseADC();
#else
AlarmDetect_RelayWelding_UseADC();
#endif //FUNC_USE_RELAY_B_CONTACT
#endif //MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK
}
#ifdef FUNC_RESET_DATA_AFTER_WRITE_NEW_MODELNAME
if (Charger.m_bTrigToClearAlarmCode)
{
Charger.m_bTrigToClearAlarmCode = HTK_FALSE;
Charger.Alarm_Code = 0;
}
#endif
osDelay(1);
}
/* USER CODE END StartAlarmTask */
}
/* USER CODE BEGIN Header_StartBleTask */
/**
* @brief Function implementing the bleTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartBleTask */
void StartBleTask(void const * argument)
{
/* USER CODE BEGIN StartBleTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
IdleUntilReadAllMemory();
#endif
char tmpBuf[128];
uint8_t endFlag[4]={0x55,0xaa,0x55,0xaa};
__IO uint32_t flash;
uint32_t checksum;
uint32_t rndNumber;
//=====================================
// Module reset
//=====================================
HAL_GPIO_WritePin(OUT_BLE_RESET_GPIO_Port, OUT_BLE_RESET_Pin, GPIO_PIN_RESET);
osDelay(60);
HAL_GPIO_WritePin(OUT_BLE_RESET_GPIO_Port, OUT_BLE_RESET_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(OUT_BLE_DSR_GPIO_Port, OUT_BLE_DSR_Pin, GPIO_PIN_SET);
Charger.ble.initSeq = 0;
Charger.ble.isDataMode = OFF;
UART_BLE_Init_OK = OFF;
osDelay(1000);
/* Infinite loop */
for(;;)
{
//=====================================
// BLE module initialization process
//=====================================
switch(Charger.ble.initSeq)
{
case 0x00:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_RESTORE], strlen(BLE_CMD[BLE_CMD_SET_RESTORE]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x01:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_ROLE], strlen(BLE_CMD[BLE_CMD_SET_ROLE]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x02:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_DTR], strlen(BLE_CMD[BLE_CMD_SET_DTR]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x03:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_DSR], strlen(BLE_CMD[BLE_CMD_SET_DSR]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x04:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_PAIRING_MODE], strlen(BLE_CMD[BLE_CMD_SET_PAIRING_MODE]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x05:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_SECURITY_MODE], strlen(BLE_CMD[BLE_CMD_SET_SECURITY_MODE]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x06:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_SECURITY_TYPE], strlen(BLE_CMD[BLE_CMD_SET_SECURITY_TYPE]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x07:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_DISCOVERABILITY], strlen(BLE_CMD[BLE_CMD_SET_DISCOVERABILITY]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x08:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_CONNECTABILITY], strlen(BLE_CMD[BLE_CMD_SET_CONNECTABILITY]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x09:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_GET_ADDR], strlen(BLE_CMD[BLE_CMD_GET_ADDR]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x0a:
sprintf(tmpBuf, "%s\"BYTON_EVSE_%s\"\r\n", BLE_CMD[BLE_CMD_SET_NAME], Charger.ble.peripheral_mac);
DEBUG_INFO("BLE module set name:BYTON_EVSE_%s\r\n", Charger.ble.peripheral_mac);
HAL_UART_Transmit(&BLE_USART, (uint8_t *)tmpBuf, strlen(tmpBuf), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x0b:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_MAX_POWER], strlen(BLE_CMD[BLE_CMD_SET_MAX_POWER]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x0c:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_MIN_INTERVAL], strlen(BLE_CMD[BLE_CMD_SET_MIN_INTERVAL]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x0d:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_MAX_INTERVAL], strlen(BLE_CMD[BLE_CMD_SET_MAX_INTERVAL]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x0e:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_TX_PHY], strlen(BLE_CMD[BLE_CMD_SET_TX_PHY]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x0f:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_RX_PHY], strlen(BLE_CMD[BLE_CMD_SET_RX_PHY]), 0xffff);
osDelay(BLE_INIT_DELAY);
break;
case 0x10:
HAL_UART_Transmit(&BLE_USART, (uint8_t *)BLE_CMD[BLE_CMD_SET_DATA_MODE], strlen(BLE_CMD[BLE_CMD_SET_DATA_MODE]), 0xffff);
DEBUG_INFO("BLE module switch to data mode.\r\n");
osDelay(BLE_INIT_DELAY);
default:
UART_BLE_Init_OK = ON;
break;
}
//=====================================
// BLE central device connect status
//=====================================
if((HAL_GPIO_ReadPin(IN_BLE_DTR_GPIO_Port, IN_BLE_DTR_Pin) == GPIO_PIN_SET) && (UART_BLE_Init_OK == ON))
{
// Device disconnect
timerRefresh(TIMER_IDX_BLE);
if(Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT || Charger.ble.loginRole == BLE_LOGIN_ROLE_USER)
{
DEBUG_INFO("BLE central device disconnect.\r\n.");
Charger.ble.loginRole = BLE_LOGIN_ROLE_UNKOWN;
}
}
else if((HAL_GPIO_ReadPin(IN_BLE_DTR_GPIO_Port, IN_BLE_DTR_Pin) == GPIO_PIN_RESET) && (UART_BLE_Init_OK == ON))
{
// Device connect in
if(Charger.ble.loginRole == BLE_LOGIN_ROLE_UNKOWN)
{
DEBUG_INFO("BLE central device connect.....wait sign in.\r\n.");
osDelay(1000);
}
}
//=====================================
// Communication timeout process
//=====================================
if(timer[TIMER_IDX_BLE].isAlarm)
{
Charger.ble.loginRole = BLE_LOGIN_ROLE_UNKOWN;
DEBUG_INFO("BLE no communication over time, disconnect central device.\r\n");
timerRefresh(TIMER_IDX_BLE);
HAL_GPIO_WritePin(OUT_BLE_DSR_GPIO_Port, OUT_BLE_DSR_Pin, GPIO_PIN_RESET);
osDelay(100);
HAL_GPIO_WritePin(OUT_BLE_DSR_GPIO_Port, OUT_BLE_DSR_Pin, GPIO_PIN_SET);
}
//=====================================
// BLE uart recieve data process
//=====================================
if(UART_BLE_recv_end_flag == ON)
{
if((HAL_GPIO_ReadPin(IN_BLE_DTR_GPIO_Port, IN_BLE_DTR_Pin) == GPIO_PIN_SET) || !Charger.ble.isDataMode)
{
// AT command rx process
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_RESTORE])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_ROLE])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_DTR])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_DSR])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_PAIRING_MODE])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_SECURITY_MODE])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_SECURITY_TYPE])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_DISCOVERABILITY])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_CONNECTABILITY])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_GET_ADDR])!=NULL)
{
memcpy(Charger.ble.peripheral_mac, &UART_BLE_rx_buffer[strcspn((char *)UART_BLE_rx_buffer, ":")+1], 12);
Charger.ble.peripheral_mac[12] = '\0';
DEBUG_INFO("Peripheral mac address: %s\r\n", Charger.ble.peripheral_mac);
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_NAME])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_MAX_POWER])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_MIN_INTERVAL])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_MAX_INTERVAL])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_TX_PHY])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_RX_PHY])!=NULL)
{
Charger.ble.initSeq++;
}
if(strstr((char *)UART_BLE_rx_buffer, BLE_CMD[BLE_CMD_SET_DATA_MODE])!=NULL)
{
Charger.ble.isDataMode = ON;
Charger.ble.initSeq++;
}
}
else
{
// Application protocol rx process
uint8_t tx[UART_BUFFER_SIZE];
uint8_t tx_len;
uint8_t chksum = 0;
uint32_t tmp;
if(isValidCheckSum_BLE() && (rndNumber != ((UART_BLE_rx_buffer[3]<<0) | (UART_BLE_rx_buffer[4]<<8) | (UART_BLE_rx_buffer[5]<<16) | (UART_BLE_rx_buffer[6]<<24))))
{
// Timer reset
timerRefresh(TIMER_IDX_BLE);
rndNumber = ((UART_BLE_rx_buffer[3]<<0) | (UART_BLE_rx_buffer[4]<<8) | (UART_BLE_rx_buffer[5]<<16) | (UART_BLE_rx_buffer[6]<<24));
switch(UART_BLE_rx_buffer[2])
{
case BLE_PROTOCOL_MESSAGE_SIGN_IN:
DEBUG_INFO("BLE device sign request...%d\r\n", UART_BLE_rx_buffer[7]);
tx_len = 5;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
tx[3] = 0x00;
if(Charger.memory.EVSE_Config.data.item.bleConfig.isRegPuk)
{
if(UART_BLE_rx_buffer[7] == 0x00)
{
if(memcmp(&UART_BLE_rx_buffer[8], &Charger.memory.EVSE_Config.data.item.bleConfig.idRoot[0], ((UART_BLE_rx_buffer[0]<<8) | (UART_BLE_rx_buffer[1]<<0)-9)) == 0)
{
// Root sign in
tx[3] = 0x02;
Charger.ble.loginRole = BLE_LOGIN_ROLE_ROOT;
DEBUG_INFO("Sign in as root.\r\n");
}
}
else
{
if(memcmp(&UART_BLE_rx_buffer[8], &Charger.memory.whiteList.data.item[0].pin[0], ((UART_BLE_rx_buffer[0]<<8) | (UART_BLE_rx_buffer[1]<<0)-9)) == 0)
{
// User sign in
tx[3] = 0x03;
Charger.ble.loginRole = BLE_LOGIN_ROLE_USER;
DEBUG_INFO("Sign in as user.\r\n");
}
}
}
else
{
if(UART_BLE_rx_buffer[7] == 0x00)
{
// Visitor
tx[3] = 0x01;
Charger.ble.loginRole = BLE_LOGIN_ROLE_VISITOR;
memcpy(&Charger.ble.loginId[0], &UART_BLE_rx_buffer[8], ((UART_BLE_rx_buffer[0]<<8) | (UART_BLE_rx_buffer[1]<<0)-9) );
DEBUG_WARN("Sign in as visitor.\r\n");
}
}
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[4] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_PUK_REG:
DEBUG_INFO("BLE device PUK registe.%02x%02x%02x%02x%02x%02x%02x%02x\r\n", UART_BLE_rx_buffer[7], UART_BLE_rx_buffer[8], UART_BLE_rx_buffer[9], UART_BLE_rx_buffer[10], UART_BLE_rx_buffer[11], UART_BLE_rx_buffer[12], UART_BLE_rx_buffer[13], UART_BLE_rx_buffer[14]);
tx_len = 11;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
tx[3] = 0x00;
if(Charger.memory.EVSE_Config.data.item.bleConfig.isRegPuk)
{
if(memcmp(&Charger.ble.loginId[0], &Charger.memory.EVSE_Config.data.item.bleConfig.idRoot[0], ARRAY_SIZE(Charger.ble.loginId)))
{
tx[3] = 0x02;
DEBUG_INFO("ID registered exist.\r\n");
}
}
else
{
if(Charger.ble.loginRole == BLE_LOGIN_ROLE_VISITOR)
{
if(memcmp(&UART_BLE_rx_buffer[7], &Charger.memory.EVSE_Config.data.item.bleConfig.puk[0], 8) == 0x00)
{
tx[3] = 0x01;
// PIN list generation
Charger.memory.EVSE_Config.data.item.bleConfig.isGenPin = ON;
for(uint8_t idx=0;idx<20;idx++)
{
Charger.memory.whiteList.data.item[idx].listType = WHITE_LIST_TYPE_BLE;
Charger.memory.whiteList.data.item[idx].pin[0] = (rand()%0x2b)+0x30;
Charger.memory.whiteList.data.item[idx].pin[1] = (rand()%0x2b)+0x30;
Charger.memory.whiteList.data.item[idx].pin[2] = (rand()%0x2b)+0x30;
Charger.memory.whiteList.data.item[idx].pin[3] = (rand()%0x2b)+0x30;
Charger.memory.whiteList.data.item[idx].pin[4] = (rand()%0x2b)+0x30;
Charger.memory.whiteList.data.item[idx].pin[5] = (rand()%0x2b)+0x30;
Charger.memory.whiteList.data.item[idx].isReg = OFF;
}
Charger.memory.whiteList.op_bits.update = ON;
Charger.memory.EVSE_Config.data.item.bleConfig.isRegPuk = ON;
memcpy(&Charger.memory.EVSE_Config.data.item.bleConfig.idRoot[0], &Charger.ble.loginId[0], ARRAY_SIZE(Charger.ble.loginId));
Charger.memory.EVSE_Config.op_bits.update = ON;
DEBUG_INFO("Root registered and PIN list generate success.\r\n");
}
}
}
memcpy(&tx[4], &UART_BLE_rx_buffer[7], 6);
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[10] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_PIN_GET:
DEBUG_INFO("PIN get request.\r\n");
tx_len = 11;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;;
tx[3] = 0x00;
if(Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT)
{
tx[3] = 0x01;
memcpy(&tx[4], &Charger.memory.whiteList.data.item[0].pin[0], 6);
DEBUG_INFO("PIN: %s\r\n", Charger.memory.whiteList.data.item[0].pin);
}
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[10] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_PIN_RENEW:
DEBUG_INFO("BLE device PIN renew request.\r\n");
tx_len = 13;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;;
tx[3] = 0x00;
if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT))
{
for(uint8_t idx=0;idx<20;idx++)
{
Charger.memory.whiteList.data.item[idx].listType = WHITE_LIST_TYPE_BLE;
Charger.memory.whiteList.data.item[idx].pin[0] = (rand()%0x2b)+0x30;
Charger.memory.whiteList.data.item[idx].pin[1] = (rand()%0x2b)+0x30;
Charger.memory.whiteList.data.item[idx].pin[2] = (rand()%0x2b)+0x30;
Charger.memory.whiteList.data.item[idx].pin[3] = (rand()%0x2b)+0x30;
Charger.memory.whiteList.data.item[idx].pin[4] = (rand()%0x2b)+0x30;
Charger.memory.whiteList.data.item[idx].pin[5] = (rand()%0x2b)+0x30;
Charger.memory.whiteList.data.item[idx].isReg = OFF;
}
Charger.memory.whiteList.op_bits.update = ON;
tx[3] = 0x01;
memcpy(&tx[4], &Charger.memory.whiteList.data.item[0].pin[0], 6);
DEBUG_INFO("PIN list renew: %s.\r\n", Charger.memory.whiteList.data.item[0].pin);
}
else
DEBUG_WARN("Login id not root.\r\n");
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[4] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_CHARGING_START:
DEBUG_INFO("BLE device request charging start.\r\n");
tx_len = 0x08;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
if(Charger.Alarm_Code>0)
{
tx[3] = 0x02;
if((Charger.Alarm_Code & ALARM_L1_OVER_VOLTAGE))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x00;
}
else if((Charger.Alarm_Code & ALARM_L1_UNDER_VOLTAGE))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x03;
}
else if((Charger.Alarm_Code & ALARM_L1_OVER_CURRENT))
{
tx[4] = 0x01;
tx[5] = 0x21;
tx[6] = 0x16;
}
else if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x23;
}
else if((Charger.Alarm_Code & ALARM_GROUND_FAIL))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x56;
}
else if((Charger.Alarm_Code & ALARM_CP_ERROR))
{
tx[4] = 0x02;
tx[5] = 0x37;
tx[6] = 0x03;
}
else if((Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC)||(Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x33;
}
else if((Charger.Alarm_Code & ALARM_MCU_TESTFAIL))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x57;
}
else if((Charger.Alarm_Code & ALARM_EMERGENCY_STOP))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x51;
}
else if((Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL))
{
tx[4] = 0x01;
tx[5] = 0x10;
tx[6] = 0x04;
}
else if((Charger.Alarm_Code & ALARM_RELAY_STATUS))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x58;
}
DEBUG_WARN("EVSE in alarm state, can not start charging.\r\n");
}
else
{
if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
{
if(Charger.Mode == MODE_IDLE)
{
Charger.ble.isRequestOn = ON;
tx[3] = 0x01;
DEBUG_INFO("Start OK.\r\n");
}
else
{
tx[3] = 0x00;
DEBUG_WARN("EVSE not in IDLE.\r\n");
}
}
else
{
tx[3] = 0x00;
DEBUG_WARN("Login first\r\n");
}
tx[4] = 0x00;
tx[5] = 0x00;
tx[6] = 0x00;
}
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[7] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_CHARGING_STOP:
DEBUG_INFO("BLE device request charging stop.\r\n");
tx_len = 0x08;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
if(Charger.Alarm_Code>0)
{
tx[3] = 0x02;
if((Charger.Alarm_Code & ALARM_L1_OVER_VOLTAGE))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x00;
}
else if((Charger.Alarm_Code & ALARM_L1_UNDER_VOLTAGE))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x03;
}
else if((Charger.Alarm_Code & ALARM_L1_OVER_CURRENT))
{
tx[4] = 0x01;
tx[5] = 0x21;
tx[6] = 0x16;
}
else if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x23;
}
else if((Charger.Alarm_Code & ALARM_GROUND_FAIL))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x56;
}
else if((Charger.Alarm_Code & ALARM_CP_ERROR))
{
tx[4] = 0x02;
tx[5] = 0x37;
tx[6] = 0x03;
}
else if((Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC)||(Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x33;
}
else if((Charger.Alarm_Code & ALARM_MCU_TESTFAIL))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x57;
}
else if((Charger.Alarm_Code & ALARM_EMERGENCY_STOP))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x51;
}
else if((Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL))
{
tx[4] = 0x01;
tx[5] = 0x10;
tx[6] = 0x04;
}
else if((Charger.Alarm_Code & ALARM_RELAY_STATUS))
{
tx[4] = 0x01;
tx[5] = 0x22;
tx[6] = 0x58;
}
DEBUG_WARN("EVSE in alarm state, can not stop charging.\r\n");
}
else
{
if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
{
if((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))
{
Charger.ble.isRequestOff = ON;
tx[3] = 0x01;
DEBUG_INFO("Stop OK.\r\n");
}
else
{
tx[3] = 0x00;
DEBUG_WARN("EVSE not in CHARGING.\r\n");
}
}
else
{
tx[3] = 0x00;
DEBUG_WARN("Login first\r\n");
}
tx[4] = 0x00;
tx[5] = 0x00;
tx[6] = 0x00;
}
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[7] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_STATUS_QUERY:
DEBUG_INFO("BLE device query EVSE status request.\r\n");
tx_len = 0x13;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
tx[3] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?Charger.Mode:0x00);
tx[4] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?((((uint32_t)(Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total/10000))>>0) & 0xff):0x00);
tx[5] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?((((uint32_t)(Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total/10000))>>8) & 0xff):0x00);
tx[6] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?((((uint32_t)(Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total/10000))>>16) & 0xff):0x00);
tx[7] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?((((uint32_t)(Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total/10000))>>24) & 0xff):0x00);
tx[8] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?(((Charger.cycle_info.Power_Consumption/10)>>0) & 0xff):0x00);
tx[9] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?(((Charger.cycle_info.Power_Consumption/10)>>8) & 0xff):0x00);
tx[10] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?(((Charger.cycle_info.Duration/60000)>>0) & 0xff):0x00);
tx[11] = (((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))?(((Charger.cycle_info.Duration/60000)>>8) & 0xff):0x00);
if((Charger.Alarm_Code>0) && ((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER)))
{
if((Charger.Alarm_Code & ALARM_L1_OVER_VOLTAGE))
{
tx[12] = 0x01;
tx[13] = 0x22;
tx[14] = 0x00;
}
else if((Charger.Alarm_Code & ALARM_L1_UNDER_VOLTAGE))
{
tx[12] = 0x01;
tx[13] = 0x22;
tx[14] = 0x03;
}
else if((Charger.Alarm_Code & ALARM_L1_OVER_CURRENT))
{
tx[12] = 0x01;
tx[13] = 0x21;
tx[14] = 0x16;
}
else if((Charger.Alarm_Code & ALARM_OVER_TEMPERATURE))
{
tx[12] = 0x01;
tx[13] = 0x22;
tx[14] = 0x23;
}
else if((Charger.Alarm_Code & ALARM_GROUND_FAIL))
{
tx[12] = 0x01;
tx[13] = 0x22;
tx[14] = 0x56;
}
else if((Charger.Alarm_Code & ALARM_CP_ERROR))
{
tx[12] = 0x02;
tx[13] = 0x37;
tx[14] = 0x03;
}
else if((Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC)||(Charger.Alarm_Code & ALARM_CURRENT_LEAK_DC))
{
tx[12] = 0x01;
tx[13] = 0x22;
tx[14] = 0x33;
}
else if((Charger.Alarm_Code & ALARM_MCU_TESTFAIL))
{
tx[12] = 0x01;
tx[13] = 0x22;
tx[14] = 0x57;
}
else if((Charger.Alarm_Code & ALARM_EMERGENCY_STOP))
{
tx[12] = 0x01;
tx[13] = 0x22;
tx[14] = 0x51;
}
else if((Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL))
{
tx[12] = 0x01;
tx[13] = 0x10;
tx[14] = 0x04;
}
else if((Charger.Alarm_Code & ALARM_RELAY_STATUS))
{
tx[12] = 0x01;
tx[13] = 0x22;
tx[14] = 0x58;
}
}
else
{
tx[12] = 0x00;
tx[13] = 0x00;
tx[14] = 0x00;
}
tx[15] = Charger.memory.EVSE_Config.data.item.reservation.mode;
tx[16] = Charger.memory.EVSE_Config.data.item.reservation.hour;
tx[17] = Charger.memory.EVSE_Config.data.item.reservation.min;
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[18] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_RESERVATION:
switch(UART_BLE_rx_buffer[7])
{
case RESERVATION_DISABLE:
DEBUG_INFO("BLE device reservation request disable.\r\n");
break;
case RESERVATION_ONCE:
DEBUG_INFO("BLE device reservation request once on %d:%d.\r\n", UART_BLE_rx_buffer[8], UART_BLE_rx_buffer[9]);
break;
case RESERVATION_ALWAYS:
DEBUG_INFO("BLE device reservation request always on %d:%d.\r\n", UART_BLE_rx_buffer[8], UART_BLE_rx_buffer[9]);
break;
}
tx_len = 0x05;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
Charger.memory.EVSE_Config.data.item.reservation.mode = UART_BLE_rx_buffer[7];
Charger.memory.EVSE_Config.data.item.reservation.hour = UART_BLE_rx_buffer[8];
Charger.memory.EVSE_Config.data.item.reservation.min = UART_BLE_rx_buffer[9];
Charger.memory.EVSE_Config.op_bits.update = ON;
tx[3] = 0x01;
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[4] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_TIME_QUERY:
DEBUG_INFO("BLE device query date time request.\r\n");
tx_len = 0x08;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
struct tm gm_date;
gm_date.tm_year = Charger.memory.EVSE_Config.data.item.SystemDateTime.year-1900;
gm_date.tm_mon = Charger.memory.EVSE_Config.data.item.SystemDateTime.month-1;
gm_date.tm_mday = Charger.memory.EVSE_Config.data.item.SystemDateTime.day;
gm_date.tm_hour = Charger.memory.EVSE_Config.data.item.SystemDateTime.hour;
gm_date.tm_min = Charger.memory.EVSE_Config.data.item.SystemDateTime.min;
gm_date.tm_sec = Charger.memory.EVSE_Config.data.item.SystemDateTime.sec;
tmp = mktime(&gm_date);
tx[3] = ((tmp >> 0)&0xff);
tx[4] = ((tmp >> 8)&0xff);
tx[5] = ((tmp >> 16)&0xff);
tx[6] = ((tmp >> 24)&0xff);
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[7] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_TIME_CONFIG:
DEBUG_INFO("BLE device config date time.\r\n");
tx_len = 0x09;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
{
struct tm *sm_date;
tmp = (UART_BLE_rx_buffer[7]<<0) | (UART_BLE_rx_buffer[8]<<8) | (UART_BLE_rx_buffer[9]<<16) | (UART_BLE_rx_buffer[10]<<24);
sm_date = gmtime(&tmp) ;
setTime.Hours = sm_date->tm_hour;
setTime.Minutes = sm_date->tm_min;
setTime.Seconds = sm_date->tm_sec;
setTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
setTime.StoreOperation = RTC_STOREOPERATION_RESET;
if (HAL_RTC_SetTime(&hrtc, &setTime, RTC_FORMAT_BIN) != HAL_OK)
{
Error_Handler();
}
setDate.Year = (sm_date->tm_year + 1900)-2000;
setDate.Month = sm_date->tm_mon + 1;
setDate.Date = sm_date->tm_mday;
if (HAL_RTC_SetDate(&hrtc, &setDate, RTC_FORMAT_BIN) != HAL_OK)
{
Error_Handler();
}
tx[3] = 0x01;
DEBUG_INFO("RTC config OK.\r\n");
}
else
{
tx[3] = 0x00;
DEBUG_WARN("User con not config RTC.\r\n");
}
tx[4] = UART_BLE_rx_buffer[7];
tx[5] = UART_BLE_rx_buffer[8];
tx[6] = UART_BLE_rx_buffer[9];
tx[7] = UART_BLE_rx_buffer[10];
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[8] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_LED_QUERY:
DEBUG_INFO("BLE device query led setting.\r\n");
tx_len = 0x08;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
/*
TODO: Query led result here
*/
if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
{
tx[3] = 0xff;
tx[4] = 0xff;
tx[5] = 0xff;
tx[6] = 0xff;
}
else
{
tx[3] = 0x00;
tx[4] = 0x00;
tx[5] = 0x00;
tx[6] = 0x00;
}
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[7] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_LED_CONFIG:
DEBUG_INFO("BLE device config led setting.\r\n");
tx_len = 0x09;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
/*
TODO: Config led result here
*/
if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
tx[3] = 0x01;
else
tx[3] = 0x00;
tx[4] = UART_BLE_rx_buffer[7];
tx[5] = UART_BLE_rx_buffer[8];
tx[6] = UART_BLE_rx_buffer[9];
tx[7] = UART_BLE_rx_buffer[10];
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[8] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_CURRENT_LIMIT_QUERY:
DEBUG_INFO("BLE device query current limit request.\r\n");
tx_len = 0x05;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
{
tx[3] = Charger.memory.EVSE_Config.data.item.MaxChargingCurrent;
DEBUG_INFO("Query current limit: %02dA.\r\n", Charger.memory.EVSE_Config.data.item.MaxChargingCurrent);
}
else
{
tx[3] = 0x00;
DEBUG_WARN("Please login first, before query current limit.\r\n");
}
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[8] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_CURRENT_LIMIT_CONFIG:
DEBUG_INFO("BLE device config current limit.\r\n");
tx_len = 0x06;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
if((Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT) || (Charger.ble.loginRole == BLE_LOGIN_ROLE_USER))
{
if(UART_BLE_rx_buffer[7]>Charger.maxRatingCurrent)
{
tx[3] = 0x02;
Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = Charger.maxRatingCurrent;
DEBUG_INFO("Setting value over max rating value, set as max rating .\r\n");
}
else
{
tx[3] = 0x01;
Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = UART_BLE_rx_buffer[7];
}
DEBUG_INFO("Config current limit: %02dA\r\n", Charger.memory.EVSE_Config.data.item.MaxChargingCurrent);
}
else
{
tx[3] = 0x00;
DEBUG_WARN("Please login first, before setting current limit.\r\n");
}
tx[4] = UART_BLE_rx_buffer[7];
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[5] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_FIRMWARE_VERSION_QUERY:
DEBUG_INFO("BLE device query firmware version.\r\n");
tx_len = 4 + strlen(Charger.Ver_FW);
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
for(uint16_t idx=0;idx>2)) == FLASHIF_OK)
{
DEBUG_INFO("Firmware transfer start address: 0x%x ,length: %d...Pass\n\r", flashdestination, (((UART_BLE_rx_buffer[1]) | (UART_BLE_rx_buffer[0])<<8)-12));
tx[3] = 0x01;
}
else
{
DEBUG_INFO("Firmware transfer start address: 0x%x, length: %d...Fail\n\r", flashdestination, (((UART_BLE_rx_buffer[1]) | (UART_BLE_rx_buffer[0])<<8)-12));
tx[3] = 0x00;
}
}
else
{
tx[3] = 0x00;
DEBUG_WARN("User can not upgrade transfer.\r\n");
}
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[4] = chksum;
break;
case BLE_PROTOCOL_MESSAGE_FIRMWARE_END_REQ:
tx_len = 5;
tx[0] = 0x00;
tx[1] = 0x05;
tx[2] = UART_BLE_rx_buffer[2] + 0x80;;
if(Charger.ble.loginRole == BLE_LOGIN_ROLE_ROOT)
{
flash = NEW_CODE_ADDRESS;
checksum = HAL_CRC_Calculate(&hcrc, (uint32_t *)flash, ((FLASH_AP_LENGTH-4)>>2));
flash = ((uint32_t)(NEW_CODE_ADDRESS+FLASH_AP_LENGTH-4));
DEBUG_INFO("Firmware transfer end, AP CRC checksum, flash: 0x%x, 0x%x\r\n", checksum, *((uint32_t *)flash) );
if(checksum == *((uint32_t *)flash))
{
if (FLASH_If_Write(UPGRADE_REQ_ADDRESS, (uint32_t *)&endFlag[0], 1) == FLASHIF_OK)
{
DEBUG_INFO("Firmware Confirm Tag write ok..\n\r");
tx[3] = 0x01;
tx[4] = 0xB5;
HAL_UART_Transmit(&IAP_USART, (uint8_t *)tx, sizeof(tx), 0xffff);
osDelay(1000);
NVIC_SystemReset();
}
else
{
DEBUG_INFO("Firmware Confirm Tag write fail...\n\r");
tx[3] = 0x00;
}
}
else
{
DEBUG_INFO("Firmware checksum compare fail...\n\r");
tx[3] = 0x00;
}
}
else
{
tx[3] = 0x00;
DEBUG_WARN("User can not upgrade stop.\r\n");
}
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[4] = chksum;
break;
default:
/*
TODO: Unknow command response here
*/
tx_len = 5;
tx[0] = 0x00;
tx[1] = 0x05;
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
tx[3] = 0x00;
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[4] = chksum;
DEBUG_ERROR("BLE unknow command.\r\n");
break;
}
}
else
{
/*
TODO: Protocol check sum error response here
*/
tx_len = 5;
tx[0] = 0x00;
tx[1] = 0x05;
tx[2] = UART_BLE_rx_buffer[2] + 0x80;
tx[3] = 0x00;
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[4] = chksum;
DEBUG_ERROR("BLE check sum validation error.\r\n");
}
HAL_UART_Transmit(&BLE_USART, (uint8_t *)tx, tx_len, 0xffff);
}
UART_BLE_rx_len=0;
UART_BLE_recv_end_flag = OFF;
}
HAL_UART_Receive_DMA(&BLE_USART, (uint8_t*)UART_BLE_rx_buffer, UART_BUFFER_SIZE);
osDelay(1);
}
/* USER CODE END StartBleTask */
}
#ifdef MODIFY_FLASH_OPERATION_20241104
void Proc_EVSE_Config(void)
{
#ifdef MODIFY_UNDEFINED_MODEL_NAME_AND_SN_ISSUE
if (Charger.memory.EVSE_Config.data.item.ModelName[0] == 0xFF ||
Charger.memory.EVSE_Config.data.item.SerialNumber[0] == 0xFF)
{
Charger.memory.EVSE_Config.data.item.ModelName[MODEL_NAME_LEN - 1] = '\0';
Charger.memory.EVSE_Config.data.item.SerialNumber[SERIAL_NUM_LEN - 1] = '\0';
Charger.memory.EVSE_Config.op_bits.update = ON;
}
#endif //MODIFY_UNDEFINED_MODEL_NAME_AND_SN_ISSUE
#ifdef FUNC_ZEROING_WHEN_MEM_CLEARNED
if (Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total == HTK_U64_MAX ||
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 == HTK_U64_MAX ||
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 == HTK_U64_MAX ||
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3 == HTK_U64_MAX)
{
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total = 0;
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 = 0;
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 = 0;
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3 = 0;
Charger.memory.EVSE_Config.op_bits.update = ON;
}
if (Charger.memory.EVSE_Config.data.item.AcPlugInTimes == HTK_U32_MAX)
{
Charger.memory.EVSE_Config.data.item.AcPlugInTimes = 0;
Charger.memory.EVSE_Config.op_bits.update = ON;
}
#ifdef FUNC_MODE_DEBUG_REC_RELAY_ON_TIMES
if (Charger.memory.EVSE_Config.data.item.m_ModeDebugRelayOnTimes == HTK_U32_MAX)
{
Charger.memory.EVSE_Config.data.item.m_ModeDebugRelayOnTimes = 0;
Charger.memory.EVSE_Config.op_bits.update = ON;
}
#endif
#endif //FUNC_ZEROING_WHEN_MEM_CLEARNED
Charger.memory.EVSE_Config.data.item.isDispDebug = ON;
sprintf(Charger.memory.EVSE_Config.data.item.System_ID, "%s%s", Charger.memory.EVSE_Config.data.item.ModelName, Charger.memory.EVSE_Config.data.item.SerialNumber);
//sprintf((char *)tmpBuf, "%08x", ~HAL_CRC_Calculate(&hcrc, (uint32_t *)&Charger.memory.EVSE_Config.data.item.System_ID[0], (ARRAY_SIZE(Charger.memory.EVSE_Config.data.item.System_ID)>>2)));
//memcpy(&Charger.memory.EVSE_Config.data.item.bleConfig.puk[0], &tmpBuf[0], ARRAY_SIZE(Charger.memory.EVSE_Config.data.item.bleConfig.puk));
//DEBUG_INFO("BLE PUK: %s\r\n", Charger.memory.EVSE_Config.data.item.bleConfig.puk);
srand(Charger.memory.EVSE_Config.data.item.bleConfig.puk[0] | (Charger.memory.EVSE_Config.data.item.bleConfig.puk[1]<<8));
setTime.Hours = Charger.memory.EVSE_Config.data.item.SystemDateTime.hour;
setTime.Minutes = Charger.memory.EVSE_Config.data.item.SystemDateTime.min;
setTime.Seconds = Charger.memory.EVSE_Config.data.item.SystemDateTime.sec;
setTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
setTime.StoreOperation = RTC_STOREOPERATION_RESET;
if (HAL_RTC_SetTime(&hrtc, &setTime, RTC_FORMAT_BIN) != HAL_OK)
{
Error_Handler();
}
setDate.Year = Charger.memory.EVSE_Config.data.item.SystemDateTime.year-2000;
setDate.Month = Charger.memory.EVSE_Config.data.item.SystemDateTime.month;
setDate.Date = Charger.memory.EVSE_Config.data.item.SystemDateTime.day;
if (HAL_RTC_SetDate(&hrtc, &setDate, RTC_FORMAT_BIN) != HAL_OK)
{
Error_Handler();
}
//CCLC_Corr_Gain_Par
//VT
#ifdef MODIFY_CORRECTION_CHECK
if (
(Charger.memory.EVSE_Config.data.item.Correction_VL1[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL1[2][MCU_DATA]) &&
(Charger.memory.EVSE_Config.data.item.Correction_VL1[1][METER_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL1[2][METER_DATA])
)
#else
if(Charger.memory.EVSE_Config.data.item.Correction_VL1[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL1[2][MCU_DATA])
#endif
{
CLC_Corr_Gain_Par( Charger.memory.EVSE_Config.data.item.Correction_VL1[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_VL1[2][METER_DATA] ,
Charger.memory.EVSE_Config.data.item.Correction_VL1[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_VL1[2][MCU_DATA] ,
&Charger.coefficient.gain_v[0], &Charger.coefficient.offset_v[0]);
}
else
{
Charger.coefficient.gain_v[0] = 1;
Charger.coefficient.offset_v[0] = 0;
}
#ifdef MODIFY_CORRECTION_CHECK
if (
(Charger.memory.EVSE_Config.data.item.Correction_VL2[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL2[2][MCU_DATA]) &&
(Charger.memory.EVSE_Config.data.item.Correction_VL2[1][METER_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL2[2][METER_DATA])
)
#else
if(Charger.memory.EVSE_Config.data.item.Correction_VL2[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL2[2][MCU_DATA])
#endif
{
CLC_Corr_Gain_Par( Charger.memory.EVSE_Config.data.item.Correction_VL2[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_VL2[2][METER_DATA] ,
Charger.memory.EVSE_Config.data.item.Correction_VL2[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_VL2[2][MCU_DATA] ,
&Charger.coefficient.gain_v[1], &Charger.coefficient.offset_v[1]);
}
else
{
Charger.coefficient.gain_v[1] = 1;
Charger.coefficient.offset_v[1] = 0;
}
#ifdef MODIFY_CORRECTION_CHECK
if (
(Charger.memory.EVSE_Config.data.item.Correction_VL3[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL3[2][MCU_DATA]) &&
(Charger.memory.EVSE_Config.data.item.Correction_VL3[1][METER_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL3[2][METER_DATA])
)
#else
if(Charger.memory.EVSE_Config.data.item.Correction_VL3[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL3[2][MCU_DATA])
#endif
if(Charger.memory.EVSE_Config.data.item.Correction_VL3[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_VL3[2][MCU_DATA])
{
CLC_Corr_Gain_Par( Charger.memory.EVSE_Config.data.item.Correction_VL3[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_VL3[2][METER_DATA] ,
Charger.memory.EVSE_Config.data.item.Correction_VL3[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_VL3[2][MCU_DATA] ,
&Charger.coefficient.gain_v[2], &Charger.coefficient.offset_v[2]);
}
else
{
Charger.coefficient.gain_v[2] = 1;
Charger.coefficient.offset_v[2] = 0;
}
//CT
#ifdef MODIFY_CORRECTION_CHECK
if (
(Charger.memory.EVSE_Config.data.item.Correction_CL1[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL1[2][MCU_DATA]) &&
(Charger.memory.EVSE_Config.data.item.Correction_CL1[1][METER_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL1[2][METER_DATA])
)
#else
if(Charger.memory.EVSE_Config.data.item.Correction_CL1[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL1[2][MCU_DATA])
#endif
{
CLC_Corr_Gain_Par(Charger.memory.EVSE_Config.data.item.Correction_CL1[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_CL1[2][METER_DATA] ,
Charger.memory.EVSE_Config.data.item.Correction_CL1[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_CL1[2][MCU_DATA] ,
&Charger.coefficient.gain_c[0], &Charger.coefficient.offset_c[0]);
}
else
{
Charger.coefficient.gain_c[0] = 1;
Charger.coefficient.offset_c[0] = 0;
}
#ifdef MODIFY_CORRECTION_CHECK
if (
(Charger.memory.EVSE_Config.data.item.Correction_CL2[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL2[2][MCU_DATA]) &&
(Charger.memory.EVSE_Config.data.item.Correction_CL2[1][METER_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL2[2][METER_DATA])
)
#else
if(Charger.memory.EVSE_Config.data.item.Correction_CL2[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL2[2][MCU_DATA])
#endif
{
CLC_Corr_Gain_Par(Charger.memory.EVSE_Config.data.item.Correction_CL2[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_CL2[2][METER_DATA] ,
Charger.memory.EVSE_Config.data.item.Correction_CL2[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_CL2[2][MCU_DATA] ,
&Charger.coefficient.gain_c[1], &Charger.coefficient.offset_c[1]);
}
else
{
Charger.coefficient.gain_c[1] = 1;
Charger.coefficient.offset_c[1] = 0;
}
#ifdef MODIFY_CORRECTION_CHECK
if (
(Charger.memory.EVSE_Config.data.item.Correction_CL3[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL3[2][MCU_DATA]) &&
(Charger.memory.EVSE_Config.data.item.Correction_CL3[1][METER_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL3[2][METER_DATA])
)
#else
if(Charger.memory.EVSE_Config.data.item.Correction_CL3[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL3[2][MCU_DATA])
#endif
if(Charger.memory.EVSE_Config.data.item.Correction_CL3[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_CL3[2][MCU_DATA])
{
CLC_Corr_Gain_Par(Charger.memory.EVSE_Config.data.item.Correction_CL3[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_CL3[2][METER_DATA] ,
Charger.memory.EVSE_Config.data.item.Correction_CL3[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_CL3[2][MCU_DATA] ,
&Charger.coefficient.gain_c[2], &Charger.coefficient.offset_c[2]);
}
else
{
Charger.coefficient.gain_c[2] = 1;
Charger.coefficient.offset_c[2] = 0;
}
//LEAK
if(Charger.memory.EVSE_Config.data.item.Correction_Leak[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_Leak[2][MCU_DATA])
{
CLC_Corr_Gain_Par(Charger.memory.EVSE_Config.data.item.Correction_Leak[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_Leak[2][METER_DATA] ,
Charger.memory.EVSE_Config.data.item.Correction_Leak[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_Leak[2][MCU_DATA] ,
&Charger.coefficient.gain_leak[0], &Charger.coefficient.offset_leak[0]);
}
else
{
Charger.coefficient.gain_leak[0] = 1;
Charger.coefficient.offset_leak[0] = 0;
}
DEBUG_INFO("Charger.coefficient.gain_leak[0] = %f\r\n",Charger.coefficient.gain_leak[0]);
DEBUG_INFO("Charger.coefficient.offset_leak[0] = %f\r\n",Charger.coefficient.offset_leak[0]);
//GMI
if(Charger.memory.EVSE_Config.data.item.Correction_GMI[1][MCU_DATA] > Charger.memory.EVSE_Config.data.item.Correction_GMI[2][MCU_DATA])
{
CLC_Corr_Gain_Par2(Charger.memory.EVSE_Config.data.item.Correction_GMI[1][METER_DATA],Charger.memory.EVSE_Config.data.item.Correction_GMI[2][METER_DATA] ,
Charger.memory.EVSE_Config.data.item.Correction_GMI[1][MCU_DATA],Charger.memory.EVSE_Config.data.item.Correction_GMI[2][MCU_DATA] ,
&Charger.coefficient.gain_gmi[0], &Charger.coefficient.offset_gmi[0], &Charger.coefficient.offsetisPosOrNeg_gmi[0]);
}
else
{
Charger.coefficient.gain_gmi[0] = 1;
Charger.coefficient.offset_gmi[0] = 0;
}
//DEBUG_INFO("Charger.coefficient.gain_gmi[0] = %f\r\n",Charger.coefficient.gain_gmi[0]);
//DEBUG_INFO("Charger.coefficient.offset_gmi[0] = %f\r\n",Charger.coefficient.offset_gmi[0]);
#ifdef FUNC_SHOW_CORRECTION_DATA
{
XP("[CORRECT DATA]======================\r\n");
XP("\r\n");
for (int i = 0; i < 4; i++)
{
XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
i, Charger.memory.EVSE_Config.data.item.Correction_VL1[i][0],
i, Charger.memory.EVSE_Config.data.item.Correction_VL1[i][1]);
}
XP("\r\n");
for (int i = 0; i < 4; i++)
{
XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
i, Charger.memory.EVSE_Config.data.item.Correction_VL2[i][0],
i, Charger.memory.EVSE_Config.data.item.Correction_VL2[i][1]);
}
XP("\r\n");
for (int i = 0; i < 4; i++)
{
XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
i, Charger.memory.EVSE_Config.data.item.Correction_VL3[i][0],
i, Charger.memory.EVSE_Config.data.item.Correction_VL3[i][1]);
}
XP("\r\n");
for (int i = 0; i < 4; i++)
{
XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
i, Charger.memory.EVSE_Config.data.item.Correction_CL1[i][0],
i, Charger.memory.EVSE_Config.data.item.Correction_CL1[i][1]);
}
XP("\r\n");
for (int i = 0; i < 4; i++)
{
XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
i, Charger.memory.EVSE_Config.data.item.Correction_CL2[i][0],
i, Charger.memory.EVSE_Config.data.item.Correction_CL2[i][1]);
}
XP("\r\n");
for (int i = 0; i < 4; i++)
{
XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
i, Charger.memory.EVSE_Config.data.item.Correction_CL3[i][0],
i, Charger.memory.EVSE_Config.data.item.Correction_CL3[i][1]);
}
XP("\r\n");
for (int i = 0; i < 4; i++)
{
XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
i, Charger.memory.EVSE_Config.data.item.Correction_Leak[i][0],
i, Charger.memory.EVSE_Config.data.item.Correction_Leak[i][1]);
}
XP("\r\n");
for (int i = 0; i < 4; i++)
{
XP("[%d][0] = 0x%04X, [%d][1] = 0x%04X\r\n",
i, Charger.memory.EVSE_Config.data.item.Correction_GMI[i][0],
i, Charger.memory.EVSE_Config.data.item.Correction_GMI[i][1]);
}
XP("====================================\r\n");
}
#endif //FUNC_SHOW_CORRECTION_DATA
//DEBUG_INFO("Read MEM_ADDR_EVSE_CONFIG block(4k byte) pass.\r\n");
// Clean update & clear flag when model name not configured
/*
if(strlen(Charger.memory.EVSE_Config.data.item.ModelName)>20)
{
Charger.memory.EVSE_Config.op_bits.update = OFF;
Charger.memory.EVSE_Config.op_bits.clear = OFF;
Charger.memory.EVSE_Config.op_bits.backup = OFF;
Charger.memory.EVSE_Config.op_bits.restore = OFF;
}
*/
parseVersionInfoFromModelname();
}
#endif //MODIFY_FLASH_OPERATION_20241104
/* USER CODE BEGIN Header_StartMemoryTask */
/**
* @brief Function implementing the memoryTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartMemoryTask */
void StartMemoryTask(void const * argument)
{
/* USER CODE BEGIN StartMemoryTask */
//mmemory
//uint8_t tmpBuf[64];
uint8_t isSuccess;
uint8_t ID[2];
BSP_W25Qx_Init();
BSP_W25Qx_Read_ID(ID);
DEBUG_INFO("W25Qxxx ID is : 0x%02X 0x%02X \r\n",ID[0],ID[1]);
Charger.memory.EVSE_Config.op_bits.read = ON;
Charger.memory.coldLoadPickUp.op_bits.read = ON;
Charger.memory.whiteList.op_bits.read = ON;
Charger.memory.hisAlarm.op_bits.read = ON;
#ifdef FUNC_METER_IC_HISTORY
Charger.memory.hisMeterIC.op_bits.read = ON;
#else
Charger.memory.hisCharging.op_bits.read = ON;
#endif
/*
Charger.memory.EVSE_Config.op_bits.clear = ON ;
Charger.memory.EVSE_Config.op_bits.clear = ON;
Charger.memory.coldLoadPickUp.op_bits.clear = ON;
Charger.memory.whiteList.op_bits.clear = ON;
Charger.memory.hisAlarm.op_bits.clear = ON;
Charger.memory.hisCharging.op_bits.clear = ON;
*/
/* Infinite loop */
for(;;)
{
/*
EVSE config operation
*/
if(Charger.memory.EVSE_Config.op_bits.read)
{
#ifdef FUNC_CALC_FLASH_CRC_IN_CRITICAL
taskENTER_CRITICAL();
#endif
#ifndef FUNC_CALC_FLASH_CRC_IN_CRITICAL
osDelay(100);
#endif
// Read data from block
if(BSP_W25Qx_Read(Charger.memory.EVSE_Config.data.value, MEM_ADDR_EVSE_CONFIG, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
#ifdef FUNC_FLASH_RESTORE_CONFIG_WHEN_PRIMARY_LOSS
#ifdef FUNC_FLASH_CONFIG_APPEND_CRC
u32 crc32 = HAL_CRC_Calculate(&hcrc, (u32*)Charger.memory.EVSE_Config.data.verify.buf, ((W25Q16FV_BLOCK_SIZE-4)>>2));
if ((Charger.memory.EVSE_Config.data.verify.crc32 == crc32 /*|| Charger.memory.EVSE_Config.data.verify.crc32 == HTK_U32_MAX*/))
#else
if (1)
#endif
{
DEBUG_INFO("Read MEM_ADDR_EVSE_CONFIG block(4k byte) pass.\r\n");
Proc_EVSE_Config();
Charger.ModelReadisOK = PASS;
}
else
{
static u8 bProc = 0;
if (!bProc)
{
bProc = 1;
DEBUG_WARN("MEM_ADDR_EVSE_CONFIG data area check sum error => restore from backup area.\r\n");
Charger.memory.EVSE_Config.op_bits.restore = ON;
}
else
{
Proc_EVSE_Config();
Charger.ModelReadisOK = PASS;
}
}
#endif //FUNC_FLASH_RESTORE_CONFIG_WHEN_PRIMARY_LOSS
Charger.memory.EVSE_Config.op_bits.read = OFF;
}
else
{
DEBUG_INFO("Read MEM_ADDR_EVSE_CONFIG block(4k byte) fail.\r\n");
}
#ifdef FUNC_CALC_FLASH_CRC_IN_CRITICAL
taskEXIT_CRITICAL();
#endif
}
if(Charger.memory.EVSE_Config.op_bits.update)
{
#ifdef FUNC_CALC_FLASH_CRC_IN_CRITICAL
taskENTER_CRITICAL();
#endif
#ifdef FUNC_AUTO_MODIFY_CCID_MODULE
Charger.memory.EVSE_Config.op_bits.update = OFF;
#endif
isSuccess = PASS;
#ifdef FUNC_FLASH_CONFIG_APPEND_CRC
#ifndef FUNC_CALC_FLASH_CRC_IN_CRITICAL
osDelay(100);
#endif
Charger.memory.EVSE_Config.data.verify.crc32 = HAL_CRC_Calculate(&hcrc, (u32*)Charger.memory.EVSE_Config.data.verify.buf, ((W25Q16FV_BLOCK_SIZE-4)>>2));
#endif
// Erase block data
if(BSP_W25Qx_Erase_Block(MEM_ADDR_EVSE_CONFIG) == W25Qx_OK)
{
// Write data to block
for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
{
if(BSP_W25Qx_Write(&Charger.memory.EVSE_Config.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_EVSE_CONFIG+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
{
isSuccess = FAIL;
}
}
if(isSuccess)
DEBUG_INFO("Update MEM_ADDR_EVSE_CONFIG success.\r\n");
else
DEBUG_WARN("Update MEM_ADDR_EVSE_CONFIG fail.\r\n");
#ifndef FUNC_AUTO_MODIFY_CCID_MODULE
Charger.memory.EVSE_Config.op_bits.update = OFF;
#endif
#ifdef FUNC_FLASH_UPDATE_CONFIG_BOTH_PRIMARY_AND_BACKUP
Charger.memory.EVSE_Config.op_bits.backup = ON;
#endif
}
else
{
DEBUG_WARN("Update MEM_ADDR_EVSE_CONFIG block(4k byte) fail.\r\n");
}
#ifdef FUNC_CALC_FLASH_CRC_IN_CRITICAL
taskEXIT_CRITICAL();
#endif
}
if(Charger.memory.EVSE_Config.op_bits.clear)
{
// Erase block data
if(BSP_W25Qx_Erase_Block(MEM_ADDR_EVSE_CONFIG) == W25Qx_OK)
{
// Read data from block
if(BSP_W25Qx_Read(Charger.memory.EVSE_Config.data.value, MEM_ADDR_EVSE_CONFIG, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Erase MEM_ADDR_EVSE_CONFIG block(4k byte) pass.\r\n");
Charger.memory.EVSE_Config.op_bits.clear = OFF;
}
else
{
DEBUG_WARN("Erase MEM_ADDR_EVSE_CONFIG block(4k byte) fail.\r\n");
}
}
else
{
DEBUG_WARN("Erase MEM_ADDR_EVSE_CONFIG block(4k byte) fail.\r\n");
}
}
if(Charger.memory.EVSE_Config.op_bits.backup)
{
#ifdef FUNC_CALC_FLASH_CRC_IN_CRITICAL
taskENTER_CRITICAL();
#endif
isSuccess = PASS;
#ifndef FUNC_CALC_FLASH_CRC_IN_CRITICAL
osDelay(100);
#endif
Charger.memory.EVSE_Config.data.verify.crc32 = HAL_CRC_Calculate(&hcrc, (u32*)Charger.memory.EVSE_Config.data.verify.buf, ((W25Q16FV_BLOCK_SIZE-4)>>2));
// Erase block data
if(BSP_W25Qx_Erase_Block(MEM_ADDR_BACKUP_EVSE_CONFIG) == W25Qx_OK)
{
// Write data to block
for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
{
if(BSP_W25Qx_Write(&Charger.memory.EVSE_Config.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_BACKUP_EVSE_CONFIG+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
{
isSuccess = FAIL;
}
}
if(isSuccess)
DEBUG_INFO("Backup MEM_ADDR_BACKUP_EVSE_CONFIG success.\r\n");
else
DEBUG_WARN("Backup MEM_ADDR_BACKUP_EVSE_CONFIG fail.\r\n");
Charger.memory.EVSE_Config.op_bits.backup = OFF;
#ifndef FUNC_FLASH_UPDATE_CONFIG_BOTH_PRIMARY_AND_BACKUP
//Charger.memory.EVSE_Config.op_bits.clear = ON;
#endif
}
else
{
DEBUG_WARN("Backup MEM_ADDR_BACKUP_EVSE_CONFIG block(4k byte) fail.\r\n");
}
#ifdef FUNC_CALC_FLASH_CRC_IN_CRITICAL
taskEXIT_CRITICAL();
#endif
}
if(Charger.memory.EVSE_Config.op_bits.restore)
{
// Restore data from backup block
if(BSP_W25Qx_Read(Charger.memory.EVSE_Config.data.value, MEM_ADDR_BACKUP_EVSE_CONFIG, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
u32 crc32 = HAL_CRC_Calculate(&hcrc, (u32*)Charger.memory.EVSE_Config.data.verify.buf, ((W25Q16FV_BLOCK_SIZE-4)>>2));
if(Charger.memory.EVSE_Config.data.verify.crc32 == crc32)
{
DEBUG_INFO("Restore MEM_ADDR_BACKUP_EVSE_CONFIG block(4k byte) pass.\r\n");
// Update data to primary area
Charger.memory.EVSE_Config.op_bits.update = ON;
Proc_EVSE_Config();
Charger.ModelReadisOK = PASS;
}
else
{
DEBUG_WARN("[FLASH] MEM_ADDR_BACKUP_EVSE_CONFIG block check sum error.\r\n");
// TODO:
static u8 bProc = 0;
if (!bProc)
{
bProc = 1;
setLedMotion(LED_ACTION_ALARM);
Charger.memory.EVSE_Config.op_bits.read = ON;
}
}
Charger.memory.EVSE_Config.op_bits.restore = OFF;
}
else
{
DEBUG_WARN("Restore MEM_ADDR_BACKUP_EVSE_CONFIG block(4k byte) fail.\r\n");
}
}
if((HAL_GPIO_ReadPin(IN_MEM_Erase_GPIO_Port, IN_MEM_Erase_Pin) == GPIO_PIN_RESET) && (Charger.Mode == MODE_IDLE) )
{
//prevent idiot to pree this button too long to cause watchdog reset
HAL_IWDG_Refresh(&hiwdg);
if(Charger.counter.RST_CFG>3000)
{
// Reset EVSE configuration to factory default value
Charger.memory.EVSE_Config.data.item.bleConfig.isGenPin = OFF;
Charger.memory.EVSE_Config.data.item.bleConfig.isRegPuk = OFF;
Charger.memory.EVSE_Config.data.item.AuthMode = AUTH_MODE_OCPP;
Charger.memory.EVSE_Config.data.item.RFID_SN_Endian = RFID_ENDIAN_LITTLE;
//Charger.memory.EVSE_Config.data.item.isAuthEnable = OFF;
Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_FREE ;
//Charger.memory.EVSE_Config.data.item.Power_Consumption_Cumulative = 0;
Charger.memory.EVSE_Config.data.item.reservation.mode = RESERVATION_DISABLE;
Charger.memory.EVSE_Config.op_bits.update = ON;
// Reset cold load pick up to factory default value
Charger.memory.coldLoadPickUp.data.item.isEnable = OFF;
Charger.memory.coldLoadPickUp.op_bits.update = ON;
// Reset white list to factory default value
for(uint8_t idx=0;idx<20;idx++)
{
Charger.memory.whiteList.data.item[idx].listType = 0xff;
Charger.memory.whiteList.data.item[idx].isReg = OFF;
memset(&Charger.memory.whiteList.data.item[idx].pin[0], 0x00, 6);
memset(&Charger.memory.whiteList.data.item[idx].listID[0], 0x00, 6);
}
Charger.memory.whiteList.op_bits.update = ON;
//restore led
setLedMotion(LED_ACTION_RESTORE_SETTING) ;
timerEnable(TIMER_IDX_LED_TEMP, 3000);
setChargerMode(MODE_IDLE);
osDelay(1000);
}
else
Charger.counter.RST_CFG++;
}
else
Charger.counter.RST_CFG = 0;
/*
Cold load pick up operation
*/
if(Charger.memory.coldLoadPickUp.op_bits.read)
{
osDelay(100);
// Read data from block
if(BSP_W25Qx_Read(Charger.memory.coldLoadPickUp.data.value, MEM_ADDR_COLD_LOAD_PICKUP, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Read MEM_ADDR_COLD_LOAD_PICKUP block(4k byte) pass.\r\n");
Charger.memory.coldLoadPickUp.op_bits.read = OFF;
}
else
{
DEBUG_WARN("Read MEM_ADDR_COLD_LOAD_PICKUP block(4k byte) fail.\r\n");
}
}
if(Charger.memory.coldLoadPickUp.op_bits.update)
{
isSuccess = PASS;
// Erase block data
if(BSP_W25Qx_Erase_Block(MEM_ADDR_COLD_LOAD_PICKUP) == W25Qx_OK)
{
// Write data to block
for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
{
if(BSP_W25Qx_Write(&Charger.memory.coldLoadPickUp.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_COLD_LOAD_PICKUP+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
{
isSuccess = FAIL;
}
}
if(isSuccess)
DEBUG_INFO("Update MEM_ADDR_COLD_LOAD_PICKUP success.\r\n");
else
DEBUG_WARN("Update MEM_ADDR_COLD_LOAD_PICKUP fail.\r\n");
Charger.memory.coldLoadPickUp.op_bits.update = OFF;
}
else
{
DEBUG_WARN("Update MEM_ADDR_COLD_LOAD_PICKUP block(4k byte) fail.\r\n");
}
}
if(Charger.memory.coldLoadPickUp.op_bits.clear)
{
// Erase block data
if(BSP_W25Qx_Erase_Block(MEM_ADDR_COLD_LOAD_PICKUP) == W25Qx_OK)
{
// Read data from block
if(BSP_W25Qx_Read(Charger.memory.coldLoadPickUp.data.value, MEM_ADDR_COLD_LOAD_PICKUP, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Erase MEM_ADDR_COLD_LOAD_PICKUP block(4k byte) pass.\r\n");
Charger.memory.coldLoadPickUp.op_bits.clear = OFF;
}
else
{
DEBUG_WARN("Erase MEM_ADDR_COLD_LOAD_PICKUP block(4k byte) fail.\r\n");
}
}
else
{
DEBUG_WARN("Erase MEM_ADDR_COLD_LOAD_PICKUP block(4k byte) fail.\r\n");
}
}
if(Charger.memory.coldLoadPickUp.op_bits.backup)
{
isSuccess = PASS;
// Erase block data
if(BSP_W25Qx_Erase_Block(MEM_ADDR_BACKUP_COLD_LOAD_PICKUP) == W25Qx_OK)
{
// Write data to block
for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
{
if(BSP_W25Qx_Write(&Charger.memory.coldLoadPickUp.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_BACKUP_COLD_LOAD_PICKUP+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
{
isSuccess = FAIL;
}
}
if(isSuccess)
DEBUG_INFO("Backup MEM_ADDR_BACKUP_COLD_LOAD_PICKUP success.\r\n");
else
DEBUG_WARN("Backup MEM_ADDR_BACKUP_COLD_LOAD_PICKUP fail.\r\n");
Charger.memory.coldLoadPickUp.op_bits.backup = OFF;
Charger.memory.coldLoadPickUp.op_bits.clear = ON;
}
else
{
DEBUG_WARN("Backup MEM_ADDR_BACKUP_COLD_LOAD_PICKUP block(4k byte) fail.\r\n");
}
}
if(Charger.memory.coldLoadPickUp.op_bits.restore)
{
// Restore data from backup block
if(BSP_W25Qx_Read(Charger.memory.coldLoadPickUp.data.value, MEM_ADDR_BACKUP_COLD_LOAD_PICKUP, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Restore MEM_ADDR_BACKUP_COLD_LOAD_PICKUP block(4k byte) pass.\r\n");
Charger.memory.coldLoadPickUp.op_bits.restore = OFF;
}
else
{
DEBUG_WARN("Restore MEM_ADDR_BACKUP_COLD_LOAD_PICKUP block(4k byte) fail.\r\n");
}
}
/*
White list operation
*/
if(Charger.memory.whiteList.op_bits.read)
{
osDelay(100);
// Read data from block
if(BSP_W25Qx_Read(Charger.memory.whiteList.data.value, MEM_ADDR_WHITE_LIST, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Read MEM_ADDR_WHITE_LIST block(4k byte) pass.\r\n");
Charger.memory.whiteList.op_bits.read = OFF;
}
else
{
DEBUG_WARN("Read MEM_ADDR_WHITE_LIST block(4k byte) fail.\r\n");
}
}
if(Charger.memory.whiteList.op_bits.update)
{
isSuccess = PASS;
// Erase block data
if(BSP_W25Qx_Erase_Block(MEM_ADDR_WHITE_LIST) == W25Qx_OK)
{
// Write data to block
for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
{
if(BSP_W25Qx_Write(&Charger.memory.whiteList.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_WHITE_LIST+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
{
isSuccess = FAIL;
}
}
if(isSuccess)
DEBUG_INFO("Update MEM_ADDR_WHITE_LIST success.\r\n");
else
DEBUG_WARN("Update MEM_ADDR_WHITE_LIST fail.\r\n");
Charger.memory.whiteList.op_bits.update = OFF;
}
else
{
DEBUG_WARN("Update MEM_ADDR_WHITE_LIST block(4k byte) fail.\r\n");
}
}
if(Charger.memory.whiteList.op_bits.clear)
{
// Erase block data
if(BSP_W25Qx_Erase_Block(MEM_ADDR_WHITE_LIST) == W25Qx_OK)
{
// Read data from block
if(BSP_W25Qx_Read(Charger.memory.whiteList.data.value, MEM_ADDR_WHITE_LIST, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Erase MEM_ADDR_WHITE_LIST block(4k byte) pass.\r\n");
Charger.memory.whiteList.op_bits.clear = OFF;
}
else
{
DEBUG_WARN("Erase MEM_ADDR_WHITE_LIST block(4k byte) fail.\r\n");
}
}
else
{
DEBUG_WARN("Erase MEM_ADDR_WHITE_LIST block(4k byte) fail.\r\n");
}
}
/*
Alarm history operation
*/
if(Charger.memory.hisAlarm.op_bits.read)
{
osDelay(100);
// Read data from block
if(BSP_W25Qx_Read(Charger.memory.hisAlarm.data.value, MEM_ADDR_HIS_ALARM, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Read MEM_ADDR_HIS_ALARM block(4k byte) pass.\r\n");
Charger.memory.hisAlarm.op_bits.read = OFF;
}
else
{
DEBUG_WARN("Read MEM_ADDR_HIS_ALARM block(4k byte) fail.\r\n");
}
}
if(Charger.memory.hisAlarm.op_bits.update)
{
isSuccess = PASS;
// Write data to block
for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
{
if(BSP_W25Qx_Write(&Charger.memory.hisAlarm.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_HIS_ALARM+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
{
isSuccess = FAIL;
}
}
if(isSuccess)
DEBUG_INFO("Update MEM_ADDR_HIS_ALARM success.\r\n");
else
DEBUG_WARN("Update MEM_ADDR_HIS_ALARM fail.\r\n");
Charger.memory.hisAlarm.op_bits.update = OFF;
}
if(Charger.memory.hisAlarm.op_bits.clear)
{
// Erase block data
if(BSP_W25Qx_Erase_Block(MEM_ADDR_HIS_ALARM) == W25Qx_OK)
{
// Read data from block
if(BSP_W25Qx_Read(Charger.memory.hisAlarm.data.value, MEM_ADDR_HIS_ALARM, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Erase MEM_ADDR_HIS_ALARM block(4k byte) pass.\r\n");
Charger.memory.hisAlarm.op_bits.clear = OFF;
}
else
{
DEBUG_WARN("Erase MEM_ADDR_HIS_ALARM block(4k byte) fail.\r\n");
}
}
else
{
DEBUG_WARN("Erase MEM_ADDR_HIS_ALARM block(4k byte) fail.\r\n");
}
}
if(Charger.memory.hisAlarm.op_bits.backup)
{
isSuccess = PASS;
// Erase block data
if(BSP_W25Qx_Erase_Block(MEM_ADDR_BACKUP_HIS_ALARM) == W25Qx_OK)
{
// Write data to block
for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
{
if(BSP_W25Qx_Write(&Charger.memory.hisAlarm.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_BACKUP_HIS_ALARM+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
{
isSuccess = FAIL;
}
}
if(isSuccess)
DEBUG_INFO("Backup MEM_ADDR_BACKUP_HIS_ALARM success.\r\n");
else
DEBUG_WARN("Backup MEM_ADDR_BACKUP_HIS_ALARM fail.\r\n");
Charger.memory.hisAlarm.op_bits.backup = OFF;
Charger.memory.hisAlarm.op_bits.clear = ON;
}
else
{
DEBUG_WARN("Backup MEM_ADDR_BACKUP_HIS_ALARM block(4k byte) fail.\r\n");
}
}
if(Charger.memory.hisAlarm.op_bits.restore)
{
// Restore data from backup block
if(BSP_W25Qx_Read(Charger.memory.hisAlarm.data.value, MEM_ADDR_BACKUP_HIS_ALARM, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Restore MEM_ADDR_BACKUP_HIS_ALARM block(4k byte) pass.\r\n");
Charger.memory.hisAlarm.op_bits.restore = OFF;
}
else
{
DEBUG_WARN("Restore MEM_ADDR_BACKUP_HIS_ALARM block(4k byte) fail.\r\n");
}
}
#ifdef FUNC_METER_IC_HISTORY
/*
Meter IC calibration history operation
*/
if(Charger.memory.hisMeterIC.op_bits.read)
{
osDelay(100);
// Read data from block
if(BSP_W25Qx_Read(Charger.memory.hisMeterIC.data.value, MEM_ADDR_HIS_METERIC, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Read MEM_ADDR_HIS_METERIC block(4k byte) pass.\r\n");
Charger.memory.hisMeterIC.op_bits.read = OFF;
}
else
{
DEBUG_INFO("Read MEM_ADDR_HIS_METERIC block(4k byte) fail.\r\n");
}
}
if(Charger.memory.hisMeterIC.op_bits.update)
{
isSuccess = PASS;
// Write data to block
for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
{
if(BSP_W25Qx_Write(&Charger.memory.hisMeterIC.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_HIS_METERIC+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
{
isSuccess = FAIL;
}
}
if(isSuccess)
DEBUG_INFO("Update MEM_ADDR_HIS_METERIC success.\r\n");
else
DEBUG_WARN("Update MEM_ADDR_HIS_METERIC fail.\r\n");
Charger.memory.hisMeterIC.op_bits.update = OFF;
}
if(Charger.memory.hisMeterIC.op_bits.clear)
{
// Erase block data
if(BSP_W25Qx_Erase_Block(MEM_ADDR_HIS_METERIC) == W25Qx_OK)
{
// Read data from block
if(BSP_W25Qx_Read(Charger.memory.hisMeterIC.data.value, MEM_ADDR_HIS_METERIC, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Erase MEM_ADDR_HIS_METERIC block(4k byte) pass.\r\n");
Charger.memory.hisMeterIC.op_bits.clear = OFF;
}
else
{
DEBUG_INFO("Erase MEM_ADDR_HIS_METERIC block(4k byte) fail.\r\n");
}
}
else
{
DEBUG_INFO("Erase MEM_ADDR_HIS_METERIC block(4k byte) fail.\r\n");
}
}
if(Charger.memory.hisMeterIC.op_bits.backup)
{
isSuccess = PASS;
// Erase block data
if(BSP_W25Qx_Erase_Block(MEM_ADDR_BACKUP_HIS_METERIC) == W25Qx_OK)
{
// Write data to block
for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
{
if(BSP_W25Qx_Write(&Charger.memory.hisMeterIC.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_BACKUP_HIS_METERIC+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
{
isSuccess = FAIL;
}
}
if(isSuccess)
DEBUG_INFO("Backup MEM_ADDR_BACKUP_HIS_METERIC success.\r\n");
else
DEBUG_WARN("Backup MEM_ADDR_BACKUP_HIS_METERIC fail.\r\n");
Charger.memory.hisMeterIC.op_bits.backup = OFF;
Charger.memory.hisMeterIC.op_bits.clear = ON;
}
else
{
DEBUG_INFO("Backup MEM_ADDR_BACKUP_HIS_METERIC block(4k byte) fail.\r\n");
}
}
if(Charger.memory.hisMeterIC.op_bits.restore)
{
// Restore data from backup block
if(BSP_W25Qx_Read(Charger.memory.hisMeterIC.data.value, MEM_ADDR_BACKUP_HIS_METERIC, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Restore MEM_ADDR_BACKUP_HIS_METERIC block(4k byte) pass.\r\n");
Charger.memory.hisMeterIC.op_bits.restore = OFF;
}
else
{
DEBUG_INFO("Restore MEM_ADDR_BACKUP_HIS_METERIC block(4k byte) fail.\r\n");
}
}
#else //FUNC_METER_IC_HISTORY
/*
Charging history operation
*/
if(Charger.memory.hisCharging.op_bits.read)
{
osDelay(100);
// Read data from block
if(BSP_W25Qx_Read(Charger.memory.hisCharging.data.value, MEM_ADDR_HIS_CHARGING, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Read MEM_ADDR_HIS_CHARGING block(4k byte) pass.\r\n");
Charger.memory.hisCharging.op_bits.read = OFF;
}
else
{
DEBUG_WARN("Read MEM_ADDR_HIS_CHARGING block(4k byte) fail.\r\n");
}
}
if(Charger.memory.hisCharging.op_bits.update)
{
isSuccess = PASS;
// Write data to block
for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
{
if(BSP_W25Qx_Write(&Charger.memory.hisCharging.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_HIS_CHARGING+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
{
isSuccess = FAIL;
}
}
if(isSuccess)
DEBUG_INFO("Update MEM_ADDR_HIS_CHARGING success.\r\n");
else
DEBUG_WARN("Update MEM_ADDR_HIS_CHARGING fail.\r\n");
Charger.memory.hisCharging.op_bits.update = OFF;
}
if(Charger.memory.hisCharging.op_bits.clear)
{
// Erase block data
if(BSP_W25Qx_Erase_Block(MEM_ADDR_HIS_CHARGING) == W25Qx_OK)
{
// Read data from block
if(BSP_W25Qx_Read(Charger.memory.hisCharging.data.value, MEM_ADDR_HIS_CHARGING, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Erase MEM_ADDR_HIS_CHARGING block(4k byte) pass.\r\n");
Charger.memory.hisCharging.op_bits.clear = OFF;
}
else
{
DEBUG_WARN("Erase MEM_ADDR_HIS_CHARGING block(4k byte) fail.\r\n");
}
}
else
{
DEBUG_WARN("Erase MEM_ADDR_HIS_CHARGING block(4k byte) fail.\r\n");
}
}
if(Charger.memory.hisCharging.op_bits.backup)
{
isSuccess = PASS;
// Erase block data
if(BSP_W25Qx_Erase_Block(MEM_ADDR_BACKUP_HIS_CHARGING) == W25Qx_OK)
{
// Write data to block
for(uint16_t idx=0;idx<((W25Q16FV_BLOCK_SIZE)>>8);idx++)
{
if(BSP_W25Qx_Write(&Charger.memory.hisCharging.data.value[idx*W25Q16FV_PAGE_SIZE], MEM_ADDR_BACKUP_HIS_CHARGING+(idx*W25Q16FV_PAGE_SIZE), W25Q16FV_PAGE_SIZE) != W25Qx_OK)
{
isSuccess = FAIL;
}
}
if(isSuccess)
DEBUG_INFO("Backup MEM_ADDR_BACKUP_HIS_CHARGING success.\r\n");
else
DEBUG_WARN("Backup MEM_ADDR_BACKUP_HIS_CHARGING fail.\r\n");
Charger.memory.hisCharging.op_bits.backup = OFF;
Charger.memory.hisCharging.op_bits.clear = ON;
}
else
{
DEBUG_WARN("Backup MEM_ADDR_BACKUP_HIS_CHARGING block(4k byte) fail.\r\n");
}
}
if(Charger.memory.hisCharging.op_bits.restore)
{
// Restore data from backup block
if(BSP_W25Qx_Read(Charger.memory.hisCharging.data.value, MEM_ADDR_BACKUP_HIS_CHARGING, W25Q16FV_BLOCK_SIZE)== W25Qx_OK)
{
DEBUG_INFO("Restore MEM_ADDR_BACKUP_HIS_CHARGING block(4k byte) pass.\r\n");
Charger.memory.hisCharging.op_bits.restore = OFF;
}
else
{
DEBUG_WARN("Restore MEM_ADDR_BACKUP_HIS_CHARGING block(4k byte) fail.\r\n");
}
}
#endif //FUNC_METER_IC_HISTORY
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
if (!Charger.m_bReadAllMemory)
{
#ifdef FUNC_METER_IC_HISTORY
MeterIC_CaliHistory_ReadAll();
#endif
Charger.m_bReadAllMemory = 1;
}
#endif
osDelay(1);
}
/* USER CODE END StartMemoryTask */
}
/* USER CODE BEGIN Header_StartWifiTask */
/**
* @brief Function implementing the wifiTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartWifiTask */
void StartWifiTask(void const * argument)
{
/* USER CODE BEGIN StartWifiTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
IdleUntilReadAllMemory();
#endif
/* Infinite loop */
char tmpBuf[128];
//uint8_t endFlag[4]={0x55,0xaa,0x55,0xaa};
__IO uint32_t flash;
//uint32_t checksum;
uint32_t rndNumber;
//=====================================
// Module reset
//=====================================
HAL_GPIO_WritePin(OUT_BLE_RESET_GPIO_Port, OUT_BLE_RESET_Pin, GPIO_PIN_RESET);
osDelay(60);
HAL_GPIO_WritePin(OUT_BLE_RESET_GPIO_Port, OUT_BLE_RESET_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(OUT_BLE_DSR_GPIO_Port, OUT_BLE_DSR_Pin, GPIO_PIN_SET);
Charger.wifi.initSeq = 0;
Charger.wifi.isDataMode = OFF;
UART_WIFI_Init_OK = OFF;
osDelay(1000);
/* Infinite loop */
for(;;)
{
//=====================================
// WIFI module initialization process
//=====================================
switch(Charger.wifi.initSeq)
{
case 0x00:
HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_RESTORE], strlen(WIFI_CMD[WIFI_CMD_SET_RESTORE]), 0xffff);
osDelay(WIFI_INIT_DELAY);
break;
case 0x01:
HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_DTR], strlen(WIFI_CMD[WIFI_CMD_SET_DTR]), 0xffff);
osDelay(WIFI_INIT_DELAY);
break;
case 0x02:
HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_DSR], strlen(WIFI_CMD[WIFI_CMD_SET_DSR]), 0xffff);
osDelay(WIFI_INIT_DELAY);
break;
case 0x03:
HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_GET_ADDR], strlen(WIFI_CMD[WIFI_CMD_GET_ADDR]), 0xffff);
osDelay(WIFI_INIT_DELAY);
break;
case 0x04:
sprintf(tmpBuf, "%s\"EVSE_AP_%sP\"\r\n", WIFI_CMD[WIFI_CMD_SET_SSID], Charger.wifi.module_mac);
DEBUG_INFO("WIFI module set name: EVSE_AP_%s\r\n", Charger.wifi.module_mac);
HAL_UART_Transmit(&WIFI_USART, (uint8_t *)tmpBuf, strlen(tmpBuf), 0xffff);
osDelay(WIFI_INIT_DELAY);
break;
case 0x05:
HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_CHANNEL], strlen(WIFI_CMD[WIFI_CMD_SET_CHANNEL]), 0xffff);
osDelay(WIFI_INIT_DELAY);
break;
case 0x06:
HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_SECURITY_MODE], strlen(WIFI_CMD[WIFI_CMD_SET_SECURITY_MODE]), 0xffff);
osDelay(WIFI_INIT_DELAY);
break;
case 0x07:
sprintf(tmpBuf, "%s\"%s\"\r\n", WIFI_CMD[WIFI_CMD_SET_PASSWORD], Charger.memory.EVSE_Config.data.item.wifiConfig.passwd);
HAL_UART_Transmit(&WIFI_USART, (uint8_t *)tmpBuf, strlen(tmpBuf), 0xffff);
osDelay(WIFI_INIT_DELAY);
break;
case 0x08:
HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_DHCPSERVER], strlen(WIFI_CMD[WIFI_CMD_SET_DHCPSERVER]), 0xffff);
osDelay(WIFI_INIT_DELAY);
break;
case 0x09:
HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_TCPSETVER_CONFIG], strlen(WIFI_CMD[WIFI_CMD_SET_TCPSETVER_CONFIG]), 0xffff);
osDelay(WIFI_INIT_DELAY);
break;
case 0x0a:
HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_AP_ACTIVE], strlen(WIFI_CMD[WIFI_CMD_SET_AP_ACTIVE]), 0xffff);
osDelay(WIFI_INIT_DELAY);
break;
case 0x0b:
HAL_UART_Transmit(&WIFI_USART, (uint8_t *)WIFI_CMD[WIFI_CMD_SET_DATA_MODE], strlen(WIFI_CMD[WIFI_CMD_SET_DATA_MODE]), 0xffff);
DEBUG_INFO("WIFI module switch to data mode.\r\n");
osDelay(WIFI_INIT_DELAY);
default:
UART_WIFI_Init_OK = ON;
break;
}
//=====================================
// WIFI central device connect status
//=====================================
if((HAL_GPIO_ReadPin(IN_BLE_DTR_GPIO_Port, IN_BLE_DTR_Pin) == GPIO_PIN_SET) && (UART_WIFI_Init_OK == ON))
{
// Device disconnect
timerRefresh(TIMER_IDX_WIFI);
if(Charger.wifi.loginRole == WIFI_LOGIN_ROLE_ROOT || Charger.wifi.loginRole == WIFI_LOGIN_ROLE_USER)
{
DEBUG_INFO("WIFI client device disconnect.\r\n.");
Charger.wifi.loginRole = WIFI_LOGIN_ROLE_UNKOWN;
}
}
else if((HAL_GPIO_ReadPin(IN_BLE_DTR_GPIO_Port, IN_BLE_DTR_Pin) == GPIO_PIN_RESET) && (UART_WIFI_Init_OK == ON))
{
// Device connect in
if(Charger.wifi.loginRole == WIFI_LOGIN_ROLE_UNKOWN)
{
DEBUG_INFO("WIFI client device connect.....wait sign in.\r\n.");
osDelay(1000);
}
}
//=====================================
// Communication timeout process
//=====================================
if(timer[TIMER_IDX_WIFI].isAlarm)
{
Charger.wifi.loginRole = WIFI_LOGIN_ROLE_UNKOWN;
DEBUG_INFO("WIFI no communication over time, disconnect client device.\r\n");
timerRefresh(TIMER_IDX_WIFI);
HAL_GPIO_WritePin(OUT_BLE_DSR_GPIO_Port, OUT_BLE_DSR_Pin, GPIO_PIN_RESET);
osDelay(100);
HAL_GPIO_WritePin(OUT_BLE_DSR_GPIO_Port, OUT_BLE_DSR_Pin, GPIO_PIN_SET);
}
//=====================================
// WIFI uart recieve data process
//=====================================
if(UART_WIFI_recv_end_flag == ON)
{
if((HAL_GPIO_ReadPin(IN_BLE_DTR_GPIO_Port, IN_BLE_DTR_Pin) == GPIO_PIN_SET) || !Charger.wifi.isDataMode)
{
// AT command rx process
if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_RESTORE])!=NULL)
{
Charger.wifi.initSeq++;
}
if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_DTR])!=NULL)
{
Charger.wifi.initSeq++;
}
if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_DSR])!=NULL)
{
Charger.wifi.initSeq++;
}
if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_GET_ADDR])!=NULL)
{
memcpy(Charger.wifi.module_mac, &UART_WIFI_rx_buffer[strcspn((char *)UART_WIFI_rx_buffer, ":")+1], 12);
Charger.wifi.module_mac[12] = '\0';
DEBUG_INFO("Wifi module mac address: %s\r\n", Charger.wifi.module_mac);
Charger.wifi.initSeq++;
}
if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_SSID])!=NULL)
{
Charger.wifi.initSeq++;
}
if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_CHANNEL])!=NULL)
{
Charger.wifi.initSeq++;
}
if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_SECURITY_MODE])!=NULL)
{
Charger.wifi.initSeq++;
}
if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_PASSWORD])!=NULL)
{
Charger.wifi.initSeq++;
}
if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_DHCPSERVER])!=NULL)
{
Charger.wifi.initSeq++;
}
if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_TCPSETVER_CONFIG])!=NULL)
{
Charger.wifi.initSeq++;
}
if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_AP_ACTIVE])!=NULL)
{
Charger.wifi.initSeq++;
}
if(strstr((char *)UART_WIFI_rx_buffer, WIFI_CMD[WIFI_CMD_SET_DATA_MODE])!=NULL)
{
Charger.wifi.isDataMode = ON;
Charger.wifi.initSeq++;
}
}
else
{
// Application protocol rx process
uint8_t tx[UART_BUFFER_SIZE];
uint8_t tx_len;
uint8_t chksum = 0;
if(isValidCheckSum_WIFI() && (rndNumber != ((UART_WIFI_rx_buffer[3]<<0) | (UART_WIFI_rx_buffer[4]<<8) | (UART_WIFI_rx_buffer[5]<<16) | (UART_WIFI_rx_buffer[6]<<24))))
{
// Timer reset
timerRefresh(TIMER_IDX_WIFI);
rndNumber = ((UART_WIFI_rx_buffer[3]<<0) | (UART_WIFI_rx_buffer[4]<<8) | (UART_WIFI_rx_buffer[5]<<16) | (UART_WIFI_rx_buffer[6]<<24));
switch(UART_WIFI_rx_buffer[2])
{
case WIFI_PROTOCOL_MESSAGE_SIGN_IN:
DEBUG_INFO("WIFI device sign request...%d\r\n", UART_WIFI_rx_buffer[7]);
tx_len = 5;
tx[0] = (tx_len>>8)&0xff;
tx[1] = (tx_len&0xff);
tx[2] = UART_WIFI_rx_buffer[2] + 0x80;
tx[3] = 0x00;
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[4] = chksum;
break;
default:
/*
TODO: Unknow command response here
*/
tx_len = 5;
tx[0] = 0x00;
tx[1] = 0x05;
tx[2] = UART_WIFI_rx_buffer[2] + 0x80;
tx[3] = 0x00;
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[4] = chksum;
DEBUG_ERROR("WIFI unknow command.\r\n");
break;
}
}
else
{
/*
TODO: Protocol check sum error response here
*/
tx_len = 5;
tx[0] = 0x00;
tx[1] = 0x05;
tx[2] = UART_WIFI_rx_buffer[2] + 0x80;
tx[3] = 0x00;
for(uint16_t idx=0;idx<((tx[1] | (tx[0]<<8))-3);idx++)
{
chksum ^= tx[2 + idx];
}
tx[4] = chksum;
DEBUG_ERROR("WIFI check sum validation error.\r\n");
}
HAL_UART_Transmit(&WIFI_USART, (uint8_t *)tx, tx_len, 0xffff);
}
UART_WIFI_rx_len=0;
UART_WIFI_recv_end_flag=0;
}
HAL_UART_Receive_DMA(&WIFI_USART, (uint8_t*)UART_WIFI_rx_buffer, UART_BUFFER_SIZE);
osDelay(1);
}
/* USER CODE END StartWifiTask */
}
/* USER CODE BEGIN Header_StartMeterTask */
/**
* @brief Function implementing the MeterTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartMeterTask */
void StartMeterTask(void const * argument)
{
/* USER CODE BEGIN StartMeterTask */
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
IdleUntilReadAllMemory();
#endif
#ifdef FUNC_WAIT_METER_IC_INIT_OK
#ifdef FUNC_IDLE_UNTIL_INIT_METER_IC
IdleUntilInitMeterIC();
#endif
#endif //FUNC_WAIT_METER_IC_INIT_OK
/* Infinite loop */
#ifdef RECODE_FUNC_METER_TASK
#else
uint8_t pollingStep = 0;
uint8_t addr = 0x01;
uint8_t meter_model;
#endif
HAL_GPIO_WritePin(Meter_DIR_GPIO_Port, Meter_DIR_Pin, GPIO_PIN_RESET);
//#ifdef FUNC_TEST_PRO380_INIT_DE_HIGH_1_SEC
// HAL_GPIO_WritePin(Meter_DIR_GPIO_Port, Meter_DIR_Pin, GPIO_PIN_SET);
// osDelay(1000);
// HAL_GPIO_WritePin(Meter_DIR_GPIO_Port, Meter_DIR_Pin, GPIO_PIN_RESET);
//#endif
//#ifndef RECODE_FUNC_METER_TASK
timerEnable(TIMER_IDX_METER_POLLING, 500);
//#endif
static void* pTargetMeter = NULL;
/* Infinite loop */
for(;;)
{
#ifdef RECODE_FUNC_METER_TASK
if(timer[TIMER_IDX_METER_POLLING].isAlarm)
{
timerRefresh(TIMER_IDX_METER_POLLING);
#endif
if (Charger.m_bUseExtMeter_PRO380)
{
#ifdef RECODE_FUNC_METER_TASK
#ifdef RECODE_METER_PRO380
static PPRO380 p = NULL;
if (p == NULL)
{
p = (PPRO380)HTK_Malloc(sizeof(PRO380));
if (p != NULL)
{
Charger.m_pPRO380 = p;
PRO380_Init(p, METER_PRO380_DEV_ADDR);
}
}
else
{
if (pTargetMeter != (void*)p)
{
pTargetMeter = (void*)p;
MX_UART4_Init_For_Meter_PRO380();
__HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE);
}
PRO380_Proc(p);
}
#endif //RECODE_METER_PRO380
#else //RECODE_FUNC_METER_TASK
{
meter_model = METER_MODEL_PRO380;
if(UART_METER_recv_end_flag != ON)
{
// Polling meter info
uint8_t tx[UART_BUFFER_SIZE];
uint8_t tx_len = 0;
if(timer[TIMER_IDX_METER_POLLING].isAlarm)
{
timerRefresh(TIMER_IDX_METER_POLLING);
switch(pollingStep)
{
case 0:
tx_len = read_Energy_tx(meter_model, addr, &tx[0]);
break;
}
HAL_GPIO_WritePin(Meter_DIR_GPIO_Port, Meter_DIR_Pin, GPIO_PIN_SET);
osDelay(5);
HAL_UART_Transmit(&METER_USART, (uint8_t *)tx, tx_len, 0xffff);
osDelay(5);
HAL_GPIO_WritePin(Meter_DIR_GPIO_Port, Meter_DIR_Pin, GPIO_PIN_RESET);
osDelay(30);
}
}
else
{
switch(pollingStep)
{
case 0:
// Total enery
if(read_Energy_rx(meter_model, addr, &UART_METER_rx_buffer[0], UART_METER_rx_len))
{
//pollingStep++; //Only process case 0 (Total Energy)
Charger.counter.Meter_Timeout.fail = 0;
Charger.m_MeterPRO380.m_LastUpdateTick = HAL_GetTick();
}
break;
}
memset(&UART_METER_rx_buffer[0], 0x00, ARRAY_SIZE(UART_METER_rx_buffer));
UART_METER_rx_len = 0;
UART_METER_recv_end_flag = OFF;
}
HAL_UART_Receive_DMA(&METER_USART,(uint8_t*)UART_METER_rx_buffer, UART_BUFFER_SIZE);
}
#endif //RECODE_FUNC_METER_TASK
}
#ifdef FUNC_PTB_METER_WM3M4C
if (Charger.m_bUseExtMeter_WM3M4C)
{
static PWM3M4C p = NULL;
if (p == NULL)
{
p = (PWM3M4C)HTK_Malloc(sizeof(WM3M4C));
if (p != NULL)
{
Charger.m_pWM3M4C = p;
WM3M4C_Init(p, METER_WM3M4C_DEV_ADDR);
}
}
else
{
if (pTargetMeter != (void*)p)
{
pTargetMeter = (void*)p;
MX_UART4_Init_For_PTB_Meter_WM3M4C();
__HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE);
}
WM3M4C_Proc(p);
}
}
#endif //FUNC_PTB_METER_WM3M4C
#ifdef FUNC_EKM_OMNIMETER
if (Charger.m_bUseExtMeter_OMNIMETER)
{
static PEKM_Omnimeter p = NULL;
if (p == NULL)
{
p = (PEKM_Omnimeter)HTK_Malloc(sizeof(EKM_Omnimeter));
if (p != NULL)
{
Charger.m_pEKM_Omnimeter = p;
EKM_Omnimeter_Init(p);
}
}
else
{
if (pTargetMeter != (void*)p)
{
pTargetMeter = (void*)p;
MX_UART4_Init_For_EKM_Omnimeter();
__HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE);
}
EKM_Omnimeter_Proc(p);
}
}
#endif //FUNC_EKM_OMNIMETER
#ifdef RECODE_FUNC_METER_TASK
}
#endif
osDelay(1);
}
/* USER CODE END StartMeterTask */
}
/* Private application code --------------------------------------------------*/
/* USER CODE BEGIN Application */
#ifdef RECODE_FUNC_METER_IC_TASK
void MeterIC_Proc(uint16_t* pUpdateMemReq)
{
#ifdef FUNC_METER_IC_ADE7858A
//Meter IC
{
//meter_model = METER_MODEL_IC;
#ifndef DEBUG_METER_IC
HTK_UNUSED(MeterIC_KP);
#endif
double Volt[AC_PHASE_NUM_MAX] = { 0 };
double Curr[AC_PHASE_NUM_MAX] = { 0 };
static uint32_t EngPlusRaw[AC_PHASE_NUM_MAX] = { 0 };
#ifdef FUNC_METER_IC_POWER_FADEOUT
static uint32_t ValidCurrTick = 0;
#endif
if(timer[TIMER_IDX_METER_IC_POLLING].isAlarm)
{
timerRefresh(TIMER_IDX_METER_IC_POLLING);
//Check new calibration values
if (Charger.m_MeterIC_TrigWriteCaliVals.m_Data != 0) //Find new calibration values
{
MeterIC_WriteCaliValsFromFlash(HTK_FALSE, HTK_TRUE);
}
//Read data from Meter IC and calculate
{
PMeterIC_MeasVals p = &Charger.m_MeterIC_MeasVals;
uint8_t *RxBuf = I2C_METER_rx_buffer;
ADE7858A_Get(AVRMS, RxBuf, &p->m_AVRMS, 4); //V1
ADE7858A_Get(BVRMS, RxBuf, &p->m_BVRMS, 4); //V2
ADE7858A_Get(CVRMS, RxBuf, &p->m_CVRMS, 4); //V3
#ifdef FUNC_METER_IC_READ_PHASE_ANGLE
{
PMeterIC_ExtraInfo pEx = &Charger.m_MeterIcEx;
ADE7858A_Get(MMODE, RxBuf, &pEx->m_MMODE, 1); //MMODE
ADE7858A_Get(COMPMODE, RxBuf, &pEx->m_COMPMODE, 2); //COMPMODE
ADE7858A_Get(ANGLE0, RxBuf, &pEx->m_AngleReg[0], 2); //ANGLE0
ADE7858A_Get(ANGLE1, RxBuf, &pEx->m_AngleReg[1], 2); //ANGLE1
ADE7858A_Get(ANGLE2, RxBuf, &pEx->m_AngleReg[2], 2); //ANGLE2
ADE7858A_Get(Period, RxBuf, &p->m_Period, 2); //Period
if (HTK_IS_BETWEEN_MIDDIFF(p->m_Period, 5120, 30)) //Datasheet "Period Measurement"
{
pEx->m_AcPeriodMode = AC_PERIOD_MODE_50HZ;
for (u8 i = 0; i < 3; i++)
{
if (pEx->m_AngleReg[i] != 0)
{
pEx->m_AngleDegree[i] = METER_IC_ANGLE_REG_TO_DEGREE(50, pEx->m_AngleReg[i]);
}
}
}
else if (HTK_IS_BETWEEN_MIDDIFF(p->m_Period, 4267, 30))
{
pEx->m_AcPeriodMode = AC_PERIOD_MODE_60HZ;
for (u8 i = 0; i < 3; i++)
{
if (pEx->m_AngleReg[i] != 0)
{
pEx->m_AngleDegree[i] = METER_IC_ANGLE_REG_TO_DEGREE(60, pEx->m_AngleReg[i]);
}
}
}
else
{
pEx->m_AcPeriodMode = AC_PERIOD_MODE_UNKNOW;
// for (u8 i = 0; i < 3; i++)
// {
// pEx.m_AngleDegree[i] = 0;
// }
}
ADE7858A_Get(STATUS0, RxBuf, &pEx->m_STATUS0, 4); //STATUS0
ADE7858A_Get(STATUS1, RxBuf, &pEx->m_STATUS1, 4); //STATUS1
pEx->m_bSEQERR = BIT_GET(pEx->m_STATUS1, 19); //bit19
}
#endif //FUNC_METER_IC_READ_PHASE_ANGLE
ADE7858A_Get(AIRMS, RxBuf, &p->m_AIRMS, 4); //I1
ADE7858A_Get(BIRMS, RxBuf, &p->m_BIRMS, 4); //I2
ADE7858A_Get(CIRMS, RxBuf, &p->m_CIRMS, 4); //I3
ADE7858A_Get(AVRMS_LRIP, RxBuf, &p->m_AVRMS_LRIP, 4); //V1_LRIP
ADE7858A_Get(BVRMS_LRIP, RxBuf, &p->m_BVRMS_LRIP, 4); //V2_LRIP
ADE7858A_Get(CVRMS_LRIP, RxBuf, &p->m_CVRMS_LRIP, 4); //V3_LRIP
ADE7858A_Get(AIRMS_LRIP, RxBuf, &p->m_AIRMS_LRIP, 4); //I1_LRIP
ADE7858A_Get(BIRMS_LRIP, RxBuf, &p->m_BIRMS_LRIP, 4); //I2_LRIP
ADE7858A_Get(CIRMS_LRIP, RxBuf, &p->m_CIRMS_LRIP, 4); //I3_LRIP
ADE7858A_Get(AWATT, RxBuf, &p->m_AWATT, 4); //P1
ADE7858A_Get(BWATT, RxBuf, &p->m_BWATT, 4); //P2
ADE7858A_Get(CWATT, RxBuf, &p->m_CWATT, 4); //P3
if (ADE7858A_Get(AWATTHR, RxBuf, &p->m_AWATTHR, 4)) { EngPlusRaw[0] += HTK_GET_VAL_MAX(p->m_AWATTHR, 0); } //E1, only positive energy allowed
if (ADE7858A_Get(BWATTHR, RxBuf, &p->m_BWATTHR, 4)) { EngPlusRaw[1] += HTK_GET_VAL_MAX(p->m_BWATTHR, 0); } //E2, only positive energy allowed
if (ADE7858A_Get(CWATTHR, RxBuf, &p->m_CWATTHR, 4)) { EngPlusRaw[2] += HTK_GET_VAL_MAX(p->m_CWATTHR, 0); } //E3, only positive energy allowed
Volt[0] = p->m_AVRMS * KV; //V
Volt[1] = p->m_BVRMS * KV; //V
Volt[2] = p->m_CVRMS * KV; //V
#ifdef TEST_ACXXX_FAKEDATA
HTK_UNUSED(Volt[0]);
#endif
#ifdef FUNC_METER_IC_VARIABLE_PARAM
Curr[0] = p->m_AIRMS * MeterIC_KI; //A
Curr[1] = p->m_BIRMS * MeterIC_KI; //A
Curr[2] = p->m_CIRMS * MeterIC_KI; //A
#else
Curr[0] = p->m_AIRMS * KI; //A
Curr[1] = p->m_BIRMS * KI; //A
Curr[2] = p->m_CIRMS * KI; //A
#endif
for (uint8_t i = 0; i < AC_PHASE_NUM_MAX; i++)
{
#ifndef TEST_ACXXX_FAKEDATA
#ifdef VO_SIMU_ACV
if (Charger.m_VOCode.m_EnableSimuACV)
{
Charger.Voltage[i] = Charger.m_SimuData.m_AcvVolt;
}
else
{
Charger.Voltage[i] = (uint16_t)(Volt[i] * 100); //10mV
}
#else
Charger.Voltage[i] = (uint16_t)(Volt[i] * 100); //10mV
#endif //VO_SIMU_ACV
#endif //TEST_ACXXX_FAKEDATA
#ifdef VO_SIMU_ACA
if (Charger.m_VOCode.m_EnableSimuACA)
{
if (Charger.m_b3PhaseModel || (!Charger.m_b3PhaseModel && i == 0))
{
Charger.Current[i] = Charger.m_SimuData.m_AcaCurr;
}
}
else
{
Charger.Current[i] = (uint16_t)(Curr[i] * 100); //10mA
}
#else
Charger.Current[i] = (uint16_t)(Curr[i] * 100); //10mA
#endif //VO_SIMU_ACA
}
#ifdef FUNC_METER_IC_POWER_FADEOUT
if (Curr[0] > METER_IC_POWER_CONSUMPTION_MIN_CURR ||
Curr[1] > METER_IC_POWER_CONSUMPTION_MIN_CURR ||
Curr[2] > METER_IC_POWER_CONSUMPTION_MIN_CURR)
{
//ValidCurrTick = (int64_t)HAL_GetTick();
ValidCurrTick = HAL_GetTick();
}
#endif
#ifdef DEBUG_METER_IC
XP("L1_Voltage: %f (%d)\r\n", Volt[0], p->m_AVRMS);
XP("L2_Voltage: %f (%d)\r\n", Volt[1], p->m_BVRMS);
XP("L3_Voltage: %f (%d)\r\n", Volt[2], p->m_CVRMS);
XP("L1_Current: %f (%d)\r\n", Curr[0], p->m_AIRMS);
XP("L2_Current: %f (%d)\r\n", Curr[1], p->m_BIRMS);
XP("L3_Current: %f (%d)\r\n", Curr[2], p->m_CIRMS);
double Volt_LRIP[AC_PHASE_NUM_MAX] = { 0 };
double Curr_LRIP[AC_PHASE_NUM_MAX] = { 0 };
Volt_LRIP[0] = p->m_AVRMS_LRIP * KV; //V
Volt_LRIP[1] = p->m_BVRMS_LRIP * KV; //V
Volt_LRIP[2] = p->m_CVRMS_LRIP * KV; //V
#ifdef FUNC_METER_IC_VARIABLE_PARAM
Curr_LRIP[0] = p->m_AIRMS_LRIP * MeterIC_KI ; //A
Curr_LRIP[1] = p->m_BIRMS_LRIP * MeterIC_KI ; //A
Curr_LRIP[2] = p->m_CIRMS_LRIP * MeterIC_KI ; //A
#else
Curr_LRIP[0] = p->m_AIRMS_LRIP * KI; //A
Curr_LRIP[1] = p->m_BIRMS_LRIP * KI; //A
Curr_LRIP[2] = p->m_CIRMS_LRIP * KI; //A
#endif
XP("L1_Voltage_LRIP: %f (%d)\r\n", Volt_LRIP[0], p->m_AVRMS_LRIP);
XP("L2_Voltage_LRIP: %f (%d)\r\n", Volt_LRIP[1], p->m_BVRMS_LRIP);
XP("L3_Voltage_LRIP: %f (%d)\r\n", Volt_LRIP[2], p->m_CVRMS_LRIP);
XP("L1_Current_LRIP: %f (%d)\r\n", Curr_LRIP[0], p->m_AIRMS_LRIP);
XP("L2_Current_LRIP: %f (%d)\r\n", Curr_LRIP[1], p->m_BIRMS_LRIP);
XP("L3_Current_LRIP: %f (%d)\r\n", Curr_LRIP[2], p->m_CIRMS_LRIP);
#ifdef FUNC_METER_IC_VARIABLE_PARAM
double Power1 = p->m_AWATT * MeterIC_KP; //W
double Power2 = p->m_BWATT * MeterIC_KP; //W
double Power3 = p->m_CWATT * MeterIC_KP; //W
#else
double Power1 = p->m_AWATT * KP; //W
double Power2 = p->m_BWATT * KP; //W
double Power3 = p->m_CWATT * KP; //W
#endif
XP("L1_WATT(W): %f (%d, %u)\r\n", Power1, p->m_AWATT, (uint32_t)p->m_AWATT);
XP("L2_WATT(W): %f (%d, %u)\r\n", Power2, p->m_BWATT, (uint32_t)p->m_BWATT);
XP("L3_WATT(W): %f (%d, %u)\r\n", Power3, p->m_CWATT, (uint32_t)p->m_CWATT);
#ifdef FUNC_METER_IC_VARIABLE_PARAM
double Energy1 = p->m_AWATTHR * MeterIC_KE; //Wh
double Energy2 = p->m_BWATTHR * MeterIC_KE; //Wh
double Energy3 = p->m_CWATTHR * MeterIC_KE; //Wh
#else
double Energy1 = p->m_AWATTHR * KE; //Wh
double Energy2 = p->m_BWATTHR * KE; //Wh
double Energy3 = p->m_CWATTHR * KE; //Wh
#endif
XP("L1_WATTHR(Wh): %f (%d, %u)\r\n", Energy1, p->m_AWATTHR, (uint32_t)p->m_AWATTHR);
XP("L2_WATTHR(Wh): %f (%d, %u)\r\n", Energy2, p->m_BWATTHR, (uint32_t)p->m_BWATTHR);
XP("L3_WATTHR(Wh): %f (%d, %u)\r\n", Energy3, p->m_CWATTHR, (uint32_t)p->m_CWATTHR);
#endif //DEBUG_METER_IC
}
}
#ifdef FUNC_POWER_CONSUMPTION_BY_METER_IC
if(timer[TIMER_IDX_POWER].isAlarm)
{
timerRefresh(TIMER_IDX_POWER);
if (0)
{
}
#ifdef FUNC_PTB_METER_WM3M4C
else if (Charger.m_bUseExtMeter_WM3M4C && Charger.m_pWM3M4C)
{
uint64_t Eng = Charger.m_pWM3M4C->m_AccuEnergy1 / ((Charger.m_b3PhaseModel) ? 3 : 1);
if (Charger.m_b3PhaseModel)
{
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 = Eng;
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 = Eng;
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3 = Eng;
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total =
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 +
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 +
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3;
}
else
{
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 = Eng;
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 = 0;
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3 = 0;
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total =
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1;
}
}
#endif //FUNC_PTB_METER_WM3M4C
else if (Charger.m_bUseExtMeter_PRO380 && Charger.m_pPRO380) //Use PRO380
{
for (uint8_t i = 0; i < AC_PHASE_NUM_MAX; i++)
{
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Lx[i] =
// //round off to 2 decimal place
// //i.g. 0.53 (float: 0.52999..) => 52.999.. => 53 => 5300 (0.0001 kWh) => 0.53 kWh
// (uint64_t)(HTK_ROUND_U64(Charger.m_MeterPRO380.m_AE_Lx_Total[i] * 100) * 100);
//round off to 4 decimal place
//i.g. 0.53 (float: 0.52999..) => 52.999.. => 53 => 5300 (0.0001 kWh) => 0.53 kWh
#ifdef RECODE_METER_PRO380
((uint64_t)(HTK_ROUND_U64(Charger.m_pPRO380->m_Lx_Total_active_energy[i].m_Val * 10000)));
#else
(uint64_t)(HTK_ROUND_U64(Charger.m_MeterPRO380.m_AE_Lx_Total[i] * 10000));
#endif
}
if (Charger.m_b3PhaseModel)
{
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total =
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 +
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 +
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3;
}
else
{
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total =
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1;
}
}
else //Use Meter IC
{
static double EngPlus[AC_PHASE_NUM_MAX] = { 0 };
static double Eng[AC_PHASE_NUM_MAX] = { 0 };
for (uint8_t i = 0; i < AC_PHASE_NUM_MAX; i++)
{
#ifdef FUNC_METER_IC_VARIABLE_PARAM
EngPlus[i] = EngPlusRaw[i] * MeterIC_KE;
#else
EngPlus[i] = EngPlusRaw[i] * KE;
#endif
EngPlusRaw[i] = 0;
#ifdef FUNC_METER_IC_POWER_FADEOUT
//Energy is calculated only when the current is greater than 0.5A and within METER_IC_POWER_FADEOUT_TIME
double PlusVal = (HTK_GET_VAL(HTK_IsInTime(ValidCurrTick, METER_IC_POWER_FADEOUT_TIME), HTK_GET_VAL_MAX(EngPlus[i], 0), 0) * 10); //Unit: 0.1 Wh
#else
//Energy is calculated only when the current is greater than 0.5A
double PlusVal = (HTK_GET_VAL(Curr[i] > METER_IC_POWER_CONSUMPTION_MIN_CURR, HTK_GET_VAL_MAX(EngPlus[i], 0), 0) * 10); //Unit: 0.1 Wh
#endif
Eng[i] += PlusVal;
#ifdef DEBUG_METER_IC
DEBUG_INFO("L%d_WATTHR(Wh): %f\r\n", i + 1, EngPlus[i]);
DEBUG_INFO("L%d += %f (%f) [%llu, %.4f kWh]\r\n", i + 1, PlusVal, Eng[i],
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Lx[i],
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Lx[i] * 0.0001);
#endif
}
#ifdef DEBUG_METER_IC
double EngTotal = (Eng[0] + Eng[1] + Eng[2]);
DEBUG_INFO("#Total Energy = %f [%llu, %.4f kWh]\r\n", EngTotal, Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total,
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total * 0.0001);
#endif
uint32_t EngIntPart[AC_PHASE_NUM_MAX] = { (uint32_t)Eng[0], (uint32_t)Eng[1], (uint32_t)Eng[2] };
if (EngIntPart[0] != 0 || EngIntPart[1] != 0 || EngIntPart[2] != 0)
{
uint32_t IntPart = 0; //Storage INTEGER part and keep the DECIMAL part
for (uint8_t i = 0; i < AC_PHASE_NUM_MAX; i++)
{
IntPart = EngIntPart[i];
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Lx[i] += IntPart;
Eng[i] -= IntPart;
#ifdef DEBUG_METER_IC
DEBUG_INFO("#PowerConsumptionCumulative_L%d = %llu (%d Added)\r\n", i + 1, Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Lx[i], IntPart);
#endif
}
if (Charger.m_b3PhaseModel)
{
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total =
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1 +
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L2 +
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L3;
}
else
{
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total =
Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_L1;
}
#ifdef DEBUG_METER_IC
DEBUG_INFO("#Power_Consumption_Cumulative = %llu\r\n", Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total);
#endif
}
}
//if(++updateMemReq >= METER_IC_POWER_CONSUMPTION_SAVE_MAX_COUNT)
if(++(*pUpdateMemReq) >= METER_IC_POWER_CONSUMPTION_SAVE_MAX_COUNT)
{
//updateMemReq = 0;
*pUpdateMemReq = 0;
static uint64_t PreSaveEnergy = 0;
if (PreSaveEnergy != Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total)
{
PreSaveEnergy = Charger.memory.EVSE_Config.data.item.PowerConsumptionCumulative_Total;
#ifdef DEBUG_METER_IC
DEBUG_INFO("#SAVE POWER CONSUMPTION DATA TO FLASH\r\n");
#endif
Charger.memory.EVSE_Config.op_bits.update = ON;
}
}
}
#endif //FUNC_POWER_CONSUMPTION_BY_METER_IC
}
#endif //FUNC_METER_IC_ADE7858A
}
void StartMeterIcTask(void const * argument)
{
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
IdleUntilReadAllMemory();
#endif
#ifdef FUNC_METER_IC_ADE7858A
while (Charger.ModelReadisOK != PASS )
{
osDelay(100);
}
MeterIC_InitLoop(METER_IC_INIT_RETRY_NUM_MAX);
timerEnable(TIMER_IDX_METER_IC_POLLING, METER_IC_TIMER_IDX_METER_POLLING_SPEC);
#ifdef FUNC_POWER_CONSUMPTION_BY_METER_IC
timerEnable(TIMER_IDX_POWER, METER_IC_TIMER_IDX_POWER_TIMEOUT_SPEC);
//uint8_t updateMemReq = 0;
uint16_t updateMemReq = 0;
#endif
#endif //FUNC_METER_IC_ADE7858A
#ifdef FUNC_TMP100
if (Charger.m_bUseTMP100)
{
TMP100_Init();
}
#endif
while (1)
{
#ifdef FUNC_RESET_DATA_AFTER_WRITE_NEW_MODELNAME
if (Charger.m_bTrigToRefreshMeterIcCaliVal)
{
Charger.m_bTrigToRefreshMeterIcCaliVal = HTK_FALSE;
MeterIC_WriteCaliValsFromFlash(HTK_TRUE, HTK_TRUE);
osDelay(1);
}
#endif
MeterIC_Proc(&updateMemReq);
#ifdef FUNC_TMP100
if (Charger.m_bUseTMP100)
{
static u8 c = 0;
c++;
if (c >= 10)
{
c = 0;
TMP100_Proc();
osDelay(10);
}
}
#endif //FUNC_TMP100
osDelay(1);
}
}
#endif //RECODE_FUNC_METER_IC_TASK
#ifdef MODIFY_IMCP
void UpdateCheckSum(uint8_t *Buf, uint16_t Len) //Len: Total package length
{
uint16_t DataLen = Len - (IMCP_FM_HEAD_LEN + IMCP_FM_TAIL_LEN);
uint8_t CheckSum = 0;
//Update DataLen
HTK_U16(Buf[IMCP_FM_DATALEN_LSB_IDX]) = DataLen;
//Update CheckSum
for (uint16_t i = 0; i < DataLen; i++)
{
CheckSum ^= Buf[IMCP_FM_DATA_BEG_IDX + i];
}
Buf[Len - 1] = CheckSum;
}
#ifdef FUNC_RS485_SLAVE
uint8_t isValidCheckSum_IAP(uint8_t *RxBuf)
{
uint8_t result = OFF;
uint8_t chksum = 0x00;
if (
(RxBuf[IMCP_FM_FRAMEID_IDX] == PROTOCOL_HEAD) &&
(
(RxBuf[IMCP_FM_DSTADDR_IDX] == PROTOCOL_ADDR)
|| (RxBuf[IMCP_FM_DSTADDR_IDX] == PROTOCOL_ADDR_AC_MAINBOARD)
|| (RxBuf[IMCP_FM_DSTADDR_IDX] == PROTOCOL_ADDR_BROADCAST)
)
)
{
uint16_t nCheckSumIdx = IMCP_FM_DATA_BEG_IDX + HTK_U16(RxBuf[IMCP_FM_DATALEN_LSB_IDX]);
for(uint16_t i = IMCP_FM_DATA_BEG_IDX; i < nCheckSumIdx; i++)
{
chksum ^= RxBuf[i];
}
if(chksum == RxBuf[nCheckSumIdx])
result = ON;
}
return result;
}
#else //FUNC_RS485_SLAVE
uint8_t isValidCheckSum_IAP(void)
{
uint8_t result = OFF;
uint8_t chksum = 0x00;
if (
(UART_IAP_rx_buffer[IMCP_FM_FRAMEID_IDX] == PROTOCOL_HEAD) &&
(
(UART_IAP_rx_buffer[IMCP_FM_DSTADDR_IDX] == PROTOCOL_ADDR)
|| (UART_IAP_rx_buffer[IMCP_FM_DSTADDR_IDX] == PROTOCOL_ADDR_BROADCAST)
)
)
{
uint16_t nCheckSumIdx = IMCP_FM_DATA_BEG_IDX + HTK_U16(UART_IAP_rx_buffer[IMCP_FM_DATALEN_LSB_IDX]);
for(uint16_t i = IMCP_FM_DATA_BEG_IDX; i < nCheckSumIdx; i++)
{
chksum ^= UART_IAP_rx_buffer[i];
}
if(chksum == UART_IAP_rx_buffer[nCheckSumIdx])
result = ON;
}
return result;
}
#endif //FUNC_RS485_SLAVE
#else //MODIFY_IMCP
uint8_t isValidCheckSum_IAP(void)
{
uint8_t result = OFF;
uint8_t chksum = 0x00;
if((UART_IAP_rx_buffer[0] == PROTOCOL_HEAD) &&
((UART_IAP_rx_buffer[2] == PROTOCOL_ADDR) | (UART_IAP_rx_buffer[2] == PROTOCOL_ADDR_BROADCAST)))
{
for(int idx=0;idx<(UART_IAP_rx_buffer[4] | (UART_IAP_rx_buffer[5]<<8));idx++)
{
chksum ^= UART_IAP_rx_buffer[6+ idx];
}
if(chksum == UART_IAP_rx_buffer[6+(UART_IAP_rx_buffer[4] | (UART_IAP_rx_buffer[5]<<8))])
result = ON;
}
return result;
}
#endif //MODIFY_IMCP
//-------------------------------------------------------------------------------------------------
uint8_t isValidCheckSum_BLE(void)
{
uint8_t result = OFF;
uint8_t chksum = 0x00;
if(((UART_BLE_rx_buffer[1] | (UART_BLE_rx_buffer[0]<<8))-1) < UART_BUFFER_SIZE)
{
for(int idx=2;idx<((UART_BLE_rx_buffer[1] | (UART_BLE_rx_buffer[0]<<8))-1);idx++)
{
chksum ^= UART_BLE_rx_buffer[idx];
}
if(chksum == UART_BLE_rx_buffer[(UART_BLE_rx_buffer[1] | (UART_BLE_rx_buffer[0]<<8))-1])
result = ON;
}
return result;
}
//-------------------------------------------------------------------------------------------------
uint8_t isValidCheckSum_WIFI(void)
{
uint8_t result = OFF;
uint8_t chksum = 0x00;
if(((UART_WIFI_rx_buffer[1] | (UART_WIFI_rx_buffer[0]<<8))-1) < UART_BUFFER_SIZE)
{
for(int idx=2;idx<((UART_WIFI_rx_buffer[1] | (UART_WIFI_rx_buffer[0]<<8))-1);idx++)
{
chksum ^= UART_WIFI_rx_buffer[idx];
}
if(chksum == UART_WIFI_rx_buffer[(UART_WIFI_rx_buffer[1] | (UART_WIFI_rx_buffer[0]<<8))-1])
result = ON;
}
return result;
}
//-------------------------------------------------------------------------------------------------
#ifdef FUNC_DEBUG_MSG_SET_CHARGER_MODE
char* getModeName(uint8_t mode);
#endif
void setChargerMode(uint8_t mode)
{
#ifdef FUNC_DEBUG_MSG_SET_CHARGER_MODE
XP("#SET CHARGER MODE: [%s] >>> [%s]\r\n", getModeName(Charger.Mode_Previous), getModeName(mode));
#endif
Charger.Mode_Previous = Charger.Mode;
Charger.Mode = mode;
}
//-------------------------------------------------------------------------------------------------
char* getModeName(uint8_t mode)
{
switch(mode)
{
case MODE_INITIAL:
return "INITIAL";
case MODE_IDLE:
return "IDLE";
case MODE_HANDSHAKE:
return "HANDSHAKING";
case MODE_CHARGING:
return "CHARGING";
case MODE_STOP:
return "STOP";
case MODE_ALARM:
return "ALARM";
case MODE_MAINTAIN:
return "MAINTAIN";
case MODE_DEBUG:
return "DEBUG";
default:
return "UNKNOW";
}
}
//-------------------------------------------------------------------------------------------------
uint8_t isModeChange(void)
{
uint8_t result = NO;
if(!isMode(Charger.Mode_Previous))
{
DEBUG_INFO("#MODE from %s to %s\r\n", getModeName(Charger.Mode_Previous), getModeName(Charger.Mode));
result |= YES;
if(Charger.Mode == MODE_ALARM)
{
Charger.Mode_Before_Alarm = Charger.Mode_Previous;
}
Charger.Mode_Previous = Charger.Mode;
}
return result;
}
//-------------------------------------------------------------------------------------------------
uint8_t isMode(uint8_t mode)
{
return ((Charger.Mode == mode)? YES : NO);
}
//-------------------------------------------------------------------------------------------------
uint8_t rfidCheckSumCal(uint8_t *data, uint8_t length)
{
uint8_t result= 0x00;
for(uint8_t idx=0;idx2000)
{
//result = FAIL;
if(retry_cnt < 1 )
{
HAL_Delay(270);
HAL_GPIO_WritePin(OUT_Leak_Test_GPIO_Port , OUT_Leak_Test_Pin , GPIO_PIN_RESET);
HAL_Delay(50); //40ms~1.2sec
HAL_GPIO_WritePin(OUT_Leak_Test_GPIO_Port , OUT_Leak_Test_Pin , GPIO_PIN_SET);
//HAL_Delay(40); //36ms
retry_cnt ++ ;
time_out_count = 0 ;
}
else
{
DEBUG_INFO("Leak module self test Fail in timeout.\r\n");
result = FAIL;
break;
}
}
else
{
time_out_count++;
HAL_Delay(1);
}
}
}
}
else // Charger.CCID_Module_Type is CCID_MODULE_CORMEX
{
SPWM_Switch(ON);
HAL_Delay(1000);
XP("#[SPWM] adc_value.ADC2_IN6_GF.value = %d\r\n",adc_value.ADC2_IN6_GF.value);
if ((adc_value.ADC2_IN6_GF.value<3000)&&(adc_value.ADC2_IN6_GF.value>2000)) //25mA
{
DEBUG_INFO("#Test_LeakModule(): OK\r\n");
result = PASS ;
}
else
{
DEBUG_INFO("Test_LeakModule(): [NG]\r\n");
//DEBUG_INFO("adc_value.ADC2_IN6_GF.value = %d\n\r",adc_value.ADC2_IN6_GF.value);
result = FAIL;
}
SPWM_Switch(OFF);
}
#endif //CCID_PROTECT
return result;
}
//-------------------------------------------------------------------------------------------------
uint8_t Valid_RFID_SN(void)
{
/*
TODO: Validation logic check
*/
uint8_t result = FAIL;
uint32_t crc_result;
uint8_t sn_len;
uint8_t *buf;
if(Charger.rfid.snType == RFID_SN_TYPE_4BYTE)
{
// SN length: 4
sn_len = 4;
}
else if(Charger.rfid.snType == RFID_SN_TYPE_7BYTE)
{
// SN length: 7
sn_len = 7;
}
else
{
// SN length: 10
sn_len = 10;
}
buf = malloc(25 + sn_len);
memcpy(buf, Charger.memory.EVSE_Config.data.item.System_ID, 25);
memcpy(&buf[25], Charger.rfid.data_Sn, sn_len);
crc_result = crc32(buf, 25 + sn_len);
if(((Charger.rfid.data_Block[0] << 8) | (Charger.rfid.data_Block[1] << 0) | (Charger.rfid.data_Block[2] << 24) | (Charger.rfid.data_Block[3] << 16)) == ~crc_result)
{
result = PASS;
}
free(buf);
return result;
}
//-------------------------------------------------------------------------------------------------
void recordAlarmHis(void)
{
uint8_t isSuccess = FAIL;
// Check record alarm request, if alarm code bit different with previous
for(uint8_t errIdx=0;errIdx<32;errIdx++)
{
if(((Charger.Alarm_Code>>errIdx)&0x01) != ((Charger.Alarm_Code_Previous>>errIdx)&0x01))
{
// Find empty memory space
for(uint16_t idx=0;idx<(W25Q16FV_BLOCK_SIZE>>4);idx++)
{
if((Charger.memory.hisAlarm.data.item[idx].alarmCode == 0xffffffff) &&
(Charger.memory.hisAlarm.data.item[idx].mode == 0xff))
{
isSuccess = PASS;
Charger.memory.hisAlarm.data.item[idx].DateTime.year = Charger.memory.EVSE_Config.data.item.SystemDateTime.year;
Charger.memory.hisAlarm.data.item[idx].DateTime.month = Charger.memory.EVSE_Config.data.item.SystemDateTime.month;
Charger.memory.hisAlarm.data.item[idx].DateTime.day = Charger.memory.EVSE_Config.data.item.SystemDateTime.day;
Charger.memory.hisAlarm.data.item[idx].DateTime.hour = Charger.memory.EVSE_Config.data.item.SystemDateTime.hour;
Charger.memory.hisAlarm.data.item[idx].DateTime.min = Charger.memory.EVSE_Config.data.item.SystemDateTime.min;
Charger.memory.hisAlarm.data.item[idx].DateTime.sec = Charger.memory.EVSE_Config.data.item.SystemDateTime.sec;
Charger.memory.hisAlarm.data.item[idx].mode = Charger.Mode;
if((Charger.Alarm_Code>>errIdx)&0x01)
{
// Record alarm occur
Charger.memory.hisAlarm.data.item[idx].alarmCode = alarm_record_code[errIdx];
Charger.memory.hisAlarm.data.item[idx].isRecover = OFF;
Charger.Alarm_Code_Previous |= (0x00000001<>4)-1))
{
osDelay(500);
Charger.memory.hisAlarm.op_bits.backup = ON;
osDelay(500);
}
break;
}
}
// If there is not any free space
if(!isSuccess)
{
osDelay(500);
Charger.memory.hisAlarm.op_bits.backup = ON;
osDelay(500);
}
}
}
}
//-------------------------------------------------------------------------------------------------
#ifdef FUNC_METER_IC_HISTORY
uint8_t recordMeterICHis(MeterIC_CaliValType Type, int32_t Val)
{
uint8_t isSuccess = FAIL;
{
for(uint16_t idx=0;idx>6);idx++)
{
if((Charger.memory.hisCharging.data.item[idx].Duration == 0xffffffff) &&
(Charger.memory.hisCharging.data.item[idx].powerSum == 0xffff) &&
(Charger.memory.hisCharging.data.item[idx].stopStatusCode == 0xffffffff) )
{
isSuccess = PASS;
Charger.memory.hisCharging.data.item[idx].DateTime.year = Charger.memory.coldLoadPickUp.data.item.DateTime.year;
Charger.memory.hisCharging.data.item[idx].DateTime.month = Charger.memory.coldLoadPickUp.data.item.DateTime.month;
Charger.memory.hisCharging.data.item[idx].DateTime.day = Charger.memory.coldLoadPickUp.data.item.DateTime.day;
Charger.memory.hisCharging.data.item[idx].DateTime.hour = Charger.memory.coldLoadPickUp.data.item.DateTime.hour;
Charger.memory.hisCharging.data.item[idx].DateTime.min = Charger.memory.coldLoadPickUp.data.item.DateTime.min;
Charger.memory.hisCharging.data.item[idx].DateTime.sec = Charger.memory.coldLoadPickUp.data.item.DateTime.sec;
Charger.memory.hisCharging.data.item[idx].Duration = Charger.memory.coldLoadPickUp.data.item.Duration;
sprintf(Charger.memory.hisCharging.data.item[idx].PlugType, EVSE_CONNECTOR_TYPE);
Charger.memory.hisCharging.data.item[idx].powerSum = Charger.memory.coldLoadPickUp.data.item.powerSum;
Charger.memory.hisCharging.data.item[idx].startType = Charger.memory.coldLoadPickUp.data.item.startType;
Charger.memory.hisCharging.data.item[idx].stopStatusCode = statusCode;
memcpy(Charger.memory.hisCharging.data.item[idx].user, Charger.rfid.currentCard, 16);
Charger.memory.hisCharging.op_bits.update = ON;
// If speace is last item, move data to backup area
//if(idx == ((W25Q16FV_BLOCK_SIZE>>4)-1)) //NG
if(idx == ((W25Q16FV_BLOCK_SIZE>>6)-1))
{
osDelay(500);
Charger.memory.hisCharging.op_bits.backup = ON;
}
break;
}
}
}
else
{
for(uint16_t idx=0;idx<(W25Q16FV_BLOCK_SIZE>>6);idx++)
{
if((Charger.memory.hisCharging.data.item[idx].Duration == 0xffffffff) &&
(Charger.memory.hisCharging.data.item[idx].powerSum == 0xffff) &&
(Charger.memory.hisCharging.data.item[idx].stopStatusCode == 0xffffffff) )
{
isSuccess = PASS;
Charger.memory.hisCharging.data.item[idx].DateTime.year = Charger.cycle_info.startDateTime.year;
Charger.memory.hisCharging.data.item[idx].DateTime.month = Charger.cycle_info.startDateTime.month;
Charger.memory.hisCharging.data.item[idx].DateTime.day = Charger.cycle_info.startDateTime.day;
Charger.memory.hisCharging.data.item[idx].DateTime.hour = Charger.cycle_info.startDateTime.hour;
Charger.memory.hisCharging.data.item[idx].DateTime.min = Charger.cycle_info.startDateTime.min;
Charger.memory.hisCharging.data.item[idx].DateTime.sec = Charger.cycle_info.startDateTime.sec;
Charger.memory.hisCharging.data.item[idx].Duration = Charger.cycle_info.Duration;
sprintf(Charger.memory.hisCharging.data.item[idx].PlugType, EVSE_CONNECTOR_TYPE);
Charger.memory.hisCharging.data.item[idx].powerSum = Charger.cycle_info.Power_Consumption;
Charger.memory.hisCharging.data.item[idx].startType = Charger.cycle_info.StartType;
Charger.memory.hisCharging.data.item[idx].stopStatusCode = statusCode;
memcpy(Charger.memory.hisCharging.data.item[idx].user, Charger.rfid.currentCard, 16);
Charger.memory.hisCharging.op_bits.update = ON;
// If speace is last item, move data to backup area
//if(idx == ((W25Q16FV_BLOCK_SIZE>>4)-1)) //NG
if(idx == ((W25Q16FV_BLOCK_SIZE>>6)-1))
{
osDelay(500);
Charger.memory.hisCharging.op_bits.backup = ON;
}
break;
}
}
}
// If there is not any free space
if(!isSuccess)
{
osDelay(500);
Charger.memory.hisCharging.op_bits.backup = ON;
}
return isSuccess;
}
#endif //FUNC_METER_IC_HISTORY
//-------------------------------------------------------------------------------------------------
void setLedMotion(uint8_t action)
{//ssetled
//standard
#ifdef TEST_FOR_ENERGY_STAR
if (action == LED_ACTION_IDLE_BACKEND_CONNECTED_SLEEP ||
action == LED_ACTION_IDLE_BACKEND_DISCONNECTED_SLEEP
)
{
#ifdef FUNC_AW48_NO_SLEEP_MODE_LED
if (Charger.m_bModelNameAW48_1P)
{
Charger.m_bLedSleepModeForceMinBrightness = 0;
}
else
{
Charger.m_bLedSleepModeForceMinBrightness = 1;
}
#else
Charger.m_bLedSleepModeForceMinBrightness = 1;
#endif
}
else
{
Charger.m_bLedSleepModeForceMinBrightness = 0;
}
#endif
switch(action)
{
case LED_ACTION_INIT:
Charger.led_R.motion = LED_MOTION_ON;
Charger.led_G.motion = LED_MOTION_ON;
Charger.led_B.motion = LED_MOTION_ON;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(1000, 1000, 1000, 0);
break;
case LED_ACTION_IDLE:
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_ON;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 1000, 0, 0);
break;
#ifdef MODIFY_LED_STATUS_202108
case LED_ACTION_IDLE_BACKEND_CONNECTED:
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_ON;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 1000, 0, 0);
break;
case LED_ACTION_IDLE_BACKEND_CONNECTED_SLEEP:
#ifdef MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
if (Charger.m_bModelNameAW48_1P)
{
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_ON;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 1000, 0, 0);
}
else
{
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_BREATHE;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 1000, 0, 0);
#ifdef MODIFY_BREATHE_LED
breatheTimeSet(BREATHE_LED_UP_SPEED, BREATHE_LED_DN_SPEED, 0, 1000, 0, 0 );
#endif
}
#else //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_BREATHE;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 1000, 0, 0);
#ifdef MODIFY_BREATHE_LED
breatheTimeSet(BREATHE_LED_UP_SPEED, BREATHE_LED_DN_SPEED, 0, 1000, 0, 0 );
#endif
#endif //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
break;
case LED_ACTION_IDLE_BACKEND_DISCONNECTED:
#ifdef MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
if (Charger.m_bModelNameAW48_1P)
{
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_ON;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 1000, 0, 0);
}
else
{
Charger.led_R.motion = LED_MOTION_ON;
Charger.led_G.motion = LED_MOTION_ON;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#else
LedOnRGBSet(1000, 1000, 0, 0);
#endif
}
#else //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
Charger.led_R.motion = LED_MOTION_ON;
Charger.led_G.motion = LED_MOTION_ON;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#else
LedOnRGBSet(1000, 1000, 0, 0);
#endif
#endif //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
break;
case LED_ACTION_IDLE_BACKEND_DISCONNECTED_SLEEP:
#ifdef MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
if (Charger.m_bModelNameAW48_1P)
{
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_ON;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 1000, 0, 0);
}
else
{
Charger.led_R.motion = LED_MOTION_BREATHE;
Charger.led_G.motion = LED_MOTION_BREATHE;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#ifdef MODIFY_BREATHE_LED
breatheTimeSet(BREATHE_LED_UP_SPEED, BREATHE_LED_DN_SPEED, LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0 );
#endif
#else //MODIFY_LED_YELLOW_PARAMETER
LedOnRGBSet(1000, 1000, 0, 0);
#endif //MODIFY_LED_YELLOW_PARAMETER
}
#else //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
Charger.led_R.motion = LED_MOTION_BREATHE;
Charger.led_G.motion = LED_MOTION_BREATHE;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#ifdef MODIFY_BREATHE_LED
breatheTimeSet(BREATHE_LED_UP_SPEED, BREATHE_LED_DN_SPEED, LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0 );
#endif
#else //MODIFY_LED_YELLOW_PARAMETER
LedOnRGBSet(1000, 1000, 0, 0);
#endif //MODIFY_LED_YELLOW_PARAMETER
#endif //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
break;
case LED_ACTION_RESERVATION_MODE:
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_BLINK;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 1000, 0, 0);
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
break;
#endif //MODIFY_LED_STATUS_202108
case LED_ACTION_AUTHED:
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_OFF;
Charger.led_B.motion = LED_MOTION_ON;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 0, 1000, 0);
break;
case LED_ACTION_CONNECTED:
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_OFF;
Charger.led_B.motion = LED_MOTION_ON;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 0, 1000, 0);
break;
case LED_ACTION_CHARGING:
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_OFF;
Charger.led_B.motion = LED_MOTION_BLINK;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 0, 1000, 0);
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
break;
case LED_ACTION_STOP:
#ifdef FUNC_MODIFY_AW48_LED_ACTION_TERMINATED_COMPLETE
if (Charger.m_bModelNameAW48_1P)
{
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_BLINK;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 1000, 0, 0);
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
}
else
{
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_OFF;
Charger.led_B.motion = LED_MOTION_ON;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 0, 1000, 0);
}
#else
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_OFF;
Charger.led_B.motion = LED_MOTION_ON;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 0, 1000, 0);
#endif
break;
case LED_ACTION_ALARM:
Charger.led_R.motion = LED_MOTION_BLINK;
Charger.led_G.motion = LED_MOTION_OFF;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(1000, 0, 0, 0);
//set alarm led blink duty
if(Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU){
Charger.Alarm_LED = Charger.Alarm_Code;
}else{
Charger.Alarm_LED = Charger.am3352.LedAlarmState;
}
if(Charger.Alarm_LED & ALARM_CP_ERROR)
blinkerTimeSet(BLINKER_IDX_LED, 500 , 500, 0, 1);
if((Charger.Alarm_LED & ALARM_L1_OVER_VOLTAGE) || (Charger.Alarm_LED & ALARM_L2_OVER_VOLTAGE) || (Charger.Alarm_LED & ALARM_L3_OVER_VOLTAGE))
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 1);
if((Charger.Alarm_LED & ALARM_L1_UNDER_VOLTAGE) || (Charger.Alarm_LED & ALARM_L2_UNDER_VOLTAGE) || (Charger.Alarm_LED & ALARM_L3_UNDER_VOLTAGE))
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 2);
if((Charger.Alarm_LED & ALARM_L1_OVER_CURRENT) || (Charger.Alarm_LED & ALARM_L2_OVER_CURRENT) || (Charger.Alarm_LED & ALARM_L3_OVER_CURRENT))
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 3);
if(Charger.Alarm_LED & ALARM_OVER_TEMPERATURE)
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 4);
if(Charger.Alarm_LED & ALARM_CURRENT_LEAK_AC)
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 5);
if(Charger.Alarm_LED & ALARM_CURRENT_LEAK_DC)
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 5);
if(Charger.Alarm_LED & ALARM_GROUND_FAIL)
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 6);
if(Charger.Alarm_LED & ALARM_HANDSHAKE_TIMEOUT)
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
if(Charger.Alarm_LED & ALARM_EMERGENCY_STOP)
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 3000, 7);
if(Charger.Alarm_LED & ALARM_ROTATORY_SWITCH_FAULT)
{
#ifdef FUNC_AW48_EXT_LED_BLINK_PERIOD_MORE_THAN_200MS
if (Charger.m_bModelNameAW48_1P)
{
blinkerTimeSet(BLINKER_IDX_LED, AW48_EXTLED_BLINK_PERIOD, AW48_EXTLED_BLINK_PERIOD, 0, 1);
}
else
{
blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
}
#else
blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
#endif
}
if(Charger.Alarm_LED & ALARM_METER_TIMEOUT)
blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
#ifdef MODIFY_LED_ALARM_LATCH
//self test error
if ((Charger.Alarm_Code & ALARM_MCU_TESTFAIL) ||
(Charger.Alarm_Code & ALARM_RELAY_STATUS) ||
(Charger.Alarm_Code & ALARM_RELAY_DRIVE_FUALT ) ||
(Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL))
{
Charger.led_R.motion = LED_MOTION_ON;
Charger.led_G.motion = LED_MOTION_OFF;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(1000, 0, 0, 0);
}
#else //MODIFY_LED_ALARM_LATCH
//OCP Latch
if ((Charger.counter.L1_OC.isLatch == ON) || (Charger.counter.L2_OC.isLatch == ON) || (Charger.counter.L3_OC.isLatch == ON))
{
Charger.led_R.motion = LED_MOTION_ON ;
Charger.led_B.motion = LED_MOTION_ON ;
LedOnRGBSet(1000, 0, 1000, 0);
}
//CCID Latch
if (Charger.counter.LEAK.isLatch == ON)
{
Charger.led_R.motion = LED_MOTION_ON ;
Charger.led_G.motion = LED_MOTION_ON ;
#ifdef MODIFY_LED_YELLOW_PARAMETER
LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#else
LedOnRGBSet(1000, 1000, 0, 0);
#endif
}
//OTP
if (Charger.counter.OT.isLatch == ON)
{
Charger.led_R.motion = LED_MOTION_ON;
Charger.led_G.motion = LED_MOTION_BLINK;
Charger.led_B.motion = LED_MOTION_BLINK;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(1000, 1000, 1000, 0);
blinkerTimeSet(BLINKER_IDX_LED, 500 , 500, 0, 1);
}
//self test error
if ((Charger.Alarm_Code & ALARM_MCU_TESTFAIL) ||
(Charger.Alarm_Code & ALARM_RELAY_STATUS) ||
(Charger.Alarm_Code & ALARM_RELAY_DRIVE_FUALT ) ||
(Charger.Alarm_Code & ALARM_LEAK_MODULE_FAIL))
{
Charger.led_R.motion = LED_MOTION_ON;
Charger.led_G.motion = LED_MOTION_OFF;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(1000, 0, 0, 0);
}
#endif //MODIFY_LED_ALARM_LATCH
break;
case LED_ACTION_MAINTAIN:
#ifdef MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
if (Charger.m_bModelNameAW48_1P)
{
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_BLINK;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 1000, 0, 0);
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
}
else
{
#ifdef MODIFY_LED_STATUS_202108
//Yellow blink
Charger.led_R.motion = LED_MOTION_BLINK;
Charger.led_G.motion = LED_MOTION_BLINK;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#else
LedOnRGBSet(1000, 1000, 0, 0);
#endif
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
#else
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_BLINK;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 1000, 0, 0);
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
#endif
}
#else //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
#ifdef MODIFY_LED_STATUS_202108
//Yellow blink
Charger.led_R.motion = LED_MOTION_BLINK;
Charger.led_G.motion = LED_MOTION_BLINK;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#else
LedOnRGBSet(1000, 1000, 0, 0);
#endif
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
#else
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_BLINK;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 1000, 0, 0);
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
#endif
#endif //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
break;
case LED_ACTION_RFID_PASS:
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_BLINK;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 1000, 0, 0);
#ifdef FUNC_AW48_EXT_LED_BLINK_PERIOD_MORE_THAN_200MS
if (Charger.m_bModelNameAW48_1P)
{
blinkerTimeSet(BLINKER_IDX_LED, AW48_EXTLED_BLINK_PERIOD, AW48_EXTLED_BLINK_PERIOD, 0, 1);
}
else
{
blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
}
#else
blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
#endif
break;
case LED_ACTION_RFID_FAIL:
Charger.led_R.motion = LED_MOTION_BLINK;
Charger.led_G.motion = LED_MOTION_OFF;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(1000, 0, 0, 0);
#ifdef FUNC_AW48_EXT_LED_BLINK_PERIOD_MORE_THAN_200MS
if (Charger.m_bModelNameAW48_1P)
{
blinkerTimeSet(BLINKER_IDX_LED, AW48_EXTLED_BLINK_PERIOD, AW48_EXTLED_BLINK_PERIOD, 0, 1);
}
else
{
blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
}
#else
blinkerTimeSet(BLINKER_IDX_LED, 200, 200, 0, 1);
#endif
break;
case LED_ACTION_DEBUG:
Charger.led_R.motion = LED_MOTION_BLINK;
Charger.led_G.motion = LED_MOTION_BLINK;
Charger.led_B.motion = LED_MOTION_BLINK;
Charger.led_W.motion = LED_MOTION_BLINK;
LedOnRGBSet(1000, 1000, 1000, 1000);
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
break;
case LED_ACTION_ALL_OFF:
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_OFF;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 0, 0, 0);
break ;
case LED_ACTION_HANDSHAKE_FAIL:
Charger.led_R.motion = LED_MOTION_BLINK;
Charger.led_G.motion = LED_MOTION_OFF;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(1000, 0, 0, 0);
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
break;
case LED_ACTION_INTERNET_DISCONNECT:
#ifdef MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
if (Charger.m_bModelNameAW48_1P)
{
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_ON;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 1000, 0, 0);
}
else
{
Charger.led_R.motion = LED_MOTION_ON;
Charger.led_G.motion = LED_MOTION_ON;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#else
LedOnRGBSet(1000, 1000, 0, 0);
#endif
}
#else //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
Charger.led_R.motion = LED_MOTION_ON;
Charger.led_G.motion = LED_MOTION_ON;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
#ifdef MODIFY_LED_YELLOW_PARAMETER
LedOnRGBSet(LED_YELLOW_R_VAL, LED_YELLOW_G_VAL, 0, 0);
#else
LedOnRGBSet(1000, 1000, 0, 0);
#endif
#endif //MODIFY_AW48_LED_NOT_USE_YELLOW_AND_BREATHE
break;
case LED_ACTION_RESTORE_SETTING:
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_OFF;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_BLINK;
LedOnRGBSet(0, 0, 0, 1000);
blinkerTimeSet(BLINKER_IDX_LED, 500, 500, 0, 1);
break;
#ifdef MODIFY_LED_STATUS_202108
#endif //MODIFY_LED_STATUS_202108
default :
Charger.led_R.motion = LED_MOTION_OFF;
Charger.led_G.motion = LED_MOTION_OFF;
Charger.led_B.motion = LED_MOTION_OFF;
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(0, 0, 0, 0);
break;
}
if((action != LED_ACTION_RFID_PASS) &&
(action != LED_ACTION_RFID_FAIL) &&
(action != LED_ACTION_BLE_CONNECT) &&
(action != LED_ACTION_BLE_DISABLE) &&
(action != LED_ACTION_HANDSHAKE_FAIL) &&
(action != LED_ACTION_RESTORE_SETTING))
{
Charger.Led_Mode = action;
}
}
//-------------------------------------------------------------------------------------------------
#ifdef FUNC_CUSTOMIZED_LED_MODE_FROM_CSU
void setLedMotion_User(uint8_t action, PLED_UserCfg p)
{
if (action != LED_ACTION_CUSTOMIZED_MODE || p == NULL)
return;
//Check data
Charger.m_bLedSleepModeForceMinBrightness = 0;
const u16 RGBMAX = 1000;
if (p->m_R > RGBMAX) p->m_R = RGBMAX;
if (p->m_G > RGBMAX) p->m_G = RGBMAX;
if (p->m_B > RGBMAX) p->m_B = RGBMAX;
if (p->m_Mode == LED_USER_MODE_SOLID)
{
Charger.led_R.motion = (p->m_R > 0 ? LED_MOTION_ON : LED_MOTION_OFF);
Charger.led_G.motion = (p->m_G > 0 ? LED_MOTION_ON : LED_MOTION_OFF);
Charger.led_B.motion = (p->m_B > 0 ? LED_MOTION_ON : LED_MOTION_OFF);
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(p->m_R, p->m_G, p->m_B, 0);
}
else if (p->m_Mode == LED_USER_MODE_BLINK)
{
Charger.led_R.motion = (p->m_R > 0 ? LED_MOTION_BLINK : LED_MOTION_OFF);
Charger.led_G.motion = (p->m_G > 0 ? LED_MOTION_BLINK : LED_MOTION_OFF);
Charger.led_B.motion = (p->m_B > 0 ? LED_MOTION_BLINK : LED_MOTION_OFF);
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(p->m_R, p->m_G, p->m_B, 0);
if (p->Blink.m_Count > HTK_U8_MAX) p->Blink.m_Count = HTK_U8_MAX;
blinkerTimeSet(BLINKER_IDX_LED, p->Blink.m_On_ms, p->Blink.m_Off_ms, p->Blink.m_Rest_ms, p->Blink.m_Count);
}
else if (p->m_Mode == LED_USER_MODE_BREATH)
{
Charger.led_R.motion = (p->m_R > 0 ? LED_MOTION_BREATHE : LED_MOTION_OFF);
Charger.led_G.motion = (p->m_G > 0 ? LED_MOTION_BREATHE : LED_MOTION_OFF);
Charger.led_B.motion = (p->m_B > 0 ? LED_MOTION_BREATHE : LED_MOTION_OFF);
Charger.led_W.motion = LED_MOTION_OFF;
LedOnRGBSet(p->m_R, p->m_G, p->m_B, 0);
breatheTimeSet(p->Breath.m_Up_ms, p->Breath.m_Down_ms, p->m_R, p->m_G, p->m_B, 0);
}
else
{
}
if (p->m_AutoRepeat)
Charger.Led_Mode = action;
}
#endif //FUNC_CUSTOMIZED_LED_MODE_FROM_CSU
//-------------------------------------------------------------------------------------------------
#ifdef FUNC_AW48_NET_LED
void setNetLedMotion(uint8_t action)
{
switch(action)
{
case NET_LED_ACTION_LTE_CONNECTING:
Charger.LedNet_G.motion = LED_MOTION_BLINK;
Charger.LedNet_B.motion = LED_MOTION_OFF;
blinkerTimeSet(BLINKER_IDX_LED_NET, 200, 800, 0, 1);
break;
case NET_LED_ACTION_LTE_CONNECTED:
Charger.LedNet_G.motion = LED_MOTION_ON;
Charger.LedNet_B.motion = LED_MOTION_OFF;
break;
case NET_LED_ACTION_WIFI_CONNECTING:
Charger.LedNet_G.motion = LED_MOTION_OFF;
Charger.LedNet_B.motion = LED_MOTION_BLINK;
blinkerTimeSet(BLINKER_IDX_LED_NET, 200, 800, 0, 1);
break;
case NET_LED_ACTION_WIFT_CONNECTED:
Charger.LedNet_G.motion = LED_MOTION_OFF;
Charger.LedNet_B.motion = LED_MOTION_ON;
break;
case NET_LED_ACTION_ETHERNET_CONNECTING:
Charger.LedNet_G.motion = LED_MOTION_OFF;
Charger.LedNet_B.motion = LED_MOTION_BLINK;
blinkerTimeSet(BLINKER_IDX_LED_NET, 200, 800, 0, 1);
break;
case NET_LED_ACTION_ETHERNET_CONNECTED:
Charger.LedNet_G.motion = LED_MOTION_OFF;
Charger.LedNet_B.motion = LED_MOTION_ON;
break;
case NET_LED_ACTION_ALL_CONNECTING:
Charger.am3352.NetLedActionSubState = NET_LED_ACTION_ETHERNET_CONNECTING_H;
break;
case NET_LED_ACTION_OFF:
Charger.LedNet_G.motion = LED_MOTION_OFF;
Charger.LedNet_B.motion = LED_MOTION_OFF;
break;
//(HIDE for NET_LED_ACTION_ALL_CONNECTING) ---------------
case NET_LED_ACTION_LTE_CONNECTING_H:
Charger.LedNet_G.motion = LED_MOTION_BLINK;
Charger.LedNet_B.motion = LED_MOTION_OFF;
blinkerTimeSet(BLINKER_IDX_LED_NET, 200, 800, 3000, 3);
break;
case NET_LED_ACTION_WIFI_CONNECTING_H:
Charger.LedNet_G.motion = LED_MOTION_OFF;
Charger.LedNet_B.motion = LED_MOTION_BLINK;
blinkerTimeSet(BLINKER_IDX_LED_NET, 200, 800, 3000, 3);
break;
case NET_LED_ACTION_ETHERNET_CONNECTING_H:
Charger.LedNet_G.motion = LED_MOTION_OFF;
Charger.LedNet_B.motion = LED_MOTION_BLINK;
blinkerTimeSet(BLINKER_IDX_LED_NET, 200, 800, 3000, 3);
break;
//---------------------------------------------------------
default:
Charger.LedNet_G.motion = LED_MOTION_OFF;
Charger.LedNet_B.motion = LED_MOTION_OFF;
break;
}
}
#endif //FUNC_AW48_NET_LED
//-------------------------------------------------------------------------------------------------
void HAL_ADC_LevelOutOfWindowCallback(ADC_HandleTypeDef* hadc)
{
#ifdef CCID_PROTECT
if (Charger.CCID_Module_Type == CCID_MODULE_CORMEX)
{
if(hadc->Instance == ADC2) //use watch dog to check ccid level
{
if (!Charger.isTestLeakModule)
{
if(Charger.counter.WatchDogLeak >= 5)
{
if(!(Charger.Alarm_Code & ALARM_CURRENT_LEAK_AC))
{
DEBUG_INFO("leak adc watch happen\r\n");
Charger.counter.LEAK.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_CURRENT_LEAK_AC;
timerEnable(TIMER_IDX_RETRY_LEAK_AC, ALARM_RETRY_INTERVAL_LEAK);
Charger.counter.LEAK.retry++ ;
Charger.Relay_Action = GPIO_RELAY_ACTION_OFF ;
RELAY1_SET_DRIV(0);
RELAY1_SET_HOLD(0);
RELAY2_SET_DRIV(0);
RELAY2_SET_HOLD(0);
Charger.counter.WatchDogLeak = 0 ;
}
}
else
{
Charger.counter.WatchDogLeak ++ ;
}
}
}
}
#endif //CCID_PROTECT
}
//-------------------------------------------------------------------------------------------------
void vApplicationStackOverflowHook( TaskHandle_t xTask, signed char *pcTaskName )
{
DEBUG_ERROR("Stack overflow: %s\r\n", pcTaskName);
osDelay(500);
}
//-------------------------------------------------------------------------------------------------
void getlastRecord(void)
{
#ifdef FUNC_METER_IC_HISTORY
for(uint16_t idx=0;idx>4);idx++) //NG
for(uint16_t idx=0;idx<(W25Q16FV_BLOCK_SIZE>>6);idx++)
{
if((Charger.memory.hisCharging.data.item[idx].Duration == 0xffffffff) &&
(Charger.memory.hisCharging.data.item[idx].powerSum == 0xffff) &&
(Charger.memory.hisCharging.data.item[idx].stopStatusCode == 0xffffffff) )
{
DEBUG_INFO("Charging record last index: %d\r\n", (idx));
break;
}
}
#endif //FUNC_METER_IC_HISTORY
//for(uint16_t idx=0;idx<(W25Q16FV_BLOCK_SIZE>>6);idx++) //NG
for(uint16_t idx=0;idx<(W25Q16FV_BLOCK_SIZE>>4);idx++)
{
if((Charger.memory.hisAlarm.data.item[idx].alarmCode == 0xffffffff) &&
(Charger.memory.hisAlarm.data.item[idx].mode == 0xff))
{
DEBUG_INFO("Alarm record last index: %d\r\n", (idx));
break;
}
}
}
//-------------------------------------------------------------------------------------------------
#ifdef FUNC_ROTARY_CURR_MAP
typedef struct _RotaryCurrItem
{
uint8_t m_nCurr; //(A)
uint8_t m_bTestMode: 1;
uint8_t m_bInvalidItem: 1;
uint8_t m_bSlaveMode: 1;
}
RotaryCurrItem, *PRotaryCurrItem;
#define ROTARY_CURR_ITEM_NUM (16)
#define AX48_DEF_CURR (48)
#define AX32_DEF_CURR (32)
#ifdef FUNC_AX80
#define AX80_DEF_CURR (80)
#endif
#ifdef FUNC_AT32
#define AT32_DEF_CURR (32)
#endif
#ifdef FUNC_AW48
#define AW48_DEF_CURR (48)
#endif
const RotaryCurrItem RotaryCurrMap_AX48[ROTARY_CURR_ITEM_NUM] =
{
{ AX48_DEF_CURR, 1, 0, 0 }, //0: Test Mode ************
{ 6, 0, 0, 0 }, //1: 6A 10%
{ 8, 0, 0, 0 }, //2: 8A 13.33%
{ 10, 0, 0, 0 }, //3: 10A 16.67%
{ 13, 0, 0, 0 }, //4: 13A 21.67%
{ 16, 0, 0, 0 }, //5: 16A 26.67%
{ 20, 0, 0, 0 }, //6: 20A 33.33%
{ 25, 0, 0, 0 }, //7: 25A 41.67%
{ 30, 0, 0, 0 }, //8: 30A 50.00%
{ 32, 0, 0, 0 }, //9: 32A 53.33%
{ 40, 0, 0, 0 }, //A: 40A 66.67%
{ AX48_DEF_CURR, 0, 0, 0 }, //B: 48A 80.00% (DEFAULT)
{ AX48_DEF_CURR, 0, 1, 0 }, //C: Reserved ************* (Invalid)
{ AX48_DEF_CURR, 0, 1, 0 }, //D: Reserved ************* (Invalid)
{ 80, 0, 1, 0 }, //E: 80A 96.00% ????? (Invalid)
{ AX48_DEF_CURR, 0, 0, 1 }, //F: Slave Mode ***********
};
#ifdef MODIFY_AX32_ROTATE_SWITCH_TABLE_20210915
const RotaryCurrItem RotaryCurrMap_AX32[ROTARY_CURR_ITEM_NUM] =
{
{ AX32_DEF_CURR, 1, 0, 0 }, //0: Test Mode ************
{ 6, 0, 0, 0 }, //1: 6A 10%
{ 8, 0, 0, 0 }, //2: 8A 13.33%
{ 10, 0, 0, 0 }, //3: 10A 16.67%
{ 13, 0, 0, 0 }, //4: 13A 21.67%
{ 16, 0, 0, 0 }, //5: 16A 26.67%
{ 20, 0, 0, 0 }, //6: 20A 33.33%
{ 25, 0, 0, 0 }, //7: 25A 41.67%
{ 30, 0, 0, 0 }, //8: 30A 50.00%
{ AX32_DEF_CURR, 0, 0, 0 }, //9: 32A 53.33% (DEFAULT)
{ AX32_DEF_CURR, 0, 1, 0 }, //A: 40A 66.67% (Invalid)
{ AX32_DEF_CURR, 0, 1, 0 }, //B: 48A 80.00% (Invalid)
{ AX32_DEF_CURR, 0, 1, 0 }, //C: Reserved ************* (Invalid)
{ AX32_DEF_CURR, 0, 1, 0 }, //D: Reserved ************* (Invalid)
{ 80, 0, 1, 0 }, //E: 80A 96.00% ????? (Invalid)
{ AX32_DEF_CURR, 0, 0, 1 }, //F: Slave Mode ***********
};
#else
// Old procedure (Deleted)
#endif //MODIFY_AX32_ROTATE_SWITCH_TABLE_20210915
#ifdef FUNC_AT32
const RotaryCurrItem RotaryCurrMap_AT32[ROTARY_CURR_ITEM_NUM] =
{
{ AT32_DEF_CURR, 1, 0, 0 }, //0: Test Mode ************
{ 6, 0, 0, 0 }, //1: 6A 10%
{ 8, 0, 0, 0 }, //2: 8A 13.33%
{ 10, 0, 0, 0 }, //3: 10A 16.67%
{ 13, 0, 0, 0 }, //4: 13A 21.67%
{ 16, 0, 0, 0 }, //5: 16A 26.67%
{ 20, 0, 0, 0 }, //6: 20A 33.33%
{ 25, 0, 0, 0 }, //7: 25A 41.67%
{ 30, 0, 0, 0 }, //8: 30A 50.00%
{ AT32_DEF_CURR, 0, 0, 0 }, //9: 32A 53.33% (DEFAULT)
{ AT32_DEF_CURR, 0, 1, 0 }, //A: 40A 66.67% (Invalid)
{ AT32_DEF_CURR, 0, 1, 0 }, //B: 48A 80.00% (Invalid)
{ AT32_DEF_CURR, 0, 1, 0 }, //C: Reserved ************* (Invalid)
{ AT32_DEF_CURR, 0, 1, 0 }, //D: Reserved ************* (Invalid)
{ 80, 0, 1, 0 }, //E: 80A 96.00% ????? (Invalid)
{ AT32_DEF_CURR, 0, 0, 1 }, //F: Slave Mode ***********
};
#endif //FUNC_AT32
#ifdef FUNC_AX80
const RotaryCurrItem RotaryCurrMap_AX80[ROTARY_CURR_ITEM_NUM] =
{
{ AX80_DEF_CURR, 1, 0, 0 }, //0: Test Mode ************
{ 6, 0, 0, 0 }, //1: 6A 10%
{ 8, 0, 0, 0 }, //2: 8A 13.33%
{ 10, 0, 0, 0 }, //3: 10A 16.67%
{ 13, 0, 0, 0 }, //4: 13A 21.67%
{ 16, 0, 0, 0 }, //5: 16A 26.67%
{ 20, 0, 0, 0 }, //6: 20A 33.33%
{ 25, 0, 0, 0 }, //7: 25A 41.67%
{ 30, 0, 0, 0 }, //8: 30A 50.00%
{ 32, 0, 0, 0 }, //9: 32A 53.33%
{ 40, 0, 0, 0 }, //A: 40A 66.67%
{ 48, 0, 0, 0 }, //B: 48A 80.00%
{ AX80_DEF_CURR, 0, 1, 0 }, //C: Reserved ************* (Invalid)
{ AX80_DEF_CURR, 0, 1, 0 }, //D: Reserved ************* (Invalid)
{ AX80_DEF_CURR, 0, 0, 0 }, //E: 80A 96.00% (DEFAULT)
{ AX80_DEF_CURR, 0, 0, 1 }, //F: Slave Mode ***********
};
#endif //FUNC_AX80
#ifdef FUNC_AW48
const RotaryCurrItem RotaryCurrMap_AW48[ROTARY_CURR_ITEM_NUM] =
{
{ AW48_DEF_CURR, 1, 0, 0 }, //0: X Test Mode ************ (Invalid)
{ 12, 0, 0, 0 }, //1: 12A 20.00%
{ 16, 0, 0, 0 }, //2: 16A 26.67%
{ 24, 0, 0, 0 }, //3: 24A 40.00%
{ 32, 0, 0, 0 }, //4: 32A 53.33%
{ 40, 0, 0, 0 }, //5: 40A 66.67%
{ AW48_DEF_CURR, 0, 0, 0 }, //6: 48A 80.00% (DEFAULT)
{ AW48_DEF_CURR, 0, 1, 0 }, //7: Reserved ************* (Invalid)
{ AW48_DEF_CURR, 0, 1, 0 }, //8: Reserved ************* (Invalid)
{ AW48_DEF_CURR, 0, 1, 0 }, //9: Reserved ************* (Invalid)
{ AW48_DEF_CURR, 0, 1, 0 }, //A: Reserved ************* (Invalid)
{ AW48_DEF_CURR, 0, 1, 0 }, //B: Reserved ************* (Invalid)
{ AW48_DEF_CURR, 0, 1, 0 }, //C: Reserved ************* (Invalid)
{ AW48_DEF_CURR, 0, 1, 0 }, //D: Reserved ************* (Invalid)
{ AW48_DEF_CURR, 0, 1, 0 }, //E: Reserved ************* (Invalid)
{ AW48_DEF_CURR, 0, 1, 0 }, //F: X Slave Mode *********** (Invalid)
};
#endif //FUNC_AW48
#endif //FUNC_ROTARY_CURR_MAP
void getRotarySwitchSetting(void)
{
uint8_t tmpBuf = 0;
#ifdef ROTATE_SWITCH_HARDCODE
tmpBuf = HC_ROTARY_SWITCH_SET_VAL;
#else
tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set1_GPIO_Port, IN_AC_Current_Set1_Pin)?0:1)<<0;
tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set2_GPIO_Port, IN_AC_Current_Set2_Pin)?0:1)<<1;
tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set3_GPIO_Port, IN_AC_Current_Set3_Pin)?0:1)<<2;
tmpBuf += (HAL_GPIO_ReadPin(IN_AC_Current_Set4_GPIO_Port, IN_AC_Current_Set4_Pin)?0:1)<<3;
#endif //ROTATE_SWITCH_HARDCODE
#ifdef FUNC_ROTARY_CURR_MAP
#ifdef FUNC_AX80
RotaryCurrItem const *p = NULL;
if (Charger.m_bModelNameAX80_1P)
{
p = &RotaryCurrMap_AX80[tmpBuf];
}
else if (Charger.m_bModelNameAX48_1P)
{
p = &RotaryCurrMap_AX48[tmpBuf];
}
else if (Charger.m_bModelNameAX32_3P || Charger.m_bModelNameDC)
{
p = &RotaryCurrMap_AX32[tmpBuf];
}
#ifdef FUNC_AT32
else if (Charger.m_bModelNameAT32_3P)
{
p = &RotaryCurrMap_AT32[tmpBuf];
}
#endif
#ifdef FUNC_AW48
else if (Charger.m_bModelNameAW48_1P)
{
p = &RotaryCurrMap_AW48[tmpBuf];
}
#endif
else
{
p = &RotaryCurrMap_AX48[tmpBuf];
}
#else
RotaryCurrItem const *p = (Charger.m_b3PhaseModel ? &RotaryCurrMap_AX32[tmpBuf] : &RotaryCurrMap_AX48[tmpBuf]);
#endif
Charger.maxRatingCurrent = p->m_nCurr;
Charger.isDebugEnable = p->m_bTestMode;
Charger.isRotarySwitchError = p->m_bInvalidItem;
XP("#[RotarySwitch(%c)] MaxCurr(%d), TestMode(%d), SwitchError(%d), SlaveMode(%d)\r\n",
CharacterArray[tmpBuf],
Charger.maxRatingCurrent,
Charger.isDebugEnable,
Charger.isRotarySwitchError,
Charger.m_bRotarySlaveMode);
#else //FUNC_ROTARY_CURR_MAP
// Old procedure (Deleted)
#endif //FUNC_ROTARY_CURR_MAP
DEBUG_INFO("Current rating value: %d A\r\n", Charger.maxRatingCurrent);
Charger.memory.EVSE_Config.data.item.MaxChargingCurrent = Charger.maxRatingCurrent;
#ifdef MODIFY_AC_EVSE_STATUS_MAX_CHARGING_CURRENT_VARIABLE
Charger.AC_MaxChargingCurrentOrDuty = Charger.maxRatingCurrent;
#endif
}
//------------------------------------------------------------------------------//
void CLC_Corr_Gain_Par(uint16_t SpecData_H ,uint16_t SpecData_L ,uint16_t MCUData_H , uint16_t MCUData_L , float *GainA , float *GainB )
{
*GainA = (float)((float)(SpecData_H -SpecData_L) / (float)( MCUData_H - MCUData_L)) ;
*GainB = (float)(SpecData_H - (float)(*GainA * MCUData_H)) ;
}
//------------------------------------------------------------------------------//
void CLC_Corr_Gain_Par2(uint16_t SpecData_H ,uint16_t SpecData_L ,uint16_t MCUData_H , uint16_t MCUData_L , float *GainA , float *GainB , uint8_t *PosorNeg )
{
*GainA = (float)((float)(SpecData_H -SpecData_L) / (float)( MCUData_H - MCUData_L)) ;
if (SpecData_H > (*GainA * MCUData_H))
{
*GainB = SpecData_H - (*GainA * MCUData_H) ;
*PosorNeg = ON ;
}
else
{
*GainB = (*GainA * MCUData_H) - SpecData_H ;
*PosorNeg = OFF ;
}
}
//------------------------------------------------------------------------------
uint8_t Array_data_Check ( uint8_t *s1, uint8_t *s2 )
{
uint8_t compare = 0;
uint8_t result = PASS;
for(compare=0;compare 0 && Charger.m_TripEnd == HTK_U32_MAX)
{
Charger.m_TripEnd = HAL_GetTick();
}
#endif
break;
default:
break;
}
}
//--------------------------------------------------------------------------------
#ifdef FUNC_OUTP_TYPE_E
void SE_Relay_Control_Function(void)
{
switch(Charger.SE_Relay_Action)
{
case GPIO_SE_RELAY_ACTION_ON:
if(SE_Relay1_Action_Get() == GPIO_SE_RELAY1_ACTION_OFF)
{
SE_Relay_Action_Set(GPIO_SE_RELAY1_ACTION_ON);
}
if(timer[TIMER_IDX_SE_RELAY_1].isAlarm == ON)
{
SE_Relay_Action_Set(GPIO_SE_RELAY1_ACTION_HOLD);
timerDisable(TIMER_IDX_SE_RELAY_1);
Charger.SE_Relay_isOperationCompleted |= 0x11 ;
}
break;
case GPIO_SE_RELAY_ACTION_OFF:
timer[TIMER_IDX_SE_RELAY_1].isEnable = OFF;
if(SE_Relay1_Action_Get() != GPIO_SE_RELAY1_ACTION_OFF)
{
SE_Relay_Action_Set(GPIO_SE_RELAY1_ACTION_OFF);
}
osDelay(10);
Charger.SE_Relay_isOperationCompleted &= 0x00 ;
break;
default:
break;
}
}
#endif //FUNC_OUTP_TYPE_E
//--------------------------------------------------------------------------------
uint8_t WatchDogLeakRawDataCheck_Event(void)
{
uint8_t result = PASS ;
for(uint16_t idx = 0 ; idx < ADC2_SAMPLE_COUNT; idx++)
{
if (ADC2_Buffer_Each[1][idx] >= 4000)
{
result = FAIL;
break;
}
}
return result ;
}
//--------------------------------------------------------------------------------
uint16_t getBrightnessDuty(uint16_t max_duty)
{
uint8_t Lv_Brightness = 3;
uint16_t duty = 1000;
Lv_Brightness = (Charger.Led_Brightness[(Charger.memory.EVSE_Config.data.item.SystemDateTime.hour/2)]>>(((Charger.memory.EVSE_Config.data.item.SystemDateTime.hour+1)%2)*4))&0xf;
switch(Lv_Brightness)
{
case 0:
duty = max_duty/4;
break;
case 1:
duty = max_duty/3;
break;
case 2:
duty = max_duty/2;
break;
case 3:
duty = max_duty;
break;
default:
duty = max_duty;
break;
}
#ifdef TEST_FOR_ENERGY_STAR
//return duty / 10;
//return duty / 4;
if (Charger.m_bLedSleepModeForceMinBrightness)
{
duty = max_duty/4;;
}
return duty;
#else
return duty;
#endif
}
//--------------------------------------------------------------------------------
void parseVersionInfoFromModelname(void)
{
#ifdef FUNC_XP_PARSE_VERSION_INFO_FROM_MODELNAME
XP("Parse ModelName: %s\r\n", Charger.memory.EVSE_Config.data.item.ModelName);
#endif
#ifdef FUNC_VERSION_USE_NEW_SPEC_20240926
//do nothing
#else //FUNC_VERSION_USE_NEW_SPEC_20240926
//--------------------------------------
// Version Naming Rule "tx.yz.ab.cddd.vv"
//Version Naming Rule "a"
for(uint8_t idx=0;idx<3;idx++)
{
switch(Charger.memory.EVSE_Config.data.item.ModelName[7+idx])
{
case '1':
// J1772 Plug
Charger.Ver_FW[6] = '4';
break;
case '2':
// J1772 Socket
Charger.Ver_FW[6] = '1';
break;
case '3':
// CE Plug
Charger.Ver_FW[6] = '5';
break;
case '4':
// CE Socket
Charger.Ver_FW[6] = '2';
break;
case '5':
// GB Plug
Charger.Ver_FW[6] = '6';
break;
case '6':
// GB Socket
Charger.Ver_FW[6] = '3';
break;
#ifdef FUNC_ADD_FW_VER_WITH_GUN_TYPE_NACS
case '9':
// NACS
Charger.Ver_FW[6] = '9';
break;
#endif
}
}
#endif //FUNC_VERSION_USE_NEW_SPEC_20240926
//Version Naming Rule "c"
switch(Charger.memory.EVSE_Config.data.item.ModelName[10])
{
case 'B':
case 'U':
//Blue tooth
Charger.Ver_FW[9] = '3';
break;
case 'W':
// WIFI
Charger.Ver_FW[9] = '1';
break;
case 'T':
// 3G/4G
Charger.Ver_FW[9] = '2';
break;
#ifdef FUNC_ADD_FW_VER_WITH_NET_TYPE_WIFI_AND_4G
case 'D':
Charger.Ver_FW[9] = '5';
break;
#endif
default:
// LAN
Charger.Ver_FW[9] = '0';
break;
}
//Version Naming Rule "d3" , Get rating power from model name
memcpy(&Charger.Ver_FW[10], &Charger.memory.EVSE_Config.data.item.ModelName[4], 0x03);
// Get vender code from model name
memcpy(&Charger.Ver_FW[14], &Charger.memory.EVSE_Config.data.item.ModelName[12], 0x02);
//--------------------------------------
//adc2 watchdog config data
ADC_AnalogWDGConfTypeDef AnalogWDGConfig = {0};
AnalogWDGConfig.WatchdogMode = ADC_ANALOGWATCHDOG_SINGLE_REG;
AnalogWDGConfig.HighThreshold = 3722;
AnalogWDGConfig.LowThreshold = 372;
AnalogWDGConfig.Channel = ADC_CHANNEL_6;
#ifdef MODIFY_OCP_PROC_WITH_MODELNAME_IDX_3_EURO_SPEC
HTK_BOOL bModelNameWithEuroSpecOCP = HTK_FALSE;
#endif
// CCID_Module_Type check
Charger.CCID_Module_Type = CCID_MODULE_VAC ;
switch(Charger.memory.EVSE_Config.data.item.ModelName[3])
{
case 'E': //CE / European Market
case 'T': //TR25 / Singapor Market
case 'Z': //EV ready / French Market
#ifdef MODIFY_OCP_PROC_WITH_MODELNAME_IDX_3_EURO_SPEC
case 'M': //E + MID Meter
case 'P': //E + PTB certification
case 'I': //Z + TIC Meter pcb
case 'F': //Z + MID Meter
bModelNameWithEuroSpecOCP = HTK_TRUE;
#endif
Charger.CCID_Module_Type = CCID_MODULE_VAC ;
AnalogWDGConfig.ITMode = DISABLE;
//#ifdef MODIFY_OCP_MAGNIFICATION
// Charger.OCP_Magnification = 125 ;
//#else
Charger.OCP_Magnification = 115 ;
//#endif
break;
case 'U':
//UL / North America Market
Charger.CCID_Module_Type = CCID_MODULE_CORMEX ;
#ifdef MODIFY_AW48_CCID_UL_SPEC_KENNY_20240401
//set at the other place
// if (Charger.m_bModelNameAW48_1P)
// {
// Charger.alarm_spec.Current_LEAK_AC = 1700 ; // unit 0.01mA
// }
// else
#endif //MODIFY_AW48_CCID_UL_SPEC_KENNY_20240401
{
Charger.alarm_spec.Current_LEAK_AC = 1800 ; // unit 0.01mA
}
AnalogWDGConfig.ITMode = ENABLE;
Charger.OCP_Magnification = 110 ;
break;
case 'G':
//GB / China Market
Charger.CCID_Module_Type = CCID_MODULE_CORMEX ;
Charger.alarm_spec.Current_LEAK_AC = 2500 ; // unit 0.01mA
AnalogWDGConfig.ITMode = ENABLE;
Charger.OCP_Magnification = 110 ;
break;
case 'C':
#ifdef FUNC_SUPPORT_MODEL_AXYC
if (Charger.memory.EVSE_Config.data.item.ModelName[2] == 'Y')
{
bModelNameWithEuroSpecOCP = HTK_TRUE;
Charger.CCID_Module_Type = CCID_MODULE_VAC ;
AnalogWDGConfig.ITMode = DISABLE;
Charger.OCP_Magnification = 115 ;
}
else
{
Charger.CCID_Module_Type = CCID_MODULE_CORMEX ;
Charger.alarm_spec.Current_LEAK_AC = 2500 ; // unit 0.01mA
AnalogWDGConfig.ITMode = ENABLE;
Charger.OCP_Magnification = 110 ;
}
#else //FUNC_SUPPORT_MODEL_AXYC
//CNS / Taiwan Market
#ifdef FUNC_REPLACE_CORMEX_WITH_VAC_FOR_CNS_MODEL
Charger.CCID_Module_Type = CCID_MODULE_VAC;
#else
Charger.CCID_Module_Type = CCID_MODULE_CORMEX ;
#endif
Charger.alarm_spec.Current_LEAK_AC = 2500 ; // unit 0.01mA
AnalogWDGConfig.ITMode = ENABLE;
Charger.OCP_Magnification = 110 ;
#endif //FUNC_SUPPORT_MODEL_AXYC
break;
case 'J':
//JARI / Japan Market
Charger.CCID_Module_Type = CCID_MODULE_CORMEX ;
Charger.alarm_spec.Current_LEAK_AC = 2500 ; // unit 0.01mA
AnalogWDGConfig.ITMode = ENABLE;
Charger.OCP_Magnification = 110 ;
break;
case 'K':
//KC / Korea Market
Charger.CCID_Module_Type = CCID_MODULE_CORMEX ;
Charger.alarm_spec.Current_LEAK_AC = 1800 ; // unit 0.01mA
AnalogWDGConfig.ITMode = ENABLE;
Charger.OCP_Magnification = 110 ;
break;
case 'B':
//British / UK Market
Charger.CCID_Module_Type = CCID_MODULE_CORMEX ;
Charger.alarm_spec.Current_LEAK_AC = 1800 ; // unit 0.01mA
AnalogWDGConfig.ITMode = ENABLE;
Charger.OCP_Magnification = 110 ;
break;
default:
Charger.CCID_Module_Type = CCID_MODULE_VAC ;
AnalogWDGConfig.ITMode = DISABLE;
Charger.alarm_spec.Current_LEAK_AC = 1800 ; // unit 0.01mA
Charger.OCP_Magnification = 110 ;
break;
}
#ifdef MODIFY_OCP_PROC_WITH_MODELNAME_IDX_3_EURO_SPEC
Charger.m_bModelNameWithEuroSpecOCP = bModelNameWithEuroSpecOCP;
XP("#Use EuropeanSpecOCP: %s\r\n", Charger.m_bModelNameWithEuroSpecOCP ? "True" : "False");
#endif
#ifdef FUNC_AUTO_MODIFY_CCID_MODULE
XP("#Use CCID Module (ModelName: %s): %s\r\n", Charger.memory.EVSE_Config.data.item.ModelName, CCID_MODULE_TYPE_STR);
if (Charger.m_bCCID_MustModify && Charger.m_CCID_ModuleTestOK != CCID_MODULE_UNKNOW)
{
Charger.CCID_Module_Type = Charger.m_CCID_ModuleTestOK;
XP("#Use CCID Module (AutoModify): %s\r\n", CCID_MODULE_TYPE_STR);
}
#endif
//adc2 watchdog config to register
if (HAL_ADC_AnalogWDGConfig(&hadc2, &AnalogWDGConfig) != HAL_OK)
{
Error_Handler();
}
#ifdef FUNC_AUTO_IGNORE_AC_PHASE
Charger.m_b3PhaseModel =
(
(Charger.memory.EVSE_Config.data.item.ModelName[2] == 'Y')
|| (Charger.memory.EVSE_Config.data.item.ModelName[2] == 'D')
|| (Charger.memory.EVSE_Config.data.item.ModelName[2] == 'W')
) ? 1 : 0;
XP("#ThreePhaseModel: %s\r\n", Charger.m_b3PhaseModel ? "True" : "False");
#ifdef FUNC_CHECK_MODELNAME_AX_PRIFIX
Charger.m_bModelNameAX =
(
(Charger.memory.EVSE_Config.data.item.ModelName[0] == 'A')
&& (Charger.memory.EVSE_Config.data.item.ModelName[1] == 'X')
) ? 1 : 0;
XP("#ModelNameAX: %s\r\n", Charger.m_bModelNameAX ? "True" : "False");
#endif
#ifdef FUNC_AT32
Charger.m_bModelNameAT =
(
(Charger.memory.EVSE_Config.data.item.ModelName[0] == 'A')
&& (Charger.memory.EVSE_Config.data.item.ModelName[1] == 'T')
) ? 1 : 0;
XP("#ModelNameAT: %s\r\n", Charger.m_bModelNameAT ? "True" : "False");
Charger.m_bModelNameAT32_3P = Charger.m_bModelNameAT &&
(
Charger.m_b3PhaseModel
// && (Charger.memory.EVSE_Config.data.item.ModelName[4] == '2')
// && (Charger.memory.EVSE_Config.data.item.ModelName[5] == '2')
// && (Charger.memory.EVSE_Config.data.item.ModelName[6] == '1')
) ? 1 : 0;
XP("#ModelNameAT32_3P: %s\r\n", Charger.m_bModelNameAT32_3P ? "True" : "False");
#endif //FUNC_AT32
#ifdef FUNC_AX80
//ex: AXLU191001W1P0
Charger.m_bModelNameAX80_1P = Charger.m_bModelNameAX &&
(
!Charger.m_b3PhaseModel
&& (Charger.memory.EVSE_Config.data.item.ModelName[4] == '1')
&& (Charger.memory.EVSE_Config.data.item.ModelName[5] == '9')
&& (Charger.memory.EVSE_Config.data.item.ModelName[6] == '1')
) ? 1 : 0;
XP("#ModelNameAX80_1P: %s\r\n", Charger.m_bModelNameAX80_1P ? "True" : "False");
Charger.m_bModelNameAX48_1P = Charger.m_bModelNameAX &&
(
!Charger.m_b3PhaseModel
&& !Charger.m_bModelNameAX80_1P
// && (Charger.memory.EVSE_Config.data.item.ModelName[4] == '1')
// && (Charger.memory.EVSE_Config.data.item.ModelName[5] == '1')
// && (Charger.memory.EVSE_Config.data.item.ModelName[6] == '1')
) ? 1 : 0;
XP("#ModelNameAX48_1P: %s\r\n", Charger.m_bModelNameAX48_1P ? "True" : "False");
#ifdef FUNC_AXSJ_USE_NEW_NACS_PCB
Charger.m_bModelNameAXSJ =
(
(Charger.memory.EVSE_Config.data.item.ModelName[0] == 'A')
&& (Charger.memory.EVSE_Config.data.item.ModelName[1] == 'X')
&& (Charger.memory.EVSE_Config.data.item.ModelName[2] == 'S')
&& (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'J')
) ? 1 : 0;
XP("#ModelNameAXSJ: %s\r\n", Charger.m_bModelNameAXSJ ? "True" : "False");
Charger.m_bModelNameAXSJ_AX48_NACS_1P =
(
Charger.m_bModelNameAXSJ
&& (Charger.memory.EVSE_Config.data.item.ModelName[4] == '9')
&& (Charger.memory.EVSE_Config.data.item.ModelName[5] == '6')
&& (Charger.memory.EVSE_Config.data.item.ModelName[6] == '0')
) ? 1 : 0;
XP("#ModelNameAXSJ_AX48_NACS_1P: %s\r\n", Charger.m_bModelNameAXSJ_AX48_NACS_1P ? "True" : "False");
Charger.m_bModelNameAXSJ_AX80_NACS_1P =
(
Charger.m_bModelNameAXSJ
&& (Charger.memory.EVSE_Config.data.item.ModelName[4] == 'x')
&& (Charger.memory.EVSE_Config.data.item.ModelName[5] == 'x')
&& (Charger.memory.EVSE_Config.data.item.ModelName[6] == 'x')
) ? 1 : 0;
XP("#ModelNameAXSJ_AX80_NACS_1P: %s\r\n", Charger.m_bModelNameAXSJ_AX80_NACS_1P ? "True" : "False");
#endif //FUNC_AXSJ_USE_NEW_NACS_PCB
#ifdef FUNC_AX48_NACS
Charger.m_bModelNameAX48_NACS_1P = Charger.m_bModelNameAX48_1P
&& (Charger.memory.EVSE_Config.data.item.ModelName[7] == '0')
&& (Charger.memory.EVSE_Config.data.item.ModelName[8] == '0')
&& (Charger.memory.EVSE_Config.data.item.ModelName[9] == '9');
#ifdef FUNC_AXSJ_USE_NEW_NACS_PCB
Charger.m_bModelNameAX48_NACS_1P |= Charger.m_bModelNameAXSJ_AX48_NACS_1P;
#endif
#ifdef ADD_AX_NACS_PCB_USE_GEN_CODE_3
Charger.m_bModelNameAX48_NACS_1P |= (Charger.m_bModelNameAX48_1P && Charger.memory.EVSE_Config.data.item.ModelName[11] == '3');
#endif
XP("#ModelNameAX48_NACS_1P: %s\r\n", Charger.m_bModelNameAX48_NACS_1P ? "True" : "False");
#ifdef FUNC_LIN_EN_SW
if (Charger.m_bModelNameAX48_NACS_1P)
{
LIN_SW(HTK_FALSE); //PWM
}
#endif //FUNC_LIN_EN_SW
#ifdef FUNC_TMP100
if (Charger.m_bModelNameAX48_NACS_1P ||
Charger.m_bModelNameAX80_NACS_1P)
{
Charger.m_bUseTMP100 = 1;
}
else
{
Charger.m_bUseTMP100 = 0;
}
XP("#UseTMP100: %s\r\n", Charger.m_bUseTMP100 ? "True" : "False");
#endif
#endif //FUNC_AX48_NACS
#ifdef FUNC_AX80_NACS
Charger.m_bModelNameAX80_NACS_1P = Charger.m_bModelNameAX80_1P
&& (Charger.memory.EVSE_Config.data.item.ModelName[7] == '0')
&& (Charger.memory.EVSE_Config.data.item.ModelName[8] == '0')
&& (Charger.memory.EVSE_Config.data.item.ModelName[9] == '9');
#ifdef FUNC_AXSJ_USE_NEW_NACS_PCB
Charger.m_bModelNameAX80_NACS_1P |= Charger.m_bModelNameAXSJ_AX80_NACS_1P;
#endif
#ifdef ADD_AX_NACS_PCB_USE_GEN_CODE_3
Charger.m_bModelNameAX80_NACS_1P |= (Charger.m_bModelNameAX80_1P && Charger.memory.EVSE_Config.data.item.ModelName[11] == '3');
#endif
XP("#ModelNameAX80_NACS_1P: %s\r\n", Charger.m_bModelNameAX80_NACS_1P ? "True" : "False");
#ifdef FUNC_LIN_EN_SW
if (Charger.m_bModelNameAX80_NACS_1P)
{
LIN_SW(HTK_FALSE); //PWM
}
#endif //FUNC_LIN_EN_SW
#endif //FUNC_AX80_NACS
Charger.m_bModelNameAX32_3P = Charger.m_bModelNameAX &&
(
Charger.m_b3PhaseModel
// && (Charger.memory.EVSE_Config.data.item.ModelName[4] == '2')
// && (Charger.memory.EVSE_Config.data.item.ModelName[5] == '2')
// && (Charger.memory.EVSE_Config.data.item.ModelName[6] == '1')
) ? 1 : 0;
XP("#ModelNameAX32_3P: %s\r\n", Charger.m_bModelNameAX32_3P ? "True" : "False");
#ifdef FUNC_AW48
Charger.m_bModelNameAW48_1P = !Charger.m_bModelNameAX &&
(
!Charger.m_b3PhaseModel
&& (Charger.memory.EVSE_Config.data.item.ModelName[0] == 'A')
&& (Charger.memory.EVSE_Config.data.item.ModelName[1] == 'W')
&& (Charger.memory.EVSE_Config.data.item.ModelName[4] == '1')
&& (Charger.memory.EVSE_Config.data.item.ModelName[5] == '1')
&& (Charger.memory.EVSE_Config.data.item.ModelName[6] == '1')
) ? 1 : 0;
XP("#ModelNameAW48_1P: %s\r\n", Charger.m_bModelNameAW48_1P ? "True" : "False");
#ifdef MODIFY_AW48_CCID_UL_SPEC_KENNY_20240401
if (Charger.m_bModelNameAW48_1P)
{
Charger.alarm_spec.Current_LEAK_AC = 1700 ; // unit 0.01mA
}
#endif //MODIFY_AW48_CCID_UL_SPEC_KENNY_20240401
#ifdef FUNC_LIN_EN_SW
if (Charger.m_bModelNameAW48_1P)
{
LIN_SW(HTK_FALSE); //PWM
}
#endif //FUNC_LIN_EN_SW
#ifdef FUNC_AW48_EXT_LED
if (Charger.m_bModelNameAW48_1P)
{
EXTLED_SET_POWER(1);
}
#endif //FUNC_AW48_EXT_LED
#endif //FUNC_AW48
#ifdef RELAY_COMMON_GPIO
if (Charger.m_bModelNameAW48_1P)
{
#ifdef AW48_NEW_PCB_WITH_CORRECT_RELAY_PIN
Charger.m_RelayMode = 0; //New PCB
#else
Charger.m_RelayMode = 1;
#endif
}
else
{
Charger.m_RelayMode = 0;
}
XP("#RelayMode: %d\r\n", Charger.m_RelayMode);
#endif
#ifdef FUNC_EKM_OMNIMETER
Charger.m_bUseExtMeter_OMNIMETER = Charger.m_bModelNameAW48_1P;
XP("#UseExtMeter_OMNIMETER: %s\r\n", Charger.m_bUseExtMeter_OMNIMETER ? "True" : "False");
#endif
#ifdef FUNC_LIN_CP
Charger.m_bUseLinCP = Charger.m_bModelNameAW48_1P;
XP("#UseLinCP: %s\r\n", Charger.m_bUseLinCP ? "True" : "False");
#endif //FUNC_AW48
#endif //FUNC_AX80
#ifdef AUTO_MODIFY_FW_VERSION_PREFIX_V_WHEN_GET_AX48_MODELNAME_WITH_CSU
UpdateFirmwareVersion();
#endif
#ifdef FUNC_NEW_RELAY_MONITOR
if (Charger.m_b3PhaseModel == 0)
{
//AX48 (1P) LN/LL use same formula
Charger.alarm_spec.Relay_LL_DriveFault_Slop = 0.003266332;
Charger.alarm_spec.Relay_LL_DriveFault_Offs = 0.28;
#ifdef MODIFY_AW48_WELDING_THRESHOLD_KENNY_20240418
if (Charger.m_bModelNameAW48_1P)
{
Charger.alarm_spec.Relay_LL_Welding_Slop = 0.001894;
Charger.alarm_spec.Relay_LL_Welding_Offs = 0.093333333;
}
else
#endif //MODIFY_AW48_WELDING_THRESHOLD_KENNY_20240418
{
Charger.alarm_spec.Relay_LL_Welding_Slop = 0.00318258;
Charger.alarm_spec.Relay_LL_Welding_Offs = 0.093333333;
}
}
else
{
//AX32 (3P) only LL
Charger.alarm_spec.Relay_LL_DriveFault_Slop = 0.003661263;
Charger.alarm_spec.Relay_LL_DriveFault_Offs = 1.340704304;
Charger.alarm_spec.Relay_LL_Welding_Slop = 0.002794857;
Charger.alarm_spec.Relay_LL_Welding_Offs = 0.391911683;
}
#endif //FUNC_NEW_RELAY_MONITOR
#ifdef FUNC_METER_IC_VARIABLE_PARAM
#ifdef FUNC_AX80
if (Charger.m_bModelNameAX80_1P)
{
MeterIC_KI = KI_AX80;
MeterIC_KP = KP_AX80;
MeterIC_KE = KE_AX80;
}
else if (Charger.m_bModelNameAX48_1P)
{
MeterIC_KI = KI_AX48;
MeterIC_KP = KP_AX48;
MeterIC_KE = KE_AX48;
}
else if (Charger.m_bModelNameAX32_3P)
{
MeterIC_KI = KI_AX32;
MeterIC_KP = KP_AX32;
MeterIC_KE = KE_AX32;
}
#ifdef FUNC_AT32
else if (Charger.m_bModelNameAT32_3P)
{
MeterIC_KI = KI_AT32;
MeterIC_KP = KP_AT32;
MeterIC_KE = KE_AT32;
}
#endif
#ifdef FUNC_AW48
else if (Charger.m_bModelNameAW48_1P)
{
MeterIC_KI = KI_AW48;
MeterIC_KP = KP_AW48;
MeterIC_KE = KE_AW48;
}
#endif
else
{
MeterIC_KI = KI_AX48;
MeterIC_KP = KP_AX48;
MeterIC_KE = KE_AX48;
}
XP("#MeterIC KI = %.10f, KP = %.10f, KE = %.10f\r\n", MeterIC_KI, MeterIC_KP, MeterIC_KE);
#else //FUNC_AX80
if (Charger.m_b3PhaseModel == 0)
{
MeterIC_KI = KI_AX48;
MeterIC_KP = KP_AX48;
MeterIC_KE = KE_AX48;
}
else
{
MeterIC_KI = KI_AX32;
MeterIC_KP = KP_AX32;
MeterIC_KE = KE_AX32;
}
#endif //FUNC_AX80
#endif //FUNC_METER_IC_VARIABLE_PARAM
#ifdef MODIFY_OTP_SPEC
#ifdef FUNC_AX80_ADD_4_TEMP_SENEOR
if (Charger.m_bModelNameAX80_1P)
{
#ifdef FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
if (Charger.m_bModelNameAX80_NACS_1P)
{
Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AX80_NACS;
Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AX80_NACS;
Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AX80_NACS;
Charger.alarm_spec.OT_G2_1 = ALARM_SPEC_OT_G2_1_AX80_NACS;
Charger.alarm_spec.OT_G2_2 = ALARM_SPEC_OT_G2_2_AX80_NACS;
Charger.alarm_spec.OT_G2_HYSTERESIS = ALARM_SPEC_OT_G2_HYSTERESIS_AX80_NACS;
#ifdef MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
Charger.alarm_spec.OT_G3_1 = ALARM_SPEC_OT_G3_1_AX80_NACS;
Charger.alarm_spec.OT_G3_2 = ALARM_SPEC_OT_G3_2_AX80_NACS;
Charger.alarm_spec.OT_G3_HYSTERESIS = ALARM_SPEC_OT_G3_HYSTERESIS_AX80_NACS;
Charger.alarm_spec.OT_G4_1 = ALARM_SPEC_OT_G4_1_AX80_NACS;
Charger.alarm_spec.OT_G4_2 = ALARM_SPEC_OT_G4_2_AX80_NACS;
Charger.alarm_spec.OT_G4_HYSTERESIS = ALARM_SPEC_OT_G4_HYSTERESIS_AX80_NACS;
#endif //MODIFY_AX80_NACS_OTP_SPEC_20240911_JACK
}
else
{
Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AX80;
Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AX80;
Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AX80;
Charger.alarm_spec.OT_G2_1 = ALARM_SPEC_OT_G2_1_AX80;
Charger.alarm_spec.OT_G2_2 = ALARM_SPEC_OT_G2_2_AX80;
Charger.alarm_spec.OT_G2_HYSTERESIS = ALARM_SPEC_OT_G2_HYSTERESIS_AX80;
}
#else //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AX80;
Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AX80;
Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AX80;
Charger.alarm_spec.OT_G2_1 = ALARM_SPEC_OT_G2_1_AX80;
Charger.alarm_spec.OT_G2_2 = ALARM_SPEC_OT_G2_2_AX80;
Charger.alarm_spec.OT_G2_HYSTERESIS = ALARM_SPEC_OT_G2_HYSTERESIS_AX80;
#endif //FUNC_AX80_NACS_ADD_6_TEMP_SENEOR
}
#ifdef FUNC_AW48_ADD_6_TEMP_SENEOR
else if (Charger.m_bModelNameAW48_1P)
{
Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AW48;
Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AW48;
Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AW48;
Charger.alarm_spec.OT_G2_1 = ALARM_SPEC_OT_G2_1_AW48;
Charger.alarm_spec.OT_G2_2 = ALARM_SPEC_OT_G2_2_AW48;
Charger.alarm_spec.OT_G2_HYSTERESIS = ALARM_SPEC_OT_G2_HYSTERESIS_AW48;
#ifdef MODIFY_AW48_OTP_SPEC_20240522_STEVEN
Charger.alarm_spec.OT_G3_1 = ALARM_SPEC_OT_G3_1_AW48;
Charger.alarm_spec.OT_G3_2 = ALARM_SPEC_OT_G3_2_AW48;
Charger.alarm_spec.OT_G3_HYSTERESIS = ALARM_SPEC_OT_G3_HYSTERESIS_AW48;
#endif //MODIFY_AW48_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AW48_OTP_SPEC_20240802_STEVEN
Charger.alarm_spec.OT_G4_1 = ALARM_SPEC_OT_G4_1_AW48;
Charger.alarm_spec.OT_G4_2 = ALARM_SPEC_OT_G4_2_AW48;
Charger.alarm_spec.OT_G4_HYSTERESIS = ALARM_SPEC_OT_G4_HYSTERESIS_AW48;
#endif //MODIFY_AW48_OTP_SPEC_20240802_STEVEN
}
#endif
#ifdef FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
else if (Charger.m_bModelNameAX48_NACS_1P)
{
Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AX48_NACS;
Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AX48_NACS;
Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AX48_NACS;
Charger.alarm_spec.OT_G2_1 = ALARM_SPEC_OT_G2_1_AX48_NACS;
Charger.alarm_spec.OT_G2_2 = ALARM_SPEC_OT_G2_2_AX48_NACS;
Charger.alarm_spec.OT_G2_HYSTERESIS = ALARM_SPEC_OT_G2_HYSTERESIS_AX48_NACS;
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
Charger.alarm_spec.OT_G3_1 = ALARM_SPEC_OT_G3_1_AX48_NACS;
Charger.alarm_spec.OT_G3_2 = ALARM_SPEC_OT_G3_2_AX48_NACS;
Charger.alarm_spec.OT_G3_HYSTERESIS = ALARM_SPEC_OT_G3_HYSTERESIS_AX48_NACS;
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240522_STEVEN
#ifdef MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
Charger.alarm_spec.OT_G4_1 = ALARM_SPEC_OT_G4_1_AX48_NACS;
Charger.alarm_spec.OT_G4_2 = ALARM_SPEC_OT_G4_2_AX48_NACS;
Charger.alarm_spec.OT_G4_HYSTERESIS = ALARM_SPEC_OT_G4_HYSTERESIS_AX48_NACS;
#endif //MODIFY_AX48_NACS_OTP_SPEC_20240826_STEVEN
}
#endif //FUNC_AX48_NACS_ADD_6_TEMP_SENEOR
else if (Charger.m_bModelNameAX48_1P)
{
Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AX48;
Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AX48;
Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AX48;
}
else if (Charger.m_bModelNameAX32_3P)
{
Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AX32;
Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AX32;
Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AX32;
}
#ifdef FUNC_AT32
else if (Charger.m_bModelNameAT32_3P)
{
Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AT32;
Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AT32;
Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AT32;
}
#endif
else
{
Charger.alarm_spec.OT_G1_1 = ALARM_SPEC_OT_G1_1_AX48;
Charger.alarm_spec.OT_G1_2 = ALARM_SPEC_OT_G1_2_AX48;
Charger.alarm_spec.OT_G1_HYSTERESIS = ALARM_SPEC_OT_G1_HYSTERESIS_AX48;
}
#else //FUNC_AX80_ADD_4_TEMP_SENEOR
if (Charger.m_b3PhaseModel == 0)
{
Charger.alarm_spec.OT_1 = ALARM_SPEC_OT_1_AX48;
Charger.alarm_spec.OT_2 = ALARM_SPEC_OT_2_AX48;
Charger.alarm_spec.OT_HYSTERESIS = ALARM_SPEC_OT_HYSTERESIS_AX48;
}
else
{
Charger.alarm_spec.OT_1 = ALARM_SPEC_OT_1_AX32;
Charger.alarm_spec.OT_2 = ALARM_SPEC_OT_2_AX32;
Charger.alarm_spec.OT_HYSTERESIS = ALARM_SPEC_OT_HYSTERESIS_AX32;
}
#endif //FUNC_AX80_ADD_4_TEMP_SENEOR
#endif //MODIFY_OTP_SPEC
#endif //FUNC_AUTO_IGNORE_AC_PHASE
#ifdef FUNC_AUTO_USE_EXT_METER
#ifdef FUNC_FORCE_USE_METER_EXT_PRO380
Charger.m_bUseExtMeter_PRO380 = 1;
XP("#UseExtMeter: FORCE Enable\r\n");
#else
Charger.m_bUseExtMeter_PRO380 =
(
(Charger.memory.EVSE_Config.data.item.ModelName[3] == 'M')
#ifndef FUNC_PTB_METER_WM3M4C
|| (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'P')
#endif
|| (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'I')
|| (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'F')
|| (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'L')
#ifdef TEST_METER_PRO380_AND_WM3M4C_AT_THE_SAME_TIME_USE_MODELNAME_IDX_3_X
|| (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'x')
#endif
) ? 1 : 0;
XP("#UseExtMeter_PRO380: %s\r\n", Charger.m_bUseExtMeter_PRO380 ? "Enable" : "Disable");
#endif //FUNC_FORCE_USE_METER_EXT_PRO380
#ifdef FUNC_PTB_METER_WM3M4C
Charger.m_bUseExtMeter_WM3M4C =
(
Charger.memory.EVSE_Config.data.item.ModelName[3] == 'P'
#ifdef TEST_METER_PRO380_AND_WM3M4C_AT_THE_SAME_TIME_USE_MODELNAME_IDX_3_X
|| (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'x')
#endif
) ? 1 : 0;
XP("#UseExtMeter_WM3M4C: %s\r\n", Charger.m_bUseExtMeter_WM3M4C ? "Enable" : "Disable");
#endif //FUNC_PTB_METER_WM3M4C
#ifdef FUNC_ADD_TILT_SENSOR_MODEL
{
Charger.m_bUseTiltSensor =
(
Charger.m_bModelNameAX80_1P
|| Charger.m_bModelNameAX48_NACS_1P
#ifdef FUNC_AX80_NACS
|| Charger.m_bModelNameAX80_NACS_1P
#endif
#ifdef FUNC_AW48
|| Charger.m_bModelNameAW48_1P
#endif
) ? 1 : 0;
XP("#UseTiltSensor: %s\r\n", Charger.m_bUseTiltSensor ? "Enable" : "Disable");
}
#endif //FUNC_ADD_TILT_SENSOR_MODEL
#endif //FUNC_AUTO_USE_EXT_METER
#ifdef FUNC_RS485_SLAVE
Charger.m_bRS485SlaveForDCModel =
(
(Charger.memory.EVSE_Config.data.item.ModelName[0] == 'D') //response to DC Model
) ? 1 : 0;
Charger.m_RS485SlaveAddr = (Charger.m_bRS485SlaveForDCModel ? PROTOCOL_ADDR_AC_MAINBOARD : PROTOCOL_ADDR);
#endif
#ifdef FUNC_FORCE_RUN_CSU_MODE_WITH_DC_MODELNAME
Charger.m_bModelNameDC =
(
(Charger.memory.EVSE_Config.data.item.ModelName[0] == 'D') //response to DC Model
) ? 1 : 0;
Charger.m_bModelNameDCReadOK = 1;
XP("#ModelNameDC: %s\r\n", Charger.m_bModelNameDC ? "True" : "False");
Update_McuCtrlMode();
#endif
#ifdef FUNC_CSU_SIGN_IN_VERIFY
Charger.m_bCsuSignInMustVerify = (Charger.m_bModelNameAW48_1P && (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_CSU));
XP("#CsuSignInMustVerify: %s\r\n", Charger.m_bCsuSignInMustVerify ? "True" : "False");
#endif
#ifdef FUNC_CSU_UPGRADE_FW_VERIFY
Charger.m_bCsuUpgradeFwMustVerify = (Charger.m_bModelNameAW48_1P && (Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_CSU));
XP("#CsuUpgradeFwMustVerify: %s\r\n", Charger.m_bCsuUpgradeFwMustVerify ? "True" : "False");
#endif
#ifdef FUNC_DETECT_PP
{
HTK_BOOL bDetectPP = HTK_FALSE;
for (uint8_t i = 7; i <= 9; i++)
{
bDetectPP |=
(
Charger.memory.EVSE_Config.data.item.ModelName[i] == '2' //IEC 62196-2 Type 1 / SAE J1772 Socket
|| Charger.memory.EVSE_Config.data.item.ModelName[i] == '4' //IEC 62196-2 Type 2 Socket
|| Charger.memory.EVSE_Config.data.item.ModelName[i] == '6' //GB/T AC Socket
) ? HTK_TRUE : HTK_FALSE;
}
Charger.m_bDetectPP = bDetectPP;
XP("#DetectPP: %s\r\n", Charger.m_bDetectPP ? "Enable" : "Disable");
}
#endif //FUNC_DETECT_PP
#ifdef FUNC_DETECT_PP_NACS
{
HTK_BOOL bDetectPP_NACS = HTK_FALSE;
#ifdef FUNC_AX80_NACS
bDetectPP_NACS = Charger.m_bModelNameAX48_NACS_1P || Charger.m_bModelNameAX80_NACS_1P;
#else
bDetectPP_NACS = Charger.m_bModelNameAX48_NACS_1P;
#endif
Charger.m_bDetectPP_NACS = bDetectPP_NACS;
XP("#DetectPP_NACS: %s\r\n", Charger.m_bDetectPP_NACS ? "Enable" : "Disable");
}
#endif //FUNC_DETECT_PP_NACS
#ifdef FUNC_GUN_LOCK
{
HTK_BOOL bUseGunLock = HTK_FALSE;
for (uint8_t i = 7; i <= 9; i++)
{
bUseGunLock |=
(
Charger.memory.EVSE_Config.data.item.ModelName[i] == '2' //IEC 62196-2 Type 1 / SAE J1772 Socket
|| Charger.memory.EVSE_Config.data.item.ModelName[i] == '4' //IEC 62196-2 Type 2 Socket
|| Charger.memory.EVSE_Config.data.item.ModelName[i] == '6' //GB/T AC Socket
) ? HTK_TRUE : HTK_FALSE;
}
Charger.m_bUseGunLock = bUseGunLock;
XP("#UseGunLock: %s\r\n", Charger.m_bUseGunLock ? "Enable" : "Disable");
#ifdef FUNC_GUN_LOCK_TRIG_MODE
if (IS_CSU_MOUNTED) //CSU Mounted
{
Charger.m_GunLockTrigMode = GL_TRIG_MODE_REQUEST;
Charger.m_GunLockRequestMode_LockDelayTick = 0;
}
else //No CSU Mounted or DC Model
{
Charger.m_GunLockTrigMode = GL_TRIG_MODE_RELAY;
}
XP("#GunLockTrigMode: %d\r\n", (int)Charger.m_GunLockTrigMode);
#endif
}
#endif //FUNC_GUN_LOCK
#ifdef FUNC_USE_RELAY_B_CONTACT
{
HTK_BOOL bUseRelayBContact = HTK_FALSE;
bUseRelayBContact = Charger.m_b3PhaseModel;
////#ifdef DISABLE_USE_RELAY_B_CONTACT_WITH_DC_MODELNAME
//// if (Charger.m_bModelNameDC)
//// bUseRelayBContact = HTK_FALSE;
////#endif
#ifdef DISABLE_USE_RELAY_B_CONTACT_WITH_AX32_OLD_PCB
bUseRelayBContact = HTK_FALSE;
#endif
Charger.m_bUseRelayBContact = bUseRelayBContact;
XP("#UseRelayBContact: %s\r\n", Charger.m_bUseRelayBContact ? "True" : "False");
}
#endif //FUNC_USE_RELAY_B_CONTACT
#ifdef FUNC_OUTP_TYPE_E
{
//#ifdef FUNC_USE_MODELNAME_TO_JUDGE_TYPEE_ENABLE
// HTK_BOOL bEnableTypeE = HTK_FALSE;
// for (uint8_t i = 7; i <= 9; i++)
// {
// bEnableTypeE |=
// (
// Charger.memory.EVSE_Config.data.item.ModelName[i] == '8' //Type E Socket
// ) ? HTK_TRUE : HTK_FALSE;
//
// }
// Charger.m_bEnableTypeE = bEnableTypeE;
//#else
#ifdef FUNC_ENABLE_TYPE_E_ONLY_IN_AX32
Charger.m_bEnableTypeE = Charger.m_b3PhaseModel;
#else
Charger.m_bEnableTypeE = HTK_TRUE;
#endif
//#endif //FUNC_USE_MODELNAME_TO_JUDGE_TYPEE_ENABLE
XP("#TypeE: %s\r\n", Charger.m_bEnableTypeE ? "Enable" : "Disable");
}
#endif //FUNC_OUTP_TYPE_E
#ifdef FUNC_CP_ADC_MODIFY
#ifdef NEW_CP_SPEC
CpDetectModuleInitialize(Charger.memory.EVSE_Config.data.item.ModelName[3]);
Charger.m_bCpDetectModuleInitOK = 1;
#endif //NEW_CP_SPEC
#endif //FUNC_CP_ADC_MODIFY
#ifdef FUNC_RULE_GB_202108
Charger.m_bSafetyRegulationGB = (Charger.memory.EVSE_Config.data.item.ModelName[3] == 'G');
#endif
#ifdef FUNC_UPDATE_ROTARY_SWITCH_SETTING_AFTER_PARSE_MODELNAME
getRotarySwitchSetting();
#endif
}
void HTK_ByteArray2HexStr(const u8* buf, const u16 BegIdx, const u16 len, char* OutStr, u16 nMaxBytesPerLine, HTK_BOOL bSpace)
{
char sTmp[8] = { 0 };
strcpy(OutStr, "\0");
for (u16 i = BegIdx; i < (BegIdx + len); i++)
{
sprintf(sTmp, bSpace ? "%02X " : "%02X", buf[i]);
strcat(OutStr, sTmp);
if ((i - BegIdx) % nMaxBytesPerLine == (nMaxBytesPerLine - 1))
{
strcat(OutStr, "\r\n");
}
}
}
void HTK_ByteArray2HexStr_XP(const char* Title, const u8* buf, const u16 BegIdx, const u16 len)
{
static char OutStr[1024 * 3 + 8] = { 0 };
HTK_ByteArray2HexStr(buf, BegIdx, len, OutStr, 0, HTK_TRUE);
XP("[%s] %s(%d)\r\n", (Title == NULL ? "" : Title), OutStr, len);
}
void HTK_ByteArray2HexStr_XT(const char* Title, const u8* buf, const u16 BegIdx, const u16 len)
{
static char OutStr[1024 * 3 + 8] = { 0 };
HTK_ByteArray2HexStr(buf, BegIdx, len, OutStr, 0, HTK_TRUE);
XT("[%s] %s(%d)\r\n", (Title == NULL ? "" : Title), OutStr, len);
}
#ifdef ENABLE_PRINT_IMCP_MSG
int CheckPrintImcpMsg(uint8_t MsgID)
{
#ifdef ENABLE_PRINT_IMCP_SPEC_MSG
return
(
// MsgID == PROTOCOL_MESSAGE_CONFIG_PARAMETER
// || MsgID == PROTOCOL_MESSAGE_QUERY_METER_IC_MEAS_PARAMETER
// || MsgID == PROTOCOL_MESSAGE_QUERY_METER_IC_CALI_PARAMETER
// || MsgID == PROTOCOL_MESSAGE_CONFIG_METER_IC_CALI_PARAMETER
MsgID == PROTOCOL_MESSAGE_CONFIG_RELAY_OUTPUT
|| MsgID == PROTOCOL_MESSAGE_CONFIG_MAX_CURRENT_PWM_DUTY
|| MsgID == PROTOCOL_MESSAGE_CONFIG_LEGACY_REQUEST
);
#else
return true;
#endif //ENABLE_PRINT_IMCP_SPEC_MSG
}
#endif //ENABLE_PRINT_IMCP_MSG
#ifdef MODIFY_COLD_LOAD_PICKUP_DELAY
void ColdLoadPickup_Delay(const char* Description)
{
//osDelay((rand()%175000)+5000);
int r = rand();
if (r < 0)
{
r = (-1) * r;
}
//uint32_t dt = (r % 175000) + 5000; //ms
uint32_t dt = (r % (COLD_LOAD_PICKUP_DELAY_TIME_MAX_RANGE_SEC * 1000)) + 5000; //ms
XP("ColdLoadPickup_Delay(ms) [%s]: %d\r\n", Description, dt);
osDelay(dt);
}
#endif
#ifdef MODIFY_CP_TASK_CTRL_CP_PWM
uint16_t GetCpPwmDuty(uint16_t Curr)
{
#ifdef FUNC_AX80
if (Curr > Charger.maxRatingCurrent)
{
Curr = Charger.maxRatingCurrent;
}
#endif
#ifdef FUNC_DETECT_PP
if (Charger.m_bDetectPP)
{
PPPInfo p = &Charger.m_PPInfo;
if (Curr > p->m_CurCurr)
Curr = p->m_CurCurr;
if (p->m_PreCurr != p->m_CurCurr)
p->m_PreCurr = p->m_CurCurr;
}
#endif
#ifdef FUNC_AX80
uint16_t rtn = 0;
if (Curr >= 6 && Curr <= 51)
{
rtn = (uint16_t)((Curr / 0.6) * 10);
}
else if (Curr > 51 && Curr <= 80)
{
rtn = (uint16_t)((Curr / 2.5 + 64) * 10);
}
#else
uint16_t rtn = (uint16_t)((Curr / 0.6) * 10);
#endif
XP("#GetCpPwmDuty(%d) => %d\r\n", Curr, rtn);
return rtn;
}
#endif
#ifdef HTK
u8 GetBit1Num(u32 x)
{
u8 Num = 0;
while (x)
{
Num++;
x &= (x - 1);
}
return Num;
}
HTK_BOOL HTK_IsInTime(u32 BegTick, u32 MaxTick)
{
u32 EndTick = HAL_GetTick();
u32 ElapseTick = (EndTick >= BegTick ? EndTick - BegTick : HTK_U32_MAX - BegTick + EndTick);
return ElapseTick <= MaxTick ? HTK_TRUE : HTK_FALSE;
}
HTK_BOOL HTK_IsTimeout(u32 BegTick, u32 MaxTick)
{
u32 EndTick = HAL_GetTick();
u32 ElapseTick = (EndTick >= BegTick ? EndTick - BegTick : HTK_U32_MAX - BegTick + EndTick);
return ElapseTick > MaxTick ? HTK_TRUE : HTK_FALSE;
}
void HTK_Timer_Reset(PHTK_Timer p)
{
//XP("#\r\n\r\n");
p->m_bStart = HTK_FALSE;
p->m_bTimeout = HTK_FALSE;
p->m_BegTick = 0;
p->m_MaxTick = 0;
}
void HTK_Timer_Start(PHTK_Timer p, u32 MaxTick)
{
//XP("#\r\n\r\n");
p->m_bStart = HTK_TRUE;
p->m_BegTick = HAL_GetTick();
p->m_MaxTick = MaxTick;
}
HTK_BOOL HTK_Timer_CheckTimeout(PHTK_Timer p)
{
// return HTK_IsTimeout(p->m_BegTick, p->m_MaxTick);
HTK_BOOL rtn = HTK_IsTimeout(p->m_BegTick, p->m_MaxTick);
if (rtn == HTK_TRUE)
{
//XP("#\r\n\r\n");
p->m_bTimeout = HTK_TRUE;
}
return rtn;
}
uint8_t HTK_CheckSum_Calulate(uint8_t* pBeg, uint32_t len)
{
if (pBeg != NULL)
{
uint8_t CheckSum = 0;
for (uint32_t i = 0; i < len; i++)
{
CheckSum ^= *(pBeg + i);
}
return CheckSum;
}
else
{
return 0;
}
}
HTK_BOOL HTK_CheckSum_Update(uint8_t* pBeg, uint32_t len, uint8_t* pCheckSum)
{
if (pBeg != NULL && pCheckSum != NULL)
{
uint8_t CheckSum = HTK_CheckSum_Calulate(pBeg, len);
*pCheckSum = CheckSum;
return HTK_TRUE;
}
else
{
return HTK_FALSE;
}
}
HTK_BOOL HTK_CheckSum_IsOK(uint8_t* pBeg, uint32_t len, uint8_t* pCheckSum)
{
if (pBeg != NULL && pCheckSum != NULL)
{
uint8_t CheckSum = HTK_CheckSum_Calulate(pBeg, len);
return (*pCheckSum == CheckSum) ? HTK_TRUE : HTK_FALSE;
}
else
{
return HTK_FALSE;
}
}
HTK_BOOL HTK_HexStrToByteArray(byte* Dst, int DstLen, const char* Src, int SrcLen)
{
if (DstLen * 2 + 1 != SrcLen)
return HTK_FALSE;
char buf[3] = { 0 };
for (int i = 0; i < DstLen; i++)
{
memcpy(buf, &Src[i * 2], 2);
Dst[i] = strtol(buf, NULL, 16);
}
return HTK_TRUE;
}
void HTK_FillChar(char* buf, char c, int count)
{
if (buf != NULL)
{
memset(buf, c, count);
buf[count] = '\0';
}
}
void HTK_PrintRow(char c, int count)
{
enum { MAX = 80 };
static char s_row[MAX + 1] = { 0 };
static int s_count = 0;
if (count > MAX)
{
count = MAX;
}
if (c != s_row[0] || count != s_count)
{
HTK_FillChar(s_row, c, count);
}
s_count = count;
XP("%s\r\n", s_row);
return;
}
static HTK_MallocHandle s_MallocHandle;
void HTK_Malloc_Init(void)
{
memset(&s_MallocHandle, 0, sizeof(s_MallocHandle));
//XP("HTK_Malloc_Init(): %d\r\n", HTK_Malloc_BlockTest(1024));
//XP("HTK_Malloc_Init(): %d\r\n", HTK_Malloc_BlockTest(8000));
XP("HTK_Malloc_Init(): %d\r\n", HTK_Malloc_BlockTest(512));
}
void* HTK_Malloc(s32 size)
{
void* p = malloc(size);
if (p != NULL)
{
s_MallocHandle.m_Allocated += size;
s_MallocHandle.m_Reserved -= size;
memset(p, 0, size);
}
XP("HTK_Malloc(%d) %s\r\n", size, (p == NULL) ? "*** [NG] ***" : "OK");
return p;
}
void HTK_Free(void* p)
{
if (p != NULL)
{
free(p);
p = NULL;
XP("HTK_Free: OK\r\n");
}
}
s32 HTK_Malloc_BlockTest(s32 size)
{
int Total = 0;
for (int i = 1; ; i++)
{
void* p = HTK_Malloc(size);
if (p == NULL)
{
break;
}
else
{
Total += size;
}
}
s_MallocHandle.m_Total = Total;
s_MallocHandle.m_Allocated = 0;
s_MallocHandle.m_Reserved = Total;
return Total;
}
#ifdef FUNC_SALT_AND_BLEND
int Salt(u8* Mixture, int MixtureLen, u8* SaltMap, int SaltMapLen, u8* Data, int DataLen, u8 bRestore)
{
int SaltMapLenMin = GET_BOX_NUM(MixtureLen, 8);
if (Mixture == NULL || SaltMap == NULL || Data == NULL || DataLen > MixtureLen || SaltMapLen < SaltMapLenMin)
return FAIL;
int SaltUsed = 0; //0 ~ (MixtureLen - DataLen)
int i = 0; //0 ~ (MixtureLen - 1)
int j = 0; //0 ~ (DataLen - 1)
if (bRestore)
{
memset(Data, 0, DataLen);
for (; i < MixtureLen; i++)
{
if (BIT_GET(SaltMap[i / 8], i % 8) == 0)
{
Data[j++] = Mixture[i];
if (j == DataLen)
{
return PASS;
}
}
}
}
else
{
memset(Mixture, 0, MixtureLen);
memset(SaltMap, 0, SaltMapLen);
for (; i < MixtureLen; i++)
{
if (rand() % 2 == 0) //insert Data
{
if (j < DataLen)
{
Mixture[i] = Data[j++];
}
else
{
Mixture[i] = rand() % 0x100;
BIT_SET(SaltMap[i / 8], i % 8);
}
}
else //insert Salt
{
if (SaltUsed < (MixtureLen - DataLen))
{
Mixture[i] = rand() % 0x100;
BIT_SET(SaltMap[i / 8], i % 8);
SaltUsed++;
}
else
{
Mixture[i] = Data[j++];
}
}
}
}
return PASS;
}
int Blend(u8* Dst, u8* Src, int Len, u8 ShiftType, u8 bRestore)
{
if (Dst == NULL || Src == NULL || Len == 0)
return FAIL;
int n = 0;
if (ShiftType == 1) //u8
{
for (int i = 0; i < Len; i++)
{
u8 x = Src[i];
n = ((GetBit1Num(x) + i + 3) % 7 + 1) * (bRestore ? (-1) : (1));
Dst[i] = LOOP_SHIFT_U8(x, n);
}
}
// else if (ShiftType == 2) //u16
// {
// for (int i = 0; i < (Len / ShiftType); i += ShiftType)
// {
// u16 x = HTK_U16(Src[i]);
// n = ((GetBit1Num(x) + i + 5) % 15 + 1) * (bRestore ? (-1) : (1));
// HTK_U16(Dst[i]) = LOOP_SHIFT_U16(x, n);
// }
//
// }
// else if (ShiftType == 4) //u32
// {
// for (int i = 0; i < (Len / ShiftType); i += ShiftType)
// {
// u32 x = HTK_U32(Src[i]);
// n = ((GetBit1Num(x) + i + 7) % 31 + 1) * (bRestore ? (-1) : (1));
// HTK_U32(Dst[i]) = LOOP_SHIFT_U32(x, n);
// }
// }
else
{
return FAIL;
}
return PASS;
}
int DataEncryption(u8* Data, int DataLen, u8* EncryptedData, int EncryptedDataLen, u8 bDecryption)
{
enum
{
DATA_LEN = 64,
SALT_LEN = 64,
MIXTURE_LEN = DATA_LEN + SALT_LEN,
SALTMAP_LEN = GET_BOX_NUM(MIXTURE_LEN, 8),
ALL_LEN = MIXTURE_LEN + SALTMAP_LEN,
};
if (DataLen != DATA_LEN || EncryptedDataLen != ALL_LEN)
return FAIL;
u8* p = EncryptedData;
if (bDecryption)
{
#ifdef FUNC_SALT_AND_BLEND_DEBUG
XP("----------------------------\r\n");
HTK_ByteArray2HexStr_XP("EncryptedData", p, 0, ALL_LEN);
#endif
// if (Blend(p, p, ALL_LEN, 4, 1) == FAIL)
// return FAIL;
//#ifdef FUNC_SALT_AND_BLEND_DEBUG
// HTK_ByteArray2HexStr_XP("Blend-Rest-4B", p, 0, ALL_LEN);
//#endif
//
// if (Blend(p, p, ALL_LEN, 2, 1) == FAIL)
// return FAIL;
//#ifdef FUNC_SALT_AND_BLEND_DEBUG
// HTK_ByteArray2HexStr_XP("Blend-Rest-2B", p, 0, ALL_LEN);
//#endif
if (Blend(p, p, ALL_LEN, 1, 1) == FAIL)
return FAIL;
#ifdef FUNC_SALT_AND_BLEND_DEBUG
HTK_ByteArray2HexStr_XP("Blend-Rest-1B", p, 0, ALL_LEN);
#endif
if (Salt(p, MIXTURE_LEN, p + MIXTURE_LEN, SALTMAP_LEN, Data, DataLen, 1) == FAIL)
return FAIL;
#ifdef FUNC_SALT_AND_BLEND_DEBUG
HTK_ByteArray2HexStr_XP("Salt-Restore ", Data, 0, DATA_LEN);
#endif
}
else
{
#ifdef FUNC_SALT_AND_BLEND_DEBUG
XP("----------------------------\r\n");
HTK_ByteArray2HexStr_XP("RAW Data ", Data, 0, DataLen);
#endif
if (Salt(p, MIXTURE_LEN, p + MIXTURE_LEN, SALTMAP_LEN, Data, DataLen, 0) == FAIL)
return FAIL;
#ifdef FUNC_SALT_AND_BLEND_DEBUG
HTK_ByteArray2HexStr_XP("Salt ", p, 0, ALL_LEN);
#endif
if (Blend(p, p, ALL_LEN, 1, 0) == FAIL)
return FAIL;
#ifdef FUNC_SALT_AND_BLEND_DEBUG
HTK_ByteArray2HexStr_XP("Blend-1B ", p, 0, ALL_LEN);
#endif
// if (Blend(p, p, ALL_LEN, 2, 0) == FAIL)
// return FAIL;
//#ifdef FUNC_SALT_AND_BLEND_DEBUG
// HTK_ByteArray2HexStr_XP("Blend-2B ", p, 0, ALL_LEN);
//#endif
//
// if (Blend(p, p, ALL_LEN, 4, 0) == FAIL)
// return FAIL;
//#ifdef FUNC_SALT_AND_BLEND_DEBUG
// HTK_ByteArray2HexStr_XP("Blend-4B ", p, 0, ALL_LEN);
//#endif
}
return PASS;
}
#endif //FUNC_SALT_AND_BLEND
#endif //HTK
#ifdef FUNC_OUTP_TYPE_E
HTK_BOOL IsTypeEPlugIn(void)
{
return HAL_GPIO_ReadPin(IN_SocketE_Detect_GPIO_Port, IN_SocketE_Detect_Pin) ? HTK_FALSE : HTK_TRUE;
}
#endif
#ifdef MODIFY_CPTASK_HEAD
void Proc_CpTaskHead(HTK_BOOL bCSU)
{
if(Charger.Alarm_Code > 0) // alarm occur
{
if(Charger.Mode != MODE_ALARM)
{
#ifdef FUNC_BLOCK_CSU_CMD_SET_DUTY_WHEN_ALARM_CP_F_STATE
Charger.m_bBlockCsuCpPwmDutyWhenAlarmCpF = HTK_TRUE;
#endif
HAL_GPIO_WritePin(OUT_StateE_GPIO_Port, OUT_StateE_Pin, GPIO_PIN_SET);
setChargerMode(MODE_ALARM);
user_pwm_setvalue(PWM_CH_CP, 0);
timerEnable(TIMER_IDX_STATE_E, 4000);
Charger.isAlarmSetPWM = OFF ;
}
// CP E or F to X1
if(timer[TIMER_IDX_STATE_E].isAlarm == ON)
{
HAL_GPIO_WritePin(OUT_StateE_GPIO_Port, OUT_StateE_Pin, GPIO_PIN_RESET);
if ( Charger.isAlarmSetPWM == OFF )
{
Charger.isAlarmSetPWM = ON ;
user_pwm_setvalue(PWM_CH_CP, PWM_DUTY_FULL);
}
#ifdef FUNC_BLOCK_CSU_CMD_SET_DUTY_WHEN_ALARM_CP_F_STATE
if (Charger.m_bBlockCsuCpPwmDutyWhenAlarmCpF)
{
Charger.m_bBlockCsuCpPwmDutyWhenAlarmCpF = HTK_FALSE;
}
#endif
}
}
else
{
if(Charger.Mode != MODE_ALARM)
{
if (!bCSU)
{
HAL_GPIO_WritePin(OUT_StateE_GPIO_Port, OUT_StateE_Pin, GPIO_PIN_RESET); //CCS communication, so skip this line
}
timerDisable(TIMER_IDX_STATE_E);
}
#ifdef FIX_OUTP_PWM_WHEN_ALARM_RECOVER_IN_4SEC
#ifdef FUNC_BLOCK_CSU_CMD_SET_DUTY_WHEN_ALARM_CP_F_STATE
if (Charger.m_bBlockCsuCpPwmDutyWhenAlarmCpF)
{
Charger.m_bBlockCsuCpPwmDutyWhenAlarmCpF = HTK_FALSE;
}
#endif
#endif
}
#ifdef FUNC_GUN_LOCK_TRIG_MODE
if (Charger.m_bUseGunLock)
{
if (Charger.m_GunLockTrigMode == GL_TRIG_MODE_REQUEST)
{
if (Charger.CP_State == SYSTEM_STATE_A && Charger.m_GunLockRequestMode_LockDelayTick != 0)
{
Charger.m_GunLockRequestMode_LockDelayTick = 0;
}
if (Charger.Alarm_Code > 0)
{
if (Charger.Alarm_Code & ALARM_EMERGENCY_STOP)
{
if (Charger.am3352.isRequestOn && !GL_IsLock())
{
if (Charger.CP_State != SYSTEM_STATE_A)
{
GL_Trig(GL_MODE_LOCK);
}
}
else if (!Charger.am3352.isRequestOn && GL_IsLock())
{
GL_Trig(GL_MODE_UNLOCK);
}
}
else //other alarm
{
if (GL_IsLock())
{
GL_Trig(GL_MODE_UNLOCK);
}
}
}
else
{
if (Charger.am3352.isRequestOn && !GL_IsLock())
{
if (Charger.CP_State != SYSTEM_STATE_A)
{
if (Charger.m_GunLockRequestMode_LockDelayTick == 0)
{
Charger.m_GunLockRequestMode_LockDelayTick = HAL_GetTick();
}
else
{
if (HTK_IsTimeout(Charger.m_GunLockRequestMode_LockDelayTick, 3000))
{
GL_Trig(GL_MODE_LOCK);
Charger.m_GunLockRequestMode_LockDelayTick = 0;
}
}
}
}
else if (!Charger.am3352.isRequestOn && GL_IsLock())
{
GL_Trig(GL_MODE_UNLOCK);
}
}
}
}
#endif
}
#endif //MODIFY_CPTASK_HEAD
#ifdef FUNC_FORCE_RUN_CSU_MODE_WITH_DC_MODELNAME
void Update_McuCtrlMode(void)
{
while (!Charger.m_bModelNameDCReadOK)
{
osDelay(100);
}
if (IS_CSU_MOUNTED || Charger.m_bModelNameDC == 1)
{
Charger.memory.EVSE_Config.data.item.MCU_Control_Mode = MCU_CONTROL_MODE_CSU;
DEBUG_INFO("#MCU_CONTROL_MODE_CSU\r\n");
}
else
{
Charger.memory.EVSE_Config.data.item.MCU_Control_Mode = MCU_CONTROL_MODE_NO_CSU;
DEBUG_INFO("#MCU_CONTROL_MODE_NO_CSU\r\n");
if (Charger.memory.EVSE_Config.data.item.AuthMode > AUTH_MODE_FREE)
{
Charger.memory.EVSE_Config.data.item.AuthMode = AUTH_MODE_FREE ;
DEBUG_INFO("#AuthMode set defualt AUTH_MODE_FREE \r\n");
}
if (Charger.memory.EVSE_Config.data.item.OfflinePolicy > RFID_USER_AUTH_NO_CHARGING)
{
Charger.memory.EVSE_Config.data.item.OfflinePolicy = RFID_USER_AUTH_FREE ;
DEBUG_INFO("#OfflinePolicy set defualt RFID_USER_AUTH_FREE \r\n");
}
}
}
#endif //FUNC_FORCE_RUN_CSU_MODE_WITH_DC_MODELNAME
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
void IdleUntilReadAllMemory(void)
{
while (!Charger.m_bReadAllMemory)
{
osDelay(10);
}
}
#endif
#ifdef FUNC_IDLE_UNTIL_INIT_METER_IC
void IdleUntilInitMeterIC(void)
{
while (!Charger.m_bInitMeterIC)
{
osDelay(10);
}
}
#endif
#ifdef FUNC_GUN_LOCK
#define GL_GPIO_IS_LOCK ((HAL_GPIO_ReadPin(IN_LOCK_Status_GPIO_Port, IN_LOCK_Status_Pin) == GPIO_PIN_RESET) ? HTK_FALSE : HTK_TRUE)
#define GL_GPIO_UNLOCK(x) (HAL_GPIO_WritePin(OUT_UNLOCK_L_GPIO_Port, OUT_UNLOCK_L_Pin , ((x) == 0) ? GPIO_PIN_RESET : GPIO_PIN_SET))
#define GL_GPIO_LOCK(x) (HAL_GPIO_WritePin(OUT_LOCK_L_GPIO_Port, OUT_LOCK_L_Pin, ((x) == 0) ? GPIO_PIN_RESET : GPIO_PIN_SET))
#define GL_GPIO_PULSE_WIDTH (290) //must < 300ms
void GL_Init(void)
{
GL_GPIO_LOCK(0);
GL_GPIO_UNLOCK(0);
GL_Unlock();
}
void GL_Lock(void)
{
GL_GPIO_LOCK(1);
osDelay(GL_GPIO_PULSE_WIDTH);
GL_GPIO_LOCK(0);
}
void GL_Unlock(void)
{
GL_GPIO_UNLOCK(1);
osDelay(GL_GPIO_PULSE_WIDTH);
GL_GPIO_UNLOCK(0);
}
HTK_BOOL GL_IsLock(void)
{
return GL_GPIO_IS_LOCK;
}
void GL_Trig(GL_MODE mode)
{
static uint32_t LastTrigTick = 0;
const uint32_t MIN_TRIG_TICK_PERIOD = 500;
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
if (
(mode == GL_MODE_LOCK && Charger.m_GunLock_Counter > GUN_LOCK_PULSE_MAX_TIMES) ||
(mode == GL_MODE_UNLOCK && Charger.m_GunUnlock_Counter > GUN_LOCK_PULSE_MAX_TIMES)
)
{
return;
}
#endif
if (HTK_IsInTime(LastTrigTick, MIN_TRIG_TICK_PERIOD))
{
return;
}
LastTrigTick = HAL_GetTick();
switch(mode)
{
case GL_MODE_UNLOCK:
if (!Charger.m_bTrigGunUnlock) //Trig unlock process
{
Charger.m_bTrigGunUnlock = HTK_TRUE;
timerEnable(TIMER_IDX_GUN_LOCK, GL_GPIO_PULSE_WIDTH);
GL_GPIO_UNLOCK(1);
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
//Charger.m_GunUnlock_Counter++;
XP("#GL Unlock-H (%d)\r\n", Charger.m_GunUnlock_Counter);
#else
XP("#GL Unlock-H\r\n");
#endif
}
break;
case GL_MODE_LOCK:
if (!Charger.m_bTrigGunLock) //Trig lock process
{
Charger.m_bTrigGunLock = HTK_TRUE;
timerEnable(TIMER_IDX_GUN_LOCK, GL_GPIO_PULSE_WIDTH);
GL_GPIO_LOCK(1);
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
//Charger.m_GunLock_Counter++;
XP("#GL Lock-H (%d)\r\n", Charger.m_GunLock_Counter);
#else
XP("#GL Lock-H\r\n");
#endif
}
break;
}
}
void GL_Proc(void)
{
if (timer[TIMER_IDX_GUN_LOCK].isAlarm)
{
if (Charger.m_bTrigGunUnlock)
{
XP("#GL Timer: %d\r\n", (uint32_t)(HAL_GetTick() - timer[TIMER_IDX_GUN_LOCK].startTime));
timerDisable(TIMER_IDX_GUN_LOCK);
Charger.m_bTrigGunUnlock = HTK_FALSE;
GL_GPIO_UNLOCK(0);
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
XP("#GL Unlock-L (%d)\r\n", Charger.m_GunUnlock_Counter);
Charger.m_GunUnlock_Counter++;
#else
XP("#GL Unlock-L\r\n");
#endif
}
if (Charger.m_bTrigGunLock)
{
XP("#GL Timer: %d\r\n", (uint32_t)(HAL_GetTick() - timer[TIMER_IDX_GUN_LOCK].startTime));
timerDisable(TIMER_IDX_GUN_LOCK);
Charger.m_bTrigGunLock = HTK_FALSE;
GL_GPIO_LOCK(0);
#ifdef MODIFY_GUN_LOCK_SPEC_TIMES_TO_ALARM
XP("#GL Lock-L (%d)\r\n", Charger.m_GunLock_Counter);
Charger.m_GunLock_Counter++;
#else
XP("#GL Lock-L\r\n");
#endif
}
}
}
#endif //FUNC_GUN_LOCK
#ifdef FUNC_AX32_TRIG_LEAKAGE
#define TRIG_LEAKAGE_GPIO_IS_TRIGGERING ((HAL_GPIO_ReadPin(OUT_TrigLeakage_GPIO_Port, OUT_TrigLeakage_Pin) == GPIO_PIN_RESET) ? HTK_FALSE : HTK_TRUE)
#define TRIG_LEAKAGE_GPIO_SET(x) (HAL_GPIO_WritePin(OUT_TrigLeakage_GPIO_Port, OUT_TrigLeakage_Pin , ((x) == 0) ? GPIO_PIN_RESET : GPIO_PIN_SET))
#define TRIG_LEAKAGE_GPIO_PULSE_WIDTH (450) //must < 500ms
#define TRIG_LEAKAGE_MAX_TIMES (3)
void TrigLeakage_Init(void)
{
XP("#TrigLeakage_Init\r\n");
TRIG_LEAKAGE_GPIO_SET(0);
}
void TrigLeakage_Trig(void)
{
static uint8_t TrigTimes = 0;
static uint32_t LastTrigTick = 0;
const uint32_t MIN_TRIG_TICK_PERIOD = 3000; //ms
if (HTK_IsInTime(LastTrigTick, MIN_TRIG_TICK_PERIOD))
{
return;
}
LastTrigTick = HAL_GetTick();
if (!Charger.m_bTrigLeakage) //Trig process
{
if (TrigTimes < TRIG_LEAKAGE_MAX_TIMES)
{
TrigTimes++;
XP("#TrigLeakage_Proc (%d)\r\n", TrigTimes);
Charger.m_bTrigLeakage = HTK_TRUE;
timerEnable(TIMER_IDX_TRIG_LEAKAGE, TRIG_LEAKAGE_GPIO_PULSE_WIDTH);
TRIG_LEAKAGE_GPIO_SET(1);
XP("#TRIG_LEAKAGE-H\r\n");
}
else
{
XP("#TrigLeakage_Proc FAIL (MAX Trig times = %d)\r\n", TRIG_LEAKAGE_MAX_TIMES);
}
}
}
//void TrigLeakage_SimpleTrig(void)
//{
// TRIG_LEAKAGE_GPIO_SET(1);
// osDelay(TRIG_LEAKAGE_GPIO_PULSE_WIDTH);
// TRIG_LEAKAGE_GPIO_SET(0);
//}
void TrigLeakage_Proc(void)
{
if (timer[TIMER_IDX_TRIG_LEAKAGE].isAlarm)
{
if (Charger.m_bTrigLeakage)
{
XP("#TRIG_LEAKAGE-Timer: %d\r\n", (uint32_t)(HAL_GetTick() - timer[TIMER_IDX_TRIG_LEAKAGE].startTime));
timerDisable(TIMER_IDX_TRIG_LEAKAGE);
Charger.m_bTrigLeakage = HTK_FALSE;
TRIG_LEAKAGE_GPIO_SET(0);
XP("#TRIG_LEAKAGE-L\r\n");
}
}
}
#endif //FUNC_AX32_TRIG_LEAKAGE
#ifdef MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK
void AlarmDetect_RelayWelding_UseADC(void)
{
#ifdef RELAY_WELDING_PROTECT
#ifdef VO_DISABLE_RELAY_WELDING
if (!Charger.m_VOCode.m_DisableRelayWelding)
#else
if (1)
#endif //VO_DISABLE_RELAY_WELDING
{
uint16_t MAX_FAIL_TIMES = 1000;
if (Charger.GroundingSystem == GROUNGING_SYSTEM_LL || Charger.GroundingSystem == GROUNGING_SYSTEM_LN)
{
if ((Charger.Relay_Action == GPIO_RELAY_ACTION_ON) && (Charger.Relay_isOperationCompleted == 0x11) &&
((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) < (Charger.Voltage[0]*0.011)))
{
#ifdef FUNC_NEW_RELAY_MONITOR
double threshold = Charger.Voltage[0] * //0.01V
Charger.alarm_spec.Relay_LL_DriveFault_Slop +
Charger.alarm_spec.Relay_LL_DriveFault_Offs;
if(adc_value.ADC2_IN5_Welding.value < threshold)
#endif
{
if(Charger.counter.RELAY_Drive_Fualt.fail > MAX_FAIL_TIMES)
{
if(!(Charger.Alarm_Code & ALARM_RELAY_DRIVE_FUALT))
{
Charger.counter.RELAY.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_RELAY_DRIVE_FUALT;
DEBUG_ERROR("Alarm Welding Voltage = %d.\r\n",adc_value.ADC2_IN5_Welding.value);
DEBUG_ERROR("Alarm relay ON status fault occur.\r\n");
}
}
else
{
Charger.counter.RELAY_Drive_Fualt.fail++;
#ifdef DEBUG_RELAY_MONITOR_SHOW_INFO
XP("#RelayDriveFault(%d): W(%.2f) T(%.2f)\r\n",
Charger.counter.RELAY_Drive_Fualt.fail,
adc_value.ADC2_IN5_Welding.value,
threshold);
#endif
}
}
else
{
Charger.counter.RELAY_Drive_Fualt.fail = 0 ;
}
}
else if ((Charger.Relay_Action == GPIO_RELAY_ACTION_OFF) && (Charger.Relay_isOperationCompleted == 0x00) &&
((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) < (Charger.Voltage[0]*0.011)))
{
#ifdef FUNC_NEW_RELAY_MONITOR
double threshold =
Charger.Voltage[0] * //0.01V
Charger.alarm_spec.Relay_LL_Welding_Slop +
Charger.alarm_spec.Relay_LL_Welding_Offs;
if(adc_value.ADC2_IN5_Welding.value > threshold)
#endif
{
if(Charger.counter.RELAY.fail > MAX_FAIL_TIMES)
{
if(!(Charger.Alarm_Code & ALARM_RELAY_STATUS))
{
Charger.counter.RELAY.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_RELAY_STATUS;
#ifdef FUNC_AX32_TRIG_LEAKAGE
Charger.AlarmRelayWeldingOccurTick = HAL_GetTick();
#endif
DEBUG_ERROR("Alarm Welding Voltage = %d.\r\n",adc_value.ADC2_IN5_Welding.value);
DEBUG_ERROR("Alarm relay OFF status fault occur.\r\n");
}
}
else
{
Charger.counter.RELAY.fail++;
#ifdef DEBUG_RELAY_MONITOR_SHOW_INFO
XP("#RelayWelding(%d): W(%.2f) T(%.2f)\r\n",
Charger.counter.RELAY.fail,
adc_value.ADC2_IN5_Welding.value,
threshold);
#endif
}
}
else
{
Charger.counter.RELAY.fail = 0 ;
}
}
}
//-------------------------------------------------
}
#endif //RELAY_WELDING_PROTECT
}
#ifdef FUNC_USE_RELAY_B_CONTACT
HTK_BOOL IsRelayContact_Closed(void)
{
return HAL_GPIO_ReadPin(IN_Relay_b_Contact_GPIO_Port, IN_Relay_b_Contact_Pin) == GPIO_PIN_SET ? HTK_TRUE : HTK_FALSE;
}
void AlarmDetect_RelayWelding_UseGPIO(void)
{
#ifdef RELAY_WELDING_PROTECT
#ifdef VO_DISABLE_RELAY_WELDING
if (!Charger.m_VOCode.m_DisableRelayWelding)
#else
if (1)
#endif //VO_DISABLE_RELAY_WELDING
{
uint16_t MAX_FAIL_TIMES = 1000;
if (Charger.GroundingSystem == GROUNGING_SYSTEM_LL || Charger.GroundingSystem == GROUNGING_SYSTEM_LN)
{
if ((Charger.Relay_Action == GPIO_RELAY_ACTION_ON) && (Charger.Relay_isOperationCompleted == 0x11) &&
((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) < (Charger.Voltage[0]*0.011)))
{
if (!IsRelayContact_Closed())
{
if(Charger.counter.RELAY_Drive_Fualt.fail > MAX_FAIL_TIMES)
{
if(!(Charger.Alarm_Code & ALARM_RELAY_DRIVE_FUALT))
{
Charger.counter.RELAY.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_RELAY_DRIVE_FUALT;
//DEBUG_ERROR("Alarm Welding Voltage = %d.\r\n",adc_value.ADC2_IN5_Welding.value);
DEBUG_ERROR("Alarm relay ON status fault occur.\r\n");
}
}
else
{
Charger.counter.RELAY_Drive_Fualt.fail++;
}
}
else
{
Charger.counter.RELAY_Drive_Fualt.fail = 0 ;
}
}
else if ((Charger.Relay_Action == GPIO_RELAY_ACTION_OFF) && (Charger.Relay_isOperationCompleted == 0x00) &&
((adc_value.ADC3_IN4_GMI_VL1.value*100*3.3/4095) < (Charger.Voltage[0]*0.011)))
{
if (IsRelayContact_Closed())
{
if(Charger.counter.RELAY.fail > MAX_FAIL_TIMES)
{
if(!(Charger.Alarm_Code & ALARM_RELAY_STATUS))
{
Charger.counter.RELAY.isOccurInCharging = (((Charger.Mode == MODE_CHARGING) || (Charger.Mode == MODE_STOP))?ON:OFF);
Charger.Alarm_Code |= ALARM_RELAY_STATUS;
#ifdef FUNC_AX32_TRIG_LEAKAGE
Charger.AlarmRelayWeldingOccurTick = HAL_GetTick();
#endif
//DEBUG_ERROR("Alarm Welding Voltage = %d.\r\n",adc_value.ADC2_IN5_Welding.value);
DEBUG_ERROR("Alarm relay OFF status fault occur.\r\n");
}
}
else
{
Charger.counter.RELAY.fail++;
}
}
else
{
Charger.counter.RELAY.fail = 0 ;
}
}
}
}
#endif //RELAY_WELDING_PROTECT
}
#endif //FUNC_USE_RELAY_B_CONTACT
#endif //MODIFY_ALARM_DETECT_RELAY_WELDING_BLOCK
#ifdef MODIFY_DC_RS485_UPGRADE_ISSUE
void RS485_TX_Enable(void)
{
HAL_GPIO_WritePin(OUT_Meter_485_DE_GPIO_Port, OUT_Meter_485_DE_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(OUT_Meter_485_RE_GPIO_Port, OUT_Meter_485_RE_Pin, GPIO_PIN_SET);
osDelay(1);
}
void RS485_TX_Disable(void)
{
HAL_GPIO_WritePin(OUT_Meter_485_DE_GPIO_Port, OUT_Meter_485_DE_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(OUT_Meter_485_RE_GPIO_Port, OUT_Meter_485_RE_Pin, GPIO_PIN_RESET);
}
void Prefix_UartTX(uint8_t* TxBuf, uint8_t* RxBuf)
{
if (RxBuf == UART_RS485_rx_buffer)
{
RS485_TX_Enable();
TxBuf[1] = Charger.m_RS485SlaveAddr; //Update Slave Address
}
}
void Postfix_UartTX(uint8_t* TxBuf, uint8_t* RxBuf)
{
if (RxBuf == UART_RS485_rx_buffer)
{
RS485_TX_Disable();
}
}
#endif //MODIFY_DC_RS485_UPGRADE_ISSUE
#ifdef FUNC_AX80_ADD_TILT_SENSOR
//#define TILT_GPIO_IS_ACTION_ON ((HAL_GPIO_ReadPin(IN_Tilt_ActOn_GPIO_Port, IN_Tilt_ActOn_Pin) == GPIO_PIN_RESET) ? HTK_FALSE : HTK_TRUE)
//#define TILT_GPIO_TEST_SET(x) (HAL_GPIO_WritePin(OUT_Tilt_Test_GPIO_Port, OUT_Tilt_Test_Pin , ((x) == 0) ? GPIO_PIN_RESET : GPIO_PIN_SET))
#define TILT_GPIO_IS_ACTION_ON ((HAL_GPIO_ReadPin(IN_Tilt_ActOn_GPIO_Port, IN_Tilt_ActOn_Pin) == GPIO_PIN_RESET) ? HTK_TRUE : HTK_FALSE)
#define TILT_GPIO_TEST_SET(x) (HAL_GPIO_WritePin(OUT_Tilt_Test_GPIO_Port, OUT_Tilt_Test_Pin , ((x) == 0) ? GPIO_PIN_RESET : GPIO_PIN_SET))
#define TILT_TRIG_LEAKAGE_GPIO_IS_TRIGGERING ((HAL_GPIO_ReadPin(OUT_Tilt_DrvLeakage_GPIO_Port, OUT_Tilt_DrvLeakage_Pin) == GPIO_PIN_RESET) ? HTK_FALSE : HTK_TRUE)
#define TILT_TRIG_LEAKAGE_GPIO_SET(x) (HAL_GPIO_WritePin(OUT_Tilt_DrvLeakage_GPIO_Port, OUT_Tilt_DrvLeakage_Pin , ((x) == 0) ? GPIO_PIN_RESET : GPIO_PIN_SET))
#define TILT_TRIG_LEAKAGE_GPIO_PULSE_WIDTH (450) //must < 500ms
#define TILT_TRIG_LEAKAGE_MAX_TIMES (3)
void TILT_TrigLeakage_Init(void)
{
XP("#TILT_TrigLeakage_Init\r\n");
TILT_TRIG_LEAKAGE_GPIO_SET(0);
TILT_GPIO_TEST_SET(1);
osDelay(1);
if (TILT_GPIO_IS_ACTION_ON)
{
XP("#Tilt sensor test OK\r\n");
}
else
{
XP("#Tilt sensor test [NG]\r\n");
}
TILT_GPIO_TEST_SET(0);
}
void TILT_TrigLeakage_Trig(void)
{
static uint8_t TrigTimes = 0;
static uint32_t LastTrigTick = 0;
const uint32_t MIN_TRIG_TICK_PERIOD = 3000; //ms
if (HTK_IsInTime(LastTrigTick, MIN_TRIG_TICK_PERIOD))
{
return;
}
LastTrigTick = HAL_GetTick();
if (!Charger.m_bTILT_TrigLeakage) //Trig process
{
if (TrigTimes < TILT_TRIG_LEAKAGE_MAX_TIMES)
{
TrigTimes++;
XP("#TILT_TrigLeakage_Proc (%d)\r\n", TrigTimes);
Charger.m_bTILT_TrigLeakage = HTK_TRUE;
timerEnable(TIMER_IDX_TILT_TRIG_LEAKAGE, TILT_TRIG_LEAKAGE_GPIO_PULSE_WIDTH);
TILT_TRIG_LEAKAGE_GPIO_SET(1);
XP("#TILT_TRIG_LEAKAGE-H\r\n");
}
else
{
XP("#TILT_TrigLeakage_Proc FAIL (MAX Trig times = %d)\r\n", TILT_TRIG_LEAKAGE_MAX_TIMES);
}
}
}
//void TILT_TrigLeakage_SimpleTrig(void)
//{
// TILT_TRIG_LEAKAGE_GPIO_SET(1);
// osDelay(TILT_TRIG_LEAKAGE_GPIO_PULSE_WIDTH);
// TILT_TRIG_LEAKAGE_GPIO_SET(0);
//}
void TILT_TrigLeakage_Proc(void)
{
if (timer[TIMER_IDX_TILT_TRIG_LEAKAGE].isAlarm)
{
if (Charger.m_bTILT_TrigLeakage)
{
XP("#TILT_TRIG_LEAKAGE-Timer: %d\r\n", (uint32_t)(HAL_GetTick() - timer[TIMER_IDX_TILT_TRIG_LEAKAGE].startTime));
timerDisable(TIMER_IDX_TILT_TRIG_LEAKAGE);
Charger.m_bTILT_TrigLeakage = HTK_FALSE;
TILT_TRIG_LEAKAGE_GPIO_SET(0);
XP("#TILT_TRIG_LEAKAGE-L\r\n");
}
}
}
void AlarmDetect_TiltSensor(void)
{
#ifdef VO_DISABLE_DETECT_TILT_SENSOR
if (!Charger.m_VOCode.m_DisableDetectTiltSensor)
#else
if (1)
#endif
{
uint16_t MAX_FAIL_TIMES = 1000;
if (TILT_GPIO_IS_ACTION_ON)
{
if (Charger.counter.TiltSensor.fail > MAX_FAIL_TIMES)
{
if(!(Charger.Alarm_Code & ALARM_TILT_SENSOR))
{
Charger.Alarm_Code |= ALARM_TILT_SENSOR;
Charger.AlarmTiltSensorOccurTick = HAL_GetTick();
DEBUG_ERROR("Alarm tilt sensor fault occur.\r\n");
}
}
else
{
Charger.counter.TiltSensor.fail++;
}
}
else
{
Charger.counter.TiltSensor.fail = 0 ;
}
}
}
#endif //FUNC_AX80_ADD_TILT_SENSOR
#ifdef FUNC_TASK_MONITOR
void StartMonitorTask(void const * argument)
{
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
IdleUntilReadAllMemory();
#endif
memset(&Charger.m_TaskMonitor, 0, sizeof(Charger.m_TaskMonitor));
#ifdef FUNC_MODIFY_TASK_MONITOR_20231227
enum { ADC_RESET_MAX = 1 };
#else
enum { ADC_RESET_MAX = 10 };
#endif
while (1)
{
//ADC
{
static PTaskADCInfo p = &Charger.m_TaskMonitor.m_ADC;
if (
(
p->m_ADC1_Counter[0] != 0 &&
p->m_ADC2_Counter[0] != 0 &&
p->m_ADC3_Counter[0] != 0
)
&&
(
p->m_ADC1_Counter[0] == p->m_ADC1_Counter[1] ||
p->m_ADC2_Counter[0] == p->m_ADC2_Counter[1] ||
p->m_ADC3_Counter[0] == p->m_ADC3_Counter[1]
)
)
{
p->m_ContinueResetCounter++;
p->m_TotalResetCounter++;
XP("#TaskMonitor: ADC[%d/%d](%d, %d, %d) ADC->SR(0x%04X, 0x%04X, 0x%04X) => [NG] Reset %s\r\n",
p->m_ContinueResetCounter, p->m_TotalResetCounter,
p->m_ADC1_Counter[0],
p->m_ADC2_Counter[0],
p->m_ADC3_Counter[0], ADC1->SR, ADC2->SR, ADC3->SR,
p->m_ContinueResetCounter > ADC_RESET_MAX ? "MCU" : "ADC");
if (p->m_ContinueResetCounter > ADC_RESET_MAX)
{
NVIC_SystemReset();
}
else
{
isDMAEnd_ADC1 = OFF;
isDMAEnd_ADC2 = OFF;
isDMAEnd_ADC3 = OFF;
HAL_ADC_Stop_DMA(&hadc1);
HAL_ADC_Stop_DMA(&hadc2);
HAL_ADC_Stop_DMA(&hadc3);
//__HAL_ADC_CLEAR_FLAG(&hadc1, ADC_FLAG_STRT);
//__HAL_ADC_CLEAR_FLAG(&hadc2, ADC_FLAG_STRT);
//__HAL_ADC_CLEAR_FLAG(&hadc3, ADC_FLAG_STRT);
MX_DMA_Init();
MX_ADC1_Init();
MX_ADC2_Init();
MX_ADC3_Init();
if(HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&ADC1_Buffer, ADC1_CHANEL_COUNT*ADC1_SAMPLE_COUNT)!=HAL_OK)Error_Handler();
if(HAL_ADC_Start_DMA(&hadc2, (uint32_t*)&ADC2_Buffer, ADC2_CHANEL_COUNT*ADC2_SAMPLE_COUNT)!=HAL_OK)Error_Handler();
if(HAL_ADC_Start_DMA(&hadc3, (uint32_t*)&ADC3_Buffer, ADC3_CHANEL_COUNT*ADC3_SAMPLE_COUNT)!=HAL_OK)Error_Handler();
}
}
else
{
p->m_ContinueResetCounter = 0;
p->m_ADC1_Counter[1] = p->m_ADC1_Counter[0];
p->m_ADC2_Counter[1] = p->m_ADC2_Counter[0];
p->m_ADC3_Counter[1] = p->m_ADC3_Counter[0];
}
}
osDelay(300);
}
}
#endif //FUNC_TASK_MONITOR
#ifdef FUNC_RS485_BLE_SW
void RS485_SW(HTK_BOOL bON)
{
XP("#\r\n", (bON ? "ON" : "OFF"));
HAL_GPIO_WritePin(RS485_SW_GPIO_Port, RS485_SW_Pin, bON ? GPIO_PIN_SET : GPIO_PIN_RESET);
}
void BLE_SW(HTK_BOOL bON)
{
XP("#\r\n", (bON ? "ON" : "OFF"));
HAL_GPIO_WritePin(BLE_SW_GPIO_Port, BLE_SW_Pin, bON ? GPIO_PIN_SET : GPIO_PIN_RESET);
}
#endif //FUNC_RS485_BLE_SW
#ifdef FUNC_LIN_EN_SW
void LIN_EN(HTK_BOOL bEnable)
{
XP("#\r\n", (bEnable ? "Enable" : "Disable"));
HAL_GPIO_WritePin(OUT_USB_DriveBus_GPIO_Port, OUT_USB_DriveBus_Pin, bEnable ? GPIO_PIN_SET : GPIO_PIN_RESET);
}
void LIN_SW(HTK_BOOL bUseLIN)
{
XP("#\r\n", (bUseLIN ? "LIN" : "PWM"));
//TMUX6219 Table8-1
// EN SEL Select Source
// 0 X All off
// 1 0 S1 (CP-LIN)
// 1 1 S2 (CP-PWM)
HAL_GPIO_WritePin(LIN_PWM_SW_GPIO_Port, LIN_PWM_SW_Pin, bUseLIN ? GPIO_PIN_RESET : GPIO_PIN_SET);
}
#endif //FUNC_LIN_EN_SW
#ifdef FUNC_LIN_CP
void StartLinCpTask(void const * argument)
{
#ifdef FUNC_IDLE_UNTIL_READ_ALL_MEM
IdleUntilReadAllMemory();
#endif
do
{
osDelay(1000);
}
while (!Charger.m_bUseLinCP);
static PLinCP p = NULL;
if (p == NULL)
{
p = (PLinCP)HTK_Malloc(sizeof(LinCP));
if (p != NULL)
{
Charger.m_pLinCP = p;
LIN_Init(p, USART1);
}
}
LIN_EN(HTK_TRUE);
//Test
//LIN_SW(HTK_TRUE);
//LIN_SW(HTK_FALSE);
// SeVersionList data;
// memset(&data, 0, sizeof(data));
// data.SeSelectedVersion = 0x01;
// data.B1 = 0x02;
// data.SeVersionPageNumber = 0x03;
// data.SeSupportedVersion1 = 0x04;
// data.SeSupportedVersion2 = 0x05;
// data.SeSupportedVersion3 = 0x06;
// data.SeSupportedVersion4 = 0x07;
// data.SeSupportedVersion5 = 0x08;
while (1)
{
// LIN_TxHeaderData(p, LINCPID_SE_VERSION_LIST, &data, sizeof(data));
// osDelay(30);
// LIN_TxHeader(p, LINCPID_EV_VERSION_LIST);
// osDelay(30);
osDelay(1000);
}
}
#endif //FUNC_LIN_CP
#ifdef FUNC_AW48_NET_LED
void Proc_NetLedActionSubState(void)
{
if (Charger.am3352.NetLedActionState == NET_LED_ACTION_ALL_CONNECTING)
{
//if(blinker[BLINKER_IDX_LED_NET].blinkisFinish)
{
if (Charger.am3352.NetLedActionSubState == NET_LED_ACTION_LTE_CONNECTING_H)
{
setNetLedMotion(Charger.am3352.NetLedActionSubState = NET_LED_ACTION_WIFI_CONNECTING_H);
}
else if (Charger.am3352.NetLedActionSubState == NET_LED_ACTION_WIFI_CONNECTING_H)
{
setNetLedMotion(Charger.am3352.NetLedActionSubState = NET_LED_ACTION_ETHERNET_CONNECTING_H);
}
else if (Charger.am3352.NetLedActionSubState == NET_LED_ACTION_ETHERNET_CONNECTING_H)
{
setNetLedMotion(Charger.am3352.NetLedActionSubState = NET_LED_ACTION_LTE_CONNECTING_H);
}
}
}
}
#endif //FUNC_AW48_NET_LED
#ifdef FUNC_AES256
HTK_BOOL AES256_Verify(u8* Data, int DataLen, u8* Key, u8* IV, u8* RemoteEncryptedData)
{
u8 PlainData[16] = { 0 };
memcpy(PlainData, Data, HTK_GET_VAL_MIN(DataLen, 16));
u8 EncryptedData[16];
size_t encryptedSize;
// Fill padding data to 16 byte with PKCS7
PKCS7_Pad(PlainData, 4, 16, PlainData);
//XP("strlen((char*)PlainData) = %d\r\n", strlen((char*)PlainData)); //??????????????????
// Encrypt data
//AES256MainCBC(Key, PlainData, IV, strlen((char*)PlainData), EncryptedData, &encryptedSize, true);
AES256MainCBC(Key, PlainData, IV, 16, EncryptedData, &encryptedSize, true);
// DEBUG_INFO("AES256 Check ============================================\r\n");
// DEBUG_INFO("EncryptedSize: %d\r\n", encryptedSize);
// for(uint8_t idx=0;idx<16;idx++)
// DEBUG_INFO("PlainData[%d]: %02X\r\n", idx, PlainData[idx]);
HTK_BOOL bRes = HTK_TRUE;
for(uint8_t idx=0;idx<16;idx++)
{
// DEBUG_INFO("EncryptedData[%d]: %02X, RemoteEncryptedData[%d]: %02X\r\n",
// idx, EncryptedData[idx], idx, RemoteEncryptedData[idx]);
if (RemoteEncryptedData[idx] != EncryptedData[idx])
{
bRes = HTK_FALSE;
break;
}
}
if (bRes)
{
DEBUG_INFO("\r\n");
return HTK_TRUE;
}
else
{
DEBUG_INFO("\r\n");
return HTK_FALSE;
}
}
void AES256_Test(void)
{
/* AES test */
uint8_t Key[32] =
{
0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12
};
uint8_t IV[] =
{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
};
uint8_t PlainData[] =
{
0x11, 0x22, 0x33, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
uint8_t encryptedData[16];
size_t encryptedSize;
// Fill padding data to 16 byte with PKCS7
PKCS7_Pad(PlainData, 4, 16, PlainData);
// Encrypt data
AES256MainCBC((u8*)Key, PlainData, IV, strlen((char*)PlainData), encryptedData, &encryptedSize, true);
DEBUG_INFO("encryptedSize: %d\r\n", encryptedSize);
for(uint8_t idx=0;idx<16;idx++)
DEBUG_INFO("PlainData[%d]: %02X\r\n", idx, PlainData[idx]);
for(uint8_t idx=0;idx<16;idx++)
DEBUG_INFO("encryptedData[%d]: %02X\r\n", idx, encryptedData[idx]);
{
u8 Data[4] = { 0x11, 0x22, 0x33, 0x44 };
AES256_Verify(Data, 4, (u8*)Key, IV, encryptedData);
}
}
#endif //FUNC_AES256
#ifdef FUNC_ECDSA
HTK_BOOL ECDSA_Verify(u8* PublicKey, int PublicKeyLen, u8* Hash, int HashLen, u8* Signature, int SignatureLen)
{
cmox_ecc_handle_t Ecc_Ctx;
cmox_ecc_retval_t retval;
uint32_t fault_check = 0;
if (PublicKeyLen != 64 || HashLen != 32 || SignatureLen != 64)
{
return HTK_FALSE;
}
enum { WORKING_BUFFER_SIZE = 2000 };
uint8_t* Working_Buffer = (uint8_t*)HTK_Malloc(WORKING_BUFFER_SIZE);
if (Working_Buffer == NULL)
{
return HTK_FALSE;
}
HTK_BOOL bRtn = HTK_FALSE;
if (cmox_initialize(NULL) != CMOX_INIT_SUCCESS)
{
XP("\r\n");
bRtn = HTK_FALSE;
}
else
{
cmox_ecc_construct(&Ecc_Ctx, CMOX_ECC256_MATH_FUNCS, Working_Buffer, WORKING_BUFFER_SIZE);
for(uint8_t idx=0;idx<2;idx++) //2nd function call will get the correct result
{
retval = cmox_ecdsa_verify(
&Ecc_Ctx, /* ECC context */
#ifdef FUNC_CSU_VERIFY_USE_ECDSA_CMOX_ECC_CURVE_SECP256R1
CMOX_ECC_CURVE_SECP256R1, //more safe then SECP256K1
#else
CMOX_ECC_CURVE_SECP256K1, /* SECP256K1 ECC curve selected */
#endif
PublicKey, PublicKeyLen, /* Public key for verification */
Hash, CMOX_SHA256_SIZE, /* Digest to verify */
Signature, SignatureLen, /* Data buffer to receive signature */
&fault_check); /* Fault check variable: to ensure no fault injection occurs during this API call */
static char* CMOX_ECC_RETVAL_STR[] =
{
"UNKNOW", //0
"SUCCESS", //1
"ERR_INTERNAL", //2
"ERR_BAD_PARAMETERS", //3
"ERR_INVALID_PUBKEY", //4
"ERR_INVALID_SIGNATURE", //5
"ERR_WRONG_RANDOM", //6
"ERR_MEMORY_FAIL", //7
"ERR_MATHCURVE_MISMATCH", //8
"ERR_ALGOCURVE_MISMATCH", //9
"AUTH_SUCCESS", //10
"AUTH_FAIL" //11
};
int StrIdx = 0;
switch (retval)
{
case CMOX_ECC_SUCCESS: StrIdx = 1; break;
case CMOX_ECC_ERR_INTERNAL: StrIdx = 2; break;
case CMOX_ECC_ERR_BAD_PARAMETERS: StrIdx = 3; break;
case CMOX_ECC_ERR_INVALID_PUBKEY: StrIdx = 4; break;
case CMOX_ECC_ERR_INVALID_SIGNATURE: StrIdx = 5; break;
case CMOX_ECC_ERR_WRONG_RANDOM: StrIdx = 6; break;
case CMOX_ECC_ERR_MEMORY_FAIL: StrIdx = 7; break;
case CMOX_ECC_ERR_MATHCURVE_MISMATCH: StrIdx = 8; break;
case CMOX_ECC_ERR_ALGOCURVE_MISMATCH: StrIdx = 9; break;
case CMOX_ECC_AUTH_SUCCESS: StrIdx = 10; break;
case CMOX_ECC_AUTH_FAIL: StrIdx = 11; break;
default: StrIdx = 0; break;
}
XP("[%d] retval = 0x%08X (CMOX_ECC_%s), fault_check = 0x%08X\r\n", idx, retval, CMOX_ECC_RETVAL_STR[StrIdx], fault_check);
}
/* Verify API returned value */
//XP("retval = 0x%08X, fault_check = 0x%08X\r\n", retval, fault_check);
if ((retval == CMOX_ECC_AUTH_SUCCESS) && (fault_check == CMOX_ECC_AUTH_SUCCESS))
{
XP("\r\n");
bRtn = HTK_TRUE;
}
else
{
XP("\r\n");
bRtn = HTK_FALSE;
}
cmox_ecc_cleanup(&Ecc_Ctx);
}
HTK_Free(Working_Buffer);
return bRtn;
}
void ECDSA_VerifyTest(void)
{
u8 Public_Key[] =
{
0x5A, 0x3D, 0x38, 0xEC, 0x72, 0x37, 0xA1, 0xB5, 0xF5, 0x2F, 0x3C, 0x34, 0x3C, 0x6E, 0x73, 0xBE,
0x31, 0x9B, 0x15, 0x13, 0xF5, 0x92, 0x9B, 0xE9, 0xD3, 0x9A, 0xD0, 0x43, 0xA7, 0xBC, 0xD1, 0x26,
0x81, 0x9C, 0x9A, 0x48, 0x1A, 0x3B, 0xE5, 0x32, 0xEE, 0xA9, 0x9D, 0x3C, 0x67, 0x30, 0x21, 0x63,
0xF4, 0x26, 0x56, 0x22, 0xE5, 0x39, 0x49, 0xEC, 0x54, 0x63, 0x6D, 0x2E, 0x98, 0x40, 0xE0, 0x19
};
u8 Known_Hash[] =
{
0xB2, 0xED, 0x99, 0x21, 0x86, 0xA5, 0xCB, 0x19, 0xF6, 0x66, 0x8A, 0xAD, 0xE8, 0x21, 0xF5, 0x02,
0xC1, 0xD0, 0x09, 0x70, 0xDF, 0xD0, 0xE3, 0x51, 0x28, 0xD5, 0x1B, 0xAC, 0x46, 0x49, 0x91, 0x6C
};
u8 Known_Signature[] =
{
0x0F, 0x80, 0xBE, 0x7F, 0x68, 0xE9, 0x73, 0x80, 0x22, 0x9A, 0xFF, 0x81, 0xEC, 0xE4, 0xE8, 0xCA,
0xB7, 0x5D, 0xF6, 0x2D, 0x69, 0xEC, 0x06, 0xB9, 0xCA, 0x6D, 0x14, 0x72, 0x7A, 0x1C, 0xBE, 0xA7,
0xC7, 0xE5, 0x1A, 0xF3, 0x43, 0x7D, 0xFD, 0x60, 0x04, 0x5B, 0xE7, 0xF1, 0xB8, 0x9C, 0xEA, 0x19,
0xE8, 0x1D, 0xF0, 0xA7, 0xA7, 0x4F, 0xE3, 0x39, 0xFE, 0xB8, 0x0B, 0xF2, 0xFA, 0x1A, 0x93, 0x44
};
ECDSA_Verify(Public_Key, sizeof(Public_Key), Known_Hash, sizeof(Known_Hash), Known_Signature, sizeof(Known_Signature));
}
#endif //FUNC_ECDSA
#ifdef FUNC_VERIFY_TASK
void StartVerifyTask(void const * argument)
{
static u8* p = Charger.m_VerifyTaskRxBuf;
#ifdef FUNC_CSU_VERIFY_USE_ECDSA
static u8* pKey = Charger.memory.EVSE_Config.data.item.m_CsuPublicKey;
#else
//Generator: https://seanwasere.com/generate-random-hex/
const u8 AES256_KEY[32] =
{
0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12
};
#endif
while (1)
{
//#ifdef FIXHW_AW48_CSU_EXIST_DELAY_CHECK
// if (Charger.m_bModelNameAW48_1P && Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
// {
// AW48_CheckCSU();
// }
//#endif
if (Charger.m_bCsuSignInMustVerify || Charger.m_bCsuUpgradeFwMustVerify)
{
if (Charger.m_bCsuSignInMustVerify && !Charger.m_bCsuSignInVerifyOK && Charger.m_bRunCsuSignInVerify)
{
#ifdef FUNC_CSU_VERIFY_USE_ECDSA
Charger.m_bCsuSignInVerifyOK = ECDSA_Verify(pKey, CSU_PUBLIC_KEY_LEN, &p[10], 32, &p[42], 64);
#else
Charger.m_bCsuSignInVerifyOK = AES256_Verify(&p[6], 4, (u8*)AES256_KEY, &p[10], &p[26]);
#endif
Charger.m_bRunCsuSignInVerify = HTK_FALSE;
if (Charger.m_bCsuSignInVerifyOK && Charger.memory.EVSE_Config.data.item.MCU_Control_Mode == MCU_CONTROL_MODE_NO_CSU)
{
Update_McuCtrlMode();
}
}
else if (Charger.m_bCsuUpgradeFwMustVerify && !Charger.m_bCsuUpgradeFwVerifyOK && Charger.m_bRunCsuUpgradeFwVerify)
{
#ifdef FUNC_CSU_VERIFY_USE_ECDSA
Charger.m_bCsuUpgradeFwVerifyOK = ECDSA_Verify(pKey, CSU_PUBLIC_KEY_LEN, &p[10], 32, &p[42], 64);
#else
Charger.m_bCsuUpgradeFwVerifyOK = AES256_Verify(&p[6], 4, (u8*)AES256_KEY, &p[10], &p[26]);
#endif
Charger.m_bRunCsuUpgradeFwVerify = HTK_FALSE;
}
}
osDelay(100);
}
}
#endif //FUNC_VERIFY_TASK
/* USER CODE END Application */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/