rt-thread 串口不能同时支持dma发送和接收？

发布于 2022-03-10 14:11:47 浏览：1647 订阅该版

1 个回答

crystal266 2022-03-10

嵌入式

可以同时支持收发的。在打开串口时设备模式标志位按照下面的方式就可以同时支持收发了。
```
rt_device_open(serial, RT_DEVICE_FLAG_DMA_RX | RT_DEVICE_FLAG_DMA_TX);
```

我觉得你找错了位置，串口设备打开的调用过程如下：rt_serial_open 会调用两次 stm32_dma_config 进行 DMA 收发的配置。 
```
rt_device_open
    |-> device_init
        |-> erial->ops->configure
            |-> stm32_configure
                |-> HAL_UART_Init
                    |-> HAL_UART_MspInit
    |-> device_open
        |-> rt_serial_open
            |-> serial->ops->control
                |-> stm32_control
                    |-> stm32_dma_config   /* DMA配置，DMA收发各调用一次 */
```

rt_serial_open 的源码如下，为了突出 DMA 的配置将和DMA配置无关的代码省去。从代码中分析可以看到首先进行了接收的判断和接收的配置，然后再进行了发送的配置。调用了两次 serial->ops->control 也就是调用了两次 stm32_dma_config 分别进行 DMA 收发的配置。
```
/* drivers/drv_usart.c */
static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag)
{
    ... ...  // 过程省略

/* initialize the Rx/Tx structure according to open flag */
    if (serial->serial_rx == RT_NULL)
    {
        if (oflag & RT_DEVICE_FLAG_INT_RX)
        {
            ... ...  // 过程省略
        }
#ifdef RT_SERIAL_USING_DMA
        else if (oflag & RT_DEVICE_FLAG_DMA_RX) 
        {
            if (serial->config.bufsz == 0) {
                struct rt_serial_rx_dma* rx_dma;

rx_dma = (struct rt_serial_rx_dma*) rt_malloc (sizeof(struct rt_serial_rx_dma));
                RT_ASSERT(rx_dma != RT_NULL);
                rx_dma->activated = RT_FALSE;

serial->serial_rx = rx_dma;
            } else {
                struct rt_serial_rx_fifo* rx_fifo;

rx_fifo = (struct rt_serial_rx_fifo*) rt_malloc (sizeof(struct rt_serial_rx_fifo) +
                    serial->config.bufsz);
                RT_ASSERT(rx_fifo != RT_NULL);
                rx_fifo->buffer = (rt_uint8_t*) (rx_fifo + 1);
                rt_memset(rx_fifo->buffer, 0, serial->config.bufsz);
                rx_fifo->put_index = 0;
                rx_fifo->get_index = 0;
                rx_fifo->is_full = RT_FALSE;
                serial->serial_rx = rx_fifo;
                /* configure fifo address and length to low level device */
                serial->ops->control(serial, RT_DEVICE_CTRL_CONFIG, (void *) RT_DEVICE_FLAG_DMA_RX);    // 调用DAM接收的配置
            }
            dev->open_flag |= RT_DEVICE_FLAG_DMA_RX;
        }
#endif /* RT_SERIAL_USING_DMA */
        else
        {
            serial->serial_rx = RT_NULL;
        }
    }
    else
    {
        if (oflag & RT_DEVICE_FLAG_INT_RX)
            dev->open_flag |= RT_DEVICE_FLAG_INT_RX;
#ifdef RT_SERIAL_USING_DMA
        else if (oflag & RT_DEVICE_FLAG_DMA_RX)
            dev->open_flag |= RT_DEVICE_FLAG_DMA_RX;
#endif /* RT_SERIAL_USING_DMA */
    }

if (serial->serial_tx == RT_NULL)
    {
        if (oflag & RT_DEVICE_FLAG_INT_TX)
        {
            ... ...  // 过程省略
        }
#ifdef RT_SERIAL_USING_DMA
        else if (oflag & RT_DEVICE_FLAG_DMA_TX)
        {
            struct rt_serial_tx_dma* tx_dma;

tx_dma = (struct rt_serial_tx_dma*) rt_malloc (sizeof(struct rt_serial_tx_dma));
            RT_ASSERT(tx_dma != RT_NULL);
            tx_dma->activated = RT_FALSE;

rt_data_queue_init(&(tx_dma->data_queue), 8, 4, RT_NULL);
            serial->serial_tx = tx_dma;

dev->open_flag |= RT_DEVICE_FLAG_DMA_TX;
            /* configure low level device */
            serial->ops->control(serial, RT_DEVICE_CTRL_CONFIG, (void *)RT_DEVICE_FLAG_DMA_TX); // 调用 DMA 发送的配置  
        }
#endif /* RT_SERIAL_USING_DMA */
        else
        {
            serial->serial_tx = RT_NULL;
        }
    }
    else
    {
        if (oflag & RT_DEVICE_FLAG_INT_TX)
            dev->open_flag |= RT_DEVICE_FLAG_INT_TX;
#ifdef RT_SERIAL_USING_DMA
        else if (oflag & RT_DEVICE_FLAG_DMA_TX)
            dev->open_flag |= RT_DEVICE_FLAG_DMA_TX;
#endif /* RT_SERIAL_USING_DMA */
    }

/* set stream flag */
    dev->open_flag |= stream_flag;

return RT_EOK;
}
```