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"
#include "wanning.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};
		power_handle_new_t *all = power_get_all();
		paras_data_t *p=paras_get();
		switch(node->oid)
		{
			case 1:
			{
				sprintf(buff,"GCG-GD32F427-%d",p->cas.addr);
			}
			break;
			case 2:
			{
					sprintf(buff,"%s",p->prod.name);
			}
			break;
			case 3:
			{
				sprintf(buff,"%s",(p->prod.type == 0) ? "AC-AC" : 
												  (p->prod.type == 1) ? "DC-DC" : 
				                  (p->prod.type == 3) ? "AC3-AC3" :
													((p->prod.type == 4) || (p->prod.type == 5)) ? "AC3-AC1" :
													(p->prod.type == 6) ? "AC3-AC2" : "Other");			
			}
			break;
			case 4:
			{
					sprintf(buff,"%s",p->prod.pnumber);					
			}
			break;
			case 5:
			{
				sprintf(buff,"%d",all->chs);		
			}				
			break;
			case 6:
			{
				sprintf(buff,"%d",3);	
			}
			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_handle_new_t *all = power_get_all();
		uint8_t id = 0;
		switch(node->oid)
		{
			case SCALAR_VOLTAGE:
			{
				sprintf(buff,"%.2f",all->total.all.voltage);
			}
			break;
			case SCALAR_CURRENT:
			{
				sprintf(buff,"%.2f",all->total.all.current);
			}
			break;
			case SCALAR_CONSUMEPTION:
			{
				sprintf(buff,"%.2f",all->total.all.consump);
			}
			break;
			case SCALAR_POWER_FACTOR:
			{
				sprintf(buff,"%.2f",all->total.all.factor);
			}
			break;
			case SCALAR_PACTIVE_POWER:
			{
				sprintf(buff,"%.2f",all->total.all.power);
			}
			break;
			case SCALAR_REACTIVE_POWER:
			{
				sprintf(buff,"%.2f",all->total.all.reactive_power);
			}
			break;
			case  SCALAR_APPARENT_POWER:
			{
				sprintf(buff,"%.2f",all->total.all.app_power);
			}
			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 struct snmp_oid_range th_table_oid_ranges[] = {
    {1, POWER_VALUE},
};

static struct snmp_oid_range th_sensor_oid_ranges[] = {
		{1,MAX_SENSOR},
};


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.sens[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.sens[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.sens[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.sens[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_handle_new_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));
			}
			break;
			case COLUMN_PDUCHANNELVOLTAGELIMITUP:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].thr.v_upper));
			}
			break;
			case COLUMN_PDUCHANNELVOLTAGELIMITDOWN:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].thr.v_lower));
			}
			break;
			case COLUMN_PDUCHANNELPOWERLIMITUP:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].thr.p_upper));
			}
			break;
			case COLUMN_PDUCHANNELCONSUMPTIONLIMITUP:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].thr.w_upper));
			}
			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);
		waning_info_t *info = {0};
		info = waning_get_info(row-1);
		
		char buff[50]= {0};
		switch (col)
		{
			case COLUMN_PDUALARMID:
			{
				*(s32_t *)value	= row-1;
				return 4;
			}
			break;
			case COLUMN_PDUALARMTYPE:
			{
				*(s32_t *)value	= info->type;
				return 4;				
			}
			break;
			case COLUMN_PDUALARMCONTEXT:
			{
				sprintf(buff,"%s",info->waning_context);
			}
			break;
			case COLUMN_PDUALARMACTION:
			{
				*(s32_t *)value	= 0;
				return 4;				
			}
			break;
			case COLUMN_PDUALARMACTIONPARA:
			{
				*(s32_t *)value	= 0;
				return 4;
			}
			break;
			case COLUMN_PDUALARMDATE:
			{
				snprintf(buff,10,"%s",info->date);
			}
			break;
			case COLUMN_PDUALARMTIME:
			{
				char * _info = &(info->date[11]);
				snprintf(buff,8,"%s",_info);
			}
			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_handle_new_t *all = power_get_all();
	th_table_oid_ranges[0].max = all->chs;
	
	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  uint8_t ph_cont = 0;

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_handle_new_t *all = power_get_all();
    for (i = 0; i < all->chs; i++)
    {
        u32_t test_oid = i + 1;
        snmp_next_oid_check(&state, &test_oid, 1, NULL);
    }

    if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS)
    {
#if 0
			if(all->ttl.type == PDU_AC_I3O3)
			{
				if(ph_cont==3)
				{
					snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len);
					cell_instance->reference.u32 = *state.next_oid; /* 下个节点行OID */
					cell_instance->reference.u32++;	
					ph_cont=0;					
				}
			}else if(all->ttl.type == PDU_AC_I3O2)
			{
				if(ph_cont == 2)
				{
					snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len);
					cell_instance->reference.u32 = *state.next_oid; /* 下个节点行OID */
					cell_instance->reference.u32++;			
					ph_cont=0;					
				}
			}else
#endif
			{
        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;
		wanning_get_count();
    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 < wanning_get_count(); 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_handle_new_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].info.alarm.l1_v_upper;
			}
			break;
			case COLUMN_PDUCHANNELPOWERALARMVOLTAGEDOWN:
			{
				*(s32_t *)value	= all->pch[row-1].info.alarm.l1_v_lower;
			}
			break;
			case COLUMN_PDUCHANNELPOWERALARMCURRENTUP:
			{
				*(s32_t *)value	= all->pch[row-1].info.alarm.l1_c_upper;
			}
			break;		
			case COLUMN_PDUCHANNELPOWERALARMPOWERUP:
			{
				*(s32_t *)value	= all->pch[row-1].info.alarm.l1_p_upper;
			}
			break;		
			case COLUMN_PDUCHANNELPOWERALARMCONSUMPTIONUP:
			{
				*(s32_t *)value	= all->pch[row-1].info.alarm.l1_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_handle_new_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};
		uint8_t id = 0;
		if( all->power_type == PDU_AC_I3O1 || all->power_type == PDU_AC_I3O1_H)
		{
			id = all->pch[row-1].info.pse.ph -1;
		}else if(all->power_type == PDU_AC_I3O2)
		{
			id = all->pch[row-1].info.pse.ph2.ph_l - 1;
		}
		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].info.status;
				return 4;
			}
				break;
			case COLUMN_PDUCHANNELVOLTAGE:
			{
				sprintf(buff,"%.2f",(float)all->pch[row-1].power[id].voltage);
			}
				break;
			case COLUMN_PDUCHANNELCURRENT:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].power[id].current));
			}
				break;
			case COLUMN_PDUCHANNELFREQUENCY:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].power[id].freq));
			}
				break;
			case COLUMN_PDUCHANNELCONSUMPTION:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].power[id].consump));
			}
				break;
			case COLUMN_PDUCHANNELPOWERFACTOR:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].power[id].factor));
			}
				break;
			case COLUMN_PDUCHANNELPACTIVEPOWER:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].power[id].power));
			}
				break;
			case COLUMN_PDUCHANNELREACTIVEPOWER:
			{

				sprintf(buff,"%.2f",((float)all->pch[row-1].power[id].reactive_power));
			}
				break;
			case COLUMN_PDUCHANNELAPPARENTPOWER:
			{
				sprintf(buff,"%.2f",((float)all->pch[row-1].power[id].app_power));
			}
				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_handle_new_t *all = power_get_all();
	  u32_t row = instance->reference.u32;
    u32_t col = SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id);
		if(row == 0)
			return SNMP_ERR_NOERROR;
		int ch = row -1;
		power_ch_new_t *pch = &all->pch[ch];
		switch(col)
		{
			case  COLUMN_PDUCHANNELSTATUS:
			{
				uint32_t val = *(uint32_t*)value;
				all->set_status(pch->info.addr,pch->info.sch,val);
			}
				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);
		if(row == 0)
			return SNMP_ERR_NOERROR;
		power_handle_new_t *all = power_get_all();
		thr_t th = all->pch[row-1].thr;
		switch(col)
		{
			case COLUMN_PDUCHANNELCURRENTLIMITUP:
			{
				th.c_upper = (float)atof((char *)value);	
			}
			break;
			case COLUMN_PDUCHANNELVOLTAGELIMITUP:
			{
				th.v_upper = (float)atof((char *)value);
			}
			break;
			case COLUMN_PDUCHANNELVOLTAGELIMITDOWN:
			{
				th.v_lower = (float)atof((char *)value);
			}
			break;
			case COLUMN_PDUCHANNELPOWERLIMITUP:
			{

				th.p_upper = (float)atof((char *)value);
			}
			break;
			case COLUMN_PDUCHANNELCONSUMPTIONLIMITUP:
			{
				th.w_upper = (float)atof((char *)value);
			}
			break;
			default:
				return SNMP_ERR_INCONSISTENTNAME;
		}
		all->set_thr(all->pch[row-1].info.addr,all->pch[row-1].info.sch,&th);
		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_handle_new_t *all = power_get_all();
	char buff[100] = {0};
	switch(instance->node->oid)
	{
		case SCALAR_VOLTAGE:
			sprintf(buff,"%.2f",all->total.all.voltage);
		break;
		case SCALAR_CURRENT:
			sprintf(buff,"%.2f",all->total.all.current);
		break;
		case SCALAR_CONSUMEPTION:
			sprintf(buff,"%.2f",all->total.all.consump);
		break;
		case SCALAR_POWER_FACTOR:
			sprintf(buff,"%.2f",all->total.all.factor);
		break;
		case SCALAR_PACTIVE_POWER:
			sprintf(buff,"%.2f",all->total.all.power);
		break;
		case SCALAR_REACTIVE_POWER:
			sprintf(buff,"%.2f",all->total.all.reactive_power);
		break;
		case SCALAR_APPARENT_POWER:
			sprintf(buff,"%.2f",all->total.all.app_power);
			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};

AlarmTrapinfo data;


void snmp_alarm_trap(AlarmTrapinfo *data, uint8_t flag)
{
		struct snmp_varbind vb={0},vb1={0},vb2={0},vb3={0};
		int a= 1,b=2,c=3;
		u32_t oid_1[9] = {1,3,6,1,4,1,2024,2};
		if(flag == 0)
		{
			oid_1[8] = 1;
		}else
		{
			oid_1[8] = 2;
		}
		//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->AlarmContext);
    vb2.value_len = strlen(data->AlarmContext);	
		
	  vb3.type = SNMP_ASN1_TYPE_OCTET_STRING;
    vb3.value = (void*)(&data->AlarmDate);
    vb3.value_len = strlen(data->AlarmDate);	
		
		vb.next = &vb1;
		vb1.next = &vb2;
		vb2.next = &vb3;
		vb3.prev = &vb2;
		vb2.prev = &vb1;
		vb1.prev = &vb;		
		
    snmp_send_trap_specific(SNMP_GENTRAP_COLDSTART, &vb);
		//snmp_send_trap_specific(SNMP_GENTRAP_COLDSTART, &vb1);
		//snmp_send_trap_specific(SNMP_GENTRAP_COLDSTART, &vb2);
		//snmp_send_trap_specific(SNMP_GENTRAP_COLDSTART, &vb3);

}



void 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);
		snmp_power_alarm_trap(&data,0);
#endif	
    // 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 char  read_only[32] = {0};
static char  read_write[32] = {0};

static void mibs_init(void) {
		paras_data_t *para = paras_get();
	
    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(para->snmp.publics);   //only read
		snmp_set_community_write(para->snmp.privates); //read write
		
		
}

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