网络阈值文件配置，传感器阈值文件配置，网络设置api，传感器SNMPv2

f407/applications/datadef.h

@@ -235,6 +235,15 @@ typedef struct {
     int8_t              tzone;
 }system_data_t;
 
+
+typedef struct {
+	uint32_t th_max_1;
+	uint32_t th_min_1;
+	uint32_t th_max_2;
+	uint32_t th_min_2;
+}sensor_th_t;
+
+
 typedef struct {
     system_data_t       sys;
     version_data_t      ver;
@@ -243,6 +252,7 @@ typedef struct {
     product_data_t      prod;
     service_data_t      serv;
     network_data_t      netwk;
+		sensor_th_t      sensor[3];
 }paras_data_t;
 
 typedef struct {
@@ -265,6 +275,8 @@ typedef struct {
 			uint16_t           current;															// 电流			保留1位小数，单位A
 			uint32_t             power;																// 功率			保留3位小数，单位W,最大值65535W
 			uint32_t           consump;														// 耗电量   保留3位小数，单位kWh	
+//			uint8_t             status;
+//			uint8_t             nwire;
 }power_t;
 
 
@@ -332,7 +344,8 @@ typedef struct{
 
 typedef struct {
     uint8_t             en;
-    float               val;                    //threashold value
+    float               max;                    //threashold max  value
+		float               min;										//
     uint8_t             act;
     uint8_t             para[14];               //14*8=128 channels
 }thr_val_t;
@@ -482,10 +495,7 @@ typedef struct {
 typedef struct {
     char                name[32];
     uint8_t             type;
-    uint8_t             subtype;
     uint8_t             addr;
-    uint8_t             subaddr;
-    uint8_t             val_cnt;
 }sensor_info_t;
 typedef struct {
     thr_val_t           thr;
@@ -494,7 +504,7 @@ typedef struct {
 typedef struct {
     sensor_info_t       info;
     sensor_val_t        val[2];
-    uint32_t            time;
+    //uint32_t            time;
 }sensor_data_t;
 typedef struct {
     uint8_t             cnt;

f407/applications/dflt.c

@@ -38,7 +38,11 @@ const paras_data_t DFLT_PARAS={
             .dns1 = "8.8.8.8",
             .dns2 = "1.1.1.1",
         },
-        
+				.sensor={
+					{0,0},
+					{0,0},
+					{0,0},
+				},
         .cas = {
             .mode = MODBUS_SLAVE,
             .addr = 1,

f407/applications/main.c

@@ -14,12 +14,15 @@
 #include "paras.h"
 #include "cascade.h"
 #include "snmp.h"
+#include "net.h"
 
 //https://embedded-rd.blog.csdn.net/article/details/109643188
 
 extern void lwip_sys_init(void);
 
 
+#if 0
+
 static int net_init(const char *ip, int port)
 {
 #define SERVER_PORT 8080
@@ -91,16 +94,17 @@ __exit:
     return ret;
 }
 
-
+#endif
 
 
 static int user_init(void)
 {
     paras_data_t *p=paras_get();
     modbus_data_t *cas=&p->cas;
+		net_init();
     snmp2_init();
     power_init();
-    cascade_init();
+    //cascade_init();
     web_init();
     
     return 0;

f407/applications/net.c

@@ -5,10 +5,20 @@
 #include <string.h>
 #include <limits.h>
 #include "rtdbg.h"
-#include "sys.h"
+//#include "sys.h"
 #include "paras.h"
 #include "cfg.h"
 #include "fs.h"
+#include "lwip/netif.h"
+#include "lwip/netifapi.h"
+#include <rtthread.h>
+#include <netif/ethernetif.h> 
+#include "paras.h"
+#include "lwip/prot/dhcp.h"
+#include <lwip/ip_addr.h>
+#include "lwip/dns.h"
+#include "net.h"
+
 
 #if 1
     #define LOGE  LOG_E
@@ -25,15 +35,15 @@
 
 
 
-////////////////////////////////////////////////
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <unistd.h>
-#include <lwip/sockets.h>
-#include <lwip/ip_addr.h>
-#include <lwip/ip6_addr.h>
+
+typedef struct{
+	struct netif *netif;
+	struct netdev *netdev;
+}net_handle_t; 
+
+
+static net_handle_t handle_net = {0};
+
 
 void print_net(char*s, network_data_t *p)
 {
@@ -52,22 +62,27 @@ void print_modbus(char*s, modbus_data_t *p)
     LOGD("__%s__mbus.path:    %s\n", s, p->path);
 }
 
+static  int set_dns(network_data_t *para)
+{
+	
+}
+
 static int set_ipaddr(int family, const char* iface, const char* addr, const char* netmask)
 {
     ip4_addr_t  ipaddr4;
     ip6_addr_t  ipaddr6;
 
-    if(family==AF_INET) {
+//    if(family==AF_INET) {
         //ip4_addr_set(&ipaddr4, IP4_ADDR(&ipaddr4, 0xbeef, 0xfeed, 0xdead, 0xbeef));
-    }
-    else {
+//    }
+//    else {
         //ip6_addr_set(&ipaddr6, IP6_ADDR(&ipaddr6, 0xbeef, 0xfeed, 0xdead, 0xbeef, 0x1337, 0xbabe, 0xbaad, 0xface));
         
         //netif_add_ip6_address(&netif, &ipaddr_v6, &chosen_idx);
         //netif.ip6_addr_state[chosen_idx] = IP6_ADDR_VALID;
         //ip6_addr_assign_zone(ip_2_ip6(&netif.ip6_addr[0]), IP6_UNICAST, &netif);
         //netif_ip6_addr_set_state(&netif, 0, IP6_ADDR_TENTATIVE);
-    }
+//    }
     
     return 0;
 }
@@ -112,7 +127,9 @@ static int is_number(char *str)
 }
 static int ip_check(char* addr)
 {
-    int flag=IP_ERR;
+
+    int flag=0;
+#if 0
     struct in_addr addr4;
     struct in6_addr addr6;
 
@@ -125,17 +142,17 @@ static int ip_check(char* addr)
     if(flag==IP_ERR) {
         LOGE("____ wrong ip addr: %s\n", addr);
     }
-    
+#endif
     return flag;
 }
 static int is_ipv6_prefix(char *ss)
 {
-    if(is_number(ss)) {
-        int val = atoi(ss);
-        if(val>1 && val<128) {
-            return 1;
-        }
-    }
+//    if(is_number(ss)) {
+//        int val = atoi(ss);
+//        if(val>1 && val<128) {
+//            return 1;
+//        }
+//    }
 
     return 0;
 }
@@ -145,6 +162,7 @@ static int is_ipv6_prefix(char *ss)
 
 static int nw_check(network_data_t *para, int ipv)
 {
+#if 0
     if(ipv==IP_V4) {
         if((ip_check(para->ipaddr)!=IP_V4) || (ip_check(para->mask)!=IP_V4) || (ip_check(para->gateway)!=IP_V4)) {
             return -1;
@@ -155,7 +173,7 @@ static int nw_check(network_data_t *para, int ipv)
             return -1;
         }
     }
-
+#endif
     return 0;
 }
 static int get_net(network_data_t *para, int ipv)
@@ -164,6 +182,8 @@ static int get_net(network_data_t *para, int ipv)
 }
 static int set_net(network_data_t *para, int ipv)
 {
+	int r =0;
+#if 0
     int r,ipv2;
     network_data_t info4,info6,*info;
 
@@ -195,7 +215,7 @@ static int set_net(network_data_t *para, int ipv)
     if((ipv==ipv2) && strcmp(para->gateway, info->gateway)) {
         strcpy(info->gateway, para->gateway);
     }
-    
+#endif    
 
     return r;
 }
@@ -204,7 +224,7 @@ static int set_net(network_data_t *para, int ipv)
 int sys_set_net(network_data_t *para, int ip_version)
 {
     int r,ipv;
-
+#if 0
     network_data_t para2;
     r = get_net(&para2, ip_version);
     if(r==0) {
@@ -213,7 +233,7 @@ int sys_set_net(network_data_t *para, int ip_version)
             return -1;
         }
         set_dns(para);
-        r = set_net(para, ipVersion);
+        r = set_net(para, ip_version);
         if(r==0) {
             sys_reboot();
             //nic_restart(DFLT_NIC); exit(0);
@@ -222,7 +242,7 @@ int sys_set_net(network_data_t *para, int ip_version)
     else {
         LOGE("get_net failed\n");
     }
-    
+#endif   
     return r;
 }
 
@@ -238,6 +258,7 @@ int sys_get_net(network_data_t *para, int ip_version)
 
 int sys_get_mac(char *mac, int maclen)
 {
+#if 0
     int sock;
     struct ifreq ifr;
 
@@ -258,12 +279,13 @@ int sys_get_mac(char *mac, int maclen)
 
     //uint8_t *p = (uint8_t*)ifr.ifr_hwaddr.sa_data;
     //snprintf(mac, maclen, "%02x%02x%02x%02x%02x%02x", p[0], p[1], p[2], p[3], p[4], p[5]);
-
+#endif
     return 0;
 }
-
+#if 0
 int sys_get_chip_id(int *id)
 {
+
     int sock;
     struct ifreq ifr;
 
@@ -271,10 +293,10 @@ int sys_get_chip_id(int *id)
         return -1;
     }
 
-    
+ 
     return 0;
 }
-
+#endif 
 
 int sys_ip_check(char *ip)
 {
@@ -282,6 +304,177 @@ 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;
+		paras_save();
+	return;
+}
+
+
+void net_get_ip(network_data_t *data)
+{
+	paras_data_t* para = paras_get();
+	if(handle_net.netif && netif_is_up(handle_net.netif))
+	{
+			char * str =  ip4addr_ntoa(netif_ip4_addr(handle_net.netif));
+			memcpy(data->ipaddr,str,strlen(str));
+			str =  ip4addr_ntoa(netif_ip4_netmask(handle_net.netif));
+			memcpy(data->mask,str,strlen(str));
+			str =  ip4addr_ntoa(netif_ip4_gw(handle_net.netif));
+			memcpy(data->gateway,str,strlen(str));
+			data->mode = para->netwk.mode;
+		
+	}else
+	{
+		memcpy(data->dns1,"8.8.8.8",strlen("8.8.8.8"));
+		memcpy(data->dns2,"114.114.114.114",strlen("114.114.114.114"));
+		memcpy(data->ipaddr,"0.0.0.0",strlen("0.0.0.0"));
+		memcpy(data->gateway,"0.0.0.0",strlen("0.0.0.0"));
+		memcpy(data->mask,"0.0.0.0",strlen("0.0.0.0"));
+		data->mode = para->netwk.mode;
+	}
+}
+
+
+
+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);	
+}
+
+
+int net_ipaddr_set(network_data_t *data)
+{
+	paras_data_t* para = paras_get();
+	
+	if(para->netwk.mode == 0)
+	{
+		if(data->mode == 1)
+		{
+			ip_save(data);
+			netifapi_dhcp_stop(handle_net.netif);
+			ip_set_static();
+			LOG_D("mode dhcp 2 static\n");
+		}
+	}else if(para->netwk.mode == 1)
+	{
+		if(data->mode == 0)
+		{
+			netifapi_dhcp_start(handle_net.netif);
+			ip_save(data);
+			LOG_D("mode static 2 dhcp\n");
+		}else if(data->mode == 1)
+		{
+			ip_save(data);
+			ip_set_static();
+			LOG_D("mode static 2 static\n");
+		}
+	}else
+	{
+		LOG_E("error mode\n");
+	}
+}
+
+
+
+int net_init()
+{
+	//获取网卡设备
+	rt_device_t dev = rt_device_find(DFLT_NIC);
+	if(dev == RT_NULL)
+	{
+		LOG_E("___ %s is not exist!!\n",DFLT_NIC);
+		goto failed;
+	}
+	struct eth_device *eth_dev = (struct eth_device*)dev;
+	if(eth_dev)
+	{
+		handle_net.netif = eth_dev->netif;
+	}else{
+		goto failed;
+	}
+//	struct netdev *netdev = netdev_get_by_name(DFLT_NIC);
+
+//	if (netdev == RT_NULL)
+//  {
+//    LOG_E("Netdev 'e0' not found!\n");
+//    return -1;
+//  }
+	
+	
+	paras_data_t* para = paras_get();
+	
+	if(para->netwk.mode == 0)			//dhcp
+	{
+		//获取dhcp ipaddr and 
+		struct dhcp* dhcp = netif_dhcp_data(handle_net.netif);
+		if(!dhcp)
+		{
+			LOG_E("___ %s dhcp failed!!\n",DFLT_NIC);
+			goto failed;
+		}
+		
+		if(dhcp->state == DHCP_STATE_REBINDING)
+		{
+			//dhcp->offered_ip_addr.addr = 
+			//filt 
+			char * str =  ip4addr_ntoa(netif_ip4_addr(handle_net.netif));
+			LOG_D("____%s\n",str);
+			memcpy(para->netwk.ipaddr,str,strlen(str));
+			str =  ip4addr_ntoa(netif_ip4_netmask(handle_net.netif));
+			LOG_D("____%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);
+			
+		}else
+		{
+			
+		}
+		
+	}else if(para->netwk.mode == 1)   //static
+	{
+		netifapi_dhcp_stop(handle_net.netif);
+		ip_set_static();
+	}
+	
+	
+	
+	return 0;
+	failed:
+	return -1;
+}
+
+
+
+
+
+#if 0
 
 ///////////////////////////////////////////////////////////////////////
 #define MAX_BUFFER_SIZE 1024
@@ -416,6 +609,7 @@ static void* polling_thread(void *arg)
 
 
 
+
 int sys_init(void)
 {
     lock_s_init();
@@ -425,4 +619,4 @@ int sys_init(void)
 
     return 0;
 }
-
+#endif

f407/applications/net.h

@@ -2,21 +2,27 @@
 #define __SYS_H__
 
 #include <stdint.h>
-#include "protocol.h"
+#include "datadef.h"
+//#include "protocol.h"
 
-enum {
-    IP_DHCP=0,
-    IP_STATIC,
-};
-enum {
-    IP_ERR=0,
-    IP_V4,
-    IP_V6,
-};
+//enum {
+//    IP_DHCP=0,
+//    IP_STATIC,
+//};
+//enum {
+//    IP_ERR=0,
+//    IP_V4,
+//    IP_V6,
+//};
+
+//int net_ip_check(char *ip);
+//int netget_mac(char *mac, int maclen);
+//int net_get_net(network_data_t *para, int ip_version);
+//int net_set_net(network_data_t *para, int ip_version);
+
+int net_init();
+void net_get_ip(network_data_t *data);
+int net_ipaddr_set(network_data_t *data);
 
-int net_ip_check(char *ip);
-int netget_mac(char *mac, int maclen);
-int net_get_net(network_data_t *para, int ip_version);
-int net_set_net(network_data_t *para, int ip_version);
 
 #endif

f407/applications/paras.c

@@ -498,6 +498,396 @@ static int proc_modbus(dictionary *dic, int op, modbus_data_t *mb)
 
     return r;
 }
+
+static int proc_sensor(dictionary *dic, int op, sensor_th_t sensor[])
+{
+    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_sensor(dic, PARAS_CHECK, sensor);
+        if(r) {
+            return -1;
+        }
+    }	
+		
+// 1
+		token = "sensor_1:th_max_1";
+		 if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            sensor[0].th_max_1 = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", sensor[0].th_max_1);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+		token = "sensor_1:th_min_1";
+		 if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            sensor[0].th_min_1 = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", sensor[0].th_min_1);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+
+		token = "sensor_1:th_max_2";
+		 if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            sensor[0].th_max_2 = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", sensor[0].th_max_2);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+		
+		token = "sensor_1:th_min_2";
+		 if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            sensor[0].th_min_2 = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", sensor[0].th_min_2);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }	
+// 2	
+		token = "sensor_2:th_max_1";
+		 if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            sensor[1].th_max_1 = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", sensor[1].th_max_1);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+		token = "sensor_2:th_min_1";
+		 if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            sensor[1].th_min_1 = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", sensor[1].th_min_1);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+
+		token = "sensor_2:th_max_2";
+		 if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            sensor[1].th_max_2 = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", sensor[1].th_max_2);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+		
+		token = "sensor_2:th_min_2";
+		 if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            sensor[1].th_min_2 = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", sensor[1].th_min_2);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }			
+//3
+		token = "sensor_3:th_max_1";
+		 if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            sensor[2].th_max_1 = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", sensor[2].th_max_1);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+		token = "sensor_3:th_min_1";
+		 if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            sensor[2].th_min_1 = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", sensor[2].th_min_1);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+
+		token = "sensor_3:th_max_2";
+		 if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            sensor[2].th_max_2 = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", sensor[2].th_max_2);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+		
+		token = "sensor_3:th_min_2";
+		 if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            sensor[2].th_min_2 = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", sensor[2].th_min_2);
+        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_sensor(dic, PARAS_CHECK, sensor);
+    }
+
+    return r;		
+}
+
+
+static int proc_net(dictionary *dic, int op,network_data_t *net)
+{
+    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_net(dic, PARAS_CHECK, net);
+        if(r) {
+            return -1;
+        }
+		}
+		token = "network:mode";
+    if(op==PARAS_READ) {
+        r = iniparser_getint(dic, token, -1);
+        if(r==-1) {
+            LOGE("___ iniparser_getint %s failed\n", token);
+            return -1;
+        } else {
+            net->mode = r;
+        }
+    }
+    else {
+        sprintf(temp, "%d", net->mode);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }	
+		token = "network:ipaddr";
+    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(net->ipaddr,str,strlen(str));
+        }
+    }
+    else {
+        sprintf(temp, "%s", net->ipaddr);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }
+		token = "network:mask";
+    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(net->mask,str,strlen(str));
+        }
+    }
+    else {
+        sprintf(temp, "%s", net->mask);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }			
+
+		token = "network:gateway";
+    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(net->gateway,str,strlen(str));
+        }
+    }
+    else {
+        sprintf(temp, "%s", net->gateway);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }				
+
+		token = "network:dns1";
+    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(net->dns1,str,strlen(str));
+        }
+    }
+    else {
+        sprintf(temp, "%s", net->dns1);
+        r = iniparser_set(dic, token, temp);
+        if(r) {
+            LOGE("___ iniparser_set %s failed\n", token);
+            return -1;
+        }
+    }					
+
+		token = "network:dns2";
+    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(net->dns2,str,strlen(str));
+        }
+    }
+    else {
+        sprintf(temp, "%s", net->dns1);
+        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_net(dic, PARAS_CHECK, net);
+    }		
+		
+		return r;
+}
+
+
 static int proc_misc(dictionary *dic, int op, misc_data_t *misc)
 {
     int r=0;
@@ -2984,6 +3374,15 @@ static dictionary* ini_load(char *path, paras_data_t *info)
         LOGE("___proc_misc failed\n");
     }
     
+		r = proc_sensor(dic, PARAS_READ, info->sensor);
+    if(r) {
+        LOGE("___proc_sensor failed\n");
+    }	
+		
+		r = proc_net(dic, PARAS_READ, &info->netwk);
+    if(r) {
+        LOGE("proc_net failed\n");
+    }	
     return dic;
 }
 static int ini_check(char *path)
@@ -3037,6 +3436,34 @@ static int ini_reset(paras_handle_t *h)
     fprintf(fp, "beep        = \"%d\"\n", p->misc.beep);
     fprintf(fp, "rotate      = \"%d\"\n", p->misc.rotate);
     fprintf(fp, "\n");
+		
+		fprintf(fp, "[sensor_1]\n");
+		fprintf(fp, "th_max_1    = \"%d\"\n", p->sensor[0].th_max_1);
+		fprintf(fp, "th_min_1    = \"%d\"\n", p->sensor[0].th_min_1);
+		fprintf(fp, "th_max_2    = \"%d\"\n", p->sensor[0].th_max_2);
+		fprintf(fp, "th_min_2    = \"%d\"\n", p->sensor[0].th_min_2);
+
+		fprintf(fp, "[sensor_2]\n");
+		fprintf(fp, "th_max_1    = \"%d\"\n", p->sensor[1].th_max_1);
+		fprintf(fp, "th_min_1    = \"%d\"\n", p->sensor[1].th_min_1);
+		fprintf(fp, "th_max_2    = \"%d\"\n", p->sensor[1].th_max_2);
+		fprintf(fp, "th_min_2    = \"%d\"\n", p->sensor[1].th_min_2);
+		fprintf(fp, "[sensor_3]\n");
+		fprintf(fp, "th_max_1    = \"%d\"\n", p->sensor[2].th_max_1);
+		fprintf(fp, "th_min_1    = \"%d\"\n", p->sensor[2].th_min_1);
+		fprintf(fp, "th_max_2    = \"%d\"\n", p->sensor[2].th_max_2);
+		fprintf(fp, "th_min_2    = \"%d\"\n", p->sensor[2].th_min_2);
+		fprintf(fp, "\n");
+		
+    fprintf(fp, "[network]\n");
+    fprintf(fp, "mode      = \"%d\"\n", p->netwk.mode);
+    fprintf(fp, "ipaddr    = \"%s\"\n", p->netwk.ipaddr);
+    fprintf(fp, "gateway   = \"%s\"\n", p->netwk.gateway);
+    fprintf(fp, "mask      = \"%s\"\n", p->netwk.mask);
+    fprintf(fp, "dns1      = \"%s\"\n", p->netwk.dns1);
+		fprintf(fp, "dns2      = \"%s\"\n", p->netwk.dns2);
+    fprintf(fp, "\n");		
+		
 
     fclose(fp);
     if(h->dic) {

f407/applications/rtconfig.h

@@ -174,7 +174,7 @@
 #define RT_LWIP_IGMP
 #define RT_LWIP_ICMP
 #define RT_LWIP_DNS
-//#define RT_LWIP_DHCP
+#define RT_LWIP_DHCP
 #define RT_LWIP_SNMP
 #define RT_LWIP_STATS
 #define IP_SOF_BROADCAST 1

f407/applications/sensor.c

@@ -3,12 +3,22 @@
 #include "mb.h"
 #include "lock.h"
 #include "sensor.h"
+#include "paras.h"
+
+
+
+
 
 
 #define RETRY_TIMES   3
 #define TIMEOUT       200
 
 
+
+
+
+
+
 typedef struct {
     lock_t        lck;
     
@@ -33,10 +43,95 @@ static int read_reg(uint8_t addr, uint16_t reg, uint16_t *data, int cnt)
 
 int sensor_init(void)
 {
+		paras_data_t* p_d = paras_get();
     sensor_handle_t *h=&ssHandle;
-    
-    h->lck = lock_init();
-    
+		ssHandle.all.data = (sensor_data_t *)malloc(sizeof(sensor_data_t) *MAX_SENSOR);
+		if(ssHandle.all.data)
+		{
+			h->lck = lock_init();
+			ssHandle.all.max = MAX_SENSOR;
+			ssHandle.all.cnt = MAX_SENSOR;
+			//first  温湿度传感器  默认地址1 不允许修改
+			memcpy(ssHandle.all.data[0].info.name,"Temp-Humi Sensor",strlen("Temp-Humi Sensor"));
+			ssHandle.all.data[0].info.addr = 1;
+			ssHandle.all.data[0].info.type = SENSOR_TYPE_TEMP_HUMI;
+			if(p_d->sensor[0].th_max_1 != 0)
+			{
+				ssHandle.all.data[0].val[0].thr.max = ((float)p_d->sensor[0].th_max_1 /100.0);
+				ssHandle.all.data[0].val[0].thr.en = 1;
+			}
+			if(p_d->sensor[0].th_min_1 != 0)
+			{
+				ssHandle.all.data[0].val[0].thr.min = ((float)p_d->sensor[0].th_min_1 /100.0);
+				ssHandle.all.data[0].val[0].thr.en = 1;
+			}
+			if(p_d->sensor[0].th_max_2 != 0)
+			{
+				ssHandle.all.data[0].val[1].thr.max = ((float)p_d->sensor[0].th_max_2 /100.0);
+				ssHandle.all.data[0].val[1].thr.en = 1;
+			}
+			if(p_d->sensor[0].th_min_2 != 0)
+			{
+				ssHandle.all.data[0].val[1].thr.min = ((float)p_d->sensor[0].th_min_2 /100.0);
+				ssHandle.all.data[0].val[1].thr.en = 1;
+			}
+			
+			//ssHandle.all.data[0].val[0].value = 0;
+			//second  烟雾传感器  默认地址2 不允许修改
+			memcpy(ssHandle.all.data[1].info.name,"Smoke Sensor",strlen("Smoke Sensor"));
+			ssHandle.all.data[1].info.addr = 2;
+			ssHandle.all.data[1].info.type = SENSOR_TYPE_SMOKE;
+			
+			if(p_d->sensor[1].th_max_1 != 0)
+			{
+				ssHandle.all.data[1].val[0].thr.max = ((float)p_d->sensor[1].th_max_1 /100.0);
+				ssHandle.all.data[1].val[0].thr.en = 1;
+			}
+			if(p_d->sensor[1].th_min_1 != 0)
+			{
+				ssHandle.all.data[1].val[0].thr.min = ((float)p_d->sensor[1].th_min_1 /100.0);
+				ssHandle.all.data[1].val[0].thr.en = 1;
+			}
+			if(p_d->sensor[1].th_max_2 != 0)
+			{
+				ssHandle.all.data[1].val[1].thr.max = ((float)p_d->sensor[1].th_max_2 /100.0);
+				ssHandle.all.data[1].val[1].thr.en = 1;
+			}
+			if(p_d->sensor[1].th_min_2 != 0)
+			{
+				ssHandle.all.data[1].val[1].thr.min = ((float)p_d->sensor[1].th_min_2 /100.0);
+				ssHandle.all.data[1].val[1].thr.en = 1;
+			}			
+			
+			
+			
+			//second  气体传感器  默认地址3 不允许修改
+			memcpy(ssHandle.all.data[2].info.name,"Gas Sensor",strlen("Gas Sensor"));
+			ssHandle.all.data[2].info.addr = 3;
+			ssHandle.all.data[2].info.type = SENSOR_TYPE_GAS;
+
+			if(p_d->sensor[2].th_max_1 != 0)
+			{
+				ssHandle.all.data[2].val[0].thr.max = ((float)p_d->sensor[2].th_max_1 /100.0);
+				ssHandle.all.data[2].val[0].thr.en = 1;
+			}
+			if(p_d->sensor[2].th_min_1 != 0)
+			{
+				ssHandle.all.data[2].val[0].thr.min = ((float)p_d->sensor[2].th_min_1 /100.0);
+				ssHandle.all.data[2].val[0].thr.en = 1;
+			}
+			if(p_d->sensor[2].th_max_2 != 0)
+			{
+				ssHandle.all.data[2].val[1].thr.max = ((float)p_d->sensor[2].th_max_2 /100.0);
+				ssHandle.all.data[2].val[1].thr.en = 1;
+			}
+			if(p_d->sensor[2].th_min_2 != 0)
+			{
+				ssHandle.all.data[2].val[1].thr.min = ((float)p_d->sensor[2].th_min_2 /100.0);
+				ssHandle.all.data[2].val[1].thr.en = 1;
+			}			
+			
+		}
     return 0;
 }
 
@@ -44,9 +139,14 @@ int sensor_init(void)
 int sensor_deinit(void)
 {
     sensor_handle_t *h=&ssHandle;
-    
+		sensor_handle_t data={0};
+		if(h->all.data)
+		{
+			free(h->all.data);
+		}
     lock_deinit(h->lck);
-    
+    *h = data;
+		
     return 0;
 }
 
@@ -136,41 +236,13 @@ static int my_read(sensor_data_t *data)
     switch(data->info.type) {
         case SENSOR_TYPE_TEMP_HUMI:
         {
-            switch(data->info.subtype) {
-                case SENSOR_TYPE_TEMP_HUMI_RSWSN01PVC:
-                {
-                    r = read_reg(addr, 0, tmp, 2);
-                    if(r<0) {
-                        return -1 ;
-                    }
-                    data->val[0].value = tmp[1]/10.0f; //湿度值
-                    data->val[1].value = tmp[0]/10.0f; //湿度值
-                }
-                break;
-
-                case SENSOR_TYPE_TEMP_HUMI_HKSHT301T1H536VRS485:    //anderson
-                {
-                    r = read_reg(addr, 0, tmp, 2);
-                    if (r < 0) {
-                        return -1;
-                    }
-                    data->val[0].value = tmp[0]/10.0f;   //温度值
-                    data->val[1].value = tmp[1]/10.0f;   //湿度值
-                }
-                break;
-            }
+           r = read_reg(addr, 0, tmp, 2);
         }
         break;
-
         case SENSOR_TYPE_SMOKE:
         case SENSOR_TYPE_WATER:
         case SENSOR_TYPE_ACCESS:
         {
-            r = -1;//read_reg(subaddr+GPIO_PD11);
-            if(r<0) {
-                return -1;
-            }
-            data->val[0].value = r;
         }
         break;
 
@@ -184,87 +256,10 @@ static int my_read(sensor_data_t *data)
         }
         break;
 
-        case SENSOR_TYPE_AIR_PRESS:
-        {
-
-        }
-        break;
-
-        case SENSOR_TYPE_AIR_COND:
-        {
-
-        }
-        break;
-
-        case SENSOR_TYPE_TEMP_DOUBLE:
-        {
-            switch(data->info.subtype) {
-                case SENSOR_TYPE_TEMP_HUMI_RSWSN01PVC:
-                {
-                    r = read_reg(addr, 0x0400, &tmp[0], 1);
-                    if (r < 0) {
-                        LOGE("___ sensor RSWSN01PVC 1 read failed, addr: %d\n", addr);
-                        return -1;
-                    }
-
-                    r = read_reg(addr, 0x0401, &tmp[1], 1);
-                    if (r < 0) {
-                        LOGE("___ sensor RSWSN01PVC 2 read failed, addr: %d\n", addr);
-                        return -1;
-                    }
-                    data->val[0].value = tmp[1]/10.0f;   //解算温度值
-                    data->val[0].value = tmp[0]/10.0f;   //解算湿度值
-                }
-                break;
-            }
-        }
-        break;
 
-        case SENSOR_TYPE_TEMP:
-        {
-            switch(data->info.subtype) {
-                case SENSOR_TYPE_TEMP_BTG50H8EL3200:
-                {
-                    r = read_reg(addr, 0, tmp, 1);
-                    if (r < 0) {
-                        LOGE("___ sensor BTG50H8EL3200 read failed, addr: %d\n", addr);
-                        return -1;
-                    }
-                    data->val[0].value = tmp[0]/10.0f - 50;
-                    //printf("___ BTG50H8EL3200 read: 0x%04x, temp: %0.2f\n", tmp, data->val[0]);
-                }
-                break;
-            }
-        }
-        break;
-
-        case SENSOR_TYPE_LEAK:
-        {
-            switch(data->info.subtype) {
-                case SENSOR_TYPE_LEAK_XWDC01A:
-                {
-                    r = read_reg(addr, 0, tmp, 4);
-                    if (r < 0) {
-                        LOGE("___ sensor XWDC01A read failed, addr: %d\n", data->info.addr);
-                        return -1;
-                    }
-                    //printf("___ XWDC01A read: 0x%04x, 0x%04x, 0x%04x, 0x%04x\n", tmp[0],tmp[1],tmp[2],tmp[3]);
-
-                    data->val[0].value = 0;
-                    if(tmp[0] || tmp[1]) {
-                        data->val[0].value = 1;
-                    }
-                }
-                break;
-            }
-        }
-        break;
     }
 
-    if(r==0) {
-        data->time = mktime(localtime(NULL));
-    }
-    
+
     return r;
 }
 
@@ -273,7 +268,6 @@ int sensor_query(void)
 {
     int i,r=-1;
     sensor_handle_t *h=&ssHandle;
-    
     lock_on(h->lck);
     for(i=0; i<h->all.cnt; i++) {
         r = my_read(&h->all.data[i]);
@@ -283,6 +277,13 @@ int sensor_query(void)
     return 0;
 }
 
+
+sensor_all_t * sensor_get_data()
+{
+	return &ssHandle.all;
+}
+
+
     
 int sensor_data_get(sensor_all_t *all)
 {

f407/applications/sensor.h

@@ -3,6 +3,10 @@
 
 #include "datadef.h"
 
+
+#define MAX_SENSOR     3
+
+
 int sensor_init(void);
 int sensor_deinit(void);
 int sensor_set(sensor_data_t *data);
@@ -10,5 +14,6 @@ int sensor_remove(sensor_data_t *data);
 int sensor_query(void);
 int sensor_data_get(sensor_all_t *all);
 int sensor_data_free(sensor_all_t *all);
+sensor_all_t * sensor_get_data();
 
 #endif

f407/applications/snmp.c

@@ -10,6 +10,7 @@
 #include "string.h"
 #include "power.h"
 #include "datadef.h"
+#include "sensor.h"
 
 
 
@@ -303,6 +304,10 @@ static struct snmp_oid_range th_table_oid_ranges[] = {
     {1, POWER_VALUE},
 };
 
+static struct snmp_oid_range th_sensor_oid_ranges[] = {
+		{1,MAX_SENSOR},
+};
+
 
 
 
@@ -389,6 +394,11 @@ static snmp_err_t thr_s_set_value(struct snmp_node_instance *instance,u16_t len,
 {
 	  u32_t row = instance->reference.u32;
     u32_t col = SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id);
+		sensor_all_t * sensor = sensor_get_data();
+		if(sensor->data == 0)
+		{
+			return SNMP_ERR_NOTWRITABLE;
+		}
 		switch(col)
 		{
 			case COLUMN_PDUSENSORLIMITVALUE1UP:
@@ -421,41 +431,42 @@ static s16_t  thr_s_get_value(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);
+		sensor_all_t *sensor = sensor_get_data();
 		char buff[50]= {0};
 		switch(col)
 		{
 			case COLUMN_PDUSENSORLIMITID:
 			{
-				*(s32_t *)value	= p_thr_s[row-1].id;
+				*(s32_t *)value	= row-1;
 				return 4;
 			}
 			break;
 			case COLUMN_PDUSENSORLIMITNAME:
 			{
-				sprintf(buff,"%s",p_thr_s[row-1].name);
+				sprintf(buff,"%s",sensor->data[row-1].info.name);
 			}
 				break;
 			case COLUMN_PDUSENSORLIMITVALUE1UP:
 			{
-				*(s32_t *)value	= p_thr_s[row-1].val1_up;
+				*(s32_t *)value	= (sensor->data[row-1].val[0].thr.max * 100);
 				return 4;
 			}
 				break;
 			case COLUMN_PDUSENSORLIMITVALUE2UP:
 			{
-				*(s32_t *)value	= p_thr_s[row-1].val2_up;
+				*(s32_t *)value	= (sensor->data[row-1].val[1].thr.max * 100);
 				return 4;
 			}
 			break;
 			case COLUMN_PDUSENSORLIMITVALUE1DOWN:
 			{
-				*(s32_t *)value	= p_thr_s[row-1].val1_down;
+				*(s32_t *)value	= (sensor->data[row-1].val[0].thr.min * 100);
 				return 4;
 			}
 			break;
 			case COLUMN_PDUSENSORLIMITVALUE2DOWN:
 			{
-				*(s32_t *)value	= p_thr_s[row-1].val2_down;
+				*(s32_t *)value	= (sensor->data[row-1].val[1].thr.min * 100);
 				return 4;
 			}
 			break;
@@ -598,6 +609,39 @@ static snmp_err_t get_instance(const u32_t *column, const u32_t *row_oid, u8_t r
 	return SNMP_ERR_NOERROR;
 }
 
+static snmp_err_t get_sensor_instance(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, struct snmp_node_instance *cell_instance)
+{
+	if (!snmp_oid_in_range(row_oid, row_oid_len, th_sensor_oid_ranges, LWIP_ARRAYSIZE(th_sensor_oid_ranges)))
+        return SNMP_ERR_NOSUCHINSTANCE;
+	cell_instance->reference.u32 = row_oid[0];
+
+	return SNMP_ERR_NOERROR;
+}
+
+static snmp_err_t get_sensor_next_instance(const u32_t *column, struct snmp_obj_id *row_oid, struct snmp_node_instance *cell_instance)
+{
+    u8_t i = 0;
+    struct snmp_next_oid_state state;
+    u32_t next_oid = 0;
+
+    snmp_next_oid_init(&state, row_oid->id, row_oid->len, &next_oid, 1);
+    for (i = 0; i < th_sensor_oid_ranges[0].max; i++)
+    {
+        u32_t test_oid = i + 1;
+        snmp_next_oid_check(&state, &test_oid, 1, NULL);
+    }
+
+    if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS)
+    {
+        snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len);
+        cell_instance->reference.u32 = *state.next_oid; /* 下个节点行OID */
+				cell_instance->reference.u32++;
+        return SNMP_ERR_NOERROR;
+    }
+
+    return SNMP_ERR_NOSUCHINSTANCE;		
+}
+
 
 
 static snmp_err_t power_get_next_instance(const u32_t *column, struct snmp_obj_id *row_oid, struct snmp_node_instance *cell_instance)
@@ -862,6 +906,19 @@ static const struct snmp_table_col_def 	sensor_limit_table[] = {
 	{0,0,0},
 };
 
+static const struct snmp_table_col_def sensor_info_table[] = {
+	{COLUMN_PDUSENSORID,											SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUSENSORNAME,										SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUSENSORTYPE,										SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUSENSORDATACHENNEL,							SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUSENSORMODBUSADDRESS,						SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUSENSORSTATUS,									SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUSENSORVALUENUM,								SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUSENSORVALUE1,									SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
+	{COLUMN_PDUSENSORVALUE2,									SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
+	{0,0,0},
+};
+
 
 
 const struct snmp_scalar_array_node sysinfo_scalars = SNMP_SCALAR_CREATE_ARRAY_NODE(1, sysinfo_scalars_nodes, sysinfo_get_value, NULL, NULL);
@@ -925,10 +982,16 @@ static const struct snmp_table_node alarm_table = SNMP_TABLE_CREATE(1, alarm_his
 static const struct snmp_table_node thr_table = SNMP_TABLE_CREATE(6, threshold_limit_table, power_get_instance, power_get_next_instance, \
 							thr_get_value, set_test, thr_set_value);
 
-static const struct snmp_table_node thr_s_table = SNMP_TABLE_CREATE(1, sensor_limit_table, get_instance, get_next_instance, \
+static const struct snmp_table_node thr_s_table = SNMP_TABLE_CREATE(1, sensor_limit_table, get_sensor_instance, get_sensor_next_instance, \
 							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);
+
+
+
+
+
 
 
 
@@ -956,11 +1019,17 @@ static const struct snmp_node *const thr_s_subnodes[] = {
     &thr_s_table.node.node,
 };
 
+static const struct snmp_node *const sensor_subnodes[] = {
+		&sensor_table.node.node,
+};
+
+
 
 const struct snmp_tree_node power_treenode 	= SNMP_CREATE_TREE_NODE(3, power_subnodes);
 const struct snmp_tree_node alarm_treenode 	= SNMP_CREATE_TREE_NODE(6, alarm_subnodes);
 const struct snmp_tree_node thr_treenode 		= SNMP_CREATE_TREE_NODE(2, thr_subnodes);
 const struct snmp_tree_node thr_s_treenode 	= SNMP_CREATE_TREE_NODE(3, thr_s_subnodes);
+const struct snmp_tree_node sensor_treenode = SNMP_CREATE_TREE_NODE(4, sensor_subnodes);
 
 
 
@@ -970,6 +1039,7 @@ static const struct snmp_node *const mib2_nodes_dev[] =
     &sysinfo_scalars.node.node,
 		&power_treenode.node,
 		&alarm_treenode.node,
+		&sensor_treenode.node,
 };
 
 

f407/applications/snmp.h

@@ -74,7 +74,16 @@
 			#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			 
 			 
 
 int snmp2_init(void);

f407/applications/ui/menu.c

@@ -35,6 +35,19 @@ enum {
 
     MODBUS_ITEM_MAX
 };
+
+enum{
+	NET_ITEM_MODE = 0,
+	NET_ITEM_ADDR,
+	NET_ITEM_MASK,
+	NET_ITEM_GATE,
+	NET_ITEM_SAVE,
+	NET_ITEM_QUIT,
+	NET_ITEM_MAX
+};
+
+
+
 enum {
     UFLAG_KEY=(1<<0),
     UFLAG_FLIP=(1<<1),
@@ -439,6 +452,34 @@ static void key_remap(key_val_t *kv, int rotate)
         }
     }
 }
+
+static int menu_net_key_handle(menu_handle_t *h, key_val_t *kv)
+{
+    int r=-1;
+    
+    if(h->menu.menu_lv==0) {
+        h->mb = paras_get()->cas;
+    }
+		switch(kv->key) {
+			case KEY_UP:
+			{
+				
+			}
+			break;
+			case KEY_DOWN:
+			{
+			}
+			break;
+			case KEY_OK:
+			{
+			}
+			break;
+			
+		}
+}
+
+
+
 static int menu_modbus_key_handle(menu_handle_t *h, key_val_t *kv)
 {
     int r=-1;