STS 代码！！！！

control/STS/HARDWARE/At24xx/At24xx.c

@@ -13,6 +13,8 @@
 #include "I2c.h"
 #include "gd32e230x_conf.h"
 #include "stdint.h"
+#include "main.h"
+
 
 
 #define CHECK_ADDR   8000
@@ -28,10 +30,15 @@
 #define AT24C256   32767 
 #define USER_DEFINE_EEPROM_TYPE    AT24C64
 
-
+ 
+static void read_iic_data(void);
 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;
 }
 uint8_t at24xx_check(void)
 {
@@ -124,3 +131,105 @@ void at24xx_write_one_byte(unsigned short write_addr,unsigned char data)
 	
   DelayNms(7);                                                                              
 }
+
+static void read_iic_data(void)
+{
+	sts_data_t *sts_d = get_sts();
+	if(sts_d)
+	{
+		uint8_t * r_addr =&sts_d->m_data.input_th;
+		at24xx_read(IIC_INPUT_THRESHOLD_START,r_addr,sizeof(iic_in_threshold_t) * 2);
+		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]);			
+			
+		}
+		
+		r_addr=&sts_d->m_data.output_th;
+		at24xx_read(IIC_OUTPUT_THRESHOLD_START,r_addr,sizeof(iic_out_threshold_t));
+		{
+			if(sts_d->m_data.output_th.voltage_max > INVALID_VALUE) 			sts_d->m_data.output_th.voltage_max  = 0;
+			if(sts_d->m_data.output_th.voltage_min > INVALID_VALUE) 			sts_d->m_data.output_th.voltage_min  = 0;
+			if(sts_d->m_data.output_th.current_max > INVALID_VALUE) 			sts_d->m_data.output_th.current_max  = 0;
+			if(sts_d->m_data.output_th.power_max > INVALID_VALUE) 				sts_d->m_data.output_th.power_max    = 0;
+			if(sts_d->m_data.output_th.consumer_max > INVALID_VALUE) 			sts_d->m_data.output_th.consumer_max = 0;
+			
+			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);				
+		}
+
+		
+		r_addr = &sts_d->m_data.temprature_th;
+		at24xx_read(IIC_TEMPRATURE_THRESHOLD_START,r_addr,sizeof(iic_temp_threshold_t));
+		{
+			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; 
+		}
+		r_addr = &sts_d->m_data.over_func;
+		at24xx_read(IIC_OVER_FUNC_START,r_addr,sizeof(iic_over_func));
+		if(sts_d->m_data.over_func > 0x003F)
+		{
+			sts_d->m_data.over_func = 0;
+		}
+		r_addr = &sts_d->iic_consumer;
+		at24xx_read(IIC_CONSUMER_START,r_addr,sizeof(float));
+		
+		r_addr = &sts_d->m_data.out_status;
+		at24xx_read(IIC_OUT_CHANNEL,r_addr,sizeof(uint16_t));
+		if(sts_d->m_data.out_status > 1)
+		{
+			sts_d->m_data.out_status = 0;
+		}
+	}
+}
+
+

control/STS/HARDWARE/Beep/Beep.c

@@ -10,6 +10,12 @@
 
 #include "Beep.h"
 #include "gd32e230x_conf.h"
+#include "main.h"
+
+static void beep(void)
+{
+	gpio_bit_toggle(GPIOB, GPIO_PIN_1);
+}
 
 void beep_init(void)
 {
@@ -18,10 +24,10 @@ void beep_init(void)
 	gpio_mode_set(GPIOB, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_1);          
   gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_1); 
   gpio_bit_reset(GPIOB, GPIO_PIN_1);  
+	
+	sts_data_t *data = get_sts();
+	data->beep = beep;
 }
 
 
-void beep(void)
-{
-	gpio_bit_toggle(GPIOB, GPIO_PIN_1);
-}
+

control/STS/HARDWARE/Beep/Beep.h

@@ -16,8 +16,6 @@
 
 
 void beep_init(void);
-void beep(void);
-
 
 #endif
 

control/STS/HARDWARE/Electricity/Electricity.c

@@ -13,9 +13,10 @@
 #include "Uart1.h"
 #include "Hlw8110.h"
 #include "SysTick.h"
+#include "main.h"
 
-
-
+void electricity_read(uint8_t channel);
+static void check_wanning(uint8_t channel);
 void electricity_init()
 {
 	InitCH448F();
@@ -27,19 +28,199 @@ void electricity_init()
 		DelayNus(50);
 		Init_HLW8110();
 	}
+	sts_data_t *data = get_sts();
+	data->read_ele = electricity_read;
+	data->check_wanning = check_wanning;
 }
 
-void electricity_read(uint8_t channel, electricity_t *ele)
+void electricity_read(uint8_t channel)
 {
-	if(!ele)
-			return;
+	electricity_t ele = {0};
 	select_channel(channel);
 	DelayNus(50);
 	Check_WriteReg_Success();
-	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();
+	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();
+	
+	sts_data_t *data = get_sts();
+	if(channel == 0)
+	{
+		data->m_data.out_power.voltage = ele.voltage * 1000;
+		data->m_data.out_power.current = ele.current * 1000;
+		
+		data->m_data.out_power.power = ele.power * 1000;
+		data->m_data.out_power.freq = ele.freq * 1000;
+		data->m_data.out_power.factor = ele.factor * 1000;
+		data->iic_consumer += ele.consumer;
+		data->m_data.out_power.consumer = data->iic_consumer * 1000;
+	}else
+	{
+		data->m_data.out_power.voltage = ele.voltage * 1000;
+		data->m_data.out_power.freq = ele.freq * 1000;
+	}
+}
+
+static void check_voltage_max(uint8_t channel)
+{
+	sts_data_t *data = get_sts();
+	if(channel == CH448_CHANNEL_1)
+	{
+		if(IS_VOLTAGE_MAX_EN(data->output_wanning_en)) {
+			if(data->m_data.out_power.voltage > data->m_data.output_th.voltage_max)
+			{
+				SET_WANNING_VOLTAGE_MAX(data->m_data.output_waning.waning);
+			}else
+			{
+				UNSET_WANNING_VOLTAGE_MAX(data->m_data.output_waning.waning);
+			}		
+		}
+	}else
+	{
+		uint8_t chn = channel-1;
+		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)
+			{
+				SET_WANNING_VOLTAGE_MAX(data->m_data.input_wanning.waning[chn]);
+			}else
+			{
+				UNSET_WANNING_VOLTAGE_MAX(data->m_data.input_wanning.waning[chn]);
+			}		
+		}		
+	}
+}
+
+static void check_voltage_min(uint8_t channel)
+{
+	sts_data_t *data = get_sts();
+	if(channel == CH448_CHANNEL_1)
+	{
+		if(IS_VOLTAGE_MIN_EN(data->output_wanning_en)) {
+			if(data->m_data.out_power.voltage < data->m_data.output_th.voltage_min)
+			{
+				SET_WANNING_VOLTAGE_MIN(data->m_data.output_waning.waning);
+			}else
+			{
+				UNSET_WANNING_VOLTAGE_MIN(data->m_data.output_waning.waning);
+			}		
+		}
+	}else
+	{
+		uint8_t chn = channel-1;
+		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)
+			{
+				SET_WANNING_VOLTAGE_MIN(data->m_data.input_wanning.waning[chn]);
+			}else
+			{
+				UNSET_WANNING_VOLTAGE_MIN(data->m_data.input_wanning.waning[chn]);
+			}		
+		}		
+	}
+}
+
+
+static void check_current_max(uint8_t channel)
+{
+	sts_data_t *data = get_sts();
+	if(channel == CH448_CHANNEL_1)
+	{
+		if(IS_CURRENT_MAX_EN(data->output_wanning_en)) {
+			if(data->m_data.out_power.current > data->m_data.output_th.current_max)
+			{
+				SET_WANNING_CURRENT_MAX(data->m_data.output_waning.waning);
+			}else
+			{
+				UNSET_WANNING_CURRENT_MAX(data->m_data.output_waning.waning);
+			}		
+		}
+	}
+}
+
+static void check_power_max(uint8_t channel)
+{
+	sts_data_t *data = get_sts();
+	if(channel == CH448_CHANNEL_1)
+	{
+		if(IS_POWER_MAX_EN(data->output_wanning_en)) {
+			if(data->m_data.out_power.power > data->m_data.output_th.power_max)
+			{
+				SET_WANNING_POWER_MAX(data->m_data.output_waning.waning);
+			}else
+			{
+				UNSET_WANNING_POWER_MAX(data->m_data.output_waning.waning);
+			}		
+		}
+	}
+}
+
+static void check_consumer_max(uint8_t channel)
+{
+	sts_data_t *data = get_sts();
+	if(channel == CH448_CHANNEL_1)
+	{
+		if(IS_CONSUMER_MAX_EN(data->output_wanning_en)) {
+			if(data->m_data.out_power.consumer > data->m_data.output_th.consumer_max)
+			{
+				SET_WANNING_CONSUMER_MAX(data->m_data.output_waning.waning);
+			}else
+			{
+				UNSET_WANNING_CONSUMER_MAX(data->m_data.output_waning.waning);
+			}		
+		}
+	}
+}
+
+static void check_freq_max(uint8_t channel)
+{
+	sts_data_t *data = get_sts();
+	if(channel != CH448_CHANNEL_1)
+	{
+		uint8_t chn = channel -1;
+		if(chn > CH448_CHANNEL_3)
+			return;
+		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)
+			{
+				SET_WANNING_FREQ_MAX(data->m_data.input_wanning.waning[chn]);
+			}else
+			{
+				UNSET_WANNING_FREQ_MAX(data->m_data.input_wanning.waning[chn]);
+			}		
+		}
+	}
+}
+
+static void check_freq_min(uint8_t channel)
+{
+	sts_data_t *data = get_sts();
+	if(channel != CH448_CHANNEL_1)
+	{
+		uint8_t chn = channel -1;
+		if(chn > CH448_CHANNEL_3)
+			return;
+		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)
+			{
+				SET_WANNING_FREQ_MIN(data->m_data.input_wanning.waning[chn]);
+			}else
+			{
+				UNSET_WANNING_FREQ_MIN(data->m_data.input_wanning.waning[chn]);
+			}		
+		}
+	}
+}
+
+static void check_wanning(uint8_t channel)
+{
+	check_voltage_max(channel);
+	check_voltage_min(channel);
+	check_current_max(channel);
+	check_power_max(channel);
+	check_consumer_max(channel);
+	check_freq_max(channel);
+	check_freq_min(channel);
 }

control/STS/HARDWARE/Electricity/Electricity.h

@@ -24,8 +24,8 @@ typedef struct {
 	float factor;
 }electricity_t;
 
+
 void electricity_init();
-void electricity_read(uint8_t channel, electricity_t *ele);
 
 #endif
 

control/STS/HARDWARE/Exti/Exti.c

@@ -1,7 +1,7 @@
 
 #include "Exti.h"
 #include "gd32e230x_conf.h"
-
+#include "main.h"
 
 #define INPUT_PIN_1   GPIO_PIN_7
 #define INPUT_PIN_2   GPIO_PIN_8
@@ -18,6 +18,11 @@
 
 #define SWITCH_EXTI       EXTI_5
 
+
+static void read_input_level(uint8_t channel);
+static void read_switch_level();
+
+
 void sts_exti_init(void)
 {
 	rcu_periph_clock_enable(RCU_GPIOB);
@@ -41,6 +46,11 @@ void sts_exti_init(void)
 	exti_interrupt_flag_clear(INPUT_EXIT_2);
 	exti_interrupt_flag_clear(SWITCH_EXTI);
 	
+	sts_data_t * data = get_sts();
+	
+	data->read_input_level = read_input_level;
+	data->read_switch_level = read_switch_level;
+	
 }
 
 uint8_t get_exti_in_1(void)
@@ -52,34 +62,70 @@ uint8_t get_exti_in_2(void)
 	return gpio_input_bit_get(GPIOB,INPUT_PIN_2);
 }
 
+
+static void read_input_level(uint8_t channel)
+{
+	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)
 {
 	return gpio_input_bit_get(GPIOB,SWTICH_PIN);
 }
 
+static void read_switch_level()
+{
+	sts_data_t * data = get_sts();
+	data->switch_status = get_exti_switch();
+}
+
+
 void EXTI4_15_IRQHandler(void)
 {
+	sts_data_t * data = get_sts();
 	if(RESET != exti_interrupt_flag_get(INPUT_EXIT_1))
 	{
 		if(get_exti_in_1() == SET) 					//rising
 		{
-			
+			data->m_data.input_status.input_status[INPUT_CHANNEL_1] = 1;
 		}else																//falling
 		{
-			
+			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);
+			}
 		}
-		
-		
 		exti_interrupt_flag_clear(INPUT_EXIT_1);
 	}
 	if(RESET != exti_interrupt_flag_get(INPUT_EXIT_2))
 	{
 		if(get_exti_in_2() == SET)				//rising
 		{
-			
+			data->m_data.input_status.input_status[INPUT_CHANNEL_2] = 1;
 		}else																//falling
 		{
-			
+			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);
+			}
 		}
 		exti_interrupt_flag_clear(INPUT_EXIT_2);
 	}
@@ -87,10 +133,18 @@ void EXTI4_15_IRQHandler(void)
 	{
 		if(get_exti_switch() == SET)     //rising
 		{
-			
+			if(data->m_data.input_status.input_status[INPUT_CHANNEL_1])
+			{
+				data->choise_input(INPUT_CHANNEL_1);
+			}
 		}else														//falling
 		{
+			if(data->m_data.input_status.input_status[INPUT_CHANNEL_2])
+			{
+				data->choise_input(INPUT_CHANNEL_2);
+			}
 		}
+		exti_interrupt_flag_clear(SWITCH_EXTI);
 	}
 }
 

control/STS/HARDWARE/Fan/Fan.c

@@ -9,7 +9,7 @@
 *********************************************************************************************************/
 #include "Fan.h"
 #include "gd32e230x_conf.h"
-
+#include "main.h"
 
 
 void fans_init(void)
@@ -18,6 +18,9 @@ void fans_init(void)
   gpio_mode_set(GPIOB, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_6);          
   gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_6); 
   gpio_bit_reset(GPIOB, GPIO_PIN_6);   
+	
+	sts_data_t *data = get_sts();
+	data->fans = fans_on_off;
 }
 
 

control/STS/HARDWARE/Relay/Relay.c

@@ -11,6 +11,7 @@
 #include "gd32e230x_conf.h"
 #include "Sn74lvc573.h"
 #include "R_Led.h"
+#include "main.h"
 
 #define RELAY_1  GPIO_PIN_3
 #define RELAY_2  GPIO_PIN_4
@@ -29,17 +30,24 @@ static void ConfigRelayGPIO(void)
 	gpio_mode_set(GPIOB, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, RELAY_2);          
   gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, RELAY_2); 
   gpio_bit_reset(GPIOB, RELAY_2); 
+	
+
 }
 void InitRelay(void)
 {
 	Init74Lvc();
   ConfigRelayGPIO();  
+	sts_data_t *data = get_sts();
+	data->choise_input = choise_input;
+	data->open_output = out_open;
+	data->close_output = out_close;
 }
 
 
 
 void choise_input(uint8_t channel)
 {
+	sts_data_t *data = get_sts();
 	switch(channel)
 	{
 		case 0:
@@ -47,6 +55,7 @@ void choise_input(uint8_t channel)
 			unlock();
 			gpio_bit_reset(GPIOB, RELAY_1);
 			lock();
+			data->m_data.md_choise.choise_ch = INPUT_CHANNEL_1;
 			in_r_led_on_off(channel);
 		}
 		break;
@@ -55,6 +64,7 @@ void choise_input(uint8_t channel)
 			unlock();
 			gpio_bit_set(GPIOB, RELAY_1);
 			lock();
+			data->m_data.md_choise.choise_ch = INPUT_CHANNEL_2;
 			in_r_led_on_off(channel);
 		}
 		break;

control/STS/HARDWARE/Temprature/Temprature.c

@@ -9,18 +9,25 @@
 *********************************************************************************************************/
 #include "Temprature.h"
 #include "Adc.h"
+#include "main.h"
 
+static void get_temp(void);
 
+static void get_temp(void)
+{
+	sts_data_t *data = get_sts();
+	float a = 0.0;
+	
+	
+	data->temprature = a;
+}
 
 
 void temp_init(void)
 {
 	adc_init();
+	sts_data_t *data = get_sts();
+	data->read_temp = get_temp;
 }
 
-float get_temp(void)
-{
-	float a = 0.0;
-	
-	return a;
-}
+

control/STS/HARDWARE/Temprature/Temprature.h

@@ -17,7 +17,5 @@
 
 void temp_init(void);
 
-float get_temp(void);
-
 #endif
 

control/STS/HARDWARE/Timer/Timer.c

@@ -9,6 +9,7 @@
 *********************************************************************************************************/
 #include "Timer.h"
 #include "gd32e230x_conf.h"
+#include "main.h"
 
 
 static unsigned char s_i100msFlag  = 0;  
@@ -21,6 +22,7 @@ static void ConfigTimer14(unsigned short arr, unsigned short psc);
 static void ConfigTimer15(unsigned short arr, unsigned short psc);  
 static void ConfigTimer16(unsigned short arr, unsigned short psc);  
 
+static sts_data_t *data = 0;
 
 static void ConfigTimer14(unsigned short arr, unsigned short psc)
 {
@@ -90,15 +92,30 @@ static void ConfigTimer16(unsigned short arr,unsigned short psc)
   timer_enable(TIMER16);                         
 }
 
+
+
 void TIMER14_IRQHandler(void)
 {  
-  static  unsigned short s_iCnt2 = 0;                            
-
+  //static  unsigned short s_iCnt2 = 0;                            
+	static  uint16_t  led_cnt = 0;
+	static  uint16_t  read_ele_cnt = 0;
   if(timer_interrupt_flag_get(TIMER14, TIMER_INT_FLAG_UP) == SET) 
   {
     timer_interrupt_flag_clear(TIMER14, TIMER_INT_FLAG_UP);       
   }
-
+	led_cnt++;
+	read_ele_cnt++;
+	
+	if(led_cnt >=1000)
+	{
+		data->led_flag = 1;
+		led_cnt = 0;
+	}
+	if(read_ele_cnt >= 100)
+	{
+		data->read_ele_flag = 1;
+		read_ele_cnt = 0;
+	}
 }
 
 
@@ -129,7 +146,7 @@ void TIMER16_IRQHandler(void)
   {
     timer_interrupt_flag_clear(TIMER16, TIMER_INT_FLAG_UP);         
   }                                                   
-                                                      
+                                              
 
 }
 
@@ -137,8 +154,9 @@ void TIMER16_IRQHandler(void)
 void InitTimer(void)
 {
 	ConfigTimer14(999, 71);  //72MHz/(71+1)=1MHz，由0计数到999为1ms 
-  ConfigTimer15(999, 71);  //72MHz/(71+1)=1MHz，由0计数到999为1ms 
-  ConfigTimer16(999, 71);  //72MHz/(71+1)=1MHz，由0计数到999为1ms
+ // ConfigTimer15(999, 71);  //72MHz/(71+1)=1MHz，由0计数到999为1ms 
+ // ConfigTimer16(999, 71);  //72MHz/(71+1)=1MHz，由0计数到999为1ms
+ data  = get_sts();
 }
 unsigned char Get2msFlag(void)
 {

control/STS/USER/main.c

@@ -26,6 +26,7 @@ sts_data_t *get_sts(void)
 
 
 
+
 int main()
 {
 	InitSysTick();
@@ -33,23 +34,110 @@ int main()
 	InitLED();
 	InitTimer();
 	
+	fans_init();
+	beep_init();
+	temp_init();
 	at24xx_init();
 	electricity_init();
 	sts_exti_init();
 	
 	
-	
-	
 	uint8_t md_addr = ReadKeyValue();
 	eMBInit(MB_RTU,md_addr,0,115200,MB_PAR_NONE);
 	eMBEnable();
 	
+	Fwdgt_Init();
+	
+	sts_data.read_input_level(INPUT_CHANNEL_1);
+	sts_data.read_input_level(INPUT_CHANNEL_2);
+	sts_data.read_switch_level();
 	
 	
-	Fwdgt_Init();
+	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
+	{
+		sts_data.choise_input(INPUT_CHANNEL_2);
+	}
+	if(sts_data.m_data.out_status)
+	{
+		sts_data.open_output();
+	}else
+	{
+		sts_data.close_output();
+	}
+	uint8_t channel = CH448_CHANNEL_1;
 	while(1){
 		Fwdgt_reload();
 		eMBPoll();
+		// read consumer
+		if(sts_data.led_flag)
+		{
+			sts_data.led_flag = 0;
+			sts_data.led_flash();
+			if(sts_data.beep_flag)
+			{
+				sts_data.beep();
+			}
+		}
+		if(sts_data.read_ele_flag)
+		{
+			sts_data.read_ele_flag = 0;
+			sts_data.read_ele(channel);
+			//
+			sts_data.check_wanning(channel);
+			channel ++;
+		}
+		
+		if(channel == CH448_CHANNEL_3)
+		{
+			//check input and is or not swtict input 
+			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;
+				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]))
+					{
+							if(STS_INPUT_HAS_WANNING(sts_data.m_data.input_wanning.waning[INPUT_CHANNEL_2]))
+							{
+								sts_data.close_output();
+							}else
+							{
+								sts_data.choise_input(INPUT_CHANNEL_2);
+							}
+					}
+				}else if(sts_data.m_data.md_choise.choise_ch == INPUT_CHANNEL_2)
+				{
+					if(STS_INPUT_HAS_WANNING(sts_data.m_data.input_wanning.waning[INPUT_CHANNEL_1]))
+					{
+							sts_data.close_output();
+					}else {
+							sts_data.choise_input(INPUT_CHANNEL_1);
+					}
+				}else
+				{
+					;
+				}
+			}else if((sts_data.m_data.input_status.input_status[INPUT_CHANNEL_1]) )
+			{
+				sts_data.beep_flag = 1;
+				if(STS_INPUT_HAS_WANNING(sts_data.m_data.input_wanning.waning[INPUT_CHANNEL_1]))
+				{
+					sts_data.close_output();
+				}
+			}else if((sts_data.m_data.input_status.input_status[INPUT_CHANNEL_2]) ){
+				sts_data.beep_flag = 1;
+				if(STS_INPUT_HAS_WANNING(sts_data.m_data.input_wanning.waning[INPUT_CHANNEL_2]))
+				{
+					sts_data.close_output();
+				}
+			}
+			channel = CH448_CHANNEL_1;
+		}
 	}
 	return 0;
 }

control/STS/USER/main.h

@@ -16,26 +16,116 @@
 
 
 #define IIC_INPUT_THRESHOLD_START          (10)
-#define IIC_INPUT_THRESHOLD_LENTH          (20)
+//#define IIC_INPUT_THRESHOLD_LENTH          (20)
 
 #define IIC_OUTPUT_THRESHOLD_START         (50)
-#define IIC_OUTPUT_THRESHOLD_LENTH         (30)
+//#define IIC_OUTPUT_THRESHOLD_LENTH         (30)
 
-#define IIC_TEMPRATURE_THRESHOLD_START     (100)
-#define IIC_TEMPRATURE_THRESHOLD_LENTH     (4)
+#define IIC_TEMPRATURE_THRESHOLD_START     (150)
+//#define IIC_TEMPRATURE_THRESHOLD_LENTH     (4)
 
-#define IIC_OVER_FUNC_START                (110)
+#define IIC_OVER_FUNC_START                (170)
 #define IIC_OVER_FUNC_LENTH                (1)
 
 
+#define IIC_CONSUMER_START                 (200)
+//#define IIC_CONSUMER_LENTH                 (4)
 
+#define IIC_OUT_CHANNEL                   (210)
 
 
+#define INVALID_VALUE                      (10000000)
+#define SMALL_VALUE                        (500) 
 
 
 
+enum{
+	INPUT_CHANNEL_1=0,
+	INPUT_CHANNEL_2,
+};
 
 
+enum {
+	CH448_CHANNEL_1 = 0,
+	CH448_CHANNEL_2,
+	CH448_CHANNEL_3,
+};
+
+
+#define    VOLTAGE_MAX_EN         (0x01)
+#define    VOLTAGE_MIN_EN         (0x02)
+#define    CURRENT_MAX_EN         (0x04)
+#define    POWER_MAX_EN           (0x08)
+#define    CONSUMER_MAX_EN        (0x10)
+#define    FREQ_MAX_EN            (0x20)
+#define    FREQ_MIN_EN            (0x40)
+
+#define    VOLTAGLE_MAX_DIS_EN    (~(VOLTAGE_MAX_EN))
+#define    VOLTAGLE_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_EN(reg) 					((reg) & FREQ_MAX_EN)
+#define   IS_FREQ_MIN_EN(reg) 				  ((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) &= VOLTAGLE_MAX_DIS_EN)
+#define   UNSET_VOLTAGE_MIN_EN(reg)        	((reg) &= VOLTAGLE_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)       SET_VOLTAGE_MAX_EN(reg) 
+#define  SET_WANNING_VOLTAGE_MIN(reg)       SET_VOLTAGE_MIN_EN(reg) 
+#define  SET_WANNING_CURRENT_MAX(reg)       SET_CURRENT_MAX_EN(reg) 
+#define  SET_WANNING_POWER_MAX(reg)         SET_POWER_MAX_EN(reg) 
+#define  SET_WANNING_CONSUMER_MAX(reg)      SET_CONSUMER_MAX_EN(reg) 
+#define  SET_WANNING_FREQ_MAX(reg)       		SET_FREQ_MAX_EN(reg) 
+#define  SET_WANNING_FREQ_MIN(reg)       		SET_FREQ_MIN_EN(reg) 
+
+
+
+#define  UNSET_WANNING_VOLTAGE_MAX(reg)  		UNSET_VOLTAGE_MAX_EN(reg)        	
+#define  UNSET_WANNING_VOLTAGE_MIN(reg) 	 	UNSET_VOLTAGE_MIN_EN(reg)        	
+#define  UNSET_WANNING_CURRENT_MAX(reg) 		UNSET_CURRENT_MAX_EN(reg)        
+#define  UNSET_WANNING_POWER_MAX(reg) 			UNSET_POWER_MAX_EN(reg)        		
+#define  UNSET_WANNING_CONSUMER_MAX(reg) 		UNSET_CONSUMER_MAX_EN(reg)        
+#define  UNSET_WANNING_FREQ_MAX(reg)  			UNSET_FREQ_MAX_EN(reg)        		
+#define  UNSET_WANNING_FREQ_MIN(reg)  			UNSET_FREQ_MIN_EN(reg)        
+
+
+
+#define IS_WANNING_VOLTAGE_MAX(reg)          IS_VOLTAGE_MAX_EN(reg)
+#define IS_WANNING_VOLTAGE_MIN(reg)					 IS_VOLTAGE_MIN_EN(reg)
+#define IS_WANNING_CURRENT_MAX(reg)					 IS_CURRENT_MAX_EN(reg)
+#define IS_WANNING_POWER_MAX(reg)						 IS_POWER_MAX_EN(reg) 
+#define IS_WANNING_CONSUMER_MAX(reg)         IS_CONSUMER_MAX_EN(reg)
+#define IS_WANNING_FREQ_MAX(reg)						 IS_FREQ_MAX_EN(reg)
+#define IS_WANNING_FREQ_MIN(reg)						 IS_FREQ_MIN_EN(reg)
+
+
+#define STS_INPUT_HAS_WANNING(reg)    ((IS_WANNING_VOLTAGE_MAX(reg)) || (IS_WANNING_VOLTAGE_MIN(reg)) \
+																			|| (IS_WANNING_FREQ_MAX(reg)) || (IS_WANNING_FREQ_MIN(reg)) )
 
 
 //#pragma pack (2)
@@ -125,22 +215,45 @@ typedef struct{
 	md_in_wanning       input_wanning;
 	md_out_wanning      output_waning;
 	md_out_power_info   		out_power;
+	uint16_t               out_status;
 	iic_in_threshold_t    input_th[2];
 	iic_out_threshold_t     output_th;
-	iic_temp_threshold_t       temprature;
+	iic_temp_threshold_t   temprature_th;
 	iic_over_func               over_func;
 }md_data_t;
 
 
+typedef struct sts_data sts_data_t;
 
 
 
-typedef struct{
+typedef struct sts_data{
 	uint8_t     led_flag;
 	uint8_t     count_start_flag;
 	uint8_t     switch_flag;
 	uint8_t     over_func_flag;
-	md_data_t 	data;
+	uint8_t     read_ele_flag;
+	uint8_t     beep_flag;
+	uint8_t       switch_status;
+	md_data_t 						m_data;
+	float      		iic_consumer;
+	float         temprature;
+	uint8_t       input_wanning_en[2];
+	uint8_t       output_wanning_en;  
+	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)();
+	void (*fans)(uint8_t on_off);
+	void (*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 (*read_temp)();
+	void (*check_wanning)(uint8_t channel);
 }sts_data_t;
 
 //#pragma pack ()