#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}; 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); 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); //sprintf(buff,"%s",p_a_data[row-1].date); } break; case COLUMN_PDUALARMTIME: { char * _info = &(info->date[11]); snprintf(buff,8,"%s",_info); // 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 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_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) { #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_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.l1_v_upper; } break; case COLUMN_PDUCHANNELPOWERALARMVOLTAGEDOWN: { *(s32_t *)value = all->pch[row-1].alarm.l1_v_lower; } break; case COLUMN_PDUCHANNELPOWERALARMCURRENTUP: { *(s32_t *)value = all->pch[row-1].alarm.l1_c_upper; } break; case COLUMN_PDUCHANNELPOWERALARMPOWERUP: { *(s32_t *)value = all->pch[row-1].alarm.l1_p_upper; } break; case COLUMN_PDUCHANNELPOWERALARMCONSUMPTIONUP: { *(s32_t *)value = all->pch[row-1].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_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)/100.0); } break; case COLUMN_PDUCHANNELCURRENT: { sprintf(buff,"%.2f",((float)all->pch[row-1].power[0].current)/100.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)/100.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)/100.0); } break; case COLUMN_PDUCHANNELREACTIVEPOWER: { float reactive = 0.0; if(all->pch[row-1].power[0].power > 0) { reactive = (float)(all->pch[row-1].power[0].power) / all->pch[row-1].power[0].factor - ((float)all->pch[row-1].power[0].power/100.0); } sprintf(buff,"%.2f",reactive); } break; case COLUMN_PDUCHANNELAPPARENTPOWER: { float app_power = 0.0; if(all->pch[row-1].power[0].power > 0) app_power = (float)(all->pch[row-1].power[0].power) / all->pch[row-1].power[0].factor; sprintf(buff,"%.2f",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_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) * 100; //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) * 100; power_set_threshold(&all->pch[row]); } break; case COLUMN_PDUCHANNELVOLTAGELIMITDOWN: { all->pch[row].thr.v_lower = (float)atof((char *)value) * 100; 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) * 100; 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) * 100; 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, ¤t_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->AlarmContext); vb2.value_len = strlen(data->AlarmContext); vb3.type = SNMP_ASN1_TYPE_OCTET_STRING; vb3.value = (void*)(&data->AlarmDate); vb3.value_len = strlen(data->AlarmDate); vb.next = &vb1; vb1.next = &vb2; vb2.next = &vb3; vb3.prev = &vb2; vb2.prev = &vb1; vb1.prev = &vb; snmp_send_trap_specific(SNMP_GENTRAP_COLDSTART, &vb); //snmp_send_trap_specific(SNMP_GENTRAP_COLDSTART, &vb1); //snmp_send_trap_specific(SNMP_GENTRAP_COLDSTART, &vb2); //snmp_send_trap_specific(SNMP_GENTRAP_COLDSTART, &vb3); } void snmp_sensor_alarm_trap(AlarmTrapinfo *data) { struct snmp_varbind vb={0},vb1={0},vb2={0},vb3={0}; int a= 1,b=2,c=3; const u32_t oid_1[]={1,3,6,1,4,1,2024,2,2}; const u32_t pduAlarmID_oid[] = { 1,3,6,1,4,1,2024,1,6,1,1,2, data->ID}; const u32_t pduAlarmContext_oid[] = { 1,3,6,1,4,1,2024,1,6,1,1,3, data->ID}; const u32_t pduAlarmDate_oid[] = { 1,3,6,1,4,1,2024,1,6,1,1,6,data->ID}; snmp_oid_assign(&vb.oid, oid_1, LWIP_ARRAYSIZE(oid_1)); snmp_oid_assign(&vb1.oid, pduAlarmID_oid, LWIP_ARRAYSIZE(pduAlarmID_oid)); snmp_oid_assign(&vb2.oid, pduAlarmContext_oid, LWIP_ARRAYSIZE(pduAlarmContext_oid)); snmp_oid_assign(&vb3.oid, pduAlarmDate_oid, LWIP_ARRAYSIZE(pduAlarmDate_oid)); vb.type = SNMP_ASN1_TYPE_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; }