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.

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ória | Capacidade no Uno | O que armazena? | Sem alimentação | Vida útil de gravação |
|---|---|---|---|---|
| Flash | 32 KB (0,5 KB reservados para o bootloader, 32.256 bytes utilizáveis) | Código do programa, dados PROGMEM | Preservados | Cerca de 10.000 ciclos de apagamento/gravação |
| SRAM | 2 KB (2.048 bytes) | Variáveis, arrays, pilha e heap | Perdidos | Ilimitada |
| EEPROM | 1 KB (1.024 bytes) | Configurações, contadores, calibração | Preservados | Cerca 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
| Placa | Flash (programa) | SRAM | EEPROM |
|---|---|---|---|
| Arduino Uno R3 / Nano (ATmega328P) | 32 KB (32.256 bytes utilizáveis no Uno, 30.720 no Nano) | 2 KB | 1 KB |
| Arduino Leonardo / Pro Micro (ATmega32U4) | 32 KB (28.672 bytes utilizáveis) | 2,5 KB | 1 KB |
| Arduino Mega 2560 | 256 KB (253.952 bytes utilizáveis) | 8 KB | 4 KB |
| Arduino Uno R4 (RA4M1) | 256 KB | 32 KB | 8 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 MB | 264 KB | Nã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.
| Mensagem | Quando aparece? | O que significa? |
|---|---|---|
| Sketch uses ... bytes (x%) of program storage space (espaço ocupado pelo sketch) | Em toda compilação | Espaç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ção | Parcela 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 RAM | O 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 flash | O 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 RAM | O código não pode ser carregado; você precisa reduzir o uso de RAM |
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ão | Conteúdo | Direção de crescimento | Aparece na saída da compilação? |
|---|---|---|---|
| .data | Variáveis globais e estáticas inicializadas, strings sem F() | Fixa | Sim |
| .bss | Variáveis globais e estáticas não inicializadas (zero), buffers de bibliotecas | Fixa | Sim |
| Heap | String, new, malloc, buffers que algumas bibliotecas alocam em begin() | Para cima | Não |
| Pilha (stack) | Variáveis locais, endereços de retorno de funções, registradores salvos durante interrupções | Para baixo | Nã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() vazios | 444 | 9 |
| Serial.begin(9600) | 1438 | 184 |
| + Serial.println("a 44-character text") (adiciona uma linha que imprime um texto de 44 caracteres) | 1518 | 232 |
| O mesmo texto com F() | 1530 | 188 |
| analogRead + Serial.println(int) | 1892 | 188 |
| Cálculo com float + Serial.println(float) | 3380 | 200 |
| Concatenação de String: "A0=" + String(analogRead(A0)) | 3316 | 202 |
| A mesma tarefa com snprintf e um array de char | 3232 | 194 |
| Uma única gravação com Wire (I2C) | 2476 | 225 |
| Cartão SD: begin, open, println, close | 10496 | 837 |
| Array int veri[700] | 1780 | 1.588 (77%, aviso Low memory) |
| Array int veri[950] | 1780 | 2.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:
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.
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(¬alar[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 / macro | O 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_float | Lê 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_P | Obtém o comprimento de uma string na flash, copia um bloco da flash |
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:
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
| Tipo | Uno (AVR) | ESP32 / Pico | Faixa de valores (Uno) |
|---|---|---|---|
| bool, char, byte (tipos de 1 byte) | 1 byte | 1 byte | byte: 0–255 |
| int | 2 bytes | 4 bytes | -32.768 a 32.767 |
| unsigned int, uint16_t | 2 bytes | uint16_t: 2 bytes, unsigned int: 4 bytes | 0–65535 |
| long, unsigned long (tipos inteiros de 4 bytes) | 4 bytes | 4 bytes | unsigned long: 0–4.294.967.295 |
| float | 4 bytes | 4 bytes | Cerca de 6–7 algarismos significativos |
| double | 4 bytes (igual a float) | 8 bytes | Sem 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 / recurso | Custo de RAM (Uno) | Quando é alocada? | Opção mais leve |
|---|---|---|---|
| Serial | Cerca 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 bytes | Na compilação (global) | Inevitável mesmo com um único dispositivo I2C; concentre-se em outras economias |
| SoftwareSerial | Cerca 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 |
| SD | Cerca de 830 bytes, mais cerca de 10 KB de flash | Na compilação (global) | Deixe o registro de dados para um ESP32 ou Mega |
| Adafruit SSD1306 128x64 | Buffer de quadro de 1.024 bytes | Do heap, dentro de begin() | Modo de páginas da U8g2 (128 bytes) ou U8x8 apenas para texto |
| Adafruit NeoPixel / FastLED | 3 bytes por LED (60 LEDs = 180 bytes) | Na inicialização | Limite 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.
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?.
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.
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?

| Situação | Recomendação |
|---|---|
| Após usar F(), PROGMEM e arrays de char, a RAM livre fica acima de 300 bytes | Continue no Uno; o problema foi resolvido |
| Vários sensores e um menu com OLED ou cartão SD, e a RAM ainda não basta | Arduino Mega 2560: 4 vezes a RAM, os mesmos pinos de 5 V e bibliotecas |
| O programa excede 32 KB, mas a RAM é suficiente | Mega ou Uno R4: 256 KB de flash |
| Você precisa de Wi-Fi, servidor web, buffers grandes ou processamento de imagens | ESP32: 520 KB de RAM, 4 MB de flash, Wi-Fi e Bluetooth |
| Você quer trabalhar com MicroPython | Raspberry Pi Pico ou Pico W |
| Um pequeno nó sensor que precisa funcionar com bateria por meses | Otimize 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
| Sintoma | Causa provável | Solução |
|---|---|---|
| Sketch too big, o código não é carregado | O programa não cabe na flash | Desative 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 minutos | Concatenações de String fragmentam o heap | Use arrays de char e snprintf no lugar de String; meça a RAM livre |
| Caracteres estranhos no Monitor Serial, variáveis mudam sozinhas | A pilha está sobrescrevendo o heap | Reduza 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 KB | Envolva as strings em F() e mude para o modo de páginas da U8g2 |
| A placa reinicia aleatoriamente, embora a memória pareça normal | Pode ser um problema de alimentação, não de memória | Alimente motores e relés separadamente e adicione um capacitor |
| Elementos do array mostram valores sem sentido | Gravação além do final do array | Confira o índice; determine os limites dos laços a partir de sizeof |
| Stack canary watchpoint triggered no ESP32 | Houve um estouro da pilha de uma tarefa | Torne arrays locais grandes globais ou aumente a pilha da tarefa |
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.
Projetos para montar depois desta leitura
Ver todos os projetos
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.

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…

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.

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.

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…

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.

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.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

