SmartPDCode/control/PDU_Triphasic_Total_Detection/App/Main/Main.c

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

/*********************************************************************************************************
*                                              包含头文件
*********************************************************************************************************/
#include "Main.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 "mb.h"
#include "Wwdgt.h"
#include "At24cxx.h"
#include "I2c.h"
#include "ReadEeprom.h"
#include "Sn74hc573.h"
#include <stdbool.h>
#include "Uart1.h"
#include "Hlw8110.h"
#include "stdint.h"
#include "Fwdgt.h"
//#include "HT7032_SPI.h"
/*********************************************************************************************************
*                                              宏定义
*********************************************************************************************************/

/*********************************************************************************************************
*                                              枚举结构体
*********************************************************************************************************/
AC3PPDU_RELAY_Para_Reg AC3PPDU_RL_time[Output_ChN_default + 2] = {0};//包括输入
AC_Output_struct_Reg  AC3PPDU_Output[Output_ChN_default + 2] = {0}; 
 
// Ch n  relay control 
AC3PPDU_RELAY_Para_Reg AC3PPDU_RL_N_time;					// add by liyi

/*********************************************************************************************************
*                                              内部变量定义
*********************************************************************************************************/
static uint8_t AC3PPDU_SlaveAddress = 0x00;
uint16_t Devid_IDChalNum = 0; //设备类型和通道数

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

bool Vin_LTmax_Enable_flag = false;
bool Vin_LTmin_Enable_flag = false;
bool Iin_LTmax_Enable_flag = false;
bool Win_LTmax_Enable_flag = false;
bool kWhin_LTmax_Enable_flag = false;
static bool Fault_lack_phase_flag = true;

uint8_t OutUnit_control_flag[Output_ChN_default +1] = {0};
uint8_t Vout_LTmax_Enable_flag[Output_ChN_default + 1] = {0};
uint8_t Vout_LTmin_Enable_flag[Output_ChN_default + 1] = {0};
uint8_t Iout_LTmax_Enable_flag[Output_ChN_default + 1] = {0};
uint8_t Wout_LTmax_Enable_flag[Output_ChN_default + 1] = {0};
uint8_t kWhout_LTmax_Enable_flag[Output_ChN_default + 1] = {0};
uint8_t Wr_eeprom_cnt = 0;
uint8_t cnt = 0;
uint8_t RL_begin_delay_flag[Output_ChN_default+1] = {0x00};
uint8_t RL_end_delay_flag[Output_ChN_default+1] = {0x00};
uint8_t RL_ON_flag[Output_ChN_default+1] = {0x00};
uint8_t RL_OFF_flag[Output_ChN_default+1] = {0x00};
uint8_t RL_Ton_en_flag[Output_ChN_default+1] = {0x00};
uint8_t RL_Toff_en_flag[Output_ChN_default+1] = {0x00};
uint8_t RL_last_state[Output_ChN_default+1] = {0};
uint8_t RL_now_state[Output_ChN_default+1] = {0};

uint8_t RL_Func_statu[Output_ChN_default + 1] = {0};
//uint32_t Hlw8110_Flash_value[Output_ChN_default + 1] = {0};
//extern uint32_t Hlw8110_Flash_Backup[Output_ChN_default + 1];



// Ch N relay control
uint8_t OutUnit_N_control_flag = 0;	//add by liyi
uint8_t RL_N_begin_delay_flag = 0;  //add by liyi
uint8_t RL_N_end_delay_flag = 0;		// add by liyi
uint8_t RL_N_ON_flag = 0;						// add by liyi
uint8_t RL_N_OFF_flag = 0;					// add by liyi
uint8_t RL_N_Ton_en_flag = 0;				// add by liyi
uint8_t RL_N_Toff_en_flag = 0;			// add by liyi
uint8_t RL_N_last_state=0;				// add by liyi
uint8_t RL_N_now_state=0;					// add by liyi

extern uint32_t RL_N_delay_cnt;			// add by liyi
extern uint32_t RL_N_delay_Limit;			// add by liyi



uint8_t reset_hlw8110_flag[Output_ChN_default + 1]={0};

uint32_t hlw8110_base[Output_ChN_default + 1] = {0}; //add by liyi
extern float hlw8110_store[Output_ChN_default + 1];
uint8_t write_kwh2Eeprom_flag = 0;

//uint32_t HLW8110_BasekWh[Output_ChN_default + 1]={0};


uint8_t AC3PPDU_active_chn = Output_ChN_default;

uint16_t Fault_state_Reg = 0;
uint16_t Fault_state_Last = 0;

uint8_t AC3PPDU_Vmax_LTen_flag[Output_ChN_default+1] = {0x01};
uint8_t AC3PPDU_Vmin_LTen_flag[Output_ChN_default+1] = {0x01};
uint8_t AC3PPDU_Imax_LTen_flag[Output_ChN_default+1] = {0x01};
uint8_t AC3PPDU_Wmax_LTen_flag[Output_ChN_default+1] = {0x01};
uint8_t AC3PPDU_kWhmax_LTen_flag[Output_ChN_default+1] = {0x01};


uint16_t Wr_erom_wait_cnt = 0;
uint16_t AC3PPDU_In_FtSt_flag = 0xffff;

uint32_t AC3PPDU_Iout_Zero[Output_ChN_default + 1] = {0};
uint32_t AC3PPDU_Modbus_Reg[AC3PPDU_Modbus_Reg_len] = {0};
uint32_t AC3PPDU_Iin_Zero = 0;
uint32_t AC3PPDU_Win_Zero = 0;


uint8_t kwh_200ms_read_flag = 0;


uint32_t dev_info = 0;

extern uint8_t ch_cnt;
extern uint16_t Relay_state;
extern uint32_t RL_delay_Limit[Output_ChN_default + 1];
extern uint32_t Modbus_Wr_buff[Mb_Wcmd_Width][Mb_Wcmd_len];
/*********************************************************************************************************
*                                              内部函数声明
*********************************************************************************************************/
static void InitSoftware(void);   			//初始化软件相关的模块
static void InitHardware(void);   			//初始化硬件相关的模块
static void CHK_JLINK(void);
static void MODbus_CMD(void);
static void MODbus_CMD_New(void);
static void Read_HT7032_data(uint8_t cs_x);
void LimiT_enable_check(uint8_t chx,uint32_t Lt_v);
static void Fault_state_process(uint8_t ch_x);
void hlw8110_init(uint8_t ch_x);
void channel_reset(uint8_t ch_x);
static bool select_channel(uint8_t ch_x);
/*********************************************************************************************************
*                                              内部函数实现
*********************************************************************************************************/
/*********************************************************************************************************
* 函数名称：InitSoftware
* 函数功能：所有的软件相关的模块初始化函数都放在此函数中
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2024年05月20日
* 注    意：
*********************************************************************************************************/
static  void  InitSoftware(void)
{
	eMBInit(MB_RTU, AC3PPDU_SlaveAddress, 0, Uart0_Baud, MB_PAR_NONE);		// 初始化modbus为RTU方式，地址RelaySlaveAddress, 波特率Uart0_Baud，无校验
	eMBEnable();	// 使能modbus协议栈
	
}


static bool select_channel(uint8_t ch_x)
{
	if(ch_x == 0)
		return false;
	switch(ch_x)
	{
		case CH1_out:
		{
				SEL_0_H;
				SEL_1_H;
				SEL_2_H;
		}
			break;
		case CH2_out:
		{
				SEL_0_L;
				SEL_1_H;
				SEL_2_H;
		}
			break;
		case CH3_out:
		{
				SEL_0_H;
				SEL_1_L;
				SEL_2_H;
		}
			break;
		default:
			return false;
	}
	return true;
}


void hlw8110_init(uint8_t ch_x)
{
	if(select_channel(ch_x) == false)
		return;
	Init_HLW8110();
}

void channel_reset(uint8_t ch_x)
{
	int i = 100;
	if(select_channel(ch_x) == false)
		return;
	Uart_HLW8110_Reset();
	//delay_ms(10);
	while(i--);
}


/*********************************************************************************************************
* 函数名称：InitHardware
* 函数功能：所有的硬件相关的模块初始化函数都放在此函数中
* 输入参数：void
* 输出参数：void
* 返 回 值：void米皮米mimMMDAAADFADAdadafadfyang
* 创建日期：2024年05月20日
* 注    意：
*********************************************************************************************************/
static  void  InitHardware(void)
{  
	SystemInit();        //系统初始化，函数里面默认是配置为内部晶振
	ViewRcuClock();			 //在线调试查看系统时钟频率
	InitNVIC();          //初始化NVIC模块 
	InitSysTick();       //初始化SysTick模块
	InitLED();           //初始化LED模块
	InitKey();           //初始化Key模块
	InitRelay();				 //初始化Relay模块
	Init_74hc573();				 //初始化74hc573锁存器
	InitTimer();         //初始化Timer模块
	InitAT24Cxx();			 //初始化24C64模块	
	ReadEeprom();
	//InitWwdgt();
	InitUART1(9600);
	InitCH448F();
	int i;
	for(i = 1; i <=AC3PPDU_active_chn;i++)
	{
		hlw8110_init(i);
	}
	
	//init_HT7032_SPI();
}
/*********************************************************************************************************
* 函数名称：CHK_JLINK
* 函数功能：检测JLINK有没有插上
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2024年05月20日
* 注    意：
*********************************************************************************************************/
static  void  CHK_JLINK(void)
{
	uint8_t i = 0;
	uint8_t j = 0;
	uint8_t temp0 = 0;
	uint8_t t_RL_state = 0;
	
	if(Chk_Jlink_conn() == false)//如果有jlink接入，则不会动作继电器，直接跳出进入主函数
	{
		//if(Fault_lack_phase_flag == false)//无缺相故障才能操作继电器
		{
//			DB_Out1_H;
//			DB_Out2_H;
//			DB_Out3_H;
//			DB_Out4_H ;
//			delay_ms(100);
//			DB_Out1_L;
//			DB_Out2_L;
//			DB_Out3_L;
//			DB_Out4_L; 
//			
//			BUFF_Data;
//			LOCK_Data;
			// Ch  N 
			RL_N_now_state = AC3PPDU_RL_N_time.LT_state & 0x01;
			if(RL_N_now_state != RL_N_last_state)
			{
				if(RL_N_now_state > 0) {		//open
					RL_N_ON_flag = 1;					// Ch N open flag
					RL_N_OFF_flag = 0;
					if((AC3PPDU_RL_N_time.LT_state & 0x40) > 0){	// Ch N have delay
						RL_N_begin_delay_flag = 1;
						RL_N_end_delay_flag = 0;
						RL_N_delay_Limit = AC3PPDU_RL_N_time.RL_ontime * 1000; // exchange to ms
					}else {
						RL_N_begin_delay_flag = 0;
						RL_N_end_delay_flag = 1;
						RL_N_delay_Limit = 0;
					}
					
				}else {		//close
					 RL_N_ON_flag = 0;					
					 RL_N_OFF_flag = 1;			// Ch N close flag
					if((AC3PPDU_RL_N_time.LT_state & 0x80) > 0)//有延时
						{
							RL_N_begin_delay_flag = 1;
							RL_N_end_delay_flag = 0;
							RL_N_delay_Limit = AC3PPDU_RL_N_time.RL_offtime * 1000;//秒转成毫秒
						}
						else//无延时
						{
							RL_N_begin_delay_flag = 0;
							RL_N_end_delay_flag = 1;
							RL_N_delay_Limit = 0;
						}
				}
				RL_N_last_state = RL_N_now_state;
			}else{
				OutUnit_N_control_flag = 0;
			}
			if(RL_N_end_delay_flag > 0){
				RL_N_begin_delay_flag = 0;
				RL_N_end_delay_flag = 0;
				if(RL_N_ON_flag > 0){
					DB_Out4_H;
					RL_N_ON_flag = 0;
					AC3PPDU_Modbus_Reg[Mb_Dbuff_CHNLT_ST_Addr] = AC3PPDU_RL_N_time.LT_state | 0x00000001;
				}else if(RL_N_OFF_flag > 0)
				{
					DB_Out4_L;
					RL_N_OFF_flag = 0;
					AC3PPDU_Modbus_Reg[Mb_Dbuff_CHNLT_ST_Addr] = AC3PPDU_RL_N_time.LT_state | 0xfffffffe;
				}else{
				}
				//lock
					BUFF_Data;
					LOCK_Data;
			}
			
			for(i = 0;i < Output_ChN_default;i++)
			{
				RL_now_state[i] = AC3PPDU_RL_time[i + CH1_out].LT_state & 0x01;
				if(RL_last_state[i] != RL_now_state[i])
				{
					if(RL_now_state[i] > 0)//开启
					{
						RL_ON_flag[i] = 1;
						RL_OFF_flag[i] = 0;
						if((AC3PPDU_RL_time[i + CH1_out].LT_state & 0x40) > 0)//有延时
						{
							RL_begin_delay_flag[i] = 1;
							RL_end_delay_flag[i] = 0;
							RL_delay_Limit[i] = AC3PPDU_RL_time[i + CH1_out].RL_ontime * 1000;//秒转成毫秒
						}
						else//无延时
						{
							RL_begin_delay_flag[i] = 0;
							RL_end_delay_flag[i] = 1;
							RL_delay_Limit[i] = 0;
						}
					}
					else//断开
					{
						RL_OFF_flag[i] = 1;
						RL_ON_flag[i] = 0;
						if((AC3PPDU_RL_time[i + CH1_out].LT_state & 0x80) > 0)//有延时
						{
							RL_begin_delay_flag[i] = 1;
							RL_end_delay_flag[i] = 0;
							RL_delay_Limit[i] = AC3PPDU_RL_time[i + CH1_out].RL_offtime * 1000;//秒转成毫秒
						}
						else//无延时
						{
							RL_begin_delay_flag[i] = 0;
							RL_end_delay_flag[i] = 1;
						}
					}
					RL_last_state[i] = RL_now_state[i];
				}
				else
				{
					if(OutUnit_control_flag[i] > 0)
					{
						OutUnit_control_flag[i] = 0;
					}
				}
				///////
				if(RL_end_delay_flag[i] > 0)
				{
					RL_begin_delay_flag[i] = 0;
					RL_end_delay_flag[i] = 0;
					if(RL_ON_flag[i] > 0)
					{
						//Relayx_Onoff_state(i,RELAY_ON);
						// setting relay status
						switch (i)
						{
							case 0:
								DB_Out1_H;
								break;
							case 1:
								DB_Out2_H;
								break;
							case 2:
								DB_Out3_H;
								break;
						}
						RL_ON_flag[i] = 0;
						
						AC3PPDU_Modbus_Reg[Mb_Dbuff_CH1LT_ST_Addr + i] = AC3PPDU_RL_time[i + CH1_out].LT_state | 0x00000001;
						
						AC3PPDU_Modbus_Reg[Mb_Dbuff_OUTCH1_ST_Addr + (i % 3)] = AC3PPDU_RL_time[i + CH1_out].LT_state | 0x00000001;
					}
					else if(RL_OFF_flag[i] > 0)
					{
						//Relayx_Onoff_state(i,RELAY_OFF);
						RL_OFF_flag[i] = 0;
						
						switch (i)
						{
							case 0:
								DB_Out1_L;
								break;
							case 1:
								DB_Out2_L;
								break;
							case 2:
								DB_Out3_L;
								break;
						}
						AC3PPDU_Modbus_Reg[Mb_Dbuff_CH1LT_ST_Addr + i]  = AC3PPDU_RL_time[i + CH1_out].LT_state & 0xfffffffe;
						AC3PPDU_Modbus_Reg[Mb_Dbuff_OUTCH1_ST_Addr + (i % 3)]  = AC3PPDU_RL_time[i + CH1_out].LT_state & 0xfffffffe;
					}
					
					//Write_74hc573(LK_Relay_D,Relay_state);
					BUFF_Data;
					LOCK_Data;
				}
			}
			RL_Allon_flag = false;
			RL_Alloff_flag = false;
		}
	}
}

//static uint8_t _check(uint8_t *sourse,uint8_t *read,int size)
//{
//	for(int i =0; i < size;i++)
//	{
//		if(sourse[i] == read[i])
//		{
//			
//		}else
//		{
//			return 1;
//		}
//	}
//	return 0;
//}
//static uint8_t write_buff[10] = {0};
//static uint8_t read_buff[10] = {0};

//static void iic_allopen(void)
//{
//	uint8_t i = 0;
//	uint32_t temp_addr;
//	//unsigned char buff[100] = {0};
//	memset(write_buff,0,10);
//	memset(read_buff,0,10);
//	for(i = 0;i < Output_ChN_default;i++)
//	{
//		temp_addr = i << 1; 
//		Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr] = Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr] | 0x41;
//		AC3PPDU_RL_time[i + CH1_out].LT_state = Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr];
//	}		
//	memcpy(write_buff,(Eeprom_Rbuf + ERom_CH1LT_ST_Addr),(2*Output_ChN_default));
//	AT24CxxWrite(ERom_CH1LT_ST_Addr,write_buff,(2*Output_ChN_default));
//	AT24CxxRead(ERom_CH1LT_ST_Addr,read_buff,(2*Output_ChN_default));
//	if(_check(write_buff,read_buff,(2*Output_ChN_default)))
//	{
//		
//	}
//}
//static void iic_allclose(void)
//{
//	uint8_t i = 0;
//	uint32_t temp_addr;
//	//unsigned char buff[100] = {0};
//	memset(write_buff,0,10);
//	memset(read_buff,0,10);
//	
//	for(i = 0;i < Output_ChN_default;i++)
//	{
//		temp_addr = i << 1;
//		Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr] = Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr] | 0x80;
//		Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr] = Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr] & 0xfe;
//		AC3PPDU_RL_time[i + CH1_out].LT_state = Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr];
//	}
//	
//	memcpy(write_buff,(Eeprom_Rbuf + ERom_CH1LT_ST_Addr),(2*Output_ChN_default));
//	AT24CxxWrite(ERom_CH1LT_ST_Addr,write_buff,(2*Output_ChN_default));
//	AT24CxxRead(ERom_CH1LT_ST_Addr,read_buff,(2*Output_ChN_default));
//	if(_check(write_buff,read_buff,(2*Output_ChN_default)))
//	{
//		
//	}
//}

// point 3Phase   add by liyi
static void check_3_phse()
{
	uint8_t Phase_3_Close_flag=0;
	
	if(3 == Phase_N){
		for(int i = 0 ; i < Output_ChN_default; i += 3 )
		{
			Phase_3_Close_flag = 0;
			for(int j = 1;j <= 3;j++)
			{
				if(RL_Func_statu[j+i] == 1)
				{
					Phase_3_Close_flag = 1;
					break;
				}
			}
			if(Phase_3_Close_flag)
			{
				for(int j = 1;j <= 3;j++)
				{
					RL_Func_statu[j+i] = 1;
				}
			}
			Phase_3_Close_flag = 0;
		}
	}
}



static void RL_Over_Func()
{
	
	check_3_phse();
	for(int i = 0; i < Output_ChN_default;i++)
	{
		if(RL_Func_statu[i+1])
		{
			switch(i)
			{
				case 0:
					DB_Out1_L;		
					break;
				case 1:
					DB_Out2_L;
					break;
				case 2:
					DB_Out3_L;
				break;
				case 3:
				case 4:
				case 5:
				case 6:
				case 7:
				case 8:
				default:
					break;
			}
			AC3PPDU_RL_time[i + CH1_out].LT_state = AC3PPDU_RL_time[i + CH1_out].LT_state &0xfffffffe;
			RL_now_state[i] = AC3PPDU_RL_time[i + CH1_out].LT_state & 0x01;
			if(RL_now_state[i] != RL_last_state[i])
			{
				RL_last_state[i] = RL_now_state[i];
			}
			
			AC3PPDU_Modbus_Reg[Mb_Dbuff_CH1LT_ST_Addr + i]  = AC3PPDU_RL_time[i + CH1_out].LT_state;	
			AC3PPDU_Modbus_Reg[Mb_Dbuff_OUTCH1_ST_Addr + (i % 3)]  = AC3PPDU_RL_time[i + CH1_out].LT_state;
			
			AC3PPDU_RL_N_time.LT_state  = AC3PPDU_RL_N_time.LT_state &0xfffffffe;
			RL_N_now_state = AC3PPDU_RL_N_time.LT_state & 0x01;
			if(RL_N_now_state != RL_N_last_state)
			{
				RL_N_last_state = RL_N_now_state;
			}
			DB_Out4_L;
			AC3PPDU_Modbus_Reg[Mb_Dbuff_CHNLT_ST_Addr] = AC3PPDU_RL_N_time.LT_state | 0xfffffffe;
			RL_Func_statu[i+1] = 0;
		}
	}
	BUFF_Data;
	LOCK_Data;
}



/*********************************************************************************************************
* 函数名称：main
* 函数功能：主函数 
* 输入参数：void
* 输出参数：void
* 返 回 值：int
* 创建日期：2024年05月20日
* 注    意：
*********************************************************************************************************/
int main(void)
{
	uint8_t i = 0;
	uint8_t j = 0;
	uint8_t cnt = 0;
	uint32_t temp0 = 0;
	uint8_t temp1 = 0;
	uint8_t temp2 = 0;
	uint32_t temp3 = 0;
	uint8_t temp4 = 0;
	uint32_t temp_da[8] = {0};
	uint32_t temp5 = 0;
	uint32_t temp6 = 0;
	uint32_t temp7 = 0;
	Wr_eeprom_cnt = 0;
	Wr_erom_wait_cnt = 0;
	Load_conn_end_flag = false;
	AC3PPDU_active_chn = Output_ChN_default;
	for(i = 0;i < AC3PPDU_active_chn;i++)
	{
		RL_begin_delay_flag[i] = 0;
		RL_end_delay_flag[i] = 0;
	}
	// Ch N RELAY delay  add by liyi
	RL_N_begin_delay_flag = 0;				//add by liyi
	RL_N_end_delay_flag = 0;					//add by liyi
	
	
	InitHardware();   						//初始化硬件相关函数
	AC3PPDU_SlaveAddress = ReadKeyValue();	//读取从机的地址
	InitSoftware(); 	                    //初始化软件相关函数
	
	Devid_IDChalNum = AC3PPDU_Device_ID;
	Devid_IDChalNum = Devid_IDChalNum << 8;
	Devid_IDChalNum += Output_ChN_default;
	AC3PPDU_Modbus_Reg[Mb_Dbuff_DevAddr] = Devid_IDChalNum;
	
	AC3PPDU_RL_time[CH_in].LT_state = AC3PPDU_Modbus_Reg[Mb_Dbuff_LT_ST_Addr];
	AC3PPDU_RL_time[CH_in].FT_state = AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr];
	LimiT_enable_check(CH_in,AC3PPDU_RL_time[CH_in].LT_state);
	Enable_74hc573_Output;
	for(i = 0;i < Output_ChN_default;i++)
	{
		RL_last_state[i] = 0;
		AC3PPDU_RL_time[i + CH1_out].LT_state = AC3PPDU_Modbus_Reg[Mb_Dbuff_CH1LT_ST_Addr + i];
		AC3PPDU_RL_time[i + CH1_out].RL_ontime = AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_Ton1_Addr + i];
		AC3PPDU_RL_time[i + CH1_out].RL_offtime = AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_Toff1_Addr + i];
		LimiT_enable_check((i + CH1_out),AC3PPDU_RL_time[i + CH1_out].LT_state);
	}
	// Ch N add by liyi
	RL_N_last_state = 0;
	AC3PPDU_RL_N_time.LT_state = AC3PPDU_Modbus_Reg[Mb_Dbuff_CHNLT_ST_Addr];					// add by liyi
	AC3PPDU_RL_N_time.RL_offtime = AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_ToffN_Addr];				// add by liyi
	AC3PPDU_RL_N_time.RL_ontime = AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_TonN_Addr];					// add by liyi
	
	AC3PPDU_active_chn = Output_ChN_default;   //bug
	Fault_state_Last = Fault_state_Reg;
	
	AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] = AC3PPDU_APlack_Fault + AC3PPDU_BPlack_Fault;
	AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] += AC3PPDU_CPlack_Fault;
	
	Fwdgt_Init();								//
	while(1)
	{
			//DelayNms(10);
		Fwdgt_reload();	
		dev_info = (AC3PPDU_Device_ID << 8 | Output_ChN_default);
			//CHK_JLINK();
		eMBPoll();
		if(Get1SecFlag()) //判断1s标志状态
		{
			LEDFlicker2();
			Clr1SecFlag();  //清除1s标志
			
		}
		if(write_kwh2Eeprom_flag)			// 120 second recode
		{
			write_kwh2Eeprom_flag = 0;
			for(i = 0; i < Output_ChN_default ;i++)
			{
				int temp = i << 2;
				Eeprom_Rbuf[ERom_TotalWh1_Addr+temp+0] = AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr+i] >> 24;
				Eeprom_Rbuf[ERom_TotalWh1_Addr+temp+1] = AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr+i] >> 16;
				Eeprom_Rbuf[ERom_TotalWh1_Addr+temp+2] = AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr+i] >> 8;
				Eeprom_Rbuf[ERom_TotalWh1_Addr+temp+3] = AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr+i];
			}
			AT24CxxWrite(ERom_TotalWh1_Addr,(Eeprom_Rbuf + ERom_TotalWh1_Addr),4*Output_ChN_default);
		}
//		if(kwh_200ms_read_flag)
//		{
//			for(i = 0; i < Output_ChN_default ;i++)
//			{
//				read_Hlw8110_kWh(i);
//			}
//			kwh_200ms_read_flag = 0;
//		}
        ////故障指示处理/////
		
		if(Fault_state_Reg > 0)
		{
			if(Fault_state_Reg != Fault_state_Last)
			{
				//RL_now_state = RL_now_state & (~Fault_state_Reg);
//				Write_74hc573(LK_FalseLed_D,Fault_state_Reg);
//				Fault_state_Last = Fault_state_Reg;
			}
		}
		else
		{
			
		}
		
		//////////////////////////
		if(Start_Read_Flag)//读数据
		{
			Start_Read_Flag = false;
//			for(i = 0;i < HT7032_CS;i++)
//			{
//			//	Read_HT7032_data(i);
//				//read Hlw8110 eche one data;
//				
//				
//			}
			if(kwh_200ms_read_flag)
			{
				for(int j = 0 ; j < Hlw8110_CS;j++)
				{
					//if(!reset_hlw8110_flag[j])
						read_Hlw8110(j,1);
				}
				kwh_200ms_read_flag = 0;
			}else
			{
				for(int j = 0 ; j < Hlw8110_CS;j++)
				{
					//if(!reset_hlw8110_flag[j])
						read_Hlw8110(j,0);
				}
			}
			
			//输入A相电压，平均
			AC3PPDU_Modbus_Reg[Mb_Dbuff_VAP_Addr] = AC3PPDU_Output[CH1_out].AC_V;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_VAP_Addr] += AC3PPDU_Output[CH4_out].AC_V;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_VAP_Addr] += AC3PPDU_Output[CH7_out].AC_V;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_VAP_Addr] /= 3;
			//输入B相电压，平均
			AC3PPDU_Modbus_Reg[Mb_Dbuff_VBP_Addr] = AC3PPDU_Output[CH2_out].AC_V;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_VBP_Addr] += AC3PPDU_Output[CH5_out].AC_V;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_VBP_Addr] += AC3PPDU_Output[CH8_out].AC_V;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_VBP_Addr] /= 3;
			//输入C相电压，平均
			AC3PPDU_Modbus_Reg[Mb_Dbuff_VCP_Addr] = AC3PPDU_Output[CH3_out].AC_V;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_VCP_Addr] += AC3PPDU_Output[CH6_out].AC_V;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_VCP_Addr] += AC3PPDU_Output[CH9_out].AC_V;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_VCP_Addr] /= 3;
			//输入A相电流，求和
			AC3PPDU_Modbus_Reg[Mb_Dbuff_IAP_Addr] = AC3PPDU_Output[CH1_out].AC_I;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_IAP_Addr] += AC3PPDU_Output[CH4_out].AC_I;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_IAP_Addr] += AC3PPDU_Output[CH7_out].AC_I;
			//输入B相电流，求和
			AC3PPDU_Modbus_Reg[Mb_Dbuff_IBP_Addr] = AC3PPDU_Output[CH2_out].AC_I;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_IBP_Addr] += AC3PPDU_Output[CH5_out].AC_I;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_IBP_Addr] += AC3PPDU_Output[CH8_out].AC_I;
			//输入C相电流，求和
			AC3PPDU_Modbus_Reg[Mb_Dbuff_ICP_Addr] = AC3PPDU_Output[CH3_out].AC_I;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_ICP_Addr] += AC3PPDU_Output[CH6_out].AC_I;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_ICP_Addr] += AC3PPDU_Output[CH9_out].AC_I;
			//输入A相功率，求和
			AC3PPDU_Modbus_Reg[Mb_Dbuff_WAP_Addr] = AC3PPDU_Output[CH1_out].AC_P;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_WAP_Addr] += AC3PPDU_Output[CH4_out].AC_P;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_WAP_Addr] += AC3PPDU_Output[CH7_out].AC_P;
			//输入B相功率，求和
			AC3PPDU_Modbus_Reg[Mb_Dbuff_WBP_Addr] = AC3PPDU_Output[CH2_out].AC_P;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_WBP_Addr] += AC3PPDU_Output[CH5_out].AC_P;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_WBP_Addr] += AC3PPDU_Output[CH8_out].AC_P;
			//输入C相功率，求和
			AC3PPDU_Modbus_Reg[Mb_Dbuff_WCP_Addr] = AC3PPDU_Output[CH3_out].AC_P;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_WCP_Addr] += AC3PPDU_Output[CH6_out].AC_P;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_WCP_Addr] += AC3PPDU_Output[CH9_out].AC_P;
			//输入A相电量，求和
			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr] = hlw8110_base[CH1_out] + (hlw8110_store[CH1_out]*1000);
			//AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr] += AC3PPDU_Output[CH1_out].AC_kWh;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr] += AC3PPDU_Output[CH4_out].AC_kWh;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr] += AC3PPDU_Output[CH7_out].AC_kWh;
			//输入B相电量，求和
			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhBP_Addr] =	hlw8110_base[CH2_out] + (hlw8110_store[CH2_out]*1000);
			//AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhBP_Addr] += AC3PPDU_Output[CH2_out].AC_kWh;
			
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhBP_Addr] += AC3PPDU_Output[CH5_out].AC_kWh;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhBP_Addr] += AC3PPDU_Output[CH8_out].AC_kWh;
			//输入C相电量，求和
			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhCP_Addr] = hlw8110_base[CH3_out] + (hlw8110_store[CH3_out]*1000);
			//AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhCP_Addr] += AC3PPDU_Output[CH3_out].AC_kWh;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhCP_Addr] += AC3PPDU_Output[CH6_out].AC_kWh;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhCP_Addr] += AC3PPDU_Output[CH9_out].AC_kWh;
			
//			HLW8110_BasekWh[CH1_out] += AC3PPDU_Output[CH1_out].AC_kWh;
//			HLW8110_BasekWh[CH2_out] += AC3PPDU_Output[CH2_out].AC_kWh;
//			HLW8110_BasekWh[CH3_out] += AC3PPDU_Output[CH3_out].AC_kWh;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr] = HLW8110_BasekWh[CH1_out];
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhBP_Addr] = HLW8110_BasekWh[CH2_out];
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhCP_Addr] = HLW8110_BasekWh[CH3_out];
			
			
			
			
			//memcpy(&AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr],&HLW8110_BasekWh[CH1_out],4);
			//memcpy(&AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhBP_Addr],&HLW8110_BasekWh[CH2_out],4);
			//memcpy(&AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhCP_Addr],&HLW8110_BasekWh[CH3_out],4);
			

//			for(i =0; i < Output_ChN_default;i++)
//		{
//			temp0 = i << 2;
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr + i] += (Eeprom_Rbuf [ERom_TotalWh1_Addr +temp0+0] << 24);
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr + i] += (Eeprom_Rbuf [ERom_TotalWh1_Addr +temp0+1] << 16);
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr + i] += (Eeprom_Rbuf [ERom_TotalWh1_Addr +temp0+2] << 8);
//			AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr + i] += (Eeprom_Rbuf [ERom_TotalWh1_Addr +temp0+3]);
//		}
			// jugement is or not lack pose
			

			for(i = 0;i < (Output_ChN_default + 1);i++)
			{
				Fault_state_process(i);
			}
			
			//RL_Over_Func();
			//
			if(((AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] & AC3PPDU_APlack_Fault) > 0) || ((AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] & AC3PPDU_BPlack_Fault) > 0) || ((AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] & AC3PPDU_CPlack_Fault) > 0))
			{
				Fault_lack_phase_flag = true;
			}
			else
			{
				Fault_lack_phase_flag = false;
			}
			
			for(i = 0;i < Output_ChN_default;i++)
			{
				if(AC3PPDU_Modbus_Reg[Mb_Dbuff_CH1FT_ST_Addr + i] > 0)
				{
					Fault_state_Reg = Fault_state_Reg | (0x0001 << i);
				}
				else
				{
					Fault_state_Reg = Fault_state_Reg & (~(0x0001 << i));
				}
			}
		}
		//////////////////////////
		MODbus_CMD_New();
		//FeedWwdgt();
		//MODbus_CMD();
	} 
}



static void MODbus_CMD_New(void)
{
	if(Modbus_Wr_buff[Wr_eeprom_cnt][0] > 0)
	{
		uint8_t i = 0;
		uint32_t temp_addr;
		uint32_t base_addr = Modbus_Wr_buff[Wr_eeprom_cnt][1];
		uint32_t data = Modbus_Wr_buff[Wr_eeprom_cnt][2];
		uint32_t value = 0;
		
		switch(base_addr)
		{
			case Mb_Dbuff_ViLit_max_Addr ... Mb_Dbuff_kWhiLit_max_Addr:						//input votage max votage min current power coustermer add by liyi
				{
					temp_addr = base_addr - Mb_Dbuff_ViLit_max_Addr;
					temp_addr = temp_addr << 2;
					temp_addr += ERom_ViLit_max_Addr;
					Eeprom_Rbuf[temp_addr + 0] = data >> 24;
					Eeprom_Rbuf[temp_addr + 1] = data >> 16;
					Eeprom_Rbuf[temp_addr + 2] = data >> 8;
					Eeprom_Rbuf[temp_addr + 3] = data >> 0;	
					AC3PPDU_Modbus_Reg[base_addr] = data;
					AT24CxxWrite(temp_addr,(Eeprom_Rbuf + temp_addr),4);
				}
				break;
			case Mb_Dbuff_VLit1_max_Addr ... Mb_Dbuff_VLit9_max_Addr:							//output voltage max threod for 1,2,3,4,5,6,7,8,9 channels
				{
					temp_addr = base_addr - Mb_Dbuff_VLit1_max_Addr;
					value = temp_addr;
					temp_addr = temp_addr << 2;
					temp_addr += ERom_VLit1_max_Addr;
					Eeprom_Rbuf[temp_addr + 0] = data >> 24;
					Eeprom_Rbuf[temp_addr + 1] = data >> 16;
					Eeprom_Rbuf[temp_addr + 2] = data >> 8;
					Eeprom_Rbuf[temp_addr + 3] = data >> 0;	
					AC3PPDU_Modbus_Reg[base_addr] = data;
					if(AC3PPDU_Modbus_Reg[base_addr] < THRESHOULD_JUDGMENT)
					{
						AC3PPDU_RL_time[value + CH1_out].LT_state &= (Shield_Vmax_Threshould_Disable);
						LimiT_enable_check((value + CH1_out),AC3PPDU_RL_time[value + CH1_out].LT_state);
					}
					AT24CxxWrite(temp_addr,(Eeprom_Rbuf + temp_addr),4);
				}
				break;
			case Mb_Dbuff_VLit1_min_Addr ... Mb_Dbuff_VLit9_min_Addr:							//output voltage min thred for 1,2,3,4,5,6,7,8,9 channels
			{
					temp_addr = base_addr - Mb_Dbuff_VLit1_min_Addr;
					value = temp_addr;
					temp_addr = temp_addr << 2;
					temp_addr += ERom_VLit1_min_Addr;
					Eeprom_Rbuf[temp_addr + 0] = data >> 24;
					Eeprom_Rbuf[temp_addr + 1] = data >> 16;
					Eeprom_Rbuf[temp_addr + 2] = data >> 8;
					Eeprom_Rbuf[temp_addr + 3] = data >> 0;	
					AC3PPDU_Modbus_Reg[base_addr] = data;
					if(AC3PPDU_Modbus_Reg[base_addr] < THRESHOULD_JUDGMENT)
					{
						AC3PPDU_RL_time[value + CH1_out].LT_state &= (Shield_Vmin_Threshould_Disable);
						LimiT_enable_check((value + CH1_out),AC3PPDU_RL_time[value + CH1_out].LT_state);
					}
					AT24CxxWrite(temp_addr,(Eeprom_Rbuf + temp_addr),4);
			}
				break;
			case Mb_Dbuff_ILit1_max_Addr ... Mb_Dbuff_ILit9_max_Addr:							// output current max throud for 1,2,3,4,5,6,7,8,9 channels
			{
					temp_addr = base_addr - Mb_Dbuff_ILit1_max_Addr;
					value = temp_addr;
					temp_addr = temp_addr << 2;
					temp_addr += ERom_ILit1_max_Addr;
					Eeprom_Rbuf[temp_addr + 0] = data >> 24;
					Eeprom_Rbuf[temp_addr + 1] = data >> 16;
					Eeprom_Rbuf[temp_addr + 2] = data >> 8;
					Eeprom_Rbuf[temp_addr + 3] = data >> 0;	
					AC3PPDU_Modbus_Reg[base_addr] = data;
					if(AC3PPDU_Modbus_Reg[base_addr] < THRESHOULD_JUDGMENT)
					{
						AC3PPDU_RL_time[value + CH1_out].LT_state &= (Shield_Imax_Threshould_Disable);
						LimiT_enable_check((value + CH1_out),AC3PPDU_RL_time[value + CH1_out].LT_state);
					}
					AT24CxxWrite(temp_addr,(Eeprom_Rbuf + temp_addr),4);
			}
				break;
			case Mb_Dbuff_WLit1_max_Addr ... Mb_Dbuff_WLit9_max_Addr:							//output power max .....
			{
					temp_addr = base_addr - Mb_Dbuff_WLit1_max_Addr;
					value = temp_addr;
					temp_addr = temp_addr << 2;
					temp_addr += ERom_WLit1_max_Addr;
					Eeprom_Rbuf[temp_addr + 0] = data >> 24;
					Eeprom_Rbuf[temp_addr + 1] = data >> 16;
					Eeprom_Rbuf[temp_addr + 2] = data >> 8;
					Eeprom_Rbuf[temp_addr + 3] = data >> 0;	
					AC3PPDU_Modbus_Reg[base_addr] = data;
					if(AC3PPDU_Modbus_Reg[base_addr] < THRESHOULD_JUDGMENT)
					{
						AC3PPDU_RL_time[value + CH1_out].LT_state &= (Shield_Wmax_Threshould_Disable);
						LimiT_enable_check((value + CH1_out),AC3PPDU_RL_time[value + CH1_out].LT_state);
					}
					AT24CxxWrite(temp_addr,(Eeprom_Rbuf + temp_addr),4);
			}
				break;
			case Mb_Dbuff_kWhLit1_max_Addr ... Mb_Dbuff_kWhLit9_max_Addr:					//output customers max .....
			{
						temp_addr = base_addr - Mb_Dbuff_kWhLit1_max_Addr;
						value = temp_addr;
						temp_addr = temp_addr << 2;
						temp_addr += ERom_kWhLit1_max_Addr;
						Eeprom_Rbuf[temp_addr + 0] = data >> 24;
						Eeprom_Rbuf[temp_addr + 1] = data >> 16;
						Eeprom_Rbuf[temp_addr + 2] = data >> 8;
						Eeprom_Rbuf[temp_addr + 3] = data >> 0;	
						AC3PPDU_Modbus_Reg[base_addr] = data;
						if(AC3PPDU_Modbus_Reg[base_addr] < THRESHOULD_JUDGMENT)
						{
							AC3PPDU_RL_time[value + CH1_out].LT_state &= (Shield_Kwhmax_Threshould_Disable);
							LimiT_enable_check((value + CH1_out),AC3PPDU_RL_time[value + CH1_out].LT_state);
						}
				
						AT24CxxWrite(temp_addr,(Eeprom_Rbuf + temp_addr),4);
			}
				break;
			case Mb_Dbuff_RL_Allon_Addr:																					//relay all on
			{
//				RL_Allon_flag = true;
//				for(i = 0;i < Output_ChN_default;i++)
//				{
//					temp_addr = i << 1; 
//					Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr] = Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr] | 0x41;
//					AC3PPDU_RL_time[i + CH1_out].LT_state = Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr];
//				}		
//				AT24CxxWrite(ERom_CH1LT_ST_Addr,(Eeprom_Rbuf + ERom_CH1LT_ST_Addr),(2*Output_ChN_default));
//				Eeprom_Rbuf[ERom_CHNLT_ST_Addr] = Eeprom_Rbuf[ERom_CHNLT_ST_Addr] | 0x41;
//				AC3PPDU_RL_N_time.LT_state = Eeprom_Rbuf[ERom_CHNLT_ST_Addr];
//				AT24CxxWrite(ERom_CHNLT_ST_Addr,(Eeprom_Rbuf + ERom_CHNLT_ST_Addr),2);
			}
				break;
			case Mb_Dbuff_RL_Alloff_Addr:																					//relay all off
			{
//				RL_Alloff_flag = true;
//				for(i = 0;i < Output_ChN_default;i++)
//				{
//					temp_addr = i << 1;
//					Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr] = Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr] | 0x80;
//					Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr] = Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr] & 0xfe;
//					AC3PPDU_RL_time[i + CH1_out].LT_state = Eeprom_Rbuf[ERom_CH1LT_ST_Addr + temp_addr];
//				}
//				AT24CxxWrite(ERom_CH1LT_ST_Addr,(Eeprom_Rbuf + ERom_CH1LT_ST_Addr),(2*Output_ChN_default));
//				Eeprom_Rbuf[ERom_CHNLT_ST_Addr] = Eeprom_Rbuf[ERom_CHNLT_ST_Addr] | 0x80;
//				Eeprom_Rbuf[ERom_CHNLT_ST_Addr] = Eeprom_Rbuf[ERom_CHNLT_ST_Addr] & 0xfe;
//				AC3PPDU_RL_N_time.LT_state = Eeprom_Rbuf[ERom_CHNLT_ST_Addr];
//				AT24CxxWrite(ERom_CHNLT_ST_Addr,(Eeprom_Rbuf + ERom_CHNLT_ST_Addr),2);
			}
				break;
			case Mb_Dbuff_LT_ST_Addr:																							//set input status
			{
				AC3PPDU_RL_time[CH_in].LT_state = data;
				Eeprom_Rbuf[ERom_LT_ST_Addr] = data;
				AC3PPDU_Modbus_Reg[base_addr] = data;
				AT24CxxWriteOneByte(ERom_LT_ST_Addr,Eeprom_Rbuf[ERom_LT_ST_Addr]);
				LimiT_enable_check(CH_in,AC3PPDU_RL_time[CH_in].LT_state);
			}
				break;
			case Mb_Dbuff_CH1LT_ST_Addr ...  Mb_Dbuff_CHNLT_ST_Addr:							//set output relay statues
			{
				temp_addr = base_addr - Mb_Dbuff_CH1LT_ST_Addr;
				if(temp_addr == 9) {					//Ch N
					AC3PPDU_RL_N_time.LT_state = data;
				}else{
					if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VLit1_max_Addr + temp_addr] < THRESHOULD_JUDGMENT)
					{
						data &= (Shield_Vmax_Threshould_Disable);
					}
					if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VLit1_min_Addr + temp_addr] < THRESHOULD_JUDGMENT)
					{
						data &= (Shield_Vmin_Threshould_Disable);
					}
					if(AC3PPDU_Modbus_Reg[Mb_Dbuff_ILit1_max_Addr + temp_addr] < THRESHOULD_JUDGMENT)
					{
						data &= (Shield_Imax_Threshould_Disable);
					}
					if(AC3PPDU_Modbus_Reg[Mb_Dbuff_WLit1_max_Addr + temp_addr] < THRESHOULD_JUDGMENT)
					{
						data &= (Shield_Wmax_Threshould_Disable);
					}
					if(AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhLit1_max_Addr + temp_addr] < THRESHOULD_JUDGMENT)
					{
						data &= (Shield_Kwhmax_Threshould_Disable);
					}
					
					AC3PPDU_RL_time[temp_addr + CH1_out].LT_state = data;
					LimiT_enable_check((temp_addr + CH1_out),AC3PPDU_RL_time[temp_addr + CH1_out].LT_state);
				}
				temp_addr = temp_addr << 1;
				temp_addr += ERom_CH1LT_ST_Addr;
				Eeprom_Rbuf[temp_addr] = data;
				AT24CxxWriteOneByte(temp_addr,Eeprom_Rbuf[temp_addr]);
			}
				break;
			case Mb_Dbuff_OUTCH1_ST_Addr ... Mb_Dbuff_OUTCH3_ST_Addr:							//set output channel relay's status
			{
				temp_addr = base_addr - Mb_Dbuff_OUTCH1_ST_Addr;
				OutUnit_control_flag[temp_addr] = 1;
				temp_addr *= 3;
				if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VLit1_max_Addr + temp_addr] < THRESHOULD_JUDGMENT)
				{
					data &= (Shield_Vmax_Threshould_Disable);
				}
				if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VLit1_min_Addr + temp_addr] < THRESHOULD_JUDGMENT)
				{
					data &= (Shield_Vmin_Threshould_Disable);
				}
				if(AC3PPDU_Modbus_Reg[Mb_Dbuff_ILit1_max_Addr + temp_addr] < THRESHOULD_JUDGMENT)
				{
					data &= (Shield_Imax_Threshould_Disable);
				}
				if(AC3PPDU_Modbus_Reg[Mb_Dbuff_WLit1_max_Addr + temp_addr] < THRESHOULD_JUDGMENT)
				{
					data &= (Shield_Wmax_Threshould_Disable);
				}
				if(AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhLit1_max_Addr + temp_addr] < THRESHOULD_JUDGMENT)
				{
					data &= (Shield_Kwhmax_Threshould_Disable);
				}
				
				AC3PPDU_RL_time[temp_addr + CH1_out].LT_state = data;
				AC3PPDU_RL_time[temp_addr + CH2_out].LT_state = data;
				AC3PPDU_RL_time[temp_addr + CH3_out].LT_state = data;
				
				LimiT_enable_check((temp_addr + CH1_out),AC3PPDU_RL_time[temp_addr + CH1_out].LT_state);
				LimiT_enable_check((temp_addr + CH2_out),AC3PPDU_RL_time[temp_addr + CH2_out].LT_state);
				LimiT_enable_check((temp_addr + CH3_out),AC3PPDU_RL_time[temp_addr + CH3_out].LT_state);
				
				temp_addr = temp_addr << 1;
				Eeprom_Rbuf[temp_addr + ERom_CH1LT_ST_Addr] = data;
				Eeprom_Rbuf[temp_addr + ERom_CH2LT_ST_Addr] = data;
				Eeprom_Rbuf[temp_addr + ERom_CH3LT_ST_Addr] = data;
				
				AT24CxxWriteOneByte(temp_addr + ERom_CH1LT_ST_Addr,Eeprom_Rbuf[temp_addr + ERom_CH1LT_ST_Addr]);
				AT24CxxWriteOneByte(temp_addr + ERom_CH2LT_ST_Addr,Eeprom_Rbuf[temp_addr + ERom_CH2LT_ST_Addr]);
				AT24CxxWriteOneByte(temp_addr + ERom_CH3LT_ST_Addr,Eeprom_Rbuf[temp_addr + ERom_CH3LT_ST_Addr]);
				
				/*
				AC3PPDU_RL_time[CH7_out - temp_addr].LT_state = Modbus_Wr_buff[Wr_eeprom_cnt][2];
				AC3PPDU_RL_time[CH8_out - temp_addr].LT_state = Modbus_Wr_buff[Wr_eeprom_cnt][2];
				AC3PPDU_RL_time[CH9_out - temp_addr].LT_state = Modbus_Wr_buff[Wr_eeprom_cnt][2];
				
				LimiT_enable_check((CH7_out - temp_addr),AC3PPDU_RL_time[CH7_out - temp_addr].LT_state);
				LimiT_enable_check((CH8_out - temp_addr),AC3PPDU_RL_time[CH8_out - temp_addr].LT_state);
				LimiT_enable_check((CH9_out - temp_addr),AC3PPDU_RL_time[CH9_out - temp_addr].LT_state);
				
				temp_addr = temp_addr << 1;
				Eeprom_Rbuf[ERom_CH7LT_ST_Addr - temp_addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
				Eeprom_Rbuf[ERom_CH8LT_ST_Addr - temp_addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
				Eeprom_Rbuf[ERom_CH9LT_ST_Addr - temp_addr] = Modbus_Wr_buff[Wr_eeprom_cnt][2];
				
				AT24CxxWriteOneByte(ERom_CH7LT_ST_Addr - temp_addr,Eeprom_Rbuf[ERom_CH7LT_ST_Addr - temp_addr]);
				AT24CxxWriteOneByte(ERom_CH8LT_ST_Addr - temp_addr,Eeprom_Rbuf[ERom_CH8LT_ST_Addr - temp_addr]);
				AT24CxxWriteOneByte(ERom_CH9LT_ST_Addr - temp_addr,Eeprom_Rbuf[ERom_CH9LT_ST_Addr - temp_addr]);*/
			}
				break;
			case Mb_Dbuff_RL_Ton1_Addr ... Mb_Dbuff_RL_TonN_Addr:									//set on status delay for 1,2,3,4,5,6,7,8,9,N channels
			{
//				temp_addr = base_addr - Mb_Dbuff_RL_Ton1_Addr;
//				if(temp_addr == 9){				//Ch   N   add by liyi
//					AC3PPDU_RL_N_time.RL_ontime = data;
//				}else
//				{
//					AC3PPDU_RL_time[temp_addr + CH1_out].RL_ontime = data;
//				}
//				AC3PPDU_RL_N_time.RL_ontime = data;
//				temp_addr += ERom_RL_Ton1_Addr;
//				Eeprom_Rbuf[temp_addr] = data;
//				Eeprom_Rbuf[ERom_RL_TonN_Addr] = data;
//				
//				AC3PPDU_Modbus_Reg[base_addr] = Eeprom_Rbuf[temp_addr];
//				AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_TonN_Addr] = Eeprom_Rbuf[ERom_RL_TonN_Addr];
//				
//				AT24CxxWriteOneByte(temp_addr,Eeprom_Rbuf[temp_addr]);
//				AT24CxxWriteOneByte(ERom_RL_TonN_Addr,Eeprom_Rbuf[ERom_RL_TonN_Addr]);
			}
				break;
			case Mb_Dbuff_RL_Toff1_Addr ... Mb_Dbuff_RL_ToffN_Addr:               //set off status delay for 1,2,3,4,5,6,7,8,9,N channels
			{
//				temp_addr = base_addr - Mb_Dbuff_RL_Toff1_Addr;
//				if(temp_addr == 9){
//					AC3PPDU_RL_N_time.RL_offtime = data;
//				}else {
//					AC3PPDU_RL_time[temp_addr + CH1_out].RL_offtime = data;
//				}
//				AC3PPDU_RL_N_time.RL_offtime = data;
//				temp_addr += ERom_RL_Toff1_Addr;
//				
//				Eeprom_Rbuf[temp_addr] = data;
//				Eeprom_Rbuf[ERom_RL_ToffN_Addr] = data;
//				
//				AC3PPDU_Modbus_Reg[base_addr] = Eeprom_Rbuf[temp_addr];
//				AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_ToffN_Addr] = Eeprom_Rbuf[ERom_RL_ToffN_Addr];
//				
//				AT24CxxWriteOneByte(temp_addr,Eeprom_Rbuf[temp_addr]);
//				AT24CxxWriteOneByte(ERom_RL_ToffN_Addr,Eeprom_Rbuf[ERom_RL_ToffN_Addr]);
			}
				break;
			case Mb_Dbuff_RL_Over_Ch1_Func ... Mb_Dbuff_RL_Over_Ch9_Func:					//threod over limit operation
			{
//				temp_addr = base_addr - Mb_Dbuff_RL_Over_Ch1_Func;
//				temp_addr += ERom_RL_Over_Ch1_Addr;
//				Eeprom_Rbuf[temp_addr] = data;
//				AC3PPDU_Modbus_Reg[base_addr] = Eeprom_Rbuf[temp_addr];
//				AT24CxxWriteOneByte(temp_addr,Eeprom_Rbuf[temp_addr]);
			}
				break;
			case Mb_Dbuff_Clear_Chn1_Consumer ... Mb_Dbuff_Clear_Chn9_Consumer:
			{
				if(data)
				{
					
					temp_addr = base_addr - Mb_Dbuff_Clear_Chn1_Consumer;
//					uint8_t value = temp_addr;
					
					//Hlw8110_Flash_value[temp_addr+CH1_out] = AC3PPDU_Output[temp_addr+CH1_out].AC_kWh;
					//Hlw8110_Flash_value[temp_addr+CH1_out] = Hlw8110_Flash_Backup[temp_addr+CH1_out];
					//hlw8110_base[temp_addr+CH1_out] = 0;
//					temp_addr = temp_addr << 2;
//					temp_addr += ERom_TotalWh1_Addr;
//					Eeprom_Rbuf[temp_addr+0] = 0;
//					Eeprom_Rbuf[temp_addr+1] = 0;
//					Eeprom_Rbuf[temp_addr+2] = 0;
//					Eeprom_Rbuf[temp_addr+3] = 0;
//					channel_reset(temp_addr+CH1_out);
//					InitUART1(9600);
//					hlw8110_init(value+CH1_out);
//					reset_hlw8110_flag[value] = 0;
//					AT24CxxWrite(temp_addr,Eeprom_Rbuf+temp_addr,4);
					
					//HLW8110_BasekWh[temp_addr+CH1_out] = 0;
					hlw8110_base[temp_addr+CH1_out] = 0;
					hlw8110_store[temp_addr+CH1_out] = 0.0;
				}
			}
			case Mb_Dbuff_Clear_Chnall_Consumer:
			{
				if(data){
//					for(i = 0; i < Output_ChN_default ;i++)
//					{
//						int temp = i << 2;
//						//Hlw8110_Flash_value[i+CH1_out] = AC3PPDU_Output[i+CH1_out].AC_kWh;
//						//Hlw8110_Flash_value[i+CH1_out] = Hlw8110_Flash_Backup[i+CH1_out];
//						Eeprom_Rbuf[ERom_TotalWh1_Addr+temp+0] = 0;
//						Eeprom_Rbuf[ERom_TotalWh1_Addr+temp+1] = 0;
//						Eeprom_Rbuf[ERom_TotalWh1_Addr+temp+2] = 0;
//						Eeprom_Rbuf[ERom_TotalWh1_Addr+temp+3] = 0;
//						hlw8110_base[i+CH1_out] = 0;
//						channel_reset(i+CH1_out);
//					}
//						InitUART1(9600);
//						//InitCH448F();
//					for(i = 0; i < Output_ChN_default ;i++)
//					{
//						//hlw8110_init(i+CH1_out);
//						//reset_hlw8110_flag[i] = 0;
//						
//					}
//					AT24CxxWrite(ERom_TotalWh1_Addr,(Eeprom_Rbuf + ERom_TotalWh1_Addr),4*Output_ChN_default);
					for(i = 0; i < Output_ChN_default;i++)
					{
						//HLW8110_BasekWh[CH1_out+i] = 0;
						hlw8110_base[i+CH1_out] = 0;
						hlw8110_store[i+CH1_out] = 0.0;
					}
				}
			}
			break;
			default:
				break;
		}
		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;
	}
}

/*********************************************************************************************************
* 函数名称：MODbus_CMD
* 函数功能：modbus命令池处理
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2024年05月06日
* 注    意：
*********************************************************************************************************/



/*********************************************************************************************************
* 函数名称：LimiT_enable_check
* 函数功能：输入和各输出通道标识位检查
* 输入参数：chx：第x通道或输入通道；Lt_v：对应通道的状态标识值
* 输出参数：void
* 返 回 值：void
* 创建日期：2024年05月06日
* 注    意：
*********************************************************************************************************/
void LimiT_enable_check(uint8_t ch_x,uint32_t Lt_v)
{
	uint16_t temp0 = 0;
	temp0 = Lt_v >> 1;
	if(ch_x > 3)
	{
		return;
	}
	//通道最大电压
	if((temp0 & AC3PPDU_Vmax_LT_enable) == AC3PPDU_Vmax_LT_enable)
	{
		AC3PPDU_Vmax_LTen_flag[ch_x] = 1;
	}
	else
	{
		AC3PPDU_Vmax_LTen_flag[ch_x] = 0;
	}
	//最小电压
	if((temp0 & AC3PPDU_Vmin_LT_enable) == AC3PPDU_Vmin_LT_enable)
	{
		AC3PPDU_Vmin_LTen_flag[ch_x] = 1;
	}
	else
	{
		AC3PPDU_Vmin_LTen_flag[ch_x] = 0;
	}
	//最大电流
	if((temp0 & AC3PPDU_Imax_LT_enable) == AC3PPDU_Imax_LT_enable)
	{
		AC3PPDU_Imax_LTen_flag[ch_x] = 1;
	}
	else
	{
		AC3PPDU_Imax_LTen_flag[ch_x] = 0;
	}
	//最大功率
	if((temp0 & AC3PPDU_Wmax_LT_enable) == AC3PPDU_Wmax_LT_enable)
	{
		AC3PPDU_Wmax_LTen_flag[ch_x] = 1;
	}
	else
	{
		AC3PPDU_Wmax_LTen_flag[ch_x] = 0;
	}
	//最大电量
	if((temp0 & AC3PPDU_kWhmax_LT_enable) == AC3PPDU_kWhmax_LT_enable)
	{
		AC3PPDU_kWhmax_LTen_flag[ch_x] = 1;
	}
	else
	{
		AC3PPDU_kWhmax_LTen_flag[ch_x] = 0;
	}
}
/*********************************************************************************************************
* 函数名称：Fault_state_process
* 函数功能：输入和各输出通道的故障状态处理
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2024年05月06日
* 注    意：
*********************************************************************************************************/
static void Fault_state_process(uint8_t ch_x)
{
	uint16_t i = 0;
	
	if(ch_x != CH_in)
		i = (ch_x -1)<< 3;
	
	
	if(ch_x == CH_in)
	{
		uint32_t sort_buff[3] = {0};
		uint32_t Vmax = 0;
		uint32_t Vmin = 0;
		sort_buff[0] = AC3PPDU_Modbus_Reg[Mb_Dbuff_VAP_Addr];
		sort_buff[1] = AC3PPDU_Modbus_Reg[Mb_Dbuff_VBP_Addr];
		sort_buff[2] = AC3PPDU_Modbus_Reg[Mb_Dbuff_VCP_Addr];
		Vmax = (sort_buff[0] >= sort_buff[1]) ? sort_buff[0] :sort_buff[1];
		Vmax = (Vmin >= sort_buff[2]) ? Vmax : sort_buff[2];
		
		Vmin = (sort_buff[0] <= sort_buff[1]) ? sort_buff[0] :sort_buff[1];
		Vmin = (Vmin <= sort_buff[2]) ? Vmin : sort_buff[2];
		
		if((Vmin < AC3PPDU_Lack_Voltage) && (Vmax != 0) && (Vmax / AC3PPDU_Lack_Voltage > 3))
		{
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VAP_Addr] < AC3PPDU_Lack_Voltage)
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_LackA_Addr] = 1;
			}
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VBP_Addr] < AC3PPDU_Lack_Voltage)
			{
					AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_LackB_Addr] = 1;
			}
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VBP_Addr] < AC3PPDU_Lack_Voltage)
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_LackC_Addr] =1;
			}
		}else 
		{
			AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_LackA_Addr] = 0;
			AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_LackB_Addr] = 0;
			AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_LackC_Addr] = 0;
		}
		return;
	}
	////电压最大、最小、缺相阈值使能，进行判断
	if(AC3PPDU_Vmax_LTen_flag[ch_x] > 0)
	{
		if(ch_x > CH_in)//输出通道
		{
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_Out1Para_Addr + i] > AC3PPDU_Modbus_Reg[Mb_Dbuff_VLit1_max_Addr + ch_x-1])//大于最大
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] |= AC3PPDU_Vmax_Fault;
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] &= AC3PPDU_Vmin_NFault;
				if(AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_Over_Ch1_Func+ch_x-1] & (AC3PPDU_Over_V_Max_Func_enable))   //is or not open func
				{
					RL_Func_statu[ch_x] = 1;
				}
			}
			else if(AC3PPDU_Modbus_Reg[Mb_Dbuff_Out1Para_Addr + i] > AC3PPDU_Modbus_Reg[Mb_Dbuff_VLit1_min_Addr + ch_x-1])//大于最小，小于最大，正常
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] &= AC3PPDU_Vmax_NFault;
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] &= AC3PPDU_Vmin_NFault;
			}
			else//小于最小
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] &= AC3PPDU_Vmax_NFault;
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] |= AC3PPDU_Vmin_Fault;
			}
		}
		else//输入通道
		{
			//A相
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VAP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_ViLit_max_Addr])//超限
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_AVmax_Fault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_AVmax_NFault;
			}
			//B相
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VBP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_ViLit_max_Addr])//超限
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_BVmax_Fault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_BVmax_NFault;
			}
			//C相
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VCP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_ViLit_max_Addr])//超限
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_CVmax_Fault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_CVmax_NFault;
			}
			
		}
	}
	else
	{
		if(ch_x > CH_in)
		{
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] &= AC3PPDU_Vmax_NFault;
		}
		else
		{
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_AVmax_NFault;
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_BVmax_NFault;
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_CVmax_NFault;
		}
	}
	//最小电压
	if(AC3PPDU_Vmin_LTen_flag[ch_x] > 0)
	{
		if(ch_x > CH_in)//输出通道
		{
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_Out1Para_Addr + i] < AC3PPDU_Modbus_Reg[Mb_Dbuff_VLit1_min_Addr + ch_x -1])//大于最大   revice by liyi max -> min 
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] |= AC3PPDU_Vmin_Fault;
				if(AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_Over_Ch1_Func + ch_x - 1] & (AC3PPDU_Over_V_Min_Func_enable))   //is or not open func add by liyi
				{
					RL_Func_statu[ch_x] = 1;
				}
			}
			else//小于最小
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] &= AC3PPDU_Vmin_NFault;
			}
		}
		else//输入通道
		{
			//A相
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VAP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_ViLit_min_Addr])//
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_AVmin_NFault;
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_APlack_NFault;
			}
			else if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VAP_Addr] > 1000)
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_AVmin_Fault;
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_APlack_NFault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_AVmin_NFault;
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_APlack_Fault;
			}
			//B相
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VBP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_ViLit_min_Addr])//
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_BVmin_NFault;
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_BPlack_NFault;
			}
			else if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VBP_Addr] > 1000)
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_BVmin_Fault;
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_BPlack_NFault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_BVmin_NFault;
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_BPlack_Fault;
			}
			//C相
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VCP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_ViLit_min_Addr])//超限
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_CVmin_NFault;
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_CPlack_NFault;
			}
			else if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VCP_Addr] > 1000)
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_CVmin_Fault;
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_CPlack_NFault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_CVmin_NFault;
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_CPlack_Fault;
			}
			
		}
	}
	else
	{
		if(ch_x > CH_in)
		{
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] &= AC3PPDU_Vmin_NFault;
		}
		else
		{
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_AVmin_NFault;
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_BVmin_NFault;
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_CVmin_NFault;
			
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VAP_Addr] > 1000)
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_APlack_NFault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_APlack_Fault;
			}
			
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VBP_Addr] > 1000)
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_BPlack_NFault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_BPlack_Fault;
			}
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_VCP_Addr] > 1000)
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_CPlack_NFault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_CPlack_Fault;
			}
		}
	}
	//电流最大
	if(AC3PPDU_Imax_LTen_flag[ch_x] > 0)
	{
		if(ch_x > CH_in)//输出通道
		{
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_Out1Para_Addr + 1 + i] > AC3PPDU_Modbus_Reg[Mb_Dbuff_ILit1_max_Addr + ch_x -1])
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] |= AC3PPDU_Imax_Fault;
				if(AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_Over_Ch1_Func + ch_x-1] & (AC3PPDU_Over_I_Max_Func_enable))   //is or not open func add by liyi
				{
					RL_Func_statu[ch_x] = 1;
				}
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] &= AC3PPDU_Imax_NFault;
			}
		}
		else//输入通道
		{
			if((AC3PPDU_Modbus_Reg[Mb_Dbuff_IAP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_IiLit_max_Addr]))//超限
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_AImax_Fault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_AImax_NFault;
			}
			
			if((AC3PPDU_Modbus_Reg[Mb_Dbuff_IBP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_IiLit_max_Addr]))//超限
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_BImax_Fault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_BImax_NFault;
			}
			
			if((AC3PPDU_Modbus_Reg[Mb_Dbuff_ICP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_IiLit_max_Addr]))//超限
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_CImax_Fault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_CImax_NFault;
			}
		}
	}
	else
	{
		if(ch_x > CH_in)
		{
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] &= AC3PPDU_Imax_NFault;
		}
		else
		{
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_AImax_NFault;
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_BImax_NFault;
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_CImax_NFault;
		}
	}
	//功率最大
	if(AC3PPDU_Wmax_LTen_flag[ch_x] > 0)
	{
		if(ch_x > CH_in)//输出通道
		{
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_Out1Para_Addr + 2 + i] > AC3PPDU_Modbus_Reg[Mb_Dbuff_WLit1_max_Addr + ch_x -1])
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] |= AC3PPDU_Wmax_Fault;
				if(AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_Over_Ch1_Func + ch_x-1] & (AC3PPDU_Over_P_Max_Func_enable))   //is or not open func add by liyi
				{
					RL_Func_statu[ch_x] = 1;
				}
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] &= AC3PPDU_Wmax_NFault;
			}
		}
		else//输入通道
		{
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_WAP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_WiLit_max_Addr])//超限
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_AWmax_Fault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_AWmax_NFault;
			}
			
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_WBP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_WiLit_max_Addr])//超限
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_BWmax_Fault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_BWmax_NFault;
			}
			
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_WCP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_WiLit_max_Addr])//超限
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_CWmax_Fault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_CWmax_NFault;
			}
		}
	}
	else
	{
		if(ch_x > CH_in)
		{
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] &= AC3PPDU_Wmax_NFault;
		}
		else
		{
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_AWmax_NFault;
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_BWmax_NFault;
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_CWmax_NFault;
		}
	}
	//电量最大
	if(AC3PPDU_kWhmax_LTen_flag[ch_x] > 0)
	{
		if(ch_x > CH_in)//输出通道
		{
			if((float)(AC3PPDU_Modbus_Reg[Mb_Dbuff_Out1Para_Addr + 6 + i]) > (float)(AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhLit1_max_Addr + ch_x-1]))
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] |= AC3PPDU_kWhmax_Fault;
				if(AC3PPDU_Modbus_Reg[Mb_Dbuff_RL_Over_Ch1_Func + ch_x-1] & (AC3PPDU_Over_C_Max_Func_enable))   //is or not open func add by liyi
				{
					RL_Func_statu[ch_x] = 1;
				}
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] &= AC3PPDU_kWhmax_NFault;
			}
		}
		else//输入通道
		{
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhAP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_WiLit_max_Addr])//超限
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_AkWhmax_Fault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_AkWhmax_NFault;
			}
			
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhBP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_WiLit_max_Addr])//超限
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_BkWhmax_Fault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_BkWhmax_NFault;
			}
			
			if(AC3PPDU_Modbus_Reg[Mb_Dbuff_kWhCP_Addr] > AC3PPDU_Modbus_Reg[Mb_Dbuff_WiLit_max_Addr])//超限
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] |= AC3PPDU_CkWhmax_Fault;
			}
			else
			{
				AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_CkWhmax_NFault;
			}
		}
	}
	else
	{
		if(ch_x > CH_in)
		{
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr + ch_x] &= AC3PPDU_kWhmax_NFault;
		}
		else
		{
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_AkWhmax_NFault;
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_BkWhmax_NFault;
			AC3PPDU_Modbus_Reg[Mb_Dbuff_FT_ST_Addr] &= AC3PPDU_CkWhmax_NFault;
		}
	}
}
#ifdef  USE_FULL_ASSERT
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