STM32 CUBEMX生成程序制作任意串口使用printf函数

最新推荐文章于 2025-06-23 11:13:10 发布
最新推荐文章于 2025-06-23 11:13:10 发布
阅读量867 收藏 17
点赞数 9
CC 4.0 BY-SA版权
文章标签： stm32 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/glgsy/article/details/147117264

一般来说，在HAL库中，我们会重写fputc或者_write函数，使得printf的输出通过某个特定的串口发送。比如，如果只针对USART1，可以这样做：

#include <stdio.h>

int __io_putchar(int ch) {
    HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, HAL_MAX_DELAY);
    return ch;
}

然后，在工程设置里勾选使用MicroLIB或者在链接器选项中做相应配置。

如果想要多串口使用，需要创建一个通用的可变参数函数，用于向指定串口发送格式化数据：

  1. 使用STM32CubeMX初始化所需的串口（如USART1、USART2、USART3）。

按照需求设置好串口的波特率、数据位、停止位、奇偶校验

此处我按照我这边需求设置USART1为57600波特率、数据位8、停止位2、无奇偶校验

由于我需要在串口1收到数据后，发送到串口2，所有需要串口1打开中断。

USART2设置为9600波特率、数据位8、停止位1、无奇偶校验。USART3没配置。

设置完串口后设置时钟为72MHZ

最后生成程序

在usart.c中加入函数USART_printf

void USART_printf (UART_HandleTypeDef *huart,char *fmt, ...)
{
    static char buffer[256];
    va_list args;
    va_start(args,fmt);
    vsprintf(buffer,fmt,args);
    va_end(args);
    HAL_UART_Transmit(huart,(uint8_t*)buffer,strlen(buffer),0xFFFFFFFFU);
}

可以printf功能实现，USART_printf(&huart2,"Temperature = %0.1f \n",Temperature);

为了实现串口1收到数据后发送到串口2：

在MX_USART1_UART_Init(void)中开启中断接收，

HAL_UART_Receive_IT(&huart1, (uint8_t *)aRxBuffer, 6);   //开启中断，接收数据，放入aRxBuffer数组，每次接收6个

重定向HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)，串口1接收完后再次启用中断接收HAL_UART_Receive_IT(&huart1, (uint8_t *)aRxBuffer,6);  //重新开启中断，接收数据，放入aRxBuffer数组，每次接收6个。

在main中循环发送串口1收到的数据，我这里分为2段从串口2发送出去。完整程序usart.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    usart.c
  * @brief   This file provides code for the configuration
  *          of the USART instances.
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2025 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "usart.h"

/* USER CODE BEGIN 0 */
#include <stdarg.h>
#include <stdio.h>
#include <string.h>

uint8_t aRxBuffer[6];  //设置串口1接收缓存数组，每次接收6个数据
/* USER CODE END 0 */

UART_HandleTypeDef huart1;
UART_HandleTypeDef huart2;

/* 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 = 57600;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_2;
  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 */
HAL_UART_Receive_IT(&huart1, (uint8_t *)aRxBuffer, 6);   //开启中断，接收数据，放入aRxBuffer数组，每次接收6个
  /* USER CODE END USART1_Init 2 */

}
/* USART2 init function */

void MX_USART2_UART_Init(void)
{

  /* USER CODE BEGIN USART2_Init 0 */

  /* USER CODE END USART2_Init 0 */

  /* USER CODE BEGIN USART2_Init 1 */

  /* USER CODE END USART2_Init 1 */
  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();
  }
  /* USER CODE BEGIN USART2_Init 2 */

  /* USER CODE END USART2_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, 0, 0);
    HAL_NVIC_EnableIRQ(USART1_IRQn);
  /* 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_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_3;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

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

    /* USART1 interrupt Deinit */
    HAL_NVIC_DisableIRQ(USART1_IRQn);
  /* 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);

  /* USER CODE BEGIN USART2_MspDeInit 1 */

  /* USER CODE END USART2_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */
//printf功能实现函数：
//USART_printf(&huart1,"Temperature = %0.1f \n",Temperature);
//HAL_Delay(500);
//USART_printf(&huart2,"Temperature = %0.1f \n",Temperature);
void USART_printf (UART_HandleTypeDef *huart,char *fmt, ...)
{
    static char buffer[256];
    va_list args;
    va_start(args,fmt);
    vsprintf(buffer,fmt,args);
    va_end(args);
    HAL_UART_Transmit(huart,(uint8_t*)buffer,strlen(buffer),0xFFFFFFFFU);
}


void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart->Instance==USART1)    
	{
		
		HAL_UART_Receive_IT(&huart1, (uint8_t *)aRxBuffer,6);  //重新开启中断，接收数据，放入aRxBuffer数组，每次接收6个
}
}
/* USER CODE END 1 */

main.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2025 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* 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 */
uint32_t ux1_dat,ux2_dat;
/* 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 */

  /* 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();
  MX_USART2_UART_Init();
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

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

    /* USER CODE BEGIN 3 */
		ux1_dat=(aRxBuffer[0] << 16) | (aRxBuffer[1] << 8) | aRxBuffer[2];
		USART_printf(&huart2,"n1.val=%d\xff\xff\xff",ux1_dat); //发送数据到串口2
		
		ux2_dat=(aRxBuffer[3] << 16) | (aRxBuffer[4] << 8) | aRxBuffer[5];
		USART_printf(&huart2,"n0.val=%d\xff\xff\xff",ux2_dat); //发送数据到串口2
  }
  /* 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();
  }
}

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

glgsy
关注
STM32CubeMX串口配置及库printf打印
sudaroot的博客
12-05 1万+
最新版STM32CubeMXV5.0.0已经上传到了网盘，或者自己通过软件在线升级。     STM32CubeMX运行环境搭建包含两个部分。首先是 Java运行环境安装，其次是STM32CubeMX软件安装。Java 软件和STM32CubeMX 软件都可以在官网找到最新的下载。         1. Java运行环境，大家可以到 Java 官网 www.java.com下载最新的 Java...
STM32CubeMx配置串口（HAL库开发）
m0_58832575的博客
05-22 1959
STM32CubeMx配置串口
STM32CubeMX 配置 USART 及 Keil 实现 Printf 教程
最新发布
qq_61187125的博客
06-23 787
本教程详细阐述了借助 STM32CubeMX 配置 USART，并在 Keil 编译器中实现 Printf 函数的完整过程。开篇介绍开发所需的软硬件环境，STM32CubeMX、Keil MDK - ARM 及对应器件支持包。在配置环节，通过 STM32CubeMX 新建工程，完成时钟树、USART 参数设定，选择异步通信模式，配置波特率等关键参数，并生成适配 Keil 的工程代码。在 Keil 开发环境中，通过重定向 fputc 函数，使
STM32 CubeMX学习实验7：USART printf打印和串口接收特定数据包
qq_46038320的博客
10-23 3712
学过C语言的同学都知道printf函数，是打开C语言大门的一个函数，如何在stm32上使用该函数呢！要在stm32上使用printf函数，需要对printf进行重定向，把串口发送的数据通过printf打印出来对printf重定向后，避免使用半主机模式二导致库函数程序无法运行，使用微库Micro LIB可以避免半主机模式，在keil中点击Options for Target...，勾选Use Micro LIB，点击OK即可。
STM32CubeMx生成的工程中使用Printf函数调试和IAP
u010134355的博客
06-08 1334
原文链接：https://blog.youkuaiyun.com/mynameislinduan/article/details/83579725 stm32cubemx工程，freerots stm32cubemx调用printf stm32 iap，stm32在线下载 stm32cubemx在线烧录 stm32 调用printf函数 stm32重定向printf函数输出 stm32串口printf输出 stm32进入dfu stm32cubemx IAP，stm32cubemx duf stm32cubemx在线
STM32CubeMX printf设置
weixin_43861166的博客
08-04 1348
STM32CubeMX printf设置 STM32F407ZGT6 1，打开STM32CubeMX，选择自己的芯片。小编这里选择的是STM32F407ZGT6。选择后，配置时钟来源。小编这里高速时钟保持默认，低速时钟为外部输入，如下图一所示： 图一 2，配置下载器，小编本想选择SW下载器，奈何手头上的SW下载器没有nRST引脚，只能使用JTAG下载器了；配置如下图所示： 图二 3，选择串口，小编这里串口1用作串口4G远程下载数据，配出的打印输出串口为串口2，设置如下图所示，后面还会编写收发数据，这里把
STM32CUBEMX实现PRINTF
qq_41465999的博客
11-07 1473
一般情况下，用一个串口打印的话，重写一下fputc()函数，就可以了，keil选项里面一定要勾上uUse MicorLIB #include <stdio.h> int fputc(int ch, FILE *file) { return HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, HAL_MAX_DELAY); } 这样就可以在包含头文件stdio.h直接使用printf。## STM32CUBEMX实现PRINTF ...
STM32CUBEMX 生成的HAL库，使用非KEIL，编译存在一个printf,不能输出，或者仿真卡死，或者仿真点击三次运行
03-02
STM32CUBEMX是一款由STMicroelectronics提供的配置工具，用于快速设置和初始化STM32微控制器。它自动生成HAL（硬件抽象...在使用STM32CUBEMX生成的HAL库时，确保正确配置和理解编译器需求，有助于避免和解决这类问题。
HAL库+CubeMX+Stm32F405 实现串口定长收发、printf函数使用、自定义打印函数
07-23
HAL库+CubeMX+Stm32F405 实现串口定长收发、printf函数使用、自定义打印函数 详情请看：https://lindoglog.blog.youkuaiyun.com/article/details/107463926
STM32CubeMx配置串口使用printf函数打印数据（HAL库开发）
m0_58832575的博客
05-24 6079
HAL库开发串口，打印printf
STM32F103单片机使用STM32CubeMX创建IAR串口工程
HXYDJ的博客
12-08 835
最后编译下载程序,在串口回调函数中打个断点，使用USB转TTL连接单片机的PA10和PA9引脚，使用串口工具发送一个字母q，可以看到串口中断已经进去了，接收到的数据也是q。接下来设置时钟，选择时钟配置，左下角时钟源选择HSE，然后在HCLK的位置直接输入需要输出的时钟值，这里设置72，按回车键。接下里设置串口参数，这里直接使用默认值，波特率115200，8位数据位，1位停止位，无校验位，发送和接收模式。接下来设置工程名，选择工程存储的位置，设置编译器的类型，和编译器最低版本。这里的编译器选择为IAR。
STM32CubeMX生成代码后汉字乱码解决方法
HXYDJ的博客
12-19 2278
总的来说汉字乱码的原因就是UTF-8和GB2312这两种格式再IAR这个编译器中不会自动转换，需要使用vscode软件手动转换代码格式。这是由于，STM32CubeMX生成的代码默认的是UTF-8格式，这里虽然把编译器的编码格式改了，但是代码本身其实还是UTF-8格式。这个打印函数是在main.c文件中，在VScode 使用UTF-8格式打开，然后编码格式另存为GB2312。此时代码中的汉字是正常的，接着再点击右下角的编码格式。此时代码的注释是汉字，但是使用IAR软件打开之后汉字是乱码。
【嵌入式学习-STM32CubeMX篇】配置HAL库串口并重定向printf和getchar函数
zengchenAAA的博客
10-25 3068
通过重定向这两个函数，可以实现对printf和getchar等高级函数的重定向，并且可以在更底层的级别上控制字符的输入和输出。同样，可以使用其他标准库函数，如fgets、fscanf等，它们依赖于getchar函数的输入。这样，可以通过重定向这两个函数，同时重定向其他使用fputc和fgetc的函数，如puts、fgets等，实现整个输入/输出流的重定向。需要注意的是，启用中断会增加代码复杂性和处理器负担，因此在使用中断之前，您需要仔细考虑系统的需求和性能要求，确保正确配置和处理中断，以充分利用其优势。
STM32CubeMx使用FreeRTOS搭建printf输出串口打印-----基于正点原子开发板阿波罗
热爱科技，物联，程序开发等
02-01 5815
主要是使用STMCubeMx在正点原子阿波罗下配置USART1的配置，重定向printf,并且加入FreeRTOS实习操作系统，本篇主要是做为笔记，参考资料也已经列出
STM32CubeMx启动串口调试功能Printf调试
热门推荐
Done Lin的专栏
08-23 1万+
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.youkuaiyun.com/u012163234/article/details/52712477 https://blog.youkuaiyun.com/u014256685/article/details/45893097 关键词：stm32调试，printf，cubeMX调试模式，Stm32CubMx调试，MD...
STM32CubeMX工程printf问题
willhu2008的专栏
09-30 893
利用STM32CubeMX创建了一个带FreeRTOS系统的工程，使能多线程保护。然后在任务函数中调用了printf函数。可是电脑的串口上没有信息输出，程序进入了硬件错误中断。原来是因为自动生成的串口初始化函数MX_LPUART1_UART_Init中，只初始化了UART，没有调用初始化IO引脚的函数。在后面加上IO引脚初始化函数就可以有打印输出了。
STM32CubeMX重定向printf输出至串口
范子琦的博客
02-27 8929
STM32CubeMX重定向printf输出至串口 第一步,CubeMX配置串口(GPIO配置略) 第二步,包含头文件 #include <stdio.h> 第三步,勾选Use Microlib 第四步,重定向printf,此处需要将huart2改为上面配置的串口 int fputc(int c, FILE *stream) { HAL_UART_Transmit(&huart2, (unsigned char *)&c, 1, 1000); retu
STM32CubeMX之Basic-创建工程模板和printf输出
while（1）
08-08 3229
介绍使用STM32CubeMX创建工程，以及简单的使用引脚做Input和Output
stm32cubemx printf重定向
06-28
### 回答1： 在使用STM32CubeMX时，可以通过重定向printf函数来将输出信息发送到串口或其他设备上。具体实现方法是在main函数中调用HAL_UART_MspInit函数，然后在该函数中设置串口的参数和初始化。接着，在main函数中调用printf函数时，将输出信息重定向到串口上即可。需要注意的是，需要在编译器中开启printf重定向功能。 ### 回答2： STM32CubeMX是针对ST公司的MCU系列开发的一套可视化工具，能够帮助用户快速配置系统时钟、外设等资源。在STM32CubeMX提供的工程中，用户可以选择使用标准外设库或者CubeHAL来编写代码。 其中，使用CubeHAL时，printf输出需要进行重定向才能够在串口或者LCD等外设上显示。重定向的本质是将printf函数中的字符通过串口或者LCD等外设进行输出，这样就可以打印一些调试信息，方便用户调试程序。 在使用CubeHAL时，重定向printf输出有如下步骤： 1. 在main函数中，调用HAL_Init函数进行初始化。 2. 在调用HAL_Init函数之后，调用重定向函数void SystemClock_Config(void)，该函数会配置系统时钟，初始化uart串口。 3. 在重定向函数中，使用HAL_UART_MspInit函数对UART进行初始化，并且使用HAL_UART_Transmit函数将printf输出的字符通过串口进行输出。 4. 在main函数中，使用如下代码重新定义printf函数： ``` int __io_putchar(int ch) { HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xFFFF); return ch; } int _write(int file, char *ptr, int len) { int i = 0; for (i = 0; i < len; i++) { __io_putchar(*ptr++); } return len; } ``` 5. 在用户程序中使用printf进行输出时，printf函数的输出结果就会被重定向到串口上显示。 需要注意的是，在使用CubeHAL时，由于使用了库函数，所以代码大小和RAM占用会比较大。因此，在开发时需要谨慎使用库函数，并合理地编写代码，以尽可能减小代码大小和RAM占用。 ### 回答3： 在使用STM32CubeMX开发STM32芯片时，printf是一个常用的调试工具，但默认情况下，printf输出的信息无法通过串口或其他外设进行传输或显示。这时就需要使用printf重定向。 重定向即是将printf的输出定向到指定的外设上，比如串口、LCD显示屏等。重定向的实现需要用户编写一些特定的函数和配置一些寄存器。下面以重定向到串口为例进行说明。 首先需要在STM32CubeMX中配置串口。在Pinout&Configuration下，选中对应的串口，设置波特率、数据位、停止位等参数。 接着，在代码中打开中断，并实现重定向函数。重定向函数的目的是将输出数据写入串口的数据缓冲区，并触发发送中断。这里需要定义一个全局变量，记录重定向的默认输出设备，如下所示： ```c #define UARTout USART1 //默认输出设备 int __io_putchar(int ch) { HAL_UART_Transmit_IT(&UARTout, (uint8_t *)&ch, 1); //写入数据，触发发送中断 return ch; } ``` 在main函数中打开中断，如下所示： ```c int main(void) { HAL_Init(); SystemClock_Config(); MX_GPIO_Init(); MX_USART1_UART_Init(); HAL_UART_Transmit_IT(&UARTout, (uint8_t *)"start....\n", 10); //重定向输出测试 HAL_NVIC_EnableIRQ(USART1_IRQn); //开启串口1中断 while (1) { } } ``` 最后，在串口发送完成中断服务函数USART1_IRQHandler()中，判断数据是否发送完成，完成时关闭发送中断，如下所示： ```c void USART1_IRQHandler(void) { if (__HAL_UART_GET_FLAG(&UARTout, UART_FLAG_TC) != RESET) { __HAL_UART_CLEAR_FLAG(&UARTout, UART_FLAG_TC); __HAL_UART_DISABLE_IT(&UARTout, UART_IT_TC); //数据发送后，关闭中断 } } ``` 以上就是printf重定向到串口的实现过程。在实际应用中，可以将重定向函数进行修改，实现重定向到其他外设的输出方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值