10 串口三种发送方式下485收发引脚控制，轮询发送，中断发送，DMA发送

发布于 2020-11-06 14:34:24 浏览：2629 订阅该版

基于STM32F429硬件的使用情况，

串口三种发送方式下485收发引脚控制
**轮询发送**，我可以直接在发送前发送后设置收发引脚，但是这样子浪费CPU时间
```
int uart_write(uint8_t *data,uint16_t length)
{
    if(config->rts_set)config->rts_set(1);
    rt_device_write(config->dev, 0, data, length);
    if(config->rts_set)config->rts_set(0);
    return 0;
}
```

**中断发送**，代码和流程跟轮询发送一样的，
```
int uart_write(uint8_t *data,uint16_t length)
{
    if(config->rts_set)config->rts_set(1);
    rt_device_write(config->dev, 0, data, length);
    if(config->rts_set)config->rts_set(0);
    return 0;
}
```
通过写数据触发中断，然后等待rt_completion_wait，这时候写线程被挂起
硬件发送完一个字节后中断触发rt_completion_done释放了写线程，接着发下一个字节，如此反复
但是这里我有一个问题，我并没有看到stm32驱动库中哪个函数去调用
rt_hw_serial_isr(serial, RT_SERIAL_EVENT_TX_DONE);中de rt_completion_done(&(tx_fifo->completion));去释放写线程。
检查了void uart_isr(struct rt_serial_device *serial)并没有找到，只有有关DMA的接收完成函数

```
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
    struct stm32_uart *uart;
    RT_ASSERT(huart != NULL);
    uart = (struct stm32_uart *)huart;
    _dma_tx_complete(&uart->serial);
}
```
后面调用了
rt_hw_serial_isr(serial, RT_SERIAL_EVENT_TX_DMADONE);
这个是中断发送的问题，我现在暂时不敢确定这个到底会不会被调用释放

**DMA发送**
然后是DMA的发送方法比较复杂，我只能开始前切换到发送模式，通过发送完成回调去关闭发送引脚
```
int uart_write(uint8_t *data,uint16_t length)
{
    if(config->rts_set)config->rts_set(1);
    rt_device_write(config->dev, 0, data, length);
    return 0;
}

//设置发送回调函数
static rt_err_t uart_tx_complete(rt_device_t dev, void *buffer)
{
    if(config->rts_set)config->rts_set(0);
}

rt_device_set_tx_complete(uart_config->dev, uart_tx_complete);

```

但是这又一个新的问题，如果rt_data_queue_pop中还有数据，在DMA发送上一帧数据完后执行到rt_hw_serial_isr函数中下面这段时，从rt_data_queue_pop中拿出数据通过serial->ops->dma_transmit发送出去，在下面接着运行了tx_complete函数，我的RS485收发引脚已经被关了，处于接收状态，这个时候DMA中发的数据肯定发送不出去

```
        case RT_SERIAL_EVENT_TX_DMADONE:
        {
            const void *data_ptr;
            rt_size_t data_size;
            const void *last_data_ptr;
            struct rt_serial_tx_dma *tx_dma;

tx_dma = (struct rt_serial_tx_dma*) serial->serial_tx;

rt_data_queue_pop(&(tx_dma->data_queue), &last_data_ptr, &data_size, 0);
            if (rt_data_queue_peak(&(tx_dma->data_queue), &data_ptr, &data_size) == RT_EOK)
            {
                /* transmit next data node */
                tx_dma->activated = RT_TRUE;
                serial->ops->dma_transmit(serial, (rt_uint8_t *)data_ptr, data_size, RT_SERIAL_DMA_TX);
            }
            else
            {
                tx_dma->activated = RT_FALSE;
            }

/* invoke callback */
            if (serial->parent.tx_complete != RT_NULL)
            {
                serial->parent.tx_complete(&serial->parent, (void*)last_data_ptr);
            }
            break;
        }
```

请问大家有什么办法不？

3 个回答

2pw 2020-11-10

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

文武斌 2020-11-11

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

请登录后再发布评论，点击登录

追加回复

Acuity 2020-11-08

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

文武斌 2020-11-09

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

但是在实际应用中，我调用了发送函数，调用返回时我是期望数据已经发送出去了，这样我好做接下来的收发引脚切换和接收应答数据，如果发送完成就不知道这个数据的情况了，这样程序就不可控了。
理想状态下我调用写或者发送函数，驱动将数据传到低层，
1.如果是轮询发送就会一直占用cpu去查询发送状态，
2.如果是中断发送就会发送一个数据挂起线程，然后等待发送完成中断触发恢复线程，如此循环将数据全部发送出去之后就恢复线程继续运行下面逻辑（这样可能适合低波特率使用，太频繁的中断和线程切换），
3.如果是DMA发送就会先将数据存在数据队列data_quque,然后再把数据转移到DMA的buff中发送，同样我也希望这个时候能先挂起我的线程，等待发送完再恢复，然后继续运行下面的逻辑
也就是说无论哪种方式，调用的发送函数是一样的，只是低层处理流程不一样，这样我便可以在发送函数之前设置485发，发送完后设置485收。
但是看到这个代码我觉得在中断发送完成的回调函数里面设置485收发可能不可靠
，我看了rtt串口中现实的中断发送方式就是这样，但是不知道是受dma的代码影响还是怎么回事，中断发送好像跟中断联系不起来

```
static void uart_isr(struct rt_serial_device *serial)
{
    struct stm32_uart *uart;
#ifdef RT_SERIAL_USING_DMA
    rt_size_t recv_total_index, recv_len;
    rt_base_t level;
#endif

RT_ASSERT(serial != RT_NULL);
    uart = rt_container_of(serial, struct stm32_uart, serial);

/* UART in mode Receiver -------------------------------------------------*/
    if ((__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_RXNE) != RESET) &&
            (__HAL_UART_GET_IT_SOURCE(&(uart->handle), UART_IT_RXNE) != RESET))
    {
        rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_IND);
    }
#ifdef RT_SERIAL_USING_DMA
    else if ((uart->uart_dma_flag) && (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_IDLE) != RESET)
             && (__HAL_UART_GET_IT_SOURCE(&(uart->handle), UART_IT_IDLE) != RESET))
    {
        level = rt_hw_interrupt_disable();
        recv_total_index = serial->config.bufsz - __HAL_DMA_GET_COUNTER(&(uart->dma_rx.handle));
        recv_len = recv_total_index - uart->dma_rx.last_index;
        uart->dma_rx.last_index = recv_total_index;
        rt_hw_interrupt_enable(level);

if (recv_len)
        {
            rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_DMADONE | (recv_len << 8));
        }
        __HAL_UART_CLEAR_IDLEFLAG(&uart->handle);
    }
    else if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_TC) &&
            (__HAL_UART_GET_IT_SOURCE(&(uart->handle), UART_IT_TC) != RESET))
    {
        if ((serial->parent.open_flag & RT_DEVICE_FLAG_DMA_TX) != 0)
        {
            HAL_UART_IRQHandler(&(uart->handle));
        }
        UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_TC);
    }
#endif
    else
    {
        if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_ORE) != RESET)
        {
            __HAL_UART_CLEAR_OREFLAG(&uart->handle);
        }
        if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_NE) != RESET)
        {
            __HAL_UART_CLEAR_NEFLAG(&uart->handle);
        }
        if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_FE) != RESET)
        {
            __HAL_UART_CLEAR_FEFLAG(&uart->handle);
        }
        if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_PE) != RESET)
        {
            __HAL_UART_CLEAR_PEFLAG(&uart->handle);
        }
#if !defined(SOC_SERIES_STM32L4) && !defined(SOC_SERIES_STM32F7) && !defined(SOC_SERIES_STM32F0) \
    && !defined(SOC_SERIES_STM32L0) && !defined(SOC_SERIES_STM32G0) && !defined(SOC_SERIES_STM32H7) \
    && !defined(SOC_SERIES_STM32G4) && !defined(SOC_SERIES_STM32MP1) && !defined(SOC_SERIES_STM32WB)
        if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_LBD) != RESET)
        {
            UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_LBD);
        }
#endif
        if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_CTS) != RESET)
        {
            UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_CTS);
        }
        if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_TXE) != RESET)
        {
            UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_TXE);
        }
        if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_TC) != RESET)
        {
            UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_TC);
        }
        if (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_RXNE) != RESET)
        {
            UART_INSTANCE_CLEAR_FUNCTION(&(uart->handle), UART_FLAG_RXNE);
        }
    }
}
#ifdef RT_SERIAL_USING_DMA
static void dma_isr(struct rt_serial_device *serial)
{
    struct stm32_uart *uart;
    rt_size_t recv_total_index, recv_len;
    rt_base_t level;

RT_ASSERT(serial != RT_NULL);
    uart = rt_container_of(serial, struct stm32_uart, serial);

if ((__HAL_DMA_GET_IT_SOURCE(&(uart->dma_rx.handle), DMA_IT_TC) != RESET) ||
            (__HAL_DMA_GET_IT_SOURCE(&(uart->dma_rx.handle), DMA_IT_HT) != RESET))
    {
        level = rt_hw_interrupt_disable();
        recv_total_index = serial->config.bufsz - __HAL_DMA_GET_COUNTER(&(uart->dma_rx.handle));
        if (recv_total_index == 0)
        {
            recv_len = serial->config.bufsz - uart->dma_rx.last_index;
        }
        else
        {
            recv_len = recv_total_index - uart->dma_rx.last_index;
        }
        uart->dma_rx.last_index = recv_total_index;
        rt_hw_interrupt_enable(level);

if (recv_len)
        {
            rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_DMADONE | (recv_len << 8));
        }
    }
}
#endif

```