SmartPDCode/control/PDU-DC_UPGRADE/App/Main/Main.c

/*********************************************************************************************************
* 模块名称：Main.c
* 摘    要：主文件，包含软硬件初始化函数和main函数
* 当前版本：1.0.0
* 作    者：anycrying
* 完成日期：2024年04月12日
* 内    容：
* 注    意：注意勾选Options for Target 'Target1'->Code Generation->Use MicroLIB，否则printf无法使用                                                                  
**********************************************************************************************************
* 取代版本：
* 作    者：
* 完成日期：
* 修改内容：
* 修改文件：
*********************************************************************************************************/

/*********************************************************************************************************
*                                              包含头文件
*********************************************************************************************************/
#include "Main.h"
//#include "gd32e230x_conf.h"
#include "string.h"
#include "NVIC.h"
#include "SysTick.h"
#include "Rcu.h"
#include "Timer.h"
#include "Led.h"
#include "Key.h"
#include "Relay.h"
#include "Uart1.h"
#include "mb.h"
#include "IM1253E.h"
#include "At24cxx.h"
#include "I2c.h"
#include "ReadEeprom.h"
#include "Sn74hc573.h"
#include "Sn74hc595.h"
#include <stdbool.h>
#include "ADC.h"
#include "Fwdgt.h"
#include "ch442e.h"
#include "detection.h"
#include "cfg.h"
#include "Flash.h"
/*********************************************************************************************************
*                                              宏定义
*********************************************************************************************************/

/*********************************************************************************************************
*                                              枚举结构体
*********************************************************************************************************/
DCPDU_RELAY_Para_Reg DCPDU_RL_time;
DC_SUM_Para_struct_Reg DCPDU_Input;
DC_Output_struct_Reg DCPDU_Output[RELAY_ChN_default]; 
/*********************************************************************************************************
*                                              内部变量定义
*********************************************************************************************************/

static  uint8_t channel = 0;
unsigned long int Delay_Ms_1 = 0;
static  uint8_t Delay_End_flag = 0;


bool Load_conn_end_flag = false;
bool Init_IM1253E_flag = false;
bool Start_Read_Flag;						//开始读取数据标志
bool RL_Allon_flag = false;
bool RL_Alloff_flag = false;
bool Read_IM1253E_flag = false;
bool Fault_stFlag_V = true;
bool Wr_eeprom_begin_flag = false;
bool IM1253E_OK_flag = false;

static  uint8_t DCPDU_SlaveAddress = 0x00;
uint8_t cnt = 0;
uint16_t Wr_erom_wait_cnt = 0;
uint8_t Wr_eeprom_cnt = 0;
uint8_t Active_state_bit = 0xff;
uint8_t RL_begin_delay_flag[RELAY_ChN_default] = {0x00};
uint8_t RL_ON_flag[RELAY_ChN_default] = {0x00};
uint8_t RL_OFF_flag[RELAY_ChN_default] = {0x00};
uint8_t RL_end_delay_flag[RELAY_ChN_default] = {0x00};
uint8_t RL_last_state = 0x00;
uint8_t RL_Rx_state = 0x00;
uint8_t DCPDU_active_chn = RELAY_ChN_default;
uint8_t Fault_state_V = 0xff;
uint8_t Fault_state_I = 0;
uint8_t Relay_OnOff_Func = 0;
uint8_t Fault_state_Reg = 0;
uint8_t Fault_state_Last = 0;
float TotalWh[RELAY_ChN_default] ={0.0};

uint8_t read_adc_flag = 0;




uint8_t DCPDU_Vmax_LTen_flag[RELAY_ChN_default] = {0x00};
uint8_t DCPDU_Vmin_LTen_flag[RELAY_ChN_default] = {0x00};
uint8_t DCPDU_Imax_LTen_flag[RELAY_ChN_default] = {0x00};
uint8_t DCPDU_Wmax_LTen_flag[RELAY_ChN_default] = {0x00};
uint8_t DCPDU_kWhmax_LTen_flag[RELAY_ChN_default] = {0x00};



uint8_t DCPDU_OverFunc[RELAY_ChN_default] = {0};
uint8_t DCPDU_All_Over_Func = 0;


uint32_t DC_BASE[4] ={0};


uint8_t RL_Last_state[RELAY_ChN_default] = {0};
uint8_t RL_Now_state[RELAY_ChN_default] = {0};




uint16_t Devid_IDChalNum = 0;//设备类型和通道数


#define ADC_VOL 8


#if SUPPORT_2_V_GA_CHN
uint16_t adc_data_zero[ADC_CH_N+ADC_V_CHN]= {0};
#else
uint16_t adc_data_zero[ADC_CH_N]= {0};
#endif


#if SUPPORT_DETECTION
uint8_t detection_value = 0;
#endif

uint32_t normal_running_time = 0;


uint32_t DCPDU_Iout_Zero[RELAY_ChN_default] = {0};
uint32_t DCPDU_Modbus_Reg[DCPDU_Modbus_Reg_len] = {0};
uint32_t DCPDU_Iin_Zero = 0;
uint32_t DCPDU_Win_Zero = 0;


META_DATA_S meta_data 		= {0};
information_t infomation;


void switch_recode();

#if SUPPORT_SWITCH_REMENBER
	uint8_t handle_status[RELAY_ChN_default] = {0};
	uint8_t handle_detection[2] = {1,1};
	uint32_t input_1_ms_count = 0;
	uint32_t input_2_ms_count = 0;
			
	uint8_t  input_1_en = 0;
	uint8_t  input_2_en = 0;

#endif




extern bool Rx_Finish_flag; 
extern bool adc_data_ok_flag;
extern uint8_t ch_cnt;
extern uint8_t Eeprom_Rbuf[RELAY_para_sum + 1];
extern uint8_t	Rx_Data_buff_IM1253E[UART1_BUF_SIZE];
extern uint32_t RL_delay_Limit[RELAY_ChN_default];
#if SUPPORT_2_V_GA_CHN
extern uint32_t adc_Avg_value[ADC_CH_N+ADC_V_CHN];//存放各通道平均值
extern uint16_t adc_original_value[ADC_CH_N+ADC_V_CHN];
#else
extern uint32_t adc_Avg_value[ADC_CH_N];//存放各通道平均值
extern uint16_t adc_original_value[ADC_CH_N];
#endif

extern uint32_t Modbus_Wr_buff[Mb_Wcmd_Width][Mb_Wcmd_len];
extern uint32_t RL_delay_cnt[RELAY_ChN_default];
/*********************************************************************************************************
*                                              内部函数声明
*********************************************************************************************************/
static  void  InitSoftware(void);   			//初始化软件相关的模块
static  void  InitHardware(void);   			//初始化硬件相关的模块
static  void  CHK_JLINK(void);
static  void MODbus_CMD(void);
static void key_io_control();

void LimiT_enable_check(uint8_t ch_x,uint32_t Lt_v);

uint32_t FfLASH = 0;
static void app_init(META_DATA_S *meta)
{
	flash_get_meta_data(meta);
	FfLASH = NVIC_VECTTAB_FLASH;
	nvic_vector_table_set(NVIC_VECTTAB_FLASH,0X08004000 - NVIC_VECTTAB_FLASH);
	__enable_irq();
}


void break_2_boot_upgreade(void)
{
	meta_data.errno = 0;
	meta_data.operation_flag = 1;
	meta_data.recent_running_time = normal_running_time;
	flash_erase_meta();
	flash_write_meta(&meta_data);
	__disable_irq();
	//__set_FAULTMASK(1);
	NVIC_SystemReset();
}

/*********************************************************************************************************
*                                              内部函数实现
*********************************************************************************************************/
/*********************************************************************************************************
* 函数名称：InitSoftware
* 函数功能：所有的软件相关的模块初始化函数都放在此函数中
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2024年04月12日
* 注    意：
*********************************************************************************************************/
static  void  InitSoftware(void)
{
	eMBInit(MB_RTU, DCPDU_SlaveAddress, 0, Uart0_Baud, MB_PAR_NONE);		// 初始化modbus为RTU方式，地址RelaySlaveAddress, 波特率Uart0_Baud，无校验
	eMBEnable();	// 使能modbus协议栈
	
}

/*********************************************************************************************************
* 函数名称：InitHardware
* 函数功能：所有的硬件相关的模块初始化函数都放在此函数中
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2024年04月12日
* 注    意：
*********************************************************************************************************/
static  void  InitHardware(void)
{  
//	SystemInit();        //系统初始化，函数里面默认是配置为内部晶振
//	ViewRcuClock();			 //在线调试查看系统时钟频率
//	InitNVIC();          //初始化NVIC模块 
	InitSysTick();       //初始化SysTick模块
	InitLED();           //初始化LED模块
	InitKey();           //初始化Key模块
	InitRelay();				 //初始化Relay模块
	InitAT24Cxx();			 //初始化24C64模块	
	Init_74hc573();				 //初始化74hc573锁存器
	Init_74hc595();       //初始化74hc595
	InitTimer();         //初始化Timer模块

#if SURPPOT_ALL_ON_ALL_OFF
	IoInit();
#endif
	

	
#if SUPPORT_STM32_ADC
	InitUART1(115200);
#elif SUPPORT_IM1253E
	InitUART1(IM1253E_bd);     //初始化UART1模块 电能计量芯片默认的波特率，偶校验
#endif

	
	
	Init_ADC();
#if SUPPORT_DETECTION
	detection_Init();
#endif
	Delay_Ms_1 = 0;
}


static void key_io_control()
{
	bool rst = false;
	bool test = false;
	
	//
	rst = get_rst();
	test = get_test();
	if(rst != test)
	{
		
		if(rst)
		{
#if SUPPORT_EIGHT_LIGHT
			RL_Rx_state = 0x80;
#else
			RL_Rx_state = 0x00;
#endif
			RL_Alloff_flag = true;
			
		}else
		{
			RL_Rx_state = 0xff & Active_state_bit;
			RL_Allon_flag = true;
		}
	}
}





/*********************************************************************************************************
* 函数名称：CHK_JLINK
* 函数功能：检测JLINK有没有插上
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2024年08月9日 liyuezong重构
* 注    意：
*********************************************************************************************************/
static  void  CHK_JLINK(void)
{
	uint8_t i = 0;
	uint8_t temp0 = 0;
	uint8_t temp1 = 0;
	uint8_t t_RL_st_old = 0;
	uint8_t t_RL_st_new = 0;
#if (SUPPORT_IM1253E == 0)
#else
	if(gpio_input_bit_get(CHECK_JLINK_IO,CHECK_JLINK_IN) == 0)//如果有jlink接入，则不会动作继电器，直接跳出进入主函数
#endif
	
	{
			//1 pan duan shi fou you qing qiu
			temp1 = Eeprom_Rbuf[ERom_RL_ST_Addr] ^ RL_Rx_state;
			if(temp1 > 0)
			{
				if(RL_Allon_flag || RL_Alloff_flag)
				{
					for(i = 0;i < DCPDU_RL_time.RL_chn;i++)//所有状态清零
					{
						RL_begin_delay_flag[i] = 0;
						RL_end_delay_flag[i] = 0;
						RL_delay_Limit[i] = 0;
						RL_ON_flag[i] = 0;
						RL_OFF_flag[i] = 0;
					}
				}
				
				for(i = 0;i < DCPDU_RL_time.RL_chn;i++)
				{
					t_RL_st_old = Eeprom_Rbuf[ERom_RL_ST_Addr] >> i;
					t_RL_st_old = t_RL_st_old & 0x01;
					t_RL_st_new = RL_Rx_state >> i;
					t_RL_st_new = t_RL_st_new & 0x01;
					
					if(t_RL_st_old > t_RL_st_new)//off
					{	
						RL_OFF_flag[i] = 1;
						if(RL_Alloff_flag)
						{
							RL_delay_Limit[i] = DCPDU_RL_time.RL_offtime[i] * 1000;//秒转成毫秒;
							RL_begin_delay_flag[i] = 1;
						}
						else
						{
							RL_end_delay_flag[i] = 1;
						}
					}
					else if(t_RL_st_old < t_RL_st_new)//on
					{
						RL_ON_flag[i] = 1;
						if(RL_Allon_flag)
						{
							RL_delay_Limit[i] = DCPDU_RL_time.RL_ontime[i] * 1000;//秒转成毫秒
							RL_begin_delay_flag[i] = 1;
						}
						else
						{
							RL_end_delay_flag[i] = 1;
						}
					}		
				}

				RL_Alloff_flag = false;
				RL_Allon_flag = false;
			}
			else
			{
				if(RL_Allon_flag || RL_Alloff_flag)
				{
					RL_Allon_flag = false;
					RL_Alloff_flag = false;
					for(i = 0;i < DCPDU_RL_time.RL_chn;i++)//所有状态清零
					{
						RL_begin_delay_flag[i] = 0;
						RL_end_delay_flag[i] = 0;
						RL_delay_Limit[i] = 0;
						RL_ON_flag[i] = 0;
						RL_OFF_flag[i] = 0;
					}		
				}
			}	
		
		for(i = 0;i < DCPDU_RL_time.RL_chn;i++)
		{
			if(RL_end_delay_flag[i] > 0)
			{
				RL_delay_Limit[i] = 0;
				RL_begin_delay_flag[i] = 0;
				RL_end_delay_flag[i] = 0;
				temp0 = 0x01 << i;
				if(RL_ON_flag[i] > 0)
				{
					Relayx_Onoff_state(i,RELAY_ON);
					RL_ON_flag[i] = 0;
					DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] |= temp0;
				}
				else if(RL_OFF_flag[i] > 0)
				{
#if SUPPORT_EIGHT_LIGHT
					if(i != 7){
						Relayx_Onoff_state(i,RELAY_OFF);
						temp0 = ~temp0;
						DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] &= temp0;
					}
#else
				Relayx_Onoff_state(i,RELAY_OFF);	
				temp0 = ~temp0;
					DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] &= temp0;
#endif
					
					RL_OFF_flag[i] = 0;
					
					
				}
				Eeprom_Rbuf[ERom_RL_ST_Addr] = DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] & Active_state_bit;
				AT24CxxWriteOneByte(ERom_RL_ST_Addr,Eeprom_Rbuf[ERom_RL_ST_Addr]);
				Write_74hc573();
			}
		}
		Load_conn_end_flag = true;
		
	}
	RL_Rx_state = Eeprom_Rbuf[ERom_RL_ST_Addr];
}

/*********************************************************************************************************
* 函数名称：fault_state_process
* 函数功能：check channel worning and openration func
* 输入参数：uint8_t
* 输出参数：void
* 返 回 值：void 
* 创建日期：2024年04月12日
* 注    意：
*********************************************************************************************************/
static void fault_state_process(uint8_t chn)
{
	uint32_t temp0 = 4 * chn;
	if(DCPDU_Vmax_LTen_flag[chn])
	{
		if(DCPDU_Modbus_Reg[Mb_Dbuff_P1Output_Addr + temp0] > DCPDU_Modbus_Reg[Mb_Dbuff_VLit1_max_Addr+chn])
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] |= DCPDU_Vmax_Fault;
			if(DCPDU_Modbus_Reg[Mb_Dbuff_RL_Over_Ch1_Func + chn] & (DCPDU_Over_V_Max_Func_enable))
			{
				DCPDU_OverFunc[chn] = 1;
			}
			//DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + i] |= DCPDU_Vmin_NFault;
		}else
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] &= DCPDU_Vmax_NFault;
		}
	}else
	{
		DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] &= DCPDU_Vmax_NFault;
	}
	if(DCPDU_Vmin_LTen_flag[chn])
	{
		if(DCPDU_Modbus_Reg[Mb_Dbuff_P1Output_Addr + temp0] < DCPDU_Modbus_Reg[Mb_Dbuff_VLit1_min_Addr+chn])
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] |= DCPDU_Vmin_Fault;
			if(DCPDU_Modbus_Reg[Mb_Dbuff_RL_Over_Ch1_Func + chn] &(DCPDU_Over_V_Min_Func_enable))
			{
				DCPDU_OverFunc[chn] = 1;
			}
		}else
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] &= DCPDU_Vmin_NFault;
		}
	}else
	{
		DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] &= DCPDU_Vmin_NFault;
	}
	if(DCPDU_Imax_LTen_flag[chn])
	{
		if(DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 1] > DCPDU_Modbus_Reg[Mb_Dbuff_ILit1_max_Addr+chn])
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] |= DCPDU_Imax_Fault;
			if(DCPDU_Modbus_Reg[Mb_Dbuff_RL_Over_Ch1_Func + chn] & (DCPDU_Over_I_Max_Func_enable))
			{
				DCPDU_OverFunc[chn] = 1;
			}
		}else {
			DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] &= DCPDU_Imax_NFault;
		}
	}else{
		DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] &= DCPDU_Imax_NFault;
	}
	if(DCPDU_Wmax_LTen_flag[chn])
	{
		if(DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 2] > DCPDU_Modbus_Reg[Mb_Dbuff_WLit1_max_Addr+chn])
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] |= DCPDU_Wmax_Fault;
			if(DCPDU_Modbus_Reg[Mb_Dbuff_RL_Over_Ch1_Func + chn]&(DCPDU_Over_P_Max_Func_enable))
			{
				DCPDU_OverFunc[chn] = 1;
			}
		}else
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] &= DCPDU_Wmax_NFault;
		}
	}else
	{
		DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] &= DCPDU_Wmax_NFault;
	}
	if(DCPDU_kWhmax_LTen_flag[chn])
	{
		if(DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 3] > DCPDU_Modbus_Reg[Mb_Dbuff_kWhLit1_max_Addr+chn])
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] |= DCPDU_kWhmax_Fault;
			if(DCPDU_Modbus_Reg[Mb_Dbuff_RL_Over_Ch1_Func + chn] & (DCPDU_Over_C_Max_Func_enable))
			{
				DCPDU_OverFunc[chn] = 1;
			}
		}else
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] &= DCPDU_kWhmax_NFault;
		}
	}else
	{
		DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + chn] &= DCPDU_kWhmax_NFault;
	}
}

static void RL_Over_Func()
{
#if (SUPPORT_STM32_ADC == 0)
	if(DCPDU_All_Over_Func)
	{
		for(int i = 0; i <RELAY_ChN_default;i++)
		{
			uint8_t temp0 = 0x01 << i;
			Relayx_Onoff_state(i,RELAY_OFF);
			temp0 = ~temp0;
			DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] &= temp0;
		}
		Eeprom_Rbuf[ERom_RL_ST_Addr] = DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] & Active_state_bit;
		RL_Rx_state = Eeprom_Rbuf[ERom_RL_ST_Addr];
		Write_74hc573();
		DCPDU_All_Over_Func = 0;
		return;
	}
#endif
	for(int i = 0; i <RELAY_ChN_default;i++)
	{
		if(DCPDU_OverFunc[i])
		{
			uint8_t temp0 = 0x01 << i;
			Relayx_Onoff_state(i,RELAY_OFF);
			temp0 = ~temp0;
			DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] &= temp0;
			//E
			//AT24CxxWriteOneByte(ERom_RL_ST_Addr,Eeprom_Rbuf[ERom_RL_ST_Addr]);
			DCPDU_OverFunc[i] = 0;
		}
	}
	Eeprom_Rbuf[ERom_RL_ST_Addr] = DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] & Active_state_bit;
	RL_Rx_state = Eeprom_Rbuf[ERom_RL_ST_Addr];
	Write_74hc573();
}

static void fault_all_state_process(void)
{
	//Voltage max
	if(DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] & Shield_Vmax_Threshould_Enable)
	{
		if(DC_BASE[0] > DCPDU_Modbus_Reg[Mb_Dbuff_Thr_All_V_Max])
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_ALLFT_ST_Addr] |= DCPDU_Vmax_Fault;
			if(DCPDU_Modbus_Reg[Mb_Dbuff_Over_All_Func] & (DCPDU_Over_V_Max_Func_enable))
			{
				DCPDU_All_Over_Func = 1;
			}
			//DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + i] |= DCPDU_Vmin_NFault;
		}else
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_ALLFT_ST_Addr] &= DCPDU_Vmax_NFault;
		}
	}
	//Voltage min
	if(DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] & Shield_Vmin_Threshould_Enable)
	{
		if(DC_BASE[0] < DCPDU_Modbus_Reg[Mb_Dbuff_Thr_All_V_Min])
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_ALLFT_ST_Addr] |= DCPDU_Vmin_Fault;
			if(DCPDU_Modbus_Reg[Mb_Dbuff_Over_All_Func] & (DCPDU_Over_V_Min_Func_enable))
			{
				DCPDU_All_Over_Func = 1;
			}
			//DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + i] |= DCPDU_Vmin_NFault;
		}else
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_ALLFT_ST_Addr] &= DCPDU_Vmin_NFault;
		}
	}	
	// Current max
	if(DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] & Shield_Imax_Threshould_Enable)
	{
		if(DC_BASE[1] > DCPDU_Modbus_Reg[Mb_Dbuff_Thr_All_I_Max])
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_ALLFT_ST_Addr] |= DCPDU_Imax_Fault;
			if(DCPDU_Modbus_Reg[Mb_Dbuff_Over_All_Func] & (DCPDU_Over_I_Max_Func_enable))
			{
				DCPDU_All_Over_Func = 1;
			}
			//DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + i] |= DCPDU_Vmin_NFault;
		}else
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_ALLFT_ST_Addr] &= DCPDU_Imax_NFault;
		}
	}
	//Power max
	if(DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] & Shield_Wmax_Threshould_Enable)
	{
		if(DC_BASE[2] > DCPDU_Modbus_Reg[Mb_Dbuff_Thr_All_P_Max])
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_ALLFT_ST_Addr] |= DCPDU_Wmax_Fault;
			if(DCPDU_Modbus_Reg[Mb_Dbuff_Over_All_Func] & (DCPDU_Over_P_Max_Func_enable))
			{
				DCPDU_All_Over_Func = 1;
			}
			//DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + i] |= DCPDU_Vmin_NFault;
		}else
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_ALLFT_ST_Addr] &= DCPDU_Wmax_NFault;
		}
	}
	//Consumer max
	if(DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] & Shield_kWhmax_Threshould_Enable)
	{
		if(DC_BASE[3] > DCPDU_Modbus_Reg[Mb_Dbuff_Thr_All_C_Max])
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_ALLFT_ST_Addr] |= DCPDU_kWhmax_Fault;
			if(DCPDU_Modbus_Reg[Mb_Dbuff_Over_All_Func] & (DCPDU_Over_C_Max_Func_enable))
			{
				DCPDU_All_Over_Func = 1;
			}
			//DCPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + i] |= DCPDU_Vmin_NFault;
		}else
		{
			DCPDU_Modbus_Reg[Mb_Dbuff_ALLFT_ST_Addr] &= DCPDU_kWhmax_NFault;
		}
	}
}
void switch_recode()
{
#if SUPPORT_SWITCH_REMENBER
	if((detection_value & 1) == 0)
	{
		if(handle_detection[0] == 1)
		{
			handle_detection[0] = 0;
			for(int i = 0;i < RELAY_ChN_default;i++)
			{
				handle_status[i] = (DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] >> i) & 0x1;
				uint8_t data = DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr];
				data &= 0x00;
				RL_Rx_state = data;
			}
		}
	}else
	{
		if(handle_detection[0] == 0)
		{
			handle_detection[0] = 1;
			uint8_t value = 0xFF;
			for(int i = 0 ;i < RELAY_ChN_default;i++)
			{
				if(handle_status[i])
				{
					value |= (1 << i);
				}else
				{
					value &= (~(1 << i));
				}
			}
			RL_Rx_state = value & Active_state_bit;
			RL_Allon_flag = true;
		}
	}
//	if((detection_value & 2) == 0)
//	{
//		if(handle_detection[1] == 1)
//		{
//			handle_detection[1] = 0;
//			for(int i = PT_SUB_COUNT;i < RELAY_ChN_default;i++)
//			{
//				handle_status[i] = (DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] >> i) & 0x1;
//				uint8_t data = DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr];
//				data &= 0x0F;
//				RL_Rx_state = data;
//			}
//		}
//	}else
//	{
//		if(handle_detection[1] == 0)
//		{
//			handle_detection[1] = 1;
//			uint8_t _data = DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr];
//			_data |= 0XF0;
//			for(int i= PT_SUB_COUNT; i < PT_SUB_COUNT;i++)
//			{
//				if(handle_status[i])
//				{
//					_data &= (1 << i);
//				}else
//				{
//					_data &= (0 << i);
//				}
//			}
//			RL_Rx_state = _data;
//			RL_Allon_flag = true;			
//		}		
//	}
#endif
}


/*********************************************************************************************************
* 函数名称：main
* 函数功能：主函数 
* 输入参数：void
* 输出参数：void
* 返 回 值：int
* 创建日期：2024年04月12日
* 注    意：
*********************************************************************************************************/
int main(void)
{
	app_init(&meta_data);
	uint8_t i = 0;
	uint32_t temp0 = 0;
	uint32_t temp_v = 0;
	uint32_t temp_i = 0;
	uint32_t temp_p = 0;
	uint8_t temp1 = 0;
	uint8_t temp2 = 0;
	uint32_t temp_da[8] = {0};
	float temp_w = 0.0;
	cnt = 0;
	Wr_eeprom_cnt = 0;
	Wr_erom_wait_cnt = 0;
	Active_state_bit = 0xff;
	for(i = 0;i < RELAY_ChN_default;i++)
	{
		RL_begin_delay_flag[i] = 0;
		RL_end_delay_flag[i] = 0;
		TotalWh[i] = 0.0;
	}
	InitHardware();//初始化硬件相关函数
	Fwdgt_Init();
	DCPDU_SlaveAddress = ReadKeyValue();//读取从机的地址
	InitSoftware();//初始化软件相关函数
	
	
	Devid_IDChalNum = DCPDU_Device_ID;
	Devid_IDChalNum = Devid_IDChalNum << 8;
	Devid_IDChalNum += DCPDU_active_chn;
	DCPDU_Modbus_Reg[Mb_Dbuff_DevAddr] = Devid_IDChalNum;//设备型号和通道数
	
	DCPDU_RL_time.RL_chn = DCPDU_active_chn;
	Active_state_bit = 0xff >> (8 - DCPDU_active_chn);
	
	strcpy(infomation.date,__DATE__);
	strcat(infomation.date," ");
	strcat(infomation.date,__TIME__);
	strcpy(infomation.ver,VERSION);
	infomation.channels = DCPDU_active_chn;
	
	flash_get_infomation(&infomation);
	ReadEeprom();
	for(i = 0;i < RELAY_ChN_default;i++)
	{
		DCPDU_RL_time.RL_ontime[i] = DCPDU_Modbus_Reg[Mb_Dbuff_RL_Ton1_Addr + i];
		DCPDU_RL_time.RL_offtime[i] = DCPDU_Modbus_Reg[Mb_Dbuff_RL_Toff1_Addr + i];
	}
	gpio_bit_reset(LOCK_74hc573_IO, LOCK_74hc573_OE);
	
	Init_Dev_parameter();
	
	RL_Rx_state = Eeprom_Rbuf[ERom_RL_ST_Addr]& Active_state_bit;
	//RL_Allon_flag = true;
	
	Eeprom_Rbuf[ERom_RL_ST_Addr]= 0 ;
	DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr]=0;

	RL_last_state = 0;
	Fault_state_V = Fault_state_V & Active_state_bit;
	Fault_display(Fault_state_V);
	Fault_state_Last = Fault_state_V;
	for(i = 0;i < DCPDU_active_chn;i++)
	{
		temp0 = 4*i;
		TotalWh[i] = DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 3];//耗电量初始化
	}
	for(i = 0;i < RELAY_ChN_default;i++)
	{
		LimiT_enable_check(i,DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr+i]);
	}
#if SUPPORT_DETECTION
		detection_value = get_detection();
#endif
#if SUPPORT_EIGHT_LIGHT
	Relayx_Onoff_state(7,RELAY_ON);
#endif
#if SUPPORT_SWITCH_REMENBER
	if((detection_value & 0x1) == 0)
	{
		if(handle_detection[0] == 1)
		{
			handle_detection[0] = 0;
			for(int i = 0;i < RELAY_ChN_default;i++)
			{
				handle_status[i] = (RL_Rx_state>>i) & 0x1;
				uint8_t data = DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr];
				data = 0x00;
				RL_Rx_state = data;
			}			
		}
	}
#endif
	//switch_recode();
	RL_Allon_flag = true;

static  uint8_t write_iic_flash = 0;
	while(1)
	{
//#if 1
//		if((detection_value & 0x1) == 0)
//		{
//			for(int i = 0; i <RELAY_ChN_default / 2;i++)
//			{

//					uint8_t temp0 = 0x01 << i;
//					Relayx_Onoff_state(i,RELAY_OFF);
//					temp0 = ~temp0;
//					DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] &= temp0;
//					//E
//					//AT24CxxWriteOneByte(ERom_RL_ST_Addr,Eeprom_Rbuf[ERom_RL_ST_Addr]);
//			}
//		}
//			Eeprom_Rbuf[ERom_RL_ST_Addr] = DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] & Active_state_bit;
//			RL_Rx_state = Eeprom_Rbuf[ERom_RL_ST_Addr];
//			Write_74hc573();
//			uint8_t data = RL_Rx_state;
//			RL_Rx_state = 0xF0;
//			RL_Rx_state &= data;		
//		
//#endif
		
		
#if 0
		if((detection_value & 0x2) == 0)
		{
			for(int i = 0; i <RELAY_ChN_default / 2;i++)
			{

					uint8_t temp0 = 0x01 << i;
					Relayx_Onoff_state(i,RELAY_OFF);
					temp0 = ~temp0;
					DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] &= temp0;
					//E
					//AT24CxxWriteOneByte(ERom_RL_ST_Addr,Eeprom_Rbuf[ERom_RL_ST_Addr]);
			}
			Eeprom_Rbuf[ERom_RL_ST_Addr] = DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] & Active_state_bit;
			RL_Rx_state = Eeprom_Rbuf[ERom_RL_ST_Addr];
//			Write_74hc573();
				uint8_t data = RL_Rx_state;
				RL_Rx_state = 0xF0;
				RL_Rx_state &= data;
		}
		if((detection_value & 0x1) == 0)
		{
			for(int i = RELAY_ChN_default / 2; i <RELAY_ChN_default;i++)
			{

					uint8_t temp0 = 0x01 << i;
					Relayx_Onoff_state(i,RELAY_OFF);
					temp0 = ~temp0;
					DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] &= temp0;
					//E
					//AT24CxxWriteOneByte(ERom_RL_ST_Addr,Eeprom_Rbuf[ERom_RL_ST_Addr]);
			}
			Eeprom_Rbuf[ERom_RL_ST_Addr] = DCPDU_Modbus_Reg[Mb_Dbuff_RL_ST_Addr] & Active_state_bit;
			RL_Rx_state = Eeprom_Rbuf[ERom_RL_ST_Addr];
//			Write_74hc573();
			uint8_t data = RL_Rx_state;
			RL_Rx_state = 0x0F;
			RL_Rx_state &= data;
		}
#endif
		CHK_JLINK();
		Fwdgt_reload();
		eMBPoll();
#if SUPPORT_IM1253E
		if(Read_IM1253E_flag)//定时读1253
		{
			Read_IM1253E_flag = false;
			if(IM1253E_OK_flag)
			{
				Read_IM1253E_REG(Device_addr_IM1253E,V_REG_ADDR,8);
			}
		}
		if(Rx_Finish_flag)//从1253读到数，进行处理
		{
			Rx_Finish_flag = false;
			for(j = 0;j < 8;j++)
			{
				temp_da[j] = 0;
				for(i = 0;i < 4;i++)
				{
					temp1 = 8 * i;
					temp1 = 24 - temp1;
					temp2 = 4 * j;
					temp2 += 3;
					temp2 += i;
					temp0 = Rx_Data_buff_IM1253E[temp2] << temp1;
					temp_da[j] += temp0;
				}
			}
			DCPDU_Modbus_Reg[Mb_Dbuff_VInput_Addr] = temp_da[0] / 100;//输入电压
			DCPDU_Modbus_Reg[Mb_Dbuff_VInput_Addr] *= 10;//去掉第3位小数
			DC_BASE[0] =  DCPDU_Modbus_Reg[Mb_Dbuff_VInput_Addr];
			for(i = 0;i < RELAY_ChN_default;i++)
			{
				temp0 = 4 * i;
				DCPDU_Modbus_Reg[Mb_Dbuff_P1Output_Addr + temp0] = DCPDU_Modbus_Reg[Mb_Dbuff_VInput_Addr];//输出电压
				temp2 = 0x01 << i;
				if(DCPDU_Modbus_Reg[Mb_Dbuff_VInput_Addr] > DCPDU_Modbus_Reg[Mb_Dbuff_VLit1_max_Addr + i])
				{
					Fault_state_V |= temp2;
//					if(DCPDU_Modbus_Reg[Mb_Dbuff_RL_Over_Ch1_Func + i] & DCPDU_Over_V_Max_Func_enable)
//					{
//						Relay_OnOff_Func |= temp2;
//					}
					//if(Relayx_Onoff_state[])
				}
				else
				{
					if((Fault_state_V & temp2) > 0)
					{
						temp1 = ~temp2;
						Fault_state_V &= temp1;
					}
				}
			}
			
			DCPDU_Modbus_Reg[Mb_Dbuff_IInput_Addr] = temp_da[1] / 100;
			DCPDU_Modbus_Reg[Mb_Dbuff_IInput_Addr] *= 10;//去掉第3位小数
			if(DCPDU_Modbus_Reg[Mb_Dbuff_IInput_Addr] > DCPDU_Iin_Zero)
			{
				DCPDU_Modbus_Reg[Mb_Dbuff_IInput_Addr] -= DCPDU_Iin_Zero;
			}
			else
			{
				DCPDU_Modbus_Reg[Mb_Dbuff_IInput_Addr] = 0;
			}
			DC_BASE[1] =  DCPDU_Modbus_Reg[Mb_Dbuff_IInput_Addr];
			
			DCPDU_Modbus_Reg[Mb_Dbuff_WInput_Addr] = temp_da[2] / 100;
			DCPDU_Modbus_Reg[Mb_Dbuff_WInput_Addr] *= 10;//去掉第3位小数
			if(DCPDU_Modbus_Reg[Mb_Dbuff_WInput_Addr] > DCPDU_Win_Zero)
			{
				DCPDU_Modbus_Reg[Mb_Dbuff_WInput_Addr] -= DCPDU_Win_Zero;
			}
			else
			{
				DCPDU_Modbus_Reg[Mb_Dbuff_WInput_Addr] = 0;
			}
			DC_BASE[2] = DCPDU_Modbus_Reg[Mb_Dbuff_WInput_Addr];
			
			DCPDU_Modbus_Reg[Mb_Dbuff_KWhInput_Addr] = temp_da[3] / 100;
			DCPDU_Modbus_Reg[Mb_Dbuff_KWhInput_Addr] *= 10;//去掉第3位小数
			
			DC_BASE[3] = DCPDU_Modbus_Reg[Mb_Dbuff_KWhInput_Addr];
			
			//jugement consumer !!!!
		}
#endif


		if(read_adc_flag == 1)
		{
			read_adc_val();
			read_adc_flag = 0;
#if SUPPORT_DETECTION
		detection_value = get_detection();
#endif
		}

		if(Get1SecFlag()) //判断1s标志状态
		{
			write_iic_flash++;
			normal_running_time++;
			LEDFlicker2();
			Clr1SecFlag();  //清除1s标志
			//read_adc_val();//定时读取ADC的数据
			//输出耗电量计算。累计。
			
#if (SUPPORT_IM1253E == 0)
				uint32_t kWh_in = 0;
#endif
			for(i = 0;i < DCPDU_active_chn;i++)
			{
				temp0 = 4*i;
				temp_w = (float)DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 2];
				temp_w = temp_w / 1000.0;//转换成W，原功率是扩大了1000倍的
				temp_w = temp_w / 3600.0;//转换成每秒的Wh,
				//temp_w = temp_w / 1000.0;//转换成每秒的kWh
				//temp_w = temp_w * 1000.0;//扩大1000倍上传
				TotalWh[i] = temp_w + TotalWh[i];//累计电量，初值为0

				DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 3] = (uint32_t)TotalWh[i];
#if (SUPPORT_IM1253E == 0)
				kWh_in += DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 3];
#endif
				if(DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 3] > 0xfffffffe)
				{
					TotalWh[i] = 0.0;
					DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 3]=(uint32_t)TotalWh[i];
				}
				
				//将耗电量实时写入Eeprom

			}
			
		if(write_iic_flash == 90)
		{
			write_iic_flash = 0;
			for(i = 0;i < DCPDU_active_chn;i++)
			{
				temp0 = 4*i;
				Eeprom_Rbuf[ERom_TotalWh1_Addr + temp0] = DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 3] >> 24;
				Eeprom_Rbuf[ERom_TotalWh1_Addr + temp0 + 1] = DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 3] >> 16;
				Eeprom_Rbuf[ERom_TotalWh1_Addr + temp0 + 2] = DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 3] >> 8;
				Eeprom_Rbuf[ERom_TotalWh1_Addr + temp0 + 3] = DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 3];
				AT24CxxWrite(ERom_TotalWh1_Addr + temp0,(Eeprom_Rbuf + ERom_TotalWh1_Addr + temp0),4);
			}
		}
#if (SUPPORT_IM1253E == 0)
			DCPDU_Modbus_Reg[Mb_Dbuff_KWhInput_Addr] = kWh_in;
			DC_BASE[3] = DCPDU_Modbus_Reg[Mb_Dbuff_KWhInput_Addr];
#endif
			for(i = 0;i < DCPDU_active_chn;i++)
			{
				fault_state_process(i);
			}
			fault_all_state_process();
		}
		if(adc_data_ok_flag)//读到ADC数据，然后进行处理。
		{
			adc_data_ok_flag = false;
			//read voltage
#if (SUPPORT_IM1253E == 0)
			uint32_t I_in = 0;
			uint32_t W_in = 0;
#if SUPPORT_STM32_ADC
			uint32_t voltage_chi_1 = 0;
			uint32_t voltage_chi_2 = 0;
			voltage_chi_1 = read_voltage(STM32_ADC_V_1) ;
			//delay_ms(5);
			voltage_chi_2 = read_voltage(STM32_ADC_V_2) ;

			DCPDU_Modbus_Reg[Mb_Dbuff_VInput_Addr] = voltage_chi_1 > voltage_chi_2 ? voltage_chi_1 : voltage_chi_2;
#else
			DCPDU_Modbus_Reg[Mb_Dbuff_VInput_Addr] = DC_V_calfunction(adc_Avg_value[ADC_VOL]);
			adc_Avg_value[ADC_VOL] = 0;	
#endif		
			DC_BASE[0] = DCPDU_Modbus_Reg[Mb_Dbuff_VInput_Addr];
				
#endif
			//for(i = 0;i < ADC_CH_N;i++)
			for(i = 0;i < DCPDU_active_chn;i++)
			{
				temp0 = 4*i;
#if SUPPORT_STM32_ADC
				if(i >=4)
				{
					DCPDU_Modbus_Reg[Mb_Dbuff_P1Output_Addr + temp0] = voltage_chi_2;
				}else
				{
					DCPDU_Modbus_Reg[Mb_Dbuff_P1Output_Addr + temp0] = voltage_chi_1;
				}
#else				
				DCPDU_Modbus_Reg[Mb_Dbuff_P1Output_Addr + temp0] = DCPDU_Modbus_Reg[Mb_Dbuff_VInput_Addr];
#endif
				if(DCPDU_Modbus_Reg[Mb_Dbuff_VInput_Addr] > DCPDU_Modbus_Reg[Mb_Dbuff_VLit1_max_Addr + i])
				{
					Fault_state_V |= temp2;
				}else
				{
					if((Fault_state_V & temp2) > 0)
					{
						temp1 = ~temp2;
						Fault_state_V &= temp1;
					}
				}

				DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 1] = DC_I_calfunction(adc_Avg_value[i],i);//输出电流
				
				
				if(Load_conn_end_flag)//负载加载以后再检测电流
				{
					temp2 = 0x01 << i;
#if (SUPPORT_IM1253E == 0)
					I_in += DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 1];
#endif
					if(DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 1] > DCPDU_Modbus_Reg[Mb_Dbuff_ILit1_max_Addr + i])
					{
						Fault_state_I |= temp2;
					}
					else
					{
						if((Fault_state_I & temp2) > 0)
						{
							temp1 = ~temp2;
							Fault_state_I &= temp1;
						}
					}
				}
				//计算功率//


				temp_v =DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr] / 10;
				temp_i = DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 1] / 10;
				temp_p = temp_v * temp_i;
		
				DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 2] = temp_p / 10;
#if (SUPPORT_IM1253E == 0)
				W_in += DCPDU_Modbus_Reg[temp0 + Mb_Dbuff_P1Output_Addr + 2];
#endif
				adc_Avg_value[i] = 0;

			}
			Fault_state_Reg = Fault_state_V | Fault_state_I;
#if (SUPPORT_IM1253E == 0)		
			DCPDU_Modbus_Reg[Mb_Dbuff_IInput_Addr] = I_in;
			DC_BASE[1] = DCPDU_Modbus_Reg[Mb_Dbuff_IInput_Addr];
			DCPDU_Modbus_Reg[Mb_Dbuff_WInput_Addr] = W_in;
			DC_BASE[2] = DCPDU_Modbus_Reg[Mb_Dbuff_WInput_Addr];
#endif
		}
		
		if(Fault_state_Reg > 0)//故障或超阈值处理
		{
			if(Fault_state_Reg != Fault_state_Last)
			{
				Fault_display(Fault_state_Reg);
				Fault_state_Last = Fault_state_Reg;
			}
		}
		else
		{

		}
		RL_Over_Func();
		MODbus_CMD();//MODBUS命令池处理。
#if SURPPOT_ALL_ON_ALL_OFF
		key_io_control();
#endif
		switch_recode();
	}
}

void LimiT_enable_check(uint8_t ch_x,uint32_t Lt_v)
{
	if((Lt_v & DCPDU_Vmax_LT_enable) == DCPDU_Vmax_LT_enable)
	{
		DCPDU_Vmax_LTen_flag[ch_x] = 1;
	}else
	{
		DCPDU_Vmax_LTen_flag[ch_x] = 0;
	}
	if((Lt_v & DCPDU_Vmin_LT_enable) == DCPDU_Vmin_LT_enable)
	{
		DCPDU_Vmin_LTen_flag[ch_x] = 1;
	}else
	{
		DCPDU_Vmin_LTen_flag[ch_x] = 0;
	}
	if((Lt_v & DCPDU_Imax_LT_enable) == DCPDU_Imax_LT_enable)
	{
		DCPDU_Imax_LTen_flag[ch_x] = 1;
	}else
	{
		DCPDU_Imax_LTen_flag[ch_x] = 0;
	}
	if((Lt_v & DCPDU_Wmax_LT_enable) == DCPDU_Wmax_LT_enable)
	{
		DCPDU_Wmax_LTen_flag[ch_x] = 1;
	}else
	{
		DCPDU_Wmax_LTen_flag[ch_x] = 0;
	}
	if((Lt_v & DCPDU_kWhmax_LT_enable) == DCPDU_kWhmax_LT_enable)
	{
		DCPDU_kWhmax_LTen_flag[ch_x] = 1;
	}else
	{
		DCPDU_kWhmax_LTen_flag[ch_x] = 0;
	}
}


/*********************************************************************************************************
* 函数名称：MODbus_CMD
* 函数功能：modbus命令池处理
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2024年04月06日
* 注    意：
*********************************************************************************************************/
void MODbus_CMD(void)
{
	if(Modbus_Wr_buff[Wr_eeprom_cnt][0] > 0)
	{
		static uint8_t temp_data[4];
		static uint32_t temp_addr;
		uint32_t data = 0;
		uint8_t index = 0;
		if(Modbus_Wr_buff[Wr_eeprom_cnt][1] < Mb_Dbuff_VLit1_min_Addr)//设置电压最大阈值
		{
			temp_addr = Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_VLit1_max_Addr;
			index = temp_addr;
			temp_addr = temp_addr << 2;
			temp_addr += ERom_VLit1_max_Addr;
			Eeprom_Rbuf[temp_addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 24;
			Eeprom_Rbuf[temp_addr + 1] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 16;
			Eeprom_Rbuf[temp_addr + 2] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 8;
			Eeprom_Rbuf[temp_addr + 3] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
			DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
			if(DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] < THRESHOULD_JUDGMENT)
			{
				DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index] &= (Shield_Vmax_Threshould_Disable);
			}else
			{
				DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index] |= (Shield_Vmax_Threshould_Enable);
			}
			LimiT_enable_check(index,DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index]);
			
			AT24CxxWrite(temp_addr,(Eeprom_Rbuf + temp_addr),4);
		}
		else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] < Mb_Dbuff_ILit1_max_Addr)//设置电压最小阈值
		{
			temp_addr = Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_VLit1_min_Addr;
			index = temp_addr;
			temp_addr = temp_addr << 2;
			temp_addr += ERom_VLit1_min_Addr;
			Eeprom_Rbuf[temp_addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 24;
			Eeprom_Rbuf[temp_addr + 1] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 16;
			Eeprom_Rbuf[temp_addr + 2] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 8;
			Eeprom_Rbuf[temp_addr + 3] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
			DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
			if(DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] < THRESHOULD_JUDGMENT)
			{
				DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index] &= (Shield_Vmin_Threshould_Disable);
			}else
			{
				DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index] |= (Shield_Vmin_Threshould_Enable);
			}
			LimiT_enable_check(index,DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index]);	
			AT24CxxWrite(temp_addr,(Eeprom_Rbuf + temp_addr),4);
		}
		else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] < Mb_Dbuff_ILit1_min_Addr)//设置电流最大阈值
		{
			temp_addr = Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_ILit1_max_Addr;
			index = temp_addr;
			temp_addr = temp_addr << 2;
			temp_addr += ERom_ILit1_max_Addr;
			Eeprom_Rbuf[temp_addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 24;
			Eeprom_Rbuf[temp_addr + 1] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 16;
			Eeprom_Rbuf[temp_addr + 2] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 8;
			Eeprom_Rbuf[temp_addr + 3] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
			DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] = Modbus_Wr_buff[Wr_eeprom_cnt][2];			
			
			if(DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] < THRESHOULD_JUDGMENT)
			{
				DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index] &= (Shield_Imax_Threshould_Disable);
			}else
			{
				DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index] |= (Shield_Imax_Threshould_Enable);
			}
			LimiT_enable_check(index,DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index]);
			AT24CxxWrite(temp_addr,(Eeprom_Rbuf + temp_addr),4);
		}
		else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] < Mb_Dbuff_RL_ST_Addr)//设置电流最小阈值
		{
			temp_addr = Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_ILit1_min_Addr;
			temp_addr = temp_addr << 2;
			temp_addr += ERom_ILit1_min_Addr;
			Eeprom_Rbuf[temp_addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 24;
			Eeprom_Rbuf[temp_addr + 1] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 16;
			Eeprom_Rbuf[temp_addr + 2] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 8;
			Eeprom_Rbuf[temp_addr + 3] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
			DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
			AT24CxxWrite(temp_addr,(Eeprom_Rbuf + temp_addr),4);
		}
		else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] == Mb_Dbuff_RL_ST_Addr)//设置继电器状态
		{
			RL_Rx_state = Modbus_Wr_buff[Wr_eeprom_cnt][2] & Active_state_bit;
			//Eeprom_Rbuf[ERom_RL_ST_Addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2] & Active_state_bit;
			//AT24CxxWriteOneByte(ERom_RL_ST_Addr,Eeprom_Rbuf[ERom_RL_ST_Addr]);
			
		}
		else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] == Mb_Dbuff_RL_Allon_Addr)//设置继电器全开
		{
			RL_Rx_state = 0xff & Active_state_bit;
			RL_Allon_flag = true;
			//Eeprom_Rbuf[ERom_RL_ST_Addr] = 0xff & Active_state_bit;
			//AT24CxxWriteOneByte(ERom_RL_ST_Addr,Eeprom_Rbuf[ERom_RL_ST_Addr]);
		}
		else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] == Mb_Dbuff_RL_Alloff_Addr)//设置继电器全关
		{
#if SUPPORT_EIGHT_LIGHT
			RL_Rx_state = 0x80;
#else
			RL_Rx_state = 0;
#endif
			RL_Alloff_flag = true;
			//Eeprom_Rbuf[ERom_RL_ST_Addr] = 0x00;
			//AT24CxxWriteOneByte(ERom_RL_ST_Addr,Eeprom_Rbuf[ERom_RL_ST_Addr]);
		}
		else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] == Mb_Dbuff_RLft_ST_Addr)//设置故障状态
		{
			temp_addr = Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_RLft_ST_Addr;
			temp_addr += ERom_RLft_ST_Addr;
			Eeprom_Rbuf[temp_addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2] & Active_state_bit;
		}
		else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] < Mb_Dbuff_RL_Toff1_Addr)//设置开启延时
		{
			temp_addr = Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_RL_Ton1_Addr;
			temp_addr += ERom_RL_Ton1_Addr;
			Eeprom_Rbuf[temp_addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
			DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] = Eeprom_Rbuf[temp_addr];
			DCPDU_RL_time.RL_ontime[Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_RL_Ton1_Addr] = Eeprom_Rbuf[temp_addr];
			AT24CxxWriteOneByte(temp_addr,Eeprom_Rbuf[temp_addr]);
		}
		else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] < Mb_Dbuff_RL_Allon_Addr)//设置继电器关断延时
		{
			temp_addr = Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_RL_Toff1_Addr;
			temp_addr += ERom_RL_Toff1_Addr;
			Eeprom_Rbuf[temp_addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
			DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] = Eeprom_Rbuf[temp_addr];
			DCPDU_RL_time.RL_offtime[Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_RL_Toff1_Addr] = Eeprom_Rbuf[temp_addr];
			AT24CxxWriteOneByte(temp_addr,Eeprom_Rbuf[temp_addr]);
		}else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] <= Mb_Dbuff_WLit8_max_Addr)					//power
		{
			temp_addr = Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_WLit1_max_Addr;
			index = temp_addr;
			temp_addr = temp_addr << 2;
			temp_addr += ERom_WLit1_max_Addr;
			Eeprom_Rbuf[temp_addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 24;
			Eeprom_Rbuf[temp_addr + 1] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 16;
			Eeprom_Rbuf[temp_addr + 2] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 8;
			Eeprom_Rbuf[temp_addr + 3] = Modbus_Wr_buff[Wr_eeprom_cnt][2];	
			DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
			if(DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] < THRESHOULD_JUDGMENT)
			{
				DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index] &= (Shield_Wmax_Threshould_Disable);
			}else
			{
				DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index] |= (Shield_Wmax_Threshould_Enable);
			}
			LimiT_enable_check(index,DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index]);
			AT24CxxWrite(temp_addr,(Eeprom_Rbuf + temp_addr),4);
		}else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] <= Mb_Dbuff_kWhLit8_max_Addr)					//consumer
		{
			temp_addr = Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_kWhLit1_max_Addr;
			index = temp_addr;
			temp_addr = temp_addr << 2;
			temp_addr += ERom_kWhLit1_max_Addr;
			Eeprom_Rbuf[temp_addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 24;
			Eeprom_Rbuf[temp_addr + 1] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 16;
			Eeprom_Rbuf[temp_addr + 2] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 8;
			Eeprom_Rbuf[temp_addr + 3] = Modbus_Wr_buff[Wr_eeprom_cnt][2];	
			DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
			if(DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] < THRESHOULD_JUDGMENT)
			{
				DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index] &= (Shield_Kwhmax_Threshould_Disable);
			}else
			{
				DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index] |= (Shield_kWhmax_Threshould_Enable);
			}
			LimiT_enable_check(index,DCPDU_Modbus_Reg[Mb_Dbuff_CH1ST_FT_Addr + index]);
			
			AT24CxxWrite(temp_addr,(Eeprom_Rbuf + temp_addr),4);
		}
		else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] <= Mb_Dbuff_RL_Over_Ch8_Func)		//over func
		{
			temp_addr = Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_RL_Over_Ch1_Func;
			temp_addr += ERom_RL_Over_Func_Ch1;
			Eeprom_Rbuf[temp_addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
			
			DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] = Eeprom_Rbuf[temp_addr];
			AT24CxxWriteOneByte(temp_addr,Eeprom_Rbuf[temp_addr]);
		}else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] < Mb_Dbuff_Clear_Consumer_ALL)
		{
			temp_addr = Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_Clear_Consumer_Ch1;
			TotalWh[temp_addr] = 0.0;
		}else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] == Mb_Dbuff_Clear_Consumer_ALL)
		{
			for(int i = 0; i < RELAY_ChN_default;i++)
			{
				TotalWh[temp_addr] = 0.0;
			}
		}else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] <= Mb_Dbuff_Thr_All_C_Max)
		{
			temp_addr = Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_Thr_All_V_Max;
			temp_addr = temp_addr << 2;
			temp_addr += ERom_All_Thr_V_Max_Addr;
			Eeprom_Rbuf[temp_addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 24;
			Eeprom_Rbuf[temp_addr + 1] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 16;
			Eeprom_Rbuf[temp_addr + 2] = Modbus_Wr_buff[Wr_eeprom_cnt][2] >> 8;
			Eeprom_Rbuf[temp_addr + 3] = Modbus_Wr_buff[Wr_eeprom_cnt][2];	
			DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
			AT24CxxWrite(temp_addr,(Eeprom_Rbuf + temp_addr),4);
			switch(Modbus_Wr_buff[Wr_eeprom_cnt][1] - Mb_Dbuff_Thr_All_V_Max)
			{
				case 0:
				{
					if(DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] < THRESHOULD_JUDGMENT)
					{
						DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] &= (Shield_Vmax_Threshould_Disable);
					}else
					{
						DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] |= (Shield_Vmax_Threshould_Enable);
					}
				}
					break;
				case 1:
				{
					if(DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] < THRESHOULD_JUDGMENT)
					{
						DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] &= (Shield_Vmin_Threshould_Disable);
					}else
					{
						DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] |= (Shield_Vmin_Threshould_Enable);
					}
				}
					break;
				case 2:
				{
					if(DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] < THRESHOULD_JUDGMENT)
					{
						DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] &= (Shield_Imax_Threshould_Disable);
					}else
					{
						DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] |= (Shield_Imax_Threshould_Enable);
					}
				}
					break;
				case 3:
				{
					if(DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] < THRESHOULD_JUDGMENT)
					{
						DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] &= (Shield_Wmax_Threshould_Disable);
					}else
					{
						DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] |= (Shield_Wmax_Threshould_Enable);
					}
				}
					break;
				case 4:
				{
					if(DCPDU_Modbus_Reg[Modbus_Wr_buff[Wr_eeprom_cnt][1]] < THRESHOULD_JUDGMENT)
					{
						DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] &= (Shield_Kwhmax_Threshould_Disable);
					}else
					{
						DCPDU_Modbus_Reg[Mb_Dbuff_ALL_ST_FT_Addr] |= (Shield_kWhmax_Threshould_Enable);
					}
				}
					break;
			}
		}else if(Modbus_Wr_buff[Wr_eeprom_cnt][1] == Mb_Dbuff_Over_All_Func)
		{
			Eeprom_Rbuf[Mb_Dbuff_Over_All_Func] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
			AT24CxxWriteOneByte(Mb_Dbuff_Over_All_Func,Eeprom_Rbuf[Mb_Dbuff_Over_All_Func]);
			DCPDU_Modbus_Reg[Mb_Dbuff_Over_All_Func] = Eeprom_Rbuf[Mb_Dbuff_Over_All_Func];
		}
		Modbus_Wr_buff[Wr_eeprom_cnt][0] = 0;
		Wr_eeprom_begin_flag = true;
	}
	Wr_eeprom_cnt++;
	if(Wr_eeprom_cnt >= Mb_Wcmd_Width)
	{
		Wr_eeprom_cnt = 0;
	}
}

/*********************************************************************************************************
* 函数名称：Init_Dev_parameter
* 函数功能：初始化模块内部参数
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2024年04月06日
* 注    意：
*********************************************************************************************************/
void Init_Dev_parameter(void)
{
	uint8_t i = 0;
	uint8_t j = 0;
	uint8_t temp1 = 0;
	uint8_t temp2 = 0;
	uint32_t temp0 = 0;
	uint32_t temp_da[8] = {0};
	while(!dma_flag_get(DMA_CH0,DMA_FLAG_FTF));
	dma_flag_clear(DMA_CH0,DMA_FLAG_FTF);
	for(i = 0;i < 8;i++)
	{
		adc_data_zero[i] = adc_original_value[i];
	}
#if (SUPPORT_IM1253E == 0)
	
#if SUPPORT_ADC_GATHER_V
	adc_data_zero[ADC_VOL] = adc_original_value[ADC_VOL] = 0x01;
#endif

#else
	Init_IM1253E_flag = true;
	while(Init_IM1253E_flag)
	{
		if(Read_IM1253E_flag)
		{
			Read_IM1253E_flag = false;
			Read_IM1253E_REG(Device_addr_IM1253E,V_REG_ADDR,8);//Device_addr_IM1253E
		}
		if(Rx_Finish_flag)
		{
			Rx_Finish_flag = false;
			for(j = 0;j < 8;j++)
			{
				temp_da[j] = 0;
				for(i = 0;i < 4;i++)
				{
					temp1 = 8 * i;
					temp1 = 24 - temp1;
					temp2 = 4 * j;
					temp2 += 3;
					temp2 += i;
					temp0 = Rx_Data_buff_IM1253E[temp2] << temp1;
					temp_da[j] += temp0;
				}
			}
			DCPDU_Iin_Zero = temp_da[1] / 10;
			DCPDU_Win_Zero = temp_da[2] / 10;
			
			DCPDU_Modbus_Reg[Mb_Dbuff_VInput_Addr] = temp_da[0] / 10;//输入电压

			for(i = 0;i < RELAY_ChN_default;i++)
			{
				temp0 = 4 * i;
				DCPDU_Modbus_Reg[Mb_Dbuff_P1Output_Addr + temp0] = DCPDU_Modbus_Reg[Mb_Dbuff_VInput_Addr];//输出电压
				temp2 = 0x01 << i;
				if((DCPDU_Modbus_Reg[Mb_Dbuff_VInput_Addr] > DCPDU_Modbus_Reg[Mb_Dbuff_VLit1_max_Addr + i]) || (DCPDU_Modbus_Reg[Mb_Dbuff_VInput_Addr] < DCPDU_Modbus_Reg[Mb_Dbuff_VLit1_min_Addr + i]))
				{
					Fault_state_V |= temp2;
				}
				else
				{
					if((Fault_state_V & temp2) > 0)
					{
						temp1 = ~temp2;
						Fault_state_V &= temp1;
					}
				}
			}
			Init_IM1253E_flag = false;
			IM1253E_OK_flag = true;
		}
	}
#endif
}
/*freemodbus作者使用了assert，故增加如下代码，同时
*options for target 对话框，target页面，勾选Use MicroLib
*/
#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred. 
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None 
  */ 
void assert_failed(uint8_t* file, uint32_t line) 
{ 
  while (1) 
  { 
  } 
}
#else
void __aeabi_assert(const char * x1, const char * x2, int x3)
{
	(void)x3;
}
#endif