STM32循环队列串口通信(工程末尾自取)

STM32循环队列串口通信

包含内容：

• 循环队列

• 环形队列

  循环队列本质是先进先出的线性序列，通过定义的头尾指针对一个数组或者一个合法的内存进行循环访问的方式存入和取出数据，通过数组或者合法内存形成数据的缓冲区。

  1.这是一段连续的内存存储和头、尾指针
  2.初始化状态令头、尾指针都置于内存起始地址
  3
  3.为避免数据假溢出 形成循环队列 令指针移动到内存末地址时重新回到内存的起始地址
  
  4.编写初始化代码

typedef struct
{
 uint16_t Head;//头指针 取出数据时移动头指针
 uint16_t Tail;//尾指针 存入数据时移动尾指针
 uint16_t Lenght;//长度  尾指针和头指针间的距离 代表存储数据的长度
 uint8_t Ring_Buff[200];//缓冲大小 申请了200长度的数组用于存取数据
}RingBuff_t;
extern RingBuff_t ringBuff; 
void RingBuff_Init();缓冲区初始化
uint8_t Write_RingBuff(uint8_t data);//入队
uint8_t Read_RingBuff(uint8_t *rData);//出队

void RingBuff_Init(void) //初始化函数
{
 ringBuff.Head=0; //头指针置于起始位
 ringBuff.Tail=0; //尾指针置于起始位
 ringBuff.Lenght=0; //计录当前数据长度 判断是否存有数据
}

5.入队代码

uint8_t Write_RingBuff(uint8_t data) //存入指定的缓冲数组并通过数据长度判断是否溢出 返回值0正常 1溢出
{
 if(ringBuff.Lenght>=200) //200是申请的内存长度 可以修改 如果超过则为溢出
 {
  return 1; //确认数据溢出返回值1
 }
 ringBuff.Ring_Buff[ringBuff.Tail]=data;  //将数据通过尾指针指向的地址存入Ring_Buff缓冲数组中
 ringBuff.Tail=(ringBuff.Tail+1)%200;     //构建尾部指针的循环 指针累加 指针地址超过199 则重新置于0
 ringBuff.Lenght++;  //记录存入数据的长度 判断数据的存有数量和溢出情况
 return 0; //无溢出情况存入数据 返回值0
}

6.出队代码

uint8_t Read_RingBuff(uint8_t *rData) //从指定的缓冲数组中读出头指针指向地址的数据
{
 if(ringBuff.Lenght==0)  //如果数据长度为0 则此时缓冲数组中未存有数据
 {
  return 1; //取出数据失败 返回值0
 }
 *rData=ringBuff.Ring_Buff[ringBuff.Head]; //在Ring_buff中从头指针指向的地址中取出数据
 ringBuff.Head=(ringBuff.Head+1)%200;  //构建头部指针的循环 指针累加 指针地址超过199 则重新置于0
 ringBuff.Lenght--; //取出数据时减去相应的数据长度
 return 0; //取出数据正常 返回值0
}

本代码多有参考 在基础上加入了自身的理解和注释 记录学习过程中的一些细节 参考博客在下方链接 对接串口通信的详细后续补充

参考博客-图片
参考博客—代码

补充串口部分

uint16_t uart_puts(uint8_t *src, uint16_t len);
uint16_t uart_read(uint8_t* buf, uint16_t read_len);

uint8_t *pDataByte;

uint8_t Data = 0;
uint8_t Flag = 0;
uint16_t Len = 0;      

uint8_t Data_BUF[200];

int main(void)
{ 
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统终端优先级2
	delay_init(168);		//延时初始化
	uart_init(115200);	//串口初始化波特率115200
	LED_Init();		  		//初始化与LED连接的IO
	memset(Data_BUF,'1',200);
	RingBuff_Init();
	while(1)
	{
//		uart_read(Data_BUF,10);
		uart_puts(Data_BUF,10);
		delay_ms(4);
	}
}

uint16_t uart_puts(uint8_t *src, uint16_t len)
{
	pDataByte = src;
	Len=len;
	USART_ITConfig(USART1, USART_IT_TXE, ENABLE);  //发送标志位使能
	return 0;
}

uint16_t uart_read(uint8_t* buf, uint16_t read_len)
{
	static uint8_t n = 0;
		if(n > read_len)
		{
			n = 0;
			buf = Data_BUF;
			Flag = 1;		
		}
		if(0 == Read_RingBuff(&Data) && Flag == 0)            //???????????
		{
				*buf++ = Data;
				n++;
		}	  
	return 0;
}

串口初始化及接收部分

#include "sys.h"
#include "usart.h"	
// 	 
//Èç¹ûʹÓÃucos,Ôò°üÀ¨ÏÂÃæµÄÍ·Îļþ¼´¿É.
#if SYSTEM_SUPPORT_OS
#include "includes.h"					//ucos ʹÓÃ	  
#endif

extern uint8_t Flag;
extern uint16_t Len;
extern uint8_t* pDataByte;

typedef struct
{
 uint16_t Head;//???
 uint16_t Tail;//???
 uint16_t Lenght;//??
 uint8_t Ring_Buff[200];//????
}RingBuff_t;

RingBuff_t ringBuff;

extern RingBuff_t ringBuff;

void RingBuff_Init(void)
{
 ringBuff.Head=0;
 ringBuff.Tail=0;
 ringBuff.Lenght=0;
}

uint8_t Write_RingBuff(uint8_t data)
{
 if(ringBuff.Lenght>=200)
 {
  return 1;
 }
 ringBuff.Ring_Buff[ringBuff.Tail]=data;
 ringBuff.Tail=(ringBuff.Tail+1)%200;
 ringBuff.Lenght++;
 return 0;
}

uint8_t Read_RingBuff(uint8_t *rData)
{
 if(ringBuff.Lenght==0)
 {
  return 1;
 }
 *rData=ringBuff.Ring_Buff[ringBuff.Head];
 ringBuff.Ring_Buff[ringBuff.Head]=0;
 ringBuff.Head=(ringBuff.Head+1)%200;
 ringBuff.Lenght--;
 return 0;
}


//¼ÓÈëÒÔÏ´úÂë,Ö§³Öprintfº¯Êý,¶ø²»ÐèҪѡÔñuse MicroLIB	  
#if 1
#pragma import(__use_no_semihosting)             
//±ê×¼¿âÐèÒªµÄÖ§³Öº¯Êý                 
struct __FILE 
{ 
	int handle; 
}; 

FILE __stdout;       
//¶¨Òå_sys_exit()ÒÔ±ÜÃâʹÓðëÖ÷»úģʽ    
void _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
 
#if EN_USART1_RX   //Èç¹ûʹÄÜÁ˽ÓÊÕ
//´®¿Ú1ÖжϷþÎñ³ÌÐò
//×¢Òâ,¶ÁÈ¡USARTx->SRÄܱÜÃâĪÃûÆäÃîµÄ´íÎó   	
u8 USART_RX_BUF[USART_REC_LEN];     //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.
//½ÓÊÕ״̬
//bit15£¬	½ÓÊÕÍê³É±êÖ¾
//bit14£¬	½ÓÊÕµ½0x0d
//bit13~0£¬	½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿
u16 USART_RX_STA=0;       //½ÓÊÕ״̬±ê¼Ç	

//³õʼ»¯IO ´®¿Ú1 
//bound:²¨ÌØÂÊ
void uart_init(u32 bound){
   //GPIO¶Ë¿ÚÉèÖÃ
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE); //ʹÄÜGPIOAʱÖÓ
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//ʹÄÜUSART1ʱÖÓ
 
	//´®¿Ú1¶ÔÓ¦Òý½Å¸´ÓÃÓ³Éä
	GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_USART1); //GPIOA9¸´ÓÃΪUSART1
	GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_USART1); //GPIOA10¸´ÓÃΪUSART1
	
	//USART1¶Ë¿ÚÅäÖÃ
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10; //GPIOA9ÓëGPIOA10
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//¸´Óù¦ÄÜ
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	//ËÙ¶È50MHz
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //ÍÆÍ츴ÓÃÊä³ö
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //ÉÏÀ­
	GPIO_Init(GPIOA,&GPIO_InitStructure); //³õʼ»¯PA9£¬PA10

   //USART1 ³õʼ»¯ÉèÖÃ
	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_Cmd(USART1, ENABLE);  //ʹÄÜ´®¿Ú1 
//	USART_ITConfig(USART1, USART_IT_TC, ENABLE);
//	USART_ClearFlag(USART1, USART_FLAG_TC);
	
#if EN_USART1_RX	
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//¿ªÆôÏà¹ØÖжÏ

	//Usart1 NVIC ÅäÖÃ
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;//´®¿Ú1ÖжÏͨµÀ
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//ÇÀÕ¼ÓÅÏȼ¶3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority =3;		//×ÓÓÅÏȼ¶3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQͨµÀʹÄÜ
	NVIC_Init(&NVIC_InitStructure);	//¸ù¾ÝÖ¸¶¨µÄ²ÎÊý³õʼ»¯VIC¼Ä´æÆ÷¡¢

#endif
	
}


void USART1_IRQHandler(void)                	//´®¿Ú1ÖжϷþÎñ³ÌÐò
{
#if SYSTEM_SUPPORT_OS 		//Èç¹ûSYSTEM_SUPPORT_OSΪÕ棬ÔòÐèÒªÖ§³ÖOS.
	OSIntEnter();    
#endif
	static uint16_t x = 1;
 if( USART_GetITStatus(USART1, USART_IT_TXE) == SET  )
	{
		if( *pDataByte == '\0' || x == Len)//x == Len
		{
			USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
			x=1;
			Flag = 0;
		}
		else
		{
			USART_SendData(USART1, *pDataByte );
			pDataByte++;
			x++;
		}
	}
//		if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //
//		{
//			USART_ClearITPendingBit(USART1,USART_IT_RXNE); 
//			Write_RingBuff(USART_ReceiveData(USART1));//(USART1->DR);	//¶ÁÈ¡½ÓÊÕµ½µÄÊý¾			
//		} 
#if SYSTEM_SUPPORT_OS 	//Èç¹ûSYSTEM_SUPPORT_OSΪÕ棬ÔòÐèÒªÖ§³ÖOS.
	OSIntExit();  											 
#endif
} 
#endif	

 [完整工程代码](https://download.csdn.net/download/zx201902020050/87389516)