From 933ed4d3e9f226a21274ff33ebc735d50d5f0be9 Mon Sep 17 00:00:00 2001 From: Stéphane Raimbault Date: Tue, 10 May 2016 13:34:22 +0200 Subject: [PATCH] Change API modbus_mapping_(offsets_new) to (new_start_address) --- doc/Makefile.am | 2 +- doc/modbus_mapping_new.txt | 6 ++++-- doc/modbus_mapping_new_start_address.txt | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ doc/modbus_mapping_offset_new.txt | 70 ---------------------------------------------------------------------- src/modbus.c | 133 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------------------------ src/modbus.h | 20 +++++++++++--------- 6 files changed, 170 insertions(+), 142 deletions(-) create mode 100644 doc/modbus_mapping_new_start_address.txt delete mode 100644 doc/modbus_mapping_offset_new.txt diff --git a/doc/Makefile.am b/doc/Makefile.am index 61ab5d5..48c0819 100644 --- a/doc/Makefile.am +++ b/doc/Makefile.am @@ -15,7 +15,7 @@ TXT3 = \ modbus_get_socket.txt \ modbus_mapping_free.txt \ modbus_mapping_new.txt \ - modbus_mapping_offset_new.txt \ + modbus_mapping_new_start_address.txt \ modbus_mask_write_register.txt \ modbus_new_rtu.txt \ modbus_new_tcp_pi.txt \ diff --git a/doc/modbus_mapping_new.txt b/doc/modbus_mapping_new.txt index 293131b..71cde1d 100644 --- a/doc/modbus_mapping_new.txt +++ b/doc/modbus_mapping_new.txt @@ -18,8 +18,9 @@ The *modbus_mapping_new()* function shall allocate four arrays to store bits, input bits, registers and inputs registers. The pointers are stored in modbus_mapping_t structure. All values of the arrays are initialized to zero. -This function is equivalent to a call of the _modbus_mapping_offset_new()_ function -with all offsets set to zero. +This function is equivalent to a call of the +linkmb:modbus_mapping_new_start_address[3] function with all start addresses to +`0`. If it isn't necessary to allocate an array for a specific type of data, you can pass the zero value in argument, the associated pointer will be NULL. @@ -59,6 +60,7 @@ if (mb_mapping == NULL) { SEE ALSO -------- linkmb:modbus_mapping_free[3] +linkmb:modbus_mapping_new_start_address[3] AUTHORS diff --git a/doc/modbus_mapping_new_start_address.txt b/doc/modbus_mapping_new_start_address.txt new file mode 100644 index 0000000..4fa196a --- /dev/null +++ b/doc/modbus_mapping_new_start_address.txt @@ -0,0 +1,81 @@ +modbus_mapping_new_start_address(3) +=================================== + + +NAME +---- +modbus_mapping_new_start_address - allocate four arrays of bits and registers accessible from their starting addresses + + +SYNOPSIS +-------- +*modbus_mapping_t* modbus_mapping_new_start_address(int 'start_bits', int 'nb_bits', + int 'start_input_bits', int 'nb_input_bits', + int 'start_registers', int 'nb_registers', + int 'start_input_registers', int 'nb_input_registers');* + + +DESCRIPTION +----------- +The _modbus_mapping_new_start_address()_ function shall allocate four arrays to +store bits, input bits, registers and inputs registers. The pointers are stored +in modbus_mapping_t structure. All values of the arrays are initialized to zero. + +The different starting adresses make it possible to place the mapping at any +address in each address space. This way, you can give access to values stored +at high adresses without allocating memory from the address zero, for eg. to +make available registers from 10000 to 10009, you can use: + +[source,c] +------------------- +mb_mapping = modbus_mapping_offset_start_address(0, 0, 0, 0, 10000, 10, 0, 0); +------------------- + +With this code, only 10 registers (`uint16_t`) are allocated. + +If it isn't necessary to allocate an array for a specific type of data, you can +pass the zero value in argument, the associated pointer will be NULL. + +This function is convenient to handle requests in a Modbus server/slave. + + +RETURN VALUE +------------ +The _modbus_mapping_offset_new()_ function shall return the new allocated structure if +successful. Otherwise it shall return NULL and set errno. + + +ERRORS +------ +ENOMEM:: +Not enough memory + + +EXAMPLE +------- +[source,c] +------------------- +/* The first value of each array is accessible at the defined address. + The end address is ADDRESS + NB - 1. */ +mb_mapping = modbus_mapping_offset_start_address(BITS_ADDRESS, BITS_NB, + INPUT_BITS_ADDRESS, INPUT_BITS_NB, + REGISTERS_ADDRESS, REGISTERS_NB, + INPUT_REGISTERS_ADDRESS, INPUT_REGISTERS_NB); +if (mb_mapping == NULL) { + fprintf(stderr, "Failed to allocate the mapping: %s\n", + modbus_strerror(errno)); + modbus_free(ctx); + return -1; +} +------------------- + +SEE ALSO +-------- +linkmb:modbus_mapping_new[3] +linkmb:modbus_mapping_free[3] + + +AUTHORS +------- +The libmodbus documentation was written by Stéphane Raimbault + diff --git a/doc/modbus_mapping_offset_new.txt b/doc/modbus_mapping_offset_new.txt deleted file mode 100644 index d860664..0000000 --- a/doc/modbus_mapping_offset_new.txt +++ /dev/null @@ -1,70 +0,0 @@ -modbus_mapping_offset_new(3) -============================ - - -NAME ----- -modbus_mapping_offset_new - allocate four arrays of bits and registers - - -SYNOPSIS --------- -*modbus_mapping_t* modbus_mapping_new(int 'nb_bits', int 'offset_bits', - int 'nb_input_bits', int 'offset_input_bits', - int 'nb_registers', int 'offset_registers', - int 'nb_input_registers', int 'offset_input_registers');* - - -DESCRIPTION ------------ -The _modbus_mapping_offset_new()_ function shall allocate four arrays to store bits, -input bits, registers and inputs registers. The pointers are stored in -modbus_mapping_t structure. All values of the arrays are initialized to zero. - -The different offsets make it possible to place the mapping at any address in -each address space. - -If it isn't necessary to allocate an array for a specific type of data, you can -pass the zero value in argument, the associated pointer will be NULL. - -This function is convenient to handle requests in a Modbus server/slave. - - -RETURN VALUE ------------- -The _modbus_mapping_offset_new()_ function shall return the new allocated structure if -successful. Otherwise it shall return NULL and set errno. - - -ERRORS ------- -ENOMEM:: -Not enough memory - - -EXAMPLE -------- -[source,c] -------------------- -/* The first value of each array is accessible at address 4. */ -mb_mapping = modbus_mapping_offset_new(BITS_ADDRESS + BITS_NB, 4, - INPUT_BITS_ADDRESS + INPUT_BITS_NB, 4, - REGISTERS_ADDRESS + REGISTERS_NB, 4, - INPUT_REGISTERS_ADDRESS + INPUT_REGISTERS_NB, 4); -if (mb_mapping == NULL) { - fprintf(stderr, "Failed to allocate the mapping: %s\n", - modbus_strerror(errno)); - modbus_free(ctx); - return -1; -} -------------------- - -SEE ALSO --------- -linkmb:modbus_mapping_free[3] - - -AUTHORS -------- -The libmodbus documentation was written by Stéphane Raimbault - diff --git a/src/modbus.c b/src/modbus.c index 1a5a778..48e2c59 100644 --- a/src/modbus.c +++ b/src/modbus.c @@ -630,8 +630,8 @@ static int check_confirmation(modbus_t *ctx, uint8_t *req, return rc; } -static int response_io_status(int address, int nb, - uint8_t *tab_io_status, +static int response_io_status(uint8_t *tab_io_status, + int address, int nb, uint8_t *rsp, int offset) { int shift = 0; @@ -639,7 +639,7 @@ static int response_io_status(int address, int nb, int one_byte = 0; int i; - for (i = address; i < address+nb; i++) { + for (i = address; i < address + nb; i++) { one_byte |= tab_io_status[i] << shift; if (shift == 7) { /* Byte is full */ @@ -706,7 +706,9 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, switch (function) { case MODBUS_FC_READ_COILS: { int nb = (req[offset + 3] << 8) + req[offset + 4]; - int addr = address - mb_mapping->offset_bits; + /* The mapping can be shifted to reduce memory consumption and it + doesn't always start at address zero. */ + int mapping_address = address - mb_mapping->start_bits; if (nb < 1 || MODBUS_MAX_READ_BITS < nb) { if (ctx->debug) { @@ -719,10 +721,11 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, rsp_length = response_exception( ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp); - } else if (address < mb_mapping->offset_bits || (addr + nb) > mb_mapping->nb_bits) { + } else if (mapping_address < 0 || + (mapping_address + nb) > mb_mapping->nb_bits) { if (ctx->debug) { fprintf(stderr, "Illegal data address 0x%0X in read_bits\n", - address < mb_mapping->offset_bits ? address : address + nb); + mapping_address < 0 ? address : address + nb); } rsp_length = response_exception( ctx, &sft, @@ -730,8 +733,8 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, } else { rsp_length = ctx->backend->build_response_basis(&sft, rsp); rsp[rsp_length++] = (nb / 8) + ((nb % 8) ? 1 : 0); - rsp_length = response_io_status(addr, nb, - mb_mapping->tab_bits, + rsp_length = response_io_status(mb_mapping->tab_bits, + mapping_address, nb, rsp, rsp_length); } } @@ -740,7 +743,7 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, /* Similar to coil status (but too many arguments to use a * function) */ int nb = (req[offset + 3] << 8) + req[offset + 4]; - int addr = address - mb_mapping->offset_input_bits; + int mapping_address = address - mb_mapping->start_input_bits; if (nb < 1 || MODBUS_MAX_READ_BITS < nb) { if (ctx->debug) { @@ -753,10 +756,11 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, rsp_length = response_exception( ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp); - } else if (address < mb_mapping->offset_input_bits || (addr + nb) > mb_mapping->nb_input_bits) { + } else if (mapping_address < 0 || + (mapping_address + nb) > mb_mapping->nb_input_bits) { if (ctx->debug) { fprintf(stderr, "Illegal data address 0x%0X in read_input_bits\n", - address < mb_mapping->offset_input_bits ? address : address + nb); + mapping_address < 0 ? address : address + nb); } rsp_length = response_exception( ctx, &sft, @@ -764,15 +768,15 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, } else { rsp_length = ctx->backend->build_response_basis(&sft, rsp); rsp[rsp_length++] = (nb / 8) + ((nb % 8) ? 1 : 0); - rsp_length = response_io_status(addr, nb, - mb_mapping->tab_input_bits, + rsp_length = response_io_status(mb_mapping->tab_input_bits, + mapping_address, nb, rsp, rsp_length); } } break; case MODBUS_FC_READ_HOLDING_REGISTERS: { int nb = (req[offset + 3] << 8) + req[offset + 4]; - int addr = address - mb_mapping->offset_registers; + int mapping_address = address - mb_mapping->start_registers; if (nb < 1 || MODBUS_MAX_READ_REGISTERS < nb) { if (ctx->debug) { @@ -785,10 +789,11 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, rsp_length = response_exception( ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp); - } else if (address < mb_mapping->offset_registers || (addr + nb) > mb_mapping->nb_registers) { + } else if (mapping_address < 0 || + (mapping_address + nb) > mb_mapping->nb_registers) { if (ctx->debug) { fprintf(stderr, "Illegal data address 0x%0X in read_registers\n", - address < mb_mapping->offset_registers ? address : address + nb); + mapping_address < 0 ? address : address + nb); } rsp_length = response_exception( ctx, &sft, @@ -798,7 +803,7 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, rsp_length = ctx->backend->build_response_basis(&sft, rsp); rsp[rsp_length++] = nb << 1; - for (i = addr; i < addr + nb; i++) { + for (i = mapping_address; i < mapping_address + nb; i++) { rsp[rsp_length++] = mb_mapping->tab_registers[i] >> 8; rsp[rsp_length++] = mb_mapping->tab_registers[i] & 0xFF; } @@ -809,7 +814,7 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, /* Similar to holding registers (but too many arguments to use a * function) */ int nb = (req[offset + 3] << 8) + req[offset + 4]; - int addr = address - mb_mapping->offset_input_registers; + int mapping_address = address - mb_mapping->start_input_registers; if (nb < 1 || MODBUS_MAX_READ_REGISTERS < nb) { if (ctx->debug) { @@ -822,10 +827,11 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, rsp_length = response_exception( ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp); - } else if (address < mb_mapping->offset_input_registers || (addr + nb) > mb_mapping->nb_input_registers) { + } else if (mapping_address < 0 || + (mapping_address + nb) > mb_mapping->nb_input_registers) { if (ctx->debug) { fprintf(stderr, "Illegal data address 0x%0X in read_input_registers\n", - address < mb_mapping->offset_input_registers ? address : address + nb); + mapping_address < 0 ? address : address + nb); } rsp_length = response_exception( ctx, &sft, @@ -835,7 +841,7 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, rsp_length = ctx->backend->build_response_basis(&sft, rsp); rsp[rsp_length++] = nb << 1; - for (i = addr; i < addr + nb; i++) { + for (i = mapping_address; i < mapping_address + nb; i++) { rsp[rsp_length++] = mb_mapping->tab_input_registers[i] >> 8; rsp[rsp_length++] = mb_mapping->tab_input_registers[i] & 0xFF; } @@ -843,9 +849,9 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, } break; case MODBUS_FC_WRITE_SINGLE_COIL: { - int addr = address - mb_mapping->offset_bits; + int mapping_address = address - mb_mapping->start_bits; - if (address < mb_mapping->offset_bits || addr >= mb_mapping->nb_bits) { + if (mapping_address < 0 || mapping_address >= mb_mapping->nb_bits) { if (ctx->debug) { fprintf(stderr, "Illegal data address 0x%0X in write_bit\n", @@ -858,7 +864,7 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, int data = (req[offset + 3] << 8) + req[offset + 4]; if (data == 0xFF00 || data == 0x0) { - mb_mapping->tab_bits[addr] = (data) ? ON : OFF; + mb_mapping->tab_bits[mapping_address] = data ? ON : OFF; memcpy(rsp, req, req_length); rsp_length = req_length; } else { @@ -875,9 +881,9 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, } break; case MODBUS_FC_WRITE_SINGLE_REGISTER: { - int addr = address - mb_mapping->offset_registers; + int mapping_address = address - mb_mapping->start_registers; - if (address < mb_mapping->offset_registers || addr >= mb_mapping->nb_registers) { + if (mapping_address < 0 || mapping_address >= mb_mapping->nb_registers) { if (ctx->debug) { fprintf(stderr, "Illegal data address 0x%0X in write_register\n", address); @@ -888,7 +894,7 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, } else { int data = (req[offset + 3] << 8) + req[offset + 4]; - mb_mapping->tab_registers[addr] = data; + mb_mapping->tab_registers[mapping_address] = data; memcpy(rsp, req, req_length); rsp_length = req_length; } @@ -896,7 +902,7 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, break; case MODBUS_FC_WRITE_MULTIPLE_COILS: { int nb = (req[offset + 3] << 8) + req[offset + 4]; - int addr = address - mb_mapping->offset_bits; + int mapping_address = address - mb_mapping->start_bits; if (nb < 1 || MODBUS_MAX_WRITE_BITS < nb) { if (ctx->debug) { @@ -912,17 +918,19 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, rsp_length = response_exception( ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp); - } else if (address < mb_mapping->offset_bits || (addr + nb) > mb_mapping->nb_bits) { + } else if (mapping_address < 0 || + (mapping_address + nb) > mb_mapping->nb_bits) { if (ctx->debug) { fprintf(stderr, "Illegal data address 0x%0X in write_bits\n", - address < mb_mapping->offset_bits ? address : address + nb); + mapping_address < 0 ? address : 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, addr, nb, &req[offset + 6]); + modbus_set_bits_from_bytes(mb_mapping->tab_bits, mapping_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 */ @@ -933,7 +941,7 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, break; case MODBUS_FC_WRITE_MULTIPLE_REGISTERS: { int nb = (req[offset + 3] << 8) + req[offset + 4]; - int addr = address - mb_mapping->offset_registers; + int mapping_address = address - mb_mapping->start_registers; if (nb < 1 || MODBUS_MAX_WRITE_REGISTERS < nb) { if (ctx->debug) { @@ -949,17 +957,18 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, rsp_length = response_exception( ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp); - } else if (address < mb_mapping->offset_registers || (addr + nb) > mb_mapping->nb_registers) { + } else if (mapping_address < 0 || + (mapping_address + nb) > mb_mapping->nb_registers) { if (ctx->debug) { fprintf(stderr, "Illegal data address 0x%0X in write_registers\n", - address < mb_mapping->offset_registers ? address : address + nb); + mapping_address < 0 ? address : address + nb); } rsp_length = response_exception( ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp); } else { int i, j; - for (i = addr, j = 6; i < addr + nb; i++, j += 2) { + for (i = mapping_address, j = 6; i < mapping_address + nb; i++, j += 2) { /* 6 and 7 = first value */ mb_mapping->tab_registers[i] = (req[offset + j] << 8) + req[offset + j + 1]; @@ -997,9 +1006,9 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, return -1; break; case MODBUS_FC_MASK_WRITE_REGISTER: { - int addr = address - mb_mapping->offset_registers; + int mapping_address = address - mb_mapping->start_registers; - if (address < mb_mapping->offset_registers || addr >= mb_mapping->nb_registers) { + if (mapping_address < 0 || mapping_address >= mb_mapping->nb_registers) { if (ctx->debug) { fprintf(stderr, "Illegal data address 0x%0X in write_register\n", address); @@ -1008,12 +1017,12 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp); } else { - uint16_t data = mb_mapping->tab_registers[addr]; + uint16_t data = mb_mapping->tab_registers[mapping_address]; uint16_t and = (req[offset + 3] << 8) + req[offset + 4]; uint16_t or = (req[offset + 5] << 8) + req[offset + 6]; data = (data & and) | (or & (~and)); - mb_mapping->tab_registers[addr] = data; + mb_mapping->tab_registers[mapping_address] = data; memcpy(rsp, req, req_length); rsp_length = req_length; } @@ -1024,8 +1033,8 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, uint16_t address_write = (req[offset + 5] << 8) + req[offset + 6]; int nb_write = (req[offset + 7] << 8) + req[offset + 8]; int nb_write_bytes = req[offset + 9]; - int addr = address - mb_mapping->offset_registers; - int addr_write = address_write - mb_mapping->offset_registers; + int mapping_address = address - mb_mapping->start_registers; + int mapping_address_write = address_write - mb_mapping->start_registers; if (nb_write < 1 || MODBUS_MAX_WR_WRITE_REGISTERS < nb_write || nb < 1 || MODBUS_MAX_WR_READ_REGISTERS < nb || @@ -1041,15 +1050,15 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, rsp_length = response_exception( ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp); - } else if (address < mb_mapping->offset_registers || - (addr + nb) > mb_mapping->nb_registers || - address_write < mb_mapping->offset_registers || - (addr_write + nb_write) > mb_mapping->nb_registers) { + } else if (mapping_address < 0 || + (mapping_address + nb) > mb_mapping->nb_registers || + mapping_address < 0 || + (mapping_address_write + nb_write) > mb_mapping->nb_registers) { if (ctx->debug) { fprintf(stderr, "Illegal data read address 0x%0X or write address 0x%0X write_and_read_registers\n", - address < mb_mapping->offset_registers ? address : address + nb, - address_write < mb_mapping->offset_registers ? address_write : address_write + nb_write); + mapping_address < 0 ? address : address + nb, + mapping_address_write < 0 ? address_write : address_write + nb_write); } rsp_length = response_exception(ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp); @@ -1060,13 +1069,14 @@ int modbus_reply(modbus_t *ctx, const uint8_t *req, /* Write first. 10 and 11 are the offset of the first values to write */ - for (i = addr_write, j = 10; i < addr_write + nb_write; i++, j += 2) { + for (i = mapping_address_write, j = 10; + i < mapping_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 = addr; i < addr + nb; i++) { + for (i = mapping_address; i < mapping_address + nb; i++) { rsp[rsp_length++] = mb_mapping->tab_registers[i] >> 8; rsp[rsp_length++] = mb_mapping->tab_registers[i] & 0xFF; } @@ -1807,12 +1817,14 @@ int modbus_set_debug(modbus_t *ctx, int flag) /* Allocates 4 arrays to store bits, input bits, registers and inputs registers. The pointers are stored in modbus_mapping structure. - The modbus_mapping_offset_new() function shall return the new allocated structure if - successful. Otherwise it shall return NULL and set errno to ENOMEM. */ -modbus_mapping_t* modbus_mapping_offset_new(int nb_bits, int offset_bits, - int nb_input_bits, int offset_input_bits, - int nb_registers, int offset_registers, - int nb_input_registers, int offset_input_registers) + The modbus_mapping_new_ranges() function shall return the new allocated + structure if successful. Otherwise it shall return NULL and set errno to + ENOMEM. */ +modbus_mapping_t* modbus_mapping_new_start_address( + unsigned int start_bits, unsigned int nb_bits, + unsigned int start_input_bits, unsigned int nb_input_bits, + unsigned int start_registers, unsigned int nb_registers, + unsigned int start_input_registers, unsigned int nb_input_registers) { modbus_mapping_t *mb_mapping; @@ -1823,7 +1835,7 @@ modbus_mapping_t* modbus_mapping_offset_new(int nb_bits, int offset_bits, /* 0X */ mb_mapping->nb_bits = nb_bits; - mb_mapping->offset_bits = offset_bits; + mb_mapping->start_bits = start_bits; if (nb_bits == 0) { mb_mapping->tab_bits = NULL; } else { @@ -1839,7 +1851,7 @@ modbus_mapping_t* modbus_mapping_offset_new(int nb_bits, int offset_bits, /* 1X */ mb_mapping->nb_input_bits = nb_input_bits; - mb_mapping->offset_input_bits = offset_input_bits; + mb_mapping->start_input_bits = start_input_bits; if (nb_input_bits == 0) { mb_mapping->tab_input_bits = NULL; } else { @@ -1855,7 +1867,7 @@ modbus_mapping_t* modbus_mapping_offset_new(int nb_bits, int offset_bits, /* 4X */ mb_mapping->nb_registers = nb_registers; - mb_mapping->offset_registers = offset_registers; + mb_mapping->start_registers = start_registers; if (nb_registers == 0) { mb_mapping->tab_registers = NULL; } else { @@ -1872,7 +1884,7 @@ modbus_mapping_t* modbus_mapping_offset_new(int nb_bits, int offset_bits, /* 3X */ mb_mapping->nb_input_registers = nb_input_registers; - mb_mapping->offset_input_registers = offset_input_registers; + mb_mapping->start_input_registers = start_input_registers; if (nb_input_registers == 0) { mb_mapping->tab_input_registers = NULL; } else { @@ -1895,7 +1907,8 @@ modbus_mapping_t* modbus_mapping_offset_new(int nb_bits, int offset_bits, modbus_mapping_t* modbus_mapping_new(int nb_bits, int nb_input_bits, int nb_registers, int nb_input_registers) { - return modbus_mapping_offset_new(nb_bits, 0, nb_input_bits, 0, nb_registers, 0, nb_input_registers, 0); + return modbus_mapping_new_start_address( + 0, nb_bits, 0, nb_input_bits, 0, nb_registers, 0, nb_input_registers); } /* Frees the 4 arrays */ diff --git a/src/modbus.h b/src/modbus.h index 47a69d1..e3e9f86 100644 --- a/src/modbus.h +++ b/src/modbus.h @@ -156,13 +156,13 @@ typedef struct _modbus modbus_t; typedef struct { int nb_bits; - int offset_bits; + int start_bits; int nb_input_bits; - int offset_input_bits; + int start_input_bits; int nb_input_registers; - int offset_input_registers; + int start_input_registers; int nb_registers; - int offset_registers; + int start_registers; uint8_t *tab_bits; uint8_t *tab_input_bits; uint16_t *tab_input_registers; @@ -213,12 +213,14 @@ MODBUS_API int modbus_write_and_read_registers(modbus_t *ctx, int write_addr, in uint16_t *dest); MODBUS_API int modbus_report_slave_id(modbus_t *ctx, int max_dest, uint8_t *dest); -MODBUS_API modbus_mapping_t* modbus_mapping_offset_new(int nb_bits, int offset_bits, - int nb_input_bits, int offset_input_bits, - int nb_registers, int offset_registers, - int nb_input_registers, int offset_input_registers); +MODBUS_API modbus_mapping_t* modbus_mapping_new_start_address( + unsigned int start_bits, unsigned int nb_bits, + unsigned int start_input_bits, unsigned int nb_input_bits, + unsigned int start_registers, unsigned int nb_registers, + unsigned int start_input_registers, unsigned int nb_input_registers); + MODBUS_API modbus_mapping_t* modbus_mapping_new(int nb_bits, int nb_input_bits, - int nb_registers, int nb_input_registers); + int nb_registers, int nb_input_registers); MODBUS_API void modbus_mapping_free(modbus_mapping_t *mb_mapping); MODBUS_API int modbus_send_raw_request(modbus_t *ctx, uint8_t *raw_req, int raw_req_length); -- libgit2 0.21.4