Major - Oh Gosh, it's brand new API!

- more coherent
- namespace
- opaque and smaller context
- usual wording

MIGRATION

@@ -2,37 +2,27 @@
 Migration notes from the 2.0 series (for 2.2)
 =============================================
 
-1 - modbus_init_rtu/tcp takes a new argument, the slave number of the device
-    which established the connection.
+The 2.2 release use a brand new API and this document covers only the general
+changes:
 
-2 - modbus_init_listen_tcp() has been renamed to modbus_slave_listen_tcp() and
-    requires a new argument, the maximal number of connections:
+- the structure modbus_param_t is gone and is replaced by a new opaque and
+dynamically allocated structure modbus_t.
 
-int modbus_slave_init_tcp(modbus_param_t *mb_param, int nb_connection);
+- 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.
 
-3 - New function modbus_slave_accept_tcp() to etablish a new connection
-    (previously in modbus_init_listen_tcp()):
+- all function and constants are respectively prefixed by modbus_ or MODBUS_.
 
-int modbus_slave_accept_tcp(modbus_param_t *mb_param, int *socket);
+- 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.
 
-4 - modbus_listen() has been renamed to modbus_slave_receive() and requires a
-    new argument, the socket file descriptor to listen on. If the sockfd is -1,
-    the internal fd of modbus_param_t is used:
-
-int modbus_slave_receive(modbus_param_t *mb_param, int sockfd,
-                         uint8_t *query, int *query_length);
-
-
-5 - If you use the HEADER_LENGTH_ defines, their values have been incremented by
-    1 to reflect the PDU and ADU of the Modbus protocol and to reduce the CPU
-    consumption:
-     - HEADER_LENGTH_RTU           0 -> 1
-     - HEADER_LENGTH_TCP           6 -> 7
-
-6 - modbus_mapping_new returns 0 on success and -1 on failure.
-
+We hope you'll enjoy the new API to accept the migration burden!
 
 =============================================
 Migration notes from the 1.2 series (for 2.0)

src/modbus-private.h

@@ -0,0 +1,113 @@
+/*
+ * Copyright © 2010 Stéphane Raimbault <stephane.raimbault@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _MODBUS_PRIVATE_H_
+#define _MODBUS_PRIVATE_H_
+
+#include "modbus.h"
+
+MODBUS_BEGIN_DECLS
+
+#define HEADER_LENGTH_RTU      1
+#define PRESET_REQ_LENGTH_RTU  6
+#define PRESET_RSP_LENGTH_RTU  2
+
+#define HEADER_LENGTH_TCP      7
+#define PRESET_REQ_LENGTH_TCP 12
+#define PRESET_RSP_LENGTH_TCP  8
+
+#define CHECKSUM_LENGTH_RTU    2
+#define CHECKSUM_LENGTH_TCP    0
+
+/* 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 EXCEPTION_RSP_LENGTH_RTU  5
+
+#define REPORT_SLAVE_ID_LENGTH   75
+
+/* Time out between trames in microsecond */
+#define TIME_OUT_BEGIN_OF_TRAME    500000
+#define TIME_OUT_END_OF_TRAME      500000
+
+/* Function codes */
+#define FC_READ_COILS                0x01
+#define FC_READ_DISCRETE_INPUTS      0x02
+#define FC_READ_HOLDING_REGISTERS    0x03
+#define FC_READ_INPUT_REGISTERS      0x04
+#define FC_WRITE_SINGLE_COIL         0x05
+#define FC_WRITE_SINGLE_REGISTER     0x06
+#define FC_READ_EXCEPTION_STATUS     0x07
+#define FC_WRITE_MULTIPLE_COILS      0x0F
+#define FC_WRITE_MULTIPLE_REGISTERS  0x10
+#define FC_REPORT_SLAVE_ID           0x11
+
+typedef enum { RTU=0, TCP } type_com_t;
+
+struct _modbus {
+    /* Communication mode: RTU or TCP */
+    type_com_t type_com;
+    /* Slave address */
+    int slave;
+    /* Socket or file descriptor */
+    int s;
+    int debug;
+    int error_recovery;
+    struct timeval timeout_begin;
+    struct timeval timeout_end;
+    void *com;
+};
+
+typedef struct _modbus_rtu {
+    /* Device: "/dev/ttyS0", "/dev/ttyUSB0" or "/dev/tty.USA19*" on Mac OS X for
+       KeySpan USB<->Serial adapters this string had to be made bigger on OS X
+       as the directory+file name was bigger than 19 bytes. Making it 67 bytes
+       for now, but OS X does support 256 byte file names. May become a problem
+       in the future. */
+#ifdef __APPLE_CC__
+    char device[64];
+#else
+    char device[16];
+#endif
+    /* 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;
+    /* Save old termios settings */
+    struct termios old_tios;
+} modbus_rtu_t;
+
+typedef struct _modbus_tcp {
+    /* TCP port */
+    int port;
+    /* IP address */
+    char ip[16];
+} modbus_tcp_t;
+
+MODBUS_END_DECLS
+
+#endif  /* _MODBUS_PRIVATE_H_ */

src/modbus.h.in

@@ -33,63 +33,15 @@
 #include <netinet/tcp.h>
 #include <arpa/inet.h>
 
-#ifdef __cplusplus
-extern "C" {
+#ifdef  __cplusplus
+# define MODBUS_BEGIN_DECLS  extern "C" {
+# define MODBUS_END_DECLS    }
+#else
+# define MODBUS_BEGIN_DECLS
+# define MODBUS_END_DECLS
 #endif
 
-#define MODBUS_TCP_DEFAULT_PORT   502
-#define MODBUS_BROADCAST_ADDRESS    0
-#define MODBUS_TCP_SLAVE         0xFF
-
-/* Slave index */
-#define HEADER_LENGTH_RTU           1
-#define PRESET_QUERY_LENGTH_RTU     6
-#define PRESET_RESPONSE_LENGTH_RTU  2
-
-#define HEADER_LENGTH_TCP           7
-#define PRESET_QUERY_LENGTH_TCP    12
-#define PRESET_RESPONSE_LENGTH_TCP  8
-
-#define CHECKSUM_LENGTH_RTU         2
-#define CHECKSUM_LENGTH_TCP         0
-
-/* 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_QUERY_LENGTH           12
-
-/* 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
- *  - TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes
- */
-#define MAX_PDU_LENGTH            253
-#define MAX_ADU_LENGTH_RTU        256
-#define MAX_ADU_LENGTH_TCP        260
-
-/* Kept for compatibility reasons (deprecated) */
-#define MAX_MESSAGE_LENGTH        260
-
-#define EXCEPTION_RESPONSE_LENGTH_RTU  5
-
-/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 1 page 12)
- * Quantity of Coils (2 bytes): 1 to 2000 (0x7D0)
- */
-#define MAX_STATUS               2000
-
-/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 3 page 15)
- * Quantity of Registers (2 bytes): 1 to 125 (0x7D)
- */
-#define MAX_REGISTERS             125
-
-#define REPORT_SLAVE_ID_LENGTH     75
-
-/* Time out between trames in microsecond */
-#define TIME_OUT_BEGIN_OF_TRAME 500000
-#define TIME_OUT_END_OF_TRAME   500000
+MODBUS_BEGIN_DECLS
 
 #ifndef FALSE
 #define FALSE 0
@@ -107,23 +59,32 @@ extern "C" {
 #define ON 1
 #endif
 
-/* Function codes */
-#define FC_READ_COIL_STATUS          0x01  /* discretes inputs */
-#define FC_READ_INPUT_STATUS         0x02  /* discretes outputs */
-#define FC_READ_HOLDING_REGISTERS    0x03
-#define FC_READ_INPUT_REGISTERS      0x04
-#define FC_FORCE_SINGLE_COIL         0x05
-#define FC_PRESET_SINGLE_REGISTER    0x06
-#define FC_READ_EXCEPTION_STATUS     0x07
-#define FC_FORCE_MULTIPLE_COILS      0x0F
-#define FC_PRESET_MULTIPLE_REGISTERS 0x10
-#define FC_REPORT_SLAVE_ID           0x11
+#define MODBUS_TCP_DEFAULT_PORT   502
+#define MODBUS_BROADCAST_ADDRESS    0
+#define MODBUS_TCP_SLAVE         0xFF
+
+/* 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
+ *  - TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes
+ */
+#define MODBUS_MAX_ADU_LENGTH_RTU  256
+#define MODBUS_MAX_ADU_LENGTH_TCP  260
+
+/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 1 page 12)
+ * Quantity of Coils (2 bytes): 1 to 2000 (0x7D0)
+ */
+#define MODBUS_MAX_BITS              2000
+
+/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 3 page 15)
+ * Quantity of Registers (2 bytes): 1 to 125 (0x7D)
+ */
+#define MODBUS_MAX_REGISTERS          125
 
 /* Random number to avoid errno conflicts */
 #define MODBUS_ENOBASE 112345678
 
 /* Protocol exceptions */
-typedef enum {
+enum {
     MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 0x01,
     MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS,
     MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE,
@@ -136,7 +97,7 @@ typedef enum {
     MODBUS_EXCEPTION_GATEWAY_PATH,
     MODBUS_EXCEPTION_GATEWAY_TARGET,
     MODBUS_EXCEPTION_MAX
-} modbus_exception_t;
+};
 
 #define EMBXILFUN  (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_FUNCTION)
 #define EMBXILADD  (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS)
@@ -156,33 +117,28 @@ typedef enum {
 #define EMBUNKEXC  (EMBXGTAR + 4)
 #define EMBMDATA   (EMBXGTAR + 5)
 
-/* Internal use */
-#define MSG_LENGTH_UNDEFINED -1
-
-/* The major version of libmb, (1, if %LIBMODBUS_VERSION is 1.2.3) */
+/* The major version, (1, if %LIBMODBUS_VERSION is 1.2.3) */
 #define LIBMODBUS_VERSION_MAJOR (@LIBMODBUS_VERSION_MAJOR@)
 
-/* The minor version of libmb (2, if %LIBMODBUS_VERSION is 1.2.3) */
+/* The minor version (2, if %LIBMODBUS_VERSION is 1.2.3) */
 #define LIBMODBUS_VERSION_MINOR (@LIBMODBUS_VERSION_MINOR@)
 
-/* The micro version of libmb (3, if %LIBMODBUS_VERSION is 1.2.3) */
+/* The micro version (3, if %LIBMODBUS_VERSION is 1.2.3) */
 #define LIBMODBUS_VERSION_MICRO (@LIBMODBUS_VERSION_MICRO@)
 
-/* The full version of libmb, like 1.2.3 */
+/* The full version, like 1.2.3 */
 #define LIBMODBUS_VERSION        @LIBMODBUS_VERSION@
 
-/* The full version of libmb, in string form (suited for
- * string concatenation)
+/* The full version, in string form (suited for string concatenation)
  */
 #define LIBMODBUS_VERSION_STRING "@LIBMODBUS_VERSION@"
 
-/* Numerically encoded version libmb, like 0x010203 */
+/* Numerically encoded version, like 0x010203 */
 #define LIBMODBUS_VERSION_HEX ((LIBMODBUS_MAJOR_VERSION << 24) |        \
                                (LIBMODBUS_MINOR_VERSION << 16) |        \
                                (LIBMODBUS_MICRO_VERSION << 8))
 
-/* Evaluates to True if the version of libmb is greater than @major, @minor and
- * @micro
+/* Evaluates to True if the version is greater than @major, @minor and @micro
  */
 #define LIBMODBUS_VERSION_CHECK(major,minor,micro)      \
     (LIBMODBUS_VERSION_MAJOR > (major) ||               \
@@ -196,123 +152,77 @@ extern const unsigned int libmodbus_version_major;
 extern const unsigned int libmodbus_version_minor;
 extern const unsigned int libmodbus_version_micro;
 
-typedef enum { RTU=0, TCP } type_com_t;
+typedef struct _modbus modbus_t;
 
-/* This structure is byte-aligned */
 typedef struct {
-    /* Slave address */
-    int slave;
-    /* Descriptor (tty or socket) */
-    int fd;
-    /* Communication mode: RTU or TCP */
-    type_com_t type_com;
-    /* Flag debug */
-    int debug;
-    /* TCP port */
-    int port;
-    /* Device: "/dev/ttyS0", "/dev/ttyUSB0" or "/dev/tty.USA19*" on Mac OS X for
-       KeySpan USB<->Serial adapters this string had to be made bigger on OS X
-       as the directory+file name was bigger than 19 bytes. Making it 67 bytes
-       for now, but OS X does support 256 byte file names. May become a problem
-       in the future. */
-#ifdef __APPLE_CC__
-    char device[64];
-#else
-    char device[16];
-#endif
-    /* 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;
-    /* In error_treat with TCP, do a reconnect or just dump the error */
-    uint8_t error_recovery;
-        /* IP address */
-    char ip[16];
-    /* Save old termios settings */
-    struct termios old_tios;
-    struct timeval timeout_begin;
-    struct timeval timeout_end;
-} modbus_param_t;
-
-typedef struct {
-    int nb_coil_status;
-    int nb_input_status;
+    int nb_bits;
+    int nb_input_bits;
     int nb_input_registers;
-    int nb_holding_registers;
-    uint8_t *tab_coil_status;
-    uint8_t *tab_input_status;
+    int nb_registers;
+    uint8_t *tab_bits;
+    uint8_t *tab_input_bits;
     uint16_t *tab_input_registers;
-    uint16_t *tab_holding_registers;
+    uint16_t *tab_registers;
 } modbus_mapping_t;
 
-int modbus_init_rtu(modbus_param_t *mb_param, const char *device,
-                    int baud, char parity, int data_bit,
-                    int stop_bit, int slave);
-int modbus_init_tcp(modbus_param_t *mb_param, const char *ip_address, int port);
-int modbus_set_slave(modbus_param_t *mb_param, int slave);
-int modbus_set_error_recovery(modbus_param_t *mb_param, int enabled);
+modbus_t* modbus_new_rtu(const char *device, int baud, char parity, int data_bit,
+                          int stop_bit, int slave);
+int modbus_set_slave(modbus_t* ctx, int slave);
+
+modbus_t* modbus_new_tcp(const char *ip_address, int port);
+
+int modbus_set_error_recovery(modbus_t *ctx, int enabled);
 
-void modbus_get_timeout_begin(modbus_param_t *mb_param, struct timeval *timeout);
-void modbus_set_timeout_begin(modbus_param_t *mb_param, const struct timeval *timeout);
+void modbus_get_timeout_begin(modbus_t *ctx, struct timeval *timeout);
+void modbus_set_timeout_begin(modbus_t *ctx, const struct timeval *timeout);
 
-void modbus_get_timeout_end(modbus_param_t *mb_param, struct timeval *timeout);
-void modbus_set_timeout_end(modbus_param_t *mb_param, const struct timeval *timeout);
+void modbus_get_timeout_end(modbus_t *ctx, struct timeval *timeout);
+void modbus_set_timeout_end(modbus_t *ctx, const struct timeval *timeout);
 
-int modbus_connect(modbus_param_t *mb_param);
-void modbus_close(modbus_param_t *mb_param);
+int modbus_connect(modbus_t *ctx);
+void modbus_close(modbus_t *ctx);
 
-int modbus_flush(modbus_param_t *mb_param);
-void modbus_set_debug(modbus_param_t *mb_param, int boolean);
+void modbus_free(modbus_t *ctx);
+
+int modbus_flush(modbus_t *ctx);
+void modbus_set_debug(modbus_t *ctx, int boolean);
 
 const char *modbus_strerror(int errnum);
 
-int read_coil_status(modbus_param_t *mb_param, int slave, int start_addr,
-                     int nb, uint8_t *dest);
-int read_input_status(modbus_param_t *mb_param, int slave, int start_addr,
-                      int nb, uint8_t *dest);
-int read_holding_registers(modbus_param_t *mb_param, int slave, int start_addr,
-                           int nb, uint16_t *dest);
-int read_input_registers(modbus_param_t *mb_param, int slave, int start_addr,
-                         int nb, uint16_t *dest);
-int force_single_coil(modbus_param_t *mb_param, int slave, int coil_addr,
-                      int state);
-int preset_single_register(modbus_param_t *mb_param, int slave, int reg_addr,
-                           int value);
-int force_multiple_coils(modbus_param_t *mb_param, int slave, int start_addr,
-                         int nb, const uint8_t *data);
-int preset_multiple_registers(modbus_param_t *mb_param, int slave, int start_addr,
-                              int nb, const uint16_t *data);
-int report_slave_id(modbus_param_t *mb_param, int slave, uint8_t *dest);
-
-int modbus_mapping_new(modbus_mapping_t *mb_mapping,
-                       int nb_coil_status, int nb_input_status,
-                       int nb_holding_registers, int nb_input_registers);
+int modbus_read_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest);
+int modbus_read_input_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest);
+int modbus_read_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest);
+int modbus_read_input_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest);
+int modbus_write_bit(modbus_t *ctx, int coil_addr, int state);
+int modbus_write_register(modbus_t *ctx, int reg_addr, int value);
+int modbus_write_bits(modbus_t *ctx, int addr, int nb, const uint8_t *data);
+int modbus_write_registers(modbus_t *ctx, int addr, int nb, const uint16_t *data);
+int modbus_report_slave_id(modbus_t *ctx, uint8_t *dest);
+
+modbus_mapping_t* modbus_mapping_new(int nb_coil_status, int nb_input_status,
+                                     int nb_holding_registers, int nb_input_registers);
 void modbus_mapping_free(modbus_mapping_t *mb_mapping);
 
-int modbus_slave_listen_tcp(modbus_param_t *mb_param, int nb_connection);
-int modbus_slave_accept_tcp(modbus_param_t *mb_param, int *socket);
-int modbus_slave_receive(modbus_param_t *mb_param, int sockfd, uint8_t *query);
-int modbus_slave_manage(modbus_param_t *mb_param, const uint8_t *query,
-                        int query_length, modbus_mapping_t *mb_mapping);
-void modbus_slave_close_tcp(int socket);
+int modbus_listen(modbus_t *ctx, int nb_connection);
+int modbus_accept(modbus_t *ctx, int *socket);
+int modbus_receive(modbus_t *ctx, int sockfd, uint8_t *req);
+int modbus_reply(modbus_t *ctx, const uint8_t *req,
+                 int req_length, modbus_mapping_t *mb_mapping);
 
 /**
  * UTILS FUNCTIONS
  **/
 
-void set_bits_from_byte(uint8_t *dest, int address, const uint8_t value);
-void set_bits_from_bytes(uint8_t *dest, int address, unsigned int nb_bits,
-                         const uint8_t *tab_byte);
-uint8_t get_byte_from_bits(const uint8_t *src, int address, unsigned int nb_bits);
-float modbus_read_float(const uint16_t *src);
-void modbus_write_float(float real, uint16_t *dest);
+#define MODBUS_GET_HIGH_BYTE(data) ((data >> 8) & 0xFF)
+#define MODBUS_GET_LOW_BYTE(data) (data & 0xFF)
 
-#ifdef __cplusplus
-}
-#endif
+void modbus_set_bits_from_byte(uint8_t *dest, int address, const uint8_t value);
+void modbus_set_bits_from_bytes(uint8_t *dest, int address, unsigned int nb_bits,
+                                const uint8_t *tab_byte);
+uint8_t modbus_get_byte_from_bits(const uint8_t *src, int address, unsigned int nb_bits);
+float modbus_get_float(const uint16_t *src);
+void modbus_set_float(float real, uint16_t *dest);
+
+MODBUS_END_DECLS
 
 #endif  /* _MODBUS_H_ */

tests/bandwidth-master.c

@@ -26,7 +26,6 @@
 #include <modbus.h>
 
 /* Tests based on PI-MBUS-300 documentation */
-#define SERVER_ID     17
 #define NB_LOOPS  100000
 
 #define G_MSEC_PER_SEC 1000
@@ -41,9 +40,9 @@ uint32_t gettime_ms(void)
 
 int main(void)
 {
-    uint8_t *tab_rp_status;
-    uint16_t *tab_rp_registers;
-    modbus_param_t mb_param;
+    uint8_t *tab_bit;
+    uint16_t *tab_reg;
+    modbus_t *ctx;
     int i;
     int nb_points;
     double elapsed;
@@ -54,28 +53,28 @@ int main(void)
     int rc;
 
     /* TCP */
-    modbus_init_tcp(&mb_param, "127.0.0.1", 1502);
-    rc = modbus_connect(&mb_param);
-    if (rc == -1) {
+    ctx = modbus_new_tcp("127.0.0.1", 1502);
+    if (modbus_connect(ctx) == -1) {
         fprintf(stderr, "Connexion failed: %s\n",
                 modbus_strerror(errno));
+        modbus_free(ctx);
         return -1;
     }
 
     /* Allocate and initialize the memory to store the status */
-    tab_rp_status = (uint8_t *) malloc(MAX_STATUS * sizeof(uint8_t));
-    memset(tab_rp_status, 0, MAX_STATUS * sizeof(uint8_t));
+    tab_bit = (uint8_t *) malloc(MODBUS_MAX_BITS * sizeof(uint8_t));
+    memset(tab_bit, 0, MODBUS_MAX_BITS * sizeof(uint8_t));
 
     /* Allocate and initialize the memory to store the registers */
-    tab_rp_registers = (uint16_t *) malloc(MAX_REGISTERS * sizeof(uint16_t));
-    memset(tab_rp_registers, 0, MAX_REGISTERS * sizeof(uint16_t));
+    tab_reg = (uint16_t *) malloc(MODBUS_MAX_REGISTERS * sizeof(uint16_t));
+    memset(tab_reg, 0, MODBUS_MAX_REGISTERS * sizeof(uint16_t));
 
-    printf("READ COIL STATUS\n\n");
+    printf("READ BITS\n\n");
 
-    nb_points = MAX_STATUS;
+    nb_points = MODBUS_MAX_BITS;
     start = gettime_ms();
     for (i=0; i<NB_LOOPS; i++) {
-        rc = read_coil_status(&mb_param, SERVER_ID, 0, nb_points, tab_rp_status);
+        rc = modbus_read_bits(ctx, 0, nb_points, tab_bit);
         if (rc == -1) {
             fprintf(stderr, "%s\n", modbus_strerror(errno));
             return -1;
@@ -107,12 +106,12 @@ int main(void)
     printf("* %'d KiB/s\n", rate);
     printf("\n\n");
 
-    printf("READ HOLDING REGISTERS\n\n");
+    printf("READ REGISTERS\n\n");
 
-    nb_points = MAX_REGISTERS;
+    nb_points = MODBUS_MAX_REGISTERS;
     start = gettime_ms();
     for (i=0; i<NB_LOOPS; i++) {
-        rc = read_holding_registers(&mb_param, SERVER_ID, 0, nb_points, tab_rp_registers);
+        rc = modbus_read_registers(ctx, 0, nb_points, tab_reg);
         if (rc == -1) {
             fprintf(stderr, "%s\n", modbus_strerror(errno));
             return -1;
@@ -145,11 +144,12 @@ int main(void)
     printf("\n");
 
     /* Free the memory */
-    free(tab_rp_status);
-    free(tab_rp_registers);
+    free(tab_bit);
+    free(tab_reg);
 
     /* Close the connection */
-    modbus_close(&mb_param);
+    modbus_close(ctx);
+    modbus_free(ctx);
 
     return 0;
 }

tests/bandwidth-slave-many-up.c

@@ -26,13 +26,15 @@
 
 #define NB_CONNECTION    5
 
+modbus_t *ctx = NULL;
 int slave_socket;
-modbus_mapping_t mb_mapping;
+modbus_mapping_t *mb_mapping;
 
 static void close_sigint(int dummy)
 {
-    modbus_slave_close_tcp(slave_socket);
-    modbus_mapping_free(&mb_mapping);
+    close(slave_socket);
+    modbus_free(ctx);
+    modbus_mapping_free(mb_mapping);
 
     exit(dummy);
 }
@@ -40,7 +42,6 @@ static void close_sigint(int dummy)
 int main(void)
 {
     int master_socket;
-    modbus_param_t mb_param;
     int rc;
     fd_set refset;
     fd_set rdset;
@@ -48,16 +49,18 @@ int main(void)
     /* Maximum file descriptor number */
     int fdmax;
 
-    modbus_init_tcp(&mb_param, "127.0.0.1", 1502);
+    ctx = modbus_new_tcp("127.0.0.1", 1502);
 
-    rc = modbus_mapping_new(&mb_mapping, MAX_STATUS, 0, MAX_REGISTERS, 0);
-    if (rc == -1) {
+    mb_mapping = modbus_mapping_new(MODBUS_MAX_BITS, 0,
+                                    MODBUS_MAX_REGISTERS, 0);
+    if (mb_mapping == NULL) {
         fprintf(stderr, "Failed to allocate the mapping: %s\n",
                 modbus_strerror(errno));
+        modbus_free(ctx);
         return -1;
     }
 
-    slave_socket = modbus_slave_listen_tcp(&mb_param, NB_CONNECTION);
+    slave_socket = modbus_listen(ctx, NB_CONNECTION);
 
     signal(SIGINT, close_sigint);
 
@@ -105,15 +108,15 @@ int main(void)
                     }
                 } else {
                     /* An already connected master has sent a new query */
-                    uint8_t query[MAX_MESSAGE_LENGTH];
+                    uint8_t query[MODBUS_MAX_ADU_LENGTH_TCP];
 
-                    rc = modbus_slave_receive(&mb_param, master_socket, query);
+                    rc = modbus_receive(ctx, master_socket, query);
                     if (rc != -1) {
-                        modbus_slave_manage(&mb_param, query, rc, &mb_mapping);
+                        modbus_reply(ctx, query, rc, mb_mapping);
                     } else {
                         /* Connection closed by the client, end of server */
                         printf("Connection closed on socket %d\n", master_socket);
-                        modbus_slave_close_tcp(master_socket);
+                        close(master_socket);
 
                         /* Remove from reference set */
                         FD_CLR(master_socket, &refset);

tests/bandwidth-slave-one.c

@@ -26,28 +26,30 @@
 int main(void)
 {
     int socket;
-    modbus_param_t mb_param;
-    modbus_mapping_t mb_mapping;
+    modbus_t *ctx;
+    modbus_mapping_t *mb_mapping;
     int rc;
 
-    modbus_init_tcp(&mb_param, "127.0.0.1", 1502);
+    ctx = modbus_new_tcp("127.0.0.1", 1502);
 
-    rc = modbus_mapping_new(&mb_mapping,  MAX_STATUS, 0, MAX_REGISTERS, 0);
-    if (rc == -1) {
+    mb_mapping = modbus_mapping_new(MODBUS_MAX_BITS, 0,
+                                    MODBUS_MAX_REGISTERS, 0);
+    if (mb_mapping == NULL) {
         fprintf(stderr, "Failed to allocate the mapping: %s\n",
                 modbus_strerror(errno));
+        modbus_free(ctx);
         return -1;
     }
 
-    socket = modbus_slave_listen_tcp(&mb_param, 1);
-    modbus_slave_accept_tcp(&mb_param, &socket);
+    socket = modbus_listen(ctx, 1);
+    modbus_accept(ctx, &socket);
 
     for(;;) {
-        uint8_t query[MAX_MESSAGE_LENGTH];
+        uint8_t query[MODBUS_MAX_ADU_LENGTH_TCP];
 
-        rc = modbus_slave_receive(&mb_param, -1, query);
+        rc = modbus_receive(ctx, -1, query);
         if (rc >= 0) {
-            modbus_slave_manage(&mb_param, query, rc, &mb_mapping);
+            modbus_reply(ctx, query, rc, mb_mapping);
         } else {
             /* Connection closed by the client or server */
             break;
@@ -56,9 +58,9 @@ int main(void)
 
     printf("Quit the loop: %s\n", modbus_strerror(errno));
 
+    modbus_mapping_free(mb_mapping);
     close(socket);
-    modbus_mapping_free(&mb_mapping);
-    modbus_close(&mb_param);
+    modbus_free(ctx);
 
     return 0;
 }

tests/random-test-master.c

@@ -25,13 +25,13 @@
 
 /* The goal of this program is to check all major functions of
    libmodbus:
-   - force_single_coil
-   - read_coil_status
-   - force_multiple_coils
-   - preset_single_register
-   - read_holding_registers
-   - preset_multiple_registers
-   - read_holding_registers
+   - write_coil
+   - read_bits
+   - write_coils
+   - write_register
+   - read_registers
+   - write_registers
+   - read_registers
 
    All these functions are called with random values on a address
    range defined by the following defines.
@@ -47,38 +47,40 @@
  */
 int main(void)
 {
+    modbus_t *ctx;
     int rc;
     int nb_fail;
     int nb_loop;
     int addr;
     int nb;
-    uint8_t *tab_rq_status;
-    uint8_t *tab_rp_status;
+    uint8_t *tab_rq_bits;
+    uint8_t *tab_rp_bits;
     uint16_t *tab_rq_registers;
     uint16_t *tab_rp_registers;
-    modbus_param_t mb_param;
 
     /*
-      modbus_init_rtu(&mb_param, "/dev/ttyS0", 19200, 'N', 8, 1, MY_ID);
+    ctx = modbus_new_rtu("/dev/ttyS0", 19200, 'N', 8, 1, MY_ID);
+    modbus_set_slave(ctx, SERVER_ID);
     */
 
     /* TCP */
-    modbus_init_tcp(&mb_param, "127.0.0.1", 1502);
-    modbus_set_debug(&mb_param, TRUE);
-    if (modbus_connect(&mb_param) == -1) {
+    ctx = modbus_new_tcp("127.0.0.1", 1502);
+    modbus_set_debug(ctx, TRUE);
+    if (modbus_connect(ctx) == -1) {
         fprintf(stderr, "Connection failed: %s\n",
                 modbus_strerror(errno));
+        modbus_free(ctx);
         return -1;
     }
 
     /* Allocate and initialize the different memory spaces */
     nb = ADDRESS_END - ADDRESS_START;
 
-    tab_rq_status = (uint8_t *) malloc(nb * sizeof(uint8_t));
-    memset(tab_rq_status, 0, nb * sizeof(uint8_t));
+    tab_rq_bits = (uint8_t *) malloc(nb * sizeof(uint8_t));
+    memset(tab_rq_bits, 0, nb * sizeof(uint8_t));
 
-    tab_rp_status = (uint8_t *) malloc(nb * sizeof(uint8_t));
-    memset(tab_rp_status, 0, nb * sizeof(uint8_t));
+    tab_rp_bits = (uint8_t *) malloc(nb * sizeof(uint8_t));
+    memset(tab_rp_bits, 0, nb * sizeof(uint8_t));
 
     tab_rq_registers = (uint16_t *) malloc(nb * sizeof(uint16_t));
     memset(tab_rq_registers, 0, nb * sizeof(uint16_t));
@@ -94,49 +96,44 @@ int main(void)
             /* Random numbers (short) */
             for (i=0; i<nb; i++) {
                 tab_rq_registers[i] = (uint16_t) (65535.0*rand() / (RAND_MAX + 1.0));
-                tab_rq_status[i] = tab_rq_registers[i] % 2;
+                tab_rq_bits[i] = tab_rq_registers[i] % 2;
             }
             nb = ADDRESS_END - addr;
 
-            /* SINGLE COIL */
-            rc = force_single_coil(&mb_param, SERVER_ID, addr, tab_rq_status[0]);
+            /* WRITE BIT */
+            rc = modbus_write_bit(ctx, addr, tab_rq_bits[0]);
             if (rc != 1) {
-                printf("ERROR force_single_coil (%d)\n", rc);
-                printf("Slave = %d, address = %d, value = %d\n",
-                       SERVER_ID, addr, tab_rq_status[0]);
+                printf("ERROR modbus_write_bit (%d)\n", rc);
+                printf("Address = %d, value = %d\n", addr, tab_rq_bits[0]);
                 nb_fail++;
             } else {
-                rc = read_coil_status(&mb_param, SERVER_ID, addr, 1, tab_rp_status);
-                if (rc != 1 || tab_rq_status[0] != tab_rp_status[0]) {
-                    printf("ERROR read_coil_status single (%d)\n", rc);
-                    printf("Slave = %d, address = %d\n",
-                           SERVER_ID, addr);
+                rc = modbus_read_bits(ctx, addr, 1, tab_rp_bits);
+                if (rc != 1 || tab_rq_bits[0] != tab_rp_bits[0]) {
+                    printf("ERROR modbus_read_bits single (%d)\n", rc);
+                    printf("address = %d\n", addr);
                     nb_fail++;
                 }
             }
 
-            /* MULTIPLE COILS */
-            rc = force_multiple_coils(&mb_param, SERVER_ID, addr, nb, tab_rq_status);
+            /* MULTIPLE BITS */
+            rc = modbus_write_bits(ctx, addr, nb, tab_rq_bits);
             if (rc != nb) {
-                printf("ERROR force_multiple_coils (%d)\n", rc);
-                printf("Slave = %d, address = %d, nb = %d\n",
-                       SERVER_ID, addr, nb);
+                printf("ERROR modbus_write_bits (%d)\n", rc);
+                printf("Address = %d, nb = %d\n", addr, nb);
                 nb_fail++;
             } else {
-                rc = read_coil_status(&mb_param, SERVER_ID, addr, nb, tab_rp_status);
+                rc = modbus_read_bits(ctx, addr, nb, tab_rp_bits);
                 if (rc != nb) {
-                    printf("ERROR read_coil_status\n");
-                    printf("Slave = %d, address = %d, nb = %d\n",
-                           SERVER_ID, addr, nb);
+                    printf("ERROR modbus_read_bits\n");
+                    printf("Address = %d, nb = %d\n", addr, nb);
                     nb_fail++;
                 } else {
                     for (i=0; i<nb; i++) {
-                        if (tab_rp_status[i] != tab_rq_status[i]) {
-                            printf("ERROR read_coil_status\n");
-                            printf("Slave = %d, address = %d, value %d (0x%X) != %d (0x%X)\n",
-                                   SERVER_ID, addr,
-                                   tab_rq_status[i], tab_rq_status[i],
-                                   tab_rp_status[i], tab_rp_status[i]);
+                        if (tab_rp_bits[i] != tab_rq_bits[i]) {
+                            printf("ERROR modbus_read_bits\n");
+                            printf("Address = %d, value %d (0x%X) != %d (0x%X)\n",
+                                   addr, tab_rq_bits[i], tab_rq_bits[i],
+                                   tab_rp_bits[i], tab_rp_bits[i]);
                             nb_fail++;
                         }
                     }
@@ -144,25 +141,23 @@ int main(void)
             }
 
             /* SINGLE REGISTER */
-            rc = preset_single_register(&mb_param, SERVER_ID, addr, tab_rq_registers[0]);
+            rc = modbus_write_register(ctx, addr, tab_rq_registers[0]);
             if (rc != 1) {
-                printf("ERROR preset_single_register (%d)\n", rc);
-                printf("Slave = %d, address = %d, value = %d (0x%X)\n",
-                       SERVER_ID, addr, tab_rq_registers[0], tab_rq_registers[0]);
+                printf("ERROR modbus_write_register (%d)\n", rc);
+                printf("Address = %d, value = %d (0x%X)\n",
+                       addr, tab_rq_registers[0], tab_rq_registers[0]);
                 nb_fail++;
             } else {
-                rc = read_holding_registers(&mb_param, SERVER_ID, addr, 1, tab_rp_registers);
+                rc = modbus_read_registers(ctx, addr, 1, tab_rp_registers);
                 if (rc != 1) {
-                    printf("ERROR read_holding_registers single (%d)\n", rc);
-                    printf("Slave = %d, address = %d\n",
-                           SERVER_ID, addr);
+                    printf("ERROR modbus_read_registers single (%d)\n", rc);
+                    printf("Address = %d\n", addr);
                     nb_fail++;
                 } else {
                     if (tab_rq_registers[0] != tab_rp_registers[0]) {
-                        printf("ERROR read_holding_registers single\n");
-                        printf("Slave = %d, address = %d, value = %d (0x%X) != %d (0x%X)\n",
-                               SERVER_ID, addr,
-                               tab_rq_registers[0], tab_rq_registers[0],
+                        printf("ERROR modbus_read_registers single\n");
+                        printf("Address = %d, value = %d (0x%X) != %d (0x%X)\n",
+                               addr, tab_rq_registers[0], tab_rq_registers[0],
                                tab_rp_registers[0], tab_rp_registers[0]);
                         nb_fail++;
                     }
@@ -170,28 +165,23 @@ int main(void)
             }
 
             /* MULTIPLE REGISTERS */
-            rc = preset_multiple_registers(&mb_param, SERVER_ID, addr, nb,
-                                           tab_rq_registers);
+            rc = modbus_write_registers(ctx, addr, nb, tab_rq_registers);
             if (rc != nb) {
-                printf("ERROR preset_multiple_registers (%d)\n", rc);
-                printf("Slave = %d, address = %d, nb = %d\n",
-                       SERVER_ID, addr, nb);
+                printf("ERROR modbus_write_registers (%d)\n", rc);
+                printf("Address = %d, nb = %d\n", addr, nb);
                 nb_fail++;
             } else {
-                rc = read_holding_registers(&mb_param, SERVER_ID, addr, nb,
-                                            tab_rp_registers);
+                rc = modbus_read_registers(ctx, addr, nb, tab_rp_registers);
                 if (rc != nb) {
-                    printf("ERROR read_holding_registers (%d)\n", rc);
-                    printf("Slave = %d, address = %d, nb = %d\n",
-                           SERVER_ID, addr, nb);
+                    printf("ERROR modbus_read_registers (%d)\n", rc);
+                    printf("Address = %d, nb = %d\n", addr, nb);
                     nb_fail++;
                 } else {
                     for (i=0; i<nb; i++) {
                         if (tab_rq_registers[i] != tab_rp_registers[i]) {
-                            printf("ERROR read_holding_registers\n");
-                            printf("Slave = %d, address = %d, value %d (0x%X) != %d (0x%X)\n",
-                                   SERVER_ID, addr,
-                                   tab_rq_registers[i], tab_rq_registers[i],
+                            printf("ERROR modbus_read_registers\n");
+                            printf("Address = %d, value %d (0x%X) != %d (0x%X)\n",
+                                   addr, tab_rq_registers[i], tab_rq_registers[i],
                                    tab_rp_registers[i], tab_rp_registers[i]);
                             nb_fail++;
                         }
@@ -209,13 +199,14 @@ int main(void)
     }
 
     /* Free the memory */
-    free(tab_rq_status);
-    free(tab_rp_status);
+    free(tab_rq_bits);
+    free(tab_rp_bits);
     free(tab_rq_registers);
     free(tab_rp_registers);
 
     /* Close the connection */
-    modbus_close(&mb_param);
+    modbus_close(ctx);
+    modbus_free(ctx);
 
     return 0;
 }

tests/random-test-slave.c

@@ -25,31 +25,31 @@
 int main(void)
 {
     int socket;
-    modbus_param_t mb_param;
-    modbus_mapping_t mb_mapping;
-    int rc;
+    modbus_t *ctx;
+    modbus_mapping_t *mb_mapping;
 
-    modbus_init_tcp(&mb_param, "127.0.0.1", 1502);
-    /* modbus_set_debug(&mb_param, TRUE); */
+    ctx = modbus_new_tcp("127.0.0.1", 1502);
+    /* modbus_set_debug(ctx, TRUE); */
 
-    rc = modbus_mapping_new(&mb_mapping, 500, 500, 500, 500);
-    if (rc == -1) {
+    mb_mapping = modbus_mapping_new(500, 500, 500, 500);
+    if (mb_mapping == NULL) {
         fprintf(stderr, "Failed to allocate the mapping: %s\n",
                 modbus_strerror(errno));
+        modbus_free(ctx);
         return -1;
     }
 
-    socket = modbus_slave_listen_tcp(&mb_param, 1);
-    modbus_slave_accept_tcp(&mb_param, &socket);
+    socket = modbus_listen(ctx, 1);
+    modbus_accept(ctx, &socket);
 
     for (;;) {
-        uint8_t query[MAX_MESSAGE_LENGTH];
+        uint8_t query[MODBUS_MAX_ADU_LENGTH_TCP];
         int rc;
 
-        rc = modbus_slave_receive(&mb_param, -1, query);
+        rc = modbus_receive(ctx, -1, query);
         if (rc != -1) {
             /* rc is the query size */
-            modbus_slave_manage(&mb_param, query, rc, &mb_mapping);
+            modbus_reply(ctx, query, rc, mb_mapping);
         } else {
             /* Connection closed by the client or error */
             break;
@@ -58,9 +58,9 @@ int main(void)
 
     printf("Quit the loop: %s\n", modbus_strerror(errno));
 
-    close(socket);
-    modbus_mapping_free(&mb_mapping);
-    modbus_close(&mb_param);
+    modbus_mapping_free(mb_mapping);
+    modbus_close(ctx);
+    modbus_free(ctx);
 
     return 0;
 }

tests/unit-test-master.c

@@ -26,10 +26,11 @@
 
 int main(void)
 {
-    uint8_t *tab_rp_status;
+    uint8_t *tab_rp_bits;
     uint16_t *tab_rp_registers;
     uint16_t *tab_rp_registers_bad;
-    modbus_param_t mb_param;
+    modbus_t *ctx;
+    int is_mode_rtu = FALSE;
     int i;
     uint8_t value;
     int address;
@@ -40,30 +41,32 @@ int main(void)
     struct timeval timeout_begin_new;
 
     /*
-      modbus_init_rtu(&mb_param, "/dev/ttyS0", 19200, 'N', 8, 1,
-      CLIENT_ID);
+      ctx = modbus_new_rtu("/dev/ttyS0", 19200, 'N', 8, 1, CLIENT_ID);
+      modbus_set_slave(ctx, SERVER_ID);
+      is_mode_rtu = TRUE;
     */
 
     /* TCP */
-    modbus_init_tcp(&mb_param, "127.0.0.1", 1502);
-    modbus_set_debug(&mb_param, TRUE);
+    ctx = modbus_new_tcp("127.0.0.1", 1502);
+    modbus_set_debug(ctx, TRUE);
 
-    if (modbus_connect(&mb_param) == -1) {
+    if (modbus_connect(ctx) == -1) {
         fprintf(stderr, "Connection failed: %s\n",
                 modbus_strerror(errno));
+        modbus_free(ctx);
         return -1;
     }
 
-    /* Allocate and initialize the memory to store the status */
-    nb_points = (UT_COIL_STATUS_NB_POINTS > UT_INPUT_STATUS_NB_POINTS) ?
-        UT_COIL_STATUS_NB_POINTS : UT_INPUT_STATUS_NB_POINTS;
-    tab_rp_status = (uint8_t *) malloc(nb_points * sizeof(uint8_t));
-    memset(tab_rp_status, 0, nb_points * sizeof(uint8_t));
+    /* Allocate and initialize the memory to store the bits */
+    nb_points = (UT_BITS_NB_POINTS > UT_INPUT_BITS_NB_POINTS) ?
+        UT_BITS_NB_POINTS : UT_INPUT_BITS_NB_POINTS;
+    tab_rp_bits = (uint8_t *) malloc(nb_points * sizeof(uint8_t));
+    memset(tab_rp_bits, 0, nb_points * sizeof(uint8_t));
 
     /* Allocate and initialize the memory to store the registers */
-    nb_points = (UT_HOLDING_REGISTERS_NB_POINTS >
+    nb_points = (UT_REGISTERS_NB_POINTS >
                  UT_INPUT_REGISTERS_NB_POINTS) ?
-        UT_HOLDING_REGISTERS_NB_POINTS : UT_INPUT_REGISTERS_NB_POINTS;
+        UT_REGISTERS_NB_POINTS : UT_INPUT_REGISTERS_NB_POINTS;
     tab_rp_registers = (uint16_t *) malloc(nb_points * sizeof(uint16_t));
     memset(tab_rp_registers, 0, nb_points * sizeof(uint16_t));
 
@@ -71,11 +74,11 @@ int main(void)
 
     printf("\nTEST WRITE/READ:\n");
 
-    /** COIL STATUS **/
+    /** COIL BITS **/
 
     /* Single */
-    rc = force_single_coil(&mb_param, SERVER_ID, UT_COIL_STATUS_ADDRESS, ON);
-    printf("1/2 force_single_coil: ");
+    rc = modbus_write_bit(ctx, UT_BITS_ADDRESS, ON);
+    printf("1/2 modbus_write_bit: ");
     if (rc == 1) {
         printf("OK\n");
     } else {
@@ -83,33 +86,30 @@ int main(void)
         goto close;
     }
 
-    rc = read_coil_status(&mb_param, SERVER_ID, UT_COIL_STATUS_ADDRESS, 1,
-                          tab_rp_status);
-    printf("2/2 read_coil_status: ");
+    rc = modbus_read_bits(ctx, UT_BITS_ADDRESS, 1, tab_rp_bits);
+    printf("2/2 modbus_read_bits: ");
     if (rc != 1) {
         printf("FAILED (nb points %d)\n", rc);
         goto close;
     }
 
-    if (tab_rp_status[0] != ON) {
-        printf("FAILED (%0X = != %0X)\n", tab_rp_status[0], ON);
+    if (tab_rp_bits[0] != ON) {
+        printf("FAILED (%0X = != %0X)\n", tab_rp_bits[0], ON);
         goto close;
     }
     printf("OK\n");
     /* End single */
 
-    /* Multiple coils */
+    /* Multiple bits */
     {
-        uint8_t tab_value[UT_COIL_STATUS_NB_POINTS];
-
-        set_bits_from_bytes(tab_value, 0, UT_COIL_STATUS_NB_POINTS,
-                            UT_COIL_STATUS_TAB);
-        rc = force_multiple_coils(&mb_param, SERVER_ID,
-                                  UT_COIL_STATUS_ADDRESS,
-                                  UT_COIL_STATUS_NB_POINTS,
-                                  tab_value);
-        printf("1/2 force_multiple_coils: ");
-        if (rc == UT_COIL_STATUS_NB_POINTS) {
+        uint8_t tab_value[UT_BITS_NB_POINTS];
+
+        modbus_set_bits_from_bytes(tab_value, 0, UT_BITS_NB_POINTS,
+                                   UT_BITS_TAB);
+        rc = modbus_write_bits(ctx, UT_BITS_ADDRESS,
+                               UT_BITS_NB_POINTS, tab_value);
+        printf("1/2 modbus_write_bits: ");
+        if (rc == UT_BITS_NB_POINTS) {
             printf("OK\n");
         } else {
             printf("FAILED\n");
@@ -117,24 +117,24 @@ int main(void)
         }
     }
 
-    rc = read_coil_status(&mb_param, SERVER_ID, UT_COIL_STATUS_ADDRESS,
-                          UT_COIL_STATUS_NB_POINTS, tab_rp_status);
-    printf("2/2 read_coil_status: ");
-    if (rc != UT_COIL_STATUS_NB_POINTS) {
+    rc = modbus_read_bits(ctx, UT_BITS_ADDRESS,
+                          UT_BITS_NB_POINTS, tab_rp_bits);
+    printf("2/2 modbus_read_bits: ");
+    if (rc != UT_BITS_NB_POINTS) {
         printf("FAILED (nb points %d)\n", rc);
         goto close;
     }
 
     i = 0;
-    address = UT_COIL_STATUS_ADDRESS;
-    nb_points = UT_COIL_STATUS_NB_POINTS;
+    address = UT_BITS_ADDRESS;
+    nb_points = UT_BITS_NB_POINTS;
     while (nb_points > 0) {
         int nb_bits = (nb_points > 8) ? 8 : nb_points;
 
-        value = get_byte_from_bits(tab_rp_status, i*8, nb_bits);
-        if (value != UT_COIL_STATUS_TAB[i]) {
+        value = modbus_get_byte_from_bits(tab_rp_bits, i*8, nb_bits);
+        if (value != UT_BITS_TAB[i]) {
             printf("FAILED (%0X != %0X)\n",
-                   value, UT_COIL_STATUS_TAB[i]);
+                   value, UT_BITS_TAB[i]);
             goto close;
         }
 
@@ -142,28 +142,28 @@ int main(void)
         i++;
     }
     printf("OK\n");
-    /* End of multiple coils */
+    /* End of multiple bits */
 
-    /** INPUT STATUS **/
-    rc = read_input_status(&mb_param, SERVER_ID, UT_INPUT_STATUS_ADDRESS,
-                           UT_INPUT_STATUS_NB_POINTS, tab_rp_status);
-    printf("1/1 read_input_status: ");
+    /** DISCRETE INPUTS **/
+    rc = modbus_read_input_bits(ctx, UT_INPUT_BITS_ADDRESS,
+                                UT_INPUT_BITS_NB_POINTS, tab_rp_bits);
+    printf("1/1 modbus_read_input_bits: ");
 
-    if (rc != UT_INPUT_STATUS_NB_POINTS) {
+    if (rc != UT_INPUT_BITS_NB_POINTS) {
         printf("FAILED (nb points %d)\n", rc);
         goto close;
     }
 
     i = 0;
-    address = UT_INPUT_STATUS_ADDRESS;
-    nb_points = UT_INPUT_STATUS_NB_POINTS;
+    address = UT_INPUT_BITS_ADDRESS;
+    nb_points = UT_INPUT_BITS_NB_POINTS;
     while (nb_points > 0) {
         int nb_bits = (nb_points > 8) ? 8 : nb_points;
 
-        value = get_byte_from_bits(tab_rp_status, i*8, nb_bits);
-        if (value != UT_INPUT_STATUS_TAB[i]) {
+        value = modbus_get_byte_from_bits(tab_rp_bits, i*8, nb_bits);
+        if (value != UT_INPUT_BITS_TAB[i]) {
             printf("FAILED (%0X != %0X)\n",
-                   value, UT_INPUT_STATUS_TAB[i]);
+                   value, UT_INPUT_BITS_TAB[i]);
             goto close;
         }
 
@@ -175,9 +175,8 @@ int main(void)
     /** HOLDING REGISTERS **/
 
     /* Single register */
-    rc = preset_single_register(&mb_param, SERVER_ID,
-                                UT_HOLDING_REGISTERS_ADDRESS, 0x1234);
-    printf("1/2 preset_single_register: ");
+    rc = modbus_write_register(ctx, UT_REGISTERS_ADDRESS, 0x1234);
+    printf("1/2 modbus_write_register: ");
     if (rc == 1) {
         printf("OK\n");
     } else {
@@ -185,10 +184,9 @@ int main(void)
         goto close;
     }
 
-    rc = read_holding_registers(&mb_param, SERVER_ID,
-                                UT_HOLDING_REGISTERS_ADDRESS,
-                                1, tab_rp_registers);
-    printf("2/2 read_holding_registers: ");
+    rc = modbus_read_registers(ctx, UT_REGISTERS_ADDRESS,
+                               1, tab_rp_registers);
+    printf("2/2 modbus_read_registers: ");
     if (rc != 1) {
         printf("FAILED (nb points %d)\n", rc);
         goto close;
@@ -203,33 +201,31 @@ int main(void)
     /* End of single register */
 
     /* Many registers */
-    rc = preset_multiple_registers(&mb_param, SERVER_ID,
-                                   UT_HOLDING_REGISTERS_ADDRESS,
-                                   UT_HOLDING_REGISTERS_NB_POINTS,
-                                   UT_HOLDING_REGISTERS_TAB);
-    printf("1/2 preset_multiple_registers: ");
-    if (rc == UT_HOLDING_REGISTERS_NB_POINTS) {
+    rc = modbus_write_registers(ctx, UT_REGISTERS_ADDRESS,
+                                UT_REGISTERS_NB_POINTS,
+                                UT_REGISTERS_TAB);
+    printf("1/2 modbus_write_registers: ");
+    if (rc == UT_REGISTERS_NB_POINTS) {
         printf("OK\n");
     } else {
         printf("FAILED\n");
         goto close;
     }
 
-    rc = read_holding_registers(&mb_param, SERVER_ID,
-                                UT_HOLDING_REGISTERS_ADDRESS,
-                                UT_HOLDING_REGISTERS_NB_POINTS,
-                                tab_rp_registers);
-    printf("2/2 read_holding_registers: ");
-    if (rc != UT_HOLDING_REGISTERS_NB_POINTS) {
+    rc = modbus_read_registers(ctx, UT_REGISTERS_ADDRESS,
+                               UT_REGISTERS_NB_POINTS,
+                               tab_rp_registers);
+    printf("2/2 modbus_read_registers: ");
+    if (rc != UT_REGISTERS_NB_POINTS) {
         printf("FAILED (nb points %d)\n", rc);
         goto close;
     }
 
-    for (i=0; i < UT_HOLDING_REGISTERS_NB_POINTS; i++) {
-        if (tab_rp_registers[i] != UT_HOLDING_REGISTERS_TAB[i]) {
+    for (i=0; i < UT_REGISTERS_NB_POINTS; i++) {
+        if (tab_rp_registers[i] != UT_REGISTERS_TAB[i]) {
             printf("FAILED (%0X != %0X)\n",
                    tab_rp_registers[i],
-                   UT_HOLDING_REGISTERS_TAB[i]);
+                   UT_REGISTERS_TAB[i]);
             goto close;
         }
     }
@@ -238,11 +234,10 @@ int main(void)
 
 
     /** INPUT REGISTERS **/
-    rc = read_input_registers(&mb_param, SERVER_ID,
-                              UT_INPUT_REGISTERS_ADDRESS,
-                              UT_INPUT_REGISTERS_NB_POINTS,
-                              tab_rp_registers);
-    printf("1/1 read_input_registers: ");
+    rc = modbus_read_input_registers(ctx, UT_INPUT_REGISTERS_ADDRESS,
+                                     UT_INPUT_REGISTERS_NB_POINTS,
+                                     tab_rp_registers);
+    printf("1/1 modbus_read_input_registers: ");
     if (rc != UT_INPUT_REGISTERS_NB_POINTS) {
         printf("FAILED (nb points %d)\n", rc);
         goto close;
@@ -257,11 +252,10 @@ int main(void)
     }
     printf("OK\n");
 
-
     printf("\nTEST FLOATS\n");
     /** FLOAT **/
-    printf("1/2 Write float: ");
-    modbus_write_float(UT_REAL, tab_rp_registers);
+    printf("1/2 Set float: ");
+    modbus_set_float(UT_REAL, tab_rp_registers);
     if (tab_rp_registers[1] == (UT_IREAL >> 16) &&
         tab_rp_registers[0] == (UT_IREAL & 0xFFFF)) {
         printf("OK\n");
@@ -271,8 +265,8 @@ int main(void)
         goto close;
     }
 
-    printf("2/2 Read float: ");
-    real = modbus_read_float(tab_rp_registers);
+    printf("2/2 Get float: ");
+    real = modbus_get_float(tab_rp_registers);
     if (real == UT_REAL) {
         printf("OK\n");
     } else {
@@ -288,23 +282,21 @@ int main(void)
     /* The mapping begins at 0 and ending at address + nb_points so
      * the addresses below are not valid. */
 
-    rc = read_coil_status(&mb_param, SERVER_ID,
-                          UT_COIL_STATUS_ADDRESS,
-                          UT_COIL_STATUS_NB_POINTS + 1,
-                          tab_rp_status);
-    printf("* read_coil_status: ");
-    if (rc == -1 && errno == EMBXILADD)
+    rc = modbus_read_bits(ctx, UT_BITS_ADDRESS,
+                          UT_BITS_NB_POINTS + 1,
+                          tab_rp_bits);
+    printf("* modbus_read_bits: ");
+    if (rc == -1 && errno == EMBXILADD) {
         printf("OK\n");
-    else {
+    } else {
         printf("FAILED\n");
         goto close;
     }
 
-    rc = read_input_status(&mb_param, SERVER_ID,
-                           UT_INPUT_STATUS_ADDRESS,
-                           UT_INPUT_STATUS_NB_POINTS + 1,
-                           tab_rp_status);
-    printf("* read_input_status: ");
+    rc = modbus_read_input_bits(ctx, UT_INPUT_BITS_ADDRESS,
+                                UT_INPUT_BITS_NB_POINTS + 1,
+                                tab_rp_bits);
+    printf("* modbus_read_input_bits: ");
     if (rc == -1 && errno == EMBXILADD)
         printf("OK\n");
     else {
@@ -312,11 +304,10 @@ int main(void)
         goto close;
     }
 
-    rc = read_holding_registers(&mb_param, SERVER_ID,
-                                UT_HOLDING_REGISTERS_ADDRESS,
-                                UT_HOLDING_REGISTERS_NB_POINTS + 1,
-                                tab_rp_registers);
-    printf("* read_holding_registers: ");
+    rc = modbus_read_registers(ctx, UT_REGISTERS_ADDRESS,
+                               UT_REGISTERS_NB_POINTS + 1,
+                               tab_rp_registers);
+    printf("* modbus_read_registers: ");
     if (rc == -1 && errno == EMBXILADD)
         printf("OK\n");
     else {
@@ -324,11 +315,10 @@ int main(void)
         goto close;
     }
 
-    rc = read_input_registers(&mb_param, SERVER_ID,
-                              UT_INPUT_REGISTERS_ADDRESS,
-                              UT_INPUT_REGISTERS_NB_POINTS + 1,
-                              tab_rp_registers);
-    printf("* read_input_registers: ");
+    rc = modbus_read_input_registers(ctx, UT_INPUT_REGISTERS_ADDRESS,
+                                     UT_INPUT_REGISTERS_NB_POINTS + 1,
+                                     tab_rp_registers);
+    printf("* modbus_read_input_registers: ");
     if (rc == -1 && errno == EMBXILADD)
         printf("OK\n");
     else {
@@ -336,10 +326,8 @@ int main(void)
         goto close;
     }
 
-    rc = force_single_coil(&mb_param, SERVER_ID,
-                           UT_COIL_STATUS_ADDRESS + UT_COIL_STATUS_NB_POINTS,
-                           ON);
-    printf("* force_single_coil: ");
+    rc = modbus_write_bit(ctx, UT_BITS_ADDRESS + UT_BITS_NB_POINTS, ON);
+    printf("* modbus_write_bit: ");
     if (rc == -1 && errno == EMBXILADD) {
         printf("OK\n");
     } else {
@@ -347,11 +335,10 @@ int main(void)
         goto close;
     }
 
-    rc = force_multiple_coils(&mb_param, SERVER_ID,
-                              UT_COIL_STATUS_ADDRESS + UT_COIL_STATUS_NB_POINTS,
-                              UT_COIL_STATUS_NB_POINTS,
-                              tab_rp_status);
-    printf("* force_multiple_coils: ");
+    rc = modbus_write_bits(ctx, UT_BITS_ADDRESS + UT_BITS_NB_POINTS,
+                           UT_BITS_NB_POINTS,
+                           tab_rp_bits);
+    printf("* modbus_write_coils: ");
     if (rc == -1 && errno == EMBXILADD) {
         printf("OK\n");
     } else {
@@ -359,11 +346,11 @@ int main(void)
         goto close;
     }
 
-    rc = preset_multiple_registers(&mb_param, SERVER_ID,
-                                   UT_HOLDING_REGISTERS_ADDRESS + UT_HOLDING_REGISTERS_NB_POINTS,
-                                   UT_HOLDING_REGISTERS_NB_POINTS,
-                                   tab_rp_registers);
-    printf("* preset_multiple_registers: ");
+    rc = modbus_write_registers(ctx, UT_REGISTERS_ADDRESS +
+                                UT_REGISTERS_NB_POINTS,
+                                UT_REGISTERS_NB_POINTS,
+                                tab_rp_registers);
+    printf("* modbus_write_registers: ");
     if (rc == -1 && errno == EMBXILADD) {
         printf("OK\n");
     } else {
@@ -375,11 +362,9 @@ int main(void)
     /** TOO MANY DATA **/
     printf("\nTEST TOO MANY DATA ERROR:\n");
 
-    rc = read_coil_status(&mb_param, SERVER_ID,
-                          UT_COIL_STATUS_ADDRESS,
-                          MAX_STATUS + 1,
-                          tab_rp_status);
-    printf("* read_coil_status: ");
+    rc = modbus_read_bits(ctx, UT_BITS_ADDRESS, MODBUS_MAX_BITS + 1,
+                          tab_rp_bits);
+    printf("* modbus_read_bits: ");
     if (rc == -1 && errno == EMBMDATA) {
         printf("OK\n");
     } else {
@@ -387,11 +372,10 @@ int main(void)
         goto close;
     }
 
-    rc = read_input_status(&mb_param, SERVER_ID,
-                           UT_INPUT_STATUS_ADDRESS,
-                           MAX_STATUS + 1,
-                           tab_rp_status);
-    printf("* read_input_status: ");
+    rc = modbus_read_input_bits(ctx, UT_INPUT_BITS_ADDRESS,
+                                MODBUS_MAX_BITS + 1,
+                                tab_rp_bits);
+    printf("* modbus_read_input_bits: ");
     if (rc == -1 && errno == EMBMDATA) {
         printf("OK\n");
     } else {
@@ -399,11 +383,10 @@ int main(void)
         goto close;
     }
 
-    rc = read_holding_registers(&mb_param, SERVER_ID,
-                                UT_HOLDING_REGISTERS_ADDRESS,
-                                MAX_REGISTERS + 1,
-                                tab_rp_registers);
-    printf("* read_holding_registers: ");
+    rc = modbus_read_registers(ctx, UT_REGISTERS_ADDRESS,
+                               MODBUS_MAX_REGISTERS + 1,
+                               tab_rp_registers);
+    printf("* modbus_read_registers: ");
     if (rc == -1 && errno == EMBMDATA) {
         printf("OK\n");
     } else {
@@ -411,11 +394,10 @@ int main(void)
         goto close;
     }
 
-    rc = read_input_registers(&mb_param, SERVER_ID,
-                              UT_INPUT_REGISTERS_ADDRESS,
-                              MAX_REGISTERS + 1,
-                              tab_rp_registers);
-    printf("* read_input_registers: ");
+    rc = modbus_read_input_registers(ctx, UT_INPUT_REGISTERS_ADDRESS,
+                                     MODBUS_MAX_REGISTERS + 1,
+                                     tab_rp_registers);
+    printf("* modbus_read_input_registers: ");
     if (rc == -1 && errno == EMBMDATA) {
         printf("OK\n");
     } else {
@@ -423,11 +405,10 @@ int main(void)
         goto close;
     }
 
-    rc = force_multiple_coils(&mb_param, SERVER_ID,
-                              UT_COIL_STATUS_ADDRESS,
-                              MAX_STATUS + 1,
-                              tab_rp_status);
-    printf("* force_multiple_coils: ");
+    rc = modbus_write_bits(ctx, UT_BITS_ADDRESS,
+                           MODBUS_MAX_BITS + 1,
+                           tab_rp_bits);
+    printf("* modbus_write_bits: ");
     if (rc == -1 && errno == EMBMDATA) {
         printf("OK\n");
     } else {
@@ -435,11 +416,10 @@ int main(void)
         printf("FAILED\n");
     }
 
-    rc = preset_multiple_registers(&mb_param, SERVER_ID,
-                                   UT_HOLDING_REGISTERS_ADDRESS,
-                                   MAX_REGISTERS + 1,
-                                   tab_rp_registers);
-    printf("* preset_multiple_registers: ");
+    rc = modbus_write_registers(ctx, UT_REGISTERS_ADDRESS,
+                                MODBUS_MAX_REGISTERS + 1,
+                                tab_rp_registers);
+    printf("* modbus_write_registers: ");
     if (rc == -1 && errno == EMBMDATA) {
         printf("OK\n");
     } else {
@@ -449,13 +429,12 @@ int main(void)
 
     /** SLAVE REPLY **/
     printf("\nTEST SLAVE REPLY:\n");
-
-    rc = read_holding_registers(&mb_param, 18,
-                                UT_HOLDING_REGISTERS_ADDRESS,
-                                UT_HOLDING_REGISTERS_NB_POINTS,
-                                tab_rp_registers);
+    modbus_set_slave(ctx, 18);
+    rc = modbus_read_registers(ctx, UT_REGISTERS_ADDRESS,
+                               UT_REGISTERS_NB_POINTS,
+                               tab_rp_registers);
     printf("1/3 No or response from slave %d: ", 18);
-    if (mb_param.type_com == RTU) {
+    if (is_mode_rtu) {
         /* No response in RTU mode */
         if (rc == -1 && errno == ETIMEDOUT) {
             printf("OK\n");
@@ -465,7 +444,7 @@ int main(void)
         }
     } else {
         /* Response in TCP mode */
-        if (rc == UT_HOLDING_REGISTERS_NB_POINTS) {
+        if (rc == UT_REGISTERS_NB_POINTS) {
             printf("OK\n");
         } else {
             printf("FAILED\n");
@@ -473,30 +452,36 @@ int main(void)
         }
     }
 
-    rc = read_holding_registers(&mb_param, MODBUS_BROADCAST_ADDRESS,
-                                UT_HOLDING_REGISTERS_ADDRESS,
-                                UT_HOLDING_REGISTERS_NB_POINTS,
-                                tab_rp_registers);
+    modbus_set_slave(ctx, MODBUS_BROADCAST_ADDRESS);
+    rc = modbus_read_registers(ctx, UT_REGISTERS_ADDRESS,
+                               UT_REGISTERS_NB_POINTS,
+                               tab_rp_registers);
     printf("2/3 Reply after a broadcast query: ");
-    if (rc == UT_HOLDING_REGISTERS_NB_POINTS) {
+    if (rc == UT_REGISTERS_NB_POINTS) {
         printf("OK\n");
     } else {
         printf("FAILED\n");
         goto close;
     }
 
+    /* Restore slave */
+    if (is_mode_rtu) {
+        modbus_set_slave(ctx, SERVER_ID);
+    } else {
+        modbus_set_slave(ctx, MODBUS_TCP_SLAVE);
+    }
+
     /* Save original timeout */
-    modbus_get_timeout_begin(&mb_param, &timeout_begin_old);
+    modbus_get_timeout_begin(ctx, &timeout_begin_old);
 
     /* Define a new and too short timeout */
     timeout_begin_new.tv_sec = 0;
     timeout_begin_new.tv_usec = 0;
-    modbus_set_timeout_begin(&mb_param, &timeout_begin_new);
+    modbus_set_timeout_begin(ctx, &timeout_begin_new);
 
-    rc = read_holding_registers(&mb_param, SERVER_ID,
-                                UT_HOLDING_REGISTERS_ADDRESS,
-                                UT_HOLDING_REGISTERS_NB_POINTS,
-                                tab_rp_registers);
+    rc = modbus_read_registers(ctx, UT_REGISTERS_ADDRESS,
+                               UT_REGISTERS_NB_POINTS,
+                               tab_rp_registers);
     printf("3/3 Too short timeout: ");
     if (rc == -1 && errno == ETIMEDOUT) {
         printf("OK\n");
@@ -506,19 +491,18 @@ int main(void)
     }
 
     /* Restore original timeout */
-    modbus_set_timeout_begin(&mb_param, &timeout_begin_old);
+    modbus_set_timeout_begin(ctx, &timeout_begin_old);
 
     /** BAD RESPONSE **/
     printf("\nTEST BAD RESPONSE ERROR:\n");
 
     /* Allocate only the required space */
     tab_rp_registers_bad = (uint16_t *) malloc(
-        UT_HOLDING_REGISTERS_NB_POINTS_SPECIAL * sizeof(uint16_t));
-    rc = read_holding_registers(&mb_param, SERVER_ID,
-                                UT_HOLDING_REGISTERS_ADDRESS,
-                                UT_HOLDING_REGISTERS_NB_POINTS_SPECIAL,
-                                tab_rp_registers_bad);
-    printf("* read_holding_registers: ");
+        UT_REGISTERS_NB_POINTS_SPECIAL * sizeof(uint16_t));
+    rc = modbus_read_registers(ctx, UT_REGISTERS_ADDRESS,
+                               UT_REGISTERS_NB_POINTS_SPECIAL,
+                               tab_rp_registers_bad);
+    printf("* modbus_read_registers: ");
     if (rc == -1 && errno == EMBBADDATA) {
         printf("OK\n");
     } else {
@@ -531,11 +515,12 @@ int main(void)
 
 close:
     /* Free the memory */
-    free(tab_rp_status);
+    free(tab_rp_bits);
     free(tab_rp_registers);
 
     /* Close the connection */
-    modbus_close(&mb_param);
+    modbus_close(ctx);
+    modbus_free(ctx);
 
     return 0;
 }

tests/unit-test-slave.c

@@ -24,26 +24,29 @@
 
 #include "unit-test.h"
 
+/* Copied from modbus-private.h */
+#define HEADER_LENGTH_TCP 7
+
 int main(void)
 {
     int socket;
-    modbus_param_t mb_param;
-    modbus_mapping_t mb_mapping;
+    modbus_t *ctx;
+    modbus_mapping_t *mb_mapping;
     int rc;
     int i;
 
-    modbus_init_tcp(&mb_param, "127.0.0.1", 1502);
-    modbus_set_debug(&mb_param, TRUE);
-    modbus_set_error_recovery(&mb_param, TRUE);
+    ctx = modbus_new_tcp("127.0.0.1", 1502);
+    modbus_set_debug(ctx, TRUE);
+    modbus_set_error_recovery(ctx, TRUE);
 
-    rc = modbus_mapping_new(&mb_mapping,
-                            UT_COIL_STATUS_ADDRESS + UT_COIL_STATUS_NB_POINTS,
-                            UT_INPUT_STATUS_ADDRESS + UT_INPUT_STATUS_NB_POINTS,
-                            UT_HOLDING_REGISTERS_ADDRESS + UT_HOLDING_REGISTERS_NB_POINTS,
-                            UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB_POINTS);
-    if (rc == -1) {
+    mb_mapping = modbus_mapping_new(UT_BITS_ADDRESS + UT_BITS_NB_POINTS,
+                                    UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB_POINTS,
+                                    UT_REGISTERS_ADDRESS + UT_REGISTERS_NB_POINTS,
+                                    UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB_POINTS);
+    if (mb_mapping == NULL) {
         fprintf(stderr, "Failed to allocate the mapping: %s\n",
                 modbus_strerror(errno));
+        modbus_free(ctx);
         return -1;
     }
 
@@ -51,33 +54,33 @@ int main(void)
        Only the read-only input values are assigned. */
 
     /** INPUT STATUS **/
-    set_bits_from_bytes(mb_mapping.tab_input_status,
-                        UT_INPUT_STATUS_ADDRESS, UT_INPUT_STATUS_NB_POINTS,
-                        UT_INPUT_STATUS_TAB);
+    modbus_set_bits_from_bytes(mb_mapping->tab_input_bits,
+                               UT_INPUT_BITS_ADDRESS, UT_INPUT_BITS_NB_POINTS,
+                               UT_INPUT_BITS_TAB);
 
     /** INPUT REGISTERS **/
     for (i=0; i < UT_INPUT_REGISTERS_NB_POINTS; i++) {
-        mb_mapping.tab_input_registers[UT_INPUT_REGISTERS_ADDRESS+i] =
+        mb_mapping->tab_input_registers[UT_INPUT_REGISTERS_ADDRESS+i] =
             UT_INPUT_REGISTERS_TAB[i];;
     }
 
-    socket = modbus_slave_listen_tcp(&mb_param, 1);
-    modbus_slave_accept_tcp(&mb_param, &socket);
+    socket = modbus_listen(ctx, 1);
+    modbus_accept(ctx, &socket);
 
     for (;;) {
-        uint8_t query[MAX_MESSAGE_LENGTH];
+        uint8_t query[MODBUS_MAX_ADU_LENGTH_TCP];
 
-        rc = modbus_slave_receive(&mb_param, -1, query);
+        rc = modbus_receive(ctx, -1, query);
         if (rc > 0) {
             if (((query[HEADER_LENGTH_TCP + 3] << 8) + query[HEADER_LENGTH_TCP + 4])
-                == UT_HOLDING_REGISTERS_NB_POINTS_SPECIAL) {
+                == UT_REGISTERS_NB_POINTS_SPECIAL) {
                 /* Change the number of values (offset
                    TCP = 6) */
                 query[HEADER_LENGTH_TCP + 3] = 0;
-                query[HEADER_LENGTH_TCP + 4] = UT_HOLDING_REGISTERS_NB_POINTS;
+                query[HEADER_LENGTH_TCP + 4] = UT_REGISTERS_NB_POINTS;
             }
 
-            rc = modbus_slave_manage(&mb_param, query, rc, &mb_mapping);
+            rc = modbus_reply(ctx, query, rc, mb_mapping);
             if (rc == -1) {
                 return -1;
             }
@@ -90,8 +93,8 @@ int main(void)
     printf("Quit the loop: %s\n", modbus_strerror(errno));
 
     close(socket);
-    modbus_mapping_free(&mb_mapping);
-    modbus_close(&mb_param);
+    modbus_mapping_free(mb_mapping);
+    modbus_free(ctx);
 
     return 0;
 }

tests/unit-test.h

@@ -28,21 +28,21 @@
 #define CLIENT_ID 15
 #define SERVER_ID 17
 
-const uint16_t UT_COIL_STATUS_ADDRESS = 0x13;
-const uint16_t UT_COIL_STATUS_NB_POINTS = 0x25;
-const uint8_t UT_COIL_STATUS_TAB[] = { 0xCD, 0x6B, 0xB2, 0x0E, 0x1B };
+const uint16_t UT_BITS_ADDRESS = 0x13;
+const uint16_t UT_BITS_NB_POINTS = 0x25;
+const uint8_t UT_BITS_TAB[] = { 0xCD, 0x6B, 0xB2, 0x0E, 0x1B };
 
-const uint16_t UT_INPUT_STATUS_ADDRESS = 0xC4;
-const uint16_t UT_INPUT_STATUS_NB_POINTS = 0x16;
-const uint8_t UT_INPUT_STATUS_TAB[] = { 0xAC, 0xDB, 0x35 };
+const uint16_t UT_INPUT_BITS_ADDRESS = 0xC4;
+const uint16_t UT_INPUT_BITS_NB_POINTS = 0x16;
+const uint8_t UT_INPUT_BITS_TAB[] = { 0xAC, 0xDB, 0x35 };
 
-const uint16_t UT_HOLDING_REGISTERS_ADDRESS = 0x6B;
-const uint16_t UT_HOLDING_REGISTERS_NB_POINTS = 0x3;
-const uint16_t UT_HOLDING_REGISTERS_TAB[] = { 0x022B, 0x0000, 0x0064 };
+const uint16_t UT_REGISTERS_ADDRESS = 0x6B;
+const uint16_t UT_REGISTERS_NB_POINTS = 0x3;
+const uint16_t UT_REGISTERS_TAB[] = { 0x022B, 0x0000, 0x0064 };
 /* If the following value is used, a bad response is sent.
    It's better to test with a lower value than
-   UT_HOLDING_REGISTERS_NB_POINTS to try to raise a segfault. */
-const uint16_t UT_HOLDING_REGISTERS_NB_POINTS_SPECIAL = 0x2;
+   UT_REGISTERS_NB_POINTS to try to raise a segfault. */
+const uint16_t UT_REGISTERS_NB_POINTS_SPECIAL = 0x2;
 
 const uint16_t UT_INPUT_REGISTERS_ADDRESS = 0x08;
 const uint16_t UT_INPUT_REGISTERS_NB_POINTS = 0x1;

tests/version.c

@@ -25,7 +25,12 @@ int main(void)
            libmodbus_version_major, libmodbus_version_minor, libmodbus_version_micro);
 
     if (LIBMODBUS_VERSION_CHECK(2, 1, 0)) {
-        printf("The functions to read/write float values are available.\n");
+        printf("The functions to read/write float values are available (2.1.0).\n");
     }
+
+    if (LIBMODBUS_VERSION_CHECK(2, 1, 1)) {
+        printf("Oh gosh, brand new API (2.1.1)!\n");
+    }
+
     return 0;
 }