STM32 5个串口初始化，前三个DMA操作，自制队列缓存机制，测试稳定

最新推荐文章于 2023-12-22 11:32:57 发布
最新推荐文章于 2023-12-22 11:32:57 发布
阅读量2.9k 收藏 36
点赞数 4
分类专栏： STM32 文章标签： STM32串口 DMA 串口缓存 队列 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42074368/article/details/103404573
版权

直接上代码：

首先头文件uart.h

#ifndef _IOT_UART_H_
#define _IOT_UART_H_
#include "stm32f10x.h"    

#define buff 5
#define blen 350

typedef struct {
	char DMA_Buffer[blen];
	char RxBuffer[buff][blen];
	char read;
	char write;
	char cnt;
}uart_stack;
extern uart_stack uart1;
extern uart_stack uart2;
extern uart_stack uart3;

void UART1_init(void);
void UART2_init(void);
void UART3_init(void);	
void UART4_init(void);
void UART5_init(void);	

//======================================栈缓存
void PushUartMsg(uart_stack * uart,u32 Uart_Rec_Cnt); 
#define PushUartMsg1(n) PushUartMsg(&uart1,n)
#define PushUartMsg2(n) PushUartMsg(&uart2,n)
#define PushUartMsg3(n) PushUartMsg(&uart3,n)

u8 * PopUartMsg(uart_stack * uart);
#define PopUartMsg1() PopUartMsg(&uart1)
#define PopUartMsg2() PopUartMsg(&uart2)
#define PopUartMsg3() PopUartMsg(&uart3)

//======================================串口
void IOT_UART_Send_Array(USART_TypeDef* USARTx,u8 * send_array,u32 num);
#define Uart1send(tx_buf,buflen)   IOT_UART_Send_Array(USART1,(u8 *)tx_buf, buflen)
#define Uart2send(tx_buf,buflen)   IOT_UART_Send_Array(USART2,(u8 *)tx_buf, buflen)
#define Uart3send(tx_buf,buflen)   IOT_UART_Send_Array(USART3,(u8 *)tx_buf, buflen)
#define Uart4send(tx_buf,buflen)   IOT_UART_Send_Array(USART4,(u8 *)tx_buf, buflen)
#define Uart5send(tx_buf,buflen)   IOT_UART_Send_Array(USART5,(u8 *)tx_buf, buflen)

#endif

下面uart.c

#include "uart.h"
#include "sys.h"
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
uart_stack uart1 = {0};
uart_stack uart2 = {0};
uart_stack uart3 = {0};
//======================================================================================================UART1_init(void)
int fputc(int ch, FILE *f)
{
    USART_SendData(USART1 , (uint8_t) ch);
    while (USART_GetFlagStatus(USART1 , USART_FLAG_TC) == RESET){}
    return ch;
}
void UART1_init(void)//调试
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	DMA_InitTypeDef DMA_InitStructure;
	
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA |RCC_APB2Periph_USART1, ENABLE);
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
	USART_DeInit(USART1);  //复位串口1
	

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    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;

    /* Enable the USART1 Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn ;//todo
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2 ;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    USART_Init(USART1 , &USART_InitStructure);
    USART_ITConfig(USART1 , USART_IT_IDLE, ENABLE);
	USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE);
    USART_Cmd(USART1 , ENABLE);
	
    //DMA配置
    DMA_DeInit(DMA1_Channel5);
    DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&USART1->DR;
    DMA_InitStructure.DMA_MemoryBaseAddr = (u32)uart1.DMA_Buffer;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStructure.DMA_BufferSize = blen;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    DMA_Init(DMA1_Channel5, &DMA_InitStructure);
	
    DMA_Cmd(DMA1_Channel5, ENABLE);
}
//========================================================================================================UART2_init(void)
void UART2_init(void)//WIFI
{
    GPIO_InitTypeDef GPIO_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    DMA_InitTypeDef DMA_InitStructure;
    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
    RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2, ENABLE);
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
    USART_DeInit(USART2);  //复位串口2
	
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 ;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    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_Init(USART2, &USART_InitStructure);
    USART_ITConfig(USART2, USART_IT_IDLE, ENABLE);
    USART_DMACmd(USART2,USART_DMAReq_Rx,ENABLE);
    USART_Cmd(USART2, ENABLE);
	
    /* Enable the USART2 Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;//todo
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1 ;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
	
    //DMA配置
    DMA_DeInit(DMA1_Channel6);
    DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&USART2->DR;
    DMA_InitStructure.DMA_MemoryBaseAddr = (u32)uart2.DMA_Buffer;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStructure.DMA_BufferSize = blen;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    DMA_Init(DMA1_Channel6, &DMA_InitStructure);

    DMA_Cmd(DMA1_Channel6, ENABLE);	
}
//========================================================================================================UART3_init(void)
void UART3_init(void)/*串口3MC20通信*/
{
	GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
    DMA_InitTypeDef DMA_InitStructure;
    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3 , ENABLE); 	
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
	USART_DeInit(USART3);  //复位串口3
    
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 ;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11 ;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

    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_Init(USART3, &USART_InitStructure);
    USART_ITConfig(USART3, USART_IT_IDLE, ENABLE);
    USART_DMACmd(USART3,USART_DMAReq_Rx,ENABLE);
    USART_Cmd(USART3, ENABLE);
	
		    /* Enable the USART2 Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;//todo
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0 ;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
	
    //DMA配置
    DMA_DeInit(DMA1_Channel3);
    DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&USART3->DR;
    DMA_InitStructure.DMA_MemoryBaseAddr = (u32)uart3.DMA_Buffer;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStructure.DMA_BufferSize = blen;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    DMA_Init(DMA1_Channel3, &DMA_InitStructure);

    DMA_Cmd(DMA1_Channel3, ENABLE);
}
//========================================================================================================UART4_init(void)
void UART4_init(void) /*串口4LCD通信*///TX-PC10 RX-PC11
{
	GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4 , ENABLE); 	
	USART_DeInit(UART4);  //复位串口3
    
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 ;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11 ;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    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_Init(UART4, &USART_InitStructure);
    //USART_ITConfig(UART4,USART_IT_RXNE,ENABLE);
    USART_Cmd(UART4, ENABLE);

}
//========================================================================================================UART5_init(void)
void UART5_init(void)/*串口5GPS通信*///TX-PC12 RX-PD2
{
	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); 	
	USART_DeInit(UART5);  //复位串口3
    
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 ;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 ;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOD, &GPIO_InitStructure);

    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_Init(UART5, &USART_InitStructure);
    USART_ITConfig(UART5,USART_IT_RXNE,ENABLE);
    USART_Cmd(UART5, ENABLE);

	/* Enable the UART5 Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel = UART5_IRQn;//todo
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
}

///
void USART1_IRQHandler(void)                	//串口1中断服务程序                                      //
{                                                                                                        //
    uint8_t Clear = Clear;                                                                               //
																										 //																									 //
    if(USART_GetFlagStatus(USART1,USART_FLAG_ORE) == SET)                                             	 //
    {                                                                                                    //
        USART_ReceiveData(USART1);                                                                    	 //
    }                                                                                                    //
    if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET)                                             	 //
    {                                                                                                    //
        Clear=USART1->SR;                                                                             	 //
        Clear=USART1->DR;                                                                              	 //
        USART_ReceiveData(USART1);                                                                     	 //USART2_IRQHandler
        int IOT_Uart_Rec_Cnt = blen-DMA_GetCurrDataCounter(DMA1_Channel5);              				 //
        DMA_Cmd(DMA1_Channel5, DISABLE );//关闭DMA                                                 	     //
        if(IOT_Uart_Rec_Cnt>0)                                                           				 //
        {                                                                                                //
            PushUartMsg1(IOT_Uart_Rec_Cnt);                                                              //
        }                                                                                                //
        USART_ClearITPendingBit(USART1,USART_IT_IDLE);                                                 	 //
        DMA_SetCurrDataCounter(DMA1_Channel5,blen);//重新计数                           				 //
        DMA_Cmd(DMA1_Channel5, ENABLE);                                                           	     //
    }                                                                                                    //
}                                                                                                        //
///
void USART2_IRQHandler(void) //USART2_IRQHandler                                                         //
{                                                                                                        //
    uint8_t Clear = Clear;                                                                               //
																										 //																									 //
    if(USART_GetFlagStatus(USART2,USART_FLAG_ORE) == SET)                                             	 //
    {                                                                                                    //
        USART_ReceiveData(USART2);                                                                    	 //
    }                                                                                                    //
    if(USART_GetITStatus(USART2, USART_IT_IDLE) != RESET)                                             	 //
    {                                                                                                    //
        Clear=USART2->SR;                                                                             	 //
        Clear=USART2->DR;                                                                              	 //
        USART_ReceiveData(USART2);                                                                     	 //USART2_IRQHandler
        int IOT_Uart_Rec_Cnt = blen-DMA_GetCurrDataCounter(DMA1_Channel6);              				 //
        DMA_Cmd(DMA1_Channel6, DISABLE );//关闭DMA                                                 	     //
        if(IOT_Uart_Rec_Cnt>0)                                                           				 //
        {                                                                                                //
            PushUartMsg2(IOT_Uart_Rec_Cnt);                                                              //
        }                                                                                                //
        USART_ClearITPendingBit(USART2,USART_IT_IDLE);                                                 	 //
        DMA_SetCurrDataCounter(DMA1_Channel6,blen);//重新计数                           				 //
        DMA_Cmd(DMA1_Channel6, ENABLE);                                                           	     //
    }                                                                                                    //
}                                                                                                        //
///
void USART3_IRQHandler(void) //USART3_IRQHandler                                                         //
{                                                                                                        //
    uint8_t Clear = Clear;                                                                               //
																										 //																										 //
    if(USART_GetFlagStatus(USART3,USART_FLAG_ORE) == SET)                                             	 //
    {                                                                                                    //
        USART_ReceiveData(USART3);                                                                    	 //
    }                                                                                                    //
    if(USART_GetITStatus(USART3, USART_IT_IDLE) != RESET)                                             	 //
    {                                                                                                    //
        Clear=USART3->SR;                                                                             	 //
        Clear=USART3->DR;                                                                                //
        USART_ReceiveData(USART3);                                                                       //
        int IOT_Uart_Rec_Cnt = blen-DMA_GetCurrDataCounter(DMA1_Channel3);             					 //USART3_IRQHandler
        DMA_Cmd(DMA1_Channel3, DISABLE);//关闭DMA                                               		 //
        if(IOT_Uart_Rec_Cnt>0)                                                         					 //
		{                                                                                                //
			PushUartMsg3(IOT_Uart_Rec_Cnt);                                                        		 //
		}                                                                                                //
        USART_ClearITPendingBit(USART3,USART_IT_IDLE);                                                	 //
        DMA_SetCurrDataCounter(DMA1_Channel3,blen);//重新计数                          					 //
        DMA_Cmd(DMA1_Channel3, ENABLE);                                                          		 //
    }                                                                                                    //
}                                                                                                        //
///
//
void IOT_UART_Send_Array(USART_TypeDef* USARTx,u8 * send_array,u32 num)       //**
{                                                                             //**
    u32 i=0;                                                                  //**
    while(i<num)                                                              //**
    {                                                                         //**
        while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET);          //**IOT_UART2_Send_Array
        USART_SendData(USARTx,send_array[i]);                                 //**
        while(USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET);           //**
        i++;                                                                  //**
    }                                                                         //**
}                                                                             //**
//============================================================================//**
void PushUartMsg(uart_stack * uart,u32 Uart_Rec_Cnt)                             
{                                                                             
	if(uart->cnt >= buff) return;                                              
	if(Uart_Rec_Cnt<blen)                                                      
	{                                                                          
		if(uart->write >= buff) uart->write = 0;                              
		memset(uart->RxBuffer[uart->write],0,blen);                            
		memcpy(uart->RxBuffer[uart->write],uart->DMA_Buffer,Uart_Rec_Cnt);    		
		uart->cnt++;                                                           
		uart->write++;                                                        
	}                                                                         
}                                                                             
																			  
u8 * PopUartMsg(uart_stack * uart)                                                         
{                                                                             
	if(uart->cnt>0)                                                            
	{                                                                          
		uart->cnt--;                                                           
		if(uart->read >= buff)                                                
			uart->read = 0;                                                   
		uart->read++;                                                         
		return (u8*)uart->RxBuffer[uart->read-1];                             
	}                                                                         
	else                                                                      
		return NULL;                                                          
}                                                                             
																			  
/

测试使用的main文件:

 

#include "stm32f10x.h"
#include "uart.h"
#include "sys.h"

int main(void)
{
	delay_init();
	UART1_init();
	UART2_init();
	while(1)
	{
		u8* str = PopUartMsg2();
		if(str != NULL)
		{
			Uart1send(str,strlen((char*)str));
		}
		str = PopUartMsg1();
		if(str != NULL)
		{
			Uart2send(str,strlen((char*)str));
		}
	} 

}

近期使用发现出现网友说的 stm32 卡死在串口接收中断，卡死原因是串口自带的BUG出现USART_FLAG_ORE标志位无法清除的问题。解决办法见：https://blog.csdn.net/qq_42074368/article/details/104031133

荒草人生
关注
  • 4
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STM32串口收/发程序--库函数编程
毛虫-strive-blogs
12-17 8349
前言 利用STM32的USART1，实现数据的收/发。本文参照文档为正点原子—库函数版本开发指南、STM32中文参考手册。 文章目录前言工具/参考文档stm32 USART寄存器状态寄存器(USART_SR)数据寄存器(USART_DR)串口设置流程1、串口时钟使能，GPIO使能2、串口复位3、GPIO端口模式设置4、串口参数初始化5、使能串口串口数据的接收与发送stm32 中断介绍代码uart.c文件完整代码（带注释）：usart.h文件：main.c文件调试过程完整工程 工具/参考文档 使用的编译器：K
stm32 5个串口初始化实现串口缓存，前三个DMA.zip
12-08
stm32测试用例 5个串口初始化， 实现全部串口队列缓存，前三个串口DMA存储，测试可用。.........
stm32学习-简单的串口接收与发送程序
Xiaomoxie的博客
12-11 1851
这里写自定义目录标 上位机的串口通信是一个很常用的程序。刚刚接触stm32芯片时写的第一个简单程序就是串口通信，现在把程序代码甩出来与大家分享。完整的程序哦~一般人我不告诉他 库版本 ：ST3.0.0欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右Sm...
stm32 打造自己环形队列
hbwang的博客
01-12 1610
本环形队列实现以数组形式批量写入和读取队列中数据。 写入数据时，对于队列剩余空间不足时，可以选择强制覆盖写入（会有覆盖部分原队列数据，请根据自己实现需要操作）；不覆盖，则不会写入； 读取数据时，如果超过队列中已存数据长度，则读取实际大小；没有超过，则正常读取。 本环形队列可用作串口数据缓存接收，尤为适用于有具体协议格式数据，方便查找TAG标识进行定位。但对于串口采用DMA方式，接收大量无协议格式的数据，暂不适用。
02 C语言使用队列实现缓存模块QueueBuffer
qq582880551的博客
03-08 918
C语言使用队列实现缓存模块QueueBuffer
基于stm32f407的串口环形队列及DMA收发中断数据处理
03-27
在本文中，我们将深入探讨如何在STM32F407微控制器上实现串口通信的环形队列和DMA（直接存储器访问）收发中断数据处理。STM32F407是一款基于ARM Cortex-M4内核的高性能单片机，广泛应用于嵌入式硬件设计。 首先，...
STM32 DMA串口不定长数据收发+FreeRTOS操作系统 参考代码
08-08
使用CubeMX封装的FreeRTOS操作系统，可直接写入到正点原子mini开发板之中或者任何一块stm32F103RCT6的板子上。 实现功能：1.有一个任务实现功能是PA8引脚（外接LED灯）可以实现呼吸灯效果。 2. UART1使用DMA+双缓存...
STM32F4 六串口初始化程序
01-13
总结，STM32F4六串口初始化程序是实现多通道通信的关键步骤，涉及寄存器配置、GPIO设置、波特率计算等多个方面。理解并熟练掌握这些知识点对于开发高效、可靠的嵌入式系统至关重要。在实际项目中，根据具体需求进行...
STM32串口空闲中断DMA接收不定长数据消息队列
01-11
在本文中，我们将深入探讨如何在STM32微控制器中实现串口空闲中断与DMA（直接内存访问）相结合，以接收不定长的数据，并利用FreeRTOS操作系统中的消息队列进行处理。STM32系列是基于ARM Cortex-M内核的微控制器，...
STM32H7 串口 DMA IDLE 任意长数据接收
10-23
1. 初始化串口和DMA：配置串口参数，如波特率、数据位、停止位等，然后配置DMA，选择合适的通道，设置传输方向为从外设到内存，指定接收缓冲区地址。 2. 设置串口的DMA中断：在HAL库中，启用串口的RXNE（接收数据...
usart_stm32五个串口初始化以及发送_
10-03
基于stm32f103的五个串口集中初始化，并且包含发送函数
【STM32专题 UART-DMA 】
2305_79343809的博客
08-18 942
DMA（Direct Memory Access）是一个硬件功能，用于使外围设备能够直接与系统内存进行数据交换，而不需要CPU的直接干预。这种方法减少了CPU的负担，并提高了数据传输的效率，尤其是对于大数据块的移动或复制操作。在STM32微控制器中，DMA主要与各种外围设备（如UART、SPI、ADC等）结合使用，以实现高效的数据传输。例如，您可以使用DMA直接将ADC转换的数据存储到内存数组中，或从内存数组中发送数据到UART，而不需要在每次数据传输时都中断CPU。
C语言 队列缓冲区
huizwang的专栏
11-27 2594
此方式使用到了单向链表，写的时候实时分配空间，读了之后释放空间，代码还有不足之处，比如说未加锁。 .C文件/********************************************************************** * Copyright (c), 2012~2016 XiShanTec All Rights Reserved * @file
STM32 串口+DMA的使用
热门推荐
菜鸟之嵌入式
09-17 1万+
STM32串口+DMA STM32有5个串口资源（USART1，USART2，USART3及UART4，UART5）。 其中3个USART（通用同步/异步收/发器universalsynchronous asynchronous receiver and transmitter）；2个UART（通用异步收/发器universalasynchronous receiver and transmi
stm32f4串口初始化
sdkdslx的博客
09-25 6710
IO口配置的一般步骤 1 定义一个IO口初始化结构体 2 IO时钟使能 3 IO模式设置 4 调用IO口初始化函数 串口配置的一般步骤 1 定义一个IO口初始化结构体，定义一个串口初始化结构体 2 IO时钟使能 3 串口时钟使能 4 IO模式设置 5 IO口初始化 6 串口参数配置 7 串口初始化 8 串口使能 1. 声明结构体变量 GPIO_InitTypeDef G...
STM32 UART串口DMA驱动设计
summers_wind的博客
11-10 1525
前言 stm32串口通信是开发中比较常用的功能，基本大家都会需要它来向别的设备或者PC端传递一些信息。然而大多数人却不能很好地设计一个好的串口驱动。对于新手或者比较懒的人一般直接赋值粘贴的网上的代码，一般这些代码包含三个功能：初始化、发送数据、中断入口函数。然后稍微变更一下端口号波特率之类的配置就可以用了。若只是调试这样用也无可厚非，但若要加入到一个系统中则有些不太严谨，对于一个系统来说追求的是占...
STM32常用的uart收发轮询、中断、DMA、不定长数据接收
最新发布
zcx_5517的博客
12-22 425
stm32 uart常用的收发有轮询、中断、DMA。
C语言实现任意数据类型的Queue环形队列RingBuffer
小歆CSDN博客
04-14 1062
头文件 fifo.h #ifndef __QUEUE_H_ #define __QUEUE_H_ /********************************************************************* * @brief Queue队列类型定义 *********************************************************************/ typedef struct { unsigned int
2022年5月２９日 STM32——USART串口通讯 和 DMA直接存储区访问
a_hua_J的博客
05-29 715
此内容仅供自己方便学习和回顾，内容来源于野火指南者开发板教程。 一.USART串口通讯 串口通讯(Serial Communication)经常用于调试，知道程序运行到哪一步，方便找出问题所在。 通讯协议基本分为物理层和协议层。 物理层：规定通讯系统中具有机械、电子功能部分的特性，确保原始数据在物理媒体的传输。 RS-232标准属于物理层： 上面的DB9接口： 协议层：规定通讯逻辑，统一收发双方的数据打包、解包标准。由起始位、主题数据、检验位以及停止位组成。 起始位：
写一个stm32f103的dma传输初始化代码，并且开启dma传输完成中断
03-25
以下是stm32f103的DMA传输初始化代码，并开启DMA传输完成中断： #include "stm32f10x.h" void DMA1_Stream7_IRQHandler(void) { if (DMA_GetITStatus(DMA1_Stream7, DMA_IT_TCIF7)) { DMA_ClearITPendingBit(DMA1_Stream7, DMA_IT_TCIF7); // DMA传输完成中断处理程序 } } void DMA_Init(void) { DMA_InitTypeDef DMA_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; // 使能DMA1时钟 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE); // DMA1-Stream7通道配置 DMA_DeInit(DMA1_Stream7); DMA_InitStructure.DMA_Channel = DMA_Channel_0; DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&(USART1->DR); DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)USART1_Tx_Buffer; DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; DMA_InitStructure.DMA_BufferSize = USART1_Tx_Buffer_Size; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh; DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable; DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full; DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; DMA_Init(DMA1_Stream7, &DMA_InitStructure); // 使能DMA1-Stream7传输完成中断 DMA_ITConfig(DMA1_Stream7, DMA_IT_TC, ENABLE); // 配置DMA1-Stream7传输完成中断优先级 NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream7_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); } int main(void) { // 初始化DMA传输 DMA_Init(); // 启动DMA传输 DMA_Cmd(DMA1_Stream7, ENABLE); while (1) { // 用户程序 } }

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值