SmartPDCode/truing_control/PDU-Magnetic-Retention-AC/hardware/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 "gd32f30x_libopt.h"
#include "At24cxx.h"
#include "string.h"
#include "Relay.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日
* 注    意：
*********************************************************************************************************/
extern unsigned short Devid_ChalNum;
extern uint8_t first_init_flag;
extern uint8_t show_channel_status;



void  ReadEeprom(void)
{
	uint16_t dev_info;
	AT24CxxRead(Eepr_AC_Sing_Init_Addr, (uint8_t*)&dev_info, Eepr_AC_Sing_Init_Qua);
	if(dev_info != Devid_ChalNum)
	{
		first_init_flag = 1;   //is not first init
		uint8_t data = 0xFF;
		dev_info = Devid_ChalNum;
		for(uint16_t i = 0; i < 2000;i++)
		{
			AT24CxxWrite(i,&data,1);
		}
		AT24CxxWrite(Eepr_AC_Sing_Init_Addr,(uint8_t *)&dev_info,2);
	}
		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 
			magnetic_hold_ctrl(0,RELAY_ON);
			SET_SHOW_LED(show_channel_status,0);
#if SUPPORT_TWIN_FIRE
			magnetic_hold_ctrl(4,RELAY_ON);
#endif	
				EE_ACDC_State_ReadRegTrue[0].ACDC_Cha_On_Off_State = true;
		}		
		else 
		{
				magnetic_hold_ctrl(0,RELAY_OFF);				//关继电器1 
				UNSET_SHOW_LED(show_channel_status,0);
#if SUPPORT_TWIN_FIRE
			magnetic_hold_ctrl(4,RELAY_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)
		{
			magnetic_hold_ctrl(1,RELAY_ON);
			SET_SHOW_LED(show_channel_status,1);
#if SUPPORT_TWIN_FIRE
			magnetic_hold_ctrl(5,RELAY_ON);
#endif	
				EE_ACDC_State_ReadRegTrue[1].ACDC_Cha_On_Off_State = true;
		}                           
		else 
		{
				magnetic_hold_ctrl(1,RELAY_OFF);				//关继电器1 
			UNSET_SHOW_LED(show_channel_status,1);
#if SUPPORT_TWIN_FIRE
			magnetic_hold_ctrl(5,RELAY_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)
		{
			magnetic_hold_ctrl(2,RELAY_ON);
			SET_SHOW_LED(show_channel_status,2);
#if SUPPORT_TWIN_FIRE
			magnetic_hold_ctrl(6,RELAY_ON);
#endif	
				EE_ACDC_State_ReadRegTrue[2].ACDC_Cha_On_Off_State = true;
		}                         
		else 
		{
			magnetic_hold_ctrl(2,RELAY_OFF);				//关继电器1 
			UNSET_SHOW_LED(show_channel_status,2);
#if SUPPORT_TWIN_FIRE
			magnetic_hold_ctrl(6,RELAY_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)
		{
			magnetic_hold_ctrl(3,RELAY_ON);
			SET_SHOW_LED(show_channel_status,3);
#if SUPPORT_TWIN_FIRE
			magnetic_hold_ctrl(7,RELAY_ON);
#endif	
				EE_ACDC_State_ReadRegTrue[3].ACDC_Cha_On_Off_State = true;
		}                              
		else 
		{
				magnetic_hold_ctrl(3,RELAY_OFF);				//关继电器1 
			UNSET_SHOW_LED(show_channel_status,3);
#if SUPPORT_TWIN_FIRE
			magnetic_hold_ctrl(7,RELAY_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)
		{
				magnetic_hold_ctrl(4,RELAY_ON);                          																											//开继电器5  
			SET_SHOW_LED(show_channel_status,4);
				EE_ACDC_State_ReadRegTrue[4].ACDC_Cha_On_Off_State = true;
		}                             
		else 
		{
				magnetic_hold_ctrl(4,RELAY_OFF);     																																							//关继电器5  
				UNSET_SHOW_LED(show_channel_status,4);
			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)
		{
				magnetic_hold_ctrl(5,RELAY_ON);                           																											//开继电器6  
				SET_SHOW_LED(show_channel_status,5);
			EE_ACDC_State_ReadRegTrue[5].ACDC_Cha_On_Off_State = true;
		}                             
		else 
		{
				magnetic_hold_ctrl(5,RELAY_OFF); 																																							//关继电器6 
				UNSET_SHOW_LED(show_channel_status,5);
			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)
		{
				magnetic_hold_ctrl(6,RELAY_ON);                            																											//开继电器7   
					SET_SHOW_LED(show_channel_status,6);
			EE_ACDC_State_ReadRegTrue[6].ACDC_Cha_On_Off_State = true;
		}                            
		else 
		{
				magnetic_hold_ctrl(6,RELAY_OFF); 																																							//关继电器7 
				UNSET_SHOW_LED(show_channel_status,6);
			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)
		{
				magnetic_hold_ctrl(7,RELAY_ON);                          																											//开继电器8        
			SET_SHOW_LED(show_channel_status,7);	
			EE_ACDC_State_ReadRegTrue[7].ACDC_Cha_On_Off_State = true;			
		}                   
		else 
		{
				magnetic_hold_ctrl(7,RELAY_OFF); 																																								//关继电器8  
			UNSET_SHOW_LED(show_channel_status,7);	
			EE_ACDC_State_ReadRegTrue[7].ACDC_Cha_On_Off_State = false;
		}
	}
}
#endif




void RelayState(void)
{
#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 	
}

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

/*********************************************************************************************************
* 函数名称：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;
					}
}