Mirror/squeezelite-esp32
1
0
Fork 0
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2025-12-06 11:36:59 +03:00
Code Issues Packages Projects Releases Wiki Activity

Store certificates in NVS, bug fixes - release

Browse Source
This commit is contained in:
Sebastien
2019-11-22 16:37:53 -05:00
parent 29242c63b9
commit 6fd80f0ff4
11 changed files with 408 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
components/squeezelite-ota/component.mk
View File

@@ -10,4 +10,4 @@ COMPONENT_EXTRA_INCLUDES += $(PROJECT_PATH)/main/
COMPONENT_EXTRA_INCLUDES += $(PROJECT_PATH)/components/tools
CFLAGS += -D LOG_LOCAL_LEVEL=ESP_LOG_INFO -DCONFIG_OTA_ALLOW_HTTP=1
#CFLAGS += -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG -DCONFIG_OTA_ALLOW_HTTP=1
COMPONENT_EMBED_TXTFILES := ${PROJECT_PATH}/server_certs/github.pem

279
components/squeezelite-ota/squeezelite-ota.c
View File

@@ -14,7 +14,6 @@
#include "esp_system.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_ota_ops.h"
#include "esp_https_ota.h"
#include "string.h"
#include <stdbool.h>
@@ -28,20 +27,17 @@
#include <time.h>
#include <sys/time.h>
#include <stdarg.h>
#include "esp_image_format.h"
#include "esp_secure_boot.h"
#include "esp_flash_encrypt.h"
#include "esp_spi_flash.h"
#include "sdkconfig.h"
#include "esp_ota_ops.h"
extern const char * get_certificate();
static const char *TAG = "squeezelite-ota";
extern const uint8_t server_cert_pem_start[] asm("_binary_github_pem_start");
extern const uint8_t server_cert_pem_end[] asm("_binary_github_pem_end");
char * cert=NULL;
char * ota_write_data = NULL;
esp_http_client_handle_t ota_http_client = NULL;
#define IMAGE_HEADER_SIZE sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t) + sizeof(esp_app_desc_t) + 1
#define BUFFSIZE 4096
#define HASH_LEN 32 /* SHA-256 digest length */
@@ -53,7 +49,6 @@ static struct {
uint32_t ota_total_len;
char * redirected_url;
char * current_url;
bool bRedirectFound;
bool bOTAStarted;
bool bInitialized;
uint8_t lastpct;
@@ -67,14 +62,14 @@ static esp_http_client_config_t ota_config;
extern void wifi_manager_refresh_ota_json();
void RECOVERY_IRAM_FUNCTION _printMemStats(){
void _printMemStats(){
ESP_LOGD(TAG,"Heap internal:%zu (min:%zu) external:%zu (min:%zu)",
heap_caps_get_free_size(MALLOC_CAP_INTERNAL),
heap_caps_get_minimum_free_size(MALLOC_CAP_INTERNAL),
heap_caps_get_free_size(MALLOC_CAP_SPIRAM),
heap_caps_get_minimum_free_size(MALLOC_CAP_SPIRAM));
}
void RECOVERY_IRAM_FUNCTION triggerStatusJsonRefresh(bool bDelay,const char * status, ...){
void triggerStatusJsonRefresh(bool bDelay,const char * status, ...){
va_list args;
va_start(args, status);
vsnprintf(ota_status.status_text,sizeof(ota_status.status_text)-1,status, args);
@@ -86,13 +81,12 @@ void RECOVERY_IRAM_FUNCTION triggerStatusJsonRefresh(bool bDelay,const char * st
vTaskDelay(200 / portTICK_PERIOD_MS); // wait here for a short amount of time. This will help with refreshing the UI status
ESP_LOGD(TAG,"Done holding task...");
}
else
{
else {
ESP_LOGI(TAG,"%s",ota_status.status_text);
taskYIELD();
}
}
const char * RECOVERY_IRAM_FUNCTION ota_get_status(){
const char * ota_get_status(){
if(!ota_status.bInitialized)
{
memset(ota_status.status_text, 0x00,sizeof(ota_status.status_text));
@@ -100,12 +94,12 @@ const char * RECOVERY_IRAM_FUNCTION ota_get_status(){
}
return ota_status.status_text;
}
uint8_t RECOVERY_IRAM_FUNCTION ota_get_pct_complete(){
uint8_t ota_get_pct_complete(){
return ota_status.ota_total_len==0?0:
(uint8_t)((float)ota_status.ota_actual_len/(float)ota_status.ota_total_len*100.0f);
}
static void __attribute__((noreturn)) RECOVERY_IRAM_FUNCTION task_fatal_error(void)
static void __attribute__((noreturn)) task_fatal_error(void)
{
ESP_LOGE(TAG, "Exiting task due to fatal error...");
(void)vTaskDelete(NULL);
@@ -115,7 +109,7 @@ static void __attribute__((noreturn)) RECOVERY_IRAM_FUNCTION task_fatal_error(vo
}
}
#define FREE_RESET(p) if(p!=NULL) { free(p); p=NULL; }
esp_err_t RECOVERY_IRAM_FUNCTION _http_event_handler(esp_http_client_event_t *evt)
esp_err_t _http_event_handler(esp_http_client_event_t *evt)
{
// --------------
// Received parameters
@@ -159,7 +153,6 @@ esp_err_t RECOVERY_IRAM_FUNCTION _http_event_handler(esp_http_client_event_t *ev
FREE_RESET(ota_status.redirected_url);
ota_status.redirected_url=strdup(evt->header_value);
ESP_LOGW(TAG,"OTA will redirect to url: %s",ota_status.redirected_url);
ota_status.bRedirectFound= true;
}
if (strcasecmp(evt->header_key, "content-length") == 0) {
ota_status.ota_total_len = atol(evt->header_value);
@@ -170,19 +163,6 @@ esp_err_t RECOVERY_IRAM_FUNCTION _http_event_handler(esp_http_client_event_t *ev
if(!ota_status.bOTAStarted) {
ESP_LOGD(TAG, "HTTP_EVENT_ON_DATA, status_code=%d, len=%d",esp_http_client_get_status_code(evt->client), evt->data_len);
}
else if(ota_status.bOTAStarted && esp_http_client_get_status_code(evt->client) == 200 ){
ota_status.ota_actual_len+=evt->data_len;
if(ota_get_pct_complete()%5 == 0) ota_status.newpct = ota_get_pct_complete();
if(ota_status.lastpct!=ota_status.newpct )
{
gettimeofday(&tv, NULL);
uint32_t elapsed_ms= (tv.tv_sec-ota_status.OTA_start.tv_sec )*1000+(tv.tv_usec-ota_status.OTA_start.tv_usec)/1000;
ESP_LOGI(TAG,"OTA progress : %d/%d (%d pct), %d KB/s", ota_status.ota_actual_len, ota_status.ota_total_len, ota_status.newpct, elapsed_ms>0?ota_status.ota_actual_len*1000/elapsed_ms/1024:0);
wifi_manager_refresh_ota_json();
ota_status.lastpct=ota_status.newpct;
}
}
break;
case HTTP_EVENT_ON_FINISH:
ESP_LOGD(TAG, "HTTP_EVENT_ON_FINISH");
@@ -194,17 +174,23 @@ esp_err_t RECOVERY_IRAM_FUNCTION _http_event_handler(esp_http_client_event_t *ev
return ESP_OK;
}
esp_err_t RECOVERY_IRAM_FUNCTION init_config(const char * url){
esp_err_t init_config(char * url){
memset(&ota_config, 0x00, sizeof(ota_config));
ota_config.cert_pem =cert==NULL?(char *)server_cert_pem_start:cert;
ota_status.bInitialized = true;
triggerStatusJsonRefresh(true,"Initializing...");
if(url==NULL || strlen(url)==0){
ESP_LOGE(TAG,"HTTP OTA called without a url");
return ESP_FAIL;
}
ota_status.current_url= url;
ota_config.cert_pem =get_certificate();
ota_config.event_handler = _http_event_handler;
ota_config.buffer_size = BUFFSIZE;
ota_config.disable_auto_redirect=true;
//conf->disable_auto_redirect=false;
//ota_config.disable_auto_redirect=true;
ota_config.disable_auto_redirect=false;
ota_config.skip_cert_common_name_check = false;
ota_config.url = strdup(url);
ota_config.max_redirection_count = 0;
ota_config.max_redirection_count = 3;
//ota_write_data = heap_caps_malloc(ota_config.buffer_size+1 , MALLOC_CAP_INTERNAL);
ota_write_data = malloc(ota_config.buffer_size+1);
if(ota_write_data== NULL){
@@ -213,7 +199,7 @@ esp_err_t RECOVERY_IRAM_FUNCTION init_config(const char * url){
}
return ESP_OK;
}
esp_partition_t * RECOVERY_IRAM_FUNCTION _get_ota_partition(esp_partition_subtype_t subtype){
esp_partition_t * _get_ota_partition(esp_partition_subtype_t subtype){
esp_partition_t *ota_partition=NULL;
ESP_LOGI(TAG, "Looking for OTA partition.");
@@ -237,7 +223,7 @@ esp_partition_t * RECOVERY_IRAM_FUNCTION _get_ota_partition(esp_partition_subtyp
esp_err_t RECOVERY_IRAM_FUNCTION _erase_last_boot_app_partition(esp_partition_t *ota_partition)
esp_err_t _erase_last_boot_app_partition(esp_partition_t *ota_partition)
{
uint16_t num_passes=0;
uint16_t remain_size=0;
@@ -270,26 +256,21 @@ esp_err_t RECOVERY_IRAM_FUNCTION _erase_last_boot_app_partition(esp_partition_t
err=esp_partition_erase_range(ota_partition, i*single_pass_size, single_pass_size);
if(err!=ESP_OK) return err;
// triggerStatusJsonRefresh(i%10==0?true:false,"Erasing flash (%u/%u)",i,num_passes);
if(i%10) {
if(i%2) {
triggerStatusJsonRefresh(false,"Erasing flash (%u/%u)",i,num_passes);
}
taskYIELD();
vTaskDelay(200/ portTICK_PERIOD_MS); // wait here for a short amount of time. This will help with reducing WDT errors
}
if(remain_size>0){
err=esp_partition_erase_range(ota_partition, ota_partition->size-remain_size, remain_size);
if(err!=ESP_OK) return err;
}
triggerStatusJsonRefresh(false,"Erasing flash (100%%)");
triggerStatusJsonRefresh(true,"Erasing flash complete.");
taskYIELD();
return ESP_OK;
}
static void RECOVERY_IRAM_FUNCTION http_cleanup(esp_http_client_handle_t client)
{
esp_http_client_close(client);
esp_http_client_cleanup(client);
}
static bool RECOVERY_IRAM_FUNCTION process_again(int status_code)
static bool process_again(int status_code)
{
switch (status_code) {
case HttpStatus_MovedPermanently:
@@ -301,7 +282,7 @@ static bool RECOVERY_IRAM_FUNCTION process_again(int status_code)
}
return false;
}
static esp_err_t RECOVERY_IRAM_FUNCTION _http_handle_response_code(esp_http_client_handle_t http_client, int status_code)
static esp_err_t _http_handle_response_code(esp_http_client_handle_t http_client, int status_code)
{
esp_err_t err;
if (status_code == HttpStatus_MovedPermanently || status_code == HttpStatus_Found) {
@@ -341,7 +322,7 @@ static esp_err_t RECOVERY_IRAM_FUNCTION _http_handle_response_code(esp_http_clie
return err;
}
static esp_err_t RECOVERY_IRAM_FUNCTION _http_connect(esp_http_client_handle_t http_client)
static esp_err_t _http_connect(esp_http_client_handle_t http_client)
{
esp_err_t err = ESP_FAIL;
int status_code, header_ret;
@@ -361,6 +342,9 @@ static esp_err_t RECOVERY_IRAM_FUNCTION _http_connect(esp_http_client_handle_t h
ESP_LOGD(TAG, "HTTP Header fetch completed, found content length of %d",header_ret);
status_code = esp_http_client_get_status_code(http_client);
ESP_LOGD(TAG, "HTTP status code was %d",status_code);
err = _http_handle_response_code(http_client, status_code);
if (err != ESP_OK) {
return err;
@@ -368,39 +352,51 @@ static esp_err_t RECOVERY_IRAM_FUNCTION _http_connect(esp_http_client_handle_t h
} while (process_again(status_code));
return err;
}
void ota_task_cleanup(const char * message, ...){
ota_status.bOTAThreadStarted=false;
if(message!=NULL){
void RECOVERY_IRAM_FUNCTION ota_task(void *pvParameter)
va_list args;
va_start(args, message);
triggerStatusJsonRefresh(true,message, args);
va_end(args);
ESP_LOGE(TAG, "%s",ota_status.status_text);
}
FREE_RESET(ota_status.redirected_url);
FREE_RESET(ota_status.current_url);
FREE_RESET(ota_write_data);
if(ota_http_client!=NULL) {
esp_http_client_cleanup(ota_http_client);
ota_http_client=NULL;
}
ota_status.bOTAStarted = false;
task_fatal_error();
}
void ota_task(void *pvParameter)
{
char * passedURL=(char *)pvParameter;
esp_err_t err = ESP_OK;
int status_code, header_ret;
size_t buffer_size = BUFFSIZE;
ESP_LOGD(TAG, "HTTP ota Thread started");
const esp_partition_t *configured = esp_ota_get_boot_partition();
const esp_partition_t *running = esp_ota_get_running_partition();
const esp_partition_t * update_partition = esp_ota_get_next_update_partition(NULL);
ESP_LOGI(TAG, "esp_ota_get_next_update_partition returned : partition [%s] subtype %d at offset 0x%x",
update_partition->label, update_partition->subtype, update_partition->address);
if (configured != running) {
ESP_LOGW(TAG, "Configured OTA boot partition at offset 0x%08x, but running from offset 0x%08x",
configured->address, running->address);
ESP_LOGW(TAG, "Configured OTA boot partition at offset 0x%08x, but running from offset 0x%08x", configured->address, running->address);
ESP_LOGW(TAG, "(This can happen if either the OTA boot data or preferred boot image become corrupted somehow.)");
}
ESP_LOGI(TAG, "Running partition type %d subtype %d (offset 0x%08x)",
running->type, running->subtype, running->address);
ESP_LOGI(TAG, "Running partition [%s] type %d subtype %d (offset 0x%08x)", running->label, running->type, running->subtype, running->address);
_printMemStats();
ota_status.bInitialized = true;
ESP_LOGD(TAG, "HTTP ota Thread started");
triggerStatusJsonRefresh(true,"Initializing...");
ota_status.bRedirectFound=false;
if(passedURL==NULL || strlen(passedURL)==0){
ESP_LOGE(TAG,"HTTP OTA called without a url");
triggerStatusJsonRefresh(true,"Error: Updating needs a URL!");
ota_status.bOTAThreadStarted=false;
FREE_RESET(ota_write_data);
vTaskDelete(NULL);
return ;
ESP_LOGI(TAG,"Initializing OTA configuration");
err = init_config(pvParameter);
if(err!=ESP_OK){
ota_task_cleanup("Error: Failed to initialize OTA.");
return;
}
ota_status.current_url= strdup(passedURL);
FREE_RESET(pvParameter);
/* Locate and erase ota application partition */
ESP_LOGW(TAG,"**************** Expecting WATCHDOG errors below during flash erase. This is OK and not to worry about **************** ");
@@ -408,75 +404,44 @@ void RECOVERY_IRAM_FUNCTION ota_task(void *pvParameter)
esp_partition_t *ota_partition = _get_ota_partition(ESP_PARTITION_SUBTYPE_APP_OTA_0);
if(ota_partition == NULL){
ESP_LOGE(TAG,"Unable to locate OTA application partition. ");
FREE_RESET(ota_status.current_url);
FREE_RESET(ota_write_data);
triggerStatusJsonRefresh(true,"Error: OTA application partition not found. (%s)",esp_err_to_name(err));
ota_status.bOTAThreadStarted=false;
vTaskDelete(NULL);
ota_task_cleanup("Error: OTA application partition not found. (%s)",esp_err_to_name(err));
return;
}
_printMemStats();
err=_erase_last_boot_app_partition(ota_partition);
if(err!=ESP_OK){
ESP_LOGE(TAG,"Unable to erase last APP partition. (%s)",esp_err_to_name(err));
FREE_RESET(ota_status.current_url);
FREE_RESET(ota_status.redirected_url);
triggerStatusJsonRefresh(true,"Error: Unable to erase last APP partition. (%s)",esp_err_to_name(err));
ota_status.bOTAThreadStarted=false;
FREE_RESET(ota_write_data);
vTaskDelete(NULL);
ota_task_cleanup("Error: Unable to erase last APP partition. (%s)",esp_err_to_name(err));
return;
}
_printMemStats();
ESP_LOGI(TAG,"Initializing http client configuration");
if(init_config(ota_status.bRedirectFound?ota_status.redirected_url:ota_status.current_url)!=ESP_OK){
ESP_LOGE(TAG, "Failed to initialise HTTP configuration");
triggerStatusJsonRefresh(true,"Error: Failed to initialize OTA.");
ota_status.bOTAThreadStarted=false;
FREE_RESET(ota_write_data);
task_fatal_error();
}
_printMemStats();
ota_status.bOTAStarted = true;
triggerStatusJsonRefresh(true,"Starting OTA...");
esp_http_client_handle_t client = esp_http_client_init(&ota_config);
if (client == NULL) {
ESP_LOGE(TAG, "Failed to initialise HTTP connection");
triggerStatusJsonRefresh(true,"Error: Failed to initialize HTTP connection.");
ota_status.bOTAThreadStarted=false;
FREE_RESET(ota_write_data);
task_fatal_error();
ota_http_client = esp_http_client_init(&ota_config);
if (ota_http_client == NULL) {
ota_task_cleanup("Error: Failed to initialize HTTP connection.");
return;
}
_printMemStats();
// Open the http connection and follow any redirection
err = _http_connect(client);
err = _http_connect(ota_http_client);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed start http read: %s", esp_err_to_name(err));
triggerStatusJsonRefresh(true,"Error: HTTP Start read failed. (%s)",esp_err_to_name(err));
ota_status.bOTAThreadStarted=false;
esp_http_client_cleanup(client);
FREE_RESET(ota_write_data);
task_fatal_error();
ota_task_cleanup("Error: HTTP Start read failed. (%s)",esp_err_to_name(err));
return;
}
_printMemStats();
// update_partition = esp_ota_get_next_update_partition(NULL);
// ESP_LOGI(TAG, "Writing to partition subtype %d at offset 0x%x",
// update_partition->subtype, update_partition->address);
// assert(update_partition != NULL);
esp_ota_handle_t update_handle = 0 ;
int binary_file_length = 0;
/*deal with all receive packet*/
bool image_header_was_checked = false;
while (1) {
int data_read = esp_http_client_read(client, ota_write_data, buffer_size);
int data_read = esp_http_client_read(ota_http_client, ota_write_data, buffer_size);
if (data_read < 0) {
ESP_LOGE(TAG, "Error: SSL data read error");
triggerStatusJsonRefresh(true,"Error: Data read error");
ota_status.bOTAThreadStarted=false;
http_cleanup(client);
FREE_RESET(ota_write_data);
task_fatal_error();
ota_task_cleanup("Error: Data read error");
return;
} else if (data_read > 0) {
if (image_header_was_checked == false) {
esp_app_desc_t new_app_info;
@@ -490,11 +455,11 @@ void RECOVERY_IRAM_FUNCTION ota_task(void *pvParameter)
ESP_LOGI(TAG, "Running recovery version: %s", running_app_info.version);
}
// const esp_partition_t* last_invalid_app = esp_ota_get_last_invalid_partition();
// esp_app_desc_t invalid_app_info;
// if (esp_ota_get_partition_description(last_invalid_app, &invalid_app_info) == ESP_OK) {
// ESP_LOGI(TAG, "Last invalid firmware version: %s", invalid_app_info.version);
// }
const esp_partition_t* last_invalid_app = esp_ota_get_last_invalid_partition();
esp_app_desc_t invalid_app_info;
if (esp_ota_get_partition_description(last_invalid_app, &invalid_app_info) == ESP_OK) {
ESP_LOGI(TAG, "Last invalid firmware version: %s", invalid_app_info.version);
}
// check current version with last invalid partition
// if (last_invalid_app != NULL) {
@@ -502,15 +467,12 @@ void RECOVERY_IRAM_FUNCTION ota_task(void *pvParameter)
// ESP_LOGW(TAG, "New version is the same as invalid version.");
// ESP_LOGW(TAG, "Previously, there was an attempt to launch the firmware with %s version, but it failed.", invalid_app_info.version);
// ESP_LOGW(TAG, "The firmware has been rolled back to the previous version.");
// http_cleanup(client);
// infinite_loop();
// ota_task_cleanup("esp_ota_begin failed (%s)", esp_err_to_name(err));
// }
// }
if (memcmp(new_app_info.version, running_app_info.version, sizeof(new_app_info.version)) == 0) {
ESP_LOGW(TAG, "Current running version is the same as a new.");
// http_cleanup(client);
// infinite_loop();
}
image_header_was_checked = true;
@@ -518,33 +480,33 @@ void RECOVERY_IRAM_FUNCTION ota_task(void *pvParameter)
// Call OTA Begin with a small partition size - this drives the erase operation which was already done;
err = esp_ota_begin(ota_partition, 512, &update_handle);
if (err != ESP_OK) {
ESP_LOGE(TAG, "esp_ota_begin failed (%s)", esp_err_to_name(err));
http_cleanup(client);
FREE_RESET(ota_write_data);
task_fatal_error();
}
else {
ESP_LOGI(TAG, "esp_ota_begin succeeded");
ota_task_cleanup("esp_ota_begin failed (%s)", esp_err_to_name(err));
return;
}
ESP_LOGD(TAG, "esp_ota_begin succeeded");
} else {
ESP_LOGE(TAG, "received package is not fit len");
triggerStatusJsonRefresh(true,"Error: Binary file too large for the current partition");
ota_status.bOTAThreadStarted=false;
http_cleanup(client);
FREE_RESET(ota_write_data);
task_fatal_error();
ota_task_cleanup("Error: Binary file too large for the current partition");
return;
}
}
err = esp_ota_write( update_handle, (const void *)ota_write_data, data_read);
if (err != ESP_OK) {
triggerStatusJsonRefresh(true,"Error: OTA Partition write failure. (%s)",esp_err_to_name(err));
ota_status.bOTAThreadStarted=false;
http_cleanup(client);
FREE_RESET(ota_write_data);
task_fatal_error();
ota_task_cleanup("Error: OTA Partition write failure. (%s)",esp_err_to_name(err));
return;
}
binary_file_length += data_read;
ESP_LOGD(TAG, "Written image length %d", binary_file_length);
ota_status.ota_actual_len=binary_file_length;
if(ota_get_pct_complete()%5 == 0) ota_status.newpct = ota_get_pct_complete();
if(ota_status.lastpct!=ota_status.newpct ) {
gettimeofday(&tv, NULL);
uint32_t elapsed_ms= (tv.tv_sec-ota_status.OTA_start.tv_sec )*1000+(tv.tv_usec-ota_status.OTA_start.tv_usec)/1000;
ESP_LOGI(TAG,"OTA progress : %d/%d (%d pct), %d KB/s", ota_status.ota_actual_len, ota_status.ota_total_len, ota_status.newpct, elapsed_ms>0?ota_status.ota_actual_len*1000/elapsed_ms/1024:0);
triggerStatusJsonRefresh(true,"Downloading & writing update.");
ota_status.lastpct=ota_status.newpct;
}
taskYIELD();
} else if (data_read == 0) {
ESP_LOGI(TAG, "Connection closed");
break;
@@ -553,40 +515,29 @@ void RECOVERY_IRAM_FUNCTION ota_task(void *pvParameter)
ESP_LOGI(TAG, "Total Write binary data length: %d", binary_file_length);
if (ota_status.ota_total_len != binary_file_length) {
ESP_LOGE(TAG, "Error in receiving complete file");
triggerStatusJsonRefresh(true,"Error: Error in receiving complete file");
ota_status.bOTAThreadStarted=false;
http_cleanup(client);
FREE_RESET(ota_write_data);
task_fatal_error();
ota_task_cleanup("Error: Error in receiving complete file");
return;
}
_printMemStats();
err = esp_ota_end(update_handle);
if (err != ESP_OK) {
ESP_LOGE(TAG, "esp_ota_end failed (%s)!", esp_err_to_name(err));
triggerStatusJsonRefresh(true,"Error: %s",esp_err_to_name(err));
ota_status.bOTAThreadStarted=false;
http_cleanup(client);
FREE_RESET(ota_write_data);
task_fatal_error();
}
ota_task_cleanup("Error: %s",esp_err_to_name(err));
return;
}
_printMemStats();
err = esp_ota_set_boot_partition(ota_partition);
if (err == ESP_OK) {
ESP_LOGI(TAG,"OTA Process completed successfully!");
triggerStatusJsonRefresh(true,"Success!");
vTaskDelay(1500/ portTICK_PERIOD_MS); // wait here to give the UI a chance to refresh
esp_restart();
} else {
triggerStatusJsonRefresh(true,"Error: %s",esp_err_to_name(err));
wifi_manager_refresh_ota_json();
ESP_LOGE(TAG, "Unable to set boot partition. %s", esp_err_to_name(err));
ota_status.bOTAThreadStarted=false;
ota_task_cleanup("Error: Unable to update boot partition [%s]",esp_err_to_name(err));
return;
}
FREE_RESET(ota_status.current_url);
FREE_RESET(ota_status.redirected_url);
FREE_RESET(ota_write_data);
vTaskDelete(NULL);
ota_task_cleanup(NULL);
return;
}
esp_err_t process_recovery_ota(const char * bin_url){

20
components/squeezelite-ota/squeezelite-ota.h
View File

@@ -7,6 +7,9 @@
#pragma once
#include "esp_attr.h"
#include "esp_image_format.h"
#include "esp_ota_ops.h"
#if RECOVERY_APPLICATION
#define CODE_RAM_LOCATION
#define RECOVERY_IRAM_FUNCTION IRAM_ATTR
@@ -17,10 +20,21 @@
// ERASE BLOCK needs to be a multiple of wear leveling's sector size
#define OTA_FLASH_ERASE_BLOCK (uint32_t)512000
#define OTA_STACK_SIZE 5120
// ERASE BLOCK needs to be a multiple of sector size. If a different multiple is passed
// the OTA process will adjust. Here, we need to strike the balance between speed and
// stability. The larger the blocks, the faster the erase will be, but the more likely
// the system will throw WDT while the flash chip is locked and the more likely
// the OTA process will derail
#define OTA_FLASH_ERASE_BLOCK (uint32_t)249856
// We're running the OTA without squeezelite in the background, so we can set a comfortable
// amount of stack to avoid overflows.
#define OTA_STACK_SIZE 10240
// To speed up processing, we set this priority to a number that is higher than normal
// tasks
#define OTA_TASK_PRIOTITY 6
esp_err_t start_ota(const char * bin_url);
const char * ota_get_status();
uint8_t ota_get_pct_complete();