STM32H743串口1-8初始化和使用DMA数据传输

按照正点原子例程，STM32H743能够使用的串口有9个，8个普通串口和1个低功耗串口，在这里作者只对串口1-8进行研究

在初始化和实验的过程中，总结了如下问题和经验：

串口1和串口6的时钟势=使能在APB2ENR寄存器，其他串口的时钟使能都是在APB1ENR寄存器

注意复用映射配置

首先是串口1-8的初始化，串口1的初始化

#if EN_USART1_RX   //如果串口1接收使能

u8 USART_RX_BUF[USART_REC_LEN];     //串口1接收数据保存
u8 USART_RX_BUF2[USART_REC_LEN];     //串口1接收数据保存2，这块是作者的接收设定，可以根据自己需求修改

u16 USART_RX_STA=0;       //接收计数
u8 USART_flag=0;
u16 USART_RX_STA2=0;       //接收计数2
u8 USART_flag2=0;     //接收完成标志位
u8 aRxBuffer[RXBUFFERSIZE];//接收数据保存
UART_HandleTypeDef UART1_Handler; 

//串口1初始化
void uart_init(u32 bound)
{	
	//UART ³õʼ»¯ÉèÖÃ
	UART1_Handler.Instance=USART1;					    //USART1
	UART1_Handler.Init.BaudRate=bound;				    //²¨ÌØÂÊ
	UART1_Handler.Init.WordLength=UART_WORDLENGTH_8B;   //×Ö³¤Îª8λÊý¾Ý¸ñʽ
	UART1_Handler.Init.StopBits=UART_STOPBITS_1;	    //Ò»¸öֹͣλ
	UART1_Handler.Init.Parity=UART_PARITY_NONE;		    //ÎÞÆæżУÑéλ
	UART1_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;   //ÎÞÓ²¼þÁ÷¿Ø
	UART1_Handler.Init.Mode=UART_MODE_TX_RX;		    //ÊÕ·¢Ä£Ê½
	HAL_UART_Init(&UART1_Handler);					    //HAL_UART_Init()»áʹÄÜUART1
	
	HAL_UART_Receive_IT(&UART1_Handler, (u8 *)aRxBuffer, RXBUFFERSIZE);//¸Ãº¯Êý»á¿ªÆô½ÓÊÕÖжϣº±ê־λUART_IT_RXNE£¬²¢ÇÒÉèÖýÓÊÕ»º³åÒÔ¼°½ÓÊÕ»º³å½ÓÊÕ×î´óÊý¾ÝÁ¿
  
}

//´®¿Ú1ÖжϷþÎñ³ÌÐò
void USART1_IRQHandler(void)                	
{ 
	u32 timeout=0;
    u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntEnter();    
#endif
	
	HAL_UART_IRQHandler(&UART1_Handler);	//µ÷ÓÃHAL¿âÖжϴ¦Àí¹«Óú¯Êý
	
	timeout=0;
    while (HAL_UART_GetState(&UART1_Handler)!=HAL_UART_STATE_READY)//µÈ´ý¾ÍÐ÷
	{
        timeout++;³¬Ê±´¦Àí
        if(timeout>maxDelay) break;		
	}
     
	timeout=0;
	while(HAL_UART_Receive_IT(&UART1_Handler,(u8 *)aRxBuffer, RXBUFFERSIZE)!=HAL_OK)//Ò»´Î´¦ÀíÍê³ÉÖ®ºó£¬ÖØпªÆôÖжϲ¢ÉèÖÃRxXferCountΪ1
	{
        timeout++; //³¬Ê±´¦Àí
        if(timeout>maxDelay) break;	
	}
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntExit();  											 
#endif
}
#endif

串口2初始化

#if EN_USART2_RX   //Èç¹ûʹÄÜÁ˽ÓÊÕ
//´®¿Ú1ÖжϷþÎñ³ÌÐò
//×¢Òâ,¶ÁÈ¡USARTx->SRÄܱÜÃâĪÃûÆäÃîµÄ´íÎó   	
u8 USART2_RX_BUF[USART_REC_LEN];     //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.
//½ÓÊÕ״̬
//bit15£¬	½ÓÊÕÍê³É±êÖ¾
//bit14£¬	½ÓÊÕµ½0x0d
//bit13~0£¬	½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿
u16 USART2_RX_STA=0;       //½ÓÊÕ״̬±ê¼Ç	
u8 USART2_flag=0;
u8 aRxBuffer2[RXBUFFERSIZE];//HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å
UART_HandleTypeDef UART2_Handler; //UART¾ä±ú

//³õʼ»¯IO ´®¿Ú1 
//bound:²¨ÌØÂÊ
void uart2_init(u32 bound)
{	
	//UART ³õʼ»¯ÉèÖÃ
	UART2_Handler.Instance=USART2;					    //USART2
	UART2_Handler.Init.BaudRate=bound;				    //²¨ÌØÂÊ
	UART2_Handler.Init.WordLength=UART_WORDLENGTH_8B;   //×Ö³¤Îª8λÊý¾Ý¸ñʽ
	UART2_Handler.Init.StopBits=UART_STOPBITS_1;	    //Ò»¸öֹͣλ
	UART2_Handler.Init.Parity=UART_PARITY_NONE;		    //ÎÞÆæżУÑéλ
	UART2_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;   //ÎÞÓ²¼þÁ÷¿Ø
	UART2_Handler.Init.Mode=UART_MODE_TX_RX;		    //ÊÕ·¢Ä£Ê½
	HAL_UART_Init(&UART2_Handler);					    //HAL_UART_Init()»áʹÄÜUART2
	
	HAL_UART_Receive_IT(&UART2_Handler, (u8 *)aRxBuffer2, RXBUFFERSIZE);//¸Ãº¯Êý»á¿ªÆô½ÓÊÕÖжϣº±ê־λUART_IT_RXNE£¬²¢ÇÒÉèÖýÓÊÕ»º³åÒÔ¼°½ÓÊÕ»º³å½ÓÊÕ×î´óÊý¾ÝÁ¿
  
}

//´®¿Ú2ÖжϷþÎñ³ÌÐò
void USART2_IRQHandler(void)                	
{ 
	u32 timeout=0;
    u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntEnter();    
#endif
	
	HAL_UART_IRQHandler(&UART2_Handler);	//µ÷ÓÃHAL¿âÖжϴ¦Àí¹«Óú¯Êý
	
	timeout=0;
    while (HAL_UART_GetState(&UART2_Handler)!=HAL_UART_STATE_READY)//µÈ´ý¾ÍÐ÷
	{
        timeout++;³¬Ê±´¦Àí
        if(timeout>maxDelay) break;		
	}
     
	timeout=0;
	while(HAL_UART_Receive_IT(&UART2_Handler,(u8 *)aRxBuffer2, RXBUFFERSIZE)!=HAL_OK)//Ò»´Î´¦ÀíÍê³ÉÖ®ºó£¬ÖØпªÆôÖжϲ¢ÉèÖÃRxXferCountΪ1
	{
        timeout++; //³¬Ê±´¦Àí
        if(timeout>maxDelay) break;	
	}
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntExit();  											 
#endif
} 
#endif	

串口3初始化：

#if EN_USART3_RX   //Èç¹ûʹÄÜÁ˽ÓÊÕ
//´®¿Ú1ÖжϷþÎñ³ÌÐò
//×¢Òâ,¶ÁÈ¡USARTx->SRÄܱÜÃâĪÃûÆäÃîµÄ´íÎó   	
u8 USART3_RX_BUF[USART_REC_LEN];     //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.
//½ÓÊÕ״̬
//bit15£¬	½ÓÊÕÍê³É±êÖ¾
//bit14£¬	½ÓÊÕµ½0x0d
//bit13~0£¬	½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿
u16 USART3_RX_STA=0;       //½ÓÊÕ״̬±ê¼Ç	
u8 USART3_flag=0;
u8 aRxBuffer3[RXBUFFERSIZE];//HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å
UART_HandleTypeDef UART3_Handler; //UART¾ä±ú

//³õʼ»¯IO ´®¿Ú1 
//bound:²¨ÌØÂÊ
void uart3_init(u32 bound)
{	
	//UART ³õʼ»¯ÉèÖÃ
	UART3_Handler.Instance=USART3;					    //USART1
	UART3_Handler.Init.BaudRate=bound;				    //²¨ÌØÂÊ
	UART3_Handler.Init.WordLength=UART_WORDLENGTH_8B;   //×Ö³¤Îª8λÊý¾Ý¸ñʽ
	UART3_Handler.Init.StopBits=UART_STOPBITS_1;	    //Ò»¸öֹͣλ
	UART3_Handler.Init.Parity=UART_PARITY_NONE;		    //ÎÞÆæżУÑéλ
	UART3_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;   //ÎÞÓ²¼þÁ÷¿Ø
	UART3_Handler.Init.Mode=UART_MODE_TX_RX;		    //ÊÕ·¢Ä£Ê½
	HAL_UART_Init(&UART3_Handler);					    //HAL_UART_Init()»áʹÄÜUART1
	
	HAL_UART_Receive_IT(&UART3_Handler, (u8 *)aRxBuffer3, RXBUFFERSIZE);//¸Ãº¯Êý»á¿ªÆô½ÓÊÕÖжϣº±ê־λUART_IT_RXNE£¬²¢ÇÒÉèÖýÓÊÕ»º³åÒÔ¼°½ÓÊÕ»º³å½ÓÊÕ×î´óÊý¾ÝÁ¿
  
}

//´®¿Ú3ÖжϷþÎñ³ÌÐò
void USART3_IRQHandler(void)                	
{ 
	u32 timeout=0;
    u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntEnter();    
#endif
	
	HAL_UART_IRQHandler(&UART3_Handler);	//µ÷ÓÃHAL¿âÖжϴ¦Àí¹«Óú¯Êý
	
      	timeout=0;
    while (HAL_UART_GetState(&UART3_Handler)!=HAL_UART_STATE_READY)//µÈ´ý¾ÍÐ÷
	{
        timeout++;³¬Ê±´¦Àí
        if(timeout>maxDelay) break;		
	}
     
	timeout=0;
	while(HAL_UART_Receive_IT(&UART3_Handler,(u8 *)aRxBuffer3, RXBUFFERSIZE)!=HAL_OK)//Ò»´Î´¦ÀíÍê³ÉÖ®ºó£¬ÖØпªÆôÖжϲ¢ÉèÖÃRxXferCountΪ1
	{
        timeout++; //³¬Ê±´¦Àí
        if(timeout>maxDelay) break;	
	}
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntExit();  											 
#endif
} 
#endif	

串口4初始化：

#if EN_UART4_RX   //Èç¹ûʹÄÜÁ˽ÓÊÕ
//´®¿Ú1ÖжϷþÎñ³ÌÐò
//×¢Òâ,¶ÁÈ¡USARTx->SRÄܱÜÃâĪÃûÆäÃîµÄ´íÎó   	
u8 UART4_RX_BUF[UART_REC_LEN];     //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.
//½ÓÊÕ״̬
//bit15£¬	½ÓÊÕÍê³É±êÖ¾
//bit14£¬	½ÓÊÕµ½0x0d
//bit13~0£¬	½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿
u16 UART4_RX_STA=0;       //½ÓÊÕ״̬±ê¼Ç	
u8 UART4_flag=0;
u8 aRxBuffer4[RXBUFFERSIZE];//HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å
UART_HandleTypeDef UART4_Handler; //UART¾ä±ú

//³õʼ»¯IO ´®¿Ú1 
//bound:²¨ÌØÂÊ
void uart4_init(u32 bound)
{	
	//UART ³õʼ»¯ÉèÖÃ
	UART4_Handler.Instance=UART4;					    //UART4
	UART4_Handler.Init.BaudRate=bound;				    //²¨ÌØÂÊ
	UART4_Handler.Init.WordLength=UART_WORDLENGTH_8B;   //×Ö³¤Îª8λÊý¾Ý¸ñʽ
	UART4_Handler.Init.StopBits=UART_STOPBITS_1;	    //Ò»¸öֹͣλ
	UART4_Handler.Init.Parity=UART_PARITY_NONE;		    //ÎÞÆæżУÑéλ
	UART4_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;   //ÎÞÓ²¼þÁ÷¿Ø
	UART4_Handler.Init.Mode=UART_MODE_TX_RX;		    //ÊÕ·¢Ä£Ê½
	HAL_UART_Init(&UART4_Handler);					    //HAL_UART_Init()»áʹÄÜUART2
	
	HAL_UART_Receive_IT(&UART4_Handler, (u8 *)aRxBuffer4, RXBUFFERSIZE);//¸Ãº¯Êý»á¿ªÆô½ÓÊÕÖжϣº±ê־λUART_IT_RXNE£¬²¢ÇÒÉèÖýÓÊÕ»º³åÒÔ¼°½ÓÊÕ»º³å½ÓÊÕ×î´óÊý¾ÝÁ¿
  
}

//´®¿Ú4ÖжϷþÎñ³ÌÐò
void UART4_IRQHandler(void)                	
{ 
	u32 timeout=0;
    u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntEnter();    
#endif
	
	HAL_UART_IRQHandler(&UART4_Handler);	//µ÷ÓÃHAL¿âÖжϴ¦Àí¹«Óú¯Êý
	
	timeout=0;
    while (HAL_UART_GetState(&UART4_Handler)!=HAL_UART_STATE_READY)//µÈ´ý¾ÍÐ÷
	{
        timeout++;³¬Ê±´¦Àí
        if(timeout>maxDelay) break;		
	}
     
	timeout=0;
	while(HAL_UART_Receive_IT(&UART4_Handler,(u8 *)aRxBuffer4, RXBUFFERSIZE)!=HAL_OK)//Ò»´Î´¦ÀíÍê³ÉÖ®ºó£¬ÖØпªÆôÖжϲ¢ÉèÖÃRxXferCountΪ1
	{
        timeout++; //³¬Ê±´¦Àí
        if(timeout>maxDelay) break;	
	}
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntExit();  											 
#endif
} 
#endif	

串口5初始化：

#if EN_UART5_RX   //Èç¹ûʹÄÜÁ˽ÓÊÕ
//´®¿Ú1ÖжϷþÎñ³ÌÐò
//×¢Òâ,¶ÁÈ¡USARTx->SRÄܱÜÃâĪÃûÆäÃîµÄ´íÎó   	
u8 UART5_RX_BUF[UART_REC_LEN];     //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.
//½ÓÊÕ״̬
//bit15£¬	½ÓÊÕÍê³É±êÖ¾
//bit14£¬	½ÓÊÕµ½0x0d
//bit13~0£¬	½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿
u16 UART5_RX_STA=0;       //½ÓÊÕ״̬±ê¼Ç	
u8 UART5_flag=0;
u8 aRxBuffer5[RXBUFFERSIZE];//HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å
UART_HandleTypeDef UART5_Handler; //UART¾ä±ú

//³õʼ»¯IO ´®¿Ú1 
//bound:²¨ÌØÂÊ
void uart5_init(u32 bound)
{	
	//UART ³õʼ»¯ÉèÖÃ
	UART5_Handler.Instance=UART5;					    //UART4
	UART5_Handler.Init.BaudRate=bound;				    //²¨ÌØÂÊ
	UART5_Handler.Init.WordLength=UART_WORDLENGTH_8B;   //×Ö³¤Îª8λÊý¾Ý¸ñʽ
	UART5_Handler.Init.StopBits=UART_STOPBITS_1;	    //Ò»¸öֹͣλ
	UART5_Handler.Init.Parity=UART_PARITY_NONE;		    //ÎÞÆæżУÑéλ
	UART5_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;   //ÎÞÓ²¼þÁ÷¿Ø
	UART5_Handler.Init.Mode=UART_MODE_TX_RX;		    //ÊÕ·¢Ä£Ê½
	HAL_UART_Init(&UART5_Handler);					    //HAL_UART_Init()»áʹÄÜUART2
	
	HAL_UART_Receive_IT(&UART5_Handler, (u8 *)aRxBuffer5, RXBUFFERSIZE);//¸Ãº¯Êý»á¿ªÆô½ÓÊÕÖжϣº±ê־λUART_IT_RXNE£¬²¢ÇÒÉèÖýÓÊÕ»º³åÒÔ¼°½ÓÊÕ»º³å½ÓÊÕ×î´óÊý¾ÝÁ¿
  
}

//´®¿Ú5ÖжϷþÎñ³ÌÐò
void UART5_IRQHandler(void)                	
{ 
	u32 timeout=0;
    u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntEnter();    
#endif
	
	HAL_UART_IRQHandler(&UART5_Handler);	//µ÷ÓÃHAL¿âÖжϴ¦Àí¹«Óú¯Êý
	
	timeout=0;
    while (HAL_UART_GetState(&UART5_Handler)!=HAL_UART_STATE_READY)//µÈ´ý¾ÍÐ÷
	{
        timeout++;³¬Ê±´¦Àí
        if(timeout>maxDelay) break;		
	}
     
	timeout=0;
	while(HAL_UART_Receive_IT(&UART5_Handler,(u8 *)aRxBuffer5, RXBUFFERSIZE)!=HAL_OK)//Ò»´Î´¦ÀíÍê³ÉÖ®ºó£¬ÖØпªÆôÖжϲ¢ÉèÖÃRxXferCountΪ1
	{
        timeout++; //³¬Ê±´¦Àí
        if(timeout>maxDelay) break;	
	}
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntExit();  											 
#endif
} 
#endif

串口6初始化：

#if EN_USART6_RX   //Èç¹ûʹÄÜÁ˽ÓÊÕ
//´®¿Ú1ÖжϷþÎñ³ÌÐò
//×¢Òâ,¶ÁÈ¡USARTx->SRÄܱÜÃâĪÃûÆäÃîµÄ´íÎó   	
u8 USART6_RX_BUF[USART_REC_LEN];     //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.
//½ÓÊÕ״̬
//bit15£¬	½ÓÊÕÍê³É±êÖ¾
//bit14£¬	½ÓÊÕµ½0x0d
//bit13~0£¬	½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿
u16 USART6_RX_STA=0;       //½ÓÊÕ״̬±ê¼Ç	
u8 USART6_flag=0;
u8 aRxBuffer6[RXBUFFERSIZE];//HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å
UART_HandleTypeDef UART6_Handler; //UART¾ä±ú

//³õʼ»¯IO ´®¿Ú1 
//bound:²¨ÌØÂÊ
void uart6_init(u32 bound)
{	
	//UART ³õʼ»¯ÉèÖÃ
	UART6_Handler.Instance=USART6;					    //USART2
	UART6_Handler.Init.BaudRate=bound;				    //²¨ÌØÂÊ
	UART6_Handler.Init.WordLength=UART_WORDLENGTH_8B;   //×Ö³¤Îª8λÊý¾Ý¸ñʽ
	UART6_Handler.Init.StopBits=UART_STOPBITS_1;	    //Ò»¸öֹͣλ
	UART6_Handler.Init.Parity=UART_PARITY_NONE;		    //ÎÞÆæżУÑéλ
	UART6_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;   //ÎÞÓ²¼þÁ÷¿Ø
	UART6_Handler.Init.Mode=UART_MODE_TX_RX;		    //ÊÕ·¢Ä£Ê½
	HAL_UART_Init(&UART6_Handler);					    //HAL_UART_Init()»áʹÄÜUART2
	
	HAL_UART_Receive_IT(&UART6_Handler, (u8 *)aRxBuffer6, RXBUFFERSIZE);//¸Ãº¯Êý»á¿ªÆô½ÓÊÕÖжϣº±ê־λUART_IT_RXNE£¬²¢ÇÒÉèÖýÓÊÕ»º³åÒÔ¼°½ÓÊÕ»º³å½ÓÊÕ×î´óÊý¾ÝÁ¿
  
}

//´®¿Ú6ÖжϷþÎñ³ÌÐò
void USART6_IRQHandler(void)                	
{ 
	u32 timeout=0;
    u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntEnter();    
#endif
	
	HAL_UART_IRQHandler(&UART6_Handler);	//µ÷ÓÃHAL¿âÖжϴ¦Àí¹«Óú¯Êý
	
	timeout=0;
    while (HAL_UART_GetState(&UART6_Handler)!=HAL_UART_STATE_READY)//µÈ´ý¾ÍÐ÷
	{
        timeout++;³¬Ê±´¦Àí
        if(timeout>maxDelay) break;		
	}
     
	timeout=0;
	while(HAL_UART_Receive_IT(&UART6_Handler,(u8 *)aRxBuffer6, RXBUFFERSIZE)!=HAL_OK)//Ò»´Î´¦ÀíÍê³ÉÖ®ºó£¬ÖØпªÆôÖжϲ¢ÉèÖÃRxXferCountΪ1
	{
        timeout++; //³¬Ê±´¦Àí
        if(timeout>maxDelay) break;	
	}
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntExit();  											 
#endif
} 
#endif	

串口7初始化：

#if EN_UART7_RX   //Èç¹ûʹÄÜÁ˽ÓÊÕ
//´®¿Ú1ÖжϷþÎñ³ÌÐò
//×¢Òâ,¶ÁÈ¡USARTx->SRÄܱÜÃâĪÃûÆäÃîµÄ´íÎó   	
u8 UART7_RX_BUF[UART_REC_LEN];     //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.
//½ÓÊÕ״̬
//bit15£¬	½ÓÊÕÍê³É±êÖ¾
//bit14£¬	½ÓÊÕµ½0x0d
//bit13~0£¬	½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿
u16 UART7_RX_STA=0;       //½ÓÊÕ״̬±ê¼Ç	
u8 UART7_flag=0;
u8 aRxBuffer7[RXBUFFERSIZE];//HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å
UART_HandleTypeDef UART7_Handler; //UART¾ä±ú

//³õʼ»¯IO ´®¿Ú1 
//bound:²¨ÌØÂÊ
void uart7_init(u32 bound)
{	
	//UART ³õʼ»¯ÉèÖÃ
	UART7_Handler.Instance=UART7;					    //UART7
	UART7_Handler.Init.BaudRate=bound;				    //²¨ÌØÂÊ
	UART7_Handler.Init.WordLength=UART_WORDLENGTH_8B;   //×Ö³¤Îª8λÊý¾Ý¸ñʽ
	UART7_Handler.Init.StopBits=UART_STOPBITS_1;	    //Ò»¸öֹͣλ
	UART7_Handler.Init.Parity=UART_PARITY_NONE;		    //ÎÞÆæżУÑéλ
	UART7_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;   //ÎÞÓ²¼þÁ÷¿Ø
	UART7_Handler.Init.Mode=UART_MODE_TX_RX;		    //ÊÕ·¢Ä£Ê½
	HAL_UART_Init(&UART7_Handler);					    //HAL_UART_Init()»áʹÄÜUART2
	
	HAL_UART_Receive_IT(&UART7_Handler, (u8 *)aRxBuffer7, RXBUFFERSIZE);//¸Ãº¯Êý»á¿ªÆô½ÓÊÕÖжϣº±ê־λUART_IT_RXNE£¬²¢ÇÒÉèÖýÓÊÕ»º³åÒÔ¼°½ÓÊÕ»º³å½ÓÊÕ×î´óÊý¾ÝÁ¿
  
}

//´®¿Ú7ÖжϷþÎñ³ÌÐò
void UART7_IRQHandler(void)                	
{ 
	u32 timeout=0;
    u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntEnter();    
#endif
	
	HAL_UART_IRQHandler(&UART7_Handler);	//µ÷ÓÃHAL¿âÖжϴ¦Àí¹«Óú¯Êý
	
	timeout=0;
    while (HAL_UART_GetState(&UART7_Handler)!=HAL_UART_STATE_READY)//µÈ´ý¾ÍÐ÷
	{
        timeout++;³¬Ê±´¦Àí
        if(timeout>maxDelay) break;		
	}
     
	timeout=0;
	while(HAL_UART_Receive_IT(&UART7_Handler,(u8 *)aRxBuffer7, RXBUFFERSIZE)!=HAL_OK)//Ò»´Î´¦ÀíÍê³ÉÖ®ºó£¬ÖØпªÆôÖжϲ¢ÉèÖÃRxXferCountΪ1
	{
        timeout++; //³¬Ê±´¦Àí
        if(timeout>maxDelay) break;	
	}
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntExit();  											 
#endif
} 
#endif	

串口8初始化：

#if EN_UART8_RX   //Èç¹ûʹÄÜÁ˽ÓÊÕ
//´®¿Ú1ÖжϷþÎñ³ÌÐò
//×¢Òâ,¶ÁÈ¡USARTx->SRÄܱÜÃâĪÃûÆäÃîµÄ´íÎó   	
u8 UART8_RX_BUF[UART_REC_LEN];     //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú.
//½ÓÊÕ״̬
//bit15£¬	½ÓÊÕÍê³É±êÖ¾
//bit14£¬	½ÓÊÕµ½0x0d
//bit13~0£¬	½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿
u16 UART8_RX_STA=0;       //½ÓÊÕ״̬±ê¼Ç	
u8 UART8_flag=0;
u8 aRxBuffer8[RXBUFFERSIZE];//HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å
UART_HandleTypeDef UART8_Handler; //UART¾ä±ú

//³õʼ»¯IO ´®¿Ú1 
//bound:²¨ÌØÂÊ
void uart8_init(u32 bound)
{	
	//UART ³õʼ»¯ÉèÖÃ
	UART8_Handler.Instance=UART8;					    //UART8
	UART8_Handler.Init.BaudRate=bound;				    //²¨ÌØÂÊ
	UART8_Handler.Init.WordLength=UART_WORDLENGTH_8B;   //×Ö³¤Îª8λÊý¾Ý¸ñʽ
	UART8_Handler.Init.StopBits=UART_STOPBITS_1;	    //Ò»¸öֹͣλ
	UART8_Handler.Init.Parity=UART_PARITY_NONE;		    //ÎÞÆæżУÑéλ
	UART8_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;   //ÎÞÓ²¼þÁ÷¿Ø
	UART8_Handler.Init.Mode=UART_MODE_TX_RX;		    //ÊÕ·¢Ä£Ê½
	HAL_UART_Init(&UART8_Handler);					    //HAL_UART_Init()»áʹÄÜUART2
	
	HAL_UART_Receive_IT(&UART8_Handler, (u8 *)aRxBuffer8, RXBUFFERSIZE);//¸Ãº¯Êý»á¿ªÆô½ÓÊÕÖжϣº±ê־λUART_IT_RXNE£¬²¢ÇÒÉèÖýÓÊÕ»º³åÒÔ¼°½ÓÊÕ»º³å½ÓÊÕ×î´óÊý¾ÝÁ¿
  
}

//´®¿Ú8ÖжϷþÎñ³ÌÐò
void UART8_IRQHandler(void)                	
{ 
	u32 timeout=0;
    u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntEnter();    
#endif
	
	HAL_UART_IRQHandler(&UART8_Handler);	//µ÷ÓÃHAL¿âÖжϴ¦Àí¹«Óú¯Êý
	
	timeout=0;
    while (HAL_UART_GetState(&UART8_Handler)!=HAL_UART_STATE_READY)//µÈ´ý¾ÍÐ÷
	{
        timeout++;³¬Ê±´¦Àí
        if(timeout>maxDelay) break;		
	}
     
	timeout=0;
	while(HAL_UART_Receive_IT(&UART8_Handler,(u8 *)aRxBuffer8, RXBUFFERSIZE)!=HAL_OK)//Ò»´Î´¦ÀíÍê³ÉÖ®ºó£¬ÖØпªÆôÖжϲ¢ÉèÖÃRxXferCountΪ1
	{
        timeout++; //³¬Ê±´¦Àí
        if(timeout>maxDelay) break;	
	}
#if SYSTEM_SUPPORT_OS	 	//ʹÓÃOS
	OSIntExit();  											 
#endif
} 
#endif	

接下来是底层初始化：

//UARTµ×²ã³õʼ»¯£¬Ê±ÖÓʹÄÜ£¬Òý½ÅÅäÖã¬ÖжÏÅäÖÃ
//´Ëº¯Êý»á±»HAL_UART_Init()µ÷ÓÃ
//huart:´®¿Ú¾ä±ú
void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{
    //GPIO¶Ë¿ÚÉèÖÃ
	GPIO_InitTypeDef GPIO_Initure;
	
	if(huart->Instance==USART1)//Èç¹ûÊÇ´®¿Ú1£¬½øÐд®¿Ú1 MSP³õʼ»¯
	{
		__HAL_RCC_GPIOA_CLK_ENABLE();			//ʹÄÜGPIOAʱÖÓ
		__HAL_RCC_USART1_CLK_ENABLE();			//ʹÄÜUSART1ʱÖÓ
	
		GPIO_Initure.Pin=GPIO_PIN_9;			//PA9
		GPIO_Initure.Mode=GPIO_MODE_AF_PP;		//¸´ÓÃÍÆÍìÊä³ö
		GPIO_Initure.Pull=GPIO_PULLUP;			//ÉÏÀ­
		GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//¸ßËÙ
		GPIO_Initure.Alternate=GPIO_AF7_USART1;	//¸´ÓÃΪUSART1
		HAL_GPIO_Init(GPIOA,&GPIO_Initure);	   	//³õʼ»¯PA9

		GPIO_Initure.Pin=GPIO_PIN_10;			//PA10
		HAL_GPIO_Init(GPIOA,&GPIO_Initure);	   	//³õʼ»¯PA10
		
#if EN_USART1_RX
		HAL_NVIC_EnableIRQ(USART1_IRQn);				//ʹÄÜUSART1ÖжÏͨµÀ
		HAL_NVIC_SetPriority(USART1_IRQn,3,3);			//ÇÀÕ¼ÓÅÏȼ¶3£¬×ÓÓÅÏȼ¶3
#endif	
	}
	
	if(huart->Instance==USART2)//Èç¹ûÊÇ´®¿Ú2£¬½øÐд®¿Ú2 MSP³õʼ»¯
	{
		__HAL_RCC_GPIOA_CLK_ENABLE();			//ʹÄÜGPIOAʱÖÓ
		__HAL_RCC_USART2_CLK_ENABLE();			//ʹÄÜUSART2ʱÖÓ
	
		GPIO_Initure.Pin=GPIO_PIN_2;			//PA2
		GPIO_Initure.Mode=GPIO_MODE_AF_PP;		//¸´ÓÃÍÆÍìÊä³ö
		GPIO_Initure.Pull=GPIO_PULLUP;			//ÉÏÀ­
		GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//¸ßËÙ
		GPIO_Initure.Alternate=GPIO_AF7_USART2;	//¸´ÓÃΪUSART2
		HAL_GPIO_Init(GPIOA,&GPIO_Initure);	   	//³õʼ»¯PA2

		GPIO_Initure.Pin=GPIO_PIN_3;			//PA3
		HAL_GPIO_Init(GPIOA,&GPIO_Initure);	   	//³õʼ»¯PA3
		
#if EN_USART2_RX
		HAL_NVIC_EnableIRQ(USART2_IRQn);				//ʹÄÜUSART2ÖжÏͨµÀ
		HAL_NVIC_SetPriority(USART2_IRQn,3,3);			//ÇÀÕ¼ÓÅÏȼ¶3£¬×ÓÓÅÏȼ¶3
#endif	
	}
	
	if(huart->Instance==USART3)//Èç¹ûÊÇ´®¿Ú3£¬½øÐд®¿Ú3 MSP³õʼ»¯
	{
		__HAL_RCC_GPIOB_CLK_ENABLE();			//ʹÄÜGPIOBʱÖÓ
		__HAL_RCC_USART3_CLK_ENABLE();			//ʹÄÜUSART3ʱÖÓ
	
		GPIO_Initure.Pin=GPIO_PIN_10;			//PB10
		GPIO_Initure.Mode=GPIO_MODE_AF_PP;		//¸´ÓÃÍÆÍìÊä³ö
		GPIO_Initure.Pull=GPIO_PULLUP;			//ÉÏÀ­
		GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//¸ßËÙ
		GPIO_Initure.Alternate=GPIO_AF7_USART3;	//¸´ÓÃΪUSART1
		HAL_GPIO_Init(GPIOB,&GPIO_Initure);	   	//³õʼ»¯PB10

		GPIO_Initure.Pin=GPIO_PIN_11;			//PB11
		HAL_GPIO_Init(GPIOB,&GPIO_Initure);	   	//³õʼ»¯PB11
		
#if EN_USART3_RX
		HAL_NVIC_EnableIRQ(USART3_IRQn);				//ʹÄÜUSART1ÖжÏͨµÀ
		HAL_NVIC_SetPriority(USART3_IRQn,0,0);			//ÇÀÕ¼ÓÅÏȼ¶3£¬×ÓÓÅÏȼ¶3
#endif	
	}
		
	if(huart->Instance==UART4)//Èç¹ûÊÇ´®¿Ú4£¬½øÐд®¿Ú4 MSP³õʼ»¯
	{
		__HAL_RCC_GPIOH_CLK_ENABLE();			//ʹÄÜGPIOBʱÖÓ
		__HAL_RCC_UART4_CLK_ENABLE();			//ʹÄÜUART4ʱÖÓ
	
		GPIO_Initure.Pin=GPIO_PIN_13;			//PH
		GPIO_Initure.Mode=GPIO_MODE_AF_PP;		//¸´ÓÃÍÆÍìÊä³ö
		GPIO_Initure.Pull=GPIO_PULLUP;			//ÉÏÀ­
		GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//¸ßËÙ
		GPIO_Initure.Alternate=GPIO_AF8_UART4;	//¸´ÓÃΪUART4
		HAL_GPIO_Init(GPIOH,&GPIO_Initure);	   	//³õʼ»¯PH13

		GPIO_Initure.Pin=GPIO_PIN_14;			//PH14
		HAL_GPIO_Init(GPIOH,&GPIO_Initure);	   	//³õʼ»¯PH14
		
#if EN_UART4_RX
		HAL_NVIC_EnableIRQ(UART4_IRQn);				//ʹÄÜUSART1ÖжÏͨµÀ
		HAL_NVIC_SetPriority(UART4_IRQn,0,0);			//ÇÀÕ¼ÓÅÏȼ¶3£¬×ÓÓÅÏȼ¶3
#endif	
	}
	
	if(huart->Instance==UART5)//Èç¹ûÊÇ´®¿Ú5£¬½øÐд®¿Ú5MSP³õʼ»¯
	{
		__HAL_RCC_GPIOB_CLK_ENABLE();			//ʹÄÜGPIOBʱÖÓ
		__HAL_RCC_UART5_CLK_ENABLE();			//ʹÄÜUART5ʱÖÓ
	
		GPIO_Initure.Pin=GPIO_PIN_13;			//PB13
		GPIO_Initure.Mode=GPIO_MODE_AF_PP;		//¸´ÓÃÍÆÍìÊä³ö
		GPIO_Initure.Pull=GPIO_PULLUP;			//ÉÏÀ­
		GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//¸ßËÙ
		GPIO_Initure.Alternate=GPIO_AF14_UART5;	//¸´ÓÃΪUART5
		HAL_GPIO_Init(GPIOB,&GPIO_Initure);	   	//³õʼ»¯PB13

		GPIO_Initure.Pin=GPIO_PIN_12;			//PB12
		HAL_GPIO_Init(GPIOB,&GPIO_Initure);	   	//³õʼ»¯PB12
		
#if EN_UART5_RX
		HAL_NVIC_EnableIRQ(UART5_IRQn);				//ʹÄÜUSART1ÖжÏͨµÀ
		HAL_NVIC_SetPriority(UART5_IRQn,0,0);			//ÇÀÕ¼ÓÅÏȼ¶3£¬×ÓÓÅÏȼ¶3
#endif	
	}
	
	if(huart->Instance==USART6)//Èç¹ûÊÇ´®¿Ú6£¬½øÐд®¿Ú6MSP³õʼ»¯
	{
		__HAL_RCC_GPIOC_CLK_ENABLE();			//ʹÄÜGPIOCʱÖÓ
		__HAL_RCC_GPIOG_CLK_ENABLE();			//ʹÄÜGPIOCʱÖÓ
		__HAL_RCC_USART6_CLK_ENABLE();			//ʹÄÜUART6ʱÖÓ
	
		GPIO_Initure.Pin=GPIO_PIN_6;			//PC6
		GPIO_Initure.Mode=GPIO_MODE_AF_PP;		//¸´ÓÃÍÆÍìÊä³ö
		GPIO_Initure.Pull=GPIO_PULLUP;			//ÉÏÀ­
		GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//¸ßËÙ
		GPIO_Initure.Alternate=GPIO_AF7_USART6;	//¸´ÓÃΪUART6
		HAL_GPIO_Init(GPIOC,&GPIO_Initure);	   	//³õʼ»¯PC6

		GPIO_Initure.Pin=GPIO_PIN_7;			//PC7,PC7òËƹÊÕÏÁË£¬Ö»Òª½ÓÉϾÍÊÇÓеçƽÊä³ö
		HAL_GPIO_Init(GPIOC,&GPIO_Initure);	   	//³õʼ»¯PC7
		
#if EN_USART6_RX
		HAL_NVIC_EnableIRQ(USART6_IRQn);				//ʹÄÜUSART6ÖжÏͨµÀ
		HAL_NVIC_SetPriority(USART6_IRQn,3,3);			//ÇÀÕ¼ÓÅÏȼ¶3£¬×ÓÓÅÏȼ¶3
#endif	
	}
	
	if(huart->Instance==UART7)//Èç¹ûÊÇ´®¿Ú7£¬½øÐд®¿Ú6MSP³õʼ»¯
	{
		__HAL_RCC_GPIOF_CLK_ENABLE();			//ʹÄÜGPIOFʱÖÓ
		__HAL_RCC_UART7_CLK_ENABLE();			//ʹÄÜUART6ʱÖÓ
	
		GPIO_Initure.Pin=GPIO_PIN_7;			//PF7
		GPIO_Initure.Mode=GPIO_MODE_AF_PP;		//¸´ÓÃÍÆÍìÊä³ö
		GPIO_Initure.Pull=GPIO_PULLUP;			//ÉÏÀ­
		GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//¸ßËÙ
		GPIO_Initure.Alternate=GPIO_AF7_UART7;	//¸´ÓÃΪUART7
		HAL_GPIO_Init(GPIOF,&GPIO_Initure);	   	//³õʼ»¯PF7

		GPIO_Initure.Pin=GPIO_PIN_6;			//PF6
		HAL_GPIO_Init(GPIOF,&GPIO_Initure);	   	//³õʼ»¯PF6
		
#if EN_UART7_RX
		HAL_NVIC_EnableIRQ(UART7_IRQn);				//ʹÄÜUSART6ÖжÏͨµÀ
		HAL_NVIC_SetPriority(UART7_IRQn,3,3);			//ÇÀÕ¼ÓÅÏȼ¶3£¬×ÓÓÅÏȼ¶3
#endif	
	}
	
  if(huart->Instance==UART8)//Èç¹ûÊÇ´®¿Ú8£¬½øÐд®¿Ú8MSP³õʼ»¯
	{
		__HAL_RCC_GPIOE_CLK_ENABLE();			//ʹÄÜGPIOEʱÖÓ
		__HAL_RCC_UART8_CLK_ENABLE();			//ʹÄÜUART8ʱÖÓ
	
		GPIO_Initure.Pin=GPIO_PIN_1;			//PE1
		GPIO_Initure.Mode=GPIO_MODE_AF_PP;		//¸´ÓÃÍÆÍìÊä³ö
		GPIO_Initure.Pull=GPIO_PULLUP;			//ÉÏÀ­
		GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//¸ßËÙ
		GPIO_Initure.Alternate=GPIO_AF8_UART8;	//¸´ÓÃΪUART8
		HAL_GPIO_Init(GPIOE,&GPIO_Initure);	   	//³õʼ»¯PE1

		GPIO_Initure.Pin=GPIO_PIN_0;			//PE0
		HAL_GPIO_Init(GPIOE,&GPIO_Initure);	   	//³õʼ»¯PE0
		
#if EN_UART8_RX
		HAL_NVIC_EnableIRQ(UART8_IRQn);				//ʹÄÜUART8ÖжÏͨµÀ
		HAL_NVIC_SetPriority(UART8_IRQn,3,3);			//ÇÀÕ¼ÓÅÏȼ¶3£¬×ÓÓÅÏȼ¶3
#endif	
	}

}

最后是回调函数：

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart->Instance==USART1)//Èç¹ûÊÇ´®¿Ú1
	{				

       ;
	}
	
	if(huart->Instance==USART2)//Èç¹ûÊÇ´®¿Ú2
	{
       ;
	}

  if(huart->Instance==USART3)//ÉÏλ»úÊý¾Ý½ÓÊÕ´¦Àí£¬2023Äê12ÔÂ4ÈÕ10:53:15
	{
       ;
	}	
	
	if(huart->Instance==UART4)//ÉÏλ»úÊý¾Ý½ÓÊÕ´¦Àí£¬2023Äê12ÔÂ4ÈÕ10:53:15
	{
       ;
	}	
	
	if(huart->Instance==UART5)//ÉÏλ»úÊý¾Ý½ÓÊÕ´¦Àí£¬2023Äê12ÔÂ4ÈÕ10:53:15
	{
        ;
	}	
	
	if(huart->Instance==USART6)//ÉÏλ»úÊý¾Ý½ÓÊÕ´¦Àí£¬2023Äê12ÔÂ4ÈÕ10:53:15
	{
        ;
	}	
	
	if(huart->Instance==UART7)//ÉÏλ»úÊý¾Ý½ÓÊÕ´¦Àí£¬2023Äê12ÔÂ4ÈÕ10:53:15
	{
       ;
	}	
	
	if(huart->Instance==UART8)//ÉÏλ»úÊý¾Ý½ÓÊÕ´¦Àí£¬2023Äê12ÔÂ4ÈÕ10:53:15
	{
        ;
	}	
}

DMA初始化

#include "dma.h"
#include "usart.h"


DMA_HandleTypeDef  UART1TxDMA_Handler;      //DMA¾ä±ú¡£´®¿Ú1´«Êä
DMA_HandleTypeDef  UART2TxDMA_Handler;      //DMA¾ä±ú¡£´®¿Ú2´«Êä
DMA_HandleTypeDef  UART3TxDMA_Handler;      //DMA¾ä±ú¡£´®¿Ú3´«Êä
DMA_HandleTypeDef  UART4TxDMA_Handler;      //DMA¾ä±ú¡£´®¿Ú4´«Êä
DMA_HandleTypeDef  UART5TxDMA_Handler;      //DMA¾ä±ú¡£´®¿Ú5´«Êä
DMA_HandleTypeDef  UART6TxDMA_Handler;      //DMA¾ä±ú¡£´®¿Ú5´«Êä
DMA_HandleTypeDef  UART7TxDMA_Handler;      //DMA¾ä±ú¡£´®¿Ú5´«Êä
DMA_HandleTypeDef  UART8TxDMA_Handler;      //DMA¾ä±ú¡£´®¿Ú5´«Êä

//DMAxµÄ¸÷ͨµÀÅäÖÃ
//ÕâÀïµÄ´«ÊäÐÎʽÊǹ̶¨µÄ,ÕâµãÒª¸ù¾Ý²»Í¬µÄÇé¿öÀ´ÐÞ¸Ä
//´Ó´æ´¢Æ÷->ÍâÉèģʽ/8λÊý¾Ý¿í¶È/´æ´¢Æ÷ÔöÁ¿Ä£Ê½
//DMA_Streamx:DMAÊý¾ÝÁ÷,DMA1_Stream0~7/DMA2_Stream0~7
void MYDMA_Config(DMA_Stream_TypeDef *DMA_Streamx)
{ 
	if((u32)DMA_Streamx>(u32)DMA2)//µÃµ½µ±Ç°streamÊÇÊôÓÚDMA2»¹ÊÇDMA1
	{
        __HAL_RCC_DMA2_CLK_ENABLE();//DMA2ʱÖÓʹÄÜ	
	}else 
	{
        __HAL_RCC_DMA1_CLK_ENABLE();//DMA1ʱÖÓʹÄÜ 
	}
    
    __HAL_LINKDMA(&UART1_Handler,hdmatx,UART1TxDMA_Handler);    //½«DMAÓëUSART1ÁªÏµÆðÀ´(·¢ËÍDMA)
    
    //Tx DMAÅäÖÃ
    UART1TxDMA_Handler.Instance=DMA_Streamx;                            //Êý¾ÝÁ÷Ñ¡Ôñ
	  UART1TxDMA_Handler.Init.Request=DMA_REQUEST_USART1_TX;				//USART1·¢ËÍDMA
    UART1TxDMA_Handler.Init.Direction=DMA_MEMORY_TO_PERIPH;             //´æ´¢Æ÷µ½ÍâÉè
    UART1TxDMA_Handler.Init.PeriphInc=DMA_PINC_DISABLE;                 //ÍâÉè·ÇÔöÁ¿Ä£Ê½
    UART1TxDMA_Handler.Init.MemInc=DMA_MINC_ENABLE;                     //´æ´¢Æ÷ÔöÁ¿Ä£Ê½
    UART1TxDMA_Handler.Init.PeriphDataAlignment=DMA_PDATAALIGN_BYTE;    //ÍâÉèÊý¾Ý³¤¶È:8λ
    UART1TxDMA_Handler.Init.MemDataAlignment=DMA_MDATAALIGN_BYTE;       //´æ´¢Æ÷Êý¾Ý³¤¶È:8λ
    UART1TxDMA_Handler.Init.Mode=DMA_NORMAL;                            //ÍâÉèÁ÷¿Øģʽ
    UART1TxDMA_Handler.Init.Priority=DMA_PRIORITY_MEDIUM;               //ÖеÈÓÅÏȼ¶
    UART1TxDMA_Handler.Init.FIFOMode=DMA_FIFOMODE_DISABLE;              
    UART1TxDMA_Handler.Init.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL;      
    UART1TxDMA_Handler.Init.MemBurst=DMA_MBURST_SINGLE;                 //´æ´¢Æ÷Í»·¢µ¥´Î´«Êä
    UART1TxDMA_Handler.Init.PeriphBurst=DMA_PBURST_SINGLE;              //ÍâÉèÍ»·¢µ¥´Î´«Êä
    
    HAL_DMA_DeInit(&UART1TxDMA_Handler);   
    HAL_DMA_Init(&UART1TxDMA_Handler);
	
} 

//DMAxµÄ¸÷ͨµÀÅäÖÃ
//ÕâÀïµÄ´«ÊäÐÎʽÊǹ̶¨µÄ,ÕâµãÒª¸ù¾Ý²»Í¬µÄÇé¿öÀ´ÐÞ¸Ä
//´Ó´æ´¢Æ÷->ÍâÉèģʽ/8λÊý¾Ý¿í¶È/´æ´¢Æ÷ÔöÁ¿Ä£Ê½
//DMA_Streamx:DMAÊý¾ÝÁ÷,DMA1_Stream0~7/DMA2_Stream0~7
void MYDMA_Config2(DMA_Stream_TypeDef *DMA_Streamx)
{ 
//	if((u32)DMA_Streamx>(u32)DMA2)//µÃµ½µ±Ç°streamÊÇÊôÓÚDMA2»¹ÊÇDMA1
//	{
//        __HAL_RCC_DMA2_CLK_ENABLE();//DMA2ʱÖÓʹÄÜ	
//	}else 
//	{
        __HAL_RCC_DMA1_CLK_ENABLE();//DMA1ʱÖÓʹÄÜ 
//	}
    
    __HAL_LINKDMA(&UART3_Handler,hdmatx,UART3TxDMA_Handler);    //½«DMAÓëUSART3ÁªÏµÆðÀ´(·¢ËÍDMA)
    
    //Tx DMAÅäÖÃ
    UART3TxDMA_Handler.Instance=DMA_Streamx;                            //Êý¾ÝÁ÷Ñ¡Ôñ
	  UART3TxDMA_Handler.Init.Request=DMA_REQUEST_USART3_TX;				//USART1·¢ËÍDMA
    UART3TxDMA_Handler.Init.Direction=DMA_MEMORY_TO_PERIPH;             //´æ´¢Æ÷µ½ÍâÉè
    UART3TxDMA_Handler.Init.PeriphInc=DMA_PINC_DISABLE;                 //ÍâÉè·ÇÔöÁ¿Ä£Ê½
    UART3TxDMA_Handler.Init.MemInc=DMA_MINC_ENABLE;                     //´æ´¢Æ÷ÔöÁ¿Ä£Ê½
    UART3TxDMA_Handler.Init.PeriphDataAlignment=DMA_PDATAALIGN_BYTE;    //ÍâÉèÊý¾Ý³¤¶È:8λ
    UART3TxDMA_Handler.Init.MemDataAlignment=DMA_MDATAALIGN_BYTE;       //´æ´¢Æ÷Êý¾Ý³¤¶È:8λ
    UART3TxDMA_Handler.Init.Mode=DMA_NORMAL;                            //ÍâÉèÁ÷¿Øģʽ
    UART3TxDMA_Handler.Init.Priority=DMA_PRIORITY_MEDIUM;               //ÖеÈÓÅÏȼ¶
    UART3TxDMA_Handler.Init.FIFOMode=DMA_FIFOMODE_DISABLE;              
    UART3TxDMA_Handler.Init.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL;      
    UART3TxDMA_Handler.Init.MemBurst=DMA_MBURST_SINGLE;                 //´æ´¢Æ÷Í»·¢µ¥´Î´«Êä
    UART3TxDMA_Handler.Init.PeriphBurst=DMA_PBURST_SINGLE;              //ÍâÉèÍ»·¢µ¥´Î´«Êä
    
    HAL_DMA_DeInit(&UART3TxDMA_Handler);   
    HAL_DMA_Init(&UART3TxDMA_Handler);
} 

//DMAxµÄ¸÷ͨµÀÅäÖÃ
//ÕâÀïµÄ´«ÊäÐÎʽÊǹ̶¨µÄ,ÕâµãÒª¸ù¾Ý²»Í¬µÄÇé¿öÀ´ÐÞ¸Ä
//´Ó´æ´¢Æ÷->ÍâÉèģʽ/8λÊý¾Ý¿í¶È/´æ´¢Æ÷ÔöÁ¿Ä£Ê½
//DMA_Streamx:DMAÊý¾ÝÁ÷,DMA1_Stream0~7/DMA2_Stream0~7
void MYDMA_Config3(DMA_Stream_TypeDef *DMA_Streamx)
{ 
//	if((u32)DMA_Streamx>(u32)DMA2)//µÃµ½µ±Ç°streamÊÇÊôÓÚDMA2»¹ÊÇDMA1
//	{
//        __HAL_RCC_DMA2_CLK_ENABLE();//DMA2ʱÖÓʹÄÜ	
//	}else 
//	{
        __HAL_RCC_DMA1_CLK_ENABLE();//DMA1ʱÖÓʹÄÜ 
//	}
    
    __HAL_LINKDMA(&UART2_Handler,hdmatx,UART2TxDMA_Handler);    //½«DMAÓëUSART2ÁªÏµÆðÀ´(·¢ËÍDMA)
    
    //Tx DMAÅäÖÃ
    UART2TxDMA_Handler.Instance=DMA_Streamx;                            //Êý¾ÝÁ÷Ñ¡Ôñ
	  UART2TxDMA_Handler.Init.Request=DMA_REQUEST_USART2_TX;				//USART1·¢ËÍDMA
    UART2TxDMA_Handler.Init.Direction=DMA_MEMORY_TO_PERIPH;             //´æ´¢Æ÷µ½ÍâÉè
    UART2TxDMA_Handler.Init.PeriphInc=DMA_PINC_DISABLE;                 //ÍâÉè·ÇÔöÁ¿Ä£Ê½
    UART2TxDMA_Handler.Init.MemInc=DMA_MINC_ENABLE;                     //´æ´¢Æ÷ÔöÁ¿Ä£Ê½
    UART2TxDMA_Handler.Init.PeriphDataAlignment=DMA_PDATAALIGN_BYTE;    //ÍâÉèÊý¾Ý³¤¶È:8λ
    UART2TxDMA_Handler.Init.MemDataAlignment=DMA_MDATAALIGN_BYTE;       //´æ´¢Æ÷Êý¾Ý³¤¶È:8λ
    UART2TxDMA_Handler.Init.Mode=DMA_NORMAL;                            //ÍâÉèÁ÷¿Øģʽ
    UART2TxDMA_Handler.Init.Priority=DMA_PRIORITY_MEDIUM;               //ÖеÈÓÅÏȼ¶
    UART2TxDMA_Handler.Init.FIFOMode=DMA_FIFOMODE_DISABLE;              
    UART2TxDMA_Handler.Init.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL;      
    UART2TxDMA_Handler.Init.MemBurst=DMA_MBURST_SINGLE;                 //´æ´¢Æ÷Í»·¢µ¥´Î´«Êä
    UART2TxDMA_Handler.Init.PeriphBurst=DMA_PBURST_SINGLE;              //ÍâÉèÍ»·¢µ¥´Î´«Êä
    
    HAL_DMA_DeInit(&UART2TxDMA_Handler);   
    HAL_DMA_Init(&UART2TxDMA_Handler);
} 

//DMAxµÄ¸÷ͨµÀÅäÖÃ
//ÕâÀïµÄ´«ÊäÐÎʽÊǹ̶¨µÄ,ÕâµãÒª¸ù¾Ý²»Í¬µÄÇé¿öÀ´ÐÞ¸Ä
//´Ó´æ´¢Æ÷->ÍâÉèģʽ/8λÊý¾Ý¿í¶È/´æ´¢Æ÷ÔöÁ¿Ä£Ê½
//DMA_Streamx:DMAÊý¾ÝÁ÷,DMA1_Stream0~7/DMA2_Stream0~7
void MYDMA_Config4(DMA_Stream_TypeDef *DMA_Streamx)
{ 
//	if((u32)DMA_Streamx>(u32)DMA2)//µÃµ½µ±Ç°streamÊÇÊôÓÚDMA2»¹ÊÇDMA1
//	{
//        __HAL_RCC_DMA2_CLK_ENABLE();//DMA2ʱÖÓʹÄÜ	
//	}else 
//	{
        __HAL_RCC_DMA1_CLK_ENABLE();//DMA1ʱÖÓʹÄÜ 
//	}
    
    __HAL_LINKDMA(&UART4_Handler,hdmatx,UART4TxDMA_Handler);    //½«DMAÓëUSART2ÁªÏµÆðÀ´(·¢ËÍDMA)
    
    //Tx DMAÅäÖÃ
    UART4TxDMA_Handler.Instance=DMA_Streamx;                            //Êý¾ÝÁ÷Ñ¡Ôñ
	  UART4TxDMA_Handler.Init.Request=DMA_REQUEST_UART4_TX;				//UART4·¢ËÍDMA
    UART4TxDMA_Handler.Init.Direction=DMA_MEMORY_TO_PERIPH;             //´æ´¢Æ÷µ½ÍâÉè
    UART4TxDMA_Handler.Init.PeriphInc=DMA_PINC_DISABLE;                 //ÍâÉè·ÇÔöÁ¿Ä£Ê½
    UART4TxDMA_Handler.Init.MemInc=DMA_MINC_ENABLE;                     //´æ´¢Æ÷ÔöÁ¿Ä£Ê½
    UART4TxDMA_Handler.Init.PeriphDataAlignment=DMA_PDATAALIGN_BYTE;    //ÍâÉèÊý¾Ý³¤¶È:8λ
    UART4TxDMA_Handler.Init.MemDataAlignment=DMA_MDATAALIGN_BYTE;       //´æ´¢Æ÷Êý¾Ý³¤¶È:8λ
    UART4TxDMA_Handler.Init.Mode=DMA_NORMAL;                            //ÍâÉèÁ÷¿Øģʽ
    UART4TxDMA_Handler.Init.Priority=DMA_PRIORITY_MEDIUM;               //ÖеÈÓÅÏȼ¶
    UART4TxDMA_Handler.Init.FIFOMode=DMA_FIFOMODE_DISABLE;              
    UART4TxDMA_Handler.Init.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL;      
    UART4TxDMA_Handler.Init.MemBurst=DMA_MBURST_SINGLE;                 //´æ´¢Æ÷Í»·¢µ¥´Î´«Êä
    UART4TxDMA_Handler.Init.PeriphBurst=DMA_PBURST_SINGLE;              //ÍâÉèÍ»·¢µ¥´Î´«Êä
    
    HAL_DMA_DeInit(&UART4TxDMA_Handler);   
    HAL_DMA_Init(&UART4TxDMA_Handler);
} 


//DMAxµÄ¸÷ͨµÀÅäÖÃ
//ÕâÀïµÄ´«ÊäÐÎʽÊǹ̶¨µÄ,ÕâµãÒª¸ù¾Ý²»Í¬µÄÇé¿öÀ´ÐÞ¸Ä
//´Ó´æ´¢Æ÷->ÍâÉèģʽ/8λÊý¾Ý¿í¶È/´æ´¢Æ÷ÔöÁ¿Ä£Ê½
//DMA_Streamx:DMAÊý¾ÝÁ÷,DMA1_Stream0~7/DMA2_Stream0~7
void MYDMA_Config5(DMA_Stream_TypeDef *DMA_Streamx)
{ 
//	if((u32)DMA_Streamx>(u32)DMA2)//µÃµ½µ±Ç°streamÊÇÊôÓÚDMA2»¹ÊÇDMA1
//	{
//        __HAL_RCC_DMA2_CLK_ENABLE();//DMA2ʱÖÓʹÄÜ	
//	}else 
//	{
        __HAL_RCC_DMA1_CLK_ENABLE();//DMA1ʱÖÓʹÄÜ 
//	}
    
    __HAL_LINKDMA(&UART5_Handler,hdmatx,UART5TxDMA_Handler);    //½«DMAÓëUSART2ÁªÏµÆðÀ´(·¢ËÍDMA)
    
    //Tx DMAÅäÖÃ
    UART5TxDMA_Handler.Instance=DMA_Streamx;                            //Êý¾ÝÁ÷Ñ¡Ôñ
	  UART5TxDMA_Handler.Init.Request=DMA_REQUEST_UART5_TX;				//UART4·¢ËÍDMA
    UART5TxDMA_Handler.Init.Direction=DMA_MEMORY_TO_PERIPH;             //´æ´¢Æ÷µ½ÍâÉè
    UART5TxDMA_Handler.Init.PeriphInc=DMA_PINC_DISABLE;                 //ÍâÉè·ÇÔöÁ¿Ä£Ê½
    UART5TxDMA_Handler.Init.MemInc=DMA_MINC_ENABLE;                     //´æ´¢Æ÷ÔöÁ¿Ä£Ê½
    UART5TxDMA_Handler.Init.PeriphDataAlignment=DMA_PDATAALIGN_BYTE;    //ÍâÉèÊý¾Ý³¤¶È:8λ
    UART5TxDMA_Handler.Init.MemDataAlignment=DMA_MDATAALIGN_BYTE;       //´æ´¢Æ÷Êý¾Ý³¤¶È:8λ
    UART5TxDMA_Handler.Init.Mode=DMA_NORMAL;                            //ÍâÉèÁ÷¿Øģʽ
    UART5TxDMA_Handler.Init.Priority=DMA_PRIORITY_MEDIUM;               //ÖеÈÓÅÏȼ¶
    UART5TxDMA_Handler.Init.FIFOMode=DMA_FIFOMODE_DISABLE;              
    UART5TxDMA_Handler.Init.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL;      
    UART5TxDMA_Handler.Init.MemBurst=DMA_MBURST_SINGLE;                 //´æ´¢Æ÷Í»·¢µ¥´Î´«Êä
    UART5TxDMA_Handler.Init.PeriphBurst=DMA_PBURST_SINGLE;              //ÍâÉèÍ»·¢µ¥´Î´«Êä
    
    HAL_DMA_DeInit(&UART5TxDMA_Handler);   
    HAL_DMA_Init(&UART5TxDMA_Handler);
} 

//DMAxµÄ¸÷ͨµÀÅäÖÃ
//ÕâÀïµÄ´«ÊäÐÎʽÊǹ̶¨µÄ,ÕâµãÒª¸ù¾Ý²»Í¬µÄÇé¿öÀ´ÐÞ¸Ä
//´Ó´æ´¢Æ÷->ÍâÉèģʽ/8λÊý¾Ý¿í¶È/´æ´¢Æ÷ÔöÁ¿Ä£Ê½
//DMA_Streamx:DMAÊý¾ÝÁ÷,DMA1_Stream0~7/DMA2_Stream0~7
void MYDMA_Config6(DMA_Stream_TypeDef *DMA_Streamx)
{ 
//	if((u32)DMA_Streamx>(u32)DMA2)//µÃµ½µ±Ç°streamÊÇÊôÓÚDMA2»¹ÊÇDMA1
//	{
//        __HAL_RCC_DMA2_CLK_ENABLE();//DMA2ʱÖÓʹÄÜ	
//	}else 
//	{
        __HAL_RCC_DMA1_CLK_ENABLE();//DMA1ʱÖÓʹÄÜ 
//	}
    
    __HAL_LINKDMA(&UART6_Handler,hdmatx,UART6TxDMA_Handler);    //½«DMAÓëUSART2ÁªÏµÆðÀ´(·¢ËÍDMA)
    
    //Tx DMAÅäÖÃ
    UART6TxDMA_Handler.Instance=DMA_Streamx;                            //Êý¾ÝÁ÷Ñ¡Ôñ
	  UART6TxDMA_Handler.Init.Request=DMA_REQUEST_USART6_RX;				//UART4·¢ËÍDMA
    UART6TxDMA_Handler.Init.Direction=DMA_MEMORY_TO_PERIPH;             //´æ´¢Æ÷µ½ÍâÉè
    UART6TxDMA_Handler.Init.PeriphInc=DMA_PINC_DISABLE;                 //ÍâÉè·ÇÔöÁ¿Ä£Ê½
    UART6TxDMA_Handler.Init.MemInc=DMA_MINC_ENABLE;                     //´æ´¢Æ÷ÔöÁ¿Ä£Ê½
    UART6TxDMA_Handler.Init.PeriphDataAlignment=DMA_PDATAALIGN_BYTE;    //ÍâÉèÊý¾Ý³¤¶È:8λ
    UART6TxDMA_Handler.Init.MemDataAlignment=DMA_MDATAALIGN_BYTE;       //´æ´¢Æ÷Êý¾Ý³¤¶È:8λ
    UART6TxDMA_Handler.Init.Mode=DMA_NORMAL;                            //ÍâÉèÁ÷¿Øģʽ
    UART6TxDMA_Handler.Init.Priority=DMA_PRIORITY_MEDIUM;               //ÖеÈÓÅÏȼ¶
    UART6TxDMA_Handler.Init.FIFOMode=DMA_FIFOMODE_DISABLE;              
    UART6TxDMA_Handler.Init.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL;      
    UART6TxDMA_Handler.Init.MemBurst=DMA_MBURST_SINGLE;                 //´æ´¢Æ÷Í»·¢µ¥´Î´«Êä
    UART6TxDMA_Handler.Init.PeriphBurst=DMA_PBURST_SINGLE;              //ÍâÉèÍ»·¢µ¥´Î´«Êä
    
    HAL_DMA_DeInit(&UART6TxDMA_Handler);   
    HAL_DMA_Init(&UART6TxDMA_Handler);
} 

//DMAxµÄ¸÷ͨµÀÅäÖÃ
//ÕâÀïµÄ´«ÊäÐÎʽÊǹ̶¨µÄ,ÕâµãÒª¸ù¾Ý²»Í¬µÄÇé¿öÀ´ÐÞ¸Ä
//´Ó´æ´¢Æ÷->ÍâÉèģʽ/8λÊý¾Ý¿í¶È/´æ´¢Æ÷ÔöÁ¿Ä£Ê½
//DMA_Streamx:DMAÊý¾ÝÁ÷,DMA1_Stream0~7/DMA2_Stream0~7
void MYDMA_Config7(DMA_Stream_TypeDef *DMA_Streamx)
{ 
//	if((u32)DMA_Streamx>(u32)DMA2)//µÃµ½µ±Ç°streamÊÇÊôÓÚDMA2»¹ÊÇDMA1
//	{
        __HAL_RCC_DMA2_CLK_ENABLE();//DMA2ʱÖÓʹÄÜ	
//	}else 
//	{
//        __HAL_RCC_DMA1_CLK_ENABLE();//DMA1ʱÖÓʹÄÜ 
//	}
    
    __HAL_LINKDMA(&UART7_Handler,hdmatx,UART7TxDMA_Handler);    //½«DMAÓëUSART2ÁªÏµÆðÀ´(·¢ËÍDMA)
    
    //Tx DMAÅäÖÃ
    UART7TxDMA_Handler.Instance=DMA_Streamx;                            //Êý¾ÝÁ÷Ñ¡Ôñ
	  UART7TxDMA_Handler.Init.Request=DMA_REQUEST_UART7_RX;				//UART4·¢ËÍDMA
    UART7TxDMA_Handler.Init.Direction=DMA_MEMORY_TO_PERIPH;             //´æ´¢Æ÷µ½ÍâÉè
    UART7TxDMA_Handler.Init.PeriphInc=DMA_PINC_DISABLE;                 //ÍâÉè·ÇÔöÁ¿Ä£Ê½
    UART7TxDMA_Handler.Init.MemInc=DMA_MINC_ENABLE;                     //´æ´¢Æ÷ÔöÁ¿Ä£Ê½
    UART7TxDMA_Handler.Init.PeriphDataAlignment=DMA_PDATAALIGN_BYTE;    //ÍâÉèÊý¾Ý³¤¶È:8λ
    UART7TxDMA_Handler.Init.MemDataAlignment=DMA_MDATAALIGN_BYTE;       //´æ´¢Æ÷Êý¾Ý³¤¶È:8λ
    UART7TxDMA_Handler.Init.Mode=DMA_NORMAL;                            //ÍâÉèÁ÷¿Øģʽ
    UART7TxDMA_Handler.Init.Priority=DMA_PRIORITY_MEDIUM;               //ÖеÈÓÅÏȼ¶
    UART7TxDMA_Handler.Init.FIFOMode=DMA_FIFOMODE_DISABLE;              
    UART7TxDMA_Handler.Init.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL;      
    UART7TxDMA_Handler.Init.MemBurst=DMA_MBURST_SINGLE;                 //´æ´¢Æ÷Í»·¢µ¥´Î´«Êä
    UART7TxDMA_Handler.Init.PeriphBurst=DMA_PBURST_SINGLE;              //ÍâÉèÍ»·¢µ¥´Î´«Êä
    
    HAL_DMA_DeInit(&UART7TxDMA_Handler);   
    HAL_DMA_Init(&UART7TxDMA_Handler);
} 

//DMAxµÄ¸÷ͨµÀÅäÖÃ
//ÕâÀïµÄ´«ÊäÐÎʽÊǹ̶¨µÄ,ÕâµãÒª¸ù¾Ý²»Í¬µÄÇé¿öÀ´ÐÞ¸Ä
//´Ó´æ´¢Æ÷->ÍâÉèģʽ/8λÊý¾Ý¿í¶È/´æ´¢Æ÷ÔöÁ¿Ä£Ê½
//DMA_Streamx:DMAÊý¾ÝÁ÷,DMA1_Stream0~7/DMA2_Stream0~7
void MYDMA_Config8(DMA_Stream_TypeDef *DMA_Streamx)
{ 
//	if((u32)DMA_Streamx>(u32)DMA2)//µÃµ½µ±Ç°streamÊÇÊôÓÚDMA2»¹ÊÇDMA1
//	{
        __HAL_RCC_DMA2_CLK_ENABLE();//DMA2ʱÖÓʹÄÜ	
//	}else 
//	{
//        __HAL_RCC_DMA1_CLK_ENABLE();//DMA1ʱÖÓʹÄÜ 
//	}
    
    __HAL_LINKDMA(&UART8_Handler,hdmatx,UART8TxDMA_Handler);    //½«DMAÓëUSART2ÁªÏµÆðÀ´(·¢ËÍDMA)
    
    //Tx DMAÅäÖÃ
    UART8TxDMA_Handler.Instance=DMA_Streamx;                            //Êý¾ÝÁ÷Ñ¡Ôñ
	  UART8TxDMA_Handler.Init.Request=DMA_REQUEST_UART8_RX;				//UART8·¢ËÍDMA
    UART8TxDMA_Handler.Init.Direction=DMA_MEMORY_TO_PERIPH;             //´æ´¢Æ÷µ½ÍâÉè
    UART8TxDMA_Handler.Init.PeriphInc=DMA_PINC_DISABLE;                 //ÍâÉè·ÇÔöÁ¿Ä£Ê½
    UART8TxDMA_Handler.Init.MemInc=DMA_MINC_ENABLE;                     //´æ´¢Æ÷ÔöÁ¿Ä£Ê½
    UART8TxDMA_Handler.Init.PeriphDataAlignment=DMA_PDATAALIGN_BYTE;    //ÍâÉèÊý¾Ý³¤¶È:8λ
    UART8TxDMA_Handler.Init.MemDataAlignment=DMA_MDATAALIGN_BYTE;       //´æ´¢Æ÷Êý¾Ý³¤¶È:8λ
    UART8TxDMA_Handler.Init.Mode=DMA_NORMAL;                            //ÍâÉèÁ÷¿Øģʽ
    UART8TxDMA_Handler.Init.Priority=DMA_PRIORITY_MEDIUM;               //ÖеÈÓÅÏȼ¶
    UART8TxDMA_Handler.Init.FIFOMode=DMA_FIFOMODE_DISABLE;              
    UART8TxDMA_Handler.Init.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL;      
    UART8TxDMA_Handler.Init.MemBurst=DMA_MBURST_SINGLE;                 //´æ´¢Æ÷Í»·¢µ¥´Î´«Êä
    UART8TxDMA_Handler.Init.PeriphBurst=DMA_PBURST_SINGLE;              //ÍâÉèÍ»·¢µ¥´Î´«Êä
    
    HAL_DMA_DeInit(&UART8TxDMA_Handler);   
    HAL_DMA_Init(&UART8TxDMA_Handler);
} 


 
 

这样就可以使用DMA进行串口数据的发送了，注意映射关系！！！