SmartPDCode/control/PDU-AC-COMBINE/App/ReadEeprom/ReadEeprom.c

/*********************************************************************************************************
* 模块名称：ReadEeprom.c
* 摘    要：ReadEeprom模块，进行独立按键初始化，以及按键扫描函数实现
* 当前版本：1.0.0
* 作    者：Leyutek(COPYRIGHT 2018 - 2021 Leyutek. All rights reserved.)
* 完成日期：2021年07月01日 
* 内    容：
* 注    意：                                                                  
**********************************************************************************************************
* 取代版本：
* 作    者：
* 完成日期：
* 修改内容：
* 修改文件：
*********************************************************************************************************/

/*********************************************************************************************************
*                                              包含头文件
*********************************************************************************************************/
#include "ReadEeprom.h"
#include "Main.h"
#include "gd32e230x_conf.h"
#include "At24cxx.h"
#include "string.h"
#include "Relay.h"
#include "Sn74lvc573.h"
#include "board_cfg.h"
/*********************************************************************************************************
*                                              宏定义
*********************************************************************************************************/

/*********************************************************************************************************
*                                              枚举结构体
*********************************************************************************************************/

/*********************************************************************************************************
*                                              内部变量定义
*********************************************************************************************************/
unsigned char Eeprom_Rbuf[200]={0};
unsigned char Chal_Num;

extern EE_ACDC_Total_Consumption  EE_ACDC_Total_Consum_Read_Reg[RelaySlaveChaNum];
extern uint32_t read_Total_Consumer[RelaySlaveChaNum];
extern uint8_t over_Func_flag[RelaySlaveChaNum];
extern EE_ACDC_ThresVal_struct_ReadReg EE_ACDC_All_ThrVal;
extern EE_ACDC_State_All_Reg_En_t EE_ACDC_State_All_en;
extern ACDC_Over_Func_WriteReg 	ACDC_Over_AllWriteReg;
extern AC_Ele_struct_ReadReg AC_Ele_ReadReg_All;
extern ACDC_Wann_Read_Reg_t ACDC_Wann_All ;
extern uint8_t over_func_all_flag;

/*********************************************************************************************************
*                                              内部函数声明
*********************************************************************************************************/

/*********************************************************************************************************
*                                              内部函数实现
*********************************************************************************************************/
/*********************************************************************************************************
* 函数名称：ReadEeprom
* 函数功能：读出Eeprom的数据 
* 输入参数：void 
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void  ReadEeprom(void)
{
	AT24CxxRead(Eepr_AC_Sing_Dela_OnSmaAddr, Eeprom_Rbuf, Eepr_AC_Sing_Dela_OnSmaQua);			//从eeprom中读出通道开启延时数据
	memcpy(&EE_ACDC_Delay_ReadReg_On,&Eeprom_Rbuf,Eepr_AC_Sing_Dela_OnSmaQua);							//将数据拷贝到指定的结构体，可能需要注意大小端问题
	memcpy(&Sort_Onbuf,&EE_ACDC_Delay_ReadReg_On,Eepr_AC_Sing_Dela_OnSmaQua);								//将数据进行排序，然后存入数组中
	Bubble_Sort(Sort_Onbuf,RelaySlaveChaNum);
	
	AT24CxxRead(Eepr_AC_Sing_Dela_OffSmaAddr, Eeprom_Rbuf, Eepr_AC_Sing_Dela_OffSmaQua);			//从eeprom中读出通道关闭延时数据
	memcpy(&EE_ACDC_Delay_ReadReg_Off,&Eeprom_Rbuf,Eepr_AC_Sing_Dela_OffSmaQua);							//将数据拷贝到指定的结构体，可能需要注意大小端问题
	memcpy(&Sort_Offbuf,&EE_ACDC_Delay_ReadReg_Off,Eepr_AC_Sing_Dela_OffSmaQua);							//将数据进行排序，然后存入数组中
	Bubble_Sort(Sort_Offbuf,RelaySlaveChaNum);
	
	AT24CxxRead(Eepr_AC_Sing_State_SmaWAddr, Eeprom_Rbuf, Eepr_AC_Sing_State_SmaWQua);//从eeprom中读出通道状态数据
	memcpy(&EE_ACDC_State_ReadReg,&Eeprom_Rbuf,Eepr_AC_Sing_State_SmaWQua);						//将数据拷贝到指定的结构体，可能需要注意大小端问题
	
	AT24CxxRead(Eepr_AC_Sing_Thr_SmaAddr, Eeprom_Rbuf, Eepr_AC_Sing_Thr_SmaQua);			//从eeprom中读出通道阈值数据
	memcpy(&EE_ACDC_ThresVal_ReadReg,&Eeprom_Rbuf,Eepr_AC_Sing_Thr_SmaQua);						//将数据拷贝到指定的结构体，可能需要注意大小端问题
	
	AT24CxxRead(Eepr_AC_Sing_All_Thr_SmaAddr, Eeprom_Rbuf, Eepr_AC_Sing_All_Thr_SmaQua);				//read thr of all 
	memcpy(&EE_ACDC_All_ThrVal,&Eeprom_Rbuf,Eepr_AC_Sing_All_Thr_SmaQua);
	
	// add by liyi
		if(EE_ACDC_All_ThrVal.ACDC_V_TopThres > Default_Voltage_Max)
		{
			EE_ACDC_All_ThrVal.ACDC_V_TopThres = 0;
		}
		if(EE_ACDC_All_ThrVal.ACDC_V_DownThres > Default_Voltage_Max)
		{
			EE_ACDC_All_ThrVal.ACDC_V_DownThres = 0;
		}
		if(EE_ACDC_All_ThrVal.ACDC_P_TopThres > Default_Power_Max)
		{
			EE_ACDC_All_ThrVal.ACDC_P_TopThres = 0;
		}	
		if(EE_ACDC_All_ThrVal.ACDC_I_TopThres > Default_Current_Max)
		{
			EE_ACDC_All_ThrVal.ACDC_I_TopThres = 0;
		}		
	
	
	
	//check is 
	for(Chal_Num=0;Chal_Num<RelaySlaveChaNum;Chal_Num++) 
	{
		if(EE_ACDC_ThresVal_ReadReg[Chal_Num].ACDC_V_TopThres > Default_Voltage_Max)
		{
			EE_ACDC_ThresVal_ReadReg[Chal_Num].ACDC_V_TopThres = 0;
		}
		if(EE_ACDC_ThresVal_ReadReg[Chal_Num].ACDC_V_DownThres > Default_Voltage_Max)
		{
			EE_ACDC_ThresVal_ReadReg[Chal_Num].ACDC_V_DownThres = 0;
		}
		if(EE_ACDC_ThresVal_ReadReg[Chal_Num].ACDC_P_TopThres > Default_Power_Max)
		{
			EE_ACDC_ThresVal_ReadReg[Chal_Num].ACDC_P_TopThres = 0;
		}	
		if(EE_ACDC_ThresVal_ReadReg[Chal_Num].ACDC_I_TopThres > Default_Current_Max)
		{
			EE_ACDC_ThresVal_ReadReg[Chal_Num].ACDC_I_TopThres = 0;
		}		
	}
	

		if(EE_ACDC_All_ThrVal.ACDC_V_TopThres <= THRESHOULD_JUDGMENT)
		{
			EE_ACDC_State_All_en.ACDC_Vol_Upper_En = false;
		}else
		{
			EE_ACDC_State_All_en.ACDC_Vol_Upper_En = true;
		}
		if(EE_ACDC_All_ThrVal.ACDC_V_DownThres <= THRESHOULD_JUDGMENT)
		{
			EE_ACDC_State_All_en.ACDC_Vol_Lower_En= false;
		}else
		{
			EE_ACDC_State_All_en.ACDC_Vol_Lower_En= true;
		}
		if(EE_ACDC_All_ThrVal.ACDC_I_TopThres <= THRESHOULD_JUDGMENT)
		{
			EE_ACDC_State_All_en.ACDC_Current_Upper_En = false;
		}else
		{
			EE_ACDC_State_All_en.ACDC_Current_Upper_En= true;
		}
		if(EE_ACDC_All_ThrVal.ACDC_P_TopThres <= THRESHOULD_JUDGMENT)
		{
			EE_ACDC_State_All_en.ACDC_Power_Upper_En = false;
		}else
		{
			EE_ACDC_State_All_en.ACDC_Power_Upper_En = true;
		}
		if(EE_ACDC_All_ThrVal.ACDC_E_TopThres <= THRESHOULD_JUDGMENT)
		{
			EE_ACDC_State_All_en.ACDC_Consumer_Upper_En = false;
		}else
		{
			EE_ACDC_State_All_en.ACDC_Consumer_Upper_En= true;
		}
	
	
	
	for(Chal_Num=0;Chal_Num<RelaySlaveChaNum;Chal_Num++) 
	{
		if(EE_ACDC_ThresVal_ReadReg[Chal_Num].ACDC_V_TopThres <= THRESHOULD_JUDGMENT)
		{
			EE_ACDC_State_ReadReg[Chal_Num].ACDC_Vol_Upthr_En = false;
		}else
		{
			EE_ACDC_State_ReadReg[Chal_Num].ACDC_Vol_Upthr_En = true;
		}
		if(EE_ACDC_ThresVal_ReadReg[Chal_Num].ACDC_V_DownThres <= THRESHOULD_JUDGMENT)
		{
			EE_ACDC_State_ReadReg[Chal_Num].ACDC_Vol_Downthr_En = false;
		}else
		{
			EE_ACDC_State_ReadReg[Chal_Num].ACDC_Vol_Downthr_En = true;
		}
		if(EE_ACDC_ThresVal_ReadReg[Chal_Num].ACDC_I_TopThres <= THRESHOULD_JUDGMENT)
		{
			EE_ACDC_State_ReadReg[Chal_Num].ACDC_Cur_Upthr_En = false;
		}else
		{
			EE_ACDC_State_ReadReg[Chal_Num].ACDC_Cur_Upthr_En = true;
		}
		if(EE_ACDC_ThresVal_ReadReg[Chal_Num].ACDC_P_TopThres <= THRESHOULD_JUDGMENT)
		{
			EE_ACDC_State_ReadReg[Chal_Num].ACDC_Pow_Upthr_En = false;
		}else
		{
			EE_ACDC_State_ReadReg[Chal_Num].ACDC_Pow_Upthr_En = true;
		}
		if(EE_ACDC_ThresVal_ReadReg[Chal_Num].ACDC_E_TopThres <= THRESHOULD_JUDGMENT)
		{
			EE_ACDC_State_ReadReg[Chal_Num].ACDC_Ele_Upthr_En = false;
		}else
		{
			EE_ACDC_State_ReadReg[Chal_Num].ACDC_Ele_Upthr_En = true;
		}
	}
	
	AT24CxxRead(Eepr_AC_Sing_Coef_SmaAddr, Eeprom_Rbuf, Eepr_AC_Sing_Coef_SmaQua);		//从eeprom中读出通道的系数
	memcpy(&EE_ACDC_Coef_ReadReg,&Eeprom_Rbuf,Eepr_AC_Sing_Coef_SmaQua);							//将数据拷贝到指定的结构体，可能需要注意大小端问题
	for(Chal_Num=0;Chal_Num<RelaySlaveChaNum;Chal_Num++)                              //如果eeprom中没有存入数据设置默认值
	{
		if((EE_ACDC_Coef_ReadReg[Chal_Num].ACDC_V_k)==0xffffffff)												//没有写入电压系数则默认K为1000，B为0;放大1000倍存入的
		{
			EE_ACDC_Coef_ReadReg[Chal_Num].ACDC_V_k = 1000;
		}
		if((EE_ACDC_Coef_ReadReg[Chal_Num].ACDC_V_b)==0xffffffff)
		{
			(EE_ACDC_Coef_ReadReg[Chal_Num].ACDC_V_b) = 0;
		}
		if((EE_ACDC_Coef_ReadReg[Chal_Num].ACDC_I_k)==0xffffffff)												 //没有写入电流系数则默认K为1000，B为0;放大1000倍存入的
		{
			EE_ACDC_Coef_ReadReg[Chal_Num].ACDC_I_k = 1000;
		}
		if((EE_ACDC_Coef_ReadReg[Chal_Num].ACDC_I_b)==0xffffffff)
		{
			EE_ACDC_Coef_ReadReg[Chal_Num].ACDC_I_b = 0;
		}
	}
	//read total consumer
  AT24CxxRead(Eepr_AC_Sing_Total_Consumer_addr, Eeprom_Rbuf, Eepr_AC_Sing_Total_Consumer_SmaQua);	
	for(int i = 0; i < RelaySlaveChaNum;i++){
		int temp = i << 2;
		read_Total_Consumer[i] += Eeprom_Rbuf[temp + 0] << 24;
		read_Total_Consumer[i] += Eeprom_Rbuf[temp + 1] << 16;
		read_Total_Consumer[i] += Eeprom_Rbuf[temp + 2] << 8;
		read_Total_Consumer[i] += Eeprom_Rbuf[temp + 3] << 0;
		
		if(read_Total_Consumer[i] > Default_Consum_Max)
		{
			read_Total_Consumer[i] = 0;
		}
	}
	
	//read wanning func 
	AT24CxxRead(Eepr_AC_Sing_Channel_Func_SmaAddr, Eeprom_Rbuf, Eepr_AC_Sing_Channel_Func_SmaQua);	
	memcpy(ACDC_Over_WriteReg,Eeprom_Rbuf,Eepr_AC_Sing_Channel_Func_SmaQua);
	for(int i=0; i < RelaySlaveChaNum;i++)
	{
		if(ACDC_Over_WriteReg[i].openration > 0x003f)
		{
			ACDC_Over_WriteReg[i].openration = 0;
		}
	}
	AT24CxxRead(Eepr_AC_Sing_All_Over_SmaAddr, Eeprom_Rbuf, Eepr_AC_Sing_All_Over_SmaQua);	
	memcpy(&ACDC_Over_AllWriteReg,Eeprom_Rbuf,Eepr_AC_Sing_All_Over_SmaQua);
	if(ACDC_Over_AllWriteReg.openration > 0x003f)
	{
		ACDC_Over_AllWriteReg.openration = 0;
	}
}




#if (RelaySlaveChaNum >= 1)
void Relay1State(void)
{
  	if(EE_ACDC_State_ReadReg[0].ACDC_Cha_On_Off_State==true)
		{
				RELAY_1_ON; 			//开继电器1 
#if SUPPORT_TWIN_FIRE
				RELAY_5_ON;
#endif	
				EE_ACDC_State_ReadRegTrue[0].ACDC_Cha_On_Off_State = true;
		}		
		else 
		{
				RELAY_1_OFF;				//关继电器1 
#if SUPPORT_TWIN_FIRE
				RELAY_5_OFF;
#endif		
				EE_ACDC_State_ReadRegTrue[0].ACDC_Cha_On_Off_State = false;			
		}                                                 
}
#endif

#if (RelaySlaveChaNum >= 2)

void Relay2State(void)
{
  	if(EE_ACDC_State_ReadReg[1].ACDC_Cha_On_Off_State==true)
		{
				RELAY_2_ON;                              																											//开继电器2    
#if SUPPORT_TWIN_FIRE
			RELAY_6_ON;
#endif		
				EE_ACDC_State_ReadRegTrue[1].ACDC_Cha_On_Off_State = true;
		}                           
		else 
		{
				RELAY_2_OFF;																																									//关继电器2  
#if SUPPORT_TWIN_FIRE
			RELAY_6_OFF;
#endif		
				EE_ACDC_State_ReadRegTrue[1].ACDC_Cha_On_Off_State = false;
		}                                                 
}

#endif


#if (RelaySlaveChaNum >= 3)
void Relay3State(void)
{
  	if(EE_ACDC_State_ReadReg[2].ACDC_Cha_On_Off_State==true)
		{
				RELAY_3_ON;                              																											//开继电器3     
#if SUPPORT_TWIN_FIRE
			RELAY_7_ON;
#endif			
				EE_ACDC_State_ReadRegTrue[2].ACDC_Cha_On_Off_State = true;
		}                         
		else 
		{
				RELAY_3_OFF;																																									//关继电器3  
#if SUPPORT_TWIN_FIRE
			RELAY_7_OFF;
#endif	
				EE_ACDC_State_ReadRegTrue[2].ACDC_Cha_On_Off_State = false;
		}	
}

#endif



#if (RelaySlaveChaNum >= 4)

void Relay4State(void)
{
  	if(EE_ACDC_State_ReadReg[3].ACDC_Cha_On_Off_State==true)
		{
				RELAY_4_ON;                              																											//开继电器4 
#if SUPPORT_TWIN_FIRE
				RELAY_8_ON;
#endif		
				EE_ACDC_State_ReadRegTrue[3].ACDC_Cha_On_Off_State = true;
		}                              
		else 
		{
				RELAY_4_OFF;																																									//关继电器4
#if SUPPORT_TWIN_FIRE
				RELAY_8_OFF;
#endif		
				EE_ACDC_State_ReadRegTrue[3].ACDC_Cha_On_Off_State = false;
		} 	
}

#endif
#if (RelaySlaveChaNum >= 5)
void Relay5State(void)
{
  	if(EE_ACDC_State_ReadReg[4].ACDC_Cha_On_Off_State==true)
		{
				RELAY_5_ON;                              																											//开继电器5  
				EE_ACDC_State_ReadRegTrue[4].ACDC_Cha_On_Off_State = true;
		}                             
		else 
		{
				RELAY_5_OFF;																																									//关继电器5  
				EE_ACDC_State_ReadRegTrue[4].ACDC_Cha_On_Off_State = false;
		}    
}
#endif

#if (RelaySlaveChaNum >= 6)
void Relay6State(void)
{
  	if(EE_ACDC_State_ReadReg[5].ACDC_Cha_On_Off_State==true)
		{
				RELAY_6_ON;                              																											//开继电器6  
				EE_ACDC_State_ReadRegTrue[5].ACDC_Cha_On_Off_State = true;
		}                             
		else 
		{
				RELAY_6_OFF;																																									//关继电器6 
				EE_ACDC_State_ReadRegTrue[5].ACDC_Cha_On_Off_State = false;
		}
}

#endif


#if (RelaySlaveChaNum >= 7)
void Relay7State(void)
{
	if(RelaySlaveChaNum>=7)
	{
  	if(EE_ACDC_State_ReadReg[6].ACDC_Cha_On_Off_State==true)
		{
				RELAY_7_ON;                              																											//开继电器7   
				EE_ACDC_State_ReadRegTrue[6].ACDC_Cha_On_Off_State = true;
		}                            
		else 
		{
				RELAY_7_OFF;																																									//关继电器7 
				EE_ACDC_State_ReadRegTrue[6].ACDC_Cha_On_Off_State = false;
		}    
	}		
}
#endif


#if (RelaySlaveChaNum >= 8)
void Relay8State(void)
{
	if(RelaySlaveChaNum>=8)
	{
  	if(EE_ACDC_State_ReadReg[7].ACDC_Cha_On_Off_State==true)
		{
				RELAY_8_ON;                              																											//开继电器8        
				EE_ACDC_State_ReadRegTrue[7].ACDC_Cha_On_Off_State = true;			
		}                   
		else 
		{
				RELAY_8_OFF;																																									//关继电器8  
				EE_ACDC_State_ReadRegTrue[7].ACDC_Cha_On_Off_State = false;
		}
	}
}
#endif




void RelayState(void)
{
	BUFF;
#if (RelaySlaveChaNum >= 1)
	Relay1State(); 
#endif
#if (RelaySlaveChaNum >= 2)
	Relay2State();
#endif
#if (RelaySlaveChaNum >= 3)
	Relay3State();
#endif
#if (RelaySlaveChaNum >= 4)
	Relay4State();
#endif
#if (RelaySlaveChaNum >= 5)
	Relay5State();
#endif
#if (RelaySlaveChaNum >= 6)
	Relay6State();
#endif
#if (RelaySlaveChaNum >= 7)
	Relay7State();
#endif
#if (RelaySlaveChaNum >= 8)
	Relay8State(); 
#endif 	
  LOCK;
}

void RelayState_ch(uint8_t chx)
{
	switch(chx)
	{
#if (RelaySlaveChaNum >= 1)
		case 0:
		Relay1State();
		break;
#endif
#if (RelaySlaveChaNum >= 2)
		case 1:
		Relay2State();
		break;
#endif	
#if (RelaySlaveChaNum >= 3)
		case 2:
		Relay3State();
		break;
#endif	
#if (RelaySlaveChaNum >= 4)
		case 3:
		Relay4State();
		break;
#endif	
#if (RelaySlaveChaNum >= 5)
		case 4:
		Relay5State();
		break;
#endif	
#if (RelaySlaveChaNum >= 6)
		case 5:
		Relay6State();
		break;
#endif	
#if (RelaySlaveChaNum >= 7)
		case 6:
		Relay7State();
		break;
#endif	
#if (RelaySlaveChaNum >= 8)
		case 7:
		Relay8State();
		break;
#endif			
		default:
			return;
	}
	BUFF;
	LOCK;
}

/*********************************************************************************************************
* 函数名称：WarnVolUpthrState
* 函数功能：根据读取的数据判断是否触发阈值
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*           
*********************************************************************************************************/
void WarnVolUpthrState(void)
{
	uint32_t  chn_num = 0;
	for(chn_num=0;chn_num<RelaySlaveChaNum;chn_num++)
	{
		if(EE_ACDC_State_ReadReg[chn_num].ACDC_Vol_Upthr_En)
		{
			if(AC_Ele_ReadReg[chn_num].AC_V>EE_ACDC_ThresVal_ReadReg[chn_num].ACDC_V_TopThres)
			{
 				EE_ACDC_State_ReadReg[chn_num].ACDC_Vol_Upthr_Warn = true;
				if(ACDC_Over_WriteReg[chn_num].openration & Voltage_Max_Func)
				{
					over_Func_flag[chn_num] = 1;
				}
			}
			else 
				EE_ACDC_State_ReadReg[chn_num].ACDC_Vol_Upthr_Warn = false;
		}
		else 
			EE_ACDC_State_ReadReg[chn_num].ACDC_Vol_Upthr_Warn = false;
	}
}

void WarnVolUpthrState_ch(uint8_t channel)
{
	if(EE_ACDC_State_ReadReg[channel].ACDC_Vol_Upthr_En)
	{
		if(AC_Ele_ReadReg[channel].AC_V>EE_ACDC_ThresVal_ReadReg[channel].ACDC_V_TopThres)
		{
 			EE_ACDC_State_ReadReg[channel].ACDC_Vol_Upthr_Warn = true;
			if(ACDC_Over_WriteReg[channel].openration & Voltage_Max_Func)
			{
				over_Func_flag[channel] = 1;
			}
		}
		else 
			EE_ACDC_State_ReadReg[channel].ACDC_Vol_Upthr_Warn = false;
	}
	else 
		EE_ACDC_State_ReadReg[channel].ACDC_Vol_Upthr_Warn = false;
}
/*********************************************************************************************************
* 函数名称：WarnVolDownthrState
* 函数功能：根据读取的数据判断是否触发阈值
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*           
*********************************************************************************************************/
void WarnVolDownthrState(void)
{
	uint32_t  chn_num = 0;
	for(chn_num=0;chn_num<RelaySlaveChaNum;chn_num++)
	{
		if(EE_ACDC_State_ReadReg[chn_num].ACDC_Vol_Downthr_En)
		{
			if(AC_Ele_ReadReg[chn_num].AC_V < EE_ACDC_ThresVal_ReadReg[chn_num].ACDC_V_DownThres)
			{
				EE_ACDC_State_ReadReg[chn_num].ACDC_Vol_Downthr_Warn = true;
				if(ACDC_Over_WriteReg[chn_num].openration & Voltage_Min_Func)
				{
					over_Func_flag[chn_num] = 1;
				}
			}
			else 
				EE_ACDC_State_ReadReg[chn_num].ACDC_Vol_Downthr_Warn = false;
		}
		else 
			EE_ACDC_State_ReadReg[chn_num].ACDC_Vol_Downthr_Warn = false;
	}
}

void WarnVolDownthrState_ch(uint8_t channel)
{
	if(EE_ACDC_State_ReadReg[channel].ACDC_Vol_Downthr_En)
	{
		if(AC_Ele_ReadReg[channel].AC_V < EE_ACDC_ThresVal_ReadReg[channel].ACDC_V_DownThres)
		{
			EE_ACDC_State_ReadReg[channel].ACDC_Vol_Downthr_Warn = true;
			if(ACDC_Over_WriteReg[channel].openration & Voltage_Min_Func)
			{
				over_Func_flag[channel] = 1;
			}
		}
		else 
			EE_ACDC_State_ReadReg[channel].ACDC_Vol_Downthr_Warn = false;
	}
	else 
		EE_ACDC_State_ReadReg[channel].ACDC_Vol_Downthr_Warn = false;	
}
/*********************************************************************************************************
* 函数名称：WarnCurUpthrState
* 函数功能：根据读取的数据判断是否触发阈值
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*           
*********************************************************************************************************/
void WarnCurUpthrState(void)
{
	uint32_t  chn_num = 0;
	for(chn_num=0;chn_num<RelaySlaveChaNum;chn_num++)
	{
		if(EE_ACDC_State_ReadReg[chn_num].ACDC_Cur_Upthr_En)
		{
			if(AC_Ele_ReadReg[chn_num].AC_I>EE_ACDC_ThresVal_ReadReg[chn_num].ACDC_I_TopThres)
			{
				EE_ACDC_State_ReadReg[chn_num].ACDC_Cur_Upthr_Warn = true;
				if(ACDC_Over_WriteReg[chn_num].openration & Current_Max_Func)
				{
					over_Func_flag[chn_num] = 1;
				}
			}
			else 
				EE_ACDC_State_ReadReg[chn_num].ACDC_Cur_Upthr_Warn = false;
		}
		else 
			EE_ACDC_State_ReadReg[chn_num].ACDC_Cur_Upthr_Warn = false;
	}
}

void WarnCurUpthrState_ch(uint8_t channel)
{
	if(EE_ACDC_State_ReadReg[channel].ACDC_Cur_Upthr_En)
	{
		if(AC_Ele_ReadReg[channel].AC_I>EE_ACDC_ThresVal_ReadReg[channel].ACDC_I_TopThres)
		{
			EE_ACDC_State_ReadReg[channel].ACDC_Cur_Upthr_Warn = true;
			if(ACDC_Over_WriteReg[channel].openration & Current_Max_Func)
			{
				over_Func_flag[channel] = 1;
			}
		}
		else 
			EE_ACDC_State_ReadReg[channel].ACDC_Cur_Upthr_Warn = false;
	}
	else 
		EE_ACDC_State_ReadReg[channel].ACDC_Cur_Upthr_Warn = false;
	
}
/*********************************************************************************************************
* 函数名称：WarnPowUpthrState
* 函数功能：根据读取的数据判断是否触发阈值
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*           
*********************************************************************************************************/
void WarnPowUpthrState(void)
{
	uint32_t  chn_num = 0;
	for(chn_num=0;chn_num<RelaySlaveChaNum;chn_num++)
	{
		if(EE_ACDC_State_ReadReg[chn_num].ACDC_Pow_Upthr_En)
		{
			if(AC_Ele_ReadReg[chn_num].AC_P>EE_ACDC_ThresVal_ReadReg[chn_num].ACDC_P_TopThres){
				EE_ACDC_State_ReadReg[chn_num].ACDC_Pow_Upthr_Warn = true;
				if(ACDC_Over_WriteReg[chn_num].openration & Power_Max_Func)
				{
					over_Func_flag[chn_num] = 1;
				}
			}
			else 
				EE_ACDC_State_ReadReg[chn_num].ACDC_Pow_Upthr_Warn = false;
		}
		else 
			EE_ACDC_State_ReadReg[chn_num].ACDC_Pow_Upthr_Warn = false;
	}
}
void WarnPowUpthrState_ch(uint8_t channel)
{

	if(EE_ACDC_State_ReadReg[channel].ACDC_Pow_Upthr_En)
	{
		if(AC_Ele_ReadReg[channel].AC_P>EE_ACDC_ThresVal_ReadReg[channel].ACDC_P_TopThres){
			EE_ACDC_State_ReadReg[channel].ACDC_Pow_Upthr_Warn = true;
			if(ACDC_Over_WriteReg[channel].openration & Power_Max_Func)
			{
				over_Func_flag[channel] = 1;
			}
		}
		else 
			EE_ACDC_State_ReadReg[channel].ACDC_Pow_Upthr_Warn = false;
	}
	else 
		EE_ACDC_State_ReadReg[channel].ACDC_Pow_Upthr_Warn = false;
	
}
/*********************************************************************************************************
* 函数名称：WarnEleUpthrState
* 函数功能：根据读取的数据判断是否触发阈值
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*           
*********************************************************************************************************/
void WarnEleUpthrState(void)
{
	uint32_t chn_num = 0;
	for(chn_num=0;chn_num<RelaySlaveChaNum;chn_num++)
	{
		if(EE_ACDC_State_ReadReg[chn_num].ACDC_Ele_Upthr_En)
		{
			if(AC_Ele_ReadReg[chn_num].AC_E>EE_ACDC_ThresVal_ReadReg[chn_num].ACDC_E_TopThres)
			{
				EE_ACDC_State_ReadReg[chn_num].ACDC_Ele_Upthr_Warn = true;
				if(ACDC_Over_WriteReg[chn_num].openration & Consumer_Max_Func)
				{
					over_Func_flag[chn_num] = 1;
				}
			}
			else 
				EE_ACDC_State_ReadReg[chn_num].ACDC_Ele_Upthr_Warn = false;
		}
		else 
			EE_ACDC_State_ReadReg[chn_num].ACDC_Ele_Upthr_Warn = false;
	}
}

void WarnEleUpthrState_ch(uint8_t channel)
{
	if(EE_ACDC_State_ReadReg[channel].ACDC_Ele_Upthr_En)
	{
		if(AC_Ele_ReadReg[channel].AC_E>EE_ACDC_ThresVal_ReadReg[channel].ACDC_E_TopThres)
		{
			EE_ACDC_State_ReadReg[channel].ACDC_Ele_Upthr_Warn = true;
			if(ACDC_Over_WriteReg[channel].openration & Consumer_Max_Func)
			{
				over_Func_flag[channel] = 1;
			}
		}
		else 
			EE_ACDC_State_ReadReg[channel].ACDC_Ele_Upthr_Warn = false;
	}
	else 
		EE_ACDC_State_ReadReg[channel].ACDC_Ele_Upthr_Warn = false;
}

/*********************************************************************************************************
* 函数名称：WarnState
* 函数功能：根据读取的数据判断是否触发阈值
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*           
*********************************************************************************************************/
void WarnState(void)
{
	WarnVolUpthrState();
	WarnVolDownthrState();
	WarnCurUpthrState();
	WarnPowUpthrState();
	WarnEleUpthrState();
}

void WarnState_ch(uint8_t channel)
{
	WarnVolUpthrState_ch(channel);
	WarnVolDownthrState_ch(channel);
	WarnCurUpthrState_ch(channel);
	WarnPowUpthrState_ch(channel);
	WarnEleUpthrState_ch(channel);
}

void All_Warn_State(void)
{
	
	//voltage max
	if(EE_ACDC_State_All_en.ACDC_Vol_Upper_En)
	{
		if(AC_Ele_ReadReg_All.AC_V > EE_ACDC_All_ThrVal.ACDC_V_TopThres)
		{
			ACDC_Wann_All.wan.ACDC_V_Max = true;
			if(ACDC_Over_AllWriteReg.openration & Voltage_Max_Func)
			{
				over_func_all_flag = 1;
				//ACDC_Wann_All.over.ACDC_V_Max_O_Func = true;
			}
		}else
		{
			ACDC_Wann_All.wan.ACDC_V_Max = false;
			//ACDC_Wann_All.over.ACDC_V_Max_O_Func = false;
		}
	}else
	{
		ACDC_Wann_All.wan.ACDC_V_Max = false;
	}
	//voltage min
	if(EE_ACDC_State_All_en.ACDC_Vol_Lower_En)
	{
		if(AC_Ele_ReadReg_All.AC_V < EE_ACDC_All_ThrVal.ACDC_V_DownThres)
		{
			ACDC_Wann_All.wan.ACDC_V_Min = true;
			if(ACDC_Over_AllWriteReg.openration & Voltage_Min_Func)
			{
				over_func_all_flag = 1;
			}
			
		}else
		{
			ACDC_Wann_All.wan.ACDC_V_Min = false;
		}
	}else
	{
		ACDC_Wann_All.wan.ACDC_V_Min = false;
	}
	//power max
		if(EE_ACDC_State_All_en.ACDC_Power_Upper_En)
		{
			if(AC_Ele_ReadReg_All.AC_P > EE_ACDC_All_ThrVal.ACDC_P_TopThres)
			{
				ACDC_Wann_All.wan.ACDC_P_Max = true;
				if(ACDC_Over_AllWriteReg.openration & Power_Max_Func)
				{
					over_func_all_flag = 1;
				}
				
			}else
			{
				ACDC_Wann_All.wan.ACDC_P_Max = false;
			}
		}else
		{
			ACDC_Wann_All.wan.ACDC_P_Max = false;
		}
	//current max
		if(EE_ACDC_State_All_en.ACDC_Current_Upper_En)
		{
			if(AC_Ele_ReadReg_All.AC_I > EE_ACDC_All_ThrVal.ACDC_I_TopThres)
			{
				ACDC_Wann_All.wan.ACDC_I_Max = true;
				if(ACDC_Over_AllWriteReg.openration & Current_Max_Func)
				{
					over_func_all_flag = 1;
				}
				
			}else
			{
				ACDC_Wann_All.wan.ACDC_I_Max = false;
			}
		}else
		{
			ACDC_Wann_All.wan.ACDC_I_Max = false;
		}
		//consumer max
		if(EE_ACDC_State_All_en.ACDC_Consumer_Upper_En)
		{
			if(AC_Ele_ReadReg_All.AC_E > EE_ACDC_All_ThrVal.ACDC_E_TopThres)
			{
				ACDC_Wann_All.wan.ACDC_C_Max = true;
				if(ACDC_Over_AllWriteReg.openration & Consumer_Max_Func)
				{
					over_func_all_flag = 1;
				}
				
			}else
			{
				ACDC_Wann_All.wan.ACDC_C_Max = false;
			}
		}else
		{
			ACDC_Wann_All.wan.ACDC_C_Max = false;
		}
	
}



/*********************************************************************************************************
* 函数名称：Bubble_Sort
* 函数功能：根据读取的数据判断是否触发阈值
* 输入参数：排序数组
* 输出参数：排序数组的长度
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*           
*********************************************************************************************************/
void Bubble_Sort(unsigned short int arr[], unsigned short int len) 
{
	unsigned short int i, j, temp;
	for (i = 0; i < len - 1; i++)
			for (j = 0; j < len - 1 - i; j++)
					if (arr[j] > arr[j + 1]) 
					{
							temp = arr[j];
							arr[j] = arr[j + 1];
							arr[j + 1] = temp;
					}
}