// Copyright (c) 2023 Cesanta Software Limited // All rights reserved #include #include "net.h" #include "appl.h" #include "modbus.h" // Authenticated user. // A user can be authenticated by: // - a name:pass pair, passed in a header Authorization: Basic ..... // - an access_token, passed in a header Cookie: access_token=.... // When a user is shown a login screen, she enters a user:pass. If successful, // a server responds with a http-only access_token cookie set. struct user { const char *name, *pass, *access_token; }; // Settings struct settings { bool log_enabled; int log_level; long brightness; char *device_name; }; static struct settings s_settings = {true, 1, 57, NULL}; static const char *s_json_header = "Content-Type: application/json\r\n" "Cache-Control: no-cache\r\n"; static uint64_t s_boot_timestamp = 0; // Updated by SNTP // This is for newlib and TLS (mbedTLS) uint64_t mg_now(void) { return mg_millis() + s_boot_timestamp; } int ui_event_next(int no, struct ui_event *e) { if (no < 0 || no >= MAX_EVENTS_NO) return 0; srand((unsigned) no); e->type = (uint8_t) rand() % 4; e->prio = (uint8_t) rand() % 3; e->timestamp = (unsigned long) ((int64_t) mg_now() - 86400 * 1000 /* one day back */ + no * 300 * 1000 /* 5 mins between alerts */ + 1000 * (rand() % 300) /* randomize event time */) / 1000UL; mg_snprintf(e->text, MAX_EVENT_TEXT_SIZE, "event#%d", no); return no + 1; } // SNTP connection event handler. When we get a response from an SNTP server, // adjust s_boot_timestamp. We'll get a valid time from that point on static void sfn(struct mg_connection *c, int ev, void *ev_data) { uint64_t *expiration_time = (uint64_t *) c->data; if (ev == MG_EV_OPEN) { *expiration_time = mg_millis() + 3000; // Store expiration time in 3s } else if (ev == MG_EV_SNTP_TIME) { uint64_t t = *(uint64_t *) ev_data; s_boot_timestamp = t - mg_millis(); c->is_closing = 1; } else if (ev == MG_EV_POLL) { if (mg_millis() > *expiration_time) c->is_closing = 1; } } static void timer_sntp_fn(void *param) { // SNTP timer function. Sync up time mg_sntp_connect(param, "udp://time.google.com:123", sfn, NULL); } // Parse HTTP requests, return authenticated user or NULL static struct user *authenticate(struct mg_http_message *hm) { // In production, make passwords strong and tokens randomly generated // In this example, user list is kept in RAM. In production, it can // be backed by file, database, or some other method. static struct user users[] = { {"admin", "admin", "admin_token"}, {"user1", "user1", "user1_token"}, {"user2", "user2", "user2_token"}, {NULL, NULL, NULL}, }; char user[64], pass[64]; struct user *u, *result = NULL; mg_http_creds(hm, user, sizeof(user), pass, sizeof(pass)); MG_VERBOSE(("user [%s] pass [%s]", user, pass)); if (user[0] != '\0' && pass[0] != '\0') { // Both user and password is set, search by user/password for (u = users; result == NULL && u->name != NULL; u++) if (strcmp(user, u->name) == 0 && strcmp(pass, u->pass) == 0) result = u; } else if (user[0] == '\0') { // Only password is set, search by token for (u = users; result == NULL && u->name != NULL; u++) if (strcmp(pass, u->access_token) == 0) result = u; } return result; } static void handle_login(struct mg_connection *c, struct user *u) { char cookie[256]; mg_snprintf(cookie, sizeof(cookie), "Set-Cookie: access_token=%s; Path=/; " "%sHttpOnly; SameSite=Lax; Max-Age=%d\r\n", u->access_token, c->is_tls ? "Secure; " : "", 3600 * 24); mg_http_reply(c, 200, cookie, "{%m:%m}", MG_ESC("user"), MG_ESC(u->name)); } static void handle_logout(struct mg_connection *c) { char cookie[256]; mg_snprintf(cookie, sizeof(cookie), "Set-Cookie: access_token=; Path=/; " "Expires=Thu, 01 Jan 1970 00:00:00 UTC; " "%sHttpOnly; Max-Age=0; \r\n", c->is_tls ? "Secure; " : ""); mg_http_reply(c, 200, cookie, "true\n"); } static void handle_debug(struct mg_connection *c, struct mg_http_message *hm) { int level = mg_json_get_long(hm->body, "$.level", MG_LL_DEBUG); mg_log_set(level); mg_http_reply(c, 200, "", "Debug level set to %d\n", level); } static size_t print_int_arr(void (*out)(char, void *), void *ptr, va_list *ap) { size_t i, len = 0, num = va_arg(*ap, size_t); // Number of items in the array int *arr = va_arg(*ap, int *); // Array ptr for (i = 0; i < num; i++) { len += mg_xprintf(out, ptr, "%s%d", i == 0 ? "" : ",", arr[i]); } return len; } static void handle_stats_get(struct mg_connection *c) { int points[] = {21, 22, 22, 19, 18, 20, 23, 23, 22, 22, 22, 23, 22}; mg_http_reply(c, 200, s_json_header, "{%m:%d,%m:%d,%m:[%M]}\n", MG_ESC("temperature"), 21, // MG_ESC("humidity"), 67, // MG_ESC("points"), print_int_arr, sizeof(points) / sizeof(points[0]), points); } static size_t print_events(void (*out)(char, void *), void *ptr, va_list *ap) { size_t len = 0; struct ui_event ev; int pageno = va_arg(*ap, int); int no = (pageno - 1) * EVENTS_PER_PAGE; int end = no + EVENTS_PER_PAGE; while ((no = ui_event_next(no, &ev)) != 0 && no <= end) { len += mg_xprintf(out, ptr, "%s{%m:%lu,%m:%d,%m:%d,%m:%m}\n", // len == 0 ? "" : ",", // MG_ESC("time"), ev.timestamp, // MG_ESC("type"), ev.type, // MG_ESC("prio"), ev.prio, // MG_ESC("text"), MG_ESC(ev.text)); } return len; } static void handle_events_get(struct mg_connection *c, struct mg_http_message *hm) { int pageno = mg_json_get_long(hm->body, "$.page", 1); mg_http_reply(c, 200, s_json_header, "{%m:[%M], %m:%d}\n", MG_ESC("arr"), print_events, pageno, MG_ESC("totalCount"), MAX_EVENTS_NO); } static void handle_settings_set(struct mg_connection *c, struct mg_str body) { struct Settings_t* set = &APPL.Set.s; struct chanmqtt_t* mqtt = &APPL.chanmqtt[2]; int cmd; int param; bool ok = true; int rc; long val; int i; char buf[128]; char* p; val = mg_json_get_long(body, "$.cmd", -1); if(val != -1){ cmd = val; syslog(LOG_INFO,"%s, cmd:%d", __func__, cmd); switch (cmd) { case SETTINGS_CMD_SET_CLOUD_USERNAME: p = mg_json_get_str(body, "$.param"); if( p != NULL){ strcpy(set->szCloudUserName, p); free(p); if(appl_cfg_save() != 0){ appl_cfg_set_err(); ok = false; syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_CLOUD_USERNAME, appl_cfg_save Fail", __func__); } }else{ ok = false; syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_CLOUD_USERNAME, mg_json_get_str Fail", __func__); } break; case SETTINGS_CMD_SET_CLOUD_PASSWD: p = mg_json_get_str(body, "$.param"); if( p != NULL){ strcpy(set->szCloudPasswd, p); free(p); if(appl_cfg_save() != 0){ appl_cfg_set_err(); ok = false; syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_CLOUD_PASSWD, appl_cfg_save Fail", __func__); } }else{ ok = false; syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_CLOUD_PASSWD, mg_json_get_str Fail", __func__); } break; case SETTINGS_CMD_SET_CLOUD_URL: p = mg_json_get_str(body, "$.param"); if( p != NULL){ strcpy(set->szCloudUrl, p); free(p); if(appl_cfg_save() != 0){ appl_cfg_set_err(); ok = false; syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_CLOUD_URL, appl_cfg_save Fail", __func__); } }else{ ok = false; syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_CLOUD_URL, mg_json_get_str Fail", __func__); } break; case SETTINGS_CMD_SET_CLOUD_CLIENTID: p = mg_json_get_str(body, "$.param"); if( p != NULL){ strcpy(set->szClientId, p); free(p); if(appl_cfg_save() != 0){ appl_cfg_set_err(); ok = false; syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_CLOUD_CLIENTID, appl_cfg_save Fail", __func__); } }else{ ok = false; syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_CLOUD_CLIENTID, mg_json_get_str Fail", __func__); } break; case SETTINGS_CMD_SET_UPLOADHIHGSPEED: val = mg_json_get_long(body, "$.param", -1); if( val == -1 ){ ok = false; syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_UPLOADHIHGSPEED, mg_json_get_long Fail", __func__); }else{ set->UploadHighSpeed = val; if(appl_cfg_save() != 0){ syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_UPLOADHIHGSPEED, appl_cfg_save Fail", __func__); appl_cfg_set_err(); ok = false; }else{ syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_UPLOADHIHGSPEED, set->UploadHighSpeed is set to %d", __func__, set->UploadHighSpeed); } } break; case SETTINGS_CMD_SET_UPLOADMEDIUMSPEED: val = mg_json_get_long(body, "$.param", -1); if( val == -1 ){ ok = false; syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_UPLOADMEDIUMSPEED, mg_json_get_long Fail", __func__); }else{ set->UploadMediumSpeed = val; if(appl_cfg_save() != 0){ syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_UPLOADMEDIUMSPEED, appl_cfg_save Fail", __func__); appl_cfg_set_err(); ok = false; }else{ syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_UPLOADMEDIUMSPEED, set->UploadMediumSpeed is set to %d", __func__, set->UploadMediumSpeed); } } break; case SETTINGS_CMD_SET_UPLOADSLOWSPEED: val = mg_json_get_long(body, "$.param", -1); if( val == -1 ){ ok = false; syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_UPLOADSLOWSPEED, mg_json_get_long Fail", __func__); }else{ set->UploadSlowSpeed = val; if(appl_cfg_save() != 0){ syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_UPLOADSLOWSPEED, appl_cfg_save Fail", __func__); appl_cfg_set_err(); ok = false; }else{ syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_UPLOADSLOWSPEED, set->UploadSlowSpeed is set to %d", __func__, set->UploadSlowSpeed); } } break; case SETTINGS_CMD_REGISTER: mqtt->Cmd = CMD_MQTT_REGISTER; break; case SETTINGS_CMD_SET_DATAKEEPDAY: val = mg_json_get_long(body, "$.param", -1); if( val == -1 ){ ok = false; syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_DATAKEEPDAY, mg_json_get_long Fail", __func__); }else{ set->DataKeepDay = val; if(appl_cfg_save() != 0){ syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_DATAKEEPDAY, appl_cfg_save Fail", __func__); appl_cfg_set_err(); ok = false; }else{ syslog(LOG_INFO, "%s, SETTINGS_CMD_SET_DATAKEEPDAY, set->DataKeepDay is set to %d", __func__, set->DataKeepDay); } } break; case SETTINGS_CMD_TEST: syslog(LOG_INFO,"%s, Get Test Cmd", __func__); rc = appl_snap_rmdir("./snap/test"); syslog(LOG_INFO,"%s, rc:%d", __func__, rc); break; default: break; } }else{ ok = false; syslog(LOG_INFO,"%s, Get Cmd Fail", __func__); } mg_http_reply(c, 200, s_json_header, "{%m:%s,%m:%m}", // MG_ESC("status"), ok ? "true" : "false", // MG_ESC("message"), MG_ESC(ok ? "Success" : "Failed")); } static void handle_ctl_get(struct mg_connection *c) { struct Settings_t* set = &APPL.Set.s; struct Snap_t* snap = &APPL.Snap; mg_http_reply(c, 200, s_json_header, "{\ %m:%m,%m:%m,\ %m:%m}\n", /*1*/MG_ESC("数据记录状态"), MG_ESC(snap->szState),MG_ESC("参数配置状态"), MG_ESC(set->szState), /*2*/MG_ESC("软件版本"),MG_ESC(VERSION)); } static void handle_settings_get(struct mg_connection *c) { struct Settings_t* set = &APPL.Set.s; mg_http_reply(c, 200, s_json_header, "{\ %m:%m,%m:%m,%m:%m,%m:%m,\ %m:%d,%m:%d,%m:%d,%m:%d}\n", MG_ESC("Cloud用户名"),MG_ESC(set->szCloudUserName),MG_ESC("Cloud密码"),MG_ESC(set->szCloudPasswd),MG_ESC("Cloud Url"),MG_ESC(set->szCloudUrl),MG_ESC("Cloud Client ID"),MG_ESC(set->szClientId), MG_ESC("数据保留天数"),set->DataKeepDay,MG_ESC("上传高速"),set->UploadHighSpeed,MG_ESC("上传中速"),set->UploadMediumSpeed,MG_ESC("上传低速"),set->UploadSlowSpeed); } static void handle_comm_get(struct mg_connection *c) { struct chan485_t* c1 = &APPL.chan485[1]; struct chan485_t* c2 = &APPL.chan485[2]; struct chan485_t* c3 = &APPL.chan485[3]; struct chan485_t* c4 = &APPL.chan485[4]; struct chancan_t* c5 = &APPL.chancan[1]; struct chancan_t* c6 = &APPL.chancan[2]; struct chanmqtt_t* c7 = &APPL.chanmqtt[1]; struct chanmqtt_t* c8 = &APPL.chanmqtt[2]; mg_http_reply(c, 200, s_json_header, "{\ %m:{%m:%m,%m:%m,%m:%d,%m:%m,%m:%m,%m:%lld,%m:%lld,%m:%lld,%m:%lld},\ %m:{%m:%m,%m:%m,%m:%d,%m:%m,%m:%m,%m:%lld,%m:%lld,%m:%lld,%m:%lld},\ %m:{%m:%m,%m:%m,%m:%d,%m:%m,%m:%m,%m:%lld,%m:%lld,%m:%lld,%m:%lld},\ %m:{%m:%m,%m:%m,%m:%d,%m:%m,%m:%m,%m:%lld,%m:%lld,%m:%lld,%m:%lld},\ %m:{%m:%m,%m:%m,%m:%m,%m:%m,%m:%lld,%m:%lld,%m:%lld,%m:%lld},\ %m:{%m:%m,%m:%m,%m:%m,%m:%m,%m:%lld,%m:%lld,%m:%lld,%m:%lld},\ %m:{%m:%m,%m:%lld,%m:%lld,%m:%lld},\ %m:{%m:%m,%m:%lld,%m:%lld,%m:%lld}}\n", MG_ESC("1#485"),MG_ESC("状态"), MG_ESC(c1->szstate),MG_ESC("故障码"),MG_ESC(c1->szerr),MG_ESC("波特率"),c1->baud,MG_ESC("设备名"), MG_ESC(c1->szdev), MG_ESC("备注"), MG_ESC(c1->szinfo), MG_ESC("循环次数"),c1->loopcnt, MG_ESC("循环时间"),c1->looptime, MG_ESC("请求次数"),c1->reqcnt, MG_ESC("失败次数"),c1->failcnt, MG_ESC("2#485"),MG_ESC("状态"), MG_ESC(c2->szstate),MG_ESC("故障码"),MG_ESC(c2->szerr),MG_ESC("波特率"),c2->baud,MG_ESC("设备名"),MG_ESC(c2->szdev), MG_ESC("备注"),MG_ESC(c2->szinfo),MG_ESC("循环次数"),c2->loopcnt,MG_ESC("循环时间"),c2->looptime,MG_ESC("请求次数"),c2->reqcnt,MG_ESC("失败次数"),c2->failcnt, MG_ESC("3#485"),MG_ESC("状态"), MG_ESC(c3->szstate),MG_ESC("故障码"),MG_ESC(c3->szerr),MG_ESC("波特率"),c3->baud,MG_ESC("设备名"),MG_ESC(c3->szdev), MG_ESC("备注"),MG_ESC(c3->szinfo),MG_ESC("循环次数"),c3->loopcnt,MG_ESC("循环时间"),c3->looptime,MG_ESC("请求次数"),c3->reqcnt,MG_ESC("失败次数"),c3->failcnt, MG_ESC("4#485"),MG_ESC("状态"), MG_ESC(c4->szstate),MG_ESC("故障码"),MG_ESC(c4->szerr),MG_ESC("波特率"),c4->baud,MG_ESC("设备名"),MG_ESC(c4->szdev), MG_ESC("备注"),MG_ESC(c4->szinfo),MG_ESC("循环次数"),c4->loopcnt,MG_ESC("循环时间"),c4->looptime,MG_ESC("请求次数"),c4->reqcnt,MG_ESC("失败次数"),c4->failcnt, MG_ESC("1#CAN"),MG_ESC("状态"), MG_ESC(c5->szState),MG_ESC("故障码"),MG_ESC(c5->szErr),MG_ESC("设备名"),MG_ESC(c5->szdev), MG_ESC("备注"),MG_ESC(c5->szinfo),MG_ESC("循环次数"),c5->Loopcnt,MG_ESC("循环时间"),c5->LoopTime,MG_ESC("发送帧数"),c5->WrCnt,MG_ESC("接收帧数"),c5->RdCnt, MG_ESC("2#CAN"),MG_ESC("状态"), MG_ESC(c6->szState),MG_ESC("故障码"),MG_ESC(c6->szErr),MG_ESC("设备名"),MG_ESC(c6->szdev), MG_ESC("备注"),MG_ESC(c6->szinfo),MG_ESC("循环次数"),c6->Loopcnt,MG_ESC("循环时间"),c6->LoopTime,MG_ESC("发送帧数"),c6->WrCnt,MG_ESC("接收帧数"),c6->RdCnt, MG_ESC("1#MQTT"),MG_ESC("状态"),MG_ESC(c7->szState),MG_ESC("发送计数"), c7->TotalSend,MG_ESC("接收计数"), c7->TotalRecv,MG_ESC("重连计数"), c7->TotalReconn, MG_ESC("2#MQTT"),MG_ESC("状态"),MG_ESC(c8->szState),MG_ESC("发送计数"), c8->TotalSend,MG_ESC("接收计数"),c8->TotalRecv,MG_ESC("重连计数"), c8->TotalReconn); } static void handle_comm_set(struct mg_connection *c, struct mg_str body) { struct chan485_t* ch = NULL; int idx = mg_json_get_long(body, "$.index", 0); int cmd = mg_json_get_long(body, "$.cmd", 0); printf("%s idx:%d cmd:%d\n", __func__, idx, cmd); if( idx >= 1 && idx <= 4 ){ ch = &APPL.chan485[idx]; ch->Cmd = cmd; mg_http_reply(c, 200, s_json_header, "true\n"); }else{ mg_http_reply(c, 403, s_json_header, "false\n"); } } static void handle_meter_get(struct mg_connection *c) { struct Dtsd1352_t* m1 = &APPL.Dtsd1352[1]; // 1#储能电表 struct Dtsd1352_t* m2 = &APPL.Dtsd1352[2]; // 2#储能电表 struct Dtsd1352_t* m3 = &APPL.Dtsd1352[3]; // 3#储能电表 struct Dtsd1352_t* m4 = &APPL.Dtsd1352[4]; // 4#储能电表 struct Dtsd1352_t* m5 = &APPL.Dtsd1352[5]; // 5#储能电表 mg_http_reply(c, 200, s_json_header, "{\ %m:{%m:%m,%m:%m,%m:%lld,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%d,%m:%d},\ %m:{%m:%m,%m:%m,%m:%lld,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%d,%m:%d},\ %m:{%m:%m,%m:%m,%m:%lld,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%d,%m:%d},\ %m:{%m:%m,%m:%m,%m:%lld,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%d,%m:%d},\ %m:{%m:%m,%m:%m,%m:%lld,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%f,%m:%d,%m:%d}}\n", /*1*/MG_ESC("1#储能电表"),MG_ESC("通信状态"), MG_ESC(m1->szCommState),MG_ESC("数据更新时间"),MG_ESC(m1->szLastUpdate),MG_ESC("通信失败次数"),m1->CommFailTotalCnt, MG_ESC("组合有功功率"), m1->com_active_p, MG_ESC("正向有功总电能"),m1->pos_active_e, MG_ESC("反向有功总电能"),m1->neg_active_e, MG_ESC("功率因数"),m1->pwr_factor, MG_ESC("正向有功需量"),m1->pos_active_dem,MG_ESC("反向有功需量"),m1->neg_active_dem, MG_ESC("A相电压"),m1->ua,MG_ESC("B相电压"),m1->ub,MG_ESC("C相电压"),m1->uc,MG_ESC("A相电流"),m1->ia,MG_ESC("B相电流"),m1->ib,MG_ESC("C相电流"),m1->ic,MG_ESC("频率"),m1->freq,MG_ESC("PT"),m1->PT,MG_ESC("CT"),m1->CT, /*2*/MG_ESC("2#储能电表"),MG_ESC("通信状态"), MG_ESC(m2->szCommState),MG_ESC("数据更新时间"),MG_ESC(m2->szLastUpdate),MG_ESC("通信失败次数"),m2->CommFailTotalCnt, MG_ESC("组合有功功率"), m2->com_active_p, MG_ESC("正向有功总电能"),m2->pos_active_e, MG_ESC("反向有功总电能"),m2->neg_active_e, MG_ESC("功率因数"),m2->pwr_factor, MG_ESC("正向有功需量"),m2->pos_active_dem,MG_ESC("反向有功需量"),m2->neg_active_dem, MG_ESC("A相电压"),m2->ua,MG_ESC("B相电压"),m2->ub,MG_ESC("C相电压"),m2->uc,MG_ESC("A相电流"),m2->ia,MG_ESC("B相电流"),m2->ib,MG_ESC("C相电流"),m2->ic,MG_ESC("频率"),m2->freq,MG_ESC("PT"),m2->PT,MG_ESC("CT"),m2->CT, /*3*/MG_ESC("3#储能电表"),MG_ESC("通信状态"), MG_ESC(m3->szCommState),MG_ESC("数据更新时间"),MG_ESC(m3->szLastUpdate),MG_ESC("通信失败次数"),m3->CommFailTotalCnt, MG_ESC("组合有功功率"), m3->com_active_p, MG_ESC("正向有功总电能"),m3->pos_active_e, MG_ESC("反向有功总电能"),m3->neg_active_e, MG_ESC("功率因数"),m3->pwr_factor, MG_ESC("正向有功需量"),m3->pos_active_dem,MG_ESC("反向有功需量"),m3->neg_active_dem, MG_ESC("A相电压"),m3->ua,MG_ESC("B相电压"),m3->ub,MG_ESC("C相电压"),m3->uc,MG_ESC("A相电流"),m3->ia,MG_ESC("B相电流"),m3->ib,MG_ESC("C相电流"),m3->ic,MG_ESC("频率"),m3->freq,MG_ESC("PT"),m3->PT,MG_ESC("CT"),m3->CT, /*4*/MG_ESC("4#储能电表"),MG_ESC("通信状态"), MG_ESC(m4->szCommState),MG_ESC("数据更新时间"),MG_ESC(m4->szLastUpdate),MG_ESC("通信失败次数"),m4->CommFailTotalCnt, MG_ESC("组合有功功率"), m4->com_active_p, MG_ESC("正向有功总电能"),m4->pos_active_e, MG_ESC("反向有功总电能"),m4->neg_active_e, MG_ESC("功率因数"),m4->pwr_factor, MG_ESC("正向有功需量"),m4->pos_active_dem,MG_ESC("反向有功需量"),m4->neg_active_dem, MG_ESC("A相电压"),m4->ua,MG_ESC("B相电压"),m4->ub,MG_ESC("C相电压"),m4->uc,MG_ESC("A相电流"),m4->ia,MG_ESC("B相电流"),m4->ib,MG_ESC("C相电流"),m4->ic,MG_ESC("频率"),m4->freq,MG_ESC("PT"),m4->PT,MG_ESC("CT"),m4->CT, /*5*/MG_ESC("5#储能电表"),MG_ESC("通信状态"), MG_ESC(m5->szCommState),MG_ESC("数据更新时间"),MG_ESC(m5->szLastUpdate),MG_ESC("通信失败次数"),m5->CommFailTotalCnt, MG_ESC("组合有功功率"), m5->com_active_p, MG_ESC("正向有功总电能"),m5->pos_active_e, MG_ESC("反向有功总电能"),m5->neg_active_e, MG_ESC("功率因数"),m5->pwr_factor, MG_ESC("正向有功需量"),m5->pos_active_dem,MG_ESC("反向有功需量"),m5->neg_active_dem, MG_ESC("A相电压"),m5->ua,MG_ESC("B相电压"),m5->ub,MG_ESC("C相电压"),m5->uc,MG_ESC("A相电流"),m5->ia,MG_ESC("B相电流"),m5->ib,MG_ESC("C相电流"),m5->ic,MG_ESC("频率"),m5->freq,MG_ESC("PT"),m5->PT,MG_ESC("CT"),m5->CT); } static void handle_meter_set(struct mg_connection *c, struct mg_str body){ bool ok = true; int rc; long meter_nmb = mg_json_get_long(body, "$.meter_nmb", -1); long pt_ct = mg_json_get_long(body, "$.pt_ct", -1);; long value = mg_json_get_long(body, "$.value", -1); if(meter_nmb != -1){ syslog(LOG_INFO,"%s, meter_nmb:%d", __func__, meter_nmb); }else{ ok = false; syslog(LOG_INFO,"%s, Get meter_nmb Fail", __func__); } struct Dtsd1352_t* m = &APPL.Dtsd1352[meter_nmb]; modbus_set_slave(m->ctx, m->Adr);// 选择电表 if(pt_ct != -1){ syslog(LOG_INFO,"%s, pt_ct:%d", __func__, pt_ct); if(value != -1){ syslog(LOG_INFO,"%s, value:%d", __func__, value); }else{ ok = false; syslog(LOG_INFO,"%s, Get value Fail", __func__); } switch (pt_ct){ case PT: rc = modbus_write_register(m->ctx, 0x008D, value); break; case CT: rc = modbus_write_register(m->ctx, 0x008E, value); break; default: break; } }else{ ok = false; syslog(LOG_INFO,"%s, Get pt_ct Fail", __func__); } mg_http_reply(c, 200, s_json_header, "{%m:%s,%m:%m}", // MG_ESC("status"), ok ? "true" : "false", // MG_ESC("message"), MG_ESC(ok ? "Success" : "Failed")); } static void handle_firmware_upload(struct mg_connection *c, struct mg_http_message *hm) { char name[64], offset[20], total[20]; struct mg_str data = hm->body; long ofs = -1, tot = -1; name[0] = offset[0] = '\0'; mg_http_get_var(&hm->query, "name", name, sizeof(name)); mg_http_get_var(&hm->query, "offset", offset, sizeof(offset)); mg_http_get_var(&hm->query, "total", total, sizeof(total)); MG_INFO(("File %s, offset %s, len %lu", name, offset, data.len)); if ((ofs = mg_json_get_long(mg_str(offset), "$", -1)) < 0 || (tot = mg_json_get_long(mg_str(total), "$", -1)) < 0) { mg_http_reply(c, 500, "", "offset and total not set\n"); } else if (ofs == 0 && mg_ota_begin((size_t) tot) == false) { mg_http_reply(c, 500, "", "mg_ota_begin(%ld) failed\n", tot); } else if (data.len > 0 && mg_ota_write(data.ptr, data.len) == false) { mg_http_reply(c, 500, "", "mg_ota_write(%lu) @%ld failed\n", data.len, ofs); mg_ota_end(); } else if (data.len == 0 && mg_ota_end() == false) { mg_http_reply(c, 500, "", "mg_ota_end() failed\n", tot); } else { mg_http_reply(c, 200, s_json_header, "true\n"); if (data.len == 0) { // Successful mg_ota_end() called, schedule device reboot mg_timer_add(c->mgr, 500, 0, (void (*)(void *)) mg_device_reset, NULL); } } } static void handle_firmware_commit(struct mg_connection *c) { mg_http_reply(c, 200, s_json_header, "%s\n", mg_ota_commit() ? "true" : "false"); } static void handle_firmware_rollback(struct mg_connection *c) { mg_http_reply(c, 200, s_json_header, "%s\n", mg_ota_rollback() ? "true" : "false"); } static size_t print_status(void (*out)(char, void *), void *ptr, va_list *ap) { int fw = va_arg(*ap, int); return mg_xprintf(out, ptr, "{%m:%d,%m:%c%lx%c,%m:%u,%m:%u}\n", MG_ESC("status"), mg_ota_status(fw), MG_ESC("crc32"), '"', mg_ota_crc32(fw), '"', MG_ESC("size"), mg_ota_size(fw), MG_ESC("timestamp"), mg_ota_timestamp(fw)); } static void handle_firmware_status(struct mg_connection *c) { mg_http_reply(c, 200, s_json_header, "[%M,%M]\n", print_status, MG_FIRMWARE_CURRENT, print_status, MG_FIRMWARE_PREVIOUS); } static void handle_device_reset(struct mg_connection *c) { mg_http_reply(c, 200, s_json_header, "true\n"); mg_timer_add(c->mgr, 500, 0, (void (*)(void *)) mg_device_reset, NULL); } static void handle_device_eraselast(struct mg_connection *c) { size_t ss = mg_flash_sector_size(), size = mg_flash_size(); char *base = (char *) mg_flash_start(), *last = base + size - ss; if (mg_flash_bank() == 2) last -= size / 2; mg_flash_erase(last); mg_http_reply(c, 200, s_json_header, "true\n"); } // HTTP request handler function static void fn(struct mg_connection *c, int ev, void *ev_data) { if (ev == MG_EV_ACCEPT) { if (c->fn_data != NULL) { // TLS listener! struct mg_tls_opts opts = {0}; opts.cert = mg_unpacked("/certs/server_cert.pem"); opts.key = mg_unpacked("/certs/server_key.pem"); mg_tls_init(c, &opts); } } else if (ev == MG_EV_HTTP_MSG) { struct mg_http_message *hm = (struct mg_http_message *) ev_data; struct user *u = authenticate(hm); if ( 0 ) { // mg_http_match_uri(hm, "/api/#") && u == NULL mg_http_reply(c, 403, "", "Not Authorised\n"); } else if (mg_http_match_uri(hm, "/api/login")) { handle_login(c, u); } else if (mg_http_match_uri(hm, "/api/logout")) { handle_logout(c); } else if (mg_http_match_uri(hm, "/api/debug")) { handle_debug(c, hm); } else if (mg_http_match_uri(hm, "/api/settings/get")) { handle_settings_get(c); } else if (mg_http_match_uri(hm, "/api/settings/set")) { handle_settings_set(c, hm->body); }else if (mg_http_match_uri(hm, "/api/stats/get")) { handle_stats_get(c); } else if (mg_http_match_uri(hm, "/api/events/get")) { handle_events_get(c, hm); } else if (mg_http_match_uri(hm, "/api/comm/get")) { handle_comm_get(c); } else if (mg_http_match_uri(hm, "/api/comm/set")) { handle_comm_set(c, hm->body); } else if (mg_http_match_uri(hm, "/api/meter/get")) { handle_meter_get(c); } else if (mg_http_match_uri(hm, "/api/meter/set")) { handle_meter_set(c, hm->body); } else if (mg_http_match_uri(hm, "/api/ctl/get")) { handle_ctl_get(c); } else if (mg_http_match_uri(hm, "/api/firmware/upload")) { handle_firmware_upload(c, hm); } else if (mg_http_match_uri(hm, "/api/firmware/commit")) { handle_firmware_commit(c); } else if (mg_http_match_uri(hm, "/api/firmware/rollback")) { handle_firmware_rollback(c); } else if (mg_http_match_uri(hm, "/api/firmware/status")) { handle_firmware_status(c); } else if (mg_http_match_uri(hm, "/api/device/reset")) { handle_device_reset(c); } else if (mg_http_match_uri(hm, "/api/device/eraselast")) { handle_device_eraselast(c); } else { struct mg_http_serve_opts opts; memset(&opts, 0, sizeof(opts)); #if MG_ARCH == MG_ARCH_UNIX || MG_ARCH == MG_ARCH_WIN32 opts.root_dir = "web_root"; // On workstations, use filesystem #else opts.root_dir = "/web_root"; // On embedded, use packed files opts.fs = &mg_fs_packed; #endif mg_http_serve_dir(c, ev_data, &opts); } MG_DEBUG(("%lu %.*s %.*s -> %.*s", c->id, (int) hm->method.len, hm->method.ptr, (int) hm->uri.len, hm->uri.ptr, (int) 3, &c->send.buf[9])); } } void web_init(struct mg_mgr *mgr) { s_settings.device_name = strdup("My Device"); mg_http_listen(mgr, HTTP_URL, fn, NULL); mg_http_listen(mgr, HTTPS_URL, fn, (void *) 1); mg_timer_add(mgr, 3600 * 1000, MG_TIMER_RUN_NOW | MG_TIMER_REPEAT, timer_sntp_fn, mgr); }