devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

什么？单片机还在裸奔？ESP8266纯串口透传，助力设备上云端_按键配网长按重启

作者：AllinToyou | 2024-03-15 07:16:00

赞

踩

按键配网长按重启

项目有些久远，前年的机器人上需要的功能，当时是需要将STM32上的数据上传到服务器，比如机器人的速度，行驶距离，是否在拍照等等。便于管理者在PC或者手机上了解机器人的工作状态，同时可以远程下发指令给机器人，控制其完成相应动作。因为所有的逻辑判断和控制都在服务器或者STM32上面，作为中间的无线模块仅仅需要上传STM32的数据并接收服务器下发的指令即可，所以这里对WiFi模块的要求不高，仅仅需要它作为透传功能即可。当时在选型的时候试过好几款WiFi模块，最终敲定了安信可的ESP8266，价格便宜，开发简单，但是搭建环境是真的不容易，深受其害。选择好模块就该考虑使用AT指令还是使用SDK开发，AT指令固然简单，但是局限性非常大。如果使用AT指令，我那开发控制端的同事估计就要跳脚了，代码里需要写一大堆的AT指令，如果功能改变，指令代码就需要重写，烦不胜烦。如果使用SDK开发，控制端只需发送简单的数据就行，完全不用考虑其他任何东西，ESP8266完全当做一个中转站，相对应的我的工作就会繁重，但是，我屈服了，选择使用SDK。
于是就有了下面基于NONOS 2.0的ESP8266串口透传。主要有以下几个功能：
 

  1. 纯串口透传，接收MCU串口数据，直接通过MQTT上传到服务器，接收服务器数据下发给MCU。
  2. smartconfig+airkiss配网，随意使用，场景丰富。
  3. 最多储存5个WIFI账号和密码，自动寻找网络连接。
  4. 按键配网，长按重新配网，前一次WiFi自动储存，添加配网指示灯。
  5. OTA空中升级（待验证）

从程序的入口开始：

  1. //程序入口
  2.  
  3. void ICACHE_FLASH_ATTR user_init(void)
  4.  
  5. {
  6.  
  7.         uart_init(115200, 115200);
  8.  
  9.         os_delay_us(60000);
  10.  
  11.         keyInit();
  12.  
  13.         set_uart_cb(uart_cb);
  14.  
  15.  
  16.  
  17.         PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO12); //GPIO12初始化
  18.  
  19.         GPIO_OUTPUT_SET(GPIO_ID_PIN(12), 0);//低电平
  20.  
  21.  
  22.  
  23.     get_mac();//获取MAC地址
  24.  
  25.  
  26.  
  27.         wifi_set_opmode(STATION_MODE); 
  28.  
  29.         //设置wifi信息存储数量，最大为5个
  30.  
  31.         wifi_station_ap_number_set(2);
  32.  
  33.  
  34.  
  35.     mqtt_init();
  36.  
  37.  
  38.  
  39.         set_wifistate_cb(wifi_connect_cb, wifi_disconnect_cb);
  40.  
  41. }

程序的入口先进行串口初始化和按键的初始化，以及LED的初始化。串口要初始化波特率，按键初始化配网按键，用于短按配网，长按重新配网，LED只要用于判断模块是否进入配网模式以及是否配网完成。
初始化完成后会首先读取MAC地址，该地址是唯一的，每个模块都不一样，用于填充进主题中，便于服务器区分不同设备，用于多台量产设备的使用，在连接MQTT服务器时会自动填充。

每连接一次WiFi都会将WiFi信息保存在模块内部，每次上电都会自动扫描暴露的WiFi，直接连接，就像手机的WIFI连接，目前最大支持五个WiFi信息的保存，超过5个会剔除最早的WiFi信息，通过短按D5(GPIO14)可进入配网模式。 

  1. /**
  2.  
  3.  *         按键短按回调
  5.  */
  7. LOCAL void ICACHE_FLASH_ATTR key1ShortPress(void) {
  8.  
  9.  
  10.  
  11.         start_smartconfig(smartconfig_cd);
  12.  
  13.         INFO("start_smartconfig\n");
  14.  
  15. }
  16.  
  17. /**
  18.  
  19.  *         按键长按回调
  21.  */
  23. LOCAL void ICACHE_FLASH_ATTR key1LongPress(void) {
  24.  
  25.  
  26.  
  27.         start_smartconfig(smartconfig_cd);
  28.  
  29.         INFO("start_smartconfig\n");
  30.  
  31. }
  32.  
  33. /**
  34.  
  35.  *         按键初始化
  37.  */
  39. LOCAL void ICACHE_FLASH_ATTR keyInit(void) {
  40.  
  41.  
  42.  
  43.         //设置按键数量
  44.  
  45.         set_key_num(1);
  46.  
  47.         //长按、短按的按键回调
  48.  
  49.         key_add(D5, NULL, key1ShortPress);
  50.  
  51.         key_add(D5, NULL, key1LongPress);
  52.  
  53.  
  54.  
  55. }
  56.  
  57.  
  58.

由于找不到最新的代码。这里的长按我没做处理，应该是断开WiFi重新进入配网模式， 或者软复位模块，再进入start_smartconfig（）函数：

  1. /**
  2.  
  3. * 开始Smartconfig配置  
  4.  
  5. * @param  cd: Smartconfig状态回调
  6.  
  7. * @retval None
  8.  
  9. */
  10.  
  11. void ICACHE_FLASH_ATTR start_smartconfig(smartconfig_cd_t cd) {
  12.  
  13.         smartconfig_flag = 1;
  14.  
  15.         smartconfig_set_type(SC_TYPE_ESPTOUCH_AIRKISS); //SC_TYPE_ESPTOUCH,SC_TYPE_AIRKISS,SC_TYPE_ESPTOUCH_AIRKISS
  16.  
  17.         wifi_station_disconnect();
  18.  
  19.         wifi_set_opmode(STATION_MODE);
  20.  
  21.         finish_cd = cd;
  22.  
  23.         smartconfig_start(smartconfig_done);
  24.  
  25.         os_timer_disarm(&OS_Timer_Wifichange);        // 关闭定时器
  26.  
  27.  
  28.  
  29.         if(connect_flag == 1){
  30.  
  31.                 w_disconnect();
  32.  
  33.                 connect_flag = 0;
  34.  
  35.         }
  36.  
  37.  
  38.  
  39.         os_timer_disarm(&OS_Timer_SM);        // 关闭定时器
  40.  
  41.         os_timer_setfn(&OS_Timer_SM, (os_timer_func_t *) sm_wait_time, NULL);// 设置定时器
  42.  
  43.         os_timer_arm(&OS_Timer_SM, 1000, 1);  // 使能定时器
  44.  
  45. }


smartconfig_set_type();函数可选3个参数：分别是：SC_TYPE_ESPTOUCH、SC_TYPE_AIRKISS和SC_TYPE_ESPTOUCH_AIRKISS
第一个是smartconfig配网（手机APP），第二个是airkiss配网（微信公众号），最后一个两者都可以。进入该函数会调用smartconfig_start();，该函数会调用smartconfig_done（）函数进行配网，配网成功后会点亮LED灯。

smartconfig_set_type();函数可选3个参数：分别是：SC_TYPE_ESPTOUCH、SC_TYPE_AIRKISS和SC_TYPE_ESPTOUCH_AIRKISS
第一个是smartconfig配网（手机APP），第二个是airkiss配网（微信公众号），最后一个两者都可以。进入该函数会调用smartconfig_start();，该函数会调用smartconfig_done（）函数进行配网，配网成功后会点亮LED灯。

  1. /**
  2.  
  3.  * Smartconfig 状态处理 
  5.  * @param  status: 状态
  7.  * @param  *pdata: AP数据
  9.  * @retval None
  11.  */
  13. void ICACHE_FLASH_ATTR
  14.  
  15. smartconfig_done(sc_status status, void *pdata) {
  16.  
  17.         switch (status) {
  18.  
  19.         case SC_STATUS_WAIT:
  20.  
  21.                 INFO("SC_STATUS_WAIT\n");
  22.  
  23.                 break;
  24.  
  25.         case SC_STATUS_FIND_CHANNEL:
  26.  
  27.                 INFO("SC_STATUS_FIND_CHANNEL\n");
  28.  
  29.                 break;
  30.  
  31.         case SC_STATUS_GETTING_SSID_PSWD:
  32.  
  33.                 INFO("SC_STATUS_GETTING_SSID_PSWD\n");
  34.  
  35.                 sc_type *type = pdata;
  36.  
  37.                 if (*type == SC_TYPE_ESPTOUCH) {
  38.  
  39.                         INFO("SC_TYPE:SC_TYPE_ESPTOUCH\n");
  40.  
  41.                 } else {
  42.  
  43.                         INFO("SC_TYPE:SC_TYPE_AIRKISS\n");
  44.  
  45.                 }
  46.  
  47.                 break;
  48.  
  49.         case SC_STATUS_LINK:
  50.  
  51.                 INFO("SC_STATUS_LINK\n");
  52.  
  53.                 sm_comfig_status = SM_STATUS_GETINFO;
  54.  
  55.                 struct station_config *sta_conf = pdata;
  56.  
  57.                 wifi_station_set_config(sta_conf);
  58.  
  59.                 wifi_station_disconnect();
  60.  
  61.                 wifi_station_connect();
  62.  
  63.                 break;
  64.  
  65.         case SC_STATUS_LINK_OVER:
  66.  
  67.                 sm_comfig_status = SM_STATUS_FINISH;
  68.  
  69.                 INFO("SC_STATUS_LINK_OVER\n");
  70.  
  71.                 if (pdata != NULL) {
  72.  
  73.                         //SC_TYPE_ESPTOUCH
  74.  
  75.                         uint8 phone_ip[4] = { 0 };
  76.  
  77.                         os_memcpy(phone_ip, (uint8*) pdata, 4);
  78.  
  79.                         INFO("Phone ip: %d.%d.%d.%d\n", phone_ip[0], phone_ip[1],
  80.  
  81.                                         phone_ip[2], phone_ip[3]);
  82.  
  83.                 } else {
  84.  
  85.                         //SC_TYPE_AIRKISS - support airkiss v2.0
  86.  
  87.                         airkiss_start_discover();
  88.  
  89.                 }
  90.  
  91.                 smartconfig_stop();
  92.  
  93.                 smartconfig_flag = 0;
  94.  
  95.                 connect_flag = 0;
  96.  
  97.                 os_timer_disarm(&OS_Timer_SM);        // 关闭定时器
  98.  
  99.                 finish_cd(sm_comfig_status);
  100.  
  101.                 os_timer_arm(&OS_Timer_Wifichange, 3000, 1);  // 使能定时器
  102.  
  103.                 break;
  104.  
  105.         }
  106.  
  107.  
  108.  
  109. }
  110.  
  111.  
  112.  
  113. /**
  114.  
  115.  *         WIFI连接回调
  117.  */
  119. void wifi_connect_cb(void){
  120.  
  121.  
  122.  
  123.         INFO("wifi connect!\r\n");
  124.  
  125.         os_printf("----- WiFi连接成功，打开绿灯---\r\n");
  126.  
  127.         GPIO_OUTPUT_SET(GPIO_ID_PIN(12), 1);
  128.  
  129.         MQTT_Connect(&mqttClient);
  130.  
  131. }
  132.  
  133.  
  134.  
  135. /**
  136.  
  137.  *         WIFI断开回调
  139.  */
  141. void wifi_disconnect_cb(void){
  142.  
  143.         INFO("wifi disconnect!\r\n");
  144.  
  145.         os_printf("----- WiFi断开，关闭绿灯---\r\n");
  146.  
  147.         GPIO_OUTPUT_SET(GPIO_ID_PIN(12), 0);
  148.  
  149.         MQTT_Disconnect(&mqttClient);
  150.  
  151. }
连接MQTT服务器

网络连接成功以后可以开始MQTT的初始化，初始化包涵一系列的连接初始化回调，连接成功或不成功回调，主题订阅发布回调等等。

  1. /**
  2.  
  3.  *         MQTT初始化
  5.  */
  7. void ICACHE_FLASH_ATTR mqtt_init(void) {
  8.  
  9.  
  10.  
  11.         MQTT_InitConnection(&mqttClient, MQTT_HOST, MQTT_PORT, DEFAULT_SECURITY);
  12.  
  13.         MQTT_InitClient(&mqttClient, mac_str, MQTT_USER,MQTT_PASS, MQTT_KEEPALIVE, 1);
  14.  
  15.         MQTT_InitLWT(&mqttClient, lwt_topic, LWT_MESSAGE, 0, 0);
  16.  
  17.         MQTT_OnConnected(&mqttClient, mqttConnectedCb);
  18.  
  19.         MQTT_OnDisconnected(&mqttClient, mqttDisconnectedCb);
  20.  
  21.         MQTT_OnPublished(&mqttClient, mqttPublishedCb);
  22.  
  23.         MQTT_OnData(&mqttClient, mqttDataCb);
  24.  
  25. }
  26.  
  27.  
  28.  
  29. void ICACHE_FLASH_ATTR
  30.  
  31. MQTT_InitConnection(MQTT_Client *mqttClient, uint8_t* host, uint32_t port, uint8_t security)
  32.  
  33. {
  34.  
  35.         uint32_t temp;
  36.  
  37.         INFO("MQTT_InitConnection\r\n");
  38.  
  39.         os_memset(mqttClient, 0, sizeof(MQTT_Client));
  40.  
  41.         temp = os_strlen(host);
  42.  
  43.         mqttClient->host = (uint8_t*)os_zalloc(temp + 1);
  44.  
  45.         os_strcpy(mqttClient->host, host);
  46.  
  47.         mqttClient->host[temp] = 0;
  48.  
  49.         mqttClient->port = port;
  50.  
  51.         mqttClient->security = security;
  52.  
  53.  
  54.  
  55. }
  56.  
  57.  
  58.  
  59. void ICACHE_FLASH_ATTR
  60.  
  61. MQTT_InitClient(MQTT_Client *mqttClient, uint8_t* client_id, uint8_t* client_user, uint8_t* client_pass, uint32_t keepAliveTime, uint8_t cleanSession)
  62.  
  63. {
  64.  
  65.         uint32_t temp;
  66.  
  67.         INFO("MQTT_InitClient\r\n");
  68.  
  69.         os_printf("CD MQTT_InitClient++++++++++++++++++++++\n");
  70.  
  71.         os_memset(&mqttClient->connect_info, 0, sizeof(mqtt_connect_info_t));
  72.  
  73.  
  74.  
  75.         temp = os_strlen(client_id);
  76.  
  77.         mqttClient->connect_info.client_id = (uint8_t*)os_zalloc(temp + 1);
  78.  
  79.         os_strcpy(mqttClient->connect_info.client_id, client_id);
  80.  
  81.         mqttClient->connect_info.client_id[temp] = 0;
  82.  
  83.  
  84.  
  85.         if (client_user)
  86.  
  87.         {
  88.  
  89.                 temp = os_strlen(client_user);
  90.  
  91.                 mqttClient->connect_info.username = (uint8_t*)os_zalloc(temp + 1);
  92.  
  93.                 os_strcpy(mqttClient->connect_info.username, client_user);
  94.  
  95.                 mqttClient->connect_info.username[temp] = 0;
  96.  
  97.         }
  98.  
  99.  
  100.  
  101.         if (client_pass)
  102.  
  103.         {
  104.  
  105.                 temp = os_strlen(client_pass);
  106.  
  107.                 mqttClient->connect_info.password = (uint8_t*)os_zalloc(temp + 1);
  108.  
  109.                 os_strcpy(mqttClient->connect_info.password, client_pass);
  110.  
  111.                 mqttClient->connect_info.password[temp] = 0;
  112.  
  113.         }
  114.  
  115.  
  116.  
  117.  
  118.  
  119.         mqttClient->connect_info.keepalive = keepAliveTime;
  120.  
  121.         mqttClient->connect_info.clean_session = cleanSession;
  122.  
  123.  
  124.  
  125.         mqttClient->mqtt_state.in_buffer = (uint8_t *)os_zalloc(MQTT_BUF_SIZE);
  126.  
  127.         mqttClient->mqtt_state.in_buffer_length = MQTT_BUF_SIZE;
  128.  
  129.         mqttClient->mqtt_state.out_buffer =  (uint8_t *)os_zalloc(MQTT_BUF_SIZE);
  130.  
  131.         mqttClient->mqtt_state.out_buffer_length = MQTT_BUF_SIZE;
  132.  
  133.         mqttClient->mqtt_state.connect_info = &mqttClient->connect_info;
  134.  
  135.  
  136.  
  137.         mqtt_msg_init(&mqttClient->mqtt_state.mqtt_connection, mqttClient->mqtt_state.out_buffer, mqttClient->mqtt_state.out_buffer_length);
  138.  
  139.  
  140.  
  141.         QUEUE_Init(&mqttClient->msgQueue, QUEUE_BUFFER_SIZE);
  142.  
  143.  
  144.  
  145.         system_os_task(MQTT_Task, MQTT_TASK_PRIO, mqtt_procTaskQueue, MQTT_TASK_QUEUE_SIZE);
  146.  
  147.         system_os_post(MQTT_TASK_PRIO, 0, (os_param_t)mqttClient);
  148.  
  149. }

WiFi连接成功和失败会触发不同的回调函数：

  1. /**
  2.  
  3.  *         MQTT连接回调
  5.  */
  7. void mqttConnectedCb(uint32_t *args) {
  8.  
  9.         MQTT_Client* client = (MQTT_Client*) args;
  10.  
  11.  
  12.  
  13.         INFO("MQTT: Connected\r\n");
  14.  
  15.         MQTT_Publish(client, birth_topic, BIRTH_MESSAGE, os_strlen(BIRTH_MESSAGE), 0,0);
  16.  
  17.         MQTT_Subscribe(client,ota_topic, 0);
  18.  
  19.         if(updata_status_check()){
  20.  
  21.                 MQTT_Publish(client, ota_topic, "updata_finish", os_strlen("updata_finish"), 0,0);
  22.  
  23.         }
  24.  
  25. }
  26.  
  27. /**
  28.  
  29.  
  30.  
  31.  *         MQTT断开连接回调
  33.  */
  35. void mqttDisconnectedCb(uint32_t *args) {
  36.  
  37.         MQTT_Client* client = (MQTT_Client*) args;
  38.  
  39.         INFO("MQTT: Disconnected\r\n");
  40.  
  41. }
  42.  
  43.  
  44.  
  45. /**
  46.  
  47.  *         MQTT发布消息回调
  49.  */
  51. void mqttPublishedCb(uint32_t *args) {
  52.  
  53.         MQTT_Client* client = (MQTT_Client*) args;
  54.  
  55.         INFO("MQTT: Published\r\n");
  56.  
  57. }

串口透传：
当模块的WiFi和MQTT服务器都连接上之后，模块就开始监听串口和服务器的数据，如果串口有数据过来便转发到服务器或者进行OTA升级，如果服务器有指令下发就转发给串口。

  1. /**
  2.  
  3.  *         MQTT接收数据回调（用于OTA升级和串口透传）
  5.  */
  7. void mqttDataCb(uint32_t *args, const char* topic, uint32_t topic_len,
  8.  
  9.                 const char *data, uint32_t data_len) {
  10.  
  11.         char *topicBuf = (char*) os_zalloc(topic_len + 1), *dataBuf =
  12.  
  13.                         (char*) os_zalloc(data_len + 1);
  14.  
  15.  
  16.  
  17.         uint8 *pdata = (uint8*)data;
  18.  
  19.         uint16 len = data_len;
  20.  
  21.         uart0_tx_buffer(pdata, len);//串口输出
  22.  
  23.  
  24.  
  25.         MQTT_Client* client = (MQTT_Client*) args;
  26.  
  27.  
  28.  
  29.         os_memcpy(topicBuf, topic, topic_len);
  30.  
  31.         topicBuf[topic_len] = 0;
  32.  
  33.  
  34.  
  35.         os_memcpy(dataBuf, data, data_len);
  36.  
  37.         dataBuf[data_len] = 0;
  38.  
  39.  
  40.  
  41. //        INFO("Receive topic: %s, data: %s \r\n", topicBuf, dataBuf);
  42.  
  43.  
  44.  
  45.         //data = {"url"="http://yourdomain.com:9001/ota/"}
  46.  
  47.         if (os_strcmp(topicBuf, ota_topic) == 0) {
  48.  
  49.                 char url_data[200];
  50.  
  51.                 if(get_josn_str(dataBuf,"url",url_data)){
  52.  
  53. //            INFO("ota_start\n");
  54.  
  55.             ota_upgrade(url_data,ota_finished_callback);
  56.  
  57.                 }
  58.  
  59.         }
  60.  
  61.  
  62.  
  63.         os_free(topicBuf);
  64.  
  65.         os_free(dataBuf);
  66.  
  67.  
  68.  
  69.  
  70.  
  71.  
  72.  
  73. }
  74.  
  75.  
  76.  
  77. /**
  78.  
  79.  *         ota升级回调
  81.  */
  83. void ICACHE_FLASH_ATTR ota_finished_callback(void * arg) {
  84.  
  85.         struct upgrade_server_info *update = arg;
  86.  
  87.         if (update->upgrade_flag == true) {
  88.  
  89.                 INFO("OTA  Success ! rebooting!\n");
  90.  
  91.                 system_upgrade_reboot();
  92.  
  93.         } else {
  94.  
  95.                 INFO("OTA Failed!\n");
  96.  
  97.         }
  98.  
  99. }
  100.  
其他问题：
连接的服务器地址，端口号等信息需要写在代码里烧录进模块，这些信息在在mqtt_config.h文件中定义。


上电后可以在串口助手看到打印的MAC地址：

按下配网按键（GPIO14接地），进入配网模式，使用APP或者微信公众号将信息发给模块便可联网，联网后自动连接MQTT服务器。
 
至此连接完成，后续只需要串口发数据给模块，便可在服务器收到信息，服务器下发指令，单片机串口也可以接收到数据。但是要记得订阅主题哦。该透传代码烧录完成可搭配任意MCU的串口使用。非常便捷。由于项目期较远，可能介绍的不是很详细，需要的大大们可以回帖获取源码。自行查看。
 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/239373
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号