STM32串口接收以及发送大全

串口接收：

 一、一帧数据以\r\n结束 

协议理解：

    协议嘛，就是我们人为创造一条规则，按这条规则规规矩矩地来章程执行能够减少错误，效率更高，都执行一个规则也能大一统。下面我来说说STM32中的这个通讯协议：
  一般情况下我们一次不会发送一大串太长的东东，所以我们先规定最大接收字节数，一般设为200，可以根据需要调整，大于这个数，我们就判断为接收出错，重新接收，我们接收到的字符就存到USART_RX_BUF[USART_REC_LEN]这个数组里面。

  那我们怎么判断接收到头结束了呢？

  在发送的末尾加上回车换行\r\n就表示接收结束，USART_RX_STA的最高位置1，如果直接受到了回车\r而下一个字节没有接收到换行\n我们认为发送的东东有误，直接受到\n没有\r也不行，并且这两个的顺序也不能改变。

#define USART_REC_LEN  200  	//定义最大接收字节数
u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲
u16 USART_RX_STA;        //接收状态标记

USART_RX_STA：

15	14	13~0
1：接收到0x0d后一位是0x0a才接收完成	1:接收到0x0d	接收到的有效字节数目

回车换行  ：

  以前仅仅这个回车换行就百思不得其解，下面来好好总结一下：

回车\r：0x0d，光标回到行首

换行\n：0x0a，光标移到下一行列不变

在不同的操作系统中，每一行的结束标志是不一样的：

\n:  UNIX 系统行末结束符

\r\n: window 系统行末结束符

\r:  MAC OS 系统行末结束符

  但我们就算在Windows按回车键也不是为了使光标回到行首，而是为了“光标回到行首&&光标移到下一行列不变”，可能是回车键集成了这两个作用，让我们平时使用起来更加方便吧。

 代码解析：

void USART1_IRQHandler(void)                	//串口1中断服务程序
	{          
	u8 Res;                                     //接收到的一个字节变量
#if SYSTEM_SUPPORT_OS 		//Èç¹ûSYSTEM_SUPPORT_OSΪÕ棬ÔòÐèÒªÖ§³ÖOS.
	OSIntEnter();    
#endif
    //如果有多个中断就要判断是哪个中断
    // USART_IT_RXNE就是接收缓冲区不为空中断
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //)
		{
		Res =USART_ReceiveData(USART1);	//读取接收到的数据
		
		if((USART_RX_STA&0x8000)==0)  //如果没有接收完成
			{
			if(USART_RX_STA&0x4000)   //如果已经接收到回车
				{
				if(Res!=0x0a)USART_RX_STA=0;   //没有接收到换行，失败
				else USART_RX_STA|=0x8000;	   // 接收到换行，成功
				}
			else //如果没有接收到回车
				{	
				if(Res==0x0d)USART_RX_STA|=0x4000;  //接收到回车，置接收到回车的标志位为1
				else                                //没有收到回车，表示是普通字符
					{
					USART_RX_BUF[USART_RX_STA&0X3FFF]=Res;//存到缓冲数组里
					USART_RX_STA++;  
                    //接收到的字符太多，失败                       
					if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;
					}		 
				}
			}   		 
     } 
#if SYSTEM_SUPPORT_OS 
	OSIntExit();  											 
#endif
} 

二、利用串口空闲中断 

        串口空闲指的是接收完一帧数据后，一个字节的时间没有接收数据产生的中断，下面的代码用的现在更流行的HAL库

u8 usartRxBuff[USART_REC_MAX_COUNT];    //接收缓冲区
u8 usartRxCount=0;                      //当前接收长度
void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(uartHandle->Instance==USART1)
  {
    __HAL_RCC_USART1_CLK_ENABLE();

    __HAL_RCC_GPIOA_CLK_ENABLE();
    GPIO_InitStruct.Pin = GPIO_PIN_9;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    GPIO_InitStruct.Pin = GPIO_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    __HAL_UART_ENABLE_IT(&huart1,UART_IT_IDLE);   //空闲中断
    __HAL_UART_ENABLE_IT(&huart1,UART_IT_RXNE);   //接收中断
    HAL_NVIC_SetPriority(USART1_IRQn,0,0);        //设置中断优先级
    HAL_NVIC_EnableIRQ(USART1_IRQn);              //使能中断
  }
}
void USART1_IRQHandler(void)
{
  if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_RXNE)!=RESET)
  {
    if(usartRxCountDR;
    }
  }
  if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE)!=RESET)
  {
    printf("receive:%s\r\n", usartRxBuff);
    usartRxCount = 0;
    __HAL_UART_CLEAR_IDLEFLAG(&huart1); // 清楚标志
  }
}

三、串口空闲中断+DMA

1、DMA初始化，DMA通道与收发外设连接

    //DMA RX
    hdma_usart1_rx.Instance = DMA1_Channel5;                   //通道选择
    hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;      //外设到内存
    hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;          //外设地址不自增
    hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;              //内存地址自增
    hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    //数据长度：字节
    hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;       //字节
    hdma_usart1_rx.Init.Mode = DMA_CIRCULAR;                      //模式为正常
    hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW;            //优先级
    HAL_DMA_Init(&hdma_usart1_rx);
    __HAL_LINKDMA(&huart1,hdmarx,hdma_usart1_rx);

    //DMA TX
    hdma_usart1_tx.Instance = DMA1_Channel4;                   //通道选择
    hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;      //外设到内存
    hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;          //外设地址不自增
    hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE;              //内存地址自增
    hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    //数据长度：字节
    hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;       //字节
    hdma_usart1_tx.Init.Mode = DMA_NORMAL;                      //模式为正常
    hdma_usart1_tx.Init.Priority = DMA_PRIORITY_LOW;            //优先级
    HAL_DMA_Init(&hdma_usart1_tx);
    __HAL_LINKDMA(&huart1,hdmatx,hdma_usart1_tx);

 2、中断初始化

//只需通道4，TX中断使能
HAL_NVIC_SetPriority(DMA1_Channel4_IRQn,0,0);  
HAL_NVIC_EnableIRQ(DMA1_Channel4_IRQn);

HAL_NVIC_SetPriority(USART1_IRQn,1,0);        //设置中断优先
HAL_NVIC_EnableIRQ(USART1_IRQn);              //使能中断

__HAL_UART_ENABLE_IT(&huart1,UART_IT_IDLE);   //空闲中断
HAL_UART_Receive_DMA(&huart1,usartRxBuff,USART_RX_MAX_COUNT);

 3、中断函数

//刚开始没加这个中断，只能发送一次，里面有清楚DMA传输完成标志
void DMA1_Channel4_IRQHandler(void)
{
  HAL_DMA_IRQHandler(&hdma_usart1_tx);
}

void USART1_IRQHandler(void)
{
  u16 countRemain = 0;
  
  if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE)!=RESET)
  {
    __HAL_UART_CLEAR_IDLEFLAG(&huart1); // 清楚标志
    HAL_UART_DMAStop(&huart1);
    countRemain = __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);  //DMA缓冲区中剩余的空间
    usartRxCount = USART_RX_MAX_COUNT - countRemain;
    usartRxFlag = 1;
    memcpy(keyBoardBuf, usartRxBuff, usartRxCount);
    HAL_UART_Receive_DMA(&huart1,usartRxBuff,USART_RX_MAX_COUNT);
  }
  HAL_UART_IRQHandler(&huart1);
}

 4、发送重定向

//串口1的DMA发送
void UART1_TX_DMA_Send(u8 *buffer, u16 length)
{
    //等待上一次的数据发送完毕
	  //while(HAL_DMA_GetState(&hdma_usart1_tx) != HAL_DMA_STATE_READY);
    //while(__HAL_DMA_GET_COUNTER(&hdma_usart1_tx));
	
    //关闭DMA
    __HAL_DMA_DISABLE(&hdma_usart1_tx);

    //开始发送数据
    HAL_UART_Transmit_DMA(&huart1, buffer, length);
}

//串口1的DMA发送printf
void debugPrintf(const char *format, ...)
{
	uint32_t length = 0;
	va_list args;
	
	__va_start(args, format);
	
	length = vsnprintf((char*)usartTxBuff, sizeof(usartTxBuff), (char*)format, args);
	
	UART1_TX_DMA_Send(usartTxBuff, length);
}


void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
	if (huart->Instance == USART1) //如果是串口1
	{
		// // 在F7系列是可以不写的，F1必须写
		// __HAL_DMA_CLEAR_FLAG(&hdma_usart1_tx, DMA_FLAG_TC4); //清除DMA2_Steam7传输完成标志
		// HAL_UART_DMAStop(&huart1);		//传输完成以后关闭串口DMA,缺了这一句会死机
    LED0 = !LED0;
    // //huart->gState = HAL_UART_STATE_READY;//huart1传输完成 变为准备
	}
}

5、应用

  while (1)
  {
      if(usartRxFlag)
      {
        keyBoardBuf[usartRxCount] = 0;
        debugPrintf("%d : %s\r\n", usartRxCount, keyBoardBuf);
        usartRxFlag = 0;
      }
  }

重定向：

  一、  最简单的，勾选 Use MiroLIB ，重写 fputc 函数

int fputc(int c, FILE *stream)
{
	while((USART1->SR & (1 << 6)) == 0);//等待上一次数据发送完成
	USART1->DR = c;
	return c;
}

 二、正点原子例程，不需要勾选 Use MiroLIB

#if 1
#pragma import(__use_no_semihosting)             
//标准库需要的支持函数                 
struct __FILE 
{ 
	int handle; 

}; 

FILE __stdout;       
//定义_sys_exit()以避免使用半主机模式    
_sys_exit(int x) 
{ 
	x = x; 
} 
//重定义fputc函数 
int fputc(int ch, FILE *f)
{      
	while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   
    USART1->DR = (u8) ch;      
	return ch;
}
#endif 

三、底层实现，也不需要勾选 Use MiroLIB

对其他串口重定向十分友好

//需要加这两个头函数，而不需要再加 stdio.h,上面两个方法都需要加stdio.h
#include "string.h"
#include "stdarg.h"


//串口二重定向
__align(8) char USART2_TxBuff[1024];  

void u2_printf(char* fmt,...) 
{  
	unsigned int i,length;
	
	va_list ap;
	va_start(ap,fmt);
	vsprintf(USART2_TxBuff,fmt,ap);
	va_end(ap);	
	
	length=strlen((const char*)USART2_TxBuff);		
	while((USART2->SR&0X40)==0);
	for(i = 0;i < length;i ++)
	{			
		USART2->DR = USART2_TxBuff[i];
		while((USART2->SR&0X40)==0);	
	}	
}