// Copyright (c) 2022 Cesanta Software Limited // All rights reserved // // UI example // It implements the following endpoints: // /api/config/get - respond with current config // /api/config/set - POST a config change // any other URI serves static files from s_root_dir // Data and results are JSON strings /** * @file webserver_project.c * @brief support webserver_project for XiUOS * @version 3.0 * @author AIIT XUOS Lab * @date 2023-11-07 */ /************************************************* File name: webserver_project.c Description: support webserver_project for XiUOS Others: History: 1. Date: 2023-11-07 Author: AIIT XUOS Lab Modification: 1、support xishutong-arm32 board, using W5500 to support webserver. 2. Date: 2024-1-3 Author: AIIT XUOS Lab Modification: 1、support xishutong board(single ethernet port), using MAC to support webserver *************************************************/ #include "ip_addr.h" #include "mongoose.h" #include "netdev.h" #include #include #include "lwip/sys.h" #ifdef APPLICATION_WEBSERVER_XISHUTONG_4G #include #endif /******************************************************************************* * Local variable definitions ('static') ******************************************************************************/ char index_path[] = "login.html"; static const char* s_http_addr = "http://192.168.131.88:8000"; // HTTP port static const char* s_root_dir = "webserver"; static const char* s_enable_hexdump = "no"; static const char* s_ssi_pattern = "#.html"; static const char* web_version = "XiUOS WebServer 1.0"; static const char* net_carrier_china_mobile = "中国移动"; static const char* net_carrier_china_unicom = "中国联通"; static const char* net_carrier_china_telecom = "中国电信"; static struct netdev* p_netdev_webserver; static struct netdev* p_netdev_ethernet; static pthread_t tid; #define WB_EVENT_TASK_STACK_SIZE 4096 #define WB_EVENT_TASK_PRIO 20 #define WB_4G_CONNECT 0x0001 #define WB_4G_DISCONNECT 0x0002 #define WB_MQTT_CONNECT 0x0004 #define WB_MQTT_DISCONNECT 0x0008 #define WB_LORA_CONNECT 0x0010 #define WB_LORA_DISCONNECT 0x0020 #define WB_ETHERNET_CONNECT 0x0040 #define WB_ETHERNET_DISCONNECT 0x0080 #define WB_EVENT_ALL (WB_4G_CONNECT | WB_4G_DISCONNECT | \ WB_MQTT_CONNECT | WB_MQTT_DISCONNECT | \ WB_LORA_CONNECT | WB_LORA_DISCONNECT | \ WB_ETHERNET_CONNECT | WB_ETHERNET_DISCONNECT) static int wb_event; static unsigned int status = 0; static pthread_t wb_event_task; enum ModulesType { MODULES_NULL = 0, // null MODULES_4G, // support 4G modules MODULES_LORA, // support LoRa modules MODULES_ALL, //all }; /*define device info*/ #ifdef APPLICATION_WEBSERVER_XISHUTONG_4G static const char* device_name = "矽数通4G"; static const char* device_type = "xishutong-arm32"; static const char* device_serial_num = "123456789"; static int support_module = MODULES_ALL; #endif #ifdef APPLICATION_WEBSERVER_XISHUTONG static const char* device_name = "矽数通"; static const char* device_type = "xishutong-arm32"; static const char* device_serial_num = "123456789"; static int support_module = MODULES_LORA; #endif /*define webserver info*/ static struct webserver_config { char *ip, *mask, *gw, *dns; } webserver_config; /*define interface info*/ static struct rs485_config { int baud_rate; int data_bit; int stop_bit; int parity; } rs485_config; int rs485_uart_fd = -1; #define RS485_DEVICE_PATH "/dev/usart4_dev4" #ifdef APPLICATION_WEBSERVER_XISHUTONG_4G /*define net 4G info*/ static struct net_4g_info { char map_ip[20]; char connect_ip[40]; char operator[20]; char signal_strength[20]; char connect_port[20]; int net_4g_init_flag; int connect_status; } net_4g_info; struct Adapter* adapter; static struct net_4g_mqtt_info { char topic[40]; char username[40]; char password[40]; char client_id[40]; int connect_status; } net_4g_mqtt_info; #endif /*define net LoRa info*/ struct net_lora_info { uint32_t frequency; // frequency uint8_t sf; // spreadfactor uint8_t bw; // bandwidth uint32_t connect_status; //connect status uint8_t lora_init_flag; //if 1 means already init } net_lora_info; /*define net Ethernet info*/ static struct net_ethernet_info { char ethernetIp[20]; char ethernetNetmask[20]; char ethernetGateway[20]; char ethernetDNS[20]; char targetIp[20]; char targetPort[20]; char targetGateway[20]; char targetDNS[20]; int connect_status; } net_ethernet_info; static int socket_fd = -1; static char tcp_ethernet_ipaddr[] = {192, 168, 130, 77}; static char tcp_ethernet_netmask[] = {255, 255, 254, 0}; static char tcp_ethernet_gwaddr[] = {192, 168, 130, 1}; static uint16_t tcp_socket_port = 8888; /*define PLC info*/ static char *plc_json; #define JSON_FILE_NAME "test_recipe.json" /******************************************************************************* * Function implementation - judge using 4G modules or LoRa modules ******************************************************************************/ static int JudgeModulesType(void) { int ret; int retry = 5; #ifdef APPLICATION_WEBSERVER_XISHUTONG_4G extern int TestLoraRadio(int argc, char *argv[]); char* check_params[2] = {"TestLoraRadio", "check"}; do { ret = TestLoraRadio(2, check_params); if (ret > 0) { retry = 0; support_module = MODULES_LORA; } else { retry--; } } while (retry > 0); #endif return support_module; } /******************************************************************************* * Function implementation - define interface info ******************************************************************************/ static void Rs485InitConfigure(void) { rs485_uart_fd = PrivOpen(RS485_DEVICE_PATH, O_RDWR); if (rs485_uart_fd < 0) { printf("open rs485 %s fd error:%d\n", RS485_DEVICE_PATH, rs485_uart_fd); return; } printf("uart %s open success\n", RS485_DEVICE_PATH); struct SerialDataCfg uart_cfg; memset(&uart_cfg, 0, sizeof(struct SerialDataCfg)); rs485_config.baud_rate = BAUD_RATE_115200; rs485_config.data_bit = DATA_BITS_8; rs485_config.stop_bit = STOP_BITS_1; rs485_config.parity = PARITY_NONE; uart_cfg.serial_baud_rate = rs485_config.baud_rate; uart_cfg.serial_data_bits = rs485_config.data_bit; uart_cfg.serial_stop_bits = rs485_config.stop_bit; uart_cfg.serial_parity_mode = rs485_config.parity; uart_cfg.serial_bit_order = BIT_ORDER_LSB; uart_cfg.serial_invert_mode = NRZ_NORMAL; uart_cfg.serial_buffer_size = SERIAL_RB_BUFSZ; uart_cfg.serial_timeout = -1; uart_cfg.is_ext_uart = 0; uart_cfg.dev_recv_callback = NULL; struct PrivIoctlCfg ioctl_cfg; ioctl_cfg.ioctl_driver_type = SERIAL_TYPE; ioctl_cfg.args = (void *)&uart_cfg; if (0 != PrivIoctl(rs485_uart_fd, OPE_INT, &ioctl_cfg)) { printf("ioctl uart fd error %d\n", rs485_uart_fd); PrivClose(rs485_uart_fd); return; } } static void Rs485Configure(int baud_rate, int data_bit, int stop_bit, int parity) { if (rs485_uart_fd < 0) { rs485_uart_fd = PrivOpen(RS485_DEVICE_PATH, O_RDWR); if (rs485_uart_fd < 0) { printf("open rs485 %s fd error:%d\n", RS485_DEVICE_PATH, rs485_uart_fd); return; } printf("uart %s open success\n", RS485_DEVICE_PATH); } struct SerialDataCfg uart_cfg; memset(&uart_cfg, 0, sizeof(struct SerialDataCfg)); uart_cfg.serial_baud_rate = baud_rate; uart_cfg.serial_data_bits = data_bit; uart_cfg.serial_stop_bits = stop_bit; uart_cfg.serial_parity_mode = parity; uart_cfg.serial_bit_order = BIT_ORDER_LSB; uart_cfg.serial_invert_mode = NRZ_NORMAL; uart_cfg.serial_buffer_size = SERIAL_RB_BUFSZ; uart_cfg.serial_timeout = -1; uart_cfg.is_ext_uart = 0; uart_cfg.dev_recv_callback = NULL; struct PrivIoctlCfg ioctl_cfg; ioctl_cfg.ioctl_driver_type = SERIAL_TYPE; ioctl_cfg.args = (void *)&uart_cfg; if (0 != PrivIoctl(rs485_uart_fd, OPE_INT, &ioctl_cfg)) { printf("ioctl uart fd error %d\n", rs485_uart_fd); PrivClose(rs485_uart_fd); return; } printf("Board RS485 changed to [br: %d, data: %d, stop: %d, party: %d]\n", baud_rate, data_bit, stop_bit, parity); } /******************************************************************************* * Function implementation - define net 4G info ******************************************************************************/ #ifdef APPLICATION_WEBSERVER_XISHUTONG_4G static void Net4gGetInfo(char *ip, char *operator, char *signal_strength) { if (net_4g_info.net_4g_init_flag) { strcpy(ip, adapter->network_info.ip_address); sprintf(signal_strength, "%d", adapter->network_info.signal_strength); switch (adapter->network_info.carrier_type) { case CARRIER_CHINA_MOBILE: strcpy(operator, net_carrier_china_mobile); break; case CARRIER_CHINA_UNICOM: strcpy(operator, net_carrier_china_unicom); break; case CARRIER_CHINA_TELECOM: strcpy(operator, net_carrier_china_telecom); break; default: break; } } } static void Net4gConnect(void) { int ret = -1; int ec200a_baud_rate; const char *send_msg = "Adapter_4G Test"; if (0 == net_4g_info.net_4g_init_flag) { adapter->socket.socket_id = 0; ec200a_baud_rate = 115200; AdapterDeviceOpen(adapter); AdapterDeviceControl(adapter, OPE_INT, &ec200a_baud_rate); AdapterDeviceNetstat(adapter); net_4g_info.net_4g_init_flag = 1; } if (1 == net_4g_mqtt_info.connect_status) { AdapterDeviceMqttDisconnect(adapter); net_4g_mqtt_info.connect_status = 0; } if (0 == net_4g_info.connect_status) { ret = AdapterDeviceConnect(adapter, CLIENT, net_4g_info.connect_ip, net_4g_info.connect_port, IPV4); if (ret < 0) { net_4g_info.connect_status = 0; printf("webserver %s fail\n", __func__); } else { net_4g_info.connect_status = 1; AdapterDeviceSend(adapter, send_msg, strlen(send_msg)); printf("webserver %s success\n", __func__); } } } static void Net4gDisconnect(void) { if (1 == net_4g_info.connect_status) { uint8_t priv_net_group = IP_PROTOCOL; AdapterDeviceDisconnect(adapter, &priv_net_group); net_4g_info.connect_status = 0; } } /******************************************************************************* * Function implementation - define net 4G MQTT info ******************************************************************************/ static void NetMqttConnect(void) { int ret = -1; int ec200a_baud_rate = 0; //for test const char *send_msg = "Adapter_4G MQTT Test"; char recv_msg[256] = {0}; int send_cnt = 1; if (0 == net_4g_info.net_4g_init_flag) { adapter->socket.socket_id = 0; ec200a_baud_rate = 115200; AdapterDeviceOpen(adapter); AdapterDeviceControl(adapter, OPE_INT, &ec200a_baud_rate); AdapterDeviceNetstat(adapter); net_4g_info.net_4g_init_flag = 1; } if (1 == net_4g_info.connect_status) { uint8_t priv_net_group = IP_PROTOCOL; AdapterDeviceDisconnect(adapter, &priv_net_group); net_4g_info.connect_status = 0; } if (0 == net_4g_mqtt_info.connect_status) { ret = AdapterDeviceMqttConnect(adapter, net_4g_info.connect_ip, net_4g_info.connect_port, net_4g_mqtt_info.client_id, net_4g_mqtt_info.username, net_4g_mqtt_info.password); if (ret < 0) { net_4g_mqtt_info.connect_status = 0; printf("webserver %s fail\n", __func__); } else { net_4g_mqtt_info.connect_status = 1; //for test while (send_cnt < 11) { AdapterDeviceMqttSend(adapter, net_4g_mqtt_info.topic, send_msg, strlen(send_msg)); AdapterDeviceMqttRecv(adapter, net_4g_mqtt_info.topic, recv_msg, sizeof(recv_msg)); printf("[%d]4G mqtt test recv msg %s\n", send_cnt, recv_msg); send_cnt++; } printf("webserver %s success\n", __func__); } } } static void NetMqttDisconnect(void) { if (1 == net_4g_mqtt_info.connect_status) { AdapterDeviceMqttDisconnect(adapter); net_4g_mqtt_info.connect_status = 0; } } #endif /******************************************************************************* * Function implementation - define net LoRa info ******************************************************************************/ static void NetLoraConnect(void) { if (MODULES_LORA == support_module) { char* tx_params[5] = {"TestLoraRadio", "tx", "1", "2000", "2"}; extern int TestLoraRadio(int argc, char *argv[]); if (0 == net_lora_info.lora_init_flag) { net_lora_info.lora_init_flag = 1; } TestLoraRadio(5, tx_params); net_lora_info.connect_status = 1; } } static void NetLoraDisconnect(void) { if (MODULES_LORA == support_module) { net_lora_info.connect_status = 0; } } /******************************************************************************* * Function implementation - define net Ethernet info ******************************************************************************/ #ifdef APPLICATION_WEBSERVER_XISHUTONG_4G static void TcpClientConnect(void) { int cnt = 20; int ret; char send_msg[128]; sscanf(net_ethernet_info.targetPort, "%d", &tcp_socket_port); memset(send_msg, 0, sizeof(send_msg)); socket_fd = socket(AF_INET, SOCK_STREAM, 0); if (socket_fd < 0) { printf("Socket error\n"); return; } struct sockaddr_in tcp_sock; tcp_sock.sin_family = AF_INET; tcp_sock.sin_port = htons(tcp_socket_port); tcp_sock.sin_addr.s_addr = inet_addr(net_ethernet_info.targetIp); memset(&(tcp_sock.sin_zero), 0, sizeof(tcp_sock.sin_zero)); int keepalive = 1; int keepidle = 30; int keepinterval = 5; int keepcount = 5; setsockopt(socket_fd, IPPROTO_TCP, /* set option at TCP level */ TCP_KEEPALIVE, /* name of option */ (void*)&keepalive, /* the cast is historical cruft */ sizeof(keepalive)); /* length of option value */ setsockopt(socket_fd, IPPROTO_TCP, /* set option at TCP level */ TCP_KEEPIDLE, /* name of option */ (void*)&keepidle, /* the cast is historical cruft */ sizeof(keepidle)); /* length of option value */ setsockopt(socket_fd, IPPROTO_TCP, /* set option at TCP level */ TCP_KEEPINTVL, /* name of option */ (void*)&keepinterval, /* the cast is historical cruft */ sizeof(keepinterval)); /* length of option value */ setsockopt(socket_fd, IPPROTO_TCP, /* set option at TCP level */ TCP_KEEPCNT, /* name of option */ (void*)&keepcount, /* the cast is historical cruft */ sizeof(keepcount)); /* length of option value */ ret = connect(socket_fd, (struct sockaddr *)&tcp_sock, sizeof(struct sockaddr)); if (ret < 0) { printf("Unable to connect %s:%d = %d\n", net_ethernet_info.targetIp, tcp_socket_port, ret); closesocket(socket_fd); return; } printf("TCP connect %s:%d success, start to send.\n", net_ethernet_info.targetIp, tcp_socket_port); net_ethernet_info.connect_status = 1; while (cnt --) { printf("Lwip client is running.\n"); snprintf(send_msg, sizeof(send_msg), "TCP test package times %d\r\n", cnt); send(socket_fd, send_msg, strlen(send_msg), 0); printf("Send tcp msg: %s ", send_msg); PrivTaskDelay(1000); } return; } static void TcpClientDisconnect(void) { printf("TCP disconnect\n"); closesocket(socket_fd); net_ethernet_info.connect_status = 0; } #endif /******************************************************************************* * Function implementation - define plc info ******************************************************************************/ static void PlcInfoWriteToSd(const char *json) { extern int GetSdMountStatus(void); if(GetSdMountStatus()) { KPrintf("------Start download json file !------\r\n"); FILE *fp = fopen(JSON_FILE_NAME, "w"); if(fp == NULL) { printf("%s file create failed,please check!\r\n", JSON_FILE_NAME); } else { printf("%s file create success!\r\n", JSON_FILE_NAME); fprintf(fp, "%s", json); fclose(fp); } printf("------download %s file done!------\r\n", JSON_FILE_NAME); } } /******************************************************************************* * Function implementation - WebserverEventTask ******************************************************************************/ static void *WebserverEventTask(void *arg) { wb_event = PrivEventCreate(LINKLIST_FLAG_FIFO); while(1) { if (0 == PrivEventProcess(wb_event, WB_EVENT_ALL, EVENT_OR | EVENT_AUTOCLEAN, 0, &status)) { switch( status ) { #ifdef APPLICATION_WEBSERVER_XISHUTONG_4G case WB_4G_CONNECT: Net4gConnect(); break; case WB_4G_DISCONNECT: Net4gDisconnect(); break; case WB_MQTT_CONNECT: NetMqttConnect(); break; case WB_MQTT_DISCONNECT: NetMqttDisconnect(); break; #endif case WB_LORA_CONNECT: NetLoraConnect(); break; case WB_LORA_DISCONNECT: NetLoraDisconnect(); break; #ifdef APPLICATION_WEBSERVER_XISHUTONG_4G case WB_ETHERNET_CONNECT: TcpClientConnect(); break; case WB_ETHERNET_DISCONNECT: TcpClientDisconnect(); break; #endif } } } } static void WbEventInit(void) { char task_name[] = "wb_event_task"; pthread_args_t args; args.pthread_name = task_name; pthread_attr_t attr; attr.schedparam.sched_priority = WB_EVENT_TASK_PRIO; attr.stacksize = WB_EVENT_TASK_STACK_SIZE; PrivTaskCreate(&wb_event_task, &attr, &WebserverEventTask, (void *)&args); PrivTaskStartup(&wb_event_task); } /******************************************************************************* * Function implementation - webserver ******************************************************************************/ // Try to update a single configuration value static void update_config(struct mg_str json, const char* path, char** value) { char* jval; if ((jval = mg_json_get_str(json, path)) != NULL) { free(*value); *value = strdup(jval); } } static void update_config_array(struct mg_str json, const char* path, char* value) { char* jval; if ((jval = mg_json_get_str(json, path)) != NULL) { sprintf(value, "%s", jval); } } static void fn(struct mg_connection* c, int ev, void* ev_data, void* fn_data) { if (ev == MG_EV_HTTP_MSG) { struct mg_http_message *hm = (struct mg_http_message*)ev_data, tmp = { 0 }; /*define modules info*/ if (mg_http_match_uri(hm, "/net/getModulesInfo")) { mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{%m:%d}\n", MG_ESC("modulesStatus"), JudgeModulesType()); } /*define device info*/ else if (mg_http_match_uri(hm, "/getSystemInfo")) { mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{%m:%m, %m:%m, %m:%m, %m:%m, %m:%m, %m:%m}\n", MG_ESC("deviceName"), MG_ESC(device_name), MG_ESC("deviceType"), MG_ESC(device_type), MG_ESC("deviceNo"), MG_ESC(device_serial_num), MG_ESC("ip"), MG_ESC(webserver_config.ip), MG_ESC("netmask"), MG_ESC(webserver_config.mask), MG_ESC("gateway"), MG_ESC(webserver_config.gw)); } /*define webserver info*/ else if (mg_http_match_uri(hm, "/setNetInfo")) { struct mg_str json = hm->body; printf("json: %s\n", json.ptr); update_config(json, "$.ip", &webserver_config.ip); update_config(json, "$.netmask", &webserver_config.mask); update_config(json, "$.gateway", &webserver_config.gw); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); ip_addr_t ipaddr, maskaddr, gwaddr; inet_aton(webserver_config.ip, &ipaddr); inet_aton(webserver_config.mask, &maskaddr); inet_aton(webserver_config.gw, &gwaddr); p_netdev_webserver->ops->set_addr_info(p_netdev_webserver, &ipaddr, &maskaddr, &gwaddr); printf("Board Webserver Net changed to [IP: %s, Mask: %s, GW: %s]\n", webserver_config.ip, webserver_config.mask, webserver_config.gw); } /*define interface info*/ else if (mg_http_match_uri(hm, "/interface/get485Info")) { mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{%m:%d, %m:%d, %m:%d, %m:%d}\n", MG_ESC("baudRate"), rs485_config.baud_rate, MG_ESC("wordLength"), rs485_config.data_bit, MG_ESC("stopBits"), rs485_config.stop_bit, MG_ESC("parity"), rs485_config.parity); } else if (mg_http_match_uri(hm, "/interface/set485Info")) { struct mg_str json = hm->body; printf("json: %s\n", json.ptr); rs485_config.baud_rate = mg_json_get_long(json, "$.baudRate", 0); rs485_config.data_bit = mg_json_get_long(json, "$.wordLength", 0); rs485_config.stop_bit = mg_json_get_long(json, "$.stopBits", 0); rs485_config.parity = mg_json_get_long(json, "$.parity", 0); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); Rs485Configure(rs485_config.baud_rate, rs485_config.data_bit, rs485_config.stop_bit, rs485_config.parity); } /*define net 4G info*/ #ifdef APPLICATION_WEBSERVER_XISHUTONG_4G else if (mg_http_match_uri(hm, "/net/get4gInfo")) { Net4gGetInfo(net_4g_info.map_ip, net_4g_info.operator, net_4g_info.signal_strength); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{%m:%m, %m:%m, %m:%m, %m:%m, %m:%m, %m:%d}\n", MG_ESC("mapIp"), MG_ESC(net_4g_info.map_ip), MG_ESC("operator"), MG_ESC(net_4g_info.operator), MG_ESC("signalIntensity"), MG_ESC(net_4g_info.signal_strength), MG_ESC("publicIp"), MG_ESC(net_4g_info.connect_ip), MG_ESC("publicPort"), MG_ESC(net_4g_info.connect_port), MG_ESC("status"), net_4g_info.connect_status); } else if (mg_http_match_uri(hm, "/net/set4gInfo")) { struct mg_str json = hm->body; printf("json: %s\n", json.ptr); update_config_array(json, "$.publicIp", net_4g_info.connect_ip); update_config_array(json, "$.publicPort", net_4g_info.connect_port); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); } else if (mg_http_match_uri(hm, "/net/connect4G")) { //enable 4G connect function PrivEvenTrigger(wb_event, WB_4G_CONNECT); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); } else if (mg_http_match_uri(hm, "/net/disconnect4G")) { //disable 4G connect function PrivEvenTrigger(wb_event, WB_4G_CONNECT); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); } else if (mg_http_match_uri(hm, "/net/getMQTTInfo")) { mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{%m:%m, %m:%m, %m:%m, %m:%m, %m:%d}\n", MG_ESC("topic"), MG_ESC(net_4g_mqtt_info.topic), MG_ESC("username"), MG_ESC(net_4g_mqtt_info.username), MG_ESC("password"), MG_ESC(net_4g_mqtt_info.password), MG_ESC("clientId"), MG_ESC(net_4g_mqtt_info.client_id), MG_ESC("status"), net_4g_mqtt_info.connect_status); } else if (mg_http_match_uri(hm, "/net/setMQTTInfo")) { struct mg_str json = hm->body; printf("json: %s\n", json.ptr); update_config_array(json, "$.topic", net_4g_mqtt_info.topic); update_config_array(json, "$.username", net_4g_mqtt_info.username); update_config_array(json, "$.password", net_4g_mqtt_info.password); update_config_array(json, "$.clientId", net_4g_mqtt_info.client_id); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); } else if (mg_http_match_uri(hm, "/net/connectMQTT")) { //enable 4G MQTT connect function PrivEvenTrigger(wb_event, WB_MQTT_CONNECT); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); } else if (mg_http_match_uri(hm, "/net/disconnectMQTT")) { //disable 4G MQTT connect function PrivEvenTrigger(wb_event, WB_MQTT_DISCONNECT); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); } #endif /*define net LoRa info*/ else if (mg_http_match_uri(hm, "/net/getLoraInfo")) { mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{%m:%d, %m:%d, %m:%d, %m:%d}\n", MG_ESC("range"), net_lora_info.frequency, MG_ESC("bandwidth"), net_lora_info.bw, MG_ESC("factor"), net_lora_info.sf, MG_ESC("status"), net_lora_info.connect_status); } else if (mg_http_match_uri(hm, "/net/setLoraInfo")) { struct mg_str json = hm->body; printf("json: %s\n", json.ptr); net_lora_info.frequency = mg_json_get_long(json, "$.range", 0); net_lora_info.sf = mg_json_get_long(json, "$.factor", 0); net_lora_info.bw = mg_json_get_long(json, "$.bandwidth", 0); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); extern void LoraRadioParamsUpdate(uint32_t frequency, uint8_t sf, uint8_t bw); LoraRadioParamsUpdate(net_lora_info.frequency, net_lora_info.sf, net_lora_info.bw); } else if (mg_http_match_uri(hm, "/net/ConnectLora")) { //enable LoRa connect function PrivEvenTrigger(wb_event, WB_LORA_CONNECT); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); } else if (mg_http_match_uri(hm, "/net/DisonnectLora")) { //disable LoRa connect function PrivEvenTrigger(wb_event, WB_LORA_DISCONNECT); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); } /*define net Ethernet info*/ #ifdef APPLICATION_WEBSERVER_XISHUTONG_4G else if (mg_http_match_uri(hm, "/net/getEthernetInfo")) { mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{%m:%m, %m:%m, %m:%m, %m:%m, %m:%m, %m:%m, %m:%m, %m:%m, %m:%d}\n", MG_ESC("ethernetIp"), MG_ESC(net_ethernet_info.ethernetIp), MG_ESC("ethernetNetmask"), MG_ESC(net_ethernet_info.ethernetNetmask), MG_ESC("ethernetGateway"), MG_ESC(net_ethernet_info.ethernetGateway), MG_ESC("ethernetDNS"), MG_ESC(net_ethernet_info.ethernetDNS), MG_ESC("targetIp"), MG_ESC(net_ethernet_info.targetIp), MG_ESC("targetPort"), MG_ESC(net_ethernet_info.targetPort), MG_ESC("targetGateway"), MG_ESC(net_ethernet_info.targetGateway), MG_ESC("targetDNS"), MG_ESC(net_ethernet_info.targetDNS), MG_ESC("ethernetStatus"), net_ethernet_info.connect_status); } else if (mg_http_match_uri(hm, "/net/setEthernetInfo")) { struct mg_str json = hm->body; printf("json: %s\n", json.ptr); update_config_array(json, "$.ethernetIp", net_ethernet_info.ethernetIp); update_config_array(json, "$.ethernetNetmask", net_ethernet_info.ethernetNetmask); update_config_array(json, "$.ethernetGateway", net_ethernet_info.ethernetGateway); update_config_array(json, "$.ethernetDNS", net_ethernet_info.ethernetDNS); update_config_array(json, "$.targetIp", net_ethernet_info.targetIp); update_config_array(json, "$.targetPort", net_ethernet_info.targetPort); update_config_array(json, "$.targetGateway", net_ethernet_info.targetGateway); update_config_array(json, "$.targetDNS", net_ethernet_info.targetDNS); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); p_netdev_ethernet = netdev_get_by_name("hd"); if (p_netdev_ethernet) { ip_addr_t ipaddr, maskaddr, gwaddr; inet_aton(net_ethernet_info.ethernetIp, &ipaddr); inet_aton(net_ethernet_info.ethernetNetmask, &maskaddr); inet_aton(net_ethernet_info.ethernetGateway, &gwaddr); p_netdev_ethernet->ops->set_addr_info(p_netdev_ethernet, &ipaddr, &maskaddr, &gwaddr); printf("Ethernet Configuration changed to [IP: %s, Mask: %s, GW: %s]\n", net_ethernet_info.ethernetIp, net_ethernet_info.ethernetNetmask, net_ethernet_info.ethernetGateway); } } else if (mg_http_match_uri(hm, "/net/connectEthernet")) { //enable Ethernet connect function PrivEvenTrigger(wb_event, WB_ETHERNET_CONNECT); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); } else if (mg_http_match_uri(hm, "/net/disconnectEthernet")) { //disable Ethernet connect function PrivEvenTrigger(wb_event, WB_ETHERNET_DISCONNECT); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); } #endif /*define plc info*/ else if (mg_http_match_uri(hm, "/control/setPLCInfo")) { struct mg_str json = hm->body; printf("json: %s\n", json.ptr); PlcInfoWriteToSd(json.ptr); mg_http_reply(c, 200, "Content-Type: application/json\r\n", "{\"status\":\"success\"}\r\n"); } else { struct mg_str unknown = mg_str_n("?", 1), *cl; struct mg_http_serve_opts opts = { .root_dir = s_root_dir, .ssi_pattern = s_ssi_pattern }; mg_http_serve_dir(c, hm, &opts); mg_http_parse((char*)c->send.buf, c->send.len, &tmp); cl = mg_http_get_header(&tmp, "Content-Length"); if (cl == NULL) cl = &unknown; MG_INFO(("%.*s %.*s %.*s %.*s", (int)hm->method.len, hm->method.ptr, (int)hm->uri.len, hm->uri.ptr, (int)tmp.uri.len, tmp.uri.ptr, (int)cl->len, cl->ptr)); } } (void)fn_data; } static void* do_webserver(void* args) { #ifdef APPLICATION_WEBSERVER_XISHUTONG_4G p_netdev_webserver = netdev_get_by_name("wz"); if (p_netdev_webserver == NULL) { MG_INFO(("Did not find wz netdev, use default.\n")); p_netdev_webserver = NETDEV_DEFAULT; } #endif #ifdef APPLICATION_WEBSERVER_XISHUTONG p_netdev_webserver = netdev_get_by_name("hd"); if (p_netdev_webserver == NULL) { MG_INFO(("Did not find hd netdev, use default.\n")); p_netdev_webserver = NETDEV_DEFAULT; } #endif MG_INFO(("Webserver Use Netdev %s", p_netdev_webserver->name)); webserver_config.ip = strdup(inet_ntoa(*p_netdev_webserver->ip_addr)); webserver_config.mask = strdup(inet_ntoa(*p_netdev_webserver->netmask)); webserver_config.gw = strdup(inet_ntoa(*p_netdev_webserver->gw)); webserver_config.dns = strdup(inet_ntoa(p_netdev_webserver->dns_servers[0])); #ifdef BSP_USING_RS485 Rs485InitConfigure(); #endif #ifdef APPLICATION_WEBSERVER_XISHUTONG_4G adapter = AdapterDeviceFindByName(ADAPTER_4G_NAME); #endif //4g init param net_4g_info.net_4g_init_flag = 0; net_4g_info.connect_status = 0; net_4g_mqtt_info.connect_status = 0; //lora init param net_lora_info.bw = 2;//bw 0:125 kHz 1:250 kHz 2:500 kHz, net_lora_info.sf = 12;//sf12 net_lora_info.lora_init_flag = 0; WbEventInit(); struct mg_mgr mgr; // Event manager // mg_log_set(MG_LL_INFO); // Set to 3 to enable debug mg_log_set(MG_LL_ERROR); // Set to 3 to enable debug mg_mgr_init(&mgr); // Initialise event manager mg_http_listen(&mgr, s_http_addr, fn, NULL); // Create HTTP listener for (;;) mg_mgr_poll(&mgr, 50); // Infinite event loop mg_mgr_free(&mgr); return NULL; } int webserver(void) { extern void LwipNetworkActive(int argc, char* argv[]); #ifdef APPLICATION_WEBSERVER_XISHUTONG_4G char* params[2] = {"LwipNetworkActive", "-a"}; LwipNetworkActive(2, params); #endif #ifdef APPLICATION_WEBSERVER_XISHUTONG char* params[3] = {"LwipNetworkActive", "-e", "0"}; LwipNetworkActive(3, params); extern void LwipSetNetwork(int argc, char* argv[]); char* ip_params[5] = {"LwipSetNetwork", "-d", "hd", "-i", "192.168.131.88"}; LwipSetNetwork(5, ip_params); char* gw_params[5] = {"LwipSetNetwork", "-d", "hd", "-g", "192.168.131.1"}; LwipSetNetwork(5, gw_params); #endif pthread_attr_t attr; attr.schedparam.sched_priority = 30; attr.stacksize = 0x4000; char task_name[] = "do_webserver"; pthread_args_t args; args.pthread_name = task_name; PrivTaskCreate(&tid, &attr, &do_webserver, (void *)&args); PrivTaskStartup(&tid); return 0; } SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(5), Webserver, webserver, webserver for project);