【RTT-Studio】详细使用教程二：RS485通信

已于 2024-07-22 17:52:05 修改
阅读量1.1k 收藏 12
点赞数 22
分类专栏： RTT-Studio 文章标签： stm32 嵌入式硬件
于 2024-07-10 10:30:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hei_se_meng_yan/article/details/140294612
版权

文章目录

一、RTT基础配置

1.新建工程： 选择合适的芯片进行工程创建，并编译工程确保工程文件可以正常运行。
在这里插入图片描述

2.添加引脚： 在board.h中添加串口所需要的引脚，以及RS485通信时的控制引脚。本次使用的是UART3，控制引脚是PB14和PB15。

#define BSP_USING_UART3
#define BSP_UART3_TX_PIN       "PD8"
#define BSP_UART3_RX_PIN       "PD9"
#define BSP_UART3_RE           "PB15"
#define BSP_UART3_DE           "PB14"

3.添加变量： 在drv_uasrt.h -> struct stm32_uart_config结构体中添加和RS485相关的变量，主要包含RD、DE名称、端口号、引脚，以及串口名称。

/* stm32 config class */
struct stm32_uart_config
{
    const char *name;
    USART_TypeDef *Instance;
    IRQn_Type irq_type;
    struct dma_config *dma_rx;
    struct dma_config *dma_tx;
    const char *tx_pin_name;
    const char *rx_pin_name;

	/* 新增变量 */
    const char *re_pin_name;    // RS485的RE名称
    const char *de_pin_name;    // RS485的DE名称
    GPIO_TypeDef *re_port;      // RE端口号
    GPIO_TypeDef *de_port;      // DE端口号
    uint16_t re_pin;            // RE引脚
    uint16_t de_pin;            // DE引脚
    char is485;                 // RS485
};

4.添加初始值： 在uart_config.h -> #define UART3_CONFIG宏定义中添加初始值。

#if defined(BSP_USING_UART3)
#ifndef UART3_CONFIG
#define UART3_CONFIG                                                \
    {                                                               \
        .name = "uart3",                                            \
        .Instance = USART3,                                         \
        .irq_type = USART3_IRQn,                                    \
        .tx_pin_name = BSP_UART3_TX_PIN,                            \
        .rx_pin_name = BSP_UART3_RX_PIN,                            \

		/* 新增初始值 */
        .is485 = 1,                                                 \
        .re_pin_name = BSP_UART3_RE,                                \
        .de_pin_name = BSP_UART3_DE,                                \
    }
#endif /* UART3_CONFIG */

5.添加初始化： 在drv_usart.c -> stm32_gpio_configure函数中增加GPIO引脚的初始化代码，主要是RS485控制线初始化，并且设置为默认接收模式。

// 串口GPIO引脚初始化
static rt_err_t stm32_gpio_configure(struct stm32_uart_config *config)
{
    int uart_num = 0;
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_TypeDef *tx_port;
    GPIO_TypeDef *rx_port;
    uint16_t tx_pin;
    uint16_t rx_pin;

    // 获取串口编号
    uart_num = config->name[4] - '0';

    // 解析GPIO 端口和引脚编号
    get_pin_by_name(config->rx_pin_name, &rx_port, &rx_pin);
    get_pin_by_name(config->tx_pin_name, &tx_port, &tx_pin);

    /* gpio ports clock enable */
    stm32_gpio_clk_enable(tx_port);
    if (tx_port != rx_port)
    {
        stm32_gpio_clk_enable(rx_port);
    }
    
    /* rx pin initialize */
    GPIO_InitStruct.Pin = tx_pin;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_PULLUP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;

    // 指定复用设备
#if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || \
    defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32G4) || \
    defined(SOC_SERIES_STM32L1) || defined(SOC_SERIES_STM32L4)
#define GPIO_AF7   ((uint8_t)0x07)
#define GPIO_AF8   ((uint8_t)0x08)
    /* uart1-3 -> AF7, uart4-8 -> AF8 */
    if (uart_num <= 3)
    {
        GPIO_InitStruct.Alternate = GPIO_AF7;
    }
    else
    {
        GPIO_InitStruct.Alternate = GPIO_AF8;
    }
#endif
    HAL_GPIO_Init(tx_port, &GPIO_InitStruct);

    /* rx pin initialize */
    GPIO_InitStruct.Pin = rx_pin;
    HAL_GPIO_Init(rx_port, &GPIO_InitStruct);

    // RS485控制线初始化
    if (config->is485)
    {
        // 解析GPIO 端口和引脚编号
        get_pin_by_name(config->de_pin_name, &(config->de_port), &(config->de_pin));
        get_pin_by_name(config->re_pin_name, &(config->re_port), &(config->re_pin));

        // 使能控制线时钟
        if (config->de_port != rx_port || config->re_port != rx_port)
        {
            stm32_gpio_clk_enable(config->de_port);
            stm32_gpio_clk_enable(config->re_port);
        }

        // 控制线初始化
        GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
        GPIO_InitStruct.Pin = config->de_pin;
        HAL_GPIO_Init(config->de_port, &GPIO_InitStruct);

        GPIO_InitStruct.Pin = config->re_pin;
        HAL_GPIO_Init(config->re_port, &GPIO_InitStruct);

        // 设置控制线默认电平为低电平，接收模式
        HAL_GPIO_WritePin(config->de_port, config->de_pin, GPIO_PIN_RESET);
        HAL_GPIO_WritePin(config->re_port, config->re_pin, GPIO_PIN_RESET);
    }

    return RT_EOK;
}

6.发送进行模式切换 在drv_usart.c -> stm32_putc函数中增加接收和发送模式的切换代码，在发送时设置成发送模式，等待发送完成，之后再设置成接收模式。

static int stm32_putc(struct rt_serial_device *serial, char c)
{
    struct stm32_uart *uart;
    RT_ASSERT(serial != RT_NULL);

    uart = rt_container_of(serial, struct stm32_uart, serial);
    UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_TC);
#if defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32WL) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32F0) \
    || defined(SOC_SERIES_STM32L0) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32L5) \
    || defined(SOC_SERIES_STM32G4) || defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32WB) || defined(SOC_SERIES_STM32F3)  \
    || defined(SOC_SERIES_STM32U5)
    uart->handle.Instance->TDR = c;
#else
	// 发送数据时，设置成发送模式
    if(uart->config->is485)
    {
        HAL_GPIO_WritePin(uart->config->de_port,uart->config->de_pin, GPIO_PIN_RESET);
    }
    uart->handle.Instance->DR = c;
#endif

	// 等带发送完成
    while (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_TC) == RESET);

	// 发送完成后，设置成接收模式
    if(uart->config->is485)
    {
        HAL_GPIO_WritePin(uart->config->de_port,uart->config->de_pin, GPIO_PIN_SET);
    }
    return 1;
}

二、注册RS485设备

1.注册设备介绍
设备注册函数：以下结构体中的函数需要具体实现，用于设备在查找之后进行设备的操作

rt_err_t  (*init)   (rt_device_t dev); 														// 设备初始化函数
rt_err_t  (*open)   (rt_device_t dev, rt_uint16_t oflag); 									// 设备打开函数
rt_err_t  (*close)  (rt_device_t dev);														// 设备关闭函数
rt_size_t (*read)   (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size); 			// 设备读取函数
rt_size_t (*write)  (rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size); 	// 设备写入函数
rt_err_t  (*control)(rt_device_t dev, int cmd, void *args);									// 设备控制函数
void *user_data;		// 设备用户数据

（1）设备初始化函数

/**
 * @brief 设备初始化接口
 * @return
 */
rt_err_t rs485_usart_init(rt_device_t dev)
{
    g_rs485.queue = rt_malloc(QUEUE_SIZE);

    // 查找创建的设备
    g_rs485.dev = (rt_device_t) rt_device_find(RS485_DEV_NAME);
    RT_ASSERT(g_rs485.dev != RT_NULL);

    // 配置创建设备的参数
    rt_device_control(g_rs485.dev, RT_DEVICE_CTRL_CONFIG, (void *)&g_user_data);

    return RT_EOK;
}
INIT_ENV_EXPORT(rs485_usart_init);

（2）设备打开函数

/**
 * @brief 设备打开接口
 * @return
 */
rt_err_t rs485_usart_open(rt_device_t dev, rt_uint16_t oflag)
{
    rs485_user_t *user = (rs485_user_t *)g_rs485.dev->user_data;

    rt_device_open(user->dev, RT_DEVICE_FLAG_INT_RX);
    return RT_EOK;
}

（3）设备关闭函数

/**
 * @brief 设备关闭接口
 * @return
 */
rt_err_t rs485_usart_close(rt_device_t dev)
{
    return RT_EOK;
}

（4）设备读取函数

/**
 * @brief 设备读取接口
 * @return
 */
rt_size_t rs485_usart_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
{
    rs485_user_t *user = (rs485_user_t *)g_rs485.dev->user_data;

    size = rt_device_read(user->dev, 0, buffer, 1);

    return size;
}

（5）设备写入函数

/**
 * @brief 设备写入接口
 * @return
 */
rt_size_t rs485_usart_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
{
    if (g_user_data.name == RT_NULL)
        return 0;

    rs485_user_t *user = (rs485_user_t *)g_rs485.dev->user_data;

    user->dev->write(user->dev, pos, buffer, size);

    return 1;
}

（6）设备控制函数

/**
 * @brief 设备控制接口
 * @return
 */
rt_err_t rs485_usart_control(rt_device_t dev, int cmd, void *args)
{
    int ret = -RT_ERROR;
    struct sram_device *sdcard;
    RT_ASSERT(dev != 0);

    sdcard = (struct sram_device *)dev;

    switch (cmd)
    {
        // 设置互斥锁
        case RT_DEVICE_CTRL_LOCK:
            lock(sdcard);
            ret = RT_EOK;
            break;

        // 解除互斥锁
        case RT_DEVICE_CTRL_UNLOCK:
            unlock(sdcard);
            ret = RT_EOK;
            break;

        default:
            ret = -RT_ERROR;
            break;
    }

    return ret;
}

（7）RS485设备注册

/**
 * @brief RS485设备注册
 * @return 0:成功 -1：失败
 */
static int RS485_Device_Register(void)
{
    rt_err_t ret;

    // 开辟一个存储空间
    g_rs485.dev = rt_malloc(sizeof(struct rt_device));
    rt_memset(g_rs485.dev, 0, sizeof(struct rt_device));

    // 串口3参数初始化
    usart3_param_init();

    // 结构体初始化
    g_rs485.dev->type       = RT_Device_Class_Char;     // 设备类型
    g_rs485.dev->init       = rs485_usart_init;         // 设备初始化接口
    g_rs485.dev->open       = rs485_usart_open;         // 设备打开接口
    g_rs485.dev->close      = rs485_usart_close;        // 设备关闭接口
    g_rs485.dev->read       = rs485_usart_read;         // 设备读取接口
    g_rs485.dev->write      = rs485_usart_write;        // 设备写入接口
    g_rs485.dev->control    = rs485_usart_control;      // 设备控制接口
    g_rs485.dev->user_data  = &g_user_data;             // 设备数据

    // 设备注册
    ret = rt_device_register(g_rs485.dev, RS485_DEV_NAME, RT_DEVICE_FLAG_RDWR);

    return ret;
}
INIT_DEVICE_EXPORT(RS485_Device_Register);

2.设备使用
正常注册完设备之后，可以直接调用函数的接口来进行数据的收发，以及对设备进行控制。

/**
 * @brief RS485接收线程
 * @param param
 */
void rs485_rx_thread_entry(void *param)
{
    char ch;
    g_rs485.qpush_index = 0;
    rt_err_t result;
    rt_uint16_t CRC_Value = 0;

    while (1)
    {
        if (g_rs485.qpush_index >= QUEUE_SIZE)
            g_rs485.qpush_index = 0;

        // 信号量设置超时时间
        result = rt_sem_take(g_rs485.rx_sem, 1000);
        if (result == RT_EOK)
        {
            g_rs485.dev->read(g_user_data.dev, 0, &ch, 1);
            g_rs485.queue[g_rs485.qpush_index++] = ch;

            // 接收数据超过三个
            if (g_rs485.qpush_index > 3)
            {
                // CRC校验
                CRC_Value = CRC_Check(g_rs485.queue, (g_rs485.qpush_index - 2));

                // 校验合格才会处理数据
                if ((g_rs485.queue[g_rs485.qpush_index - 1] == ((char) CRC_Value))
                        && (g_rs485.queue[g_rs485.qpush_index - 2] == (char) (CRC_Value >> 8)))
                {
                    g_rs485.dev->write(RT_NULL, 0, g_rs485.queue, g_rs485.qpush_index);
                    g_rs485.qpush_index = 0;
                }
            }
        }
        else
        {
            g_rs485.qpush_index = 0;
        }
    }
}

3.设备访问
（1）查询函数：应用程序根据设备名称获取设备句柄，进而可以操作设备。

rt_device_t rt_device_find(const char* name);

参数描述
name设备名称
返回- -
设备句柄查找到对应设备将返回相应的设备句柄
RT_NULL没有找到相应的设备对象

（2）初始化设备：获得设备句柄后，应用程序可使用如下函数对设备进行初始化操作。当一个设备已经初始化成功后，调用这个接口将不再重复做初始化 0。

rt_err_t rt_device_init(rt_device_t dev);

参数描述
dev设备句柄
返回— —
RT_EOK设备初始化成功
错误码设备初始化失败

（3）打开设备：通过设备句柄，应用程序可以打开和关闭设备，打开设备时，会检测设备是否已经初始化，没有初始化则会默认调用初始化接口初始化设备。

rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflags);

参数描述
dev设备句柄
oflags设备打开模式标志
返回— —
RT_EOK设备打开成功
-RT_EBUSY如果设备注册时指定的参数中包括 RT_DEVICE_FLAG_STANDALONE 参数，此设备将不允许重复打开
其他错误码设备打开失败

oflags 支持以下的参数：

#define RT_DEVICE_OFLAG_CLOSE 0x000   /* 设备已经关闭（内部使用）*/
#define RT_DEVICE_OFLAG_RDONLY 0x001  /* 以只读方式打开设备 */
#define RT_DEVICE_OFLAG_WRONLY 0x002  /* 以只写方式打开设备 */
#define RT_DEVICE_OFLAG_RDWR 0x003    /* 以读写方式打开设备 */
#define RT_DEVICE_OFLAG_OPEN 0x008    /* 设备已经打开（内部使用）*/
#define RT_DEVICE_FLAG_STREAM 0x040   /* 设备以流模式打开 */
#define RT_DEVICE_FLAG_INT_RX 0x100   /* 设备以中断接收模式打开 */
#define RT_DEVICE_FLAG_DMA_RX 0x200   /* 设备以 DMA 接收模式打开 */
#define RT_DEVICE_FLAG_INT_TX 0x400   /* 设备以中断发送模式打开 */
#define RT_DEVICE_FLAG_DMA_TX 0x800   /* 设备以 DMA 发送模式打开 */

注：如果上层应用程序需要设置设备的接收回调函数，则必须以 RT_DEVICE_FLAG_INT_RX 或者 RT_DEVICE_FLAG_DMA_RX 的方式打开设备，否则不会回调函数。

（4）关闭设备：不需要再对设备进行操作则可以关闭设备。

rt_err_t rt_device_close(rt_device_t dev);

参数描述
dev设备句柄
返回— —
RT_EOK关闭设备成功
-RT_ERROR设备已经完全关闭，不能重复关闭设备
其他错误码关闭设备失败

注：关闭设备接口和打开设备接口需配对使用，打开一次设备对应要关闭一次设备，这样设备才会被完全关闭，否则设备仍处于未关闭状态。

（5）控制设备：通过命令控制字，应用程序也可以对设备进行控制

rt_err_t rt_device_control(rt_device_t dev, rt_uint8_t cmd, void* arg);

参数描述
dev设备句柄
cmd命令控制字，这个参数通常与设备驱动程序相关
arg控制的参数
返回— —
RT_EOK函数执行成功
-RT_ENOSYS执行失败，dev 为空
其他错误码执行失败

参数 cmd 的通用设备命令可取如下宏定义：

#define RT_DEVICE_CTRL_RESUME           0x01   /* 恢复设备 */
#define RT_DEVICE_CTRL_SUSPEND          0x02   /* 挂起设备 */
#define RT_DEVICE_CTRL_CONFIG           0x03   /* 配置设备 */
#define RT_DEVICE_CTRL_SET_INT          0x10   /* 设置中断 */
#define RT_DEVICE_CTRL_CLR_INT          0x11   /* 清中断 */
#define RT_DEVICE_CTRL_GET_INT          0x12   /* 获取中断状态 */

（6）读设备：应用程序从设备中读取数据，调用这个函数，会从 dev 设备中读取数据，并存放在 buffer 缓冲区中，这个缓冲区的最大长度是 size，pos 根据不同的设备类别有不同的意义。

rt_size_t rt_device_read(rt_device_t dev, rt_off_t pos,void* buffer, rt_size_t size);

参数描述
dev设备句柄
pos读取数据偏移量
buffer内存缓冲区指针，读取的数据将会被保存在缓冲区中
size读取数据的大小
返回— —
读到数据的实际大小如果是字符设备，返回大小以字节为单位，如果是块设备，返回的大小以块为单位
0需要读取当前线程的 errno 来判断错误状态

（7）写设备：向设备中写入数据，调用这个函数，会把缓冲区 buffer 中的数据写入到设备 dev 中，写入数据的最大长度是 size，pos 根据不同的设备类别存在不同的意义。

rt_size_t rt_device_write(rt_device_t dev, rt_off_t pos,const void* buffer, rt_size_t size);

参数描述
dev设备句柄
pos写入数据偏移量
buffer内存缓冲区指针，放置要写入的数据
size写入数据的大小
返回— —
写入数据的实际大小如果是字符设备，返回大小以字节为单位；如果是块设备，返回的大小以块为单位
0需要读取当前线程的 errno 来判断错误状态

（8）数据接收回调：当硬件设备收到数据时，可以通过如下函数回调另一个函数来设置数据接收指示，通知上层应用线程有数据到达。

rt_err_t rt_device_set_rx_indicate(rt_device_t dev, rt_err_t (*rx_ind)(rt_device_t dev,rt_size_t size));

参数描述
dev设备句柄
rx_ind回调函数指针
返回— —
RT_EOK设置成功
  • 该函数的回调函数由调用者提供。当硬件设备接收到数据时，会回调这个函数并把收到的数据长度放在 size 参数中传递给上层应用。上层应用线程应在收到指示后，立刻从设备中读取数据。

（9）数据发送回调：应用程序调用 rt_device_write() 写入数据时，如果底层硬件能够支持自动发送，那么上层应用可以设置一个回调函数。这个回调函数会在底层硬件数据发送完成后 (例如 DMA 传送完成或 FIFO 已经写入完毕产生完成中断时) 调用。

参数描述
dev设备句柄
tx_done回调函数指针
返回— —
RT_EOK设置成功
  • 调用这个函数时，回调函数由调用者提供，当硬件设备发送完数据时，由驱动程序回调这个函数并把发送完成的数据块地址 buffer 作为参数传递给上层应用。上层应用（线程）在收到指示时会根据发送 buffer 的情况，释放 buffer 内存块或将其作为下一个写数据的缓存。

三、收发函数以及校验

1.接收函数线程：在一个线程中进行数据的接收，通过接收中断来实现。

g_rs485.dev->read(g_user_data.dev, 0, &ch, 1);		// 接收一个字节的数据

2.发送函数：将接收到的数据通过发送函数，进行发送。

g_rs485.dev->write(RT_NULL, 0, g_rs485.queue, g_rs485.qpush_index);  	// 将数据发送出去

3.串口接收中断：通过使用信号量，当接收到数据时，释放信号量，进行数据接收。

/**
 * @brief 串口接收回调函数
 */
static rt_err_t rx_callback(rt_device_t dev, rt_size_t size)
{
    /*串口接收到数据后,马上释放信号量,以便读取数据的线程运行*/
    rt_sem_release(g_rs485.rx_sem);

    return RT_EOK;
}

4.CRC校验：通过函数实现ModbusCRC16数据校验码

/**
 * @brief  CRC校验码生成
 * @param  CRC_Ptr->数组指针，LEN->长度
 * @retval CRC校验值
 */
rt_uint16_t CRC_Check(uint8_t *CRC_Ptr, uint8_t LEN)
{
    rt_uint16_t CRC_Value = 0;
    rt_uint8_t i = 0;
    rt_uint8_t j = 0;

    CRC_Value = 0xffff;

    // LEN为数组长度
    for (i = 0; i < LEN; i++)
    {
        CRC_Value ^= *(CRC_Ptr + i);
        for (j = 0; j < 8; j++)
        {
            if (CRC_Value & 0x00001)
                CRC_Value = (CRC_Value >> 1) ^ 0xA001;
            else
                CRC_Value = (CRC_Value >> 1);
        }
    }

    // 交换高低字节
    CRC_Value = ((CRC_Value >> 8) + (CRC_Value << 8));

    return CRC_Value;
}

四、完整代码

1.rs485.h

#ifndef APPLICATIONS_RS485_H_
#define APPLICATIONS_RS485_H_

#include <rtthread.h>
#include <drv_usart.h>
#include <rtdef.h>

/**====================================================###### 宏定义 ######==================================================*/
#define RS485_DEV_NAME  "RS485"
#define RS485_UART_DEV_NAME  "uart3"

#define QUEUE_SIZE          100     // 接收字节大小

#define RT_DEVICE_CTRL_LOCK             0x13
#define RT_DEVICE_CTRL_UNLOCK           0x14

// 串口初始化参数
#define RT_RS485_SERIAL_CONFIG                           \
{                                                        \
    BAUD_RATE_115200,               /* 115200 bits/s */  \
    DATA_BITS_8,                    /* 8 databits */     \
    STOP_BITS_1,                    /* 1 stopbit */      \
    PARITY_NONE,                    /* No parity  */     \
    BIT_ORDER_LSB,                  /* LSB first sent */ \
    NRZ_NORMAL,                     /* Normal mode */    \
    RT_SERIAL_RB_BUFSZ,             /* Buffer size */    \
    RT_SERIAL_FLOWCONTROL_NONE,     /* Off flowcontrol */\
    0                                                    \
}

typedef struct
{
    rt_device_t dev;        // 设备名称
    rt_uint32_t timout_us;  // 超时时间
    const char *name;       // 设备名字

} rs485_user_t;

typedef struct
{
    rt_device_t dev;                    // 注册设备
    rt_sem_t rx_sem;                    // 信号量
    rt_thread_t thread;                 // RS485线程

    rt_uint8_t qpush_index;             // 队列序号
    rt_uint8_t *queue;                  // 队列

} rs485_dev_t;

struct sram_device
{
    struct rt_device parent;
    struct rt_mutex lock;
};

rs485_dev_t g_rs485;                    // 注册设备结构体
rs485_user_t g_user_data;               // 用户数据结构体

#define lock(x)         rt_mutex_take(&x->lock, RT_WAITING_FOREVER)
#define unlock(x)       rt_mutex_release(&x->lock)
/**====================================================#######  END  #######=================================================*/

#endif /* APPLICATIONS_RS485_H_ */

2.rs485.c

#include "rs485.h"
#include <rtdevice.h>

struct serial_configure rs485_config = RT_RS485_SERIAL_CONFIG;   /* 初始化串口配置参数 */

/*=====================================================### 静态函数调用 ###==================================================*/
/**
 * @brief  CRC校验码生成
 * @param  CRC_Ptr->数组指针，LEN->长度
 * @retval CRC校验值
 */
rt_uint16_t CRC_Check(uint8_t *CRC_Ptr, uint8_t LEN)
{
    rt_uint16_t CRC_Value = 0;
    rt_uint8_t i = 0;
    rt_uint8_t j = 0;

    CRC_Value = 0xffff;

    // LEN为数组长度
    for (i = 0; i < LEN; i++)
    {
        CRC_Value ^= *(CRC_Ptr + i);
        for (j = 0; j < 8; j++)
        {
            if (CRC_Value & 0x00001)
                CRC_Value = (CRC_Value >> 1) ^ 0xA001;
            else
                CRC_Value = (CRC_Value >> 1);
        }
    }

    // 交换高低字节
    CRC_Value = ((CRC_Value >> 8) + (CRC_Value << 8));

    return CRC_Value;
}

/**
 * @brief 串口接收回调函数
 */
static rt_err_t rx_callback(rt_device_t dev, rt_size_t size)
{
    /*串口接收到数据后,马上释放信号量,以便读取数据的线程运行*/
    rt_sem_release(g_rs485.rx_sem);

    return RT_EOK;
}

/**
 * @brief RS485接收线程
 * @param param
 */
void rs485_rx_thread_entry(void *param)
{
    char ch;
    g_rs485.qpush_index = 0;
    rt_err_t result;
    rt_uint16_t CRC_Value = 0;

    while (1)
    {
        if (g_rs485.qpush_index >= QUEUE_SIZE)
            g_rs485.qpush_index = 0;

        // 信号量设置超时时间
        result = rt_sem_take(g_rs485.rx_sem, 1000);
        if (result == RT_EOK)
        {
            g_rs485.dev->read(g_user_data.dev, 0, &ch, 1);
            g_rs485.queue[g_rs485.qpush_index++] = ch;

            // 接收数据超过三个
            if (g_rs485.qpush_index > 3)
            {
                // CRC校验
                CRC_Value = CRC_Check(g_rs485.queue, (g_rs485.qpush_index - 2));

                // 校验合格才会处理数据
                if ((g_rs485.queue[g_rs485.qpush_index - 1] == ((char) CRC_Value))
                        && (g_rs485.queue[g_rs485.qpush_index - 2] == (char) (CRC_Value >> 8)))
                {
                    g_rs485.dev->write(RT_NULL, 0, g_rs485.queue, g_rs485.qpush_index);
                    g_rs485.qpush_index = 0;
                }
            }
        }
        else
        {
            g_rs485.qpush_index = 0;
        }
    }
}
/*=====================================================#######  END  #######=================================================*/

/*=====================================================##### 设备注册 #####==================================================*/
/**
 * @brief 设备初始化接口
 * @return
 */
rt_err_t rs485_usart_init(rt_device_t dev)
{
    g_rs485.queue = rt_malloc(QUEUE_SIZE);

    // 查找创建的设备
    g_rs485.dev = (rt_device_t) rt_device_find(RS485_DEV_NAME);
    RT_ASSERT(g_rs485.dev != RT_NULL);

    // 配置创建设备的参数
    rt_device_control(g_rs485.dev, RT_DEVICE_CTRL_CONFIG, (void *)&g_user_data);

    return RT_EOK;
}
INIT_ENV_EXPORT(rs485_usart_init);

/**
 * @brief 设备打开接口
 * @return
 */
rt_err_t rs485_usart_open(rt_device_t dev, rt_uint16_t oflag)
{
    rs485_user_t *user = (rs485_user_t *)g_rs485.dev->user_data;

    rt_device_open(user->dev, RT_DEVICE_FLAG_INT_RX);
    return RT_EOK;
}

/**
 * @brief 设备关闭接口
 * @return
 */
rt_err_t rs485_usart_close(rt_device_t dev)
{
    return RT_EOK;
}

/**
 * @brief 设备读取接口
 * @return
 */
rt_size_t rs485_usart_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
{
    rs485_user_t *user = (rs485_user_t *)g_rs485.dev->user_data;

    size = rt_device_read(user->dev, 0, buffer, 1);

    return size;
}

/**
 * @brief 设备写入接口
 * @return
 */
rt_size_t rs485_usart_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
{
    if (g_user_data.name == RT_NULL)
        return 0;

    rs485_user_t *user = (rs485_user_t *)g_rs485.dev->user_data;

    user->dev->write(user->dev, pos, buffer, size);

    return 1;
}

/**
 * @brief 设备控制接口
 * @return
 */
rt_err_t rs485_usart_control(rt_device_t dev, int cmd, void *args)
{
    int ret = -RT_ERROR;
    struct sram_device *sdcard;
    RT_ASSERT(dev != 0);

    sdcard = (struct sram_device *)dev;

    switch (cmd)
    {
        // 设置互斥锁
        case RT_DEVICE_CTRL_LOCK:
            lock(sdcard);
            ret = RT_EOK;
            break;

        // 解除互斥锁
        case RT_DEVICE_CTRL_UNLOCK:
            unlock(sdcard);
            ret = RT_EOK;
            break;

        default:
            ret = -RT_ERROR;
            break;
    }

    return ret;
}

/**
 * @brief 串口3参数初始化
 */
void usart3_param_init(void)
{
    rt_err_t ret;

    // 查找串口设备获取设备句柄
    rt_device_t serial_dev = (rt_device_t) rt_device_find(RS485_UART_DEV_NAME);
    RT_ASSERT(serial_dev != RT_NULL);

    // 打开串口，可读可写|接收中断方式打开
    ret = rt_device_open(serial_dev, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
    RT_ASSERT(ret == RT_EOK);

    // 配置串口参数
    rt_device_control(serial_dev, RT_DEVICE_CTRL_CONFIG, (void *) &rs485_config);

    // 设置接收中断函数
    rt_device_set_rx_indicate(serial_dev, rx_callback);

    // 创建信号量
    g_rs485.rx_sem = rt_sem_create("rs485_sem", 0, RT_IPC_FLAG_PRIO);

    // 初始化用户数据
    g_user_data.name = RS485_DEV_NAME;
    g_user_data.timout_us = 1;
    g_user_data.dev = serial_dev;

    // 创建接收线程
    g_rs485.thread = rt_thread_create("rs485_rx", rs485_rx_thread_entry, serial_dev, 1024, 16, 20);
    if (g_rs485.thread == RT_NULL)
    {
        rt_kprintf("rt_thread_create failedread_th...\n");
    }
    else
    {
        // 启动线程
        rt_thread_startup(g_rs485.thread);
    }
}

/**
 * @brief RS485设备注册
 * @return 0:成功 -1：失败
 */
static int RS485_Device_Register(void)
{
    rt_err_t ret;

    // 开辟一个存储空间
    g_rs485.dev = rt_malloc(sizeof(struct rt_device));
    rt_memset(g_rs485.dev, 0, sizeof(struct rt_device));

    // 串口3参数初始化
    usart3_param_init();

    // 结构体初始化
    g_rs485.dev->type       = RT_Device_Class_Char;     // 设备类型
    g_rs485.dev->init       = rs485_usart_init;         // 设备初始化接口
    g_rs485.dev->open       = rs485_usart_open;         // 设备打开接口
    g_rs485.dev->close      = rs485_usart_close;        // 设备关闭接口
    g_rs485.dev->read       = rs485_usart_read;         // 设备读取接口
    g_rs485.dev->write      = rs485_usart_write;        // 设备写入接口
    g_rs485.dev->control    = rs485_usart_control;      // 设备控制接口
    g_rs485.dev->user_data  = &g_user_data;             // 设备数据

    // 设备注册
    ret = rt_device_register(g_rs485.dev, RS485_DEV_NAME, RT_DEVICE_FLAG_RDWR);

    return ret;
}
INIT_DEVICE_EXPORT(RS485_Device_Register);
/*=====================================================#######  END  #######=================================================*/

五、测试现象

通过发送ModBus的指令，来测试程序是否可以使用，并且串口可以自动加CRC16校验：
在这里插入图片描述

六、其他RS485例程

===》》》RS485使用DMA串行通信进行数据收发
===》》》RS485使用中断进行数据收发

0南城逆流0
关注
  • 22
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
RT-Thread 应用笔记 - freemodbus RTU RS485 从机
坚韧与专注
12-01 5075
RT-Thread 应用笔记 - 不正确使用LOG也会引发hard fault RT-thread 应用笔记 - RTC Alarm 组件的使用 RT-thread 应用笔记 - freemodbus RTU RS485 从机 背景 modbus协议，简单，实用，一些小数据通信控制场合，用的比较多。 部分用户使用起来，并不是想象中那么的顺利。 freemodbus，官方提供从机的程序，代码比较易懂，易于学习协议的实现。 基于rt-threaad，已经有freemodbus的主从机软件包。.
RTT-ViewerPlusProMax-V1.0.0.1
05-12
JLinkARM.dll是SEGGER公司的J-Link调试器的动态链接库文件，它是RTT-ViewerPlusProMax与硬件设备进行通信的核心组件。通过这个库，程序可以实现对J-Link调试器的控制，包括读取和写入目标系统的内存，设置断点，以及...
玩转RT-Thread系列教程(9)--485总线读取温湿度
Rb的工作站
06-02 5734
玩转RT-Thread系列教程(9)–485总线读取温湿度 一、485总线介绍 485（一般称作 RS485/EIA-485）是隶属于 OSI 模型物理层的电气特性规定为 2 线，半双工，多点通信的标准。它的电气特性和 RS-232 大不一样。用缆线两端的电压差值来表示传递信号。RS485 仅仅规定了接受端和发送端的电气特性。它没有规定或推荐任何数据协议。 RS485 的特点包括： 1） 接口电平低，不易损坏芯片。RS485 的电气特性：逻辑“1”以两线间的电压差为+(26)V表示；逻辑“0”以两线间的电
【RTT-Studio】详细使用教程三：DAC模拟输出
最新发布
Hei_se_meng_yan的博客
07-18 1163
【RTT-Studio】详细使用教程三：DAC模拟输出
【开发工具】RT-Thread Studio使用教程
但行好事，莫问前程
12-12 2612
RT-Thread Studio安装、开发、使用教程
使用RT-Thread Studio, RT-Thread+ stm32f103c8最小系统板点亮LED灯
紫蝶侠的博客
03-07 2305
1. 使用RT-Thread Studio 新建RT-Thread项目 2. 根据自己芯片选择 3. 在main.c中添加如下代码 #include <rtthread.h> #include <board.h> #include <rtdevice.h> #define DBG_TAG "main" #define DBG_LVL DBG_LOG #in...
【STM32】RTT-Studio中HAL库开发教程一：RS485串行通信
Hei_se_meng_yan的博客
06-28 1495
STM32在RTT-Studio中使用HAL库进行RS485通信代码
RTT（RT-Thread）串口设备（RTT保姆级教程）
qq_25218501的博客
08-14 6521
本章主要介绍串口设备在RT-Thread操作系统中应用层如何使用。关于串口设备的使用，我们只需要在应用层找到串口设备，然后去初始化，初始化完成以后就可以读写串口设备了。操作的方法在应用层，驱动是不需要我们去完成的，驱动已经在操作系统中提供了。
FreeModbus_Slave-Master-RTT-STM32-master_stm32mastermodbus_stm32
09-11
《FreeModbus_Slave-Master-RTT-STM32-master_stm32mastermodbus_stm32：深入理解MODBUS通信在STM32中的应用》 MODBUS通信协议，作为工业自动化领域的标准通信协议，因其简单、开放、易实现的特点，在嵌入式系统...
jlink RTT-V1.6
11-08
这是一个J-Llink RTT软件，用来接收由MCU通过SEGGER RTT发送的数据,通过JLink SWD/JTAG端口打印/接收调试信息，无需额外的物理串口 1 RTT简介 RTT全称是Real Time Transmit（实时传输）是Segger公司推出的调试手段...
FreeModbus_Slave-Master-RTT-STM32.zip_FreeModbus裸机_Master/Slave_
07-14
FreeModbus是一款开源的Modbus协议栈，但是只有从机开源，主机源码是需要收费的。同时网上也没有发现比较好的开源的Modbus主机协议栈，所以才开发这款支持主机模式的FreeModbus协议栈。本版FreeModbus版本号更改为V...
手把手教你RT-Thread 环境快速搭建入门教程.zip
11-01
内有三个pdf文档，分别为：《正点原子-RT-Thread 环境快速搭建入门教程》；《手把手教你实战RT-Thread Nano，不信都这样了你还不会》；《RT-Thread实时操作系统编程指南》。
FreeModbus_Slave-Master-RTT-STM32:Add master mode to FreeModbus. | 在 FreeModbus 中添加主机模式
04-30
FreeModbus V1.6 主机使用说明 一、简述 FreeModbus是一款开源的Modbus协议栈，但是只有从机开源，主机源码是需要收费的。同时网上也没有发现比较好的开源的Modbus主机协议栈，所以才开发这款支持主机模式的Free...
RT-Thread Studio 项目实战教程 | 快速打造一个桌面mini网络时钟TOC
qq_51146579的博客
06-28 695
RT-Thread Studio 项目实战教程 | 快速打造一个桌面mini网络时钟TOC 一、前期准备 1. 1.1开发环境准备 RT-Thread Studio 是一站式的 RT-Thread 开发工具，通过简单易用的图形化配置系统以及丰富的软件包和组件资源，让物联网开发变得简单和高效。 官网下载 新建工程采用开发板项目 1. 1.2硬件准备 ART-Pi硬件需求 主控：ART-Pi开发板 温湿度传感器： SHT30 通信模组：ESP8266（WIFI） 显示模组：0.96’OLED（SSD130
RT-Thread Studio学习（一）新建工程
iqiaoqiao的博客
02-27 6931
RT-Thread Studio学习（一）使用外部时钟系统开发环境简介新建RT-Thread项目CubeMX配置设置工程 开发环境 MCU：STM32F407VET6 RT-Thread Studio: V2.1.5 RT-Thread内核：V4.0.3 STM32 CubeMX: V6.3.0 KEIL: V5.35.0.0 STM32 CubeMX firmware: STM32Cube FW_F4 V1.26.2 简介 本文将介绍如何使用RT-Thread Studio来新建项目，并结合STM3
RT-Thread studio使用（持续更新）
热门推荐
仰望星空，脚踏实地的博客
11-18 1万+
记录RT-Thread studio软件的下载安装，创建工程，日常使用，以及常见问题解决
RT-Thread中RS485驱动包的使用
weixin_46158019的博客
02-07 1160
开发环境：野火的stm32f407，rt-thread studio版本是版本: 2.2.6，stm32f4的资源包为0.2.2。工程使用上一篇 rt-thread studio新建stm32f407工程为基础。硬件配置：查看野火资料确定rs485的引脚和控制脚分别是：485_R:USART2_RX PA3；485_T:USART2_TX PA2；控制脚：PC0。野火板子需要使用跳线帽进行连接48...
手把手教你基于RT-Thread Studio 使用STM32单片机的PWM外设
qq_21479819的博客
03-14 4888
一、使用说明 目前我使用的是STM32L475系列单片机，是ali当时在PDD 50块钱卖的一个开发板，其他STM32单片机参考即可，这里会手把手教大家基于RTT Studio 来使用PWM。 工程链接奉上，Gitee链接 二、创建工程 1. 创建工程 首先大家打开RT-Thread Studio 来基于单片机创建工程。点击左上角文件，新建 RT-Thread项目 Project name就是项目名称，如果大家想自定义路径保存，就取消掉缺省位置然后自定义路径。 2. 芯片参数设置 选择基于芯片，下面的参数
rtthread 添加串口 (uart2)
lyq308152569的博客
11-25 3708
查询uart配置过程 文件路径： /drivers/board.h /** After configuring corresponding UART or UART DMA, you can use it. * * STEP 1, define macro define related to the serial port opening based on the serial port number * such as #define BSP_USING_UA
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值