8ee675946c
Added the stop_bits_client parameter to the modbus_serial_param struct. Being able to configure the number of stop bits for the client independently from the parity setting, allows to support connecting to modbus server that do not follow the MODBUS over Serial Line Specification and Implementation Guide. Signed-off-by: Constantin Krischke <constantin.krischke@lemonbeat.com> Signed-off-by: Jan Geldmacher <jan.geldmacher@lemonbeat.com>
540 lines
16 KiB
C
540 lines
16 KiB
C
/*
|
|
* Copyright (c) 2020 PHYTEC Messtechnik GmbH
|
|
* Copyright (c) 2021 Nordic Semiconductor ASA
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
/*
|
|
* Client API in this file is based on mbm_core.c from uC/Modbus Stack.
|
|
*
|
|
* uC/Modbus
|
|
* The Embedded Modbus Stack
|
|
*
|
|
* Copyright 2003-2020 Silicon Laboratories Inc. www.silabs.com
|
|
*
|
|
* SPDX-License-Identifier: APACHE-2.0
|
|
*
|
|
* This software is subject to an open source license and is distributed by
|
|
* Silicon Laboratories Inc. pursuant to the terms of the Apache License,
|
|
* Version 2.0 available at www.apache.org/licenses/LICENSE-2.0.
|
|
*/
|
|
|
|
/**
|
|
* @brief MODBUS transport protocol API
|
|
* @defgroup modbus MODBUS
|
|
* @ingroup io_interfaces
|
|
* @{
|
|
*/
|
|
|
|
#ifndef ZEPHYR_INCLUDE_MODBUS_H_
|
|
#define ZEPHYR_INCLUDE_MODBUS_H_
|
|
|
|
#include <drivers/uart.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/** Length of MBAP Header */
|
|
#define MODBUS_MBAP_LENGTH 7
|
|
/** Length of MBAP Header plus function code */
|
|
#define MODBUS_MBAP_AND_FC_LENGTH (MODBUS_MBAP_LENGTH + 1)
|
|
|
|
/**
|
|
* @brief Frame struct used internally and for raw ADU support.
|
|
*/
|
|
struct modbus_adu {
|
|
/** Transaction Identifier */
|
|
uint16_t trans_id;
|
|
/** Protocol Identifier */
|
|
uint16_t proto_id;
|
|
/** Length of the data only (not the length of unit ID + PDU) */
|
|
uint16_t length;
|
|
/** Unit Identifier */
|
|
uint8_t unit_id;
|
|
/** Function Code */
|
|
uint8_t fc;
|
|
/** Transaction Data */
|
|
uint8_t data[CONFIG_MODBUS_BUFFER_SIZE - 4];
|
|
/** RTU CRC */
|
|
uint16_t crc;
|
|
};
|
|
|
|
/**
|
|
* @brief Coil read (FC01)
|
|
*
|
|
* Sends a Modbus message to read the status of coils from a server.
|
|
*
|
|
* @param iface Modbus interface index
|
|
* @param unit_id Modbus unit ID of the server
|
|
* @param start_addr Coil starting address
|
|
* @param coil_tbl Pointer to an array of bytes containing the value
|
|
* of the coils read.
|
|
* The format is:
|
|
*
|
|
* MSB LSB
|
|
* B7 B6 B5 B4 B3 B2 B1 B0
|
|
* -------------------------------------
|
|
* coil_tbl[0] #8 #7 #1
|
|
* coil_tbl[1] #16 #15 #9
|
|
* :
|
|
* :
|
|
*
|
|
* Note that the array that will be receiving the coil
|
|
* values must be greater than or equal to:
|
|
* (num_coils - 1) / 8 + 1
|
|
* @param num_coils Quantity of coils to read
|
|
*
|
|
* @retval 0 If the function was successful
|
|
*/
|
|
int modbus_read_coils(const int iface,
|
|
const uint8_t unit_id,
|
|
const uint16_t start_addr,
|
|
uint8_t *const coil_tbl,
|
|
const uint16_t num_coils);
|
|
|
|
/**
|
|
* @brief Read discrete inputs (FC02)
|
|
*
|
|
* Sends a Modbus message to read the status of discrete inputs from
|
|
* a server.
|
|
*
|
|
* @param iface Modbus interface index
|
|
* @param unit_id Modbus unit ID of the server
|
|
* @param start_addr Discrete input starting address
|
|
* @param di_tbl Pointer to an array that will receive the state
|
|
* of the discrete inputs.
|
|
* The format of the array is as follows:
|
|
*
|
|
* MSB LSB
|
|
* B7 B6 B5 B4 B3 B2 B1 B0
|
|
* -------------------------------------
|
|
* di_tbl[0] #8 #7 #1
|
|
* di_tbl[1] #16 #15 #9
|
|
* :
|
|
* :
|
|
*
|
|
* Note that the array that will be receiving the discrete
|
|
* input values must be greater than or equal to:
|
|
* (num_di - 1) / 8 + 1
|
|
* @param num_di Quantity of discrete inputs to read
|
|
*
|
|
* @retval 0 If the function was successful
|
|
*/
|
|
int modbus_read_dinputs(const int iface,
|
|
const uint8_t unit_id,
|
|
const uint16_t start_addr,
|
|
uint8_t *const di_tbl,
|
|
const uint16_t num_di);
|
|
|
|
/**
|
|
* @brief Read holding registers (FC03)
|
|
*
|
|
* Sends a Modbus message to read the value of holding registers
|
|
* from a server.
|
|
*
|
|
* @param iface Modbus interface index
|
|
* @param unit_id Modbus unit ID of the server
|
|
* @param start_addr Register starting address
|
|
* @param reg_buf Is a pointer to an array that will receive
|
|
* the current values of the holding registers from
|
|
* the server. The array pointed to by 'reg_buf' needs
|
|
* to be able to hold at least 'num_regs' entries.
|
|
* @param num_regs Quantity of registers to read
|
|
*
|
|
* @retval 0 If the function was successful
|
|
*/
|
|
int modbus_read_holding_regs(const int iface,
|
|
const uint8_t unit_id,
|
|
const uint16_t start_addr,
|
|
uint16_t *const reg_buf,
|
|
const uint16_t num_regs);
|
|
|
|
/**
|
|
* @brief Read input registers (FC04)
|
|
*
|
|
* Sends a Modbus message to read the value of input registers from
|
|
* a server.
|
|
*
|
|
* @param iface Modbus interface index
|
|
* @param unit_id Modbus unit ID of the server
|
|
* @param start_addr Register starting address
|
|
* @param reg_buf Is a pointer to an array that will receive
|
|
* the current value of the holding registers
|
|
* from the server. The array pointed to by 'reg_buf'
|
|
* needs to be able to hold at least 'num_regs' entries.
|
|
* @param num_regs Quantity of registers to read
|
|
*
|
|
* @retval 0 If the function was successful
|
|
*/
|
|
int modbus_read_input_regs(const int iface,
|
|
const uint8_t unit_id,
|
|
const uint16_t start_addr,
|
|
uint16_t *const reg_buf,
|
|
const uint16_t num_regs);
|
|
|
|
/**
|
|
* @brief Write single coil (FC05)
|
|
*
|
|
* Sends a Modbus message to write the value of single coil to a server.
|
|
*
|
|
* @param iface Modbus interface index
|
|
* @param unit_id Modbus unit ID of the server
|
|
* @param coil_addr Coils starting address
|
|
* @param coil_state Is the desired state of the coil
|
|
*
|
|
* @retval 0 If the function was successful
|
|
*/
|
|
int modbus_write_coil(const int iface,
|
|
const uint8_t unit_id,
|
|
const uint16_t coil_addr,
|
|
const bool coil_state);
|
|
|
|
/**
|
|
* @brief Write single holding register (FC06)
|
|
*
|
|
* Sends a Modbus message to write the value of single holding register
|
|
* to a server unit.
|
|
*
|
|
* @param iface Modbus interface index
|
|
* @param unit_id Modbus unit ID of the server
|
|
* @param start_addr Coils starting address
|
|
* @param reg_val Desired value of the holding register
|
|
*
|
|
* @retval 0 If the function was successful
|
|
*/
|
|
int modbus_write_holding_reg(const int iface,
|
|
const uint8_t unit_id,
|
|
const uint16_t start_addr,
|
|
const uint16_t reg_val);
|
|
|
|
/**
|
|
* @brief Read diagnostic (FC08)
|
|
*
|
|
* Sends a Modbus message to perform a diagnostic function of a server unit.
|
|
*
|
|
* @param iface Modbus interface index
|
|
* @param unit_id Modbus unit ID of the server
|
|
* @param sfunc Diagnostic sub-function code
|
|
* @param data Sub-function data
|
|
* @param data_out Pointer to the data value
|
|
*
|
|
* @retval 0 If the function was successful
|
|
*/
|
|
int modbus_request_diagnostic(const int iface,
|
|
const uint8_t unit_id,
|
|
const uint16_t sfunc,
|
|
const uint16_t data,
|
|
uint16_t *const data_out);
|
|
|
|
/**
|
|
* @brief Write coils (FC15)
|
|
*
|
|
* Sends a Modbus message to write to coils on a server unit.
|
|
*
|
|
* @param iface Modbus interface index
|
|
* @param unit_id Modbus unit ID of the server
|
|
* @param start_addr Coils starting address
|
|
* @param coil_tbl Pointer to an array of bytes containing the value
|
|
* of the coils to write.
|
|
* The format is:
|
|
*
|
|
* MSB LSB
|
|
* B7 B6 B5 B4 B3 B2 B1 B0
|
|
* -------------------------------------
|
|
* coil_tbl[0] #8 #7 #1
|
|
* coil_tbl[1] #16 #15 #9
|
|
* :
|
|
* :
|
|
*
|
|
* Note that the array that will be receiving the coil
|
|
* values must be greater than or equal to:
|
|
* (num_coils - 1) / 8 + 1
|
|
* @param num_coils Quantity of coils to write
|
|
*
|
|
* @retval 0 If the function was successful
|
|
*/
|
|
int modbus_write_coils(const int iface,
|
|
const uint8_t unit_id,
|
|
const uint16_t start_addr,
|
|
uint8_t *const coil_tbl,
|
|
const uint16_t num_coils);
|
|
|
|
/**
|
|
* @brief Write holding registers (FC16)
|
|
*
|
|
* Sends a Modbus message to write to integer holding registers
|
|
* to a server unit.
|
|
*
|
|
* @param iface Modbus interface index
|
|
* @param unit_id Modbus unit ID of the server
|
|
* @param start_addr Register starting address
|
|
* @param reg_buf Is a pointer to an array containing
|
|
* the value of the holding registers to write.
|
|
* Note that the array containing the register values must
|
|
* be greater than or equal to 'num_regs'
|
|
* @param num_regs Quantity of registers to write
|
|
*
|
|
* @retval 0 If the function was successful
|
|
*/
|
|
int modbus_write_holding_regs(const int iface,
|
|
const uint8_t unit_id,
|
|
const uint16_t start_addr,
|
|
uint16_t *const reg_buf,
|
|
const uint16_t num_regs);
|
|
|
|
/**
|
|
* @brief Read floating-point holding registers (FC03)
|
|
*
|
|
* Sends a Modbus message to read the value of floating-point
|
|
* holding registers from a server unit.
|
|
*
|
|
* @param iface Modbus interface index
|
|
* @param unit_id Modbus unit ID of the server
|
|
* @param start_addr Register starting address
|
|
* @param reg_buf Is a pointer to an array that will receive
|
|
* the current values of the holding registers from
|
|
* the server. The array pointed to by 'reg_buf' needs
|
|
* to be able to hold at least 'num_regs' entries.
|
|
* @param num_regs Quantity of registers to read
|
|
*
|
|
* @retval 0 If the function was successful
|
|
*/
|
|
int modbus_read_holding_regs_fp(const int iface,
|
|
const uint8_t unit_id,
|
|
const uint16_t start_addr,
|
|
float *const reg_buf,
|
|
const uint16_t num_regs);
|
|
|
|
/**
|
|
* @brief Write floating-point holding registers (FC16)
|
|
*
|
|
* Sends a Modbus message to write to floating-point holding registers
|
|
* to a server unit.
|
|
*
|
|
* @param iface Modbus interface index
|
|
* @param unit_id Modbus unit ID of the server
|
|
* @param start_addr Register starting address
|
|
* @param reg_buf Is a pointer to an array containing
|
|
* the value of the holding registers to write.
|
|
* Note that the array containing the register values must
|
|
* be greater than or equal to 'num_regs'
|
|
* @param num_regs Quantity of registers to write
|
|
*
|
|
* @retval 0 If the function was successful
|
|
*/
|
|
int modbus_write_holding_regs_fp(const int iface,
|
|
const uint8_t unit_id,
|
|
const uint16_t start_addr,
|
|
float *const reg_buf,
|
|
const uint16_t num_regs);
|
|
|
|
/** Modbus Server User Callback structure */
|
|
struct modbus_user_callbacks {
|
|
/** Coil read callback */
|
|
int (*coil_rd)(uint16_t addr, bool *state);
|
|
|
|
/** Coil write callback */
|
|
int (*coil_wr)(uint16_t addr, bool state);
|
|
|
|
/** Discrete Input read callback */
|
|
int (*discrete_input_rd)(uint16_t addr, bool *state);
|
|
|
|
/** Input Register read callback */
|
|
int (*input_reg_rd)(uint16_t addr, uint16_t *reg);
|
|
|
|
/** Floating Point Input Register read callback */
|
|
int (*input_reg_rd_fp)(uint16_t addr, float *reg);
|
|
|
|
/** Holding Register read callback */
|
|
int (*holding_reg_rd)(uint16_t addr, uint16_t *reg);
|
|
|
|
/** Holding Register write callback */
|
|
int (*holding_reg_wr)(uint16_t addr, uint16_t reg);
|
|
|
|
/** Floating Point Holding Register read callback */
|
|
int (*holding_reg_rd_fp)(uint16_t addr, float *reg);
|
|
|
|
/** Floating Point Holding Register write callback */
|
|
int (*holding_reg_wr_fp)(uint16_t addr, float reg);
|
|
};
|
|
|
|
/**
|
|
* @brief Get Modbus interface index according to interface name
|
|
*
|
|
* If there is more than one interface, it can be used to clearly
|
|
* identify interfaces in the application.
|
|
*
|
|
* @param iface_name Modbus interface name
|
|
*
|
|
* @retval Modbus interface index or negative error value.
|
|
*/
|
|
int modbus_iface_get_by_name(const char *iface_name);
|
|
|
|
/**
|
|
* @brief ADU raw callback function signature
|
|
*
|
|
* @param iface Modbus RTU interface index
|
|
* @param adu Pointer to the RAW ADU struct to send
|
|
*
|
|
* @retval 0 If transfer was successful
|
|
*/
|
|
typedef int (*modbus_raw_cb_t)(const int iface, const struct modbus_adu *adu);
|
|
|
|
/**
|
|
* @brief Modbus interface mode
|
|
*/
|
|
enum modbus_mode {
|
|
/** Modbus over serial line RTU mode */
|
|
MODBUS_MODE_RTU,
|
|
/** Modbus over serial line ASCII mode */
|
|
MODBUS_MODE_ASCII,
|
|
/** Modbus raw ADU mode */
|
|
MODBUS_MODE_RAW,
|
|
};
|
|
|
|
/**
|
|
* @brief Modbus serial line parameter
|
|
*/
|
|
struct modbus_serial_param {
|
|
/** Baudrate of the serial line */
|
|
uint32_t baud;
|
|
/** parity UART's parity setting:
|
|
* UART_CFG_PARITY_NONE,
|
|
* UART_CFG_PARITY_EVEN,
|
|
* UART_CFG_PARITY_ODD
|
|
*/
|
|
enum uart_config_parity parity;
|
|
/** stop_bits_client UART's stop bits setting if in client mode:
|
|
* UART_CFG_STOP_BITS_0_5,
|
|
* UART_CFG_STOP_BITS_1,
|
|
* UART_CFG_STOP_BITS_1_5,
|
|
* UART_CFG_STOP_BITS_2,
|
|
*/
|
|
enum uart_config_stop_bits stop_bits_client;
|
|
};
|
|
|
|
/**
|
|
* @brief Modbus server parameter
|
|
*/
|
|
struct modbus_server_param {
|
|
/** Pointer to the User Callback structure */
|
|
struct modbus_user_callbacks *user_cb;
|
|
/** Modbus unit ID of the server */
|
|
uint8_t unit_id;
|
|
};
|
|
|
|
/**
|
|
* @brief User parameter structure to configure Modbus interface
|
|
* as client or server.
|
|
*/
|
|
struct modbus_iface_param {
|
|
/** Mode of the interface */
|
|
enum modbus_mode mode;
|
|
union {
|
|
struct modbus_server_param server;
|
|
/** Amount of time client will wait for
|
|
* a response from the server.
|
|
*/
|
|
uint32_t rx_timeout;
|
|
};
|
|
union {
|
|
/** Serial support parameter of the interface */
|
|
struct modbus_serial_param serial;
|
|
/** Pointer to raw ADU callback function */
|
|
modbus_raw_cb_t raw_tx_cb;
|
|
};
|
|
};
|
|
|
|
/**
|
|
* @brief Configure Modbus Interface as raw ADU server
|
|
*
|
|
* @param iface Modbus RTU interface index
|
|
* @param param Configuration parameter of the server interface
|
|
*
|
|
* @retval 0 If the function was successful
|
|
*/
|
|
int modbus_init_server(const int iface, struct modbus_iface_param param);
|
|
|
|
/**
|
|
* @brief Configure Modbus Interface as raw ADU client
|
|
*
|
|
* @param iface Modbus RTU interface index
|
|
* @param param Configuration parameter of the client interface
|
|
*
|
|
* @retval 0 If the function was successful
|
|
*/
|
|
int modbus_init_client(const int iface, struct modbus_iface_param param);
|
|
|
|
/**
|
|
* @brief Disable Modbus Interface
|
|
*
|
|
* This function is called to disable Modbus interface.
|
|
*
|
|
* @param iface Modbus interface index
|
|
*
|
|
* @retval 0 If the function was successful
|
|
*/
|
|
int modbus_disable(const uint8_t iface);
|
|
|
|
/**
|
|
* @brief Submit raw ADU
|
|
*
|
|
* @param iface Modbus RTU interface index
|
|
* @param adu Pointer to the RAW ADU struct that is received
|
|
*
|
|
* @retval 0 If transfer was successful
|
|
*/
|
|
int modbus_raw_submit_rx(const int iface, const struct modbus_adu *adu);
|
|
|
|
/**
|
|
* @brief Put MBAP header into a buffer
|
|
*
|
|
* @param adu Pointer to the RAW ADU struct
|
|
* @param header Pointer to the buffer in which MBAP header
|
|
* will be placed.
|
|
*/
|
|
void modbus_raw_put_header(const struct modbus_adu *adu, uint8_t *header);
|
|
|
|
/**
|
|
* @brief Get MBAP header from a buffer
|
|
*
|
|
* @param adu Pointer to the RAW ADU struct
|
|
* @param header Pointer to the buffer containing MBAP header
|
|
*/
|
|
void modbus_raw_get_header(struct modbus_adu *adu, const uint8_t *header);
|
|
|
|
/**
|
|
* @brief Set Server Device Failure exception
|
|
*
|
|
* This function modifies ADU passed by the pointer.
|
|
*
|
|
* @param adu Pointer to the RAW ADU struct
|
|
*/
|
|
void modbus_raw_set_server_failure(struct modbus_adu *adu);
|
|
|
|
/**
|
|
* @brief Use interface as backend to send and receive ADU
|
|
*
|
|
* This function overwrites ADU passed by the pointer and generates
|
|
* exception responses if backend interface is misconfigured or
|
|
* target device is unreachable.
|
|
*
|
|
* @param iface Modbus client interface index
|
|
* @param adu Pointer to the RAW ADU struct
|
|
*
|
|
* @retval 0 If transfer was successful
|
|
*/
|
|
int modbus_raw_backend_txn(const int iface, struct modbus_adu *adu);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
#endif /* ZEPHYR_INCLUDE_MODBUS_H_ */
|