-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.2.0)
-include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+# 每次编译都强制重新生成时间戳（不清空build也更新）
+string(TIMESTAMP COMPILE_TIME "%Y%m%d_%H%M")
+set(PROJECT_VER "V0.0.0_${COMPILE_TIME}")
+file(WRITE ${CMAKE_CURRENT_LIST_DIR}/version.txt "${PROJECT_VER}\n")
+# 关键：强制每次编译都重新运行CMake，刷新时间
+add_custom_target(
+ force_cmake_refresh ALL
+ COMMAND ${CMAKE_COMMAND} -E touch_nocreate "${CMAKE_CURRENT_LIST_FILE}"
+ COMMENT "Forcing CMake refresh to update compile time..."
+)
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(ssl_mutual_auth)
\ No newline at end of file
-idf_component_register(SRCS "app_main.c"
+idf_component_register(SRCS "https_ota.c" "app_main.c"
"iap.c"
"mqtt.c"
"project_common.c"
"crc.c"
"http.c"
"uart.c"
+ "https_ota.c"
PRIV_REQUIRES mqtt
esp_wifi
bt
esp_http_client
esp_driver_uart
esp_driver_gpio
+ esp_https_ota
json
app_update
INCLUDE_DIRS ".")
*/
#include "project_common.h"
#include "esp_timer.h"
-
+#include "https_ota.h"
static const char *MAIN_TAG = "main";
// 1秒定时器句柄
// 1秒定时器回调函数
static void onesec_timer_callback(void* arg)
{
+ Mqtt_Send_Data();
// 在这里添加每秒执行的代码
ESP_LOGI(MAIN_TAG, "onesec_timer_callback memory head size: %" PRIu32 " bytes", esp_get_free_heap_size());
// 例如：检查状态、发送心跳等
const char* http_url = "http://192.168.66.85:8080";//"http://107.23.202.137:8080";//"http://192.168.66.80:8080";//http://107.23.202.137:8080
const char* http_token = "Bearer eyJhbGciOiJIUzUxMiJ9.eyJsb2dpbl91c2VyX2tleSI6ImJhZWRiZjUyLTUzMDgtNDRlOS04MWI3LTE1MmU4NGYwYzk5ZCJ9.fyxIGmmYD-pKd7VQ02DrL6FwBKVkqXoIu4iKSVMOUj8WubDvuSdbX6j8YzQw8K_t6UTRVZsRDTlO5me2KKhs7A";//"eyJhbGciOiJIUzUxMiJ9.eyJsb2dpbl91c2VyX2tleSI6IjRhNjBlZDdiLTExMDUtNDU5Ny1iNDBhLTg5ZDRiMzMzNTIyYSJ9.CUxkgU2F6BoxzE3HHVdXAin2OEDD1-D_iI0zh7VWTnlNsjsHHulvZVMq2hQLXF4cAQIJpLWwiMZJQO6Bvy9vwg";
const uint32_t user_id = 1;
-const char* wifi_ssid = "XiaoMing1919810";
-const char* wifi_pwd = "XiaoMing1919810";
+const char* wifi_ssid = "PXN";
+const char* wifi_pwd = "PXN998877";
const uint16_t mcu_vid = 0x36E6;
const uint16_t mcu_pid = 0xA00B;
{
common_setting.heart_beat_interval = 1000;
common_setting.mcu_info_got_flag = 1;
-
- // 创建1秒周期性定时器
+ common_setting.ble_status.ble_state=0;
+ // // 创建1秒周期性定时器
const esp_timer_create_args_t onesec_timer_args = {
.callback = &onesec_timer_callback,
.arg = NULL,
.name = "onesec_timer"
};
ESP_ERROR_CHECK(esp_timer_create(&onesec_timer_args, &onesec_timer_handle));
-
// 启动1秒周期性定时器 (1000000微秒 = 1秒)
ESP_ERROR_CHECK(esp_timer_start_periodic(onesec_timer_handle, 1000000));
ESP_LOGI(MAIN_TAG, "1 second periodic timer started");
+
#if (IOT_ENABLE)
- if(common_storage.net_info.wifi_info_flag == 1 && common_storage.net_info.serial_number_flag == 1 && common_storage.ssl_cert[0].length != 0 && common_storage.ssl_cert[1].length != 0 && common_storage.ssl_cert[2].length != 0)
- {
- Wifi_Queue_Send(0, 0x03, 0);
- }
+ //直连mqtts
+ // common_setting.wifi_status.cur_ssid_len=common_storage.net_info.wifi_ssid_len;
+ // common_setting.wifi_status.cur_pwd_len=common_storage.net_info.wifi_pwd_len;
+ // memcpy(common_setting.wifi_status.cur_ssid, common_storage.net_info.wifi_ssid,common_storage.net_info.wifi_ssid_len);
+ // memcpy(common_setting.wifi_status.cur_pwd, common_storage.net_info.wifi_pwd,common_storage.net_info.wifi_pwd_len);
+ // Wifi_Queue_Send(0, 0x03, 0);
+ // vTaskDelay(pdMS_TO_TICKS(1000));
+ // xEventGroupSetBits(common_event_group, COMMON_MQTT_CONNECT_BIT);
+ // ESP_LOGI(MAIN_TAG, "[APP] Free memory connect power on: on: %" PRIu32 " bytes", esp_get_free_heap_size());
common_setting.mcu_info.vid = mcu_vid;
common_setting.mcu_info.pid = mcu_pid;
common_setting.mcu_info.fw_version = 0x0001;
memcpy(common_setting.mcu_info.product_name, device_name, strlen(device_name));
common_setting.mcu_info.product_name_len = strlen(device_name);
common_setting.mcu_info_got_flag = 1;
+
#if (USER_TEST_ENABLE)
// BLE Test
+
common_setting.mcu_info.vid = mcu_vid;
common_setting.mcu_info.pid = mcu_pid;
common_setting.mcu_info.fw_version = 0x0001;
common_setting.mcu_info_got_flag = 1;
common_setting.net_pairing_info.serial_number_flag =1;//等同于device_id
// Ble_Queue_Send(0xFF, 0x01);
- xEventGroupSetBits(ble_event_group, BLE_ON_BIT);
+ // xEventGroupSetBits(ble_event_group, BLE_ON_BIT);
memset(common_setting.net_pairing_info.http_url, 0x00, sizeof(common_setting.net_pairing_info.http_url));
memset(common_setting.net_pairing_info.http_token, 0x00, sizeof(common_setting.net_pairing_info.http_token));
memcpy(common_setting.wifi_status.cur_pwd, wifi_pwd, strlen(wifi_pwd));
common_setting.wifi_status.cur_ssid_len = strlen(wifi_ssid);
common_setting.wifi_status.cur_pwd_len = strlen(wifi_pwd);
+ common_setting.ble_status.ble_state=0;
+ common_storage.net_info.wifi_info_flag=1;
+ common_storage.net_info.serial_number_flag=1;
+ // Esp_Check_Mcu_info_Flag();
+
Wifi_Queue_Send(0, 0x02, 0);
#endif
#endif
+
for(;;)
{
#if (1)
Ble_Enable_Status_Check();
-
Wifi_Enable_Status_Check();
Http_Connect_Status_Check();
Mqtt_Connect_Status_Check();
+ #if OPEN_HTTPS_OTA_FUNC
+ Https_Ota_Status_Check();
+ #endif
#endif
// heart beat
if(common_setting.heart_beat_enable == 1 && common_setting.heart_beat_interval != 0)
esp_restart();
}
}
+
vTaskDelay(MAIN_LOOP_INTERVAL / portTICK_PERIOD_MS);
}
}
ESP_ERROR_CHECK(esp_event_loop_create_default());
ESP_LOGI(MAIN_TAG, "[APP] Free memory after lwip: %" PRIu32 " bytes", esp_get_free_heap_size());
- // WIFI MQTT
+
+ // WIFI
Wifi_Sta_Init();
-
+ vTaskDelay(1000);
+ //等待wifi稳定再去连接wifi
ESP_LOGI(MAIN_TAG, "[APP] Free memory after wifi: %" PRIu32 " bytes", esp_get_free_heap_size());
#endif
-
+ common_setting.heart_beat_interval = 1000;
+ common_setting.mcu_info_got_flag = 1;
+
main_loop_task_handler = xTaskCreateStatic(Main_Loop_Task, "Main_Loop_Task", MAIN_LOOP_TASK_STACK, NULL, 4, main_loop_task_stack, &main_loop_task_tcb);
ESP_LOGI(MAIN_TAG, "[APP] Free memory after Main_Loop: %" PRIu32 " bytes", esp_get_free_heap_size());
-
+ #if (!USER_TEST_ENABLE)
+ Esp_Check_Mcu_Info_Flag();
+ #endif
}
// xQueueSend(ble_queue_handle, ble_queue_write, 0);
// }
//common_setting.mcu_info_got_flag=0 common_storage.net_info.device_id_flag=0 common_storage.net_info.wifi_info_flag=0 common_setting.ble_status.ble_state=0
-void Ble_Enable_Status_Check(void)
+//串口接收主控发过来的消息 才开启判断是否需要配网
+void Esp_Check_Mcu_Info_Flag(void)
{
if(common_setting.mcu_info_got_flag)
{
//无serial_number wifi info 并且蓝牙关闭状态开启蓝牙配网功能
- if(common_storage.net_info.serial_number_flag == 0 && common_storage.net_info.wifi_info_flag == 0 && common_setting.ble_status.ble_state == 0)
+ ESP_LOGI(BLE_TAG, "[APP] Free memory Esp_Check_Mcu_info_Flag on: %d %d %d\n",common_storage.net_info.serial_number_flag,common_storage.net_info.wifi_info_flag,\
+ common_setting.ble_status.ble_state);
+ //只要有一个不为1都需要重新配网
+ if((common_storage.net_info.serial_number_flag == 0 || common_storage.net_info.wifi_info_flag == 0) && common_setting.ble_status.ble_state == 0 )
{
- // Ble_Queue_Send(0xFF, 0x01);
+
xEventGroupSetBits(ble_event_group, BLE_ON_BIT);
- ESP_LOGI(BLE_TAG, "[APP] Free memory no serial_number on: %" PRIu32 " bytes", esp_get_free_heap_size());
+ ESP_LOGI(BLE_TAG, "[APP] Free memory start BLE_ON_BIT on: %" PRIu32 " bytes", esp_get_free_heap_size());
}
else if(common_storage.net_info.serial_number_flag == 1 && common_storage.net_info.wifi_info_flag == 1){
//有serial_number wifi信息
ESP_LOGI(BLE_TAG, "[APP] Free memory have serial_number on: %" PRIu32 " bytes", esp_get_free_heap_size());
//还要查询是否有订阅地址和证书 没有订阅地址 或者 没有密码 没有wifi名称 没有证书长度
- if(common_storage.net_info.mqtt_url_len != 0 || common_storage.net_info.wifi_ssid_len != 0 || common_storage.net_info.wifi_pwd_len != 0 || \
- common_storage.ssl_cert[SSL_CLIENT_CRT].length != 0 || common_storage.ssl_cert[SSL_CLIENT_KEY].length != 0 || common_storage.ssl_cert[SSL_SERVER_CRT].length != 0)
+ if(common_storage.net_info.mqtt_url_len == 0 || common_storage.net_info.wifi_ssid_len == 0 || common_storage.net_info.wifi_pwd_len == 0 || \
+ common_storage.ssl_cert[SSL_CLIENT_CRT].length == 0 || common_storage.ssl_cert[SSL_CLIENT_KEY].length == 0 || common_storage.ssl_cert[SSL_SERVER_CRT].length == 0)
{
ESP_LOGI(BLE_TAG, "[APP] Free memory have mqtt_sub_url on: %d %d %d %d %d %d\n", common_storage.net_info.mqtt_url_len,common_storage.net_info.wifi_ssid_len,\
common_storage.net_info.wifi_pwd_len,common_storage.ssl_cert[SSL_SERVER_CRT].length,common_storage.ssl_cert[SSL_CLIENT_KEY].length,\
common_storage.ssl_cert[SSL_CLIENT_CRT].length);
- //直连mqtts
- xEventGroupSetBits(common_event_group, COMMON_MQTT_CONNECT_BIT);
- }else
- {
xEventGroupSetBits(ble_event_group, BLE_ON_BIT);//开启配网模式
- ESP_LOGI(BLE_TAG, "[APP] Free memory have not mqtt_sub_url on: on: %" PRIu32 " bytes", esp_get_free_heap_size());
+ }else//有mqtt地址 密码 名称 证书才能直连mqtt服务器
+ {
+ //直连mqtts
+ common_setting.wifi_status.cur_ssid_len=common_storage.net_info.wifi_ssid_len;
+ common_setting.wifi_status.cur_pwd_len=common_storage.net_info.wifi_pwd_len;
+ if(common_setting.wifi_status.cur_pwd_len !=0 && common_setting.wifi_status.cur_ssid_len != 0)
+ {
+ memcpy(common_setting.wifi_status.cur_ssid, common_storage.net_info.wifi_ssid,common_storage.net_info.wifi_ssid_len);
+ memcpy(common_setting.wifi_status.cur_pwd, common_storage.net_info.wifi_pwd,common_storage.net_info.wifi_pwd_len);
+ if(common_storage.net_info.mqtt_url_len !=0)
+ {
+ Wifi_Queue_Send(0, 3, 0);
+
+ }else{
+ ESP_LOGI(BLE_TAG, "[APP] Free memory connect mqtt_sub_url no len");
+ }
+ }else{
+ ESP_LOGI(BLE_TAG, "[APP] Free memory connect ssid pwd no len");
+ }
+ ESP_LOGI(BLE_TAG, "[APP] Free memory connect mqtt_sub_url on: on: %" PRIu32 " bytes", esp_get_free_heap_size());
}
+ }else{
+ xEventGroupSetBits(ble_event_group, BLE_ON_BIT);//开启配网模式
+ ESP_LOGI(BLE_TAG, "[APP] Free memory have not start BLE_ON_BIT error on: on: %" PRIu32 " bytes", esp_get_free_heap_size());
}
- //只有配网后设备主动关闭蓝牙配网 或者开始配网之后30分钟后没有进行配网则关闭 其他条件无需关闭配网
- // else if(common_storage.net_info.serial_number_flag && common_storage.net_info.wifi_info_flag && common_setting.ble_status.ble_state != 0)
- // {
- // // Ble_Queue_Send(0xFF, 0xFF);
- // xEventGroupSetBits(ble_event_group, BLE_OFF_BIT);
- // ESP_LOGI(BLE_TAG, "[APP] Free memory device_id_flag2 on: %" PRIu32 " bytes", esp_get_free_heap_size());
- // }
}
+}
+
+void Ble_Enable_Status_Check(void)
+{
+
// static uint8_t ble_queue_read[BLE_QUEUE_ITEM_SIZE] = {0}; // byte0:0:串口 1:蓝牙 0xFF:本地 byte1:1:打开BLE 0xFF:关闭
EventBits_t ble_bits = xEventGroupWaitBits(ble_event_group, BLE_ON_BIT | BLE_OFF_BIT, pdFALSE, pdFALSE, 0);
// 开始配网
common_setting.ble_status.ble_state = 1;
common_setting.ble_enable_tick = 0;
+ common_setting.ble_status.nimble_flag=1;
common_setting.net_pairing_info.http_url_flag = 0;
common_setting.net_pairing_info.http_token_flag = 0;
common_setting.net_pairing_info.user_id_flag = 0;
ESP_LOGI(BLE_TAG, "[APP] Free memory ble on1: %" PRIu32 " bytes", esp_get_free_heap_size());
Ble_Nimble_Init();
-
-
ESP_LOGI(BLE_TAG, "[APP] Free memory ble on2: %" PRIu32 " bytes", esp_get_free_heap_size());
}
}
nimble_port_deinit();
common_setting.ble_status.ble_state = 0;
common_setting.ble_enable_tick = 0;
-
- // xEventGroupSetBits(ble_event_group, BLE_ON_BIT);
+ common_setting.ble_status.nimble_flag=0;
ESP_LOGI(BLE_TAG, "nimble_port_stop\n");
}
else
// void Ble_Queue_Send(uint8_t host_type, uint8_t enable);
void Ble_Enable_Status_Check(void);
-
+void Esp_Check_Mcu_Info_Flag(void);
#endif
{
crc8 = crc8_table[(crc8 ^ *data++) & 0xff];
}
- ESP_LOGI(CHECKCRC_TAG, "Crc8_ROHC_Cal %x bytes:", crc8);
+ // ESP_LOGI(CHECKCRC_TAG, "Crc8_ROHC_Cal %x bytes:", crc8);
return crc8;
}
#endif
ESP_LOGI(HTTP_TAG, "HTTP_EVENT_ON_HEADER, key=%s, value=%s", evt->header_key, evt->header_value);
break;
case HTTP_EVENT_ON_DATA:
- ESP_LOGI(HTTP_TAG, "HTTP_EVENT_ON_DATA, len=%d", evt->data_len);
+ // ESP_LOGI(HTTP_TAG, "HTTP_EVENT_ON_DATA, len=%d", evt->data_len);
// if (!esp_http_client_is_chunked_response(evt->client))
// {
// printf("%.*s", evt->data_len, (char*)evt->data);
#if HTTP_DOWNLOAD_CER_FUNC_ENABLE
static char http_download_cache[sizeof(common_storage.ssl_cert[0].content)] = {0};
#endif
-// esp_err_t http_get_cert(uint8_t cert_type, esp_http_client_handle_t http_client)
-// {
-// esp_err_t err = 0;
-// do
-// {
-// err = esp_http_client_open(http_client, 0);
-// if (err == ESP_OK)
-// {
-// int header_ret = esp_http_client_fetch_headers(http_client);
-// ESP_LOGI(HTTP_TAG, "esp_http_client_fetch_headers = %d", header_ret);
-
-// int code = esp_http_client_get_status_code(http_client);
-// if(code == 200)
-// {
-// int file_size = esp_http_client_get_content_length(http_client);
-// if(file_size <= (sizeof(common_storage.ssl_cert[0].content)))
-// {
-// int read_len = 0;
-// memset(http_download_cache, 0x00, sizeof(http_download_cache));
-// read_len = esp_http_client_read(http_client, http_download_cache, file_size);
-// if(read_len == file_size)
-// {
-// // 成功
-// ESP_LOGI(HTTP_TAG, "\nrecv data len%d: %s\n", file_size, http_download_cache);
-
-// if(common_storage.ssl_cert[cert_type].length == file_size && memcmp(http_download_cache, common_storage.ssl_cert[cert_type].content, file_size) == 0)
-// {
-// ESP_LOGI(HTTP_TAG, "cert same: %d", cert_type);
-// err = ESP_OK;
-// break;
-// }
-// common_storage.ssl_cert[cert_type].length = file_size;
-// memset(common_storage.ssl_cert[cert_type].content, 0x00, sizeof(common_storage.ssl_cert[0].content));
-// memcpy(common_storage.ssl_cert[cert_type].content, http_download_cache, file_size);
-// if(User_Flash_Write_With_Flag(UF_OFFSET_CERT_CLIENT_CRT_ADDR+FLASH_SEC_SIZE*cert_type, UF_OFFSET_CERT_CERT_FLAG, &common_storage.ssl_cert[cert_type], sizeof(SSL_CERT_T)) == ESP_OK)
-// {
-// err = ESP_OK;
-// }
-// else
-// {
-// ESP_LOGE(HTTP_TAG, "flash write error: %d\n", cert_type);
-// err = ESP_FAIL;
-// break;
-// }
-// }
-// else
-// {
-// ESP_LOGE(HTTP_TAG, "http read size low = %d", read_len);
-// err = ESP_FAIL;
-// break;
-// }
-// }
-// else
-// {
-// ESP_LOGE(HTTP_TAG, "file_size too large");
-// err = ESP_FAIL;
-// break;
-// }
-// }
-// else
-// {
-// ESP_LOGE(HTTP_TAG, "http req failed");
-// err = ESP_FAIL;
-// break;
-// }
-// }
-// else
-// {
-// err = ESP_FAIL;
-// }
-// }while(0);
-
-// return err;
-// }
#define HTTP_RETRY_NUMBER_MAX (5) //HTTP请求失败重试次数最大值
#define HTTP_GET 0
#define HTTP_POST 0
#define HTTP_PUT_REPORT_MAC_RSSI_ENABLE 1 //PUT请求上报mac和rssi信息
#define HTTP_GET_SERIAL_NUMBER_ENBALE 1 //GET请求获取serialNumber，服务器根据设备token mac pid等信息返回对应的serialNumber=deviceID等信息
#define HTTP_GET_URL_MAX_SIZE NET_PAIRING_INFO_MAX_LEN+128
-char output_buffer[MAX_HTTP_OUTPUT_BUFFER] = {0};
+
+
#define DOWNLOAD_BLOCK_SIZE 512
HTTP_GET_CERT_TASK_PARAM_T http_get_cert_task_param;
static const char *HTTP_DOWNLOAD_TASK_TAG = "http_download_task";
-
+const esp_partition_t *s_ota_partition = NULL;
+esp_ota_handle_t s_ota_handle = 0;
void http_download_task(void *pvParameters)
{
uint8_t success_bit = 0;
}
esp_http_client_config_t http_config = {
- // .url = "https://e-pxn.com.cn/pms/api/mqtt_ssl_mutual_auth.bin",
+ // .url = "https://pxn-iot.s3.us-east-2.amazonaws.com/iot01/2026/04/11/ssl_mutual_auth.bin",// "https://e-pxn.com.cn/pms/api/mqtt_ssl_mutual_auth.bin",
.url = (const char*)&http_get_cert_task_param.url[cert_type][0],
.crt_bundle_attach = esp_crt_bundle_attach,
.event_handler = _http_event_handler,
int code = esp_http_client_get_status_code(http_client);
int total_size = esp_http_client_get_content_length(http_client);
+ int data_total_size = 0;
+ // 擦除OTA分区
+ // s_ota_partition = esp_ota_get_next_update_partition(NULL);
+ // if (esp_ota_begin(s_ota_partition, OTA_SIZE_UNKNOWN, &s_ota_handle) == ESP_OK) {
+
+
+ // while (1) //0
+ // {
+
+ // // 每次读 512 字节
+ // uint8_t flash_buf[DOWNLOAD_BLOCK_SIZE+512] = {0};
+ // int read_len = esp_http_client_read(http_client, (char*)flash_buf, DOWNLOAD_BLOCK_SIZE+512);
+
+ // if (read_len <= 0)
+ // {
+ // ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG, "http req failed");
+
+ // break;
+ // }
+ // esp_ota_write(s_ota_handle, flash_buf, read_len);
+ // data_total_size+=read_len;
+ // }
+ // esp_err_t err = esp_ota_end(s_ota_handle);
+ // if(err == ESP_OK)
+ // {
+ // err = esp_ota_set_boot_partition(s_ota_partition);
+ // if(err == ESP_OK)
+ // {
+ // ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG, "OTA success");
+ // vTaskDelay(1000);
+ // esp_restart();
+ // }
+ // }
+ // else {
+ // ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG, "OTA 下载不完整");
+ // }
+ // }
+ ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG, "http req data_total_size:%d\n",data_total_size);
+
if(code == 200 && total_size > 0 && total_size <= (sizeof(common_storage.ssl_cert[cert_type].content)))
{
ESP_LOGI(HTTP_DOWNLOAD_TASK_TAG, "esp_http_client_get_status_code");
uint8_t flash_buf[DOWNLOAD_BLOCK_SIZE] = {0};
uint8_t download_ok = 1;
- // 先清空对应证书存储区
+ // 先清空对应证书存储区
memset(common_storage.ssl_cert[cert_type].content, 0, sizeof(common_storage.ssl_cert[cert_type].content));
common_storage.ssl_cert[cert_type].length = total_size;
crc_download =Crc32_JAMCRC_Cal_Continue(crc_download,flash_buf,read_len);//读出来的数据 和实际读出来的size_len计算crc32校验
// 直接写入 RAM 结构体（分段写）
- printf(HTTP_DOWNLOAD_TASK_TAG, "flash_buf %s crc_download:%08X",flash_buf,crc_download);
+ ESP_LOGI(HTTP_DOWNLOAD_TASK_TAG, "flash_buf %s",flash_buf);
memcpy(common_storage.ssl_cert[cert_type].content + total_read, flash_buf, read_len);
total_read += read_len;
ESP_LOGI(HTTP_TAG, "Cert %d download success, size=%d", cert_type, total_read);
if(crc_value == crc_download)
{
- if(common_storage.net_info.wifi_pwd_len != 0 && common_storage.net_info.wifi_ssid_len != 0)
+
+ ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG, "flash write wifi pwd ssid success: \n");
+ // 写入 Flash（一次性写整个证书，因为已经在 RAM 里了）
+ if (User_Flash_Write_With_Flag(
+ UF_OFFSET_CERT_CLIENT_CRT_ADDR + FLASH_SEC_SIZE * cert_type,
+ UF_OFFSET_CERT_CERT_FLAG,
+ &common_storage.ssl_cert[cert_type],
+ sizeof(SSL_CERT_T)) == ESP_OK)
{
- if(User_Flash_Write_With_Flag(UF_OFFSET_USER_CONFIG_INFO_ADDR, UF_OFFSET_USER_CONFIG_INFO_FLAG, &common_storage.net_info, sizeof(NET_INFO_T)) == ESP_OK)
+ err = ESP_OK;
+ success_bit |= (1 << cert_type);
+ ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG, "flash write cer success: %d\n",common_storage.ssl_cert[cert_type].length);
+ if(User_Flash_Read_Check(UF_OFFSET_CERT_CLIENT_CRT_ADDR+ FLASH_SEC_SIZE * cert_type, UF_OFFSET_CERT_CERT_FLAG, &common_storage.ssl_cert[cert_type], sizeof(SSL_CERT_T)) != ESP_OK)
{
- ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG, "flash write wifi pwd ssid success: \n");
- // 写入 Flash（一次性写整个证书，因为已经在 RAM 里了）
- if (User_Flash_Write_With_Flag(
- UF_OFFSET_CERT_CLIENT_CRT_ADDR + FLASH_SEC_SIZE * cert_type,
- UF_OFFSET_CERT_CERT_FLAG + cert_type,
- &common_storage.ssl_cert[cert_type],
- sizeof(SSL_CERT_T)) == ESP_OK)
- {
- err = ESP_OK;
- success_bit |= (1 << cert_type);
- ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG, "flash write cer success: %d\n",common_storage.ssl_cert[cert_type].length);
- if(User_Flash_Read_Check(UF_OFFSET_CERT_CLIENT_CRT_ADDR, UF_OFFSET_CERT_CERT_FLAG+cert_type, &common_storage.ssl_cert[cert_type], sizeof(SSL_CERT_T)) != ESP_OK)
- {
- common_storage.ssl_cert[cert_type].length = 0;
- ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG,"read cer failed");
- }else{
- ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG,"read client_ssl_cer success");
- }
- }
- else
- {
- ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG, "flash write cer failed:%d\n",cert_type);
- err = ESP_FAIL;
- }
- }
- else{
- ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG, "flash write wifi pwd ssid failed: \n");
- err = ESP_FAIL;
+ common_storage.ssl_cert[cert_type].length = 0;
+ ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG,"read cer failed");
+ }else{
+ ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG,"read client_ssl_cer success");
}
}
- else{
- ESP_LOGI(HTTP_TAG, "device have not ssid or pwd\n");
+ else
+ {
+ ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG, "flash write cer failed:%d\n",cert_type);
+ err = ESP_FAIL;
}
+
}else{
ESP_LOGI(HTTP_TAG, "Cert %d download failed, size=%d", cert_type, total_read);
err = ESP_FAIL;
ESP_LOGI(HTTP_DOWNLOAD_TASK_TAG, "\nrecv data len%d: %s\n", total_size, http_download_cache);
- if(common_storage.ssl_cert[cert_type].length == total_size && memcmp(http_download_cache, common_storage.ssl_cert[cert_type].content, total_size) == 0)
+ if(0)
{
ESP_LOGI(HTTP_DOWNLOAD_TASK_TAG, "cert same: %d", cert_type);
err = ESP_OK;
common_storage.ssl_cert[cert_type].length = total_size;
memset(common_storage.ssl_cert[cert_type].content, 0x00, sizeof(common_storage.ssl_cert[0].content));
memcpy(common_storage.ssl_cert[cert_type].content, http_download_cache, total_size);
+ common_storage.ssl_cert[cert_type].content[total_size] = '\0';
+ for(uint8_t i = 0;i < 10;i++)
+ {
+ ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG,"common_storage. qian 10 ssl_cert[%d].content 0x%x\n",cert_type,common_storage.ssl_cert[cert_type].content[i]);
+ }
+ uint16_t total_size_t = total_size-10;
+
+ ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG, "flash write cer key server_crt success: %d\n", cert_type);
if(common_storage.net_info.wifi_pwd_len != 0 && common_storage.net_info.wifi_ssid_len != 0)
{
if(User_Flash_Write_With_Flag(UF_OFFSET_USER_CONFIG_INFO_ADDR, UF_OFFSET_USER_CONFIG_INFO_FLAG, &common_storage.net_info, sizeof(NET_INFO_T)) == ESP_OK)
//
if(User_Flash_Write_With_Flag(UF_OFFSET_CERT_CLIENT_CRT_ADDR+FLASH_SEC_SIZE*cert_type, UF_OFFSET_CERT_CERT_FLAG, &common_storage.ssl_cert[cert_type], sizeof(SSL_CERT_T)) == ESP_OK)
{
+ err = ESP_OK;
+ success_bit |= (1 << cert_type);
ESP_LOGE(HTTP_DOWNLOAD_TASK_TAG, "flash write cer key server_crt success: %d\n", cert_type);
err = ESP_OK;
+
}
else
{
common_storage.net_info.serial_number_flag = 1;
common_storage.net_info.wifi_info_flag = 1;
#endif
+ #if (NIMBLE_FLOW_MODE)
xEventGroupSetBits(ble_event_group, BLE_OFF_BIT);//关闭蓝牙配网
+ #endif
ESP_LOGI(HTTP_TAG, "download clientcer clientkey mqtt \n");
+ common_setting.mqtt_start_flag = 1;
+ xEventGroupSetBits(common_event_group, COMMON_HTTPS_OTA_BIT);
xEventGroupSetBits(common_event_group, COMMON_MQTT_CONNECT_BIT);
+ // Mqtt_Stack_init();
}
vTaskDelete(NULL);
return;
}
-
+#define HTTP_CONTENT_AMX_LEN 2048
+#define USE_MALLOC_DATA_SIZE 0
+#define HTTP_CHUNK_SIZE 512
+#if USE_MALLOC_DATA_SIZE
+#define MAX_HTTP_OUTPUT_BUFFER 512
+#else
+#define MAX_HTTP_OUTPUT_BUFFER 1024
+#endif
+char output_buffer[MAX_HTTP_OUTPUT_BUFFER+1] = {0};
void http_get_url_task(void *pvParameters)
{
if(common_setting.net_pairing_info.http_url_flag == 0 || common_setting.net_pairing_info.http_token_flag == 0 || common_setting.net_pairing_info.user_id_flag == 0 || common_setting.mcu_info_got_flag == 0 || common_setting.net_pairing_info.http_url_length == 0 || common_setting.net_pairing_info.http_token_length == 0 || common_setting.net_pairing_info.http_url_length > NET_PAIRING_INFO_MAX_LEN || common_setting.net_pairing_info.http_token_length > NET_PAIRING_INFO_MAX_LEN)
{
ESP_LOGI(HTTP_TAG, "param wrong:%d %d %d %d %d %d\n", common_setting.net_pairing_info.http_url_flag, common_setting.net_pairing_info.http_token_flag, common_setting.net_pairing_info.user_id_flag, common_setting.mcu_info_got_flag, common_setting.net_pairing_info.http_url_length, common_setting.net_pairing_info.http_token_length);
vTaskDelete(NULL);
+
return;
}
//
// Get(Send:PID/Get:serialNumber) deviceID
ESP_LOGI(HTTP_TAG, "\nHTTP STEP 1.......GET serialNumber=deviceID.................\n");
esp_http_client_handle_t http_client = NULL;
+ int content_len = 0;
+ int status_code=0;
+ #if (!USE_MALLOC_DATA_SIZE)
+ int data_read=0;
+ #endif
for(uint8_t retry=0;retry<HTTP_RETRY_NUMBER_MAX;retry++)
{
result = 0;
ESP_LOGI(HTTP_TAG, "%s esp_http_client_open...1.....%d %" PRIu32 " bytes",__func__,result,esp_get_free_heap_size());
esp_err_t err = esp_http_client_open(http_client, 0);//开始连接服务器并发送HTTP请求，write_len参数为0表示没有要发送的请求体
ESP_LOGI(HTTP_TAG, "%s esp_http_client_open....2....%d %" PRIu32 " bytes",__func__,result,esp_get_free_heap_size());
+ content_len = 0;
+ status_code=0;
if(err == ESP_OK)
{
int header_ret = esp_http_client_fetch_headers(http_client);//获取HTTP响应头，返回值为响应头的总长度，如果返回值小于0表示获取响应头失败
ESP_LOGI(HTTP_TAG, "esp_http_client_fetch_headers = %d", header_ret);
if (header_ret >= 0)
{
- memset(output_buffer, 0x00, sizeof(output_buffer));
- int data_read = esp_http_client_read_response(http_client, output_buffer, MAX_HTTP_OUTPUT_BUFFER);//读取HTTP响应体，output_buffer为存储响应体的缓冲区，MAX_HTTP_OUTPUT_BUFFER为缓冲区的大小，返回值为实际读取的字节数，如果返回值小于0表示读取响应体失败
- if (data_read >= 0)
+ #if USE_MALLOC_DATA_SIZE
+ status_code = esp_http_client_get_status_code(http_client);//获取HTTP响应状态码，返回值为状态码的整数值，例如200表示请求成功，404表示资源未找到等
+ content_len = esp_http_client_get_content_length(http_client);//获取HTTP响应体的长度，返回值为响应体的字节数，如果返回值小于0表示获取响应体长度失败
+ ESP_LOGI(HTTP_TAG, "http_read_buff malloc is status_code %d content_len %d\n",status_code,content_len);
+ if(status_code == 200)
{
- int status_code = esp_http_client_get_status_code(http_client);//获取HTTP响应状态码，返回值为状态码的整数值，例如200表示请求成功，404表示资源未找到等
- int read_len = esp_http_client_get_content_length(http_client);//获取HTTP响应体的长度，返回值为响应体的字节数，如果返回值小于0表示获取响应体长度失败
- ESP_LOGI(HTTP_TAG, "HTTP GET Status = %d, content_length = %d", status_code, read_len);
+ char *json_buf = malloc(HTTP_CONTENT_AMX_LEN+1);
+ if(json_buf == NULL)
+ {
+ result=2;
+ ESP_LOGI(HTTP_TAG, "http_read_buff malloc is failed\n");
+ }else{
+ int total_read = 0;
+ int read_len;
+ memset(output_buffer, 0, sizeof(output_buffer));
+ // 分段读取，拼到一次性申请的 buffer 里
+ while ((read_len = esp_http_client_read_response(http_client, output_buffer, HTTP_CHUNK_SIZE)) > 0)
+ {
+ if (total_read + read_len > HTTP_CONTENT_AMX_LEN)
+ {
+ break; // 防越界
+ }
+ memcpy(json_buf + total_read, output_buffer, read_len);
+ total_read += read_len;
+ }
+
+ json_buf[total_read] = '\0';
+
+ cJSON* root_base = cJSON_Parse(json_buf);
+ if(root_base != NULL)
+ {
+ cJSON* pData = cJSON_GetObjectItem(root_base,"data");
+ if(pData != NULL)
+ {
+ cJSON* pSerialNumber = cJSON_GetObjectItem(pData,"serialNumber");
+ //get the value
+ if(pSerialNumber != NULL && cJSON_IsString(pSerialNumber))
+ {
+ char* str_serialNumber = pSerialNumber->valuestring;
+ ESP_LOGI(HTTP_TAG, "serialNumber: %s\n", str_serialNumber);
+
+
+ uint8_t serial_number_len = strlen(str_serialNumber);
+ if(serial_number_len == 0)
+ {
+ ESP_LOGI(HTTP_TAG, "serialNumber length is 0\n");
+ cJSON_Delete(root_base);
+ result=2;
+ }else{
+
+ if(serial_number_len > SERIAL_NUMBER_MAX_LEN)
+ {
+ serial_number_len= SERIAL_NUMBER_MAX_LEN;
+ }
+ //临时使用的数据
+ memset(common_setting.net_pairing_info.serial_number, 0x00, SERIAL_NUMBER_MAX_LEN+1);
+ memccpy(common_setting.net_pairing_info.serial_number, str_serialNumber, 0, serial_number_len);
+ common_setting.net_pairing_info.serial_number[serial_number_len] = '\0';
+ common_setting.net_pairing_info.serial_number_length = serial_number_len;
+ common_setting.net_pairing_info.serial_number_flag = 1;
+
+ //真正需要存储的flash数据
+ memset(common_storage.net_info.serial_number, 0x00, SERIAL_NUMBER_MAX_LEN+1);
+ memccpy(common_storage.net_info.serial_number, str_serialNumber, 0, serial_number_len);
+ common_storage.net_info.serial_number[serial_number_len] = '\0';
+ common_storage.net_info.serial_number_flag=1;
+ //保存flash后，
+ if(User_Flash_Write_With_Flag(UF_OFFSET_USER_CONFIG_INFO_ADDR, UF_OFFSET_USER_CONFIG_INFO_FLAG, &common_storage.net_info, sizeof(NET_INFO_T)) == ESP_OK)
+ {
+ ESP_LOGI(HTTP_TAG, "flash write user config info success\n");
+ if(User_Flash_Read_Check(UF_OFFSET_USER_CONFIG_INFO_ADDR, UF_OFFSET_USER_CONFIG_INFO_FLAG, &common_storage.net_info, sizeof(NET_INFO_T)) == ESP_OK)
+ {
+ ESP_LOGI(HTTP_TAG, "read serialNumber: %s\n", common_storage.net_info.serial_number);
+ }
+ result = 1;
+
+ }else
+ {
+ ESP_LOGE(HTTP_TAG, "flash write error\n");
+ result = 2;
+
+ }
+ }
+
+ }
+ else
+ {
+ result = 2;
+ }
+ }
+ else
+ {
+ result = 2;
+ }
+ cJSON_Delete(root_base);
+ }
+ else
+ {
+ result = 2;
+ ESP_LOGI(HTTP_TAG, "root_base is null\n");
+ }
+ if(json_buf)
+ {
+ free(json_buf);
+ json_buf=NULL;
+ }
+ }
+ }
+
+ #else
+ memset(output_buffer, 0, sizeof(output_buffer));
+ data_read=0;
+ data_read = esp_http_client_read_response(http_client, output_buffer, MAX_HTTP_OUTPUT_BUFFER);//读取HTTP响应体，output_buffer为存储响应体的缓冲区，MAX_HTTP_OUTPUT_BUFFER为缓冲区的大小，返回值为实际读取的字节数，如果返回值小于0表示读取响应体失败
+ status_code = esp_http_client_get_status_code(http_client);//获取HTTP响应状态码，返回值为状态码的整数值，例如200表示请求成功，404表示资源未找到等
+ if (data_read > 0 && data_read <= MAX_HTTP_OUTPUT_BUFFER && status_code == 200)
+ {
+
+ content_len = esp_http_client_get_content_length(http_client);//获取HTTP响应体的长度，返回值为响应体的字节数，如果返回值小于0表示获取响应体长度失败
+ ESP_LOGI(HTTP_TAG, "HTTP GET Status = %d, content_length = %d", status_code, content_len);
// ESP_LOG_BUFFER_CHAR(HTTP_TAG, output_buffer, data_read);
ESP_LOGI(HTTP_TAG, "\nrecv data: %s\n", output_buffer);
output_buffer[data_read]='\0';
else
{
result = 2;
+ ESP_LOGI(HTTP_TAG, "data len is too large\n");
}
}
else
result = 2;
ESP_LOGE(HTTP_TAG, "Failed to read response");
}
+ #endif
}
}
if(http_client != NULL){
esp_http_client_set_method(http_client, HTTP_METHOD_GET);
esp_err_t err = esp_http_client_open(http_client, 0);
+
if(err == ESP_OK)
{
+ content_len = 0;
+ status_code=0;
int header_ret = esp_http_client_fetch_headers(http_client);
ESP_LOGI(HTTP_TAG, "esp_http_client_fetch_headers = %d", header_ret);
if (header_ret >= 0)
{
+ #if USE_MALLOC_DATA_SIZE
+ status_code = esp_http_client_get_status_code(http_client);//获取HTTP响应状态码，返回值为状态码的整数值，例如200表示请求成功，404表示资源未找到等
+ content_len = esp_http_client_get_content_length(http_client);//获取HTTP响应体的长度，返回值为响应体的字节数，如果返回值小于0表示获取响应体长度失败
+ ESP_LOGI(HTTP_TAG, "http_read_buff malloc is status_code %d content_len %d\n",status_code,content_len);
+ if(status_code == 200)
+ {
+ char *json_buf = malloc(HTTP_CONTENT_AMX_LEN+1);
+ if(json_buf == NULL)
+ {
+ result=2;
+ ESP_LOGI(HTTP_TAG, "http_read_buff malloc is failed\n");
+ }else{
+ int total_read = 0;
+ int read_len;
+ memset(output_buffer, 0x00, sizeof(output_buffer));
+ // 分段读取，拼到一次性申请的 buffer 里
+ while ((read_len = esp_http_client_read_response(http_client, output_buffer, HTTP_CHUNK_SIZE)) > 0)
+ {
+ if (total_read + read_len > HTTP_CONTENT_AMX_LEN)
+ {
+ break; // 防越界
+ }
+ memcpy(json_buf + total_read, output_buffer, read_len);
+ total_read += read_len;
+ }
+
+ json_buf[total_read] = '\0';
+ ESP_LOGI(HTTP_TAG, "http_read_buff cert data total is failed %d\n",total_read);
+ cJSON* root_base = cJSON_Parse(json_buf);
+ if(root_base != NULL)
+ {
+ cJSON* pData = cJSON_GetObjectItem(root_base,"data");
+ if(pData != NULL)
+ {
+ // cJSON* pDevice_id = cJSON_GetObjectItem(pData,"deviceId");
+ // {
+ // "serialNumber":"PXN1LJ1QUR078E",
+ // "firmwareVersion":1.0,
+ // "status":4,
+ // "rssi":-80,
+ // "clientcrtUrl":"https://pxn-iot.s3.us-east-2.amazonaws.com/iot01/2026/04/02/69ce08f0bfcbe4e5bea9a6a5.crt",
+ // "clientkeyUrl":"https://pxn-iot.s3.us-east-2.amazonaws.com/iot01/2026/04/02/69ce08b3bfcbe4e5bea9a6a4.key",
+ // "mosquittoorgcrtUrl":"https://pxn-iot.s3.us-east-2.amazonaws.com/iot01/2026/04/02/69ce0836bfcbe4e5bea9a6a3.crt",
+ // "mqttUrl":"mqtts://a3l6aw6tvk7fvq-ats.iot.us-east-1.amazonaws.com:8883",
+ // "macAddress":"1",
+ // "pid":"0xA00B"
+ // }
+ pClientCrt = cJSON_GetObjectItem(pData,"clientcrtUrl");
+ pClientkey = cJSON_GetObjectItem(pData,"clientkeyUrl");
+ pServerCrt = cJSON_GetObjectItem(pData,"mosquittoorgcrtUrl");
+ pMqttSubUrl = cJSON_GetObjectItem(pData,"mqttUrl");
+
+ memset(&http_get_cert_task_param.url[SSL_CLIENT_CRT][0], 0x00, sizeof(http_get_cert_task_param.url[SSL_CLIENT_CRT]));
+ memset(&http_get_cert_task_param.url[SSL_CLIENT_KEY][0], 0x00, strlen(http_get_cert_task_param.url[SSL_CLIENT_KEY]));
+ memset(&http_get_cert_task_param.url[SSL_SERVER_CRT][0], 0x00, strlen(http_get_cert_task_param.url[SSL_SERVER_CRT]));
+ //get the value
+ if((pClientCrt != NULL && cJSON_IsString(pClientCrt)) &&
+ (pClientkey != NULL && cJSON_IsString(pClientkey)) &&
+ (pServerCrt != NULL && cJSON_IsString(pServerCrt)) &&
+ (pMqttSubUrl != NULL && cJSON_IsString(pMqttSubUrl)))
+ {
+ ESP_LOGI(HTTP_TAG, "get 证书 mqtt 地址\n");
+ // common_setting.net_pairing_info.device_id = pDevice_id->valueint;
+ // common_setting.net_pairing_info.device_id_flag = 1;
+ result = 1;
+
+ memcpy(&http_get_cert_task_param.url[SSL_CLIENT_CRT][0], pClientCrt->valuestring, strlen((const char*)pClientCrt->valuestring));
+ memcpy(&http_get_cert_task_param.url[SSL_CLIENT_KEY][0], pClientkey->valuestring, strlen((const char*)pClientkey->valuestring));
+ memcpy(&http_get_cert_task_param.url[SSL_SERVER_CRT][0], pServerCrt->valuestring, strlen((const char*)pServerCrt->valuestring));
+
+ uint16_t mqtt_url_len = strlen((const char*)pMqttSubUrl->valuestring);
+ if(mqtt_url_len > MQTT_SUB_URL_MAX_LEN)
+ {
+ mqtt_url_len=MQTT_SUB_URL_MAX_LEN;
+ }
+
+ memset(common_setting.net_pairing_info.mqtt_sub_url, 0x00, sizeof(common_setting.net_pairing_info.mqtt_sub_url));
+ memcpy(common_setting.net_pairing_info.mqtt_sub_url, pMqttSubUrl->valuestring, mqtt_url_len);
+ common_setting.net_pairing_info.mqtt_sub_url_length = mqtt_url_len;
+ common_setting.net_pairing_info.mqtt_sub_url_flag = 1;
+
+
+ memset(common_storage.net_info.mqtt_sub_url, 0x00, sizeof(common_storage.net_info.mqtt_sub_url));
+ memcpy(common_storage.net_info.mqtt_sub_url, pMqttSubUrl->valuestring,mqtt_url_len);
+ common_storage.net_info.mqtt_sub_url[mqtt_url_len]='\0';
+ common_storage.net_info.mqtt_url_len=mqtt_url_len;
+
+ //保存mqtt 地址
+ //UF_OFFSET_USER_CONFIG_INFO_ADDR, UF_OFFSET_USER_CONFIG_INFO_FLAG, &common_storage.net_info, sizeof(NET_INFO_T)) != ESP_OK
+ if(User_Flash_Write_With_Flag(UF_OFFSET_USER_CONFIG_INFO_ADDR, UF_OFFSET_USER_CONFIG_INFO_FLAG, &common_storage.net_info, sizeof(NET_INFO_T)) == ESP_OK)
+ {
+ ESP_LOGE(HTTP_TAG, "flash write mqtt_sub_url success: %s\n",common_storage.net_info.mqtt_sub_url);
+ err = ESP_OK;
+ }
+ else
+ {
+ ESP_LOGE(HTTP_TAG, "flash write mqtt_sub_url fail: %s\n",common_storage.net_info.mqtt_sub_url);
+ err = ESP_FAIL;
+ }
+
+ }
+ else
+ {
+ result = 2;
+ }
+ }
+ else
+ {
+ result = 3;
+ }
+ cJSON_Delete(root_base);
+ }
+ else
+ {
+ result = 4;
+ ESP_LOGI(HTTP_TAG, "root_base is null\n");
+ }
+ if(json_buf)
+ {
+ free(json_buf);
+ json_buf=NULL;
+ }
+ }
+ }
+
+ #else
memset(output_buffer, 0x00, sizeof(output_buffer));
- int data_read = esp_http_client_read_response(http_client, output_buffer, MAX_HTTP_OUTPUT_BUFFER);
- if (data_read >= 0)
+ data_read=0;
+ data_read = esp_http_client_read_response(http_client, output_buffer, MAX_HTTP_OUTPUT_BUFFER);
+ status_code = esp_http_client_get_status_code(http_client);
+ if (data_read > 0 && status_code == 200)
{
- int status_code = esp_http_client_get_status_code(http_client);
+
int read_len = esp_http_client_get_content_length(http_client);
ESP_LOGI(HTTP_TAG, "%s HTTP GET Status = %d, content_length = %d data_read = %d\n",__func__, status_code, read_len,data_read);
// ESP_LOG_BUFFER_CHAR(HTTP_TAG, output_buffer, data_read);
memset(common_storage.net_info.mqtt_sub_url, 0x00, sizeof(common_storage.net_info.mqtt_sub_url));
memcpy(common_storage.net_info.mqtt_sub_url, pMqttSubUrl->valuestring,mqtt_url_len);
+ common_storage.net_info.mqtt_sub_url[mqtt_url_len]='\0';
common_storage.net_info.mqtt_url_len=mqtt_url_len;
+
//保存mqtt 地址
//UF_OFFSET_USER_CONFIG_INFO_ADDR, UF_OFFSET_USER_CONFIG_INFO_FLAG, &common_storage.net_info, sizeof(NET_INFO_T)) != ESP_OK
if(User_Flash_Write_With_Flag(UF_OFFSET_USER_CONFIG_INFO_ADDR, UF_OFFSET_USER_CONFIG_INFO_FLAG, &common_storage.net_info, sizeof(NET_INFO_T)) == ESP_OK)
result = 6;
ESP_LOGE(HTTP_TAG, "Failed to read response");
}
+ #endif
}
}
if(http_client != NULL)
if (header_ret >= 0)
{
memset(output_buffer, 0x00, sizeof(output_buffer));
- int data_read = esp_http_client_read_response(http_client, output_buffer, MAX_HTTP_OUTPUT_BUFFER);
- if (data_read >= 0)
+ data_read=0;
+ data_read = esp_http_client_read_response(http_client, output_buffer, MAX_HTTP_OUTPUT_BUFFER);
+ if (data_read > 0)
{
int status_code = esp_http_client_get_status_code(http_client);
int read_len = esp_http_client_get_content_length(http_client);
void Http_Connect_Status_Check(void)
{
+ // ESP_LOGI(HTTP_TAG, "[APP] Free memory http1 on: %" PRIu32 " bytes", esp_get_free_heap_size());
if((xEventGroupWaitBits(common_event_group, COMMON_HTTP_DOWNLOAD_BIT, pdFALSE, pdFALSE, 0) & COMMON_HTTP_DOWNLOAD_BIT) != 0)
{
xEventGroupClearBits(common_event_group, COMMON_HTTP_DOWNLOAD_BIT);
#include "esp_http_client.h"
-#define MAX_HTTP_OUTPUT_BUFFER 2560
+
#define CONFIG_EXAMPLE_ENABLE_RESPONSE_BUFFER_DUMP 1
typedef struct
ESP_LOGI(IAP_TAG, "unauth\n");
}
- Ble_Pairing_Reply(iap_reply.cmd.cmd1, iap_reply.other.buf, sizeof(iap_reply.other.buf), HOST_TYPE_UART);
+ Uart_Reply(iap_reply.cmd.cmd1, iap_reply.other.buf, sizeof(iap_reply.other.buf), HOST_TYPE_UART);
}
#include "mqtt.h"
static const char *MQTT_TAG = "MQTT";
-
+#define MQTT_TOPIC "sdk/test/python"
#define MQTT_MAX_TRY_CONNECT_TIME 10
static uint8_t retry_connect_cnt = 0;
-// extern const uint8_t client_cert_pem_start[] asm("_binary_client_crt_start");
-// extern const uint8_t client_cert_pem_end[] asm("_binary_client_crt_end");
-// extern const uint8_t client_key_pem_start[] asm("_binary_client_key_start");
-// extern const uint8_t client_key_pem_end[] asm("_binary_client_key_end");
-// extern const uint8_t server_cert_pem_start[] asm("_binary_mosquitto_org_crt_start");
-// extern const uint8_t server_cert_pem_end[] asm("_binary_mosquitto_org_crt_end");
static void log_error_if_nonzero(const char *message, int error_code)
{
* @param event_id The id for the received event.
* @param event_data The data for the event, esp_mqtt_event_handle_t.
*/
+static esp_mqtt_client_handle_t mqtt_client;
+static uint8_t mqtt_init_flag = 0;
+static uint8_t mqtt_send_data_count = 0;
+static uint8_t esp_mqtt_init_flag = 0;
static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
{
ESP_LOGD(MQTT_TAG, "Event dispatched from event loop base=%s, event_id=%" PRIi32, base, event_id);
esp_mqtt_event_handle_t event = event_data;
- esp_mqtt_client_handle_t client = event->client;
+ mqtt_client = event->client;
int msg_id;
switch ((esp_mqtt_event_id_t)event_id) {
case MQTT_EVENT_CONNECTED:
retry_connect_cnt = 0;
+ mqtt_send_data_count=0;
+ common_setting.mqtt_connect_flag=1;
ESP_LOGI(MQTT_TAG, "MQTT_EVENT_CONNECTED");
- // modify
- // msg_id = esp_mqtt_client_subscribe(client, "/topic/qos0", 0);
- // ESP_LOGI(MQTT_TAG, "sent subscribe successful, msg_id=%d", msg_id);
-
- msg_id = esp_mqtt_client_subscribe(client, "sdk/test/python", 0);
+ msg_id = esp_mqtt_client_subscribe(mqtt_client, MQTT_TOPIC, 0);
ESP_LOGI(MQTT_TAG, "sent subscribe successful, msg_id=%d", msg_id);
-
- // msg_id = esp_mqtt_client_subscribe(client, "/topic/qos1", 1);
- // ESP_LOGI(MQTT_TAG, "sent subscribe successful, msg_id=%d", msg_id);
-
- // msg_id = esp_mqtt_client_unsubscribe(client, "/topic/qos1");
- // ESP_LOGI(MQTT_TAG, "sent unsubscribe successful, msg_id=%d", msg_id);
-
break;
case MQTT_EVENT_DISCONNECTED:
- if(common_setting.wifi_status.connect_mode != 3 && ++retry_connect_cnt >= MQTT_MAX_TRY_CONNECT_TIME)
- {
-
- xEventGroupSetBits(common_event_group, COMMON_MQTT_DISCONNECT_BIT);
- }
+ mqtt_send_data_count=0;
+ common_setting.mqtt_connect_flag = 0;
+ // xEventGroupSetBits(common_event_group, COMMON_MQTT_DISCONNECT_BIT);//不能重复关闭 要不然吃内存最后每次不够
ESP_LOGI(MQTT_TAG, "MQTT_EVENT_DISCONNECTED");
break;
case MQTT_EVENT_SUBSCRIBED:
+ mqtt_send_data_count=0;
+ common_setting.mqtt_connect_flag=2;
ESP_LOGI(MQTT_TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
- // modify
- // msg_id = esp_mqtt_client_publish(client, "/topic/qos0", "data", 0, 0, 0);
- msg_id = esp_mqtt_client_publish(client, "sdk/test/python", "good123", 0, 0, 0);
- ESP_LOGI(MQTT_TAG, "sent publish successful, msg_id=%d", msg_id);
+ msg_id = esp_mqtt_client_publish(mqtt_client, "sdk/test/python", "good 456", 0, 0, 0);
+ // ESP_LOGI(MQTT_TAG, "sent publish successful, msg_id=%d", msg_id);
break;
case MQTT_EVENT_UNSUBSCRIBED:
ESP_LOGI(MQTT_TAG, "MQTT_EVENT_DATA");
ESP_LOGI(MQTT_TAG, "TOPIC=%.*s\r\n", event->topic_len, event->topic);
ESP_LOGI(MQTT_TAG, "DATA=%.*s\r\n", event->data_len, event->data);
-
+ Mqtt_Rec_Data(event->topic,event->topic_len,event->data,event->data_len);
// modify
// msg_id = esp_mqtt_client_publish(client, "sdk/test/python", "good 456", 0, 0, 0);
// ESP_LOGI(MQTT_TAG, "sent publish successful, msg_id=%d", msg_id);
break;
}
}
-static uint8_t esp_mqtt_init_flag = 0;
+
+
static esp_err_t Mqtt_App_Init(void)
{
esp_err_t err = ESP_FAIL;
ESP_LOGI(MQTT_TAG, "cert error");
return ESP_FAIL;
}
- if(common_setting.net_pairing_info.mqtt_sub_url_flag == 0 || common_setting.net_pairing_info.mqtt_sub_url_length == 0)
+ if(common_storage.net_info.mqtt_url_len == 0)
{
ESP_LOGI(MQTT_TAG, "mqtt url error");
return ESP_FAIL;
ESP_LOGI(MQTT_TAG, "Mqtt init has been initialized.\n");
return ESP_OK;
}
+ if(common_storage.net_info.mqtt_url_len==0)
+ {
+ ESP_LOGI(MQTT_TAG, "user falsh mqtt_sub_url == 0");
+ return ESP_FAIL;
+ }
+
+ memset(&common_setting.mqtt_cfg, 0, sizeof(common_setting.mqtt_cfg));
retry_connect_cnt = 0;
// common_setting.mqtt_cfg.session.keepalive = 60;
common_setting.mqtt_cfg.network.disable_auto_reconnect = false;
// common_setting.mqtt_cfg.buffer.out_size = 2048;
// common_setting.mqtt_cfg.buffer.size = 2048;
- // ESP_LOGI(MQTT_TAG, "URI: %s", common_setting.net_pairing_info.mqtt_sub_url);
-
- common_setting.mqtt_cfg.broker.address.uri = (const char *)common_setting.net_pairing_info.mqtt_sub_url;
+ ESP_LOGI(MQTT_TAG, "URI: %s %s", common_storage.net_info.mqtt_sub_url,common_setting.net_pairing_info.mqtt_sub_url);
+
+ common_setting.mqtt_cfg.broker.address.uri = (const char *)common_storage.net_info.mqtt_sub_url;
+
common_setting.mqtt_cfg.broker.verification.certificate = (const char *)common_storage.ssl_cert[SSL_SERVER_CRT].content;
common_setting.mqtt_cfg.credentials.authentication.certificate = (const char *)common_storage.ssl_cert[SSL_CLIENT_CRT].content;
common_setting.mqtt_cfg.credentials.authentication.key = (const char *)common_storage.ssl_cert[SSL_CLIENT_KEY].content;
- // common_setting.mqtt_cfg.credentials.client_id = (const char *)common_setting.net_pairing_info.serial_number;
+
common_setting.mqtt_cfg.credentials.client_id = "basicPubSub";
-
+ ESP_LOGI(MQTT_TAG, "Mqtt reset esp_mqtt_client_init 1");
common_setting.mqtt_client_handle = esp_mqtt_client_init(&common_setting.mqtt_cfg);
-
+
+ ESP_LOGI(MQTT_TAG, "Mqtt reset esp_mqtt_client_init 2");
/* The last argument may be used to pass data to the event handler, in this example mqtt_event_handler */
err = esp_mqtt_client_register_event(common_setting.mqtt_client_handle, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL);
if(err == ESP_OK)
return err;
}
+void Mqtt_Send_Data(void)
+{
+ return;
+ int m_id;
+ static uint8_t i=0;
+ char data[10] = {0};
+ if(common_setting.mqtt_connect_flag == 2)
+ {
+
+ if(mqtt_send_data_count >= 2)
+ {
+ mqtt_send_data_count=0;
+
+ i++;
+ if(i >= 255)
+ {
+ i=0;
+ }
+ sprintf(data,"%s%d","good",i);
+ m_id = esp_mqtt_client_publish(mqtt_client, "sdk/test/python", data, 0, 0, 0);
+ ESP_LOGI(MQTT_TAG, "sent publish successful, msg_id=%d %s\n", m_id,data);
+
+ }
+ mqtt_send_data_count++;
+ }
+}
+//接收mqtt发过来的数据
+void Mqtt_Rec_Data(char *topic,int topic_len,char *data,int data_len){
+ if(memcmp(topic,MQTT_TOPIC,topic_len)!=0 || strlen(MQTT_TOPIC) != topic_len)
+ {
+ ESP_LOGI(MQTT_TAG, "主题和订阅的主题不匹配 或者长度不一致 %s %d\n",topic,topic_len);
+ return;
+ }
+ //json数据
+ // 2. 安全打印（必须带长度，不能直接当字符串）
+ ESP_LOGI(MQTT_TAG, "收到合法数据：%.*s", data_len, data);
+
+
+
+ // 现在 data 就是标准C字符串，可以用 cJSON 解析
+ // cJSON_Parse(data);
+}
+
void Mqtt_Connect_Status_Check(void)
{
- if((xEventGroupWaitBits(common_event_group, COMMON_MQTT_CONNECT_BIT, pdFALSE, pdFALSE, 0) & COMMON_MQTT_CONNECT_BIT) != 0)
+ if((xEventGroupWaitBits(common_event_group, COMMON_MQTT_CONNECT_BIT, pdFALSE, pdFALSE, 0) & COMMON_MQTT_CONNECT_BIT) != 0 && common_setting.ble_status.ble_state == 0\
+ && common_setting.wifi_status.wifi_state == 1 && common_setting.https_ota_cfg.https_ota_start_flag == 0)
{
xEventGroupClearBits(common_event_group, COMMON_MQTT_CONNECT_BIT);
vTaskDelay(50 / portTICK_PERIOD_MS);
{
xEventGroupClearBits(common_event_group, COMMON_MQTT_DISCONNECT_BIT);
vTaskDelay(50 / portTICK_PERIOD_MS);
- if(esp_mqtt_client_stop(common_setting.mqtt_client_handle) == ESP_OK)
+
+ if(esp_mqtt_init_flag == 1){
+ if(common_setting.mqtt_client_handle){
+ if(esp_mqtt_client_stop(common_setting.mqtt_client_handle) == ESP_OK)
+ {
+ // esp_mqtt_client_destroy(common_setting.mqtt_client_handle);
+ common_setting.mqtt_client_handle=NULL;
+ retry_connect_cnt = 0;
+ esp_mqtt_init_flag=0;
+ ESP_LOGI(MQTT_TAG, "[APP] Free memory mqtt off: %" PRIu32 " bytes", esp_get_free_heap_size());
+ }
+ else
+ {
+ ESP_LOGI(MQTT_TAG, "Mqtt stop fail");
+ }
+ }
+ }
+
+ }
+
+}
+
+void Mqtt_Connect_Task(void *p)
+{
+ while (1)
+ {
+ if((xEventGroupWaitBits(common_event_group, COMMON_MQTT_CONNECT_BIT, pdFALSE, pdFALSE, 0) & COMMON_MQTT_CONNECT_BIT) != 0 && common_setting.wifi_status.wifi_state == 1 \
+ && common_setting.ble_status.ble_state == 0)
{
- retry_connect_cnt = 0;
- ESP_LOGI(MQTT_TAG, "[APP] Free memory mqtt off: %" PRIu32 " bytes", esp_get_free_heap_size());
+ xEventGroupClearBits(common_event_group, COMMON_MQTT_CONNECT_BIT);
+ vTaskDelay(50 / portTICK_PERIOD_MS);
+ if(Mqtt_App_Init() == ESP_OK)
+ {
+ ESP_LOGI(MQTT_TAG, "[APP] Free memory mqtt on: %" PRIu32 " bytes", esp_get_free_heap_size());
+ }
+ else
+ {
+ ESP_LOGI(MQTT_TAG, "Mqtt init fail");
+ }
}
- else
+
+ if((xEventGroupWaitBits(common_event_group, COMMON_MQTT_DISCONNECT_BIT, pdFALSE, pdFALSE, 0) & COMMON_MQTT_DISCONNECT_BIT) != 0)
{
- ESP_LOGI(MQTT_TAG, "Mqtt stop fail");
+ xEventGroupClearBits(common_event_group, COMMON_MQTT_DISCONNECT_BIT);
+ vTaskDelay(50 / portTICK_PERIOD_MS);
+ if(esp_mqtt_client_stop(common_setting.mqtt_client_handle) == ESP_OK)
+ {
+ retry_connect_cnt = 0;
+ ESP_LOGI(MQTT_TAG, "[APP] Free memory mqtt off: %" PRIu32 " bytes", esp_get_free_heap_size());
+ }
+ else
+ {
+ ESP_LOGI(MQTT_TAG, "Mqtt stop fail");
+ }
}
+ vTaskDelay(10 / portTICK_PERIOD_MS);
}
+
+
}
-
+void Mqtt_Stack_Init(void)
+{
+ if(mqtt_init_flag){
+ return;
+ }
+ mqtt_init_flag=1;
+ ESP_LOGI(MQTT_TAG, "Mqtt_Stack_init 1");
+ mqtt_connect_task_handler = xTaskCreateStatic(Mqtt_Connect_Task, "mqtt_connect_task", MQTT_CONNECT_TASK_STACK, NULL, 2, mqtt_connect_task_stack, &mqtt_connect_task_tcb);
+ ESP_LOGI(MQTT_TAG, "Mqtt_Stack_init 2");
+}
void Mqtt_Connect_Status_Check(void);
-
+void Mqtt_Stack_Init(void);
+void Mqtt_Send_Data(void);
+void Mqtt_Rec_Data(char *topic,int topic_len,char *data,int data_len);
#endif
StackType_t wifi_scan_task_stack[WIFI_SCAN_TASK_STACK];
StaticTask_t wifi_scan_task_tcb;
+// MQTT_LOOP
+TaskHandle_t mqtt_connect_task_handler;
+StackType_t mqtt_connect_task_stack[MQTT_CONNECT_TASK_STACK];
+StaticTask_t mqtt_connect_task_tcb;
+
// HTTP
// TaskHandle_t http_get_url_task_handler;
// StackType_t http_get_url_task_stack[HTTP_GET_URL_TASK_STACK];
//*pub不包含帧头 命令 crcr长度等协议字段，纯数据部分，len为数据部分长度
void Uart_Reply(uint8_t cmd, uint8_t* pbuf, uint16_t len, uint8_t host_type)
{
- if (len > UART_REPLY_MAX_PAYLOAD-4) // 5 = header(1) + cmd(1) + len(2) + crc(1) 暂时len为1个字节
+ if (len > UART_REPLY_MAX_PAYLOAD-3) // 5 = header(1) + cmd(1) + len(1) + crc(1) 暂时len为1个字节
{
ESP_LOGE(COMMON_TAG, "Uart_Reply length too large: %d\n", len);
return;
}
static UART_RECV_DATA_T uart_pairing_reply = { 0 };
- uint8_t header[4] = {FRAMEHEAD_IOT_TO_PANEL, cmd, 0x00, 0x00};
- memcpy(&header[2], &len, 2);
- uart_pairing_reply.size = len + 1 + 1 + 2 + 1; // header(1)+cmd(1)+len(2)+crc(1)
+ uint8_t header[3] = {FRAMEHEAD_IOT_TO_PANEL, cmd, 0x00};
+ memcpy(&header[2], &len, 1);
+ uart_pairing_reply.size = len + 1 + 1 + 1 + 1; // header(1)+cmd(1)+len(1)+crc(1)
- memcpy(uart_pairing_reply.buffer, header, 4);
+ memcpy(uart_pairing_reply.buffer, header, 3);
if (len > 0 && pbuf != NULL)
{
- memcpy(&uart_pairing_reply.buffer[4], pbuf, len);
+ memcpy(&uart_pairing_reply.buffer[3], pbuf, len);
}
- uint8_t crc = Crc8_ROHC_Cal(&uart_pairing_reply.buffer[1], len + 3);
- uart_pairing_reply.buffer[len + 4] = crc;
- ESP_LOGI(COMMON_TAG, "%s crc %02x len %d",__func__, crc, len);
+ uint8_t crc = Crc8_ROHC_Cal(&uart_pairing_reply.buffer[1], len + 2);
+ uart_pairing_reply.buffer[len + 3] = crc;
+ // ESP_LOGI(COMMON_TAG, "%s crc %02x len %d",__func__, crc, len);
xQueueSend(uart_tx_queue_handle, &uart_pairing_reply, 0);
}
void Ble_Pairing_Reply(uint8_t cmd, uint8_t* pbuf, uint16_t len, uint8_t host_type)
{
+ if(common_setting.ble_status.ble_state!=2)
+ {
+ return;
+ }
if (len > NET_PAIRING_REPLY_MAX_PAYLOAD)
{
ESP_LOGE(COMMON_TAG, "Ble_Pairing_Reply length too large: %d\n", len);
{
memcpy(common_setting.mcu_info.product_name, &data[12], name_len);
common_setting.mcu_info.product_name[name_len] = '\0'; // 确保字符串结尾
+ common_setting.mcu_info.product_name_len = name_len;
+ common_setting.mcu_info_got_flag = 1;
+ Esp_Check_Mcu_Info_Flag();//开启蓝牙配网
}
else
{
name_len = 0;
}
}
- common_setting.mcu_info.product_name_len = name_len;
- common_setting.mcu_info_got_flag = 1;
+
}
}
break;
{
if(data[3] == 1) // 停止配网
{
- common_setting.net_pairing_info.http_url_flag = 0;
- common_setting.net_pairing_info.http_token_flag = 0;
- common_setting.net_pairing_info.user_id_flag = 0;
+ // common_setting.net_pairing_info.http_url_flag = 0;
+ // common_setting.net_pairing_info.http_token_flag = 0;
+ // common_setting.net_pairing_info.user_id_flag = 0;
}
}
memcpy(common_setting.wifi_status.cur_pwd, wifi_pwd, wifi_pwd_len);
common_setting.wifi_status.cur_pwd[wifi_pwd_len]='\0';
ESP_LOGI(COMMON_TAG, "%s wifi ssid len: %d\n",__func__, wifi_ssid_len);
-
+
memset(common_storage.net_info.wifi_ssid,0,32);
common_storage.net_info.wifi_ssid_len=wifi_ssid_len;
-
memcpy(common_storage.net_info.wifi_ssid, wifi_ssid, wifi_ssid_len);
+
memset(common_storage.net_info.wifi_pwd,0,64);
memcpy(common_storage.net_info.wifi_pwd, wifi_pwd, wifi_pwd_len);
common_storage.net_info.wifi_pwd_len=wifi_pwd_len;
+
common_storage.net_info.wifi_info_flag=1;
+ //保存flash后，
+ if(User_Flash_Write_With_Flag(UF_OFFSET_USER_CONFIG_INFO_ADDR, UF_OFFSET_USER_CONFIG_INFO_FLAG, &common_storage.net_info, sizeof(NET_INFO_T)) == ESP_OK)
+ {
+ ESP_LOGI(COMMON_TAG, "%s save wifi pwd success: %d\n",__func__, wifi_ssid_len);
+ }else{
+ ESP_LOGI(COMMON_TAG, "%s save wifi pwd failed: %d\n",__func__, wifi_ssid_len);
+ }
ESP_LOG_BUFFER_CHAR(COMMON_TAG, common_setting.wifi_status.cur_ssid, wifi_ssid_len);
ESP_LOGI(COMMON_TAG, "%s wifi pwd len: %d\n",__func__, wifi_pwd_len);
ESP_LOGI(COMMON_TAG, "%s wifi flag: %d %d %d\n",__func__,common_setting.net_pairing_info.http_url_flag, common_setting.net_pairing_info.http_token_flag, common_setting.net_pairing_info.user_id_flag);
- if(common_setting.net_pairing_info.http_url_flag && common_setting.net_pairing_info.http_token_flag && common_setting.net_pairing_info.user_id_flag)
+ //if(common_setting.net_pairing_info.http_url_flag && common_setting.net_pairing_info.http_token_flag && common_setting.net_pairing_info.user_id_flag)
+
+ if(common_setting.net_pairing_info.http_url_flag && common_setting.net_pairing_info.http_token_flag)
{
if(data[4] == 0)
{
http_end=1;
memset(common_setting.net_pairing_info.http_url, 0x00, NET_PAIRING_INFO_MAX_LEN);
net_pairing_reply.content[5] |= 0x20;
+ common_setting.net_pairing_info.http_url_flag = 0;
ESP_LOGI(COMMON_TAG, "%s CRC错误: 计算=%04x 接收=%04x\n",__func__, calc_crc, packet_crc);
}
}
token_end=1;
memset(common_setting.net_pairing_info.http_token, 0x00, NET_PAIRING_INFO_MAX_LEN);
net_pairing_reply.content[5] |= 0x20;
+ common_setting.net_pairing_info.http_token_flag = 0;
ESP_LOGI(COMMON_TAG, "%s CRC错误: 计算=%04x 接收=%04x",__func__, calc_crc, packet_crc);
}
}
else
{
common_setting.net_pairing_info.user_id=0;
+ common_setting.net_pairing_info.user_id_flag = 0;
// 校验失败
net_pairing_reply.content[5] |= 0x20;
ESP_LOGI(COMMON_TAG, "%s BLE user id crc16 err:%04x %04x\n", __func__,packet_crc, calc_crc);
if(data[4] == 1) // 停止配网
{
// common_setting.net_pairing_info.net_pair_cooldown = 0;
- common_setting.net_pairing_info.http_url_flag = 0;
- common_setting.net_pairing_info.http_token_flag = 0;
- common_setting.net_pairing_info.user_id_flag = 0;
+ // common_setting.net_pairing_info.http_url_flag = 0;
+ // common_setting.net_pairing_info.http_token_flag = 0;
+ // common_setting.net_pairing_info.user_id_flag = 0;
net_pairing_reply.content[0] = 1;//0成功 1失败
net_pairing_reply.content[1] = data[4]; //1停止配网
net_pairing_reply.len = 2;
if (len < 5) break;
if(data[4] == 1) // 开启蓝牙配网
{
- xEventGroupSetBits(ble_event_group, BLE_ON_BIT);
+ if(common_setting.ble_status.ble_state == 0){
+ xEventGroupSetBits(ble_event_group, BLE_ON_BIT);
+ }
+
ESP_LOGI(COMMON_TAG, "%s ble on by app\n",__func__);
}
else if(data[4] == 0) // 关闭蓝牙配网
ESP_LOG_BUFFER_CHAR(COMMON_TAG, common_setting.wifi_status.cur_ssid, 32);
ESP_LOGI(COMMON_TAG, "%s wifi test len: %d\n",__func__, 64);
ESP_LOG_BUFFER_CHAR(COMMON_TAG, common_setting.wifi_status.cur_pwd, 64);
- common_setting.net_pairing_info.http_url_flag=1;
- common_setting.net_pairing_info.http_token_flag=1;
- common_setting.net_pairing_info.user_id_flag=1;
- common_setting.ble_status.ble_state=0;//
- xEventGroupSetBits(ble_event_group, BLE_ON_BIT);//打开蓝牙配网
+ // common_setting.net_pairing_info.http_url_flag=1;
+ // common_setting.net_pairing_info.http_token_flag=1;
+ // common_setting.net_pairing_info.user_id_flag=1;
Wifi_Queue_Send(HOST_TYPE_BLE,1,0);
break;
{
//发送调试数据不需要crc校验
ESP_LOGI(COMMON_TAG, "%s no need checkcrc recv %d bytes:cmd %0x",__func__,len, data[1]);
- // ESP_LOG_BUFFER_HEX(COMMON_TAG, data, len);
- // BLE_SEND_REPLY_T net_pairing_reply = {0};
- // memset(&net_pairing_reply, 0x00, sizeof(BLE_SEND_REPLY_T));
- // char wifi_ssid[10+1] = {0};
- // char wifi_pwd[15+1] = {0};
- // switch (data[1])
- // {
- // case 0xFE://fe + cmd+cmd1+dataLen+data+crc8
- // {
+ ESP_LOG_BUFFER_HEX(COMMON_TAG, data, len);
+ BLE_SEND_REPLY_T net_pairing_reply = {0};
+ memset(&net_pairing_reply, 0x00, sizeof(BLE_SEND_REPLY_T));
+ char wifi_ssid[10+1] = {0};
+ char wifi_pwd[15+1] = {0};
+ switch (data[1])
+ {
+ case 0xFE://fe + cmd+cmd1+dataLen+data+crc8
+ {
- // switch (data[4])
- // {
- // case 0x01://调试app下发wifi名称和密码重新连接新的wifi,不需要加密
- // //调试指令
- // if (len < 20)
- // {
- // ESP_LOGW(COMMON_TAG, "APP 0xFE len too short %u", len);
- // break;
- // }
- // memcpy(wifi_ssid, &data[5], 10);
- // wifi_ssid[10] = '\0';
- // memcpy(wifi_pwd, &data[15], 15);
- // wifi_pwd[15] = '\0';
- // common_setting.wifi_status.cur_ssid_len = 10;
- // memcpy(common_setting.wifi_status.cur_ssid, wifi_ssid, 10);
- // common_setting.wifi_status.cur_pwd_len = 15;
- // memcpy(common_setting.wifi_status.cur_pwd, wifi_pwd, 15);
- // ESP_LOGI(COMMON_TAG, "wifi ssid len: %d", 10);
- // ESP_LOG_BUFFER_CHAR(COMMON_TAG, common_setting.wifi_status.cur_ssid, 10);
- // ESP_LOGI(COMMON_TAG, "wifi pwd len: %d", 15);
- // ESP_LOG_BUFFER_CHAR(COMMON_TAG, common_setting.wifi_status.cur_pwd, 15);
- // ESP_LOGI(COMMON_TAG, "wifi test start");
- // Wifi_Queue_Send(host_type, 1, 0);
- // /* code */
- // break;
+ switch (data[4])
+ {
+ case 0x01://调试app下发wifi名称和密码重新连接新的wifi,不需要加密
+ //调试指令
+ if (len < 20)
+ {
+ ESP_LOGW(COMMON_TAG, "APP 0xFE len too short %u", len);
+ break;
+ }
+ memcpy(wifi_ssid, &data[5], 10);
+ wifi_ssid[10] = '\0';
+ memcpy(wifi_pwd, &data[15], 15);
+ wifi_pwd[15] = '\0';
+ common_setting.wifi_status.cur_ssid_len = 10;
+ memcpy(common_setting.wifi_status.cur_ssid, wifi_ssid, 10);
+ common_setting.wifi_status.cur_pwd_len = 15;
+ memcpy(common_setting.wifi_status.cur_pwd, wifi_pwd, 15);
+ ESP_LOGI(COMMON_TAG, "wifi ssid len: %d", 10);
+ ESP_LOG_BUFFER_CHAR(COMMON_TAG, common_setting.wifi_status.cur_ssid, 10);
+ ESP_LOGI(COMMON_TAG, "wifi pwd len: %d", 15);
+ ESP_LOG_BUFFER_CHAR(COMMON_TAG, common_setting.wifi_status.cur_pwd, 15);
+ ESP_LOGI(COMMON_TAG, "wifi test start");
+ Wifi_Queue_Send(host_type, 1, 0);
+ /* code */
+ break;
- // default:
- // break;
- // }
+ default:
+ break;
+ }
- // }
- // break;
+ }
+ break;
- // default:
- // break;
- // }
+ default:
+ break;
+ }
}
}
+#include "esp_chip_info.h"
+//获取模组的芯片型号
+static const char *CHIP_LOG = "CHIP_TAG";
+void print_chip_info(void)
+{
+ // 定义 + 获取芯片信息
+ esp_chip_info_t chip_info;
+ esp_chip_info(&chip_info);
+
+ // 打印型号（数字 → 转成文字）
+ const char *chip_name = "Unknown";
+ switch(chip_info.model) {
+ case CHIP_ESP32: chip_name = "ESP32"; break;
+ case CHIP_ESP32S2: chip_name = "ESP32-S2"; break;
+ case CHIP_ESP32S3: chip_name = "ESP32-S3"; break;
+ case CHIP_ESP32C2: chip_name = "ESP32-C2"; break;
+ case CHIP_ESP32C3: chip_name = "ESP32-C3"; break;
+ case CHIP_ESP32C6: chip_name = "ESP32-C6"; break;
+ case CHIP_ESP32H2: chip_name = "ESP32-H2"; break;
+ case CHIP_ESP32P4: chip_name = "ESP32-P4"; break;
+ case CHIP_ESP32C61: chip_name = "ESP32-C61"; break;
+ case CHIP_POSIX_LINUX: chip_name = "POSIX_LINUX"; break;
+ default:
+ break;
+ }
+ // 最终清晰打印
+ ESP_LOGI(CHIP_LOG, "======================================");
+ ESP_LOGI(CHIP_LOG, "芯片型号: %s", chip_name);
+ ESP_LOGI(CHIP_LOG, "芯片版本: 0x%04x", chip_info.revision);
+ ESP_LOGI(CHIP_LOG, "核心数量: %d", chip_info.cores);
+ ESP_LOGI(CHIP_LOG, "======================================");
+}
\ No newline at end of file
// Project
#define FW_VERSION (0x0001) // 固件版本
-#define BUILD_VERSION (0x0004) // 编译测试版本
+#define BUILD_VERSION (0x0005) // 编译测试版本
#define DEVICE_VID (0x36E6) // 设备厂商代码
#define DEVICE_PID (0xEC01) // 设备型号代码
#define LWIP_LOCAL_HOSTNAME "PXN-Device" // WIFI本地主机名称
#define FW_HEADER_CODE_SIZE 12
#define FW_HEADER_CODE "WGTL_ESP32C2"
#define IOT_ENABLE 1
-#define USER_TEST_ENABLE 1
+#define USER_TEST_ENABLE 0
#define BLE_TEST_WIFI_CONNECT_ENABLE 1//BLE下发wifixin不需要做htttp token user_id校验
#define IS_CLOSE_BLE 0 //是否关闭蓝牙广播暂时测试不关闭 一直广播
-
+#define NIMBLE_FLOW_MODE 0 //1连上wifi不关闭蓝牙配网 直接请求http 0连上wifi关闭配网 再请求http为了节省空间
+#define OPEN_HTTPS_OTA_FUNC 0 //是否开启HTTPS_OTA升级
#define WIFI_SSID_MAX_LEN 32
#define WIFI_PWD_MAX_LEN 64
/**************** Task ****************/
// extern TaskHandle_t http_download_crt_task_handler;
// extern StackType_t http_download_crt_task_stack[HTTP_DOWNLOAD_CRT_TASK_STACK];
// extern StaticTask_t http_download_crt_task_tcb;
+// WIFI
+
+#define MQTT_CONNECT_TASK_STACK (0)
+extern TaskHandle_t mqtt_connect_task_handler;
+extern StackType_t mqtt_connect_task_stack[MQTT_CONNECT_TASK_STACK];
+extern StaticTask_t mqtt_connect_task_tcb;
#define NET_PAIRING_INFO_MAX_LEN 256
#define SERIAL_NUMBER_MAX_LEN 32
COMMON_HTTP_DOWNLOAD_BIT = BIT1,
COMMON_MQTT_CONNECT_BIT = BIT2,
COMMON_MQTT_DISCONNECT_BIT = BIT3,
+ COMMON_MQTT_INIT_BIT = BIT4,
+ COMMON_HTTPS_OTA_BIT = BIT5,
}COMMON_EVENT_GROUP_BIT_E;
typedef enum
typedef struct
{
uint8_t ble_state; // 0:关闭 1:广播 2:已连接
+ uint8_t nimble_flag;//1打开配网 0关闭配网
}__attribute__((packed)) BLE_STATUS_T;
typedef struct
uint32_t user_id;
char mqtt_sub_url[MQTT_SUB_URL_MAX_LEN+1];
}__attribute__((packed)) NET_PAIR_INFO_T;
-
+typedef struct
+{
+ uint8_t https_ota_start_flag;//需要升级1 0不需要升级
+
+
+}__attribute__((packed)) HTTPS_OTA_CONFIG_INFO_T;
typedef struct
{
uint8_t heart_beat_enable:1;
uint8_t mcu_info_got_flag:1;
uint8_t reserved:6;
-
+ uint8_t mqtt_start_flag;
+ uint8_t mqtt_connect_flag;
// UNIVERSAL
uint32_t heart_beat_interval; // ms
MCU_INFO_T mcu_info;
// MQTT
esp_mqtt_client_config_t mqtt_cfg;
esp_mqtt_client_handle_t mqtt_client_handle;
+
+ HTTPS_OTA_CONFIG_INFO_T https_ota_cfg;
}COMMON_SETTING_T;
#define WIFI_QUEUE_LENGTH 2
//寻找分区表
partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_ANY, PARA_FLASH_NAME);
assert(partition != NULL);
-
+ // User_Flash_Erase(UF_OFFSET_USER_CONFIG_INFO_ADDR,FLASH_SEC_SIZE);
if(User_Flash_Read_Check(UF_OFFSET_USER_CONFIG_INFO_ADDR, UF_OFFSET_USER_CONFIG_INFO_FLAG, &common_storage.net_info, sizeof(NET_INFO_T)) != ESP_OK)
{
printf("%s read common_storage failed\n",__func__);
common_storage.net_info.wifi_info_flag = 0;
common_storage.net_info.device_id_flag = 0;
common_storage.net_info.serial_number_flag=0;
-
+ memset(&common_storage.net_info,0x00,sizeof(NET_INFO_T));
}else{
- printf("%s read serialNumber %s\n",__func__,common_storage.net_info.serial_number);
+ printf("%s read serialNumber %s %d wifi_info_flag:%d\n",__func__,common_storage.net_info.serial_number,common_storage.net_info.serial_number_flag,common_storage.net_info.wifi_info_flag);
}
-
- if(User_Flash_Read_Check(UF_OFFSET_CERT_CLIENT_CRT_ADDR, UF_OFFSET_CERT_CERT_FLAG+SSL_CLIENT_CRT, &common_storage.ssl_cert[SSL_CLIENT_CRT], sizeof(SSL_CERT_T)) != ESP_OK)
+ // User_Flash_Erase(UF_OFFSET_CERT_CLIENT_CRT_ADDR,FLASH_SEC_SIZE);
+ memset(&common_storage.ssl_cert[SSL_CLIENT_CRT].content,0x00,sizeof(common_storage.ssl_cert[SSL_CLIENT_CRT].content));
+ if(User_Flash_Read_Check(UF_OFFSET_CERT_CLIENT_CRT_ADDR, UF_OFFSET_CERT_CERT_FLAG, &common_storage.ssl_cert[SSL_CLIENT_CRT], sizeof(SSL_CERT_T)) != ESP_OK)
{
common_storage.ssl_cert[SSL_CLIENT_CRT].length = 0;
- printf("%s read client_ssl_cer failed\n",__func__);
+ memset(&common_storage.ssl_cert[SSL_CLIENT_CRT].content,0x00,sizeof(common_storage.ssl_cert[SSL_CLIENT_CRT].content));
+ printf(" read client_ssl_cer failed\n");
}else{
- printf("%s read client_ssl_cer success %d\n",__func__,common_storage.ssl_cert[SSL_CLIENT_CRT].length);
+ printf("read client_ssl_cer success 0 %d\n",common_storage.ssl_cert[SSL_CLIENT_CRT].length);
+
}
- if(User_Flash_Read_Check(UF_OFFSET_CERT_CLIENT_KEY_ADDR, UF_OFFSET_CERT_CERT_FLAG+SSL_CLIENT_KEY, &common_storage.ssl_cert[SSL_CLIENT_KEY], sizeof(SSL_CERT_T)) != ESP_OK)
+ // User_Flash_Erase(UF_OFFSET_CERT_CLIENT_KEY_ADDR,FLASH_SEC_SIZE);
+ memset(&common_storage.ssl_cert[SSL_CLIENT_KEY].content,0x00,sizeof(common_storage.ssl_cert[SSL_CLIENT_KEY].content));
+ if(User_Flash_Read_Check(UF_OFFSET_CERT_CLIENT_KEY_ADDR, UF_OFFSET_CERT_CERT_FLAG, &common_storage.ssl_cert[SSL_CLIENT_KEY], sizeof(SSL_CERT_T)) != ESP_OK)
{
common_storage.ssl_cert[SSL_CLIENT_KEY].length = 0;
- printf("%s read client_ssl_cer_key failed\n",__func__);
+ printf("read client_ssl_cer_key failed\n");
+ memset(&common_storage.ssl_cert[SSL_CLIENT_KEY].content,0x00,sizeof(common_storage.ssl_cert[SSL_CLIENT_KEY].content));
}
else{
- printf("%s read client_ssl_cer success %d\n",__func__,common_storage.ssl_cert[SSL_CLIENT_KEY].length);
+ printf("read client_ssl_cer success 1 %d\n",common_storage.ssl_cert[SSL_CLIENT_KEY].length);
+
}
- if(User_Flash_Read_Check(UF_OFFSET_CERT_SERVER_CRT_ADDR, UF_OFFSET_CERT_CERT_FLAG+SSL_CLIENT_KEY, &common_storage.ssl_cert[SSL_SERVER_CRT], sizeof(SSL_CERT_T)) != ESP_OK)
+ // User_Flash_Erase(UF_OFFSET_CERT_SERVER_CRT_ADDR,FLASH_SEC_SIZE);
+ memset(&common_storage.ssl_cert[SSL_SERVER_CRT].content,0x00,sizeof(common_storage.ssl_cert[SSL_SERVER_CRT].content));
+ if(User_Flash_Read_Check(UF_OFFSET_CERT_SERVER_CRT_ADDR, UF_OFFSET_CERT_CERT_FLAG, &common_storage.ssl_cert[SSL_SERVER_CRT], sizeof(SSL_CERT_T)) != ESP_OK)
{
common_storage.ssl_cert[SSL_SERVER_CRT].length = 0;
- printf("%s read server_ssl_cer failed\n",__func__);
+ memset(&common_storage.ssl_cert[SSL_SERVER_CRT].content,0x00,sizeof(common_storage.ssl_cert[SSL_SERVER_CRT].content));
+ printf("read server_ssl_cer failed\n");
}else{
- printf("%s read client_ssl_cer success %d\n",__func__,common_storage.ssl_cert[SSL_CLIENT_KEY].length);
+ printf("read client_ssl_cer success 2 %d\n",common_storage.ssl_cert[SSL_SERVER_CRT].length);
+
}
}
esp_err_t User_Flash_Write_With_Flag(uint32_t addr, uint32_t flag, void* data, uint16_t size);
esp_err_t User_Flash_Read_Check(uint32_t addr, uint32_t flag, void* buf, uint16_t size);
-
+esp_err_t User_Flash_Erase(size_t offset, size_t size);
#endif
*/
#include <string.h>
#include "project_common.h"
-
+#include "esp_https_ota.h"
+#include "https_ota.h"
// #include "freertos/FreeRTOS.h"
// #include "freertos/task.h"
// #include "freertos/event_groups.h"
SemaphoreHandle_t wifi_scan_mutex;
-
//获取wifi的rssi事件处理函数
static void esp_bss_rssi_low_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data)
{
static void event_handler(void* arg, esp_event_base_t event_base,
int32_t event_id, void* event_data)
{
- ESP_LOGE(WIFI_TAG, "event_handler %" PRId32 "\n", event_id);
+ // ESP_LOGE(WIFI_TAG, "event_handler %" PRId32 "\n", event_id);
if(event_base == WIFI_EVENT)
{
switch(event_id)
{
case WIFI_EVENT_STA_START:
{
- if(common_setting.ble_status.ble_state > 0)//只有蓝牙开启才能连接wifi，其他情况不连接wifi，除非重启设备或者app下发wifi信息重新配网
+ if(1)//
{
esp_wifi_connect();
common_setting.wifi_status.wifi_state = 0;
s_retry_num = 0;
common_setting.wifi_status.wifi_state = 1;
Wifi_Connect_Timerout_Stop();//连接成功了就关闭定时器
+ #if OPEN_HTTPS_OTA_FUNC
+ if(!common_setting.ble_status.nimble_flag && common_setting.mqtt_start_flag == 1) //在配网状态下还不能ota升级只有配完网之后 有证书 wifi密码
+ {
+ xEventGroupSetBits(common_event_group, COMMON_HTTPS_OTA_BIT);
+ }
+
+ #endif
+ #if NIMBLE_FLOW_MODE
xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
+ #else
+ ESP_LOGI(WIFI_TAG, "got common_setting.ble_status.nimble_flag:%d",common_setting.ble_status.nimble_flag);
+ if(common_setting.ble_status.nimble_flag)//在配网状态不是普通wifi连接
+ {
+ //要先关闭配网再发送ble数据
+ ESP_LOGI(WIFI_TAG, "start http get put1 :\n");
+ xEventGroupSetBits(ble_event_group, BLE_OFF_BIT);
+ ESP_LOGI(WIFI_TAG, "start http get put2 :\n");
+ xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
+ }
+ else{
+ ESP_LOGI(WIFI_TAG, "start http get common_setting.wifi_status.connect_mode %d\n",common_setting.wifi_status.connect_mode);
+ if(common_setting.wifi_status.connect_mode == 3 || common_setting.mqtt_start_flag == 1)//已经连过一次了
+ {
+ xEventGroupSetBits(common_event_group, COMMON_MQTT_CONNECT_BIT);
+ }
+ }
+ #endif
+
+
esp_wifi_set_rssi_threshold(WIFI_RSSI_THRESHOLD);
}
break;
}
}
+ else if (event_base == ESP_HTTPS_OTA_EVENT) {
+ switch (event_id) {
+ case ESP_HTTPS_OTA_START:
+ ESP_LOGI(WIFI_TAG, "OTA started");
+ break;
+ case ESP_HTTPS_OTA_CONNECTED:
+ ESP_LOGI(WIFI_TAG, "Connected to server");
+ break;
+ case ESP_HTTPS_OTA_GET_IMG_DESC:
+ ESP_LOGI(WIFI_TAG, "Reading Image Description");
+ break;
+ case ESP_HTTPS_OTA_VERIFY_CHIP_ID:
+ ESP_LOGI(WIFI_TAG, "Verifying chip id of new image: %d", *(esp_chip_id_t *)event_data);
+ break;
+ case ESP_HTTPS_OTA_DECRYPT_CB:
+ ESP_LOGI(WIFI_TAG, "Callback to decrypt function");
+ break;
+ case ESP_HTTPS_OTA_WRITE_FLASH:
+ ESP_LOGI(WIFI_TAG, "Writing to flash: %d written", *(int *)event_data);
+ break;
+ case ESP_HTTPS_OTA_UPDATE_BOOT_PARTITION:
+ ESP_LOGI(WIFI_TAG, "Boot partition updated. Next Partition: %d", *(esp_partition_subtype_t *)event_data);
+ break;
+ case ESP_HTTPS_OTA_FINISH:
+ ESP_LOGI(WIFI_TAG, "OTA finish");
+ break;
+ case ESP_HTTPS_OTA_ABORT:
+ ESP_LOGI(WIFI_TAG, "OTA abort");
+ break;
+ }
+ }
}
void Wifi_Sta_Init(void)
NULL,
&instance_got_ip));
+ ESP_ERROR_CHECK(esp_event_handler_register(ESP_HTTPS_OTA_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
+
ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_BSS_RSSI_LOW, &esp_bss_rssi_low_handler, NULL));
// wifi_config_t wifi_config = {
// Stop and delete the timer if it's still running
wifi_one_timer_flag = 0;
esp_timer_stop(wifi_one_timer_handle);
- esp_timer_delete(wifi_one_timer_handle);
-
}
}
void Wifi_Start(void)
// memcpy(common_setting.wifi_config.sta.password, "PXN201807", 10);
// memcpy(common_setting.wifi_config.sta.ssid, "ChinaNet-LaDe", 13);
// memcpy(common_setting.wifi_config.sta.password, "9596w3wq", 9);
+ ESP_LOGI(WIFI_TAG, "[APP] Free memory wifi len on: %d %d\n",common_setting.wifi_status.cur_ssid_len,common_setting.wifi_status.cur_pwd_len);
+ if(common_setting.wifi_status.cur_ssid_len == 0 || common_setting.wifi_status.cur_pwd_len == 0)
+ {
+ ESP_LOGI(WIFI_TAG, "[APP] Free memory not wifi on: %" PRIu32 " bytes", esp_get_free_heap_size());
+ return;
+ }
memcpy(common_setting.wifi_config.sta.ssid, common_setting.wifi_status.cur_ssid, common_setting.wifi_status.cur_ssid_len);
memcpy(common_setting.wifi_config.sta.password, common_setting.wifi_status.cur_pwd, common_setting.wifi_status.cur_pwd_len);
xSemaphoreGive(wifi_scan_mutex);
common_setting.wifi_status.wifi_mode = 0;
common_setting.wifi_status.wifi_state = 0;
- common_setting.net_pairing_info.http_url_flag = 0;
- common_setting.net_pairing_info.http_token_flag = 0;
- common_setting.net_pairing_info.user_id_flag = 0;
+ // common_setting.net_pairing_info.http_url_flag = 0;
+ // common_setting.net_pairing_info.http_token_flag = 0;
+ // common_setting.net_pairing_info.user_id_flag = 0;
}
}
bits_last = (bits&(WIFI_CONNECTED_BIT | WIFI_FAIL_BIT));
if (bits & WIFI_CONNECTED_BIT)
{
- ESP_LOGI(WIFI_TAG, "wifi connected\n");
-
+ ESP_LOGI(WIFI_TAG, "wifi connected %d\n",common_setting.wifi_status.connect_mode);
+
+ #if (!OPEN_HTTPS_OTA_FUNC)
if((common_setting.wifi_status.connect_mode == 1 || common_setting.wifi_status.connect_mode == 2))
{
-
static BLE_SEND_REPLY_T wifi_pairing_reply={0};
wifi_pairing_reply.send_flag = 1;
wifi_pairing_reply.cmd = 0x15;
wifi_pairing_reply.content[1] = common_setting.wifi_status.connect_mode-1;
wifi_pairing_reply.content[2] = common_setting.wifi_status.net_pair_encrypt_profile;
Check_Host_Type(wifi_pairing_reply.cmd, wifi_pairing_reply.content, wifi_pairing_reply.len, common_setting.wifi_status.net_pair_host);
+ ESP_LOGI(WIFI_TAG, "connect_modeCheck_Host_Type\n");
Wifi_Connect_Timerout_Stop();//关闭定时器
if (USER_TEST_ENABLE)
{
// memcpy(&http_get_cert_task_param.url[SSL_SERVER_CRT][0], "https://e-pxn.com.cn/pms/api/mosquitto.org.crt", 47);
// http_download_crt_task_handler = xTaskCreateStatic(http_download_task, "http_download_task", HTTP_DOWNLOAD_CRT_TASK_STACK, NULL, 2, http_download_crt_task_stack, &http_download_crt_task_tcb);
}
+
}
-
-
- // if(common_setting.mqtt_client_handle != NULL)
- // {
- // // esp_mqtt_client_start(common_setting.mqtt_client_handle);
- // }
+ #else
+ https_ota_task();
+ #endif
}
else if (bits & WIFI_FAIL_BIT)
{
wifi_pairing_reply.content[2] = common_setting.wifi_status.net_pair_encrypt_profile;
Check_Host_Type(wifi_pairing_reply.cmd, wifi_pairing_reply.content, wifi_pairing_reply.len, common_setting.wifi_status.net_pair_host);
}
- // if(common_setting.mqtt_client_handle != NULL)
- // {
- // // esp_mqtt_client_stop(common_setting.mqtt_client_handle);
- // }
}
else
{
projects / mirrors / mqtt_wglt.git / commitdiff