SmartPDCode/f407/applications/snmp.c

#include "snmp.h"
#include "lwip/apps/snmp.h"
#include "lwip/apps/snmp_mib2.h"
#include "lwip/apps/snmp_opts.h"
#include "lwip/apps/snmpv3.h" // 如果使用 SNMP v3
#include "lwip/apps/snmp_opts.h"
#include "lwip/apps/snmp_core.h"
#include "lwip/apps/snmp_table.h"
#include "lwip/apps/snmp_scalar.h"
#include "string.h"
#include "power.h"
#include "datadef.h"






#define SNMP_SMARTPDU_OID 										{1,3,6,1,4,1,2024}
#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}
#define   SNMP_SMARTPDU_THR_TABLE_IOD           {1,3,6,1,4,1,2024,1,7}
#define   SNMP_SMARTPDU_TOTAL_OID                {1,3,6,1,4,1,2024,1,3}

typedef struct 
{
	uint8_t sysdescr[10];
	uint8_t syscontact[5];
	uint8_t sysname[3];
	uint8_t syslocation[3];
	struct snmp_obj_id device_enterprose_oid;
//	char *id_manifacture;
//	char *id_device;
//	char *id_sn;
//	char *id_version;	
	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 s16_t sysinfo_get_value(const struct snmp_scalar_array_node_def *node, void *value)
{
    char *var = NULL;
    s16_t var_len;
		char buff[100]= {0};
		switch(node->oid)
		{
			case 1:
			{
				sprintf(buff,"%d",0);
			}
			break;
			case 2:
			{
					sprintf(buff,"%s","smart_pdu");
			}
			break;
			case 3:
			{
					sprintf(buff,"%s","DC");			
			}
			break;
			case 4:
			{
					sprintf(buff,"%s","SN1235");					
			}
			break;
			case 5:
			{
				sprintf(buff,"%d",12);		
			}				
			break;
			case 6:
			{
				sprintf(buff,"%d",7);	
			}
			break;
			default:
			{
				  LOGE("sysinfo_get_value(): unknown id: %d\n", node->oid);
					return 0;
			}

		}
		var_len = strlen(buff);
		memcpy(value, buff, var_len);
		return var_len;
}



static s16_t total_get_value(const struct snmp_scalar_array_node_def *node, void *value)
{
    char *var = NULL;
    s16_t var_len;
		char buff[100]= {0};
		power_all_t *all = power_get_all();
		
		switch(node->oid)
		{
			case SCALAR_VOLTAGE:
			{
				sprintf(buff,"%.2f",all->ttl.total[0].voltage);
			}
			break;
			case SCALAR_CURRENT:
			{
				sprintf(buff,"%.2f",all->ttl.total[0].current);
			}
			break;
			case SCALAR_CONSUMEPTION:
			{
				sprintf(buff,"%.2f",all->ttl.total[0].consump);
			}
			break;
			case SCALAR_POWER_FACTOR:
			{
				sprintf(buff,"%.2f",all->ttl.total[0].factor);
			}
			break;
			case SCALAR_PACTIVE_POWER:
			{
				sprintf(buff,"%.2f",all->ttl.total[0].power);
			}
			break;
			case SCALAR_REACTIVE_POWER:
			{
				sprintf(buff,"%.2f",all->ttl.total[0].reactive);
			}
			break;
			case  SCALAR_APPARENT_POWER:
			{
				sprintf(buff,"%.2f",all->ttl.total[0].active);
			}
			break;
			default:
				return 0;
		}
		var_len = strlen(buff);
		memcpy(value, buff, var_len);		
		return var_len;
}



#define POWER_VALUE 4

typedef struct power_data{
	uint8_t 						id;
	char  	 *				name;
	uint8_t         status;
	float  						v;
	float             i;
	float 						f;
	float             c;
	float             fa;
	float             p;
	float             r_p;
	float             a_p;
}p_data_t;

typedef struct alarm_data{
	uint8_t id;
	uint8_t type;
	char * alarm_info;
	uint8_t alarm_action;
	uint32_t alarm_action_para;
	char * date;
	char * time;
}p_alarm_t;

typedef struct threshold_data{
	uint8_t 		 id;
	char 			*name;
	float     v_max;
	float     v_min;
	float     i_max;
	float     p_max;
	float     c_max;
}thr_d_t;


typedef struct thr_sensor_data{
	uint8_t 		 id;
	char         *name;
	uint32_t     val1_up;
	uint32_t     val2_up;
	uint32_t     val1_down;
	uint32_t     val2_down;
}thr_s_t;





static p_data_t p_data[POWER_VALUE]={
	{
		.id = 1,
		.name = "smart_pdu",
		.status = 1,
		.v=220.0,
		.i = 15.3,
		.f = 48.95,
		.c = 20.14,
		.fa = 0.89,
		.p = 480.12,
		.r_p = 520.45,
		.a_p = 600.12,
	},
		{
		.id = 2,
		.name = "smart_pdu",
		.status = 1,
		.v=218.0,
		.i = 15.3,
		.f = 49.95,
		.c = 20.14,
		.fa = 0.89,
		.p = 480.12,
		.r_p = 520.45,
		.a_p = 600.12,
	},
			{
		.id = 3,
		.name = "smart_pdu",
		.status = 1,
		.v=219.0,
		.i = 9.3,
		.f = 48.95,
		.c = 20.14,
		.fa = 0.89,
		.p = 100.12,
		.r_p = 230.45,
		.a_p = 460.12,
	},
	{
		.id = 4,
		.name = "smart_pdu",
		.status = 0,
		.v=220.0,
		.i = 15.3,
		.f = 48.95,
		.c = 20.14,
		.fa = 0.89,
		.p = 480.12,
		.r_p = 520.45,
		.a_p = 600.12,
	},
};

static thr_s_t  p_thr_s[POWER_VALUE] = {
	{
		.id = 1,
	  .name = "sers_th1",
		.val1_up = 23,
		.val2_up = 32,
		.val1_down = 11,
		.val2_down = 12,
	},
	{
		.id = 2,
	  .name = "sers_th2",
		.val1_up = 23,
		.val2_up = 32,
		.val1_down = 11,
		.val2_down = 12,
	},
	{
		.id = 3,
	  .name = "sers_th3",
		.val1_up = 23,
		.val2_up = 32,
		.val1_down = 11,
		.val2_down = 12,
	},
	{
		.id = 4,
	  .name = "sers_th4",
		.val1_up = 23,
		.val2_up = 32,
		.val1_down = 11,
		.val2_down = 12,
	},
};

static struct snmp_oid_range th_table_oid_ranges[] = {
    {1, POWER_VALUE},
};




static p_alarm_t p_a_data[POWER_VALUE]={
	{
		.id = 1,
		.type = 3,
		.alarm_info="voltage alarm!!!",
		.alarm_action = 0,
		.alarm_action_para = 4,
		.date = "2052.12.20",
		.time = "12:30:47",
	},
	{
		.id = 2,
		.type = 2,
		.alarm_info="current alarm!!!",
		.alarm_action = 1,
		.alarm_action_para = 2,
		.date = "2002-11-20",
		.time = "10:30:47",
	},
	{
		.id = 3,
		.type = 1,
		.alarm_info="power alarm!!!",
		.alarm_action = 3,
		.alarm_action_para = 6,
		.date = "2012-11-20",
		.time = "10:59:47",
	},
	{
		.id = 4,
		.type = 4,
		.alarm_info="consumer alarm!!!",
		.alarm_action = 3,
		.alarm_action_para = 6,
		.date = "2012-11-20",
		.time = "10:59:47",
	},
};

static thr_d_t p_t_data[POWER_VALUE]=
{
	{
		.id = 1,
		.name="thrould",
		.v_max = 250.00,
		.v_min = 180.00,
		.i_max = 50.00,
		.p_max = 20000.00,
		.c_max = 10000,
	},
	{
		.id = 2,
		.name="thrould",
		.v_max = 250.00,
		.v_min = 180.00,
		.i_max = 50.00,
		.p_max = 20000.00,
		.c_max = 10000,
	},
	{
		.id = 3,
		.name="thrould",
		.v_max = 250.00,
		.v_min = 180.00,
		.i_max = 50.00,
		.p_max = 20000.00,
		.c_max = 10000,
	},
	{
		.id = 4,
		.name="thrould",
		.v_max = 250.00,
		.v_min = 180.00,
		.i_max = 50.00,
		.p_max = 20000.00,
		.c_max = 10000,
	},
};

static snmp_err_t thr_s_set_value(struct snmp_node_instance *instance,u16_t len, void *value)
{
	  u32_t row = instance->reference.u32;
    u32_t col = SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id);
		switch(col)
		{
			case COLUMN_PDUSENSORLIMITVALUE1UP:
			{
				p_thr_s[row-1].val1_up =  *(uint32_t *)value;
			}
				break;
			case COLUMN_PDUSENSORLIMITVALUE2UP:
			{
				p_thr_s[row-1].val2_up =  *(uint32_t *)value;
			}
				break;
			case COLUMN_PDUSENSORLIMITVALUE1DOWN:
			{
				p_thr_s[row-1].val1_down =  *(uint32_t *)value;
			}
				break;
			case COLUMN_PDUSENSORLIMITVALUE2DOWN:
			{
				p_thr_s[row-1].val2_down =  *(uint32_t *)value;
			}
				break;
			default:
				return SNMP_ERR_NOTWRITABLE;
		}
		return SNMP_ERR_NOERROR;
}

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);
		char buff[50]= {0};
		switch(col)
		{
			case COLUMN_PDUSENSORLIMITID:
			{
				*(s32_t *)value	= p_thr_s[row-1].id;
				return 4;
			}
			break;
			case COLUMN_PDUSENSORLIMITNAME:
			{
				sprintf(buff,"%s",p_thr_s[row-1].name);
			}
				break;
			case COLUMN_PDUSENSORLIMITVALUE1UP:
			{
				*(s32_t *)value	= p_thr_s[row-1].val1_up;
				return 4;
			}
				break;
			case COLUMN_PDUSENSORLIMITVALUE2UP:
			{
				*(s32_t *)value	= p_thr_s[row-1].val2_up;
				return 4;
			}
			break;
			case COLUMN_PDUSENSORLIMITVALUE1DOWN:
			{
				*(s32_t *)value	= p_thr_s[row-1].val1_down;
				return 4;
			}
			break;
			case COLUMN_PDUSENSORLIMITVALUE2DOWN:
			{
				*(s32_t *)value	= p_thr_s[row-1].val2_down;
				return 4;
			}
			break;
			default:
				return 0;
		}
		memcpy(value,buff,strlen(buff));
    return strlen(buff);
}



static s16_t thr_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);
		char buff[50]= {0};
		switch (col)
		{
			case COLUMN_PDUCHANNELLIMITID:
			{
				*(s32_t *)value	= row-1;
				return 4;
			}
				break;
			case COLUMN_PDUCHANNELLIMITNAME:
			{
				sprintf(buff,"%s",snmp_smart.all.pch[row-1].info.name);
			}
			break;
			case COLUMN_PDUCHANNELCURRENTLIMITUP:
			{
				sprintf(buff,"%.2f",((float)snmp_smart.all.pch[row-1].thr.c_upper/10.0));
			}
			break;
			case COLUMN_PDUCHANNELVOLTAGELIMITUP:
			{
				sprintf(buff,"%.2f",((float)snmp_smart.all.pch[row-1].thr.v_upper/10.0));
			}
			break;
			case COLUMN_PDUCHANNELVOLTAGELIMITDOWN:
			{
				sprintf(buff,"%.2f",((float)snmp_smart.all.pch[row-1].thr.v_lower/10.0));
			}
			break;
			case COLUMN_PDUCHANNELPOWERLIMITUP:
			{
				sprintf(buff,"%.2f",((float)snmp_smart.all.pch[row-1].thr.p_upper/10.0));
			}
			break;
			case COLUMN_PDUCHANNELCONSUMPTIONLIMITUP:
			{
				sprintf(buff,"%.2f",((float)snmp_smart.all.pch[row-1].thr.w_upper/10.0));
			}
			break;
			default:
				return 0;
		}
		memcpy(value,buff,strlen(buff));
    return strlen(buff);
}



static s16_t alarm_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);
		char buff[50]= {0};
		switch (col)
		{
			case COLUMN_PDUALARMID:
			{
				*(s32_t *)value	= p_a_data[row-1].id;
				return 4;
			}
			break;
			case COLUMN_PDUALARMTYPE:
			{
				*(s32_t *)value	= p_a_data[row-1].type;
				return 4;				
			}
			break;
			case COLUMN_PDUALARMCONTEXT:
			{
				sprintf(buff,"%s",p_a_data[row-1].alarm_info);
			}
			break;
			case COLUMN_PDUALARMACTION:
			{
				*(s32_t *)value	= p_a_data[row-1].alarm_action;
				return 4;				
			}
			break;
			case COLUMN_PDUALARMACTIONPARA:
			{
				*(s32_t *)value	= p_a_data[row-1].alarm_action_para;
				return 4;					
			}
			break;
			case COLUMN_PDUALARMDATE:
			{
				sprintf(buff,"%s",p_a_data[row-1].date);
			}
			break;
			case COLUMN_PDUALARMTIME:
			{
				sprintf(buff,"%s",p_a_data[row-1].time);
			}
			break;
			default:
				return 0;
		}
		memcpy(value,buff,strlen(buff));
		
    return strlen(buff);
}




static snmp_err_t power_get_instance(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, struct snmp_node_instance *cell_instance)
{
	th_table_oid_ranges[0].max = snmp_smart.all.chs-1;
	if (!snmp_oid_in_range(row_oid, row_oid_len, th_table_oid_ranges, LWIP_ARRAYSIZE(th_table_oid_ranges)))
        return SNMP_ERR_NOSUCHINSTANCE;
	cell_instance->reference.u32 = row_oid[0];

	return SNMP_ERR_NOERROR;
}

static snmp_err_t get_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_table_oid_ranges, LWIP_ARRAYSIZE(th_table_oid_ranges)))
        return SNMP_ERR_NOSUCHINSTANCE;
	cell_instance->reference.u32 = row_oid[0];

	return SNMP_ERR_NOERROR;
}



static snmp_err_t power_get_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);
		
    power_data_get(&snmp_smart.all);
    for (i = 0; i < snmp_smart.all.chs-1; 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 get_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);
		
    power_data_get(&snmp_smart.all);
    for (i = 0; i < POWER_VALUE; 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 */
        return SNMP_ERR_NOERROR;
    }

    return SNMP_ERR_NOSUCHINSTANCE;
}

static s16_t power_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);
		char buff[100]= {0};
		switch (col)
		{
			case COLUMN_PDUCHANNELID:
			{
				*(s32_t *)value	= row-1;
				return 4;
			}
				break;
			case COLUMN_PDUCHANNELNAME:
			{
				sprintf(buff,"%s",snmp_smart.all.pch[row-1].info.name);
			}
				break;
			case COLUMN_PDUCHANNELSTATUS:
			{
				//sprintf(buff,"%d",p_data[row].status);
				//*(s32_t *)value	= p_data[row-1].status;
				*(s32_t *)value = snmp_smart.all.pch[row-1].status;
				return 4;
			}
				break;
			case COLUMN_PDUCHANNELVOLTAGE:
			{
				sprintf(buff,"%.2f",((float)snmp_smart.all.pch[row-1].power[0].voltage)/10.0);
			}
				break;
			case COLUMN_PDUCHANNELCURRENT:
			{
				sprintf(buff,"%.2f",((float)snmp_smart.all.pch[row-1].power[0].current)/10.0);
			}
				break;
			case COLUMN_PDUCHANNELFREQUENCY:
			{
				sprintf(buff,"%.2f",((float)snmp_smart.all.pch[row-1].power[0].freq)/100.0);
			}
				break;
			case COLUMN_PDUCHANNELCONSUMPTION:
			{
				sprintf(buff,"%.2f",((float)snmp_smart.all.pch[row-1].power[0].consump)/1000.0);
			}
				break;
			case COLUMN_PDUCHANNELPOWERFACTOR:
			{
				sprintf(buff,"%.2f",((float)snmp_smart.all.pch[row-1].power[0].factor)/100.0);
			}
				break;
			case COLUMN_PDUCHANNELPACTIVEPOWER:
			{
				sprintf(buff,"%.2f",((float)snmp_smart.all.pch[row-1].power[0].power)/1000.0);
			}
				break;
			case COLUMN_PDUCHANNELREACTIVEPOWER:
			{
				sprintf(buff,"%.2f",p_data[row-1].r_p);
			}
				break;
			case COLUMN_PDUCHANNELAPPARENTPOWER:
			{
				sprintf(buff,"%.2f",p_data[row-1].a_p);
			}
				break;
			default:
				return 0;
		}
		
		memcpy(value,buff,strlen(buff));
		
    return strlen(buff);
}
static snmp_err_t set_test(struct snmp_node_instance *instance, u16_t len, void *value)
{
	LOGD("write test\n");
	return SNMP_ERR_NOERROR;
}

static snmp_err_t  power_set_value (struct snmp_node_instance *instance, u16_t len, void *value)
{
	  u32_t row = instance->reference.u32;
    u32_t col = SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id);
		switch(col)
		{
			case  COLUMN_PDUCHANNELSTATUS:
			{
				//p_data[row-1].status = *(uint32_t*)value;
				snmp_smart.all.pch[row].status = *(uint32_t*)value;
				power_set_ch_sw_n(&snmp_smart.all.pch[row]);
			}
				break;
			default:
				return SNMP_ERR_NOTWRITABLE;
		}
		return SNMP_ERR_NOERROR;
}
static snmp_err_t thr_set_value(struct snmp_node_instance *instance,u16_t len, void *value)
{
	  u32_t row = instance->reference.u32;
    u32_t col = SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id);
		switch(col)
		{
			case COLUMN_PDUCHANNELCURRENTLIMITUP:
			{
				snmp_smart.all.pch[row].thr.c_upper = (float)atof((char *)value) * 10;
				//p_t_data[row-1].i_max = (float)atof((char *)value);
				//snmp_smart.all.pch[row-1]
				power_set_threshold(&snmp_smart.all.pch[row]);
			}
			break;
			case COLUMN_PDUCHANNELVOLTAGELIMITUP:
			{
				//p_t_data[row-1].v_max = (float)atof((char *)value);
				snmp_smart.all.pch[row].thr.v_upper = (float)atof((char *)value) * 10;
				power_set_threshold(&snmp_smart.all.pch[row]);
			}
			break;
			case COLUMN_PDUCHANNELVOLTAGELIMITDOWN:
			{
				snmp_smart.all.pch[row].thr.v_lower = (float)atof((char *)value) * 10;
				power_set_threshold(&snmp_smart.all.pch[row]);
				//p_t_data[row-1].v_min = (float)atof((char *)value);
				//snmp_smart.all.pch[row-1].thr.v_upper = (float)atof((char *)value) * 10;
			}
			break;
			case COLUMN_PDUCHANNELPOWERLIMITUP:
			{
				//p_t_data[row-1].p_max = (float)atof((char *)value);
				snmp_smart.all.pch[row].thr.p_upper = (float)atof((char *)value) * 1000;
				power_set_threshold(&snmp_smart.all.pch[row]);
			}
			break;
			case COLUMN_PDUCHANNELCONSUMPTIONLIMITUP:
			{
				//p_t_data[row-1].c_max = (float)atof((char *)value);
				snmp_smart.all.pch[row].thr.w_upper = (float)atof((char *)value) * 1000;
				power_set_threshold(&snmp_smart.all.pch[row]);
			}
			break;
			default:
				return SNMP_ERR_INCONSISTENTNAME;
		}
		return SNMP_ERR_NOERROR;		
}

static const struct snmp_scalar_array_node_def sysinfo_scalars_nodes[] = {
    {1, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, 				/* product id  */
    {2, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, 				/* product name */
    {3, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, 				/* product type */
    {4, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, 				/* product firmware */
		{5, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, 				/* product channal number */
		{6, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, 				/* product sensor number */
		{0,0,0},
};



static const struct snmp_scalar_array_node_def total_scalars_node[] = {
	{SCALAR_VOLTAGE,													SNMP_ASN1_TYPE_OCTET_STRING,				  SNMP_NODE_INSTANCE_READ_ONLY,},
	{SCALAR_CURRENT,													SNMP_ASN1_TYPE_OCTET_STRING,				  SNMP_NODE_INSTANCE_READ_ONLY,},
	{SCALAR_CONSUMEPTION,											SNMP_ASN1_TYPE_OCTET_STRING,				  SNMP_NODE_INSTANCE_READ_ONLY,},
	{SCALAR_POWER_FACTOR,											SNMP_ASN1_TYPE_OCTET_STRING,				  SNMP_NODE_INSTANCE_READ_ONLY,},
	{SCALAR_PACTIVE_POWER,										SNMP_ASN1_TYPE_OCTET_STRING,				  SNMP_NODE_INSTANCE_READ_ONLY,},
	{SCALAR_REACTIVE_POWER,										SNMP_ASN1_TYPE_OCTET_STRING,				  SNMP_NODE_INSTANCE_READ_ONLY,},
	{SCALAR_APPARENT_POWER,										SNMP_ASN1_TYPE_OCTET_STRING,				  SNMP_NODE_INSTANCE_READ_ONLY,},
	{0,0,0},
};


static const struct snmp_table_col_def power_table_channels[]={
	{COLUMN_PDUCHANNELID,											SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUCHANNELNAME,										SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUCHANNELSTATUS,									SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_WRITE},
	{COLUMN_PDUCHANNELVOLTAGE,								SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUCHANNELCURRENT,								SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUCHANNELFREQUENCY,							SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUCHANNELCONSUMPTION,						SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUCHANNELPOWERFACTOR,						SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUCHANNELPACTIVEPOWER,						SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUCHANNELREACTIVEPOWER,					SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUCHANNELAPPARENTPOWER,					SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
	{0,0,0},
};



static const struct snmp_table_col_def alarm_history_table[]={
	{COLUMN_PDUALARMID,												SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUALARMTYPE,											SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUALARMCONTEXT,									SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUALARMACTION,										SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUALARMACTIONPARA,								SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUALARMDATE,											SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY},
	{COLUMN_PDUALARMTIME,											SNMP_ASN1_TYPE_OCTET_STRING,					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},
	{COLUMN_PDUCHANNELCURRENTLIMITUP,					SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_WRITE},
	{COLUMN_PDUCHANNELVOLTAGELIMITUP,					SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_WRITE},
	{COLUMN_PDUCHANNELVOLTAGELIMITDOWN,				SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_WRITE},
	{COLUMN_PDUCHANNELPOWERLIMITUP,						SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_WRITE},
	{COLUMN_PDUCHANNELCONSUMPTIONLIMITUP,			SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_WRITE},
	{0,0,0},
};

static const struct snmp_table_col_def 	sensor_limit_table[] = {
	{COLUMN_PDUSENSORLIMITID,									SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_ONLY,},
	{COLUMN_PDUSENSORLIMITNAME,								SNMP_ASN1_TYPE_OCTET_STRING,					SNMP_NODE_INSTANCE_READ_ONLY,},
	{COLUMN_PDUSENSORLIMITVALUE1UP,						SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_WRITE,},
	{COLUMN_PDUSENSORLIMITVALUE2UP,						SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_WRITE,},
	{COLUMN_PDUSENSORLIMITVALUE1DOWN,					SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_WRITE,},
	{COLUMN_PDUSENSORLIMITVALUE2DOWN,					SNMP_ASN1_TYPE_INTEGER,								SNMP_NODE_INSTANCE_READ_WRITE,},
	{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);
const struct snmp_scalar_array_node total_scalars = SNMP_SCALAR_CREATE_ARRAY_NODE(1,total_scalars_node, total_get_value, NULL, NULL);



static const struct snmp_table_node power_table = SNMP_TABLE_CREATE(9, power_table_channels, power_get_instance, power_get_next_instance, \
							power_get_value, set_test, power_set_value);



static const struct snmp_table_node alarm_table = SNMP_TABLE_CREATE(1, alarm_history_table, get_instance, get_next_instance, \
							alarm_get_value, set_test, NULL);

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, \
							thr_s_get_value, set_test, thr_s_set_value);






static const struct snmp_node *const alarm_subnodes[]={
	&alarm_table.node.node,
};
static const struct snmp_node *const power_subnodes[] = {
    &power_table.node.node,
		//&total_scalars.node.node,
};

//static const struct snmp_node *const total_subnodes[] = {
//		&total_scalars.node.node,
//    //&power_table.node.node,
//};
static const struct snmp_node *const thr_subnodes[] = {
    &thr_table.node.node,
};

static const struct snmp_node *const thr_s_subnodes[] = {
    &thr_s_table.node.node,
};


const struct snmp_tree_node power_treenode 	= SNMP_CREATE_TREE_NODE(3, power_subnodes);
//const struct snmp_tree_node total_treenode 	= SNMP_CREATE_TREE_NODE(3, total_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);


static const struct snmp_node *const mib2_nodes_dev_3[]=
{
	&total_scalars.node.node,
};


static const struct snmp_node *const mib2_nodes_dev[] =
{
    &sysinfo_scalars.node.node,
		&power_treenode.node,
		&alarm_treenode.node,
		//&total_scalars.node.node,
		//&total_treenode.node,
	  //&total_scalars.node.node,
};


static const struct snmp_node *const mib2_nodes_dev_2[]={
	&thr_treenode.node,
	&thr_s_treenode.node,
};


static const struct snmp_tree_node snmp_mib2_root_dev = SNMP_CREATE_TREE_NODE(1, mib2_nodes_dev);
static const struct snmp_tree_node snmp_mib2_thr_dev = SNMP_CREATE_TREE_NODE(7, mib2_nodes_dev_2);
static const struct snmp_tree_node snmp_mib2_totol_dev = SNMP_CREATE_TREE_NODE(3,mib2_nodes_dev_3);

static const u32_t prvmib_base_oid[] = SNMP_SMARTPDU_DEVICE_OID;
static const u32_t thr_base_oid[] = SNMP_SMARTPDU_THR_TABLE_IOD;
static const u32_t total_base_oid[] = SNMP_SMARTPDU_TOTAL_OID;

const struct snmp_mib mib2_dev = SNMP_MIB_CREATE(prvmib_base_oid, &snmp_mib2_root_dev.node);
const struct snmp_mib mib2_th_dev = SNMP_MIB_CREATE(thr_base_oid, &snmp_mib2_thr_dev.node);
const struct snmp_mib mib2_totol_dev = SNMP_MIB_CREATE(total_base_oid, &snmp_mib2_totol_dev.node);


static const struct snmp_mib *dev_mibs[] = {&mib2, &mib2_dev,&mib2_th_dev,&mib2_totol_dev};








void netif_event_callback(struct netif *netif) {
    //snmp_ifType ifType = netif->link_type == NETIF_TYPE_ETHERNET ? ifTypeEthernetCsmacd : ifTypeOther;
    //snmp_insert_ipnetif(netif, ifType); // 将网络接口添加到 SNMP MIB-2 中
}

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);
    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_set_mibs(&dev_mibs[0], LWIP_ARRAYSIZE(dev_mibs));
    snmp_set_community("public");
    snmp_set_community_write("public");	
}

int snmp2_init(void)
{
	
	mibs_init();
  snmp_init();

    
    return 0;
}


int snmp2_deinit(void)
{
    
    return 0;
}