精华内容
下载资源
问答
  • STM32 HAL库+串口DMA+空闲中断(IDLE)实现不定长数据接收,可以用来参考学习使用,简单易懂。
  • STM32HAL库将底层包装的很完备了, 在使用过程中几乎不需要去修改HAL库本身代码, 直接使用现有HAL库接口就可以快速方便的开发应用程序, 配合CubMx对开发人员来说实在是太友好了, 今天介绍个自用的串口中断接收的...

    STM32的HAL库将底层包装的很完备了, 在使用过程中几乎不需要去修改HAL库本身代码, 直接使用现有HAL库接口就可以快速方便的开发应用程序, 配合CubMx对开发人员来说实在是太友好了, 今天介绍个自用的串口中断接收的使用方法, 先看下HAL库的串口中断接收的序列图:

    从图中可以看出从第 3步到第7步已经形成一个接收闭环了, HAL库的调用方式上图已说明, 需要用户自己去实现的部分就是重写HAL_UART_RxCpltCallback这个函数, 下面介绍下我使用的接收方法.

    基本原理是使用了自定义的队列进行串口数据的接收存储与处理, 下面具体说下:

    重写的回调函数:

    void HAL_UART_RxCpltCallback(UART_HandleTypeDef *aHuart)
    {
    	HAL_StatusTypeDef status;
    
    	if (aHuart->Instance == USART1)
    	{
    		UART1_ReceiveByte(m_Uart1_RcvByte);
    		status = HAL_UART_Receive_IT(aHuart, &m_Uart1_RcvByte, 1);
    	}
    }

    在这里使用了一个字节的变量用于串口数据的接收, 具体接收处理在UART1_ReceiveByte()这个函数中处理, 这么处理的好处是可以更灵活的接收不定长的数据, 在UART1_ReceiveByte函数中的处理更像传统的中断处理方式, 直接处理接收到的单字节即可.

    UART1_ReceiveByte函数中我的处理方式是根据对接设备的协议进行一次预处理, 申请一个足够装下一条协议数据的缓存区对接收到的数据进行截取, 然后将截取到的数据推入到指定队列中.

    然后在消息处理循环中去读取队列中的协议数据, 进行二次判断并进行相应的消息处理即可.

    至此, 该串口中断接收数据处理流程就已完成了.

    展开全文
  • stm32 cubemx hal库 串口收发 中断接收 包括 MDK项目 和 stm32的cubemx 项目 使用hal最新的库函数开发 cubemx 4.26.1 有中文注释
  • 关于STM32 HAL库 串口接收中断 串口每次接收到一个数据都会进入中断,而只有huart->RxXferCount减小到0了,才会进入中断回调函数。可以从下图中看出。 所以,中断接收的过程就是 (pTxBuffPtr,TxXferSize 和 ...

    关于STM32 HAL库 串口接收中断

    串口每次接收到一个数据都会进入中断,而只有huart->RxXferCount减小到0了,才会进入中断回调函数。可以从下图中看出。
    在这里插入图片描述
    在这里插入图片描述
    所以,中断接收的过程就是
    在这里插入图片描述
    (pTxBuffPtr,TxXferSize 和 TxXferCount 三个变量分别用来设置串口发送的数据缓存指针,发送的数据量和还剩余的要发送的数据量。
    pRxBuffPtr,RxXferSize 和RxXferCount 则是用来设置接收的数据缓存指针,接收的最大数据量以及还剩余的要接收的数
    据量。)

    过程

    当接收到一个字符之后,在函数
    UART_Receive_IT中会把数据保存在串口句柄的成员变量pRxBuffPtr缓存中,并且使RxXferSize +1,RxXferCount -1,当RxXferCount 减小到0的时候,就会调用接收完成回调函数
    HAL_UART_RxCpltCallback 进行处理。

    1.CUBEMX配置的MX_USART1_UART_Init()中是没有开启中断的,需要加上

    HAL_UART_Receive_IT(&huart1, (u8 *)aRxBuffer, RXBUFFERSIZE);
    

    其中aRxBuffer是我们自己定义的临时缓冲区,如果它的长度RXBUFFERSIZE = 1,则每次进入中断之后,都会进入中断回调函数。
    2.回调函数每调用一次,库的设置会自动将中断关闭,所以需要再次开启,这里我们放在了USART1_IRQHandler(),中断入口函数中。

    3.读取USARTx->SR能避免莫名其妙的错误,所以在中断入口函数中加了

    while(HAL_UART_GetState(&huart1) != HAL_UART_STATE_READY)//等待就绪
    
    展开全文
  • ST推的HAL库,在整个接收过程中,是没有用到串口接收空闲中断,它的处理有三种,分别是轮询,接收完成中断(每一个字节一次),DMA接收。 整个Hal库接收和发送过程都封装好了,就用最简单的轮询方式看,先看...
  • 简介:STM32与上位机之间用通信协议(自己定义)进行串口通信。怎么判断上位机发过来的指令是正确的,而不是一串乱码?怎么从正确的指令中提取出想要的命令代号,从而实现想要的功能? 方法:读取上位机发来的命令,...
  • //接收数据错误,重新开始接收 } } } } } //串口1中断服务程序 void USART1_IRQHandler(void) { uint32_t timeout=0; HAL_UART_IRQHandler(&huart1); //调用HAL库中断处理公用函数 timeout=0; while...

    cubeMCX设置:在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    生成工程文件
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    usart.c

    /**
      ******************************************************************************
      * @file    usart.c
      * @brief   This file provides code for the configuration
      *          of the USART instances.
      ******************************************************************************
      * @attention
      *
      * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
      * All rights reserved.</center></h2>
      *
      * This software component is licensed by ST under BSD 3-Clause license,
      * the "License"; You may not use this file except in compliance with the
      * License. You may obtain a copy of the License at:
      *                        opensource.org/licenses/BSD-3-Clause
      *
      ******************************************************************************
      */
    
    /* Includes ------------------------------------------------------------------*/
    #include "usart.h"
    
    /* USER CODE BEGIN 0 */
    //串口1中断服务程序
    //注意,读取USARTx->SR能避免莫名其妙的错误   
    uint8_t USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
    //接收状态
    //bit15,	接收完成标志
    //bit14,	接收到0x0d
    //bit13~0,	接收到的有效字节数目
    uint16_t USART_RX_STA=0;       //接收状态标记	  
    
    uint8_t aRxBuffer[RXBUFFERSIZE];//HAL库使用的串口接收缓冲
    UART_HandleTypeDef UART1_Handler; //UART句柄
    
    int fputc(int ch, FILE *f){
    HAL_UART_Transmit (&huart1,(uint8_t *)&ch,1,0xffff);
    	return ch;
    }
    
    int fgetc(FILE *f)
    {
      uint8_t ch = 0;
      HAL_UART_Receive(&huart1, &ch, 1, 0xffff);
      return ch;
    } 
    
    /* USER CODE END 0 */
    
    UART_HandleTypeDef huart1;
    
    /* USART1 init function */
    
    void MX_USART1_UART_Init(void)
    {
    
      /* USER CODE BEGIN USART1_Init 0 */
    
      /* USER CODE END USART1_Init 0 */
    
      /* USER CODE BEGIN USART1_Init 1 */
    
      /* USER CODE END USART1_Init 1 */
      huart1.Instance = USART1;
      huart1.Init.BaudRate = 115200;
      huart1.Init.WordLength = UART_WORDLENGTH_8B;
      huart1.Init.StopBits = UART_STOPBITS_1;
      huart1.Init.Parity = UART_PARITY_NONE;
      huart1.Init.Mode = UART_MODE_TX_RX;
      huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
      huart1.Init.OverSampling = UART_OVERSAMPLING_16;
      if (HAL_UART_Init(&huart1) != HAL_OK)
      {
        Error_Handler();
      }
      /* USER CODE BEGIN USART1_Init 2 */
    
      /* USER CODE END USART1_Init 2 */
    
    }
    
    void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
    {
    
      GPIO_InitTypeDef GPIO_InitStruct = {0};
      if(uartHandle->Instance==USART1)
      {
      /* USER CODE BEGIN USART1_MspInit 0 */
    
      /* USER CODE END USART1_MspInit 0 */
        /* USART1 clock enable */
        __HAL_RCC_USART1_CLK_ENABLE();
    
        __HAL_RCC_GPIOA_CLK_ENABLE();
        /**USART1 GPIO Configuration
        PA9     ------> USART1_TX
        PA10     ------> USART1_RX
        */
        GPIO_InitStruct.Pin = GPIO_PIN_9;
        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
        GPIO_InitStruct.Pin = GPIO_PIN_10;
        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
        /* USART1 interrupt Init */
        HAL_NVIC_SetPriority(USART1_IRQn, 3, 0);			//抢占优先级3,子优先级3
        HAL_NVIC_EnableIRQ(USART1_IRQn);					//使能USART1中断通道
      /* USER CODE BEGIN USART1_MspInit 1 */
    
      /* USER CODE END USART1_MspInit 1 */
      }
    }
    
    void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
    {
    
      if(uartHandle->Instance==USART1)
      {
      /* USER CODE BEGIN USART1_MspDeInit 0 */
    
      /* USER CODE END USART1_MspDeInit 0 */
        /* Peripheral clock disable */
        __HAL_RCC_USART1_CLK_DISABLE();
    
        /**USART1 GPIO Configuration
        PA9     ------> USART1_TX
        PA10     ------> USART1_RX
        */
        HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9|GPIO_PIN_10);
    
        /* USART1 interrupt Deinit */
        HAL_NVIC_DisableIRQ(USART1_IRQn);
      /* USER CODE BEGIN USART1_MspDeInit 1 */
    
      /* USER CODE END USART1_MspDeInit 1 */
      }
    }
    
    /* USER CODE BEGIN 1 */
    void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)			//自定义中断回调函数
    {
    	if(huart->Instance==USART1)//如果是串口1
    	{
    		if((USART_RX_STA&0x8000)==0)//接收未完成
    		{
    			if(USART_RX_STA&0x4000)//接收到了0x0d
    			{
    				if(aRxBuffer[0]!=0x0a)USART_RX_STA=0;//接收错误,重新开始
    				else USART_RX_STA|=0x8000;	//接收完成了 
    			}
    			else //还没收到0X0D
    			{	
    				if(aRxBuffer[0]==0x0d)USART_RX_STA|=0x4000;
    				else
    				{
    					USART_RX_BUF[USART_RX_STA&0X3FFF]=aRxBuffer[0] ;
    					USART_RX_STA++;
    					if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收	  
    				}		 
    			}
    		}
    	}
    }
    
    
    //串口1中断服务程序
    void USART1_IRQHandler(void)                	
    { 
    	uint32_t timeout=0;
    	HAL_UART_IRQHandler(&huart1);	//调用HAL库中断处理公用函数	
    	timeout=0;
        while (HAL_UART_GetState(&huart1) != HAL_UART_STATE_READY)//等待就绪
    	{
    	 timeout++;超时处理
         if(timeout>HAL_MAX_DELAY) break;		
    	}    
    	timeout=0;
    	while(HAL_UART_Receive_IT(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)//一次处理完成之后,重新开启中断并设置RxXferCount为1
    	{
    	 timeout++; //超时处理
    	 if(timeout>HAL_MAX_DELAY) break;	
    	}
    	
    } 
    
    
    /* USER CODE END 1 */
    
    /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
    
    

    main.c

    /* USER CODE BEGIN Header */
    /**
      ******************************************************************************
      * @file           : main.c
      * @brief          : Main program body
      ******************************************************************************
      * @attention
      *
      * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
      * All rights reserved.</center></h2>
      *
      * This software component is licensed by ST under BSD 3-Clause license,
      * the "License"; You may not use this file except in compliance with the
      * License. You may obtain a copy of the License at:
      *                        opensource.org/licenses/BSD-3-Clause
      *
      ******************************************************************************
      */
    /* USER CODE END Header */
    /* Includes ------------------------------------------------------------------*/
    #include "main.h"
    #include "usart.h"
    #include "gpio.h"
    
    /* Private includes ----------------------------------------------------------*/
    /* USER CODE BEGIN Includes */
    
    /* USER CODE END Includes */
    
    /* Private typedef -----------------------------------------------------------*/
    /* USER CODE BEGIN PTD */
    
    /* USER CODE END PTD */
    
    /* Private define ------------------------------------------------------------*/
    /* USER CODE BEGIN PD */
    /* USER CODE END PD */
    
    /* Private macro -------------------------------------------------------------*/
    /* USER CODE BEGIN PM */
    
    /* USER CODE END PM */
    
    /* Private variables ---------------------------------------------------------*/
    
    /* USER CODE BEGIN PV */
    
    /* USER CODE END PV */
    
    /* Private function prototypes -----------------------------------------------*/
    void SystemClock_Config(void);
    /* USER CODE BEGIN PFP */
    
    /* USER CODE END PFP */
    
    /* Private user code ---------------------------------------------------------*/
    /* USER CODE BEGIN 0 */
    
    /* USER CODE END 0 */
    
    /**
      * @brief  The application entry point.
      * @retval int
      */
    int main(void)
    {
      /* USER CODE BEGIN 1 */
    	uint8_t len;	
    	uint16_t times=0;
      /* USER CODE END 1 */
    
      /* MCU Configuration--------------------------------------------------------*/
    
      /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
      HAL_Init();
    
      /* USER CODE BEGIN Init */
    
      /* USER CODE END Init */
    
      /* Configure the system clock */
      SystemClock_Config();
    
      /* USER CODE BEGIN SysInit */
    
      /* USER CODE END SysInit */
    
      /* Initialize all configured peripherals */
      MX_GPIO_Init();
      MX_USART1_UART_Init();
      HAL_UART_Receive_IT(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE);//该函数会开启接收中断:标志位UART_IT_RXNE,并且设置接收缓冲以及接收缓冲接收最大数据量
     
     /* USER CODE BEGIN 2 */
    
      /* USER CODE END 2 */
    
      /* Infinite loop */
      /* USER CODE BEGIN WHILE */
      while (1)
      {
        /* USER CODE END WHILE */
    
        /* USER CODE BEGIN 3 */
           if(USART_RX_STA&0x8000)
    		{					   
    			len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
    			printf("\r\n您发送的消息为:\r\n");
    			HAL_UART_Transmit(&huart1,(uint8_t*)USART_RX_BUF,len,1000);	//发送接收到的数据
    			while(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_TC)!=SET);		//等待发送结束
    			printf("\r\n\r\n");//插入换行
    			USART_RX_STA=0;
    		}else
    		{
    			times++;
    			if(times%2000==0)printf("请输入数据,以回车键结束\r\n");  
    			HAL_Delay(10);   
    		} 
      }
      /* USER CODE END 3 */
    }
    
    /**
      * @brief System Clock Configuration
      * @retval None
      */
    void SystemClock_Config(void)
    {
      RCC_OscInitTypeDef RCC_OscInitStruct = {0};
      RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
    
      /** Initializes the RCC Oscillators according to the specified parameters
      * in the RCC_OscInitTypeDef structure.
      */
      RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
      RCC_OscInitStruct.HSIState = RCC_HSI_ON;
      RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
      RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
      if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
      {
        Error_Handler();
      }
      /** Initializes the CPU, AHB and APB buses clocks
      */
      RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                                  |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
      RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
      RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
      RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
      RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
    
      if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
      {
        Error_Handler();
      }
    }
    
    /* USER CODE BEGIN 4 */
    
    /* USER CODE END 4 */
    
    /**
      * @brief  This function is executed in case of error occurrence.
      * @retval None
      */
    void Error_Handler(void)
    {
      /* USER CODE BEGIN Error_Handler_Debug */
      /* User can add his own implementation to report the HAL error return state */
      __disable_irq();
      while (1)
      {
      }
      /* USER CODE END Error_Handler_Debug */
    }
    
    #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 CODE BEGIN 6 */
      /* User can add his own implementation to report the file name and line number,
         ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
      /* USER CODE END 6 */
    }
    #endif /* USE_FULL_ASSERT */
    
    /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
    
    

    需要在stm32f1xx_it.c里把void USART1_IRQHandler(void)注释掉,因为我在串口.C里面设置了他的中断了。

    实验效果:
    在这里插入图片描述

    展开全文
  • STM32 HAL实现串口中断接收

    千次阅读 2020-03-28 17:20:58
    一、串口设置 1. 异步模式 2. 参数 3. 中断使能 4. 生成代码如下 /* USART6 init function */ static void MX_USART6_UART_Init(void) { huart6.Instance = USART6; huart6.Init.BaudRate = 115200; huart6....

    一、串口设置

    1. 异步模式

    在这里插入图片描述
    默认RX在PC7上,根据需要改到PG9上
    在这里插入图片描述
    在这里插入图片描述

    2. 参数

    在这里插入图片描述

    3. 中断使能

    在这里插入图片描述

    4. 生成代码如下

    /* USART6 init function */
    static void MX_USART6_UART_Init(void)
    {
    
      huart6.Instance = USART6;
      huart6.Init.BaudRate = 115200;
      huart6.Init.WordLength = UART_WORDLENGTH_8B;
      huart6.Init.StopBits = UART_STOPBITS_1;
      huart6.Init.Parity = UART_PARITY_NONE;
      huart6.Init.Mode = UART_MODE_TX_RX;
      huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE;
      huart6.Init.OverSampling = UART_OVERSAMPLING_16;
      if (HAL_UART_Init(&huart6) != HAL_OK)
      {
        _Error_Handler(__FILE__, __LINE__);
      }
    }
    

    5. 自己需添加中断服务函数

    //发生溢出中断或DMA中断时
    uint8_t Rx_HAL_Buff_Temp[2];	//HAL函数接收临时缓存
    uint8_t Rx_Buff[100];			//接收帧缓存,自己定义大小
    uint8_t RxCounter = 0;			//接收计数器
    void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
    {
      huart->ErrorCode = HAL_UART_ERROR_NONE;
      HAL_UART_Receive_IT(&huart6,Rx_HAL_Buff_Temp,1);
    }
    //接收到1字节数据,回调函数如下
    void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    {
      if(huart->Instance==USART6)
      {
    	Rx_Buff[[RxCounter++] = Rx_HAL_Buff_Temp[0];
    	//加上自己的代码
      	HAL_UART_Receive_IT(&huart6,Rx_HAL_Buff_Temp,1);
      } 
    }
    
    展开全文
  • STM32使用HAL库串口接收中断

    万次阅读 热门讨论 2019-03-16 22:16:31
    下面讲解使用HAL库配置串口1,使串口1可以使用中断接收字节并原样返回。 1. STM32CubeMX对串口1作如下配置 2. 添加如下代码 ​ uint8_t uart1_rxbuf[10]; // 用于存放接收到的数据 void MX_USART1...
  • HAL库版本:v1.9.0(STM32Cube MCU Package for STM32F0 Series) 本文内容: 不定长数据接收的原理 串口接收中断的配置 串口接收DMA线的配置 示例程序及起运行流程 附件:代码工程(MDK) ...
  • STM32HAL库串口处理---中断收发

    千次阅读 2020-03-05 21:57:39
    STM32HAL库串口处理—中断收发 文章目录STM32HAL库串口处理---中断收发Arduino串口机制的接口函数代码实现编写硬件层MSP支持代码定义新的串口结构体接口函数实现实例化对象`serial_init()``serial_available()``...
  • [STM32系列]一、HAL库串口中断接收

    千次阅读 2019-09-09 14:41:50
    [STM32系列]一、HAL库串口中断接收1、前言2、回调函数3、HAL库中断接收函数使用 1、前言 HAL即硬件抽象层(英语:Hardware Abstraction Layer),实现了不同硬件的统一接口操作。这就极大的简化了程序员的移植工作...
  • 串口模式实现有三种 1.普通模式:在主函数中接收函数 2.中断模式:产生的不影响主程序运行 3. DMA模式:与主函数互不影响,独立运行 本文记录第二种中断模式。
  • STM32F1 1.8.3 版本 1. CUBE配置 打开串口 打开中断 配置优先级 生成工程文件 2. 代码添加 在usart.h中添加: #define USART_REC_LEN 200 //定义最大接收字节数 200 #define EN_USART1_RX 1 //使能
  • 发送和接收两个函数  /*##-2- Start the transmission process #####################################*/  /* While the UART in reception process, user can transmit data through   "aTxBuffer"...
  • STM32 HAL CubeMX 串口IDLE接收空闲中断+DMA

    万次阅读 多人点赞 2020-03-22 11:01:56
    STM32HAL库 STM32CubeMX教程十一—DMA (串口DMA发送接收) 本篇文章我们仅针对例程进行详解剖析 本篇文章提供两种方法: 一种是 :IDLE 接收空闲中断+DMA 一种是: IDLE 接收空闲中断+RXNE接收数据中断 都可完成...
  • hal库实现stm32串口中断接收数据

    千次阅读 2020-12-01 14:14:21
    先设置并开启串口中断接收 该函数功能为开启串口接收中断,并指定存储接收数据的缓存区,设置从串口接收的数据大小。这里要特别注意,该函数只有从串口接收到Size个数据后才会返回,不然会阻塞。 HAL_UART_Receive_...
  • STM32串口中断接收实验(HAL库

    万次阅读 2018-09-10 20:11:39
    简介:STM32与上位机之间用通信协议(自己定义)进行串口通信。怎么判断上位机发过来的指令是正确的,而不是一串乱码?怎么从正确的指令中提取出想要的命令代号,从而实现想要的功能? 方法:读取上位机发来的命令...
  • (二)STM32 HAL库 串口中断

    千次阅读 2021-08-14 14:51:15
    各位老铁,上一篇文章咱们讨论了STM32中断家族中的外部中断。下面就和各位老铁分享下串口中断的奥秘。 (一) 串口中断是干什么?就是接受数据的,接受一个数据中断就执行一次,直到数据 接受结束。下面我们以...
  • stm32L053 低功耗设计开发MCU,使用STM32 官方的驱动库HAL,采用串口中断接收方式,接收不定长数据,发送则采用DMA发送,项目中稳定使用的USART驱动方式。
  • 首先,使用CubeMX配置STM32 串口二用来接收数据,串口一打印输出,使能中断和DMA。 在串口二的初始化里添加空闲中断的使能: static void MX_USART2_UART_Init(void) { /* USER CODE BEGIN USART2_Init 0 ...
  • stm32l051_stop.rar

    2020-06-18 15:54:09
    STM32L051使用CUBEMX配置,使用HAL库串口中断接收,使用空闲中断方式接收不定长数据,非DMA方式。同时配置了RTC,并且设置了RTC闹钟为每小时定时触发方式。程序在STM32的Nucleo开发板上实验不丢失字节。
  • hal库里面路径:STM32Cube_FW_L0_V1.10.0\Projects\STM32L053C8-Discovery\Examples \UART\UART_TwoBoards_ComIT 工程是串口1中断收发模式配置   UART_HandleTypeDef UartHandle; //串口结构体变量  Uart...
  • 网上使用HAL串口时很多都没有实现不定长数据的接收,要么是限定数据长度,要么是加“0x0a 0x0d”来控制接收完成,找了很久都没有真正找到一个能用的,在很多通信中不可能是定义的,或是加上“0x0a 0x0d”来实现的,...
  • STM32 HAL库串口+DMA接收不定长数据

    千次阅读 2020-11-04 17:14:51
    这里我们采用三线SWD下载方式,加一个LED灯交替闪烁,串口中断+DMA来接收不定长数据,串口采用默认配置,打开串口中断,采用MDA方式就行发送和接收: 然后保存工程生成代码。 生成代码后先定义以下变量: ...
  • 这里使用USART1串口 usart.c中添加 (1)添加全局变量 uint8_t USART1_Buff[100] = {0}; //接收帧缓存,自己定义大小 uint8_t USART1_STA = 0; bool USART1_Receive_Flag = false; uint8_t res = 0; (2)在MX...
  • stm32cubeMX的配置界面如下: 1.使用DMA,方向是内存到外设 2.使用USART1 代码方面: #define Length_MAX 255 //数组最大长度 uint8_t RxBuf[Length_MAX]; //缓存数组 uint8_t RxByte[1]; //接收数组 uint
  • stm32使用hal库配置串口接收中断

    千次阅读 2021-10-06 13:54:06
    此函数使能串口接收中断,并且进入中断后需要重新设置,否则只能进入一次。第三个参数是接受到多少数据后进入中断,也就是接收缓冲区。这个参数最好设置为1,在中断中一个个处理接受的的每个字节。 ...
  • 我这里要用串口中断接收两种帧头的数据,1. 以0x0D 0x0A为帧头的数据。2,以0x55 0xA5为帧头的数据。两种数据帧头数据不同。 其中定义的变量 uint8_t aRxBuff; //用于存放串口接收到的单字节 uint8_t rxNum = 0;...
  • STM32 HAL库 串口DMA接收不定长数据 整体思路:我是用的CUBEMX软件生成的工程,使能了两个串口串口2用来接收不定长的数据,串口1用来发送串口2接收到的数据;串口2我找了一个UBLOX卫星模块,每秒输出不定长的定位...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,202
精华内容 1,280
关键字:

stm32hal库串口中断接收