怎样去使用stm32f429的串口驱动模块呢

写在开头：这段时间在整理modbus协议时，发现没有一个比较方便使用的串口模块，因此结合之前的一些理解，将串口驱动整理出来。此串口驱动有以下特点：


发送接收均使用 DMA

• 串口配置不需要从刷固件便能修改，方便二次开发
  
  
• 数据接收有环形队列缓存，能接收不定长数据帧
  
  
• 使用读缓存函数能获取当前缓存帧数以及每帧的数据长度.
  
  
  
  
  
  

说明：
发送 ：数据在发送过程中，首先被压入缓存，发送计时器会严格控制每条数据的发送时间间隔，发送使用DMA,以减轻CPU的负荷。
接收 ：数据接收能实现不定长度接收，首先每帧数据都会通过DMA转移到接收缓存中，在每一帧数据到来时，会产生DMA空闲中断，此时会将数据帧的长度存入帧长度缓存。通过帧长度缓存，能够建立接收缓存中每一帧数据的索引，以及能得出缓存中剩余数据帧的个数。因此，在从缓存取出数据时，操作方便，避免程序主循环运行周期导致数据帧取出时周期不固定（这一点后面详细讨论）。
二 .软件实现
硬件平台为stm32f429，移植到其他平台只需要将初始化改此对应平台即可。
1.初始化
串口初始化一般分为以下步骤：1.时钟初始化；2.端口初始化； 3.DMA初始化；4.中断初始化。因此建立一个串口类型结构体SERIAL_INIT_TYPE。在使用串口时，定义相应串口号结构体变量，初始化时赋初值完成串口初始化。多数人习惯使用宏定义，对串口的每个引脚，波特率等使用宏定义，然后串口的打开使用宏开关，实现最大程度的消除重复代码。以定义变量的方式来操作同样是为了消除重复代码，但更为重要的一点是，参数灵活性得到提高。既然是变量，值是受控的，因此设备在运行过程中可以通过软件更改端口参数。在很多产品中，都会附带一个上位机软件，以来改变设备的配置（伺服驱动器等），驱动器本身的固件是不变的，属于“一次开发”，而上位机软件属于二次开发，目的是为了适当调整参数，令设备达到最优运行状态。宏定义虽然能减少代码量，但这种预编译处理产生的软件功能限制较死，每次增添功能需要重新刷固件。因此，二次开发也是本文强调的重点。
以下是结构体成员：
以下是结构体成员：

以下是结构体成员：
typedef struct
{
struct
{
/*有关时钟的配置项*/
}rcc_cfg;
struct
{
/*有关串口的配置项*/
}port_cfg;
struct
{
/*有关DMA的配置*/
}dma_cfg;
struct
{
/*有关中断的配置*/
}nvic_cfg;
}SERIAL_INIT_TYPE;

下面分别介绍四个内嵌结构体成员，分别是时钟结构体，串口结构体，dma结构体，中断结构体。
a.时钟结构体


struct /*rcc */
{
uint32_t rxPORT; /*Port_RCC*/
uint32_t txPORT;
uint32_t USART; /*USART_RCC*/
uint32_t rxDMA; /*DMA_RCC*/
uint32_t txDMA;
}rcc_cfg;

串口相关的时钟一般为引脚时钟，串口时钟，dma时钟，这个需要查找硬件手册以确定其值。
b.串口结构体

struct /*port*/
{
uint32_t baud; /*波特率*/
USART_TypeDef* USARTx; /*串口号*/
GPIO_TypeDef* rxPORT; /*串口接收引脚端口号*/
GPIO_TypeDef* txPORT; /*串口发送引脚端口号*/
uint16_t rxPIN; /*串口接收引脚引脚号*/
uint16_t txPIN; /*串口发送引脚引脚号*/
uint8_t rxAF; /*接收引脚复用*/
uint8_t txAF; /*发送引脚复用*/
uint8_t rxSOURCE; /*接收源*/
uint8_t txSOURCE; /*发送源*/
}port_cfg;

c.dma结构体

struct /*dma*/
{
uint32_t rxCHANNEL; /*接收通道*/
uint32_t txCHANNEL; /*发送通道*/
uint32_t txFLAG; /*发送完成标志*/
DMA_Stream_TypeDef* rxSTREAM ; /*接收dma数据流*/
DMA_Stream_TypeDef* txSTREAM ; /*发送dma数据流*/
USART_TypeDef* USARTx; /*串口号*/
uint8_t rxbuff[FIFO_SIZE]; /*接收缓存*/
uint8_t txbuff[FIFO_SIZE]; /*发送缓存*/
uint8_t fifo_record[FRAME_SIZE]; /*接收帧长度缓存*/
uint16_t record_point; /*帧长度缓存指针*/
uint16_t length; /*缓存长度*/
uint16_t tail; /*缓存尾指针*/
uint16_t head; /*缓存头指针*/

}dma_cfg;

d.中断结构体

struct /*nvic*/
{
uint8_t usart_channel; /*串口中断通道*/
uint8_t usart_Preemption; /*抢占优先级*/
uint8_t usart_Sub; /*从优先级*/

uint8_t dma_txchannel; /*dma中断通道*/
uint8_t dma_txPreemption; /*抢占优先级*/
uint8_t dma_txSub; /*从优先级*/
}nvic_cfg;

以下是初始化串口1示例：


SERIAL_INIT_TYPE usart1=
{ .rcc_cfg.USART = RCC_APB2Periph_USART1, /*时钟*/
. rcc_cfg.rxPORT = RCC_AHB1Periph_GPIOA,
.rcc_cfg.txPORT = RCC_AHB1Periph_GPIOA,
.rcc_cfg.rxDMA = RCC_AHB1Periph_DMA2,
.rcc_cfg.txDMA = RCC_AHB1Periph_DMA2,
.port_cfg.USARTx = USART1, /*串口*/
.port_cfg.baud = 115200,
.port_cfg.rxPORT = GPIOA,
.port_cfg.txPORT = GPIOA,
.port_cfg.rxPIN = GPIO_Pin_10,
.port_cfg.txPIN = GPIO_Pin_9,
.port_cfg.rxAF = GPIO_AF_USART1,
.port_cfg.txAF = GPIO_AF_USART1,
.port_cfg.rxSOURCE = GPIO_PinSource10,
.port_cfg.txSOURCE = GPIO_PinSource9,
.dma_cfg.USARTx = USART1, /*dma*/
.dma_cfg.rxCHANNEL = DMA_Channel_4,
.dma_cfg.txCHANNEL = DMA_Channel_4,
.dma_cfg.txSTREAM = DMA2_Stream7,
.dma_cfg.rxSTREAM = DMA2_Stream5,
.dma_cfg.txFLAG = DMA_FLAG_TCIF4,
.dma_cfg.head = 0,
.dma_cfg.tail = 0,
.dma_cfg.length = FIFO_SIZE,
.nvic_cfg.usart_channel = USART1_IRQn, /*中断*/
.nvic_cfg.usart_Preemption = 0,
.nvic_cfg.usart_Sub = 1,
.nvic_cfg.dma_txchannel = DMA2_Stream7_IRQn,
.nvic_cfg.dma_txPreemption = 0,
.nvic_cfg.dma_txSub = 2
};

定义以以上串口描述结构体，之后构建初始化函数，初始化时，只需要将以上变量传入初始化函数，即可完成不同串口的初始化。


初始化函数和串口类型结构体相对应，4个块分别初始化。


void usart_config(SERIAL_INIT_TYPE* usart)
{
usart_rcc_cfg(usart);
usart_nvic_cfg(usart);
usart_dma_cfg(usart);
usart_port_cfg(usart);
}

具体的初始化过程详细见源码。


2.数据发送


初始化完成后，dma发送控制已经设置为指定数据地址（txbuff【】）内容到串口，此时只需要要将数据放进发送缓存中，启动dma发送，数据就能发送出去。


注意：在使用DMA发送时，遇到一个问题，数据只能发送一帧。产生的原因为：dma发送完成后，发送完成标志位被置一，即使在不使能发送中断的情况下，完成标志位也会影响下一帧数据的发送，因此这里使能发送中断，发送完成将标志位清零。


void DMA1_Stream6_IRQHandler(void) /*dma发送中断*/
{
if(DMA_GetFlagStatus(DMA1_Stream6,DMA_FLAG_TCIF6)!=RESET)
{
DMA_ClearFlag(DMA1_Stream6,DMA_FLAG_TCIF6);
}
}

static void start_dma(SERIAL_INIT_TYPE* usart,u16 ndtr) //启动dma
{
/*使能DMA*/
DMA_Cmd(usart->dma_cfg.txSTREAM, DISABLE);
while(DMA_GetFlagStatus(usart->dma_cfg.txSTREAM,usart->dma_cfg.txFLAG) != DISABLE){}
DMA_SetCurrDataCounter(usart->dma_cfg.txSTREAM,ndtr);
/* USART1 向 DMA发出TX请求 */
/*使能DMA*/
DMA_Cmd(usart->dma_cfg.txSTREAM, ENABLE);
}

由于这里对发送时序没有严格要求，因此一启动dma数据立即会发送，但对时序有严格要求的系统，比如某些传感器会有最高频率限制要求，这时就需要加入发送计时器，以一定周期来发送，适应外部低速设备。


3.数据接收


串口接收数据我们知道会经常用到两种中断：字节中断和帧中断。一个是每接收到一个字节的数据便产生一次中断，另一个是接收到一帧数据后产生中断。使用这两种方式配合，便能实现，串口简单的接收处理，只不过接收是实时的。在接收数据处理不及时的情况下，容易出现丢包情况。


环形缓存：


在通讯设备中经常听到缓存一词，缓存是避免丢包的有效措施。关于环形缓存的概念，这里不提及，百度有详细的介绍。以下是环形队列的实现方法:


a .创建队列结构体


#define FIFO_MAX_LEN 200
typedef struct
{
uint16_t head; //队列头
uint16_t tail; //队列尾
uint16_t len; //当前队列数据长度
uint8_t buff[FIFO_MAX_LEN]; //队列数组
}u8FIFO_TYPE;

b.队列初始化


void fifo_init(pu8FIFO_TYPE fifo)
{
fifo->head=0;
fifo->tail=0;
fifo->len=0;
}

c.队列判断空满


bool is_fifo_empty(pu8FIFO_TYPE fifo)
{
if(fifo->head==fifo->tail && !fifo->len) /*头尾相等，长度为0为空*/
return 1;
else
return 0;
}
/*判满*/
bool is_fifo_full(pu8FIFO_TYPE fifo)
{
if(fifo->len>=FIFO_MAX_LEN) /*长度大于等于最大容量为满*/
return 1;
else
return 0;
}

d.存数据与取数据

/*数据压入缓存*/
bool push_to_fifo(pu8FIFO_TYPE fifo , uint8_t data)
{
if( ! is_fifo_full(fifo))
{
fifo->buff[fifo->tail]=data;
fifo->len++;
/*存入一个字节，尾指针加一当到达最大长度，将尾指针指向0，
以此达到头尾相连的环形缓存区*/
fifo->tail=(fifo->tail+1) % FIFO_MAX_LEN;
return 1;
}
else
return 0;
}

/*缓存数据弹出*/
bool pop_from_fifo(pu8FIFO_TYPE fifo,uint8_t* data)
{
*data = fifo->buff[fifo->head]; /*取出一个字节数据*/
/*头指针加1，到达最大值清零，构建环形队列*/
fifo->head=(fifo->head+1) % FIFO_MAX_LEN;
if(!fifo->len)
{
fifo->len--;
return 1;
}
else
return 0;
}

以上为环形队列的实现，我们可以将压入数据进缓存发在串口中断接收中，每接收到一个数据，便存入缓存，在应用函数中调用缓存数据弹出函数，一个字节一个直接的取出数据。
在stm32 DMA中，接收DMA能够自动构建环形缓存区，类似上面fifo->tail=(fifo->tail+1) % FIFO_MAX_LEN; 实现方式。通过配置DMA初始化结构体成员：DMA_InitStructure.DMA_Mode = DMA_Mode_Circular; 初始化完成后，用户只需要DMA_GetCurrDataCounter函数，便能获取当前缓存剩余容量，也就是队尾tail可以用以下公式获得：tail = MAX_LEN - DMA_GetCurrDataCounter();以上，实现了串口DMA接收数据，
由缓存区取单字节数据。
可以看出，每次只能从缓存取出一个字节的数据，也就是说每循环一次取一个数据。因此，取数据是和主循环周期相关的。如果我们能知道缓存中数据帧的长度即数量，那么我们就能一次取出一帧的数据。能实现这种，不定长数据接收自然也解决了。下面实现不定长度的接收。
4.不定长度数据接收





程序实现：
a.串口空闲中断函数


void USART1_IRQHandler(void)
{
u16 data;
static uint16_t count=0;
static uint16_t last_tail=0;
if(USART_GetITStatus(USART1,USART_IT_IDLE) != RESET) /*空闲中断*/
{
data = USART1->SR;
data = USART1->DR; /*清除中断标志*/
/*计算缓存尾指针*/
usart1.dma_cfg.tail=MAX_LEN - DMA_GetCurrDataCounter(usart1.dma_cfg.rREAM);
/*尾指针由经过环形交接处*/
if(usart1.dma_cfg.tail< last_tail)
usart1.dma_cfg.fifo_record[count] =FRAME_SIZE -last_tail + usart1.dma_cfg.tail;
else
usart1.dma_cfg.fifo_record[count]= usart1.dma_cfg.tail-last_tail;
/*将计算的帧长度存入缓存*/
last_tail = usart1.dma_cfg.tail;
/*构造帧长度环形缓存*/
count=(count+1) % FRAME_SIZE;
}
}
b.从缓存中取数据


从缓存中取出一个字节：
bool get_byte(SERIAL_INIT_TYPE* usart,uint8_t* data)
{
if(usart->dma_cfg.tail==usart->dma_cfg.head) //空或满
return 0;
else //取数据
{
*data = usart->dma_cfg.rxbuff[usart->dma_cfg.head];
usart->dma_cfg.head = (usart->dma_cfg.head+1)%500;
return 1;
}
}
从缓存中取出一帧数据：
bool get_str(SERIAL_INIT_TYPE* usart , uint8_t* frame, uint8_t* len)
{
uint8_t temp;
temp=usart->dma_cfg.fifo_record[usart->dma_cfg.record_point];
if(temp)
{
*len = temp;
usart->dma_cfg.fifo_record[usart->dma_cfg.record_point]=0;
while(temp--)
{
if(get_byte(usart,frame++)){}
else
{
usart->dma_cfg.record_point=
(usart->dma_cfg.record_point+1)%usart->dma_cfg.length;
return 0;
}
}
usart->dma_cfg.record_point=
(usart->dma_cfg.record_point+1)%FRAME_SIZE;
return 1;
}
else
return 0;

}


取出字节函数为内部函数，面向上层的为取出一帧数据 bool get_str(SERIAL_INIT_TYPE* usart , uint8_t* frame, uint8_t* len)当取出数据有效时，返回1.输入串口号。frame为取出数据帧后，暂时存储区的首地址。len指向存储数据帧长度的地址。即调用函数，数据帧以及长度会传到frame和len。
三 .接口实现
我们已经实现了串口的读写，初始化函数，为了能被上层更方便的调用。应该将接口统一化。定义以下机构体：
typedef struct
{
void(*init)(SERIAL_INIT_TYPE* usart);
void(*write)(SERIAL_INIT_TYPE* usart,uint8_t* data, uint16_t len);
bool(*read)(SERIAL_INIT_TYPE* usart,uint8_t* data,uint8_t* len);
}SERIAL_OPS_TYPE;

其中函数指针分别指向串口1的发送接收函数，初始化函数。当上层需要使用串口时。
按以下步骤实现（拿modbus_slave来举例）：
/* 第一步定义modbus的发送接收端口类型，若存在其他接口类型比如can，同
样建立类似的驱动，定义一个输入can的类，然后在modbus中初始化时具体
选择哪种接口*/
SERIAL_OPS_TYPE md=
{
.init=usart_config,
.write=usart_send,
.read=get_str
};
/* 以下分别时modbus的初始化，发送，接收函数，淡化了串口号*/
void modbus_init(void)
{
md.init(&usart2);
}
/*发送指定长度数据*/
void modbus_write(uint8_t* frame,uint16_t len)
{
md.write(&usart2,frame,len);
}
/*读取一个字节*/
bool modbus_read(uint8_t* data,uint8_t* len)
{
return md.read(&usart2,data,len);
}