From a7202c37e4a3a5789544f76cffbdb43af4e3c5a9 Mon Sep 17 00:00:00 2001 From: thiagoralves Date: Thu, 16 Jun 2016 12:01:32 -0500 Subject: [PATCH] Added libmodbus --- libmodbus_src/AUTHORS | 8 + libmodbus_src/CONTRIBUTING.md | 29 + libmodbus_src/COPYING.LESSER | 502 +++++ libmodbus_src/ISSUE_TEMPLATE.md | 13 + libmodbus_src/MIGRATION | 53 + libmodbus_src/Makefile.am | 16 + libmodbus_src/NEWS | 517 +++++ libmodbus_src/README.md | 90 + libmodbus_src/acinclude.m4 | 29 + libmodbus_src/autogen.sh | 14 + libmodbus_src/configure.ac | 183 ++ libmodbus_src/doc/Makefile.am | 85 + libmodbus_src/doc/asciidoc.conf | 51 + libmodbus_src/doc/libmodbus.txt | 280 +++ libmodbus_src/doc/modbus_close.txt | 51 + libmodbus_src/doc/modbus_connect.txt | 52 + libmodbus_src/doc/modbus_flush.txt | 30 + libmodbus_src/doc/modbus_free.txt | 33 + .../doc/modbus_get_byte_from_bits.txt | 35 + libmodbus_src/doc/modbus_get_byte_timeout.txt | 50 + libmodbus_src/doc/modbus_get_float.txt | 39 + libmodbus_src/doc/modbus_get_float_abcd.txt | 39 + libmodbus_src/doc/modbus_get_float_badc.txt | 39 + libmodbus_src/doc/modbus_get_float_cdab.txt | 39 + libmodbus_src/doc/modbus_get_float_dcba.txt | 39 + .../doc/modbus_get_header_length.txt | 35 + .../doc/modbus_get_response_timeout.txt | 52 + libmodbus_src/doc/modbus_get_socket.txt | 35 + libmodbus_src/doc/modbus_mapping_free.txt | 34 + libmodbus_src/doc/modbus_mapping_new.txt | 69 + .../doc/modbus_mapping_new_start_address.txt | 81 + .../doc/modbus_mask_write_register.txt | 41 + libmodbus_src/doc/modbus_new_rtu.txt | 87 + libmodbus_src/doc/modbus_new_tcp.txt | 71 + libmodbus_src/doc/modbus_new_tcp_pi.txt | 73 + libmodbus_src/doc/modbus_read_bits.txt | 48 + libmodbus_src/doc/modbus_read_input_bits.txt | 47 + .../doc/modbus_read_input_registers.txt | 51 + libmodbus_src/doc/modbus_read_registers.txt | 79 + libmodbus_src/doc/modbus_receive.txt | 42 + .../doc/modbus_receive_confirmation.txt | 53 + libmodbus_src/doc/modbus_reply.txt | 52 + libmodbus_src/doc/modbus_reply_exception.txt | 57 + libmodbus_src/doc/modbus_report_slave_id.txt | 61 + libmodbus_src/doc/modbus_rtu_get_rts.txt | 47 + .../doc/modbus_rtu_get_rts_delay.txt | 46 + .../doc/modbus_rtu_get_serial_mode.txt | 53 + .../doc/modbus_rtu_set_custom_rts.txt | 45 + libmodbus_src/doc/modbus_rtu_set_rts.txt | 81 + .../doc/modbus_rtu_set_rts_delay.txt | 46 + .../doc/modbus_rtu_set_serial_mode.txt | 56 + libmodbus_src/doc/modbus_send_raw_request.txt | 68 + .../doc/modbus_set_bits_from_byte.txt | 36 + .../doc/modbus_set_bits_from_bytes.txt | 36 + libmodbus_src/doc/modbus_set_byte_timeout.txt | 54 + libmodbus_src/doc/modbus_set_debug.txt | 38 + .../doc/modbus_set_error_recovery.txt | 70 + libmodbus_src/doc/modbus_set_float.txt | 36 + libmodbus_src/doc/modbus_set_float_abcd.txt | 38 + libmodbus_src/doc/modbus_set_float_badc.txt | 38 + libmodbus_src/doc/modbus_set_float_cdab.txt | 39 + libmodbus_src/doc/modbus_set_float_dcba.txt | 37 + .../doc/modbus_set_response_timeout.txt | 65 + libmodbus_src/doc/modbus_set_slave.txt | 80 + libmodbus_src/doc/modbus_set_socket.txt | 56 + libmodbus_src/doc/modbus_strerror.txt | 54 + libmodbus_src/doc/modbus_tcp_accept.txt | 56 + libmodbus_src/doc/modbus_tcp_listen.txt | 72 + libmodbus_src/doc/modbus_tcp_pi_accept.txt | 56 + libmodbus_src/doc/modbus_tcp_pi_listen.txt | 67 + .../doc/modbus_write_and_read_registers.txt | 51 + libmodbus_src/doc/modbus_write_bit.txt | 38 + libmodbus_src/doc/modbus_write_bits.txt | 45 + libmodbus_src/doc/modbus_write_register.txt | 38 + libmodbus_src/doc/modbus_write_registers.txt | 38 + libmodbus_src/libmodbus.pc.in | 10 + libmodbus_src/m4/.gitignore | 5 + libmodbus_src/src/Makefile.am | 42 + libmodbus_src/src/modbus-data.c | 229 ++ libmodbus_src/src/modbus-private.h | 115 + libmodbus_src/src/modbus-rtu-private.h | 76 + libmodbus_src/src/modbus-rtu.c | 1275 +++++++++++ libmodbus_src/src/modbus-rtu.h | 42 + libmodbus_src/src/modbus-tcp-private.h | 44 + libmodbus_src/src/modbus-tcp.c | 901 ++++++++ libmodbus_src/src/modbus-tcp.h | 52 + libmodbus_src/src/modbus-version.h.in | 53 + libmodbus_src/src/modbus.c | 1861 +++++++++++++++++ libmodbus_src/src/modbus.h | 289 +++ libmodbus_src/src/win32/Make-tests | 62 + libmodbus_src/src/win32/README.win32 | 20 + libmodbus_src/src/win32/config.h.win32 | 167 ++ libmodbus_src/src/win32/configure.js | 163 ++ libmodbus_src/src/win32/modbus-9.sln | 20 + .../src/win32/modbus.dll.manifest.in | 14 + libmodbus_src/src/win32/modbus.rc | 55 + libmodbus_src/src/win32/modbus.vcproj | 457 ++++ libmodbus_src/tests/LICENSE | 30 + libmodbus_src/tests/Makefile.am | 52 + libmodbus_src/tests/README.md | 27 + libmodbus_src/tests/bandwidth-client.c | 214 ++ .../tests/bandwidth-server-many-up.c | 141 ++ libmodbus_src/tests/bandwidth-server-one.c | 92 + libmodbus_src/tests/random-test-client.c | 245 +++ libmodbus_src/tests/random-test-server.c | 60 + libmodbus_src/tests/unit-test-client.c | 878 ++++++++ libmodbus_src/tests/unit-test-server.c | 203 ++ libmodbus_src/tests/unit-test.h.in | 71 + libmodbus_src/tests/unit-tests.sh | 19 + libmodbus_src/tests/version.c | 25 + 110 files changed, 12973 insertions(+) create mode 100644 libmodbus_src/AUTHORS create mode 100644 libmodbus_src/CONTRIBUTING.md create mode 100644 libmodbus_src/COPYING.LESSER create mode 100644 libmodbus_src/ISSUE_TEMPLATE.md create mode 100644 libmodbus_src/MIGRATION create mode 100644 libmodbus_src/Makefile.am create mode 100644 libmodbus_src/NEWS create mode 100644 libmodbus_src/README.md create mode 100644 libmodbus_src/acinclude.m4 create mode 100755 libmodbus_src/autogen.sh create mode 100644 libmodbus_src/configure.ac create mode 100644 libmodbus_src/doc/Makefile.am create mode 100644 libmodbus_src/doc/asciidoc.conf create mode 100644 libmodbus_src/doc/libmodbus.txt create mode 100644 libmodbus_src/doc/modbus_close.txt create mode 100644 libmodbus_src/doc/modbus_connect.txt create mode 100644 libmodbus_src/doc/modbus_flush.txt create mode 100644 libmodbus_src/doc/modbus_free.txt create mode 100644 libmodbus_src/doc/modbus_get_byte_from_bits.txt create mode 100644 libmodbus_src/doc/modbus_get_byte_timeout.txt create mode 100644 libmodbus_src/doc/modbus_get_float.txt create mode 100644 libmodbus_src/doc/modbus_get_float_abcd.txt create mode 100644 libmodbus_src/doc/modbus_get_float_badc.txt create mode 100644 libmodbus_src/doc/modbus_get_float_cdab.txt create mode 100644 libmodbus_src/doc/modbus_get_float_dcba.txt create mode 100644 libmodbus_src/doc/modbus_get_header_length.txt create mode 100644 libmodbus_src/doc/modbus_get_response_timeout.txt create mode 100644 libmodbus_src/doc/modbus_get_socket.txt create mode 100644 libmodbus_src/doc/modbus_mapping_free.txt create mode 100644 libmodbus_src/doc/modbus_mapping_new.txt create mode 100644 libmodbus_src/doc/modbus_mapping_new_start_address.txt create mode 100644 libmodbus_src/doc/modbus_mask_write_register.txt create mode 100644 libmodbus_src/doc/modbus_new_rtu.txt create mode 100644 libmodbus_src/doc/modbus_new_tcp.txt create mode 100644 libmodbus_src/doc/modbus_new_tcp_pi.txt create mode 100644 libmodbus_src/doc/modbus_read_bits.txt create mode 100644 libmodbus_src/doc/modbus_read_input_bits.txt create mode 100644 libmodbus_src/doc/modbus_read_input_registers.txt create mode 100644 libmodbus_src/doc/modbus_read_registers.txt create mode 100644 libmodbus_src/doc/modbus_receive.txt create mode 100644 libmodbus_src/doc/modbus_receive_confirmation.txt create mode 100644 libmodbus_src/doc/modbus_reply.txt create mode 100644 libmodbus_src/doc/modbus_reply_exception.txt create mode 100644 libmodbus_src/doc/modbus_report_slave_id.txt create mode 100644 libmodbus_src/doc/modbus_rtu_get_rts.txt create mode 100644 libmodbus_src/doc/modbus_rtu_get_rts_delay.txt create mode 100644 libmodbus_src/doc/modbus_rtu_get_serial_mode.txt create mode 100644 libmodbus_src/doc/modbus_rtu_set_custom_rts.txt create mode 100644 libmodbus_src/doc/modbus_rtu_set_rts.txt create mode 100644 libmodbus_src/doc/modbus_rtu_set_rts_delay.txt create mode 100644 libmodbus_src/doc/modbus_rtu_set_serial_mode.txt create mode 100644 libmodbus_src/doc/modbus_send_raw_request.txt create mode 100644 libmodbus_src/doc/modbus_set_bits_from_byte.txt create mode 100644 libmodbus_src/doc/modbus_set_bits_from_bytes.txt create mode 100644 libmodbus_src/doc/modbus_set_byte_timeout.txt create mode 100644 libmodbus_src/doc/modbus_set_debug.txt create mode 100644 libmodbus_src/doc/modbus_set_error_recovery.txt create mode 100644 libmodbus_src/doc/modbus_set_float.txt create mode 100644 libmodbus_src/doc/modbus_set_float_abcd.txt create mode 100644 libmodbus_src/doc/modbus_set_float_badc.txt create mode 100644 libmodbus_src/doc/modbus_set_float_cdab.txt create mode 100644 libmodbus_src/doc/modbus_set_float_dcba.txt create mode 100644 libmodbus_src/doc/modbus_set_response_timeout.txt create mode 100644 libmodbus_src/doc/modbus_set_slave.txt create mode 100644 libmodbus_src/doc/modbus_set_socket.txt create mode 100644 libmodbus_src/doc/modbus_strerror.txt create mode 100644 libmodbus_src/doc/modbus_tcp_accept.txt create mode 100644 libmodbus_src/doc/modbus_tcp_listen.txt create mode 100644 libmodbus_src/doc/modbus_tcp_pi_accept.txt create mode 100644 libmodbus_src/doc/modbus_tcp_pi_listen.txt create mode 100644 libmodbus_src/doc/modbus_write_and_read_registers.txt create mode 100644 libmodbus_src/doc/modbus_write_bit.txt create mode 100644 libmodbus_src/doc/modbus_write_bits.txt create mode 100644 libmodbus_src/doc/modbus_write_register.txt create mode 100644 libmodbus_src/doc/modbus_write_registers.txt create mode 100644 libmodbus_src/libmodbus.pc.in create mode 100644 libmodbus_src/m4/.gitignore create mode 100644 libmodbus_src/src/Makefile.am create mode 100644 libmodbus_src/src/modbus-data.c create mode 100644 libmodbus_src/src/modbus-private.h create mode 100644 libmodbus_src/src/modbus-rtu-private.h create mode 100644 libmodbus_src/src/modbus-rtu.c create mode 100644 libmodbus_src/src/modbus-rtu.h create mode 100644 libmodbus_src/src/modbus-tcp-private.h create mode 100644 libmodbus_src/src/modbus-tcp.c create mode 100644 libmodbus_src/src/modbus-tcp.h create mode 100644 libmodbus_src/src/modbus-version.h.in create mode 100644 libmodbus_src/src/modbus.c create mode 100644 libmodbus_src/src/modbus.h create mode 100644 libmodbus_src/src/win32/Make-tests create mode 100644 libmodbus_src/src/win32/README.win32 create mode 100644 libmodbus_src/src/win32/config.h.win32 create mode 100644 libmodbus_src/src/win32/configure.js create mode 100644 libmodbus_src/src/win32/modbus-9.sln create mode 100644 libmodbus_src/src/win32/modbus.dll.manifest.in create mode 100644 libmodbus_src/src/win32/modbus.rc create mode 100644 libmodbus_src/src/win32/modbus.vcproj create mode 100644 libmodbus_src/tests/LICENSE create mode 100644 libmodbus_src/tests/Makefile.am create mode 100644 libmodbus_src/tests/README.md create mode 100644 libmodbus_src/tests/bandwidth-client.c create mode 100644 libmodbus_src/tests/bandwidth-server-many-up.c create mode 100644 libmodbus_src/tests/bandwidth-server-one.c create mode 100644 libmodbus_src/tests/random-test-client.c create mode 100644 libmodbus_src/tests/random-test-server.c create mode 100644 libmodbus_src/tests/unit-test-client.c create mode 100644 libmodbus_src/tests/unit-test-server.c create mode 100644 libmodbus_src/tests/unit-test.h.in create mode 100755 libmodbus_src/tests/unit-tests.sh create mode 100644 libmodbus_src/tests/version.c diff --git a/libmodbus_src/AUTHORS b/libmodbus_src/AUTHORS new file mode 100644 index 0000000..188dcb8 --- /dev/null +++ b/libmodbus_src/AUTHORS @@ -0,0 +1,8 @@ +Stéphane Raimbault +Tobias Doerffel - CLA +Florian Forster +oldfaber +Hannu Vuolasaho - CLA +Michael Heimpold - CLA +Jimmy Bergström - CLA +Jakob Bysewski - CLA \ No newline at end of file diff --git a/libmodbus_src/CONTRIBUTING.md b/libmodbus_src/CONTRIBUTING.md new file mode 100644 index 0000000..3466193 --- /dev/null +++ b/libmodbus_src/CONTRIBUTING.md @@ -0,0 +1,29 @@ +How Do I Submit A Good Bug Report? +---------------------------------- + +Please, don't send direct emails to Stéphane Raimbault unless you want +commercial support. + +Take care to read the documentation at http://libmodbus.org/documentation/. + +- *Be sure it's a bug before creating an issue*, in doubt, post a message on + https://groups.google.com/forum/#!forum/libmodbus or send an email to + libmodbus@googlegroups.com + +- *Use a clear and decriptive title* for the issue to identify + +- *Which version of libmodbus are you using?* you can obtain this information +from your package manager or by running `pkg-config --modversion libmodbus`. +You can provide the sha1 of the commit if you have fetched the code with `git`. + +- *Which operating system are you using?* + +- *Describe the exact steps which reproduce the problem* in as many details as +possible. For example, the software/equipement which runs the Modbus server, how +the clients are connected (TCP, RTU, ASCII) and the source code you are using. + +- *Enable the debug mode*, libmodbus provides a function to display the content +of the Modbus messages and it's very convenient to analyze issues +(http://libmodbus.org/docs/latest/modbus_set_debug.html). + +Good bug reports provide right and quick fixes! diff --git a/libmodbus_src/COPYING.LESSER b/libmodbus_src/COPYING.LESSER new file mode 100644 index 0000000..4362b49 --- /dev/null +++ b/libmodbus_src/COPYING.LESSER @@ -0,0 +1,502 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + 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 + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/libmodbus_src/ISSUE_TEMPLATE.md b/libmodbus_src/ISSUE_TEMPLATE.md new file mode 100644 index 0000000..19d08a2 --- /dev/null +++ b/libmodbus_src/ISSUE_TEMPLATE.md @@ -0,0 +1,13 @@ +### libmodbus version + +### Operating system + +### Description of the Modbus network (server, client, links, etc) + +### Expected behavior + +### Actual behavior + +### Steps to reproduce the behavior (commands or source code) + +### libmodbus output with debug mode enabled diff --git a/libmodbus_src/MIGRATION b/libmodbus_src/MIGRATION new file mode 100644 index 0000000..095703c --- /dev/null +++ b/libmodbus_src/MIGRATION @@ -0,0 +1,53 @@ +============================================= +Migration notes from the 2.0 series (for 3.0) +============================================= + +The 3.0 release use a brand new API and this document covers only the general +changes: + +- the structure modbus_param_t is gone and is replaced by a new opaque and +dynamically allocated structure modbus_t. + +- the slave argument is no more an argument of the Modbus functions, you need to + call modbus_set_slave first. + +- the public header file is smaller so some internal defines aren't accessible + anymore. + +- all function and constants are respectively prefixed by modbus_ or MODBUS_. + +- the POSIX error conventions are used (if an error occured, -1 or NULL is + returned and errno is set accordingly). + +- coil status and discretes inputs are just bits and force/preset actions have + been renamed to write actions. + +We hope you'll enjoy the new API to accept the migration burden! + +============================================= +Migration notes from the 1.2 series (for 2.0) +============================================= + +Init +==== + +modbus_init_tcp requires a third new argument, the port number. + +modbus_init_tcp(modbus_param_t *mb_param, char *ip_address, int port) + +Set the port to MODBUS_TCP_DEFAULT_PORT to use the default one +(502). It's convenient to use a port number greater than or equal to +1024 because it's not necessary to be root to use this port number. + + +Pointers of data +================ + +The coil and input status are now stored in an array of type uint8_t +(in 1.2.X series, array of type int was used). So now, you need to +pass a pointer of type uint8_t to use read_coil_status(), for example. + +The holding and input registers are now stored in an array of type +uint16_t. + +These changes reduce the memory consumption. diff --git a/libmodbus_src/Makefile.am b/libmodbus_src/Makefile.am new file mode 100644 index 0000000..a0a165e --- /dev/null +++ b/libmodbus_src/Makefile.am @@ -0,0 +1,16 @@ +CLEANFILES = +ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS} +AM_MAKEFLAGS = --no-print-directory + +pkgconfigdir = $(libdir)/pkgconfig +pkgconfig_DATA = libmodbus.pc +EXTRA_DIST = libmodbus.pc.in +CLEANFILES += libmodbus.pc + +dist_doc_DATA = MIGRATION README.md + +SUBDIRS = src doc + +if BUILD_TESTS +SUBDIRS += tests +endif diff --git a/libmodbus_src/NEWS b/libmodbus_src/NEWS new file mode 100644 index 0000000..ad366bb --- /dev/null +++ b/libmodbus_src/NEWS @@ -0,0 +1,517 @@ +libmodbus 3.1.4 (2016-05-28) +============================ + +- C_PROG_RANLIB is rendered obsolete by LT_INIT +- Improve ifdef around bswap_16 for __CYGWIN__ +- Improve Cygwin support. Thanks to StalderT. +- Another round of DRY in modbus_reply() +- Rename raw_rep to raw_rsp in unit-test-client +- Fix wrong function name in debug message +- Fix handling of invalid function code (closes #315) +- Add debug message on unknown function and new unit test +- DRY in modbus_reply by improving response_exception() +- Fix typo in 3053bd0adb +- CID 69145 - Argument cannot be negative in unit-test-server +- CID 69142 - Unchecked return value in unit-test-server +- Fix CID 69140 - Bad bit shift operation (coverity) in tests +- Rewrite and rename README as README.md in tests/ +- Github's contributing and issue template files +- Fix small leak (64 bytes in TCP) in unit-test-client +- Add unit-tests.sh to tarball +- Add ./configure.scan to .gitignore +- Move setting of option inside the relevant conditional group +- Add links to new modbus_*_float_* functions in index +- Slight change to modbus_report_slave_id doc. + +libmodbus 3.1.3 (2016-05-11) +============================ + +- New bswap macros for Max OSX by Jakob Bysewski. +- Fix "wildcard address" in TCP IPv6 by Shoichi Sakane. +- Introduce offsets in modbus mappings with modbus_mapping_new_start_address. + Thanks to Michael Heimpold and Stéphane Raimbault. +- Fix address range in random-test-client. + Thanks to Martin Galvan. +- Add an option to disable tests compilation by Yegor Yefremov. +- Define MSG_DONTWAIT to MSG_NONBLOCK on AIX (#294). + Thanks to Fabrice Cantos. +- Fix building when byteswap.h is not defined by Tomasz Mon. +- Add some more macros for data manipulation and documentation. +- Remove duplicate install of modbus.h (closes #290). + Thanks to Daniel Sutcliffe. +- Move MIGRATION and README.md to dist_doc_DATA target. +- Change order of few functions in modbus RTU code. +- Add entries for modbus_rtu_[get|set]_delay in documentation index. +- Implemented runtime configurable RTS delay by Jimmy Bergström. +- Add an entry in libmodbus index page for modbus_rtu_set_custom_rts. +- Add support for user defined RTS toggle function by Jimmy + Bergström. +- Added ILLEGAL_DATA_ADDRESS tests for modbus_write_register[|s]. + Thanks to Andrey Skvortsov. +- Update documentation of modbus_rtu_set_rts +- Fix rts signal switch time by Hiromasa Ihara. +- Improve new_rtu and set_slave documentation (related to #276). +- Fix late check of ctx in modbus_reply[|_exception] (closes #269). +- Wait the server for 1 second before running tests (help Travis). +- A libmodbus context isn't thread safe and won't be (closes #246). +- Fix buffer overflow in modbus_mask_write_register (#265). +- Minor adjustments to README about AsciiDoc. +- Export MODBUS_MAX_ADU_LENGTH and documentation (ref #241). +- Explicit check against Modbus broadcast address. +- Do not reply on broadcast requests (fixes #153). Thanks to Michael. +- Add Travis support. +- Run unit tests with standard: make check (closes #205, closes #238). + This patch has been developed by Andrey Skvortsov, Michael Heimpold + and Stéphane Raimbault. +- modbus_send_raw_request: limit request length (fixes #207). + Thanks to Hanno Neuer for spotting this security flaw. +- Add new contributors to AUTHORS +- Introduce SPDX license identifiers. Thanks to Michael Heimpold. + +libmodbus 3.1.2 (2015-02-13) +============================ + +If you still want to listen any addresses in your TCP IPv4 server, you must now +set the IP address to NULL in modbus_new_tcp before listening. Now, +modbus_tcp_listen only listen the IP address set in the Modbus context (see +documentation). + +This release introduces API changes on modbus_get_byte_timeout, +modbus_get_response_timeout, modbus_set_byte_timeout, +modbus_set_response_timeout to ease writing of language bindings. + +- Rewrite documentation building system +- Fix timeouts in unit tests +- Don't flush on illegal address errors in single write functions +- Fix compilation on compilers not supporting c99 mode. + Thanks to Michael Heimpold. +- Update license for the tests in Debian packaging (#221) +- Move check of device earlier to avoid a free call +- Unit test for baud rate check and error message. +- Fix crash modbus_new_rtu when baud is 0. + Thank you to Daniel Schürmann. +- Removed function prototype without implementation + Thank you Andrej Skvortzov. +- Switch test programs to a BSD license +- Fix remote buffer overflow vulnerability on write requests +- Avoid twice connect() in source code (closes #194) +- Fix compilation with MinGW (GCC 4.8.1) under Win7 (closes #163) + Thank you MarjanTomas and SwissKnife. +- Fix TCP IPv4 modbus_connect() on win32 (closes #100 and #165) + Thank you Petr Gladkiy and Marjan Tomas. +- Fix 24a05ebd3c0 - win32: init of modbus_tcp_pi_listen (#187) +- INADDR_* macros are defined in host byte order +- Filter of IP addresses in IPv4 server (closes #190) +- Allow to listen any hosts in IPv6 (closes #32) +- Define and public export of MODBUS_MAX_PDU_LENGTH (closes #167) +- Truncate data from response in report_slave_id to new max arg (closes #167) +- Fix response timeout modification on connect (closes #80) +- New API to set/get response and byte timeouts. + New unit tests and updated documentation. +- Export Modbus function codes supported by libmodbus +- Fix bandwidth-server-one (closes #152) +- Check debug flag in RTU code +- Remove warnings caused by shadowed 'index' variable. + Thanks to Åke Forslund. +- Use accept4 in TCP PI if available +- Add documentation for tcp[_pi]_accept (closes #31) +- Fix mistake in modbus_tcp_listen documentation +- Add documentation for modbus_tcp_pi_listen +- Fix for MinGW and Windows (#144, #169, #175, #180, #181, #187) + Thanks to Marjan Tomas. +- Many other fixes (#134, #157, #158, #183, #184) and improvements. + +libmodbus 3.1.1 (2013-10-06) +============================ + +More robust to exploits, more compliant and better handling of connect/close +sequences. Windows support still broken. + +- New unit tests +- Fix remote buffer overflow vulnerability (closes #25, #105) +- Explain how to define response timeouts when many RTU slaves +- Fix receiving of incorrect queries in write_single and mask_write_register + Thanks to James Nutaro. +- Check return value of autoreconf. + Thanks to Lauri Nurmi +- Constant for broacast and test ordering +- Fix the fix of device string check +- Various changes to try to improve *broken* Windows support +- Try to fix MinGW compilation +- Portable use of bswap_32 +- Improve support of MacOS X +- Fix socket value on init/close +- Returns -1 on invalid mode in modbus_rtu_set_rts +- Protect all public functions against invalid context +- Sleep for delay of response timeout before reconnect (closes #77). + Thanks to Karl Palsson. +- Baud rate until 4,000,000 (POSIX), 1,000,000 (Windows) (closes #93) +- New modbus_get|set_float_dcba to get|set float in inversed byte order +- Remove unsupported -Wtype-limits for GCC < 4.3.5 (closes #109) +- Enable out-of-source build. Thanks to Yegor Yefremov. +- Fix alignment problem on ARMv5 platform +- Improvement to Debian package. Thanks to Alexander Klauer. +- Improve support of VS 2005. Thanks to Petr Gladkiy. +- Add documentation for modbus_mask_write_register (closes #91). + Thanks to Martijn de Gouw. +- Avoid C99 declaration in win32 section code (closes #92). + Thanks to oldfaber and endrelovas. +- Add a windows scripting host configure file. + Thanks to oldfaber and Stéphane Raimbault. +- Fix typo in modbus_strerror documentation. Thanks to Mirko Rajkovaca. +- Rename reserved C++ keywords of modbus_mask_write_register. + Thanks Tobias Doerffel. +- Another quick workaround for deficient OS (closes #63) +- Add support for Mask Write Register +- Fix missing close on socket in random-test-server. + Thanks to Damian Zieliński. +- Use nonblocking sockets on Win32 and OS X/iOS too. + Thanks to Julian Raschke. +- Fix all compilations warnings spotted by new compilation flags +- Major update of build system +- Calculate RTS activation time by send length +- Dynamic memory allocation of device name (closes #11) +- Add unit tests for modbus_mapping_new +- Add Visual Studio 2008 project files by oldfaber +- Fix missing argument in synopsis section of modbus_rtu_set_serial_mode +- Fix wrong constant names to create version number +- More compilation fixes for Windows by oldfaber. +- Fix wrong constant names to create version number. + Thanks to Denis Davydov. + +libmodbus 3.1.0 (2012-06-22) +============================ + +Major changes to handle many slaves in RTU mode, non blocking connections and +RTS flow control. + +- Fixes for Microsoft Visual C++ compiler +- Fixes for Windows. Thanks to oldfaber +- Return value of _modbus_tcp_pi_connect() on failure (closes #61) +- Avoid ioctl call on non-RS485 ports. Thanks to Michael Haberler +- Display node and service in PI and port in IPv4 at connection +- Return -1 on getaddrinfo error and print error in debug mode +- More robust way to establish the connection in non blocking mode +- TCP - Socket in non blocking mode by default. Thanks to Thomas Stalder +- Apply CLOEXEC flag for TCP protocol independent too (IPv6) +- New RTU receive() to ignore confirmation from other slaves (closes #18) +- Move RTU filtering in CRC check to avoid useless call to modbus_reply +- Unique transaction identifier by TCP connection +- Use accept4 with SOCK_CLOEXEC when available (Linux) +- Open fd and socket with the CLOEXEC flag when available +- Exception response on report slave ID wasn't detected (closes #27) +- Provides a way to disable the byte timeout (Alex Stapleton) +- Added slave ID check for response messages (Alex Stapleton) +- RTS flow control with modbus_rtu_set_rts and modbus_rtu_get_rts + functions by Torello Querci and Stéphane Raimbault. + +libmodbus 3.0.4 (2012-05-08) +============================ + +- autogen.sh creates symlinks instead of copies +- Add missing m4 directory (closes #103) +- Fix alignment problem on ARMv5 platform + Thanks to Alexander Dahl +- Remove useless test on error_recovery argument + Thanks to Carlos Tangerino + +libmodbus 3.0.3 (2012-05-25) +============================ + +- Fix another Visual C++ 2008/2010 deficiency (closes #53) +- Add -lsocket to compile on QNX +- Fix TCP PI init under Windows. + Thanks to oldfaber. +- Fix a missing free in random-test-client + Thanks again to Stefan Finzel. +- Fix OMG bug in modbus_mapping_free not freeing memory. + Thanks to Stefan Finzel for the bug report. +- Fix semicolon typo and unistd.h include under Windows. + Thanks to Andrew Kravchuk. + +libmodbus 3.0.2 (2012-01-16) +============================ + +- Update Debian package +- Documentation fixes and additions +- Add missing C++ macros in public headers. + Thanks to Bernhard Agthe. +- Protects modbus_mapping_free against NULL argument. + Thanks to Andrea Mattia +- Fix check on file doc/libmodbus.7 in acinclude.m4 (closes #28) +- Close file descriptor when the settings don't apply in RTU. + Original patch provided by Thomas Stalder. +- unit-test.h is now generated to avoid config.h dependency. +- Request for Windows Sockets specification version 2.2 instead of 2.0 + Thanks to Pavel Mazniker for the report. + +libmodbus 3.0.1 (2011-07-18) +============================ + +- Avoid useless serial_mode integer when TIOCSRS485 isn't supported +- Fix compilation failure on Windows (RS485 support) by Tobias Doerffel + +- Properly check TIOCSRS485 define by Matthijs Kool +- Rename package to libmodbus5 to fix lintian warning + +libmodbus 3.0.0 (2011-07-11) +============================ + +- Revert libmodbus licence from LGPLv3 to LGPLv2.1 to avoid + incompatibility with GPLv2 program. This change has been approved + by Tobias Doerffel, Florian octo Forster and Hannu Vuolasaho. +- Enable RS485 support only when available +- Export modbus_set/get_serial_mode functions on all platforms +- API change for read/write multiple registers function: + * modbus_read_and_write_registers -> modbus_write_and_read_registers + The function name was confusing because the write operation is performed + before the read. Take care to swap the arguments in the migration process. +- Documentation of modbus_write_and_read_registers, modbus_mapping_new/free, + report_slave_id. modbus_get_byte_from_bits, modbus_set_bits_from_byte(s), + modbus_[gs]et_float, modbus_reply and modbus_reply_exception. +- Enhanced report slave ID +- New RPM spec file to package documentation and development files + +libmodbus 2.9.4 (2011-06-05) +============================ + +- IPv6 support + Make the TCP implementation "protocol independent" by Florian Forster + and Stéphane Raimbault. +- Fix compilation on Windows 7 (x64) with MinGW/MSYS and GCC 4.5 + Reported by Patsy Kaye. +- Documentation of libmodbus functions with AsciiDoc (man and HTML) by Stéphane + Raimbault +- Avoid an iteration in flush function +- New functions to send and receive raw requests (modbus_send_raw_request, + modbus_receive_confirmation) +- Fix flush function of TCP backend on Windows +- API changes for server/slave: + * modbus_receive doesn't take socket/fd argument anymore + * new function modbus_set_socket to set socket/fd +- API changes for timeout functions: + * modbus_get_timeout_begin -> modbus_get_response_timeout + * modbus_set_timeout_begin -> modbus_set_response_timeout + * modbus_get_timeout_end -> modbus_get_byte_timeout + * modbus_set_timeout_end -> modbus_set_byte_timeout +- Fix longstanding limitation of server to wait forever +- New functions modbus_set/get_serial_mode by Manfred Gruber and Stéphane + Raimbault for RS485 communications +- Improved recovery mode (see modbus_set_error_recovery documentation) for + data link and protocol errors. +- Fix compilation issue with Microsoft Visual Studio 2008. + Reported by Allan Cornet. + +libmodbus 2.9.3 (2011-01-14) +============================ + +- Major rewriting of the message reading (no more timeouts on exception) + by Stéphane Raimbault +- New function to reply to an indication with an exception message + modbus_reply_exception() +- New function modbus_get_header_length(modbus_t *ctx) +- New functions to manipulate data: + * MODBUS_GET_INT32_FROM_INT16 + * MODBUS_GET_INT16_FROM_INT8 + * MODBUS_SET_INT16_TO_INT8 +- Fix GH-2. Read/write were swapped in _FC_READ_AND_WRITE_REGISTERS +- Install an ignore handler for SIGPIPE on *BSD + Original patch by Jason Oster. +- Fix closing of Win32 socket. + Reported by Petr Parýzek. +- Fix unit identifier not copied by the TCP server. + Reported by Antti Manninen. +- Fix missing modbus_flush() in unit tests +- Fixes for OpenBSD by Barry Grumbine and Jason Oster + + +libmodbus 2.9.2 (2010-12-05) +============================ + +- Win32 support by Tobias Doerffel +- Split source code around RTU and TCP (backends) +- Rename modbus_[listen|accept] to modbus_tcp_[listen|accept] +- Remove slave argument from modbus_new_rtu() +- Check received function code +- Fix segfault in bandwidth-server-many-up on inet_ntoa() call +- Fix unit test of report slave ID in RTU +- Fix GH-3. Remove inclusion of config.h in modbus.h +- Correctly detect if we are cross-compiling for win32 by Kirill Smelkov. +- Fix setting of the broadcast address + + +libmodbus 2.9.1 (2010-08-16) +============================ + +- Brand new API (see MIGRATION notes)! +- Remove the internal function set_message_length_tcp +- Restore slave ID (server ID) argument in functions +- Error conventions of POSIX systems and error recover +- Parity setting is now a single char ('N', 'E' or 'O') +- Report slave ID server side +- OpenBSD support by Anibal Limón. +- New read and write registers function by Hannu Vuolasaho. +- Versioning infrastructure + Inspired by the Clutter project and the work done by Florian Forster. +- Fix the broadcast constant (255 -> 0) + Reported by David Olivari. +- Fix #463299 - New functions to define the timeouts of begin and end of trame + Original patch by Sisyph (eric-paul). +- Fix #591142 - Slave id check should be disabled in TCP connection + Reported by aladdinwu. + + +libmodbus 2.1.0 (2010-03-24) +============================ + +- New API to read and write float values by Stéphane Raimbault and Florian + Forster. +- New API for slave server (see MIGRATION) +- New slave server able to handle multiple connections +- Slave only replies to broadcast queries or queries with its slave ID +- Improved Modbus protocol conformance +- modbus_param_t is smaller (2 int removed) +- Better error management and SIGPIPE signal is blocked +- Faster +- Fix #333455 - Cygwin IPTOS_LOWDELAY not supported on cygwin + Reported by Jeff Laughlin and Yishin Li. +- Fix #375926 - modbus.c:164: error: `MSG_DONTWAIT' undeclared + Reported and tested by Yishin Li. +- Fix #378981 - CRC error on RTU response doesn't return negative value + Reported by Henrik Munktell. +- Fix report slave ID request + Patch (bzr) provided by Paul Fertser. +- Fix #425604 - Conditional jump or move depends on uninitialised value(s) + Occurs on first occurence of slave timeout. + Reported by Henrik Munktell. +- Fix #457200 - FreeBSD support + Patch provided by Norbert Koch. + +Other changes: + +- The code is now published and developed on + http://github.com/stephane/libmodbus +- Waf support has been removed + + +libmodbus 2.0.3 (2009-03-22) +============================ + +- Fix CRC error when a slave RTU send a response. + Thanks to Justin Carroll to have reported and tested my patch. +- Remove an assignment in compute_response_length() +- Remove duplicate counter in read_io_status() +- Fix #274511 reported by 'Kylesch' + Invalid error check in modbus_init_listen_tcp + + +libmodbus 2.0.2 (2008-08-10) +============================ +- Fix a bug reported by email by Davide Pippa + The function modbus_receive must check the number of values + indicated in the response accordingly to the query. +- Fix #241006 reported by Jesus Hernandez Tapia + modbus_check_response() crashes on an invalid exception code +- Reduce the number of function calls (read_reg_response and + preset_response have been removed) +- Add a new unit test for bad response +- Catch the timeout even if the length is equal to a exception trame +- Test only msg_length_computed on change +- Many comments and cleanups + + +libmodbus 2.0.1 (2008-07-02) +============================ + +- Include libmodbus.spec in the tarball +- Fix #241006 reported by Jesus Hernandez Tapia + modbus_check_response() crashes on an invalid exception code + + +libmodbus 2.0.0 (2008-05-18) +============================ + +- Slave API + https://blueprints.launchpad.net/libmodbus/+spec/slave-api +- No more glib dependency + https://blueprints.launchpad.net/libmodbus/+spec/glib-dependency +- Unit testing and many test programs +- Waf build support + https://blueprints.launchpad.net/libmodbus/+spec/waf-support +- MacOS X support by Matthew Butch + https://blueprints.launchpad.net/libmodbus/+spec/macosx-support +- Unit testing (unit-test-slave and unit-test-master) +- Port number is now defined at initialisation by Dirk Reusch +- Better memory management (uint8_t *data and packing of + modbus_param_t) +- Better error management +- Declare many static functions and const arrays +- Enhance an integer division +- The GNU licences LGPL and GPL are in version 3 +- Debian and RPM packages (#224496) +- Many cleanups +- Fix #159443 reported by Stefan Bisanz + Index of incoming data in force multiple coils function +- Fix #161989 reported by Konstantinos Togias + Serial device paths more than 10 chars long (eg. /dev/ttyUSB0) don't + fit to modbus_param_t -> device char[11] var. +- Fix #188189 reported by Chris Hellyar + Compute_response_size() no entry for read_input_status() +- Fix #191039 reported by Todd Denniston + modbus.h is not installed at prefix. +- Fix #211460 reported by Todd Denniston + With TCP, automatic reconnect on error may not be desired. +- Fix #224485 reported by Todd Denniston + libmodbus does not link with c++ code. +- Fix #224496 reported by Todd Denniston + It is easier to install on rpm based systems with a spec file. + + +libmodbus 1.2.5 (2008-05-18) +============================ + +- Fix #224485 reported by Todd Denniston + libmodbus does not link with c++ code. + + +libmodbus 1.2.4 (2008-03-14) +============================ + +- Fix #191039 reported by Todd Denniston + modbus.h is not installed at prefix. + + +libmodbus 1.2.3 (2008-02-03) +============================ + +- Fix #188189 reported by Chris Hellyar + Compute_response_size() no entry for read_input_status() +- Fix #181887 reported by Jesus Hernandez Tapia. + Slave address in build_request_packet_tcp() is hardcoded as 0xFF. + + +libmodbus 1.2.2 (2007-11-12) +============================ + +- Fix #161989 reported by Konstantinos Togias + Serial device paths more than 10 chars long (eg. /dev/ttyUSB0) don't + fit to modbus_param_t -> device char[11] var. +- Structure is also bit better 'packed' to conserve memory (see the + trunk for a real enhancement). + + +libmodbus 1.2.1 (2007-11-02) +============================ + +- Fix #159443 reported by Stefan Bisanz + Index of incoming data in force multiple coils function +- Deleted useless code in check_crc16() +- Untabify source code +- Changed author's email to Stéphane Raimbault + + +libmodbus 1.2.0 (2007-05-10) +============================ + +- FIX Compilation GCC-4.0 +- Project name in autogen.sh diff --git a/libmodbus_src/README.md b/libmodbus_src/README.md new file mode 100644 index 0000000..d41e5f7 --- /dev/null +++ b/libmodbus_src/README.md @@ -0,0 +1,90 @@ +A groovy modbus library +======================= + +[![Build Status](https://travis-ci.org/stephane/libmodbus.svg?branch=master)](https://travis-ci.org/stephane/libmodbus) + +Overview +-------- + +libmodbus is a free software library to send/receive data with a device which +respects the Modbus protocol. This library can use a serial port or an Ethernet +connection. + +The functions included in the library have been derived from the Modicon Modbus +Protocol Reference Guide which can be obtained from Schneider at +[www.schneiderautomation.com](http://www.schneiderautomation.com). + +The license of libmodbus is *LGPL v2.1 or later*. + +The documentation is available as manual pages (`man libmodbus` to read general +description and list of available functions) or Web pages +[www.libmodbus.org/documentation/](http://libmodbus.org/documentation/). The +documentation is licensed under the Creative Commons Attribution-ShareAlike +License 3.0 (Unported) (). + +The official website is [www.libmodbus.org](http://www.libmodbus.org). + +The library is written in C and designed to run on Linux, Mac OS X, FreeBSD and +QNX and Windows. + +Installation +------------ + +You will only need to install automake, autoconf, libtool and a C compiler (gcc +or clang) to compile the library and asciidoc and xmlto to generate the +documentation (optional). + +To install, just run the usual dance, `./configure && make install`. Run +`./autogen.sh` first to generate the `configure` script if required. + +You can change installation directory with prefix option, eg. `./configure +--prefix=/usr/local/`. You have to check that the installation library path is +properly set up on your system (*/etc/ld.so.conf.d*) and library cache is up to +date (run `ldconfig` as root if required). + +The library provides a *libmodbus.pc* file to use with `pkg-config` to ease your +program compilation and linking. + +If you want to compile with Microsoft Visual Studio, you need to install + to fill the absence of stdint.h. + +To compile under Windows, install [MinGW](http://www.mingw.org/) and MSYS then +select the common packages (gcc, automake, libtool, etc). The directory +*./src/win32/* contains a Visual C project. + +To compile under OS X with [homebrew](http://mxcl.github.com/homebrew/), you +will need to install the following dependencies first: `brew install autoconf +automake libtool`. + +Documentation +------------- + +The documentation is available [online](http://libmodbus.org/documentation) or +as manual pages after installation. + +The documentation is based on +[AsciiDoc](http://www.methods.co.nz/asciidoc/). Only man pages are built +by default with `make` command, you can run `make htmldoc` in *docs* directory +to generate HTML files. + +Testing +------- + +Some tests are provided in *tests* directory, you can freely edit the source +code to fit your needs (it's Free Software :). + +See *tests/README* for a description of each program. + +For a quick test of libmodbus, you can run the following programs in two shells: + +1. ./unit-test-server +2. ./unit-test-client + +By default, all TCP unit tests will be executed (see --help for options). + +It's also possible to run the unit tests with `make check`. + +To report a bug or to contribute +-------------------------------- + +See [CONTRIBUTING](CONTRIBUTING.md) document. \ No newline at end of file diff --git a/libmodbus_src/acinclude.m4 b/libmodbus_src/acinclude.m4 new file mode 100644 index 0000000..47c7971 --- /dev/null +++ b/libmodbus_src/acinclude.m4 @@ -0,0 +1,29 @@ +dnl ############################################################################## +dnl # AC_LIBMODBUS_CHECK_BUILD_DOC # +dnl # Check whether to build documentation and install man-pages # +dnl ############################################################################## +AC_DEFUN([AC_LIBMODBUS_CHECK_BUILD_DOC], [{ + # Allow user to disable doc build + AC_ARG_WITH([documentation], [AS_HELP_STRING([--without-documentation], + [disable documentation build even if asciidoc and xmlto are present [default=no]])]) + + if test "x$with_documentation" = "xno"; then + ac_libmodbus_build_doc="no" + else + # Determine whether or not documentation should be built and installed. + ac_libmodbus_build_doc="yes" + # Check for asciidoc and xmlto and don't build the docs if these are not installed. + AC_CHECK_PROG(ac_libmodbus_have_asciidoc, asciidoc, yes, no) + AC_CHECK_PROG(ac_libmodbus_have_xmlto, xmlto, yes, no) + if test "x$ac_libmodbus_have_asciidoc" = "xno" -o "x$ac_libmodbus_have_xmlto" = "xno"; then + ac_libmodbus_build_doc="no" + fi + fi + + AC_MSG_CHECKING([whether to build documentation]) + AC_MSG_RESULT([$ac_libmodbus_build_doc]) + if test "x$ac_libmodbus_build_doc" = "xno"; then + AC_MSG_WARN([The tools to build the documentation aren't installed]) + fi + AM_CONDITIONAL(BUILD_DOC, test "x$ac_libmodbus_build_doc" = "xyes") +}]) diff --git a/libmodbus_src/autogen.sh b/libmodbus_src/autogen.sh new file mode 100755 index 0000000..c49e3bc --- /dev/null +++ b/libmodbus_src/autogen.sh @@ -0,0 +1,14 @@ +#! /bin/sh +if autoreconf --install --symlink --force; then + echo + echo "------------------------------------------------------" + echo "Initialized build system. You can now run ./configure " + echo "------------------------------------------------------" + echo +else + echo + echo "--------------------------" + echo "Running autoreconf failed." + echo "--------------------------" + echo +fi diff --git a/libmodbus_src/configure.ac b/libmodbus_src/configure.ac new file mode 100644 index 0000000..a568e47 --- /dev/null +++ b/libmodbus_src/configure.ac @@ -0,0 +1,183 @@ +# libmodbus package version number, (as distinct from shared library version) +# An odd micro number indicates in-progress development from Git +# An even micro number indicates a released version +# +# Making a point release: +# - increase libmodbus_version_micro to the next even number +# +# After the release: +# - increase libmodbus_version_minor to the next odd number +# +# Take care to update the libtool versioning when required (LIBMODBUS_LD_*). +# http://www.gnu.org/software/libtool/manual/html_node/Libtool-versioning.html +# +m4_define([libmodbus_version_major], [3]) +m4_define([libmodbus_version_minor], [1]) +m4_define([libmodbus_version_micro], [4]) + +m4_define([libmodbus_release_status], + [m4_if(m4_eval(libmodbus_version_minor % 2), [1], [snapshot], [release])]) + +m4_define([libmodbus_version], + [libmodbus_version_major.libmodbus_version_minor.libmodbus_version_micro]) + +AC_PREREQ([2.63]) +AC_INIT([libmodbus], + [libmodbus_version], + [https://github.com/stephane/libmodbus/issues], + [libmodbus], + [http://libmodbus.org/]) +AC_CONFIG_SRCDIR([src/modbus.c]) +AC_CONFIG_AUX_DIR([build-aux]) +AM_INIT_AUTOMAKE([check-news foreign 1.11 -Wall -Wno-portability silent-rules tar-pax subdir-objects]) +AC_PROG_CC_STDC +AC_USE_SYSTEM_EXTENSIONS +AC_SYS_LARGEFILE +AC_CONFIG_MACRO_DIR([m4]) +AM_SILENT_RULES([yes]) + +LIBMODBUS_VERSION_MAJOR=libmodbus_version_major +LIBMODBUS_VERSION_MINOR=libmodbus_version_minor +LIBMODBUS_VERSION_MICRO=libmodbus_version_micro +LIBMODBUS_VERSION=libmodbus_version +AC_SUBST(LIBMODBUS_VERSION_MAJOR) +AC_SUBST(LIBMODBUS_VERSION_MINOR) +AC_SUBST(LIBMODBUS_VERSION_MICRO) +AC_SUBST(LIBMODBUS_VERSION) + +# ABI version +# http://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html +LIBMODBUS_LD_CURRENT=6 +LIBMODBUS_LD_REVISION=0 +LIBMODBUS_LD_AGE=1 +LIBMODBUS_LT_VERSION_INFO=$LIBMODBUS_LD_CURRENT:$LIBMODBUS_LD_REVISION:$LIBMODBUS_LD_AGE +AC_SUBST(LIBMODBUS_LT_VERSION_INFO) + +AC_CANONICAL_HOST + +# OS check +os_win32="false" +os_cygwin="false" +os_qnx="false" +case "${host_os}" in + *mingw32*) + os_win32="true" + ;; + *nto-qnx*) + os_qnx="true" + ;; + *cygwin*) + os_cygwin="true" + ;; +esac +AM_CONDITIONAL(OS_WIN32, test "$os_win32" = "true") +AM_CONDITIONAL(OS_QNX, test "$os_qnx" = "true") + +LT_INIT([disable-static win32-dll pic-only]) +AC_CHECK_HEADERS([ \ + arpa/inet.h \ + byteswap.h \ + errno.h \ + fcntl.h \ + limits.h \ + linux/serial.h \ + netdb.h \ + netinet/in.h \ + netinet/tcp.h \ + sys/ioctl.h \ + sys/params.h \ + sys/socket.h \ + sys/time.h \ + sys/types.h \ + termios.h \ + time.h \ + unistd.h \ +]) + +# Check whether to build docs / install man pages +AC_LIBMODBUS_CHECK_BUILD_DOC + +# Cygwin defines IPTOS_LOWDELAY but can't handle that flag so it's necessary to +# workaround that problem and Cygwin doesn't define MSG_DONTWAIT. +AC_CHECK_DECLS([__CYGWIN__]) + +# Checks for library functions. +AC_FUNC_FORK +AC_FUNC_MALLOC +AC_CHECK_FUNCS([accept4 getaddrinfo gettimeofday inet_ntoa memset select socket strerror strlcpy]) + +# Required for MinGW with GCC v4.8.1 on Win7 +AC_DEFINE(WINVER, 0x0501, _) + +# Required for bswap +AC_C_INLINE + +# libtool +AC_PROG_CXX + +# Various types +AC_TYPE_INT64_T +AC_TYPE_SIZE_T +AC_TYPE_SSIZE_T +AC_TYPE_UINT16_T +AC_TYPE_UINT32_T +AC_TYPE_UINT8_T + +if test "$os_cygwin" = "false"; then + # Required for getaddrinfo (TCP IP - IPv6) + AC_CHECK_HEADERS([winsock2.h], HAVE_WINSOCK2_H=yes) + if test "x$HAVE_WINSOCK2_H" = "xyes"; then + LIBS="$LIBS -lws2_32" + AC_SUBST(LIBS) + fi +fi + +# Check for RS485 support (Linux kernel version 2.6.28+) +AC_CHECK_DECLS([TIOCSRS485], [], [], [[#include ]]) +# Check for RTS flags +AC_CHECK_DECLS([TIOCM_RTS], [], [], [[#include ]]) + +# Wtype-limits is not supported by gcc 4.2 (default on recent Mac OS X) +my_CFLAGS="-Wall \ +-Wmissing-declarations -Wmissing-prototypes \ +-Wnested-externs -Wpointer-arith \ +-Wpointer-arith -Wsign-compare -Wchar-subscripts \ +-Wstrict-prototypes -Wshadow \ +-Wformat-security" +AC_SUBST([my_CFLAGS]) + +# Build options +AC_ARG_ENABLE(tests, + AS_HELP_STRING([--disable-tests], + [Build tests (default: yes)]),, + [enable_tests=yes]) +AM_CONDITIONAL(BUILD_TESTS, [test $enable_tests != no]) + +AC_CONFIG_HEADERS([config.h tests/unit-test.h]) +AC_CONFIG_FILES([ + Makefile + src/Makefile + src/modbus-version.h + src/win32/modbus.dll.manifest + tests/Makefile + doc/Makefile + libmodbus.pc +]) + +AC_OUTPUT +AC_MSG_RESULT([ + $PACKAGE $VERSION + =============== + + prefix: ${prefix} + sysconfdir: ${sysconfdir} + libdir: ${libdir} + includedir: ${includedir} + + compiler: ${CC} + cflags: ${CFLAGS} + ldflags: ${LDFLAGS} + + documentation: ${ac_libmodbus_build_doc} + tests: ${enable_tests} +]) diff --git a/libmodbus_src/doc/Makefile.am b/libmodbus_src/doc/Makefile.am new file mode 100644 index 0000000..48c0819 --- /dev/null +++ b/libmodbus_src/doc/Makefile.am @@ -0,0 +1,85 @@ +TXT3 = \ + modbus_close.txt \ + modbus_connect.txt \ + modbus_flush.txt \ + modbus_free.txt \ + modbus_get_byte_from_bits.txt \ + modbus_get_byte_timeout.txt \ + modbus_get_float.txt \ + modbus_get_float_abcd.txt \ + modbus_get_float_badc.txt \ + modbus_get_float_cdab.txt \ + modbus_get_float_dcba.txt \ + modbus_get_header_length.txt \ + modbus_get_response_timeout.txt \ + modbus_get_socket.txt \ + modbus_mapping_free.txt \ + modbus_mapping_new.txt \ + modbus_mapping_new_start_address.txt \ + modbus_mask_write_register.txt \ + modbus_new_rtu.txt \ + modbus_new_tcp_pi.txt \ + modbus_new_tcp.txt \ + modbus_read_bits.txt \ + modbus_read_input_bits.txt \ + modbus_read_input_registers.txt \ + modbus_read_registers.txt \ + modbus_receive_confirmation.txt \ + modbus_receive.txt \ + modbus_reply_exception.txt \ + modbus_reply.txt \ + modbus_report_slave_id.txt \ + modbus_rtu_get_serial_mode.txt \ + modbus_rtu_set_serial_mode.txt \ + modbus_rtu_get_rts.txt \ + modbus_rtu_set_rts.txt \ + modbus_rtu_set_custom_rts.txt \ + modbus_rtu_get_rts_delay.txt \ + modbus_rtu_set_rts_delay.txt \ + modbus_send_raw_request.txt \ + modbus_set_bits_from_bytes.txt \ + modbus_set_bits_from_byte.txt \ + modbus_set_byte_timeout.txt \ + modbus_set_debug.txt \ + modbus_set_error_recovery.txt \ + modbus_set_float.txt \ + modbus_set_float_abcd.txt \ + modbus_set_float_badc.txt \ + modbus_set_float_cdab.txt \ + modbus_set_float_dcba.txt \ + modbus_set_response_timeout.txt \ + modbus_set_slave.txt \ + modbus_set_socket.txt \ + modbus_strerror.txt \ + modbus_tcp_accept.txt \ + modbus_tcp_pi_accept.txt \ + modbus_tcp_listen.txt \ + modbus_tcp_pi_listen.txt \ + modbus_write_and_read_registers.txt \ + modbus_write_bits.txt \ + modbus_write_bit.txt \ + modbus_write_registers.txt \ + modbus_write_register.txt +TXT7 = libmodbus.txt + +EXTRA_DIST = asciidoc.conf $(TXT3) $(TXT7) + +MAN3 = $(TXT3:%.txt=%.3) +MAN7 = $(TXT7:%.txt=%.7) + +if BUILD_DOC +man3_MANS = $(MAN3) +man7_MANS = $(MAN7) +endif + +HTML = $(TXT3:%.txt=%.html) $(TXT7:%.txt=%.html) + +htmldoc: $(HTML) + +.txt.html: + asciidoc -d manpage -b xhtml11 -f asciidoc.conf -alibmodbus_version=@LIBMODBUS_VERSION@ $< + +.txt.3 .txt.7: + a2x --doctype manpage --format manpage -alibmodbus_version=@LIBMODBUS_VERSION@ $< + +CLEANFILES = *.3 *.7 *.html diff --git a/libmodbus_src/doc/asciidoc.conf b/libmodbus_src/doc/asciidoc.conf new file mode 100644 index 0000000..39e67e4 --- /dev/null +++ b/libmodbus_src/doc/asciidoc.conf @@ -0,0 +1,51 @@ +[paradef-default] +literal-style=template="literalparagraph" + +[macros] +(?su)[\\]?(?Plinkmb):(?P\S*?)\[(?P.*?)\]= + +ifdef::backend-docbook[] +[linkmb-inlinemacro] +{0%{target}} +{0#} +{0#{target}{0}} +{0#} +endif::backend-docbook[] + +ifdef::backend-xhtml11[] +[linkmb-inlinemacro] +{target}{0?({0})} +endif::backend-xhtml11[] + +ifdef::doctype-manpage[] +ifdef::backend-docbook[] +[header] +template::[header-declarations] + + +{mantitle} +{manvolnum} +libmodbus +v{libmodbus_version} +libmodbus Manual + + + {manname} + {manpurpose} + +endif::backend-docbook[] +endif::doctype-manpage[] + +ifdef::backend-xhtml11[] +[footer] + +{disable-javascript%
} + + + +endif::backend-xhtml11[] diff --git a/libmodbus_src/doc/libmodbus.txt b/libmodbus_src/doc/libmodbus.txt new file mode 100644 index 0000000..d7af689 --- /dev/null +++ b/libmodbus_src/doc/libmodbus.txt @@ -0,0 +1,280 @@ +libmodbus(7) +============ + + +NAME +---- +libmodbus - a fast and portable Modbus library + + +SYNOPSIS +-------- +*#include * + +*cc* \`pkg-config --cflags --libs libmodbus` 'files' + + +DESCRIPTION +----------- +libmodbus is a library to send/receive data with a device which respects the +Modbus protocol. This library contains various backends to communicate over +different networks (eg. serial in RTU mode or Ethernet in TCP/IPv6). The +http://www.modbus.org site provides documentation about the protocol at +http://www.modbus.org/specs.php. + +libmodbus provides an abstraction of the lower communication layers and offers +the same API on all supported platforms. + +This documentation presents an overview of libmodbus concepts, describes how +libmodbus abstracts Modbus communication with different hardware and platforms +and provides a reference manual for the functions provided by the libmodbus +library. + + +Contexts +~~~~~~~~ +The Modbus protocol contains many variants (eg. serial RTU or Ehternet TCP), to +ease the implementation of a variant, the library was designed to use a backend +for each variant. The backends are also a convenient way to fulfill other +requirements (eg. real-time operations). Each backend offers a specific function +to create a new 'modbus_t' context. The 'modbus_t' context is an opaque +structure containing all necessary information to establish a connection with +others Modbus devices according to the selected variant. + +You can choose the best context for your needs among: + +RTU Context +^^^^^^^^^^^ +The RTU backend (Remote Terminal Unit) is used in serial communication and makes +use of a compact, binary representation of the data for protocol +communication. The RTU format follows the commands/data with a cyclic redundancy +check checksum as an error check mechanism to ensure the reliability of +data. Modbus RTU is the most common implementation available for Modbus. A +Modbus RTU message must be transmitted continuously without inter-character +hesitations (extract from Wikipedia, Modbus, http://en.wikipedia.org/wiki/Modbus +(as of Mar. 13, 2011, 20:51 GMT). + +The Modbus RTU framing calls a slave, a device/service which handle Modbus +requests, and a master, a client which send requests. The communication is +always initiated by the master. + +Many Modbus devices can be connected together on the same physical link so +before sending a message, you must set the slave (receiver) with +linkmb:modbus_set_slave[3]. If you're running a slave, its slave number will be +used to filter received messages. + +The libmodbus implementation of RTU isn't time based as stated in original +Modbus specification, instead all bytes are sent as fast as possible and a +response or an indication is considered complete when all expected characters +have been received. This implementation offers very fast communication but you +must take care to set a response timeout of slaves less than response timeout of +master (ortherwise other slaves may ignore master requests when one of the slave +is not responding). + +Create a Modbus RTU context:: + linkmb:modbus_new_rtu[3] + + +Set the serial mode:: + linkmb:modbus_rtu_get_serial_mode[3] + linkmb:modbus_rtu_set_serial_mode[3] + linkmb:modbus_rtu_get_rts[3] + linkmb:modbus_rtu_set_rts[3] + linkmb:modbus_rtu_set_custom_rts[3] + linkmb:modbus_rtu_get_rts_delay[3] + linkmb:modbus_rtu_set_rts_delay[3] + + +TCP (IPv4) Context +^^^^^^^^^^^^^^^^^^ +The TCP backend implements a Modbus variant used for communications over +TCP/IPv4 networks. It does not require a checksum calculation as lower layer +takes care of the same. + +Create a Modbus TCP context:: + linkmb:modbus_new_tcp[3] + + +TCP PI (IPv4 and IPv6) Context +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +The TCP PI (Protocol Independent) backend implements a Modbus variant used for +communications over TCP IPv4 and IPv6 networks. It does not require a checksum +calculation as lower layer takes care of the same. + +Contrary to the TCP IPv4 only backend, the TCP PI backend offers hostname +resolution but it consumes about 1Kb of additional memory. + +Create a Modbus TCP context:: + linkmb:modbus_new_tcp_pi[3] + + +Common +^^^^^^ +Before using any libmodbus functions, the caller must allocate and initialize a +'modbus_t' context with functions explained above, then the following functions +are provided to modify and free a 'context': + +Free libmodbus context:: + linkmb:modbus_free[3] + +Set slave ID:: + linkmb:modbus_set_slave[3] + +Enable debug mode:: + linkmb:modbus_set_debug[3] + +Timeout settings:: + linkmb:modbus_get_byte_timeout[3] + linkmb:modbus_set_byte_timeout[3] + linkmb:modbus_get_response_timeout[3] + linkmb:modbus_set_response_timeout[3] + +Error recovery mode:: + linkmb:modbus_set_error_recovery[3] + +Setter/getter of internal socket:: + linkmb:modbus_set_socket[3] + linkmb:modbus_get_socket[3] + +Information about header:: + linkmb:modbus_get_header_length[3] + +Macros for data manipulation:: + +- MODBUS_GET_HIGH_BYTE(data), extracts the high byte from a byte +- MODBUS_GET_LOW_BYTE(data), extracts the low byte from a byte +- MODBUS_GET_INT64_FROM_INT16(tab_int16, index), builds an int64 from the four + first int16 starting at tab_int16[index] +- MODBUS_GET_INT32_FROM_INT16(tab_int16, index), builds an int32 from the two + first int16 starting at tab_int16[index] +- MODBUS_GET_INT16_FROM_INT8(tab_int8, index), builds an int16 from the two + first int8 starting at tab_int8[index] +- MODBUS_SET_INT16_TO_INT8(tab_int8, index, value), set an int16 value into + the two first bytes starting at tab_int8[index] +- MODBUS_SET_INT32_TO_INT16(tab_int16, index, value), set an int32 value into + the two first int16 starting at tab_int16[index] +- MODBUS_SET_INT64_TO_INT16(tab_int16, index, value), set an int64 value into + the four first int16 starting at tab_int16[index] + +Handling of bits and bytes:: + linkmb:modbus_set_bits_from_byte[3] + linkmb:modbus_set_bits_from_bytes[3] + linkmb:modbus_get_byte_from_bits[3] + +Set or get float numbers:: + linkmb:modbus_get_float_abcd[3] + linkmb:modbus_set_float_abcd[3] + linkmb:modbus_get_float_badc[3] + linkmb:modbus_set_float_badc[3] + linkmb:modbus_get_float_cdab[3] + linkmb:modbus_set_float_cdab[3] + linkmb:modbus_get_float_dcba[3] + linkmb:modbus_set_float_dcba[3] + linkmb:modbus_get_float[3] (deprecated) + linkmb:modbus_set_float[3] (deprecated) + + + +Connection +~~~~~~~~~~ +The following functions are provided to establish and close a connection with +Modbus devices: + +Establish a connection:: + linkmb:modbus_connect[3] + +Close a connection:: + linkmb:modbus_close[3] + +Flush a connection:: + linkmb:modbus_flush[3] + + +Client +~~~~~~ +The Modbus protocol defines different data types and functions to read and write +them from/to remote devices. The following functions are used by the clients to +send Modbus requests: + +Read data:: + linkmb:modbus_read_bits[3] + linkmb:modbus_read_input_bits[3] + linkmb:modbus_read_registers[3] + linkmb:modbus_read_input_registers[3] + linkmb:modbus_report_slave_id[3] + +Write data:: + linkmb:modbus_write_bit[3] + linkmb:modbus_write_register[3] + linkmb:modbus_write_bits[3] + linkmb:modbus_write_registers[3] + +Write and read data:: + linkmb:modbus_write_and_read_registers[3] + +Raw requests:: + linkmb:modbus_send_raw_request[3] + linkmb:modbus_receive_confirmation[3] + +Reply an exception:: + linkmb:modbus_reply_exception[3] + + +Server +~~~~~~ +The server is waiting for request from clients and must answer when it is +concerned by the request. The libmodbus offers the following functions to +handle requests: + +Data mapping: + linkmb:modbus_mapping_new[3] + linkmb:modbus_mapping_free[3] + +Receive:: + linkmb:modbus_receive[3] + +Reply:: + linkmb:modbus_reply[3] + linkmb:modbus_reply_exception[3] + + +ERROR HANDLING +-------------- +The libmodbus functions handle errors using the standard conventions found on +POSIX systems. Generally, this means that upon failure a libmodbus function +shall return either a NULL value (if returning a pointer) or a negative value +(if returning an integer), and the actual error code shall be stored in the +'errno' variable. + +The *modbus_strerror()* function is provided to translate libmodbus-specific +error codes into error message strings; for details refer to +linkmb:modbus_strerror[3]. + + +MISCELLANEOUS +------------- +The _LIBMODBUS_VERSION_STRING_ constant indicates the libmodbus version the +program has been compiled against. The variables 'libmodbus_version_major', +'libmodbus_version_minor', 'libmodbus_version_micro' give the version the +program is linked against. + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + + + +RESOURCES +--------- +Main web site: + +Report bugs on the issue tracker at +. + + +COPYING +------- +Free use of this software is granted under the terms of the GNU Lesser General +Public License (LGPL v2.1+). For details see the file `COPYING.LESSER` included +with the libmodbus distribution. diff --git a/libmodbus_src/doc/modbus_close.txt b/libmodbus_src/doc/modbus_close.txt new file mode 100644 index 0000000..5a0afc0 --- /dev/null +++ b/libmodbus_src/doc/modbus_close.txt @@ -0,0 +1,51 @@ +modbus_close(3) +=============== + + +NAME +---- +modbus_close - close a Modbus connection + + +SYNOPSIS +-------- +*void modbus_close(modbus_t *'ctx');* + + +DESCRIPTION +----------- +The *modbus_close()* function shall close the connection established with the +backend set in the context. + + +RETURN VALUE +------------ +There is no return value. + + +EXAMPLE +------- +[source,c] +------------------- +modbus_t *ctx; + +ctx = modbus_new_tcp("127.0.0.1", 502); +if (modbus_connect(ctx) == -1) { + fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); + modbus_free(ctx); + return -1; +} + +modbus_close(ctx); +modbus_free(ctx); +------------------- + +SEE ALSO +-------- +linkmb:modbus_connect[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_connect.txt b/libmodbus_src/doc/modbus_connect.txt new file mode 100644 index 0000000..a4437ec --- /dev/null +++ b/libmodbus_src/doc/modbus_connect.txt @@ -0,0 +1,52 @@ +modbus_connect(3) +================= + + +NAME +---- +modbus_connect - establish a Modbus connection + + +SYNOPSIS +-------- +*int modbus_connect(modbus_t *'ctx');* + + +DESCRIPTION +----------- +The *modbus_connect()* function shall establish a connection to a Modbus server, +a network or a bus using the context information of libmodbus context given in +argument. + + +RETURN VALUE +------------ +The function shall return 0 if successful. Otherwise it shall return -1 and set +errno to one of the values defined by the system calls of the underlying +platform. + + +EXAMPLE +------- +[source,c] +------------------- +modbus_t *ctx; + +ctx = modbus_new_tcp("127.0.0.1", 502); +if (modbus_connect(ctx) == -1) { + fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); + modbus_free(ctx); + return -1; +} +------------------- + + +SEE ALSO +-------- +linkmb:modbus_close[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_flush.txt b/libmodbus_src/doc/modbus_flush.txt new file mode 100644 index 0000000..f4f9b16 --- /dev/null +++ b/libmodbus_src/doc/modbus_flush.txt @@ -0,0 +1,30 @@ +modbus_flush(3) +=============== + + +NAME +---- +modbus_flush - flush non-transmitted data + + +SYNOPSIS +-------- +*int modbus_flush(modbus_t *'ctx');* + + +DESCRIPTION +----------- +The *modbus_flush()* function shall discard data received but not read to the +socket or file descriptor associated to the context 'ctx'. + + +RETURN VALUE +------------ +The function shall return 0 or the number of flushed bytes if +successful. Otherwise it shall return -1 and set errno. + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_free.txt b/libmodbus_src/doc/modbus_free.txt new file mode 100644 index 0000000..f7b12f0 --- /dev/null +++ b/libmodbus_src/doc/modbus_free.txt @@ -0,0 +1,33 @@ +modbus_free(3) +============== + + +NAME +---- +modbus_free - free a libmodbus context + + +SYNOPSIS +-------- +*void modbus_free(modbus_t *'ctx');* + + +DESCRIPTION +----------- +The *modbus_free()* function shall free an allocated modbus_t structure. + + +RETURN VALUE +------------ +There is no return values. + + +SEE ALSO +-------- +linkmb:libmodbus[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_get_byte_from_bits.txt b/libmodbus_src/doc/modbus_get_byte_from_bits.txt new file mode 100644 index 0000000..e0828f1 --- /dev/null +++ b/libmodbus_src/doc/modbus_get_byte_from_bits.txt @@ -0,0 +1,35 @@ +modbus_get_byte_from_bits(3) +============================ + +NAME +---- +modbus_get_byte_from_bits - get the value from many bits + + +SYNOPSIS +-------- +*uint8_t modbus_get_byte_from_bits(const uint8_t *'src', int 'index', unsigned int 'nb_bits');* + + +DESCRIPTION +----------- +The *modbus_get_byte_from_bits()* function shall extract a value from many +bits. All _nb_bits_ bits from _src_ at position _index_ will be read as a +single value. To obtain a full byte, set nb_bits to 8. + + +RETURN VALUE +------------ +The function shall return a byte containing the bits read. + + +SEE ALSO +-------- +linkmb:modbus_set_bits_from_byte[3] +linkmb:modbus_set_bits_from_bytes[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_get_byte_timeout.txt b/libmodbus_src/doc/modbus_get_byte_timeout.txt new file mode 100644 index 0000000..b959a0a --- /dev/null +++ b/libmodbus_src/doc/modbus_get_byte_timeout.txt @@ -0,0 +1,50 @@ +modbus_get_byte_timeout(3) +========================== + + +NAME +---- +modbus_get_byte_timeout - get timeout between bytes + + +SYNOPSIS +-------- +*int modbus_get_byte_timeout(modbus_t *'ctx', uint32_t *'to_sec', uint32_t *'to_usec');* + + +DESCRIPTION +----------- +The *modbus_get_byte_timeout()* function shall store the timeout interval +between two consecutive bytes of the same message in the _to_sec_ and _to_usec_ +arguments. + + +RETURN VALUE +------------ +The function shall return 0 if successful. Otherwise it shall return -1 and set +errno. + + +EXAMPLE +------- +[source,c] +------------------- +uint32_t to_sec; +uint32_t to_usec; + +/* Save original timeout */ +modbus_get_byte_timeout(ctx, &to_sec, &to_usec); +------------------- + + +SEE ALSO +-------- +linkmb:modbus_get_response_timeout[3] +linkmb:modbus_set_response_timeout[3] +linkmb:modbus_set_byte_timeout[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_get_float.txt b/libmodbus_src/doc/modbus_get_float.txt new file mode 100644 index 0000000..023c0bb --- /dev/null +++ b/libmodbus_src/doc/modbus_get_float.txt @@ -0,0 +1,39 @@ +modbus_get_float(3) +=================== + + +NAME +---- +modbus_get_float - get a float value from 2 registers + + +SYNOPSIS +-------- +*float modbus_get_float(const uint16_t *'src');* + +Warning, this function is *deprecated* since libmodbus v3.2.0 and has been +replaced by *modbus_get_float_dcba()*. + +DESCRIPTION +----------- +The *modbus_get_float()* function shall get a float from 4 bytes in Modbus +format (DCBA byte order). The _src_ array must be a pointer on two 16 bits +values, for example, if the first word is set to 0x4465 and the second to +0x229a, the float value will be 916.540649. + + +RETURN VALUE +------------ +The function shall return a float. + + +SEE ALSO +-------- +linkmb:modbus_set_float[3] +linkmb:modbus_set_float_dcba[3] +linkmb:modbus_get_float_dcba[3] + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_get_float_abcd.txt b/libmodbus_src/doc/modbus_get_float_abcd.txt new file mode 100644 index 0000000..6a491b2 --- /dev/null +++ b/libmodbus_src/doc/modbus_get_float_abcd.txt @@ -0,0 +1,39 @@ +modbus_get_float_abcd(3) +======================== + + +NAME +---- +modbus_get_float_abcd - get a float value from 2 registers in ABCD byte order + + +SYNOPSIS +-------- +*float modbus_get_float_abcd(const uint16_t *'src');* + + +DESCRIPTION +----------- +The *modbus_get_float_abcd()* function shall get a float from 4 bytes in usual +Modbus format. The _src_ array must be a pointer on two 16 bits values, for +example, if the first word is set to 0x0020 and the second to 0xF147, the float +value will be read as 123456.0. + + +RETURN VALUE +------------ +The function shall return a float. + + +SEE ALSO +-------- +linkmb:modbus_set_float_abcd[3] +linkmb:modbus_get_float_badc[3] +linkmb:modbus_get_float_cdab[3] +linkmb:modbus_get_float_dcba[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_get_float_badc.txt b/libmodbus_src/doc/modbus_get_float_badc.txt new file mode 100644 index 0000000..317770d --- /dev/null +++ b/libmodbus_src/doc/modbus_get_float_badc.txt @@ -0,0 +1,39 @@ +modbus_get_float_badc(3) +======================== + + +NAME +---- +modbus_get_float_badc - get a float value from 2 registers in BADC byte order + + +SYNOPSIS +-------- +*float modbus_get_float_badc(const uint16_t *'src');* + + +DESCRIPTION +----------- +The *modbus_get_float_badc()* function shall get a float from 4 bytes with +swapped bytes (BADC instead of ABCD). The _src_ array must be a pointer on two +16 bits values, for example, if the first word is set to 0x2000 and the second +to 0x47F1, the float value will be read as 123456.0. + + +RETURN VALUE +------------ +The function shall return a float. + + +SEE ALSO +-------- +linkmb:modbus_set_float_badc[3] +linkmb:modbus_get_float_abcd[3] +linkmb:modbus_get_float_cdab[3] +linkmb:modbus_get_float_dcba[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_get_float_cdab.txt b/libmodbus_src/doc/modbus_get_float_cdab.txt new file mode 100644 index 0000000..82261b7 --- /dev/null +++ b/libmodbus_src/doc/modbus_get_float_cdab.txt @@ -0,0 +1,39 @@ +modbus_get_float_cdab(3) +======================== + + +NAME +---- +modbus_get_float_cdab - get a float value from 2 registers in CDAB byte order + + +SYNOPSIS +-------- +*float modbus_get_float_cdab(const uint16_t *'src');* + + +DESCRIPTION +----------- +The *modbus_get_float_cdab()* function shall get a float from 4 bytes with +swapped words (CDAB order instead of ABCD). The _src_ array must be a pointer on +two 16 bits values, for example, if the first word is set to F147 and the second +to 0x0020, the float value will be read as 123456.0. + + +RETURN VALUE +------------ +The function shall return a float. + + +SEE ALSO +-------- +linkmb:modbus_set_float_cdab[3] +linkmb:modbus_get_float_abcd[3] +linkmb:modbus_get_float_badc[3] +linkmb:modbus_get_float_dcba[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_get_float_dcba.txt b/libmodbus_src/doc/modbus_get_float_dcba.txt new file mode 100644 index 0000000..cd98a04 --- /dev/null +++ b/libmodbus_src/doc/modbus_get_float_dcba.txt @@ -0,0 +1,39 @@ +modbus_get_float_dcba(3) +======================== + + +NAME +---- +modbus_get_float_dcba - get a float value from 2 registers in DCBA byte order + + +SYNOPSIS +-------- +*float modbus_get_float_dcba(const uint16_t *'src');* + + +DESCRIPTION +----------- +The *modbus_get_float_dcba()* function shall get a float from 4 bytes in +inversed Modbus format (DCBA order instead of ABCD). The _src_ array must be a +pointer on two 16 bits values, for example, if the first word is set to 0x47F1 +and the second to 0x2000, the float value will be read as 123456.0. + + +RETURN VALUE +------------ +The function shall return a float. + + +SEE ALSO +-------- +linkmb:modbus_set_float_dcba[3] +linkmb:modbus_get_float_abcd[3] +linkmb:modbus_get_float_badc[3] +linkmb:modbus_get_float_cdab[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_get_header_length.txt b/libmodbus_src/doc/modbus_get_header_length.txt new file mode 100644 index 0000000..79f7cd9 --- /dev/null +++ b/libmodbus_src/doc/modbus_get_header_length.txt @@ -0,0 +1,35 @@ +modbus_get_header_length(3) +=========================== + + +NAME +---- +modbus_get_header_length - retrieve the current header length + + +SYNOPSIS +-------- +*int modbus_get_header_length(modbus_t *'ctx');* + + +DESCRIPTION +----------- +The *modbus_get_header_length()* function shall retrieve the current header +length from the backend. This function is convenient to manipulate a message and +so its limited to low-level operations. + + +RETURN VALUE +------------ +The header length as integer value. + + +SEE ALSO +-------- +linkmb:libmodbus[7] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_get_response_timeout.txt b/libmodbus_src/doc/modbus_get_response_timeout.txt new file mode 100644 index 0000000..3355802 --- /dev/null +++ b/libmodbus_src/doc/modbus_get_response_timeout.txt @@ -0,0 +1,52 @@ +modbus_get_response_timeout(3) +============================== + + +NAME +---- +modbus_get_response_timeout - get timeout for response + + +SYNOPSIS +-------- +*int modbus_get_response_timeout(modbus_t *'ctx', uint32_t *'to_sec', uint32_t *'to_usec');* + + +DESCRIPTION +----------- +The *modbus_get_response_timeout()* function shall return the timeout interval +used to wait for a response in the _to_sec_ and _to_usec_ arguments. + + +RETURN VALUE +------------ +The function shall return 0 if successful. Otherwise it shall return -1 and set +errno. + + +EXAMPLE +------- +[source,c] +------------------- +uint32_t old_response_to_sec; +uint32_t old_response_to_usec; + +/* Save original timeout */ +modbus_get_response_timeout(ctx, &old_response_to_sec, &old_response_to_usec); + +/* Define a new and too short timeout! */ +modbus_set_response_timeout(ctx, 0, 0); +------------------- + + +SEE ALSO +-------- +linkmb:modbus_set_response_timeout[3] +linkmb:modbus_get_byte_timeout[3] +linkmb:modbus_set_byte_timeout[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_get_socket.txt b/libmodbus_src/doc/modbus_get_socket.txt new file mode 100644 index 0000000..8645fa4 --- /dev/null +++ b/libmodbus_src/doc/modbus_get_socket.txt @@ -0,0 +1,35 @@ +modbus_get_socket(3) +==================== + + +NAME +---- +modbus_get_socket - get the current socket of the context + + +SYNOPSIS +-------- +*int modbus_get_socket(modbus_t *'ctx');* + + +DESCRIPTION +----------- +The *modbus_get_socket()* function shall return the current socket or file +descriptor of the libmodbus context. + + +RETURN VALUE +------------ +The function returns the current socket or file descriptor of the context if +successful. Otherwise it shall return -1 and set errno. + + +SEE ALSO +-------- +linkmb:modbus_set_socket[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_mapping_free.txt b/libmodbus_src/doc/modbus_mapping_free.txt new file mode 100644 index 0000000..0a99f62 --- /dev/null +++ b/libmodbus_src/doc/modbus_mapping_free.txt @@ -0,0 +1,34 @@ +modbus_mapping_free(3) +===================== + + +NAME +---- +modbus_mapping_free - free a modbus_mapping_t structure + + +SYNOPSIS +-------- +*void modbus_mapping_free(modbus_mapping_t *'mb_mapping');* + + +DESCRIPTION +----------- +The function shall free the four arrays of mb_mapping_t structure and finally +the mb_mapping_t referenced by _mb_mapping_. + + +RETURN VALUE +------------ +There is no return values. + + +SEE ALSO +-------- +linkmb:modbus_mapping_new[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_mapping_new.txt b/libmodbus_src/doc/modbus_mapping_new.txt new file mode 100644 index 0000000..71cde1d --- /dev/null +++ b/libmodbus_src/doc/modbus_mapping_new.txt @@ -0,0 +1,69 @@ +modbus_mapping_new(3) +===================== + + +NAME +---- +modbus_mapping_new - allocate four arrays of bits and registers + + +SYNOPSIS +-------- +*modbus_mapping_t* modbus_mapping_new(int 'nb_bits', int 'nb_input_bits', int 'nb_registers', int 'nb_input_registers');* + + +DESCRIPTION +----------- +The *modbus_mapping_new()* function shall allocate four arrays to store bits, +input bits, registers and inputs registers. The pointers are stored in +modbus_mapping_t structure. All values of the arrays are initialized to zero. + +This function is equivalent to a call of the +linkmb:modbus_mapping_new_start_address[3] function with all start addresses to +`0`. + +If it isn't necessary to allocate an array for a specific type of data, you can +pass the zero value in argument, the associated pointer will be NULL. + +This function is convenient to handle requests in a Modbus server/slave. + + +RETURN VALUE +------------ +The function shall return the new allocated structure if successful. Otherwise +it shall return NULL and set errno. + + +ERRORS +------ +*ENOMEM*:: +Not enough memory + + +EXAMPLE +------- +[source,c] +------------------- +/* The first value of each array is accessible from the 0 address. */ +mb_mapping = modbus_mapping_new(BITS_ADDRESS + BITS_NB, + INPUT_BITS_ADDRESS + INPUT_BITS_NB, + REGISTERS_ADDRESS + REGISTERS_NB, + INPUT_REGISTERS_ADDRESS + INPUT_REGISTERS_NB); +if (mb_mapping == NULL) { + fprintf(stderr, "Failed to allocate the mapping: %s\n", + modbus_strerror(errno)); + modbus_free(ctx); + return -1; +} +------------------- + +SEE ALSO +-------- +linkmb:modbus_mapping_free[3] +linkmb:modbus_mapping_new_start_address[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_mapping_new_start_address.txt b/libmodbus_src/doc/modbus_mapping_new_start_address.txt new file mode 100644 index 0000000..4fa196a --- /dev/null +++ b/libmodbus_src/doc/modbus_mapping_new_start_address.txt @@ -0,0 +1,81 @@ +modbus_mapping_new_start_address(3) +=================================== + + +NAME +---- +modbus_mapping_new_start_address - allocate four arrays of bits and registers accessible from their starting addresses + + +SYNOPSIS +-------- +*modbus_mapping_t* modbus_mapping_new_start_address(int 'start_bits', int 'nb_bits', + int 'start_input_bits', int 'nb_input_bits', + int 'start_registers', int 'nb_registers', + int 'start_input_registers', int 'nb_input_registers');* + + +DESCRIPTION +----------- +The _modbus_mapping_new_start_address()_ function shall allocate four arrays to +store bits, input bits, registers and inputs registers. The pointers are stored +in modbus_mapping_t structure. All values of the arrays are initialized to zero. + +The different starting adresses make it possible to place the mapping at any +address in each address space. This way, you can give access to values stored +at high adresses without allocating memory from the address zero, for eg. to +make available registers from 10000 to 10009, you can use: + +[source,c] +------------------- +mb_mapping = modbus_mapping_offset_start_address(0, 0, 0, 0, 10000, 10, 0, 0); +------------------- + +With this code, only 10 registers (`uint16_t`) are allocated. + +If it isn't necessary to allocate an array for a specific type of data, you can +pass the zero value in argument, the associated pointer will be NULL. + +This function is convenient to handle requests in a Modbus server/slave. + + +RETURN VALUE +------------ +The _modbus_mapping_offset_new()_ function shall return the new allocated structure if +successful. Otherwise it shall return NULL and set errno. + + +ERRORS +------ +ENOMEM:: +Not enough memory + + +EXAMPLE +------- +[source,c] +------------------- +/* The first value of each array is accessible at the defined address. + The end address is ADDRESS + NB - 1. */ +mb_mapping = modbus_mapping_offset_start_address(BITS_ADDRESS, BITS_NB, + INPUT_BITS_ADDRESS, INPUT_BITS_NB, + REGISTERS_ADDRESS, REGISTERS_NB, + INPUT_REGISTERS_ADDRESS, INPUT_REGISTERS_NB); +if (mb_mapping == NULL) { + fprintf(stderr, "Failed to allocate the mapping: %s\n", + modbus_strerror(errno)); + modbus_free(ctx); + return -1; +} +------------------- + +SEE ALSO +-------- +linkmb:modbus_mapping_new[3] +linkmb:modbus_mapping_free[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_mask_write_register.txt b/libmodbus_src/doc/modbus_mask_write_register.txt new file mode 100644 index 0000000..7365503 --- /dev/null +++ b/libmodbus_src/doc/modbus_mask_write_register.txt @@ -0,0 +1,41 @@ +modbus_mask_write_register(3) +============================= + + +NAME +---- +modbus_mask_write_register - mask a single register + + +SYNOPSIS +-------- +*int modbus_mask_write_register(modbus_t *'ctx', int 'addr', uint16_t 'and', uint16_t 'or');* + + +DESCRIPTION +----------- +The *modbus_mask_write_register()* function shall modify the value of the +holding register at the address 'addr' of the remote device using the algorithm: + + new value = (current value AND 'and') OR ('or' AND (NOT 'and')) + +The function uses the Modbus function code 0x16 (mask single register). + + +RETURN VALUE +------------ +The function shall return 1 if successful. Otherwise it shall return -1 and set +errno. + + +SEE ALSO +-------- +linkmb:modbus_read_registers[3] +linkmb:modbus_write_registers[3] + + +AUTHORS +------- +Martijn de Gouw +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_new_rtu.txt b/libmodbus_src/doc/modbus_new_rtu.txt new file mode 100644 index 0000000..34fc419 --- /dev/null +++ b/libmodbus_src/doc/modbus_new_rtu.txt @@ -0,0 +1,87 @@ +modbus_new_rtu(3) +================= + + +NAME +---- +modbus_new_rtu - create a libmodbus context for RTU + + +SYNOPSIS +-------- +*modbus_t *modbus_new_rtu(const char *'device', int 'baud', char 'parity', int 'data_bit', int 'stop_bit');* + + + +DESCRIPTION +----------- +The *modbus_new_rtu()* function shall allocate and initialize a _modbus_t_ +structure to communicate in RTU mode on a serial line. + +The _device_ argument specifies the name of the serial port handled by the OS, +eg. "/dev/ttyS0" or "/dev/ttyUSB0". On Windows, it's necessary to prepend COM +name with "\\.\" for COM number greater than 9, eg. "\\\\.\\COM10". See +http://msdn.microsoft.com/en-us/library/aa365247(v=vs.85).aspx for details + +The _baud_ argument specifies the baud rate of the communication, eg. 9600, +19200, 57600, 115200, etc. + +The _parity_ argument can have one of the following values::: +* _N_ for none +* _E_ for even +* _O_ for odd + +The _data_bits_ argument specifies the number of bits of data, the allowed +values are 5, 6, 7 and 8. + +The _stop_bits_ argument specifies the bits of stop, the allowed values are 1 +and 2. + +Once the _modbus_t_ structure is initialized, you must set the slave of your +device with linkmb:modbus_set_slave[3] and connect to the serial bus with +linkmb:modbus_connect[3]. + +RETURN VALUE +------------ +The function shall return a pointer to a _modbus_t_ structure if +successful. Otherwise it shall return NULL and set errno to one of the values +defined below. + + +ERRORS +------ +*EINVAL*:: +An invalid argument was given. + + +EXAMPLE +------- +[source,c] +------------------- +modbus_t *ctx; + +ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1); +if (ctx == NULL) { + fprintf(stderr, "Unable to create the libmodbus context\n"); + return -1; +} + +modbus_set_slave(ctx, YOUR_DEVICE_ID); + +if (modbus_connect(ctx) == -1) { + fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); + modbus_free(ctx); + return -1; +} +------------------- + +SEE ALSO +-------- +linkmb:modbus_new_tcp[3] +linkmb:modbus_free[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_new_tcp.txt b/libmodbus_src/doc/modbus_new_tcp.txt new file mode 100644 index 0000000..f446212 --- /dev/null +++ b/libmodbus_src/doc/modbus_new_tcp.txt @@ -0,0 +1,71 @@ +modbus_new_tcp(3) +================= + + +NAME +---- +modbus_new_tcp - create a libmodbus context for TCP/IPv4 + + +SYNOPSIS +-------- +*modbus_t *modbus_new_tcp(const char *'ip', int 'port');* + + +DESCRIPTION +----------- +The *modbus_new_tcp()* function shall allocate and initialize a modbus_t +structure to communicate with a Modbus TCP IPv4 server. + +The _ip_ argument specifies the IP address of the server to which the client +wants to establish a connection. A NULL value can be used to listen any addresses in +server mode. + +The _port_ argument is the TCP port to use. Set the port to +`MODBUS_TCP_DEFAULT_PORT` to use the default one (502). It’s convenient to use a +port number greater than or equal to 1024 because it’s not necessary to have +administrator privileges. + + +RETURN VALUE +------------ +The function shall return a pointer to a *modbus_t* structure if +successful. Otherwise it shall return NULL and set errno to one of the values +defined below. + + +ERRORS +------ +*EINVAL*:: +An invalid IP address was given. + + +EXAMPLE +------- +[source,c] +------------------- +modbus_t *ctx; + +ctx = modbus_new_tcp("127.0.0.1", 1502); +if (ctx == NULL) { + fprintf(stderr, "Unable to allocate libmodbus context\n"); + return -1; +} + +if (modbus_connect(ctx) == -1) { + fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); + modbus_free(ctx); + return -1; +} +------------------- + +SEE ALSO +-------- +linkmb:modbus_tcp_listen[3] +linkmb:modbus_free[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_new_tcp_pi.txt b/libmodbus_src/doc/modbus_new_tcp_pi.txt new file mode 100644 index 0000000..cb92ec1 --- /dev/null +++ b/libmodbus_src/doc/modbus_new_tcp_pi.txt @@ -0,0 +1,73 @@ +modbus_new_tcp_pi(3) +==================== + + +NAME +---- +modbus_new_tcp_pi - create a libmodbus context for TCP Protocol Independent + + +SYNOPSIS +-------- +*modbus_t *modbus_new_tcp_pi(const char *'node', const char *'service');* + + +DESCRIPTION +----------- +The *modbus_new_tcp_pi()* function shall allocate and initialize a modbus_t +structure to communicate with a Modbus TCP IPv4 or IPv6 server. + +The _node_ argument specifies the host name or IP address of the host to connect +to, eg. "192.168.0.5" , "::1" or "server.com". A NULL value can be used to +listen any addresses in server mode. + +The _service_ argument is the service name/port number to connect to. To use the +default Modbus port use the string "502". On many Unix systems, it’s +convenient to use a port number greater than or equal to 1024 because it’s not +necessary to have administrator privileges. + + +RETURN VALUE +------------ +The function shall return a pointer to a *modbus_t* structure if +successful. Otherwise it shall return NULL and set errno to one of the values +defined below. + + +ERRORS +------ +*EINVAL*:: +The node string is empty or has been truncated. The service string is empty or +has been truncated. + + +EXAMPLE +------- +[source,c] +------------------- +modbus_t *ctx; + +ctx = modbus_new_tcp_pi("::1", "1502"); +if (ctx == NULL) { + fprintf(stderr, "Unable to allocate libmodbus context\n"); + return -1; +} + +if (modbus_connect(ctx) == -1) { + fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); + modbus_free(ctx); + return -1; +} +------------------- + +SEE ALSO +-------- +linkmb:modbus_new_tcp[3] +linkmb:modbus_tcp_pi_listen[3] +linkmb:modbus_free[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_read_bits.txt b/libmodbus_src/doc/modbus_read_bits.txt new file mode 100644 index 0000000..1e7fd1e --- /dev/null +++ b/libmodbus_src/doc/modbus_read_bits.txt @@ -0,0 +1,48 @@ +modbus_read_bits(3) +=================== + + +NAME +---- +modbus_read_bits - read many bits + + +SYNOPSIS +-------- +*int modbus_read_bits(modbus_t *'ctx', int 'addr', int 'nb', uint8_t *'dest');* + + +DESCRIPTION +----------- +The *modbus_read_bits()* function shall read the status of the _nb_ bits (coils) +to the address _addr_ of the remote device. The result of reading is stored in +_dest_ array as unsigned bytes (8 bits) set to `TRUE` or `FALSE`. + +You must take care to allocate enough memory to store the results in _dest_ +(at least _nb_ * sizeof(uint8_t)). + +The function uses the Modbus function code 0x01 (read coil status). + + +RETURN VALUE +------------ +The function shall return the number of read bits if successful. Otherwise it +shall return -1 and set errno. + + +ERRORS +------ +*EMBMDATA*:: +Too many bits requested + + +SEE ALSO +-------- +linkmb:modbus_write_bit[3] +linkmb:modbus_write_bits[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_read_input_bits.txt b/libmodbus_src/doc/modbus_read_input_bits.txt new file mode 100644 index 0000000..d7fd3e0 --- /dev/null +++ b/libmodbus_src/doc/modbus_read_input_bits.txt @@ -0,0 +1,47 @@ +modbus_read_input_bits(3) +========================= + + +NAME +---- +modbus_read_input_bits - read many input bits + + +SYNOPSIS +-------- +*int modbus_read_input_bits(modbus_t *'ctx', int 'addr', int 'nb', uint8_t *'dest');* + + +DESCRIPTION +----------- +The *modbus_read_input_bits()* function shall read the content of the _nb_ input +bits to the address _addr_ of the remote device. The result of reading is stored +in _dest_ array as unsigned bytes (8 bits) set to _TRUE_ or _FALSE_. + +You must take care to allocate enough memory to store the results in _dest_ +(at least _nb_ * sizeof(uint8_t)). + +The function uses the Modbus function code 0x02 (read input status). + + +RETURN VALUE +------------ +The function shall return the number of read input status if +successful. Otherwise it shall return -1 and set errno. + + +ERRORS +------ +*EMBMDATA*:: +Too many discrete inputs requested + + +SEE ALSO +-------- +linkmb:modbus_read_input_registers[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_read_input_registers.txt b/libmodbus_src/doc/modbus_read_input_registers.txt new file mode 100644 index 0000000..20a5376 --- /dev/null +++ b/libmodbus_src/doc/modbus_read_input_registers.txt @@ -0,0 +1,51 @@ +modbus_read_input_registers(3) +============================== + + +NAME +---- +modbus_read_input_registers - read many input registers + + +SYNOPSIS +-------- +*int modbus_read_input_registers(modbus_t *'ctx', int 'addr', int 'nb', uint16_t *'dest');* + + +DESCRIPTION +----------- +The *modbus_read_input_registers()* function shall read the content of the _nb_ +input registers to address _addr_ of the remote device. The result of the +reading is stored in _dest_ array as word values (16 bits). + +You must take care to allocate enough memory to store the results in _dest_ (at +least _nb_ * sizeof(uint16_t)). + +The function uses the Modbus function code 0x04 (read input registers). The +holding registers and input registers have different historical meaning, but +nowadays it's more common to use holding registers only. + + +RETURN VALUE +------------ +The function shall return the number of read input registers if +successful. Otherwise it shall return -1 and set errno. + + +ERRORS +------ +*EMBMDATA*:: +Too many bits requested + + +SEE ALSO +-------- +linkmb:modbus_read_input_bits[3] +linkmb:modbus_write_register[3] +linkmb:modbus_write_registers[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_read_registers.txt b/libmodbus_src/doc/modbus_read_registers.txt new file mode 100644 index 0000000..dd29fdc --- /dev/null +++ b/libmodbus_src/doc/modbus_read_registers.txt @@ -0,0 +1,79 @@ +modbus_read_registers(3) +======================== + + +NAME +---- +modbus_read_registers - read many registers + + +SYNOPSIS +-------- +*int modbus_read_registers(modbus_t *'ctx', int 'addr', int 'nb', uint16_t *'dest');* + + +DESCRIPTION +----------- +The *modbus_read_registers()* function shall read the content of the _nb_ +holding registers to the address _addr_ of the remote device. The result of +reading is stored in _dest_ array as word values (16 bits). + +You must take care to allocate enough memory to store the results in _dest_ +(at least _nb_ * sizeof(uint16_t)). + +The function uses the Modbus function code 0x03 (read holding registers). + + +RETURN VALUE +------------ +The function shall return the number of read registers +if successful. Otherwise it shall return -1 and set errno. + + +ERRORS +------ +*EMBMDATA*:: +Too many registers requested + + +EXAMPLE +------- +[source,c] +------------------- +modbus_t *ctx; +uint16_t tab_reg[64]; +int rc; +int i; + +ctx = modbus_new_tcp("127.0.0.1", 1502); +if (modbus_connect(ctx) == -1) { + fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); + modbus_free(ctx); + return -1; +} + +rc = modbus_read_registers(ctx, 0, 10, tab_reg); +if (rc == -1) { + fprintf(stderr, "%s\n", modbus_strerror(errno)); + return -1; +} + +for (i=0; i < rc; i++) { + printf("reg[%d]=%d (0x%X)\n", i, tab_reg[i], tab_reg[i]); +} + +modbus_close(ctx); +modbus_free(ctx); +------------------- + + +SEE ALSO +-------- +linkmb:modbus_write_register[3] +linkmb:modbus_write_registers[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_receive.txt b/libmodbus_src/doc/modbus_receive.txt new file mode 100644 index 0000000..460d19b --- /dev/null +++ b/libmodbus_src/doc/modbus_receive.txt @@ -0,0 +1,42 @@ +modbus_receive(3) +================= + + +NAME +---- +modbus_receive - receive an indication request + + +SYNOPSIS +-------- +*int modbus_receive(modbus_t *'ctx', uint8_t *'req');* + + +DESCRIPTION +----------- +The *modbus_receive()* function shall receive an indication request from the +socket of the context _ctx_. This function is used by Modbus slave/server to +receive and analyze indication request sent by the masters/clients. + +If you need to use another socket or file descriptor than the one defined in the +context _ctx_, see the function linkmb:modbus_set_socket[3]. + + +RETURN VALUE +------------ +The function shall store the indication request in _req_ and return the request +length if successful. The returned request length can be zero if the indication +request is ignored (eg. a query for another slave in RTU mode). Otherwise it +shall return -1 and set errno. + + +SEE ALSO +-------- +linkmb:modbus_set_socket[3] +linkmb:modbus_reply[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_receive_confirmation.txt b/libmodbus_src/doc/modbus_receive_confirmation.txt new file mode 100644 index 0000000..118ee2b --- /dev/null +++ b/libmodbus_src/doc/modbus_receive_confirmation.txt @@ -0,0 +1,53 @@ +modbus_receive_confirmation(3) +============================== + + +NAME +---- +modbus_receive_confirmation - receive a confirmation request + + +SYNOPSIS +-------- +*int modbus_receive_confirmation(modbus_t *'ctx', uint8_t *'rsp');* + + +DESCRIPTION +----------- +The *modbus_receive_confirmation()* function shall receive a request via the +socket of the context _ctx_. This function must be used for debugging purposes +because the received response isn't checked against the initial request. This +function can be used to receive request not handled by the library. + +The maximum size of the response depends on the used backend, in RTU the _rsp_ +array must be _MODBUS_RTU_MAX_ADU_LENGTH_ bytes and in TCP it must be +_MODBUS_TCP_MAX_ADU_LENGTH_ bytes. If you want to write code compatible with +both, you can use the constant _MODBUS_MAX_ADU_LENGTH_ (maximum value of all +libmodbus backends). Take care to allocate enough memory to store responses to +avoid crashes of your server. + + +RETURN VALUE +------------ +The function shall store the confirmation request in _rsp_ and return the +response length if sucessful. The returned request length can be zero if the +indication request is ignored (eg. a query for another slave in RTU +mode). Otherwise it shall return -1 and set errno. + +EXAMPLE +------- +[source,c] +------------------- +uint8_t rsp[MODBUS_MAX_ADU_LENGTH]; +rc = modbus_receive_confirmation(ctx, rsp); +------------------- + +SEE ALSO +-------- +linkmb:modbus_send_raw_request[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_reply.txt b/libmodbus_src/doc/modbus_reply.txt new file mode 100644 index 0000000..0b29d6f --- /dev/null +++ b/libmodbus_src/doc/modbus_reply.txt @@ -0,0 +1,52 @@ +modbus_reply(3) +=============== + +NAME +---- +modbus_reply - send a reponse to the received request + + +SYNOPSIS +-------- +*int modbus_reply(modbus_t *'ctx', const uint8_t *'req', int 'req_length', modbus_mapping_t *'mb_mapping'); + + +DESCRIPTION +----------- +The *modbus_reply()* function shall send a response to received request. The +request _req_ given in argument is analyzed, a response is then built and sent +by using the information of the modbus context _ctx_. + +If the request indicates to read or write a value the operation will done in the +modbus mapping _mb_mapping_ according to the type of the manipulated data. + +If an error occurs, an exception response will be sent. + +This function is designed for Modbus server. + + +RETURN VALUE +------------ +The function shall return the length of the response sent if +successful. Otherwise it shall return -1 and set errno. + + +ERRORS +------ +*EMBMDATA*:: +Sending has failed + +See also the errors returned by the syscall used to send the response (eg. send +or write). + + +SEE ALSO +-------- +linkmb:modbus_reply_exception[3] +linkmb:libmodbus[7] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_reply_exception.txt b/libmodbus_src/doc/modbus_reply_exception.txt new file mode 100644 index 0000000..7e6324f --- /dev/null +++ b/libmodbus_src/doc/modbus_reply_exception.txt @@ -0,0 +1,57 @@ +modbus_reply_exception(3) +========================= + +NAME +---- +modbus_reply_exception - send an exception reponse + + +SYNOPSIS +-------- +*int modbus_reply_exception(modbus_t *'ctx', const uint8_t *'req', unsigned int 'exception_code'); + + +DESCRIPTION +----------- +The *modbus_reply_exception()* function shall send an exception response based +on the 'exception_code' in argument. + +The libmodbus provides the following exception codes: + +* MODBUS_EXCEPTION_ILLEGAL_FUNCTION (1) +* MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS (2) +* MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE (3) +* MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE (4) +* MODBUS_EXCEPTION_ACKNOWLEDGE (5) +* MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY (6) +* MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE (7) +* MODBUS_EXCEPTION_MEMORY_PARITY (8) +* MODBUS_EXCEPTION_NOT_DEFINED (9) +* MODBUS_EXCEPTION_GATEWAY_PATH (10) +* MODBUS_EXCEPTION_GATEWAY_TARGET (11) + +The initial request _req_ is required to build a valid response. + + +RETURN VALUE +------------ +The function shall return the length of the response sent if +successful. Otherwise it shall return -1 and set errno. + + +ERRORS +------ +*EINVAL*:: +The exception code is invalid + + +SEE ALSO +-------- +linkmb:modbus_reply[3] +linkmb:libmodbus[7] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_report_slave_id.txt b/libmodbus_src/doc/modbus_report_slave_id.txt new file mode 100644 index 0000000..6aedec6 --- /dev/null +++ b/libmodbus_src/doc/modbus_report_slave_id.txt @@ -0,0 +1,61 @@ +modbus_report_slave_id(3) +========================= + + +NAME +---- +modbus_report_slave_id - returns a description of the controller + + +SYNOPSIS +-------- +*int modbus_report_slave_id(modbus_t *'ctx', int 'max_dest', uint8_t *'dest');* + + +DESCRIPTION +----------- +The *modbus_report_slave_id()* function shall send a request to the controller +to obtain a description of the controller. + +The response stored in _dest_ contains: + +* the slave ID, this unique ID is in reality not unique at all so it's not + possible to depend on it to know how the information are packed in the + response. +* the run indicator status (0x00 = OFF, 0xFF = ON) +* additional data specific to each controller. For example, libmodbus returns + the version of the library as a string. + +The function writes at most _max_dest_ bytes from the response to _dest_ so +you must ensure that _dest_ is large enough. + +RETURN VALUE +------------ +The function shall return the number of read data if successful. + +If the output was truncated due to the _max_dest_ limit then the return value is +the number of bytes which would have been written to _dest_ if enough space had +been available. Thus, a return value greater than _max_dest_ means that the +response data was truncated. + +Otherwise it shall return -1 and set errno. + +EXAMPLE +------- +[source,c] +------------------- +uint8_t tab_bytes[MODBUS_MAX_PDU_LENGTH]; + +... + +rc = modbus_report_slave_id(ctx, MODBUS_MAX_PDU_LENGTH, tab_bytes); +if (rc > 1) { + printf("Run Status Indicator: %s\n", tab_bytes[1] ? "ON" : "OFF"); +} +------------------- + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_rtu_get_rts.txt b/libmodbus_src/doc/modbus_rtu_get_rts.txt new file mode 100644 index 0000000..559c80b --- /dev/null +++ b/libmodbus_src/doc/modbus_rtu_get_rts.txt @@ -0,0 +1,47 @@ +modbus_rtu_get_rts(3) +===================== + + +NAME +---- +modbus_rtu_get_rts - get the current RTS mode in RTU + + +SYNOPSIS +-------- +*int modbus_rtu_get_rts(modbus_t *'ctx');* + + +DESCRIPTION +----------- +The *modbus_rtu_get_rts()* function shall get the current Request To Send mode +of the libmodbus context _ctx_. The possible returned values are: + +* MODBUS_RTU_RTS_NONE +* MODBUS_RTU_RTS_UP +* MODBUS_RTU_RTS_DOWN + +This function can only be used with a context using a RTU backend. + + +RETURN VALUE +------------ +The function shall return the current RTS mode if successful. Otherwise it shall +return -1 and set errno. + + +ERRORS +------ +*EINVAL*:: +The libmodbus backend is not RTU. + + +SEE ALSO +-------- +linkmb:modbus_rtu_set_rts[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_rtu_get_rts_delay.txt b/libmodbus_src/doc/modbus_rtu_get_rts_delay.txt new file mode 100644 index 0000000..43853d4 --- /dev/null +++ b/libmodbus_src/doc/modbus_rtu_get_rts_delay.txt @@ -0,0 +1,46 @@ +modbus_rtu_get_rts_delay(3) +=========================== + + +NAME +---- +modbus_rtu_get_rts_delay - get the current RTS delay in RTU + + +SYNOPSIS +-------- +*int modbus_rtu_get_rts_delay(modbus_t *'ctx');* + + +DESCRIPTION +----------- + +The _modbus_rtu_get_rts_delay()_ function shall get the current Request To Send +delay period of the libmodbus context 'ctx'. + +This function can only be used with a context using a RTU backend. + + +RETURN VALUE +------------ +The _modbus_rtu_get_rts_delay()_ function shall return the current RTS delay in +microseconds if successful. Otherwise it shall return -1 and set errno. + + +ERRORS +------ +*EINVAL*:: +The libmodbus backend is not RTU. + + +SEE ALSO +-------- +linkmb:modbus_rtu_set_rts_delay[3] + + +AUTHORS +------- +Jimmy Bergström + +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_rtu_get_serial_mode.txt b/libmodbus_src/doc/modbus_rtu_get_serial_mode.txt new file mode 100644 index 0000000..b580728 --- /dev/null +++ b/libmodbus_src/doc/modbus_rtu_get_serial_mode.txt @@ -0,0 +1,53 @@ +modbus_rtu_get_serial_mode(3) +============================= + + +NAME +---- +modbus_rtu_get_serial_mode - get the current serial mode + + +SYNOPSIS +-------- +*int modbus_rtu_get_serial_mode(modbus_t *'ctx');* + + +DESCRIPTION +----------- +The *modbus_rtu_get_serial_mode()* function shall return the serial mode +currently used by the libmodbus context: + +*MODBUS_RTU_RS232*:: the serial line is set for RS232 communication. RS-232 + (Recommended Standard 232) is the traditional name for a series of standards + for serial binary single-ended data and control signals connecting between a + DTE (Data Terminal Equipment) and a DCE (Data Circuit-terminating + Equipment). It is commonly used in computer serial ports + +*MODBUS_RTU_RS485*:: the serial line is set for RS485 communication. EIA-485, + also known as TIA/EIA-485 or RS-485, is a standard defining the electrical + characteristics of drivers and receivers for use in balanced digital multipoint + systems. This standard is widely used for communications in industrial + automation because it can be used effectively over long distances and in + electrically noisy environments. + +This function is only available on Linux kernels 2.6.28 onwards and can only be +used with a context using a RTU backend. + + +RETURN VALUE +------------ +The function shall return `MODBUS_RTU_RS232` or `MODBUS_RTU_RS485` if +successful. Otherwise it shall return -1 and set errno to one of the values +defined below. + + +ERRORS +------ +*EINVAL*:: +The current libmodbus backend is not RTU. + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_rtu_set_custom_rts.txt b/libmodbus_src/doc/modbus_rtu_set_custom_rts.txt new file mode 100644 index 0000000..c17bd3d --- /dev/null +++ b/libmodbus_src/doc/modbus_rtu_set_custom_rts.txt @@ -0,0 +1,45 @@ +modbus_rtu_set_custom_rts(3) +============================ + + +NAME +---- +modbus_rtu_set_custom_rts - set a function to be used for custom RTS implementation + + +SYNOPSIS +-------- +*int modbus_rtu_set_custom_rts(modbus_t *'ctx', void (*'set_rts') (modbus_t *ctx, int on))* + + +DESCRIPTION +----------- +The _modbus_rtu_set_custom_rts()_ function shall set a custom function to be +called when the RTS pin is to be set before and after a transmission. By default +this is set to an internal function that toggles the RTS pin using an ioctl +call. + +Note that this function adheres to the RTS mode, the values MODBUS_RTU_RTS_UP or +MODBUS_RTU_RTS_DOWN must be used for the function to be called. + +This function can only be used with a context using a RTU backend. + + +RETURN VALUE +------------ +The _modbus_rtu_set_custom_rts()_ function shall return 0 if successful. +Otherwise it shall return -1 and set errno to one of the values defined below. + + +ERRORS +------ +*EINVAL*:: +The libmodbus backend is not RTU. + + +AUTHORS +------- +Jimmy Bergström + +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_rtu_set_rts.txt b/libmodbus_src/doc/modbus_rtu_set_rts.txt new file mode 100644 index 0000000..98a231e --- /dev/null +++ b/libmodbus_src/doc/modbus_rtu_set_rts.txt @@ -0,0 +1,81 @@ +modbus_rtu_set_rts(3) +===================== + + +NAME +---- +modbus_rtu_set_rts - set the RTS mode in RTU + + +SYNOPSIS +-------- +*int modbus_rtu_set_rts(modbus_t *'ctx', int 'mode')* + + +DESCRIPTION +----------- +The *modbus_rtu_set_rts()* function shall set the Request To Send mode to +communicate on a RS485 serial bus. By default, the mode is set to +`MODBUS_RTU_RTS_NONE` and no signal is issued before writing data on the wire. + +To enable the RTS mode, the values `MODBUS_RTU_RTS_UP` or `MODBUS_RTU_RTS_DOWN` +must be used, these modes enable the RTS mode and set the polarity at the same +time. When `MODBUS_RTU_RTS_UP` is used, an ioctl call is made with RTS flag +enabled then data is written on the bus after a delay of 1 ms, then another +ioctl call is made with the RTS flag disabled and again a delay of 1 ms occurs. +The `MODBUS_RTU_RTS_DOWN` mode applies the same procedure but with an inverted +RTS flag. + +This function can only be used with a context using a RTU backend. + + +RETURN VALUE +------------ +The function shall return 0 if successful. Otherwise it shall return -1 and set +errno to one of the values defined below. + + +ERRORS +------ +*EINVAL*:: +The libmodbus backend isn't RTU or the mode given in argument is invalid. + + +EXAMPLE +------- +.Enable the RTS mode with positive polarity +[source,c] +------------------- +modbus_t *ctx; +uint16_t tab_reg[10]; + +ctx = modbus_new_rtu("/dev/ttyS0", 115200, 'N', 8, 1); +modbus_set_slave(ctx, 1); +modbus_rtu_set_serial_mode(ctx, MODBUS_RTU_RS485); +modbus_rtu_set_rts(ctx, MODBUS_RTU_RTS_UP); + +if (modbus_connect(ctx) == -1) { + fprintf(stderr, "Connexion failed: %s\n", modbus_strerror(errno)); + modbus_free(ctx); + return -1; +} + +rc = modbus_read_registers(ctx, 0, 7, tab_reg); +if (rc == -1) { + fprintf(stderr, "%s\n", modbus_strerror(errno)); + return -1; +} + +modbus_close(ctx); +modbus_free(ctx); +------------------- + +SEE ALSO +-------- +linkmb:modbus_rtu_get_rts[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_rtu_set_rts_delay.txt b/libmodbus_src/doc/modbus_rtu_set_rts_delay.txt new file mode 100644 index 0000000..39af7df --- /dev/null +++ b/libmodbus_src/doc/modbus_rtu_set_rts_delay.txt @@ -0,0 +1,46 @@ +modbus_rtu_set_rts_delay(3) +=========================== + + +NAME +---- +modbus_rtu_set_rts_delay - set the RTS delay in RTU + + +SYNOPSIS +-------- +*int modbus_rtu_set_rts_delay(modbus_t *'ctx', int 'us');* + + +DESCRIPTION +----------- + +The _modbus_rtu_set_rts_delay()_ function shall set the Request To Send delay +period of the libmodbus context 'ctx'. + +This function can only be used with a context using a RTU backend. + + +RETURN VALUE +------------ +The _modbus_rtu_set_rts_delay()_ function shall return 0 if successful. +Otherwise it shall return -1 and set errno. + + +ERRORS +------ +*EINVAL*:: +The libmodbus backend is not RTU or a negative delay was specified. + + +SEE ALSO +-------- +linkmb:modbus_rtu_get_rts_delay[3] + + +AUTHORS +------- +Jimmy Bergström + +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_rtu_set_serial_mode.txt b/libmodbus_src/doc/modbus_rtu_set_serial_mode.txt new file mode 100644 index 0000000..7086dc4 --- /dev/null +++ b/libmodbus_src/doc/modbus_rtu_set_serial_mode.txt @@ -0,0 +1,56 @@ +modbus_rtu_set_serial_mode(3) +============================= + + +NAME +---- +modbus_rtu_set_serial_mode - set the serial mode + + +SYNOPSIS +-------- +*int modbus_rtu_set_serial_mode(modbus_t *'ctx', int 'mode');* + + +DESCRIPTION +----------- +The *modbus_rtu_set_serial_mode()* function shall set the selected serial +mode: + +*MODBUS_RTU_RS232*:: the serial line is set for RS232 communication. RS-232 + (Recommended Standard 232) is the traditional name for a series of standards + for serial binary single-ended data and control signals connecting between a + DTE (Data Terminal Equipment) and a DCE (Data Circuit-terminating + Equipment). It is commonly used in computer serial ports + +*MODBUS_RTU_RS485*:: the serial line is set for RS485 communication. EIA-485, + also known as TIA/EIA-485 or RS-485, is a standard defining the electrical + characteristics of drivers and receivers for use in balanced digital multipoint + systems. This standard is widely used for communications in industrial + automation because it can be used effectively over long distances and in + electrically noisy environments. + +This function is only supported on Linux kernels 2.6.28 onwards. + + +RETURN VALUE +------------ +The function shall return 0 if successful. Otherwise it shall return -1 and set +errno to one of the values defined below. + + +ERRORS +------ +*EINVAL*:: +The current libmodbus backend is not RTU. + +*ENOTSUP*:: +The function is not supported on your platform. + +If the call to ioctl() fails, the error code of ioctl will be returned. + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_send_raw_request.txt b/libmodbus_src/doc/modbus_send_raw_request.txt new file mode 100644 index 0000000..344ff1d --- /dev/null +++ b/libmodbus_src/doc/modbus_send_raw_request.txt @@ -0,0 +1,68 @@ +modbus_send_raw_request(3) +========================== + + +NAME +---- +modbus_send_raw_request - send a raw request + + +SYNOPSIS +-------- +*int modbus_send_raw_request(modbus_t *'ctx', uint8_t *'raw_req', int 'raw_req_length');* + + +DESCRIPTION +----------- +The *modbus_send_raw_request()* function shall send a request via the socket of +the context _ctx_. This function must be used for debugging purposes because you +have to take care to make a valid request by hand. The function only adds to the +message, the header or CRC of the selected backend, so _raw_req_ must start and +contain at least a slave/unit identifier and a function code. This function can +be used to send request not handled by the library. + +The public header of libmodbus provides a list of supported Modbus functions +codes, prefixed by `MODBUS_FC_` (eg. `MODBUS_FC_READ_HOLDING_REGISTERS`), to help +build of raw requests. + + +RETURN VALUE +------------ +The function shall return the full message length, counting the extra data +relating to the backend, if successful. Otherwise it shall return -1 and set +errno. + + +EXAMPLE +------- +[source,c] +------------------- +modbus_t *ctx; +/* Read 5 holding registers from address 1 */ +uint8_t raw_req[] = { 0xFF, MODBUS_FC_READ_HOLDING_REGISTERS, 0x00, 0x01, 0x0, 0x05 }; +int req_length; +uint8_t rsp[MODBUS_TCP_MAX_ADU_LENGTH]; + +ctx = modbus_new_tcp("127.0.0.1", 1502); +if (modbus_connect(ctx) == -1) { + fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); + modbus_free(ctx); + return -1; +} + +req_length = modbus_send_raw_request(ctx, raw_req, 6 * sizeof(uint8_t)); +modbus_receive_confirmation(ctx, rsp); + +modbus_close(ctx); +modbus_free(ctx); +------------------- + +SEE ALSO +-------- +linkmb:modbus_receive_confirmation[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_set_bits_from_byte.txt b/libmodbus_src/doc/modbus_set_bits_from_byte.txt new file mode 100644 index 0000000..72b2949 --- /dev/null +++ b/libmodbus_src/doc/modbus_set_bits_from_byte.txt @@ -0,0 +1,36 @@ +modbus_set_bits_from_byte(3) +============================ + + +NAME +---- +modbus_set_bits_from_byte - set many bits from a single byte value + + +SYNOPSIS +-------- +*void modbus_set_bits_from_byte(uint8_t *'dest', int 'index', const uint8_t 'value');* + + +DESCRIPTION +----------- +The *modbus_set_bits_from_byte()* function shall set many bits from a single byte. +All 8 bits from the byte _value_ will be written to _dest_ array starting at +_index_ position. + + +RETURN VALUE +------------ +There is no return values. + + +SEE ALSO +-------- +linkmb:modbus_set_bits_from_byte[3] +linkmb:modbus_set_bits_from_bytes[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_set_bits_from_bytes.txt b/libmodbus_src/doc/modbus_set_bits_from_bytes.txt new file mode 100644 index 0000000..cfbb8ed --- /dev/null +++ b/libmodbus_src/doc/modbus_set_bits_from_bytes.txt @@ -0,0 +1,36 @@ +modbus_set_bits_from_bytes(3) +============================ + + +NAME +---- +modbus_set_bits_from_bytes - set many bits from an array of bytes + + +SYNOPSIS +-------- +*void modbus_set_bits_from_bytes(uint8_t *'dest', int 'index', unsigned int 'nb_bits', const uint8_t *'tab_byte');* + + +DESCRIPTION +----------- +The *modbus_set_bits_from_bytes* function shall set bits by reading an array of +bytes. All the bits of the bytes read from the first position of the array +_tab_byte_ are written as bits in the _dest_ array starting at position _index_. + + +RETURN VALUE +------------ +There is no return values. + + +SEE ALSO +-------- +linkmb:modbus_set_bits_from_byte[3] +linkmb:modbus_get_byte_from_bits[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_set_byte_timeout.txt b/libmodbus_src/doc/modbus_set_byte_timeout.txt new file mode 100644 index 0000000..84e73ae --- /dev/null +++ b/libmodbus_src/doc/modbus_set_byte_timeout.txt @@ -0,0 +1,54 @@ +modbus_set_byte_timeout(3) +========================== + + +NAME +---- +modbus_set_byte_timeout - set timeout between bytes + + +SYNOPSIS +-------- +*void modbus_set_byte_timeout(modbus_t *'ctx', uint32_t 'to_sec', uint32_t 'to_usec');* + + +DESCRIPTION +----------- +The *modbus_set_byte_timeout()* function shall set the timeout interval between +two consecutive bytes of the same message. The timeout is an upper bound on the +amount of time elapsed before *select()* returns, if the time elapsed is longer +than the defined timeout, an `ETIMEDOUT` error will be raised by the +function waiting for a response. + +The value of _to_usec_ argument must be in the range 0 to 999999. + +If both _to_sec_ and _to_usec_ are zero, this timeout will not be used at all. +In this case, *modbus_set_response_timeout()* governs the entire handling of the +response, the full confirmation response must be received before expiration of +the response timeout. When a byte timeout is set, the response timeout is only +used to wait for until the first byte of the response. + + +RETURN VALUE +------------ +The function shall return 0 if successful. Otherwise it shall return -1 and set +errno. + + +ERRORS +------ +*EINVAL*:: +The argument _ctx_ is NULL or _to_usec_ is larger than 1000000. + + +SEE ALSO +-------- +linkmb:modbus_get_byte_timeout[3] +linkmb:modbus_get_response_timeout[3] +linkmb:modbus_set_response_timeout[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_set_debug.txt b/libmodbus_src/doc/modbus_set_debug.txt new file mode 100644 index 0000000..3154c21 --- /dev/null +++ b/libmodbus_src/doc/modbus_set_debug.txt @@ -0,0 +1,38 @@ +modbus_set_debug(3) +=================== + +NAME +---- +modbus_set_debug - set debug flag of the context + + +SYNOPSIS +-------- +*int modbus_set_debug(modbus_t *'ctx', int 'flag');* + + +DESCRIPTION +----------- +The *modbus_set_debug()* function shall set the debug flag of the *modbus_t* +context by using the argument _flag_. By default, the boolean flag is set to +`FALSE`. When the _flag_ value is set to `TRUE`, many verbose messages are +displayed on stdout and stderr. For example, this flag is useful to display the +bytes of the Modbus messages. + +[verse] +___________________ +[00][14][00][00][00][06][12][03][00][6B][00][03] +Waiting for a confirmation... +<00><14><00><00><00><09><12><03><06><02><2B><00><00><00><00> +___________________ + + +RETURN VALUE +------------ +The function shall return 0 if successful. Otherwise it shall return -1 and set errno. + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_set_error_recovery.txt b/libmodbus_src/doc/modbus_set_error_recovery.txt new file mode 100644 index 0000000..b5fc521 --- /dev/null +++ b/libmodbus_src/doc/modbus_set_error_recovery.txt @@ -0,0 +1,70 @@ +modbus_set_error_recovery(3) +============================ + + +NAME +---- +modbus_set_error_recovery - set the error recovery mode + + +SYNOPSIS +-------- +*int modbus_set_error_recovery(modbus_t *'ctx', modbus_error_recovery_mode 'error_recovery');* + + +DESCRIPTION +----------- +The *modbus_set_error_recovery()* function shall set the error recovery mode to +apply when the connection fails or the byte received is not expected. The +argument _error_recovery_ may be bitwise-or'ed with zero or more of the +following constants. + +By default there is no error recovery (`MODBUS_ERROR_RECOVERY_NONE`) so the +application is responsible for controlling the error values returned by +libmodbus functions and for handling them if necessary. + +When `MODBUS_ERROR_RECOVERY_LINK` is set, the library will attempt an +reconnection after a delay defined by response timeout of the libmodbus context. +This mode will try an infinite close/connect loop until success on send call and +will just try one time to re-establish the connection on select/read calls (if the +connection was down, the values to read are certainly not available any more after +reconnection, except for slave/server). This mode will also run flush requests +after a delay based on the current response timeout in some situations (eg. +timeout of select call). The reconnection attempt can hang for several seconds +if the network to the remote target unit is down. + +When `MODBUS_ERROR_RECOVERY_PROTOCOL` is set, a sleep and flush sequence will be +used to clean up the ongoing communication, this can occurs when the message +length is invalid, the TID is wrong or the received function code is not the +expected one. The response timeout delay will be used to sleep. + +The modes are mask values and so they are complementary. + +It's not recommended to enable error recovery for slave/server. + + +RETURN VALUE +------------ +The function shall return 0 if successful. Otherwise it shall return -1 and set +errno to one of the values defined below. + + +ERRORS +------ +*EINVAL*:: +The value of the argument _error_recovery_ is not positive. + + +EXAMPLE +------- +[source,c] +------------------- +modbus_set_error_recovery(ctx, + MODBUS_ERROR_RECOVERY_LINK | + MODBUS_ERROR_RECOVERY_PROTOCOL); +------------------- + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_set_float.txt b/libmodbus_src/doc/modbus_set_float.txt new file mode 100644 index 0000000..f124022 --- /dev/null +++ b/libmodbus_src/doc/modbus_set_float.txt @@ -0,0 +1,36 @@ +modbus_set_float(3) +=================== + +NAME +---- +modbus_set_float - set a float value from 2 registers + + +SYNOPSIS +-------- +*void modbus_set_float(float 'f', uint16_t *'dest');* + +Warning, this function is *deprecated* since libmodbus v3.2.0 and has been +replaced by *modbus_set_float_dcba()*. + +DESCRIPTION +----------- +The *modbus_set_float()* function shall set a float to 4 bytes in Modbus format +(ABCD). The _dest_ array must be pointer on two 16 bits values to be able to +store the full result of the conversion. + + +RETURN VALUE +------------ +There is no return values. + + +SEE ALSO +-------- +linkmb:modbus_get_float[3] +linkmb:modbus_set_float_dcba[3] + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_set_float_abcd.txt b/libmodbus_src/doc/modbus_set_float_abcd.txt new file mode 100644 index 0000000..386cbef --- /dev/null +++ b/libmodbus_src/doc/modbus_set_float_abcd.txt @@ -0,0 +1,38 @@ +modbus_set_float_abcd(3) +======================== + + +NAME +---- +modbus_set_float_abcd - set a float value in 2 registers using ABCD byte order + + +SYNOPSIS +-------- +*void modbus_set_float_abcd(float 'f', uint16_t *'dest');* + + +DESCRIPTION +----------- +The *modbus_set_float_abcd()* function shall set a float to 4 bytes in usual +Modbus format. The _dest_ array must be pointer on two 16 bits values to be able +to store the full result of the conversion. + + +RETURN VALUE +------------ +There is no return values. + + +SEE ALSO +-------- +linkmb:modbus_get_float_abcd[3] +linkmb:modbus_set_float_badc[3] +linkmb:modbus_set_float_cdab[3] +linkmb:modbus_set_float_dcba[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_set_float_badc.txt b/libmodbus_src/doc/modbus_set_float_badc.txt new file mode 100644 index 0000000..8df8ca9 --- /dev/null +++ b/libmodbus_src/doc/modbus_set_float_badc.txt @@ -0,0 +1,38 @@ +modbus_set_float_badc(3) +======================== + + +NAME +---- +modbus_set_float_badc - set a float value in 2 registers using BADC byte order + + +SYNOPSIS +-------- +*void modbus_set_float_badc(float 'f', uint16_t *'dest');* + + +DESCRIPTION +----------- +The *modbus_set_float_badc()* function shall set a float to 4 bytes in swapped +bytes Modbus format (BADC insted of ABCD). The _dest_ array must be pointer on +two 16 bits values to be able to store the full result of the conversion. + + +RETURN VALUE +------------ +There is no return values. + + +SEE ALSO +-------- +linkmb:modbus_get_float_badc[3] +linkmb:modbus_set_float_abcd[3] +linkmb:modbus_set_float_cdab[3] +linkmb:modbus_set_float_dcba[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_set_float_cdab.txt b/libmodbus_src/doc/modbus_set_float_cdab.txt new file mode 100644 index 0000000..3a03725 --- /dev/null +++ b/libmodbus_src/doc/modbus_set_float_cdab.txt @@ -0,0 +1,39 @@ +modbus_set_float_cdab(3) +======================== + + +NAME +---- +modbus_set_float_cdab - set a float value in 2 registers using CDAB byte order + + +SYNOPSIS +-------- +*void modbus_set_float_cdab(float 'f', uint16_t *'dest');* + + +DESCRIPTION +----------- +The *modbus_set_float_cdab()* function shall set a float to 4 bytes in swapped +words Modbus format (CDAB order instead of ABCD). The _dest_ array must be +pointer on two 16 bits values to be able to store the full result of the +conversion. + + +RETURN VALUE +------------ +There is no return values. + + +SEE ALSO +-------- +linkmb:modbus_get_float_cdab[3] +linkmb:modbus_set_float_abcd[3] +linkmb:modbus_set_float_badc[3] +linkmb:modbus_set_float_dcba[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_set_float_dcba.txt b/libmodbus_src/doc/modbus_set_float_dcba.txt new file mode 100644 index 0000000..578ae6f --- /dev/null +++ b/libmodbus_src/doc/modbus_set_float_dcba.txt @@ -0,0 +1,37 @@ +modbus_set_float_dcba(3) +======================== + + +NAME +---- +modbus_set_float_dcba - set a float value in 2 registers using DCBA byte order + + +SYNOPSIS +-------- +*void modbus_set_float_dcba(float 'f', uint16_t *'dest');* + + +DESCRIPTION +----------- +The *modbus_set_float_dcba()* function shall set a float to 4 bytes in inverted +Modbus format (DCBA order). The _dest_ array must be pointer on two 16 bits +values to be able to store the full result of the conversion. + + +RETURN VALUE +------------ +There is no return values. + + +SEE ALSO +-------- +linkmb:modbus_get_float_dcba[3] +linkmb:modbus_set_float[3] +linkmb:modbus_get_float[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_set_response_timeout.txt b/libmodbus_src/doc/modbus_set_response_timeout.txt new file mode 100644 index 0000000..47caf61 --- /dev/null +++ b/libmodbus_src/doc/modbus_set_response_timeout.txt @@ -0,0 +1,65 @@ +modbus_set_response_timeout(3) +============================== + + +NAME +---- +modbus_set_response_timeout - set timeout for response + + +SYNOPSIS +-------- +*int modbus_set_response_timeout(modbus_t *'ctx', uint32_t 'to_sec', uint32_t 'to_usec');* + + +DESCRIPTION +----------- +The *modbus_set_response_timeout()* function shall set the timeout interval used +to wait for a response. When a byte timeout is set, if elapsed time for the +first byte of response is longer than the given timeout, an `ETIMEDOUT` error +will be raised by the function waiting for a response. When byte timeout is +disabled, the full confirmation response must be received before expiration of +the response timeout. + +The value of _to_usec_ argument must be in the range 0 to 999999. + + +RETURN VALUE +------------ +The function shall return 0 if successful. Otherwise it shall return -1 and set +errno. + + +ERRORS +------ +*EINVAL*:: +The argument _ctx_ is NULL, or both _to_sec_ and _to_usec_ are zero, or _to_usec_ +is larger than 1000000. + + +EXAMPLE +------- +[source,c] +------------------- +uint32_t old_response_to_sec; +uint32_t old_response_to_usec; + +/* Save original timeout */ +modbus_get_response_timeout(ctx, &old_response_to_sec, &old_response_to_usec); + +/* Define a new timeout of 200ms */ +modbus_set_response_timeout(ctx, 0, 200000); +------------------- + + +SEE ALSO +-------- +linkmb:modbus_get_response_timeout[3] +linkmb:modbus_get_byte_timeout[3] +linkmb:modbus_set_byte_timeout[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_set_slave.txt b/libmodbus_src/doc/modbus_set_slave.txt new file mode 100644 index 0000000..5088856 --- /dev/null +++ b/libmodbus_src/doc/modbus_set_slave.txt @@ -0,0 +1,80 @@ +modbus_set_slave(3) +=================== + + +NAME +---- +modbus_set_slave - set slave number in the context + + +SYNOPSIS +-------- +*int modbus_set_slave(modbus_t *'ctx', int 'slave');* + + +DESCRIPTION +----------- +The *modbus_set_slave()* function shall set the slave number in the libmodbus +context. + +The behavior depends of network and the role of the device: + +*RTU*:: +Define the slave ID of the remote device to talk in master mode or set the +internal slave ID in slave mode. According to the protocol, a Modbus device must +only accept message holding its slave number or the special broadcast number. + +*TCP*:: +The slave number is only required in TCP if the message must reach a device on a +serial network. Some not compliant devices or software (such as modpoll) uses +the slave ID as unit identifier, that's incorrect (cf page 23 of Modbus +Messaging Implementation Guide v1.0b) but without the slave value, the faulty +remote device or software drops the requests! The special value +`MODBUS_TCP_SLAVE` (0xFF) can be used in TCP mode to restore the default value. + +The broadcast address is `MODBUS_BROADCAST_ADDRESS`. This special value must be +use when you want all Modbus devices of the network receive the request. + + +RETURN VALUE +------------ +The function shall return 0 if successful. Otherwise it shall return -1 and set +errno to one of the values defined below. + + +ERRORS +------ +*EINVAL*:: +The slave number is invalid. + + +EXAMPLE +------- +[source,c] +------------------- +modbus_t *ctx; + +ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1); +if (ctx == NULL) { + fprintf(stderr, "Unable to create the libmodbus context\n"); + return -1; +} + +rc = modbus_set_slave(ctx, YOUR_DEVICE_ID); +if (rc == -1) { + fprintf(stderr, "Invalid slave ID\n"); + modbus_free(ctx); + return -1; +} + +if (modbus_connect(ctx) == -1) { + fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); + modbus_free(ctx); + return -1; +} +------------------- + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_set_socket.txt b/libmodbus_src/doc/modbus_set_socket.txt new file mode 100644 index 0000000..49e5d1f --- /dev/null +++ b/libmodbus_src/doc/modbus_set_socket.txt @@ -0,0 +1,56 @@ +modbus_set_socket(3) +==================== + + +NAME +---- +modbus_set_socket - set socket of the context + + +SYNOPSIS +-------- +*int modbus_set_socket(modbus_t *'ctx', int 's');* + + +DESCRIPTION +----------- +The *modbus_set_socket()* function shall set the socket or file descriptor in +the libmodbus context. This function is useful for managing multiple client +connections to the same server. + + +RETURN VALUE +------------ +The function shall return 0 if successful. Otherwise it shall return -1 and set errno. + + +EXAMPLE +------- +[source,c] +------------------- +ctx = modbus_new_tcp("127.0.0.1", 1502); +server_socket = modbus_tcp_listen(ctx, NB_CONNECTION); + +FD_ZERO(&rdset); +FD_SET(server_socket, &rdset); + +/* .... */ + +if (FD_ISSET(master_socket, &rdset)) { + modbus_set_socket(ctx, master_socket); + rc = modbus_receive(ctx, query); + if (rc != -1) { + modbus_reply(ctx, query, rc, mb_mapping); + } +} +------------------- + +SEE ALSO +-------- +linkmb:modbus_get_socket[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_strerror.txt b/libmodbus_src/doc/modbus_strerror.txt new file mode 100644 index 0000000..9cc355f --- /dev/null +++ b/libmodbus_src/doc/modbus_strerror.txt @@ -0,0 +1,54 @@ +modbus_strerror(3) +================= + + +NAME +---- +modbus_strerror - return the error message + + +SYNOPSIS +-------- +*const char *modbus_strerror(int 'errnum');* + + +DESCRIPTION +----------- +The *modbus_strerror()* function shall return a pointer to an error message +string corresponding to the error number specified by the _errnum_ argument. As +libmodbus defines additional error numbers over and above those defined by the +operating system, applications should use *modbus_strerror()* in preference to +the standard *strerror()* function. + + +RETURN VALUE +------------ +The *modbus_strerror()* function shall return a pointer to an error message +string. + + +ERRORS +------ +No errors are defined. + + +EXAMPLE +------- +.Display an error message when a Modbus connection cannot be established +[source,c] +------------------- +if (modbus_connect(ctx) == -1) { + fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); + abort(); +} +------------------- + +SEE ALSO +-------- +linkmb:libmodbus + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_tcp_accept.txt b/libmodbus_src/doc/modbus_tcp_accept.txt new file mode 100644 index 0000000..4c46d90 --- /dev/null +++ b/libmodbus_src/doc/modbus_tcp_accept.txt @@ -0,0 +1,56 @@ +modbus_tcp_accept(3) +==================== + + +NAME +---- +modbus_tcp_accept - accept a new connection on a TCP Modbus socket (IPv4) + + +SYNOPSIS +-------- +*int modbus_tcp_accept(modbus_t *'ctx', int *'s);* + + +DESCRIPTION +----------- +The *modbus_tcp_accept()* function shall extract the first connection on the +queue of pending connections, create a new socket and store it in libmodbus +context given in argument. If available, _accept4()_ with `SOCK_CLOEXEC` will be +called instead of *accept()*. + + +RETURN VALUE +------------ +The function shall return a new socket if successful. +Otherwise it shall return -1 and set errno. + + +EXAMPLE +------- +For detailed example, see unit-test-server.c source file in tests directory. + +[source,c] +------------------- +... + +ctx = modbus_new_tcp("127.0.0.1", 502); +s = modbus_tcp_listen(ctx, 1); +modbus_tcp_accept(ctx, &s); + +... + +close(s) +modbus_free(ctx); +------------------- + +SEE ALSO +-------- +linkmb:modbus_tcp_pi_accept[3] +linkmb:modbus_tcp_listen[3] +linkmb:modbus_tcp_pi_listen[3] + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_tcp_listen.txt b/libmodbus_src/doc/modbus_tcp_listen.txt new file mode 100644 index 0000000..a88443b --- /dev/null +++ b/libmodbus_src/doc/modbus_tcp_listen.txt @@ -0,0 +1,72 @@ +modbus_tcp_listen(3) +==================== + + +NAME +---- +modbus_tcp_listen - create and listen a TCP Modbus socket (IPv4) + + +SYNOPSIS +-------- +*int modbus_tcp_listen(modbus_t *'ctx', int 'nb_connection');* + + +DESCRIPTION +----------- +The *modbus_tcp_listen()* function shall create a socket and listen to maximum +_nb_connection_ incoming connections on the specified IP address. The context +_ctx _must be allocated and initialized with linkmb:modbus_new_tcp[3] before to +set the IP address to listen, if IP address is set to NULL, any addresses will be +listen. + + +RETURN VALUE +------------ +The function shall return a new socket if successful. Otherwise it shall return +-1 and set errno. + + +EXAMPLE +------- +For detailed examples, see source files in tests directory: + +- unit-test-server.c, simple but handle only one connection +- bandwidth-server-many-up.c, handles several connections at once + + +[source,c] +------------------- +... + +/* To listen any addresses on port 502 */ +ctx = modbus_new_tcp(NULL, 502); + +/* Handle until 10 established connections */ +server_socket = modbus_tcp_listen(ctx, 10); + +/* Clear the reference set of socket */ +FD_ZERO(&refset); + +/* Add the server socket */ +FD_SET(server_socket, &refset); + +if (select(server_socket + 1, &refset, NULL, NULL, NULL) == -1) { +} + +... + +close(server_socket); +modbus_free(ctx); +------------------- + +SEE ALSO +-------- +linkmb:modbus_new_tcp[3] +linkmb:modbus_tcp_accept[3] +linkmb:modbus_tcp_pi_listen[3] + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_tcp_pi_accept.txt b/libmodbus_src/doc/modbus_tcp_pi_accept.txt new file mode 100644 index 0000000..a84dc43 --- /dev/null +++ b/libmodbus_src/doc/modbus_tcp_pi_accept.txt @@ -0,0 +1,56 @@ +modbus_tcp_pi_accept(3) +======================= + + +NAME +---- +modbus_tcp_pi_accept - accept a new connection on a TCP PI Modbus socket (IPv6) + + +SYNOPSIS +-------- +*int modbus_tcp_pi_accept(modbus_t *'ctx', int *'s);* + + +DESCRIPTION +----------- +The *modbus_tcp_pi_accept()* function shall extract the first connection on the +queue of pending connections, create a new socket and store it in libmodbus +context given in argument. If available, _accept4()_ with `SOCK_CLOEXEC` will be +called instead of *accept()*. + + +RETURN VALUE +------------ +The function shall return a new socket if successful. +Otherwise it shall return -1 and set errno. + + +EXAMPLE +------- +For detailed example, see unit-test-server.c source file in tests directory. + +[source,c] +------------------- +... + +ctx = modbus_new_tcp_pi("::0", 502); +s = modbus_tcp_pi_listen(ctx, 1); +modbus_tcp_pi_accept(ctx, &s); + +... + +close(s) +modbus_free(ctx); +------------------- + +SEE ALSO +-------- +linkmb:modbus_tcp_pi_accept[3] +linkmb:modbus_tcp_listen[3] +linkmb:modbus_tcp_pi_listen[3] + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_tcp_pi_listen.txt b/libmodbus_src/doc/modbus_tcp_pi_listen.txt new file mode 100644 index 0000000..a4df960 --- /dev/null +++ b/libmodbus_src/doc/modbus_tcp_pi_listen.txt @@ -0,0 +1,67 @@ +modbus_tcp_pi_listen(3) +======================= + + +NAME +---- +modbus_tcp_pi_listen - create and listen a TCP PI Modbus socket (IPv6) + + +SYNOPSIS +-------- +*int modbus_tcp_pi_listen(modbus_t *'ctx', int 'nb_connection');* + + +DESCRIPTION +----------- +The *modbus_tcp_pi_listen()* function shall create a socket and listen to +maximum _nb_connection_ incoming connections on the specified nodes. The +context *ctx* must be allocated and initialized with linkmb:modbus_new_tcp_pi[3] +before to set the node to listen, if node is set to NULL, any addresses will be +listen. + + +RETURN VALUE +------------ +The function shall return a new socket if successful. Otherwise it shall return +-1 and set errno. + + +EXAMPLE +------- + +For detailed examples, see source files in tests directory: + +- unit-test-server.c, simple but handle only one connection + +[source,c] +------------------- +... + +ctx = modbus_new_tcp_pi("::0", "502"); +s = modbus_tcp_pi_listen(ctx, 1); +modbus_tcp_pi_accept(ctx, &s); + +for (;;) { + rc = modbus_receive(ctx, query); + modbus_replay(ctx, query, rc, mb_mapping); +} +... + +mclose(s); +modbus_free(ctx); +------------------- + +- bandwidth-server-many-up.c, handles several connections at once + + +SEE ALSO +-------- +linkmb:modbus_new_tcp_pi[3] +linkmb:modbus_tcp_pi_accept[3] +linkmb:modbus_tcp_listen[3] + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_write_and_read_registers.txt b/libmodbus_src/doc/modbus_write_and_read_registers.txt new file mode 100644 index 0000000..e9b14bd --- /dev/null +++ b/libmodbus_src/doc/modbus_write_and_read_registers.txt @@ -0,0 +1,51 @@ +modbus_write_and_read_registers(3) +================================== + + +NAME +---- +modbus_write_and_read_registers - write and read many registers in a single transaction + + +SYNOPSIS +-------- +*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', const uint16_t *'dest');* + + +DESCRIPTION +----------- +The *modbus_write_and_read_registers()* function shall write the content of the +_write_nb_ holding registers from the array 'src' to the address _write_addr_ of +the remote device then shall read the content of the _read_nb_ holding registers +to the address _read_addr_ of the remote device. The result of reading is stored +in _dest_ array as word values (16 bits). + +You must take care to allocate enough memory to store the results in _dest_ +(at least _nb_ * sizeof(uint16_t)). + +The function uses the Modbus function code 0x17 (write/read registers). + + +RETURN VALUE +------------ +The function shall return the number of read registers if successful. Otherwise +it shall return -1 and set errno. + + +ERRORS +------ +*EMBMDATA*:: +Too many registers requested, Too many registers to write + + +SEE ALSO +-------- +linkmb:modbus_read_registers[3] +linkmb:modbus_write_register[3] +linkmb:modbus_write_registers[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_write_bit.txt b/libmodbus_src/doc/modbus_write_bit.txt new file mode 100644 index 0000000..3b4df9e --- /dev/null +++ b/libmodbus_src/doc/modbus_write_bit.txt @@ -0,0 +1,38 @@ +modbus_write_bit(3) +=================== + + +NAME +---- +modbus_write_bit - write a single bit + + +SYNOPSIS +-------- +*int modbus_write_bit(modbus_t *'ctx', int 'addr', int 'status');* + + +DESCRIPTION +----------- +The *modbus_write_bit()* function shall write the status of _status_ at the +address _addr_ of the remote device. The value must be set to `TRUE` or `FALSE`. + +The function uses the Modbus function code 0x05 (force single coil). + + +RETURN VALUE +------------ +The function shall return 1 if successful. Otherwise it shall return -1 and set +errno. + + +SEE ALSO +-------- +linkmb:modbus_read_bits[3] +linkmb:modbus_write_bits[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_write_bits.txt b/libmodbus_src/doc/modbus_write_bits.txt new file mode 100644 index 0000000..7f1af84 --- /dev/null +++ b/libmodbus_src/doc/modbus_write_bits.txt @@ -0,0 +1,45 @@ +modbus_write_bits(3) +==================== + + +NAME +---- +modbus_write_bits - write many bits + + +SYNOPSIS +-------- +*int modbus_write_bits(modbus_t *'ctx', int 'addr', int 'nb', const uint8_t *'src');* + + +DESCRIPTION +----------- +The *modbus_write_bits()* function shall write the status of the _nb_ bits +(coils) from _src_ at the address _addr_ of the remote device. The +_src_ array must contains bytes set to `TRUE` or `FALSE`. + +The function uses the Modbus function code 0x0F (force multiple coils). + + +RETURN VALUE +------------ +The function shall return the number of written bits if successful. Otherwise it +shall return -1 and set errno. + + +ERRORS +------ +*EMBMDATA*:: +Writing too many bits + + +SEE ALSO +-------- +linkmb:modbus_read_bits[3] +linkmb:modbus_write_bit[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_write_register.txt b/libmodbus_src/doc/modbus_write_register.txt new file mode 100644 index 0000000..d2fab0f --- /dev/null +++ b/libmodbus_src/doc/modbus_write_register.txt @@ -0,0 +1,38 @@ +modbus_write_register(3) +======================== + + +NAME +---- +modbus_write_register - write a single register + + +SYNOPSIS +-------- +*int modbus_write_register(modbus_t *'ctx', int 'addr', int 'value');* + + +DESCRIPTION +----------- +The *modbus_write_register()* function shall write the value of _value_ +holding registers at the address _addr_ of the remote device. + +The function uses the Modbus function code 0x06 (preset single register). + + +RETURN VALUE +------------ +The function shall return 1 if successful. Otherwise it shall return -1 and set +errno. + + +SEE ALSO +-------- +linkmb:modbus_read_registers[3] +linkmb:modbus_write_registers[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/doc/modbus_write_registers.txt b/libmodbus_src/doc/modbus_write_registers.txt new file mode 100644 index 0000000..a5654fb --- /dev/null +++ b/libmodbus_src/doc/modbus_write_registers.txt @@ -0,0 +1,38 @@ +modbus_write_registers(3) +========================= + + +NAME +---- +modbus_write_registers - write many registers + + +SYNOPSIS +-------- +*int modbus_write_registers(modbus_t *'ctx', int 'addr', int 'nb', const uint16_t *'src');* + + +DESCRIPTION +----------- +The *modbus_write_registers()* function shall write the content of the _nb_ +holding registers from the array _src_ at address _addr_ of the remote device. + +The function uses the Modbus function code 0x10 (preset multiple registers). + + +RETURN VALUE +------------ +The function shall return the number of written registers if +successful. Otherwise it shall return -1 and set errno. + + +SEE ALSO +-------- +linkmb:modbus_write_register[3] +linkmb:modbus_read_registers[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/libmodbus_src/libmodbus.pc.in b/libmodbus_src/libmodbus.pc.in new file mode 100644 index 0000000..f1a9cbf --- /dev/null +++ b/libmodbus_src/libmodbus.pc.in @@ -0,0 +1,10 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: modbus +Description: Modbus library +Version: @VERSION@ +Libs: -L${libdir} -lmodbus +Cflags: -I${includedir}/modbus diff --git a/libmodbus_src/m4/.gitignore b/libmodbus_src/m4/.gitignore new file mode 100644 index 0000000..38066dd --- /dev/null +++ b/libmodbus_src/m4/.gitignore @@ -0,0 +1,5 @@ +libtool.m4 +ltoptions.m4 +ltsugar.m4 +ltversion.m4 +lt~obsolete.m4 diff --git a/libmodbus_src/src/Makefile.am b/libmodbus_src/src/Makefile.am new file mode 100644 index 0000000..551fe43 --- /dev/null +++ b/libmodbus_src/src/Makefile.am @@ -0,0 +1,42 @@ +EXTRA_DIST = +lib_LTLIBRARIES = libmodbus.la + +AM_CPPFLAGS = \ + -include $(top_builddir)/config.h \ + -DSYSCONFDIR=\""$(sysconfdir)"\" \ + -DLIBEXECDIR=\""$(libexecdir)"\" \ + -I${top_srcdir}/src + +AM_CFLAGS = ${my_CFLAGS} + +libmodbus_la_SOURCES = \ + modbus.c \ + modbus.h \ + modbus-data.c \ + modbus-private.h \ + modbus-rtu.c \ + modbus-rtu.h \ + modbus-rtu-private.h \ + modbus-tcp.c \ + modbus-tcp.h \ + modbus-tcp-private.h \ + modbus-version.h + +libmodbus_la_LDFLAGS = -no-undefined \ + -version-info $(LIBMODBUS_LT_VERSION_INFO) + +if OS_WIN32 +libmodbus_la_LIBADD = -lwsock32 +endif + +if OS_QNX +libmodbus_la_LIBADD = -lsocket +endif + +# Header files to install +libmodbusincludedir = $(includedir)/modbus +libmodbusinclude_HEADERS = modbus.h modbus-version.h modbus-rtu.h modbus-tcp.h + +DISTCLEANFILES = modbus-version.h +EXTRA_DIST += modbus-version.h.in +CLEANFILES = *~ diff --git a/libmodbus_src/src/modbus-data.c b/libmodbus_src/src/modbus-data.c new file mode 100644 index 0000000..902b8c6 --- /dev/null +++ b/libmodbus_src/src/modbus-data.c @@ -0,0 +1,229 @@ +/* + * Copyright © 2010-2014 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#include + +#ifndef _MSC_VER +# include +#else +# include "stdint.h" +#endif + +#include +#include + +#if defined(_WIN32) +# include +#else +# include +#endif + +#include + +#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 +#endif + +#if defined(_MSC_VER) && (_MSC_VER >= 1400) +# define bswap_32 _byteswap_ulong +# define bswap_16 _byteswap_ushort +#endif + +#if !defined(__CYGWIN__) && !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; + + i = ntohl(((uint32_t)src[0] << 16) + src[1]); + memcpy(&f, &i, sizeof(float)); + + 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; + + i = ntohl(bswap_32((((uint32_t)src[0]) << 16) + src[1])); + memcpy(&f, &i, sizeof(float)); + + 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; + + i = ntohl((uint32_t)(bswap_16(src[0]) << 16) + bswap_16(src[1])); + memcpy(&f, &i, sizeof(float)); + + 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; + + i = ntohl((((uint32_t)src[1]) << 16) + src[0]); + memcpy(&f, &i, sizeof(float)); + + 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; + + memcpy(&i, &f, sizeof(uint32_t)); + i = htonl(i); + dest[0] = (uint16_t)(i >> 16); + dest[1] = (uint16_t)i; +} + +/* 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; + + memcpy(&i, &f, sizeof(uint32_t)); + i = bswap_32(htonl(i)); + dest[0] = (uint16_t)(i >> 16); + dest[1] = (uint16_t)i; +} + +/* 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; + + memcpy(&i, &f, sizeof(uint32_t)); + i = htonl(i); + dest[0] = (uint16_t)bswap_16(i >> 16); + dest[1] = (uint16_t)bswap_16(i & 0xFFFF); +} + +/* 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; + + memcpy(&i, &f, sizeof(uint32_t)); + i = htonl(i); + dest[0] = (uint16_t)i; + dest[1] = (uint16_t)(i >> 16); +} + +/* 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_src/src/modbus-private.h b/libmodbus_src/src/modbus-private.h new file mode 100644 index 0000000..c5af0f9 --- /dev/null +++ b/libmodbus_src/src/modbus-private.h @@ -0,0 +1,115 @@ +/* + * Copyright © 2010-2012 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#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 + +#include "modbus.h" + +MODBUS_BEGIN_DECLS + +/* It's not really the minimal length (the real one is report slave ID + * in RTU (4 bytes)) but it's a convenient size to use in RTU or TCP + * communications to read many values or write a single one. + * Maximum between : + * - HEADER_LENGTH_TCP (7) + function (1) + address (2) + number (2) + * - HEADER_LENGTH_RTU (1) + function (1) + address (2) + number (2) + CRC (2) + */ +#define _MIN_REQ_LENGTH 12 + +#define _REPORT_SLAVE_ID 180 + +#define _MODBUS_EXCEPTION_RSP_LENGTH 5 + +/* Timeouts in microsecond (0.5 s) */ +#define _RESPONSE_TIMEOUT 500000 +#define _BYTE_TIMEOUT 500000 + +typedef enum { + _MODBUS_BACKEND_TYPE_RTU=0, + _MODBUS_BACKEND_TYPE_TCP +} modbus_backend_type_t; + +/* + * ---------- Request Indication ---------- + * | Client | ---------------------->| Server | + * ---------- Confirmation Response ---------- + */ +typedef enum { + /* Request message on the server side */ + MSG_INDICATION, + /* Request message on the client side */ + MSG_CONFIRMATION +} msg_type_t; + +/* This structure reduces the number of params in functions and so + * optimizes the speed of execution (~ 37%). */ +typedef struct _sft { + int slave; + int function; + int t_id; +} sft_t; + +typedef struct _modbus_backend { + unsigned int backend_type; + unsigned int header_length; + unsigned int checksum_length; + unsigned int max_adu_length; + int (*set_slave) (modbus_t *ctx, int slave); + int (*build_request_basis) (modbus_t *ctx, int function, int addr, + int nb, uint8_t *req); + int (*build_response_basis) (sft_t *sft, uint8_t *rsp); + int (*prepare_response_tid) (const uint8_t *req, int *req_length); + int (*send_msg_pre) (uint8_t *req, int req_length); + ssize_t (*send) (modbus_t *ctx, const uint8_t *req, int req_length); + int (*receive) (modbus_t *ctx, uint8_t *req); + ssize_t (*recv) (modbus_t *ctx, uint8_t *rsp, int rsp_length); + int (*check_integrity) (modbus_t *ctx, uint8_t *msg, + const int msg_length); + int (*pre_check_confirmation) (modbus_t *ctx, const uint8_t *req, + const uint8_t *rsp, int rsp_length); + int (*connect) (modbus_t *ctx); + 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; + 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_src/src/modbus-rtu-private.h b/libmodbus_src/src/modbus-rtu-private.h new file mode 100644 index 0000000..a1d0473 --- /dev/null +++ b/libmodbus_src/src/modbus-rtu-private.h @@ -0,0 +1,76 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#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_src/src/modbus-rtu.c b/libmodbus_src/src/modbus-rtu.c new file mode 100644 index 0000000..cb2fb50 --- /dev/null +++ b/libmodbus_src/src/modbus-rtu.c @@ -0,0 +1,1275 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#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_hi ^ *buffer++; /* calculate the CRC */ + crc_hi = crc_lo ^ table_crc_hi[i]; + crc_lo = 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); + req[req_length++] = crc >> 8; + req[req_length++] = crc & 0x00FF; + + 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 is the message is ignored and the + message length if the CRC is valid. Otherwise it shall return -1 and set + errno to EMBADCRC. */ +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 - 2] << 8) | msg[msg_length - 1]; + + /* 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 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 ouput */ + 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; + memset(&rs485conf, 0x0, sizeof(struct serial_rs485)); + + if (mode == MODBUS_RTU_RS485) { + 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, 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) { + 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)); + _modbus_init_common(ctx); + ctx->backend = &_modbus_rtu_backend; + ctx->backend_data = (modbus_rtu_t *)malloc(sizeof(modbus_rtu_t)); + ctx_rtu = (modbus_rtu_t *)ctx->backend_data; + ctx_rtu->device = NULL; + + /* Device name and \0 */ + ctx_rtu->device = (char *)malloc((strlen(device) + 1) * sizeof(char)); + 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_src/src/modbus-rtu.h b/libmodbus_src/src/modbus-rtu.h new file mode 100644 index 0000000..214a888 --- /dev/null +++ b/libmodbus_src/src/modbus-rtu.h @@ -0,0 +1,42 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#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_src/src/modbus-tcp-private.h b/libmodbus_src/src/modbus-tcp-private.h new file mode 100644 index 0000000..55edf26 --- /dev/null +++ b/libmodbus_src/src/modbus-tcp-private.h @@ -0,0 +1,44 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#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 dependant 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_src/src/modbus-tcp.c b/libmodbus_src/src/modbus-tcp.c new file mode 100644 index 0000000..15a8f00 --- /dev/null +++ b/libmodbus_src/src/modbus-tcp.c @@ -0,0 +1,901 @@ +/* + * Copyright © 2001-2013 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#include +#include +#include +#include +#ifndef _MSC_VER +#include +#endif +#include +#include + +#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 +/* 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) +{ + /* Substract 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; + 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 + + new_s = socket(PF_INET, SOCK_STREAM, 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 s; + + s = socket(ai_ptr->ai_family, ai_ptr->ai_socktype, + 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) { + close(*s); + *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) { + close(*s); + *s = -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, "Coud not install SIGPIPE handler.\n"); + return NULL; + } +#endif + + ctx = (modbus_t *)malloc(sizeof(modbus_t)); + _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)); + 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)); + _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)); + 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 catched 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_src/src/modbus-tcp.h b/libmodbus_src/src/modbus-tcp.h new file mode 100644 index 0000000..abaef27 --- /dev/null +++ b/libmodbus_src/src/modbus-tcp.h @@ -0,0 +1,52 @@ +/* + * Copyright © 2001-2010 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#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_src/src/modbus-version.h.in b/libmodbus_src/src/modbus-version.h.in new file mode 100644 index 0000000..d2dcac8 --- /dev/null +++ b/libmodbus_src/src/modbus-version.h.in @@ -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 (@LIBMODBUS_VERSION_MAJOR@) + +/* The minor version (2, if %LIBMODBUS_VERSION is 1.2.3) */ +#define LIBMODBUS_VERSION_MINOR (@LIBMODBUS_VERSION_MINOR@) + +/* The micro version (3, if %LIBMODBUS_VERSION is 1.2.3) */ +#define LIBMODBUS_VERSION_MICRO (@LIBMODBUS_VERSION_MICRO@) + +/* The full version, like 1.2.3 */ +#define LIBMODBUS_VERSION @LIBMODBUS_VERSION@ + +/* The full version, in string form (suited for string concatenation) + */ +#define LIBMODBUS_VERSION_STRING "@LIBMODBUS_VERSION@" + +/* Numerically encoded version, like 0x010203 */ +#define LIBMODBUS_VERSION_HEX ((LIBMODBUS_VERSION_MAJOR << 24) | \ + (LIBMODBUS_VERSION_MINOR << 16) | \ + (LIBMODBUS_VERSION_MICRO << 8)) + +/* 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_src/src/modbus.c b/libmodbus_src/src/modbus.c new file mode 100644 index 0000000..f1da5c6 --- /dev/null +++ b/libmodbus_src/src/modbus.c @@ -0,0 +1,1861 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + * + * This library implements the Modbus protocol. + * http://libmodbus.org/ + */ + +#include +#include +#include +#include +#include +#include +#include +#ifndef _MSC_VER +#include +#endif + +#include + +#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) */ +#define MAX_MESSAGE_LENGTH 260 + +/* 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, 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 + - EMBUNKEXC + - 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 a 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 */ + p_tv = NULL; + } 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 mapping_address = address - mb_mapping->start_bits; + + if (nb < 1 || MODBUS_MAX_WRITE_BITS < 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 mapping_address = address - mb_mapping->start_registers; + + if (nb < 1 || MODBUS_MAX_WRITE_REGISTERS < nb) { + 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 < 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 (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; +} + +/* Reads the data from a remove 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; + int req_length; + uint8_t req[_MIN_REQ_LENGTH]; + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + 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; + + 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; +} + +/* 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, int 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, 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, int 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 substraction 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; +} + +/* 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_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; +} + +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_ranges() 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_src/src/modbus.h b/libmodbus_src/src/modbus.h new file mode 100644 index 0000000..e3e9f86 --- /dev/null +++ b/libmodbus_src/src/modbus.h @@ -0,0 +1,289 @@ +/* + * Copyright © 2001-2013 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#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 + +/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 1 page 12) + * Quantity of Coils to read (2 bytes): 1 to 2000 (0x7D0) + * (chapter 6 section 11 page 29) + * Quantity of Coils to write (2 bytes): 1 to 1968 (0x7B0) + */ +#define MODBUS_MAX_READ_BITS 2000 +#define MODBUS_MAX_WRITE_BITS 1968 + +/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 3 page 15) + * Quantity of Registers to read (2 bytes): 1 to 125 (0x7D) + * (chapter 6 section 12 page 31) + * Quantity of Registers to write (2 bytes) 1 to 123 (0x7B) + * (chapter 6 section 17 page 38) + * Quantity of Registers to write in R/W registers (2 bytes) 1 to 121 (0x79) + */ +#define MODBUS_MAX_READ_REGISTERS 125 +#define MODBUS_MAX_WRITE_REGISTERS 123 +#define MODBUS_MAX_WR_WRITE_REGISTERS 121 +#define MODBUS_MAX_WR_READ_REGISTERS 125 + +/* The size of the MODBUS PDU is limited by the size constraint inherited from + * the first MODBUS implementation on Serial Line network (max. RS485 ADU = 256 + * bytes). Therefore, MODBUS PDU for serial line communication = 256 - Server + * address (1 byte) - CRC (2 bytes) = 253 bytes. + */ +#define MODBUS_MAX_PDU_LENGTH 253 + +/* Consequently: + * - RTU MODBUS ADU = 253 bytes + Server address (1 byte) + CRC (2 bytes) = 256 + * bytes. + * - TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes. + * so the maximum of both backend in 260 bytes. This size can used to allocate + * an array of bytes to store responses and it will be compatible with the two + * backends. + */ +#define MODBUS_MAX_ADU_LENGTH 260 + +/* Random number to avoid errno conflicts */ +#define MODBUS_ENOBASE 112345678 + +/* Protocol exceptions */ +enum { + MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 0x01, + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, + MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE, + MODBUS_EXCEPTION_ACKNOWLEDGE, + MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY, + MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE, + MODBUS_EXCEPTION_MEMORY_PARITY, + MODBUS_EXCEPTION_NOT_DEFINED, + MODBUS_EXCEPTION_GATEWAY_PATH, + MODBUS_EXCEPTION_GATEWAY_TARGET, + MODBUS_EXCEPTION_MAX +}; + +#define EMBXILFUN (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_FUNCTION) +#define EMBXILADD (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS) +#define EMBXILVAL (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE) +#define EMBXSFAIL (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE) +#define EMBXACK (MODBUS_ENOBASE + MODBUS_EXCEPTION_ACKNOWLEDGE) +#define EMBXSBUSY (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY) +#define EMBXNACK (MODBUS_ENOBASE + MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE) +#define EMBXMEMPAR (MODBUS_ENOBASE + MODBUS_EXCEPTION_MEMORY_PARITY) +#define EMBXGPATH (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_PATH) +#define EMBXGTAR (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_TARGET) + +/* Native libmodbus error codes */ +#define EMBBADCRC (EMBXGTAR + 1) +#define EMBBADDATA (EMBXGTAR + 2) +#define EMBBADEXC (EMBXGTAR + 3) +#define EMBUNKEXC (EMBXGTAR + 4) +#define EMBMDATA (EMBXGTAR + 5) +#define EMBBADSLAVE (EMBXGTAR + 6) + +extern const unsigned int libmodbus_version_major; +extern const unsigned int libmodbus_version_minor; +extern const unsigned int libmodbus_version_micro; + +typedef struct _modbus modbus_t; + +typedef struct { + 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_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_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, int 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, 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) ((tab_int16[(index)] << 16) + tab_int16[(index) + 1]) +#define MODBUS_GET_INT16_FROM_INT8(tab_int8, index) ((tab_int8[(index)] << 8) + tab_int8[(index) + 1]) +#define MODBUS_SET_INT16_TO_INT8(tab_int8, index, value) \ + do { \ + tab_int8[(index)] = (value) >> 8; \ + tab_int8[(index) + 1] = (value) & 0xFF; \ + } while (0) +#define MODBUS_SET_INT32_TO_INT16(tab_int16, index, value) \ + do { \ + tab_int16[(index) ] = (value) >> 16; \ + tab_int16[(index) + 1] = (value); \ + } while (0) +#define MODBUS_SET_INT64_TO_INT16(tab_int16, index, value) \ + do { \ + tab_int16[(index) ] = (value) >> 48; \ + tab_int16[(index) + 1] = (value) >> 32; \ + tab_int16[(index) + 2] = (value) >> 16; \ + tab_int16[(index) + 3] = (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/libmodbus_src/src/win32/Make-tests b/libmodbus_src/src/win32/Make-tests new file mode 100644 index 0000000..d4a569e --- /dev/null +++ b/libmodbus_src/src/win32/Make-tests @@ -0,0 +1,62 @@ +# Windows makefile +# -- +# use mingw make +# Get make-3.82-5-mingw32-bin.tar.lzma from +# http://sourceforge.net/projects/mingw/files/MinGW/Extension/make/make-3.82-mingw32/ +# -- +# Set CC=gcc or CC=cl for the pre-defined compilers +# before using this Makefile +# -- +# Compile and link the bandwidth and random tests. +# Build modbus.dll and the import library before building the tests +# modbus.lib/libmodbus.a (the import library) should be in this directory +# modbus.dll should be in this directory or in path + +INCLUDES:=-I../.. -I.. -I. + +ifeq ($(CC),cl) +DEFS+=-D_CRT_SECURE_NO_DEPRECATE=1 -D_CRT_NONSTDC_NO_DEPRECATE=1 +CFLAGS=-Zi -W3 -MT -ID:/include/msvc_std +LDOPTS=-link -incremental:NO +LDLIBS=-Fe$@ ws2_32.lib modbus.lib $(LDOPTS) +RES:=res +RCOUT= +endif + +ifeq ($(CC),gcc) +CFLAGS=-g -Wall -O -static -static-libgcc +LDLIBS=-o$@ -lws2_32 -luser32 -L. -lmodbus +LDOPTS= +RES:=o +RCOUT=-o$@ +endif + +CFLAGS+=-DHAVE_CONFIG_H $(DEFS) $(INCLUDES) + +.SUFFIXES: +.SUFFIXES: .c .rc .$(RES) .$(oo) + +# pattern rule for resources +%.$(RES) : %.rc + $(RC) $< $(RCOUT) + +vpath %.c ../../tests +vpath %.h ../src + +all: random-test-client random-test-server bandwidth-client bandwidth-server-one + +random-test-client: random-test-client.c + $(LINK.c) $^ $(LDLIBS) + +random-test-server: random-test-server.c + $(LINK.c) $^ $(LDLIBS) + +bandwidth-server-one: bandwidth-server-one.c + $(LINK.c) $^ $(LDLIBS) + +bandwidth-client: bandwidth-client.c + $(LINK.c) $^ $(LDLIBS) + + +clean: + -@cmd "/c del /Q /S $(OBJS) *.o *.obj *.exe *.pdb *.ilk *.ncb *.res *.dll *.exp *.lib *.ncb *.a *.map *.asm" > NUL: 2>&1 diff --git a/libmodbus_src/src/win32/README.win32 b/libmodbus_src/src/win32/README.win32 new file mode 100644 index 0000000..86dbe2e --- /dev/null +++ b/libmodbus_src/src/win32/README.win32 @@ -0,0 +1,20 @@ +Intro +----- + +This directory contains the project file for Visual Studio 2008 to build +modbus.dll and the import library modbus.lib. + +The project file looks for D:/include/msvc_std to find stdint.h. +See ../../README.md file. + +config.h and ../modbus-version.h are generated using configure.js. + +Run + cscript configure.js +or + wscript configure.js +or + double click configure.js to generate these files. + +To get project file for Visual Studio 2005 open copy of file modbus.vcproj in +editor and change attribute `Version` of `VisualStudioProject` tag to "8,00". \ No newline at end of file diff --git a/libmodbus_src/src/win32/config.h.win32 b/libmodbus_src/src/win32/config.h.win32 new file mode 100644 index 0000000..02ac444 --- /dev/null +++ b/libmodbus_src/src/win32/config.h.win32 @@ -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 @LIBMODBUS_VERSION@" + +/* 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 "@LIBMODBUS_VERSION@" + +/* 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 "@LIBMODBUS_VERSION@" + +/* 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_src/src/win32/configure.js b/libmodbus_src/src/win32/configure.js new file mode 100644 index 0000000..aa21e49 --- /dev/null +++ b/libmodbus_src/src/win32/configure.js @@ -0,0 +1,163 @@ +/* Configure script for modbus.dll, specific for Windows with Scripting Host. + * + * Inspired by configure.js from libxml2 + * + * oldfaber < oldfaber _at_ gmail _dot_ com > + * + */ + +/* The source directory, relative to the one where this file resides. */ +var srcDir = ".."; +/* Base name of what we are building. */ +var baseName = "modbus"; +/* Configure file template and output file */ +var configFile = srcDir + "\\..\\configure.ac"; +/* Input and output files for the modbus-version.h include */ +var newfile; +/* Version strings for the binary distribution. Will be filled later in the code. */ +var verMajor; +var verMinor; +var verMicro; +/* modbus features. */ +var dryRun = false; +/* Win32 build options. NOT used yet */ +var compiler = "msvc"; +/* Local stuff */ +var error = 0; +/* Filename */ +var newFile; + +/* Displays the details about how to use this script. */ +function usage() { + var txt; + + txt = "Usage:\n"; + txt += " cscript " + WScript.ScriptName + " \n"; + txt += " cscript " + WScript.ScriptName + " help\n\n"; + txt += "Options can be specified in the form