STM32从零开始 - 第三章：从串口输出HelloWorld

最新推荐文章于 2024-09-01 21:50:14 发布
最新推荐文章于 2024-09-01 21:50:14 发布
阅读量2.2k 收藏 8
点赞数 1
分类专栏： ARM嵌入式 文章标签： stm32 单片机 c语言 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/diaoxuesong/article/details/110357686
版权

目录

 

前言

串口初始化

重定向C库的printf函数到串口

在main中添加测试代码

完整的main.c代码

编译下载

程序效果

扩展实验1：格式化字符串输出

扩展实验2：串口输入

前言

本章我们将使用STM32官方BSP中的串口驱动，在串口上输出HelloWorld。

 

从串口输出HelloWorld的方法

1. 简单的将HelloWorld这个字符串从串口里输出。

2. 可以将C库的printf输出重定向到串口上

本章我们使用第2种方法，因为第一种方法有太多的参考代码了。

 

串口初始化

首先我们需要将USART初始化为普通的异步串口。

USART的初始化代码，在我们第一章里，已经由STM32CubeMX自动产生出来了，因为我们当时在配置引脚的时候将PA9/PA10配置成了UART1，自动产生出的UART初始化代码请参考main.c里面的：

MX_USART1_UART_Init函数：

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static 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 */

}

以及stm32f1xx_hal_msp.c里面的函数MX_USART1_UART_Init：

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static 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 */

}

其中：MX_USART1_UART_Init是在HAL_UART_Init里面调用的。

然后我们稍微封装一下串口的输出接口：

void uart1_write(void* pdata, unsigned int len)
{
    HAL_UART_Transmit(&huart1, pdata, len, HAL_MAX_DELAY);
}

void uart1_write_byte(uint8_t value)
{
    uart1_write(&value, 1);
}

重定向C库的printf函数到串口

gcc编译器的small库需要重新实现__io_putchar即可。

而非gcc编译器，如ARMCC编译器则需要重新实现fputc。

#ifdef __GNUC__
  /* With GCC/RAISONANCE, 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__ */
/**
  * @brief  Retargets the C library printf function to the USART.
  * @param  None
  * @retval None
  */
PUTCHAR_PROTOTYPE
{
  uart1_write_byte((uint8_t)ch);
  return ch;
}

所以上面这段代码可以同时用于gcc或非gcc编译器。

在main中添加测试代码

在串口初始化后的任意地方加入HelloWorld输出语句：

printf("HelloWorld!\r\n");

完整的main.c代码

/* USER CODE BEGIN Header */
#include <stdio.h>
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2020 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"

/* 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 ---------------------------------------------------------*/
SPI_HandleTypeDef hspi2;

UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_SPI2_Init(void);
static void MX_USART1_UART_Init(void);
void uart1_write_byte(uint8_t value);
/* USER CODE BEGIN PFP */

#ifdef __GNUC__
  /* With GCC/RAISONANCE, 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__ */
/**
  * @brief  Retargets the C library printf function to the USART.
  * @param  None
  * @retval None
  */
PUTCHAR_PROTOTYPE
{
  uart1_write_byte((uint8_t)ch);
  return ch;
}

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
static void led_init(void)
{
	// PC13 is LED control PIN
	GPIO_InitTypeDef gpiodef;

	gpiodef.Pin = GPIO_PIN_13;
	gpiodef.Mode = GPIO_MODE_OUTPUT_PP;
	gpiodef.Speed = GPIO_SPEED_FREQ_HIGH;

	HAL_GPIO_Init(GPIOC, &gpiodef);
}

static void led_onoff(int onoff)
{
	if (!onoff)
	{
		// PC13 = HIGH
		HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);
	}
	else
	{
		// PC13 = LOW
		HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);
	}
}
/* 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_SPI2_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */

  led_init();

  printf("HelloWorld!\r\n");
  /* USER CODE END 2 */

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

	  led_onoff(1);
	  HAL_Delay(500);
	  led_onoff(0);
	  HAL_Delay(500);

    /* USER CODE BEGIN 3 */
  }
  /* 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_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  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_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
  /** Enables the Clock Security System
  */
  HAL_RCC_EnableCSS();
}

/**
  * @brief SPI2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_SPI2_Init(void)
{

  /* USER CODE BEGIN SPI2_Init 0 */

  /* USER CODE END SPI2_Init 0 */

  /* USER CODE BEGIN SPI2_Init 1 */

  /* USER CODE END SPI2_Init 1 */
  /* SPI2 parameter configuration*/
  hspi2.Instance = SPI2;
  hspi2.Init.Mode = SPI_MODE_MASTER;
  hspi2.Init.Direction = SPI_DIRECTION_2LINES;
  hspi2.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi2.Init.NSS = SPI_NSS_SOFT;
  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi2.Init.CRCPolynomial = 10;
  if (HAL_SPI_Init(&hspi2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI2_Init 2 */

  /* USER CODE END SPI2_Init 2 */

}

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static 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 uart1_write(void* pdata, unsigned int len)
{
    HAL_UART_Transmit(&huart1, pdata, len, HAL_MAX_DELAY);
}

void uart1_write_byte(uint8_t value)
{
    uart1_write(&value, 1);
}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();

}

/* 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 */

  /* 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,
     tex: 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****/

我们保留了之前的LED闪灯代码，这样能知道程序是否正常运行。

并且我们修正了之前闪灯接口的一个错误，LED灯亮对应的是低电平，我们之前错设为高电平了。

编译下载

编译完成后，使用STM32CubeProgrammer工具，及CH341串口下载程序到STM32开发板中。

下载方法参考LED闪烁这个章节中的程序烧录相关章节的内容。

记得用串口下载前必需将BOOT0拉高才能进入下载模式，而下载完成后需要将BOOT0拉低才能启动之前烧进去的程序。

程序效果

连线：CH341线除了3.3V和GND外，还需要连接串口线，就是下载口的连接方式。

程序下载烧录完成后不用拔掉TX/RX线，我们的HelloWorld就是从STM32的Tx（PA9）上输出到CH341的Rx上的。

扩展实验1：格式化字符串输出

我们是用printf来输出的HelloWorld，也就是说，我们可以用printf来输出格式化字符串，测试语句：

{
	  int ia = 123;
	  char cb = 'A';
	  char *strc = "HelloWorld";
	  unsigned int hd = 0xA5;

	  printf("ia: %d\r\n", ia);
	  printf("cb: %d\r\n", cb);
	  printf("strc: %s\r\n", strc);
	  printf("hd: 0x%02X\r\n", hd);
  }

实际串口输出内容：

看起来格式化输出没问题了，然后在后续的实验里，我们就可以实验printf来输出一些调试日志了。

扩展实验2：串口输入

既然我们已经将串口初始化了，那么我们理论上是可以用串口接收来自上位机的数据的，这里我们的上位机就是连接CH341的电脑。

我们简单封装一个读串口的接口：

int uart1_read(void* pdata, unsigned int len)
{
    int ret = 0;
    if (HAL_OK != HAL_UART_Receive(&huart1, pdata, len, HAL_MAX_DELAY))
    {
        ret = -1;
    }
    else
    {
        ret = len;
    }

    return ret;
}

int uart1_read_byte(void)
{
    int bytedata = 0;
    if (1 != uart1_read(&bytedata, 1))
    {
        bytedata = -1;
    }

    return bytedata;
}

测试代码：

{
    int chtmp = uart1_read_byte();
    if (chtmp >= 0)
    {
        uart1_write_byte((uint8_t)chtmp);
    }
    else
    {
        uart1_write_byte(0xFF);
    }
}

这个测试代码是一个ECHO功能：将从串口上接收到的内容原样输出到串口上去。

我们将他放到while循环中去，这样程序就能监听串口，并将串口上的数据echo回去。

/* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
	  {
	      int chtmp = uart1_read_byte();
	      if (chtmp >= 0)
	      {
	          uart1_write_byte((uint8_t)chtmp);
	      }
	      else
	      {
	          uart1_write_byte(0xFF);
	      }
	  }

	  led_onoff(1);
	  HAL_Delay(500);
	  led_onoff(0);
	  HAL_Delay(500);

    /* USER CODE BEGIN 3 */
  }

原来的LED闪灯还在，但是这里闪灯的节奏会被串口读取的动作打乱，程序效果是当电脑发送一个字节给STM32开发板，程序会将字节内容发回给电脑，并控制灯亮灭一次。

实验输出：

当我们通过电脑向STM32发送Ab后，STM32将受到的A和b分别发送回给电脑了。

注意：由于我们在LED闪灯那里做了延时，所以此处不能一次发送多个字节，否则会因为LED闪灯等待时间中串口FIFO中的数据没有被及时读走而导致串口数据接收不完整。

 

 

 

从零开始学STM32-M3
weixin_43961941的博客
01-04 524
自用
基于 MDK 创建 STM32 汇编程序：串口输出 Hello world
m0_65923764的博客
10-22 196
输出的字符是一个一个的输出，效率很低。
从零开始学习STM32（一）
m0_60322729的博客
03-31 969
（一）软件准备 KEIL Keil C51是美国Keil Software公司出品的51系列兼容单片机C语言软件开发系统，与汇编相比，C语言在功能上、结构性、可读性、可维护性上有明显的优势，因而易学易用。Keil提供了包括C编译器、宏汇编、链接器、库管理和一个功能强大的仿真调试器等在内的完整开发方案，通过一个集成开发环境（μVision）将这些部分组合在一起。运行Keil软件需要WIN98、NT、WIN2000、WINXP等操作系统。如果你使用C语言编程，那么Keil几乎就是你的不二之选，即使不使用C语
零基础快速上手STM32开发
hxsln11的博客
08-26 806
作为一名嵌入式工程师，STM32 是必须要学习的一款单片机，同时这款单片机资料足够多，而且比较简单，非常适合初学者入门。STM32 是一款由 STMicroelectronics 公司开发的 32 位微控制器，由于其强大的处理能力和广泛的应用领域，如嵌入式系统、物联网设备、机器人等，而受到了广泛的欢迎。但对于零基础的初学者来说，STM32 既没屏幕也没键盘，除了上电以外根本就不知道如何开发它。没关系，不用担心，本文将为你提供一个完整的、详细的手把手教程，帮助你从零开始搭建 STM32 开发环境。
从零开始——STM32学习日记
BIANJIAG的博客
08-22 1309
本人最近刚接触STM32单片机，可以说是一个100%的新手小白，对于单片机的一些基础概念很容易弄混淆，比如认为GPIO与串口是两个差不多的接口。但随着不断的学习，这些概念开始有了一些理解，希望能给同样为新手的朋友一些帮助。点击这里。本文只是对GPIO的一些简单的认识，许多都是基于他人的讲解，因此若有什么需要补充和不正确的地方，欢迎大家批评指正。
cortex 介绍
kwame211的博客
11-20 1463
ARM公司在经典处理器ARM11以后的产品改用Cortex命名，并分成A、R和M三类，旨在为各种不同的市场提供服务。 Cortex系列属于ARMv7架构，这是到2010年为止ARM公司最新的指令集架构。（2011年，ARMv8 架构在 TechCon 上推出）ARMv7架构定义了三大分工明确的系列：“A”系列面向尖端的基于虚拟内存的操作系统和用户应用；“R”系列针对实时系统；“M”系列对微控制器。 由于应用领域不同，基于v7架构的Cortex处理器系列所采用的技术也不相同，基于v7A的称为Co...
STM32 汇编程序——串口输出 Hello world
weixin_54089068的博客
10-24 2391
文章目录一、UART介绍二、项目建立及编译1.新建项目2.代码3.编译三、电路连接及烧录1.串口连接2.烧录四、串口输出五、总结参考链接 一、UART介绍 通用同步异步收发器(Universal Synchronous Asynchronous Receiver and Transmitter)是一 个串行通信设备，可以灵活地与外部设备进行全双工数据交换。有别于 USART 还有一个 UART(Universal Asynchronous Receiver and Transmitter)，它是在 USA
基于STM32实现串口通信输出hello windows！
qq_52340288的博客
10-17 1763
基于STM32F103C8芯片利用STM32CubeMX以及keil实现串口通信接收hello windows!
STM32的USART串口通信——串口输出hello windows!
qq_59341567的博客
10-16 2123
STM32的USART串口通信——串口输出hello worlds!
从零开始构建矽璓工业物联操作系统：使用ARM架构的STM32F407-discovery开发板
AIIT_Ubiquitous的博客
04-27 1291
XiUOS (X Industrial Ubiquitous Operating System) 矽璓工业物联操作系统是一款面向工业物联场景的泛在操作系统，来自泛在操作系统研究计划。所谓泛在操作系统(UOS: Ubiquitous Operating Systems)，是支持互联网时代人机物融合泛在计算应用模式的新型操作系统，是传统操作系统概念的泛化与延伸。在泛在操作系统技术体系中，不同的泛在计算设备和泛在应用场景需要符合各自特性的不同UOS，XiUOS即是面向工业物联场景的一种UOS，主要由一个极简的微型
[STM32]从零开始的STM32标准库环境搭建（小白向）
最新发布
c858845275的博客
09-01 3300
讲述了STM32F103C8T6标准库工程创建以及部分错误解决方案！
stm32中的“hello world”
pengmingjv的博客
12-09 1543
stm32中的“hello world”hello world 这是本人第一次书写博客，写的不好，大家多多担待！！！ 本人是一名爱好嵌入式编程的学生，在自学stm32的时候，收获不小，在这里分享给大家 自学的过程中最困难的就是寻找资源，因此遇到了不少的问题，所以我想为那些有理想去没有头绪的朋友提供一下帮助，共同进步。 hello world 大家学习c语言的时候，第一个编写程序的时候，肯定是输出h...
Proteus仿真STM32读取DHT11并串口打印输出
weixin_48220838的博客
02-10 3039
Proteus仿真STM32读取DHT11并串口打印输出 并解决一些仿真上的坑。
STM32输出调试信息-printf重定向到串口
uddzhi的博客
09-09 4919
在STM32调试过程中常常需要将调试信息输出到串口，然后通过串口助手查看输出的调试信息。一般来说，串口输出的是指定长度的十六进制字节，对于想打印的调试信息来 说，略显灵活性不足。这时候如果可以将printf重定向到串口输出，则能很好的解决这个问题。 关于printf重定向的方法有很多种，这里只讨论一种我认为相对简单实用的方法。其主要方法步骤如下： 1、配置STM32的串口，确保STM32能输
STM32HAL库函数
c1278943913的博客
05-25 1万+
STM32HAL库 概述 本文本是我对我自己平日里使用STM32的总结，结合了网上和自己的理解，方便自己以后回顾学习。只包含在学习过程有用到的。 1.GPIO (1)HAL_GPIO_DeInit 功能：这个函数的主要功能是将我们在1函数初始化之后的引脚恢复成默认的状态，即各个寄存器复位时的值 例：HAL_GPIO_DeInit(GPIOx,GPIO_PIN_X); (2)HAL_GPIO_EXTI_Callback 功能：这个函数是中断回调函数，可以理解为中断函数具体要响应的动作 例：H
STM32学习笔记-SMT32使用HAL库UART中断方式使用
热门推荐
weixin_54778315的博客
10-20 1万+
发送数据 和 接受不定长度的数据 并对数据进行简单约定处理
STM32 - HAL库UART串口
如图所示
02-20 1547
USART1_BASE被强制转换为USART_TypeDef的起始地址，内存空间将以USART_TypeDef类型进行构建，首址为USART1_BASE，空间内有成员，按其固有类型顺序依次分配内存空间。第一行表示：名为huart1的、类型为UART_HandleTypeDef型的一个结构体。第二行表示：名为huart2的、类型为UART_HandleTypeDef型的一个结构体。常量强制转化为一个结构体指针，该常量为结构体的起始地址。stm32f1xx_hal_uart.h文件。USART1是一个宏。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值