From a9973a2860d1f49b0629d1cc34f393c296e6eb39 Mon Sep 17 00:00:00 2001 From: zcy <290198252@qq.com> Date: Thu, 28 Sep 2023 01:30:27 +0800 Subject: [PATCH] no message --- global.cpp | 4 + global.h | 173 +++ libmodbus.zip | Bin 0 -> 37772 bytes libmodbus/config.h | 167 +++ libmodbus/modbus-data.c | 303 +++++ libmodbus/modbus-private.h | 115 ++ libmodbus/modbus-rtu-private.h | 76 ++ libmodbus/modbus-rtu.c | 1305 ++++++++++++++++++++++ libmodbus/modbus-rtu.h | 42 + libmodbus/modbus-tcp-private.h | 44 + libmodbus/modbus-tcp.c | 929 ++++++++++++++++ libmodbus/modbus-tcp.h | 52 + libmodbus/modbus-version.h | 53 + libmodbus/modbus.c | 1910 ++++++++++++++++++++++++++++++++ libmodbus/modbus.h | 303 +++++ main.cpp | 43 + mainwindow.cpp | 85 ++ mainwindow.h | 70 ++ mainwindow.ui | 123 ++ mdbguard.cpp | 6 + mdbguard.h | 73 ++ modbus.lib | Bin 0 -> 285130 bytes sub.ui | 111 ++ subform.cpp | 189 ++++ subform.h | 72 ++ untitled.pro | 49 + untitled.pro.user | 259 +++++ untitled.pro.user.22 | 264 +++++ untitled.pro.user.4.8-pre1 | 318 ++++++ untitled.pro.user.8d885e7 | 264 +++++ 30 files changed, 7402 insertions(+) create mode 100644 global.cpp create mode 100644 global.h create mode 100644 libmodbus.zip create mode 100644 libmodbus/config.h create mode 100644 libmodbus/modbus-data.c create mode 100644 libmodbus/modbus-private.h create mode 100644 libmodbus/modbus-rtu-private.h create mode 100644 libmodbus/modbus-rtu.c create mode 100644 libmodbus/modbus-rtu.h create mode 100644 libmodbus/modbus-tcp-private.h create mode 100644 libmodbus/modbus-tcp.c create mode 100644 libmodbus/modbus-tcp.h create mode 100644 libmodbus/modbus-version.h create mode 100644 libmodbus/modbus.c create mode 100644 libmodbus/modbus.h create mode 100644 main.cpp create mode 100644 mainwindow.cpp create mode 100644 mainwindow.h create mode 100644 mainwindow.ui create mode 100644 mdbguard.cpp create mode 100644 mdbguard.h create mode 100644 modbus.lib create mode 100644 sub.ui create mode 100644 subform.cpp create mode 100644 subform.h create mode 100644 untitled.pro create mode 100644 untitled.pro.user create mode 100644 untitled.pro.user.22 create mode 100644 untitled.pro.user.4.8-pre1 create mode 100644 untitled.pro.user.8d885e7 diff --git a/global.cpp b/global.cpp new file mode 100644 index 0000000..525e2f4 --- /dev/null +++ b/global.cpp @@ -0,0 +1,4 @@ +#include "global.h" + + +ASyncReadData *gAsyncData = nullptr; diff --git a/global.h b/global.h new file mode 100644 index 0000000..01ef2cf --- /dev/null +++ b/global.h @@ -0,0 +1,173 @@ +#ifndef GLOBAL_H +#define GLOBAL_H + +#include "Qss.h" +#include +#include +#include + +extern "C"{ + #include "libmodbus/modbus.h" +} + +typedef struct { + float val1; + float val2; + float val3; + float val4; + float val5; + float val6; +}CapData; + + +typedef struct T_Config{ + QString com; + int addr; + int rate; +}Config; + + +class ASyncReadData :public QSSASyncProcess{ +public: + ASyncReadData(QWidget *parent) + :QSSASyncProcess(parent){ + + } + ~ASyncReadData(){ + if(mMod) + modbus_close(mMod); + } + void Stop(){ + mRuning = false; + } + void AddMonitor(QString addr){ + + } + void AddConfig(Config c){ + this->mConf.append(c); + } + void Run(void *v) override{ + Config *pcom = (Config*)v; + qDebug()<<"start"<com; + + // 读取1 + float x = 0; + while(mRuning){ + + + for(auto itr = mConf.begin();itr != mConf.end(); + itr++){ + uint16_t dat[10] = {0}; + uint16_t dat2[10] = {0}; + uint16_t dat3[10] {0}; + uint16_t dat4[4] = {0}; + qDebug()<com<addr; + + mMod = modbus_new_rtu(itr->com.toStdString().c_str(), + 57600, 'N', 8, 1); //相同的端口只能同时打开一个 + + modbus_set_debug(mMod,true); + modbus_set_slave(mMod,itr->addr); //设置modbus从机地址 + modbus_connect(mMod); + modbus_set_response_timeout(mMod,1000,1000); + QThread::msleep(300); + + QThread::msleep(1000); + int ret = modbus_read_registers(mMod,1,1,dat); + + mMux.lock(); + + qDebug()<addr)){ + mListData[itr->addr]->push_front(new CapData{ + float(float(dat2[0])), + float(float(dat3[0])), + float(float(dat3[1])), + float(dat[0]), + float(dat[1]), + float(dat4[0]/10), + }); + }else{ + mListData[itr->addr] = new QList; + mListData[itr->addr]->push_front(new CapData{ + float(float(dat2[0])), + float(float(dat3[0])), + float(float(dat3[1])), + float(dat[0]), + float(dat[1]), + float(dat4[0]/10), + }); + } + + x += 3.1415*2 /256; + + mMux.unlock(); + modbus_close(mMod); + } + +// modbus_set_slave(mMod,49); //设置modbus从机地址 +// modbus_connect(mMod); +// modbus_set_response_timeout(mMod,1,1); +// QThread::msleep(300); + +// modbus_write_register(mMod,1500,0x2011); // 解锁生产权限 + +// QThread::msleep(100); +// int ret = modbus_read_registers(mMod,300,2,dat); +// QThread::msleep(100); +// ret = modbus_read_registers(mMod,0x8008,1,dat2); +// QThread::msleep(100); +// ret = modbus_read_registers(mMod,0x8001,3,dat3); +// QThread::msleep(100); +// ret = modbus_read_registers(mMod,107,3,dat4); +// mMux.lock(); + +// qDebug()<rate); + } + // 读取2 + } + + int TakeLast(int addr,CapData **p){ + if(this->mListData.contains(addr)){ + mMux.lock(); + if(mListData[addr]->size() > 0){ + *p = (CapData *)mListData[addr]->takeLast(); + mMux.unlock(); + + return 0; + }else{ + mMux.unlock(); + return -1; + } + }else{ + return -1; + } + } + QMap*> mListData; + QMutex mMux; + modbus_t* mMod; + bool mRuning; + QList mConf; +}; + +extern ASyncReadData *gAsyncData; + + + +#endif // GLOBAL_H diff --git a/libmodbus.zip b/libmodbus.zip new file mode 100644 index 0000000000000000000000000000000000000000..d46797eaff1e9d8fa89505af44e3eca821afd4cf GIT binary patch literal 37772 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 BzefN7 literal 0 HcmV?d00001 diff --git a/libmodbus/config.h b/libmodbus/config.h new file mode 100644 index 0000000..18726de --- /dev/null +++ b/libmodbus/config.h @@ -0,0 +1,167 @@ +/* config.h. Generated from config.h.in by configure. */ +/* config.h.in. Generated from configure.ac by autoheader. */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_ARPA_INET_H */ + +/* Define to 1 if you have the declaration of `TIOCSRS485', and to 0 if you + don't. */ +/* #undef HAVE_DECL_TIOCSRS485 */ + +/* Define to 1 if you have the declaration of `__CYGWIN__', and to 0 if you + don't. */ +/* #undef HAVE_DECL___CYGWIN__ */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_DLFCN_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_ERRNO_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_FCNTL_H 1 + +/* Define to 1 if you have the `fork' function. */ +/* #undef HAVE_FORK */ + +/* Define to 1 if you have the `getaddrinfo' function. */ +/* #undef HAVE_GETADDRINFO */ + +/* Define to 1 if you have the `gettimeofday' function. */ +/* #undef HAVE_GETTIMEOFDAY */ + +/* Define to 1 if you have the `inet_ntoa' function. */ +/* #undef HAVE_INET_NTOA */ + +/* Define to 1 if you have the header file. */ +#define HAVE_INTTYPES_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_LIMITS_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_LINUX_SERIAL_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_MEMORY_H 1 + +/* Define to 1 if you have the `memset' function. */ +#define HAVE_MEMSET 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_NETDB_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_NETINET_IN_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_NETINET_TCP_H */ + +/* Define to 1 if you have the `select' function. */ +/* #undef HAVE_SELECT */ + +/* Define to 1 if you have the `socket' function. */ +/* #undef HAVE_SOCKET */ + +/* Define to 1 if you have the header file. */ +#define HAVE_STDINT_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STDLIB_H 1 + +/* Define to 1 if you have the `strerror' function. */ +#define HAVE_STRERROR 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_STRINGS_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_STRING_H 1 + +/* Define to 1 if you have the `strlcpy' function. */ +/* #undef HAVE_STRLCPY */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_IOCTL_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_SOCKET_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_TIME_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_TERMIOS_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_TIME_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_UNISTD_H */ + +/* Define to 1 if you have the `vfork' function. */ +/* #undef HAVE_VFORK */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_VFORK_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_WINSOCK2_H 1 + +/* Define to 1 if `fork' works. */ +/* #undef HAVE_WORKING_FORK */ + +/* Define to 1 if `vfork' works. */ +/* #undef HAVE_WORKING_VFORK */ + +/* Define to the sub-directory in which libtool stores uninstalled libraries. + */ +/* #undef LT_OBJDIR */ + +/* Name of package */ +#define PACKAGE "libmodbus" + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "https://github.com/stephane/libmodbus/issues" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME "libmodbus" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING "libmodbus 3.1.7" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME "libmodbus" + +/* Define to the home page for this package. */ +#define PACKAGE_URL "" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION "3.1.7" + +/* Define to 1 if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Define to 1 if you can safely include both and . */ +/* #undef TIME_WITH_SYS_TIME */ + +/* Version number of package */ +#define VERSION "3.1.7" + +/* Define to empty if `const' does not conform to ANSI C. */ +/* #undef const */ + +/* Define to `int' if does not define. */ +/* #undef pid_t */ + +/* Define to `unsigned int' if does not define. */ +/* #undef size_t */ + +/* Define as `fork' if `vfork' does not work. */ +#define vfork fork diff --git a/libmodbus/modbus-data.c b/libmodbus/modbus-data.c new file mode 100644 index 0000000..8994080 --- /dev/null +++ b/libmodbus/modbus-data.c @@ -0,0 +1,303 @@ +/* + * Copyright © 2010-2014 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#include + +#ifndef _MSC_VER +# include +#else +# include "stdint.h" +#endif + +#include +#include + +#if defined(_WIN32) +# include +#else +# include +#endif + +#include "config.h" + +#include "modbus.h" + +#if defined(HAVE_BYTESWAP_H) +# include +#endif + +#if defined(__APPLE__) +# include +# define bswap_16 OSSwapInt16 +# define bswap_32 OSSwapInt32 +# define bswap_64 OSSwapInt64 +#endif + +#if defined(__GNUC__) +# define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__ * 10) +# if GCC_VERSION >= 430 +// Since GCC >= 4.30, GCC provides __builtin_bswapXX() alternatives so we switch to them +# undef bswap_32 +# define bswap_32 __builtin_bswap32 +# endif +# if GCC_VERSION >= 480 +# undef bswap_16 +# define bswap_16 __builtin_bswap16 +# endif +#endif + +#if defined(_MSC_VER) && (_MSC_VER >= 1400) +# define bswap_32 _byteswap_ulong +# define bswap_16 _byteswap_ushort +#endif + +#if !defined(bswap_16) +# warning "Fallback on C functions for bswap_16" +static inline uint16_t bswap_16(uint16_t x) +{ + return (x >> 8) | (x << 8); +} +#endif + +#if !defined(bswap_32) +# warning "Fallback on C functions for bswap_32" +static inline uint32_t bswap_32(uint32_t x) +{ + return (bswap_16(x & 0xffff) << 16) | (bswap_16(x >> 16)); +} +#endif + +/* Sets many bits from a single byte value (all 8 bits of the byte value are + set) */ +void modbus_set_bits_from_byte(uint8_t *dest, int idx, const uint8_t value) +{ + int i; + + for (i=0; i < 8; i++) { + dest[idx+i] = (value & (1 << i)) ? 1 : 0; + } +} + +/* Sets many bits from a table of bytes (only the bits between idx and + idx + nb_bits are set) */ +void modbus_set_bits_from_bytes(uint8_t *dest, int idx, unsigned int nb_bits, + const uint8_t *tab_byte) +{ + unsigned int i; + int shift = 0; + + for (i = idx; i < idx + nb_bits; i++) { + dest[i] = tab_byte[(i - idx) / 8] & (1 << shift) ? 1 : 0; + /* gcc doesn't like: shift = (++shift) % 8; */ + shift++; + shift %= 8; + } +} + +/* Gets the byte value from many bits. + To obtain a full byte, set nb_bits to 8. */ +uint8_t modbus_get_byte_from_bits(const uint8_t *src, int idx, + unsigned int nb_bits) +{ + unsigned int i; + uint8_t value = 0; + + if (nb_bits > 8) { + /* Assert is ignored if NDEBUG is set */ + assert(nb_bits < 8); + nb_bits = 8; + } + + for (i=0; i < nb_bits; i++) { + value |= (src[idx+i] << i); + } + + return value; +} + +/* Get a float from 4 bytes (Modbus) without any conversion (ABCD) */ +float modbus_get_float_abcd(const uint16_t *src) +{ + float f; + uint32_t i; + uint8_t a, b, c, d; + + a = (src[0] >> 8) & 0xFF; + b = (src[0] >> 0) & 0xFF; + c = (src[1] >> 8) & 0xFF; + d = (src[1] >> 0) & 0xFF; + + i = (a << 24) | + (b << 16) | + (c << 8) | + (d << 0); + memcpy(&f, &i, 4); + + return f; +} + +/* Get a float from 4 bytes (Modbus) in inversed format (DCBA) */ +float modbus_get_float_dcba(const uint16_t *src) +{ + float f; + uint32_t i; + uint8_t a, b, c, d; + + a = (src[0] >> 8) & 0xFF; + b = (src[0] >> 0) & 0xFF; + c = (src[1] >> 8) & 0xFF; + d = (src[1] >> 0) & 0xFF; + + i = (d << 24) | + (c << 16) | + (b << 8) | + (a << 0); + memcpy(&f, &i, 4); + + return f; +} + +/* Get a float from 4 bytes (Modbus) with swapped bytes (BADC) */ +float modbus_get_float_badc(const uint16_t *src) +{ + float f; + uint32_t i; + uint8_t a, b, c, d; + + a = (src[0] >> 8) & 0xFF; + b = (src[0] >> 0) & 0xFF; + c = (src[1] >> 8) & 0xFF; + d = (src[1] >> 0) & 0xFF; + + i = (b << 24) | + (a << 16) | + (d << 8) | + (c << 0); + memcpy(&f, &i, 4); + + return f; +} + +/* Get a float from 4 bytes (Modbus) with swapped words (CDAB) */ +float modbus_get_float_cdab(const uint16_t *src) +{ + float f; + uint32_t i; + uint8_t a, b, c, d; + + a = (src[0] >> 8) & 0xFF; + b = (src[0] >> 0) & 0xFF; + c = (src[1] >> 8) & 0xFF; + d = (src[1] >> 0) & 0xFF; + + i = (c << 24) | + (d << 16) | + (a << 8) | + (b << 0); + memcpy(&f, &i, 4); + + return f; +} + +/* DEPRECATED - Get a float from 4 bytes in sort of Modbus format */ +float modbus_get_float(const uint16_t *src) +{ + float f; + uint32_t i; + + i = (((uint32_t)src[1]) << 16) + src[0]; + memcpy(&f, &i, sizeof(float)); + + return f; + +} + +/* Set a float to 4 bytes for Modbus w/o any conversion (ABCD) */ +void modbus_set_float_abcd(float f, uint16_t *dest) +{ + uint32_t i; + uint8_t *out = (uint8_t*) dest; + uint8_t a, b, c, d; + + memcpy(&i, &f, sizeof(uint32_t)); + a = (i >> 24) & 0xFF; + b = (i >> 16) & 0xFF; + c = (i >> 8) & 0xFF; + d = (i >> 0) & 0xFF; + + out[0] = a; + out[1] = b; + out[2] = c; + out[3] = d; +} + +/* Set a float to 4 bytes for Modbus with byte and word swap conversion (DCBA) */ +void modbus_set_float_dcba(float f, uint16_t *dest) +{ + uint32_t i; + uint8_t *out = (uint8_t*) dest; + uint8_t a, b, c, d; + + memcpy(&i, &f, sizeof(uint32_t)); + a = (i >> 24) & 0xFF; + b = (i >> 16) & 0xFF; + c = (i >> 8) & 0xFF; + d = (i >> 0) & 0xFF; + + out[0] = d; + out[1] = c; + out[2] = b; + out[3] = a; + +} + +/* Set a float to 4 bytes for Modbus with byte swap conversion (BADC) */ +void modbus_set_float_badc(float f, uint16_t *dest) +{ + uint32_t i; + uint8_t *out = (uint8_t*) dest; + uint8_t a, b, c, d; + + memcpy(&i, &f, sizeof(uint32_t)); + a = (i >> 24) & 0xFF; + b = (i >> 16) & 0xFF; + c = (i >> 8) & 0xFF; + d = (i >> 0) & 0xFF; + + out[0] = b; + out[1] = a; + out[2] = d; + out[3] = c; +} + +/* Set a float to 4 bytes for Modbus with word swap conversion (CDAB) */ +void modbus_set_float_cdab(float f, uint16_t *dest) +{ + uint32_t i; + uint8_t *out = (uint8_t*) dest; + uint8_t a, b, c, d; + + memcpy(&i, &f, sizeof(uint32_t)); + a = (i >> 24) & 0xFF; + b = (i >> 16) & 0xFF; + c = (i >> 8) & 0xFF; + d = (i >> 0) & 0xFF; + + out[0] = c; + out[1] = d; + out[2] = a; + out[3] = b; +} + +/* DEPRECATED - Set a float to 4 bytes in a sort of Modbus format! */ +void modbus_set_float(float f, uint16_t *dest) +{ + uint32_t i; + + memcpy(&i, &f, sizeof(uint32_t)); + dest[0] = (uint16_t)i; + dest[1] = (uint16_t)(i >> 16); +} diff --git a/libmodbus/modbus-private.h b/libmodbus/modbus-private.h new file mode 100644 index 0000000..87d31ba --- /dev/null +++ b/libmodbus/modbus-private.h @@ -0,0 +1,115 @@ +/* + * Copyright © 2010-2012 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#ifndef MODBUS_PRIVATE_H +#define MODBUS_PRIVATE_H + +#ifndef _MSC_VER +# include +# include +#else +# include "stdint.h" +# include +typedef int ssize_t; +#endif +#include +#include "config.h" + +#include "modbus.h" + +MODBUS_BEGIN_DECLS + +/* It's not really the minimal length (the real one is report slave ID + * in RTU (4 bytes)) but it's a convenient size to use in RTU or TCP + * communications to read many values or write a single one. + * Maximum between : + * - HEADER_LENGTH_TCP (7) + function (1) + address (2) + number (2) + * - HEADER_LENGTH_RTU (1) + function (1) + address (2) + number (2) + CRC (2) + */ + +#define _REPORT_SLAVE_ID 180 + +#define _MODBUS_EXCEPTION_RSP_LENGTH 5 + +/* Timeouts in microsecond (0.5 s) */ +#define _RESPONSE_TIMEOUT 500000 +#define _BYTE_TIMEOUT 500000 + +typedef enum { + _MODBUS_BACKEND_TYPE_RTU=0, + _MODBUS_BACKEND_TYPE_TCP +} modbus_backend_type_t; + +/* + * ---------- Request Indication ---------- + * | Client | ---------------------->| Server | + * ---------- Confirmation Response ---------- + */ +typedef enum { + /* Request message on the server side */ + MSG_INDICATION, + /* Request message on the client side */ + MSG_CONFIRMATION +} msg_type_t; + +/* This structure reduces the number of params in functions and so + * optimizes the speed of execution (~ 37%). */ +typedef struct _sft { + int slave; + int function; + int t_id; +} sft_t; + +typedef struct _modbus_backend { + unsigned int backend_type; + unsigned int header_length; + unsigned int checksum_length; + unsigned int max_adu_length; + int (*set_slave) (modbus_t *ctx, int slave); + int (*build_request_basis) (modbus_t *ctx, int function, int addr, + int nb, uint8_t *req); + int (*build_response_basis) (sft_t *sft, uint8_t *rsp); + int (*prepare_response_tid) (const uint8_t *req, int *req_length); + int (*send_msg_pre) (uint8_t *req, int req_length); + ssize_t (*send) (modbus_t *ctx, const uint8_t *req, int req_length); + int (*receive) (modbus_t *ctx, uint8_t *req); + ssize_t (*recv) (modbus_t *ctx, uint8_t *rsp, int rsp_length); + int (*check_integrity) (modbus_t *ctx, uint8_t *msg, + const int msg_length); + int (*pre_check_confirmation) (modbus_t *ctx, const uint8_t *req, + const uint8_t *rsp, int rsp_length); + int (*connect) (modbus_t *ctx); + void (*close) (modbus_t *ctx); + int (*flush) (modbus_t *ctx); + int (*select) (modbus_t *ctx, fd_set *rset, struct timeval *tv, int msg_length); + void (*free) (modbus_t *ctx); +} modbus_backend_t; + +struct _modbus { + /* Slave address */ + int slave; + /* Socket or file descriptor */ + int s; + int debug; + int error_recovery; + struct timeval response_timeout; + struct timeval byte_timeout; + struct timeval indication_timeout; + const modbus_backend_t *backend; + void *backend_data; +}; + +void _modbus_init_common(modbus_t *ctx); +void _error_print(modbus_t *ctx, const char *context); +int _modbus_receive_msg(modbus_t *ctx, uint8_t *msg, msg_type_t msg_type); + +#ifndef HAVE_STRLCPY +size_t strlcpy(char *dest, const char *src, size_t dest_size); +#endif + +MODBUS_END_DECLS + +#endif /* MODBUS_PRIVATE_H */ diff --git a/libmodbus/modbus-rtu-private.h b/libmodbus/modbus-rtu-private.h new file mode 100644 index 0000000..1c7d478 --- /dev/null +++ b/libmodbus/modbus-rtu-private.h @@ -0,0 +1,76 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#ifndef MODBUS_RTU_PRIVATE_H +#define MODBUS_RTU_PRIVATE_H + +#ifndef _MSC_VER +#include +#else +#include "stdint.h" +#endif + +#if defined(_WIN32) +#include +#else +#include +#endif + +#define _MODBUS_RTU_HEADER_LENGTH 1 +#define _MODBUS_RTU_PRESET_REQ_LENGTH 6 +#define _MODBUS_RTU_PRESET_RSP_LENGTH 2 + +#define _MODBUS_RTU_CHECKSUM_LENGTH 2 + +#if defined(_WIN32) +#if !defined(ENOTSUP) +#define ENOTSUP WSAEOPNOTSUPP +#endif + +/* WIN32: struct containing serial handle and a receive buffer */ +#define PY_BUF_SIZE 512 +struct win32_ser { + /* File handle */ + HANDLE fd; + /* Receive buffer */ + uint8_t buf[PY_BUF_SIZE]; + /* Received chars */ + DWORD n_bytes; +}; +#endif /* _WIN32 */ + +typedef struct _modbus_rtu { + /* Device: "/dev/ttyS0", "/dev/ttyUSB0" or "/dev/tty.USA19*" on Mac OS X. */ + char *device; + /* Bauds: 9600, 19200, 57600, 115200, etc */ + int baud; + /* Data bit */ + uint8_t data_bit; + /* Stop bit */ + uint8_t stop_bit; + /* Parity: 'N', 'O', 'E' */ + char parity; +#if defined(_WIN32) + struct win32_ser w_ser; + DCB old_dcb; +#else + /* Save old termios settings */ + struct termios old_tios; +#endif +#if HAVE_DECL_TIOCSRS485 + int serial_mode; +#endif +#if HAVE_DECL_TIOCM_RTS + int rts; + int rts_delay; + int onebyte_time; + void (*set_rts) (modbus_t *ctx, int on); +#endif + /* To handle many slaves on the same link */ + int confirmation_to_ignore; +} modbus_rtu_t; + +#endif /* MODBUS_RTU_PRIVATE_H */ diff --git a/libmodbus/modbus-rtu.c b/libmodbus/modbus-rtu.c new file mode 100644 index 0000000..ba4ad95 --- /dev/null +++ b/libmodbus/modbus-rtu.c @@ -0,0 +1,1305 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#include +#include +#include +#include +#include +#ifndef _MSC_VER +#include +#endif +#include + +#include "modbus-private.h" + +#include "modbus-rtu.h" +#include "modbus-rtu-private.h" + +#if HAVE_DECL_TIOCSRS485 || HAVE_DECL_TIOCM_RTS +#include +#endif + +#if HAVE_DECL_TIOCSRS485 +#include +#endif + +/* Table of CRC values for high-order byte */ +static const uint8_t table_crc_hi[] = { + 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, + 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, + 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, + 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, + 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, + 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, + 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, + 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, + 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, + 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, + 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, + 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, + 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, + 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, + 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, + 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, + 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, + 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, + 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, + 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, + 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, + 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, + 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, + 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, + 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, + 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40 +}; + +/* Table of CRC values for low-order byte */ +static const uint8_t table_crc_lo[] = { + 0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, + 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD, + 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, + 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, + 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4, + 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3, + 0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, + 0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4, + 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, + 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, + 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, + 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26, + 0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, + 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, + 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, + 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, + 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E, + 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5, + 0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, + 0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, + 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C, + 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, + 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B, + 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C, + 0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, + 0x43, 0x83, 0x41, 0x81, 0x80, 0x40 +}; + +/* Define the slave ID of the remote device to talk in master mode or set the + * internal slave ID in slave mode */ +static int _modbus_set_slave(modbus_t *ctx, int slave) +{ + /* Broadcast address is 0 (MODBUS_BROADCAST_ADDRESS) */ + if (slave >= 0 && slave <= 247) { + ctx->slave = slave; + } else { + errno = EINVAL; + return -1; + } + + return 0; +} + +/* Builds a RTU request header */ +static int _modbus_rtu_build_request_basis(modbus_t *ctx, int function, + int addr, int nb, + uint8_t *req) +{ + assert(ctx->slave != -1); + req[0] = ctx->slave; + req[1] = function; + req[2] = addr >> 8; + req[3] = addr & 0x00ff; + req[4] = nb >> 8; + req[5] = nb & 0x00ff; + + return _MODBUS_RTU_PRESET_REQ_LENGTH; +} + +/* Builds a RTU response header */ +static int _modbus_rtu_build_response_basis(sft_t *sft, uint8_t *rsp) +{ + /* In this case, the slave is certainly valid because a check is already + * done in _modbus_rtu_listen */ + rsp[0] = sft->slave; + rsp[1] = sft->function; + + return _MODBUS_RTU_PRESET_RSP_LENGTH; +} + +static uint16_t crc16(uint8_t *buffer, uint16_t buffer_length) +{ + uint8_t crc_hi = 0xFF; /* high CRC byte initialized */ + uint8_t crc_lo = 0xFF; /* low CRC byte initialized */ + unsigned int i; /* will index into CRC lookup */ + + /* pass through message buffer */ + while (buffer_length--) { + i = crc_lo ^ *buffer++; /* calculate the CRC */ + crc_lo = crc_hi ^ table_crc_hi[i]; + crc_hi = table_crc_lo[i]; + } + + return (crc_hi << 8 | crc_lo); +} + +static int _modbus_rtu_prepare_response_tid(const uint8_t *req, int *req_length) +{ + (*req_length) -= _MODBUS_RTU_CHECKSUM_LENGTH; + /* No TID */ + return 0; +} + +static int _modbus_rtu_send_msg_pre(uint8_t *req, int req_length) +{ + uint16_t crc = crc16(req, req_length); + + /* According to the MODBUS specs (p. 14), the low order byte of the CRC comes + * first in the RTU message */ + req[req_length++] = crc & 0x00FF; + req[req_length++] = crc >> 8; + + return req_length; +} + +#if defined(_WIN32) + +/* This simple implementation is sort of a substitute of the select() call, + * working this way: the win32_ser_select() call tries to read some data from + * the serial port, setting the timeout as the select() call would. Data read is + * stored into the receive buffer, that is then consumed by the win32_ser_read() + * call. So win32_ser_select() does both the event waiting and the reading, + * while win32_ser_read() only consumes the receive buffer. + */ + +static void win32_ser_init(struct win32_ser *ws) +{ + /* Clear everything */ + memset(ws, 0x00, sizeof(struct win32_ser)); + + /* Set file handle to invalid */ + ws->fd = INVALID_HANDLE_VALUE; +} + +/* FIXME Try to remove length_to_read -> max_len argument, only used by win32 */ +static int win32_ser_select(struct win32_ser *ws, int max_len, + const struct timeval *tv) +{ + COMMTIMEOUTS comm_to; + unsigned int msec = 0; + + /* Check if some data still in the buffer to be consumed */ + if (ws->n_bytes > 0) { + return 1; + } + + /* Setup timeouts like select() would do. + FIXME Please someone on Windows can look at this? + Does it possible to use WaitCommEvent? + When tv is NULL, MAXDWORD isn't infinite! + */ + if (tv == NULL) { + msec = MAXDWORD; + } else { + msec = tv->tv_sec * 1000 + tv->tv_usec / 1000; + if (msec < 1) + msec = 1; + } + + comm_to.ReadIntervalTimeout = msec; + comm_to.ReadTotalTimeoutMultiplier = 0; + comm_to.ReadTotalTimeoutConstant = msec; + comm_to.WriteTotalTimeoutMultiplier = 0; + comm_to.WriteTotalTimeoutConstant = 1000; + SetCommTimeouts(ws->fd, &comm_to); + + /* Read some bytes */ + if ((max_len > PY_BUF_SIZE) || (max_len < 0)) { + max_len = PY_BUF_SIZE; + } + + if (ReadFile(ws->fd, &ws->buf, max_len, &ws->n_bytes, NULL)) { + /* Check if some bytes available */ + if (ws->n_bytes > 0) { + /* Some bytes read */ + return 1; + } else { + /* Just timed out */ + return 0; + } + } else { + /* Some kind of error */ + return -1; + } +} + +static int win32_ser_read(struct win32_ser *ws, uint8_t *p_msg, + unsigned int max_len) +{ + unsigned int n = ws->n_bytes; + + if (max_len < n) { + n = max_len; + } + + if (n > 0) { + memcpy(p_msg, ws->buf, n); + } + + ws->n_bytes -= n; + + return n; +} +#endif + +#if HAVE_DECL_TIOCM_RTS +static void _modbus_rtu_ioctl_rts(modbus_t *ctx, int on) +{ + int fd = ctx->s; + int flags; + + ioctl(fd, TIOCMGET, &flags); + if (on) { + flags |= TIOCM_RTS; + } else { + flags &= ~TIOCM_RTS; + } + ioctl(fd, TIOCMSET, &flags); +} +#endif + +static ssize_t _modbus_rtu_send(modbus_t *ctx, const uint8_t *req, int req_length) +{ +#if defined(_WIN32) + modbus_rtu_t *ctx_rtu = ctx->backend_data; + DWORD n_bytes = 0; + return (WriteFile(ctx_rtu->w_ser.fd, req, req_length, &n_bytes, NULL)) ? (ssize_t)n_bytes : -1; +#else +#if HAVE_DECL_TIOCM_RTS + modbus_rtu_t *ctx_rtu = ctx->backend_data; + if (ctx_rtu->rts != MODBUS_RTU_RTS_NONE) { + ssize_t size; + + if (ctx->debug) { + fprintf(stderr, "Sending request using RTS signal\n"); + } + + ctx_rtu->set_rts(ctx, ctx_rtu->rts == MODBUS_RTU_RTS_UP); + usleep(ctx_rtu->rts_delay); + + size = write(ctx->s, req, req_length); + + usleep(ctx_rtu->onebyte_time * req_length + ctx_rtu->rts_delay); + ctx_rtu->set_rts(ctx, ctx_rtu->rts != MODBUS_RTU_RTS_UP); + + return size; + } else { +#endif + return write(ctx->s, req, req_length); +#if HAVE_DECL_TIOCM_RTS + } +#endif +#endif +} + +static int _modbus_rtu_receive(modbus_t *ctx, uint8_t *req) +{ + int rc; + modbus_rtu_t *ctx_rtu = ctx->backend_data; + + if (ctx_rtu->confirmation_to_ignore) { + _modbus_receive_msg(ctx, req, MSG_CONFIRMATION); + /* Ignore errors and reset the flag */ + ctx_rtu->confirmation_to_ignore = FALSE; + rc = 0; + if (ctx->debug) { + printf("Confirmation to ignore\n"); + } + } else { + rc = _modbus_receive_msg(ctx, req, MSG_INDICATION); + if (rc == 0) { + /* The next expected message is a confirmation to ignore */ + ctx_rtu->confirmation_to_ignore = TRUE; + } + } + return rc; +} + +static ssize_t _modbus_rtu_recv(modbus_t *ctx, uint8_t *rsp, int rsp_length) +{ +#if defined(_WIN32) + return win32_ser_read(&((modbus_rtu_t *)ctx->backend_data)->w_ser, rsp, rsp_length); +#else + return read(ctx->s, rsp, rsp_length); +#endif +} + +static int _modbus_rtu_flush(modbus_t *); + +static int _modbus_rtu_pre_check_confirmation(modbus_t *ctx, const uint8_t *req, + const uint8_t *rsp, int rsp_length) +{ + /* Check responding slave is the slave we requested (except for broacast + * request) */ + if (req[0] != rsp[0] && req[0] != MODBUS_BROADCAST_ADDRESS) { + if (ctx->debug) { + fprintf(stderr, + "The responding slave %d isn't the requested slave %d\n", + rsp[0], req[0]); + } + errno = EMBBADSLAVE; + return -1; + } else { + return 0; + } +} + +/* The check_crc16 function shall return 0 if the message is ignored and the + message length if the CRC is valid. Otherwise it shall return -1 and set + errno to EMBBADCRC. */ +static int _modbus_rtu_check_integrity(modbus_t *ctx, uint8_t *msg, + const int msg_length) +{ + uint16_t crc_calculated; + uint16_t crc_received; + int slave = msg[0]; + + /* Filter on the Modbus unit identifier (slave) in RTU mode to avoid useless + * CRC computing. */ + if (slave != ctx->slave && slave != MODBUS_BROADCAST_ADDRESS) { + if (ctx->debug) { + printf("Request for slave %d ignored (not %d)\n", slave, ctx->slave); + } + /* Following call to check_confirmation handles this error */ + return 0; + } + + crc_calculated = crc16(msg, msg_length - 2); + crc_received = (msg[msg_length - 1] << 8) | msg[msg_length - 2]; + + /* Check CRC of msg */ + if (crc_calculated == crc_received) { + return msg_length; + } else { + if (ctx->debug) { + fprintf(stderr, "ERROR CRC received 0x%0X != CRC calculated 0x%0X\n", + crc_received, crc_calculated); + } + + if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) { + _modbus_rtu_flush(ctx); + } + errno = EMBBADCRC; + return -1; + } +} + +/* Sets up a serial port for RTU communications */ +static int _modbus_rtu_connect(modbus_t *ctx) +{ +#if defined(_WIN32) + DCB dcb; +#else + struct termios tios; + speed_t speed; + int flags; +#endif + modbus_rtu_t *ctx_rtu = ctx->backend_data; + + if (ctx->debug) { + printf("Opening %s at %d bauds (%c, %d, %d)\n", + ctx_rtu->device, ctx_rtu->baud, ctx_rtu->parity, + ctx_rtu->data_bit, ctx_rtu->stop_bit); + } + +#if defined(_WIN32) + /* Some references here: + * http://msdn.microsoft.com/en-us/library/aa450602.aspx + */ + win32_ser_init(&ctx_rtu->w_ser); + + /* ctx_rtu->device should contain a string like "COMxx:" xx being a decimal + * number */ + ctx_rtu->w_ser.fd = CreateFileA(ctx_rtu->device, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + 0, + NULL); + + /* Error checking */ + if (ctx_rtu->w_ser.fd == INVALID_HANDLE_VALUE) { + if (ctx->debug) { + fprintf(stderr, "ERROR Can't open the device %s (LastError %d)\n", + ctx_rtu->device, (int)GetLastError()); + } + return -1; + } + + /* Save params */ + ctx_rtu->old_dcb.DCBlength = sizeof(DCB); + if (!GetCommState(ctx_rtu->w_ser.fd, &ctx_rtu->old_dcb)) { + if (ctx->debug) { + fprintf(stderr, "ERROR Error getting configuration (LastError %d)\n", + (int)GetLastError()); + } + CloseHandle(ctx_rtu->w_ser.fd); + ctx_rtu->w_ser.fd = INVALID_HANDLE_VALUE; + return -1; + } + + /* Build new configuration (starting from current settings) */ + dcb = ctx_rtu->old_dcb; + + /* Speed setting */ + switch (ctx_rtu->baud) { + case 110: + dcb.BaudRate = CBR_110; + break; + case 300: + dcb.BaudRate = CBR_300; + break; + case 600: + dcb.BaudRate = CBR_600; + break; + case 1200: + dcb.BaudRate = CBR_1200; + break; + case 2400: + dcb.BaudRate = CBR_2400; + break; + case 4800: + dcb.BaudRate = CBR_4800; + break; + case 9600: + dcb.BaudRate = CBR_9600; + break; + case 14400: + dcb.BaudRate = CBR_14400; + break; + case 19200: + dcb.BaudRate = CBR_19200; + break; + case 38400: + dcb.BaudRate = CBR_38400; + break; + case 57600: + dcb.BaudRate = CBR_57600; + break; + case 115200: + dcb.BaudRate = CBR_115200; + break; + case 230400: + /* CBR_230400 - not defined */ + dcb.BaudRate = 230400; + break; + case 250000: + dcb.BaudRate = 250000; + break; + case 256000: + dcb.BaudRate = 256000; + break; + case 460800: + dcb.BaudRate = 460800; + break; + case 500000: + dcb.BaudRate = 500000; + break; + case 921600: + dcb.BaudRate = 921600; + break; + case 1000000: + dcb.BaudRate = 1000000; + break; + default: + dcb.BaudRate = CBR_9600; + if (ctx->debug) { + fprintf(stderr, "WARNING Unknown baud rate %d for %s (B9600 used)\n", + ctx_rtu->baud, ctx_rtu->device); + } + } + + /* Data bits */ + switch (ctx_rtu->data_bit) { + case 5: + dcb.ByteSize = 5; + break; + case 6: + dcb.ByteSize = 6; + break; + case 7: + dcb.ByteSize = 7; + break; + case 8: + default: + dcb.ByteSize = 8; + break; + } + + /* Stop bits */ + if (ctx_rtu->stop_bit == 1) + dcb.StopBits = ONESTOPBIT; + else /* 2 */ + dcb.StopBits = TWOSTOPBITS; + + /* Parity */ + if (ctx_rtu->parity == 'N') { + dcb.Parity = NOPARITY; + dcb.fParity = FALSE; + } else if (ctx_rtu->parity == 'E') { + dcb.Parity = EVENPARITY; + dcb.fParity = TRUE; + } else { + /* odd */ + dcb.Parity = ODDPARITY; + dcb.fParity = TRUE; + } + + /* Hardware handshaking left as default settings retrieved */ + + /* No software handshaking */ + dcb.fTXContinueOnXoff = TRUE; + dcb.fOutX = FALSE; + dcb.fInX = FALSE; + + /* Binary mode (it's the only supported on Windows anyway) */ + dcb.fBinary = TRUE; + + /* Don't want errors to be blocking */ + dcb.fAbortOnError = FALSE; + + /* Setup port */ + if (!SetCommState(ctx_rtu->w_ser.fd, &dcb)) { + if (ctx->debug) { + fprintf(stderr, "ERROR Error setting new configuration (LastError %d)\n", + (int)GetLastError()); + } + CloseHandle(ctx_rtu->w_ser.fd); + ctx_rtu->w_ser.fd = INVALID_HANDLE_VALUE; + return -1; + } +#else + /* The O_NOCTTY flag tells UNIX that this program doesn't want + to be the "controlling terminal" for that port. If you + don't specify this then any input (such as keyboard abort + signals and so forth) will affect your process + + Timeouts are ignored in canonical input mode or when the + NDELAY option is set on the file via open or fcntl */ + flags = O_RDWR | O_NOCTTY | O_NDELAY | O_EXCL; +#ifdef O_CLOEXEC + flags |= O_CLOEXEC; +#endif + + ctx->s = open(ctx_rtu->device, flags); + if (ctx->s == -1) { + if (ctx->debug) { + fprintf(stderr, "ERROR Can't open the device %s (%s)\n", + ctx_rtu->device, strerror(errno)); + } + return -1; + } + + /* Save */ + tcgetattr(ctx->s, &ctx_rtu->old_tios); + + memset(&tios, 0, sizeof(struct termios)); + + /* C_ISPEED Input baud (new interface) + C_OSPEED Output baud (new interface) + */ + switch (ctx_rtu->baud) { + case 110: + speed = B110; + break; + case 300: + speed = B300; + break; + case 600: + speed = B600; + break; + case 1200: + speed = B1200; + break; + case 2400: + speed = B2400; + break; + case 4800: + speed = B4800; + break; + case 9600: + speed = B9600; + break; + case 19200: + speed = B19200; + break; + case 38400: + speed = B38400; + break; +#ifdef B57600 + case 57600: + speed = B57600; + break; +#endif +#ifdef B115200 + case 115200: + speed = B115200; + break; +#endif +#ifdef B230400 + case 230400: + speed = B230400; + break; +#endif +#ifdef B460800 + case 460800: + speed = B460800; + break; +#endif +#ifdef B500000 + case 500000: + speed = B500000; + break; +#endif +#ifdef B576000 + case 576000: + speed = B576000; + break; +#endif +#ifdef B921600 + case 921600: + speed = B921600; + break; +#endif +#ifdef B1000000 + case 1000000: + speed = B1000000; + break; +#endif +#ifdef B1152000 + case 1152000: + speed = B1152000; + break; +#endif +#ifdef B1500000 + case 1500000: + speed = B1500000; + break; +#endif +#ifdef B2500000 + case 2500000: + speed = B2500000; + break; +#endif +#ifdef B3000000 + case 3000000: + speed = B3000000; + break; +#endif +#ifdef B3500000 + case 3500000: + speed = B3500000; + break; +#endif +#ifdef B4000000 + case 4000000: + speed = B4000000; + break; +#endif + default: + speed = B9600; + if (ctx->debug) { + fprintf(stderr, + "WARNING Unknown baud rate %d for %s (B9600 used)\n", + ctx_rtu->baud, ctx_rtu->device); + } + } + + /* Set the baud rate */ + if ((cfsetispeed(&tios, speed) < 0) || + (cfsetospeed(&tios, speed) < 0)) { + close(ctx->s); + ctx->s = -1; + return -1; + } + + /* C_CFLAG Control options + CLOCAL Local line - do not change "owner" of port + CREAD Enable receiver + */ + tios.c_cflag |= (CREAD | CLOCAL); + /* CSIZE, HUPCL, CRTSCTS (hardware flow control) */ + + /* Set data bits (5, 6, 7, 8 bits) + CSIZE Bit mask for data bits + */ + tios.c_cflag &= ~CSIZE; + switch (ctx_rtu->data_bit) { + case 5: + tios.c_cflag |= CS5; + break; + case 6: + tios.c_cflag |= CS6; + break; + case 7: + tios.c_cflag |= CS7; + break; + case 8: + default: + tios.c_cflag |= CS8; + break; + } + + /* Stop bit (1 or 2) */ + if (ctx_rtu->stop_bit == 1) + tios.c_cflag &=~ CSTOPB; + else /* 2 */ + tios.c_cflag |= CSTOPB; + + /* PARENB Enable parity bit + PARODD Use odd parity instead of even */ + if (ctx_rtu->parity == 'N') { + /* None */ + tios.c_cflag &=~ PARENB; + } else if (ctx_rtu->parity == 'E') { + /* Even */ + tios.c_cflag |= PARENB; + tios.c_cflag &=~ PARODD; + } else { + /* Odd */ + tios.c_cflag |= PARENB; + tios.c_cflag |= PARODD; + } + + /* Read the man page of termios if you need more information. */ + + /* This field isn't used on POSIX systems + tios.c_line = 0; + */ + + /* C_LFLAG Line options + + ISIG Enable SIGINTR, SIGSUSP, SIGDSUSP, and SIGQUIT signals + ICANON Enable canonical input (else raw) + XCASE Map uppercase \lowercase (obsolete) + ECHO Enable echoing of input characters + ECHOE Echo erase character as BS-SP-BS + ECHOK Echo NL after kill character + ECHONL Echo NL + NOFLSH Disable flushing of input buffers after + interrupt or quit characters + IEXTEN Enable extended functions + ECHOCTL Echo control characters as ^char and delete as ~? + ECHOPRT Echo erased character as character erased + ECHOKE BS-SP-BS entire line on line kill + FLUSHO Output being flushed + PENDIN Retype pending input at next read or input char + TOSTOP Send SIGTTOU for background output + + Canonical input is line-oriented. Input characters are put + into a buffer which can be edited interactively by the user + until a CR (carriage return) or LF (line feed) character is + received. + + Raw input is unprocessed. Input characters are passed + through exactly as they are received, when they are + received. Generally you'll deselect the ICANON, ECHO, + ECHOE, and ISIG options when using raw input + */ + + /* Raw input */ + tios.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); + + /* C_IFLAG Input options + + Constant Description + INPCK Enable parity check + IGNPAR Ignore parity errors + PARMRK Mark parity errors + ISTRIP Strip parity bits + IXON Enable software flow control (outgoing) + IXOFF Enable software flow control (incoming) + IXANY Allow any character to start flow again + IGNBRK Ignore break condition + BRKINT Send a SIGINT when a break condition is detected + INLCR Map NL to CR + IGNCR Ignore CR + ICRNL Map CR to NL + IUCLC Map uppercase to lowercase + IMAXBEL Echo BEL on input line too long + */ + if (ctx_rtu->parity == 'N') { + /* None */ + tios.c_iflag &= ~INPCK; + } else { + tios.c_iflag |= INPCK; + } + + /* Software flow control is disabled */ + tios.c_iflag &= ~(IXON | IXOFF | IXANY); + + /* C_OFLAG Output options + OPOST Postprocess output (not set = raw output) + ONLCR Map NL to CR-NL + + ONCLR ant others needs OPOST to be enabled + */ + + /* Raw output */ + tios.c_oflag &=~ OPOST; + + /* C_CC Control characters + VMIN Minimum number of characters to read + VTIME Time to wait for data (tenths of seconds) + + UNIX serial interface drivers provide the ability to + specify character and packet timeouts. Two elements of the + c_cc array are used for timeouts: VMIN and VTIME. Timeouts + are ignored in canonical input mode or when the NDELAY + option is set on the file via open or fcntl. + + VMIN specifies the minimum number of characters to read. If + it is set to 0, then the VTIME value specifies the time to + wait for every character read. Note that this does not mean + that a read call for N bytes will wait for N characters to + come in. Rather, the timeout will apply to the first + character and the read call will return the number of + characters immediately available (up to the number you + request). + + If VMIN is non-zero, VTIME specifies the time to wait for + the first character read. If a character is read within the + time given, any read will block (wait) until all VMIN + characters are read. That is, once the first character is + read, the serial interface driver expects to receive an + entire packet of characters (VMIN bytes total). If no + character is read within the time allowed, then the call to + read returns 0. This method allows you to tell the serial + driver you need exactly N bytes and any read call will + return 0 or N bytes. However, the timeout only applies to + the first character read, so if for some reason the driver + misses one character inside the N byte packet then the read + call could block forever waiting for additional input + characters. + + VTIME specifies the amount of time to wait for incoming + characters in tenths of seconds. If VTIME is set to 0 (the + default), reads will block (wait) indefinitely unless the + NDELAY option is set on the port with open or fcntl. + */ + /* Unused because we use open with the NDELAY option */ + tios.c_cc[VMIN] = 0; + tios.c_cc[VTIME] = 0; + + if (tcsetattr(ctx->s, TCSANOW, &tios) < 0) { + close(ctx->s); + ctx->s = -1; + return -1; + } +#endif + + return 0; +} + +int modbus_rtu_set_serial_mode(modbus_t *ctx, int mode) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) { +#if HAVE_DECL_TIOCSRS485 + modbus_rtu_t *ctx_rtu = ctx->backend_data; + struct serial_rs485 rs485conf; + + if (mode == MODBUS_RTU_RS485) { + // Get + if (ioctl(ctx->s, TIOCGRS485, &rs485conf) < 0) { + return -1; + } + // Set + rs485conf.flags |= SER_RS485_ENABLED; + if (ioctl(ctx->s, TIOCSRS485, &rs485conf) < 0) { + return -1; + } + + ctx_rtu->serial_mode = MODBUS_RTU_RS485; + return 0; + } else if (mode == MODBUS_RTU_RS232) { + /* Turn off RS485 mode only if required */ + if (ctx_rtu->serial_mode == MODBUS_RTU_RS485) { + /* The ioctl call is avoided because it can fail on some RS232 ports */ + if (ioctl(ctx->s, TIOCGRS485, &rs485conf) < 0) { + return -1; + } + rs485conf.flags &= ~SER_RS485_ENABLED; + if (ioctl(ctx->s, TIOCSRS485, &rs485conf) < 0) { + return -1; + } + } + ctx_rtu->serial_mode = MODBUS_RTU_RS232; + return 0; + } +#else + if (ctx->debug) { + fprintf(stderr, "This function isn't supported on your platform\n"); + } + errno = ENOTSUP; + return -1; +#endif + } + + /* Wrong backend and invalid mode specified */ + errno = EINVAL; + return -1; +} + +int modbus_rtu_get_serial_mode(modbus_t *ctx) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) { +#if HAVE_DECL_TIOCSRS485 + modbus_rtu_t *ctx_rtu = ctx->backend_data; + return ctx_rtu->serial_mode; +#else + if (ctx->debug) { + fprintf(stderr, "This function isn't supported on your platform\n"); + } + errno = ENOTSUP; + return -1; +#endif + } else { + errno = EINVAL; + return -1; + } +} + +int modbus_rtu_get_rts(modbus_t *ctx) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) { +#if HAVE_DECL_TIOCM_RTS + modbus_rtu_t *ctx_rtu = ctx->backend_data; + return ctx_rtu->rts; +#else + if (ctx->debug) { + fprintf(stderr, "This function isn't supported on your platform\n"); + } + errno = ENOTSUP; + return -1; +#endif + } else { + errno = EINVAL; + return -1; + } +} + +int modbus_rtu_set_rts(modbus_t *ctx, int mode) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) { +#if HAVE_DECL_TIOCM_RTS + modbus_rtu_t *ctx_rtu = ctx->backend_data; + + if (mode == MODBUS_RTU_RTS_NONE || mode == MODBUS_RTU_RTS_UP || + mode == MODBUS_RTU_RTS_DOWN) { + ctx_rtu->rts = mode; + + /* Set the RTS bit in order to not reserve the RS485 bus */ + ctx_rtu->set_rts(ctx, ctx_rtu->rts != MODBUS_RTU_RTS_UP); + + return 0; + } else { + errno = EINVAL; + return -1; + } +#else + if (ctx->debug) { + fprintf(stderr, "This function isn't supported on your platform\n"); + } + errno = ENOTSUP; + return -1; +#endif + } + /* Wrong backend or invalid mode specified */ + errno = EINVAL; + return -1; +} + +int modbus_rtu_set_custom_rts(modbus_t *ctx, void (*set_rts) (modbus_t *ctx, int on)) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) { +#if HAVE_DECL_TIOCM_RTS + modbus_rtu_t *ctx_rtu = ctx->backend_data; + ctx_rtu->set_rts = set_rts; + return 0; +#else + if (ctx->debug) { + fprintf(stderr, "This function isn't supported on your platform\n"); + } + errno = ENOTSUP; + return -1; +#endif + } else { + errno = EINVAL; + return -1; + } +} + +int modbus_rtu_get_rts_delay(modbus_t *ctx) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) { +#if HAVE_DECL_TIOCM_RTS + modbus_rtu_t *ctx_rtu; + ctx_rtu = (modbus_rtu_t *)ctx->backend_data; + return ctx_rtu->rts_delay; +#else + if (ctx->debug) { + fprintf(stderr, "This function isn't supported on your platform\n"); + } + errno = ENOTSUP; + return -1; +#endif + } else { + errno = EINVAL; + return -1; + } +} + +int modbus_rtu_set_rts_delay(modbus_t *ctx, int us) +{ + if (ctx == NULL || us < 0) { + errno = EINVAL; + return -1; + } + + if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) { +#if HAVE_DECL_TIOCM_RTS + modbus_rtu_t *ctx_rtu; + ctx_rtu = (modbus_rtu_t *)ctx->backend_data; + ctx_rtu->rts_delay = us; + return 0; +#else + if (ctx->debug) { + fprintf(stderr, "This function isn't supported on your platform\n"); + } + errno = ENOTSUP; + return -1; +#endif + } else { + errno = EINVAL; + return -1; + } +} + +static void _modbus_rtu_close(modbus_t *ctx) +{ + /* Restore line settings and close file descriptor in RTU mode */ + modbus_rtu_t *ctx_rtu = ctx->backend_data; + +#if defined(_WIN32) + /* Revert settings */ + if (!SetCommState(ctx_rtu->w_ser.fd, &ctx_rtu->old_dcb) && ctx->debug) { + fprintf(stderr, "ERROR Couldn't revert to configuration (LastError %d)\n", + (int)GetLastError()); + } + + if (!CloseHandle(ctx_rtu->w_ser.fd) && ctx->debug) { + fprintf(stderr, "ERROR Error while closing handle (LastError %d)\n", + (int)GetLastError()); + } +#else + if (ctx->s != -1) { + tcsetattr(ctx->s, TCSANOW, &ctx_rtu->old_tios); + close(ctx->s); + ctx->s = -1; + } +#endif +} + +static int _modbus_rtu_flush(modbus_t *ctx) +{ +#if defined(_WIN32) + modbus_rtu_t *ctx_rtu = ctx->backend_data; + ctx_rtu->w_ser.n_bytes = 0; + return (PurgeComm(ctx_rtu->w_ser.fd, PURGE_RXCLEAR) == FALSE); +#else + return tcflush(ctx->s, TCIOFLUSH); +#endif +} + +static int _modbus_rtu_select(modbus_t *ctx, fd_set *rset, + struct timeval *tv, int length_to_read) +{ + int s_rc; +#if defined(_WIN32) + s_rc = win32_ser_select(&((modbus_rtu_t *)ctx->backend_data)->w_ser, + length_to_read, tv); + if (s_rc == 0) { + errno = ETIMEDOUT; + return -1; + } + + if (s_rc < 0) { + return -1; + } +#else + while ((s_rc = select(ctx->s+1, rset, NULL, NULL, tv)) == -1) { + if (errno == EINTR) { + if (ctx->debug) { + fprintf(stderr, "A non blocked signal was caught\n"); + } + /* Necessary after an error */ + FD_ZERO(rset); + FD_SET(ctx->s, rset); + } else { + return -1; + } + } + + if (s_rc == 0) { + /* Timeout */ + errno = ETIMEDOUT; + return -1; + } +#endif + + return s_rc; +} + +static void _modbus_rtu_free(modbus_t *ctx) { + if (ctx->backend_data) { + free(((modbus_rtu_t *)ctx->backend_data)->device); + free(ctx->backend_data); + } + + free(ctx); +} + +const modbus_backend_t _modbus_rtu_backend = { + _MODBUS_BACKEND_TYPE_RTU, + _MODBUS_RTU_HEADER_LENGTH, + _MODBUS_RTU_CHECKSUM_LENGTH, + MODBUS_RTU_MAX_ADU_LENGTH, + _modbus_set_slave, + _modbus_rtu_build_request_basis, + _modbus_rtu_build_response_basis, + _modbus_rtu_prepare_response_tid, + _modbus_rtu_send_msg_pre, + _modbus_rtu_send, + _modbus_rtu_receive, + _modbus_rtu_recv, + _modbus_rtu_check_integrity, + _modbus_rtu_pre_check_confirmation, + _modbus_rtu_connect, + _modbus_rtu_close, + _modbus_rtu_flush, + _modbus_rtu_select, + _modbus_rtu_free +}; + +modbus_t* modbus_new_rtu(const char *device, + int baud, char parity, int data_bit, + int stop_bit) +{ + modbus_t *ctx; + modbus_rtu_t *ctx_rtu; + + /* Check device argument */ + if (device == NULL || *device == 0) { + fprintf(stderr, "The device string is empty\n"); + errno = EINVAL; + return NULL; + } + + /* Check baud argument */ + if (baud == 0) { + fprintf(stderr, "The baud rate value must not be zero\n"); + errno = EINVAL; + return NULL; + } + + ctx = (modbus_t *)malloc(sizeof(modbus_t)); + if (ctx == NULL) { + return NULL; + } + + _modbus_init_common(ctx); + ctx->backend = &_modbus_rtu_backend; + ctx->backend_data = (modbus_rtu_t *)malloc(sizeof(modbus_rtu_t)); + if (ctx->backend_data == NULL) { + modbus_free(ctx); + errno = ENOMEM; + return NULL; + } + ctx_rtu = (modbus_rtu_t *)ctx->backend_data; + + /* Device name and \0 */ + ctx_rtu->device = (char *)malloc((strlen(device) + 1) * sizeof(char)); + if (ctx_rtu->device == NULL) { + modbus_free(ctx); + errno = ENOMEM; + return NULL; + } + strcpy(ctx_rtu->device, device); + + ctx_rtu->baud = baud; + if (parity == 'N' || parity == 'E' || parity == 'O') { + ctx_rtu->parity = parity; + } else { + modbus_free(ctx); + errno = EINVAL; + return NULL; + } + ctx_rtu->data_bit = data_bit; + ctx_rtu->stop_bit = stop_bit; + +#if HAVE_DECL_TIOCSRS485 + /* The RS232 mode has been set by default */ + ctx_rtu->serial_mode = MODBUS_RTU_RS232; +#endif + +#if HAVE_DECL_TIOCM_RTS + /* The RTS use has been set by default */ + ctx_rtu->rts = MODBUS_RTU_RTS_NONE; + + /* Calculate estimated time in micro second to send one byte */ + ctx_rtu->onebyte_time = 1000000 * (1 + data_bit + (parity == 'N' ? 0 : 1) + stop_bit) / baud; + + /* The internal function is used by default to set RTS */ + ctx_rtu->set_rts = _modbus_rtu_ioctl_rts; + + /* The delay before and after transmission when toggling the RTS pin */ + ctx_rtu->rts_delay = ctx_rtu->onebyte_time; +#endif + + ctx_rtu->confirmation_to_ignore = FALSE; + + return ctx; +} diff --git a/libmodbus/modbus-rtu.h b/libmodbus/modbus-rtu.h new file mode 100644 index 0000000..fa37655 --- /dev/null +++ b/libmodbus/modbus-rtu.h @@ -0,0 +1,42 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#ifndef MODBUS_RTU_H +#define MODBUS_RTU_H + +#include "modbus.h" + +MODBUS_BEGIN_DECLS + +/* Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5 + * RS232 / RS485 ADU = 253 bytes + slave (1 byte) + CRC (2 bytes) = 256 bytes + */ +#define MODBUS_RTU_MAX_ADU_LENGTH 256 + +MODBUS_API modbus_t* modbus_new_rtu(const char *device, int baud, char parity, + int data_bit, int stop_bit); + +#define MODBUS_RTU_RS232 0 +#define MODBUS_RTU_RS485 1 + +MODBUS_API int modbus_rtu_set_serial_mode(modbus_t *ctx, int mode); +MODBUS_API int modbus_rtu_get_serial_mode(modbus_t *ctx); + +#define MODBUS_RTU_RTS_NONE 0 +#define MODBUS_RTU_RTS_UP 1 +#define MODBUS_RTU_RTS_DOWN 2 + +MODBUS_API int modbus_rtu_set_rts(modbus_t *ctx, int mode); +MODBUS_API int modbus_rtu_get_rts(modbus_t *ctx); + +MODBUS_API int modbus_rtu_set_custom_rts(modbus_t *ctx, void (*set_rts) (modbus_t *ctx, int on)); + +MODBUS_API int modbus_rtu_set_rts_delay(modbus_t *ctx, int us); +MODBUS_API int modbus_rtu_get_rts_delay(modbus_t *ctx); + +MODBUS_END_DECLS + +#endif /* MODBUS_RTU_H */ diff --git a/libmodbus/modbus-tcp-private.h b/libmodbus/modbus-tcp-private.h new file mode 100644 index 0000000..164c8c7 --- /dev/null +++ b/libmodbus/modbus-tcp-private.h @@ -0,0 +1,44 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#ifndef MODBUS_TCP_PRIVATE_H +#define MODBUS_TCP_PRIVATE_H + +#define _MODBUS_TCP_HEADER_LENGTH 7 +#define _MODBUS_TCP_PRESET_REQ_LENGTH 12 +#define _MODBUS_TCP_PRESET_RSP_LENGTH 8 + +#define _MODBUS_TCP_CHECKSUM_LENGTH 0 + +/* In both structures, the transaction ID must be placed on first position + to have a quick access not dependent of the TCP backend */ +typedef struct _modbus_tcp { + /* Extract from MODBUS Messaging on TCP/IP Implementation Guide V1.0b + (page 23/46): + The transaction identifier is used to associate the future response + with the request. This identifier is unique on each TCP connection. */ + uint16_t t_id; + /* TCP port */ + int port; + /* IP address */ + char ip[16]; +} modbus_tcp_t; + +#define _MODBUS_TCP_PI_NODE_LENGTH 1025 +#define _MODBUS_TCP_PI_SERVICE_LENGTH 32 + +typedef struct _modbus_tcp_pi { + /* Transaction ID */ + uint16_t t_id; + /* TCP port */ + int port; + /* Node */ + char node[_MODBUS_TCP_PI_NODE_LENGTH]; + /* Service */ + char service[_MODBUS_TCP_PI_SERVICE_LENGTH]; +} modbus_tcp_pi_t; + +#endif /* MODBUS_TCP_PRIVATE_H */ diff --git a/libmodbus/modbus-tcp.c b/libmodbus/modbus-tcp.c new file mode 100644 index 0000000..5164273 --- /dev/null +++ b/libmodbus/modbus-tcp.c @@ -0,0 +1,929 @@ +/* + * Copyright © 2001-2013 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#if defined(_WIN32) +# define OS_WIN32 +/* ws2_32.dll has getaddrinfo and freeaddrinfo on Windows XP and later. + * minwg32 headers check WINVER before allowing the use of these */ +# ifndef WINVER +# define WINVER 0x0501 +# endif +#endif + +#include +#include +#include +#include +#ifndef _MSC_VER +#include +#endif +#include +#include + +#if defined(_WIN32) +/* Already set in modbus-tcp.h but it seems order matters in VS2005 */ +# include +# include +# define SHUT_RDWR 2 +# define close closesocket +#else +# include +# include + +#if defined(__OpenBSD__) || (defined(__FreeBSD__) && __FreeBSD__ < 5) +# define OS_BSD +# include +#endif + +# include +# include +# include +# include +# include +#endif + +#if !defined(MSG_NOSIGNAL) +#define MSG_NOSIGNAL 0 +#endif + +#if defined(_AIX) && !defined(MSG_DONTWAIT) +#define MSG_DONTWAIT MSG_NONBLOCK +#endif + +#include "modbus-private.h" + +#include "modbus-tcp.h" +#include "modbus-tcp-private.h" + +#ifdef OS_WIN32 +static int _modbus_tcp_init_win32(void) +{ + /* Initialise Windows Socket API */ + WSADATA wsaData; + + if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) { + fprintf(stderr, "WSAStartup() returned error code %d\n", + (unsigned int)GetLastError()); + errno = EIO; + return -1; + } + return 0; +} +#endif + +static int _modbus_set_slave(modbus_t *ctx, int slave) +{ + /* Broadcast address is 0 (MODBUS_BROADCAST_ADDRESS) */ + if (slave >= 0 && slave <= 247) { + ctx->slave = slave; + } else if (slave == MODBUS_TCP_SLAVE) { + /* The special value MODBUS_TCP_SLAVE (0xFF) can be used in TCP mode to + * restore the default value. */ + ctx->slave = slave; + } else { + errno = EINVAL; + return -1; + } + + return 0; +} + +/* Builds a TCP request header */ +static int _modbus_tcp_build_request_basis(modbus_t *ctx, int function, + int addr, int nb, + uint8_t *req) +{ + modbus_tcp_t *ctx_tcp = ctx->backend_data; + + /* Increase transaction ID */ + if (ctx_tcp->t_id < UINT16_MAX) + ctx_tcp->t_id++; + else + ctx_tcp->t_id = 0; + req[0] = ctx_tcp->t_id >> 8; + req[1] = ctx_tcp->t_id & 0x00ff; + + /* Protocol Modbus */ + req[2] = 0; + req[3] = 0; + + /* Length will be defined later by set_req_length_tcp at offsets 4 + and 5 */ + + req[6] = ctx->slave; + req[7] = function; + req[8] = addr >> 8; + req[9] = addr & 0x00ff; + req[10] = nb >> 8; + req[11] = nb & 0x00ff; + + return _MODBUS_TCP_PRESET_REQ_LENGTH; +} + +/* Builds a TCP response header */ +static int _modbus_tcp_build_response_basis(sft_t *sft, uint8_t *rsp) +{ + /* Extract from MODBUS Messaging on TCP/IP Implementation + Guide V1.0b (page 23/46): + The transaction identifier is used to associate the future + response with the request. */ + rsp[0] = sft->t_id >> 8; + rsp[1] = sft->t_id & 0x00ff; + + /* Protocol Modbus */ + rsp[2] = 0; + rsp[3] = 0; + + /* Length will be set later by send_msg (4 and 5) */ + + /* The slave ID is copied from the indication */ + rsp[6] = sft->slave; + rsp[7] = sft->function; + + return _MODBUS_TCP_PRESET_RSP_LENGTH; +} + + +static int _modbus_tcp_prepare_response_tid(const uint8_t *req, int *req_length) +{ + return (req[0] << 8) + req[1]; +} + +static int _modbus_tcp_send_msg_pre(uint8_t *req, int req_length) +{ + /* Subtract the header length to the message length */ + int mbap_length = req_length - 6; + + req[4] = mbap_length >> 8; + req[5] = mbap_length & 0x00FF; + + return req_length; +} + +static ssize_t _modbus_tcp_send(modbus_t *ctx, const uint8_t *req, int req_length) +{ + /* MSG_NOSIGNAL + Requests not to send SIGPIPE on errors on stream oriented + sockets when the other end breaks the connection. The EPIPE + error is still returned. */ + return send(ctx->s, (const char *)req, req_length, MSG_NOSIGNAL); +} + +static int _modbus_tcp_receive(modbus_t *ctx, uint8_t *req) { + return _modbus_receive_msg(ctx, req, MSG_INDICATION); +} + +static ssize_t _modbus_tcp_recv(modbus_t *ctx, uint8_t *rsp, int rsp_length) { + return recv(ctx->s, (char *)rsp, rsp_length, 0); +} + +static int _modbus_tcp_check_integrity(modbus_t *ctx, uint8_t *msg, const int msg_length) +{ + return msg_length; +} + +static int _modbus_tcp_pre_check_confirmation(modbus_t *ctx, const uint8_t *req, + const uint8_t *rsp, int rsp_length) +{ + /* Check transaction ID */ + if (req[0] != rsp[0] || req[1] != rsp[1]) { + if (ctx->debug) { + fprintf(stderr, "Invalid transaction ID received 0x%X (not 0x%X)\n", + (rsp[0] << 8) + rsp[1], (req[0] << 8) + req[1]); + } + errno = EMBBADDATA; + return -1; + } + + /* Check protocol ID */ + if (rsp[2] != 0x0 && rsp[3] != 0x0) { + if (ctx->debug) { + fprintf(stderr, "Invalid protocol ID received 0x%X (not 0x0)\n", + (rsp[2] << 8) + rsp[3]); + } + errno = EMBBADDATA; + return -1; + } + + return 0; +} + +static int _modbus_tcp_set_ipv4_options(int s) +{ + int rc; + int option; + + /* Set the TCP no delay flag */ + /* SOL_TCP = IPPROTO_TCP */ + option = 1; + rc = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, + (const void *)&option, sizeof(int)); + if (rc == -1) { + return -1; + } + + /* If the OS does not offer SOCK_NONBLOCK, fall back to setting FIONBIO to + * make sockets non-blocking */ + /* Do not care about the return value, this is optional */ +#if !defined(SOCK_NONBLOCK) && defined(FIONBIO) +#ifdef OS_WIN32 + { + /* Setting FIONBIO expects an unsigned long according to MSDN */ + u_long loption = 1; + ioctlsocket(s, FIONBIO, &loption); + } +#else + option = 1; + ioctl(s, FIONBIO, &option); +#endif +#endif + +#ifndef OS_WIN32 + /** + * Cygwin defines IPTOS_LOWDELAY but can't handle that flag so it's + * necessary to workaround that problem. + **/ + /* Set the IP low delay option */ + option = IPTOS_LOWDELAY; + rc = setsockopt(s, IPPROTO_IP, IP_TOS, + (const void *)&option, sizeof(int)); + if (rc == -1) { + return -1; + } +#endif + + return 0; +} + +static int _connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen, + const struct timeval *ro_tv) +{ + int rc = connect(sockfd, addr, addrlen); + +#ifdef OS_WIN32 + int wsaError = 0; + if (rc == -1) { + wsaError = WSAGetLastError(); + } + + if (wsaError == WSAEWOULDBLOCK || wsaError == WSAEINPROGRESS) { +#else + if (rc == -1 && errno == EINPROGRESS) { +#endif + fd_set wset; + int optval; + socklen_t optlen = sizeof(optval); + struct timeval tv = *ro_tv; + + /* Wait to be available in writing */ + FD_ZERO(&wset); + FD_SET(sockfd, &wset); + rc = select(sockfd + 1, NULL, &wset, NULL, &tv); + if (rc <= 0) { + /* Timeout or fail */ + return -1; + } + + /* The connection is established if SO_ERROR and optval are set to 0 */ + rc = getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&optval, &optlen); + if (rc == 0 && optval == 0) { + return 0; + } else { + errno = ECONNREFUSED; + return -1; + } + } + return rc; +} + +/* Establishes a modbus TCP connection with a Modbus server. */ +static int _modbus_tcp_connect(modbus_t *ctx) +{ + int rc; + /* Specialized version of sockaddr for Internet socket address (same size) */ + struct sockaddr_in addr; + modbus_tcp_t *ctx_tcp = ctx->backend_data; + int flags = SOCK_STREAM; + +#ifdef OS_WIN32 + if (_modbus_tcp_init_win32() == -1) { + return -1; + } +#endif + +#ifdef SOCK_CLOEXEC + flags |= SOCK_CLOEXEC; +#endif + +#ifdef SOCK_NONBLOCK + flags |= SOCK_NONBLOCK; +#endif + + ctx->s = socket(PF_INET, flags, 0); + if (ctx->s == -1) { + return -1; + } + + rc = _modbus_tcp_set_ipv4_options(ctx->s); + if (rc == -1) { + close(ctx->s); + ctx->s = -1; + return -1; + } + + if (ctx->debug) { + printf("Connecting to %s:%d\n", ctx_tcp->ip, ctx_tcp->port); + } + + addr.sin_family = AF_INET; + addr.sin_port = htons(ctx_tcp->port); + addr.sin_addr.s_addr = inet_addr(ctx_tcp->ip); + rc = _connect(ctx->s, (struct sockaddr *)&addr, sizeof(addr), &ctx->response_timeout); + if (rc == -1) { + close(ctx->s); + ctx->s = -1; + return -1; + } + + return 0; +} + +/* Establishes a modbus TCP PI connection with a Modbus server. */ +static int _modbus_tcp_pi_connect(modbus_t *ctx) +{ + int rc; + struct addrinfo *ai_list; + struct addrinfo *ai_ptr; + struct addrinfo ai_hints; + modbus_tcp_pi_t *ctx_tcp_pi = ctx->backend_data; + +#ifdef OS_WIN32 + if (_modbus_tcp_init_win32() == -1) { + return -1; + } +#endif + + memset(&ai_hints, 0, sizeof(ai_hints)); +#ifdef AI_ADDRCONFIG + ai_hints.ai_flags |= AI_ADDRCONFIG; +#endif + ai_hints.ai_family = AF_UNSPEC; + ai_hints.ai_socktype = SOCK_STREAM; + ai_hints.ai_addr = NULL; + ai_hints.ai_canonname = NULL; + ai_hints.ai_next = NULL; + + ai_list = NULL; + rc = getaddrinfo(ctx_tcp_pi->node, ctx_tcp_pi->service, + &ai_hints, &ai_list); + if (rc != 0) { + if (ctx->debug) { + fprintf(stderr, "Error returned by getaddrinfo: %s\n", gai_strerror(rc)); + } + errno = ECONNREFUSED; + return -1; + } + + for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) { + int flags = ai_ptr->ai_socktype; + int s; + +#ifdef SOCK_CLOEXEC + flags |= SOCK_CLOEXEC; +#endif + +#ifdef SOCK_NONBLOCK + flags |= SOCK_NONBLOCK; +#endif + + s = socket(ai_ptr->ai_family, flags, ai_ptr->ai_protocol); + if (s < 0) + continue; + + if (ai_ptr->ai_family == AF_INET) + _modbus_tcp_set_ipv4_options(s); + + if (ctx->debug) { + printf("Connecting to [%s]:%s\n", ctx_tcp_pi->node, ctx_tcp_pi->service); + } + + rc = _connect(s, ai_ptr->ai_addr, ai_ptr->ai_addrlen, &ctx->response_timeout); + if (rc == -1) { + close(s); + continue; + } + + ctx->s = s; + break; + } + + freeaddrinfo(ai_list); + + if (ctx->s < 0) { + return -1; + } + + return 0; +} + +/* Closes the network connection and socket in TCP mode */ +static void _modbus_tcp_close(modbus_t *ctx) +{ + if (ctx->s != -1) { + shutdown(ctx->s, SHUT_RDWR); + close(ctx->s); + ctx->s = -1; + } +} + +static int _modbus_tcp_flush(modbus_t *ctx) +{ + int rc; + int rc_sum = 0; + + do { + /* Extract the garbage from the socket */ + char devnull[MODBUS_TCP_MAX_ADU_LENGTH]; +#ifndef OS_WIN32 + rc = recv(ctx->s, devnull, MODBUS_TCP_MAX_ADU_LENGTH, MSG_DONTWAIT); +#else + /* On Win32, it's a bit more complicated to not wait */ + fd_set rset; + struct timeval tv; + + tv.tv_sec = 0; + tv.tv_usec = 0; + FD_ZERO(&rset); + FD_SET(ctx->s, &rset); + rc = select(ctx->s+1, &rset, NULL, NULL, &tv); + if (rc == -1) { + return -1; + } + + if (rc == 1) { + /* There is data to flush */ + rc = recv(ctx->s, devnull, MODBUS_TCP_MAX_ADU_LENGTH, 0); + } +#endif + if (rc > 0) { + rc_sum += rc; + } + } while (rc == MODBUS_TCP_MAX_ADU_LENGTH); + + return rc_sum; +} + +/* Listens for any request from one or many modbus masters in TCP */ +int modbus_tcp_listen(modbus_t *ctx, int nb_connection) +{ + int new_s; + int enable; + int flags; + struct sockaddr_in addr; + modbus_tcp_t *ctx_tcp; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + ctx_tcp = ctx->backend_data; + +#ifdef OS_WIN32 + if (_modbus_tcp_init_win32() == -1) { + return -1; + } +#endif + + flags = SOCK_STREAM; + +#ifdef SOCK_CLOEXEC + flags |= SOCK_CLOEXEC; +#endif + + new_s = socket(PF_INET, flags, IPPROTO_TCP); + if (new_s == -1) { + return -1; + } + + enable = 1; + if (setsockopt(new_s, SOL_SOCKET, SO_REUSEADDR, + (char *)&enable, sizeof(enable)) == -1) { + close(new_s); + return -1; + } + + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + /* If the modbus port is < to 1024, we need the setuid root. */ + addr.sin_port = htons(ctx_tcp->port); + if (ctx_tcp->ip[0] == '0') { + /* Listen any addresses */ + addr.sin_addr.s_addr = htonl(INADDR_ANY); + } else { + /* Listen only specified IP address */ + addr.sin_addr.s_addr = inet_addr(ctx_tcp->ip); + } + if (bind(new_s, (struct sockaddr *)&addr, sizeof(addr)) == -1) { + close(new_s); + return -1; + } + + if (listen(new_s, nb_connection) == -1) { + close(new_s); + return -1; + } + + return new_s; +} + +int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection) +{ + int rc; + struct addrinfo *ai_list; + struct addrinfo *ai_ptr; + struct addrinfo ai_hints; + const char *node; + const char *service; + int new_s; + modbus_tcp_pi_t *ctx_tcp_pi; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + ctx_tcp_pi = ctx->backend_data; + +#ifdef OS_WIN32 + if (_modbus_tcp_init_win32() == -1) { + return -1; + } +#endif + + if (ctx_tcp_pi->node[0] == 0) { + node = NULL; /* == any */ + } else { + node = ctx_tcp_pi->node; + } + + if (ctx_tcp_pi->service[0] == 0) { + service = "502"; + } else { + service = ctx_tcp_pi->service; + } + + memset(&ai_hints, 0, sizeof (ai_hints)); + /* If node is not NULL, than the AI_PASSIVE flag is ignored. */ + ai_hints.ai_flags |= AI_PASSIVE; +#ifdef AI_ADDRCONFIG + ai_hints.ai_flags |= AI_ADDRCONFIG; +#endif + ai_hints.ai_family = AF_UNSPEC; + ai_hints.ai_socktype = SOCK_STREAM; + ai_hints.ai_addr = NULL; + ai_hints.ai_canonname = NULL; + ai_hints.ai_next = NULL; + + ai_list = NULL; + rc = getaddrinfo(node, service, &ai_hints, &ai_list); + if (rc != 0) { + if (ctx->debug) { + fprintf(stderr, "Error returned by getaddrinfo: %s\n", gai_strerror(rc)); + } + errno = ECONNREFUSED; + return -1; + } + + new_s = -1; + for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) { + int flags = ai_ptr->ai_socktype; + int s; + +#ifdef SOCK_CLOEXEC + flags |= SOCK_CLOEXEC; +#endif + + s = socket(ai_ptr->ai_family, flags, ai_ptr->ai_protocol); + if (s < 0) { + if (ctx->debug) { + perror("socket"); + } + continue; + } else { + int enable = 1; + rc = setsockopt(s, SOL_SOCKET, SO_REUSEADDR, + (void *)&enable, sizeof (enable)); + if (rc != 0) { + close(s); + if (ctx->debug) { + perror("setsockopt"); + } + continue; + } + } + + rc = bind(s, ai_ptr->ai_addr, ai_ptr->ai_addrlen); + if (rc != 0) { + close(s); + if (ctx->debug) { + perror("bind"); + } + continue; + } + + rc = listen(s, nb_connection); + if (rc != 0) { + close(s); + if (ctx->debug) { + perror("listen"); + } + continue; + } + + new_s = s; + break; + } + freeaddrinfo(ai_list); + + if (new_s < 0) { + return -1; + } + + return new_s; +} + +int modbus_tcp_accept(modbus_t *ctx, int *s) +{ + struct sockaddr_in addr; + socklen_t addrlen; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + addrlen = sizeof(addr); +#ifdef HAVE_ACCEPT4 + /* Inherit socket flags and use accept4 call */ + ctx->s = accept4(*s, (struct sockaddr *)&addr, &addrlen, SOCK_CLOEXEC); +#else + ctx->s = accept(*s, (struct sockaddr *)&addr, &addrlen); +#endif + + if (ctx->s == -1) { + return -1; + } + + if (ctx->debug) { + printf("The client connection from %s is accepted\n", + inet_ntoa(addr.sin_addr)); + } + + return ctx->s; +} + +int modbus_tcp_pi_accept(modbus_t *ctx, int *s) +{ + struct sockaddr_storage addr; + socklen_t addrlen; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + addrlen = sizeof(addr); +#ifdef HAVE_ACCEPT4 + /* Inherit socket flags and use accept4 call */ + ctx->s = accept4(*s, (struct sockaddr *)&addr, &addrlen, SOCK_CLOEXEC); +#else + ctx->s = accept(*s, (struct sockaddr *)&addr, &addrlen); +#endif + + if (ctx->s == -1) { + return -1; + } + + if (ctx->debug) { + printf("The client connection is accepted.\n"); + } + + return ctx->s; +} + +static int _modbus_tcp_select(modbus_t *ctx, fd_set *rset, struct timeval *tv, int length_to_read) +{ + int s_rc; + while ((s_rc = select(ctx->s+1, rset, NULL, NULL, tv)) == -1) { + if (errno == EINTR) { + if (ctx->debug) { + fprintf(stderr, "A non blocked signal was caught\n"); + } + /* Necessary after an error */ + FD_ZERO(rset); + FD_SET(ctx->s, rset); + } else { + return -1; + } + } + + if (s_rc == 0) { + errno = ETIMEDOUT; + return -1; + } + + return s_rc; +} + +static void _modbus_tcp_free(modbus_t *ctx) { + free(ctx->backend_data); + free(ctx); +} + +const modbus_backend_t _modbus_tcp_backend = { + _MODBUS_BACKEND_TYPE_TCP, + _MODBUS_TCP_HEADER_LENGTH, + _MODBUS_TCP_CHECKSUM_LENGTH, + MODBUS_TCP_MAX_ADU_LENGTH, + _modbus_set_slave, + _modbus_tcp_build_request_basis, + _modbus_tcp_build_response_basis, + _modbus_tcp_prepare_response_tid, + _modbus_tcp_send_msg_pre, + _modbus_tcp_send, + _modbus_tcp_receive, + _modbus_tcp_recv, + _modbus_tcp_check_integrity, + _modbus_tcp_pre_check_confirmation, + _modbus_tcp_connect, + _modbus_tcp_close, + _modbus_tcp_flush, + _modbus_tcp_select, + _modbus_tcp_free +}; + + +const modbus_backend_t _modbus_tcp_pi_backend = { + _MODBUS_BACKEND_TYPE_TCP, + _MODBUS_TCP_HEADER_LENGTH, + _MODBUS_TCP_CHECKSUM_LENGTH, + MODBUS_TCP_MAX_ADU_LENGTH, + _modbus_set_slave, + _modbus_tcp_build_request_basis, + _modbus_tcp_build_response_basis, + _modbus_tcp_prepare_response_tid, + _modbus_tcp_send_msg_pre, + _modbus_tcp_send, + _modbus_tcp_receive, + _modbus_tcp_recv, + _modbus_tcp_check_integrity, + _modbus_tcp_pre_check_confirmation, + _modbus_tcp_pi_connect, + _modbus_tcp_close, + _modbus_tcp_flush, + _modbus_tcp_select, + _modbus_tcp_free +}; + +modbus_t* modbus_new_tcp(const char *ip, int port) +{ + modbus_t *ctx; + modbus_tcp_t *ctx_tcp; + size_t dest_size; + size_t ret_size; + +#if defined(OS_BSD) + /* MSG_NOSIGNAL is unsupported on *BSD so we install an ignore + handler for SIGPIPE. */ + struct sigaction sa; + + sa.sa_handler = SIG_IGN; + if (sigaction(SIGPIPE, &sa, NULL) < 0) { + /* The debug flag can't be set here... */ + fprintf(stderr, "Could not install SIGPIPE handler.\n"); + return NULL; + } +#endif + + ctx = (modbus_t *)malloc(sizeof(modbus_t)); + if (ctx == NULL) { + return NULL; + } + _modbus_init_common(ctx); + + /* Could be changed after to reach a remote serial Modbus device */ + ctx->slave = MODBUS_TCP_SLAVE; + + ctx->backend = &_modbus_tcp_backend; + + ctx->backend_data = (modbus_tcp_t *)malloc(sizeof(modbus_tcp_t)); + if (ctx->backend_data == NULL) { + modbus_free(ctx); + errno = ENOMEM; + return NULL; + } + ctx_tcp = (modbus_tcp_t *)ctx->backend_data; + + if (ip != NULL) { + dest_size = sizeof(char) * 16; + ret_size = strlcpy(ctx_tcp->ip, ip, dest_size); + if (ret_size == 0) { + fprintf(stderr, "The IP string is empty\n"); + modbus_free(ctx); + errno = EINVAL; + return NULL; + } + + if (ret_size >= dest_size) { + fprintf(stderr, "The IP string has been truncated\n"); + modbus_free(ctx); + errno = EINVAL; + return NULL; + } + } else { + ctx_tcp->ip[0] = '0'; + } + ctx_tcp->port = port; + ctx_tcp->t_id = 0; + + return ctx; +} + + +modbus_t* modbus_new_tcp_pi(const char *node, const char *service) +{ + modbus_t *ctx; + modbus_tcp_pi_t *ctx_tcp_pi; + size_t dest_size; + size_t ret_size; + + ctx = (modbus_t *)malloc(sizeof(modbus_t)); + if (ctx == NULL) { + return NULL; + } + _modbus_init_common(ctx); + + /* Could be changed after to reach a remote serial Modbus device */ + ctx->slave = MODBUS_TCP_SLAVE; + + ctx->backend = &_modbus_tcp_pi_backend; + + ctx->backend_data = (modbus_tcp_pi_t *)malloc(sizeof(modbus_tcp_pi_t)); + if (ctx->backend_data == NULL) { + modbus_free(ctx); + errno = ENOMEM; + return NULL; + } + ctx_tcp_pi = (modbus_tcp_pi_t *)ctx->backend_data; + + if (node == NULL) { + /* The node argument can be empty to indicate any hosts */ + ctx_tcp_pi->node[0] = 0; + } else { + dest_size = sizeof(char) * _MODBUS_TCP_PI_NODE_LENGTH; + ret_size = strlcpy(ctx_tcp_pi->node, node, dest_size); + if (ret_size == 0) { + fprintf(stderr, "The node string is empty\n"); + modbus_free(ctx); + errno = EINVAL; + return NULL; + } + + if (ret_size >= dest_size) { + fprintf(stderr, "The node string has been truncated\n"); + modbus_free(ctx); + errno = EINVAL; + return NULL; + } + } + + if (service != NULL) { + dest_size = sizeof(char) * _MODBUS_TCP_PI_SERVICE_LENGTH; + ret_size = strlcpy(ctx_tcp_pi->service, service, dest_size); + } else { + /* Empty service is not allowed, error caught below. */ + ret_size = 0; + } + + if (ret_size == 0) { + fprintf(stderr, "The service string is empty\n"); + modbus_free(ctx); + errno = EINVAL; + return NULL; + } + + if (ret_size >= dest_size) { + fprintf(stderr, "The service string has been truncated\n"); + modbus_free(ctx); + errno = EINVAL; + return NULL; + } + + ctx_tcp_pi->t_id = 0; + + return ctx; +} diff --git a/libmodbus/modbus-tcp.h b/libmodbus/modbus-tcp.h new file mode 100644 index 0000000..d67c239 --- /dev/null +++ b/libmodbus/modbus-tcp.h @@ -0,0 +1,52 @@ +/* + * Copyright © 2001-2010 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#ifndef MODBUS_TCP_H +#define MODBUS_TCP_H + +#include "modbus.h" + +MODBUS_BEGIN_DECLS + +#if defined(_WIN32) && !defined(__CYGWIN__) +/* Win32 with MinGW, supplement to */ +#include +#if !defined(ECONNRESET) +#define ECONNRESET WSAECONNRESET +#endif +#if !defined(ECONNREFUSED) +#define ECONNREFUSED WSAECONNREFUSED +#endif +#if !defined(ETIMEDOUT) +#define ETIMEDOUT WSAETIMEDOUT +#endif +#if !defined(ENOPROTOOPT) +#define ENOPROTOOPT WSAENOPROTOOPT +#endif +#if !defined(EINPROGRESS) +#define EINPROGRESS WSAEINPROGRESS +#endif +#endif + +#define MODBUS_TCP_DEFAULT_PORT 502 +#define MODBUS_TCP_SLAVE 0xFF + +/* Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5 + * TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes + */ +#define MODBUS_TCP_MAX_ADU_LENGTH 260 + +MODBUS_API modbus_t* modbus_new_tcp(const char *ip_address, int port); +MODBUS_API int modbus_tcp_listen(modbus_t *ctx, int nb_connection); +MODBUS_API int modbus_tcp_accept(modbus_t *ctx, int *s); + +MODBUS_API modbus_t* modbus_new_tcp_pi(const char *node, const char *service); +MODBUS_API int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection); +MODBUS_API int modbus_tcp_pi_accept(modbus_t *ctx, int *s); + +MODBUS_END_DECLS + +#endif /* MODBUS_TCP_H */ diff --git a/libmodbus/modbus-version.h b/libmodbus/modbus-version.h new file mode 100644 index 0000000..ac09419 --- /dev/null +++ b/libmodbus/modbus-version.h @@ -0,0 +1,53 @@ +/* + * Copyright © 2010-2014 Stéphane Raimbault + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef MODBUS_VERSION_H +#define MODBUS_VERSION_H + +/* The major version, (1, if %LIBMODBUS_VERSION is 1.2.3) */ +#define LIBMODBUS_VERSION_MAJOR (3) + +/* The minor version (2, if %LIBMODBUS_VERSION is 1.2.3) */ +#define LIBMODBUS_VERSION_MINOR (1) + +/* The micro version (3, if %LIBMODBUS_VERSION is 1.2.3) */ +#define LIBMODBUS_VERSION_MICRO (7) + +/* The full version, like 1.2.3 */ +#define LIBMODBUS_VERSION 3.1.7 + +/* The full version, in string form (suited for string concatenation) + */ +#define LIBMODBUS_VERSION_STRING "3.1.7" + +/* Numerically encoded version, eg. v1.2.3 is 0x010203 */ +#define LIBMODBUS_VERSION_HEX ((LIBMODBUS_VERSION_MAJOR << 16) | \ + (LIBMODBUS_VERSION_MINOR << 8) | \ + (LIBMODBUS_VERSION_MICRO << 0)) + +/* Evaluates to True if the version is greater than @major, @minor and @micro + */ +#define LIBMODBUS_VERSION_CHECK(major,minor,micro) \ + (LIBMODBUS_VERSION_MAJOR > (major) || \ + (LIBMODBUS_VERSION_MAJOR == (major) && \ + LIBMODBUS_VERSION_MINOR > (minor)) || \ + (LIBMODBUS_VERSION_MAJOR == (major) && \ + LIBMODBUS_VERSION_MINOR == (minor) && \ + LIBMODBUS_VERSION_MICRO >= (micro))) + +#endif /* MODBUS_VERSION_H */ diff --git a/libmodbus/modbus.c b/libmodbus/modbus.c new file mode 100644 index 0000000..5e225c4 --- /dev/null +++ b/libmodbus/modbus.c @@ -0,0 +1,1910 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + * + * This library implements the Modbus protocol. + * http://libmodbus.org/ + */ + +#include +#include +#include +#include +#include +#include +#include +#ifndef _MSC_VER +#include +#endif + +#include "config.h" + +#include "modbus.h" +#include "modbus-private.h" + +/* Internal use */ +#define MSG_LENGTH_UNDEFINED -1 + +/* Exported version */ +const unsigned int libmodbus_version_major = LIBMODBUS_VERSION_MAJOR; +const unsigned int libmodbus_version_minor = LIBMODBUS_VERSION_MINOR; +const unsigned int libmodbus_version_micro = LIBMODBUS_VERSION_MICRO; + +/* Max between RTU and TCP max adu length (so TCP) */ + +/* 3 steps are used to parse the query */ +typedef enum { + _STEP_FUNCTION, + _STEP_META, + _STEP_DATA +} _step_t; + +const char *modbus_strerror(int errnum) { + switch (errnum) { + case EMBXILFUN: + return "Illegal function"; + case EMBXILADD: + return "Illegal data address"; + case EMBXILVAL: + return "Illegal data value"; + case EMBXSFAIL: + return "Slave device or server failure"; + case EMBXACK: + return "Acknowledge"; + case EMBXSBUSY: + return "Slave device or server is busy"; + case EMBXNACK: + return "Negative acknowledge"; + case EMBXMEMPAR: + return "Memory parity error"; + case EMBXGPATH: + return "Gateway path unavailable"; + case EMBXGTAR: + return "Target device failed to respond"; + case EMBBADCRC: + return "Invalid CRC"; + case EMBBADDATA: + return "Invalid data"; + case EMBBADEXC: + return "Invalid exception code"; + case EMBMDATA: + return "Too many data"; + case EMBBADSLAVE: + return "Response not from requested slave"; + default: + return strerror(errnum); + } +} + +void _error_print(modbus_t *ctx, const char *context) +{ + if (ctx->debug) { + fprintf(stderr, "ERROR %s", modbus_strerror(errno)); + if (context != NULL) { + fprintf(stderr, ": %s\n", context); + } else { + fprintf(stderr, "\n"); + } + } +} + +static void _sleep_response_timeout(modbus_t *ctx) +{ + /* Response timeout is always positive */ +#ifdef _WIN32 + /* usleep doesn't exist on Windows */ + Sleep((ctx->response_timeout.tv_sec * 1000) + + (ctx->response_timeout.tv_usec / 1000)); +#else + /* usleep source code */ + struct timespec request, remaining; + request.tv_sec = ctx->response_timeout.tv_sec; + request.tv_nsec = ((long int)ctx->response_timeout.tv_usec) * 1000; + while (nanosleep(&request, &remaining) == -1 && errno == EINTR) { + request = remaining; + } +#endif +} + +int modbus_flush(modbus_t *ctx) +{ + int rc; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + rc = ctx->backend->flush(ctx); + if (rc != -1 && ctx->debug) { + /* Not all backends are able to return the number of bytes flushed */ + printf("Bytes flushed (%d)\n", rc); + } + return rc; +} + +/* Computes the length of the expected response */ +static unsigned int compute_response_length_from_request(modbus_t *ctx, uint8_t *req) +{ + int length; + const int offset = ctx->backend->header_length; + + switch (req[offset]) { + case MODBUS_FC_READ_COILS: + case MODBUS_FC_READ_DISCRETE_INPUTS: { + /* Header + nb values (code from write_bits) */ + int nb = (req[offset + 3] << 8) | req[offset + 4]; + length = 2 + (nb / 8) + ((nb % 8) ? 1 : 0); + } + break; + case MODBUS_FC_WRITE_AND_READ_REGISTERS: + case MODBUS_FC_READ_HOLDING_REGISTERS: + case MODBUS_FC_READ_INPUT_REGISTERS: + /* Header + 2 * nb values */ + length = 2 + 2 * (req[offset + 3] << 8 | req[offset + 4]); + break; + case MODBUS_FC_READ_EXCEPTION_STATUS: + length = 3; + break; + case MODBUS_FC_REPORT_SLAVE_ID: + /* The response is device specific (the header provides the + length) */ + return MSG_LENGTH_UNDEFINED; + case MODBUS_FC_MASK_WRITE_REGISTER: + length = 7; + break; + default: + length = 5; + } + + return offset + length + ctx->backend->checksum_length; +} + +/* Sends a request/response */ +static int send_msg(modbus_t *ctx, uint8_t *msg, int msg_length) +{ + int rc; + int i; + + msg_length = ctx->backend->send_msg_pre(msg, msg_length); + + if (ctx->debug) { + for (i = 0; i < msg_length; i++) + printf("[%.2X]", msg[i]); + printf("\n"); + } + + /* In recovery mode, the write command will be issued until to be + successful! Disabled by default. */ + do { + rc = ctx->backend->send(ctx, msg, msg_length); + if (rc == -1) { + _error_print(ctx, NULL); + if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) { + int saved_errno = errno; + + if ((errno == EBADF || errno == ECONNRESET || errno == EPIPE)) { + modbus_close(ctx); + _sleep_response_timeout(ctx); + modbus_connect(ctx); + } else { + _sleep_response_timeout(ctx); + modbus_flush(ctx); + } + errno = saved_errno; + } + } + } while ((ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) && + rc == -1); + + if (rc > 0 && rc != msg_length) { + errno = EMBBADDATA; + return -1; + } + + return rc; +} + +int modbus_send_raw_request(modbus_t *ctx, const uint8_t *raw_req, int raw_req_length) +{ + sft_t sft; + uint8_t req[MAX_MESSAGE_LENGTH]; + int req_length; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (raw_req_length < 2 || raw_req_length > (MODBUS_MAX_PDU_LENGTH + 1)) { + /* The raw request must contain function and slave at least and + must not be longer than the maximum pdu length plus the slave + address. */ + errno = EINVAL; + return -1; + } + + sft.slave = raw_req[0]; + sft.function = raw_req[1]; + /* The t_id is left to zero */ + sft.t_id = 0; + /* This response function only set the header so it's convenient here */ + req_length = ctx->backend->build_response_basis(&sft, req); + + if (raw_req_length > 2) { + /* Copy data after function code */ + memcpy(req + req_length, raw_req + 2, raw_req_length - 2); + req_length += raw_req_length - 2; + } + + return send_msg(ctx, req, req_length); +} + +/* + * ---------- Request Indication ---------- + * | Client | ---------------------->| Server | + * ---------- Confirmation Response ---------- + */ + +/* Computes the length to read after the function received */ +static uint8_t compute_meta_length_after_function(int function, + msg_type_t msg_type) +{ + int length; + + if (msg_type == MSG_INDICATION) { + if (function <= MODBUS_FC_WRITE_SINGLE_REGISTER) { + length = 4; + } else if (function == MODBUS_FC_WRITE_MULTIPLE_COILS || + function == MODBUS_FC_WRITE_MULTIPLE_REGISTERS) { + length = 5; + } else if (function == MODBUS_FC_MASK_WRITE_REGISTER) { + length = 6; + } else if (function == MODBUS_FC_WRITE_AND_READ_REGISTERS) { + length = 9; + } else { + /* MODBUS_FC_READ_EXCEPTION_STATUS, MODBUS_FC_REPORT_SLAVE_ID */ + length = 0; + } + } else { + /* MSG_CONFIRMATION */ + switch (function) { + case MODBUS_FC_WRITE_SINGLE_COIL: + case MODBUS_FC_WRITE_SINGLE_REGISTER: + case MODBUS_FC_WRITE_MULTIPLE_COILS: + case MODBUS_FC_WRITE_MULTIPLE_REGISTERS: + length = 4; + break; + case MODBUS_FC_MASK_WRITE_REGISTER: + length = 6; + break; + default: + length = 1; + } + } + + return length; +} + +/* Computes the length to read after the meta information (address, count, etc) */ +static int compute_data_length_after_meta(modbus_t *ctx, uint8_t *msg, + msg_type_t msg_type) +{ + int function = msg[ctx->backend->header_length]; + int length; + + if (msg_type == MSG_INDICATION) { + switch (function) { + case MODBUS_FC_WRITE_MULTIPLE_COILS: + case MODBUS_FC_WRITE_MULTIPLE_REGISTERS: + length = msg[ctx->backend->header_length + 5]; + break; + case MODBUS_FC_WRITE_AND_READ_REGISTERS: + length = msg[ctx->backend->header_length + 9]; + break; + default: + length = 0; + } + } else { + /* MSG_CONFIRMATION */ + if (function <= MODBUS_FC_READ_INPUT_REGISTERS || + function == MODBUS_FC_REPORT_SLAVE_ID || + function == MODBUS_FC_WRITE_AND_READ_REGISTERS) { + length = msg[ctx->backend->header_length + 1]; + } else { + length = 0; + } + } + + length += ctx->backend->checksum_length; + + return length; +} + + +/* Waits a response from a modbus server or a request from a modbus client. + This function blocks if there is no replies (3 timeouts). + + The function shall return the number of received characters and the received + message in an array of uint8_t if successful. Otherwise it shall return -1 + and errno is set to one of the values defined below: + - ECONNRESET + - EMBBADDATA + - ETIMEDOUT + - read() or recv() error codes +*/ + +int _modbus_receive_msg(modbus_t *ctx, uint8_t *msg, msg_type_t msg_type) +{ + int rc; + fd_set rset; + struct timeval tv; + struct timeval *p_tv; + int length_to_read; + int msg_length = 0; + _step_t step; + + if (ctx->debug) { + if (msg_type == MSG_INDICATION) { + printf("Waiting for an indication...\n"); + } else { + printf("Waiting for a confirmation...\n"); + } + } + + /* Add a file descriptor to the set */ + FD_ZERO(&rset); + FD_SET(ctx->s, &rset); + + /* We need to analyse the message step by step. At the first step, we want + * to reach the function code because all packets contain this + * information. */ + step = _STEP_FUNCTION; + length_to_read = ctx->backend->header_length + 1; + + if (msg_type == MSG_INDICATION) { + /* Wait for a message, we don't know when the message will be + * received */ + if (ctx->indication_timeout.tv_sec == 0 && ctx->indication_timeout.tv_usec == 0) { + /* By default, the indication timeout isn't set */ + p_tv = NULL; + } else { + /* Wait for an indication (name of a received request by a server, see schema) */ + tv.tv_sec = ctx->indication_timeout.tv_sec; + tv.tv_usec = ctx->indication_timeout.tv_usec; + p_tv = &tv; + } + } else { + tv.tv_sec = ctx->response_timeout.tv_sec; + tv.tv_usec = ctx->response_timeout.tv_usec; + p_tv = &tv; + } + + while (length_to_read != 0) { + rc = ctx->backend->select(ctx, &rset, p_tv, length_to_read); + if (rc == -1) { + _error_print(ctx, "select"); + if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) { + int saved_errno = errno; + + if (errno == ETIMEDOUT) { + _sleep_response_timeout(ctx); + modbus_flush(ctx); + } else if (errno == EBADF) { + modbus_close(ctx); + modbus_connect(ctx); + } + errno = saved_errno; + } + return -1; + } + + rc = ctx->backend->recv(ctx, msg + msg_length, length_to_read); + if (rc == 0) { + errno = ECONNRESET; + rc = -1; + } + + if (rc == -1) { + _error_print(ctx, "read"); + if ((ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) && + (errno == ECONNRESET || errno == ECONNREFUSED || + errno == EBADF)) { + int saved_errno = errno; + modbus_close(ctx); + modbus_connect(ctx); + /* Could be removed by previous calls */ + errno = saved_errno; + } + return -1; + } + + /* Display the hex code of each character received */ + if (ctx->debug) { + int i; + for (i=0; i < rc; i++) + printf("<%.2X>", msg[msg_length + i]); + } + + /* Sums bytes received */ + msg_length += rc; + /* Computes remaining bytes */ + length_to_read -= rc; + + if (length_to_read == 0) { + switch (step) { + case _STEP_FUNCTION: + /* Function code position */ + length_to_read = compute_meta_length_after_function( + msg[ctx->backend->header_length], + msg_type); + if (length_to_read != 0) { + step = _STEP_META; + break; + } /* else switches straight to the next step */ + case _STEP_META: + length_to_read = compute_data_length_after_meta( + ctx, msg, msg_type); + if ((msg_length + length_to_read) > (int)ctx->backend->max_adu_length) { + errno = EMBBADDATA; + _error_print(ctx, "too many data"); + return -1; + } + step = _STEP_DATA; + break; + default: + break; + } + } + + if (length_to_read > 0 && + (ctx->byte_timeout.tv_sec > 0 || ctx->byte_timeout.tv_usec > 0)) { + /* If there is no character in the buffer, the allowed timeout + interval between two consecutive bytes is defined by + byte_timeout */ + tv.tv_sec = ctx->byte_timeout.tv_sec; + tv.tv_usec = ctx->byte_timeout.tv_usec; + p_tv = &tv; + } + /* else timeout isn't set again, the full response must be read before + expiration of response timeout (for CONFIRMATION only) */ + } + + if (ctx->debug) + printf("\n"); + + return ctx->backend->check_integrity(ctx, msg, msg_length); +} + +/* Receive the request from a modbus master */ +int modbus_receive(modbus_t *ctx, uint8_t *req) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return ctx->backend->receive(ctx, req); +} + +/* Receives the confirmation. + + The function shall store the read response in rsp and return the number of + values (bits or words). Otherwise, its shall return -1 and errno is set. + + The function doesn't check the confirmation is the expected response to the + initial request. +*/ +int modbus_receive_confirmation(modbus_t *ctx, uint8_t *rsp) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); +} + +static int check_confirmation(modbus_t *ctx, uint8_t *req, + uint8_t *rsp, int rsp_length) +{ + int rc; + int rsp_length_computed; + const int offset = ctx->backend->header_length; + const int function = rsp[offset]; + + if (ctx->backend->pre_check_confirmation) { + rc = ctx->backend->pre_check_confirmation(ctx, req, rsp, rsp_length); + if (rc == -1) { + if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) { + _sleep_response_timeout(ctx); + modbus_flush(ctx); + } + return -1; + } + } + + rsp_length_computed = compute_response_length_from_request(ctx, req); + + /* Exception code */ + if (function >= 0x80) { + if (rsp_length == (offset + 2 + (int)ctx->backend->checksum_length) && + req[offset] == (rsp[offset] - 0x80)) { + /* Valid exception code received */ + + int exception_code = rsp[offset + 1]; + if (exception_code < MODBUS_EXCEPTION_MAX) { + errno = MODBUS_ENOBASE + exception_code; + } else { + errno = EMBBADEXC; + } + _error_print(ctx, NULL); + return -1; + } else { + errno = EMBBADEXC; + _error_print(ctx, NULL); + return -1; + } + } + + /* Check length */ + if ((rsp_length == rsp_length_computed || + rsp_length_computed == MSG_LENGTH_UNDEFINED) && + function < 0x80) { + int req_nb_value; + int rsp_nb_value; + + /* Check function code */ + if (function != req[offset]) { + if (ctx->debug) { + fprintf(stderr, + "Received function not corresponding to the request (0x%X != 0x%X)\n", + function, req[offset]); + } + if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) { + _sleep_response_timeout(ctx); + modbus_flush(ctx); + } + errno = EMBBADDATA; + return -1; + } + + /* Check the number of values is corresponding to the request */ + switch (function) { + case MODBUS_FC_READ_COILS: + case MODBUS_FC_READ_DISCRETE_INPUTS: + /* Read functions, 8 values in a byte (nb + * of values in the request and byte count in + * the response. */ + req_nb_value = (req[offset + 3] << 8) + req[offset + 4]; + req_nb_value = (req_nb_value / 8) + ((req_nb_value % 8) ? 1 : 0); + rsp_nb_value = rsp[offset + 1]; + break; + case MODBUS_FC_WRITE_AND_READ_REGISTERS: + case MODBUS_FC_READ_HOLDING_REGISTERS: + case MODBUS_FC_READ_INPUT_REGISTERS: + /* Read functions 1 value = 2 bytes */ + req_nb_value = (req[offset + 3] << 8) + req[offset + 4]; + rsp_nb_value = (rsp[offset + 1] / 2); + break; + case MODBUS_FC_WRITE_MULTIPLE_COILS: + case MODBUS_FC_WRITE_MULTIPLE_REGISTERS: + /* N Write functions */ + req_nb_value = (req[offset + 3] << 8) + req[offset + 4]; + rsp_nb_value = (rsp[offset + 3] << 8) | rsp[offset + 4]; + break; + case MODBUS_FC_REPORT_SLAVE_ID: + /* Report slave ID (bytes received) */ + req_nb_value = rsp_nb_value = rsp[offset + 1]; + break; + default: + /* 1 Write functions & others */ + req_nb_value = rsp_nb_value = 1; + } + + if (req_nb_value == rsp_nb_value) { + rc = rsp_nb_value; + } else { + if (ctx->debug) { + fprintf(stderr, + "Quantity not corresponding to the request (%d != %d)\n", + rsp_nb_value, req_nb_value); + } + + if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) { + _sleep_response_timeout(ctx); + modbus_flush(ctx); + } + + errno = EMBBADDATA; + rc = -1; + } + } else { + if (ctx->debug) { + fprintf(stderr, + "Message length not corresponding to the computed length (%d != %d)\n", + rsp_length, rsp_length_computed); + } + if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) { + _sleep_response_timeout(ctx); + modbus_flush(ctx); + } + errno = EMBBADDATA; + rc = -1; + } + + return rc; +} + +static int response_io_status(uint8_t *tab_io_status, + int address, int nb, + uint8_t *rsp, int offset) +{ + int shift = 0; + /* Instead of byte (not allowed in Win32) */ + int one_byte = 0; + int i; + + for (i = address; i < address + nb; i++) { + one_byte |= tab_io_status[i] << shift; + if (shift == 7) { + /* Byte is full */ + rsp[offset++] = one_byte; + one_byte = shift = 0; + } else { + shift++; + } + } + + if (shift != 0) + rsp[offset++] = one_byte; + + return offset; +} + +/* Build the exception response */ +static int response_exception(modbus_t *ctx, sft_t *sft, + int exception_code, uint8_t *rsp, + unsigned int to_flush, + const char* template, ...) +{ + int rsp_length; + + /* Print debug message */ + if (ctx->debug) { + va_list ap; + + va_start(ap, template); + vfprintf(stderr, template, ap); + va_end(ap); + } + + /* Flush if required */ + if (to_flush) { + _sleep_response_timeout(ctx); + modbus_flush(ctx); + } + + /* Build exception response */ + sft->function = sft->function + 0x80; + rsp_length = ctx->backend->build_response_basis(sft, rsp); + rsp[rsp_length++] = exception_code; + + return rsp_length; +} + +/* Send a response to the received request. + Analyses the request and constructs a response. + + If an error occurs, this function construct the response + accordingly. +*/ +int modbus_reply(modbus_t *ctx, const uint8_t *req, + int req_length, modbus_mapping_t *mb_mapping) +{ + int offset; + int slave; + int function; + uint16_t address; + uint8_t rsp[MAX_MESSAGE_LENGTH]; + int rsp_length = 0; + sft_t sft; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + offset = ctx->backend->header_length; + slave = req[offset - 1]; + function = req[offset]; + address = (req[offset + 1] << 8) + req[offset + 2]; + + sft.slave = slave; + sft.function = function; + sft.t_id = ctx->backend->prepare_response_tid(req, &req_length); + + /* Data are flushed on illegal number of values errors. */ + switch (function) { + case MODBUS_FC_READ_COILS: + case MODBUS_FC_READ_DISCRETE_INPUTS: { + unsigned int is_input = (function == MODBUS_FC_READ_DISCRETE_INPUTS); + int start_bits = is_input ? mb_mapping->start_input_bits : mb_mapping->start_bits; + int nb_bits = is_input ? mb_mapping->nb_input_bits : mb_mapping->nb_bits; + uint8_t *tab_bits = is_input ? mb_mapping->tab_input_bits : mb_mapping->tab_bits; + const char * const name = is_input ? "read_input_bits" : "read_bits"; + int nb = (req[offset + 3] << 8) + req[offset + 4]; + /* The mapping can be shifted to reduce memory consumption and it + doesn't always start at address zero. */ + int mapping_address = address - start_bits; + + if (nb < 1 || MODBUS_MAX_READ_BITS < nb) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE, + "Illegal nb of values %d in %s (max %d)\n", + nb, name, MODBUS_MAX_READ_BITS); + } else if (mapping_address < 0 || (mapping_address + nb) > nb_bits) { + rsp_length = response_exception( + ctx, &sft, + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data address 0x%0X in %s\n", + mapping_address < 0 ? address : address + nb, name); + } else { + rsp_length = ctx->backend->build_response_basis(&sft, rsp); + rsp[rsp_length++] = (nb / 8) + ((nb % 8) ? 1 : 0); + rsp_length = response_io_status(tab_bits, mapping_address, nb, + rsp, rsp_length); + } + } + break; + case MODBUS_FC_READ_HOLDING_REGISTERS: + case MODBUS_FC_READ_INPUT_REGISTERS: { + unsigned int is_input = (function == MODBUS_FC_READ_INPUT_REGISTERS); + int start_registers = is_input ? mb_mapping->start_input_registers : mb_mapping->start_registers; + int nb_registers = is_input ? mb_mapping->nb_input_registers : mb_mapping->nb_registers; + uint16_t *tab_registers = is_input ? mb_mapping->tab_input_registers : mb_mapping->tab_registers; + const char * const name = is_input ? "read_input_registers" : "read_registers"; + int nb = (req[offset + 3] << 8) + req[offset + 4]; + /* The mapping can be shifted to reduce memory consumption and it + doesn't always start at address zero. */ + int mapping_address = address - start_registers; + + if (nb < 1 || MODBUS_MAX_READ_REGISTERS < nb) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE, + "Illegal nb of values %d in %s (max %d)\n", + nb, name, MODBUS_MAX_READ_REGISTERS); + } else if (mapping_address < 0 || (mapping_address + nb) > nb_registers) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data address 0x%0X in %s\n", + mapping_address < 0 ? address : address + nb, name); + } else { + int i; + + rsp_length = ctx->backend->build_response_basis(&sft, rsp); + rsp[rsp_length++] = nb << 1; + for (i = mapping_address; i < mapping_address + nb; i++) { + rsp[rsp_length++] = tab_registers[i] >> 8; + rsp[rsp_length++] = tab_registers[i] & 0xFF; + } + } + } + break; + case MODBUS_FC_WRITE_SINGLE_COIL: { + int mapping_address = address - mb_mapping->start_bits; + + if (mapping_address < 0 || mapping_address >= mb_mapping->nb_bits) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data address 0x%0X in write_bit\n", + address); + } else { + int data = (req[offset + 3] << 8) + req[offset + 4]; + + if (data == 0xFF00 || data == 0x0) { + mb_mapping->tab_bits[mapping_address] = data ? ON : OFF; + memcpy(rsp, req, req_length); + rsp_length = req_length; + } else { + rsp_length = response_exception( + ctx, &sft, + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, FALSE, + "Illegal data value 0x%0X in write_bit request at address %0X\n", + data, address); + } + } + } + break; + case MODBUS_FC_WRITE_SINGLE_REGISTER: { + int mapping_address = address - mb_mapping->start_registers; + + if (mapping_address < 0 || mapping_address >= mb_mapping->nb_registers) { + rsp_length = response_exception( + ctx, &sft, + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data address 0x%0X in write_register\n", + address); + } else { + int data = (req[offset + 3] << 8) + req[offset + 4]; + + mb_mapping->tab_registers[mapping_address] = data; + memcpy(rsp, req, req_length); + rsp_length = req_length; + } + } + break; + case MODBUS_FC_WRITE_MULTIPLE_COILS: { + int nb = (req[offset + 3] << 8) + req[offset + 4]; + int nb_bits = req[offset + 5]; + int mapping_address = address - mb_mapping->start_bits; + + if (nb < 1 || MODBUS_MAX_WRITE_BITS < nb || nb_bits * 8 < nb) { + /* May be the indication has been truncated on reading because of + * invalid address (eg. nb is 0 but the request contains values to + * write) so it's necessary to flush. */ + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE, + "Illegal number of values %d in write_bits (max %d)\n", + nb, MODBUS_MAX_WRITE_BITS); + } else if (mapping_address < 0 || + (mapping_address + nb) > mb_mapping->nb_bits) { + rsp_length = response_exception( + ctx, &sft, + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data address 0x%0X in write_bits\n", + mapping_address < 0 ? address : address + nb); + } else { + /* 6 = byte count */ + modbus_set_bits_from_bytes(mb_mapping->tab_bits, mapping_address, nb, + &req[offset + 6]); + + rsp_length = ctx->backend->build_response_basis(&sft, rsp); + /* 4 to copy the bit address (2) and the quantity of bits */ + memcpy(rsp + rsp_length, req + rsp_length, 4); + rsp_length += 4; + } + } + break; + case MODBUS_FC_WRITE_MULTIPLE_REGISTERS: { + int nb = (req[offset + 3] << 8) + req[offset + 4]; + int nb_bytes = req[offset + 5]; + int mapping_address = address - mb_mapping->start_registers; + + if (nb < 1 || MODBUS_MAX_WRITE_REGISTERS < nb || nb_bytes != nb * 2) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE, + "Illegal number of values %d in write_registers (max %d)\n", + nb, MODBUS_MAX_WRITE_REGISTERS); + } else if (mapping_address < 0 || + (mapping_address + nb) > mb_mapping->nb_registers) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data address 0x%0X in write_registers\n", + mapping_address < 0 ? address : address + nb); + } else { + int i, j; + for (i = mapping_address, j = 6; i < mapping_address + nb; i++, j += 2) { + /* 6 and 7 = first value */ + mb_mapping->tab_registers[i] = + (req[offset + j] << 8) + req[offset + j + 1]; + } + + rsp_length = ctx->backend->build_response_basis(&sft, rsp); + /* 4 to copy the address (2) and the no. of registers */ + memcpy(rsp + rsp_length, req + rsp_length, 4); + rsp_length += 4; + } + } + break; + case MODBUS_FC_REPORT_SLAVE_ID: { + int str_len; + int byte_count_pos; + + rsp_length = ctx->backend->build_response_basis(&sft, rsp); + /* Skip byte count for now */ + byte_count_pos = rsp_length++; + rsp[rsp_length++] = _REPORT_SLAVE_ID; + /* Run indicator status to ON */ + rsp[rsp_length++] = 0xFF; + /* LMB + length of LIBMODBUS_VERSION_STRING */ + str_len = 3 + strlen(LIBMODBUS_VERSION_STRING); + memcpy(rsp + rsp_length, "LMB" LIBMODBUS_VERSION_STRING, str_len); + rsp_length += str_len; + rsp[byte_count_pos] = rsp_length - byte_count_pos - 1; + } + break; + case MODBUS_FC_READ_EXCEPTION_STATUS: + if (ctx->debug) { + fprintf(stderr, "FIXME Not implemented\n"); + } + errno = ENOPROTOOPT; + return -1; + break; + case MODBUS_FC_MASK_WRITE_REGISTER: { + int mapping_address = address - mb_mapping->start_registers; + + if (mapping_address < 0 || mapping_address >= mb_mapping->nb_registers) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data address 0x%0X in write_register\n", + address); + } else { + uint16_t data = mb_mapping->tab_registers[mapping_address]; + uint16_t and = (req[offset + 3] << 8) + req[offset + 4]; + uint16_t or = (req[offset + 5] << 8) + req[offset + 6]; + + data = (data & and) | (or & (~and)); + mb_mapping->tab_registers[mapping_address] = data; + memcpy(rsp, req, req_length); + rsp_length = req_length; + } + } + break; + case MODBUS_FC_WRITE_AND_READ_REGISTERS: { + int nb = (req[offset + 3] << 8) + req[offset + 4]; + uint16_t address_write = (req[offset + 5] << 8) + req[offset + 6]; + int nb_write = (req[offset + 7] << 8) + req[offset + 8]; + int nb_write_bytes = req[offset + 9]; + int mapping_address = address - mb_mapping->start_registers; + int mapping_address_write = address_write - mb_mapping->start_registers; + + if (nb_write < 1 || MODBUS_MAX_WR_WRITE_REGISTERS < nb_write || + nb < 1 || MODBUS_MAX_WR_READ_REGISTERS < nb || + nb_write_bytes != nb_write * 2) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE, + "Illegal nb of values (W%d, R%d) in write_and_read_registers (max W%d, R%d)\n", + nb_write, nb, MODBUS_MAX_WR_WRITE_REGISTERS, MODBUS_MAX_WR_READ_REGISTERS); + } else if (mapping_address < 0 || + (mapping_address + nb) > mb_mapping->nb_registers || + mapping_address_write < 0 || + (mapping_address_write + nb_write) > mb_mapping->nb_registers) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data read address 0x%0X or write address 0x%0X write_and_read_registers\n", + mapping_address < 0 ? address : address + nb, + mapping_address_write < 0 ? address_write : address_write + nb_write); + } else { + int i, j; + rsp_length = ctx->backend->build_response_basis(&sft, rsp); + rsp[rsp_length++] = nb << 1; + + /* Write first. + 10 and 11 are the offset of the first values to write */ + for (i = mapping_address_write, j = 10; + i < mapping_address_write + nb_write; i++, j += 2) { + mb_mapping->tab_registers[i] = + (req[offset + j] << 8) + req[offset + j + 1]; + } + + /* and read the data for the response */ + for (i = mapping_address; i < mapping_address + nb; i++) { + rsp[rsp_length++] = mb_mapping->tab_registers[i] >> 8; + rsp[rsp_length++] = mb_mapping->tab_registers[i] & 0xFF; + } + } + } + break; + + default: + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_FUNCTION, rsp, TRUE, + "Unknown Modbus function code: 0x%0X\n", function); + break; + } + + /* Suppress any responses when the request was a broadcast */ + return (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU && + slave == MODBUS_BROADCAST_ADDRESS) ? 0 : send_msg(ctx, rsp, rsp_length); +} + +int modbus_reply_exception(modbus_t *ctx, const uint8_t *req, + unsigned int exception_code) +{ + int offset; + int slave; + int function; + uint8_t rsp[MAX_MESSAGE_LENGTH]; + int rsp_length; + int dummy_length = 99; + sft_t sft; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + offset = ctx->backend->header_length; + slave = req[offset - 1]; + function = req[offset]; + + sft.slave = slave; + sft.function = function + 0x80; + sft.t_id = ctx->backend->prepare_response_tid(req, &dummy_length); + rsp_length = ctx->backend->build_response_basis(&sft, rsp); + + /* Positive exception code */ + if (exception_code < MODBUS_EXCEPTION_MAX) { + rsp[rsp_length++] = exception_code; + return send_msg(ctx, rsp, rsp_length); + } else { + errno = EINVAL; + return -1; + } +} + +/* Reads IO status */ +static int read_io_status(modbus_t *ctx, int function, + int addr, int nb, uint8_t *dest) +{ + int rc; + int req_length; + + uint8_t req[_MIN_REQ_LENGTH]; + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + req_length = ctx->backend->build_request_basis(ctx, function, addr, nb, req); + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + int i, temp, bit; + int pos = 0; + int offset; + int offset_end; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + if (rc == -1) + return -1; + + offset = ctx->backend->header_length + 2; + offset_end = offset + rc; + for (i = offset; i < offset_end; i++) { + /* Shift reg hi_byte to temp */ + temp = rsp[i]; + + for (bit = 0x01; (bit & 0xff) && (pos < nb);) { + dest[pos++] = (temp & bit) ? TRUE : FALSE; + bit = bit << 1; + } + + } + } + + return rc; +} + +/* Reads the boolean status of bits and sets the array elements + in the destination to TRUE or FALSE (single bits). */ +int modbus_read_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest) +{ + int rc; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (nb > MODBUS_MAX_READ_BITS) { + if (ctx->debug) { + fprintf(stderr, + "ERROR Too many bits requested (%d > %d)\n", + nb, MODBUS_MAX_READ_BITS); + } + errno = EMBMDATA; + return -1; + } + + rc = read_io_status(ctx, MODBUS_FC_READ_COILS, addr, nb, dest); + + if (rc == -1) + return -1; + else + return nb; +} + + +/* Same as modbus_read_bits but reads the remote device input table */ +int modbus_read_input_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest) +{ + int rc; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (nb > MODBUS_MAX_READ_BITS) { + if (ctx->debug) { + fprintf(stderr, + "ERROR Too many discrete inputs requested (%d > %d)\n", + nb, MODBUS_MAX_READ_BITS); + } + errno = EMBMDATA; + return -1; + } + + rc = read_io_status(ctx, MODBUS_FC_READ_DISCRETE_INPUTS, addr, nb, dest); + + if (rc == -1) + return -1; + else + return nb; +} +int req_length; +uint8_t req[_MIN_REQ_LENGTH]; +uint8_t rsp[MAX_MESSAGE_LENGTH]; +int resp_length; +/* Reads the data from a remote device and put that data into an array */ +static int read_registers(modbus_t *ctx, int function, int addr, int nb, + uint16_t *dest) +{ + int rc; + + + if (nb > MODBUS_MAX_READ_REGISTERS) { + if (ctx->debug) { + fprintf(stderr, + "ERROR Too many registers requested (%d > %d)\n", + nb, MODBUS_MAX_READ_REGISTERS); + } + errno = EMBMDATA; + return -1; + } + + req_length = ctx->backend->build_request_basis(ctx, function, addr, nb, req); + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + int offset; + int i; + memset(rsp,0,sizeof(rsp)); + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + resp_length = rc; + rc = check_confirmation(ctx, req, rsp, rc); + if (rc == -1) + return -1; + + offset = ctx->backend->header_length; + + for (i = 0; i < rc; i++) { + /* shift reg hi_byte to temp OR with lo_byte */ + dest[i] = (rsp[offset + 2 + (i << 1)] << 8) | + rsp[offset + 3 + (i << 1)]; + } + } + + return rc; +} + +/* Reads the holding registers of remote device and put the data into an + array */ +int modbus_read_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest) +{ + int status; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (nb > MODBUS_MAX_READ_REGISTERS) { + if (ctx->debug) { + fprintf(stderr, + "ERROR Too many registers requested (%d > %d)\n", + nb, MODBUS_MAX_READ_REGISTERS); + } + errno = EMBMDATA; + return -1; + } + + status = read_registers(ctx, MODBUS_FC_READ_HOLDING_REGISTERS, + addr, nb, dest); + return status; +} + +/* Reads the input registers of remote device and put the data into an array */ +int modbus_read_input_registers(modbus_t *ctx, int addr, int nb, + uint16_t *dest) +{ + int status; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (nb > MODBUS_MAX_READ_REGISTERS) { + fprintf(stderr, + "ERROR Too many input registers requested (%d > %d)\n", + nb, MODBUS_MAX_READ_REGISTERS); + errno = EMBMDATA; + return -1; + } + + status = read_registers(ctx, MODBUS_FC_READ_INPUT_REGISTERS, + addr, nb, dest); + + return status; +} + +/* Write a value to the specified register of the remote device. + Used by write_bit and write_register */ +static int write_single(modbus_t *ctx, int function, int addr, const uint16_t value) +{ + int rc; + int req_length; + uint8_t req[_MIN_REQ_LENGTH]; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + req_length = ctx->backend->build_request_basis(ctx, function, addr, (int) value, req); + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + /* Used by write_bit and write_register */ + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + } + + return rc; +} + +/* Turns ON or OFF a single bit of the remote device */ +int modbus_write_bit(modbus_t *ctx, int addr, int status) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return write_single(ctx, MODBUS_FC_WRITE_SINGLE_COIL, addr, + status ? 0xFF00 : 0); +} + +/* Writes a value in one register of the remote device */ +int modbus_write_register(modbus_t *ctx, int addr, const uint16_t value) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return write_single(ctx, MODBUS_FC_WRITE_SINGLE_REGISTER, addr, value); +} + +/* Write the bits of the array in the remote device */ +int modbus_write_bits(modbus_t *ctx, int addr, int nb, const uint8_t *src) +{ + int rc; + int i; + int byte_count; + int req_length; + int bit_check = 0; + int pos = 0; + uint8_t req[MAX_MESSAGE_LENGTH]; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (nb > MODBUS_MAX_WRITE_BITS) { + if (ctx->debug) { + fprintf(stderr, "ERROR Writing too many bits (%d > %d)\n", + nb, MODBUS_MAX_WRITE_BITS); + } + errno = EMBMDATA; + return -1; + } + + req_length = ctx->backend->build_request_basis(ctx, + MODBUS_FC_WRITE_MULTIPLE_COILS, + addr, nb, req); + byte_count = (nb / 8) + ((nb % 8) ? 1 : 0); + req[req_length++] = byte_count; + + for (i = 0; i < byte_count; i++) { + int bit; + + bit = 0x01; + req[req_length] = 0; + + while ((bit & 0xFF) && (bit_check++ < nb)) { + if (src[pos++]) + req[req_length] |= bit; + else + req[req_length] &=~ bit; + + bit = bit << 1; + } + req_length++; + } + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + } + + + return rc; +} + +/* Write the values from the array to the registers of the remote device */ +int modbus_write_registers(modbus_t *ctx, int addr, int nb, const uint16_t *src) +{ + int rc; + int i; + int req_length; + int byte_count; + uint8_t req[MAX_MESSAGE_LENGTH]; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (nb > MODBUS_MAX_WRITE_REGISTERS) { + if (ctx->debug) { + fprintf(stderr, + "ERROR Trying to write to too many registers (%d > %d)\n", + nb, MODBUS_MAX_WRITE_REGISTERS); + } + errno = EMBMDATA; + return -1; + } + + req_length = ctx->backend->build_request_basis(ctx, + MODBUS_FC_WRITE_MULTIPLE_REGISTERS, + addr, nb, req); + byte_count = nb * 2; + req[req_length++] = byte_count; + + for (i = 0; i < nb; i++) { + req[req_length++] = src[i] >> 8; + req[req_length++] = src[i] & 0x00FF; + } + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + } + + return rc; +} + +int modbus_mask_write_register(modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask) +{ + int rc; + int req_length; + /* The request length can not exceed _MIN_REQ_LENGTH - 2 and 4 bytes to + * store the masks. The ugly subtraction is there to remove the 'nb' value + * (2 bytes) which is not used. */ + uint8_t req[_MIN_REQ_LENGTH + 2]; + + req_length = ctx->backend->build_request_basis(ctx, + MODBUS_FC_MASK_WRITE_REGISTER, + addr, 0, req); + + /* HACKISH, count is not used */ + req_length -= 2; + + req[req_length++] = and_mask >> 8; + req[req_length++] = and_mask & 0x00ff; + req[req_length++] = or_mask >> 8; + req[req_length++] = or_mask & 0x00ff; + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + /* Used by write_bit and write_register */ + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + } + + return rc; +} + +/* Write multiple registers from src array to remote device and read multiple + registers from remote device to dest array. */ +int modbus_write_and_read_registers(modbus_t *ctx, + int write_addr, int write_nb, + const uint16_t *src, + int read_addr, int read_nb, + uint16_t *dest) + +{ + int rc; + int req_length; + int i; + int byte_count; + uint8_t req[MAX_MESSAGE_LENGTH]; + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (write_nb > MODBUS_MAX_WR_WRITE_REGISTERS) { + if (ctx->debug) { + fprintf(stderr, + "ERROR Too many registers to write (%d > %d)\n", + write_nb, MODBUS_MAX_WR_WRITE_REGISTERS); + } + errno = EMBMDATA; + return -1; + } + + if (read_nb > MODBUS_MAX_WR_READ_REGISTERS) { + if (ctx->debug) { + fprintf(stderr, + "ERROR Too many registers requested (%d > %d)\n", + read_nb, MODBUS_MAX_WR_READ_REGISTERS); + } + errno = EMBMDATA; + return -1; + } + req_length = ctx->backend->build_request_basis(ctx, + MODBUS_FC_WRITE_AND_READ_REGISTERS, + read_addr, read_nb, req); + + req[req_length++] = write_addr >> 8; + req[req_length++] = write_addr & 0x00ff; + req[req_length++] = write_nb >> 8; + req[req_length++] = write_nb & 0x00ff; + byte_count = write_nb * 2; + req[req_length++] = byte_count; + + for (i = 0; i < write_nb; i++) { + req[req_length++] = src[i] >> 8; + req[req_length++] = src[i] & 0x00FF; + } + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + int offset; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + if (rc == -1) + return -1; + + offset = ctx->backend->header_length; + for (i = 0; i < rc; i++) { + /* shift reg hi_byte to temp OR with lo_byte */ + dest[i] = (rsp[offset + 2 + (i << 1)] << 8) | + rsp[offset + 3 + (i << 1)]; + } + } + + return rc; +} + +/* Send a request to get the slave ID of the device (only available in serial + communication). */ +int modbus_report_slave_id(modbus_t *ctx, int max_dest, uint8_t *dest) +{ + int rc; + int req_length; + uint8_t req[_MIN_REQ_LENGTH]; + + if (ctx == NULL || max_dest <= 0) { + errno = EINVAL; + return -1; + } + + req_length = ctx->backend->build_request_basis(ctx, MODBUS_FC_REPORT_SLAVE_ID, + 0, 0, req); + + /* HACKISH, addr and count are not used */ + req_length -= 4; + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + int i; + int offset; + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + if (rc == -1) + return -1; + + offset = ctx->backend->header_length + 2; + + /* Byte count, slave id, run indicator status and + additional data. Truncate copy to max_dest. */ + for (i=0; i < rc && i < max_dest; i++) { + dest[i] = rsp[offset + i]; + } + } + + return rc; +} + +void _modbus_init_common(modbus_t *ctx) +{ + /* Slave and socket are initialized to -1 */ + ctx->slave = -1; + ctx->s = -1; + + ctx->debug = FALSE; + ctx->error_recovery = MODBUS_ERROR_RECOVERY_NONE; + + ctx->response_timeout.tv_sec = 0; + ctx->response_timeout.tv_usec = _RESPONSE_TIMEOUT; + + ctx->byte_timeout.tv_sec = 0; + ctx->byte_timeout.tv_usec = _BYTE_TIMEOUT; + + ctx->indication_timeout.tv_sec = 0; + ctx->indication_timeout.tv_usec = 0; +} + +/* Define the slave number */ +int modbus_set_slave(modbus_t *ctx, int slave) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return ctx->backend->set_slave(ctx, slave); +} + +int modbus_get_slave(modbus_t *ctx) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return ctx->slave; +} + +int modbus_set_error_recovery(modbus_t *ctx, + modbus_error_recovery_mode error_recovery) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + /* The type of modbus_error_recovery_mode is unsigned enum */ + ctx->error_recovery = (uint8_t) error_recovery; + return 0; +} + +int modbus_set_socket(modbus_t *ctx, int s) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + ctx->s = s; + return 0; +} + +int modbus_get_socket(modbus_t *ctx) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return ctx->s; +} + +/* Get the timeout interval used to wait for a response */ +int modbus_get_response_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + *to_sec = ctx->response_timeout.tv_sec; + *to_usec = ctx->response_timeout.tv_usec; + return 0; +} + +int modbus_set_response_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec) +{ + if (ctx == NULL || + (to_sec == 0 && to_usec == 0) || to_usec > 999999) { + errno = EINVAL; + return -1; + } + + ctx->response_timeout.tv_sec = to_sec; + ctx->response_timeout.tv_usec = to_usec; + return 0; +} + +/* Get the timeout interval between two consecutive bytes of a message */ +int modbus_get_byte_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + *to_sec = ctx->byte_timeout.tv_sec; + *to_usec = ctx->byte_timeout.tv_usec; + return 0; +} + +int modbus_set_byte_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec) +{ + /* Byte timeout can be disabled when both values are zero */ + if (ctx == NULL || to_usec > 999999) { + errno = EINVAL; + return -1; + } + + ctx->byte_timeout.tv_sec = to_sec; + ctx->byte_timeout.tv_usec = to_usec; + return 0; +} + +/* Get the timeout interval used by the server to wait for an indication from a client */ +int modbus_get_indication_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + *to_sec = ctx->indication_timeout.tv_sec; + *to_usec = ctx->indication_timeout.tv_usec; + return 0; +} + +int modbus_set_indication_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec) +{ + /* Indication timeout can be disabled when both values are zero */ + if (ctx == NULL || to_usec > 999999) { + errno = EINVAL; + return -1; + } + + ctx->indication_timeout.tv_sec = to_sec; + ctx->indication_timeout.tv_usec = to_usec; + return 0; +} + +int modbus_get_header_length(modbus_t *ctx) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return ctx->backend->header_length; +} + +int modbus_connect(modbus_t *ctx) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return ctx->backend->connect(ctx); +} + +void modbus_close(modbus_t *ctx) +{ + if (ctx == NULL) + return; + + ctx->backend->close(ctx); +} + +void modbus_free(modbus_t *ctx) +{ + if (ctx == NULL) + return; + + ctx->backend->free(ctx); +} + +int modbus_set_debug(modbus_t *ctx, int flag) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + ctx->debug = flag; + return 0; +} + +/* Allocates 4 arrays to store bits, input bits, registers and inputs + registers. The pointers are stored in modbus_mapping structure. + + The modbus_mapping_new_start_address() function shall return the new allocated + structure if successful. Otherwise it shall return NULL and set errno to + ENOMEM. */ +modbus_mapping_t* modbus_mapping_new_start_address( + unsigned int start_bits, unsigned int nb_bits, + unsigned int start_input_bits, unsigned int nb_input_bits, + unsigned int start_registers, unsigned int nb_registers, + unsigned int start_input_registers, unsigned int nb_input_registers) +{ + modbus_mapping_t *mb_mapping; + + mb_mapping = (modbus_mapping_t *)malloc(sizeof(modbus_mapping_t)); + if (mb_mapping == NULL) { + return NULL; + } + + /* 0X */ + mb_mapping->nb_bits = nb_bits; + mb_mapping->start_bits = start_bits; + if (nb_bits == 0) { + mb_mapping->tab_bits = NULL; + } else { + /* Negative number raises a POSIX error */ + mb_mapping->tab_bits = + (uint8_t *) malloc(nb_bits * sizeof(uint8_t)); + if (mb_mapping->tab_bits == NULL) { + free(mb_mapping); + return NULL; + } + memset(mb_mapping->tab_bits, 0, nb_bits * sizeof(uint8_t)); + } + + /* 1X */ + mb_mapping->nb_input_bits = nb_input_bits; + mb_mapping->start_input_bits = start_input_bits; + if (nb_input_bits == 0) { + mb_mapping->tab_input_bits = NULL; + } else { + mb_mapping->tab_input_bits = + (uint8_t *) malloc(nb_input_bits * sizeof(uint8_t)); + if (mb_mapping->tab_input_bits == NULL) { + free(mb_mapping->tab_bits); + free(mb_mapping); + return NULL; + } + memset(mb_mapping->tab_input_bits, 0, nb_input_bits * sizeof(uint8_t)); + } + + /* 4X */ + mb_mapping->nb_registers = nb_registers; + mb_mapping->start_registers = start_registers; + if (nb_registers == 0) { + mb_mapping->tab_registers = NULL; + } else { + mb_mapping->tab_registers = + (uint16_t *) malloc(nb_registers * sizeof(uint16_t)); + if (mb_mapping->tab_registers == NULL) { + free(mb_mapping->tab_input_bits); + free(mb_mapping->tab_bits); + free(mb_mapping); + return NULL; + } + memset(mb_mapping->tab_registers, 0, nb_registers * sizeof(uint16_t)); + } + + /* 3X */ + mb_mapping->nb_input_registers = nb_input_registers; + mb_mapping->start_input_registers = start_input_registers; + if (nb_input_registers == 0) { + mb_mapping->tab_input_registers = NULL; + } else { + mb_mapping->tab_input_registers = + (uint16_t *) malloc(nb_input_registers * sizeof(uint16_t)); + if (mb_mapping->tab_input_registers == NULL) { + free(mb_mapping->tab_registers); + free(mb_mapping->tab_input_bits); + free(mb_mapping->tab_bits); + free(mb_mapping); + return NULL; + } + memset(mb_mapping->tab_input_registers, 0, + nb_input_registers * sizeof(uint16_t)); + } + + return mb_mapping; +} + +modbus_mapping_t* modbus_mapping_new(int nb_bits, int nb_input_bits, + int nb_registers, int nb_input_registers) +{ + return modbus_mapping_new_start_address( + 0, nb_bits, 0, nb_input_bits, 0, nb_registers, 0, nb_input_registers); +} + +/* Frees the 4 arrays */ +void modbus_mapping_free(modbus_mapping_t *mb_mapping) +{ + if (mb_mapping == NULL) { + return; + } + + free(mb_mapping->tab_input_registers); + free(mb_mapping->tab_registers); + free(mb_mapping->tab_input_bits); + free(mb_mapping->tab_bits); + free(mb_mapping); +} + +#ifndef HAVE_STRLCPY +/* + * Function strlcpy was originally developed by + * Todd C. Miller to simplify writing secure code. + * See ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/strlcpy.3 + * for more information. + * + * Thank you Ulrich Drepper... not! + * + * Copy src to string dest of size dest_size. At most dest_size-1 characters + * will be copied. Always NUL terminates (unless dest_size == 0). Returns + * strlen(src); if retval >= dest_size, truncation occurred. + */ +size_t strlcpy(char *dest, const char *src, size_t dest_size) +{ + register char *d = dest; + register const char *s = src; + register size_t n = dest_size; + + /* Copy as many bytes as will fit */ + if (n != 0 && --n != 0) { + do { + if ((*d++ = *s++) == 0) + break; + } while (--n != 0); + } + + /* Not enough room in dest, add NUL and traverse rest of src */ + if (n == 0) { + if (dest_size != 0) + *d = '\0'; /* NUL-terminate dest */ + while (*s++) + ; + } + + return (s - src - 1); /* count does not include NUL */ +} +#endif diff --git a/libmodbus/modbus.h b/libmodbus/modbus.h new file mode 100644 index 0000000..babb3cf --- /dev/null +++ b/libmodbus/modbus.h @@ -0,0 +1,303 @@ +/* + * Copyright © 2001-2013 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#ifndef MODBUS_H +#define MODBUS_H + +/* Add this for macros that defined unix flavor */ +#if (defined(__unix__) || defined(unix)) && !defined(USG) +#include +#endif + +#ifndef _MSC_VER +#include +#else +#include "stdint.h" +#endif + +#include "modbus-version.h" + +#if defined(_MSC_VER) +# if defined(DLLBUILD) +/* define DLLBUILD when building the DLL */ +# define MODBUS_API __declspec(dllexport) +# else +# define MODBUS_API __declspec(dllimport) +# endif +#else +# define MODBUS_API +#endif + +#ifdef __cplusplus +# define MODBUS_BEGIN_DECLS extern "C" { +# define MODBUS_END_DECLS } +#else +# define MODBUS_BEGIN_DECLS +# define MODBUS_END_DECLS +#endif + +MODBUS_BEGIN_DECLS + +#ifndef FALSE +#define FALSE 0 +#endif + +#ifndef TRUE +#define TRUE 1 +#endif + +#ifndef OFF +#define OFF 0 +#endif + +#ifndef ON +#define ON 1 +#endif + +/* Modbus function codes */ +#define MODBUS_FC_READ_COILS 0x01 +#define MODBUS_FC_READ_DISCRETE_INPUTS 0x02 +#define MODBUS_FC_READ_HOLDING_REGISTERS 0x03 +#define MODBUS_FC_READ_INPUT_REGISTERS 0x04 +#define MODBUS_FC_WRITE_SINGLE_COIL 0x05 +#define MODBUS_FC_WRITE_SINGLE_REGISTER 0x06 +#define MODBUS_FC_READ_EXCEPTION_STATUS 0x07 +#define MODBUS_FC_WRITE_MULTIPLE_COILS 0x0F +#define MODBUS_FC_WRITE_MULTIPLE_REGISTERS 0x10 +#define MODBUS_FC_REPORT_SLAVE_ID 0x11 +#define MODBUS_FC_MASK_WRITE_REGISTER 0x16 +#define MODBUS_FC_WRITE_AND_READ_REGISTERS 0x17 + +#define MODBUS_BROADCAST_ADDRESS 0 + +#define MAX_MESSAGE_LENGTH 260 +#define _MIN_REQ_LENGTH 12 + +/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 1 page 12) + * Quantity of Coils to read (2 bytes): 1 to 2000 (0x7D0) + * (chapter 6 section 11 page 29) + * Quantity of Coils to write (2 bytes): 1 to 1968 (0x7B0) + */ +#define MODBUS_MAX_READ_BITS 2000 +#define MODBUS_MAX_WRITE_BITS 1968 + +/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 3 page 15) + * Quantity of Registers to read (2 bytes): 1 to 125 (0x7D) + * (chapter 6 section 12 page 31) + * Quantity of Registers to write (2 bytes) 1 to 123 (0x7B) + * (chapter 6 section 17 page 38) + * Quantity of Registers to write in R/W registers (2 bytes) 1 to 121 (0x79) + */ +#define MODBUS_MAX_READ_REGISTERS 125 +#define MODBUS_MAX_WRITE_REGISTERS 123 +#define MODBUS_MAX_WR_WRITE_REGISTERS 121 +#define MODBUS_MAX_WR_READ_REGISTERS 125 + +/* The size of the MODBUS PDU is limited by the size constraint inherited from + * the first MODBUS implementation on Serial Line network (max. RS485 ADU = 256 + * bytes). Therefore, MODBUS PDU for serial line communication = 256 - Server + * address (1 byte) - CRC (2 bytes) = 253 bytes. + */ +#define MODBUS_MAX_PDU_LENGTH 253 + +/* Consequently: + * - RTU MODBUS ADU = 253 bytes + Server address (1 byte) + CRC (2 bytes) = 256 + * bytes. + * - TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes. + * so the maximum of both backend in 260 bytes. This size can used to allocate + * an array of bytes to store responses and it will be compatible with the two + * backends. + */ +#define MODBUS_MAX_ADU_LENGTH 260 + +/* Random number to avoid errno conflicts */ +#define MODBUS_ENOBASE 112345678 + +/* Protocol exceptions */ +enum { + MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 0x01, + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, + MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE, + MODBUS_EXCEPTION_ACKNOWLEDGE, + MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY, + MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE, + MODBUS_EXCEPTION_MEMORY_PARITY, + MODBUS_EXCEPTION_NOT_DEFINED, + MODBUS_EXCEPTION_GATEWAY_PATH, + MODBUS_EXCEPTION_GATEWAY_TARGET, + MODBUS_EXCEPTION_MAX +}; + +#define EMBXILFUN (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_FUNCTION) +#define EMBXILADD (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS) +#define EMBXILVAL (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE) +#define EMBXSFAIL (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE) +#define EMBXACK (MODBUS_ENOBASE + MODBUS_EXCEPTION_ACKNOWLEDGE) +#define EMBXSBUSY (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY) +#define EMBXNACK (MODBUS_ENOBASE + MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE) +#define EMBXMEMPAR (MODBUS_ENOBASE + MODBUS_EXCEPTION_MEMORY_PARITY) +#define EMBXGPATH (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_PATH) +#define EMBXGTAR (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_TARGET) + +/* Native libmodbus error codes */ +#define EMBBADCRC (EMBXGTAR + 1) +#define EMBBADDATA (EMBXGTAR + 2) +#define EMBBADEXC (EMBXGTAR + 3) +#define EMBUNKEXC (EMBXGTAR + 4) +#define EMBMDATA (EMBXGTAR + 5) +#define EMBBADSLAVE (EMBXGTAR + 6) + +extern const unsigned int libmodbus_version_major; +extern const unsigned int libmodbus_version_minor; +extern const unsigned int libmodbus_version_micro; +extern uint8_t rsp[MAX_MESSAGE_LENGTH]; +extern int req_length; +extern uint8_t req[_MIN_REQ_LENGTH]; +extern int resp_length; +typedef struct _modbus modbus_t; + +typedef struct _modbus_mapping_t { + int nb_bits; + int start_bits; + int nb_input_bits; + int start_input_bits; + int nb_input_registers; + int start_input_registers; + int nb_registers; + int start_registers; + uint8_t *tab_bits; + uint8_t *tab_input_bits; + uint16_t *tab_input_registers; + uint16_t *tab_registers; +} modbus_mapping_t; + +typedef enum +{ + MODBUS_ERROR_RECOVERY_NONE = 0, + MODBUS_ERROR_RECOVERY_LINK = (1<<1), + MODBUS_ERROR_RECOVERY_PROTOCOL = (1<<2) +} modbus_error_recovery_mode; + +MODBUS_API int modbus_set_slave(modbus_t* ctx, int slave); +MODBUS_API int modbus_get_slave(modbus_t* ctx); +MODBUS_API int modbus_set_error_recovery(modbus_t *ctx, modbus_error_recovery_mode error_recovery); +MODBUS_API int modbus_set_socket(modbus_t *ctx, int s); +MODBUS_API int modbus_get_socket(modbus_t *ctx); + +MODBUS_API int modbus_get_response_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec); +MODBUS_API int modbus_set_response_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec); + +MODBUS_API int modbus_get_byte_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec); +MODBUS_API int modbus_set_byte_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec); + +MODBUS_API int modbus_get_indication_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec); +MODBUS_API int modbus_set_indication_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec); + +MODBUS_API int modbus_get_header_length(modbus_t *ctx); + +MODBUS_API int modbus_connect(modbus_t *ctx); +MODBUS_API void modbus_close(modbus_t *ctx); + +MODBUS_API void modbus_free(modbus_t *ctx); + +MODBUS_API int modbus_flush(modbus_t *ctx); +MODBUS_API int modbus_set_debug(modbus_t *ctx, int flag); + +MODBUS_API const char *modbus_strerror(int errnum); + +MODBUS_API int modbus_read_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest); +MODBUS_API int modbus_read_input_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest); +MODBUS_API int modbus_read_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest); +MODBUS_API int modbus_read_input_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest); +MODBUS_API int modbus_write_bit(modbus_t *ctx, int coil_addr, int status); +MODBUS_API int modbus_write_register(modbus_t *ctx, int reg_addr, const uint16_t value); +MODBUS_API int modbus_write_bits(modbus_t *ctx, int addr, int nb, const uint8_t *data); +MODBUS_API int modbus_write_registers(modbus_t *ctx, int addr, int nb, const uint16_t *data); +MODBUS_API int modbus_mask_write_register(modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask); +MODBUS_API int modbus_write_and_read_registers(modbus_t *ctx, int write_addr, int write_nb, + const uint16_t *src, int read_addr, int read_nb, + uint16_t *dest); +MODBUS_API int modbus_report_slave_id(modbus_t *ctx, int max_dest, uint8_t *dest); + +MODBUS_API modbus_mapping_t* modbus_mapping_new_start_address( + unsigned int start_bits, unsigned int nb_bits, + unsigned int start_input_bits, unsigned int nb_input_bits, + unsigned int start_registers, unsigned int nb_registers, + unsigned int start_input_registers, unsigned int nb_input_registers); + +MODBUS_API modbus_mapping_t* modbus_mapping_new(int nb_bits, int nb_input_bits, + int nb_registers, int nb_input_registers); +MODBUS_API void modbus_mapping_free(modbus_mapping_t *mb_mapping); + +MODBUS_API int modbus_send_raw_request(modbus_t *ctx, const uint8_t *raw_req, int raw_req_length); + +MODBUS_API int modbus_receive(modbus_t *ctx, uint8_t *req); + +MODBUS_API int modbus_receive_confirmation(modbus_t *ctx, uint8_t *rsp); + +MODBUS_API int modbus_reply(modbus_t *ctx, const uint8_t *req, + int req_length, modbus_mapping_t *mb_mapping); +MODBUS_API int modbus_reply_exception(modbus_t *ctx, const uint8_t *req, + unsigned int exception_code); + +/** + * UTILS FUNCTIONS + **/ + +#define MODBUS_GET_HIGH_BYTE(data) (((data) >> 8) & 0xFF) +#define MODBUS_GET_LOW_BYTE(data) ((data) & 0xFF) +#define MODBUS_GET_INT64_FROM_INT16(tab_int16, index) \ + (((int64_t)tab_int16[(index) ] << 48) | \ + ((int64_t)tab_int16[(index) + 1] << 32) | \ + ((int64_t)tab_int16[(index) + 2] << 16) | \ + (int64_t)tab_int16[(index) + 3]) +#define MODBUS_GET_INT32_FROM_INT16(tab_int16, index) \ + (((int32_t)tab_int16[(index) ] << 16) | \ + (int32_t)tab_int16[(index) + 1]) +#define MODBUS_GET_INT16_FROM_INT8(tab_int8, index) \ + (((int16_t)tab_int8[(index) ] << 8) | \ + (int16_t)tab_int8[(index) + 1]) +#define MODBUS_SET_INT16_TO_INT8(tab_int8, index, value) \ + do { \ + ((int8_t*)(tab_int8))[(index) ] = (int8_t)((value) >> 8); \ + ((int8_t*)(tab_int8))[(index) + 1] = (int8_t)(value); \ + } while (0) +#define MODBUS_SET_INT32_TO_INT16(tab_int16, index, value) \ + do { \ + ((int16_t*)(tab_int16))[(index) ] = (int16_t)((value) >> 16); \ + ((int16_t*)(tab_int16))[(index) + 1] = (int16_t)(value); \ + } while (0) +#define MODBUS_SET_INT64_TO_INT16(tab_int16, index, value) \ + do { \ + ((int16_t*)(tab_int16))[(index) ] = (int16_t)((value) >> 48); \ + ((int16_t*)(tab_int16))[(index) + 1] = (int16_t)((value) >> 32); \ + ((int16_t*)(tab_int16))[(index) + 2] = (int16_t)((value) >> 16); \ + ((int16_t*)(tab_int16))[(index) + 3] = (int16_t)(value); \ + } while (0) + +MODBUS_API void modbus_set_bits_from_byte(uint8_t *dest, int idx, const uint8_t value); +MODBUS_API void modbus_set_bits_from_bytes(uint8_t *dest, int idx, unsigned int nb_bits, + const uint8_t *tab_byte); +MODBUS_API uint8_t modbus_get_byte_from_bits(const uint8_t *src, int idx, unsigned int nb_bits); +MODBUS_API float modbus_get_float(const uint16_t *src); +MODBUS_API float modbus_get_float_abcd(const uint16_t *src); +MODBUS_API float modbus_get_float_dcba(const uint16_t *src); +MODBUS_API float modbus_get_float_badc(const uint16_t *src); +MODBUS_API float modbus_get_float_cdab(const uint16_t *src); + +MODBUS_API void modbus_set_float(float f, uint16_t *dest); +MODBUS_API void modbus_set_float_abcd(float f, uint16_t *dest); +MODBUS_API void modbus_set_float_dcba(float f, uint16_t *dest); +MODBUS_API void modbus_set_float_badc(float f, uint16_t *dest); +MODBUS_API void modbus_set_float_cdab(float f, uint16_t *dest); + +#include "modbus-tcp.h" +#include "modbus-rtu.h" + +MODBUS_END_DECLS + +#endif /* MODBUS_H */ diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..9bff7b5 --- /dev/null +++ b/main.cpp @@ -0,0 +1,43 @@ +#include "mainwindow.h" +#include + +#include +#include +#include +#include +#include + + +void SetProcessAutoRunSelf(const QString &appPath) +{ + //ע·Ҫʹ˫бܣ32λϵͳҪʹQSettings::Registry32Format + QSettings settings("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", + QSettings::Registry64Format); + + //ԳΪעеļ + //ݼȡӦֵ· + QFileInfo fInfo(appPath); + QString name = fInfo.baseName(); + QString path = settings.value(name).toString(); + + //עе·͵ǰ·һ + //ʾûѾ· + //toNativeSeparators˼ǽ"/"滻Ϊ"\" + QString newPath = QDir::toNativeSeparators(appPath); + if (path != newPath) + { + + settings.setValue(name, newPath); + } +} + +int main(int argc, char *argv[]) +{ + SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED); + + QApplication a(argc, argv); + MainWindow w; + w.show(); + + return a.exec(); +} diff --git a/mainwindow.cpp b/mainwindow.cpp new file mode 100644 index 0000000..8cd9b74 --- /dev/null +++ b/mainwindow.cpp @@ -0,0 +1,85 @@ +#include "mainwindow.h" +#include "ui_mainwindow.h" +#include +#include +#include +#include "Qss.h" +#include "libmodbus/modbus.h" +#include +#include +#include +#include "global.h" +#include + +#if defined(_MSC_VER) && (_MSC_VER >= 1600) +# pragma execution_character_set("utf-8") +#endif + + + + +MainWindow::MainWindow(QWidget *parent) + : QMainWindow(parent) + , ui(new Ui::MainWindow) + , mStart(false) + , mConfig(nullptr) { + ui->setupUi(this); + auto list3 = QSerialPortInfo::availablePorts(); + for(int i=0;icomboBox_2->addItem(list3[i].portName()); + } +} + +MainWindow::~MainWindow() +{ + delete ui; +} + +void MainWindow::init_charts() +{ +} + + +void MainWindow::on_pushButton_2_clicked() +{ + +} + +void MainWindow::on_pushButton_clicked() +{ +} + + +void MainWindow::on_pushButton_3_clicked() +{ + if(this->mForms.contains(ui->lineEdit_2->text())){ + QMessageBox::warning(this,"地址已经监听","地址已经监听"); + return; + } + SubForm *p1 = new SubForm(ui->lineEdit_2->text()); + qDebug()<lineEdit_2->text(); + ui->tabWidget->addTab((QWidget*)p1,"豸ַ:" + ui->lineEdit_2->text()); + this->mForms[ui->lineEdit_2->text()] = p1; + + + if(nullptr == gAsyncData){ + gAsyncData = new ASyncReadData(this); + connect(gAsyncData,&QSSASyncProcess::Done,[&](){ + qDebug()<<"done"; + }); + + gAsyncData->Start(new Config{ + QString(ui->comboBox_2->currentText()), + ui->lineEdit_2->text().toInt(), + ui->lineEdit_3->text().toInt(), + }); + } + gAsyncData->AddConfig( Config{ + QString(ui->comboBox_2->currentText()), + ui->lineEdit_2->text().toInt(), + ui->lineEdit_3->text().toInt(), + }); + +} + diff --git a/mainwindow.h b/mainwindow.h new file mode 100644 index 0000000..4114eab --- /dev/null +++ b/mainwindow.h @@ -0,0 +1,70 @@ +#ifndef MAINWINDOW_H +#define MAINWINDOW_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "global.h" +#include "subform.h" +#include + + + +QT_BEGIN_NAMESPACE +namespace Ui { class MainWindow; } +QT_END_NAMESPACE + +using namespace QtCharts; + +class MainWindow : public QMainWindow +{ + Q_OBJECT + +public: + MainWindow(QWidget *parent = nullptr); + ~MainWindow(); + void init_charts(); +private slots: + void on_pushButton_2_clicked(); + + void on_pushButton_clicked(); + + void on_pushButton_3_clicked(); + +private: + QMap mForms; + Ui::MainWindow *ui; + QChart *mChart; + QValueAxis *mAxisX; + QValueAxis *mAxisY; + QValueAxis *mAxisY2; + + QLineSeries *mSeries1; + QLineSeries *mSeries2; + QLineSeries *mSeries3; + QLineSeries *mSeries4; + QLineSeries *mSeries5; + QLineSeries *mSeries6; + + QVector pTime; + + + QVector p1; + QVector p2; + QVector p3; + QVector p4; + QVector p5; + QVector p6; + + Config *mConfig; + float mMaxX; + QDateTime mStartTime; + bool mStart; +}; +#endif // MAINWINDOW_H diff --git a/mainwindow.ui b/mainwindow.ui new file mode 100644 index 0000000..27721d3 --- /dev/null +++ b/mainwindow.ui @@ -0,0 +1,123 @@ + + + MainWindow + + + + 0 + 0 + 1058 + 758 + + + + modbus rtu monitor + + + + + + + + + + 12 + + + + 地址： + + + + + + + + 12 + + + + + + + + + 12 + + + + 串口: + + + + + + + + 12 + + + + + + + + + 12 + + + + 采样间隔(秒): + + + + + + + + 12 + + + + + + + + + 14 + + + + 添加 + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + + + -1 + + + + + + + + + + diff --git a/mdbguard.cpp b/mdbguard.cpp new file mode 100644 index 0000000..2bf7b09 --- /dev/null +++ b/mdbguard.cpp @@ -0,0 +1,6 @@ +#include "mdbguard.h" + +MdbGuard::MdbGuard() +{ + +} diff --git a/mdbguard.h b/mdbguard.h new file mode 100644 index 0000000..fd1dcda --- /dev/null +++ b/mdbguard.h @@ -0,0 +1,73 @@ +#ifndef MDBGUARD_H +#define MDBGUARD_H + + +#include //线程保护序列化 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +typedef struct +{ + QString a; + DWORD b; + long c; +}CDBPARAMETER; + +typedef std::vector ParamListVec; + +class MyDataBase +{ +public: + MyDataBase(); + ~MyDataBase(); + +private: + MyDataBase(const MyDataBase &); + MyDataBase operator =(const MyDataBase &); + +private: + static MyDataBase *m_pInstance; + +public: + static MyDataBase * GetInstance(); + bool ConnectAccessDB(const QString &strDBName,const QString &strUser,const QString &strPwd) const; + +public: + QSqlDatabase GetDatabase() const + { + return QSqlDatabase::database("MyAccessDB"); + } + + QSqlQuery GetSqlQuery() const + { + static QSqlQuery query(m_pInstance->GetDatabase()); + return query; + } + + bool IsValid() const + { + return this->GetDatabase().isValid(); + } + bool IsConnected() const + { + return this->GetDatabase().isOpen(); + } +}; + + +class MdbGuard +{ +public: + MdbGuard(); +}; + +#endif // MDBGUARD_H diff --git a/modbus.lib b/modbus.lib new file mode 100644 index 0000000000000000000000000000000000000000..73660c94cbaa8736b50400e0de0fddec651f0466 GIT binary patch literal 285130 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

sy5!Nkc3ur>qv!9M2jF~`T^HcGv z4N~v~5ikj`fv^}P|#WanHMMzJ3DnvY$c`n9LOs48c zVNZq#1**Bm18o-)O-gTjDnz_P7^l=>ir4tsGa%wiO-OZbeC??Z@x^{$sR;5>g2FMZ4)f>t!C?AZySLK~kq zKW=2jrm?3a95hB^IF~{`_GE<6pjQ1gn5M;h1^qIDB=(Gikl3lEMRE*0vB#jP17}`( z+S^;28|t|$TJ&W^{DL?PFSfk9tFi60R_TttKx3M`?X;$jIvk8pUB9Y%MfVD6cl*E# zlkc7y#EvP4NEr4@D0rf(e0pN`T|CQcf|&FP%{QUIP&}YFVN^gxvawOKG8CrW#Zwox zOvZ}X&=V8x;%RgS)gnDG*)ASl7o z$7+wfHzRt8jSiwqvRMq(NMEEH!%$N^1sZLpu-FX9q|jz!m$(jS^Bbo9b=LVZHHcuS z-dLS^r$}Z83l_7THS=MIMuXb+M9cS!VxWJPrTl4-#v|o%jtApv-djqYG})R)+AD_s zw*C<@AVE$V0ec|PeDv(6J<+vdNEr~LmiSzQN0$S=;WzC1+w44Hj-P{kV`V(^v?m%Q zUN8A;p`xn{&jH#KvZH2$MRzc^{G^Ybf%an%QCp+tib*jrNuk0*{ooB(G>U-+dr{I1 zaz-vxChEb-;L=o*1u(?n1M^+hnFTO7h}6t4ml2AT{8*6SWxF5m(P~gN%KT-V z9AvOTkN~gUHG#auMz4>T<+gc40=#_J1Qcuaj)Dv*AN0p7c&C4i6AbjH!lZwW@y9zV z=v-JxuyZgpLL@Pn<|0+UBo)RdUQF#p>#(;vjJ`~a2`V(w3NE324^slV~V z;Ey(ayqd4I)ac96`&#$Yxq#0>~JX9d&I)chj8MXT*huhD$tRc(Lna9-!mA zRhAv|Fhhjb$1H+4^po_VqI99NIoYo#`N(y+2~g`PE5jJJtR^y7hRQUENio7u$fTK! zn}{E2@U}?kqUVGq-l5@Lh>Q|RJE|9L$Y0^X{4z)As1im)el zk7KZf@(O3+#cT|MEvZA#F$%cjfYWQn^m48)SfF|GMmV17RWH;`Ug7IVhaF1T(1Pfy zUuK&RwX55kB+AJO&)3S(_HzWsHCLdeQs;YJbYOXfA7UWK!)19C1x~Y)6Qv-xd4&f< zXW`)S({Xe*%tQ6;qZu8?TLTDxUg2AKcO9*p%f%{8+DG7IXA-5GC!_e?jp5bMdITuh z>&1~W^m|+;g!&~zzRku6xk4f&8O9-A&T!$m`EflM#vmrO#MTjgMDc^-@6 zI1R^^bs*)87mM$#ZX9CMg$^&TkiIg=VO@3Mft89waX`!>;nD@1_!jSid;m2bsELTv zQ9Zq824v#nKoEK*aWbMo<;rd`(N6Tbnv1zvI9_T7o={V*b2r1Z)$9EQ=V7;aVwnlA$R}@NS0MH7-f?391P>w zH=!7ZWQL+D6Kw1sAp{SD#xX{wti=~)y&wFkCG55h)f&N+1s2)`(EBQ3Lw+P2)swE1 zWM)m(h9JXt<Pl44m55+6D&nJr&P$C4qb@BCSXxH8EENrRxmUd??pXur4yo zHKmhwA*E1^@`xR zWjK0Fousamk*&_tD@qCy+@xutLaCLwLJp}*E|HVcptwpCla|4vN?V!~^D}xOa?b5C& zR*m#EtY_vXE?;MuF%1OF5!VDUM`qEF(wSd%5v!S;HpGz8O!iH?CV zn?8=x6H?;Cj+|>Z020F-;Yd8GNNLjX&gE?#T~hL7p_U~`Q{oD?)U|Uk zN9+8lU72W8rjNzbjV9l^Oft!(ds-y*#{_Ki!fsdS5Jb+VA{tv(w46i6TW16; zNw$2HqO;GH1h67$ra0;y%g#lsbNv(wq5?<9c|s8HxIcikr^rW41PQ)YvegcdR_Zm4 za5(FdF+dn86grt~|Cu zPF{j9XH&5{P0hkG7=?mgHtAk!bV8>t681vvU?VDlJUEUQ(}Xh`4(Vh!7m8Btvj({I z6EWHALdB3fj0z&okEqCJR+{4NZO~l!n2V`u(Xdj|*t>#AzjkpPh}k&TQ*-WlXU?Qs zety=mgV+D&C!e+=F2QfP?myd(Kg<8wN0on>^{40mvoFp!5d3-j{dS`F#kXGA_m?LY zymZoY$ice`|D(rNt$t+SsXx0e*ngjkI;LRK9uX9{4xVuSZI3nAtp9WQ<`t(N`tO%u zSqOf>X?I`w;ldH4zJK6aPu)MhKi#sn2>zF=hHRWNJ2G|C403tqqN;NhQKcSPC1&TOxPWY2qxj(klhuaMtBL$9}iobL)hxRnxW&FTs8n!FQCObma@bdvjgxn8&~U z&-q7wug);y{w`jRL2|g)W*y3G9wdwB4ZM%%FL0NjY%K5Wh0%_-WgYb^ipsIKqO)ki zs+ltmTR0aTLfdJbMO8R4ZQ-xo4mFioXm$m-Te6Qe^DvTOByO#5m#LoXw>#{SBqWoXfxJcm=Z0!1h+0}(dPF7~klAUc0KTHcsp|*DYPg2kE`441dD=v&z`Bf-z+lelN zdvkNGP~ipWPd>xO)i9n1T3>2czBLR45y6epu6!%7=93BQURpIQ;VD@2Ue=cPvIhSf z6vw=9cHTMP?t-g(z=p!9n*(dMP1w2vkJfgK%W*>CE?j~<5>I#F&ana;78d6PHk?^p z5K7FS8A!Y_^~pzefrV%2@3WU4v)#8b>RRd>>U}Yg2o+CQ>fbOtkO1vc&z6t!eCrE6 zL+{I8?{O{N?m>qLcOU_7>pi)i#O5tu!;$AnY!OHPCT{Wq~>whq0|HT1rqYs-6i*;}^yHkN%0-eA&C*ybc2 z-5O{J=J=;R8Q66Q$T9B47v^#2SpKP-|4t0d2JDKIy!N8x@d!BvP^Lw`q4(wc zhu&AGf3mUM}P^CZ3jvn_wi%l=v-%6`2Ur{`^EEb|gwkqgT1 z%C##J+-DK~Kd@vI&w3zzyQEk*cyrcmUUfj?37f2YYM`Mi zM|p1d=1{U#sX$Ik0#l#Sg}JbJaUjuByc|;Rj&EIaMjjH=RXne2gfCH%6WBO6FR+nk zXQ^6T$|Mf`eMGYjY>ebBMGD8MSQ1q^p^a4|JeyzxT0j>EHr5sw>3F~sX&<_F8PWl{ zTL}PD)A}>)!yHVB=6L3y$lF7SQ&Gk{?ZO+n z7H7>_5YX)?f3QKJ_==AWZM>lPTHxXKg*LKg;EM7uz`uEc4Qs_8fo39KRxmNAAeac} zsp46;xy!%iY&45QbtQ?E2NLOG9nuX%(z4xx0dMqDyJyj&1zQ7&t0kJiy0?a|eI4GE zoaJmdi+u_2phPSWHKF1RB)(p^dFcAfLA2(KoUHCS56}h=H2jlUxd_hfYXva1fyA>& zco8ydL5uuHF`&GS4Q*Uoe1#$=An^ldFU{#e2u;Ooji^qP7ieig&hsSwNKip&V|YX$ z5i3eOZx?U(=s?5sb_y3vU`Ez?AQ2yDZ#X+gi6a^`1XGo_9Z8Ng^n#uLrTjozRau}* z(2}zpuE%iaSgY~BU0mnkU$t)Lb%x-W1J$~J0hemsZ^Naej$cgOj3=zago}ryVFxE% zv&3~0TuRp3;ZkySHe5$o#v3GBJky5!rQlV#~+bZnu!%^%?8@%XIQ4|$4*+uU6s!M0mJ293`4!eTdtJP=59L4B;*RubQeqXl&4Ja8$gtb~xf1tRc_#Z2-dH83YxU9waXPvmL<@i5VTgKH{om-RLNRjTlyQ^gZ$RjLZ$suH@u#(sd-RwxteVPJFcvt%r>7O>3X zJImyir=66#I}2?5=G}dl2(zTa45b}H!6J7ddWzk$^Yi9w?#d%C}bHpSc`pVbW7v`PLP1DY~n*ON^bluy)S* zWI42SYG**b9cb8Do!A*jJQqm3qZDM~Ynp89sA&|U-?Ojp+69Gw+F8Lw?#8f-eZfpx zLT>gPGifZbps69Lcc;EYy+IqwjpUjB;Ov>w&pg0URA^(Uc$yG1bm@`j3~_buM{l zxU>;-^&WXc40>GSg87I%%@J8VH!oQ)Vxa0-AcvrE=iscT9 zA)wfSl(?)8ydPXC{wEm!L*#i5o@pO&{5Mc@#6pP%G*J&X)>!9>=L|IH0|hr4&un;@ z#of4B&ate|@w8rW>W^~F8TuiBXKMUFm(@cl83Z^L5L&f|F`-a< z$^b_Ih5*L^a@M5?kb*N7kT%YEz}o>Q0J3!*0r)6j3E-1}M*&h;_)Kl~3T~y%=*qWf z^(fqY?aH^B46fPW)*2jhq{33;sj#$>6z*|@d&=P0!WG?{2KR-*{oCMZ*eN=cispxW zYurHwhdgQARD-KAIJP^LmP;Tbir;10m2X{da5oyJ)YJix zIpd$+1Si;DsSq7yfo>0sE8=2YY)X{;F5GB{{Mw!pUdrxr2Lm_Ul-+#5g&H5WtRCjC z1~3m0^4T*=Kko-vi|28G>`4y=Tm;Bg1xf3f0mvSgWkWn=la`H=O}g@}1qK(_u6*kZ zgZq)ey=QPA8k}7(cOuRHw0hx)mH9yWrJVxcGWEjcF-y9eTN?3gbNL({&OGUC=8B&5 zS_*|qRW`+7nB^~wAXHK$T++J@lw?2vcmkb-j)97L3EvvnjkRTIA!2POg=i#% zh~lk;$Yhs_mVKH+i$15KEix!%ixSDiF)L8z$cj>(qB|*=_Qg7*{IOmsE4&&}X{<-+ zs~%QE3*cnHvjIsn2)B|ay7Db*Glg5BUHLM5p>Ssz+|`EeT7!Gg;2tr!*A4D%gZs+h zzBRaENVke(ly>D?(+rMtS1Nr^7~C@kXUj3QX?dC)+qF6#eo-ZdaAlO^&i1y}&L)Q- zzYTiWOIXcDb&^y!6OfkUWqA{9n@%MgN!w_`Udjf!L!E#-E10sOD;OM;ed9df?TdL~ z{Zg_*8hI`*Q#Cl z(myM@3k>c(L-(P<+4V3SY4oJk1O0e$G%+W0J*cnPa#hDNe922S-@Y_{jx=9pI9V0^ z1}`frSrv+kMLQf7wjUfWS+@xjXIa;BAx9X_Qf(`eL6>251?M?kG9l9{6o5)#=@=Yi7sV-C>&d?!lBN^HPHHr!EG`)aMEjEsS4wQ`7bxLjec7G6s;E5bv{=xh}DFy0ez zTh_HuB8ORXkxbTbA==o@f*+cp8)XWrkpikBnv6?9Jqnp%cEe!F1v*a_s39zeN^X+r z%OM|nsKiR*P>BsO3U^Xg*sm4=!<^`G62;{>pm-H)@qu+E7sZGEck1Vf`gyZ{F2QqB zCtsnl1grzf7t(A|JMu!m)x-Lk3CN8S(^1F{HVee}!$Yy{i@ zSO*9_ZNW0{#^c?*MxK3D^Kgd8LJ;`+LjtuuU+}p zsRq|=aKARVTMX_G2DioF-Zi)n42~lT6)#dLu6%2$!JTYyD-G^+gFDaQDD5iE*Baan z24}a4D}hPZQQMJ{V%*o`J_$mku9SXWzFwR`N1;0Ob(lyn<&$avpB!?G|2rDuo!B)> z5g!4sBZT16)OKOdS~Q4fDW*HKOq-yr(tPhVLqHGCrog48(xiJeV^!oT+3U|A~u{|i< z7K2-dyeZrU?aH@)W^j~N`sQ1|Gq`&U&X(z0K`|pu&$E2kPwj`hp%0nvXzHum9e_~W z|CQS94#4w?g{W+6SAn`IN<}2qmqU~?cEd?M7_fr?GOes*rkA}MuaB~<9;V`Bz+r%& z0PX|$DIoLoPr!rpGwY80RNc{qA-ln0^eeu~K2>zIPZix}L$}S~FsBTWNt;vN49xvm z$h<5AuxE9<76vw4T?_%#)4}qht=BtndtJv4L;M(H5HYQ*z z-|l7h$wyF#Ele+V5?gWSK&|1U7~=Bcp9VyZRgM2gg^m+Z6qFn(nmfdG7XDuq*X71# z3)Kt29GfOozXFa{R0219Ty>==N-Q4jip%NcqL{dRoYS23vM8U!<{~@~gBWE4a+3&m zZ`hNY%yfoJ_t-2UY9*?iB9M_cCm0oPr$yHfK75|8nT>}8QS@j;I|oI~4+Sp|Fr;bG z+J)pf1PJyx+!P~Tvb_xFTohi5=aEEOx4BX*zWv0qlj#F^PH+{X zZ)?Otmr<^vP%+BtyIKMkxcXsFtPijJId^WNXz%I}O+@pPIuxTG7qbwAFi_0d({Ye? zjHF4=x^RC4^F`xgun^tp`Zb12`&redv}iGA_w3Bg$u7wqJ!ovdlo@-T41wb_3NJ!n z70Z5zbqp$3O&7|$1}1~-#v&HJLr~8yt3sY9N>PoYm(_wfbDJfNKqpHay;C?2ZK6N$ zY*$R7vu!x7+IBM2*J#^eapEZ7S}v~&m@8VfOn9>A<|Gm;k97*G)~-`|0{}D&ThO{b zXB95h%meUYV|r6R+x9PKj(L4EO!<5C^JqWJEc>(Y;zz+Z~2mBcD=YTr_uL5K({sNFz-8F#qfY$+b0bUQd8t_+uh*S7o40scs zL2La6@HW8P0q+CEL}?G(D&wb~n2KBJ3A*yF#Rk`?UHKOCq3F5{?oNYaE>zg(432t3 z;XX3BPYsTfD~jJf+Ldn|Y;fZZE?{uf3W^`i6BTx&!QE z1)Zk&ougg()<%Q7*x-I)aMu~!?FPrqEGiBzAyoXf7~Hc4M-8gzb{HH?3XQY%EJZwh zz>IzXwS$2f?nbmMb*1!q(6dYXwxv{<^eK$O%o>aOgVHucqA4-sTif8W;s3kgYXt~#3HYO)Yr(d6sj=nDRIxoBND*l^0rRC-4uEI`h`WWGy+}9StX|cR0G3t5@i9Y>0K@C$c_g~S z6ANjF+TD!}ZIi4>=+qz0Bz8x*Sf7;7L4Yk9xf!aSb-Weu0KjLp-31*e{lN2p(|~^gFbenzU=84FfVF_H19EV% z4RA5wV}L9S;#o+=xRw0Ul`rusT)Xzow|cZ|psd|fbk`UhxhWjwP=&qE;E*njL&`MW zhX%L9;07SyD(qnG%D0X-xMK{CeUzf3{Lz(feQ0ny3@!&gJ8{2)y{WC`)YL_iPW&jBf4SLym62Dhqzy40Xi;ac&ma6i$m zf!3u4_ocyoZE$v(KM72FzhXBgrl~e_nd{~FQp_~uGQGae6W=1cn6=UYPr34t0kwXF zyWsb(jFToKTQAF)+s1U|v|h=ui=fy6)8FdzUU(+H|U1=~DfI!qwwh;m**m zf!2=n&TWR@UrL5K8M>`CoG5bI)TO512h+ci>{*`t?Gm>HEE)7i}0*) ztF&vNEU8hrUl`nVhAszLS7BKzif(^{D>68{?*0hO%(VXd5pWxU`&QgbGS^)vK8M!8 z6C*OM72pIBaxL|h)I|HpL})#lF6*mFy^&4oAk`<*=$a_OFGi6ZU${ib_0lt1!Q;g9 za^aoqx5uGFv-@b(k;S{(pd{;6&ztP0$BU+$2PT}AWsPFwx6( z7T^j%EDq|SW%xcIbhh;Y;I9E;&xst$B_nCVsKjw?lFVIq_z&r7Nf#`VsM`s zoZYVWq!VL(wJUs>sCTPMwj!kylNRr8bYg06|G&_Qsr~+F6s*>X&Zv?)k;}JiJ75Bc z?JJW`yhZE8JG4$Db0tS~DV?Zri}0*)tF%k$M1`YHRCL!FI_gA)W34DUN`S&qCn}s> zcV8jo@o74d`j8j0WYzRtcX2KlXzx%H`l;qXvJOW$doE|uITyT*kdcJaP%DM!4R0E2oFLCQ z6RP^7Lo>{LGB|5k)$%A2pgwx9Kp|42hK{PCcS3TV&pJh%y(GJFxFarmik0Tk;lS{+ zXD8Xm@#5^HWA@QT(~IRtiK9gMh`{w0B#CAEJ|NTjA>eet{w}q&@-sZo!E-L2S?iX+<*6U{+Rq2tv7Plg#ZW~}`}^iDhu0WD|psTfNni29?BS630NGJBSu z4CLiGyqNWf%g#EnlqF^lSe-p3w4Vb%Q!$f&mMi(Q>?wD={MqUaRsfL27X)M$LV%>9 zRjFi?F118m;rO0Q;hGFxv%yhQDmrRPMMq0X;b8cWoWNY(&wbY1hg0OapU+cYQm90E;JJ%_^L#1O66XnQNTsrOI>G_#Lo;nFq{<_sjx( z5RmzK2#__t9k;4+y7IX|T;opCu6)jaNVyHPSd%Qle5oB3mL;dcZqu%T7PXPWu|BXl zx21SAcb^ww=Xv6z``z%~fg3NpUk`BSC=ZLkuJjgcuUfOMXc0DkKP|^2C?d7TZF}}E zgt(s~9oXPiXCT0VU|*BRXtSY80&R!IiW=Sgac5xNS6y+nRX?yXfNiX=Dy|4qxG|8W zqhSASeY{U#&DRAT(;a(a)lm-Eo2=;UOMg`E^l^7y$<)mo+H#g|=udIuAr0wy z+7Gm}9@N(V=fzcy|FF0?@2Gs+;Ce!E6bhDZ4wuzhFN%x3z)j+!W_?qn`9Xtw6s|uB z?kTv~f^tOLD}JxzS@ENU?8LntwA0e0J|DQD@cR~b6ZDL_di05Q`g`Zn!Shs2m({E$ zL6RDH7^GUgG*&|VZ=BlcGGkkp)y_lrXfh7BnM2z#2uqW;9X9fy+2oor2bQVGehIb8 zaI8?g0~s6$wR^l?tBEb>aUKsRjA%JsDP)HtUan2?6b3MP{*mCaq=)Fe4xiee%8jd- z569ft0J#2zEb=fwLJqOlz|CQH`cS)w!St19J1h>h?PXCctcVMR#gR7kv}*FYFc#@0 zsQs)L!F`CesE`ejFB9@nN^Jfd=<D;e>n6! zOZYgg|BnYe6wk{5X8?Kty@2I_Q9$++EE4t;Cj(Xjb^=xbo(;GN@La$s;Q4?xfGqeJ zAS`mL7LZbngW`Iq`%eVC7jOaKbASs0G5c|qp)u#OawW{q7;SdF!+45CrLwjCe-9G?uOh!MHj1?H_+krzgL~Y7p0yraN95r)4 z-^>}^{R11P3svGdo1$QMI=%l=--e^1XG1tv0Qz4mTW7AufSppOZn%`Pt$-_nJ4bdm zDc^QHE9KY?mr{-tU>0i*2aOiRHb>48;>1gibZZLt27FZ5ci>7@tXNurMOUfj#9-it zg7SOZOVP^Jm8Mv^HigrGO1HM!7Dc*t#Ts8|I$r<6{@h&AXetOkMY6KFLD?ZmoA;nT zl<7F(@t!EtjO%2mI;j|!3gP7#PN}sh>5B0jWQg~kUk+0Lm4KU4h>}B^wN!};mCV7S zLUx+eg0@y(^P>wrp;T@4#KuT!8@Mgq10vOKT= zR`#-72Y57|I{|%ws{l^`JROk5aRwk&%b9>w=4S!^2=Hvc^?>I9{sb@qco*QsfQ<8J zfLj5t0Hk8R5|F0v&jEJ;UIq9G;5C4s0bUD8nPGaU{GP$BlpkGcI#b~mYhU$hQsF4! zitZBa8faZ+aKAISdkl_pt->-@Dr^*Grf?iKD%@g&Ycx2T>xzyGVH91D!Ld~+9P2>Q zU2Sl3A`BX_QW)w;D75Z3aC%4g!7LcGJ=U8!+-as+6e;F?pdp`ACq-O^Ie{}Q1t3;K z0Ci^6<2>}KYkwRIb)-EqctIcIBkU7ioJA9YMzQzW3)=zU@@FJ6N8VhhX3oCyRopq! z^RRMrEQ;cT;#!6OS0uz)aQ#Mb8}Y9~*tS;_DAHBL<)ES{uEo8$mx|!-$ohtcruOug z95kLdA|8!k+=DmXa*558)Ec89Cm5&X(qQWp8!4$9s?n$q6b(WtM(3+{-rGwusgBaN zZcG4~J-%g&=PERgZQTs7uRPmfwxF|#+iS<8a3|kBa7JeyFzS_Ur;L7!_>5cav%uR1 zv78ul+U|=wpm@c#PH0h&))G9cfs(8yTddIpEN6-!>$a8%T-g8K!vee-@Bl!pE|OI( zcLTcdj7`h3%JUY$C3wb4BY6wK5fu;HHK^+-s7 z=Y`?Kt$FO+qdS1Hr4e$Cl zmS?FM&=Q80voY-HP!(F(UkX1tPXo|GcaM&K=?W``BR@%;Xck) z&>YKlEHwc%h@L#<316j&Kc+k%#VIV6z(B&zFf%I$7C{-Lmx|3yl+edp71);45tJOI zBc{WpTKpWiUc#MYoreEM#dRuzz;nq>EpW3lNf z&L_e}#hskTH~^KAu2ndjG7?mTi!y2zuIxkuOMS^ht&-FrCt72nB}P$;fE71J+bf8< zbTxH2w-4ylaBd&aa_12>(s3ApC701Qwbn0bX@cpJJotj`I!~PoG72+vOsTCbY3*cz znB-I=oRLc%!P#TZDn^J!xBtKq=uQ>I#j{jVi^X64^;S^FwYM_P)Ba{Fqk5n6o&-{VlnZLZeew8;#{UJg)vUZv0QU#{2jF$GTBzO}ExQ8Orh(+qB=!NK@C=abFImb1fHTl_o0hzT}Kbicy{`}k<5 z#Z^Kj-UD)_gq6khnpj*zdl^|5D8{y(bL!9fP|CcRkgLT=vL|W);@yX0)uR*Mi`9poHK=tWzf* zxErgg4DSyH@4>3#7h9CQW%Qs^W!YBMW{F(=^;TJ|B3os>0C!Sl(W-hKm_1unC7@zr z9D7wT_%z^2 zfX@K3Zb)||;B&ZDqopffUcV{a678EW=C;Ch7~GGwYoK+Z!ExlG=qMR<;WdlFQS~XD zTb+-(+?V(qlhm}5MmYq2V>wStUXD{qVHjPl4I>_~X>EJ^zmQcvOu-%QMg_@97(0i1lyjV#;V0Fj3&8tT-s-bId1A%VT zf2V#7GOs=KKr{Tfnn$Vf7}dTgC)<<< zdlIiIBJi35mJW7dXTBB7bfC*gy2-u zVp|SI0C5Ly9H5H-m&8S(ehm4}5v%Mm!SR2)xJYx8xZcM93~_yk|69ey-cRx4I*>;N zHw~^Qgx@Ln-z>OQaNQ%Wb#Of`zCXkN-Gam36Ycw3xSkVVn(4}NLvt{V`^Ad#TmQpvr^aVSw?z)M`f4GF6QZkpXE4u@3<^yt2>Q z55lu|rshBi+lsIQC2Vol{!mx{S3A_~om``Z!M<6A(Do_o7Y>EeXZAJ;!3nNH>_nSq z#j#F&sP!rC;jY85`94RCUarj(MS$bM`dJ6#jqKm06X4VqrjpVo=N1UZlaOy^R$CU| zuO!!7e20AT9b}(--lUOPLtUz$f_;sups}BEF3+AOpep7l@oG#ID4d<EEoMZEJj`ezte2 zaU!3WZEath=D$fl+txRg0WUi|O*CF+r`zXvV2iddwy7)d%x;jK6R%=)i);W|L-gE@eY0?q}b%+3e=0`Nq@ zuK^bUvdWhNaxd62!0~`MXs~B8U^C!Mz*7K^18fCs18fIm!JP`onTZZS?t|+D+yK}O zm;hW2cqQQJfGo%}0J#Gk|H1B>Cgju2> z`h53`o(==K>e|^5Z^WI$?cmle;<7tYjwFsu8=J&H!LdmdZW{dR>T#@o>b;gJIV+>q zG9{lGTCH260_c0)5@XA}ZmGl`f!OPo$RzUutP)`|PNHEVu|&(U;Hny#rIxa+Dd>^I zh4yw6zB>QEUk8JS!agFokO|xJwM~GJ|`~;NCJgPF|?6G_DoD#V8tu&9glJ3&{~-P)B0OOrwm*S4_RbD$m>nqDn8|6=r0Ag z??}XVR~AK57AVo@kK#j2DgX4va#K8%ii8CcE zWksDDgW^k`oYu0hOnljekT1fcTr8A}>_SHRdD&%?S|W-MC-hX=Fb+MN$Vq zQX#EcQr9>_|H*__E`~0a&|~{$S^YljFSK?D`YJj~fO0X%Dg>#%#%*7jcpt8KYZ99; zB_J7pG6uz$JO?A3eP!ZHDM4#48(@`n4YH1_9d1pYhA*!^n)6=PVik_&qlh*23=DmeJSGZW z{k;UBcqkVs%Y=t&gR_Oq4nbc<$5bg7Ye0n{)dt-5m5Dc3gsC=2Dw{8BAQ^u$2E~^= ze?@YAW#Y?q7^s09mzARxsoN$89DrNpQn{FqS`{Kc$I9=5tkLGfwOanwAM>a}DHlWW zMUU3oQ&cT2bA%{1A(V?D7E1_`XU_lOvO~~U(UHG$u{2c(QeBVRzB2J%s(5P>n{N)D z6?JM1iZ6L?vY8sn)G*W%I+rynmx~-BUWQwhi*hlR4hgaELAhuv)mH9%IqlhtRmdnL zpSeoP-wp?_R}3%ZBCl17*MaQi219oYvW9jHY-gYn+^M`a60I*vlS-Fzkrz#L$Q!ju zBlI#ZI|O|d9ZO%i$XkUV6$c6SrTke+%Ei!Y6>m+#5WG@p6g6W|e97}GlIbfG-yaKK z*MJ;rz)St!v&)gwK=w5i4wX~oVrni@sS$Y|Wc5SI@v=iP1&Wq=R4(>NDio=%L3sPh z#Q(CC+}eDZ+hiJ)i*YHwwpzTJl(+3RGeGu~il1_k-_0roBl4^fjrrDy+5y%G^j9Nl3fdX) z5&r3mszrrXE{49NSNe->a=?HIpnwD$jPsx>dypB*+CX{k96eka}`R(jj zSA9oUcl(6HlAn8$CGbUD_Flwqj7`T^()mFF>>b7aQM#}f$6C^i?Spz2uy%P!*Z;qOQM=J~nHzH~o$%l_U`*0etgMKe$iI-?v+>F;hOf!Z|0R;vAVwOk)w88SvK{h z7cM^US2ejm|L@7aoVD^VJ6wo?5vODI?d+y0V!4oT=x$3mX&Z`>! zUKFQiuyyDToJD+{O=$Nv10^q9wb=Bdanvlicban8@KdiKQrUp_T;&?^(Zyz=1ZN3I$e3VeI>yV-5` z{Ivgp|2Q`9{_&$C=jDx=-E;0v&!%@izqH}`hiB)kJpZVlpI-m(BbNPZ`J<=Lbl?B{ zQw1M|T&KKRc4JP*d%qa@!m#$z&VRgq$TNewzkBz92t;frhjbwu&+$K8ELUvS3qvCj;z z|N4wezyGXp;3FHpT=HaL&$b0Krp$T#rs)?y^q)D4BM&}t=8@~0hpxQsil5fbTd`vD zw{L9t&zs?_zym~<-0L!o*8(=SzF$A9b>2W z<=SaO9vzpz{fyje{#|HDqI2421E?$fW>IpFD%1+Q$Yw0j75L)(h>NzILqcIUYGNuzAby|k&m zYf?$cMJ`v5#;j~>nY5x2Gd_6JCp429aac(gK5l`F+BMtt9i6zwytIh33%DjVHZAF1 zRve?7A+ud0F#cmFpS&h@HLdC@UeQVn`dZMq@lTGw9p9Z$ED zdG9RzZ!**<2E~=rD^$P#L*0A8M^&Zo<9C<GJ#1ZrqFc= zNq}e|F_}=TaX|$m>Z)t+x|Usg!LA@GSa!v_D)x$HU3)M8=XuY$=gys(Am88m`~1HD z12^Z~_dM@=+I!wp?zwkB^?F7~EGE&>V{dV|>?uR%B(5&Pr6xmImmmD@BM#SWEvris zS6AWU1c`3`=g*^{9(5x}9T@DI#KmEnpFLFAUw-KscDVjb7P#~zE?JUz$jcNKY}gW>BrZG*7eju>#o>0u@)UOWy{PaiLO{x%d;gZULgahX;QYa=c#PKCXmek$5J=8_TT zIcf3v2puu*w6JXoE>3His_(+y%}!bmXs+y}w0aBIKKM&_XYB|mgk7%ZH5W1N+UNs{ z*Ruy%;EriszsTXj$t`ijxN}Io^?KMR2>CWt{F#%(BF)uT2TqRl(>FLT>U}!dN@g@Zv6c6&8QSz96pZ{*I#kP)jUh&^$b(d*1u0#_K;Jq6Eqhw z?s5$fu3VvGTW;N)JDjxc)?5RUayU@93h5-IFlv5nd1LnO26bZxV(r?)C7D9JP%uGYK;sRIeuo81^E% zeo2^pK}B1{<#~X@#MSeDg1H)hX_xn{8=^7F>t(bB(RA5K zm;*rdde|0r{R~XP94MFtab?Hi9<=!U93&WSSK9gMl7yi}b(g(c5@wWO0+3_3MMe_l zV8P%Cw&*%;&?brb$xD)xo`m7J;Pr45&Mtdbg^6p6F@iY)f03Nk_o}SZlXZTqV6K52 zT57s6Npi-4>h%QhmvWveo3=K&4~`d1yqs}Ka%fS#o_sCm%=10pB+Hp77|yKha!p8* zgDDl{WFXHR$-cY(*s00onk<+HkYQQ}x=BfLxH;?faC4gNwPtEF%7q)3Zg3OW>sbgn zcHfzjB#5*hTq9R~0h<7!u6hm%=7PBT35Xn!t*&H)8*JqWAGT*T#S%)B?B6Ji zqA)zpg|R=wAu)#=RvzwViEr5blYwjR~x5{!k-O|!NtGF+^;J)Zv8 zO%B%!noBTNd|DyHg@9H1;FEsGM!l=K1mjAp*l;ne;a}gd!{Pc;a|yvpym>c zE3FdYV$CzHx=y1KJxzxBBuZNYA7VD5)^PcH@io^At<`Rr6tt#QN z+v~Z#`Y(65dUr)6oM2q#ngy!Ylf%EbatD9%iNiHga|ykiE&7*|>ggv;(+sxl~&Z1)_-pQ*C7tqAZ>&M<4S9xaM^nJ;?j3( z9j@`3OE9jqs$FTFdCFHOI$UL%OE9jq775n?{H1Gp^42Of&*a@vnoBUQv}zFR=;4$3 z-@oB-tpm&>-kfzO8_gvcS6WTNWtZ#f>tFd=?OiafAsPIOo`B2UUPqH+ zZ0}V!jC$4KD$-nnai!HPT()l9+q3K}hwEs~B^Xz^T3l(ZsJrS;hwDGgox-vHSf)}4PXOE9jq zR)Xr(;n#29=ySLVHJ4yqX{{12+9=wMS@-NcN$nrv#yV1S3C5MyYQ#Eey)bQjnZtFg z<`Rr6tz(4CPHX;%=L2d_k7>1QF2T6cI@Xm|_p_#LbGWY4T!L|>b)0b7x{LmUTxlKeN^8s93$Agv-qc)zaiw*FaM`-?;W71bY5lCZ1mjBUL|0msCw2BZX$|C* z2Tm}qwAw&bHP86@_pkj~?J@Fhg63*N*xkQQBE|HtTT7pKz~QRWT!L|>^(WzCdvRQT zT{;qAKS~QnnT;*EhO6%0^@8LHNY_4-Omtb6Jtraf24i{W=S!ajq4$UPPS6U~# z(t7ie!T8ArJFVw6mtb6Jog!Rz|Dugj`_CX-UuiDExY9b+mDZ2*t}1Z2diEr*I_iv? zk6Y`l1J&ypg1_uvTW{)lrrM*%jkT}l5{xUY^@w%aYgB1Xlf&iHT!L|>b((Nd=joo< zbKq*VPs_WxnoBUQwAvBtq}Bb=mogo$nC23UE3MOoE4~iZzBUAf?}7Z zlTb$XLYt*Y5PN9x&k)Z7(d!wmqO6BEo%X1`UxxK9xaf#+bNv|<=Q(Wiy`KT8Qi9%S zE@IqVXA75}1Y4Is{Bj?M>r%}{jGOBm;nJqZn*LPhha9ernu{1W*SW%F_n(n3qadZ7exa=H`zvv1yyIrnNG#4>$uJeTJK>Vd!cHw?Lhbt{pi1Mi{H`n=y@OpAp zwDsb=Vu-QR@@Xz&+*}t37ws6`;nqdt9j=v{ix@Z8g`jvndy@rj$lS|6ak#G6T*SD! zE&|2tVPAKgox`^^7cq+VwWbgYIqI2RCGRfAg=ZxUy4w#@Yn0%KDOI+ zff&78b?5E3O~89sI|VK7QcsabZcEpEV`(=rM@L)y#7(4WB@*CpZvQ+ z@hP;_Ew42nzfX*CrDgw|PCN*-6)uqaZ7_V4x^78xeQdQW4tYuS+hNnEM+yg$5alL8&iPSR9I!6wh?n z>|gM5^GqL~x60?rk^S?YT2_9cub{XzFtf-X@fGN!m&=zR7md@$PtPqVY?(fmUhVV= zZZUB`6l&)x;42Chl$Df(N_@fQ=Ei2`Jl5L0ybgt0w0ipZC3P`=LacuI;zkG^Z;F#2 z@67?Fs!nXTUe^H(vp~!nuf*}w+gAB-i~iH{TncLR`Y#+m+O{v{Wyt^J}91j)_9Z;ae4y>eI(_HAU%x=Bsb4i8Z+5 z(UA5bUd6C9*0{Vu!x=`0m3-7MM-OM4$KNlHHCF3;efn2{RlgEG-CByy-m39&r-yai z($-jQvG zz|F!Bd&Xg)Bgu>)+O4Od@|(#@AB>7=J3-54Xv|35?<>b^BdxFNhaIBPqKZ)U^4f;F z=7OblHAkU3TIyW4_M5d}i6Pc>YOk}D$GLb2=if(73 zlXDv%n=0A(_*5y!$1DCZu8tEQulPHTPmy^wXSG`-z5!%1n@S1Pq&5YMj!2P;o=2tN zv13v&$+RW~i=wAsKvi_aV@FMoM&zgLTPk9W&6tz=rjN!{d>3>NFTZSNFz7D``kW~r)(pkCX2h>S$uyDqV8TmfEqh=N) z6GHjH@Qkwjh)+#>O+?sNFf&wITv$-zLwD12U=us8w5)VSX-P?$kF#q-o)C!y0^ynA zpifOMOhiH07Yr5Vmz2&7`0!R6awc!UF^BdmaMQ>09XNX>Hoo5B4f+Cpe}1T}tYg-C ztY6fiW!UnIeMK{71_On~1&Xh@3=5tZmLFL15ic*wae-y8lnQ)>h57jfHsUKDdN(8fWfE>U@F3>{{oPv+Rz{Y+jZtC8 zjGKsqn%I2_L=>e9JfD@7AHSu>n043_;crZ)mn$6iMtoM8FaAh0V1=;tr*Qgdg_AF?*9+Qjl&I(oMka4f^9rIA2o!dIPsJ0hcO& ztcM?W12-Btei~&oF1n7&i(M`25MY{q2iFMPF~EGJaoj&jRWIBy%dWzoIOoesE^jH~ z_XlpJ#&(pygMd2;n45kF*8tqz!0a3~_X+@<+Yj zkqVcP?$5yWz)6qvg$TfL16$Hfz~zBHWg#AG;-WM5AOT1HSho;c__*kdKF7UMLHaga z7cInZ^j7nZ2LV|Q*tG=Q0NAz5fZ13hF!@SSDqIc{y0#WJrcU9Qk5srU>eXUAKB`x^ zoDOiuLEhpc@wK9(6pnT&mAp1|u=CLA`X8-ugF3+Vg}gz{I0D_GaBSaH@`yVdm}_GS z*HJm}!5`~eV18Ypa2@6EAjrFYB_2So+O@oUfE%^ivOYLQ;rQ$!RsNm^t{G2^ryalR zbn#_e>q}rBYE!tO9mu;C@;*KZy0Av!u=}1e-8SH+ti@aXC+`}^mqX^Af^Q!1i6fk; zzXUyHbA1U+%{qZO`kbJDeNm2+fcXob{lS^`O^_Er+=cBp!h?$rY^on6$m0tWJP!XC zKBo*@^T^X4PZL)X%F149RkcP*X&we1)}%+E9N@5=%8jP^^Y%bTmVeo zbpn$YbR>UqkMSA9dVN4+6q5Cv=ZimhX5+R2_kzYUUBRW0_vLQN`xUs1>s6{9$zwkp zp)m^CasDO&7x*1{eIaBKFe?&qvKF^fQ1x;yFjpkv63R95C-B;!?=tcc^>d zqBG@4ke80Q12jf}_|uX8jR9`jZpd4(oAPRbYuXKYXY8iD^MJc*H{@;FO?lgZdto=^ zeYuvmJ#S-@TLJM!3n@7qmz z{{-&U-;qas{(d**SvR78;G*lOJ(#}(fSHzvOVQsJ0JAg^m(btXe@_ACyhL0Id3OS{ zDG`?-uLtD4p)m-G>!|;J4BWTBBaijh_a-e!dmYIe0^A6V?Wq2kzrx*=R}S0}yCLtm z-ITWuxO0C;9?N_CZpyn4xW{)x-g~<#?^EEu{~dW8Kl6F>rA=mFOd^i^#c@a9h+UV4zL9|ArW1Cz4-Nzi{Z--0aB=>W zy<1!BYezNIFWP&z$Y3cbsZ78|!huqMNw5Os;GD8ZdF2%SIEhcm@nyb5GDz5u$H}|8 z=6ak!0=O;}1m|LY4?-!;v6hawJBT7zO>0Z6aal*qT5hzquAzGME~IM!s#<=ET8-CTN)R~az>QzpTh@Q z%j%E8larhReEzB)r)H4u7r0&?1zT%%&7O*!bh4_N>!YDaMP;R68zA1l>kGj?)C73j?FsTsYlSd-@g zIy%iAT^W!jVtzWiV#86s6ESt4^lgYj#P;Hk)9DxXNIE4E)<=L#`x~> z@wz^spOFA6uR@fAs2=gCGWNNGNMvSl5T74XVtOV4q%*K)rNJnqS3HJQ%Ff1!%=n06 zbk6;BL{@x6Vc1_3Wg(-Lk!U1;2Kt#PMRq)}tg>9;3L>SVi0q0?2S2Lg)X|(kc{Ea9 zTvS|YbfZsvd>}HrG#v2<%KVifQxARP5#^CcCG=Ia!>-PL@qpse;>u!wI9ga74vHSw zwbef!g+4xKZq(?CjoBj^V>D)%F3^B@3|ciYB_eUfIImb?9|NTg*#l&cRpu{85(WO!NNI5aZ0S7J!i?;s zBMZxmgQbD+T*(C^ygCBLv8tSQkj-z4Ow*CNK9$X)ZjiIHjx>gW`C~*E9pNu62%#Ua zN=WXi$)dxkiHc}dX|STeuPq%R>9)uq)LbAMz%EWeHw|FZM+?g%CB^_SHbcjv2r5!E zq>tw9u46^>?Y#ETM0CGd!E&i$O6qBo3qrvXKSo29d@q|^jB&>nk*SG+NQoaRYgbQ} zCWj*helzS)cD60Vu5rz1%j>PWSibEB9A6_-mo zQFL$B`x)O!$5*1eMYr6y#0*pAC@x(`qSsYKOM{iL!!wP{ZaNaW zQ{YF_1jIm)EyIc7aO@9v?-s_I9z&W2n z#?xprKF!3>hJB9A#w>}Wx6E}atbH}Avx5re!|awt%Bspr{G}MrWS&B!MrmCPEXF3eM5WV-oCckTN-irW%zM(_>db4}&ujIkwnCl_&)>*3;np zfq=BRsU;3Cg!D2HyZBD|4%V1Vg9%kumYE?cYL7!vU5TRo6q;oiDxjk>2v}e7;s^vyZ~#70A?J}k0=aBWmSdrd1h>Y!C?l?iZ%)~(8SnTs|t6CYA+TMWmUpnQdU_Z>T)Wdzgy9gNFcweBAV|nn2C{FRtC}X z$|@OWx(KACf@_cfhI|=kXv`Slu^0iPURYdSqM|sC1(7K{dzs1UTClXLM8+`^J(^gK z!54F14o4(+(q!bLDjbx$A=#_R#hlv|;vk}Ah%sq81~mhfCOf?6pJL7-hyaJMFDyY42div4O!Dz1EhHc>bIe+M3V7ar|2b>0kDUqj3jm@v9PQV z!>rJ4a2Em3Wm;h=IKf>-aM^5k&eAnCE*ENhVG!isI8N4;Gn86wAX%lNcjIGs7jA zR`kqXV${t(5zbvC`(-xv<4d#13;WAfWd}v~$DqbpbZG>AE^H0gDD;+8D0|DJ7hwBK z(Pm-KWDJG?b?>!!KMvMg-KXOm5kt=Nwx zrcLZgVpZwPQjVQ=qFE#sk2d#x<$jVhCne?bUK!GdPEj?HS=WzFg!zAa{v;A|UmHu*!*V5Hb1~SbcsU*^x zn1#-DhA-|ttpTu;4Lq!>xO^tM>6~aq7&8NzX=Nf~mQ_|9D5)scW2de7EH$ICYH>#g zXB$?mNnLRmr^Cf1va3Q?tV~_efpULgr8FR8u{3qXV*Et&bEKC(PY4#ME=Vv?Txk-= zBGna1^NGB1p-EmWR$b8$9x0SAFdng3ozJa^VoE%Ef}weA+SoDDUy17^G}tytcCc`& z#h0iR<{c%$l6))(xCh2)3{)*X)X?C7YDGNG*a`V z?UE;ec>}ss5q=CyCDC=4a9KJ;xl2|dliQJrB`A)hEWmh3C)QPfL@Y<(fIrOj->gU& zTQt^W&E_gYBAc4|Vscf9p`JV0QO->Knl(MXJipH>^YKD#EcnaBVr5GK)s`M-)L0*2 zep<@z8L7gITa=9;d(T%uXueWz(dz{+IUUG4l z(`3fp{1upuKte8%y$38H*j5`SATBhRpuH8GoFFYaTA>uvcdj!Dwl{_ate2KZH4eGI zM%tUiiD}0{ITTQ+y>BegDz2o|envs0Ozn0MWN#h|r~-untUQRlBFw=!bs@&yIu?vf z$%_O2S?J5sd+Zvv_m2f-56cdWi!}8)EM<+o{D#v6HelnFV66 z&UMYn(7~kajb<%JZP<%pVXVEuEU_4Kiwlc`f#hnnHOSs;7Pv}DZEtbfEXzF(3>0kd zI13U>9eGY5OJ2s>o6Qo-+Ck}=DolAGi~)$Yo47%GQ(C3RUHZ~W+UH0GHq0ZXc%u79{v86tK|i*MZM$(mhd7$w zqH;{hO>G|-kJXikS$m-wP7ZPb#+K=4jHWe4#>ZoWS+-quvzgWyr7Le#JQ%jA0$aFf zTK#;@X+68C501yXh0EX?nToI!N16kB>*nE*`f@WoHY8 zwvEdK7fSXNR}F*FPs`MR`w1G0Kj^;ab;a|70xJ?RIjRE*1Al#A`V0pb}Nd@ zxXm*&T3Cf?I#<`EW2FVUp1)%+089W8A8=M(fnEQbe3=!jT;_88syVQqP3ZyXAVsd%tE$`7>jLE<_w$a5R;Dw{_?D2 zEMo9UU7SBc?}yRGR-8Y-0_!4@ptl>q zy-aCJo`6z05FUGXjho4g!d|0&I4V$Dfn?INUk2I!8UhNRF8hknR2zoa_Dj$H5^z>= ziLS2-s7bmU42V@Pu}=k5u5PM>Dx_y~w?_+?Zvo&Vb2W`PSg=|S!J!oCvY8E5Zen5( znk6*u%Y()eb1wpmj`Zw9ASzIhkGf0G-UnrDZmB<}E*isbhq@2&%uEz#Jn)n&J$nZ> zN6V^abF*>;Zn+TO)iPYIj#<89mJey;aW@~zVe_Ar)CUP-ky|A43G1nHs1}*rCouV_ zGC2JHdp0+QAx-ZLV+%4}c6N20=w(xsC{p~Zo4w739=28)-s#PD-2 z(Y(C8(O5sFXE$|0DX|N}9ocjlWRRA#@Wnbz)mxMm$7)%DN?csa!-!JP+3aiJ{tngtd|4Mw6qZwIc!Z@R6wc;~ZF-d~4a$<=k=EEO+4=Wmj z4ggK=ci9*Psx|h*J$Du2S|e$NFIyEu0iGOH>F<;b6lsj}edKo^|*{qp4JhMWs?rJrJ&Y z5g&{wMWZd#H7)v0kX`dYiJ%;m3I-eNfKt&KZq}m_)NZ{&u-uchRQAiTHYTj9fr$-3 zD)BZ}bZRB0w(;->wMtIrL}VXc%nr@JZA>@_z=-fskJ4dZ=FJ7Cy?kx~-k&YQ^) z!tAjhLX338eR0oS+uzx<#U=>ys6^s?Kq*Y8h#LU1^a;lTXdBP$v45d^*=@#Fl0@0$ zEO0bReVi~302Z3N)hx8xj+Ro*29=8==~LW<2L!wIqA0Anqeaa{E=@kWcoq7;8MmlN zVWmlIe?BgS1U~68A_!3%Czy$)%ku*F(*kVxRt4STk=RJq%D*8HwHZHtvoL(vqI=WP zt@X`EwTQ}aqG4--Rv9(!><>6Ps~%KX2t63v%E6jKJ;e{5k_GB7H|bHPqHrYNABKWP zgCRT`M3yV0vmn+|W{IueO|`!1T7B3o6b03z)!~z4wt_r17Q?^^imQCglbBK*bihL> zN@a7}waz}nW5bZblgfDDq0T>(jjhR#g0?O;{klb$lw(2@#7MWMj6H~j5IF{^)rw8X zCu|_wPwiy<*dL{e;sim=HkeI~us3zhEvD7P)Jc_njYRk(cld8*c{X49)1%Xl4}Sjf zjQ1zM{>)DU)lVp8c}^L0%gBOfcWfVc`Mj*>4*w@|cCO&Nt-RyH_ZIZ+|I2+>_^bZ? z3%-T$hR}mMM)^05fBo5Wj@|hD*;{CU}&;GODY zg#O&I&p+|oH)npmx_z%b?l^ruT7h}W@)VZV40?CY*9UcL8uHeO>ku53 zH){0cym6yP%qYKbjv#`k4g zs+;Qndyyz6K7d{KUkYl$T)M6nRo{$HP%l~j$4FzoVlB1*r7+P68t^|tPE8|Le6VvX z|8RkSh}Kg5?JTMfL*q+ui|d#Cw?&uUusrtPijnMbA@xTHQXifBBP7{1wybU$e$p}8 z@<+;C`G;gvcQ5o+*>?DEGq`L4irUz`S{aZI-*i(mD0#1~#`*%LneSkBvBGjl>HA(h zFU4o0KkHD2)hCk=R7u-Ihcc`soJR=lC>;V~^GQC>rZzt>J51jW+jRTh_HDZD+jQGc zq}%tl-x01Oy3J?%HqQ2Ky6q>@?R(odxJ{cqTfChfdAv*4t(_lxH0|jgJ^zvU%s+c& zJo!}jC%UC?dwIaXR|fBRbfry3{P(8^ zy_Y-u{rx`tVBfvpd3T?;hvmF=#lq?u0u~Hly^6Gb0;H!lwt;o*X>2 zsPL3O`JF(*zZu|Np>cAp<>;uE*k6%rF^2C`|oDg$y zcNeZSE3|$=ZhB~aLvB`ReJpptY)H&$_xRgi@wb29{&A@Ni#6Z>);cJ#!FP0MLqBj> zp$)7COT=bw>=J4Z=az-qW4XR{p7yPqzfWK1@6^6U{Iq*8SGIiX>OGY9o)mb@M@=wLzky87a z8$IhfWp4DRt;_e^gZj0$tm*XY*iBocexz1HH9v;hU&*}tUsCjSX?rc+yfb}WU@y;x zqE1pURj9t;eF_(o=*(lQ-SVCdmu}(7qY` zleP>6>wSuyEu&IyUkyR8taD;A zlJAo@wPq+L%7_CD!|ju}(&V$EBP28xe{Yu%l~KhOaF)=#Ox}#ki8bb63WteKhEk-s z>^{$3$$+uZJ0eE)V@vfq7Vl@1u8STUKmt%4@P?bl$3oH zR7uw3*d6OHq{s~w>G4&VdF~bnfI`jRG8h~W2^Tv?=EhF`%#B%79*NCbyD3(_W;H5k zBHJ_XUe;r1{c*WD?Ju|gD0xAiw1NlPp9-{Z)kHufZ*sfUiss+m#py-5hf$6BC4@BT z&{Sm{j>6yDBy<@5s;-95?&dVt@t0(3`69Rc7){Rb+MN29<@?2QViGIALsM64B6Yp8 zZ)WMr{js>_<;;z}(KQ3;sE2Hi!2-l`rF1EqAANI@s?-e?zlPeMk)mX7tUTnm%#Gng zeqFrzo%F@spIv;&Bdxu4L$Et*mNh4!(uPZYW#0XA=H0uftZxf@q{a3OwUfPvDKOvSD!Elc|cFWm1d2{Uq|y)e>w{^RnHe8MBPlY{))eS z+WsF1sTwa=zw48;xUt#Ps8-n8oDs_#W2pZ9Gb}ls!jIgw_{jg=n@X1SYRYkL|0d{tcy_+Furl;r6b! zF>l`nbr+(j^+#;!(1!DK;B7sXe>tk5Z`k&#wNPZ{s(aB3E!6ZLbY|7PL+uf5=Tw)` zh4`onVl%TudS-TT`e(He=2A%VU$L@^hH6eW%U=L#)qK{wjRt$rvZW{lZ7Z@V5qEVBAMjRhaOPxYYyt za!C7VxC&F~M*|U_x~VrLO`h6@u^MuHlSHmHlX9;I1Lb}JAN-8_=zSF?{G(S?m=Zps z{sF_>f3z9lsoaP;u_Ts1)p{Eu$4s>z@mR6Fr&?>hRxESsS=+r<>r4vgz7-ik|7e{K z1NzB{B!cym6%0VwC(EW<>0PZ@bZX9(@FG*KtX@`Z`cz+jrWHFFAm&LLDj-dyTRqdX zQ4uVtYNSv02Aq7K45V<#`6LSg%KfA(DM%-CW2DELk2=SOtog_j%U<(?C)VZh;5+G` zWZ`euPcrbg%O`30+qvz;o@(&)X9gZ$7km#2-|NuQ)*kJ_m)E@YOJH5=yPxzvH28S% z-A2arKCh0=X=3Sv3j zsqPbMFZnz)_Gu|~sQu2|DAwkm5KHq5Fk)D->1X z?n5Xnw8s%rxLR~>>@Py{Duh&Cpd^~39ifQCUW*X54<%}egE9 zj}5Om2zR_3yI0NOrx6S?2G!QBsIRFb;|TLhPx0^|e{CxVA8d(HzS=WrZC2BPM2^}1 za-20R%Bfm@)N=fAl4K$WSctC`qs&zDCr`-B%V}+?bF!q;z>bcjfltf)PC6Xa?cwnU z+GdO|M`OxVnibk`9<7)$U;9rkN{^+oUU9>}nlh7Hv2m=*gC_n@co*0M=ssu;)pS%h z)pXMkQjHx#s0tTes=!~>*z*ulNGWKVldOdDRP<37JxBernGr_2VY zA)9ceNh{qeA!o|*G453tv?s2waPAs9`H5I|sJ)vciy}_afv05R`Vp99{d0#%NpMmuq%#>8j)`mWy3QrU5C2Dzl~WJw`o^Df`O5~w?Wz*%Fpp- zBesV;N>Y@BU)Vt1N3y>}R9+k-^YA$?<~Uc=q1$Z?E`ZOx9S)ymyct(_;btfU>oZl# z?iMwl<;}1zKuF;((V+}e2TuVJv}cA18W#Dn zI>HAaVu(aX1-{gzI0V&Vr?7mHM6yf+1w2>o>kSz1>H^G%>>dk0X(_SHd{EF6aV{X3 z9l`wwx#u4b_UHoHWe8<6x2 zIi)VW1||=W1{hsZ+`Z#9t))p~XCgOtY{$05)*$K>rAIuJPBmcGv>HI7sDbE#PYIR3 zEDQC3ws4%LqvhHd#Gf|OPlDeA{u=l!^IG`S2lg3dV;IW7o{~-DIIC#u4DED7d&|(? zGqf~>zQ9$EA;zCj-=Bh>iR)QhAEvJF#2<0pmCYH9fx(|mo5S4=3q#KV=(LC9aymPI zgpqb6z6r=x0xs43$D=!WtfO!dSK{$lH;A-+Y`{&+9)xUq0Z|4?8gy7*Mzom^!|E9l)uy|>OC8i_K9w}$7*By91WkU(F%V* z_$%O#gufC#>lmjP+75w#CVZ@At>fXdN>6~l1pZ0z8{q#5K6?UjC%|6|AAQF<89u9f zJ$%kVPlNw7{L|r6$B91(K6kTK|6(WuJFGUXUWYQUA8XTA8`{N&cDbQ(wXftcMI~>G zp=~v^orcC5QaEUb=1tR~44hK1Y5YwNh08OvafTK!w2-0k*Bew`P}7k9ZkF6 z&>l9lQrHK@OG}~B<=(!cH5i(0Px=XGp;2iRN`3%41O8dKK8N}!=d$1G2i|sNMS6<< z(;oB`{teLDR6T@thLaUc+u_g4X2$GZVf(x88OgnYDn3kPV(^9r^FB}C@2BtQ==*8< zo(f6Fc-19jEGSb{`AfZFpWr+)py{<~RvS31#qe2-BjGctqu^Ja~4I5>evhzPaD^0Xd4Xe&xZE4p}lWtUl`gqh6b~#)9tK785V7dN|&0T z@^X-&QDYU&)|cl%nVc~G@Yj|&*E|pY&MXAPx%EZ;=9`Ql9nE!zi^fnNhKqm=Ug{T* zqNiK6HH&ZnuYhk?$b;T7NQx7)Zupmji<3$pD5-UfTDU(Mth2lW|cWW z0$2yzu}!J#Wgwic>F2=ivYju5e<1wJ;8(!E4nB4K@9?RqykDvBuY`Xm?yrM?7krjv zBmC##-wXeB_*lWW{RAIYtc@kv1b+~GY%}38JlX>Hi{L*EA8A|vf`0}4m*M{v{tNJL zg#RM^+u%P7pAW2{t8EX$|0n!M;XeZ(vaDC(Z->7FK6pg#H}F5e{rB)cg#Qctcj2d@ z?C-(v2LCPiP!j8H_&j;{I{YE<-+(_1{zvdf!2cNjNchYzt?;+-xdr_l{CV)df?o~) zYxs-d{|Eju_@BdXg#Ri074ZKJe-->6;GYQpNBAefmwJGY4g0oh;3IEse}kU^pTC^c z8UFL|yTE@Dekb^^!S}*{1O9K2^FDmoxwa4C|BU<3;G=A99<)2k)YcU~wlmtg!ygF0 zCw!E-EgOD+_>82(z-w(e5 zem;C^WC8p$;fLU#3;#5<|7Gy02eg?!T*_uLl)<&Urd8`uhOE6A+nuX3iOsOi)S>Ry zIfk~`&>k~1%x|>3W*y4loJG?xTha2)FtoD`4Shl5t}?Wn4efSAgRX1bBZdb3)HGuB%Hi z@D-!9-2}e341BC)<+@?kJ&zsD`VA88YZn!ta*xEB*VBgEj`?Lh$IoGIMm;hox9IxC zgRQnfxW5hlKJf2^&-%U#KJ7m5S?@>SQuWRd_Hzu4_lm|fufi=iv_}nXo1xit%pMg= zsN)8p7{3J92dV40gI}h0D?68WPAxa!-5$Q-MjF0d1liO+a{P=moc%0kiQ7Fs7CQ!% zS7utR0jD~~iM+Bnd0gzqAQ|#nn(QSQ8S7Ip*2gh&MiT;~tqS%e#9k?mV1AQbN>#8| zhb)-d^RlNMnu5Y`y~y;KSzw&ZI(oD)E;+Ud^@w^?sp)eujnVm z%xMgQMO$pa)CA5GxzS)dmXCVCI$+z;VfNZa{{r~5Vi&<@`LTYI_8o$-YF~!bzL=uX zMkpF*z>3CIm!f@bXx|%}UH1ne4~gp%&P6$H)Z%(Cb=~XZ7YXK>{gdW78;pGTH4zo= zZh~y#$g!(lOo3x4W?==hKZXQ?@)(UBq)$uS@wum7MNPb za<_+d$`hOJ4x6px?fuF$*)WX(=^8`Gv=l;=+fSI5V*Hpagnm{|+&cFiWZawGy|7EV zw_EpItaUr}>(QlK2K1Aaij6(t?u!sR8Yhul3h!Fc>?JN`Q^oSY=U&#*OlYOkejTcsCo`KMd_zL+g(GD_o`yWpEEu)6Oz9TmQKBo0Ks3`5DsK zC~xEXGPVA-)HT%A@a5NzA0yUF19P792IO!Hh0g@5F`1@L$qVZ7d-*f5;OHbQGY!j7 z*uX$GtBrPTk+8;A2&fDtQSMxQZ>KX<_S%*1s_o}!tPulUb*%uMIgn!H{6}SQC@RU> zXXh(g-hI0C_V(#M9RK$2(#bmncU`;m@*a%M_ihI>OYfpPd90N!BAM1ZNAmQ%m|B&E zW!0-VmI-1H#By?rZ3L+d)f1Mr)YXVF=lsRTSXhKkXaO#azLXAI)3|IIN+H!jrDs>M zpJm#UvohgSe+D>Vzq2#MB5`MkdTZ|tH6iSDAwJAxb+eV&VbDr^nArvrYd_*a?GFZl zTB|x$QVmbeJ_C_-pCjvBiE+t8_Z{wKV)rF(moMP_4xSGGY4~Tt z{}=ol;j_8^4*zX^&;G|bp6Y)LW$@X%rY+PVHK$WJmRjN34UQIG(YQmea911JqlUK4 z&|WaKmksR~LxWyvd7Q~9dEEI_Y0NgX`G&UI(2h5>3k>ZNLz|C2tK>y>2>Z5%#vZNG zSZiqO49)KMm=`CFJL8de#^>RB7rLUHYu?yWw_ME=sWYh#52TAt=x8;wcl@|gceFjp zbB`-~i{kGssV|Q%S{=jJ4)FcIY#%7>A{@Rt-ZMxSL|=5D-dU3*ob*S}Kz)dCRG;Gs zmC`*YEdxa5Z z9{`_iFjkK(Oh@T9LuzbMG>$Eb#$Kyv#~IqChIXZ)J#1)O4DD@0d*9Hoe$w)&DLM^9 zJI>H-eL4V?X$j-VXh`EcW?x)ycC1fPJ}AV3B!0%C*B>;gigB#By;tKqy^V)$FnI)O6P~6MHtI=N`yDS2S$+ zB<*qZ!Y9e7KddY2Mf}|3GOS%#df1~jW(n3vo`GHipLKd2eCp6%xRib{lz}%!Y}#TS z%D{UfHf@EWalNB>FE%vD)U>}F+TDhBzoEToXs;NW5BXQ}IL}pivGwCApc3~FSv`y& zi|f^7{lMrGRS(#AHO&}-RqLOdMu%&TQ zSQfS)^_^o6-Qj2-maiH<`!#y2Jg?(D*EDD+8RH;Fo^jN}=k%Z!{wVl$@L4ycvz@85 zs+}29dya}0)v+1Yu?Badp}l2j?-?2nH>Ue<|1FSt_mjcQjgKtG+ZDy3^+R&Q8}TG`=cd_@&6lO7w zv~@w1+p8Bfxus>v7yMv7fy1kDa_>i(4p5nsdmj40FGeuYIY=Z^i0Ysn7gW>bzPkvS zgNcJJBoog#rG!QZevyJXn+K+@LOc>V%Migw#^s*YiYk}FLC^a@t67oCTIq@#1R|}> zFkBIjBHEReQsvn$i7J08RF!SD4nAvcJ$x2+1AG<=b3=7Z1O5!$p9O!ejz@Rl!xDL{ zcP@OYJk5qud4@9N!LXunk*{dS7~BblcABAaHmYzJ85#_$rrl>~4;k8%hW1ZG`;Vc0 zWoYOjI)7f&yh?+ME|tGNhBnU7u&JSOT#74P*wDDSr)aEIB`<^n!dYRwMKd70KAf9V zF^jK9;oSF+p$)Ozg?L?VCo*B-bs3%q&k4704YfZXYEKs`x?NuMi1}MMc;Admz4Laf zgzWw{3n`6EI93|~qCc)faq*mxa&3#7n(+;j#WMA(!Wiqpx1VBIRxK0d<48SBkcm$g zh6%@s;OJ&W3mf@Top3l?SKMsneH zltd(<*AMB~=Wv#C{0c{p!NYoCH17n+ZMf|Pti9imM>*QD11QJi!1jIv1#r?=hA0+2 z;<1ZPDl^35fvSt=4Dpk+G z%3iSj2blYvf%Y$fK%SGG`f& zi~FPgBM#qkuMb(^JB%U4+5Ua##yx>QL_i1sQG+Foh(71RjEKd>F7va^2&xzhA zv~{z*SN7ZHwnMvHt>1-y+pIBov3DCFt>Yk29iNwot(X^LT7p+?kVdE-sq^*7xNK$a zg~rU>=nZX{?^);Jz_@l(>wh)`Zx5_rk$$LW#SmZHFTq&ZHA3gu;Z@+Qfz{W}w4ZjOD%6ErVqom0zH+M;F zBmUkgp|$w?goLO9Q3+j$zbf`Y6M7aQ&hXN#m+)6f*$?s+?I45{4Nq2d4r&qN)8#b$ zQ^PjD@iQ*Lj4T797vkxEjSi$-oBj%w{v~A@-T2`;kELG8f#p&A;DZHU?wJm)f63za znc~NFwH)A~OmM<=mHiZ&1dQ`|2}s}^o|PLQV)?9Hb?_?B40Qju!N$?G2_TP!=OOj6 z)dFNY^%KrHo>D};55r>*-AW)1gKHCnj9161ql@a54RW@ZvPD!Q(##f~1)d1%>jPLp zhZR5B+$5|W9a>)qR(tk~hgdjp|jiBzp8(;(Ruz4Of zjhrJ!oDYA4i$6$0pBHJo_~b8f#pBpU9&hFx!Ut(=JRBmD_o+~__y>B@5X6-M*MuwL z(Ur`z^fa4nFfiK{Nb*8MHkH%MIwE^H$Xp#gi;VI90)79BzJEa9GZ}6=JtOzfd#uEH zKU~yA-8<&_Esdf_J>|elbNqs)Z^teZ74b#*BjLXWe>D8p;rrkZ?yR0Jyn}l-$h+{5 zh5sS^b?|q>KNJ2(@Yxg}!@mLkm+-g3{|f%o@V|!tBK&XQzXktW_@Bb3d@A_&xaUgr zC-{5A{}uj$@PC6p0X{0Gjgt#6d>{Nl@VUeE65=_GY{sRA5r)*tLD6Uz6s^VJRvOwG zL*sy=a90`HwT5=Pp=~s@9ftO%p?zg&-x(TqJ#_vC>5zI$fT?x2ICe0Ep-+dpTX^QH zX~!DciH3Hiq4Av7X5l>&_KBhH)^Z)nu#Pdb6AbM%Lp#IJE;6*s4DD}*M$4ztc+}9g z85$;QBluF()KI%WZ_OmDb)3AxJ}}P4n^*E==Nyw}72EHcJDmlcVxKjhd2!=c~ z$5heVaH+RGmDw)By$adJ`W{dwB^c}Z!lfP+eu5sYoNcW60Z#sSJ$`=PSR=LhM?2$e z%FM(^Soar8$!&jj6l!MT30vF7(7rJ5DIDyJy`$o+#o2AY1en&ucFZ?BZCCgKO?(Y= zCzkbf_}$>Y10Pnv`Vc;C7+$NBPW&-^&b7XP&rb3fF4ajGQd`K1wou1rh!s;bnl6Q7 z2UfK0hW5X*;km?_wu^@UY*!5*t*vXQUj6^L`C&OxhTl_w(Xe_{0DJ*Z6ksBJD!^3u zRDfylshmFeRDdG*RDf-`lmalM_R$oL`)GYcm_Td0N)}I1$YiV72p;4Q~+*? zD+ORE!>Tp3r8<-$2N)FYI76cXC>j+&@&2z=0B%Z5--QDFJEa0}Betd$)3Ig$ha&)& z>qnsh@RFS#MW{8-2Ea@_V91qmgU^2Laf6HfNvO|1YW(0@o${CyypX4JVz#z^&#DZ7 zm7r1$gioa!3ZF`q3!h3g96qzYAABm+DEL&W$8jm8Vkkqt)TC%jbZiFRJ+pC~Jt`d6 zY6^F$q1|L?w;9?9w5h^zt)_VYS1Ml@WN%mVj!!#OzW=j%hw}=um@TTDvm$gfQhp2L#EZ~JWT2E*3@p}sQHLMa9?i=`2xF6wD;ks*u>!B5{msYrbTHzigMz)X{ zQu7!^TZnr_Yto_ak~Kx+LPg=uF}SM@?K(pnf_7B6938@5ke=xJ@twB+3zOZwk+_=d zvPY@OF58T~APvv4?J4d|6G}tq3tVX2q&bh;3$f(v@PBrtbh|O_J2Xq{?Aucy^y_K&8Jv)k0CWzQ#8)i6m6BkajvFlR5yjY*wCnMibf-&aJgttMdJXgXdyg< z!Dl2>Ka%-@k7VZD3$Xg4SxA2}Y}XHG_6J;9HWpGnrYS<`R$OWLr>q#Ct{jvwZ>vDu zU|h6$Jg2K%TijEcuK8YNHm;6cx@JpI$G{^h-!vKMAa%>+QT-F5`j!*vx($Ng(U^9)Y22AA*A)PG?= z;j(LhoX-k^b)iD!dPiuUUf2j9hsVuhGCog#t4kS(^2HJQbkE^Z>8TJocM5G7UJ&dY z<21(MV64LRFrh4j6h}QmC*ZPOD%qbQ(rbzA+H}c@&C!u;#X;1EwqW?FWPhz><8ORU zSSwE1oZKt9B9j(CyHs+2L>%%=U1NP9-*ila&Rr9Vzc1*jPB@$4zOL<3$tQ;Lm9yn` zly4=MGP(b4yHs*HefL_PG>?^*uW<8iIQ-{vsg_qEma4}tIk;$694bVP-n-;@(Qv2` zIXElmI9D$j4izHD&|Pw{C#qbj5IHy$xYOVa%62a!pg2^B9Ne{bbHvxxD~3ab$dQ-C z5pSP3BU5Rp5IMN-k2LzGTYaHJeJi_KeaCgN`i@brh;zWR9s88xRv~g9>ZI36;izS{ zdkO)?p+e-y7mi_RovgHR3TJaLR^h0!k0bpyX2K z(Y8>7bn}#|Qf8!C8K|3#FrFrSR0B%g~-t?9K$lxtjt)N)fsh1XLGTY6_%~6LTod|MN}Cs+oh7fO3Bv{TQ1wq z$%6_pEhU#S8#D*KRB}&HCC%(&W!B=^F7ll@rh607pYo4(6XB~8s}M`PRyYSn)2-;Z zK2}yO9;!aq?X9j&YK&V51WWidE-x+|kW-$7efX>7sSxFzrg9=0frF%4^VoZBSB`+< zQXz7krRs%aWv!}nn}e|m#~M)~*1qB(Y6&jerILM~lC2@OT-LdhzLSEIOPLqjLJiW* z!*l6gYv7PBR?l&nR?oAg))tZ}go}A}YVBu|wWCE;{G4&)@|@L;t<5?3HN6-z*)m0JD!)y^r%pK<8@zP1J9 zuRHQ!A6`qtgQzJB@Vhie;su!n4fTuEfrkYx%{BZ5ov~vUteP-xK{?)^!H>BtP?4jW zY8P2wev#GbhWEGEWRI`kF>JPsyd*tK$BlXYCI5p_Mrs0&l ze+}!rw)5;mhM#oxf!$AfX!1ALKJw3ZuK8Q%w@)oQ>YD?8YF@DZ*jEl)_3+V0-gD-h z-x`K}yv4s}amJK24{ds&?;B%6(Qx?UC6lIn-PZ8t<%2Kl`R6x32t4#fc*kMa=6yHw z;y1fa`pcC&uJ3!;V=vyfbK{@7{@P{8*=2X+4nJkd9Rm+Nu|0cSTEYB3zf$wfsb9Um zA(;Eq<7XWG#!w2uYFn{cG+x{_bW%MHd z#9-a&r=5BHt%Fx>J?*wLXZ<+kv(UT!HjZEY<&`&XY3cr_U)oRnVcy|)O&a^aajy@3 zeEaKPypw;xH#-MSJ*w%tFV3lbDEIW9GalG)(3SmOzOmx7*(Y7$FTDMp{HIs{TGM6H z=|A1H&)oLsPmVtP&-yQ`Cm#RQn3kTk-z^(_{<4~$(L1g`?5o4B|9D~J(?g0M>Uz%i z?I)}|qUUAPf6XhJ{8_=6pZZ3dp6@iLecZ|Ou3i^?@q@;_=Iqz4u)1)`l;R#|PoMSY zs~^~ZUbB7w)tZdIj=g2eJ@)$$lN~?hanG3T*L_xb#L(OOul}UV9;eeOGTgEWfTJdC$*(^x;eH{Pm9e`+V^D4QnnBSFy>!B|n&5XwoH262&K+C(6y@$!-f+PE$IhOz ze%j>Vg52=)FT8Q}S+88R_WkDLuHRO7`eCD9n%4Zw?SDG@mhmg>_?Nnd&z`YmugUiP z+>Luo==SWXoj*Bs#>m;TCN&=S*_D4D`oxo$+4=o(;hIMdtUd6yudLWd-<@*g!oGib zCJ=hPG|PAL%R7hlKljmZD(<*%__mYB)jYHPg^cxAFL`c{sRPpXSTSMEsViQe@#r&q z{qpU3Juce!iTwKG9@w}c?UWZX*Ool{{H9TX|Gcrhtmj3KyuJ9_(Cfhme;zXY&F|9> zoAliIdtPzw==rk`zWk7NZ=Krzm7*t~yy?MnCa&!}$+7%S9XKx+<@&5M>b-3=(RARstS1yi#UQcfwf8^4~ za-1CIu&8k9N#(+-6I^z!XU_caD2L0hxw<8B@#vV>!&w(0xBc~%R~@cJnkyrTtGjS< z{!GYSgCp-bTs*x)*FA}ga~!XS^Jli)i3jz^#6g4QZB`JmQqEy}#nn9LG+xgDM#8;) zS656v?3%wqvlHX4!(O0xam-Jp@b&ZO#-;U)=IW)=imUld;W|ijU3TmPw>mj|OLJu= zaUnxUs{wymuBW2|(X<+DeW?RkiYu;M)N8M20{+siJa{9fX?D5zO(;5I+~uNHcs-xu zFSW#aWGI#pc3S*G6kYG6wEBSR_3S6Hc!l$<5b1!aU`E2tKI@1#9IjH$MU0z^y5yAWwSqlYIb5e}E@IqVT+cXMci)tEs>3CpwnjWL zZmvPXWw-K6f4^^`!}Xg^ix_al>EU4E;vAj*bL4FY9qrU1&b^2moK%NHK=*oJdc~Ff zZQ*%NTE&`+7mkso*Jjahj!vwPp ze{GwXBYBO->@666Y@O{**EtEZ52#*G4ib_chr9G7Os-(EkkK53=z1q%sN4TvbKe3V zM|GV)tCcNTen|2IgL%mygLzm;vg8N0(ayf4wN|^!?n<^nWGzdwEwCj=l5HR%hyVd< z2#+?+`=1w0Xp%N*N`Qtm!9Y`!Kmvv|X=u~D<0PbnKwAnPj=x$;^sE$26u*F3-^g5aLup=Z6U^P7Ft04p!`3z!;CwDysivnd zU#D`vH$1Fof`Pk{51EsAw3p~%{SXXrbj}!muaA3%K&j=`vqms{CBR9a)g^k?3g*~) zE))!BS{*%WOY|Tb#|_W=5W}dA&(xrL{CI8$4+PFu3%u&qbE|LCnlI2fAP2C$`=ll=EJyP z-UmHSS&oSwkok7I91T{3vAvz<%YnS+$w z1G{#O4LT%J3fK*Fbj(NDKQMs@?30S-glDy}Zs`yvN+_3>P%bZ_TwOxBwS@AK63Q1! zC=ZuVzFk83m8P_tRQ{hSIDl9flIol+}jPrzsl@Wsj!VhH{IhtTmL6 zYYJO3<ZyB0X-uY^ZjyXEKGX72 zVt@*z)d8_S6bdUVIapGJ!m3FQ)-8SvOSd1x`p{2dO(K*Qwi7&T{P{67G1F?g(jC=y zf)Wfk^}%-@SoJYghl6ars8d5Q7A6MGSh&kbF(ns2{++*ZrGizIRWq*WEqiPwKy_`U z{_*R!TTbU|DZ%(`Z8TD}wd|$8e%6&*s-*-r-6;r=?UY;LV45pRLa{Em`AARqDoDFg{zo zBIU&E?H9ke&y_kwO9{pouRfox4+9Xn%Z9TR2pK4Vb2eOsaWWo4s zZT8u^bI21mm-{rNox%Z_w7AT1qfJTbGpBa;5IoQiAc>V#}_^GStp^slEj7 z{zXd(#%HS^TsO}%Uar&&T1qfJTbGHHW{WM=ucNKmoIt`M7@w`Tfalx z-s(!-t)&Fxvo%;^OZ91K>rpKw7@w^npDp^!mHMfc5{%E*aEUE7PNA(CdiW<8pRMga zTZg)q_qkH1Ybn9_Z0!&!*1bG#iVVJ_#=^W?qooAnv$YdkH*fsM4M$&brM7A*!T4;A zh?L{6`g;r4s&Nx--K3=i2NFTCtZy+=z4#%Jpak#gFULtk3|J6G!CT1qfJ zTf2O={-SxqL09VUw3J|cwswn@Qy*^l_9tyu>LD#97@w_CpRMP<-t@35^(`$W7@sY6 zh*iqt!dmvkmSt+3%e(JuDZ%(`?E%;I*N<~M60X!yEhQMAEg1#Nd<(U=Tzm6sHSXr! z>9hH(-r7Jf#nZPL2i3K8(q${2aHZC0DZ%(`O&BR^WxUjU0`D?fN-#cKli<3x7JuOz zvs|fNT1qfJTYHTZwbPcGm*Cw^T1qfJTl>IuZT-iSi`TnSAJtNV@!8rhQcj-##6AD| zlA5=ntp~J}V0^Z&^w~OT|G)mND|J{)3C3sZDxWR3DQa$qwtl6h1mm-Hwa=Dy?n{HN z)CsI6aR|m|>usQ_`FZv?+CI8}p(_>AQiAc>db>!GO{vc`zV}gAYL}K0jL+6JBIT5? z=N|e57MRk*CF^}!N-#cK@9^1r`T33qU8zU4lwf?et~IuBVSVbl^sm*N9`Ammr3B-% zH3hDlH=3HSea4kqIG3`PHHANafBrgB0;k|NfWQB~{Cez;x~pH@G|U-|5Wpkyc^Y0g7Mk90bDm;Pc549L09T#EhQMAts6zk zse5m1I_W*G)W@`xV0^aT<+GK%=enpX^<^z37@w`1M9Rq<8;)kraHYPZr3B-%b+gY_ z!-|F`SL(M~N-#cKw}{k<_@%!-)Zh4PHCKrnYwkS$$|6bhvZp@$Gf>?$oDq2R9#?9) zmJ*E5)&Y_7)*EUrmo~y$N-#cKxB6^dlY8PuSL#wNB^au)CO~m4_@55kCVH9$g?+j{ z$cH)=`tH+O4>5kJcZ(GBGmplr{%M6P^ZNHm1Yr zaI~i@)X`|$QT}wSl;2kV?%~fkf5!N8Ie&)vGsvGw{&Wa%7cWQnvyDHyLyn0^B-Cw3 zW6ADlMohSZSBmsn`E87*d7j{ps2bqaKK_Wgj&@#lG)BVe98JktQP+k{3V7q|+l{R{4Vq75jWT)y5`Xv(sz`p^Zj6LmLz6?qsSf9>Uva9qnr6{UK~b+|e%CfvFdX z4wHJbn;T0OC@L{BW0G65V=3B=vJkxWcY^)jEa zVWbhgjfu{9j~zAAvK4ekyWZQoqusN)w^yvQE0&0)~~u-ru{Uoxw&5VTW%g zxJYnUwlmb-o$icoOvRi4Ym+GX-0Hid9g80syG7}Uy{U(FscepRg}M^mv5j5nw4*5^ z+h0reP#a*YOsnGH1|b}Z$2;wGIMe9}>LADt*s!g(!0u?5J+S>j&`W!Jv$jmVdkNbH z2Cv{sz{lKbxlkAw9G@(VjBP9M)l7gVCWl7G3S7*3Y_zb?ne;CdMt1LUv@26WiC}TL z$>BJ*?6x6GOcslH^IqR>!h%i0*Y^=7UYG3Zttp+ulV*E&mlQz&a+A=lNtwOlJBCTr z_qpN8Vu&W?M|Ka7?Zql6>b=c^vx=3zWyL1dyJxio4~t8vct7^@uqef^oINCG!4(gQ zD9?xZMI6ZM4^}-4twl4OR2~@}fhO^TTdS!O&ngw^(3w*SIUd}*yY4D|Vf8vzOS^k77izro6oCiyllpso#IJvb{ z*lR-Z)n_6i201BquuS}hI>NsNUS>(M*mtyGfw|oeN98@ zj&}K;h65>QP=L;8XEKpabtjaNw;wIv*>tq?LmTvu$MCal82!>hVmD$H#-}pAE{N)U zT(Ej|gZF4zwW_^!?ds+=esV)gbMvZIs~Q?w+nU=}ion*Ip?5V}U%fm$_(=@)x9Ner z_YHQEeugQVd!5NOjj?L#eD6Pzycv@oAEKwA_!rphpNacLvZ&zb~<~0h#xwwY9 z%vSIFROGw_ySD*z-GvHw0#2d2Qhk_Uu`XMuFwSo|eaoS561WeoS13;2m($lm_6CJ< ze#_}=gT5BvhA&d6>GWYL$9ha-j;HUxfjc*JY<&#hyER53%cmc|ZT%{6uhO5V1{{px}kz?!I3ikO?g>in%=?fuzw*vQgOrfR=-(_Go#~n@TTuvX?4!#Yz z$GQ||2~Oqwy9o3r5(?w|mea?#`F;f4A2uq~bm3bD_O@pK(d zvwM!OkNIySaPLSRU*C^3#?d-m_-3T>?oQ_T`u<8|j-`*`I|SUT7Z>UCyq7}`=TW!v zwG7V@s%s8;XM)L^gTI}?O=>Lb4Z#)Zs{{S6*QxL0!2NBpKF>D?P-QXc9xu_C33Lf&~*vQX7pt;IOjlb*R%;u?^C?<&Ia6=qc37er%myEmCnCc+n< zv3KvtP!qneJmYndArk4y7h%)MXv*%1q{VPj`6A@Hk7C1c-gKE(1d zjbOltsPH0kvAmR3ET5*h!6I%n9qGk9FdrSk>EJerIZ;&vYP zRsy|RA{0&JGD&+&B%O*UIt#gook}KBu|hf%x!~!(rv*~0Zma@ai7}iQs;EH2{d+g1HFaowI5zTjDy=WyQ@xUAdxN`fp(4cMW7gqa+iwQ$uv@|FP((9 zvG=Gl;fq7DSUjDL#0tHsM8050A}BTmJDEi7qC~5`@j1RIJe*6%^Mwfd3ui(_y+kmK zJg#enI4`G=MsKWAq;Jy_62^@CHQc8keeij8ds{zY2pwbHn$2wsry(yJU zqi7+QnZV5O!W;w)`9L$hpjayE-~_~+#}HR}K|X_#bWa9eNab@_HcWx5z2HO&iIGIs z?(`tf(a2d|q{p@g>LhH97uuVnK0DGCi$>C!Em$>HS)T0$<)9F-Z0zFRSS~M>1*0;@ zi-{!dTn;6@4`o?OkCVc4y{H~Mb;@ta#9SEjGnHXGLf73Apg1Z8)=n<=ERC)8VkHf8 zTT%!<>LID8SesF2ofn5V_)$)J)O%5)tv6#b0GkV{n(qZEzTEO=iiO-0yxcxiaPdSeTAHj*4qEJmD@!UHCDRd=SZo-m z_(U%<8q;Q-BtOZ^W$GYIw5qD)tkm7qvc!vHeTw|d`Z=9T&^2~GkGy8`_sL!~{Ed1# z8)Ki*iI8=+4&5nUWF(24hH73)L@J+P^WtQ;Q@y}MZ>l?m^6X|Iwo(k|Xrd<>cy~@%;d9dymQ9P8D2yro$gM=3Mg%P zX{e~;Oh2F}W23>!q?3urmICUsSfUTDniKa%KUit&&7fbD%K_%(iDl(rXyRF&OLCc1 zKWkc~ij4uDJuNUBV;gIL%clh*4SO4j!`!^uRh3w5ul`kjo{=Edn=n!iSOYU*|`GM7vCZZ4qEhEYj%Bhu^` z($}kes8|-&U%@Guu5|~!+J{ah;_+CtP|{2}<#~-4y{avYehqS@8W5bQ?fWoj@A4+& zto2HxxG`+eLbKstSeD;n`0L8@TMd7GS^i4H-%ys{X80GC<+mGtM_K+V!w;3^uQq(U zEPsvRhs*NU8h)fK-!}YcS$^2?V`cdf!;hEcM-9KTEZ^;Cc9rGFP0f-h%f}~dPDgZO zc|eN+be9LT8bGo4#cWS}s3gh*^N zTghY`Enp`rRn_e)HDsP9CjoeA7SZ7rJdgbu^h%lY#p-+@dh#T{Fq*pc!{L})cOHkX+)AeUrBpvnC}N% zg08=~a)Swh$T&^%A_SYPfQShzn#zfXNv?3oiA-Ocp$C2RRp?w+)h`eWsdO}kp|OlD z4LM*5850K__2Ye0g~pn}M5FhXO@xsYGHF3ILB+_UsgT(L(kc}#!eI~Ggf0=L4%qJ^ zbA~p6UK^4YZEq}#E^Z7<0V@7XFJDF)l&VrxxP&83WC#R2hm50iJ8`PkhSNO~cxHYI z&r)P(D#L`c#!pw?VR@y{>>_47Yj=uPc9%~D0MDp;l1wK$wcsQe%Obe}A6Jsc5v=gB zkkv&kr^6^1^l?p?nQ6(c^t1C(aS=H)e4I=|qB&QBq6Stn6{7kxIq61_>5QL+srq!% zqUL16i3n!|EeN z#;`L`R>lh_cr1N$oCFk+kmuL=s1l!c89XLKu!L?SAE zXEL1OtS~qmRG?>Bv#E(J6ANcVtIX%K3MZp6lv5T(s&j_4g4!I-V!|we`45vfobjyi zow}0|8JlXZ48fQo=D3tNdTM8zx zI2dOf>%o{D!vQ$;I3rlWz^k!rCY#8il8c(c;0$90;)IrM)jG&qR&IEF-|)D-XV0#Y zL3x2$D#o<%5<|O&b36A=4vp;}6@80A#`LtEg$WEs( zEk+70wJ=aQqD?_P$P&d_XG&pWT9`ULW%^a}2AP1bitsYn;f0h5Ge zOhXG<@-R{&hap}JGo)yT=tM%Q9hDsN3q%80VG%G(1L*of9HTT-0gzjxxrl;dN)B0| zWoK)yC4 zb?UBnlsGA_1s#3!HD5=atx*DEaBr@+pdXM)!8uc?mUji%_ztV+uWXCWC$^n@VElc#R9nn4as3OHqkQ{Z65I9u9hUlHWeN5PRQi;tAA@dBxiM|`Z3pA$IV7l`8jA^0@PCLZ$ zmCSrQO6!b(j6m2}=hM2W=8P~6*BeZ4DpJVVm^NS>Pz6T1EywbF1M0-1D%P~9zN8(M zIvG_uYY#m;M6C;qK;90AF~SLF)0<=<#TtZ&g$5zBEi#=(`XWPjvV^WJIMaoPFPKD^ z!5Fb8lwgywP8$=G9KXRO95NcGE;eBG!3n4uYwv`kUS zfQa;&nvSl8oio%bO~vy!q;WlTv;d3Ye54S;+=6{*sIlJThh;^X-^8U}#Ci&^=O!XX0qtgzkVbJ_mRUZ6zhJ1Y;Zy#hFe1 zkYW5SR8J^Q2N?A)OF~~Fo9{({*-DU%T9@PuDrSep#3l>%Em`P*IUF|M zyFwUKL5MARr`H~4Mohnj2}PzcMrK!cvPT+%591vtgs)#rrmSse$}z-iOhoNd_Th7AdAgFgKH0L#lj0 zC+SYo9FpLagpDy9ok8MU5}j!h$7mgii53%xg>t_}oJFBV-s{55OifzFlr<$($p@;C zuLT_y!j@bnhN8viPEwRfMxrS)D{M}HFrCRjrJxwj+_d2!1ziyt3)41bP%kJBDzi>K zU?CmVf~LbW9IJ8w&EEYoFfpx{=BO%cV+hiNceoOHJkG!qi>MUTMFNSUPb>8q3W%D0 zB0XRkI?D)eBvX=C;qs8y!eVcNtf0$chm;k)bO*_+ba{!M3}*TgdGz$q-pNz+4l&9$ zP(3oFcn(=KgP{?cuPqqZS4%D{l*?p@Pjx-VVUq(poIzOrsy)N-XSGyFpfmrX^z{ji zRVQe)!pI{ZRM+!m$nlAhtA`7d$c*Yf$~lJup39+`sg_qmj`d=QdIe)4kO}B7zyQVv z?8TrGt_5`gEZ|LwPEkl0howL<+U&!jm**JnHMn}YMJgVU@|6}EF>b> z<}xulF^Sdr3eC;UEhq@p^;}UdgJA{BQMEiDF_!oyl_Ud;Jv$7nf>7!u8I~fD`|$$) zIFeyDBzZ40FK6Rs1q3`PQ1a@Ayn}KYfDzFwGbrrEvASTJ4_C${bn_WH#!+lEz(#lr zh8%MtIvaIKCbEe&0PW8QPk@e(Bx&$rIL$1j8N^FkQq*+1bB-rYdC^6m<}m0k)FB24r5n}!QqL>*m&2_cxvx%d^$K79o{}NI?TP+tLx8zjQCwN)H9$t44U(3M->w} zP>&D9t4yH1BcqcotB_(R1H;O&Y%XOCSd*aGNbkXkkyt~Fc;5hRm~O^X%#>sXmU2W; z6?222y)`h$Af2QTP%2rOQ3x{7eQ8t_R5=NivP>fc$bBpBH%ZRmT?4U__$)*mB{4x| zh?Efit4*Yl{4vJrx+l{ z%$lsKV9~9sj2FbysCTMm{skD%)Qc2v27uWmsq@QOxL*x*Y%GrP$``sn2!%3>u5t>+ zN7S7NvUnez2)w-%&GkqJ0Hs%wjR_^$lA-2{ZVa_~-A;VbuBhnZh%Xr1w?ZtbRv2E1}TwfOb`jDGa)P z^VUWpcq#<>aveg_nM{ZA!dC{ZYZqEm7|Kcf!L?LDV6rb@YETqjWTnNf6VpTbO_DR{ zW+$Sw$HjV>Z&$V=A2P3TUK%2tD92lfYJ#05eh+|>JqhCUjMSu@sM2*QlZ{OZgq>!} zq=l3viIVja^kf2T%rH3`c-NB8t%yAJ?2{*bmwgjP_#%B>VAlS>fB#SV7oPCi zmp*Fu{`xg6qVpc1$DVDnA8P;ir~dqH_dR{rBcVfTN4UDcN3NWATkD1Cl@EOF#M~o~ zbz&inRv4%YRQ8|w$VcuzGxPp+=l*ryC;sQHc%xeAz1Lp)-Orx6;JJ^TH}kn8r$2i) zHbocu;kP~g*wO#G{iUl8oWA()Z@m=Bc`Cjts0*C--l0dXd+FjEUR&S!>A(5p?B8LP z3!%qTgG+wA`K9w`?K$NK*S5d>Rj&F@{4YN;aqri@wcxc^Yice%ykae?%gP|>gV(%w zYW=G>+n-)uab?@13z{vfN9eEpV*kol?r&MV#roVl>w>4hjARu0c>J>WKl%CZ-8l2) zul@d&o6dg?3)l<&>wWirzpv@9KXA?Zxi^32_WvBkikV2CxqN9ja$$dFd~C<~!0rZq zBtFrw{K_?}>KTGC#I|qM;kFU-!2(_a{aNckLY-#${7;Q_I@sww9*m{=K`oInT)0 z;N-5Roo|AsiLt>eTHm-PY$JrWVPbM8K7}8e7}zuNMpfd2{C@R~)|;Ve5G!Ty6Mwa6 zYhmJz>J%qn?UUg*sAvNHh2bGabYK_O^LT^W_A=3&sP2DLQcnkvQJtI^dZXc!WE-7) zqiQ6Yljx^H(X?Awsm~+S>-B?gsG#UHK(Rw_U~K%2hJJTHa^cwcRjQDnI(Pwp{K96Y zm8^dsTIH@=`nh@UWMkbXY#`mx`mBB6p##6~I`D#h{ma$+8tey9msnl5@gpgm=JIre zKMzpJuPSeRX!2}q<-2`*?ddm=Y}vOhTx%bAELwYCWvhMkpndoUcFlLA>kf_otn0vJ z z49^I7alxyN&_@CR>vFkY0RBbw4RS4CgbJROJ8duoHP$8dRNaplo?^|fYam%4bd)|q z^$2TyeKT&E7U=-ff)svw$@r!NjPF8FLbzjRARTbx#68nxi{Q;5I|uzx4a+p5zhkp@ zTGkYOgTPNQL3iPNI?l*RQ#3S&a|h1w-BbqW37i>GEZ#SDKF<6$Qf(p3s~T(2(01sn z8p>!Kq~xl`y3^3uIZ(16Gqk@lv_}l>pAGFhhW4zXy=Z9vV`xFdRfVrgU)5M=8rs>0 z_8~+2sG-%~e{n_a{ego&stZ1e-Lk7+tgVYSRzE^NzJR~O_*+$!%@>2lgE_4O9#e-m zo6A>8l3$y^FPFO)m*lhsP{Xh1n9R(DA-Ud;TotaTBbA{l$w|U0{n0szXxdddX&&+o zDIxr&1KTkP!QuXIH3cU*7$;^KenQN`&f{BfJ`gHpZpE374B<~X zl2%E5dK|`baLin3){l?Hx&JH{YCm#G|^}!!h&&H)) zaqvg#A}AMSN?Up6=yo~AkO4J ziZdN~2xpecujAZ|^EYs&VOz zlrt4=P;-?t6^+hRI670&=uAbUGZl@_RJ2&_eTVGY`wn&u9&QYD1)sXP!ai{DsUwYn zo5KNI9XwLOOA-$r3Gy;1mzBJ%l*<{soFSJp?SsFlY7E#@KLlxJ^yZCKreB1~m6GoN zR?v79@VBPK@BDPy|CKtX*3f~T$qv#GRuYx|v)ljQDp_L^y2|zUXG`z<6<7&aZtr_@ zfcAN8Jx)KVUiXS~b^IG^x7W^FcWgcQlg@C^M@2B>ksmu$*HnE|@ohI5%oy z5T|^ucGbLS2b+1HSJx7_Hje|q@mTprjlK#uWHojF?!&8 zT?d|8`B?10(~;Xw2}ajFJ8@C!w#p^7r(5=c!`#@+vd??^=^u0*{ADnFLuF0vdmh5T z@Mi0}AEHj0x~A&rW7j|SGAKtMP8@wGy6)-m$2dfEJH}5!L#U{4#YI5af!u_@wMNr&-cEScD!R}N&B-9ucOXSKD2?Dv;h+KyIi{w!OMol|Mwoghh*%_39Iff4lFc;0i z=X_+=25QC1HB0b%Pw`;$a_Cga#*gjin-mlg_Xpkl*Oh%aVr2H+i$8b7xCqn+P}Eq{ z#EJQueag-Fa}N5GnVN}*%q$1^Q*;M9`BRKvKh6y}11sZ5Wb~;GxZjF1WyohzZo~O} zoXJy}pI0^3u%V6Us~QQg!d+!(HyRvzucD>K`jnx4#?bCJv>2y{Dn0a8H#vl*L%VVb8v-VI&4Jc6=6S4wc3gw;( zn8i&Ui;j~AiwBm>lMEjf>MGUARBIfaI5R%XRBSDoA$XhKq zCW=3mX?Rs5nN-n`y@XrC2@Z|hWoWk>+MgTRPYmsdp}9^uaOmJKPQ1B>r@EUr26(Q% zd1D3IN#mq%L#%jIxePQ$pb>we>7ArTmD79bjL6Bl)~edKCkN{$8epDBLBo)mqDU9hvT{` z5Ln&uH~}u9D^J6ju3L(;%vs=k3hpuQDK2cpnOS)m&U7KOgmNLTlnWJ&E>twSP|@f@ zMWYK9jV@F)x=_*RLPaZfA?wbYQTpl*9y#%kbfJ9=7s{CNPuzt}5a)1Q=q-KEqeA5U z?{TIJU%{EKdll!?aefVFy6z~>bX^>O%5}U_u2VF+PSNN(MWgE!jjmHPx=zvPIz^-F z6fH2L!kWQ_;BZ_fzv?G}Q_!l!uez$nRgcgDwKJ{Sp(?Ak4d>R`dq9*GBYEbr5r0Zj zT~RV8v?vz2>bLgbF~b-hMGRwNaT52t@U&$cD*rKzg|?ylHv!rNFoQUIsVl%AfW!bk z#vg>fQJ@R>!}b-xH=urNu-1UiFsH0Vi-tBw!W-8=7@F#D|J3CdggO|E6oL z{wr6t^=F574dZcVzj|A16V*{kDA9$){1TR*(^$n}TT|NOsiKkvYY z_y2z3BWK=o+M*AC<1L?!-}^*hZTC|<7oM?v>fQGo{{980P5j**=dXUp%59CO*F5v7 z?_789A7-`Jg#Tmmrh7iP@rLg%?Y(bm&i>1r^PhWgebv*=I$;o2>8tnEj4-}9S$wtNw}Xlne#|GDVL z`+mA3ciVYS-nwP%r!Q7~^YbU&7TlSi9ci5Tp~v6u4KyN(Jwvtq`LC1 zIZDZ3fUB7L5AXV=LBU+ZU;O3%EV-OLT>oCs%pt+ROCYoB!Xqd{SFfHKqy`oX7kedr z{xJ}W^~@B^a*%5@PVE%u)x+xB-HU$DzE5L}RIG<3Bp6^Jbo5k}glCpuR%kn0pZFdM zc(EQz`}OF(%{}|obNJ?l=dP-+p!^o=nIjmkhUtVy?@8{_GgmO}_~o(bu1g;+)iVzq ze|YAW#EW%cFt8QBJU;urfL*Gm4xC^hK%ZlUJAOSqKjHw(^8$L5Ut}2nLo>369$jv_DX)hq({o@#s;z zU3v2lb6_yQmW0Q=OaAfSO7)xwjz66jmxPCpeO*0)wzjiM^)OZZ;W?>9&&fVLeM>k9 z#(&FOPT8LM!=rYfDwN&hnx&CPt<@lP1D6p}N4=q})sutni9!%&740mBtX&()eT z*HG@zlv#%INllq;C|}l;1%~p3rYtg)A8X3VhVna2S!^h^0Yy4VDA@VArB!2?SJiIJ z$Xs%;uJZ4_d@3lx0BZ&wb1Po^zRIh-L$^*2!T9#bV#>MuaV`GYncsA!y0nyFeEV^+ z-w_P3l=0xcaH>A!9jB#u2*zit0aVwPeM9eRSL#+RB^b-Q4(n2pO5vBs#UW-?23z ztLB21=Jp29alCcnTUM@VR&cHpACz_Czk=$NeFYo=Z=FoS`;ez^<%Q=6ab4qaymi!w z44L@@6s48DmVl|-gcGR?T_zrW5+S9Ee{=R*J!&g z@Y|jL_45x7&-qw3{`{8PoBkcm{0pF;2j(Sud~Xp657uL!rrRPUyb-Z30vxzhlzVG&Ff#1H`15KtNeKEx1rt|+&^@jQHC{q}tqO?!{JA{jJR{Yx}v^(_Uw|>zo~peAUonK*-F! zSk4!ty>X2BMy(ytHiFUPFf@;1-g^wFNx?K*&c8NeeNqIoB3gh&Egk=)) + + Form + + + + 0 + 0 + 1358 + 896 + + + + Form + + + + + + + + + 9 + + + + 电机地址: + + + + + + + + + + 监视地址: + + + + + + + + + + 长度 + + + + + + + + + + 添加监控 + + + + + + + 导出 + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + + + + + 结果: + + + + + + + + + + + + + + + + QtCharts::QChartView + QGraphicsView +

QtCharts/QChartView
+ + + + + diff --git a/subform.cpp b/subform.cpp new file mode 100644 index 0000000..f0e53ee --- /dev/null +++ b/subform.cpp @@ -0,0 +1,189 @@ +#include "subform.h" +#include + +#include +#include +#include +#include "Qss.h" +#include "libmodbus/modbus.h" +#include +#include +#include + +#if defined(_MSC_VER) && (_MSC_VER >= 1600) +# pragma execution_character_set("utf-8") +#endif + + +SubForm::SubForm(QString addr) + :ui(new Ui::Form) { + ui->setupUi(this); + + init_charts(); + QTimer *pTimer = new QTimer(this); + QString *com = new QString(addr); + qDebug()<<*com; + connect(pTimer,&QTimer::timeout,[=](){ + static float sd = 0; + if(gAsyncData == nullptr) + return; + CapData *z = new CapData; + + int ret = gAsyncData->TakeLast((*com).toInt(),&z); + if(ret == 0){ + mSeries1->append(sd,z->val1); + + pTime.append(QDateTime::currentDateTime().toString("yyyyMMdd-hh:mm:ss")); + + sd ++; + if(sd > mMaxX){ + mMaxX += 1024; + mAxisX->setMax(mMaxX); + } + } + }); + pTimer->start(100); + qDebug()<lineEdit_2->setText(addr); + + mModel = new QStandardItemModel(this); + mModel->setHorizontalHeaderLabels(QStringList() << "Name" << "Age"); + ui->tableView->setModel(mModel); +} + +void SubForm::on_pushButton_clicked() { + auto mGifFile = QFileDialog::getSaveFileName(this, "", + QString("%1-%2.csv").arg(ui->lineEdit_2->text()) + .arg(QDateTime::currentDateTime().toString("yyyyMMdd-hhmmss"))); + + if(mGifFile != ""){ + //.csv + QFile file(mGifFile); + if(!file.open(QIODevice::WriteOnly | QIODevice::Text)) + { + qDebug()<<"Cannot open file for writing"; + return; + } + QTextStream out(&file); + + // + out << tr("x,") << tr("error,") << tr("speed,")<< tr("temperature,")<< + tr("input volate,")<legend()->hide(); // + mChart->addSeries(mSeries1); // + + mAxisX->setMin(0); //YΧ + mAxisX->setMax(1024); + mMaxX = 1024; + mAxisX->setTickCount(17); + mAxisX->setLabelFormat("%d"); + mAxisX->setTitleText("point"); //X + mAxisX->setLineVisible(true); + mAxisX->setGridLinePen(QPen(Qt::white,0.1,Qt::SolidLine,Qt::RoundCap,Qt::RoundJoin)); + mAxisX->setLinePen(QPen(Qt::yellow,1,Qt::SolidLine,Qt::FlatCap,Qt::RoundJoin)); + mAxisX->setLabelsFont(QFont("",8,18,false)); + mAxisX->setLabelsBrush(QBrush(QColor(Qt::white), + Qt::SolidPattern)); + mAxisX->setLabelsColor(QColor(Qt::white)); + + mAxisY->setMin(-10); //YΧ + mAxisY->setMax(100); + mAxisY->setTickCount(11); + mAxisY->setLabelFormat("%d"); + mAxisY->setLinePenColor(QColor(Qt::yellow)); // + mAxisY->setGridLineColor(QColor(Qt::yellow)); + mAxisY->setGridLinePen(QPen(Qt::white,0.1,Qt::SolidLine,Qt::RoundCap,Qt::RoundJoin)); + mAxisY->setGridLineVisible(true); + mAxisY->setLinePen(QPen(Qt::yellow,1,Qt::SolidLine,Qt::RoundCap,Qt::RoundJoin)); + mAxisY->setLabelsFont(QFont("",8,18,false)); + mAxisY->setLabelsBrush(QBrush(QColor(Qt::white), + Qt::SolidPattern)); + mAxisY->setLabelsColor(QColor(Qt::white)); + mAxisY->setTitleFont(QFont("",13,20,false)); + mAxisY->setTitleBrush(QBrush(QColor(Qt::white), + Qt::SolidPattern)); + mAxisY->setTitleText("temperature (°C)"); + + mAxisY2->setMin(0); //YΧ + mAxisY2->setMax(100); + mAxisY2->setTickCount(11); + mAxisY2->setLabelFormat("%d"); + mAxisY2->setLinePenColor(QColor(Qt::yellow)); // + mAxisY2->setGridLineColor(QColor(Qt::yellow)); + mAxisY2->setGridLinePen(QPen(Qt::white,0.1,Qt::SolidLine,Qt::RoundCap,Qt::RoundJoin)); + mAxisY2->setGridLineVisible(true); + mAxisY2->setLinePen(QPen(Qt::yellow,1,Qt::SolidLine,Qt::RoundCap,Qt::RoundJoin)); + mAxisY2->setLabelsFont(QFont("",8,18,false)); + mAxisY2->setLabelsBrush(QBrush(QColor(Qt::white), + Qt::SolidPattern)); + mAxisY2->setLabelsColor(QColor(Qt::white)); + mAxisY2->setTitleFont(QFont("",13,20,false)); + mAxisY2->setTitleBrush(QBrush(QColor(Qt::white), + Qt::SolidPattern)); + mAxisY2->setTitleText("wet %"); + + mChart->addAxis(mAxisX,Qt::AlignBottom); //λmChartеλ + mChart->addAxis(mAxisY,Qt::AlignLeft); + mChart->addAxis(mAxisY2,Qt::AlignRight); + + mChart->setBackgroundVisible(false); + mSeries1->attachAxis(mAxisX); // + mSeries1->attachAxis(mAxisY); + + //mChart + mChart->setMargins(QMargins(0,0,0,0)); + + ui->graphicsView->setChart(mChart); + ui->graphicsView->setRenderHint(QPainter::TextAntialiasing); // + ui->graphicsView->setBackgroundBrush(QBrush(QColor(Qt::black),Qt::SolidPattern)); + ui->graphicsView->scene()->setBackgroundBrush(QBrush(QColor(Qt::black),Qt::SolidPattern)); + ui->graphicsView->setRubberBand(QChartView::VerticalRubberBand); + + mChart->legend()->setAlignment(Qt::AlignBottom);// + mChart->legend()->setContentsMargins(10,10,10,10);//left,top,right,bottom + mChart->legend()->setVisible(true);// + QFont font = mChart->legend()->font(); + font.setItalic(!font.italic()); + mChart->legend()->setFont(font);//б + font.setPointSizeF(12); + mChart->legend()->setFont(font);//С + mChart->legend()->setFont(QFont(""));// + mChart->legend()->setLabelColor(Qt::white); // +} + + +void SubForm::on_pushButton_2_clicked(bool checked) { + +} + + +void SubForm::on_pushButton_2_clicked() { + +} + diff --git a/subform.h b/subform.h new file mode 100644 index 0000000..bd22824 --- /dev/null +++ b/subform.h @@ -0,0 +1,72 @@ +#ifndef SUBFORM_H +#define SUBFORM_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "global.h" +#include +#include + + +QT_BEGIN_NAMESPACE +namespace Ui { class Form; } +QT_END_NAMESPACE + +using namespace QtCharts; + + + +class SubForm :QWidget +{ + Q_OBJECT +public: + SubForm(QString); + + void init_charts(); +private slots: + void on_pushButton_clicked(); + + void on_pushButton_2_clicked(bool checked); + + void on_pushButton_2_clicked(); + +private: + Ui::Form *ui; + QChart *mChart; + QValueAxis *mAxisX; + QValueAxis *mAxisY; + QValueAxis *mAxisY2; + + QLineSeries *mSeries1; + QLineSeries *mSeries2; + QLineSeries *mSeries3; + QLineSeries *mSeries4; + QLineSeries *mSeries5; + QLineSeries *mSeries6; + + QVector pTime; + + + QVector p1; + QVector p2; + QVector p3; + QVector p4; + QVector p5; + QVector p6; + + Config *mConfig; + float mMaxX; + QDateTime mStartTime; + bool mStart; + QStandardItemModel *mModel; + +}; + +#endif // SUBFORM_H diff --git a/untitled.pro b/untitled.pro new file mode 100644 index 0000000..e4eee29 --- /dev/null +++ b/untitled.pro @@ -0,0 +1,49 @@ +QT += core gui serialport charts + +greaterThan(QT_MAJOR_VERSION, 4): QT += widgets + +CONFIG += c++11 + +# You can make your code fail to compile if it uses deprecated APIs. +# In order to do so, uncomment the following line. +#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 + +include(G:\project\c++qt\qsswraper\qsswraper.pri) + + +SOURCES += \ + global.cpp \ + libmodbus/modbus-data.c \ + libmodbus/modbus-rtu.c \ + libmodbus/modbus-tcp.c \ + libmodbus/modbus.c \ + main.cpp \ + mainwindow.cpp \ + mdbguard.cpp \ + subform.cpp + +HEADERS += \ + global.h \ + libmodbus/config.h \ + libmodbus/modbus-private.h \ + libmodbus/modbus-rtu-private.h \ + libmodbus/modbus-rtu.h \ + libmodbus/modbus-tcp-private.h \ + libmodbus/modbus-tcp.h \ + libmodbus/modbus-version.h \ + libmodbus/modbus.h \ + mainwindow.h \ + mdbguard.h \ + subform.h + +FORMS += \ + mainwindow.ui \ + sub.ui + +LIBS += ws2_32.lib + + +# Default rules for deployment. +qnx: target.path = /tmp/$${TARGET}/bin +else: unix:!android: target.path = /opt/$${TARGET}/bin +!isEmpty(target.path): INSTALLS += target diff --git a/untitled.pro.user b/untitled.pro.user new file mode 100644 index 0000000..d5f5a22 --- /dev/null +++ b/untitled.pro.user @@ -0,0 +1,259 @@ + + + + + + EnvironmentId + {2f8149c7-6065-4889-8af2-fdde6a16f5dc} + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + true + false + true + + Cpp + + CppGlobal + + + + QmlJS + + QmlJSGlobal + + + 2 + GBK + false + 4 + false + 80 + true + true + 1 + false + true + false + 0 + true + true + 0 + 8 + true + false + 1 + true + true + true + *.md, *.MD, Makefile + false + true + + + + ProjectExplorer.Project.PluginSettings + + + true + false + true + true + true + true + + + 0 + true + + true + true + Builtin.DefaultTidyAndClazy + 6 + + + + true + + + + + ProjectExplorer.Project.Target.0 + + Desktop + Desktop Qt 5.12.12 MSVC2017 64bit + Desktop Qt 5.12.12 MSVC2017 64bit + qt.qt5.51212.win64_msvc2017_64_kit + 0 + 0 + 0 + + 0 + F:\project\build-untitled-Desktop_Qt_5_12_12_MSVC2017_64bit-Debug + F:/project/build-untitled-Desktop_Qt_5_12_12_MSVC2017_64bit-Debug + + + true + QtProjectManager.QMakeBuildStep + false + + + + true + Qt4ProjectManager.MakeStep + + 2 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + clean + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + + Debug + Qt4ProjectManager.Qt4BuildConfiguration + 2 + + + F:\project\build-untitled-Desktop_Qt_5_12_12_MSVC2017_64bit-Release + F:/project/build-untitled-Desktop_Qt_5_12_12_MSVC2017_64bit-Release + + + true + QtProjectManager.QMakeBuildStep + false + + + + true + Qt4ProjectManager.MakeStep + + 2 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + clean + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + + Release + Qt4ProjectManager.Qt4BuildConfiguration + 0 + 0 + + + 0 + F:\project\build-untitled-Desktop_Qt_5_12_12_MSVC2017_64bit-Profile + F:/project/build-untitled-Desktop_Qt_5_12_12_MSVC2017_64bit-Profile + + + true + QtProjectManager.QMakeBuildStep + false + + + + true + Qt4ProjectManager.MakeStep + + 2 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + clean + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + + Profile + Qt4ProjectManager.Qt4BuildConfiguration + 0 + 0 + 0 + + 3 + + + 0 + Deploy + Deploy + ProjectExplorer.BuildSteps.Deploy + + 1 + + false + ProjectExplorer.DefaultDeployConfiguration + + 1 + + true + true + true + + 2 + + Qt4ProjectManager.Qt4RunConfiguration:F:/project/modbus_rtu_test/untitled.pro + F:/project/modbus_rtu_test/untitled.pro + false + true + true + false + true + F:/project/build-untitled-Desktop_Qt_5_12_12_MSVC2017_64bit-Debug + + 1 + + + + ProjectExplorer.Project.TargetCount + 1 + + + ProjectExplorer.Project.Updater.FileVersion + 22 + + + Version + 22 + + diff --git a/untitled.pro.user.22 b/untitled.pro.user.22 new file mode 100644 index 0000000..5bfab8e --- /dev/null +++ b/untitled.pro.user.22 @@ -0,0 +1,264 @@ + + + + + + EnvironmentId + {8d885e72-c22b-4c19-96c6-c22b89c64d17} + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + true + false + true + + Cpp + + CppGlobal + + + + QmlJS + + QmlJSGlobal + + + 2 + UTF-8 + false + 4 + false + 80 + true + true + 1 + false + true + false + 0 + true + true + 0 + 8 + true + false + 1 + true + true + true + *.md, *.MD, Makefile + false + true + + + + ProjectExplorer.Project.PluginSettings + + + true + false + true + true + true + true + + + 0 + true + + -fno-delayed-template-parsing + + true + Builtin.BuildSystem + + true + true + Builtin.DefaultTidyAndClazy + 6 + + + + true + + + + + ProjectExplorer.Project.Target.0 + + Desktop + fff + fff + {3db38eb9-927d-43c3-abe0-ce88310c14bb} + 1 + 0 + 0 + + 0 + D:\proejct\qt\test\build-untitled-fff-Debug + D:/proejct/qt/test/build-untitled-fff-Debug + + + true + QtProjectManager.QMakeBuildStep + false + + + + true + Qt4ProjectManager.MakeStep + + 2 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + clean + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + + Debug + Qt4ProjectManager.Qt4BuildConfiguration + 2 + + + D:\proejct\qt\test\build-untitled-fff-Release + D:/proejct/qt/test/build-untitled-fff-Release + + + true + QtProjectManager.QMakeBuildStep + false + + + + true + Qt4ProjectManager.MakeStep + + 2 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + clean + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + + Release + Qt4ProjectManager.Qt4BuildConfiguration + 0 + 0 + + + 0 + D:\proejct\qt\test\build-untitled-fff-Profile + D:/proejct/qt/test/build-untitled-fff-Profile + + + true + QtProjectManager.QMakeBuildStep + false + + + + true + Qt4ProjectManager.MakeStep + + 2 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + clean + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + + Profile + Qt4ProjectManager.Qt4BuildConfiguration + 0 + 0 + 0 + + 3 + + + 0 + Deploy + Deploy + ProjectExplorer.BuildSteps.Deploy + + 1 + + false + ProjectExplorer.DefaultDeployConfiguration + + 1 + + true + true + true + + 2 + + Qt4ProjectManager.Qt4RunConfiguration:D:/proejct/qt/test/untitled/untitled.pro + D:/proejct/qt/test/untitled/untitled.pro + false + true + true + false + true + D:/proejct/qt/test/build-untitled-fff-Release + + 1 + + + + ProjectExplorer.Project.TargetCount + 1 + + + ProjectExplorer.Project.Updater.FileVersion + 22 + + + Version + 22 + + diff --git a/untitled.pro.user.4.8-pre1 b/untitled.pro.user.4.8-pre1 new file mode 100644 index 0000000..73ec0b5 --- /dev/null +++ b/untitled.pro.user.4.8-pre1 @@ -0,0 +1,318 @@ + + + + + + EnvironmentId + {8d885e72-c22b-4c19-96c6-c22b89c64d17} + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + true + false + true + + Cpp + + CppGlobal + + + + QmlJS + + QmlJSGlobal + + + 2 + UTF-8 + false + 4 + false + 80 + true + true + 1 + true + false + 0 + true + true + 0 + 8 + true + 0 + true + true + true + false + + + + ProjectExplorer.Project.PluginSettings + + + + ProjectExplorer.Project.Target.0 + + Desktop Qt 5.6.3 MSVC2015 32bit + Desktop Qt 5.6.3 MSVC2015 32bit + qt.563.win32_msvc2015_kit + 0 + 0 + 0 + + D:/proejct/qt/test/build-untitled-Desktop_Qt_5_6_3_MSVC2015_32bit-Debug + + + true + qmake + + QtProjectManager.QMakeBuildStep + true + + false + false + false + + + true + Make + + Qt4ProjectManager.MakeStep + + false + + + + 2 + 构建 + + ProjectExplorer.BuildSteps.Build + + + + true + Make + + Qt4ProjectManager.MakeStep + + true + clean + + + 1 + 清理 + + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Debug + + Qt4ProjectManager.Qt4BuildConfiguration + 2 + true + + + D:/proejct/qt/test/build-untitled-Desktop_Qt_5_6_3_MSVC2015_32bit-Release + + + true + qmake + + QtProjectManager.QMakeBuildStep + false + + false + false + false + + + true + Make + + Qt4ProjectManager.MakeStep + + false + + + + 2 + 构建 + + ProjectExplorer.BuildSteps.Build + + + + true + Make + + Qt4ProjectManager.MakeStep + + true + clean + + + 1 + 清理 + + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Release + + Qt4ProjectManager.Qt4BuildConfiguration + 0 + true + + + D:/proejct/qt/test/build-untitled-Desktop_Qt_5_6_3_MSVC2015_32bit-Profile + + + true + qmake + + QtProjectManager.QMakeBuildStep + true + + false + true + false + + + true + Make + + Qt4ProjectManager.MakeStep + + false + + + + 2 + 构建 + + ProjectExplorer.BuildSteps.Build + + + + true + Make + + Qt4ProjectManager.MakeStep + + true + clean + + + 1 + 清理 + + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Profile + + Qt4ProjectManager.Qt4BuildConfiguration + 0 + true + + 3 + + + 0 + 部署 + + ProjectExplorer.BuildSteps.Deploy + + 1 + 在本地部署 + + ProjectExplorer.DefaultDeployConfiguration + + 1 + + + false + false + 1000 + + true + + false + false + false + false + true + 0.01 + 10 + true + 1 + 25 + + 1 + true + false + true + valgrind + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + + 2 + + untitled + + Qt4ProjectManager.Qt4RunConfiguration:D:/proejct/qt/test/untitled/untitled.pro + true + + untitled.pro + false + + + 3768 + false + true + false + false + true + + 1 + + + + ProjectExplorer.Project.TargetCount + 1 + + + ProjectExplorer.Project.Updater.FileVersion + 18 + + + Version + 18 + + diff --git a/untitled.pro.user.8d885e7 b/untitled.pro.user.8d885e7 new file mode 100644 index 0000000..7b26dff --- /dev/null +++ b/untitled.pro.user.8d885e7 @@ -0,0 +1,264 @@ + + + + + + EnvironmentId + {8d885e72-c22b-4c19-96c6-c22b89c64d17} + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + true + false + true + + Cpp + + CppGlobal + + + + QmlJS + + QmlJSGlobal + + + 2 + UTF-8 + false + 4 + false + 80 + true + true + 1 + false + true + false + 0 + true + true + 0 + 8 + true + false + 1 + true + true + true + *.md, *.MD, Makefile + false + true + + + + ProjectExplorer.Project.PluginSettings + + + true + false + true + true + true + true + + + 0 + true + + -fno-delayed-template-parsing + + true + Builtin.BuildSystem + + true + true + Builtin.DefaultTidyAndClazy + 6 + + + + true + + + + + ProjectExplorer.Project.Target.0 + + Desktop + Replacement for "Desktop Qt 5.12.12 MSVC2015 64bit" + Replacement for "Desktop Qt 5.12.12 MSVC2015 64bit" + qt.qt5.51212.win64_msvc2015_64_kit + 0 + 0 + 0 + + 0 + D:\proejct\qt\test\build-untitled-Replacement_for_Desktop_Qt_5_12_12_MSVC2015_64bit-Debug + D:/proejct/qt/test/build-untitled-Replacement_for_Desktop_Qt_5_12_12_MSVC2015_64bit-Debug + + + true + QtProjectManager.QMakeBuildStep + false + + + + true + Qt4ProjectManager.MakeStep + + 2 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + clean + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + + Debug + Qt4ProjectManager.Qt4BuildConfiguration + 2 + + + D:\proejct\qt\test\build-untitled-Replacement_for_Desktop_Qt_5_12_12_MSVC2015_64bit-Release + D:/proejct/qt/test/build-untitled-Replacement_for_Desktop_Qt_5_12_12_MSVC2015_64bit-Release + + + true + QtProjectManager.QMakeBuildStep + false + + + + true + Qt4ProjectManager.MakeStep + + 2 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + clean + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + + Release + Qt4ProjectManager.Qt4BuildConfiguration + 0 + 0 + + + 0 + D:\proejct\qt\test\build-untitled-Replacement_for_Desktop_Qt_5_12_12_MSVC2015_64bit-Profile + D:/proejct/qt/test/build-untitled-Replacement_for_Desktop_Qt_5_12_12_MSVC2015_64bit-Profile + + + true + QtProjectManager.QMakeBuildStep + false + + + + true + Qt4ProjectManager.MakeStep + + 2 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + clean + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + + Profile + Qt4ProjectManager.Qt4BuildConfiguration + 0 + 0 + 0 + + 3 + + + 0 + Deploy + Deploy + ProjectExplorer.BuildSteps.Deploy + + 1 + + false + ProjectExplorer.DefaultDeployConfiguration + + 1 + + true + true + true + + 2 + + Qt4ProjectManager.Qt4RunConfiguration:D:/proejct/qt/test/untitled/untitled.pro + D:/proejct/qt/test/untitled/untitled.pro + false + true + true + false + true + D:/proejct/qt/test/build-untitled-Replacement_for_Desktop_Qt_5_12_12_MSVC2015_64bit-Debug + + 1 + + + + ProjectExplorer.Project.TargetCount + 1 + + + ProjectExplorer.Project.Updater.FileVersion + 22 + + + Version + 22 + +

A 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