STS 第二版改动

truing_control/STS/CORE/system_gd32f30x.c

@@ -45,14 +45,14 @@
 /* use IRC8M */
 //#define __SYSTEM_CLOCK_IRC8M                    (uint32_t)(__IRC8M) 
 //#define __SYSTEM_CLOCK_48M_PLL_IRC8M            (uint32_t)(48000000)
-#define __SYSTEM_CLOCK_72M_PLL_IRC8M            (uint32_t)(72000000)
+//#define __SYSTEM_CLOCK_72M_PLL_IRC8M            (uint32_t)(72000000)
 //#define __SYSTEM_CLOCK_108M_PLL_IRC8M           (uint32_t)(108000000)
 //#define __SYSTEM_CLOCK_120M_PLL_IRC8M           (uint32_t)(120000000)
 
 /* use HXTAL(XD series CK_HXTAL = 8M, CL series CK_HXTAL = 25M) */
 //#define __SYSTEM_CLOCK_HXTAL                    (uint32_t)(__HXTAL)
 //#define __SYSTEM_CLOCK_48M_PLL_HXTAL            (uint32_t)(48000000)
-//#define __SYSTEM_CLOCK_72M_PLL_HXTAL            (uint32_t)(72000000)
+#define __SYSTEM_CLOCK_72M_PLL_HXTAL            (uint32_t)(72000000)
 //#define __SYSTEM_CLOCK_108M_PLL_HXTAL           (uint32_t)(108000000)
 //#define __SYSTEM_CLOCK_120M_PLL_HXTAL           (uint32_t)(120000000)
 

truing_control/STS/HARDWARE/At24xx/At24xx.c

@@ -37,8 +37,8 @@ void at24xx_init(void)
 	InitI2C(); 
 	sts_data_t *data = get_sts();
 	data->read_eeprom = read_iic_data;
-	data->write_at24 = at24xx_write;
-	data->read_at24 = at24xx_read;
+//	data->write_at24 = at24xx_write;
+//	data->read_at24 = at24xx_read;
 }
 uint8_t at24xx_check(void)
 {

truing_control/STS/HARDWARE/Beep/Beep.c

@@ -18,26 +18,25 @@ static void beep(void)
 	if(flag)
 	{
 		flag = 0;
-		gpio_bit_set(GPIOC, GPIO_PIN_13);
+		gpio_bit_set(GPIOC, GPIO_PIN_7);
 	}else
 	{
-		gpio_bit_reset(GPIOC, GPIO_PIN_13);
+		gpio_bit_reset(GPIOC, GPIO_PIN_7);
 		flag = 1;
 	}
 }
 static void clear_beep(void)
 {
-	gpio_bit_reset(GPIOC, GPIO_PIN_13);
+	gpio_bit_reset(GPIOC, GPIO_PIN_7);
 }
 
 void beep_init(void)
 {
 	rcu_periph_clock_enable(RCU_GPIOC);
-	
-	gpio_init(GPIOC,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_13);
-  gpio_bit_reset(GPIOC, GPIO_PIN_13); 
-	
 	sts_data_t *data = get_sts();
+	gpio_init(GPIOC,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_7);
+  
+	gpio_bit_reset(GPIOC, GPIO_PIN_7); 
 	data->beep = beep;
 	data->clear_beep = clear_beep;
 }

truing_control/STS/HARDWARE/DS18B20/ds18b20.c

@@ -0,0 +1,169 @@
+#include "ds18b20.h"
+#include "gd32f30x_libopt.h"
+#include "SysTick.h"
+#include "main.h"
+
+#define DS18B20_IO_IN() do { \
+	gpio_init(GPIOC,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,GPIO_PIN_1);	\
+}while(0);
+#define DS18B20_IO_OUT() do { \
+	gpio_init(GPIOC,GPIO_MODE_OUT_OD,GPIO_OSPEED_50MHZ,GPIO_PIN_1);	\
+	gpio_bit_set(GPIOC,GPIO_PIN_1);\
+}while(0);
+										   
+//#define	DS18B20_DQ_OUT PGout(11) 
+//#define	gpio_input_bit_get(GPIOC,GPIO_PIN_1)  PGin(11)  
+
+//复位DS18B20
+void DS18B20_Rst(void)	   
+{                 
+	DS18B20_IO_OUT(); 	//SET PG11 OUTPUT
+  gpio_bit_reset(GPIOC,GPIO_PIN_1); 	//拉低DQ
+  DelayNus(750);    	//拉低750us
+  gpio_bit_set(GPIOC,GPIO_PIN_1); 	//DQ=1 
+	DelayNus(15);     	//15US
+}
+
+
+
+uint8_t DS18B20_Check(void) 	   
+{   
+	uint8_t retry=0;
+	DS18B20_IO_IN();	//SET PG11 INPUT	 
+  while (gpio_input_bit_get(GPIOC,GPIO_PIN_1) && retry<200)
+	{
+		retry++;
+		DelayNus(1);
+	};	 
+	if(retry>=200)return 1;
+	else retry=0;
+	while (!gpio_input_bit_get(GPIOC,GPIO_PIN_1) && retry<240)
+	{
+		retry++;
+		DelayNus(1);
+	};
+	if(retry>=240)return 1;	    
+	return 0;
+}
+//从DS18B20读取一个位
+//返回值：1/0
+uint8_t DS18B20_Read_Bit(void) 	 
+{
+    uint8_t data;
+	DS18B20_IO_OUT();	//SET PG11 OUTPUT
+    gpio_bit_reset(GPIOC,GPIO_PIN_1); 
+	DelayNus(2);
+    gpio_bit_set(GPIOC,GPIO_PIN_1); 
+	DS18B20_IO_IN();	//SET PG11 INPUT
+	DelayNus(12);
+	if(gpio_input_bit_get(GPIOC,GPIO_PIN_1))data=1;
+    else data=0;	 
+    DelayNus(50);     
+		
+    return data;
+}
+//从DS18B20读取一个字节
+//返回值：读到的数据
+uint8_t DS18B20_Read_Byte(void)     
+{        
+    uint8_t i,j,dat;
+    dat=0;
+	for (i=1;i<=8;i++) 
+	{
+        j=DS18B20_Read_Bit();
+        dat=(j<<7)|(dat>>1);
+    }						    
+    return dat;
+}
+//写一个字节到DS18B20
+//dat：要写入的字节
+void DS18B20_Write_Byte(uint8_t dat)     
+ {             
+    uint8_t j;
+    uint8_t testb;
+	DS18B20_IO_OUT();	//SET PG11 OUTPUT;
+    for (j=1;j<=8;j++) 
+	{
+        testb=dat&0x01;
+        dat=dat>>1;
+        if (testb) 
+        {
+            gpio_bit_reset(GPIOC,GPIO_PIN_1);	// Write 1
+            DelayNus(2);                            
+            gpio_bit_set(GPIOC,GPIO_PIN_1);
+            DelayNus(60);             
+        }
+        else 
+        {
+            gpio_bit_reset(GPIOC,GPIO_PIN_1);	// Write 0
+            DelayNus(60);             
+            gpio_bit_set(GPIOC,GPIO_PIN_1);
+            DelayNus(2);                          
+        }
+    }
+}
+//开始温度转换
+void DS18B20_Start(void) 
+{   						               
+    DS18B20_Rst();	   
+	  DS18B20_Check();	 
+    DS18B20_Write_Byte(0xcc);	// skip rom
+    DS18B20_Write_Byte(0x44);	// convert
+} 
+
+   	 
+uint8_t DS18B20_Init(void)
+{
+
+  gpio_init(GPIOC,GPIO_MODE_OUT_OD,GPIO_OSPEED_50MHZ,GPIO_PIN_1);								//设置GPIO输出模式及速度 SDA
+	gpio_bit_set(GPIOC,GPIO_PIN_1);
+	
+	DS18B20_Rst();
+
+	return DS18B20_Check();
+}  
+static uint8_t count = 0;
+
+short DS18B20_Get_Temp(void)
+{
+	  sts_data_t *sts_d = get_sts();
+    uint8_t temp = 0;
+    uint8_t TL=0,TH=0;
+	  short tem=-550;
+    DS18B20_Start ();  			// ds1820 start convert
+    DS18B20_Rst();
+    if(DS18B20_Check())
+		{
+			count++;
+			if(count == 3)
+			{
+				sts_d->m_data.temprature_flag = 0;
+				count = 0;
+			}
+			return tem;
+		}else
+		{
+			sts_d->m_data.temprature_flag = 1;
+		}
+    DS18B20_Write_Byte(0xcc);	// skip rom
+    DS18B20_Write_Byte(0xbe);	// convert	    
+    TL=DS18B20_Read_Byte(); 	// LSB   
+    TH=DS18B20_Read_Byte(); 	// MSB  
+	    	  
+    if(TH>7)
+    {
+        TH=~TH;
+        TL=~TL; 
+        temp=0;					//温度为负  
+    }else temp=1;				//温度为正	  	  
+    tem=TH; 					//获得高八位
+    tem<<=8;    
+    tem+=TL;					//获得底八位
+    tem=(float)tem*0.625;		//转换     
+	if(temp)return tem; 		//返回温度值
+	else return -tem;    
+}
+
+
+
+ 

truing_control/STS/HARDWARE/DS18B20/ds18b20.h

@@ -0,0 +1,30 @@
+#ifndef __DS18B20_H
+#define __DS18B20_H 
+#include "stdint.h"
+
+
+   	
+uint8_t DS18B20_Init(void);
+short DS18B20_Get_Temp(void);
+void DS18B20_Start(void);
+void DS18B20_Write_Byte(uint8_t dat);
+uint8_t DS18B20_Read_Byte(void);
+uint8_t DS18B20_Read_Bit(void);
+uint8_t DS18B20_Check(void);
+void DS18B20_Rst(void);
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

truing_control/STS/HARDWARE/Electricity/Electricity.c

@@ -47,21 +47,33 @@ extern uint8_t read_ele_flag;
 void electricity_read(uint8_t channel)
 {
 	electricity_t ele = {0};
+	sts_data_t *data = get_sts();
 	select_channel(channel);
-	//DelayNus(50);
-	Check_WriteReg_Success();
-//	read_ele_flag = 1;
-//	read_ele_count = 0;
-	Calculate_HLW8110_MeterData();
-//	read_ele_flag = 0;
-//	ele.voltage = read_hlw8110_v();
-//	ele.current = read_hlw8110_i();
-//	ele.consumer = read_hlw8110_e();
-//	ele.power = read_hlw8110_p();
-//	ele.freq = read_hlw8110_freq();
-//	ele.factor = read_hlw8110_pf();
+	if(channel == 0)
+	{
+		Calculate_HLW8110_MeterData(data->m_data.output_i_k,data->m_data.output_v_k);
+	}else
+	{
+		Calculate_HLW8110_MeterData(data->m_data.input_i_k[channel-1],data->m_data.input_v_k[channel-1]);
+	}
+	
+	if(F_AC_V < 6.0)
+	{
+			F_AC_V = 0.0;
+			F_AC_I = 0.0;
+			F_AC_P = 0.0;
+			F_AC_LINE_Freq = 0.0;
+			F_AC_PF = 0.0;
+	}else if(F_AC_PF < 0.1 || F_AC_PF > 1 || F_AC_P < 1)
+	{
+			F_AC_I = 0.0;
+			F_AC_P = 0.0;
+			F_AC_PF = 0.0;
+	}else if(F_AC_LINE_Freq > 100)
+	{
+			F_AC_LINE_Freq = 0.0;
+	}
 	
-	sts_data_t *data = get_sts();
 	if(channel == 0)
 	{
 		data->m_data.out_power.voltage = F_AC_V * 1000;
@@ -72,7 +84,6 @@ void electricity_read(uint8_t channel)
 		data->m_data.out_power.factor = F_AC_PF * 1000;
 		data->iic_consumer += F_AC_E;
 		data->m_data.out_power.consumer = data->iic_consumer * 1000;
-		data->m_data.out_power.angle = F_Angle *1000;
 	}else
 	{
 		data->m_data.input[channel-1].voltage = F_AC_V * 1000;
@@ -89,6 +100,12 @@ static void check_voltage_max(uint8_t channel)
 			if(data->m_data.out_power.voltage > data->m_data.output_th.voltage_max)
 			{
 				SET_WANNING_VOLTAGE_MAX(data->m_data.output_waning.waning);
+				if(!data->o_beep.o_t.o_v_max)
+				{
+					data->o_beep.o_t.o_v_max =1;
+					data->o_beep_flag.o_t.o_v_max =1;
+					data->beep_count = data->wanning_count;
+				}
 				if(IS_OVERFUNC_VOLTAGE_MAX(data->m_data.over_func))
 				{
 					data->close_output();
@@ -96,6 +113,11 @@ static void check_voltage_max(uint8_t channel)
 			}else
 			{
 				UNSET_WANNING_VOLTAGE_MAX(data->m_data.output_waning.waning);
+				if(data->o_beep.o_t.o_v_max)
+				{
+					data->o_beep.o_t.o_v_max = 0;
+					data->o_beep_flag.o_t.o_v_max = 0;
+				}
 			}		
 		}
 	}else
@@ -104,10 +126,18 @@ static void check_voltage_max(uint8_t channel)
 		if(IS_VOLTAGE_MAX_EN(data->input_wanning_en[chn])) {
 			if(data->m_data.input[chn].voltage > data->m_data.input_th[chn].voltage_max)
 			{
+				if(!data->i_beep[chn].i_t.i_v_max)
+				{
+					data->i_beep[chn].i_t.i_v_max =1;
+					data->i_beep_flag[chn].i_t.i_v_max =1;
+					data->beep_count = data->wanning_count;
+				}
 				SET_WANNING_VOLTAGE_MAX(data->m_data.input_wanning.waning[chn]);
 			}else
 			{
 				UNSET_WANNING_VOLTAGE_MAX(data->m_data.input_wanning.waning[chn]);
+				data->i_beep[chn].i_t.i_v_max =0;
+			  data->i_beep_flag[chn].i_t.i_v_max =0;
 			}		
 		}		
 	}
@@ -121,6 +151,12 @@ static void check_voltage_min(uint8_t channel)
 		if(IS_VOLTAGE_MIN_EN(data->output_wanning_en)) {
 			if(data->m_data.out_power.voltage < data->m_data.output_th.voltage_min)
 			{
+				if(!data->o_beep.o_t.o_v_max)
+				{
+					data->o_beep.o_t.o_v_min =1;
+					data->o_beep_flag.o_t.o_v_min =1;
+					data->beep_count = data->wanning_count;
+				}
 				SET_WANNING_VOLTAGE_MIN(data->m_data.output_waning.waning);
 				if(IS_OVERFUNC_VOLTAGE_MIN(data->m_data.over_func))
 				{
@@ -128,6 +164,8 @@ static void check_voltage_min(uint8_t channel)
 				}
 			}else
 			{
+					data->o_beep.o_t.o_v_min = 0;
+					data->o_beep_flag.o_t.o_v_min = 0;
 				UNSET_WANNING_VOLTAGE_MIN(data->m_data.output_waning.waning);
 			}		
 		}
@@ -137,10 +175,18 @@ static void check_voltage_min(uint8_t channel)
 		if(IS_VOLTAGE_MIN_EN(data->input_wanning_en[chn])) {
 			if(data->m_data.input[chn].voltage < data->m_data.input_th[chn].voltage_min)
 			{
+				if(!data->i_beep[chn].i_t.i_v_min)
+				{
+					data->i_beep[chn].i_t.i_v_min =1;
+					data->i_beep_flag[chn].i_t.i_v_min =1;
+					data->beep_count = data->wanning_count;
+				}
 				SET_WANNING_VOLTAGE_MIN(data->m_data.input_wanning.waning[chn]);
 			}else
 			{
 				UNSET_WANNING_VOLTAGE_MIN(data->m_data.input_wanning.waning[chn]);
+					data->i_beep[chn].i_t.i_v_min =0;
+					data->i_beep_flag[chn].i_t.i_v_min =0;
 			}		
 		}		
 	}
@@ -156,12 +202,20 @@ static void check_current_max(uint8_t channel)
 			if(data->m_data.out_power.current > data->m_data.output_th.current_max)
 			{
 				SET_WANNING_CURRENT_MAX(data->m_data.output_waning.waning);
+				if(!data->o_beep.o_t.o_i_max)
+				{
+					data->o_beep.o_t.o_i_max =1;
+					data->o_beep_flag.o_t.o_i_max =1;
+					data->beep_count = data->wanning_count;
+				}
 				if(IS_OVERFUNC_CURRENT_MAX(data->m_data.over_func))
 				{
 					data->close_output();
 				}
 			}else
 			{
+				data->o_beep.o_t.o_i_max =0;
+				data->o_beep_flag.o_t.o_i_max =0;
 				UNSET_WANNING_CURRENT_MAX(data->m_data.output_waning.waning);
 			}		
 		}
@@ -176,6 +230,12 @@ static void check_power_max(uint8_t channel)
 		if(IS_POWER_MAX_EN(data->output_wanning_en)) {
 			if(data->m_data.out_power.power > data->m_data.output_th.power_max)
 			{
+				if(!data->o_beep.o_t.o_p_max)
+				{
+					data->o_beep.o_t.o_p_max =1;
+					data->o_beep_flag.o_t.o_p_max =1;
+					data->beep_count = data->wanning_count;
+				}
 				SET_WANNING_POWER_MAX(data->m_data.output_waning.waning);
 				if(IS_OVERFUNC_POWER_MAX(data->m_data.over_func))
 				{
@@ -183,6 +243,8 @@ static void check_power_max(uint8_t channel)
 				}
 			}else
 			{
+					data->o_beep.o_t.o_p_max = 0;
+					data->o_beep_flag.o_t.o_p_max = 0;
 				UNSET_WANNING_POWER_MAX(data->m_data.output_waning.waning);
 			}		
 		}
@@ -197,6 +259,12 @@ static void check_consumer_max(uint8_t channel)
 		if(IS_CONSUMER_MAX_EN(data->output_wanning_en)) {
 			if(data->m_data.out_power.consumer > data->m_data.output_th.consumer_max)
 			{
+				if(!data->o_beep.o_t.o_c_max)
+				{
+					data->o_beep.o_t.o_c_max =1;
+					data->o_beep_flag.o_t.o_c_max =1;
+					data->beep_count = data->wanning_count;
+				}
 				SET_WANNING_CONSUMER_MAX(data->m_data.output_waning.waning);
 				if(IS_OVERFUNC_CONSUMER_MAX(data->m_data.over_func))
 				{
@@ -204,6 +272,8 @@ static void check_consumer_max(uint8_t channel)
 				}
 			}else
 			{
+					data->o_beep.o_t.o_c_max =0;
+					data->o_beep_flag.o_t.o_c_max =0;
 				UNSET_WANNING_CONSUMER_MAX(data->m_data.output_waning.waning);
 			}		
 		}
@@ -221,9 +291,17 @@ static void check_freq_max(uint8_t channel)
 		if(IS_FREQ_MAX_EN(data->input_wanning_en[chn])) {
 			if(data->m_data.input[chn].freq > data->m_data.input_th[chn].freq_max)
 			{
+				if(!data->i_beep[chn].i_t.i_hz_max)
+				{
+					data->i_beep[chn].i_t.i_hz_max =1;
+					data->i_beep_flag[chn].i_t.i_hz_max =1;
+					data->beep_count = data->wanning_count;
+				}
 				SET_WANNING_FREQ_MAX(data->m_data.input_wanning.waning[chn]);
 			}else
 			{
+					data->i_beep[chn].i_t.i_hz_max =0;
+					data->i_beep_flag[chn].i_t.i_hz_max =0;
 				UNSET_WANNING_FREQ_MAX(data->m_data.input_wanning.waning[chn]);
 			}		
 		}
@@ -241,9 +319,17 @@ static void check_freq_min(uint8_t channel)
 		if(IS_FREQ_MIN_EN(data->input_wanning_en[chn])) {
 			if(data->m_data.input[chn].freq < data->m_data.input_th[chn].freq_min)
 			{
+				if(!data->i_beep[chn].i_t.i_hz_min)
+				{
+					data->i_beep[chn].i_t.i_hz_min =1;
+					data->i_beep_flag[chn].i_t.i_hz_min =1;
+					data->beep_count = data->wanning_count;
+				}
 				SET_WANNING_FREQ_MIN(data->m_data.input_wanning.waning[chn]);
 			}else
 			{
+					data->i_beep[chn].i_t.i_hz_min =0;
+					data->i_beep_flag[chn].i_t.i_hz_min =0;
 				UNSET_WANNING_FREQ_MIN(data->m_data.input_wanning.waning[chn]);
 			}		
 		}

truing_control/STS/HARDWARE/Exti/Exti.c

@@ -5,75 +5,72 @@
 
 #define INPUT_PIN_1   GPIO_PIN_0
 #define INPUT_PIN_2   GPIO_PIN_1
+#define SWTICH_PIN    GPIO_PIN_8
+#define KEY_BEEP_PIN  GPIO_PIN_5
 
-#define SWTICH_PIN    GPIO_PIN_5
+//#define EXIT_INPUT_PIN_1  EXTI_SOURCE_PIN0
+//#define EXIT_INPUT_PIN_2 	EXTI_SOURCE_PIN1
+//#define SWITCH_INPUT_PIN  EXTI_SOURCE_PIN8
+//#define EXIT_KEY_BEEP_PIN     GPIO_PIN_5
 
-#define EXIT_INPUT_PIN_1  EXTI_SOURCE_PIN0
-#define EXIT_INPUT_PIN_2 	EXTI_SOURCE_PIN1
 
-#define SWITCH_INPUT_PIN  EXTI_SOURCE_PIN9
 
 #define INPUT_EXIT_1 			EXTI_0
 #define INPUT_EXIT_2      EXTI_1
+#define SWITCH_EXTI       EXTI_8
+#define KEY_BEEP_EXTI     EXTI_5
 
-#define SWITCH_EXTI       EXTI_5
-
-
-static void read_input_level(uint8_t channel);
 static void read_switch_level();
 
+static uint8_t get_exti_input2(void);
+static uint8_t get_exti_input1(void);
 
 void sts_exti_init(void)
 {
-	rcu_periph_clock_enable(RCU_GPIOA);
+	rcu_periph_clock_enable(RCU_GPIOB);
 	rcu_periph_clock_enable(RCU_GPIOC);
 	rcu_periph_clock_enable(RCU_AF);
-	//rcu_periph_clock_enable(RCU_CFGCMP);
-	//rcu_periph_clock_enable(RCU_AF);
-	gpio_init(GPIOA,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,INPUT_PIN_1 | INPUT_PIN_2);
-	gpio_init(GPIOA,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,INPUT_PIN_1 | INPUT_PIN_2);
+	gpio_init(GPIOB,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,INPUT_PIN_1 | INPUT_PIN_2);
 	gpio_init(GPIOC,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,SWTICH_PIN);
-	nvic_irq_enable(EXTI0_IRQn,0,0);
-	nvic_irq_enable(EXTI1_IRQn,0,0);
-	nvic_irq_enable(EXTI5_9_IRQn,0,0);
-	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOA, GPIO_PIN_SOURCE_0);
-	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOA, GPIO_PIN_SOURCE_1);
+	gpio_init(GPIOC,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,KEY_BEEP_PIN);
+	//nvic_irq_enable(EXTI0_IRQn,0,0);
+	//nvic_irq_enable(EXTI1_IRQn,0,0);
+	nvic_irq_enable(EXTI5_9_IRQn,0,2);
+	//gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOB, GPIO_PIN_SOURCE_0);
+	//gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOB, GPIO_PIN_SOURCE_1);
+	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOC, GPIO_PIN_SOURCE_8);
 	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOC, GPIO_PIN_SOURCE_5);
 	
-	exti_init(INPUT_EXIT_1,EXTI_INTERRUPT,EXTI_TRIG_BOTH);
-	exti_init(INPUT_EXIT_2,EXTI_INTERRUPT,EXTI_TRIG_BOTH);
-//	syscfg_exti_line_config(EXTI_SOURCE_GPIOA,EXIT_INPUT_PIN_1);
-//	syscfg_exti_line_config(EXTI_SOURCE_GPIOA,EXIT_INPUT_PIN_2);
-//	syscfg_exti_line_config(EXTI_SOURCE_GPIOB,SWITCH_INPUT_PIN);
-//	
-//	exti_init(INPUT_EXIT_1,EXTI_INTERRUPT,EXTI_TRIG_BOTH);
-//	exti_init(INPUT_EXIT_2,EXTI_INTERRUPT,EXTI_TRIG_BOTH);
+	//exti_init(INPUT_EXIT_1,EXTI_INTERRUPT,EXTI_TRIG_BOTH);
+	//exti_init(INPUT_EXIT_2,EXTI_INTERRUPT,EXTI_TRIG_BOTH);
 	exti_init(SWITCH_EXTI,EXTI_INTERRUPT,EXTI_TRIG_BOTH);
-//	
-	exti_interrupt_flag_clear(INPUT_EXIT_1);
-	exti_interrupt_flag_clear(INPUT_EXIT_2);
+	exti_init(KEY_BEEP_EXTI,EXTI_INTERRUPT,EXTI_TRIG_FALLING);
+	
+	//exti_interrupt_flag_clear(INPUT_EXIT_1);
+	//exti_interrupt_flag_clear(INPUT_EXIT_2);
 	exti_interrupt_flag_clear(SWITCH_EXTI);
+	exti_interrupt_flag_clear(KEY_BEEP_EXTI);
 	
 	sts_data_t * data = get_sts();
-	
-	data->read_input_level = read_input_level;
 	data->read_switch_level = read_switch_level;
-	
+	data->get_input1_level = get_exti_input1;
+	data->get_input2_level = get_exti_input2;
+	data->exit_init_flag = 1;
 }
 
-uint8_t get_exti_in_1(void)
-{
 
-	if(gpio_input_bit_get(GPIOA,INPUT_PIN_1))
+uint8_t get_exti_switch(void)
+{
+	if(gpio_input_bit_get(GPIOC,SWTICH_PIN))
 	{
 		return 0;
 	}else 
 		return 1;
-	
 }
-uint8_t get_exti_in_2(void)
+
+static uint8_t get_exti_input1(void)
 {
-	if(gpio_input_bit_get(GPIOA,INPUT_PIN_2))
+	if(gpio_input_bit_get(GPIOB,INPUT_PIN_1))
 	{
 		return 0;
 	}else 
@@ -81,85 +78,63 @@ uint8_t get_exti_in_2(void)
 }
 
 
-static void read_input_level(uint8_t channel)
+static uint8_t get_exti_input2(void)
 {
-	sts_data_t * data = get_sts();
-	switch(channel)
-	{
-		case INPUT_CHANNEL_1:
-		{
-			data->m_data.input_status.input_status[INPUT_CHANNEL_1]	 = get_exti_in_1();
-		}
-			break;
-		case INPUT_CHANNEL_2:
-		{
-			data->m_data.input_status.input_status[INPUT_CHANNEL_2]	 = get_exti_in_2();
-		}
-			break;
-		default:
-			break;
-	}
-}
-
-
-uint8_t get_exti_switch(void)
-{
-	if(gpio_input_bit_get(GPIOC,SWTICH_PIN))
+	if(gpio_input_bit_get(GPIOB,INPUT_PIN_2))
 	{
 		return 0;
 	}else 
 		return 1;
 }
 
+
 static void read_switch_level()
 {
 	sts_data_t * data = get_sts();
 	data->switch_status = get_exti_switch();
 }
+int  up_count = 0;
+//int  down_count = 0;
 
 void EXTI0_IRQHandler(void)
 {
+#if 0
 	sts_data_t * data = get_sts();
 	if(RESET != exti_interrupt_flag_get(INPUT_EXIT_1))
 	{
 		exti_interrupt_flag_clear(INPUT_EXIT_1);
-		if(get_exti_in_1() == RESET) 					//rising
+		if(gpio_input_bit_get(GPIOB,INPUT_PIN_1) == SET) 					//rising
 		{
-			data->m_data.input_status.input_status[INPUT_CHANNEL_1] = 0;
-			if(data->m_data.input_status.input_status[INPUT_CHANNEL_2])
-			{
-				data->choise_input(INPUT_CHANNEL_2);
-			}
 			
-		}else																//falling
+			data->input_1_up_flag = 1;
+		}else	if(gpio_input_bit_get(GPIOB,INPUT_PIN_1)== RESET) 															//falling
 		{
+			
+			data->input_1_down_flag = 1;
 			data->m_data.input_status.input_status[INPUT_CHANNEL_1] = 1;
 		}
-		
 	}
+#endif
 }
 
 
 void EXTI1_IRQHandler(void)
 {
+#if 0
 	sts_data_t * data = get_sts();
 	if(RESET != exti_interrupt_flag_get(INPUT_EXIT_2))
 	{
 		exti_interrupt_flag_clear(INPUT_EXIT_2);
-		if(get_exti_in_2() == RESET)				//rising
+		if(gpio_input_bit_get(GPIOB,INPUT_PIN_2)== SET)				//rising
 		{
-			data->m_data.input_status.input_status[INPUT_CHANNEL_2] = 0;
-			if(data->m_data.input_status.input_status[INPUT_CHANNEL_1])
-			{
-				data->choise_input(INPUT_CHANNEL_1);
-			}
-		}else																//falling
+			data->input_2_up_flag = 1;
+		}else if(gpio_input_bit_get(GPIOB,INPUT_PIN_2) == RESET) 															//falling
 		{
-
+			data->input_2_down_flag = 1;
 			data->m_data.input_status.input_status[INPUT_CHANNEL_2] = 1;
 		}
-		
 	}	
+#endif
 }
 uint8_t value = 0;
 void EXTI5_9_IRQHandler(void)
@@ -169,6 +144,7 @@ void EXTI5_9_IRQHandler(void)
 	if(RESET != exti_interrupt_flag_get(SWITCH_EXTI))
 	{
 		exti_interrupt_flag_clear(SWITCH_EXTI);
+		for(int i = 0;i < 10;i++);
 		value = get_exti_switch();
 		if(value == RESET)     //rising
 		{
@@ -185,7 +161,18 @@ void EXTI5_9_IRQHandler(void)
 					data->choise_input(INPUT_CHANNEL_2);
 			}
 		}
-		
+	}
+	if(RESET != exti_interrupt_flag_get(KEY_BEEP_EXTI))
+	{
+		exti_interrupt_flag_clear(KEY_BEEP_EXTI);
+		for(int i = 0;i < 10;i++);
+		if(gpio_input_bit_get(GPIOC,KEY_BEEP_PIN) == RESET)
+		{
+			data->beep_flag = 0;
+			data->i_beep_flag[0].beep_waning = 0;
+			data->i_beep_flag[1].beep_waning = 0;
+			data->o_beep_flag.beep_waning = 0;
+		}
 	}
 }
 

truing_control/STS/HARDWARE/Fan/Fan.c

@@ -15,8 +15,8 @@
 void fans_init(void)
 {
 	rcu_periph_clock_enable(RCU_GPIOC);  
-	gpio_init(GPIOC,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_14);
-  gpio_bit_reset(GPIOC, GPIO_PIN_14);      
+	gpio_init(GPIOC,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_9);
+  gpio_bit_reset(GPIOC, GPIO_PIN_9);      
 	
 	sts_data_t *data = get_sts();
 	data->fans = fans_on_off;
@@ -28,11 +28,11 @@ void fans_on_off(unsigned char status)
 	sts_data_t *data = get_sts();
 	if(status == FANS_OFF)
 	{
-		gpio_bit_reset(GPIOC, GPIO_PIN_14); 
+		gpio_bit_reset(GPIOC, GPIO_PIN_9); 
 		data->m_data.fans_status = FANS_OFF;
 	}else if(status == FANS_ON)
 	{
-		gpio_bit_set(GPIOC, GPIO_PIN_14); 
+		gpio_bit_set(GPIOC, GPIO_PIN_9); 
 		data->m_data.fans_status = FANS_ON;
 	}else{
 	

truing_control/STS/HARDWARE/Hlw8110/Hlw8110.h

@@ -2,8 +2,9 @@
 #define __HLW8110_H	 
 
 #include "stdio.h"
+#include "stdint.h"
 
-
+//8112/8110 reg define
 #define REG_SYSCON_ADDR         0x00
 #define REG_EMUCON_ADDR         0x01
 #define REG_HFCONST_ADDR        0x02
@@ -49,7 +50,6 @@
 
 
 void Init_HLW8110(void);
-void Calculate_HLW8110_MeterData(void);
 void Clear_RxBuf(void);
 unsigned char HLW8110_checkSum_Write(unsigned char u8_Reg_length);
 unsigned char HLW8110_checkSum_Read(unsigned char u8_Reg_length);
@@ -62,26 +62,17 @@ void Uart_HLW8110_Reset(void);
 unsigned char Judge_CheckSum_HLW8110_Calfactor(void);
 void Init_HLW8110(void);
 void Check_WriteReg_Success(void);
-void Read_HLW8110_IA(void);
-void Read_HLW8110_U(void);
-void Read_HLW8110_PA(void);
-void Read_HLW8110_EA(void);
+void Read_HLW8110_IA(uint16_t i_k);
+void Read_HLW8110_U(uint16_t v_k);
+void Read_HLW8110_PA(uint16_t i_k,uint16_t v_k);
+void Read_HLW8110_EA(uint16_t i_k,uint16_t v_k);
 void Read_HLW8110_LineFreq(void);
 void Read_HLW8110_PF(void);
 void Read_HLW8110_Angle(void);
-void Calculate_HLW8110_MeterData(void);
+void Calculate_HLW8110_MeterData(uint16_t i_k,uint16_t v_k);
 
 
 void Init_HLW8112(void);
 void HLW8112_Measure(void);
-
-
-
-float read_hlw8110_i(void);
-float read_hlw8110_v(void);
-float read_hlw8110_p(void);
-float read_hlw8110_e(void);
-float read_hlw8110_pf(void);
-float read_hlw8110_freq(void);
-
+void reinit_hlw8110(void);
 #endif

truing_control/STS/HARDWARE/I2c/I2c.c

@@ -63,8 +63,8 @@ static  void  ConfigI2CGPIO(void)
 {
 	//配置PC13
   rcu_periph_clock_enable(RCU_GPIOB);                                            //使能GPIOC的时钟
-  gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_5);
-	gpio_bit_reset(GPIOB,GPIO_PIN_5);
+  gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_8);
+	gpio_bit_reset(GPIOB,GPIO_PIN_8);
 	
   //配置PB7
   gpio_init(GPIOB,GPIO_MODE_OUT_OD,GPIO_OSPEED_50MHZ,GPIO_PIN_7);								//设置GPIO输出模式及速度 SDA

truing_control/STS/HARDWARE/I2c/eeprom.c

@@ -0,0 +1,609 @@
+#include "eeprom.h"
+#include "gd32f30x_libopt.h"
+#include "SysTick.h"
+#include "main.h"
+
+
+#define ACK       1   
+#define NACK      0   
+
+#define IIC_WP_PIN          GPIO_PIN_8
+
+#define IIC_DATA_IO         GPIOB
+#define IIC_SDA_PIN         GPIO_PIN_7
+#define IIC_SCL_PIN         GPIO_PIN_6
+#define PAGE_SZIE_32        (32)
+#define PAGE_SIZE_16        (16)
+
+
+#define IIC_READ_SDA()      gpio_input_bit_get(IIC_DATA_IO, IIC_SDA_PIN) 
+
+#define IIC_SCL_SET         gpio_bit_set(IIC_DATA_IO, IIC_SCL_PIN) 
+#define IIC_SCL_CLR         gpio_bit_reset(IIC_DATA_IO, IIC_SCL_PIN) 
+
+#define IIC_SDA_SET         gpio_bit_set(IIC_DATA_IO, IIC_SDA_PIN)  
+#define IIC_SDA_CLR         gpio_bit_reset(IIC_DATA_IO, IIC_SDA_PIN)  
+
+#define AT24C01    127           
+#define AT24C02    255
+#define AT24C04    511
+#define AT24C08    1023
+#define AT24C16    2047
+#define AT24C32    4095
+#define AT24C64    8191
+#define AT24C128   16383
+#define AT24C256   32767
+
+#define USER_DEFINE_EEPROM_TYPE    AT24C64 
+#define PAGE_SIZE                  PAGE_SZIE_32
+
+
+
+
+static void 				iic_init(void);
+static void 				iic_start_signal(void);
+static void 				iic_stop_signal(void);
+static void 				iic_send_byte(uint8_t data);
+static uint8_t 			iic_read_byte(uint8_t ack); 
+static uint8_t      iic_wait_ack(void);
+static void         iic_send_ack(void);
+static void         iic_send_nack(void);
+
+
+static uint8_t      eeprom_read_1_byte(uint16_t addr);
+static void         eeprom_write_1_byte(uint16_t addr,uint8_t data);
+
+static void         eeprom_write(uint16_t w_addr,uint8_t *data,uint16_t lenth); 
+static void         eeprom_read(uint16_t r_addr,uint8_t *data,uint16_t lenth);
+static void 				check_threshold(uint8_t in_out,uint8_t channel);
+
+static uint8_t 				eeprom_page_read(uint16_t addr,uint8_t *data,uint16_t lenth);
+static uint8_t         eeprom_write_page(uint16_t addr,uint8_t *data,uint16_t chuank);
+static void 				eeprom_auto_page_write(uint16_t addr,uint8_t *data,uint16_t lenth);
+static void 				eeprom_auto_page_read(uint16_t addr,uint8_t *data,uint16_t lenth);
+static inline void iic_set_sda_input()
+{
+//	gpio_mode_set(IIC_DATA_IO, GPIO_MODE_INPUT, GPIO_PUPD_NONE, IIC_SDA_PIN);
+	gpio_init(GPIOB,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,IIC_SDA_PIN);	
+}
+
+static inline void iic_set_sda_output()
+{
+//	gpio_mode_set(IIC_DATA_IO, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, IIC_SDA_PIN);
+//	gpio_output_options_set(IIC_DATA_IO, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, IIC_SDA_PIN);
+	gpio_init(GPIOB,GPIO_MODE_OUT_OD,GPIO_OSPEED_50MHZ,IIC_SDA_PIN);	
+	gpio_bit_set(GPIOB,IIC_SDA_PIN);
+	
+}
+
+
+
+void eeprom_init(void)
+{
+
+	sts_data_t *board =get_sts();
+
+	iic_init();
+	board->read_eeprom = eeprom_read;
+	board->write_eeprom = eeprom_write;
+	board->read_eeprom_page = eeprom_auto_page_read;
+	board->write_eeprom_page = eeprom_auto_page_write;
+	
+}
+
+
+static void iic_init(void)
+{
+	
+  rcu_periph_clock_enable(RCU_GPIOB);                                            //使能GPIOC的时钟
+  gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,IIC_WP_PIN);
+	gpio_bit_reset(GPIOB,IIC_WP_PIN);
+	
+  //配置PB7
+  gpio_init(GPIOB,GPIO_MODE_OUT_OD,GPIO_OSPEED_50MHZ,IIC_SDA_PIN);								//设置GPIO输出模式及速度 SDA
+	gpio_bit_set(GPIOB,IIC_SDA_PIN);
+                                                                    
+  //配置PB6
+  gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,IIC_SCL_PIN);								//设置GPIO输出模式及速度 SCL
+	gpio_bit_set(GPIOB,IIC_SCL_PIN);
+}
+/*****************************************************************************************
+*    start data transport signal
+*								1 2    3     4
+*									__________
+*        SCL : __/          \_____
+*              ________ 
+*        SDA :         \___________
+******************************************************************************************/
+static void iic_start_signal(void)
+{
+	iic_set_sda_output();
+	IIC_SDA_SET;
+	IIC_SCL_SET;
+	DelayNus(4);
+	IIC_SDA_CLR;
+	DelayNus(4);
+	IIC_SCL_CLR;
+}
+
+/*****************************************************************************************
+*    stop data transport signal
+*								1 2    3     4
+*									     _______________
+*        SCL :  ______/
+*               __        ____________
+*        SDA :    \______/
+*                   ^
+*                   |
+*                 
+******************************************************************************************/
+static void iic_stop_signal(void)
+{
+	iic_set_sda_output();
+	IIC_SCL_CLR;
+	IIC_SDA_CLR;
+	DelayNus(4);
+	IIC_SCL_SET;
+	DelayNus(4);
+	IIC_SDA_SET;
+	DelayNus(4);
+}
+/*****************************************************************************************
+*     						iic send 1 byte  
+*                 1 2     3      4
+*                          ______  
+*           SCL:  ________/      \______
+*                 ______________________
+*           SDA:  \\\___________________
+*
+******************************************************************************************/
+static void iic_send_byte(uint8_t data)
+{
+	iic_set_sda_output();
+	IIC_SCL_CLR;
+	uint8_t t;
+	for(t = 0; t < 8; t++){
+		if((data & 0x80) >> 7)
+		{
+			IIC_SDA_SET;
+		}else
+		{
+			IIC_SDA_CLR;
+		}
+		data <<= 1;
+		DelayNus(2);
+		IIC_SCL_SET;
+		DelayNus(2);
+		IIC_SCL_CLR;
+		DelayNus(2);
+	}
+}
+/*****************************************************************************************
+*          						read 1 byte
+*                    1  2    3  4
+*                       ______
+*           SCL: ______/      \___
+*                ____________________
+*           SDA: \\\\______________\\\
+*
+******************************************************************************************/
+static uint8_t iic_read_byte(uint8_t ack)
+{
+	uint8_t i;
+	uint8_t receive = 0;
+	iic_set_sda_input();
+	for(i = 0; i < 8; i++ ){
+		IIC_SCL_CLR;
+		DelayNus(2);
+		IIC_SCL_SET;
+		receive <<= 1;
+		
+		if(IIC_READ_SDA())
+		{
+			receive ++;
+		}
+		DelayNus(1);
+	}
+	if(NACK == ack)
+	{
+		iic_send_nack();
+	}else{
+		iic_send_ack();
+	}
+	return receive;
+}
+/*****************************************************************************************
+*                wait ack signal
+*                _______|____
+*           SCL:        |    \_________
+*                _______|     
+*           SDA:         \_____________
+*
+******************************************************************************************/
+static uint8_t iic_wait_ack(void)
+{
+	uint8_t err_time = 0;
+	iic_set_sda_input();
+	IIC_SCL_SET;
+	DelayNus(1);
+	while(IIC_READ_SDA())
+	{
+		err_time++;
+		if(err_time >250)
+		{
+			iic_stop_signal();
+			return 1;
+		}
+	}
+	IIC_SCL_CLR;
+	return 0;
+}
+/*****************************************************************************************
+*                send ack signal
+*                 1 2     3      4
+*                         ______
+*           SCL: ________/      \______ 
+*                __     
+*           SDA:   \___________________
+******************************************************************************************/
+static void iic_send_ack(void)
+{
+	IIC_SCL_CLR;
+	iic_set_sda_output();
+	IIC_SDA_CLR;
+	DelayNus(2);
+	IIC_SCL_SET;
+	DelayNus(2);
+	IIC_SCL_CLR;
+}
+
+/*****************************************************************************************
+*                send nack signal
+*               1 2     3      4
+*                        ______
+*          SCL: ________/      \______ 
+*               ______________________
+*          SDA: __/
+******************************************************************************************/
+static void iic_send_nack(void)
+{
+	IIC_SCL_CLR;
+	iic_set_sda_output();
+	IIC_SDA_SET;
+	DelayNus(2);
+	IIC_SCL_SET;
+	DelayNus(2);
+	IIC_SCL_CLR;	
+}
+
+static uint8_t eeprom_read_1_byte(uint16_t addr)
+{
+	uint8_t temp =0;
+	iic_start_signal();
+	if(USER_DEFINE_EEPROM_TYPE > AT24C16)
+	{
+		iic_send_byte(0XA0);
+		iic_wait_ack();
+		iic_send_byte(addr >> 8);
+	}else
+	{
+		iic_send_byte(0XA0 + ((addr / 256) << 1));
+	}
+	iic_wait_ack();
+	iic_send_byte(addr % 256);
+	iic_wait_ack();
+	iic_start_signal();
+	iic_send_byte(0XA1);
+	iic_wait_ack();
+	temp = iic_read_byte(0);
+	iic_stop_signal();
+	return temp;
+}
+
+static void  eeprom_write_1_byte(uint16_t addr,uint8_t data)
+{
+	iic_start_signal();
+	if(USER_DEFINE_EEPROM_TYPE > AT24C16)
+	{
+		iic_send_byte(0XA0);
+		iic_wait_ack();
+		iic_send_byte(addr >> 8);
+	}else
+	{
+		iic_send_byte(0XA0 + ((addr / 256) << 1));
+	}
+	iic_wait_ack();
+	iic_send_byte(addr % 256);
+	iic_wait_ack();
+	
+	iic_send_byte(data);
+	iic_wait_ack();
+	iic_stop_signal();
+	DelayNms(7);
+}
+static void eeprom_write(uint16_t w_addr,uint8_t *data,uint16_t lenth)
+{
+	while(lenth)
+	{
+		eeprom_write_1_byte(w_addr,*data);
+		w_addr++;
+		data++;
+		lenth--;
+	}
+}
+static void eeprom_read(uint16_t r_addr,uint8_t *data,uint16_t lenth)
+{
+	while(lenth)
+	{
+		*data = eeprom_read_1_byte(r_addr);
+		data++;
+		r_addr++;
+		lenth--;
+	}
+}
+
+
+static uint8_t eeprom_page_read(uint16_t addr,uint8_t *data,uint16_t lenth)
+{
+   if(lenth == 0 || lenth > PAGE_SIZE || ((addr % PAGE_SIZE) + lenth > PAGE_SIZE))
+   {
+      return 1;
+   }
+	iic_start_signal();
+	if(USER_DEFINE_EEPROM_TYPE > AT24C16)
+	{
+		iic_send_byte(0XA0);
+	if(iic_wait_ack())
+		goto failed;
+		iic_send_byte(addr >> 8);
+	}else
+	{
+		iic_send_byte(0XA0 + ((addr / 256) << 1));
+	}
+	if(iic_wait_ack())
+		goto failed;
+	iic_send_byte(addr % 256);
+	if(iic_wait_ack())
+		goto failed;
+	iic_start_signal();
+	iic_send_byte(0XA1);
+	if(iic_wait_ack())
+		goto failed;
+	
+	for(int i = 0; i < lenth;i++)
+	{
+		if(i == lenth -1)
+		{
+			data[i] = iic_read_byte(0);
+		}else
+		{
+			data[i] = iic_read_byte(1);
+		}
+	}
+	
+	iic_stop_signal();
+	return 0;
+failed:
+	iic_stop_signal();
+	return 1;	
+}
+
+static uint8_t eeprom_write_page(uint16_t addr,uint8_t *data,uint16_t chuank)
+{
+	  if(chuank == 0 || chuank > PAGE_SIZE || ((addr % PAGE_SIZE) + chuank > PAGE_SIZE))
+    {
+        return 1;
+    }
+
+	iic_start_signal();
+	if(USER_DEFINE_EEPROM_TYPE > AT24C16)
+	{
+		iic_send_byte(0XA0);
+		if(iic_wait_ack())
+			goto failed;
+		iic_send_byte(addr >> 8);
+	}else
+	{
+		iic_send_byte(0XA0 + ((addr / 256) << 1));
+	}
+	if(iic_wait_ack())
+		goto failed;
+	iic_send_byte(addr % 256);
+	if(iic_wait_ack())
+		goto failed;
+	for(uint16_t i = 0; i < chuank;i++)
+	{
+		iic_send_byte(data[i]);
+		if(iic_wait_ack())
+			goto failed;
+	}
+	iic_stop_signal();
+	DelayNms(7);
+	
+	return 0;
+failed:
+	iic_stop_signal();
+	return 1;
+}
+
+
+
+
+static void eeprom_auto_page_write(uint16_t addr,uint8_t *data,uint16_t lenth)
+{
+    uint16_t remaining = lenth;
+    uint8_t *p = data;
+		uint8_t count = 5;
+    
+    while(remaining > 0)
+    {
+        uint8_t chunk = PAGE_SIZE - (addr % PAGE_SIZE);
+        if(chunk > remaining) chunk = remaining;
+				do{
+					if(!eeprom_write_page(addr, p,chunk))
+					{
+						break;
+					}
+				}while(count--);
+
+        addr += chunk;
+        p += chunk;
+        remaining -= chunk;
+    }	
+}
+
+
+static void eeprom_auto_page_read(uint16_t addr,uint8_t *data,uint16_t lenth)
+{
+    uint16_t remaining = lenth;
+    uint8_t *p = data;
+    uint8_t count = 5;
+	
+    while(remaining > 0)
+    {
+        uint8_t chunk = PAGE_SIZE - (addr % PAGE_SIZE);
+        if(chunk > remaining) chunk = remaining;
+				do{
+					if(!eeprom_page_read(addr, p, chunk))
+					{
+						break;
+					}
+				}while(count--);          
+        addr += chunk;
+        p += chunk;
+        remaining -= chunk;
+    }
+}
+
+void read_config_from_eeprom(void)	
+{
+	sts_data_t *sts_d = get_sts();
+	uint16_t device_info = 0xFFFF;
+	eeprom_auto_page_read(IIC_DEVICE_INFO,&device_info,sizeof(uint16_t));
+	if(device_info != sts_d->m_data.dev)
+	{
+		uint8_t * r_addr =&sts_d->m_data.input_th[0].voltage_max;
+		memset(r_addr,0,sizeof(iic_in_threshold_t)*2);
+		eeprom_auto_page_write(IIC_INPUT_THRESHOLD_START,r_addr,sizeof(iic_in_threshold_t) * 2);
+		
+		r_addr=&sts_d->m_data.output_th.voltage_max;
+		memset(r_addr,0,sizeof(iic_out_threshold_t));
+		eeprom_auto_page_write(IIC_OUTPUT_THRESHOLD_START,r_addr,sizeof(iic_out_threshold_t));
+		
+		r_addr = &sts_d->m_data.temprature_th.fans_max_temp;
+		memset(r_addr,0,sizeof(iic_temp_threshold_t));
+		eeprom_auto_page_write(IIC_TEMPRATURE_THRESHOLD_START,r_addr,sizeof(iic_temp_threshold_t));
+		
+		r_addr = &sts_d->m_data.over_func;
+		memset(r_addr,0,sizeof(iic_over_func));
+		eeprom_auto_page_write(IIC_OVER_FUNC_START,r_addr,sizeof(iic_over_func));
+		
+		sts_d->m_data.out_status = 1;
+		r_addr = &sts_d->m_data.out_status;
+		eeprom_auto_page_write(IIC_OUT_CHANNEL,r_addr,sizeof(uint16_t));		
+		eeprom_auto_page_write(IIC_DEVICE_INFO,&sts_d->m_data.dev,sizeof(uint16_t));	
+		sts_d->m_data.input_v_k[0] = 3135;
+		sts_d->m_data.input_v_k[1] = 3135;
+		sts_d->m_data.input_i_k[0] = 10000;
+		sts_d->m_data.input_i_k[1] = 10000;
+		sts_d->m_data.output_v_k = 3135;
+		sts_d->m_data.output_i_k = 10000;
+		eeprom_auto_page_write(IIC_K_START,&sts_d->m_data.input_v_k[0],sizeof(uint16_t)*6);	
+		
+		iic_consumer_data_t chache = {0};
+		for(int i = 0; i < MAX_ROW;i++)
+		{
+			eeprom_auto_page_write(IIC_CONSUMER_START+(IIC_CONSUMER_PAGE*i),&chache,sizeof(iic_consumer_data_t));
+		}
+	}
+	eeprom_auto_page_read(IIC_INPUT_THRESHOLD_START,&sts_d->m_data.input_th[0].voltage_max,sizeof(iic_in_threshold_t) * 2);
+	eeprom_auto_page_read(IIC_OUTPUT_THRESHOLD_START,&sts_d->m_data.output_th.voltage_max,sizeof(iic_out_threshold_t));
+	eeprom_auto_page_read(IIC_TEMPRATURE_THRESHOLD_START,&sts_d->m_data.temprature_th,sizeof(iic_temp_threshold_t));
+	eeprom_auto_page_read(IIC_OVER_FUNC_START,&sts_d->m_data.over_func,sizeof(iic_over_func));
+	//eeprom_auto_page_read(IIC_CONSUMER_START,&sts_d->iic_consumer,4);
+	eeprom_auto_page_read(IIC_OUT_CHANNEL,&sts_d->m_data.out_status,sizeof(uint16_t));	
+	eeprom_auto_page_read(IIC_K_START,&sts_d->m_data.input_v_k[0],sizeof(uint16_t)*6);	
+	
+	iic_consumer_data_t chache = {0};
+	for(uint8_t i = 0 ; i < MAX_ROW;i++)
+	{
+		eeprom_auto_page_read(IIC_CONSUMER_START+(IIC_CONSUMER_PAGE*i),&chache,sizeof(iic_consumer_data_t));
+		if(sts_d->kwh.index <= chache.recode_index1)
+		{
+			sts_d->kwh.index = chache.recode_index1;
+			sts_d->kwh.row = i;
+		}
+	}
+	eeprom_auto_page_read(IIC_CONSUMER_START+(IIC_CONSUMER_PAGE*sts_d->kwh.row),&chache,sizeof(iic_consumer_data_t));
+	sts_d->iic_consumer = chache.iic_consumer;
+	
+	for(uint8_t i = 0 ;i < 2 ;i ++)
+	{
+		if(sts_d->m_data.input_th[i].voltage_max > INVALID_VALUE) 	sts_d->m_data.input_th[i].voltage_max = 0;
+		if(sts_d->m_data.input_th[i].voltage_min > INVALID_VALUE) 	sts_d->m_data.input_th[i].voltage_min = 0;
+		if(sts_d->m_data.input_th[i].freq_max > INVALID_VALUE) 			sts_d->m_data.input_th[i].freq_max = 0;
+		if(sts_d->m_data.input_th[i].freq_min > INVALID_VALUE) 			sts_d->m_data.input_th[i].freq_min = 0;
+			
+		sts_d->input_wanning_en[i] = 0;
+			
+		if(sts_d->m_data.input_th[i].voltage_max <= SMALL_VALUE)
+				UNSET_VOLTAGE_MAX_EN(sts_d->input_wanning_en[i]);
+		else
+				SET_VOLTAGE_MAX_EN(sts_d->input_wanning_en[i]);
+			
+		if(sts_d->m_data.input_th[i].voltage_min <= SMALL_VALUE)
+				UNSET_VOLTAGE_MIN_EN(sts_d->input_wanning_en[i]);
+		else
+			SET_VOLTAGE_MIN_EN(sts_d->input_wanning_en[i]);		
+			
+		if(sts_d->m_data.input_th[i].freq_max <= SMALL_VALUE)
+				UNSET_FREQ_MAX_EN(sts_d->input_wanning_en[i]);
+		else
+				SET_FREQ_MAX_EN(sts_d->input_wanning_en[i]);	
+
+		if(sts_d->m_data.input_th[i].freq_min <= SMALL_VALUE)
+				UNSET_FREQ_MIN_EN(sts_d->input_wanning_en[i]);
+		else
+				SET_FREQ_MIN_EN(sts_d->input_wanning_en[i]);				
+		}
+			sts_d ->output_wanning_en = 0;
+			
+			if(sts_d->m_data.output_th.voltage_max <= SMALL_VALUE)
+				UNSET_VOLTAGE_MAX_EN(sts_d ->output_wanning_en);
+			else
+				SET_VOLTAGE_MAX_EN(sts_d ->output_wanning_en);
+			
+			if(sts_d->m_data.output_th.voltage_min <= SMALL_VALUE)
+				UNSET_VOLTAGE_MIN_EN(sts_d ->output_wanning_en);
+			else
+				SET_VOLTAGE_MIN_EN(sts_d ->output_wanning_en);
+
+			if(sts_d->m_data.output_th.current_max <= SMALL_VALUE)
+				UNSET_CURRENT_MAX_EN(sts_d ->output_wanning_en);
+			else
+				SET_CURRENT_MAX_EN(sts_d ->output_wanning_en);
+
+			if(sts_d->m_data.output_th.power_max <= SMALL_VALUE)
+				UNSET_POWER_MAX_EN(sts_d ->output_wanning_en);
+			else
+				SET_POWER_MAX_EN(sts_d ->output_wanning_en);
+
+			if(sts_d->m_data.output_th.consumer_max <= SMALL_VALUE)
+				UNSET_CONSUMER_MAX_EN(sts_d ->output_wanning_en);
+			else
+				SET_CONSUMER_MAX_EN(sts_d ->output_wanning_en);				
+		
+			if(sts_d->m_data.temprature_th.fans_max_temp > 0x7fff) sts_d->m_data.temprature_th.fans_max_temp = 0; 
+			if(sts_d->m_data.temprature_th.fans_min_temp > 0x7fff) sts_d->m_data.temprature_th.fans_min_temp = 0; 
+			if(sts_d->m_data.over_func > 0x003F)
+			{
+				sts_d->m_data.over_func = 0;
+			}
+			if(sts_d->m_data.out_status > 1)
+			{
+				sts_d->m_data.out_status = 0;
+			}
+			
+	
+}
+

truing_control/STS/HARDWARE/I2c/eeprom.h

@@ -0,0 +1,18 @@
+#ifndef __EEPROM_H_
+#define __EEPROM_H_
+
+
+
+
+
+
+
+
+
+void eeprom_init(void);
+void read_config_from_eeprom(void);
+
+
+
+
+#endif

truing_control/STS/HARDWARE/Key/Key.c

@@ -15,21 +15,20 @@
 
 #define KEY_NAME_MAX 	5
 
-#define KEY_1_RCU   	RCU_GPIOA
-#define KEY_1_IO			GPIOA
-#define KEY_2_5_RCU			RCU_GPIOB
-#define KEY_2_5_IO 			GPIOB
+#define KEY_RCU   	RCU_GPIOE
+#define KEY_IO			GPIOE
+
 
 #define KEY_ON 0
 #define KEY_OFF 1
 
 
 
-#define KEY1 GPIO_PIN_11
-#define KEY2 GPIO_PIN_15
-#define KEY3 GPIO_PIN_14
-#define KEY4 GPIO_PIN_13
-#define KEY5 	GPIO_PIN_12
+#define KEY1 GPIO_PIN_2
+#define KEY2 GPIO_PIN_3
+#define KEY3 GPIO_PIN_4
+#define KEY4 GPIO_PIN_5
+#define KEY5 	GPIO_PIN_6
 
 
 static  unsigned char  s_arrKeyDownLevel[KEY_NAME_MAX];     
@@ -39,15 +38,8 @@ static  void  ConfigKeyGPIO(void);
 
 static  void  ConfigKeyGPIO(void)
 {
-  rcu_periph_clock_enable(KEY_1_RCU); //ʹÄÜGPIOAµÄʱÖÓ
-	rcu_periph_clock_enable(KEY_2_5_RCU);
-	
-	gpio_init(KEY_1_IO,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,KEY1);
-	gpio_init(KEY_2_5_IO,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,KEY2);
-	gpio_init(KEY_2_5_IO,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,KEY3);
-	gpio_init(KEY_2_5_IO,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,KEY4);
-	gpio_init(KEY_2_5_IO,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,KEY5);
-
+  rcu_periph_clock_enable(KEY_RCU); //ʹÄÜGPIOAµÄʱÖÓ
+	gpio_init(KEY_IO,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,KEY1|KEY2|KEY3|KEY4|KEY5);
 }
 
 void InitKey(void)
@@ -67,11 +59,11 @@ unsigned char ScanKey(unsigned int gpio_periph,unsigned int pin)
 unsigned char ReadKeyValue(void)
 {
 	static  unsigned char  SlaveAddress;
-	s_arrKeyDownLevel[0]=ScanKey(KEY_1_IO,KEY1);
-	s_arrKeyDownLevel[1]=ScanKey(KEY_2_5_IO,KEY2);
-	s_arrKeyDownLevel[2]=ScanKey(KEY_2_5_IO,KEY3);
-	s_arrKeyDownLevel[3]=ScanKey(KEY_2_5_IO,KEY4);
-	s_arrKeyDownLevel[4]=ScanKey(KEY_2_5_IO,KEY5);
+	s_arrKeyDownLevel[0]=ScanKey(KEY_IO,KEY1);
+	s_arrKeyDownLevel[1]=ScanKey(KEY_IO,KEY2);
+	s_arrKeyDownLevel[2]=ScanKey(KEY_IO,KEY3);
+	s_arrKeyDownLevel[3]=ScanKey(KEY_IO,KEY4);
+	s_arrKeyDownLevel[4]=ScanKey(KEY_IO,KEY5);
 
 	SlaveAddress=(~((s_arrKeyDownLevel[4]<<4)|(s_arrKeyDownLevel[3]<<3)|(s_arrKeyDownLevel[2]<<2)|(s_arrKeyDownLevel[1]<<1)|s_arrKeyDownLevel[0]))&0x1f;
 	return SlaveAddress;

truing_control/STS/HARDWARE/Led/Led.c

@@ -15,13 +15,13 @@
 
 static void ConfigLEDGPIO(void);  
 
-#define USR_LED_RCU GPIOA
-#define USR_LED GPIO_PIN_12
+#define USR_LED_RCU GPIOC
+#define USR_LED GPIO_PIN_6
 
 
 static void ConfigLEDGPIO(void)
 {
-  rcu_periph_clock_enable(RCU_GPIOA);                                        
+  rcu_periph_clock_enable(RCU_GPIOC);                                        
 	gpio_init(USR_LED_RCU,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,USR_LED);
   gpio_bit_reset(USR_LED_RCU, USR_LED);                                              
 }

truing_control/STS/HARDWARE/R_Led/R_Led.c

@@ -14,18 +14,18 @@
 #include "main.h"
 
 
-#define POWER_R2_Y        GPIO_PIN_12
-#define POWER_R2_G        GPIO_PIN_11
-#define POWER_R2_R        GPIO_PIN_10
+#define POWER_R2_Y        GPIO_PIN_4
+#define POWER_R2_G        GPIO_PIN_5
+#define POWER_R2_R        GPIO_PIN_6
 
-#define POWER_R1_Y        GPIO_PIN_9
-#define POWER_R1_G        GPIO_PIN_8
-#define POWER_R1_R        GPIO_PIN_7
+#define POWER_R1_Y        GPIO_PIN_1
+#define POWER_R1_G        GPIO_PIN_2
+#define POWER_R1_R        GPIO_PIN_3
 
 
-#define POWER_OUT_R      	GPIO_PIN_2
-#define POWER_OUT_G       GPIO_PIN_3
-#define POWER_OUT_Y       GPIO_PIN_4
+#define POWER_OUT_R      	GPIO_PIN_14
+#define POWER_OUT_G       GPIO_PIN_13
+#define POWER_OUT_Y       GPIO_PIN_12
 
 
 
@@ -38,10 +38,10 @@ uint16_t led_status = 0;
 
 void r_led_init(void)
 {
-	rcu_periph_clock_enable(RCU_GPIOC);  
+	rcu_periph_clock_enable(RCU_GPIOD);  
 
-	gpio_init(GPIOC,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,POWER_R2_Y |POWER_R2_G| POWER_R2_R | POWER_R1_Y | POWER_R1_G | POWER_R1_R | POWER_OUT_R | POWER_OUT_G | POWER_OUT_Y);
-	gpio_bit_reset(GPIOC, POWER_R2_Y |POWER_R2_G| POWER_R2_R | POWER_R1_Y | POWER_R1_G | POWER_R1_R | POWER_OUT_R | POWER_OUT_G | POWER_OUT_Y);	
+	gpio_init(GPIOD,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,POWER_R2_Y |POWER_R2_G| POWER_R2_R | POWER_R1_Y | POWER_R1_G | POWER_R1_R | POWER_OUT_R | POWER_OUT_G | POWER_OUT_Y);
+	gpio_bit_reset(GPIOD, POWER_R2_Y |POWER_R2_G| POWER_R2_R | POWER_R1_Y | POWER_R1_G | POWER_R1_R | POWER_OUT_R | POWER_OUT_G | POWER_OUT_Y);	
 	
 }
 
@@ -50,12 +50,12 @@ void in_r_led_on_off(unsigned char channel)
 {
 //	if(channel  == 0)
 //	{
-//		gpio_bit_set(GPIOB, GPIO_PIN_2);
-//		gpio_bit_reset(GPIOB, GPIO_PIN_10);
+//		gpio_bit_set(GPIOD, POWER_R1_G);
+//		gpio_bit_reset(GPIOD, POWER_R2_G);
 //	}else
 //	{
-//		gpio_bit_reset(GPIOB, GPIO_PIN_2);
-//		gpio_bit_set(GPIOB, GPIO_PIN_10);
+//		gpio_bit_reset(GPIOD, POWER_R1_G);
+//		gpio_bit_set(GPIOD, POWER_R2_G);
 //	}
 }
 
@@ -63,10 +63,10 @@ void out_r_led(unsigned char status)
 {
 //	if(status == 0)
 //	{
-//		gpio_bit_set(GPIOB, GPIO_PIN_11);
+//		gpio_bit_set(GPIOD, POWER_OUT_G);
 //	}else
 //	{
-//		gpio_bit_reset(GPIOB, GPIO_PIN_11);
+//		gpio_bit_reset(GPIOD, POWER_OUT_G);
 //	}
 }
 
@@ -92,7 +92,6 @@ void show_wanning_led(void)
 				if(data->m_data.input_wanning.waning[0] != 0)
 				{
 					value |= POWER_R1_Y;
-					//value |= POWER_R2_G;
 				}else
 				{
 					value |= POWER_R1_G;
@@ -100,7 +99,6 @@ void show_wanning_led(void)
 				if(data->m_data.input_wanning.waning[1] != 0)
 				{
 					value |= POWER_R2_Y;
-					//value |= POWER_R1_G;
 				}else
 				{
 					value |= POWER_R2_G;
@@ -118,7 +116,7 @@ void show_wanning_led(void)
 					{
 						value |= POWER_R2_Y;
 					}else
-						value |=POWER_R2_G;
+						value |= POWER_R2_G;
 				
 				}
 				if(data->m_data.input_wanning.waning[0] != 0)
@@ -159,10 +157,8 @@ void show_wanning_led(void)
 		if(value != led_status)
 		{
 			led_status = value;
-			gpio_bit_reset(GPIOC, POWER_R2_Y |POWER_R2_G| POWER_R2_R | POWER_R1_Y | POWER_R1_G | POWER_R1_R | POWER_OUT_R | POWER_OUT_G | POWER_OUT_Y);	
-			gpio_bit_set(GPIOC,led_status);
-			unlock();
-			lock();
+			gpio_bit_reset(GPIOD, POWER_R2_Y |POWER_R2_G| POWER_R2_R | POWER_R1_Y | POWER_R1_G | POWER_R1_R | POWER_OUT_R | POWER_OUT_G | POWER_OUT_Y);	
+			gpio_bit_set(GPIOD,led_status);
 		}
 	}
 }

truing_control/STS/HARDWARE/Relay/Relay.c

@@ -16,12 +16,12 @@
 
 
 
-#define RELAY_RCU  				RCU_GPIOC
-#define RELAY_GPIO   			GPIOC
+#define RELAY_RCU  				RCU_GPIOA
+#define RELAY_GPIO   			GPIOA
 
 
-#define RELAY_1  GPIO_PIN_0
-#define RELAY_2  GPIO_PIN_1
+#define RELAY_1  GPIO_PIN_6
+#define RELAY_2  GPIO_PIN_7
 
 
 static void ConfigRelayGPIO(void);  
@@ -30,8 +30,8 @@ static void ConfigRelayGPIO(void)
 {
 	rcu_periph_clock_enable(RELAY_RCU);
 	
-	gpio_init(RELAY_GPIO,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_0 | GPIO_PIN_1);
-	gpio_bit_reset(RELAY_GPIO,GPIO_PIN_0 | GPIO_PIN_1);
+	gpio_init(RELAY_GPIO,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,RELAY_1 | RELAY_2);
+	gpio_bit_reset(RELAY_GPIO,RELAY_1 | RELAY_2);
 }
 void InitRelay(void)
 {
@@ -58,8 +58,8 @@ void choise_input(uint8_t channel)
 			
 			data->m_data.md_choise.choise_ch = INPUT_CHANNEL_1;
 			in_r_led_on_off(channel);
-			unlock();
-			lock();
+//			unlock();
+//			lock();
 		}
 		break;
 		case 1:
@@ -68,8 +68,8 @@ void choise_input(uint8_t channel)
 			gpio_bit_set(RELAY_GPIO, RELAY_1);
 			data->m_data.md_choise.choise_ch = INPUT_CHANNEL_2;
 			in_r_led_on_off(channel);
-			unlock();
-			lock();
+//			unlock();
+//			lock();
 		}
 		break;
 		default:
@@ -81,9 +81,9 @@ void choise_input(uint8_t channel)
 void out_open()
 {
 		sts_data_t *data = get_sts();
-		unlock();
+		//unlock();
 		gpio_bit_set(RELAY_GPIO, RELAY_2);
-		lock();
+		//lock();
 		out_r_led(0);
 		data->m_data.out_status = OUT_OPEN;
 }
@@ -91,9 +91,9 @@ void out_open()
 void out_close()
 {
 		sts_data_t *data = get_sts();
-		unlock();
+		//unlock();
 		gpio_bit_reset(RELAY_GPIO, RELAY_2);
-		lock();
-		out_r_led(1);
+		//lock();
+		//out_r_led(1);
 		data->m_data.out_status = OUT_CLOSE;
 }

truing_control/STS/HARDWARE/Sn74lvc573/Sn74lvc573.c

@@ -14,23 +14,25 @@
 static  void  Config74LvcGPIO(void); 
 
 
-#define LOCK_OE 							GPIO_PIN_3
-#define LOCK_LE 							GPIO_PIN_4
+#define LOCK_OE 							GPIO_PIN_11
+#define LOCK_LE 							GPIO_PIN_12
 
 
 static  void  Config74LvcGPIO(void)
 {
+#if 1
 	rcu_periph_clock_enable(RCU_AF);
 	gpio_pin_remap_config(GPIO_SWJ_SWDPENABLE_REMAP,ENABLE);	
 
   rcu_periph_clock_enable(RCU_GPIOA); 
-  rcu_periph_clock_enable(RCU_GPIOB); 
+  //rcu_periph_clock_enable(RCU_GPIOB); 
 	
-	gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,LOCK_OE);
-	gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,LOCK_LE);
+	gpio_init(GPIOA,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,LOCK_OE);
+	gpio_init(GPIOA,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,LOCK_LE);
   				 
   gpio_bit_reset(GPIOA, LOCK_OE);                                           
 	 gpio_bit_reset(GPIOA, LOCK_LE);  
+#endif
 }
 
 
@@ -42,9 +44,9 @@ void Init74Lvc(void)
 
 void lock(void)
 {
-	gpio_bit_set(GPIOB, LOCK_LE);
+	gpio_bit_set(GPIOA, LOCK_LE);
 }
 void unlock(void)
 {
-	gpio_bit_reset(GPIOB, LOCK_LE);
+	gpio_bit_reset(GPIOA, LOCK_LE);
 }

truing_control/STS/HARDWARE/Temprature/Temprature.c

@@ -11,6 +11,7 @@
 #include "Adc.h"
 #include "main.h"
 #include "math.h"
+#include "ds18b20.h"
 /****************************************************************
 *
 *     NXFT15XH103
@@ -34,13 +35,36 @@ static float get_temp(void);
 
 //static uint32_t all_get_ad = 0;
 
+static short temp[20] = {0};
+static int count = 0;
+
+static int cmp_func (const void * a, const void * b)
+{
+	return (*(short*)a - *(short*)b);
+}
 
 static float get_temp(void)
 {
 	sts_data_t *data = get_sts();
 	uint32_t all_get_ad = 0;	
 	float temprature = 0.0;
-	
+	short tmp = DS18B20_Get_Temp();
+	if(tmp >= -550 && tmp <=1250)
+	{
+		temp[count++] = tmp;
+		if(count == 20)
+		{
+			qsort(temp, 20, sizeof(short),cmp_func);
+			temprature = (float)(temp[10]) / 10.0;
+			data->m_data.temprature = temprature * 10;
+			count = 0;
+		}
+	}
+	if(data->m_data.temprature_flag == 0)
+	{
+		data->m_data.temprature = 0;
+	}
+#if 0
 	for(uint32_t i = 0; i < GATHER_MAX ;i++)
 	{
 		all_get_ad += get_adc();
@@ -66,13 +90,16 @@ static float get_temp(void)
 		data->m_data.temprature_flag = TEMP_INLINE;
 		data->m_data.temprature =(-88.88 *100);
 	}
+#endif
+	
 	return temprature;
 }
 
 
 void temp_init(void)
 {
-	adc_init();
+	//adc_init();
+	DS18B20_Init();
 	sts_data_t *data = get_sts();
 	data->read_temp = get_temp;
 }

truing_control/STS/HARDWARE/Timer/Timer.c

@@ -46,28 +46,134 @@ static void ConfigTimer14(unsigned short arr, unsigned short psc)
   timer_enable(TIMER2);                      
 }
 
-//uint32_t read_ele_count = 0;
-//uint8_t read_ele_flag = 0;
 
+static 	uint8_t   cnt_1 = 0;
+static 	uint8_t   cnt_2 = 0;
+
+static  uint8_t   level_cnt1 = 0;
+static  uint8_t   level_cnt2 = 0;
+
+static uint32_t   beep_cnt = 0;
 
 void TIMER2_IRQHandler(void)
 {  
   //static  unsigned short s_iCnt2 = 0;                            
 	static  uint16_t  cnt_1000 = 0;
 	static  uint16_t   cnt_100 = 0;
-	static 	uint8_t   cnt_5 = 0;
+	
+
   if(timer_interrupt_flag_get(TIMER2, TIMER_INT_FLAG_UP) == SET) 
   {
     timer_interrupt_flag_clear(TIMER2, TIMER_INT_FLAG_UP);       
   }
+	if(data->beep_flag || data->i_beep_flag[0].beep_waning || data->i_beep_flag[1].beep_waning || data->o_beep_flag.beep_waning)
+	{
+		beep_cnt++;
+		if(beep_cnt >= data->beep_count)
+		{
+			beep_cnt = 0;
+			data->beep();
+		}
+	}else
+	{
+		beep_cnt = 0;
+	}
+	
+	
+#if 0
+	if(data->input_1_up_flag)
+	{
+		level_cnt1 = 0;
+		if(!data->input_1_down_flag)
+		{
+			cnt_1++;
+			if(cnt_1 >= 3)
+			{
+				cnt_1 = data->input_1_up_flag = data->input_1_down_flag = 0;
+				data->m_data.input_status.input_status[INPUT_CHANNEL_1] = 0;
+				if(data->m_data.input_status.input_status[INPUT_CHANNEL_2]) data->choise_input(INPUT_CHANNEL_2);
+			}
+		}else
+		{
+			cnt_1 = data->input_1_up_flag = data->input_1_down_flag = 0;
+		}
+	}
+#endif
+	if(data->exit_init_flag)
+	{
+			if(data->get_input1_level()==0)
+			{
+				level_cnt1++;
+				if(level_cnt1 >= 3)
+				{
+					level_cnt1 = 0;
+					data->m_data.input_status.input_status[INPUT_CHANNEL_1] = 0;
+					if(data->m_data.input_status.input_status[INPUT_CHANNEL_2])
+					{
+						if(data->m_data.md_choise.choise_ch != INPUT_CHANNEL_2)
+						{
+							data->choise_input(INPUT_CHANNEL_2);
+						}
+					}						
+				}
+			}else
+			{
+				level_cnt1 = 0;
+				data->m_data.input_status.input_status[INPUT_CHANNEL_1] = 1;
+			}
+	}
+	
+	
+#if 0
+	if(data->input_2_up_flag)
+	{
+		if(!data->input_2_down_flag)
+		{
+			cnt_2++;
+			if(cnt_2 >= 3)
+			{
+				cnt_2 = data->input_2_up_flag = data->input_2_down_flag = 0;
+				data->m_data.input_status.input_status[INPUT_CHANNEL_2] = 0;
+				if(data->m_data.input_status.input_status[INPUT_CHANNEL_1]) data->choise_input(INPUT_CHANNEL_1);
+			}
+		}else
+		{
+			cnt_2 = data->input_2_up_flag = data->input_2_down_flag = 0;
+		}
+	}
+#endif
+	if(data->exit_init_flag)
+	{
+			if(data->get_input2_level()==0)
+			{
+				level_cnt2++;
+				if(level_cnt2 >= 2)
+				{
+					level_cnt2 = 0;
+					data->m_data.input_status.input_status[INPUT_CHANNEL_2] = 0;
+					if(data->m_data.input_status.input_status[INPUT_CHANNEL_1])
+					{
+						if(data->m_data.md_choise.choise_ch != INPUT_CHANNEL_1)
+						{
+							data->choise_input(INPUT_CHANNEL_1);
+						}
+					}						
+				}
+			}else
+			{
+				level_cnt2 = 0;
+				data->m_data.input_status.input_status[INPUT_CHANNEL_2] = 1;
+			}
+	}
+
 	cnt_1000++;
 	cnt_100++;
-	if(cnt_1000 >=1000)
+	if(cnt_1000 >= 1000)
 	{
 		data->flag_1000ms = 1;
 		cnt_1000 = 0;
 	}
-	if(cnt_100 >= 300)
+	if(cnt_100 >= 100)
 	{
 		data->flag_100ms = 1;
 		cnt_100 = 0;
@@ -83,8 +189,8 @@ void TIMER2_IRQHandler(void)
 
 void InitTimer(void)
 {
+	data  = get_sts();
 	ConfigTimer14(999, 71);  //72MHz/(71+1)=1MHz£¬ÓÉ0¼ÆÊýµ½999Ϊ1ms 
- data  = get_sts();
 }
 
 

truing_control/STS/HARDWARE/Uart1/Uart1.c

@@ -17,23 +17,23 @@
 
 #define UART1_BUF_SIZE 10       
 
-#define XEN GPIO_PIN_0
-#define YEN GPIO_PIN_1
+#define XEN GPIO_PIN_11
+#define YEN GPIO_PIN_12
 
 
-#define SEL0 GPIO_PIN_2
-#define SEL1 GPIO_PIN_10
-#define SEL2 GPIO_PIN_11
+#define SEL0 GPIO_PIN_13
+#define SEL1 GPIO_PIN_14
+#define SEL2 GPIO_PIN_15
 
 
-#define SEL_0_H  gpio_bit_set(GPIOB,GPIO_PIN_2)
-#define SEL_0_L  gpio_bit_reset(GPIOB,GPIO_PIN_2)
+#define SEL_0_H  gpio_bit_set(GPIOE,GPIO_PIN_13)
+#define SEL_0_L  gpio_bit_reset(GPIOE,GPIO_PIN_13)
 
-#define SEL_1_H  gpio_bit_set(GPIOB,GPIO_PIN_10)
-#define SEL_1_L  gpio_bit_reset(GPIOB,GPIO_PIN_10)
+#define SEL_1_H  gpio_bit_set(GPIOE,GPIO_PIN_14)
+#define SEL_1_L  gpio_bit_reset(GPIOE,GPIO_PIN_14)
 
-#define SEL_2_H  gpio_bit_set(GPIOB,GPIO_PIN_11)
-#define SEL_2_L  gpio_bit_reset(GPIOB,GPIO_PIN_11)
+#define SEL_2_H  gpio_bit_set(GPIOE,GPIO_PIN_15)
+#define SEL_2_L  gpio_bit_reset(GPIOE,GPIO_PIN_15)
 
 extern unsigned char	u8_TxBuf[UART1_BUF_SIZE]; 
 extern unsigned char	u8_RxBuf[UART1_BUF_SIZE];
@@ -68,9 +68,9 @@ extern unsigned char	B_Rx_Finish;
 static void ConfigCH448FGPIO(void)
 {
 
-	rcu_periph_clock_enable(RCU_GPIOB);
-	gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_10|GPIO_PIN_11);
-	gpio_bit_reset(GPIOB,GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_10|GPIO_PIN_11);
+	rcu_periph_clock_enable(RCU_GPIOE);
+	gpio_init(GPIOE,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15);
+	gpio_bit_reset(GPIOE,GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15);
 }
 
 static void ConfigUART1(unsigned int bound)
@@ -101,21 +101,31 @@ static void ConfigUART1(unsigned int bound)
 
 void USART1_IRQHandler(void)            
 {
-  if(usart_interrupt_flag_get(USART1, USART_INT_FLAG_RBNE) != RESET)  
+	if(usart_flag_get(USART1, USART_FLAG_ORERR) == SET)
   {                                                         
-    usart_interrupt_flag_clear(USART1, USART_INT_FLAG_RBNE);  
+    usart_flag_clear(USART1, USART_FLAG_ORERR);       
+  } 
+	if(usart_interrupt_flag_get(USART1, USART_INT_FLAG_TBE)!= RESET) 
+  {     
+    usart_interrupt_flag_clear(USART1, USART_INT_FLAG_TBE);       
+  }
+	if(usart_interrupt_flag_get(USART1, USART_INT_FLAG_RBNE) != RESET) 
+	{
+		usart_interrupt_flag_clear(USART1, USART_INT_FLAG_RBNE);
 		if (u8_RX_Index < u8_RX_Length )
 		{
-			u8_RxBuf[u8_RX_Index] = usart_data_receive(USART1);    
+			u8_RxBuf[u8_RX_Index] = usart_data_receive(USART1); 
 			u8_RX_Index++;
-			B_Rx_Data_ING = 1;																			
+			B_Rx_Data_ING = 1;
+			if(u8_RX_Index == u8_RX_Length)
+			{
+				B_Rx_Finish = TRUE;	
+				u8_RX_Index = 0;
+			}
 		}
-    else
-		{
-			B_Rx_Finish = TRUE;								
-			u8_RX_Index = 0;
-		}                                                                                     
-  }                                                                                                                                                                                                                                
+	}
+
+	
 } 
 
 void InitUART1(unsigned int bound)

truing_control/STS/HARDWARE/common/common.c

@@ -0,0 +1,257 @@
+#include "common.h"
+#include "board_cfg.h"
+#include "systick.h"
+#include "string.h"
+
+#if EEPROM_TEST		
+
+#define TEST_ADDR  (120 * 32)
+#define LENTH      (32)
+
+#endif
+
+
+
+void reset_config_for_eeprom(void)
+{
+	board_t *board = get_board();
+	if(board)
+	{
+			for(uint8_t i = 0; i < MAX_CHANNEL;i++)
+			{
+				board->md_data.rw_data.open.delay_open[i]  = (1+i) *1000;
+				board->md_data.rw_data.close.delay_close[i] = (1+i) *1000;
+			}
+		memset((void*)&board->md_data.rw_data.thr.th[0].v_top,0,sizeof(ac_rw_data_t)-sizeof(ac_delay_open_t)-sizeof(ac_delay_close_t));
+		board->write_eeprom_page(EEPROM_OTHER_ADDR,(uint8_t *)&board->md_data.rw_data.open.delay_open[0], sizeof(ac_rw_data_t));
+	}
+}
+
+
+void read_config_from_eeprom(void)
+{
+	board_t *board = get_board();
+	if(board)
+	{
+		uint16_t device = 0;
+		board->read_eeprom(EEPROM_DEVICES_ADDR,(uint8_t *)&device,EEPROM_DEVICES_LENTH);
+
+		if(device != board->md_data.r_data.dev_chn)
+		{
+			//default write eeprom
+			
+			board->write_eeprom_page(EEPROM_STATUS_ADDR,(uint8_t *)&board->relay_staging_staus[0],2*RelaySlaveChaNum);
+			for(uint8_t i = 0; i < RelaySlaveChaNum;i++)
+			{
+				board->md_data.rw_data.open.delay_open[i]  	= (1+i) * 1000;
+				board->md_data.rw_data.close.delay_close[i] = (1+i) * 1000;
+			}
+			
+			board->write_eeprom_page(EEPROM_OTHER_ADDR,(uint8_t *)&board->md_data.rw_data.open.delay_open[0], sizeof(ac_rw_data_t));
+			iic_data chache={0};
+			for(uint8_t i = 0 ; i < MAX_ROW;i++){
+				board->write_eeprom_page(EEPROM_CONSUMER_ADDR +(CONSUM_PAGE*i),(uint8_t*)&chache.data[0],CONSUM_PAGE);
+			}
+			
+			board->v_k[0] = 3135;
+			board->v_k[1] = 3135;
+			
+			board->i_k[0] = 10000;
+			board->i_k[1] = 10000;		
+			board->write_eeprom_page(EEPROM_K_V_ADDR,(uint8_t *)&board->v_k[0],EEPROM_K_V_LEN);
+			
+			board->write_eeprom_page(EEPROM_K_I_ADDR,(uint8_t *)&board->i_k[0],EEPROM_K_I_LEN);
+				
+			board->write_eeprom_page(EEPROM_DEVICES_ADDR,(uint8_t *)&board->md_data.r_data.dev_chn,EEPROM_DEVICES_LENTH);
+		}
+		{
+			//channel open or close
+			board->read_eeprom_page(EEPROM_STATUS_ADDR,(uint8_t *)&board->relay_staging_staus[0],2*RelaySlaveChaNum);
+			{
+				for(int i = 0 ;i < RelaySlaveChaNum;i++)
+				{
+#ifndef SUPPORT_MON
+		#if SUPPORT_CTRL2_LOCK2
+					if(i < AVALIABLE_RELAY)
+					{
+						if(board->relay_staging_staus[i])
+						{
+							SET_RL_ON_DELAY_FLAG(board->relay_staging_staus[i]);
+							CLEAR_RL_OFF_DELAY_FLAG(board->relay_staging_staus[i]);
+							SET_RL_ORDER_FLAG(board->relay_staging_staus[i]);
+						}
+					}else
+					{
+						board->md_data.r_data.state.state[i].state = 1;
+					}
+					
+		#else					
+					if(board->relay_staging_staus[i])
+					{
+						SET_RL_ON_DELAY_FLAG(board->relay_staging_staus[i]);
+						CLEAR_RL_OFF_DELAY_FLAG(board->relay_staging_staus[i]);
+						SET_RL_ORDER_FLAG(board->relay_staging_staus[i]);
+					}
+		#endif
+#else
+					board->md_data.r_data.state.state[i].state = 1;
+#endif
+				}
+
+			}
+			board->read_eeprom_page(EEPROM_OTHER_ADDR,(uint8_t *)&board->md_data.rw_data.open.delay_open[0],sizeof(ac_rw_data_t));
+
+			for(uint8_t i = 0 ; i < RelaySlaveChaNum;i++)
+			{
+				board->check_threshold(THRESHOLD_OUT,i);
+			}
+			
+			board->read_eeprom_page(EEPROM_K_V_ADDR,(uint8_t *)&board->v_k[0],EEPROM_K_V_LEN);
+			
+			board->read_eeprom_page(EEPROM_K_I_ADDR,(uint8_t *)&board->i_k[0],EEPROM_K_I_LEN);
+			
+			for(int i =0 ;i < 2;i++)
+			{
+				board->v_k[i] = board->v_k[i] > 10000 ?  3135 : board->v_k[i];
+				board->i_k[i] = board->i_k[i] > 10000 ?  10000 : board->i_k[i];
+			}
+			
+			iic_data chache={0};
+			for(uint8_t i = 0 ; i < MAX_ROW;i++)
+			{
+				board->read_eeprom_page(EEPROM_CONSUMER_ADDR + (CONSUM_PAGE*i),(uint8_t*)&chache,sizeof(iic_data));
+				if(board->con_da.index > chache.iic_con.recode_index1)
+				{
+					
+				}else
+				{
+					board->con_da.index = chache.iic_con.recode_index1;
+					board->con_da.row = i;
+				}
+			}	
+			board->read_eeprom_page(EEPROM_CONSUMER_ADDR +(CONSUM_PAGE*(board->con_da.row)),(uint8_t*)&chache,sizeof(iic_data));
+			for(uint16_t i = 0 ; i < RelaySlaveChaNum;i++)
+			{
+					board->ele_restore[i] = chache.iic_con.iic_consumer[i];
+			}
+
+			board->con_da.row++;      //point next write row
+			if(board->con_da.row >= MAX_ROW)
+			{
+				board->con_da.row = 0;
+			}
+			board->con_da.index++;		//point next write consumer index
+			if(board->con_da.index >= UINT64_MAX)
+			{
+				iic_data chache1={0};
+				board->con_da.index = 0;
+				for(uint8_t i = 0 ; i < MAX_ROW;i++){
+					board->write_eeprom_page(EEPROM_CONSUMER_ADDR +(CONSUM_PAGE*i),(uint8_t*)&chache1,CONSUM_PAGE);
+					DelayNms(7);
+				}
+			}
+			//read chn ctrl
+		}
+	}
+}
+
+
+void set_relay_sta_async(async_data *data)
+{
+	if(!data)
+		goto failed;
+	board_t *board = get_board();
+	if(board)
+	{
+		if(data->fire_or_zero == _FIRE)
+		{
+			//if(board->md_data.rw_data.rw_d.chn_ctrl[data->channel] != 0)  goto failed;
+			if(data->w_eep_flag == FLAG_W_EEP)
+			{
+				w_eeprom_data_t da = {0};
+				da.lenth =2;
+				memcpy((void*)&da.data,(void*)&data->status,2);
+				da.start_addr = (EEPROM_STATUS_ADDR+(data->channel*2));
+				board->q_cache.en_queue(&da);
+			}
+		}
+		else if(data->fire_or_zero == _ZERO)
+		{
+	#if (ZERO_CONTRL == ZERO_LINE_CTRL_YES)
+			if(data->w_eep_flag == FLAG_W_EEP)
+			{
+				w_eeprom_data_t da = {0};
+				da.lenth =2;
+				memcpy(&da.data,&data->status,2);
+				da.start_addr = (EEPROM_STATUS_ADDR+((data->channel+13)*2));
+				board->q_cache.en_queue(&da);	
+			}			
+	#else
+				goto failed;
+	#endif			
+		}
+		else
+		{
+			goto failed;
+		}
+		SET_RL_STATUS(*data->reg,data->status);
+		if(data->method == DELAY_CTRL)
+		{
+				if(data->status)
+				{
+					SET_RL_ON_DELAY_FLAG(*(data->reg));
+					CLEAR_RL_OFF_DELAY_FLAG(*(data->reg));
+				}else
+				{
+					CLEAR_RL_ON_DELAY_FLAG(*(data->reg));
+					SET_RL_OFF_DELAY_FLAG(*(data->reg));
+				}						
+		}else
+		{
+			if(data->status)
+			{
+				CLEAR_RL_ON_DELAY_FLAG(*(data->reg));
+				CLEAR_RL_OFF_DELAY_FLAG(*(data->reg));
+			}else
+			{
+				CLEAR_RL_ON_DELAY_FLAG(*(data->reg));
+				CLEAR_RL_OFF_DELAY_FLAG(*(data->reg));
+			}						
+		}
+		SET_RL_ORDER_FLAG(*(data->reg));
+	}
+failed:
+	return;
+}
+
+
+
+void set_relay_status_async(uint16_t *reg,uint8_t method,uint16_t status)
+{
+	board_t *board = get_board();
+	SET_RL_STATUS(*reg,status);
+	if(method == DELAY_CTRL)
+	{
+		if(status)
+		{
+			SET_RL_ON_DELAY_FLAG(*reg);
+			CLEAR_RL_OFF_DELAY_FLAG(*reg);
+		}else
+		{
+			CLEAR_RL_ON_DELAY_FLAG(*reg);
+			SET_RL_OFF_DELAY_FLAG(*reg);
+		}
+	}else 
+	{
+		 if(status)
+		 {
+			 CLEAR_RL_ON_DELAY_FLAG(*reg);
+			 CLEAR_RL_OFF_DELAY_FLAG(*reg);
+		 }else
+		 {
+			 CLEAR_RL_ON_DELAY_FLAG(*reg);
+			 CLEAR_RL_OFF_DELAY_FLAG(*reg);
+		 }
+	}
+	SET_RL_ORDER_FLAG(*reg);
+}

truing_control/STS/HARDWARE/common/common.h

@@ -0,0 +1,788 @@
+/*********************************************************************************************************
+* Module   : common
+* Abstract : defined data structure! 
+* Version  : 1.0.0
+* Author   : Leopul(COPYRIGHT 2025 ~ 2027 Leopul. All rights reserved.)
+* Complete : 2025-02-16
+* Content  : None
+* Note     : None
+*********************************************************************************************************/
+
+#ifndef _COMMON_H_
+#define _COMMON_H_
+
+
+#include "stdint.h"
+
+
+
+#define START_R_REGISTER            			4000
+
+#define DEVICE_ID_LEN                     1
+
+#define ELE_DATA                          4011
+#define ELE_DATA_LEN                      (12 * RelaySlaveChaNum)
+
+#define RELAY_STATE                       4209
+#define RELAY_STATE_LEN                   (RelaySlaveChaNum)
+
+#define CHANNEL_ALL_CONSUMER              4250
+#define CHANNEL_ALL_CONSUMER_LEN          (2 * RelaySlaveChaNum)
+
+
+#define DETECTION                         4310
+#define DETECTION_LEN                       1
+
+
+#define INFOMATION                         (4360)
+
+
+
+#define OPEN_DELAY                         (4500)
+#define OPEN_DELAY_LEN                     (RelaySlaveChaNum)
+
+
+#define CLOSE_DELAY                        (4518)
+#define CLOSE_DELAY_LEN                    (RelaySlaveChaNum)
+
+#define SET_STATE                          (4586)
+#define SET_STATE_LEN                      (RelaySlaveChaNum)
+
+#define VALUE_THR                          (4629)
+#define VALUE_THR_LEN                      (RelaySlaveChaNum*2*8)
+
+#define CHANNEL_FUNC                       (5100)
+#define CHANNEL_FUNC_LEN                   (RelaySlaveChaNum)
+
+
+#define CLEAR_CONSUMER                     (5120)
+#define CLEAR_CONSUMER_LEN                 (RelaySlaveChaNum)
+
+#define CLEAR_CONSUMER_ALL                 (5128)
+
+#define SET_PT_KV													(5129)
+#define SET_PT_KV_LEN                     (2)
+
+#define SET_PT_KI                         (5131)
+#define SET_PT_KI_LEN                     (2)
+
+#define TOTAL_THR                           (5200)
+#define TOTAL_THR_LEN                       (16)
+
+#define TOTAL_CHANNEL_FUNC                  (5250)
+
+#define BREAKE_UPGRATE                       (5260)
+
+
+
+
+
+
+
+
+#define START_R_LENTH             				(250)
+
+
+
+#define START_RW_REGISTER         				(START_R_REGISTER + START_R_LENTH)
+
+
+#define START_RW_LENTH            				(350)
+
+
+#define START_W_REGISTER          				(START_RW_REGISTER+START_RW_LENTH)
+
+#define START_W_LENTH             				(100)
+
+
+
+
+//#define 
+
+
+
+#define MAX_CHANNEL              	9
+#define MAX_INPUT_CAHNNEL         3
+#define VERSION_LENTH            	6
+#define DATA_LENTH               	16
+
+
+
+
+
+
+
+
+
+
+#define VOLTAGE_MAX     									(1 << 0)
+#define VOLTAGE_MIN     									(1 << 1)
+#define CURRENT_MAX                       (1 << 2)
+#define POWER_MAX													(1 << 3)
+#define CONSUMER_MAX                      (1 << 4)
+#define FREQ_MAX                          (1 << 5)
+#define FREQ_MIN                          (1 << 6)
+
+
+#define VOLTAGE_MAX_EN     									VOLTAGE_MAX
+#define VOLTAGE_MIN_EN     									VOLTAGE_MIN
+#define CURRENT_MAX_EN                      CURRENT_MAX
+#define POWER_MAX_EN												POWER_MAX
+#define CONSUMER_MAX_EN                     CONSUMER_MAX
+#define FREQ_MAX_EN                         FREQ_MAX
+#define FREQ_MIN_EN                         FREQ_MIN
+
+#define VOL_MAX_OVER_FUNC										VOLTAGE_MAX
+#define VOL_MIN_OVER_FUNC										VOLTAGE_MIN
+#define CUR_MAX_OVER_FUNC                   CURRENT_MAX
+#define POW_MAX_OVER_FUNC                   POWER_MAX
+#define CON_MAX_OVER_FUNC                   CONSUMER_MAX
+#define FREQ_MAX_OVER_FUNC                  FREQ_MAX
+#define FREQ_MIN_OVER_FUNC                  FREQ_MIN
+
+
+
+
+
+#define VOLTAGE_MAX_DIS_EN									(~(VOLTAGE_MAX_EN))
+#define VOLTAGE_MIN_DIS_EN									(~(VOLTAGE_MIN_EN))
+#define CURRENT_MAX_DIS_EN									(~(CURRENT_MAX_EN))
+#define POWER_MAX_DIS_EN                    (~(POWER_MAX_EN))
+#define CONSUMER_MAX_DIS_EN                 (~(CONSUMER_MAX_EN))
+#define FREQ_MAX_DIS_EN                     (~(FREQ_MAX_EN))
+#define FREQ_MIN_DIS_EN                     (~(FREQ_MIN_EN))
+
+
+#define IS_VOLTAGE_MAX_EN(reg)           		((reg) & VOLTAGE_MAX_EN)
+#define IS_VOLTAGE_MIN_EN(reg)           		((reg) & VOLTAGE_MIN_EN)
+#define IS_CURRENT_MAX_EN(reg)           		((reg) & CURRENT_MAX_EN)
+#define IS_POWER_MAX_EN(reg)           			((reg) & POWER_MAX_EN)
+#define IS_CONSUMER_MAX_EN(reg)           	((reg) & CONSUMER_MAX_EN)
+#define IS_FREQ_MAX                       	((reg) & FREQ_MAX_EN)
+#define IS_FREQ_MIN                       	((reg) & FREQ_MIN_EN)
+
+
+#define   SET_VOLTAGE_MAX_EN(reg)        		((reg) |= VOLTAGE_MAX_EN)
+#define   SET_VOLTAGE_MIN_EN(reg)        		((reg) |= VOLTAGE_MIN_EN)
+#define   SET_CURRENT_MAX_EN(reg)        		((reg) |= CURRENT_MAX_EN)
+#define   SET_POWER_MAX_EN(reg)        			((reg) |= POWER_MAX_EN)
+#define   SET_CONSUMER_MAX_EN(reg)        	((reg) |= CONSUMER_MAX_EN)
+#define   SET_FREQ_MAX_EN(reg)        			((reg) |= FREQ_MAX_EN)
+#define   SET_FREQ_MIN_EN(reg)        			((reg) |= FREQ_MIN_EN)
+
+
+#define   UNSET_VOLTAGE_MAX_EN(reg)        	((reg) &= VOLTAGE_MAX_DIS_EN)
+#define   UNSET_VOLTAGE_MIN_EN(reg)        	((reg) &= VOLTAGE_MIN_DIS_EN)
+#define   UNSET_CURRENT_MAX_EN(reg)        	((reg) &= CURRENT_MAX_DIS_EN)
+#define   UNSET_POWER_MAX_EN(reg)        		((reg) &= POWER_MAX_DIS_EN)
+#define   UNSET_CONSUMER_MAX_EN(reg)        ((reg) &= CONSUMER_MAX_DIS_EN)
+#define   UNSET_FREQ_MAX_EN(reg)        		((reg) &= FREQ_MAX_DIS_EN)
+#define   UNSET_FREQ_MIN_EN(reg)        		((reg) &= FREQ_MIN_DIS_EN)
+
+
+#define  SET_WANNING_VOLTAGE_MAX(reg)       ((reg) |= VOLTAGE_MAX)
+#define  SET_WANNING_VOLTAGE_MIN(reg)       ((reg) |= VOLTAGE_MIN)
+#define  SET_WANNING_CURRENT_MAX(reg)       ((reg) |= CURRENT_MAX)
+#define  SET_WANNING_POWER_MAX(reg)         ((reg) |= POWER_MAX)
+#define  SET_WANNING_CONSUMER_MAX(reg)      ((reg) |= CONSUMER_MAX)
+#define  SET_WANNING_FREQ_MAX(reg)       		((reg) |= FREQ_MAX)
+#define  SET_WANNING_FREQ_MIN(reg)       		((reg) |= FREQ_MIN)
+
+
+#define  UNSET_WANNING_VOLTAGE_MAX(reg)       ((reg) &= (~VOLTAGE_MAX))
+#define  UNSET_WANNING_VOLTAGE_MIN(reg)       ((reg) &= (~VOLTAGE_MIN))
+#define  UNSET_WANNING_CURRENT_MAX(reg)       ((reg) &= (~CURRENT_MAX))
+#define  UNSET_WANNING_POWER_MAX(reg)         ((reg) &= (~POWER_MAX))
+#define  UNSET_WANNING_CONSUMER_MAX(reg)      ((reg) &= (~CONSUMER_MAX))
+#define  UNSET_WANNING_FREQ_MAX(reg)       		((reg) &= (~FREQ_MAX))
+#define  UNSET_WANNING_FREQ_MIN(reg)       		((reg) &= (~FREQ_MIN))
+
+
+
+
+
+#define  IS_OVERFUNC_VOLTAGE_MAX(reg)       ((reg) & VOL_MAX_OVER_FUNC)
+#define  IS_OVERFUNC_VOLTAGE_MIN(reg)				((reg) & VOL_MIN_OVER_FUNC)
+#define  IS_OVERFUNC_CURRENT_MAX(reg)				((reg) & CUR_MAX_OVER_FUNC)	
+#define  IS_OVERFUNC_POWER_MAX(reg)					((reg) & POW_MAX_OVER_FUNC)	
+#define  IS_OVERFUNC_CONSUMER_MAX(reg)      ((reg) & CON_MAX_OVER_FUNC) 
+#define  IS_OVERFUNC_FREQ_MAX(reg)          ((reg) & FREQ_MAX_OVER_FUNC) 
+#define  IS_OVERFUNC_FREQ_MIN(reg)    			((reg) & FREQ_MIN_OVER_FUNC)
+
+
+
+// EEPROM 
+#define EEPROM_RELAY_STARTUS_ADDR          		(0)
+#define EEPROM_RELAY_BYTES                		(2)
+#define EEPROM_RELAY_COUNT_MAX            		(64)         /* 2 page */
+
+#define EEPROM_DELAY_ADDR                     (64)
+#define EEPROM_DELAY_BYTES                		(2)
+#define EEPROM_DELAY_COUNT_MAX                (64)				 /* 2 page */
+
+
+#define EEPROM_THRESHOLD_INPUT_ADDR           (128)
+#define EEPROM_THRESHOLD_INPUT_BYTES          (4)
+#define EEPROM_THRESHOLD_INPUT_MAX            (64)					/* 2 page */
+
+#define EEPROM_THRESHOLD_OUTPUT_ADDR          (192)
+#define EEPROM_THRESHOLD_OUTPUT_BYTES         (4)
+#define EEPROM_THRESHOLD_OUTPUT_MAX           (256)         /* 8 page */
+
+#define EEPROM_INPUT_OVER_FUNC_ADDR           (448)
+#define EEPROM_INPUT_OVER_FUNC_BYTES          (2)
+#define EEPROM_INPUT_OVER_FUNC_MAX            (32)					/* 1 page */
+
+
+#define EEPROM_OUTPUT_OVER_FUNC_ADDR          (480)      
+#define EEPROM_OUTPUT_OVER_FUNC_BYTES         (2)
+#define EEPROM_OUTPUT_OVER_FUNC_MAX           (32)          /* 1 page */
+
+
+
+
+
+#define EEPROM_DEVICES_ADDR                   (0)				//device signal
+#define EEPROM_DEVICES_LENTH                  (2)
+
+
+
+#define EEPROM_STATUS_ADDR                    (64)			// one page
+#define EEPROM_STATUS_LENTH                   (16*2)
+
+
+
+#define EEPROM_OTHER_ADDR                     (128)
+#define EEPROM_OTHER_LENTH                    (32*30)   // 30 page    
+
+
+#define EEPROM_CHANNEL_PHASE                  (2048)
+#define EEPROM_CHANNEL_LENTH                  (9)
+
+
+//#define EEPROM_CHN_CTRL                       (2080)
+//#define EEPROM_CHN_CTRL_LENTH                 (32)     //one page
+
+#define CONSUM_PAGE                           (64)
+#define MAX_ROW                               (40)
+
+#define EEPROM_CONSUMER_ADDR                  (3072)
+#define EEPROM_CONSUMER_ADDR_LEN              (CONSUM_PAGE*MAX_ROW)
+
+#define EEPROM_K_V_ADDR                        (6144)
+#define EEPROM_K_V_LEN                         (4)
+
+#define EEPROM_K_I_ADDR												 (6176)
+#define EEPROM_K_I_LEN                         (4)
+
+
+
+
+
+
+#define THRESHOLD_IN             							0
+#define THRESHOLD_OUT            							1
+
+
+#define ELE_INPUT                             0
+#define ELE_OUTPUT                            1
+
+#define AC3PPDU_Lack_Voltage			(30000)
+
+
+#define Default_Consum_Max   (4000000000)
+#define Default_Voltage_Max  (1000000000)
+#define Default_Current_Max  (1000000000)
+#define Default_Power_Max		 (1000000000)
+
+#define THRESHOULD_JUDGMENT    		(50)
+
+
+
+
+
+/* relay controller */
+#define RL_STATUS                             (1 << 0)
+#define RL_COUNTER_END_FLAG            				(1 << 1)
+#define RL_COUNTER_BEGIN_FLAG         				(1 << 2)
+#define RL_ORDER_FLAG                  				(1 << 3)
+#define RL_ON_FLAG                     				(1 << 4)
+#define RL_OFF_FLAG                    				(1 << 5)
+#define RL_ON_DELAY_FLAG               				(1 << 6)
+#define RL_OFF_DELAY_FLAG              				(1 << 7)
+
+#define GET_RL_STATUS(reg)                       (reg & (RL_STATUS))    
+#define IS_RL_ORDER_FLAG_EN(reg)  						   (reg & RL_ORDER_FLAG)
+#define IS_RL_COUNTER_END_FLAG_EN(reg)					 (reg & RL_COUNTER_END_FLAG)
+#define IS_RL_COUNTER_BEGINE_FLAG_EN(reg)        (reg & RL_COUNTER_BEGIN_FLAG)
+#define IS_RL_ON_FLAG_EN(reg) 									 (reg & RL_ON_FLAG)
+#define IS_RL_OFF_FLAG_EN(reg) 									 (reg & RL_OFF_FLAG)
+#define IS_RL_ON_DELAY_FLAG_EN(reg) 						 (reg & RL_ON_DELAY_FLAG)
+#define IS_RL_OFF_DELAY_FLAG_EN(reg) 						 (reg & RL_OFF_DELAY_FLAG)
+
+
+#define SET_RL_STATUS(reg,value)                  ((reg) = ((value) ? ((reg) | 1) : ((reg) & (~1))))
+
+#define SET_RL_ORDER_FLAG(reg)                   (reg |= RL_ORDER_FLAG)
+#define SET_RL_COUNTER_END_FLAG(reg)             (reg |= RL_COUNTER_END_FLAG)
+#define SET_RL_COUNTER_BEGIN_FLAG(reg)          (reg |= RL_COUNTER_BEGIN_FLAG )
+#define SET_RL_ON_FLAG(reg)                      (reg |= RL_ON_FLAG)
+#define SET_RL_OFF_FLAG(reg)                     (reg |= RL_OFF_FLAG)
+#define SET_RL_ON_DELAY_FLAG(reg)                (reg |= RL_ON_DELAY_FLAG)
+#define SET_RL_OFF_DELAY_FLAG(reg)               (reg |= RL_OFF_DELAY_FLAG)
+
+
+#define CLEAR_RL_ORDER_FLAG(reg)                     (reg &= (~(RL_ORDER_FLAG)))
+#define CLEAR_RL_COUNTER_END_FLAG(reg)               (reg &= (~(RL_COUNTER_END_FLAG)))
+#define CLEAR_RL_COUNTER_BEGIN_FLAG(reg)            (reg &= (~(RL_COUNTER_BEGIN_FLAG)))
+#define CLEAR_RL_ON_FLAG(reg)                        (reg &= (~(RL_ON_FLAG)))
+#define CLEAR_RL_OFF_FLAG(reg)                       (reg &= (~(RL_OFF_FLAG)))
+#define CLEAR_RL_ON_DELAY_FLAG(reg)                  (reg &= (~(RL_ON_DELAY_FLAG)))
+#define CLEAR_RL_OFF_DELAY_FLAG(reg)                 (reg &= (~(RL_OFF_DELAY_FLAG))) 
+
+
+
+enum{
+	DELAY_CTRL = 0,
+	PROMPT_CTRL,
+};
+enum{
+	STM32_ADC_V_1 = 0,
+	STM32_ADC_V_2,
+};
+
+
+#pragma pack (2)
+typedef struct {
+	uint32_t uniq_3;
+	uint32_t uniq_2;
+	uint32_t uniq_1;
+	uint32_t dev_chn;
+	uint16_t version[6];
+	uint16_t date[16];
+	uint64_t keep_running_time;    
+}board_info_t;
+
+
+typedef struct {
+	uint32_t voltage;
+	uint32_t current;
+	uint32_t power;
+	uint32_t freq;
+	uint32_t consumer;
+	uint32_t factor;
+}old_ele_info_t;
+
+typedef struct	
+{
+	uint16_t    	state						:1;       	 
+	uint16_t 			v_top_en				:1;             
+	uint16_t 			v_top_wanning		:1;           
+	uint16_t 			v_down_en				:1;           
+	uint16_t 			v_down_wanning  :1;         
+	uint16_t 			c_top_en        :1;             
+	uint16_t 			c_top_wanning   :1;           
+	uint16_t 			p_top_en        :1;             
+	uint16_t 			p_top_wanning   :1;           
+	uint16_t 			e_top_en				:1;             
+	uint16_t 			e_top_wanning   :1;
+	uint16_t    									:5;
+}old_state_t; 
+
+
+typedef uint32_t old_consumer_t;
+
+
+typedef struct {
+	old_ele_info_t ele_info[8];
+}ac_ele_t;
+
+typedef struct {
+	old_state_t state[8];
+}ac_state_t;
+
+
+typedef struct {
+	old_consumer_t consumer[8];
+}ac_consumer_t;
+
+
+typedef uint32_t ac_total_consumer_t;
+
+typedef struct{
+	uint16_t          i_max_func    :      1;
+	uint16_t          v_max_func    :      1;
+	uint16_t          v_min_func    :      1;
+	uint16_t          p_max_func    :      1;
+	uint16_t          c_max_func    :      1;
+	uint16_t                        :      3;
+}ac_over_func_t;
+
+
+
+
+
+
+typedef struct{
+	uint16_t         total_v_wanning_max     :   1;
+	uint16_t         total_v_wanning_min     :   1;
+	uint16_t         total_i_wanning_max     :   1;
+	uint16_t         total_p_waning_max      :   1;
+	uint16_t         total_c_waning_max      :   1;
+	uint16_t                        			:      3;
+}total_waning_t;
+
+
+
+
+typedef struct {
+		uint32_t uniq_ID_64_95;
+		uint32_t uniq_ID_32_63;
+		uint32_t uniq_ID_00_31;
+    int  channels;
+		char ver[12];
+    char date[32];
+		uint64_t  runing_time;
+}ac_information_t;
+
+
+
+
+
+typedef struct {
+	uint16_t delay_open[8];
+}ac_delay_open_t;
+
+typedef struct {
+	uint16_t delay_close[8];
+}ac_delay_close_t;
+
+
+
+typedef struct {
+	uint32_t v_top;
+	uint32_t v_down;
+	uint32_t i_top;
+	uint32_t i_down;
+	uint32_t p_top;
+	uint32_t p_down;
+	uint32_t e_top;
+	uint32_t e_down;
+}thr_t;
+
+
+
+typedef struct {
+	thr_t  th[8];
+}ac_thr_t;
+
+typedef  thr_t all_thr_t;
+//typedef  uint16_t  all_over_func_t; 
+
+
+
+
+
+
+typedef struct {
+	uint16_t 						     dev_chn;
+	ac_ele_t  						    ac_ele;
+	ac_state_t  					     state;
+	ac_consumer_t 			    consumer;
+	uint32_t          total_sonsumer;
+	uint16_t      		 		 detection;
+	total_waning_t     total_wanning;
+	ac_information_t            info;
+}ac_r_data_t;
+
+
+
+
+
+typedef struct{
+	ac_delay_open_t 				open;
+	ac_delay_close_t  		 close;
+	ac_thr_t                 thr;
+	all_thr_t          totol_thr;
+	ac_over_func_t     over_func[8];
+}ac_rw_data_t;
+
+
+
+
+
+
+typedef struct {
+	uint32_t voltage;
+	uint32_t current;
+	uint32_t power;
+	uint32_t consumer;
+	uint16_t freq;
+	uint16_t factor;
+	uint16_t wanning;
+	uint16_t resever;
+}elect_info_t;
+
+
+
+
+
+
+
+
+typedef struct{
+	elect_info_t info[3];
+}elect_3_info_t;
+
+
+typedef struct {
+	uint16_t delay_open;
+	uint16_t delay_close;
+}delay_t;
+
+typedef struct{
+	uint32_t th_voltage_max;
+	uint32_t th_voltage_min;
+	uint32_t th_current_max;
+	uint32_t th_power_max;
+	uint32_t th_consumer_max;
+	uint32_t reserve1;
+	uint32_t reserve2;
+}threshold_t;
+
+
+
+typedef struct {
+	uint16_t 						dev_chn;
+	board_info_t				b_info;
+	elect_3_info_t      ele_3_in;
+	elect_info_t        ele_out[MAX_CHANNEL];
+	uint16_t            detection;
+	uint16_t            wanning_lock_L1;
+	uint16_t            wanning_lock_L2;
+	uint16_t            wanning_lock_L3; 
+}r_data_t;
+
+
+
+
+typedef struct {
+	uint16_t            relay_status[MAX_CHANNEL];
+	uint16_t            combin_relay_status[4];
+	uint16_t            zero_relay_status[3];
+	delay_t             delay_chn[MAX_CHANNEL];
+  delay_t             combin_chn[4];
+	delay_t             zero_chn[3];
+	threshold_t         th_in[MAX_INPUT_CAHNNEL];
+	threshold_t         th_out[MAX_CHANNEL];
+	threshold_t         th_combin_out[4];
+	uint16_t            over_fun_in[3];
+	uint16_t            over_func_out[MAX_CHANNEL];
+	uint16_t            combin_over_func[4];
+	uint16_t            chn_ctrl[MAX_CHANNEL];
+	#define            	CTRL_YES    			0
+	#define             CTRL_HARD_OPEN    1
+	#define             CTRL_HARD_CLOSE   2
+}rw_data_t;
+
+
+typedef union{
+	uint16_t data[START_R_LENTH];
+	r_data_t r_d;
+}mod_bus_r;
+
+typedef union{
+	uint16_t 	data[START_RW_LENTH];
+	rw_data_t rw_d;
+}mod_bus_rw;
+
+typedef struct {
+	//mod_bus_r r_data;
+	//mod_bus_rw rw_data;
+	ac_r_data_t  	 r_data;
+	ac_rw_data_t  rw_data;
+}mod_data_t;
+
+
+typedef struct {
+	uint32_t iic_consumer[MAX_CHANNEL];
+	uint64_t recode_index1;
+}iic_consumer_chache_t;
+
+typedef union{
+	uint8_t  data[64];
+	iic_consumer_chache_t iic_con;
+}iic_data;
+
+typedef union{
+	uint8_t 	data[4];
+	uint32_t     value;
+}Rx_Data;
+
+
+
+#pragma pack ()
+
+typedef struct{
+	iic_data   iic_da;
+	uint64_t   index;
+	uint16_t   row;
+}consumer_data;
+
+
+typedef struct {
+	uint8_t flag;
+	uint16_t start_addr;
+	uint16_t lenth;
+	uint8_t  data[72];
+}eeprom_write_cache_t;
+
+
+typedef struct {
+	uint16_t start_addr;
+	uint16_t lenth;
+	uint8_t  data[36];
+}w_eeprom_data_t;
+
+
+typedef struct {
+#define QUEUE_MAX     25
+	uint8_t  front;
+	uint8_t  rear;
+	w_eeprom_data_t data[QUEUE_MAX];
+	uint8_t (*is_empty)(void);
+	uint8_t (*is_full)(void);
+	uint8_t (*en_queue)(w_eeprom_data_t *d);
+	uint8_t (*de_queue)(w_eeprom_data_t *d);
+}queue_t;
+
+
+typedef struct {
+	uint8_t fire_or_zero;
+#define _FIRE   0
+#define _ZERO   1
+	uint8_t channel;
+	uint16_t *reg;
+	uint8_t method;
+	uint16_t status;
+	uint8_t  w_eep_flag;
+#define FLAG_N_W_EEP 0
+#define FLAG_W_EEP   1
+}async_data;
+
+
+
+
+
+
+
+
+
+
+
+typedef struct {
+	mod_data_t md_data;
+	uint8_t 	flag_1s;
+	uint8_t	  flag_10s;
+	uint8_t   flag_100ms;
+	uint8_t   clear_flag; 															/* erase consumer and all successful this flag is 0 */
+	uint8_t   out_wanning_en[8];
+	uint8_t   in_wanning_en[MAX_INPUT_CAHNNEL];
+	uint8_t   in_over_func[3];
+	uint8_t   over_func[MAX_CHANNEL];
+	uint16_t  relay_staging_staus[MAX_CHANNEL];
+	//uint16_t  relay_combin_staging_status[4];
+	//uint16_t  relay_zero_staging_status[3];
+	uint16_t  relay_limit_counter[MAX_CHANNEL];
+	//uint16_t  relay_zero_limit_counter[3];
+	consumer_data con_da;
+	uint32_t ele_restore[MAX_CHANNEL];
+	uint16_t    v_k[2];
+	uint16_t    i_k[2];
+	uint8_t   haddr;
+	uint8_t   detection_1_value;
+	uint32_t  detection_1_count;
+	uint32_t  timer_count;
+	queue_t    q_cache;
+#if SURPPORT_2_PT
+	uint8_t   detection_2_value;
+	uint32_t  detection_2_count;
+#endif
+#if SUPPORT_SELF_LOCK
+//	#if (RelaySlaveChaNum >= 1)
+//		uint8_t 			handle_k_1_status;
+//		uint8_t  			key_1;
+//	#endif
+//	#if (RelaySlaveChaNum >= 2)
+//		uint8_t 			handle_k_2_status;
+//		uint8_t 			key_2;
+//	#endif
+//	#if (RelaySlaveChaNum >= 3)	
+//		uint8_t 			handle_k_3_status;
+//		uint8_t 			key_3;
+//	#endif
+//	#if (RelaySlaveChaNum >= 4)
+//		uint8_t 			handle_k_4_status;
+//		uint8_t 			key_4;
+//	#endif
+	uint8_t  				handle_k_status[4];
+	uint8_t         val_key[4];  
+#endif
+	
+#if SUPPORT_RELAY_REMENBER
+	uint8_t handle_status[MAX_CHANNEL];  						/* Save the state before the power failure  */
+	#if SURPPORT_2_PT
+		uint8_t  handle_input_pt[2];										/* recode input status  */
+	#else
+		uint8_t  handle_input_pt[1];
+	#endif
+#endif
+
+#if SUPPORT_SELF_LOCK
+//	#if (RelaySlaveChaNum >= 1)
+//		void (*read_key_1)();
+//	#endif
+//	#if (RelaySlaveChaNum >= 2)
+//		void (*read_key_2)();
+//	#endif
+//	#if (RelaySlaveChaNum >= 3)	
+//	void (*read_key_3)();
+//	#endif
+//	#if (RelaySlaveChaNum >= 4)
+//	void (*read_key_4)();
+//	#endif
+	void (*get_lock_key)();
+	void (*opt_lock_key)();
+#endif
+
+	void (*open)(uint8_t channel);
+	void (*close)(uint8_t channel);
+	void (*read_ele)(uint8_t channel);
+	void (*led_flash)(void);
+	void (*read_eeprom)(uint16_t addr,uint8_t *r_buff,uint16_t lenth);
+	void (*write_eeprom)(uint16_t addr,uint8_t *w_buff,uint16_t lenth);
+	void (*check_wanning)(uint8_t in_out, uint8_t channel);
+	void (*detection)(void);
+	void (*opt_detection)(void);
+	void (*erase_consumer)(void);
+	void (*opt_overfunc)(uint8_t channel);
+	void (*opt_alloverfunc)(uint8_t input);
+	void (*break_uboot)(void);
+	void (*feed_dog)(void);
+	void (*lock)(void);
+	void (*unlock)(void);
+	void (*check_threshold)(uint8_t in_out,uint8_t channel);
+	void (*relay_sync)(void);
+	void (*read_eeprom_page)(uint16_t addr,uint8_t *r_buff,uint16_t lenth);
+	void (*write_eeprom_page)(uint16_t addr,uint8_t *r_buff,uint16_t lenth);
+	void (*tog)(uint8_t channel);
+}board_t;
+
+
+board_t *get_board(void);
+void set_relay_status_async(uint16_t *reg,uint8_t method,uint16_t status);
+void read_config_from_eeprom(void);
+void reset_config_for_eeprom(void);
+void set_relay_sta_async(async_data *data);
+#endif
+

truing_control/STS/MODBUS/BARE/port/port.c

@@ -186,12 +186,12 @@ eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegi
 								memcpy(&recive,&usRegHoldBuf[WiRegIndex],WusNRegs*2);
 								if(recive == 1)
 								{
-									t_data->write_at24(IIC_OUT_CHANNEL,&recive,sizeof(recive));
+									t_data->write_eeprom_page(IIC_OUT_CHANNEL,&recive,sizeof(recive));
 									t_data->open_output();
 								}else if(recive == 0)
 								{
 									t_data->close_output();
-									t_data->write_at24(IIC_OUT_CHANNEL,&recive,sizeof(recive));
+									t_data->write_eeprom_page(IIC_OUT_CHANNEL,&recive,sizeof(recive));
 								}else
 								{
 									eStatus = MB_ENOREG;
@@ -211,9 +211,9 @@ eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegi
 							}else if(usAddress >= STS_INPUT_THRESHOLD && usAddress < STS_OUTPUT_THRESHOLD)
 							{
 								WeeiRegIndex = (uint16_t)(usAddress - STS_INPUT_THRESHOLD);
-								uint16_t *p_start = &(data->input_th[0].voltage_max);
+								uint16_t *p_start = (uint16_t *)&(data->input_th[0].voltage_max);
 								memcpy(p_start+WeeiRegIndex,&usRegHoldBuf[WiRegIndex],WusNRegs*2);
-								t_data->write_at24(IIC_INPUT_THRESHOLD_START+(WeeiRegIndex*2),&usRegHoldBuf[WiRegIndex],WusNRegs*2);
+								t_data->write_eeprom_page(IIC_INPUT_THRESHOLD_START+(WeeiRegIndex*2),&usRegHoldBuf[WiRegIndex],WusNRegs*2);
 								for(int i =0 ; i < 2; i++) {
 									if(data->input_th[i].voltage_max <= SMALL_VALUE)
 										UNSET_VOLTAGE_MAX_EN(t_data->input_wanning_en[i]);
@@ -238,9 +238,10 @@ eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegi
 							}else if(usAddress >= STS_OUTPUT_THRESHOLD  && usAddress < STS_TEMP_THRESHOLD)
 							{
 								WeeiRegIndex = (uint16_t)(usAddress - STS_OUTPUT_THRESHOLD);
-								uint16_t *p_start = &data->output_th;
+								uint16_t *p_start = (uint16_t *)&data->output_th.voltage_max;
 								memcpy(p_start+WeeiRegIndex,&usRegHoldBuf[WiRegIndex],WusNRegs*2);
-								t_data->write_at24(IIC_OUTPUT_THRESHOLD_START+(WeeiRegIndex*2),&usRegHoldBuf[WiRegIndex],WusNRegs*2);
+								t_data->write_eeprom_page(IIC_OUTPUT_THRESHOLD_START+(WeeiRegIndex*2),&usRegHoldBuf[WiRegIndex],WusNRegs*2);
+								
 								if(data->output_th.voltage_max <= SMALL_VALUE)
 									UNSET_VOLTAGE_MAX_EN(t_data ->output_wanning_en);
 								else
@@ -269,9 +270,9 @@ eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegi
 							}else if(usAddress >= STS_TEMP_THRESHOLD && usAddress < STS_OVER_FUNC)
 							{
 								WeeiRegIndex = (uint16_t)(usAddress - STS_TEMP_THRESHOLD);
-								uint16_t *p_start = &data->temprature_th;
+								uint16_t *p_start = &data->temprature_th.fans_max_temp;
 								memcpy(p_start+WeeiRegIndex,&usRegHoldBuf[WiRegIndex],WusNRegs*2);
-								t_data->write_at24(IIC_TEMPRATURE_THRESHOLD_START+(WeeiRegIndex*2),&usRegHoldBuf[WiRegIndex],WusNRegs*2);
+								t_data->write_eeprom_page(IIC_TEMPRATURE_THRESHOLD_START+(WeeiRegIndex*2),&usRegHoldBuf[WiRegIndex],WusNRegs*2);
 							}else if(usAddress == STS_OVER_FUNC)
 							{
 								uint16_t recive = 0;
@@ -281,9 +282,24 @@ eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegi
 								}else{
 									memcpy(&recive,&usRegHoldBuf[WiRegIndex],WusNRegs*2);
 									t_data->m_data.over_func = recive;
-									t_data->write_at24(IIC_OVER_FUNC_START,&recive,sizeof(recive));
+									t_data->write_eeprom_page(IIC_OVER_FUNC_START,&recive,sizeof(recive));
 								}
-							}else
+							}else if(usAddress >= STS_V_I_K && usAddress < STS_CLEAR_CONSUMER)
+							{
+								uint16_t *p_start = &data->input_v_k[0];
+								memcpy(p_start+WeeiRegIndex,&usRegHoldBuf[WiRegIndex],WusNRegs*2);
+								t_data->write_eeprom_page(IIC_K_START+(WeeiRegIndex*2),&usRegHoldBuf[WiRegIndex],WusNRegs*2);
+							}else if(usAddress == STS_CLEAR_CONSUMER)
+							{
+								t_data->iic_consumer = 0;
+							}else if(usAddress ==  STS_CLEAR_BEEP)
+							{
+								t_data->beep_flag = 0;
+								t_data->i_beep_flag[0].beep_waning = 0;
+								t_data->i_beep_flag[1].beep_waning = 0;
+								t_data->o_beep_flag.beep_waning = 0;
+							}
+							else
 							{
 								eStatus = MB_ENOREG;
 							}

truing_control/STS/MODBUS/BARE/port/portserial.c

@@ -36,6 +36,16 @@ vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
     /* If xRXEnable enable serial receive interrupts. If xTxENable enable
      * transmitter empty interrupts.
      */
+		if(FALSE == xRxEnable && xTxEnable == FALSE)
+		{
+			usart_interrupt_disable(USART0,USART_INT_RBNE);
+			usart_interrupt_disable(USART0,USART_INT_TC);
+			usart_disable(USART0);
+			nvic_irq_disable(USART0_IRQn); 
+			gpio_bit_reset(GPIOA, GPIO_PIN_8);
+			return;
+		}
+	
 	  if(TRUE == xRxEnable)
     {
         usart_interrupt_enable(USART0,USART_INT_RBNE);//使能接收中断
@@ -47,16 +57,6 @@ vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
 				gpio_bit_set(GPIOA, GPIO_PIN_8);							 //恢复发送
     }
     
-//    if(TRUE == xTxEnable)
-//    {	
-//        usart_interrupt_enable(USART0,USART_INT_TBE);	//使能发送中断
-//				gpio_bit_set(GPIOA, GPIO_PIN_11);            	//发送
-//    }
-//    else
-//    {
-//        usart_interrupt_disable(USART0,USART_INT_TBE);	//失能发送为空中断
-//				usart_interrupt_enable(USART0,USART_INT_TC);		//使能发送完成中断
-//    }
 		if(TRUE == xTxEnable)
     {	
         usart_interrupt_enable(USART0,USART_INT_TC);	//使能发送中断

truing_control/STS/MODBUS/include/mb.h

@@ -409,6 +409,10 @@ eMBErrorCode    eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress,
  */
 eMBErrorCode    eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress,
                                   USHORT usNDiscrete );
+																	
+																	
+																	
+uint8_t eMBCheck(void);
 
 #ifdef __cplusplus
 PR_END_EXTERN_C

truing_control/STS/MODBUS/include/mbconfig.h

@@ -46,7 +46,7 @@ PR_BEGIN_EXTERN_C
  *  @{
  */
 /*! \brief If Modbus ASCII support is enabled. */
-#define MB_ASCII_ENABLED                        (  1 )
+#define MB_ASCII_ENABLED                        (  0 )
 
 /*! \brief If Modbus RTU support is enabled. */
 #define MB_RTU_ENABLED                          (  1 )

truing_control/STS/MODBUS/mb.c

@@ -313,6 +313,7 @@ eMBDisable( void )
     if( eMBState == STATE_ENABLED )
     {
         pvMBFrameStopCur(  );
+
         eMBState = STATE_DISABLED;
         eStatus = MB_ENOERR;
     }
@@ -327,6 +328,20 @@ eMBDisable( void )
     return eStatus;
 }
 
+
+uint8_t eMBCheck(void)
+{
+	if( eMBState != STATE_ENABLED)
+	{
+		return 1;
+	}else
+	{
+		return 0;
+	}
+}
+
+
+
 eMBErrorCode
 eMBPoll( void )
 {

truing_control/STS/MODBUS/rtu/mbrtu.c

@@ -44,7 +44,7 @@
 
 /* ----------------------- Defines ------------------------------------------*/
 #define MB_SER_PDU_SIZE_MIN     4       /*!< Minimum size of a Modbus RTU frame. */
-#define MB_SER_PDU_SIZE_MAX     1024     /*!< Maximum size of a Modbus RTU frame. */
+#define MB_SER_PDU_SIZE_MAX     256     /*!< Maximum size of a Modbus RTU frame. */
 #define MB_SER_PDU_SIZE_CRC     2       /*!< Size of CRC field in PDU. */
 #define MB_SER_PDU_ADDR_OFF     0       /*!< Offset of slave address in Ser-PDU. */
 #define MB_SER_PDU_PDU_OFF      1       /*!< Offset of Modbus-PDU in Ser-PDU. */
@@ -110,6 +110,7 @@ eMBRTUInit( UCHAR ucSlaveAddress, UCHAR ucPort, ULONG ulBaudRate, eMBParity ePar
              * for t3.5.
              */
             usTimerT35_50us = ( 7UL * 220000UL ) / ( 2UL * ulBaudRate );
+					//usTimerT35_50us +=2;
         }
         if( xMBPortTimersInit( ( USHORT ) usTimerT35_50us ) != TRUE )
         {
@@ -153,8 +154,14 @@ eMBRTUReceive( UCHAR * pucRcvAddress, UCHAR ** pucFrame, USHORT * pusLength )
     eMBErrorCode    eStatus = MB_ENOERR;
 
     ENTER_CRITICAL_SECTION(  );
-    assert( usRcvBufferPos < MB_SER_PDU_SIZE_MAX );
-
+		
+    //assert( usRcvBufferPos < MB_SER_PDU_SIZE_MAX );
+		if(usRcvBufferPos >= MB_SER_PDU_SIZE_MAX)
+		{
+			eMBDisable();
+			EXIT_CRITICAL_SECTION(  );
+			return eStatus;
+		}
     /* Length and CRC check */
     if( ( usRcvBufferPos >= MB_SER_PDU_SIZE_MIN )
         && ( usMBCRC16( ( UCHAR * ) ucRTUBuf, usRcvBufferPos ) == 0 ) )
@@ -237,7 +244,14 @@ xMBRTUReceiveFSM( void )
     BOOL            xTaskNeedSwitch = FALSE;
     UCHAR           ucByte;
 
-    assert( eSndState == STATE_TX_IDLE );
+    //assert( eSndState == STATE_TX_IDLE );
+//		if(eSndState != STATE_TX_IDLE)
+//		{
+//			eMBDisable();
+//			eSndState = STATE_TX_IDLE;
+//			xMBPortSerialGetByte( ( CHAR * ) & ucByte );
+//			return xTaskNeedSwitch;
+//		}
 
     /* Always read the character. */
     ( void )xMBPortSerialGetByte( ( CHAR * ) & ucByte );
@@ -296,8 +310,19 @@ xMBRTUTransmitFSM( void )
 {
     BOOL            xNeedPoll = FALSE;
 
-    assert( eRcvState == STATE_RX_IDLE );
-
+    //assert( eRcvState == STATE_RX_IDLE );
+//		if(eRcvState != STATE_RX_IDLE)
+//		{
+//			eMBDisable();
+//			eRcvState = STATE_RX_IDLE;
+//			return xNeedPoll;
+//		}
+//		if(eRcvState != STATE_RX_IDLE)
+//		{
+//			eMBDisable();
+//			eMBRTUStart();
+//			return xNeedPoll;
+//		}
     switch ( eSndState )
     {
         /* We should not get a transmitter event if the transmitter is in
@@ -317,11 +342,13 @@ xMBRTUTransmitFSM( void )
         }
         else
         {
+						
             xNeedPoll = xMBPortEventPost( EV_FRAME_SENT );
             /* Disable transmitter. This prevents another transmit buffer
              * empty interrupt. */
+						eSndState = STATE_TX_IDLE;
             vMBPortSerialEnable( TRUE, FALSE );
-            eSndState = STATE_TX_IDLE;
+            //eSndState = STATE_TX_IDLE;
         }
         break;
     }
@@ -353,8 +380,13 @@ xMBRTUTimerT35Expired( void )
 
         /* Function called in an illegal state. */
     default:
-        assert( ( eRcvState == STATE_RX_INIT ) ||
-                ( eRcvState == STATE_RX_RCV ) || ( eRcvState == STATE_RX_ERROR ) );
+			{
+//				eMBDisable();
+//				eRcvState = STATE_RX_IDLE;
+//				return xNeedPoll;
+				//  assert( ( eRcvState == STATE_RX_INIT ) ||
+				//          ( eRcvState == STATE_RX_RCV ) || ( eRcvState == STATE_RX_ERROR ) );
+			}
     }
 
     vMBPortTimersDisable(  );

truing_control/STS/PRJ/sts.uvoptx

@@ -119,18 +119,18 @@
       <TargetDriverDllRegistry>
         <SetRegEntry>
           <Number>0</Number>
-          <Key>ARMRTXEVENTFLAGS</Key>
-          <Name>-L70 -Z18 -C0 -M0 -T1</Name>
+          <Key>UL2CM3</Key>
+          <Name>UL2CM3(-S0 -C0 -P0 ) -FN1 -FC1000 -FD20000000 -FF0GD32F30x_HD -FL040000 -FS08000000 -FP0($$Device:GD32F303VC$Flash\GD32F30x_HD.FLM)</Name>
         </SetRegEntry>
         <SetRegEntry>
           <Number>0</Number>
-          <Key>UL2CM3</Key>
-          <Name>UL2CM3(-S0 -C0 -P0 -FD20000000 -FC1000 -FN1 -FF0GD32F30x_HD -FS08000000 -FL040000 -FP0($$Device:GD32F303RC$Flash\GD32F30x_HD.FLM))</Name>
+          <Key>JL2CM3</Key>
+          <Name>-U69545264 -O78 -S5 -ZTIFSpeedSel1000 -A0 -C0 -JU1 -JI127.0.0.1 -JP0 -RST0 -N00("ARM CoreSight SW-DP") -D00(2BA01477) -L00(0) -TO18 -TC10000000 -TP21 -TDS8001 -TDT0 -TDC1F -TIEFFFFFFFF -TIP8 -TB1 -TFE0 -FO15 -FD20000000 -FC1000 -FN1 -FF0GD32F30x_HD.FLM -FS08000000 -FL080000 -FP0($$Device:GD32F303VC$Flash\GD32F30x_HD.FLM)</Name>
         </SetRegEntry>
         <SetRegEntry>
           <Number>0</Number>
-          <Key>JL2CM3</Key>
-          <Name>-U69545260 -O78 -S5 -ZTIFSpeedSel1000 -A0 -C0 -JU1 -JI127.0.0.1 -JP0 -RST0 -N00("ARM CoreSight SW-DP") -D00(2BA01477) -L00(0) -TO18 -TC10000000 -TP21 -TDS8001 -TDT0 -TDC1F -TIEFFFFFFFF -TIP8 -TB1 -TFE0 -FO15 -FD20000000 -FC1000 -FN1 -FF0GD32F30x_HD.FLM -FS08000000 -FL080000 -FP0($$Device:GD32F303RC$Flash\GD32F30x_HD.FLM)</Name>
+          <Key>ARMRTXEVENTFLAGS</Key>
+          <Name>-L70 -Z18 -C0 -M0 -T1</Name>
         </SetRegEntry>
         <SetRegEntry>
           <Number>0</Number>
@@ -142,11 +142,6 @@
           <Key>ARMDBGFLAGS</Key>
           <Name></Name>
         </SetRegEntry>
-        <SetRegEntry>
-          <Number>0</Number>
-          <Key>DLGUARM</Key>
-          <Name>€(??</Name>
-        </SetRegEntry>
       </TargetDriverDllRegistry>
       <Breakpoint/>
       <WatchWindow1>
@@ -185,6 +180,76 @@
           <WinNumber>1</WinNumber>
           <ItemText>read_ele_count</ItemText>
         </Ww>
+        <Ww>
+          <count>7</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>sts_data</ItemText>
+        </Ww>
+        <Ww>
+          <count>8</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>up_2_flag</ItemText>
+        </Ww>
+        <Ww>
+          <count>9</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>down_1_flag</ItemText>
+        </Ww>
+        <Ww>
+          <count>10</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>down_2_flag</ItemText>
+        </Ww>
+        <Ww>
+          <count>11</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>up_1_flag</ItemText>
+        </Ww>
+        <Ww>
+          <count>12</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>data</ItemText>
+        </Ww>
+        <Ww>
+          <count>13</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>data[0]</ItemText>
+        </Ww>
+        <Ww>
+          <count>14</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>data[1]</ItemText>
+        </Ww>
+        <Ww>
+          <count>15</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>F_AC_P</ItemText>
+        </Ww>
+        <Ww>
+          <count>16</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>level_cnt1</ItemText>
+        </Ww>
+        <Ww>
+          <count>17</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>down_count</ItemText>
+        </Ww>
+        <Ww>
+          <count>18</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>up_count</ItemText>
+        </Ww>
+        <Ww>
+          <count>19</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>data-&gt;input_2_up_flag</ItemText>
+        </Ww>
+        <Ww>
+          <count>20</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>max</ItemText>
+        </Ww>
       </WatchWindow1>
       <Tracepoint>
         <THDelay>0</THDelay>
@@ -949,6 +1014,30 @@
       <RteFlg>0</RteFlg>
       <bShared>0</bShared>
     </File>
+    <File>
+      <GroupNumber>3</GroupNumber>
+      <FileNumber>59</FileNumber>
+      <FileType>1</FileType>
+      <tvExp>0</tvExp>
+      <tvExpOptDlg>0</tvExpOptDlg>
+      <bDave2>0</bDave2>
+      <PathWithFileName>..\HARDWARE\I2c\eeprom.c</PathWithFileName>
+      <FilenameWithoutPath>eeprom.c</FilenameWithoutPath>
+      <RteFlg>0</RteFlg>
+      <bShared>0</bShared>
+    </File>
+    <File>
+      <GroupNumber>3</GroupNumber>
+      <FileNumber>60</FileNumber>
+      <FileType>1</FileType>
+      <tvExp>0</tvExp>
+      <tvExpOptDlg>0</tvExpOptDlg>
+      <bDave2>0</bDave2>
+      <PathWithFileName>..\HARDWARE\DS18B20\ds18b20.c</PathWithFileName>
+      <FilenameWithoutPath>ds18b20.c</FilenameWithoutPath>
+      <RteFlg>0</RteFlg>
+      <bShared>0</bShared>
+    </File>
   </Group>
 
   <Group>
@@ -959,7 +1048,7 @@
     <RteFlg>0</RteFlg>
     <File>
       <GroupNumber>4</GroupNumber>
-      <FileNumber>59</FileNumber>
+      <FileNumber>61</FileNumber>
       <FileType>2</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -971,7 +1060,7 @@
     </File>
     <File>
       <GroupNumber>4</GroupNumber>
-      <FileNumber>60</FileNumber>
+      <FileNumber>62</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -983,7 +1072,7 @@
     </File>
     <File>
       <GroupNumber>4</GroupNumber>
-      <FileNumber>61</FileNumber>
+      <FileNumber>63</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -1003,7 +1092,7 @@
     <RteFlg>0</RteFlg>
     <File>
       <GroupNumber>5</GroupNumber>
-      <FileNumber>62</FileNumber>
+      <FileNumber>64</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>

truing_control/STS/USER/gd32f30x_it.c

@@ -55,6 +55,7 @@ void NMI_Handler(void)
 void HardFault_Handler(void)
 {
     /* if Hard Fault exception occurs, go to infinite loop */
+	int i = 0;
     while (1){
     }
 }

truing_control/STS/USER/main.c

@@ -16,7 +16,7 @@
 #include "R_Led.h"
 
 
-#define VERSION  "V1.0.0.0"
+#define VERSION  "V1.1.0.0"
 
 #define UNIQU_1                       			0x1FFFF7E8
 #define UNIQU_2                       			0x1FFFF7EC
@@ -46,13 +46,12 @@ int main()
 	fans_init();
 	beep_init();
 	temp_init();
-	at24xx_init();
+	eeprom_init();
 	electricity_init();
 	sts_exti_init();
 	
-	
-	uint8_t md_addr = ReadKeyValue();
-	eMBInit(MB_RTU,md_addr,0,115200,MB_PAR_NONE);
+  uint8_t md_addr = ReadKeyValue();
+	eMBInit(MB_RTU,md_addr,0,9600,MB_PAR_NONE);
 	eMBEnable();
 
 	strcpy(sts_data.m_data.info.date,__DATE__);
@@ -66,18 +65,15 @@ int main()
 	sts_data.m_data.info.uniq_ID_64_95 						= *(uint32_t*)(UNIQU_3);
 	sts_data.m_data.info.uniq_ID_32_63 						= *(uint32_t*)(UNIQU_2);
 	sts_data.m_data.info.uniq_ID_00_31 						= *(uint32_t*)(UNIQU_1);
-
-	Fwdgt_Init();
-	
-	sts_data.read_input_level(INPUT_CHANNEL_1);
-	sts_data.read_input_level(INPUT_CHANNEL_2);
+	sts_data.lost_count = LOST_COUNT;
+	sts_data.wanning_count = WANNING_COUNT;
+	//Fwdgt_Init();
+#if 1	
 	sts_data.read_switch_level();
-//	sts_data.m_data.input_status.input_status[INPUT_CHANNEL_1] = 1;						//test
-//	sts_data.m_data.input_status.input_status[INPUT_CHANNEL_2] = 1;						//test
-	sts_data.read_eeprom();
 
-	if(sts_data.switch_status == INPUT_CHANNEL_1 && 
-			sts_data.m_data.input_status.input_status[INPUT_CHANNEL_1])
+	read_config_from_eeprom();
+
+	if(sts_data.switch_status == INPUT_CHANNEL_1 && sts_data.m_data.input_status.input_status[INPUT_CHANNEL_1])
 	{
 		sts_data.choise_input(INPUT_CHANNEL_1);
 	}else
@@ -92,53 +88,87 @@ int main()
 		sts_data.close_output();
 	}
 	uint8_t channel = CH448_CHANNEL_1;
-
-uint8_t write_errp_count = 0;
+#endif
+  uint8_t write_errp_count = 0;
 
 	while(1){
-		Fwdgt_reload();
+		//Fwdgt_reload();
+		
+		if(eMBCheck())
+		{
+			eMBInit(MB_RTU, md_addr, 0, 9600, MB_PAR_NONE);
+			eMBEnable();
+			DelayNms(5);
+		}
 		eMBPoll();
 #if 1
-		sts_data.read_temp();
-#endif
-		// read consumer
 		if(sts_data.flag_1000ms)
 		{
 			sts_data.flag_1000ms = 0;
 			sts_data.led_flash();
 			write_errp_count++;
-
-			if(sts_data.beep_flag)
+		}
+		if(write_errp_count >= 10)
+		{
+			write_errp_count = 0;
+			if(sts_data.kwh.row >= MAX_ROW)
+			{
+				sts_data.kwh.row  = 0;
+			}
+			iic_consumer_data_t chache = {0};
+			if(sts_data.kwh.index >= UINT64_MAX)
+			{
+				for(int i = 0 ; i < MAX_ROW;i++){
+					sts_data.write_eeprom_page(IIC_CONSUMER_START+(IIC_CONSUMER_PAGE*i),&chache,sizeof(iic_consumer_data_t));
+					eMBPoll();
+				}
+				sts_data.kwh.row = 0;
+			}
+			chache.iic_consumer = sts_data.iic_consumer;
+			chache.recode_index1 = sts_data.kwh.index;
+			eMBPoll();
+			sts_data.write_eeprom_page(IIC_CONSUMER_START+(IIC_CONSUMER_PAGE*sts_data.kwh.row),&chache,sizeof(iic_consumer_data_t));
+			sts_data.kwh.index++;
+			sts_data.kwh.row++;
+		}
+		if(sts_data.beep_flag == 0)
+		{
+			if(sts_data.i_beep_flag[0].beep_waning || sts_data.i_beep_flag[1].beep_waning || sts_data.o_beep_flag.beep_waning)
 			{
-				sts_data.beep();
+				sts_data.beep_count = sts_data.wanning_count;
 			}else
 			{
 				sts_data.clear_beep();
 			}
 		}
-
-		if(write_errp_count >= 30)
+		if(sts_data.i_beep_flag[0].beep_waning && sts_data.i_beep_flag[1].beep_waning && sts_data.o_beep_flag.beep_waning)
 		{
-			write_errp_count = 0;
-			sts_data.write_at24(IIC_CONSUMER_START,&sts_data.iic_consumer,sizeof(sts_data.iic_consumer));
+			if(sts_data.beep_flag == 1)
+			{
+				sts_data.beep_count = sts_data.lost_count;
+			}else
+			{
+				sts_data.clear_beep();
+			}
 		}
-#if 1
+		
 		if(sts_data.flag_100ms)
 		{
 			sts_data.flag_100ms = 0;
 			sts_data.read_ele(channel);
 			sts_data.check_wanning(channel);
+			sts_data.read_temp();
 			channel ++;
 		}
-#endif
 		if(channel == CH448_CHANNEL_NONE)
 		{
 			//check input and is or not swtict input 
-#if 1
+
 			if((sts_data.m_data.input_status.input_status[INPUT_CHANNEL_1]) && 
 							(sts_data.m_data.input_status.input_status[INPUT_CHANNEL_2]))
 			{
 				sts_data.beep_flag = 0;
+				sts_data.input_beep = 0;
 				if(sts_data.m_data.md_choise.choise_ch == INPUT_CHANNEL_1)
 				{
 					if(STS_INPUT_HAS_WANNING(sts_data.m_data.input_wanning.waning[INPUT_CHANNEL_1]))
@@ -169,25 +199,36 @@ uint8_t write_errp_count = 0;
 				}
 			}else if((sts_data.m_data.input_status.input_status[INPUT_CHANNEL_1]) )
 			{
-				sts_data.beep_flag = 1;
+				if(!sts_data.input_beep){
+						sts_data.input_beep = 1;
+					  sts_data.beep_count =sts_data.lost_count;
+						sts_data.beep_flag = 1;
+				}
 				if(STS_INPUT_HAS_WANNING(sts_data.m_data.input_wanning.waning[INPUT_CHANNEL_1]))
 				{
 					if(sts_data.m_data.out_status == OUT_OPEN) sts_data.close_output();
 				}
 			}else if((sts_data.m_data.input_status.input_status[INPUT_CHANNEL_2]) ){
-				sts_data.beep_flag = 1;
+				if(!sts_data.input_beep){
+						sts_data.input_beep = 1;
+						sts_data.beep_count =sts_data.lost_count;
+						sts_data.beep_flag = 1;
+				}
 				if(STS_INPUT_HAS_WANNING(sts_data.m_data.input_wanning.waning[INPUT_CHANNEL_2]))
 				{
 					if(sts_data.m_data.out_status == OUT_OPEN) sts_data.close_output();
 				}
 			}else
 			{
-				sts_data.beep_flag = 1;
+				if(!sts_data.input_beep){
+						sts_data.input_beep = 1;
+						sts_data.beep_count =sts_data.lost_count;
+						sts_data.beep_flag = 1;
+				}
 			}
-#endif
 			channel = CH448_CHANNEL_1;
 		}
-#if 1
+
 		if(sts_data.m_data.temprature_flag == TEMP_ONLINE)
 		{
 			if(sts_data.m_data.temprature_th.fans_max_temp != 0 && sts_data.m_data.temprature_th.fans_min_temp != 0)
@@ -210,9 +251,10 @@ uint8_t write_errp_count = 0;
 				}
 			}
 		}
-#endif
 		show_wanning_led();
+#endif
 	}
+
 	return 0;
 }
 

truing_control/STS/USER/main.h

@@ -29,32 +29,95 @@
 
 #define STS_OVER_FUNC             (STS_TEMP_THRESHOLD +2)
 
+#define STS_V_I_K                 (STS_OVER_FUNC + 1)
 
+#define STS_CLEAR_CONSUMER        (STS_V_I_K + 6)
+
+#define STS_CLEAR_BEEP            (STS_CLEAR_CONSUMER + 1)
+
+
+
+
+
+#define EEPROM_SATRT_DEVICE                (0)
+#define EEPROM_SATRT_DEVICE_LENTH          (2)
+
+#define EEPROM_ENABLE_SATRT                (3)
+#define EEPROM_ENABLE_LENTH                (8)
+
+#define EEPROM_INPUT_THRESHOLD_START       				(32)
+#define EEPROM_INPUT_THRESHOLD_LENTH       				(32)
+
+
+#define EEPROM_OUTPUT_THRESHOLD_START    			(96)
+#define EEPROM_OUTPUT_THRESHOLD_LENTH         (80)
+
+
+#define EEPROM_TEMPRATURE_THRESHOLD_START    			(192)
+#define EEPROM_TEMPRATURE_THRESHOLD_LENTH         (8)
+
+
+
+
+
+
+
+#define EEPROM_INPUT_THRESHOLD_START       				(0)
+#define EEPROM_INPUT_THRESHOLD_LENTH       				(16)
+
+#define EEPROM_OUTPUT_THRESHOLD_START      				(32)
+#define EEPROM_OUTPUT_THRESHOLD_LENTH      				(24)
+
+#define EEPROM_TEMPRATURE_THRESHOLD_START    			(64)
+#define EEPROM_TEMPRATURE_THRESHOLD_LENTH         (8)
+
+#define EEPROM_OVER_FUNC_START                    (96)
+#define EEPROM_OVER_FUNC_LENTH                    (2)
+
+
+
+
+#define IIC_DEVICE_INFO                    (0)
 
 #define IIC_INPUT_THRESHOLD_START          (10)
-//#define IIC_INPUT_THRESHOLD_LENTH          (20)
 
 #define IIC_OUTPUT_THRESHOLD_START         (50)
-//#define IIC_OUTPUT_THRESHOLD_LENTH         (30)
 
 #define IIC_TEMPRATURE_THRESHOLD_START     (150)
-//#define IIC_TEMPRATURE_THRESHOLD_LENTH     (4)
+
 
 #define IIC_OVER_FUNC_START                (170)
 #define IIC_OVER_FUNC_LENTH                (1)
 
+#define IIC_K_START                				 (180)
+#define IIC_K_LENTH                				 (12)
+
 
-#define IIC_CONSUMER_START                 (200)
-//#define IIC_CONSUMER_LENTH                 (4)
+
+
+//#define IIC_CONSUMER_START                 (200)
 
 #define IIC_OUT_CHANNEL                   (210)
 
 
+#define MAX_ROW                                (40)
+
+#define  IIC_CONSUMER_START                    (2048)
+#define  IIC_CONSUMER_LENTH                    (12)
+#define  IIC_CONSUMER_PAGE                     (32)
+#define  IIC_CONSUMER_MAX_NUM                  (30)
+
+
+
 #define INVALID_VALUE                      (40000000000)
 #define SMALL_VALUE                        (500) 
 
 
 
+#define LOST_COUNT                         100
+#define WANNING_COUNT                      1000
+
+
 enum{
 	INPUT_CHANNEL_1 = 0,
 	INPUT_CHANNEL_2,
@@ -200,6 +263,21 @@ typedef struct{
 }md_in_wanning;
 
 
+typedef struct {
+	float iic_consumer;
+	uint64_t recode_index1;
+}iic_consumer_data_t;
+
+
+typedef struct{
+	iic_consumer_data_t   iic_da;
+	uint64_t   index;
+	uint16_t   row;
+}consumer_data;
+
+
+
+
 typedef struct {
 	uint16_t waning;
 }md_out_wanning;
@@ -223,6 +301,44 @@ typedef struct {
 	uint32_t freq_min;
 }iic_in_threshold_t;
 
+typedef struct 
+{
+	uint8_t o_v_max  : 1;
+	uint8_t o_v_min  : 1;
+	uint8_t o_i_max  : 1;
+	uint8_t o_p_max  : 1;
+	uint8_t o_c_max  : 1;
+	uint8_t          : 3;
+}wanning_o_t;
+
+typedef union
+{
+	uint8_t 		beep_waning;
+	wanning_o_t o_t; 
+}wanning_o_beep_t;
+
+typedef wanning_o_beep_t  wanning_o_beep_flag_t;
+
+
+
+typedef struct 
+{
+	uint8_t i_v_max   : 1;
+	uint8_t i_v_min   : 1;
+	uint8_t i_hz_max  : 1;
+	uint8_t i_hz_min  : 1;
+	uint8_t           : 4;
+}wanning_i_t;
+
+typedef union
+{
+	uint8_t 		beep_waning;
+	wanning_i_t i_t; 
+}wanning_i_beep_t;
+
+typedef wanning_i_beep_t  wanning_i_beep_flag_t;
+
+
 
 
 typedef struct{
@@ -250,36 +366,52 @@ typedef struct{
 	iic_out_threshold_t     output_th;
 	iic_temp_threshold_t   temprature_th;
 	iic_over_func               over_func;
+	uint16_t               input_v_k[2];
+	uint16_t               input_i_k[2];
+	uint16_t               output_v_k;
+	uint16_t               output_i_k;
 }md_data_t;
 
-#pragma pack ()
-//typedef struct sts_data sts_data_t;
 
 
+#pragma pack ()
 
 typedef struct sts_data{
 	uint8_t     flag_1000ms;
 	uint8_t     flag_100ms;
 	uint8_t     beep_flag;
+	uint32_t    beep_count;
+	uint32_t    lost_count;
+	uint32_t    wanning_count;
+	uint8_t     exit_init_flag;
 	uint8_t       switch_status;
 	md_data_t 						m_data;
+	consumer_data          kwh;
 	float      		iic_consumer;
 	float         temprature;
 	uint8_t       input_wanning_en[2];
 	uint8_t       output_wanning_en;  
+	uint8_t       input_beep;
+	wanning_o_beep_t   o_beep;
+	wanning_o_beep_flag_t o_beep_flag;
+	wanning_i_beep_t   i_beep[2];
+	wanning_i_beep_flag_t   i_beep_flag[2];
 	void (*choise_input)(uint8_t channel);
 	void (*open_output)();
 	void (*close_output)();
 	void (*read_ele)(uint8_t channel);
-	void (*read_input_level)(uint8_t channel);
 	void (*read_switch_level)();
+	uint8_t (*get_input1_level)();
+	uint8_t (*get_input2_level)();
 	void (*fans)(uint8_t on_off);
 	void (*beep)();
 	void (*clear_beep)();
 	void (*led_flash)();
-	void (*read_eeprom)();
-	void (*read_at24)(uint16_t start,uint8_t *buff,uint16_t lenth);
-	void (*write_at24)(uint16_t start,uint8_t *buff,uint16_t lenth);
+	void (*key_clear_beep)();
+	void (*read_eeprom)(uint16_t addr,uint8_t *r_buff,uint16_t lenth);
+	void (*write_eeprom)(uint16_t addr,uint8_t *w_buff,uint16_t lenth);
+	void (*read_eeprom_page)(uint16_t addr,uint8_t *r_buff,uint16_t lenth);
+	void (*write_eeprom_page)(uint16_t addr,uint8_t *r_buff,uint16_t lenth);
 	float (*read_temp)();
 	void (*check_wanning)(uint8_t channel);
 }sts_data_t;