[3]rt-thread-nano agile_modbus主机例程

已于 2024-01-04 22:50:04 修改
阅读量810 收藏 14
点赞数 19
分类专栏： rt-thread 文章标签： 嵌入式硬件 stm32 单片机 硬件工程 驱动开发
于 2024-01-04 22:27:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29356039/article/details/135396960
版权

gitee代码：

https://gitee.com/xuwenqiang_1989/rt-thread-nano

简介

移植agile_modbus，演示主机程序。

串口：UART4

过程：每隔3秒，读取从机1的10个位数据和10个寄存器数据，将位数据取反，寄存器数据+1后，再发送返回从机。

1.下载agile_modbus包

agile_modbus作者博客：http://github.loogg.cn/agile_packages/agile_modbus/#_1-3%E3%80%81%E8%AE%B8%E5%8F%AF%E8%AF%81

agile_modbus github下载地址:https://github.com/loogg/agile_modbus

下载后，把agile_modbus放入工程

2.工程配置

将agile_modbus/src内的C文件添加进工程

将agile_modbus/inc内的头文件包含进目录

新建模块modbus_poll.c和modbus_poll.h用于演示主机程序，并用同方法添加进工程

3.在Cubemx中配置UART4

开启UART4，配置波特率，数据等参数

配置UART4所用引脚

配置UART4   DMA接收

开启UART4中断，取消生成IRQ函数（我们自己编写）。

开启DMA接收中断，取消生成IRQ函数。

生成代码

4.modbus_poll.h

modbus_poll.h程序入下图

#ifndef __MODBUS_POLL_H_
#define __MODBUS_POLL_H_

#include "main.h"
#include "board.h"

#include "agile_modbus.h"

int modbus_poll_init(void);

#endif /*__MODBUS_H_*/

5.modbus_poll.c

包含头文件

#include "modbus_poll.h"

声明和定义接收和发送缓冲区

#define UART_PORT huart4                               // 串口
#define UART_REC_MAX_SIZE AGILE_MODBUS_MAX_ADU_LENGTH  // 接收缓冲大小
#define UART_SEND_MAX_SIZE AGILE_MODBUS_MAX_ADU_LENGTH // 发送缓冲大小
static uint8_t rx_buff[UART_REC_MAX_SIZE];             // 接收缓冲区
static uint32_t rx_size;                               // 接收数据长度
static uint8_t tx_buff[UART_SEND_MAX_SIZE];            // 发送缓冲区

定义agile_modbus需要的变量

static uint16_t hold_reg[10];               // 数据寄存器
static uint8_t coil_reg[10];                // 位寄存器
static agile_modbus_rtu_t ctx_rtu;          // rtu结构体
static agile_modbus_t *ctx = &ctx_rtu._ctx; // modbus 结构体

定义接收用信号量，线程句柄。

声明数据发送函数，数据接收函数，线程入口函数。

static rt_sem_t usart_rec_sem = RT_NULL; // 接收信号量

static int modbus_usart_read(rt_int32_t time);                                // 数据发送
static void modbus_usart_send(uint8_t *buff, uint32_t size, rt_int32_t time); // 数据接收

static rt_thread_t modbus_thread = RT_NULL;       // 线程句柄
static void modbus_thread_entry(void *parameter); // 线程入口

modbus_poll.c完整代码：

/* agile_modbus rtu poll sample*/
/* agile modbus rtu 主机程序*/
/* 2023-12-30*/
/* by Qaaa*/

#include "modbus_poll.h"

#define UART_PORT huart4                               // 串口
#define UART_REC_MAX_SIZE AGILE_MODBUS_MAX_ADU_LENGTH  // 接收缓冲大小
#define UART_SEND_MAX_SIZE AGILE_MODBUS_MAX_ADU_LENGTH // 发送缓冲大小
static uint8_t rx_buff[UART_REC_MAX_SIZE];             // 接收缓冲区
static uint32_t rx_size;                               // 接收数据长度
static uint8_t tx_buff[UART_SEND_MAX_SIZE];            // 发送缓冲区

static uint16_t hold_reg[10];               // 数据寄存器
static uint8_t coil_reg[10];                // 位寄存器
static agile_modbus_rtu_t ctx_rtu;          // rtu结构体
static agile_modbus_t *ctx = &ctx_rtu._ctx; // modbus 结构体

static rt_sem_t usart_rec_sem = RT_NULL; // 接收信号量

static int modbus_usart_read(rt_int32_t time);                                // 数据发送
static void modbus_usart_send(uint8_t *buff, uint32_t size, rt_int32_t time); // 数据接收

static rt_thread_t modbus_thread = RT_NULL;       // 线程句柄
static void modbus_thread_entry(void *parameter); // 线程入口

/* modbus 初始化*/
int modbus_poll_init(void)
{
    usart_rec_sem = rt_sem_create("usart_sem",
                                  0,
                                  RT_IPC_FLAG_FIFO);              // 创建接收信号量
    __HAL_UART_CLEAR_IDLEFLAG(&UART_PORT);                        // 清除接收空闲中断标志
    __HAL_UART_ENABLE_IT(&UART_PORT, UART_IT_IDLE);               // 使能接收空闲中断
    HAL_UART_Receive_DMA(&UART_PORT, rx_buff, UART_REC_MAX_SIZE); // 开启DMA接收

    // agile_modbus init
    modbus_thread = rt_thread_create("modbus_thread",
                                     modbus_thread_entry,
                                     RT_NULL,
                                     1024,
                                     4,
                                     20); // 创建任务线程
    if (modbus_thread != RT_NULL)
        rt_thread_startup(modbus_thread); // 启动线程
    else
        return -1;

    return 0;
}

/* 任务线程入口函数*/
static void modbus_thread_entry(void *parameter)
{
    agile_modbus_rtu_init(&ctx_rtu, tx_buff, sizeof(tx_buff), rx_buff, sizeof(rx_buff)); // rtu初始化
    agile_modbus_set_slave(ctx, 1);                                                      // 设置地址
    while (1)
    {
        rt_thread_mdelay(3000); // 每次主机读取间隔

        /*hold reg 数据寄存器读取*/
        int send_len = agile_modbus_serialize_read_registers(ctx, 0, 10); // 格式化读取数据的发送内容
        modbus_usart_send(ctx->send_buf, send_len, 100);                  // 发送读取数据
        int read_len = modbus_usart_read(1000);                           // 等待slave返回数据
        if (read_len == 0)                                                // 读取超时
        {
            rt_kprintf("read hold reg timout\n");
            continue; // 继续下次循环
        }

        int rc = agile_modbus_deserialize_read_registers(ctx, read_len, hold_reg); // 将收到的salve数据格式化进数据缓冲
        if (rc < 0)                                                                // 格式化失败
        {
            rt_kprintf("read hold reg failed\n");
            if (rc != -1)
                rt_kprintf("error code:%d", -128 - rc);
            continue; // 继续下次循环
        }

        rt_kprintf("hold reg:\n"); // 打印收到的数据
        for (int i = 0; i < 10; i++)
        {
            rt_kprintf("hold_reg[%d]:0x%04x\n", i, hold_reg[i]);
        }

        /* 写入寄存器数据*/
        for (int i = 0; i < 10; i++)
        {
            hold_reg[i]++;
        }
        send_len = agile_modbus_serialize_write_registers(ctx, 0, 10, hold_reg); // 格式化写入数据的发送内容
        modbus_usart_send(ctx->send_buf, send_len, 100);                         // 串口发送
        read_len = modbus_usart_read(1000);                                      // 等待从机返回数据
        if (read_len == 0)                                                       // 读取超时
        {
            rt_kprintf("write hold reg timout\n");
            continue;
        }

        rc = agile_modbus_deserialize_write_registers(ctx, 10); // 检查从机应答数据
        if (rc < 0)
        {
            rt_kprintf("write hold reg failed\n");
            if (rc != -1)
                rt_kprintf("error code:%d", -128 - rc);
            continue; // 继续下次循环
        }
        rt_kprintf("write hold reg success\n");
        rt_kprintf("\r\n\r\n\r\n");

        /*coil reg 位读取*/
        send_len = agile_modbus_serialize_read_bits(ctx, 0, 10);
        modbus_usart_send(ctx->send_buf, send_len, 100);
        read_len = modbus_usart_read(1000);
        if (read_len == 0)
        {
            rt_kprintf("read coil reg timout\n");
            continue;
        }

        rc = agile_modbus_deserialize_read_bits(ctx, read_len, coil_reg);
        if (rc < 0)
        {
            rt_kprintf("read coil reg failed\n");
            if (rc != -1)
                rt_kprintf("error code:%d", -128 - rc);
            continue;
        }

        rt_kprintf("coil reg:\n");
        for (int i = 0; i < 10; i++)
        {
            rt_kprintf("coil_reg[%d]:%d\n", i, coil_reg[i]);
        }

        /* 写入位数据*/
        for (int i = 0; i < 10; i++)
        {
            coil_reg[i] ^= 1;
        }
        send_len = agile_modbus_serialize_write_bits(ctx, 0, 10, coil_reg); // 格式化写入数据的发送内容
        modbus_usart_send(ctx->send_buf, send_len, 100);                    // 串口发送
        read_len = modbus_usart_read(1000);                                 // 等待从机返回数据
        if (read_len == 0)                                                  // 读取超时
        {
            rt_kprintf("write coil reg timout\n");
            continue;
        }

        rc = agile_modbus_deserialize_write_bits(ctx, 10); // 检查从机应答数据
        if (rc < 0)
        {
            rt_kprintf("write coil reg failed\n");
            if (rc != -1)
                rt_kprintf("error code:%d", -128 - rc);
            continue; // 继续下次循环
        }
        rt_kprintf("write coil reg success\n");
        rt_kprintf("\r\n\r\n\r\n");
    }
}

/* 串口读取*/
/* int: 数据帧长度 */
/* time: 等待数据时间*/
static int modbus_usart_read(rt_int32_t time)
{
    rt_err_t uwRet = RT_EOK;
    uwRet = rt_sem_take(usart_rec_sem, time); // 获取接收空闲中断信号量
    if (uwRet == RT_EOK)                      // 收到数据帧，返回数据帧长度，数据在rx_buff内
    {
        return rx_size;
    }

    return 0;
}

/* 串口发送*/
/* *buff:待发送数据缓冲指针*/
/* size：待发送数据长度*/
/* time: 发送超时时间*/
static void modbus_usart_send(uint8_t *buff, uint32_t size, rt_int32_t time)
{
    if ((buff == NULL) || (size == 0U))
    {
        return;
    }
    HAL_UART_Transmit(&UART_PORT, buff, size, time);
}

/* 串口中断函数*/
void UART4_IRQHandler(void)
{
    uint32_t tmp;

    if (__HAL_UART_GET_FLAG(&UART_PORT, UART_FLAG_IDLE) != RESET) // 检测接收空闲中断是否挂起
    {
        __HAL_UART_CLEAR_IDLEFLAG(&UART_PORT); // 清除空闲中断标志
        tmp = UART_PORT.Instance->ISR;         // 根据手册清除空闲中断标志操作
        tmp = UART_PORT.Instance->RDR;
        tmp++;
        HAL_UART_DMAStop(&UART_PORT);                                          // 停止DMA接收
        rx_size = UART_REC_MAX_SIZE - __HAL_DMA_GET_COUNTER(UART_PORT.hdmarx); // 计算接收到的数据长度
        rt_sem_release(usart_rec_sem);                                         // 释放接收信号量
        HAL_UART_Receive_DMA(&UART_PORT, rx_buff, UART_REC_MAX_SIZE);          // 重新开启DMA接收
    }
}

5.1 modbus初始化函数

1.创建DMA接收用信号量 usart_sem

2.使能接收空闲中断 UART_IT_IDLE

3.开启DMA接收

4.创建modbus_poll线程

5.启动modbus_poll线程

/* modbus 初始化*/
int modbus_poll_init(void)
{
    usart_rec_sem = rt_sem_create("usart_sem",
                                  0,
                                  RT_IPC_FLAG_FIFO);              // 创建接收信号量
    __HAL_UART_CLEAR_IDLEFLAG(&UART_PORT);                        // 清除接收空闲中断标志
    __HAL_UART_ENABLE_IT(&UART_PORT, UART_IT_IDLE);               // 使能接收空闲中断
    HAL_UART_Receive_DMA(&UART_PORT, rx_buff, UART_REC_MAX_SIZE); // 开启DMA接收

    // agile_modbus init
    modbus_thread = rt_thread_create("modbus_thread",
                                     modbus_thread_entry,
                                     RT_NULL,
                                     1024,
                                     4,
                                     20); // 创建任务线程
    if (modbus_thread != RT_NULL)
        rt_thread_startup(modbus_thread); // 启动线程
    else
        return -1;

    return 0;
}

5.2 串口接收中断处理

1.串口进入空闲中断，说明数据桢接收完毕。

2.清除空闲中断。

3.停止串口DMA，停止接收新数据。

4.计算接收到的数据帧长度，写入rx_size。

5.释放信号量uart_rec_sem。

6.重新启动DMA接收。

/* 串口中断函数*/
void UART4_IRQHandler(void)
{
    uint32_t tmp;

    if (__HAL_UART_GET_FLAG(&UART_PORT, UART_FLAG_IDLE) != RESET) // 检测接收空闲中断是否挂起
    {
        __HAL_UART_CLEAR_IDLEFLAG(&UART_PORT); // 清除空闲中断标志
        tmp = UART_PORT.Instance->ISR;         // 根据手册清除空闲中断标志操作
        tmp = UART_PORT.Instance->RDR;
        tmp++;
        HAL_UART_DMAStop(&UART_PORT);                                          // 停止DMA接收
        rx_size = UART_REC_MAX_SIZE - __HAL_DMA_GET_COUNTER(UART_PORT.hdmarx); // 计算接收到的数据长度
        rt_sem_release(usart_rec_sem);                                         // 释放接收信号量
        HAL_UART_Receive_DMA(&UART_PORT, rx_buff, UART_REC_MAX_SIZE);          // 重新开启DMA接收
    }
}

5.3 串口数据读取

1.获取接收信号量usart_rec_sem。（数据帧接收完毕，在中断中释放）。

2.成功获取，返回接收数据帧长度。（数据在缓冲rx_buff中）。

/* 串口读取*/
/* int: 数据帧长度 */
/* time: 等待数据时间*/
static int modbus_usart_read(rt_int32_t time)
{
    rt_err_t uwRet = RT_EOK;
    uwRet = rt_sem_take(usart_rec_sem, time); // 获取接收空闲中断信号量
    if (uwRet == RT_EOK)                      // 收到数据帧，返回数据帧长度，数据在rx_buff内
    {
        return rx_size;
    }

    return 0;
}

5.4 串口数据发送

用HAL库发送数据。

/* 串口发送*/
/* *buff:待发送数据缓冲指针*/
/* size：待发送数据长度*/
/* time: 发送超时时间*/
static void modbus_usart_send(uint8_t *buff, uint32_t size, rt_int32_t time)
{
    if ((buff == NULL) || (size == 0U))
    {
        return;
    }
    HAL_UART_Transmit(&UART_PORT, buff, size, time);
}

5.4 modbus线程处理 

1.agile_modbus RTU模式初始化，配置接收和发送缓冲。

2.设置modbus地址为1。

    agile_modbus_rtu_init(&ctx_rtu, tx_buff, sizeof(tx_buff), rx_buff, sizeof(rx_buff)); // rtu初始化
    agile_modbus_set_slave(ctx, 1);                                                      // 设置地址

 1.格式化读取从机寄存器需要发送的数据帧格式。

2.发送读取从机寄存器的数据帧。

3.等待从机答复。

        /*hold reg 数据寄存器读取*/
        int send_len = agile_modbus_serialize_read_registers(ctx, 0, 10); // 格式化读取数据的发送内容
        modbus_usart_send(ctx->send_buf, send_len, 100);                  // 发送读取数据
        int read_len = modbus_usart_read(1000);                           // 等待slave返回数据
        if (read_len == 0)                                                // 读取超时
        {
            rt_kprintf("read hold reg timout\n");
            continue; // 继续下次循环
        }

1.将收到从机的答复数据帧，反格式化写入到保存数据中。

2.打印收到的数据。

        int rc = agile_modbus_deserialize_read_registers(ctx, read_len, hold_reg); // 将收到的salve数据格式化进数据缓冲
        if (rc < 0)                                                                // 格式化失败
        {
            rt_kprintf("read hold reg failed\n");
            if (rc != -1)
                rt_kprintf("error code:%d", -128 - rc);
            continue; // 继续下次循环
        }

        rt_kprintf("hold reg:\n"); // 打印收到的数据
        for (int i = 0; i < 10; i++)
        {
            rt_kprintf("hold_reg[%d]:0x%04x\n", i, hold_reg[i]);
        }

 1.将收到的从机寄存器数据+1。

2.格式化写入从机寄存器数据帧格式。

3.发送写入从机寄存器数据帧。

4.等待从机应答。

5.检查从机应答。

6.写入从机寄存器成功，打印写入寄存器成功信息。

        /* 写入寄存器数据*/
        for (int i = 0; i < 10; i++)
        {
            hold_reg[i]++;
        }
        send_len = agile_modbus_serialize_write_registers(ctx, 0, 10, hold_reg); // 格式化写入数据的发送内容
        modbus_usart_send(ctx->send_buf, send_len, 100);                         // 串口发送
        read_len = modbus_usart_read(1000);                                      // 等待从机返回数据
        if (read_len == 0)                                                       // 读取超时
        {
            rt_kprintf("write hold reg timout\n");
            continue;
        }

        rc = agile_modbus_deserialize_write_registers(ctx, 10); // 检查从机应答数据
        if (rc < 0)
        {
            rt_kprintf("write hold reg failed\n");
            if (rc != -1)
                rt_kprintf("error code:%d", -128 - rc);
            continue; // 继续下次循环
        }
        rt_kprintf("write hold reg success\n");
        rt_kprintf("\r\n\r\n\r\n");

 位数据的读取和写入，同寄存器操作。

附上完整线程代码：

/* 任务线程入口函数*/
static void modbus_thread_entry(void *parameter)
{
    agile_modbus_rtu_init(&ctx_rtu, tx_buff, sizeof(tx_buff), rx_buff, sizeof(rx_buff)); // rtu初始化
    agile_modbus_set_slave(ctx, 1);                                                      // 设置地址
    while (1)
    {
        rt_thread_mdelay(3000); // 每次主机读取间隔

        /*hold reg 数据寄存器读取*/
        int send_len = agile_modbus_serialize_read_registers(ctx, 0, 10); // 格式化读取数据的发送内容
        modbus_usart_send(ctx->send_buf, send_len, 100);                  // 发送读取数据
        int read_len = modbus_usart_read(1000);                           // 等待slave返回数据
        if (read_len == 0)                                                // 读取超时
        {
            rt_kprintf("read hold reg timout\n");
            continue; // 继续下次循环
        }

        int rc = agile_modbus_deserialize_read_registers(ctx, read_len, hold_reg); // 将收到的salve数据格式化进数据缓冲
        if (rc < 0)                                                                // 格式化失败
        {
            rt_kprintf("read hold reg failed\n");
            if (rc != -1)
                rt_kprintf("error code:%d", -128 - rc);
            continue; // 继续下次循环
        }

        rt_kprintf("hold reg:\n"); // 打印收到的数据
        for (int i = 0; i < 10; i++)
        {
            rt_kprintf("hold_reg[%d]:0x%04x\n", i, hold_reg[i]);
        }

        /* 写入寄存器数据*/
        for (int i = 0; i < 10; i++)
        {
            hold_reg[i]++;
        }
        send_len = agile_modbus_serialize_write_registers(ctx, 0, 10, hold_reg); // 格式化写入数据的发送内容
        modbus_usart_send(ctx->send_buf, send_len, 100);                         // 串口发送
        read_len = modbus_usart_read(1000);                                      // 等待从机返回数据
        if (read_len == 0)                                                       // 读取超时
        {
            rt_kprintf("write hold reg timout\n");
            continue;
        }

        rc = agile_modbus_deserialize_write_registers(ctx, 10); // 检查从机应答数据
        if (rc < 0)
        {
            rt_kprintf("write hold reg failed\n");
            if (rc != -1)
                rt_kprintf("error code:%d", -128 - rc);
            continue; // 继续下次循环
        }
        rt_kprintf("write hold reg success\n");
        rt_kprintf("\r\n\r\n\r\n");

        /*coil reg 位读取*/
        send_len = agile_modbus_serialize_read_bits(ctx, 0, 10);
        modbus_usart_send(ctx->send_buf, send_len, 100);
        read_len = modbus_usart_read(1000);
        if (read_len == 0)
        {
            rt_kprintf("read coil reg timout\n");
            continue;
        }

        rc = agile_modbus_deserialize_read_bits(ctx, read_len, coil_reg);
        if (rc < 0)
        {
            rt_kprintf("read coil reg failed\n");
            if (rc != -1)
                rt_kprintf("error code:%d", -128 - rc);
            continue;
        }

        rt_kprintf("coil reg:\n");
        for (int i = 0; i < 10; i++)
        {
            rt_kprintf("coil_reg[%d]:%d\n", i, coil_reg[i]);
        }

        /* 写入位数据*/
        for (int i = 0; i < 10; i++)
        {
            coil_reg[i] ^= 1;
        }
        send_len = agile_modbus_serialize_write_bits(ctx, 0, 10, coil_reg); // 格式化写入数据的发送内容
        modbus_usart_send(ctx->send_buf, send_len, 100);                    // 串口发送
        read_len = modbus_usart_read(1000);                                 // 等待从机返回数据
        if (read_len == 0)                                                  // 读取超时
        {
            rt_kprintf("write coil reg timout\n");
            continue;
        }

        rc = agile_modbus_deserialize_write_bits(ctx, 10); // 检查从机应答数据
        if (rc < 0)
        {
            rt_kprintf("write coil reg failed\n");
            if (rc != -1)
                rt_kprintf("error code:%d", -128 - rc);
            continue; // 继续下次循环
        }
        rt_kprintf("write coil reg success\n");
        rt_kprintf("\r\n\r\n\r\n");
    }
}

6.演示

此山无老虎
关注
  • 19
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
RT-Thread GD32F4xx 软件包agile_modbus
madao1234的博客
01-19 252
GD32F4xx MCU的RT-Thread标准版工程，使用agile_modbus软件包实现Modbus RTU Master 、Slave。
MODBUS学习篇四------freemodbus的移植（rt-thread系统）
weixin_42682108的博客
01-22 2381
一.FreeModbus简介 FreeMODBUS一个奥地利人写的Modbus协议。它是一个针对嵌入式应用的一个免费（自由）的通用MODBUS协议的移植。Modbus是一个工业制造环境中应用的一个通用协议。Modbus通信协议栈包括两层：Modbus应用层协议，该层定义了数据模式和功能；另外一层是网络层。 FreeMODBUS 提供了RTU/ASCII 传输模式及TCP协议支持。FreeModbus遵循BSD许可证，这意味着用户可以将FreeModbus应用于商业环境中。目前版本FreeModb...
Modbus 485学习笔记
最新发布
嵌入式C
04-06 282
比如从设备地址为0x11 功能码01 起始地址0x14 读多少个从设备 0x19(25个) CRC。地址一个字节 功能码一个字节 数据2个字节 寄存器数量2个字节 CRC2个字节。从机回复：地址 功能码 读多少个从设备占的字节数 相应字节位数据 CRC。地址0x22 功能码 0x05 起始地址：0x1D 数量 0xff crc。以功能码05写举例：向从设备所有继电器写，打开/关闭所有继电器（取反一样）以功能码01举例：实现主设备读25个继电器的状态是开还是关。
RT-Thread中Agile Modbus软件包的使用
weixin_46158019的博客
02-07 2854
开发环境：野火的stm32f407，rt-thread studio版本是版本: 2.2.6，stm32f4的资源包为0.2.2，Agile Modbus软件包版本为v1.1.2。工程使用上一篇 RT-Thread中RS485驱动包的使用 工程为基础。单片机作为主站Master，从站使用软件Modbus Slave模拟。打开工程，添加软件包Agile Modbus，添加成功，先进行编译，查看是否有...
Agile Modbus 轻量型协议栈 移植笔记
Cc_maoshu的博客
12-08 2190
函数可以发现都是函数指针，使用什么方式绑定对应的指针函数就可以，但是不用我们自己绑定，有写好的代码，了解一下就可以，他的结构体也是一个封装原理。这里没什么讲的，就是把数据发送出去，这里要注意的就是第一个形参必须要是地址类型，因为发送长度不是固定的。，他就存到初始化时指向的数组里了，然后会返回一个长度，就可以通过串口发送了，发送完了要立刻接收，，这个是自己实现的接收我通过指针把他指向的地址的值修改了，然后返回修改了的长度。他三个形参就是解析地址，解析长度，解析完了寸哪的地址。进行解析了，实际上就是解析它。
轻量级modbus协议库
qq_35591467的博客
02-07 2081
agile_modbus 即：轻量型 modbus 协议栈，是我在使用其他第三方库过程中进行归纳而形成的一个库。 仓库地址：https://github.com/loogg/agile_modbus
开放原子训练营（第四季）TobudOS- 添加agile_modbus功能包并演示modbus rtu主机模式
qq_29356039的博客
01-06 1101
开放原子训练营（第四季）TobudOS- 添加agile_modbus功能包并演示modbus rtu主机模式
STM32+RTThread+lwip实现Modbus-TCP工程源码
04-07
基于STM32F107开发板，搭载RT-Thread操作系统，通过lwip协议栈实现Modbus-TCP协议控制开发板上的LED；通过I2C利用开发板自带的EEPROM存储IP配置信息，使用者可通过操作系统的shell组件finsh修改并保存IP配置。 工程...
RT-Thread 串口IAP升级
07-26
RT-Thread串口IAP升级是一种在嵌入式系统中实现固件在线更新的方法，它利用内部编程（In-Application Programming, IAP）技术，通过串口与上位机进行通信，实现对设备固件的远程升级。这种方法适用于基于RT-Thread...
[Martin] - Agile Software Development_agile_
10-01
敏捷软件开发（Agile Software Development）是一种以人为核心、迭代、逐步交付的软件开发方法论。这种方法强调灵活性、快速响应变化以及高效的团队协作，旨在在不断变化的需求环境中提供高质量的软件产品。 标题中...
rt-thread物联网操作系统-其他
06-12
RT-Thread有完整版和Nano版，对于资源受限的微控制器（MCU）系统，可通过简单易用的工具，裁剪出仅需要 3KB Flash、1.2KB RAM 内存资源的 NANO 内核版本；而相对资源丰富的物联网设备，可使用RT-Thread完整版，通过...
Modbus通讯库，希望对大家有用
03-07
Modbus通讯库，包含读取寄存器数据，写入寄存寄存器，批量读写等常用功能。
modbus-主机-stm32移植源码与调试工具
07-27
modbus-主机-stm32移植源码与调试工具.............................................
stm8ef-modbus:STM8 eForth中的（非常）轻量级的MODBUS实现
05-24
stm8ef-modbus 该存储库为“有线”控制节点（例如家庭自动化）提供了带有的轻量级MODBUS RTU实现。 主要目标是低成本STM8S 8位µC，例如具有8K闪存和1K RAM的STM8S003F3P6。 将STM8 Forth用于MODBUS具有一些优点：实现非常紧凑，它使应用程序可以访问许多高级架构功能，例如“后台I / O位置执行”或CLI（命令行界面）。 Forth编译器/解释器是二进制文件的一部分，您可以在开发板与MODBUS主机通信时直接更改代码！ MODBUS RTU实现涵盖了基本的FC：它是简单I / O节点中常见的的子集。 为其他FC编写代码很容易。 用类似独立于百叶窗的控制器的方式打开电路板也很简单：MODBUS主机仅命令“打开”或“关闭”，而不是“向上”和“向下”命令。 本地控制代码可以帮助使家庭自动化更加强大和React灵敏。 支持的板 C0135
rtthread 调通freemodbus 从机和主机STM32F103VCT6
07-07
rtthread 调通freemodbus 从机和主机STM32F103VCT6
rt-thread-modbus-App01-03.rar
01-22
在STM32上移植了Rt-thread操作系统后，继续移植了freemodbus,实现多线程操作
rt-thread学习（一） 创建led闪烁 加入串口设备 pwm配置 modbus主/从测试代码
dawm的博客
10-02 2243
rt-thread学习（一） 创建led闪烁 加入串口设备 pwm配置 modbus主/从测试代码led灯闪烁加入串口设备使用cubemx 配置hse配置pwmfreemodbus 测试代码freemodbus 从机测试代码 led灯闪烁 #include <rtthread.h> #include <rtdevice.h> #define DBG_TAG "main" #define DBG_LVL DBG_LOG #include <rtdbg.h> #inclu
手把手教-基于单片机的Modbus TCP Slave例程
weixin_46158019的博客
07-31 621
单片机最终运行效果，软件获取到数据，如下：一、开发环境硬件：gd32f450开发板操作系统：rt-thread 5.0.0软件包：Agile Modbus软件包电脑测试软件：Modbus Poll二、开发步骤开发步骤如下：①使用env工具，添加Agile Modbus软件包；②下载软件包，重新生成工程；③打开工程，软件包已添加到工程，编译看下是否报错，编译正常；...
MODBUS主机协议移植
热门推荐
JT同学的博客
07-27 1万+
最近由于项目需求需要移植的modbus主机协议，由于MODBUS主机的源码不开源，网上的例程也不多，在百度苦苦找寻一番没有什么结果。最后参考了安富莱的例程，将其修改并移植到自己的工程中。我通过USB转串口连接到电脑，用虚拟设备测试，读写正常。 以下是我的移植过程，最下面有STM32F1和MSP430F5的源码与MODBUS虚拟设备 下面使用的芯片是stm32f103zet6，IDE...
agile_modbus
07-17
### 回答1： Agile Modbus是一种现代的通信协议，用于实现工业自动化和数据采集系统中设备之间的通信。 Modbus是一种常见的开放式通信协议，用于连接不同设备和控制系统，尤其是在工业环境中。Agile Modbus是在传统Modbus基础上进行了改进和优化，以提高通信性能和灵活性。 Agile Modbus具有以下特点： 1. 高性能：Agile Modbus通过减少通信延迟和提高数据传输速度，提供更高的通信性能。这使得设备能够实时地发送和接收大量的数据，提高了系统的响应速度和效率。 2. 灵活性：Agile Modbus支持多种通信方式，包括串口、以太网和无线通信。这使得设备能够灵活地选择最适合自己的通信方式，以适应不同的工业环境和应用需求。 3. 安全性：Agile Modbus提供了强大的安全机制，包括数据加密和身份验证。这确保了通信过程中的数据安全性，并防止未经授权的访问和攻击。 4. 易于集成：Agile Modbus采用了标准的通信协议和接口，使得设备能够很容易地与其他Modbus兼容的设备和控制系统进行集成。这降低了系统集成的复杂性和成本。 总而言之，Agile Modbus是一种高性能、灵活和安全的通信协议，适用于工业自动化和数据采集系统。它能够提高设备之间的通信效率，实现实时数据传输和远程控制，为工业生产提供更好的支持和保障。 ### 回答2： agile_modbus，简称AM，是一种基于Modbus协议的敏捷开发方法论。敏捷开发是一种迭代、增量的软件开发方式，旨在提高项目的灵活性和反应速度。而Modbus是一种常用的工业通讯协议，用于实现设备之间的数据交换。 agile_modbus结合了敏捷开发和Modbus协议，旨在为工控系统的开发提供更高效、更灵活的解决方案。在传统的工控系统开发中，开发周期长、需求变更困难，无法满足快速迭代的需求。而采用agile_modbus方法论，开发团队可以将项目拆分成多个小而可实现的任务，每个任务即为一个迭代周期。这种方式可以提高反馈速度，及时响应需求变更。 在实践中，agile_modbus通常采用用户故事的方式来描述需求。用户故事是简洁的描述，从用户的角度说明需求，包括角色、功能和期望结果。开发团队将用户故事转化为任务，并为每个任务设置优先级。团队成员在每个迭代周期内，根据优先级选择任务并实现，每个迭代周期结束后进行验收和反馈。通过不断迭代，agile_modbus可以实现快速交付，并适应需求变化。 总结来说，agile_modbus是一种基于Modbus协议的敏捷开发方法论，可以提高工控系统的开发效率和灵活性。通过将项目拆分为多个小任务，结合用户故事和优先级，实现迭代开发和快速交付。这种方法能够有效应对需求变更，提高反应速度，使开发团队更加高效地完成工控系统的开发任务。 ### 回答3： Agile_Modbus是一种基于敏捷开发方法的Modbus通信协议。Modbus是一种在工业领域广泛应用的通信协议，用于连接不同设备之间进行数据交换。Agile_Modbus通过引入敏捷开发方法，提供了更灵活和高效的Modbus通信解决方案。 敏捷开发是一种迭代、增量的开发方法，强调团队合作和快速响应需求变化。它的核心原则是通过不断的迭代开发和持续集成，将产品交付给客户，并根据客户反馈不断改进和优化。Agile_Modbus在Modbus通信协议上采用类似的方法，使得开发人员能够更加灵活地应对客户需求和不断变化的环境。 Agile_Modbus的主要特点包括以下几点。首先，它采用迭代开发方式，每个迭代都会交付一个可用的部分产品，而不是等待整个产品开发完毕。这样可以更早地验证产品功能和性能，及时修正和调整。其次，Agile_Modbus注重团队合作和交流，通过持续集成和快速反馈机制，使得开发人员和用户能够更好地沟通和理解彼此需求。第三，Agile_Modbus强调用户参与和反馈。用户可以在迭代过程中不断验证产品，并及时提出改进意见和需求变更。最后，Agile_Modbus鼓励自组织和自管理的团队，提倡灵活性和适应性，使得开发过程更加高效和可靠。 总的来说，Agile_Modbus通过引入敏捷开发方法，为Modbus通信协议带来了更高的灵活性和效率。它适用于不断变化的工业环境，能够快速响应和适应不同的客户需求。通过提供持续集成和快速反馈机制，Agile_Modbus能够在开发过程中及时修正和优化产品，提高软件质量和用户满意度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值