Renamed modbus_read_and_write_registers to modbus_write_and_read_registers

The function name was confusing because the write operation is performed
before the read. Take care to swap the arguments in the migration process.

NEWS

@@ -6,6 +6,10 @@ libmodbus 2.9.5 (2011-06-XX)
   by Tobias Doerffel, Florian octo Forster and Hannu Vuolasaho.
 - Enable RS485 support only when available
 - Export modbus_set/get_serial_mode functions on all platforms
+- API change for read/write multiple registers function:
+    * modbus_read_and_write_registers -> modbus_write_and_read_registers
+  The function name was confusing because the write operation is performed
+  before the read. Take care to swap the arguments in the migration process.
 
 libmodbus 2.9.4 (2011-06-05)
 ============================

src/modbus-private.h

@@ -61,7 +61,7 @@ MODBUS_BEGIN_DECLS
 #define _FC_WRITE_MULTIPLE_COILS      0x0F
 #define _FC_WRITE_MULTIPLE_REGISTERS  0x10
 #define _FC_REPORT_SLAVE_ID           0x11
-#define _FC_READ_AND_WRITE_REGISTERS  0x17
+#define _FC_WRITE_AND_READ_REGISTERS  0x17
 
 typedef enum {
     _MODBUS_BACKEND_TYPE_RTU=0,

src/modbus.c

@@ -138,7 +138,7 @@ static unsigned int compute_response_length_from_request(modbus_t *ctx, uint8_t
         length = 2 + (nb / 8) + ((nb % 8) ? 1 : 0);
     }
         break;
-    case _FC_READ_AND_WRITE_REGISTERS:
+    case _FC_WRITE_AND_READ_REGISTERS:
     case _FC_READ_HOLDING_REGISTERS:
     case _FC_READ_INPUT_REGISTERS:
         /* Header + 2 * nb values */
@@ -254,7 +254,7 @@ static uint8_t compute_meta_length_after_function(int function,
         } else if (function == _FC_WRITE_MULTIPLE_COILS ||
                    function == _FC_WRITE_MULTIPLE_REGISTERS) {
             length = 5;
-        } else if (function == _FC_READ_AND_WRITE_REGISTERS) {
+        } else if (function == _FC_WRITE_AND_READ_REGISTERS) {
             length = 9;
         } else {
             /* _FC_READ_EXCEPTION_STATUS, _FC_REPORT_SLAVE_ID */
@@ -290,7 +290,7 @@ static int compute_data_length_after_meta(modbus_t *ctx, uint8_t *msg,
         case _FC_WRITE_MULTIPLE_REGISTERS:
             length = msg[ctx->backend->header_length + 5];
             break;
-        case _FC_READ_AND_WRITE_REGISTERS:
+        case _FC_WRITE_AND_READ_REGISTERS:
             length = msg[ctx->backend->header_length + 9];
             break;
         default:
@@ -300,7 +300,7 @@ static int compute_data_length_after_meta(modbus_t *ctx, uint8_t *msg,
         /* MSG_CONFIRMATION */
         if (function <= _FC_READ_INPUT_REGISTERS ||
             function == _FC_REPORT_SLAVE_ID ||
-            function == _FC_READ_AND_WRITE_REGISTERS) {
+            function == _FC_WRITE_AND_READ_REGISTERS) {
             length = msg[ctx->backend->header_length + 1];
         } else {
             length = 0;
@@ -526,7 +526,7 @@ static int check_confirmation(modbus_t *ctx, uint8_t *req,
             req_nb_value = (req_nb_value / 8) + ((req_nb_value % 8) ? 1 : 0);
             rsp_nb_value = rsp[offset + 1];
             break;
-        case _FC_READ_AND_WRITE_REGISTERS:
+        case _FC_WRITE_AND_READ_REGISTERS:
         case _FC_READ_HOLDING_REGISTERS:
         case _FC_READ_INPUT_REGISTERS:
             /* Read functions 1 value = 2 bytes */
@@ -858,7 +858,7 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req,
         return -1;
         break;
 
-    case _FC_READ_AND_WRITE_REGISTERS: {
+    case _FC_WRITE_AND_READ_REGISTERS: {
         int nb = (req[offset + 3] << 8) + req[offset + 4];
         uint16_t address_write = (req[offset + 5] << 8) + req[offset + 6];
         int nb_write = (req[offset + 7] << 8) + req[offset + 8];
@@ -867,7 +867,7 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req,
             (address_write + nb_write) > mb_mapping->nb_registers) {
             if (ctx->debug) {
                 fprintf(stderr,
-                        "Illegal data read address %0X or write address %0X in read_and_write_registers\n",
+                        "Illegal data read address %0X or write address %0X write_and_read_registers\n",
                         address + nb, address_write + nb_write);
             }
             rsp_length = response_exception(ctx, &sft,
@@ -1255,11 +1255,12 @@ int modbus_write_registers(modbus_t *ctx, int addr, int nb, const uint16_t *src)
     return rc;
 }
 
-/* Read multiple registers from remote device to dest array and write multiple
-   registers to remote device from data array. */
-int modbus_read_and_write_registers(modbus_t *ctx,
-                                    int read_addr, int read_nb, uint16_t *dest,
-                                    int write_addr, int write_nb, const uint16_t *data)
+/* Write multiple registers from src array to remote device and read multiple
+   registers from remote device to dest array. */
+int modbus_write_and_read_registers(modbus_t *ctx,
+                                    int write_addr, int write_nb, const uint16_t *src,
+                                    int read_addr, int read_nb, uint16_t *dest)
+
 {
     int rc;
     int req_length;
@@ -1268,27 +1269,27 @@ int modbus_read_and_write_registers(modbus_t *ctx,
     uint8_t req[MAX_MESSAGE_LENGTH];
     uint8_t rsp[MAX_MESSAGE_LENGTH];
 
-    if (read_nb > MODBUS_MAX_READ_REGISTERS) {
+    if (write_nb > MODBUS_MAX_RW_WRITE_REGISTERS) {
         if (ctx->debug) {
             fprintf(stderr,
-                    "ERROR Too many registers requested (%d > %d)\n",
-                    read_nb, MODBUS_MAX_READ_REGISTERS);
+                    "ERROR Too many registers to write (%d > %d)\n",
+                    write_nb, MODBUS_MAX_RW_WRITE_REGISTERS);
         }
         errno = EMBMDATA;
         return -1;
     }
 
-    if (write_nb > MODBUS_MAX_RW_WRITE_REGISTERS) {
+    if (read_nb > MODBUS_MAX_READ_REGISTERS) {
         if (ctx->debug) {
             fprintf(stderr,
-                    "ERROR Too many registers to write (%d > %d)\n",
-                    write_nb, MODBUS_MAX_RW_WRITE_REGISTERS);
+                    "ERROR Too many registers requested (%d > %d)\n",
+                    read_nb, MODBUS_MAX_READ_REGISTERS);
         }
         errno = EMBMDATA;
         return -1;
     }
     req_length = ctx->backend->build_request_basis(ctx,
-                                                   _FC_READ_AND_WRITE_REGISTERS,
+                                                   _FC_WRITE_AND_READ_REGISTERS,
                                                    read_addr, read_nb, req);
 
     req[req_length++] = write_addr >> 8;
@@ -1299,8 +1300,8 @@ int modbus_read_and_write_registers(modbus_t *ctx,
     req[req_length++] = byte_count;
 
     for (i = 0; i < write_nb; i++) {
-        req[req_length++] = data[i] >> 8;
-        req[req_length++] = data[i] & 0x00FF;
+        req[req_length++] = src[i] >> 8;
+        req[req_length++] = src[i] & 0x00FF;
     }
 
     rc = send_msg(ctx, req, req_length);

src/modbus.h

@@ -173,9 +173,9 @@ int modbus_write_bit(modbus_t *ctx, int coil_addr, int status);
 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_read_and_write_registers(modbus_t *ctx, int read_addr,
-                                    int read_nb, uint16_t *dest, int write_addr,
-                                    int write_nb, const uint16_t *data);
+int modbus_write_and_read_registers(modbus_t *ctx, int write_addr, int write_nb,
+                                    const uint16_t *src, int read_addr, int read_nb,
+                                    uint16_t *dest);
 int modbus_report_slave_id(modbus_t *ctx, uint8_t *dest);
 
 modbus_mapping_t* modbus_mapping_new(int nb_coil_status, int nb_input_status,

tests/bandwidth-client.c

@@ -174,7 +174,7 @@ int main(int argc, char *argv[])
     nb_points = MODBUS_MAX_RW_WRITE_REGISTERS;
     start = gettime_ms();
     for (i=0; i<n_loop; i++) {
-        rc = modbus_read_and_write_registers(ctx,
+        rc = modbus_write_and_read_registers(ctx,
                                              0, nb_points, tab_reg,
                                              0, nb_points, tab_reg);
         if (rc == -1) {

tests/random-test-client.c

@@ -195,9 +195,9 @@ int main(void)
                 }
             }
             /* R/W MULTIPLE REGISTERS */
-            rc = modbus_read_and_write_registers(ctx,
-                                                 addr, nb, tab_rp_registers,
-                                                 addr, nb, tab_rw_rq_registers);
+            rc = modbus_write_and_read_registers(ctx,
+                                                 addr, nb, tab_rw_rq_registers,
+                                                 addr, nb, tab_rp_registers);
             if (rc != nb) {
                 printf("ERROR modbus_read_and_write_registers (%d)\n", rc);
                 printf("Address = %d, nb = %d\n", addr, nb);

tests/unit-test-client.c

@@ -269,13 +269,13 @@ int main(int argc, char *argv[])
     /* Write registers to zero from tab_rp_registers and store read registers
        into tab_rp_registers. So the read registers must set to 0, except the
        first one because there is an offset of 1 register on write. */
-    rc = modbus_read_and_write_registers(ctx,
-                                         UT_REGISTERS_ADDRESS, UT_REGISTERS_NB,
+    rc = modbus_write_and_read_registers(ctx,
+                                         UT_REGISTERS_ADDRESS + 1, UT_REGISTERS_NB - 1,
                                          tab_rp_registers,
-                                         UT_REGISTERS_ADDRESS + 1,
-                                         UT_REGISTERS_NB - 1,
+                                         UT_REGISTERS_ADDRESS,
+                                         UT_REGISTERS_NB,
                                          tab_rp_registers);
-    printf("4/5 modbus_read_and_write_registers: ");
+    printf("4/5 modbus_write_and_read_registers: ");
     if (rc != UT_REGISTERS_NB) {
         printf("FAILED (nb points %d != %d)\n", rc, UT_REGISTERS_NB);
         goto close;