/* Send a response to the received request.
Analyses the request and constructs a response.
If an error occurs, this function construct the response
accordingly.
*/
int modbus_reply(modbus_t *ctx, const uint8_t *req,
int req_length, modbus_mapping_t *mb_mapping)
{
int offset = ctx->backend->header_length;
int slave = req[offset - 1];
int function = req[offset];
uint16_t address = (req[offset + 1] << 8) + req[offset + 2];
uint8_t rsp[MAX_MESSAGE_LENGTH];
int rsp_length = 0;
sft_t sft;
sft.slave = slave;
sft.function = function;
sft.t_id = ctx->backend->prepare_response_tid(req, &req_length);
switch (function) {
case _FC_READ_COILS: {
int nb = (req[offset + 3] << 8) + req[offset + 4];
if ((address + nb) > mb_mapping->nb_bits) {
if (ctx->debug) {
fprintf(stderr, "Illegal data address %0X in read_bits\n",
address + nb);
}
rsp_length = response_exception(
ctx, &sft,
MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp);
} else {
rsp_length = ctx->backend->build_response_basis(&sft, rsp);
rsp[rsp_length++] = (nb / 8) + ((nb % 8) ? 1 : 0);
rsp_length = response_io_status(address, nb,
mb_mapping->tab_bits,
rsp, rsp_length);
}
}
break;
case _FC_READ_DISCRETE_INPUTS: {
/* Similar to coil status (but too many arguments to use a
* function) */
int nb = (req[offset + 3] << 8) + req[offset + 4];
if ((address + nb) > mb_mapping->nb_input_bits) {
if (ctx->debug) {
fprintf(stderr, "Illegal data address %0X in read_input_bits\n",
address + nb);
}
rsp_length = response_exception(
ctx, &sft,
MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp);
} else {
rsp_length = ctx->backend->build_response_basis(&sft, rsp);
rsp[rsp_length++] = (nb / 8) + ((nb % 8) ? 1 : 0);
rsp_length = response_io_status(address, nb,
mb_mapping->tab_input_bits,
rsp, rsp_length);
}
}
break;
case _FC_READ_HOLDING_REGISTERS: {
int nb = (req[offset + 3] << 8) + req[offset + 4];
if ((address + nb) > mb_mapping->nb_registers) {
if (ctx->debug) {
fprintf(stderr, "Illegal data address %0X in read_registers\n",
address + nb);
}
rsp_length = response_exception(
ctx, &sft,
MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp);
} else {
int i;
rsp_length = ctx->backend->build_response_basis(&sft, rsp);
rsp[rsp_length++] = nb << 1;
for (i = address; i < address + nb; i++) {
rsp[rsp_length++] = mb_mapping->tab_registers[i] >> 8;
rsp[rsp_length++] = mb_mapping->tab_registers[i] & 0xFF;
}
}
}
break;
case _FC_READ_INPUT_REGISTERS: {
/* Similar to holding registers (but too many arguments to use a
* function) */
int nb = (req[offset + 3] << 8) + req[offset + 4];
if ((address + nb) > mb_mapping->nb_input_registers) {
if (ctx->debug) {
fprintf(stderr, "Illegal data address %0X in read_input_registers\n",
address + nb);
}
rsp_length = response_exception(
ctx, &sft,
MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp);
} else {
int i;
rsp_length = ctx->backend->build_response_basis(&sft, rsp);
rsp[rsp_length++] = nb << 1;
for (i = address; i < address + nb; i++) {
rsp[rsp_length++] = mb_mapping->tab_input_registers[i] >> 8;
rsp[rsp_length++] = mb_mapping->tab_input_registers[i] & 0xFF;
}
}
}
break;
case _FC_WRITE_SINGLE_COIL:
if (address >= mb_mapping->nb_bits) {
if (ctx->debug) {
fprintf(stderr, "Illegal data address %0X in write_bit\n",
address);
}
rsp_length = response_exception(
ctx, &sft,
MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp);
} else {
int data = (req[offset + 3] << 8) + req[offset + 4];
if (data == 0xFF00 || data == 0x0) {
mb_mapping->tab_bits[address] = (data) ? ON : OFF;
memcpy(rsp, req, req_length);
rsp_length = req_length;
} else {
if (ctx->debug) {
fprintf(stderr,
"Illegal data value %0X in write_bit request at address %0X\n",
data, address);
}
rsp_length = response_exception(
ctx, &sft,
MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp);
}
}
break;
case _FC_WRITE_SINGLE_REGISTER:
if (address >= mb_mapping->nb_registers) {
if (ctx->debug) {
fprintf(stderr, "Illegal data address %0X in write_register\n",
address);
}
rsp_length = response_exception(
ctx, &sft,
MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp);
} else {
int data = (req[offset + 3] << 8) + req[offset + 4];
mb_mapping->tab_registers[address] = data;
memcpy(rsp, req, req_length);
rsp_length = req_length;
}
break;
case _FC_WRITE_MULTIPLE_COILS: {
int nb = (req[offset + 3] << 8) + req[offset + 4];
if ((address + nb) > mb_mapping->nb_bits) {
if (ctx->debug) {
fprintf(stderr, "Illegal data address %0X in write_bits\n",
address + nb);
}
rsp_length = response_exception(
ctx, &sft,
MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp);
} else {
/* 6 = byte count */
modbus_set_bits_from_bytes(mb_mapping->tab_bits, address, nb, &req[offset + 6]);
rsp_length = ctx->backend->build_response_basis(&sft, rsp);
/* 4 to copy the bit address (2) and the quantity of bits */
memcpy(rsp + rsp_length, req + rsp_length, 4);
rsp_length += 4;
}
}
break;
case _FC_WRITE_MULTIPLE_REGISTERS: {
int nb = (req[offset + 3] << 8) + req[offset + 4];
if ((address + nb) > mb_mapping->nb_registers) {
if (ctx->debug) {
fprintf(stderr, "Illegal data address %0X in write_registers\n",
address + nb);
}
rsp_length = response_exception(
ctx, &sft,
MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp);
} else {
int i, j;
for (i = address, j = 6; i < address + nb; i++, j += 2) {
/* 6 and 7 = first value */
mb_mapping->tab_registers[i] =
(req[offset + j] << 8) + req[offset + j + 1];
}
rsp_length = ctx->backend->build_response_basis(&sft, rsp);
/* 4 to copy the address (2) and the no. of registers */
memcpy(rsp + rsp_length, req + rsp_length, 4);
rsp_length += 4;
}
}
break;
case _FC_REPORT_SLAVE_ID: {
int str_len;
int byte_count_pos;
rsp_length = ctx->backend->build_response_basis(&sft, rsp);
/* Skip byte count for now */
byte_count_pos = rsp_length++;
rsp[rsp_length++] = _REPORT_SLAVE_ID;
/* Run indicator status to ON */
rsp[rsp_length++] = 0xFF;
/* LMB + length of LIBMODBUS_VERSION_STRING */
str_len = 3 + strlen(LIBMODBUS_VERSION_STRING);
memcpy(rsp + rsp_length, "LMB" LIBMODBUS_VERSION_STRING, str_len);
rsp_length += str_len;
rsp[byte_count_pos] = rsp_length - byte_count_pos - 1;
}
break;
case _FC_READ_EXCEPTION_STATUS:
if (ctx->debug) {
fprintf(stderr, "FIXME Not implemented\n");
}
errno = ENOPROTOOPT;
return -1;
break;
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];
if ((address + nb) > mb_mapping->nb_registers ||
(address_write + nb_write) > mb_mapping->nb_registers) {
if (ctx->debug) {
fprintf(stderr,
"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,
MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp);
} else {
int i, j;
rsp_length = ctx->backend->build_response_basis(&sft, rsp);
rsp[rsp_length++] = nb << 1;
/* Write first.
10 and 11 are the offset of the first values to write */
for (i = address_write, j = 10; i < address_write + nb_write; i++, j += 2) {
mb_mapping->tab_registers[i] =
(req[offset + j] << 8) + req[offset + j + 1];
}
/* and read the data for the response */
for (i = address; i < address + nb; i++) {
rsp[rsp_length++] = mb_mapping->tab_registers[i] >> 8;
rsp[rsp_length++] = mb_mapping->tab_registers[i] & 0xFF;
}
}
}
break;
default:
rsp_length = response_exception(ctx, &sft,
MODBUS_EXCEPTION_ILLEGAL_FUNCTION,
rsp);
break;
}
return send_msg(ctx, rsp, rsp_length);
}
int main(int argc, char*argv[])
{
int s = -1;
modbus_t *ctx;
modbus_mapping_t *mb_mapping;
int rc;
int i;
int use_backend;
uint8_t *query;
int header_length;
if (argc > 1) {
if (strcmp(argv[1], "tcp") == 0) {
use_backend = TCP;
} else if (strcmp(argv[1], "tcppi") == 0) {
use_backend = TCP_PI;
} else if (strcmp(argv[1], "rtu") == 0) {
use_backend = RTU;
} else {
printf("Usage:\n %s [tcp|tcppi|rtu] - Modbus server for unit testing\n\n", argv[0]);
return -1;
}
} else {
/* By default */
use_backend = TCP;
}
if (use_backend == TCP) {
ctx = modbus_new_tcp("127.0.0.1", 1502);
query = malloc(MODBUS_TCP_MAX_ADU_LENGTH);
} else if (use_backend == TCP_PI) {
ctx = modbus_new_tcp_pi("::0", "1502");
query = malloc(MODBUS_TCP_MAX_ADU_LENGTH);
} else {
ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1);
modbus_set_slave(ctx, SERVER_ID);
query = malloc(MODBUS_RTU_MAX_ADU_LENGTH);
}
header_length = modbus_get_header_length(ctx);
modbus_set_debug(ctx, TRUE);
mb_mapping = modbus_mapping_new(
UT_BITS_ADDRESS + UT_BITS_NB,
UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB,
UT_REGISTERS_ADDRESS + UT_REGISTERS_NB,
UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB);
if (mb_mapping == NULL) {
fprintf(stderr, "Failed to allocate the mapping: %s\n",
modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
/* Unit tests of modbus_mapping_new (tests would not be sufficient if two
nb_* were identical) */
if (mb_mapping->nb_bits != UT_BITS_ADDRESS + UT_BITS_NB) {
printf("Invalid nb bits (%d != %d)\n", UT_BITS_ADDRESS + UT_BITS_NB, mb_mapping->nb_bits);
modbus_free(ctx);
return -1;
}
if (mb_mapping->nb_input_bits != UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB) {
printf("Invalid nb input bits: %d\n", UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB);
modbus_free(ctx);
return -1;
}
if (mb_mapping->nb_registers != UT_REGISTERS_ADDRESS + UT_REGISTERS_NB) {
printf("Invalid nb registers: %d\n", UT_REGISTERS_ADDRESS + UT_REGISTERS_NB);
modbus_free(ctx);
return -1;
}
if (mb_mapping->nb_input_registers != UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB) {
printf("Invalid nb input registers: %d\n", UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB);
modbus_free(ctx);
return -1;
}
/* Examples from PI_MODBUS_300.pdf.
Only the read-only input values are assigned. */
/** INPUT STATUS **/
modbus_set_bits_from_bytes(mb_mapping->tab_input_bits,
UT_INPUT_BITS_ADDRESS, UT_INPUT_BITS_NB,
UT_INPUT_BITS_TAB);
/** INPUT REGISTERS **/
for (i=0; i < UT_INPUT_REGISTERS_NB; i++) {
mb_mapping->tab_input_registers[UT_INPUT_REGISTERS_ADDRESS+i] =
UT_INPUT_REGISTERS_TAB[i];;
}
if (use_backend == TCP) {
s = modbus_tcp_listen(ctx, 1);
modbus_tcp_accept(ctx, &s);
} else if (use_backend == TCP_PI) {
s = modbus_tcp_pi_listen(ctx, 1);
modbus_tcp_pi_accept(ctx, &s);
} else {
rc = modbus_connect(ctx);
if (rc == -1) {
fprintf(stderr, "Unable to connect %s\n", modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
}
for (;;) {
do {
rc = modbus_receive(ctx, query);
/* Filtered queries return 0 */
} while (rc == 0);
/* The connection is not closed on errors which require on reply such as
bad CRC in RTU. */
if (rc == -1 && errno != EMBBADCRC) {
/* Quit */
break;
}
/* Special server behavior to test client */
if (query[header_length] == 0x03) {
/* Read holding registers */
if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 3)
== UT_REGISTERS_NB_SPECIAL) {
printf("Set an incorrect number of values\n");
MODBUS_SET_INT16_TO_INT8(query, header_length + 3,
UT_REGISTERS_NB_SPECIAL - 1);
} else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1)
== UT_REGISTERS_ADDRESS_SPECIAL) {
printf("Reply to this special register address by an exception\n");
modbus_reply_exception(ctx, query,
MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY);
continue;
} else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1)
== UT_REGISTERS_ADDRESS_INVALID_TID_OR_SLAVE) {
const int RAW_REQ_LENGTH = 5;
uint8_t raw_req[] = {
(use_backend == RTU) ? INVALID_SERVER_ID : 0xFF,
0x03,
0x02, 0x00, 0x00
};
printf("Reply with an invalid TID or slave\n");
modbus_send_raw_request(ctx, raw_req, RAW_REQ_LENGTH * sizeof(uint8_t));
continue;
} else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1)
== UT_REGISTERS_ADDRESS_SLEEP_500_MS) {
printf("Sleep 0.5 s before replying\n");
usleep(500000);
} else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1)
== UT_REGISTERS_ADDRESS_BYTE_SLEEP_5_MS) {
/* Test low level only available in TCP mode */
/* Catch the reply and send reply byte a byte */
uint8_t req[] = "\x00\x1C\x00\x00\x00\x05\xFF\x03\x02\x00\x00";
int req_length = 11;
int w_s = modbus_get_socket(ctx);
/* Copy TID */
req[1] = query[1];
for (i=0; i < req_length; i++) {
printf("(%.2X)", req[i]);
usleep(5000);
send(w_s, (const char*)(req + i), 1, MSG_NOSIGNAL);
}
continue;
}
}
rc = modbus_reply(ctx, query, rc, mb_mapping);
if (rc == -1) {
break;
}
}
printf("Quit the loop: %s\n", modbus_strerror(errno));
if (use_backend == TCP) {
if (s != -1) {
close(s);
}
}
modbus_mapping_free(mb_mapping);
free(query);
/* For RTU */
modbus_close(ctx);
modbus_free(ctx);
return 0;
}
int main(int argc, char*argv[])
{
int socket;
modbus_t *ctx;
modbus_mapping_t *mb_mapping;
int rc;
int i;
int use_backend;
uint8_t *query;
int header_length;
if (argc > 1) {
if (strcmp(argv[1], "tcp") == 0) {
use_backend = TCP;
} else if (strcmp(argv[1], "rtu") == 0) {
use_backend = RTU;
} else {
printf("Usage:\n %s [tcp|rtu] - Modbus server for unit testing\n\n", argv[0]);
return -1;
}
} else {
/* By default */
use_backend = TCP;
}
if (use_backend == TCP) {
ctx = modbus_new_tcp("127.0.0.1", 1502);
query = malloc(MODBUS_TCP_MAX_ADU_LENGTH);
} else {
ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1);
modbus_set_slave(ctx, SERVER_ID);
query = malloc(MODBUS_RTU_MAX_ADU_LENGTH);
}
header_length = modbus_get_header_length(ctx);
modbus_set_debug(ctx, TRUE);
modbus_set_error_recovery(ctx, TRUE);
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;
}
/* Examples from PI_MODBUS_300.pdf.
Only the read-only input values are assigned. */
/** INPUT STATUS **/
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] =
UT_INPUT_REGISTERS_TAB[i];;
}
if (use_backend == TCP) {
socket = modbus_tcp_listen(ctx, 1);
modbus_tcp_accept(ctx, &socket);
} else {
rc = modbus_connect(ctx);
if (rc == -1) {
fprintf(stderr, "Unable to connect %s\n", modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
}
for (;;) {
rc = modbus_receive(ctx, -1, query);
if (rc == -1) {
/* Connection closed by the client or error */
break;
}
/* Read holding registers */
if (query[header_length] == 0x03) {
if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 3)
== UT_REGISTERS_NB_POINTS_SPECIAL) {
printf("Set an incorrect number of values\n");
MODBUS_SET_INT16_TO_INT8(query, header_length + 3,
UT_REGISTERS_NB_POINTS);
} else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1)
== UT_REGISTERS_ADDRESS_SPECIAL) {
modbus_reply_exception(ctx, query,
MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY);
continue;
}
}
rc = modbus_reply(ctx, query, rc, mb_mapping);
if (rc == -1) {
break;
}
}
printf("Quit the loop: %s\n", modbus_strerror(errno));
if (use_backend == TCP) {
close(socket);
}
modbus_mapping_free(mb_mapping);
free(query);
modbus_free(ctx);
return 0;
}
int main(int argc, char*argv[])
{
int socket,client_socket;
modbus_t *ctx;
modbus_mapping_t *mb_mapping;
int rc;
int i;
int use_backend;
uint8_t *query;
int header_length;
if (argc > 1) {
if (strcmp(argv[1], "tcp") == 0) {
use_backend = TCP;
} else if (strcmp(argv[1], "utcp") == 0 ) {
use_backend = UNIX_TCP;
} else if (strcmp(argv[1], "tcppi") == 0) {
use_backend = TCP_PI;
} else if (strcmp(argv[1], "rtu") == 0) {
use_backend = RTU;
} else {
printf("Usage:\n %s [tcp|tcppi|rtu] - Modbus server for unit testing\n\n", argv[0]);
return -1;
}
} else {
/* By default */
use_backend = UNIX_TCP;
}
//signal(SIGINT, signal_handler);
if (use_backend == TCP) {
ctx = modbus_new_tcp("127.0.0.1", 502);
query = malloc(MODBUS_TCP_MAX_ADU_LENGTH);
} else if (use_backend == UNIX_TCP) {
ctx = modbus_new_unix_tcp("/tmp/modbus.sock");
query = malloc(MODBUS_TCP_MAX_ADU_LENGTH);
} else if (use_backend == TCP_PI) {
ctx = modbus_new_tcp_pi("::0", "1502");
query = malloc(MODBUS_TCP_MAX_ADU_LENGTH);
} else {
ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1);
modbus_set_slave(ctx, SERVER_ID);
query = malloc(MODBUS_RTU_MAX_ADU_LENGTH);
}
header_length = modbus_get_header_length(ctx);
modbus_set_debug(ctx, TRUE);
//by jesse
modbus_init_cb(ctx, &cb);
//end
mb_mapping = modbus_mapping_new(
UT_BITS_ADDRESS + UT_BITS_NB, // read buffer : start address + number
UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB,
UT_REGISTERS_ADDRESS + UT_REGISTERS_NB,
UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB);
if (mb_mapping == NULL) {
fprintf(stderr, "Failed to allocate the mapping: %s\n",
modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
/* Examples from PI_MODBUS_300.pdf.
Only the read-only input values are assigned. */
/** INPUT STATUS **/
modbus_set_bits_from_bytes(mb_mapping->tab_input_bits,
UT_INPUT_BITS_ADDRESS, UT_INPUT_BITS_NB,
UT_INPUT_BITS_TAB);
/** INPUT REGISTERS **/
for (i=0; i < UT_INPUT_REGISTERS_NB; i++) {
mb_mapping->tab_input_registers[UT_INPUT_REGISTERS_ADDRESS+i] =
UT_INPUT_REGISTERS_TAB[i];;
}
if (use_backend == TCP) {
socket = modbus_tcp_listen(ctx, 1);
} else if (use_backend == UNIX_TCP) {
socket = modbus_unix_tcp_listen(ctx, 1);
} else if (use_backend == TCP_PI) {
socket = modbus_tcp_pi_listen(ctx, 1);
} else {
client_socket = modbus_connect(ctx);
if (rc == -1) {
fprintf(stderr, "Unable to connect %s\n", modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
}
// for unix sock
while (running) {
if (use_backend == TCP) {
client_socket = modbus_tcp_accept(ctx, &socket);
} else if (use_backend == UNIX_TCP) {
client_socket = modbus_unix_tcp_accept(ctx, &socket);
} else if (use_backend == TCP_PI) {
client_socket = modbus_tcp_pi_accept(ctx, &socket);
} else {
// RTU : nothing
}
rc = modbus_receive(ctx, query);
if (rc == -1) {
/* Connection closed by the client or error */
if ( use_backend != RTU)
close(client_socket);
continue;
}
/* Read holding registers */
if (query[header_length] == 0x03) {
if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 3)
== UT_REGISTERS_NB_SPECIAL) {
printf("Set an incorrect number of values\n");
MODBUS_SET_INT16_TO_INT8(query, header_length + 3,
UT_REGISTERS_NB_SPECIAL - 1);
} else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1)
== UT_REGISTERS_ADDRESS_SPECIAL) {
printf("Reply to this special register address by an exception\n");
modbus_reply_exception(ctx, query,
MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY);
continue;
}
}
rc = modbus_reply(ctx, query, rc, mb_mapping);
if ( use_backend != RTU)
close(client_socket);
}
printf("Quit the loop: %s\n", modbus_strerror(errno));
if (use_backend == TCP) {
close(socket);
}
modbus_uninit_cb(ctx, &cb);
modbus_mapping_free(mb_mapping);
free(query);
modbus_free(ctx);
return 0;
}