open_source / modbus

Browse Code »

Commit 500c015abdaf00ae2c91824050f119b0263c0288

Authored by Peter M. Groen 2022-06-01 12:13:03 +0200

1 parent c5fb1247

Setting up working version

.gitignore 0 → 100644

View file @500c015

+/submodules/

3rdparty/libmodbus/config.h 0 → 100644

View file @500c015

		1	+/* config.h. Generated from config.h.in by configure. */
		2	+/* config.h.in. Generated from configure.ac by autoheader. */
		3	+
		4	+/* Define to 1 if you have the <arpa/inet.h> header file. */
		5	+#define HAVE_ARPA_INET_H 1
		6	+
		7	+/* Define to 1 if you have the declaration of `TIOCSRS485', and to 0 if you
		8	+ don't. */
		9	+#define HAVE_DECL_TIOCSRS485 0
		10	+
		11	+/* Define to 1 if you have the declaration of `TIOCM_RTS', and to 0 if you
		12	+ don't. */
		13	+#define HAVE_DECL_TIOCM_RTS 0
		14	+
		15	+/* Define to 1 if you have the declaration of `__CYGWIN__', and to 0 if you
		16	+ don't. */
		17	+#define HAVE_DECL___CYGWIN__ 0
		18	+
		19	+/* Define to 1 if you have the <dlfcn.h> header file. */
		20	+#define HAVE_DLFCN_H 1
		21	+
		22	+/* Define to 1 if you have the <errno.h> header file. */
		23	+#define HAVE_ERRNO_H 1
		24	+
		25	+/* Define to 1 if you have the <fcntl.h> header file. */
		26	+#define HAVE_FCNTL_H 1
		27	+
		28	+/* Define to 1 if you have the `fork' function. */
		29	+#define HAVE_FORK 1
		30	+
		31	+/* Define to 1 if you have the `getaddrinfo' function. */
		32	+#define HAVE_GETADDRINFO 1
		33	+
		34	+/* Define to 1 if you have the `gettimeofday' function. */
		35	+#define HAVE_GETTIMEOFDAY 1
		36	+
		37	+/* Define to 1 if you have the `inet_ntoa' function. */
		38	+#define HAVE_INET_NTOA 1
		39	+
		40	+/* Define to 1 if you have the <inttypes.h> header file. */
		41	+#define HAVE_INTTYPES_H 1
		42	+
		43	+/* Define to 1 if you have the <limits.h> header file. */
		44	+#define HAVE_LIMITS_H 1
		45	+
		46	+/* Define to 1 if you have the <linux/serial.h> header file. */
		47	+#define HAVE_LINUX_SERIAL_H 1
		48	+
		49	+/* Define to 1 if you have the <memory.h> header file. */
		50	+#define HAVE_MEMORY_H 1
		51	+
		52	+/* Define to 1 if you have the `memset' function. */
		53	+#define HAVE_MEMSET 1
		54	+
		55	+/* Define to 1 if you have the <netdb.h> header file. */
		56	+#define HAVE_NETDB_H 1
		57	+
		58	+/* Define to 1 if you have the <netinet/in.h> header file. */
		59	+#define HAVE_NETINET_IN_H 1
		60	+
		61	+/* Define to 1 if you have the <netinet/tcp.h> header file. */
		62	+#define HAVE_NETINET_TCP_H 1
		63	+
		64	+/* Define to 1 if you have the `select' function. */
		65	+#define HAVE_SELECT 1
		66	+
		67	+/* Define to 1 if you have the `socket' function. */
		68	+#define HAVE_SOCKET 1
		69	+
		70	+/* Define to 1 if you have the <stdint.h> header file. */
		71	+#define HAVE_STDINT_H 1
		72	+
		73	+/* Define to 1 if you have the <stdlib.h> header file. */
		74	+#define HAVE_STDLIB_H 1
		75	+
		76	+/* Define to 1 if you have the `strerror' function. */
		77	+#define HAVE_STRERROR 1
		78	+
		79	+/* Define to 1 if you have the <strings.h> header file. */
		80	+#define HAVE_STRINGS_H 1
		81	+
		82	+/* Define to 1 if you have the <string.h> header file. */
		83	+#define HAVE_STRING_H 1
		84	+
		85	+/* Define to 1 if you have the `strlcpy' function. */
		86	+/* #undef HAVE_STRLCPY */
		87	+
		88	+/* Define to 1 if you have the <sys/ioctl.h> header file. */
		89	+#define HAVE_SYS_IOCTL_H 1
		90	+
		91	+/* Define to 1 if you have the <sys/socket.h> header file. */
		92	+#define HAVE_SYS_SOCKET_H 1
		93	+
		94	+/* Define to 1 if you have the <sys/stat.h> header file. */
		95	+#define HAVE_SYS_STAT_H 1
		96	+
		97	+/* Define to 1 if you have the <sys/time.h> header file. */
		98	+#define HAVE_SYS_TIME_H 1
		99	+
		100	+/* Define to 1 if you have the <sys/types.h> header file. */
		101	+#define HAVE_SYS_TYPES_H 1
		102	+
		103	+/* Define to 1 if you have the <termios.h> header file. */
		104	+#define HAVE_TERMIOS_H 1
		105	+
		106	+/* Define to 1 if you have the <time.h> header file. */
		107	+#define HAVE_TIME_H 1
		108	+
		109	+/* Define to 1 if you have the <unistd.h> header file. */
		110	+#define HAVE_UNISTD_H 1
		111	+
		112	+/* Define to 1 if you have the `vfork' function. */
		113	+#define HAVE_VFORK 1
		114	+
		115	+/* Define to 1 if you have the <vfork.h> header file. */
		116	+/* #undef HAVE_VFORK_H */
		117	+
		118	+/* Define to 1 if you have the <winsock2.h> header file. */
		119	+/* #undef HAVE_WINSOCK2_H */
		120	+
		121	+/* Define to 1 if `fork' works. */
		122	+#define HAVE_WORKING_FORK 1
		123	+
		124	+/* Define to 1 if `vfork' works. */
		125	+#define HAVE_WORKING_VFORK 1
		126	+
		127	+/* Define to the sub-directory in which libtool stores uninstalled libraries.
		128	+ */
		129	+#define LT_OBJDIR ".libs/"
		130	+
		131	+/* Name of package */
		132	+#define PACKAGE "libmodbus"
		133	+
		134	+/* Define to the address where bug reports for this package should be sent. */
		135	+#define PACKAGE_BUGREPORT "https://github.com/stephane/libmodbus/issues"
		136	+
		137	+/* Define to the full name of this package. */
		138	+#define PACKAGE_NAME "libmodbus"
		139	+
		140	+/* Define to the full name and version of this package. */
		141	+#define PACKAGE_STRING "libmodbus 3.1.0-1"
		142	+
		143	+/* Define to the one symbol short name of this package. */
		144	+#define PACKAGE_TARNAME "libmodbus"
		145	+
		146	+/* Define to the home page for this package. */
		147	+#define PACKAGE_URL ""
		148	+
		149	+/* Define to the version of this package. */
		150	+#define PACKAGE_VERSION "3.1.0-1"
		151	+
		152	+/* Define to 1 if you have the ANSI C header files. */
		153	+#define STDC_HEADERS 1
		154	+
		155	+/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
		156	+#define TIME_WITH_SYS_TIME 1
		157	+
		158	+/* Version number of package */
		159	+#define VERSION "3.1.0-1"
		160	+
		161	+/* Define to empty if `const' does not conform to ANSI C. */
		162	+/* #undef const */
		163	+
		164	+/* Define to `int' if <sys/types.h> does not define. */
		165	+/* #undef pid_t */
		166	+
		167	+/* Define to `unsigned int' if <sys/types.h> does not define. */
		168	+/* #undef size_t */
		169	+
		170	+/* Define as `fork' if `vfork' does not work. */
		171	+/* #undef vfork */

3rdparty/libmodbus/modbus-data.c 0 → 100644

View file @500c015

		1	+/*
		2	+ * Copyright © 2010-2014 Stéphane Raimbault <stephane.raimbault@gmail.com>
		3	+ *
		4	+ * SPDX-License-Identifier: LGPL-2.1+
		5	+ */
		6	+
		7	+#include <stdlib.h>
		8	+
		9	+#ifndef _MSC_VER
		10	+# include <stdint.h>
		11	+#else
		12	+# include "stdint.h"
		13	+#endif
		14	+
		15	+#include <string.h>
		16	+#include <assert.h>
		17	+
		18	+#if defined(_WIN32)
		19	+# include <winsock2.h>
		20	+#else
		21	+# include <arpa/inet.h>
		22	+#endif
		23	+
		24	+#include <config.h>
		25	+
		26	+#include "modbus.h"
		27	+
		28	+#if defined(HAVE_BYTESWAP_H)
		29	+# include <byteswap.h>
		30	+#endif
		31	+
		32	+#if defined(__APPLE__)
		33	+# include <libkern/OSByteOrder.h>
		34	+# define bswap_16 OSSwapInt16
		35	+# define bswap_32 OSSwapInt32
		36	+# define bswap_64 OSSwapInt64
		37	+#endif
		38	+
		39	+#if defined(__GNUC__)
		40	+# define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__ * 10)
		41	+# if GCC_VERSION >= 430
		42	+// Since GCC >= 4.30, GCC provides __builtin_bswapXX() alternatives so we switch to them
		43	+# undef bswap_32
		44	+# define bswap_32 __builtin_bswap32
		45	+# endif
		46	+#endif
		47	+
		48	+#if defined(_MSC_VER) && (_MSC_VER >= 1400)
		49	+# define bswap_32 _byteswap_ulong
		50	+# define bswap_16 _byteswap_ushort
		51	+#endif
		52	+
		53	+#if !defined(__CYGWIN__) && !defined(bswap_16)
		54	+# warning "Fallback on C functions for bswap_16"
		55	+static inline uint16_t bswap_16(uint16_t x)
		56	+{
		57	+ return (x >> 8) \| (x << 8);
		58	+}
		59	+#endif
		60	+
		61	+#if !defined(bswap_32)
		62	+# warning "Fallback on C functions for bswap_32"
		63	+static inline uint32_t bswap_32(uint32_t x)
		64	+{
		65	+ return (bswap_16(x & 0xffff) << 16) \| (bswap_16(x >> 16));
		66	+}
		67	+#endif
		68	+
		69	+/* Sets many bits from a single byte value (all 8 bits of the byte value are
		70	+ set) */
		71	+void modbus_set_bits_from_byte(uint8_t *dest, int idx, const uint8_t value)
		72	+{
		73	+ int i;
		74	+
		75	+ for (i=0; i < 8; i++) {
		76	+ dest[idx+i] = (value & (1 << i)) ? 1 : 0;
		77	+ }
		78	+}
		79	+
		80	+/* Sets many bits from a table of bytes (only the bits between idx and
		81	+ idx + nb_bits are set) */
		82	+void modbus_set_bits_from_bytes(uint8_t *dest, int idx, unsigned int nb_bits,
		83	+ const uint8_t *tab_byte)
		84	+{
		85	+ unsigned int i;
		86	+ int shift = 0;
		87	+
		88	+ for (i = idx; i < idx + nb_bits; i++) {
		89	+ dest[i] = tab_byte[(i - idx) / 8] & (1 << shift) ? 1 : 0;
		90	+ /* gcc doesn't like: shift = (++shift) % 8; */
		91	+ shift++;
		92	+ shift %= 8;
		93	+ }
		94	+}
		95	+
		96	+/* Gets the byte value from many bits.
		97	+ To obtain a full byte, set nb_bits to 8. */
		98	+uint8_t modbus_get_byte_from_bits(const uint8_t *src, int idx,
		99	+ unsigned int nb_bits)
		100	+{
		101	+ unsigned int i;
		102	+ uint8_t value = 0;
		103	+
		104	+ if (nb_bits > 8) {
		105	+ /* Assert is ignored if NDEBUG is set */
		106	+ assert(nb_bits < 8);
		107	+ nb_bits = 8;
		108	+ }
		109	+
		110	+ for (i=0; i < nb_bits; i++) {
		111	+ value \|= (src[idx+i] << i);
		112	+ }
		113	+
		114	+ return value;
		115	+}
		116	+
		117	+/* Get a float from 4 bytes (Modbus) without any conversion (ABCD) */
		118	+float modbus_get_float_abcd(const uint16_t *src)
		119	+{
		120	+ float f;
		121	+ uint32_t i;
		122	+
		123	+ i = ntohl(((uint32_t)src[0] << 16) + src[1]);
		124	+ memcpy(&f, &i, sizeof(float));
		125	+
		126	+ return f;
		127	+}
		128	+
		129	+/* Get a float from 4 bytes (Modbus) in inversed format (DCBA) */
		130	+float modbus_get_float_dcba(const uint16_t *src)
		131	+{
		132	+ float f;
		133	+ uint32_t i;
		134	+
		135	+ i = ntohl(bswap_32((((uint32_t)src[0]) << 16) + src[1]));
		136	+ memcpy(&f, &i, sizeof(float));
		137	+
		138	+ return f;
		139	+}
		140	+
		141	+/* Get a float from 4 bytes (Modbus) with swapped bytes (BADC) */
		142	+float modbus_get_float_badc(const uint16_t *src)
		143	+{
		144	+ float f;
		145	+ uint32_t i;
		146	+
		147	+ i = ntohl((uint32_t)(bswap_16(src[0]) << 16) + bswap_16(src[1]));
		148	+ memcpy(&f, &i, sizeof(float));
		149	+
		150	+ return f;
		151	+}
		152	+
		153	+/* Get a float from 4 bytes (Modbus) with swapped words (CDAB) */
		154	+float modbus_get_float_cdab(const uint16_t *src)
		155	+{
		156	+ float f;
		157	+ uint32_t i;
		158	+
		159	+ i = ntohl((((uint32_t)src[1]) << 16) + src[0]);
		160	+ memcpy(&f, &i, sizeof(float));
		161	+
		162	+ return f;
		163	+}
		164	+
		165	+/* DEPRECATED - Get a float from 4 bytes in sort of Modbus format */
		166	+float modbus_get_float(const uint16_t *src)
		167	+{
		168	+ float f;
		169	+ uint32_t i;
		170	+
		171	+ i = (((uint32_t)src[1]) << 16) + src[0];
		172	+ memcpy(&f, &i, sizeof(float));
		173	+
		174	+ return f;
		175	+}
		176	+
		177	+/* Set a float to 4 bytes for Modbus w/o any conversion (ABCD) */
		178	+void modbus_set_float_abcd(float f, uint16_t *dest)
		179	+{
		180	+ uint32_t i;
		181	+
		182	+ memcpy(&i, &f, sizeof(uint32_t));
		183	+ i = htonl(i);
		184	+ dest[0] = (uint16_t)(i >> 16);
		185	+ dest[1] = (uint16_t)i;
		186	+}
		187	+
		188	+/* Set a float to 4 bytes for Modbus with byte and word swap conversion (DCBA) */
		189	+void modbus_set_float_dcba(float f, uint16_t *dest)
		190	+{
		191	+ uint32_t i;
		192	+
		193	+ memcpy(&i, &f, sizeof(uint32_t));
		194	+ i = bswap_32(htonl(i));
		195	+ dest[0] = (uint16_t)(i >> 16);
		196	+ dest[1] = (uint16_t)i;
		197	+}
		198	+
		199	+/* Set a float to 4 bytes for Modbus with byte swap conversion (BADC) */
		200	+void modbus_set_float_badc(float f, uint16_t *dest)
		201	+{
		202	+ uint32_t i;
		203	+
		204	+ memcpy(&i, &f, sizeof(uint32_t));
		205	+ i = htonl(i);
		206	+ dest[0] = (uint16_t)bswap_16(i >> 16);
		207	+ dest[1] = (uint16_t)bswap_16(i & 0xFFFF);
		208	+}
		209	+
		210	+/* Set a float to 4 bytes for Modbus with word swap conversion (CDAB) */
		211	+void modbus_set_float_cdab(float f, uint16_t *dest)
		212	+{
		213	+ uint32_t i;
		214	+
		215	+ memcpy(&i, &f, sizeof(uint32_t));
		216	+ i = htonl(i);
		217	+ dest[0] = (uint16_t)i;
		218	+ dest[1] = (uint16_t)(i >> 16);
		219	+}
		220	+
		221	+/* DEPRECATED - Set a float to 4 bytes in a sort of Modbus format! */
		222	+void modbus_set_float(float f, uint16_t *dest)
		223	+{
		224	+ uint32_t i;
		225	+
		226	+ memcpy(&i, &f, sizeof(uint32_t));
		227	+ dest[0] = (uint16_t)i;
		228	+ dest[1] = (uint16_t)(i >> 16);
		229	+}

3rdparty/libmodbus/modbus-private.h 0 → 100644

View file @500c015

		1	+/*
		2	+ * Copyright © 2010-2012 Stéphane Raimbault <stephane.raimbault@gmail.com>
		3	+ *
		4	+ * SPDX-License-Identifier: LGPL-2.1+
		5	+ */
		6	+
		7	+#ifndef MODBUS_PRIVATE_H
		8	+#define MODBUS_PRIVATE_H
		9	+
		10	+#ifndef _MSC_VER
		11	+# include <stdint.h>
		12	+# include <sys/time.h>
		13	+#else
		14	+# include "stdint.h"
		15	+# include <time.h>
		16	+typedef int ssize_t;
		17	+#endif
		18	+#include <sys/types.h>
		19	+#include <config.h>
		20	+
		21	+#include "modbus.h"
		22	+
		23	+MODBUS_BEGIN_DECLS
		24	+
		25	+/* It's not really the minimal length (the real one is report slave ID
		26	+ * in RTU (4 bytes)) but it's a convenient size to use in RTU or TCP
		27	+ * communications to read many values or write a single one.
		28	+ * Maximum between :
		29	+ * - HEADER_LENGTH_TCP (7) + function (1) + address (2) + number (2)
		30	+ * - HEADER_LENGTH_RTU (1) + function (1) + address (2) + number (2) + CRC (2)
		31	+ */
		32	+#define _MIN_REQ_LENGTH 12
		33	+
		34	+#define _REPORT_SLAVE_ID 180
		35	+
		36	+#define _MODBUS_EXCEPTION_RSP_LENGTH 5
		37	+
		38	+/* Timeouts in microsecond (0.5 s) */
		39	+#define _RESPONSE_TIMEOUT 500000
		40	+#define _BYTE_TIMEOUT 500000
		41	+
		42	+typedef enum {
		43	+ _MODBUS_BACKEND_TYPE_RTU=0,
		44	+ _MODBUS_BACKEND_TYPE_TCP
		45	+} modbus_backend_type_t;
		46	+
		47	+/*
		48	+ * ---------- Request Indication ----------
		49	+ * \| Client \| ---------------------->\| Server \|
		50	+ * ---------- Confirmation Response ----------
		51	+ */
		52	+typedef enum {
		53	+ /* Request message on the server side */
		54	+ MSG_INDICATION,
		55	+ /* Request message on the client side */
		56	+ MSG_CONFIRMATION
		57	+} msg_type_t;
		58	+
		59	+/* This structure reduces the number of params in functions and so
		60	+ * optimizes the speed of execution (~ 37%). */
		61	+typedef struct _sft {
		62	+ int slave;
		63	+ int function;
		64	+ int t_id;
		65	+} sft_t;
		66	+
		67	+typedef struct _modbus_backend {
		68	+ unsigned int backend_type;
		69	+ unsigned int header_length;
		70	+ unsigned int checksum_length;
		71	+ unsigned int max_adu_length;
		72	+ int (set_slave) (modbus_t ctx, int slave);
		73	+ int (build_request_basis) (modbus_t ctx, int function, int addr,
		74	+ int nb, uint8_t *req);
		75	+ int (build_response_basis) (sft_t sft, uint8_t *rsp);
		76	+ int (prepare_response_tid) (const uint8_t req, int *req_length);
		77	+ int (send_msg_pre) (uint8_t req, int req_length);
		78	+ ssize_t (send) (modbus_t ctx, const uint8_t *req, int req_length);
		79	+ int (receive) (modbus_t ctx, uint8_t *req);
		80	+ ssize_t (recv) (modbus_t ctx, uint8_t *rsp, int rsp_length);
		81	+ int (check_integrity) (modbus_t ctx, uint8_t *msg,
		82	+ const int msg_length);
		83	+ int (pre_check_confirmation) (modbus_t ctx, const uint8_t *req,
		84	+ const uint8_t *rsp, int rsp_length);
		85	+ int (connect) (modbus_t ctx);
		86	+ void (close) (modbus_t ctx);
		87	+ int (flush) (modbus_t ctx);
		88	+ int (select) (modbus_t ctx, fd_set rset, struct timeval tv, int msg_length);
		89	+ void (free) (modbus_t ctx);
		90	+} modbus_backend_t;
		91	+
		92	+struct _modbus {
		93	+ /* Slave address */
		94	+ int slave;
		95	+ /* Socket or file descriptor */
		96	+ int s;
		97	+ int debug;
		98	+ int error_recovery;
		99	+ struct timeval response_timeout;
		100	+ struct timeval byte_timeout;
		101	+ const modbus_backend_t *backend;
		102	+ void *backend_data;
		103	+};
		104	+
		105	+void _modbus_init_common(modbus_t *ctx);
		106	+void _error_print(modbus_t ctx, const char context);
		107	+int _modbus_receive_msg(modbus_t ctx, uint8_t msg, msg_type_t msg_type);
		108	+
		109	+#ifndef HAVE_STRLCPY
		110	+size_t strlcpy(char dest, const char src, size_t dest_size);
		111	+#endif
		112	+
		113	+MODBUS_END_DECLS
		114	+
		115	+#endif /* MODBUS_PRIVATE_H */

3rdparty/libmodbus/modbus-rtu-private.h 0 → 100644

View file @500c015

		1	+/*
		2	+ * Copyright © 2001-2011 Stéphane Raimbault <stephane.raimbault@gmail.com>
		3	+ *
		4	+ * SPDX-License-Identifier: LGPL-2.1+
		5	+ */
		6	+
		7	+#ifndef MODBUS_RTU_PRIVATE_H
		8	+#define MODBUS_RTU_PRIVATE_H
		9	+
		10	+#ifndef _MSC_VER
		11	+#include <stdint.h>
		12	+#else
		13	+#include "stdint.h"
		14	+#endif
		15	+
		16	+#if defined(_WIN32)
		17	+#include <windows.h>
		18	+#else
		19	+#include <termios.h>
		20	+#endif
		21	+
		22	+#define _MODBUS_RTU_HEADER_LENGTH 1
		23	+#define _MODBUS_RTU_PRESET_REQ_LENGTH 6
		24	+#define _MODBUS_RTU_PRESET_RSP_LENGTH 2
		25	+
		26	+#define _MODBUS_RTU_CHECKSUM_LENGTH 2
		27	+
		28	+#if defined(_WIN32)
		29	+#if !defined(ENOTSUP)
		30	+#define ENOTSUP WSAEOPNOTSUPP
		31	+#endif
		32	+
		33	+/* WIN32: struct containing serial handle and a receive buffer */
		34	+#define PY_BUF_SIZE 512
		35	+struct win32_ser {
		36	+ /* File handle */
		37	+ HANDLE fd;
		38	+ /* Receive buffer */
		39	+ uint8_t buf[PY_BUF_SIZE];
		40	+ /* Received chars */
		41	+ DWORD n_bytes;
		42	+};
		43	+#endif /* _WIN32 */
		44	+
		45	+typedef struct _modbus_rtu {
		46	+ /* Device: "/dev/ttyS0", "/dev/ttyUSB0" or "/dev/tty.USA19" on Mac OS X. /
		47	+ char *device;
		48	+ /* Bauds: 9600, 19200, 57600, 115200, etc */
		49	+ int baud;
		50	+ /* Data bit */
		51	+ uint8_t data_bit;
		52	+ /* Stop bit */
		53	+ uint8_t stop_bit;
		54	+ /* Parity: 'N', 'O', 'E' */
		55	+ char parity;
		56	+#if defined(_WIN32)
		57	+ struct win32_ser w_ser;
		58	+ DCB old_dcb;
		59	+#else
		60	+ /* Save old termios settings */
		61	+ struct termios old_tios;
		62	+#endif
		63	+#if HAVE_DECL_TIOCSRS485
		64	+ int serial_mode;
		65	+#endif
		66	+//*Not part of libmodbus - added for QModMaster*//
		67	+#if defined(_WIN32) \|\| HAVE_DECL_TIOCM_RTS
		68	+ int rts;
		69	+ int rts_delay;
		70	+ int onebyte_time;
		71	+ void (set_rts) (modbus_t ctx, int on);
		72	+#endif
		73	+ /* To handle many slaves on the same link */
		74	+ int confirmation_to_ignore;
		75	+} modbus_rtu_t;
		76	+
		77	+#endif /* MODBUS_RTU_PRIVATE_H */

3rdparty/libmodbus/modbus-rtu.c 0 → 100644

View file @500c015

		1	+/*
		2	+ * Copyright © 2001-2011 Stéphane Raimbault <stephane.raimbault@gmail.com>
		3	+ *
		4	+ * SPDX-License-Identifier: LGPL-2.1+
		5	+ */
		6	+
		7	+#include <stdio.h>
		8	+#include <stdlib.h>
		9	+#include <errno.h>
		10	+#include <fcntl.h>
		11	+#include <string.h>
		12	+#ifndef _MSC_VER
		13	+#include <unistd.h>
		14	+#endif
		15	+#include <assert.h>
		16	+
		17	+#include "modbus-private.h"
		18	+
		19	+#include "modbus-rtu.h"
		20	+#include "modbus-rtu-private.h"
		21	+
		22	+#if HAVE_DECL_TIOCSRS485 \|\| HAVE_DECL_TIOCM_RTS
		23	+#include <sys/ioctl.h>
		24	+#endif
		25	+
		26	+#if HAVE_DECL_TIOCSRS485
		27	+#include <linux/serial.h>
		28	+#endif
		29	+
		30	+/* Table of CRC values for high-order byte */
		31	+static const uint8_t table_crc_hi[] = {
		32	+ 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
		33	+ 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
		34	+ 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
		35	+ 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
		36	+ 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
		37	+ 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
		38	+ 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
		39	+ 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
		40	+ 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
		41	+ 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
		42	+ 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
		43	+ 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
		44	+ 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
		45	+ 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
		46	+ 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
		47	+ 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
		48	+ 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
		49	+ 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
		50	+ 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
		51	+ 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
		52	+ 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
		53	+ 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
		54	+ 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
		55	+ 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
		56	+ 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
		57	+ 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40
		58	+};
		59	+
		60	+/* Table of CRC values for low-order byte */
		61	+static const uint8_t table_crc_lo[] = {
		62	+ 0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06,
		63	+ 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD,
		64	+ 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
		65	+ 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
		66	+ 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4,
		67	+ 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
		68	+ 0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3,
		69	+ 0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
		70	+ 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
		71	+ 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29,
		72	+ 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED,
		73	+ 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
		74	+ 0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60,
		75	+ 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67,
		76	+ 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
		77	+ 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
		78	+ 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E,
		79	+ 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
		80	+ 0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71,
		81	+ 0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
		82	+ 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
		83	+ 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B,
		84	+ 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B,
		85	+ 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
		86	+ 0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42,
		87	+ 0x43, 0x83, 0x41, 0x81, 0x80, 0x40
		88	+};
		89	+
		90	+/* Define the slave ID of the remote device to talk in master mode or set the
		91	+ * internal slave ID in slave mode */
		92	+static int _modbus_set_slave(modbus_t *ctx, int slave)
		93	+{
		94	+ /* Broadcast address is 0 (MODBUS_BROADCAST_ADDRESS) */
		95	+ if (slave >= 0 && slave <= 247) {
		96	+ ctx->slave = slave;
		97	+ } else {
		98	+ errno = EINVAL;
		99	+ return -1;
		100	+ }
		101	+
		102	+ return 0;
		103	+}
		104	+
		105	+/* Builds a RTU request header */
		106	+static int _modbus_rtu_build_request_basis(modbus_t *ctx, int function,
		107	+ int addr, int nb,
		108	+ uint8_t *req)
		109	+{
		110	+ assert(ctx->slave != -1);
		111	+ req[0] = ctx->slave;
		112	+ req[1] = function;
		113	+ req[2] = addr >> 8;
		114	+ req[3] = addr & 0x00ff;
		115	+ req[4] = nb >> 8;
		116	+ req[5] = nb & 0x00ff;
		117	+
		118	+ return _MODBUS_RTU_PRESET_REQ_LENGTH;
		119	+}
		120	+
		121	+/* Builds a RTU response header */
		122	+static int _modbus_rtu_build_response_basis(sft_t sft, uint8_t rsp)
		123	+{
		124	+ /* In this case, the slave is certainly valid because a check is already
		125	+ * done in _modbus_rtu_listen */
		126	+ rsp[0] = sft->slave;
		127	+ rsp[1] = sft->function;
		128	+
		129	+ return _MODBUS_RTU_PRESET_RSP_LENGTH;
		130	+}
		131	+
		132	+static uint16_t crc16(uint8_t *buffer, uint16_t buffer_length)
		133	+{
		134	+ uint8_t crc_hi = 0xFF; /* high CRC byte initialized */
		135	+ uint8_t crc_lo = 0xFF; /* low CRC byte initialized */
		136	+ unsigned int i; /* will index into CRC lookup */
		137	+
		138	+ /* pass through message buffer */
		139	+ while (buffer_length--) {
		140	+ i = crc_hi ^ buffer++; / calculate the CRC */
		141	+ crc_hi = crc_lo ^ table_crc_hi[i];
		142	+ crc_lo = table_crc_lo[i];
		143	+ }
		144	+
		145	+ return (crc_hi << 8 \| crc_lo);
		146	+}
		147	+
		148	+static int _modbus_rtu_prepare_response_tid(const uint8_t req, int req_length)
		149	+{
		150	+ (*req_length) -= _MODBUS_RTU_CHECKSUM_LENGTH;
		151	+ /* No TID */
		152	+ return 0;
		153	+}
		154	+
		155	+static int _modbus_rtu_send_msg_pre(uint8_t *req, int req_length)
		156	+{
		157	+ uint16_t crc = crc16(req, req_length);
		158	+ req[req_length++] = crc >> 8;
		159	+ req[req_length++] = crc & 0x00FF;
		160	+
		161	+ return req_length;
		162	+}
		163	+
		164	+#if defined(_WIN32)
		165	+
		166	+/* This simple implementation is sort of a substitute of the select() call,
		167	+ * working this way: the win32_ser_select() call tries to read some data from
		168	+ * the serial port, setting the timeout as the select() call would. Data read is
		169	+ * stored into the receive buffer, that is then consumed by the win32_ser_read()
		170	+ * call. So win32_ser_select() does both the event waiting and the reading,
		171	+ * while win32_ser_read() only consumes the receive buffer.
		172	+ */
		173	+
		174	+static void win32_ser_init(struct win32_ser *ws)
		175	+{
		176	+ /* Clear everything */
		177	+ memset(ws, 0x00, sizeof(struct win32_ser));
		178	+
		179	+ /* Set file handle to invalid */
		180	+ ws->fd = INVALID_HANDLE_VALUE;
		181	+}
		182	+
		183	+/* FIXME Try to remove length_to_read -> max_len argument, only used by win32 */
		184	+static int win32_ser_select(struct win32_ser *ws, int max_len,
		185	+ const struct timeval *tv)
		186	+{
		187	+ COMMTIMEOUTS comm_to;
		188	+ unsigned int msec = 0;
		189	+
		190	+ /* Check if some data still in the buffer to be consumed */
		191	+ if (ws->n_bytes > 0) {
		192	+ return 1;
		193	+ }
		194	+
		195	+ /* Setup timeouts like select() would do.
		196	+ FIXME Please someone on Windows can look at this?
		197	+ Does it possible to use WaitCommEvent?
		198	+ When tv is NULL, MAXDWORD isn't infinite!
		199	+ */
		200	+ if (tv == NULL) {
		201	+ msec = MAXDWORD;
		202	+ } else {
		203	+ msec = tv->tv_sec * 1000 + tv->tv_usec / 1000;
		204	+ if (msec < 1)
		205	+ msec = 1;
		206	+ }
		207	+
		208	+ comm_to.ReadIntervalTimeout = msec;
		209	+ comm_to.ReadTotalTimeoutMultiplier = 0;
		210	+ comm_to.ReadTotalTimeoutConstant = msec;
		211	+ comm_to.WriteTotalTimeoutMultiplier = 0;
		212	+ comm_to.WriteTotalTimeoutConstant = 1000;
		213	+ SetCommTimeouts(ws->fd, &comm_to);
		214	+
		215	+ /* Read some bytes */
		216	+ if ((max_len > PY_BUF_SIZE) \|\| (max_len < 0)) {
		217	+ max_len = PY_BUF_SIZE;
		218	+ }
		219	+
		220	+ if (ReadFile(ws->fd, &ws->buf, max_len, &ws->n_bytes, NULL)) {
		221	+ /* Check if some bytes available */
		222	+ if (ws->n_bytes > 0) {
		223	+ /* Some bytes read */
		224	+ return 1;
		225	+ } else {
		226	+ /* Just timed out */
		227	+ return 0;
		228	+ }
		229	+ } else {
		230	+ /* Some kind of error */
		231	+ return -1;
		232	+ }
		233	+}
		234	+
		235	+static int win32_ser_read(struct win32_ser ws, uint8_t p_msg,
		236	+ unsigned int max_len)
		237	+{
		238	+ unsigned int n = ws->n_bytes;
		239	+
		240	+ if (max_len < n) {
		241	+ n = max_len;
		242	+ }
		243	+
		244	+ if (n > 0) {
		245	+ memcpy(p_msg, ws->buf, n);
		246	+ }
		247	+
		248	+ ws->n_bytes -= n;
		249	+
		250	+ return n;
		251	+}
		252	+#endif
		253	+
		254	+#if HAVE_DECL_TIOCM_RTS
		255	+static void _modbus_rtu_ioctl_rts(modbus_t *ctx, int on)
		256	+{
		257	+ int fd = ctx->s;
		258	+ int flags;
		259	+
		260	+ ioctl(fd, TIOCMGET, &flags);
		261	+ if (on) {
		262	+ flags \|= TIOCM_RTS;
		263	+ } else {
		264	+ flags &= ~TIOCM_RTS;
		265	+ }
		266	+ ioctl(fd, TIOCMSET, &flags);
		267	+}
		268	+#endif
		269	+
		270	+static ssize_t _modbus_rtu_send(modbus_t ctx, const uint8_t req, int req_length)
		271	+{
		272	+#if defined(_WIN32)
		273	+ modbus_rtu_t *ctx_rtu = ctx->backend_data;
		274	+ DWORD n_bytes = 0;
		275	+ return (WriteFile(ctx_rtu->w_ser.fd, req, req_length, &n_bytes, NULL)) ? (ssize_t)n_bytes : -1;
		276	+#else
		277	+#if HAVE_DECL_TIOCM_RTS
		278	+ modbus_rtu_t *ctx_rtu = ctx->backend_data;
		279	+ if (ctx_rtu->rts != MODBUS_RTU_RTS_NONE) {
		280	+ ssize_t size;
		281	+
		282	+ if (ctx->debug) {
		283	+ fprintf(stderr, "Sending request using RTS signal\n");
		284	+ }
		285	+
		286	+ ctx_rtu->set_rts(ctx, ctx_rtu->rts == MODBUS_RTU_RTS_UP);
		287	+ usleep(ctx_rtu->rts_delay);
		288	+
		289	+ size = write(ctx->s, req, req_length);
		290	+
		291	+ usleep(ctx_rtu->onebyte_time * req_length + ctx_rtu->rts_delay);
		292	+ ctx_rtu->set_rts(ctx, ctx_rtu->rts != MODBUS_RTU_RTS_UP);
		293	+
		294	+ return size;
		295	+ } else {
		296	+#endif
		297	+ return write(ctx->s, req, req_length);
		298	+#if HAVE_DECL_TIOCM_RTS
		299	+ }
		300	+#endif
		301	+#endif
		302	+}
		303	+
		304	+static int _modbus_rtu_receive(modbus_t ctx, uint8_t req)
		305	+{
		306	+ int rc;
		307	+ modbus_rtu_t *ctx_rtu = ctx->backend_data;
		308	+
		309	+ if (ctx_rtu->confirmation_to_ignore) {
		310	+ _modbus_receive_msg(ctx, req, MSG_CONFIRMATION);
		311	+ /* Ignore errors and reset the flag */
		312	+ ctx_rtu->confirmation_to_ignore = FALSE;
		313	+ rc = 0;
		314	+ if (ctx->debug) {
		315	+ printf("Confirmation to ignore\n");
		316	+ }
		317	+ } else {
		318	+ rc = _modbus_receive_msg(ctx, req, MSG_INDICATION);
		319	+ if (rc == 0) {
		320	+ /* The next expected message is a confirmation to ignore */
		321	+ ctx_rtu->confirmation_to_ignore = TRUE;
		322	+ }
		323	+ }
		324	+ return rc;
		325	+}
		326	+
		327	+static ssize_t _modbus_rtu_recv(modbus_t ctx, uint8_t rsp, int rsp_length)
		328	+{
		329	+#if defined(_WIN32)
		330	+ return win32_ser_read(&((modbus_rtu_t *)ctx->backend_data)->w_ser, rsp, rsp_length);
		331	+#else
		332	+ return read(ctx->s, rsp, rsp_length);
		333	+#endif
		334	+}
		335	+
		336	+static int _modbus_rtu_flush(modbus_t *);
		337	+
		338	+static int _modbus_rtu_pre_check_confirmation(modbus_t ctx, const uint8_t req,
		339	+ const uint8_t *rsp, int rsp_length)
		340	+{
		341	+ /* Check responding slave is the slave we requested (except for broacast
		342	+ * request) */
		343	+ if (req[0] != rsp[0] && req[0] != MODBUS_BROADCAST_ADDRESS) {
		344	+ if (ctx->debug) {
		345	+ fprintf(stderr,
		346	+ "The responding slave %d isn't the requested slave %d\n",
		347	+ rsp[0], req[0]);
		348	+ }
		349	+ errno = EMBBADSLAVE;
		350	+ return -1;
		351	+ } else {
		352	+ return 0;
		353	+ }
		354	+}
		355	+
		356	+/* The check_crc16 function shall return 0 is the message is ignored and the
		357	+ message length if the CRC is valid. Otherwise it shall return -1 and set
		358	+ errno to EMBADCRC. */
		359	+static int _modbus_rtu_check_integrity(modbus_t ctx, uint8_t msg,
		360	+ const int msg_length)
		361	+{
		362	+ uint16_t crc_calculated;
		363	+ uint16_t crc_received;
		364	+ int slave = msg[0];
		365	+
		366	+ /* Filter on the Modbus unit identifier (slave) in RTU mode to avoid useless
		367	+ * CRC computing. */
		368	+ if (slave != ctx->slave && slave != MODBUS_BROADCAST_ADDRESS) {
		369	+ if (ctx->debug) {
		370	+ printf("Request for slave %d ignored (not %d)\n", slave, ctx->slave);
		371	+ }
		372	+ /* Following call to check_confirmation handles this error */
		373	+ return 0;
		374	+ }
		375	+
		376	+ crc_calculated = crc16(msg, msg_length - 2);
		377	+ crc_received = (msg[msg_length - 2] << 8) \| msg[msg_length - 1];
		378	+
		379	+ /* Check CRC of msg */
		380	+ if (crc_calculated == crc_received) {
		381	+ return msg_length;
		382	+ } else {
		383	+ if (ctx->debug) {
		384	+ fprintf(stderr, "ERROR CRC received 0x%0X != CRC calculated 0x%0X\n",
		385	+ crc_received, crc_calculated);
		386	+ }
		387	+
		388	+ if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) {
		389	+ _modbus_rtu_flush(ctx);
		390	+ }
		391	+ errno = EMBBADCRC;
		392	+ return -1;
		393	+ }
		394	+}
		395	+
		396	+/* Sets up a serial port for RTU communications */
		397	+static int _modbus_rtu_connect(modbus_t *ctx)
		398	+{
		399	+#if defined(_WIN32)
		400	+ DCB dcb;
		401	+#else
		402	+ struct termios tios;
		403	+ speed_t speed;
		404	+ int flags;
		405	+#endif
		406	+ modbus_rtu_t *ctx_rtu = ctx->backend_data;
		407	+
		408	+ if (ctx->debug) {
		409	+ printf("Opening %s at %d bauds (%c, %d, %d)\n",
		410	+ ctx_rtu->device, ctx_rtu->baud, ctx_rtu->parity,
		411	+ ctx_rtu->data_bit, ctx_rtu->stop_bit);
		412	+ }
		413	+
		414	+#if defined(_WIN32)
		415	+ /* Some references here:
		416	+ * http://msdn.microsoft.com/en-us/library/aa450602.aspx
		417	+ */
		418	+ win32_ser_init(&ctx_rtu->w_ser);
		419	+
		420	+ /* ctx_rtu->device should contain a string like "COMxx:" xx being a decimal
		421	+ * number */
		422	+ ctx_rtu->w_ser.fd = CreateFileA(ctx_rtu->device,
		423	+ GENERIC_READ \| GENERIC_WRITE,
		424	+ 0,
		425	+ NULL,
		426	+ OPEN_EXISTING,
		427	+ 0,
		428	+ NULL);
		429	+
		430	+ /* Error checking */
		431	+ if (ctx_rtu->w_ser.fd == INVALID_HANDLE_VALUE) {
		432	+ if (ctx->debug) {
		433	+ fprintf(stderr, "ERROR Can't open the device %s (LastError %d)\n",
		434	+ ctx_rtu->device, (int)GetLastError());
		435	+ }
		436	+ return -1;
		437	+ }
		438	+
		439	+ /* Save params */
		440	+ ctx_rtu->old_dcb.DCBlength = sizeof(DCB);
		441	+ if (!GetCommState(ctx_rtu->w_ser.fd, &ctx_rtu->old_dcb)) {
		442	+ if (ctx->debug) {
		443	+ fprintf(stderr, "ERROR Error getting configuration (LastError %d)\n",
		444	+ (int)GetLastError());
		445	+ }
		446	+ CloseHandle(ctx_rtu->w_ser.fd);
		447	+ ctx_rtu->w_ser.fd = INVALID_HANDLE_VALUE;
		448	+ return -1;
		449	+ }
		450	+
		451	+ /* Build new configuration (starting from current settings) */
		452	+ dcb = ctx_rtu->old_dcb;
		453	+
		454	+ /* Speed setting */
		455	+ switch (ctx_rtu->baud) {
		456	+ case 110:
		457	+ dcb.BaudRate = CBR_110;
		458	+ break;
		459	+ case 300:
		460	+ dcb.BaudRate = CBR_300;
		461	+ break;
		462	+ case 600:
		463	+ dcb.BaudRate = CBR_600;
		464	+ break;
		465	+ case 1200:
		466	+ dcb.BaudRate = CBR_1200;
		467	+ break;
		468	+ case 2400:
		469	+ dcb.BaudRate = CBR_2400;
		470	+ break;
		471	+ case 4800:
		472	+ dcb.BaudRate = CBR_4800;
		473	+ break;
		474	+ case 9600:
		475	+ dcb.BaudRate = CBR_9600;
		476	+ break;
		477	+ case 14400:
		478	+ dcb.BaudRate = CBR_14400;
		479	+ break;
		480	+ case 19200:
		481	+ dcb.BaudRate = CBR_19200;
		482	+ break;
		483	+ case 38400:
		484	+ dcb.BaudRate = CBR_38400;
		485	+ break;
		486	+ case 57600:
		487	+ dcb.BaudRate = CBR_57600;
		488	+ break;
		489	+ case 115200:
		490	+ dcb.BaudRate = CBR_115200;
		491	+ break;
		492	+ case 230400:
		493	+ /* CBR_230400 - not defined */
		494	+ dcb.BaudRate = 230400;
		495	+ break;
		496	+ case 250000:
		497	+ dcb.BaudRate = 250000;
		498	+ break;
		499	+ case 460800:
		500	+ dcb.BaudRate = 460800;
		501	+ break;
		502	+ case 500000:
		503	+ dcb.BaudRate = 500000;
		504	+ break;
		505	+ case 921600:
		506	+ dcb.BaudRate = 921600;
		507	+ break;
		508	+ case 1000000:
		509	+ dcb.BaudRate = 1000000;
		510	+ break;
		511	+ default:
		512	+ dcb.BaudRate = CBR_9600;
		513	+ if (ctx->debug) {
		514	+ fprintf(stderr, "WARNING Unknown baud rate %d for %s (B9600 used)\n",
		515	+ ctx_rtu->baud, ctx_rtu->device);
		516	+ }
		517	+ }
		518	+
		519	+ /* Data bits */
		520	+ switch (ctx_rtu->data_bit) {
		521	+ case 5:
		522	+ dcb.ByteSize = 5;
		523	+ break;
		524	+ case 6:
		525	+ dcb.ByteSize = 6;
		526	+ break;
		527	+ case 7:
		528	+ dcb.ByteSize = 7;
		529	+ break;
		530	+ case 8:
		531	+ default:
		532	+ dcb.ByteSize = 8;
		533	+ break;
		534	+ }
		535	+
		536	+ /* Stop bits */
		537	+ if (ctx_rtu->stop_bit == 1)
		538	+ dcb.StopBits = ONESTOPBIT;
		539	+ else /* 2 */
		540	+ dcb.StopBits = TWOSTOPBITS;
		541	+
		542	+ /* Parity */
		543	+ if (ctx_rtu->parity == 'N') {
		544	+ dcb.Parity = NOPARITY;
		545	+ dcb.fParity = FALSE;
		546	+ } else if (ctx_rtu->parity == 'E') {
		547	+ dcb.Parity = EVENPARITY;
		548	+ dcb.fParity = TRUE;
		549	+ } else {
		550	+ /* odd */
		551	+ dcb.Parity = ODDPARITY;
		552	+ dcb.fParity = TRUE;
		553	+ }
		554	+
		555	+ /* Hardware handshaking left as default settings retrieved */
		556	+
		557	+ /* No software handshaking */
		558	+ dcb.fTXContinueOnXoff = TRUE;
		559	+ dcb.fOutX = FALSE;
		560	+ dcb.fInX = FALSE;
		561	+
		562	+ /* Binary mode (it's the only supported on Windows anyway) */
		563	+ dcb.fBinary = TRUE;
		564	+
		565	+ /* Don't want errors to be blocking */
		566	+ dcb.fAbortOnError = FALSE;
		567	+
		568	+ //*Not part of libmodbus - added for QModMaster*//
		569	+ dcb.fRtsControl = ctx_rtu->rts;
		570	+
		571	+ /* Setup port */
		572	+ if (!SetCommState(ctx_rtu->w_ser.fd, &dcb)) {
		573	+ if (ctx->debug) {
		574	+ fprintf(stderr, "ERROR Error setting new configuration (LastError %d)\n",
		575	+ (int)GetLastError());
		576	+ }
		577	+ CloseHandle(ctx_rtu->w_ser.fd);
		578	+ ctx_rtu->w_ser.fd = INVALID_HANDLE_VALUE;
		579	+ return -1;
		580	+ }
		581	+#else
		582	+ /* The O_NOCTTY flag tells UNIX that this program doesn't want
		583	+ to be the "controlling terminal" for that port. If you
		584	+ don't specify this then any input (such as keyboard abort
		585	+ signals and so forth) will affect your process
		586	+
		587	+ Timeouts are ignored in canonical input mode or when the
		588	+ NDELAY option is set on the file via open or fcntl */
		589	+ flags = O_RDWR \| O_NOCTTY \| O_NDELAY \| O_EXCL;
		590	+#ifdef O_CLOEXEC
		591	+ flags \|= O_CLOEXEC;
		592	+#endif
		593	+
		594	+ ctx->s = open(ctx_rtu->device, flags);
		595	+ if (ctx->s == -1) {
		596	+ if (ctx->debug) {
		597	+ fprintf(stderr, "ERROR Can't open the device %s (%s)\n",
		598	+ ctx_rtu->device, strerror(errno));
		599	+ }
		600	+ return -1;
		601	+ }
		602	+
		603	+ /* Save */
		604	+ tcgetattr(ctx->s, &ctx_rtu->old_tios);
		605	+
		606	+ memset(&tios, 0, sizeof(struct termios));
		607	+
		608	+ /* C_ISPEED Input baud (new interface)
		609	+ C_OSPEED Output baud (new interface)
		610	+ */
		611	+ switch (ctx_rtu->baud) {
		612	+ case 110:
		613	+ speed = B110;
		614	+ break;
		615	+ case 300:
		616	+ speed = B300;
		617	+ break;
		618	+ case 600:
		619	+ speed = B600;
		620	+ break;
		621	+ case 1200:
		622	+ speed = B1200;
		623	+ break;
		624	+ case 2400:
		625	+ speed = B2400;
		626	+ break;
		627	+ case 4800:
		628	+ speed = B4800;
		629	+ break;
		630	+ case 9600:
		631	+ speed = B9600;
		632	+ break;
		633	+ case 19200:
		634	+ speed = B19200;
		635	+ break;
		636	+ case 38400:
		637	+ speed = B38400;
		638	+ break;
		639	+#ifdef B57600
		640	+ case 57600:
		641	+ speed = B57600;
		642	+ break;
		643	+#endif
		644	+#ifdef B115200
		645	+ case 115200:
		646	+ speed = B115200;
		647	+ break;
		648	+#endif
		649	+#ifdef B230400
		650	+ case 230400:
		651	+ speed = B230400;
		652	+ break;
		653	+#endif
		654	+#ifdef B460800
		655	+ case 460800:
		656	+ speed = B460800;
		657	+ break;
		658	+#endif
		659	+#ifdef B500000
		660	+ case 500000:
		661	+ speed = B500000;
		662	+ break;
		663	+#endif
		664	+#ifdef B576000
		665	+ case 576000:
		666	+ speed = B576000;
		667	+ break;
		668	+#endif
		669	+#ifdef B921600
		670	+ case 921600:
		671	+ speed = B921600;
		672	+ break;
		673	+#endif
		674	+#ifdef B1000000
		675	+ case 1000000:
		676	+ speed = B1000000;
		677	+ break;
		678	+#endif
		679	+#ifdef B1152000
		680	+ case 1152000:
		681	+ speed = B1152000;
		682	+ break;
		683	+#endif
		684	+#ifdef B1500000
		685	+ case 1500000:
		686	+ speed = B1500000;
		687	+ break;
		688	+#endif
		689	+#ifdef B2500000
		690	+ case 2500000:
		691	+ speed = B2500000;
		692	+ break;
		693	+#endif
		694	+#ifdef B3000000
		695	+ case 3000000:
		696	+ speed = B3000000;
		697	+ break;
		698	+#endif
		699	+#ifdef B3500000
		700	+ case 3500000:
		701	+ speed = B3500000;
		702	+ break;
		703	+#endif
		704	+#ifdef B4000000
		705	+ case 4000000:
		706	+ speed = B4000000;
		707	+ break;
		708	+#endif
		709	+ default:
		710	+ speed = B9600;
		711	+ if (ctx->debug) {
		712	+ fprintf(stderr,
		713	+ "WARNING Unknown baud rate %d for %s (B9600 used)\n",
		714	+ ctx_rtu->baud, ctx_rtu->device);
		715	+ }
		716	+ }
		717	+
		718	+ /* Set the baud rate */
		719	+ if ((cfsetispeed(&tios, speed) < 0) \|\|
		720	+ (cfsetospeed(&tios, speed) < 0)) {
		721	+ close(ctx->s);
		722	+ ctx->s = -1;
		723	+ return -1;
		724	+ }
		725	+
		726	+ /* C_CFLAG Control options
		727	+ CLOCAL Local line - do not change "owner" of port
		728	+ CREAD Enable receiver
		729	+ */
		730	+ tios.c_cflag \|= (CREAD \| CLOCAL);
		731	+ /* CSIZE, HUPCL, CRTSCTS (hardware flow control) */
		732	+
		733	+ /* Set data bits (5, 6, 7, 8 bits)
		734	+ CSIZE Bit mask for data bits
		735	+ */
		736	+ tios.c_cflag &= ~CSIZE;
		737	+ switch (ctx_rtu->data_bit) {
		738	+ case 5:
		739	+ tios.c_cflag \|= CS5;
		740	+ break;
		741	+ case 6:
		742	+ tios.c_cflag \|= CS6;
		743	+ break;
		744	+ case 7:
		745	+ tios.c_cflag \|= CS7;
		746	+ break;
		747	+ case 8:
		748	+ default:
		749	+ tios.c_cflag \|= CS8;
		750	+ break;
		751	+ }
		752	+
		753	+ /* Stop bit (1 or 2) */
		754	+ if (ctx_rtu->stop_bit == 1)
		755	+ tios.c_cflag &=~ CSTOPB;
		756	+ else /* 2 */
		757	+ tios.c_cflag \|= CSTOPB;
		758	+
		759	+ /* PARENB Enable parity bit
		760	+ PARODD Use odd parity instead of even */
		761	+ if (ctx_rtu->parity == 'N') {
		762	+ /* None */
		763	+ tios.c_cflag &=~ PARENB;
		764	+ } else if (ctx_rtu->parity == 'E') {
		765	+ /* Even */
		766	+ tios.c_cflag \|= PARENB;
		767	+ tios.c_cflag &=~ PARODD;
		768	+ } else {
		769	+ /* Odd */
		770	+ tios.c_cflag \|= PARENB;
		771	+ tios.c_cflag \|= PARODD;
		772	+ }
		773	+
		774	+ /* Read the man page of termios if you need more information. */
		775	+
		776	+ /* This field isn't used on POSIX systems
		777	+ tios.c_line = 0;
		778	+ */
		779	+
		780	+ /* C_LFLAG Line options
		781	+
		782	+ ISIG Enable SIGINTR, SIGSUSP, SIGDSUSP, and SIGQUIT signals
		783	+ ICANON Enable canonical input (else raw)
		784	+ XCASE Map uppercase \lowercase (obsolete)
		785	+ ECHO Enable echoing of input characters
		786	+ ECHOE Echo erase character as BS-SP-BS
		787	+ ECHOK Echo NL after kill character
		788	+ ECHONL Echo NL
		789	+ NOFLSH Disable flushing of input buffers after
		790	+ interrupt or quit characters
		791	+ IEXTEN Enable extended functions
		792	+ ECHOCTL Echo control characters as ^char and delete as ~?
		793	+ ECHOPRT Echo erased character as character erased
		794	+ ECHOKE BS-SP-BS entire line on line kill
		795	+ FLUSHO Output being flushed
		796	+ PENDIN Retype pending input at next read or input char
		797	+ TOSTOP Send SIGTTOU for background output
		798	+
		799	+ Canonical input is line-oriented. Input characters are put
		800	+ into a buffer which can be edited interactively by the user
		801	+ until a CR (carriage return) or LF (line feed) character is
		802	+ received.
		803	+
		804	+ Raw input is unprocessed. Input characters are passed
		805	+ through exactly as they are received, when they are
		806	+ received. Generally you'll deselect the ICANON, ECHO,
		807	+ ECHOE, and ISIG options when using raw input
		808	+ */
		809	+
		810	+ /* Raw input */
		811	+ tios.c_lflag &= ~(ICANON \| ECHO \| ECHOE \| ISIG);
		812	+
		813	+ /* C_IFLAG Input options
		814	+
		815	+ Constant Description
		816	+ INPCK Enable parity check
		817	+ IGNPAR Ignore parity errors
		818	+ PARMRK Mark parity errors
		819	+ ISTRIP Strip parity bits
		820	+ IXON Enable software flow control (outgoing)
		821	+ IXOFF Enable software flow control (incoming)
		822	+ IXANY Allow any character to start flow again
		823	+ IGNBRK Ignore break condition
		824	+ BRKINT Send a SIGINT when a break condition is detected
		825	+ INLCR Map NL to CR
		826	+ IGNCR Ignore CR
		827	+ ICRNL Map CR to NL
		828	+ IUCLC Map uppercase to lowercase
		829	+ IMAXBEL Echo BEL on input line too long
		830	+ */
		831	+ if (ctx_rtu->parity == 'N') {
		832	+ /* None */
		833	+ tios.c_iflag &= ~INPCK;
		834	+ } else {
		835	+ tios.c_iflag \|= INPCK;
		836	+ }
		837	+
		838	+ /* Software flow control is disabled */
		839	+ tios.c_iflag &= ~(IXON \| IXOFF \| IXANY);
		840	+
		841	+ /* C_OFLAG Output options
		842	+ OPOST Postprocess output (not set = raw output)
		843	+ ONLCR Map NL to CR-NL
		844	+
		845	+ ONCLR ant others needs OPOST to be enabled
		846	+ */
		847	+
		848	+ /* Raw ouput */
		849	+ tios.c_oflag &=~ OPOST;
		850	+
		851	+ /* C_CC Control characters
		852	+ VMIN Minimum number of characters to read
		853	+ VTIME Time to wait for data (tenths of seconds)
		854	+
		855	+ UNIX serial interface drivers provide the ability to
		856	+ specify character and packet timeouts. Two elements of the
		857	+ c_cc array are used for timeouts: VMIN and VTIME. Timeouts
		858	+ are ignored in canonical input mode or when the NDELAY
		859	+ option is set on the file via open or fcntl.
		860	+
		861	+ VMIN specifies the minimum number of characters to read. If
		862	+ it is set to 0, then the VTIME value specifies the time to
		863	+ wait for every character read. Note that this does not mean
		864	+ that a read call for N bytes will wait for N characters to
		865	+ come in. Rather, the timeout will apply to the first
		866	+ character and the read call will return the number of
		867	+ characters immediately available (up to the number you
		868	+ request).
		869	+
		870	+ If VMIN is non-zero, VTIME specifies the time to wait for
		871	+ the first character read. If a character is read within the
		872	+ time given, any read will block (wait) until all VMIN
		873	+ characters are read. That is, once the first character is
		874	+ read, the serial interface driver expects to receive an
		875	+ entire packet of characters (VMIN bytes total). If no
		876	+ character is read within the time allowed, then the call to
		877	+ read returns 0. This method allows you to tell the serial
		878	+ driver you need exactly N bytes and any read call will
		879	+ return 0 or N bytes. However, the timeout only applies to
		880	+ the first character read, so if for some reason the driver
		881	+ misses one character inside the N byte packet then the read
		882	+ call could block forever waiting for additional input
		883	+ characters.
		884	+
		885	+ VTIME specifies the amount of time to wait for incoming
		886	+ characters in tenths of seconds. If VTIME is set to 0 (the
		887	+ default), reads will block (wait) indefinitely unless the
		888	+ NDELAY option is set on the port with open or fcntl.
		889	+ */
		890	+ /* Unused because we use open with the NDELAY option */
		891	+ tios.c_cc[VMIN] = 0;
		892	+ tios.c_cc[VTIME] = 0;
		893	+
		894	+ if (tcsetattr(ctx->s, TCSANOW, &tios) < 0) {
		895	+ close(ctx->s);
		896	+ ctx->s = -1;
		897	+ return -1;
		898	+ }
		899	+#endif
		900	+
		901	+ return 0;
		902	+}
		903	+
		904	+int modbus_rtu_set_serial_mode(modbus_t *ctx, int mode)
		905	+{
		906	+ if (ctx == NULL) {
		907	+ errno = EINVAL;
		908	+ return -1;
		909	+ }
		910	+
		911	+ if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) {
		912	+#if HAVE_DECL_TIOCSRS485
		913	+ modbus_rtu_t *ctx_rtu = ctx->backend_data;
		914	+ struct serial_rs485 rs485conf;
		915	+ memset(&rs485conf, 0x0, sizeof(struct serial_rs485));
		916	+
		917	+ if (mode == MODBUS_RTU_RS485) {
		918	+ rs485conf.flags = SER_RS485_ENABLED;
		919	+ if (ioctl(ctx->s, TIOCSRS485, &rs485conf) < 0) {
		920	+ return -1;
		921	+ }
		922	+
		923	+ ctx_rtu->serial_mode = MODBUS_RTU_RS485;
		924	+ return 0;
		925	+ } else if (mode == MODBUS_RTU_RS232) {
		926	+ /* Turn off RS485 mode only if required */
		927	+ if (ctx_rtu->serial_mode == MODBUS_RTU_RS485) {
		928	+ /* The ioctl call is avoided because it can fail on some RS232 ports */
		929	+ if (ioctl(ctx->s, TIOCSRS485, &rs485conf) < 0) {
		930	+ return -1;
		931	+ }
		932	+ }
		933	+ ctx_rtu->serial_mode = MODBUS_RTU_RS232;
		934	+ return 0;
		935	+ }
		936	+#else
		937	+ if (ctx->debug) {
		938	+ fprintf(stderr, "This function isn't supported on your platform\n");
		939	+ }
		940	+ errno = ENOTSUP;
		941	+ return -1;
		942	+#endif
		943	+ }
		944	+
		945	+ /* Wrong backend and invalid mode specified */
		946	+ errno = EINVAL;
		947	+ return -1;
		948	+}
		949	+
		950	+int modbus_rtu_get_serial_mode(modbus_t *ctx)
		951	+{
		952	+ if (ctx == NULL) {
		953	+ errno = EINVAL;
		954	+ return -1;
		955	+ }
		956	+
		957	+ if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) {
		958	+#if HAVE_DECL_TIOCSRS485
		959	+ modbus_rtu_t *ctx_rtu = ctx->backend_data;
		960	+ return ctx_rtu->serial_mode;
		961	+#else
		962	+ if (ctx->debug) {
		963	+ fprintf(stderr, "This function isn't supported on your platform\n");
		964	+ }
		965	+ errno = ENOTSUP;
		966	+ return -1;
		967	+#endif
		968	+ } else {
		969	+ errno = EINVAL;
		970	+ return -1;
		971	+ }
		972	+}
		973	+
		974	+int modbus_rtu_get_rts(modbus_t *ctx)
		975	+{
		976	+ if (ctx == NULL) {
		977	+ errno = EINVAL;
		978	+ return -1;
		979	+ }
		980	+
		981	+ if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) {
		982	+#if HAVE_DECL_TIOCM_RTS
		983	+ modbus_rtu_t *ctx_rtu = ctx->backend_data;
		984	+ return ctx_rtu->rts;
		985	+#else
		986	+ if (ctx->debug) {
		987	+ fprintf(stderr, "This function isn't supported on your platform\n");
		988	+ }
		989	+ errno = ENOTSUP;
		990	+ return -1;
		991	+#endif
		992	+ } else {
		993	+ errno = EINVAL;
		994	+ return -1;
		995	+ }
		996	+}
		997	+
		998	+int modbus_rtu_set_rts(modbus_t *ctx, int mode)
		999	+{
		1000	+ if (ctx == NULL) {
		1001	+ errno = EINVAL;
		1002	+ return -1;
		1003	+ }
		1004	+
		1005	+ if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) {
		1006	+#if HAVE_DECL_TIOCM_RTS
		1007	+ modbus_rtu_t *ctx_rtu = ctx->backend_data;
		1008	+
		1009	+ if (mode == MODBUS_RTU_RTS_NONE \|\| mode == MODBUS_RTU_RTS_UP \|\|
		1010	+ mode == MODBUS_RTU_RTS_DOWN) {
		1011	+ ctx_rtu->rts = mode;
		1012	+
		1013	+ /* Set the RTS bit in order to not reserve the RS485 bus */
		1014	+ ctx_rtu->set_rts(ctx, ctx_rtu->rts != MODBUS_RTU_RTS_UP);
		1015	+
		1016	+ return 0;
		1017	+ } else {
		1018	+ errno = EINVAL;
		1019	+ return -1;
		1020	+ }
		1021	+#else
		1022	+ if (ctx->debug) {
		1023	+ fprintf(stderr, "This function isn't supported on your platform\n");
		1024	+ }
		1025	+ errno = ENOTSUP;
		1026	+ return -1;
		1027	+#endif
		1028	+ }
		1029	+ /* Wrong backend or invalid mode specified */
		1030	+ errno = EINVAL;
		1031	+ return -1;
		1032	+}
		1033	+
		1034	+int modbus_rtu_set_custom_rts(modbus_t ctx, void (set_rts) (modbus_t *ctx, int on))
		1035	+{
		1036	+ if (ctx == NULL) {
		1037	+ errno = EINVAL;
		1038	+ return -1;
		1039	+ }
		1040	+
		1041	+ if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) {
		1042	+#if HAVE_DECL_TIOCM_RTS
		1043	+ modbus_rtu_t *ctx_rtu = ctx->backend_data;
		1044	+ ctx_rtu->set_rts = set_rts;
		1045	+ return 0;
		1046	+#else
		1047	+ if (ctx->debug) {
		1048	+ fprintf(stderr, "This function isn't supported on your platform\n");
		1049	+ }
		1050	+ errno = ENOTSUP;
		1051	+ return -1;
		1052	+#endif
		1053	+ } else {
		1054	+ errno = EINVAL;
		1055	+ return -1;
		1056	+ }
		1057	+}
		1058	+
		1059	+int modbus_rtu_get_rts_delay(modbus_t *ctx)
		1060	+{
		1061	+ if (ctx == NULL) {
		1062	+ errno = EINVAL;
		1063	+ return -1;
		1064	+ }
		1065	+
		1066	+ if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) {
		1067	+#if HAVE_DECL_TIOCM_RTS
		1068	+ modbus_rtu_t *ctx_rtu;
		1069	+ ctx_rtu = (modbus_rtu_t *)ctx->backend_data;
		1070	+ return ctx_rtu->rts_delay;
		1071	+#else
		1072	+ if (ctx->debug) {
		1073	+ fprintf(stderr, "This function isn't supported on your platform\n");
		1074	+ }
		1075	+ errno = ENOTSUP;
		1076	+ return -1;
		1077	+#endif
		1078	+ } else {
		1079	+ errno = EINVAL;
		1080	+ return -1;
		1081	+ }
		1082	+}
		1083	+
		1084	+int modbus_rtu_set_rts_delay(modbus_t *ctx, int us)
		1085	+{
		1086	+ if (ctx == NULL \|\| us < 0) {
		1087	+ errno = EINVAL;
		1088	+ return -1;
		1089	+ }
		1090	+
		1091	+ if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) {
		1092	+#if HAVE_DECL_TIOCM_RTS
		1093	+ modbus_rtu_t *ctx_rtu;
		1094	+ ctx_rtu = (modbus_rtu_t *)ctx->backend_data;
		1095	+ ctx_rtu->rts_delay = us;
		1096	+ return 0;
		1097	+#else
		1098	+ if (ctx->debug) {
		1099	+ fprintf(stderr, "This function isn't supported on your platform\n");
		1100	+ }
		1101	+ errno = ENOTSUP;
		1102	+ return -1;
		1103	+#endif
		1104	+ } else {
		1105	+ errno = EINVAL;
		1106	+ return -1;
		1107	+ }
		1108	+}
		1109	+
		1110	+static void _modbus_rtu_close(modbus_t *ctx)
		1111	+{
		1112	+ /* Restore line settings and close file descriptor in RTU mode */
		1113	+ modbus_rtu_t *ctx_rtu = ctx->backend_data;
		1114	+
		1115	+#if defined(_WIN32)
		1116	+ /* Revert settings */
		1117	+ if (!SetCommState(ctx_rtu->w_ser.fd, &ctx_rtu->old_dcb) && ctx->debug) {
		1118	+ fprintf(stderr, "ERROR Couldn't revert to configuration (LastError %d)\n",
		1119	+ (int)GetLastError());
		1120	+ }
		1121	+
		1122	+ if (!CloseHandle(ctx_rtu->w_ser.fd) && ctx->debug) {
		1123	+ fprintf(stderr, "ERROR Error while closing handle (LastError %d)\n",
		1124	+ (int)GetLastError());
		1125	+ }
		1126	+#else
		1127	+ if (ctx->s != -1) {
		1128	+ tcsetattr(ctx->s, TCSANOW, &ctx_rtu->old_tios);
		1129	+ close(ctx->s);
		1130	+ ctx->s = -1;
		1131	+ }
		1132	+#endif
		1133	+}
		1134	+
		1135	+static int _modbus_rtu_flush(modbus_t *ctx)
		1136	+{
		1137	+#if defined(_WIN32)
		1138	+ modbus_rtu_t *ctx_rtu = ctx->backend_data;
		1139	+ ctx_rtu->w_ser.n_bytes = 0;
		1140	+ return (PurgeComm(ctx_rtu->w_ser.fd, PURGE_RXCLEAR) == FALSE);
		1141	+#else
		1142	+ return tcflush(ctx->s, TCIOFLUSH);
		1143	+#endif
		1144	+}
		1145	+
		1146	+static int _modbus_rtu_select(modbus_t ctx, fd_set rset,
		1147	+ struct timeval *tv, int length_to_read)
		1148	+{
		1149	+ int s_rc;
		1150	+#if defined(_WIN32)
		1151	+ s_rc = win32_ser_select(&((modbus_rtu_t *)ctx->backend_data)->w_ser,
		1152	+ length_to_read, tv);
		1153	+ if (s_rc == 0) {
		1154	+ errno = ETIMEDOUT;
		1155	+ return -1;
		1156	+ }
		1157	+
		1158	+ if (s_rc < 0) {
		1159	+ return -1;
		1160	+ }
		1161	+#else
		1162	+ while ((s_rc = select(ctx->s+1, rset, NULL, NULL, tv)) == -1) {
		1163	+ if (errno == EINTR) {
		1164	+ if (ctx->debug) {
		1165	+ fprintf(stderr, "A non blocked signal was caught\n");
		1166	+ }
		1167	+ /* Necessary after an error */
		1168	+ FD_ZERO(rset);
		1169	+ FD_SET(ctx->s, rset);
		1170	+ } else {
		1171	+ return -1;
		1172	+ }
		1173	+ }
		1174	+
		1175	+ if (s_rc == 0) {
		1176	+ /* Timeout */
		1177	+ errno = ETIMEDOUT;
		1178	+ return -1;
		1179	+ }
		1180	+#endif
		1181	+
		1182	+ return s_rc;
		1183	+}
		1184	+
		1185	+static void _modbus_rtu_free(modbus_t *ctx) {
		1186	+ free(((modbus_rtu_t*)ctx->backend_data)->device);
		1187	+ free(ctx->backend_data);
		1188	+ free(ctx);
		1189	+}
		1190	+
		1191	+const modbus_backend_t _modbus_rtu_backend = {
		1192	+ _MODBUS_BACKEND_TYPE_RTU,
		1193	+ _MODBUS_RTU_HEADER_LENGTH,
		1194	+ _MODBUS_RTU_CHECKSUM_LENGTH,
		1195	+ MODBUS_RTU_MAX_ADU_LENGTH,
		1196	+ _modbus_set_slave,
		1197	+ _modbus_rtu_build_request_basis,
		1198	+ _modbus_rtu_build_response_basis,
		1199	+ _modbus_rtu_prepare_response_tid,
		1200	+ _modbus_rtu_send_msg_pre,
		1201	+ _modbus_rtu_send,
		1202	+ _modbus_rtu_receive,
		1203	+ _modbus_rtu_recv,
		1204	+ _modbus_rtu_check_integrity,
		1205	+ _modbus_rtu_pre_check_confirmation,
		1206	+ _modbus_rtu_connect,
		1207	+ _modbus_rtu_close,
		1208	+ _modbus_rtu_flush,
		1209	+ _modbus_rtu_select,
		1210	+ _modbus_rtu_free
		1211	+};
		1212	+
		1213	+//*Not part of libmodbus - rts param added for QModMaster*//
		1214	+modbus_t* modbus_new_rtu(const char *device,
		1215	+ int baud, char parity, int data_bit,
		1216	+ int stop_bit, int rts)
		1217	+{
		1218	+ modbus_t *ctx;
		1219	+ modbus_rtu_t *ctx_rtu;
		1220	+
		1221	+ /* Check device argument */
		1222	+ if (device == NULL \|\| *device == 0) {
		1223	+ fprintf(stderr, "The device string is empty\n");
		1224	+ errno = EINVAL;
		1225	+ return NULL;
		1226	+ }
		1227	+
		1228	+ /* Check baud argument */
		1229	+ if (baud == 0) {
		1230	+ fprintf(stderr, "The baud rate value must not be zero\n");
		1231	+ errno = EINVAL;
		1232	+ return NULL;
		1233	+ }
		1234	+
		1235	+ ctx = (modbus_t *)malloc(sizeof(modbus_t));
		1236	+ _modbus_init_common(ctx);
		1237	+ ctx->backend = &_modbus_rtu_backend;
		1238	+ ctx->backend_data = (modbus_rtu_t *)malloc(sizeof(modbus_rtu_t));
		1239	+ ctx_rtu = (modbus_rtu_t *)ctx->backend_data;
		1240	+ ctx_rtu->device = NULL;
		1241	+
		1242	+ /* Device name and \0 */
		1243	+ ctx_rtu->device = (char )malloc((strlen(device) + 1) sizeof(char));
		1244	+ strcpy(ctx_rtu->device, device);
		1245	+
		1246	+ ctx_rtu->baud = baud;
		1247	+ if (parity == 'N' \|\| parity == 'E' \|\| parity == 'O') {
		1248	+ ctx_rtu->parity = parity;
		1249	+ } else {
		1250	+ modbus_free(ctx);
		1251	+ errno = EINVAL;
		1252	+ return NULL;
		1253	+ }
		1254	+ ctx_rtu->data_bit = data_bit;
		1255	+ ctx_rtu->stop_bit = stop_bit;
		1256	+
		1257	+#if HAVE_DECL_TIOCSRS485
		1258	+ /* The RS232 mode has been set by default */
		1259	+ ctx_rtu->serial_mode = MODBUS_RTU_RS232;
		1260	+#endif
		1261	+
		1262	+#if HAVE_DECL_TIOCM_RTS
		1263	+ /* The RTS use has been set by default */
		1264	+ ctx_rtu->rts = MODBUS_RTU_RTS_NONE;
		1265	+
		1266	+ /* Calculate estimated time in micro second to send one byte */
		1267	+ ctx_rtu->onebyte_time = 1000000 * (1 + data_bit + (parity == 'N' ? 0 : 1) + stop_bit) / baud;
		1268	+
		1269	+ /* The internal function is used by default to set RTS */
		1270	+ ctx_rtu->set_rts = _modbus_rtu_ioctl_rts;
		1271	+
		1272	+ /* The delay before and after transmission when toggling the RTS pin */
		1273	+ ctx_rtu->rts_delay = ctx_rtu->onebyte_time;
		1274	+#endif
		1275	+
		1276	+//*Not part of libmodbus - added for QModMaster*//
		1277	+#if defined(_WIN32)
		1278	+ ctx_rtu->rts = rts;
		1279	+#endif
		1280	+
		1281	+ ctx_rtu->confirmation_to_ignore = FALSE;
		1282	+
		1283	+ return ctx;
		1284	+}

3rdparty/libmodbus/modbus-rtu.h 0 → 100644

View file @500c015

		1	+/*
		2	+ * Copyright © 2001-2011 Stéphane Raimbault <stephane.raimbault@gmail.com>
		3	+ *
		4	+ * SPDX-License-Identifier: LGPL-2.1+
		5	+ */
		6	+
		7	+#ifndef MODBUS_RTU_H
		8	+#define MODBUS_RTU_H
		9	+
		10	+#include "modbus.h"
		11	+
		12	+MODBUS_BEGIN_DECLS
		13	+
		14	+/* Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5
		15	+ * RS232 / RS485 ADU = 253 bytes + slave (1 byte) + CRC (2 bytes) = 256 bytes
		16	+ */
		17	+#define MODBUS_RTU_MAX_ADU_LENGTH 256
		18	+
		19	+//*Not part of libmodbus - rts param added for QModMaster*//
		20	+MODBUS_API modbus_t* modbus_new_rtu(const char *device, int baud, char parity,
		21	+ int data_bit, int stop_bit, int rts);
		22	+
		23	+#define MODBUS_RTU_RS232 0
		24	+#define MODBUS_RTU_RS485 1
		25	+
		26	+MODBUS_API int modbus_rtu_set_serial_mode(modbus_t *ctx, int mode);
		27	+MODBUS_API int modbus_rtu_get_serial_mode(modbus_t *ctx);
		28	+
		29	+#define MODBUS_RTU_RTS_NONE 0
		30	+#define MODBUS_RTU_RTS_UP 1
		31	+#define MODBUS_RTU_RTS_DOWN 2
		32	+
		33	+MODBUS_API int modbus_rtu_set_rts(modbus_t *ctx, int mode);
		34	+MODBUS_API int modbus_rtu_get_rts(modbus_t *ctx);
		35	+
		36	+MODBUS_API int modbus_rtu_set_custom_rts(modbus_t ctx, void (set_rts) (modbus_t *ctx, int on));
		37	+
		38	+MODBUS_API int modbus_rtu_set_rts_delay(modbus_t *ctx, int us);
		39	+MODBUS_API int modbus_rtu_get_rts_delay(modbus_t *ctx);
		40	+
		41	+MODBUS_END_DECLS
		42	+
		43	+#endif /* MODBUS_RTU_H */

3rdparty/libmodbus/modbus-tcp-private.h 0 → 100644

View file @500c015

		1	+/*
		2	+ * Copyright © 2001-2011 Stéphane Raimbault <stephane.raimbault@gmail.com>
		3	+ *
		4	+ * SPDX-License-Identifier: LGPL-2.1+
		5	+ */
		6	+
		7	+#ifndef MODBUS_TCP_PRIVATE_H
		8	+#define MODBUS_TCP_PRIVATE_H
		9	+
		10	+#define _MODBUS_TCP_HEADER_LENGTH 7
		11	+#define _MODBUS_TCP_PRESET_REQ_LENGTH 12
		12	+#define _MODBUS_TCP_PRESET_RSP_LENGTH 8
		13	+
		14	+#define _MODBUS_TCP_CHECKSUM_LENGTH 0
		15	+
		16	+/* In both structures, the transaction ID must be placed on first position
		17	+ to have a quick access not dependant of the TCP backend */
		18	+typedef struct _modbus_tcp {
		19	+ /* Extract from MODBUS Messaging on TCP/IP Implementation Guide V1.0b
		20	+ (page 23/46):
		21	+ The transaction identifier is used to associate the future response
		22	+ with the request. This identifier is unique on each TCP connection. */
		23	+ uint16_t t_id;
		24	+ /* TCP port */
		25	+ int port;
		26	+ /* IP address */
		27	+ char ip[16];
		28	+} modbus_tcp_t;
		29	+
		30	+#define _MODBUS_TCP_PI_NODE_LENGTH 1025
		31	+#define _MODBUS_TCP_PI_SERVICE_LENGTH 32
		32	+
		33	+typedef struct _modbus_tcp_pi {
		34	+ /* Transaction ID */
		35	+ uint16_t t_id;
		36	+ /* TCP port */
		37	+ int port;
		38	+ /* Node */
		39	+ char node[_MODBUS_TCP_PI_NODE_LENGTH];
		40	+ /* Service */
		41	+ char service[_MODBUS_TCP_PI_SERVICE_LENGTH];
		42	+} modbus_tcp_pi_t;
		43	+
		44	+#endif /* MODBUS_TCP_PRIVATE_H */

3rdparty/libmodbus/modbus-tcp.c 0 → 100644

View file @500c015

		1	+/*
		2	+ * Copyright © 2001-2013 Stéphane Raimbault <stephane.raimbault@gmail.com>
		3	+ *
		4	+ * SPDX-License-Identifier: LGPL-2.1+
		5	+ */
		6	+
		7	+#include <stdio.h>
		8	+#include <stdlib.h>
		9	+#include <string.h>
		10	+#include <errno.h>
		11	+#ifndef _MSC_VER
		12	+#include <unistd.h>
		13	+#endif
		14	+#include <signal.h>
		15	+#include <sys/types.h>
		16	+
		17	+#if defined(_WIN32)
		18	+# define OS_WIN32
		19	+/* ws2_32.dll has getaddrinfo and freeaddrinfo on Windows XP and later.
		20	+ * minwg32 headers check WINVER before allowing the use of these */
		21	+# ifndef WINVER
		22	+# define WINVER 0x0501
		23	+# endif
		24	+/* Already set in modbus-tcp.h but it seems order matters in VS2005 */
		25	+# include <winsock2.h>
		26	+# include <ws2tcpip.h>
		27	+# define SHUT_RDWR 2
		28	+# define close closesocket
		29	+#else
		30	+# include <sys/socket.h>
		31	+# include <sys/ioctl.h>
		32	+
		33	+#if defined(__OpenBSD__) \|\| (defined(__FreeBSD__) && __FreeBSD__ < 5)
		34	+# define OS_BSD
		35	+# include <netinet/in_systm.h>
		36	+#endif
		37	+
		38	+# include <netinet/in.h>
		39	+# include <netinet/ip.h>
		40	+# include <netinet/tcp.h>
		41	+# include <arpa/inet.h>
		42	+# include <netdb.h>
		43	+#endif
		44	+
		45	+#if !defined(MSG_NOSIGNAL)
		46	+#define MSG_NOSIGNAL 0
		47	+#endif
		48	+
		49	+#if defined(_AIX) && !defined(MSG_DONTWAIT)
		50	+#define MSG_DONTWAIT MSG_NONBLOCK
		51	+#endif
		52	+
		53	+#include "modbus-private.h"
		54	+
		55	+#include "modbus-tcp.h"
		56	+#include "modbus-tcp-private.h"
		57	+
		58	+#ifdef OS_WIN32
		59	+static int _modbus_tcp_init_win32(void)
		60	+{
		61	+ /* Initialise Windows Socket API */
		62	+ WSADATA wsaData;
		63	+
		64	+ if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
		65	+ fprintf(stderr, "WSAStartup() returned error code %d\n",
		66	+ (unsigned int)GetLastError());
		67	+ errno = EIO;
		68	+ return -1;
		69	+ }
		70	+ return 0;
		71	+}
		72	+#endif
		73	+
		74	+static int _modbus_set_slave(modbus_t *ctx, int slave)
		75	+{
		76	+ /* Broadcast address is 0 (MODBUS_BROADCAST_ADDRESS) */
		77	+ if (slave >= 0 && slave <= 247) {
		78	+ ctx->slave = slave;
		79	+ } else if (slave == MODBUS_TCP_SLAVE) {
		80	+ /* The special value MODBUS_TCP_SLAVE (0xFF) can be used in TCP mode to
		81	+ * restore the default value. */
		82	+ ctx->slave = slave;
		83	+ } else {
		84	+ errno = EINVAL;
		85	+ return -1;
		86	+ }
		87	+
		88	+ return 0;
		89	+}
		90	+
		91	+/* Builds a TCP request header */
		92	+static int _modbus_tcp_build_request_basis(modbus_t *ctx, int function,
		93	+ int addr, int nb,
		94	+ uint8_t *req)
		95	+{
		96	+ modbus_tcp_t *ctx_tcp = ctx->backend_data;
		97	+
		98	+ /* Increase transaction ID */
		99	+ if (ctx_tcp->t_id < UINT16_MAX)
		100	+ ctx_tcp->t_id++;
		101	+ else
		102	+ ctx_tcp->t_id = 0;
		103	+ req[0] = ctx_tcp->t_id >> 8;
		104	+ req[1] = ctx_tcp->t_id & 0x00ff;
		105	+
		106	+ /* Protocol Modbus */
		107	+ req[2] = 0;
		108	+ req[3] = 0;
		109	+
		110	+ /* Length will be defined later by set_req_length_tcp at offsets 4
		111	+ and 5 */
		112	+
		113	+ req[6] = ctx->slave;
		114	+ req[7] = function;
		115	+ req[8] = addr >> 8;
		116	+ req[9] = addr & 0x00ff;
		117	+ req[10] = nb >> 8;
		118	+ req[11] = nb & 0x00ff;
		119	+
		120	+ return _MODBUS_TCP_PRESET_REQ_LENGTH;
		121	+}
		122	+
		123	+/* Builds a TCP response header */
		124	+static int _modbus_tcp_build_response_basis(sft_t sft, uint8_t rsp)
		125	+{
		126	+ /* Extract from MODBUS Messaging on TCP/IP Implementation
		127	+ Guide V1.0b (page 23/46):
		128	+ The transaction identifier is used to associate the future
		129	+ response with the request. */
		130	+ rsp[0] = sft->t_id >> 8;
		131	+ rsp[1] = sft->t_id & 0x00ff;
		132	+
		133	+ /* Protocol Modbus */
		134	+ rsp[2] = 0;
		135	+ rsp[3] = 0;
		136	+
		137	+ /* Length will be set later by send_msg (4 and 5) */
		138	+
		139	+ /* The slave ID is copied from the indication */
		140	+ rsp[6] = sft->slave;
		141	+ rsp[7] = sft->function;
		142	+
		143	+ return _MODBUS_TCP_PRESET_RSP_LENGTH;
		144	+}
		145	+
		146	+
		147	+static int _modbus_tcp_prepare_response_tid(const uint8_t req, int req_length)
		148	+{
		149	+ return (req[0] << 8) + req[1];
		150	+}
		151	+
		152	+static int _modbus_tcp_send_msg_pre(uint8_t *req, int req_length)
		153	+{
		154	+ /* Substract the header length to the message length */
		155	+ int mbap_length = req_length - 6;
		156	+
		157	+ req[4] = mbap_length >> 8;
		158	+ req[5] = mbap_length & 0x00FF;
		159	+
		160	+ return req_length;
		161	+}
		162	+
		163	+static ssize_t _modbus_tcp_send(modbus_t ctx, const uint8_t req, int req_length)
		164	+{
		165	+ /* MSG_NOSIGNAL
		166	+ Requests not to send SIGPIPE on errors on stream oriented
		167	+ sockets when the other end breaks the connection. The EPIPE
		168	+ error is still returned. */
		169	+ return send(ctx->s, (const char *)req, req_length, MSG_NOSIGNAL);
		170	+}
		171	+
		172	+static int _modbus_tcp_receive(modbus_t ctx, uint8_t req) {
		173	+ return _modbus_receive_msg(ctx, req, MSG_INDICATION);
		174	+}
		175	+
		176	+static ssize_t _modbus_tcp_recv(modbus_t ctx, uint8_t rsp, int rsp_length) {
		177	+ return recv(ctx->s, (char *)rsp, rsp_length, 0);
		178	+}
		179	+
		180	+static int _modbus_tcp_check_integrity(modbus_t ctx, uint8_t msg, const int msg_length)
		181	+{
		182	+ return msg_length;
		183	+}
		184	+
		185	+static int _modbus_tcp_pre_check_confirmation(modbus_t ctx, const uint8_t req,
		186	+ const uint8_t *rsp, int rsp_length)
		187	+{
		188	+ /* Check transaction ID */
		189	+ if (req[0] != rsp[0] \|\| req[1] != rsp[1]) {
		190	+ if (ctx->debug) {
		191	+ fprintf(stderr, "Invalid transaction ID received 0x%X (not 0x%X)\n",
		192	+ (rsp[0] << 8) + rsp[1], (req[0] << 8) + req[1]);
		193	+ }
		194	+ errno = EMBBADDATA;
		195	+ return -1;
		196	+ }
		197	+
		198	+ /* Check protocol ID */
		199	+ if (rsp[2] != 0x0 && rsp[3] != 0x0) {
		200	+ if (ctx->debug) {
		201	+ fprintf(stderr, "Invalid protocol ID received 0x%X (not 0x0)\n",
		202	+ (rsp[2] << 8) + rsp[3]);
		203	+ }
		204	+ errno = EMBBADDATA;
		205	+ return -1;
		206	+ }
		207	+
		208	+ return 0;
		209	+}
		210	+
		211	+static int _modbus_tcp_set_ipv4_options(int s)
		212	+{
		213	+ int rc;
		214	+ int option;
		215	+
		216	+ /* Set the TCP no delay flag */
		217	+ /* SOL_TCP = IPPROTO_TCP */
		218	+ option = 1;
		219	+ rc = setsockopt(s, IPPROTO_TCP, TCP_NODELAY,
		220	+ (const void *)&option, sizeof(int));
		221	+ if (rc == -1) {
		222	+ return -1;
		223	+ }
		224	+
		225	+ /* If the OS does not offer SOCK_NONBLOCK, fall back to setting FIONBIO to
		226	+ * make sockets non-blocking */
		227	+ /* Do not care about the return value, this is optional */
		228	+#if !defined(SOCK_NONBLOCK) && defined(FIONBIO)
		229	+#ifdef OS_WIN32
		230	+ {
		231	+ /* Setting FIONBIO expects an unsigned long according to MSDN */
		232	+ u_long loption = 1;
		233	+ ioctlsocket(s, FIONBIO, &loption);
		234	+ }
		235	+#else
		236	+ option = 1;
		237	+ ioctl(s, FIONBIO, &option);
		238	+#endif
		239	+#endif
		240	+
		241	+#ifndef OS_WIN32
		242	+ /**
		243	+ * Cygwin defines IPTOS_LOWDELAY but can't handle that flag so it's
		244	+ * necessary to workaround that problem.
		245	+ **/
		246	+ /* Set the IP low delay option */
		247	+ option = IPTOS_LOWDELAY;
		248	+ rc = setsockopt(s, IPPROTO_IP, IP_TOS,
		249	+ (const void *)&option, sizeof(int));
		250	+ if (rc == -1) {
		251	+ return -1;
		252	+ }
		253	+#endif
		254	+
		255	+ return 0;
		256	+}
		257	+
		258	+static int _connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen,
		259	+ const struct timeval *ro_tv)
		260	+{
		261	+ int rc = connect(sockfd, addr, addrlen);
		262	+
		263	+#ifdef OS_WIN32
		264	+ int wsaError = 0;
		265	+ if (rc == -1) {
		266	+ wsaError = WSAGetLastError();
		267	+ }
		268	+
		269	+ if (wsaError == WSAEWOULDBLOCK \|\| wsaError == WSAEINPROGRESS) {
		270	+#else
		271	+ if (rc == -1 && errno == EINPROGRESS) {
		272	+#endif
		273	+ fd_set wset;
		274	+ int optval;
		275	+ socklen_t optlen = sizeof(optval);
		276	+ struct timeval tv = *ro_tv;
		277	+
		278	+ /* Wait to be available in writing */
		279	+ FD_ZERO(&wset);
		280	+ FD_SET(sockfd, &wset);
		281	+ rc = select(sockfd + 1, NULL, &wset, NULL, &tv);
		282	+ if (rc <= 0) {
		283	+ /* Timeout or fail */
		284	+ return -1;
		285	+ }
		286	+
		287	+ /* The connection is established if SO_ERROR and optval are set to 0 */
		288	+ rc = getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&optval, &optlen);
		289	+ if (rc == 0 && optval == 0) {
		290	+ return 0;
		291	+ } else {
		292	+ errno = ECONNREFUSED;
		293	+ return -1;
		294	+ }
		295	+ }
		296	+ return rc;
		297	+}
		298	+
		299	+/* Establishes a modbus TCP connection with a Modbus server. */
		300	+static int _modbus_tcp_connect(modbus_t *ctx)
		301	+{
		302	+ int rc;
		303	+ /* Specialized version of sockaddr for Internet socket address (same size) */
		304	+ struct sockaddr_in addr;
		305	+ modbus_tcp_t *ctx_tcp = ctx->backend_data;
		306	+ int flags = SOCK_STREAM;
		307	+
		308	+#ifdef OS_WIN32
		309	+ if (_modbus_tcp_init_win32() == -1) {
		310	+ return -1;
		311	+ }
		312	+#endif
		313	+
		314	+#ifdef SOCK_CLOEXEC
		315	+ flags \|= SOCK_CLOEXEC;
		316	+#endif
		317	+
		318	+#ifdef SOCK_NONBLOCK
		319	+ flags \|= SOCK_NONBLOCK;
		320	+#endif
		321	+
		322	+ ctx->s = socket(PF_INET, flags, 0);
		323	+ if (ctx->s == -1) {
		324	+ return -1;
		325	+ }
		326	+
		327	+ rc = _modbus_tcp_set_ipv4_options(ctx->s);
		328	+ if (rc == -1) {
		329	+ close(ctx->s);
		330	+ ctx->s = -1;
		331	+ return -1;
		332	+ }
		333	+
		334	+ if (ctx->debug) {
		335	+ printf("Connecting to %s:%d\n", ctx_tcp->ip, ctx_tcp->port);
		336	+ }
		337	+
		338	+ addr.sin_family = AF_INET;
		339	+ addr.sin_port = htons(ctx_tcp->port);
		340	+ addr.sin_addr.s_addr = inet_addr(ctx_tcp->ip);
		341	+ rc = _connect(ctx->s, (struct sockaddr *)&addr, sizeof(addr), &ctx->response_timeout);
		342	+ if (rc == -1) {
		343	+ close(ctx->s);
		344	+ ctx->s = -1;
		345	+ return -1;
		346	+ }
		347	+
		348	+ return 0;
		349	+}
		350	+
		351	+/* Establishes a modbus TCP PI connection with a Modbus server. */
		352	+static int _modbus_tcp_pi_connect(modbus_t *ctx)
		353	+{
		354	+ int rc;
		355	+ struct addrinfo *ai_list;
		356	+ struct addrinfo *ai_ptr;
		357	+ struct addrinfo ai_hints;
		358	+ modbus_tcp_pi_t *ctx_tcp_pi = ctx->backend_data;
		359	+
		360	+#ifdef OS_WIN32
		361	+ if (_modbus_tcp_init_win32() == -1) {
		362	+ return -1;
		363	+ }
		364	+#endif
		365	+
		366	+ memset(&ai_hints, 0, sizeof(ai_hints));
		367	+#ifdef AI_ADDRCONFIG
		368	+ ai_hints.ai_flags \|= AI_ADDRCONFIG;
		369	+#endif
		370	+ ai_hints.ai_family = AF_UNSPEC;
		371	+ ai_hints.ai_socktype = SOCK_STREAM;
		372	+ ai_hints.ai_addr = NULL;
		373	+ ai_hints.ai_canonname = NULL;
		374	+ ai_hints.ai_next = NULL;
		375	+
		376	+ ai_list = NULL;
		377	+ rc = getaddrinfo(ctx_tcp_pi->node, ctx_tcp_pi->service,
		378	+ &ai_hints, &ai_list);
		379	+ if (rc != 0) {
		380	+ if (ctx->debug) {
		381	+ fprintf(stderr, "Error returned by getaddrinfo: %s\n", gai_strerror(rc));
		382	+ }
		383	+ errno = ECONNREFUSED;
		384	+ return -1;
		385	+ }
		386	+
		387	+ for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) {
		388	+ int flags = ai_ptr->ai_socktype;
		389	+ int s;
		390	+
		391	+#ifdef SOCK_CLOEXEC
		392	+ flags \|= SOCK_CLOEXEC;
		393	+#endif
		394	+
		395	+#ifdef SOCK_NONBLOCK
		396	+ flags \|= SOCK_NONBLOCK;
		397	+#endif
		398	+
		399	+ s = socket(ai_ptr->ai_family, flags, ai_ptr->ai_protocol);
		400	+ if (s < 0)
		401	+ continue;
		402	+
		403	+ if (ai_ptr->ai_family == AF_INET)
		404	+ _modbus_tcp_set_ipv4_options(s);
		405	+
		406	+ if (ctx->debug) {
		407	+ printf("Connecting to [%s]:%s\n", ctx_tcp_pi->node, ctx_tcp_pi->service);
		408	+ }
		409	+
		410	+ rc = _connect(s, ai_ptr->ai_addr, ai_ptr->ai_addrlen, &ctx->response_timeout);
		411	+ if (rc == -1) {
		412	+ close(s);
		413	+ continue;
		414	+ }
		415	+
		416	+ ctx->s = s;
		417	+ break;
		418	+ }
		419	+
		420	+ freeaddrinfo(ai_list);
		421	+
		422	+ if (ctx->s < 0) {
		423	+ return -1;
		424	+ }
		425	+
		426	+ return 0;
		427	+}
		428	+
		429	+/* Closes the network connection and socket in TCP mode */
		430	+static void _modbus_tcp_close(modbus_t *ctx)
		431	+{
		432	+ if (ctx->s != -1) {
		433	+ shutdown(ctx->s, SHUT_RDWR);
		434	+ close(ctx->s);
		435	+ ctx->s = -1;
		436	+ }
		437	+}
		438	+
		439	+static int _modbus_tcp_flush(modbus_t *ctx)
		440	+{
		441	+ int rc;
		442	+ int rc_sum = 0;
		443	+
		444	+ do {
		445	+ /* Extract the garbage from the socket */
		446	+ char devnull[MODBUS_TCP_MAX_ADU_LENGTH];
		447	+#ifndef OS_WIN32
		448	+ rc = recv(ctx->s, devnull, MODBUS_TCP_MAX_ADU_LENGTH, MSG_DONTWAIT);
		449	+#else
		450	+ /* On Win32, it's a bit more complicated to not wait */
		451	+ fd_set rset;
		452	+ struct timeval tv;
		453	+
		454	+ tv.tv_sec = 0;
		455	+ tv.tv_usec = 0;
		456	+ FD_ZERO(&rset);
		457	+ FD_SET(ctx->s, &rset);
		458	+ rc = select(ctx->s+1, &rset, NULL, NULL, &tv);
		459	+ if (rc == -1) {
		460	+ return -1;
		461	+ }
		462	+
		463	+ if (rc == 1) {
		464	+ /* There is data to flush */
		465	+ rc = recv(ctx->s, devnull, MODBUS_TCP_MAX_ADU_LENGTH, 0);
		466	+ }
		467	+#endif
		468	+ if (rc > 0) {
		469	+ rc_sum += rc;
		470	+ }
		471	+ } while (rc == MODBUS_TCP_MAX_ADU_LENGTH);
		472	+
		473	+ return rc_sum;
		474	+}
		475	+
		476	+/* Listens for any request from one or many modbus masters in TCP */
		477	+int modbus_tcp_listen(modbus_t *ctx, int nb_connection)
		478	+{
		479	+ int new_s;
		480	+ int enable;
		481	+ struct sockaddr_in addr;
		482	+ modbus_tcp_t *ctx_tcp;
		483	+
		484	+ if (ctx == NULL) {
		485	+ errno = EINVAL;
		486	+ return -1;
		487	+ }
		488	+
		489	+ ctx_tcp = ctx->backend_data;
		490	+
		491	+#ifdef OS_WIN32
		492	+ if (_modbus_tcp_init_win32() == -1) {
		493	+ return -1;
		494	+ }
		495	+#endif
		496	+
		497	+ new_s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
		498	+ if (new_s == -1) {
		499	+ return -1;
		500	+ }
		501	+
		502	+ enable = 1;
		503	+ if (setsockopt(new_s, SOL_SOCKET, SO_REUSEADDR,
		504	+ (char *)&enable, sizeof(enable)) == -1) {
		505	+ close(new_s);
		506	+ return -1;
		507	+ }
		508	+
		509	+ memset(&addr, 0, sizeof(addr));
		510	+ addr.sin_family = AF_INET;
		511	+ /* If the modbus port is < to 1024, we need the setuid root. */
		512	+ addr.sin_port = htons(ctx_tcp->port);
		513	+ if (ctx_tcp->ip[0] == '0') {
		514	+ /* Listen any addresses */
		515	+ addr.sin_addr.s_addr = htonl(INADDR_ANY);
		516	+ } else {
		517	+ /* Listen only specified IP address */
		518	+ addr.sin_addr.s_addr = inet_addr(ctx_tcp->ip);
		519	+ }
		520	+ if (bind(new_s, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
		521	+ close(new_s);
		522	+ return -1;
		523	+ }
		524	+
		525	+ if (listen(new_s, nb_connection) == -1) {
		526	+ close(new_s);
		527	+ return -1;
		528	+ }
		529	+
		530	+ return new_s;
		531	+}
		532	+
		533	+int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection)
		534	+{
		535	+ int rc;
		536	+ struct addrinfo *ai_list;
		537	+ struct addrinfo *ai_ptr;
		538	+ struct addrinfo ai_hints;
		539	+ const char *node;
		540	+ const char *service;
		541	+ int new_s;
		542	+ modbus_tcp_pi_t *ctx_tcp_pi;
		543	+
		544	+ if (ctx == NULL) {
		545	+ errno = EINVAL;
		546	+ return -1;
		547	+ }
		548	+
		549	+ ctx_tcp_pi = ctx->backend_data;
		550	+
		551	+#ifdef OS_WIN32
		552	+ if (_modbus_tcp_init_win32() == -1) {
		553	+ return -1;
		554	+ }
		555	+#endif
		556	+
		557	+ if (ctx_tcp_pi->node[0] == 0) {
		558	+ node = NULL; /* == any */
		559	+ } else {
		560	+ node = ctx_tcp_pi->node;
		561	+ }
		562	+
		563	+ if (ctx_tcp_pi->service[0] == 0) {
		564	+ service = "502";
		565	+ } else {
		566	+ service = ctx_tcp_pi->service;
		567	+ }
		568	+
		569	+ memset(&ai_hints, 0, sizeof (ai_hints));
		570	+ /* If node is not NULL, than the AI_PASSIVE flag is ignored. */
		571	+ ai_hints.ai_flags \|= AI_PASSIVE;
		572	+#ifdef AI_ADDRCONFIG
		573	+ ai_hints.ai_flags \|= AI_ADDRCONFIG;
		574	+#endif
		575	+ ai_hints.ai_family = AF_UNSPEC;
		576	+ ai_hints.ai_socktype = SOCK_STREAM;
		577	+ ai_hints.ai_addr = NULL;
		578	+ ai_hints.ai_canonname = NULL;
		579	+ ai_hints.ai_next = NULL;
		580	+
		581	+ ai_list = NULL;
		582	+ rc = getaddrinfo(node, service, &ai_hints, &ai_list);
		583	+ if (rc != 0) {
		584	+ if (ctx->debug) {
		585	+ fprintf(stderr, "Error returned by getaddrinfo: %s\n", gai_strerror(rc));
		586	+ }
		587	+ errno = ECONNREFUSED;
		588	+ return -1;
		589	+ }
		590	+
		591	+ new_s = -1;
		592	+ for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) {
		593	+ int s;
		594	+
		595	+ s = socket(ai_ptr->ai_family, ai_ptr->ai_socktype,
		596	+ ai_ptr->ai_protocol);
		597	+ if (s < 0) {
		598	+ if (ctx->debug) {
		599	+ perror("socket");
		600	+ }
		601	+ continue;
		602	+ } else {
		603	+ int enable = 1;
		604	+ rc = setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
		605	+ (void *)&enable, sizeof (enable));
		606	+ if (rc != 0) {
		607	+ close(s);
		608	+ if (ctx->debug) {
		609	+ perror("setsockopt");
		610	+ }
		611	+ continue;
		612	+ }
		613	+ }
		614	+
		615	+ rc = bind(s, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
		616	+ if (rc != 0) {
		617	+ close(s);
		618	+ if (ctx->debug) {
		619	+ perror("bind");
		620	+ }
		621	+ continue;
		622	+ }
		623	+
		624	+ rc = listen(s, nb_connection);
		625	+ if (rc != 0) {
		626	+ close(s);
		627	+ if (ctx->debug) {
		628	+ perror("listen");
		629	+ }
		630	+ continue;
		631	+ }
		632	+
		633	+ new_s = s;
		634	+ break;
		635	+ }
		636	+ freeaddrinfo(ai_list);
		637	+
		638	+ if (new_s < 0) {
		639	+ return -1;
		640	+ }
		641	+
		642	+ return new_s;
		643	+}
		644	+
		645	+int modbus_tcp_accept(modbus_t ctx, int s)
		646	+{
		647	+ struct sockaddr_in addr;
		648	+ socklen_t addrlen;
		649	+
		650	+ if (ctx == NULL) {
		651	+ errno = EINVAL;
		652	+ return -1;
		653	+ }
		654	+
		655	+ addrlen = sizeof(addr);
		656	+#ifdef HAVE_ACCEPT4
		657	+ /* Inherit socket flags and use accept4 call */
		658	+ ctx->s = accept4(s, (struct sockaddr )&addr, &addrlen, SOCK_CLOEXEC);
		659	+#else
		660	+ ctx->s = accept(s, (struct sockaddr )&addr, &addrlen);
		661	+#endif
		662	+
		663	+ if (ctx->s == -1) {
		664	+ close(*s);
		665	+ *s = -1;
		666	+ return -1;
		667	+ }
		668	+
		669	+ if (ctx->debug) {
		670	+ printf("The client connection from %s is accepted\n",
		671	+ inet_ntoa(addr.sin_addr));
		672	+ }
		673	+
		674	+ return ctx->s;
		675	+}
		676	+
		677	+int modbus_tcp_pi_accept(modbus_t ctx, int s)
		678	+{
		679	+ struct sockaddr_storage addr;
		680	+ socklen_t addrlen;
		681	+
		682	+ if (ctx == NULL) {
		683	+ errno = EINVAL;
		684	+ return -1;
		685	+ }
		686	+
		687	+ addrlen = sizeof(addr);
		688	+#ifdef HAVE_ACCEPT4
		689	+ /* Inherit socket flags and use accept4 call */
		690	+ ctx->s = accept4(s, (struct sockaddr )&addr, &addrlen, SOCK_CLOEXEC);
		691	+#else
		692	+ ctx->s = accept(s, (struct sockaddr )&addr, &addrlen);
		693	+#endif
		694	+ if (ctx->s == -1) {
		695	+ close(*s);
		696	+ *s = -1;
		697	+ }
		698	+
		699	+ if (ctx->debug) {
		700	+ printf("The client connection is accepted.\n");
		701	+ }
		702	+
		703	+ return ctx->s;
		704	+}
		705	+
		706	+static int _modbus_tcp_select(modbus_t ctx, fd_set rset, struct timeval *tv, int length_to_read)
		707	+{
		708	+ int s_rc;
		709	+ while ((s_rc = select(ctx->s+1, rset, NULL, NULL, tv)) == -1) {
		710	+ if (errno == EINTR) {
		711	+ if (ctx->debug) {
		712	+ fprintf(stderr, "A non blocked signal was caught\n");
		713	+ }
		714	+ /* Necessary after an error */
		715	+ FD_ZERO(rset);
		716	+ FD_SET(ctx->s, rset);
		717	+ } else {
		718	+ return -1;
		719	+ }
		720	+ }
		721	+
		722	+ if (s_rc == 0) {
		723	+ errno = ETIMEDOUT;
		724	+ return -1;
		725	+ }
		726	+
		727	+ return s_rc;
		728	+}
		729	+
		730	+static void _modbus_tcp_free(modbus_t *ctx) {
		731	+ free(ctx->backend_data);
		732	+ free(ctx);
		733	+}
		734	+
		735	+const modbus_backend_t _modbus_tcp_backend = {
		736	+ _MODBUS_BACKEND_TYPE_TCP,
		737	+ _MODBUS_TCP_HEADER_LENGTH,
		738	+ _MODBUS_TCP_CHECKSUM_LENGTH,
		739	+ MODBUS_TCP_MAX_ADU_LENGTH,
		740	+ _modbus_set_slave,
		741	+ _modbus_tcp_build_request_basis,
		742	+ _modbus_tcp_build_response_basis,
		743	+ _modbus_tcp_prepare_response_tid,
		744	+ _modbus_tcp_send_msg_pre,
		745	+ _modbus_tcp_send,
		746	+ _modbus_tcp_receive,
		747	+ _modbus_tcp_recv,
		748	+ _modbus_tcp_check_integrity,
		749	+ _modbus_tcp_pre_check_confirmation,
		750	+ _modbus_tcp_connect,
		751	+ _modbus_tcp_close,
		752	+ _modbus_tcp_flush,
		753	+ _modbus_tcp_select,
		754	+ _modbus_tcp_free
		755	+};
		756	+
		757	+
		758	+const modbus_backend_t _modbus_tcp_pi_backend = {
		759	+ _MODBUS_BACKEND_TYPE_TCP,
		760	+ _MODBUS_TCP_HEADER_LENGTH,
		761	+ _MODBUS_TCP_CHECKSUM_LENGTH,
		762	+ MODBUS_TCP_MAX_ADU_LENGTH,
		763	+ _modbus_set_slave,
		764	+ _modbus_tcp_build_request_basis,
		765	+ _modbus_tcp_build_response_basis,
		766	+ _modbus_tcp_prepare_response_tid,
		767	+ _modbus_tcp_send_msg_pre,
		768	+ _modbus_tcp_send,
		769	+ _modbus_tcp_receive,
		770	+ _modbus_tcp_recv,
		771	+ _modbus_tcp_check_integrity,
		772	+ _modbus_tcp_pre_check_confirmation,
		773	+ _modbus_tcp_pi_connect,
		774	+ _modbus_tcp_close,
		775	+ _modbus_tcp_flush,
		776	+ _modbus_tcp_select,
		777	+ _modbus_tcp_free
		778	+};
		779	+
		780	+modbus_t* modbus_new_tcp(const char *ip, int port)
		781	+{
		782	+ modbus_t *ctx;
		783	+ modbus_tcp_t *ctx_tcp;
		784	+ size_t dest_size;
		785	+ size_t ret_size;
		786	+
		787	+#if defined(OS_BSD)
		788	+ /* MSG_NOSIGNAL is unsupported on *BSD so we install an ignore
		789	+ handler for SIGPIPE. */
		790	+ struct sigaction sa;
		791	+
		792	+ sa.sa_handler = SIG_IGN;
		793	+ if (sigaction(SIGPIPE, &sa, NULL) < 0) {
		794	+ /* The debug flag can't be set here... */
		795	+ fprintf(stderr, "Coud not install SIGPIPE handler.\n");
		796	+ return NULL;
		797	+ }
		798	+#endif
		799	+
		800	+ ctx = (modbus_t *)malloc(sizeof(modbus_t));
		801	+ _modbus_init_common(ctx);
		802	+
		803	+ /* Could be changed after to reach a remote serial Modbus device */
		804	+ ctx->slave = MODBUS_TCP_SLAVE;
		805	+
		806	+ ctx->backend = &_modbus_tcp_backend;
		807	+
		808	+ ctx->backend_data = (modbus_tcp_t *)malloc(sizeof(modbus_tcp_t));
		809	+ ctx_tcp = (modbus_tcp_t *)ctx->backend_data;
		810	+
		811	+ if (ip != NULL) {
		812	+ dest_size = sizeof(char) * 16;
		813	+ ret_size = strlcpy(ctx_tcp->ip, ip, dest_size);
		814	+ if (ret_size == 0) {
		815	+ fprintf(stderr, "The IP string is empty\n");
		816	+ modbus_free(ctx);
		817	+ errno = EINVAL;
		818	+ return NULL;
		819	+ }
		820	+
		821	+ if (ret_size >= dest_size) {
		822	+ fprintf(stderr, "The IP string has been truncated\n");
		823	+ modbus_free(ctx);
		824	+ errno = EINVAL;
		825	+ return NULL;
		826	+ }
		827	+ } else {
		828	+ ctx_tcp->ip[0] = '0';
		829	+ }
		830	+ ctx_tcp->port = port;
		831	+ ctx_tcp->t_id = 0;
		832	+
		833	+ return ctx;
		834	+}
		835	+
		836	+
		837	+modbus_t* modbus_new_tcp_pi(const char node, const char service)
		838	+{
		839	+ modbus_t *ctx;
		840	+ modbus_tcp_pi_t *ctx_tcp_pi;
		841	+ size_t dest_size;
		842	+ size_t ret_size;
		843	+
		844	+ ctx = (modbus_t *)malloc(sizeof(modbus_t));
		845	+ _modbus_init_common(ctx);
		846	+
		847	+ /* Could be changed after to reach a remote serial Modbus device */
		848	+ ctx->slave = MODBUS_TCP_SLAVE;
		849	+
		850	+ ctx->backend = &_modbus_tcp_pi_backend;
		851	+
		852	+ ctx->backend_data = (modbus_tcp_pi_t *)malloc(sizeof(modbus_tcp_pi_t));
		853	+ ctx_tcp_pi = (modbus_tcp_pi_t *)ctx->backend_data;
		854	+
		855	+ if (node == NULL) {
		856	+ /* The node argument can be empty to indicate any hosts */
		857	+ ctx_tcp_pi->node[0] = 0;
		858	+ } else {
		859	+ dest_size = sizeof(char) * _MODBUS_TCP_PI_NODE_LENGTH;
		860	+ ret_size = strlcpy(ctx_tcp_pi->node, node, dest_size);
		861	+ if (ret_size == 0) {
		862	+ fprintf(stderr, "The node string is empty\n");
		863	+ modbus_free(ctx);
		864	+ errno = EINVAL;
		865	+ return NULL;
		866	+ }
		867	+
		868	+ if (ret_size >= dest_size) {
		869	+ fprintf(stderr, "The node string has been truncated\n");
		870	+ modbus_free(ctx);
		871	+ errno = EINVAL;
		872	+ return NULL;
		873	+ }
		874	+ }
		875	+
		876	+ if (service != NULL) {
		877	+ dest_size = sizeof(char) * _MODBUS_TCP_PI_SERVICE_LENGTH;
		878	+ ret_size = strlcpy(ctx_tcp_pi->service, service, dest_size);
		879	+ } else {
		880	+ /* Empty service is not allowed, error catched below. */
		881	+ ret_size = 0;
		882	+ }
		883	+
		884	+ if (ret_size == 0) {
		885	+ fprintf(stderr, "The service string is empty\n");
		886	+ modbus_free(ctx);
		887	+ errno = EINVAL;
		888	+ return NULL;
		889	+ }
		890	+
		891	+ if (ret_size >= dest_size) {
		892	+ fprintf(stderr, "The service string has been truncated\n");
		893	+ modbus_free(ctx);
		894	+ errno = EINVAL;
		895	+ return NULL;
		896	+ }
		897	+
		898	+ ctx_tcp_pi->t_id = 0;
		899	+
		900	+ return ctx;
		901	+}

3rdparty/libmodbus/modbus-tcp.h 0 → 100644

View file @500c015

		1	+/*
		2	+ * Copyright © 2001-2010 Stéphane Raimbault <stephane.raimbault@gmail.com>
		3	+ *
		4	+ * SPDX-License-Identifier: LGPL-2.1+
		5	+ */
		6	+
		7	+#ifndef MODBUS_TCP_H
		8	+#define MODBUS_TCP_H
		9	+
		10	+#include "modbus.h"
		11	+
		12	+MODBUS_BEGIN_DECLS
		13	+
		14	+#if defined(_WIN32) && !defined(__CYGWIN__)
		15	+/* Win32 with MinGW, supplement to <errno.h> */
		16	+#include <winsock2.h>
		17	+#if !defined(ECONNRESET)
		18	+#define ECONNRESET WSAECONNRESET
		19	+#endif
		20	+#if !defined(ECONNREFUSED)
		21	+#define ECONNREFUSED WSAECONNREFUSED
		22	+#endif
		23	+#if !defined(ETIMEDOUT)
		24	+#define ETIMEDOUT WSAETIMEDOUT
		25	+#endif
		26	+#if !defined(ENOPROTOOPT)
		27	+#define ENOPROTOOPT WSAENOPROTOOPT
		28	+#endif
		29	+#if !defined(EINPROGRESS)
		30	+#define EINPROGRESS WSAEINPROGRESS
		31	+#endif
		32	+#endif
		33	+
		34	+#define MODBUS_TCP_DEFAULT_PORT 502
		35	+#define MODBUS_TCP_SLAVE 0xFF
		36	+
		37	+/* Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5
		38	+ * TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes
		39	+ */
		40	+#define MODBUS_TCP_MAX_ADU_LENGTH 260
		41	+
		42	+MODBUS_API modbus_t* modbus_new_tcp(const char *ip_address, int port);
		43	+MODBUS_API int modbus_tcp_listen(modbus_t *ctx, int nb_connection);
		44	+MODBUS_API int modbus_tcp_accept(modbus_t ctx, int s);
		45	+
		46	+MODBUS_API modbus_t* modbus_new_tcp_pi(const char node, const char service);
		47	+MODBUS_API int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection);
		48	+MODBUS_API int modbus_tcp_pi_accept(modbus_t ctx, int s);
		49	+
		50	+MODBUS_END_DECLS
		51	+
		52	+#endif /* MODBUS_TCP_H */

3rdparty/libmodbus/modbus-version.h 0 → 100644

View file @500c015

		1	+/*
		2	+ * Copyright © 2010-2014 Stéphane Raimbault <stephane.raimbault@gmail.com>
		3	+ *
		4	+ * This library is free software; you can redistribute it and/or
		5	+ * modify it under the terms of the GNU Lesser General Public
		6	+ * License as published by the Free Software Foundation; either
		7	+ * version 2.1 of the License, or (at your option) any later version.
		8	+ *
		9	+ * This library is distributed in the hope that it will be useful,
		10	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
		11	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		12	+ * Lesser General Public License for more details.
		13	+ *
		14	+ * You should have received a copy of the GNU Lesser General Public
		15	+ * License along with this library; if not, write to the Free Software
		16	+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		17	+ */
		18	+
		19	+#ifndef MODBUS_VERSION_H
		20	+#define MODBUS_VERSION_H
		21	+
		22	+/* The major version, (1, if %LIBMODBUS_VERSION is 1.2.3) */
		23	+#define LIBMODBUS_VERSION_MAJOR (3)
		24	+
		25	+/* The minor version (2, if %LIBMODBUS_VERSION is 1.2.3) */
		26	+#define LIBMODBUS_VERSION_MINOR (1)
		27	+
		28	+/* The micro version (3, if %LIBMODBUS_VERSION is 1.2.3) */
		29	+#define LIBMODBUS_VERSION_MICRO (4)
		30	+
		31	+/* The full version, like 1.2.3 */
		32	+#define LIBMODBUS_VERSION 3.1.4
		33	+
		34	+/* The full version, in string form (suited for string concatenation)
		35	+ */
		36	+#define LIBMODBUS_VERSION_STRING "3.1.4"
		37	+
		38	+/* Numerically encoded version, like 0x010203 */
		39	+#define LIBMODBUS_VERSION_HEX ((LIBMODBUS_VERSION_MAJOR << 24) \| \
		40	+ (LIBMODBUS_VERSION_MINOR << 16) \| \
		41	+ (LIBMODBUS_VERSION_MICRO << 8))
		42	+
		43	+/* Evaluates to True if the version is greater than @major, @minor and @micro
		44	+ */
		45	+#define LIBMODBUS_VERSION_CHECK(major,minor,micro) \
		46	+ (LIBMODBUS_VERSION_MAJOR > (major) \|\| \
		47	+ (LIBMODBUS_VERSION_MAJOR == (major) && \
		48	+ LIBMODBUS_VERSION_MINOR > (minor)) \|\| \
		49	+ (LIBMODBUS_VERSION_MAJOR == (major) && \
		50	+ LIBMODBUS_VERSION_MINOR == (minor) && \
		51	+ LIBMODBUS_VERSION_MICRO >= (micro)))
		52	+
		53	+#endif /* MODBUS_VERSION_H */

3rdparty/libmodbus/modbus.c 0 → 100644

View file @500c015

		1	+/*
		2	+ * Copyright © 2001-2011 Stéphane Raimbault <stephane.raimbault@gmail.com>
		3	+ *
		4	+ * SPDX-License-Identifier: LGPL-2.1+
		5	+ *
		6	+ * This library implements the Modbus protocol.
		7	+ * http://libmodbus.org/
		8	+ */
		9	+
		10	+#include <stdio.h>
		11	+#include <string.h>
		12	+#include <stdlib.h>
		13	+#include <stdarg.h>
		14	+#include <errno.h>
		15	+#include <limits.h>
		16	+#include <time.h>
		17	+#ifndef _MSC_VER
		18	+#include <unistd.h>
		19	+#endif
		20	+
		21	+#include <config.h>
		22	+
		23	+#include "modbus.h"
		24	+#include "modbus-private.h"
		25	+
		26	+/* Internal use */
		27	+#define MSG_LENGTH_UNDEFINED -1
		28	+
		29	+/* Exported version */
		30	+const unsigned int libmodbus_version_major = LIBMODBUS_VERSION_MAJOR;
		31	+const unsigned int libmodbus_version_minor = LIBMODBUS_VERSION_MINOR;
		32	+const unsigned int libmodbus_version_micro = LIBMODBUS_VERSION_MICRO;
		33	+
		34	+/* Max between RTU and TCP max adu length (so TCP) */
		35	+#define MAX_MESSAGE_LENGTH 260
		36	+
		37	+/* 3 steps are used to parse the query */
		38	+typedef enum {
		39	+ _STEP_FUNCTION,
		40	+ _STEP_META,
		41	+ _STEP_DATA
		42	+} _step_t;
		43	+
		44	+const char *modbus_strerror(int errnum) {
		45	+ switch (errnum) {
		46	+ case EMBXILFUN:
		47	+ return "Illegal function";
		48	+ case EMBXILADD:
		49	+ return "Illegal data address";
		50	+ case EMBXILVAL:
		51	+ return "Illegal data value";
		52	+ case EMBXSFAIL:
		53	+ return "Slave device or server failure";
		54	+ case EMBXACK:
		55	+ return "Acknowledge";
		56	+ case EMBXSBUSY:
		57	+ return "Slave device or server is busy";
		58	+ case EMBXNACK:
		59	+ return "Negative acknowledge";
		60	+ case EMBXMEMPAR:
		61	+ return "Memory parity error";
		62	+ case EMBXGPATH:
		63	+ return "Gateway path unavailable";
		64	+ case EMBXGTAR:
		65	+ return "Target device failed to respond";
		66	+ case EMBBADCRC:
		67	+ return "Invalid CRC";
		68	+ case EMBBADDATA:
		69	+ return "Invalid data";
		70	+ case EMBBADEXC:
		71	+ return "Invalid exception code";
		72	+ case EMBMDATA:
		73	+ return "Too many data";
		74	+ case EMBBADSLAVE:
		75	+ return "Response not from requested slave";
		76	+ default:
		77	+ return strerror(errnum);
		78	+ }
		79	+}
		80	+
		81	+void _error_print(modbus_t ctx, const char context)
		82	+{
		83	+ if (ctx->debug) {
		84	+ fprintf(stderr, "ERROR %s", modbus_strerror(errno));
		85	+ if (context != NULL) {
		86	+ fprintf(stderr, ": %s\n", context);
		87	+ } else {
		88	+ fprintf(stderr, "\n");
		89	+ }
		90	+ }
		91	+}
		92	+
		93	+static void _sleep_response_timeout(modbus_t *ctx)
		94	+{
		95	+ /* Response timeout is always positive */
		96	+#ifdef _WIN32
		97	+ /* usleep doesn't exist on Windows */
		98	+ Sleep((ctx->response_timeout.tv_sec * 1000) +
		99	+ (ctx->response_timeout.tv_usec / 1000));
		100	+#else
		101	+ /* usleep source code */
		102	+ struct timespec request, remaining;
		103	+ request.tv_sec = ctx->response_timeout.tv_sec;
		104	+ request.tv_nsec = ((long int)ctx->response_timeout.tv_usec) * 1000;
		105	+ while (nanosleep(&request, &remaining) == -1 && errno == EINTR) {
		106	+ request = remaining;
		107	+ }
		108	+#endif
		109	+}
		110	+
		111	+int modbus_flush(modbus_t *ctx)
		112	+{
		113	+ int rc;
		114	+
		115	+ if (ctx == NULL) {
		116	+ errno = EINVAL;
		117	+ return -1;
		118	+ }
		119	+
		120	+ rc = ctx->backend->flush(ctx);
		121	+ if (rc != -1 && ctx->debug) {
		122	+ /* Not all backends are able to return the number of bytes flushed */
		123	+ printf("Bytes flushed (%d)\n", rc);
		124	+ }
		125	+ return rc;
		126	+}
		127	+
		128	+/* Computes the length of the expected response */
		129	+static unsigned int compute_response_length_from_request(modbus_t ctx, uint8_t req)
		130	+{
		131	+ int length;
		132	+ const int offset = ctx->backend->header_length;
		133	+
		134	+ switch (req[offset]) {
		135	+ case MODBUS_FC_READ_COILS:
		136	+ case MODBUS_FC_READ_DISCRETE_INPUTS: {
		137	+ /* Header + nb values (code from write_bits) */
		138	+ int nb = (req[offset + 3] << 8) \| req[offset + 4];
		139	+ length = 2 + (nb / 8) + ((nb % 8) ? 1 : 0);
		140	+ }
		141	+ break;
		142	+ case MODBUS_FC_WRITE_AND_READ_REGISTERS:
		143	+ case MODBUS_FC_READ_HOLDING_REGISTERS:
		144	+ case MODBUS_FC_READ_INPUT_REGISTERS:
		145	+ /* Header + 2 * nb values */
		146	+ length = 2 + 2 * (req[offset + 3] << 8 \| req[offset + 4]);
		147	+ break;
		148	+ case MODBUS_FC_READ_EXCEPTION_STATUS:
		149	+ length = 3;
		150	+ break;
		151	+ case MODBUS_FC_REPORT_SLAVE_ID:
		152	+ /* The response is device specific (the header provides the
		153	+ length) */
		154	+ return MSG_LENGTH_UNDEFINED;
		155	+ case MODBUS_FC_MASK_WRITE_REGISTER:
		156	+ length = 7;
		157	+ break;
		158	+ default:
		159	+ length = 5;
		160	+ }
		161	+
		162	+ return offset + length + ctx->backend->checksum_length;
		163	+}
		164	+
		165	+/* Sends a request/response */
		166	+static int send_msg(modbus_t ctx, uint8_t msg, int msg_length)
		167	+{
		168	+ int rc;
		169	+ int i;
		170	+
		171	+ msg_length = ctx->backend->send_msg_pre(msg, msg_length);
		172	+
		173	+ if (ctx->debug) {
		174	+ for (i = 0; i < msg_length; i++)
		175	+ printf("[%.2X]", msg[i]);
		176	+ printf("\n");
		177	+ }
		178	+
		179	+ /* In recovery mode, the write command will be issued until to be
		180	+ successful! Disabled by default. */
		181	+ do {
		182	+ rc = ctx->backend->send(ctx, msg, msg_length);
		183	+ if (rc == -1) {
		184	+ _error_print(ctx, NULL);
		185	+ if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) {
		186	+ int saved_errno = errno;
		187	+
		188	+ if ((errno == EBADF \|\| errno == ECONNRESET \|\| errno == EPIPE)) {
		189	+ modbus_close(ctx);
		190	+ _sleep_response_timeout(ctx);
		191	+ modbus_connect(ctx);
		192	+ } else {
		193	+ _sleep_response_timeout(ctx);
		194	+ modbus_flush(ctx);
		195	+ }
		196	+ errno = saved_errno;
		197	+ }
		198	+ }
		199	+ } while ((ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) &&
		200	+ rc == -1);
		201	+
		202	+ if (rc > 0 && rc != msg_length) {
		203	+ errno = EMBBADDATA;
		204	+ return -1;
		205	+ }
		206	+
		207	+ return rc;
		208	+}
		209	+
		210	+int modbus_send_raw_request(modbus_t ctx, uint8_t raw_req, int raw_req_length)
		211	+{
		212	+ sft_t sft;
		213	+ uint8_t req[MAX_MESSAGE_LENGTH];
		214	+ int req_length;
		215	+
		216	+ if (ctx == NULL) {
		217	+ errno = EINVAL;
		218	+ return -1;
		219	+ }
		220	+
		221	+ if (raw_req_length < 2 \|\| raw_req_length > (MODBUS_MAX_PDU_LENGTH + 1)) {
		222	+ /* The raw request must contain function and slave at least and
		223	+ must not be longer than the maximum pdu length plus the slave
		224	+ address. */
		225	+ errno = EINVAL;
		226	+ return -1;
		227	+ }
		228	+
		229	+ sft.slave = raw_req[0];
		230	+ sft.function = raw_req[1];
		231	+ /* The t_id is left to zero */
		232	+ sft.t_id = 0;
		233	+ /* This response function only set the header so it's convenient here */
		234	+ req_length = ctx->backend->build_response_basis(&sft, req);
		235	+
		236	+ if (raw_req_length > 2) {
		237	+ /* Copy data after function code */
		238	+ memcpy(req + req_length, raw_req + 2, raw_req_length - 2);
		239	+ req_length += raw_req_length - 2;
		240	+ }
		241	+
		242	+ return send_msg(ctx, req, req_length);
		243	+}
		244	+
		245	+/*
		246	+ * ---------- Request Indication ----------
		247	+ * \| Client \| ---------------------->\| Server \|
		248	+ * ---------- Confirmation Response ----------
		249	+ */
		250	+
		251	+/* Computes the length to read after the function received */
		252	+static uint8_t compute_meta_length_after_function(int function,
		253	+ msg_type_t msg_type)
		254	+{
		255	+ int length;
		256	+
		257	+ if (msg_type == MSG_INDICATION) {
		258	+ if (function <= MODBUS_FC_WRITE_SINGLE_REGISTER) {
		259	+ length = 4;
		260	+ } else if (function == MODBUS_FC_WRITE_MULTIPLE_COILS \|\|
		261	+ function == MODBUS_FC_WRITE_MULTIPLE_REGISTERS) {
		262	+ length = 5;
		263	+ } else if (function == MODBUS_FC_MASK_WRITE_REGISTER) {
		264	+ length = 6;
		265	+ } else if (function == MODBUS_FC_WRITE_AND_READ_REGISTERS) {
		266	+ length = 9;
		267	+ } else {
		268	+ /* MODBUS_FC_READ_EXCEPTION_STATUS, MODBUS_FC_REPORT_SLAVE_ID */
		269	+ length = 0;
		270	+ }
		271	+ } else {
		272	+ /* MSG_CONFIRMATION */
		273	+ switch (function) {
		274	+ case MODBUS_FC_WRITE_SINGLE_COIL:
		275	+ case MODBUS_FC_WRITE_SINGLE_REGISTER:
		276	+ case MODBUS_FC_WRITE_MULTIPLE_COILS:
		277	+ case MODBUS_FC_WRITE_MULTIPLE_REGISTERS:
		278	+ length = 4;
		279	+ break;
		280	+ case MODBUS_FC_MASK_WRITE_REGISTER:
		281	+ length = 6;
		282	+ break;
		283	+ default:
		284	+ length = 1;
		285	+ }
		286	+ }
		287	+
		288	+ return length;
		289	+}
		290	+
		291	+/* Computes the length to read after the meta information (address, count, etc) */
		292	+static int compute_data_length_after_meta(modbus_t ctx, uint8_t msg,
		293	+ msg_type_t msg_type)
		294	+{
		295	+ int function = msg[ctx->backend->header_length];
		296	+ int length;
		297	+
		298	+ if (msg_type == MSG_INDICATION) {
		299	+ switch (function) {
		300	+ case MODBUS_FC_WRITE_MULTIPLE_COILS:
		301	+ case MODBUS_FC_WRITE_MULTIPLE_REGISTERS:
		302	+ length = msg[ctx->backend->header_length + 5];
		303	+ break;
		304	+ case MODBUS_FC_WRITE_AND_READ_REGISTERS:
		305	+ length = msg[ctx->backend->header_length + 9];
		306	+ break;
		307	+ default:
		308	+ length = 0;
		309	+ }
		310	+ } else {
		311	+ /* MSG_CONFIRMATION */
		312	+ if (function <= MODBUS_FC_READ_INPUT_REGISTERS \|\|
		313	+ function == MODBUS_FC_REPORT_SLAVE_ID \|\|
		314	+ function == MODBUS_FC_WRITE_AND_READ_REGISTERS) {
		315	+ length = msg[ctx->backend->header_length + 1];
		316	+ } else {
		317	+ length = 0;
		318	+ }
		319	+ }
		320	+
		321	+ length += ctx->backend->checksum_length;
		322	+
		323	+ return length;
		324	+}
		325	+
		326	+
		327	+/* Waits a response from a modbus server or a request from a modbus client.
		328	+ This function blocks if there is no replies (3 timeouts).
		329	+
		330	+ The function shall return the number of received characters and the received
		331	+ message in an array of uint8_t if successful. Otherwise it shall return -1
		332	+ and errno is set to one of the values defined below:
		333	+ - ECONNRESET
		334	+ - EMBBADDATA
		335	+ - EMBUNKEXC
		336	+ - ETIMEDOUT
		337	+ - read() or recv() error codes
		338	+*/
		339	+
		340	+int _modbus_receive_msg(modbus_t ctx, uint8_t msg, msg_type_t msg_type)
		341	+{
		342	+ int rc;
		343	+ fd_set rset;
		344	+ struct timeval tv;
		345	+ struct timeval *p_tv;
		346	+ int length_to_read;
		347	+ int msg_length = 0;
		348	+ _step_t step;
		349	+
		350	+ if (ctx->debug) {
		351	+ if (msg_type == MSG_INDICATION) {
		352	+ printf("Waiting for a indication...\n");
		353	+ } else {
		354	+ printf("Waiting for a confirmation...\n");
		355	+ }
		356	+ }
		357	+
		358	+ /* Add a file descriptor to the set */
		359	+ FD_ZERO(&rset);
		360	+ FD_SET(ctx->s, &rset);
		361	+
		362	+ /* We need to analyse the message step by step. At the first step, we want
		363	+ * to reach the function code because all packets contain this
		364	+ * information. */
		365	+ step = _STEP_FUNCTION;
		366	+ length_to_read = ctx->backend->header_length + 1;
		367	+
		368	+ if (msg_type == MSG_INDICATION) {
		369	+ /* Wait for a message, we don't know when the message will be
		370	+ * received */
		371	+ p_tv = NULL;
		372	+ } else {
		373	+ tv.tv_sec = ctx->response_timeout.tv_sec;
		374	+ tv.tv_usec = ctx->response_timeout.tv_usec;
		375	+ p_tv = &tv;
		376	+ }
		377	+
		378	+ while (length_to_read != 0) {
		379	+ rc = ctx->backend->select(ctx, &rset, p_tv, length_to_read);
		380	+ if (rc == -1) {
		381	+ _error_print(ctx, "select");
		382	+ if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) {
		383	+ int saved_errno = errno;
		384	+
		385	+ if (errno == ETIMEDOUT) {
		386	+ _sleep_response_timeout(ctx);
		387	+ modbus_flush(ctx);
		388	+ } else if (errno == EBADF) {
		389	+ modbus_close(ctx);
		390	+ modbus_connect(ctx);
		391	+ }
		392	+ errno = saved_errno;
		393	+ }
		394	+ return -1;
		395	+ }
		396	+
		397	+ rc = ctx->backend->recv(ctx, msg + msg_length, length_to_read);
		398	+ if (rc == 0) {
		399	+ errno = ECONNRESET;
		400	+ rc = -1;
		401	+ }
		402	+
		403	+ if (rc == -1) {
		404	+ _error_print(ctx, "read");
		405	+ if ((ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) &&
		406	+ (errno == ECONNRESET \|\| errno == ECONNREFUSED \|\|
		407	+ errno == EBADF)) {
		408	+ int saved_errno = errno;
		409	+ modbus_close(ctx);
		410	+ modbus_connect(ctx);
		411	+ /* Could be removed by previous calls */
		412	+ errno = saved_errno;
		413	+ }
		414	+ return -1;
		415	+ }
		416	+
		417	+ /* Display the hex code of each character received */
		418	+ if (ctx->debug) {
		419	+ int i;
		420	+ for (i=0; i < rc; i++)
		421	+ printf("<%.2X>", msg[msg_length + i]);
		422	+ }
		423	+
		424	+ /* Sums bytes received */
		425	+ msg_length += rc;
		426	+ /* Computes remaining bytes */
		427	+ length_to_read -= rc;
		428	+
		429	+ if (length_to_read == 0) {
		430	+ switch (step) {
		431	+ case _STEP_FUNCTION:
		432	+ /* Function code position */
		433	+ length_to_read = compute_meta_length_after_function(
		434	+ msg[ctx->backend->header_length],
		435	+ msg_type);
		436	+ if (length_to_read != 0) {
		437	+ step = _STEP_META;
		438	+ break;
		439	+ } /* else switches straight to the next step */
		440	+ case _STEP_META:
		441	+ length_to_read = compute_data_length_after_meta(
		442	+ ctx, msg, msg_type);
		443	+ if ((msg_length + length_to_read) > (int)ctx->backend->max_adu_length) {
		444	+ errno = EMBBADDATA;
		445	+ _error_print(ctx, "too many data");
		446	+ return -1;
		447	+ }
		448	+ step = _STEP_DATA;
		449	+ break;
		450	+ default:
		451	+ break;
		452	+ }
		453	+ }
		454	+
		455	+ if (length_to_read > 0 &&
		456	+ (ctx->byte_timeout.tv_sec > 0 \|\| ctx->byte_timeout.tv_usec > 0)) {
		457	+ /* If there is no character in the buffer, the allowed timeout
		458	+ interval between two consecutive bytes is defined by
		459	+ byte_timeout */
		460	+ tv.tv_sec = ctx->byte_timeout.tv_sec;
		461	+ tv.tv_usec = ctx->byte_timeout.tv_usec;
		462	+ p_tv = &tv;
		463	+ }
		464	+ /* else timeout isn't set again, the full response must be read before
		465	+ expiration of response timeout (for CONFIRMATION only) */
		466	+ }
		467	+
		468	+ if (ctx->debug)
		469	+ printf("\n");
		470	+
		471	+ return ctx->backend->check_integrity(ctx, msg, msg_length);
		472	+}
		473	+
		474	+/* Receive the request from a modbus master */
		475	+int modbus_receive(modbus_t ctx, uint8_t req)
		476	+{
		477	+ if (ctx == NULL) {
		478	+ errno = EINVAL;
		479	+ return -1;
		480	+ }
		481	+
		482	+ return ctx->backend->receive(ctx, req);
		483	+}
		484	+
		485	+/* Receives the confirmation.
		486	+
		487	+ The function shall store the read response in rsp and return the number of
		488	+ values (bits or words). Otherwise, its shall return -1 and errno is set.
		489	+
		490	+ The function doesn't check the confirmation is the expected response to the
		491	+ initial request.
		492	+*/
		493	+int modbus_receive_confirmation(modbus_t ctx, uint8_t rsp)
		494	+{
		495	+ if (ctx == NULL) {
		496	+ errno = EINVAL;
		497	+ return -1;
		498	+ }
		499	+
		500	+ return _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION);
		501	+}
		502	+
		503	+static int check_confirmation(modbus_t ctx, uint8_t req,
		504	+ uint8_t *rsp, int rsp_length)
		505	+{
		506	+ int rc;
		507	+ int rsp_length_computed;
		508	+ const int offset = ctx->backend->header_length;
		509	+ const int function = rsp[offset];
		510	+
		511	+ if (ctx->backend->pre_check_confirmation) {
		512	+ rc = ctx->backend->pre_check_confirmation(ctx, req, rsp, rsp_length);
		513	+ if (rc == -1) {
		514	+ if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) {
		515	+ _sleep_response_timeout(ctx);
		516	+ modbus_flush(ctx);
		517	+ }
		518	+ return -1;
		519	+ }
		520	+ }
		521	+
		522	+ rsp_length_computed = compute_response_length_from_request(ctx, req);
		523	+
		524	+ /* Exception code */
		525	+ if (function >= 0x80) {
		526	+ if (rsp_length == (offset + 2 + (int)ctx->backend->checksum_length) &&
		527	+ req[offset] == (rsp[offset] - 0x80)) {
		528	+ /* Valid exception code received */
		529	+
		530	+ int exception_code = rsp[offset + 1];
		531	+ if (exception_code < MODBUS_EXCEPTION_MAX) {
		532	+ errno = MODBUS_ENOBASE + exception_code;
		533	+ } else {
		534	+ errno = EMBBADEXC;
		535	+ }
		536	+ _error_print(ctx, NULL);
		537	+ return -1;
		538	+ } else {
		539	+ errno = EMBBADEXC;
		540	+ _error_print(ctx, NULL);
		541	+ return -1;
		542	+ }
		543	+ }
		544	+
		545	+ /* Check length */
		546	+ if ((rsp_length == rsp_length_computed \|\|
		547	+ rsp_length_computed == MSG_LENGTH_UNDEFINED) &&
		548	+ function < 0x80) {
		549	+ int req_nb_value;
		550	+ int rsp_nb_value;
		551	+
		552	+ /* Check function code */
		553	+ if (function != req[offset]) {
		554	+ if (ctx->debug) {
		555	+ fprintf(stderr,
		556	+ "Received function not corresponding to the request (0x%X != 0x%X)\n",
		557	+ function, req[offset]);
		558	+ }
		559	+ if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) {
		560	+ _sleep_response_timeout(ctx);
		561	+ modbus_flush(ctx);
		562	+ }
		563	+ errno = EMBBADDATA;
		564	+ return -1;
		565	+ }
		566	+
		567	+ /* Check the number of values is corresponding to the request */
		568	+ switch (function) {
		569	+ case MODBUS_FC_READ_COILS:
		570	+ case MODBUS_FC_READ_DISCRETE_INPUTS:
		571	+ /* Read functions, 8 values in a byte (nb
		572	+ * of values in the request and byte count in
		573	+ * the response. */
		574	+ req_nb_value = (req[offset + 3] << 8) + req[offset + 4];
		575	+ req_nb_value = (req_nb_value / 8) + ((req_nb_value % 8) ? 1 : 0);
		576	+ rsp_nb_value = rsp[offset + 1];
		577	+ break;
		578	+ case MODBUS_FC_WRITE_AND_READ_REGISTERS:
		579	+ case MODBUS_FC_READ_HOLDING_REGISTERS:
		580	+ case MODBUS_FC_READ_INPUT_REGISTERS:
		581	+ /* Read functions 1 value = 2 bytes */
		582	+ req_nb_value = (req[offset + 3] << 8) + req[offset + 4];
		583	+ rsp_nb_value = (rsp[offset + 1] / 2);
		584	+ break;
		585	+ case MODBUS_FC_WRITE_MULTIPLE_COILS:
		586	+ case MODBUS_FC_WRITE_MULTIPLE_REGISTERS:
		587	+ /* N Write functions */
		588	+ req_nb_value = (req[offset + 3] << 8) + req[offset + 4];
		589	+ rsp_nb_value = (rsp[offset + 3] << 8) \| rsp[offset + 4];
		590	+ break;
		591	+ case MODBUS_FC_REPORT_SLAVE_ID:
		592	+ /* Report slave ID (bytes received) */
		593	+ req_nb_value = rsp_nb_value = rsp[offset + 1];
		594	+ break;
		595	+ default:
		596	+ /* 1 Write functions & others */
		597	+ req_nb_value = rsp_nb_value = 1;
		598	+ }
		599	+
		600	+ if (req_nb_value == rsp_nb_value) {
		601	+ rc = rsp_nb_value;
		602	+ } else {
		603	+ if (ctx->debug) {
		604	+ fprintf(stderr,
		605	+ "Quantity not corresponding to the request (%d != %d)\n",
		606	+ rsp_nb_value, req_nb_value);
		607	+ }
		608	+
		609	+ if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) {
		610	+ _sleep_response_timeout(ctx);
		611	+ modbus_flush(ctx);
		612	+ }
		613	+
		614	+ errno = EMBBADDATA;
		615	+ rc = -1;
		616	+ }
		617	+ } else {
		618	+ if (ctx->debug) {
		619	+ fprintf(stderr,
		620	+ "Message length not corresponding to the computed length (%d != %d)\n",
		621	+ rsp_length, rsp_length_computed);
		622	+ }
		623	+ if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) {
		624	+ _sleep_response_timeout(ctx);
		625	+ modbus_flush(ctx);
		626	+ }
		627	+ errno = EMBBADDATA;
		628	+ rc = -1;
		629	+ }
		630	+
		631	+ return rc;
		632	+}
		633	+
		634	+static int response_io_status(uint8_t *tab_io_status,
		635	+ int address, int nb,
		636	+ uint8_t *rsp, int offset)
		637	+{
		638	+ int shift = 0;
		639	+ /* Instead of byte (not allowed in Win32) */
		640	+ int one_byte = 0;
		641	+ int i;
		642	+
		643	+ for (i = address; i < address + nb; i++) {
		644	+ one_byte \|= tab_io_status[i] << shift;
		645	+ if (shift == 7) {
		646	+ /* Byte is full */
		647	+ rsp[offset++] = one_byte;
		648	+ one_byte = shift = 0;
		649	+ } else {
		650	+ shift++;
		651	+ }
		652	+ }
		653	+
		654	+ if (shift != 0)
		655	+ rsp[offset++] = one_byte;
		656	+
		657	+ return offset;
		658	+}
		659	+
		660	+/* Build the exception response */
		661	+static int response_exception(modbus_t ctx, sft_t sft,
		662	+ int exception_code, uint8_t *rsp,
		663	+ unsigned int to_flush,
		664	+ const char* template, ...)
		665	+{
		666	+ int rsp_length;
		667	+
		668	+ /* Print debug message */
		669	+ if (ctx->debug) {
		670	+ va_list ap;
		671	+
		672	+ va_start(ap, template);
		673	+ vfprintf(stderr, template, ap);
		674	+ va_end(ap);
		675	+ }
		676	+
		677	+ /* Flush if required */
		678	+ if (to_flush) {
		679	+ _sleep_response_timeout(ctx);
		680	+ modbus_flush(ctx);
		681	+ }
		682	+
		683	+ /* Build exception response */
		684	+ sft->function = sft->function + 0x80;
		685	+ rsp_length = ctx->backend->build_response_basis(sft, rsp);
		686	+ rsp[rsp_length++] = exception_code;
		687	+
		688	+ return rsp_length;
		689	+}
		690	+
		691	+/* Send a response to the received request.
		692	+ Analyses the request and constructs a response.
		693	+
		694	+ If an error occurs, this function construct the response
		695	+ accordingly.
		696	+*/
		697	+int modbus_reply(modbus_t ctx, const uint8_t req,
		698	+ int req_length, modbus_mapping_t *mb_mapping)
		699	+{
		700	+ int offset;
		701	+ int slave;
		702	+ int function;
		703	+ uint16_t address;
		704	+ uint8_t rsp[MAX_MESSAGE_LENGTH];
		705	+ int rsp_length = 0;
		706	+ sft_t sft;
		707	+
		708	+ if (ctx == NULL) {
		709	+ errno = EINVAL;
		710	+ return -1;
		711	+ }
		712	+
		713	+ offset = ctx->backend->header_length;
		714	+ slave = req[offset - 1];
		715	+ function = req[offset];
		716	+ address = (req[offset + 1] << 8) + req[offset + 2];
		717	+
		718	+ sft.slave = slave;
		719	+ sft.function = function;
		720	+ sft.t_id = ctx->backend->prepare_response_tid(req, &req_length);
		721	+
		722	+ /* Data are flushed on illegal number of values errors. */
		723	+ switch (function) {
		724	+ case MODBUS_FC_READ_COILS:
		725	+ case MODBUS_FC_READ_DISCRETE_INPUTS: {
		726	+ unsigned int is_input = (function == MODBUS_FC_READ_DISCRETE_INPUTS);
		727	+ int start_bits = is_input ? mb_mapping->start_input_bits : mb_mapping->start_bits;
		728	+ int nb_bits = is_input ? mb_mapping->nb_input_bits : mb_mapping->nb_bits;
		729	+ uint8_t *tab_bits = is_input ? mb_mapping->tab_input_bits : mb_mapping->tab_bits;
		730	+ const char * const name = is_input ? "read_input_bits" : "read_bits";
		731	+ int nb = (req[offset + 3] << 8) + req[offset + 4];
		732	+ /* The mapping can be shifted to reduce memory consumption and it
		733	+ doesn't always start at address zero. */
		734	+ int mapping_address = address - start_bits;
		735	+
		736	+ if (nb < 1 \|\| MODBUS_MAX_READ_BITS < nb) {
		737	+ rsp_length = response_exception(
		738	+ ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE,
		739	+ "Illegal nb of values %d in %s (max %d)\n",
		740	+ nb, name, MODBUS_MAX_READ_BITS);
		741	+ } else if (mapping_address < 0 \|\| (mapping_address + nb) > nb_bits) {
		742	+ rsp_length = response_exception(
		743	+ ctx, &sft,
		744	+ MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE,
		745	+ "Illegal data address 0x%0X in %s\n",
		746	+ mapping_address < 0 ? address : address + nb, name);
		747	+ } else {
		748	+ rsp_length = ctx->backend->build_response_basis(&sft, rsp);
		749	+ rsp[rsp_length++] = (nb / 8) + ((nb % 8) ? 1 : 0);
		750	+ rsp_length = response_io_status(tab_bits, mapping_address, nb,
		751	+ rsp, rsp_length);
		752	+ }
		753	+ }
		754	+ break;
		755	+ case MODBUS_FC_READ_HOLDING_REGISTERS:
		756	+ case MODBUS_FC_READ_INPUT_REGISTERS: {
		757	+ unsigned int is_input = (function == MODBUS_FC_READ_INPUT_REGISTERS);
		758	+ int start_registers = is_input ? mb_mapping->start_input_registers : mb_mapping->start_registers;
		759	+ int nb_registers = is_input ? mb_mapping->nb_input_registers : mb_mapping->nb_registers;
		760	+ uint16_t *tab_registers = is_input ? mb_mapping->tab_input_registers : mb_mapping->tab_registers;
		761	+ const char * const name = is_input ? "read_input_registers" : "read_registers";
		762	+ int nb = (req[offset + 3] << 8) + req[offset + 4];
		763	+ /* The mapping can be shifted to reduce memory consumption and it
		764	+ doesn't always start at address zero. */
		765	+ int mapping_address = address - start_registers;
		766	+
		767	+ if (nb < 1 \|\| MODBUS_MAX_READ_REGISTERS < nb) {
		768	+ rsp_length = response_exception(
		769	+ ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE,
		770	+ "Illegal nb of values %d in %s (max %d)\n",
		771	+ nb, name, MODBUS_MAX_READ_REGISTERS);
		772	+ } else if (mapping_address < 0 \|\| (mapping_address + nb) > nb_registers) {
		773	+ rsp_length = response_exception(
		774	+ ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE,
		775	+ "Illegal data address 0x%0X in %s\n",
		776	+ mapping_address < 0 ? address : address + nb, name);
		777	+ } else {
		778	+ int i;
		779	+
		780	+ rsp_length = ctx->backend->build_response_basis(&sft, rsp);
		781	+ rsp[rsp_length++] = nb << 1;
		782	+ for (i = mapping_address; i < mapping_address + nb; i++) {
		783	+ rsp[rsp_length++] = tab_registers[i] >> 8;
		784	+ rsp[rsp_length++] = tab_registers[i] & 0xFF;
		785	+ }
		786	+ }
		787	+ }
		788	+ break;
		789	+ case MODBUS_FC_WRITE_SINGLE_COIL: {
		790	+ int mapping_address = address - mb_mapping->start_bits;
		791	+
		792	+ if (mapping_address < 0 \|\| mapping_address >= mb_mapping->nb_bits) {
		793	+ rsp_length = response_exception(
		794	+ ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE,
		795	+ "Illegal data address 0x%0X in write_bit\n",
		796	+ address);
		797	+ } else {
		798	+ int data = (req[offset + 3] << 8) + req[offset + 4];
		799	+
		800	+ if (data == 0xFF00 \|\| data == 0x0) {
		801	+ mb_mapping->tab_bits[mapping_address] = data ? ON : OFF;
		802	+ memcpy(rsp, req, req_length);
		803	+ rsp_length = req_length;
		804	+ } else {
		805	+ rsp_length = response_exception(
		806	+ ctx, &sft,
		807	+ MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, FALSE,
		808	+ "Illegal data value 0x%0X in write_bit request at address %0X\n",
		809	+ data, address);
		810	+ }
		811	+ }
		812	+ }
		813	+ break;
		814	+ case MODBUS_FC_WRITE_SINGLE_REGISTER: {
		815	+ int mapping_address = address - mb_mapping->start_registers;
		816	+
		817	+ if (mapping_address < 0 \|\| mapping_address >= mb_mapping->nb_registers) {
		818	+ rsp_length = response_exception(
		819	+ ctx, &sft,
		820	+ MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE,
		821	+ "Illegal data address 0x%0X in write_register\n",
		822	+ address);
		823	+ } else {
		824	+ int data = (req[offset + 3] << 8) + req[offset + 4];
		825	+
		826	+ mb_mapping->tab_registers[mapping_address] = data;
		827	+ memcpy(rsp, req, req_length);
		828	+ rsp_length = req_length;
		829	+ }
		830	+ }
		831	+ break;
		832	+ case MODBUS_FC_WRITE_MULTIPLE_COILS: {
		833	+ int nb = (req[offset + 3] << 8) + req[offset + 4];
		834	+ int mapping_address = address - mb_mapping->start_bits;
		835	+
		836	+ if (nb < 1 \|\| MODBUS_MAX_WRITE_BITS < nb) {
		837	+ /* May be the indication has been truncated on reading because of
		838	+ * invalid address (eg. nb is 0 but the request contains values to
		839	+ * write) so it's necessary to flush. */
		840	+ rsp_length = response_exception(
		841	+ ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE,
		842	+ "Illegal number of values %d in write_bits (max %d)\n",
		843	+ nb, MODBUS_MAX_WRITE_BITS);
		844	+ } else if (mapping_address < 0 \|\|
		845	+ (mapping_address + nb) > mb_mapping->nb_bits) {
		846	+ rsp_length = response_exception(
		847	+ ctx, &sft,
		848	+ MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE,
		849	+ "Illegal data address 0x%0X in write_bits\n",
		850	+ mapping_address < 0 ? address : address + nb);
		851	+ } else {
		852	+ /* 6 = byte count */
		853	+ modbus_set_bits_from_bytes(mb_mapping->tab_bits, mapping_address, nb,
		854	+ &req[offset + 6]);
		855	+
		856	+ rsp_length = ctx->backend->build_response_basis(&sft, rsp);
		857	+ /* 4 to copy the bit address (2) and the quantity of bits */
		858	+ memcpy(rsp + rsp_length, req + rsp_length, 4);
		859	+ rsp_length += 4;
		860	+ }
		861	+ }
		862	+ break;
		863	+ case MODBUS_FC_WRITE_MULTIPLE_REGISTERS: {
		864	+ int nb = (req[offset + 3] << 8) + req[offset + 4];
		865	+ int mapping_address = address - mb_mapping->start_registers;
		866	+
		867	+ if (nb < 1 \|\| MODBUS_MAX_WRITE_REGISTERS < nb) {
		868	+ rsp_length = response_exception(
		869	+ ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE,
		870	+ "Illegal number of values %d in write_registers (max %d)\n",
		871	+ nb, MODBUS_MAX_WRITE_REGISTERS);
		872	+ } else if (mapping_address < 0 \|\|
		873	+ (mapping_address + nb) > mb_mapping->nb_registers) {
		874	+ rsp_length = response_exception(
		875	+ ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE,
		876	+ "Illegal data address 0x%0X in write_registers\n",
		877	+ mapping_address < 0 ? address : address + nb);
		878	+ } else {
		879	+ int i, j;
		880	+ for (i = mapping_address, j = 6; i < mapping_address + nb; i++, j += 2) {
		881	+ /* 6 and 7 = first value */
		882	+ mb_mapping->tab_registers[i] =
		883	+ (req[offset + j] << 8) + req[offset + j + 1];
		884	+ }
		885	+
		886	+ rsp_length = ctx->backend->build_response_basis(&sft, rsp);
		887	+ /* 4 to copy the address (2) and the no. of registers */
		888	+ memcpy(rsp + rsp_length, req + rsp_length, 4);
		889	+ rsp_length += 4;
		890	+ }
		891	+ }
		892	+ break;
		893	+ case MODBUS_FC_REPORT_SLAVE_ID: {
		894	+ int str_len;
		895	+ int byte_count_pos;
		896	+
		897	+ rsp_length = ctx->backend->build_response_basis(&sft, rsp);
		898	+ /* Skip byte count for now */
		899	+ byte_count_pos = rsp_length++;
		900	+ rsp[rsp_length++] = _REPORT_SLAVE_ID;
		901	+ /* Run indicator status to ON */
		902	+ rsp[rsp_length++] = 0xFF;
		903	+ /* LMB + length of LIBMODBUS_VERSION_STRING */
		904	+ str_len = 3 + strlen(LIBMODBUS_VERSION_STRING);
		905	+ memcpy(rsp + rsp_length, "LMB" LIBMODBUS_VERSION_STRING, str_len);
		906	+ rsp_length += str_len;
		907	+ rsp[byte_count_pos] = rsp_length - byte_count_pos - 1;
		908	+ }
		909	+ break;
		910	+ case MODBUS_FC_READ_EXCEPTION_STATUS:
		911	+ if (ctx->debug) {
		912	+ fprintf(stderr, "FIXME Not implemented\n");
		913	+ }
		914	+ errno = ENOPROTOOPT;
		915	+ return -1;
		916	+ break;
		917	+ case MODBUS_FC_MASK_WRITE_REGISTER: {
		918	+ int mapping_address = address - mb_mapping->start_registers;
		919	+
		920	+ if (mapping_address < 0 \|\| mapping_address >= mb_mapping->nb_registers) {
		921	+ rsp_length = response_exception(
		922	+ ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE,
		923	+ "Illegal data address 0x%0X in write_register\n",
		924	+ address);
		925	+ } else {
		926	+ uint16_t data = mb_mapping->tab_registers[mapping_address];
		927	+ uint16_t and = (req[offset + 3] << 8) + req[offset + 4];
		928	+ uint16_t or = (req[offset + 5] << 8) + req[offset + 6];
		929	+
		930	+ data = (data & and) \| (or & (~and));
		931	+ mb_mapping->tab_registers[mapping_address] = data;
		932	+ memcpy(rsp, req, req_length);
		933	+ rsp_length = req_length;
		934	+ }
		935	+ }
		936	+ break;
		937	+ case MODBUS_FC_WRITE_AND_READ_REGISTERS: {
		938	+ int nb = (req[offset + 3] << 8) + req[offset + 4];
		939	+ uint16_t address_write = (req[offset + 5] << 8) + req[offset + 6];
		940	+ int nb_write = (req[offset + 7] << 8) + req[offset + 8];
		941	+ int nb_write_bytes = req[offset + 9];
		942	+ int mapping_address = address - mb_mapping->start_registers;
		943	+ int mapping_address_write = address_write - mb_mapping->start_registers;
		944	+
		945	+ if (nb_write < 1 \|\| MODBUS_MAX_WR_WRITE_REGISTERS < nb_write \|\|
		946	+ nb < 1 \|\| MODBUS_MAX_WR_READ_REGISTERS < nb \|\|
		947	+ nb_write_bytes != nb_write * 2) {
		948	+ rsp_length = response_exception(
		949	+ ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE,
		950	+ "Illegal nb of values (W%d, R%d) in write_and_read_registers (max W%d, R%d)\n",
		951	+ nb_write, nb, MODBUS_MAX_WR_WRITE_REGISTERS, MODBUS_MAX_WR_READ_REGISTERS);
		952	+ } else if (mapping_address < 0 \|\|
		953	+ (mapping_address + nb) > mb_mapping->nb_registers \|\|
		954	+ mapping_address < 0 \|\|
		955	+ (mapping_address_write + nb_write) > mb_mapping->nb_registers) {
		956	+ rsp_length = response_exception(
		957	+ ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE,
		958	+ "Illegal data read address 0x%0X or write address 0x%0X write_and_read_registers\n",
		959	+ mapping_address < 0 ? address : address + nb,
		960	+ mapping_address_write < 0 ? address_write : address_write + nb_write);
		961	+ } else {
		962	+ int i, j;
		963	+ rsp_length = ctx->backend->build_response_basis(&sft, rsp);
		964	+ rsp[rsp_length++] = nb << 1;
		965	+
		966	+ /* Write first.
		967	+ 10 and 11 are the offset of the first values to write */
		968	+ for (i = mapping_address_write, j = 10;
		969	+ i < mapping_address_write + nb_write; i++, j += 2) {
		970	+ mb_mapping->tab_registers[i] =
		971	+ (req[offset + j] << 8) + req[offset + j + 1];
		972	+ }
		973	+
		974	+ /* and read the data for the response */
		975	+ for (i = mapping_address; i < mapping_address + nb; i++) {
		976	+ rsp[rsp_length++] = mb_mapping->tab_registers[i] >> 8;
		977	+ rsp[rsp_length++] = mb_mapping->tab_registers[i] & 0xFF;
		978	+ }
		979	+ }
		980	+ }
		981	+ break;
		982	+
		983	+ default:
		984	+ rsp_length = response_exception(
		985	+ ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_FUNCTION, rsp, TRUE,
		986	+ "Unknown Modbus function code: 0x%0X\n", function);
		987	+ break;
		988	+ }
		989	+
		990	+ /* Suppress any responses when the request was a broadcast */
		991	+ return (slave == MODBUS_BROADCAST_ADDRESS) ? 0 : send_msg(ctx, rsp, rsp_length);
		992	+}
		993	+
		994	+int modbus_reply_exception(modbus_t ctx, const uint8_t req,
		995	+ unsigned int exception_code)
		996	+{
		997	+ int offset;
		998	+ int slave;
		999	+ int function;
		1000	+ uint8_t rsp[MAX_MESSAGE_LENGTH];
		1001	+ int rsp_length;
		1002	+ int dummy_length = 99;
		1003	+ sft_t sft;
		1004	+
		1005	+ if (ctx == NULL) {
		1006	+ errno = EINVAL;
		1007	+ return -1;
		1008	+ }
		1009	+
		1010	+ offset = ctx->backend->header_length;
		1011	+ slave = req[offset - 1];
		1012	+ function = req[offset];
		1013	+
		1014	+ sft.slave = slave;
		1015	+ sft.function = function + 0x80;;
		1016	+ sft.t_id = ctx->backend->prepare_response_tid(req, &dummy_length);
		1017	+ rsp_length = ctx->backend->build_response_basis(&sft, rsp);
		1018	+
		1019	+ /* Positive exception code */
		1020	+ if (exception_code < MODBUS_EXCEPTION_MAX) {
		1021	+ rsp[rsp_length++] = exception_code;
		1022	+ return send_msg(ctx, rsp, rsp_length);
		1023	+ } else {
		1024	+ errno = EINVAL;
		1025	+ return -1;
		1026	+ }
		1027	+}
		1028	+
		1029	+/* Reads IO status */
		1030	+static int read_io_status(modbus_t *ctx, int function,
		1031	+ int addr, int nb, uint8_t *dest)
		1032	+{
		1033	+ int rc;
		1034	+ int req_length;
		1035	+
		1036	+ uint8_t req[_MIN_REQ_LENGTH];
		1037	+ uint8_t rsp[MAX_MESSAGE_LENGTH];
		1038	+
		1039	+ req_length = ctx->backend->build_request_basis(ctx, function, addr, nb, req);
		1040	+
		1041	+ rc = send_msg(ctx, req, req_length);
		1042	+ if (rc > 0) {
		1043	+ int i, temp, bit;
		1044	+ int pos = 0;
		1045	+ int offset;
		1046	+ int offset_end;
		1047	+
		1048	+ rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION);
		1049	+ if (rc == -1)
		1050	+ return -1;
		1051	+
		1052	+ rc = check_confirmation(ctx, req, rsp, rc);
		1053	+ if (rc == -1)
		1054	+ return -1;
		1055	+
		1056	+ offset = ctx->backend->header_length + 2;
		1057	+ offset_end = offset + rc;
		1058	+ for (i = offset; i < offset_end; i++) {
		1059	+ /* Shift reg hi_byte to temp */
		1060	+ temp = rsp[i];
		1061	+
		1062	+ for (bit = 0x01; (bit & 0xff) && (pos < nb);) {
		1063	+ dest[pos++] = (temp & bit) ? TRUE : FALSE;
		1064	+ bit = bit << 1;
		1065	+ }
		1066	+
		1067	+ }
		1068	+ }
		1069	+
		1070	+ return rc;
		1071	+}
		1072	+
		1073	+/* Reads the boolean status of bits and sets the array elements
		1074	+ in the destination to TRUE or FALSE (single bits). */
		1075	+int modbus_read_bits(modbus_t ctx, int addr, int nb, uint8_t dest)
		1076	+{
		1077	+ int rc;
		1078	+
		1079	+ if (ctx == NULL) {
		1080	+ errno = EINVAL;
		1081	+ return -1;
		1082	+ }
		1083	+
		1084	+ if (nb > MODBUS_MAX_READ_BITS) {
		1085	+ if (ctx->debug) {
		1086	+ fprintf(stderr,
		1087	+ "ERROR Too many bits requested (%d > %d)\n",
		1088	+ nb, MODBUS_MAX_READ_BITS);
		1089	+ }
		1090	+ errno = EMBMDATA;
		1091	+ return -1;
		1092	+ }
		1093	+
		1094	+ rc = read_io_status(ctx, MODBUS_FC_READ_COILS, addr, nb, dest);
		1095	+
		1096	+ if (rc == -1)
		1097	+ return -1;
		1098	+ else
		1099	+ return nb;
		1100	+}
		1101	+
		1102	+
		1103	+/* Same as modbus_read_bits but reads the remote device input table */
		1104	+int modbus_read_input_bits(modbus_t ctx, int addr, int nb, uint8_t dest)
		1105	+{
		1106	+ int rc;
		1107	+
		1108	+ if (ctx == NULL) {
		1109	+ errno = EINVAL;
		1110	+ return -1;
		1111	+ }
		1112	+
		1113	+ if (nb > MODBUS_MAX_READ_BITS) {
		1114	+ if (ctx->debug) {
		1115	+ fprintf(stderr,
		1116	+ "ERROR Too many discrete inputs requested (%d > %d)\n",
		1117	+ nb, MODBUS_MAX_READ_BITS);
		1118	+ }
		1119	+ errno = EMBMDATA;
		1120	+ return -1;
		1121	+ }
		1122	+
		1123	+ rc = read_io_status(ctx, MODBUS_FC_READ_DISCRETE_INPUTS, addr, nb, dest);
		1124	+
		1125	+ if (rc == -1)
		1126	+ return -1;
		1127	+ else
		1128	+ return nb;
		1129	+}
		1130	+
		1131	+/* Reads the data from a remove device and put that data into an array */
		1132	+static int read_registers(modbus_t *ctx, int function, int addr, int nb,
		1133	+ uint16_t *dest)
		1134	+{
		1135	+ int rc;
		1136	+ int req_length;
		1137	+ uint8_t req[_MIN_REQ_LENGTH];
		1138	+ uint8_t rsp[MAX_MESSAGE_LENGTH];
		1139	+
		1140	+ if (nb > MODBUS_MAX_READ_REGISTERS) {
		1141	+ if (ctx->debug) {
		1142	+ fprintf(stderr,
		1143	+ "ERROR Too many registers requested (%d > %d)\n",
		1144	+ nb, MODBUS_MAX_READ_REGISTERS);
		1145	+ }
		1146	+ errno = EMBMDATA;
		1147	+ return -1;
		1148	+ }
		1149	+
		1150	+ req_length = ctx->backend->build_request_basis(ctx, function, addr, nb, req);
		1151	+
		1152	+ rc = send_msg(ctx, req, req_length);
		1153	+ if (rc > 0) {
		1154	+ int offset;
		1155	+ int i;
		1156	+
		1157	+ rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION);
		1158	+ if (rc == -1)
		1159	+ return -1;
		1160	+
		1161	+ rc = check_confirmation(ctx, req, rsp, rc);
		1162	+ if (rc == -1)
		1163	+ return -1;
		1164	+
		1165	+ offset = ctx->backend->header_length;
		1166	+
		1167	+ for (i = 0; i < rc; i++) {
		1168	+ /* shift reg hi_byte to temp OR with lo_byte */
		1169	+ dest[i] = (rsp[offset + 2 + (i << 1)] << 8) \|
		1170	+ rsp[offset + 3 + (i << 1)];
		1171	+ }
		1172	+ }
		1173	+
		1174	+ return rc;
		1175	+}
		1176	+
		1177	+/* Reads the holding registers of remote device and put the data into an
		1178	+ array */
		1179	+int modbus_read_registers(modbus_t ctx, int addr, int nb, uint16_t dest)
		1180	+{
		1181	+ int status;
		1182	+
		1183	+ if (ctx == NULL) {
		1184	+ errno = EINVAL;
		1185	+ return -1;
		1186	+ }
		1187	+
		1188	+ if (nb > MODBUS_MAX_READ_REGISTERS) {
		1189	+ if (ctx->debug) {
		1190	+ fprintf(stderr,
		1191	+ "ERROR Too many registers requested (%d > %d)\n",
		1192	+ nb, MODBUS_MAX_READ_REGISTERS);
		1193	+ }
		1194	+ errno = EMBMDATA;
		1195	+ return -1;
		1196	+ }
		1197	+
		1198	+ status = read_registers(ctx, MODBUS_FC_READ_HOLDING_REGISTERS,
		1199	+ addr, nb, dest);
		1200	+ return status;
		1201	+}
		1202	+
		1203	+/* Reads the input registers of remote device and put the data into an array */
		1204	+int modbus_read_input_registers(modbus_t *ctx, int addr, int nb,
		1205	+ uint16_t *dest)
		1206	+{
		1207	+ int status;
		1208	+
		1209	+ if (ctx == NULL) {
		1210	+ errno = EINVAL;
		1211	+ return -1;
		1212	+ }
		1213	+
		1214	+ if (nb > MODBUS_MAX_READ_REGISTERS) {
		1215	+ fprintf(stderr,
		1216	+ "ERROR Too many input registers requested (%d > %d)\n",
		1217	+ nb, MODBUS_MAX_READ_REGISTERS);
		1218	+ errno = EMBMDATA;
		1219	+ return -1;
		1220	+ }
		1221	+
		1222	+ status = read_registers(ctx, MODBUS_FC_READ_INPUT_REGISTERS,
		1223	+ addr, nb, dest);
		1224	+
		1225	+ return status;
		1226	+}
		1227	+
		1228	+/* Write a value to the specified register of the remote device.
		1229	+ Used by write_bit and write_register */
		1230	+static int write_single(modbus_t *ctx, int function, int addr, int value)
		1231	+{
		1232	+ int rc;
		1233	+ int req_length;
		1234	+ uint8_t req[_MIN_REQ_LENGTH];
		1235	+
		1236	+ if (ctx == NULL) {
		1237	+ errno = EINVAL;
		1238	+ return -1;
		1239	+ }
		1240	+
		1241	+ req_length = ctx->backend->build_request_basis(ctx, function, addr, value, req);
		1242	+
		1243	+ rc = send_msg(ctx, req, req_length);
		1244	+ if (rc > 0) {
		1245	+ /* Used by write_bit and write_register */
		1246	+ uint8_t rsp[MAX_MESSAGE_LENGTH];
		1247	+
		1248	+ rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION);
		1249	+ if (rc == -1)
		1250	+ return -1;
		1251	+
		1252	+ rc = check_confirmation(ctx, req, rsp, rc);
		1253	+ }
		1254	+
		1255	+ return rc;
		1256	+}
		1257	+
		1258	+/* Turns ON or OFF a single bit of the remote device */
		1259	+int modbus_write_bit(modbus_t *ctx, int addr, int status)
		1260	+{
		1261	+ if (ctx == NULL) {
		1262	+ errno = EINVAL;
		1263	+ return -1;
		1264	+ }
		1265	+
		1266	+ return write_single(ctx, MODBUS_FC_WRITE_SINGLE_COIL, addr,
		1267	+ status ? 0xFF00 : 0);
		1268	+}
		1269	+
		1270	+/* Writes a value in one register of the remote device */
		1271	+int modbus_write_register(modbus_t *ctx, int addr, int value)
		1272	+{
		1273	+ if (ctx == NULL) {
		1274	+ errno = EINVAL;
		1275	+ return -1;
		1276	+ }
		1277	+
		1278	+ return write_single(ctx, MODBUS_FC_WRITE_SINGLE_REGISTER, addr, value);
		1279	+}
		1280	+
		1281	+/* Write the bits of the array in the remote device */
		1282	+int modbus_write_bits(modbus_t ctx, int addr, int nb, const uint8_t src)
		1283	+{
		1284	+ int rc;
		1285	+ int i;
		1286	+ int byte_count;
		1287	+ int req_length;
		1288	+ int bit_check = 0;
		1289	+ int pos = 0;
		1290	+ uint8_t req[MAX_MESSAGE_LENGTH];
		1291	+
		1292	+ if (ctx == NULL) {
		1293	+ errno = EINVAL;
		1294	+ return -1;
		1295	+ }
		1296	+
		1297	+ if (nb > MODBUS_MAX_WRITE_BITS) {
		1298	+ if (ctx->debug) {
		1299	+ fprintf(stderr, "ERROR Writing too many bits (%d > %d)\n",
		1300	+ nb, MODBUS_MAX_WRITE_BITS);
		1301	+ }
		1302	+ errno = EMBMDATA;
		1303	+ return -1;
		1304	+ }
		1305	+
		1306	+ req_length = ctx->backend->build_request_basis(ctx,
		1307	+ MODBUS_FC_WRITE_MULTIPLE_COILS,
		1308	+ addr, nb, req);
		1309	+ byte_count = (nb / 8) + ((nb % 8) ? 1 : 0);
		1310	+ req[req_length++] = byte_count;
		1311	+
		1312	+ for (i = 0; i < byte_count; i++) {
		1313	+ int bit;
		1314	+
		1315	+ bit = 0x01;
		1316	+ req[req_length] = 0;
		1317	+
		1318	+ while ((bit & 0xFF) && (bit_check++ < nb)) {
		1319	+ if (src[pos++])
		1320	+ req[req_length] \|= bit;
		1321	+ else
		1322	+ req[req_length] &=~ bit;
		1323	+
		1324	+ bit = bit << 1;
		1325	+ }
		1326	+ req_length++;
		1327	+ }
		1328	+
		1329	+ rc = send_msg(ctx, req, req_length);
		1330	+ if (rc > 0) {
		1331	+ uint8_t rsp[MAX_MESSAGE_LENGTH];
		1332	+
		1333	+ rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION);
		1334	+ if (rc == -1)
		1335	+ return -1;
		1336	+
		1337	+ rc = check_confirmation(ctx, req, rsp, rc);
		1338	+ }
		1339	+
		1340	+
		1341	+ return rc;
		1342	+}
		1343	+
		1344	+/* Write the values from the array to the registers of the remote device */
		1345	+int modbus_write_registers(modbus_t ctx, int addr, int nb, const uint16_t src)
		1346	+{
		1347	+ int rc;
		1348	+ int i;
		1349	+ int req_length;
		1350	+ int byte_count;
		1351	+ uint8_t req[MAX_MESSAGE_LENGTH];
		1352	+
		1353	+ if (ctx == NULL) {
		1354	+ errno = EINVAL;
		1355	+ return -1;
		1356	+ }
		1357	+
		1358	+ if (nb > MODBUS_MAX_WRITE_REGISTERS) {
		1359	+ if (ctx->debug) {
		1360	+ fprintf(stderr,
		1361	+ "ERROR Trying to write to too many registers (%d > %d)\n",
		1362	+ nb, MODBUS_MAX_WRITE_REGISTERS);
		1363	+ }
		1364	+ errno = EMBMDATA;
		1365	+ return -1;
		1366	+ }
		1367	+
		1368	+ req_length = ctx->backend->build_request_basis(ctx,
		1369	+ MODBUS_FC_WRITE_MULTIPLE_REGISTERS,
		1370	+ addr, nb, req);
		1371	+ byte_count = nb * 2;
		1372	+ req[req_length++] = byte_count;
		1373	+
		1374	+ for (i = 0; i < nb; i++) {
		1375	+ req[req_length++] = src[i] >> 8;
		1376	+ req[req_length++] = src[i] & 0x00FF;
		1377	+ }
		1378	+
		1379	+ rc = send_msg(ctx, req, req_length);
		1380	+ if (rc > 0) {
		1381	+ uint8_t rsp[MAX_MESSAGE_LENGTH];
		1382	+
		1383	+ rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION);
		1384	+ if (rc == -1)
		1385	+ return -1;
		1386	+
		1387	+ rc = check_confirmation(ctx, req, rsp, rc);
		1388	+ }
		1389	+
		1390	+ return rc;
		1391	+}
		1392	+
		1393	+int modbus_mask_write_register(modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask)
		1394	+{
		1395	+ int rc;
		1396	+ int req_length;
		1397	+ /* The request length can not exceed _MIN_REQ_LENGTH - 2 and 4 bytes to
		1398	+ * store the masks. The ugly substraction is there to remove the 'nb' value
		1399	+ * (2 bytes) which is not used. */
		1400	+ uint8_t req[_MIN_REQ_LENGTH + 2];
		1401	+
		1402	+ req_length = ctx->backend->build_request_basis(ctx,
		1403	+ MODBUS_FC_MASK_WRITE_REGISTER,
		1404	+ addr, 0, req);
		1405	+
		1406	+ /* HACKISH, count is not used */
		1407	+ req_length -= 2;
		1408	+
		1409	+ req[req_length++] = and_mask >> 8;
		1410	+ req[req_length++] = and_mask & 0x00ff;
		1411	+ req[req_length++] = or_mask >> 8;
		1412	+ req[req_length++] = or_mask & 0x00ff;
		1413	+
		1414	+ rc = send_msg(ctx, req, req_length);
		1415	+ if (rc > 0) {
		1416	+ /* Used by write_bit and write_register */
		1417	+ uint8_t rsp[MAX_MESSAGE_LENGTH];
		1418	+
		1419	+ rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION);
		1420	+ if (rc == -1)
		1421	+ return -1;
		1422	+
		1423	+ rc = check_confirmation(ctx, req, rsp, rc);
		1424	+ }
		1425	+
		1426	+ return rc;
		1427	+}
		1428	+
		1429	+/* Write multiple registers from src array to remote device and read multiple
		1430	+ registers from remote device to dest array. */
		1431	+int modbus_write_and_read_registers(modbus_t *ctx,
		1432	+ int write_addr, int write_nb,
		1433	+ const uint16_t *src,
		1434	+ int read_addr, int read_nb,
		1435	+ uint16_t *dest)
		1436	+
		1437	+{
		1438	+ int rc;
		1439	+ int req_length;
		1440	+ int i;
		1441	+ int byte_count;
		1442	+ uint8_t req[MAX_MESSAGE_LENGTH];
		1443	+ uint8_t rsp[MAX_MESSAGE_LENGTH];
		1444	+
		1445	+ if (ctx == NULL) {
		1446	+ errno = EINVAL;
		1447	+ return -1;
		1448	+ }
		1449	+
		1450	+ if (write_nb > MODBUS_MAX_WR_WRITE_REGISTERS) {
		1451	+ if (ctx->debug) {
		1452	+ fprintf(stderr,
		1453	+ "ERROR Too many registers to write (%d > %d)\n",
		1454	+ write_nb, MODBUS_MAX_WR_WRITE_REGISTERS);
		1455	+ }
		1456	+ errno = EMBMDATA;
		1457	+ return -1;
		1458	+ }
		1459	+
		1460	+ if (read_nb > MODBUS_MAX_WR_READ_REGISTERS) {
		1461	+ if (ctx->debug) {
		1462	+ fprintf(stderr,
		1463	+ "ERROR Too many registers requested (%d > %d)\n",
		1464	+ read_nb, MODBUS_MAX_WR_READ_REGISTERS);
		1465	+ }
		1466	+ errno = EMBMDATA;
		1467	+ return -1;
		1468	+ }
		1469	+ req_length = ctx->backend->build_request_basis(ctx,
		1470	+ MODBUS_FC_WRITE_AND_READ_REGISTERS,
		1471	+ read_addr, read_nb, req);
		1472	+
		1473	+ req[req_length++] = write_addr >> 8;
		1474	+ req[req_length++] = write_addr & 0x00ff;
		1475	+ req[req_length++] = write_nb >> 8;
		1476	+ req[req_length++] = write_nb & 0x00ff;
		1477	+ byte_count = write_nb * 2;
		1478	+ req[req_length++] = byte_count;
		1479	+
		1480	+ for (i = 0; i < write_nb; i++) {
		1481	+ req[req_length++] = src[i] >> 8;
		1482	+ req[req_length++] = src[i] & 0x00FF;
		1483	+ }
		1484	+
		1485	+ rc = send_msg(ctx, req, req_length);
		1486	+ if (rc > 0) {
		1487	+ int offset;
		1488	+
		1489	+ rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION);
		1490	+ if (rc == -1)
		1491	+ return -1;
		1492	+
		1493	+ rc = check_confirmation(ctx, req, rsp, rc);
		1494	+ if (rc == -1)
		1495	+ return -1;
		1496	+
		1497	+ offset = ctx->backend->header_length;
		1498	+ for (i = 0; i < rc; i++) {
		1499	+ /* shift reg hi_byte to temp OR with lo_byte */
		1500	+ dest[i] = (rsp[offset + 2 + (i << 1)] << 8) \|
		1501	+ rsp[offset + 3 + (i << 1)];
		1502	+ }
		1503	+ }
		1504	+
		1505	+ return rc;
		1506	+}
		1507	+
		1508	+/* Send a request to get the slave ID of the device (only available in serial
		1509	+ communication). */
		1510	+int modbus_report_slave_id(modbus_t ctx, int max_dest, uint8_t dest)
		1511	+{
		1512	+ int rc;
		1513	+ int req_length;
		1514	+ uint8_t req[_MIN_REQ_LENGTH];
		1515	+
		1516	+ if (ctx == NULL \|\| max_dest <= 0) {
		1517	+ errno = EINVAL;
		1518	+ return -1;
		1519	+ }
		1520	+
		1521	+ req_length = ctx->backend->build_request_basis(ctx, MODBUS_FC_REPORT_SLAVE_ID,
		1522	+ 0, 0, req);
		1523	+
		1524	+ /* HACKISH, addr and count are not used */
		1525	+ req_length -= 4;
		1526	+
		1527	+ rc = send_msg(ctx, req, req_length);
		1528	+ if (rc > 0) {
		1529	+ int i;
		1530	+ int offset;
		1531	+ uint8_t rsp[MAX_MESSAGE_LENGTH];
		1532	+
		1533	+ rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION);
		1534	+ if (rc == -1)
		1535	+ return -1;
		1536	+
		1537	+ rc = check_confirmation(ctx, req, rsp, rc);
		1538	+ if (rc == -1)
		1539	+ return -1;
		1540	+
		1541	+ offset = ctx->backend->header_length + 2;
		1542	+
		1543	+ /* Byte count, slave id, run indicator status and
		1544	+ additional data. Truncate copy to max_dest. */
		1545	+ for (i=0; i < rc && i < max_dest; i++) {
		1546	+ dest[i] = rsp[offset + i];
		1547	+ }
		1548	+ }
		1549	+
		1550	+ return rc;
		1551	+}
		1552	+
		1553	+void _modbus_init_common(modbus_t *ctx)
		1554	+{
		1555	+ /* Slave and socket are initialized to -1 */
		1556	+ ctx->slave = -1;
		1557	+ ctx->s = -1;
		1558	+
		1559	+ ctx->debug = FALSE;
		1560	+ ctx->error_recovery = MODBUS_ERROR_RECOVERY_NONE;
		1561	+
		1562	+ ctx->response_timeout.tv_sec = 0;
		1563	+ ctx->response_timeout.tv_usec = _RESPONSE_TIMEOUT;
		1564	+
		1565	+ ctx->byte_timeout.tv_sec = 0;
		1566	+ ctx->byte_timeout.tv_usec = _BYTE_TIMEOUT;
		1567	+}
		1568	+
		1569	+/* Define the slave number */
		1570	+int modbus_set_slave(modbus_t *ctx, int slave)
		1571	+{
		1572	+ if (ctx == NULL) {
		1573	+ errno = EINVAL;
		1574	+ return -1;
		1575	+ }
		1576	+
		1577	+ return ctx->backend->set_slave(ctx, slave);
		1578	+}
		1579	+
		1580	+int modbus_set_error_recovery(modbus_t *ctx,
		1581	+ modbus_error_recovery_mode error_recovery)
		1582	+{
		1583	+ if (ctx == NULL) {
		1584	+ errno = EINVAL;
		1585	+ return -1;
		1586	+ }
		1587	+
		1588	+ /* The type of modbus_error_recovery_mode is unsigned enum */
		1589	+ ctx->error_recovery = (uint8_t) error_recovery;
		1590	+ return 0;
		1591	+}
		1592	+
		1593	+int modbus_set_socket(modbus_t *ctx, int s)
		1594	+{
		1595	+ if (ctx == NULL) {
		1596	+ errno = EINVAL;
		1597	+ return -1;
		1598	+ }
		1599	+
		1600	+ ctx->s = s;
		1601	+ return 0;
		1602	+}
		1603	+
		1604	+int modbus_get_socket(modbus_t *ctx)
		1605	+{
		1606	+ if (ctx == NULL) {
		1607	+ errno = EINVAL;
		1608	+ return -1;
		1609	+ }
		1610	+
		1611	+ return ctx->s;
		1612	+}
		1613	+
		1614	+/* Get the timeout interval used to wait for a response */
		1615	+int modbus_get_response_timeout(modbus_t ctx, uint32_t to_sec, uint32_t *to_usec)
		1616	+{
		1617	+ if (ctx == NULL) {
		1618	+ errno = EINVAL;
		1619	+ return -1;
		1620	+ }
		1621	+
		1622	+ *to_sec = ctx->response_timeout.tv_sec;
		1623	+ *to_usec = ctx->response_timeout.tv_usec;
		1624	+ return 0;
		1625	+}
		1626	+
		1627	+int modbus_set_response_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec)
		1628	+{
		1629	+ if (ctx == NULL \|\|
		1630	+ (to_sec == 0 && to_usec == 0) \|\| to_usec > 999999) {
		1631	+ errno = EINVAL;
		1632	+ return -1;
		1633	+ }
		1634	+
		1635	+ ctx->response_timeout.tv_sec = to_sec;
		1636	+ ctx->response_timeout.tv_usec = to_usec;
		1637	+ return 0;
		1638	+}
		1639	+
		1640	+/* Get the timeout interval between two consecutive bytes of a message */
		1641	+int modbus_get_byte_timeout(modbus_t ctx, uint32_t to_sec, uint32_t *to_usec)
		1642	+{
		1643	+ if (ctx == NULL) {
		1644	+ errno = EINVAL;
		1645	+ return -1;
		1646	+ }
		1647	+
		1648	+ *to_sec = ctx->byte_timeout.tv_sec;
		1649	+ *to_usec = ctx->byte_timeout.tv_usec;
		1650	+ return 0;
		1651	+}
		1652	+
		1653	+int modbus_set_byte_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec)
		1654	+{
		1655	+ /* Byte timeout can be disabled when both values are zero */
		1656	+ if (ctx == NULL \|\| to_usec > 999999) {
		1657	+ errno = EINVAL;
		1658	+ return -1;
		1659	+ }
		1660	+
		1661	+ ctx->byte_timeout.tv_sec = to_sec;
		1662	+ ctx->byte_timeout.tv_usec = to_usec;
		1663	+ return 0;
		1664	+}
		1665	+
		1666	+int modbus_get_header_length(modbus_t *ctx)
		1667	+{
		1668	+ if (ctx == NULL) {
		1669	+ errno = EINVAL;
		1670	+ return -1;
		1671	+ }
		1672	+
		1673	+ return ctx->backend->header_length;
		1674	+}
		1675	+
		1676	+int modbus_connect(modbus_t *ctx)
		1677	+{
		1678	+ if (ctx == NULL) {
		1679	+ errno = EINVAL;
		1680	+ return -1;
		1681	+ }
		1682	+
		1683	+ return ctx->backend->connect(ctx);
		1684	+}
		1685	+
		1686	+void modbus_close(modbus_t *ctx)
		1687	+{
		1688	+ if (ctx == NULL)
		1689	+ return;
		1690	+
		1691	+ ctx->backend->close(ctx);
		1692	+}
		1693	+
		1694	+void modbus_free(modbus_t *ctx)
		1695	+{
		1696	+ if (ctx == NULL)
		1697	+ return;
		1698	+
		1699	+ ctx->backend->free(ctx);
		1700	+}
		1701	+
		1702	+int modbus_set_debug(modbus_t *ctx, int flag)
		1703	+{
		1704	+ if (ctx == NULL) {
		1705	+ errno = EINVAL;
		1706	+ return -1;
		1707	+ }
		1708	+
		1709	+ ctx->debug = flag;
		1710	+ return 0;
		1711	+}
		1712	+
		1713	+/* Allocates 4 arrays to store bits, input bits, registers and inputs
		1714	+ registers. The pointers are stored in modbus_mapping structure.
		1715	+
		1716	+ The modbus_mapping_new_ranges() function shall return the new allocated
		1717	+ structure if successful. Otherwise it shall return NULL and set errno to
		1718	+ ENOMEM. */
		1719	+modbus_mapping_t* modbus_mapping_new_start_address(
		1720	+ unsigned int start_bits, unsigned int nb_bits,
		1721	+ unsigned int start_input_bits, unsigned int nb_input_bits,
		1722	+ unsigned int start_registers, unsigned int nb_registers,
		1723	+ unsigned int start_input_registers, unsigned int nb_input_registers)
		1724	+{
		1725	+ modbus_mapping_t *mb_mapping;
		1726	+
		1727	+ mb_mapping = (modbus_mapping_t *)malloc(sizeof(modbus_mapping_t));
		1728	+ if (mb_mapping == NULL) {
		1729	+ return NULL;
		1730	+ }
		1731	+
		1732	+ /* 0X */
		1733	+ mb_mapping->nb_bits = nb_bits;
		1734	+ mb_mapping->start_bits = start_bits;
		1735	+ if (nb_bits == 0) {
		1736	+ mb_mapping->tab_bits = NULL;
		1737	+ } else {
		1738	+ /* Negative number raises a POSIX error */
		1739	+ mb_mapping->tab_bits =
		1740	+ (uint8_t ) malloc(nb_bits sizeof(uint8_t));
		1741	+ if (mb_mapping->tab_bits == NULL) {
		1742	+ free(mb_mapping);
		1743	+ return NULL;
		1744	+ }
		1745	+ memset(mb_mapping->tab_bits, 0, nb_bits * sizeof(uint8_t));
		1746	+ }
		1747	+
		1748	+ /* 1X */
		1749	+ mb_mapping->nb_input_bits = nb_input_bits;
		1750	+ mb_mapping->start_input_bits = start_input_bits;
		1751	+ if (nb_input_bits == 0) {
		1752	+ mb_mapping->tab_input_bits = NULL;
		1753	+ } else {
		1754	+ mb_mapping->tab_input_bits =
		1755	+ (uint8_t ) malloc(nb_input_bits sizeof(uint8_t));
		1756	+ if (mb_mapping->tab_input_bits == NULL) {
		1757	+ free(mb_mapping->tab_bits);
		1758	+ free(mb_mapping);
		1759	+ return NULL;
		1760	+ }
		1761	+ memset(mb_mapping->tab_input_bits, 0, nb_input_bits * sizeof(uint8_t));
		1762	+ }
		1763	+
		1764	+ /* 4X */
		1765	+ mb_mapping->nb_registers = nb_registers;
		1766	+ mb_mapping->start_registers = start_registers;
		1767	+ if (nb_registers == 0) {
		1768	+ mb_mapping->tab_registers = NULL;
		1769	+ } else {
		1770	+ mb_mapping->tab_registers =
		1771	+ (uint16_t ) malloc(nb_registers sizeof(uint16_t));
		1772	+ if (mb_mapping->tab_registers == NULL) {
		1773	+ free(mb_mapping->tab_input_bits);
		1774	+ free(mb_mapping->tab_bits);
		1775	+ free(mb_mapping);
		1776	+ return NULL;
		1777	+ }
		1778	+ memset(mb_mapping->tab_registers, 0, nb_registers * sizeof(uint16_t));
		1779	+ }
		1780	+
		1781	+ /* 3X */
		1782	+ mb_mapping->nb_input_registers = nb_input_registers;
		1783	+ mb_mapping->start_input_registers = start_input_registers;
		1784	+ if (nb_input_registers == 0) {
		1785	+ mb_mapping->tab_input_registers = NULL;
		1786	+ } else {
		1787	+ mb_mapping->tab_input_registers =
		1788	+ (uint16_t ) malloc(nb_input_registers sizeof(uint16_t));
		1789	+ if (mb_mapping->tab_input_registers == NULL) {
		1790	+ free(mb_mapping->tab_registers);
		1791	+ free(mb_mapping->tab_input_bits);
		1792	+ free(mb_mapping->tab_bits);
		1793	+ free(mb_mapping);
		1794	+ return NULL;
		1795	+ }
		1796	+ memset(mb_mapping->tab_input_registers, 0,
		1797	+ nb_input_registers * sizeof(uint16_t));
		1798	+ }
		1799	+
		1800	+ return mb_mapping;
		1801	+}
		1802	+
		1803	+modbus_mapping_t* modbus_mapping_new(int nb_bits, int nb_input_bits,
		1804	+ int nb_registers, int nb_input_registers)
		1805	+{
		1806	+ return modbus_mapping_new_start_address(
		1807	+ 0, nb_bits, 0, nb_input_bits, 0, nb_registers, 0, nb_input_registers);
		1808	+}
		1809	+
		1810	+/* Frees the 4 arrays */
		1811	+void modbus_mapping_free(modbus_mapping_t *mb_mapping)
		1812	+{
		1813	+ if (mb_mapping == NULL) {
		1814	+ return;
		1815	+ }
		1816	+
		1817	+ free(mb_mapping->tab_input_registers);
		1818	+ free(mb_mapping->tab_registers);
		1819	+ free(mb_mapping->tab_input_bits);
		1820	+ free(mb_mapping->tab_bits);
		1821	+ free(mb_mapping);
		1822	+}
		1823	+
		1824	+#ifndef HAVE_STRLCPY
		1825	+/*
		1826	+ * Function strlcpy was originally developed by
		1827	+ * Todd C. Miller <Todd.Miller@courtesan.com> to simplify writing secure code.
		1828	+ * See ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/strlcpy.3
		1829	+ * for more information.
		1830	+ *
		1831	+ * Thank you Ulrich Drepper... not!
		1832	+ *
		1833	+ * Copy src to string dest of size dest_size. At most dest_size-1 characters
		1834	+ * will be copied. Always NUL terminates (unless dest_size == 0). Returns
		1835	+ * strlen(src); if retval >= dest_size, truncation occurred.
		1836	+ */
		1837	+size_t strlcpy(char dest, const char src, size_t dest_size)
		1838	+{
		1839	+ register char *d = dest;
		1840	+ register const char *s = src;
		1841	+ register size_t n = dest_size;
		1842	+
		1843	+ /* Copy as many bytes as will fit */
		1844	+ if (n != 0 && --n != 0) {
		1845	+ do {
		1846	+ if ((d++ = s++) == 0)
		1847	+ break;
		1848	+ } while (--n != 0);
		1849	+ }
		1850	+
		1851	+ /* Not enough room in dest, add NUL and traverse rest of src */
		1852	+ if (n == 0) {
		1853	+ if (dest_size != 0)
		1854	+ d = '\0'; / NUL-terminate dest */
		1855	+ while (*s++)
		1856	+ ;
		1857	+ }
		1858	+
		1859	+ return (s - src - 1); /* count does not include NUL */
		1860	+}
		1861	+#endif

3rdparty/libmodbus/modbus.h 0 → 100644

View file @500c015

		1	+/*
		2	+ * Copyright © 2001-2013 Stéphane Raimbault <stephane.raimbault@gmail.com>
		3	+ *
		4	+ * SPDX-License-Identifier: LGPL-2.1+
		5	+ */
		6	+
		7	+#ifndef MODBUS_H
		8	+#define MODBUS_H
		9	+
		10	+/* Add this for macros that defined unix flavor */
		11	+#if (defined(__unix__) \|\| defined(unix)) && !defined(USG)
		12	+#include <sys/param.h>
		13	+#endif
		14	+
		15	+#ifndef _MSC_VER
		16	+#include <stdint.h>
		17	+#else
		18	+#include "stdint.h"
		19	+#endif
		20	+
		21	+#include "modbus-version.h"
		22	+
		23	+#if defined(_MSC_VER)
		24	+# if defined(DLLBUILD)
		25	+/* define DLLBUILD when building the DLL */
		26	+# define MODBUS_API __declspec(dllexport)
		27	+# else
		28	+# define MODBUS_API __declspec(dllimport)
		29	+# endif
		30	+#else
		31	+# define MODBUS_API
		32	+#endif
		33	+
		34	+#ifdef __cplusplus
		35	+# define MODBUS_BEGIN_DECLS extern "C" {
		36	+# define MODBUS_END_DECLS }
		37	+#else
		38	+# define MODBUS_BEGIN_DECLS
		39	+# define MODBUS_END_DECLS
		40	+#endif
		41	+
		42	+MODBUS_BEGIN_DECLS
		43	+
		44	+#ifndef FALSE
		45	+#define FALSE 0
		46	+#endif
		47	+
		48	+#ifndef TRUE
		49	+#define TRUE 1
		50	+#endif
		51	+
		52	+#ifndef OFF
		53	+#define OFF 0
		54	+#endif
		55	+
		56	+#ifndef ON
		57	+#define ON 1
		58	+#endif
		59	+
		60	+/* Modbus function codes */
		61	+#define MODBUS_FC_READ_COILS 0x01
		62	+#define MODBUS_FC_READ_DISCRETE_INPUTS 0x02
		63	+#define MODBUS_FC_READ_HOLDING_REGISTERS 0x03
		64	+#define MODBUS_FC_READ_INPUT_REGISTERS 0x04
		65	+#define MODBUS_FC_WRITE_SINGLE_COIL 0x05
		66	+#define MODBUS_FC_WRITE_SINGLE_REGISTER 0x06
		67	+#define MODBUS_FC_READ_EXCEPTION_STATUS 0x07
		68	+#define MODBUS_FC_WRITE_MULTIPLE_COILS 0x0F
		69	+#define MODBUS_FC_WRITE_MULTIPLE_REGISTERS 0x10
		70	+#define MODBUS_FC_REPORT_SLAVE_ID 0x11
		71	+#define MODBUS_FC_MASK_WRITE_REGISTER 0x16
		72	+#define MODBUS_FC_WRITE_AND_READ_REGISTERS 0x17
		73	+
		74	+#define MODBUS_BROADCAST_ADDRESS 0
		75	+
		76	+/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 1 page 12)
		77	+ * Quantity of Coils to read (2 bytes): 1 to 2000 (0x7D0)
		78	+ * (chapter 6 section 11 page 29)
		79	+ * Quantity of Coils to write (2 bytes): 1 to 1968 (0x7B0)
		80	+ */
		81	+#define MODBUS_MAX_READ_BITS 2000
		82	+#define MODBUS_MAX_WRITE_BITS 1968
		83	+
		84	+/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 3 page 15)
		85	+ * Quantity of Registers to read (2 bytes): 1 to 125 (0x7D)
		86	+ * (chapter 6 section 12 page 31)
		87	+ * Quantity of Registers to write (2 bytes) 1 to 123 (0x7B)
		88	+ * (chapter 6 section 17 page 38)
		89	+ * Quantity of Registers to write in R/W registers (2 bytes) 1 to 121 (0x79)
		90	+ */
		91	+#define MODBUS_MAX_READ_REGISTERS 125
		92	+#define MODBUS_MAX_WRITE_REGISTERS 123
		93	+#define MODBUS_MAX_WR_WRITE_REGISTERS 121
		94	+#define MODBUS_MAX_WR_READ_REGISTERS 125
		95	+
		96	+/* The size of the MODBUS PDU is limited by the size constraint inherited from
		97	+ * the first MODBUS implementation on Serial Line network (max. RS485 ADU = 256
		98	+ * bytes). Therefore, MODBUS PDU for serial line communication = 256 - Server
		99	+ * address (1 byte) - CRC (2 bytes) = 253 bytes.
		100	+ */
		101	+#define MODBUS_MAX_PDU_LENGTH 253
		102	+
		103	+/* Consequently:
		104	+ * - RTU MODBUS ADU = 253 bytes + Server address (1 byte) + CRC (2 bytes) = 256
		105	+ * bytes.
		106	+ * - TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes.
		107	+ * so the maximum of both backend in 260 bytes. This size can used to allocate
		108	+ * an array of bytes to store responses and it will be compatible with the two
		109	+ * backends.
		110	+ */
		111	+#define MODBUS_MAX_ADU_LENGTH 260
		112	+
		113	+/* Random number to avoid errno conflicts */
		114	+#define MODBUS_ENOBASE 112345678
		115	+
		116	+/* Protocol exceptions */
		117	+enum {
		118	+ MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 0x01,
		119	+ MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS,
		120	+ MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE,
		121	+ MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE,
		122	+ MODBUS_EXCEPTION_ACKNOWLEDGE,
		123	+ MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY,
		124	+ MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE,
		125	+ MODBUS_EXCEPTION_MEMORY_PARITY,
		126	+ MODBUS_EXCEPTION_NOT_DEFINED,
		127	+ MODBUS_EXCEPTION_GATEWAY_PATH,
		128	+ MODBUS_EXCEPTION_GATEWAY_TARGET,
		129	+ MODBUS_EXCEPTION_MAX
		130	+};
		131	+
		132	+#define EMBXILFUN (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_FUNCTION)
		133	+#define EMBXILADD (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS)
		134	+#define EMBXILVAL (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE)
		135	+#define EMBXSFAIL (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE)
		136	+#define EMBXACK (MODBUS_ENOBASE + MODBUS_EXCEPTION_ACKNOWLEDGE)
		137	+#define EMBXSBUSY (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY)
		138	+#define EMBXNACK (MODBUS_ENOBASE + MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE)
		139	+#define EMBXMEMPAR (MODBUS_ENOBASE + MODBUS_EXCEPTION_MEMORY_PARITY)
		140	+#define EMBXGPATH (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_PATH)
		141	+#define EMBXGTAR (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_TARGET)
		142	+
		143	+/* Native libmodbus error codes */
		144	+#define EMBBADCRC (EMBXGTAR + 1)
		145	+#define EMBBADDATA (EMBXGTAR + 2)
		146	+#define EMBBADEXC (EMBXGTAR + 3)
		147	+#define EMBUNKEXC (EMBXGTAR + 4)
		148	+#define EMBMDATA (EMBXGTAR + 5)
		149	+#define EMBBADSLAVE (EMBXGTAR + 6)
		150	+
		151	+extern const unsigned int libmodbus_version_major;
		152	+extern const unsigned int libmodbus_version_minor;
		153	+extern const unsigned int libmodbus_version_micro;
		154	+
		155	+typedef struct _modbus modbus_t;
		156	+
		157	+typedef struct {
		158	+ int nb_bits;
		159	+ int start_bits;
		160	+ int nb_input_bits;
		161	+ int start_input_bits;
		162	+ int nb_input_registers;
		163	+ int start_input_registers;
		164	+ int nb_registers;
		165	+ int start_registers;
		166	+ uint8_t *tab_bits;
		167	+ uint8_t *tab_input_bits;
		168	+ uint16_t *tab_input_registers;
		169	+ uint16_t *tab_registers;
		170	+} modbus_mapping_t;
		171	+
		172	+typedef enum
		173	+{
		174	+ MODBUS_ERROR_RECOVERY_NONE = 0,
		175	+ MODBUS_ERROR_RECOVERY_LINK = (1<<1),
		176	+ MODBUS_ERROR_RECOVERY_PROTOCOL = (1<<2)
		177	+} modbus_error_recovery_mode;
		178	+
		179	+MODBUS_API int modbus_set_slave(modbus_t* ctx, int slave);
		180	+MODBUS_API int modbus_set_error_recovery(modbus_t *ctx, modbus_error_recovery_mode error_recovery);
		181	+MODBUS_API int modbus_set_socket(modbus_t *ctx, int s);
		182	+MODBUS_API int modbus_get_socket(modbus_t *ctx);
		183	+
		184	+MODBUS_API int modbus_get_response_timeout(modbus_t ctx, uint32_t to_sec, uint32_t *to_usec);
		185	+MODBUS_API int modbus_set_response_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec);
		186	+
		187	+MODBUS_API int modbus_get_byte_timeout(modbus_t ctx, uint32_t to_sec, uint32_t *to_usec);
		188	+MODBUS_API int modbus_set_byte_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec);
		189	+
		190	+MODBUS_API int modbus_get_header_length(modbus_t *ctx);
		191	+
		192	+MODBUS_API int modbus_connect(modbus_t *ctx);
		193	+MODBUS_API void modbus_close(modbus_t *ctx);
		194	+
		195	+MODBUS_API void modbus_free(modbus_t *ctx);
		196	+
		197	+MODBUS_API int modbus_flush(modbus_t *ctx);
		198	+MODBUS_API int modbus_set_debug(modbus_t *ctx, int flag);
		199	+
		200	+MODBUS_API const char *modbus_strerror(int errnum);
		201	+
		202	+MODBUS_API int modbus_read_bits(modbus_t ctx, int addr, int nb, uint8_t dest);
		203	+MODBUS_API int modbus_read_input_bits(modbus_t ctx, int addr, int nb, uint8_t dest);
		204	+MODBUS_API int modbus_read_registers(modbus_t ctx, int addr, int nb, uint16_t dest);
		205	+MODBUS_API int modbus_read_input_registers(modbus_t ctx, int addr, int nb, uint16_t dest);
		206	+MODBUS_API int modbus_write_bit(modbus_t *ctx, int coil_addr, int status);
		207	+MODBUS_API int modbus_write_register(modbus_t *ctx, int reg_addr, int value);
		208	+MODBUS_API int modbus_write_bits(modbus_t ctx, int addr, int nb, const uint8_t data);
		209	+MODBUS_API int modbus_write_registers(modbus_t ctx, int addr, int nb, const uint16_t data);
		210	+MODBUS_API int modbus_mask_write_register(modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask);
		211	+MODBUS_API int modbus_write_and_read_registers(modbus_t *ctx, int write_addr, int write_nb,
		212	+ const uint16_t *src, int read_addr, int read_nb,
		213	+ uint16_t *dest);
		214	+MODBUS_API int modbus_report_slave_id(modbus_t ctx, int max_dest, uint8_t dest);
		215	+
		216	+MODBUS_API modbus_mapping_t* modbus_mapping_new_start_address(
		217	+ unsigned int start_bits, unsigned int nb_bits,
		218	+ unsigned int start_input_bits, unsigned int nb_input_bits,
		219	+ unsigned int start_registers, unsigned int nb_registers,
		220	+ unsigned int start_input_registers, unsigned int nb_input_registers);
		221	+
		222	+MODBUS_API modbus_mapping_t* modbus_mapping_new(int nb_bits, int nb_input_bits,
		223	+ int nb_registers, int nb_input_registers);
		224	+MODBUS_API void modbus_mapping_free(modbus_mapping_t *mb_mapping);
		225	+
		226	+MODBUS_API int modbus_send_raw_request(modbus_t ctx, uint8_t raw_req, int raw_req_length);
		227	+
		228	+MODBUS_API int modbus_receive(modbus_t ctx, uint8_t req);
		229	+
		230	+MODBUS_API int modbus_receive_confirmation(modbus_t ctx, uint8_t rsp);
		231	+
		232	+MODBUS_API int modbus_reply(modbus_t ctx, const uint8_t req,
		233	+ int req_length, modbus_mapping_t *mb_mapping);
		234	+MODBUS_API int modbus_reply_exception(modbus_t ctx, const uint8_t req,
		235	+ unsigned int exception_code);
		236	+
		237	+/**
		238	+ * UTILS FUNCTIONS
		239	+ **/
		240	+
		241	+#define MODBUS_GET_HIGH_BYTE(data) (((data) >> 8) & 0xFF)
		242	+#define MODBUS_GET_LOW_BYTE(data) ((data) & 0xFF)
		243	+#define MODBUS_GET_INT64_FROM_INT16(tab_int16, index) \
		244	+ (((int64_t)tab_int16[(index) ] << 48) + \
		245	+ ((int64_t)tab_int16[(index) + 1] << 32) + \
		246	+ ((int64_t)tab_int16[(index) + 2] << 16) + \
		247	+ (int64_t)tab_int16[(index) + 3])
		248	+#define MODBUS_GET_INT32_FROM_INT16(tab_int16, index) ((tab_int16[(index)] << 16) + tab_int16[(index) + 1])
		249	+#define MODBUS_GET_INT16_FROM_INT8(tab_int8, index) ((tab_int8[(index)] << 8) + tab_int8[(index) + 1])
		250	+#define MODBUS_SET_INT16_TO_INT8(tab_int8, index, value) \
		251	+ do { \
		252	+ tab_int8[(index)] = (value) >> 8; \
		253	+ tab_int8[(index) + 1] = (value) & 0xFF; \
		254	+ } while (0)
		255	+#define MODBUS_SET_INT32_TO_INT16(tab_int16, index, value) \
		256	+ do { \
		257	+ tab_int16[(index) ] = (value) >> 16; \
		258	+ tab_int16[(index) + 1] = (value); \
		259	+ } while (0)
		260	+#define MODBUS_SET_INT64_TO_INT16(tab_int16, index, value) \
		261	+ do { \
		262	+ tab_int16[(index) ] = (value) >> 48; \
		263	+ tab_int16[(index) + 1] = (value) >> 32; \
		264	+ tab_int16[(index) + 2] = (value) >> 16; \
		265	+ tab_int16[(index) + 3] = (value); \
		266	+ } while (0)
		267	+
		268	+MODBUS_API void modbus_set_bits_from_byte(uint8_t *dest, int idx, const uint8_t value);
		269	+MODBUS_API void modbus_set_bits_from_bytes(uint8_t *dest, int idx, unsigned int nb_bits,
		270	+ const uint8_t *tab_byte);
		271	+MODBUS_API uint8_t modbus_get_byte_from_bits(const uint8_t *src, int idx, unsigned int nb_bits);
		272	+MODBUS_API float modbus_get_float(const uint16_t *src);
		273	+MODBUS_API float modbus_get_float_abcd(const uint16_t *src);
		274	+MODBUS_API float modbus_get_float_dcba(const uint16_t *src);
		275	+MODBUS_API float modbus_get_float_badc(const uint16_t *src);
		276	+MODBUS_API float modbus_get_float_cdab(const uint16_t *src);
		277	+
		278	+MODBUS_API void modbus_set_float(float f, uint16_t *dest);
		279	+MODBUS_API void modbus_set_float_abcd(float f, uint16_t *dest);
		280	+MODBUS_API void modbus_set_float_dcba(float f, uint16_t *dest);
		281	+MODBUS_API void modbus_set_float_badc(float f, uint16_t *dest);
		282	+MODBUS_API void modbus_set_float_cdab(float f, uint16_t *dest);
		283	+
		284	+#include "modbus-tcp.h"
		285	+#include "modbus-rtu.h"
		286	+
		287	+MODBUS_END_DECLS
		288	+
		289	+#endif /* MODBUS_H */

CMakeLists.txt 0 → 100644

View file @500c015

		1	+cmake_minimum_required(VERSION 3.2)
		2	+project(modbus)
		3	+
		4	+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
		5	+
		6	+aux_source_directory(3rdparty/libmodbus DIRSRCS)
		7	+include_directories(3rdparty/libmodbus include)
		8	+
		9	+set(SOURCE_FILES tests/main.cpp src/modbusadapter.cpp)
		10	+add_executable(main ${SOURCE_FILES} ${DIRSRCS})

scripts/setup_submodules 0 → 100755

View file @500c015

		1	+#!/bin/bash
		2	+
		3	+# ===============================================
		4	+# == Setting some environment variables
		5	+# ===============================================
		6	+GIT_URL_OPEN="http://gitlab.osdev.nl/open_source"
		7	+GIT_URL_CLOSED="git@gitlab.osdev.nl:closed_source"
		8	+
		9	+FUNC_RESULT="-1"
		10	+
		11	+# Name : print_usage_exit()
		12	+# Description : Print the way this script is intended to be used and exit.
		13	+# Parameters : None.
		14	+# Returns : err_code 1 to the Operating System
		15	+# --------------------------------------------------------------------------------------
		16	+function print_usage_exit()
		17	+{
		18	+ echo "Usage $0 -i\|--install\|-u\|--update"
		19	+ echo " -i or --install Install the submodules mentioned in the submodules.list"
		20	+ echo " -u or --update Update the submodules mentioned in the submodules.list"
		21	+ echo " "
		22	+ exit 1
		23	+}
		24	+
		25	+# Name : check_top_or_sub
		26	+# Description : Determine if we're running in a "single" lib-build or part of a
		27	+# "meta"-repository ( submodule ).
		28	+# Parameters : None
		29	+# Returns : Updates the value FUNC_RESULT.
		30	+# -1 - We're neither a git-repo or submodule.
		31	+# 0 - We're a submodule
		32	+# 1 - We're a top-repo ( Single library )
		33	+# --------------------------------------------------------------------------------------
		34	+function check_top_or_sub()
		35	+{
		36	+ # This function checks if we're the top-repository.
		37	+ # In that case we need the submodules.. If we're already a submodule,
		38	+ # we simply exit this script with a message
		39	+ if [ -e ./.git ]; then
		40	+ FUNC_RESULT="1"
		41	+ return
		42	+ elif [ -e ../.git ]; then
		43	+ if [ -e ../.submodules ]; then
		44	+ echo "Seems like we're already a submodule. Nothing to do here."
		45	+ FUNC_RESULT="0"
		46	+ return
		47	+ fi
		48	+ fi
		49	+ FUNC_RESULT="-1"
		50	+ return
		51	+}
		52	+
		53	+# Name : check_working_dir
		54	+# Description : If we're in the top of our repo, we can run this script further.
		55	+# Parameters : None.
		56	+# Returns : Updates the value FUNC_RESULT.
		57	+# -1 - Not used.
		58	+# 0 - We're not on the top-level
		59	+# 1 - We're at the top-level. Good to go.
		60	+# --------------------------------------------------------------------------------------
		61	+function check_working_dir()
		62	+{
		63	+ FUNC_RESULT="-1"
		64	+ # Check if we're in the top-level directory of our repository.
		65	+ if [ -f ./scripts/submodules.list ]; then
		66	+ # We're good to go
		67	+ FUNC_RESULT="1"
		68	+ return
		69	+ fi
		70	+ FUNC_RESULT="0"
		71	+ return
		72	+}
		73	+
		74	+# Name : read_submodules
		75	+# Description : Read the list of submodules needed for this project
		76	+# Parameters : None
		77	+# Returns : Updates the value FUNC_RESULT
		78	+# 0 - Module list was not found
		79	+# 1 - Module list was found and read.
		80	+# --------------------------------------------------------------------------------------
		81	+function read_submodules()
		82	+{
		83	+ FUNC_RESULT="-1"
		84	+ if [ -e ./scripts/submodules.list ]; then
		85	+ source ./scripts/submodules.list
		86	+ FUNC_RESULT="1"
		87	+ return
		88	+ fi
		89	+
		90	+ echo "Submodules list not found...."
		91	+ FUNC_RESULT="0"
		92	+ return
		93	+}
		94	+
		95	+# Name : add_submodules
		96	+# Description : Configure the repo to add the submodules.
		97	+# Parameters : None.
		98	+# Returns : None.
		99	+# --------------------------------------------------------------------------------------
		100	+function add_submodules()
		101	+{
		102	+ echo -e "Adding SubModule(s)."
		103	+ for SUB_MODULE in ${SUB_MODULES_OPEN}
		104	+ do
		105	+ git submodule add -f ${GIT_URL_OPEN}/${SUB_MODULE}.git submodules/${SUB_MODULE}
		106	+ git config submodule.${SUB_MODULE}.url ${GIT_URL_OPEN}/${SUB_MODULE}.git
		107	+ done
		108	+
		109	+ for SUB_MODULE in ${SUB_MODULES_CLOSED}
		110	+ do
		111	+ echo {GIT_URL_CLOSED}/${SUB_MODULE}.git
		112	+ git submodule add -f ${GIT_URL_CLOSED}/${SUB_MODULE}.git submodules/${SUB_MODULE}
		113	+ git config submodule.${SUB_MODULE}.url ${GIT_URL_CLOSED}/${SUB_MODULE}.git
		114	+ done
		115	+
		116	+}
		117	+
		118	+# Name : get_submodules
		119	+# Description : Actually get the submodules from gitlab and add them.
		120	+# Parameters : None
		121	+# Returns : None
		122	+# --------------------------------------------------------------------------------------
		123	+function get_submodules()
		124	+{
		125	+ git submodule update --init --recursive
		126	+}
		127	+
		128	+# Name : update_submodules
		129	+# Description : Update the submodules already added.
		130	+# Parameters : None
		131	+# Returns : None
		132	+# --------------------------------------------------------------------------------------
		133	+function update_submodules()
		134	+{
		135	+ git submodule update --recursive
		136	+}
		137	+
		138	+# =============================================================================
		139	+# == T H E M A I N E N T R Y O F T H I S S C R I P T ==
		140	+# =============================================================================
		141	+check_top_or_sub
		142	+if [ "${FUNC_RESULT}" == "0" ]; then
		143	+ echo "Seems like we're a submodule already or not part of a repository."
		144	+ exit 0
		145	+fi
		146	+
		147	+check_working_dir
		148	+if [ "${FUNC_RESULT}" == "0" ]; then
		149	+ echo "Go to the top of this repository and type : scripts/setup_submodules [-i\|--install]"
		150	+ exit 0
		151	+fi
		152	+
		153	+read_submodules
		154	+
		155	+case "$1" in
		156	+ -i\|--install)
		157	+ echo "Installing submodules for this repository ( ${PWD} )"
		158	+ add_submodules
		159	+ get_submodules
		160	+ ;;
		161	+ -u\|--update)
		162	+ echo "Update submodules : ${SUB_MODULES}"
		163	+ update_submodules
		164	+ ;;
		165	+ *)
		166	+ echo "No parameters found..."
		167	+ print_usage_exit
		168	+ ;;
		169	+esac
		170	+

scripts/submodules.list 0 → 100644

View file @500c015

		1	+SUB_MODULES_OPEN="cmake"
		2	+
		3	+SUB_MODULES_CLOSED=""

src/modbus.cpp deleted

View file @c5fb124

src/modbus.h deleted

View file @c5fb124

1	-#pragma once
2	-
3	-

src/modbus_defines.h deleted

View file @c5fb124

1	-/****************************************************************************
2	- * Copyright (c) 2022 Priva B.V.
3	- ****************************************************************************/
4	-
5	-#pragma once
6	-
7	-/* Modbus Function codes as defined in the protocol standard */
8	-enum class E_MB_FUNCTION_CODES
9	-{
10	- E_MODBUS_FC_READ_COILS 0x01,
11	- E_MODBUS_FC_READ_DISCRETE_INPUTS 0x02,
12	- E_MODBUS_FC_READ_HOLDING_REGISTERS 0x03,
13	- E_MODBUS_FC_READ_INPUT_REGISTERS 0x04,
14	- E_MODBUS_FC_WRITE_SINGLE_COIL 0x05,
15	- E_MODBUS_FC_WRITE_SINGLE_REGISTER 0x06,
16	- E_MODBUS_FC_READ_EXCEPTION_STATUS 0x07,
17	- E_MODBUS_FC_WRITE_MULTIPLE_COILS 0x0F,
18	- E_MODBUS_FC_WRITE_MULTIPLE_REGISTERS 0x10,
19	- E_MODBUS_FC_REPORT_SLAVE_ID 0x11,
20	- E_MODBUS_FC_MASK_WRITE_REGISTERS 0x16,
21	- E_MODBUS_FC_WRITE_AND_READ_REGISTERS 0x17
22	-};
23	-
24	-#define MODBUS_BROADCAST_ADDRESS 0
25	-
26	-/* Modbus Application Protocol V1.1b ( Chapter 6 section 1 page 12 )
27	- * Quantity of Coils to read ( 2 bytes ): 1 to 2000 ( 0x7D0 )
28	- * ( chapter 6 section 11 page 29 )
29	- * Quantity of Coils to write ( 2 bytes ): 1 to 1968 ( 0x7B0 )
30	- */
31	-#define MODBUS_MAX_READ_BITS 2000
32	-#define MODBUS_MAX_WRITE_BITS 1968
33	-
34	-/* Modbus Application Protocol V1.1b ( Chapter 6 section 3 page 12 )
35	- * Quantity of Registers to read ( 2 bytes ): 1 to 125 ( 0x7D )
36	- * ( chapter 6 section 12 page 31 )
37	- * Quantity of Registers to write ( 2 bytes ): 1 to 123 ( 0x7B )
38	- * ( chapter 6 section 17 page 38 )
39	- * Quantity of Registers to write in R/W registers ( 2 bytes ) 1 to 123 ( 0x79 )
40	- */
41	-#define MODBUS_MAX_READ_REGISTERS 125
42	-#define MODBUS_MAX_WRITE_REGISTERS 123
43	-#define MODBUS_MAX_WR_WRITE_REGISTERS 121
44	-#define MODBUS_MAX_WR_READ_REGISTERS 125
45	-
46	-/* The MODBUS PDU is 256 bytes maximum. Therefore MODBUS PDU for serial line
47	- * communication = 256 - Server address ( 1 byte ) - CRC ( 2 bytes ) = 253 bytes
48	- */
49	-#define MODBUS_MAX_PDU_LENGTH 253
50	-
51	-/* Consequently :
52	- * - RTU MODBUS_ADU = 253 bytes + Server address ( 1 byte ) + CRC ( 2 bytes ) = 256
53	- * bytes
54	- * - TCP MODBUS ADU = 253 bytes + MBAP ( 7 bytes ) = 260 bytes
55	- * so the maximum of both backends is 260 bytes. This size can be used to allocate
56	- * an array of bytes to store responses and it will be compatible with the two
57	- * backends.
58	- */
59	-#define MODBUS_MAX_ADU_LENGTH 260
60	-
61	-/* Random number to avoid errno conflicts */
62	-#define MODBUS_ENOBASE 31428571
63	-
64	-/* Protocol exceptions */
65	-enum class E_MODBUS_EXCEPTIONS
66	-{
67	- MODBUS_EXCEPTION_ILLEGAL_FUNCTION 0x01,
68	- MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS,
69	- MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE,
70	- MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE,
71	- MODBUS_EXCEPTION_ACKNOWLEDGE,
72	- MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY,
73	- MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE,
74	- MODBUS_EXCEPTION_MEMORY_PARITY,
75	- MODBUS_EXCEPTION_NOT_DEFINED,
76	- MODBUS_EXCEPTION_GATEWAY_PATH,
77	- MODBUS_EXCEPTION_GATEWAY_TARGET,
78	- MODBUS_EXCEPTION_MAX
79	-};
80	-
81	-/* MODBUS Error codes */
82	-#define EMBXILFUN ( MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_FUNCTION )
83	-#define EMBXILADD ( MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS )
84	-#define EMBXILVAL ( MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE )
85	-#define EMBXSFAIL ( MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE )
86	-#define EMBXACK ( MODBUS_ENOBASE + MODBUS_EXCEPTION_ACKNOWLEDGE )
87	-#define EMBXSBUSY ( MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY )
88	-#define EMBXNACK ( MODBUS_ENOBASE + MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE )
89	-#define EMBXMEMPAR ( MODBUS_ENOBASE + MODBUS_EXCEPTION_MEMORY_PARITY )
90	-#define EMBXGPATH ( MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_PATH )
91	-#define EMBXGTAR ( MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_TARGET )
92	-
93	-/* Native modbus error codes */
94	-#define EMBBADCRC ( EMBXGTAR + 1 )
95	-#define EMBBADDATA ( EMBXGTAR + 2 )
96	-#define EMBBADEXC ( EMBXGTAR + 3 )
97	-#define EMBUNKEXC ( EMBXGTAR + 4 )
98	-#define EMBMDATA ( EMBXGTAR + 5 )
99	-#define EMBBADSLAVE ( EMBXGTAR + 6 )
100	-
101	-/* Recovery Modes */
102	-enum class MODBUS_ERROR_RECOVERY_MODE
103	-{
104	- MODBUS_ERROR_RECOVERY_NONE = 0,
105	- MODBUS_ERROR_RECOVERY_LINK = ( 1 << 1 ),
106	- MODBUS_ERROR_RECOVERY_PROTOCOL = ( 1 << 2 )
107	-};

tests/main.cpp 0 → 100644

View file @500c015

		1	+#include <iostream>
		2	+
		3	+int main( int argc, char* argv[] )
		4	+{
		5	+
		6	+}