STM32五个串口同时收发函数配置

最新推荐文章于 2024-08-16 21:30:28 发布
最新推荐文章于 2024-08-16 21:30:28 发布
阅读量1.6w 收藏 75
点赞数 14
分类专栏： 单片机 串口通信 stm32 文章标签： STM32五个串口同时收发函数配置
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36958104/article/details/94573330
版权
stm32 同时被 3 个专栏收录
57 篇文章 42 订阅
订阅专栏
单片机
40 篇文章 11 订阅
订阅专栏
串口通信
10 篇文章 1 订阅
订阅专栏 
#include "user_usart.h"

#include "stm32f10x_usart.h"




/*使用microLib的方法*/
 /* 
int fputc(int ch, FILE *f)
{
	USART_SendData(USART1, (uint8_t) ch);

	while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET) {}	
   
    return ch;
}
int GetKey (void)  { 

    while (!(USART1->SR & USART_FLAG_RXNE));

    return ((int)(USART1->DR & 0x1FF));
}
*/
 
//#if EN_USART1_RX   //如果使能了接收

//#if EN_USART1_RX   //如果使能了接收
//串口1中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误   	
//u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，	接收完成标志
//bit14，	接收到0x0d
//bit13~0，	接收到的有效字节数目

u8 	checkdata[1];		//检测串口1接收的特定数据数据

//串口1队列定义
u8 	UART1SendBuff[UART1BuffSize];		//发送数据
u8 	UART1ReceBuff[UART1BuffSize];		//接收数据？
u16 UART1ReceIn = 0;//接收状态标记数据位	 
u8  UART1ReceFullFlag = 0;//接收完数据标志位

//串口2队列定义
u8 	UART2SendBuff[UART2BuffSize];		
u8 	UART2ReceBuff[UART2BuffSize];		
u16 UART2ReceIn = 0;
u8  UART2ReceFullFlag = 0;

//串口3队列定义
u8 	UART3SendBuff[UART3BuffSize];		
u8 	UART3ReceBuff[UART3BuffSize];		
u16 UART3ReceIn = 0;
u8  UART3ReceFullFlag = 0;

//串口4队列定义
u8 	UART4SendBuff[UART4BuffSize];		
u8 	UART4ReceBuff[UART4BuffSize];		
u16 UART4ReceIn = 0;
u8  UART4ReceFullFlag = 0;

//串口5队列定义
u8 	UART5SendBuff[UART5BuffSize];		
u8 	UART5ReceBuff[UART5BuffSize];		
u16 UART5ReceIn = 0;
u8  UART5ReceFullFlag = 0;


u8    usartflag;  //串口中断接收数据的标志位 串口2 串口3
//串口1初始化
void USART1_Configuration(u32 bound)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	USART_InitTypeDef USART_InitStructure;;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1,ENABLE);//开启GPIOA和USART1时钟
	
	//USART1_TX   GPIOA.9
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽输出
    GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
	
	//USART1_RX	  GPIOA.10初始化
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  
	
	//Usart1 NVIC 配置
  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2 ;//抢占优先级3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;		//子优先级3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQ通道使能
	NVIC_Init(&NVIC_InitStructure);	//根据指定的参数初始化VIC寄存器
	
	//USART 初始化设置
	USART_InitStructure.USART_BaudRate = bound;//串口波特率
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
	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_Init(USART1, &USART_InitStructure); //初始化串口1
	
	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);  //开启串口接收中断
	USART_Cmd(USART1, ENABLE);                    //使能串口1 
}

//串口2初始化
void USART2_Configuration(u32 bound)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	USART_InitTypeDef USART_InitStructure;;
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);//开启GPIOA和USART1时钟
	
	//USART2_TX   GPIOA.2
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; //PA.2
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽输出
    GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.2
	
	//USART2_RX	  GPIOA.3初始化
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;//PA3
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.3  
	
	//Usart2 NVIC 配置
    NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2 ;//抢占优先级3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;		//子优先级3  响应
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQ通道使能
	NVIC_Init(&NVIC_InitStructure);	//根据指定的参数初始化VIC寄存器
	
	//USART 初始化设置
	USART_InitStructure.USART_BaudRate = bound;//串口波特率
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
	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_Init(USART2, &USART_InitStructure); //初始化串口2
	
	USART_ITConfig(USART2,USART_IT_RXNE,ENABLE);  //开启串口接收中断
	USART_Cmd(USART2, ENABLE);                    //使能串口2 
}

//串口3初始化
void USART3_Configuration(u32 bound)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	USART_InitTypeDef USART_InitStructure;;
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);//开启GPIOA和USART1时钟
	
	//USART3_TX   GPIOB.10
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //PB.10
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽输出
    GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOA.10
	
	//USART3_RX	  GPIOB.3初始化
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;//PB11
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB.11  
	
	//Usart3 NVIC 配置
    NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2 ;//抢占优先级3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;		//子优先级3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQ通道使能
	NVIC_Init(&NVIC_InitStructure);	//根据指定的参数初始化VIC寄存器
	
	//USART 初始化设置
	USART_InitStructure.USART_BaudRate = bound;//串口波特率
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
	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_Init(USART3, &USART_InitStructure); //初始化串口3
	
	USART_ITConfig(USART3,USART_IT_RXNE,ENABLE);  //开启串口接收中断
	USART_Cmd(USART3, ENABLE);                    //使能串口3 
}
//串口4初始化
void UART4_Configuration(u32 bound)
{

			GPIO_InitTypeDef GPIO_InitStructure;
			USART_InitTypeDef USART_InitStructure;
			NVIC_InitTypeDef NVIC_InitStructure; 


		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE );
		RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE );



		GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //UART4 TX；
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出；
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_Init(GPIOC, &GPIO_InitStructure); //端口C；
		GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11; //UART4 RX；
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入；
		GPIO_Init(GPIOC, &GPIO_InitStructure); //端口C；

		USART_InitStructure.USART_BaudRate = bound; //波特率；
		USART_InitStructure.USART_WordLength = USART_WordLength_8b; //数据位8位；
		USART_InitStructure.USART_StopBits = USART_StopBits_1; //停止位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_Init(UART4, &USART_InitStructure);//配置串口参数；



	//	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置中断组，4位抢占优先级，4位响应优先级；
		NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn; //中断号；
		NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; //抢占优先级；
		NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //响应优先级；
		NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
		NVIC_Init(&NVIC_InitStructure);
		USART_ITConfig(UART4, USART_IT_RXNE, ENABLE);
		USART_Cmd(UART4, ENABLE); //使能串口；

}

//串口5初始化
void UART5_Configuration(u32 bound)
{
			
		GPIO_InitTypeDef GPIO_InitStructure;
		USART_InitTypeDef USART_InitStructure;

		NVIC_InitTypeDef NVIC_InitStructure; 
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD, ENABLE );
		RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART5, ENABLE );
		GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12; //UART5 TX；
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出；
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_Init(GPIOC, &GPIO_InitStructure); //端口C；
		GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; //UART5 RX；
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入；
		GPIO_Init(GPIOD, &GPIO_InitStructure); //端口D；


		USART_InitStructure.USART_BaudRate = bound; //波特率；
		USART_InitStructure.USART_WordLength = USART_WordLength_8b; //数据位8位；
		USART_InitStructure.USART_StopBits = USART_StopBits_1; //停止位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_Init(UART5, &USART_InitStructure);//配置串口参数；

		//NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置中断组，4位抢占优先级，4位响应优先级；
		NVIC_InitStructure.NVIC_IRQChannel = UART5_IRQn; //中断号；
		NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; //抢占优先级；
		NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //响应优先级；
		NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
		NVIC_Init(&NVIC_InitStructure);

		USART_ITConfig(UART5, USART_IT_RXNE, ENABLE);
		USART_Cmd(UART5, ENABLE); //使能串口；


}


//串口1发送一帧数据
void USART1_SendOneData(uint8_t SendOneData)
{
	USART_SendData(USART1, SendOneData);
	while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)
	{}
}

//串口2发送一帧数据
void USART2_SendOneData(uint8_t SendOneData)
{
	USART_SendData(USART2, SendOneData);
	while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET)
	{}
}

//串口3发送一帧数据
void USART3_SendOneData(uint8_t SendOneData)
{
	USART_SendData(USART3, SendOneData);
	while (USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET)
	{}
}

//串口4发送一帧数据
void UART4_SendOneData(uint8_t SendOneData)
{
	USART_SendData(UART4, SendOneData);
	while (USART_GetFlagStatus(UART4, USART_FLAG_TC) == RESET)
	{}
}

//串口5发送一帧数据
void UART5_SendOneData(uint8_t SendOneData)
{
	USART_SendData(UART5, SendOneData);
	while (USART_GetFlagStatus(UART5, USART_FLAG_TC) == RESET)
	{}
}

//串口1发送一列数据
void USART1_SendUnfixedData(uint8_t *Buffer, uint8_t Length)
{
	uint8_t  i;
	for(i=0;i<Length;i++)
	{
		USART1_SendOneData(*Buffer++);
	}
}

//串口2发送一列数据
void USART2_SendUnfixedData(uint8_t *Buffer, uint8_t Length)
{
	uint8_t  i;
	for(i=0;i<Length;i++)
	{
		USART2_SendOneData(*Buffer++);
	}
}

//串口3发送一列数据
void USART3_SendUnfixedData(uint8_t *Buffer, uint8_t Length)
{
	uint8_t  i;
	for(i=0;i<Length;i++)
	{
		USART3_SendOneData(*Buffer++);
	}
}
//串口4发送一列数据
void UART4_SendUnfixedData(uint8_t *Buffer, uint8_t Length)
{
	uint8_t  i;
	for(i=0;i<Length;i++)
	{
		UART4_SendOneData(*Buffer++);
	}
}

//串口5发送一列数据
void UART5_SendUnfixedData(uint8_t *Buffer, uint8_t Length)
{
	uint8_t  i;
	for(i=0;i<Length;i++)
	{
		UART5_SendOneData(*Buffer++);
	}
}

//串口1中断服务函数
void USART1_IRQHandler(void)
{
	u8 Res;//数据暂存
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断
	{
		Res =USART_ReceiveData(USART1);	//读取接收到的数据
		switch(UART1ReceIn)//读取接收到的数据有几位 每一位对应的数据协议校验
		{
			case 0:
				if(Res==0xFF)
					UART1ReceBuff[UART1ReceIn++] = Res;
				else
					UART1ReceIn = 0;
				break;
			case 1:
				if(Res==0xFE)
					UART1ReceBuff[UART1ReceIn++] = Res;
				else
					UART1ReceIn = 0;
				break;
			case 2://此处为判断数据的位置  
//				if(Res==0x02)//在其他位置判断数据
//				{UART1ReceBuff[UART1ReceIn++] = Res;
//					checkdata[0]=UART1ReceBuff[2];}
			{UART1ReceBuff[UART1ReceIn++] = Res;
			checkdata[0]=UART1ReceBuff[2];}
//			
//				else
//					UART1ReceIn = 0;
//				break;
			case 3:
				if(Res==0xFE)
					UART1ReceBuff[UART1ReceIn++] = Res;
				else
					UART1ReceIn = 0;
				break;
			case 4:
				if(Res==0xFE)
					UART1ReceBuff[UART1ReceIn++] = Res;
				else
					UART1ReceIn = 0;
				break;
			default:
				UART1ReceBuff[UART1ReceIn++] = Res;
				break;
		}

		if(UART1ReceIn >= 5)
		{
			UART1ReceFullFlag = 1;	//数据完整接受完 
			
		}
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);//清除相对应的中断位   清除中断预处理位USART_ClearITPendingBit左移八位是USART_ClearFlag  
	}
	else if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET)	// 发送中断  USART_GetITStatus
	{
		USART_ClearITPendingBit(USART1, USART_IT_TXE);					// clear interrupt  清除中断预处理位
	}	
}

//串口2中断服务函数
void USART2_IRQHandler(void)
{
		u8 Res;//数据暂存
	if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)  //接收中断
	{
		Res =USART_ReceiveData(USART2);	//读取接收到的数据
		USART_SendData(USART1,Res);//将读取到的数据通过串口1发送
		usartflag=2;
		switch(UART2ReceIn)//读取接收到的数据有几位 每一位对应的数据协议校验
		{
			case 0:
				if(Res==0xFF)
					UART2ReceBuff[UART2ReceIn++] = Res;
				else
					UART2ReceIn = 0;
				break;
			case 1:
				if(Res==0xFF)
					UART2ReceBuff[UART2ReceIn++] = Res;
				else
					UART2ReceIn = 0;
				break;
			case 2:
				if(Res==0x0f)
					UART2ReceBuff[UART2ReceIn++] = Res;
				else
					UART2ReceIn = 0;
				break;
			case 3:
				if(Res==0x01)
					UART2ReceBuff[UART2ReceIn++] = Res;
				else
					UART2ReceIn = 0;
				break;
			default:
				UART2ReceBuff[UART2ReceIn++] = Res;
				break;
		}

		if(UART2ReceIn >= 4)
		{
			UART2ReceFullFlag = 1;	//数据完整接受完			
		}
		USART_ClearITPendingBit(USART2, USART_IT_RXNE);//清除相对应的中断位   清除中断预处理位USART_ClearITPendingBit左移八位是USART_ClearFlag  
	}
	else if(USART_GetITStatus(USART2, USART_IT_TXE) != RESET)	// 发送中断  USART_GetITStatus
	{
		USART_ClearITPendingBit(USART2, USART_IT_TXE);					// clear interrupt  清除中断预处理位
	}	
	
} 
//串口3中断服务函数
void USART3_IRQHandler(void)
{
	u8 Res;//数据暂存
	if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)  //接收中断
	{
		Res =USART_ReceiveData(USART3);	//读取接收到的数据 USART_ReceiveData
		USART_SendData(USART1,Res);//将读取到的数据通过串口1发送
		usartflag=3;
		switch(UART3ReceIn)//读取接收到的数据有几位 每一位对应的数据协议校验
		{
			case 0:
				if(Res==0xFF)
					UART3ReceBuff[UART3ReceIn++] = Res;
				else
					UART3ReceIn = 0;
				break;
			case 1:
				if(Res==0xFF)
					UART3ReceBuff[UART3ReceIn++] = Res;
				else
					UART3ReceIn = 0;
				break;
			case 2:
				if(Res==0x0f)
					UART3ReceBuff[UART3ReceIn++] = Res;
				else
					UART3ReceIn = 0;
				break;
			case 3:
				if(Res==0x01)
					UART3ReceBuff[UART3ReceIn++] = Res;
				else
					UART3ReceIn = 0;
				break;
			case 4:
				if(Res==0x31)
					UART3ReceBuff[UART3ReceIn++] = Res;
				else
					UART3ReceIn = 0;
				break;
			default:
				UART3ReceBuff[UART3ReceIn++] = Res;
				break;
		}

		if(UART3ReceIn >= 57)
		{
			UART3ReceFullFlag = 1;	//数据完整接受完 
		}
		USART_ClearITPendingBit(USART3, USART_IT_RXNE);//清除相对应的中断位   清除中断预处理位USART_ClearITPendingBit左移八位是USART_ClearFlag  
	}
	else if(USART_GetITStatus(USART3, USART_IT_TXE) != RESET)	// 发送中断  USART_GetITStatus
	{
		USART_ClearITPendingBit(USART3, USART_IT_TXE);					// clear interrupt  清除中断预处理位
	}	
}

//串口4中断服务函数
void UART4_IRQHandler(void)
{
	u8 Res;//数据暂存
	if(USART_GetITStatus(UART4, USART_IT_RXNE) != RESET)  //接收中断
	{
		Res =USART_ReceiveData(UART4);	//读取接收到的数据 USART_ReceiveData
		USART_SendData(USART1,Res);//将读取到的数据通过串口1发送
		usartflag=4;
		switch(UART4ReceIn)//读取接收到的数据有几位 每一位对应的数据协议校验
		{
			case 0:
				if(Res==0xFF)
					UART4ReceBuff[UART4ReceIn++] = Res;
				else
					UART4ReceIn = 0;
				break;
			case 1:
				if(Res==0xFF)
					UART4ReceBuff[UART4ReceIn++] = Res;
				else
					UART4ReceIn = 0;
				break;
			case 2:
				if(Res==0x0f)
					UART4ReceBuff[UART4ReceIn++] = Res;
				else
					UART4ReceIn = 0;
				break;
			case 3:
				if(Res==0x01)
					UART4ReceBuff[UART4ReceIn++] = Res;
				else
					UART4ReceIn = 0;
				break;
			case 4:
				if(Res==0x31)
					UART4ReceBuff[UART4ReceIn++] = Res;
				else
					UART4ReceIn = 0;
				break;
			default:
				UART4ReceBuff[UART4ReceIn++] = Res;
				break;
		}

		if(UART4ReceIn >= 57)
		{
			UART4ReceFullFlag = 1;	//数据完整接受完 
		}
		USART_ClearITPendingBit(UART4, USART_IT_RXNE);//清除相对应的中断位   清除中断预处理位USART_ClearITPendingBit左移八位是USART_ClearFlag  
	}
	else if(USART_GetITStatus(UART4, USART_IT_TXE) != RESET)	// 发送中断  USART_GetITStatus
	{
		USART_ClearITPendingBit(UART4, USART_IT_TXE);					// clear interrupt  清除中断预处理位
	}	
}

//串口5中断服务函数
void UART5_IRQHandler(void)
{
	u8 Res;//数据暂存
	if(USART_GetITStatus(UART5, USART_IT_RXNE) != RESET)  //接收中断
	{
		Res =USART_ReceiveData(UART5);	//读取接收到的数据 USART_ReceiveData
		USART_SendData(USART1,Res);//将读取到的数据通过串口1发送
		usartflag=5;
		switch(UART5ReceIn)//读取接收到的数据有几位 每一位对应的数据协议校验
		{
			case 0:
				if(Res==0xFF)
					UART5ReceBuff[UART5ReceIn++] = Res;
				else
					UART5ReceIn = 0;
				break;
			case 1:
				if(Res==0xFF)
					UART5ReceBuff[UART5ReceIn++] = Res;
				else
					UART5ReceIn = 0;
				break;
			case 2:
				if(Res==0x0f)
					UART5ReceBuff[UART5ReceIn++] = Res;
				else
					UART5ReceIn = 0;
				break;
			case 3:
				if(Res==0x01)
					UART5ReceBuff[UART5ReceIn++] = Res;
				else
					UART5ReceIn = 0;
				break;
			case 4:
				if(Res==0x31)
					UART5ReceBuff[UART5ReceIn++] = Res;
				else
					UART5ReceIn = 0;
				break;
			default:
				UART5ReceBuff[UART5ReceIn++] = Res;
				break;
		}

		if(UART5ReceIn >= 57)
		{
			UART5ReceFullFlag = 1;	//数据完整接受完 
		}
		USART_ClearITPendingBit(UART5, USART_IT_RXNE);//清除相对应的中断位   清除中断预处理位USART_ClearITPendingBit左移八位是USART_ClearFlag  
	}
	else if(USART_GetITStatus(UART5, USART_IT_TXE) != RESET)	// 发送中断  USART_GetITStatus
	{
		USART_ClearITPendingBit(UART5, USART_IT_TXE);					// clear interrupt  清除中断预处理位
	}	
}

/*********************************
串口中断服务函数

void USART1_IRQHandler(void)
{
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //接收中断
	{
		RS485_RX_BUF[RS485_RX_CNT]=USART_ReceiveData(USART1);//RS485_RX_BUF  接收缓存
		switch(RS485_RX_CNT)
		{
			case 0:
				if(RS485_RX_BUF[RS485_RX_CNT]==0xaa)
				{
					RS485_RX_CNT++;
				}
				else
				{
					RS485_RX_CNT=0;
				}
				break;
			case 1:
				if(RS485_RX_BUF[RS485_RX_CNT]==0xbb)
				{
					RS485_RX_CNT++;
				}
				else
				{
					RS485_RX_CNT=0;
				}
				break;
			case 2:
				if(RS485_RX_BUF[RS485_RX_CNT]==0x01)
				{
					RS485_RX_CNT++;
				}
				else
				{
					RS485_RX_CNT=0;
				}
				break;
				case 3:
				if(RS485_RX_BUF[RS485_RX_CNT]==0x04)
				{
					RS485_RX_CNT++;
				}
				else
				{
					RS485_RX_CNT=0;
				}
				break;
				case 4:
				RecDuoji[0]=RS485_RX_BUF[4];
				RS485_RX_CNT++;
				break;
				case 5:
				if(RS485_RX_BUF[RS485_RX_CNT]==0xcc)
				{
					RS485_RX_CNT++;
				}
				else
				{
					RS485_RX_CNT=0;
				}
				break;
			  case 6:
				if(RS485_RX_BUF[RS485_RX_CNT]==0xdd)
				{
					RS485_RX_CNT++;
				}
				else
				{
					RS485_RX_CNT=0;
				}
				break;
				default:
					RS485_RX_CNT++;
				break ;
	    }
		if(RS485_RX_CNT>=6)
		{
			RS485_RX_CNT=0;
	//		UART1ReceFullFlag = 1;	 //接收完数据标志位
		}
}
	

}

******************************/

 

位文杰TOP
关注
专栏目录
STM32多路串口同时使用
09-21
串口1、2、3、4串口内被动发数据，串口之间通信互发数据，读取串口的缓冲区进行收发都可以，资源冲突已经解决，可以直接用。口均已启用DMA及空闲中断，支持不定长度数据接收。
使用STM32三个串口的接收与发送
07-21
同时使用STM32三个串口的接收与发送，串口1使用printf(),串口2使用u2_printf(),串口3使用u3_printf().接受采用定时器中断超时，5ms未接收到数据认为本次接收结束，置位相应的标志位，主程序检测并处理接收数据。
STM32实现三个串口同时开启发送接收数据
gr1423428723的博客
03-28 2423
实现STM32开通三个串口，每个串口都可以实现接收和发送数据。STM32打开三个串口收发数据代码，STM32使用三个串口收发数据
【stm32】USART 串口的接收（Rx）
最新发布
tsumikistep的博客
08-16 914
接着 tx 的部分来RXNE (Receive Not Empty)标志:当RXNE标志位为1时,表示UART的接收缓冲区中有新的数据可以被读取。当数据被读取后,RXNE标志位会被自动置为0。这个标志用于判断是否可以从缓冲区读取数据。有点像 riscv 汇编语言的 bne, beqNVIC的全称是Nested vectoredinterrupt controller，即嵌套向量中断控制器。对于NVIC，有个重要的知识点就是优先级分组，抢占优先级和子优先级。
STM32F103两个串口同时使用，使用闲时中断，不定长接收和不用结尾符。
04-07
STM32F103两个串口同时使用，使用闲时中断，不定长接收和不用结尾符。MDK编译通过。测试通过。
【STM32】串口通信基本原理（超基础、详细版）
u013407012的专栏
10-09 4854
本文链接：https://blog.csdn.net/qq_38410730/article/details/79887200 STM32F1xx官方资料： 《STM32中文参考手册V10》-第25章通用同步异步收发器（USART) 通信接口背景知识 设备之间通信的方式 一般情况下，设备之间的通信方式可以分成并行通信和串行通信两种。它们的区别是： 并、串行通信的区别 并行通...
stm32三个串口同时使用的工程
01-13
STM32F103C8T6的片子上同时使用三个串口，其中用于串口光纤的，用于带485接口的LoRa的和另一路作为DTU Modbus从机的三个串口，硬件上属于两路485和一个串口共三个串口通信。配置了好长时间，网上的例程都是转来转去不能用，里面的Modbus协议也可以好好研究一下。
双串口同时工作_stm32双串口_stm32两个串口_stm32两个串口_两个串口_usart双串口
09-10
综上所述，STM32的双串口同时工作涉及到串口配置、数据接收与发送任务的创建、中断服务程序的编写以及错误处理等多个方面。通过合理的设计和编程，可以充分利用STM32的串口资源，实现高效的多通道通信。
HAL库+CubeMX+Stm32F405 实现串口定长收发、printf函数使用、自定义打印函数
07-23
HAL库+CubeMX+Stm32F405 实现串口定长收发、printf函数使用、自定义打印函数 详情请看：https://lindoglog.blog.csdn.net/article/details/107463926
STM32F103五个串口通信函数
05-03
在本教程中，我们将深入探讨STM32F103的五个串口通信函数的初始化和收发功能。 1. **串口初始化**： STM32F103通常包含5个UART接口：UART1、UART2、UART3、UART4和UART5。每个串口都需要进行初始化配置，包括波特...
stm32f429usart串口收发配置
02-20
串口收发函数包括`HAL_UART_Transmit()`和`HAL_UART_Receive()`. `HAL_UART_Transmit()`用于发送数据，它会阻塞直到所有数据发送完毕。而`HAL_UART_Receive()`可以设定为中断或DMA方式，中断方式下，在接收一定数量...
stm32f103双串口收发（调试通过）
06-23
stm32f103实现双串口收发，初始化三个串口，调用两个，一个串口发送另外一个串口接收
STM32F103串口UART4UART5例程
12-26
STM32F103串口UART4UART5配置有别去其他的串口，现将配置测试例程上传，以供大家使用，本人亲测可用
usart_stm32五个串口初始化以及发送_
10-03
总结来说，STM32F103的五个串口初始化和发送涉及的关键点包括时钟配置、GPIO复用设置、USART初始化、中断配置、发送数据以及错误处理。通过`usart.c`和`usart.h`这两个文件，我们可以了解到具体实现这些功能的代码...
STM32F1的5个串口使用方法
出迷者
03-08 1万+
串口是我们常用的一个数据传输接口，STM32F103系列单片机共有5个串口，其中1-3是通用同步/异步串行接口USART(Universal Synchronous/Asynchronous Receiver/Transmitter)，4,、5是通用异步串行接口UART(Universal Asynchronous Receiver/Transmitter)。配置串口包括三部分内容：1.  I/O...
单片机串口接收多字节数据
热门推荐
phenixyf的专栏
07-14 1万+
http://bbs.elecfans.com/jishu_409918_1_1.html 各位大侠看一下，我下面的程序为什么不能接收两个字节的数据呢？ #include #define uchar unsigned char #define uint unsigned int void rs232_init(); uchar flag,i,g,d; uchar code table
STM32F1系列各串口配置代码
LuDvei的博客
03-06 564
【代码】STM32F1系列各串口配置代码。
STM32F103 5个串口同时使用
zpzyf的专栏
08-10 1万+
STM32+5个串口
STM32串口配置实验
weixin_44234294的博客
10-17 1322
STM32 串口简介 串口作为 MCU 的重要外部接口，同时也是软件开发重要的调试手段，其重要性不言而喻。 现在基本上所有的 MCU 都会带有串口，STM32 自然也不例外。STM32 的串口资源相当丰富的，功能也相当强劲。ALIENTEK 战舰 STM32 开发板所使用的 STM32F103ZET6 最多可提供 5 路串口，有分数波特率发生器、支持同步单线通信和半双工单线通讯、支持 LIN、支持调制解调器操作、智能卡协议和 IrDA SIR ENDEC 规范、具有 DMA等。 STM32 串口通信接口 U
STM32F103ZET6串口模块配置与中断实现
在该文档中，主要讨论的是STM32F103ZET6的串行通信接口（USART，通用同步/异步收发传输器）的配置，特别是针对串口一（USART1）的设置。 首先，串口的配置涉及多个步骤： 1. **GPIO端口设置**：USART1的TX（发送）...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值