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

已于 2023-07-24 12:33:43 修改
阅读量2.2k 收藏 29
点赞数
分类专栏： STM32 文章标签： stm32 嵌入式硬件 单片机
于 2023-07-19 10:51:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73379310/article/details/131777502
版权

目录

一 串口介绍

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博客

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博客

我有在好好学习
关注
专栏目录
05 STM32寄存器开发基础-串口编程
07-17 6090
这篇文章学习`STM32F103`单片机，从0开始学习串口，以寄存器方式，配置串口，完成串口的数据发送与接收。
基于STM32设计的4G远程视频侦查小车(图传+远程控制+EMQX+MQTT)(204)
08-09 955
当前设计了一款基于STM32F103ZET6主控芯片和废旧Android手机改造的4G侦查小车。该设计充分利用已有的智能手机硬件资源，实现摄像头画面的实时采集与上传，以及远程控制功能。这样的设计不仅降低了成本，而且充分利用了废旧手机中高性能的硬件资源，如摄像头、4G通信模块和电池等，实现了资源的有效循环利用。
STM32串口
weixin_43006196的博客
03-01 1958
1、通过STM32CubeMX配置串口。 串口1选择Asynchronous，异步通信。 115200bps，8N1，默认即可。 2、串口发送数据。 STM32Cube生成代码后，在main.c的while(1)前面加一句。 HAL_UART_Transmit(&huart1, "Hello world!\r\n", 14, 10); HAL_UART_Transmit()是串口发送函数， 第一个参数是串口号，&huart1. 第二个参数是要发送的数组，"Hello w
✔stm32—串口
qq_68915288的博客
08-16 377
外部设备将数据往Rx引脚上发送，因为串口协议规定数据是一个bit一个bit 发送的，所以每来一个bit，需要进行位移位或操作后先将其保存在接收移位寄存器中，当数据到齐之后，再将其挪入接收数据寄存器(Receiver Data Register)，此时CPU就应该及时将RDR寄存器中接收到的数据及时读走，否则会被下一次发过来的数据给覆盖掉。一个串口控制器，只对应一个中断，但是串口的多个标志，都可以引起串口的中断，因此，在你的串口中断处理函数中，要加以区分，以作不同的处理。
STM32入门教程：WiFi通信
最新发布
xiaoalla的博客
09-20 910
在本教程中，我们将使用STM32微控制器和WiFi模块进行无线通信。我们将以详细的代码案例为基础，逐步介绍如何设置WiFi模块、建立连接、发送和接收数据等操作。第四步：建立连接 在本例中，我们将使用TCP/IP协议通过WiFi模块建立与远程服务器的连接。将WiFi模块连接到STM32板上，使用USB转串口模块将STM32板连接到计算机上。第二步：设置WiFi模块 我们将使用AT指令集来配置和控制WiFi模块。当您输入这些指令后，您应该能够看到WiFi模块成功连接到WiFi网络，并获得一个IP地址。
STM32之串口
qq_45764141的博客
04-25 3003
并行通信 一次性一起传，需要引脚比较多，速度快。 串行同行 一个个传，需要引脚比较少，速度较慢 串行通信的通信方式 1、同步（带时钟同步信号），如：SPI，IIC 2、异步（不带时钟同步信号），如：UART，单总线 UART：通用异步收发传输器 USART：通用同步/异步串行接收/发送器 USART ...
STM32F103C8T6第4天：串口实验（非中断和中断）、hc01蓝牙、esp8266WIFI、4g
Jaci133的博客
11-15 430
通过ESP8266模块，实现手机控制wifi插座/风扇/灯。
STM32 SPI驱动 CH9434串口拓展芯片
09-13
CH9434是一款SPI转四串口控制芯片，提供四组全双工的9线异步串口，用于单片机/嵌入式系统扩展异步串口。CH9434包含四个兼容16C550的异步串口，最高支持4Mbps波特率通讯...与蓝牙、4G、WiFi等串口模块通讯实现无线传输。
stm32 AES256加密 串口IAP升级 bootloader程序 通过上位机将keil生成的BIN文件进行AES加密，得到
09-13
stm32 AES256加密 串口IAP升级 bootloader程序 通过上位机将keil生成的...理论上，只要移植AES的.c和.h文件，并且你能将数据发送到单片机串口，就能用任意方式来对单片机进行升级，包括但不限于wifi，蓝牙，4G模块等。
STM32串口wifi
09-01
stm32驱动串口wifi，和android设备进行通信。 stm32温湿度采集和12864显示 把采集的温湿度数据传入Android端口。 Android可以手动设置温湿度范围，并将数据传给下位机。
stm32——串口
m0_59247951的博客
07-19 1320
USART 是 Universal Synchronous/Asynchronous Receiver/Transmitter 的缩写，即通用同步/异步收发传输器。串口通讯的基本参数：串口通讯的速率标志一个数据帧的开始，且固定是低电平数据帧的有效载荷，1为高电平，0为低电平·校验位:用于数据验证，根据数据位计算而来（奇偶校验）用于数据帧间隔，固定为高电平注意：这里我们 可以看到一个为8位数据一个为9位数据，他们的校验位就是一个用无校验，一个用奇偶校验。
STM32—串口
m0_49830036的博客
01-30 2642
串行接口简称串口，也称串行通信接口或串行通讯接口（通常指COM接口），是采用串行通信方式的扩展接口。串行接口（Serial Interface）是指数据一位一位地顺序传送。其特点是通信线路简单，只要一对传输线就可以实现双向通信（可以直接利用电话线作为传输线），从而大大降低了成本，特别适用于远距离通信，但传送速度较慢是设备间接线通信的一种方式数据一位一位地顺序传送双向通信，全双工传送速度相对较慢UART是异步串行接口，通信双方使用时钟不同，因为双方硬件配置不同，但是需要约定通信 速度，叫做波特率。
【STM32】串口通信基本原理（超基础、详细版）
u013407012的专栏
10-09 5191
本文链接：https://blog.csdn.net/qq_38410730/article/details/79887200 STM32F1xx官方资料： 《STM32中文参考手册V10》-第25章通用同步异步收发器（USART) 通信接口背景知识 设备之间通信的方式 一般情况下，设备之间的通信方式可以分成并行通信和串行通信两种。它们的区别是： 并、串行通信的区别 并行通...
STM32的串口通信
rich369的博客
07-10 165
在基础实验成功的基础上，对串口的调试方法进行实践。硬件代码顺利完成之后，对日后调试需要用到的printf重定义进行调试，固定在自己的库函数中。 b) 初始化函数定义： void USART_Configuration(void); //定义串口初始化函数 c) 初始化函数调用： void UART_Configuration(void); //串口初始化函数调用 初始化代码： void USART_Configuration(void) //串口初始化函数 { //串口参数初始化 USART_InitTyp
STM32之串口通信
m0_47794668的博客
10-29 645
​ 任务一、 用STM32CubeMX配合keil，用GPIO端口完成三只LED红绿灯的周期闪烁 1、STM32CubeMx下载网址：STM32CubeMX - STM32Cube initialization code generator - STMicroelectronics 安装好之后，打开主界面，找到help→manage embedded software paclages 下载STM32F1中的1.8.4版本 2、HAL方式 ①创建工程，点击file→new project，选择STM32F
【stm32】串口通信
weixin_51914919的博客
03-07 7071
串口通信一、串口通信协议原理二、usart功能框图三、stm32库 一、串口通信协议原理 串口在嵌入式系统当中是一类重要的数据通信接口，其本质功能是作为 CPU 和串行设备间的编码转换器。当数据从 CPU 经过串行端口发送出去时，字节数据转换为串行的位；在接收数据时，串行的位被转换为字节数据。应用程序要使用串口进行通信，必须在使用之前向操作系统提出资源申请要求（打开串口），通信完成后必须释放资源（关闭串口）。典型地，串口用于 ASCII 码字符的传输。通信使用3根线完成：地线，发送数据线，接收数据线。串口通
STM32串口通信
AKAYY的博客
12-05 455
STM32串口通信一、基于寄存器与固件库的stm32编程方式的差异二、STM32串口通信1、准备 一、基于寄存器与固件库的stm32编程方式的差异 使用固件库，目前比较多的例程是使用固件库编写的。固件库编写方式，特点是简单易于理解，资料多。新手适合用这种方式入门。 使用寄存器，想要深入理解CortexM3内核或是需要为了获得更好的可移植性，学习寄存器编程会比较有帮助。但是从专业的角度上看，寄存器更贴近底层，对外设的工作原理和运行机理会有更深的理解。优点：①具体参数更直观 ②程序运行占用资源少。 缺点：①开发
STM32F030CCT6智能锁工程：指纹、蓝牙/WIFI与电子纸显示屏功能集成
资源摘要信息:"基于STM32F030CCT6的智能锁工程，涉及的技术点广泛，包括指纹识别、蓝牙与WIFI通信、电子纸显示屏、语音芯片应用、直流电机驱动以及电源管理。该工程是一个完整的系统，结合了STM32F030CCT6微控制器的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值