Stm32f103单片机多串口打印程序

petertang1975

已于 2023-09-24 21:04:54 修改

阅读量335

点赞数

文章标签：单片机 stm32

于 2023-09-24 20:57:24 首次发布

本文链接：https://blog.csdn.net/petertang1975/article/details/133251298

版权

stm32实现串口打印输出
以STM32F1x系列单片机为例，主要介绍了串口1与3的初始化。
串口3使用了全映射，并连接一个串口触摸屏，采集的ad的数据显示在串口屏上。
串口1输出到计算机显示。

//usart.h
#ifndef __USART_H
#define __USART_H
#include "stdio.h"	
#include "sys.h" 
#include <string.h>
#include <stdarg.h>  //必须有
//	 
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
//Mini STM32开发板
//串口1初始化		   
//正点原子@ALIENTEK
//技术论坛:www.openedv.csom
//修改日期:2011/6/14
//版本：V1.4
//版权所有，盗版必究。
//Copyright(C) 正点原子 2009-2019
//All rights reserved
//********************************************************************************
//V1.3修改说明 
//支持适应不同频率下的串口波特率设置.
//加入了对printf的支持
//增加了串口接收命令功能.
//修正了printf第一个字符丢失的bug
//V1.4修改说明
//1,修改串口初始化IO的bug
//2,修改了USART_RX_STA,使得串口最大接收字节数为2的14次方
//3,增加了USART_REC_LEN,用于定义串口最大允许接收的字节数(不大于2的14次方)
//4,修改了EN_USART1_RX的使能方式
// 	
#define USART_REC_LEN  			200  	//定义最大接收字节数 200
#define EN_USART1_RX 			  1		//使能（1）/禁止（0）串口1接收

#define USART3_REC_LEN      200
	  	
extern u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符 
extern u16 USART_RX_STA;         		//接收状态标记	
//如果想串口中断接收，请不要注释以下宏定义
void uart_init(u32 bound);
//void USART2_Config(void);   //初始化 配置USART2
void init_uart3(u32 bound);	//printf初始化
void uart_SendData(USART_TypeDef* USARTx, uint16_t Data);
void USART3_printf (char *fmt, ...);
/*****************  发送一个16位数 **********************/
void Usart_SendHalfWord( USART_TypeDef * pUSARTx, uint16_t ch);
void UART1_Send_Array(u16 *send_array,unsigned char num); //两个参数 一是数组(的数据) 二是数组长度1-255?


#endif

//usart.c

#include "sys.h"
#include "usart.h"	  
// 	 
//如果使用ucos,则包括下面的头文件即可.
#if SYSTEM_SUPPORT_UCOS
#include "includes.h"					//ucos 使用	  
#endif
//	 
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
//ALIENTEK STM32开发板
//串口1初始化		   
//正点原子@ALIENTEK
//技术论坛:www.openedv.com
//修改日期:2012/8/18
//版本：V1.5
//版权所有，盗版必究。
//Copyright(C) 广州市星翼电子科技有限公司 2009-2019
//All rights reserved
//********************************************************************************
//V1.3修改说明 
//支持适应不同频率下的串口波特率设置.
//加入了对printf的支持
//增加了串口接收命令功能.
//修正了printf第一个字符丢失的bug
//V1.4修改说明
//1,修改串口初始化IO的bug
//2,修改了USART_RX_STA,使得串口最大接收字节数为2的14次方
//3,增加了USART_REC_LEN,用于定义串口最大允许接收的字节数(不大于2的14次方)
//4,修改了EN_USART1_RX的使能方式
//V1.5修改说明
//1,增加了对UCOSII的支持
// 	  
 
float a[3]={0.00},w[3]={0.00},angle[3]={0.00},T=0;
unsigned char Re_buf[11]={0x00};
unsigned char Usart1_Re_buf[11]={0x00};
unsigned char counter=0;
unsigned char Usart1_counter=0;
unsigned char temp_buf[11]={0x00};
unsigned char sign=0;
unsigned char usart1_sign=0;
static unsigned char imu_Temp[11]={0x00};
//uint8_t temp_h, temp_l;

//u8 is_check_ok = 1;
//static unsigned char Usart1_Temp[11]={0x00};
vu8 uart_len;
vu8 RxBuffer[100];
volatile uint16_t Rx5_StepAD[100]={0x00};//唐新星
u8 k;
//unsigned char data_ok_flag=0;
//
//加入以下代码,支持printf函数,而不需要选择use MicroLIB	  
#if 1
#pragma import(__use_no_semihosting)             
//标准库需要的支持函数                 
struct __FILE 
{ 
	int handle; 

}; 

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

/*使用microLib的方法*/
 /* 
int fputc(int ch, FILE *f)
{
	USART_SendData(USART1, (uint8_t) ch);

	while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET) {}	
   
    return ch;
}
int GetKey (void)  { 

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

    return ((int)(USART1->DR & 0x1FF));
}
*/
 
#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;       //接收状态标记	  

/**************************************************************************************************
函数功能：初始化IO 串口1 
函数说明：bound:波特率
**************************************************************************************************/
void uart_init(u32 bound){
    //GPIO端口设置
  GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	 
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);	//使能USART1，GPIOA时钟
 	USART_DeInit(USART1);  //复位串口1
	 //USART1_TX   PA.9
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽输出
    GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化PA9
   
    //USART1_RX	  PA.10
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    GPIO_Init(GPIOA, &GPIO_InitStructure);  //初始化PA10

   //Usart1 NVIC 配置

  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1 ;//抢占优先级3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		//子优先级3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQ通道使能
	NVIC_Init(&NVIC_InitStructure);	//根据指定的参数初始化VIC寄存器
  
   //USART 初始化设置

	USART_InitStructure.USART_BaudRate = bound;//一般设置为9600;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
	USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
	USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	//收发模式

  USART_Init(USART1, &USART_InitStructure); //初始化串口
  USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);//开启idle中断
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启中断
  USART_Cmd(USART1, ENABLE);                    //使能串口 

}
/**************************************************************************************************
函数功能：串口接收数据 中断方式 
函数说明：接收到的数据长度len=USART_RX_STA&0x3fff; 数据接收完成标志flag=(USART_RX_STA&0x8000) 为1表示接收完成 为0表示接收未完成
			输入数据以enter键表示数据输入完成
**************************************************************************************************/
void uart_SendData(USART_TypeDef* USARTx, uint16_t Data)
{
	USART_SendData(USARTx, Data);//向串口1发送数据
	while(USART_GetFlagStatus(USARTx,USART_FLAG_TC)!=SET);//等待发送结束
}
/**************************************************************************************************
函数功能：串口接收数据 中断方式 
函数说明：接收到的数据长度len=USART_RX_STA&0x3fff; 数据接收完成标志flag=(USART_RX_STA&0x8000) 为1表示接收完成 为0表示接收未完成
			输入数据以（enter enter+ctrl）键表示数据输入完成
**************************************************************************************************/


//static u16* pRecieve=(u16*)RxBuffer;
void USART1_IRQHandler(void)     //串口1中断服务程序  
{
//	u8 Res;
#ifdef OS_TICKS_PER_SEC	 	//如果时钟节拍数定义了,说明要使用ucosII了.
	OSIntEnter();    
#endif
	
   if(USART_GetITStatus(USART1,USART_IT_RXNE)!=RESET)
   {
		 if(RESET != USART_GetFlagStatus(USART1,USART_FLAG_RXNE))
		 {   
//				if(uart_len > 99 )
//					 uart_len =0;
//        RxBuffer[uart_len++]=USART_ReceiveData(USART1);
				USART_ClearFlag(USART1,USART_FLAG_RXNE);
     }
		 

		 
		//USART_SendData(USART1,USART_ReceiveData(USART1));
		//while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);
   }
	 if(RESET !=  USART_GetITStatus(USART1,USART_IT_IDLE))
	 {   
			 if(RESET != USART_GetFlagStatus(USART1,USART_FLAG_IDLE))
			 {   
//				  USART_ReceiveData(USART1);
//					switch(uart_len)
//					{
//						case 24:
//							pRecieve=(u16*)RxBuffer;
//							for(k=0;k<12;k++)
//						{
//							Rx5_StepAD[k]=*pRecieve++  ;
//						}
(uint16_t)(TxBuffer5[uart_len] << 8)+TxBuffer5[uart_len+1]						
//							break;
//						case 7:
//							if(is_check_ok)
//							{
//								RxBuffer[6] = '\0';
//							
//								if(NULL != strstr((char*)RxBuffer,"stepok"))
//								{
//									//接受完stepok的
//									Usart_SendHalfWord(USART1,0x1234);
//									is_check_ok = 0;
//								}
//							}
//							
//							break;
//							default:
//               break;
//					}
//					uart_len =0;
			 }
	 }	

#ifdef OS_TICKS_PER_SEC	 	//如果时钟节拍数定义了,说明要使用ucosII了.
	OSIntExit();  											 
#endif
} 
#endif	

/*****************  发送一个16位数 **********************/
void Usart_SendHalfWord( USART_TypeDef * pUSARTx, uint16_t ch)
{
	uint8_t temp_h, temp_l;
	u16 ad_dec;
	
	/* 取出高八位 */
	temp_h = (ch&0XFF00)>>8;
	/* 取出低八位 */
	temp_l = ch&0XFF;
	ad_dec=temp_h*256+temp_l;
	printf("ad_dec=%d\r\n",ad_dec);
//	/* 发送高八位 */
//	USART_SendData(pUSARTx,temp_h);	
//	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
//	
//	/* 发送低八位 */
//	USART_SendData(pUSARTx,temp_l);	
//	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);	
}

void UART1_Send_Array(u16 *send_array,unsigned char num) //两个参数 一是数组(的数据) 二是数组长度1-255?
{
//串口发送
 unsigned char i=0;//??//定义一个局部变量??用来 发送字符串 ++运算

  for(i=0;i<num;i++)
    {
      USART_SendData(USART1,send_array[i]);通过库函数??发送数据
       while( USART_GetFlagStatus(USART1,USART_FLAG_TC)!= SET);//??
//等待发送完成。? ?检测 USART_FLAG_TC 是否置1；? ? //见库函数 P359 介绍
  //      num--;//;//??//值 加一? ? ? ???
    }
}


void init_uart3(u32 bound)	//printf初始化
{
		GPIO_InitTypeDef GPIO_InitStructure;	//声明一个结构体变量，用来初始化GPIO
	NVIC_InitTypeDef NVIC_InitStructure;	 //中断结构体定义
	USART_InitTypeDef  USART_InitStructure;	  //串口结构体定义

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO,ENABLE);
  RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART3, ENABLE); 
  GPIO_PinRemapConfig(GPIO_FullRemap_USART3,ENABLE); 
	
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_8;//TX
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;
	GPIO_Init(GPIOD,&GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9;//RX
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;//GPIO_Mode_IN_FLOATING;
	GPIO_Init(GPIOD,&GPIO_InitStructure);
 
 	USART_InitStructure.USART_BaudRate=115200;   //波特率设置为9600
	USART_InitStructure.USART_WordLength=USART_WordLength_8b;
	USART_InitStructure.USART_StopBits=USART_StopBits_1;
	USART_InitStructure.USART_Parity=USART_Parity_No;
	USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;
	
	USART_Init(USART3,&USART_InitStructure);
	USART_Cmd(USART3, ENABLE);
	USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//使能或者失能指定的USART中断 接收中断
	USART_ClearFlag(USART3,USART_FLAG_TC);//清除USARTx的待处理标志位
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
	NVIC_InitStructure.NVIC_IRQChannel=USART3_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;	   //抢占优先级1	
  NVIC_InitStructure.NVIC_IRQChannelSubPriority=1; 
  NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE; 
  NVIC_Init(&NVIC_InitStructure); 
	
}

void USART3_printf (char *fmt, ...)
{
	 char buffer[USART3_REC_LEN+1]; // CMD_BUFFER_LEN???????
   u8 i = 0;
   va_list arg_ptr;
   va_start(arg_ptr, fmt);
   vsnprintf(buffer, USART3_REC_LEN+1, fmt, arg_ptr);
   while ((i < USART3_REC_LEN) && buffer[i])
  {
    USART_SendData(USART3, (u8) buffer[i++]);
    while (USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET);
	}
   va_end(arg_ptr);
}

void USART2_IRQHandler(void)		   //串口2全局中断服务函数
{

	
	
}

void USART3_IRQHandler(void)		   //串口3全局中断服务函数
{
	USART_ClearFlag(USART3,USART_FLAG_TC);
   if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)  //接收中断有效,若接收数据寄存器满
  {
		  USART_ClearITPendingBit(USART3,USART_IT_RXNE);
      imu_Temp[counter] = USART_ReceiveData(USART3);   //接收数据
      //网购给的程序
      //if(counter == 0 && Re_buf[0] != 0x55) return;      //第 0 号数据不是帧头，跳过
	  if(counter == 0 && imu_Temp[0] != 0x55) return;      //第 0 号数据不是帧头，跳过
      counter++; 
      if(counter==11) //接收到 11 个数据
      { 
         memcpy(Re_buf,imu_Temp,11);
         counter=0; //重新赋值，准备下一帧数据的接收
         sign=1;
//				data_ok_flag=1;
      }    
   }
}

//main.c

void hmi_end()
{
    USART3_printf("%c",0xff);
    USART3_printf("%c",0xff);
    USART3_printf("%c",0xff);
}

void hmi_send()//单个测试
{
    USART3_printf("n0.val=%d",ad[0]);
    hmi_end();
    USART3_printf("n1.val=%d",ad[1]);
    hmi_end();
    USART3_printf("n2.val=%d",ad[2]);
    hmi_end();
    USART3_printf("n3.val=%d",ad[3]);
    hmi_end();
    USART3_printf("n4.val=%d",ad[4]);
    hmi_end();
    USART3_printf("n5.val=%d",ad[5]);
    hmi_end();
    USART3_printf("n6.val=%d",ad[6]);
    hmi_end();
    USART3_printf("n7.val=%d",ad[7]);
    hmi_end();
    USART3_printf("n8.val=%d",ad[8]);
    hmi_end();
    USART3_printf("n9.val=%d",ad[9]);
    hmi_end();
    USART3_printf("n10.val=%d",ad[10]);
    hmi_end();
    USART3_printf("n11.val=%d",ad[11]);
    hmi_end();
    USART3_printf("n12.val=%d",ad[12]);
    hmi_end();
    USART3_printf("n13.val=%d",ad[13]);
    hmi_end();
    USART3_printf("n14.val=%d",ad[14]);
    hmi_end();
    USART3_printf("n15.val=%d",ad[15]);
    hmi_end();
    USART3_printf("n16.val=%d",ad[16]);
    hmi_end();
    USART3_printf("n17.val=%d",ad[17]);
    hmi_end();
    USART3_printf("n18.val=%d",ad[18]);
    hmi_end();
    USART3_printf("t0.txt=\"%s\"",ttt0);
    hmi_end();
    USART3_printf("t1.txt=\"%s\"",ttt1);
    hmi_end();
    USART3_printf("t2.txt=\"%s\"",ttt2);
    hmi_end();
    
}

//主函数
int main(void)
{	
    u8 j;	
    unsigned char imu_Temp[11];
    
    // data_ok_flag=1;
    is_check_ok=1;
	  is_write_not=1;
    RCC_Configuration();	//系统时钟初始化
    GPIO_Configuration();//端口初始化
    //LED_Init();
    //KEY_Init(); 
    delay_init();	    //延时函数初始化	  
    NVIC_Configuration(); 	 //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
    uart_init(115200);    //串口1初始化，波特率115200
   	init_uart3(115200); 

    Adc_Init();		  //PA0~3
    TIM1_Configuration(7199,9);//PWM初始化   72M/7200 = 10k  100分频 =100HZ
	  TIM2_Configuration(7199,9); 	
    TIM4_Configuration(7199,9);  
    TIM5_Configuration(7199,9);



    printf("uart_init\r\n");
    
    //主要循环函数
    while(1)
    { 
        //printf("---------main()-----------\r\n");
        CD4067_ChooseS();//AD采集
        for(i=0;i<12;i++)//输出采集到的AD值
        {			 
            Usart_SendHalfWord(USART1,ad[i]);
//					  Usart_SendHalfWord(USART3,ad[i]);
        } 
     
	  	 hmi_send();
		   delay_ms(10);
      
    }		
}