diff --git a/APP_Framework/Applications/control_app/plc_demo/Makefile b/APP_Framework/Applications/control_app/plc_demo/Makefile index 747b6d28b..2ecd7fa53 100755 --- a/APP_Framework/Applications/control_app/plc_demo/Makefile +++ b/APP_Framework/Applications/control_app/plc_demo/Makefile @@ -1,3 +1,3 @@ -SRC_DIR := advantech beckhoff br delta mitsubishi omron schneider siemens ge xinje inovance keyence +SRC_DIR := advantech beckhoff br delta mitsubishi omron schneider siemens ge xinje inovance keyence ab include $(KERNEL_ROOT)/compiler.mk diff --git a/APP_Framework/Applications/control_app/plc_demo/ab/Makefile b/APP_Framework/Applications/control_app/plc_demo/ab/Makefile new file mode 100755 index 000000000..41f97a516 --- /dev/null +++ b/APP_Framework/Applications/control_app/plc_demo/ab/Makefile @@ -0,0 +1,3 @@ +SRC_FILES := ab_l30.c + +include $(KERNEL_ROOT)/compiler.mk diff --git a/APP_Framework/Applications/control_app/plc_demo/ab/ab_l30.c b/APP_Framework/Applications/control_app/plc_demo/ab/ab_l30.c new file mode 100644 index 000000000..d9083e21f --- /dev/null +++ b/APP_Framework/Applications/control_app/plc_demo/ab/ab_l30.c @@ -0,0 +1,48 @@ +/* + * 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 ab_l30.c + * @brief PLC ABB L30 app + * @version 3.0 + * @author AIIT XUOS Lab + * @date 2022.9.27 + */ + +#include + +void Controlabl30Test(void) +{ + int i = 0; + uint16_t read_data_length = 0; + uint8_t read_data[1024] = {0}; + ControlProtocolType CIP_protocol = ControlProtocolFind(); + if (NULL == CIP_protocol) { + printf("%s get CIP protocol %p failed\n", __func__, CIP_protocol); + return; + } + + printf("%s get CIP protocol %p successfull\n", __func__, CIP_protocol); + if (CONTROL_REGISTERED == CIP_protocol->protocol_status) { + ControlProtocolOpen(CIP_protocol); + + for (;;) { + read_data_length = ControlProtocolRead(CIP_protocol, read_data, sizeof(read_data)); + printf("%s read [%d] CIP data %d using receipe file\n", __func__, i, read_data_length); + i++; + PrivTaskDelay(10000); + } + + //ControlProtocolClose(CIP_protocol); + } +} +PRIV_SHELL_CMD_FUNCTION(Controlabl30Test, Ab Plc CIP Demo, PRIV_SHELL_CMD_MAIN_ATTR); diff --git a/APP_Framework/Framework/control/plc_protocol/Kconfig b/APP_Framework/Framework/control/plc_protocol/Kconfig index 315d9600f..ba3672ac9 100755 --- a/APP_Framework/Framework/control/plc_protocol/Kconfig +++ b/APP_Framework/Framework/control/plc_protocol/Kconfig @@ -27,3 +27,11 @@ config CONTROL_PROTOCOL_S7 if CONTROL_PROTOCOL_S7 source "$APP_DIR/Framework/control/plc_protocol/s7/Kconfig" endif + +config CONTROL_PROTOCOL_CIP + bool "Using cip control protocol" + default n + select CONTROL_USING_SOCKET +if CONTROL_PROTOCOL_CIP + source "$APP_DIR/Framework/control/plc_protocol/cip/Kconfig" +endif diff --git a/APP_Framework/Framework/control/plc_protocol/Makefile b/APP_Framework/Framework/control/plc_protocol/Makefile index 66e467295..3de046143 100755 --- a/APP_Framework/Framework/control/plc_protocol/Makefile +++ b/APP_Framework/Framework/control/plc_protocol/Makefile @@ -14,4 +14,8 @@ ifeq ($(CONFIG_CONTROL_PROTOCOL_S7), y) SRC_DIR := s7 endif +ifeq ($(CONFIG_CONTROL_PROTOCOL_CIP), y) + SRC_DIR := cip +endif + include $(KERNEL_ROOT)/compiler.mk diff --git a/APP_Framework/Framework/control/plc_protocol/cip/Kconfig b/APP_Framework/Framework/control/plc_protocol/cip/Kconfig new file mode 100755 index 000000000..e69de29bb diff --git a/APP_Framework/Framework/control/plc_protocol/cip/Makefile b/APP_Framework/Framework/control/plc_protocol/cip/Makefile new file mode 100644 index 000000000..dbfeab3b3 --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/cip/Makefile @@ -0,0 +1,2 @@ +SRC_FILES := $(wildcard ./*.c) +include $(KERNEL_ROOT)/compiler.mk diff --git a/APP_Framework/Framework/control/plc_protocol/cip/ab_cip.c b/APP_Framework/Framework/control/plc_protocol/cip/ab_cip.c new file mode 100644 index 000000000..a22f61c1b --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/cip/ab_cip.c @@ -0,0 +1,394 @@ +#include "ab_cip_helper.h" +#include "ab_cip.h" +#include "ab_cip_private.h" + +// #include "socket.h" +#include "cip_socket.h" +#include +#include +#include +#include +#ifdef _WIN32 +#include +#include +#include +#pragma comment(lib, "ws2_32.lib") /* Linking with winsock library */ +#pragma warning(disable : 4996) +#else +#include +// #include +// #include +#include +#include "lwip/inet.h" +#endif + +int port = 102; +char ip_address[64] = {0}; +bool ab_cip_connect(char *ip_addr, int port, int slot, int *fd) +{ + bool ret = false; + int temp_fd = -1; + g_plc_slot = slot; + + temp_fd = socket_open_tcp_client_socket(ip_addr, port); + *fd = temp_fd; + + printf("%d %s %d\n",temp_fd,__func__,__LINE__); + + if (temp_fd >= 0) + ret = initialization_on_connect(temp_fd); + + printf("%d %s %d\n",ret,__func__,__LINE__); + + if (!ret && temp_fd > 0) + { + socket_close_tcp_socket(temp_fd); + *fd = -1; + } + return ret; +} +bool ab_cip_disconnect(int fd) +{ + socket_close_tcp_socket(fd); + return true; +} + +////////////////////////////////////////////////////////////////////////// +cip_error_code_e ab_cip_read_bool(int fd, const char *address, bool *val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + byte_array_info read_data; + memset(&read_data, 0, sizeof(read_data)); + ret = read_value(fd, address, 1, &read_data); + if (ret == CIP_ERROR_CODE_OK && read_data.length > 0) + { + *val = (bool)read_data.data[0]; + RELEASE_DATA(read_data.data); + } + return ret; +} + +cip_error_code_e ab_cip_read_short(int fd, const char *address, short *val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + byte_array_info read_data; + memset(&read_data, 0, sizeof(read_data)); + ret = read_value(fd, address, 1, &read_data); + if (ret == CIP_ERROR_CODE_OK && read_data.length >= 2) + { + *val = bytes2short(read_data.data); + } + RELEASE_DATA(read_data.data); + return ret; +} + +cip_error_code_e ab_cip_read_ushort(int fd, const char *address, ushort *val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + byte_array_info read_data; + memset(&read_data, 0, sizeof(read_data)); + ret = read_value(fd, address, 1, &read_data); + if (ret == CIP_ERROR_CODE_OK && read_data.length >= 2) + { + *val = bytes2ushort(read_data.data); + RELEASE_DATA(read_data.data); + } + return ret; +} + +cip_error_code_e ab_cip_read_int32(int fd, const char *address, int32 *val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + byte_array_info read_data; + memset(&read_data, 0, sizeof(read_data)); + ret = read_value(fd, address, 4, &read_data); + if (ret == CIP_ERROR_CODE_OK && read_data.length >= 4) + { + *val = bytes2int32(read_data.data); + RELEASE_DATA(read_data.data); + } + return ret; +} + +cip_error_code_e ab_cip_read_uint32(int fd, const char *address, uint32 *val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + byte_array_info read_data; + memset(&read_data, 0, sizeof(read_data)); + ret = read_value(fd, address, 4, &read_data); + if (ret == CIP_ERROR_CODE_OK && read_data.length >= 2) + { + *val = bytes2uint32(read_data.data); + RELEASE_DATA(read_data.data); + } + return ret; +} + +cip_error_code_e ab_cip_read_int64(int fd, const char *address, int64 *val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + byte_array_info read_data; + memset(&read_data, 0, sizeof(read_data)); + ret = read_value(fd, address, 8, &read_data); + if (ret == CIP_ERROR_CODE_OK && read_data.length >= 8) + { + *val = bytes2bigInt(read_data.data); + RELEASE_DATA(read_data.data); + } + return ret; +} + +cip_error_code_e ab_cip_read_uint64(int fd, const char *address, uint64 *val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + byte_array_info read_data; + memset(&read_data, 0, sizeof(read_data)); + ret = read_value(fd, address, 8, &read_data); + if (ret == CIP_ERROR_CODE_OK && read_data.length >= 8) + { + *val = bytes2ubigInt(read_data.data); + RELEASE_DATA(read_data.data); + } + return ret; +} + +cip_error_code_e ab_cip_read_float(int fd, const char *address, float *val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + byte_array_info read_data; + memset(&read_data, 0, sizeof(read_data)); + ret = read_value(fd, address, 1, &read_data); + if (ret == CIP_ERROR_CODE_OK && read_data.length >= 4) + { + *val = bytes2float(read_data.data); + } + RELEASE_DATA(read_data.data); + return ret; +} + +cip_error_code_e ab_cip_read_double(int fd, const char *address, double *val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + byte_array_info read_data; + memset(&read_data, 0, sizeof(read_data)); + ret = read_value(fd, address, 8, &read_data); + if (ret == CIP_ERROR_CODE_OK && read_data.length >= 8) + { + *val = bytes2double(read_data.data); + RELEASE_DATA(read_data.data); + } + return ret; +} + +cip_error_code_e ab_cip_read_string(int fd, const char *address, int *length, char **val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + if (length != NULL && *length > 0) + { + byte_array_info read_data; + memset(&read_data, 0, sizeof(read_data)); + ret = read_value(fd, address, *length, &read_data); + if (ret == CIP_ERROR_CODE_OK && read_data.length > 6) + { + *length = 0; + uint32 str_length = bytes2uint32(read_data.data + 2); + if (str_length > 0) + { + *length = str_length; + char *ret_str = (char *)malloc(str_length + 1); + memset(ret_str, 0, str_length + 1); + memcpy(ret_str, read_data.data + 6, str_length); + *val = ret_str; + } + RELEASE_DATA(read_data.data); + } + } + return ret; +} + +cip_error_code_e ab_cip_write_bool(int fd, const char *address, bool val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + if (fd > 0 && address != NULL) + { + int write_len = 2; + byte_array_info write_data; + memset(&write_data, 0, sizeof(write_data)); + write_data.data = (byte *)malloc(write_len); + write_data.length = write_len; + + if (val) + { + write_data.data[0] = 0xFF; + write_data.data[1] = 0xFF; + } + ret = write_value(fd, address, 1, 0xC1, write_data); + } + return ret; +} + +cip_error_code_e ab_cip_write_short(int fd, const char *address, short val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + if (fd > 0 && address != NULL) + { + int write_len = 2; + byte_array_info write_data; + memset(&write_data, 0, sizeof(write_data)); + write_data.data = (byte *)malloc(write_len); + write_data.length = write_len; + + short2bytes(val, write_data.data); + ret = write_value(fd, address, 1, 0xC3, write_data); + } + return ret; +} + +cip_error_code_e ab_cip_write_ushort(int fd, const char *address, ushort val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + if (fd > 0 && address != NULL) + { + int write_len = 2; + byte_array_info write_data; + memset(&write_data, 0, sizeof(write_data)); + write_data.data = (byte *)malloc(write_len); + write_data.length = write_len; + + ushort2bytes(val, write_data.data); + ret = write_value(fd, address, 1, 0xC3, write_data); + } + return ret; +} + +cip_error_code_e ab_cip_write_int32(int fd, const char *address, int32 val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + if (fd > 0 && address != NULL) + { + int write_len = 4; + byte_array_info write_data; + memset(&write_data, 0, sizeof(write_data)); + write_data.data = (byte *)malloc(write_len); + write_data.length = write_len; + + int2bytes(val, write_data.data); + ret = write_value(fd, address, 1, 0xC4, write_data); + } + return ret; +} + +cip_error_code_e ab_cip_write_uint32(int fd, const char *address, uint32 val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + if (fd > 0 && address != NULL) + { + int write_len = 4; + byte_array_info write_data; + memset(&write_data, 0, sizeof(write_data)); + write_data.data = (byte *)malloc(write_len); + write_data.length = write_len; + + uint2bytes(val, write_data.data); + ret = write_value(fd, address, 1, 0xC4, write_data); + } + return ret; +} + +cip_error_code_e ab_cip_write_int64(int fd, const char *address, int64 val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + if (fd > 0 && address != NULL) + { + int write_len = 8; + byte_array_info write_data; + memset(&write_data, 0, sizeof(write_data)); + write_data.data = (byte *)malloc(write_len); + write_data.length = write_len; + + bigInt2bytes(val, write_data.data); + ret = write_value(fd, address, 1, 0xC5, write_data); + } + return ret; +} + +cip_error_code_e ab_cip_write_uint64(int fd, const char *address, uint64 val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + if (fd > 0 && address != NULL) + { + int write_len = 8; + byte_array_info write_data; + memset(&write_data, 0, sizeof(write_data)); + write_data.data = (byte *)malloc(write_len); + write_data.length = write_len; + + ubigInt2bytes(val, write_data.data); + ret = write_value(fd, address, 1, 0xC5, write_data); + } + return ret; +} + +cip_error_code_e ab_cip_write_float(int fd, const char *address, float val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + if (fd > 0 && address != NULL) + { + int write_len = 4; + byte_array_info write_data; + memset(&write_data, 0, sizeof(write_data)); + write_data.data = (byte *)malloc(write_len); + write_data.length = write_len; + + float2bytes(val, write_data.data); + ret = write_value(fd, address, 1, 0xCA, write_data); + } + return ret; +} + +cip_error_code_e ab_cip_write_double(int fd, const char *address, double val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + if (fd > 0 && address != NULL) + { + int write_len = 8; + byte_array_info write_data; + memset(&write_data, 0, sizeof(write_data)); + write_data.data = (byte *)malloc(write_len); + write_data.length = write_len; + + double2bytes(val, write_data.data); + ret = write_value(fd, address, 1, 0xCB, write_data); + } + return ret; +} + +cip_error_code_e ab_cip_write_string(int fd, const char *address, int length, const char *val) +{ + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + if (fd > 0 && address != NULL && val != NULL) + { + byte write_len = length + 1; + byte_array_info write_data = {0}; + write_data.data = (byte *)malloc(write_len); + memset(write_data.data, 0, write_len); + memcpy(write_data.data, &write_len, 1); + memcpy(write_data.data + 1, val, length); + write_data.length = write_len; + + char temp_addr[100] = {0}; + sprintf(temp_addr, "%s", address); + ret = write_value(fd, temp_addr, 1, 0xD0, write_data); + } + return ret; +} + +byte get_plc_slot() +{ + return g_plc_slot; +} + +void set_plc_slot(byte slot) +{ + g_plc_slot = slot; +} \ No newline at end of file diff --git a/APP_Framework/Framework/control/plc_protocol/cip/ab_cip.h b/APP_Framework/Framework/control/plc_protocol/cip/ab_cip.h new file mode 100644 index 000000000..28f773b9b --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/cip/ab_cip.h @@ -0,0 +1,40 @@ +#ifndef __H_AB_CIP_H__ +#define __H_AB_CIP_H__ + +#include "typedef.h" + +///////////////////////////////////////////////////////////// + +byte get_plc_slot(); +void set_plc_slot(byte slot); + +///////////////////////////////////////////////////////////// + +bool ab_cip_connect(char *ip_addr, int port, int slot, int *fd); +bool ab_cip_disconnect(int fd); + +// read +cip_error_code_e ab_cip_read_bool(int fd, const char *address, bool *val); +cip_error_code_e ab_cip_read_short(int fd, const char *address, short *val); +cip_error_code_e ab_cip_read_ushort(int fd, const char *address, ushort *val); +cip_error_code_e ab_cip_read_int32(int fd, const char *address, int32 *val); +cip_error_code_e ab_cip_read_uint32(int fd, const char *address, uint32 *val); +cip_error_code_e ab_cip_read_int64(int fd, const char *address, int64 *val); +cip_error_code_e ab_cip_read_uint64(int fd, const char *address, uint64 *val); +cip_error_code_e ab_cip_read_float(int fd, const char *address, float *val); +cip_error_code_e ab_cip_read_double(int fd, const char *address, double *val); +cip_error_code_e ab_cip_read_string(int fd, const char *address, int *length, char **val); // need free val + +// write +cip_error_code_e ab_cip_write_bool(int fd, const char *address, bool val); +cip_error_code_e ab_cip_write_short(int fd, const char *address, short val); +cip_error_code_e ab_cip_write_ushort(int fd, const char *address, ushort val); +cip_error_code_e ab_cip_write_int32(int fd, const char *address, int32 val); +cip_error_code_e ab_cip_write_uint32(int fd, const char *address, uint32 val); +cip_error_code_e ab_cip_write_int64(int fd, const char *address, int64 val); +cip_error_code_e ab_cip_write_uint64(int fd, const char *address, uint64 val); +cip_error_code_e ab_cip_write_float(int fd, const char *address, float val); +cip_error_code_e ab_cip_write_double(int fd, const char *address, double val); +cip_error_code_e ab_cip_write_string(int fd, const char *address, int length, const char *val); + +#endif //__H_AB_CIP_H__ \ No newline at end of file diff --git a/APP_Framework/Framework/control/plc_protocol/cip/ab_cip_helper.c b/APP_Framework/Framework/control/plc_protocol/cip/ab_cip_helper.c new file mode 100644 index 000000000..af6bd3e86 --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/cip/ab_cip_helper.c @@ -0,0 +1,332 @@ +#include +#include +#include +#include "ab_cip_helper.h" +#include "cip_socket.h" + +extern uint32 g_session; +extern byte g_plc_slot; +extern byte g_registered_command[28]; + +// 从地址构造核心报文 +byte_array_info build_read_core_command(const char *address, int length) +{ + size_t addr_length = strlen(address); + size_t addr_adjust_length = addr_length; + if (addr_adjust_length % 2 == 1) + addr_adjust_length += 1; + + char *temp_address = (char *)malloc(addr_adjust_length); + memset(temp_address, 0, addr_adjust_length); + memcpy(temp_address, address, strlen(address)); + + const ushort command_len = 9 + 26 + (ushort)addr_adjust_length + 1 + 24; + byte *command = (byte *)malloc(command_len); + memset(command, 0, command_len); + + command[0] = 0x6F; // 命令 + command[2] = (byte)((command_len - 24) % 256); + command[3] = (byte)((command_len - 24) / 256); // 长度 + + char temp_session[4] = {0}; + uint2bytes(g_session, temp_session); + command[4] = temp_session[0]; + command[5] = temp_session[1]; + command[6] = temp_session[2]; + command[7] = temp_session[3]; // 会话句柄 + + command[0 + 24] = 0x00; + command[1 + 24] = 0x00; + command[2 + 24] = 0x00; + command[3 + 24] = 0x00; // 接口句柄，默认为0x00000000（CIP） + command[4 + 24] = 0x01; + command[5 + 24] = 0x0A; // 超时（0x000A） + command[6 + 24] = 0x02; + command[7 + 24] = 0x00; // 项数（0x0002） + command[8 + 24] = 0x00; + command[9 + 24] = 0x00; // 空地址项（0x0000） + command[10 + 24] = 0x00; + command[11 + 24] = 0x00; // 长度（0x0000） + command[12 + 24] = 0xB2; + command[13 + 24] = 0x00; // 未连接数据项（0x00b2） + command[14 + 24] = (byte)((command_len - 16 - 24) % 256); // 后面数据包的长度，等全部生成后在赋值 + command[15 + 24] = (byte)((command_len - 16 - 24) / 256); + command[16 + 24] = 0x52; // 服务类型（0x03请求服务列表，0x52请求标签数据） + command[17 + 24] = 0x02; // 请求路径大小 + command[18 + 24] = 0x20; + command[19 + 24] = 0x06; // 请求路径(0x0620) + command[20 + 24] = 0x24; + command[21 + 24] = 0x01; // 请求路径(0x0124) + command[22 + 24] = 0x0A; + command[23 + 24] = 0xF0; + command[24 + 24] = (byte)((6 + addr_adjust_length) % 256); // CIP指令长度 + command[25 + 24] = (byte)((6 + addr_adjust_length) / 256); + + command[0 + 24 + 26] = 0x4C; // 读取数据 + command[1 + 24 + 26] = (byte)((addr_adjust_length + 2) / 2); + command[2 + 24 + 26] = 0x91; + command[3 + 24 + 26] = (byte)addr_length; + memcpy(command + 4 + 24 + 26, temp_address, addr_adjust_length); + command[4 + 24 + 26 + addr_adjust_length] = (byte)((length) % 256); + command[5 + 24 + 26 + addr_adjust_length] = (byte)((length) / 256); + + command[6 + 24 + 26 + addr_adjust_length] = 0x01; + command[7 + 24 + 26 + addr_adjust_length] = 0x00; + command[8 + 24 + 26 + addr_adjust_length] = 0x01; + command[9 + 24 + 26 + addr_adjust_length] = g_plc_slot; + + byte_array_info ret = {0}; + ret.data = command; + ret.length = command_len; + free(temp_address); + return ret; +} + +byte_array_info build_write_core_command(const char *address, ushort typeCode, int length, byte_array_info value) +{ + int val_len = 0; + if (value.data != NULL) + val_len = value.length; + + size_t addr_length = strlen(address); + size_t addr_adjust_length = addr_length; + if (addr_adjust_length % 2 == 1) + addr_adjust_length += 1; + + char *temp_address = (char *)malloc(addr_adjust_length); + memset(temp_address, 0, addr_adjust_length); + memcpy(temp_address, address, strlen(address)); + + const ushort command_len = 8 + 26 + (ushort)addr_adjust_length + val_len + 4 + 24; + byte *command = (byte *)malloc(command_len); + memset(command, 0, command_len); + + command[0] = 0x6F; // 命令 + command[2] = (byte)((command_len - 24) % 256); + command[3] = (byte)((command_len - 24) / 256); // 长度 + + char temp_session[4] = {0}; + uint2bytes(g_session, temp_session); + command[4] = temp_session[0]; + command[5] = temp_session[1]; + command[6] = temp_session[2]; + command[7] = temp_session[3]; // 会话句柄 + + command[0 + 24] = 0x00; + command[1 + 24] = 0x00; + command[2 + 24] = 0x00; + command[3 + 24] = 0x00; // 接口句柄，默认为0x00000000（CIP） + command[4 + 24] = 0x01; + command[5 + 24] = 0x0A; // 超时（0x0001） + command[6 + 24] = 0x02; + command[7 + 24] = 0x00; // 项数（0x0002） + command[8 + 24] = 0x00; + command[9 + 24] = 0x00; + command[10 + 24] = 0x00; + command[11 + 24] = 0x00; // 空地址项（0x0000） + command[12 + 24] = 0xB2; + command[13 + 24] = 0x00; // 未连接数据项（0x00b2） + command[14 + 24] = (byte)((command_len - 16 - 24) % 256); + ; // 后面数据包的长度，等全部生成后在赋值 + command[15 + 24] = (byte)((command_len - 16 - 24) / 256); + ; + command[16 + 24] = 0x52; // 服务类型（0x03请求服务列表，0x52请求标签数据） + command[17 + 24] = 0x02; // 请求路径大小 + command[18 + 24] = 0x20; + command[19 + 24] = 0x06; // 请求路径(0x0620) + command[20 + 24] = 0x24; + command[21 + 24] = 0x01; // 请求路径(0x0124) + command[22 + 24] = 0x0A; + command[23 + 24] = 0xF0; + command[24 + 24] = (byte)((8 + val_len + addr_adjust_length) % 256); // CIP指令长度 + command[25 + 24] = (byte)((8 + val_len + addr_adjust_length) / 256); + + command[0 + 26 + 24] = 0x4D; // 写数据 + command[1 + 26 + 24] = (byte)((addr_adjust_length + 2) / 2); + command[2 + 26 + 24] = 0x91; + command[3 + 26 + 24] = (byte)addr_length; + memcpy(command + 4 + 26 + 24, temp_address, addr_adjust_length); + command[4 + 26 + 24 + addr_adjust_length] = (byte)(typeCode % 256); + command[5 + 26 + 24 + addr_adjust_length] = (byte)(typeCode) / 256; + command[6 + 26 + 24 + addr_adjust_length] = (byte)(length % 256); // TODO length ?? + command[7 + 26 + 24 + addr_adjust_length] = (byte)(length / 256); + memcpy(command + 8 + 26 + 24 + addr_adjust_length, value.data, value.length); + + command[8 + 26 + 24 + addr_adjust_length + val_len] = 0x01; + command[9 + 26 + 24 + addr_adjust_length + val_len] = 0x00; + command[10 + 26 + 24 + addr_adjust_length + val_len] = 0x01; + command[11 + 26 + 24 + addr_adjust_length + val_len] = g_plc_slot; + + if (value.data != NULL) + free(value.data); + + byte_array_info ret = {0}; + ret.data = command; + ret.length = command_len; + return ret; +} + +cip_error_code_e cip_analysis_read_byte(byte_array_info response, byte_array_info *ret) +{ + cip_error_code_e ret_code = CIP_ERROR_CODE_OK; + if (response.length == 0) + return CIP_ERROR_CODE_FAILED; + + int temp_length = 0; + int data_length = 0; + if (response.length >= 40) // index 38 is count[ushort] + { + data_length = bytes2ushort(response.data + 38); + if (data_length > 6) + { + temp_length = data_length - 6; + ret->data = (byte *)malloc(temp_length); + memset(ret->data, 0, temp_length); + memcpy(ret->data, response.data + 46, temp_length); + ret->length = temp_length; + } + } + else + { + ret_code = CIP_ERROR_CODE_UNKOWN; + } + return ret_code; +} + +cip_error_code_e cip_analysis_write_byte(byte_array_info response) +{ + cip_error_code_e ret_code = CIP_ERROR_CODE_OK; + if (response.length == 0) + return CIP_ERROR_CODE_FAILED; + + return ret_code; +} + +////////////////////////////////////////////////////////////////////////// +cip_error_code_e read_value(int fd, const char *address, int length, byte_array_info *out_bytes) +{ + cip_error_code_e ret = CIP_ERROR_CODE_UNKOWN; + byte_array_info core_cmd = build_read_core_command(address, length); + if (core_cmd.data != NULL) + { + int need_send = core_cmd.length; + int real_sends = socket_send_data(fd, core_cmd.data, need_send); + if (real_sends == need_send) + { + byte temp[BUFFER_SIZE] = {0}; + memset(temp, 0, BUFFER_SIZE); + byte_array_info response = {0}; + response.data = temp; + response.length = BUFFER_SIZE; + if (cip_read_response(fd, &response)) + ret = cip_analysis_read_byte(response, out_bytes); + // printf("%s %hu\n",__func__,response.data); + } + free(core_cmd.data); + } + return ret; +} + +cip_error_code_e write_value(int fd, const char *address, int length, ushort type_code, byte_array_info in_bytes) +{ + cip_error_code_e ret = CIP_ERROR_CODE_UNKOWN; + byte_array_info core_cmd = build_write_core_command(address, type_code, length, in_bytes); + if (core_cmd.data != NULL) + { + int need_send = core_cmd.length; + int real_sends = socket_send_data(fd, core_cmd.data, need_send); + if (real_sends == need_send) + { + byte temp[BUFFER_SIZE] = {0}; + memset(temp, 0, BUFFER_SIZE); + byte_array_info response = {0}; + response.data = temp; + response.length = BUFFER_SIZE; + + if (cip_read_response(fd, &response)) + ret = cip_analysis_write_byte(response); + } + free(core_cmd.data); + } + return ret; +} + +bool initialization_on_connect(int fd) +{ + bool is_ok = false; + g_session = 0; + + // First handshake -> send regiseter command + byte_array_info temp = {0}; + int command_len = sizeof(g_registered_command); + temp.data = (byte *)malloc(command_len); + memcpy(temp.data, g_registered_command, command_len); + temp.length = command_len; + is_ok = read_data_from_server(fd, temp, &g_session); + + // 返回成功的信号 -> Return a successful signal + return is_ok; +} + +bool cip_read_response(int fd, byte_array_info *response) +{ + bool is_ok = false; + int nread = 0; + int content_size = 0; + + if (fd < 0) + return -1; + + byte *content = NULL; + byte head[HEAD_SIZE]; + memset(head, 0, HEAD_SIZE); + int recv_size = socket_recv_data_one_loop(fd, head, HEAD_SIZE); + if (recv_size >= HEAD_SIZE) // header size + { + content_size = bytes2ushort(head + 2); + if (content_size > 0) + { + content = (byte *)malloc(content_size); + memset(content, 0, content_size); + } + recv_size = socket_recv_data(fd, content, content_size); + if (recv_size == content_size) + { + response->length = HEAD_SIZE + content_size; + response->data = (byte *)malloc(response->length); + memset(response->data, 0, response->length); + memcpy(response->data, head, HEAD_SIZE); + memcpy(response->data + HEAD_SIZE, content, content_size); + + is_ok = true; + } + + free(content); + } + return is_ok; +} + +bool read_data_from_server(int fd, byte_array_info send, int *session) +{ + bool is_ok = false; + int need_send = send.length; + int real_sends = socket_send_data(fd, send.data, need_send); + if (real_sends == need_send) + { + byte_array_info response = {0}; + is_ok = cip_read_response(fd, &response); + if (is_ok) + { + is_ok = false; + if (response.length > 8) + { + *session = bytes2uint32(response.data + 4); + is_ok = true; + } + + if (response.data != NULL) + free(response.data); + } + } + return is_ok; +} \ No newline at end of file diff --git a/APP_Framework/Framework/control/plc_protocol/cip/ab_cip_helper.h b/APP_Framework/Framework/control/plc_protocol/cip/ab_cip_helper.h new file mode 100644 index 000000000..0daa2c38e --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/cip/ab_cip_helper.h @@ -0,0 +1,32 @@ +#ifndef __H_AB_CIP_HELPER_H__ +#define __H_AB_CIP_HELPER_H__ +#include "utill.h" + +#define RELEASE_DATA(addr) \ + { \ + if (addr != NULL) \ + { \ + free(addr); \ + } \ + } +#define BUFFER_SIZE 1024 +#define HEAD_SIZE 24 + +byte_array_info build_read_core_command(const char *address, int length); +byte_array_info build_write_core_command(const char *address, ushort typeCode, int length, byte_array_info value); + +cip_error_code_e cip_analysis_read_byte(byte_array_info response, byte_array_info *ret); +cip_error_code_e cip_analysis_write_byte(byte_array_info response); + +bool read_data_from_server(int fd, byte_array_info send, int *session); +bool cip_read_response(int fd, byte_array_info *response); + +////////////////////////////////////////////////////////////////////////// +cip_error_code_e read_value(int fd, const char *address, int length, byte_array_info *out_bytes); +cip_error_code_e write_value(int fd, const char *address, int length, ushort type_code, byte_array_info in_bytes); + +////////////////////////////////////////////////////////////////////////// + +bool initialization_on_connect(int fd); + +#endif //__H_AB_CIP_HELPER_H__ \ No newline at end of file diff --git a/APP_Framework/Framework/control/plc_protocol/cip/ab_cip_private.h b/APP_Framework/Framework/control/plc_protocol/cip/ab_cip_private.h new file mode 100644 index 000000000..605cf7be2 --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/cip/ab_cip_private.h @@ -0,0 +1,27 @@ +#ifndef __H_AB_CIP_PRIVATE_H__ +#define __H_AB_CIP_PRIVATE_H__ +#include "typedef.h" + +/// +/// 注册命令 +/// +const byte g_registered_command[] = + { + 0x65, 0x00, // 注册请求 + 0x04, 0x00, // 命令数据长度(单位字节) + 0x00, 0x00, 0x00, 0x00, // 会话句柄,初始值为0x00000000 + 0x00, 0x00, 0x00, 0x00, // 状态，初始值为0x00000000（状态好） + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 请求通信一方的说明 + 0x00, 0x00, 0x00, 0x00, // 选项，默认为0x00000000 + 0x01, 0x00, // 协议版本（0x0001） + 0x00, 0x00 // 选项标记（0x0000 +}; + +/////////////////////////////////////////////////////////////////////////// + +// 会话句柄(由AB PLC生成) +uint32 g_session; + +byte g_plc_slot; + +#endif //__H_AB_CIP_PRIVATE_H__ diff --git a/APP_Framework/Framework/control/plc_protocol/cip/ab_plc_cip_net.sln b/APP_Framework/Framework/control/plc_protocol/cip/ab_plc_cip_net.sln new file mode 100644 index 000000000..9a07b19a0 --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/cip/ab_plc_cip_net.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.33027.164 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ab_plc_cip_net", "ab_plc_cip_net.vcxproj", "{181055E5-C375-4C97-84A2-90CD807A17FD}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {181055E5-C375-4C97-84A2-90CD807A17FD}.Debug|x64.ActiveCfg = Debug|x64 + {181055E5-C375-4C97-84A2-90CD807A17FD}.Debug|x64.Build.0 = Debug|x64 + {181055E5-C375-4C97-84A2-90CD807A17FD}.Debug|x86.ActiveCfg = Debug|Win32 + {181055E5-C375-4C97-84A2-90CD807A17FD}.Debug|x86.Build.0 = Debug|Win32 + {181055E5-C375-4C97-84A2-90CD807A17FD}.Release|x64.ActiveCfg = Release|x64 + {181055E5-C375-4C97-84A2-90CD807A17FD}.Release|x64.Build.0 = Release|x64 + {181055E5-C375-4C97-84A2-90CD807A17FD}.Release|x86.ActiveCfg = Release|Win32 + {181055E5-C375-4C97-84A2-90CD807A17FD}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {0313BC2F-57C8-4606-B430-4861FF084853} + EndGlobalSection +EndGlobal diff --git a/APP_Framework/Framework/control/plc_protocol/cip/ab_plc_cip_net.vcxproj b/APP_Framework/Framework/control/plc_protocol/cip/ab_plc_cip_net.vcxproj new file mode 100644 index 000000000..d35cf9a93 --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/cip/ab_plc_cip_net.vcxproj @@ -0,0 +1,177 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 15.0 + {181055E5-C375-4C97-84A2-90CD807A17FD} + Win32Proj + melsec_mc_net + 10.0 + + + + Application + true + v142 + MultiByte + + + Application + false + v141 + true + MultiByte + + + Application + true + v143 + Unicode + + + Application + false + v142 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + NotUsing + Level3 + Disabled + true + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS;_WINSOCK_SECURE_NO_WARNINGS + true + pch.h + 4966 + MultiThreadedDebug + + + Console + true + + + + + NotUsing + Level3 + Disabled + true + _DEBUG;_CONSOLE;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS;_WINSOCK_SECURE_NO_WARNINGS + true + pch.h + 4966 + + + Console + true + + + + + NotUsing + Level3 + MaxSpeed + true + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS;_WINSOCK_SECURE_NO_WARNINGS + true + pch.h + 4966 + MultiThreaded + + + Console + true + true + true + + + + + NotUsing + Level3 + MaxSpeed + true + true + true + NDEBUG;_CONSOLE;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS;_WINSOCK_SECURE_NO_WARNINGS + true + pch.h + 4966 + + + Console + true + true + true + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/APP_Framework/Framework/control/plc_protocol/cip/cip.c b/APP_Framework/Framework/control/plc_protocol/cip/cip.c new file mode 100644 index 000000000..9a23f3454 --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/cip/cip.c @@ -0,0 +1,312 @@ +/* + * 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 CIP.c + * @brief plc protocol CIP Ethernet/IP + * @version 3.0 + * @author AIIT XUOS Lab + * @date 2023-4-14 + */ +#pragma warning(disable : 4996) +#include +#include "ab_cip.h" + + +CIPReadItem CIP_read_item[1024] = {0}; + +/** + * @description: S7 Receive Plc Data Task + * @param parameter - parameter pointer + * @return + */ +void *ReceivePlcDataTask(void *parameter) +{ + struct ControlProtocol *control_protocol = (struct ControlProtocol *)parameter; + ReadPlcDataByRecipe(control_protocol->recipe); +} + +/** + * @description: S7 Protocol Open + * @param control_protocol - control protocol pointer + * @return success : 0 error + */ +int CIPOpen(struct ControlProtocol *control_protocol) +{ + ControlProtocolOpenDef(control_protocol); + return 0; +} + +/** + * @description: S7 Protocol Close + * @param control_protocol - control protocol pointer + * @return success : 0 error + */ +int CIPClose(struct ControlProtocol *control_protocol) +{ + ControlProtocolCloseDef(); + return 0; +} + +/** + * @description: S7 Protocol Read Data + * @param control_protocol - control protocol pointer + * @param buf - read data buffer pointer + * @param len - read data length + * @return success : data length error : 0 + */ +int CIPRead(struct ControlProtocol *control_protocol, void *buf, size_t len) +{ + struct CircularAreaApp *circular_area = (struct CircularAreaApp *)control_protocol->args; + return CircularAreaAppRead(circular_area, buf, len); +} + +static struct ControlDone CIP_protocol_done = +{ + ._open = CIPOpen, + ._close = CIPClose, + ._read = CIPRead, + ._write = NULL, + ._ioctl = NULL, +}; + +/** + * @description: Push Data Onto a Stack One By One + * @param datastack - data stack pointer + * @param args - data pointer + * @param length - data length + * @return + */ +void PushDataIntoStack(uint8_t *datastack,uint8_t* args,uint16_t length) +{ + static int index = 8; + for(int i =0; i < length; i ++) { + datastack[index] = args[i]; + index++; + if(index >= control_protocol->recipe->protocol_data.data_length){ + index = 8; + } + } +} + +#define GET_RESULT(ret) \ + { \ + if (ret != 0) \ + faild_count++; \ + } + +/** + * @description: Read PLC Data By Recipe + * @param p_recipe - recipe pointer + * @return success : 0 error : -1 + */ +int8_t ReadPlcDataByRecipe(struct ControlRecipe *p_recipe) +{ + static BasicSocketPlc plc_socket = {0}; + uint16_t data_length = control_protocol->recipe->protocol_data.data_length; + uint8_t *CIP_data = control_protocol->recipe->protocol_data.data; + struct CircularAreaApp *circular_area = (struct CircularAreaApp *)control_protocol->args; + memset(&plc_socket, 0, sizeof(BasicSocketPlc)); + char plc_ip_string[15] = {0}; + sprintf(plc_ip_string, "%u.%u.%u.%u", + p_recipe->socket_config.plc_ip[0], + p_recipe->socket_config.plc_ip[1], + p_recipe->socket_config.plc_ip[2], + p_recipe->socket_config.plc_ip[3]); + char *plc_ip = plc_ip_string; + plc_socket.port = control_protocol->recipe->socket_config.port; + int fd = -1; + int slot = 0; + bool ret_con = ab_cip_connect(plc_ip, plc_socket.port, 0, &fd); + cip_error_code_e ret = CIP_ERROR_CODE_FAILED; + int faild_count = 0; + char address[50] = {0}; + int i = 0; + uint8_t val[8] = {0} ; + bool all_success = false; + bool b_val = true; + short s_val = 0; + ushort us_val = 0; + int i_val = 0; + uint32 ui_val = 0; + float f_val = 0; + double d_val = 0; + while (1){ + if (ret_con || fd > 0) + { + faild_count = 0; + for (i = 0; i < p_recipe->read_item_count; i++) + { + printf("==============Test count: %d==============\n", i + 1); + strcpy(address, CIP_read_item[i].value_name); + switch (CIP_read_item[i].value_type) + { + case 1: + ////////////////////////////////////////////////////////////////////////// + // strcpy(address, CIP_read_item[i].value_name);// + // ret = ab_cip_write_bool(fd, address, val); + // printf("Write\t %s \tbool:\t %d, \tret: %d\n", address, val, ret); + // GET_RESULT(ret); + + b_val = false; + ret = ab_cip_read_bool(fd, address, &b_val); + // printf("Read\t %s \tbool:\t %d\n", address, b_val); + GET_RESULT(ret); + memcpy(val,&b_val,sizeof(b_val)); + PushDataIntoStack(CIP_data,val,1); + break; + + case 3: + ////////////////////////////////////////////////////////////////////////// + // short w_s_val = 23; + // strcpy(address, CIP_read_item[i].value_name); + // ret = ab_cip_write_short(fd, address, w_s_val); + // printf("Write\t %s \tshort:\t %d, \tret: %d\n", address, w_s_val, ret); + // GET_RESULT(ret); + + ret = ab_cip_read_short(fd, address, &s_val); + // printf("Read\t %s \tshort:\t %d\n", address, s_val); + GET_RESULT(ret); + memcpy(val,&s_val,sizeof(s_val)); + PushDataIntoStack(CIP_data,val,2); + break; + + case 4: + ////////////////////////////////////////////////////////////////////////// + // int32 w_i_val = 12345; + strcpy(address, CIP_read_item[i].value_name); + // ret = ab_cip_write_int32(fd, address, w_i_val); + // printf("Write\t %s \tint32:\t %d, \tret: %d\n", address, w_i_val, ret); + // GET_RESULT(ret); + + + ret = ab_cip_read_int32(fd, address, &i_val); + // printf("Read\t %s \tint32:\t %d\n", address, i_val); + GET_RESULT(ret); + memcpy(val,&i_val,sizeof(s_val)); + PushDataIntoStack(CIP_data,val,2); + break; + + case 6: + ////////////////////////////////////////////////////////////////////////// + // ushort w_us_val = 22; + strcpy(address, CIP_read_item[i].value_name); + // ret = ab_cip_write_ushort(fd, address, w_us_val); + // printf("Write\t %s \tushort:\t %d, \tret: %d\n", address, w_us_val, ret); + // GET_RESULT(ret); + + ret = ab_cip_read_ushort(fd, address, &us_val); + // printf("Read\t %s \tushort:\t %d\n", address, us_val); + GET_RESULT(ret); + memcpy(val,&us_val,sizeof(us_val)); + PushDataIntoStack(CIP_data,val,1); + break; + + case 7: + // ////////////////////////////////////////////////////////////////////////// + // uint32 w_ui_val = 22345; + strcpy(address, CIP_read_item[i].value_name); + // ret = ab_cip_write_uint32(fd, address, w_ui_val); + // printf("Write\t %s \tuint32:\t %d, \tret: %d\n", address, w_ui_val, ret); + // GET_RESULT(ret); + + ret = ab_cip_read_uint32(fd, address, &ui_val); + // printf("Read\t %s \tuint32:\t %d\n", address, ui_val); + GET_RESULT(ret); + memcpy(val,&ui_val,sizeof(us_val)); + PushDataIntoStack(CIP_data,val,1); + break; + + case 8: + //////////////////////////////////////////////////////////////////////// + // double w_d_val = 12345.6789; + strcpy(address, CIP_read_item[i].value_name); + // ret = ab_cip_write_double(fd, address, w_d_val); + // printf("Write\t %s \tdouble:\t %lf, \tret: %d\n", address, w_d_val, ret); + // GET_RESULT(ret); + + ret = ab_cip_read_double(fd, address, &d_val); + // printf("Read\t %s \tdouble:\t %lf\n", address, d_val); + GET_RESULT(ret); + memcpy(val,&d_val,sizeof(us_val)); + PushDataIntoStack(CIP_data,val,1); + break; + + case 9: + ////////////////////////////////////////////////////////////////////////// + // float w_f_val = 32.454f; + // strcpy(address, CIP_read_item[i].value_name); + // ret = ab_cip_write_float(fd, address, w_f_val); + // printf("Write\t %s \tfloat:\t %f, \tret: %d\n", address, w_f_val, ret); + // GET_RESULT(ret); + + ret = ab_cip_read_float(fd, address, &f_val); + // printf("Read\t %s \tfloat:\t %f\n", address, f_val); + GET_RESULT(ret); + memcpy(val,&f_val,sizeof(us_val)); + PushDataIntoStack(CIP_data,val,1); + break; + + default: + printf("value type no found!\n"); + break; + } + ControlPrintfList("CIP RECV", CIP_data, data_length); + } + printf("All Failed count: %d\n", faild_count); + if(faild_count != 0) + { + ab_cip_disconnect(fd); + system("pause"); + } + /*read all variable item data, put them into circular_area*/ + printf("%s get %d item %d length\n", __func__, i, data_length); + CircularAreaAppWrite(circular_area, CIP_data, data_length, 0); + PrivTaskDelay(100); + } + } + return ret; +} + +/** + * @description: CIP Protocol Cmd Generate + * @param p_recipe - recipe pointer + * @param protocol_format_info - protocol format info pointer + * @return success : 0 error : -1 + */ +int CIPProtocolFormatCmd(struct ControlRecipe *p_recipe, ProtocolFormatInfo *protocol_format_info) +{ + int ret = 0; + int i = protocol_format_info->read_item_index; + // CIPReadItem *CIP_read_item = (CIPReadItem *)p_recipe->read_item; + CIP_read_item[i].value_type = cJSON_GetObjectItem(protocol_format_info->read_single_item_json, "value_type")->valueint; + strncpy(CIP_read_item[i].value_name, cJSON_GetObjectItem(protocol_format_info->read_single_item_json, "value_name")->valuestring, 20); + + return ret; +} +/** + * @description: CIP Protocol Init + * @param p_recipe - recipe pointer + * @return success : 0 error : -1 + */ +int CipProtocolInit(struct ControlRecipe *p_recipe) +{ + p_recipe->read_item = PrivMalloc(sizeof(CIPReadItem) * p_recipe->read_item_count); + if (NULL == p_recipe->read_item) { + PrivFree(p_recipe->read_item); + return -1; + } + memset(p_recipe->read_item, 0, sizeof(CIPReadItem)); + p_recipe->ControlProtocolFormatCmd = CIPProtocolFormatCmd; + p_recipe->done = &CIP_protocol_done; + return 0; +} diff --git a/APP_Framework/Framework/control/plc_protocol/cip/cip_socket.c b/APP_Framework/Framework/control/plc_protocol/cip/cip_socket.c new file mode 100644 index 000000000..9b4b7d08b --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/cip/cip_socket.c @@ -0,0 +1,174 @@ +#include "cip_socket.h" +#include +#include + +#ifdef _WIN32 +#include +#include +#include +#pragma comment(lib, "ws2_32.lib") /* Linking with winsock library */ +#else +#include +#include +// #include +#include +// #include +#include "lwip/inet.h" +#include +#endif + +int socket_send_data(int fd, void *buf, int nbytes) +{ + int nleft, nwritten; + char *ptr = (char *)buf; + + if (fd < 0) + return -1; + + nleft = nbytes; + while (nleft > 0) + { + nwritten = send(fd, ptr, nleft, 0); + if (nwritten <= 0) + { + if (errno == EINTR) + continue; + else + return -1; + } + else + { + nleft -= nwritten; + ptr += nwritten; + } + } + + return (nbytes - nleft); +} + +int socket_recv_data(int fd, void *buf, int nbytes) +{ + int nleft, nread; + char *ptr = (char *)buf; + + if (fd < 0) + return -1; + + nleft = nbytes; + while (nleft > 0) + { + nread = recv(fd, ptr, nleft, 0); + if (nread == 0) + { + break; + } + else if (nread < 0) + { + if (errno == EINTR) + continue; + else + return -1; + } + else + { + nleft -= nread; + ptr += nread; + } + } + + return (nbytes - nleft); +} + +int socket_recv_data_one_loop(int fd, void *buf, int nbytes) +{ + int nleft, nread; + char *ptr = (char *)buf; + + if (fd < 0) + return -1; + + nleft = nbytes; + while (nleft > 0) + { + nread = recv(fd, ptr, nleft, 0); + if (nread == 0) + { + break; + } + else if (nread < 0) + { + if (errno == EINTR) + continue; + else + return -1; + } + else + { + nleft -= nread; + ptr += nread; + + // 目前只接收一次 + break; + } + } + + return (nbytes - nleft); +} + +int socket_open_tcp_client_socket(char *destIp, short destPort) +{ + int sockFd = 0; + struct sockaddr_in serverAddr; + int ret; + + sockFd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); //IPPROTO_TCP + + printf("%d %s %d\n",sockFd ,__func__,__LINE__); + + if (sockFd < 0) + { + return -1; +#pragma warning(disable : 4996) + } + + memset((char *)&serverAddr, 0, sizeof(serverAddr)); + serverAddr.sin_family = AF_INET; + serverAddr.sin_addr.s_addr = inet_addr(destIp); + serverAddr.sin_port = (uint16_t)htons((uint16_t)destPort); + + ret = connect(sockFd, (struct sockaddr *)&serverAddr, sizeof(serverAddr)); + if (ret != 0) + { + socket_close_tcp_socket(sockFd); + sockFd = -1; + } + +#ifdef _WIN32 + int timeout = 5000; // 5s + ret = setsockopt(sockFd, SOL_SOCKET, SO_SNDTIMEO, (const char *)&timeout, sizeof(timeout)); + ret = setsockopt(sockFd, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout)); +#else + struct timeval timeout = {5, 0}; // 3s + ret = setsockopt(sockFd, SOL_SOCKET, SO_SNDTIMEO, (const char *)&timeout, sizeof(timeout)); + ret = setsockopt(sockFd, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout)); +#endif + + return sockFd; +} + +void socket_close_tcp_socket(int sockFd) +{ + if (sockFd > 0) + { +#ifdef _WIN32 + closesocket(sockFd); +#else + close(sockFd); +#endif + } +} + +void tinet_ntoa(char *ipstr, unsigned int ip) +{ + sprintf(ipstr, "%d.%d.%d.%d", ip & 0xFF, (ip >> 8) & 0xFF, (ip >> 16) & 0xFF, ip >> 24); +} \ No newline at end of file diff --git a/APP_Framework/Framework/control/plc_protocol/cip/cip_socket.h b/APP_Framework/Framework/control/plc_protocol/cip/cip_socket.h new file mode 100644 index 000000000..9f2e70f69 --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/cip/cip_socket.h @@ -0,0 +1,12 @@ +#ifndef __SOCKET_H_ +#define __SOCKET_H_ + +#include "utill.h" + +int socket_send_data(int fd, void *ptr, int nbytes); +int socket_recv_data(int fd, void *ptr, int nbytes); +int socket_recv_data_one_loop(int fd, void *ptr, int nbytes); +int socket_open_tcp_client_socket(char *ip, short port); +void socket_close_tcp_socket(int sockFd); + +#endif //__SOCKET_H_ diff --git a/APP_Framework/Framework/control/plc_protocol/cip/typedef.h b/APP_Framework/Framework/control/plc_protocol/cip/typedef.h new file mode 100644 index 000000000..f8f72d30b --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/cip/typedef.h @@ -0,0 +1,21 @@ +#ifndef __H_TYPEDEF_H__ +#define __H_TYPEDEF_H__ + +#include +#include + +typedef unsigned char byte; +typedef unsigned short ushort; +typedef signed int int32; +typedef unsigned int uint32; +typedef long long int64; +typedef unsigned long long uint64; + +typedef enum _tag_cip_error_code +{ + CIP_ERROR_CODE_OK = 0, // 成功 + CIP_ERROR_CODE_FAILED = 1, // 错误 + CIP_ERROR_CODE_UNKOWN = 99, // 未知错误 +} cip_error_code_e; + +#endif // !__H_TYPEDEF_H__ \ No newline at end of file diff --git a/APP_Framework/Framework/control/plc_protocol/cip/utill.c b/APP_Framework/Framework/control/plc_protocol/cip/utill.c new file mode 100644 index 000000000..bce6d6367 --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/cip/utill.c @@ -0,0 +1,383 @@ +#include "utill.h" +#include +#include + +#ifdef _WIN32 +#include +#else +#include +#endif + +#define _WS2_32_WINSOCK_SWAP_LONG(l) \ + ((((l) >> 24) & 0x000000FFL) | \ + (((l) >> 8) & 0x0000FF00L) | \ + (((l) << 8) & 0x00FF0000L) | \ + (((l) << 24) & 0xFF000000L)) + +#define _WS2_32_WINSOCK_SWAP_LONGLONG(l) \ + ((((l) >> 56) & 0x00000000000000FFLL) | \ + (((l) >> 40) & 0x000000000000FF00LL) | \ + (((l) >> 24) & 0x0000000000FF0000LL) | \ + (((l) >> 8) & 0x00000000FF000000LL) | \ + (((l) << 8) & 0x000000FF00000000LL) | \ + (((l) << 24) & 0x0000FF0000000000LL) | \ + (((l) << 40) & 0x00FF000000000000LL) | \ + (((l) << 56) & 0xFF00000000000000LL)) + +void short2bytes(short i, byte *bytes) +{ + int size = 2; + memset(bytes, 0, sizeof(byte) * size); + bytes[0] = (byte)(0xff & i); + bytes[1] = (byte)((0xff00 & i) >> 8); +} + +short bytes2short(byte *bytes) +{ + short iRetVal = bytes[0] & 0xFF; + iRetVal |= (((short)bytes[1] << 8) & 0xFF00); + return iRetVal; +} + +void ushort2bytes(ushort i, byte *bytes) +{ + int size = 2; + memset(bytes, 0, sizeof(byte) * size); + bytes[0] = (byte)(0xff & i); + bytes[1] = (byte)((0xff00 & i) >> 8); +} + +ushort bytes2ushort(byte *bytes) +{ + ushort iRetVal = bytes[0] & 0xFF; + iRetVal |= (((ushort)bytes[1] << 8) & 0xFF00); + return iRetVal; +} + +void int2bytes(int32 i, byte *bytes) +{ + int size = 4; + memset(bytes, 0, sizeof(byte) * size); + bytes[0] = (byte)(0xff & i); + bytes[1] = (byte)((0xff00 & i) >> 8); + bytes[2] = (byte)((0xff0000 & i) >> 16); + bytes[3] = (byte)((0xff000000 & i) >> 24); +} + +int32 bytes2int32(byte *bytes) +{ + int32 iRetVal = bytes[0] & 0xFF; + iRetVal |= (((int32)bytes[1] << 8) & 0xFF00); + iRetVal |= (((int32)bytes[2] << 16) & 0xFF0000); + iRetVal |= (((int32)bytes[3] << 24) & 0xFF000000); + return iRetVal; +} + +void uint2bytes(uint32 i, byte *bytes) +{ + int size = 4; + memset(bytes, 0, sizeof(byte) * size); + bytes[0] = (byte)(0xff & i); + bytes[1] = (byte)((0xff00 & i) >> 8); + bytes[2] = (byte)((0xff0000 & i) >> 16); + bytes[3] = (byte)((0xff000000 & i) >> 24); +} + +uint32 bytes2uint32(byte *bytes) +{ + uint32 iRetVal = bytes[0] & 0xFF; + iRetVal |= (((uint32)bytes[1] << 8) & 0xFF00); + iRetVal |= (((uint32)bytes[2] << 16) & 0xFF0000); + iRetVal |= (((uint32)bytes[3] << 24) & 0xFF000000); + return iRetVal; +} + +void bigInt2bytes(int64 i, byte *bytes) +{ + int size = 8; + memset(bytes, 0, sizeof(byte) * size); + bytes[0] = (byte)(0xff & i); + bytes[1] = (byte)(0xff & (i >> 8)); + bytes[2] = (byte)(0xff & (i >> 16)); + bytes[3] = (byte)(0xff & (i >> 24)); + bytes[4] = (byte)(0xff & (i >> 32)); + bytes[5] = (byte)(0xff & (i >> 40)); + bytes[6] = (byte)(0xff & (i >> 48)); + bytes[7] = (byte)(0xff & (i >> 56)); +} + +int64 bytes2bigInt(byte *bytes) +{ + int64 iRetVal = bytes[0] & 0xFF; + iRetVal |= (((int64)bytes[1] << 8) & 0xFF00); + iRetVal |= (((int64)bytes[2] << 16) & 0xFF0000); + iRetVal |= (((int64)bytes[3] << 24) & 0xFF000000); + iRetVal |= (((int64)bytes[4] << 32) & 0xFF00000000); + iRetVal |= (((int64)bytes[5] << 40) & 0xFF0000000000); + iRetVal |= (((int64)bytes[6] << 48) & 0xFF000000000000); + iRetVal |= (((int64)bytes[7] << 56) & 0xFF00000000000000); + return iRetVal; +} + +void ubigInt2bytes(uint64 i, byte *bytes) +{ + int size = 8; + memset(bytes, 0, sizeof(byte) * size); + bytes[0] = (byte)(0xff & i); + bytes[1] = (byte)(0xff & (i >> 8)); + bytes[2] = (byte)(0xff & (i >> 16)); + bytes[3] = (byte)(0xff & (i >> 24)); + bytes[4] = (byte)(0xff & (i >> 32)); + bytes[5] = (byte)(0xff & (i >> 40)); + bytes[6] = (byte)(0xff & (i >> 48)); + bytes[7] = (byte)(0xff & (i >> 56)); +} + +uint64 bytes2ubigInt(byte *bytes) +{ + uint64 iRetVal = bytes[0] & 0xFF; + iRetVal |= (((uint64)bytes[1] << 8) & 0xFF00); + iRetVal |= (((uint64)bytes[2] << 16) & 0xFF0000); + iRetVal |= (((uint64)bytes[3] << 24) & 0xFF000000); + iRetVal |= (((uint64)bytes[4] << 32) & 0xFF00000000); + iRetVal |= (((uint64)bytes[5] << 40) & 0xFF0000000000); + iRetVal |= (((uint64)bytes[6] << 48) & 0xFF000000000000); + iRetVal |= (((uint64)bytes[7] << 56) & 0xFF00000000000000); + return iRetVal; +} + +void float2bytes(float i, byte *bytes) +{ + int size = 4; + int temp = *(int *)&i; + int2bytes(temp, bytes); +} + +float bytes2float(byte *bytes) +{ + int temp = bytes2int32(bytes); + return *(float *)&temp; +} + +void double2bytes(double i, byte *bytes) +{ + int64 temp = *(int64 *)&i; + bigInt2bytes(temp, bytes); +} + +double bytes2double(byte *bytes) +{ + int64 temp = bytes2bigInt(bytes); + return *(double *)&temp; +} + +int str_to_int(const char *address) +{ + int ret = 0; + ret = (int)strtol(address, NULL, 10); + return ret; +} + +// void str_toupper(char *input) +// { +// if (input == NULL) +// return; + +// int32 len = strlen(input), i = 0; +// for (; i < len; i++) +// input[i] = toupper(input[i]); +// } + +// void str_tolower(char *input) +// { +// if (input == NULL) +// return; + +// int32 len = strlen(input), i = 0; +// for (; i < len; i++) +// input[i] = tolower(input[i]); +// } + +/** + * ×Ö·û´®originÒÔ×Ö·û´®prefix¿ªÍ·£¬·µ»Ø0£»·ñÔò·µ»Ø1£»Òì³£·µ»Ø-1 + */ +int str_start_with(const char *origin, char *prefix) +{ + if (origin == NULL || + prefix == NULL || + strlen(prefix) > strlen(origin)) + { + return -1; + } + + int n = strlen(prefix), i; + for (i = 0; i < n; i++) + { + if (origin[i] != prefix[i]) + { + return 1; + } + } + return 0; +} + +/** + * ×Ö·û´®originÒÔ×Ö·û´®end½á⣬·µ»Ø0£»·ñÔò·µ»Ø1£»Òì³£·µ»Ø-1 + */ +int str_end_with(const char *origin, char *end) +{ + if (origin == NULL || + end == NULL || + strlen(end) > strlen(origin)) + { + return -1; + } + + int n = strlen(end); + int m = strlen(origin); + int i; + for (i = 0; i < n; i++) + { + if (origin[m - i - 1] != end[n - i - 1]) + return 1; + } + return 0; +} + +uint32 htonf_(float value) +{ + uint32 Tempval; + uint32 Retval; + Tempval = *(uint32 *)(&value); + Retval = _WS2_32_WINSOCK_SWAP_LONG(Tempval); + return Retval; +} + +float ntohf_(uint32 value) +{ + const uint32 Tempval = _WS2_32_WINSOCK_SWAP_LONG(value); + float Retval; + *((uint32 *)&Retval) = Tempval; + return Retval; +} + +uint64 htond_(double value) +{ + uint64 Tempval; + uint64 Retval; + Tempval = *(uint64 *)(&value); + Retval = _WS2_32_WINSOCK_SWAP_LONGLONG(Tempval); + return Retval; +} + +double ntohd_(uint64 value) +{ + const uint64 Tempval = _WS2_32_WINSOCK_SWAP_LONGLONG(value); + double Retval; + *((uint64 *)&Retval) = Tempval; + return Retval; +} + +uint64 htonll_(uint64 Value) +{ + const uint64 Retval = _WS2_32_WINSOCK_SWAP_LONGLONG(Value); + return Retval; +} + +uint64 ntohll_(uint64 Value) +{ + const uint64 Retval = _WS2_32_WINSOCK_SWAP_LONGLONG(Value); + return Retval; +} + +#ifndef _WIN32 +/* +============= +itoa + +Convert integer to string + +PARAMS: +- value A 64-bit number to convert +- str Destination buffer; should be 66 characters long for radix2, 24 - radix8, 22 - radix10, 18 - radix16. +- radix Radix must be in range -36 .. 36. Negative values used for signed numbers. +============= +*/ + +char *cip_itoa(unsigned long long value, char str[], int radix) +{ + char buf[66]; + char *dest = buf + sizeof(buf); + bool sign = false; + + if (value == 0) + { + memcpy(str, "0", 2); + return str; + } + + if (radix < 0) + { + radix = -radix; + if ((long long)value < 0) + { + value = -value; + sign = true; + } + } + + *--dest = '\0'; + + switch (radix) + { + case 16: + while (value) + { + *--dest = '0' + (value & 0xF); + if (*dest > '9') + *dest += 'A' - '9' - 1; + value >>= 4; + } + break; + case 10: + while (value) + { + *--dest = '0' + (value % 10); + value /= 10; + } + break; + + case 8: + while (value) + { + *--dest = '0' + (value & 7); + value >>= 3; + } + break; + + case 2: + while (value) + { + *--dest = '0' + (value & 1); + value >>= 1; + } + break; + + default: // The slow version, but universal + while (value) + { + *--dest = '0' + (value % radix); + if (*dest > '9') + *dest += 'A' - '9' - 1; + value /= radix; + } + break; + } + + if (sign) + *--dest = '-'; + + memcpy(str, dest, buf + sizeof(buf) - dest); + return str; +} +#endif \ No newline at end of file diff --git a/APP_Framework/Framework/control/plc_protocol/cip/utill.h b/APP_Framework/Framework/control/plc_protocol/cip/utill.h new file mode 100644 index 000000000..b3d5cef63 --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/cip/utill.h @@ -0,0 +1,58 @@ +#ifndef __UTILL_H__ +#define __UTILL_H__ + +#include "typedef.h" + +typedef struct _tag_byte_array_info +{ + byte *data; // 内容 + int length; // 长度 +} byte_array_info; + +typedef struct _tag_bool_array_info +{ + bool *data; // 内容 + int length; // 长度 +} bool_array_info; + +void short2bytes(short i, byte *bytes); +short bytes2short(byte *bytes); + +void ushort2bytes(ushort i, byte *bytes); +ushort bytes2ushort(byte *bytes); + +void int2bytes(int32 i, byte *bytes); +int32 bytes2int32(byte *bytes); + +void uint2bytes(uint32 i, byte *bytes); +uint32 bytes2uint32(byte *bytes); + +void bigInt2bytes(int64 i, byte *bytes); +int64 bytes2bigInt(byte *bytes); + +void ubigInt2bytes(uint64 i, byte *bytes); +uint64 bytes2ubigInt(byte *bytes); + +void float2bytes(float i, byte *bytes); +float bytes2float(byte *bytes); + +void double2bytes(double i, byte *bytes); +double bytes2double(byte *bytes); + +int str_to_int(const char *address); +void str_toupper(char *input); +void str_tolower(char *input); +int str_start_with(const char *origin, char *prefix); + +uint32 htonf_(float value); +float ntohf_(uint32 value); +uint64 htond_(double value); +double ntohd_(uint64 value); +uint64 htonll_(uint64 Value); +uint64 ntohll_(uint64 Value); + +#ifndef _WIN32 +char *cip_itoa(unsigned long long value, char str[], int radix); +#endif // !_WIN32 + +#endif diff --git a/APP_Framework/Framework/control/plc_protocol/include/cip.h b/APP_Framework/Framework/control/plc_protocol/include/cip.h new file mode 100644 index 000000000..e56eb5109 --- /dev/null +++ b/APP_Framework/Framework/control/plc_protocol/include/cip.h @@ -0,0 +1,40 @@ +/* +* 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 cip.h + * @brief plc protocol cip + * @version 3.0 + * @author AIIT XUOS Lab + * @date 2022-10-08 + */ + +#ifndef Cip_H +#define Cip_H + +#include + +#define BASE_PLC_RECV_BUFF_SIZE 1024 + +ControlProtocolType control_protocol; + +int8_t ReadPlcDataByRecipe(struct ControlRecipe *p_recipe); +void voidpush(uint8_t *datastack,uint8_t* args,uint16_t length); +static uint8_t GetUniformValueTypeMemorySize(UniformValueType uniform_value_type); + +typedef struct +{ + UniformValueType value_type; + char value_name[20]; +}CIPReadItem; + +#endif \ No newline at end of file diff --git a/APP_Framework/Framework/control/shared/control.h b/APP_Framework/Framework/control/shared/control.h index 17f2a093d..7679b3225 100644 --- a/APP_Framework/Framework/control/shared/control.h +++ b/APP_Framework/Framework/control/shared/control.h @@ -56,6 +56,7 @@ typedef enum PROTOCOL_MELSEC_1C, PROTOCOL_MELSEC_3C, PROTOCOL_FREEMODBUS_TCP_SERVER, + PROTOCOL_CIP, PROTOCOL_END }ProtocolType; diff --git a/APP_Framework/Framework/control/shared/control_def.c b/APP_Framework/Framework/control/shared/control_def.c index 1e7aa0be4..099a959b3 100644 --- a/APP_Framework/Framework/control/shared/control_def.c +++ b/APP_Framework/Framework/control/shared/control_def.c @@ -53,6 +53,10 @@ extern int S7ProtocolInit(struct ControlRecipe *p_recipe); extern int FreeModbusTcpServerInit(struct ControlRecipe *p_recipe); #endif +#ifdef CONTROL_PROTOCOL_CIP +extern int CipProtocolInit(struct ControlRecipe *p_recipe); +#endif + /* CONTROL FRAMEWORK READ DATA FORMAT: | HEAD |device_id|read data length|read item count| data | @@ -96,6 +100,9 @@ static struct ControlProtocolInitParam protocol_init[] = { PROTOCOL_FREEMODBUS_TCP_SERVER, FreeModbusTcpServerInit }, #endif +#ifdef CONTROL_PROTOCOL_CIP + { PROTOCOL_CIP, CipProtocolInit }, +#endif { PROTOCOL_END, NULL }, }; @@ -329,7 +336,7 @@ int ControlProtocolOpenDef(struct ControlProtocol *control_protocol) pthread_attr_t attr; attr.schedparam.sched_priority = 19; - attr.stacksize = 2048; + attr.stacksize = 4096; char task_name[] = "control_recv_data"; pthread_args_t args; diff --git a/Ubiquitous/XiZi_IIoT/board/edu-arm32/config.mk b/Ubiquitous/XiZi_IIoT/board/edu-arm32/config.mk index 9b2a506c1..188cac0c9 100644 --- a/Ubiquitous/XiZi_IIoT/board/edu-arm32/config.mk +++ b/Ubiquitous/XiZi_IIoT/board/edu-arm32/config.mk @@ -1,10 +1,6 @@ export CROSS_COMPILE ?=/usr/bin/arm-none-eabi- -<<<<<<< HEAD -export CFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Dgcc -O0 -fgnu89-inline -Wa,-mimplicit-it=thumb -Werror -======= -export CFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Dgcc -O0 -fgnu89-inline -Wa,-mimplicit-it=thumb -Werror -Wuninitialized ->>>>>>> upstream/prepare_for_master +export CFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Dgcc -O0 -fgnu89-inline -Wa,-mimplicit-it=thumb -Werror -Wuninitialized # export CFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Dgcc -O0 -gdwarf-2 -g -fgnu89-inline -Wa,-mimplicit-it=thumb -Werror export AFLAGS := -c -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -x assembler-with-cpp -Wa,-mimplicit-it=thumb -gdwarf-2 export LFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Wl,--gc-sections,-Map=XiZi-edu-arm32.map,-cref,-u,Reset_Handler -T $(BSP_ROOT)/link.lds diff --git a/Ubiquitous/XiZi_IIoT/path_kernel.mk b/Ubiquitous/XiZi_IIoT/path_kernel.mk index 8fb6de932..a793e8f0d 100755 --- a/Ubiquitous/XiZi_IIoT/path_kernel.mk +++ b/Ubiquitous/XiZi_IIoT/path_kernel.mk @@ -536,6 +536,7 @@ KERNELPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/control/plc_protoc KERNELPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/control/plc_protocol/opcua # KERNELPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/control/plc_protocol/s7 # KERNELPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/control/ipc_protocol/freemodbustcpserver # +KERNELPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/control/plc_protocol/cip # endif ifeq ($(CONFIG_LIB_USING_CJSON), y)