求助，STM32F4串口2使用DMA时遇到的问题

iSTM32 · 发表于 2021-7-5 11:13:41

STM32F446想在串口2上开启DMA，跟串口1配置的类似，DMA映射也确认过，但是就是跑不起来，想请教下各位是哪里有问题，贴出代码如下，串口1的配置已经注释，感谢

#include "usart.h"
#include "string.h"
#include <stdarg.h>
//////////////////////////////////////////////////////////////////////////////////
//如果使用os,则包括下面的头文件即可.
#if SYSTEM_SUPPORT_OS
#include "includes.h" //os 使用
#endif
//////////////////////////////////////////////////////////////////////////////////
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
//ALIENTEK STM32F7开发板
//串口1初始化
//正点原子@ALIENTEK
//技术论坛:www.openedv.com
//修改日期:2015/6/23
//版本：V1.5
//版权所有，盗版必究。
//Copyright(C) 广州市星翼电子科技有限公司 2009-2019
//All rights reserved
//********************************************************************************
//V1.0修改说明
//////////////////////////////////////////////////////////////////////////////////
//通过外部拨动按键开关选择工作模式
//高电平：WiFi模式
//低电平：USB模式
u8 Work_Mode;
void Working_Mode_Init(void)
{
GPIO_InitTypeDef GPIO_Initure;
__HAL_RCC_GPIOB_CLK_ENABLE(); //开启GPIOB时钟
GPIO_Initure.Pin=GPIO_PIN_3; //PB3
GPIO_Initure.Mode=GPIO_MODE_INPUT; //输入
GPIO_Initure.Pull=GPIO_PULLUP; //上拉
GPIO_Initure.Speed=GPIO_SPEED_HIGH; //高速
HAL_GPIO_Init(GPIOB,&GPIO_Initure);
}
//加入以下代码,支持printf函数,而不需要选择use MicroLIB
//#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#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)
{
Work_Mode=HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_3);
if(Work_Mode==0)
{
while((USART1->SR&0X40)==0);//串口1循环发送,直到发送完毕
USART1->DR = (u8) ch;
}
if(Work_Mode==1)
{
while((USART2->SR&0X40)==0);//串口2循环发送,直到发送完毕
USART2->DR = (u8) ch;
}
return ch;
}
#endif
/*****************************************************************************/
/*
UART_HandleTypeDef UART1_Handler; //UART1句柄
DMA_HandleTypeDef DMA_UART1_RX; //UART1接收的DMA句柄
DMA_HandleTypeDef DMA_UART1_TX; //UART1发送的DMA句柄
u8 command[USART_DMA_RX_BUFFER_MAXIMUM];
uint8_t usart1_rx_buffer[USART_DMA_RX_BUFFER_MAXIMUM]; //串口1的DMA接收缓冲区
uint8_t usart1_tx_buffer[USART_DMA_TX_BUFFER_MAXIMUM]; //串口1的DMA发送缓冲区
uint8_t usart1_rx_flag = 0; //DMA接收成功标志 0，未接收到/1,,接收到等待处理
uint16_t usart1_rx_len = 0; //DMA一次空闲中断接收到的数据长度
//初始化IO 串口1
//bound:波特率
void uart1_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); //初始化使能UART1
//开启空闲接收中断
__HAL_UART_ENABLE_IT(&UART1_Handler, UART_IT_IDLE);
//打开DMA接收，指定接收缓存区和接收大小
HAL_UART_Receive_DMA(&UART1_Handler, (uint8_t *)&usart1_rx_buffer, USART_DMA_RX_BUFFER_MAXIMUM);
}
*/
UART_HandleTypeDef UART2_Handler; //UART2句柄
DMA_HandleTypeDef DMA_UART2_RX; //UART2接收的DMA句柄
DMA_HandleTypeDef DMA_UART2_TX; //UART2发送的DMA句柄
u8 connect_num=0;
u8 start_num=0;
u8 command[USART_DMA_RX_BUFFER_MAXIMUM];
uint8_t usart2_rx_buffer[USART_DMA_RX_BUFFER_MAXIMUM]; //串口2的DMA接收缓冲区
uint8_t usart2_tx_buffer[USART_DMA_TX_BUFFER_MAXIMUM]; //串口2的DMA发送缓冲区
uint8_t usart2_rx_flag = 0; //DMA接收成功标志 0，未接收到/1,,接收到等待处理
uint16_t usart2_rx_len = 0; //DMA一次空闲中断接收到的数据长度
//初始化IO 串口2
//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); //初始化使能UART2
//开启空闲接收中断
__HAL_UART_ENABLE_IT(&UART2_Handler, UART_IT_IDLE);
//打开DMA接收，指定接收缓存区和接收大小
HAL_UART_Receive_DMA(&UART2_Handler, (uint8_t *)&usart2_rx_buffer, USART_DMA_RX_BUFFER_MAXIMUM);
}
//UART底层初始化，时钟使能，引脚配置，中断配置
//此函数会被HAL_UART_Init()调用
//huart:串口句柄
void HAL_UART_MspInit(UART_HandleTypeDef *huart) //在这里重写HAL_UART_MspInit函数
{
//GPIO端口设置
GPIO_InitTypeDef GPIO_Initure;
/*
if(huart->Instance==USART1)//如果是串口1，进行串口1 MSP初始化
{
//时钟使能
__HAL_RCC_GPIOA_CLK_ENABLE(); //使能GPIOA时钟
__HAL_RCC_USART1_CLK_ENABLE(); //使能USART1时钟
__HAL_RCC_DMA2_CLK_ENABLE(); //使能DMA2时钟
//端口初始化
GPIO_Initure.Pin = GPIO_PIN_9; //PA9
GPIO_Initure.Mode = GPIO_MODE_AF_PP; //复用推挽输出
GPIO_Initure.Pull = GPIO_PULLUP; //上拉
GPIO_Initure.Speed = GPIO_SPEED_FAST; //高速
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
//USART1_RX DMA初始化
DMA_UART1_RX.Instance = DMA2_Stream5;
DMA_UART1_RX.Init.Channel = DMA_CHANNEL_4; //通道选择
DMA_UART1_RX.Init.Direction = DMA_PERIPH_TO_MEMORY; //从外设到内存
DMA_UART1_RX.Init.PeriphInc = DMA_PINC_DISABLE; //外设地址寄存器不变
DMA_UART1_RX.Init.MemInc = DMA_MINC_ENABLE; //内存地址寄存器递增
DMA_UART1_RX.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; //外设地址宽度8位
DMA_UART1_RX.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; //内存地址宽度8位
DMA_UART1_RX.Init.Mode = DMA_NORMAL; //正常模式（即一次传输完成后，需重新状态该通道）
DMA_UART1_RX.Init.Priority = DMA_PRIORITY_LOW; //通道优先级低
DMA_UART1_RX.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
DMA_UART1_RX.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
DMA_UART1_RX.Init.MemBurst = DMA_MBURST_SINGLE; //存储器突发单次传输
DMA_UART1_RX.Init.PeriphBurst = DMA_PBURST_SINGLE; //外设突发单次传输
HAL_DMA_Init(&DMA_UART1_RX);
__HAL_LINKDMA(huart, hdmarx, DMA_UART1_RX);
//USART1_TX DMA初始化
DMA_UART1_TX.Instance = DMA2_Stream7;
DMA_UART1_TX.Init.Channel = DMA_CHANNEL_4; //通道选择
DMA_UART1_TX.Init.Direction = DMA_MEMORY_TO_PERIPH; //从内存到外设
DMA_UART1_TX.Init.PeriphInc = DMA_PINC_DISABLE; //外设地址寄存器不变
DMA_UART1_TX.Init.MemInc = DMA_MINC_ENABLE; //内存地址寄存器递增
DMA_UART1_TX.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; //外设地址宽度8位
DMA_UART1_TX.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; //内存地址宽度8位
DMA_UART1_TX.Init.Mode = DMA_NORMAL; //正常模式
DMA_UART1_TX.Init.Priority = DMA_PRIORITY_LOW; //通道优先级低
DMA_UART1_TX.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
DMA_UART1_TX.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
DMA_UART1_TX.Init.MemBurst = DMA_MBURST_SINGLE; //存储器突发单次传输
DMA_UART1_TX.Init.PeriphBurst = DMA_PBURST_SINGLE; //外设突发单次传输
HAL_DMA_Init(&DMA_UART1_TX);
__HAL_LINKDMA(huart, hdmatx, DMA_UART1_TX);
//关闭USART2中断
HAL_NVIC_DisableIRQ(USART2_IRQn);
//USART1中断和优先级配置
HAL_NVIC_EnableIRQ(USART1_IRQn); //使能USART1中断通道
HAL_NVIC_SetPriority(USART1_IRQn, 3, 3); //抢占优先级3，子优先级3
//USART1的DMA中断和优先级配置
HAL_NVIC_SetPriority(DMA2_Stream7_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn);
HAL_NVIC_SetPriority(DMA2_Stream5_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream5_IRQn);
}
*/
if(huart->Instance==USART2)//如果是串口2，进行串口2 MSP初始化
{
//时钟使能
__HAL_RCC_GPIOA_CLK_ENABLE(); //使能GPIOA时钟
__HAL_RCC_USART2_CLK_ENABLE(); //使能USART2时钟
__HAL_RCC_DMA2_CLK_ENABLE(); //使能DMA2时钟
//端口初始化
GPIO_Initure.Pin = GPIO_PIN_2; //PA2
GPIO_Initure.Mode = GPIO_MODE_AF_PP; //复用推挽输出
GPIO_Initure.Pull = GPIO_PULLUP; //上拉
GPIO_Initure.Speed = GPIO_SPEED_FAST; //高速
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
//USART2_RX DMA初始化
DMA_UART2_RX.Instance = DMA1_Stream5;
DMA_UART2_RX.Init.Channel = DMA_CHANNEL_4; //通道选择
DMA_UART2_RX.Init.Direction = DMA_PERIPH_TO_MEMORY; //从外设到内存
DMA_UART2_RX.Init.PeriphInc = DMA_PINC_DISABLE; //外设地址寄存器不变
DMA_UART2_RX.Init.MemInc = DMA_MINC_ENABLE; //内存地址寄存器递增
DMA_UART2_RX.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; //外设地址宽度8位
DMA_UART2_RX.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; //内存地址宽度8位
DMA_UART2_RX.Init.Mode = DMA_NORMAL; //正常模式（即一次传输完成后，需重新状态该通道）
DMA_UART2_RX.Init.Priority = DMA_PRIORITY_LOW; //通道优先级低
DMA_UART2_RX.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
DMA_UART2_RX.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
DMA_UART2_RX.Init.MemBurst = DMA_MBURST_SINGLE; //存储器突发单次传输
DMA_UART2_RX.Init.PeriphBurst = DMA_PBURST_SINGLE; //外设突发单次传输
HAL_DMA_Init(&DMA_UART2_RX);
__HAL_LINKDMA(huart, hdmarx, DMA_UART2_RX);
//USART2_TX DMA初始化
DMA_UART2_TX.Instance = DMA1_Stream6;
DMA_UART2_TX.Init.Channel = DMA_CHANNEL_4; //通道选择
DMA_UART2_TX.Init.Direction = DMA_MEMORY_TO_PERIPH; //从内存到外设
DMA_UART2_TX.Init.PeriphInc = DMA_PINC_DISABLE; //外设地址寄存器不变
DMA_UART2_TX.Init.MemInc = DMA_MINC_ENABLE; //内存地址寄存器递增
DMA_UART2_TX.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; //外设地址宽度8位
DMA_UART2_TX.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; //内存地址宽度8位
DMA_UART2_TX.Init.Mode = DMA_NORMAL; //正常模式
DMA_UART2_TX.Init.Priority = DMA_PRIORITY_LOW; //通道优先级低
DMA_UART2_TX.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
DMA_UART2_TX.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
DMA_UART2_TX.Init.MemBurst = DMA_MBURST_SINGLE; //存储器突发单次传输
DMA_UART2_TX.Init.PeriphBurst = DMA_PBURST_SINGLE; //外设突发单次传输
HAL_DMA_Init(&DMA_UART2_TX);
__HAL_LINKDMA(huart, hdmatx, DMA_UART2_TX);
//关闭USART1中断
HAL_NVIC_DisableIRQ(USART1_IRQn);
//USART2中断和优先级配置
HAL_NVIC_EnableIRQ(USART2_IRQn); //使能USART2中断通道
HAL_NVIC_SetPriority(USART2_IRQn, 3, 3); //抢占优先级3，子优先级3
//USART2的DMA中断和优先级配置
HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);
HAL_NVIC_SetPriority(DMA1_Stream6_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn);
}
}
//UART底层复位
//此函数会被HAL_UART_DeInit()调用
//huart:串口句柄
void HAL_UART_MspDeInit(UART_HandleTypeDef* huart)
{
/*
if(huart->Instance==USART1)
{
//串口1时钟关闭
__HAL_RCC_USART1_CLK_DISABLE();
//端口复位
HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9|GPIO_PIN_10);
//串口1的DMA关闭
HAL_DMA_DeInit(huart->hdmarx);
HAL_DMA_DeInit(huart->hdmatx);
//串口1中断关闭
HAL_NVIC_DisableIRQ(USART1_IRQn);
}
*/
if(huart->Instance==USART2)
{
//串口2时钟关闭
__HAL_RCC_USART2_CLK_DISABLE();
//端口复位
HAL_GPIO_DeInit(GPIOA, GPIO_PIN_2|GPIO_PIN_3);
//串口2的DMA关闭
HAL_DMA_DeInit(huart->hdmarx);
HAL_DMA_DeInit(huart->hdmatx);
//串口2中断关闭
HAL_NVIC_DisableIRQ(USART2_IRQn);
}
}
/*
//USART1的DMA发送中断
{
HAL_DMA_IRQHandler(&DMA_UART1_TX);
//HAL_DMA_IRQHandler(&DMA_UART2_TX);
}
//USART1的DMA接收中断
void DMA2_Stream5_IRQHandler(void)
{
HAL_DMA_IRQHandler(&DMA_UART1_RX);
//HAL_DMA_IRQHandler(&DMA_UART2_RX);
}
*/
//USART2的DMA发送中断
void DMA1_Stream6_IRQHandler(void)
{
//HAL_DMA_IRQHandler(&DMA_UART1_TX);
HAL_DMA_IRQHandler(&DMA_UART2_TX);
}
//USART2的DMA接收中断
void DMA1_Stream5_IRQHandler(void)
{
//HAL_DMA_IRQHandler(&DMA_UART1_RX);
HAL_DMA_IRQHandler(&DMA_UART2_RX);
}
/*
//串口1的DMA发送
void UART1_TX_DMA_Send(u8 *buffer, u16 length)
{
//等待上一次的数据发送完毕
while(HAL_DMA_GetState(&DMA_UART1_TX) == HAL_DMA_STATE_BUSY);
//关闭DMA
__HAL_DMA_DISABLE(&DMA_UART1_TX);
//开始发送数据
HAL_UART_Transmit_DMA(&UART1_Handler, buffer, length);
}
*/
//串口2的DMA发送
void UART2_TX_DMA_Send(u8 *buffer, u16 length)
{
//等待上一次的数据发送完毕
while(HAL_DMA_GetState(&DMA_UART2_TX) == HAL_DMA_STATE_BUSY);
//关闭DMA
__HAL_DMA_DISABLE(&DMA_UART2_TX);
//开始发送数据
HAL_UART_Transmit_DMA(&UART2_Handler, buffer, length);
}
/*
//串口1的DMA发送printf
void Debug_printf_1(const char *format, ...)
{
uint32_t length = 0;
va_list args;
__va_start(args, format);
length = vsnprintf((char*)usart1_tx_buffer, sizeof(usart1_tx_buffer), (char*)format, args);
UART1_TX_DMA_Send(usart1_tx_buffer, length);
}
*/
//串口2的DMA发送printf
void Debug_printf_2(const char *format, ...)
{
uint32_t length = 0;
va_list args;
__va_start(args, format);
length = vsnprintf((char*)usart2_tx_buffer, sizeof(usart2_tx_buffer), (char*)format, args);
UART2_TX_DMA_Send(usart2_tx_buffer, length);
}
//串口接收空闲中断
void UsartReceive_IDLE(UART_HandleTypeDef *huart)
{
uint32_t i = 0;
//当触发了串口空闲中断
if((__HAL_UART_GET_FLAG(huart, UART_FLAG_IDLE) != RESET))
{
// if(huart->Instance == USART1)
// {
// /* 1.清除标志 */
// __HAL_UART_CLEAR_IDLEFLAG(huart); //清除空闲标志
//
// // SCB_DisableDCache(); //对于F7带Cache需要注意，读取DMA前先关闭
//
// /* 2.读取DMA */
// HAL_UART_DMAStop(huart); //先停止DMA，暂停接收
// //这里应注意数据接收不要大于 USART_REC_LEN
// usart1_rx_len = USART_DMA_RX_BUFFER_MAXIMUM - (__HAL_DMA_GET_COUNTER(&DMA_UART1_RX)); //接收个数等于接收缓冲区总大小减已经接收的个数
//
// /* 3.搬移数据进行其他处理 */
// memcpy(usart1_tx_buffer, usart1_rx_buffer, usart1_rx_len);
// usart1_rx_flag = 1; //标志已经成功接收到一包等待处理
//
// for(u16 i=0;i<usart1_rx_len;i++)
// {
// command[i]=usart1_rx_buffer[i];
// DT_Commad_Receive_Prepare(command[i]);
// }
// // SCB_EnableDCache(); //对于F7带Cache需要注意，读取DMA完成后再打开
//
// /* 4.开启新的一次DMA接收 */
// HAL_UART_Receive_DMA(huart, usart1_rx_buffer, USART_DMA_RX_BUFFER_MAXIMUM); //启动接收
// }
if(huart->Instance == USART2)
{
/* 1.清除标志 */
__HAL_UART_CLEAR_IDLEFLAG(huart); //清除空闲标志
// SCB_DisableDCache(); //对于F7带Cache需要注意，读取DMA前先关闭
/* 2.读取DMA */
HAL_UART_DMAStop(huart); //先停止DMA，暂停接收
//这里应注意数据接收不要大于 USART_REC_LEN
usart2_rx_len = USART_DMA_RX_BUFFER_MAXIMUM - (__HAL_DMA_GET_COUNTER(&DMA_UART2_RX)); //接收个数等于接收缓冲区总大小减已经接收的个数
/* 3.搬移数据进行其他处理 */
memcpy(usart2_tx_buffer, usart2_rx_buffer, usart2_rx_len);
usart2_rx_flag = 1; //标志已经成功接收到一包等待处理
for(u16 i=0;i<usart1_rx_len;i++)
{
command[i]=usart1_rx_buffer[i];
DT_Commad_Receive_Prepare(command[i]);
}
// SCB_EnableDCache(); //对于F7带Cache需要注意，读取DMA完成后再打开
/* 4.开启新的一次DMA接收 */
HAL_UART_Receive_DMA(huart, usart2_rx_buffer, USART_DMA_RX_BUFFER_MAXIMUM); //启动接收
}
}
}
/*
//串口1中断服务程序
void USART1_IRQHandler(void)
{
u8 Res;
#if SYSTEM_SUPPORT_OS //使用OS
OSIntEnter();
#endif
//串口空闲中断处理
UsartReceive_IDLE(&UART1_Handler);
//HAL库串口处理
HAL_UART_IRQHandler(&UART1_Handler);
#if SYSTEM_SUPPORT_OS //使用OS
OSIntExit();
#endif
}
*/
//串口2中断服务程序
void USART2_IRQHandler(void)
{
u8 Res;
#if SYSTEM_SUPPORT_OS //使用OS
OSIntEnter();
#endif
//串口空闲中断处理
UsartReceive_IDLE(&UART2_Handler);
//HAL库串口处理
HAL_UART_IRQHandler(&UART2_Handler);
#if SYSTEM_SUPPORT_OS //使用OS
OSIntExit();
#endif
}

复制代码

bin133 · 发表于 2021-7-5 13:54:06

帮顶

正点原子 · 发表于 2021-7-6 00:34:24

帮顶

帐号		自动登录	找回密码
密码			立即注册

求助，STM32F4串口2使用DMA时遇到的问题

原子哥极力推荐 /2