RT-Thread下的串口驱动程序分析

编写本文稿的目的，在于通过分析stm32平台上的串口中断源码，学习

• RTT中如何编写中断处理程序

• 如何编写RTT设备驱动接口代码

• 了解串行设备的常见处理机制

先以RTT官方源码中的STM32 BSP包来分析。rt-thread\bsp\stm32f10x 下,涉及的文件为：

1. usart.c

2. usart.h

3. serail.c

4. serail.h

RTT的设备驱动程序概述

编写uart的驱动程序，首先需要了解RTT的设备框架，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 rt_hw_usart_init();

前四个函数，是跟ST官方固件库提供的示例代码的名字保持一致。这些函数内部也是直接调用官方库代码实现的。具体不再赘述。

对STM32裸机开发尚不太熟悉的朋友，建议先去官方网站下载官方固件源码包，以及应用手册和示例程序，ST提供了大量的文档和示例代码，利用好这些资源可以极大地加快开发。

现在来重点关注一下最后一个函数，即 rt_hw_usart_init函数的实现。

/*
 * Init all related hardware in here
 * rt_hw_serial_init() will register all supported USART device
 */
void rt_hw_usart_init()
{
	USART_InitTypeDef USART_InitStructure;
	USART_ClockInitTypeDef USART_ClockInitStructure;   RCC_Configuration();   GPIO_Configuration();   NVIC_Configuration();   DMA_Configuration();   /* uart init */
#ifdef RT_USING_UART1
	USART_InitStructure.USART_BaudRate = 115200;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;
	USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;
	USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;
	USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;
	USART_Init(USART1, &USART_InitStructure);
	USART_ClockInit(USART1, &USART_ClockInitStructure);   /* register uart1 */
	rt_hw_serial_register(&uart1_device, "uart1",
		RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
		&uart1);   /* enable interrupt */
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
#endif   #ifdef RT_USING_UART2
....
#endif   #ifdef RT_USING_UART3
....
#endif
}

上述代码中，大部分代码都是调用ST库函数，请注意下列语句。

	/* register uart1 */
	rt_hw_serial_register(&uart1_device, "uart1",
		RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
		&uart1);

这个函数的实现位于serial.c中，我们将在下一小节分析，暂且不表。

显然，函数rt_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设备层中

RTT IO设备驱动简介

要想将某个设备纳入到RTT的IO设备层中，需要为这个设备创建一个名为rt_device的数据结构。该数据结构在rtdef.h中定义。

/**
 * Device structure
 */
struct rt_device
{
    struct rt_object parent;                        /**< inherit from rt_object                     */   enum rt_device_class_type type;                 /**< device type                                */
    rt_uint16_t flag, open_flag;                    /**< device flag and device open flag           */   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);   /* 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, rt_uint8_t cmd, void *args);   #ifdef RT_USING_DEVICE_SUSPEND   rt_err_t (*suspend) (rt_device_t dev);
    rt_err_t (*resumed) (rt_device_t dev);
#endif   void *user_data;                                /**< device private data                        */
};

对这个数据结构做一些详细的说明。

• struct rt_object parent;这个域是RTT的所谓的面向对象设计，跟我们关系不大。

• type域配合前面的parent域，来制定设备的类型，也与我们关系不大。

• flag和openflag用来存储设备的权限，比如是只读，还是读写等等。

• device_id即设备号，每一个设备都拥有唯一的编号，内核可以根据这个编号查找到设备。

接下来就是定义了一组函数指针，用于操作这个设备的一些回调（callback）函数。他们分别是：

  rx_indicate
  tx_complete
  init
  open
  close
  read
  write
  control

以及一个指针变量，由用户根据实际需要填充

  void *user_data;  

如果在rtconfig.h中使能了RT_USING_DEVICE_SUSPEND宏，还会增加两个函数

  rt_err_t (*suspend) (rt_device_t dev);
  rt_err_t (*resumed) (rt_device_t dev);

这些域并不一定全部填充，后面我们会看到对于有些函数，可以为其填充一个空函数。

RTT的设备管理，可以简单的概括为：每一个设备都会用于一个rt_device数据结构，这些数据结构通过某种方式组织起来，每个数据结构都会有一个唯一的device_id，以及一组硬件操作函数等等。这样硬件就被抽象成统一的逻辑设备了，即rt_device。

还有一个小问题，device_id是纯粹的数字，所以难以记忆，因此RTT中为其分配一个ascii码字符串来以方便是使用，比如将字符串”uart”和usart的rt_device数据结构关联起来，这和网络里，ip地址不好记忆，因此使用域名系统是一个道理。

那么自然而然，我们需要一些函数来操作逻辑设备，这些函数在rt-thread/src/device.c文件中提供，它们是：

• rt_err_t rt_device_register(rt_device_t dev, const char *name, rt_uint16_t flags)

• 将rt_device数据结构加入到RTT的设备层中，这个过程称为“注册”。RTT的设备管理层会为这个数据结构创建唯一的device_id。

• rt_err_t rt_device_unregister(rt_device_t dev)

  • 与注册相反，自然是注销了，将某个设备从RTT的设备驱动层中移除。

• rt_device_t rt_device_find(const char *name)

  • 根据设备的字符串名查找某个设备。

• rt_err_t rt_device_init(rt_device_t dev)

  • 通过调用rt_device数据结构中的init函数来初始设备。

• rt_err_t rt_device_init_all(void)

  • 初始化RTT设备管理层中的所有已注册的设备

• rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflag)

  • 通过调用rt_device数据结构中的open函数来打开设备。

• rt_err_t rt_device_close(rt_device_t dev)

  • 通过调用rt_device数据结构中的close函数来关闭设备。

• rt_size_t rt_device_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)

  • 通过调用rt_device数据结构中的read函数来从设备上读取数据。

• rt_size_t rt_device_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)

  • 通过调用rt_device数据结构中的write函数来向设备写入数据（比如设备是flash，SD卡等，nand or nor flash等等）。

说明：关于这些函数各个参数的作用，建议参考官方提供的API文档。http://www.rt-thread.org/rt-thread/rttdoc_1_0_0/group___device.html

分析USART下的RTT设备驱动源码

相对于stm32的内核来说，USART是一种低速的串行设备，并且为了最大的发挥的MCU的性能，因此使用中断方式实现接收（发送也可以使用DMA方式）。这些已经在usart.c中使能了。

串口接收情况

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

所谓缓冲机制，简略的来说，即开辟一个缓冲区，可以是静态数组，也可以是malloc（或mempool）申请的动态缓冲区。在串口中断中，先从串口的硬件寄存器中读取数据，并保存到缓冲区中。这种情况下，我们需要两个变量，一个用于标记当前写入的位置，另外一个用来表示已经被处理的数据的位置。这样当数据处理线程阻塞时，连续收到的数据会保存到缓冲区中而避免了丢失。当中断中已经接收到了一些串口数据后，数据处理线程终于就绪，并开始处理数据，通常来说处理数据的速度必然比接受到的数据要快，因此这样就能解决前面所说的问题。

【图】

聪明的读者发现了，还有一个小问题，缓冲区的长度必然是有限的，终归会有用到头的时候，那该怎么办呢？别担心，缓冲区前面已经被处理过的数据所占用的空间按自然可以重复使用，即，当接收指针指向了缓冲区末尾时，只要缓冲区头的数据已经被处理过了，自然可以直接将缓冲区指针从新设置为头，对于表示已处理的指针变量同理。这样这个缓冲区也就成为了一个环形缓冲区。

关于环形缓冲区，可以参考：http://www.rt-thread.org/dokuwiki/doku.php?id=rt-thread%E4%B8%80%E8%88%AC%E6%80%A7%E9%97%AE%E9%A2%98

串口发送情况

RTT在stm32的串口发送上，为了最大限度的发挥硬件的效能，使用了DMA来实现自动发送。同接收类似，也使用了缓冲机制。不过因为涉及的DMA，这个机制实现稍微复杂，我们将在稍后做分析。

源码分析

先来看看一些重要数据结构，它们在serial.h中定义：

/* STM32F10x library definitions */
#include <stm32f10x.h>   #define UART_RX_BUFFER_SIZE		64
#define UART_TX_DMA_NODE_SIZE	4   /* data node for Tx Mode */
struct stm32_serial_data_node
{
	rt_uint8_t *data_ptr;
	rt_size_t  data_size;
	struct stm32_serial_data_node *next, *prev;
};
struct stm32_serial_dma_tx
{
	/* DMA Channel */
	DMA_Channel_TypeDef* dma_channel;   /* data list head and tail */
	struct stm32_serial_data_node *list_head, *list_tail;   /* data node memory pool */
	struct rt_mempool data_node_mp;
	rt_uint8_t data_node_mem_pool[UART_TX_DMA_NODE_SIZE *
		(sizeof(struct stm32_serial_data_node) + sizeof(void*))];
};   struct stm32_serial_int_rx
{
	rt_uint8_t  rx_buffer[UART_RX_BUFFER_SIZE];
	rt_uint32_t read_index, save_index;
};   struct stm32_serial_device
{
	USART_TypeDef* uart_device;   /* rx structure */
	struct stm32_serial_int_rx* int_rx;   /* tx structure */
	struct stm32_serial_dma_tx* dma_tx;
};

可以看到，对于stm32的串行设备，抽象为一个专门的数据结构 struct stm32_serial_device uart_device域将用来填充具体的硬件USART指针，在stm32系列芯片上，可能存在USART1到USART3多个硬件USART。

int_rx是一个专门的用于处理接受数据的数据结构指针。dma_tx同理，关于它们的具体定义都在前面的代码中。

struct stm32_serial_int_rx {

rt_uint8_t  rx_buffer[UART_RX_BUFFER_SIZE];
rt_uint32_t read_index, save_index;

}; 可以看到，跟上一小节说明类似，这里定义了一个名为rx_buffer的缓冲区，并且定义了两个变量read_index表示已经读取（即已被处理）的索引，而save_index，则表示下一个可以用于存储接受数据的索引。

接下来，让我们深入代码，来看看究竟是如何处理的：首先来看看USART1_IRQHandler(void)的源码，位于stm32f10x_it.c中

void USART1_IRQHandler(void)
{
#ifdef RT_USING_UART1
    extern struct rt_device uart1_device;
	extern void rt_hw_serial_isr(struct rt_device *device);   /* enter interrupt */
    rt_interrupt_enter();   rt_hw_serial_isr(&uart1_device);   /* leave interrupt */
    rt_interrupt_leave();
#endif
}

在RTT下的每一个中断服务子程序的入口都调用了

rt_interrupt_enter();

在中断函数的子程序的出口则调用了

rt_interrupt_leave();

中间的函数 rt_hw_serial_isr，来重点关注一下：

/* ISR for serial interrupt */
void rt_hw_serial_isr(rt_device_t device)
{
	struct stm32_serial_device* uart = (struct stm32_serial_device*) device->user_data;   if(USART_GetITStatus(uart->uart_device, USART_IT_RXNE) != RESET)
        //判断标志位，判断是否是能了接受中断
	{
		/* interrupt mode receive */
		RT_ASSERT(device->flag & RT_DEVICE_FLAG_INT_RX);   /* save on rx buffer */
		while (uart->uart_device->SR & USART_FLAG_RXNE)
            //从datasheet上查到，SR的RXNE标志位表示确实接收到了字节
		{
			rt_base_t level;   /* disable interrupt */
            //暂时关闭中断，因为要操作uart数据结构
			level = rt_hw_interrupt_disable();   /* save character */
			uart->int_rx->rx_buffer[uart->int_rx->save_index] = uart->uart_device->DR & 0xff;
			uart->int_rx->save_index ++;
		    //下面的代码检查save_index是否已经到到缓冲区尾部，如果是则回转到头部，称为一个环形缓冲区	
			if (uart->int_rx->save_index >= UART_RX_BUFFER_SIZE)
				uart->int_rx->save_index = 0;   //这种情况表示反转后的save_index追上了read_index，则增大read_index，丢弃一个旧的数据
			/* if the next position is read index, discard this 'read char' */
			if (uart->int_rx->save_index == uart->int_rx->read_index)
			{
				uart->int_rx->read_index ++;
				if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE)
					uart->int_rx->read_index = 0;
			}   /* enable interrupt */
			//uart数据结构已经操作完成，重新使能中断
			rt_hw_interrupt_enable(level);
		}   /* clear interrupt */
		USART_ClearITPendingBit(uart->uart_device, USART_IT_RXNE);   /* invoke callback */
		if (device->rx_indicate != RT_NULL)
		{
			rt_size_t rx_length;   /* get rx length */
			rx_length = uart->int_rx->read_index > uart->int_rx->save_index ?
				UART_RX_BUFFER_SIZE - uart->int_rx->read_index + uart->int_rx->save_index :
				uart->int_rx->save_index - uart->int_rx->read_index;   device->rx_indicate(device, rx_length);
		}
	}   if (USART_GetITStatus(uart->uart_device, USART_IT_TC) != RESET)
	{
		/* clear interrupt */
		USART_ClearITPendingBit(uart->uart_device, USART_IT_TC);
	}
}

这里来重点说明一下下面代码的作用。【绘制图形，待添加】

        //这种情况表示反转后的save_index追上了read_index，则增大read_index，丢弃一个旧的数据
        /* if the next position is read index, discard this 'read char' */
        if (uart->int_rx->save_index == uart->int_rx->read_index)
        {
            uart->int_rx->read_index ++;
            if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE)
                uart->int_rx->read_index = 0;
        }

这段代码又是做什么用的呢？

    /* invoke callback */
    if (device->rx_indicate != RT_NULL)
    {
        rt_size_t rx_length;   /* get rx length */
        rx_length = uart->int_rx->read_index > uart->int_rx->save_index ?
            UART_RX_BUFFER_SIZE - uart->int_rx->read_index + uart->int_rx->save_index :
            uart->int_rx->save_index - uart->int_rx->read_index;   device->rx_indicate(device, rx_length);
    }

默认情况下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函数，将当前设备指针以及待读取的数据长度作为调用参数传递给用户

编写设备函数，open，close等等

分析完毕中断处理程序，接下来我们要分析rt_devcie数据结构中，open，read等函数的编写。

init

init函数完成对设备数据结构的初始化工作。 RTT的设备驱动存在大量的预定义宏，它们在rtdef.h中定义。

(1)接收/发送模式，似乎共有三种，分别是中断模式，DMA模式和轮询模式。在serial.c中，对于接收，只支持中断模式，和轮询模式。对于发送，只支持轮询发送模式和DMA发送模式。

|------+----------------+----------------+---------|
|      | FLAG_INT_RX/TX | FLAG_DMA_RX/TX | polling |
|------+----------------+----------------+---------|
| 发送 | Yes            | no             | yes     |
|------+----------------+----------------+---------|
| 接受 | no             | yes            | yes     |
|------+----------------+----------------+---------|

(2)设备权限分为只读，只写和读写三种，分别由 RT_DEVICE_FLAG_RDONLY 只读 RT_DEVICE_FLAG_WRONLY 只写 RT_DEVICE_FLAG_RDWR 读写

(3)设备当前状态 RT_DEVICE_FLAG_REMOVABLE 可移除设备 RT_DEVICE_FLAG_STANDALONE 啥意思？？？ RT_DEVICE_FLAG_ACTIVATED 设备处于活动状态，表示设备已经被init过了 RT_DEVICE_FLAG_SUSPENDED 设备当前被挂起 RT_DEVICE_FLAG_STREAM 设备处于流模式（到底啥意思？–字符串模式，发送数据时会在'\n'前自动添加一个'\r'）

注意，上面描述的这么多状态，在一个设备驱动中并非全部都需要予以支持。这需要根据自驱动的实际情况实现。

先来看init函数，如下所示：

static rt_err_t rt_serial_init (rt_device_t dev)
{
	struct stm32_serial_device* uart = (struct stm32_serial_device*) dev->user_data;   if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED))
	{
		if (dev->flag & RT_DEVICE_FLAG_INT_RX)
		{
			rt_memset(uart->int_rx->rx_buffer, 0,
				sizeof(uart->int_rx->rx_buffer));
			uart->int_rx->read_index = 0;
			uart->int_rx->save_index = 0;
		}
        ......   /* Enable USART */
		USART_Cmd(uart->uart_device, ENABLE);   dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
	}   return RT_EOK;
}
开始时，设备的dev->flag域全是0，即为非激活模式，如果RX为INT_RX,模式，可以看到即简单的将uart->int_rx全部清0。

open

因为在usart.c中已经初始usart设备，然后init中通过USART_Cmd语句后，串口就会开始工作。因此open函数设置为空即可

close

同colse，之间置空即可

read

static rt_size_t rt_serial_read (rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)

pos表示读写的位置，buffer是用于存储读取到数据的缓冲区。size为字节数目。对于USART这种串行的流设备来说，pos没有意义，因此这里的pos没有意义。 rt_device数据结构dev的的 user_data域存放了(struct stm32_serial_device*)型指针。【待修改】如果采用INT_RX模式，即中断接受模式，则主体代码为

		while (size)
		{
			rt_base_t level;   /* disable interrupt */
			level = rt_hw_interrupt_disable();   if (uart->int_rx->read_index != uart->int_rx->save_index)
			{
				/* read a character */
				*ptr++ = uart->int_rx->rx_buffer[uart->int_rx->read_index];
				size--;   /* move to next position */
				uart->int_rx->read_index ++;
				if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE)
					uart->int_rx->read_index = 0;
			}
			else
			{
				/* set error code */
				err_code = -RT_EEMPTY;   /* enable interrupt */
				rt_hw_interrupt_enable(level);
				break;
			}   /* enable interrupt */
			rt_hw_interrupt_enable(level);
		}   </code c>
上述代码很容易理解，不再赘述。   如果采用查询模式，则主体代码为：
<code c>
		/* polling mode */
		while ((rt_uint32_t)ptr - (rt_uint32_t)buffer < size)
		{
			while (uart->uart_device->SR & USART_FLAG_RXNE)
			{
				*ptr = uart->uart_device->DR & 0xff;
				ptr ++;
			}
		}

这个函数返回实际读到的数据数目。

write

向串口写入数据，即发送数据。

(1) INT_TX模式，则报错

		/* interrupt mode Tx, does not support */
		RT_ASSERT(0);

(2) DMA模式

写操作处理部分：

if (dev->flag & RT_DEVICE_FLAG_DMA_TX)
{
	/* DMA mode Tx */   /* allocate a data node */
	struct stm32_serial_data_node* data_node = (struct stm32_serial_data_node*)
		rt_mp_alloc (&(uart->dma_tx->data_node_mp), RT_WAITING_FOREVER);
	if (data_node == RT_NULL)
	{
		/* set error code */
		err_code = -RT_ENOMEM;
	}
	else
	{
		rt_uint32_t level;   /* fill data node */
		data_node->data_ptr 	= ptr;
		data_node->data_size 	= size;   /* insert to data link */
		data_node->next = RT_NULL;   /* disable interrupt */
		level = rt_hw_interrupt_disable();   data_node->prev = uart->dma_tx->list_tail;
		if (uart->dma_tx->list_tail != RT_NULL)
			uart->dma_tx->list_tail->next = data_node;
		uart->dma_tx->list_tail = data_node;   if (uart->dma_tx->list_head == RT_NULL)
		{
			/* start DMA to transmit data */
			uart->dma_tx->list_head = data_node;   /* Enable DMA Channel */
			rt_serial_enable_dma(uart->dma_tx->dma_channel,
				(rt_uint32_t)uart->dma_tx->list_head->data_ptr,
				uart->dma_tx->list_head->data_size);
		}   /* enable interrupt */
		rt_hw_interrupt_enable(level);
	}
}

在DMA发送模式下，uart驱动将为每次写操作分配一个data_node数据节点，将本次写入的数据指针地址、长度写入此节点，并其插入到uart→dma_tx链表尾部，等待DMA中断处理此节点。

若判断到当前发送链表头为空时

uart->dma_tx->list_head == RT_NULL

说明没有正在进行的DMA活动，则将新加入的节点设置为链表头，启动DMA，开始发送数据。

(3)轮询模式

		/* polling mode */
		if (dev->flag & RT_DEVICE_FLAG_STREAM)
		{
			/* stream mode */
			while (size)
			{
				if (*ptr == '\n')
				{
					while (!(uart->uart_device->SR & USART_FLAG_TXE));
					uart->uart_device->DR = '\r';
		/* interrupt mode Tx, does not support */
		RT_ASSERT(0);
				}   while (!(uart->uart_device->SR & USART_FLAG_TXE));
				uart->uart_device->DR = (*ptr & 0x1FF);   ++ptr; --size;
			}
		}
		else
		{
			/* write data directly */
			while (size)
			{
				while (!(uart->uart_device->SR & USART_FLAG_TXE));
				uart->uart_device->DR = (*ptr & 0x1FF);   ++ptr; --size;
			}
		}

从上面的代码可以看到，所谓的STREAM模式，即在字符串中遇到\n换行，则自动插入\r回车符。

control

static rt_err_t rt_serial_control (rt_device_t dev, rt_uint8_t cmd, void *args)
{
	struct stm32_serial_device* uart;   RT_ASSERT(dev != RT_NULL);   uart = (struct stm32_serial_device*)dev->user_data;
	switch (cmd)
	{
	case RT_DEVICE_CTRL_SUSPEND:
		/* suspend device */
		dev->flag |= RT_DEVICE_FLAG_SUSPENDED;
		USART_Cmd(uart->uart_device, DISABLE);
		break;   case RT_DEVICE_CTRL_RESUME:
		/* resume device */
		dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED;
		USART_Cmd(uart->uart_device, ENABLE);
		break;
	}   return RT_EOK;
}

这个函数非常容易懂，不再赘述。

注册USART的rt_device结构

rt_err_t rt_hw_serial_register(rt_device_t device, const char* name, rt_uint32_t flag, struct stm32_serial_device *serial)
{
	RT_ASSERT(device != RT_NULL);   if ((flag & RT_DEVICE_FLAG_DMA_RX) ||
		(flag & RT_DEVICE_FLAG_INT_TX))
	{
		RT_ASSERT(0);
	}   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	= serial;   /* register a character device */
	return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag);
}

上面的函数也同样利于理解，只是简单的填充device数据结构。需要注意两个地方。

device->user_data	= serial; 

user_data域用于存储struct stm32_serial_device *serial

最后调用rt_device_register函数将rt_device注册到RTT的设备层中，所有的设备将形成一个链表。