Restore slave ID (server ID) argument in functions

The ID used at init time will be the device ID of the caller and
the server ID in request functions is the target to reach.

MIGRATION

@@ -2,12 +2,8 @@
 Migration notes from the 2.0 series (for 2.2)
 =============================================
 
-1 - modbus_init_rtu/tcp takes a new argument: the slave and it is only required
-    in that function (eg. read_coil_status doesn't receive the slave ID in
-    argument anymore). If you need to use different slaves with the same
-    connection (eg. RS485), you can copy modbus_param_t, use modbus_set_slave()
-    function or directly set modbus_param_t.slave to a different value when
-    required.
+1 - modbus_init_rtu/tcp takes a new argument, the slave number of the device
+    which established the connection.
 
 2 - modbus_init_listen_tcp() has been renamed to modbus_slave_listen_tcp() and
     requires a new argument, the maximal number of connections:
@@ -65,23 +61,3 @@ The holding and input registers are now stored in an array of type
 uint16_t.
 
 These changes reduce the memory consumption.
-
-
-New functions
-=============
-
-report_slave_id
-
-modbus_set_error_handling
-modbus_mapping_new
-modbus_mapping_free
-modbus_init_listen_tcp
-modbus_listen
-modbus_manage_query
-
-get_slave_query_tcp
-set_bits_from_byte
-set_bits_from_bytes
-get_byte_from_bits
-
-Read modbus.h for more informations.

configure.ac

@@ -19,7 +19,8 @@ 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])
+m4_define([libmodbus_version],
+        [libmodbus_version_major.libmodbus_version_minor.libmodbus_version_micro])
 
 AC_PREREQ(2.63)
 AC_INIT([libmodbus],[libmodbus_version],[stephane.raimbault@gmail.com])
@@ -39,7 +40,7 @@ AC_SUBST(LIBMODBUS_VERSION_MICRO)
 AC_SUBST(LIBMODBUS_VERSION)
 
 # ABI version
-LIBMODBUS_LD_CURRENT=3
+LIBMODBUS_LD_CURRENT=4
 LIBMODBUS_LD_REVISION=0
 LIBMODBUS_LD_AGE=0
 LIBMODBUS_LT_LDFLAGS="-version-info $LIBMODBUS_LD_CURRENT:$LIBMODBUS_LD_REVISION:$LIBMODBUS_LD_AGE"

src/modbus.c

@@ -324,15 +324,15 @@ static int build_query_basis_tcp(int slave, int function,
         return PRESET_QUERY_LENGTH_TCP;
 }
 
-static int build_query_basis(modbus_param_t *mb_param,
+static int build_query_basis(modbus_param_t *mb_param, int slave,
                              int function, int start_addr,
                              int nb, uint8_t *query)
 {
         if (mb_param->type_com == RTU)
-                return build_query_basis_rtu(mb_param->slave, function,
+                return build_query_basis_rtu(slave, function,
                                              start_addr, nb, query);
         else
-                return build_query_basis_tcp(mb_param->slave, function,
+                return build_query_basis_tcp(slave, function,
                                              start_addr, nb, query);
 }
 
@@ -1114,7 +1114,7 @@ int modbus_slave_manage(modbus_param_t *mb_param, const uint8_t *query,
 }
 
 /* Reads IO status */
-static int read_io_status(modbus_param_t *mb_param, int function,
+static int read_io_status(modbus_param_t *mb_param, int slave, int function,
                           int start_addr, int nb, uint8_t *data_dest)
 {
         int rc;
@@ -1123,7 +1123,7 @@ static int read_io_status(modbus_param_t *mb_param, int function,
         uint8_t query[MIN_QUERY_LENGTH];
         uint8_t response[MAX_MESSAGE_LENGTH];
 
-        query_length = build_query_basis(mb_param, function,
+        query_length = build_query_basis(mb_param, slave, function,
                                          start_addr, nb, query);
 
         rc = modbus_send(mb_param, query, query_length);
@@ -1156,7 +1156,7 @@ static int read_io_status(modbus_param_t *mb_param, int function,
 
 /* Reads the boolean status of coils and sets the array elements
    in the destination to TRUE or FALSE. */
-int read_coil_status(modbus_param_t *mb_param, int start_addr,
+int read_coil_status(modbus_param_t *mb_param, int slave, int start_addr,
                      int nb, uint8_t *data_dest)
 {
         int rc;
@@ -1171,8 +1171,8 @@ int read_coil_status(modbus_param_t *mb_param, int start_addr,
                 return -1;
         }
 
-        rc = read_io_status(mb_param, FC_READ_COIL_STATUS, start_addr, nb,
-                            data_dest);
+        rc = read_io_status(mb_param, slave, FC_READ_COIL_STATUS, start_addr,
+                            nb, data_dest);
 
         if (rc == -1)
                 return -1;
@@ -1182,7 +1182,7 @@ int read_coil_status(modbus_param_t *mb_param, int start_addr,
 
 
 /* Same as read_coil_status but reads the slaves input table */
-int read_input_status(modbus_param_t *mb_param, int start_addr,
+int read_input_status(modbus_param_t *mb_param, int slave, int start_addr,
                       int nb, uint8_t *data_dest)
 {
         int rc;
@@ -1197,7 +1197,7 @@ int read_input_status(modbus_param_t *mb_param, int start_addr,
                 return -1;
         }
 
-        rc = read_io_status(mb_param, FC_READ_INPUT_STATUS, start_addr,
+        rc = read_io_status(mb_param, slave, FC_READ_INPUT_STATUS, start_addr,
                             nb, data_dest);
 
         if (rc == -1)
@@ -1207,7 +1207,7 @@ int read_input_status(modbus_param_t *mb_param, int start_addr,
 }
 
 /* Reads the data from a modbus slave and put that data into an array */
-static int read_registers(modbus_param_t *mb_param, int function,
+static int read_registers(modbus_param_t *mb_param, int slave, int function,
                           int start_addr, int nb, uint16_t *data_dest)
 {
         int rc;
@@ -1225,7 +1225,7 @@ static int read_registers(modbus_param_t *mb_param, int function,
                 return -1;
         }
 
-        query_length = build_query_basis(mb_param, function,
+        query_length = build_query_basis(mb_param, slave, function,
                                          start_addr, nb, query);
 
         rc = modbus_send(mb_param, query, query_length);
@@ -1250,7 +1250,7 @@ static int read_registers(modbus_param_t *mb_param, int function,
 
 /* Reads the holding registers in a slave and put the data into an
    array */
-int read_holding_registers(modbus_param_t *mb_param,
+int read_holding_registers(modbus_param_t *mb_param, int slave,
                            int start_addr, int nb, uint16_t *data_dest)
 {
         int status;
@@ -1265,15 +1265,15 @@ int read_holding_registers(modbus_param_t *mb_param,
                 return -1;
         }
 
-        status = read_registers(mb_param, FC_READ_HOLDING_REGISTERS,
+        status = read_registers(mb_param, slave, FC_READ_HOLDING_REGISTERS,
                                 start_addr, nb, data_dest);
         return status;
 }
 
 /* Reads the input registers in a slave and put the data into
    an array */
-int read_input_registers(modbus_param_t *mb_param, int start_addr, int nb,
-                         uint16_t *data_dest)
+int read_input_registers(modbus_param_t *mb_param, int slave, int start_addr,
+                         int nb, uint16_t *data_dest)
 {
         int status;
 
@@ -1285,7 +1285,7 @@ int read_input_registers(modbus_param_t *mb_param, int start_addr, int nb,
                 return -1;
         }
 
-        status = read_registers(mb_param, FC_READ_INPUT_REGISTERS,
+        status = read_registers(mb_param, slave, FC_READ_INPUT_REGISTERS,
                                 start_addr, nb, data_dest);
 
         return status;
@@ -1293,14 +1293,14 @@ int read_input_registers(modbus_param_t *mb_param, int start_addr, int nb,
 
 /* Sends a value to a register in a slave.
    Used by force_single_coil and preset_single_register */
-static int set_single(modbus_param_t *mb_param, int function,
+static int set_single(modbus_param_t *mb_param, int slave, int function,
                       int addr, int value)
 {
         int rc;
         int query_length;
         uint8_t query[MIN_QUERY_LENGTH];
 
-        query_length = build_query_basis(mb_param, function,
+        query_length = build_query_basis(mb_param, slave, function,
                                          addr, value, query);
 
         rc = modbus_send(mb_param, query, query_length);
@@ -1315,33 +1315,34 @@ static int set_single(modbus_param_t *mb_param, int function,
 }
 
 /* Turns ON or OFF a single coil in the slave device */
-int force_single_coil(modbus_param_t *mb_param, int coil_addr, int state)
+int force_single_coil(modbus_param_t *mb_param, int slave, int coil_addr, int state)
 {
         int status;
 
         if (state)
                 state = 0xFF00;
 
-        status = set_single(mb_param, FC_FORCE_SINGLE_COIL,
+        status = set_single(mb_param, slave, FC_FORCE_SINGLE_COIL,
                             coil_addr, state);
 
         return status;
 }
 
 /* Sets a value in one holding register in the slave device */
-int preset_single_register(modbus_param_t *mb_param, int reg_addr, int value)
+int preset_single_register(modbus_param_t *mb_param, int slave, int reg_addr,
+                           int value)
 {
         int status;
 
-        status = set_single(mb_param, FC_PRESET_SINGLE_REGISTER,
+        status = set_single(mb_param, slave, FC_PRESET_SINGLE_REGISTER,
                             reg_addr, value);
 
         return status;
 }
 
 /* Sets/resets the coils in the slave from an array in argument */
-int force_multiple_coils(modbus_param_t *mb_param, int start_addr, int nb,
-                         const uint8_t *data_src)
+int force_multiple_coils(modbus_param_t *mb_param, int slave, int start_addr,
+                         int nb, const uint8_t *data_src)
 {
         int rc;
         int i;
@@ -1361,7 +1362,7 @@ int force_multiple_coils(modbus_param_t *mb_param, int start_addr, int nb,
                 return -1;
         }
 
-        query_length = build_query_basis(mb_param, FC_FORCE_MULTIPLE_COILS,
+        query_length = build_query_basis(mb_param, slave, FC_FORCE_MULTIPLE_COILS,
                                          start_addr, nb, query);
         byte_count = (nb / 8) + ((nb % 8) ? 1 : 0);
         query[query_length++] = byte_count;
@@ -1394,8 +1395,8 @@ int force_multiple_coils(modbus_param_t *mb_param, int start_addr, int nb,
 }
 
 /* Copies the values in the slave from the array given in argument */
-int preset_multiple_registers(modbus_param_t *mb_param, int start_addr, int nb,
-                              const uint16_t *data_src)
+int preset_multiple_registers(modbus_param_t *mb_param, int slave, int start_addr,
+                              int nb, const uint16_t *data_src)
 {
         int rc;
         int i;
@@ -1414,7 +1415,7 @@ int preset_multiple_registers(modbus_param_t *mb_param, int start_addr, int nb,
                 return -1;
         }
 
-        query_length = build_query_basis(mb_param, FC_PRESET_MULTIPLE_REGISTERS,
+        query_length = build_query_basis(mb_param, slave, FC_PRESET_MULTIPLE_REGISTERS,
                                          start_addr, nb, query);
         byte_count = nb * 2;
         query[query_length++] = byte_count;
@@ -1433,14 +1434,15 @@ int preset_multiple_registers(modbus_param_t *mb_param, int start_addr, int nb,
         return rc;
 }
 
-/* Returns the slave id! */
-int report_slave_id(modbus_param_t *mb_param, uint8_t *data_dest)
+/* Request the slave ID */
+int report_slave_id(modbus_param_t *mb_param, int slave, uint8_t *data_dest)
 {
         int rc;
         int query_length;
         uint8_t query[MIN_QUERY_LENGTH];
 
-        query_length = build_query_basis(mb_param, FC_REPORT_SLAVE_ID, 0, 0, query);
+        query_length = build_query_basis(mb_param, slave,
+                                         FC_REPORT_SLAVE_ID, 0, 0, query);
 
         /* HACKISH, start_addr and count are not used */
         query_length -= 4;
@@ -1474,6 +1476,7 @@ int report_slave_id(modbus_param_t *mb_param, uint8_t *data_dest)
    - parity: "even", "odd" or "none"
    - data_bits: 5, 6, 7, 8
    - stop_bits: 1, 2
+   - slave: slave number
 */
 void modbus_init_rtu(modbus_param_t *mb_param, const char *device,
                      int baud, const char *parity, int data_bit,
@@ -1510,8 +1513,7 @@ void modbus_init_tcp(modbus_param_t *mb_param, const char *ip, int port, int sla
         mb_param->slave = slave;
 }
 
-/* Define the slave number.
-   The special value MODBUS_BROADCAST_ADDRESS can be used. */
+/* Define the slave number */
 void modbus_set_slave(modbus_param_t *mb_param, int slave)
 {
         mb_param->slave = slave;
@@ -1519,7 +1521,7 @@ void modbus_set_slave(modbus_param_t *mb_param, int slave)
 
 /*
    When disabled (default), it is expected that the application will check for error
-   returns and deal with them as necessary. 
+   returns and deal with them as necessary.
 
    It's not recommanded to enable error recovery for slave/server.
 

src/modbus.h.in

@@ -263,22 +263,23 @@ void modbus_set_debug(modbus_param_t *mb_param, int boolean);
 
 const char *modbus_strerror(int errnum);
 
-int read_coil_status(modbus_param_t *mb_param, int start_addr, int nb,
-                     uint8_t *dest);
-int read_input_status(modbus_param_t *mb_param, int start_addr, int nb,
-                      uint8_t *dest);
-int read_holding_registers(modbus_param_t *mb_param, int start_addr, int nb,
-                           uint16_t *dest);
-int read_input_registers(modbus_param_t *mb_param, int start_addr, int nb,
-                         uint16_t *dest);
-int force_single_coil(modbus_param_t *mb_param, int coil_addr, int state);
-
-int preset_single_register(modbus_param_t *mb_param, int reg_addr, int value);
-int force_multiple_coils(modbus_param_t *mb_param, int start_addr, int nb,
-                         const uint8_t *data);
-int preset_multiple_registers(modbus_param_t *mb_param, int start_addr, int nb,
-                              const uint16_t *data);
-int report_slave_id(modbus_param_t *mb_param, uint8_t *dest);
+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,

tests/bandwidth-master.c

@@ -26,7 +26,8 @@
 #include <modbus.h>
 
 /* Tests based on PI-MBUS-300 documentation */
-#define SLAVE     0x11
+#define MY_ID          1
+#define SERVER_ID     17
 #define NB_LOOPS  100000
 
 #define G_MSEC_PER_SEC 1000
@@ -54,7 +55,7 @@ int main(void)
         int rc;
 
         /* TCP */
-        modbus_init_tcp(&mb_param, "127.0.0.1", 1502, SLAVE);
+        modbus_init_tcp(&mb_param, "127.0.0.1", 1502, MY_ID);
         rc = modbus_connect(&mb_param);
         if (rc == -1) {
                 fprintf(stderr, "Connexion failed: %s\n",
@@ -75,9 +76,9 @@ int main(void)
         nb_points = MAX_STATUS;
         start = gettime_ms();
         for (i=0; i<NB_LOOPS; i++) {
-                rc = read_coil_status(&mb_param, 0, nb_points, tab_rp_status);
+                rc = read_coil_status(&mb_param, SERVER_ID, 0, nb_points, tab_rp_status);
                 if (rc == -1) {
-                        fprintf(stderr, modbus_strerror(errno));
+                        fprintf(stderr, "%s\n", modbus_strerror(errno));
                         return -1;
                 }
         }
@@ -112,9 +113,9 @@ int main(void)
         nb_points = MAX_REGISTERS;
         start = gettime_ms();
         for (i=0; i<NB_LOOPS; i++) {
-                rc = read_holding_registers(&mb_param, 0, nb_points, tab_rp_registers);
+                rc = read_holding_registers(&mb_param, SERVER_ID, 0, nb_points, tab_rp_registers);
                 if (rc == -1) {
-                        fprintf(stderr, modbus_strerror(errno));
+                        fprintf(stderr, "%s\n", modbus_strerror(errno));
                         return -1;
                 }
         }

tests/bandwidth-slave-many-up.c

@@ -24,7 +24,6 @@
 
 #include <modbus.h>
 
-#define SLAVE         0x11
 #define NB_CONNECTION    5
 
 int slave_socket;
@@ -49,9 +48,9 @@ int main(void)
         /* Maximum file descriptor number */
         int fdmax;
 
-        modbus_init_tcp(&mb_param, "127.0.0.1", 1502, SLAVE);
+        modbus_init_tcp(&mb_param, "127.0.0.1", 1502, 17);
 
-        rc = modbus_mapping_new(&mb_mapping,  MAX_STATUS, 0, MAX_REGISTERS, 0);
+        rc = modbus_mapping_new(&mb_mapping, MAX_STATUS, 0, MAX_REGISTERS, 0);
         if (rc == -1) {
                 fprintf(stderr, "Failed to allocate the mapping: %s\n",
                         modbus_strerror(errno));

tests/bandwidth-slave-one.c

@@ -23,8 +23,6 @@
 
 #include <modbus.h>
 
-#define SLAVE 0x11
-
 int main(void)
 {
         int socket;
@@ -32,7 +30,7 @@ int main(void)
         modbus_mapping_t mb_mapping;
         int rc;
 
-        modbus_init_tcp(&mb_param, "127.0.0.1", 1502, SLAVE);
+        modbus_init_tcp(&mb_param, "127.0.0.1", 1502, 17);
 
         rc = modbus_mapping_new(&mb_mapping,  MAX_STATUS, 0, MAX_REGISTERS, 0);
         if (rc == -1) {

tests/random-test-master.c

@@ -37,9 +37,10 @@
    range defined by the following defines.
 */
 #define LOOP             1
-#define SLAVE         0x11
+#define MY_ID            1
+#define SERVER_ID       17
 #define ADDRESS_START    0
-#define ADDRESS_END      99
+#define ADDRESS_END     99
 
 /* At each loop, the program works in the range ADDRESS_START to
  * ADDRESS_END then ADDRESS_START + 1 to ADDRESS_END and so on.
@@ -58,10 +59,12 @@ int main(void)
         modbus_param_t mb_param;
 
         /* RTU parity : none, even, odd */
-        /* modbus_init_rtu(&mb_param, "/dev/ttyS0", 19200, "none", 8, 1); */
+        /*
+          modbus_init_rtu(&mb_param, "/dev/ttyS0", 19200, "none", 8, 1, MY_ID);
+        */
 
         /* TCP */
-        modbus_init_tcp(&mb_param, "127.0.0.1", 1502, SLAVE);
+        modbus_init_tcp(&mb_param, "127.0.0.1", 1502, MY_ID);
         modbus_set_debug(&mb_param, TRUE);
         if (modbus_connect(&mb_param) == -1) {
                 fprintf(stderr, "Connection failed: %s\n",
@@ -97,42 +100,42 @@ int main(void)
                         nb = ADDRESS_END - addr;
 
                         /* SINGLE COIL */
-                        rc = force_single_coil(&mb_param, addr, tab_rq_status[0]);
+                        rc = force_single_coil(&mb_param, SERVER_ID, addr, tab_rq_status[0]);
                         if (rc != 1) {
                                 printf("ERROR force_single_coil (%d)\n", rc);
                                 printf("Slave = %d, address = %d, value = %d\n",
-                                       SLAVE, addr, tab_rq_status[0]);
+                                       SERVER_ID, addr, tab_rq_status[0]);
                                 nb_fail++;
                         } else {
-                                rc = read_coil_status(&mb_param, addr, 1, tab_rp_status);
+                                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",
-                                               SLAVE, addr);
+                                               SERVER_ID, addr);
                                         nb_fail++;
                                 }
                         }
 
                         /* MULTIPLE COILS */
-                        rc = force_multiple_coils(&mb_param, addr, nb, tab_rq_status);
+                        rc = force_multiple_coils(&mb_param, SERVER_ID, addr, nb, tab_rq_status);
                         if (rc != nb) {
                                 printf("ERROR force_multiple_coils (%d)\n", rc);
                                 printf("Slave = %d, address = %d, nb = %d\n",
-                                       SLAVE, addr, nb);
+                                       SERVER_ID, addr, nb);
                                 nb_fail++;
                         } else {
-                                rc = read_coil_status(&mb_param, addr, nb, tab_rp_status);
+                                rc = read_coil_status(&mb_param, SERVER_ID, addr, nb, tab_rp_status);
                                 if (rc != nb) {
                                         printf("ERROR read_coil_status\n");
                                         printf("Slave = %d, address = %d, nb = %d\n",
-                                               SLAVE, addr, nb);
+                                               SERVER_ID, 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",
-                                                               SLAVE, addr,
+                                                               SERVER_ID, addr,
                                                                tab_rq_status[i], tab_rq_status[i],
                                                                tab_rp_status[i], tab_rp_status[i]);
                                                         nb_fail++;
@@ -142,24 +145,24 @@ int main(void)
                         }
 
                         /* SINGLE REGISTER */
-                        rc = preset_single_register(&mb_param, addr, tab_rq_registers[0]);
+                        rc = preset_single_register(&mb_param, SERVER_ID, 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",
-                                       SLAVE, addr, tab_rq_registers[0], tab_rq_registers[0]);
+                                       SERVER_ID, addr, tab_rq_registers[0], tab_rq_registers[0]);
                                 nb_fail++;
                         } else {
-                                rc = read_holding_registers(&mb_param, addr, 1, tab_rp_registers);
+                                rc = read_holding_registers(&mb_param, SERVER_ID, addr, 1, tab_rp_registers);
                                 if (rc != 1) {
                                         printf("ERROR read_holding_registers single (%d)\n", rc);
                                         printf("Slave = %d, address = %d\n",
-                                               SLAVE, addr);
+                                               SERVER_ID, 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",
-                                                       SLAVE, addr,
+                                                       SERVER_ID, addr,
                                                        tab_rq_registers[0], tab_rq_registers[0],
                                                        tab_rp_registers[0], tab_rp_registers[0]);
                                                 nb_fail++;
@@ -168,27 +171,27 @@ int main(void)
                         }
 
                         /* MULTIPLE REGISTERS */
-                        rc = preset_multiple_registers(&mb_param, addr, nb,
+                        rc = preset_multiple_registers(&mb_param, SERVER_ID, addr, nb,
                                                         tab_rq_registers);
                         if (rc != nb) {
                                 printf("ERROR preset_multiple_registers (%d)\n", rc);
                                 printf("Slave = %d, address = %d, nb = %d\n",
-                                               SLAVE, addr, nb);
+                                               SERVER_ID, addr, nb);
                                 nb_fail++;
                         } else {
-                                rc = read_holding_registers(&mb_param, addr, nb,
+                                rc = read_holding_registers(&mb_param, SERVER_ID, addr, nb,
                                                              tab_rp_registers);
                                 if (rc != nb) {
                                         printf("ERROR read_holding_registers (%d)\n", rc);
                                         printf("Slave = %d, address = %d, nb = %d\n",
-                                               SLAVE, addr, nb);
+                                               SERVER_ID, 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",
-                                                               SLAVE, addr,
+                                                               SERVER_ID, addr,
                                                                tab_rq_registers[i], tab_rq_registers[i],
                                                                tab_rp_registers[i], tab_rp_registers[i]);
                                                         nb_fail++;

tests/random-test-slave.c

@@ -22,8 +22,6 @@
 
 #include <modbus.h>
 
-#define SLAVE 0x11
-
 int main(void)
 {
         int socket;
@@ -31,7 +29,7 @@ int main(void)
         modbus_mapping_t mb_mapping;
         int rc;
 
-        modbus_init_tcp(&mb_param, "127.0.0.1", 1502, SLAVE);
+        modbus_init_tcp(&mb_param, "127.0.0.1", 1502, 17);
         /* modbus_set_debug(&mb_param, TRUE); */
 
         rc = modbus_mapping_new(&mb_mapping, 500, 500, 500, 500);

tests/unit-test-master.c

@@ -20,12 +20,9 @@
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
-
 #include <modbus.h>
-#include "unit-test.h"
 
-/* Tests based on PI-MBUS-300 documentation */
-#define SLAVE    0x11
+#include "unit-test.h"
 
 int main(void)
 {
@@ -41,10 +38,13 @@ int main(void)
         float real;
 
         /* RTU parity : none, even, odd */
-/*      modbus_init_rtu(&mb_param, "/dev/ttyS0", 19200, "none", 8, 1, SLAVE); */
+        /*
+        modbus_init_rtu(&mb_param, "/dev/ttyS0", 19200, "none", 8, 1,
+                        CLIENT_ID);
+        */
 
         /* TCP */
-        modbus_init_tcp(&mb_param, "127.0.0.1", 1502, SLAVE);
+        modbus_init_tcp(&mb_param, "127.0.0.1", 1502, CLIENT_ID);
         modbus_set_debug(&mb_param, TRUE);
 
         if (modbus_connect(&mb_param) == -1) {
@@ -73,7 +73,7 @@ int main(void)
         /** COIL STATUS **/
 
         /* Single */
-        rc = force_single_coil(&mb_param, UT_COIL_STATUS_ADDRESS, ON);
+        rc = force_single_coil(&mb_param, SERVER_ID, UT_COIL_STATUS_ADDRESS, ON);
         printf("1/2 force_single_coil: ");
         if (rc == 1) {
                 printf("OK\n");
@@ -82,7 +82,7 @@ int main(void)
                 goto close;
         }
 
-        rc = read_coil_status(&mb_param, UT_COIL_STATUS_ADDRESS, 1,
+        rc = read_coil_status(&mb_param, SERVER_ID, UT_COIL_STATUS_ADDRESS, 1,
                               tab_rp_status);
         printf("2/2 read_coil_status: ");
         if (rc != 1) {
@@ -103,7 +103,7 @@ int main(void)
 
                 set_bits_from_bytes(tab_value, 0, UT_COIL_STATUS_NB_POINTS,
                                     UT_COIL_STATUS_TAB);
-                rc = force_multiple_coils(&mb_param,
+                rc = force_multiple_coils(&mb_param, SERVER_ID,
                                           UT_COIL_STATUS_ADDRESS,
                                           UT_COIL_STATUS_NB_POINTS,
                                           tab_value);
@@ -116,7 +116,7 @@ int main(void)
                 }
         }
 
-        rc = read_coil_status(&mb_param, UT_COIL_STATUS_ADDRESS,
+        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) {
@@ -144,7 +144,7 @@ int main(void)
         /* End of multiple coils */
 
         /** INPUT STATUS **/
-        rc = read_input_status(&mb_param, UT_INPUT_STATUS_ADDRESS,
+        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: ");
 
@@ -174,7 +174,7 @@ int main(void)
         /** HOLDING REGISTERS **/
 
         /* Single register */
-        rc = preset_single_register(&mb_param,
+        rc = preset_single_register(&mb_param, SERVER_ID,
                                     UT_HOLDING_REGISTERS_ADDRESS, 0x1234);
         printf("1/2 preset_single_register: ");
         if (rc == 1) {
@@ -184,7 +184,7 @@ int main(void)
                 goto close;
         }
 
-        rc = read_holding_registers(&mb_param,
+        rc = read_holding_registers(&mb_param, SERVER_ID,
                                     UT_HOLDING_REGISTERS_ADDRESS,
                                     1, tab_rp_registers);
         printf("2/2 read_holding_registers: ");
@@ -202,7 +202,7 @@ int main(void)
         /* End of single register */
 
         /* Many registers */
-        rc = preset_multiple_registers(&mb_param,
+        rc = preset_multiple_registers(&mb_param, SERVER_ID,
                                        UT_HOLDING_REGISTERS_ADDRESS,
                                        UT_HOLDING_REGISTERS_NB_POINTS,
                                        UT_HOLDING_REGISTERS_TAB);
@@ -214,7 +214,7 @@ int main(void)
                 goto close;
         }
 
-        rc = read_holding_registers(&mb_param,
+        rc = read_holding_registers(&mb_param, SERVER_ID,
                                     UT_HOLDING_REGISTERS_ADDRESS,
                                     UT_HOLDING_REGISTERS_NB_POINTS,
                                     tab_rp_registers);
@@ -237,7 +237,7 @@ int main(void)
 
 
         /** INPUT REGISTERS **/
-        rc = read_input_registers(&mb_param,
+        rc = read_input_registers(&mb_param, SERVER_ID,
                                   UT_INPUT_REGISTERS_ADDRESS,
                                   UT_INPUT_REGISTERS_NB_POINTS,
                                   tab_rp_registers);
@@ -287,7 +287,7 @@ 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,
+        rc = read_coil_status(&mb_param, SERVER_ID,
                               UT_COIL_STATUS_ADDRESS,
                               UT_COIL_STATUS_NB_POINTS + 1,
                               tab_rp_status);
@@ -299,7 +299,7 @@ int main(void)
                 goto close;
         }
 
-        rc = read_input_status(&mb_param,
+        rc = read_input_status(&mb_param, SERVER_ID,
                                UT_INPUT_STATUS_ADDRESS,
                                UT_INPUT_STATUS_NB_POINTS + 1,
                                tab_rp_status);
@@ -311,7 +311,7 @@ int main(void)
                 goto close;
         }
 
-        rc = read_holding_registers(&mb_param,
+        rc = read_holding_registers(&mb_param, SERVER_ID,
                                     UT_HOLDING_REGISTERS_ADDRESS,
                                     UT_HOLDING_REGISTERS_NB_POINTS + 1,
                                     tab_rp_registers);
@@ -323,7 +323,7 @@ int main(void)
                 goto close;
         }
 
-        rc = read_input_registers(&mb_param,
+        rc = read_input_registers(&mb_param, SERVER_ID,
                                   UT_INPUT_REGISTERS_ADDRESS,
                                   UT_INPUT_REGISTERS_NB_POINTS + 1,
                                   tab_rp_registers);
@@ -335,7 +335,7 @@ int main(void)
                 goto close;
         }
 
-        rc = force_single_coil(&mb_param,
+        rc = force_single_coil(&mb_param, SERVER_ID,
                                UT_COIL_STATUS_ADDRESS + UT_COIL_STATUS_NB_POINTS,
                                ON);
         printf("* force_single_coil: ");
@@ -346,7 +346,7 @@ int main(void)
                 goto close;
         }
 
-        rc = force_multiple_coils(&mb_param,
+        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);
@@ -358,7 +358,7 @@ int main(void)
                 goto close;
         }
 
-        rc = preset_multiple_registers(&mb_param,
+        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);
@@ -374,7 +374,7 @@ int main(void)
         /** TOO MANY DATA **/
         printf("\nTEST TOO MANY DATA ERROR:\n");
 
-        rc = read_coil_status(&mb_param,
+        rc = read_coil_status(&mb_param, SERVER_ID,
                               UT_COIL_STATUS_ADDRESS,
                               MAX_STATUS + 1,
                               tab_rp_status);
@@ -386,7 +386,7 @@ int main(void)
                 goto close;
         }
 
-        rc = read_input_status(&mb_param,
+        rc = read_input_status(&mb_param, SERVER_ID,
                                UT_INPUT_STATUS_ADDRESS,
                                MAX_STATUS + 1,
                                tab_rp_status);
@@ -398,7 +398,7 @@ int main(void)
                 goto close;
         }
 
-        rc = read_holding_registers(&mb_param,
+        rc = read_holding_registers(&mb_param, SERVER_ID,
                                     UT_HOLDING_REGISTERS_ADDRESS,
                                     MAX_REGISTERS + 1,
                                     tab_rp_registers);
@@ -410,7 +410,7 @@ int main(void)
                 goto close;
         }
 
-        rc = read_input_registers(&mb_param,
+        rc = read_input_registers(&mb_param, SERVER_ID,
                                   UT_INPUT_REGISTERS_ADDRESS,
                                   MAX_REGISTERS + 1,
                                   tab_rp_registers);
@@ -422,7 +422,7 @@ int main(void)
                 goto close;
         }
 
-        rc = force_multiple_coils(&mb_param,
+        rc = force_multiple_coils(&mb_param, SERVER_ID,
                                   UT_COIL_STATUS_ADDRESS,
                                   MAX_STATUS + 1,
                                   tab_rp_status);
@@ -434,7 +434,7 @@ int main(void)
                 printf("FAILED\n");
         }
 
-        rc = preset_multiple_registers(&mb_param,
+        rc = preset_multiple_registers(&mb_param, SERVER_ID,
                                        UT_HOLDING_REGISTERS_ADDRESS,
                                        MAX_REGISTERS + 1,
                                        tab_rp_registers);
@@ -448,12 +448,11 @@ int main(void)
 
         /** SLAVE REPLY **/
         printf("\nTEST SLAVE REPLY:\n");
-        modbus_set_slave(&mb_param, 18);
-        rc = read_holding_registers(&mb_param,
+        rc = read_holding_registers(&mb_param, 18,
                                     UT_HOLDING_REGISTERS_ADDRESS+1,
                                     UT_HOLDING_REGISTERS_NB_POINTS,
                                     tab_rp_registers);
-        printf("1/2 No reply from slave %d: ", mb_param.slave);
+        printf("1/2 No reply from slave %d: ", 18);
         if (rc == -1 && errno == ETIMEDOUT) {
                 printf("OK\n");
         } else {
@@ -461,8 +460,7 @@ int main(void)
                 goto close;
         }
 
-        modbus_set_slave(&mb_param, MODBUS_BROADCAST_ADDRESS);
-        rc = read_holding_registers(&mb_param,
+        rc = read_holding_registers(&mb_param, MODBUS_BROADCAST_ADDRESS,
                                     UT_HOLDING_REGISTERS_ADDRESS,
                                     UT_HOLDING_REGISTERS_NB_POINTS,
                                     tab_rp_registers);
@@ -480,7 +478,7 @@ int main(void)
         /* 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,
+        rc = read_holding_registers(&mb_param, SERVER_ID,
                                     UT_HOLDING_REGISTERS_ADDRESS,
                                     UT_HOLDING_REGISTERS_NB_POINTS_SPECIAL,
                                     tab_rp_registers_bad);

tests/unit-test-slave.c

@@ -20,8 +20,8 @@
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
-
 #include <modbus.h>
+
 #include "unit-test.h"
 
 int main(void)
@@ -32,7 +32,7 @@ int main(void)
         int rc;
         int i;
 
-        modbus_init_tcp(&mb_param, "127.0.0.1", 1502, SLAVE);
+        modbus_init_tcp(&mb_param, "127.0.0.1", 1502, SERVER_ID);
         modbus_set_debug(&mb_param, TRUE);
         modbus_set_error_recovery(&mb_param, TRUE);
 

tests/unit-test.h

@@ -25,7 +25,8 @@
 #include <stdint.h>
 #endif
 
-#define SLAVE 0x11
+#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;