狐尔摩斯 2024-04-10 19:33 采纳率: 0%

已结题

HAL库串口启用硬件流控，数据错乱问题

使用一款国产MCU芯片，使用的是HAL库，在使用串口DMA编写例程，与串口板通信遇到数据错乱和丢失问题。

例程做的事情就是接收数据指定接收6个字节数据，并把数据发送回去，以下是例程代码：

#include "main.h"
#include "string.h"
/* Private define ------------------------------------------------------------*/
#ifdef __GNUC__
  /* With GCC, small printf (option LD Linker->Libraries->Small printf
  set to 'Yes') calls __io_putchar() */
  #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
  #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /* __GNUC__ */

/* Private user code ---------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
static void APP_SystemClockConfig(void);

/* Private variables ---------------------------------------------------------*/
UART_HandleTypeDef UartHandle;
uint8_t aTxBuffer[64] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
uint8_t aRxBuffer[64] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};

static void app_uart_init(void)
{
    /* Initialize USART2 */
  UartHandle.Instance          = USART1;
  UartHandle.Init.BaudRate     = 115200;
  UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits     = UART_STOPBITS_1;
  UartHandle.Init.Parity       = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_RTS_CTS;
  UartHandle.Init.Mode         = UART_MODE_TX_RX;
  HAL_UART_Init(&UartHandle);
  
}


int main(void)
{
  /* Reset of all peripherals, Initializes the Systick */
  HAL_Init();
  
  /* System clock configuration */
  APP_SystemClockConfig(); 

    app_uart_init();
    HAL_UART_Transmit_DMA(&UartHandle, (uint8_t *)aTxBuffer, 12);
  while (1)
  {
            
        //UartHandle.hdmarx->Instance->CNDTR = 1024;
    /* Receive data using DMA */
    if (HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, 6) != HAL_OK)
    {
      APP_ErrorHandler();
    }
    /* Wait for receiving data to complete */
    while(HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
    {
    }

        
    /* Send data using DMA */
    if (HAL_UART_Transmit_DMA(&UartHandle, (uint8_t *)aRxBuffer, 6) != HAL_OK)
    {
      APP_ErrorHandler();
    }
    /* Wait for sending data to complete */
    while(HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
    {
    }
        

  }
}

/**
  * @brief  System clock configuration function
  * @param  None
  * @retval None
  */
static void APP_SystemClockConfig(void)
{
  RCC_OscInitTypeDef  OscInitstruct = {0};
  RCC_ClkInitTypeDef  ClkInitstruct = {0};
  
  OscInitstruct.OscillatorType  = RCC_OSCILLATORTYPE_HSE | RCC_OSCILLATORTYPE_HSI | RCC_OSCILLATORTYPE_LSE | 
                                  RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_HSI48M;
  OscInitstruct.HSEState        = RCC_HSE_OFF;                              /* Disable HSE */
/* OscInitstruct.HSEFreq         = RCC_HSE_16_32MHz; */                     /* HSE working frequency range: 16M~32M */
  OscInitstruct.HSI48MState     = RCC_HSI48M_OFF;                           /* Disable HSI48M */
  OscInitstruct.HSIState        = RCC_HSI_ON;                               /* Enable HSI */
  OscInitstruct.LSEState        = RCC_LSE_OFF;                              /* Disable LSE */
/* OscInitstruct.LSEDriver       = RCC_LSEDRIVE_HIGH; */                    /* Drive capability level: High */
  OscInitstruct.LSIState        = RCC_LSI_OFF;                              /* Disable LSI */
  OscInitstruct.PLL.PLLState    = RCC_PLL_OFF;                              /* Disable PLL */
/*  OscInitstruct.PLL.PLLSource   = RCC_PLLSOURCE_HSE; */                   /* PLL clock source: HSE */
/*  OscInitstruct.PLL.PLLMUL      = RCC_PLL_MUL6; */                        /* PLL multiplication factor: 6 */
  /* Configure Oscillators */
  if(HAL_RCC_OscConfig(&OscInitstruct) != HAL_OK)
  {
    APP_ErrorHandler();
  }
  
  ClkInitstruct.ClockType       = RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  ClkInitstruct.SYSCLKSource    = RCC_SYSCLKSOURCE_HSI;                 /* System clock source: HSI */
  ClkInitstruct.AHBCLKDivider   = RCC_SYSCLK_DIV1;                      /* AHB clock not divided */
  ClkInitstruct.APB1CLKDivider  = RCC_HCLK_DIV1;                        /* APB1 clock not divided */
  ClkInitstruct.APB2CLKDivider  = RCC_HCLK_DIV2;                        /* APB1 clock divided by 2 */
  /* Configure Clocks */
  if(HAL_RCC_ClockConfig(&ClkInitstruct, FLASH_LATENCY_0) != HAL_OK)
  {
    APP_ErrorHandler();
  }
}

/**
  * @brief  This function is executed in case of error occurrence.
  * @param  None
  * @retval None
  */
void APP_ErrorHandler(void)
{
  /* Infinite loop */
  while (1)
  {
  }
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file：pointer to the source file name
  * @param  line：assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* User can add his own implementation to report the file name and line number,
     for example: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* Infinite loop */
  while (1)
  {
  }
}
#endif /* USE_FULL_ASSERT */

IO口配置的代码：

void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{
  GPIO_InitTypeDef  GPIO_InitStruct;
    if (huart->Instance == USART1)
  {
    /* Enable clock */
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_USART1_CLK_ENABLE();

    __HAL_RCC_SYSCFG_CLK_ENABLE();
    __HAL_RCC_DMA1_CLK_ENABLE();

    /* GPIO Initialization
    PA2     ------> USART1_TX
    PA3     ------> USART1_RX
    */
    GPIO_InitStruct.Pin       = GPIO_PIN_9;
    GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull      = GPIO_PULLUP;
    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF2_USART1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_10;
    GPIO_InitStruct.Alternate = GPIO_AF2_USART1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    if(huart->Init.HwFlowCtl == UART_HWCONTROL_RTS_CTS)
    {
        GPIO_InitStruct.Pin = GPIO_PIN_11;//cts
        GPIO_InitStruct.Alternate = GPIO_AF2_USART1;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

        GPIO_InitStruct.Pin = GPIO_PIN_12;//rts
        GPIO_InitStruct.Alternate = GPIO_AF2_USART1;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    }


    /* USART1 DMA configuration */
    /* USART1_TX initialization */
    hdma_usart1_tx.Instance = DMA1_Channel1;
    hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart1_tx.Init.Mode = DMA_NORMAL;//DMA_CIRCULAR;
    hdma_usart1_tx.Init.Priority = DMA_PRIORITY_LOW;
    if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK)
    {
      APP_ErrorHandler();
    }

    __HAL_LINKDMA(huart, hdmatx, hdma_usart1_tx);
    /* USART1_RX initialization */
    hdma_usart1_rx.Instance = DMA1_Channel2;
    hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart1_rx.Init.Mode = DMA_NORMAL;
    hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW;
    if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK)
    {
      APP_ErrorHandler();
    }
    __HAL_LINKDMA(huart, hdmarx, hdma_usart1_rx);
    
    /* Set DMA request mapping */
    HAL_DMA_ChannelMap(&hdma_usart1_tx, DMA_CHANNEL_MAP_USART1_WR);
    HAL_DMA_ChannelMap(&hdma_usart1_rx, DMA_CHANNEL_MAP_USART1_RD);
    
    /* Enable NVIC */
    HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    HAL_NVIC_EnableIRQ(USART1_IRQn);
    
    HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 1);
    HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);

    HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 1, 1);
    HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);

  }
  else if (huart->Instance == USART2)
  {
    /* Enable clock */
    __HAL_RCC_GPIOD_CLK_ENABLE();
    __HAL_RCC_USART2_CLK_ENABLE();
    __HAL_RCC_SYSCFG_CLK_ENABLE();
    __HAL_RCC_DMA1_CLK_ENABLE();
    
    /* GPIO Initialization
    PA2     ------> USART1_TX
    PA3     ------> USART1_RX
    */
    GPIO_InitStruct.Pin       = GPIO_PIN_5;
    GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull      = GPIO_PULLUP;
    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF2_USART2;
    HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_6;
    GPIO_InitStruct.Alternate = GPIO_AF2_USART2;
    HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
    
    /* USART2 DMA configuration */
    /* USART2_TX initialization */
    hdma_usart2_tx.Instance = DMA1_Channel1;
    hdma_usart2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    hdma_usart2_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart2_tx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart2_tx.Init.Mode = DMA_NORMAL;
    hdma_usart2_tx.Init.Priority = DMA_PRIORITY_LOW;
    if (HAL_DMA_Init(&hdma_usart2_tx) != HAL_OK)
    {
      APP_ErrorHandler();
    }

    __HAL_LINKDMA(&UartHandle, hdmatx, hdma_usart2_tx);
    /* USART2_RX initialization */
    hdma_usart2_rx.Instance = DMA1_Channel2;
    hdma_usart2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_usart2_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart2_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart2_rx.Init.Mode = DMA_NORMAL;
    hdma_usart2_rx.Init.Priority = DMA_PRIORITY_LOW;
    if (HAL_DMA_Init(&hdma_usart2_rx) != HAL_OK)
    {
      APP_ErrorHandler();
    }
    __HAL_LINKDMA(&UartHandle, hdmarx, hdma_usart2_rx);
    
    /* Set DMA request mapping */
    HAL_DMA_ChannelMap(&hdma_usart2_tx, DMA_CHANNEL_MAP_USART2_WR);
    HAL_DMA_ChannelMap(&hdma_usart2_rx, DMA_CHANNEL_MAP_USART2_RD);
    
    /* Enable NVIC */
    HAL_NVIC_SetPriority(USART2_IRQn, 0, 1);
    HAL_NVIC_EnableIRQ(USART2_IRQn);
    
    HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 1);
    HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);

    HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 1, 1);
    HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
  }
}

我使用的串口板支持CTS RTS功能，也正确连接了，如果把杜邦线断开，串口调试工具就收不到任何数据，说明引脚连接应该没问题。

实验串口调试助手一次发送12个字节，但是MCU没有分两次把数据完整接收。

实验结果的打印如下：


[2024-04-10 19:27:21.880]# RECV HEX>
FF FF FF FF FF FF FF FF FF FF FF FF 
[2024-04-10 19:27:25.525]# SEND HEX>
01 02 03 04 05 06 07 08 09 0A 0B 0C 
[2024-04-10 19:27:25.575]# RECV HEX>
01 02 03 04 05 06 
[2024-04-10 19:27:26.784]# SEND HEX>
01 02 03 04 05 06 07 08 09 0A 0B 0C 
[2024-04-10 19:27:26.847]# RECV HEX>
07 0A 0B 0C 01 02 03 06 07 08 09 0A 
[2024-04-10 19:27:27.470]# SEND HEX>
01 02 03 04 05 06 07 08 09 0A 0B 0C 
[2024-04-10 19:27:27.517]# RECV HEX>
0B 01 02 03 04 05 
[2024-04-10 19:27:29.546]# SEND HEX>
01 02 03 04 05 06 07 08 09 0A 0B 0C 
[2024-04-10 19:27:29.603]# RECV HEX>
06 09 0A 0B 0C 01 02 05 06 07 08 09 
[2024-04-10 19:27:30.186]# SEND HEX>
01 02 03 04 05 06 07 08 09 0A 0B 0C 
[2024-04-10 19:27:30.234]# RECV HEX>
0A 01 02 03 04 05 
[2024-04-10 19:27:30.762]# SEND HEX>
01 02 03 04 05 06 07 08 09 0A 0B 0C 
[2024-04-10 19:27:30.809]# RECV HEX>
06 09 0A 0B 0C 01 02 05 06 07 08 09 
[2024-04-10 19:27:31.551]# SEND HEX>
01 02 03 04 05 06 07 08 09 0A 0B 0C 
[2024-04-10 19:27:31.612]# RECV HEX>
0A 01 02 03 04 05

并没有按照预期的收到：
01 02 03 04 05 06
07 08 09 0A 0B 0C
01 02 03 04 05 06
07 08 09 0A 0B 0C
这样的数据，是配置的不对，还是硬件流控只能做到这样？请指点。

写回答
好问题 0 提建议
追加酬金
关注问题
分享
邀请回答
编辑收藏删除
收藏举报

18条回答默认最新

码农阿豪 Java领域优质创作者 2024-04-10 19:39

关注

让阿豪来帮你解答，本回答参考chatgpt3.5编写提供，如果还有疑问可以评论或留言

问题：使用一款国产MCU芯片，使用的是HAL库，在使用串口DMA编写例程，与串口板通信遇到数据错乱和丢失问题。例程做的事情就是接收数据指定接收6个字节数据，并把数据发送回去。解答：数据错乱和丢失问题可能有以下几个原因：

码率不匹配：串口通信需要保证发送端和接收端的波特率一致，如果不一致就可能会出现数据错乱和丢失问题。可以检查是否设置了正确的波特率。
缓冲区溢出：在DMA传输数据时，需要保证接收缓冲区大小足够。如果接收缓冲区大小不够，数据就会被覆盖，从而出现数据错乱和丢失的问题。
DMA传输未结束：在DMA传输数据时，需要等待传输结束，否则可能会出现数据错乱和丢失的问题。可以通过检查DMA的状态来确认传输是否结束。
中断优先级设置不正确：如果中断优先级设置不正确，可能会导致数据丢失。可以检查中断优先级设置是否正确。以下是可能导致数据错乱和丢失问题的例程代码，并给出了解决方案：

#include "main.h"
#include "string.h"
/* Private define ------------------------------------------------------------*/
#ifdef __GNUC__  
/* With GCC, small printf (option LD Linker->Libraries->Small printf set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else  
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /* __GNUC__ */
/* Private user code ---------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
static void APP_SystemClockConfig(void);
/* Private variables ---------------------------------------------------------*/
UART_HandleTypeDef UartHandle;
uint8_t aTxBuffer[64] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
uint8_t aRxBuffer[64] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
static void app_uart_init(void){
  /* Initialize USART2 */
  UartHandle.Instance          = USART1;
  UartHandle.Init.BaudRate     = 115200;
  UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits     = UART_STOPBITS_1;
  UartHandle.Init.Parity       = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_RTS_CTS;
  UartHandle.Init.Mode         = UART_MODE_TX_RX;
  HAL_UART_Init(&UartHandle);
}
int main(void){
  /* Reset of all peripherals, Initializes the Systick */
  HAL_Init();
  
  /* System clock configuration */
  APP_SystemClockConfig();
  
  app_uart_init();
  
  HAL_UART_Transmit_DMA(&UartHandle, (uint8_t *)aTxBuffer, 12);
  
  while (1){
    //UartHandle.hdmarx->Instance->CNDTR = 1024;
    
    /* Receive data using DMA */
    if (HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, 6) != HAL_OK){
      APP_ErrorHandler();
    }
    
    /* Wait for receiving data to complete */
    while(HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY){
    }
    
    /* Send data using DMA */
    if (HAL_UART_Transmit_DMA(&UartHandle, (uint8_t *)aRxBuffer, 6) != HAL_OK){
      APP_ErrorHandler();
    }
    
    /* Wait for sending data to complete */
    while(HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY){
    }
    
  }
}
/**
 * @brief  System clock configuration function
 * @param  None
 * @retval None
 */
static void APP_SystemClockConfig(void){
  RCC_OscInitTypeDef  OscInitstruct = {0};
  RCC_ClkInitTypeDef  ClkInitstruct = {0};
  
  OscInitstruct.OscillatorType  = RCC_OSCILLATORTYPE_HSE | RCC_OSCILLATORTYPE_HSI | RCC_OSCILLATORTYPE_LSE | RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_HSI48M;
  OscInitstruct.HSEState        = RCC_HSE_OFF;                            
  /* Disable HSE */
  /* OscInitstruct.HSEFreq         = RCC_HSE_16_32MHz; */                     
  /* HSE working frequency range: 16M~32M */
  OscInitstruct.HSI48MState     = RCC_HSI48M_OFF;                           
  /* Disable HSI48M */
  OscInitstruct.HSIState        = RCC_HSI_ON;                             
}

解决方案： 1. 确认串口通信的波特率一致，可以通过以下的代码设置波特率：

UartHandle.Init.BaudRate = 115200;

确认接收缓冲区大小足够，可以通过以下代码设置接收缓冲区大小：

uint8_t aRxBuffer[64] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
if (HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, 6) != HAL_OK){
    APP_ErrorHandler();
}

等待DMA传输结束，可以通过以下代码等待传输结束：

/* Wait for receiving data to complete */
while(HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY){
}

确认中断优先级设置正确，可以通过以下代码设置中断优先级：

HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);

报告相同问题？

关注问题

hal库串口传输中文乱码 stm32
2022-07-25 18:12

回答 1 已采纳编码问题，注意下这个源码对应文件的编码格式，一般默认是utf8，要么改源码文件的编码格式，要么加入utf8-->gbk函数做转换处理。
HAL库配置stm32f103zet6PWM电机驱动 stm32 单片机嵌入式硬件
2022-04-26 09:33

回答 2 已采纳什么系统下配置驱动
基于STM32hal库定时中断出现的问题 stm32
2021-12-07 11:21

回答 1 已采纳我自己已经解决这个问题了，原因是32上电之后会默认进一次定时中断在HAL_TIM_Base_Start_IT(&htim2);这句话前加一个这个__HAL_TIM_CLEAR_FLAG(&htim2,
STM32 HAL库串口+DMA空闲中断接收不定长数据
2020-11-04 17:36

STM32 HAL库+串口DMA+空闲中断（IDLE）实现不定长数据接收，可以用来参考学习使用，简单易懂。
stm32 使用hal库进行串口接收数据，如何根据接收到的数据执行相应指令？ c语言
2020-12-27 16:03

回答 2 已采纳 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)//回调函数 { if(huart->Instance==USART2)
STM32基于HAL库使用串口发送16进制数组 stm32 有问必答
2023-02-03 21:59

回答 8 已采纳去掉for,直接用 HAL_UART_Transmit (&huart4,dj,7,0xfff); 要考虑可能存在的丢包和断包问题，发送7字节，接收方可能接收1次或者多次才能收满这7字节。丢包
HAL库制作STM32红外避障小车见到障碍物反而变快了？ stm32 单片机嵌入式硬件
2022-04-12 20:04

回答 3 已采纳因为你没有遇到障碍物时直接跳出了循环，没有继续执行延时函数，也就是你的PWM节奏乱了。如果使用的是专用的PWM端口就不会有该问题存在
HAL库STM32F407：Uart串口通信实验-程序源码
2022-10-19 22:15

使用STM32CubeMX生成HAL库工程文件 MCU芯片为STM32F407VET6，实现Uart串口通信收发实验
基于HAL库在STM32H7写入flash时死机，进入default_Handler卡死 c语言 stm32 嵌入式硬件
2022-11-09 15:10

回答 1 已采纳 HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t FlashAddress, uint32_t DataAddres
KEIL5用HAL库明明定义了函数，函数里定义好的变量好也有代码提示符，编译时却没定义 stm32 单片机嵌入式硬件
2022-04-11 11:39

回答 3 已采纳有个.h文件stm32f4xx_hal_conf.h，里面设置了启用哪些功能你说的代码一直都存在，但如果没Enable该功能，会被屏蔽掉的
stm32HAL的硬件复位中断在那里？ stm32 嵌入式硬件
2021-09-16 09:50

回答 2 已采纳硬件复位是不用写的，说明是硬件复位，当然跟软件没有关系，只要在芯片的reset引脚接到key1，然后接地，按键按下就可以复位了
STM32HAL库+RS485+串口+定时器+Modbus协议（主机+从机测试）
2022-01-29 20:06

STM32+RS485+MODBUS协议主机-从机代妈共包含3部分测试（每一部分需单独测试） 1-主机读取从机数据测试 2-主机向从机的一个寄存器中写入数据 3-本设备作为从机使用，作为从机时地址为0x02
使用标准库和使用HAL库的STM32单片机可以串口通信吗 arm stm32 单片机
2023-02-02 23:21

回答 2 已采纳回答不易，求求您采纳点赞哦是的，使用标准库和使用 HAL 库的 STM32 单片机可以通过串口进行通信。不同库的 STM32 单片机间通信是没有问题的，因为串口通信的原理是相同的，只是不同库中实
【STM32】HAL库-串口异步通信-非阻塞式接收数据
2022-05-11 16:26

串口异步通信，开启收发方向，阻塞式发送（仿printf发送）；非阻塞式接收数据。 PC13控制LED灯，LED灯的亮灭指示接收到数据。程序初始化完成之后，开启接收中断。在接收完成回调函数中，重新开启接收中断（因为在...
stm32hal库串口接收不定长数据
2023-06-30 12:13

Dylan649的博客在中断服务函数中写空闲中断函数，空闲中断标志位记得要清除。把每个接收到的数据存入数组uart_buf。1.正常使用接收中断函数。2.使用空闲接收中断函数。主函数中处理空闲中断状态。
没有解决我的问题, 去提问

问题事件

关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
已结题（查看结题原因） 4月15日
关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
创建了问题 4月10日

悬赏问题

¥100 set_link_state
¥15 虚幻5 UE美术毛发渲染
¥15 CVRP 图论物流运输优化
¥15 Tableau online 嵌入ppt失败
¥100 支付宝网页转账系统不识别账号
¥15 基于单片机的靶位控制系统
¥15 真我手机蓝牙传输进度消息被关闭了，怎么打开？(关键词-消息通知)
¥15 装 pytorch 的时候出了好多问题，遇到这种情况怎么处理？
¥20 IOS游览器某宝手机网页版自动立即购买JavaScript脚本
¥15 手机接入宽带网线，如何释放宽带全部速度

HAL库串口启用硬件流控，数据错乱问题

18条回答 默认 最新

问题事件

悬赏问题

18条回答默认最新