F427 snmp tarp ,web配置 ，北向读取控制配置，

f427/applications/cascade.c

@@ -860,7 +860,7 @@ int mb_port_read_hold(u16 addr, u16 *preg)//读保持寄存器, 返回 : 0-成
 
 int mb_port_write_hold(u16 addr, u16 reg)//写保持寄存器, 返回 : 0-成功, -2-地址错误, -3-值非法, -4-设备故障
 {
-    //power_all_t *power = power_data_get();
+    power_all_t *power = power_get_all();
 	
 	if(AC_DC_SET_DELAY_OPEN <= addr && addr <= AC_DC_ALL_SET_SWITCH_REG)
 	{
@@ -869,14 +869,104 @@ int mb_port_write_hold(u16 addr, u16 reg)//写保持寄存器, 返回 : 0-成功
 			case AC_DC_SET_DELAY_OPEN ... (AC_DC_SET_DELAY_CLOSE-1):
 			{
 				uint16_t channel = addr - AC_DC_SET_DELAY_OPEN;
-				//获取通道控制接口 写入数据
-				
-				
+				if(channel < power->chs -1)
+				{
+					power->pch[channel+1].info.open_delay = reg;
+					power_set_open_delay(&power->pch[channel+1]);
+				}
+			}
+			break;
+			case AC_DC_SET_DELAY_CLOSE ...(AC_DC_CHN_SET_SWITCH_STA_REG - 1):
+			{
+				uint16_t channel = addr - AC_DC_SET_DELAY_CLOSE;
+				if(channel < power->chs -1)
+				{
+					power->pch[channel+1].info.close_delay = reg;
+					power_set_close_delay(&power->pch[channel+1]);
+				}				
+			}
+			break;
+			case AC_DC_CHN_SET_SWITCH_STA_REG ... (AC_DC_ALL_SET_SWITCH_REG-1):
+			{
+				uint16_t channel = addr - AC_DC_CHN_SET_SWITCH_STA_REG;
+				if(channel <= power->chs -1)
+				{
+					power->pch[channel+1].status = reg;
+					power_set_ch_sw_n(&power->pch[channel+1]);
+				}
+			}
+			break;
+			case AC_DC_ALL_SET_SWITCH_REG:
+			{
+				power_handle_t * handle =  get_power_handle();
+				if(handle->cnt > 0)
+				{
+					for(int i = 1 ; i <= handle->cnt;i++)
+					{
+						if(handle->pbrd[i])
+						{
+							handle->pbrd[i]->fn.set_all(reg,handle->pbrd[i]);
+						}
+					}
+				}
 			}
 			break;
 		}
 		return 0;
 	}
+	
+	if(AC_3_SET_DELAY_OPEN <= addr && addr <= AC_3_ALL_SET_SWITCH_REG )
+	{
+		switch(addr)
+		{
+			case AC_3_SET_DELAY_OPEN ... (AC_3_SET_DELAY_CLOSE-1):
+			{
+				uint16_t channel = addr - AC_DC_SET_DELAY_OPEN;
+				if(channel < power->chs -1)
+				{
+					power->pch[channel+1].info.open_delay = reg;
+					power_set_open_delay(&power->pch[channel+1]);
+				}
+			}
+			break;
+			case AC_3_SET_DELAY_CLOSE ... (AC_3_CHN_SET_SWITCH_STA_REG-1):
+			{
+				uint16_t channel = addr - AC_DC_SET_DELAY_CLOSE;
+				if(channel < power->chs -1)
+				{
+					power->pch[channel+1].info.close_delay = reg;
+					power_set_close_delay(&power->pch[channel+1]);
+				}					
+			}
+			break;
+			case AC_3_CHN_SET_SWITCH_STA_REG ... (AC_3_ALL_SET_SWITCH_REG -1):
+			{
+				uint16_t channel = addr - AC_DC_CHN_SET_SWITCH_STA_REG;
+				if(channel <= power->chs -1)
+				{
+					power->pch[channel+1].status = reg;
+					power_set_ch_sw_n(&power->pch[channel+1]);
+				}
+			}
+			break;
+			case AC_3_ALL_SET_SWITCH_REG:
+			{
+				power_handle_t * handle =  get_power_handle();
+				if(handle->cnt > 0)
+				{
+					for(int i = 1 ; i <= handle->cnt;i++)
+					{
+						if(handle->pbrd[i])
+						{
+							handle->pbrd[i]->fn.set_all(reg,handle->pbrd[i]);
+						}
+					}
+				}				
+			}
+			break;
+		}
+	}
+	
 	return(-2);
 } 
 

f427/applications/datadef.h

@@ -247,9 +247,14 @@ typedef struct {
 typedef struct {
     uint8_t             lang;
     int8_t              tzone;
+		char                sys_time[32];
 }system_data_t;
 
 
+
+
+
+
 typedef struct {
 	uint32_t th_max_1;
 	uint32_t th_min_1;
@@ -258,6 +263,25 @@ typedef struct {
 }sensor_th_t;
 
 
+typedef struct {
+    char                alg[12];
+    char                passwd[32];
+}crypt_data_t;
+typedef struct {
+    char                user[32];
+    crypt_data_t        auth;
+    crypt_data_t        priv;
+}crypt_t;
+typedef struct {
+    uint8_t             mode;
+    uint8_t             version;
+    char                publics[10];
+    uint8_t             trapmode;
+    //crypt_t             crypt;
+    char                nms_ip[32];
+}snmp_data_t;
+
+
 typedef struct {
     system_data_t       sys;
     version_data_t      ver;
@@ -267,6 +291,7 @@ typedef struct {
     service_data_t      serv;
     network_data_t      netwk;
 		sensor_th_t      sensor[3];
+		snmp_data_t         snmp;
 }paras_data_t;
 
 typedef struct {
@@ -466,24 +491,28 @@ typedef struct {
     breaker_data_t      *data;
 }breaker_all_t;
 
+typedef struct board_data board_data_t;
+
 typedef struct {
-    int (*get_power)(power_ch_t *pch);
-    int (*get_alarm)(power_ch_t *pch);
-    int (*set_ch)(power_ch_t *pch);
-    int (*set_open_delay)(power_ch_t *pch);
-    int (*set_close_delay)(power_ch_t *pch);
-    int (*set_kb_value)(power_ch_t *pch);
-    int (*set_threshold)(power_ch_t *pch);
-    int (*reset_consump)(power_ch_t *pch);
+//    int (*get_power)(power_ch_t *pch);
+//    int (*get_alarm)(power_ch_t *pch);
+//    int (*set_ch)(power_ch_t *pch);
+//    int (*set_open_delay)(power_ch_t *pch);
+//    int (*set_close_delay)(power_ch_t *pch);
+//    int (*set_kb_value)(power_ch_t *pch);
+//    int (*set_threshold)(power_ch_t *pch);
+//    int (*reset_consump)(power_ch_t *pch);
 
-    int (*detect)(uint8_t addr);
-    int (*get_info)(uint8_t addr, board_info_t *info);
+//    int (*detect)(uint8_t addr);
+//    int (*get_info)(uint8_t addr, board_info_t *info);
     //int (*get_board)(board_data_t *pbrd);
-    int (*set_board)(uint8_t addr, uint8_t on);
-    int (*set_all)(uint8_t on);
+//    int (*set_board)(uint8_t addr, uint8_t on);
+    int (*set_all)(uint16_t on,board_data_t *data);
 }board_fn_t;
 
-typedef struct {
+
+
+struct board_data{
     board_fn_t          fn;
     uint8_t             type;
     uint8_t             addr;
@@ -494,7 +523,12 @@ typedef struct {
     board_info_t        info;
     breaker_data_t      brk[2];
     power_ch_t          *pch;                   //根据实际通道数申请连续内存
-}board_data_t;
+};
+
+
+
+
+
 
 typedef struct {
     float               voltage;                //电压
@@ -599,24 +633,6 @@ typedef struct
     uint32_t            time;                   //创建时间
 }role_data_t;
 
-typedef struct {
-    char                alg[12];
-    char                passwd[64];
-}crypt_data_t;
-typedef struct {
-    char                user[32];
-    crypt_data_t        auth;
-    crypt_data_t        priv;
-}crypt_t;
-typedef struct {
-    uint8_t             mode;
-    uint8_t             version;
-    char                publics[64];
-    uint8_t             trapmode;
-
-    crypt_t             crypt;
-    char                nms_ip[64];
-}snmp_data_t;
 
 typedef struct
 {
@@ -794,7 +810,9 @@ enum {
     SUB_TYPE_PARAS_PROD,
     SUB_TYPE_PARAS_SERV,
     SUB_TYPE_PARAS_NETWORK,
-    
+		SUB_TYPE_PARAS_SNMP,
+    SUB_TYPE_PARAS_NTP,
+		SUB_TYPE_POWER_CONSUMER_CLEAR,
     SUB_TYPE_MAX
 };
 

f427/applications/dflt.c

@@ -74,6 +74,13 @@ const paras_data_t DFLT_PARAS={
         #endif
             
         },
+				.snmp={
+					.mode = 1,
+					.version = 1,
+					.publics = "public",
+					.trapmode = 1,
+					.nms_ip = "127.0.0.1",
+				}
 };
 
 

f427/applications/main.c

@@ -116,7 +116,6 @@ int main(void)
     sys_init();
     user_init();
     while (1) {
-			
-			sleep(10);
+			sleep(2);
     }
 }

f427/applications/net.c

@@ -17,17 +17,20 @@
 #include "lwip/prot/dhcp.h"
 #include <lwip/ip_addr.h>
 #include "lwip/dns.h"
+#include "lwip/ip4_addr.h"
 #include "net.h"
+#include "netdev.h"
 
 
-#if 1
+
+#if 0
     #define LOGE  LOG_E
     #define LOGW  LOG_W
     #define LOGD  LOG_D
 #else
-    #define LOGD  rt_printf
-    #define LOGW  rt_printf
-    #define LOGE  rt_printf
+    #define LOGD  printf
+    #define LOGW  printf
+    #define LOGE  printf
 #endif
 
 
@@ -48,7 +51,7 @@ static net_handle_t handle_net = {0};
 void print_net(char*s, network_data_t *p)
 {
     LOGD("__%s__net.mode:    %d\n", s, p->mode);
-    LOGD("__%s__net.addr:    %s\n", s, p->ip_address);
+    LOGD("__%s__net.addr:    %s\n", s, p->ipaddr);
     LOGD("__%s__net.mask:    %s\n", s, p->mask);
     LOGD("__%s__net.gateway: %s\n", s, p->gateway);
     LOGD("__%s__net.dns1:    %s\n", s, p->dns1);
@@ -58,8 +61,8 @@ void print_modbus(char*s, modbus_data_t *p)
 {
     LOGD("__%s__mbus.mode:    %d\n", s, p->mode);
     LOGD("__%s__mbus.addr:    %d\n", s, p->addr);
-    LOGD("__%s__mbus.baud:    %d\n", s, p->baudrate);
-    LOGD("__%s__mbus.path:    %s\n", s, p->path);
+    LOGD("__%s__mbus.baud:    %d\n", s, p->baud);
+    //LOGD("__%s__mbus.path:    %s\n", s, p->path);
 }
 
 static  int set_dns(network_data_t *para)
@@ -307,12 +310,13 @@ int sys_ip_check(char *ip)
 static void ip_save(network_data_t *data)
 {
 		paras_data_t* para = paras_get();
-		memcmp(para->netwk.ipaddr,data->ipaddr,strlen(data->ipaddr));
-		memcmp(para->netwk.gateway,data->gateway,strlen(data->gateway));
-		memcmp(para->netwk.mask,data->mask,strlen(data->mask));
-		memcmp(para->netwk.dns1,data->dns1,strlen(data->dns1));
-		memcmp(para->netwk.dns2,data->dns2,strlen(data->dns2));		
-		para->netwk.mode = data->mode;
+		para->netwk = *data;
+//		memcpy(para->netwk.ipaddr,data->ipaddr,strlen(data->ipaddr));
+//		memcpy(para->netwk.gateway,data->gateway,strlen(data->gateway));
+//		memcpy(para->netwk.mask,data->mask,strlen(data->mask));
+//		memcpy(para->netwk.dns1,data->dns1,strlen(data->dns1));
+//		memcpy(para->netwk.dns2,data->dns2,strlen(data->dns2));		
+//    para->netwk.mode = data->mode;
 		paras_save();
 	return;
 }
@@ -347,22 +351,37 @@ void net_get_ip(network_data_t *data)
 static void ip_set_static()
 {
 	paras_data_t* para = paras_get();
-	u32_t ip = ipaddr_addr(para->netwk.ipaddr);
-	u32_t gw = ipaddr_addr(para->netwk.gateway);
-	u32_t mask = ipaddr_addr(para->netwk.mask);
-	netifapi_netif_set_addr(handle_net.netif, (ip4_addr_t*)&ip, (ip4_addr_t*)&mask, (ip4_addr_t*)&gw);
-			
+	
 	ip_addr_t primary_dns, backup_dns;
-			
+	
 	ipaddr_aton(para->netwk.dns1, &primary_dns);  // 主 DNS
 	ipaddr_aton(para->netwk.dns2, &backup_dns); // 备 DNS	
-			
+	
+	
 	dns_setserver(0, &primary_dns);  // 索引 0 为主
 	dns_setserver(1, &backup_dns);   // 索引 1 为备
-	netifapi_netif_set_link_down(handle_net.netif);
+	
+	
 	usleep(10000);
-	netifapi_netif_set_link_up(handle_net.netif);
-	usleep(100000);	
+	
+	u32_t ip = ipaddr_addr(para->netwk.ipaddr);
+	u32_t gw = ipaddr_addr(para->netwk.gateway);
+	u32_t mask = ipaddr_addr(para->netwk.mask);
+	//netifapi_netif_set_addr(handle_net.netif, (ip4_addr_t*)&ip, (ip4_addr_t*)&mask, (ip4_addr_t*)&gw);
+	
+
+	netif_set_down(handle_net.netif);
+	
+	netif_set_addr(handle_net.netif,(ip4_addr_t*)&ip,(ip4_addr_t*)&mask,(ip4_addr_t*)&gw);
+			
+	netif_set_up(handle_net.netif);
+			
+	
+	//netifapi_netif_set_link_down(handle_net.netif);
+	
+	//usleep(10000);
+	//netifapi_netif_set_link_up(handle_net.netif);
+	//usleep(100000);	
 }
 
 
@@ -375,9 +394,26 @@ int net_ipaddr_set(network_data_t *data)
 		if(data->mode == 1)
 		{
 			ip_save(data);
-			netifapi_dhcp_stop(handle_net.netif);
+			struct netdev *netdev = RT_NULL;
+			//netifapi_dhcp_stop(handle_net.netif);
+			netdev = netdev_get_by_name("e0");
+			if (netdev == RT_NULL) {
+					rt_kprintf("bad network interface device name(e0).\n");
+			}
+
+			netdev_dhcp_enabled(netdev, RT_FALSE);
+			
+			sleep(1);
 			ip_set_static();
 			LOG_D("mode dhcp 2 static\n");
+		}else
+		{
+//			netifapi_dhcp_stop(handle_net.netif);
+			netifapi_dhcp_release_and_stop(handle_net.netif);
+			sleep(1);
+			netifapi_dhcp_start(handle_net.netif);
+			
+			LOG_D("mode static 2 dhcp\n");
 		}
 	}else if(para->netwk.mode == 1)
 	{
@@ -442,15 +478,15 @@ int net_init(void)
 			//dhcp->offered_ip_addr.addr = 
 			//filt 
 			char * str =  ip4addr_ntoa(netif_ip4_addr(handle_net.netif));
-			LOG_D("____%s\n",str);
+			LOG_E("____%s\n",str);
 			memcpy(para->netwk.ipaddr,str,strlen(str));
 			str =  ip4addr_ntoa(netif_ip4_netmask(handle_net.netif));
-			LOG_D("____%s\n",str);
+			LOG_E("____%s\n",str);
 			memcpy(para->netwk.mask,str,strlen(str));
 			
 			str =  ip4addr_ntoa(netif_ip4_gw(handle_net.netif));
 			memcpy(para->netwk.gateway,str,strlen(str));
-			LOG_D("____%s\n",str);
+			LOG_E("____%s\n",str);
 			
 		}else
 		{

f427/applications/paras.c

@@ -753,6 +753,123 @@ static int proc_sensor(dictionary *dic, int op, sensor_th_t sensor[])
 }
 
 
+static int proc_snmp_n(dictionary *dic, int op, snmp_data_t *snmp)
+{
+
+    int r=0;
+    char temp[100];
+    char *p,*token=NULL;
+		if(op==PARAS_CHECK) {
+			return 0;
+		}else if (op==PARAS_CREATE) {
+			return 0;
+		}else if (op==PARAS_WRITE) {
+        r = proc_snmp_n(dic, PARAS_CHECK, snmp);
+        if(r) {
+            return -1;
+        }
+		}
+		token = "snmp:mode";
+    if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            snmp->mode = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", snmp->mode);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }			
+		token = "snmp:version";
+    if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            snmp->version = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", snmp->version);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+
+		token = "snmp:public";
+    if(op==PARAS_READ) {
+        const char * str = iniparser_getstring(dic, token,NULL);
+        if(str == NULL) {
+            LOGE("___ iniparser_getstring %s failed\n", token);
+            return -1;
+        } else {
+            memcpy(snmp->publics,str,strlen(str));
+        }
+    }
+    else {
+        sprintf(temp, "%s", snmp->publics);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+
+		token = "snmp:trap_mode";
+    if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            snmp->trapmode = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", snmp->trapmode);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }		
+		token = "snmp:nms_ip";
+    if(op==PARAS_READ) {
+        const char * str = iniparser_getstring(dic, token,NULL);
+        if(str == NULL) {
+            LOGE("___ iniparser_getstring %s failed\n", token);
+            return -1;
+        } else {
+            memcpy(snmp->nms_ip,str,strlen(str));
+        }
+    }
+    else {
+        sprintf(temp, "%s", snmp->nms_ip);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+		r = 0;
+    if(op==PARAS_READ) {
+        r = proc_snmp_n(dic, PARAS_CHECK, snmp);
+    }	
+		return r;
+}
+
+
+
 static int proc_net(dictionary *dic, int op,network_data_t *net)
 {
     int r=0;
@@ -872,7 +989,7 @@ static int proc_net(dictionary *dic, int op,network_data_t *net)
         }
     }
     else {
-        sprintf(temp, "%s", net->dns1);
+        sprintf(temp, "%s", net->dns2);
         r = iniparser_set(dic, token, temp);
         if(r) {
             LOGE("___ iniparser_set %s failed\n", token);
@@ -1136,14 +1253,20 @@ quit:
     iniparser_freedict(dic);
     return r;
 }
-static int proc_snmp(char *path, int op, SNMPManager *snmp)
+#endif
+
+
+
+
+
+static int proc_snmp(char *path, int op, snmp_data_t *snmp)
 {
     int r=0,len=0;
     char temp[100];
     char *p,*token=NULL;
     dictionary *dic=NULL;
-    SNMPManager snmp2,*psnmp=snmp;
-    GlobalDeviceManager *dm=get_dm();
+    snmp_data_t *psnmp=snmp;
+    //GlobalDeviceManager *dm=get_dm();
 
     switch(op) {
         case PARAS_CHECK:
@@ -1154,7 +1277,7 @@ static int proc_snmp(char *path, int op, SNMPManager *snmp)
             }
 
             if(psnmp->mode==1) {
-                if(!psnmp->public[0]) {
+                if(!psnmp->publics[0]) {
                     LOGE("___ check snmp, no public input\n");
                     r = -1; 
                 }
@@ -1163,17 +1286,17 @@ static int proc_snmp(char *path, int op, SNMPManager *snmp)
                     LOGE("___ check snmp, trapmode %d is wrong, correct value is 0/1\n", psnmp->trapmode);
                     r = -1; 
                 }
-
+#if 0
                 if(psnmp->version>=1 && sys_ip_check(psnmp->nmsIP)==IP_ERR) {
                     LOGE("___ check snmp, nms ip is invalid\n");
                     r = -1;
                 }
-
+#endif
                 if(psnmp->version<0 || psnmp->version>2) {
                     LOGE("___ check snmp, version %d is wrong, correct value is 0/1/2\n");
                     r = -1;
                 }
-
+#if 0
                 if(psnmp->version==2) {
 
                     if(!psnmp->crypt.user[0]) {
@@ -1231,6 +1354,7 @@ static int proc_snmp(char *path, int op, SNMPManager *snmp)
                         r = -1;
                     }
                 }
+#endif
             }
             return r;
         }
@@ -1246,44 +1370,46 @@ static int proc_snmp(char *path, int op, SNMPManager *snmp)
 
             fprintf(fp, "[snmp]\n");
             fprintf(fp, "mode        = \"%d\"\n", snmp->mode);
-            fprintf(fp, "version     = \"%d\"\n", snmp->version+1);
-            fprintf(fp, "public      = \"%s\"\n", snmp->public);
+            fprintf(fp, "version     = \"%d\"\n", snmp->version);
+            fprintf(fp, "public      = \"%s\"\n", snmp->publics);
             fprintf(fp, "trap_mode   = \"%d\"\n", snmp->trapmode);
-            fprintf(fp, "nms_ip      = \"%s\"\n", snmp->nmsIP);
+            fprintf(fp, "nms_ip      = \"%s\"\n", snmp->nms_ip);
+#if 0
             fprintf(fp, "crypt.user  = \"%s\"\n", snmp->crypt.user);
             fprintf(fp, "crypt.auth.proto     = \"%s\"\n", snmp->crypt.auth.alg);
             fprintf(fp, "crypt.auth.password  = \"%s\"\n", snmp->crypt.auth.passwd);
             fprintf(fp, "crypt.priv.proto     = \"%s\"\n", snmp->crypt.priv.alg);
             fprintf(fp, "crypt.priv.password  = \"%s\"\n", snmp->crypt.priv.passwd);
-            fprintf(fp, "nms_ip      = \"%s\"\n", snmp->nmsIP);
+
+            fprintf(fp, "nms_ip      = \"%s\"\n", snmp->nms_ip);
+#endif
             fprintf(fp, "\n");
 
             fclose(fp);
-            return 0;
         }
         break;
 
         case PARAS_READ:
         {
-            char ver[32];
+           // char ver[32];
 
-            psnmp = &snmp2;
+            //psnmp = &snmp2;
             dic = iniparser_load(path); if(!dic) return -1;
 
-            memset(psnmp, 0, sizeof(SNMPManager));
+            memset(psnmp, 0, sizeof(snmp_data_t));
             r = ini_rw(dic, "snmp:mode",     &psnmp->mode,     sizeof(psnmp->mode),    TYPE_INT, op, 1); if(r) goto quit;
-            r = ini_rw(dic, "snmp:public",   psnmp->public,    sizeof(psnmp->public),  TYPE_STR, op, 1); if(r) goto quit;
-            r = ini_rw(dic, "snmp:version",  ver,              sizeof(ver),            TYPE_STR, op, 1); if(r) goto quit;
-            if(strcmp(ver, "V1")==0)       psnmp->version = 0;
-            else if(strcmp(ver, "V2c")==0) psnmp->version = 1;
-            else if(strcmp(ver, "V3")==0)  psnmp->version = 2;
-            else {r=-1; goto quit;}
-
-            r = ini_rw(dic, "snmp:trap_mode",  &psnmp->trapmode,  sizeof(ver), TYPE_INT, op, 1); if(r) goto quit;
-            if(psnmp->version>=1) {
-                r = ini_rw(dic, "snmp:nms_ip",     psnmp->nmsIP,      sizeof(ver), TYPE_STR, op, 1); if(r) goto quit;
-            }
-
+            r = ini_rw(dic, "snmp:public",   psnmp->publics,    sizeof(psnmp->publics),  TYPE_STR, op, 1); if(r) goto quit;
+            r = ini_rw(dic, "snmp:version",  &psnmp->version,              sizeof(psnmp->version),  TYPE_INT, op, 1); if(r) goto quit;
+//            if(strcmp(ver, "V1")==0)       psnmp->version = 0;
+//            else if(strcmp(ver, "V2c")==0) psnmp->version = 1;
+//            else if(strcmp(ver, "V3")==0)  psnmp->version = 2;
+//            else {r=-1; goto quit;}
+
+            r = ini_rw(dic, "snmp:trap_mode",  &psnmp->trapmode,  sizeof(psnmp->trapmode), TYPE_INT, op, 1); if(r) goto quit;
+            //if(psnmp->version>=1) {
+            r = ini_rw(dic, "snmp:nms_ip",     psnmp->nms_ip,      sizeof(psnmp->nms_ip), TYPE_STR, op, 1); if(r) goto quit;
+            //}
+#if 0
             if(psnmp->version==2) {
                 r = ini_rw(dic, "snmp:crypt.user",          psnmp->crypt.user,        sizeof(psnmp->crypt.user),        TYPE_STR, op, 1); if(r) goto quit;
                 r = ini_rw(dic, "snmp:crypt.auth.proto",    psnmp->crypt.auth.alg,    sizeof(psnmp->crypt.auth.alg),    TYPE_STR, op, 1); if(r) goto quit;
@@ -1296,38 +1422,42 @@ static int proc_snmp(char *path, int op, SNMPManager *snmp)
 
                 r = ini_rw(dic, "snmp:crypt.priv.password", psnmp->crypt.priv.passwd, sizeof(psnmp->crypt.priv.passwd), TYPE_STR, op, 1); if(r) goto quit;
             }
-
+#endif
             r = proc_snmp(path, PARAS_CHECK, psnmp);
             if(r==0) {
+#if 0
                 //r = dev_clear_table(dm->db, TAB_ID_SNMP);  if(r) goto quit;
                 r = dev_update_snmp_info(dm->db, 0, psnmp);  if(r) goto quit;
 
                 extern int snmp_config(SNMPManager *m, int quit);
                 snmp_config(psnmp, 0);
+#endif
+						return 0;
             }
         }
         break;
 
         case PARAS_WRITE:
         {
-            char ver[32];
-
-            psnmp = &snmp2;
-            r = dev_get_snmp_info(dm->db, psnmp);    if(r) return -1;
+            //char ver[32];
+				
+            //psnmp = &snmp2;
+						dic = iniparser_load(path); if(!dic) return -1;
+            //r = dev_get_snmp_info(dm->db, psnmp);    if(r) return -1;
             r = proc_snmp(path, PARAS_CHECK, psnmp); if(r) return -1;
-            dic = dictionary_new(0);                 if(r) return -1;
+            //dic = dictionary_new(0);                 if(r) return -1;
             
             r = ini_rw(dic, "snmp:mode",     &psnmp->mode,     sizeof(psnmp->mode),    TYPE_INT, op, 1); if(r) goto quit;
-            r = ini_rw(dic, "snmp:public",   psnmp->public,    sizeof(psnmp->public),  TYPE_STR, op, 1); if(r) goto quit;
-
-            if(psnmp->version==0)       strcpy(ver, "V1");
-            else if(psnmp->version==1)  strcpy(ver, "V2c");
-            else if(psnmp->version==2)  strcpy(ver, "V3");
-            r = ini_rw(dic, "snmp:version",  ver,  sizeof(ver), TYPE_STR, op, 1); if(r) goto quit;
+            r = ini_rw(dic, "snmp:public",   psnmp->publics,    sizeof(psnmp->publics),  TYPE_STR, op, 1); if(r) goto quit;
 
-            r = ini_rw(dic, "snmp:trap_mode",  &psnmp->trapmode,  sizeof(ver), TYPE_INT, op, 1); if(r) goto quit;
-            r = ini_rw(dic, "snmp:nms_ip",     psnmp->nmsIP,      sizeof(ver), TYPE_STR, op, 1); if(r) goto quit;
+           //if(psnmp->version==0)       strcpy(ver, "V1");
+           //else if(psnmp->version==1)  strcpy(ver, "V2c");
+           // else if(psnmp->version==2)  strcpy(ver, "V3");
+            r = ini_rw(dic, "snmp:version",  &psnmp->version,  sizeof(psnmp->version), TYPE_INT, op, 1); if(r) goto quit;
 
+            r = ini_rw(dic, "snmp:trap_mode",  &psnmp->trapmode,  sizeof(psnmp->trapmode), TYPE_INT, op, 1); if(r) goto quit;
+            r = ini_rw(dic, "snmp:nms_ip",     psnmp->nms_ip,      sizeof(psnmp->nms_ip), TYPE_STR, op, 1); if(r) goto quit;
+#if 0
             if(psnmp->version==2) {
                 r = ini_rw(dic, "snmp:crypt.user",          psnmp->crypt.user,        sizeof(psnmp->crypt.user),        TYPE_STR, op, 1); if(r) goto quit;
                 r = ini_rw(dic, "snmp:crypt.auth.proto",    psnmp->crypt.auth.alg,    sizeof(psnmp->crypt.auth.alg),    TYPE_STR, op, 1); if(r) goto quit;
@@ -1339,18 +1469,21 @@ static int proc_snmp(char *path, int op, SNMPManager *snmp)
                 r = ini_rw(dic, "snmp:crypt.priv.proto",    psnmp->crypt.priv.alg,    sizeof(psnmp->crypt.priv.alg),    TYPE_STR, op, 1); if(r) goto quit;
                 r = ini_rw(dic, "snmp:crypt.priv.password", psnmp->crypt.priv.passwd, sizeof(psnmp->crypt.priv.passwd), TYPE_STR, op, 1); if(r) goto quit;
             }
+
             r = ini_dump(path, dic);
+#endif
+						//iniparser_freedict(dic);
         }
         break;
 
         default:
         return -1;
     }
-
 quit:
-    iniparser_freedict(dic);
     return r;
 }
+
+#if 0
 static int proc_mqtt(char *path, int op, mqtt_info_t *mqtt)
 {
     char *p;
@@ -3383,6 +3516,10 @@ static dictionary* ini_load(char *path, paras_data_t *info)
     if(r) {
         LOGE("proc_net failed\n");
     }	
+		r = proc_snmp_n(dic, PARAS_READ, &info->snmp);
+		if(r){
+			LOGE("proc_snmp failed\n");
+		}
     return dic;
 }
 static int ini_check(char *path)
@@ -3464,7 +3601,14 @@ static int ini_reset(paras_handle_t *h)
 		fprintf(fp, "dns2      = \"%s\"\n", p->netwk.dns2);
     fprintf(fp, "\n");		
 		
-
+    fprintf(fp, "[snmp]\n");
+    fprintf(fp, "mode        = \"%d\"\n", p->snmp.mode);
+    fprintf(fp, "version     = \"%d\"\n", p->snmp.version);
+    fprintf(fp, "public      = \"%s\"\n", p->snmp.publics);
+    fprintf(fp, "trap_mode   = \"%d\"\n", p->snmp.trapmode);
+    fprintf(fp, "nms_ip      = \"%s\"\n", p->snmp.nms_ip);	
+		fprintf(fp, "\n");	
+		
     fclose(fp);
     if(h->dic) {
         iniparser_freedict(h->dic);
@@ -3493,7 +3637,17 @@ static int ini_save(paras_handle_t *h)
         LOGE("___ini_w_modbus failed\n");
         return -1;
     }
-
+		
+		r= proc_net(h->dic, PARAS_WRITE, &h->paras.netwk);
+    if(r) {
+        LOGE("___ini_w_net failed\n");
+        return -1;
+    }		
+		r = proc_snmp_n(h->dic,PARAS_WRITE,&h->paras.snmp);
+    if(r) {
+        LOGE("___ini_w_snmp failed\n");
+        return -1;
+    }				
     FILE *fp=fopen(h->path, "w");
     if(!fp) {
         LOGE("___%s open failed\n", h->path);

f427/applications/power.c

@@ -1,7 +1,7 @@
 #include "mb.h"
 #include "cfg.h"
 #include "web.h"
-#include "lock.h"
+
 #include "list.h"
 #include "paras.h"
 #include "power.h"
@@ -12,25 +12,13 @@
 #define LIMIT_HOF(x)  (x*1.1f)
 #define LIMIT_LOF(x)  (x*0.9f)
 
-typedef struct {
-    lock_t          lck;
-    uint8_t         cur_addr;
-    
-    uint8_t         chs;                    //所有控制板的总通道数
-    power_ch_t      *pch[32];                  //动态指针
-    power_ch_t      ch0;
-    
-    uint8_t         cnt;                    //实际扫到的板子个数，不可大于POWER_
-    uint8_t         brd_max;
-    board_data_t    *pbrd[POWER_BOARD_MAX+1];       //通过modbus地址索引
-    
-    board_key_t     key[POWER_BOARD_MAX+1];
-    power_total_t   ttl;
-    uint8_t         flag[POWER_CH_MAX];
-    
-    product_data_t *prod;
-    power_all_t    all;
-}power_handle_t;
+static power_handle_t pwrHandle={0};
+static int write_reg(power_handle_t *h, uint8_t addr, uint16_t reg, uint16_t *data, int cnt);
+
+power_handle_t * get_power_handle(void)
+{
+	return &pwrHandle;
+}
 
 static int get_power(power_ch_t *pch)
 {
@@ -85,29 +73,90 @@ static int set_board(uint8_t addr, uint8_t on)
 {
     return power_set_board_sw(addr, on);
 }
-static int set_all(uint8_t on)
+static int set_all(uint16_t on,board_data_t *data)
 {
-    return power_set_all_sw(on);
+		
+    //return power_set_all_sw(on);
 }
 
 
-static board_fn_t board_fn={
-    .get_power = get_power,
-    .get_alarm = get_alarm,
-    .set_ch = set_ch,
-    .set_open_delay = set_open_delay,
-    .set_close_delay = set_close_delay,
-    .set_kb_value = set_kb_value,
-    .set_threshold = set_threshold,
-    .reset_consump = reset_consump,
-
-    .detect = do_detect,
-    .get_info = get_info,
-    //.get_board = get_board,
-    .set_board = set_board,
-    .set_all = set_all,
+int board_ac_all_status(uint16_t on_off,board_data_t *board)
+{
+	//power_handle_t *h=&pwrHandle;
+	power_handle_t *h=&pwrHandle;
+	uint16_t switch_ctrl[8] = {0};
+	lock_on(h->lck);
+  for (size_t i = 0; i < 8; i++)
+  {
+    switch_ctrl[i] = on_off;
+		if(on_off==1)
+		{
+			switch_ctrl[i] |= (1<<11);
+		}else
+		{
+			switch_ctrl[i] |= (1<<12);
+		}
+  }
+	write_reg(h, board->addr, POWER_AC_CH_STAT_L, &switch_ctrl[0], board->chs);
+	lock_off(h->lck);
+	return 0;
+}
+
+int board_dc_all_status(uint16_t on_off,board_data_t *board)
+{
+	//POWER_DC_ALL_OPEN_INFO
+	power_handle_t *h=&pwrHandle;
+	uint32_t val = on_off;
+	lock_on(h->lck);
+	if(on_off==1)
+	{
+		write_reg(h, board->addr, POWER_DC_ALL_OPEN_INFO, (uint16_t*)&val,2);
+	}else
+	{
+		val = 0;
+		write_reg(h, board->addr, POWER_DC_ALL_CLOSE_INFO, (uint16_t*)&val,2);
+	}
+	lock_off(h->lck);
+	return 0;
+}
+int board_ac3_all_status(uint16_t on_off,board_data_t *board)
+{
+	power_handle_t *h=&pwrHandle;
+	uint32_t val = on_off;
+	lock_on(h->lck);
+	if(on_off==1)
+	{
+		write_reg(h, board->addr, POWER_AC3_ALL_OPEN_INFO, (uint16_t*)&val,2);
+	}else
+	{
+		val = 0;
+		write_reg(h, board->addr, POWER_AC3_ALL_CLOSE_INFO, (uint16_t*)&val,2);
+	}
+	lock_off(h->lck);	
+}
+
+static board_fn_t board_fn_ac={
+//    .get_power = get_power,
+//    .get_alarm = get_alarm,
+//    .set_ch = set_ch,
+//    .set_open_delay = set_open_delay,
+//    .set_close_delay = set_close_delay,
+//    .set_kb_value = set_kb_value,
+//    .set_threshold = set_threshold,
+//    .reset_consump = reset_consump,
+
+//    .detect = do_detect,
+//    .get_info = get_info,
+//    //.get_board = get_board,
+//    .set_board = set_board,
+    .set_all = board_ac_all_status,
+};
+static board_fn_t board_fn_dc={
+    .set_all = board_dc_all_status,
+};
+static board_fn_t board_fn_ac3={
+    .set_all = board_ac3_all_status,
 };
-static power_handle_t pwrHandle={0};
 
 static int get_flag(power_handle_t *h, uint8_t ch, uint8_t thr)
 {
@@ -1133,8 +1182,18 @@ int power_scan(void)
                 return -1;
             }
             
-            pbrd->fn = board_fn;
+            //pbrd->fn = board_fn;
             pbrd->type = pkey->type;
+						if(pkey->type == 1 || pkey->type == 2)
+						{
+							pbrd->fn = board_fn_ac;
+						}else if(pkey->type == PDU_AC_I3O3)
+						{
+							pbrd->fn = board_fn_ac3;
+						}else 
+						{
+							pbrd->fn = board_fn_dc;
+						}
             pbrd->chs  = pkey->chs;
             pbrd->addr = i;
             pbrd->ch0 = ch_idx;
@@ -1917,6 +1976,44 @@ int power_set_open_delay(power_ch_t *pch)
     
     return r;
 }
+
+int power_set_clear_consumer(power_ch_t *pch)
+{
+	
+	int r=-1;
+  uint16_t tmp[2],reg,offset;
+  power_handle_t *h=&pwrHandle;  
+  lock_on(h->lck);
+	switch(pch->info.type) {
+	  case AC_SINGLE_S_TYPE:
+    case AC_SINGLE_B_TYPE:
+		{
+			uint16_t val = 1;
+			offset = POWER_AC_RESET_CONSUMP + pch->info.ch-1;
+			r = write_reg(h, pch->info.addr, offset, &val, 1);
+		}		
+		break;
+		case DCPDU_TYPE:
+		{
+			uint32_t val = 1;
+			offset = POWER_DC_CONSUMP_CLEAR + pch->info.ch-1;
+			r = write_reg(h, pch->info.addr, offset, (uint16_t*)&val, 1);
+		}
+		break;
+		case TREE_AC_TYPE:
+		{
+			uint32_t val = 1;
+			offset = POWER_AC3_RESET_CONSUMP + pch->info.ch-1;
+			r = write_reg(h, pch->info.addr, offset, (uint16_t*)&val, 1);			
+		}
+		break;		
+	}
+	lock_off(h->lck);
+	
+	return 0;
+}
+
+
 int power_set_close_delay(power_ch_t *pch)
 {
     int r=-1;

f427/applications/power.h

@@ -2,6 +2,7 @@
 #define __POWER_Hx__
 
 #include "datadef.h"
+#include "lock.h"
 
 #define POWER_AC_GET_INFO                         0x0FA0          //获取继电器板类型通道
 #define POWER_AC_CUR_INFO_L                       0x0FAB          //单相小电流继电器信息，共8路继电器
@@ -148,6 +149,28 @@ typedef struct {
 }kb_val_t;
 
 
+typedef struct {
+    lock_t          lck;
+    uint8_t         cur_addr;
+    
+    uint8_t         chs;                    //所有控制板的总通道数
+    power_ch_t      *pch[32];                  //动态指针
+    power_ch_t      ch0;
+    
+    uint8_t         cnt;                    //实际扫到的板子个数，不可大于POWER_
+    uint8_t         brd_max;
+    board_data_t    *pbrd[POWER_BOARD_MAX+1];       //通过modbus地址索引
+    
+    board_key_t     key[POWER_BOARD_MAX+1];
+    power_total_t   ttl;
+    uint8_t         flag[POWER_CH_MAX];
+    
+    product_data_t *prod;
+    power_all_t    all;
+}power_handle_t;
+
+
+
 int power_init(void);
 int power_deinit(void);
 
@@ -170,5 +193,9 @@ int power_reset(void);
 power_all_t * power_get_all(void);
 int power_data_get(power_all_t *all);
 int power_breaker_get(breaker_all_t *all);
+
+power_handle_t * get_power_handle(void);
+int power_set_clear_consumer(power_ch_t *pch);
+
 #endif
 

f427/applications/snmp.c

@@ -18,7 +18,7 @@
 
 
 
-#define SNMP_SMARTPDU_OID 										{1,3,6,1,4,1,2024}
+#define SNMP_SMARTPDU_OID 										{1,3,6,1,2,1,1}
 #define SNMP_SMARTPDU_DEVICE_OID							{1,3,6,1,4,1,2024,1}
 //#define SNMP_SMARTPDU_CHANNEL_TABLE           {1,3,6,1,4,1,2024,1,3,9}
 //#define SNMP_SMARTPDU_ALARM_TABLE_IOD       	{1,3,6,1,4,1,2024,1,6,1}
@@ -39,20 +39,20 @@ typedef struct
 //	power_all_t all;
 }snmp_smarpdu_t;
 
-static snmp_smarpdu_t snmp_smart={
-		.sysdescr={"Smart_pdu"},
-		.syscontact={"KyKy"},
-		.sysname={"Rt"},
-		.syslocation={"CN"},
-		.device_enterprose_oid={
-			.len = 7,
-			.id = SNMP_SMARTPDU_OID,
-		},
-//		.id_manifacture = "Gowone Industry",
-//		.id_device = "Smart_PDU",
-//		.id_sn = "SN123465",
-//		.id_version = "v1.0.0.0",
-};
+//static snmp_smarpdu_t snmp_smart={
+//		.sysdescr={"Smart_pdu"},
+//		.syscontact={"KyKy"},
+//		.sysname={"Rt"},
+//		.syslocation={"CN"},
+//		.device_enterprose_oid={
+//			.len = 7,
+//			.id = SNMP_SMARTPDU_OID,
+//		},
+////		.id_manifacture = "Gowone Industry",
+////		.id_device = "Smart_PDU",
+////		.id_sn = "SN123465",
+////		.id_version = "v1.0.0.0",
+//};
 
 
 
@@ -391,7 +391,7 @@ static thr_d_t p_t_data[POWER_VALUE]=
 	},
 };
 
-static int thr_s_get_info(struct snmp_node_instance *instance, void *value)
+static s16_t thr_s_get_info(struct snmp_node_instance *instance, void *value)
 {
 	  u32_t row = instance->reference.u32;
     u32_t col = SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id);
@@ -413,10 +413,50 @@ static int thr_s_get_info(struct snmp_node_instance *instance, void *value)
 				break;
 			case COLUMN_PDUSENSORTYPE:
 			{
-				
+				sprintf(buff,"%d",sensor->data[row-1].info.type);
+			}
+			break;
+			case COLUMN_PDUSENSORDATACHENNEL:
+			{
+				sprintf(buff,"%d",sensor->data[row-1].info.num_val);
+			}
+			break;
+			case COLUMN_PDUSENSORMODBUSADDRESS:
+			{
+				//sprintf(buff,"%d",sensor->data[row-1].info.addr);
+				*(s32_t *)value = sensor->data[row-1].info.addr;
+				return 4;
+			}
+			break;
+			case COLUMN_PDUSENSORSTATUS:
+			{
+				//sprintf(buff,"%d",sensor->data[row-1].info.status);
+				*(s32_t *)value = sensor->data[row-1].info.status;
+				return 4;
+			}
+			break;
+			case COLUMN_PDUSENSORVALUENUM:
+			{
+				//sprintf(buff,"%d",sensor->data[row-1].info.num_val);
+				*(s32_t *)value = sensor->data[row-1].info.num_val;
+				return 4;
 			}
+			break;
+			case COLUMN_PDUSENSORVALUE1:
+			{
+				sprintf(buff,"%.2f",sensor->data[row-1].val[0].value);
+			}
+			break;
+			case COLUMN_PDUSENSORVALUE2:
+			{
+				sprintf(buff,"%.2f",sensor->data[row-1].val[1].value);
+			}
+			break;
+			default:
+				break;
 		}
-	
+		memcpy(value,buff,strlen(buff));
+    return strlen(buff);
 	
 }
 
@@ -761,6 +801,91 @@ static snmp_err_t get_next_instance(const u32_t *column, struct snmp_obj_id *row
     return SNMP_ERR_NOSUCHINSTANCE;
 }
 
+static s16_t alarm_power_get(struct snmp_node_instance *instance, void *value)
+{
+		power_all_t *all = power_get_all();
+    u32_t row = instance->reference.u32;
+    u32_t col = SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id);
+		switch (col)
+		{
+			case COLUMN_PDUCHANNELPOWERALARMID:
+			{
+				*(s32_t *)value	= row-1;
+			}
+			break;
+			case COLUMN_PDUCHANNELPOWERALARMVOLTAGEUP:
+			{
+				*(s32_t *)value	= all->pch[row-1].alarm.v_upper;
+			}
+			break;
+			case COLUMN_PDUCHANNELPOWERALARMVOLTAGEDOWN:
+			{
+				*(s32_t *)value	= all->pch[row-1].alarm.v_lower;
+			}
+			break;
+			case COLUMN_PDUCHANNELPOWERALARMCURRENTUP:
+			{
+				*(s32_t *)value	= all->pch[row-1].alarm.c_upper;
+			}
+			break;		
+			case COLUMN_PDUCHANNELPOWERALARMPOWERUP:
+			{
+				*(s32_t *)value	= all->pch[row-1].alarm.p_upper;
+			}
+			break;		
+			case COLUMN_PDUCHANNELPOWERALARMCONSUMPTIONUP:
+			{
+				*(s32_t *)value	= all->pch[row-1].alarm.w_upper;
+			}
+			break;	
+			default:
+					return 0;
+		}
+	
+		return 4;
+}
+
+static s16_t alarm_sensor_get(struct snmp_node_instance *instance, void *value)
+{
+		sensor_all_t *sensor = sensor_get_data();
+    u32_t row = instance->reference.u32;
+    u32_t col = SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id);
+		switch (col)
+		{
+			case COLUMN_PDUSENSORALARMID:
+			{
+				*(s32_t *)value	= row-1;
+			}
+			break;
+			case COLUMN_PDUSENSORALARMVALUE1UP:
+			{
+				*(s32_t *)value	= sensor->data[row-1].val[0].s_alarm.max_up;
+			}
+			break;
+			case COLUMN_PDUSENSORALARMVALUE1DOWN:
+			{
+				*(s32_t *)value	= sensor->data[row-1].val[0].s_alarm.min_down;
+			}
+			break;
+			case COLUMN_PDUSENSORALARMVALUE2UP:
+			{
+				*(s32_t *)value	=  sensor->data[row-1].val[1].s_alarm.max_up;
+			}
+			break;	
+			case COLUMN_PDUSENSORALARMVALUE2DOWN:
+			{
+				*(s32_t *)value	= sensor->data[row-1].val[0].s_alarm.min_down;
+			}
+			break;
+			default:
+					return 0;
+		}
+	
+		return 4;
+}
+
+
+
 static s16_t power_get_value(struct snmp_node_instance *instance, void *value)
 {
 		power_all_t *all = power_get_all();
@@ -951,6 +1076,28 @@ static const struct snmp_table_col_def alarm_history_table[]={
 	{0,0,0},
 };
 
+
+static const struct snmp_table_col_def alarm_power_table[]={
+	{COLUMN_PDUCHANNELPOWERALARMID,										SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUCHANNELPOWERALARMVOLTAGEUP,						SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUCHANNELPOWERALARMVOLTAGEDOWN,					SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUCHANNELPOWERALARMCURRENTUP,						SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUALARMACTIONPARA,												SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUCHANNELPOWERALARMPOWERUP,							SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUCHANNELPOWERALARMCONSUMPTIONUP,				SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{0,0,0},
+};
+
+
+static const struct snmp_table_col_def alarm_sensor_table[]={
+	{COLUMN_PDUSENSORALARMID,								  SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUSENSORALARMVALUE1UP,						SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUSENSORALARMVALUE1DOWN,					SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUSENSORALARMVALUE2UP,						SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUSENSORALARMVALUE2DOWN,					SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{0,0,0},
+};
+
 static const struct snmp_table_col_def threshold_limit_table[] = {
 	{COLUMN_PDUCHANNELLIMITID,								SNMP_ASN1_TYPE_INTEGER,               SNMP_NODE_INSTANCE_READ_ONLY},
 	{COLUMN_PDUCHANNELLIMITNAME,							SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
@@ -1019,8 +1166,7 @@ static s16_t get_total_scalar_value(struct snmp_node_instance *instance , void*
 		default:
 			return 0;
 	}
-	memcpy(data,buff,strlen(buff));
-		
+	 memcpy(data,buff,strlen(buff));
    return strlen(buff);	
 }
 
@@ -1052,18 +1198,21 @@ static const struct snmp_table_node thr_s_table = SNMP_TABLE_CREATE(1, sensor_li
 							thr_s_get_value, set_test, thr_s_set_value);
 
 
-static const struct snmp_table_node  sensor_table = SNMP_TABLE_CREATE(4,sensor_info_table,get_sensor_instance,get_sensor_next_instance,NULL,NULL,NULL);
-
-
-
-
+static const struct snmp_table_node  sensor_table = SNMP_TABLE_CREATE(1,sensor_info_table,get_sensor_instance,get_sensor_next_instance,\
+							thr_s_get_info,set_test,thr_s_set_value);
 
+static const struct snmp_table_node  alarm_p_table = SNMP_TABLE_CREATE(2,alarm_power_table,power_get_instance,power_get_next_instance,\
+							alarm_power_get,NULL,NULL);
 
+static const struct snmp_table_node  alarm_s_table = SNMP_TABLE_CREATE(3,alarm_sensor_table,get_sensor_instance,get_sensor_next_instance,\
+							alarm_sensor_get,NULL,NULL);
 
 
 
 static const struct snmp_node *const alarm_subnodes[]={
 	&alarm_table.node.node,
+	&alarm_p_table.node.node,
+	&alarm_s_table.node.node
 };
 static const struct snmp_node *const power_subnodes[] = {
     &power_table.node.node,
@@ -1132,6 +1281,96 @@ static const struct snmp_mib *dev_mibs[] = {&mib2, &mib2_dev,&mib2_th_dev};
 
 
 
+void snmp_power_alarm_trap(AlarmTrapinfo *data)
+{
+		struct snmp_varbind vb={0},vb1={0},vb2={0},vb3={0};
+		int a= 1,b=2,c=3;
+
+		const u32_t oid_1[]={1,3,6,1,4,1,2024,2,1};
+		const u32_t pduAlarmID_oid[] = { 1,3,6,1,4,1,2024,1,6,1,1,2,data->ID};
+    const u32_t pduAlarmContext_oid[] = { 1,3,6,1,4,1,2024,1,6,1,1,3,data->ID};
+    const u32_t pduAlarmDate_oid[] = { 1,3,6,1,4,1,2024,1,6,1,1,6,data->ID};
+	
+		snmp_oid_assign(&vb.oid, oid_1, LWIP_ARRAYSIZE(oid_1));
+		snmp_oid_assign(&vb1.oid, pduAlarmID_oid, LWIP_ARRAYSIZE(pduAlarmID_oid));
+		snmp_oid_assign(&vb2.oid, pduAlarmContext_oid, LWIP_ARRAYSIZE(pduAlarmContext_oid));
+		snmp_oid_assign(&vb3.oid, pduAlarmDate_oid, LWIP_ARRAYSIZE(pduAlarmDate_oid));
+		
+    vb.type = SNMP_ASN1_TYPE_OBJECT_ID;
+    vb.value = (void*)&a;
+    vb.value_len = 4;
+		
+	  vb1.type = SNMP_ASN1_TYPE_INTEGER;
+    vb1.value = (void*)&data->Alarmid;
+    vb1.value_len = 4;	
+		
+	  vb2.type = SNMP_ASN1_TYPE_OCTET_STRING;
+    vb2.value = (void*)&data->AlarmContext;
+    vb2.value_len = strlen(data->AlarmContext);	
+		
+	  vb3.type = SNMP_ASN1_TYPE_OCTET_STRING;
+    vb3.value = (void*)&data->AlarmDate;
+    vb3.value_len = strlen(data->AlarmDate);	
+		
+		vb.next = &vb1;
+		vb1.next = &vb2;
+		vb2.next = &vb3;
+		vb3.prev = &vb2;
+		vb2.prev = &vb1;
+		vb1.prev = &vb;		
+		
+    snmp_send_trap_specific(SNMP_GENTRAP_COLDSTART, &vb);
+//		snmp_send_trap_specific(SNMP_GENTRAP_COLDSTART, &vb1);
+//		snmp_send_trap_specific(SNMP_GENTRAP_COLDSTART, &vb2);
+//		snmp_send_trap_specific(SNMP_GENTRAP_COLDSTART, &vb3);
+
+}
+
+void snmp_sensor_alarm_trap(AlarmTrapinfo *data)
+{
+		struct snmp_varbind vb={0},vb1={0},vb2={0},vb3={0};
+		int a= 1,b=2,c=3;
+
+		const u32_t oid_1[]={1,3,6,1,4,1,2024,2,2};
+    const u32_t pduAlarmID_oid[] = { 1,3,6,1,4,1,2024,1,6,1,1,2, data->ID};
+    const u32_t pduAlarmContext_oid[] = { 1,3,6,1,4,1,2024,1,6,1,1,3, data->ID};
+    const u32_t pduAlarmDate_oid[] = { 1,3,6,1,4,1,2024,1,6,1,1,6,data->ID};
+	
+		snmp_oid_assign(&vb.oid, oid_1, LWIP_ARRAYSIZE(oid_1));
+		snmp_oid_assign(&vb1.oid, pduAlarmID_oid, LWIP_ARRAYSIZE(pduAlarmID_oid));
+		snmp_oid_assign(&vb2.oid, pduAlarmContext_oid, LWIP_ARRAYSIZE(pduAlarmContext_oid));
+		snmp_oid_assign(&vb3.oid, pduAlarmDate_oid, LWIP_ARRAYSIZE(pduAlarmDate_oid));
+		
+    vb.type = SNMP_ASN1_TYPE_OBJECT_ID;
+    vb.value = (void*)&a;
+    vb.value_len = 4;
+		
+	  vb1.type = SNMP_ASN1_TYPE_INTEGER;
+    vb1.value = (void*)&data->Alarmid;
+    vb1.value_len = 4;	
+		
+	  vb2.type = SNMP_ASN1_TYPE_OCTET_STRING;
+    vb2.value = (void*)&data->AlarmContext;
+    vb2.value_len = strlen(data->AlarmContext);	
+		
+	  vb3.type = SNMP_ASN1_TYPE_OCTET_STRING;
+    vb3.value = (void*)&data->AlarmDate;
+    vb3.value_len = strlen(data->AlarmDate);	
+		
+		vb.next = &vb1;
+		vb1.next = &vb2;
+		vb2.next = &vb3;
+		vb3.prev = &vb2;
+		vb2.prev = &vb1;
+		vb1.prev = &vb;		
+		
+    snmp_send_trap_specific(SNMP_GENTRAP_COLDSTART, &vb);	
+}
+
+
+
+
+//MSH_CMD_EXPORT_ALIAS(cmd_snmp_tarp_test, snmp, snmp agent test);
 
 
 
@@ -1141,41 +1380,91 @@ void netif_event_callback(struct netif *netif) {
 }
 
 static void mibs_init(void) {
-		uint16_t len = 0;
-		len= strlen((const char *)snmp_smart.sysdescr);
-    snmp_mib2_set_sysdescr(snmp_smart.sysdescr, &len);
-	
-		len= strlen((const char *)snmp_smart.syscontact);
-    snmp_mib2_set_syscontact(snmp_smart.syscontact, &len, 0);
-	
-		len= strlen((const char *)snmp_smart.sysname);
-    snmp_mib2_set_sysname(snmp_smart.sysname, &len, 0);
-	
-		len= strlen((const char *)snmp_smart.syslocation);
-    snmp_mib2_set_syslocation(snmp_smart.syslocation, &len, 0);	
-	
-	  snmp_set_device_enterprise_oid(&snmp_smart.device_enterprose_oid);
+			paras_data_t *para = paras_get();
+//		uint16_t len = 0;
+//		len= strlen((const char *)snmp_smart.sysdescr);
+//    snmp_mib2_set_sysdescr(snmp_smart.sysdescr, &len);
+//	
+//		len= strlen((const char *)snmp_smart.syscontact);
+//    snmp_mib2_set_syscontact(snmp_smart.syscontact, &len, 0);
+//	
+//		len= strlen((const char *)snmp_smart.sysname);
+//    snmp_mib2_set_sysname(snmp_smart.sysname, &len, 0);
+//	
+//		len= strlen((const char *)snmp_smart.syslocation);
+//    snmp_mib2_set_syslocation(snmp_smart.syslocation, &len, 0);	
+//	
+//	  snmp_set_device_enterprise_oid(&snmp_smart.device_enterprose_oid);
     snmp_set_auth_traps_enabled(SNMP_AUTH_TRAPS_DISABLED);
-	
-    snmp_trap_dst_enable(0, 0);
-    //snmp_trap_dst_ip_set(0, &test_snmp_trap_ip);	
+		snmp_strap_set();
+//		if(para->snmp.trapmode == 1)
+//		{
+//			ip_addr_t  ip_addr={0};
+//			if(ipaddr_aton(para->snmp.nms_ip,&ip_addr) == 0)
+//			{
+//				snmp_trap_dst_enable(0, 1);
+//				snmp_trap_dst_ip_set(0, &ip_addr);
+//			}else
+//			{
+//				LOG_E("snmp trap ip error!!!!\n");
+//				snmp_trap_dst_enable(0, 0);
+//			}
+//		}else
+//		{
+//			snmp_trap_dst_enable(0, 0);
+//		}
 
     snmp_set_mibs(&dev_mibs[0], LWIP_ARRAYSIZE(dev_mibs));
     snmp_set_community("public");
-    snmp_set_community_write("public");	
+		if(strncmp(para->snmp.publics,"public",strlen("public")))
+		{
+			snmp_set_community_write("public");	
+		}else
+		{
+			snmp_set_community_write("private");	
+		}
+		
+		//snmp_send_trap_specific();
 }
 
 int snmp2_init(void)
 {
-	
+
 	mibs_init();
   snmp_init();
-
-    
     return 0;
 }
 
 
+
+
+
+
+void snmp_strap_set(void)
+{
+		paras_data_t* para=paras_get();
+		if(para->snmp.trapmode == 1)
+		{
+			ip_addr_t  ip_addr={0};
+			if(ipaddr_aton(para->snmp.nms_ip,&ip_addr))
+			{
+				snmp_trap_dst_enable(0, 1);
+				snmp_trap_dst_ip_set(0, &ip_addr);
+			}else
+			{
+				LOG_E("snmp trap ip error!!!!\n");
+				snmp_trap_dst_enable(0, 0);
+			}
+		}else
+		{
+			snmp_trap_dst_enable(0, 0);
+		}
+}
+
+
+
+
+
 int snmp2_deinit(void)
 {
     

f427/applications/snmp.h

@@ -74,21 +74,36 @@
 			#define   SCALAR_REACTIVE_POWER						6
 			#define   SCALAR_APPARENT_POWER           7
 			 
-			
-       #define COLUMN_PDUSENSORID		1
-       #define COLUMN_PDUSENSORNAME		2
-       #define COLUMN_PDUSENSORTYPE		3
-       #define COLUMN_PDUSENSORDATACHENNEL		4
-       #define COLUMN_PDUSENSORMODBUSADDRESS		5
-       #define COLUMN_PDUSENSORSTATUS		7
-       #define COLUMN_PDUSENSORVALUENUM		8
-       #define COLUMN_PDUSENSORVALUE1		9
-       #define COLUMN_PDUSENSORVALUE2		10			 
+       #define COLUMN_PDUCHANNELPOWERALARMID		1    
+       #define COLUMN_PDUCHANNELPOWERALARMVOLTAGEUP		2    
+       #define COLUMN_PDUCHANNELPOWERALARMVOLTAGEDOWN		3    
+       #define COLUMN_PDUCHANNELPOWERALARMCURRENTUP		4     
+       #define COLUMN_PDUCHANNELPOWERALARMPOWERUP		5    
+       #define COLUMN_PDUCHANNELPOWERALARMCONSUMPTIONUP		6  
 			 
+       #define COLUMN_PDUSENSORALARMID		1    
+       #define COLUMN_PDUSENSORALARMVALUE1UP		2    
+       #define COLUMN_PDUSENSORALARMVALUE1DOWN		3    
+       #define COLUMN_PDUSENSORALARMVALUE2UP		4     
+       #define COLUMN_PDUSENSORALARMVALUE2DOWN		5    
+
+
+			 
+typedef struct AlarmTrapinfo{
+    uint32_t    Alarmid;
+    uint32_t    ID;
+    char            AlarmContext[64];
+    char            AlarmDate[36];
+}AlarmTrapinfo;			 
+
+
+
 
 int snmp2_init(void);
 int snmp2_deinit(void);
-
+void snmp_strap_set(void);
+void snmp_power_alarm_trap(AlarmTrapinfo *data);
+void snmp_sensor_alarm_trap(AlarmTrapinfo *data);
 
 #endif
 

f427/applications/ui/menu.c

@@ -216,7 +216,7 @@ static void menu_system_paint(menu_handle_t *h, int font1, int font2, int item_h
     lcd_draw_string(10, item_h*3, LCD_WIDTH-10, item_h, tmp, font2, COLOR_WHITE, COLOR_BLACK, HORIZONTAL_LEFT, VERTICAL_CENTER);
 		
 		
-    sprintf(tmp, "IP:%s", RT_LWIP_IPADDR);//getLocalIpAddress("e0"));
+    sprintf(tmp, "IP:%s", h->m_net.n_bak.ipaddr);//getLocalIpAddress("e0"));
     lcd_draw_string(10, item_h*4, LCD_WIDTH-10, item_h, tmp, font2, COLOR_WHITE, COLOR_BLACK, HORIZONTAL_LEFT, VERTICAL_CENTER);
     //lcd_refresh();
 }
@@ -272,9 +272,25 @@ static void menu_output_paint(menu_handle_t *h, int font1, int font2, int item_h
     sprintf(tmp, "%s", lang_get_str(h->lang, STR_ID_OUTPUT));
 
     //r = get_output(h, h->ch_out, h->ph_out, &info);
+		if(!all)
+		{
+			lcd_draw_string(0, 0, LCD_WIDTH, item_h, tmp, font1, COLOR_WHITE, COLOR_BLACK, HORIZONTAL_CENTER, VERTICAL_CENTER);
+			return;
+		}
+		
     if(h->ch_out_max>0) {
         sprintf(tmp, "%s CH%d", lang_get_str(h->lang, STR_ID_OUTPUT), h->ch_out+1);
-    }
+    }else
+		{
+			lcd_draw_string(0, 0, LCD_WIDTH, item_h, tmp, font1, COLOR_WHITE, COLOR_BLACK, HORIZONTAL_CENTER, VERTICAL_CENTER);
+			sprintf(tmp, "%s:%s  %s:0.00", lang_get_str(h->lang, STR_ID_SWITCH), lang_get_str(h->lang, STR_ID_OFF), lang_get_str(h->lang, STR_ID_CURRENT));
+			lcd_draw_string(0, item_h, LCD_WIDTH, item_h, tmp, font2, COLOR_WHITE, COLOR_BLACK, HORIZONTAL_LEFT, VERTICAL_CENTER);
+			sprintf(tmp, "%s:.0.00 %s:0.00", lang_get_str(h->lang, STR_ID_POWER), lang_get_str(h->lang, STR_ID_FACTOR));
+			lcd_draw_string(0, item_h*2, LCD_WIDTH, item_h, tmp, font2, COLOR_WHITE, COLOR_BLACK, HORIZONTAL_LEFT, VERTICAL_CENTER);
+			sprintf(tmp, "%s:0.00", lang_get_str(h->lang, STR_ID_CONSUMP));
+			lcd_draw_string(0, item_h*3, LCD_WIDTH, item_h, tmp, font2, COLOR_WHITE, COLOR_BLACK, HORIZONTAL_LEFT, VERTICAL_CENTER);
+			return;
+		}
 
     //lcd_fill(COLOR_BLACK);
     lcd_draw_string(0, 0, LCD_WIDTH, item_h, tmp, font1, COLOR_WHITE, COLOR_BLACK, HORIZONTAL_CENTER, VERTICAL_CENTER);
@@ -843,7 +859,7 @@ static int menu_net_key_handle(menu_handle_t *h, key_val_t *kv)
     int r=-1;
 	
     if(h->menu.menu_lv==0) {
-        h->m_net.n_bak = paras_get()->netwk;
+      //h->m_net.n_bak = paras_get()->netwk;
 			/// get new ip 
 			net_get_ip(&h->m_net.n_bak);
     }
@@ -966,9 +982,12 @@ static int menu_net_key_handle(menu_handle_t *h, key_val_t *kv)
 					if(h->menu.page[h->menu.menu_id].item_id==NET_ITEM_SAVE || h->menu.page[h->menu.menu_id].item_id==NET_ITEM_QUIT) {
 						if(h->menu.page[h->menu.menu_id].item_id==NET_ITEM_SAVE) {
 							//save net data
-							paras_get()->netwk = h->m_net.n_bak;
-							paras_save();
+							sprintf(h->m_net.n_bak.dns1,"8.8.8.8");
+							sprintf(h->m_net.n_bak.dns2,"114.114.114.114");
 							net_ipaddr_set(&h->m_net.n_bak);
+//							paras_get()->netwk = h->m_net.n_bak;
+//							paras_save();
+							
 						}
 						h->menu.page[h->menu.menu_id].item_id = 0;
             h->menu.menu_lv = 0;
@@ -1252,6 +1271,7 @@ static int menu_key_handle(menu_handle_t *h, key_val_t *kv)
         case MENU_SYSTEM:
         {
             if(h->menu.menu_lv==0) {
+								net_get_ip(&h->m_net.n_bak);
                 if(h->uflag&UFLAG_FLIP || ((kv->key==KEY_UP || kv->key==KEY_DOWN) && kv->type==TYPE_SHORT)) {
                     if(kv->key==KEY_UP) {
                         h->menu.menu_id = h->menu.menu_id?(h->menu.menu_id-1):MENU_MAX-1;

f427/applications/web.c

@@ -13,6 +13,8 @@
 #include <stdio.h>
 #include "datadef.h"
 #include "cascade.h"
+#include "snmp.h"
+#include "net.h"
 
 #define TIMER_INTERVAL      1000
 #define ONCE_SEND_CNT       13
@@ -125,7 +127,7 @@ static int ws_send_pkt(web_handle_t *h, mg_conn_t *c, uint8_t addr, uint8_t type
 
 static void send_powerc(web_handle_t *h, mg_conn_t *c, uint8_t addr)
 {
-    int i,j,xlen,offset,times,left;
+    int i=0,j,xlen,offset,times,left;
     pkt_hdr_t *hdr=NULL;
     power_all_t all;
     
@@ -145,27 +147,44 @@ static void send_powerc(web_handle_t *h, mg_conn_t *c, uint8_t addr)
     hdr->addr  = addr;
     hdr->type  = PKT_TYPE_POWER_CH;
     hdr->nack  = 0;
+		int count = all.chs;
+		int bag = 0;
+		
 
 #if 1  
-    times = all.chs/ONCE_SEND_CNT;
-    for(i=0; i<times; i++) {
-        for(j=0; j<ONCE_SEND_CNT; j++) {
-            offset = j*sizeof(power_ch_t);
-            memcpy(hdr->data+offset, &all.pch[i*ONCE_SEND_CNT+j], sizeof(power_ch_t));
-        }
-        xlen = ONCE_SEND_CNT*sizeof(power_ch_t)+sizeof(pkt_hdr_t);
-        hdr->dlen  = xlen-sizeof(pkt_hdr_t);
-        ws_send(c, h->buf, xlen, 1);
-    }
-    
-//    left = all.chs%ONCE_SEND_CNT;
-//    for(i=0; i<left; i++) {
-//        offset = i*sizeof(power_ch_t);
-//        memcpy(hdr->data+offset, &all.pch[all.chs-left+i], sizeof(power_ch_t));
-//    }
-//    xlen = (all.chs%ONCE_SEND_CNT)*sizeof(power_ch_t)+sizeof(pkt_hdr_t);
-//    hdr->dlen  = xlen-sizeof(pkt_hdr_t);
-//    ws_send(c, h->buf, xlen, 1);
+	
+		do{
+			bag ++;
+			if(count < ONCE_SEND_CNT)
+			{
+				for(j=0;j<count;j++)
+				{
+					offset = j*sizeof(power_ch_t);
+					memcpy(hdr->data+offset, &all.pch[i*ONCE_SEND_CNT+j],sizeof(power_ch_t));
+					hdr->flag = (-1);
+				}
+				xlen = sizeof(power_ch_t) * count + sizeof(pkt_hdr_t);
+				hdr->dlen  = xlen-sizeof(pkt_hdr_t);
+				i += count;
+				count -= count;
+			}else
+			{
+				for(j=0;j<ONCE_SEND_CNT;j++)
+				{
+					offset = j*sizeof(power_ch_t);
+					memcpy(hdr->data+offset, &all.pch[i*ONCE_SEND_CNT+j],sizeof(power_ch_t));
+				}
+				xlen = sizeof(power_ch_t) * ONCE_SEND_CNT + sizeof(pkt_hdr_t);
+				hdr->dlen  = xlen-sizeof(pkt_hdr_t);
+				count -= ONCE_SEND_CNT;
+				hdr->flag = bag;
+				i += ONCE_SEND_CNT;
+			}
+			
+
+			ws_send(c, h->buf, xlen, 1);
+		}while(count > 0);
+		
 #endif
 }
 static void send_powert(web_handle_t *h, mg_conn_t *c, uint8_t addr)
@@ -258,6 +277,33 @@ static void send_breaker(web_handle_t *h, mg_conn_t *c, uint8_t addr)
     
     breaker_data_free(&all);
 }
+
+static void sendntp(web_handle_t *h, mg_conn_t *c)
+{
+	time_t t=time(NULL);
+  struct tm *tm=localtime(&t);
+	char date[40] = {0};
+	char _time[40] = {0};
+	snprintf(date, 40, "%04d%/%02d/%02d", (tm->tm_year+1900), tm->tm_mon+1, tm->tm_mday);
+	snprintf(_time, 40, "%04d%:%02d:%02d", tm->tm_hour, tm->tm_min, tm->tm_sec);
+	paras_data_t* para=paras_get();
+	pkt_hdr_t *hdr=NULL;
+	hdr->magic = PKT_MAGIC;
+  hdr->addr  = 0;
+  hdr->type  = PKT_TYPE_PARAS;
+  hdr->nack  = 0;
+	hdr->subtype = SUB_TYPE_PARAS_SYS;
+	
+	system_data_t data = {0};
+	data.lang = para->sys.lang;
+	data.tzone = para->sys.tzone;
+	sprintf(data.sys_time,"%s %s",date,_time);
+	
+	memcpy(hdr->data, &data, sizeof(system_data_t));
+	hdr->dlen  = sizeof(system_data_t);
+	ws_send(c, h->buf, hdr->dlen, 1);
+}
+
 static void send_dlist(web_handle_t *h, mg_conn_t *c)
 {
     int i,j=0,r;
@@ -306,6 +352,7 @@ static int ws_handle(web_handle_t *h, pkt_hdr_t *hdr, mg_conn_t *c)
                 
                 case SUB_TYPE_PARAS_SYS:
                 {
+									if(hdr->dlen>0) {
                     system_data_t *sys=(system_data_t*)hdr->data;
                     if(sys->lang<LANG_ID_MAX && sys->lang!=para->sys.lang) {
                         para->sys.lang = sys->lang;
@@ -314,19 +361,35 @@ static int ws_handle(web_handle_t *h, pkt_hdr_t *hdr, mg_conn_t *c)
                         para->sys.tzone = sys->tzone;
                         rt_tz_set(para->sys.tzone*3600);
                     }
-                    
+										char str[32] = {0};
+										int lenth = strlen(sys->sys_time);
+										for(int i = 0; i < lenth;i++)
+										{
+											if(sys->sys_time[i] <'0' || sys->sys_time[i] > '9')
+											{
+												sys->sys_time[i]=' ';
+											}
+										}
+										sprintf(str,"date %s",sys->sys_time);
+                    system(str);
+										
                     if(flag) {
                         paras_save();
                     }
+									}else
+									{
+										sendntp(h, c);
+									}
                 }
                 break;
                 
                 case SUB_TYPE_PARAS_MODBUS:
                 {
-//                    modbus_data_t *p=(modbus_data_t*)hdr->data;
+                    modbus_data_t *p=(modbus_data_t*)hdr->data;
 //                    cascade_reinit(p->mode, p->addr, p->baud);
 //                    para->cas = *p;
 //                    paras_save();
+									cascade_reset(p->mode,p->addr);
                 }
                 break;
                 
@@ -358,12 +421,29 @@ static int ws_handle(web_handle_t *h, pkt_hdr_t *hdr, mg_conn_t *c)
                 case SUB_TYPE_PARAS_NETWORK:
                 {
                     network_data_t *p=(network_data_t*)hdr->data;
-                    extern void set_dns(uint8_t dns_num, char* dns_server);
-                    extern void set_if(char* netif_name, char* ip_addr, char* gw_addr, char* nm_addr);
-                    set_if("e0", p->ipaddr, p->gateway, p->mask);
-                    set_dns(0, p->dns1); set_dns(1, p->dns2);
+										paras_data_t *para = paras_get();
+										net_ipaddr_set(p);
+										para->netwk = *p;
+										paras_save();
+//                    extern void set_dns(uint8_t dns_num, char* dns_server);
+//                    extern void set_if(char* netif_name, char* ip_addr, char* gw_addr, char* nm_addr);
+//                    set_if("e0", p->ipaddr, p->gateway, p->mask);
+//                    set_dns(0, p->dns1); 
+//									  set_dns(1, p->dns2);
+										
                 }
                 break;
+								case SUB_TYPE_PARAS_SNMP:
+								{
+									snmp_data_t *p=(snmp_data_t*)hdr->data;
+									
+									paras_data_t *para = paras_get();
+									para->snmp = *p;
+									snmp_strap_set();
+									paras_save();
+									
+								}
+								break;
                 
             }
         }
@@ -426,6 +506,15 @@ static int ws_handle(web_handle_t *h, pkt_hdr_t *hdr, mg_conn_t *c)
                         }
                     }
                     break;
+										case SUB_TYPE_POWER_CONSUMER_CLEAR:
+										{
+                        if(hdr->addr==0) {
+                            r = power_set_clear_consumer(pch);
+                        }
+                        else {
+                            
+                        }											
+										}
                 }
             }
             else {