modbus.h

Go to the documentation of this file.

/*
 * 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.
 */
 
#ifndef ZEPHYR_INCLUDE_MODBUS_H_
#define ZEPHYR_INCLUDE_MODBUS_H_
 
#include <zephyr/drivers/uart.h>
#include <zephyr/sys/slist.h>
#ifdef __cplusplus
extern "C" {
#endif
 
#define MODBUS_MBAP_LENGTH              7
#define MODBUS_MBAP_AND_FC_LENGTH       (MODBUS_MBAP_LENGTH + 1)
 
/* Modbus exception codes */
#define MODBUS_EXC_NONE                         0
#define MODBUS_EXC_ILLEGAL_FC                   1
#define MODBUS_EXC_ILLEGAL_DATA_ADDR            2
#define MODBUS_EXC_ILLEGAL_DATA_VAL             3
#define MODBUS_EXC_SERVER_DEVICE_FAILURE        4
#define MODBUS_EXC_ACK                          5
#define MODBUS_EXC_SERVER_DEVICE_BUSY           6
#define MODBUS_EXC_MEM_PARITY_ERROR             8
#define MODBUS_EXC_GW_PATH_UNAVAILABLE          10
#define MODBUS_EXC_GW_TARGET_FAILED_TO_RESP     11
struct modbus_adu {
        uint16_t trans_id;
        uint16_t proto_id;
        uint16_t length;
        uint8_t unit_id;
        uint8_t fc;
        uint8_t data[CONFIG_MODBUS_BUFFER_SIZE - 4];
        uint16_t crc;
};
 
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);
 
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);
 
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);
 
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);
 
int modbus_write_coil(const int iface,
                      const uint8_t unit_id,
                      const uint16_t coil_addr,
                      const bool coil_state);
 
int modbus_write_holding_reg(const int iface,
                             const uint8_t unit_id,
                             const uint16_t start_addr,
                             const uint16_t reg_val);
 
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);
 
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);
 
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);
 
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);
 
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);
 
struct modbus_user_callbacks {
        int (*coil_rd)(uint16_t addr, bool *state);
 
        int (*coil_wr)(uint16_t addr, bool state);
 
        int (*discrete_input_rd)(uint16_t addr, bool *state);
 
        int (*input_reg_rd)(uint16_t addr, uint16_t *reg);
 
        int (*input_reg_rd_fp)(uint16_t addr, float *reg);
 
        int (*holding_reg_rd)(uint16_t addr, uint16_t *reg);
 
        int (*holding_reg_wr)(uint16_t addr, uint16_t reg);
 
        int (*holding_reg_rd_fp)(uint16_t addr, float *reg);
 
        int (*holding_reg_wr_fp)(uint16_t addr, float reg);
};
 
int modbus_iface_get_by_name(const char *iface_name);
 
typedef int (*modbus_raw_cb_t)(const int iface, const struct modbus_adu *adu,
                                void *user_data);
 
typedef bool (*modbus_custom_cb_t)(const int iface,
                                const struct modbus_adu *const rx_adu,
                                struct modbus_adu *const tx_adu,
                                uint8_t *const excep_code,
                                void *const user_data);
 
struct modbus_custom_fc {
        sys_snode_t node;
        modbus_custom_cb_t cb;
        void *user_data;
        uint8_t fc;
        uint8_t excep_code;
};
#define MODBUS_CUSTOM_FC_DEFINE(name, user_cb, user_fc, userdata)       \
        static struct modbus_custom_fc modbus_cfg_##name = {            \
                .cb = user_cb,                                          \
                .user_data = userdata,                                  \
                .fc = user_fc,                                          \
                .excep_code = MODBUS_EXC_NONE,                          \
        }
 
enum modbus_mode {
        MODBUS_MODE_RTU,
        MODBUS_MODE_ASCII,
        MODBUS_MODE_RAW,
};
 
struct modbus_serial_param {
        uint32_t baud;
        enum uart_config_parity parity;
        enum uart_config_stop_bits stop_bits_client;
};
 
struct modbus_server_param {
        struct modbus_user_callbacks *user_cb;
        uint8_t unit_id;
};
 
struct modbus_raw_cb {
        modbus_raw_cb_t raw_tx_cb;
        void *user_data;
};
 
struct modbus_iface_param {
        enum modbus_mode mode;
        union {
                struct modbus_server_param server;
                uint32_t rx_timeout;
        };
        union {
                struct modbus_serial_param serial;
                struct modbus_raw_cb rawcb;
        };
};
 
int modbus_init_server(const int iface, struct modbus_iface_param param);
 
int modbus_init_client(const int iface, struct modbus_iface_param param);
 
int modbus_disable(const uint8_t iface);
 
int modbus_raw_submit_rx(const int iface, const struct modbus_adu *adu);
 
void modbus_raw_put_header(const struct modbus_adu *adu, uint8_t *header);
 
void modbus_raw_get_header(struct modbus_adu *adu, const uint8_t *header);
 
void modbus_raw_set_server_failure(struct modbus_adu *adu);
 
int modbus_raw_backend_txn(const int iface, struct modbus_adu *adu);
 
int modbus_register_user_fc(const int iface, struct modbus_custom_fc *custom_fc);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_MODBUS_H_ */