Reduce the number of params in functions to enhance the speed of

execution.

modbus/modbus.c

@@ -52,6 +52,14 @@
 
 #define UNKNOWN_ERROR_MSG "Not defined in modbus specification"
 
+/* This structure reduces the number of params in functions and so
+ * optimizes the speed of execution (~ 37%). */
+typedef struct {
+        int slave;
+        int function;
+        int t_id; 
+} sft_t;
+
 static const uint8_t NB_TAB_ERROR_MSG = 12;
 static const char *TAB_ERROR_MSG[] = {
         /* 0x00 */ UNKNOWN_ERROR_MSG,
@@ -254,23 +262,23 @@ static int build_query_basis(modbus_param_t *mb_param, int slave,
 }
 
 /* Builds a RTU response header */
-static int build_response_basis_rtu(int slave, int function, uint8_t *response)
+static int build_response_basis_rtu(sft_t *sft, uint8_t *response)
 {
-        response[0] = slave;
-        response[1] = function;
+        response[0] = sft->slave;
+        response[1] = sft->function;
 
         return PRESET_RESPONSE_LENGTH_RTU;
 }
 
 /* Builds a TCP response header */
-static int build_response_basis_tcp(int slave, int function, uint8_t *response, int t_id)
+static int build_response_basis_tcp(sft_t *sft, uint8_t *response)
 {
         /* Extract from MODBUS Messaging on TCP/IP Implementation
            Guide V1.0b (page 23/46):
            The transaction identifier is used to associate the future
            response with the request. */
-        response[0] = t_id >> 8;
-        response[1] = t_id & 0x00ff;
+        response[0] = sft->t_id >> 8;
+        response[1] = sft->t_id & 0x00ff;
 
         /* Protocol Modbus */
         response[2] = 0;
@@ -278,19 +286,19 @@ static int build_response_basis_tcp(int slave, int function, uint8_t *response,
 
         /* Length to fix later with set_message_length_tcp (4 and 5) */
 
-        response[6] = slave;
-        response[7] = function;
+        response[6] = sft->slave;
+        response[7] = sft->function;
 
         return PRESET_RESPONSE_LENGTH_TCP;
 }
 
-static int build_response_basis(modbus_param_t *mb_param, int slave, 
-                                int function, uint8_t *response, int t_id)
+static int build_response_basis(modbus_param_t *mb_param, sft_t *sft, 
+                                uint8_t *response)
 {
         if (mb_param->type_com == RTU)
-                return build_response_basis_rtu(slave, function, response);
+                return build_response_basis_rtu(sft, response);
         else
-                return build_response_basis_tcp(slave, function, response, t_id);
+                return build_response_basis_tcp(sft, response);
 }
 
 /* Sets the length of TCP message in the message (query and response) */
@@ -698,15 +706,14 @@ static int response_io_status(int address, int count,
 }
 
 /* Build the exception response */
-static int response_exception(modbus_param_t *mb_param, int slave,
-                              int function, int exception_code,
-                              uint8_t *response, int t_id)
+static int response_exception(modbus_param_t *mb_param, sft_t *sft,
+                              int exception_code, uint8_t *response)
 {
         int response_length;
 
-        response_length = build_response_basis(mb_param, slave,
-                                               function + 0x80, response,
-                                               t_id);
+        sft->function = sft->function + 0x80;
+        response_length = build_response_basis(mb_param, sft, response);
+
         /* Positive exception code */
         response[response_length++] = -exception_code;
 
@@ -727,12 +734,14 @@ void manage_query(modbus_param_t *mb_param, uint8_t *query,
         uint16_t address = (query[offset+2] << 8) + query[offset+3];
         uint8_t response[MAX_MESSAGE_LENGTH];
         int resp_length = 0;
-        int t_id;
+        sft_t sft;
 
+        sft.slave = slave;
+        sft.function = function;
         if (mb_param->type_com == TCP)
-                t_id = (query[0] << 8) + query[1];
+                sft.t_id = (query[0] << 8) + query[1];
         else
-                t_id = 0;
+                sft.t_id = 0;
 
         switch (function) {
         case FC_READ_COIL_STATUS: {
@@ -741,10 +750,10 @@ void manage_query(modbus_param_t *mb_param, uint8_t *query,
                 if ((address + count) > mb_mapping->nb_coil_status) {
                         printf("Illegal data address %0X in read_coil_status\n",
                                address + count); 
-                        resp_length = response_exception(mb_param, slave, function,
-                                                         ILLEGAL_DATA_ADDRESS, response, t_id);  
+                        resp_length = response_exception(mb_param, &sft,
+                                                         ILLEGAL_DATA_ADDRESS, response);  
                 } else {
-                        resp_length = build_response_basis(mb_param, slave, function, response, t_id);
+                        resp_length = build_response_basis(mb_param, &sft, response);
                         response[resp_length++] = (count / 8) + ((count % 8) ? 1 : 0);
                         resp_length = response_io_status(address, count,
                                                          mb_mapping->tab_coil_status,
@@ -759,10 +768,10 @@ void manage_query(modbus_param_t *mb_param, uint8_t *query,
                 if ((address + count) > mb_mapping->nb_input_status) {
                         printf("Illegal data address %0X in read_input_status\n",
                                address + count); 
-                        resp_length = response_exception(mb_param, slave, function,
-                                                         ILLEGAL_DATA_ADDRESS, response, t_id);
+                        resp_length = response_exception(mb_param, &sft,
+                                                         ILLEGAL_DATA_ADDRESS, response);
                 } else {
-                        resp_length = build_response_basis(mb_param, slave, function, response, t_id);
+                        resp_length = build_response_basis(mb_param, &sft, response);
                         response[resp_length++] = (count / 8) + ((count % 8) ? 1 : 0);
                         resp_length = response_io_status(address, count,
                                                          mb_mapping->tab_input_status,
@@ -776,12 +785,12 @@ void manage_query(modbus_param_t *mb_param, uint8_t *query,
                 if ((address + count) > mb_mapping->nb_holding_registers) {
                         printf("Illegal data address %0X in read_holding_registers\n",
                                address + count); 
-                        resp_length = response_exception(mb_param, slave, function,
-                                                         ILLEGAL_DATA_ADDRESS, response, t_id);
+                        resp_length = response_exception(mb_param, &sft,
+                                                         ILLEGAL_DATA_ADDRESS, response);
                 } else {
                         int i;
                         
-                        resp_length = build_response_basis(mb_param, slave, function, response, t_id);
+                        resp_length = build_response_basis(mb_param, &sft, response);
                         response[resp_length++] = count << 1;
                         for (i = address; i < address + count; i++) {
                                 response[resp_length++] = mb_mapping->tab_holding_registers[i] >> 8;
@@ -797,12 +806,12 @@ void manage_query(modbus_param_t *mb_param, uint8_t *query,
                 if ((address + count) > mb_mapping->nb_input_registers) {
                         printf("Illegal data address %0X in read_input_registers\n",
                                address + count);
-                        resp_length = response_exception(mb_param, slave, function,
-                                                         ILLEGAL_DATA_ADDRESS, response, t_id);
+                        resp_length = response_exception(mb_param, &sft,
+                                                         ILLEGAL_DATA_ADDRESS, response);
                 } else {
                         int i;
 
-                        resp_length = build_response_basis(mb_param, slave, function, response, t_id);
+                        resp_length = build_response_basis(mb_param, &sft, response);
                         response[resp_length++] = count << 1;
                         for (i = address; i < address + count; i++) {
                                 response[resp_length++] = mb_mapping->tab_input_registers[i] >> 8;
@@ -814,8 +823,8 @@ void manage_query(modbus_param_t *mb_param, uint8_t *query,
         case FC_FORCE_SINGLE_COIL:
                 if (address >= mb_mapping->nb_coil_status) {
                         printf("Illegal data address %0X in force_singe_coil\n", address); 
-                        resp_length = response_exception(mb_param, slave, function,
-                                                         ILLEGAL_DATA_ADDRESS, response, t_id);  
+                        resp_length = response_exception(mb_param, &sft,
+                                                         ILLEGAL_DATA_ADDRESS, response);  
                 } else {
                         int data = (query[offset+4] << 8) + query[offset+5];
                         
@@ -829,16 +838,16 @@ void manage_query(modbus_param_t *mb_param, uint8_t *query,
                         } else {
                                 printf("Illegal data value %0X in force_single_coil request at address %0X\n",
                                        data, address);
-                                resp_length = response_exception(mb_param, slave, function,
-                                                                 ILLEGAL_DATA_VALUE, response, t_id);
+                                resp_length = response_exception(mb_param, &sft,
+                                                                 ILLEGAL_DATA_VALUE, response);
                         }
                 }
                 break;          
         case FC_PRESET_SINGLE_REGISTER:
                 if (address >= mb_mapping->nb_holding_registers) {
                         printf("Illegal data address %0X in preset_holding_register\n", address); 
-                        resp_length = response_exception(mb_param, slave, function,
-                                                         ILLEGAL_DATA_ADDRESS, response, t_id);  
+                        resp_length = response_exception(mb_param, &sft,
+                                                         ILLEGAL_DATA_ADDRESS, response);  
                 } else {
                         int data = (query[offset+4] << 8) + query[offset+5];
                         
@@ -853,10 +862,10 @@ void manage_query(modbus_param_t *mb_param, uint8_t *query,
                 if ((address + count) > mb_mapping->nb_coil_status) {
                         printf("Illegal data address %0X in force_multiple_coils\n",
                                address + count);
-                        resp_length = response_exception(mb_param, slave, function,
-                                                         ILLEGAL_DATA_ADDRESS, response, t_id);
+                        resp_length = response_exception(mb_param, &sft,
+                                                         ILLEGAL_DATA_ADDRESS, response);
                 } else {
-                        resp_length = build_response_basis(mb_param, slave, function, response, t_id);
+                        resp_length = build_response_basis(mb_param, &sft, response);
                         /* 4 to copy the coil address (2) and the quantity of coils */
                         memcpy(response + resp_length, query + resp_length, 4);
                         resp_length += 4;
@@ -869,10 +878,10 @@ void manage_query(modbus_param_t *mb_param, uint8_t *query,
                 if ((address + count) > mb_mapping->nb_holding_registers) {
                         printf("Illegal data address %0X in preset_multiple_registers\n",
                                address + count);
-                        resp_length = response_exception(mb_param, slave, function,
-                                                         ILLEGAL_DATA_ADDRESS, response, t_id);
+                        resp_length = response_exception(mb_param, &sft,
+                                                         ILLEGAL_DATA_ADDRESS, response);
                 } else {
-                        resp_length = build_response_basis(mb_param, slave, function, response, t_id);
+                        resp_length = build_response_basis(mb_param, &sft, response);
                         /* 4 to copy the address (2) and the no. of registers */
                         memcpy(response + resp_length, query + resp_length, 4);
                         resp_length += 4;