Peter M. Groen / libmodbus

Commit c94fc60376a2d05340a70e0580e47fb2e70d3eb7

Authored by Stéphane Raimbault
1 parent d2bba0ba

Minor changes to try to follow the 80 columns coding convention.

Inline Side-by-side
Showing 1 changed file with 41 additions and 20 deletions
modbus/modbus.c
  View file @c94fc60
... ... @@ -182,7 +182,8 @@ static unsigned int compute_response_length(modbus_param_t *mb_param,
182 182 case FC_READ_HOLDING_REGISTERS:
183 183 case FC_READ_INPUT_REGISTERS:
184 184 /* Header + 2 * nb values */
185   - resp_length = 3 + 2 * (query[offset + 4] << 8 | query[offset + 5]);
  185 + resp_length = 3 + 2 * (query[offset + 4] << 8 |
  186 + query[offset + 5]);
186 187 break;
187 188 case FC_READ_EXCEPTION_STATUS:
188 189 resp_length = 4;
... ... @@ -347,7 +348,8 @@ int check_crc16(modbus_param_t *mb_param,
347 348 ret = 0;
348 349 } else {
349 350 char s_error[64];
350   - sprintf(s_error, "invalid crc received %0X - crc_calc %0X",
  351 + sprintf(s_error,
  352 + "invalid crc received %0X - crc_calc %0X",
351 353 crc_received, crc_calc);
352 354 ret = INVALID_CRC;
353 355 error_treat(mb_param, ret, s_error);
... ... @@ -479,7 +481,8 @@ int receive_msg(modbus_param_t *mb_param,
479 481 if (msg_length_computed == MSG_LENGTH_UNDEFINED)
480 482 printf("Waiting for a message...\n");
481 483 else
482   - printf("Waiting for a message (%d bytes)...\n", msg_length_computed);
  484 + printf("Waiting for a message (%d bytes)...\n",
  485 + msg_length_computed);
483 486 }
484 487  
485 488 /* Add a file descriptor to the set */
... ... @@ -519,7 +522,8 @@ int receive_msg(modbus_param_t *mb_param,
519 522 read_ret = recv(mb_param->fd, p_msg, length_to_read, 0);
520 523  
521 524 if (read_ret == -1) {
522   - error_treat(mb_param, PORT_SOCKET_FAILURE, "Read port/socket failure");
  525 + error_treat(mb_param, PORT_SOCKET_FAILURE,
  526 + "Read port/socket failure");
523 527 return PORT_SOCKET_FAILURE;
524 528 } else if (read_ret == 0) {
525 529 printf("Connection closed\n");
... ... @@ -604,7 +608,8 @@ static int modbus_check_response(modbus_param_t *mb_param,
604 608 int ret;
605 609  
606 610 response_length_computed = compute_response_length(mb_param, query);
607   - ret = receive_msg(mb_param, response_length_computed, response, &response_length);
  611 + ret = receive_msg(mb_param, response_length_computed,
  612 + response, &response_length);
608 613 if (ret == 0) {
609 614 /* Check message */
610 615 ret = check_crc16(mb_param, response, response_length);
... ... @@ -664,8 +669,11 @@ static int modbus_check_response(modbus_param_t *mb_param,
664 669 case but can avoid a vicious
665 670 segfault */
666 671 char s_error[64];
667   - sprintf(s_error, "Invalid exception code %d", response[offset + 2]);
668   - error_treat(mb_param, INVALID_EXCEPTION_CODE, s_error);
  672 + sprintf(s_error,
  673 + "Invalid exception code %d",
  674 + response[offset + 2]);
  675 + error_treat(mb_param, INVALID_EXCEPTION_CODE,
  676 + s_error);
669 677 free(s_error);
670 678 return INVALID_EXCEPTION_CODE;
671 679 }
... ... @@ -1114,7 +1122,8 @@ int force_single_coil(modbus_param_t *mb_param, int slave,
1114 1122 if (state)
1115 1123 state = 0xFF00;
1116 1124  
1117   - status = set_single(mb_param, slave, FC_FORCE_SINGLE_COIL, coil_addr, state);
  1125 + status = set_single(mb_param, slave, FC_FORCE_SINGLE_COIL,
  1126 + coil_addr, state);
1118 1127  
1119 1128 return status;
1120 1129 }
... ... @@ -1125,7 +1134,8 @@ int preset_single_register(modbus_param_t *mb_param, int slave,
1125 1134 {
1126 1135 int status;
1127 1136  
1128   - status = set_single(mb_param, slave, FC_PRESET_SINGLE_REGISTER, reg_addr, value);
  1137 + status = set_single(mb_param, slave, FC_PRESET_SINGLE_REGISTER,
  1138 + reg_addr, value);
1129 1139  
1130 1140 return status;
1131 1141 }
... ... @@ -1151,7 +1161,8 @@ int force_multiple_coils(modbus_param_t *mb_param, int slave,
1151 1161 nb_points = MAX_STATUS;
1152 1162 }
1153 1163  
1154   - query_length = build_query_basis(mb_param, slave, FC_FORCE_MULTIPLE_COILS,
  1164 + query_length = build_query_basis(mb_param, slave,
  1165 + FC_FORCE_MULTIPLE_COILS,
1155 1166 start_addr, nb_points, query);
1156 1167 byte_count = (nb_points / 8) + ((nb_points % 8) ? 1 : 0);
1157 1168 query[query_length++] = byte_count;
... ... @@ -1312,7 +1323,8 @@ void modbus_init_tcp(modbus_param_t *mb_param, char *ip, int port)
1312 1323 With NOP_ON_ERROR, it is expected that the application will
1313 1324 check for error returns and deal with them as necessary.
1314 1325 */
1315   -void modbus_set_error_handling(modbus_param_t *mb_param, error_handling_t error_handling)
  1326 +void modbus_set_error_handling(modbus_param_t *mb_param,
  1327 + error_handling_t error_handling)
1316 1328 {
1317 1329 if (error_handling == FLUSH_OR_RECONNECT_ON_ERROR ||
1318 1330 error_handling == NOP_ON_ERROR) {
... ... @@ -1684,15 +1696,19 @@ int modbus_mapping_new(modbus_mapping_t *mb_mapping,
1684 1696 {
1685 1697 /* 0X */
1686 1698 mb_mapping->nb_coil_status = nb_coil_status;
1687   - mb_mapping->tab_coil_status = (uint8_t *) malloc(nb_coil_status * sizeof(uint8_t));
1688   - memset(mb_mapping->tab_coil_status, 0, nb_coil_status * sizeof(uint8_t));
  1699 + mb_mapping->tab_coil_status =
  1700 + (uint8_t *) malloc(nb_coil_status * sizeof(uint8_t));
  1701 + memset(mb_mapping->tab_coil_status, 0,
  1702 + nb_coil_status * sizeof(uint8_t));
1689 1703 if (mb_mapping->tab_coil_status == NULL)
1690 1704 return FALSE;
1691 1705  
1692 1706 /* 1X */
1693 1707 mb_mapping->nb_input_status = nb_input_status;
1694   - mb_mapping->tab_input_status = (uint8_t *) malloc(nb_input_status * sizeof(uint8_t));
1695   - memset(mb_mapping->tab_input_status, 0, nb_input_status * sizeof(uint8_t));
  1708 + mb_mapping->tab_input_status =
  1709 + (uint8_t *) malloc(nb_input_status * sizeof(uint8_t));
  1710 + memset(mb_mapping->tab_input_status, 0,
  1711 + nb_input_status * sizeof(uint8_t));
1696 1712 if (mb_mapping->tab_input_status == NULL) {
1697 1713 free(mb_mapping->tab_coil_status);
1698 1714 return FALSE;
... ... @@ -1700,8 +1716,10 @@ int modbus_mapping_new(modbus_mapping_t *mb_mapping,
1700 1716  
1701 1717 /* 4X */
1702 1718 mb_mapping->nb_holding_registers = nb_holding_registers;
1703   - mb_mapping->tab_holding_registers = (uint16_t *) malloc(nb_holding_registers * sizeof(uint16_t));
1704   - memset(mb_mapping->tab_holding_registers, 0, nb_holding_registers * sizeof(uint16_t));
  1719 + mb_mapping->tab_holding_registers =
  1720 + (uint16_t *) malloc(nb_holding_registers * sizeof(uint16_t));
  1721 + memset(mb_mapping->tab_holding_registers, 0,
  1722 + nb_holding_registers * sizeof(uint16_t));
1705 1723 if (mb_mapping->tab_holding_registers == NULL) {
1706 1724 free(mb_mapping->tab_coil_status);
1707 1725 free(mb_mapping->tab_input_status);
... ... @@ -1710,8 +1728,10 @@ int modbus_mapping_new(modbus_mapping_t *mb_mapping,
1710 1728  
1711 1729 /* 3X */
1712 1730 mb_mapping->nb_input_registers = nb_input_registers;
1713   - mb_mapping->tab_input_registers = (uint16_t *) malloc(nb_input_registers * sizeof(uint16_t));
1714   - memset(mb_mapping->tab_input_registers, 0, nb_input_registers * sizeof(uint16_t));
  1731 + mb_mapping->tab_input_registers =
  1732 + (uint16_t *) malloc(nb_input_registers * sizeof(uint16_t));
  1733 + memset(mb_mapping->tab_input_registers, 0,
  1734 + nb_input_registers * sizeof(uint16_t));
1715 1735 if (mb_mapping->tab_input_registers == NULL) {
1716 1736 free(mb_mapping->tab_coil_status);
1717 1737 free(mb_mapping->tab_input_status);
... ... @@ -1802,7 +1822,8 @@ void set_bits_from_byte(uint8_t *dest, int address, const uint8_t value)
1802 1822  
1803 1823 /* Sets many inputs/coils from a table of bytes (only the bits between
1804 1824 address and address + nb_points are setted) */
1805   -void set_bits_from_bytes(uint8_t *dest, int address, int nb_points, const uint8_t tab_byte[])
  1825 +void set_bits_from_bytes(uint8_t *dest, int address, int nb_points,
  1826 + const uint8_t tab_byte[])
1806 1827 {
1807 1828 int i;
1808 1829 int shift = 0;
... ...