Pular para o conteúdo
ThingFace

ESP32 sem PSRAM no Arduino: buffers TLS dinâmicos

No ESP32 clássico sem PSRAM, com o core Arduino 3.3 como ele vem, o SDK online deixa pouca RAM para um segundo TLS: um app que, além da nuvem, chama uma API HTTPS (pagamento, telemetria) costuma falhar no handshake com (-32512) SSL - Memory allocation failed. A causa é o mbedTLS pré-compilado do core: ele vem com o DTLS ligado, o que impede os buffers dinâmicos, e cada conexão TLS prende dois buffers fixos de ~16,7 KB (entrada e saída) do primeiro ao último byte, mesmo parada. Esta página é a receita recomendada para esse caso: recompilar o mbedTLS do core com buffers dinâmicos pelo custom_sdkconfig do pioarduino. Ela foi testada num ESP32 sem PSRAM com o core 3.3.12.

O ESP-IDF não precisa disto: os exemplos do SDK já ligam os buffers dinâmicos (Limites). Placas com PSRAM (WROVER, S3 com PSRAM) também não costumam precisar.

O que muda

Medido em 11/11/2026, ESP32 sem PSRAM a 240 MHz, core 3.3.12 (pioarduino 55.03.312-1, ESP-IDF 5.5.5), SDK online com 0 abas, Wi-Fi e um WebServer na porta 80. "Livre de 8 bits" é heap_caps_get_free_size(MALLOC_CAP_8BIT), a RAM que o TLS pode usar (veja Como conferir). O segundo TLS é um NetworkClientSecure com HTTPClient para uma API pública com cadeia RSA-2048 (TLS 1.2, ECDHE-RSA-AES128-GCM).

Core como vemBuffers dinâmicos
Sessão TLS do SDK, parada40.788 B4.156 B
O que o SDK online tira da RAM de 8 bits~82 KB~45 KB
Livre de 8 bits com o SDK online (sketch mínimo)93.464 B132.064 B
Queda da RAM de 8 bits no handshake do segundo TLS53,8 KB, com 2 blocos contínuos de 16.717 B23,1 KB; o maior bloco pedido tem 5.108 B
App com tela (~114 KB de RAM estática): livre de 8 bits com o SDK online30.496 B (maior bloco 28.660 B): o segundo TLS falha69.064 B (maior bloco 61.428 B): o segundo TLS passa, com 47.212 B no pior momento
O mesmo app, com uma sessão HTTPS mantida aberta e outra abrindo, e o SDK onlinenão cabepassa, com 36.348 B no pior momento

Além disso, o firmware fica ~27 KB menor na flash (sem o DTLS), e a RAM estática cai ~1,4 KB.

A receita

1. Um diretório do PlatformIO só para este projeto

O custom_sdkconfig recompila as bibliotecas do core e as troca dentro do diretório do PlatformIO: qualquer outro projeto que use o mesmo diretório passa a compilar com elas (ou o pioarduino as recompila de volta, a cada troca de projeto). Use um diretório só deste projeto, pelo PLATFORMIO_CORE_DIR, sempre que rodar o pio:

# PowerShell (o pioarduino recusa o Git Bash)
$env:PLATFORMIO_CORE_DIR = "$HOME\pio-meu-projeto"

Instale nele o PlatformIO do pioarduino na versão 6.2.0 exata, num ambiente Python dentro do diretório:

python -m venv $HOME\pio-meu-projeto\penv
$HOME\pio-meu-projeto\penv\Scripts\pip download pioarduino==6.2.0 --no-deps -d dl
# o SHA-256 de dl\pioarduino-6.2.0-py3-none-any.whl deve ser
#   12e251cd3ee51e114ab3f12af74196358263a3983253d172b620d13ff9d9804f
$HOME\pio-meu-projeto\penv\Scripts\pip install dl\pioarduino-6.2.0-py3-none-any.whl
# para fixar também as dependências: pip install --no-deps -r penv.txt <o .whl>, com o penv.txt de
# arduino/platformio/ no repositório do SDK
$HOME\pio-meu-projeto\penv\Scripts\python -m platformio --version   # PlatformIO Core, version 6.2.0

Rode o pio sempre por esse Python ($HOME\pio-meu-projeto\penv\Scripts\python -m platformio run). Deixado por conta própria, o pioarduino instala o 6.2.0.post1, e a recompilação para no meio com IncompatiblePlatform: ... depends on PlatformIO Core >=6.2.0 (e remove a plataforma do diretório).

2. O platformio.ini

[env:esp32]
; o core 3.3.12 (ESP-IDF 5.5.5), versão fixa
platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.312-1/platform-espressif32.zip
board = esp32dev
framework = arduino
; a tabela do SDK (a chave da placa na partição devui): extras/partitions.csv da biblioteca
board_build.partitions = <pasta da biblioteca ThingFace>/extras/partitions.csv

; o mbedTLS do core recompilado: sem DTLS (que impede os buffers dinâmicos), com buffers dinâmicos, os dados de
; configuração e as raízes liberados depois do handshake, e a saída em 4 KB. Uma opção por linha, sempre com =y ou =n:
; uma linha que começa com # vira comentário do .ini e some sem aviso.
custom_sdkconfig =
	CONFIG_MBEDTLS_SSL_PROTO_DTLS=n
	CONFIG_MBEDTLS_DYNAMIC_BUFFER=y
	CONFIG_MBEDTLS_DYNAMIC_FREE_CONFIG_DATA=y
	CONFIG_MBEDTLS_DYNAMIC_FREE_CA_CERT=y
	CONFIG_MBEDTLS_ASYMMETRIC_CONTENT_LEN=y
	CONFIG_MBEDTLS_SSL_IN_CONTENT_LEN=16384
	CONFIG_MBEDTLS_SSL_OUT_CONTENT_LEN=4096

; OBRIGATÓRIO: os buffers dinâmicos só funcionam com estes 12 --wrap no link. O ESP-IDF os põe sozinho; o pioarduino
; não os leva para o link do Arduino, e sem eles nada muda e nada avisa.
build_flags =
	-Wl,--wrap=mbedtls_ssl_write_client_hello
	-Wl,--wrap=mbedtls_ssl_handshake_client_step
	-Wl,--wrap=mbedtls_ssl_tls13_handshake_client_step
	-Wl,--wrap=mbedtls_ssl_handshake_server_step
	-Wl,--wrap=mbedtls_ssl_tls13_handshake_server_step
	-Wl,--wrap=mbedtls_ssl_read
	-Wl,--wrap=mbedtls_ssl_write
	-Wl,--wrap=mbedtls_ssl_session_reset
	-Wl,--wrap=mbedtls_ssl_free
	-Wl,--wrap=mbedtls_ssl_setup
	-Wl,--wrap=mbedtls_ssl_send_alert_message
	-Wl,--wrap=mbedtls_ssl_close_notify

A biblioteca ThingFace entra como você já a usa (lib_deps ou lib_extra_dirs). Os outros build_flags do projeto vão na mesma lista, abaixo dos --wrap. A entrada de 16 KB fica de propósito: um servidor que não aceita fragmentos menores (a maioria das APIs) manda registros de até 16 KB, e com os buffers dinâmicos esse buffer só existe enquanto um registro chega.

Com a atualização remota de firmware: a receita mantém a curva P-384 e o pacote de CAs completo do core, que o download do firmware exige (as raízes do armazenamento são P-384). Não acrescente CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED=n nem CONFIG_MBEDTLS_CERTIFICATE_BUNDLE=n: sem eles o DevUIOta.begin recusa. Os buffers dinâmicos valem também para a segunda sessão TLS, a do download.

3. A primeira compilação

A primeira compilação baixa o ESP-IDF e recompila as bibliotecas do core: de 6 a 12 minutos num PC de 16 núcleos (medido com 6 trabalhos em paralelo: 11 min com os downloads, 5,6 min numa recompilação), e alguns GB no diretório do passo 1. Ela diz *** Compile Arduino IDF libs for esp32 *** no começo e *** Copied compiled esp32 IDF libraries to Arduino framework *** no fim. As seguintes levam o tempo de sempre, enquanto o custom_sdkconfig não mudar; mudar uma linha dele recompila tudo de novo. Todos os ambientes do projeto devem ter o mesmo custom_sdkconfig (uma seção comum com extends), senão o pioarduino recompila a cada troca.

Como conferir

1. Os --wrap entraram no firmware. Sem eles a compilação passa, a placa funciona, e a RAM fica igual à do core como vem. Confira no ELF:

<diretório do passo 1>\packages\toolchain-xtensa-esp-elf\bin\xtensa-esp32-elf-nm .pio\build\esp32\firmware.elf | findstr __wrap_mbedtls_ssl_setup

Uma linha T __wrap_mbedtls_ssl_setup diz que estão lá.

2. Meça a RAM de 8 bits, não o ESP.getFreeHeap(). No ESP32, o getFreeHeap() e o getMaxAllocHeap() contam também a IRAM livre (~39 KB no core 3.3.12, ~54 KB com as bibliotecas recompiladas), que só aceita acessos de 32 bits e que o TLS não usa. O maior bloco que o getMaxAllocHeap() mostra pode ser da IRAM: com a RAM de 8 bits quase acabando, ele continua mostrando ~36 KB. Meça assim:

#include "esp_heap_caps.h"

Serial.printf("livre 8 bits %u, maior bloco %u, mínimo %u\n",
              (unsigned)heap_caps_get_free_size(MALLOC_CAP_8BIT),
              (unsigned)heap_caps_get_largest_free_block(MALLOC_CAP_8BIT),
              (unsigned)heap_caps_get_minimum_free_size(MALLOC_CAP_8BIT));

3. O SDK online custa ~45 KB, não ~82 KB. Meça a linha acima logo antes do DevUI.begin() e uns 10 s depois do DEVUI_EV_ONLINE: a diferença é o que o SDK tirou da RAM de 8 bits. Perto de 82 KB, os buffers dinâmicos não estão valendo (volte ao item 1).

4. A sessão TLS parada perto de 4 KB. Para ver só o mbedTLS, conte as alocações dele: este arquivo C (em C, porque o esp_mem.h do core não declara extern "C") soma o que o mbedTLS tem alocado. Chame tls_conta_instalar() na primeira linha do setup() e leia tls_vivo com o SDK online: ~4,2 KB com os buffers dinâmicos, ~40,8 KB sem eles.

/* tls_conta.c */
#include "esp_heap_caps.h"
#include "freertos/FreeRTOS.h"
#include "mbedtls/platform.h"
#include "esp_mem.h"

volatile int tls_vivo;
static portMUX_TYPE trava = portMUX_INITIALIZER_UNLOCKED;

static void *conta_calloc(size_t n, size_t t)
{
    void *p = esp_mbedtls_mem_calloc(n, t);
    if (p) {
        portENTER_CRITICAL_SAFE(&trava);
        tls_vivo += heap_caps_get_allocated_size(p);
        portEXIT_CRITICAL_SAFE(&trava);
    }
    return p;
}

static void conta_free(void *p)
{
    if (p) {
        portENTER_CRITICAL_SAFE(&trava);
        tls_vivo -= heap_caps_get_allocated_size(p);
        portEXIT_CRITICAL_SAFE(&trava);
    }
    esp_mbedtls_mem_free(p);
}

void tls_conta_instalar(void)
{
    mbedtls_platform_set_calloc_free(conta_calloc, conta_free);
}

No sketch: extern "C" { extern volatile int tls_vivo; void tls_conta_instalar(void); }.

Se não der para recompilar o core: pausar o SDK

Sem o custom_sdkconfig, a outra saída é parar o SDK enquanto o app usa o próprio TLS: DevUI.stop(), esperar DevUI.status() == DEVUI_STATUS_STOPPED, fazer a requisição e DevUI.begin(cfg) de novo. O STOPPED só aparece quando a sessão TLS do SDK já voltou ao heap (de 0,2 a 0,35 s depois do stop, medido; se o cliente travar ao fechar, ele sai assim mesmo 20 s depois, com um aviso no log); no mesmo app com tela da tabela acima, a requisição passa com ~34 KB de RAM de 8 bits no pior momento. O custo: a placa fica offline na nuvem durante a pausa, e voltar leva de 4,5 a 7,7 s (um handshake e um HELLO novos). A fila do banco na flash fica; chame DevUI.dbQueue(...) de novo depois do begin (Banco de dados).