SmartPDCode/f427/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"
#include "sensor.h"
#include "paras.h"
#include "pthread.h"
#include "rtthread.h"







#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}
#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;
	pthread_mutex_t mutex;
	pthread_cond_t cond;
	pthread_t       id;
}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,
		},
};



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 struct snmp_oid_range th_sensor_oid_ranges[] = {
		{1,MAX_SENSOR},
};




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 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);
		sensor_all_t *sensor = sensor_get_data();
		char buff[50]= {0};
		if(!sensor)
			return 0;
		switch(col)
		{
			case  COLUMN_PDUSENSORID:
			{
				*(s32_t *)value	= row;
				return 4;				
			}
			case COLUMN_PDUSENSORNAME:
			{
				sprintf(buff,"%s",sensor->data[row-1].info.name);
			}
				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);
	
}


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);
		sensor_all_t * sensor = sensor_get_data();
		paras_data_t *p=paras_get();
		uint32_t val = *(uint32_t *)value;
		if(sensor->data == 0)
		{
			return SNMP_ERR_NOTWRITABLE;
		}
		switch(col)
		{
			case COLUMN_PDUSENSORLIMITVALUE1UP:
			{
				sensor->data[row-1].val[0].thr.max = (val/100.0);
				p->sensor[row-1].th_max_1 = val;
				if(val)
				{
					sensor->data[row-1].val[0].thr.en.th_sen_max_en = 1;
				}else
				{
					sensor->data[row-1].val[0].thr.en.th_sen_max_en = 0;
				}
			}
				break;
			case COLUMN_PDUSENSORLIMITVALUE2UP:
			{
				sensor->data[row-1].val[1].thr.max = (val/100.0);
				p->sensor[row-1].th_max_2 = val;
				if(val)
				{
					sensor->data[row-1].val[1].thr.en.th_sen_max_en = 1;
				}else
				{
					sensor->data[row-1].val[1].thr.en.th_sen_max_en = 0;
				}				
			}
				break;
			case COLUMN_PDUSENSORLIMITVALUE1DOWN:
			{
				sensor->data[row-1].val[0].thr.min = (val/100.0);
				p->sensor[row-1].th_min_1 = val;
				if(val)
				{
					sensor->data[row-1].val[0].thr.en.th_sen_min_en = 1;
				}else
				{
					sensor->data[row-1].val[0].thr.en.th_sen_min_en = 0;
				}
			}
				break;
			case COLUMN_PDUSENSORLIMITVALUE2DOWN:
			{
				sensor->data[row-1].val[1].thr.min = (val/100.0);
				p->sensor[row-1].th_min_2 = val;
				if(val)
				{
					sensor->data[row-1].val[1].thr.en.th_sen_min_en = 1;
				}else
				{
					sensor->data[row-1].val[1].thr.en.th_sen_min_en = 0;
				}	
			}
				break;
			default:
				return SNMP_ERR_NOTWRITABLE;
		}
		
		paras_save();
		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);
		sensor_all_t *sensor = sensor_get_data();
		char buff[50]= {0};
		switch(col)
		{
			case COLUMN_PDUSENSORLIMITID:
			{
				*(s32_t *)value	= row;
				return 4;
			}
			break;
			case COLUMN_PDUSENSORLIMITNAME:
			{
				sprintf(buff,"%s",sensor->data[row-1].info.name);
			}
				break;
			case COLUMN_PDUSENSORLIMITVALUE1UP:
			{
				*(s32_t *)value	= (sensor->data[row-1].val[0].thr.max * 100);
				return 4;
			}
				break;
			case COLUMN_PDUSENSORLIMITVALUE2UP:
			{
				*(s32_t *)value	= (sensor->data[row-1].val[1].thr.max * 100);
				return 4;
			}
			break;
			case COLUMN_PDUSENSORLIMITVALUE1DOWN:
			{
				*(s32_t *)value	= (sensor->data[row-1].val[0].thr.min * 100);
				return 4;
			}
			break;
			case COLUMN_PDUSENSORLIMITVALUE2DOWN:
			{
				*(s32_t *)value	= (sensor->data[row-1].val[1].thr.min * 100);
				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)
{
		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);
		char buff[50]= {0};
		switch (col)
		{
			case COLUMN_PDUCHANNELLIMITID:
			{
				*(s32_t *)value	= row-1;
				return 4;
			}
				break;
			case COLUMN_PDUCHANNELLIMITNAME:
			{
				sprintf(buff,"%s",all->pch[row-1].info.name);
			}
			break;
			case COLUMN_PDUCHANNELCURRENTLIMITUP:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].thr.c_upper/10.0));
			}
			break;
			case COLUMN_PDUCHANNELVOLTAGELIMITUP:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].thr.v_upper/10.0));
			}
			break;
			case COLUMN_PDUCHANNELVOLTAGELIMITDOWN:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].thr.v_lower/10.0));
			}
			break;
			case COLUMN_PDUCHANNELPOWERLIMITUP:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].thr.p_upper/10.0));
			}
			break;
			case COLUMN_PDUCHANNELCONSUMPTIONLIMITUP:
			{
				sprintf(buff,"%.2f",((float)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)
{
	power_all_t *all = power_get_all();
	th_table_oid_ranges[0].max = 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 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 */
        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)
{
    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);
		power_all_t *all = power_get_all();
    for (i = 0; i < 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_all_t *all = power_get_all();
    //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 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();
    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",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 = all->pch[row-1].status;
				return 4;
			}
				break;
			case COLUMN_PDUCHANNELVOLTAGE:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].power[0].voltage)/10.0);
			}
				break;
			case COLUMN_PDUCHANNELCURRENT:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].power[0].current)/10.0);
			}
				break;
			case COLUMN_PDUCHANNELFREQUENCY:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].power[0].freq)/100.0);
			}
				break;
			case COLUMN_PDUCHANNELCONSUMPTION:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].power[0].consump)/1000.0);
			}
				break;
			case COLUMN_PDUCHANNELPOWERFACTOR:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].power[0].factor)/100.0);
			}
				break;
			case COLUMN_PDUCHANNELPACTIVEPOWER:
			{
				sprintf(buff,"%.2f",((float)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)
{
		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_PDUCHANNELSTATUS:
			{
				//p_data[row-1].status = *(uint32_t*)value;
				all->pch[row].status = *(uint32_t*)value;
				power_set_ch_sw_n(&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);
		power_all_t *all = power_get_all();
		switch(col)
		{
			case COLUMN_PDUCHANNELCURRENTLIMITUP:
			{
				all->pch[row].thr.c_upper = (float)atof((char *)value) * 10;
				//p_t_data[row-1].i_max = (float)atof((char *)value);
				//all->pch[row-1]
				power_set_threshold(&all->pch[row]);
			}
			break;
			case COLUMN_PDUCHANNELVOLTAGELIMITUP:
			{
				//p_t_data[row-1].v_max = (float)atof((char *)value);
				all->pch[row].thr.v_upper = (float)atof((char *)value) * 10;
				power_set_threshold(&all->pch[row]);
			}
			break;
			case COLUMN_PDUCHANNELVOLTAGELIMITDOWN:
			{
				all->pch[row].thr.v_lower = (float)atof((char *)value) * 10;
				power_set_threshold(&all->pch[row]);
				//p_t_data[row-1].v_min = (float)atof((char *)value);
				//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);
				all->pch[row].thr.p_upper = (float)atof((char *)value) * 1000;
				power_set_threshold(&all->pch[row]);
			}
			break;
			case COLUMN_PDUCHANNELCONSUMPTIONLIMITUP:
			{
				//p_t_data[row-1].c_max = (float)atof((char *)value);
				all->pch[row].thr.w_upper = (float)atof((char *)value) * 1000;
				power_set_threshold(&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_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 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},
	{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},
};

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);

static s16_t get_total_scalar_value(struct snmp_node_instance *instance , void* data)
{
	power_all_t *all = power_get_all();
	char buff[100] = {0};
	switch(instance->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;
	}
	 memcpy(data,buff,strlen(buff));
   return strlen(buff);	
}


const struct snmp_scalar_node voltage_scalar = SNMP_SCALAR_CREATE_NODE(SCALAR_VOLTAGE,SNMP_NODE_INSTANCE_READ_ONLY,SNMP_ASN1_TYPE_OCTET_STRING,get_total_scalar_value,NULL,NULL);
const struct snmp_scalar_node current_scalar = SNMP_SCALAR_CREATE_NODE(SCALAR_CURRENT,SNMP_NODE_INSTANCE_READ_ONLY,SNMP_ASN1_TYPE_OCTET_STRING,get_total_scalar_value,NULL,NULL);
const struct snmp_scalar_node consumer_scalar = SNMP_SCALAR_CREATE_NODE(SCALAR_CONSUMEPTION,SNMP_NODE_INSTANCE_READ_ONLY,SNMP_ASN1_TYPE_OCTET_STRING,get_total_scalar_value,NULL,NULL);
const struct snmp_scalar_node factor_scalar = SNMP_SCALAR_CREATE_NODE(SCALAR_POWER_FACTOR,SNMP_NODE_INSTANCE_READ_ONLY,SNMP_ASN1_TYPE_OCTET_STRING,get_total_scalar_value,NULL,NULL);
const struct snmp_scalar_node pactive_scalar = SNMP_SCALAR_CREATE_NODE(SCALAR_PACTIVE_POWER,SNMP_NODE_INSTANCE_READ_ONLY,SNMP_ASN1_TYPE_OCTET_STRING,get_total_scalar_value,NULL,NULL);
const struct snmp_scalar_node reactive_scalar = SNMP_SCALAR_CREATE_NODE(SCALAR_REACTIVE_POWER,SNMP_NODE_INSTANCE_READ_ONLY,SNMP_ASN1_TYPE_OCTET_STRING,get_total_scalar_value,NULL,NULL);
const struct snmp_scalar_node appactive_scalar = SNMP_SCALAR_CREATE_NODE(SCALAR_APPARENT_POWER,SNMP_NODE_INSTANCE_READ_ONLY,SNMP_ASN1_TYPE_OCTET_STRING,get_total_scalar_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_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(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,
		&voltage_scalar.node.node,
		&current_scalar.node.node,
		&consumer_scalar.node.node,
		&factor_scalar.node.node,
		&pactive_scalar.node.node,
		&reactive_scalar.node.node,
		&appactive_scalar.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,
};

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);




static const struct snmp_node *const mib2_nodes_dev[] =
{
    &sysinfo_scalars.node.node,
		&power_treenode.node,
		&alarm_treenode.node,
		&sensor_treenode.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 u32_t prvmib_base_oid[] = SNMP_SMARTPDU_DEVICE_OID;
static const u32_t thr_base_oid		[] = SNMP_SMARTPDU_THR_TABLE_IOD;

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);



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_INTEGER;
    vb.value = (void*)&(data->ID);
    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->AlarmDate);
    vb2.value_len = strlen(data->AlarmDate);	
		
	  vb3.type = SNMP_ASN1_TYPE_OCTET_STRING;
    vb3.value = (void*)(&data->AlarmContext);
    vb3.value_len = strlen(data->AlarmContext);	
		
		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_INTEGER;
    vb.value = (void*)&(data->ID);;
    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);	
}

AlarmTrapinfo data = {
		2,
		1,
		"dasdasdasdas",
		"dasdasdjkhasdjia"
};


//void *snmp_thread(void *args)
//{
//	while(1)
//	{
//		 pthread_mutex_lock(&snmp_smart.mutex);
//		 while(pthread_cond_wait(&snmp_smart.cond, &snmp_smart.mutex));
//		 if(paras_get()->snmp.trapmode == 1)
//			 snmp_power_alarm_trap(&data);
////				system("snmp");
//			
//		 pthread_mutex_unlock(&snmp_smart.mutex);
//	}
//}


//void send_snmp_tarp(void)
//{
//	pthread_mutex_lock(&snmp_smart.mutex);
//	pthread_cond_signal(&snmp_smart.cond);
//	pthread_mutex_unlock(&snmp_smart.mutex);
//}


void cmd_snmp_test(int argc, char **argv)
{
#if 0
    struct snmp_varbind vb;
    memset(&vb, 0, sizeof(struct snmp_varbind));
    char *str = "trap test";

    static const u32_t oid[] = {1, 3, 6, 1, 4, 1, 5888, 1, 5, 0};
    snmp_oid_assign(&vb.oid, oid, LWIP_ARRAYSIZE(oid));
    vb.type = SNMP_ASN1_TYPE_OCTET_STRING;
    vb.value = (void *)str;
    vb.value_len = strlen(str);

    snmp_send_trap_specific(0, &vb);
	
#endif
	

	snmp_power_alarm_trap(&data);
	
    // snmp_send_trap_generic(SNMP_GENTRAP_COLDSTART);
}
MSH_CMD_EXPORT_ALIAS(cmd_snmp_test, snmp, snmp agent test);




void netif_event_callback(struct netif *netif) {

}

static void mibs_init(void) {
			paras_data_t *para = paras_get();
			//snmp_v2c_enable(1);
			//snmp_v2c_enabled();
//		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);
	
//		pthread_mutex_init(&snmp_smart.mutex,NULL);
//	  pthread_cond_init(&snmp_smart.cond,NULL);
//	
	
    snmp_set_auth_traps_enabled(SNMP_AUTH_TRAPS_DISABLED);
		snmp_strap_set();

    snmp_set_mibs(&dev_mibs[0], LWIP_ARRAYSIZE(dev_mibs));
    snmp_set_community("public");
		if(strncmp(para->snmp.publics,"public",strlen("public")))
		{
			snmp_set_community_write("public");	
		}else
		{
			snmp_set_community_write("private");	
		}
		
		//snmp_send_trap_specific();
		
//		pthread_create(&snmp_smart.id,NULL,snmp_thread,NULL);
		//pthread_detach(snmp_smart.id);
}

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)
{
    
    return 0;
}