调试串口通讯的模块的环境搭建（以stm32f107vc调试esp01s为例）

最新推荐文章于 2024-07-16 11:04:47 发布

黑夜中闭上眼睛

最新推荐文章于 2024-07-16 11:04:47 发布

阅读量182

点赞数 6

分类专栏： STM32学习文章标签： stm32 嵌入式硬件单片机

本文链接：https://blog.csdn.net/qq_39956670/article/details/139712201

版权

STM32学习专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一，概述

由于我们用开发发版开发esp01s时需要实时能看到esp01s的响应，并且需要通过发AT指令操控esp01s所以我们需要用到两个串口。一个连接esp01s，另一个用于传输我们的操控命令（AT指令）和回显esp01s的响应数据。（这里我用开发板stm32f10x系列的开发板的USART1和USART2）USART1用作操控和响应回显，USART2用作EPS01S通讯。

二，需要的工具

硬件方面：stm32f1系列开发板一个，usb转ttl模块一个，esp01s模块一个，给开发烧录程序的配套硬件，供电电源，

软件方面：串口调试助手（我用的是安信可串口调试助手）

下载链接：https://pan.baidu.com/s/1KnZIXarAWNnOq65grdvUDg 提取码：2004

三，连接和数据流向

四，程序源码

bsp_uart.h

#ifndef __BSP_UART_H__
#define __BSP_UART_H__
#include "stm32f10x.h"

/**
uart1	tx:PA9	RX:PA10
uart2	tx:PA2	RX:PA3

uart2连接wifi作为通讯端口

esp01s						stm32f103vct6
3.3v							3.3v
tx								PA3
rx								PA2
gnd								gnd

uart1作为调试端口
*/

/**
	USARTx	(x......1.2.3.4.5)
	USART_BaudRate
	USART_WordLength	USART_WordLength_8b/USART_WordLength_9b
	USART_StopBits		USART_StopBits_1/USART_StopBits_0_5/USART_StopBits_2/USART_StopBits_1_5
	USART_Parity		USART_Parity_No/USART_Parity_Even/USART_Parity_Odd
	USART_IT
  *   This parameter can be one of the following values:
  *     @arg USART_IT_CTS:  CTS change interrupt (not available for UART4 and UART5)
  *     @arg USART_IT_LBD:  LIN Break detection interrupt
  *     @arg USART_IT_TXE:  Tansmit Data Register empty interrupt
  *     @arg USART_IT_TC:   Transmission complete interrupt
  *     @arg USART_IT_RXNE: Receive Data register not empty interrupt
  *     @arg USART_IT_IDLE: Idle line detection interrupt
  *     @arg USART_IT_ORE:  OverRun Error interrupt
  *     @arg USART_IT_NE:   Noise Error interrupt
  *     @arg USART_IT_FE:   Framing Error interrupt
  *     @arg USART_IT_PE:   Parity Error interrupt
	
	
*/


void BSP_UART_Init(USART_TypeDef* USARTx,
				uint8_t NVIC_PRE_Priority,
				uint8_t NVIC_SUB_Priority,
				uint32_t USART_BaudRate,
				uint16_t USART_WordLength,
				uint16_t USART_StopBits,
				uint16_t USART_Parity);

void Serial_SendByte(USART_TypeDef* USARTx,uint8_t Byte);
void Serial_SendArray(USART_TypeDef* USARTx,uint8_t *Array, uint16_t Length);
void Serial_SendString(USART_TypeDef* USARTx,char *String);


#endif /**		__BSP_UART_H__	*/

bsp_uart.c

#include "bsp_uart.h"
/**

	USARTx	(x......1.2.3.4.5)
	USART_BaudRate
	USART_WordLength	USART_WordLength_8b/USART_WordLength_9b
	USART_StopBits		USART_StopBits_1/USART_StopBits_0_5/USART_StopBits_2/USART_StopBits_1_5
	USART_Parity		USART_Parity_No/USART_Parity_Even/USART_Parity_Odd
*/
void BSP_UART_Init(USART_TypeDef* USARTx,
				uint8_t NVIC_PRE_Priority,
				uint8_t NVIC_SUB_Priority,
				uint32_t USART_BaudRate,
				uint16_t USART_WordLength,
				uint16_t USART_StopBits,
				uint16_t USART_Parity)
{
	GPIO_TypeDef* USART_GPIOx;
	uint32_t RCC_UARTx_PORT_CLK;
	uint32_t RCC_UARTx_CLK;
	uint16_t USARTx_PIN_TX;
	uint16_t USARTx_PIN_RX;

	IRQn_Type NVIC_USARTx_IRQn;
	
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	
	if(USARTx==USART1)
	{
		USART_GPIOx = GPIOA;
		USARTx_PIN_TX = GPIO_Pin_9;
		USARTx_PIN_RX = GPIO_Pin_10;
		NVIC_USARTx_IRQn = USART1_IRQn;
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);

	}else if(USARTx==USART2)
	{
		USART_GPIOx = GPIOA;
		RCC_UARTx_PORT_CLK = RCC_APB2Periph_GPIOA;
		RCC_UARTx_CLK = RCC_APB1Periph_USART2;
		USARTx_PIN_TX = GPIO_Pin_2;
		USARTx_PIN_RX = GPIO_Pin_3;
		NVIC_USARTx_IRQn = USART2_IRQn;
	}else if(USARTx==USART3)
	{
		USART_GPIOx = GPIOB;
		RCC_UARTx_PORT_CLK = RCC_APB2Periph_GPIOB;
		RCC_UARTx_CLK = RCC_APB1Periph_USART3;
		USARTx_PIN_TX = GPIO_Pin_10;
		USARTx_PIN_RX = GPIO_Pin_11;
		NVIC_USARTx_IRQn = USART3_IRQn;
	}else if(USARTx==UART4)
	{
		USART_GPIOx = GPIOC;
		RCC_UARTx_PORT_CLK = RCC_APB2Periph_GPIOC;
		RCC_UARTx_CLK = RCC_APB1Periph_USART3;
		USARTx_PIN_TX = GPIO_Pin_10;
		USARTx_PIN_RX = GPIO_Pin_11;
		NVIC_USARTx_IRQn = UART4_IRQn;
	}else if(USARTx==UART5)
	{
		USARTx_PIN_TX = GPIO_Pin_12;
		USARTx_PIN_RX = GPIO_Pin_2;
		NVIC_USARTx_IRQn = UART5_IRQn;
	}
	if(USARTx!=USART1&&USARTx!=UART5)
	{
		RCC_APB1PeriphClockCmd(RCC_UARTx_CLK,ENABLE);
		RCC_APB2PeriphClockCmd(RCC_UARTx_PORT_CLK,ENABLE);
	}else if(USARTx==UART5)
	{
		RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART5,ENABLE);
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE);
		
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
		GPIO_InitStructure.GPIO_Pin = USARTx_PIN_TX;
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_Init(GPIOC,&GPIO_InitStructure);
	
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
		GPIO_InitStructure.GPIO_Pin = USARTx_PIN_RX;
		GPIO_Init(GPIOD,&GPIO_InitStructure);
	}

	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = USARTx_PIN_TX;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(USART_GPIOx,&GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_InitStructure.GPIO_Pin = USARTx_PIN_RX;
	GPIO_Init(USART_GPIOx,&GPIO_InitStructure);
	
	USART_InitStructure.USART_BaudRate = USART_BaudRate;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Rx|USART_Mode_Tx;
	USART_InitStructure.USART_Parity = USART_Parity;
	USART_InitStructure.USART_StopBits = USART_StopBits;
	USART_InitStructure.USART_WordLength = USART_WordLength;
	USART_Init(USARTx,&USART_InitStructure);
	
	//开启接收非空中断和空闲中断
	USART_ITConfig(USARTx,USART_IT_RXNE,ENABLE);
	USART_ITConfig(USARTx,USART_IT_IDLE,ENABLE);
	
	NVIC_InitStructure.NVIC_IRQChannel = NVIC_USARTx_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRE_Priority;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = NVIC_SUB_Priority;
	NVIC_Init(&NVIC_InitStructure);
	
	//使能串口
	USART_Cmd(USARTx, ENABLE);

}


/**
  * 函    数：串口发送一个字节
  * 参    数：Byte 要发送的一个字节
  * 返 回 值：无
  */
void Serial_SendByte(USART_TypeDef* USARTx,uint8_t Byte)
{
	USART_SendData(USARTx, Byte);		//将字节数据写入数据寄存器，写入后USART自动生成时序波形
	while (USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET);	//等待发送完成
	/*下次写入数据寄存器会自动清除发送完成标志位，故此循环后，无需清除标志位*/
}

/**
  * 函    数：串口发送一个数组
  * 参    数：Array 要发送数组的首地址
  * 参    数：Length 要发送数组的长度
  * 返 回 值：无
  */
void Serial_SendArray(USART_TypeDef* USARTx,uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)		//遍历数组
	{
		Serial_SendByte(USARTx,Array[i]);		//依次调用Serial_SendByte发送每个字节数据
	}
}

/**
  * 函    数：串口发送一个字符串
  * 参    数：String 要发送字符串的首地址
  * 返 回 值：无
  */
void Serial_SendString(USART_TypeDef* USARTx,char *String)
{
	uint8_t i;
	for (i = 0; String[i] != '\0'; i ++)//遍历字符数组（字符串），遇到字符串结束标志位后停止
	{
		Serial_SendByte(USARTx,String[i]);		//依次调用Serial_SendByte发送每个字节数据
	}
	
}

main.c

#include "stm32f10x.h"
#include "bsp_uart.h"
//usart1数据缓冲
uint8_t USART1_REV[100];
//usart2数据缓冲
uint8_t USART2_REV[100];
//usart1数据个数
uint8_t usart1_index=0;
//usart2数据个数
uint8_t usart2_index=0;
//usart1数据接受完成标志位
uint8_t usart1_flag = 0;
//usart2数据接受完成标志位
uint8_t usart2_flag = 0;

void Clear_Buff(uint8_t* BUFF_DATA,uint8_t index);

int main(void)
{
	//设置NVIC组
	NVIC_SetPriorityGrouping(NVIC_PriorityGroup_2);
	//初始化USART1和USART2
	BSP_UART_Init(USART1,2,2,115200,USART_WordLength_8b,USART_StopBits_1,USART_Parity_No);
	BSP_UART_Init(USART2,2,1,115200,USART_WordLength_8b,USART_StopBits_1,USART_Parity_No);

//	Serial_SendString(USART2,"AT+GMR\r\n");
	while(1)
	{
		if(usart1_flag==1)
		{
			//把PC发来的数据发送到ESP01S
			Serial_SendArray(USART2,USART1_REV,usart1_index);
			//清除USART1数据缓冲，方便下次使用
			Clear_Buff(USART1_REV,usart1_index);
			usart1_index=0;
			//清除接收完成标志位
			usart1_flag=0;
		}
		if(usart2_flag==1)
		{
			//把ESP01S来的数据发送给PC
			Serial_SendArray(USART1,USART2_REV,usart2_index);
			Clear_Buff(USART2_REV,usart2_index);
			usart2_index=0;
			usart2_flag=0;
		}
	}
}

void USART1_IRQHandler(void)
{
	
	if(USART_GetITStatus(USART1,USART_IT_RXNE)!=RESET)
	{
		USART1_REV[usart1_index++]=USART_ReceiveData(USART1);
	}
	if(USART_GetITStatus(USART1,USART_IT_IDLE)!=RESET)
	{
		USART1->SR;	 //读取SR寄存器
		USART1->DR;    //读取DR寄存器 (先读USART_SR，然后读USART_DR可以清除空闲中断标志位IDLE)
		usart1_flag=1;
	}

}


void USART2_IRQHandler(void)
{
	
	if(USART_GetITStatus(USART2,USART_IT_RXNE)!=RESET)
	{
		USART2_REV[usart2_index++]=USART_ReceiveData(USART2);
	}
	if(USART_GetITStatus(USART2,USART_IT_IDLE)!=RESET)
	{
		USART2->SR;	 	//读取SR寄存器
		USART2->DR;		//读取DR寄存器 (先读USART_SR，然后读USART_DR可以清除空闲中断标志位IDLE)
		usart2_flag=1;	//置1数据接收完成标志位
	}
}

void Clear_Buff(uint8_t* BUFF_DATA,uint8_t index)
{
	uint8_t i=0;
	while(i<=index)
	{
		BUFF_DATA[i]='0';
		i++;
	}

}

打完收工