Guias · 15 min de leitura

Arduino sem memória: como resolver Sketch too big e Low memory

Arduino sem memória? Entenda Flash, SRAM e EEPROM, F() e PROGMEM, arrays de char no lugar de String, como medir a RAM livre e quando migrar para um Mega ou ESP32.

Um aviso de memória insuficiente no Arduino indica que seu programa ou suas variáveis não cabem na memória da placa e costuma aparecer de duas formas: o código não chega a ser carregado porque a compilação para com Sketch too big, ou o código é carregado após o aviso Low memory available, stability problems may occur e a placa passa a reiniciar aleatoriamente, imprimir caracteres estranhos no Monitor Serial ou travar. Como o Arduino Uno tem apenas 32 KB de memória de programa e 2 KB de RAM, esse problema é especialmente comum em projetos que combinam um display, um cartão SD e alguns sensores.

Neste guia, você verá primeiro a diferença entre Flash, SRAM e EEPROM e como ler as duas linhas no final da compilação. Depois, usando valores que medimos em compilações reais para um Uno, aprenderá quanta memória cada linha consome, como tirar dados constantes da RAM com a macro F() e PROGMEM, como usar arrays de char no lugar de String, o custo oculto das bibliotecas e como medir a RAM livre durante a execução. Na última parte, verá como monitorar a memória no ESP32 e no Raspberry Pi Pico e quando migrar para um Mega ou ESP32 é a decisão certa.

Placa Arduino Uno e seu microcontrolador ATmega328P
O ATmega328P no coração do Arduino Uno: 32 KB de flash, 2 KB de SRAM e 1 KB de EEPROM. A maioria dos problemas de memória ocorre nesses 2 KB de RAM.

As três memórias do Arduino: Flash, SRAM e EEPROM

O microcontrolador do Arduino contém três memórias com funções completamente diferentes. A Flash (memória de programa) armazena seu código compilado; preserva os dados sem alimentação e só é gravada quando você carrega o código. A SRAM (memória de trabalho) guarda variáveis, chamadas de funções e dados temporários; é rápida, mas perde o conteúdo quando a placa é desligada. A EEPROM é uma pequena área para dados que precisam ser mantidos, mas mudam raramente, como configurações e valores de calibração. Em placas AVR como o Uno, essas três memórias ficam em espaços de endereçamento separados (arquitetura Harvard). Esse detalhe explica por que as técnicas F() e PROGMEM apresentadas abaixo são necessárias.

MemóriaCapacidade no UnoO que armazena?Sem alimentaçãoVida útil de gravação
Flash32 KB (0,5 KB reservados para o bootloader, 32.256 bytes utilizáveis)Código do programa, dados PROGMEMPreservadosCerca de 10.000 ciclos de apagamento/gravação
SRAM2 KB (2.048 bytes)Variáveis, arrays, pilha e heapPerdidosIlimitada
EEPROM1 KB (1.024 bytes)Configurações, contadores, calibraçãoPreservadosCerca de 100.000 gravações por célula

Usar EEPROM no lugar de RAM não resolve: ela é lenta e cada célula tem um número limitado de gravações. Se você gravar na EEPROM uma variável que muda rapidamente a cada repetição do loop, poderá desgastar essa célula em poucos dias. Veja as formas corretas de usar a EEPROM no tutorial de EEPROM no Arduino.

Capacidade de memória por placa

PlacaFlash (programa)SRAMEEPROM
Arduino Uno R3 / Nano (ATmega328P)32 KB (32.256 bytes utilizáveis no Uno, 30.720 no Nano)2 KB1 KB
Arduino Leonardo / Pro Micro (ATmega32U4)32 KB (28.672 bytes utilizáveis)2,5 KB1 KB
Arduino Mega 2560256 KB (253.952 bytes utilizáveis)8 KB4 KB
Arduino Uno R4 (RA4M1)256 KB32 KB8 KB (flash de dados)
ESP32 (WROOM)Chip de flash de 4 MB (partição padrão do app de 1,25 MB)520 KB (sobram cerca de 300 KB de heap para seu programa)Não tem; Preferences armazena os dados na flash
Raspberry Pi Pico (RP2040)Chip de flash de 2 MB264 KBNão tem; emulada na flash

A diferença é enorme: o ESP32 tem 260 vezes a RAM do Uno, e o Pico, cerca de 130 vezes. Por isso, economias de memória que exigem bastante esforço no Uno muitas vezes são desnecessárias no ESP32. Mesmo assim, Uno, Nano e Pro Mini são as placas mais usadas pelo baixo preço e pela simplicidade, então aprender a trabalhar com 2 KB é útil para qualquer usuário de Arduino.

Como ler a saída da compilação: Sketch uses e Global variables use

No final de cada compilação bem-sucedida, o Arduino IDE imprime duas linhas. Compile para o Uno um sketch com setup() e loop() vazios e você verá Sketch uses 444 bytes (1%) of program storage space e Global variables use 9 bytes (0%) of dynamic memory, leaving 2039 bytes for local variables. A primeira linha informa quanto o programa ocupa na flash; a segunda, quanta RAM as variáveis globais e estáticas ocupam. O ponto essencial é que a segunda linha só contabiliza variáveis cujo tamanho é conhecido na compilação. Variáveis locais de funções (a pilha) e memória alocada durante a execução com String ou malloc (o heap) não estão incluídas. O espaço restante para “local variables” é o que elas precisam compartilhar.

MensagemQuando aparece?O que significa?
Sketch uses ... bytes (x%) of program storage space (espaço ocupado pelo sketch)Em toda compilaçãoEspaço ocupado pelo código na flash
Global variables use ... bytes (x%) of dynamic memory (memória usada pelas variáveis globais)Em toda compilaçãoParcela da RAM usada por variáveis globais e estáticas
Low memory available, stability problems may occur. (pouca memória disponível; podem ocorrer problemas de estabilidade)Quando as variáveis globais ultrapassam cerca de 75% da RAMO código é carregado, mas sobra pouco espaço para a pilha e o heap
Sketch too big e text section exceeds available space in board (o programa excede o espaço disponível)Quando o programa não cabe na flashO código não pode ser carregado; você precisa reduzir o uso de flash
Not enough memory e data section exceeds available space in board (os dados excedem o espaço disponível)Quando as variáveis globais excedem a RAMO código não pode ser carregado; você precisa reduzir o uso de RAM
O aviso “Low memory” não é um erro e o código é carregado normalmente; esse é justamente o perigo. Um sketch com int veri[700];, por exemplo, usa 1.588 bytes (77%) em variáveis globais no Uno e deixa apenas 460 bytes para a pilha e o heap. Quando algumas chamadas de função aninhadas, uma concatenação de String ou um buffer alocado por uma biblioteca em begin() consomem esse espaço, o programa trava. Os sintomas são reinicializações aleatórias, variáveis corrompidas e travamentos; para diferenciá-los de problemas de alimentação, leia também Arduino reiniciando sozinho.

Dentro da SRAM: variáveis globais, heap e pilha

Os 2.048 bytes de RAM do Uno são divididos em quatro regiões. Na parte inferior ficam as variáveis globais com valor inicial (.data); acima delas, as variáveis globais que começam em zero (.bss); o compilador mostra a soma dessas duas regiões na linha “Global variables use”. Depois vem o heap, que cresce para cima: é onde ficam os objetos String e a memória alocada com new e malloc. A partir do topo da RAM, a pilha cresce para baixo: cada chamada de função coloca ali seu endereço de retorno e suas variáveis locais, e os registradores são salvos ali quando ocorre uma interrupção. Se o heap e a pilha se encontrarem no espaço livre entre eles, um sobrescreverá o outro e o programa falhará de maneiras imprevisíveis.

RegiãoConteúdoDireção de crescimentoAparece na saída da compilação?
.dataVariáveis globais e estáticas inicializadas, strings sem F()FixaSim
.bssVariáveis globais e estáticas não inicializadas (zero), buffers de bibliotecasFixaSim
HeapString, new, malloc, buffers que algumas bibliotecas alocam em begin()Para cimaNão
Pilha (stack)Variáveis locais, endereços de retorno de funções, registradores salvos durante interrupçõesPara baixoNão

Essa organização tem duas consequências importantes. Primeiro, toda string sem F() é copiada para .data, porque o processador AVR não consegue ler dados na flash como uma variável comum. Segundo, o heap se fragmenta: ao criar e excluir Strings de tamanhos diferentes, pequenos espaços ficam vazios e, mesmo quando a memória livre total parece suficiente, não é possível alocar um bloco grande. Por isso, em programas que rodam por muito tempo no Uno, evitar o heap tanto quanto possível é a abordagem mais segura.

Meça primeiro: quanta memória cada linha consome?

O primeiro passo para resolver um problema de memória é medir, não adivinhar. Cada linha da tabela abaixo é a saída real de um pequeno sketch compilado separadamente para o Arduino Uno com o core Arduino AVR 1.8.6. Os valores podem variar alguns bytes conforme as versões das bibliotecas e do core, mas as proporções permanecem as mesmas.

O que há no sketch?Flash (bytes)RAM global (bytes)
setup() e loop() vazios4449
Serial.begin(9600)1438184
+ Serial.println("a 44-character text") (adiciona uma linha que imprime um texto de 44 caracteres)1518232
O mesmo texto com F()1530188
analogRead + Serial.println(int)1892188
Cálculo com float + Serial.println(float)3380200
Concatenação de String: "A0=" + String(analogRead(A0))3316202
A mesma tarefa com snprintf e um array de char3232194
Uma única gravação com Wire (I2C)2476225
Cartão SD: begin, open, println, close10496837
Array int veri[700]17801.588 (77%, aviso Low memory)
Array int veri[950]17802.088 (101%, não compila)

As lições são claras. Só Serial.begin() ocupa 175 bytes de RAM, porque a porta serial aloca um buffer de recepção de 64 bytes e um de transmissão de 64 bytes. Uma única string de 44 caracteres custa 44 bytes de RAM; com F(), essa RAM é recuperada. Usar float acrescenta cerca de 1,5 KB de código de ponto flutuante à flash. A biblioteca SD sozinha consome 10 KB de flash e cerca de 830 bytes de RAM; 40% da RAM do Uno vai para um único arquivo de registro. A RAM global do exemplo com String parece pequena, mas seu custo real aparece no heap durante a execução e nunca na saída da compilação.

A macro F(): tire strings constantes da RAM

No Uno, toda string entre aspas, como "Temperature: ", fica na flash, mas é copiada para a RAM quando o programa começa e ocupa espaço ali permanentemente. A macro F() impede essa cópia: a string permanece na flash e funções como Serial.print leem seus caracteres diretamente da flash, um a um. F() funciona com todo objeto derivado da classe Print, incluindo Serial, LiquidCrystal, LiquidCrystal_I2C, Adafruit SSD1306 e arquivos SD. Em um projeto com menus, mensagens de erro e textos de ajuda, simplesmente adicionar F() pode recuperar algumas centenas de bytes de RAM. O código abaixo mostra a diferença e mede a RAM livre durante a execução:

C++ (Arduino IDE)
1// Boş RAM'i ölçmek ve F() ile RAM kazanmak (Uno, Nano, Mega)
2// Measure free RAM and save RAM with F() (Uno, Nano, Mega)
3extern int __heap_start, *__brkval;   // avr-libc heap sınırları / avr-libc heap limits
4
5int bosRam() {
6  int yerel;                          // stack'in o anki tepesi / current top of the stack
7  return (int)&yerel - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
8}
9
10void setup() {
11  Serial.begin(9600);
12  Serial.println("Bu metin RAM'e kopyalanir");   // RAM'de 26 bayt / 26 bytes of RAM
13  Serial.println(F("Bu metin flasta kalir"));     // RAM'de 0 bayt / 0 bytes of RAM
14  Serial.print(F("Bos RAM / Free RAM: "));
15  Serial.println(bosRam());
16}
17
18void loop() {
19}

A função bosRam() calcula a distância entre o topo atual da pilha e o final do heap, ou seja, quantos bytes restam antes de o heap e a pilha se encontrarem. Chame-a dentro de loop(), logo após uma atualização do display ou uma gravação no SD, para capturar o pior momento. Uma regra prática: no Uno, não deixe a RAM livre cair abaixo de 200–300 bytes durante a execução. F() não funciona com funções que esperam um char* (strcmp, strcpy); nesses casos, use as versões _P e a macro PSTR() mostradas abaixo.

PROGMEM: mantenha tabelas grandes na flash

F() serve apenas para strings. Para arrays grandes que nunca mudam, como arrays de notas, ícones de display (bitmaps), tabelas de caracteres, curvas de calibração ou listas de mensagens, use a palavra-chave PROGMEM. Um array declarado com PROGMEM nunca é copiado para a RAM; para lê-lo, você precisa de funções especiais, como pgm_read_byte e pgm_read_word, em vez do acesso normal a arrays. Uma melodia de 100 notas com tabelas de frequência e duração, por exemplo, ocupa 400 bytes; isso é um quinto da RAM do Uno, e PROGMEM transfere tudo para a flash.

C++ (Arduino IDE)
1// Mesaj listesi ve nota tablosu flaşta (PROGMEM)
2// Message list and note table kept in flash (PROGMEM)
3const char m0[] PROGMEM = "Sistem hazir";
4const char m1[] PROGMEM = "Sensor hatasi";
5const char m2[] PROGMEM = "Kapi acik";
6const char* const mesajlar[] PROGMEM = { m0, m1, m2 };   // işaretçi tablosu da flaşta / pointer table in flash too
7
8const uint16_t notalar[] PROGMEM = { 262, 294, 330, 349, 392, 440, 494, 523 };   // Do-Re-Mi ... Do (Hz)
9const byte BUZZER_PIN = 8;
10
11void setup() {
12  Serial.begin(9600);
13  char tampon[20];                                     // RAM'de tek ortak tampon / one shared RAM buffer
14  for (byte i = 0; i < 3; i++) {
15    strcpy_P(tampon, (const char*)pgm_read_ptr(&mesajlar[i]));   // flaştan RAM'e kopyala / copy flash -> RAM
16    Serial.println(tampon);
17  }
18  for (byte i = 0; i < 8; i++) {
19    uint16_t frekans = pgm_read_word(&notalar[i]);     // 2 baytlık değeri oku / read a 2-byte value
20    tone(BUZZER_PIN, frekans, 200);
21    delay(250);
22  }
23}
24
25void loop() {
26}
Função / macroO que faz?
pgm_read_byte(&array[i])Lê 1 byte da flash (arrays de byte, char e uint8_t, bitmaps)
pgm_read_word(&array[i])Lê 2 bytes da flash (int, uint16_t; tabelas de notas e números no Uno)
pgm_read_dword / pgm_read_floatLê valores long e float de 4 bytes
pgm_read_ptr(&table[i])Lê um ponteiro armazenado na flash (tabelas de strings)
strcpy_P(dest, src)Copia uma string da flash para um buffer na RAM
strcmp_P(ram_text, PSTR("..."))Compara uma string na RAM com uma string na flash
strlen_P / memcpy_PObtém o comprimento de uma string na flash, copia um bloco da flash
No ESP32 e no Pico, arrays declarados como const já ficam na flash; PROGMEM não tem efeito nessas placas, mas também não causa erros, e as funções pgm_read_* estão definidas. Assim, o código escrito com PROGMEM compila nas três placas. Há uma exceção: ao ler uma tabela de ponteiros, pgm_read_word funciona no Uno, mas trunca o ponteiro em placas de 32 bits; use pgm_read_ptr para ter código portável.

Use arrays de char no lugar de String

A classe String do Arduino é prática, mas cada concatenação (+) solicita um novo bloco ao heap e libera o anterior. Repetida milhares de vezes no pequeno heap do Uno, essa operação deixa a memória cheia de espaços vazios. O programa funciona bem por horas e, de repente, trava, e o bug é muito difícil de encontrar. A solução é usar arrays de char cujo tamanho seja conhecido de antemão: a memória é alocada uma única vez, nunca se fragmenta e os bytes usados aparecem na saída da compilação. O código abaixo lê comandos do Monitor Serial sem String e formata a medição em uma única linha:

C++ (Arduino IDE)
1// String yerine sabit boyutlu char dizileri / fixed-size char arrays instead of String
2char komut[16];          // gelen komut tamponu / incoming command buffer
3byte konum = 0;          // tampondaki karakter sayısı / characters in the buffer
4
5void setup() {
6  Serial.begin(9600);
7  pinMode(13, OUTPUT);
8  Serial.println(F("Komutlar / Commands: LED ON, LED OFF, OLC"));
9}
10
11void olcumGonder() {
12  int ham = analogRead(A0);
13  float volt = ham * 5.0 / 1023.0;          // Uno: 5 V, 10 bit
14  char vMetin[8];
15  dtostrf(volt, 4, 2, vMetin);              // AVR'de snprintf %f desteklemez / AVR snprintf has no %f
16  char satir[40];
17  snprintf(satir, sizeof(satir), "A0=%d ham, %s V", ham, vMetin);   // taşma olmaz / never overflows
18  Serial.println(satir);
19}
20
21void komutIsle(const char* k) {
22  if (strcmp_P(k, PSTR("LED ON")) == 0) digitalWrite(13, HIGH);     // PSTR: metin flaşta / literal in flash
23  else if (strcmp_P(k, PSTR("LED OFF")) == 0) digitalWrite(13, LOW);
24  else if (strcmp_P(k, PSTR("OLC")) == 0) olcumGonder();
25  else Serial.println(F("Bilinmeyen komut / Unknown command"));
26}
27
28void loop() {
29  while (Serial.available()) {
30    char c = Serial.read();
31    if (c == '\n') {                        // satır bitti / line complete
32      komut[konum] = '\0';
33      komutIsle(komut);
34      konum = 0;
35    } else if (c != '\r' && konum < sizeof(komut) - 1) {
36      komut[konum++] = c;                   // taşmadan ekle / append without overflow
37    }
38  }
39}

Três detalhes do código merecem atenção. snprintf conhece o tamanho do buffer, então nunca ultrapassa os limites do array, mesmo com um texto longo; sprintf não oferece essa proteção. Como a família printf do AVR não suporta o formato %f por padrão, o valor float é primeiro convertido em texto com dtostrf. E o limite do buffer de comandos (konum < sizeof(komut) - 1) impede que uma linha longa sobrescreva outra parte da memória. Se você precisar usar String (algumas bibliotecas retornam uma), pelo menos reserve o espaço antecipadamente em setup() com text.reserve(64) e torne a String global; isso reduz bastante a fragmentação.

O tipo de dado certo e as variáveis locais

TipoUno (AVR)ESP32 / PicoFaixa de valores (Uno)
bool, char, byte (tipos de 1 byte)1 byte1 bytebyte: 0–255
int2 bytes4 bytes-32.768 a 32.767
unsigned int, uint16_t2 bytesuint16_t: 2 bytes, unsigned int: 4 bytes0–65535
long, unsigned long (tipos inteiros de 4 bytes)4 bytes4 bytesunsigned long: 0–4.294.967.295
float4 bytes4 bytesCerca de 6–7 algarismos significativos
double4 bytes (igual a float)8 bytesSem diferença em relação a float no Uno
  • byte para números pequenos: Usar byte no lugar de int para números de pinos, contadores e porcentagens entre 0 e 255 economiza 1 byte por variável e 200 bytes em um array de 200 elementos.
  • const para números de pinos: O compilador incorpora constantes declaradas como const byte LED_PIN = 13; diretamente ao código e não reserva RAM para elas.
  • Flags de ligado/desligado em bits: Oito variáveis bool ocupam 8 bytes; armazene a mesma informação nos bits de um byte com bitRead e bitWrite e 1 byte será suficiente.
  • Cuidado com arrays locais grandes: Um char buffer[300]; declarado dentro de uma função não aparece na saída da compilação, mas ocupa 300 bytes da pilha a cada chamada da função. Torne buffers grandes globais para que seu tamanho fique visível.
  • Evite recursão: Toda função que chama a si mesma abre um novo nível na pilha; no Uno, até algumas dezenas de níveis podem esgotar a RAM.
  • Passe estruturas grandes por referência: Passar uma struct por valor para uma função coloca uma cópia na pilha; passá-la por referência como const Settings& s não cria cópia.

O custo oculto de memória das bibliotecas

Quando um projeto fica sem memória de repente, muitas vezes a causa não é seu código, mas uma biblioteca adicionada. Algumas bibliotecas reservam RAM na compilação (como buffer global); outras a retiram do heap quando begin() é chamada. No segundo caso, a saída da compilação parece normal, mas a memória se esgota quando a placa está em execução. Alguns valores abaixo vêm da tabela de medições anterior; outros, dos tamanhos dos buffers das bibliotecas:

Biblioteca / recursoCusto de RAM (Uno)Quando é alocada?Opção mais leve
SerialCerca de 175 bytes (buffers de 64 + 64 bytes)Na compilação (global)Remova Serial completamente se não precisar dela
Wire (I2C)Cerca de 215 bytesNa compilação (global)Inevitável mesmo com um único dispositivo I2C; concentre-se em outras economias
SoftwareSerialCerca de 120 bytes (buffer de recepção de 64 bytes)Na compilação (global)A porta serial de hardware, se possível, ou as portas extras do Mega
SDCerca de 830 bytes, mais cerca de 10 KB de flashNa compilação (global)Deixe o registro de dados para um ESP32 ou Mega
Adafruit SSD1306 128x64Buffer de quadro de 1.024 bytesDo heap, dentro de begin()Modo de páginas da U8g2 (128 bytes) ou U8x8 apenas para texto
Adafruit NeoPixel / FastLED3 bytes por LED (60 LEDs = 180 bytes)Na inicializaçãoLimite o número de LEDs ao comprimento real da fita

Essa tabela explica por que usar um display OLED, um cartão SD e um módulo Wi-Fi ao mesmo tempo no Uno é quase impossível: só o buffer do SSD1306 e a biblioteca SD somam 1,8 KB, deixando quase nada dos 2 KB de RAM para seu programa. O erro SSD1306 allocation failed que aparece com displays OLED é justamente essa falha de alocação no heap; você também encontra soluções no artigo sobre o display OLED de 0,96 polegada (SSD1306).

Sketch too big: formas de reduzir o uso de flash

  • Desative a saída de depuração: Linhas Serial.print adicionadas durante o desenvolvimento consomem flash e RAM. Com a macro DEBUG abaixo, você pode remover todas da compilação alterando uma única linha.
  • Evite float e sprintf: Como mostram as medições, float acrescenta cerca de 1,5 KB e snprintf mais de 1 KB de código. Multiplicar a temperatura por 10 e armazená-la como int (235 em vez de 23,5 °C) basta na maioria dos projetos.
  • Transforme código repetido em funções e arrays: Guardar os números dos pinos em um array e processá-los em um laço, em vez de escrever um bloco de dez linhas para cada LED, reduz bastante o código.
  • Escolha uma biblioteca menor: Se você não precisa de gráficos, U8x8 ou LiquidCrystal_I2C ocupam muito menos espaço que bibliotecas baseadas em Adafruit GFX. Em vez de incluir uma biblioteca inteira para uma única função, considere escrever essa parte por conta própria.
  • Confira a configuração da placa: O Arduino IDE calcula o limite com base na placa selecionada: 32.256 bytes para o Uno, 30.720 para o Nano (bootloader antigo ou novo) e 28.672 para o Leonardo. Se a placa errada estiver selecionada, tanto o limite quanto as definições dos pinos estarão errados.
  • Migre para uma placa com mais memória: Se ainda não couber depois de tudo isso, um Mega (256 KB) ou um ESP32 (1,25 MB ou mais) executa o mesmo código com pequenas alterações.
C++ (Arduino IDE)
1// DEBUG makrosu: hata ayıklama çıktısını tek satırla aç/kapat
2// DEBUG macro: switch debug output on/off with one line
3#define DEBUG 1          // yayında 0 yap / set to 0 for release
4
5#if DEBUG
6  #define DBG(x)   Serial.print(x)
7  #define DBGLN(x) Serial.println(x)
8#else
9  #define DBG(x)
10  #define DBGLN(x)
11#endif
12
13void setup() {
14#if DEBUG
15  Serial.begin(9600);
16#endif
17  pinMode(13, OUTPUT);
18  DBGLN(F("Basladi / Started"));
19}
20
21void loop() {
22  int deger = analogRead(A0);
23  digitalWrite(13, deger > 512 ? HIGH : LOW);   // asıl iş / the real job
24  DBG(F("A0: "));
25  DBGLN(deger);
26  delay(500);
27}

Com DEBUG 1, esse sketch usa 2.292 bytes de flash e 188 bytes de RAM no Uno; defina DEBUG 0 e o código Serial será totalmente removido da compilação, reduzindo os valores para 934 bytes de flash e 9 bytes de RAM. A diferença de 1,3 KB de flash e 179 bytes de RAM costuma bastar para adicionar um novo recurso a um projeto pronto.

Como medir a memória no ESP32

O ESP32 tem bastante memória, mas ela não é ilimitada. Ativar o Wi-Fi aloca dezenas de KB de RAM e, com Bluetooth também ativo, esse valor pode se aproximar de 100 KB; servidores web, documentos JSON e buffers de imagem também enchem a memória rapidamente. Alguns módulos, como o ESP32-CAM, têm PSRAM extra (geralmente 4 MB) para buffers grandes. Na flash, se sua aplicação não couber na partição padrão de 1,25 MB, você pode chegar a 3 MB com a opção “Huge APP” na configuração Partition Scheme do menu Ferramentas. Para conhecer os recursos gerais do ESP32, veja O que é o ESP32?.

C++ (Arduino IDE)
1// ESP32 bellek raporu / ESP32 memory report
2void setup() {
3  Serial.begin(115200);
4  delay(500);
5  Serial.printf("Bos heap / Free heap: %u bayt\n", ESP.getFreeHeap());
6  Serial.printf("En dusuk heap / Minimum free heap: %u bayt\n", ESP.getMinFreeHeap());
7  Serial.printf("En buyuk blok / Largest free block: %u bayt\n", ESP.getMaxAllocHeap());
8  Serial.printf("PSRAM: %u bayt\n", ESP.getPsramSize());
9  Serial.printf("Program / Sketch: %u, bos alan / free: %u bayt\n", ESP.getSketchSize(), ESP.getFreeSketchSpace());
10}
11
12void loop() {
13  // loop görevinin hiç kullanılmamış stack'i / never-used stack of the loop task
14  Serial.printf("loop stack bos / free: %u bayt\n", (unsigned)uxTaskGetStackHighWaterMark(NULL));
15  Serial.printf("Bos heap / Free heap: %u bayt\n", ESP.getFreeHeap());
16  delay(5000);
17}

Os dois números mais úteis aqui são getMinFreeHeap e getMaxAllocHeap. O primeiro informa o menor heap livre desde o início do programa; o segundo, o maior bloco que pode ser alocado de uma só vez. Se o heap livre indicar 100 KB, mas o maior bloco tiver menos de 10 KB, o heap está fragmentado e talvez não seja possível alocar uma String ou um documento JSON grande. No ESP32, loop() roda em uma tarefa própria com uma pilha de 8 KB; uxTaskGetStackHighWaterMark mostra a parte dessa pilha que nunca foi usada e, se ela cair abaixo de algumas centenas de bytes, pode ocorrer o erro “Stack canary watchpoint triggered”.

Memória no Raspberry Pi Pico e no MicroPython

Os 264 KB de RAM do Pico são enormes em comparação com o Uno, mas o próprio interpretador MicroPython usa parte deles; seu programa costuma ficar com cerca de 190 KB de heap. No MicroPython, a memória é gerenciada por um coletor de lixo: objetos que não estão mais em uso são removidos quando gc.collect() é chamada ou quando a memória está prestes a acabar. Quando a memória realmente se esgota, aparece MemoryError: memory allocation failed. Concatenar strings em um laço, criar listas grandes e ter um único arquivo de código muito longo são as causas mais comuns desse erro.

Python
1import gc
2import micropython
3
4gc.collect()                                   # önce çöpleri topla / collect garbage first
5print("Bos RAM / Free RAM:", gc.mem_free(), "bayt")
6print("Kullanilan / Used:", gc.mem_alloc(), "bayt")
7micropython.mem_info()                         # ayrıntılı rapor / detailed report
8
9# Kötü: her turda yeni metin nesnesi / bad: a new string object every loop
10# satir = ""
11# for i in range(100): satir += str(i) + ","
12
13# İyi: tek seferlik bytearray tamponu / good: one preallocated bytearray buffer
14tampon = bytearray(64)
15for i in range(10):
16    tampon[i] = 48 + i                         # ASCII '0'..'9'
17print(bytes(tampon[:10]))

Para preservar a memória no MicroPython, aloque buffers antecipadamente com bytearray e reutilize-os no laço, defina números constantes com const(), transforme módulos grandes em arquivos .mpy pré-compilados com mpy-cross e chame gc.collect() antes de tarefas longas. Veja os comandos básicos do MicroPython no Pico em Fundamentos do MicroPython e os recursos gerais da placa em O que é o Raspberry Pi Pico?.

Quando migrar para um Mega ou ESP32?

Placa Arduino Mega 2560
Arduino Mega 2560: 256 KB de flash, 8 KB de SRAM e 4 KB de EEPROM. O código do Uno costuma rodar nele sem alterações.
SituaçãoRecomendação
Após usar F(), PROGMEM e arrays de char, a RAM livre fica acima de 300 bytesContinue no Uno; o problema foi resolvido
Vários sensores e um menu com OLED ou cartão SD, e a RAM ainda não bastaArduino Mega 2560: 4 vezes a RAM, os mesmos pinos de 5 V e bibliotecas
O programa excede 32 KB, mas a RAM é suficienteMega ou Uno R4: 256 KB de flash
Você precisa de Wi-Fi, servidor web, buffers grandes ou processamento de imagensESP32: 520 KB de RAM, 4 MB de flash, Wi-Fi e Bluetooth
Você quer trabalhar com MicroPythonRaspberry Pi Pico ou Pico W
Um pequeno nó sensor que precisa funcionar com bateria por mesesOtimize no Uno ou use um Pro Mini; uma placa maior consome mais corrente

Ao migrar para um Mega, a maior parte do código continua igual; lembre-se apenas de que os pinos I2C são 20 (SDA) e 21 (SCL), e os pinos SPI são 50–53. A migração para um ESP32 traz diferenças como o nível lógico de 3,3 V, outros números de pinos e o resultado de 12 bits (0–4095) de analogRead. Para decidir qual placa atende você, leia a comparação Arduino ou ESP32; para uma opção compatível com 5 V e com muito mais memória, veja o artigo sobre o Arduino Uno R4.

Erros comuns e como resolvê-los

SintomaCausa provávelSolução
Sketch too big, o código não é carregadoO programa não cabe na flashDesative a saída de depuração, reduza float e sprintf, escolha bibliotecas menores e migre para um Mega se necessário
O código é carregado, mas trava após alguns minutosConcatenações de String fragmentam o heapUse arrays de char e snprintf no lugar de String; meça a RAM livre
Caracteres estranhos no Monitor Serial, variáveis mudam sozinhasA pilha está sobrescrevendo o heapReduza o uso de RAM global para menos de 75% e remova arrays locais grandes
SSD1306 allocation failed (falha na alocação)begin() não consegue alocar o buffer de 1 KBEnvolva as strings em F() e mude para o modo de páginas da U8g2
A placa reinicia aleatoriamente, embora a memória pareça normalPode ser um problema de alimentação, não de memóriaAlimente motores e relés separadamente e adicione um capacitor
Elementos do array mostram valores sem sentidoGravação além do final do arrayConfira o índice; determine os limites dos laços a partir de sizeof
Stack canary watchpoint triggered no ESP32Houve um estouro da pilha de uma tarefaTorne arrays locais grandes globais ou aumente a pilha da tarefa
Para evitar problemas de memória desde o início, anote as duas porcentagens da saída da compilação sempre que adicionar um novo módulo ao projeto. Comece a aplicar F() e PROGMEM quando a RAM global passar de 60%; esperar pelo aviso de 75% significa deixar o problema para o momento em que será mais difícil resolvê-lo.

A falta de memória no Arduino geralmente pode ser resolvida sem trocar a placa: mover strings constantes para a flash com F(), transferir tabelas grandes para PROGMEM, usar arrays de char no lugar de String e remover bibliotecas desnecessárias libera um espaço surpreendente nos 2 KB de RAM. No app BlueGrays, você pode explorar projetos que consomem bastante memória, como jogos em OLED, melodias com buzzer e animações em matriz de LEDs, com esquemas do circuito passo a passo e código escrito com essas técnicas.

Perguntas frequentes

O que significa Low memory available no Arduino?

Significa que as variáveis globais ocupam cerca de 75% da RAM e sobra pouco espaço para a pilha e o heap. O código é carregado, mas podem ocorrer reinicializações aleatórias, travamentos e variáveis corrompidas durante a execução. Envolver strings constantes em F() e mover arrays grandes para PROGMEM costuma eliminar o aviso.

Como resolver o erro Sketch too big?

Esse erro significa que o programa não cabe na memória flash. Desative a saída Serial adicionada para depuração, reduza float e sprintf, transforme código repetido em funções e escolha bibliotecas menores. Se ainda não couber, migre para uma placa com mais flash, como o Arduino Mega ou um ESP32.

Quanta memória o Arduino Uno tem?

O ATmega328P do Arduino Uno tem 32 KB de flash (0,5 KB reservados para o bootloader), 2 KB de SRAM e 1 KB de EEPROM. O programa fica na flash, as variáveis na SRAM e as configurações permanentes na EEPROM. A maioria dos problemas ocorre nesses 2 KB de SRAM.

Para que serve a macro F()?

F() impede que strings constantes passadas a funções como Serial.print sejam copiadas para a RAM e as mantém na flash. No Uno, cada caractere economiza um byte de RAM, o que soma centenas de bytes em projetos com muitas mensagens. Ela também compila no ESP32 e no Pico, mas não tem efeito nessas placas.

Como medir a RAM livre no Arduino?

No Uno, Nano e Mega, use uma pequena função que calcula a distância entre a pilha e o heap com as variáveis __heap_start e __brkval. No ESP32, ESP.getFreeHeap() e ESP.getMinFreeHeap() fornecem a mesma informação; no MicroPython, gc.mem_free(). É importante medir no momento de pico do uso de memória.

Por que usar String no Arduino é um problema?

Objetos String solicitam nova memória ao heap a cada concatenação e liberam o bloco anterior, fazendo o pequeno heap do Uno se fragmentar com o tempo. Mesmo que a memória livre total pareça suficiente, não é possível alocar um novo bloco e o programa trava. Arrays de char de tamanho fixo e snprintf eliminam completamente esse problema.

Ver todos os projetos
Hino nacional da Turquia com buzzer
AR-15Intermediário

Hino nacional da Turquia com buzzer

Pressione o botão e um pequeno buzzer começa a tocar o hino nacional da Turquia, nota por nota.

4.8(114)
235
Temperatura e umidade com DHT11
AR-55Intermediário

Temperatura e umidade com DHT11

Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

4.7(47)
83
Jogo de bola e raquetes - SSD1306
AR-86Intermediário
Premium

Jogo de bola e raquetes - SSD1306

Uma bola, duas raquetes e você: jogue tênis de mesa, um dos primeiros videogames, em um pequeno display OLED.

4.5(47)
65
Corrida do T-Rex no OLED: jogo do dinossauro com Arduino
AR-87Avançado
Premium

Corrida do T-Rex no OLED: jogo do dinossauro com Arduino

O jogo do dinossauro que aparece quando a internet cai, agora na sua mesa: o dinossauro corre pelo pequeno display OLED, os cactos vêm na sua direção e você pula com um único botão.

4.7(33)
53
Cobrinha em pixels: matriz 8x8
AR-88Avançado
Premium

Cobrinha em pixels: matriz 8x8

Monte o clássico jogo da cobrinha com as próprias mãos e jogue. Em uma matriz de luzes coloridas 8x8, você guia uma cobra verde com um joystick e come maçãs vermelhas; a cada maçã, a cobra cresce…

4.7(39)
57
Jogo da memória com Arduino (4 LEDs + 4 botões + buzzer)
AR-93Avançado
Premium

Jogo da memória com Arduino (4 LEDs + 4 botões + buzzer)

Você confia na sua memória? Quatro LEDs coloridos acendem em sequência, cada um tocando sua própria nota, e você repete a mesma ordem apertando os botões.

4.8(46)
69
Fechadura com senha, teclado 4x4 e LCD
AR-64Avançado
Premium

Fechadura com senha, teclado 4x4 e LCD

Uma pequena fechadura eletrônica que impede a entrada de quem não sabe a senha. Você pressiona a cerquilha e digita a senha no teclado.

4.8(59)
75