程序员经验分享-hwhale

STM32CubeMX使用教程——使用485总线接收变送器数据

2023-11-09

一、要使用的外设

  1. USART1（引脚PA9、PA10）用于打印信息
  2. USART2（引脚PA2、PA3）用于接收485总线上的数据,使能PG8用于控制485收发。
  3. 灯（引脚PF9、PF10）点灯用于程序调试查看运行状态。

二、使用STM32CubeMX生成工程

1、先打开MCU选择器
在这里插入图片描述
2、选择芯片,在搜索框里输入STM32F407ZG就会弹出STM32F407ZGT6,双击。
在这里插入图片描述
3、 进入配置界面。
上面有四栏，主要用的是引脚配置、时钟配置、工程管理。
左边有8栏，分别是内核、模拟量、定时器、通信、多媒体等相关的外设。
在这里插入图片描述

引脚配置

1、内核方面配置两个东西：RCC、SYS
时钟源的配置选择外部时钟
在这里插入图片描述
调试选项配置选SW
在这里插入图片描述
2、通信方面配置两个串口USART1、USART2
串口1用于打印信息，只修改模式为异步的，然后直接照着原理图在右边把引脚修改成USART1的复用模式。其它参数默认。
在这里插入图片描述
串口2用于接收SP3485传过来的信号，故要配置4个东西。
一是在右边修改引脚复用。不仅要设置PA9、PA10的复用，还要设置PG8为GPIO_Output，用于SP3485的收发控制。
在这里插入图片描述

二是参数设置里要修改波特率与变送器一致。
在这里插入图片描述
三是在NVIC里使能串口2的中断。
在这里插入图片描述
四是在DMA设置里添加引脚的DMA收发。
在这里插入图片描述

时钟树配置

开发板上外部晶振为8MHz
STM32F407ZGT6的最高主频到168M，使HCLK = 168Mhz即可：
在这里插入图片描述

工程管理

项目里设置名称、位置、IDE
在这里插入图片描述
代码生成器设置里设置生成独立的初始化文件：
在这里插入图片描述

生成项目

在这里插入图片描述

三、代码编辑

1、打开生成的项目如下：
在这里插入图片描述
2、主要在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 "dma.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>//自行包含头文件，为了使用prinrf()函数
#include <string.h>
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
uint8_t USART2_buff[10]={0};//定义一个接收缓存区
uint8_t USART2_RXbuff[10]={0};//定义一个正真的接收数组
uint8_t USART2_cut[2]={0};//后面会用到该数组存放响应指令截取后的两个字节

int Usart_Flag=1;//设置一个标志，外部硬件触发中断执行，中断回调函数的执行通过标志位触发主函数的执行

int val = 0;//这两个是用于拼接字符串并转换成int类型
char *pBuf = (char*)&val;

uint8_t stress_send[8]={0x01,0x03,0x00,0x04,0x00,0x01,0xC5,0xCB};  //485发送指令，读取压力值
/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
extern DMA_HandleTypeDef hdma_usart2_rx;
/* 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 */
//定义中断回调函数
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) 
{
	if(huart->Instance == USART2)  //如果是串口2中断
	 {	
			if((__HAL_UART_GET_FLAG(&huart2,UART_FLAG_IDLE) != RESET))//如果是接收完成中断，idle标志被置位
			{ 
				huart2.Instance->SR;                       //清除状态寄存器SR,读取SR寄存器可以实现清除SR寄存器的功能
				huart2.Instance->DR;                       //读取数据寄存器中的数据
				
				HAL_UART_DMAStop(&huart2); //关DMA
				
				hdma_usart2_rx.Instance->NDTR;            // 获取DMA中未传输的数据个数
				memcpy(USART2_RXbuff,USART2_buff,sizeof(USART2_RXbuff));//将USART2_buff中的数据复制到USART2_RXbuff
				//printf("复制前的数组为%d\r\n",USART2_buff[0]);
				//printf("复制后的数据为%d\r\n",USART2_RXbuff[0]);
				//printf("串口2接收数据:%s\r\n",USART2_RXbuff);//打印接收长度
				//printf("进入中断\r\n");
				memset(USART2_buff,0,sizeof(USART2_buff));    //清空缓存区
				__HAL_UART_CLEAR_IDLEFLAG(&huart2);               //清除标志位
				Usart_Flag = 1;//标志置1，启动后台程序
				
				HAL_UART_Receive_DMA(&huart2,USART2_buff,sizeof(USART2_buff));  //开DMA接收，数据存入rx_buffer数组中。
			}
	 }
 }
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* 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_DMA_Init();
  MX_USART1_UART_Init();
  MX_USART2_UART_Init();
  /* USER CODE BEGIN 2 */
  __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);//使能idle中断
  HAL_UART_Receive_DMA(&huart2,USART2_buff,sizeof(USART2_buff));//打开串口DMA接收
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
//	Usart_SendString(stress_send);
//	HAL_Delay(2000);
	if(Usart_Flag == 1)
		{
				HAL_GPIO_WritePin(GPIOG, GPIO_PIN_8, GPIO_PIN_SET);//拉高PG8
				HAL_UART_Transmit(&huart2,stress_send,sizeof(stress_send),0XFFFF);//发送数组里的字符串数据
				HAL_GPIO_WritePin(GPIOG, GPIO_PIN_8, GPIO_PIN_RESET);//拉低PG8，准备后面的接收

				USART2_cut[0]=USART2_RXbuff[3];//将接收的字符数组的第4、5个字符取出来，存到一个新数组
				USART2_cut[1]=USART2_RXbuff[4];
				pBuf[0] = USART2_cut[1];//进行字符拼接与转换成int类型
				pBuf[1] = USART2_cut[0];
				//printf("%d\r\n",USART2_RXbuff[3]);
				//printf("%d\r\n",pBuf[1]);
				printf("测得当前时刻压力值为%d\r\n",val);//打印解析出来的压力数值
				memset(USART2_RXbuff,0,sizeof(USART2_RXbuff));//清空接收数组
				Usart_Flag = 0;                        //标志位清零，防止陷入后台
				HAL_Delay(2000);
		}
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  /** 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_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 8;
  RCC_OscInitStruct.PLL.PLLN = 168;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  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_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != 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****/

3、在usart.c里面添加printf重定向函数

/**
  ******************************************************************************
  * @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 */
#include <stdio.h>
//将printf函数重定向到串口1
int fputc(int ch,FILE *f)
{
  uint8_t temp[1]={ch};
  HAL_UART_Transmit(&huart1,temp,1,0XFFFF);
  return 0;
}

/*****************  发送字符串 **********************/
//UART_HandleTypeDef UartHandle;
//void Usart_SendString(uint8_t *str)
//{
//	unsigned int k=0;
//  do 
//  {
//      HAL_UART_Transmit(&UartHandle,(uint8_t *)(str + k) ,1,1000);
//      k++;
//  } while(*(str + k)!='\0');
//  
//}



/* USER CODE END 0 */

UART_HandleTypeDef huart1;
UART_HandleTypeDef huart2;
DMA_HandleTypeDef hdma_usart2_rx;
DMA_HandleTypeDef hdma_usart2_tx;

/* USART1 init function */

void MX_USART1_UART_Init(void)
{

  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();
  }

}
/* USART2 init function */

void MX_USART2_UART_Init(void)
{

  huart2.Instance = USART2;
  huart2.Init.BaudRate = 9600;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }

}

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_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* USER CODE BEGIN USART1_MspInit 1 */

  /* USER CODE END USART1_MspInit 1 */
  }
  else if(uartHandle->Instance==USART2)
  {
  /* USER CODE BEGIN USART2_MspInit 0 */

  /* USER CODE END USART2_MspInit 0 */
    /* USART2 clock enable */
    __HAL_RCC_USART2_CLK_ENABLE();

    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**USART2 GPIO Configuration
    PA2     ------> USART2_TX
    PA3     ------> USART2_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* USART2 DMA Init */
    /* USART2_RX Init */
    hdma_usart2_rx.Instance = DMA1_Stream5;
    hdma_usart2_rx.Init.Channel = DMA_CHANNEL_4;
    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;
    hdma_usart2_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    if (HAL_DMA_Init(&hdma_usart2_rx) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart2_rx);

    /* USART2_TX Init */
    hdma_usart2_tx.Instance = DMA1_Stream6;
    hdma_usart2_tx.Init.Channel = DMA_CHANNEL_4;
    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;
    hdma_usart2_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    if (HAL_DMA_Init(&hdma_usart2_tx) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart2_tx);

    /* USART2 interrupt Init */
    HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(USART2_IRQn);
  /* USER CODE BEGIN USART2_MspInit 1 */

  /* USER CODE END USART2_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);

  /* USER CODE BEGIN USART1_MspDeInit 1 */

  /* USER CODE END USART1_MspDeInit 1 */
  }
  else if(uartHandle->Instance==USART2)
  {
  /* USER CODE BEGIN USART2_MspDeInit 0 */

  /* USER CODE END USART2_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_USART2_CLK_DISABLE();

    /**USART2 GPIO Configuration
    PA2     ------> USART2_TX
    PA3     ------> USART2_RX
    */
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_2|GPIO_PIN_3);

    /* USART2 DMA DeInit */
    HAL_DMA_DeInit(uartHandle->hdmarx);
    HAL_DMA_DeInit(uartHandle->hdmatx);

    /* USART2 interrupt Deinit */
    HAL_NVIC_DisableIRQ(USART2_IRQn);
  /* USER CODE BEGIN USART2_MspDeInit 1 */

  /* USER CODE END USART2_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

还要将中断回调函数的调用填写到stm32f407xx_it.c的中断服务函数里面去。

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    stm32f4xx_it.c
  * @brief   Interrupt Service Routines.
  ******************************************************************************
  * @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 "stm32f4xx_it.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN TD */

/* USER CODE END TD */

/* 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 -----------------------------------------------*/
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/* External variables --------------------------------------------------------*/
extern DMA_HandleTypeDef hdma_usart2_rx;
extern DMA_HandleTypeDef hdma_usart2_tx;
extern UART_HandleTypeDef huart2;
/* USER CODE BEGIN EV */

/* USER CODE END EV */

/******************************************************************************/
/*           Cortex-M4 Processor Interruption and Exception Handlers          */
/******************************************************************************/
/**
  * @brief This function handles Non maskable interrupt.
  */
void NMI_Handler(void)
{
  /* USER CODE BEGIN NonMaskableInt_IRQn 0 */

  /* USER CODE END NonMaskableInt_IRQn 0 */
  /* USER CODE BEGIN NonMaskableInt_IRQn 1 */
  while (1)
  {
  }
  /* USER CODE END NonMaskableInt_IRQn 1 */
}

/**
  * @brief This function handles Hard fault interrupt.
  */
void HardFault_Handler(void)
{
  /* USER CODE BEGIN HardFault_IRQn 0 */

  /* USER CODE END HardFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_HardFault_IRQn 0 */
    /* USER CODE END W1_HardFault_IRQn 0 */
  }
}

/**
  * @brief This function handles Memory management fault.
  */
void MemManage_Handler(void)
{
  /* USER CODE BEGIN MemoryManagement_IRQn 0 */

  /* USER CODE END MemoryManagement_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_MemoryManagement_IRQn 0 */
    /* USER CODE END W1_MemoryManagement_IRQn 0 */
  }
}

/**
  * @brief This function handles Pre-fetch fault, memory access fault.
  */
void BusFault_Handler(void)
{
  /* USER CODE BEGIN BusFault_IRQn 0 */

  /* USER CODE END BusFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_BusFault_IRQn 0 */
    /* USER CODE END W1_BusFault_IRQn 0 */
  }
}

/**
  * @brief This function handles Undefined instruction or illegal state.
  */
void UsageFault_Handler(void)
{
  /* USER CODE BEGIN UsageFault_IRQn 0 */

  /* USER CODE END UsageFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_UsageFault_IRQn 0 */
    /* USER CODE END W1_UsageFault_IRQn 0 */
  }
}

/**
  * @brief This function handles System service call via SWI instruction.
  */
void SVC_Handler(void)
{
  /* USER CODE BEGIN SVCall_IRQn 0 */

  /* USER CODE END SVCall_IRQn 0 */
  /* USER CODE BEGIN SVCall_IRQn 1 */

  /* USER CODE END SVCall_IRQn 1 */
}

/**
  * @brief This function handles Debug monitor.
  */
void DebugMon_Handler(void)
{
  /* USER CODE BEGIN DebugMonitor_IRQn 0 */

  /* USER CODE END DebugMonitor_IRQn 0 */
  /* USER CODE BEGIN DebugMonitor_IRQn 1 */

  /* USER CODE END DebugMonitor_IRQn 1 */
}

/**
  * @brief This function handles Pendable request for system service.
  */
void PendSV_Handler(void)
{
  /* USER CODE BEGIN PendSV_IRQn 0 */

  /* USER CODE END PendSV_IRQn 0 */
  /* USER CODE BEGIN PendSV_IRQn 1 */

  /* USER CODE END PendSV_IRQn 1 */
}

/**
  * @brief This function handles System tick timer.
  */
void SysTick_Handler(void)
{
  /* USER CODE BEGIN SysTick_IRQn 0 */

  /* USER CODE END SysTick_IRQn 0 */
  HAL_IncTick();
  /* USER CODE BEGIN SysTick_IRQn 1 */

  /* USER CODE END SysTick_IRQn 1 */
}

/******************************************************************************/
/* STM32F4xx Peripheral Interrupt Handlers                                    */
/* Add here the Interrupt Handlers for the used peripherals.                  */
/* For the available peripheral interrupt handler names,                      */
/* please refer to the startup file (startup_stm32f4xx.s).                    */
/******************************************************************************/

/**
  * @brief This function handles DMA1 stream5 global interrupt.
  */
void DMA1_Stream5_IRQHandler(void)
{
  /* USER CODE BEGIN DMA1_Stream5_IRQn 0 */

  /* USER CODE END DMA1_Stream5_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_usart2_rx);
  /* USER CODE BEGIN DMA1_Stream5_IRQn 1 */

  /* USER CODE END DMA1_Stream5_IRQn 1 */
}

/**
  * @brief This function handles DMA1 stream6 global interrupt.
  */
void DMA1_Stream6_IRQHandler(void)
{
  /* USER CODE BEGIN DMA1_Stream6_IRQn 0 */

  /* USER CODE END DMA1_Stream6_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_usart2_tx);
  /* USER CODE BEGIN DMA1_Stream6_IRQn 1 */

  /* USER CODE END DMA1_Stream6_IRQn 1 */
}

/**
  * @brief This function handles USART2 global interrupt.
  */
void USART2_IRQHandler(void)
{
  /* USER CODE BEGIN USART2_IRQn 0 */
	HAL_UART_RxCpltCallback(&huart2);//调用中断回调函数
  /* USER CODE END USART2_IRQn 0 */
  HAL_UART_IRQHandler(&huart2);
  /* USER CODE BEGIN USART2_IRQn 1 */

  /* USER CODE END USART2_IRQn 1 */
}

/* USER CODE BEGIN 1 */

/* USER CODE END 1 */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

四、注意事项

  1. 485通信接线是不交叉的，即A接A，B接B，可以多节点的挂载在总线上。而串口通信接线是交叉的，只能两个节点之间通信。
  2. DMA初始化后就可以接收定长的数据了，DMA加串口空闲中断可以接收不定长的数据。
  3. 本来打算用标准库的，最后HAL库真香，在大波与师弟的帮助下迈出了第一步，发个文章纪念。
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

各种问题排查

c语言

单片机

嵌入式

串口通信

STM32CubeMX使用教程——使用485总线接收变送器数据 的相关文章

随机推荐

  • 小红书web端cookie信息生成

    小红书web端的cookie包含4个参数 xhsTrackerId extra exp ids timestamp2 timestamp2 sig 前面两个参数直接携带请求小红书主页即可获取 后两个需要携带data两个参数做post请求获取

  • erp系统多少钱一套

    erp系统多少钱一套 鼎捷ERP来告诉你 ERP价格与企业的规模和职工数有关 几千块的有 从几万到几十万的也有 企业自身规模200 上千人 ERP价格几万到几十万不等 这个规模的公司 一般在行业里面都做的不错 订单量也不错 对生产过程要求比

  • Java基础-继承

    对外是一个对象 内部还是两个空间 子类信息还是放在子类空间中 父类信息还是放在父类空间中 继承的特点 子类可以继承父类的属性和行为 但是子类不能继承父类的构造器 Java是单继承模式 一个类只能继承一个直接父类 Java不支持多继承 但是支

  • JavaGUI（JavaFX）程序打包成jar包和直接运行的exe文件全过程一条龙手把手教学

    文章目录 1 先打包成jar包 Intellij IDEA为例 2 下载exe4j 3 使用exe4j打包生成可直接运行的exe文件 1 先打包成jar包 Intellij IDEA为例 在file中 gt Project Structur

  • 点击和滚动监听事件（接口）监听器

    点击和滚动监听事件 接口 实现方法 加载适配器

  • python 安装chromadb报错：hnswlib

    conda install c conda forge hnswlib

  • 《Python 计算机视觉编程》学习笔记（一）

    Python计算机视觉编程 文章目录 前言 第 1 章 基本的图像操作和处理 引言 1 1 PIL Python图像处理类库 图像读取 显示 显示对应灰度图 更改图像格式 后缀 创建缩略图 复制和粘贴图像区域 调整尺寸和旋转 1 2 Mat

  • opencv实践项目-修改表格缺失轮廓

    目录 1 背景 2 修复步骤 2 1 图像灰度化 并进行高斯模糊 2 2 对图像进行阀值处理 2 3 查找轮廓 2 4 利用存储的值了解表格的位置 2 5 提取所有的水平线和垂直线 2 6 合并垂直和水平的两个模版 3 完整代码 1 背景

  • 如何去掉 Discuz标题后缀power by discuz

    如何去掉 Discuz标题后缀power by discuz 打开如下文件 template default common header common htm php 找到如下代码 navtitle G setting bbname Pow

  • Package包 和 Library库 理解

    Library 库 一组相关功能的模块的集合 import的类库 最常用的有java util等 通过动态链接在程序中实现功能 Package 包 一个有层次的文件结构 Java源文件第一条语句 解决类冲突 包名要与文件夹一致

  • KVM管理工具

    kvm实现方式 qemu工具 qemu kvm qemu img qemu 处理器模拟器 仿真各种IO设备 将仿真设备连接至主机的物理设备 提供用户接口 基本格式 qemu kvm 选项 磁盘镜像文件 标准选项 machine type n

  • 数组应用（C）： 数据求均值

    数组应用 数据求均值 问题描述 由键盘输入读取整型数据 数据数量不超过100个 当读取到数据 1时 停止读取数据 并计算这些数据的均值 不包含 1 问题分析 给定了数据数量不超过100 若将每个输入数据分别赋值给变量 a1 a2 a3 a4

  • Aop监控所有Controller，包括void类型的response中的出参（工具类）

    一 主要坐标

  • 了解实现一个高并发的内存池——TLS Memmory Pool

    为什么需要内存池 1 效率问题 如果我们直接向系统申请内存 当我们需要频繁的申请释放内存时 就需要频繁的与系统层产生交互 多次切换用户态和内核态 而用户态和内核态之间的切换的消耗是非常大的 因此申请内存的消耗就会很大 程序效率也就随之降低了

  • 数据结构—判断一棵二叉树是否是完全二叉树（java）

    判断一棵二叉树是否是完全二叉树 一 完全二叉树的三种节点 完全二叉树有右树必有左树 节点编号和满二叉树一一对应 1 度为2的节点有n个 2 度为1的节点只能有1个 3 度为0的节点有n个 二 具体思路 1 分两个阶段 第一阶段所有节点都有左

  • Linux下安装Lua脚本

    yum install libtermcap devel ncurses devel libevent devel readline devel curl R O http www lua org ftp lua 5 3 5 tar gz

  • 密码学与网络安全-基本概念

    安全方法 安全模型 无安全性 隐藏安全 一件事物不为人知 那么它是安全的 如密码 类比代码实现防范 路径 端口等 主机安全性 网络安全性 安全管理 向有关方面解释安全策略 该要介绍每个人的责任 建立可监察性 提供预期和定期审查 安全原则 举

  • mongodb内置角色

    开发十年 就只剩下这套Java开发体系了 gt gt gt 1 内置角色组织结构图 2 角色解释 2 1数据库用户角色 针对每一个数据库进行控制 read 提供了读取所有非系统集合 以及系统集合中的system indexes system

  • 【技能树笔记】网络篇——练习题解析（二）

    目录 前言 一 数据链路层的作用 1 1 数据链路层作用 1 2 数据链路层封装 1 3 数据链路层功能 1 4 数据帧格式 二 MAC地址及分类 2 1 MAC地址 2 2 MAC地址分类 三 交换机的作用 3 1 交换机的作用 3 2

  • STM32CubeMX使用教程——使用485总线接收变送器数据

    STM32CubeMX使用485总线接收变送器数据 一 要使用的外设 二 使用STM32CubeMX生成工程 引脚配置 时钟树配置 工程管理 生成项目 三 代码编辑 四 注意事项 一 要使用的外设 USART1 引脚PA9 PA10 用于打

热门标签