STM32 中重定向printf 和 scanf

最新推荐文章于 2024-05-14 14:51:52 发布
最新推荐文章于 2024-05-14 14:51:52 发布
阅读量4.8k 收藏 7
点赞数
分类专栏： STM32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/graduation201209/article/details/79028792
版权

uart.c

  如果使用#pragma import(__use_no_semihosting),则在MDK中不勾选use Microlib。当前代码直接重定向没使用#pragma import(__use_no_semihosting),故需要选择use Microlib。

   

#include "usart.h"
#include <stdio.h>
#include <string.h>
#include "ad5592.h"
#include "ad5766.h"
#include "ad7699.h"
// 	
#define SELF_CHECK_CMD_R    			0x01
#define SELF_CHECK_CMD_T    			0x02
#define LASER_CMD_R         			0x03
#define LASER_CMD_T         			0x04
#define LASER_PARAMETER_CMD_R     0x05
#define LASER_PARAMETER_CMD_T     0x06
#define TEC_PARAMETER_CMD_R       0x07
#define TEC_PARAMETER_CMD_T       0x08
#define MODULATOR_CMD_R           0x09
#define MODULATOR_CMD_T           0x0A
#define FFT_CMD_R                 0x0B
#define FFT_CMD_T                 0x0C


//如果使用os,则包括下面的头文件即可.
#if SYSTEM_SUPPORT_OS
#include "includes.h"					//os 使用	  
#endif
	  UART_HandleTypeDef UART1_Handler; //UART句柄
//加入以下代码,支持printf函数,而不需要选择use MicroLIB	  
//#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)	
#if 0
#pragma import(__use_no_semihosting)             
//标准库需要的支持函数                 
struct __FILE 
{ 
	int handle; 
}; 

FILE __stdout;       
//定义_sys_exit()以避免使用半主机模式    
void _sys_exit(int x) 
{ 
	x = x; 
} 
//重定义fputc函数 
int fputc(int ch, FILE *f)
{ 	
	while((USART1->ISR&0X40)==0);//循环发送,直到发送完毕   
	USART1->TDR=(u8)ch;      
	return ch;
}
#endif 

#if 1
	//重定义fputc函数 
int fputc(int ch, FILE *f)
{ 	
	while((USART1->ISR&0X40)==0);//循环发送,直到发送完毕   
	//USART1->RQR |= USART_RQR_TXFRQ;
	USART1->TDR=(u8)ch;      
	return ch;
}

int fgetc(FILE *f)
{
	while((USART1->ISR & UART_FLAG_RXNE) == RESET);
	//USART1->RQR |= USART_RQR_RXFRQ;
	return (int)(USART1->RDR);

}


#endif



#if EN_USART1_RX   //如果使能了接收
//串口1中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误   	
u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，	接收完成标志
//bit14，	接收到0x0d
//bit13~0，	接收到的有效字节数目
u16 USART_RX_STA=0;       //接收状态标记	
u16 gUsartOneReceiveFlag = 0;      //接收到一帧数据标志
u8 aRxBuffer[RXBUFFERSIZE];       //HAL库使用的串口接收缓冲
u8 gFrameInfo[RXBUFFERSIZE];
u16 gADC5767_ADCVal[8];

u8 FFT_Flag = 0;                  //FFT实时数据上报标志
extern ad5766_dev *dev;


typedef struct{
	uint16_t Head;
	uint8_t  SourceID;
	uint8_t  DestinationID;
	uint8_t  Command;
	uint8_t  Data[9];
	uint16_t Tail;
}FrameInfo_TypeDef;



//初始化IO 串口1 
//bound:波特率
void uart_init(u32 bound)
{	
	//UART 初始化设置
	UART1_Handler.Instance=USART1;					            //USART1
	UART1_Handler.Init.BaudRate=bound;				          //波特率
	UART1_Handler.Init.WordLength=UART_WORDLENGTH_8B;   //字长为8位数据格式
	UART1_Handler.Init.StopBits=UART_STOPBITS_1;	      //一个停止位
	UART1_Handler.Init.Parity=UART_PARITY_NONE;		      //无奇偶校验位
	UART1_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;   //无硬件流控
	UART1_Handler.Init.Mode=UART_MODE_TX_RX;		        //收发模式
	HAL_UART_Init(&UART1_Handler);					            //HAL_UART_Init()会使能UART1
	
	//HAL_UART_Receive_IT(&UART1_Handler, (u8 *)aRxBuffer, RXBUFFERSIZE);//该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量
  
} 

//UART底层初始化，时钟使能，引脚配置，中断配置
//此函数会被HAL_UART_Init()调用
//huart:串口句柄

void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{
    //GPIO端口设置
	GPIO_InitTypeDef GPIO_Initure;
	
	if(huart->Instance==USART1)//如果是串口1，进行串口1 MSP初始化
	{
		__HAL_RCC_GPIOA_CLK_ENABLE();			//使能GPIOA时钟
		__HAL_RCC_GPIOB_CLK_ENABLE();			//使能GPIOA时钟
		__HAL_RCC_USART1_CLK_ENABLE();			//使能USART1时钟
	  
		#if 1
		GPIO_Initure.Pin=GPIO_PIN_9;			//PA9
		GPIO_Initure.Mode=GPIO_MODE_AF_PP;		//复用推挽输出
		GPIO_Initure.Pull=GPIO_PULLUP;			//上拉
		GPIO_Initure.Speed=GPIO_SPEED_FAST;		//高速
		GPIO_Initure.Alternate=GPIO_AF7_USART1;	//复用为USART1
		HAL_GPIO_Init(GPIOA,&GPIO_Initure);	   	//初始化PA9

		GPIO_Initure.Pin=GPIO_PIN_10;			//PA10
		HAL_GPIO_Init(GPIOA,&GPIO_Initure);	   	//初始化PA10
		#endif
		
		#if 0
		GPIO_Initure.Pin=GPIO_PIN_6;			       //PB6
		GPIO_Initure.Mode=GPIO_MODE_AF_PP;		   //复用推挽输出
		GPIO_Initure.Pull=GPIO_PULLUP;			     //上拉
		GPIO_Initure.Speed=GPIO_SPEED_FAST;		   //高速
		GPIO_Initure.Alternate=GPIO_AF7_USART1;	 //复用为USART1
		HAL_GPIO_Init(GPIOB,&GPIO_Initure);	   	 //初始化PB6

		GPIO_Initure.Pin=GPIO_PIN_7;			       //PB7
		HAL_GPIO_Init(GPIOB,&GPIO_Initure);	   	//初始化PB7
		#endif
#if EN_USART1_RX
		HAL_NVIC_EnableIRQ(USART1_IRQn);				    //使能USART1中断通道
		HAL_NVIC_SetPriority(USART1_IRQn,0,0);			//抢占优先级3，子优先级3
#endif	
	}

}

//接收完成处理回调函数
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;//接收数据错误,重新开始接收	  
//				}		 
//			}
		   memset(gFrameInfo, 0, RXBUFFERSIZE);	
			 memcpy(gFrameInfo, aRxBuffer, RXBUFFERSIZE);
		   gUsartOneReceiveFlag = 1; //接收一帧数据标志，待处理
		   HAL_UART_Receive_IT(&UART1_Handler,(u8 *)aRxBuffer, RXBUFFERSIZE);
		  //}

	}
}

#if 0
//串口1中断服务程序
void USART1_IRQHandler(void)                	
{ 
	u32 timeout=0;
    u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS	 	//使用OS
	OSIntEnter();    
#endif
	
	HAL_UART_IRQHandler(&UART1_Handler);	//调用HAL库中断处理公用函数
	
	timeout=0;
  while (HAL_UART_GetState(&UART1_Handler)!=HAL_UART_STATE_READY)//等待就绪
	{
        timeout++;超时处理
        if(timeout>maxDelay) break;		
	}
     
	timeout=0;
	while(HAL_UART_Receive_IT(&UART1_Handler,(u8 *)aRxBuffer, RXBUFFERSIZE)!=HAL_OK)//一次处理完成之后，重新开启中断并设置RxXferCount为1
	{
        timeout++; //超时处理
        if(timeout>maxDelay) break;	
	}
#if SYSTEM_SUPPORT_OS	 	//使用OS
	OSIntExit();  											 
#endif
} 
#endif	//end of //串口1中断服务程序

#endif// end of EN_USART1_RX


#if 1
//串口1中断服务程序
void USART1_IRQHandler(void)    
{
	u8 res;
#if SYSTEM_SUPPORT_OS	 	//使用OS
	OSIntEnter();    
#endif
//	if(__HAL_UART_GET_FLAG(&UART1_Handler, UART_FLAG_RXNE)!=RESET)
//	{
//		HAL_UART_Receive(&UART1_Handler, &res, 1, 1000);
//		if((USART_RX_STA&0x8000)==0)//接收未完成
//		{
//			if(USART_RX_STA&0x4000)//接收到了0x0d
//			{
//				if(res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
//				else USART_RX_STA|=0x8000;	//接收完成了 
//			}
//			else //还没收到0X0D
//			{	
//				if(res==0x0d)USART_RX_STA|=0x4000;
//				else
//				{
//					USART_RX_BUF[USART_RX_STA&0X3FFF]=res ;
//					USART_RX_STA++;
//					if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收	  
//				}		 
//			}
//		}
//	}
	HAL_UART_IRQHandler(&UART1_Handler);	//调用HAL库中断处理公用函数
	#if SYSTEM_SUPPORT_OS //使用OS
		OSIntExit();
	#endif
	
}

#endif














/*下面代码我们直接把中断控制逻辑写在中断服务函数内部。*/
/*

//串口1中断服务程序
void USART1_IRQHandler(void)                	
{ 
	u8 Res;
#if SYSTEM_SUPPORT_OS	 	//使用OS
	OSIntEnter();    
#endif
	if((__HAL_UART_GET_FLAG(&UART1_Handler,UART_FLAG_RXNE)!=RESET))  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
	{
        HAL_UART_Receive(&UART1_Handler,&Res,1,1000); 
		if((USART_RX_STA&0x8000)==0)//接收未完成
		{
			if(USART_RX_STA&0x4000)//接收到了0x0d
			{
				if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
				else USART_RX_STA|=0x8000;	//接收完成了 
			}
			else //还没收到0X0D
			{	
				if(Res==0x0d)USART_RX_STA|=0x4000;
				else
				{
					USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
					USART_RX_STA++;
					if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收	  
				}		 
			}
		}   		 
	}
	HAL_UART_IRQHandler(&UART1_Handler);	
#if SYSTEM_SUPPORT_OS	 	//使用OS
	OSIntExit();  											 
#endif
} 
#endif	
*/

 /**----------------------------------------------------------------------------
** @Function:		   FrameInfoProcess
**
** @Descriptions:	   	
**
** @parameters:			
**                  
**                  
**                  
** @Returned: none
** 
** @Author:  MCU Application Team
**
** @Date: 2017-11-16
**
-------------------------------------------------------------------------------*/
 void FrameInfoProcess(void)
 {
	 
	 u8 RxBuffer[RXBUFFERSIZE]; 
	 FrameInfo_TypeDef* sFrameInfo = (FrameInfo_TypeDef*)RxBuffer;
//	  uint16_t FrameHead = 0;
//	  uint8_t SourceID = 0, DestinationID = 0;
	  memcpy(RxBuffer, gFrameInfo, RXBUFFERSIZE);
//	  FrameHead = RxBuffer[0] + (RxBuffer[1]<<8);
//	  SourceID = RxBuffer[2];
//	  Destina
最低0.47元/天 解锁文章
persueadream
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
STM32中printf与scanf的重定向问题
goldage的博客
12-04 1万+
关于STM32中 printf 与 scanf 的重定向问题在此我仅对不使用 "USE MircoLIB" 的情况做整理（针对Keil RVMDK开发环境）。 ① ：首先需要在 usart.h 中包含 “stdio.h” 头文件 ② ：在 usart.c 中，加入如下代码块，以此避免使用半主机模式，并重定向 printf 和scanf 函数； #if 1 #pragma im
STM32半主机模式
liberation_best的博客
09-15 921
半主机
STM32学习和实践笔记（28）：printf重定向实验
最新发布
qq_37191547的博客
05-14 398
函数里，默认输出设备是显示器，如果想要用这个函数将输出结果到串口或者LCD上显示，就必须重定义标准库函数里中printf。//将此处原来的显示器改为USART1。函数调用的与输出设备相关的函数。按照十进制整型数打印，至少。按照浮点数打印，小数点后有。函数时会自动调用这个函数。比如要使用printf。,这个更改就叫重定向。按照十进制整型数打印。输出到串口，需要先将。按照浮点数打印，至少。按照浮点数打印，至少。个字符宽，小数点后有。函数输出一个整型数据。
预处理指令#pragma import(__use_no_semihosting)
m0_65736560的博客
07-12 1022
半主机是一种调试功能，可以在嵌入式系统中与调试器进行通信，例如在开发板上显示调试信息、读写文件等。然而，使用半主机功能可能会增加代码的大小和复杂性，不适用于生产环境。的作用是告诉编译器不要链接与半主机相关的库和函数，以减少生成的可执行文件的大小。这通常在嵌入式系统的生产代码中使用，以去除调试相关的功能并减小代码的体积。需要注意的是，具体的行为和效果取决于使用的编译器和目标平台。不同的编译器可能会有不同的预处理指令或选项来控制半主机功能的使用或禁用。
STM32 printf 和 scanf 函数重定向
guaizaiguaizai的博客
02-13 3715
1. 方法一 /// 重定向c库函数printf到USART1 int fputc(int ch, FILE *f) { /* 发送一个字节数据到USART1 */ USART_SendData(USART1, (uint8_t) ch); /* 等待发送完毕 */ while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) =...
STM32 printf()函数和scanf()函数重定向到串口
热门推荐
魔鬼的步伐
08-27 2万+
printf()函数和scanf()函数重定向 在学习STM32的时候，常常需要用串口来测试代码的正确与否，这时候就要要用到printf()函数或者scanf()函数，但是printf()这个函数是格式化输出到屏幕的，scanf()函数又是格式化输入（从屏幕），并不能输出到串口助手中，所以需要进行重定向。 在系统中有三个标准文件：标准输入，标准输出，标准错误。 printf : 强大的格...
STM32 串口 #pragma import(__use_no_semihosting)解析
tao658的博客
07-25 1万+
标准库函数的默认输出设备是显示器， 要实现在串口或 LCD 输出，必须重定义标准库函数里调用的与输出 设备相关的函数 . 例如 :printf 输出到串口，需要将 fputc 里面的输出指向串口 (重定向 ),方法如下 : 只要自己添加一个 int fputc(int ch, FILE *f) 函数，能够输出字符就可以了 #ifdef __GNUC__ /* With GCC/RAISONANCE...
STM32F4 UART4重定向printf和scanf函数
01-25
将printf和scanf重定向串口，直接打印到串口，方便调试，非常好用。自己写的，求下载啊
STM32实现printf和scanf源代码，保证能运行
08-14
STM32实现printf和scanf源代码，保证能运行
STM32 串口 UART 实现 printf scanf
03-11
ARC STM32 UART，串口实例， 实现 printf, scanf, 使用标准库
【STM32】标准库-SPI-DMA收发数据-读写Flash(W25Q256JV)-仿printf和scanf输入输出
06-29
采用STM32F429IGT6单片机，KeilMDK5.32版本 使用SysTick系统滴答定时器进行延时 LED_R、LED_G、LED_B分别为PH10,PH11,PH12 Key1为PA0，Key2为PC13 KEIL5下载配置有FLASH与SRAM 用SPI5与Flash芯片通信(W25Q256JV)，...
【STM32】标准库-I2C-DMA收发数据-读写AT24C02-仿printf和scanf输入输出
07-01
采用STM32F429IGT6单片机，KeilMDK5.32版本 使用SysTick系统滴答定时器进行延时 LED_R、LED_G、LED_B分别为PH10,PH11,PH12 Key1为PA0，Key2为PC13 KEIL5下载配置有FLASH与SRAM 收发共用一个缓冲区 I2C使用DMA与AT...
STM32笔记---避免使用 C 库半主机
Aniu127的专栏
09-30 3944
在独立应用程序中，您不太可能支持半主机操作。 因此，必须确保您的应用程序中没有链接 C 库半主机函数。 为确保没有从 C 库链接使用半主机的函数，必须导入符号 __use_no_semihosting。 可在您工程的任何 C 或汇编语言源文件中执行此操作，如下所示： 在 C 模块中，使用 #pragma 指令： #pragma import(__use_no_semiho
关于STM32使用scanf /printf输出输入重定向
luan_qd的博客
12-29 1018
摘要：关于stm32G030，使用c库函数scanf/printf，重定向的分享
KEIL中 __use_no_semihosting was requested, but _ttywrch was referenced问题
qq_34442618的博客
08-31 3349
编译遇到__use_no_semihosting was requested, but _ttywrch was referenced的解决办法
#pragma 指令
07-22 507
#Pragma 指令 C语言 在所有的预处理指令中，#Pragma 指令可能是最复杂的了，它的作用是设定编译器的状 态或者是指示编译器完成一些特定的动作。#pragma指令对每个编译器给出了一个方法,在保持 与C和C+
STM32串口重定向printf,scanf
return_lin的博客
01-16 582
串口1Asynchronous模式PA9TX连接usb转ttl模块RXPA10RX连接usb转ttl模块TX。
stm32 scanf重定向
09-15
在使用 STM32 单片机进行开发时，可以通过重定向标准输入输出流的方式实现 `scanf` 函数的重定向。这样，我们就可以使用其他的输入源（如串口）来替代默认的标准输入流。 下面是一个基本的例子，演示了如何重定向 `...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值