SmartPDCode/truing_control/PDU-Magnetic-Retention-AC/usr/main.c

#include "gd32f30x_libopt.h"
#include "systick.h"
#include <stdio.h>
#include "main.h"
#include "At24cxx.h"
#include "I2c.h"
#include "ReadEeprom.h"
#include "Fwdgt.h"
#include "key_io.h"
#include "Flash.h"
#include "Main.h"
#include "string.h"
#include "SysTick.h"
#include "Timer.h"
#include "Led.h"
#include "Key.h"
#include "Relay.h"
#include "Uart1.h"
#include "mb.h"
#include "Hlw8110.h"
#include "74hc595d.h"
#include "power_failure_save.h"


static  unsigned char RelaySlaveAddress=0x00;
static  unsigned int Uart0_Baud=115200;
static  unsigned char channel=0;
unsigned long int Delay_Ms_1=0;
static  unsigned char Delay_End_flag=0;
unsigned short int Devid_ChalNum = (ACSingCurrid<<8)+RelaySlaveChaNum;



ACDC_Delay_struct_WriteReg ACDC_Delay_WriteReg[RelaySlaveChaNum];
AC_Ele_struct_ReadReg AC_Ele_ReadReg[RelaySlaveChaNum];
ACDC_State_struct_WriteReg ACDC_State_WriteReg[RelaySlaveChaNum];
ACDC_ThresVal_struct_WriteReg ACDC_ThresVal_WriteReg[RelaySlaveChaNum];
ACDC_Coef_struct_WriteReg ACDC_Coef_WriteReg[RelaySlaveChaNum];
EE_ACDC_Delay_struct_ReadReg_On EE_ACDC_Delay_ReadReg_On[RelaySlaveChaNum];
EE_ACDC_Delay_struct_ReadReg_Off EE_ACDC_Delay_ReadReg_Off[RelaySlaveChaNum];
EE_ACDC_State_struct_ReadReg EE_ACDC_State_ReadReg[RelaySlaveChaNum];
EE_ACDC_State_struct_ReadRegTrue EE_ACDC_State_ReadRegTrue[RelaySlaveChaNum];
EE_ACDC_ThresVal_struct_ReadReg EE_ACDC_ThresVal_ReadReg[RelaySlaveChaNum];
EE_ACDC_Coef_struct_ReadReg EE_ACDC_Coef_ReadReg[RelaySlaveChaNum];

EE_ACDC_Total_Consumption  EE_ACDC_Total_Consum_Read_Reg[RelaySlaveChaNum];

ACDC_Consumer_Clear EE_ACDC_Consumer_Clear[RelaySlaveChaNum] = {0};

ACDC_Over_Func_WriteReg 	ACDC_Over_WriteReg[RelaySlaveChaNum];  

ACDC_All_Chn_Consumption ACDC_Total_All_Chn_Read_Reg;


EE_ACDC_ThresVal_struct_ReadReg EE_ACDC_All_ThrVal;

ACDC_Over_Func_WriteReg 	ACDC_Over_AllWriteReg;
ACDC_Wann_Read_Reg_t ACDC_Wann_All = {0};
EE_ACDC_State_All_Reg_En_t EE_ACDC_State_All_en;
AC_Ele_struct_ReadReg AC_Ele_ReadReg_All;


uint32_t normal_running_time = 0;

uint8_t over_Func_flag[RelaySlaveChaNum] = {0};
uint8_t over_func_all_flag = 0;

uint8_t relay_delay_flag[RelaySlaveChaNum] = {0};

uint8_t relay_delay_counter[RelaySlaveChaNum] = {0};




uint32_t read_Total_Consumer[RelaySlaveChaNum] = {0};

float Hlw8110_Restore[RelaySlaveChaNum]={0.0};

uint32_t write_2_minute_flag = 0;

uint16_t detection_value = 0;
uint8_t show_channel_status = 0;



#if SUPPORT_SELF_LOCK
	uint8_t handle_k_1_status = 1;
	uint8_t handle_k_2_status = 1;
	uint8_t handle_k_3_status = 1;
	uint8_t handle_k_4_status = 1;
	bool key_1 = 0;
	bool key_2 = 0;
	bool key_3 = 0;
	bool key_4 = 0;
#endif


META_DATA_S meta_data 		= {0};
information_t infomation;

uint8_t first_init_flag = 0;


unsigned short int Sort_Onbuf[RelaySlaveChaNum];
unsigned short int Sort_Offbuf[RelaySlaveChaNum];


unsigned long int 	AC_V_Total;         
unsigned long int 	AC_LINE_Freq_Total;	

unsigned int Start_Read_Flag;						
unsigned char Jlink_Sta_Flag = 0;				
unsigned int StaticCur = 50;						
unsigned char No_Load[RelaySlaveChaNum]={0};
unsigned char test1;
extern float   F_AC_V;												
extern float   F_AC_I;													
extern float   F_AC_P;												
extern float   F_AC_LINE_Freq;     							
extern float   F_AC_E;												
extern float   F_AC_PF;												



static  void  InitSoftware(void);   			
static  void  InitHardware(void);   			
static  void  Proc2msTask_Start(void);   	
static  void  Proc1SecTask(void);   			

static void over_RelayState(void);
static void over_RelayState_ch(uint8_t channel);
static void all_over_RelayState(void);
void switch_recode();
#if SUPPORT_SWITCH_REMENBER
	bool handle_status[RelaySlaveChaNum] = {0};
	#if ((RelaySlaveChaNum == 6) || (SUPPORT_2_DETECTION && RelaySlaveChaNum == 8))
			uint8_t handle_detection[2] = {1,1};
			uint32_t input_1_ms_count = 0;
			uint32_t input_2_ms_count = 0;
			
			uint8_t  input_1_en = 0;
			uint8_t  input_2_en = 0;
	#else
			uint8_t handle_detection[1] = {1};
	#endif
#endif

uint8_t consumer_clear_flag = 0;
uint32_t all_val = 0;
			
			
			
static  void  InitSoftware(void)
{
	eMBInit(MB_RTU, RelaySlaveAddress, 0, Uart0_Baud, MB_PAR_NONE);		
	eMBEnable();																											
}

static void app_init(META_DATA_S *meta)
{
	flash_get_meta_data(meta);
	nvic_vector_table_set(NVIC_VECTTAB_FLASH,meta->rom_addr - NVIC_VECTTAB_FLASH);
	__enable_irq();
}

void break_2_boot_upgreade(void)
{
	meta_data.errno = 0;
	meta_data.operation_flag = 1;
	meta_data.recent_running_time = normal_running_time;
	flash_erase_meta();
	flash_write_meta(&meta_data);
	__disable_irq();
	//__set_FAULTMASK(1);
	NVIC_SystemReset();
}
void check_channel_reset()
{
	if(consumer_clear_flag){
		for(int i = 0; i < RelaySlaveChaNum;i++)
		{
			if(EE_ACDC_Consumer_Clear[i].flag)
			{
				if(EE_ACDC_Consumer_Clear[i].value)
				{
					
					int temp = i << 2;
					uint8_t buff[4] = {0};
					read_Total_Consumer[i] = 0;
					Hlw8110_Restore[i] = 0.0;
					EE_ACDC_Consumer_Clear[i].value = 0;
					
				}
				EE_ACDC_Consumer_Clear[i].flag = 0;
			}
		}
		consumer_clear_flag = 0;
	}
}

static  void  Proc100msTask(void)
{
	unsigned int chal_num=0;
  if(Get100msFlag())  
  { 
		
		select_channel(channel);
		Calculate_HLW8110_MeterData();
		//AC_Ele_ReadReg[0].AC_V=(F_AC_V*EE_ACDC_Coef_ReadReg[0].ACDC_V_k)+(EE_ACDC_Coef_ReadReg[0].ACDC_V_b/1000);
		if((Start_Read_Flag)&&(channel==0x00))		
		{
			Start_Read_Flag = 0;
		}	
		AC_Ele_ReadReg[channel].AC_V=(F_AC_V*EE_ACDC_Coef_ReadReg[0].ACDC_V_k)+(EE_ACDC_Coef_ReadReg[channel].ACDC_V_b/1000);
			AC_Ele_ReadReg_All.AC_V = AC_Ele_ReadReg[0].AC_V;
			if(AC_Ele_ReadReg[channel].AC_V <= 10000)			
			{
				AC_Ele_ReadReg[channel].AC_LINE_Freq=0;
				AC_Ele_ReadReg[channel].AC_V = 0;
			}
			else
			{
				AC_Ele_ReadReg[channel].AC_LINE_Freq=F_AC_LINE_Freq*1000;
			}
		AC_Ele_ReadReg[channel].AC_I=(F_AC_I*EE_ACDC_Coef_ReadReg[channel].ACDC_I_k)+(EE_ACDC_Coef_ReadReg[channel].ACDC_I_b/1000);
		if((AC_Ele_ReadReg[channel].AC_I)<=No_Load[channel])
		{
			AC_Ele_ReadReg[channel].AC_I = 0;
		}
		if((AC_Ele_ReadReg[channel].AC_I)<=No_Load[channel])
			AC_Ele_ReadReg[channel].AC_P=0;                                                                               
		else
			AC_Ele_ReadReg[channel].AC_P=F_AC_P*1000;                                                                                
		Hlw8110_Restore[channel] += F_AC_E;
		AC_Ele_ReadReg[channel].AC_E=(Hlw8110_Restore[channel]*1000 + read_Total_Consumer[channel]);																																									 //????
		AC_Ele_ReadReg[channel].AC_PF=F_AC_PF*1000;					
		
	//	AC_Ele_ReadReg_All.AC_V = AC_Ele_ReadReg[0].AC_V;
	//	AC_Ele_ReadReg_All.AC_I += AC_Ele_ReadReg[channel].AC_I;		//all current
	//	AC_Ele_ReadReg_All.AC_P += AC_Ele_ReadReg[channel].AC_P;
	//	AC_Ele_ReadReg_All.AC_LINE_Freq = AC_Ele_ReadReg[0].AC_LINE_Freq;
	//	AC_Ele_ReadReg_All.AC_PF= AC_Ele_ReadReg[channel].AC_PF;
		
		EE_ACDC_Total_Consum_Read_Reg[channel].ACDC_Consumption = AC_Ele_ReadReg[channel].AC_E;										//total consumer
	//	ACDC_Total_All_Chn_Read_Reg.ACDC_All_Consumption += EE_ACDC_Total_Consum_Read_Reg[channel].ACDC_Consumption;
		all_val += EE_ACDC_Total_Consum_Read_Reg[channel].ACDC_Consumption;
	//	AC_Ele_ReadReg_All.AC_E += EE_ACDC_Total_Consum_Read_Reg[channel].ACDC_Consumption;

		WarnState_ch(channel);																																																							
		//over_RelayState();
		over_RelayState_ch(channel);
		channel=channel+1;
		if(channel>=RelaySlaveChaNum){
		//	ACDC_Total_All_Chn_Read_Reg.ACDC_All_Consumption = all_val;
		//	AC_Ele_ReadReg_All.AC_E = all_val;
	//		all_val = 0;
			// jugement all 
	//		All_Warn_State();
	//		all_over_RelayState();
			channel=0;
		//	AC_Ele_ReadReg_All.AC_I = 0;
			//AC_Ele_ReadReg_All.AC_E = 0;
		//	AC_Ele_ReadReg_All.AC_P = 0;
		}
//		Uart_Read_HLW8110_Reg(REG_HFCONST_ADDR,2);
    Clr100msFlag();   
  }
}
void set_channel_status(uint8_t channel,uint8_t status)
{
	
	if(status)
	{	
		EE_ACDC_State_ReadReg[channel].ACDC_Cha_On_Off_State 			= true;	
	}else
	{
		EE_ACDC_State_ReadReg[channel].ACDC_Cha_On_Off_State 			= false;	
	}
}

static  void  Proc1SecTask(void)
{ 
  if(Get1SecFlag()) 
  {
		LEDFlicker2();
    Clr1SecFlag();  
//		static uint8_t value = 0;
//		value =value *2+1; 
//		show_channel_staus(value);
		normal_running_time++;
#if SUPPORT_DETECTION
		detection_value = get_detection();
#endif
#if SUPPORT_SELF_LOCK
		key_1 = get_key_io_1();
		key_2 = get_key_io_2();
		key_3 = get_key_io_3();
		key_4 = get_key_io_4();
#endif
  }    
}

static void all_over_RelayState(void)
{
		//all 
	if(over_func_all_flag)
	{
		for(int i = 0 ; i < RelaySlaveChaNum;i++)
		{
			if(EE_ACDC_State_ReadReg[i].ACDC_Cha_On_Off_State 	== true	)	
			{
				set_channel_status(i,0);
				RelayState_ch(i);
				AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+i*2,(uint8_t *)&EE_ACDC_State_ReadReg[i],2);
			}
		}
		over_func_all_flag = 0;
		//RelayState();	
	}
	return;
}

static void over_RelayState_ch(uint8_t channel)
{
	if(over_Func_flag[channel])
	{
	   if(EE_ACDC_State_ReadReg[channel].ACDC_Cha_On_Off_State 	== true	)	
		 {
				set_channel_status(channel,0);
				RelayState_ch(channel);
			//write to flash and save status
			AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+channel*2,(uint8_t *)&EE_ACDC_State_ReadReg[channel],2);
		 }
		 over_Func_flag[channel] = 0;
	}
}


#if SUPPORT_ALL_ON_OFF
void check_or_controll_all()
{
	bool rst = false;
	bool test = false;
	rst = get_rst();
	test = get_test();
	if(detection_value != 0)
	{
		if(rst != test)
		{
			uint8_t buff[20]= {0};
			timer_disable(TIMER14);
			if(rst)
			{
//				while(All_On_Flag == 1)
//					DelayNms(5);
				
				All_Off_Flag = 1;																										//???????1
				All_On_Flag = 0;
				Delay_Ms_2 = 0;
				EE_ACDC_State_ReadReg[0].ACDC_Cha_On_Off_State=false;
				EE_ACDC_State_ReadReg[0].ACDC_ALLCha_Off_State=true;
				for(int i =0; i < RelaySlaveChaNum;i++){
					EE_ACDC_State_ReadReg[i].ACDC_Cha_On_Off_State = false;
				}	
			}
			else
			{
//				while(All_Off_Flag == 1)
//					DelayNms(5);
				All_Off_Flag =0;
				All_On_Flag = 1;																										//???????1
				EE_ACDC_State_ReadReg[0].ACDC_Cha_On_Off_State=true;
				EE_ACDC_State_ReadReg[0].ACDC_ALLCha_On_State=true;
				
				for(int i =0; i < RelaySlaveChaNum;i++)
					EE_ACDC_State_ReadReg[i].ACDC_Cha_On_Off_State = true;
				Delay_Ms_2 = 0;
				
			}
			memcpy(&buff,&EE_ACDC_State_ReadReg,RelaySlaveChaNum*2);
			AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr,buff,RelaySlaveChaNum*2);
			timer_enable(TIMER14);
		}
	}else
	{
			
				for(int i =0; i < RelaySlaveChaNum;i++){
					EE_ACDC_State_ReadReg[i].ACDC_Cha_On_Off_State = false;
					set_channel_status(i,0);
				}
				RelayState();
	}
}
#endif





void switch_recode()
{
	
#if SUPPORT_DETECTION
#if SUPPORT_SWITCH_REMENBER
	#if (SUPPORT_2_DETECTION)
		if((detection_value & 1) == 0)
			{
					if(handle_detection[0] == 1)
					{
						uint8_t channel = (RelaySlaveChaNum % 2) ? (RelaySlaveChaNum/2 +1) : (RelaySlaveChaNum / 2);
						EE_ACDC_State_ReadReg[0].ACDC_ALLCha_Off_State=true;
						for(uint8_t k = 0; k < channel;k++)
						{
							handle_status[k] = EE_ACDC_State_ReadReg[k].ACDC_Cha_On_Off_State;
							EE_ACDC_State_ReadReg[k].ACDC_Cha_On_Off_State=false;
							AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+k*2,(uint8_t *)&EE_ACDC_State_ReadReg[k],2);
							RelayState_ch(k);
						}
						handle_detection[0] = 0;
					}
			}else
			{
				if(handle_detection[0] == 0)
				{
					handle_detection[0] = 1;
					uint8_t channel = (RelaySlaveChaNum % 2) ? (RelaySlaveChaNum/2 +1) : (RelaySlaveChaNum / 2);
					EE_ACDC_State_ReadReg[0].ACDC_ALLCha_On_State=true;
					for(uint8_t k = 0; k < channel;k++)
					{
						EE_ACDC_State_ReadReg[k].ACDC_Cha_On_Off_State=handle_status[k];
						AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+k*2,(uint8_t *)&EE_ACDC_State_ReadReg[k],2);
					}
					input_1_en = 1;
					input_1_ms_count = 0;			
				}
			}
			
			if((detection_value & 2) == 0)
			{
				if(handle_detection[1] == 1)
				{
					EE_ACDC_State_ReadReg[0].ACDC_ALLCha_Off_State=true;
					uint8_t channel = (RelaySlaveChaNum % 2) ? (RelaySlaveChaNum/2 +1) : (RelaySlaveChaNum /2);
					for(uint8_t k = channel; k < RelaySlaveChaNum;k++)
					{
						handle_status[k] = EE_ACDC_State_ReadReg[k].ACDC_Cha_On_Off_State;
						EE_ACDC_State_ReadReg[k].ACDC_Cha_On_Off_State=false;
						AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+k*2,(uint8_t *)&EE_ACDC_State_ReadReg[k],2);
						RelayState_ch(k);
					}
					handle_detection[1] = 0;
				}
			}else
			{
				if(handle_detection[1] == 0)
				{
					handle_detection[1] = 1;
					EE_ACDC_State_ReadReg[0].ACDC_ALLCha_On_State=true;
					uint8_t channel = (RelaySlaveChaNum % 2) ? (RelaySlaveChaNum/2 +1) : (RelaySlaveChaNum / 2);
					for(uint8_t k = channel; k < RelaySlaveChaNum;k++)
					{
						EE_ACDC_State_ReadReg[k].ACDC_Cha_On_Off_State=handle_status[k];
						AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+k*2,(uint8_t *)&EE_ACDC_State_ReadReg[k],2);
					}
					input_2_en = 1;
					input_2_ms_count = 0;
				}
			}
	#else
		if(detection_value == 0)
		{
				if(handle_detection[0] == 1)
				{
					EE_ACDC_State_ReadReg[0].ACDC_ALLCha_Off_State=true;
					for(int i = 0;i < RelaySlaveChaNum;i++)
					{
						handle_status[i] = EE_ACDC_State_ReadReg[i].ACDC_Cha_On_Off_State;
						EE_ACDC_State_ReadReg[i].ACDC_Cha_On_Off_State = false;
						AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+i*2,(uint8_t *)&EE_ACDC_State_ReadReg[i],2);
						RelayState_ch(i);
					}
			    handle_detection[0] = 0;
				}
		}else
		{
			if(handle_detection[0] == 0)
			{
				handle_detection[0] = 1;
				EE_ACDC_State_ReadReg[0].ACDC_ALLCha_On_State=true;
				for(int i = 0;i < RelaySlaveChaNum;i++){
					EE_ACDC_State_ReadReg[i].ACDC_Cha_On_Off_State=handle_status[i];
					AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+i*2,(uint8_t *)&EE_ACDC_State_ReadReg[i],2);
				}
				
				All_On_Flag = 1;																										
				All_Off_Flag = 0;	
				Delay_Ms_2 = 0;
				timer_enable(TIMER2);
			}
		}
	#endif
#else
	#if SUPPORT_2_DETECTION
			if((detection_value & 1) == 0)
			{
					for(int i = 0; i < (RelaySlaveChaNum)/2;i++)
					{
						set_channel_status(i,0);
					}
					RelayState();
			}
			if((detection_value & 2) == 0)
			{
					for(int i = (RelaySlaveChaNum)/2; i < RelaySlaveChaNum;i++)
					{
						set_channel_status(i,0);
					}
					RelayState();
			}
	#else
			if(detection_value == 0)
			{
				for(int i = 0; i < RelaySlaveChaNum;i++)
				{
					set_channel_status(i,0);
				}
				RelayState();
			}
	#endif	
#endif
#endif
	
}



#if SUPPORT_SELF_LOCK

void sub_control()
{
	if(detection_value == 0)		//all close
	{
			for(int i = 0; i < RelaySlaveChaNum;i++)
			{
				if(EE_ACDC_State_ReadReg[channel].ACDC_Cha_On_Off_State 	== true	)
				{
					EE_ACDC_State_ReadReg[i].ACDC_Cha_On_Off_State = false;
					set_channel_status(i,0);
					RelayState_ch(i);
					AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+i*2,(uint8_t *)&EE_ACDC_State_ReadReg[i],2);
				}
			}
			//RelayState();
		
			if(key_1  == false)
			{
				handle_k_1_status = 0;
			}
			if(key_2  == false)
			{
				handle_k_2_status = 0;
			}
			if(key_3  == false)
			{
				handle_k_3_status = 0;
			}
			if(key_4  == false)
			{
				handle_k_4_status = 0;
			}
		
	}else
	{
#if (RelaySlaveChaNum >= 1)
		if(key_1  == false )				//not in line
		{
			if(handle_k_1_status == 1)
			{
				set_channel_status(0,0);
				Relay1State();
				AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr,(uint8_t*)&(EE_ACDC_State_ReadReg[0]),2);
				handle_k_1_status = 0;
			}
		}else
		{
			if(handle_k_1_status == 0)
			{
				handle_k_1_status = 1;
				set_channel_status(0,1);
				Relay1State();			
				AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr,(uint8_t*)&(EE_ACDC_State_ReadReg[0]),2);
			}
		}
#endif
#if (RelaySlaveChaNum >= 2 )
		if(key_2  == false)
		{
			if(handle_k_2_status == 1)
			{
				set_channel_status(1,0);
				Relay2State();
				BUFF;
				LOCK;
				AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+2,(uint8_t*)&(EE_ACDC_State_ReadReg[1]),2);
				handle_k_2_status = 0;
			}
		}else
		{
			if(handle_k_2_status == 0)
			{
				handle_k_2_status = 1;
				set_channel_status(1,1);
				Relay2State();
				AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+2,(uint8_t*)&(EE_ACDC_State_ReadReg[1]),2);
			}
		}
#endif
#if (RelaySlaveChaNum >= 3)
		if(key_3 == false)
		{
			if(handle_k_3_status == 1)
			{
				set_channel_status(2,0);
				Relay3State();
				AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+4,(uint8_t*)&(EE_ACDC_State_ReadReg[2]),2);
				handle_k_3_status = 0;
			}
		}else
		{
			if(handle_k_3_status == 0)
			{
				handle_k_3_status = 1;
				set_channel_status(2,1);
				Relay3State();
				AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+4,(uint8_t*)&(EE_ACDC_State_ReadReg[2]),2);
			}
		}
#endif
#if (RelaySlaveChaNum >= 4)
		if(key_4 == false)
		{
			if(handle_k_4_status == 1)
			{
				set_channel_status(3,0);
				Relay4State();
				AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+6,(uint8_t*)&(EE_ACDC_State_ReadReg[3]),2);
				handle_k_4_status = 0;
			}
		}else
		{
			if(handle_k_4_status == 0)
			{
				handle_k_4_status = 1;
				set_channel_status(3,1);
				Relay4State();
				AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+6,(uint8_t*)&(EE_ACDC_State_ReadReg[3]),2);
			}			
		}
#endif
	}
}

#endif

static  void  InitHardware(void)
{  
	unsigned int i;
	for(i=0;i<RelaySlaveChaNum;i++){
		No_Load[i] = StaticCur; 
		relay_delay_counter[i]=100;   // 100 ji shu qi
	}


	



  InitLED();          
	InitKey();           
	InitRelay();				 
  InitTimer();     
	InitAT24Cxx();	
	InitUART1(9600);    
	InitCH448F();			
		 
	key_io_init(NULL);
	shift_init();
	power_save_init();
	RelaySlaveAddress=ReadKeyValue();	
  InitSoftware();   								

	
#if SURPPORT_2_2
	solid_on();
	BUFF;
	LOCK;
#endif
	ReadEeprom();
	channel = 0;
	select_channel(channel);
	Init_HLW8110();	
	while(1)						
	{
		select_channel(channel);
		Init_HLW8110();
		channel++;
		if(channel>=RelaySlaveChaNum){
			channel=0;
			break;
		}
	}
	if(first_init_flag)
	{
		//first init all channel is close
		for(i =0 ; i < RelaySlaveChaNum;i++)
		{
			EE_ACDC_State_ReadReg[i].ACDC_Cha_On_Off_State = false;
			AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+i*2,(uint8_t *)&EE_ACDC_State_ReadReg[i],2);
			RelayState_ch(i);
		}
	}else
	{
		for(i =0 ; i < RelaySlaveChaNum;i++)
		{
			if(EE_ACDC_State_ReadReg[i].ACDC_Cha_On_Off_State == true)
				SET_SHOW_LED(show_channel_status,i);
			else
				UNSET_SHOW_LED(show_channel_status,i);
		}
	}
	strcpy(infomation.date,__DATE__);
	strcat(infomation.date," ");
	strcat(infomation.date,__TIME__);
	strcpy(infomation.ver,VERSION);
	infomation.channels = RelaySlaveChaNum;
	flash_get_infomation(&infomation);
	
	Delay_Ms_1 = 0;
#if SUPPORT_DETECTION
	detection_value = get_detection();
#endif
	 switch_recode();
#if SUPPORT_SELF_LOCK
		key_1 = get_key_io_1();
		key_2 = get_key_io_2();
		key_3 = get_key_io_3();
		key_4 = get_key_io_4();
#if RelaySlaveChaNum >= 1
		if(key_1  == false)
		{
			handle_k_1_status = 0;
			set_channel_status(0,0);
			RelayState_ch(0);
			//write to flash and save status
			AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr,(uint8_t *)&EE_ACDC_State_ReadReg[0],2);
		}
#endif
#if RelaySlaveChaNum >= 2
		if(key_2  == false)
		{
			handle_k_2_status = 0;
			set_channel_status(1,0);
			RelayState_ch(1);
			//write to flash and save status
			AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+2,(uint8_t *)&EE_ACDC_State_ReadReg[1],2);
		}
#endif
#if RelaySlaveChaNum >= 3
		if(key_3  == false)
		{
			handle_k_3_status = 0;
			set_channel_status(2,0);
			RelayState_ch(2);
			//write to flash and save status
			AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+4,(uint8_t *)&EE_ACDC_State_ReadReg[2],2);
		}
#endif
#if RelaySlaveChaNum >= 4
		if(key_4  == false)
		{
			handle_k_4_status = 0;
			set_channel_status(3,0);
			RelayState_ch(3);
			//write to flash and save status
			AT24CxxWrite(Eepr_AC_Sing_State_SmaWAddr+6,(uint8_t *)&EE_ACDC_State_ReadReg[3],2);
		}
#endif
#endif
//    copy status 2 modbus
			for(i= 0;i < RelaySlaveChaNum;i++)
			{
				EE_ACDC_State_ReadRegTrue[i].ACDC_Cha_On_Off_State = EE_ACDC_State_ReadReg[i].ACDC_Cha_On_Off_State;
			}
			timer_disable(TIMER2);
			Delay_Ms_1 = 0;
			Delay_End_flag = 0;

}

int main(void)
{
	nvic_priority_group_set(NVIC_PRIGROUP_PRE0_SUB4);
  systick_config();
	InitHardware(); 
	Fwdgt_Init();	
    
  while(1)
  {
		eMBPoll();
		Proc100msTask();		
		check_channel_reset();
    Proc1SecTask(); 			  
		Fwdgt_reload();
		switch_recode();
		
#if SUPPORT_ALL_ON_OFF
			check_or_controll_all();
#endif
#if SUPPORT_SELF_LOCK
			sub_control();
#endif
			
			show_channel_staus(show_channel_status);
		if(write_2_minute_flag == 1)
		{
			write_2_minute_flag = 0;
			uint8_t buff[4*RelaySlaveChaNum] = {0};
			
			for(int i = 0 ; i < RelaySlaveChaNum;i++)
			{
				int temp = i << 2;
				buff[temp + 0] = EE_ACDC_Total_Consum_Read_Reg[i].ACDC_Consumption >> 24;
				buff[temp + 1] = EE_ACDC_Total_Consum_Read_Reg[i].ACDC_Consumption >> 16;
				buff[temp + 2] = EE_ACDC_Total_Consum_Read_Reg[i].ACDC_Consumption >> 8;
				buff[temp + 3] = EE_ACDC_Total_Consum_Read_Reg[i].ACDC_Consumption >> 0;
			}
			AT24CxxWrite(Eepr_AC_Sing_Total_Consumer_addr, buff,4*RelaySlaveChaNum);
		}
  }
	return 0;
}