STM32：串口（蓝牙/WIFI/4G）

目录

一 串口介绍

1.常用函数介绍

串口发送/接收函数：

串口中断回调函数：

状态标记变量：

 2.串口接收中断流程​编辑

3.串口实验（非中断）

 编程实现：

4.串口实验（中断）

编程实现：

二 蓝牙

非中断

中断

连接蓝牙模块

 三 Wifi

1.Wifi模块基本接收和使用

2.WiFi连接服务器

3.Wifi服务器

 四 4G

一 串口介绍

参考51系列文章：

(54条消息) C51：串口_我有在好好学习的博客-CSDN博客

(54条消息) C51：蓝牙/Wifi/4G 无线控制开关_c51蓝牙_我有在好好学习的博客-CSDN博客

1.常用函数介绍

串口发送/接收函数：

HAL_UART_Transmit(); 串口发送数据，使用超时管理机制

HAL_UART_Receive(); 串口接收数据，使用超时管理机制

HAL_UART_Transmit_IT(); 串口中断模式发送

HAL_UART_Receive_IT(); 串口中断模式接收

HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart,uint8_t *pData, uint16_t Size, uint32_t Timeout)

作用：以阻塞的方式发送指定字节的数据

形参 1 ：UART_HandleTypeDef 结构体类型指针变量

形参 2：指向要发送的数据地址

形参 3：要发送的数据大小，以字节为单位

形参 4：设置的超时时间，以ms单位

HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart,uint8_t *pData, uint16_t Size)

作用：以中断的方式接收指定字节的数据

形参 1 是 UART_HandleTypeDef 结构体类型指针变量

形参 2 是指向接收数据缓冲区

形参 3 是要接收的数据大小，以字节为单位

此函数执行完后将清除中断，需要再次调用以重新开启中断。

串口中断回调函数：

HAL_UART_IRQHandler(UART_HandleTypeDef *huart); //串口中断处理函数

HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart); //发送中断回调函数

HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart); //接收中断回调函数

状态标记变量：

USART_RX_STA

从0开始，串口中断接收到一个数据（一个字节）就自增1。当数据读取全部OK时候（回车和换行符号来的时候），那么 USART_RX_STA的最高位置1，表示串口数据接收全部完毕了，然后main函数里面可以处理数据了。

 2.串口接收中断流程

3.串口实验（非中断）

需求：

接受串口工具发送的字符串，并将其发送回串口工具。

硬件接线：

TX -- A10

RX -- A9

一定要记得交叉接线！！

串口配置：

1. 选定串口

 2. 选择模式

异步通讯

3. 串口配置

4. 使用MicroLIB库

从魔术棒打开，这个勾勾一定要打上，否则 printf 无法重映射！

 编程实现：

重写了printf

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include <string.h>

/* USER CODE END Includes */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
int fputc(int ch, FILE *f)
{
	unsigned char temp[1]={ch};
	HAL_UART_Transmit(&huart1,temp,1,0xffff);
	return ch;
}

/* USER CODE END 0 */

//=============================================================================
  /* USER CODE BEGIN 1 */
	uint8_t str[] = "hello world\r\n";
	uint8_t ch[21];
	memset(ch,'\0',21);
	
  /* USER CODE END 1 */

 /* USER CODE BEGIN 2 */
	HAL_UART_Transmit(&huart1,str,strlen(str),100); //串口发送数据，使用超时管理机制
	
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		HAL_UART_Receive(&huart1,ch,20,100);//串口接收数据，使用超时管理机制
		//HAL_UART_Transmit(&huart1,str1,strlen(str1),100); //串口发送数据，使用超时管理机制
		printf(ch);
		memset(ch,'\0',21);
  }
  /* USER CODE END 3 */

4.串口实验（中断）

需求：

通过中断的方法接受串口工具发送的字符串，并将其发送回串口工具。

硬件接线：

同上

串口配置：

前4步同上

5. 打开中断

编程实现：

覆写函数的模板：直接复制粘贴

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
//串口接收缓存（1字节）
uint8_t buf=0;

//定义最大接收字节数 200，可根据需求调整
#define UART1_REC_LEN 200

// 接收缓冲, 串口接收到的数据放在这个数组里，最大UART1_REC_LEN个字节
uint8_t UART1_RX_Buffer[UART1_REC_LEN];

//  接收状态
//  bit15，      接收完成标志
//  bit14，      接收到0x0d
//  bit13~0，    接收到的有效字节数目
uint16_t UART1_RX_STA=0;

/* USER CODE END PV */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
// 接收完成回调函数，收到一个数据后，在这里处理
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	// 判断中断是由哪个串口触发的
	if(huart->Instance == USART1)
	{
		// 判断接收是否完成（UART1_RX_STA bit15 位是否为1）
		if((UART1_RX_STA & 0x8000) == 0)
		{
			// 如果已经收到了 0x0d （回车），
			if(UART1_RX_STA & 0x4000)
			{
				// 则接着判断是否收到 0x0a （换行）
				if(buf == 0x0a)
					// 如果 0x0a 和 0x0d 都收到，则将 bit15 位置为1
					UART1_RX_STA |= 0x8000;
				else
					// 否则认为接收错误，重新开始
					UART1_RX_STA = 0;
			}
			else	// 如果没有收到了 0x0d （回车）
			{
				//则先判断收到的这个字符是否是 0x0d （回车）
				if(buf == 0x0d)
				{
					// 是的话则将 bit14 位置为1
					UART1_RX_STA |= 0x4000;
				}
				else
				{
					// 否则将接收到的数据保存在缓存数组里
					UART1_RX_Buffer[UART1_RX_STA & 0X3FFF] = buf;
					UART1_RX_STA++;
					
					// 如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
					if(UART1_RX_STA > UART1_REC_LEN - 1)
						UART1_RX_STA = 0;
				}
			}
		}
		// 重新开启中断
		HAL_UART_Receive_IT(&huart1, &buf, 1);
	}
}

//=================================================
  /* USER CODE BEGIN 2 */
	// 开启接收中断
	HAL_UART_Receive_IT(&huart1, &buf, 1);
	
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		
		//判断判断串口是否接收完成
		if(UART1_RX_STA & 0x8000)
		{
			printf("收到数据：");
			// 将收到的数据发送到串口
			HAL_UART_Transmit(&huart1, UART1_RX_Buffer, UART1_RX_STA & 0x3fff, 0xffff);
			// 等待发送完成
			while(huart1.gState != HAL_UART_STATE_READY);
			printf("\r\n");
			// 重新开始下一次接收
			UART1_RX_STA = 0;
		}
		printf("=====\r\n");
		HAL_Delay(1000);
  }
	
  /* USER CODE END 3 */

二 蓝牙

非中断

点亮板载LED，判断接收的数据是否为“open”"close",如果不是就提示输入错误，先用串口调试，再上蓝牙模块。

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <string.h>
#include <stdio.h>

/* USER CODE END Includes */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
//覆写printf
int fputc(int ch, FILE *f)
{
	unsigned char temp[1]={ch};
	HAL_UART_Transmit(&huart1,temp,1,0xffff);
	return ch;
}

/* USER CODE END 0 */
//=============================================================================
  /* USER CODE BEGIN 2 */
	HAL_UART_Transmit(&huart1,(uint8_t *)"uart_start\r\n",strlen("uart_start\r\n"),100); //串口发送数据，使用超时管理机制
  /* USER CODE END 2 */

    /* USER CODE BEGIN 3 */
		HAL_UART_Receive(&huart1, ch, 19, 100);
		//HAL_UART_Transmit(&huart1, ch, strlen(ch), 100);
		//printf((char *)ch);
		printf("%s", ch);
		
		if (!strcmp((const char *)ch, "open")) {
			HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_RESET);
			if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_RESET)
				printf("LED1已打开\r\n");
		}else if(!strcmp((const char *)ch, "close")) {
			HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_SET);
			if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_SET)
				printf("LED1已关闭\r\n");
		} else {
			if(ch[0] != '\0')
				printf("指令发送错误：%s\r\n", ch);
		}
		
		memset(ch, 0, strlen((const char *)ch));
  }
  /* USER CODE END 3 */

中断

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
//串口接收缓存（1字节）
uint8_t buf=0;

//定义最大接收字节数 200，可根据需求调整
#define UART1_REC_LEN 200

// 接收缓冲, 串口接收到的数据放在这个数组里，最大UART1_REC_LEN个字节
uint8_t UART1_RX_Buffer[UART1_REC_LEN];

//  接收状态
//  bit15，      接收完成标志
//  bit14，      接收到0x0d
//  bit13~0，    接收到的有效字节数目
uint16_t UART1_RX_STA=0;

/* USER CODE END PV */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
// 接收完成回调函数，收到一个数据后，在这里处理
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	// 判断中断是由哪个串口触发的
	if(huart->Instance == USART1)
	{
		// 判断接收是否完成（UART1_RX_STA bit15 位是否为1）
		if((UART1_RX_STA & 0x8000) == 0)
		{
			// 如果已经收到了 0x0d （回车），
			if(UART1_RX_STA & 0x4000)
			{
				// 则接着判断是否收到 0x0a （换行）
				if(buf == 0x0a)
					// 如果 0x0a 和 0x0d 都收到，则将 bit15 位置为1
					UART1_RX_STA |= 0x8000;
				else
					// 否则认为接收错误，重新开始
					UART1_RX_STA = 0;
			}
			else	// 如果没有收到了 0x0d （回车）
			{
				//则先判断收到的这个字符是否是 0x0d （回车）
				if(buf == 0x0d)
				{
					// 是的话则将 bit14 位置为1
					UART1_RX_STA |= 0x4000;
				}
				else
				{
					// 否则将接收到的数据保存在缓存数组里
					UART1_RX_Buffer[UART1_RX_STA & 0X3FFF] = buf;
					UART1_RX_STA++;
					
					// 如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
					if(UART1_RX_STA > UART1_REC_LEN - 1)
						UART1_RX_STA = 0;
				}
			}
		}
		// 重新开启中断
		HAL_UART_Receive_IT(&huart1, &buf, 1);
	}
}

//覆写printf
int fputc(int ch, FILE *f)
{
	unsigned char temp[1]={ch};
	HAL_UART_Transmit(&huart1,temp,1,0xffff);
	return ch;
}

/* USER CODE END 0 */

//=====================================================================================
/* USER CODE BEGIN 2 */
	// 开启接收中断
	HAL_UART_Receive_IT(&huart1, &buf, 1);
	//启动提示
	HAL_UART_Transmit(&huart1,(uint8_t *)"uart_start\r\n",strlen("uart_start\r\n"),100); 
	
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		//判断判断串口是否接收完成
		if(UART1_RX_STA & 0x8000)
		{
			printf("收到数据：");
			
		if (!strcmp((const char *)UART1_RX_Buffer, "open")) {
			HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_RESET);
			if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_RESET)
				printf("LED1已打开\r\n");
		}else if(!strcmp((const char *)UART1_RX_Buffer, "close")) {
			HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_SET);
			if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_SET)
				printf("LED1已关闭\r\n");
		} else {
			if(UART1_RX_Buffer[0] != '\0')
				printf("指令发送错误：%s\r\n", UART1_RX_Buffer);
		}
		
		memset(UART1_RX_Buffer, 0, strlen((const char *)UART1_RX_Buffer));

			// 重新开始下一次接收
			UART1_RX_STA = 0;
		}
		HAL_Delay(200);
  }
  /* USER CODE END 3 */
}

连接蓝牙模块

模块波特率为9600

所以修改串口波特率

再连接模块即可使用。 

 三 Wifi

1.Wifi模块基本接收和使用

参考之前的文章

(55条消息) C51：蓝牙/Wifi/4G 无线控制开关_c51蓝牙_我有在好好学习的博客-CSDN博客文章来源地址https://www.toymoban.com/news/detail-764316.html

2.WiFi连接服务器

 在接收中断处理中加入一个是否接收到OK的判断，改变标志位AT_OK_FLAG,用这个标志位卡住联网过程，收到OK再继续发下一个AT指令。

联网完成后，服务器端会收到你设置的心跳包。并且开始进行灯控指令的接收判断。

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <string.h>
#include <stdio.h>

/* USER CODE END Includes */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
//AT指令
char connecct_wifi[] = "AT+CWJAP=\"iQOO 5\",\"88888888\"\r\n";
char connect_server[] = "AT+CIPSTART=\"TCP\",\"192.168.138.144\",8880\r\n";
char CIPMODE[] = "AT+CIPMODE=1\r\n";
char CIPSEND[] = "AT+CIPSEND\r\n";

//是否收到OK标志位，是否收到error标志位,联网状态标志位
uint8_t AT_OK_FLAG = 0;
uint8_t ERROR_FLAG = 0;
uint8_t NET_OK_FLAG = 0;

/* USER CODE END PD */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
//串口接收缓存（1字节）
uint8_t buf=0;

//定义最大接收字节数 200，可根据需求调整
#define UART1_REC_LEN 200

// 接收缓冲, 串口接收到的数据放在这个数组里，最大UART1_REC_LEN个字节
uint8_t UART1_RX_Buffer[UART1_REC_LEN];

//  接收状态
//  bit15，      接收完成标志
//  bit14，      接收到0x0d
//  bit13~0，    接收到的有效字节数目
uint16_t UART1_RX_STA=0;

/* USER CODE END PV */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
// 接收完成回调函数，收到一个数据后，在这里处理
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	// 判断中断是由哪个串口触发的
	if(huart->Instance == USART1)
	{
		// 判断接收是否完成（UART1_RX_STA bit15 位是否为1）
		if((UART1_RX_STA & 0x8000) == 0)
		{
			// 如果已经收到了 0x0d （回车），
			if(UART1_RX_STA & 0x4000)
			{
				// 则接着判断是否收到 0x0a （换行）
				if(buf == 0x0a)
				{
					// 如果 0x0a 和 0x0d 都收到，则将 bit15 位置为1
					UART1_RX_STA |= 0x8000;
					
					//=================================
					//判断是否是已经连上服务器，
                    //如果没有，判断有没有收到AT指令返回的OK，ERROR
					if(!NET_OK_FLAG)
					{
						if(!strcmp((const char *)UART1_RX_Buffer, "OK"))
							AT_OK_FLAG = 1;
						if(!strcmp((const char *)UART1_RX_Buffer, "ERROR"))
						{
							ERROR_FLAG = 1;
							//收到ERROR，闪灯
							for(i = 0;i<10;i++)
							{
								HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_9);
								HAL_Delay(200);
							}
						}
					}
					//=================================
					//如果已经连上服务器，进行灯控指令部分判断
					else
					{
						if (!strcmp((const char *)UART1_RX_Buffer, "open")) {
							HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_RESET);
							if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_RESET)
								printf("LED1已打开\r\n");
						}else if(!strcmp((const char *)UART1_RX_Buffer, "close")) {
							HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_SET);
							if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_SET)
								printf("LED1已关闭\r\n");
						} else {
							if(UART1_RX_Buffer[0] != '\0')
								printf("指令发送错误：%s\r\n", UART1_RX_Buffer);
						}
					}
					//=================================
					//判断结束，清空接收信息
					memset(UART1_RX_Buffer, 0, UART1_REC_LEN);
					// 重新开始下一次接收
					UART1_RX_STA = 0;
				}
					
				else
					// 否则认为接收错误，重新开始
					UART1_RX_STA = 0;
			}
			else	// 如果没有收到了 0x0d （回车）
			{
				//则先判断收到的这个字符是否是 0x0d （回车）
				if(buf == 0x0d)
				{
					// 是的话则将 bit14 位置为1
					UART1_RX_STA |= 0x4000;
				}
				else
				{
					// 否则将接收到的数据保存在缓存数组里
					UART1_RX_Buffer[UART1_RX_STA & 0X3FFF] = buf;
					UART1_RX_STA++;
					
					// 如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
					if(UART1_RX_STA > UART1_REC_LEN - 1)
						UART1_RX_STA = 0;
				}
			}
		}
		// 重新开启中断
		HAL_UART_Receive_IT(&huart1, &buf, 1);
	}
}

//覆写printf
int fputc(int ch, FILE *f)
{
	unsigned char temp[1]={ch};
	HAL_UART_Transmit(&huart2,temp,1,0xffff);//发送给串口2
	return ch;
}
//===================================main===========================================
/* USER CODE END 0 */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  MX_USART2_UART_Init();
	
  /* USER CODE BEGIN 2 */
	// 开启接收中断
	HAL_UART_Receive_IT(&huart1, &buf, 1);
	//启动提示
	printf("uart_start\r\n"); 
	
	//============联网部分代码=============
	//给上电时间
	HAL_Delay(2000);
	//如果下面收到ERROR，从这里重新开始
	retry:
	//先清0
	ERROR_FLAG = 0;
	
	//开始联网提示
	printf("begin connection\r\n"); 
	
	//发送第1个AT指令===========================
	HAL_UART_Transmit(&huart1,(uint8_t *)connecct_wifi,strlen(connecct_wifi),100);
	
	//如果收到OK，再继续
	while(!AT_OK_FLAG)
	{
		//判断是否已经ERR，如果ERR，重新开始联网
		if(ERROR_FLAG)	goto retry;
		HAL_Delay(50);
	}
	AT_OK_FLAG = 0;
	
	printf("Wifi ON\r\n");
	
	//发送第2个AT指令===========================
	HAL_UART_Transmit(&huart1,(uint8_t *)connect_server,strlen(connect_server),100);
	
	//如果收到OK，再继续
	while(!AT_OK_FLAG)
	{
		//判断是否已经ERR，如果ERR，重新开始联网
		if(ERROR_FLAG)	goto retry;
		HAL_Delay(50);
	}
	AT_OK_FLAG = 0;
	
	printf("Server ON\r\n");
	
	//发送第3个AT指令===========================
	HAL_UART_Transmit(&huart1,(uint8_t *)CIPMODE,strlen(CIPMODE),100);
	
	//如果收到OK，再继续
	while(!AT_OK_FLAG)
	{
		//判断是否已经ERR，如果ERR，重新开始联网
		if(ERROR_FLAG)	goto retry;
		HAL_Delay(50);
	}
	AT_OK_FLAG = 0;
	
	printf("CIPMODE ON\r\n");

	//发送第4个AT指令===========================
	HAL_UART_Transmit(&huart1,(uint8_t *)CIPSEND,strlen(CIPSEND),100);
	
	//如果收到OK，再继续
	while(!AT_OK_FLAG)
	{
		//判断是否已经ERR，如果ERR，重新开始联网
		if(ERROR_FLAG)	goto retry;
		HAL_Delay(50);
	}
	AT_OK_FLAG = 0;
	
	printf("CIPSEND ON\r\n");
	
	//联网完成改变标志位
	NET_OK_FLAG = 1;
	//联网完成亮起指示灯
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, GPIO_PIN_RESET);
	
	printf("NET OK\r\n");

  /* USER CODE END 2 */
//===============================================================================

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		//判断判断串口是否接收完成
		//心跳包
		HAL_UART_Transmit(&huart1,(uint8_t *)"stm32\r\n",strlen("stm32\r\n"),100);
		HAL_Delay(1000);

  }
  /* USER CODE END 3 */

3.Wifi服务器

原理相同，基本上改变一些AT指令就可以了。

但是要注意，主机模式下收到的字符串形式如下

发送“ op ” ，实际上接收的结果为“ +IPD,0,2:op ”

直接用strcmp()没法判断，所以做了一个小字符串buffer，用来获取 “ : ” 后的内容

然后判断buffer的内容即可

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <string.h>
#include <stdio.h>

/* USER CODE END Includes */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
//AT指令

//1 配置成双模
uint8_t CWMODE[] = "AT+CWMODE=2\r\n";
//2 使能多链接
uint8_t CIPMUX[] = "AT+CIPMUX=1\r\n";
//3 建立TCPServer
uint8_t CIPSERVER[] = "AT+CIPSERVER=1\r\n";// default port = 333
//4 发送数据
uint8_t CIPSEND[] = "AT+CIPSEND=0,8\r\n";// 发送8个字节在连接0通道上

//是否收到OK标志位，是否收到error标志位,联网状态标志位
uint8_t AT_OK_FLAG = 0;
uint8_t ERROR_FLAG = 0;
uint8_t NET_OK_FLAG = 0;

uint8_t i,j;//for用

uint8_t buffer[8];//接收开灯指令
uint8_t message_mark = 0;//判断是否是来自客户端的指令

/* USER CODE END PD */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
//串口接收缓存（1字节）
uint8_t buf=0;

//定义最大接收字节数 200，可根据需求调整
#define UART1_REC_LEN 200

// 接收缓冲, 串口接收到的数据放在这个数组里，最大UART1_REC_LEN个字节
uint8_t UART1_RX_Buffer[UART1_REC_LEN];

//  接收状态
//  bit15，      接收完成标志
//  bit14，      接收到0x0d
//  bit13~0，    接收到的有效字节数目
uint16_t UART1_RX_STA=0;

/* USER CODE END PV */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
// 接收完成回调函数，收到一个数据后，在这里处理
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	// 判断中断是由哪个串口触发的
	if(huart->Instance == USART1)
	{
		// 判断接收是否完成（UART1_RX_STA bit15 位是否为1）
		if((UART1_RX_STA & 0x8000) == 0)
		{
			// 如果已经收到了 0x0d （回车），
			if(UART1_RX_STA & 0x4000)
			{
				// 则接着判断是否收到 0x0a （换行）
				if(buf == 0x0a)
				{
					// 如果 0x0a 和 0x0d 都收到，则将 bit15 位置为1
					UART1_RX_STA |= 0x8000;
					
					//=================================
					//判断是否是已经连上服务器，
          //如果没有，判断有没有收到AT指令返回的OK，ERROR
					if(!NET_OK_FLAG)
					{
						if(!strcmp((const char *)UART1_RX_Buffer, "OK"))
							AT_OK_FLAG = 1;
						if(!strcmp((const char *)UART1_RX_Buffer, "ERROR"))
						{
							ERROR_FLAG = 1;
							//收到ERROR，闪灯
							for(i = 0;i<10;i++)
							{
								HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_9);
								HAL_Delay(200);
							}
						}
					}
					//=================================
					//如果已经连上服务器，进行灯控指令部分判断
					else
					{
						//判断是否是来自客户端的信息，如果是就接收它
						for(i = 0;i < UART1_REC_LEN;i++){
							if(UART1_RX_Buffer[i] == ':' || message_mark){
								if(UART1_RX_Buffer[i] == ':')	i++;
								message_mark = 1;
								buffer[j] = UART1_RX_Buffer[i];
								j++;
								if(j >= 8)	break;
							}
						}
						message_mark = 0;
						j = 0;
						//根据来自客户端的信息判断开不开灯
						if (!strcmp((const char *)buffer, "open")) {
							HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_RESET);
							if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_RESET)
								printf("LED1已打开\r\n");
							memset(buffer, 0, 8);
							}else if(!strcmp((const char *)buffer, "close")) {
							HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_SET);
							if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_SET)
								printf("LED1已关闭\r\n");
							memset(buffer, 0, 8);
						}
					}
					//=================================
					//判断结束，清空接收信息
					memset(UART1_RX_Buffer, 0, UART1_REC_LEN);
					// 重新开始下一次接收
					UART1_RX_STA = 0;
				}
					
				else
					// 否则认为接收错误，重新开始
					UART1_RX_STA = 0;
			}
			else	// 如果没有收到了 0x0d （回车）
			{
				//则先判断收到的这个字符是否是 0x0d （回车）
				if(buf == 0x0d)
				{
					// 是的话则将 bit14 位置为1
					UART1_RX_STA |= 0x4000;
				}
				else
				{
					// 否则将接收到的数据保存在缓存数组里
					UART1_RX_Buffer[UART1_RX_STA & 0X3FFF] = buf;
					UART1_RX_STA++;
					
					// 如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
					if(UART1_RX_STA > UART1_REC_LEN - 1)
						UART1_RX_STA = 0;
				}
			}
		}
		// 重新开启中断
		HAL_UART_Receive_IT(&huart1, &buf, 1);
	}
}

//覆写printf
int fputc(int ch, FILE *f)
{
	unsigned char temp[1]={ch};
	HAL_UART_Transmit(&huart2,temp,1,0xffff);//发送给串口2
	return ch;
}

/* USER CODE END 0 */

//==================================main====================================
  /* USER CODE BEGIN 2 */
	// 开启接收中断
	HAL_UART_Receive_IT(&huart1, &buf, 1);
	//启动提示
	printf("uart_start\r\n"); 
	
	//=================================
	//给上电时间
	HAL_Delay(2000);
	//如果下面收到ERROR，从这里重新开始
	retry:
	//先清0
	ERROR_FLAG = 0;
	
	//开始联网提示
	printf("begin connection\r\n"); 
	
	//发送第1个AT指令===========================
	HAL_UART_Transmit(&huart1,(uint8_t *)CWMODE,strlen((const char *)CWMODE),100);
	
	//如果收到OK，再继续
	while(!AT_OK_FLAG)
	{
		//判断是否已经ERR，如果ERR，重新开始联网
		if(ERROR_FLAG)	goto retry;
		HAL_Delay(50);
	}
	AT_OK_FLAG = 0;
	
	printf("Wifi ON\r\n");
	
	//发送第2个AT指令===========================
	HAL_UART_Transmit(&huart1,(uint8_t *)CIPMUX,strlen((const char *)CIPMUX),100);
	
	//如果收到OK，再继续
	while(!AT_OK_FLAG)
	{
		//判断是否已经ERR，如果ERR，重新开始联网
		if(ERROR_FLAG)	goto retry;
		HAL_Delay(50);
	}
	AT_OK_FLAG = 0;
	
	printf("Server ON\r\n");
	
	//发送第3个AT指令===========================
	HAL_UART_Transmit(&huart1,(uint8_t *)CIPSERVER,strlen((const char *)CIPSERVER),100);
	
	//如果收到OK，再继续
	while(!AT_OK_FLAG)
	{
		//判断是否已经ERR，如果ERR，重新开始联网
		if(ERROR_FLAG)	goto retry;
		HAL_Delay(50);
	}
	AT_OK_FLAG = 0;
	
	printf("CIPMODE ON\r\n");

	
	//联网完成改变标志位
	NET_OK_FLAG = 1;
	//联网完成亮起指示灯
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, GPIO_PIN_RESET);
	
	printf("server OK\r\n");

  /* USER CODE END 2 */
//==========================================
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		//判断判断串口是否接收完成
		//心跳包
		
		HAL_UART_Transmit(&huart1,(uint8_t *)CIPSEND,strlen((const char *)CIPSEND),100);
		HAL_Delay(2000);
		HAL_UART_Transmit(&huart1,(uint8_t *)"stm32f1.",strlen("stm32f1."),100);
		HAL_Delay(2000);
		
  }
  /* USER CODE END 3 */

 四 4G

和WIFI模块一样的操作，而且更加简单，修改对应的AT指令即可，主机搞个内网穿透。

具体参考之前的文章，轻松愉快，不写出来了。

(55条消息) C51：蓝牙/Wifi/4G 无线控制开关_c51蓝牙_我有在好好学习的博客-CSDN博客

到了这里，关于STM32：串口（蓝牙/WIFI/4G）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！