michaelh/zephyr
1
0
Fork 0
Code Releases Activity

modbus: rename internal designations and do few minor fixups

Browse source 
Prefix internal functions and structs with modbus_.
Use unit_id consistently instead of node_addr.
Fix mbm_ remainder and rename to mbc_.
Rename struct modbus_frame to modbus_adu since
ADU is closer to what the structure represents.

Let the compiler/linker do the job and
remove ifdef around mbc_validate_fc03fp_response().

Signed-off-by: Johann Fischer <johann.fischer@nordicsemi.no>
This commit is contained in:
Johann Fischer 2021-03-03 15:34:43 +01:00 • committed by Carles Cufí
commit e3c630d25f
6 changed files with 279 additions and 281 deletions
Download patch file Download diff file Expand all files Collapse all files

48
include/modbus/modbus.h
View file

@ -41,7 +41,7 @@ extern "C" {
* Sends a Modbus message to read the status of coils from a server. * Sends a Modbus message to read the status of coils from a server.
* *
* @param iface Modbus interface index * @param iface Modbus interface index
* @param node_addr Modbus unit address of the server * @param unit_id Modbus unit ID of the server
* @param start_addr Coil starting address * @param start_addr Coil starting address
* @param coil_tbl Pointer to an array of bytes containing the value * @param coil_tbl Pointer to an array of bytes containing the value
* of the coils read. * of the coils read.
@ -63,7 +63,7 @@ extern "C" {
* @retval 0 If the function was successful * @retval 0 If the function was successful
*/ */
int modbus_read_coils(const int iface, int modbus_read_coils(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
uint8_t *const coil_tbl, uint8_t *const coil_tbl,
const uint16_t num_coils); const uint16_t num_coils);
@ -75,7 +75,7 @@ int modbus_read_coils(const int iface,
* a server. * a server.
* *
* @param iface Modbus interface index * @param iface Modbus interface index
* @param node_addr Modbus unit address of the server * @param unit_id Modbus unit ID of the server
* @param start_addr Discrete input starting address * @param start_addr Discrete input starting address
* @param di_tbl Pointer to an array that will receive the state * @param di_tbl Pointer to an array that will receive the state
* of the discrete inputs. * of the discrete inputs.
@ -97,7 +97,7 @@ int modbus_read_coils(const int iface,
* @retval 0 If the function was successful * @retval 0 If the function was successful
*/ */
int modbus_read_dinputs(const int iface, int modbus_read_dinputs(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
uint8_t *const di_tbl, uint8_t *const di_tbl,
const uint16_t num_di); const uint16_t num_di);
@ -109,7 +109,7 @@ int modbus_read_dinputs(const int iface,
* from a server. * from a server.
* *
* @param iface Modbus interface index * @param iface Modbus interface index
* @param node_addr Modbus unit address of the server * @param unit_id Modbus unit ID of the server
* @param start_addr Register starting address * @param start_addr Register starting address
* @param reg_buf Is a pointer to an array that will receive * @param reg_buf Is a pointer to an array that will receive
* the current values of the holding registers from * the current values of the holding registers from
@ -120,7 +120,7 @@ int modbus_read_dinputs(const int iface,
* @retval 0 If the function was successful * @retval 0 If the function was successful
*/ */
int modbus_read_holding_regs(const int iface, int modbus_read_holding_regs(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
uint16_t *const reg_buf, uint16_t *const reg_buf,
const uint16_t num_regs); const uint16_t num_regs);
@ -132,7 +132,7 @@ int modbus_read_holding_regs(const int iface,
* a server. * a server.
* *
* @param iface Modbus interface index * @param iface Modbus interface index
* @param node_addr Modbus unit address of the server * @param unit_id Modbus unit ID of the server
* @param start_addr Register starting address * @param start_addr Register starting address
* @param reg_buf Is a pointer to an array that will receive * @param reg_buf Is a pointer to an array that will receive
* the current value of the holding registers * the current value of the holding registers
@ -143,7 +143,7 @@ int modbus_read_holding_regs(const int iface,
* @retval 0 If the function was successful * @retval 0 If the function was successful
*/ */
int modbus_read_input_regs(const int iface, int modbus_read_input_regs(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
uint16_t *const reg_buf, uint16_t *const reg_buf,
const uint16_t num_regs); const uint16_t num_regs);
@ -154,14 +154,14 @@ int modbus_read_input_regs(const int iface,
* Sends a Modbus message to write the value of single coil to a server. * Sends a Modbus message to write the value of single coil to a server.
* *
* @param iface Modbus interface index * @param iface Modbus interface index
* @param node_addr Modbus unit address of the server * @param unit_id Modbus unit ID of the server
* @param coil_addr Coils starting address * @param coil_addr Coils starting address
* @param coil_state Is the desired state of the coil * @param coil_state Is the desired state of the coil
* *
* @retval 0 If the function was successful * @retval 0 If the function was successful
*/ */
int modbus_write_coil(const int iface, int modbus_write_coil(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t coil_addr, const uint16_t coil_addr,
const bool coil_state); const bool coil_state);
@ -172,14 +172,14 @@ int modbus_write_coil(const int iface,
* to a server unit. * to a server unit.
* *
* @param iface Modbus interface index * @param iface Modbus interface index
* @param node_addr Modbus unit address of the server * @param unit_id Modbus unit ID of the server
* @param start_addr Coils starting address * @param start_addr Coils starting address
* @param reg_val Desired value of the holding register * @param reg_val Desired value of the holding register
* *
* @retval 0 If the function was successful * @retval 0 If the function was successful
*/ */
int modbus_write_holding_reg(const int iface, int modbus_write_holding_reg(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
const uint16_t reg_val); const uint16_t reg_val);
@ -189,7 +189,7 @@ int modbus_write_holding_reg(const int iface,
* Sends a Modbus message to perform a diagnostic function of a server unit. * Sends a Modbus message to perform a diagnostic function of a server unit.
* *
* @param iface Modbus interface index * @param iface Modbus interface index
* @param node_addr Modbus unit address of the server * @param unit_id Modbus unit ID of the server
* @param sfunc Diagnostic sub-function code * @param sfunc Diagnostic sub-function code
* @param data Sub-function data * @param data Sub-function data
* @param data_out Pointer to the data value * @param data_out Pointer to the data value
@ -197,7 +197,7 @@ int modbus_write_holding_reg(const int iface,
* @retval 0 If the function was successful * @retval 0 If the function was successful
*/ */
int modbus_request_diagnostic(const int iface, int modbus_request_diagnostic(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t sfunc, const uint16_t sfunc,
const uint16_t data, const uint16_t data,
uint16_t *const data_out); uint16_t *const data_out);
@ -208,7 +208,7 @@ int modbus_request_diagnostic(const int iface,
* Sends a Modbus message to write to coils on a server unit. * Sends a Modbus message to write to coils on a server unit.
* *
* @param iface Modbus interface index * @param iface Modbus interface index
* @param node_addr Modbus unit address of the server * @param unit_id Modbus unit ID of the server
* @param start_addr Coils starting address * @param start_addr Coils starting address
* @param coil_tbl Pointer to an array of bytes containing the value * @param coil_tbl Pointer to an array of bytes containing the value
* of the coils to write. * of the coils to write.
@ -230,7 +230,7 @@ int modbus_request_diagnostic(const int iface,
* @retval 0 If the function was successful * @retval 0 If the function was successful
*/ */
int modbus_write_coils(const int iface, int modbus_write_coils(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
uint8_t *const coil_tbl, uint8_t *const coil_tbl,
const uint16_t num_coils); const uint16_t num_coils);
@ -242,7 +242,7 @@ int modbus_write_coils(const int iface,
* to a server unit. * to a server unit.
* *
* @param iface Modbus interface index * @param iface Modbus interface index
* @param node_addr Modbus unit address of the server * @param unit_id Modbus unit ID of the server
* @param start_addr Register starting address * @param start_addr Register starting address
* @param reg_buf Is a pointer to an array containing * @param reg_buf Is a pointer to an array containing
* the value of the holding registers to write. * the value of the holding registers to write.
@ -253,7 +253,7 @@ int modbus_write_coils(const int iface,
* @retval 0 If the function was successful * @retval 0 If the function was successful
*/ */
int modbus_write_holding_regs(const int iface, int modbus_write_holding_regs(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
uint16_t *const reg_buf, uint16_t *const reg_buf,
const uint16_t num_regs); const uint16_t num_regs);
@ -265,7 +265,7 @@ int modbus_write_holding_regs(const int iface,
* holding registers from a server unit. * holding registers from a server unit.
* *
* @param iface Modbus interface index * @param iface Modbus interface index
* @param node_addr Modbus unit address of the server * @param unit_id Modbus unit ID of the server
* @param start_addr Register starting address * @param start_addr Register starting address
* @param reg_buf Is a pointer to an array that will receive * @param reg_buf Is a pointer to an array that will receive
* the current values of the holding registers from * the current values of the holding registers from
@ -276,7 +276,7 @@ int modbus_write_holding_regs(const int iface,
* @retval 0 If the function was successful * @retval 0 If the function was successful
*/ */
int modbus_read_holding_regs_fp(const int iface, int modbus_read_holding_regs_fp(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
float *const reg_buf, float *const reg_buf,
const uint16_t num_regs); const uint16_t num_regs);
@ -288,7 +288,7 @@ int modbus_read_holding_regs_fp(const int iface,
* to a server unit. * to a server unit.
* *
* @param iface Modbus interface index * @param iface Modbus interface index
* @param node_addr Modbus unit address of the server * @param unit_id Modbus unit ID of the server
* @param start_addr Register starting address * @param start_addr Register starting address
* @param reg_buf Is a pointer to an array containing * @param reg_buf Is a pointer to an array containing
* the value of the holding registers to write. * the value of the holding registers to write.
@ -299,7 +299,7 @@ int modbus_read_holding_regs_fp(const int iface,
* @retval 0 If the function was successful * @retval 0 If the function was successful
*/ */
int modbus_write_holding_regs_fp(const int iface, int modbus_write_holding_regs_fp(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
float *const reg_buf, float *const reg_buf,
const uint16_t num_regs); const uint16_t num_regs);
@ -350,7 +350,7 @@ int modbus_iface_get_by_name(const char *iface_name);
* @brief Configure Modbus Interface as server * @brief Configure Modbus Interface as server
* *
* @param iface Modbus interface index * @param iface Modbus interface index
* @param node_addr Modbus unit address of the server * @param unit_id Modbus unit ID of the server
* @param baud Baudrate of the serial line * @param baud Baudrate of the serial line
* @param parity UART's parity setting: * @param parity UART's parity setting:
* UART_CFG_PARITY_NONE, * UART_CFG_PARITY_NONE,
@ -361,7 +361,7 @@ int modbus_iface_get_by_name(const char *iface_name);
* *
* @retval 0 If the function was successful * @retval 0 If the function was successful
*/ */
int modbus_init_server(const uint8_t iface, const uint8_t node_addr, int modbus_init_server(const uint8_t iface, const uint8_t unit_id,
const uint32_t baud, enum uart_config_parity parity, const uint32_t baud, enum uart_config_parity parity,
struct modbus_user_callbacks *const cb, struct modbus_user_callbacks *const cb,
bool ascii_mode); bool ascii_mode);

224
subsys/modbus/modbus_client.c
View file

@ -26,16 +26,16 @@
#include <logging/log.h> #include <logging/log.h>
LOG_MODULE_REGISTER(modbus_c, CONFIG_MODBUS_LOG_LEVEL); LOG_MODULE_REGISTER(modbus_c, CONFIG_MODBUS_LOG_LEVEL);
static int mbm_validate_response_fc(struct modbus_context *ctx, static int mbc_validate_response_fc(struct modbus_context *ctx,
const uint8_t node_addr, const uint8_t unit_id,
uint8_t fc) uint8_t fc)
{ {
uint8_t resp_fc = ctx->rx_frame.fc; uint8_t resp_fc = ctx->rx_adu.fc;
uint8_t excep_code = ctx->rx_frame.data[0]; uint8_t excep_code = ctx->rx_adu.data[0];
const uint8_t excep_bit = BIT(7); const uint8_t excep_bit = BIT(7);
const uint8_t excep_mask = BIT_MASK(7); const uint8_t excep_mask = BIT_MASK(7);
if (node_addr != ctx->rx_frame.addr) { if (unit_id != ctx->rx_adu.unit_id) {
return -EIO; return -EIO;
} }
@ -54,17 +54,16 @@ static int mbm_validate_response_fc(struct modbus_context *ctx,
return 0; return 0;
} }
#ifdef CONFIG_MODBUS_FP_EXTENSIONS static int mbc_validate_fc03fp_response(struct modbus_context *ctx, float *ptbl)
static int mbm_validate_fc03fp_response(struct modbus_context *ctx, float *ptbl)
{ {
uint8_t resp_byte_cnt; uint8_t resp_byte_cnt;
uint8_t req_byte_cnt; uint8_t req_byte_cnt;
uint16_t req_qty; uint16_t req_qty;
uint8_t *resp_data; uint8_t *resp_data;
resp_byte_cnt = ctx->rx_frame.data[0]; resp_byte_cnt = ctx->rx_adu.data[0];
resp_data = &ctx->rx_frame.data[1]; resp_data = &ctx->rx_adu.data[1];
req_qty = sys_get_be16(&ctx->tx_frame.data[2]); req_qty = sys_get_be16(&ctx->tx_adu.data[2]);
req_byte_cnt = req_qty * sizeof(float); req_byte_cnt = req_qty * sizeof(float);
if (req_byte_cnt != resp_byte_cnt) { if (req_byte_cnt != resp_byte_cnt) {
@ -81,10 +80,9 @@ static int mbm_validate_fc03fp_response(struct modbus_context *ctx, float *ptbl)
return 0; return 0;
} }
#endif
static int mbm_validate_rd_response(struct modbus_context *ctx, static int mbc_validate_rd_response(struct modbus_context *ctx,
const uint8_t node_addr, const uint8_t unit_id,
uint8_t fc, uint8_t fc,
uint8_t *data) uint8_t *data)
{ {
@ -100,10 +98,10 @@ static int mbm_validate_rd_response(struct modbus_context *ctx,
return -EINVAL; return -EINVAL;
} }
resp_byte_cnt = ctx->rx_frame.data[0]; resp_byte_cnt = ctx->rx_adu.data[0];
resp_data = &ctx->rx_frame.data[1]; resp_data = &ctx->rx_adu.data[1];
req_qty = sys_get_be16(&ctx->tx_frame.data[2]); req_qty = sys_get_be16(&ctx->tx_adu.data[2]);
req_addr = sys_get_be16(&ctx->tx_frame.data[0]); req_addr = sys_get_be16(&ctx->tx_adu.data[0]);
switch (fc) { switch (fc) {
case MODBUS_FC01_COIL_RD: case MODBUS_FC01_COIL_RD:
@ -124,10 +122,10 @@ static int mbm_validate_rd_response(struct modbus_context *ctx,
case MODBUS_FC03_HOLDING_REG_RD: case MODBUS_FC03_HOLDING_REG_RD:
if (IS_ENABLED(CONFIG_MODBUS_FP_EXTENSIONS) && if (IS_ENABLED(CONFIG_MODBUS_FP_EXTENSIONS) &&
(req_addr >= MODBUS_FP_EXTENSIONS_ADDR)) { (req_addr >= MODBUS_FP_EXTENSIONS_ADDR)) {
err = mbm_validate_fc03fp_response(ctx, (float *)data); err = mbc_validate_fc03fp_response(ctx, (float *)data);
break; break;
} }
/* fallthrough */ __fallthrough;
case MODBUS_FC04_IN_REG_RD: case MODBUS_FC04_IN_REG_RD:
req_byte_cnt = req_qty * sizeof(uint16_t); req_byte_cnt = req_qty * sizeof(uint16_t);
if (req_byte_cnt != resp_byte_cnt) { if (req_byte_cnt != resp_byte_cnt) {
@ -151,8 +149,8 @@ static int mbm_validate_rd_response(struct modbus_context *ctx,
return err; return err;
} }
static int mbm_validate_fc08_response(struct modbus_context *ctx, static int mbc_validate_fc08_response(struct modbus_context *ctx,
const uint8_t node_addr, const uint8_t unit_id,
uint16_t *data) uint16_t *data)
{ {
int err; int err;
@ -165,10 +163,10 @@ static int mbm_validate_fc08_response(struct modbus_context *ctx,
return -EINVAL; return -EINVAL;
} }
req_sfunc = sys_get_be16(&ctx->tx_frame.data[0]); req_sfunc = sys_get_be16(&ctx->tx_adu.data[0]);
req_data = sys_get_be16(&ctx->tx_frame.data[2]); req_data = sys_get_be16(&ctx->tx_adu.data[2]);
resp_sfunc = sys_get_be16(&ctx->rx_frame.data[0]); resp_sfunc = sys_get_be16(&ctx->rx_adu.data[0]);
resp_data = sys_get_be16(&ctx->rx_frame.data[2]); resp_data = sys_get_be16(&ctx->rx_adu.data[2]);
if (req_sfunc != resp_sfunc) { if (req_sfunc != resp_sfunc) {
LOG_ERR("Mismatch in the sub-function code"); LOG_ERR("Mismatch in the sub-function code");
@ -203,8 +201,8 @@ static int mbm_validate_fc08_response(struct modbus_context *ctx,
return err; return err;
} }
static int mbm_validate_wr_response(struct modbus_context *ctx, static int mbc_validate_wr_response(struct modbus_context *ctx,
const uint8_t node_addr, const uint8_t unit_id,
uint8_t fc) uint8_t fc)
{ {
int err; int err;
@ -213,10 +211,10 @@ static int mbm_validate_wr_response(struct modbus_context *ctx,
uint16_t resp_addr; uint16_t resp_addr;
uint16_t resp_value; uint16_t resp_value;
req_addr = sys_get_be16(&ctx->tx_frame.data[0]); req_addr = sys_get_be16(&ctx->tx_adu.data[0]);
req_value = sys_get_be16(&ctx->tx_frame.data[2]); req_value = sys_get_be16(&ctx->tx_adu.data[2]);
resp_addr = sys_get_be16(&ctx->rx_frame.data[0]); resp_addr = sys_get_be16(&ctx->rx_adu.data[0]);
resp_value = sys_get_be16(&ctx->rx_frame.data[2]); resp_value = sys_get_be16(&ctx->rx_adu.data[2]);
switch (fc) { switch (fc) {
case MODBUS_FC05_COIL_WR: case MODBUS_FC05_COIL_WR:
@ -238,15 +236,15 @@ static int mbm_validate_wr_response(struct modbus_context *ctx,
return err; return err;
} }
static int mbm_send_cmd(struct modbus_context *ctx, const uint8_t node_addr, static int mbc_send_cmd(struct modbus_context *ctx, const uint8_t unit_id,
uint8_t fc, void *data) uint8_t fc, void *data)
{ {
int err; int err;
ctx->tx_frame.addr = node_addr; ctx->tx_adu.unit_id = unit_id;
ctx->tx_frame.fc = fc; ctx->tx_adu.fc = fc;
mb_tx_frame(ctx); modbus_tx_adu(ctx);
if (k_sem_take(&ctx->client_wait_sem, K_USEC(ctx->rxwait_to)) != 0) { if (k_sem_take(&ctx->client_wait_sem, K_USEC(ctx->rxwait_to)) != 0) {
LOG_WRN("Client wait-for-RX timeout"); LOG_WRN("Client wait-for-RX timeout");
@ -254,12 +252,12 @@ static int mbm_send_cmd(struct modbus_context *ctx, const uint8_t node_addr,
goto exit_error; goto exit_error;
} }
if (ctx->rx_frame_err != 0) { if (ctx->rx_adu_err != 0) {
err = ctx->rx_frame_err; err = ctx->rx_adu_err;
goto exit_error; goto exit_error;
} }
err = mbm_validate_response_fc(ctx, node_addr, fc); err = mbc_validate_response_fc(ctx, unit_id, fc);
if (err < 0) { if (err < 0) {
LOG_ERR("Failed to validate address or function code"); LOG_ERR("Failed to validate address or function code");
goto exit_error; goto exit_error;
@ -273,18 +271,18 @@ static int mbm_send_cmd(struct modbus_context *ctx, const uint8_t node_addr,
case MODBUS_FC02_DI_RD: case MODBUS_FC02_DI_RD:
case MODBUS_FC03_HOLDING_REG_RD: case MODBUS_FC03_HOLDING_REG_RD:
case MODBUS_FC04_IN_REG_RD: case MODBUS_FC04_IN_REG_RD:
err = mbm_validate_rd_response(ctx, node_addr, fc, data); err = mbc_validate_rd_response(ctx, unit_id, fc, data);
break; break;
case MODBUS_FC08_DIAGNOSTICS: case MODBUS_FC08_DIAGNOSTICS:
err = mbm_validate_fc08_response(ctx, node_addr, data); err = mbc_validate_fc08_response(ctx, unit_id, data);
break; break;
case MODBUS_FC05_COIL_WR: case MODBUS_FC05_COIL_WR:
case MODBUS_FC06_HOLDING_REG_WR: case MODBUS_FC06_HOLDING_REG_WR:
case MODBUS_FC15_COILS_WR: case MODBUS_FC15_COILS_WR:
case MODBUS_FC16_HOLDING_REGS_WR: case MODBUS_FC16_HOLDING_REGS_WR:
err = mbm_validate_wr_response(ctx, node_addr, fc); err = mbc_validate_wr_response(ctx, unit_id, fc);
break; break;
default: default:
@ -297,12 +295,12 @@ exit_error:
} }
int modbus_read_coils(const int iface, int modbus_read_coils(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
uint8_t *const coil_tbl, uint8_t *const coil_tbl,
const uint16_t num_coils) const uint16_t num_coils)
{ {
struct modbus_context *ctx = mb_get_context(iface); struct modbus_context *ctx = modbus_get_context(iface);
int err; int err;
if (ctx == NULL) { if (ctx == NULL) {
@ -311,23 +309,23 @@ int modbus_read_coils(const int iface,
k_mutex_lock(&ctx->iface_lock, K_FOREVER); k_mutex_lock(&ctx->iface_lock, K_FOREVER);
ctx->tx_frame.length = 4; ctx->tx_adu.length = 4;
sys_put_be16(start_addr, &ctx->tx_frame.data[0]); sys_put_be16(start_addr, &ctx->tx_adu.data[0]);
sys_put_be16(num_coils, &ctx->tx_frame.data[2]); sys_put_be16(num_coils, &ctx->tx_adu.data[2]);
err = mbm_send_cmd(ctx, node_addr, MODBUS_FC01_COIL_RD, coil_tbl); err = mbc_send_cmd(ctx, unit_id, MODBUS_FC01_COIL_RD, coil_tbl);
k_mutex_unlock(&ctx->iface_lock); k_mutex_unlock(&ctx->iface_lock);
return err; return err;
} }
int modbus_read_dinputs(const int iface, int modbus_read_dinputs(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
uint8_t *const di_tbl, uint8_t *const di_tbl,
const uint16_t num_di) const uint16_t num_di)
{ {
struct modbus_context *ctx = mb_get_context(iface); struct modbus_context *ctx = modbus_get_context(iface);
int err; int err;
if (ctx == NULL) { if (ctx == NULL) {
@ -336,23 +334,23 @@ int modbus_read_dinputs(const int iface,
k_mutex_lock(&ctx->iface_lock, K_FOREVER); k_mutex_lock(&ctx->iface_lock, K_FOREVER);
ctx->tx_frame.length = 4; ctx->tx_adu.length = 4;
sys_put_be16(start_addr, &ctx->tx_frame.data[0]); sys_put_be16(start_addr, &ctx->tx_adu.data[0]);
sys_put_be16(num_di, &ctx->tx_frame.data[2]); sys_put_be16(num_di, &ctx->tx_adu.data[2]);
err = mbm_send_cmd(ctx, node_addr, MODBUS_FC02_DI_RD, di_tbl); err = mbc_send_cmd(ctx, unit_id, MODBUS_FC02_DI_RD, di_tbl);
k_mutex_unlock(&ctx->iface_lock); k_mutex_unlock(&ctx->iface_lock);
return err; return err;
} }
int modbus_read_holding_regs(const int iface, int modbus_read_holding_regs(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
uint16_t *const reg_buf, uint16_t *const reg_buf,
const uint16_t num_regs) const uint16_t num_regs)
{ {
struct modbus_context *ctx = mb_get_context(iface); struct modbus_context *ctx = modbus_get_context(iface);
int err; int err;
if (ctx == NULL) { if (ctx == NULL) {
@ -361,11 +359,11 @@ int modbus_read_holding_regs(const int iface,
k_mutex_lock(&ctx->iface_lock, K_FOREVER); k_mutex_lock(&ctx->iface_lock, K_FOREVER);
ctx->tx_frame.length = 4; ctx->tx_adu.length = 4;
sys_put_be16(start_addr, &ctx->tx_frame.data[0]); sys_put_be16(start_addr, &ctx->tx_adu.data[0]);
sys_put_be16(num_regs, &ctx->tx_frame.data[2]); sys_put_be16(num_regs, &ctx->tx_adu.data[2]);
err = mbm_send_cmd(ctx, node_addr, MODBUS_FC03_HOLDING_REG_RD, reg_buf); err = mbc_send_cmd(ctx, unit_id, MODBUS_FC03_HOLDING_REG_RD, reg_buf);
k_mutex_unlock(&ctx->iface_lock); k_mutex_unlock(&ctx->iface_lock);
return err; return err;
@ -374,12 +372,12 @@ int modbus_read_holding_regs(const int iface,
#ifdef CONFIG_MODBUS_FP_EXTENSIONS #ifdef CONFIG_MODBUS_FP_EXTENSIONS
int modbus_read_holding_regs_fp(const int iface, int modbus_read_holding_regs_fp(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
float *const reg_buf, float *const reg_buf,
const uint16_t num_regs) const uint16_t num_regs)
{ {
struct modbus_context *ctx = mb_get_context(iface); struct modbus_context *ctx = modbus_get_context(iface);
int err; int err;
if (ctx == NULL) { if (ctx == NULL) {
@ -388,11 +386,11 @@ int modbus_read_holding_regs_fp(const int iface,
k_mutex_lock(&ctx->iface_lock, K_FOREVER); k_mutex_lock(&ctx->iface_lock, K_FOREVER);
ctx->tx_frame.length = 4; ctx->tx_adu.length = 4;
sys_put_be16(start_addr, &ctx->tx_frame.data[0]); sys_put_be16(start_addr, &ctx->tx_adu.data[0]);
sys_put_be16(num_regs, &ctx->tx_frame.data[2]); sys_put_be16(num_regs, &ctx->tx_adu.data[2]);
err = mbm_send_cmd(ctx, node_addr, MODBUS_FC03_HOLDING_REG_RD, reg_buf); err = mbc_send_cmd(ctx, unit_id, MODBUS_FC03_HOLDING_REG_RD, reg_buf);
k_mutex_unlock(&ctx->iface_lock); k_mutex_unlock(&ctx->iface_lock);
return err; return err;
@ -400,12 +398,12 @@ int modbus_read_holding_regs_fp(const int iface,
#endif #endif
int modbus_read_input_regs(const int iface, int modbus_read_input_regs(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
uint16_t *const reg_buf, uint16_t *const reg_buf,
const uint16_t num_regs) const uint16_t num_regs)
{ {
struct modbus_context *ctx = mb_get_context(iface); struct modbus_context *ctx = modbus_get_context(iface);
int err; int err;
if (ctx == NULL) { if (ctx == NULL) {
@ -414,22 +412,22 @@ int modbus_read_input_regs(const int iface,
k_mutex_lock(&ctx->iface_lock, K_FOREVER); k_mutex_lock(&ctx->iface_lock, K_FOREVER);
ctx->tx_frame.length = 4; ctx->tx_adu.length = 4;
sys_put_be16(start_addr, &ctx->tx_frame.data[0]); sys_put_be16(start_addr, &ctx->tx_adu.data[0]);
sys_put_be16(num_regs, &ctx->tx_frame.data[2]); sys_put_be16(num_regs, &ctx->tx_adu.data[2]);
err = mbm_send_cmd(ctx, node_addr, 4, reg_buf); err = mbc_send_cmd(ctx, unit_id, 4, reg_buf);
k_mutex_unlock(&ctx->iface_lock); k_mutex_unlock(&ctx->iface_lock);
return err; return err;
} }
int modbus_write_coil(const int iface, int modbus_write_coil(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t coil_addr, const uint16_t coil_addr,
const bool coil_state) const bool coil_state)
{ {
struct modbus_context *ctx = mb_get_context(iface); struct modbus_context *ctx = modbus_get_context(iface);
int err; int err;
uint16_t coil_val; uint16_t coil_val;
@ -445,22 +443,22 @@ int modbus_write_coil(const int iface,
coil_val = MODBUS_COIL_ON_CODE; coil_val = MODBUS_COIL_ON_CODE;
} }
ctx->tx_frame.length = 4; ctx->tx_adu.length = 4;
sys_put_be16(coil_addr, &ctx->tx_frame.data[0]); sys_put_be16(coil_addr, &ctx->tx_adu.data[0]);
sys_put_be16(coil_val, &ctx->tx_frame.data[2]); sys_put_be16(coil_val, &ctx->tx_adu.data[2]);
err = mbm_send_cmd(ctx, node_addr, MODBUS_FC05_COIL_WR, NULL); err = mbc_send_cmd(ctx, unit_id, MODBUS_FC05_COIL_WR, NULL);
k_mutex_unlock(&ctx->iface_lock); k_mutex_unlock(&ctx->iface_lock);
return err; return err;
} }
int modbus_write_holding_reg(const int iface, int modbus_write_holding_reg(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
const uint16_t reg_val) const uint16_t reg_val)
{ {
struct modbus_context *ctx = mb_get_context(iface); struct modbus_context *ctx = modbus_get_context(iface);
int err; int err;
if (ctx == NULL) { if (ctx == NULL) {
@ -469,23 +467,23 @@ int modbus_write_holding_reg(const int iface,
k_mutex_lock(&ctx->iface_lock, K_FOREVER); k_mutex_lock(&ctx->iface_lock, K_FOREVER);
ctx->tx_frame.length = 4; ctx->tx_adu.length = 4;
sys_put_be16(start_addr, &ctx->tx_frame.data[0]); sys_put_be16(start_addr, &ctx->tx_adu.data[0]);
sys_put_be16(reg_val, &ctx->tx_frame.data[2]); sys_put_be16(reg_val, &ctx->tx_adu.data[2]);
err = mbm_send_cmd(ctx, node_addr, MODBUS_FC06_HOLDING_REG_WR, NULL); err = mbc_send_cmd(ctx, unit_id, MODBUS_FC06_HOLDING_REG_WR, NULL);
k_mutex_unlock(&ctx->iface_lock); k_mutex_unlock(&ctx->iface_lock);
return err; return err;
} }
int modbus_request_diagnostic(const int iface, int modbus_request_diagnostic(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t sfunc, const uint16_t sfunc,
const uint16_t data, const uint16_t data,
uint16_t *const data_out) uint16_t *const data_out)
{ {
struct modbus_context *ctx = mb_get_context(iface); struct modbus_context *ctx = modbus_get_context(iface);
int err; int err;
if (ctx == NULL) { if (ctx == NULL) {
@ -494,23 +492,23 @@ int modbus_request_diagnostic(const int iface,
k_mutex_lock(&ctx->iface_lock, K_FOREVER); k_mutex_lock(&ctx->iface_lock, K_FOREVER);
ctx->tx_frame.length = 4; ctx->tx_adu.length = 4;
sys_put_be16(sfunc, &ctx->tx_frame.data[0]); sys_put_be16(sfunc, &ctx->tx_adu.data[0]);
sys_put_be16(data, &ctx->tx_frame.data[2]); sys_put_be16(data, &ctx->tx_adu.data[2]);
err = mbm_send_cmd(ctx, node_addr, MODBUS_FC08_DIAGNOSTICS, data_out); err = mbc_send_cmd(ctx, unit_id, MODBUS_FC08_DIAGNOSTICS, data_out);
k_mutex_unlock(&ctx->iface_lock); k_mutex_unlock(&ctx->iface_lock);
return err; return err;
} }
int modbus_write_coils(const int iface, int modbus_write_coils(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
uint8_t *const coil_tbl, uint8_t *const coil_tbl,
const uint16_t num_coils) const uint16_t num_coils)
{ {
struct modbus_context *ctx = mb_get_context(iface); struct modbus_context *ctx = modbus_get_context(iface);
uint8_t num_bytes; uint8_t num_bytes;
int err; int err;
uint8_t *data_ptr; uint8_t *data_ptr;
@ -521,29 +519,29 @@ int modbus_write_coils(const int iface,
k_mutex_lock(&ctx->iface_lock, K_FOREVER); k_mutex_lock(&ctx->iface_lock, K_FOREVER);
sys_put_be16(start_addr, &ctx->tx_frame.data[0]); sys_put_be16(start_addr, &ctx->tx_adu.data[0]);
sys_put_be16(num_coils, &ctx->tx_frame.data[2]); sys_put_be16(num_coils, &ctx->tx_adu.data[2]);
num_bytes = (uint8_t)(((num_coils - 1) / 8) + 1); num_bytes = (uint8_t)(((num_coils - 1) / 8) + 1);
ctx->tx_frame.data[4] = num_bytes; ctx->tx_adu.data[4] = num_bytes;
data_ptr = &ctx->tx_frame.data[5]; data_ptr = &ctx->tx_adu.data[5];
ctx->tx_frame.length = 5 + num_bytes; ctx->tx_adu.length = 5 + num_bytes;
memcpy(data_ptr, coil_tbl, num_bytes); memcpy(data_ptr, coil_tbl, num_bytes);
err = mbm_send_cmd(ctx, node_addr, MODBUS_FC15_COILS_WR, NULL); err = mbc_send_cmd(ctx, unit_id, MODBUS_FC15_COILS_WR, NULL);
k_mutex_unlock(&ctx->iface_lock); k_mutex_unlock(&ctx->iface_lock);
return err; return err;
} }
int modbus_write_holding_regs(const int iface, int modbus_write_holding_regs(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
uint16_t *const reg_buf, uint16_t *const reg_buf,
const uint16_t num_regs) const uint16_t num_regs)
{ {
struct modbus_context *ctx = mb_get_context(iface); struct modbus_context *ctx = modbus_get_context(iface);
uint8_t num_bytes; uint8_t num_bytes;
int err; int err;
uint8_t *data_ptr; uint8_t *data_ptr;
@ -554,20 +552,20 @@ int modbus_write_holding_regs(const int iface,
k_mutex_lock(&ctx->iface_lock, K_FOREVER); k_mutex_lock(&ctx->iface_lock, K_FOREVER);
sys_put_be16(start_addr, &ctx->tx_frame.data[0]); sys_put_be16(start_addr, &ctx->tx_adu.data[0]);
sys_put_be16(num_regs, &ctx->tx_frame.data[2]); sys_put_be16(num_regs, &ctx->tx_adu.data[2]);
num_bytes = (uint8_t) (num_regs * sizeof(uint16_t)); num_bytes = (uint8_t) (num_regs * sizeof(uint16_t));
ctx->tx_frame.length = num_bytes + 5; ctx->tx_adu.length = num_bytes + 5;
ctx->tx_frame.data[4] = num_bytes; ctx->tx_adu.data[4] = num_bytes;
data_ptr = &ctx->tx_frame.data[5]; data_ptr = &ctx->tx_adu.data[5];
for (uint16_t i = 0; i < num_regs; i++) { for (uint16_t i = 0; i < num_regs; i++) {
sys_put_be16(reg_buf[i], data_ptr); sys_put_be16(reg_buf[i], data_ptr);
data_ptr += sizeof(uint16_t); data_ptr += sizeof(uint16_t);
} }
err = mbm_send_cmd(ctx, node_addr, MODBUS_FC16_HOLDING_REGS_WR, NULL); err = mbc_send_cmd(ctx, unit_id, MODBUS_FC16_HOLDING_REGS_WR, NULL);
k_mutex_unlock(&ctx->iface_lock); k_mutex_unlock(&ctx->iface_lock);
return err; return err;
@ -575,12 +573,12 @@ int modbus_write_holding_regs(const int iface,
#ifdef CONFIG_MODBUS_FP_EXTENSIONS #ifdef CONFIG_MODBUS_FP_EXTENSIONS
int modbus_write_holding_regs_fp(const int iface, int modbus_write_holding_regs_fp(const int iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint16_t start_addr, const uint16_t start_addr,
float *const reg_buf, float *const reg_buf,
const uint16_t num_regs) const uint16_t num_regs)
{ {
struct modbus_context *ctx = mb_get_context(iface); struct modbus_context *ctx = modbus_get_context(iface);
uint8_t num_bytes; uint8_t num_bytes;
int err; int err;
uint8_t *data_ptr; uint8_t *data_ptr;
@ -591,13 +589,13 @@ int modbus_write_holding_regs_fp(const int iface,
k_mutex_lock(&ctx->iface_lock, K_FOREVER); k_mutex_lock(&ctx->iface_lock, K_FOREVER);
sys_put_be16(start_addr, &ctx->tx_frame.data[0]); sys_put_be16(start_addr, &ctx->tx_adu.data[0]);
sys_put_be16(num_regs, &ctx->tx_frame.data[2]); sys_put_be16(num_regs, &ctx->tx_adu.data[2]);
num_bytes = (uint8_t) (num_regs * sizeof(float)); num_bytes = (uint8_t) (num_regs * sizeof(float));
ctx->tx_frame.length = num_bytes + 5; ctx->tx_adu.length = num_bytes + 5;
ctx->tx_frame.data[4] = num_bytes; ctx->tx_adu.data[4] = num_bytes;
data_ptr = &ctx->tx_frame.data[5]; data_ptr = &ctx->tx_adu.data[5];
for (uint16_t i = 0; i < num_regs; i++) { for (uint16_t i = 0; i < num_regs; i++) {
uint32_t reg_val; uint32_t reg_val;
@ -607,7 +605,7 @@ int modbus_write_holding_regs_fp(const int iface,
data_ptr += sizeof(uint32_t); data_ptr += sizeof(uint32_t);
} }
err = mbm_send_cmd(ctx, node_addr, MODBUS_FC16_HOLDING_REGS_WR, NULL); err = mbc_send_cmd(ctx, unit_id, MODBUS_FC16_HOLDING_REGS_WR, NULL);
k_mutex_unlock(&ctx->iface_lock); k_mutex_unlock(&ctx->iface_lock);
return err; return err;

22
subsys/modbus/modbus_core.c
View file

@ -70,7 +70,7 @@ static void modbus_rx_handler(struct k_work *item)
case MODBUS_MODE_ASCII: case MODBUS_MODE_ASCII:
if (IS_ENABLED(CONFIG_MODBUS_SERIAL)) { if (IS_ENABLED(CONFIG_MODBUS_SERIAL)) {
modbus_serial_rx_disable(ctx); modbus_serial_rx_disable(ctx);
ctx->rx_frame_err = modbus_serial_rx_frame(ctx); ctx->rx_adu_err = modbus_serial_rx_adu(ctx);
} }
break; break;
default: default:
@ -84,7 +84,7 @@ static void modbus_rx_handler(struct k_work *item)
} }
if (IS_ENABLED(CONFIG_MODBUS_SERVER)) { if (IS_ENABLED(CONFIG_MODBUS_SERVER)) {
bool respond = mbs_rx_handler(ctx); bool respond = modbus_server_handler(ctx);
switch (ctx->mode) { switch (ctx->mode) {
case MODBUS_MODE_RTU: case MODBUS_MODE_RTU:
@ -101,13 +101,13 @@ static void modbus_rx_handler(struct k_work *item)
} }
} }
void mb_tx_frame(struct modbus_context *ctx) void modbus_tx_adu(struct modbus_context *ctx)
{ {
switch (ctx->mode) { switch (ctx->mode) {
case MODBUS_MODE_RTU: case MODBUS_MODE_RTU:
case MODBUS_MODE_ASCII: case MODBUS_MODE_ASCII:
if (IS_ENABLED(CONFIG_MODBUS_SERIAL) && if (IS_ENABLED(CONFIG_MODBUS_SERIAL) &&
modbus_serial_tx_frame(ctx)) { modbus_serial_tx_adu(ctx)) {
LOG_ERR("Unsupported MODBUS serial mode"); LOG_ERR("Unsupported MODBUS serial mode");
} }
break; break;
@ -116,7 +116,7 @@ void mb_tx_frame(struct modbus_context *ctx)
} }
} }
struct modbus_context *mb_get_context(const uint8_t iface) struct modbus_context *modbus_get_context(const uint8_t iface)
{ {
struct modbus_context *ctx; struct modbus_context *ctx;
@ -136,7 +136,7 @@ struct modbus_context *mb_get_context(const uint8_t iface)
} }
static struct modbus_context *mb_cfg_iface(const uint8_t iface, static struct modbus_context *mb_cfg_iface(const uint8_t iface,
const uint8_t node_addr, const uint8_t unit_id,
const uint32_t baud, const uint32_t baud,
const enum uart_config_parity parity, const enum uart_config_parity parity,
const uint32_t rx_timeout, const uint32_t rx_timeout,
@ -165,7 +165,7 @@ static struct modbus_context *mb_cfg_iface(const uint8_t iface,
} }
ctx->rxwait_to = rx_timeout; ctx->rxwait_to = rx_timeout;
ctx->node_addr = node_addr; ctx->unit_id = unit_id;
ctx->client = client; ctx->client = client;
ctx->mbs_user_cb = NULL; ctx->mbs_user_cb = NULL;
k_mutex_init(&ctx->iface_lock); k_mutex_init(&ctx->iface_lock);
@ -174,7 +174,7 @@ static struct modbus_context *mb_cfg_iface(const uint8_t iface,
k_work_init(&ctx->server_work, modbus_rx_handler); k_work_init(&ctx->server_work, modbus_rx_handler);
if (IS_ENABLED(CONFIG_MODBUS_FC08_DIAGNOSTIC)) { if (IS_ENABLED(CONFIG_MODBUS_FC08_DIAGNOSTIC)) {
mbs_reset_statistics(ctx); modbus_reset_stats(ctx);
} }
switch (ctx->mode) { switch (ctx->mode) {
@ -196,7 +196,7 @@ static struct modbus_context *mb_cfg_iface(const uint8_t iface,
return ctx; return ctx;
} }
int modbus_init_server(const uint8_t iface, const uint8_t node_addr, int modbus_init_server(const uint8_t iface, const uint8_t unit_id,
const uint32_t baud, const enum uart_config_parity parity, const uint32_t baud, const enum uart_config_parity parity,
struct modbus_user_callbacks *const cb, struct modbus_user_callbacks *const cb,
const bool ascii_mode) const bool ascii_mode)
@ -213,7 +213,7 @@ int modbus_init_server(const uint8_t iface, const uint8_t node_addr,
return -EINVAL; return -EINVAL;
} }
ctx = mb_cfg_iface(iface, node_addr, baud, ctx = mb_cfg_iface(iface, unit_id, baud,
parity, 0, false, ascii_mode); parity, 0, false, ascii_mode);
if (ctx == NULL) { if (ctx == NULL) {
@ -281,7 +281,7 @@ int modbus_disable(const uint8_t iface)
} }
ctx->rxwait_to = 0; ctx->rxwait_to = 0;
ctx->node_addr = 0; ctx->unit_id = 0;
ctx->mode = MODBUS_MODE_RTU; ctx->mode = MODBUS_MODE_RTU;
ctx->mbs_user_cb = NULL; ctx->mbs_user_cb = NULL;
atomic_clear_bit(&ctx->state, MODBUS_STATE_CONFIGURED); atomic_clear_bit(&ctx->state, MODBUS_STATE_CONFIGURED);

26
subsys/modbus/modbus_internal.h
View file

@ -72,9 +72,9 @@
#define MODBUS_ASCII_END_FRAME_CHAR1 '\r' #define MODBUS_ASCII_END_FRAME_CHAR1 '\r'
#define MODBUS_ASCII_END_FRAME_CHAR2 '\n' #define MODBUS_ASCII_END_FRAME_CHAR2 '\n'
struct mb_rtu_frame { struct modbus_adu {
uint16_t length; uint16_t length;
uint8_t addr; uint8_t unit_id;
uint8_t fc; uint8_t fc;
uint8_t data[CONFIG_MODBUS_BUFFER_SIZE - 4]; uint8_t data[CONFIG_MODBUS_BUFFER_SIZE - 4];
uint16_t crc; uint16_t crc;
@ -138,12 +138,12 @@ struct modbus_context {
/* Server work item */ /* Server work item */
struct k_work server_work; struct k_work server_work;
/* Received frame */ /* Received frame */
struct mb_rtu_frame rx_frame; struct modbus_adu rx_adu;
/* Frame to transmit */ /* Frame to transmit */
struct mb_rtu_frame tx_frame; struct modbus_adu tx_adu;
/* Records error from frame reception, e.g. CRC error */ /* Records error from frame reception, e.g. CRC error */
int rx_frame_err; int rx_adu_err;
#ifdef CONFIG_MODBUS_FC08_DIAGNOSTIC #ifdef CONFIG_MODBUS_FC08_DIAGNOSTIC
uint16_t mbs_msg_ctr; uint16_t mbs_msg_ctr;
@ -152,21 +152,21 @@ struct modbus_context {
uint16_t mbs_server_msg_ctr; uint16_t mbs_server_msg_ctr;
uint16_t mbs_noresp_ctr; uint16_t mbs_noresp_ctr;
#endif #endif
/* Node address */ /* Unit ID */
uint8_t node_addr; uint8_t unit_id;
}; };
struct modbus_context *mb_get_context(const uint8_t iface); struct modbus_context *modbus_get_context(const uint8_t iface);
void mb_tx_frame(struct modbus_context *ctx); void modbus_tx_adu(struct modbus_context *ctx);
bool mbs_rx_handler(struct modbus_context *ctx); bool modbus_server_handler(struct modbus_context *ctx);
void mbs_reset_statistics(struct modbus_context *pch); void modbus_reset_stats(struct modbus_context *ctx);
void modbus_serial_rx_disable(struct modbus_context *ctx); void modbus_serial_rx_disable(struct modbus_context *ctx);
void modbus_serial_rx_enable(struct modbus_context *ctx); void modbus_serial_rx_enable(struct modbus_context *ctx);
int modbus_serial_rx_frame(struct modbus_context *ctx); int modbus_serial_rx_adu(struct modbus_context *ctx);
int modbus_serial_tx_frame(struct modbus_context *ctx); int modbus_serial_tx_adu(struct modbus_context *ctx);
int modbus_serial_init(struct modbus_context *ctx, int modbus_serial_init(struct modbus_context *ctx,
uint32_t baudrate, uint32_t baudrate,
enum uart_config_parity parity, enum uart_config_parity parity,

74
subsys/modbus/modbus_serial.c
View file

@ -95,7 +95,7 @@ static uint8_t modbus_ascii_get_lrc(uint8_t *src, size_t length)
} }
/* Parses and converts an ASCII mode frame into a Modbus RTU frame. */ /* Parses and converts an ASCII mode frame into a Modbus RTU frame. */
static int modbus_ascii_rx_frame(struct modbus_context *ctx) static int modbus_ascii_rx_adu(struct modbus_context *ctx)
{ {
struct modbus_serial_config *cfg = ctx->cfg; struct modbus_serial_config *cfg = ctx->cfg;
uint8_t *pmsg; uint8_t *pmsg;
@ -105,7 +105,7 @@ static int modbus_ascii_rx_frame(struct modbus_context *ctx)
uint8_t calc_lrc; uint8_t calc_lrc;
rx_size = cfg->uart_buf_ctr; rx_size = cfg->uart_buf_ctr;
prx_data = &ctx->rx_frame.data[0]; prx_data = &ctx->rx_adu.data[0];
if (!(rx_size & 0x01)) { if (!(rx_size & 0x01)) {
LOG_WRN("Message should have an odd number of bytes"); LOG_WRN("Message should have an odd number of bytes");
@ -129,27 +129,27 @@ static int modbus_ascii_rx_frame(struct modbus_context *ctx)
/* Point past the ':' to the address. */ /* Point past the ':' to the address. */
pmsg = &cfg->uart_buf[1]; pmsg = &cfg->uart_buf[1];
hex2bin(pmsg, 2, &ctx->rx_frame.addr, 1); hex2bin(pmsg, 2, &ctx->rx_adu.unit_id, 1);
pmsg += 2; pmsg += 2;
rx_size -= 2; rx_size -= 2;
hex2bin(pmsg, 2, &ctx->rx_frame.fc, 1); hex2bin(pmsg, 2, &ctx->rx_adu.fc, 1);
pmsg += 2; pmsg += 2;
rx_size -= 2; rx_size -= 2;
/* Get the data from the message */ /* Get the data from the message */
ctx->rx_frame.length = 0; ctx->rx_adu.length = 0;
while (rx_size > 2) { while (rx_size > 2) {
hex2bin(pmsg, 2, prx_data, 1); hex2bin(pmsg, 2, prx_data, 1);
prx_data++; prx_data++;
pmsg += 2; pmsg += 2;
rx_size -= 2; rx_size -= 2;
/* Increment the number of Modbus packets received */ /* Increment the number of Modbus packets received */
ctx->rx_frame.length++; ctx->rx_adu.length++;
} }
/* Extract the message's LRC */ /* Extract the message's LRC */
hex2bin(pmsg, 2, &frame_lrc, 1); hex2bin(pmsg, 2, &frame_lrc, 1);
ctx->rx_frame.crc = frame_lrc; ctx->rx_adu.crc = frame_lrc;
/* /*
* The LRC is calculated on the ADDR, FC and Data fields, * The LRC is calculated on the ADDR, FC and Data fields,
@ -181,7 +181,7 @@ static uint8_t *modbus_ascii_bin2hex(uint8_t value, uint8_t *pbuf)
return pbuf; return pbuf;
} }
static void modbus_ascii_tx_frame(struct modbus_context *ctx) static void modbus_ascii_tx_adu(struct modbus_context *ctx)
{ {
struct modbus_serial_config *cfg = ctx->cfg; struct modbus_serial_config *cfg = ctx->cfg;
uint16_t tx_bytes = 0; uint16_t tx_bytes = 0;
@ -193,13 +193,13 @@ static void modbus_ascii_tx_frame(struct modbus_context *ctx)
tx_bytes = 1; tx_bytes = 1;
pbuf = &cfg->uart_buf[1]; pbuf = &cfg->uart_buf[1];
pbuf = modbus_ascii_bin2hex(ctx->tx_frame.addr, pbuf); pbuf = modbus_ascii_bin2hex(ctx->tx_adu.unit_id, pbuf);
tx_bytes += 2; tx_bytes += 2;
pbuf = modbus_ascii_bin2hex(ctx->tx_frame.fc, pbuf); pbuf = modbus_ascii_bin2hex(ctx->tx_adu.fc, pbuf);
tx_bytes += 2; tx_bytes += 2;
for (int i = 0; i < ctx->tx_frame.length; i++) { for (int i = 0; i < ctx->tx_adu.length; i++) {
pbuf = modbus_ascii_bin2hex(ctx->tx_frame.data[i], pbuf); pbuf = modbus_ascii_bin2hex(ctx->tx_adu.data[i], pbuf);
tx_bytes += 2; tx_bytes += 2;
} }
@ -228,12 +228,12 @@ static void modbus_ascii_tx_frame(struct modbus_context *ctx)
modbus_serial_tx_on(ctx); modbus_serial_tx_on(ctx);
} }
#else #else
static int modbus_ascii_rx_frame(struct modbus_context *ctx) static int modbus_ascii_rx_adu(struct modbus_context *ctx)
{ {
return 0; return 0;
} }
static void modbus_ascii_tx_frame(struct modbus_context *ctx) static void modbus_ascii_tx_adu(struct modbus_context *ctx)
{ {
} }
#endif #endif
@ -270,7 +270,7 @@ static uint16_t modbus_rtu_crc16(uint8_t *src, size_t length)
} }
/* Copy Modbus RTU frame and check if the CRC is valid. */ /* Copy Modbus RTU frame and check if the CRC is valid. */
static int modbus_rtu_rx_frame(struct modbus_context *ctx) static int modbus_rtu_rx_adu(struct modbus_context *ctx)
{ {
struct modbus_serial_config *cfg = ctx->cfg; struct modbus_serial_config *cfg = ctx->cfg;
uint16_t calc_crc; uint16_t calc_crc;
@ -284,22 +284,22 @@ static int modbus_rtu_rx_frame(struct modbus_context *ctx)
return -EMSGSIZE; return -EMSGSIZE;
} }
ctx->rx_frame.addr = cfg->uart_buf[0]; ctx->rx_adu.unit_id = cfg->uart_buf[0];
ctx->rx_frame.fc = cfg->uart_buf[1]; ctx->rx_adu.fc = cfg->uart_buf[1];
data_ptr = &cfg->uart_buf[2]; data_ptr = &cfg->uart_buf[2];
/* Payload length without node address, function code, and CRC */ /* Payload length without node address, function code, and CRC */
ctx->rx_frame.length = cfg->uart_buf_ctr - 4; ctx->rx_adu.length = cfg->uart_buf_ctr - 4;
/* CRC index */ /* CRC index */
crc_idx = cfg->uart_buf_ctr - sizeof(uint16_t); crc_idx = cfg->uart_buf_ctr - sizeof(uint16_t);
memcpy(ctx->rx_frame.data, data_ptr, ctx->rx_frame.length); memcpy(ctx->rx_adu.data, data_ptr, ctx->rx_adu.length);
ctx->rx_frame.crc = sys_get_le16(&cfg->uart_buf[crc_idx]); ctx->rx_adu.crc = sys_get_le16(&cfg->uart_buf[crc_idx]);
/* Calculate CRC over address, function code, and payload */ /* Calculate CRC over address, function code, and payload */
calc_crc = modbus_rtu_crc16(&cfg->uart_buf[0], calc_crc = modbus_rtu_crc16(&cfg->uart_buf[0],
cfg->uart_buf_ctr - sizeof(ctx->rx_frame.crc)); cfg->uart_buf_ctr - sizeof(ctx->rx_adu.crc));
if (ctx->rx_frame.crc != calc_crc) { if (ctx->rx_adu.crc != calc_crc) {
LOG_WRN("Calculated CRC does not match received CRC"); LOG_WRN("Calculated CRC does not match received CRC");
return -EIO; return -EIO;
} }
@ -307,23 +307,23 @@ static int modbus_rtu_rx_frame(struct modbus_context *ctx)
return 0; return 0;
} }
static void rtu_tx_frame(struct modbus_context *ctx) static void rtu_tx_adu(struct modbus_context *ctx)
{ {
struct modbus_serial_config *cfg = ctx->cfg; struct modbus_serial_config *cfg = ctx->cfg;
uint16_t tx_bytes = 0; uint16_t tx_bytes = 0;
uint8_t *data_ptr; uint8_t *data_ptr;
cfg->uart_buf[0] = ctx->tx_frame.addr; cfg->uart_buf[0] = ctx->tx_adu.unit_id;
cfg->uart_buf[1] = ctx->tx_frame.fc; cfg->uart_buf[1] = ctx->tx_adu.fc;
tx_bytes = 2 + ctx->tx_frame.length; tx_bytes = 2 + ctx->tx_adu.length;
data_ptr = &cfg->uart_buf[2]; data_ptr = &cfg->uart_buf[2];
memcpy(data_ptr, ctx->tx_frame.data, ctx->tx_frame.length); memcpy(data_ptr, ctx->tx_adu.data, ctx->tx_adu.length);
ctx->tx_frame.crc = modbus_rtu_crc16(&cfg->uart_buf[0], ctx->tx_adu.crc = modbus_rtu_crc16(&cfg->uart_buf[0],
ctx->tx_frame.length + 2); ctx->tx_adu.length + 2);
sys_put_le16(ctx->tx_frame.crc, sys_put_le16(ctx->tx_adu.crc,
&cfg->uart_buf[ctx->tx_frame.length + 2]); &cfg->uart_buf[ctx->tx_adu.length + 2]);
tx_bytes += 2; tx_bytes += 2;
cfg->uart_buf_ctr = tx_bytes; cfg->uart_buf_ctr = tx_bytes;
@ -480,21 +480,21 @@ void modbus_serial_rx_enable(struct modbus_context *ctx)
modbus_serial_rx_on(ctx); modbus_serial_rx_on(ctx);
} }
int modbus_serial_rx_frame(struct modbus_context *ctx) int modbus_serial_rx_adu(struct modbus_context *ctx)
{ {
struct modbus_serial_config *cfg = ctx->cfg; struct modbus_serial_config *cfg = ctx->cfg;
int rc = 0; int rc = 0;
switch (ctx->mode) { switch (ctx->mode) {
case MODBUS_MODE_RTU: case MODBUS_MODE_RTU:
rc = modbus_rtu_rx_frame(ctx); rc = modbus_rtu_rx_adu(ctx);
break; break;
case MODBUS_MODE_ASCII: case MODBUS_MODE_ASCII:
if (!IS_ENABLED(CONFIG_MODBUS_ASCII_MODE)) { if (!IS_ENABLED(CONFIG_MODBUS_ASCII_MODE)) {
return -ENOTSUP; return -ENOTSUP;
} }
rc = modbus_ascii_rx_frame(ctx); rc = modbus_ascii_rx_adu(ctx);
break; break;
default: default:
LOG_ERR("Unsupported MODBUS mode"); LOG_ERR("Unsupported MODBUS mode");
@ -507,15 +507,15 @@ int modbus_serial_rx_frame(struct modbus_context *ctx)
return rc; return rc;
} }
int modbus_serial_tx_frame(struct modbus_context *ctx) int modbus_serial_tx_adu(struct modbus_context *ctx)
{ {
switch (ctx->mode) { switch (ctx->mode) {
case MODBUS_MODE_RTU: case MODBUS_MODE_RTU:
rtu_tx_frame(ctx); rtu_tx_adu(ctx);
return 0; return 0;
case MODBUS_MODE_ASCII: case MODBUS_MODE_ASCII:
if (IS_ENABLED(CONFIG_MODBUS_ASCII_MODE)) { if (IS_ENABLED(CONFIG_MODBUS_ASCII_MODE)) {
modbus_ascii_tx_frame(ctx); modbus_ascii_tx_adu(ctx);
return 0; return 0;
} }
default: default:

166
subsys/modbus/modbus_server.c
View file

@ -31,7 +31,7 @@ LOG_MODULE_REGISTER(modbus_s, CONFIG_MODBUS_LOG_LEVEL);
* statistics and communications counters. * statistics and communications counters.
*/ */
#ifdef CONFIG_MODBUS_FC08_DIAGNOSTIC #ifdef CONFIG_MODBUS_FC08_DIAGNOSTIC
void mbs_reset_statistics(struct modbus_context *ctx) void modbus_reset_stats(struct modbus_context *ctx)
{ {
/* Initialize all MODBUS event counters. */ /* Initialize all MODBUS event counters. */
ctx->mbs_msg_ctr = 0; ctx->mbs_msg_ctr = 0;
@ -66,7 +66,7 @@ static void update_noresp_ctr(struct modbus_context *ctx)
ctx->mbs_noresp_ctr++; ctx->mbs_noresp_ctr++;
} }
#else #else
#define mbs_reset_statistics(...) #define modbus_reset_stats(...)
#define update_msg_ctr(...) #define update_msg_ctr(...)
#define update_crcerr_ctr(...) #define update_crcerr_ctr(...)
#define update_excep_ctr(...) #define update_excep_ctr(...)
@ -82,13 +82,13 @@ static void mbs_exception_rsp(struct modbus_context *ctx, uint8_t excep_code)
{ {
const uint8_t excep_bit = BIT(7); const uint8_t excep_bit = BIT(7);
LOG_INF("FC 0x%02x Error 0x%02x", ctx->rx_frame.fc, excep_code); LOG_INF("FC 0x%02x Error 0x%02x", ctx->rx_adu.fc, excep_code);
update_excep_ctr(ctx); update_excep_ctr(ctx);
ctx->tx_frame.fc |= excep_bit; ctx->tx_adu.fc |= excep_bit;
ctx->tx_frame.data[0] = excep_code; ctx->tx_adu.data[0] = excep_code;
ctx->tx_frame.length = 1; ctx->tx_adu.length = 1;
} }
/* /*
@ -117,7 +117,7 @@ static bool mbs_fc01_coil_read(struct modbus_context *ctx)
uint8_t bit_mask; uint8_t bit_mask;
uint16_t coil_cntr; uint16_t coil_cntr;
if (ctx->rx_frame.length != request_len) { if (ctx->rx_adu.length != request_len) {
LOG_ERR("Wrong request length"); LOG_ERR("Wrong request length");
return false; return false;
} }
@ -127,8 +127,8 @@ static bool mbs_fc01_coil_read(struct modbus_context *ctx)
return true; return true;
} }
coil_addr = sys_get_be16(&ctx->rx_frame.data[0]); coil_addr = sys_get_be16(&ctx->rx_adu.data[0]);
coil_qty = sys_get_be16(&ctx->rx_frame.data[2]); coil_qty = sys_get_be16(&ctx->rx_adu.data[2]);
/* Make sure we don't exceed the allowed limit per request */ /* Make sure we don't exceed the allowed limit per request */
if (coil_qty == 0 || coil_qty > coils_limit) { if (coil_qty == 0 || coil_qty > coils_limit) {
@ -140,16 +140,16 @@ static bool mbs_fc01_coil_read(struct modbus_context *ctx)
/* Calculate byte count for response. */ /* Calculate byte count for response. */
num_bytes = ((coil_qty - 1) / 8) + 1; num_bytes = ((coil_qty - 1) / 8) + 1;
/* Number of data bytes + byte count. */ /* Number of data bytes + byte count. */
ctx->tx_frame.length = num_bytes + 1; ctx->tx_adu.length = num_bytes + 1;
/* Set number of data bytes in response message. */ /* Set number of data bytes in response message. */
ctx->tx_frame.data[0] = (uint8_t)num_bytes; ctx->tx_adu.data[0] = (uint8_t)num_bytes;
/* Clear bytes in response */ /* Clear bytes in response */
presp = &ctx->tx_frame.data[1]; presp = &ctx->tx_adu.data[1];
memset(presp, 0, num_bytes); memset(presp, 0, num_bytes);
/* Reset the pointer to the start of the response payload */ /* Reset the pointer to the start of the response payload */
presp = &ctx->tx_frame.data[1]; presp = &ctx->tx_adu.data[1];
/* Start with bit 0 in response byte data mask. */ /* Start with bit 0 in response byte data mask. */
bit_mask = BIT(0); bit_mask = BIT(0);
/* Initialize loop counter. */ /* Initialize loop counter. */
@ -216,7 +216,7 @@ static bool mbs_fc02_di_read(struct modbus_context *ctx)
uint8_t bit_mask; uint8_t bit_mask;
uint16_t di_cntr; uint16_t di_cntr;
if (ctx->rx_frame.length != request_len) { if (ctx->rx_adu.length != request_len) {
LOG_ERR("Wrong request length"); LOG_ERR("Wrong request length");
return false; return false;
} }
@ -226,8 +226,8 @@ static bool mbs_fc02_di_read(struct modbus_context *ctx)
return true; return true;
} }
di_addr = sys_get_be16(&ctx->rx_frame.data[0]); di_addr = sys_get_be16(&ctx->rx_adu.data[0]);
di_qty = sys_get_be16(&ctx->rx_frame.data[2]); di_qty = sys_get_be16(&ctx->rx_adu.data[2]);
/* Make sure we don't exceed the allowed limit per request */ /* Make sure we don't exceed the allowed limit per request */
if (di_qty == 0 || di_qty > di_limit) { if (di_qty == 0 || di_qty > di_limit) {
@ -239,18 +239,18 @@ static bool mbs_fc02_di_read(struct modbus_context *ctx)
/* Get number of bytes needed for response. */ /* Get number of bytes needed for response. */
num_bytes = ((di_qty - 1) / 8) + 1; num_bytes = ((di_qty - 1) / 8) + 1;
/* Number of data bytes + byte count. */ /* Number of data bytes + byte count. */
ctx->tx_frame.length = num_bytes + 1; ctx->tx_adu.length = num_bytes + 1;
/* Set number of data bytes in response message. */ /* Set number of data bytes in response message. */
ctx->tx_frame.data[0] = (uint8_t)num_bytes; ctx->tx_adu.data[0] = (uint8_t)num_bytes;
/* Clear bytes in response */ /* Clear bytes in response */
presp = &ctx->tx_frame.data[1]; presp = &ctx->tx_adu.data[1];
for (di_cntr = 0; di_cntr < num_bytes; di_cntr++) { for (di_cntr = 0; di_cntr < num_bytes; di_cntr++) {
*presp++ = 0x00; *presp++ = 0x00;
} }
/* Reset the pointer to the start of the response payload */ /* Reset the pointer to the start of the response payload */
presp = &ctx->tx_frame.data[1]; presp = &ctx->tx_adu.data[1];
/* Start with bit 0 in response byte data mask. */ /* Start with bit 0 in response byte data mask. */
bit_mask = BIT(0); bit_mask = BIT(0);
/* Initialize loop counter. */ /* Initialize loop counter. */
@ -314,13 +314,13 @@ static bool mbs_fc03_hreg_read(struct modbus_context *ctx)
uint16_t reg_qty; uint16_t reg_qty;
uint16_t num_bytes; uint16_t num_bytes;
if (ctx->rx_frame.length != request_len) { if (ctx->rx_adu.length != request_len) {
LOG_ERR("Wrong request length"); LOG_ERR("Wrong request length");
return false; return false;
} }
reg_addr = sys_get_be16(&ctx->rx_frame.data[0]); reg_addr = sys_get_be16(&ctx->rx_adu.data[0]);
reg_qty = sys_get_be16(&ctx->rx_frame.data[2]); reg_qty = sys_get_be16(&ctx->rx_adu.data[2]);
if ((reg_addr < MODBUS_FP_EXTENSIONS_ADDR) || if ((reg_addr < MODBUS_FP_EXTENSIONS_ADDR) ||
!IS_ENABLED(CONFIG_MODBUS_FP_EXTENSIONS)) { !IS_ENABLED(CONFIG_MODBUS_FP_EXTENSIONS)) {
@ -356,12 +356,12 @@ static bool mbs_fc03_hreg_read(struct modbus_context *ctx)
} }
/* Number of data bytes + byte count. */ /* Number of data bytes + byte count. */
ctx->tx_frame.length = num_bytes + 1; ctx->tx_adu.length = num_bytes + 1;
/* Set number of data bytes in response message. */ /* Set number of data bytes in response message. */
ctx->tx_frame.data[0] = (uint8_t)num_bytes; ctx->tx_adu.data[0] = (uint8_t)num_bytes;
/* Reset the pointer to the start of the response payload */ /* Reset the pointer to the start of the response payload */
presp = &ctx->tx_frame.data[1]; presp = &ctx->tx_adu.data[1];
/* Loop through each register requested. */ /* Loop through each register requested. */
while (reg_qty > 0) { while (reg_qty > 0) {
if (reg_addr < MODBUS_FP_EXTENSIONS_ADDR) { if (reg_addr < MODBUS_FP_EXTENSIONS_ADDR) {
@ -424,13 +424,13 @@ static bool mbs_fc04_inreg_read(struct modbus_context *ctx)
uint16_t reg_qty; uint16_t reg_qty;
uint16_t num_bytes; uint16_t num_bytes;
if (ctx->rx_frame.length != request_len) { if (ctx->rx_adu.length != request_len) {
LOG_ERR("Wrong request length"); LOG_ERR("Wrong request length");
return false; return false;
} }
reg_addr = sys_get_be16(&ctx->rx_frame.data[0]); reg_addr = sys_get_be16(&ctx->rx_adu.data[0]);
reg_qty = sys_get_be16(&ctx->rx_frame.data[2]); reg_qty = sys_get_be16(&ctx->rx_adu.data[2]);
if ((reg_addr < MODBUS_FP_EXTENSIONS_ADDR) || if ((reg_addr < MODBUS_FP_EXTENSIONS_ADDR) ||
!IS_ENABLED(CONFIG_MODBUS_FP_EXTENSIONS)) { !IS_ENABLED(CONFIG_MODBUS_FP_EXTENSIONS)) {
@ -466,12 +466,12 @@ static bool mbs_fc04_inreg_read(struct modbus_context *ctx)
} }
/* Number of data bytes + byte count. */ /* Number of data bytes + byte count. */
ctx->tx_frame.length = num_bytes + 1; ctx->tx_adu.length = num_bytes + 1;
/* Set number of data bytes in response message. */ /* Set number of data bytes in response message. */
ctx->tx_frame.data[0] = (uint8_t)num_bytes; ctx->tx_adu.data[0] = (uint8_t)num_bytes;
/* Reset the pointer to the start of the response payload */ /* Reset the pointer to the start of the response payload */
presp = &ctx->tx_frame.data[1]; presp = &ctx->tx_adu.data[1];
/* Loop through each register requested. */ /* Loop through each register requested. */
while (reg_qty > 0) { while (reg_qty > 0) {
if (reg_addr < MODBUS_FP_EXTENSIONS_ADDR) { if (reg_addr < MODBUS_FP_EXTENSIONS_ADDR) {
@ -533,8 +533,8 @@ static bool mbs_fc05_coil_write(struct modbus_context *ctx)
uint16_t coil_val; uint16_t coil_val;
bool coil_state; bool coil_state;
if (ctx->rx_frame.length != request_len) { if (ctx->rx_adu.length != request_len) {
LOG_ERR("Wrong request length %u", ctx->rx_frame.length); LOG_ERR("Wrong request length %u", ctx->rx_adu.length);
return false; return false;
} }
@ -544,8 +544,8 @@ static bool mbs_fc05_coil_write(struct modbus_context *ctx)
} }
/* Get the desired coil address and coil value */ /* Get the desired coil address and coil value */
coil_addr = sys_get_be16(&ctx->rx_frame.data[0]); coil_addr = sys_get_be16(&ctx->rx_adu.data[0]);
coil_val = sys_get_be16(&ctx->rx_frame.data[2]); coil_val = sys_get_be16(&ctx->rx_adu.data[2]);
/* See if coil needs to be OFF? */ /* See if coil needs to be OFF? */
if (coil_val == MODBUS_COIL_OFF_CODE) { if (coil_val == MODBUS_COIL_OFF_CODE) {
@ -563,9 +563,9 @@ static bool mbs_fc05_coil_write(struct modbus_context *ctx)
} }
/* Assemble response payload */ /* Assemble response payload */
ctx->tx_frame.length = response_len; ctx->tx_adu.length = response_len;
sys_put_be16(coil_addr, &ctx->tx_frame.data[0]); sys_put_be16(coil_addr, &ctx->tx_adu.data[0]);
sys_put_be16(coil_val, &ctx->tx_frame.data[2]); sys_put_be16(coil_val, &ctx->tx_adu.data[2]);
return true; return true;
} }
@ -591,8 +591,8 @@ static bool mbs_fc06_hreg_write(struct modbus_context *ctx)
uint16_t reg_addr; uint16_t reg_addr;
uint16_t reg_val; uint16_t reg_val;
if (ctx->rx_frame.length != request_len) { if (ctx->rx_adu.length != request_len) {
LOG_ERR("Wrong request length %u", ctx->rx_frame.length); LOG_ERR("Wrong request length %u", ctx->rx_adu.length);
return false; return false;
} }
@ -601,8 +601,8 @@ static bool mbs_fc06_hreg_write(struct modbus_context *ctx)
return true; return true;
} }
reg_addr = sys_get_be16(&ctx->rx_frame.data[0]); reg_addr = sys_get_be16(&ctx->rx_adu.data[0]);
reg_val = sys_get_be16(&ctx->rx_frame.data[2]); reg_val = sys_get_be16(&ctx->rx_adu.data[2]);
err = ctx->mbs_user_cb->holding_reg_wr(reg_addr, reg_val); err = ctx->mbs_user_cb->holding_reg_wr(reg_addr, reg_val);
@ -613,9 +613,9 @@ static bool mbs_fc06_hreg_write(struct modbus_context *ctx)
} }
/* Assemble response payload */ /* Assemble response payload */
ctx->tx_frame.length = response_len; ctx->tx_adu.length = response_len;
sys_put_be16(reg_addr, &ctx->tx_frame.data[0]); sys_put_be16(reg_addr, &ctx->tx_adu.data[0]);
sys_put_be16(reg_val, &ctx->tx_frame.data[2]); sys_put_be16(reg_val, &ctx->tx_adu.data[2]);
return true; return true;
} }
@ -641,13 +641,13 @@ static bool mbs_fc08_diagnostics(struct modbus_context *ctx)
uint16_t sfunc; uint16_t sfunc;
uint16_t data; uint16_t data;
if (ctx->rx_frame.length != request_len) { if (ctx->rx_adu.length != request_len) {
LOG_ERR("Wrong request length %u", ctx->rx_frame.length); LOG_ERR("Wrong request length %u", ctx->rx_adu.length);
return false; return false;
} }
sfunc = sys_get_be16(&ctx->rx_frame.data[0]); sfunc = sys_get_be16(&ctx->rx_adu.data[0]);
data = sys_get_be16(&ctx->rx_frame.data[2]); data = sys_get_be16(&ctx->rx_adu.data[2]);
switch (sfunc) { switch (sfunc) {
case MODBUS_FC08_SUBF_QUERY: case MODBUS_FC08_SUBF_QUERY:
@ -656,7 +656,7 @@ static bool mbs_fc08_diagnostics(struct modbus_context *ctx)
case MODBUS_FC08_SUBF_CLR_CTR: case MODBUS_FC08_SUBF_CLR_CTR:
/* Sub-function 0x0A clear Counters and Diagnostic */ /* Sub-function 0x0A clear Counters and Diagnostic */
mbs_reset_statistics(ctx); modbus_reset_stats(ctx);
break; break;
case MODBUS_FC08_SUBF_BUS_MSG_CTR: case MODBUS_FC08_SUBF_BUS_MSG_CTR:
@ -691,9 +691,9 @@ static bool mbs_fc08_diagnostics(struct modbus_context *ctx)
} }
/* Assemble response payload */ /* Assemble response payload */
ctx->tx_frame.length = response_len; ctx->tx_adu.length = response_len;
sys_put_be16(sfunc, &ctx->tx_frame.data[0]); sys_put_be16(sfunc, &ctx->tx_adu.data[0]);
sys_put_be16(data, &ctx->tx_frame.data[2]); sys_put_be16(data, &ctx->tx_adu.data[2]);
return true; return true;
} }
@ -735,8 +735,8 @@ static bool mbs_fc15_coils_write(struct modbus_context *ctx)
uint8_t data_ix; uint8_t data_ix;
bool coil_state; bool coil_state;
if (ctx->rx_frame.length < request_len) { if (ctx->rx_adu.length < request_len) {
LOG_ERR("Wrong request length %u", ctx->rx_frame.length); LOG_ERR("Wrong request length %u", ctx->rx_adu.length);
return false; return false;
} }
@ -745,10 +745,10 @@ static bool mbs_fc15_coils_write(struct modbus_context *ctx)
return true; return true;
} }
coil_addr = sys_get_be16(&ctx->rx_frame.data[0]); coil_addr = sys_get_be16(&ctx->rx_adu.data[0]);
coil_qty = sys_get_be16(&ctx->rx_frame.data[2]); coil_qty = sys_get_be16(&ctx->rx_adu.data[2]);
/* Get the byte count for the data. */ /* Get the byte count for the data. */
num_bytes = ctx->rx_frame.data[4]; num_bytes = ctx->rx_adu.data[4];
if (coil_qty == 0 || coil_qty > coils_limit) { if (coil_qty == 0 || coil_qty > coils_limit) {
LOG_ERR("Number of coils limit exceeded"); LOG_ERR("Number of coils limit exceeded");
@ -758,7 +758,7 @@ static bool mbs_fc15_coils_write(struct modbus_context *ctx)
/* Be sure byte count is valid for quantity of coils. */ /* Be sure byte count is valid for quantity of coils. */
if (((((coil_qty - 1) / 8) + 1) != num_bytes) || if (((((coil_qty - 1) / 8) + 1) != num_bytes) ||
(ctx->rx_frame.length != (num_bytes + 5))) { (ctx->rx_adu.length != (num_bytes + 5))) {
LOG_ERR("Mismatch in the number of coils"); LOG_ERR("Mismatch in the number of coils");
mbs_exception_rsp(ctx, MODBUS_EXC_ILLEGAL_DATA_VAL); mbs_exception_rsp(ctx, MODBUS_EXC_ILLEGAL_DATA_VAL);
return true; return true;
@ -771,7 +771,7 @@ static bool mbs_fc15_coils_write(struct modbus_context *ctx)
while (coil_cntr < coil_qty) { while (coil_cntr < coil_qty) {
/* Move to the next data byte after every eight bits. */ /* Move to the next data byte after every eight bits. */
if ((coil_cntr % 8) == 0) { if ((coil_cntr % 8) == 0) {
temp = ctx->rx_frame.data[data_ix++]; temp = ctx->rx_adu.data[data_ix++];
} }
if (temp & BIT(0)) { if (temp & BIT(0)) {
@ -796,9 +796,9 @@ static bool mbs_fc15_coils_write(struct modbus_context *ctx)
} }
/* Assemble response payload */ /* Assemble response payload */
ctx->tx_frame.length = response_len; ctx->tx_adu.length = response_len;
sys_put_be16(coil_addr, &ctx->tx_frame.data[0]); sys_put_be16(coil_addr, &ctx->tx_adu.data[0]);
sys_put_be16(coil_qty, &ctx->tx_frame.data[2]); sys_put_be16(coil_qty, &ctx->tx_adu.data[2]);
return true; return true;
} }
@ -835,15 +835,15 @@ static bool mbs_fc16_hregs_write(struct modbus_context *ctx)
uint16_t num_bytes; uint16_t num_bytes;
uint8_t reg_size; uint8_t reg_size;
if (ctx->rx_frame.length < request_len) { if (ctx->rx_adu.length < request_len) {
LOG_ERR("Wrong request length %u", ctx->rx_frame.length); LOG_ERR("Wrong request length %u", ctx->rx_adu.length);
return false; return false;
} }
reg_addr = sys_get_be16(&ctx->rx_frame.data[0]); reg_addr = sys_get_be16(&ctx->rx_adu.data[0]);
reg_qty = sys_get_be16(&ctx->rx_frame.data[2]); reg_qty = sys_get_be16(&ctx->rx_adu.data[2]);
/* Get the byte count for the data. */ /* Get the byte count for the data. */
num_bytes = ctx->rx_frame.data[4]; num_bytes = ctx->rx_adu.data[4];
if ((reg_addr < MODBUS_FP_EXTENSIONS_ADDR) || if ((reg_addr < MODBUS_FP_EXTENSIONS_ADDR) ||
!IS_ENABLED(CONFIG_MODBUS_FP_EXTENSIONS)) { !IS_ENABLED(CONFIG_MODBUS_FP_EXTENSIONS)) {
@ -877,7 +877,7 @@ static bool mbs_fc16_hregs_write(struct modbus_context *ctx)
} }
/* Compare number of bytes and payload length */ /* Compare number of bytes and payload length */
if ((ctx->rx_frame.length - 5) != num_bytes) { if ((ctx->rx_adu.length - 5) != num_bytes) {
LOG_ERR("Mismatch in the number of bytes"); LOG_ERR("Mismatch in the number of bytes");
mbs_exception_rsp(ctx, MODBUS_EXC_ILLEGAL_DATA_VAL); mbs_exception_rsp(ctx, MODBUS_EXC_ILLEGAL_DATA_VAL);
return true; return true;
@ -890,7 +890,7 @@ static bool mbs_fc16_hregs_write(struct modbus_context *ctx)
} }
/* The 1st registers data byte is 6th element in payload */ /* The 1st registers data byte is 6th element in payload */
prx_data = &ctx->rx_frame.data[5]; prx_data = &ctx->rx_adu.data[5];
for (uint16_t reg_cntr = 0; reg_cntr < reg_qty; reg_cntr++) { for (uint16_t reg_cntr = 0; reg_cntr < reg_qty; reg_cntr++) {
uint16_t addr = reg_addr + reg_cntr; uint16_t addr = reg_addr + reg_cntr;
@ -919,9 +919,9 @@ static bool mbs_fc16_hregs_write(struct modbus_context *ctx)
} }
/* Assemble response payload */ /* Assemble response payload */
ctx->tx_frame.length = response_len; ctx->tx_adu.length = response_len;
sys_put_be16(reg_addr, &ctx->tx_frame.data[0]); sys_put_be16(reg_addr, &ctx->tx_adu.data[0]);
sys_put_be16(reg_qty, &ctx->tx_frame.data[2]); sys_put_be16(reg_qty, &ctx->tx_adu.data[2]);
return true; return true;
} }
@ -929,16 +929,16 @@ static bool mbs_fc16_hregs_write(struct modbus_context *ctx)
static bool mbs_fc_handler(struct modbus_context *ctx) static bool mbs_fc_handler(struct modbus_context *ctx)
{ {
bool send_reply = false; bool send_reply = false;
uint8_t addr = ctx->rx_frame.addr; uint8_t addr = ctx->rx_adu.unit_id;
uint8_t fc = ctx->rx_frame.fc; uint8_t fc = ctx->rx_adu.fc;
if (addr != 0 && addr != ctx->node_addr) { if (addr != 0 && addr != ctx->unit_id) {
return false; return false;
} }
/* Prepare response header */ /* Prepare response header */
ctx->tx_frame.addr = addr; ctx->tx_adu.unit_id = addr;
ctx->tx_frame.fc = fc; ctx->tx_adu.fc = fc;
update_server_msg_ctr(ctx); update_server_msg_ctr(ctx);
@ -994,20 +994,20 @@ static bool mbs_fc_handler(struct modbus_context *ctx)
} }
} }
bool mbs_rx_handler(struct modbus_context *ctx) bool modbus_server_handler(struct modbus_context *ctx)
{ {
LOG_DBG("Server RX handler %p", ctx); LOG_DBG("Server RX handler %p", ctx);
update_msg_ctr(ctx); update_msg_ctr(ctx);
if (ctx->rx_frame_err == -EIO) { if (ctx->rx_adu_err == -EIO) {
update_noresp_ctr(ctx); update_noresp_ctr(ctx);
update_crcerr_ctr(ctx); update_crcerr_ctr(ctx);
} else if (ctx->rx_frame_err != 0) { } else if (ctx->rx_adu_err != 0) {
update_noresp_ctr(ctx); update_noresp_ctr(ctx);
} else { } else {
if (mbs_fc_handler(ctx) == true) { if (mbs_fc_handler(ctx) == true) {
mb_tx_frame(ctx); modbus_tx_adu(ctx);
return true; return true;
} }