During the firmware upgrade process of the ESP32, the HTTPS transmission rate often becomes a key factor limiting upgrade efficiency. Based on actual test data, traditional HTTPS upgrade methods exhibit the following typical issues:
- • Slow transmission rate: A 1MB firmware takes about 90 seconds
- • High memory usage: The SSL handshake and encryption/decryption processes consume a large amount of RAM
- • Unstable network: Fluctuations in WiFi signal lead to transmission interruptions
- • High failure rate: Verification errors are likely to occur during the transmission of large files
Performance Bottleneck Analysis
// Typical process of traditional HTTPS upgrade
esp_err_t traditional_https_ota_update(const char* url) {
// 1. SSL handshake - consumes a lot of time and memory
esp_http_client_config_t config = {
.url = url,
.cert_pem = server_cert_pem_start,
.timeout_ms = 30000, // 30 seconds timeout
};
// 2. Chunked download - size limit for each chunk
esp_http_client_handle_t client = esp_http_client_init(&config);
esp_http_client_set_header(client, "Range", "bytes=0-1023"); // 1KB chunk
// 3. Validate chunk by chunk - frequent validation operations
while (received_size < total_size) {
esp_http_client_fetch_headers(client);
esp_http_client_read(client, buffer, 1024);
// Validate each chunk
verify_chunk(buffer, 1024);
}
}HTTPS Transmission Mechanism
ESP32 HTTPS Architecture
The HTTPS implementation of ESP32 is based on the mbedTLS library, and its transmission architecture is as follows:
Application Layer (HTTP Client)
↓
Transport Layer (TCP + TLS/SSL)
↓
Network Layer (WiFi + TCP/IP)
↓
Hardware Layer (ESP32 WiFi + Crypto Engine)Key Performance Parameters
| Parameter | Default Value | Optimization Suggestions | Impact |
| TCP Window Size | 4KB | 16KB-32KB | Network Throughput |
| SSL Buffer | 2KB | 8KB-16KB | Encryption Efficiency |
| HTTP Chunk Size | 1KB | 4KB-8KB | Transmission Efficiency |
| Timeout | 30s | 60s-120s | Stability |
Memory Usage Analysis
// ESP32 HTTPS memory usage
typedef struct {
uint8_t ssl_buffer[8192]; // SSL buffer
uint8_t tcp_buffer[4096]; // TCP buffer
uint8_t http_buffer[2048]; // HTTP buffer
uint8_t crypto_workspace[1024]; // Encryption workspace
} https_memory_usage_t;Transmission Rate Optimization Strategies
Network Layer Optimization
TCP Parameter Tuning
// Optimize TCP parameter configuration
esp_err_t optimize_tcp_parameters(void) {
// Set TCP window size
esp_wifi_set_ps(WIFI_PS_NONE); // Disable power-saving mode
// Configure TCP parameters
struct tcp_pcb* pcb = tcp_new();
tcp_nagle_disable(pcb); // Disable Nagle's algorithm
tcp_snd_buf = 32768; // Send buffer 32KB
tcp_wnd = 65535; // Receive window 64KB
return ESP_OK;
}WiFi Connection Optimization
// Optimize WiFi connection quality
esp_err_t optimize_wifi_connection(void) {
wifi_config_t wifi_config = {
.sta = {
.threshold.authmode = WIFI_AUTH_WPA2_PSK,
.pmf_cfg = {
.capable = true,
.required = false
},
},
};
// Set WiFi power
esp_wifi_set_max_tx_power(84); // Maximum transmission power
// Configure channel bandwidth
esp_wifi_set_bandwidth(WIFI_IF_STA, WIFI_BW_HT40);
return ESP_OK;
}SSL/TLS Layer Optimization
Encryption Algorithm Selection
// Select high-performance cipher suites
const char* optimized_cipher_suites[] = {
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256", // Recommended
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384", // Alternative
"TLS_RSA_WITH_AES_128_CBC_SHA", // Compatible
};
esp_err_t configure_ssl_ciphers(esp_http_client_handle_t client) {
mbedtls_ssl_conf_ciphersuites(&ssl_conf, optimized_cipher_suites);
return ESP_OK;
}SSL Session Resumption
// Implement SSL session resumption
typedef struct {
mbedtls_ssl_session session;
char hostname[64];
uint32_t timestamp;
} ssl_session_cache_t;
static ssl_session_cache_t session_cache[4];
esp_err_t reuse_ssl_session(const char* hostname, mbedtls_ssl_context* ssl) {
for (int i = 0; i < 4; i++) {
if (strcmp(session_cache[i].hostname, hostname) == 0 &&
(esp_timer_get_time() - session_cache[i].timestamp) < 300000000) { // 5 minutes
mbedtls_ssl_set_session(ssl, &session_cache[i].session);
return ESP_OK;
}
}
return ESP_FAIL;
}HTTP Layer Optimization
Chunked Transfer Optimization
// Optimize chunked transfer strategy
esp_err_t optimized_chunked_transfer(esp_http_client_handle_t client) {
// Set larger transfer chunks
esp_http_client_set_header(client, "Accept-Encoding", "gzip, deflate");
esp_http_client_set_header(client, "Connection", "keep-alive");
// Use range requests
char range_header[64];
snprintf(range_header, sizeof(range_header), "bytes=%d-%d",
current_offset, current_offset + CHUNK_SIZE - 1);
esp_http_client_set_header(client, "Range", range_header);
return ESP_OK;
}Concurrent Transfer
// Multi-connection concurrent transfer
#define MAX_CONCURRENT_CONNECTIONS 3
typedef struct {
esp_http_client_handle_t client;
int start_offset;
int end_offset;
bool active;
} concurrent_connection_t;
esp_err_t concurrent_download(const char* url, size_t file_size) {
concurrent_connection_t connections[MAX_CONCURRENT_CONNECTIONS];
size_t chunk_size = file_size / MAX_CONCURRENT_CONNECTIONS;
// Create multiple concurrent connections
for (int i = 0; i < MAX_CONCURRENT_CONNECTIONS; i++) {
connections[i].start_offset = i * chunk_size;
connections[i].end_offset = (i + 1) * chunk_size - 1;
connections[i].active = true;
// Start concurrent download task
xTaskCreate(download_chunk_task, "chunk_task", 8192,
&connections[i], 5, NULL);
}
return ESP_OK;
}Performance Testing and Comparative Analysis
Test Environment Configuration
// Test environment parameters
typedef struct {
// Hardware environment
struct {
const char* chip_model = "ESP32-WROOM-32";
int flash_size = 4 * 1024 * 1024; // 4MB
int sram_size = 520 * 1024; // 520KB
} hardware;
// Network environment
struct {
const char* wifi_ssid = "TestNetwork";
int signal_strength = -45; // dBm
int bandwidth = 40; // MHz
int channel = 6;
} network;
// Server environment
struct {
const char* server_url = "https://ota.example.com";
int server_bandwidth = 100; // Mbps
int server_latency = 20; // ms
} server;
} test_environment_t;Test Case Design
// Test case structure
typedef struct {
const char* test_name;
size_t firmware_size;
int concurrent_connections;
bool use_compression;
bool use_differential;
int expected_time;
float expected_success_rate;
} test_case_t;
test_case_t test_cases[] = {
{"Small File Test", 512*1024, 1, false, false, 30, 95.0},
{"Medium File Test", 2*1024*1024, 2, true, false, 120, 98.0},
{"Large File Test", 8*1024*1024, 3, true, true, 300, 99.0},
{"Unstable Network Test", 2*1024*1024, 2, true, false, 180, 90.0},
};Test Result Analysis
// Performance test results
typedef struct {
float avg_download_speed; // KB/s
float avg_upload_speed; // KB/s
int connection_time; // ms
int ssl_handshake_time; // ms
int total_transfer_time; // s
float success_rate; // %
int memory_peak_usage; // KB
} performance_metrics_t;
// Test result comparison
performance_metrics_t results[] = {
// Original version
{45.2, 12.3, 850, 1200, 720, 65.0, 8},
// Optimized version
{156.8, 45.6, 320, 450, 180, 98.5, 16},
// Extremely optimized version
{512.4, 128.9, 180, 280, 45, 99.5, 20},
};