From 68e5436aae8d519eef629dfb9447f266e88f75a7 Mon Sep 17 00:00:00 2001 From: wlyu Date: Mon, 14 Mar 2022 18:13:13 +0800 Subject: [PATCH 1/2] remove default config --- Ubiquitous/XiZi/board/ok1052-c/board.c | 13 +++++++++++-- .../XiZi/board/ok1052-c/third_party_driver/Kconfig | 6 +++--- .../board/ok1052-c/third_party_driver/spi/Makefile | 6 +++++- 3 files changed, 19 insertions(+), 6 deletions(-) diff --git a/Ubiquitous/XiZi/board/ok1052-c/board.c b/Ubiquitous/XiZi/board/ok1052-c/board.c index 55786560d..7ff852c2b 100644 --- a/Ubiquitous/XiZi/board/ok1052-c/board.c +++ b/Ubiquitous/XiZi/board/ok1052-c/board.c @@ -17,10 +17,10 @@ File name: board.c Description: support imxrt1052-board init function Others: take SDK_2.6.1_MIMXRT1052xxxxB for references -History: +History: 1. Date: 2022-01-25 Author: AIIT XUOS Lab -Modification: +Modification: 1. support imxrt1052-board MPU、clock、memory init 2. support imxrt1052-board uart、semc、sdio driver init 3. support imxrt1052-board I2C, SPI, ADC, RTC driver init @@ -68,9 +68,18 @@ int MountSDCard(void) #include #include + +#ifdef BSP_USING_ADC #include +#endif + +#ifdef BSP_USING_SPI #include +#endif + +#ifdef BSP_USING_RTC #include +#endif #define NVIC_PRIORITYGROUP_0 0x00000007U /*!< 0 bits for pre-emption priority 4 bits for subpriority */ diff --git a/Ubiquitous/XiZi/board/ok1052-c/third_party_driver/Kconfig b/Ubiquitous/XiZi/board/ok1052-c/third_party_driver/Kconfig index ed032333a..0ec9c3aa4 100644 --- a/Ubiquitous/XiZi/board/ok1052-c/third_party_driver/Kconfig +++ b/Ubiquitous/XiZi/board/ok1052-c/third_party_driver/Kconfig @@ -22,7 +22,7 @@ menuconfig BSP_USING_GPIO menuconfig BSP_USING_I2C bool "Using I2C device" - default y + default n select RESOURCES_I2C if BSP_USING_I2C @@ -31,7 +31,7 @@ menuconfig BSP_USING_I2C menuconfig BSP_USING_ADC bool "Using ADC device" - default y + default n select RESOURCES_ADC if BSP_USING_ADC @@ -40,7 +40,7 @@ menuconfig BSP_USING_ADC menuconfig BSP_USING_SPI bool "Using SPI device" - default y + default n select RESOURCES_SPI if BSP_USING_SPI diff --git a/Ubiquitous/XiZi/board/ok1052-c/third_party_driver/spi/Makefile b/Ubiquitous/XiZi/board/ok1052-c/third_party_driver/spi/Makefile index 7eaf163ae..8765fdab1 100755 --- a/Ubiquitous/XiZi/board/ok1052-c/third_party_driver/spi/Makefile +++ b/Ubiquitous/XiZi/board/ok1052-c/third_party_driver/spi/Makefile @@ -1,3 +1,7 @@ -SRC_FILES := fsl_lpspi.c connect_spi.c connect_flash_spi.c +SRC_FILES := fsl_lpspi.c connect_spi.c + +ifeq ($(CONFIG_RESOURCES_SPI_SFUD),y) + SRC_FILES += connect_flash_spi.c +endif include $(KERNEL_ROOT)/compiler.mk From e5d124231c72798f7f77b842cc8c631b79043914 Mon Sep 17 00:00:00 2001 From: wlyu Date: Wed, 16 Mar 2022 18:34:55 +0800 Subject: [PATCH 2/2] support plc socket and optimize LWIP test demo cases --- .../socket_demo/lwip_tcp_socket_demo.c | 24 +- .../socket_demo/lwip_udp_socket_demo.c | 6 +- .../control_app/opcua_demo/opcua_demo.c | 38 +- .../control/plc/interoperability/Kconfig | 6 +- .../control/plc/interoperability/Makefile | 4 + .../plc/interoperability/opcua/open62541.c | 6 +- .../plc/interoperability/opcua/ua_api.c | 7 +- .../plc/interoperability/opcua/ua_api.h | 3 +- .../plc/interoperability/opcua/ua_client.c | 42 +- .../plc/interoperability/opcua/ua_test.c | 6 +- .../plc/interoperability/socket/Kconfig | 11 + .../plc/interoperability/socket/Makefile | 4 + .../plc/interoperability/socket/br_socket.c | 1867 +++++++++++++++++ .../plc/interoperability/socket/plc_socket.c | 322 +++ .../plc/interoperability/socket/plc_socket.h | 67 + Ubiquitous/XiZi/kernel/thread/msgqueue.c | 1 + .../resources/ethernet/LwIP/api/api_lib.c | 2 +- .../resources/ethernet/LwIP/arch/lwipopts.h | 22 +- .../resources/ethernet/LwIP/arch/sys_arch.c | 14 +- .../ethernet/cmd_lwip/lwip_config_demo.c | 16 +- .../ethernet/cmd_lwip/lwip_dhcp_demo.c | 34 +- .../ethernet/cmd_lwip/lwip_ping_demo.c | 2 +- .../ethernet/cmd_lwip/lwip_tcp_demo.c | 50 +- .../ethernet/cmd_lwip/lwip_udp_demo.c | 32 +- .../XiZi/resources/ethernet/cmd_lwip/ping.c | 10 +- .../resources/ethernet/cmd_lwip/tcpecho_raw.c | 4 +- 26 files changed, 2442 insertions(+), 158 deletions(-) create mode 100755 APP_Framework/Framework/control/plc/interoperability/socket/Kconfig create mode 100755 APP_Framework/Framework/control/plc/interoperability/socket/Makefile create mode 100755 APP_Framework/Framework/control/plc/interoperability/socket/br_socket.c create mode 100755 APP_Framework/Framework/control/plc/interoperability/socket/plc_socket.c create mode 100755 APP_Framework/Framework/control/plc/interoperability/socket/plc_socket.h diff --git a/APP_Framework/Applications/connection_app/socket_demo/lwip_tcp_socket_demo.c b/APP_Framework/Applications/connection_app/socket_demo/lwip_tcp_socket_demo.c index d30248442..a09866fa9 100755 --- a/APP_Framework/Applications/connection_app/socket_demo/lwip_tcp_socket_demo.c +++ b/APP_Framework/Applications/connection_app/socket_demo/lwip_tcp_socket_demo.c @@ -67,7 +67,7 @@ static void TCPSocketRecvTask(void *arg) } lw_print("tcp bind success, start to receive.\n"); - lw_pr_info("\n\nLocal Port:%d\n\n", LWIP_LOCAL_PORT); + lw_notice("\n\nLocal Port:%d\n\n", LWIP_LOCAL_PORT); // setup socket fd as listening mode if (listen(fd, 5) != 0 ) @@ -78,7 +78,7 @@ static void TCPSocketRecvTask(void *arg) // accept client connection clientfd = accept(fd, (struct sockaddr *)&tcp_addr, (socklen_t*)&addr_len); - lw_pr_info("client %s connected\n", inet_ntoa(tcp_addr.sin_addr)); + lw_notice("client %s connected\n", inet_ntoa(tcp_addr.sin_addr)); while(1) { @@ -86,8 +86,8 @@ static void TCPSocketRecvTask(void *arg) recv_len = recvfrom(clientfd, recv_buf, TCP_DEMO_BUF_SIZE, 0, (struct sockaddr *)&tcp_addr, &addr_len); if(recv_len > 0) { - lw_pr_info("Receive from : %s\n", inet_ntoa(tcp_addr.sin_addr)); - lw_pr_info("Receive data : %d - %s\n\n", recv_len, recv_buf); + lw_notice("Receive from : %s\n", inet_ntoa(tcp_addr.sin_addr)); + lw_notice("Receive data : %d - %s\n\n", recv_len, recv_buf); } sendto(clientfd, recv_buf, recv_len, 0, (struct sockaddr*)&tcp_addr, addr_len); } @@ -113,7 +113,7 @@ void TCPSocketRecvTest(int argc, char *argv[]) sscanf(argv[1], "%d.%d.%d.%d", &tcp_socket_ip[0], &tcp_socket_ip[1], &tcp_socket_ip[2], &tcp_socket_ip[3]); } - lwip_config_tcp(lwip_ipaddr, lwip_netmask, lwip_gwaddr); + lwip_config_tcp(lwip_ipaddr, lwip_netmask, tcp_socket_ip); sys_thread_new("TCPSocketRecvTask", TCPSocketRecvTask, NULL, LWIP_TASK_STACK_SIZE, LWIP_DEMO_TASK_PRIO); } @@ -133,7 +133,7 @@ static void TCPSocketSendTask(void *arg) if (fd < 0) { lw_print("Socket error\n"); - goto __exit; + return; } struct sockaddr_in tcp_sock; @@ -145,25 +145,23 @@ static void TCPSocketSendTask(void *arg) if (connect(fd, (struct sockaddr *)&tcp_sock, sizeof(struct sockaddr))) { lw_print("Unable to connect\n"); - goto __exit; + closesocket(fd); + return; } lw_print("tcp connect success, start to send.\n"); - lw_pr_info("\n\nTarget Port:%d\n\n", LWIP_TARGET_PORT); + lw_notice("\n\nTarget Port:%d\n\n", LWIP_TARGET_PORT); while (cnt --) { lw_print("Lwip client is running.\n"); snprintf(send_msg, sizeof(send_msg), "TCP test package times %d\r\n", cnt); sendto(fd, send_msg, strlen(send_msg), 0, (struct sockaddr*)&tcp_sock, sizeof(struct sockaddr)); - lw_pr_info("Send tcp msg: %s ", send_msg); + lw_notice("Send tcp msg: %s ", send_msg); MdelayKTask(1000); } -__exit: - if (fd >= 0) - closesocket(fd); - + closesocket(fd); return; } diff --git a/APP_Framework/Applications/connection_app/socket_demo/lwip_udp_socket_demo.c b/APP_Framework/Applications/connection_app/socket_demo/lwip_udp_socket_demo.c index 4dd23b9e2..24a1a374f 100755 --- a/APP_Framework/Applications/connection_app/socket_demo/lwip_udp_socket_demo.c +++ b/APP_Framework/Applications/connection_app/socket_demo/lwip_udp_socket_demo.c @@ -78,8 +78,8 @@ static void UdpSocketRecvTask(void *arg) { memset(recv_buf, 0, UDP_BUF_SIZE); recv_len = recvfrom(socket_fd, recv_buf, UDP_BUF_SIZE, 0, (struct sockaddr *)&server_addr, &addr_len); - lw_pr_info("Receive from : %s\n", inet_ntoa(server_addr.sin_addr)); - lw_pr_info("Receive data : %s\n\n", recv_buf); + lw_notice("Receive from : %s\n", inet_ntoa(server_addr.sin_addr)); + lw_notice("Receive data : %s\n\n", recv_buf); sendto(socket_fd, recv_buf, recv_len, 0, (struct sockaddr*)&server_addr, addr_len); } @@ -151,7 +151,7 @@ static void UdpSocketSendTask(void *arg) { snprintf(send_str, sizeof(send_str), "UDP test package times %d\r\n", cnt); sendto(socket_fd, send_str, strlen(send_str), 0, (struct sockaddr*)&udp_sock, sizeof(struct sockaddr)); - lw_pr_info("Send UDP msg: %s ", send_str); + lw_notice("Send UDP msg: %s ", send_str); MdelayKTask(1000); } diff --git a/APP_Framework/Applications/control_app/opcua_demo/opcua_demo.c b/APP_Framework/Applications/control_app/opcua_demo/opcua_demo.c index c8a0e8d54..e1edcf29a 100755 --- a/APP_Framework/Applications/control_app/opcua_demo/opcua_demo.c +++ b/APP_Framework/Applications/control_app/opcua_demo/opcua_demo.c @@ -11,7 +11,7 @@ */ /** - * @file ua_demo.c + * @file opcua_demo.c * @brief Demo for OpcUa function * @version 1.0 * @author AIIT XUOS Lab @@ -29,7 +29,6 @@ * Definitions ******************************************************************************/ -#define TCP_LOCAL_PORT 4840 #define UA_URL_SIZE 100 #define UA_STACK_SIZE 4096 #define UA_TASK_PRIO 15 @@ -66,18 +65,17 @@ static void UaConnectTestTask(void* arg) UA_ClientConfig_setDefault(config); snprintf(ua_uri, sizeof(ua_uri), "opc.tcp://%d.%d.%d.%d:4840", test_ua_ip[0], test_ua_ip[1], test_ua_ip[2], test_ua_ip[3]); - ua_pr_info("ua uri: %d %s\n", strlen(ua_uri), ua_uri); + ua_notice("ua uri: %d %s\n", strlen(ua_uri), ua_uri); retval = UA_Client_connect(client,ua_uri); if(retval != UA_STATUSCODE_GOOD) { - ua_pr_info("ua: [%s] connected failed %x\n", __func__, retval); + ua_notice("ua: [%s] connected failed %x\n", __func__, retval); UA_Client_delete(client); return; } - ua_pr_info("ua: [%s] connected ok!\n", __func__); - UA_Client_disconnect(client); + ua_notice("ua: [%s] connected ok!\n", __func__); UA_Client_delete(client); } @@ -92,12 +90,13 @@ SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | void UaBrowserObjectsTestTask(void* param) { + static int test_cnt = 0; UA_Client* client = UA_Client_new(); - ua_pr_info("ua: [%s] start ...\n", __func__); + ua_notice("ua: [%s] start %d ...\n", __func__, test_cnt++); if(client == NULL) { - ua_print("ua: [%s] tcp client null\n", __func__); + ua_error("ua: [%s] tcp client NULL\n", __func__); return; } @@ -107,18 +106,17 @@ void UaBrowserObjectsTestTask(void* param) if(retval != UA_STATUSCODE_GOOD) { - ua_print("ua: [%s] connect failed %#x\n", __func__, retval); + ua_error("ua: [%s] connect failed %#x\n", __func__, retval); UA_Client_delete(client); return; } - ua_print("ua: [%s] connect ok!\n", __func__); - ua_pr_info("--- start read time ---\n", __func__); + ua_notice("--- start read time ---\n", __func__); ua_read_time(client); - ua_pr_info("--- get server info ---\n", __func__); + ua_notice("--- get server info ---\n", __func__); ua_test_browser_objects(client); + /* Clean up */ - UA_Client_disconnect(client); UA_Client_delete(client); /* Disconnects the client internally */ } @@ -130,7 +128,7 @@ void* UaBrowserObjectsTest(int argc, char* argv[]) { if(sscanf(argv[1], "%d.%d.%d.%d", &test_ua_ip[0], &test_ua_ip[1], &test_ua_ip[2], &test_ua_ip[3]) == EOF) { - lw_pr_info("input wrong ip\n"); + lw_notice("input wrong ip\n"); return NULL; } } @@ -147,7 +145,7 @@ SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | void UaGetInfoTestTask(void* param) { UA_Client* client = UA_Client_new(); - ua_pr_info("ua: [%s] start ...\n", __func__); + ua_notice("ua: [%s] start ...\n", __func__); if(client == NULL) { @@ -167,7 +165,7 @@ void UaGetInfoTestTask(void* param) } ua_print("ua: [%s] connect ok!\n", __func__); - ua_pr_info("--- interactive server ---\n", __func__); + ua_notice("--- interactive server ---\n", __func__); ua_test_interact_server(client); /* Clean up */ UA_Client_disconnect(client); @@ -182,7 +180,7 @@ void* UaGetInfoTest(int argc, char* argv[]) { if(sscanf(argv[1], "%d.%d.%d.%d", &test_ua_ip[0], &test_ua_ip[1], &test_ua_ip[2], &test_ua_ip[3]) == EOF) { - lw_pr_info("input wrong ip\n"); + lw_notice("input wrong ip\n"); return NULL; } } @@ -199,7 +197,7 @@ SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | void UaAddNodesTask(void* param) { UA_Client* client = UA_Client_new(); - ua_pr_info("ua: [%s] start ...\n", __func__); + ua_notice("ua: [%s] start ...\n", __func__); if(client == NULL) { @@ -219,7 +217,7 @@ void UaAddNodesTask(void* param) } ua_print("ua: [%s] connect ok!\n", __func__); - ua_pr_info("--- add nodes ---\n", __func__); + ua_notice("--- add nodes ---\n", __func__); ua_add_nodes(client); /* Clean up */ UA_Client_disconnect(client); @@ -234,7 +232,7 @@ void* UaAddNodesTest(int argc, char* argv[]) { if(sscanf(argv[1], "%d.%d.%d.%d", &test_ua_ip[0], &test_ua_ip[1], &test_ua_ip[2], &test_ua_ip[3]) == EOF) { - lw_pr_info("input wrong ip\n"); + lw_notice("input wrong ip\n"); return NULL; } } diff --git a/APP_Framework/Framework/control/plc/interoperability/Kconfig b/APP_Framework/Framework/control/plc/interoperability/Kconfig index 66ae5f182..6a7cb0324 100755 --- a/APP_Framework/Framework/control/plc/interoperability/Kconfig +++ b/APP_Framework/Framework/control/plc/interoperability/Kconfig @@ -2,5 +2,9 @@ menuconfig USING_CONTROL_PLC_OPCUA bool "PLC support OPCUA" default y - depends on RESOURCES_LWIP + depends on RESOURCES_LWIP +menuconfig USING_CONTROL_PLC_SOCKET + bool "PLC support SOCKET" + default y + depends on RESOURCES_LWIP diff --git a/APP_Framework/Framework/control/plc/interoperability/Makefile b/APP_Framework/Framework/control/plc/interoperability/Makefile index 7f542f711..d329b91fb 100755 --- a/APP_Framework/Framework/control/plc/interoperability/Makefile +++ b/APP_Framework/Framework/control/plc/interoperability/Makefile @@ -6,6 +6,10 @@ ifeq ($(CONFIG_USING_CONTROL_PLC_OPCUA), y) SRC_DIR += opcua endif +ifeq ($(CONFIG_USING_CONTROL_PLC_SOCKET), y) + SRC_DIR += socket +endif + endif SRC_FILES += interoperability.c diff --git a/APP_Framework/Framework/control/plc/interoperability/opcua/open62541.c b/APP_Framework/Framework/control/plc/interoperability/opcua/open62541.c index 3da01d2b7..fc525aa8d 100755 --- a/APP_Framework/Framework/control/plc/interoperability/opcua/open62541.c +++ b/APP_Framework/Framework/control/plc/interoperability/opcua/open62541.c @@ -68231,11 +68231,11 @@ UA_Log_Stdout_log(void *context, UA_LogLevel level, UA_LogCategory category, // (int)(tOffset / UA_DATETIME_SEC / 36), logLevelNames[level], logCategoryNames[category]); // vprintf(msg, args); - KPrintf("%s/%s" ANSI_COLOR_RESET "\t", + ua_print("%s/%s" ANSI_COLOR_RESET "\t", logLevelNames[level], logCategoryNames[category]); vsnprintf(str, sizeof(str) - 1, msg, args); - KPrintf(msg, str); - KPrintf("\n"); + ua_print(msg, str); + ua_print("\n"); // printf("\n"); fflush(stdout); diff --git a/APP_Framework/Framework/control/plc/interoperability/opcua/ua_api.c b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_api.c index e2e5fdb3e..4512368be 100755 --- a/APP_Framework/Framework/control/plc/interoperability/opcua/ua_api.c +++ b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_api.c @@ -28,7 +28,7 @@ int ua_open(void *dev) param->client = UA_Client_new(); - ua_pr_info("ua: [%s] start ...\n", __func__); + ua_notice("ua: [%s] start ...\n", __func__); if (param->client == NULL) { @@ -39,11 +39,11 @@ int ua_open(void *dev) UA_ClientConfig *config = UA_Client_getConfig(param->client); UA_ClientConfig_setDefault(config); - ua_pr_info("ua: [%s] %d %s\n", __func__, strlen(param->ua_remote_ip), param->ua_remote_ip); + ua_notice("ua: [%s] %d %s\n", __func__, strlen(param->ua_remote_ip), param->ua_remote_ip); UA_StatusCode retval = UA_Client_connect(param->client, param->ua_remote_ip); if(retval != UA_STATUSCODE_GOOD) { - ua_pr_info("ua: [%s] deleted ret %x!\n", __func__, retval); + ua_notice("ua: [%s] deleted ret %x!\n", __func__, retval); return (int)retval; } return EOK; @@ -52,7 +52,6 @@ int ua_open(void *dev) void ua_close(void *dev) { UaParamType *param = (UaParamType *)dev; - UA_Client_disconnect(param->client); UA_Client_delete(param->client); /* Disconnects the client internally */ } diff --git a/APP_Framework/Framework/control/plc/interoperability/opcua/ua_api.h b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_api.h index 903d9c6aa..7da7a4faa 100755 --- a/APP_Framework/Framework/control/plc/interoperability/opcua/ua_api.h +++ b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_api.h @@ -43,8 +43,9 @@ typedef struct UaParam #define ua_print //KPrintf #define ua_trace() //KPrintf("ua: [%s] line %d checked!\n", __func__, __LINE__) -#define ua_pr_info KPrintf +#define ua_notice KPrintf #define ua_debug //KPrintf +#define ua_error KPrintf extern const char *opc_server_url; extern char test_ua_ip[]; diff --git a/APP_Framework/Framework/control/plc/interoperability/opcua/ua_client.c b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_client.c index 65a4ecb43..749025f75 100755 --- a/APP_Framework/Framework/control/plc/interoperability/opcua/ua_client.c +++ b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_client.c @@ -42,7 +42,7 @@ static UA_StatusCode nodeIter(UA_NodeId childId, UA_Boolean isInverse, UA_NodeId } UA_NodeId* parent = (UA_NodeId*)handle; - ua_pr_info("%d, %d --- %d ---> NodeId %d, %d\n", + ua_notice("%d, %d --- %d ---> NodeId %d, %d\n", parent->namespaceIndex, parent->identifier.numeric, referenceTypeId.identifier.numeric, childId.namespaceIndex, childId.identifier.numeric); @@ -81,38 +81,38 @@ void ua_print_value(UA_Variant* val) if(val->type == &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]) { UA_LocalizedText* ptr = (UA_LocalizedText*)val->data; - ua_pr_info("%.*s (Text)\n", ptr->text.length, ptr->text.data); + ua_notice("%.*s (Text)\n", ptr->text.length, ptr->text.data); } else if(val->type == &UA_TYPES[UA_TYPES_UINT32]) { UA_UInt32* ptr = (UA_UInt32*)val->data; - ua_pr_info("%d (UInt32)\n", *ptr); + ua_notice("%d (UInt32)\n", *ptr); } else if(val->type == &UA_TYPES[UA_TYPES_BOOLEAN]) { UA_Boolean* ptr = (UA_Boolean*)val->data; - ua_pr_info("%i (BOOL)\n", *ptr); + ua_notice("%i (BOOL)\n", *ptr); } else if(val->type == &UA_TYPES[UA_TYPES_INT32]) { UA_Int32* ptr = (UA_Int32*)val->data; - ua_pr_info("%d (Int32)\n", *ptr); + ua_notice("%d (Int32)\n", *ptr); } else if(val->type == &UA_TYPES[UA_TYPES_INT16]) { UA_Int16* ptr = (UA_Int16*)val->data; - ua_pr_info("%d (Int16)\n", *ptr); + ua_notice("%d (Int16)\n", *ptr); } else if(val->type == &UA_TYPES[UA_TYPES_STRING]) { UA_String* ptr = (UA_String*)val->data; - ua_pr_info("%*.s (String)\n", ptr->length, ptr->data); + ua_notice("%*.s (String)\n", ptr->length, ptr->data); } else if(val->type == &UA_TYPES[UA_TYPES_DATETIME]) { UA_DateTime* ptr = (UA_DateTime*)val->data; UA_DateTimeStruct dts = UA_DateTime_toStruct(*ptr); - ua_pr_info("%d-%d-%d %d:%d:%d.%03d (Time)\n", + ua_notice("%d-%d-%d %d:%d:%d.%03d (Time)\n", dts.day, dts.month, dts.year, dts.hour, dts.min, dts.sec, dts.milliSec); } } @@ -144,14 +144,14 @@ void ua_print_nodeid(UA_NodeId *node_id) switch(node_id->identifierType) { case UA_NODEIDTYPE_NUMERIC: - ua_pr_info(" NodeID n%d,%d ", node_id->namespaceIndex, node_id->identifier.numeric); + ua_notice(" NodeID n%d,%d ", node_id->namespaceIndex, node_id->identifier.numeric); break; case UA_NODEIDTYPE_STRING: - ua_pr_info(" NodeID n%d,%.*s ", node_id->namespaceIndex, node_id->identifier.string.length, + ua_notice(" NodeID n%d,%.*s ", node_id->namespaceIndex, node_id->identifier.string.length, node_id->identifier.string.data); break; case UA_NODEIDTYPE_BYTESTRING: - ua_pr_info(" NodeID n%d,%s ", node_id->namespaceIndex, node_id->identifier.byteString.data); + ua_notice(" NodeID n%d,%s ", node_id->namespaceIndex, node_id->identifier.byteString.data); break; default: break; @@ -160,7 +160,7 @@ void ua_print_nodeid(UA_NodeId *node_id) void ua_print_object(UA_BrowseResponse* res) { - ua_pr_info("%-9s %-16s %-16s %-16s\n", "NAMESPACE", "NODEID", "BROWSE NAME", "DISPLAY NAME"); + ua_notice("%-9s %-16s %-16s %-16s\n", "NAMESPACE", "NODEID", "BROWSE NAME", "DISPLAY NAME"); for(size_t i = 0; i < res->resultsSize; ++i) { @@ -170,14 +170,14 @@ void ua_print_object(UA_BrowseResponse* res) if(ref->nodeId.nodeId.identifierType == UA_NODEIDTYPE_NUMERIC) { - ua_pr_info("%-9d %-16d %-16.*s %-16.*s\n", ref->nodeId.nodeId.namespaceIndex, + ua_notice("%-9d %-16d %-16.*s %-16.*s\n", ref->nodeId.nodeId.namespaceIndex, ref->nodeId.nodeId.identifier.numeric, (int)ref->browseName.name.length, ref->browseName.name.data, (int)ref->displayName.text.length, ref->displayName.text.data); } else if(ref->nodeId.nodeId.identifierType == UA_NODEIDTYPE_STRING) { - ua_pr_info("%-9d %-16.*s %-16.*s %-16.*s\n", ref->nodeId.nodeId.namespaceIndex, + ua_notice("%-9d %-16.*s %-16.*s %-16.*s\n", ref->nodeId.nodeId.namespaceIndex, (int)ref->nodeId.nodeId.identifier.string.length, ref->nodeId.nodeId.identifier.string.data, (int)ref->browseName.name.length, ref->browseName.name.data, @@ -188,7 +188,7 @@ void ua_print_object(UA_BrowseResponse* res) } } - ua_pr_info("\n"); + ua_notice("\n"); } UA_StatusCode ua_read_array_value(UA_Client* client, int array_size, UA_ReadValueId* array) @@ -203,7 +203,7 @@ UA_StatusCode ua_read_array_value(UA_Client* client, int array_size, UA_ReadValu || (response.resultsSize != array_size)) { UA_ReadResponse_clear(&response); - ua_pr_info("ua: [%s] read failed 0x%x\n", __func__, + ua_notice("ua: [%s] read failed 0x%x\n", __func__, response.responseHeader.serviceResult); return UA_STATUSCODE_BADUNEXPECTEDERROR; } @@ -215,11 +215,11 @@ UA_StatusCode ua_read_array_value(UA_Client* client, int array_size, UA_ReadValu if((response.results[i].status == UA_STATUSCODE_GOOD) && (response.results[i].hasValue)) { - ua_pr_info("node %s: ", ua_get_nodeid_str(&array[i].nodeId)); + ua_notice("node %s: ", ua_get_nodeid_str(&array[i].nodeId)); ua_print_value(&response.results[i].value); } } - ua_pr_info("\n"); + ua_notice("\n"); free(arr_ret); UA_ReadResponse_clear(&response); @@ -229,7 +229,7 @@ UA_StatusCode ua_read_array_value(UA_Client* client, int array_size, UA_ReadValu void ua_browser_id(UA_Client* client, UA_NodeId id) { /* Browse some objects */ - ua_pr_info("Browsing nodes in objects folder:\n"); + ua_notice("Browsing nodes in objects folder:\n"); UA_BrowseRequest bReq; UA_BrowseRequest_init(&bReq); bReq.requestedMaxReferencesPerNode = 0; @@ -327,7 +327,7 @@ void ua_write_nodeid_value(UA_Client* client, UA_NodeId id, char* value) if(wResp.responseHeader.serviceResult == UA_STATUSCODE_GOOD) { - ua_pr_info("write new value is: %s\n", value); + ua_notice("write new value is: %s\n", value); } UA_WriteRequest_clear(&wReq); @@ -489,7 +489,7 @@ void ua_read_time(UA_Client* client) { UA_DateTime raw_date = *(UA_DateTime*) value.data; UA_DateTimeStruct dts = UA_DateTime_toStruct(raw_date); - ua_pr_info("date is: %d-%d-%d %d:%d:%d.%03d\n", + ua_notice("date is: %d-%d-%d %d:%d:%d.%03d\n", dts.day, dts.month, dts.year, dts.hour, dts.min, dts.sec, dts.milliSec); } diff --git a/APP_Framework/Framework/control/plc/interoperability/opcua/ua_test.c b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_test.c index 329118bfc..d11b86896 100755 --- a/APP_Framework/Framework/control/plc/interoperability/opcua/ua_test.c +++ b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_test.c @@ -53,7 +53,7 @@ void ua_test_browser_objects(UA_Client *client) ua_browser_id(client, UA_TEST_BROWSER_NODEID); ua_browser_id(client, UA_TEST_BROWSER_NODEID1); test_id = UA_TEST_BROWSER_NODEID1; - ua_pr_info("Show values in %s:\n", ua_get_nodeid_str(&test_id)); + ua_notice("Show values in %s:\n", ua_get_nodeid_str(&test_id)); ua_test_read_array(client); return; } @@ -64,11 +64,11 @@ void ua_test_write_attr(UA_Client *client) char val_str[UA_NODE_LEN]; UA_NodeId id = UA_TEST_WRITE_NODEID; - ua_pr_info("--- Test write %s ---\n", ua_get_nodeid_str(&id)); + ua_notice("--- Test write %s ---\n", ua_get_nodeid_str(&id)); ua_read_nodeid_value(client, id, &value); ua_write_nodeid_value(client, id, itoa(value + 1, val_str, 10)); ua_read_nodeid_value(client, id, &value); - ua_pr_info("\n"); + ua_notice("\n"); } int ua_test_interact_server(UA_Client *client) diff --git a/APP_Framework/Framework/control/plc/interoperability/socket/Kconfig b/APP_Framework/Framework/control/plc/interoperability/socket/Kconfig new file mode 100755 index 000000000..d8325aa40 --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/socket/Kconfig @@ -0,0 +1,11 @@ + +menuconfig USING_CONTROL_PLC_OPCUA + bool "PLC support OPCUA" + default y + depends on RESOURCES_LWIP + +menuconfig USING_CONTROL_PLC_SOCKET + bool "PLC support SOCKET" + default y + depends on RESOURCES_LWIP + diff --git a/APP_Framework/Framework/control/plc/interoperability/socket/Makefile b/APP_Framework/Framework/control/plc/interoperability/socket/Makefile new file mode 100755 index 000000000..2c3e00b48 --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/socket/Makefile @@ -0,0 +1,4 @@ +SRC_FILES := plc_socket.c + +include $(KERNEL_ROOT)/compiler.mk + diff --git a/APP_Framework/Framework/control/plc/interoperability/socket/br_socket.c b/APP_Framework/Framework/control/plc/interoperability/socket/br_socket.c new file mode 100755 index 000000000..a655a0a67 --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/socket/br_socket.c @@ -0,0 +1,1867 @@ +#include +#include +#include "plc_socket.h" + +#define xs_kprintf KPrintf +#define xs_device_t uint32_t + + +static unsigned char data_head = 0x5A; +static char device_s14[] = "S14"; +static char device_s15[] = "S15"; +static char device_s16[] = "S16"; +static char device_s17[] = "S17"; +static char device_s18[] = "S18"; +static char data_end[] = "#"; +unsigned char redis_data[1024]; + +// 创建一个信号量，用于接收消息的同步 +static sem_t Ch_Sem = NULL; +static sem_t Rx_Sem = NULL; + +extern xs_device_t ec200t; + +//for SIEMENS TCP read data cmd +const unsigned char handshake_first[] = +{ + 0x3, 0x00, 0x00, 0x16, 0x11, 0xe0, 0x00, 0x00, 0x02, + 0xc8,0x00,0xc1,0x02,0x02,0x01,0xc2,0x02,0x02,0x01,0xc0,0x01,0x0a +}; + +const unsigned char handshake_second[] = +{ + 0x3,0x00,0x00,0x19,0x02,0xf0,0x80,0x32,0x01,0x00,0x00,0x00,0x0d,0x00,0x08,0x00,0x00,0xf0,0x00,0x00,0x01,0x00,0x01,0x00,0xf0 +}; + +const unsigned char siemens_read_data[] = +{ + 0x3,0x00,0x00, 0x1f,0x02,0xf0,0x80,0x32,0x01,0x00,0x00,0x33,0x01,0x00,0x0e,0x00,0x00,0x04,0x01,0x12,0x0a,0x10,0x02,0x00,0xD2,0x00,0x34,0x84,0x00,0x00,0x00 +}; + +//for OML UDP read data cmd +const unsigned char UDP_read_data[] = +{ + 0x80,0x00,0x02,0x00,0x03,0x00,0x00,0x7E,0x00,0x00,0x01,0x01,0x82,0x0F,0xA0,0x00,0x00,0x20 +}; + +//for SIEMENS 1200 read data cmd +const unsigned char handshake_1200_first[] = +{ + 0x03, 0x00, 0x00, 0x16, 0x11, 0xE0, 0x00, 0x00, 0x02, 0xC8, 0x00, 0xC1, 0x02, 0x02, 0x01, 0xC2, 0x02, 0x02, 0x01, 0xC0, 0x01, 0x0A +}; + +const unsigned char handshake_1200_second[] = +{ + 0x03, 0x00, 0x00, 0x19, 0x02, 0xF0, 0x80, 0x32, 0x01, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x08, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0xF0 +}; + +const unsigned char siemens_1200_read_data[] = +{ + 0x03, 0x00, 0x00, 0x1F, 0x02, 0xF0, 0x80, 0x32, 0x01, 0x00, 0x00, 0x33, 0x01, 0x00, 0x0E, 0x00, 0x00, 0x04, 0x01, 0x12, 0x0A, 0x10, 0x02, 0x00, 0xD2, 0x00, 0x34, 0x84, 0x00, 0x00, 0x00 +}; + +#define PUT_ULONG_BE(n,b,i) \ +{ \ + (b)[(i) ] = (uint8_t) ( (n) >> 24 ); \ + (b)[(i) + 1] = (uint8_t) ( (n) >> 16 ); \ + (b)[(i) + 2] = (uint8_t) ( (n) >> 8 ); \ + (b)[(i) + 3] = (uint8_t) ( (n) ); \ +} + +#define GET_ULONG_BE(n,b,i) \ +{ \ + (n) = ( (uint32_t) (b)[(i) ] << 24 ) \ + | ( (uint32_t) (b)[(i) + 1] << 16 ) \ + | ( (uint32_t) (b)[(i) + 2] << 8 ) \ + | ( (uint32_t) (b)[(i) + 3] ); \ +} + +#define XS_SERIAL_RB_BUFSZ 128 + +char rx_buffer_cmp[256 + 1]; +char msg_pool[256]; +char rx_buffer[XS_SERIAL_RB_BUFSZ + 1] = {0}; +#define WIFI_RESET 73 + +#define LEN_PARA_BUF 128 +uint8_t server_addr_wifi[LEN_PARA_BUF] = "192.168.23.181"; //??????? +uint8_t server_port_wifi[LEN_PARA_BUF] = "9999"; //?????? + +uint8_t WIFI_ssid[LEN_PARA_BUF] = "xiaoshanos"; //WIFI? +uint8_t WIFI_pwd[LEN_PARA_BUF] = "12345678"; //WIFI???? + +#if 0 +/* ?????? */ +xs_device_t hfa21; +/* ??????? */ +struct xs_MessageQueue* rx3_mq; +/* ???????? */ + +void hfa21_sta_config(void) +{ + xs_kprintf("hfa21_sta_config start\r\n"); + uint8_t i,step; + uint8_t cmd[LEN_PARA_BUF]; + step = 1; + strcpy(cmd, "+++"); + //send + xs_DeviceWrite(hfa21, 0, cmd, 3); + xs_kprintf("cmd.%d=%s\r\n",step,cmd); + step = 2; + memset(cmd,0,sizeof(cmd)); + xs_MdelayKTask(100); + strcpy(cmd,"a"); + //send + xs_DeviceWrite(hfa21, 0, cmd, 1); + xs_kprintf("cmd.%d=%s\r\n",step,cmd); + step = 3; + memset(cmd,0,sizeof(cmd)); + xs_MdelayKTask(2500); + strcpy(cmd, "AT+FCLR\r\n"); + + //send + for(i=0; i 1000) + { + xs_kprintf("data length too long\n "); + return; + } + + xs_DeviceWrite(hfa21, 0, buf, len); + return ; +} + +void msg_send_once(void) +{ + uint8_t msg[1024] = { 0}; + uint32_t i = 0; + xs_kprintf("ap test, send msg to server : "); + memset(msg,0x37,1024); + xs_memcpy(msg,"arm:dev7,data:",14); + msg[1023] = '\n'; + xs_DeviceWrite(hfa21,0, msg, 1024); + // xs_MdelayKTask(1000); + return ; +} +MSH_CMD_EXPORT(msg_send_once, asd); + +void msg_send_nointerval(void) +{ + uint8_t msg[1024] = { 0}; + uint32_t i = 1; + uint32_t index = 0; + uint8_t seq[10] = { 0}; + uint8_t* prefix = "{board:stm32f407-st-discovery,arch:arm,device:7,seq:"; + xs_kprintf("ap test, send msg to server : "); + + for(;;) + { + index = 0; + memset(msg,0x37,1024); + memset(seq,0,10); + msg[1021] = '}'; + msg[1022] = '\n'; + msg[1023] = 0; + xs_memcpy(msg,prefix,strlen(prefix)); + index = index + strlen(prefix); + PUT_ULONG_BE(i, msg, index) + index = index + 4; + xs_memcpy(msg+index,",data:",6); + xs_DeviceWrite(hfa21,0, msg, 1024); + ++ i; + } + + return ; +} +MSH_CMD_EXPORT(msg_send_nointerval, asd); + +void msg_send_interval(void) +{ + uint8_t msg[1024] = { 0}; + uint32_t i = 1; + uint32_t index = 0; + uint8_t seq[4] = { 0}; + uint8_t* prefix = "{board:stm32f407-st-discovery,arch:arm,device:7,seq:"; + xs_kprintf("ap test, send msg to server : "); + + for(;;) + { + index = 0; + memset(msg,0x37,1024); + memset(seq,0,10); + msg[1021] = '}'; + msg[1022] = '\n'; + msg[1023] = 0; + xs_memcpy(msg,prefix,strlen(prefix)); + index = index + strlen(prefix); + PUT_ULONG_BE(i, msg, index) + index = index + 4; + xs_memcpy(msg+index,",data:",6); + xs_DeviceWrite(hfa21,0, msg, 1024); + xs_MdelayKTask(1000); + ++ i; + } + + return ; +} +MSH_CMD_EXPORT(msg_send_interval, asd); + +struct xs_Ringbuffer* ringbuffer; + +uint8_t stack[256] = {0}; +xs_uint16 data_index = 0 ; +uint8_t start = 0xaa; +uint8_t end = 0xbb; + +uint8_t lora_buffer[8][256] = {0}; + +static void read_ringbuffer_thread_entry(void* parameter) +{ + uint8_t ch = 0; + xs_uint16 index = 0 ; + uint8_t devicenumber; + + while(1) + { + if(1 == xs_GetRingBufferchar(ringbuffer,&ch)) + { + if(data_index < 256) + { + stack[data_index++] = ch; + + if(data_index > 2) + { + if(stack[data_index-1] == start && stack[data_index-2] == start) + { + data_index = 0; + stack[data_index++] == start; + stack[data_index++] == start; + } + else if(stack[data_index-1] == end && stack[data_index-2] == end) + { + //end + devicenumber = stack[3] - 0x30; + + if(devicenumber > 0 && devicenumber < 8) + { + memset(lora_buffer[devicenumber-1],0,256); + memcpy(lora_buffer[devicenumber-1], &stack[2],data_index - 4); + // xs_kprintf("lora data: %s\n",lora_buffer[devicenumber-1]); + } + + data_index = 0; + } + } + } + else + { + data_index = 0; + } + } + else + { + xs_MdelayKTask(20); + } + } +} +#endif + +#if 0 +/***********************************************************************/ +//欧姆龙PLC IP 192.168.250.3 port 9600 + +static xs_err_t oml_uart_input(xs_device_t dev, xs_size_t size) +{ + xs_KSemaphoreAbandon(Ch_Sem); + return XS_EOK; +} + +static void oml_plc_thread(void* parameter) +{ + xs_err_t ret; + uint32_t rx_length, total_rx_length = 0; + uint8_t i; + unsigned int length = 0; + + while(1) + { + ret = xs_KSemaphoreObtain(Ch_Sem, XS_WAITING_FOREVER); + + if(XS_EOK == ret) + { + rx_length = xs_DeviceRead(hfa21, 0, redis_data + 1 + sizeof(device_s14) + total_rx_length, 78); + xs_kprintf("dst data length %d total length %d\n", rx_length, total_rx_length); + + for(i = 0; i < rx_length; ++i) + { + xs_kprintf("0x%x ", redis_data[i + 1 + sizeof(device_s14) + total_rx_length]); + } + + xs_kprintf("\n"); + total_rx_length += rx_length; + + if((78 == total_rx_length) && (0xC0 == redis_data[1 + sizeof(device_s14)]) + && (0x00 == redis_data[1 + sizeof(device_s14) + 1]) + && (0x02 == redis_data[1 + sizeof(device_s14) + 2]) + && (0x00 == redis_data[1 + sizeof(device_s14) + 3])) + { + /******format redis data******/ + memcpy(redis_data, &data_head, 1); + memcpy(redis_data + 1, device_s14, sizeof(device_s14)); + memcpy(redis_data + 1 + sizeof(device_s14) + total_rx_length, data_end, sizeof(data_end)); + length = 1 + sizeof(device_s14) + total_rx_length + sizeof(data_end); + /******end******/ + xs_DeviceWrite(ec200t, 0, redis_data, length); + total_rx_length = 0; + memset(redis_data, 0, sizeof(redis_data)); + xs_KSemaphoreAbandon(Rx_Sem); + } + } + } +} + +int OML_UDP(void) +{ + struct SerialConfigure config3 = XS_SERIAL_CONFIG_DEFAULT; + hfa21 = xs_DeviceFind("uart3"); + + if(!hfa21) + { + xs_kprintf("find dev.hfa21 failed!\r\n"); + return XS_ERROR; + } + + Ch_Sem = xs_KCreateSemaphore("Ch_Sem",0,XS_LINKLIST_FLAG_FIFO); + + if(Ch_Sem == NULL) + { + xs_kprintf("create Ch_sem failed .\n"); + return XS_ERROR; + } + + Rx_Sem = xs_KCreateSemaphore("Rx_Sem",0,XS_LINKLIST_FLAG_FIFO); + + if(Rx_Sem == NULL) + { + xs_kprintf("create Rx_sem failed .\n"); + return XS_ERROR; + } + + //hfa21 + config3.BaudRate = BAUD_RATE_460800; + config3.DataBits = DATA_BITS_8; + config3.StopBits = STOP_BITS_1; + config3.bufsz = XS_SERIAL_RB_BUFSZ; + config3.parity = PARITY_NONE; + xs_DeviceControl(hfa21, XS_DEVICE_CTRL_CONFIG, &config3); + xs_DeviceOpen(hfa21,XS_DEVICE_FLAG_DMA_RX); + xs_DeviceSetRxIndicate(hfa21, oml_uart_input); + xs_kprintf("hfa21 init success!\r\n"); + TaskDescriptorPointer thread_oml_plc = xs_KTaskCreate("oml_hfa21", oml_plc_thread, NULL, 1024, 25); + + if(thread_oml_plc != NULL) + { + xs_StartupKTask(thread_oml_plc); + } + else + { + return XS_ERROR; + } + + xs_MdelayKTask(10000); + xs_kprintf("The UDP send_receive function is running......\n"); + + while(1) + { +// CH438UARTSend(6, UDP_read_data, sizeof(UDP_read_data)); //UDP_read_data + xs_DeviceWrite(hfa21, 0, UDP_read_data, sizeof(UDP_read_data)); + xs_kprintf("hfa21 write cmd\n"); + xs_KSemaphoreObtain(Rx_Sem, XS_WAITING_FOREVER); + xs_MdelayKTask(1000); + } + + return XS_EOK; +} +MSH_CMD_EXPORT(OML_UDP, oml); + +/*********************************************************************************************/ +// IP 192.168.250.50 port 102 tcp + +//工控机的测试代码，数据帧头FF，帧尾FE，数据帧长度不固?static struct xs_MessageQueue *ipc_mq; +xs_device_t ipc_hfa21; + +static xs_err_t ipc_uart_input(xs_device_t dev, xs_size_t size) +{ + struct rx_msg msg; + xs_err_t result; + msg.dev = dev; + msg.size = size; + result = xs_KMsgQueueSend(ipc_mq, &msg, sizeof(msg)); + + if(result == -XS_EFULL) + { + xs_kprintf("ipc_mq message queue full!\r\n"); + } + + xs_KSemaphoreAbandon(Ch_Sem); + return result; +} + +static void ipc_plc_thread(void* parameter) +{ + struct rx_msg msg; + xs_err_t ret; + uint32_t rx_length, total_rx_length = 0; + uint8_t i; + unsigned int length = 0; + + while(1) + { + ret = xs_KSemaphoreObtain(Ch_Sem, XS_WAITING_FOREVER); + + if(XS_EOK == ret) + { + xs_memset(&msg, 0, sizeof(msg)); + ret = xs_KMsgQueueRecv(ipc_mq, &msg, sizeof(msg), XS_WAITING_FOREVER); + + if(XS_EOK == ret) + { + rx_length = xs_DeviceRead(ipc_hfa21, 0, redis_data + 2 + sizeof(device_s15) + total_rx_length, msg.size); + xs_kprintf("dst data length %d total length %d\n", rx_length, total_rx_length); + + for(i = 0; i < rx_length; ++i) + { + xs_kprintf("0x%x ", redis_data[i + 2 + sizeof(device_s15) + total_rx_length]); + } + + xs_kprintf("\n"); + total_rx_length += rx_length; + + if((0x46 == redis_data[2 + sizeof(device_s15)]) && (0x46 == redis_data[2 + sizeof(device_s15) + 1]) && + (0x45 == redis_data[2 + sizeof(device_s15) + total_rx_length - 1]) && (0x46 == redis_data[2 + sizeof(device_s15) + total_rx_length - 2])) + { + /******format redis data******/ + redis_data[0] = data_head; + redis_data[1] = PLC_IPC_FLAG; + memcpy(redis_data + 2, device_s15, sizeof(device_s15)); + length = 2 + sizeof(device_s15) + total_rx_length; + /******end******/ + // xs_kprintf("redis data : \n"); + // for(i = 0; i < length; ++i) + // xs_kprintf("0x%x ", redis_data[i]); + // xs_kprintf("\n"); + xs_DeviceWrite(ec200t, 0, redis_data, length); + total_rx_length = 0; + memset(redis_data, 0, sizeof(redis_data)); + xs_KSemaphoreAbandon(Rx_Sem); + } + } + } + } +} + +int BRL_IPC(void) +{ + struct SerialConfigure config3 = XS_SERIAL_CONFIG_DEFAULT; + ipc_hfa21 = xs_DeviceFind("uart3"); + + if(!ipc_hfa21) + { + xs_kprintf("find ipc_hfa21 failed!\r\n"); + return XS_ERROR; + } + + Ch_Sem = xs_KCreateSemaphore("Ch_Sem",0,XS_LINKLIST_FLAG_FIFO); + + if(Ch_Sem == NULL) + { + xs_kprintf("BRL_IPC create sem failed .\n"); + return XS_ERROR; + } + + Rx_Sem = xs_KCreateSemaphore("Rx_Sem",0,XS_LINKLIST_FLAG_FIFO); + + if(Rx_Sem == NULL) + { + xs_kprintf("BRL_IPC create Rx_sem failed .\n"); + return XS_ERROR; + } + + ipc_mq = xs_KCreateMsgQueue("ipc_mq", + sizeof(struct rx_msg), + sizeof(msg_pool), + XS_LINKLIST_FLAG_FIFO); + + if(ipc_mq == NULL) + { + xs_kprintf("create ipc_mq mutex failed.\n"); + return -1; + } + + //ipc_hfa21 + config3.BaudRate = BAUD_RATE_460800; + config3.DataBits = DATA_BITS_8; + config3.StopBits = STOP_BITS_1; + config3.bufsz = XS_SERIAL_RB_BUFSZ; + config3.parity = PARITY_NONE; + xs_DeviceControl(ipc_hfa21, XS_DEVICE_CTRL_CONFIG, &config3); + xs_DeviceOpen(ipc_hfa21,XS_DEVICE_FLAG_DMA_RX); + xs_DeviceSetRxIndicate(ipc_hfa21, ipc_uart_input); + xs_kprintf("ipc_hfa21 init success!\r\n"); + TaskDescriptorPointer thread_ipc_plc = xs_KTaskCreate("ipc_hfa21", ipc_plc_thread, NULL, 1024, 25); + + if(thread_ipc_plc != NULL) + { + xs_StartupKTask(thread_ipc_plc); + } + else + { + return XS_ERROR; + } + + xs_kprintf("start to receive data...\n"); + + while(1) + { + xs_MdelayKTask(100); + xs_KSemaphoreObtain(Rx_Sem, XS_WAITING_FOREVER); + xs_kprintf("\n"); + } + + return XS_EOK; +} +MSH_CMD_EXPORT(BRL_IPC, IPC server); + +/*********************************************************************************************/ +// IP 192.168.250.150 port 9898 tcp + +//金凤工控机的测试代码，数据帧头FF，帧尾EF +xs_device_t jf_ipc_hfa21; +static sem_t jf_input_sem = NULL; +static sem_t jf_ec200t_sem = NULL; + +static xs_err_t jf_ipc_uart_input(xs_device_t dev, xs_size_t size) +{ + xs_KSemaphoreAbandon(jf_input_sem); + return XS_EOK; +} + +static void jf_ipc_plc_thread(void* parameter) +{ + xs_err_t ret; + uint32_t rx_length, total_rx_length = 0; + uint8_t i; + unsigned int length = 0; + + while(1) + { + ret = xs_KSemaphoreObtain(jf_input_sem, XS_WAITING_FOREVER); + + if(XS_EOK == ret) + { + rx_length = xs_DeviceRead(jf_ipc_hfa21, 0, redis_data + 2 + sizeof(device_s16) + total_rx_length, 512); + xs_kprintf("dst data length %d total length %d\n", rx_length, total_rx_length); + + for(i = 0; i < rx_length; ++i) + { + xs_kprintf("0x%x ", redis_data[i + 2 + sizeof(device_s16) + total_rx_length]); + } + + xs_kprintf("\n"); + total_rx_length += rx_length; + + if(((((unsigned int)redis_data[2 + sizeof(device_s16) + 2] & 0x000000FF) << 8) | ((unsigned int)redis_data[2 + sizeof(device_s16) + 3] & 0x000000FF) == total_rx_length) && + (0xFF == redis_data[2 + sizeof(device_s16)]) && (0x20 == redis_data[2 + sizeof(device_s16) + 1])) + { + /******format redis data******/ + redis_data[0] = data_head; + redis_data[1] = PLC_JF_IPC_FLAG; + memcpy(redis_data + 2, device_s16, sizeof(device_s16)); + length = 2 + sizeof(device_s16) + total_rx_length; + /******end******/ + xs_DeviceWrite(ec200t, 0, redis_data, length); + total_rx_length = 0; + memset(redis_data, 0, sizeof(redis_data)); + xs_KSemaphoreAbandon(jf_ec200t_sem); + } + } + } +} + +int JF_IPC(void) +{ + struct SerialConfigure config3 = XS_SERIAL_CONFIG_DEFAULT; + jf_ipc_hfa21 = xs_DeviceFind("uart3"); + + if(!jf_ipc_hfa21) + { + xs_kprintf("find jf_ipc_hfa21 failed!\r\n"); + return XS_ERROR; + } + + jf_ec200t_sem = xs_KCreateSemaphore("jf_ec200t_sem",0,XS_LINKLIST_FLAG_FIFO); + + if(jf_ec200t_sem == NULL) + { + xs_kprintf("JF_IPC create jf_ec200t_sem failed .\n"); + return XS_ERROR; + } + + jf_input_sem = xs_KCreateSemaphore("jf_input_sem",0,XS_LINKLIST_FLAG_FIFO); + + if(jf_input_sem == NULL) + { + xs_kprintf("JF_IPC create jf_input_sem failed .\n"); + return XS_ERROR; + } + + //jf_ipc_hfa21 + config3.BaudRate = BAUD_RATE_460800; + config3.DataBits = DATA_BITS_8; + config3.StopBits = STOP_BITS_1; + config3.bufsz = XS_SERIAL_RB_BUFSZ; + config3.parity = PARITY_NONE; + xs_DeviceControl(jf_ipc_hfa21, XS_DEVICE_CTRL_CONFIG, &config3); + xs_DeviceOpen(jf_ipc_hfa21,XS_DEVICE_FLAG_DMA_RX); + xs_DeviceSetRxIndicate(jf_ipc_hfa21, jf_ipc_uart_input); + xs_kprintf("jf_ipc_hfa21 init success!\r\n"); + TaskDescriptorPointer thread_jf_ipc_plc = xs_KTaskCreate("jf_ipc_hfa21", jf_ipc_plc_thread, NULL, 1024, 25); + + if(thread_jf_ipc_plc != NULL) + { + xs_StartupKTask(thread_jf_ipc_plc); + } + else + { + return XS_ERROR; + } + + xs_kprintf("start to receive data...\n"); + + while(1) + { + xs_MdelayKTask(100); + xs_KSemaphoreObtain(jf_ec200t_sem, XS_WAITING_FOREVER); + xs_kprintf("JF send data to server done\n"); + } + + return XS_EOK; +} +MSH_CMD_EXPORT(JF_IPC, JF IPC client); + +/*********************************************************************************************/ +//西门子PLC IP 192.168.250.9 port 102 + +static xs_device_t siemens_hfa21; +static sem_t siemens_input_sem = NULL; +static sem_t siemens_ec200t_sem = NULL; + +static xs_err_t siemens_uart_input(xs_device_t dev, xs_size_t size) +{ + xs_KSemaphoreAbandon(siemens_input_sem); + return XS_EOK; +} + +static void siemens_plc_thread(void* parameter) +{ + xs_err_t ret; + uint32_t rx_length, total_rx_length = 0; + uint8_t i; + static char shakehand_cnt = 0; + unsigned int length = 0; + + while(1) + { + ret = xs_KSemaphoreObtain(siemens_input_sem, XS_WAITING_FOREVER); + + if(XS_EOK == ret) + { + //rx_length = xs_DeviceRead(siemens_hfa21, 0, redis_data, 234); + // xs_kprintf("siemens dst data length %d\n", rx_length); + // for(i = 0; i < rx_length; ++i) + // xs_kprintf("0x%x ", redis_data[i]); + // xs_kprintf("\n"); + if(shakehand_cnt < 2) + { + //ignore first two siemens input sem + xs_DeviceRead(siemens_hfa21, 0, redis_data + 2 + sizeof(device_s17), 87); + shakehand_cnt++; + continue; + } + + rx_length = xs_DeviceRead(siemens_hfa21, 0, redis_data + 2 + sizeof(device_s17) + total_rx_length, 87); + xs_kprintf("siemens dst data length %d total length %d\n", rx_length, total_rx_length); + + for(i = 0; i < rx_length; ++i) + { + xs_kprintf("0x%x ", redis_data[i + 2 + sizeof(device_s17) + total_rx_length]); + } + + xs_kprintf("\n"); + total_rx_length += rx_length; + + if((87 == total_rx_length) && (0x03 == redis_data[2 + sizeof(device_s17)]) + && (0x00 == redis_data[2 + sizeof(device_s17) + 1]) + && (0x00 == redis_data[2 + sizeof(device_s17) + 2]) + && (0x57 == redis_data[2 + sizeof(device_s17) + 3])) + { + /******format redis data******/ + redis_data[0] = data_head; + redis_data[1] = PLC_SIEMENS_FLAG; + memcpy(redis_data + 2, device_s17, sizeof(device_s17)); + length = 2 + sizeof(device_s17) + total_rx_length; + /******end******/ + xs_DeviceWrite(ec200t, 0, redis_data, length); + total_rx_length = 0; + memset(redis_data, 0, sizeof(redis_data)); + xs_KSemaphoreAbandon(siemens_ec200t_sem); + } + } + } +} + +int SIEMENS_TCP(void) +{ + xs_err_t result; + struct SerialConfigure config3 = XS_SERIAL_CONFIG_DEFAULT; + siemens_hfa21 = xs_DeviceFind("uart3"); + + if(!siemens_hfa21) + { + xs_kprintf("find siemens_hfa21 failed!\r\n"); + return XS_ERROR; + } + + siemens_input_sem = xs_KCreateSemaphore("siemens_input_sem", 0, XS_LINKLIST_FLAG_FIFO); + + if(siemens_input_sem == NULL) + { + xs_kprintf("siemens_hfa21 create siemens_input_sem failed.\n"); + return XS_ERROR; + } + + siemens_ec200t_sem = xs_KCreateSemaphore("siemens_ec200t_sem", 0, XS_LINKLIST_FLAG_FIFO); + + if(siemens_ec200t_sem == NULL) + { + xs_kprintf("siemens_hfa21 create siemens_ec200t_sem failed.\n"); + return XS_ERROR; + } + + //siemens_hfa21 + config3.BaudRate = BAUD_RATE_460800; + config3.DataBits = DATA_BITS_8; + config3.StopBits = STOP_BITS_1; + config3.bufsz = XS_SERIAL_RB_BUFSZ; + config3.parity = PARITY_NONE; + xs_DeviceControl(siemens_hfa21, XS_DEVICE_CTRL_CONFIG, &config3); + xs_DeviceOpen(siemens_hfa21, XS_DEVICE_FLAG_DMA_RX); + xs_DeviceSetRxIndicate(siemens_hfa21, siemens_uart_input); + TaskDescriptorPointer thread_siemens_plc = xs_KTaskCreate("siemens_hfa21", siemens_plc_thread, NULL, 1024, 25); + + if(thread_siemens_plc != NULL) + { + xs_StartupKTask(thread_siemens_plc); + } + else + { + return XS_ERROR; + } + + //step1 : send handshake_first cmd, waiting for response sem + xs_kprintf("siemens_hfa21 start send handshake_first!\r\n"); + //CH438UARTSend(6, handshake_first, sizeof(handshake_first)); + xs_DeviceWrite(siemens_hfa21, 0, handshake_first, sizeof(handshake_first)); + xs_MdelayKTask(3000); + xs_DeviceWrite(siemens_hfa21, 0, handshake_first, sizeof(handshake_first)); + xs_MdelayKTask(500); + //step2 : send handshake_second cmd, waiting for response sem + xs_kprintf("siemens_hfa21 start send handshake_second!\r\n"); + //CH438UARTSend(6, handshake_second, sizeof(handshake_second)); + xs_DeviceWrite(siemens_hfa21, 0, handshake_second, sizeof(handshake_second)); + xs_kprintf("siemens_hfa21 init success!\r\n"); + xs_MdelayKTask(500); + + while(1) + { + //CH438UARTSend(6, siemens_read_data, sizeof(siemens_read_data)); //read_data + xs_DeviceWrite(siemens_hfa21, 0, siemens_read_data, sizeof(siemens_read_data)); + xs_kprintf("siemens hfa21 write cmd\n"); + xs_KSemaphoreObtain(siemens_ec200t_sem, XS_WAITING_FOREVER); + xs_MdelayKTask(1000); + } + + return XS_EOK; +} +MSH_CMD_EXPORT(SIEMENS_TCP, Siemens TCP PLC); + +/*********************************************************************************************/ +//西门?1200 PLC IP 192.168.250.107 port 102 + +static xs_device_t siemens_1200_hfa21; +static sem_t siemens_1200_input_sem = NULL; +static sem_t siemens_1200_ec200t_sem = NULL; + +static xs_err_t siemens_1200_uart_input(xs_device_t dev, xs_size_t size) +{ + xs_KSemaphoreAbandon(siemens_1200_input_sem); + return XS_EOK; +} + +static void siemens_1200_plc_thread(void* parameter) +{ + xs_err_t ret; + uint32_t rx_length, total_rx_length = 0; + uint8_t i; + static char shakehand_cnt = 0; + unsigned int length = 0; + + while(1) + { + ret = xs_KSemaphoreObtain(siemens_1200_input_sem, XS_WAITING_FOREVER); + + if(XS_EOK == ret) + { + if(shakehand_cnt < 2) + { + //ignore first two siemens input sem + xs_DeviceRead(siemens_1200_hfa21, 0, redis_data + 2 + sizeof(device_s18), 235); + shakehand_cnt++; + continue; + } + + rx_length = xs_DeviceRead(siemens_1200_hfa21, 0, redis_data + 2 + sizeof(device_s18) + total_rx_length, 235); + xs_kprintf("siemens 1200 dst data length %d total length %d\n", rx_length, total_rx_length); + + for(i = 0; i < rx_length; ++i) + { + xs_kprintf("0x%x ", redis_data[i + 2 + sizeof(device_s18) + total_rx_length]); + } + + xs_kprintf("\n"); + total_rx_length += rx_length; + + if((235 == total_rx_length) && (0x03 == redis_data[2 + sizeof(device_s18)]) + && (0x00 == redis_data[2 + sizeof(device_s18) + 1]) + && (0x00 == redis_data[2 + sizeof(device_s18) + 2]) + && (0xEB == redis_data[2 + sizeof(device_s18) + 3])) + { + /******format redis data******/ + redis_data[0] = data_head; + redis_data[1] = PLC_SIEMENS_1200_FLAG; + memcpy(redis_data + 2, device_s18, sizeof(device_s18)); + length = 2 + sizeof(device_s18) + total_rx_length; + /******end******/ + xs_DeviceWrite(ec200t, 0, redis_data, length); + total_rx_length = 0; + memset(redis_data, 0, sizeof(redis_data)); + xs_KSemaphoreAbandon(siemens_1200_ec200t_sem); + } + } + } +} + +int SIEMENS_1200(void) +{ + xs_err_t result; + struct SerialConfigure config3 = XS_SERIAL_CONFIG_DEFAULT; + siemens_1200_hfa21 = xs_DeviceFind("uart3"); + + if(!siemens_1200_hfa21) + { + xs_kprintf("find siemens_1200_hfa21 failed!\r\n"); + return XS_ERROR; + } + + siemens_1200_input_sem = xs_KCreateSemaphore("siemens_1200_input_sem", 0, XS_LINKLIST_FLAG_FIFO); + + if(siemens_1200_input_sem == NULL) + { + xs_kprintf("siemens_1200_hfa21 create siemens_1200_input_sem failed.\n"); + return XS_ERROR; + } + + siemens_1200_ec200t_sem = xs_KCreateSemaphore("siemens_1200_ec200t_sem", 0, XS_LINKLIST_FLAG_FIFO); + + if(siemens_1200_ec200t_sem == NULL) + { + xs_kprintf("siemens_1200_hfa21 create siemens_1200_ec200t_sem failed.\n"); + return XS_ERROR; + } + + //siemens_hfa21 + config3.BaudRate = BAUD_RATE_460800; + config3.DataBits = DATA_BITS_8; + config3.StopBits = STOP_BITS_1; + config3.bufsz = XS_SERIAL_RB_BUFSZ; + config3.parity = PARITY_NONE; + xs_DeviceControl(siemens_1200_hfa21, XS_DEVICE_CTRL_CONFIG, &config3); + xs_DeviceOpen(siemens_1200_hfa21, XS_DEVICE_FLAG_DMA_RX); + xs_DeviceSetRxIndicate(siemens_1200_hfa21, siemens_1200_uart_input); + TaskDescriptorPointer thread_siemens_1200_plc = xs_KTaskCreate("siemens_1200_hfa21", siemens_1200_plc_thread, NULL, 1024, 25); + + if(thread_siemens_1200_plc != NULL) + { + xs_StartupKTask(thread_siemens_1200_plc); + } + else + { + return XS_ERROR; + } + + //step1 : send handshake_1200_first cmd, waiting for response sem + xs_kprintf("siemens_1200_hfa21 start send handshake_1200_first!\r\n"); + //CH438UARTSend(6, handshake_1200_first, sizeof(handshake_1200_first)); + xs_DeviceWrite(siemens_1200_hfa21, 0, handshake_1200_first, sizeof(handshake_1200_first)); + xs_MdelayKTask(3000); + xs_DeviceWrite(siemens_1200_hfa21, 0, handshake_1200_first, sizeof(handshake_1200_first)); + xs_MdelayKTask(500); + //step2 : send handshake_1200_second cmd, waiting for response sem + xs_kprintf("siemens_1200_hfa21 start send handshake_1200_second!\r\n"); + //CH438UARTSend(6, handshake_1200_second, sizeof(handshake_1200_second)); + xs_DeviceWrite(siemens_1200_hfa21, 0, handshake_1200_second, sizeof(handshake_1200_second)); + xs_kprintf("siemens_1200_hfa21 init success!\r\n"); + xs_MdelayKTask(500); + + while(1) + { + //CH438UARTSend(6, siemens_1200_read_data, sizeof(siemens_1200_read_data)); //read_data + xs_DeviceWrite(siemens_1200_hfa21, 0, siemens_1200_read_data, sizeof(siemens_1200_read_data)); + xs_kprintf("siemens 1200 hfa21 write cmd\n"); + xs_KSemaphoreObtain(siemens_1200_ec200t_sem, XS_WAITING_FOREVER); + xs_MdelayKTask(1000); + } + + return XS_EOK; +} +MSH_CMD_EXPORT(SIEMENS_1200, Siemens 1200 PLC); +#endif + +/*********************************************************************************************/ +//贝加莱PLC IP 192.168.250.4 port 12000 +static unsigned char brl_redis_data[2048]; +static xs_device_t brl_plc_hfa21; +static sem_t brl_plc_input_sem = NULL; +static sem_t brl_plc_ec200t_sem = NULL; + +static xs_err_t brl_plc_uart_input(xs_device_t dev, xs_size_t size) +{ + xs_KSemaphoreAbandon(brl_plc_input_sem); + return XS_EOK; +} + +static void brl_plc_thread(void* parameter) +{ + xs_err_t ret; + uint32_t rx_length, total_rx_length = 0; + uint8_t i; + unsigned int length = 0; + + while(1) + { + ret = xs_KSemaphoreObtain(brl_plc_input_sem, XS_WAITING_FOREVER); + + if(XS_EOK == ret) + { + xs_kprintf("before total %d\n", total_rx_length); + rx_length = xs_DeviceRead(brl_plc_hfa21, 0, brl_redis_data + 2 + total_rx_length, 1640); + xs_kprintf("brl dst data length %d total length %d\n", rx_length, total_rx_length); + + for(i = 0; i < rx_length / 10; i ++) + { + xs_kprintf("0x%x ", brl_redis_data[i + 2 + total_rx_length]); + } + + xs_kprintf("\n"); + total_rx_length += rx_length; + + if(total_rx_length > 1640) + { + xs_kprintf("ERROR : rx_buffer is full total_rx_length %d\n", total_rx_length); + total_rx_length = 0; + memset(brl_redis_data, 0, sizeof(brl_redis_data)); + xs_KSemaphoreAbandon(brl_plc_ec200t_sem); + continue; + } + + if((1640 == total_rx_length) && (0x53 == brl_redis_data[2])) + { + /******format redis data******/ + brl_redis_data[0] = data_head; + brl_redis_data[1] = PLC_BRL_FLAG; + length = 2 + total_rx_length; + + /******end******/ + for(i = 0; i < 10; i ++) + { + xs_kprintf("0x%x ", brl_redis_data[i + 1478]); + } + + xs_kprintf("\n"); + xs_DeviceWrite(ec200t, 0, brl_redis_data, length); + total_rx_length = 0; + memset(brl_redis_data, 0, sizeof(brl_redis_data)); + xs_KSemaphoreAbandon(brl_plc_ec200t_sem); + } + } + } +} + +int BRL_PLC(void) +{ + xs_err_t result; + const unsigned char brl_reply_data[] = {0x1, 0x1, 0x1}; + struct SerialConfigure config3 = XS_SERIAL_CONFIG_DEFAULT; + brl_plc_hfa21 = xs_DeviceFind("uart3"); + + if(!brl_plc_hfa21) + { + xs_kprintf("find brl_plc_hfa21 failed!\r\n"); + return XS_ERROR; + } + + brl_plc_input_sem = xs_KCreateSemaphore("brl_plc_input_sem", 0, XS_LINKLIST_FLAG_FIFO); + + if(brl_plc_input_sem == NULL) + { + xs_kprintf("brl_plc_hfa21 create brl_plc_input_sem failed.\n"); + return XS_ERROR; + } + + brl_plc_ec200t_sem = xs_KCreateSemaphore("brl_plc_ec200t_sem", 0, XS_LINKLIST_FLAG_FIFO); + + if(brl_plc_ec200t_sem == NULL) + { + xs_kprintf("brl_plc_hfa21 create brl_plc_ec200t_sem failed.\n"); + return XS_ERROR; + } + + //brl_hfa21 + config3.BaudRate = BAUD_RATE_460800; + config3.DataBits = DATA_BITS_8; + config3.StopBits = STOP_BITS_1; + config3.bufsz = 2048; + config3.parity = PARITY_NONE; + xs_DeviceControl(brl_plc_hfa21, XS_DEVICE_CTRL_CONFIG, &config3); + xs_DeviceOpen(brl_plc_hfa21, XS_DEVICE_FLAG_DMA_RX); + xs_DeviceSetRxIndicate(brl_plc_hfa21, brl_plc_uart_input); + TaskDescriptorPointer thread_brl_plc = xs_KTaskCreate("brl_plc_hfa21", brl_plc_thread, NULL, 1024, 25); + + if(thread_brl_plc != NULL) + { + xs_StartupKTask(thread_brl_plc); + } + else + { + return XS_ERROR; + } + + xs_kprintf("brl_plc_hfa21 init success!\r\n"); + xs_MdelayKTask(500); + + while(1) + { + //CH438UARTSend(6, brl_reply_data, sizeof(brl_reply_data)); + xs_kprintf("brl_plc hfa21 write cmd\n"); //read_data + xs_DeviceWrite(brl_plc_hfa21, 0, brl_reply_data, sizeof(brl_reply_data)); + xs_KSemaphoreObtain(brl_plc_ec200t_sem, XS_WAITING_FOREVER); + } + + return XS_EOK; +} + +MSH_CMD_EXPORT(BRL_PLC, Brl PLC); + diff --git a/APP_Framework/Framework/control/plc/interoperability/socket/plc_socket.c b/APP_Framework/Framework/control/plc/interoperability/socket/plc_socket.c new file mode 100755 index 000000000..e61202f05 --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/socket/plc_socket.c @@ -0,0 +1,322 @@ +/* + * Copyright (c) 2022 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file plc_socket.c + * @brief Demo for PLC socket communication function + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2022.03.16 + */ + +#include "transform.h" +#include "plc_socket.h" +#include "sys_arch.h" +#include "lwip/sockets.h" + +#define PLC_SOCK_CMD_NUM 10 + +// for saving PLC command +int plc_cmd_index = 0; + +//siemens test +PlcBinCmdType TestPlcCmd[PLC_SOCK_CMD_NUM] = +{ +#ifdef SUPPORT_PLC_SIEMENS + // handshake1 repeat 1 + { + 0, 3000, 22, + { + 0x03, 0x00, 0x00, 0x16, 0x11, 0xE0, 0x00, 0x00, + 0x02, 0xC8, 0x00, 0xC1, 0x02, 0x02, 0x01, 0xC2, + 0x02, 0x02, 0x01, 0xC0, 0x01, 0x0A + } + }, + // handshake2 + { + 1, 500, 25, + { + 0x03, 0x00, 0x00, 0x19, 0x02, 0xF0, 0x80, 0x32, + 0x01, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x08, 0x00, + 0x00, 0xF0, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0xF0 + } + }, + // read command + { + 2, 1000, 31, + { + 0x03, 0x00, 0x00, 0x1F, 0x02, 0xF0, 0x80, 0x32, + 0x01, 0x00, 0x00, 0x33, 0x01, 0x00, 0x0E, 0x00, + 0x00, 0x04, 0x01, 0x12, 0x0A, 0x10, 0x02, 0x00, + 0xD2, 0x00, 0x34, 0x84, 0x00, 0x00, 0x00 + } + } + // oml plc +#else// SUPPORT_PLC_OML + { + 0, 1000, 18, + { + 0x80, 0x00, 0x02, 0x00, 0x03, 0x00, 0x00, 0x7E, + 0x00, 0x00, 0x01, 0x01, 0x82, 0x0F, 0xA0, 0x00, + 0x00, 0x20 + } + } +#endif +}; + +//SIEMENS PLC IP: 192.168.250.9 Port: 102 +//S7-200 192.168.250.8 +//S7-1200 192.168.250.6 +//OML 192.168.250.3 port 9600 +PlcSocketParamType plc_socket_demo_data = { + .ip = {192, 168, 250, 3}, + .port = 9600, + .device_type = PLC_DEV_TYPE_OML, + .socket_type = SOCK_STREAM, //SOCK_DGRAM, //udp + .step = 0, + .cmd_num = 3, + .buf_size = PLC_TEST_SIZE, + .buf = NULL, +}; + +#define OML_HEADER_LEN 78 +#define CHECK_OML_HEADER(_s) ((0xC0 == *(_s)) && (0x00 == *(_s + 1)) && (0x02 == *(_s + 2)) && (0x00 == *(_s + 3))) + +/******************************************************************************/ + +static void *PlcSocketStart(void *arg) +{ + int fd = -1; + int recv_len; + int step = 0; + char *recv_buf; + struct sockaddr_in sock_addr; + socklen_t addr_len = sizeof(struct sockaddr_in); + PlcSocketParamType *param = (PlcSocketParamType *)&plc_socket_demo_data; + + plc_print("start %d.%d.%d.%d:%d dev %d sock %d\n", + param->ip[0], + param->ip[1], + param->ip[2], + param->ip[3], + param->port, + param->device_type, + param->socket_type); + + //malloc memory + recv_buf = (char *)malloc(param->buf_size); + if (recv_buf == NULL) + { + plc_error("No memory\n"); + return NULL; + } + + fd = socket(AF_INET, param->socket_type, 0); + if (fd < 0) + { + plc_error("Socket error %d\n", param->socket_type); + free(recv_buf); + return NULL; + } + + plc_print("start %d.%d.%d.%d:%d\n", param->ip[0], param->ip[1], param->ip[2], param->ip[3], param->port); + + sock_addr.sin_family = AF_INET; + sock_addr.sin_port = htons(param->port); + sock_addr.sin_addr.s_addr = PP_HTONL(LWIP_MAKEU32(param->ip[0], param->ip[1], param->ip[2], param->ip[3])); + memset(&(sock_addr.sin_zero), 0, sizeof(sock_addr.sin_zero)); + + if (connect(fd, (struct sockaddr *)&sock_addr, sizeof(struct sockaddr)) < 0) + { + plc_error("Unable to connect\n"); + closesocket(fd); + free(recv_buf); + return NULL; + } + + lw_notice("client %s connected\n", inet_ntoa(sock_addr.sin_addr)); + + while(step < param->cmd_num) + { + sendto(fd, TestPlcCmd[step].cmd, TestPlcCmd[step].cmd_len, 0, (struct sockaddr*)&sock_addr, addr_len); + lw_notice("Send Cmd: %d - ", TestPlcCmd[step].cmd_len); + for(int i = 0; i < TestPlcCmd[step].cmd_len; i++) + { + lw_notice(" %#x", TestPlcCmd[step].cmd[i]); + } + lw_notice("\n"); + MdelayKTask(TestPlcCmd[step].delay_ms); + + memset(recv_buf, 0, param->buf_size); + while(1) + { + recv_len = recvfrom(fd, recv_buf, param->buf_size, 0, (struct sockaddr *)&sock_addr, &addr_len); + if(recv_len > 0) + { + if(param->device_type == PLC_DEV_TYPE_OML) + { + if((recv_len == OML_HEADER_LEN) && (CHECK_OML_HEADER(recv_buf))) + { + lw_notice("This is Oml package!!!\n"); + } + } + lw_notice("Receive from : %s\n", inet_ntoa(sock_addr.sin_addr)); + lw_notice("Receive data : %d -", recv_len); + for(int i = 0; i < recv_len; i++) + { + lw_notice(" %#x", recv_buf[i]); + } + lw_notice("\n"); + break; + } + } + step ++; + } + + closesocket(fd); + free(recv_buf); + return NULL; +} + +void PlcGetParamCmd(char *cmd) +{ + const char s[2] = ","; + char *token; + uint16_t cmd_index = 0; + char bin_cmd[PLC_BIN_CMD_LEN] = {0}; + token = strtok(cmd, s); + while(token != NULL) + { + sscanf(token, "%x", &bin_cmd[cmd_index]); + plc_print("%d - %s %d\n", cmd_index, token, bin_cmd[cmd_index]); + token = strtok(NULL, s); + cmd_index ++; + } + TestPlcCmd[plc_cmd_index].cmd_len = cmd_index; + memcpy(TestPlcCmd[plc_cmd_index].cmd, bin_cmd, cmd_index); + plc_print("get %d cmd len %d\n", plc_cmd_index, TestPlcCmd[plc_cmd_index].cmd_len); + plc_cmd_index ++; + plc_socket_demo_data.cmd_num = plc_cmd_index; +} + +void PlcShowUsage(void) +{ + plc_notice("------------------------------------\n"); + plc_notice("PlcSocket [ip].[ip].[ip].[ip]:[port]\n"); + plc_notice("PlcSocket support other param:\n"); + plc_notice("plc=[] 0: OML 1:SIEMENS\n"); + plc_notice("tcp=[] 0: udp 1:tcp\n"); + plc_notice("ip=[ip.ip.ip.ip]\n"); + plc_notice("port=port\n"); + plc_notice("------------------------------------\n"); +} + +void PlcCheckParam(int argc, char *argv[]) +{ + int i; + PlcSocketParamType *param = &plc_socket_demo_data; + plc_cmd_index = 0; + + for(i = 0; i < argc; i++) + { + char *str = argv[i]; + int is_tcp = 0; + char cmd_str[PLC_BIN_CMD_LEN] = {0}; + + plc_print("check %d %s\n", i, str); + + if(sscanf(str, "ip=%d.%d.%d.%d", + ¶m->ip[0], + ¶m->ip[1], + ¶m->ip[2], + ¶m->ip[3]) == 4) + { + plc_print("find ip %d %d %d %d\n", param->ip[0], param->ip[1], param->ip[2], param->ip[3]); + continue; + } + + if(sscanf(str, "port=%d", ¶m->port) == 1) + { + plc_print("find port %d\n", param->port); + continue; + } + + if(sscanf(str, "tcp=%d", &is_tcp) == 1) + { + plc_print("find tcp %d\n", is_tcp); + param->socket_type = is_tcp ? SOCK_STREAM:SOCK_DGRAM; + continue; + } + + if(sscanf(str, "plc=%d", ¶m->device_type) == 1) + { + plc_print("find device %d\n", param->device_type); + continue; + } + + if(sscanf(str, "cmd=%s", cmd_str) == 1) + { + plc_print("find cmd %s\n", cmd_str); + PlcGetParamCmd(cmd_str); + continue; + } + } + + if(argc >= 2) + { + if(sscanf(argv[1], "%d.%d.%d.%d:%d", + ¶m->ip[0], + ¶m->ip[1], + ¶m->ip[2], + ¶m->ip[3], + ¶m->port) != EOF) + { + return; + } + + if(sscanf(argv[1], "%d.%d.%d.%d", + ¶m->ip[0], + ¶m->ip[1], + ¶m->ip[2], + ¶m->ip[3]) != EOF) + { + return; + } + } + else + { + PlcShowUsage(); + } +} + + +void PlcSocketTask(int argc, char *argv[]) +{ + int result = 0; + pthread_t th_id; + + pthread_attr_t attr; + attr.schedparam.sched_priority = LWIP_DEMO_TASK_PRIO; + attr.stacksize = LWIP_TASK_STACK_SIZE; + PlcSocketParamType *param = &plc_socket_demo_data; + + PlcCheckParam(argc, argv); + + lwip_config_net(lwip_ipaddr, lwip_netmask, param->ip); + PrivTaskCreate(&th_id, &attr, PlcSocketStart, param); +} + + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(3), + PlcSocket, PlcSocketTask, Test PLC Socket); + diff --git a/APP_Framework/Framework/control/plc/interoperability/socket/plc_socket.h b/APP_Framework/Framework/control/plc/interoperability/socket/plc_socket.h new file mode 100755 index 000000000..363877083 --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/socket/plc_socket.h @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2022 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file plc_socket.h + * @brief Demo for PLC socket communication function + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2022.03.16 + */ + +#ifndef __PLC_SOCKET_H_ +#define __PLC_SOCKET_H_ + +#define PLC_BIN_CMD_LEN 512 + +typedef struct +{ + uint8_t step; + uint16_t delay_ms; + uint8_t cmd_len; + uint8_t cmd[PLC_BIN_CMD_LEN]; +}PlcBinCmdType; + +enum PlcDeviceType { + PLC_DEV_TYPE_OML = 0, + PLC_DEV_TYPE_IPC, + PLC_DEV_TYPE_BRL, + PLC_DEV_TYPE_SIEMENS, + PLC_DEV_TYPE_SIEMENS_1200, + PLC_DEV_TYPE_JF_IPC, + PLC_DEV_TYPE_HG, + /* ...... */ + PLC_DEV_TYPE_END, +}; + +#define PLC_IP_SIZE 16 +#define PLC_DEV_SIZE 32 +#define PLC_TEST_SIZE 65536 + +typedef struct PlcSocketParamStruct{ + char ip[PLC_IP_SIZE]; + uint32_t port; + uint32_t device_type; //PlcDeviceType + uint32_t socket_type; //UDP or TCP + char device[PLC_DEV_SIZE]; + uint32_t step; // communication step + uint32_t cmd_num; // command number + uint32_t buf_size; + uint8_t *buf; +}PlcSocketParamType; + +//debug command +#define plc_print //KPrintf +#define plc_error KPrintf +#define plc_notice KPrintf + +#endif diff --git a/Ubiquitous/XiZi/kernel/thread/msgqueue.c b/Ubiquitous/XiZi/kernel/thread/msgqueue.c index 3c690011a..9480afdb5 100644 --- a/Ubiquitous/XiZi/kernel/thread/msgqueue.c +++ b/Ubiquitous/XiZi/kernel/thread/msgqueue.c @@ -297,6 +297,7 @@ static x_err_t _DeleteMsgQueue(struct MsgQueue *mq) KERNEL_FREE(mq->msg_buf); lock = CriticalAreaLock(); + IdRemoveObj(&k_mq_id_manager, mq->id.id); DoubleLinkListRmNode(&(mq->link)); CriticalAreaUnLock(lock); KERNEL_FREE(mq); diff --git a/Ubiquitous/XiZi/resources/ethernet/LwIP/api/api_lib.c b/Ubiquitous/XiZi/resources/ethernet/LwIP/api/api_lib.c index a2c136f0b..e03b8b745 100644 --- a/Ubiquitous/XiZi/resources/ethernet/LwIP/api/api_lib.c +++ b/Ubiquitous/XiZi/resources/ethernet/LwIP/api/api_lib.c @@ -246,7 +246,7 @@ netconn_delete(struct netconn *conn) } else #endif /* LWIP_NETCONN_FULLDUPLEX */ { -// err = netconn_prepare_delete(conn); + err = netconn_prepare_delete(conn); } if (err == ERR_OK) { netconn_free(conn); diff --git a/Ubiquitous/XiZi/resources/ethernet/LwIP/arch/lwipopts.h b/Ubiquitous/XiZi/resources/ethernet/LwIP/arch/lwipopts.h index ff32bc38b..a8f4b5be8 100644 --- a/Ubiquitous/XiZi/resources/ethernet/LwIP/arch/lwipopts.h +++ b/Ubiquitous/XiZi/resources/ethernet/LwIP/arch/lwipopts.h @@ -74,7 +74,7 @@ a lot of data that needs to be copied, this should be set high. */ #define MEMP_NUM_TCP_PCB_LISTEN 2 /* MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP segments. */ -#define MEMP_NUM_TCP_SEG 120 +#define MEMP_NUM_TCP_SEG 20 /* MEMP_NUM_SYS_TIMEOUT: the number of simulateously active timeouts. */ #define MEMP_NUM_SYS_TIMEOUT 6 @@ -212,26 +212,19 @@ The STM32F4x7 allows computing and verifying the IP, UDP, TCP and ICMP checksums --------------------------------- */ -#define DEFAULT_RAW_RECVMBOX_SIZE 10 -#define DEFAULT_UDP_RECVMBOX_SIZE 10 -#define DEFAULT_TCP_RECVMBOX_SIZE 10 -#define DEFAULT_ACCEPTMBOX_SIZE 10 +#define DEFAULT_RAW_RECVMBOX_SIZE 8 +#define DEFAULT_UDP_RECVMBOX_SIZE 8 +#define DEFAULT_TCP_RECVMBOX_SIZE 8 +#define DEFAULT_ACCEPTMBOX_SIZE 8 #define DEFAULT_THREAD_PRIO 20 #define DEFAULT_THREAD_STACKSIZE 1024 #define TCPIP_THREAD_NAME "tcp" #define TCPIP_THREAD_STACKSIZE 8192 -#define TCPIP_MBOX_SIZE 10 +#define TCPIP_MBOX_SIZE 8 #define TCPIP_THREAD_PRIO 15 -//#define IPERF_SERVER_THREAD_NAME "iperf_server" -//#define IPERF_SERVER_THREAD_STACKSIZE 1024 -//#define IPERF_SERVER_THREAD_PRIO 0 - -//#define BLOCK_TIME 250 -//#define BLOCK_TIME_WAITING_FOR_INPUT ( ( portTickType ) 100 ) - /* ---------------------------------------- ---------- Lwip Debug options ---------- @@ -259,7 +252,8 @@ typedef unsigned int nfds_t; #define lw_print //KPrintf #define lw_trace() //KPrintf("lw: [%s][%d] passed!\n", __func__, __LINE__) #define lw_error() //KPrintf("lw: [%s][%d] failed!\n", __func__, __LINE__) -#define lw_pr_info KPrintf +#define lw_debug KPrintf +#define lw_notice KPrintf #endif /* __LWIPOPTS_H__ */ /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Ubiquitous/XiZi/resources/ethernet/LwIP/arch/sys_arch.c b/Ubiquitous/XiZi/resources/ethernet/LwIP/arch/sys_arch.c index ad8b13af3..5088c7f37 100644 --- a/Ubiquitous/XiZi/resources/ethernet/LwIP/arch/sys_arch.c +++ b/Ubiquitous/XiZi/resources/ethernet/LwIP/arch/sys_arch.c @@ -513,16 +513,16 @@ void lwip_config_net(char *ip, char *mask, char *gw) if(chk_lwip_bit(LWIP_PRINT_FLAG)) { - lw_pr_info("\r\n************************************************\r\n"); - lw_pr_info(" Network Configuration\r\n"); - lw_pr_info("************************************************\r\n"); - lw_pr_info(" IPv4 Address : %u.%u.%u.%u\r\n", ((u8_t *)&net_ipaddr)[0], ((u8_t *)&net_ipaddr)[1], + lw_notice("\r\n************************************************\r\n"); + lw_notice(" Network Configuration\r\n"); + lw_notice("************************************************\r\n"); + lw_notice(" IPv4 Address : %u.%u.%u.%u\r\n", ((u8_t *)&net_ipaddr)[0], ((u8_t *)&net_ipaddr)[1], ((u8_t *)&net_ipaddr)[2], ((u8_t *)&net_ipaddr)[3]); - lw_pr_info(" IPv4 Subnet mask : %u.%u.%u.%u\r\n", ((u8_t *)&net_netmask)[0], ((u8_t *)&net_netmask)[1], + lw_notice(" IPv4 Subnet mask : %u.%u.%u.%u\r\n", ((u8_t *)&net_netmask)[0], ((u8_t *)&net_netmask)[1], ((u8_t *)&net_netmask)[2], ((u8_t *)&net_netmask)[3]); - lw_pr_info(" IPv4 Gateway : %u.%u.%u.%u\r\n", ((u8_t *)&net_gw)[0], ((u8_t *)&net_gw)[1], + lw_notice(" IPv4 Gateway : %u.%u.%u.%u\r\n", ((u8_t *)&net_gw)[0], ((u8_t *)&net_gw)[1], ((u8_t *)&net_gw)[2], ((u8_t *)&net_gw)[3]); - lw_pr_info("************************************************\r\n"); + lw_notice("************************************************\r\n"); } lwip_config_input(&gnetif); } diff --git a/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_config_demo.c b/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_config_demo.c index 87e79fd8e..a9e662c09 100755 --- a/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_config_demo.c +++ b/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_config_demo.c @@ -81,18 +81,18 @@ void LwipShowIPTask(int argc, char *argv[]) { char mac_addr[] = configMAC_ADDR; - lw_pr_info("\r\n************************************************\r\n"); - lw_pr_info(" Network Configuration\r\n"); - lw_pr_info("************************************************\r\n"); - lw_pr_info(" IPv4 Address : %u.%u.%u.%u\r\n", ((u8_t *)&lwip_ipaddr)[0], ((u8_t *)&lwip_ipaddr)[1], + lw_notice("\r\n************************************************\r\n"); + lw_notice(" Network Configuration\r\n"); + lw_notice("************************************************\r\n"); + lw_notice(" IPv4 Address : %u.%u.%u.%u\r\n", ((u8_t *)&lwip_ipaddr)[0], ((u8_t *)&lwip_ipaddr)[1], ((u8_t *)&lwip_ipaddr)[2], ((u8_t *)&lwip_ipaddr)[3]); - lw_pr_info(" IPv4 Subnet mask : %u.%u.%u.%u\r\n", ((u8_t *)&lwip_netmask)[0], ((u8_t *)&lwip_netmask)[1], + lw_notice(" IPv4 Subnet mask : %u.%u.%u.%u\r\n", ((u8_t *)&lwip_netmask)[0], ((u8_t *)&lwip_netmask)[1], ((u8_t *)&lwip_netmask)[2], ((u8_t *)&lwip_netmask)[3]); - lw_pr_info(" IPv4 Gateway : %u.%u.%u.%u\r\n", ((u8_t *)&lwip_gwaddr)[0], ((u8_t *)&lwip_gwaddr)[1], + lw_notice(" IPv4 Gateway : %u.%u.%u.%u\r\n", ((u8_t *)&lwip_gwaddr)[0], ((u8_t *)&lwip_gwaddr)[1], ((u8_t *)&lwip_gwaddr)[2], ((u8_t *)&lwip_gwaddr)[3]); - lw_pr_info(" MAC Address : %x:%x:%x:%x:%x:%x\r\n", mac_addr[0], mac_addr[1], mac_addr[2], + lw_notice(" MAC Address : %x:%x:%x:%x:%x:%x\r\n", mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]); - lw_pr_info("************************************************\r\n"); + lw_notice("************************************************\r\n"); } SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(0), diff --git a/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_dhcp_demo.c b/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_dhcp_demo.c index cfeff2499..87443523e 100755 --- a/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_dhcp_demo.c +++ b/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_dhcp_demo.c @@ -61,54 +61,54 @@ int LwipPrintDHCP(struct netif *netif) { dhcp_last_state = dhcp->state; - lw_pr_info(" DHCP state : "); + lw_notice(" DHCP state : "); switch (dhcp_last_state) { case DHCP_STATE_OFF: - lw_pr_info("OFF"); + lw_notice("OFF"); break; case DHCP_STATE_REQUESTING: - lw_pr_info("REQUESTING"); + lw_notice("REQUESTING"); break; case DHCP_STATE_INIT: - lw_pr_info("INIT"); + lw_notice("INIT"); break; case DHCP_STATE_REBOOTING: - lw_pr_info("REBOOTING"); + lw_notice("REBOOTING"); break; case DHCP_STATE_REBINDING: - lw_pr_info("REBINDING"); + lw_notice("REBINDING"); break; case DHCP_STATE_RENEWING: - lw_pr_info("RENEWING"); + lw_notice("RENEWING"); break; case DHCP_STATE_SELECTING: - lw_pr_info("SELECTING"); + lw_notice("SELECTING"); break; case DHCP_STATE_INFORMING: - lw_pr_info("INFORMING"); + lw_notice("INFORMING"); break; case DHCP_STATE_CHECKING: - lw_pr_info("CHECKING"); + lw_notice("CHECKING"); break; case DHCP_STATE_BOUND: - lw_pr_info("BOUND"); + lw_notice("BOUND"); break; case DHCP_STATE_BACKING_OFF: - lw_pr_info("BACKING_OFF"); + lw_notice("BACKING_OFF"); break; default: - lw_pr_info("%u", dhcp_last_state); + lw_notice("%u", dhcp_last_state); assert(0); break; } - lw_pr_info("\r\n"); + lw_notice("\r\n"); if (dhcp_last_state == DHCP_STATE_BOUND) { - lw_pr_info("\r\n IPv4 Address : %s\r\n", ipaddr_ntoa(&netif->ip_addr)); - lw_pr_info(" IPv4 Subnet mask : %s\r\n", ipaddr_ntoa(&netif->netmask)); - lw_pr_info(" IPv4 Gateway : %s\r\n\r\n", ipaddr_ntoa(&netif->gw)); + lw_notice("\r\n IPv4 Address : %s\r\n", ipaddr_ntoa(&netif->ip_addr)); + lw_notice(" IPv4 Subnet mask : %s\r\n", ipaddr_ntoa(&netif->netmask)); + lw_notice(" IPv4 Gateway : %s\r\n\r\n", ipaddr_ntoa(&netif->gw)); return 1; } } diff --git a/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_ping_demo.c b/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_ping_demo.c index f99e8b380..4eb01d0ba 100755 --- a/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_ping_demo.c +++ b/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_ping_demo.c @@ -60,7 +60,7 @@ void LwipPingTest(int argc, char *argv[]) { if(sscanf(argv[1], "%d.%d.%d.%d", &lwip_gwaddr[0], &lwip_gwaddr[1], &lwip_gwaddr[2], &lwip_gwaddr[3]) == EOF) { - lw_pr_info("input wrong ip\n"); + lw_notice("input wrong ip\n"); return; } } diff --git a/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_tcp_demo.c b/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_tcp_demo.c index 98bf62cb5..387899abc 100755 --- a/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_tcp_demo.c +++ b/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_tcp_demo.c @@ -27,52 +27,61 @@ #define MSG_SIZE 128 +typedef struct LwipTcpSocketStruct +{ + char ip[6]; + uint16_t port; + char *buf; // test buffer +}LwipTcpSocketParamType; + // this is for test in shell, in fact, shell restrict the length of input string, which is less then 128 char tcp_send_msg[MSG_SIZE] = {0}; char tcp_target[] = {192, 168, 250, 252}; +uint16_t tcp_port = LWIP_TARGET_PORT; /******************************************************************************/ static void LwipTcpSendTask(void *arg) { - lw_print("LwipTcpSendTask start.\n"); + lw_notice("LwipTcpSendTask start.\n"); int fd = -1; fd = socket(AF_INET, SOCK_STREAM, 0); if (fd < 0) { - lw_print("Socket error\n"); + lw_notice("Socket error\n"); return; } + LwipTcpSocketParamType *param = (LwipTcpSocketParamType *)arg; + struct sockaddr_in tcp_sock; tcp_sock.sin_family = AF_INET; - tcp_sock.sin_port = htons(LWIP_TARGET_PORT); - tcp_sock.sin_addr.s_addr = PP_HTONL(LWIP_MAKEU32(tcp_target[0], tcp_target[1], tcp_target[2], tcp_target[3])); + tcp_sock.sin_port = htons(param->port); + tcp_sock.sin_addr.s_addr = PP_HTONL(LWIP_MAKEU32(param->ip[0], param->ip[1], param->ip[2], param->ip[3])); memset(&(tcp_sock.sin_zero), 0, sizeof(tcp_sock.sin_zero)); if (connect(fd, (struct sockaddr *)&tcp_sock, sizeof(struct sockaddr))) { - lw_print("Unable to connect\n"); - goto __exit; + lw_notice("Unable to connect\n"); + closesocket(fd); + return; } - lw_print("tcp connect success, start to send.\n"); - lw_print("\n\nTarget Port:%d\n\n", tcp_sock.sin_port); + lw_notice("tcp connect success, start to send.\n"); + lw_notice("\n\nTarget Port:%d\n\n", tcp_sock.sin_port); sendto(fd, tcp_send_msg, strlen(tcp_send_msg), 0, (struct sockaddr*)&tcp_sock, sizeof(struct sockaddr)); - lw_print("Send tcp msg: %s ", tcp_send_msg); - -__exit: - if (fd >= 0) - closesocket(fd); + lw_notice("Send tcp msg: %s ", tcp_send_msg); + closesocket(fd); return; } void LwipTcpSendTest(int argc, char *argv[]) { + LwipTcpSocketParamType param; memset(tcp_send_msg, 0, MSG_SIZE); if(argc >= 2) { @@ -86,11 +95,20 @@ void LwipTcpSendTest(int argc, char *argv[]) if(argc >= 3) { - sscanf(argv[2], "%d.%d.%d.%d", &tcp_target[0], &tcp_target[1], &tcp_target[2], &tcp_target[3]); + if(sscanf(argv[2], "%d.%d.%d.%d:%d", &tcp_target[0], &tcp_target[1], &tcp_target[2], &tcp_target[3], &tcp_port) == EOK) + { + sscanf(argv[2], "%d.%d.%d.%d", &tcp_target[0], &tcp_target[1], &tcp_target[2], &tcp_target[3]); + } } + lw_notice("get ipaddr %d.%d.%d.%d:%d\n", tcp_target[0], tcp_target[1], tcp_target[2], tcp_target[3], tcp_port); + lwip_config_tcp(lwip_ipaddr, lwip_netmask, tcp_target); - lwip_config_tcp(lwip_ipaddr, lwip_netmask, lwip_gwaddr); - sys_thread_new("tcp send", LwipTcpSendTask, NULL, LWIP_TASK_STACK_SIZE, LWIP_DEMO_TASK_PRIO); + memcpy(param.ip, tcp_target, 4); + param.port = tcp_port; + param.buf = malloc(MSG_SIZE); + memcpy(param.buf, tcp_send_msg, MSG_SIZE); + + sys_thread_new("tcp send", LwipTcpSendTask, ¶m, LWIP_TASK_STACK_SIZE, LWIP_DEMO_TASK_PRIO); } SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(3), diff --git a/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_udp_demo.c b/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_udp_demo.c index 9f459031a..97d06b119 100755 --- a/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_udp_demo.c +++ b/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/lwip_udp_demo.c @@ -30,7 +30,8 @@ #define PBUF_SIZE 27 static struct udp_pcb *udpecho_raw_pcb; -char udp_target[] = {192, 168, 250, 252}; +char udp_demo_ip[] = {192, 168, 250, 252}; +uint16_t udp_demo_port = LWIP_TARGET_PORT; char hello_str[] = {"hello world\r\n"}; char udp_send_msg[] = "\n\nThis one is UDP pkg. Congratulations on you.\n\n"; @@ -52,28 +53,23 @@ static void LwipUDPSendTask(void *arg) struct sockaddr_in udp_sock; udp_sock.sin_family = AF_INET; - udp_sock.sin_port = htons(LWIP_TARGET_PORT); - udp_sock.sin_addr.s_addr = PP_HTONL(LWIP_MAKEU32(udp_target[0],udp_target[1],udp_target[2],udp_target[3])); + udp_sock.sin_port = htons(udp_demo_port); + udp_sock.sin_addr.s_addr = PP_HTONL(LWIP_MAKEU32(udp_demo_ip[0], udp_demo_ip[1], udp_demo_ip[2], udp_demo_ip[3])); memset(&(udp_sock.sin_zero), 0, sizeof(udp_sock.sin_zero)); if (connect(socket_fd, (struct sockaddr *)&udp_sock, sizeof(struct sockaddr))) { lw_print("Unable to connect\n"); - goto __exit; + closesocket(socket_fd); + return; } lw_print("UDP connect success, start to send.\n"); lw_print("\n\nTarget Port:%d\n\n", udp_sock.sin_port); sendto(socket_fd, udp_send_msg, strlen(udp_send_msg), 0, (struct sockaddr*)&udp_sock, sizeof(struct sockaddr)); - lw_pr_info("Send UDP msg: %s ", udp_send_msg); - -__exit: - if (socket_fd >= 0) - { - closesocket(socket_fd); - } - + lw_notice("Send UDP msg: %s ", udp_send_msg); + closesocket(socket_fd); return; } @@ -86,7 +82,7 @@ void *LwipUdpSendTest(int argc, char *argv[]) if(argc == 1) { - lw_print("lw: [%s] gw %d.%d.%d.%d\n", __func__, udp_target[0], udp_target[1], udp_target[2], udp_target[3]); + lw_print("lw: [%s] gw %d.%d.%d.%d\n", __func__, udp_demo_ip[0], udp_demo_ip[1], udp_demo_ip[2], udp_demo_ip[3]); strncpy(udp_send_msg, hello_str, strlen(hello_str)); } else @@ -95,12 +91,12 @@ void *LwipUdpSendTest(int argc, char *argv[]) strncat(udp_send_msg, "\r\n", 2); if(argc == 3) { - sscanf(argv[2], "%d.%d.%d.%d", &udp_target[0], &udp_target[1], &udp_target[2], &udp_target[3]); + sscanf(argv[2], "%d.%d.%d.%d", &udp_demo_ip[0], &udp_demo_ip[1], &udp_demo_ip[2], &udp_demo_ip[3]); } } - lw_print("lw: [%s] gw %d.%d.%d.%d\n", __func__, udp_target[0], udp_target[1], udp_target[2], udp_target[3]); + lw_print("lw: [%s] gw %d.%d.%d.%d\n", __func__, udp_demo_ip[0], udp_demo_ip[1], udp_demo_ip[2], udp_demo_ip[3]); - lwip_config_tcp(lwip_ipaddr, lwip_netmask, lwip_gwaddr); + lwip_config_net(lwip_ipaddr, lwip_netmask, lwip_gwaddr); sys_thread_new("udp socket send", LwipUDPSendTask, NULL, LWIP_TASK_STACK_SIZE, LWIP_DEMO_TASK_PRIO); } @@ -121,11 +117,11 @@ static void LwipUdpRecvTask(void *arg, struct udp_pcb *upcb, struct pbuf *p, return; } udp_len = p->tot_len; - lw_pr_info("Receive data :%dB\r\n", udp_len); + lw_notice("Receive data :%dB\r\n", udp_len); if(udp_len <= 80) { - lw_pr_info("%.*s\r\n", udp_len, (char *)(p->payload)); + lw_notice("%.*s\r\n", udp_len, (char *)(p->payload)); } udp_buf = pbuf_alloc(PBUF_TRANSPORT, PBUF_SIZE, PBUF_RAM); diff --git a/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/ping.c b/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/ping.c index 1a66bd272..15c2f6c1e 100755 --- a/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/ping.c +++ b/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/ping.c @@ -492,7 +492,7 @@ int get_url_ip(char* url) /* convert URL to IP */ if (lwip_getaddrinfo(url, NULL, &hint, &res) != 0) { - lw_pr_info("ping: unknown host %s\n", url); + lw_notice("ping: unknown host %s\n", url); return -1; } memcpy(&h, &res->ai_addr, sizeof(struct sockaddr_in *)); @@ -500,13 +500,13 @@ int get_url_ip(char* url) lwip_freeaddrinfo(res); if (inet_aton(inet_ntoa(ina), &target_addr) == 0) { - lw_pr_info("ping: unknown host %s\n", url); + lw_notice("ping: unknown host %s\n", url); return -2; } /* new a socket */ if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) { - lw_pr_info("ping: create socket failed\n"); + lw_notice("ping: create socket failed\n"); return -3; } @@ -521,12 +521,12 @@ int get_url_ip(char* url) #endif /* LWIP_DEBUG */ if ((recv_len = lwip_ping_recv(s, &ttl)) >= 0) { - lw_pr_info("%d bytes from %s icmp_seq=%d ttl=%d time=%d ms\n", recv_len, inet_ntoa(ina), cnt, + lw_notice("%d bytes from %s icmp_seq=%d ttl=%d time=%d ms\n", recv_len, inet_ntoa(ina), cnt, ttl, sys_now() - ping_time); } else { - lw_pr_info("From %s icmp_seq=%d timeout\n", inet_ntoa(ina), cnt); + lw_notice("From %s icmp_seq=%d timeout\n", inet_ntoa(ina), cnt); } } diff --git a/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/tcpecho_raw.c b/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/tcpecho_raw.c index 026207891..d924f3285 100755 --- a/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/tcpecho_raw.c +++ b/Ubiquitous/XiZi/resources/ethernet/cmd_lwip/tcpecho_raw.c @@ -159,9 +159,9 @@ tcpecho_raw_ack(struct tcp_pcb *tpcb, struct tcpecho_raw_state* es){ if((recv_len != TCP_MSS) || (recv_buf[recv_len - 1] == TCP_EOF_CH)) { if(g_buf_size < MAX_TCP_SHOW_SIZE){ - lw_pr_info("Received: %s\n", g_buf); + lw_notice("Received: %s\n", g_buf); }else{ - lw_pr_info("Received a string of length %d\n", g_buf_size); + lw_notice("Received a string of length %d\n", g_buf_size); } tcpecho_raw_ack_size(tpcb, g_buf_size);