1. // 添加这个函数
   
2. int fputc(int ch,FILE *f)
   
3. {
   
4.     uint8_t temp[1]={ch};
   
5.     HAL_UART_Transmit(&UartHandle,temp,1,2);
   
6. }

复制代码

MDK设置：勾选Use Micro LIB

测试板子：STM32F746NG-DISCOVERY

main.c文件

1. /* Includes ------------------------------------------------------------------*/
   
2. #include "main.h"
   
3. #include <stdio.h>
   
4. /** @addtogroup STM32F7xx_HAL_Examples
   
5.   * @{
   
6.   */
   
7. 
   
8. /** @addtogroup UART_TwoBoards_ComDMA
   
9.   * @{
   
10.   */
    
11. 
    
12. /* Private typedef -----------------------------------------------------------*/
    
13. /* Private define ------------------------------------------------------------*/
    
14. #define TRANSMITTER_BOARD
    
15. 
    
16. /* Private macro -------------------------------------------------------------*/
    
17. /* Private variables ---------------------------------------------------------*/
    
18. /* UART handler declaration */
    
19. UART_HandleTypeDef UartHandle;
    
20. __IO ITStatus UartReady = RESET;
    
21. __IO uint32_t UserButtonStatus = 0;  /* set to 1 after User Button interrupt  */
    
22. 
    
23. /* Buffer used for transmission */
    
24. uint8_t aTxBuffer[] = " ****UART_TwoBoards communication based on DMA****  ****UART_TwoBoards communication based on DMA****  ****UART_TwoBoards communication based on DMA**** ";
    
25. 
    
26. /* Buffer used for reception */
    
27. uint8_t aRxBuffer[RXBUFFERSIZE];
    
28. 
    
29. /* Private function prototypes -----------------------------------------------*/
    
30. void SystemClock_Config(void);
    
31. static void Error_Handler(void);
    
32. static uint16_t Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength);
    
33. static void MPU_Config(void);
    
34. static void CPU_CACHE_Enable(void);
    
35. 
    
36. /* Private functions ---------------------------------------------------------*/
    
37. UART_HandleTypeDef UartHandle;
    
38. uint8_t sendbuf[]="send ok ";
    
39. 
    
40. // 添加这个函数
    
41. int fputc(int ch,FILE *f)
    
42. {
    
43.     uint8_t temp[1]={ch};
    
44.     HAL_UART_Transmit(&UartHandle,temp,1,2);
    
45. }
    
46. 
    
47. /**
    
48.   * @brief  Main program
    
49.   * @param  None
    
50.   * @retval None
    
51.   */
    
52. int main(void)
    
53. {
    
54.   /* Configure the MPU attributes as Write Through */
    
55.   MPU_Config();
    
56. 
    
57.   /* Enable the CPU Cache */
    
58.   CPU_CACHE_Enable();
    
59.   /* STM32F7xx HAL library initialization:
    
60.        - Configure the Flash ART accelerator
    
61.        - Systick timer is configured by default as source of time base, but user
    
62.          can eventually implement his proper time base source (a general purpose
    
63.          timer for example or other time source), keeping in mind that Time base
    
64.          duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
    
65.          handled in milliseconds basis.
    
66.        - Set NVIC Group Priority to 4
    
67.        - Low Level Initialization
    
68.      */
    
69.   HAL_Init();
    
70. 
    
71.   /* Configure the system clock to 216 MHz */
    
72.   SystemClock_Config();
    
73.   
    
74.   /* Configure LED1 */
    
75.   BSP_LED_Init(LED1);
    
76.    
    
77.   UartHandle.Instance        = DISCOVERY_COM1;
    
78. 
    
79.   UartHandle.Init.BaudRate   = 9600;
    
80.   UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
81.   UartHandle.Init.StopBits   = UART_STOPBITS_1;
    
82.   UartHandle.Init.Parity     = UART_PARITY_NONE;
    
83.   UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    
84.   UartHandle.Init.Mode       = UART_MODE_TX_RX;
    
85.     BSP_COM_DeInit(COM1,&UartHandle);
    
86.     BSP_COM_Init(COM1,&UartHandle);
    
87.    
    
88. //    HAL_UART_Transmit(&UartHandle,sendbuf,sizeof(sendbuf),10);
    
89.   /* Configure User push-button in Interrupt mode */
    
90.   BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_EXTI);
    
91.   
    
92.   /* Wait for User push-button press before starting the Communication.
    
93.      In the meantime, LED1 is blinking */
    
94.     printf("hello");
    
95.    
    
96.    
    
97.   while(UserButtonStatus == 0)
    
98.   {
    
99.       /* Toggle LED1*/
    
100.       BSP_LED_Toggle(LED1);
     
101.       HAL_Delay(100);
     
102.   }
     
103.   /* Turn on LED1 if test passes then enter infinite loop */
     
104.   BSP_LED_On(LED1);
     
105.   /* Infinite loop */
     
106.   while (1)
     
107.   {
     
108.   }
     
109. }
     
110. 
     
111. /**
     
112.   * @brief  System Clock Configuration
     
113.   *         The system Clock is configured as follow :
     
114.   *            System Clock source            = PLL (HSE)
     
115.   *            SYSCLK(Hz)                     = 216000000
     
116.   *            HCLK(Hz)                       = 216000000
     
117.   *            AHB Prescaler                  = 1
     
118.   *            APB1 Prescaler                 = 4
     
119.   *            APB2 Prescaler                 = 2
     
120.   *            HSE Frequency(Hz)              = 25000000
     
121.   *            PLL_M                          = 25
     
122.   *            PLL_N                          = 432
     
123.   *            PLL_P                          = 2
     
124.   *            PLL_Q                          = 9
     
125.   *            VDD(V)                         = 3.3
     
126.   *            Main regulator output voltage  = Scale1 mode
     
127.   *            Flash Latency(WS)              = 7
     
128.   * @param  None
     
129.   * @retval None
     
130.   */
     
131. void SystemClock_Config(void)
     
132. {
     
133.   RCC_ClkInitTypeDef RCC_ClkInitStruct;
     
134.   RCC_OscInitTypeDef RCC_OscInitStruct;
     
135.   HAL_StatusTypeDef ret = HAL_OK;
     
136. 
     
137.   /* Enable HSE Oscillator and activate PLL with HSE as source */
     
138.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
     
139.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
     
140.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
     
141.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
     
142.   RCC_OscInitStruct.PLL.PLLM = 25;
     
143.   RCC_OscInitStruct.PLL.PLLN = 432;
     
144.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
     
145.   RCC_OscInitStruct.PLL.PLLQ = 9;
     
146.   
     
147.   ret = HAL_RCC_OscConfig(&RCC_OscInitStruct);
     
148.   if(ret != HAL_OK)
     
149.   {
     
150.     while(1) { ; }
     
151.   }
     
152.   
     
153.   /* Activate the OverDrive to reach the 216 MHz Frequency */  
     
154.   ret = HAL_PWREx_EnableOverDrive();
     
155.   if(ret != HAL_OK)
     
156.   {
     
157.     while(1) { ; }
     
158.   }
     
159.   
     
160.   /* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2 clocks dividers */
     
161.   RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
     
162.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
     
163.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     
164.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;  
     
165.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
     
166.   
     
167.   ret = HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_7);
     
168.   if(ret != HAL_OK)
     
169.   {
     
170.     while(1) { ; }
     
171.   }  
     
172. }
     
173. 
     
174. /**
     
175.   * @brief  Tx Transfer completed callback
     
176.   * @param  UartHandle: UART handle.
     
177.   * @note   This example shows a simple way to report end of DMA Tx transfer, and
     
178.   *         you can add your own implementation.
     
179.   * @retval None
     
180.   */
     
181. void HAL_UART_TxCpltCallback(UART_HandleTypeDef *UartHandle)
     
182. {
     
183.   /* Set transmission flag: trasfer complete*/
     
184.   UartReady = SET;
     
185. 
     
186.   
     
187. }
     
188. 
     
189. /**
     
190.   * @brief  Rx Transfer completed callback
     
191.   * @param  UartHandle: UART handle
     
192.   * @note   This example shows a simple way to report end of DMA Rx transfer, and
     
193.   *         you can add your own implementation.
     
194.   * @retval None
     
195.   */
     
196. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
     
197. {
     
198.   /* Set transmission flag: trasfer complete*/
     
199.   UartReady = SET;
     
200. 
     
201.   
     
202. }
     
203. 
     
204. /**
     
205.   * @brief  UART error callbacks
     
206.   * @param  UartHandle: UART handle
     
207.   * @note   This example shows a simple way to report transfer error, and you can
     
208.   *         add your own implementation.
     
209.   * @retval None
     
210.   */
     
211. void HAL_UART_ErrorCallback(UART_HandleTypeDef *UartHandle)
     
212. {
     
213.     Error_Handler();
     
214. }
     
215. 
     
216. 
     
217. /**
     
218.   * @brief EXTI line detection callbacks
     
219.   * @param GPIO_Pin: Specifies the pins connected EXTI line
     
220.   * @retval None
     
221.   */
     
222. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
     
223. {
     
224.   if(GPIO_Pin == KEY_BUTTON_PIN)
     
225.   {  
     
226.     UserButtonStatus = 1;
     
227.   }
     
228. }
     
229. 
     
230. /**
     
231.   * @brief  Compares two buffers.
     
232.   * @param  pBuffer1, pBuffer2: buffers to be compared.
     
233.   * @param  BufferLength: buffer's length
     
234.   * @retval 0  : pBuffer1 identical to pBuffer2
     
235.   *         >0 : pBuffer1 differs from pBuffer2
     
236.   */
     
237. static uint16_t Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength)
     
238. {
     
239.   while (BufferLength--)
     
240.   {
     
241.     if ((*pBuffer1) != *pBuffer2)
     
242.     {
     
243.       return BufferLength;
     
244.     }
     
245.     pBuffer1++;
     
246.     pBuffer2++;
     
247.   }
     
248. 
     
249.   return 0;
     
250. }
     
251. 
     
252. /**
     
253.   * @brief  This function is executed in case of error occurrence.
     
254.   * @param  None
     
255.   * @retval None
     
256.   */
     
257. static void Error_Handler(void)
     
258. {
     
259.   /* Turn LED1 on */
     
260.   BSP_LED_On(LED1);
     
261.   while(1)
     
262.   {
     
263.     /* Error if LED1 is slowly blinking (1 sec. period) */
     
264.     BSP_LED_Toggle(LED1);
     
265.     HAL_Delay(1000);
     
266.   }  
     
267. }
     
268. 
     
269. #ifdef  USE_FULL_ASSERT
     
270. 
     
271. /**
     
272.   * @brief  Reports the name of the source file and the source line number
     
273.   *         where the assert_param error has occurred.
     
274.   * @param  file: pointer to the source file name
     
275.   * @param  line: assert_param error line source number
     
276.   * @retval None
     
277.   */
     
278. void assert_failed(uint8_t* file, uint32_t line)
     
279. {
     
280.   /* User can add his own implementation to report the file name and line number,
     
281.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     
282. 
     
283.   /* Infinite loop */
     
284.   while (1)
     
285.   {
     
286.   }
     
287. }
     
288. #endif
     
289. 
     
290. /**
     
291.   * @brief  Configure the MPU attributes as Write Through for SRAM1/2.
     
292.   * @note   The Base Address is 0x20010000 since this memory interface is the AXI.
     
293.   *         The Region Size is 256KB, it is related to SRAM1 and SRAM2  memory size.
     
294.   * @param  None
     
295.   * @retval None
     
296.   */
     
297. static void MPU_Config(void)
     
298. {
     
299.   MPU_Region_InitTypeDef MPU_InitStruct;
     
300.   
     
301.   /* Disable the MPU */
     
302.   HAL_MPU_Disable();
     
303. 
     
304.   /* Configure the MPU attributes as WT for SRAM */
     
305.   MPU_InitStruct.Enable = MPU_REGION_ENABLE;
     
306.   MPU_InitStruct.BaseAddress = 0x20010000;
     
307.   MPU_InitStruct.Size = MPU_REGION_SIZE_256KB;
     
308.   MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
     
309.   MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
     
310.   MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;
     
311.   MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
     
312.   MPU_InitStruct.Number = MPU_REGION_NUMBER0;
     
313.   MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
     
314.   MPU_InitStruct.SubRegionDisable = 0x00;
     
315.   MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
     
316. 
     
317.   HAL_MPU_ConfigRegion(&MPU_InitStruct);
     
318. 
     
319.   /* Enable the MPU */
     
320.   HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     
321. }
     
322. 
     
323. /**
     
324.   * @brief  CPU L1-Cache enable.
     
325.   * @param  None
     
326.   * @retval None
     
327.   */
     
328. static void CPU_CACHE_Enable(void)
     
329. {
     
330.   /* Enable I-Cache */
     
331.   SCB_EnableICache();
     
332. 
     
333.   /* Enable D-Cache */
     
334.   SCB_EnableDCache();
     
335. }
     
336. 
     
337. /**
     
338.   * @}
     
339.   */
     
340. 
     
341. /**
     
342.   * @}“stdio.h”
     
343.   */
     
344. 
     
345. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

复制代码

今天调试了stm32f407的ADC，一切顺利，然而用串口发送ADC结果时都是16进制数，看着很不爽。于是打算用用牛B的“printf”函数，按照以前的做法，在main文件中添加了“stdio.h”，写好了“printf”函数，沏杯茶，打算边品茶边坐等结果，然而这一坐竟坐了半天也没见结果

。一调试发现程序停在了printf函数处，百思不得其解，百度之，得答案，不敢独享，分享如下：

STM32串口通信中使用printf发送数据配置方法(开发环境 Keil RVMDK)

标签: STM32 串口通信 printf方法 2011-06-29 23:29

在STM32串口通信程序中使用printf发送数据，非常的方便。可在刚开始使用的时候总是遇到问题，常见的是硬件访真时无法进入main主函数，其实只要简单的配置一下就可以了。

下面就说一下使用printf需要做哪些配置。

有两种配置方法：

一、对工程属性进行配置，详细步骤如下

1、首先要在你的main 文件中 包含“stdio.h” （标准输入输出头文件）。

2、在main文件中重定义<fputc>函数 如下：

// 发送数据

int fputc(int ch, FILE *f)

{

USART_SendData(USART1, (unsigned char) ch);// USART1 可以换成 USART2 等

while (!(USART1->SR & USART_FLAG_TXE));

return (ch);

}

// 接收数据

int GetKey (void) {

while (!(USART1->SR & USART_FLAG_RXNE));

return ((int)(USART1->DR & 0x1FF));

}

这样在使用printf时就会调用自定义的fputc函数，来发送字符。

3、在工程属性的 “Target" -> "Code Generation" 选项中勾选 "Use MicroLIB"”

MicroLIB 是缺省C的备份库，关于它可以到网上查找详细资料。

至此完成配置，在工程中可以随意使用printf向串口发送数据了。

二、第二种方法是在工程中添加“Regtarge.c”文件

1、在main文件中包含 “stdio.h” 文件

2、在工程中创建一个文件保存为 Regtarge.c ， 然后将其添加工程中

在文件中输入如下内容（直接复制即可）

#include <stdio.h>

#include <rt_misc.h>

#pragma import(__use_no_semihosting_swi)

extern int SendChar(int ch); // 声明外部函数，在main文件中定义

extern int GetKey(void);

struct __FILE {

int handle; // Add whatever you need here

};

FILE __stdout;

FILE __stdin;

int fputc(int ch, FILE *f) {

return (SendChar(ch));

}

int fgetc(FILE *f) {

return (SendChar(GetKey()));

}

void _ttywrch(int ch) {

SendChar (ch);

}

int ferror(FILE *f) { // Your implementation of ferror

return EOF;

}

void _sys_exit(int return_code) {

label: goto label; // endless loop

}

3、在main文件中添加定义以下两个函数

int SendChar (int ch) {

while (!(USART1->SR & USART_FLAG_TXE)); // USART1 可换成你程序中通信的串口

USART1->DR = (ch & 0x1FF);

return (ch);

}

int GetKey (void) {

while (!(USART1->SR & USART_FLAG_RXNE));

return ((int)(USART1->DR & 0x1FF));

}