F103串口的配置和理解

Lu_time

于 2023-11-09 12:05:32 发布

阅读量157

点赞数

文章标签：单片机 stm32 嵌入式硬件

本文链接：https://blog.csdn.net/Lu_time/article/details/134305742

版权

1、配置经典参数

第一步先配置USART和GPIO的使能，USART1_TX GPIOA.9 配置复用推挽输出，USART1_RX GPIOA.9 配置上拉输入。

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);		//使能USART1，GPIOA时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;			//复用推挽输出
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;              //USART1_TX   GPIOA.9
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;		  //上拉输入
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;            //USART1_RX   GPIOA.9
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);

第二步初始化USART

	USART_InitTypeDef USART_InitStructure;
	USART_InitStructure.USART_BaudRate=9600;
	USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;   //无硬件数据控制流
	USART_InitStructure.USART_Mode=USART_Mode_Tx | USART_Mode_Rx;					//收发模式
	USART_InitStructure.USART_Parity=USART_Parity_No;   							//无奇偶校验位
	USART_InitStructure.USART_StopBits=USART_StopBits_1;   							//停止位，一位
	USART_InitStructure.USART_WordLength=USART_WordLength_8b;                       //八位数据位
	USART_Init(USART1,&USART_InitStructure);

第三步开启串口接收中断和中断分组

USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);                  //开启串口接受中断   

NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);               //设置NVIC中断分组2:2位抢占优先级，2位响应优先级

第四步初始化NVIC

	NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel=USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;			   //USART1_IRQn 通道使能
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;
	NVIC_Init(&NVIC_InitStructure);

第五步给串口使能

	USART_Cmd(USART1,ENABLE);                                 //使能串口1

2、封装各类函数

一发送数据

void Serial_SendBaty(uint8_t Baty)											
{                                                                           	//给串口发送数据，参数为串口号和数据
	USART_SendData(USART1,Baty);                                                   //USART_FLAG_TXE 发送数据寄存器空标志位	
	while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);               
}

二发送数组

 //发送数组，参数为数组数据，长度
void Serial_SendArray(uint8_t *Array,uint16_t Length)                       
{                                                                           
	uint16_t i;                                                             
	for(i=0;i<Length;i++)                                                   
	{                                                                       
		Serial_SendBaty(Array[i]);                                          
	}                                                                       
}

三发送字符串

void Serial_SendString(char*String)          //发送字符串，参数为"字符"
{                                                                           
	uint8_t i;                                                              
	for(i=0;String[i]!='\0';i++)                                            
	{                                                                       
		Serial_SendBaty(String[i]);                                         
	}                                                                       
}

四发送数字

uint32_t Serial_Pow(uint32_t X,uint32_t Y)                                  //X的Y次方
{                                                                           
	uint32_t Result=1;                                                      
	while(Y--)                                                              
	{                                                                       
		Result *=X;                                                         
	}                                                                       
	return Result;                                                          
}                                                                             
void Serial_SendNumber(uint32_t Number,uint32_t Length)                     //发送数字参数为数字，长度。
{                                                                           
	uint8_t i;                                                              
	for(i=0;i<Length;i++)                                                   
	{                                                                       
		Serial_SendBaty(Number/Serial_Pow(10,Length-i-1)%10+0x30);          
	}                                                                       
}

五 printf 打印输出

int fputc(int ch,FILE *f)                            //库函数，是printf的底层函数
{                                                                           
	Serial_SendBaty(ch);                                                    
	return ch;                                                              
}                                                                              
void Serial_Printf(char *format, ...)				//C语言的可变参数
{
	char String[100];
	va_list arg;
	__va_start(arg,format);
	vsprintf(String,format,arg);
	__va_end(arg);
	Serial_SendString(String);
}

3、中断函数

uint8_t Serial_GetRXFlag(void)                        //手动清除标志位函数
{
	if(Serial_RXFlag==1)
	{
		Serial_RXFlag=0;
		return 1;
	}
	return 0;
}
uint8_t Serial_GrtRXData(void)                 //返回接收到的数据
{
	return Serial_RXData;
}
void USART1_IRQHandler(void)
{
	if(USART_GetITStatus(USART1,USART_IT_RXNE)==SET)      //接收中断
	{
		Serial_RXData=USART_ReceiveData(USART1);          //接收一个16进制数
		Serial_RXFlag=1;
		USART_ClearITPendingBit(USART1,USART_IT_RXNE);
	}
	/*USART_ClearITPendingBit(USART1,USART_IT_RXNE); 
	是用于清除 USART1 接收中断挂起位的函数。当 USART1 接收到数据时，
	会产生接收中断，并设置接收中断挂起位。通过调用 
	USART_ClearITPendingBit(USART1,USART_IT_RXNE); 
	函数可以清除该挂起位，以便下一次接收中断能够正常触发。*/
}

总览

#include "stm32f10x.h"                  // Device header
#include<stdio.h>
#include<stdarg.h>

uint8_t Serial_RXData;
uint8_t Serial_RXFlag;
void Serial_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);		//使能USART1，GPIOA时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;			//复用推挽输出
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;              //USART1_TX   GPIOA.9
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;		  //上拉输入
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;            //USART1_RX   GPIOA.9
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
		/*
	　　为什么需要流控?

　　数据在两个串口之间进行通讯的时候常常会出现丢失数据的现象，比如两台计算机或者是一台计算机和一
	个单片机之间进行通讯，当接收端的数据缓冲区已经满了，这个时候如果还有数据发送过来，因为接收端
	没有时间进行处理，那这样的数据就有可能会丢失。在工业现场或者其他领域，经常会遇到这种问题，本
	质原因是速度不匹配、处理能力不匹配。比如单片机的主频只有20M或30M，ARM的处理能力可能是200M，PC机
	的处理能力是几个G，这种处理能力的不匹配造成了传输的时候数据容易丢失。

　　硬件流控就是来解决这个速度匹配的问题。它的基本含义非常简单，当接收端接收到的数据处理不过来时，
	就向发送端发送不再接收的信号，发送端接收到这个信号之后就会停止发送，直到收到可以继续发送的信
	号再继续发送。因此流控本身是可以控制数据传输的进度，进而防止数据丢失。
	
	*/
	USART_InitTypeDef USART_InitStructure;
	USART_InitStructure.USART_BaudRate=9600;
	USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;   //无硬件数据控制流
	USART_InitStructure.USART_Mode=USART_Mode_Tx | USART_Mode_Rx;					//收发模式
	USART_InitStructure.USART_Parity=USART_Parity_No;   							//无奇偶校验位
	USART_InitStructure.USART_StopBits=USART_StopBits_1;   							//停止位，一位
	USART_InitStructure.USART_WordLength=USART_WordLength_8b;                       //八位数据位
	USART_Init(USART1,&USART_InitStructure);
	
	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);                  //开启串口接受中断       
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);               //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
	
	/*初始化NVIC。 NVIC_IRQChannelPreemptionPriority设置了中断的抢占优先级为1，
				   NVIC_IRQChannelSubPriority设置了中断的子优先级为1。

	这意味着当多个中断同时发生时，具有更高抢占优先级的中断将优先执行，
	而具有相同抢占优先级的中断将按照子优先级的顺序执行。*/
	
	NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel=USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;			   //USART1_IRQn 通道使能
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;
	NVIC_Init(&NVIC_InitStructure);
	
	USART_Cmd(USART1,ENABLE);                                 //使能串口1
}

void Serial_SendBaty(uint8_t Baty)											
{                                                                           	//给串口发送数据，参数为串口号和数据
	USART_SendData(USART1,Baty);                                                   //USART_FLAG_TXE 发送数据寄存器空标志位	
	while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);               
}                                                                           
 //发送数组，参数为数组数据，长度
void Serial_SendArray(uint8_t *Array,uint16_t Length)                       
{                                                                           
	uint16_t i;                                                             
	for(i=0;i<Length;i++)                                                   
	{                                                                       
		Serial_SendBaty(Array[i]);                                          
	}                                                                       
}                                                                              
void Serial_SendString(char*String)          //发送字符串，参数为"字符"
{                                                                           
	uint8_t i;                                                              
	for(i=0;String[i]!='\0';i++)                                            
	{                                                                       
		Serial_SendBaty(String[i]);                                         
	}                                                                       
}                                                                           
                                                                             
uint32_t Serial_Pow(uint32_t X,uint32_t Y)                                  //X的Y次方
{                                                                           
	uint32_t Result=1;                                                      
	while(Y--)                                                              
	{                                                                       
		Result *=X;                                                         
	}                                                                       
	return Result;                                                          
}                                                                             
void Serial_SendNumber(uint32_t Number,uint32_t Length)                     //发送数字参数为数字，长度。
{                                                                           
	uint8_t i;                                                              
	for(i=0;i<Length;i++)                                                   
	{                                                                       
		Serial_SendBaty(Number/Serial_Pow(10,Length-i-1)%10+0x30);          
	}                                                                       
}                                                                               
int fputc(int ch,FILE *f)                            //库函数，是printf的底层函数
{                                                                           
	Serial_SendBaty(ch);                                                    
	return ch;                                                              
}                                                                              
void Serial_Printf(char *format, ...)				//C语言的可变参数
{
	char String[100];
	va_list arg;
	__va_start(arg,format);
	vsprintf(String,format,arg);
	__va_end(arg);
	Serial_SendString(String);
}
uint8_t Serial_GetRXFlag(void)                        //手动清除标志位函数
{
	if(Serial_RXFlag==1)
	{
		Serial_RXFlag=0;
		return 1;
	}
	return 0;
}
uint8_t Serial_GrtRXData(void)                 //返回接收到的数据
{
	return Serial_RXData;
}
void USART1_IRQHandler(void)
{
	if(USART_GetITStatus(USART1,USART_IT_RXNE)==SET)      //接收中断
	{
		Serial_RXData=USART_ReceiveData(USART1);          //接收一个16进制数
		Serial_RXFlag=1;
		USART_ClearITPendingBit(USART1,USART_IT_RXNE);
	}
	/*USART_ClearITPendingBit(USART1,USART_IT_RXNE); 
	是用于清除 USART1 接收中断挂起位的函数。当 USART1 接收到数据时，
	会产生接收中断，并设置接收中断挂起位。通过调用 
	USART_ClearITPendingBit(USART1,USART_IT_RXNE); 
	函数可以清除该挂起位，以便下一次接收中断能够正常触发。*/
}

4、main函数

4-2 这个实验是发送数据到串口

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include"Serial.h"
int main(void)
{
	OLED_Init();
	
	Serial_Init();
	Serial_SendBaty(0x41);
	uint8_t MyArray[]={0x42,0x43,0x44,0x45};
	Serial_SendArray(MyArray,4);
	Serial_SendString("\r\nNum1=");
	Serial_SendNumber(456,3);
	printf("\r\nNum2=%d",789);
	char String[100];
	sprintf(String,"\r\nNum3=%d",123);
	Serial_SendString(String);
	Serial_Printf("\r\nNum4=%d\r\n",666);
	Serial_Printf("周总，你好\r\n");
	
	while (1)
	{
		
	}
}

4-2 这个实验是从接收一个16进制数，并在OLED上显示接收到的数据，再发送到串口

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include"Serial.h"

uint16_t RXData;

int main(void)
{
	OLED_Init();
	Serial_Init();

	while (1)
	{
		if(Serial_GetRXFlag()==1)
		{
			RXData=Serial_GrtRXData();
			Serial_SendBaty(RXData);
			OLED_ShowHexNum(1,1,RXData,3);
		}
	}
}

4-3 这个实验是串口收发数据包，收发格式 OxFF (四位16进制数据) 0xFE ，可以通过按键给发送的数据++；

#include "stm32f10x.h"                  // Device header
#include<stdio.h>
#include<stdarg.h>

uint8_t Serial_RXFlag;
uint8_t Serial_TXPacker[4];
uint8_t Serial_RXPacker[4];
void Serial_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);      //开启串口时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);	   //开启GPIO时钟
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;            //复用推挽输出
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;             //高电平输入
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	USART_InitTypeDef USART_InitStructure;
	USART_InitStructure.USART_BaudRate=9600;                                        //波特率
	USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;   //硬件控制流
	USART_InitStructure.USART_Mode=USART_Mode_Tx | USART_Mode_Rx;
	USART_InitStructure.USART_Parity=USART_Parity_No;   							//校验位，不校验
	USART_InitStructure.USART_StopBits=USART_StopBits_1;   							//停止位，一位
	USART_InitStructure.USART_WordLength=USART_WordLength_8b;                       //八位数据位
	USART_Init(USART1,&USART_InitStructure);
	
	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);                                    //开启串口中断
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                                 //中断分组2
	
	NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel=USART1_IRQn;                                //串口1
	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1;                        //优先级
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;
	NVIC_Init(&NVIC_InitStructure);
	
	USART_Cmd(USART1,ENABLE);                                                     //开启串口命令
}

void Serial_SendBaty(uint8_t Baty)                                   //发送字函数，参数为要发送的数据
{
	USART_SendData(USART1,Baty);                                     //串口发送数据函数        
	while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);        //发送结束标志位
}

void Serial_SendArray(uint8_t *Array,uint16_t Length)                //发送数据函数
{
	uint16_t i;
	for(i=0;i<Length;i++)
	{
		Serial_SendBaty(Array[i]);
	}
}
void Serial_SendString(char*String)                                //发送字符串函数
{
	uint8_t i;
	for(i=0;String[i]!='\0';i++)
	{
		Serial_SendBaty(String[i]);
	}
}

uint32_t Serial_Pow(uint32_t X,uint32_t Y)                        //求X的Y次方函数，返回值
{
	uint32_t Result=1;
	while(Y--)
	{
		Result *=X;
	}
	return Result;
}
void Serial_SendNumber(uint32_t Number,uint32_t Length)        //发送数字函数，参数为要发送的数字，长度
{
	uint8_t i;
	for(i=0;i<Length;i++)
	{
		Serial_SendBaty(Number/Serial_Pow(10,Length-i-1)%10+0x30);
	}
}
int fputc(int ch,FILE *f)                                     //printf 函数
{
	Serial_SendBaty(ch);
	return ch;
}
void Serial_Printf(char *format, ...)                        //printf 函数
{
	char String[100];
	va_list arg;
	__va_start(arg,format);
	vsprintf(String,format,arg);
	__va_end(arg);
	Serial_SendString(String);
}
void Serial_SendPacker(void)                               //发送文本数据包函数
{
	Serial_SendBaty(0xFF);
	Serial_SendArray(Serial_TXPacker,4);
	Serial_SendBaty(0xFE);
}
uint8_t Serial_GetRXFlag(void)                            //获取接收完成标志位函数
{
	if(Serial_RXFlag==1)
	{
		Serial_RXFlag=0;
		return 1;
	}
	return 0;
}

void USART1_IRQHandler(void)                        //串口中断1
{
	static uint8_t RxState=0;
	static uint8_t RxPacker=0;
	
	if(USART_GetITStatus(USART1,USART_IT_RXNE)==SET)   //串口中断判断，参数为串口号，方式：接收
	{
		uint8_t RxData=USART_ReceiveData(USART1);      //获取数据
		if(RxState==0)
		{
			if(RxData==0XFF)
			{
				RxState=1;
				RxPacker=0;
			}
		}
		else if(RxState==1)
		{
			Serial_RXPacker[RxPacker]=RxData;        
			RxPacker++;
			if(RxPacker>=4)
			{
				RxState=2;
			}
		}
		else if(RxState==2)
		{
			if(RxData==0xFE)
			{
				RxState=0;
				Serial_RXFlag=1;
			}
		}
		USART_ClearITPendingBit(USART1,USART_IT_RXNE);    //清除串口标志
	}
}






#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Key.h"
#include "Serial.h"

uint16_t RXData;
uint8_t Keynum;
int main(void)
{
	OLED_Init();
	
	Serial_Init();

	OLED_ShowString(1,1,"TXPacker");
	OLED_ShowString(3,1,"RXPacker");
	
	Serial_TXPacker[0]=0x01;
	Serial_TXPacker[1]=0x02;
	Serial_TXPacker[2]=0x03;
	Serial_TXPacker[3]=0x04;
	
	
	while (1)
	{	Keynum=Key_GetNum();
		if(Keynum==1)
		{	Serial_TXPacker[0]++;
			Serial_TXPacker[1]++;
			Serial_TXPacker[2]++;
			Serial_TXPacker[3]++;

			Serial_SendPacker();
			
			OLED_ShowHexNum(2,1,Serial_TXPacker[0],2);
			OLED_ShowHexNum(2,4,Serial_TXPacker[1],2);
			OLED_ShowHexNum(2,7,Serial_TXPacker[2],2);
			OLED_ShowHexNum(2,10,Serial_TXPacker[3],2);			
			
		}

		
		if(Serial_GetRXFlag()==1)
		{ 
			OLED_ShowHexNum(4,1,Serial_RXPacker[0],2);
			OLED_ShowHexNum(4,4,Serial_RXPacker[1],2);
			OLED_ShowHexNum(4,7,Serial_RXPacker[2],2);
			OLED_ShowHexNum(4,10,Serial_RXPacker[3],2);
		}
	
	}
}

4-4 这个实验是收发可变文本长度数据包格式：@ - - - - \r\n ,可以通过发送相关字节控制灯的亮灭

#include "stm32f10x.h"                  // Device header
#include<stdio.h>
#include<stdarg.h>

uint8_t Serial_RXFlag;
char Serial_RXPacker[100];
void Serial_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);      //开启串口时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);	   //开启GPIO时钟
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;            //复用推挽输出
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;                 //TX
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;             //高电平输入
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;                //RX
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	USART_InitTypeDef USART_InitStructure;
	USART_InitStructure.USART_BaudRate=9600;                                        //波特率
	USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;   //硬件控制流
	USART_InitStructure.USART_Mode=USART_Mode_Tx | USART_Mode_Rx;
	USART_InitStructure.USART_Parity=USART_Parity_No;   							//校验位，不校验
	USART_InitStructure.USART_StopBits=USART_StopBits_1;   							//停止位，一位
	USART_InitStructure.USART_WordLength=USART_WordLength_8b;                       //八位数据位
	USART_Init(USART1,&USART_InitStructure);
	
	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);                                    //开启串口中断
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                                 //中断分组2
	
	NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel=USART1_IRQn;                                //串口1
	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1;                        //优先级
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;
	NVIC_Init(&NVIC_InitStructure);
	
	USART_Cmd(USART1,ENABLE);                                                     //开启串口命令
}

void Serial_SendBaty(uint8_t Baty)                                   //发送字函数，参数为要发送的数据
{
	USART_SendData(USART1,Baty);                                     //串口发送数据函数        
	while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);        //发送结束标志位
}

void Serial_SendArray(uint8_t *Array,uint16_t Length)                //发送数据函数
{
	uint16_t i;
	for(i=0;i<Length;i++)
	{
		Serial_SendBaty(Array[i]);
	}
}
void Serial_SendString(char*String)                                //发送字符串函数
{
	uint8_t i;
	for(i=0;String[i]!='\0';i++)
	{
		Serial_SendBaty(String[i]);
	}
}

uint32_t Serial_Pow(uint32_t X,uint32_t Y)                        //求X的Y次方函数，返回值
{
	uint32_t Result=1;
	while(Y--)
	{
		Result *=X;
	}
	return Result;
}
void Serial_SendNumber(uint32_t Number,uint32_t Length)        //发送数字函数，参数为要发送的数字，长度
{
	uint8_t i;
	for(i=0;i<Length;i++)
	{
		Serial_SendBaty(Number/Serial_Pow(10,Length-i-1)%10+0x30);
	}
}
int fputc(int ch,FILE *f)                                     //printf 函数
{
	Serial_SendBaty(ch);
	return ch;
}
void Serial_Printf(char *format, ...)                        //printf 函数
{
	char String[100];
	va_list arg;
	__va_start(arg,format);
	vsprintf(String,format,arg);
	__va_end(arg);
	Serial_SendString(String);
}


void USART1_IRQHandler(void)                        //串口中断1
{
	static uint8_t RxState=0;
	static uint8_t RxPacker=0;
	
	if(USART_GetITStatus(USART1,USART_IT_RXNE)==SET)   //串口中断判断，参数为串口号，方式：接收
	{
		uint8_t RxData=USART_ReceiveData(USART1);      //获取数据
		if(RxState==0)
		{
			if(RxData=='@'&&Serial_RXFlag==0)
			{
				RxState=1;
				RxPacker=0;
			}
		}
		else if(RxState==1)
		{
			if(RxData=='\r')
			{
				RxState=2;
			}
			else
			{
				Serial_RXPacker[RxPacker]=RxData;        
				RxPacker++;				
			}
		}
		else if(RxState==2)
		{
			if(RxData=='\n')
			{
				RxState=0;
				Serial_RXPacker[RxPacker]='\0'; 
				Serial_RXFlag=1;
			}
		}
		USART_ClearITPendingBit(USART1,USART_IT_RXNE);    //清除串口标志
	}
}






#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Key.h"
#include "LED.h"
#include "Serial.h"
#include <string.h>


uint16_t RXData;
uint8_t Keynum;
int main(void)
{
	OLED_Init();
	LED_Init();
	Serial_Init();

	OLED_ShowString(1,1,"TXPacker");
	OLED_ShowString(3,1,"RXPacker");
	
	while (1)
	{	
	
		if(Serial_RXFlag==1)
		{ 
			OLED_ShowString(4,1,"				");
			OLED_ShowString(4,1,Serial_RXPacker);
			if(strcmp(Serial_RXPacker,"LED_ON")==0)
			{
				LED1_ON();
				Serial_SendString("LED_ON_OK\r\n");
				OLED_ShowString(2,1,"				");
				OLED_ShowString(2,1,"LED_ON_OK");
			}
			else if(strcmp(Serial_RXPacker,"LED_OFF")==0)
			{
				LED1_OFF();
				Serial_SendString("LED_ON_OFF\r\n");
				OLED_ShowString(2,1,"				");
				OLED_ShowString(2,1,"LED_ON_OFF");
			}
			else
			{
				Serial_SendString("error_command\r\n");
				OLED_ShowString(2,1,"				");
				OLED_ShowString(2,1,"error_command");
			}
			Serial_RXFlag=0;
		}
	}
}

4-5 这个实验是通过串口连接连接WiFi再连接巴法云

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Key.h"
#include "LED.h"
#include "Serial.h"
#include <string.h>


uint16_t RXData;
uint8_t Keynum;
int main(void)
{
	OLED_Init();
	LED_Init();
	Serial_Init();
	Serial_SendString("AT+CWMODE=1\r\n");              //给WiFi发送AT指令
	OLED_ShowString(1,1,"1");
	Delay_s(1);
//	Serial_SendString("AT\r\r\n");//
//	OLED_ShowString(1,1,"1");
//	Delay_s(1);	
	Serial_SendString("AT+CWJAP=\"104\",\"ERPmingde104\"\r\n");   //WiFi的名称和密码
	OLED_ShowString(1,1,"2");
	Delay_s(3);
	Serial_SendString("AT+CIPSTART=\"TCP\",\"bemfa.com\",8344\r\n");   
                                 //TCP指令，如果是MQTT就更换
	OLED_ShowString(1,1,"3");
	Delay_s(1);
	Serial_SendString("AT+CIPSEND=56\r\n");  
        //下面要发送的字节的长多，通过字节计算器算出来之后要减2才是真的字节长度
	OLED_ShowString(1,1,"4");
	Delay_s(1);
	Serial_SendString("cmd=1&uid=aeaa192df9524107a3f5bba16019f928&topic=DHT11\r\n");
	Serial_SendString("AT+CIPSEND=64\r\n");
	OLED_ShowString(1,1,"4");
	Delay_s(1);
	Serial_SendString("cmd=2&uid=aeaa192df9524107a3f5bba16019f928&topic=DHT11&msg=off\r\n");
	OLED_ShowString(1,1,"5");
//	OLED_ShowString(1,1,"TXPacker");
//	OLED_ShowString(3,1,"RXPacker");
	
	while (1)
	{	
		
	}
}

Lu_time

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
F103串口的配置和理解

4-3 这个实验是串口收发数据包，收发格式 OxFF (四位16进制数据) 0xFE ，可以通过按键给发送的数据++；4-4 这个实验是收发可变文本长度数据包格式：@ - - - - \r\n ,可以通过发送相关字节控制灯的亮灭。4-2 这个实验是从接收一个16进制数，并在OLED上显示接收到的数据，再发送到串口。4-5 这个实验是通过串口连接连接WiFi再连接巴法云。4-2 这个实验是发送数据到串口。
复制链接

扫一扫