rt-thread 驱动篇之 serialX 全网公测 30.00

发布于 2022-01-25 14:46:45 浏览：7395 订阅该版

[tocm]

## 前言

“serialX” 我起的名字，起个名字想破头。
在前一篇文章里，大致提出了我的串口驱动框架理论。里面做了一些对串口驱动特性的幻想。也在 NUC970 芯片下通过了中断模式的实践验证。但是，因为 NUC970 的 uart 自带 fifo 。用它测试效果好，并不能真正说明驱动框架通过验证了。

然后，紧接着笔者在 STM32F429 完成了中断和 DMA 两种模式。今天，我把一些测试结果和移植说明发出来，征求全网公测。

测试配置：DMA 二级缓存 32 个字节，串口收发缓存各 512 字节。

注：本串口驱动工作特性请参阅前一篇文章[rt-thread 驱动篇 之 串口驱动框架剖析性能提升](https://club.rt-thread.org/ask/article/3335.html)

### STM32 中断模式测试

以下是三组连续发收测试：

1. 定时间隔20ms，发送250字节数据，持续发送2600w，接收发送数据量相等
    ![250-20ms-2600w.png](https://oss-club.rt-thread.org/uploads/20220125/5de5de54bb0998667d748cf6356cd28b.png)
2. 定时间隔50ms，发送250字节数据，持续发送600w，接收发送数据量相等
    ![250-50ms-600w.png](https://oss-club.rt-thread.org/uploads/20220125/8e659edea4e6a1285cb26d600ba6bb83.png)
3. 定时间隔80ms，发送1000字节数据，持续发送600w，接收发送数据量相等
    ![1000-80ms-610w.png](https://oss-club.rt-thread.org/uploads/20220125/dce68d173d58b2325a68c5143b0bee92.png)

注：刚刚跟我们小伙伴求证了一下，串口调试助手的定时间隔是固定周期。如果是这样的，以上测试是有意义的，如果不是，那就没达到串口带宽上限。

### STM32 DMA模式测试

1. 读写测试，串口调试助手定时 10ms ，发送40字节数据，持续发送129w
   ![dma-40-10ms-129w.png](https://oss-club.rt-thread.org/uploads/20220125/377e5d219b31b46f8b842a6b078e5c55.png)
2. 串口调试助手定时 50ms ，发送500字节数据，持续发送527w
   ![dma-500-50ms-527w.png](https://oss-club.rt-thread.org/uploads/20220125/4a9c288eaad0690cea1869118ddd3baf.png)
3. 串口调试助手定时 40ms ，发送500字节数据，持续发送261w
   ![dma-500-40ms-261w.png](https://oss-club.rt-thread.org/uploads/20220125/fa8fa1663b1e6b8b48eb324cd58d4d90.png)
4. 串口调试助手定时 40ms ，发送1000字节数据，持续发送262w
   ![dma-1000-40ms-262w.png](https://oss-club.rt-thread.org/uploads/20220125/908be374e0a07c4f37c93558e349ce13.png)
   串口调试助手上发送和接收数量不相等，接着我在代码中添加了个断点，单独发送了一个字节 ‘Z’ 。
   ![dma-1000-40ms-262w-rw.png](https://oss-club.rt-thread.org/uploads/20220125/79547f1a7517248bf37bebf4b3604ebc.png)

代码中接收和发送数量相等，都等于串口调试助手的接收量。这个缺少的部分是串口调试助手发送失败数量，还是串口驱动接收丢失了？

接下来，修改成中断接收发送模式，其它不做修改进行相同的测试，也是有数量差。进一步检查串口驱动里，接收缓存有溢出现象。应用层没来得及把数据取走，就删掉了最旧的数据。

### 接口详解及移植说明

#### rtdef.h 添加几个宏定义

添加一个强制 inline 宏定义

`#define rt_forceinline              static __attribute__((always_inline))`

添加阻塞打开相关标志（）

```
#define RT_DEVICE_OFLAG_BLOCKING        0x000           /**< blocking io mode */
#define RT_DEVICE_OFLAG_NONBLOCKING     0x004           /**< non-blocking io mode */

...

#define RT_DEVICE_CTRL_BLOCKING         0x05            /**< blocking io */
```

#### serialX.h

添加串口驱动缓存和 DMA 二级缓存大小定义（放弃使用 `RT_SERIAL_RB_BUFSZ`）：

```
#ifndef RT_SERIAL_FIFO_BUFSZ
#define RT_SERIAL_FIFO_BUFSZ            512
#endif

#ifndef RT_SERIAL_DMA_BUFSZ
#define RT_SERIAL_DMA_BUFSZ             32
#endif
```

串口接收和发送使用的缓存大小是一样的，如果想改变串口缓存大小，请修改 `RT_SERIAL_FIFO_BUFSZ` 的值。

如果想改变 DMA 二级缓存大小，请修改 `RT_SERIAL_DMA_BUFSZ` 的值。

定义一个收发通用 fifo：

```
struct rt_serial_fifo
{
    rt_uint32_t buf_sz;
    /* software fifo */
    rt_uint8_t *buffer;

rt_uint16_t put_index, get_index;

rt_bool_t is_full;
};
```

重新定义 `rt_serial_device` 定义：

```
struct rt_serial_device
{
    struct rt_device          parent;

const struct rt_uart_ops *ops;
    struct serial_configure   config;

void *serial_rx;			// 串口接收缓存
    void *serial_tx;			// 串口发送缓存

#ifdef RT_SERIAL_USING_DMA							// 串口收发缓存和 DMA 使用的二级缓存分开
    rt_size_t dma_idx_rx;
    rt_uint8_t serial_dma_rx[RT_SERIAL_DMA_BUFSZ];	// DMA 接收缓存
    rt_uint8_t serial_dma_tx[RT_SERIAL_DMA_BUFSZ];	// DMA 发送缓存
#endif

cb_serial_tx _cb_tx;		// 写过程回调函数指针
    cb_serial_rx _cb_rx;		// 读过程回调函数指针

struct rt_completion completion_tx;				// 发送完成
    struct rt_completion completion_rx;				// 接收到新数据
};
typedef struct rt_serial_device rt_serial_t;
```

串口驱动通用框架和硬件底层接口定义

```
struct rt_uart_ops
{
	// 用于配置外设寄存器，引脚功能复用，启用外设等等
    rt_err_t (*configure)(struct rt_serial_device *serial, struct serial_configure *cfg);
    // 用于使能禁用中断，初始配置 DMA
    rt_err_t (*control)(struct rt_serial_device *serial, int cmd, void *arg);
	// 串口外设写数据寄存器*为空*，把数据放入写数据寄存器。*不为空*，死等
    int (*putc)(struct rt_serial_device *serial, char c);
    // 串口外设读数据寄存器*不为空*，读出读数据寄存器的值。*为空*，返回 -1
    int (*getc)(struct rt_serial_device *serial);

// 启动发送，多数是开启串口外设发送寄存器空中断
    void (*start_tx)(struct rt_serial_device *serial);
	// 结束发送，多数是关闭串口外设发送寄存器空中断
    void (*stop_tx)(struct rt_serial_device *serial);

#ifdef RT_SERIAL_USING_DMA
	// 判断 DMA 是否在发送过程中，就像上一篇里笔者多次提示的，必须有效检测 DMA 是否在发送数据中
    rt_bool_t (*is_dma_txing)(struct rt_serial_device *serial);
    // 启动 DMA 发送
    void (*start_dma_tx)(struct rt_serial_device *serial, rt_uint8_t *buf, rt_size_t size);
    // 停止 DMA 发送
    void (*stop_dma_tx)(struct rt_serial_device *serial);
#endif
	// 使能串口外设中断
    void (*enable_interrupt)(struct rt_serial_device *serial);
    // 禁用串口外设中断
    void (*disable_interrupt)(struct rt_serial_device *serial);
};
```

移植 serialX 到新芯片上，必须按照 `rt_uart_ops` 的定义实现上述几个接口。函数功能不能随意更改。

#### `rt_hw_serial_isr`

这个中断只接收 `RT_SERIAL_EVENT_RX_IND` `RT_SERIAL_EVENT_RX_IND` `RT_SERIAL_EVENT_RX_DMADONE` `RT_SERIAL_EVENT_TX_DMADONE`  四种中断状态。

- `RT_SERIAL_EVENT_RX_IND` 接收寄存器不空中断
- `RT_SERIAL_EVENT_TX_DONE` 发送寄存器空中断，为了兼容自带 fifo 的芯片，event 参数的高三字节代表 fifo 容量
- `RT_SERIAL_EVENT_RX_DMADONE` 串口接收 DMA 中断。 这个可以兼容接收半传输和全传输等多种中断。event 参数的高三字节代表 DMA fifo 接收数据数量（1-RT_SERIAL_DMA_BUFSZ）。
- `RT_SERIAL_EVENT_TX_DMADONE` 串口发送 DMA 中断。这个应该保证 DMA 发送完本次 DMA 缓存中的所有数据，也就是对于 stm32 芯片是 DMA 计数达到 0。

### 使用注意

-  `RT_SERIAL_FIFO_BUFSZ` `RT_SERIAL_DMA_BUFSZ` 两个的定义和实际是否合适，小数据量通信可以定义小点儿，数据量大的情况适当调整这两个值。
- `rt_uart_ops` 接口定义，功能实现必须匹配。
- 阻塞模式，收发是一致的。默认是阻塞模式。想使用非阻塞模式请 open 的时候添加 `RT_DEVICE_OFLAG_NONBLOCKING` flag。
- 使用 `RT_DEVICE_FLAG_INT` `RT_DEVICE_FLAG_DMA_RX` `RT_DEVICE_FLAG_INT_TX` `RT_DEVICE_FLAG_DMA_TX` 四个 open flag 指定收发模式，是用中断还是 DMA。
- **特别提醒**，非阻塞模式下，read 可能返回 0。write 返回值可能不是目标写入 size。read/write 还可能返回 `RT_EXXX` 错误值。
- **特别提醒**，阻塞模式下，read 返回值可能不是期望数据量 size。笔者也曾经提供过可靠处理流数据的方案，详见 [rt-thread 使用宝典（2021-1210更新）](https://club.rt-thread.org/ask/article/3186.html)

#### 使用完成量进入阻塞漏洞分析

> PS: 谢谢 @HelloBye 的及时纠正，`rt_completion` 不存在本小节描述的漏洞。各位看官可以直接跳过本小节了。

串口驱动里有几个阻塞点，进入阻塞都使用的 `rt_completion` ，如下代码：

```
serial->ops->enable_interrupt(serial);
ret = rt_completion_wait(&(serial->completion_rx), RT_WAITING_FOREVER);// 或者 serial->completion_tx
```

首先开中断，调用 `rt_completion_wait` 等待完成量进入阻塞。这样是有个漏洞的，当开中断后有个串口中断，中断处理函数里调用 `rt_completion_done` 是没有任何反应的，`rt_completion_done` 直接返回退出。

进而回到原线程才执行 `rt_completion_wait`。之后，如果有第二次接收（或发送）中断发生时才会结束上一次的阻塞。但是，第二次什么时候出现也就是个未知数了。即便前一次可能已经收全了全部想要的数据，但是会不定期阻塞下去。

解决方法有两个：一、不用永久阻塞，换成 10ms 或者几 ms 等待；二、用二值信号量替代。

但是！！！我没有用上述方法中的任何一个进行改进，原因是：

第一种方法无疑要引入一个循环，`rt_completion_wait` 超时返回的时候循环继续阻塞。还有就是等待时间没有理论支持。最重要的是用循环方式补漏洞的方式不美观。

没使用二值信号量的原因是，rt-thread 的信号量实现没有真正的“二值”，如果中断已经多次 release 了，然后应用层才来一次 take，之后还可能成功 take 多次（虽然应该是要阻塞的，但是实际不阻塞，反而会循环 take 多次）。

~~因此，暂时继续使用完成量。年后信号量的真正的二值性实现后，再换成信号量方式。~~

## 结束语

现笔者将打码开放出来 gitee 仓库 [serialX](https://gitee.com/thewon/serialX)，求全论坛公测。期待各位大佬提出各种测试方案对它蹂躏。

有问题可以在仓库里提 [issue](https://gitee.com/thewon/serialX/issues) ,或者到 rt-thread 官方论坛上进行讨论。

aozima 打赏了 5.00 元 2022-01-25 14:51:51
andychen 打赏了 5.00 元 2022-01-25 17:55:59
jiezhi320 打赏了 10.00 元 2022-05-09 10:23:04
PTEP_5766 打赏了 10.00 元 2022-11-21 14:32:29

54 条评论

Assert 2022-01-25

这家伙很懒，什么也没写！

出出啊 2022-01-25

恃人不如自恃，人之为己者不如己之自为也

出出啊 2022-01-25

恃人不如自恃，人之为己者不如己之自为也

梅江松子 2022-01-25

这家伙很懒，什么也没写！

梅江松子 2022-01-25

这家伙很懒，什么也没写！

mysterywolf 2022-01-26

https://github.com/mysterywolf

梅江松子 2022-01-26

这家伙很懒，什么也没写！

出出啊 2022-01-26

恃人不如自恃，人之为己者不如己之自为也

出出啊 2022-01-26

恃人不如自恃，人之为己者不如己之自为也

hfmm 2022-01-28

这家伙很懒，什么也没写！

出出啊 2022-01-28

恃人不如自恃，人之为己者不如己之自为也

出出啊 2022-01-28

恃人不如自恃，人之为己者不如己之自为也

HelloBye 2022-01-29

这家伙很懒，什么也没写！

不太理解你所说的completion导致阻塞漏洞的理由，你的意思是因为在中断中不能使用 rt_completion_done 还是说 rt_completion_done 先于 rt_completion_wait调用执行导致 done无效？我猜测你说的是第二种。
看 completion 的源码可以发现先done后wiat 还是先wait后done都是可以正常运行的。下面是我写的一个测试代码
```
static struct rt_completion completion1;
static struct rt_completion completion2;

void rt_completion_test_thread(void* par)
{
    struct rt_completion* completion = (struct rt_completion*)par;

LOG_D("%d wait completion addr = %X",rt_tick_get(), completion);
    rt_completion_wait(completion, RT_WAITING_FOREVER);

LOG_I("%d completion addr = %X", rt_tick_get(), completion);

while (1)
    {
        rt_thread_mdelay(100);
    }
}

void rt_completion_test(void)
{
    rt_completion_init(&completion1);
    rt_completion_done(&completion1);

rt_thread_t thread;
    thread = rt_thread_create("completion_test1", rt_completion_test_thread, &completion1, 4096, 25, 5);
    rt_thread_startup(thread);
}

void rt_completion_test1(void)
{
    rt_completion_init(&completion2);

rt_thread_t thread;
    thread = rt_thread_create("completion_test2", rt_completion_test_thread, &completion2, 4096, 25, 5);
    rt_thread_startup(thread);

rt_thread_mdelay(1000);
    rt_completion_done(&completion2);
}
MSH_CMD_EXPORT(rt_completion_test, rt_completion_test);
MSH_CMD_EXPORT(rt_completion_test1, rt_completion_test1);
```
![image.png](https://oss-club.rt-thread.org/uploads/20220129/7d863b1efd9558e99cb5f2e1584a5fbc.png)

出出啊 2022-02-07

恃人不如自恃，人之为己者不如己之自为也

Juggernaut 2022-02-07

①②③

ZWH 2022-03-05

这个人很勤快，没空留下点什么

出出啊 2022-03-05

恃人不如自恃，人之为己者不如己之自为也

ZWH 2022-03-05

这个人很勤快，没空留下点什么

ZWH 2022-03-05

这个人很勤快，没空留下点什么

ZWH 2022-03-05

这个人很勤快，没空留下点什么

出出啊 2022-03-06

恃人不如自恃，人之为己者不如己之自为也

梅江松子 2022-03-07

这家伙很懒，什么也没写！

出出啊 2022-03-07

恃人不如自恃，人之为己者不如己之自为也

cheung 2022-03-31

实事求是

lionshaka 2022-08-23

这家伙很懒，什么也没写！

@出出啊 这段代码感觉怪怪的。
```c
#ifdef RT_SERIAL_USING_DMA
    case RT_SERIAL_EVENT_RX_DMADONE:
    {
        int dma_idx, ch = -1;
        struct rt_serial_fifo* rx_fifo;

if (serial->dma_idx_rx == dma_idx) break;
		
		dma_idx = event >> 8;

rx_fifo = (struct rt_serial_fifo*)serial->serial_rx;

while (serial->dma_idx_rx != dma_idx) {
            ch = serial->serial_dma_rx[serial->dma_idx_rx];

/* if fifo is full, discard one byte first */
            if (rx_fifo->is_full == RT_TRUE) {
                rx_fifo->get_index += 1;
                if (rx_fifo->get_index >= rx_fifo->buf_sz) rx_fifo->get_index = 0;
            }
            /* push a new data */
            _serial_fifo_push_data(rx_fifo, ch);

/* if put index equal to read index, fifo is full */
            if (rx_fifo->put_index == rx_fifo->get_index)
            {
                rx_fifo->is_full = RT_TRUE;
            }
            serial->dma_idx_rx++;
            if (serial->dma_idx_rx == RT_SERIAL_DMA_BUFSZ) {
                serial->dma_idx_rx = 0;
            }
        }
        serial->dma_idx_rx = dma_idx;
#ifndef RT_SERIAL_USE_EVENT
        rt_completion_done(&(serial->completion_rx));
#else
        rt_event_send(serial->rx_done, RT_SERIAL_EVENT_RXDONE);
#endif

/* invoke callback */
        if (serial->parent.rx_indicate != RT_NULL) {
            rt_size_t rx_length;

/* get rx length */
            rx_length = _serial_fifo_calc_data_len(rx_fifo);
            if (rx_length) {
                serial->parent.rx_indicate(&serial->parent, rx_length);
            }
        }
    }
    break;
```

dma_idx定义完后并没有赋值，就与serial->dma_idx_rx进行比较。此时的dma_idx的值不确定，有可能与serial->dma_idx_rx相等，造成数据不存入fifo。实际测试有发现此类情况，在接收到下一条串口命令后，才能把上一条的命令执行处理掉。我感觉是这里的问题，准备把
`dma_idx = event >> 8;`这句提到`if (serial->dma_idx_rx == dma_idx) break;`的前面。明天去了测试一下。