Agile Modbus: Agile Modbus

Agile Modbus 1.1.2
Lightweight modbus protocol stack.
Agile Modbus

1、介绍

Agile Modbus 即：轻量型 modbus 协议栈，满足用户任何场景下的使用需求。

  • examples 文件夹提供 PC 上的示例
  • MCU 上的示例查看 mcu_demos
  • 在 AT32F437 上基于 RT-Thread 实现的支持 Modbus 固件升级的 Bootloader：AT32F437_Boot
  • 在 HPM6750 上基于 RT-Thread 实现的支持 Modbus 固件升级的 Bootloader：HPM6750_Boot

1.1、特性

  1. 支持 rtu 及 tcp 协议，使用纯 C 开发，不涉及任何硬件接口，可在任何形式的硬件上直接使用。
  2. 由于其使用纯 C 开发、不涉及硬件，完全可以在串口上跑 tcp 协议，在网络上跑 rtu 协议。
  3. 支持符合 modbus 格式的自定义协议。
  4. 同时支持多主机和多从机。
  5. 使用简单，只需要将 rtu 或 tcp 句柄初始化好后，调用相应 API 进行组包和解包即可。

1.2、目录结构

名称 | 说明
doc | 文档
examples | 例子
figures | 素材
inc | 头文件
src | 源代码
util | 提供简单实用的组件

1.3、许可证

Agile Modbus 遵循 Apache-2.0 许可，详见 LICENSE 文件。

2、使用 Agile Modbus

帮助文档请查看 doc/doxygen/Agile_Modbus.chm

2.1、移植

  • 用户需要实现硬件接口的 发送数据 、 等待数据接收结束 、 清空接收缓存 函数

    对于 等待数据接收结束，提供如下几点思路：

    1. 通用方法

      每隔 20 / 50 ms (该时间可根据波特率和硬件设置，这里只是给了参考值) 从硬件接口读取数据存放到缓冲区中并更新偏移，直到读取不到或缓冲区满，退出读取。

      这对于裸机或操作系统都适用，操作系统可通过 select 或 信号量 方式完成阻塞。

    2. 串口 DMA + IDLE 中断方式

      配置 DMA + IDLE 中断，在中断中使能标志，应用程序中判断该标志是否置位即可。

      但该方案容易出问题，数据字节间稍微错开一点时间就不是一帧了。推荐第一种方案。

  • 主机：
    1. agile_modbus_rtu_init / agile_modbus_tcp_init 初始化 RTU/TCP 环境
    2. agile_modbus_set_slave 设置从机地址
    3. 清空接收缓存
    4. agile_modbus_serialize_xxx 打包请求数据
    5. 发送数据
    6. 等待数据接收结束
    7. agile_modbus_deserialize_xxx 解析响应数据
    8. 用户处理得到的数据
  • 从机：
    1. 实现 agile_modbus_slave_callback_t 类型回调函数
    2. agile_modbus_rtu_init / agile_modbus_tcp_init 初始化 RTU/TCP 环境
    3. agile_modbus_set_slave 设置从机地址
    4. 等待数据接收结束
    5. agile_modbus_slave_handle 处理请求数据
    6. 清空接收缓存 (可选)
    7. 发送数据

  • 特殊功能码

    需要调用 agile_modbus_set_compute_meta_length_after_function_cb 和 agile_modbus_set_compute_data_length_after_meta_cb API 设置特殊功能码在主从模式下处理的回调。

    • agile_modbus_set_compute_meta_length_after_function_cb

      msg_type == AGILE_MODBUS_MSG_INDICATION: 返回主机请求报文的数据元长度(uint8_t 类型)，不是特殊功能码必须返回 0。

      msg_type == MSG_CONFIRMATION: 返回从机响应报文的数据元长度(uint8_t 类型)，不是特殊功能码必须返回 1。

    • agile_modbus_set_compute_data_length_after_meta_cb

      msg_type == AGILE_MODBUS_MSG_INDICATION: 返回主机请求报文数据元之后的数据长度，不是特殊功能码必须返回 0。

      msg_type == MSG_CONFIRMATION: 返回从机响应报文数据元之后的数据长度，不是特殊功能码必须返回 0。

  • agile_modbus_rtu_init / agile_modbus_tcp_init

    初始化 RTU/TCP 环境时需要用户传入 发送缓冲区 和 接收缓冲区，建议这两个缓冲区大小都为 AGILE_MODBUS_MAX_ADU_LENGTH (260) 字节。特殊功能码 情况用户根据协议自行决定。

    但对于小内存 MCU，这两个缓冲区也可以设置小，所有 API 都会对缓冲区大小进行判断：

    发送缓冲区设置：如果 预期请求的数据长度 或 预期响应的数据长度 大于 设置的发送缓冲区大小，返回异常。

    接收缓冲区设置：如果 主机请求的报文长度 大于 设置的接收缓冲区大小，返回异常。这个是合理的，小内存 MCU 做从机肯定是需要对某些功能码做限制的。

2.2、主机

见 2.1、移植。

2.3、从机

2.3.1、接口说明

  • agile_modbus_slave_handle 介绍

    int agile_modbus_slave_handle(agile_modbus_t *ctx, int msg_length, uint8_t slave_strict,
    agile_modbus_slave_callback_t slave_cb, const void *slave_data, int *frame_length)
    agile_modbus_slave_callback_t
    int(* agile_modbus_slave_callback_t)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data)
    从机回调函数
    Definition: agile_modbus.h:251
    agile_modbus_slave_handle
    int agile_modbus_slave_handle(agile_modbus_t *ctx, int msg_length, uint8_t slave_strict, agile_modbus_slave_callback_t slave_cb, const void *slave_data, int *frame_length)
    从机数据处理
    Definition: agile_modbus.c:1203
    agile_modbus
    Agile Modbus 结构体
    Definition: agile_modbus.h:203

    msg_length: 等待数据接收结束 后接收到的数据长度。

    slave_strict: 从机地址严格性检查 (0: 不判断地址是否一致，由用户回调处理; 1: 地址必须一致，否则不会调用回调，也不打包响应数据)。

    slave_cb: agile_modbus_slave_callback_t 类型回调函数，用户实现并传入。如果为 NULL，所有功能码都能响应且为成功，但寄存器数据依然为 0。

    slave_data: 从机回调函数私有数据。

    frame_length: 获取解析出的 modbus 数据帧长度。这个参数的意义在于：

    1. 尾部有脏数据: 仍能解析成功，并告诉用户真实的 modbus 帧长，用户可以进行处理
    2. 数据粘包: 数据由 一帧完整的 modbus 数据 + 部分 modbus 数据帧 组成，用户获得真实 modbus 帧长后，可以移除处理完的 modbus 数据帧，再次读取硬件接口数据与当前 部分 modbus 数据帧 组成新的一帧
    3. 该参数在 modbus 广播传输大数据时使用较多(如：自定义功能码广播升级固件)，普通的从机响应都是一问一答式，只处理完整数据帧就行，建议在响应前执行 清空接收缓存

  • agile_modbus_slave_callback_t 介绍

    typedef int (*agile_modbus_slave_callback_t)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data);
    agile_modbus_slave_info
    Agile Modbus 从机信息结构体
    Definition: agile_modbus.h:232

    agile_modbus_slave_info:

    sft: 包含从机地址和功能码属性，回调中可利用

    rsp_length: 响应数据长度指针，回调中处理 特殊功能码 时需要更新其值，否则 不准更改

    address: 寄存器地址 (不是所有功能码都用到)

    nb: 数目 (不是所有功能码都用到)

    buf: 不同功能码需要使用的数据域 (不是所有功能码都用到)

    send_index: 发送缓冲区当前索引 (不是所有功能码都用到)

  • agile_modbus_slave_info 不同功能码使用

    • AGILE_MODBUS_FC_READ_COILS、AGILE_MODBUS_FC_READ_DISCRETE_INPUTS

      需要使用到 address、nb、send_index 属性，需要调用 agile_modbus_slave_io_set API 将 IO 数据存放到 ctx->send_buf + send_index 开始的数据区域。

    • AGILE_MODBUS_FC_READ_HOLDING_REGISTERS、AGILE_MODBUS_FC_READ_INPUT_REGISTERS

      需要使用到 address、nb、send_index 属性，需要调用 agile_modbus_slave_register_set API 将寄存器数据存放到 ctx->send_buf + send_index 开始的数据区域。

    • AGILE_MODBUS_FC_WRITE_SINGLE_COIL、AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER

      需要使用到 address、buf 属性，将 buf 强转为 int * 类型，获取值存放到寄存器中。

    • AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS

      需要使用到 address、nb、buf 属性，需要调用 agile_modbus_slave_io_get API 获取要写入的 IO 数据。

    • AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS

      需要使用到 address、nb、buf 属性，需要调用 agile_modbus_slave_register_get API 获取要写入的寄存器数据。

    • AGILE_MODBUS_FC_MASK_WRITE_REGISTER

      需要使用到 address、buf 属性，通过 (buf[0] << 8) + buf[1] 获取 and 值，通过 (buf[2] << 8) + buf[3] 获取 or 值。获取寄存器值 data，进行 data = (data & and) | (or & (~and)) 操作更新 data 值，写入寄存器。

    • AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS

      需要使用到 address、buf、send_index 属性，通过 (buf[0] << 8) + buf[1] 获取要读取的寄存器数目，通过 (buf[2] << 8) + buf[3] 获取要写入的寄存器地址，通过 (buf[4] << 8) + buf[5] 获取要写入的寄存器数目。需要调用 agile_modbus_slave_register_get API 获取要写入的寄存器数据，调用 agile_modbus_slave_register_set API 将寄存器数据存放到 ctx->send_buf + send_index 开始的数据区域。

    • 自定义功能码

      需要使用到 send_index、nb、buf 属性，用户在回调中处理数据。

      send_index: 发送缓冲区当前索引

      nb: PUD - 1，也就是 modbus 数据域长度

      buf: modbus 数据域起始位置

      注意: 用户在回调中往发送缓冲区填入数据后，需要更新 agile_modbus_slave_info 的 rsp_length 值。

2.3.2、简易从机接入接口

Agile Modbus 提供了 agile_modbus_slave_callback_t 的一种实现方式，使用户能够简单方便接入。

使用示例可查看 examples/slave。

使用方式：

#include "agile_modbus.h"
#include "agile_modbus_slave_util.h"
const agile_modbus_slave_util_t slave_util = {
/* User implementation */
};
agile_modbus_slave_handle(ctx, read_len, 0, agile_modbus_slave_util_callback, &slave_util, NULL);
agile_modbus.h
Agile Modbus 软件包通用头文件
agile_modbus_slave_util.h
Agile Modbus 软件包提供的简易从机接入头文件
agile_modbus_slave_util_callback
int agile_modbus_slave_util_callback(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data)
从机回调函数
Definition: agile_modbus_slave_util.c:387
agile_modbus_slave_util
从机功能结构体
Definition: agile_modbus_slave_util.h:48
  • agile_modbus_slave_util_callback 介绍
    • Agile Modbus 提供的一种 agile_modbus_slave_callback_t 实现方式，需要 agile_modbus_slave_util_t 类型变量指针作为私有数据。
    • 私有数据为 NULL，所有功能码都能响应且为成功，但寄存器数据依然为 0。

  • agile_modbus_slave_util_t 介绍

    typedef struct agile_modbus_slave_util {
    const agile_modbus_slave_util_map_t *tab_bits;
    int nb_bits;
    const agile_modbus_slave_util_map_t *tab_input_bits;
    int nb_input_bits;
    const agile_modbus_slave_util_map_t *tab_registers;
    int nb_registers;
    const agile_modbus_slave_util_map_t *tab_input_registers;
    int nb_input_registers;
    int (*addr_check)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info);
    int (*special_function)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info);
    int (*done)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, int ret);
    } agile_modbus_slave_util_t;
    agile_modbus_slave_util_t
    struct agile_modbus_slave_util agile_modbus_slave_util_t
    从机功能结构体
    agile_modbus_slave_util_map
    从机寄存器映射结构体
    Definition: agile_modbus_slave_util.h:38
    agile_modbus_slave_util::addr_check
    int(* addr_check)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info)
    地址检查接口
    Definition: agile_modbus_slave_util.h:57
    agile_modbus_slave_util::nb_input_registers
    int nb_input_registers
    输入寄存器定义数组数目
    Definition: agile_modbus_slave_util.h:56
    agile_modbus_slave_util::nb_bits
    int nb_bits
    线圈寄存器定义数组数目
    Definition: agile_modbus_slave_util.h:50
    agile_modbus_slave_util::tab_input_registers
    const agile_modbus_slave_util_map_t * tab_input_registers
    输入寄存器定义数组
    Definition: agile_modbus_slave_util.h:55
    agile_modbus_slave_util::special_function
    int(* special_function)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info)
    特殊功能码处理接口
    Definition: agile_modbus_slave_util.h:58
    agile_modbus_slave_util::nb_input_bits
    int nb_input_bits
    离散量输入寄存器定义数组数目
    Definition: agile_modbus_slave_util.h:52
    agile_modbus_slave_util::tab_input_bits
    const agile_modbus_slave_util_map_t * tab_input_bits
    离散量输入寄存器定义数组
    Definition: agile_modbus_slave_util.h:51
    agile_modbus_slave_util::done
    int(* done)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, int ret)
    处理结束接口
    Definition: agile_modbus_slave_util.h:59
    agile_modbus_slave_util::nb_registers
    int nb_registers
    保持寄存器定义数组数目
    Definition: agile_modbus_slave_util.h:54
    agile_modbus_slave_util::tab_bits
    const agile_modbus_slave_util_map_t * tab_bits
    线圈寄存器定义数组
    Definition: agile_modbus_slave_util.h:49
    agile_modbus_slave_util::tab_registers
    const agile_modbus_slave_util_map_t * tab_registers
    保持寄存器定义数组
    Definition: agile_modbus_slave_util.h:53

    • 寄存器相关

      用户需要实现 bits、input_bits、registers、input_registers 定义。如果某个寄存器定义为 NULL，该寄存器对应的功能码能响应且为成功，但寄存器数据都为 0。

    • 接口调用过程

  • agile_modbus_slave_util_map 介绍

    typedef struct agile_modbus_slave_util_map {
    int start_addr;
    int end_addr;
    int (*get)(void *buf, int bufsz);
    int (*set)(int index, int len, void *buf, int bufsz);
    } agile_modbus_slave_util_map_t;
    agile_modbus_slave_util_map_t
    struct agile_modbus_slave_util_map agile_modbus_slave_util_map_t
    从机寄存器映射结构体
    agile_modbus_slave_util_map::get
    int(* get)(void *buf, int bufsz)
    获取寄存器数据接口
    Definition: agile_modbus_slave_util.h:41
    agile_modbus_slave_util_map::start_addr
    int start_addr
    起始地址
    Definition: agile_modbus_slave_util.h:39
    agile_modbus_slave_util_map::end_addr
    int end_addr
    结束地址
    Definition: agile_modbus_slave_util.h:40
    agile_modbus_slave_util_map::set
    int(* set)(int index, int len, void *buf, int bufsz)
    设置寄存器数据接口
    Definition: agile_modbus_slave_util.h:42
    • 注意事项:
      • 起始地址和结束地址决定的寄存器个数有限制。更改函数内部 map_buf 数组大小可使其变大。
        • bit 寄存器 < 250
        • register 寄存器 < 125
      • 接口函数为 NULL，寄存器对应的功能码能响应且为成功。

    • get 接口

      将地址域内的数据全部拷贝到 buf 中。

    • set 接口

      • index: 地址域内的偏移
      • len: 长度

      根据 index 和 len 修改数据。

2.4、示例

  • examples 文件夹中提供 PC 上的示例，可以在 WSL 或 Linux 下编译运行。
    • RTU / TCP 主机、从机的示例

    • 特殊功能码的示例

      RTU 点对点传输文件: 演示特殊功能码的使用方式

      RTU 广播传输文件: 演示 agile_modbus_slave_handle 中 frame_length 的用处

  • mcu_demos 提供在 MCU 上的例子。
  • AT32F437_Boot 在 AT32F437 上基于 RT-Thread 实现的支持 Modbus 固件升级的 Bootloader。
  • HPM6750_Boot 在 HPM6750 上基于 RT-Thread 实现的支持 Modbus 固件升级的 Bootloader。

2.5、Doxygen 文档生成

  • 使用 Doxywizard 打开 Doxyfile 运行，生成的文件在 doxygen/output 下。
  • 需要更改 Graphviz 路径。
  • HTML 生成未使用 chm 格式的，如果使能需要更改 hhc.exe 路径。

3、支持

如果 Agile Modbus 解决了你的问题，不妨扫描上面二维码请我 喝杯咖啡 ~

4、联系方式 & 感谢

  • 维护：马龙伟
  • 主页：https://github.com/loogg/agile_modbus
  • 邮箱：25440.nosp@m.4721.nosp@m.3@qq..nosp@m.com
制作者 doxygen 1.9.2


Agile Modbus: 更新记录

更新记录

Agile Modbus 1.1.0 发布

新功能

2021-12-02：马龙伟

  • 增加 Doxygen 注释，生成文档

2021-12-28：马龙伟

  • 增加 RTU 和 TCP 主机例子
  • 增加 RTU 和 TCP 从机例子
  • 增加示例文档

2022-01-08：马龙伟

  • 增加 RTU 点对点传输文件例子
  • 增加 RTU 广播传输文件例子

修改

2022-01-06：马龙伟

  • 修改从机例子，RTU 和 TCP 使用同一个从机回调
  • TCP 从机支持最大 5 个客户端接入
  • TCP 从机 10s 内未收到正确报文主动断开

2022-01-08：马龙伟

  • 去除接收数据判断中长度限制
  • 去除 agile_modbus_serialize_raw_request 对于原始数据的长度限制

Agile Modbus 1.1.1 发布

修改

2022-06-22：马龙伟

  • README.md 增加在 AT32F437 上基于 RT-Thread 实现的支持 Modbus 固件升级的 Bootloader 链接
  • 增加 HPM6750_Boot 链接
  • 更改 LICENSE 为 Apache-2.0

Agile Modbus 1.1.2 发布

新功能

2022-07-28：马龙伟

  • 提供简易从机接入 agile_modbus_slave_util_callback 接口

修改

2022-07-28：马龙伟

  • agile_modbus_slave_handle 增加 从机回调私有数据 参数
  • agile_modbus_slave_callback_t 增加 私有数据 参数
  • examples 中从机示例使用 agile_modbus_slave_util_callback 接口实现寄存器读写


Agile Modbus: 示例说明

示例说明

1、介绍

该示例提供 RTU / TCP 主机和从机的功能演示。

WSL 或 Linux 下使用 gcc 可直接 make all 编译出所有示例，在电脑上运行测试程序。

目录结构：

名称 | 说明
common | 公用源码
figures | 素材
rtu_master | RTU 主机示例
tcp_master | TCP 主机示例
slave | RTU + TCP 从机示例
rtu_p2p | RTU 点对点传输文件
rtu_broadcast | RTU 广播传输文件 (粘包处理示例)

2、使用

需要准备的工具如下：

  • 虚拟串口软件
  • Modbus Poll
  • Modbus Slave

命令行敲击 make clean 、 make all 。

2.1、主机

  • RTU (rtu_master)

    • 使用虚拟串口软件虚拟出一对串口

    • 打开 Modbus Slave ，按下图设置

    • Modbus Slave 连接，按下图设置

    • 进入 rtu_master 目录，./RtuMaster /dev/ttySX 运行 RTU 主机示例，ttySX 为一对虚拟串口中的另一个

  • TCP (tcp_master)
    • 打开 Modbus Slave，SetUp 设置同 RTU 一致

    • Modbus Slave 连接，按下图设置

    • 进入 tcp_master 目录，./TcpMaster 127.0.0.1 502 运行 TCP 主机示例

2.2、从机

  • 该示例 (slave) 同时提供 RTU 和 TCP 从机功能演示，控制的是同一片内存。TCP 最大可接入 5 个客户端，每个客户端无数据超时为 10s, 10s 后自动断开。
  • 示例支持所有功能码(除了功能码 0x07)。
  • 对 bit、input_bit、register、input_register 寄存器每个文件单独定义。
  • 使用 agile_modbus_slave_util_callback 。
  • 寄存器地址域：
寄存器 | 地址范围
线圈寄存器 | 0x041A ~ 0x0423 (1050 ~ 1059)
离散量输入寄存器 | 0x041A ~ 0x0423 (1050 ~ 1059)
保持寄存器 | 0xFFF6 ~ 0xFFFF (65526 ~ 65535)
输入寄存器 | 0xFFF6 ~ 0xFFFF (65526 ~ 65535)

注意: 读写其他地址寄存器都能成功，但值都为 0。

使用：

  • 使用虚拟串口软件虚拟出一对串口

  • 进入 slave 目录，./ModbusSlave /dev/ttyS2 1025 运行示例

    /dev/ttySX: 虚拟串口中的一个

    1025：监听端口号，如果不是 root 权限，端口号必须大于 1024

  • 打开 Modbus Poll 按下图设置和连接 RTU

  • 打开 5 个 Modbus Poll ，设置同 RTU，连接如下图

  • 效果演示

  • 超时断开演示

    将 Modbus Poll 的 poll 界面关闭，看控制台打印可以看到 close 报文。

2.3、RTU 传输文件

使用 0x50 作为传输文件的特殊功能码。

分包传输文件数据，每包数据最大 1024 字节。

Data 字段协议定义：

  • 主机请求
命令 | 字节数 | 数据
2 Bytes | 2 Bytes | N Bytes

命令:

命令 | 说明 | 数据
0x0001 | 开始发送 | 文件大小(4 Bytes) + 文件名称(字符串)
0x0002 | 传输数据 | 标志(1 Byte) + 文件数据

标志:

状态 | 说明
0x00 | 最后一包数据
0x01 | 不是最后一包数据
  • 从机响应
命令 | 状态
2 Bytes | 1 Byte

状态:

状态 | 说明
0x00 | 失败
0x01 | 成功

  • 使用虚拟串口软件虚拟出 3 个串口，组成串口群组

    这里我使用的时 MX 虚拟串口

2.3.1、点对点传输

  • 进入 rtu_p2p 目录，打开 Linux Shell，演示效果如下

    注意:

    • 传输的文件必须是一般文件，像可执行文件、目录等不支持
    • 文件路径必须是 Linux 环境下的路径
    • 从机接收到数据后修改文件名称 (从机地址_原文件名) 写入在当前目录。

2.3.2、广播传输

该例子主要演示 agile_modbus_slave_handle 中 frame_length 的用处。

broadcast_master 中，使用广播地址 0，周期 5ms 发送数据包。同时每包数据后都发送 100 字节的脏数据。

int send_len = agile_modbus_serialize_raw_request(ctx, raw_req, raw_req_len);
serial_send(_fd, ctx->send_buf, send_len);
//脏数据
serial_send(_fd, _dirty_buf, sizeof(_dirty_buf));
agile_modbus_serialize_raw_request
int agile_modbus_serialize_raw_request(agile_modbus_t *ctx, const uint8_t *raw_req, int raw_req_length)
将原始数据打包成请求报文
Definition: agile_modbus.c:1031

在如此快速的数据流下，broadcast_slave 必须使用 agile_modbus_slave_handle 中 frame_length 参数来对粘包进行处理。

  • 进入 rtu_broadcast 目录，打开 Linux Shell，演示效果如下

    注意:

    • 传输的文件必须是一般文件，像可执行文件、目录等不支持
    • 文件路径必须是 Linux 环境下的路径
    • 从机接收到数据后修改文件名称 (从机地址_原文件名) 写入在当前目录。


Agile Modbus: 模块

模块
这里列出了所有模块:
[详情级别 123]
▼ Common |
▼ Common Exported Constants |
Modbus Function Codes |
Modbus Constants |
Common Exported Types |
Common Private Constants |
Common Private Functions |
Common Exported Functions |
▼ Modbus Master |
Master Private Functions |
Master Common Operation Functions | 常用 modbus 主机操作函数
Master Raw Operation Functions |
▼ Modbus Slave |
Slave Exported Types |
Slave Private Functions |
Slave Operation Functions |
▼ RTU |
RTU Exported Constants |
RTU Exported Types |
RTU Private Constants |
RTU Private Functions |
RTU Exported Functions |
▼ TCP |
TCP Exported Constants |
TCP Exported Types |
TCP Private Functions |
TCP Private Constants |
TCP Exported Functions |
▼ UTIL |
▼ Slave Util |
Slave Util Private Functions |
Slave Util Exported Functions |
Slave Util Exported Types |


Agile Modbus: Common

模块
Common
Common 的协作图:

模块

Common Exported Constants
Common Exported Types
Common Private Constants
Common Private Functions
Common Exported Functions
Modbus Master
Modbus Slave

详细描述

制作者 doxygen 1.9.2


Agile Modbus: Common Exported Constants

模块
Common Exported Constants
Common
Common Exported Constants 的协作图:

模块

Modbus Function Codes
Modbus Constants

详细描述

制作者 doxygen 1.9.2


Agile Modbus: Modbus Function Codes

宏定义
Modbus Function Codes
Common » Common Exported Constants
Modbus Function Codes 的协作图:

宏定义

#define | AGILE_MODBUS_FC_READ_COILS 0x01
#define | AGILE_MODBUS_FC_READ_DISCRETE_INPUTS 0x02
#define | AGILE_MODBUS_FC_READ_HOLDING_REGISTERS 0x03
#define | AGILE_MODBUS_FC_READ_INPUT_REGISTERS 0x04
#define | AGILE_MODBUS_FC_WRITE_SINGLE_COIL 0x05
#define | AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER 0x06
#define | AGILE_MODBUS_FC_READ_EXCEPTION_STATUS 0x07
#define | AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS 0x0F
#define | AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS 0x10
#define | AGILE_MODBUS_FC_REPORT_SLAVE_ID 0x11
#define | AGILE_MODBUS_FC_MASK_WRITE_REGISTER 0x16
#define | AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS 0x17

详细描述

宏定义说明

◆ AGILE_MODBUS_FC_READ_COILS

#define AGILE_MODBUS_FC_READ_COILS 0x01

在文件 agile_modbus.h 第 34 行定义.

◆ AGILE_MODBUS_FC_READ_DISCRETE_INPUTS

#define AGILE_MODBUS_FC_READ_DISCRETE_INPUTS 0x02

在文件 agile_modbus.h 第 35 行定义.

◆ AGILE_MODBUS_FC_READ_HOLDING_REGISTERS

#define AGILE_MODBUS_FC_READ_HOLDING_REGISTERS 0x03

在文件 agile_modbus.h 第 36 行定义.

◆ AGILE_MODBUS_FC_READ_INPUT_REGISTERS

#define AGILE_MODBUS_FC_READ_INPUT_REGISTERS 0x04

在文件 agile_modbus.h 第 37 行定义.

◆ AGILE_MODBUS_FC_WRITE_SINGLE_COIL

#define AGILE_MODBUS_FC_WRITE_SINGLE_COIL 0x05

在文件 agile_modbus.h 第 38 行定义.

◆ AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER

#define AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER 0x06

在文件 agile_modbus.h 第 39 行定义.

◆ AGILE_MODBUS_FC_READ_EXCEPTION_STATUS

#define AGILE_MODBUS_FC_READ_EXCEPTION_STATUS 0x07

在文件 agile_modbus.h 第 40 行定义.

◆ AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS

#define AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS 0x0F

在文件 agile_modbus.h 第 41 行定义.

◆ AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS

#define AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS 0x10

在文件 agile_modbus.h 第 42 行定义.

◆ AGILE_MODBUS_FC_REPORT_SLAVE_ID

#define AGILE_MODBUS_FC_REPORT_SLAVE_ID 0x11

在文件 agile_modbus.h 第 43 行定义.

◆ AGILE_MODBUS_FC_MASK_WRITE_REGISTER

#define AGILE_MODBUS_FC_MASK_WRITE_REGISTER 0x16

在文件 agile_modbus.h 第 44 行定义.

◆ AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS

#define AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS 0x17

在文件 agile_modbus.h 第 45 行定义.


Agile Modbus: Modbus Constants

宏定义
Modbus Constants
Common » Common Exported Constants
Modbus Constants 的协作图:

宏定义

#define | AGILE_MODBUS_VERSION_STRING "AMB_1.1.0"
Agile Modbus 版本号 更多...
#define | AGILE_MODBUS_BROADCAST_ADDRESS 0
Modbus 广播地址 更多...
#define | AGILE_MODBUS_MAX_PDU_LENGTH 253
#define | AGILE_MODBUS_MAX_ADU_LENGTH 260

Quantity limit of Coils

   Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 1 page 12)
   Quantity of Coils to read (2 bytes): 1 to 2000 (0x7D0)
   (chapter 6 section 11 page 29)
   Quantity of Coils to write (2 bytes): 1 to 1968 (0x7B0)
#define | AGILE_MODBUS_MAX_READ_BITS 2000
#define | AGILE_MODBUS_MAX_WRITE_BITS 1968

Quantity limit of Registers

   Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 3 page 15)
   Quantity of Registers to read (2 bytes): 1 to 125 (0x7D)
   (chapter 6 section 12 page 31)
   Quantity of Registers to write (2 bytes) 1 to 123 (0x7B)
   (chapter 6 section 17 page 38)
   Quantity of Registers to write in R/W registers (2 bytes) 1 to 121 (0x79)
#define | AGILE_MODBUS_MAX_READ_REGISTERS 125
#define | AGILE_MODBUS_MAX_WRITE_REGISTERS 123
#define | AGILE_MODBUS_MAX_WR_WRITE_REGISTERS 121
#define | AGILE_MODBUS_MAX_WR_READ_REGISTERS 125

详细描述

宏定义说明

◆ AGILE_MODBUS_VERSION_STRING

#define AGILE_MODBUS_VERSION_STRING "AMB_1.1.0"

Agile Modbus 版本号

在文件 agile_modbus.h 第 53 行定义.

◆ AGILE_MODBUS_BROADCAST_ADDRESS

#define AGILE_MODBUS_BROADCAST_ADDRESS 0

Modbus 广播地址

在文件 agile_modbus.h 第 55 行定义.

◆ AGILE_MODBUS_MAX_READ_BITS

#define AGILE_MODBUS_MAX_READ_BITS 2000

在文件 agile_modbus.h 第 67 行定义.

◆ AGILE_MODBUS_MAX_WRITE_BITS

#define AGILE_MODBUS_MAX_WRITE_BITS 1968

在文件 agile_modbus.h 第 68 行定义.

◆ AGILE_MODBUS_MAX_READ_REGISTERS

#define AGILE_MODBUS_MAX_READ_REGISTERS 125

在文件 agile_modbus.h 第 85 行定义.

◆ AGILE_MODBUS_MAX_WRITE_REGISTERS

#define AGILE_MODBUS_MAX_WRITE_REGISTERS 123

在文件 agile_modbus.h 第 86 行定义.

◆ AGILE_MODBUS_MAX_WR_WRITE_REGISTERS

#define AGILE_MODBUS_MAX_WR_WRITE_REGISTERS 121

在文件 agile_modbus.h 第 87 行定义.

◆ AGILE_MODBUS_MAX_WR_READ_REGISTERS

#define AGILE_MODBUS_MAX_WR_READ_REGISTERS 125

在文件 agile_modbus.h 第 88 行定义.

◆ AGILE_MODBUS_MAX_PDU_LENGTH

#define AGILE_MODBUS_MAX_PDU_LENGTH 253
   The size of the MODBUS PDU is limited by the size constraint inherited from
   the first MODBUS implementation on Serial Line network (max. RS485 ADU = 256
   bytes). Therefore, MODBUS PDU for serial line communication = 256 - Server
   address (1 byte) - CRC (2 bytes) = 253 bytes.

在文件 agile_modbus.h 第 102 行定义.

◆ AGILE_MODBUS_MAX_ADU_LENGTH

#define AGILE_MODBUS_MAX_ADU_LENGTH 260
   Consequently:
   - RTU MODBUS ADU = 253 bytes + Server address (1 byte) + CRC (2 bytes) = 256
   bytes.
   - TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes.
   so the maximum of both backend in 260 bytes. This size can used to allocate
   an array of bytes to store responses and it will be compatible with the two
   backends.

在文件 agile_modbus.h 第 116 行定义.


Agile Modbus: Common Exported Types

结构体 | 类型定义 | 枚举
Common Exported Types
Common
Common Exported Types 的协作图:

结构体

struct | agile_modbus_sft
包含 modbus 头部参数结构体 更多...
struct | agile_modbus_backend
Agile Modbus 后端接口结构体 更多...
struct | agile_modbus
Agile Modbus 结构体 更多...

类型定义

typedef struct agile_modbus_sft | agile_modbus_sft_t
包含 modbus 头部参数结构体 更多...
typedef struct agile_modbus | agile_modbus_t
Agile Modbus 结构体 更多...
typedef struct agile_modbus_backend | agile_modbus_backend_t
Agile Modbus 后端接口结构体 更多...

枚举

enum {
AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 0x01 , AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS , AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE , AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE ,
AGILE_MODBUS_EXCEPTION_ACKNOWLEDGE , AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY , AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE , AGILE_MODBUS_EXCEPTION_MEMORY_PARITY ,
AGILE_MODBUS_EXCEPTION_NOT_DEFINED , AGILE_MODBUS_EXCEPTION_GATEWAY_PATH , AGILE_MODBUS_EXCEPTION_GATEWAY_TARGET , AGILE_MODBUS_EXCEPTION_UNKNOW = 0xff
}
Modbus 异常码 更多...
enum | agile_modbus_backend_type_t { AGILE_MODBUS_BACKEND_TYPE_RTU = 0 , AGILE_MODBUS_BACKEND_TYPE_TCP }
Modbus 后端类型 更多...
enum | agile_modbus_msg_type_t { AGILE_MODBUS_MSG_INDICATION , AGILE_MODBUS_MSG_CONFIRMATION }
Modbus 收到消息类型 更多...

详细描述

类型定义说明

◆ agile_modbus_sft_t

typedef struct agile_modbus_sft agile_modbus_sft_t

包含 modbus 头部参数结构体

◆ agile_modbus_t

typedef struct agile_modbus agile_modbus_t

Agile Modbus 结构体

在文件 agile_modbus.h 第 179 行定义.

◆ agile_modbus_backend_t

typedef struct agile_modbus_backend agile_modbus_backend_t

Agile Modbus 后端接口结构体

枚举类型说明

◆ anonymous enum

anonymous enum

Modbus 异常码

枚举值
AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION
AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS
AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE
AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE
AGILE_MODBUS_EXCEPTION_ACKNOWLEDGE
AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY
AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE
AGILE_MODBUS_EXCEPTION_MEMORY_PARITY
AGILE_MODBUS_EXCEPTION_NOT_DEFINED
AGILE_MODBUS_EXCEPTION_GATEWAY_PATH
AGILE_MODBUS_EXCEPTION_GATEWAY_TARGET
AGILE_MODBUS_EXCEPTION_UNKNOW

在文件 agile_modbus.h 第 132 行定义.

◆ agile_modbus_backend_type_t

enum agile_modbus_backend_type_t

Modbus 后端类型

枚举值
AGILE_MODBUS_BACKEND_TYPE_RTU | RTU
AGILE_MODBUS_BACKEND_TYPE_TCP | TCP

在文件 agile_modbus.h 第 150 行定义.

◆ agile_modbus_msg_type_t

enum agile_modbus_msg_type_t

Modbus 收到消息类型

   ---------- Request     Indication ----------
   | Client | ---------------------->| Server |
   ---------- Confirmation  Response ----------
枚举值
AGILE_MODBUS_MSG_INDICATION | 主机端的请求消息
AGILE_MODBUS_MSG_CONFIRMATION | 服务器端的请求消息

在文件 agile_modbus.h 第 165 行定义.


Agile Modbus: agile_modbus_sft结构体 参考

成员变量
agile_modbus_sft结构体 参考
Common » Common Exported Types

包含 modbus 头部参数结构体 更多...

#include <agile_modbus.h>

成员变量

int | slave
从机地址 更多...
int | function
功能码 更多...
int | t_id
事务标识符 更多...

详细描述

包含 modbus 头部参数结构体

在文件 agile_modbus.h 第 173 行定义.

结构体成员变量说明

◆ slave

int agile_modbus_sft::slave

从机地址

在文件 agile_modbus.h 第 174 行定义.

◆ function

int agile_modbus_sft::function

功能码

在文件 agile_modbus.h 第 175 行定义.

◆ t_id

int agile_modbus_sft::t_id

事务标识符

在文件 agile_modbus.h 第 176 行定义.

该结构体的文档由以下文件生成:
  • C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/inc/agile_modbus.h


Agile Modbus: agile_modbus_backend结构体 参考

成员变量
agile_modbus_backend结构体 参考
Common » Common Exported Types

Agile Modbus 后端接口结构体 更多...

#include <agile_modbus.h>

成员变量

uint32_t | backend_type
后端类型 更多...
uint32_t | header_length
头部长度，不包含功能码 更多...
uint32_t | checksum_length
校验数据长度 更多...
uint32_t | max_adu_length
后端 ADU 长度 更多...
int(* | set_slave )(agile_modbus_t *ctx, int slave)
设置地址接口 更多...
int(* | build_request_basis )(agile_modbus_t *ctx, int function, int addr, int nb, uint8_t *req)
构建基础请求报文接口 更多...
int(* | build_response_basis )(agile_modbus_sft_t *sft, uint8_t *rsp)
构建基础响应报文接口 更多...
int(* | prepare_response_tid )(const uint8_t *req, int *req_length)
准备响应接口 更多...
int(* | send_msg_pre )(uint8_t *req, int req_length)
预发送数据接口 更多...
int(* | check_integrity )(agile_modbus_t *ctx, uint8_t *msg, const int msg_length)
检查接收数据完整性接口 更多...
int(* | pre_check_confirmation )(agile_modbus_t *ctx, const uint8_t *req, const uint8_t *rsp, int rsp_length)
预检查确认接口 更多...

详细描述

Agile Modbus 后端接口结构体

在文件 agile_modbus.h 第 184 行定义.

结构体成员变量说明

◆ backend_type

uint32_t agile_modbus_backend::backend_type

后端类型

在文件 agile_modbus.h 第 185 行定义.

◆ header_length

uint32_t agile_modbus_backend::header_length

头部长度，不包含功能码

在文件 agile_modbus.h 第 186 行定义.

◆ checksum_length

uint32_t agile_modbus_backend::checksum_length

校验数据长度

在文件 agile_modbus.h 第 187 行定义.

◆ max_adu_length

uint32_t agile_modbus_backend::max_adu_length

后端 ADU 长度

在文件 agile_modbus.h 第 188 行定义.

◆ set_slave

int(* agile_modbus_backend::set_slave) (agile_modbus_t *ctx, int slave)

设置地址接口

在文件 agile_modbus.h 第 189 行定义.

◆ build_request_basis

int(* agile_modbus_backend::build_request_basis) (agile_modbus_t *ctx, int function, int addr, int nb, uint8_t *req)

构建基础请求报文接口

在文件 agile_modbus.h 第 190 行定义.

◆ build_response_basis

int(* agile_modbus_backend::build_response_basis) (agile_modbus_sft_t *sft, uint8_t *rsp)

构建基础响应报文接口

在文件 agile_modbus.h 第 192 行定义.

◆ prepare_response_tid

int(* agile_modbus_backend::prepare_response_tid) (const uint8_t *req, int *req_length)

准备响应接口

在文件 agile_modbus.h 第 193 行定义.

◆ send_msg_pre

int(* agile_modbus_backend::send_msg_pre) (uint8_t *req, int req_length)

预发送数据接口

在文件 agile_modbus.h 第 194 行定义.

◆ check_integrity

int(* agile_modbus_backend::check_integrity) (agile_modbus_t *ctx, uint8_t *msg, const int msg_length)

检查接收数据完整性接口

在文件 agile_modbus.h 第 195 行定义.

◆ pre_check_confirmation

int(* agile_modbus_backend::pre_check_confirmation) (agile_modbus_t *ctx, const uint8_t *req, const uint8_t *rsp, int rsp_length)

预检查确认接口

在文件 agile_modbus.h 第 196 行定义.

该结构体的文档由以下文件生成:
  • C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/inc/agile_modbus.h


Agile Modbus: agile_modbus结构体 参考

成员变量
agile_modbus结构体 参考
Common » Common Exported Types

Agile Modbus 结构体 更多...

#include <agile_modbus.h>

agile_modbus 的协作图:
[图例]

成员变量

int | slave
从机地址 更多...
uint8_t * | send_buf
发送缓冲区 更多...
int | send_bufsz
发送缓冲区大小 更多...
uint8_t * | read_buf
接收缓冲区 更多...
int | read_bufsz
接收缓冲区大小 更多...
uint8_t(* | compute_meta_length_after_function )(agile_modbus_t *ctx, int function, agile_modbus_msg_type_t msg_type)
自定义计算数据元长度接口 更多...
int(* | compute_data_length_after_meta )(agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type)
自定义计算数据长度接口 更多...
const agile_modbus_backend_t * | backend
后端接口 更多...
void * | backend_data
后端数据，指向 RTU 或 TCP 结构体 更多...

详细描述

Agile Modbus 结构体

在文件 agile_modbus.h 第 203 行定义.

结构体成员变量说明

◆ slave

int agile_modbus::slave

从机地址

在文件 agile_modbus.h 第 204 行定义.

◆ send_buf

uint8_t* agile_modbus::send_buf

发送缓冲区

在文件 agile_modbus.h 第 205 行定义.

◆ send_bufsz

int agile_modbus::send_bufsz

发送缓冲区大小

在文件 agile_modbus.h 第 206 行定义.

◆ read_buf

uint8_t* agile_modbus::read_buf

接收缓冲区

在文件 agile_modbus.h 第 207 行定义.

◆ read_bufsz

int agile_modbus::read_bufsz

接收缓冲区大小

在文件 agile_modbus.h 第 208 行定义.

◆ compute_meta_length_after_function

uint8_t(* agile_modbus::compute_meta_length_after_function) (agile_modbus_t *ctx, int function, agile_modbus_msg_type_t msg_type)

自定义计算数据元长度接口

在文件 agile_modbus.h 第 209 行定义.

◆ compute_data_length_after_meta

int(* agile_modbus::compute_data_length_after_meta) (agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type)

自定义计算数据长度接口

在文件 agile_modbus.h 第 211 行定义.

◆ backend

const agile_modbus_backend_t* agile_modbus::backend

后端接口

在文件 agile_modbus.h 第 213 行定义.

◆ backend_data

void* agile_modbus::backend_data

后端数据，指向 RTU 或 TCP 结构体

在文件 agile_modbus.h 第 214 行定义.

该结构体的文档由以下文件生成:
  • C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/inc/agile_modbus.h


Agile Modbus: Common Private Constants

宏定义
Common Private Constants
Common
Common Private Constants 的协作图:

宏定义

#define AGILE_MODBUS_MSG_LENGTH_UNDEFINED -1
对应功能码数据长度未定义 更多...

详细描述

宏定义说明

◆ AGILE_MODBUS_MSG_LENGTH_UNDEFINED

#define AGILE_MODBUS_MSG_LENGTH_UNDEFINED -1

对应功能码数据长度未定义

在文件 agile_modbus.c 第 49 行定义.


Agile Modbus: Common Private Functions

函数
Common Private Functions
Common
Common Private Functions 的协作图:

函数

static uint8_t | agile_modbus_compute_meta_length_after_function (agile_modbus_t *ctx, int function, agile_modbus_msg_type_t msg_type)
计算功能码后要接收的数据元长度 更多...
static int | agile_modbus_compute_data_length_after_meta (agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type)
计算数据元之后要接收的数据长度 更多...
static int | agile_modbus_receive_msg_judge (agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type)
检验接收数据正确性 更多...

详细描述

函数说明

◆ agile_modbus_compute_meta_length_after_function()

static uint8_t agile_modbus_compute_meta_length_after_function | ( | agile_modbus_t * | ctx,
 |  | int | function,
 |  | agile_modbus_msg_type_t | msg_type
 | ) |  |
static

计算功能码后要接收的数据元长度

   ---------- Request     Indication ----------
   | Client | ---------------------->| Server |
   ---------- Confirmation  Response ----------

   以 03 功能码请求报文举例

   ---------- ------ --------------- ---------
   | header | | 03 | | 00 00 00 01 | | CRC16 |
   ---------- ------ --------------- ---------

   ----------
   | header |
   ----------
       RTU: 设备地址
       TCP: | 事务处理标识  协议标识  长度  单元标识符 |

   ---------------
   | 00 00 00 01 |
   ---------------
       数据元: 与功能码相关的数据，如 03 功能码数据元中包含寄存器起始地址和寄存器长度
参数
ctx | modbus 句柄
function | 功能码
msg_type | 消息类型
返回
数据元长度

在文件 agile_modbus.c 第 88 行定义.

这是这个函数的调用关系图:

◆ agile_modbus_compute_data_length_after_meta()

static int agile_modbus_compute_data_length_after_meta | ( | agile_modbus_t * | ctx,
 |  | uint8_t * | msg,
 |  | int | msg_length,
 |  | agile_modbus_msg_type_t | msg_type
 | ) |  |
static

计算数据元之后要接收的数据长度

   ---------- Request     Indication ----------
   | Client | ---------------------->| Server |
   ---------- Confirmation  Response ----------

   以 03 功能码响应报文举例

   ---------- ------ ------ --------- ---------
   | header | | 03 | | 02 | | 00 00 | | CRC16 |
   ---------- ------ ------ --------- ---------

   ----------
   | header |
   ----------
       RTU: 设备地址
       TCP: | 事务处理标识  协议标识  长度  单元标识符 |

   ------
   | 02 |
   ------
       数据元: 两个字节数据

   ---------
   | 00 00 |
   ---------
       数据
参数
ctx | modbus 句柄
msg | 消息指针
msg_length | 消息长度
msg_type | 消息类型
返回
数据长度

在文件 agile_modbus.c 第 177 行定义.

这是这个函数的调用关系图:

◆ agile_modbus_receive_msg_judge()

static int agile_modbus_receive_msg_judge | ( | agile_modbus_t * | ctx,
 |  | uint8_t * | msg,
 |  | int | msg_length,
 |  | agile_modbus_msg_type_t | msg_type
 | ) |  |
static

检验接收数据正确性

参数
ctx | modbus 句柄
msg | 消息指针
msg_length | 消息长度
msg_type | 消息类型
返回
>0:正确，modbus 数据帧长度; 其他:异常

在文件 agile_modbus.c 第 224 行定义.

函数调用图:
这是这个函数的调用关系图:


Agile Modbus: Common Exported Functions

函数
Common Exported Functions
Common
Common Exported Functions 的协作图:

函数

void | agile_modbus_common_init (agile_modbus_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
初始化 modbus 句柄 更多...
int | agile_modbus_set_slave (agile_modbus_t *ctx, int slave)
设置地址 更多...
void | agile_modbus_set_compute_meta_length_after_function_cb (agile_modbus_t *ctx, uint8_t(*cb)(agile_modbus_t *ctx, int function, agile_modbus_msg_type_t msg_type))
设置 modbus 对象的计算功能码后要接收的数据元长度回调函数 更多...
void | agile_modbus_set_compute_data_length_after_meta_cb (agile_modbus_t *ctx, int(*cb)(agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type))
设置 modbus 对象的计算数据元之后要接收的数据长度回调函数 更多...
int | agile_modbus_receive_judge (agile_modbus_t *ctx, int msg_length, agile_modbus_msg_type_t msg_type)
校验接收数据正确性 更多...

详细描述

函数说明

◆ agile_modbus_common_init()

void agile_modbus_common_init | ( | agile_modbus_t * | ctx,
 |  | uint8_t * | send_buf,
 |  | int | send_bufsz,
 |  | uint8_t * | read_buf,
 |  | int | read_bufsz
 | ) |  |

初始化 modbus 句柄

参数
ctx | modbus 句柄
send_buf | 发送缓冲区
send_bufsz | 发送缓冲区大小
read_buf | 接收缓冲区
read_bufsz | 接收缓冲区大小

在文件 agile_modbus.c 第 257 行定义.

这是这个函数的调用关系图:

◆ agile_modbus_set_slave()

int agile_modbus_set_slave | ( | agile_modbus_t * | ctx,
 |  | int | slave
 | ) |  |

设置地址

参数
ctx | modbus 句柄
slave | 地址
返回
0:成功

在文件 agile_modbus.c 第 273 行定义.

◆ agile_modbus_set_compute_meta_length_after_function_cb()

void agile_modbus_set_compute_meta_length_after_function_cb | ( | agile_modbus_t * | ctx,
 |  | uint8_t(*)(agile_modbus_t *ctx, int function, agile_modbus_msg_type_t msg_type) | cb
 | ) |  |

设置 modbus 对象的计算功能码后要接收的数据元长度回调函数

参数
ctx | modbus 句柄
cb | 计算功能码后要接收的数据元长度回调函数
参见
agile_modbus_compute_meta_length_after_function

在文件 agile_modbus.c 第 284 行定义.

◆ agile_modbus_set_compute_data_length_after_meta_cb()

void agile_modbus_set_compute_data_length_after_meta_cb | ( | agile_modbus_t * | ctx,
 |  | int(*)(agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type) | cb
 | ) |  |

设置 modbus 对象的计算数据元之后要接收的数据长度回调函数

参数
ctx | modbus 句柄
cb | 计算数据元之后要接收的数据长度回调函数
参见
agile_modbus_compute_data_length_after_meta

在文件 agile_modbus.c 第 297 行定义.

◆ agile_modbus_receive_judge()

int agile_modbus_receive_judge | ( | agile_modbus_t * | ctx,
 |  | int | msg_length,
 |  | agile_modbus_msg_type_t | msg_type
 | ) |  |

校验接收数据正确性

注解
该 API 返回的是 modbus 数据帧长度，比如 8 个字节的 modbus 数据帧 + 2 个字节的脏数据，返回 8
参数
ctx | modbus 句柄
msg_length | 接收数据长度
msg_type | 消息类型
返回
>0:正确，modbus 数据帧长度; 其他:异常

在文件 agile_modbus.c 第 312 行定义.

函数调用图:
这是这个函数的调用关系图:


Agile Modbus: Modbus Master

模块
Modbus Master
Common
Modbus Master 的协作图:

模块

Master Private Functions
Master Common Operation Functions
常用 modbus 主机操作函数
Master Raw Operation Functions

详细描述

制作者 doxygen 1.9.2


Agile Modbus: Master Private Functions

函数
Master Private Functions
Common » Modbus Master
Master Private Functions 的协作图:

函数

static int | agile_modbus_compute_response_length_from_request (agile_modbus_t *ctx, uint8_t *req)
计算预期响应数据长度 更多...
static int | agile_modbus_check_confirmation (agile_modbus_t *ctx, uint8_t *req, uint8_t *rsp, int rsp_length)
检查确认从机响应的数据 更多...

详细描述

函数说明

◆ agile_modbus_compute_response_length_from_request()

static int agile_modbus_compute_response_length_from_request | ( | agile_modbus_t * | ctx,
 |  | uint8_t * | req
 | ) |  |
static

计算预期响应数据长度

注解
如果是特殊的功能码，返回 AGILE_MODBUS_MSG_LENGTH_UNDEFINED ，但这不代表异常。 agile_modbus_check_confirmation 调用该 API 处理时认为 AGILE_MODBUS_MSG_LENGTH_UNDEFINED 返回值也是有效的。
参数
ctx | modbus 句柄
req | 请求数据指针
返回
预期响应数据长度

在文件 agile_modbus.c 第 342 行定义.

这是这个函数的调用关系图:

◆ agile_modbus_check_confirmation()

static int agile_modbus_check_confirmation | ( | agile_modbus_t * | ctx,
 |  | uint8_t * | req,
 |  | uint8_t * | rsp,
 |  | int | rsp_length
 | ) |  |
static

检查确认从机响应的数据

参数
ctx | modbus 句柄
req | 请求数据指针
rsp | 响应数据指针
rsp_length | 响应数据长度
返回
>=0:对应功能码响应对象的长度(如 03 功能码，值代表寄存器个数); 其他:异常 (-1：报文错误；其他：可根据 -128 - $返回值 得到异常码)

在文件 agile_modbus.c 第 391 行定义.

函数调用图:
这是这个函数的调用关系图:


Agile Modbus: Master Common Operation Functions

函数
Master Common Operation Functions
Common » Modbus Master

常用 modbus 主机操作函数 更多...

Master Common Operation Functions 的协作图:

函数

int | agile_modbus_serialize_read_bits (agile_modbus_t *ctx, int addr, int nb)
int | agile_modbus_deserialize_read_bits (agile_modbus_t *ctx, int msg_length, uint8_t *dest)
int | agile_modbus_serialize_read_input_bits (agile_modbus_t *ctx, int addr, int nb)
int | agile_modbus_deserialize_read_input_bits (agile_modbus_t *ctx, int msg_length, uint8_t *dest)
int | agile_modbus_serialize_read_registers (agile_modbus_t *ctx, int addr, int nb)
int | agile_modbus_deserialize_read_registers (agile_modbus_t *ctx, int msg_length, uint16_t *dest)
int | agile_modbus_serialize_read_input_registers (agile_modbus_t *ctx, int addr, int nb)
int | agile_modbus_deserialize_read_input_registers (agile_modbus_t *ctx, int msg_length, uint16_t *dest)
int | agile_modbus_serialize_write_bit (agile_modbus_t *ctx, int addr, int status)
int | agile_modbus_deserialize_write_bit (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_write_register (agile_modbus_t *ctx, int addr, const uint16_t value)
int | agile_modbus_deserialize_write_register (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_write_bits (agile_modbus_t *ctx, int addr, int nb, const uint8_t *src)
int | agile_modbus_deserialize_write_bits (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_write_registers (agile_modbus_t *ctx, int addr, int nb, const uint16_t *src)
int | agile_modbus_deserialize_write_registers (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_mask_write_register (agile_modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask)
int | agile_modbus_deserialize_mask_write_register (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_write_and_read_registers (agile_modbus_t *ctx, int write_addr, int write_nb, const uint16_t *src, int read_addr, int read_nb)
int | agile_modbus_deserialize_write_and_read_registers (agile_modbus_t *ctx, int msg_length, uint16_t *dest)
int | agile_modbus_serialize_report_slave_id (agile_modbus_t *ctx)
int | agile_modbus_deserialize_report_slave_id (agile_modbus_t *ctx, int msg_length, int max_dest, uint8_t *dest)

详细描述

常用 modbus 主机操作函数

   API 形式如下：
   - agile_modbus_serialize_xxx    打包请求数据
   返回值:
       >0:请求数据长度
       其他:异常

   - agile_modbus_deserialize_xxx  解析响应数据
   返回值:
       >=0:对应功能码响应对象的长度(如 03 功能码，值代表寄存器个数)
       其他:异常 (-1：报文错误；其他：可根据 `-128 - $返回值` 得到异常码)

函数说明

◆ agile_modbus_serialize_read_bits()

int agile_modbus_serialize_read_bits | ( | agile_modbus_t * | ctx,
 |  | int | addr,
 |  | int | nb
 | ) |  |

在文件 agile_modbus.c 第 493 行定义.

◆ agile_modbus_deserialize_read_bits()

int agile_modbus_deserialize_read_bits | ( | agile_modbus_t * | ctx,
 |  | int | msg_length,
 |  | uint8_t * | dest
 | ) |  |

在文件 agile_modbus.c 第 509 行定义.

函数调用图:

◆ agile_modbus_serialize_read_input_bits()

int agile_modbus_serialize_read_input_bits | ( | agile_modbus_t * | ctx,
 |  | int | addr,
 |  | int | nb
 | ) |  |

在文件 agile_modbus.c 第 548 行定义.

◆ agile_modbus_deserialize_read_input_bits()

int agile_modbus_deserialize_read_input_bits | ( | agile_modbus_t * | ctx,
 |  | int | msg_length,
 |  | uint8_t * | dest
 | ) |  |

在文件 agile_modbus.c 第 564 行定义.

函数调用图:

◆ agile_modbus_serialize_read_registers()

int agile_modbus_serialize_read_registers | ( | agile_modbus_t * | ctx,
 |  | int | addr,
 |  | int | nb
 | ) |  |

在文件 agile_modbus.c 第 603 行定义.

◆ agile_modbus_deserialize_read_registers()

int agile_modbus_deserialize_read_registers | ( | agile_modbus_t * | ctx,
 |  | int | msg_length,
 |  | uint16_t * | dest
 | ) |  |

在文件 agile_modbus.c 第 619 行定义.

函数调用图:

◆ agile_modbus_serialize_read_input_registers()

int agile_modbus_serialize_read_input_registers | ( | agile_modbus_t * | ctx,
 |  | int | addr,
 |  | int | nb
 | ) |  |

在文件 agile_modbus.c 第 647 行定义.

◆ agile_modbus_deserialize_read_input_registers()

int agile_modbus_deserialize_read_input_registers | ( | agile_modbus_t * | ctx,
 |  | int | msg_length,
 |  | uint16_t * | dest
 | ) |  |

在文件 agile_modbus.c 第 663 行定义.

函数调用图:

◆ agile_modbus_serialize_write_bit()

int agile_modbus_serialize_write_bit | ( | agile_modbus_t * | ctx,
 |  | int | addr,
 |  | int | status
 | ) |  |

在文件 agile_modbus.c 第 691 行定义.

◆ agile_modbus_deserialize_write_bit()

int agile_modbus_deserialize_write_bit | ( | agile_modbus_t * | ctx,
 |  | int | msg_length
 | ) |  |

在文件 agile_modbus.c 第 704 行定义.

函数调用图:

◆ agile_modbus_serialize_write_register()

int agile_modbus_serialize_write_register | ( | agile_modbus_t * | ctx,
 |  | int | addr,
 |  | const uint16_t | value
 | ) |  |

在文件 agile_modbus.c 第 721 行定义.

◆ agile_modbus_deserialize_write_register()

int agile_modbus_deserialize_write_register | ( | agile_modbus_t * | ctx,
 |  | int | msg_length
 | ) |  |

在文件 agile_modbus.c 第 734 行定义.

函数调用图:

◆ agile_modbus_serialize_write_bits()

int agile_modbus_serialize_write_bits | ( | agile_modbus_t * | ctx,
 |  | int | addr,
 |  | int | nb,
 |  | const uint8_t * | src
 | ) |  |

在文件 agile_modbus.c 第 751 行定义.

◆ agile_modbus_deserialize_write_bits()

int agile_modbus_deserialize_write_bits | ( | agile_modbus_t * | ctx,
 |  | int | msg_length
 | ) |  |

在文件 agile_modbus.c 第 796 行定义.

函数调用图:

◆ agile_modbus_serialize_write_registers()

int agile_modbus_serialize_write_registers | ( | agile_modbus_t * | ctx,
 |  | int | addr,
 |  | int | nb,
 |  | const uint16_t * | src
 | ) |  |

在文件 agile_modbus.c 第 813 行定义.

◆ agile_modbus_deserialize_write_registers()

int agile_modbus_deserialize_write_registers | ( | agile_modbus_t * | ctx,
 |  | int | msg_length
 | ) |  |

在文件 agile_modbus.c 第 844 行定义.

函数调用图:

◆ agile_modbus_serialize_mask_write_register()

int agile_modbus_serialize_mask_write_register | ( | agile_modbus_t * | ctx,
 |  | int | addr,
 |  | uint16_t | and_mask,
 |  | uint16_t | or_mask
 | ) |  |

在文件 agile_modbus.c 第 861 行定义.

◆ agile_modbus_deserialize_mask_write_register()

int agile_modbus_deserialize_mask_write_register | ( | agile_modbus_t * | ctx,
 |  | int | msg_length
 | ) |  |

在文件 agile_modbus.c 第 883 行定义.

函数调用图:

◆ agile_modbus_serialize_write_and_read_registers()

int agile_modbus_serialize_write_and_read_registers | ( | agile_modbus_t * | ctx,
 |  | int | write_addr,
 |  | int | write_nb,
 |  | const uint16_t * | src,
 |  | int | read_addr,
 |  | int | read_nb
 | ) |  |

在文件 agile_modbus.c 第 900 行定义.

◆ agile_modbus_deserialize_write_and_read_registers()

int agile_modbus_deserialize_write_and_read_registers | ( | agile_modbus_t * | ctx,
 |  | int | msg_length,
 |  | uint16_t * | dest
 | ) |  |

在文件 agile_modbus.c 第 941 行定义.

函数调用图:

◆ agile_modbus_serialize_report_slave_id()

int agile_modbus_serialize_report_slave_id ( agile_modbus_t * ctx )

在文件 agile_modbus.c 第 969 行定义.

◆ agile_modbus_deserialize_report_slave_id()

int agile_modbus_deserialize_report_slave_id | ( | agile_modbus_t * | ctx,
 |  | int | msg_length,
 |  | int | max_dest,
 |  | uint8_t * | dest
 | ) |  |

在文件 agile_modbus.c 第 984 行定义.

函数调用图:


Agile Modbus: Master Raw Operation Functions

函数
Master Raw Operation Functions
Common » Modbus Master
Master Raw Operation Functions 的协作图:

函数

int | agile_modbus_serialize_raw_request (agile_modbus_t *ctx, const uint8_t *raw_req, int raw_req_length)
将原始数据打包成请求报文 更多...
int | agile_modbus_deserialize_raw_response (agile_modbus_t *ctx, int msg_length)
解析响应原始数据 更多...

详细描述

函数说明

◆ agile_modbus_serialize_raw_request()

int agile_modbus_serialize_raw_request | ( | agile_modbus_t * | ctx,
 |  | const uint8_t * | raw_req,
 |  | int | raw_req_length
 | ) |  |

将原始数据打包成请求报文

参数
ctx | modbus 句柄
raw_req | 原始报文(PDU + Slave address)
raw_req_length | 原始报文长度
返回
>0:请求数据长度; 其他:异常

在文件 agile_modbus.c 第 1031 行定义.

◆ agile_modbus_deserialize_raw_response()

int agile_modbus_deserialize_raw_response | ( | agile_modbus_t * | ctx,
 |  | int | msg_length
 | ) |  |

解析响应原始数据

参数
ctx | modbus 句柄
msg_length | 接收数据长度
返回
>=0:对应功能码响应对象的长度(如 03 功能码，值代表寄存器个数); 其他:异常 (-1：报文错误；其他：可根据 -128 - $返回值 得到异常码)

在文件 agile_modbus.c 第 1073 行定义.

函数调用图:


Agile Modbus: Modbus Slave

模块
Modbus Slave
Common
Modbus Slave 的协作图:

模块

Slave Exported Types
Slave Private Functions
Slave Operation Functions

详细描述

制作者 doxygen 1.9.2


Agile Modbus: Slave Exported Types

结构体 | 类型定义
Slave Exported Types
Common » Modbus Slave
Slave Exported Types 的协作图:

结构体

struct agile_modbus_slave_info
Agile Modbus 从机信息结构体 更多...

类型定义

typedef int(* agile_modbus_slave_callback_t) (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data)
从机回调函数 更多...

详细描述

类型定义说明

◆ agile_modbus_slave_callback_t

typedef int(* agile_modbus_slave_callback_t) (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data)

从机回调函数

参数
ctx | modbus 句柄
slave_info | 从机信息体
data | 私有数据
返回
=0:正常; <0:异常 (-AGILE_MODBUS_EXCEPTION_UNKNOW(-255): 未知异常，从机不会打包响应数据) (其他负数异常码: 从机会打包异常响应数据)

在文件 agile_modbus.h 第 251 行定义.


Agile Modbus: agile_modbus_slave_info结构体 参考

成员变量
agile_modbus_slave_info结构体 参考
Common » Modbus Slave » Slave Exported Types

Agile Modbus 从机信息结构体 更多...

#include <agile_modbus.h>

agile_modbus_slave_info 的协作图:
[图例]

成员变量

agile_modbus_sft_t * sft
sft 结构体指针 更多...
int * | rsp_length
响应数据长度指针 更多...
int | address
寄存器地址 更多...
int | nb
数目 更多...
uint8_t * | buf
不同功能码需要使用的数据域 更多...
int | send_index
发送缓冲区当前索引 更多...

详细描述

Agile Modbus 从机信息结构体

在文件 agile_modbus.h 第 232 行定义.

结构体成员变量说明

◆ sft

agile_modbus_sft_t* agile_modbus_slave_info::sft

sft 结构体指针

在文件 agile_modbus.h 第 233 行定义.

◆ rsp_length

int* agile_modbus_slave_info::rsp_length

响应数据长度指针

在文件 agile_modbus.h 第 234 行定义.

◆ address

int agile_modbus_slave_info::address

寄存器地址

在文件 agile_modbus.h 第 235 行定义.

◆ nb

int agile_modbus_slave_info::nb

数目

在文件 agile_modbus.h 第 236 行定义.

◆ buf

uint8_t* agile_modbus_slave_info::buf

不同功能码需要使用的数据域

在文件 agile_modbus.h 第 237 行定义.

◆ send_index

int agile_modbus_slave_info::send_index

发送缓冲区当前索引

在文件 agile_modbus.h 第 238 行定义.

该结构体的文档由以下文件生成:
  • C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/inc/agile_modbus.h


Agile Modbus: Slave Private Functions

函数
Slave Private Functions
Common » Modbus Slave
Slave Private Functions 的协作图:

函数

static int agile_modbus_serialize_response_exception (agile_modbus_t *ctx, agile_modbus_sft_t *sft, int exception_code)
打包异常响应数据 更多...

详细描述

函数说明

◆ agile_modbus_serialize_response_exception()

static int agile_modbus_serialize_response_exception | ( | agile_modbus_t * | ctx,
 |  | agile_modbus_sft_t * | sft,
 |  | int | exception_code
 | ) |  |
static

打包异常响应数据

参数
ctx | modbus 句柄
sft | modbus 信息头
exception_code | 异常码
返回
响应数据长度

在文件 agile_modbus.c 第 1113 行定义.

这是这个函数的调用关系图:


Agile Modbus: Slave Operation Functions

函数
Slave Operation Functions
Common » Modbus Slave
Slave Operation Functions 的协作图:

函数

int | agile_modbus_slave_handle (agile_modbus_t *ctx, int msg_length, uint8_t slave_strict, agile_modbus_slave_callback_t slave_cb, const void *slave_data, int *frame_length)
从机数据处理 更多...
void | agile_modbus_slave_io_set (uint8_t *buf, int index, int status)
从机 IO 设置 更多...
uint8_t | agile_modbus_slave_io_get (uint8_t *buf, int index)
读取从机 IO 状态 更多...
void | agile_modbus_slave_register_set (uint8_t *buf, int index, uint16_t data)
从机寄存器设置 更多...
uint16_t | agile_modbus_slave_register_get (uint8_t *buf, int index)
读取从机寄存器数据 更多...

详细描述

函数说明

◆ agile_modbus_slave_handle()

int agile_modbus_slave_handle | ( | agile_modbus_t * | ctx,
 |  | int | msg_length,
 |  | uint8_t | slave_strict,
 |  | agile_modbus_slave_callback_t | slave_cb,
 |  | const void * | slave_data,
 |  | int * | frame_length
 | ) |  |

从机数据处理

参数
ctx | modbus 句柄
msg_length | 接收数据长度
slave_strict 从机地址严格检查标志
  • 0: 不比对从机地址
  • 1: 比对从机地址
slave_cb | 从机回调函数
slave_data | 从机回调函数私有数据
frame_length | 存放 modbus 数据帧长度
返回
>=0:要响应的数据长度; 其他:异常

在文件 agile_modbus.c 第 1203 行定义.

函数调用图:

◆ agile_modbus_slave_io_set()

void agile_modbus_slave_io_set | ( | uint8_t * | buf,
 |  | int | index,
 |  | int | status
 | ) |  |

从机 IO 设置

参数
buf | 存放 IO 数据区
index | IO 索引(第几个 IO)
status | IO 状态

在文件 agile_modbus.c 第 1139 行定义.

这是这个函数的调用关系图:

◆ agile_modbus_slave_io_get()

uint8_t agile_modbus_slave_io_get | ( | uint8_t * | buf,
 |  | int | index
 | ) |  |

读取从机 IO 状态

参数
buf | IO 数据区域
index | IO 索引(第几个 IO)
返回
IO 状态(1/0)

在文件 agile_modbus.c 第 1156 行定义.

这是这个函数的调用关系图:

◆ agile_modbus_slave_register_set()

void agile_modbus_slave_register_set | ( | uint8_t * | buf,
 |  | int | index,
 |  | uint16_t | data
 | ) |  |

从机寄存器设置

参数
buf | 存放数据区
index | 寄存器索引(第几个寄存器)
data | 寄存器数据

在文件 agile_modbus.c 第 1172 行定义.

这是这个函数的调用关系图:

◆ agile_modbus_slave_register_get()

uint16_t agile_modbus_slave_register_get | ( | uint8_t * | buf,
 |  | int | index
 | ) |  |

读取从机寄存器数据

参数
buf | 寄存器数据区域
index | 寄存器索引(第几个寄存器)
返回
寄存器数据

在文件 agile_modbus.c 第 1184 行定义.

这是这个函数的调用关系图:


Agile Modbus: RTU

模块
RTU
RTU 的协作图:

模块

RTU Exported Constants
RTU Exported Types
RTU Private Constants
RTU Private Functions
RTU Exported Functions

详细描述

制作者 doxygen 1.9.2


Agile Modbus: RTU Exported Constants

宏定义
RTU Exported Constants
RTU
RTU Exported Constants 的协作图:

宏定义

#define | AGILE_MODBUS_RTU_HEADER_LENGTH 1
#define | AGILE_MODBUS_RTU_PRESET_REQ_LENGTH 6
#define | AGILE_MODBUS_RTU_PRESET_RSP_LENGTH 2
#define | AGILE_MODBUS_RTU_CHECKSUM_LENGTH 2
#define | AGILE_MODBUS_RTU_MAX_ADU_LENGTH 256

详细描述

宏定义说明

◆ AGILE_MODBUS_RTU_HEADER_LENGTH

#define AGILE_MODBUS_RTU_HEADER_LENGTH 1

在文件 agile_modbus_rtu.h 第 30 行定义.

◆ AGILE_MODBUS_RTU_PRESET_REQ_LENGTH

#define AGILE_MODBUS_RTU_PRESET_REQ_LENGTH 6

在文件 agile_modbus_rtu.h 第 31 行定义.

◆ AGILE_MODBUS_RTU_PRESET_RSP_LENGTH

#define AGILE_MODBUS_RTU_PRESET_RSP_LENGTH 2

在文件 agile_modbus_rtu.h 第 32 行定义.

◆ AGILE_MODBUS_RTU_CHECKSUM_LENGTH

#define AGILE_MODBUS_RTU_CHECKSUM_LENGTH 2

在文件 agile_modbus_rtu.h 第 34 行定义.

◆ AGILE_MODBUS_RTU_MAX_ADU_LENGTH

#define AGILE_MODBUS_RTU_MAX_ADU_LENGTH 256
   Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5
   RS232 / RS485 ADU = 253 bytes + slave (1 byte) + CRC (2 bytes) = 256 bytes

在文件 agile_modbus_rtu.h 第 43 行定义.


Agile Modbus: RTU Exported Types

结构体 | 类型定义
RTU Exported Types
RTU
RTU Exported Types 的协作图:

结构体

struct agile_modbus_rtu
RTU 结构体 更多...

类型定义

typedef struct agile_modbus_rtu agile_modbus_rtu_t
RTU 结构体 更多...

详细描述

类型定义说明

◆ agile_modbus_rtu_t

typedef struct agile_modbus_rtu agile_modbus_rtu_t

RTU 结构体


Agile Modbus: agile_modbus_rtu结构体 参考

成员变量
agile_modbus_rtu结构体 参考
RTU » RTU Exported Types

RTU 结构体 更多...

#include <agile_modbus_rtu.h>

agile_modbus_rtu 的协作图:
[图例]

成员变量

agile_modbus_t _ctx
modbus 句柄 更多...

详细描述

RTU 结构体

在文件 agile_modbus_rtu.h 第 55 行定义.

结构体成员变量说明

◆ _ctx

agile_modbus_t agile_modbus_rtu::_ctx

modbus 句柄

在文件 agile_modbus_rtu.h 第 56 行定义.

该结构体的文档由以下文件生成:
  • C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/inc/agile_modbus_rtu.h


Agile Modbus: RTU Private Constants

变量
RTU Private Constants
RTU
RTU Private Constants 的协作图:

变量

static const uint8_t | _table_crc_hi []
Table of CRC values for high-order byte 更多...
static const uint8_t | _table_crc_lo []
Table of CRC values for low-order byte 更多...
static const agile_modbus_backend_t | agile_modbus_rtu_backend
RTU 后端接口 更多...

详细描述

变量说明

◆ _table_crc_hi

const uint8_t _table_crc_hi[]
static
初始值:
=
{
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40}

Table of CRC values for high-order byte

在文件 agile_modbus_rtu.c 第 25 行定义.

◆ _table_crc_lo

const uint8_t _table_crc_lo[]
static
初始值:
=
{
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06,
0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD,
0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4,
0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3,
0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29,
0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED,
0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60,
0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67,
0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E,
0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71,
0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B,
0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B,
0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42,
0x43, 0x83, 0x41, 0x81, 0x80, 0x40}

Table of CRC values for low-order byte

在文件 agile_modbus_rtu.c 第 55 行定义.

◆ agile_modbus_rtu_backend

const agile_modbus_backend_t agile_modbus_rtu_backend
static
初始值:
=
{
AGILE_MODBUS_BACKEND_TYPE_RTU,
AGILE_MODBUS_RTU_HEADER_LENGTH,
AGILE_MODBUS_RTU_CHECKSUM_LENGTH,
AGILE_MODBUS_RTU_MAX_ADU_LENGTH,
agile_modbus_rtu_set_slave,
agile_modbus_rtu_build_request_basis,
agile_modbus_rtu_build_response_basis,
agile_modbus_rtu_prepare_response_tid,
agile_modbus_rtu_send_msg_pre,
agile_modbus_rtu_check_integrity,
agile_modbus_rtu_pre_check_confirmation}
AGILE_MODBUS_BACKEND_TYPE_RTU
@ AGILE_MODBUS_BACKEND_TYPE_RTU
RTU
Definition: agile_modbus.h:151
AGILE_MODBUS_RTU_HEADER_LENGTH
#define AGILE_MODBUS_RTU_HEADER_LENGTH
Definition: agile_modbus_rtu.h:30
AGILE_MODBUS_RTU_MAX_ADU_LENGTH
#define AGILE_MODBUS_RTU_MAX_ADU_LENGTH
Definition: agile_modbus_rtu.h:43
AGILE_MODBUS_RTU_CHECKSUM_LENGTH
#define AGILE_MODBUS_RTU_CHECKSUM_LENGTH
Definition: agile_modbus_rtu.h:34
agile_modbus_rtu_build_response_basis
static int agile_modbus_rtu_build_response_basis(agile_modbus_sft_t *sft, uint8_t *rsp)
RTU 构建基础响应报文接口(头部报文)
Definition: agile_modbus_rtu.c:154
agile_modbus_rtu_send_msg_pre
static int agile_modbus_rtu_send_msg_pre(uint8_t *req, int req_length)
RTU 预发送数据接口
Definition: agile_modbus_rtu.c:183
agile_modbus_rtu_build_request_basis
static int agile_modbus_rtu_build_request_basis(agile_modbus_t *ctx, int function, int addr, int nb, uint8_t *req)
RTU 构建基础请求报文接口(头部报文)
Definition: agile_modbus_rtu.c:134
agile_modbus_rtu_set_slave
static int agile_modbus_rtu_set_slave(agile_modbus_t *ctx, int slave)
RTU 设置地址接口
Definition: agile_modbus_rtu.c:119
agile_modbus_rtu_check_integrity
static int agile_modbus_rtu_check_integrity(agile_modbus_t *ctx, uint8_t *msg, const int msg_length)
RTU 检查接收数据完整性接口(CRC16 对比)
Definition: agile_modbus_rtu.c:199
agile_modbus_rtu_pre_check_confirmation
static int agile_modbus_rtu_pre_check_confirmation(agile_modbus_t *ctx, const uint8_t *req, const uint8_t *rsp, int rsp_length)
RTU 预检查确认接口(请求响应地址对比)
Definition: agile_modbus_rtu.c:223
agile_modbus_rtu_prepare_response_tid
static int agile_modbus_rtu_prepare_response_tid(const uint8_t *req, int *req_length)
RTU 准备响应接口
Definition: agile_modbus_rtu.c:169

RTU 后端接口

在文件 agile_modbus_rtu.c 第 245 行定义.


Agile Modbus: RTU Private Functions

函数
RTU Private Functions
RTU
RTU Private Functions 的协作图:

函数

static uint16_t | agile_modbus_rtu_crc16 (uint8_t *buffer, uint16_t buffer_length)
RTU CRC16 计算 更多...
static int | agile_modbus_rtu_set_slave (agile_modbus_t *ctx, int slave)
RTU 设置地址接口 更多...
static int | agile_modbus_rtu_build_request_basis (agile_modbus_t *ctx, int function, int addr, int nb, uint8_t *req)
RTU 构建基础请求报文接口(头部报文) 更多...
static int | agile_modbus_rtu_build_response_basis (agile_modbus_sft_t *sft, uint8_t *rsp)
RTU 构建基础响应报文接口(头部报文) 更多...
static int | agile_modbus_rtu_prepare_response_tid (const uint8_t *req, int *req_length)
RTU 准备响应接口 更多...
static int | agile_modbus_rtu_send_msg_pre (uint8_t *req, int req_length)
RTU 预发送数据接口 更多...
static int | agile_modbus_rtu_check_integrity (agile_modbus_t *ctx, uint8_t *msg, const int msg_length)
RTU 检查接收数据完整性接口(CRC16 对比) 更多...
static int | agile_modbus_rtu_pre_check_confirmation (agile_modbus_t *ctx, const uint8_t *req, const uint8_t *rsp, int rsp_length)
RTU 预检查确认接口(请求响应地址对比) 更多...

详细描述

函数说明

◆ agile_modbus_rtu_crc16()

static uint16_t agile_modbus_rtu_crc16 | ( | uint8_t * | buffer,
 |  | uint16_t | buffer_length
 | ) |  |
static

RTU CRC16 计算

参数
buffer | 数据指针
buffer_length | 数据长度
返回
CRC16 值

在文件 agile_modbus_rtu.c 第 97 行定义.

这是这个函数的调用关系图:

◆ agile_modbus_rtu_set_slave()

static int agile_modbus_rtu_set_slave | ( | agile_modbus_t * | ctx,
 |  | int | slave
 | ) |  |
static

RTU 设置地址接口

参数
ctx | modbus 句柄
slave | 从机地址
返回
0:成功

在文件 agile_modbus_rtu.c 第 119 行定义.

◆ agile_modbus_rtu_build_request_basis()

static int agile_modbus_rtu_build_request_basis | ( | agile_modbus_t * | ctx,
 |  | int | function,
 |  | int | addr,
 |  | int | nb,
 |  | uint8_t * | req
 | ) |  |
static

RTU 构建基础请求报文接口(头部报文)

参数
ctx | modbus 句柄
function | 功能码
addr | 寄存器地址
nb | 寄存器数目
req | 数据存放指针
返回
数据长度

在文件 agile_modbus_rtu.c 第 134 行定义.

◆ agile_modbus_rtu_build_response_basis()

static int agile_modbus_rtu_build_response_basis | ( | agile_modbus_sft_t * | sft,
 |  | uint8_t * | rsp
 | ) |  |
static

RTU 构建基础响应报文接口(头部报文)

参数
sft | modbus 头部参数结构体指针
rsp | 数据存放指针
返回
数据长度

在文件 agile_modbus_rtu.c 第 154 行定义.

◆ agile_modbus_rtu_prepare_response_tid()

static int agile_modbus_rtu_prepare_response_tid | ( | const uint8_t * | req,
 |  | int * | req_length
 | ) |  |
static

RTU 准备响应接口

注解
该 API 会将 req_length 自动减去 AGILE_MODBUS_RTU_CHECKSUM_LENGTH 长度
参数
req | 请求数据指针
req_length | 请求数据长度
返回
0 (RTU 没有事务标识符)

在文件 agile_modbus_rtu.c 第 169 行定义.

◆ agile_modbus_rtu_send_msg_pre()

static int agile_modbus_rtu_send_msg_pre | ( | uint8_t * | req,
 |  | int | req_length
 | ) |  |
static

RTU 预发送数据接口

注解
该 API 会计算 CRC16 并自动填入尾部
参数
req | 数据存放指针
req_length | 已有数据长度
返回
数据长度

在文件 agile_modbus_rtu.c 第 183 行定义.

函数调用图:

◆ agile_modbus_rtu_check_integrity()

static int agile_modbus_rtu_check_integrity | ( | agile_modbus_t * | ctx,
 |  | uint8_t * | msg,
 |  | const int | msg_length
 | ) |  |
static

RTU 检查接收数据完整性接口(CRC16 对比)

参数
ctx | modbus 句柄
msg | 接收数据指针
msg_length | 有效数据长度
返回
>0:有效数据长度; 其他:异常

在文件 agile_modbus_rtu.c 第 199 行定义.

函数调用图:

◆ agile_modbus_rtu_pre_check_confirmation()

static int agile_modbus_rtu_pre_check_confirmation | ( | agile_modbus_t * | ctx,
 |  | const uint8_t * | req,
 |  | const uint8_t * | rsp,
 |  | int | rsp_length
 | ) |  |
static

RTU 预检查确认接口(请求响应地址对比)

注解
如果请求地址是广播地址0，返回成功
参数
ctx | modbus 句柄
req | 请求数据指针
rsp | 响应数据指针
rsp_length | 响应数据长度
返回
0:成功; 其他:异常

在文件 agile_modbus_rtu.c 第 223 行定义.


Agile Modbus: RTU Exported Functions

函数
RTU Exported Functions
RTU
RTU Exported Functions 的协作图:

函数

int agile_modbus_rtu_init (agile_modbus_rtu_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
RTU 初始化 更多...

详细描述

函数说明

◆ agile_modbus_rtu_init()

int agile_modbus_rtu_init | ( | agile_modbus_rtu_t * | ctx,
 |  | uint8_t * | send_buf,
 |  | int | send_bufsz,
 |  | uint8_t * | read_buf,
 |  | int | read_bufsz
 | ) |  |

RTU 初始化

参数
ctx | RTU 句柄
send_buf | 发送缓冲区
send_bufsz | 发送缓冲区大小
read_buf | 接收缓冲区
read_bufsz | 接收缓冲区大小
返回
0:成功

在文件 agile_modbus_rtu.c 第 276 行定义.

函数调用图:


Agile Modbus: TCP

模块
TCP
TCP 的协作图:

模块

TCP Exported Constants
TCP Exported Types
TCP Private Functions
TCP Private Constants
TCP Exported Functions

详细描述

制作者 doxygen 1.9.2


Agile Modbus: TCP Exported Constants

宏定义
TCP Exported Constants
TCP
TCP Exported Constants 的协作图:

宏定义

#define | AGILE_MODBUS_TCP_HEADER_LENGTH 7
#define | AGILE_MODBUS_TCP_PRESET_REQ_LENGTH 12
#define | AGILE_MODBUS_TCP_PRESET_RSP_LENGTH 8
#define | AGILE_MODBUS_TCP_CHECKSUM_LENGTH 0
#define | AGILE_MODBUS_TCP_MAX_ADU_LENGTH 260

详细描述

宏定义说明

◆ AGILE_MODBUS_TCP_HEADER_LENGTH

#define AGILE_MODBUS_TCP_HEADER_LENGTH 7

在文件 agile_modbus_tcp.h 第 30 行定义.

◆ AGILE_MODBUS_TCP_PRESET_REQ_LENGTH

#define AGILE_MODBUS_TCP_PRESET_REQ_LENGTH 12

在文件 agile_modbus_tcp.h 第 31 行定义.

◆ AGILE_MODBUS_TCP_PRESET_RSP_LENGTH

#define AGILE_MODBUS_TCP_PRESET_RSP_LENGTH 8

在文件 agile_modbus_tcp.h 第 32 行定义.

◆ AGILE_MODBUS_TCP_CHECKSUM_LENGTH

#define AGILE_MODBUS_TCP_CHECKSUM_LENGTH 0

在文件 agile_modbus_tcp.h 第 34 行定义.

◆ AGILE_MODBUS_TCP_MAX_ADU_LENGTH

#define AGILE_MODBUS_TCP_MAX_ADU_LENGTH 260
   Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5
   TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes

在文件 agile_modbus_tcp.h 第 43 行定义.


Agile Modbus: TCP Exported Types

结构体 | 类型定义
TCP Exported Types
TCP
TCP Exported Types 的协作图:

结构体

struct agile_modbus_tcp
TCP 结构体 更多...

类型定义

typedef struct agile_modbus_tcp agile_modbus_tcp_t
TCP 结构体 更多...

详细描述

类型定义说明

◆ agile_modbus_tcp_t

typedef struct agile_modbus_tcp agile_modbus_tcp_t

TCP 结构体


Agile Modbus: agile_modbus_tcp结构体 参考

成员变量
agile_modbus_tcp结构体 参考
TCP » TCP Exported Types

TCP 结构体 更多...

#include <agile_modbus_tcp.h>

agile_modbus_tcp 的协作图:
[图例]

成员变量

agile_modbus_t _ctx
modbus 句柄 更多...
uint16_t t_id
Extract from MODBUS Messaging on TCP/IP Implementation Guide V1.0b (page 23/46): The transaction identifier is used to associate the future response with the request. 更多...

详细描述

TCP 结构体

在文件 agile_modbus_tcp.h 第 55 行定义.

结构体成员变量说明

◆ _ctx

agile_modbus_t agile_modbus_tcp::_ctx

modbus 句柄

在文件 agile_modbus_tcp.h 第 56 行定义.

◆ t_id

uint16_t agile_modbus_tcp::t_id

Extract from MODBUS Messaging on TCP/IP Implementation Guide V1.0b (page 23/46): The transaction identifier is used to associate the future response with the request.

This identifier is unique on each TCP connection.

在文件 agile_modbus_tcp.h 第 57 行定义.

该结构体的文档由以下文件生成:
  • C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/inc/agile_modbus_tcp.h


Agile Modbus: TCP Private Functions

函数
TCP Private Functions
TCP
TCP Private Functions 的协作图:

函数

static int | agile_modbus_tcp_set_slave (agile_modbus_t *ctx, int slave)
TCP 设置地址接口 更多...
static int | agile_modbus_tcp_build_request_basis (agile_modbus_t *ctx, int function, int addr, int nb, uint8_t *req)
TCP 构建基础请求报文接口(头部报文) 更多...
static int | agile_modbus_tcp_build_response_basis (agile_modbus_sft_t *sft, uint8_t *rsp)
TCP 构建基础响应报文接口(头部报文) 更多...
static int | agile_modbus_tcp_prepare_response_tid (const uint8_t *req, int *req_length)
TCP 准备响应接口 更多...
static int | agile_modbus_tcp_send_msg_pre (uint8_t *req, int req_length)
TCP 预发送数据接口(计算长度字段的值并存入) 更多...
static int | agile_modbus_tcp_check_integrity (agile_modbus_t *ctx, uint8_t *msg, const int msg_length)
TCP 检查接收数据完整性接口 更多...
static int | agile_modbus_tcp_pre_check_confirmation (agile_modbus_t *ctx, const uint8_t *req, const uint8_t *rsp, int rsp_length)
TCP 预检查确认接口(对比事务标识符和协议标识符) 更多...

详细描述

函数说明

◆ agile_modbus_tcp_set_slave()

static int agile_modbus_tcp_set_slave | ( | agile_modbus_t * | ctx,
 |  | int | slave
 | ) |  |
static

TCP 设置地址接口

参数
ctx | modbus 句柄
slave | 从机地址
返回
0:成功

在文件 agile_modbus_tcp.c 第 31 行定义.

◆ agile_modbus_tcp_build_request_basis()

static int agile_modbus_tcp_build_request_basis | ( | agile_modbus_t * | ctx,
 |  | int | function,
 |  | int | addr,
 |  | int | nb,
 |  | uint8_t * | req
 | ) |  |
static

TCP 构建基础请求报文接口(头部报文)

参数
ctx | modbus 句柄
function | 功能码
addr | 寄存器地址
nb | 寄存器数目
req | 数据存放指针
返回
数据长度

在文件 agile_modbus_tcp.c 第 46 行定义.

◆ agile_modbus_tcp_build_response_basis()

static int agile_modbus_tcp_build_response_basis | ( | agile_modbus_sft_t * | sft,
 |  | uint8_t * | rsp
 | ) |  |
static

TCP 构建基础响应报文接口(头部报文)

参数
sft | modbus 头部参数结构体指针
rsp | 数据存放指针
返回
数据长度

在文件 agile_modbus_tcp.c 第 83 行定义.

◆ agile_modbus_tcp_prepare_response_tid()

static int agile_modbus_tcp_prepare_response_tid | ( | const uint8_t * | req,
 |  | int * | req_length
 | ) |  |
static

TCP 准备响应接口

参数
req | 请求数据指针
req_length | 请求数据长度
返回
事务标识符

在文件 agile_modbus_tcp.c 第 111 行定义.

◆ agile_modbus_tcp_send_msg_pre()

static int agile_modbus_tcp_send_msg_pre | ( | uint8_t * | req,
 |  | int | req_length
 | ) |  |
static

TCP 预发送数据接口(计算长度字段的值并存入)

参数
req | 数据存放指针
req_length | 已有数据长度
返回
数据长度

在文件 agile_modbus_tcp.c 第 122 行定义.

◆ agile_modbus_tcp_check_integrity()

static int agile_modbus_tcp_check_integrity | ( | agile_modbus_t * | ctx,
 |  | uint8_t * | msg,
 |  | const int | msg_length
 | ) |  |
static

TCP 检查接收数据完整性接口

参数
ctx | modbus 句柄
msg | 接收数据指针
msg_length | 有效数据长度
返回
有效数据长度

在文件 agile_modbus_tcp.c 第 140 行定义.

◆ agile_modbus_tcp_pre_check_confirmation()

static int agile_modbus_tcp_pre_check_confirmation | ( | agile_modbus_t * | ctx,
 |  | const uint8_t * | req,
 |  | const uint8_t * | rsp,
 |  | int | rsp_length
 | ) |  |
static

TCP 预检查确认接口(对比事务标识符和协议标识符)

参数
ctx | modbus 句柄
req | 请求数据指针
rsp | 响应数据指针
rsp_length | 响应数据长度
返回
0:成功; 其他:异常

在文件 agile_modbus_tcp.c 第 153 行定义.


Agile Modbus: TCP Private Constants

变量
TCP Private Constants
TCP
TCP Private Constants 的协作图:

变量

static const agile_modbus_backend_t agile_modbus_tcp_backend
TCP 后端接口 更多...

详细描述

变量说明

◆ agile_modbus_tcp_backend

const agile_modbus_backend_t agile_modbus_tcp_backend
static
初始值:
=
{
AGILE_MODBUS_BACKEND_TYPE_TCP,
AGILE_MODBUS_TCP_HEADER_LENGTH,
AGILE_MODBUS_TCP_CHECKSUM_LENGTH,
AGILE_MODBUS_TCP_MAX_ADU_LENGTH,
agile_modbus_tcp_set_slave,
agile_modbus_tcp_build_request_basis,
agile_modbus_tcp_build_response_basis,
agile_modbus_tcp_prepare_response_tid,
agile_modbus_tcp_send_msg_pre,
agile_modbus_tcp_check_integrity,
agile_modbus_tcp_pre_check_confirmation}
AGILE_MODBUS_BACKEND_TYPE_TCP
@ AGILE_MODBUS_BACKEND_TYPE_TCP
TCP
Definition: agile_modbus.h:152
AGILE_MODBUS_TCP_CHECKSUM_LENGTH
#define AGILE_MODBUS_TCP_CHECKSUM_LENGTH
Definition: agile_modbus_tcp.h:34
AGILE_MODBUS_TCP_MAX_ADU_LENGTH
#define AGILE_MODBUS_TCP_MAX_ADU_LENGTH
Definition: agile_modbus_tcp.h:43
AGILE_MODBUS_TCP_HEADER_LENGTH
#define AGILE_MODBUS_TCP_HEADER_LENGTH
Definition: agile_modbus_tcp.h:30
agile_modbus_tcp_pre_check_confirmation
static int agile_modbus_tcp_pre_check_confirmation(agile_modbus_t *ctx, const uint8_t *req, const uint8_t *rsp, int rsp_length)
TCP 预检查确认接口(对比事务标识符和协议标识符)
Definition: agile_modbus_tcp.c:153
agile_modbus_tcp_set_slave
static int agile_modbus_tcp_set_slave(agile_modbus_t *ctx, int slave)
TCP 设置地址接口
Definition: agile_modbus_tcp.c:31
agile_modbus_tcp_check_integrity
static int agile_modbus_tcp_check_integrity(agile_modbus_t *ctx, uint8_t *msg, const int msg_length)
TCP 检查接收数据完整性接口
Definition: agile_modbus_tcp.c:140
agile_modbus_tcp_send_msg_pre
static int agile_modbus_tcp_send_msg_pre(uint8_t *req, int req_length)
TCP 预发送数据接口(计算长度字段的值并存入)
Definition: agile_modbus_tcp.c:122
agile_modbus_tcp_build_request_basis
static int agile_modbus_tcp_build_request_basis(agile_modbus_t *ctx, int function, int addr, int nb, uint8_t *req)
TCP 构建基础请求报文接口(头部报文)
Definition: agile_modbus_tcp.c:46
agile_modbus_tcp_build_response_basis
static int agile_modbus_tcp_build_response_basis(agile_modbus_sft_t *sft, uint8_t *rsp)
TCP 构建基础响应报文接口(头部报文)
Definition: agile_modbus_tcp.c:83
agile_modbus_tcp_prepare_response_tid
static int agile_modbus_tcp_prepare_response_tid(const uint8_t *req, int *req_length)
TCP 准备响应接口
Definition: agile_modbus_tcp.c:111

TCP 后端接口

在文件 agile_modbus_tcp.c 第 178 行定义.


Agile Modbus: TCP Exported Functions

函数
TCP Exported Functions
TCP
TCP Exported Functions 的协作图:

函数

int agile_modbus_tcp_init (agile_modbus_tcp_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
TCP 初始化 更多...

详细描述

函数说明

◆ agile_modbus_tcp_init()

int agile_modbus_tcp_init | ( | agile_modbus_tcp_t * | ctx,
 |  | uint8_t * | send_buf,
 |  | int | send_bufsz,
 |  | uint8_t * | read_buf,
 |  | int | read_bufsz
 | ) |  |

TCP 初始化

参数
ctx | TCP 句柄
send_buf | 发送缓冲区
send_bufsz | 发送缓冲区大小
read_buf | 接收缓冲区
read_bufsz | 接收缓冲区大小
返回
0:成功

在文件 agile_modbus_tcp.c 第 209 行定义.

函数调用图:


Agile Modbus: UTIL

模块
UTIL
UTIL 的协作图:

模块

Slave Util

详细描述

制作者 doxygen 1.9.2


Agile Modbus: Slave Util

模块
Slave Util
UTIL
Slave Util 的协作图:

模块

Slave Util Private Functions
Slave Util Exported Functions
Slave Util Exported Types

详细描述

制作者 doxygen 1.9.2


Agile Modbus: Slave Util Private Functions

函数
Slave Util Private Functions
UTIL » Slave Util
Slave Util Private Functions 的协作图:

函数

static const agile_modbus_slave_util_map_t * | get_map_by_addr (const agile_modbus_slave_util_map_t *maps, int nb_maps, int address)
根据寄存器地址从映射对象数组中获取映射对象 更多...
static int | read_registers (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
读取寄存器 更多...
static int | write_registers (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
写寄存器 更多...
static int | mask_write_register (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
掩码写寄存器 更多...
static int | write_read_registers (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
写并读寄存器 更多...

详细描述

函数说明

◆ get_map_by_addr()

static const agile_modbus_slave_util_map_t * get_map_by_addr | ( | const agile_modbus_slave_util_map_t * | maps,
 |  | int | nb_maps,
 |  | int | address
 | ) |  |
static

根据寄存器地址从映射对象数组中获取映射对象

参数
maps | 映射对象数组
nb_maps | 数组数目
address | 寄存器地址
返回
!=NULL:映射对象; =NULL:失败

在文件 agile_modbus_slave_util.c 第 37 行定义.

这是这个函数的调用关系图:

◆ read_registers()

static int read_registers | ( | agile_modbus_t * | ctx,
 |  | struct agile_modbus_slave_info * | slave_info,
 |  | const agile_modbus_slave_util_t * | slave_util
 | ) |  |
static

读取寄存器

参数
ctx | modbus 句柄
slave_info | 从机信息体
slave_util | 从机功能结构体
返回
=0:正常; <0:异常 (-AGILE_MODBUS_EXCEPTION_UNKNOW(-255): 未知异常，从机不会打包响应数据) (其他负数异常码: 从机会打包异常响应数据)

在文件 agile_modbus_slave_util.c 第 58 行定义.

函数调用图:
这是这个函数的调用关系图:

◆ write_registers()

static int write_registers | ( | agile_modbus_t * | ctx,
 |  | struct agile_modbus_slave_info * | slave_info,
 |  | const agile_modbus_slave_util_t * | slave_util
 | ) |  |
static

写寄存器

参数
ctx | modbus 句柄
slave_info | 从机信息体
slave_util | 从机功能结构体
返回
=0:正常; <0:异常 (-AGILE_MODBUS_EXCEPTION_UNKNOW(-255): 未知异常，从机不会打包响应数据) (其他负数异常码: 从机会打包异常响应数据)

在文件 agile_modbus_slave_util.c 第 141 行定义.

函数调用图:
这是这个函数的调用关系图:

◆ mask_write_register()

static int mask_write_register | ( | agile_modbus_t * | ctx,
 |  | struct agile_modbus_slave_info * | slave_info,
 |  | const agile_modbus_slave_util_t * | slave_util
 | ) |  |
static

掩码写寄存器

参数
ctx | modbus 句柄
slave_info | 从机信息体
slave_util | 从机功能结构体
返回
=0:正常; <0:异常 (-AGILE_MODBUS_EXCEPTION_UNKNOW(-255): 未知异常，从机不会打包响应数据) (其他负数异常码: 从机会打包异常响应数据)

在文件 agile_modbus_slave_util.c 第 244 行定义.

函数调用图:
这是这个函数的调用关系图:

◆ write_read_registers()

static int write_read_registers | ( | agile_modbus_t * | ctx,
 |  | struct agile_modbus_slave_info * | slave_info,
 |  | const agile_modbus_slave_util_t * | slave_util
 | ) |  |
static

写并读寄存器

参数
ctx | modbus 句柄
slave_info | 从机信息体
slave_util | 从机功能结构体
返回
=0:正常; <0:异常 (-AGILE_MODBUS_EXCEPTION_UNKNOW(-255): 未知异常，从机不会打包响应数据) (其他负数异常码: 从机会打包异常响应数据)

在文件 agile_modbus_slave_util.c 第 291 行定义.

函数调用图:
这是这个函数的调用关系图:


Agile Modbus: Slave Util Exported Functions

函数
Slave Util Exported Functions
UTIL » Slave Util
Slave Util Exported Functions 的协作图:

函数

int agile_modbus_slave_util_callback (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data)
从机回调函数 更多...

详细描述

函数说明

◆ agile_modbus_slave_util_callback()

int agile_modbus_slave_util_callback | ( | agile_modbus_t * | ctx,
 |  | struct agile_modbus_slave_info * | slave_info,
 |  | const void * | data
 | ) |  |

从机回调函数

参数
ctx | modbus 句柄
slave_info | 从机信息体
data | 私有数据
返回
=0:正常; <0:异常 (-AGILE_MODBUS_EXCEPTION_UNKNOW(-255): 未知异常，从机不会打包响应数据) (其他负数异常码: 从机会打包异常响应数据)

在文件 agile_modbus_slave_util.c 第 387 行定义.

函数调用图:


Agile Modbus: Slave Util Exported Types

结构体 | 类型定义
Slave Util Exported Types
UTIL » Slave Util
Slave Util Exported Types 的协作图:

结构体

struct | agile_modbus_slave_util_map
从机寄存器映射结构体 更多...
struct | agile_modbus_slave_util
从机功能结构体 更多...

类型定义

typedef struct agile_modbus_slave_util_map | agile_modbus_slave_util_map_t
从机寄存器映射结构体 更多...
typedef struct agile_modbus_slave_util | agile_modbus_slave_util_t
从机功能结构体 更多...

详细描述

类型定义说明

◆ agile_modbus_slave_util_map_t

typedef struct agile_modbus_slave_util_map agile_modbus_slave_util_map_t

从机寄存器映射结构体

◆ agile_modbus_slave_util_t

typedef struct agile_modbus_slave_util agile_modbus_slave_util_t

从机功能结构体


Agile Modbus: agile_modbus_slave_util_map结构体 参考

成员变量
agile_modbus_slave_util_map结构体 参考
UTIL » Slave Util » Slave Util Exported Types

从机寄存器映射结构体 更多...

#include <agile_modbus_slave_util.h>

成员变量

int | start_addr
起始地址 更多...
int | end_addr
结束地址 更多...
int(* | get )(void *buf, int bufsz)
获取寄存器数据接口 更多...
int(* | set )(int index, int len, void *buf, int bufsz)
设置寄存器数据接口 更多...

详细描述

从机寄存器映射结构体

在文件 agile_modbus_slave_util.h 第 38 行定义.

结构体成员变量说明

◆ start_addr

int agile_modbus_slave_util_map::start_addr

起始地址

在文件 agile_modbus_slave_util.h 第 39 行定义.

◆ end_addr

int agile_modbus_slave_util_map::end_addr

结束地址

在文件 agile_modbus_slave_util.h 第 40 行定义.

◆ get

int(* agile_modbus_slave_util_map::get) (void *buf, int bufsz)

获取寄存器数据接口

在文件 agile_modbus_slave_util.h 第 41 行定义.

◆ set

int(* agile_modbus_slave_util_map::set) (int index, int len, void *buf, int bufsz)

设置寄存器数据接口

在文件 agile_modbus_slave_util.h 第 42 行定义.

该结构体的文档由以下文件生成:
  • C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/util/agile_modbus_slave_util.h


Agile Modbus: agile_modbus_slave_util结构体 参考

成员变量
agile_modbus_slave_util结构体 参考
UTIL » Slave Util » Slave Util Exported Types

从机功能结构体 更多...

#include <agile_modbus_slave_util.h>

agile_modbus_slave_util 的协作图:
[图例]

成员变量

const agile_modbus_slave_util_map_t * | tab_bits
线圈寄存器定义数组 更多...
int | nb_bits
线圈寄存器定义数组数目 更多...
const agile_modbus_slave_util_map_t * | tab_input_bits
离散量输入寄存器定义数组 更多...
int | nb_input_bits
离散量输入寄存器定义数组数目 更多...
const agile_modbus_slave_util_map_t * | tab_registers
保持寄存器定义数组 更多...
int | nb_registers
保持寄存器定义数组数目 更多...
const agile_modbus_slave_util_map_t * | tab_input_registers
输入寄存器定义数组 更多...
int | nb_input_registers
输入寄存器定义数组数目 更多...
int(* | addr_check )(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info)
地址检查接口 更多...
int(* | special_function )(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info)
特殊功能码处理接口 更多...
int(* | done )(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, int ret)
处理结束接口 更多...

详细描述

从机功能结构体

在文件 agile_modbus_slave_util.h 第 48 行定义.

结构体成员变量说明

◆ tab_bits

const agile_modbus_slave_util_map_t* agile_modbus_slave_util::tab_bits

线圈寄存器定义数组

在文件 agile_modbus_slave_util.h 第 49 行定义.

◆ nb_bits

int agile_modbus_slave_util::nb_bits

线圈寄存器定义数组数目

在文件 agile_modbus_slave_util.h 第 50 行定义.

◆ tab_input_bits

const agile_modbus_slave_util_map_t* agile_modbus_slave_util::tab_input_bits

离散量输入寄存器定义数组

在文件 agile_modbus_slave_util.h 第 51 行定义.

◆ nb_input_bits

int agile_modbus_slave_util::nb_input_bits

离散量输入寄存器定义数组数目

在文件 agile_modbus_slave_util.h 第 52 行定义.

◆ tab_registers

const agile_modbus_slave_util_map_t* agile_modbus_slave_util::tab_registers

保持寄存器定义数组

在文件 agile_modbus_slave_util.h 第 53 行定义.

◆ nb_registers

int agile_modbus_slave_util::nb_registers

保持寄存器定义数组数目

在文件 agile_modbus_slave_util.h 第 54 行定义.

◆ tab_input_registers

const agile_modbus_slave_util_map_t* agile_modbus_slave_util::tab_input_registers

输入寄存器定义数组

在文件 agile_modbus_slave_util.h 第 55 行定义.

◆ nb_input_registers

int agile_modbus_slave_util::nb_input_registers

输入寄存器定义数组数目

在文件 agile_modbus_slave_util.h 第 56 行定义.

◆ addr_check

int(* agile_modbus_slave_util::addr_check) (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info)

地址检查接口

在文件 agile_modbus_slave_util.h 第 57 行定义.

◆ special_function

int(* agile_modbus_slave_util::special_function) (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info)

特殊功能码处理接口

在文件 agile_modbus_slave_util.h 第 58 行定义.

◆ done

int(* agile_modbus_slave_util::done) (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, int ret)

处理结束接口

在文件 agile_modbus_slave_util.h 第 59 行定义.

该结构体的文档由以下文件生成:
  • C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/util/agile_modbus_slave_util.h


Agile Modbus: 结构体

结构体
这里列出了所有结构体，并附带简要说明:
C agile_modbus | Agile Modbus 结构体
C agile_modbus_backend | Agile Modbus 后端接口结构体
C agile_modbus_rtu | RTU 结构体
C agile_modbus_sft | 包含 modbus 头部参数结构体
C agile_modbus_slave_info | Agile Modbus 从机信息结构体
C agile_modbus_slave_util | 从机功能结构体
C agile_modbus_slave_util_map | 从机寄存器映射结构体
C agile_modbus_tcp | TCP 结构体


Agile Modbus: 结构体索引

结构体索引
A
A
agile_modbus
agile_modbus_backend
agile_modbus_rtu
agile_modbus_sft
agile_modbus_slave_info
agile_modbus_slave_util
agile_modbus_slave_util_map
agile_modbus_tcp


Agile Modbus: 成员变量

这里列出了所有结构体和联合体的成员变量，并附带结构体或联合的详细说明:

- _ -

  • _ctx : agile_modbus_rtu, agile_modbus_tcp

- a -

  • addr_check : agile_modbus_slave_util
  • address : agile_modbus_slave_info

- b -

  • backend : agile_modbus
  • backend_data : agile_modbus
  • backend_type : agile_modbus_backend
  • buf : agile_modbus_slave_info
  • build_request_basis : agile_modbus_backend
  • build_response_basis : agile_modbus_backend

- c -

  • check_integrity : agile_modbus_backend
  • checksum_length : agile_modbus_backend
  • compute_data_length_after_meta : agile_modbus
  • compute_meta_length_after_function : agile_modbus

- d -

  • done : agile_modbus_slave_util

- e -

  • end_addr : agile_modbus_slave_util_map

- f -

  • function : agile_modbus_sft

- g -

  • get : agile_modbus_slave_util_map

- h -

  • header_length : agile_modbus_backend

- m -

  • max_adu_length : agile_modbus_backend

- n -

  • nb : agile_modbus_slave_info
  • nb_bits : agile_modbus_slave_util
  • nb_input_bits : agile_modbus_slave_util
  • nb_input_registers : agile_modbus_slave_util
  • nb_registers : agile_modbus_slave_util

- p -

  • pre_check_confirmation : agile_modbus_backend
  • prepare_response_tid : agile_modbus_backend

- r -

  • read_buf : agile_modbus
  • read_bufsz : agile_modbus
  • rsp_length : agile_modbus_slave_info

- s -

  • send_buf : agile_modbus
  • send_bufsz : agile_modbus
  • send_index : agile_modbus_slave_info
  • send_msg_pre : agile_modbus_backend
  • set : agile_modbus_slave_util_map
  • set_slave : agile_modbus_backend
  • sft : agile_modbus_slave_info
  • slave : agile_modbus, agile_modbus_sft
  • special_function : agile_modbus_slave_util
  • start_addr : agile_modbus_slave_util_map

- t -

  • t_id : agile_modbus_sft, agile_modbus_tcp
  • tab_bits : agile_modbus_slave_util
  • tab_input_bits : agile_modbus_slave_util
  • tab_input_registers : agile_modbus_slave_util
  • tab_registers : agile_modbus_slave_util


Agile Modbus: 成员变量 - 变量

- _ -

  • _ctx : agile_modbus_rtu, agile_modbus_tcp

- a -

  • addr_check : agile_modbus_slave_util
  • address : agile_modbus_slave_info

- b -

  • backend : agile_modbus
  • backend_data : agile_modbus
  • backend_type : agile_modbus_backend
  • buf : agile_modbus_slave_info
  • build_request_basis : agile_modbus_backend
  • build_response_basis : agile_modbus_backend

- c -

  • check_integrity : agile_modbus_backend
  • checksum_length : agile_modbus_backend
  • compute_data_length_after_meta : agile_modbus
  • compute_meta_length_after_function : agile_modbus

- d -

  • done : agile_modbus_slave_util

- e -

  • end_addr : agile_modbus_slave_util_map

- f -

  • function : agile_modbus_sft

- g -

  • get : agile_modbus_slave_util_map

- h -

  • header_length : agile_modbus_backend

- m -

  • max_adu_length : agile_modbus_backend

- n -

  • nb : agile_modbus_slave_info
  • nb_bits : agile_modbus_slave_util
  • nb_input_bits : agile_modbus_slave_util
  • nb_input_registers : agile_modbus_slave_util
  • nb_registers : agile_modbus_slave_util

- p -

  • pre_check_confirmation : agile_modbus_backend
  • prepare_response_tid : agile_modbus_backend

- r -

  • read_buf : agile_modbus
  • read_bufsz : agile_modbus
  • rsp_length : agile_modbus_slave_info

- s -

  • send_buf : agile_modbus
  • send_bufsz : agile_modbus
  • send_index : agile_modbus_slave_info
  • send_msg_pre : agile_modbus_backend
  • set : agile_modbus_slave_util_map
  • set_slave : agile_modbus_backend
  • sft : agile_modbus_slave_info
  • slave : agile_modbus, agile_modbus_sft
  • special_function : agile_modbus_slave_util
  • start_addr : agile_modbus_slave_util_map

- t -

  • t_id : agile_modbus_sft, agile_modbus_tcp
  • tab_bits : agile_modbus_slave_util
  • tab_input_bits : agile_modbus_slave_util
  • tab_input_registers : agile_modbus_slave_util
  • tab_registers : agile_modbus_slave_util


Agile Modbus: 文件列表

文件列表
这里列出了所有文件，并附带简要说明:
[详情级别 12]
examples |
▼ inc |
agile_modbus.h | Agile Modbus 软件包通用头文件
agile_modbus_rtu.h | Agile Modbus 软件包 RTU 头文件
agile_modbus_tcp.h | Agile Modbus 软件包 TCP 头文件
▼ src |
agile_modbus.c | Agile Modbus 软件包通用源文件
agile_modbus_rtu.c | Agile Modbus 软件包 RTU 源文件
agile_modbus_tcp.c | Agile Modbus 软件包 TCP 源文件
▼ util |
agile_modbus_slave_util.c | Agile Modbus 软件包提供的简易从机接入源文件
agile_modbus_slave_util.h | Agile Modbus 软件包提供的简易从机接入头文件


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/examples 目录参考

  • examples
examples 目录参考


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/inc 目录参考

  • inc
inc 目录参考

文件

文件 | agile_modbus.h [代码]
Agile Modbus 软件包通用头文件
文件 | agile_modbus_rtu.h [代码]
Agile Modbus 软件包 RTU 头文件
文件 | agile_modbus_tcp.h [代码]
Agile Modbus 软件包 TCP 头文件


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/inc/agile_modbus.h 文件参考

  • inc
结构体 | 宏定义 | 类型定义 | 枚举 | 函数
agile_modbus.h 文件参考

Agile Modbus 软件包通用头文件 更多...

#include <stdint.h>
#include "agile_modbus_rtu.h"
#include "agile_modbus_tcp.h"
agile_modbus.h 的引用(Include)关系图:
此图展示该文件直接或间接的被哪些文件引用了:

浏览源代码.

结构体

struct | agile_modbus_sft
包含 modbus 头部参数结构体 更多...
struct | agile_modbus_backend
Agile Modbus 后端接口结构体 更多...
struct | agile_modbus
Agile Modbus 结构体 更多...
struct | agile_modbus_slave_info
Agile Modbus 从机信息结构体 更多...

宏定义

#define | AGILE_MODBUS_FC_READ_COILS 0x01
#define | AGILE_MODBUS_FC_READ_DISCRETE_INPUTS 0x02
#define | AGILE_MODBUS_FC_READ_HOLDING_REGISTERS 0x03
#define | AGILE_MODBUS_FC_READ_INPUT_REGISTERS 0x04
#define | AGILE_MODBUS_FC_WRITE_SINGLE_COIL 0x05
#define | AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER 0x06
#define | AGILE_MODBUS_FC_READ_EXCEPTION_STATUS 0x07
#define | AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS 0x0F
#define | AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS 0x10
#define | AGILE_MODBUS_FC_REPORT_SLAVE_ID 0x11
#define | AGILE_MODBUS_FC_MASK_WRITE_REGISTER 0x16
#define | AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS 0x17
#define | AGILE_MODBUS_VERSION_STRING "AMB_1.1.0"
Agile Modbus 版本号 更多...
#define | AGILE_MODBUS_BROADCAST_ADDRESS 0
Modbus 广播地址 更多...
#define | AGILE_MODBUS_MAX_PDU_LENGTH 253
#define | AGILE_MODBUS_MAX_ADU_LENGTH 260
Quantity limit of Coils
   Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 1 page 12)
   Quantity of Coils to read (2 bytes): 1 to 2000 (0x7D0)
   (chapter 6 section 11 page 29)
   Quantity of Coils to write (2 bytes): 1 to 1968 (0x7B0)
#define | AGILE_MODBUS_MAX_READ_BITS 2000
#define | AGILE_MODBUS_MAX_WRITE_BITS 1968
Quantity limit of Registers
   Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 3 page 15)
   Quantity of Registers to read (2 bytes): 1 to 125 (0x7D)
   (chapter 6 section 12 page 31)
   Quantity of Registers to write (2 bytes) 1 to 123 (0x7B)
   (chapter 6 section 17 page 38)
   Quantity of Registers to write in R/W registers (2 bytes) 1 to 121 (0x79)
#define | AGILE_MODBUS_MAX_READ_REGISTERS 125
#define | AGILE_MODBUS_MAX_WRITE_REGISTERS 123
#define | AGILE_MODBUS_MAX_WR_WRITE_REGISTERS 121
#define | AGILE_MODBUS_MAX_WR_READ_REGISTERS 125

类型定义

typedef struct agile_modbus_sft | agile_modbus_sft_t
包含 modbus 头部参数结构体 更多...
typedef struct agile_modbus | agile_modbus_t
Agile Modbus 结构体 更多...
typedef struct agile_modbus_backend | agile_modbus_backend_t
Agile Modbus 后端接口结构体 更多...
typedef int(* | agile_modbus_slave_callback_t) (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data)
从机回调函数 更多...

枚举

enum {
AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 0x01 , AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS , AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE , AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE ,
AGILE_MODBUS_EXCEPTION_ACKNOWLEDGE , AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY , AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE , AGILE_MODBUS_EXCEPTION_MEMORY_PARITY ,
AGILE_MODBUS_EXCEPTION_NOT_DEFINED , AGILE_MODBUS_EXCEPTION_GATEWAY_PATH , AGILE_MODBUS_EXCEPTION_GATEWAY_TARGET , AGILE_MODBUS_EXCEPTION_UNKNOW = 0xff
}
Modbus 异常码 更多...
enum | agile_modbus_backend_type_t { AGILE_MODBUS_BACKEND_TYPE_RTU = 0 , AGILE_MODBUS_BACKEND_TYPE_TCP }
Modbus 后端类型 更多...
enum | agile_modbus_msg_type_t { AGILE_MODBUS_MSG_INDICATION , AGILE_MODBUS_MSG_CONFIRMATION }
Modbus 收到消息类型 更多...

函数

void | agile_modbus_common_init (agile_modbus_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
初始化 modbus 句柄 更多...
int | agile_modbus_set_slave (agile_modbus_t *ctx, int slave)
设置地址 更多...
void | agile_modbus_set_compute_meta_length_after_function_cb (agile_modbus_t *ctx, uint8_t(*cb)(agile_modbus_t *ctx, int function, agile_modbus_msg_type_t msg_type))
设置 modbus 对象的计算功能码后要接收的数据元长度回调函数 更多...
void | agile_modbus_set_compute_data_length_after_meta_cb (agile_modbus_t *ctx, int(*cb)(agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type))
设置 modbus 对象的计算数据元之后要接收的数据长度回调函数 更多...
int | agile_modbus_receive_judge (agile_modbus_t *ctx, int msg_length, agile_modbus_msg_type_t msg_type)
校验接收数据正确性 更多...
int | agile_modbus_serialize_read_bits (agile_modbus_t *ctx, int addr, int nb)
int | agile_modbus_deserialize_read_bits (agile_modbus_t *ctx, int msg_length, uint8_t *dest)
int | agile_modbus_serialize_read_input_bits (agile_modbus_t *ctx, int addr, int nb)
int | agile_modbus_deserialize_read_input_bits (agile_modbus_t *ctx, int msg_length, uint8_t *dest)
int | agile_modbus_serialize_read_registers (agile_modbus_t *ctx, int addr, int nb)
int | agile_modbus_deserialize_read_registers (agile_modbus_t *ctx, int msg_length, uint16_t *dest)
int | agile_modbus_serialize_read_input_registers (agile_modbus_t *ctx, int addr, int nb)
int | agile_modbus_deserialize_read_input_registers (agile_modbus_t *ctx, int msg_length, uint16_t *dest)
int | agile_modbus_serialize_write_bit (agile_modbus_t *ctx, int addr, int status)
int | agile_modbus_deserialize_write_bit (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_write_register (agile_modbus_t *ctx, int addr, const uint16_t value)
int | agile_modbus_deserialize_write_register (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_write_bits (agile_modbus_t *ctx, int addr, int nb, const uint8_t *src)
int | agile_modbus_deserialize_write_bits (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_write_registers (agile_modbus_t *ctx, int addr, int nb, const uint16_t *src)
int | agile_modbus_deserialize_write_registers (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_mask_write_register (agile_modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask)
int | agile_modbus_deserialize_mask_write_register (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_write_and_read_registers (agile_modbus_t *ctx, int write_addr, int write_nb, const uint16_t *src, int read_addr, int read_nb)
int | agile_modbus_deserialize_write_and_read_registers (agile_modbus_t *ctx, int msg_length, uint16_t *dest)
int | agile_modbus_serialize_report_slave_id (agile_modbus_t *ctx)
int | agile_modbus_deserialize_report_slave_id (agile_modbus_t *ctx, int msg_length, int max_dest, uint8_t *dest)
int | agile_modbus_serialize_raw_request (agile_modbus_t *ctx, const uint8_t *raw_req, int raw_req_length)
将原始数据打包成请求报文 更多...
int | agile_modbus_deserialize_raw_response (agile_modbus_t *ctx, int msg_length)
解析响应原始数据 更多...
int | agile_modbus_slave_handle (agile_modbus_t *ctx, int msg_length, uint8_t slave_strict, agile_modbus_slave_callback_t slave_cb, const void *slave_data, int *frame_length)
从机数据处理 更多...
void | agile_modbus_slave_io_set (uint8_t *buf, int index, int status)
从机 IO 设置 更多...
uint8_t | agile_modbus_slave_io_get (uint8_t *buf, int index)
读取从机 IO 状态 更多...
void | agile_modbus_slave_register_set (uint8_t *buf, int index, uint16_t data)
从机寄存器设置 更多...
uint16_t | agile_modbus_slave_register_get (uint8_t *buf, int index)
读取从机寄存器数据 更多...

详细描述

Agile Modbus 软件包通用头文件

作者
马龙伟 (25440.nosp@m.4721.nosp@m.3@qq..nosp@m.com)
日期
2022-07-28
注意

© Copyright (c) 2021 Ma Longwei. All rights reserved.

在文件 agile_modbus.h 中定义.


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/inc/agile_modbus_rtu.h 文件参考

  • inc
结构体 | 宏定义 | 类型定义 | 函数
agile_modbus_rtu.h 文件参考

Agile Modbus 软件包 RTU 头文件 更多...

#include <stdint.h>
agile_modbus_rtu.h 的引用(Include)关系图:
此图展示该文件直接或间接的被哪些文件引用了:

浏览源代码.

结构体

struct agile_modbus_rtu
RTU 结构体 更多...

宏定义

#define | AGILE_MODBUS_RTU_HEADER_LENGTH 1
#define | AGILE_MODBUS_RTU_PRESET_REQ_LENGTH 6
#define | AGILE_MODBUS_RTU_PRESET_RSP_LENGTH 2
#define | AGILE_MODBUS_RTU_CHECKSUM_LENGTH 2
#define | AGILE_MODBUS_RTU_MAX_ADU_LENGTH 256

类型定义

typedef struct agile_modbus_rtu agile_modbus_rtu_t
RTU 结构体 更多...

函数

int agile_modbus_rtu_init (agile_modbus_rtu_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
RTU 初始化 更多...

详细描述

Agile Modbus 软件包 RTU 头文件

作者
马龙伟 (25440.nosp@m.4721.nosp@m.3@qq..nosp@m.com)
日期
2021-12-02
注意

© Copyright (c) 2021 Ma Longwei. All rights reserved.

在文件 agile_modbus_rtu.h 中定义.


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/inc/agile_modbus_tcp.h 文件参考

  • inc
结构体 | 宏定义 | 类型定义 | 函数
agile_modbus_tcp.h 文件参考

Agile Modbus 软件包 TCP 头文件 更多...

#include <stdint.h>
agile_modbus_tcp.h 的引用(Include)关系图:
此图展示该文件直接或间接的被哪些文件引用了:

浏览源代码.

结构体

struct agile_modbus_tcp
TCP 结构体 更多...

宏定义

#define | AGILE_MODBUS_TCP_HEADER_LENGTH 7
#define | AGILE_MODBUS_TCP_PRESET_REQ_LENGTH 12
#define | AGILE_MODBUS_TCP_PRESET_RSP_LENGTH 8
#define | AGILE_MODBUS_TCP_CHECKSUM_LENGTH 0
#define | AGILE_MODBUS_TCP_MAX_ADU_LENGTH 260

类型定义

typedef struct agile_modbus_tcp agile_modbus_tcp_t
TCP 结构体 更多...

函数

int agile_modbus_tcp_init (agile_modbus_tcp_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
TCP 初始化 更多...

详细描述

Agile Modbus 软件包 TCP 头文件

作者
马龙伟 (25440.nosp@m.4721.nosp@m.3@qq..nosp@m.com)
日期
2021-12-02
注意

© Copyright (c) 2021 Ma Longwei. All rights reserved.

在文件 agile_modbus_tcp.h 中定义.


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/src 目录参考

  • src
src 目录参考
src 的目录依赖关系图

文件

文件 | agile_modbus.c [代码]
Agile Modbus 软件包通用源文件
文件 | agile_modbus_rtu.c [代码]
Agile Modbus 软件包 RTU 源文件
文件 | agile_modbus_tcp.c [代码]
Agile Modbus 软件包 TCP 源文件


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/src/agile_modbus.c 文件参考

  • src
宏定义 | 函数
agile_modbus.c 文件参考

Agile Modbus 软件包通用源文件 更多...

#include "agile_modbus.h"
#include <string.h>
agile_modbus.c 的引用(Include)关系图:

浏览源代码.

宏定义

#define AGILE_MODBUS_MSG_LENGTH_UNDEFINED -1
对应功能码数据长度未定义 更多...

函数

static uint8_t | agile_modbus_compute_meta_length_after_function (agile_modbus_t *ctx, int function, agile_modbus_msg_type_t msg_type)
计算功能码后要接收的数据元长度 更多...
static int | agile_modbus_compute_data_length_after_meta (agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type)
计算数据元之后要接收的数据长度 更多...
static int | agile_modbus_receive_msg_judge (agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type)
检验接收数据正确性 更多...
void | agile_modbus_common_init (agile_modbus_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
初始化 modbus 句柄 更多...
int | agile_modbus_set_slave (agile_modbus_t *ctx, int slave)
设置地址 更多...
void | agile_modbus_set_compute_meta_length_after_function_cb (agile_modbus_t *ctx, uint8_t(*cb)(agile_modbus_t *ctx, int function, agile_modbus_msg_type_t msg_type))
设置 modbus 对象的计算功能码后要接收的数据元长度回调函数 更多...
void | agile_modbus_set_compute_data_length_after_meta_cb (agile_modbus_t *ctx, int(*cb)(agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type))
设置 modbus 对象的计算数据元之后要接收的数据长度回调函数 更多...
int | agile_modbus_receive_judge (agile_modbus_t *ctx, int msg_length, agile_modbus_msg_type_t msg_type)
校验接收数据正确性 更多...
static int | agile_modbus_compute_response_length_from_request (agile_modbus_t *ctx, uint8_t *req)
计算预期响应数据长度 更多...
static int | agile_modbus_check_confirmation (agile_modbus_t *ctx, uint8_t *req, uint8_t *rsp, int rsp_length)
检查确认从机响应的数据 更多...
int | agile_modbus_serialize_read_bits (agile_modbus_t *ctx, int addr, int nb)
int | agile_modbus_deserialize_read_bits (agile_modbus_t *ctx, int msg_length, uint8_t *dest)
int | agile_modbus_serialize_read_input_bits (agile_modbus_t *ctx, int addr, int nb)
int | agile_modbus_deserialize_read_input_bits (agile_modbus_t *ctx, int msg_length, uint8_t *dest)
int | agile_modbus_serialize_read_registers (agile_modbus_t *ctx, int addr, int nb)
int | agile_modbus_deserialize_read_registers (agile_modbus_t *ctx, int msg_length, uint16_t *dest)
int | agile_modbus_serialize_read_input_registers (agile_modbus_t *ctx, int addr, int nb)
int | agile_modbus_deserialize_read_input_registers (agile_modbus_t *ctx, int msg_length, uint16_t *dest)
int | agile_modbus_serialize_write_bit (agile_modbus_t *ctx, int addr, int status)
int | agile_modbus_deserialize_write_bit (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_write_register (agile_modbus_t *ctx, int addr, const uint16_t value)
int | agile_modbus_deserialize_write_register (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_write_bits (agile_modbus_t *ctx, int addr, int nb, const uint8_t *src)
int | agile_modbus_deserialize_write_bits (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_write_registers (agile_modbus_t *ctx, int addr, int nb, const uint16_t *src)
int | agile_modbus_deserialize_write_registers (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_mask_write_register (agile_modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask)
int | agile_modbus_deserialize_mask_write_register (agile_modbus_t *ctx, int msg_length)
int | agile_modbus_serialize_write_and_read_registers (agile_modbus_t *ctx, int write_addr, int write_nb, const uint16_t *src, int read_addr, int read_nb)
int | agile_modbus_deserialize_write_and_read_registers (agile_modbus_t *ctx, int msg_length, uint16_t *dest)
int | agile_modbus_serialize_report_slave_id (agile_modbus_t *ctx)
int | agile_modbus_deserialize_report_slave_id (agile_modbus_t *ctx, int msg_length, int max_dest, uint8_t *dest)
int | agile_modbus_serialize_raw_request (agile_modbus_t *ctx, const uint8_t *raw_req, int raw_req_length)
将原始数据打包成请求报文 更多...
int | agile_modbus_deserialize_raw_response (agile_modbus_t *ctx, int msg_length)
解析响应原始数据 更多...
static int | agile_modbus_serialize_response_exception (agile_modbus_t *ctx, agile_modbus_sft_t *sft, int exception_code)
打包异常响应数据 更多...
void | agile_modbus_slave_io_set (uint8_t *buf, int index, int status)
从机 IO 设置 更多...
uint8_t | agile_modbus_slave_io_get (uint8_t *buf, int index)
读取从机 IO 状态 更多...
void | agile_modbus_slave_register_set (uint8_t *buf, int index, uint16_t data)
从机寄存器设置 更多...
uint16_t | agile_modbus_slave_register_get (uint8_t *buf, int index)
读取从机寄存器数据 更多...
int | agile_modbus_slave_handle (agile_modbus_t *ctx, int msg_length, uint8_t slave_strict, agile_modbus_slave_callback_t slave_cb, const void *slave_data, int *frame_length)
从机数据处理 更多...

详细描述

Agile Modbus 软件包通用源文件

作者
马龙伟 (25440.nosp@m.4721.nosp@m.3@qq..nosp@m.com)
日期
2022-07-28
   使用：
   用户需要实现硬件接口的 `发送数据` 、 `等待数据接收结束` 、 `清空接收缓存` 函数

   - 主机：
       1. `agile_modbus_rtu_init` / `agile_modbus_tcp_init` 初始化 `RTU/TCP` 环境
       2. `agile_modbus_set_slave` 设置从机地址
       3. `清空接收缓存`
       4. `agile_modbus_serialize_xxx` 打包请求数据
       5. `发送数据`
       6. `等待数据接收结束`
       7. `agile_modbus_deserialize_xxx` 解析响应数据
       8. 用户处理得到的数据

   - 从机：
       1. 实现 `agile_modbus_slave_callback_t` 类型回调函数
       2. `agile_modbus_rtu_init` / `agile_modbus_tcp_init` 初始化 `RTU/TCP` 环境
       3. `agile_modbus_set_slave` 设置从机地址
       4. `等待数据接收结束`
       5. `agile_modbus_slave_handle` 处理请求数据
       6. `清空接收缓存` (可选)
       7. `发送数据`
注意

© Copyright (c) 2021 Ma Longwei. All rights reserved.

在文件 agile_modbus.c 中定义.


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/src/agile_modbus_rtu.c 文件参考

  • src
函数 | 变量
agile_modbus_rtu.c 文件参考

Agile Modbus 软件包 RTU 源文件 更多...

#include "agile_modbus.h"
#include "agile_modbus_rtu.h"
agile_modbus_rtu.c 的引用(Include)关系图:

浏览源代码.

函数

static uint16_t | agile_modbus_rtu_crc16 (uint8_t *buffer, uint16_t buffer_length)
RTU CRC16 计算 更多...
static int | agile_modbus_rtu_set_slave (agile_modbus_t *ctx, int slave)
RTU 设置地址接口 更多...
static int | agile_modbus_rtu_build_request_basis (agile_modbus_t *ctx, int function, int addr, int nb, uint8_t *req)
RTU 构建基础请求报文接口(头部报文) 更多...
static int | agile_modbus_rtu_build_response_basis (agile_modbus_sft_t *sft, uint8_t *rsp)
RTU 构建基础响应报文接口(头部报文) 更多...
static int | agile_modbus_rtu_prepare_response_tid (const uint8_t *req, int *req_length)
RTU 准备响应接口 更多...
static int | agile_modbus_rtu_send_msg_pre (uint8_t *req, int req_length)
RTU 预发送数据接口 更多...
static int | agile_modbus_rtu_check_integrity (agile_modbus_t *ctx, uint8_t *msg, const int msg_length)
RTU 检查接收数据完整性接口(CRC16 对比) 更多...
static int | agile_modbus_rtu_pre_check_confirmation (agile_modbus_t *ctx, const uint8_t *req, const uint8_t *rsp, int rsp_length)
RTU 预检查确认接口(请求响应地址对比) 更多...
int | agile_modbus_rtu_init (agile_modbus_rtu_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
RTU 初始化 更多...

变量

static const uint8_t | _table_crc_hi []
Table of CRC values for high-order byte 更多...
static const uint8_t | _table_crc_lo []
Table of CRC values for low-order byte 更多...
static const agile_modbus_backend_t | agile_modbus_rtu_backend
RTU 后端接口 更多...

详细描述

Agile Modbus 软件包 RTU 源文件

作者
马龙伟 (25440.nosp@m.4721.nosp@m.3@qq..nosp@m.com)
日期
2021-12-02
注意

© Copyright (c) 2021 Ma Longwei. All rights reserved.

在文件 agile_modbus_rtu.c 中定义.


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/src/agile_modbus_tcp.c 文件参考

  • src
函数 | 变量
agile_modbus_tcp.c 文件参考

Agile Modbus 软件包 TCP 源文件 更多...

#include "agile_modbus.h"
#include "agile_modbus_tcp.h"
agile_modbus_tcp.c 的引用(Include)关系图:

浏览源代码.

函数

static int | agile_modbus_tcp_set_slave (agile_modbus_t *ctx, int slave)
TCP 设置地址接口 更多...
static int | agile_modbus_tcp_build_request_basis (agile_modbus_t *ctx, int function, int addr, int nb, uint8_t *req)
TCP 构建基础请求报文接口(头部报文) 更多...
static int | agile_modbus_tcp_build_response_basis (agile_modbus_sft_t *sft, uint8_t *rsp)
TCP 构建基础响应报文接口(头部报文) 更多...
static int | agile_modbus_tcp_prepare_response_tid (const uint8_t *req, int *req_length)
TCP 准备响应接口 更多...
static int | agile_modbus_tcp_send_msg_pre (uint8_t *req, int req_length)
TCP 预发送数据接口(计算长度字段的值并存入) 更多...
static int | agile_modbus_tcp_check_integrity (agile_modbus_t *ctx, uint8_t *msg, const int msg_length)
TCP 检查接收数据完整性接口 更多...
static int | agile_modbus_tcp_pre_check_confirmation (agile_modbus_t *ctx, const uint8_t *req, const uint8_t *rsp, int rsp_length)
TCP 预检查确认接口(对比事务标识符和协议标识符) 更多...
int | agile_modbus_tcp_init (agile_modbus_tcp_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
TCP 初始化 更多...

变量

static const agile_modbus_backend_t agile_modbus_tcp_backend
TCP 后端接口 更多...

详细描述

Agile Modbus 软件包 TCP 源文件

作者
马龙伟 (25440.nosp@m.4721.nosp@m.3@qq..nosp@m.com)
日期
2021-12-02
注意

© Copyright (c) 2021 Ma Longwei. All rights reserved.

在文件 agile_modbus_tcp.c 中定义.


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/util 目录参考

  • util
util 目录参考
util 的目录依赖关系图

文件

文件 | agile_modbus_slave_util.c [代码]
Agile Modbus 软件包提供的简易从机接入源文件
文件 | agile_modbus_slave_util.h [代码]
Agile Modbus 软件包提供的简易从机接入头文件


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/util/agile_modbus_slave_util.c 文件参考

  • util
函数
agile_modbus_slave_util.c 文件参考

Agile Modbus 软件包提供的简易从机接入源文件 更多...

#include "agile_modbus.h"
#include "agile_modbus_slave_util.h"
#include <string.h>
agile_modbus_slave_util.c 的引用(Include)关系图:

浏览源代码.

函数

static const agile_modbus_slave_util_map_t * | get_map_by_addr (const agile_modbus_slave_util_map_t *maps, int nb_maps, int address)
根据寄存器地址从映射对象数组中获取映射对象 更多...
static int | read_registers (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
读取寄存器 更多...
static int | write_registers (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
写寄存器 更多...
static int | mask_write_register (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
掩码写寄存器 更多...
static int | write_read_registers (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
写并读寄存器 更多...
int | agile_modbus_slave_util_callback (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data)
从机回调函数 更多...

详细描述

Agile Modbus 软件包提供的简易从机接入源文件

作者
马龙伟 (25440.nosp@m.4721.nosp@m.3@qq..nosp@m.com)
日期
2022-07-28
注意

© Copyright (c) 2022 Ma Longwei. All rights reserved.

在文件 agile_modbus_slave_util.c 中定义.


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/util/agile_modbus_slave_util.h 文件参考

  • util
结构体 | 类型定义 | 函数
agile_modbus_slave_util.h 文件参考

Agile Modbus 软件包提供的简易从机接入头文件 更多...

#include <stdint.h>
agile_modbus_slave_util.h 的引用(Include)关系图:
此图展示该文件直接或间接的被哪些文件引用了:

浏览源代码.

结构体

struct | agile_modbus_slave_util_map
从机寄存器映射结构体 更多...
struct | agile_modbus_slave_util
从机功能结构体 更多...

类型定义

typedef struct agile_modbus_slave_util_map | agile_modbus_slave_util_map_t
从机寄存器映射结构体 更多...
typedef struct agile_modbus_slave_util | agile_modbus_slave_util_t
从机功能结构体 更多...

函数

int agile_modbus_slave_util_callback (agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data)
从机回调函数 更多...

详细描述

Agile Modbus 软件包提供的简易从机接入头文件

作者
马龙伟 (25440.nosp@m.4721.nosp@m.3@qq..nosp@m.com)
日期
2022-07-28
注意

© Copyright (c) 2022 Ma Longwei. All rights reserved.

在文件 agile_modbus_slave_util.h 中定义.


Agile Modbus: 全局定义

这里列出了所有函数,变量,宏,枚举和类型定义等,并附带其所属的文件:

- _ -

  • _table_crc_hi : agile_modbus_rtu.c
  • _table_crc_lo : agile_modbus_rtu.c

- a -

  • agile_modbus_backend_t : agile_modbus.h
  • AGILE_MODBUS_BACKEND_TYPE_RTU : agile_modbus.h
  • agile_modbus_backend_type_t : agile_modbus.h
  • AGILE_MODBUS_BACKEND_TYPE_TCP : agile_modbus.h
  • AGILE_MODBUS_BROADCAST_ADDRESS : agile_modbus.h
  • agile_modbus_check_confirmation() : agile_modbus.c
  • agile_modbus_common_init() : agile_modbus.h
  • agile_modbus_compute_data_length_after_meta() : agile_modbus.c
  • agile_modbus_compute_meta_length_after_function() : agile_modbus.c
  • agile_modbus_compute_response_length_from_request() : agile_modbus.c
  • agile_modbus_deserialize_mask_write_register() : agile_modbus.h
  • agile_modbus_deserialize_raw_response() : agile_modbus.h
  • agile_modbus_deserialize_read_bits() : agile_modbus.h
  • agile_modbus_deserialize_read_input_bits() : agile_modbus.h
  • agile_modbus_deserialize_read_input_registers() : agile_modbus.h
  • agile_modbus_deserialize_read_registers() : agile_modbus.h
  • agile_modbus_deserialize_report_slave_id() : agile_modbus.h
  • agile_modbus_deserialize_write_and_read_registers() : agile_modbus.h
  • agile_modbus_deserialize_write_bit() : agile_modbus.h
  • agile_modbus_deserialize_write_bits() : agile_modbus.h
  • agile_modbus_deserialize_write_register() : agile_modbus.h
  • agile_modbus_deserialize_write_registers() : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_ACKNOWLEDGE : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_GATEWAY_PATH : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_GATEWAY_TARGET : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_MEMORY_PARITY : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_NOT_DEFINED : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_UNKNOW : agile_modbus.h
  • AGILE_MODBUS_FC_MASK_WRITE_REGISTER : agile_modbus.h
  • AGILE_MODBUS_FC_READ_COILS : agile_modbus.h
  • AGILE_MODBUS_FC_READ_DISCRETE_INPUTS : agile_modbus.h
  • AGILE_MODBUS_FC_READ_EXCEPTION_STATUS : agile_modbus.h
  • AGILE_MODBUS_FC_READ_HOLDING_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_FC_READ_INPUT_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_FC_REPORT_SLAVE_ID : agile_modbus.h
  • AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS : agile_modbus.h
  • AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_FC_WRITE_SINGLE_COIL : agile_modbus.h
  • AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER : agile_modbus.h
  • AGILE_MODBUS_MAX_ADU_LENGTH : agile_modbus.h
  • AGILE_MODBUS_MAX_PDU_LENGTH : agile_modbus.h
  • AGILE_MODBUS_MAX_READ_BITS : agile_modbus.h
  • AGILE_MODBUS_MAX_READ_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_MAX_WR_READ_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_MAX_WR_WRITE_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_MAX_WRITE_BITS : agile_modbus.h
  • AGILE_MODBUS_MAX_WRITE_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_MSG_CONFIRMATION : agile_modbus.h
  • AGILE_MODBUS_MSG_INDICATION : agile_modbus.h
  • AGILE_MODBUS_MSG_LENGTH_UNDEFINED : agile_modbus.c
  • agile_modbus_msg_type_t : agile_modbus.h
  • agile_modbus_receive_judge() : agile_modbus.h
  • agile_modbus_receive_msg_judge() : agile_modbus.c
  • agile_modbus_rtu_backend : agile_modbus_rtu.c
  • agile_modbus_rtu_build_request_basis() : agile_modbus_rtu.c
  • agile_modbus_rtu_build_response_basis() : agile_modbus_rtu.c
  • agile_modbus_rtu_check_integrity() : agile_modbus_rtu.c
  • AGILE_MODBUS_RTU_CHECKSUM_LENGTH : agile_modbus_rtu.h
  • agile_modbus_rtu_crc16() : agile_modbus_rtu.c
  • AGILE_MODBUS_RTU_HEADER_LENGTH : agile_modbus_rtu.h
  • agile_modbus_rtu_init() : agile_modbus_rtu.h
  • AGILE_MODBUS_RTU_MAX_ADU_LENGTH : agile_modbus_rtu.h
  • agile_modbus_rtu_pre_check_confirmation() : agile_modbus_rtu.c
  • agile_modbus_rtu_prepare_response_tid() : agile_modbus_rtu.c
  • AGILE_MODBUS_RTU_PRESET_REQ_LENGTH : agile_modbus_rtu.h
  • AGILE_MODBUS_RTU_PRESET_RSP_LENGTH : agile_modbus_rtu.h
  • agile_modbus_rtu_send_msg_pre() : agile_modbus_rtu.c
  • agile_modbus_rtu_set_slave() : agile_modbus_rtu.c
  • agile_modbus_rtu_t : agile_modbus_rtu.h
  • agile_modbus_serialize_mask_write_register() : agile_modbus.h
  • agile_modbus_serialize_raw_request() : agile_modbus.h
  • agile_modbus_serialize_read_bits() : agile_modbus.h
  • agile_modbus_serialize_read_input_bits() : agile_modbus.h
  • agile_modbus_serialize_read_input_registers() : agile_modbus.h
  • agile_modbus_serialize_read_registers() : agile_modbus.h
  • agile_modbus_serialize_report_slave_id() : agile_modbus.h
  • agile_modbus_serialize_response_exception() : agile_modbus.c
  • agile_modbus_serialize_write_and_read_registers() : agile_modbus.h
  • agile_modbus_serialize_write_bit() : agile_modbus.h
  • agile_modbus_serialize_write_bits() : agile_modbus.h
  • agile_modbus_serialize_write_register() : agile_modbus.h
  • agile_modbus_serialize_write_registers() : agile_modbus.h
  • agile_modbus_set_compute_data_length_after_meta_cb() : agile_modbus.h
  • agile_modbus_set_compute_meta_length_after_function_cb() : agile_modbus.h
  • agile_modbus_set_slave() : agile_modbus.h
  • agile_modbus_sft_t : agile_modbus.h
  • agile_modbus_slave_callback_t : agile_modbus.h
  • agile_modbus_slave_handle() : agile_modbus.h
  • agile_modbus_slave_io_get() : agile_modbus.h
  • agile_modbus_slave_io_set() : agile_modbus.h
  • agile_modbus_slave_register_get() : agile_modbus.h
  • agile_modbus_slave_register_set() : agile_modbus.h
  • agile_modbus_slave_util_callback() : agile_modbus_slave_util.c
  • agile_modbus_slave_util_map_t : agile_modbus_slave_util.h
  • agile_modbus_slave_util_t : agile_modbus_slave_util.h
  • agile_modbus_t : agile_modbus.h
  • agile_modbus_tcp_backend : agile_modbus_tcp.c
  • agile_modbus_tcp_build_request_basis() : agile_modbus_tcp.c
  • agile_modbus_tcp_build_response_basis() : agile_modbus_tcp.c
  • agile_modbus_tcp_check_integrity() : agile_modbus_tcp.c
  • AGILE_MODBUS_TCP_CHECKSUM_LENGTH : agile_modbus_tcp.h
  • AGILE_MODBUS_TCP_HEADER_LENGTH : agile_modbus_tcp.h
  • agile_modbus_tcp_init() : agile_modbus_tcp.h
  • AGILE_MODBUS_TCP_MAX_ADU_LENGTH : agile_modbus_tcp.h
  • agile_modbus_tcp_pre_check_confirmation() : agile_modbus_tcp.c
  • agile_modbus_tcp_prepare_response_tid() : agile_modbus_tcp.c
  • AGILE_MODBUS_TCP_PRESET_REQ_LENGTH : agile_modbus_tcp.h
  • AGILE_MODBUS_TCP_PRESET_RSP_LENGTH : agile_modbus_tcp.h
  • agile_modbus_tcp_send_msg_pre() : agile_modbus_tcp.c
  • agile_modbus_tcp_set_slave() : agile_modbus_tcp.c
  • agile_modbus_tcp_t : agile_modbus_tcp.h
  • AGILE_MODBUS_VERSION_STRING : agile_modbus.h

- g -

  • get_map_by_addr() : agile_modbus_slave_util.c

- m -

  • mask_write_register() : agile_modbus_slave_util.c

- r -

  • read_registers() : agile_modbus_slave_util.c

- w -

  • write_read_registers() : agile_modbus_slave_util.c
  • write_registers() : agile_modbus_slave_util.c


Agile Modbus: 全局定义

- a -

  • agile_modbus_check_confirmation() : agile_modbus.c
  • agile_modbus_common_init() : agile_modbus.h
  • agile_modbus_compute_data_length_after_meta() : agile_modbus.c
  • agile_modbus_compute_meta_length_after_function() : agile_modbus.c
  • agile_modbus_compute_response_length_from_request() : agile_modbus.c
  • agile_modbus_deserialize_mask_write_register() : agile_modbus.h
  • agile_modbus_deserialize_raw_response() : agile_modbus.h
  • agile_modbus_deserialize_read_bits() : agile_modbus.h
  • agile_modbus_deserialize_read_input_bits() : agile_modbus.h
  • agile_modbus_deserialize_read_input_registers() : agile_modbus.h
  • agile_modbus_deserialize_read_registers() : agile_modbus.h
  • agile_modbus_deserialize_report_slave_id() : agile_modbus.h
  • agile_modbus_deserialize_write_and_read_registers() : agile_modbus.h
  • agile_modbus_deserialize_write_bit() : agile_modbus.h
  • agile_modbus_deserialize_write_bits() : agile_modbus.h
  • agile_modbus_deserialize_write_register() : agile_modbus.h
  • agile_modbus_deserialize_write_registers() : agile_modbus.h
  • agile_modbus_receive_judge() : agile_modbus.h
  • agile_modbus_receive_msg_judge() : agile_modbus.c
  • agile_modbus_rtu_build_request_basis() : agile_modbus_rtu.c
  • agile_modbus_rtu_build_response_basis() : agile_modbus_rtu.c
  • agile_modbus_rtu_check_integrity() : agile_modbus_rtu.c
  • agile_modbus_rtu_crc16() : agile_modbus_rtu.c
  • agile_modbus_rtu_init() : agile_modbus_rtu.h
  • agile_modbus_rtu_pre_check_confirmation() : agile_modbus_rtu.c
  • agile_modbus_rtu_prepare_response_tid() : agile_modbus_rtu.c
  • agile_modbus_rtu_send_msg_pre() : agile_modbus_rtu.c
  • agile_modbus_rtu_set_slave() : agile_modbus_rtu.c
  • agile_modbus_serialize_mask_write_register() : agile_modbus.h
  • agile_modbus_serialize_raw_request() : agile_modbus.h
  • agile_modbus_serialize_read_bits() : agile_modbus.h
  • agile_modbus_serialize_read_input_bits() : agile_modbus.h
  • agile_modbus_serialize_read_input_registers() : agile_modbus.h
  • agile_modbus_serialize_read_registers() : agile_modbus.h
  • agile_modbus_serialize_report_slave_id() : agile_modbus.h
  • agile_modbus_serialize_response_exception() : agile_modbus.c
  • agile_modbus_serialize_write_and_read_registers() : agile_modbus.h
  • agile_modbus_serialize_write_bit() : agile_modbus.h
  • agile_modbus_serialize_write_bits() : agile_modbus.h
  • agile_modbus_serialize_write_register() : agile_modbus.h
  • agile_modbus_serialize_write_registers() : agile_modbus.h
  • agile_modbus_set_compute_data_length_after_meta_cb() : agile_modbus.h
  • agile_modbus_set_compute_meta_length_after_function_cb() : agile_modbus.h
  • agile_modbus_set_slave() : agile_modbus.h
  • agile_modbus_slave_handle() : agile_modbus.h
  • agile_modbus_slave_io_get() : agile_modbus.h
  • agile_modbus_slave_io_set() : agile_modbus.h
  • agile_modbus_slave_register_get() : agile_modbus.h
  • agile_modbus_slave_register_set() : agile_modbus.h
  • agile_modbus_slave_util_callback() : agile_modbus_slave_util.c
  • agile_modbus_tcp_build_request_basis() : agile_modbus_tcp.c
  • agile_modbus_tcp_build_response_basis() : agile_modbus_tcp.c
  • agile_modbus_tcp_check_integrity() : agile_modbus_tcp.c
  • agile_modbus_tcp_init() : agile_modbus_tcp.h
  • agile_modbus_tcp_pre_check_confirmation() : agile_modbus_tcp.c
  • agile_modbus_tcp_prepare_response_tid() : agile_modbus_tcp.c
  • agile_modbus_tcp_send_msg_pre() : agile_modbus_tcp.c
  • agile_modbus_tcp_set_slave() : agile_modbus_tcp.c

- g -

  • get_map_by_addr() : agile_modbus_slave_util.c

- m -

  • mask_write_register() : agile_modbus_slave_util.c

- r -

  • read_registers() : agile_modbus_slave_util.c

- w -

  • write_read_registers() : agile_modbus_slave_util.c
  • write_registers() : agile_modbus_slave_util.c


Agile Modbus: 全局定义

  • _table_crc_hi : agile_modbus_rtu.c
  • _table_crc_lo : agile_modbus_rtu.c
  • agile_modbus_rtu_backend : agile_modbus_rtu.c
  • agile_modbus_tcp_backend : agile_modbus_tcp.c


Agile Modbus: 全局定义

  • agile_modbus_backend_t : agile_modbus.h
  • agile_modbus_rtu_t : agile_modbus_rtu.h
  • agile_modbus_sft_t : agile_modbus.h
  • agile_modbus_slave_callback_t : agile_modbus.h
  • agile_modbus_slave_util_map_t : agile_modbus_slave_util.h
  • agile_modbus_slave_util_t : agile_modbus_slave_util.h
  • agile_modbus_t : agile_modbus.h
  • agile_modbus_tcp_t : agile_modbus_tcp.h


Agile Modbus: 全局定义

  • agile_modbus_backend_type_t : agile_modbus.h
  • agile_modbus_msg_type_t : agile_modbus.h


Agile Modbus: 全局定义

  • AGILE_MODBUS_BACKEND_TYPE_RTU : agile_modbus.h
  • AGILE_MODBUS_BACKEND_TYPE_TCP : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_ACKNOWLEDGE : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_GATEWAY_PATH : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_GATEWAY_TARGET : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_MEMORY_PARITY : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_NOT_DEFINED : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE : agile_modbus.h
  • AGILE_MODBUS_EXCEPTION_UNKNOW : agile_modbus.h
  • AGILE_MODBUS_MSG_CONFIRMATION : agile_modbus.h
  • AGILE_MODBUS_MSG_INDICATION : agile_modbus.h


Agile Modbus: 全局定义

- a -

  • AGILE_MODBUS_BROADCAST_ADDRESS : agile_modbus.h
  • AGILE_MODBUS_FC_MASK_WRITE_REGISTER : agile_modbus.h
  • AGILE_MODBUS_FC_READ_COILS : agile_modbus.h
  • AGILE_MODBUS_FC_READ_DISCRETE_INPUTS : agile_modbus.h
  • AGILE_MODBUS_FC_READ_EXCEPTION_STATUS : agile_modbus.h
  • AGILE_MODBUS_FC_READ_HOLDING_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_FC_READ_INPUT_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_FC_REPORT_SLAVE_ID : agile_modbus.h
  • AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS : agile_modbus.h
  • AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_FC_WRITE_SINGLE_COIL : agile_modbus.h
  • AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER : agile_modbus.h
  • AGILE_MODBUS_MAX_ADU_LENGTH : agile_modbus.h
  • AGILE_MODBUS_MAX_PDU_LENGTH : agile_modbus.h
  • AGILE_MODBUS_MAX_READ_BITS : agile_modbus.h
  • AGILE_MODBUS_MAX_READ_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_MAX_WR_READ_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_MAX_WR_WRITE_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_MAX_WRITE_BITS : agile_modbus.h
  • AGILE_MODBUS_MAX_WRITE_REGISTERS : agile_modbus.h
  • AGILE_MODBUS_MSG_LENGTH_UNDEFINED : agile_modbus.c
  • AGILE_MODBUS_RTU_CHECKSUM_LENGTH : agile_modbus_rtu.h
  • AGILE_MODBUS_RTU_HEADER_LENGTH : agile_modbus_rtu.h
  • AGILE_MODBUS_RTU_MAX_ADU_LENGTH : agile_modbus_rtu.h
  • AGILE_MODBUS_RTU_PRESET_REQ_LENGTH : agile_modbus_rtu.h
  • AGILE_MODBUS_RTU_PRESET_RSP_LENGTH : agile_modbus_rtu.h
  • AGILE_MODBUS_TCP_CHECKSUM_LENGTH : agile_modbus_tcp.h
  • AGILE_MODBUS_TCP_HEADER_LENGTH : agile_modbus_tcp.h
  • AGILE_MODBUS_TCP_MAX_ADU_LENGTH : agile_modbus_tcp.h
  • AGILE_MODBUS_TCP_PRESET_REQ_LENGTH : agile_modbus_tcp.h
  • AGILE_MODBUS_TCP_PRESET_RSP_LENGTH : agile_modbus_tcp.h
  • AGILE_MODBUS_VERSION_STRING : agile_modbus.h


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/ChangeLog.md 文件参考

C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/ChangeLog.md 文件参考


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/README.md 文件参考

C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/README.md 文件参考


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/src/agile_modbus.c 源文件

  • src
agile_modbus.c
浏览该文件的文档.
1
39#include "agile_modbus.h"
40#include <string.h>
41
49#define AGILE_MODBUS_MSG_LENGTH_UNDEFINED -1
88static uint8_t agile_modbus_compute_meta_length_after_function(agile_modbus_t *ctx, int function, agile_modbus_msg_type_t msg_type)
89{
90 int length;
91
92 if (msg_type == AGILE_MODBUS_MSG_INDICATION) {
93 if (function <= AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER) {
94 length = 4;
95 } else if (function == AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS ||
96 function == AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS) {
97 length = 5;
98 } else if (function == AGILE_MODBUS_FC_MASK_WRITE_REGISTER) {
99 length = 6;
100 } else if (function == AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS) {
101 length = 9;
102 } else {
103 /* MODBUS_FC_READ_EXCEPTION_STATUS, MODBUS_FC_REPORT_SLAVE_ID */
104 length = 0;
105 if (ctx->compute_meta_length_after_function)
106 length = ctx->compute_meta_length_after_function(ctx, function, msg_type);
107 }
108 } else {
109 /* MSG_CONFIRMATION */
110 switch (function) {
111 case AGILE_MODBUS_FC_READ_COILS:
112 case AGILE_MODBUS_FC_READ_DISCRETE_INPUTS:
113 case AGILE_MODBUS_FC_READ_HOLDING_REGISTERS:
114 case AGILE_MODBUS_FC_READ_INPUT_REGISTERS:
115 case AGILE_MODBUS_FC_REPORT_SLAVE_ID:
116 case AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS:
117 length = 1;
118 break;
119
120 case AGILE_MODBUS_FC_WRITE_SINGLE_COIL:
121 case AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER:
122 case AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS:
123 case AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS:
124 length = 4;
125 break;
126
127 case AGILE_MODBUS_FC_MASK_WRITE_REGISTER:
128 length = 6;
129 break;
130
131 default:
132 length = 1;
133 if (ctx->compute_meta_length_after_function)
134 length = ctx->compute_meta_length_after_function(ctx, function, msg_type);
135 }
136 }
137
138 return length;
139}
140
177static int agile_modbus_compute_data_length_after_meta(agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type)
178{
179 int function = msg[ctx->backend->header_length];
180 int length;
181
182 if (msg_type == AGILE_MODBUS_MSG_INDICATION) {
183 switch (function) {
184 case AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS:
185 case AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS:
186 length = msg[ctx->backend->header_length + 5];
187 break;
188
189 case AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS:
190 length = msg[ctx->backend->header_length + 9];
191 break;
192
193 default:
194 length = 0;
195 if (ctx->compute_data_length_after_meta)
196 length = ctx->compute_data_length_after_meta(ctx, msg, msg_length, msg_type);
197 }
198 } else {
199 /* MSG_CONFIRMATION */
200 if (function <= AGILE_MODBUS_FC_READ_INPUT_REGISTERS ||
201 function == AGILE_MODBUS_FC_REPORT_SLAVE_ID ||
202 function == AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS) {
203 length = msg[ctx->backend->header_length + 1];
204 } else {
205 length = 0;
206 if (ctx->compute_data_length_after_meta)
207 length = ctx->compute_data_length_after_meta(ctx, msg, msg_length, msg_type);
208 }
209 }
210
211 length += ctx->backend->checksum_length;
212
213 return length;
214}
215
224static int agile_modbus_receive_msg_judge(agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type)
225{
226 int remain_len = msg_length;
227
228 remain_len -= (ctx->backend->header_length + 1);
229 if (remain_len < 0)
230 return -1;
231 remain_len -= agile_modbus_compute_meta_length_after_function(ctx, msg[ctx->backend->header_length], msg_type);
232 if (remain_len < 0)
233 return -1;
234 remain_len -= agile_modbus_compute_data_length_after_meta(ctx, msg, msg_length, msg_type);
235 if (remain_len < 0)
236 return -1;
237
238 return ctx->backend->check_integrity(ctx, msg, msg_length - remain_len);
239}
240
257void agile_modbus_common_init(agile_modbus_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
258{
259 memset(ctx, 0, sizeof(agile_modbus_t));
260 ctx->slave = -1;
261 ctx->send_buf = send_buf;
262 ctx->send_bufsz = send_bufsz;
263 ctx->read_buf = read_buf;
264 ctx->read_bufsz = read_bufsz;
265}
266
273int agile_modbus_set_slave(agile_modbus_t *ctx, int slave)
274{
275 return ctx->backend->set_slave(ctx, slave);
276}
277
284void agile_modbus_set_compute_meta_length_after_function_cb(agile_modbus_t *ctx,
285 uint8_t (*cb)(agile_modbus_t *ctx, int function,
286 agile_modbus_msg_type_t msg_type))
287{
288 ctx->compute_meta_length_after_function = cb;
289}
290
297void agile_modbus_set_compute_data_length_after_meta_cb(agile_modbus_t *ctx,
298 int (*cb)(agile_modbus_t *ctx, uint8_t *msg,
299 int msg_length, agile_modbus_msg_type_t msg_type))
300{
301 ctx->compute_data_length_after_meta = cb;
302}
303
312int agile_modbus_receive_judge(agile_modbus_t *ctx, int msg_length, agile_modbus_msg_type_t msg_type)
313{
314 if ((msg_length <= 0) || (msg_length > ctx->read_bufsz))
315 return -1;
316
317 int rc = agile_modbus_receive_msg_judge(ctx, ctx->read_buf, msg_length, msg_type);
318
319 return rc;
320}
321
342static int agile_modbus_compute_response_length_from_request(agile_modbus_t *ctx, uint8_t *req)
343{
344 int length;
345 const int offset = ctx->backend->header_length;
346
347 switch (req[offset]) {
348 case AGILE_MODBUS_FC_READ_COILS:
349 case AGILE_MODBUS_FC_READ_DISCRETE_INPUTS: {
350 /* Header + nb values (code from write_bits) */
351 int nb = (req[offset + 3] << 8) | req[offset + 4];
352 length = 2 + (nb / 8) + ((nb % 8) ? 1 : 0);
353 } break;
354
355 case AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS:
356 case AGILE_MODBUS_FC_READ_HOLDING_REGISTERS:
357 case AGILE_MODBUS_FC_READ_INPUT_REGISTERS:
358 /* Header + 2 * nb values */
359 length = 2 + 2 * (req[offset + 3] << 8 | req[offset + 4]);
360 break;
361
362 case AGILE_MODBUS_FC_WRITE_SINGLE_COIL:
363 case AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER:
364 case AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS:
365 case AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS:
366 length = 5;
367 break;
368
369 case AGILE_MODBUS_FC_MASK_WRITE_REGISTER:
370 length = 7;
371 break;
372
373 default:
374 /* The response is device specific (the header provides the
375 length) */
376 return AGILE_MODBUS_MSG_LENGTH_UNDEFINED;
377 }
378
379 return offset + length + ctx->backend->checksum_length;
380}
381
391static int agile_modbus_check_confirmation(agile_modbus_t *ctx, uint8_t *req,
392 uint8_t *rsp, int rsp_length)
393{
394 int rc;
395 int rsp_length_computed;
396 const int offset = ctx->backend->header_length;
397 const int function = rsp[offset];
398
399 if (ctx->backend->pre_check_confirmation) {
400 rc = ctx->backend->pre_check_confirmation(ctx, req, rsp, rsp_length);
401 if (rc < 0)
402 return -1;
403 }
404
405 rsp_length_computed = agile_modbus_compute_response_length_from_request(ctx, req);
406
407 /* Exception code */
408 if (function >= 0x80) {
409 if (rsp_length == (offset + 2 + (int)ctx->backend->checksum_length) && req[offset] == (rsp[offset] - 0x80))
410 return (-128 - rsp[offset + 1]);
411 else
412 return -1;
413 }
414
415 /* Check length */
416 if ((rsp_length == rsp_length_computed || rsp_length_computed == AGILE_MODBUS_MSG_LENGTH_UNDEFINED) && function < 0x80) {
417 int req_nb_value;
418 int rsp_nb_value;
419
420 /* Check function code */
421 if (function != req[offset])
422 return -1;
423
424 /* Check the number of values is corresponding to the request */
425 switch (function) {
426 case AGILE_MODBUS_FC_READ_COILS:
427 case AGILE_MODBUS_FC_READ_DISCRETE_INPUTS:
428 /* Read functions, 8 values in a byte (nb
429 * of values in the request and byte count in
430 * the response. */
431 req_nb_value = (req[offset + 3] << 8) + req[offset + 4];
432 req_nb_value = (req_nb_value / 8) + ((req_nb_value % 8) ? 1 : 0);
433 rsp_nb_value = rsp[offset + 1];
434 break;
435
436 case AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS:
437 case AGILE_MODBUS_FC_READ_HOLDING_REGISTERS:
438 case AGILE_MODBUS_FC_READ_INPUT_REGISTERS:
439 /* Read functions 1 value = 2 bytes */
440 req_nb_value = (req[offset + 3] << 8) + req[offset + 4];
441 rsp_nb_value = (rsp[offset + 1] / 2);
442 break;
443
444 case AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS:
445 case AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS:
446 /* N Write functions */
447 req_nb_value = (req[offset + 3] << 8) + req[offset + 4];
448 rsp_nb_value = (rsp[offset + 3] << 8) | rsp[offset + 4];
449 break;
450
451 case AGILE_MODBUS_FC_REPORT_SLAVE_ID:
452 /* Report slave ID (bytes received) */
453 req_nb_value = rsp_nb_value = rsp[offset + 1];
454 break;
455
456 default:
457 /* 1 Write functions & others */
458 req_nb_value = rsp_nb_value = 1;
459 }
460
461 if (req_nb_value == rsp_nb_value)
462 rc = rsp_nb_value;
463 else
464 rc = -1;
465 } else
466 rc = -1;
467
468 return rc;
469}
470
493int agile_modbus_serialize_read_bits(agile_modbus_t *ctx, int addr, int nb)
494{
495 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
496 if (ctx->send_bufsz < min_req_length)
497 return -1;
498
499 if (nb > AGILE_MODBUS_MAX_READ_BITS)
500 return -1;
501
502 int req_length = 0;
503 req_length = ctx->backend->build_request_basis(ctx, AGILE_MODBUS_FC_READ_COILS, addr, nb, ctx->send_buf);
504 req_length = ctx->backend->send_msg_pre(ctx->send_buf, req_length);
505
506 return req_length;
507}
508
509int agile_modbus_deserialize_read_bits(agile_modbus_t *ctx, int msg_length, uint8_t *dest)
510{
511 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
512 if (ctx->send_bufsz < min_req_length)
513 return -1;
514 if ((msg_length <= 0) || (msg_length > ctx->read_bufsz))
515 return -1;
516
517 int rc = agile_modbus_receive_msg_judge(ctx, ctx->read_buf, msg_length, AGILE_MODBUS_MSG_CONFIRMATION);
518 if (rc < 0)
519 return -1;
520
521 rc = agile_modbus_check_confirmation(ctx, ctx->send_buf, ctx->read_buf, rc);
522 if (rc < 0)
523 return rc;
524
525 int i, temp, bit;
526 int pos = 0;
527 int offset;
528 int offset_end;
529 int nb;
530
531 offset = ctx->backend->header_length + 2;
532 offset_end = offset + rc;
533 nb = (ctx->send_buf[ctx->backend->header_length + 3] << 8) + ctx->send_buf[ctx->backend->header_length + 4];
534
535 for (i = offset; i < offset_end; i++) {
536 /* Shift reg hi_byte to temp */
537 temp = ctx->read_buf[i];
538
539 for (bit = 0x01; (bit & 0xff) && (pos < nb);) {
540 dest[pos++] = (temp & bit) ? 1 : 0;
541 bit = bit << 1;
542 }
543 }
544
545 return nb;
546}
547
548int agile_modbus_serialize_read_input_bits(agile_modbus_t *ctx, int addr, int nb)
549{
550 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
551 if (ctx->send_bufsz < min_req_length)
552 return -1;
553
554 if (nb > AGILE_MODBUS_MAX_READ_BITS)
555 return -1;
556
557 int req_length = 0;
558 req_length = ctx->backend->build_request_basis(ctx, AGILE_MODBUS_FC_READ_DISCRETE_INPUTS, addr, nb, ctx->send_buf);
559 req_length = ctx->backend->send_msg_pre(ctx->send_buf, req_length);
560
561 return req_length;
562}
563
564int agile_modbus_deserialize_read_input_bits(agile_modbus_t *ctx, int msg_length, uint8_t *dest)
565{
566 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
567 if (ctx->send_bufsz < min_req_length)
568 return -1;
569 if ((msg_length <= 0) || (msg_length > ctx->read_bufsz))
570 return -1;
571
572 int rc = agile_modbus_receive_msg_judge(ctx, ctx->read_buf, msg_length, AGILE_MODBUS_MSG_CONFIRMATION);
573 if (rc < 0)
574 return -1;
575
576 rc = agile_modbus_check_confirmation(ctx, ctx->send_buf, ctx->read_buf, rc);
577 if (rc < 0)
578 return rc;
579
580 int i, temp, bit;
581 int pos = 0;
582 int offset;
583 int offset_end;
584 int nb;
585
586 offset = ctx->backend->header_length + 2;
587 offset_end = offset + rc;
588 nb = (ctx->send_buf[ctx->backend->header_length + 3] << 8) + ctx->send_buf[ctx->backend->header_length + 4];
589
590 for (i = offset; i < offset_end; i++) {
591 /* Shift reg hi_byte to temp */
592 temp = ctx->read_buf[i];
593
594 for (bit = 0x01; (bit & 0xff) && (pos < nb);) {
595 dest[pos++] = (temp & bit) ? 1 : 0;
596 bit = bit << 1;
597 }
598 }
599
600 return nb;
601}
602
603int agile_modbus_serialize_read_registers(agile_modbus_t *ctx, int addr, int nb)
604{
605 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
606 if (ctx->send_bufsz < min_req_length)
607 return -1;
608
609 if (nb > AGILE_MODBUS_MAX_READ_REGISTERS)
610 return -1;
611
612 int req_length = 0;
613 req_length = ctx->backend->build_request_basis(ctx, AGILE_MODBUS_FC_READ_HOLDING_REGISTERS, addr, nb, ctx->send_buf);
614 req_length = ctx->backend->send_msg_pre(ctx->send_buf, req_length);
615
616 return req_length;
617}
618
619int agile_modbus_deserialize_read_registers(agile_modbus_t *ctx, int msg_length, uint16_t *dest)
620{
621 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
622 if (ctx->send_bufsz < min_req_length)
623 return -1;
624 if ((msg_length <= 0) || (msg_length > ctx->read_bufsz))
625 return -1;
626
627 int rc = agile_modbus_receive_msg_judge(ctx, ctx->read_buf, msg_length, AGILE_MODBUS_MSG_CONFIRMATION);
628 if (rc < 0)
629 return -1;
630
631 rc = agile_modbus_check_confirmation(ctx, ctx->send_buf, ctx->read_buf, rc);
632 if (rc < 0)
633 return rc;
634
635 int offset;
636 int i;
637
638 offset = ctx->backend->header_length;
639 for (i = 0; i < rc; i++) {
640 /* shift reg hi_byte to temp OR with lo_byte */
641 dest[i] = (ctx->read_buf[offset + 2 + (i << 1)] << 8) | ctx->read_buf[offset + 3 + (i << 1)];
642 }
643
644 return rc;
645}
646
647int agile_modbus_serialize_read_input_registers(agile_modbus_t *ctx, int addr, int nb)
648{
649 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
650 if (ctx->send_bufsz < min_req_length)
651 return -1;
652
653 if (nb > AGILE_MODBUS_MAX_READ_REGISTERS)
654 return -1;
655
656 int req_length = 0;
657 req_length = ctx->backend->build_request_basis(ctx, AGILE_MODBUS_FC_READ_INPUT_REGISTERS, addr, nb, ctx->send_buf);
658 req_length = ctx->backend->send_msg_pre(ctx->send_buf, req_length);
659
660 return req_length;
661}
662
663int agile_modbus_deserialize_read_input_registers(agile_modbus_t *ctx, int msg_length, uint16_t *dest)
664{
665 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
666 if (ctx->send_bufsz < min_req_length)
667 return -1;
668 if ((msg_length <= 0) || (msg_length > ctx->read_bufsz))
669 return -1;
670
671 int rc = agile_modbus_receive_msg_judge(ctx, ctx->read_buf, msg_length, AGILE_MODBUS_MSG_CONFIRMATION);
672 if (rc < 0)
673 return -1;
674
675 rc = agile_modbus_check_confirmation(ctx, ctx->send_buf, ctx->read_buf, rc);
676 if (rc < 0)
677 return rc;
678
679 int offset;
680 int i;
681
682 offset = ctx->backend->header_length;
683 for (i = 0; i < rc; i++) {
684 /* shift reg hi_byte to temp OR with lo_byte */
685 dest[i] = (ctx->read_buf[offset + 2 + (i << 1)] << 8) | ctx->read_buf[offset + 3 + (i << 1)];
686 }
687
688 return rc;
689}
690
691int agile_modbus_serialize_write_bit(agile_modbus_t *ctx, int addr, int status)
692{
693 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
694 if (ctx->send_bufsz < min_req_length)
695 return -1;
696
697 int req_length = 0;
698 req_length = ctx->backend->build_request_basis(ctx, AGILE_MODBUS_FC_WRITE_SINGLE_COIL, addr, status ? 0xFF00 : 0, ctx->send_buf);
699 req_length = ctx->backend->send_msg_pre(ctx->send_buf, req_length);
700
701 return req_length;
702}
703
704int agile_modbus_deserialize_write_bit(agile_modbus_t *ctx, int msg_length)
705{
706 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
707 if (ctx->send_bufsz < min_req_length)
708 return -1;
709 if ((msg_length <= 0) || (msg_length > ctx->read_bufsz))
710 return -1;
711
712 int rc = agile_modbus_receive_msg_judge(ctx, ctx->read_buf, msg_length, AGILE_MODBUS_MSG_CONFIRMATION);
713 if (rc < 0)
714 return -1;
715
716 rc = agile_modbus_check_confirmation(ctx, ctx->send_buf, ctx->read_buf, rc);
717
718 return rc;
719}
720
721int agile_modbus_serialize_write_register(agile_modbus_t *ctx, int addr, const uint16_t value)
722{
723 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
724 if (ctx->send_bufsz < min_req_length)
725 return -1;
726
727 int req_length = 0;
728 req_length = ctx->backend->build_request_basis(ctx, AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER, addr, (int)value, ctx->send_buf);
729 req_length = ctx->backend->send_msg_pre(ctx->send_buf, req_length);
730
731 return req_length;
732}
733
734int agile_modbus_deserialize_write_register(agile_modbus_t *ctx, int msg_length)
735{
736 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
737 if (ctx->send_bufsz < min_req_length)
738 return -1;
739 if ((msg_length <= 0) || (msg_length > ctx->read_bufsz))
740 return -1;
741
742 int rc = agile_modbus_receive_msg_judge(ctx, ctx->read_buf, msg_length, AGILE_MODBUS_MSG_CONFIRMATION);
743 if (rc < 0)
744 return -1;
745
746 rc = agile_modbus_check_confirmation(ctx, ctx->send_buf, ctx->read_buf, rc);
747
748 return rc;
749}
750
751int agile_modbus_serialize_write_bits(agile_modbus_t *ctx, int addr, int nb, const uint8_t *src)
752{
753 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
754 if (ctx->send_bufsz < min_req_length)
755 return -1;
756
757 if (nb > AGILE_MODBUS_MAX_WRITE_BITS)
758 return -1;
759
760 int i;
761 int byte_count;
762 int req_length;
763 int bit_check = 0;
764 int pos = 0;
765
766 req_length = ctx->backend->build_request_basis(ctx, AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS, addr, nb, ctx->send_buf);
767 byte_count = (nb / 8) + ((nb % 8) ? 1 : 0);
768
769 min_req_length += (1 + byte_count);
770 if (ctx->send_bufsz < min_req_length)
771 return -1;
772
773 ctx->send_buf[req_length++] = byte_count;
774 for (i = 0; i < byte_count; i++) {
775 int bit;
776
777 bit = 0x01;
778 ctx->send_buf[req_length] = 0;
779
780 while ((bit & 0xFF) && (bit_check++ < nb)) {
781 if (src[pos++])
782 ctx->send_buf[req_length] |= bit;
783 else
784 ctx->send_buf[req_length] &= ~bit;
785
786 bit = bit << 1;
787 }
788 req_length++;
789 }
790
791 req_length = ctx->backend->send_msg_pre(ctx->send_buf, req_length);
792
793 return req_length;
794}
795
796int agile_modbus_deserialize_write_bits(agile_modbus_t *ctx, int msg_length)
797{
798 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
799 if (ctx->send_bufsz < min_req_length)
800 return -1;
801 if ((msg_length <= 0) || (msg_length > ctx->read_bufsz))
802 return -1;
803
804 int rc = agile_modbus_receive_msg_judge(ctx, ctx->read_buf, msg_length, AGILE_MODBUS_MSG_CONFIRMATION);
805 if (rc < 0)
806 return -1;
807
808 rc = agile_modbus_check_confirmation(ctx, ctx->send_buf, ctx->read_buf, rc);
809
810 return rc;
811}
812
813int agile_modbus_serialize_write_registers(agile_modbus_t *ctx, int addr, int nb, const uint16_t *src)
814{
815 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
816 if (ctx->send_bufsz < min_req_length)
817 return -1;
818
819 if (nb > AGILE_MODBUS_MAX_WRITE_REGISTERS)
820 return -1;
821
822 int i;
823 int req_length;
824 int byte_count;
825
826 req_length = ctx->backend->build_request_basis(ctx, AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS, addr, nb, ctx->send_buf);
827 byte_count = nb * 2;
828
829 min_req_length += (1 + byte_count);
830 if (ctx->send_bufsz < min_req_length)
831 return -1;
832
833 ctx->send_buf[req_length++] = byte_count;
834 for (i = 0; i < nb; i++) {
835 ctx->send_buf[req_length++] = src[i] >> 8;
836 ctx->send_buf[req_length++] = src[i] & 0x00FF;
837 }
838
839 req_length = ctx->backend->send_msg_pre(ctx->send_buf, req_length);
840
841 return req_length;
842}
843
844int agile_modbus_deserialize_write_registers(agile_modbus_t *ctx, int msg_length)
845{
846 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
847 if (ctx->send_bufsz < min_req_length)
848 return -1;
849 if ((msg_length <= 0) || (msg_length > ctx->read_bufsz))
850 return -1;
851
852 int rc = agile_modbus_receive_msg_judge(ctx, ctx->read_buf, msg_length, AGILE_MODBUS_MSG_CONFIRMATION);
853 if (rc < 0)
854 return -1;
855
856 rc = agile_modbus_check_confirmation(ctx, ctx->send_buf, ctx->read_buf, rc);
857
858 return rc;
859}
860
861int agile_modbus_serialize_mask_write_register(agile_modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask)
862{
863 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length + 2;
864 if (ctx->send_bufsz < min_req_length)
865 return -1;
866
867 int req_length = 0;
868 req_length = ctx->backend->build_request_basis(ctx, AGILE_MODBUS_FC_MASK_WRITE_REGISTER, addr, 0, ctx->send_buf);
869
870 /* HACKISH, count is not used */
871 req_length -= 2;
872
873 ctx->send_buf[req_length++] = and_mask >> 8;
874 ctx->send_buf[req_length++] = and_mask & 0x00ff;
875 ctx->send_buf[req_length++] = or_mask >> 8;
876 ctx->send_buf[req_length++] = or_mask & 0x00ff;
877
878 req_length = ctx->backend->send_msg_pre(ctx->send_buf, req_length);
879
880 return req_length;
881}
882
883int agile_modbus_deserialize_mask_write_register(agile_modbus_t *ctx, int msg_length)
884{
885 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
886 if (ctx->send_bufsz < min_req_length)
887 return -1;
888 if ((msg_length <= 0) || (msg_length > ctx->read_bufsz))
889 return -1;
890
891 int rc = agile_modbus_receive_msg_judge(ctx, ctx->read_buf, msg_length, AGILE_MODBUS_MSG_CONFIRMATION);
892 if (rc < 0)
893 return -1;
894
895 rc = agile_modbus_check_confirmation(ctx, ctx->send_buf, ctx->read_buf, rc);
896
897 return rc;
898}
899
900int agile_modbus_serialize_write_and_read_registers(agile_modbus_t *ctx,
901 int write_addr, int write_nb,
902 const uint16_t *src,
903 int read_addr, int read_nb)
904{
905 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
906 if (ctx->send_bufsz < min_req_length)
907 return -1;
908
909 if (write_nb > AGILE_MODBUS_MAX_WR_WRITE_REGISTERS)
910 return -1;
911
912 if (read_nb > AGILE_MODBUS_MAX_WR_READ_REGISTERS)
913 return -1;
914
915 int req_length;
916 int i;
917 int byte_count;
918
919 req_length = ctx->backend->build_request_basis(ctx, AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS, read_addr, read_nb, ctx->send_buf);
920 byte_count = write_nb * 2;
921
922 min_req_length += (5 + byte_count);
923 if (ctx->send_bufsz < min_req_length)
924 return -1;
925
926 ctx->send_buf[req_length++] = write_addr >> 8;
927 ctx->send_buf[req_length++] = write_addr & 0x00ff;
928 ctx->send_buf[req_length++] = write_nb >> 8;
929 ctx->send_buf[req_length++] = write_nb & 0x00ff;
930 ctx->send_buf[req_length++] = byte_count;
931 for (i = 0; i < write_nb; i++) {
932 ctx->send_buf[req_length++] = src[i] >> 8;
933 ctx->send_buf[req_length++] = src[i] & 0x00FF;
934 }
935
936 req_length = ctx->backend->send_msg_pre(ctx->send_buf, req_length);
937
938 return req_length;
939}
940
941int agile_modbus_deserialize_write_and_read_registers(agile_modbus_t *ctx, int msg_length, uint16_t *dest)
942{
943 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
944 if (ctx->send_bufsz < min_req_length)
945 return -1;
946 if ((msg_length <= 0) || (msg_length > ctx->read_bufsz))
947 return -1;
948
949 int rc = agile_modbus_receive_msg_judge(ctx, ctx->read_buf, msg_length, AGILE_MODBUS_MSG_CONFIRMATION);
950 if (rc < 0)
951 return -1;
952
953 rc = agile_modbus_check_confirmation(ctx, ctx->send_buf, ctx->read_buf, rc);
954 if (rc < 0)
955 return rc;
956
957 int offset;
958 int i;
959
960 offset = ctx->backend->header_length;
961 for (i = 0; i < rc; i++) {
962 /* shift reg hi_byte to temp OR with lo_byte */
963 dest[i] = (ctx->read_buf[offset + 2 + (i << 1)] << 8) | ctx->read_buf[offset + 3 + (i << 1)];
964 }
965
966 return rc;
967}
968
969int agile_modbus_serialize_report_slave_id(agile_modbus_t *ctx)
970{
971 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
972 if (ctx->send_bufsz < min_req_length)
973 return -1;
974
975 int req_length = 0;
976 req_length = ctx->backend->build_request_basis(ctx, AGILE_MODBUS_FC_REPORT_SLAVE_ID, 0, 0, ctx->send_buf);
977 /* HACKISH, addr and count are not used */
978 req_length -= 4;
979 req_length = ctx->backend->send_msg_pre(ctx->send_buf, req_length);
980
981 return req_length;
982}
983
984int agile_modbus_deserialize_report_slave_id(agile_modbus_t *ctx, int msg_length, int max_dest, uint8_t *dest)
985{
986 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
987 if (ctx->send_bufsz < min_req_length)
988 return -1;
989 if ((msg_length <= 0) || (msg_length > ctx->read_bufsz))
990 return -1;
991 if (max_dest <= 0)
992 return -1;
993
994 int rc = agile_modbus_receive_msg_judge(ctx, ctx->read_buf, msg_length, AGILE_MODBUS_MSG_CONFIRMATION);
995 if (rc < 0)
996 return -1;
997
998 rc = agile_modbus_check_confirmation(ctx, ctx->send_buf, ctx->read_buf, rc);
999 if (rc < 0)
1000 return rc;
1001
1002 int i;
1003 int offset;
1004
1005 offset = ctx->backend->header_length + 2;
1006
1007 /* Byte count, slave id, run indicator status and
1008 additional data. Truncate copy to max_dest. */
1009 for (i = 0; i < rc && i < max_dest; i++) {
1010 dest[i] = ctx->read_buf[offset + i];
1011 }
1012
1013 return rc;
1014}
1015
1031int agile_modbus_serialize_raw_request(agile_modbus_t *ctx, const uint8_t *raw_req, int raw_req_length)
1032{
1033 if (raw_req_length < 2) {
1034 /* The raw request must contain function and slave at least and
1035 must not be longer than the maximum pdu length plus the slave
1036 address. */
1037
1038 return -1;
1039 }
1040
1041 int min_req_length = ctx->backend->header_length + 1 + ctx->backend->checksum_length + raw_req_length - 2;
1042 if (ctx->send_bufsz < min_req_length)
1043 return -1;
1044
1045 agile_modbus_sft_t sft;
1046 int req_length;
1047
1048 sft.slave = raw_req[0];
1049 sft.function = raw_req[1];
1050 /* The t_id is left to zero */
1051 sft.t_id = 0;
1052 /* This response function only set the header so it's convenient here */
1053 req_length = ctx->backend->build_response_basis(&sft, ctx->send_buf);
1054
1055 if (raw_req_length > 2) {
1056 /* Copy data after function code */
1057 memcpy(ctx->send_buf + req_length, raw_req + 2, raw_req_length - 2);
1058 req_length += raw_req_length - 2;
1059 }
1060
1061 req_length = ctx->backend->send_msg_pre(ctx->send_buf, req_length);
1062
1063 return req_length;
1064}
1065
1073int agile_modbus_deserialize_raw_response(agile_modbus_t *ctx, int msg_length)
1074{
1075 int min_req_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
1076 if (ctx->send_bufsz < min_req_length)
1077 return -1;
1078 if ((msg_length <= 0) || (msg_length > ctx->read_bufsz))
1079 return -1;
1080
1081 int rc = agile_modbus_receive_msg_judge(ctx, ctx->read_buf, msg_length, AGILE_MODBUS_MSG_CONFIRMATION);
1082 if (rc < 0)
1083 return -1;
1084
1085 rc = agile_modbus_check_confirmation(ctx, ctx->send_buf, ctx->read_buf, rc);
1086
1087 return rc;
1088}
1089
1113static int agile_modbus_serialize_response_exception(agile_modbus_t *ctx, agile_modbus_sft_t *sft, int exception_code)
1114{
1115 int rsp_length;
1116
1117 /* Build exception response */
1118 sft->function = sft->function + 0x80;
1119 rsp_length = ctx->backend->build_response_basis(sft, ctx->send_buf);
1120 ctx->send_buf[rsp_length++] = exception_code;
1121
1122 return rsp_length;
1123}
1124
1139void agile_modbus_slave_io_set(uint8_t *buf, int index, int status)
1140{
1141 int offset = index / 8;
1142 int shift = index % 8;
1143
1144 if (status)
1145 buf[offset] |= (0x01 << shift);
1146 else
1147 buf[offset] &= ~(0x01 << shift);
1148}
1149
1156uint8_t agile_modbus_slave_io_get(uint8_t *buf, int index)
1157{
1158 int offset = index / 8;
1159 int shift = index % 8;
1160
1161 uint8_t status = (buf[offset] & (0x01 << shift)) ? 1 : 0;
1162
1163 return status;
1164}
1165
1172void agile_modbus_slave_register_set(uint8_t *buf, int index, uint16_t data)
1173{
1174 buf[index * 2] = data >> 8;
1175 buf[index * 2 + 1] = data & 0xFF;
1176}
1177
1184uint16_t agile_modbus_slave_register_get(uint8_t *buf, int index)
1185{
1186 uint16_t data = (buf[index * 2] << 8) + buf[index * 2 + 1];
1187
1188 return data;
1189}
1190
1203int agile_modbus_slave_handle(agile_modbus_t *ctx, int msg_length, uint8_t slave_strict,
1204 agile_modbus_slave_callback_t slave_cb, const void *slave_data, int *frame_length)
1205{
1206 int min_rsp_length = ctx->backend->header_length + 5 + ctx->backend->checksum_length;
1207 if (ctx->send_bufsz < min_rsp_length)
1208 return -1;
1209
1210 int req_length = agile_modbus_receive_judge(ctx, msg_length, AGILE_MODBUS_MSG_INDICATION);
1211 if (req_length < 0)
1212 return -1;
1213 if (frame_length)
1214 *frame_length = req_length;
1215
1216 int offset;
1217 int slave;
1218 int function;
1219 uint16_t address;
1220 int rsp_length = 0;
1221 int exception_code = 0;
1222 agile_modbus_sft_t sft;
1223 uint8_t *req = ctx->read_buf;
1224 uint8_t *rsp = ctx->send_buf;
1225
1226 memset(rsp, 0, ctx->send_bufsz);
1227 offset = ctx->backend->header_length;
1228 slave = req[offset - 1];
1229 function = req[offset];
1230 address = (req[offset + 1] << 8) + req[offset + 2];
1231
1232 sft.slave = slave;
1233 sft.function = function;
1234 sft.t_id = ctx->backend->prepare_response_tid(req, &req_length);
1235
1236 struct agile_modbus_slave_info slave_info = {0};
1237 slave_info.sft = &sft;
1238 slave_info.rsp_length = &rsp_length;
1239 slave_info.address = address;
1240
1241 if (slave_strict) {
1242 if ((slave != ctx->slave) && (slave != AGILE_MODBUS_BROADCAST_ADDRESS))
1243 return 0;
1244 }
1245
1246 switch (function) {
1247 case AGILE_MODBUS_FC_READ_COILS:
1248 case AGILE_MODBUS_FC_READ_DISCRETE_INPUTS: {
1249 int nb = (req[offset + 3] << 8) + req[offset + 4];
1250 if (nb < 1 || AGILE_MODBUS_MAX_READ_BITS < nb) {
1251 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE;
1252 break;
1253 }
1254
1255 int end_address = (int)address + nb - 1;
1256 if (end_address > 0xFFFF) {
1257 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS;
1258 break;
1259 }
1260
1261 rsp_length = ctx->backend->build_response_basis(&sft, rsp);
1262 slave_info.nb = (nb / 8) + ((nb % 8) ? 1 : 0);
1263 rsp[rsp_length++] = slave_info.nb;
1264 slave_info.send_index = rsp_length;
1265 rsp_length += slave_info.nb;
1266 slave_info.nb = nb;
1267 if (ctx->send_bufsz < (rsp_length + ctx->backend->checksum_length)) {
1268 exception_code = AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE;
1269 break;
1270 }
1271 } break;
1272
1273 case AGILE_MODBUS_FC_READ_HOLDING_REGISTERS:
1274 case AGILE_MODBUS_FC_READ_INPUT_REGISTERS: {
1275 int nb = (req[offset + 3] << 8) + req[offset + 4];
1276 if (nb < 1 || AGILE_MODBUS_MAX_READ_REGISTERS < nb) {
1277 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE;
1278 break;
1279 }
1280
1281 int end_address = (int)address + nb - 1;
1282 if (end_address > 0xFFFF) {
1283 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS;
1284 break;
1285 }
1286
1287 rsp_length = ctx->backend->build_response_basis(&sft, rsp);
1288 slave_info.nb = nb << 1;
1289 rsp[rsp_length++] = slave_info.nb;
1290 slave_info.send_index = rsp_length;
1291 rsp_length += slave_info.nb;
1292 slave_info.nb = nb;
1293 if (ctx->send_bufsz < (rsp_length + ctx->backend->checksum_length)) {
1294 exception_code = AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE;
1295 break;
1296 }
1297 } break;
1298
1299 case AGILE_MODBUS_FC_WRITE_SINGLE_COIL: {
1300 if (address > 0xFFFF) {
1301 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS;
1302 break;
1303 }
1304
1305 int data = (req[offset + 3] << 8) + req[offset + 4];
1306 if (data == 0xFF00 || data == 0x0)
1307 data = data ? 1 : 0;
1308 else {
1309 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE;
1310 break;
1311 }
1312
1313 slave_info.buf = (uint8_t *)&data;
1314 rsp_length = req_length;
1315 if (ctx->send_bufsz < (rsp_length + ctx->backend->checksum_length)) {
1316 exception_code = AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE;
1317 break;
1318 }
1319 memcpy(rsp, req, req_length);
1320 } break;
1321
1322 case AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER: {
1323 if (address > 0xFFFF) {
1324 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS;
1325 break;
1326 }
1327
1328 int data = (req[offset + 3] << 8) + req[offset + 4];
1329
1330 slave_info.buf = (uint8_t *)&data;
1331 rsp_length = req_length;
1332 if (ctx->send_bufsz < (rsp_length + ctx->backend->checksum_length)) {
1333 exception_code = AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE;
1334 break;
1335 }
1336 memcpy(rsp, req, req_length);
1337 } break;
1338
1339 case AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS: {
1340 int nb = (req[offset + 3] << 8) + req[offset + 4];
1341 int nb_bits = req[offset + 5];
1342 if (nb < 1 || AGILE_MODBUS_MAX_WRITE_BITS < nb || nb_bits * 8 < nb) {
1343 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE;
1344 break;
1345 }
1346
1347 int end_address = (int)address + nb - 1;
1348 if (end_address > 0xFFFF) {
1349 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS;
1350 break;
1351 }
1352
1353 rsp_length = ctx->backend->build_response_basis(&sft, rsp);
1354 slave_info.nb = nb;
1355 slave_info.buf = &req[offset + 6];
1356 if (ctx->send_bufsz < (rsp_length + ctx->backend->checksum_length + 4)) {
1357 exception_code = AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE;
1358 break;
1359 }
1360 /* 4 to copy the bit address (2) and the quantity of bits */
1361 memcpy(rsp + rsp_length, req + rsp_length, 4);
1362 rsp_length += 4;
1363 } break;
1364
1365 case AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS: {
1366 int nb = (req[offset + 3] << 8) + req[offset + 4];
1367 int nb_bytes = req[offset + 5];
1368 if (nb < 1 || AGILE_MODBUS_MAX_WRITE_REGISTERS < nb || nb_bytes != nb * 2) {
1369 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE;
1370 break;
1371 }
1372
1373 int end_address = (int)address + nb - 1;
1374 if (end_address > 0xFFFF) {
1375 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS;
1376 break;
1377 }
1378
1379 rsp_length = ctx->backend->build_response_basis(&sft, rsp);
1380 slave_info.nb = nb;
1381 slave_info.buf = &req[offset + 6];
1382 if (ctx->send_bufsz < (rsp_length + ctx->backend->checksum_length + 4)) {
1383 exception_code = AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE;
1384 break;
1385 }
1386 /* 4 to copy the address (2) and the no. of registers */
1387 memcpy(rsp + rsp_length, req + rsp_length, 4);
1388 rsp_length += 4;
1389
1390 } break;
1391
1392 case AGILE_MODBUS_FC_REPORT_SLAVE_ID: {
1393 int str_len;
1394 int byte_count_pos;
1395
1396 slave_cb = NULL;
1397 rsp_length = ctx->backend->build_response_basis(&sft, rsp);
1398 /* Skip byte count for now */
1399 byte_count_pos = rsp_length++;
1400 rsp[rsp_length++] = ctx->slave;
1401 /* Run indicator status to ON */
1402 rsp[rsp_length++] = 0xFF;
1403
1404 str_len = strlen(AGILE_MODBUS_VERSION_STRING);
1405 if (ctx->send_bufsz < (rsp_length + ctx->backend->checksum_length + str_len)) {
1406 exception_code = AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE;
1407 break;
1408 }
1409 memcpy(rsp + rsp_length, AGILE_MODBUS_VERSION_STRING, str_len);
1410 rsp_length += str_len;
1411 rsp[byte_count_pos] = rsp_length - byte_count_pos - 1;
1412 } break;
1413
1414 case AGILE_MODBUS_FC_READ_EXCEPTION_STATUS:
1415 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION;
1416 break;
1417
1418 case AGILE_MODBUS_FC_MASK_WRITE_REGISTER: {
1419 if (address > 0xFFFF) {
1420 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS;
1421 break;
1422 }
1423
1424 slave_info.buf = &req[offset + 3];
1425 rsp_length = req_length;
1426 if (ctx->send_bufsz < (rsp_length + ctx->backend->checksum_length)) {
1427 exception_code = AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE;
1428 break;
1429 }
1430 memcpy(rsp, req, req_length);
1431 } break;
1432
1433 case AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS: {
1434 int nb = (req[offset + 3] << 8) + req[offset + 4];
1435 uint16_t address_write = (req[offset + 5] << 8) + req[offset + 6];
1436 int nb_write = (req[offset + 7] << 8) + req[offset + 8];
1437 int nb_write_bytes = req[offset + 9];
1438 if (nb_write < 1 || AGILE_MODBUS_MAX_WR_WRITE_REGISTERS < nb_write ||
1439 nb < 1 || AGILE_MODBUS_MAX_WR_READ_REGISTERS < nb ||
1440 nb_write_bytes != nb_write * 2) {
1441 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE;
1442 break;
1443 }
1444
1445 int end_address = (int)address + nb - 1;
1446 int end_address_write = (int)address_write + nb_write - 1;
1447 if (end_address > 0xFFFF || end_address_write > 0xFFFF) {
1448 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS;
1449 break;
1450 }
1451
1452 rsp_length = ctx->backend->build_response_basis(&sft, rsp);
1453 rsp[rsp_length++] = nb << 1;
1454 slave_info.buf = &req[offset + 3];
1455 slave_info.send_index = rsp_length;
1456 rsp_length += (nb << 1);
1457 if (ctx->send_bufsz < (rsp_length + ctx->backend->checksum_length)) {
1458 exception_code = AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE;
1459 break;
1460 }
1461 } break;
1462
1463 default: {
1464 if (slave_cb == NULL)
1465 exception_code = AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION;
1466 else {
1467 rsp_length = ctx->backend->build_response_basis(&sft, rsp);
1468 slave_info.send_index = rsp_length;
1469 slave_info.buf = &req[offset + 1];
1470 slave_info.nb = req_length - offset - 1;
1471 }
1472 } break;
1473 }
1474
1475 if (exception_code)
1476 rsp_length = agile_modbus_serialize_response_exception(ctx, &sft, exception_code);
1477 else {
1478 if (slave_cb) {
1479 int ret = slave_cb(ctx, &slave_info, slave_data);
1480
1481 if (ret < 0) {
1482 if (ret == -AGILE_MODBUS_EXCEPTION_UNKNOW)
1483 rsp_length = 0;
1484 else
1485 rsp_length = agile_modbus_serialize_response_exception(ctx, &sft, -ret);
1486 }
1487 }
1488 }
1489
1490 if (rsp_length) {
1491 if ((ctx->backend->backend_type == AGILE_MODBUS_BACKEND_TYPE_RTU) && (slave == AGILE_MODBUS_BROADCAST_ADDRESS))
1492 return 0;
1493
1494 rsp_length = ctx->backend->send_msg_pre(rsp, rsp_length);
1495 }
1496
1497 return rsp_length;
1498}
1499
agile_modbus.h
Agile Modbus 软件包通用头文件
agile_modbus_set_compute_data_length_after_meta_cb
void agile_modbus_set_compute_data_length_after_meta_cb(agile_modbus_t *ctx, int(*cb)(agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type))
设置 modbus 对象的计算数据元之后要接收的数据长度回调函数
Definition: agile_modbus.c:297
agile_modbus_common_init
void agile_modbus_common_init(agile_modbus_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
初始化 modbus 句柄
Definition: agile_modbus.c:257
agile_modbus_receive_judge
int agile_modbus_receive_judge(agile_modbus_t *ctx, int msg_length, agile_modbus_msg_type_t msg_type)
校验接收数据正确性
Definition: agile_modbus.c:312
agile_modbus_set_slave
int agile_modbus_set_slave(agile_modbus_t *ctx, int slave)
设置地址
Definition: agile_modbus.c:273
agile_modbus_set_compute_meta_length_after_function_cb
void agile_modbus_set_compute_meta_length_after_function_cb(agile_modbus_t *ctx, uint8_t(*cb)(agile_modbus_t *ctx, int function, agile_modbus_msg_type_t msg_type))
设置 modbus 对象的计算功能码后要接收的数据元长度回调函数
Definition: agile_modbus.c:284
agile_modbus_msg_type_t
agile_modbus_msg_type_t
Modbus 收到消息类型
Definition: agile_modbus.h:165
AGILE_MODBUS_EXCEPTION_UNKNOW
@ AGILE_MODBUS_EXCEPTION_UNKNOW
Definition: agile_modbus.h:144
AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION
@ AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION
Definition: agile_modbus.h:133
AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE
@ AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE
Definition: agile_modbus.h:135
AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS
@ AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS
Definition: agile_modbus.h:134
AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE
@ AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE
Definition: agile_modbus.h:139
AGILE_MODBUS_BACKEND_TYPE_RTU
@ AGILE_MODBUS_BACKEND_TYPE_RTU
RTU
Definition: agile_modbus.h:151
AGILE_MODBUS_MSG_CONFIRMATION
@ AGILE_MODBUS_MSG_CONFIRMATION
服务器端的请求消息
Definition: agile_modbus.h:167
AGILE_MODBUS_MSG_INDICATION
@ AGILE_MODBUS_MSG_INDICATION
主机端的请求消息
Definition: agile_modbus.h:166
AGILE_MODBUS_MSG_LENGTH_UNDEFINED
#define AGILE_MODBUS_MSG_LENGTH_UNDEFINED
对应功能码数据长度未定义
Definition: agile_modbus.c:49
agile_modbus_receive_msg_judge
static int agile_modbus_receive_msg_judge(agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type)
检验接收数据正确性
Definition: agile_modbus.c:224
agile_modbus_compute_meta_length_after_function
static uint8_t agile_modbus_compute_meta_length_after_function(agile_modbus_t *ctx, int function, agile_modbus_msg_type_t msg_type)
计算功能码后要接收的数据元长度
Definition: agile_modbus.c:88
agile_modbus_compute_data_length_after_meta
static int agile_modbus_compute_data_length_after_meta(agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type)
计算数据元之后要接收的数据长度
Definition: agile_modbus.c:177
agile_modbus_serialize_write_register
int agile_modbus_serialize_write_register(agile_modbus_t *ctx, int addr, const uint16_t value)
Definition: agile_modbus.c:721
agile_modbus_serialize_write_and_read_registers
int agile_modbus_serialize_write_and_read_registers(agile_modbus_t *ctx, int write_addr, int write_nb, const uint16_t *src, int read_addr, int read_nb)
Definition: agile_modbus.c:900
agile_modbus_deserialize_write_and_read_registers
int agile_modbus_deserialize_write_and_read_registers(agile_modbus_t *ctx, int msg_length, uint16_t *dest)
Definition: agile_modbus.c:941
agile_modbus_deserialize_mask_write_register
int agile_modbus_deserialize_mask_write_register(agile_modbus_t *ctx, int msg_length)
Definition: agile_modbus.c:883
agile_modbus_deserialize_write_registers
int agile_modbus_deserialize_write_registers(agile_modbus_t *ctx, int msg_length)
Definition: agile_modbus.c:844
agile_modbus_deserialize_write_bit
int agile_modbus_deserialize_write_bit(agile_modbus_t *ctx, int msg_length)
Definition: agile_modbus.c:704
agile_modbus_serialize_read_registers
int agile_modbus_serialize_read_registers(agile_modbus_t *ctx, int addr, int nb)
Definition: agile_modbus.c:603
agile_modbus_deserialize_read_input_bits
int agile_modbus_deserialize_read_input_bits(agile_modbus_t *ctx, int msg_length, uint8_t *dest)
Definition: agile_modbus.c:564
agile_modbus_serialize_write_bits
int agile_modbus_serialize_write_bits(agile_modbus_t *ctx, int addr, int nb, const uint8_t *src)
Definition: agile_modbus.c:751
agile_modbus_serialize_read_bits
int agile_modbus_serialize_read_bits(agile_modbus_t *ctx, int addr, int nb)
Definition: agile_modbus.c:493
agile_modbus_serialize_write_registers
int agile_modbus_serialize_write_registers(agile_modbus_t *ctx, int addr, int nb, const uint16_t *src)
Definition: agile_modbus.c:813
agile_modbus_deserialize_report_slave_id
int agile_modbus_deserialize_report_slave_id(agile_modbus_t *ctx, int msg_length, int max_dest, uint8_t *dest)
Definition: agile_modbus.c:984
agile_modbus_deserialize_read_input_registers
int agile_modbus_deserialize_read_input_registers(agile_modbus_t *ctx, int msg_length, uint16_t *dest)
Definition: agile_modbus.c:663
agile_modbus_deserialize_read_bits
int agile_modbus_deserialize_read_bits(agile_modbus_t *ctx, int msg_length, uint8_t *dest)
Definition: agile_modbus.c:509
agile_modbus_serialize_write_bit
int agile_modbus_serialize_write_bit(agile_modbus_t *ctx, int addr, int status)
Definition: agile_modbus.c:691
agile_modbus_deserialize_write_register
int agile_modbus_deserialize_write_register(agile_modbus_t *ctx, int msg_length)
Definition: agile_modbus.c:734
agile_modbus_serialize_mask_write_register
int agile_modbus_serialize_mask_write_register(agile_modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask)
Definition: agile_modbus.c:861
agile_modbus_deserialize_write_bits
int agile_modbus_deserialize_write_bits(agile_modbus_t *ctx, int msg_length)
Definition: agile_modbus.c:796
agile_modbus_serialize_read_input_registers
int agile_modbus_serialize_read_input_registers(agile_modbus_t *ctx, int addr, int nb)
Definition: agile_modbus.c:647
agile_modbus_deserialize_read_registers
int agile_modbus_deserialize_read_registers(agile_modbus_t *ctx, int msg_length, uint16_t *dest)
Definition: agile_modbus.c:619
agile_modbus_serialize_report_slave_id
int agile_modbus_serialize_report_slave_id(agile_modbus_t *ctx)
Definition: agile_modbus.c:969
agile_modbus_serialize_read_input_bits
int agile_modbus_serialize_read_input_bits(agile_modbus_t *ctx, int addr, int nb)
Definition: agile_modbus.c:548
agile_modbus_check_confirmation
static int agile_modbus_check_confirmation(agile_modbus_t *ctx, uint8_t *req, uint8_t *rsp, int rsp_length)
检查确认从机响应的数据
Definition: agile_modbus.c:391
agile_modbus_compute_response_length_from_request
static int agile_modbus_compute_response_length_from_request(agile_modbus_t *ctx, uint8_t *req)
计算预期响应数据长度
Definition: agile_modbus.c:342
agile_modbus_deserialize_raw_response
int agile_modbus_deserialize_raw_response(agile_modbus_t *ctx, int msg_length)
解析响应原始数据
Definition: agile_modbus.c:1073
agile_modbus_serialize_raw_request
int agile_modbus_serialize_raw_request(agile_modbus_t *ctx, const uint8_t *raw_req, int raw_req_length)
将原始数据打包成请求报文
Definition: agile_modbus.c:1031
AGILE_MODBUS_BROADCAST_ADDRESS
#define AGILE_MODBUS_BROADCAST_ADDRESS
Modbus 广播地址
Definition: agile_modbus.h:55
AGILE_MODBUS_MAX_READ_BITS
#define AGILE_MODBUS_MAX_READ_BITS
Definition: agile_modbus.h:67
AGILE_MODBUS_VERSION_STRING
#define AGILE_MODBUS_VERSION_STRING
Agile Modbus 版本号
Definition: agile_modbus.h:53
AGILE_MODBUS_MAX_WRITE_REGISTERS
#define AGILE_MODBUS_MAX_WRITE_REGISTERS
Definition: agile_modbus.h:86
AGILE_MODBUS_MAX_WRITE_BITS
#define AGILE_MODBUS_MAX_WRITE_BITS
Definition: agile_modbus.h:68
AGILE_MODBUS_MAX_WR_WRITE_REGISTERS
#define AGILE_MODBUS_MAX_WR_WRITE_REGISTERS
Definition: agile_modbus.h:87
AGILE_MODBUS_MAX_READ_REGISTERS
#define AGILE_MODBUS_MAX_READ_REGISTERS
Definition: agile_modbus.h:85
AGILE_MODBUS_MAX_WR_READ_REGISTERS
#define AGILE_MODBUS_MAX_WR_READ_REGISTERS
Definition: agile_modbus.h:88
AGILE_MODBUS_FC_MASK_WRITE_REGISTER
#define AGILE_MODBUS_FC_MASK_WRITE_REGISTER
Definition: agile_modbus.h:44
AGILE_MODBUS_FC_READ_COILS
#define AGILE_MODBUS_FC_READ_COILS
Definition: agile_modbus.h:34
AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER
#define AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER
Definition: agile_modbus.h:39
AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS
#define AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS
Definition: agile_modbus.h:41
AGILE_MODBUS_FC_WRITE_SINGLE_COIL
#define AGILE_MODBUS_FC_WRITE_SINGLE_COIL
Definition: agile_modbus.h:38
AGILE_MODBUS_FC_READ_HOLDING_REGISTERS
#define AGILE_MODBUS_FC_READ_HOLDING_REGISTERS
Definition: agile_modbus.h:36
AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS
#define AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS
Definition: agile_modbus.h:45
AGILE_MODBUS_FC_READ_INPUT_REGISTERS
#define AGILE_MODBUS_FC_READ_INPUT_REGISTERS
Definition: agile_modbus.h:37
AGILE_MODBUS_FC_REPORT_SLAVE_ID
#define AGILE_MODBUS_FC_REPORT_SLAVE_ID
Definition: agile_modbus.h:43
AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS
#define AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS
Definition: agile_modbus.h:42
AGILE_MODBUS_FC_READ_EXCEPTION_STATUS
#define AGILE_MODBUS_FC_READ_EXCEPTION_STATUS
Definition: agile_modbus.h:40
AGILE_MODBUS_FC_READ_DISCRETE_INPUTS
#define AGILE_MODBUS_FC_READ_DISCRETE_INPUTS
Definition: agile_modbus.h:35
agile_modbus_slave_callback_t
int(* agile_modbus_slave_callback_t)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data)
从机回调函数
Definition: agile_modbus.h:251
agile_modbus_slave_handle
int agile_modbus_slave_handle(agile_modbus_t *ctx, int msg_length, uint8_t slave_strict, agile_modbus_slave_callback_t slave_cb, const void *slave_data, int *frame_length)
从机数据处理
Definition: agile_modbus.c:1203
agile_modbus_slave_io_get
uint8_t agile_modbus_slave_io_get(uint8_t *buf, int index)
读取从机 IO 状态
Definition: agile_modbus.c:1156
agile_modbus_slave_io_set
void agile_modbus_slave_io_set(uint8_t *buf, int index, int status)
从机 IO 设置
Definition: agile_modbus.c:1139
agile_modbus_slave_register_get
uint16_t agile_modbus_slave_register_get(uint8_t *buf, int index)
读取从机寄存器数据
Definition: agile_modbus.c:1184
agile_modbus_slave_register_set
void agile_modbus_slave_register_set(uint8_t *buf, int index, uint16_t data)
从机寄存器设置
Definition: agile_modbus.c:1172
agile_modbus_serialize_response_exception
static int agile_modbus_serialize_response_exception(agile_modbus_t *ctx, agile_modbus_sft_t *sft, int exception_code)
打包异常响应数据
Definition: agile_modbus.c:1113
agile_modbus_backend::check_integrity
int(* check_integrity)(agile_modbus_t *ctx, uint8_t *msg, const int msg_length)
检查接收数据完整性接口
Definition: agile_modbus.h:195
agile_modbus_backend::set_slave
int(* set_slave)(agile_modbus_t *ctx, int slave)
设置地址接口
Definition: agile_modbus.h:189
agile_modbus_backend::pre_check_confirmation
int(* pre_check_confirmation)(agile_modbus_t *ctx, const uint8_t *req, const uint8_t *rsp, int rsp_length)
预检查确认接口
Definition: agile_modbus.h:196
agile_modbus_backend::build_response_basis
int(* build_response_basis)(agile_modbus_sft_t *sft, uint8_t *rsp)
构建基础响应报文接口
Definition: agile_modbus.h:192
agile_modbus_backend::header_length
uint32_t header_length
头部长度，不包含功能码
Definition: agile_modbus.h:186
agile_modbus_backend::backend_type
uint32_t backend_type
后端类型
Definition: agile_modbus.h:185
agile_modbus_backend::send_msg_pre
int(* send_msg_pre)(uint8_t *req, int req_length)
预发送数据接口
Definition: agile_modbus.h:194
agile_modbus_backend::prepare_response_tid
int(* prepare_response_tid)(const uint8_t *req, int *req_length)
准备响应接口
Definition: agile_modbus.h:193
agile_modbus_backend::build_request_basis
int(* build_request_basis)(agile_modbus_t *ctx, int function, int addr, int nb, uint8_t *req)
构建基础请求报文接口
Definition: agile_modbus.h:190
agile_modbus_backend::checksum_length
uint32_t checksum_length
校验数据长度
Definition: agile_modbus.h:187
agile_modbus_sft
包含 modbus 头部参数结构体
Definition: agile_modbus.h:173
agile_modbus_sft::slave
int slave
从机地址
Definition: agile_modbus.h:174
agile_modbus_sft::t_id
int t_id
事务标识符
Definition: agile_modbus.h:176
agile_modbus_sft::function
int function
功能码
Definition: agile_modbus.h:175
agile_modbus_slave_info
Agile Modbus 从机信息结构体
Definition: agile_modbus.h:232
agile_modbus_slave_info::buf
uint8_t * buf
不同功能码需要使用的数据域
Definition: agile_modbus.h:237
agile_modbus_slave_info::send_index
int send_index
发送缓冲区当前索引
Definition: agile_modbus.h:238
agile_modbus_slave_info::sft
agile_modbus_sft_t * sft
sft 结构体指针
Definition: agile_modbus.h:233
agile_modbus_slave_info::address
int address
寄存器地址
Definition: agile_modbus.h:235
agile_modbus_slave_info::rsp_length
int * rsp_length
响应数据长度指针
Definition: agile_modbus.h:234
agile_modbus_slave_info::nb
int nb
数目
Definition: agile_modbus.h:236
agile_modbus
Agile Modbus 结构体
Definition: agile_modbus.h:203
agile_modbus::compute_data_length_after_meta
int(* compute_data_length_after_meta)(agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type)
自定义计算数据长度接口
Definition: agile_modbus.h:211
agile_modbus::compute_meta_length_after_function
uint8_t(* compute_meta_length_after_function)(agile_modbus_t *ctx, int function, agile_modbus_msg_type_t msg_type)
自定义计算数据元长度接口
Definition: agile_modbus.h:209
agile_modbus::send_bufsz
int send_bufsz
发送缓冲区大小
Definition: agile_modbus.h:206
agile_modbus::send_buf
uint8_t * send_buf
发送缓冲区
Definition: agile_modbus.h:205
agile_modbus::read_buf
uint8_t * read_buf
接收缓冲区
Definition: agile_modbus.h:207
agile_modbus::backend
const agile_modbus_backend_t * backend
后端接口
Definition: agile_modbus.h:213
agile_modbus::slave
int slave
从机地址
Definition: agile_modbus.h:204
agile_modbus::read_bufsz
int read_bufsz
接收缓冲区大小
Definition: agile_modbus.h:208


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/inc/agile_modbus.h 源文件

  • inc
agile_modbus.h
浏览该文件的文档.
1
14#ifndef __PKG_AGILE_MODBUS_H
15#define __PKG_AGILE_MODBUS_H
16
17#ifdef __cplusplus
18extern "C" {
19#endif
20
21#include <stdint.h>
22
34#define AGILE_MODBUS_FC_READ_COILS 0x01
35#define AGILE_MODBUS_FC_READ_DISCRETE_INPUTS 0x02
36#define AGILE_MODBUS_FC_READ_HOLDING_REGISTERS 0x03
37#define AGILE_MODBUS_FC_READ_INPUT_REGISTERS 0x04
38#define AGILE_MODBUS_FC_WRITE_SINGLE_COIL 0x05
39#define AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER 0x06
40#define AGILE_MODBUS_FC_READ_EXCEPTION_STATUS 0x07
41#define AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS 0x0F
42#define AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS 0x10
43#define AGILE_MODBUS_FC_REPORT_SLAVE_ID 0x11
44#define AGILE_MODBUS_FC_MASK_WRITE_REGISTER 0x16
45#define AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS 0x17
53#define AGILE_MODBUS_VERSION_STRING "AMB_1.1.0"
55#define AGILE_MODBUS_BROADCAST_ADDRESS 0
67#define AGILE_MODBUS_MAX_READ_BITS 2000
68#define AGILE_MODBUS_MAX_WRITE_BITS 1968
85#define AGILE_MODBUS_MAX_READ_REGISTERS 125
86#define AGILE_MODBUS_MAX_WRITE_REGISTERS 123
87#define AGILE_MODBUS_MAX_WR_WRITE_REGISTERS 121
88#define AGILE_MODBUS_MAX_WR_READ_REGISTERS 125
102#define AGILE_MODBUS_MAX_PDU_LENGTH 253
103
116#define AGILE_MODBUS_MAX_ADU_LENGTH 260
132enum {
133 AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 0x01,
134 AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS,
135 AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE,
136 AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE,
137 AGILE_MODBUS_EXCEPTION_ACKNOWLEDGE,
138 AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY,
139 AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE,
140 AGILE_MODBUS_EXCEPTION_MEMORY_PARITY,
141 AGILE_MODBUS_EXCEPTION_NOT_DEFINED,
142 AGILE_MODBUS_EXCEPTION_GATEWAY_PATH,
143 AGILE_MODBUS_EXCEPTION_GATEWAY_TARGET,
144 AGILE_MODBUS_EXCEPTION_UNKNOW = 0xff
145};
146
150typedef enum {
151 AGILE_MODBUS_BACKEND_TYPE_RTU = 0,
152 AGILE_MODBUS_BACKEND_TYPE_TCP
153} agile_modbus_backend_type_t;
154
165typedef enum {
166 AGILE_MODBUS_MSG_INDICATION,
167 AGILE_MODBUS_MSG_CONFIRMATION
168} agile_modbus_msg_type_t;
169
173typedef struct agile_modbus_sft {
174 int slave;
175 int function;
176 int t_id;
177} agile_modbus_sft_t;
178
179typedef struct agile_modbus agile_modbus_t;
184typedef struct agile_modbus_backend {
185 uint32_t backend_type;
186 uint32_t header_length;
187 uint32_t checksum_length;
188 uint32_t max_adu_length;
189 int (*set_slave)(agile_modbus_t *ctx, int slave);
190 int (*build_request_basis)(agile_modbus_t *ctx, int function, int addr,
191 int nb, uint8_t *req);
192 int (*build_response_basis)(agile_modbus_sft_t *sft, uint8_t *rsp);
193 int (*prepare_response_tid)(const uint8_t *req, int *req_length);
194 int (*send_msg_pre)(uint8_t *req, int req_length);
195 int (*check_integrity)(agile_modbus_t *ctx, uint8_t *msg, const int msg_length);
196 int (*pre_check_confirmation)(agile_modbus_t *ctx, const uint8_t *req,
197 const uint8_t *rsp, int rsp_length);
198} agile_modbus_backend_t;
199
203struct agile_modbus {
204 int slave;
205 uint8_t *send_buf;
206 int send_bufsz;
207 uint8_t *read_buf;
208 int read_bufsz;
209 uint8_t (*compute_meta_length_after_function)(agile_modbus_t *ctx, int function,
210 agile_modbus_msg_type_t msg_type);
211 int (*compute_data_length_after_meta)(agile_modbus_t *ctx, uint8_t *msg,
212 int msg_length, agile_modbus_msg_type_t msg_type);
213 const agile_modbus_backend_t *backend;
214 void *backend_data;
215};
216
232struct agile_modbus_slave_info {
233 agile_modbus_sft_t *sft;
234 int *rsp_length;
235 int address;
236 int nb;
237 uint8_t *buf;
238 int send_index;
239};
240
251typedef int (*agile_modbus_slave_callback_t)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data);
252
264void agile_modbus_common_init(agile_modbus_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz);
265int agile_modbus_set_slave(agile_modbus_t *ctx, int slave);
266void agile_modbus_set_compute_meta_length_after_function_cb(agile_modbus_t *ctx,
267 uint8_t (*cb)(agile_modbus_t *ctx, int function,
268 agile_modbus_msg_type_t msg_type));
269void agile_modbus_set_compute_data_length_after_meta_cb(agile_modbus_t *ctx,
270 int (*cb)(agile_modbus_t *ctx, uint8_t *msg,
271 int msg_length, agile_modbus_msg_type_t msg_type));
272int agile_modbus_receive_judge(agile_modbus_t *ctx, int msg_length, agile_modbus_msg_type_t msg_type);
284int agile_modbus_serialize_read_bits(agile_modbus_t *ctx, int addr, int nb);
285int agile_modbus_deserialize_read_bits(agile_modbus_t *ctx, int msg_length, uint8_t *dest);
286int agile_modbus_serialize_read_input_bits(agile_modbus_t *ctx, int addr, int nb);
287int agile_modbus_deserialize_read_input_bits(agile_modbus_t *ctx, int msg_length, uint8_t *dest);
288int agile_modbus_serialize_read_registers(agile_modbus_t *ctx, int addr, int nb);
289int agile_modbus_deserialize_read_registers(agile_modbus_t *ctx, int msg_length, uint16_t *dest);
290int agile_modbus_serialize_read_input_registers(agile_modbus_t *ctx, int addr, int nb);
291int agile_modbus_deserialize_read_input_registers(agile_modbus_t *ctx, int msg_length, uint16_t *dest);
292int agile_modbus_serialize_write_bit(agile_modbus_t *ctx, int addr, int status);
293int agile_modbus_deserialize_write_bit(agile_modbus_t *ctx, int msg_length);
294int agile_modbus_serialize_write_register(agile_modbus_t *ctx, int addr, const uint16_t value);
295int agile_modbus_deserialize_write_register(agile_modbus_t *ctx, int msg_length);
296int agile_modbus_serialize_write_bits(agile_modbus_t *ctx, int addr, int nb, const uint8_t *src);
297int agile_modbus_deserialize_write_bits(agile_modbus_t *ctx, int msg_length);
298int agile_modbus_serialize_write_registers(agile_modbus_t *ctx, int addr, int nb, const uint16_t *src);
299int agile_modbus_deserialize_write_registers(agile_modbus_t *ctx, int msg_length);
300int agile_modbus_serialize_mask_write_register(agile_modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask);
301int agile_modbus_deserialize_mask_write_register(agile_modbus_t *ctx, int msg_length);
302int agile_modbus_serialize_write_and_read_registers(agile_modbus_t *ctx,
303 int write_addr, int write_nb,
304 const uint16_t *src,
305 int read_addr, int read_nb);
306int agile_modbus_deserialize_write_and_read_registers(agile_modbus_t *ctx, int msg_length, uint16_t *dest);
307int agile_modbus_serialize_report_slave_id(agile_modbus_t *ctx);
308int agile_modbus_deserialize_report_slave_id(agile_modbus_t *ctx, int msg_length, int max_dest, uint8_t *dest);
316int agile_modbus_serialize_raw_request(agile_modbus_t *ctx, const uint8_t *raw_req, int raw_req_length);
317int agile_modbus_deserialize_raw_response(agile_modbus_t *ctx, int msg_length);
333int agile_modbus_slave_handle(agile_modbus_t *ctx, int msg_length, uint8_t slave_strict,
334 agile_modbus_slave_callback_t slave_cb, const void *slave_data, int *frame_length);
335void agile_modbus_slave_io_set(uint8_t *buf, int index, int status);
336uint8_t agile_modbus_slave_io_get(uint8_t *buf, int index);
337void agile_modbus_slave_register_set(uint8_t *buf, int index, uint16_t data);
338uint16_t agile_modbus_slave_register_get(uint8_t *buf, int index);
351/* Include RTU and TCP module */
352#include "agile_modbus_rtu.h"
353#include "agile_modbus_tcp.h"
354
355#ifdef __cplusplus
356}
357#endif
358
359#endif /* __PKG_AGILE_MODBUS_H */
agile_modbus_rtu.h
Agile Modbus 软件包 RTU 头文件
agile_modbus_tcp.h
Agile Modbus 软件包 TCP 头文件
agile_modbus_set_compute_data_length_after_meta_cb
void agile_modbus_set_compute_data_length_after_meta_cb(agile_modbus_t *ctx, int(*cb)(agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type))
设置 modbus 对象的计算数据元之后要接收的数据长度回调函数
Definition: agile_modbus.c:297
agile_modbus_common_init
void agile_modbus_common_init(agile_modbus_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
初始化 modbus 句柄
Definition: agile_modbus.c:257
agile_modbus_receive_judge
int agile_modbus_receive_judge(agile_modbus_t *ctx, int msg_length, agile_modbus_msg_type_t msg_type)
校验接收数据正确性
Definition: agile_modbus.c:312
agile_modbus_set_slave
int agile_modbus_set_slave(agile_modbus_t *ctx, int slave)
设置地址
Definition: agile_modbus.c:273
agile_modbus_set_compute_meta_length_after_function_cb
void agile_modbus_set_compute_meta_length_after_function_cb(agile_modbus_t *ctx, uint8_t(*cb)(agile_modbus_t *ctx, int function, agile_modbus_msg_type_t msg_type))
设置 modbus 对象的计算功能码后要接收的数据元长度回调函数
Definition: agile_modbus.c:284
agile_modbus_backend_t
struct agile_modbus_backend agile_modbus_backend_t
Agile Modbus 后端接口结构体
agile_modbus_backend_type_t
agile_modbus_backend_type_t
Modbus 后端类型
Definition: agile_modbus.h:150
agile_modbus_sft_t
struct agile_modbus_sft agile_modbus_sft_t
包含 modbus 头部参数结构体
agile_modbus_msg_type_t
agile_modbus_msg_type_t
Modbus 收到消息类型
Definition: agile_modbus.h:165
AGILE_MODBUS_EXCEPTION_GATEWAY_PATH
@ AGILE_MODBUS_EXCEPTION_GATEWAY_PATH
Definition: agile_modbus.h:142
AGILE_MODBUS_EXCEPTION_UNKNOW
@ AGILE_MODBUS_EXCEPTION_UNKNOW
Definition: agile_modbus.h:144
AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION
@ AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION
Definition: agile_modbus.h:133
AGILE_MODBUS_EXCEPTION_GATEWAY_TARGET
@ AGILE_MODBUS_EXCEPTION_GATEWAY_TARGET
Definition: agile_modbus.h:143
AGILE_MODBUS_EXCEPTION_ACKNOWLEDGE
@ AGILE_MODBUS_EXCEPTION_ACKNOWLEDGE
Definition: agile_modbus.h:137
AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY
@ AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY
Definition: agile_modbus.h:138
AGILE_MODBUS_EXCEPTION_NOT_DEFINED
@ AGILE_MODBUS_EXCEPTION_NOT_DEFINED
Definition: agile_modbus.h:141
AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE
@ AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE
Definition: agile_modbus.h:135
AGILE_MODBUS_EXCEPTION_MEMORY_PARITY
@ AGILE_MODBUS_EXCEPTION_MEMORY_PARITY
Definition: agile_modbus.h:140
AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE
@ AGILE_MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE
Definition: agile_modbus.h:136
AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS
@ AGILE_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS
Definition: agile_modbus.h:134
AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE
@ AGILE_MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE
Definition: agile_modbus.h:139
AGILE_MODBUS_BACKEND_TYPE_RTU
@ AGILE_MODBUS_BACKEND_TYPE_RTU
RTU
Definition: agile_modbus.h:151
AGILE_MODBUS_BACKEND_TYPE_TCP
@ AGILE_MODBUS_BACKEND_TYPE_TCP
TCP
Definition: agile_modbus.h:152
AGILE_MODBUS_MSG_CONFIRMATION
@ AGILE_MODBUS_MSG_CONFIRMATION
服务器端的请求消息
Definition: agile_modbus.h:167
AGILE_MODBUS_MSG_INDICATION
@ AGILE_MODBUS_MSG_INDICATION
主机端的请求消息
Definition: agile_modbus.h:166
agile_modbus_serialize_write_register
int agile_modbus_serialize_write_register(agile_modbus_t *ctx, int addr, const uint16_t value)
Definition: agile_modbus.c:721
agile_modbus_serialize_write_and_read_registers
int agile_modbus_serialize_write_and_read_registers(agile_modbus_t *ctx, int write_addr, int write_nb, const uint16_t *src, int read_addr, int read_nb)
Definition: agile_modbus.c:900
agile_modbus_deserialize_write_and_read_registers
int agile_modbus_deserialize_write_and_read_registers(agile_modbus_t *ctx, int msg_length, uint16_t *dest)
Definition: agile_modbus.c:941
agile_modbus_deserialize_mask_write_register
int agile_modbus_deserialize_mask_write_register(agile_modbus_t *ctx, int msg_length)
Definition: agile_modbus.c:883
agile_modbus_deserialize_write_registers
int agile_modbus_deserialize_write_registers(agile_modbus_t *ctx, int msg_length)
Definition: agile_modbus.c:844
agile_modbus_deserialize_write_bit
int agile_modbus_deserialize_write_bit(agile_modbus_t *ctx, int msg_length)
Definition: agile_modbus.c:704
agile_modbus_serialize_read_registers
int agile_modbus_serialize_read_registers(agile_modbus_t *ctx, int addr, int nb)
Definition: agile_modbus.c:603
agile_modbus_deserialize_read_input_bits
int agile_modbus_deserialize_read_input_bits(agile_modbus_t *ctx, int msg_length, uint8_t *dest)
Definition: agile_modbus.c:564
agile_modbus_serialize_write_bits
int agile_modbus_serialize_write_bits(agile_modbus_t *ctx, int addr, int nb, const uint8_t *src)
Definition: agile_modbus.c:751
agile_modbus_serialize_read_bits
int agile_modbus_serialize_read_bits(agile_modbus_t *ctx, int addr, int nb)
Definition: agile_modbus.c:493
agile_modbus_serialize_write_registers
int agile_modbus_serialize_write_registers(agile_modbus_t *ctx, int addr, int nb, const uint16_t *src)
Definition: agile_modbus.c:813
agile_modbus_deserialize_report_slave_id
int agile_modbus_deserialize_report_slave_id(agile_modbus_t *ctx, int msg_length, int max_dest, uint8_t *dest)
Definition: agile_modbus.c:984
agile_modbus_deserialize_read_input_registers
int agile_modbus_deserialize_read_input_registers(agile_modbus_t *ctx, int msg_length, uint16_t *dest)
Definition: agile_modbus.c:663
agile_modbus_deserialize_read_bits
int agile_modbus_deserialize_read_bits(agile_modbus_t *ctx, int msg_length, uint8_t *dest)
Definition: agile_modbus.c:509
agile_modbus_serialize_write_bit
int agile_modbus_serialize_write_bit(agile_modbus_t *ctx, int addr, int status)
Definition: agile_modbus.c:691
agile_modbus_deserialize_write_register
int agile_modbus_deserialize_write_register(agile_modbus_t *ctx, int msg_length)
Definition: agile_modbus.c:734
agile_modbus_serialize_mask_write_register
int agile_modbus_serialize_mask_write_register(agile_modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask)
Definition: agile_modbus.c:861
agile_modbus_deserialize_write_bits
int agile_modbus_deserialize_write_bits(agile_modbus_t *ctx, int msg_length)
Definition: agile_modbus.c:796
agile_modbus_serialize_read_input_registers
int agile_modbus_serialize_read_input_registers(agile_modbus_t *ctx, int addr, int nb)
Definition: agile_modbus.c:647
agile_modbus_deserialize_read_registers
int agile_modbus_deserialize_read_registers(agile_modbus_t *ctx, int msg_length, uint16_t *dest)
Definition: agile_modbus.c:619
agile_modbus_serialize_report_slave_id
int agile_modbus_serialize_report_slave_id(agile_modbus_t *ctx)
Definition: agile_modbus.c:969
agile_modbus_serialize_read_input_bits
int agile_modbus_serialize_read_input_bits(agile_modbus_t *ctx, int addr, int nb)
Definition: agile_modbus.c:548
agile_modbus_deserialize_raw_response
int agile_modbus_deserialize_raw_response(agile_modbus_t *ctx, int msg_length)
解析响应原始数据
Definition: agile_modbus.c:1073
agile_modbus_serialize_raw_request
int agile_modbus_serialize_raw_request(agile_modbus_t *ctx, const uint8_t *raw_req, int raw_req_length)
将原始数据打包成请求报文
Definition: agile_modbus.c:1031
agile_modbus_slave_callback_t
int(* agile_modbus_slave_callback_t)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data)
从机回调函数
Definition: agile_modbus.h:251
agile_modbus_slave_handle
int agile_modbus_slave_handle(agile_modbus_t *ctx, int msg_length, uint8_t slave_strict, agile_modbus_slave_callback_t slave_cb, const void *slave_data, int *frame_length)
从机数据处理
Definition: agile_modbus.c:1203
agile_modbus_slave_io_get
uint8_t agile_modbus_slave_io_get(uint8_t *buf, int index)
读取从机 IO 状态
Definition: agile_modbus.c:1156
agile_modbus_slave_io_set
void agile_modbus_slave_io_set(uint8_t *buf, int index, int status)
从机 IO 设置
Definition: agile_modbus.c:1139
agile_modbus_slave_register_get
uint16_t agile_modbus_slave_register_get(uint8_t *buf, int index)
读取从机寄存器数据
Definition: agile_modbus.c:1184
agile_modbus_slave_register_set
void agile_modbus_slave_register_set(uint8_t *buf, int index, uint16_t data)
从机寄存器设置
Definition: agile_modbus.c:1172
agile_modbus_backend
Agile Modbus 后端接口结构体
Definition: agile_modbus.h:184
agile_modbus_backend::check_integrity
int(* check_integrity)(agile_modbus_t *ctx, uint8_t *msg, const int msg_length)
检查接收数据完整性接口
Definition: agile_modbus.h:195
agile_modbus_backend::set_slave
int(* set_slave)(agile_modbus_t *ctx, int slave)
设置地址接口
Definition: agile_modbus.h:189
agile_modbus_backend::max_adu_length
uint32_t max_adu_length
后端 ADU 长度
Definition: agile_modbus.h:188
agile_modbus_backend::pre_check_confirmation
int(* pre_check_confirmation)(agile_modbus_t *ctx, const uint8_t *req, const uint8_t *rsp, int rsp_length)
预检查确认接口
Definition: agile_modbus.h:196
agile_modbus_backend::build_response_basis
int(* build_response_basis)(agile_modbus_sft_t *sft, uint8_t *rsp)
构建基础响应报文接口
Definition: agile_modbus.h:192
agile_modbus_backend::header_length
uint32_t header_length
头部长度，不包含功能码
Definition: agile_modbus.h:186
agile_modbus_backend::backend_type
uint32_t backend_type
后端类型
Definition: agile_modbus.h:185
agile_modbus_backend::send_msg_pre
int(* send_msg_pre)(uint8_t *req, int req_length)
预发送数据接口
Definition: agile_modbus.h:194
agile_modbus_backend::prepare_response_tid
int(* prepare_response_tid)(const uint8_t *req, int *req_length)
准备响应接口
Definition: agile_modbus.h:193
agile_modbus_backend::build_request_basis
int(* build_request_basis)(agile_modbus_t *ctx, int function, int addr, int nb, uint8_t *req)
构建基础请求报文接口
Definition: agile_modbus.h:190
agile_modbus_backend::checksum_length
uint32_t checksum_length
校验数据长度
Definition: agile_modbus.h:187
agile_modbus_sft
包含 modbus 头部参数结构体
Definition: agile_modbus.h:173
agile_modbus_sft::slave
int slave
从机地址
Definition: agile_modbus.h:174
agile_modbus_sft::t_id
int t_id
事务标识符
Definition: agile_modbus.h:176
agile_modbus_slave_info
Agile Modbus 从机信息结构体
Definition: agile_modbus.h:232
agile_modbus_slave_info::buf
uint8_t * buf
不同功能码需要使用的数据域
Definition: agile_modbus.h:237
agile_modbus_slave_info::send_index
int send_index
发送缓冲区当前索引
Definition: agile_modbus.h:238
agile_modbus_slave_info::sft
agile_modbus_sft_t * sft
sft 结构体指针
Definition: agile_modbus.h:233
agile_modbus_slave_info::address
int address
寄存器地址
Definition: agile_modbus.h:235
agile_modbus_slave_info::rsp_length
int * rsp_length
响应数据长度指针
Definition: agile_modbus.h:234
agile_modbus_slave_info::nb
int nb
数目
Definition: agile_modbus.h:236
agile_modbus
Agile Modbus 结构体
Definition: agile_modbus.h:203
agile_modbus::compute_data_length_after_meta
int(* compute_data_length_after_meta)(agile_modbus_t *ctx, uint8_t *msg, int msg_length, agile_modbus_msg_type_t msg_type)
自定义计算数据长度接口
Definition: agile_modbus.h:211
agile_modbus::compute_meta_length_after_function
uint8_t(* compute_meta_length_after_function)(agile_modbus_t *ctx, int function, agile_modbus_msg_type_t msg_type)
自定义计算数据元长度接口
Definition: agile_modbus.h:209
agile_modbus::send_bufsz
int send_bufsz
发送缓冲区大小
Definition: agile_modbus.h:206
agile_modbus::send_buf
uint8_t * send_buf
发送缓冲区
Definition: agile_modbus.h:205
agile_modbus::read_buf
uint8_t * read_buf
接收缓冲区
Definition: agile_modbus.h:207
agile_modbus::backend
const agile_modbus_backend_t * backend
后端接口
Definition: agile_modbus.h:213
agile_modbus::slave
int slave
从机地址
Definition: agile_modbus.h:204
agile_modbus::read_bufsz
int read_bufsz
接收缓冲区大小
Definition: agile_modbus.h:208
agile_modbus::backend_data
void * backend_data
后端数据，指向 RTU 或 TCP 结构体
Definition: agile_modbus.h:214


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/src/agile_modbus_rtu.c 源文件

  • src
agile_modbus_rtu.c
浏览该文件的文档.
1
14#include "agile_modbus.h"
15#include "agile_modbus_rtu.h"
16
25static const uint8_t _table_crc_hi[] =
26 {
27 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
28 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
29 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
30 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
31 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
32 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
33 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
34 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
35 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
36 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
37 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
38 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
39 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
40 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
41 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
42 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
43 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
44 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
45 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
46 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
47 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
48 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
49 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
50 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
51 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
52 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40};
53
55static const uint8_t _table_crc_lo[] =
56 {
57 0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06,
58 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD,
59 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
60 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
61 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4,
62 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
63 0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3,
64 0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
65 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
66 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29,
67 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED,
68 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
69 0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60,
70 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67,
71 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
72 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
73 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E,
74 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
75 0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71,
76 0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
77 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
78 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B,
79 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B,
80 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
81 0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42,
82 0x43, 0x83, 0x41, 0x81, 0x80, 0x40};
97static uint16_t agile_modbus_rtu_crc16(uint8_t *buffer, uint16_t buffer_length)
98{
99 uint8_t crc_hi = 0xFF; /* high CRC byte initialized */
100 uint8_t crc_lo = 0xFF; /* low CRC byte initialized */
101 unsigned int i; /* will index into CRC lookup */
102
103 /* pass through message buffer */
104 while (buffer_length--) {
105 i = crc_hi ^ *buffer++; /* calculate the CRC */
106 crc_hi = crc_lo ^ _table_crc_hi[i];
107 crc_lo = _table_crc_lo[i];
108 }
109
110 return (crc_hi << 8 | crc_lo);
111}
112
119static int agile_modbus_rtu_set_slave(agile_modbus_t *ctx, int slave)
120{
121 ctx->slave = slave;
122 return 0;
123}
124
134static int agile_modbus_rtu_build_request_basis(agile_modbus_t *ctx, int function,
135 int addr, int nb,
136 uint8_t *req)
137{
138 req[0] = ctx->slave;
139 req[1] = function;
140 req[2] = addr >> 8;
141 req[3] = addr & 0x00ff;
142 req[4] = nb >> 8;
143 req[5] = nb & 0x00ff;
144
145 return AGILE_MODBUS_RTU_PRESET_REQ_LENGTH;
146}
147
154static int agile_modbus_rtu_build_response_basis(agile_modbus_sft_t *sft, uint8_t *rsp)
155{
156 rsp[0] = sft->slave;
157 rsp[1] = sft->function;
158
159 return AGILE_MODBUS_RTU_PRESET_RSP_LENGTH;
160}
161
169static int agile_modbus_rtu_prepare_response_tid(const uint8_t *req, int *req_length)
170{
171 (*req_length) -= AGILE_MODBUS_RTU_CHECKSUM_LENGTH;
172 /* No TID */
173 return 0;
174}
175
183static int agile_modbus_rtu_send_msg_pre(uint8_t *req, int req_length)
184{
185 uint16_t crc = agile_modbus_rtu_crc16(req, req_length);
186 req[req_length++] = crc >> 8;
187 req[req_length++] = crc & 0x00FF;
188
189 return req_length;
190}
191
199static int agile_modbus_rtu_check_integrity(agile_modbus_t *ctx, uint8_t *msg, const int msg_length)
200{
201 uint16_t crc_calculated;
202 uint16_t crc_received;
203
204 crc_calculated = agile_modbus_rtu_crc16(msg, msg_length - 2);
205 crc_received = (msg[msg_length - 2] << 8) | msg[msg_length - 1];
206
207 /* Check CRC of msg */
208 if (crc_calculated == crc_received)
209 return msg_length;
210
211 return -1;
212}
213
223static int agile_modbus_rtu_pre_check_confirmation(agile_modbus_t *ctx, const uint8_t *req,
224 const uint8_t *rsp, int rsp_length)
225{
226 /* Check responding slave is the slave we requested (except for broacast
227 * request) */
228 if (req[0] != rsp[0] && req[0] != AGILE_MODBUS_BROADCAST_ADDRESS)
229 return -1;
230
231 return 0;
232}
233
245static const agile_modbus_backend_t agile_modbus_rtu_backend =
246 {
247 AGILE_MODBUS_BACKEND_TYPE_RTU,
248 AGILE_MODBUS_RTU_HEADER_LENGTH,
249 AGILE_MODBUS_RTU_CHECKSUM_LENGTH,
250 AGILE_MODBUS_RTU_MAX_ADU_LENGTH,
251 agile_modbus_rtu_set_slave,
252 agile_modbus_rtu_build_request_basis,
253 agile_modbus_rtu_build_response_basis,
254 agile_modbus_rtu_prepare_response_tid,
255 agile_modbus_rtu_send_msg_pre,
256 agile_modbus_rtu_check_integrity,
257 agile_modbus_rtu_pre_check_confirmation};
258
276int agile_modbus_rtu_init(agile_modbus_rtu_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
277{
278 agile_modbus_common_init(&(ctx->_ctx), send_buf, send_bufsz, read_buf, read_bufsz);
279 ctx->_ctx.backend = &agile_modbus_rtu_backend;
280 ctx->_ctx.backend_data = ctx;
281
282 return 0;
283}
284
agile_modbus.h
Agile Modbus 软件包通用头文件
agile_modbus_rtu.h
Agile Modbus 软件包 RTU 头文件
agile_modbus_common_init
void agile_modbus_common_init(agile_modbus_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
初始化 modbus 句柄
Definition: agile_modbus.c:257
AGILE_MODBUS_BACKEND_TYPE_RTU
@ AGILE_MODBUS_BACKEND_TYPE_RTU
RTU
Definition: agile_modbus.h:151
AGILE_MODBUS_BROADCAST_ADDRESS
#define AGILE_MODBUS_BROADCAST_ADDRESS
Modbus 广播地址
Definition: agile_modbus.h:55
AGILE_MODBUS_RTU_HEADER_LENGTH
#define AGILE_MODBUS_RTU_HEADER_LENGTH
Definition: agile_modbus_rtu.h:30
AGILE_MODBUS_RTU_MAX_ADU_LENGTH
#define AGILE_MODBUS_RTU_MAX_ADU_LENGTH
Definition: agile_modbus_rtu.h:43
AGILE_MODBUS_RTU_PRESET_RSP_LENGTH
#define AGILE_MODBUS_RTU_PRESET_RSP_LENGTH
Definition: agile_modbus_rtu.h:32
AGILE_MODBUS_RTU_PRESET_REQ_LENGTH
#define AGILE_MODBUS_RTU_PRESET_REQ_LENGTH
Definition: agile_modbus_rtu.h:31
AGILE_MODBUS_RTU_CHECKSUM_LENGTH
#define AGILE_MODBUS_RTU_CHECKSUM_LENGTH
Definition: agile_modbus_rtu.h:34
agile_modbus_rtu_init
int agile_modbus_rtu_init(agile_modbus_rtu_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
RTU 初始化
Definition: agile_modbus_rtu.c:276
_table_crc_hi
static const uint8_t _table_crc_hi[]
Table of CRC values for high-order byte
Definition: agile_modbus_rtu.c:25
agile_modbus_rtu_backend
static const agile_modbus_backend_t agile_modbus_rtu_backend
RTU 后端接口
Definition: agile_modbus_rtu.c:245
_table_crc_lo
static const uint8_t _table_crc_lo[]
Table of CRC values for low-order byte
Definition: agile_modbus_rtu.c:55
agile_modbus_rtu_build_response_basis
static int agile_modbus_rtu_build_response_basis(agile_modbus_sft_t *sft, uint8_t *rsp)
RTU 构建基础响应报文接口(头部报文)
Definition: agile_modbus_rtu.c:154
agile_modbus_rtu_send_msg_pre
static int agile_modbus_rtu_send_msg_pre(uint8_t *req, int req_length)
RTU 预发送数据接口
Definition: agile_modbus_rtu.c:183
agile_modbus_rtu_build_request_basis
static int agile_modbus_rtu_build_request_basis(agile_modbus_t *ctx, int function, int addr, int nb, uint8_t *req)
RTU 构建基础请求报文接口(头部报文)
Definition: agile_modbus_rtu.c:134
agile_modbus_rtu_set_slave
static int agile_modbus_rtu_set_slave(agile_modbus_t *ctx, int slave)
RTU 设置地址接口
Definition: agile_modbus_rtu.c:119
agile_modbus_rtu_crc16
static uint16_t agile_modbus_rtu_crc16(uint8_t *buffer, uint16_t buffer_length)
RTU CRC16 计算
Definition: agile_modbus_rtu.c:97
agile_modbus_rtu_check_integrity
static int agile_modbus_rtu_check_integrity(agile_modbus_t *ctx, uint8_t *msg, const int msg_length)
RTU 检查接收数据完整性接口(CRC16 对比)
Definition: agile_modbus_rtu.c:199
agile_modbus_rtu_pre_check_confirmation
static int agile_modbus_rtu_pre_check_confirmation(agile_modbus_t *ctx, const uint8_t *req, const uint8_t *rsp, int rsp_length)
RTU 预检查确认接口(请求响应地址对比)
Definition: agile_modbus_rtu.c:223
agile_modbus_rtu_prepare_response_tid
static int agile_modbus_rtu_prepare_response_tid(const uint8_t *req, int *req_length)
RTU 准备响应接口
Definition: agile_modbus_rtu.c:169
agile_modbus_backend
Agile Modbus 后端接口结构体
Definition: agile_modbus.h:184
agile_modbus_rtu
RTU 结构体
Definition: agile_modbus_rtu.h:55
agile_modbus_rtu::_ctx
agile_modbus_t _ctx
modbus 句柄
Definition: agile_modbus_rtu.h:56
agile_modbus_sft
包含 modbus 头部参数结构体
Definition: agile_modbus.h:173
agile_modbus_sft::slave
int slave
从机地址
Definition: agile_modbus.h:174
agile_modbus_sft::function
int function
功能码
Definition: agile_modbus.h:175
agile_modbus
Agile Modbus 结构体
Definition: agile_modbus.h:203
agile_modbus::backend
const agile_modbus_backend_t * backend
后端接口
Definition: agile_modbus.h:213
agile_modbus::slave
int slave
从机地址
Definition: agile_modbus.h:204
agile_modbus::backend_data
void * backend_data
后端数据，指向 RTU 或 TCP 结构体
Definition: agile_modbus.h:214


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/inc/agile_modbus_rtu.h 源文件

  • inc
agile_modbus_rtu.h
浏览该文件的文档.
1
14#ifndef __PKG_AGILE_MODBUS_RTU_H
15#define __PKG_AGILE_MODBUS_RTU_H
16
17#ifdef __cplusplus
18extern "C" {
19#endif
20
21#include <stdint.h>
22
30#define AGILE_MODBUS_RTU_HEADER_LENGTH 1
31#define AGILE_MODBUS_RTU_PRESET_REQ_LENGTH 6
32#define AGILE_MODBUS_RTU_PRESET_RSP_LENGTH 2
33
34#define AGILE_MODBUS_RTU_CHECKSUM_LENGTH 2
35
43#define AGILE_MODBUS_RTU_MAX_ADU_LENGTH 256
55typedef struct agile_modbus_rtu {
56 agile_modbus_t _ctx;
57} agile_modbus_rtu_t;
58
66int agile_modbus_rtu_init(agile_modbus_rtu_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz);
75#ifdef __cplusplus
76}
77#endif
78
79#endif /* __PKG_AGILE_MODBUS_RTU_H */
agile_modbus_rtu_init
int agile_modbus_rtu_init(agile_modbus_rtu_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
RTU 初始化
Definition: agile_modbus_rtu.c:276
agile_modbus_rtu_t
struct agile_modbus_rtu agile_modbus_rtu_t
RTU 结构体
agile_modbus_rtu
RTU 结构体
Definition: agile_modbus_rtu.h:55
agile_modbus_rtu::_ctx
agile_modbus_t _ctx
modbus 句柄
Definition: agile_modbus_rtu.h:56
agile_modbus
Agile Modbus 结构体
Definition: agile_modbus.h:203


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/util/agile_modbus_slave_util.c 源文件

  • util
agile_modbus_slave_util.c
浏览该文件的文档.
1
14#include "agile_modbus.h"
15#include "agile_modbus_slave_util.h"
16#include <string.h>
17
37static const agile_modbus_slave_util_map_t *get_map_by_addr(const agile_modbus_slave_util_map_t *maps, int nb_maps, int address)
38{
39 for (int i = 0; i < nb_maps; i++) {
40 const agile_modbus_slave_util_map_t *map = &maps[i];
41 if (address >= map->start_addr && address <= map->end_addr)
42 return map;
43 }
44
45 return NULL;
46}
47
58static int read_registers(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
59{
60 uint8_t map_buf[AGILE_MODBUS_MAX_PDU_LENGTH];
61 int function = slave_info->sft->function;
62 int address = slave_info->address;
63 int nb = slave_info->nb;
64 int send_index = slave_info->send_index;
65 const agile_modbus_slave_util_map_t *maps = NULL;
66 int nb_maps = 0;
67
68 switch (function) {
69 case AGILE_MODBUS_FC_READ_COILS: {
70 maps = slave_util->tab_bits;
71 nb_maps = slave_util->nb_bits;
72 } break;
73
74 case AGILE_MODBUS_FC_READ_DISCRETE_INPUTS: {
75 maps = slave_util->tab_input_bits;
76 nb_maps = slave_util->nb_input_bits;
77 } break;
78
79 case AGILE_MODBUS_FC_READ_HOLDING_REGISTERS: {
80 maps = slave_util->tab_registers;
81 nb_maps = slave_util->nb_registers;
82 } break;
83
84 case AGILE_MODBUS_FC_READ_INPUT_REGISTERS: {
85 maps = slave_util->tab_input_registers;
86 nb_maps = slave_util->nb_input_registers;
87 } break;
88
89 default:
90 return -AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION;
91 }
92
93 if (maps == NULL)
94 return 0;
95
96 for (int now_address = address, i = 0; now_address < address + nb; now_address++, i++) {
97 const agile_modbus_slave_util_map_t *map = get_map_by_addr(maps, nb_maps, now_address);
98 if (map == NULL)
99 continue;
100
101 int map_len = map->end_addr - now_address + 1;
102 if (map->get) {
103 memset(map_buf, 0, sizeof(map_buf));
104 map->get(map_buf, sizeof(map_buf));
105 int index = now_address - map->start_addr;
106 int need_len = address + nb - now_address;
107 if (need_len > map_len) {
108 need_len = map_len;
109 }
110
111 if (function == AGILE_MODBUS_FC_READ_COILS || function == AGILE_MODBUS_FC_READ_DISCRETE_INPUTS) {
112 uint8_t *ptr = map_buf;
113 for (int j = 0; j < need_len; j++) {
114 agile_modbus_slave_io_set(ctx->send_buf + send_index, i + j, ptr[index + j]);
115 }
116 } else {
117 uint16_t *ptr = (uint16_t *)map_buf;
118 for (int j = 0; j < need_len; j++) {
119 agile_modbus_slave_register_set(ctx->send_buf + send_index, i + j, ptr[index + j]);
120 }
121 }
122 }
123
124 now_address += map_len - 1;
125 i += map_len - 1;
126 }
127
128 return 0;
129}
130
141static int write_registers(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
142{
143 uint8_t map_buf[AGILE_MODBUS_MAX_PDU_LENGTH];
144 int function = slave_info->sft->function;
145 int address = slave_info->address;
146 int nb = 0;
147 const agile_modbus_slave_util_map_t *maps = NULL;
148 int nb_maps = 0;
149
150 switch (function) {
151 case AGILE_MODBUS_FC_WRITE_SINGLE_COIL:
152 case AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS: {
153 maps = slave_util->tab_bits;
154 nb_maps = slave_util->nb_bits;
155 if (function == AGILE_MODBUS_FC_WRITE_SINGLE_COIL) {
156 nb = 1;
157 } else {
158 nb = slave_info->nb;
159 }
160 } break;
161
162 case AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER:
163 case AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS: {
164 maps = slave_util->tab_registers;
165 nb_maps = slave_util->nb_registers;
166 if (function == AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER) {
167 nb = 1;
168 } else {
169 nb = slave_info->nb;
170 }
171 } break;
172
173 default:
174 return -AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION;
175 }
176
177 if (maps == NULL)
178 return 0;
179
180 for (int now_address = address, i = 0; now_address < address + nb; now_address++, i++) {
181 const agile_modbus_slave_util_map_t *map = get_map_by_addr(maps, nb_maps, now_address);
182 if (map == NULL)
183 continue;
184
185 int map_len = map->end_addr - now_address + 1;
186 if (map->set) {
187 memset(map_buf, 0, sizeof(map_buf));
188 if (map->get) {
189 map->get(map_buf, sizeof(map_buf));
190 }
191
192 int index = now_address - map->start_addr;
193 int need_len = address + nb - now_address;
194 if (need_len > map_len) {
195 need_len = map_len;
196 }
197
198 if (function == AGILE_MODBUS_FC_WRITE_SINGLE_COIL || function == AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS) {
199 uint8_t *ptr = map_buf;
200 if (function == AGILE_MODBUS_FC_WRITE_SINGLE_COIL) {
201 int data = *((int *)slave_info->buf);
202 ptr[index] = data;
203 } else {
204 for (int j = 0; j < need_len; j++) {
205 uint8_t data = agile_modbus_slave_io_get(slave_info->buf, i + j);
206 ptr[index + j] = data;
207 }
208 }
209 } else {
210 uint16_t *ptr = (uint16_t *)map_buf;
211 if (function == AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER) {
212 int data = *((int *)slave_info->buf);
213 ptr[index] = data;
214 } else {
215 for (int j = 0; j < need_len; j++) {
216 uint16_t data = agile_modbus_slave_register_get(slave_info->buf, i + j);
217 ptr[index + j] = data;
218 }
219 }
220 }
221
222 int rc = map->set(index, need_len, map_buf, sizeof(map_buf));
223 if (rc != 0)
224 return rc;
225 }
226
227 now_address += map_len - 1;
228 i += map_len - 1;
229 }
230
231 return 0;
232}
233
244static int mask_write_register(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
245{
246 uint8_t map_buf[AGILE_MODBUS_MAX_PDU_LENGTH];
247 int address = slave_info->address;
248 const agile_modbus_slave_util_map_t *maps = slave_util->tab_registers;
249 int nb_maps = slave_util->nb_registers;
250
251 if (maps == NULL)
252 return 0;
253
254 const agile_modbus_slave_util_map_t *map = get_map_by_addr(maps, nb_maps, address);
255 if (map == NULL)
256 return 0;
257
258 if (map->set) {
259 memset(map_buf, 0, sizeof(map_buf));
260 if (map->get) {
261 map->get(map_buf, sizeof(map_buf));
262 }
263
264 int index = address - map->start_addr;
265 uint16_t *ptr = (uint16_t *)map_buf;
266 uint16_t data = ptr[index];
267 uint16_t and = (slave_info->buf[0] << 8) + slave_info->buf[1];
268 uint16_t or = (slave_info->buf[2] << 8) + slave_info->buf[3];
269
270 data = (data & and) | (or &(~and));
271 ptr[index] = data;
272
273 int rc = map->set(index, 1, map_buf, sizeof(map_buf));
274 if (rc != 0)
275 return rc;
276 }
277
278 return 0;
279}
280
291static int write_read_registers(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
292{
293 uint8_t map_buf[AGILE_MODBUS_MAX_PDU_LENGTH];
294 int address = slave_info->address;
295 int nb = (slave_info->buf[0] << 8) + slave_info->buf[1];
296 int address_write = (slave_info->buf[2] << 8) + slave_info->buf[3];
297 int nb_write = (slave_info->buf[4] << 8) + slave_info->buf[5];
298 int send_index = slave_info->send_index;
299
300 const agile_modbus_slave_util_map_t *maps = slave_util->tab_registers;
301 int nb_maps = slave_util->nb_registers;
302
303 if (maps == NULL)
304 return 0;
305
306 /* Write first. 7 is the offset of the first values to write */
307 for (int now_address = address_write, i = 0; now_address < address_write + nb_write; now_address++, i++) {
308 const agile_modbus_slave_util_map_t *map = get_map_by_addr(maps, nb_maps, now_address);
309 if (map == NULL)
310 continue;
311
312 int map_len = map->end_addr - now_address + 1;
313 if (map->set) {
314 memset(map_buf, 0, sizeof(map_buf));
315 if (map->get) {
316 map->get(map_buf, sizeof(map_buf));
317 }
318
319 int index = now_address - map->start_addr;
320 uint16_t *ptr = (uint16_t *)map_buf;
321 int need_len = address_write + nb_write - now_address;
322 if (need_len > map_len) {
323 need_len = map_len;
324 }
325
326 for (int j = 0; j < need_len; j++) {
327 uint16_t data = agile_modbus_slave_register_get(slave_info->buf + 7, i + j);
328 ptr[index + j] = data;
329 }
330
331 int rc = map->set(index, need_len, map_buf, sizeof(map_buf));
332 if (rc != 0)
333 return rc;
334 }
335
336 now_address += map_len - 1;
337 i += map_len - 1;
338 }
339
340 /* and read the data for the response */
341 for (int now_address = address, i = 0; now_address < address + nb; now_address++, i++) {
342 const agile_modbus_slave_util_map_t *map = get_map_by_addr(maps, nb_maps, now_address);
343 if (map == NULL)
344 continue;
345
346 int map_len = map->end_addr - now_address + 1;
347 if (map->get) {
348 memset(map_buf, 0, sizeof(map_buf));
349 map->get(map_buf, sizeof(map_buf));
350 int index = now_address - map->start_addr;
351 uint16_t *ptr = (uint16_t *)map_buf;
352 int need_len = address + nb - now_address;
353 if (need_len > map_len) {
354 need_len = map_len;
355 }
356
357 for (int j = 0; j < need_len; j++) {
358 agile_modbus_slave_register_set(ctx->send_buf + send_index, i + j, ptr[index + j]);
359 }
360 }
361
362 now_address += map_len - 1;
363 i += map_len - 1;
364 }
365
366 return 0;
367}
368
387int agile_modbus_slave_util_callback(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data)
388{
389 int function = slave_info->sft->function;
390 int ret = 0;
391 const agile_modbus_slave_util_t *slave_util = (const agile_modbus_slave_util_t *)data;
392
393 if (slave_util == NULL)
394 return 0;
395
396 if (slave_util->addr_check) {
397 ret = slave_util->addr_check(ctx, slave_info);
398 if (ret != 0)
399 return ret;
400 }
401
402 switch (function) {
403 case AGILE_MODBUS_FC_READ_COILS:
404 case AGILE_MODBUS_FC_READ_DISCRETE_INPUTS:
405 case AGILE_MODBUS_FC_READ_HOLDING_REGISTERS:
406 case AGILE_MODBUS_FC_READ_INPUT_REGISTERS:
407 ret = read_registers(ctx, slave_info, slave_util);
408 break;
409
410 case AGILE_MODBUS_FC_WRITE_SINGLE_COIL:
411 case AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS:
412 case AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER:
413 case AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS:
414 ret = write_registers(ctx, slave_info, slave_util);
415 break;
416
417 case AGILE_MODBUS_FC_MASK_WRITE_REGISTER:
418 ret = mask_write_register(ctx, slave_info, slave_util);
419 break;
420
421 case AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS:
422 ret = write_read_registers(ctx, slave_info, slave_util);
423 break;
424
425 default: {
426 if (slave_util->special_function) {
427 ret = slave_util->special_function(ctx, slave_info);
428 } else {
429 ret = -AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION;
430 }
431 } break;
432 }
433
434 if (slave_util->done) {
435 slave_util->done(ctx, slave_info, ret);
436 }
437
438 return ret;
439}
440
agile_modbus.h
Agile Modbus 软件包通用头文件
agile_modbus_slave_util.h
Agile Modbus 软件包提供的简易从机接入头文件
AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION
@ AGILE_MODBUS_EXCEPTION_ILLEGAL_FUNCTION
Definition: agile_modbus.h:133
AGILE_MODBUS_MAX_PDU_LENGTH
#define AGILE_MODBUS_MAX_PDU_LENGTH
Definition: agile_modbus.h:102
AGILE_MODBUS_FC_MASK_WRITE_REGISTER
#define AGILE_MODBUS_FC_MASK_WRITE_REGISTER
Definition: agile_modbus.h:44
AGILE_MODBUS_FC_READ_COILS
#define AGILE_MODBUS_FC_READ_COILS
Definition: agile_modbus.h:34
AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER
#define AGILE_MODBUS_FC_WRITE_SINGLE_REGISTER
Definition: agile_modbus.h:39
AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS
#define AGILE_MODBUS_FC_WRITE_MULTIPLE_COILS
Definition: agile_modbus.h:41
AGILE_MODBUS_FC_WRITE_SINGLE_COIL
#define AGILE_MODBUS_FC_WRITE_SINGLE_COIL
Definition: agile_modbus.h:38
AGILE_MODBUS_FC_READ_HOLDING_REGISTERS
#define AGILE_MODBUS_FC_READ_HOLDING_REGISTERS
Definition: agile_modbus.h:36
AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS
#define AGILE_MODBUS_FC_WRITE_AND_READ_REGISTERS
Definition: agile_modbus.h:45
AGILE_MODBUS_FC_READ_INPUT_REGISTERS
#define AGILE_MODBUS_FC_READ_INPUT_REGISTERS
Definition: agile_modbus.h:37
AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS
#define AGILE_MODBUS_FC_WRITE_MULTIPLE_REGISTERS
Definition: agile_modbus.h:42
AGILE_MODBUS_FC_READ_DISCRETE_INPUTS
#define AGILE_MODBUS_FC_READ_DISCRETE_INPUTS
Definition: agile_modbus.h:35
agile_modbus_slave_util_callback
int agile_modbus_slave_util_callback(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data)
从机回调函数
Definition: agile_modbus_slave_util.c:387
write_registers
static int write_registers(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
写寄存器
Definition: agile_modbus_slave_util.c:141
get_map_by_addr
static const agile_modbus_slave_util_map_t * get_map_by_addr(const agile_modbus_slave_util_map_t *maps, int nb_maps, int address)
根据寄存器地址从映射对象数组中获取映射对象
Definition: agile_modbus_slave_util.c:37
read_registers
static int read_registers(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
读取寄存器
Definition: agile_modbus_slave_util.c:58
mask_write_register
static int mask_write_register(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
掩码写寄存器
Definition: agile_modbus_slave_util.c:244
write_read_registers
static int write_read_registers(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const agile_modbus_slave_util_t *slave_util)
写并读寄存器
Definition: agile_modbus_slave_util.c:291
agile_modbus_slave_io_get
uint8_t agile_modbus_slave_io_get(uint8_t *buf, int index)
读取从机 IO 状态
Definition: agile_modbus.c:1156
agile_modbus_slave_io_set
void agile_modbus_slave_io_set(uint8_t *buf, int index, int status)
从机 IO 设置
Definition: agile_modbus.c:1139
agile_modbus_slave_register_get
uint16_t agile_modbus_slave_register_get(uint8_t *buf, int index)
读取从机寄存器数据
Definition: agile_modbus.c:1184
agile_modbus_slave_register_set
void agile_modbus_slave_register_set(uint8_t *buf, int index, uint16_t data)
从机寄存器设置
Definition: agile_modbus.c:1172
agile_modbus_sft::function
int function
功能码
Definition: agile_modbus.h:175
agile_modbus_slave_info
Agile Modbus 从机信息结构体
Definition: agile_modbus.h:232
agile_modbus_slave_info::buf
uint8_t * buf
不同功能码需要使用的数据域
Definition: agile_modbus.h:237
agile_modbus_slave_info::send_index
int send_index
发送缓冲区当前索引
Definition: agile_modbus.h:238
agile_modbus_slave_info::sft
agile_modbus_sft_t * sft
sft 结构体指针
Definition: agile_modbus.h:233
agile_modbus_slave_info::address
int address
寄存器地址
Definition: agile_modbus.h:235
agile_modbus_slave_info::nb
int nb
数目
Definition: agile_modbus.h:236
agile_modbus_slave_util_map
从机寄存器映射结构体
Definition: agile_modbus_slave_util.h:38
agile_modbus_slave_util_map::get
int(* get)(void *buf, int bufsz)
获取寄存器数据接口
Definition: agile_modbus_slave_util.h:41
agile_modbus_slave_util_map::start_addr
int start_addr
起始地址
Definition: agile_modbus_slave_util.h:39
agile_modbus_slave_util_map::end_addr
int end_addr
结束地址
Definition: agile_modbus_slave_util.h:40
agile_modbus_slave_util_map::set
int(* set)(int index, int len, void *buf, int bufsz)
设置寄存器数据接口
Definition: agile_modbus_slave_util.h:42
agile_modbus_slave_util
从机功能结构体
Definition: agile_modbus_slave_util.h:48
agile_modbus_slave_util::addr_check
int(* addr_check)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info)
地址检查接口
Definition: agile_modbus_slave_util.h:57
agile_modbus_slave_util::nb_input_registers
int nb_input_registers
输入寄存器定义数组数目
Definition: agile_modbus_slave_util.h:56
agile_modbus_slave_util::nb_bits
int nb_bits
线圈寄存器定义数组数目
Definition: agile_modbus_slave_util.h:50
agile_modbus_slave_util::tab_input_registers
const agile_modbus_slave_util_map_t * tab_input_registers
输入寄存器定义数组
Definition: agile_modbus_slave_util.h:55
agile_modbus_slave_util::special_function
int(* special_function)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info)
特殊功能码处理接口
Definition: agile_modbus_slave_util.h:58
agile_modbus_slave_util::nb_input_bits
int nb_input_bits
离散量输入寄存器定义数组数目
Definition: agile_modbus_slave_util.h:52
agile_modbus_slave_util::tab_input_bits
const agile_modbus_slave_util_map_t * tab_input_bits
离散量输入寄存器定义数组
Definition: agile_modbus_slave_util.h:51
agile_modbus_slave_util::done
int(* done)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, int ret)
处理结束接口
Definition: agile_modbus_slave_util.h:59
agile_modbus_slave_util::nb_registers
int nb_registers
保持寄存器定义数组数目
Definition: agile_modbus_slave_util.h:54
agile_modbus_slave_util::tab_bits
const agile_modbus_slave_util_map_t * tab_bits
线圈寄存器定义数组
Definition: agile_modbus_slave_util.h:49
agile_modbus_slave_util::tab_registers
const agile_modbus_slave_util_map_t * tab_registers
保持寄存器定义数组
Definition: agile_modbus_slave_util.h:53
agile_modbus
Agile Modbus 结构体
Definition: agile_modbus.h:203
agile_modbus::send_buf
uint8_t * send_buf
发送缓冲区
Definition: agile_modbus.h:205


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/util/agile_modbus_slave_util.h 源文件

  • util
agile_modbus_slave_util.h
浏览该文件的文档.
1
14#ifndef __PKG_AGILE_MODBUS_SLAVE_UTIL_H
15#define __PKG_AGILE_MODBUS_SLAVE_UTIL_H
16
17#ifdef __cplusplus
18extern "C" {
19#endif
20
21#include <stdint.h>
22
38typedef struct agile_modbus_slave_util_map {
39 int start_addr;
40 int end_addr;
41 int (*get)(void *buf, int bufsz);
42 int (*set)(int index, int len, void *buf, int bufsz);
43} agile_modbus_slave_util_map_t;
44
48typedef struct agile_modbus_slave_util {
49 const agile_modbus_slave_util_map_t *tab_bits;
50 int nb_bits;
51 const agile_modbus_slave_util_map_t *tab_input_bits;
52 int nb_input_bits;
53 const agile_modbus_slave_util_map_t *tab_registers;
54 int nb_registers;
55 const agile_modbus_slave_util_map_t *tab_input_registers;
56 int nb_input_registers;
57 int (*addr_check)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info);
58 int (*special_function)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info);
59 int (*done)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, int ret);
60} agile_modbus_slave_util_t;
61
69int agile_modbus_slave_util_callback(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data);
82#ifdef __cplusplus
83}
84#endif
85
86#endif /* __PKG_AGILE_MODBUS_SLAVE_UTIL_H */
agile_modbus_slave_util_callback
int agile_modbus_slave_util_callback(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, const void *data)
从机回调函数
Definition: agile_modbus_slave_util.c:387
agile_modbus_slave_util_t
struct agile_modbus_slave_util agile_modbus_slave_util_t
从机功能结构体
agile_modbus_slave_util_map_t
struct agile_modbus_slave_util_map agile_modbus_slave_util_map_t
从机寄存器映射结构体
agile_modbus_slave_info
Agile Modbus 从机信息结构体
Definition: agile_modbus.h:232
agile_modbus_slave_util_map
从机寄存器映射结构体
Definition: agile_modbus_slave_util.h:38
agile_modbus_slave_util_map::get
int(* get)(void *buf, int bufsz)
获取寄存器数据接口
Definition: agile_modbus_slave_util.h:41
agile_modbus_slave_util_map::start_addr
int start_addr
起始地址
Definition: agile_modbus_slave_util.h:39
agile_modbus_slave_util_map::end_addr
int end_addr
结束地址
Definition: agile_modbus_slave_util.h:40
agile_modbus_slave_util_map::set
int(* set)(int index, int len, void *buf, int bufsz)
设置寄存器数据接口
Definition: agile_modbus_slave_util.h:42
agile_modbus_slave_util
从机功能结构体
Definition: agile_modbus_slave_util.h:48
agile_modbus_slave_util::addr_check
int(* addr_check)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info)
地址检查接口
Definition: agile_modbus_slave_util.h:57
agile_modbus_slave_util::nb_input_registers
int nb_input_registers
输入寄存器定义数组数目
Definition: agile_modbus_slave_util.h:56
agile_modbus_slave_util::nb_bits
int nb_bits
线圈寄存器定义数组数目
Definition: agile_modbus_slave_util.h:50
agile_modbus_slave_util::tab_input_registers
const agile_modbus_slave_util_map_t * tab_input_registers
输入寄存器定义数组
Definition: agile_modbus_slave_util.h:55
agile_modbus_slave_util::special_function
int(* special_function)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info)
特殊功能码处理接口
Definition: agile_modbus_slave_util.h:58
agile_modbus_slave_util::nb_input_bits
int nb_input_bits
离散量输入寄存器定义数组数目
Definition: agile_modbus_slave_util.h:52
agile_modbus_slave_util::tab_input_bits
const agile_modbus_slave_util_map_t * tab_input_bits
离散量输入寄存器定义数组
Definition: agile_modbus_slave_util.h:51
agile_modbus_slave_util::done
int(* done)(agile_modbus_t *ctx, struct agile_modbus_slave_info *slave_info, int ret)
处理结束接口
Definition: agile_modbus_slave_util.h:59
agile_modbus_slave_util::nb_registers
int nb_registers
保持寄存器定义数组数目
Definition: agile_modbus_slave_util.h:54
agile_modbus_slave_util::tab_bits
const agile_modbus_slave_util_map_t * tab_bits
线圈寄存器定义数组
Definition: agile_modbus_slave_util.h:49
agile_modbus_slave_util::tab_registers
const agile_modbus_slave_util_map_t * tab_registers
保持寄存器定义数组
Definition: agile_modbus_slave_util.h:53
agile_modbus
Agile Modbus 结构体
Definition: agile_modbus.h:203


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/src/agile_modbus_tcp.c 源文件

  • src
agile_modbus_tcp.c
浏览该文件的文档.
1
14#include "agile_modbus.h"
15#include "agile_modbus_tcp.h"
16
31static int agile_modbus_tcp_set_slave(agile_modbus_t *ctx, int slave)
32{
33 ctx->slave = slave;
34 return 0;
35}
36
46static int agile_modbus_tcp_build_request_basis(agile_modbus_t *ctx, int function,
47 int addr, int nb,
48 uint8_t *req)
49{
50 agile_modbus_tcp_t *ctx_tcp = ctx->backend_data;
51
52 /* Increase transaction ID */
53 if (ctx_tcp->t_id < UINT16_MAX)
54 ctx_tcp->t_id++;
55 else
56 ctx_tcp->t_id = 0;
57 req[0] = ctx_tcp->t_id >> 8;
58 req[1] = ctx_tcp->t_id & 0x00ff;
59
60 /* Protocol Modbus */
61 req[2] = 0;
62 req[3] = 0;
63
64 /* Length will be defined later by set_req_length_tcp at offsets 4
65 and 5 */
66
67 req[6] = ctx->slave;
68 req[7] = function;
69 req[8] = addr >> 8;
70 req[9] = addr & 0x00ff;
71 req[10] = nb >> 8;
72 req[11] = nb & 0x00ff;
73
74 return AGILE_MODBUS_TCP_PRESET_REQ_LENGTH;
75}
76
83static int agile_modbus_tcp_build_response_basis(agile_modbus_sft_t *sft, uint8_t *rsp)
84{
85 /* Extract from MODBUS Messaging on TCP/IP Implementation
86 Guide V1.0b (page 23/46):
87 The transaction identifier is used to associate the future
88 response with the request. */
89 rsp[0] = sft->t_id >> 8;
90 rsp[1] = sft->t_id & 0x00ff;
91
92 /* Protocol Modbus */
93 rsp[2] = 0;
94 rsp[3] = 0;
95
96 /* Length will be set later by send_msg (4 and 5) */
97
98 /* The slave ID is copied from the indication */
99 rsp[6] = sft->slave;
100 rsp[7] = sft->function;
101
102 return AGILE_MODBUS_TCP_PRESET_RSP_LENGTH;
103}
104
111static int agile_modbus_tcp_prepare_response_tid(const uint8_t *req, int *req_length)
112{
113 return (req[0] << 8) + req[1];
114}
115
122static int agile_modbus_tcp_send_msg_pre(uint8_t *req, int req_length)
123{
124 /* Substract the header length to the message length */
125 int mbap_length = req_length - 6;
126
127 req[4] = mbap_length >> 8;
128 req[5] = mbap_length & 0x00FF;
129
130 return req_length;
131}
132
140static int agile_modbus_tcp_check_integrity(agile_modbus_t *ctx, uint8_t *msg, const int msg_length)
141{
142 return msg_length;
143}
144
153static int agile_modbus_tcp_pre_check_confirmation(agile_modbus_t *ctx, const uint8_t *req,
154 const uint8_t *rsp, int rsp_length)
155{
156 /* Check transaction ID */
157 if (req[0] != rsp[0] || req[1] != rsp[1])
158 return -1;
159
160 /* Check protocol ID */
161 if (rsp[2] != 0x0 && rsp[3] != 0x0)
162 return -1;
163
164 return 0;
165}
166
178static const agile_modbus_backend_t agile_modbus_tcp_backend =
179 {
180 AGILE_MODBUS_BACKEND_TYPE_TCP,
181 AGILE_MODBUS_TCP_HEADER_LENGTH,
182 AGILE_MODBUS_TCP_CHECKSUM_LENGTH,
183 AGILE_MODBUS_TCP_MAX_ADU_LENGTH,
184 agile_modbus_tcp_set_slave,
185 agile_modbus_tcp_build_request_basis,
186 agile_modbus_tcp_build_response_basis,
187 agile_modbus_tcp_prepare_response_tid,
188 agile_modbus_tcp_send_msg_pre,
189 agile_modbus_tcp_check_integrity,
190 agile_modbus_tcp_pre_check_confirmation};
191
209int agile_modbus_tcp_init(agile_modbus_tcp_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
210{
211 agile_modbus_common_init(&(ctx->_ctx), send_buf, send_bufsz, read_buf, read_bufsz);
212 ctx->_ctx.backend = &agile_modbus_tcp_backend;
213 ctx->_ctx.backend_data = ctx;
214
215 ctx->t_id = 0;
216
217 return 0;
218}
219
agile_modbus.h
Agile Modbus 软件包通用头文件
agile_modbus_tcp.h
Agile Modbus 软件包 TCP 头文件
agile_modbus_common_init
void agile_modbus_common_init(agile_modbus_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
初始化 modbus 句柄
Definition: agile_modbus.c:257
AGILE_MODBUS_BACKEND_TYPE_TCP
@ AGILE_MODBUS_BACKEND_TYPE_TCP
TCP
Definition: agile_modbus.h:152
AGILE_MODBUS_TCP_CHECKSUM_LENGTH
#define AGILE_MODBUS_TCP_CHECKSUM_LENGTH
Definition: agile_modbus_tcp.h:34
AGILE_MODBUS_TCP_PRESET_RSP_LENGTH
#define AGILE_MODBUS_TCP_PRESET_RSP_LENGTH
Definition: agile_modbus_tcp.h:32
AGILE_MODBUS_TCP_MAX_ADU_LENGTH
#define AGILE_MODBUS_TCP_MAX_ADU_LENGTH
Definition: agile_modbus_tcp.h:43
AGILE_MODBUS_TCP_PRESET_REQ_LENGTH
#define AGILE_MODBUS_TCP_PRESET_REQ_LENGTH
Definition: agile_modbus_tcp.h:31
AGILE_MODBUS_TCP_HEADER_LENGTH
#define AGILE_MODBUS_TCP_HEADER_LENGTH
Definition: agile_modbus_tcp.h:30
agile_modbus_tcp_init
int agile_modbus_tcp_init(agile_modbus_tcp_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
TCP 初始化
Definition: agile_modbus_tcp.c:209
agile_modbus_tcp_backend
static const agile_modbus_backend_t agile_modbus_tcp_backend
TCP 后端接口
Definition: agile_modbus_tcp.c:178
agile_modbus_tcp_pre_check_confirmation
static int agile_modbus_tcp_pre_check_confirmation(agile_modbus_t *ctx, const uint8_t *req, const uint8_t *rsp, int rsp_length)
TCP 预检查确认接口(对比事务标识符和协议标识符)
Definition: agile_modbus_tcp.c:153
agile_modbus_tcp_set_slave
static int agile_modbus_tcp_set_slave(agile_modbus_t *ctx, int slave)
TCP 设置地址接口
Definition: agile_modbus_tcp.c:31
agile_modbus_tcp_check_integrity
static int agile_modbus_tcp_check_integrity(agile_modbus_t *ctx, uint8_t *msg, const int msg_length)
TCP 检查接收数据完整性接口
Definition: agile_modbus_tcp.c:140
agile_modbus_tcp_send_msg_pre
static int agile_modbus_tcp_send_msg_pre(uint8_t *req, int req_length)
TCP 预发送数据接口(计算长度字段的值并存入)
Definition: agile_modbus_tcp.c:122
agile_modbus_tcp_build_request_basis
static int agile_modbus_tcp_build_request_basis(agile_modbus_t *ctx, int function, int addr, int nb, uint8_t *req)
TCP 构建基础请求报文接口(头部报文)
Definition: agile_modbus_tcp.c:46
agile_modbus_tcp_build_response_basis
static int agile_modbus_tcp_build_response_basis(agile_modbus_sft_t *sft, uint8_t *rsp)
TCP 构建基础响应报文接口(头部报文)
Definition: agile_modbus_tcp.c:83
agile_modbus_tcp_prepare_response_tid
static int agile_modbus_tcp_prepare_response_tid(const uint8_t *req, int *req_length)
TCP 准备响应接口
Definition: agile_modbus_tcp.c:111
agile_modbus_backend
Agile Modbus 后端接口结构体
Definition: agile_modbus.h:184
agile_modbus_sft
包含 modbus 头部参数结构体
Definition: agile_modbus.h:173
agile_modbus_sft::slave
int slave
从机地址
Definition: agile_modbus.h:174
agile_modbus_sft::t_id
int t_id
事务标识符
Definition: agile_modbus.h:176
agile_modbus_sft::function
int function
功能码
Definition: agile_modbus.h:175
agile_modbus_tcp
TCP 结构体
Definition: agile_modbus_tcp.h:55
agile_modbus_tcp::_ctx
agile_modbus_t _ctx
modbus 句柄
Definition: agile_modbus_tcp.h:56
agile_modbus_tcp::t_id
uint16_t t_id
Extract from MODBUS Messaging on TCP/IP Implementation Guide V1.0b (page 23/46): The transaction iden...
Definition: agile_modbus_tcp.h:57
agile_modbus
Agile Modbus 结构体
Definition: agile_modbus.h:203
agile_modbus::backend
const agile_modbus_backend_t * backend
后端接口
Definition: agile_modbus.h:213
agile_modbus::slave
int slave
从机地址
Definition: agile_modbus.h:204
agile_modbus::backend_data
void * backend_data
后端数据，指向 RTU 或 TCP 结构体
Definition: agile_modbus.h:214


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/inc/agile_modbus_tcp.h 源文件

  • inc
agile_modbus_tcp.h
浏览该文件的文档.
1
14#ifndef __PKG_AGILE_MODBUS_TCP_H
15#define __PKG_AGILE_MODBUS_TCP_H
16
17#ifdef __cplusplus
18extern "C" {
19#endif
20
21#include <stdint.h>
22
30#define AGILE_MODBUS_TCP_HEADER_LENGTH 7
31#define AGILE_MODBUS_TCP_PRESET_REQ_LENGTH 12
32#define AGILE_MODBUS_TCP_PRESET_RSP_LENGTH 8
33
34#define AGILE_MODBUS_TCP_CHECKSUM_LENGTH 0
35
43#define AGILE_MODBUS_TCP_MAX_ADU_LENGTH 260
55typedef struct agile_modbus_tcp {
56 agile_modbus_t _ctx;
57 uint16_t t_id;
61} agile_modbus_tcp_t;
62
70int agile_modbus_tcp_init(agile_modbus_tcp_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz);
79#ifdef __cplusplus
80}
81#endif
82
83#endif
agile_modbus_tcp_init
int agile_modbus_tcp_init(agile_modbus_tcp_t *ctx, uint8_t *send_buf, int send_bufsz, uint8_t *read_buf, int read_bufsz)
TCP 初始化
Definition: agile_modbus_tcp.c:209
agile_modbus_tcp_t
struct agile_modbus_tcp agile_modbus_tcp_t
TCP 结构体
agile_modbus_tcp
TCP 结构体
Definition: agile_modbus_tcp.h:55
agile_modbus_tcp::_ctx
agile_modbus_t _ctx
modbus 句柄
Definition: agile_modbus_tcp.h:56
agile_modbus_tcp::t_id
uint16_t t_id
Extract from MODBUS Messaging on TCP/IP Implementation Guide V1.0b (page 23/46): The transaction iden...
Definition: agile_modbus_tcp.h:57
agile_modbus
Agile Modbus 结构体
Definition: agile_modbus.h:203


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/src -> inc 关系

  • src

src → inc 关系

文件在 src | 在 inc 中引用
agile_modbus.c | agile_modbus.h
agile_modbus_rtu.c | agile_modbus.h
agile_modbus_rtu.c | agile_modbus_rtu.h
agile_modbus_tcp.c | agile_modbus.h
agile_modbus_tcp.c | agile_modbus_tcp.h


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/util -> inc 关系

  • util

util → inc 关系

文件在 util | 在 inc 中引用
agile_modbus_slave_util.c | agile_modbus.h


Agile Modbus: C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/examples/README.md 文件参考

C:/Users/25440/Desktop/stm32f407-atk-explorer/packages/agile_modbus/examples/README.md 文件参考


Agile Modbus: 图例

图例

本页将向您解释如何理解由 doxygen 生成的图.

考虑如下例子:

/*! 由于截断而使 Invisible 不可见 */
class Invisible { };
/*! Truncated 的继承关系将被隐藏 */
class Truncated : public Invisible { };
/* 没有被doxygen文档化的类 */
class Undocumented { };
/*! public 继承关系的类 */
class PublicBase : public Truncated { };
/*! 一个模板类 */
template<class T> class Templ { };
/*! protected 继承关系的类 */
class ProtectedBase { };
/*! private 继承关系的类 */
class PrivateBase { };
/*! 被 Inherited 使用的类 */
class Used { };
/*! 继承自其它若干类的超级类 */
class Inherited : public PublicBase,
protected ProtectedBase,
private PrivateBase,
public Undocumented,
public Templ<int>
{
private:
Used *m_usedClass;
};

结果将会生成以下图:

上图中的矩形有如下意义:

  • 灰色填充的矩形 表示上图是由该结构体或类生成.
  • 黑色边框的矩形 表示已经被文档化的结构体或类.
  • 灰色边框的矩形 表示未被文档化的结构体或类.
  • 红色边框的矩形 表示该结构体或类的关系没有被完全显示.如果生成的图不能调整到制定的尺寸，有一些关系就会被截断而不显示出来.

箭头有如下意义:

  • 深蓝色的箭头被用于展示 public 的继承关系.
  • 深绿色的箭头表示 protected 的继承关系.
  • 深红色的箭头说明了是 privated 的继承关系.
  • 紫色虚线箭头用来表示两个类之间的聚合关系. 被箭头指向的类的类型的变量,可以通过箭头旁标明的变量去访问.
  • 黄色虚线箭头表示模板类实例和模板类之间的关系. 箭头旁边标明了模板类实例化的参数.


Agile Modbus: 相关页面

相关页面
这里列出了所有相关页面:
更新记录
示例说明