既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新
2.3.1 ONENET MQTT服务器地址
mqtts.heclouds.com 1883
2.3.2 clientld、username、password
更加详细的介绍如下图：
2.3.3 password 获取方法
连接除了clientld、username，还需要password 。 ONENET的 password 需要使用费 token 算法 获取：
ONENET token 算法说明
ONENET token工具下载
1、products/产品ID/devices/设备名称
2、时间戳
通过这个的工具获取： 在线 时间戳转换工具
填入工具之中：
3、key
4、生成密码
通过 MQTT.fx 配置连接云平台，按照如下配置进行设置：
配置完成以后，点击connect，在ONENET上可以看到设备在线状态：
2.4 订阅Topic
ONENET平台 与设备 Topic 的约定，不能随意的定义自己的Topic，有对应的规定:
有如下一些Topic：
比如，我们订阅一个上报结果，类似如图所示：
2.5 发送数据至云平台
我们上面完成了数据上报结果订阅，那么有关于任何数据点上报的结果，我们都能收到消息，我们使用工具来尝试一下给平台发送数据：
在 MQTT.fx 中，数据格式使用 Json 格式发送：
点击发布，我们可以通过订阅的消息看到消息已经发送，在云平台也能看到数据上报成功：
2.6 云平台下发命令
接收平台下发的命令，就是订阅设备所有命令相关消息：
在云平台点击下发命令，如下图，然后写入cmd，在MQTT.fx 中我们订阅过消息，所以能够收到命令：
测试完成，到时候我们将会使用这个命令来控制板子上的RGB灯。
三、整体调整测试
3.1 结合平台的基本调整
在前面其实有提到过 topic 的说明，设备发布消息到非法topic ，平台会断开设备连接：
所以在整体修改的过程中需要注意，不要有其他的无用的测试Topic 。
在前面修改完成的整体程序框架中，根据平台的测试结果，修改一些必要的地方：
一些基本的定义：
MQTT配置部分代码：
周期上报的逻辑：
3.2 .url 和 .host
在此期间测试有一个问题：
实际上这里有个概念没有搞清楚：
此处的内容可参考博文：网址（url），域名，ip地址，dns，hosts之间的关系
3.3 周期上报效果
最终测试结果，周期上报板子上传感器数值，在云平台可以看到周期上报的结果：
3.4 下行命令处理（RMT应用）
下行命令处理，我们这里是基于订阅了云平台的 CMD 命令，但是对于这个下行的命令，目前看到也并没有一个标准的格式指定。这里目的是为了演示，所以我们怎么简单怎么来。
我们自己把下行需要处理的命令格式定位： mycmd：XXXXX。
比如：mycmd：ledred mycmd：ledblue。
这样，我们通过接受到的消息经常简单的数据处理以后，做出对应的动作。
（具体的执行可参考源码）
测试结果， 切换成蓝灯：
测试结果，切换成红灯：
附录（源码）
这里上一下app_main.c文件源码，其实只要看过我的教学博文，下面这个文件的代码都是有分析说明的，包括本文上面也对每个部分的功能有单独说明。整个应用工程的代码，我上传到了资源：
app_main.c：
/\* MQTT (over TCP) Example
This example code is in the Public Domain (or CC0 licensed, at your option.)
Unless required by applicable law or agreed to in writing, this
software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied.
\*/
#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include "esp\_wifi.h"
#include "esp\_system.h"
#include "nvs\_flash.h"
#include "esp\_event.h"
#include "esp\_netif.h"
#include "protocol\_examples\_common.h"
/\*
smartconfig
\*/
#include "esp\_smartconfig.h"
#include "freertos/event\_groups.h"
// #include "esp\_wpa2.h"
/\*
定时器
\*/
#include "driver/timer.h"
/\*
ADC
\*/
#include "driver/adc.h"
#include "driver/gpio.h"
/\*
I2C
\*/
#include "sht21.h"
/\*
button
\*/
#include "my\_button.h"
/\*
RMT
\*/
#include "driver/rmt.h"
#include "led\_strip.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "freertos/queue.h"
#include "lwip/sockets.h"
#include "lwip/dns.h"
#include "lwip/netdb.h"
#include "esp\_log.h"
#include "mqtt\_client.h"
#define TIMER\_SCALE (TIMER\_BASE\_CLK / 16) // convert counter value to seconds
#define ONENET\_MqttServer "mqtts.heclouds.com"
#define ONENET\_clientld "esp32-device1" //name
#define ONENET\_UserName "493136" //ID
#define ONENET\_Password "version=2018-10-31&res=products%2F493136%2Fdevices%2Fesp32-device1&et=1741490120&method=md5&sign=wscxn0OWnKxbxQ7mae3CLQ%3D%3D"
//设备上传数据的post主题
#define ONENET\_TOPIC\_PROP\_POST "$sys/" ONENET\_UserName "/" ONENET\_clientld "/dp/post/json"
#define ONENET\_TOPIC\_DP\_Publish "$sys/493136/esp32-device1/dp/post/json"
#define ONENET\_TOPIC\_DP\_Sub "$sys/493136/esp32-device1/dp/post/json/+"
#define ONENET\_TOPIC\_CMD\_Sub "$sys/493136/esp32-device1/cmd/#"
//这是post上传数据使用的模板
#define ONENET\_POST\_BODY\_FORMAT "{\"id\":123,\"dp\":%s}"
static EventGroupHandle_t s_wifi_event_group;
static const int CONNECTED_BIT = BIT0;
static const int ESPTOUCH_DONE_BIT = BIT1;
static const char \*TAG = "MQTT";
static const char \*TAG2 = "smartconfig";
// static EventGroupHandle\_t s\_cmd\_event\_group;
static const int RED_BIT = BIT3;
static const int BLUE_BIT = BIT4;
bool send_cycle = false;
typedef struct {
int timer_group;
int timer_idx;
int alarm_interval;
bool auto_reload;
} example\_timer\_info\_t;
#define RMT\_TX\_NUM 8 //WS2812 control pin
#define RMT\_TX\_CHANNEL RMT\_CHANNEL\_0
#define EXAMPLE\_CHASE\_SPEED\_MS (10)
#define LED\_STRIP\_NUM 1
#define COLOR\_RED 9
#define COLOR\_GREE 8
#define COLOR\_BULE 10
#define COLOR\_PURPLE 11
#define COLOR\_ORANGE 12
#define Lamp\_Open 13
#define lamp\_close 14
#define lamp\_speed\_Up 15
#define lamp\_speed\_down 16
#define ligth\_down 18
#define ligth\_up 19
struct WS2812\_COLOR
{
uint8\_t lamp;
uint8\_t ligth_rank;
uint8\_t lamp_speed;
uint32\_t red;
uint32\_t green;
uint32\_t blue;
};
static led\_strip\_t \*strip;
struct WS2812\_COLOR WS2812_RGB;
/\*\*
\* @brief A sample structure to pass events from the timer ISR to task
\*
\*/
typedef struct {
example\_timer\_info\_t info;
uint64\_t timer_counter_value;
} example\_timer\_event\_t;
static void smartconfig\_example\_task(void \* parm);
static void led\_cmd\_task(void \* parm);
void RGB16for10(struct WS2812\_COLOR \*RGB, uint32\_t reb_16)
{
uint32\_t rgb_16 = reb_16;
RGB->blue = rgb_16 & 0Xff;
rgb_16 = rgb_16 >> 8;
RGB->green = rgb_16 & 0xff;
rgb_16 = rgb_16 >> 8;
RGB->red = rgb_16 & 0xff;
}
void set\_rgb(uint32\_t rgb_24bit, uint8\_t ligth_rank)
{
RGB16for10(&WS2812_RGB, rgb_24bit);
ligth_rank = 21 - ligth_rank;
for (int i = 0; i < LED_STRIP_NUM; i++)
{
strip->set\_pixel(strip, i, WS2812_RGB.red / ligth_rank, WS2812_RGB.green / ligth_rank, WS2812_RGB.blue / ligth_rank);
}
strip->refresh(strip, 10);
}
void init\_led()
{
rmt\_config\_t config = RMT\_DEFAULT\_CONFIG\_TX(RMT_TX_NUM, RMT_TX_CHANNEL);
// set counter clock to 40MHz
config.clk_div = 2;
ESP\_ERROR\_CHECK(rmt\_config(&config));
ESP\_ERROR\_CHECK(rmt\_driver\_install(config.channel, 0, 0));
// install ws2812 driver
led\_strip\_config\_t strip_config = LED\_STRIP\_DEFAULT\_CONFIG(1, (led\_strip\_dev\_t)config.channel);
strip = led\_strip\_new\_rmt\_ws2812(&strip_config);
if (!strip)
{
ESP\_LOGE(TAG, "install WS2812 driver failed");
}
// Clear LED strip (turn off all LEDs)
ESP\_ERROR\_CHECK(strip->clear(strip, 100));
}
static void log\_error\_if\_nonzero(const char \* message, int error_code)
{
if (error_code != 0) {
ESP\_LOGE(TAG, "Last error %s: 0x%x", message, error_code);
}
}
static int single\_read(void \*arg)
{
int adc1_reading[1] = {0};
adc1_reading[0] = adc1\_get\_raw(ADC1_CHANNEL_0);
// vout = (adc1\_reading[0] \* 2500.00)/4095.00;
// ESP\_LOGI(TAG\_CH[0], "%x vout mv is %f", adc1\_reading[0],vout);
return adc1_reading[0];
}
static bool IRAM_ATTR system\_timer\_callback(void\* arg)
{
BaseType_t high_task_awoken = pdFALSE;
send_cycle = true;
return high_task_awoken == pdTRUE; // return whether we need to yield at the end of ISR
}
static void event\_handler(void\* arg, esp\_event\_base\_t event_base,
int32\_t event_id, void\* event_data)
{
if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
xTaskCreate(smartconfig_example_task, "smartconfig\_example\_task", 4096, NULL, 3, NULL);
} else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
esp\_wifi\_connect();
xEventGroupClearBits(s_wifi_event_group, CONNECTED_BIT);
} else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
xEventGroupSetBits(s_wifi_event_group, CONNECTED_BIT);
} else if (event_base == SC_EVENT && event_id == SC_EVENT_SCAN_DONE) {
ESP\_LOGI(TAG2, "Scan done");
} else if (event_base == SC_EVENT && event_id == SC_EVENT_FOUND_CHANNEL) {
ESP\_LOGI(TAG2, "Found channel");
} else if (event_base == SC_EVENT && event_id == SC_EVENT_GOT_SSID_PSWD) {
ESP\_LOGI(TAG2, "Got SSID and password");
smartconfig\_event\_got\_ssid\_pswd\_t \*evt = (smartconfig\_event\_got\_ssid\_pswd\_t \*)event_data;
wifi\_config\_t wifi_config;
uint8\_t ssid[33] = { 0 };
uint8\_t password[65] = { 0 };
uint8\_t rvd_data[33] = { 0 };
bzero(&wifi_config, sizeof(wifi\_config\_t));
memcpy(wifi_config.sta.ssid, evt->ssid, sizeof(wifi_config.sta.ssid));
memcpy(wifi_config.sta.password, evt->password, sizeof(wifi_config.sta.password));
wifi_config.sta.bssid_set = evt->bssid_set;
if (wifi_config.sta.bssid_set == true) {
memcpy(wifi_config.sta.bssid, evt->bssid, sizeof(wifi_config.sta.bssid));
}
memcpy(ssid, evt->ssid, sizeof(evt->ssid));
memcpy(password, evt->password, sizeof(evt->password));
ESP\_LOGI(TAG2, "SSID:%s", ssid);
ESP\_LOGI(TAG2, "PASSWORD:%s", password);
if (evt->type == SC_TYPE_ESPTOUCH_V2) {
ESP\_ERROR\_CHECK( esp\_smartconfig\_get\_rvd\_data(rvd_data, sizeof(rvd_data)) );
ESP\_LOGI(TAG2, "RVD\_DATA:");
for (int i=0; i<33; i++) {
printf("%02x ", rvd_data[i]);
}
printf("\n");
}
ESP\_ERROR\_CHECK( esp\_wifi\_disconnect() );
ESP\_ERROR\_CHECK( esp\_wifi\_set\_config(WIFI_IF_STA, &wifi_config) );
printf("ready to connect!\r\n");
esp\_wifi\_connect();
} else if (event_base == SC_EVENT && event_id == SC_EVENT_SEND_ACK_DONE) {
xEventGroupSetBits(s_wifi_event_group, ESPTOUCH_DONE_BIT);
}
}
static esp\_err\_t mqtt\_event\_handler\_cb(esp\_mqtt\_event\_handle\_t event)
{
esp\_mqtt\_client\_handle\_t client = event->client;
int msg_id;
char cmdbuf[20];
// your\_context\_t \*context = event->context;
switch (event->event_id) {
case MQTT_EVENT_CONNECTED:
ESP\_LOGI(TAG, "MQTT\_EVENT\_CONNECTED");
// msg\_id = esp\_mqtt\_client\_publish(client, "/topic/qos1", "data\_3", 0, 1, 0);
// ESP\_LOGI(TAG, "sent publish successful, msg\_id=%d", msg\_id);
msg_id = esp\_mqtt\_client\_subscribe(client, ONENET_TOPIC_DP_Sub, 0);
ESP\_LOGI(TAG, "sent subscribe successful, msg\_id=%d", msg_id);
msg_id = esp\_mqtt\_client\_subscribe(client, ONENET_TOPIC_CMD_Sub, 1);
ESP\_LOGI(TAG, "sent subscribe successful, msg\_id=%d", msg_id);
// msg\_id = esp\_mqtt\_client\_unsubscribe(client, "/topic/qos1");
// ESP\_LOGI(TAG, "sent unsubscribe successful, msg\_id=%d", msg\_id);
break;
case MQTT_EVENT_DISCONNECTED:
ESP\_LOGI(TAG, "MQTT\_EVENT\_DISCONNECTED");
// esp\_mqtt\_client\_start(client);
break;
case MQTT_EVENT_SUBSCRIBED:
ESP\_LOGI(TAG, "MQTT\_EVENT\_SUBSCRIBED, msg\_id=%d", event->msg_id);
// msg\_id = esp\_mqtt\_client\_publish(client, "/topic/qos0", "data", 0, 0, 0);
// ESP\_LOGI(TAG, "sent publish successful, msg\_id=%d", msg\_id);
break;
case MQTT_EVENT_UNSUBSCRIBED:
ESP\_LOGI(TAG, "MQTT\_EVENT\_UNSUBSCRIBED, msg\_id=%d", event->msg_id);
break;
case MQTT_EVENT_PUBLISHED:
ESP\_LOGI(TAG, "MQTT\_EVENT\_PUBLISHED, msg\_id=%d", event->msg_id);
break;
case MQTT_EVENT_DATA:
ESP\_LOGI(TAG, "MQTT\_EVENT\_DATA");
printf("TOPIC=%.\*s\r\n", event->topic_len, event->topic);
printf("DATA=%.\*s\r\n", event->data_len, event->data);
sprintf(cmdbuf,"%.\*s",event->data_len,event->data);
if(strstr(cmdbuf, "：ledred")){
xEventGroupSetBits(s_wifi_event_group, RED_BIT);
}
else if(strstr(cmdbuf, "：ledblue")){
xEventGroupSetBits(s_wifi_event_group, BLUE_BIT);
}
break;
case MQTT_EVENT_ERROR:
ESP\_LOGI(TAG, "MQTT\_EVENT\_ERROR");
if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {
log\_error\_if\_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err);
log\_error\_if\_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err);
log\_error\_if\_nonzero("captured as transport's socket errno", event->error_handle->esp_transport_sock_errno);
ESP\_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno));
}
break;
default:
ESP\_LOGI(TAG, "Other event id:%d", event->event_id);
break;
}
return ESP_OK;
}
static void mqtt\_event\_handler(void \*handler_args, esp\_event\_base\_t base, int32\_t event_id, void \*event_data) {
ESP\_LOGD(TAG, "Event dispatched from event loop base=%s, event\_id=%d", base, event_id);
mqtt\_event\_handler\_cb(event_data);
}
static void mqtt\_app\_start(void)
{
int msg_id;
int adc_value;
float adc_mv;
/\* ADC \*/
adc1\_config\_width(ADC_WIDTH_BIT_DEFAULT);
adc1\_config\_channel\_atten(ADC1_CHANNEL_0, ADC_ATTEN_DB_11);
/\* \*/
esp\_mqtt\_client\_config\_t mqtt_cfg = {
// .uri = ONENET\_MqttServer,
.host = "mqtts.heclouds.com",
// .uri = "mqtt://broker.emqx.io",
.client_id = ONENET_clientld,
.username = ONENET_UserName,
.password = ONENET_Password,
.port = 1883,
};
#if CONFIG\_BROKER\_URL\_FROM\_STDIN
char line[128];
if (strcmp(mqtt_cfg.uri, "FROM\_STDIN") == 0) {
int count = 0;
printf("Please enter url of mqtt broker\n");
while (count < 128) {
int c = fgetc(stdin);
if (c == '\n') {
line[count] = '\0';
break;
} else if (c > 0 && c < 127) {
line[count] = c;
++count;
}
vTaskDelay(10 / portTICK_PERIOD_MS);
}
mqtt_cfg.uri = line;
printf("Broker url: %s\n", line);
} else {
ESP\_LOGE(TAG, "Configuration mismatch: wrong broker url");
abort();
}
#endif /\* CONFIG\_BROKER\_URL\_FROM\_STDIN \*/
esp\_mqtt\_client\_handle\_t client = esp\_mqtt\_client\_init(&mqtt_cfg);
esp\_mqtt\_client\_register\_event(client, ESP_EVENT_ANY_ID, mqtt_event_handler, client);
esp\_mqtt\_client\_start(client);
// char \*adc\_head ="my adc value is:";
// char \*adc\_tail ="mv";
// char adc\_publish[25] = {0};
// int thread;
float T,H;
char jsonBuf[100];
char databuf[80];
while (1)
{
if(send_cycle){
send_cycle = false;
adc_value = single\_read(NULL);
adc_mv = (adc_value \* 2500.00)/4095.00;
SHT2X\_THMeasure(I2C_MASTER_NUM);
// if(thread == ESP\_ERR\_TIMEOUT){}
// else{
T =(getTemperature()/100.0);
H =(getHumidity()/100.0);
printf("this is my th test, %4.2f C\r\n%4.2f %%\r\n",T,H);
// }
sprintf(databuf, "{ \"tem\":[{\"v\":%.2f}] ,\"hum\":[{\"v\":%.2f}] ,\"adc\":[{\"v\":%.2f}] }", T,H,adc_mv);
sprintf(jsonBuf, ONENET_POST_BODY_FORMAT, databuf);
// sprintf(adc\_publish,"%s %.2f %s",adc\_head,adc\_mv,adc\_tail);
msg_id = esp\_mqtt\_client\_publish(client, ONENET_TOPIC_DP_Publish, jsonBuf , 0, 1, 0);
ESP\_LOGI(TAG, "sent publish successful, msg\_id=%d", msg_id);
}
vTaskDelay(1);
}
}
static void initialise\_wifi(void)
{
ESP\_ERROR\_CHECK(esp\_netif\_init());
s_wifi_event_group = xEventGroupCreate();
ESP\_ERROR\_CHECK(esp\_event\_loop\_create\_default());
esp\_netif\_t \*sta_netif = esp\_netif\_create\_default\_wifi\_sta();
assert(sta_netif);
wifi\_init\_config\_t cfg = WIFI\_INIT\_CONFIG\_DEFAULT();
ESP\_ERROR\_CHECK( esp\_wifi\_init(&cfg) );
/\*
just for test ESP\_ERR\_WIFI\_NOT\_INIT: WiFi is not initialized by esp\_wifi\_init
esp\_wifi\_restore 使用需要在 esp\_wifi\_init 之后
\*/
// esp\_wifi\_restore();
ESP\_ERROR\_CHECK( esp\_event\_handler\_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL) );
ESP\_ERROR\_CHECK( esp\_event\_handler\_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &event_handler, NULL) );
ESP\_ERROR\_CHECK( esp\_event\_handler\_register(SC_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL) );
ESP\_ERROR\_CHECK( esp\_wifi\_set\_mode(WIFI_MODE_STA) );
ESP\_ERROR\_CHECK( esp\_wifi\_start() );
xTaskCreate(led_cmd_task, "led\_cmd\_task", 2048, NULL, 2, NULL);
}
/\*\*
\* @brief Initialize selected timer of timer group
\*
\* @param group Timer Group number, index from 0
\* @param timer timer ID, index from 0
\* @param auto\_reload whether auto-reload on alarm event
\* @param timer\_interval\_sec interval of alarm
\*/
static void example\_tg\_timer\_init(int group, int timer, bool auto_reload, int timer_interval_sec)
{
/\* Select and initialize basic parameters of the timer \*/
timer\_config\_t config = {
.divider = 16,
.counter_dir = TIMER_COUNT_UP,
.counter_en = TIMER_PAUSE,
.alarm_en = TIMER_ALARM_EN,
.auto_reload = auto_reload,
}; // default clock source is APB
timer\_init(group, timer, &config);
/\* Timer's counter will initially start from value below.
Also, if auto\_reload is set, this value will be automatically reload on alarm \*/
timer\_set\_counter\_value(group, timer, 0);
/\* Configure the alarm value and the interrupt on alarm. \*/
timer\_set\_alarm\_value(group, timer, timer_interval_sec \* (TIMER_BASE_CLK / 16));
timer\_enable\_intr(group, timer);
example\_timer\_info\_t \*timer_info = calloc(1, sizeof(example\_timer\_info\_t));
timer_info->timer_group = group;
timer_info->timer_idx = timer;
timer_info->auto_reload = auto_reload;
timer_info->alarm_interval = timer_interval_sec;
timer\_isr\_callback\_add(group, timer, system_timer_callback, timer_info, 0);
timer\_start(group, timer);
}
static void smartconfig\_example\_task(void \* parm)
{
EventBits_t uxBits;
wifi\_config\_t myconfig = {0};
esp\_wifi\_get\_config(ESP_IF_WIFI_STA,&myconfig);
**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！**
**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新**
**[如果你需要这些资料，可以戳这里获取](https://gitee.com/vip204888)**
