【stm32片外外设】esp8266的mqtt通信

于 2024-08-12 15:50:37 发布
阅读量201 收藏 2
点赞数 5
分类专栏： stm32外设 文章标签： stm32 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63954303/article/details/141133836
版权

【stm32片外外设】esp8266的mqtt通信

文章目录

2024年8月12日

参考一家4G模块公司写的mqtt通信代码，写的一个esp8266的mqtt通信的代码。

介绍啥的就没写了，代码有简单的解释，先发布混混阅读点赞，哈哈哈哈，后面有时间再补。

参考代码

bsp_esp8266.h

/**
 * author：	临木木
 * date：	2024年8月12日
 * 适用于stm32裸机的esp8266的mqtt通信驱动
 * 依赖文件：
 *			#include "./usart/bsp_usart.h"				// 串口
 *			#include "./soft_timer/bsp_soft_timer.h"	// 软件定时器
 *			#include "./cjson/cJSON.h"					// cjson
 * 
 * bsp_esp8266_work()置于主循环内，即可按默认的顺序循环发送信息
 * 可使用以下函数进行有限配置修改
 * bsp_esp8266_wifi_disposition_set()/bsp_esp8266_broker_disposition_set()/bsp_esp8266_publish_data_set()
 */
#ifndef __BSP_ESP8266_H__
#define __BSP_ESP8266_H__


#define DEBUG_HUART						huart1			
#define WIFI_HUART						huart2
#define WIFI_BSP_HUART					BSP_USART_2
#define WIFI_SOFT_TIMER_ID				1
#define WIFI_SOFT_TIMER_ID_2			2


#define ESP8266_POWER_ON_WAIT_TIME 		4000 													/* 开机等待时间 */
#define RST_GPIO_SET_HIGH  				HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET)		/* RST复位引脚设置为高电平 */
#define RST_GPIO_SET_LOW   				HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET) 	/* RST复位引脚设置为低电平 */	

/* esp8266用户属性 */
#define MQTT_USER_ID					"client_1"
#define MQTT_USER_NAME					"lin"
#define MQTT_USER_PASSWORD				"12345678"

#define MQTT_SUBSCRIBE_TOPIC			"oo"		/* 订阅主题 */

#define MQTT_PUBLISH_TOPIC				"hello"		/* 发布主题 */

	
int bsp_esp8266_work
	(
	void
	);
	
int bsp_esp8266_wifi_disposition_set
	(
	char 			name[],
	unsigned int 	len_name,
	char 			password[],
	unsigned int 	len_password
	);
	
int bsp_esp8266_broker_disposition_set
	(
	char 			ip[],
	unsigned int 	len_ip,
	char 			port[],
	unsigned int 	len_port
	);
	
int bsp_esp8266_publish_data_set
	(
	char 			data[],
	unsigned int 	len_data
	);
	

#endif

bsp_esp8266.c

#include "./esp8266/bsp_esp8266.h"

#include <string.h>
#include <stdio.h>

#include "gpio.h"
#include "usart.h"

#include "./usart/bsp_usart.h"
#include "./soft_timer/bsp_soft_timer.h"
#include "./cjson/cJSON.h"


#define ESP8266_RECIVE_BUF_SIZE		1024

/* esp8266状态 */
typedef enum ESP8266_STATE
{
	ESP8266_RESET 			= 0,
	ESP8266_SHAKE_HANDS		= 1,
	ESP8266_WIFI_CONNECT	= 2,
	ESP8266_MQTT_INIT		= 3,
	ESP8266_COMMUNICATION	= 4,
	ESP8266_OK				= 0xFE,
	ESP8266_ERROR			= 0xFF
} ESP8266_STATE;


static int 	esp8266_state = 0;
static char esp8266_wifi_name[48] 		= "1315";
static char esp8266_wifi_password[48] 	= "shd13151315";
static char mqtt_broker_ip[16] 			= "192.168.1.100";
static char mqtt_broker_port[8] 		= "1883";
static char esp8266_publish_data[256]	= "hello";

static int recive_len = 0;
static unsigned char recive_buf[ESP8266_RECIVE_BUF_SIZE];

static cJSON *cjson_test	= NULL;
static cJSON *cjson_name	= NULL;
static cJSON *cjson_age		= NULL;


/* bsp_esp8266_at_cmd：esp8266发送at指令
 * cmd			at指令
 * delay		等待指令回复的时间
 * return		到达等待时间返回1，否则返回0 */
int bsp_esp8266_at_cmd
	(
	const char 		*cmd,
	unsigned int 	delay
	)
{
	if (bsp_soft_timer_state_get(WIFI_SOFT_TIMER_ID) == SOFT_TIMER_STOPPED)
	{
		bsp_soft_timer_start(WIFI_SOFT_TIMER_ID, SOFT_TIMER_MODE_ONE_SHOT, delay, bsp_soft_timer_nop_callback, NULL, 0);
		HAL_UART_Transmit(&DEBUG_HUART, (const unsigned char*)cmd, (unsigned short int)strlen(cmd), 1000);
		HAL_UART_Transmit(&WIFI_HUART, (const unsigned char*)cmd, (unsigned short int)strlen(cmd), delay);
	}
	
	if (bsp_soft_timer_state_get(WIFI_SOFT_TIMER_ID) == SOFT_TIMER_TIMEOUT)
	{
		return 1;
	}
	
	return 0;
}


/* bsp_esp8266_keyword_matching：应答字符关键字校验
 * keyword		关键字 
 * return		包含关键字返回1，否则返回0 */
int bsp_esp8266_keyword_matching
	(
	char 			*keyword
	)
{
	recive_len = bsp_usart_get(recive_buf, WIFI_BSP_HUART);
	
	if (recive_len != -1)
	{	
		HAL_UART_Transmit(&DEBUG_HUART, recive_buf, recive_len, 1000);
		/* bsp_usart_get()函数的传递方式 */
		recive_buf[recive_len] = '\0';		
		if (strstr((const char*)recive_buf, keyword) != NULL)
		{
			return 1;
		}
		else
		{
			return 0;
		}
	}
	else
	{
	}
	
	return -1;
}


/* bsp_esp8266_reset：esp8266复位操作
 * return		成功返回1，正在复位返回0 */
int bsp_esp8266_reset
	(
	void
	)
{
	static unsigned char state = 0;
	
	switch (state)
	{
		case 0x00:
			state++;
			RST_GPIO_SET_HIGH;
			break;
		
		case 0x01:
			state++;
			RST_GPIO_SET_LOW;
			break;
		
		case 0x02:
			if (bsp_soft_timer_state_get(WIFI_SOFT_TIMER_ID) == SOFT_TIMER_STOPPED)
			{
				bsp_soft_timer_start(WIFI_SOFT_TIMER_ID, SOFT_TIMER_MODE_ONE_SHOT, 1000, bsp_soft_timer_nop_callback, NULL, 0);
			}
			
			if (bsp_soft_timer_state_get(WIFI_SOFT_TIMER_ID) == SOFT_TIMER_TIMEOUT)
			{
				state++;
				RST_GPIO_SET_HIGH;
			}
			break;
			
		case 0x03:
			if (bsp_soft_timer_state_get(WIFI_SOFT_TIMER_ID) == SOFT_TIMER_STOPPED)
			{
				bsp_soft_timer_start(WIFI_SOFT_TIMER_ID, SOFT_TIMER_MODE_ONE_SHOT, ESP8266_POWER_ON_WAIT_TIME, bsp_soft_timer_nop_callback, NULL, 0);
			}
			
			if (bsp_soft_timer_state_get(WIFI_SOFT_TIMER_ID) == SOFT_TIMER_TIMEOUT)
			{
				state = 0x00;
				return 1;
			}
			break;
	}
	
	return 0;
}


/* bsp_esp8266_shake_hands：esp8266握手操作
 * return		成功返回ESP8266_OK，正在握手返回0，错误返回ESP8266_ERROR */
int bsp_esp8266_shake_hands
	(
	void
	)
{
	static unsigned char state = 0;
	static unsigned char error_times = 0;

	switch (state)
	{
		case 0x00:
			if (bsp_esp8266_at_cmd("AT\r\n", 1000) == 1)
			{
				if (bsp_esp8266_keyword_matching("OK") == 1)
				{
					state = ESP8266_OK;
					error_times = 0;
					printf("esp8266: %s ==> OK\r\n", "AT");
				}
				else
				{
					/* 三次以上错误，进入复位 */
					if (++error_times > 3)
					{
						state = ESP8266_ERROR;
						printf("esp8266: %s ==> ERROR\r\n", "AT");
					}
				}
			}
			break;
			
		case ESP8266_ERROR:
			state = 0x00;
			error_times = 0;
			return ESP8266_ERROR;
		
		case ESP8266_OK:
			state = 0x00;
			return ESP8266_OK;
	}
	
	return 0;
}


/* bsp_esp8266_wifi_connect：esp8266上网操作
 * return		成功返回ESP8266_OK，正在握手返回0，错误返回ESP8266_ERROR */
int bsp_esp8266_wifi_connect
	(
	void
	)
{
	static unsigned char state = 0;
	static unsigned char error_times = 0;
	
	char tmp_buf[1024];

	switch (state)
	{
		case 0x00:
			/* 关闭回显 */
			if (bsp_esp8266_at_cmd("ATE0\r\n", 500) == 1)
			{
				if (bsp_esp8266_keyword_matching("OK") == 1)
				{
					state++;
					error_times = 0;
					printf("esp8266: %s ==> OK\r\n", "ATE0");
				}
				else
				{
					if (++error_times > 3)
					{
						state = ESP8266_ERROR;
						printf("esp8266: %s ==> ERROR\r\n", "ATE0");
					}
				}
			}
			break;
		
		case 0x01:
			/* 设置esp8266为station模式 */
			if (bsp_esp8266_at_cmd("AT+CWMODE=1,0\r\n", 500) == 1)
			{
				if (bsp_esp8266_keyword_matching("OK") == 1)
				{
					state++;
					error_times = 0;
					printf("esp8266: %s ==> OK\r\n", "AT+CWMODE=1,0");
				}
				else
				{
					if (++error_times > 3)
					{
						state = ESP8266_ERROR;
						printf("esp8266: %s ==> ERROR\r\n", "AT+CWMODE=1,0");
					}
				}
			}
			break;
			
		case 0x02:
			/* 连接wifi */
			sprintf(tmp_buf, "AT+CWJAP=\"%s\",\"%s\"\r\n", esp8266_wifi_name, esp8266_wifi_password);
			if (bsp_esp8266_at_cmd(tmp_buf, 4000) == 1)
			{
				if (bsp_esp8266_keyword_matching("OK") == 1)
				{
					state = ESP8266_OK;
					error_times = 0;
					printf("esp8266: %s ==> OK\r\n", "AT+CWJAP");
				}
				else
				{
					if (++error_times > 3)
					{
						state = ESP8266_ERROR;
						printf("esp8266: %s ==> ERROR\r\n", "AT+CWJAP");
					}
				}
			}
			break;
			
		case ESP8266_ERROR:
			state = 0x00;
			error_times = 0;
			return ESP8266_ERROR;
		
		case ESP8266_OK:
			state = 0x00;
			return ESP8266_OK;
	}
	
	return 0;
}


/* bsp_esp8266_mqtt_init：esp8266 mqtt通信初始化操作
 * return		成功返回ESP8266_OK，正在握手返回0，错误返回ESP8266_ERROR */
int bsp_esp8266_mqtt_init
	(
	void
	)
{
	static unsigned char state = 0;
	static unsigned char error_times = 0;
	
	char tmp_buf[1024];
	
	switch (state)
	{
		case 0x00:
			/* 设置esp8266 mqtt用户属性 */
			sprintf(tmp_buf, "AT+MQTTUSERCFG=0,1,\"%s\",\"%s\",\"%s\",0,0,\"\"\r\n", MQTT_USER_ID, MQTT_USER_NAME, MQTT_USER_PASSWORD);
			if (bsp_esp8266_at_cmd(tmp_buf, 1000) == 1)
			{
				if (bsp_esp8266_keyword_matching("OK") == 1)
				{
					state++;
					error_times = 0;
					printf("esp8266: %s ==> OK\r\n", "AT+MQTTUSERCFG");
				}
				else
				{
					printf("esp8266: %s ==> ERROR\r\n", "AT+MQTTUSERCFG");
					if (++error_times > 3)
					{
						state = ESP8266_ERROR;
					}
				}
			}
			break;
		
		case 0x01:
			/* 连接mqtt服务器 */
			sprintf(tmp_buf, "AT+MQTTCONN=0,\"%s\",%s,0\r\n", mqtt_broker_ip, mqtt_broker_port);
			if (bsp_esp8266_at_cmd(tmp_buf, 2000) == 1)
			{
				if (bsp_esp8266_keyword_matching("OK") == 1)
				{
					state++;
					error_times = 0;
					printf("esp8266: %s ==> OK\r\n", "AT+MQTTCONN");
				}
				else
				{
					printf("esp8266: %s ==> ERROR\r\n", "AT+MQTTCONN");
					if (++error_times > 3)
					{
						state = ESP8266_ERROR;
					}
				}
			}
			break;
			
		case 0x02:
			/* 订阅mqtt主题 */
			sprintf(tmp_buf, "AT+MQTTSUB=0,\"%s\",0\r\n", MQTT_SUBSCRIBE_TOPIC);
			if (bsp_esp8266_at_cmd(tmp_buf, 1000) == 1)
			{
				if (bsp_esp8266_keyword_matching("OK") == 1)
				{
					state = ESP8266_OK;
					error_times = 0;
					printf("esp8266: %s ==> OK\r\n", "AT+MQTTSUB");
				}
				else
				{
					if (++error_times > 3)
					{
						state = ESP8266_ERROR;
						printf("esp8266: %s ==> ERROR\r\n", "AT+MQTTSUB");
					}
				}
			}
			break;
		
		case ESP8266_ERROR:
			state = 0x00;
			error_times = 0;
			return ESP8266_ERROR;
		
		case ESP8266_OK:
			state = 0x00;
			return ESP8266_OK;
		
	}
	
	return 0;
}


/* bsp_esp8266_communication：esp8266 mqtt通信操作
 * send_time_interval	循环发送mqtt消息的时间间隔	
 * return 				成功返回ESP8266_OK，正在握手返回0，错误返回ESP8266_ERROR */
int bsp_esp8266_communication
	(
	unsigned int send_time_interval
	)
{
	static unsigned char state = 0x00;
	static unsigned char error_times = 0;
	static unsigned char recive_enable_flag = 1;
	
	static char *recive_topic;
	static int recive_data_len = 0;
	
	static char tmp_buf[512] = "AT+MQTTPUB=0,\"hello\",\"hello world\",1,0\r\n";
	static char tmp_buf_2[256] = "";
	
	static unsigned int count = 0;
	
	switch (state)
	{
		/* 发送消息 */
		case 0x00:
			state++;
		
			if (bsp_soft_timer_state_get(WIFI_SOFT_TIMER_ID) == SOFT_TIMER_STOPPED)
			{
				bsp_soft_timer_start(WIFI_SOFT_TIMER_ID, SOFT_TIMER_MODE_ONE_SHOT, send_time_interval, bsp_soft_timer_nop_callback, NULL, 0);
				
				sprintf(esp8266_publish_data, "count: %d", count++);
				sprintf(tmp_buf, "AT+MQTTPUB=0,\"%s\",\"%s\",1,0\r\n", MQTT_PUBLISH_TOPIC, esp8266_publish_data);
				HAL_UART_Transmit(&WIFI_HUART, (const unsigned char*)tmp_buf, (unsigned short int)strlen(tmp_buf), send_time_interval);
				HAL_UART_Transmit(&DEBUG_HUART, (const unsigned char*)tmp_buf, (unsigned short int)strlen(tmp_buf), 1000);
			
				bsp_soft_timer_start(WIFI_SOFT_TIMER_ID_2, SOFT_TIMER_MODE_ONE_SHOT, 50, bsp_soft_timer_nop_callback, NULL, 0);
				recive_enable_flag = 0;
			}
			
			if (bsp_soft_timer_state_get(WIFI_SOFT_TIMER_ID_2) == SOFT_TIMER_TIMEOUT)
			{				
				if (bsp_esp8266_keyword_matching("OK") == 1)
				{
					error_times = 0;
					printf("esp8266: %s ==> OK\r\n", "AT+MQTTPUB");
				}
				else
				{
					printf("esp8266: %s ==> ERROR\r\n", "AT+MQTTPUB");
					if (++error_times > 3)
					{
						state = ESP8266_ERROR;
					}
				}
				
				recive_enable_flag = 1;
			}
			break;
		
		/* 接收消息 */
		case 0x01:
			state--;
		
			if (recive_enable_flag == 1)
			{
				recive_len = bsp_usart_get(recive_buf, WIFI_BSP_HUART);
				if (recive_len != -1)
				{	
					recive_topic = strstr((const char*)recive_buf, MQTT_SUBSCRIBE_TOPIC);
					if (recive_topic == NULL)
					{
						printf("esp8266: %s ==> ERROR\r\n", "json parse_1");
						return 0;
					}
					sscanf((const char*)recive_topic + strlen(MQTT_SUBSCRIBE_TOPIC) + 2, "%d,%s", &recive_data_len, tmp_buf_2);
					
					cjson_test = cJSON_Parse((const char*)tmp_buf_2);
					if(cjson_test == NULL)
					{
						HAL_UART_Transmit(&DEBUG_HUART, recive_buf, recive_len, 1000);
						printf("esp8266: %s ==> ERROR\r\n", "json parse_2");
						return 0;
					}
					
					cjson_name = cJSON_GetObjectItem(cjson_test, "name");
					cjson_age  = cJSON_GetObjectItem(cjson_test, "age");
					
					printf("name: %s\r\n", cjson_name->valuestring);
					printf("age: %d\r\n", cjson_age->valueint);
				}
			}
			/* 软件定时器的状态刷新时，会遇到的bug，所以这里这样设计 */
			else
			{
				if (bsp_soft_timer_state_get(WIFI_SOFT_TIMER_ID_2) == SOFT_TIMER_TIMEOUT)
				{
					if (bsp_esp8266_keyword_matching("OK") == 1)
					{
						error_times = 0;
						printf("esp8266: %s ==> OK\r\n", "AT+MQTTPUB");
					}
					else
					{
						printf("esp8266: %s ==> ERROR\r\n", "AT+MQTTPUB");
						if (++error_times > 3)
						{
							state = ESP8266_ERROR;
						}
					}
					
					recive_enable_flag = 1;
				}
			}
			break;
		
		case ESP8266_ERROR:
			error_times = 0;
			state = 0x00;
			return ESP8266_ERROR;
	}
	
	return 0;
}


/* bsp_esp8266_work：esp8266工作函数
 * return 		返回esp8266当前工作状态 */
int bsp_esp8266_work
	(
	void
	)
{	
	int ret = 0;
	
	switch (esp8266_state)
	{
		/* 复位 */
		case ESP8266_RESET:
			if (bsp_esp8266_reset() == 1)		
			{
				esp8266_state = ESP8266_SHAKE_HANDS;
				recive_len = bsp_usart_get(recive_buf, WIFI_BSP_HUART);
				if (recive_len != -1)
				{	
					HAL_UART_Transmit(&DEBUG_HUART, recive_buf, recive_len, 1000);
					recive_buf[recive_len] = '\0';
				}
				printf("esp8266: %s  ==> OK\r\n", "ESP8266_RESET");
			}
			break;
			
		/* 握手 */
		case ESP8266_SHAKE_HANDS:
			ret = bsp_esp8266_shake_hands();
			if (ret == ESP8266_OK)
			{
				esp8266_state = ESP8266_WIFI_CONNECT;
			}
			else if (ret == ESP8266_ERROR)
			{		
				esp8266_state = ESP8266_ERROR;
			}
			break;
		
		/* 上网 */
		case ESP8266_WIFI_CONNECT:
			ret = bsp_esp8266_wifi_connect();
			if (ret == ESP8266_OK)
			{
				esp8266_state = ESP8266_MQTT_INIT;
			}
			else if (ret == ESP8266_ERROR)
			{		
				esp8266_state = ESP8266_ERROR;
			}
			break;
			
		/* mqtt通信初始化 */
		case ESP8266_MQTT_INIT:
			ret = bsp_esp8266_mqtt_init();
			if (ret == ESP8266_OK)
			{
				esp8266_state = ESP8266_COMMUNICATION;
			}
			else if (ret == ESP8266_ERROR)
			{		
				esp8266_state = ESP8266_ERROR;
			}
			break;
		/* mqtt通信 */
		case ESP8266_COMMUNICATION:
			ret = bsp_esp8266_communication(3000);
			if (ret == ESP8266_ERROR)
			{
				esp8266_state = ESP8266_ERROR;
			}
			break;
		
		/* 错误跳转到复位 */
		case ESP8266_ERROR:
			esp8266_state = ESP8266_RESET;
			break;
		
		default:
			break;
	}
	
	return esp8266_state;
}


/* bsp_esp8266_wifi_disposition_set：esp8266设置连接WiFi名称及密码函数
 * name 			wifi名称
 * len_name			wifi名称长度 
 * password			wifi密码
 * len_password		wifi密码长度 */
int bsp_esp8266_wifi_disposition_set
	(
	char 			name[],
	unsigned int 	len_name,
	char 			password[],
	unsigned int 	len_password
	)
{
	memset(esp8266_wifi_name, '\0', 48);
	memset(esp8266_wifi_password, '\0', 48);
	strncpy(esp8266_wifi_name, name, len_name); 
	strncpy(esp8266_wifi_password, password, len_password); 
	
	esp8266_state = ESP8266_RESET;
	
	return 0;
}


/* bsp_esp8266_broker_disposition_set：esp8266设置连接mqtt服务器ip及端口函数
 * ip 			mqtt服务器ip
 * len_ip		mqtt服务器ip长度 
 * port			mqtt服务器端口
 * len_port		mqtt服务器端口长度 */
int bsp_esp8266_broker_disposition_set
	(
	char 			ip[],
	unsigned int 	len_ip,
	char 			port[],
	unsigned int 	len_port
	)
{
	memset(mqtt_broker_ip, '\0', 16);
	memset(mqtt_broker_port, '\0', 8);
	strncpy(mqtt_broker_ip, ip, len_ip); 
	strncpy(mqtt_broker_port, port, len_port); 
	
	esp8266_state = ESP8266_RESET;
	
	return 0;
}


/* bsp_esp8266_publish_data_set：esp8266设置发送的mqtt消息函数
 * data 		mqtt消息
 * len_data		mqtt消息长度 */
int bsp_esp8266_publish_data_set
	(
	char 			data[],
	unsigned int 	len_data
	)
{
	memset(esp8266_publish_data, '\0', 256);
	strncpy(esp8266_publish_data, data, len_data); 
	
	return 0;
}
临木木
关注
  • 5
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【物联网】手把手完整实现STM32+ESP8266+MQTT+阿里云+APP应用——第1节-阿里云配置+MQTT.fx模拟与使用AT命令发布订阅消息
阿齐Archie
12-27 4万+
本节完成了阿里云平台配置与绘制IOT Studio界面，且完成了MQTT.fx测试阿里云物联网平台与ESP8266发布订阅消息，且完成了使用AT命令的方式实现阿里云物联网平台与esp8266发布订阅消息。
STM32+ESP8266+MQTT协议连接阿里云物联网平台
热门推荐
07-13 5万+
一、环境介绍 单片机采用：STM32F103C8T6 上网方式：采用ESP8266，也可以使用其他设备代替，只要支持TCP协议即可。比如：GSM模块、有线网卡等。 开发软件：keil5 二、实现功能 通过阿里云物联网服务器实现设备数据远程上传、下发，实现数据交互。 在当前使用的开发板上有4盏LED灯、一个蜂鸣器、4个按键。 三、阿里云物联网服务器创建步骤 说明：如果没有账号的话，先点击网页右上角，注册一个账号，并完成实名认证再继续下一步。 产品名称根据自己情况填...
STM32通过ESP8266连接MQTT服务器
qq_43819071的博客
08-08 5374
ESP8266有多种连接MQTT方式，本文介绍使用的是AT MQTT版本固件的ESP01s，基于此固件版本进行说明。本文所需硬件：STM32F103RCT6、LED、ESP01s、DHT11，实现功能：温湿度上传和远程开关灯的基本功能。
MQTT+ESP8266实现STM32数据上传
weixin_57669614的博客
12-02 8621
MATT协议来上传数据
最新！基于stm32+esp8266+mqtt连接最新版onenet云平台（非旧版本多协议接入）HAL库开发版本 文末附代码
m0_60853221的博客
04-25 4935
基于stm32+esp8266+mqtt连接最新版onenet云平台（非旧版本多协议接入）HAL库开发版本 文末附代码
【HAL库】STM32+ESP8266+Onenet+MQTT，极简工程，hal库移植。
xifan的博客
04-08 4188
从标准库移到了HAL库，过程有点麻烦，整了一天。做完后整理了一下，这个极简的工程，方便以后开发，也希望能帮助大家，节约时间。接收部分：用串口中断接收esp8266发来的消息。随便在哪个文件夹填加串口回调函数，我个人是之前专门建了个uart.c文件放串口相关的所有代码。发送部分：在esp8266.c里，将huart3全部替换为要修改的串口号，比如串口2。串口1用于调试，串口3用于ESP8266通信，打开中断。外设：串口1用作调试，串口3用作esp8266。基础的我就不配置了，可以看前面的详细讲解。
【物联网】手把手完整实现STM32+ESP8266+MQTT+阿里云+APP应用——第2节-编写STM32程序初步实现ESP8266上云与发布订阅消息
阿齐Archie
01-04 3万+
本节实现，硬件连接STM32与ESP8266，编写STM32程序通过at命令方式实现STM32+ESP8266与阿里云物联网平台发布订阅消息，本节最终实现初步的发布订阅消息（能够发布消息给阿里云物联网平台但无外设数据，能够订阅阿里云物联网平台发送的消息来开关LED灯）。
esp8266教程：esp8266使用mqtt连接百度智能云
qq_27809619的博客
05-07 3687
一、mqtt介绍 1.1、什么是mqtt？ MQTT（Message Queuing Telemetry Transport，消息队列遥测传输协议）由IBM在1999年发布。可以简单理解为给应用层使用的一种传输协议比如我们常见的http、tftp等，为什么会有多种传输协议，就是为了满足不同的使用场景，比如http是一种超文本协议，主要是运用在网页，文件传输上，如果要使用这种协议，需要比较大的数据量传输。但是我们的iot设备不需要传输那么多的数据量，而且http协议不能通过服务端发起传输到客户端，只能客户端发
STM32+ESP8266连接阿里云
Actkeying的博客
07-04 977
当使用STM32微控制器连接到阿里云时，通过宏定义可以显著提升代码的可读性和灵活性。在开始配置和编写代码之前，通常会定义一些初始宏来简化代码的编写和调试过程。//WIFI配置//阿里云证书配置//阿里云域名配置//数据下行//数据上行//上行数据。
STM32+ESP8266+MQTT+阿里云 （嵌入式开发 ）
07-06
在嵌入式开发领域，将STM32微控制器与ESP8266 WiFi模块结合，利用MQTT消息传输协议，并接入阿里云物联网平台，可以构建一个高效、可靠的远程监控和控制系统。以下是对这些关键技术和组件的详细说明： 1. STM32（意...
STM32F407+ESP8266+阿里云 阿里云mqtt固件库
11-10
1. **硬件连接**：STM32F407通过UART接口与ESP8266建立通信，需要配置正确的波特率、数据位、停止位和校验位。 2. **固件烧录**：STM32F407需要烧录包含MQTT库的固件，而ESP8266则需要烧录对应的Wi-Fi连接和AT指令...
STM32F407+ESP8266+机智云
11-10
- 软件配置：编写STM32和ESP8266的驱动程序，调试通信过程。 - 云端对接：按照机智云的开发者指南，完成设备接入和数据交互的代码编写。 - 测试验证：测试设备的连网能力，数据上传与下载的可靠性，以及远程控制...
通过MQTT协议实现STM32+ESP8266和服务器的数据传输.zip
10-17
要实现STM32和ESP8266之间的MQTT通信，首先需要在STM32端配置MQTT客户端库。在提供的"MQTT—stm32"文件中，可能包含了配置MQTT参数的代码，如服务器地址、端口、主题等。当这些参数正确设置后，STM32可以连接到...
【STM32系统】基于STM32设计的按键PWM控制舵机窗帘&柜子&门禁&家居等控制系统——文末资料下载
阿齐Archie
08-04 2000
设计并实现了一种基于STM32单片机的按键PWM控制舵机系统。通过按键可以精确控制舵机角度，实现对窗帘、柜子、门禁等家居设备的智能化控制。系统采用STM32F10x系列单片机，结合OLED显示屏和按键模块，实现了角度的实时显示与调整。本文详细介绍了系统的硬件设计、软件实现以及功能测试结果。
STM32CubleMX创建FreeRtos工程教程，图文教程
weixin_62292999的博客
08-08 589
指 CMSIS-RTOS 的第二个版本，它在 V1 的基础上进行了改进和扩展，增强了兼容性和功能性，更适合现代嵌入式开发需求。，也就是抵达定时器，Hal库的也默认是 SysTick ，为了防止会产生冲突，这里将Hal库的时基单元选择为TIM4。这里配置一下工程，选择开发平台，这里本人使用Keil5进行开发，不同的开发软件选择不同的选向就好了。这里时基单元的选择，这里选择为TIM4，FreeRtos操作系统的时基单元默认是，也就是选择不同封装FreeRtos的版本，进行开发，建议选择V2，功能较为完善。
学习STM32（5）--STM32单片机串口通信的应用
weixin_73690807的博客
08-07 1060
学习stm32第五篇
【STM32】DMA数据转运（存储器到存储器）
最新发布
m0_75090944的博客
08-09 962
DMA实现存储器到存储器代码框架与讲解
stm32f103zet6 esp8266 mqtt
03-16
STM32F103ZET6是一款基于ARM Cortex-M3内核的微控制器，具有丰富的外设和高性能。ESP8266是一款低成本、低功耗的Wi-Fi模块，可用于连接互联网。MQTT是一种轻量级的消息传输协议，常用于物联网设备之间的通信。在使用STM32F103ZET6和ESP8266进行物联网开发时，可以使用MQTT协议进行设备之间的通信。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值