From 96e322cd6c0387b7630994bab8d0637a69a69ef3 Mon Sep 17 00:00:00 2001 From: Carl <732416424@qq.com> Date: Wed, 20 Nov 2024 16:11:23 +0800 Subject: [PATCH] [Add] can driver and the 4G driver --- CMakeLists.txt | 6 + drv/drv_4g.c | 125 +++++++ drv/drv_4g.h | 21 ++ drv/drv_can.c | 364 ++++++--------------- drv/drv_can.h | 42 +-- drv/drv_tcp.h | 6 +- lib/libmodbus/include/config.h | 292 +++++++++++++++++ lib/libmodbus/include/modbus-private.h | 125 +++++++ lib/libmodbus/include/modbus-rtu-private.h | 77 +++++ lib/libmodbus/include/modbus-rtu.h | 43 +++ lib/libmodbus/include/modbus-tcp-private.h | 41 +++ lib/libmodbus/include/modbus-tcp.h | 52 +++ lib/libmodbus/include/modbus-version.h | 51 +++ lib/libmodbus/include/modbus.h | 329 +++++++++++++++++++ lib/libmodbus/lib/libmodbus.so | Bin 0 -> 70416 bytes test/test.c | 50 ++- test/test.h | 8 +- 17 files changed, 1322 insertions(+), 310 deletions(-) create mode 100644 lib/libmodbus/include/config.h create mode 100644 lib/libmodbus/include/modbus-private.h create mode 100644 lib/libmodbus/include/modbus-rtu-private.h create mode 100644 lib/libmodbus/include/modbus-rtu.h create mode 100644 lib/libmodbus/include/modbus-tcp-private.h create mode 100644 lib/libmodbus/include/modbus-tcp.h create mode 100644 lib/libmodbus/include/modbus-version.h create mode 100644 lib/libmodbus/include/modbus.h create mode 100644 lib/libmodbus/lib/libmodbus.so diff --git a/CMakeLists.txt b/CMakeLists.txt index 979d485..251780f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -42,6 +42,10 @@ set(DRV_SOURCE ${PROJECT_SOURCE_DIR}/drv/drv_can.c # TCP驱动源文件 ${PROJECT_SOURCE_DIR}/drv/drv_tcp.c + # 4G驱动源文件 + ${PROJECT_SOURCE_DIR}/drv/drv_4g.c + # CAN驱动源文件 + ${PROJECT_SOURCE_DIR}/drv/drv_can.c ) # 添加KIT源文件 @@ -71,6 +75,7 @@ include_directories( lib/libxml2/include lib/libssl/include lib/libcjson/include + lib/libmodbus/include # /usr/include ) @@ -83,6 +88,7 @@ NAMES ssl PATHS lib/libssl/lib crypto PATHS lib/libssl/lib cjson PATHS lib/libcjson/lib + modbus PATHS lib/libmodbus/lib ) target_link_libraries(${ProjectName} PRIVATE ${MY_LIBRARY_PATH}) diff --git a/drv/drv_4g.c b/drv/drv_4g.c index e69de29..6375189 100644 --- a/drv/drv_4g.c +++ b/drv/drv_4g.c @@ -0,0 +1,125 @@ +#include "drv_4g.h" + +#define BUFFER_SIZE 1024 +#define LOCAL "10.244.216.42" + +void client(char interface[], char server_addr[], int server_port) { + int sock = 0; + struct ifreq ifr; + + char buffer[BUFFER_SIZE]; + + + // 创建套接字 + if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == 0) { + perror("套接字创建失败"); + exit(EXIT_FAILURE); + } + + //************如果只绑定网卡名不能连接服务端，可以同时绑定ip和网卡尝试一下************* */ + // //local ip + // struct sockaddr_in local_addr; + // local_addr.sin_family = AF_INET; + // local_addr.sin_port = htons(0); + // local_addr.sin_addr.s_addr = inet_addr("10.232.226.30"); + + // // if (inet_pton(AF_INET, "192.168.2.190", &local_addr.sin_addr) <= 0) { + // // perror("无效的地址"); + // // exit(EXIT_FAILURE); + // // } + + // if (bind(sock, (struct sockaddr *)&local_addr, sizeof(local_addr)) < 0) { + // perror("bind失败"); + // exit(EXIT_FAILURE); + // } + // else + // { + // printf("bind success\n"); + // } + // else { + // printf("bind success!\n"); + // } + + + + // if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == 0) { + // perror("套接字创建失败"); + // exit(EXIT_FAILURE); + // } + + // 设置要绑定的网卡接口名称 + strcpy(ifr.ifr_name, interface); + + // 将套接字绑定到指定的网卡 + if (setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, &ifr, sizeof(ifr)) < 0) { + perror("setsockopt"); + close(sock); + exit(1); + } + else{ + printf("connect the local interface:%s\n", ifr.ifr_name); + } + + //绑定服务端的ip + // 设置服务器地址结构体 + struct sockaddr_in serv_addr; + serv_addr.sin_family = AF_INET; + serv_addr.sin_port = htons(server_port); + serv_addr.sin_addr.s_addr = inet_addr(server_addr); + + // 连接服务器 + if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) { + perror("connect失败"); + exit(EXIT_FAILURE); + } + else { + printf("connect success!\n"); + } + + + // // 将服务器IP地址从点分十进制字符串转换为网络字节序 + // if (inet_pton(AF_INET, "47.120.14.45", &serv_addr.sin_addr) <= 0) { + // perror("无效的地址"); + // exit(EXIT_FAILURE); + // } + + while (1) + { + // 输入要发送的数据 + printf("请输入要发送的数据（输入'quit'退出）："); + fgets(buffer, BUFFER_SIZE, stdin); + + // 去除换行符 + buffer[strcspn(buffer, "\n")] = 0; + + if (strcmp(buffer, "quit") == 0) { + break; + } + + // 向服务器发送数据 + if (send(sock, buffer, strlen(buffer), 0) < 0) { + perror("发送数据失败"); + break; + } + + printf("已向服务端发送数据\n"); + + // 接收服务器返回的回复数据 + memset(buffer, 0, BUFFER_SIZE); + if (recv(sock, buffer, BUFFER_SIZE, 0) < 0) { + perror("接收数据失败"); + break; + } + + if (strlen(buffer) == 0) { + // 服务器断开连接 + printf("服务器已断开连接\n"); + break; + } + + printf("收到服务端回复：%s\n", buffer); + } + + // 关闭套接字 + close(sock); +} diff --git a/drv/drv_4g.h b/drv/drv_4g.h index e69de29..bc2e63c 100644 --- a/drv/drv_4g.h +++ b/drv/drv_4g.h @@ -0,0 +1,21 @@ +#ifndef __DRV_4G_H_ +#define __DRV_4G_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +void client(char interface[], char server_addr[], int server_port); + +#endif diff --git a/drv/drv_can.c b/drv/drv_can.c index fce1c04..6e85e4c 100644 --- a/drv/drv_can.c +++ b/drv/drv_can.c @@ -1,287 +1,123 @@ #include "drv_can.h" -/* - * @description : 字符串按格式输出 - * @param - *destpoint : 字符串格式缓冲区 - * @param - *fmt : 多个参数 - * @return : 按格式输出字符串缓冲区首指针 - */ -char func_dprintf(char *destpoint, char *fmt, ...) +void can_recv(char cannum[], unsigned int canID[], int canIDnum, int dataLength) { - va_list arg_ptr; - char ulen, *tmpBuf; - - tmpBuf = destpoint; - va_start(arg_ptr, fmt); - ulen = vsprintf(tmpBuf, fmt, arg_ptr); - - va_end(arg_ptr); - return ulen; -} - -/* - * @description : 打开can外设，设置波特率，创建文件描述符 - * @param - *device : 设备名称 - * @param - para : can应用参数 - * @return : 打开设备执成功返回文件描述符，失败返回-1 - */ -int func_open_can(char *device, struct_can_param para) -{ - FILE *fstream = NULL; - char buff[300] = {0}, command[50] = {0}; - int fd = -1; struct sockaddr_can addr; - struct ifreq ifr; + struct can_frame frame; + struct can_frame frame_send; + int s; + int nbytes; + struct can_filter filters[canIDnum]; - /*关闭can设备 ifconfig can0 down*/ - memset(buff, 0, sizeof(buff)); - memset(command, 0, sizeof(command)); - func_dprintf(command, "ifconfig %s down", device); - printf("%s \n", command); + s = socket(PF_CAN, SOCK_RAW, CAN_RAW); + if (s < 0) { + perror("Socket creation failed"); + exit(EXIT_FAILURE); + } + printf("创建Can_recv_Socket sucess\n"); - if (NULL == (fstream = popen(command, "w"))) - { - fprintf(stderr, "execute command failed: %s", strerror(errno)); - } - while (NULL != fgets(buff, sizeof(buff), fstream)) - { - printf("%s\n", buff); - if (strstr(buff, "No such device") || strstr(buff, "Cannot find device")) - return -1; - } - pclose(fstream); - sleep(1); - - /*设置can波特率 ip link set can0 up type can bitrate 250000 triple-sampling on*/ - memset(buff, 0, sizeof(buff)); - memset(command, 0, sizeof(command)); - if (para.loopback_mode == 1) - { - func_dprintf(command, "ip link set %s up type can bitrate %d triple-sampling on loopback on", device, para.baudrate); - } - else - { - func_dprintf(command, "ip link set %s up type can bitrate %d triple-sampling on loopback off", device, para.baudrate); - } - printf("%s \n", command); - - if (NULL == (fstream = popen(command, "w"))) - { - fprintf(stderr, "execute command failed: %s", strerror(errno)); - } - while (NULL != fgets(buff, sizeof(buff), fstream)) - { - printf("%s\n", buff); - if (strstr(buff, "No such device") || strstr(buff, "Cannot find device")) - return -1; - } - pclose(fstream); - sleep(1); - - /*打开can设备 ifconfig can0 up*/ - memset(buff, 0, sizeof(buff)); - memset(command, 0, sizeof(command)); - func_dprintf(command, "ifconfig %s up", device); - printf("%s \n", command); - - if (NULL == (fstream = popen(command, "w"))) - { - fprintf(stderr, "execute command failed: %s", strerror(errno)); - } - while (NULL != fgets(buff, sizeof(buff), fstream)) - { - printf("%s\n", buff); - if (strstr(buff, "No such device") || strstr(buff, "Cannot find device")) - return -1; - } - pclose(fstream); - sleep(3); - - /* 创建 socket */ - fd = socket(PF_CAN, SOCK_RAW, CAN_RAW); - if (fd < 0) - { - printf("socket:%s", strerror(errno)); - return -1; - } - /* 设置接口设备名称 */ - strcpy(ifr.ifr_name, device); - /* 确定接口 index */ - if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0) - { - printf("SIOCGIFINDEX:%s\n", strerror(errno)); - return -1; - } - - memset(&addr, 0, sizeof(addr)); + memset(&addr, 0, sizeof(struct sockaddr_can)); addr.can_family = AF_CAN; - addr.can_ifindex = ifr.ifr_ifindex; - /* 绑定 socket到 CAN 接口 */ - if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) + addr.can_ifindex = if_nametoindex(cannum); // 设置can接口 + + if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) { + perror("Binding failed"); + exit(EXIT_FAILURE); + } + printf("连接CAN设备 sucess\n"); + + // 设置发送帧的参数，使用传入的canID和数据长度 + frame_send.can_id = 0x123456; + frame_send.can_dlc = dataLength; + memset(frame_send.data, 0, dataLength); + frame_send.data[0] = 0x11; + frame_send.data[1] = 0x22; + + // 设置过滤规则，只接收指定canID的帧 + for(int i = 0; i < canIDnum; i++) { - printf("bind:%s\n", strerror(errno)); - return -1; + filters[i].can_id = canID[i]; + filters[i].can_mask = 0x7FF; // 这里的掩码根据实际需求设置，0x7FF表示只匹配canID的低11位 } - return fd; + if (setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, filters, sizeof(filters)) < 0) { + perror("Setting filter failed"); + exit(EXIT_FAILURE); + } + + nbytes = read(s, &frame, sizeof(struct can_frame)); + if (nbytes < 0) { + perror("Read failed"); + exit(EXIT_FAILURE); + } + int match_found = 0; + for (int i = 0; i < canIDnum; i++) { + if ((frame.can_id & filters[i].can_mask) == filters[i].can_id) { + match_found = 1; + break; + } + } + if (match_found) { + printf("Received %d bytes: CAN ID 0x%X, Data: ", nbytes, frame.can_id); + for (int i = 0; i < frame.can_dlc; i++) { + printf("%02X ", frame.data[i]); + } + printf("\n"); + // nbytes = write(s, &frame_send, sizeof(struct can_frame)); + // if (nbytes < 0) { + // perror("Send failed"); + // exit(EXIT_FAILURE); + // } + // printf("Sent %d bytes: CAN ID 0x%X, Data: ", nbytes, frame_send.can_id); + // for (int i = 0; i < frame_send.can_dlc; i++) { + // printf("%02X ", frame_send.data[i]); + // } + // printf("\n"); + } + close(s); } -/* - * @description : 设置can回环模式和过滤规则 - * @param - fd : 文件描述符 - * @param - para: can应用参数 - * @return : 设置成功返回1，失败返回-1 - */ -int func_set_can(int fd, struct_can_param para) +void can_send(char cannum[], unsigned int canID, char* dataToSend, int dataLength) { - int loopback = 1; - int reciveown = 1; + struct sockaddr_can addr; + struct can_frame frame_send; + int s; - if (para.loopback_mode == 1) - { - //回环设置 0 关闭回环 1 打开回环 - setsockopt(fd, SOL_CAN_RAW, CAN_RAW_LOOPBACK, &loopback, sizeof(loopback)); - //接收自己的帧 0 不接收自己帧 1 接收自己帧 - setsockopt(fd, SOL_CAN_RAW, CAN_RAW_RECV_OWN_MSGS, &reciveown, sizeof(reciveown)); + s = socket(PF_CAN, SOCK_RAW, CAN_RAW); + if (s < 0) { + perror("Socket creation failed for sending"); + exit(EXIT_FAILURE); + } + printf("create the can_send socket success!\n"); + + memset(&addr, 0, sizeof(struct sockaddr_can)); + addr.can_family = AF_CAN; + addr.can_ifindex = if_nametoindex(cannum); + + if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) { + perror("Binding failed for sending"); + exit(EXIT_FAILURE); } - /* 设置过滤规则 */ - if (setsockopt(fd, SOL_CAN_RAW, CAN_RAW_FILTER, ¶.filter, sizeof(para.filter)) < 0) - { - printf("error when set filter\n"); - return -1; - } - return 1; -} - -/* - * @description : can接收一个can帧 - * @param - fd : 文件描述符 - * @param - *pframe: 一个can帧结构体指针 - * @return : 接收数据长度 - */ -int func_receive_can_frame(int fd, struct can_frame *pframe) -{ - int rx_count = 0; - - rx_count = recv(fd, pframe, sizeof(*pframe), 0); - if (rx_count <= 0) - { - return rx_count; - } - else - { - if (pframe->can_id & CAN_EFF_FLAG) /*如果是扩展帧，清除扩展帧标识*/ - { - pframe->can_id &= (~CAN_EFF_FLAG); - } - else - { - pframe->can_id &= (~CAN_SFF_MASK); - } + // 设置发送帧的参数 + frame_send.can_id = canID; + frame_send.can_dlc = dataLength; + memset(frame_send.data, 0, dataLength); + for (int i = 0; i < dataLength; i++) { + frame_send.data[i] = dataToSend[i]; } - return pframe->can_dlc; -} - -/* - * @description : can接收一组数据包 - * @param - fd : 文件描述符 - * @param - *buff: 要接收can一组数据的缓冲区首指针 - * @param - len : 接收到一组数据的长度 - * @return : 接收数据长度 - */ -int func_receive_can_buff(int fd, unsigned char *buff, int len) -{ - int receive_len = 0, total_receive_len = 0; - struct can_frame frame; - int i = 0; - - while (1) - { - receive_len = func_receive_can_frame(fd, &frame); - for (i = 0; i < receive_len; i++) - { - *(buff + total_receive_len) = frame.data[i]; - total_receive_len++; - } - if ((receive_len < 8) || (total_receive_len > (len - 8))) - { - return total_receive_len; - } + int nbytes = write(s, &frame_send, sizeof(struct can_frame)); + if (nbytes < 0) { + perror("Send failed"); + exit(EXIT_FAILURE); } - return total_receive_len; -} -/* - * @description : can发送一个can帧 - * @param - fd : 文件描述符 - * @param - *pframe: 一个can帧结构体指针 - * @param - param : can应用参数 - * @return : 发送数据长度，发送失败返回-1 - */ -int func_send_can_frame(int fd, struct can_frame *pframe, struct_can_param param) -{ - int result = 0; - - if (param.extend == 1) /*扩展帧增加扩展帧标志*/ - { - pframe->can_id &= CAN_EFF_MASK; - pframe->can_id |= CAN_EFF_FLAG; + printf("Sent %d bytes: CAN ID 0x%X, Data: ", nbytes, frame_send.can_id); + for (int i = 0; i < frame_send.can_dlc; i++) { + printf("%02X ", frame_send.data[i]); } - else - { - pframe->can_id &= CAN_SFF_MASK; - } - result = send(fd, pframe, sizeof(struct can_frame), 0); - if (result == -1) - { - printf("send:%s\n", strerror(errno)); - return -1; - } - return result; -} + printf("\n"); -/* - * @description : can发送一组数据包 - * @param - fd : 文件描述符 - * @param - *buff: 要发送can一组数据的缓冲区首指针 - * @param - len : 发送数据的长度 - * @param - param: can应用参数 - * @return : 实际发送数据长度 - */ -int func_send_can_buff(int fd, unsigned char *buff, int len, struct_can_param param) -{ - int remain_frame_len = 0, frame_numb = 0; - struct can_frame frame; - int i = 0; - - remain_frame_len = len; - while (1) - { - if (remain_frame_len >= 8) - { - frame.can_dlc = 8; /*填充发送长度*/ - remain_frame_len -= 8; /*剩余数据长度*/ - } - else - { - frame.can_dlc = remain_frame_len; /*填充发送长度*/ - remain_frame_len = 0; // - } - - frame.can_id = param.id; /*填充发送id*/ - - for (i = 0; i < frame.can_dlc; i++) - { - frame.data[i] = buff[frame_numb * 8 + i]; /*填充发送数据*/ - } - func_send_can_frame(fd, &frame, param); - frame_numb++; - if (remain_frame_len == 0) - { - return len; - } - } - return len; + close(s); } \ No newline at end of file diff --git a/drv/drv_can.h b/drv/drv_can.h index bf7a1cc..331fa2c 100644 --- a/drv/drv_can.h +++ b/drv/drv_can.h @@ -1,47 +1,19 @@ -#ifndef __DRV_CAN_H_ -#define __DRV_CAN_H_ +#ifndef __DEV_CAN_H_ +#define __DEV_CAN_H_ -#define _DEFAULT_SOURCE - -#include -#include #include -#include #include #include #include -#include -#include -#include #include +#include #include #include -#include /*PPSIX 终端控制定义*/ +#include +#include -#define CAN_MODE 0 -#define CAN_FD_MODE 1 +void can_recv(char cannum[], unsigned int canID[], int canIDnum, int dataLength); -/*CAN口参数结构体 */ -typedef struct -{ - unsigned long baudrate; /*波特率 5k~1000k*/ - unsigned int id; /*设备ID*/ - struct can_filter filter; /*接收设备过滤ID*/ - unsigned char extend; /*扩展ID*/ - unsigned char loopback_mode; /*回环模式*/ - - unsigned char canfd_mode; /*CANFD模式*/ - unsigned long data_baudrate; /*CANFD模式下需要单独设置数据波特率*/ -} struct_can_param; - -int func_open_can(char *device, struct_can_param para); -int func_set_can(int fd, struct_can_param para); -int func_receive_can_buff(int fd, unsigned char *buff, int len); -int func_send_can_buff(int fd, unsigned char *buff, int len, struct_can_param param); - -// int func_open_canfd(char *device, struct_can_param para); -// int func_set_canfd(int fd, struct_can_param para); -// int func_receive_canfd_buff(int fd, unsigned char *buff, int len); -// int func_send_canfd_buff(int fd, unsigned char *buff, int len, struct_can_param param); +void can_send(char cannum[], unsigned int canID, char* dataToSend, int dataLength); #endif \ No newline at end of file diff --git a/drv/drv_tcp.h b/drv/drv_tcp.h index c1e422d..749aba3 100644 --- a/drv/drv_tcp.h +++ b/drv/drv_tcp.h @@ -1,8 +1,6 @@ #ifndef __DRV_TCP_H_ #define __DRV_TCP_H_ -#define _DEFAULT_SOURCE - #include #include #include @@ -13,9 +11,9 @@ #include #include -void getInterfacesAndIPs(char *interfaces[], char *ips[], int *numInterfaces); +void getInterfacesAndIPs(char *interfaces[], char *ips[], int *count); void closeAndFree(int server_fd, int new_socket, char *interface, char *ip); -void *tcpServeThread(void *arg); void tcpServe(int port); +void *tcpServeThread(void *arg); #endif \ No newline at end of file diff --git a/lib/libmodbus/include/config.h b/lib/libmodbus/include/config.h new file mode 100644 index 0000000..3d77a65 --- /dev/null +++ b/lib/libmodbus/include/config.h @@ -0,0 +1,292 @@ +/* config.h. Generated from config.h.in by configure. */ +/* config.h.in. Generated from configure.ac by autoheader. */ + +/* Define to 1 if you have the `accept4' function. */ +/* #undef HAVE_ACCEPT4 */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_ARPA_INET_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_BYTESWAP_H */ + +/* Define to 1 if you have the declaration of `TIOCM_RTS', and to 0 if you + don't. */ +#define HAVE_DECL_TIOCM_RTS 0 + +/* Define to 1 if you have the declaration of `TIOCSRS485', and to 0 if you + don't. */ +#define HAVE_DECL_TIOCSRS485 0 + +/* Define to 1 if you have the declaration of `__CYGWIN__', and to 0 if you + don't. */ +#define HAVE_DECL___CYGWIN__ 0 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_DLFCN_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_ERRNO_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_FCNTL_H 1 + +/* Define to 1 if you have the `getaddrinfo' function. */ +/* #undef HAVE_GETADDRINFO */ + +/* Define to 1 if you have the `gettimeofday' function. */ +#define HAVE_GETTIMEOFDAY 1 + +/* Define to 1 if you have the `inet_ntop' function. */ +/* #undef HAVE_INET_NTOP */ + +/* Define to 1 if you have the `inet_pton' function. */ +/* #undef HAVE_INET_PTON */ + +/* Define to 1 if you have the header file. */ +#define HAVE_INTTYPES_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_LIMITS_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_LINUX_SERIAL_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_MINIX_CONFIG_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_NETDB_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_NETINET_IN_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_NETINET_TCP_H */ + +/* Define to 1 if you have the `select' function. */ +/* #undef HAVE_SELECT */ + +/* Define to 1 if you have the `socket' function. */ +/* #undef HAVE_SOCKET */ + +/* Define to 1 if you have the header file. */ +#define HAVE_STDINT_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STDIO_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STDLIB_H 1 + +/* Define to 1 if you have the `strerror' function. */ +#define HAVE_STRERROR 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STRINGS_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STRING_H 1 + +/* Define to 1 if you have the `strlcpy' function. */ +/* #undef HAVE_STRLCPY */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_IOCTL_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_PARAMS_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_SOCKET_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_TIME_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_TERMIOS_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_TIME_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_UNISTD_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_WCHAR_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_WINSOCK2_H 1 + +/* Define to the sub-directory where libtool stores uninstalled libraries. */ +#define LT_OBJDIR ".libs/" + +/* Name of package */ +#define PACKAGE "libmodbus" + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "https://github.com/stephane/libmodbus/issues" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME "libmodbus" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING "libmodbus 3.1.10" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME "libmodbus" + +/* Define to the home page for this package. */ +#define PACKAGE_URL "http://libmodbus.org/" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION "3.1.10" + +/* Define to 1 if all of the C90 standard headers exist (not just the ones + required in a freestanding environment). This macro is provided for + backward compatibility; new code need not use it. */ +#define STDC_HEADERS 1 + +/* Enable extensions on AIX 3, Interix. */ +#ifndef _ALL_SOURCE +# define _ALL_SOURCE 1 +#endif +/* Enable general extensions on macOS. */ +#ifndef _DARWIN_C_SOURCE +# define _DARWIN_C_SOURCE 1 +#endif +/* Enable general extensions on Solaris. */ +#ifndef __EXTENSIONS__ +# define __EXTENSIONS__ 1 +#endif +/* Enable GNU extensions on systems that have them. */ +#ifndef _GNU_SOURCE +# define _GNU_SOURCE 1 +#endif +/* Enable X/Open compliant socket functions that do not require linking + with -lxnet on HP-UX 11.11. */ +#ifndef _HPUX_ALT_XOPEN_SOCKET_API +# define _HPUX_ALT_XOPEN_SOCKET_API 1 +#endif +/* Identify the host operating system as Minix. + This macro does not affect the system headers' behavior. + A future release of Autoconf may stop defining this macro. */ +#ifndef _MINIX +/* # undef _MINIX */ +#endif +/* Enable general extensions on NetBSD. + Enable NetBSD compatibility extensions on Minix. */ +#ifndef _NETBSD_SOURCE +# define _NETBSD_SOURCE 1 +#endif +/* Enable OpenBSD compatibility extensions on NetBSD. + Oddly enough, this does nothing on OpenBSD. */ +#ifndef _OPENBSD_SOURCE +# define _OPENBSD_SOURCE 1 +#endif +/* Define to 1 if needed for POSIX-compatible behavior. */ +#ifndef _POSIX_SOURCE +/* # undef _POSIX_SOURCE */ +#endif +/* Define to 2 if needed for POSIX-compatible behavior. */ +#ifndef _POSIX_1_SOURCE +/* # undef _POSIX_1_SOURCE */ +#endif +/* Enable POSIX-compatible threading on Solaris. */ +#ifndef _POSIX_PTHREAD_SEMANTICS +# define _POSIX_PTHREAD_SEMANTICS 1 +#endif +/* Enable extensions specified by ISO/IEC TS 18661-5:2014. */ +#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__ +# define __STDC_WANT_IEC_60559_ATTRIBS_EXT__ 1 +#endif +/* Enable extensions specified by ISO/IEC TS 18661-1:2014. */ +#ifndef __STDC_WANT_IEC_60559_BFP_EXT__ +# define __STDC_WANT_IEC_60559_BFP_EXT__ 1 +#endif +/* Enable extensions specified by ISO/IEC TS 18661-2:2015. */ +#ifndef __STDC_WANT_IEC_60559_DFP_EXT__ +# define __STDC_WANT_IEC_60559_DFP_EXT__ 1 +#endif +/* Enable extensions specified by ISO/IEC TS 18661-4:2015. */ +#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__ +# define __STDC_WANT_IEC_60559_FUNCS_EXT__ 1 +#endif +/* Enable extensions specified by ISO/IEC TS 18661-3:2015. */ +#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__ +# define __STDC_WANT_IEC_60559_TYPES_EXT__ 1 +#endif +/* Enable extensions specified by ISO/IEC TR 24731-2:2010. */ +#ifndef __STDC_WANT_LIB_EXT2__ +# define __STDC_WANT_LIB_EXT2__ 1 +#endif +/* Enable extensions specified by ISO/IEC 24747:2009. */ +#ifndef __STDC_WANT_MATH_SPEC_FUNCS__ +# define __STDC_WANT_MATH_SPEC_FUNCS__ 1 +#endif +/* Enable extensions on HP NonStop. */ +#ifndef _TANDEM_SOURCE +# define _TANDEM_SOURCE 1 +#endif +/* Enable X/Open extensions. Define to 500 only if necessary + to make mbstate_t available. */ +#ifndef _XOPEN_SOURCE +/* # undef _XOPEN_SOURCE */ +#endif + + +/* Version number of package */ +#define VERSION "3.1.10" + +/* _ */ +#define WINVER 0x0501 + +/* Number of bits in a file offset, on hosts where this is settable. */ +#define _FILE_OFFSET_BITS 64 + +/* Define for large files, on AIX-style hosts. */ +/* #undef _LARGE_FILES */ + +/* Define for Solaris 2.5.1 so the uint32_t typedef from , + , or is not used. If the typedef were allowed, the + #define below would cause a syntax error. */ +/* #undef _UINT32_T */ + +/* Define for Solaris 2.5.1 so the uint8_t typedef from , + , or is not used. If the typedef were allowed, the + #define below would cause a syntax error. */ +/* #undef _UINT8_T */ + +/* Define to `__inline__' or `__inline' if that's what the C compiler + calls it, or to nothing if 'inline' is not supported under any name. */ +#ifndef __cplusplus +/* #undef inline */ +#endif + +/* Define to the type of a signed integer type of width exactly 64 bits if + such a type exists and the standard includes do not define it. */ +/* #undef int64_t */ + +/* Define to `unsigned int' if does not define. */ +/* #undef size_t */ + +/* Define to `int' if does not define. */ +/* #undef ssize_t */ + +/* Define to the type of an unsigned integer type of width exactly 16 bits if + such a type exists and the standard includes do not define it. */ +/* #undef uint16_t */ + +/* Define to the type of an unsigned integer type of width exactly 32 bits if + such a type exists and the standard includes do not define it. */ +/* #undef uint32_t */ + +/* Define to the type of an unsigned integer type of width exactly 8 bits if + such a type exists and the standard includes do not define it. */ +/* #undef uint8_t */ diff --git a/lib/libmodbus/include/modbus-private.h b/lib/libmodbus/include/modbus-private.h new file mode 100644 index 0000000..4beab96 --- /dev/null +++ b/lib/libmodbus/include/modbus-private.h @@ -0,0 +1,125 @@ +/* + * Copyright © Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#ifndef MODBUS_PRIVATE_H +#define MODBUS_PRIVATE_H + +// clang-format off +#ifndef _MSC_VER +# include +# include +#else +# include "stdint.h" +# include +typedef int ssize_t; +#endif +// clang-format on +#include +#include + +#include "modbus.h" + +MODBUS_BEGIN_DECLS + +/* It's not really the minimal length (the real one is report slave ID + * in RTU (4 bytes)) but it's a convenient size to use in RTU or TCP + * communications to read many values or write a single one. + * Maximum between : + * - HEADER_LENGTH_TCP (7) + function (1) + address (2) + number (2) + * - HEADER_LENGTH_RTU (1) + function (1) + address (2) + number (2) + CRC (2) + */ +#define _MIN_REQ_LENGTH 12 + +#define _REPORT_SLAVE_ID 180 + +#define _MODBUS_EXCEPTION_RSP_LENGTH 5 + +/* Timeouts in microsecond (0.5 s) */ +#define _RESPONSE_TIMEOUT 500000 +#define _BYTE_TIMEOUT 500000 + +typedef enum { + _MODBUS_BACKEND_TYPE_RTU = 0, + _MODBUS_BACKEND_TYPE_TCP +} modbus_backend_type_t; + +/* + * ---------- Request Indication ---------- + * | Client | ---------------------->| Server | + * ---------- Confirmation Response ---------- + */ +typedef enum { + /* Request message on the server side */ + MSG_INDICATION, + /* Request message on the client side */ + MSG_CONFIRMATION +} msg_type_t; + +/* This structure reduces the number of params in functions and so + * optimizes the speed of execution (~ 37%). */ +typedef struct _sft { + int slave; + int function; + int t_id; +} sft_t; + +typedef struct _modbus_backend { + unsigned int backend_type; + unsigned int header_length; + unsigned int checksum_length; + unsigned int max_adu_length; + int (*set_slave)(modbus_t *ctx, int slave); + int (*build_request_basis)( + modbus_t *ctx, int function, int addr, int nb, uint8_t *req); + int (*build_response_basis)(sft_t *sft, uint8_t *rsp); + int (*prepare_response_tid)(const uint8_t *req, int *req_length); + int (*send_msg_pre)(uint8_t *req, int req_length); + ssize_t (*send)(modbus_t *ctx, const uint8_t *req, int req_length); + int (*receive)(modbus_t *ctx, uint8_t *req); + ssize_t (*recv)(modbus_t *ctx, uint8_t *rsp, int rsp_length); + int (*check_integrity)(modbus_t *ctx, uint8_t *msg, const int msg_length); + int (*pre_check_confirmation)(modbus_t *ctx, + const uint8_t *req, + const uint8_t *rsp, + int rsp_length); + int (*connect)(modbus_t *ctx); + unsigned int (*is_connected)(modbus_t *ctx); + void (*close)(modbus_t *ctx); + int (*flush)(modbus_t *ctx); + int (*select)(modbus_t *ctx, fd_set *rset, struct timeval *tv, int msg_length); + void (*free)(modbus_t *ctx); +} modbus_backend_t; + +struct _modbus { + /* Slave address */ + int slave; + /* Socket or file descriptor */ + int s; + int debug; + int error_recovery; + int quirks; + struct timeval response_timeout; + struct timeval byte_timeout; + struct timeval indication_timeout; + const modbus_backend_t *backend; + void *backend_data; + uint8_t *sendMsg; + int sendMsgLen; + uint8_t *recvMsg; + int recvMsgLen; +}; + +void _modbus_init_common(modbus_t *ctx); +void _error_print(modbus_t *ctx, const char *context); +int _modbus_receive_msg(modbus_t *ctx, uint8_t *msg, msg_type_t msg_type); + +#ifndef HAVE_STRLCPY +size_t strlcpy(char *dest, const char *src, size_t dest_size); +#endif + +MODBUS_END_DECLS + +#endif /* MODBUS_PRIVATE_H */ diff --git a/lib/libmodbus/include/modbus-rtu-private.h b/lib/libmodbus/include/modbus-rtu-private.h new file mode 100644 index 0000000..01e6a91 --- /dev/null +++ b/lib/libmodbus/include/modbus-rtu-private.h @@ -0,0 +1,77 @@ +/* + * Copyright © Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#ifndef MODBUS_RTU_PRIVATE_H +#define MODBUS_RTU_PRIVATE_H + +#ifndef _MSC_VER +#include +#else +#include "stdint.h" +#endif + +#if defined(_WIN32) +#include +#else +#include +#endif + +#define _MODBUS_RTU_HEADER_LENGTH 1 +#define _MODBUS_RTU_PRESET_REQ_LENGTH 6 +#define _MODBUS_RTU_PRESET_RSP_LENGTH 2 + +#define _MODBUS_RTU_CHECKSUM_LENGTH 2 + +#if defined(_WIN32) +#if !defined(ENOTSUP) +#define ENOTSUP WSAEOPNOTSUPP +#endif + +/* WIN32: struct containing serial handle and a receive buffer */ +#define PY_BUF_SIZE 512 + +struct win32_ser { + /* File handle */ + HANDLE fd; + /* Receive buffer */ + uint8_t buf[PY_BUF_SIZE]; + /* Received chars */ + DWORD n_bytes; +}; +#endif /* _WIN32 */ + +typedef struct _modbus_rtu { + /* Device: "/dev/ttyS0", "/dev/ttyUSB0" or "/dev/tty.USA19*" on Mac OS X. */ + char *device; + /* Bauds: 9600, 19200, 57600, 115200, etc */ + int baud; + /* Data bit */ + uint8_t data_bit; + /* Stop bit */ + uint8_t stop_bit; + /* Parity: 'N', 'O', 'E' */ + char parity; +#if defined(_WIN32) + struct win32_ser w_ser; + DCB old_dcb; +#else + /* Save old termios settings */ + struct termios old_tios; +#endif +#if HAVE_DECL_TIOCSRS485 + int serial_mode; +#endif +#if HAVE_DECL_TIOCM_RTS + int rts; + int rts_delay; + int onebyte_time; + void (*set_rts)(modbus_t *ctx, int on); +#endif + /* To handle many slaves on the same link */ + int confirmation_to_ignore; +} modbus_rtu_t; + +#endif /* MODBUS_RTU_PRIVATE_H */ diff --git a/lib/libmodbus/include/modbus-rtu.h b/lib/libmodbus/include/modbus-rtu.h new file mode 100644 index 0000000..8e89e73 --- /dev/null +++ b/lib/libmodbus/include/modbus-rtu.h @@ -0,0 +1,43 @@ +/* + * Copyright © Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#ifndef MODBUS_RTU_H +#define MODBUS_RTU_H + +#include "modbus.h" + +MODBUS_BEGIN_DECLS + +/* Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5 + * RS232 / RS485 ADU = 253 bytes + slave (1 byte) + CRC (2 bytes) = 256 bytes + */ +#define MODBUS_RTU_MAX_ADU_LENGTH 256 + +MODBUS_API modbus_t * +modbus_new_rtu(const char *device, int baud, char parity, int data_bit, int stop_bit); + +#define MODBUS_RTU_RS232 0 +#define MODBUS_RTU_RS485 1 + +MODBUS_API int modbus_rtu_set_serial_mode(modbus_t *ctx, int mode); +MODBUS_API int modbus_rtu_get_serial_mode(modbus_t *ctx); + +#define MODBUS_RTU_RTS_NONE 0 +#define MODBUS_RTU_RTS_UP 1 +#define MODBUS_RTU_RTS_DOWN 2 + +MODBUS_API int modbus_rtu_set_rts(modbus_t *ctx, int mode); +MODBUS_API int modbus_rtu_get_rts(modbus_t *ctx); + +MODBUS_API int modbus_rtu_set_custom_rts(modbus_t *ctx, + void (*set_rts)(modbus_t *ctx, int on)); + +MODBUS_API int modbus_rtu_set_rts_delay(modbus_t *ctx, int us); +MODBUS_API int modbus_rtu_get_rts_delay(modbus_t *ctx); + +MODBUS_END_DECLS + +#endif /* MODBUS_RTU_H */ diff --git a/lib/libmodbus/include/modbus-tcp-private.h b/lib/libmodbus/include/modbus-tcp-private.h new file mode 100644 index 0000000..faffc21 --- /dev/null +++ b/lib/libmodbus/include/modbus-tcp-private.h @@ -0,0 +1,41 @@ +/* + * Copyright © Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#ifndef MODBUS_TCP_PRIVATE_H +#define MODBUS_TCP_PRIVATE_H + +#define _MODBUS_TCP_HEADER_LENGTH 7 +#define _MODBUS_TCP_PRESET_REQ_LENGTH 12 +#define _MODBUS_TCP_PRESET_RSP_LENGTH 8 + +#define _MODBUS_TCP_CHECKSUM_LENGTH 0 + +/* In both structures, the transaction ID must be placed on first position + to have a quick access not dependent of the TCP backend */ +typedef struct _modbus_tcp { + /* Extract from MODBUS Messaging on TCP/IP Implementation Guide V1.0b + (page 23/46): + The transaction identifier is used to associate the future response + with the request. This identifier is unique on each TCP connection. */ + uint16_t t_id; + /* TCP port */ + int port; + /* IP address */ + char ip[16]; +} modbus_tcp_t; + +typedef struct _modbus_tcp_pi { + /* Transaction ID */ + uint16_t t_id; + /* TCP port */ + int port; + /* Node */ + char *node; + /* Service */ + char *service; +} modbus_tcp_pi_t; + +#endif /* MODBUS_TCP_PRIVATE_H */ diff --git a/lib/libmodbus/include/modbus-tcp.h b/lib/libmodbus/include/modbus-tcp.h new file mode 100644 index 0000000..768d38c --- /dev/null +++ b/lib/libmodbus/include/modbus-tcp.h @@ -0,0 +1,52 @@ +/* + * Copyright © Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#ifndef MODBUS_TCP_H +#define MODBUS_TCP_H + +#include "modbus.h" + +MODBUS_BEGIN_DECLS + +#if defined(_WIN32) && !defined(__CYGWIN__) +/* Win32 with MinGW, supplement to */ +#include +#if !defined(ECONNRESET) +#define ECONNRESET WSAECONNRESET +#endif +#if !defined(ECONNREFUSED) +#define ECONNREFUSED WSAECONNREFUSED +#endif +#if !defined(ETIMEDOUT) +#define ETIMEDOUT WSAETIMEDOUT +#endif +#if !defined(ENOPROTOOPT) +#define ENOPROTOOPT WSAENOPROTOOPT +#endif +#if !defined(EINPROGRESS) +#define EINPROGRESS WSAEINPROGRESS +#endif +#endif + +#define MODBUS_TCP_DEFAULT_PORT 502 +#define MODBUS_TCP_SLAVE 0xFF + +/* Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5 + * TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes + */ +#define MODBUS_TCP_MAX_ADU_LENGTH 260 + +MODBUS_API modbus_t *modbus_new_tcp(const char *ip_address, int port); +MODBUS_API int modbus_tcp_listen(modbus_t *ctx, int nb_connection); +MODBUS_API int modbus_tcp_accept(modbus_t *ctx, int *s); + +MODBUS_API modbus_t *modbus_new_tcp_pi(const char *node, const char *service); +MODBUS_API int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection); +MODBUS_API int modbus_tcp_pi_accept(modbus_t *ctx, int *s); + +MODBUS_END_DECLS + +#endif /* MODBUS_TCP_H */ diff --git a/lib/libmodbus/include/modbus-version.h b/lib/libmodbus/include/modbus-version.h new file mode 100644 index 0000000..16a34da --- /dev/null +++ b/lib/libmodbus/include/modbus-version.h @@ -0,0 +1,51 @@ +/* + * Copyright © Stéphane Raimbault + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef MODBUS_VERSION_H +#define MODBUS_VERSION_H + +/* The major version, (1, if %LIBMODBUS_VERSION is 1.2.3) */ +#define LIBMODBUS_VERSION_MAJOR (3) + +/* The minor version (2, if %LIBMODBUS_VERSION is 1.2.3) */ +#define LIBMODBUS_VERSION_MINOR (1) + +/* The micro version (3, if %LIBMODBUS_VERSION is 1.2.3) */ +#define LIBMODBUS_VERSION_MICRO (10) + +/* The full version, like 1.2.3 */ +#define LIBMODBUS_VERSION 3.1.10 + +/* The full version, in string form (suited for string concatenation) + */ +#define LIBMODBUS_VERSION_STRING "3.1.10" + +/* Numerically encoded version, eg. v1.2.3 is 0x010203 */ +#define LIBMODBUS_VERSION_HEX \ + ((LIBMODBUS_VERSION_MAJOR << 16) | (LIBMODBUS_VERSION_MINOR << 8) | \ + (LIBMODBUS_VERSION_MICRO << 0)) + +/* Evaluates to True if the version is greater than @major, @minor and @micro + */ +#define LIBMODBUS_VERSION_CHECK(major, minor, micro) \ + (LIBMODBUS_VERSION_MAJOR > (major) || \ + (LIBMODBUS_VERSION_MAJOR == (major) && LIBMODBUS_VERSION_MINOR > (minor)) || \ + (LIBMODBUS_VERSION_MAJOR == (major) && LIBMODBUS_VERSION_MINOR == (minor) && \ + LIBMODBUS_VERSION_MICRO >= (micro))) + +#endif /* MODBUS_VERSION_H */ diff --git a/lib/libmodbus/include/modbus.h b/lib/libmodbus/include/modbus.h new file mode 100644 index 0000000..55ef08a --- /dev/null +++ b/lib/libmodbus/include/modbus.h @@ -0,0 +1,329 @@ +/* + * Copyright © Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#ifndef MODBUS_H +#define MODBUS_H + +// clang-format off +/* Add this for macros that defined unix flavor */ +#if (defined(__unix__) || defined(unix)) && !defined(USG) +# include +#endif + +#ifndef _MSC_VER +# include +#else +# include "stdint.h" +#endif + +#include "modbus-version.h" + +#if defined(_MSC_VER) +# if defined(DLLBUILD) +/* define DLLBUILD when building the DLL */ +# define MODBUS_API __declspec(dllexport) +# else +# define MODBUS_API __declspec(dllimport) +# endif +#else +# define MODBUS_API +#endif + +#ifdef __cplusplus +# define MODBUS_BEGIN_DECLS extern "C" { +# define MODBUS_END_DECLS } +#else +# define MODBUS_BEGIN_DECLS +# define MODBUS_END_DECLS +#endif +// clang-format on + +MODBUS_BEGIN_DECLS + +#ifndef FALSE +#define FALSE 0 +#endif + +#ifndef TRUE +#define TRUE 1 +#endif + +#ifndef OFF +#define OFF 0 +#endif + +#ifndef ON +#define ON 1 +#endif + +/* Modbus function codes */ +#define MODBUS_FC_READ_COILS 0x01 +#define MODBUS_FC_READ_DISCRETE_INPUTS 0x02 +#define MODBUS_FC_READ_HOLDING_REGISTERS 0x03 +#define MODBUS_FC_READ_INPUT_REGISTERS 0x04 +#define MODBUS_FC_WRITE_SINGLE_COIL 0x05 +#define MODBUS_FC_WRITE_SINGLE_REGISTER 0x06 +#define MODBUS_FC_READ_EXCEPTION_STATUS 0x07 +#define MODBUS_FC_WRITE_MULTIPLE_COILS 0x0F +#define MODBUS_FC_WRITE_MULTIPLE_REGISTERS 0x10 +#define MODBUS_FC_REPORT_SLAVE_ID 0x11 +#define MODBUS_FC_MASK_WRITE_REGISTER 0x16 +#define MODBUS_FC_WRITE_AND_READ_REGISTERS 0x17 + +#define MODBUS_BROADCAST_ADDRESS 0 + +/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 1 page 12) + * Quantity of Coils to read (2 bytes): 1 to 2000 (0x7D0) + * (chapter 6 section 11 page 29) + * Quantity of Coils to write (2 bytes): 1 to 1968 (0x7B0) + */ +#define MODBUS_MAX_READ_BITS 2000 +#define MODBUS_MAX_WRITE_BITS 1968 + +/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 3 page 15) + * Quantity of Registers to read (2 bytes): 1 to 125 (0x7D) + * (chapter 6 section 12 page 31) + * Quantity of Registers to write (2 bytes) 1 to 123 (0x7B) + * (chapter 6 section 17 page 38) + * Quantity of Registers to write in R/W registers (2 bytes) 1 to 121 (0x79) + */ +#define MODBUS_MAX_READ_REGISTERS 125 +#define MODBUS_MAX_WRITE_REGISTERS 123 +#define MODBUS_MAX_WR_WRITE_REGISTERS 121 +#define MODBUS_MAX_WR_READ_REGISTERS 125 + +/* The size of the MODBUS PDU is limited by the size constraint inherited from + * the first MODBUS implementation on Serial Line network (max. RS485 ADU = 256 + * bytes). Therefore, MODBUS PDU for serial line communication = 256 - Server + * address (1 byte) - CRC (2 bytes) = 253 bytes. + */ +#define MODBUS_MAX_PDU_LENGTH 253 + +/* Consequently: + * - RTU MODBUS ADU = 253 bytes + Server address (1 byte) + CRC (2 bytes) = 256 + * bytes. + * - TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes. + * so the maximum of both backend in 260 bytes. This size can used to allocate + * an array of bytes to store responses and it will be compatible with the two + * backends. + */ +#define MODBUS_MAX_ADU_LENGTH 260 + +/* Random number to avoid errno conflicts */ +#define MODBUS_ENOBASE 112345678 + +/* Protocol exceptions */ +enum { + MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 0x01, + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, + MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE, + MODBUS_EXCEPTION_ACKNOWLEDGE, + MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY, + MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE, + MODBUS_EXCEPTION_MEMORY_PARITY, + MODBUS_EXCEPTION_NOT_DEFINED, + MODBUS_EXCEPTION_GATEWAY_PATH, + MODBUS_EXCEPTION_GATEWAY_TARGET, + MODBUS_EXCEPTION_MAX +}; + +#define EMBXILFUN (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_FUNCTION) +#define EMBXILADD (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS) +#define EMBXILVAL (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE) +#define EMBXSFAIL (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE) +#define EMBXACK (MODBUS_ENOBASE + MODBUS_EXCEPTION_ACKNOWLEDGE) +#define EMBXSBUSY (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY) +#define EMBXNACK (MODBUS_ENOBASE + MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE) +#define EMBXMEMPAR (MODBUS_ENOBASE + MODBUS_EXCEPTION_MEMORY_PARITY) +#define EMBXGPATH (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_PATH) +#define EMBXGTAR (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_TARGET) + +/* Native libmodbus error codes */ +#define EMBBADCRC (EMBXGTAR + 1) +#define EMBBADDATA (EMBXGTAR + 2) +#define EMBBADEXC (EMBXGTAR + 3) +#define EMBUNKEXC (EMBXGTAR + 4) +#define EMBMDATA (EMBXGTAR + 5) +#define EMBBADSLAVE (EMBXGTAR + 6) + +extern const unsigned int libmodbus_version_major; +extern const unsigned int libmodbus_version_minor; +extern const unsigned int libmodbus_version_micro; + +typedef struct _modbus modbus_t; + +typedef struct _modbus_mapping_t { + int nb_bits; + int start_bits; + int nb_input_bits; + int start_input_bits; + int nb_input_registers; + int start_input_registers; + int nb_registers; + int start_registers; + uint8_t *tab_bits; + uint8_t *tab_input_bits; + uint16_t *tab_input_registers; + uint16_t *tab_registers; +} modbus_mapping_t; + +typedef enum { + MODBUS_ERROR_RECOVERY_NONE = 0, + MODBUS_ERROR_RECOVERY_LINK = (1 << 1), + MODBUS_ERROR_RECOVERY_PROTOCOL = (1 << 2) +} modbus_error_recovery_mode; + +typedef enum { + MODBUS_QUIRK_NONE = 0, + MODBUS_QUIRK_MAX_SLAVE = (1 << 1), + MODBUS_QUIRK_REPLY_TO_BROADCAST = (1 << 2), + MODBUS_QUIRK_ALL = 0xFF +} modbus_quirks; + +MODBUS_API int modbus_set_slave(modbus_t *ctx, int slave); +MODBUS_API int modbus_get_slave(modbus_t *ctx); +MODBUS_API int modbus_set_error_recovery(modbus_t *ctx, + modbus_error_recovery_mode error_recovery); +MODBUS_API int modbus_set_socket(modbus_t *ctx, int s); +MODBUS_API int modbus_get_socket(modbus_t *ctx); + +MODBUS_API int +modbus_get_response_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec); +MODBUS_API int +modbus_set_response_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec); + +MODBUS_API int +modbus_get_byte_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec); +MODBUS_API int modbus_set_byte_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec); + +MODBUS_API int +modbus_get_indication_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec); +MODBUS_API int +modbus_set_indication_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec); + +MODBUS_API int modbus_get_header_length(modbus_t *ctx); + +MODBUS_API int modbus_connect(modbus_t *ctx); +MODBUS_API void modbus_close(modbus_t *ctx); + +MODBUS_API void modbus_free(modbus_t *ctx); + +MODBUS_API int modbus_flush(modbus_t *ctx); +MODBUS_API int modbus_set_debug(modbus_t *ctx, int flag); + +MODBUS_API const char *modbus_strerror(int errnum); + +MODBUS_API int modbus_read_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest); +MODBUS_API int modbus_read_input_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest); +MODBUS_API int modbus_read_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest); +MODBUS_API int +modbus_read_input_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest); +MODBUS_API int modbus_write_bit(modbus_t *ctx, int coil_addr, int status); +MODBUS_API int modbus_write_register(modbus_t *ctx, int reg_addr, const uint16_t value); +MODBUS_API int modbus_write_bits(modbus_t *ctx, int addr, int nb, const uint8_t *data); +MODBUS_API int +modbus_write_registers(modbus_t *ctx, int addr, int nb, const uint16_t *data); +MODBUS_API int +modbus_mask_write_register(modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask); +MODBUS_API int modbus_write_and_read_registers(modbus_t *ctx, + int write_addr, + int write_nb, + const uint16_t *src, + int read_addr, + int read_nb, + uint16_t *dest); +MODBUS_API int modbus_report_slave_id(modbus_t *ctx, int max_dest, uint8_t *dest); + +MODBUS_API modbus_mapping_t * +modbus_mapping_new_start_address(unsigned int start_bits, + unsigned int nb_bits, + unsigned int start_input_bits, + unsigned int nb_input_bits, + unsigned int start_registers, + unsigned int nb_registers, + unsigned int start_input_registers, + unsigned int nb_input_registers); + +MODBUS_API modbus_mapping_t *modbus_mapping_new(int nb_bits, + int nb_input_bits, + int nb_registers, + int nb_input_registers); +MODBUS_API void modbus_mapping_free(modbus_mapping_t *mb_mapping); + +MODBUS_API int +modbus_send_raw_request(modbus_t *ctx, const uint8_t *raw_req, int raw_req_length); + +MODBUS_API int modbus_receive(modbus_t *ctx, uint8_t *req); + +MODBUS_API int modbus_receive_confirmation(modbus_t *ctx, uint8_t *rsp); + +MODBUS_API int modbus_reply(modbus_t *ctx, + const uint8_t *req, + int req_length, + modbus_mapping_t *mb_mapping); +MODBUS_API int +modbus_reply_exception(modbus_t *ctx, const uint8_t *req, unsigned int exception_code); +MODBUS_API int modbus_enable_quirks(modbus_t *ctx, unsigned int quirks_mask); +MODBUS_API int modbus_disable_quirks(modbus_t *ctx, unsigned int quirks_mask); + +/** + * UTILS FUNCTIONS + **/ + +#define MODBUS_GET_HIGH_BYTE(data) (((data) >> 8) & 0xFF) +#define MODBUS_GET_LOW_BYTE(data) ((data) &0xFF) +#define MODBUS_GET_INT64_FROM_INT16(tab_int16, index) \ + (((int64_t) tab_int16[(index)] << 48) | ((int64_t) tab_int16[(index) + 1] << 32) | \ + ((int64_t) tab_int16[(index) + 2] << 16) | (int64_t) tab_int16[(index) + 3]) +#define MODBUS_GET_INT32_FROM_INT16(tab_int16, index) \ + (((int32_t) tab_int16[(index)] << 16) | (int32_t) tab_int16[(index) + 1]) +#define MODBUS_GET_INT16_FROM_INT8(tab_int8, index) \ + (((int16_t) tab_int8[(index)] << 8) | (int16_t) tab_int8[(index) + 1]) +#define MODBUS_SET_INT16_TO_INT8(tab_int8, index, value) \ + do { \ + ((int8_t *) (tab_int8))[(index)] = (int8_t) ((value) >> 8); \ + ((int8_t *) (tab_int8))[(index) + 1] = (int8_t) (value); \ + } while (0) +#define MODBUS_SET_INT32_TO_INT16(tab_int16, index, value) \ + do { \ + ((int16_t *) (tab_int16))[(index)] = (int16_t) ((value) >> 16); \ + ((int16_t *) (tab_int16))[(index) + 1] = (int16_t) (value); \ + } while (0) +#define MODBUS_SET_INT64_TO_INT16(tab_int16, index, value) \ + do { \ + ((int16_t *) (tab_int16))[(index)] = (int16_t) ((value) >> 48); \ + ((int16_t *) (tab_int16))[(index) + 1] = (int16_t) ((value) >> 32); \ + ((int16_t *) (tab_int16))[(index) + 2] = (int16_t) ((value) >> 16); \ + ((int16_t *) (tab_int16))[(index) + 3] = (int16_t) (value); \ + } while (0) + +MODBUS_API void modbus_set_bits_from_byte(uint8_t *dest, int idx, const uint8_t value); +MODBUS_API void modbus_set_bits_from_bytes(uint8_t *dest, + int idx, + unsigned int nb_bits, + const uint8_t *tab_byte); +MODBUS_API uint8_t modbus_get_byte_from_bits(const uint8_t *src, + int idx, + unsigned int nb_bits); +MODBUS_API float modbus_get_float(const uint16_t *src); +MODBUS_API float modbus_get_float_abcd(const uint16_t *src); +MODBUS_API float modbus_get_float_dcba(const uint16_t *src); +MODBUS_API float modbus_get_float_badc(const uint16_t *src); +MODBUS_API float modbus_get_float_cdab(const uint16_t *src); + +MODBUS_API void modbus_set_float(float f, uint16_t *dest); +MODBUS_API void modbus_set_float_abcd(float f, uint16_t *dest); +MODBUS_API void modbus_set_float_dcba(float f, uint16_t *dest); +MODBUS_API void modbus_set_float_badc(float f, uint16_t *dest); +MODBUS_API void modbus_set_float_cdab(float f, uint16_t *dest); + +#include "modbus-rtu.h" +#include "modbus-tcp.h" + +MODBUS_END_DECLS + +#endif /* MODBUS_H */ diff --git a/lib/libmodbus/lib/libmodbus.so b/lib/libmodbus/lib/libmodbus.so new file mode 100644 index 0000000000000000000000000000000000000000..6d70657501a158d1923fdda39cab1927f1d959f8 GIT binary patch literal 70416 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 cV|J7kk}vDZw`#VXc>