RT-Thread-串口发送函数解析 -- 关于流模式RT-Thread问答社区

串口发送函数解析 -- 关于流模式

发布于 2022-08-11 17:42:55 浏览：1164 订阅该版

问题
Q1、在使用GD32F303的官方移植的开发板的例程代码的时候，串口发送能不能使用中断和DMA方式进行发送，和流模式有什么区别？
回答：在该模式下并不支持中断和DMA的方式发送数据，实际在发送过程中，都是以流模式进行数据发送的。

1、在非中断发送模式下
rt_device_write(hinst->serial, 0, buf, size);  发送函数
device_write(dev, pos, buffer, size);通过调用外设公用组件中的写函数，该函数由下面的定义做出规定#define device_write    (dev->write)。
根据下面的结构体，可以定位到dev->write。
```
struct rt_device
{
    struct rt_object          parent;                   /**< inherit from rt_object */

enum rt_device_class_type type;                     /**< device type */
    rt_uint16_t               flag;                     /**< device flag */
    rt_uint16_t               open_flag;                /**< device open flag */

rt_uint8_t                ref_count;                /**< reference count */
    rt_uint8_t                device_id;                /**< 0 - 255 */

/* device call back */
    rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
    rt_err_t (*tx_complete)(rt_device_t dev, void *buffer);

#ifdef RT_USING_DEVICE_OPS
    const struct rt_device_ops *ops;
#else
    /* common device interface */
    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);
#endif

#ifdef RT_USING_POSIX_DEVIO
    const struct dfs_file_ops *fops;
    struct rt_wqueue wait_queue;
#endif

void                     *user_data;                /**< device private data */
    void                     *device_data;                /**< device private data */
};

```
```
struct rt_serial_device
{
    struct rt_device          parent;

const struct rt_uart_ops *ops;
    struct serial_configure   config;

void *serial_rx;
    void *serial_tx;
};
```
在
```
/* register UART device */
        rt_hw_serial_register(uarts[i].serial,
                              uarts[i].device_name,
                              RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
                              (void *)&uarts[i]);
代码中，进行了如下的初始化过程
device->write       = rt_serial_write;
下列代码时串行设备的写指令
static rt_size_t rt_serial_write(struct rt_device *dev,
                                 rt_off_t          pos,
                                 const void       *buffer,
                                 rt_size_t         size)
{
    struct rt_serial_device *serial;

RT_ASSERT(dev != RT_NULL);
    if (size == 0) return 0;
  //在设备信息结构体中，dev是rt_serial_device结构体的第一个参数，这样用dev作为地址，就可以找到整个参  //数
    serial = (struct rt_serial_device *)dev;
//以中断的方式发送数据
    if (dev->open_flag & RT_DEVICE_FLAG_INT_TX)
    {
        return _serial_int_tx(serial, (const rt_uint8_t *)buffer, size);
    }
//以DMA的方式发送数据
#ifdef RT_SERIAL_USING_DMA
    else if (dev->open_flag & RT_DEVICE_FLAG_DMA_TX)
    {
        return _serial_dma_tx(serial, (const rt_uint8_t *)buffer, size);
    }
#endif /* RT_SERIAL_USING_DMA */
//以阻塞的方式发送数据
    else
    {
        return _serial_poll_tx(serial, (const rt_uint8_t *)buffer, size);
    }
}
```
```
一下代码是中断发送代码
rt_inline int _serial_int_tx(struct rt_serial_device *serial, const rt_uint8_t *data, int length)
{
    int size;
    struct rt_serial_tx_fifo *tx;

RT_ASSERT(serial != RT_NULL);

size = length;
    tx = (struct rt_serial_tx_fifo*) serial->serial_tx;
    RT_ASSERT(tx != RT_NULL);

while (length)
    {
        /*
         * to be polite with serial console add a line feed
         * to the carriage return character
         */
//当数据是流数据的情况下，检测到\n就会自动加入\R
        if (*data == '\n' && (serial->parent.open_flag & RT_DEVICE_FLAG_STREAM))
        {
            if (serial->ops->putc(serial, '\r') == -1)
            {
                rt_completion_wait(&(tx->completion), RT_WAITING_FOREVER);
                continue;
            }
        }
//通过结构体讲数据映射到输出gd32_putc函数上。
//在这一行会等待发送结束的标志位。
//但是在自己写的串口发送数据的函数中gd32_putc中，不会返回-1，所以不会等待接收完成标志位。
        if (serial->ops->putc(serial, *(char*)data) == -1)
        {
            rt_completion_wait(&(tx->completion), RT_WAITING_FOREVER);
            continue;
        }

data ++; length --;
    }

return size - length;
}
```
```
关于(serial->ops->putc(serial, '\r')的初始化，在下两段代码中实现
static const struct rt_uart_ops gd32_uart_ops =
{
    gd32_configure,
    gd32_control,
    gd32_putc,
    gd32_getc
};
```
```
int gd32_hw_usart_init(void)
{
    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
    int i;

for (i = 0; i < sizeof(uarts) / sizeof(uarts[0]); i++)
    {
        uarts[i].serial->ops    = &gd32_uart_ops;
        uarts[i].serial->config = config;

/* register UART device */
        rt_hw_serial_register(uarts[i].serial,
                              uarts[i].device_name,
                              RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
                              (void *)&uarts[i]);
    }

return 0;
}
```
```
//流模式
rt_inline int _serial_poll_tx(struct rt_serial_device *serial, const rt_uint8_t *data, int length)
{
    int size;
    RT_ASSERT(serial != RT_NULL);

size = length;
    while (length)
    {
        /*
         * to be polite with serial console add a line feed
         * to the carriage return character
         */
        if (*data == '\n' && (serial->parent.open_flag & RT_DEVICE_FLAG_STREAM))
        {
            serial->ops->putc(serial, '\r');
        }

serial->ops->putc(serial, *data);

++ data;
        -- length;
    }

return size - length;
}
```
需要注意的是，在rt_hw_serial_register函数中，入口参数的类型是struct rt_serial_device，但是device = &(serial->parent);代码中device的类型是rt_device，而实际使用串口组件的时候使用的数据类型是typedef struct rt_device *rt_device_t;这一个。在rt_hw_serial_register函数中，通过device->user_data   = data;代码存储了整个设备外设的信息。即用户数据里面存储了整个外设的信息。