RT thread 设备驱动组件之USART设备

来源:互联网 发布:制作视频剪辑的软件 编辑:程序博客网 时间:2024/06/06 00:04

本文以stm32f4xx平台介绍串口驱动,主要目的是:1、RTT中如何编写中断处理程序;2、如何编写RTT设备驱动接口代码;3、了解串行设备的常见处理机制。所涉及的主要源码文件有:驱动框架文件(usart.c,usart.h),底层硬件驱动文件(serial.c,serial.h)。应用串口设备驱动时,需要在rtconfig.h中宏定义#define RT_USING_SERIAL。

一、RTT的设备驱动程序概述

      编写uart的驱动程序,首先需要了解RTT的设备框架,这里以usart的驱动来具体分析RTT的IO设备管理。注:参考《RTT实时操作系统编程指南》 I/O设备管理一章。

我们可以将USART的硬件驱动分成两个部分,如下图所示

  +----------------------+
  | rtt下的usart设备驱动     |
  |---------------------- |
  | usart硬件初始化代码      |
  |---------------------- |
  | usart 硬件                  |
  +----------------------+

      实际上,在缺乏操作系统的平台,即裸机平台上,我们通常只需要编写USART硬件初始化代码即可。而引入了RTOS,如RTT后,RTT中自带IO设备管理层,它是为了将各种各样的硬件设备封装成具有统一的接口的逻辑设备,以方便管理及使用。让我们从下向上看,先来看看USART硬件初始化程序,这部分代码位于usart.c和usart.h中。

二、USART硬件初始化

假如在接触RTT之前,你已经对stm32很熟悉了,那么此文件中定义的函数名一定让你倍感亲切。这里实现的函数有:

  • static void RCC_Configuration(void);

  • static void GPIO_Configuration(void);

  • static void NVIC_Configuration(void);

  • static void DMA_Configuration(void);

  • void stm32_hw_usart_init();

前四个函数,是跟ST官方固件库提供的示例代码的名字保持一致。这些函数内部也是直接调用官方库代码实现的。具体不再赘述。对STM32裸机开发不太熟悉的朋友,建议先去官方网站下载官方固件源码包,以及应用手册和示例程序,ST提供了大量的文档和示例代码,利用好这些资源可以极大地加快开发。

下面重点看一下 usart.c中stm32_hw_usart_init():

复制代码
int stm32_hw_usart_init(void){    struct stm32_uart *uart;    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;    RCC_Configuration();    GPIO_Configuration();#ifdef RT_USING_UART2    uart = &uart2;    serial2.ops    = &stm32_uart_ops;    serial2.config = config;    NVIC_Configuration(&uart2);    /* register UART2 device */    rt_hw_serial_register(&serial2,                          "uart2",                          RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX, //dev->flag (not dev->open_flag)                          uart);#endif /* RT_USING_UART2 */#ifdef RT_USING_UART3...#endif /* RT_USING_UART3 */    return 0;}//INIT_BOARD_EXPORT(stm32_hw_usart_init); //it must be invoked in board.c(rt_hw_board_init for setting CONSOLE_DEVICE)
复制代码

      首先该函数调用RCC_Configuration()和GPIO_Configuration()打开串口外设时钟和IO口配置;调用NVIC_Configuration(&uart2)设置串口中断,其中参数&uart2为一个自定义结构体类型:

/* STM32 uart driver */struct stm32_uart{    USART_TypeDef *uart_device;    IRQn_Type irq;};

      接着初始化设备类对象serial2中的ops和config两个参数,并在usart.c中实现了stm32_uart_ops中的四个函数。

复制代码
static const struct rt_uart_ops stm32_uart_ops ={    stm32_configure,    stm32_control,    stm32_putc,    stm32_getc,};
复制代码
struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;

      最后注册串口设备serial2,注册函数位于serial.c中:

/* register UART2 device */rt_hw_serial_register(&serial2,                       "uart2",                       RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX, //dev->flag (not dev->open_flag)                       uart);

      显然,函数 stm32_hw_usart_init(),顾名思义,是用于初始化USART硬件的函数,因此这个函数一定会在USART使用之前被调用。搜索工程发现,这个函数是在board.c中rt_hw_board_init函数中被调用,而rt_hw_board_init函数又是在startup.c里的 rtthread_startup函数中调用的。进一步在startup.c的main函数中调用的,我们将实际的路径调用过程绘制如下。

  startup.c main()  ---> startup.c rtthread_startup()  ---> board.c   rt_hw_board_init()   ---> usart.c   rt_hw_usart_init()

      到这里,USART硬件的初始化工作已经完成完成了99%,下一步,我们需要为USART编写代码,将其纳入到RTT的设备管理层之中,正如前面所说,这部分代码在serial.c中实现。我们来重点分析这一文件。

三、在RTT下使用USART,将USART纳入RTT的IO设备层中

      相对于stm32的内核来说,USART是一种低速的串行设备,并且为了最大的发挥的MCU的性能,因此使用查询方式发送、中断方式接收(发送也可以使用DMA方式)。这些已经在usart.c中使能了。首先看一些serial.h中的重要数据结构:

复制代码
/* * Serial FIFO mode  */struct rt_serial_rx_fifo{    /* software fifo */    rt_uint8_t *buffer;    rt_uint16_t put_index, get_index;};struct rt_serial_tx_fifo{    struct rt_completion completion;};/*  * Serial DMA mode */struct rt_serial_rx_dma{    rt_bool_t activated;};struct rt_serial_tx_dma{    rt_bool_t activated;    struct rt_data_queue data_queue;};struct rt_serial_device{    struct rt_device          parent;    const struct rt_uart_ops *ops;    struct serial_configure   config;    void *serial_rx;    void *serial_tx;};typedef struct rt_serial_device rt_serial_t;
复制代码
复制代码
/** * uart operators */struct rt_uart_ops{    rt_err_t (*configure)(struct rt_serial_device *serial, struct serial_configure *cfg);    rt_err_t (*control)(struct rt_serial_device *serial, int cmd, void *arg);    int (*putc)(struct rt_serial_device *serial, char c);    int (*getc)(struct rt_serial_device *serial);    rt_size_t (*dma_transmit)(struct rt_serial_device *serial, const rt_uint8_t *buf, rt_size_t size, int direction);};
复制代码

在serial.c中主要实现rtthread系统的IO设备统一接口函数,并注册串口设备:

复制代码
/* * serial register */rt_err_t rt_hw_serial_register(struct rt_serial_device *serial,                               const char              *name,                               rt_uint32_t              flag,                               void                    *data){    struct rt_device *device;    RT_ASSERT(serial != RT_NULL);    device = &(serial->parent);    device->type        = RT_Device_Class_Char;    device->rx_indicate = RT_NULL;    device->tx_complete = RT_NULL;    device->init        = rt_serial_init;    device->open        = rt_serial_open;    device->close       = rt_serial_close;    device->read        = rt_serial_read;    device->write       = rt_serial_write;    device->control     = rt_serial_control;    device->user_data   = data;    /* register a character device */    return rt_device_register(device, name, flag);}
复制代码

       对于串口发送数据,默认采用查询方式。因为串口设备注册的时候,其设备标志为RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,没有RT_DEVICE_FLAG_DMA_TX或RT_DEVICE_FLAG_INT_TX标志。 数据发送流程为:rt_device_write()-->rt_serial_write()-->_serial_poll_tx()-->stm32_putc()。

      考虑串口接受数据的情况,串口收到一个字节的数据,就会触发串口中断USARTx_IRQHandler,数据字节会存放于串口的硬件寄存器中。但是在RTOS中,通常存在多个线程,如果某个处理串口数据的线程在没有串口数据时阻塞,当下一串口数据到来时,如果该数据线程依然没有唤醒并启动,并读取串口字节,则上一个串口字节丢失了,因此这不是一个优良的设计,我们需要设计一种机制来解决这种潜在的问题。实际上,缓冲机制可以大大缓解这个问题。数据读取流程为:rt_device_read()-->rt_serial_read()-->rt_hw_serial_isr()-->stm32_getc()。

      所谓缓冲机制,简略的来说,即开辟一个缓冲区,可以是静态数组,也可以是malloc(或mempool)申请的动态缓冲区。在串口中断中,先从串口的硬件寄存器中读取数据,并保存到缓冲区中。这种情况下,我们需要两个变量,一个用于标记当前写入的位置,另外一个用来表示已经被处理的数据的位置。这样当数据处理线程阻塞时,连续收到的数据会保存到缓冲区中而避免了丢失。当中断中已经接收到了一些串口数据后,数据处理线程终于就绪,并开始处理数据,通常来说处理数据的速度必然比接受数据要快,因此这样就能解决前面所说的问题。聪明的读者发现了,还有一个小问题,缓冲区的长度必然是有限的,终归会有用到头的时候,那该怎么办呢?别担心,缓冲区前面已经被处理过的数据所占用的空间按自然可以重复使用,即,当接收指针指向了缓冲区末尾时,只要缓冲区头的数据已经被处理过了,自然可以直接将缓冲区指针从新设置为头,对于表示已处理的指针变量同理。这样这个缓冲区也就成为了一个环形缓冲区。

下面重点看一下中断函数:

复制代码
#if defined(RT_USING_UART2)/* UART2 device driver structure */struct stm32_uart uart2 ={    USART2,    USART2_IRQn,};struct rt_serial_device serial2;void USART2_IRQHandler(void){    struct stm32_uart *uart;    uart = &uart2;    /* enter interrupt */    rt_interrupt_enter();    if (USART_GetITStatus(uart->uart_device, USART_IT_RXNE) != RESET)    {        rt_hw_serial_isr(&serial2, RT_SERIAL_EVENT_RX_IND);//USART_IT_RXNE is cleared automatically by reading USART_DR in stm32_getc()    }    if (USART_GetITStatus(uart->uart_device, USART_IT_TC) != RESET)    {        /* clear interrupt */        USART_ClearITPendingBit(uart->uart_device, USART_IT_TC);    }    /* leave interrupt */    rt_interrupt_leave();}#endif /* RT_USING_UART2 */

该中断函数在usart.c中,在RTT下的每一个中断服务子程序的入口都调用了rt_interrupt_enter(),在中断函数的子程序的出口则调用了rt_interrupt_leave()。
复制代码
复制代码
/* ISR for serial interrupt */void rt_hw_serial_isr(struct rt_serial_device *serial, int event){    switch (event & 0xff)    {        case RT_SERIAL_EVENT_RX_IND:        {            int ch = -1;            rt_base_t level;            struct rt_serial_rx_fifo* rx_fifo;            rx_fifo = (struct rt_serial_rx_fifo*)serial->serial_rx;            RT_ASSERT(rx_fifo != RT_NULL);                        /* interrupt mode receive */            RT_ASSERT(serial->parent.open_flag & RT_DEVICE_FLAG_INT_RX);                        while (1)            {                ch = serial->ops->getc(serial);                if (ch == -1) break;                                /* disable interrupt */                level = rt_hw_interrupt_disable();                                rx_fifo->buffer[rx_fifo->put_index] = ch;                rx_fifo->put_index += 1;                if (rx_fifo->put_index >= serial->config.bufsz) rx_fifo->put_index = 0;                                /* if the next position is read index, discard this 'read char' */                if (rx_fifo->put_index == rx_fifo->get_index)                {                    rx_fifo->get_index += 1;                    if (rx_fifo->get_index >= serial->config.bufsz) rx_fifo->get_index = 0;                }                                /* enable interrupt */                rt_hw_interrupt_enable(level);            }                        /* invoke callback */            if (serial->parent.rx_indicate != RT_NULL)            {                rt_size_t rx_length;                            /* get rx length */                level = rt_hw_interrupt_disable();                rx_length = (rx_fifo->put_index >= rx_fifo->get_index)? (rx_fifo->put_index - rx_fifo->get_index):                    (serial->config.bufsz - (rx_fifo->get_index - rx_fifo->put_index));                rt_hw_interrupt_enable(level);                serial->parent.rx_indicate(&serial->parent, rx_length);            }            break;        }        case RT_SERIAL_EVENT_TX_DONE:        {            struct rt_serial_tx_fifo* tx_fifo;            tx_fifo = (struct rt_serial_tx_fifo*)serial->serial_tx;            rt_completion_done(&(tx_fifo->completion));            break;        }        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, 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;        }        case RT_SERIAL_EVENT_RX_DMADONE:        {            int length;            struct rt_serial_rx_dma* rx_dma;            rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx;            /* get DMA rx length */            length = (event & (~0xff)) >> 8;            serial->parent.rx_indicate(&(serial->parent), length);            rx_dma->activated = RT_FALSE;            break;        }    }}

该函数位于serial.c中,默认情况下usart的rt_device结构体中rx_indicate域被置空,因此不会运行这一段代码。如果使用rt_device_set_rx_indicate(rt_device_t dev, rt_err_t(* rx_ind)(rt_device_t dev, rt_size_t size))函数为一个串口设备注册了接收事件回调函数,在该串口接收到数据后,就会调用之前注册的rx_ind函数,将当前设备指针以及待读取的数据长度作为调用参数传递给用户。
复制代码
0 0