SmartPDCode/control/PDU-V1.20_Double_line/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 "SysTick.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];
/*********************************************************************************************************
*                                              内部函数声明
*********************************************************************************************************/

/*********************************************************************************************************
*                                              内部函数实现
*********************************************************************************************************/
/*********************************************************************************************************
* 函数名称：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);								//将数据进行排序，然后存入数组中
#ifndef ACSingPhSmaDouble
	Bubble_Sort(Sort_Onbuf,RelaySlaveChaNum);
#else
		Bubble_Sort(Sort_Onbuf,Relay_4_CHANEL);
#endif
	
	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);							//将数据进行排序，然后存入数组中
#ifndef ACSingPhSmaDouble
	Bubble_Sort(Sort_Offbuf,RelaySlaveChaNum);
#else
		Bubble_Sort(Sort_Offbuf,Relay_4_CHANEL);
#endif
	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);						//将数据拷贝到指定的结构体，可能需要注意大小端问题
	
	//check is 
#ifndef ACSingPhSmaDouble
	for(Chal_Num=0;Chal_Num<RelaySlaveChaNum;Chal_Num++) 
#else
	for(Chal_Num=0;Chal_Num<Relay_4_CHANEL;Chal_Num++) 
#endif
	{
		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;
		}		
	}
#ifndef ACSingPhSmaDouble
	for(Chal_Num=0;Chal_Num<RelaySlaveChaNum;Chal_Num++) 
#else
	for(Chal_Num=0;Chal_Num<Relay_4_CHANEL;Chal_Num++) 
#endif
	{
		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);							//将数据拷贝到指定的结构体，可能需要注意大小端问题
#ifndef ACSingPhSmaDouble
	for(Chal_Num=0;Chal_Num<RelaySlaveChaNum;Chal_Num++)                              //如果eeprom中没有存入数据设置默认值
#else
	for(Chal_Num=0;Chal_Num<Relay_4_CHANEL;Chal_Num++)     
#endif
	
	
	{
		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);	
#ifndef ACSingPhSmaDouble
	for(int i = 0; i < RelaySlaveChaNum;i++){
#else
	for(int i = 0; i < Relay_4_CHANEL;i++){
#endif
		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);	
	memcmp(ACDC_Over_WriteReg,Eeprom_Rbuf,Eepr_AC_Sing_Channel_Func_SmaQua);
#ifndef ACSingPhSmaDouble
	for(int i=0; i < RelaySlaveChaNum;i++)
#else
	for(int i=0; i < Relay_4_CHANEL;i++)
#endif
	{
		if(ACDC_Over_WriteReg[i].openration > 0x003f)
		{
			ACDC_Over_WriteReg[i].openration = 0;
		}
	}
}

#if ACSingPhSmaCurr
/*********************************************************************************************************
*                                              API函数实现
*********************************************************************************************************/
/*********************************************************************************************************
* 函数名称：Relay1State
* 函数功能：Relay1State模块,控制继电器和更新通道状态
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void Relay1State(void)
{
	if(RelaySlaveChaNum>=1)
	{
  	if(EE_ACDC_State_ReadReg[0].ACDC_Cha_On_Off_State==true)
		{
			RELAY_1_ON;   			//开继电器1 
			#if ACSingPhSmaDouble
			RELAY_5_ON;
			#endif			
			EE_ACDC_State_ReadRegTrue[0].ACDC_Cha_On_Off_State = true;
		}		
		else 
		{
				RELAY_1_OFF;																																									//关继电器1 
		#if ACSingPhSmaDouble
			RELAY_5_OFF;
		#endif		
			EE_ACDC_State_ReadRegTrue[0].ACDC_Cha_On_Off_State = false;			
		}
	}                                                     
}
/*********************************************************************************************************
* 函数名称：Relay2State
* 函数功能：Relay2State模块,控制继电器和更新通道状态
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void Relay2State(void)
{
	if(RelaySlaveChaNum>=2)
	{
  	if(EE_ACDC_State_ReadReg[1].ACDC_Cha_On_Off_State==true)
		{
				RELAY_2_ON;                              																											//开继电器2    
			#if ACSingPhSmaDouble
			RELAY_6_ON;
			#endif				
			EE_ACDC_State_ReadRegTrue[1].ACDC_Cha_On_Off_State = true;
		}                           
		else 
		{
				RELAY_2_OFF;																																									//关继电器2  
		#if ACSingPhSmaDouble
			RELAY_6_OFF;
		#endif			
			EE_ACDC_State_ReadRegTrue[1].ACDC_Cha_On_Off_State = false;
		}
	}                                                 
}
/*********************************************************************************************************
* 函数名称：Relay3State
* 函数功能：Relay3State模块,控制继电器和更新通道状态
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void Relay3State(void)
{
	if(RelaySlaveChaNum>=3)
	{
  	if(EE_ACDC_State_ReadReg[2].ACDC_Cha_On_Off_State==true)
		{
				RELAY_3_ON;                              																											//开继电器3     	
			#if ACSingPhSmaDouble
			RELAY_7_ON;
			#endif				
			EE_ACDC_State_ReadRegTrue[2].ACDC_Cha_On_Off_State = true;
		}                         
		else 
		{
				RELAY_3_OFF;																																									//关继电器3  
		#if ACSingPhSmaDouble
			RELAY_7_OFF;
		#endif			
			EE_ACDC_State_ReadRegTrue[2].ACDC_Cha_On_Off_State = false;
		}
	}		
}
/*********************************************************************************************************
* 函数名称：Relay4State
* 函数功能：Relay4State模块,控制继电器和更新通道状态
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void Relay4State(void)
{
	if(RelaySlaveChaNum>=4)
	{
  	if(EE_ACDC_State_ReadReg[3].ACDC_Cha_On_Off_State==true)
		{
				RELAY_4_ON;                              																											//开继电器4 
			#if ACSingPhSmaDouble
			RELAY_8_ON;
			#endif			
			EE_ACDC_State_ReadRegTrue[3].ACDC_Cha_On_Off_State = true;
		}                              
		else 
		{
				RELAY_4_OFF;			//关继电器4
		#if ACSingPhSmaDouble
			RELAY_8_OFF;
		#endif		
			EE_ACDC_State_ReadRegTrue[3].ACDC_Cha_On_Off_State = false;
		} 
	}		
}
/*********************************************************************************************************
* 函数名称：Relay5State
* 函数功能：Relay5State模块,控制继电器和更新通道状态
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void Relay5State(void)
{
#ifndef ACSingPhSmaDouble
	if(RelaySlaveChaNum>=5)
	{
  	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
}
/*********************************************************************************************************
* 函数名称：Relay6State
* 函数功能：Relay6State模块,控制继电器和更新通道状态
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void Relay6State(void)
{
#ifndef ACSingPhSmaDouble
	if(RelaySlaveChaNum>=6)
	{
  	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	
}
/*********************************************************************************************************
* 函数名称：Relay7State
* 函数功能：Relay7State模块,控制继电器和更新通道状态
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void Relay7State(void)
{
#ifndef ACSingPhSmaDouble
	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
}
/*********************************************************************************************************
* 函数名称：Relay8State
* 函数功能：Relay8State模块,控制继电器和更新通道状态
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void Relay8State(void)
{
#ifndef ACSingPhSmaDouble
	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
}
/*********************************************************************************************************
* 函数名称：RelayState
* 函数功能：RelayState模块,控制继电器和更新通道状态
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void RelayState(void)
{
	BUFF;
	Relay1State(); 
	Relay2State();
	Relay3State();
	Relay4State();
	Relay5State();
	Relay6State();
	Relay7State();
	Relay8State();  	
  LOCK;
}
#endif
#if ACSingPhHigCurr
/*********************************************************************************************************
*                                              API函数实现
*********************************************************************************************************/
/*********************************************************************************************************
* 函数名称：Relay1State
* 函数功能：Relay1State模块,控制继电器和更新通道状态
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void Relay1State(void)
{
	if(RelaySlaveChaNum>=1)
	{
  	if(EE_ACDC_State_ReadReg[0].ACDC_Cha_On_Off_State==true)
		{
				RELAY_1_ON;                              																											//开继电器1  
				EE_ACDC_State_ReadRegTrue[0].ACDC_Cha_On_Off_State = true;			
		}                        
		else 
		{
				RELAY_1_OFF;																																									//关继电器1  
				EE_ACDC_State_ReadRegTrue[0].ACDC_Cha_On_Off_State = false;			
		}
	}                                                     
}
/*********************************************************************************************************
* 函数名称：Relay2State
* 函数功能：Relay2State模块,控制继电器和更新通道状态
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void Relay2State(void)
{
	if(RelaySlaveChaNum>=2)
	{
  	if(EE_ACDC_State_ReadReg[1].ACDC_Cha_On_Off_State==true)
		{
				RELAY_2_ON;                              																											//开继电器2    
				EE_ACDC_State_ReadRegTrue[1].ACDC_Cha_On_Off_State = true;			
		}			
		else 
		{
				RELAY_2_OFF;																																									//关继电器2 
				EE_ACDC_State_ReadRegTrue[1].ACDC_Cha_On_Off_State = false;	
		}			
	}                                                 
}
/*********************************************************************************************************
* 函数名称：Relay3State
* 函数功能：Relay3State模块,控制继电器和更新通道状态
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void Relay3State(void)
{
	if(RelaySlaveChaNum>=3)
	{
  	if(EE_ACDC_State_ReadReg[2].ACDC_Cha_On_Off_State==true)
		{
				RELAY_3_ON;                              																											//开继电器3  
				EE_ACDC_State_ReadRegTrue[2].ACDC_Cha_On_Off_State = true;
		}                            
		else 
		{
				RELAY_3_OFF;																																									//关继电器3 
				EE_ACDC_State_ReadRegTrue[2].ACDC_Cha_On_Off_State = false;				
		}
	}		
}
/*********************************************************************************************************
* 函数名称：Relay4State
* 函数功能：Relay4State模块,控制继电器和更新通道状态
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void Relay4State(void)
{
	if(RelaySlaveChaNum>=4)
	{
  	if(EE_ACDC_State_ReadReg[3].ACDC_Cha_On_Off_State==true)
		{
				RELAY_4_ON;                              																											//开继电器4 
				EE_ACDC_State_ReadRegTrue[3].ACDC_Cha_On_Off_State = true;
		}                              
		else 
		{
				RELAY_4_OFF;																																									//关继电器4 
				EE_ACDC_State_ReadRegTrue[3].ACDC_Cha_On_Off_State = false;
		}
	}		
}
/*********************************************************************************************************
* 函数名称：RelayState
* 函数功能：RelayState模块,控制继电器和更新通道状态
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*********************************************************************************************************/
void RelayState(void)
{
	BUFF;
	Relay1State(); 
	Relay2State();
	Relay3State();
	Relay4State(); 	
  LOCK;
}
#endif
/*********************************************************************************************************
* 函数名称：WarnVolUpthrState
* 函数功能：根据读取的数据判断是否触发阈值
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*           
*********************************************************************************************************/
void WarnVolUpthrState(uint8_t chn_num)
{

//	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;
			}

//}
}
/*********************************************************************************************************
* 函数名称：WarnVolDownthrState
* 函数功能：根据读取的数据判断是否触发阈值
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*           
*********************************************************************************************************/
void WarnVolDownthrState(uint8_t chn_num)
{
//	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;
		}

//	}
}
/*********************************************************************************************************
* 函数名称：WarnCurUpthrState
* 函数功能：根据读取的数据判断是否触发阈值
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*           
*********************************************************************************************************/
void WarnCurUpthrState(uint8_t chn_num)
{
//	uint32_t  chn_num = 0;
//	for(chn_num=0;chn_num<RelaySlaveChaNum;chn_num++)
//	{
		DelayNms(2);
		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;
		}
//	}
}
/*********************************************************************************************************
* 函数名称：WarnPowUpthrState
* 函数功能：根据读取的数据判断是否触发阈值
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*           
*********************************************************************************************************/
void WarnPowUpthrState(uint8_t chn_num)
{

//	uint32_t  chn_num = 0;
//	for(chn_num=0;chn_num<RelaySlaveChaNum;chn_num++)
//	{
	DelayNms(2);
		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;
		}
//	}
}

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

//	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)
			{
				if(EE_ACDC_State_ReadReg[chn_num].ACDC_Pow_Upthr_Warn != true)
					EE_ACDC_State_ReadReg[chn_num].ACDC_Pow_Upthr_Warn = true;
				if(ACDC_Over_WriteReg[chn_num].openration & Consumer_Max_Func)
				{
					over_Func_flag[chn_num] = 1;
				}
			}
			else {
				if(EE_ACDC_State_ReadReg[chn_num].ACDC_Ele_Upthr_Warn != false)
					EE_ACDC_State_ReadReg[chn_num].ACDC_Ele_Upthr_Warn = false;
			}
		}
		else {
			if(EE_ACDC_State_ReadReg[chn_num].ACDC_Ele_Upthr_Warn != false)
				EE_ACDC_State_ReadReg[chn_num].ACDC_Ele_Upthr_Warn = false;
		}
//	}
}
/*********************************************************************************************************
* 函数名称：WarnState
* 函数功能：根据读取的数据判断是否触发阈值
* 输入参数：void
* 输出参数：void
* 返 回 值：void
* 创建日期：2021年07月01日
* 注    意：
*           
*********************************************************************************************************/
void WarnState(uint8_t chn)
{
	WarnVolUpthrState(chn);
	WarnVolDownthrState(chn);
	WarnCurUpthrState(chn);
	WarnPowUpthrState(chn);
	WarnEleUpthrState(chn);
}
/*********************************************************************************************************
* 函数名称：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;
					}
}