Aprender

Arduino "Low memory available, stability problems may occur", e "Sketch too big"

Iniciante

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: um potenciômetro no A0, impressoao vivo0.000 s 0.00x
Clique para abrir no editor
Abra, mude uma linha e aperte Rodar: a aba Compilação mostra quanto flash e RAM o sketch usa.

Depois de cada compilação o IDE do Arduino imprime duas linhas: quanto do flash o programa ocupa e quanto da RAM as variáveis globais ocupam. Quando a linha da RAM passa de cerca de três quartos, aparece uma terceira linha: "Low memory available, stability problems may occur." É um aviso, não um erro. O sketch ainda é enviado. Se ele funciona depois depende de quanta RAM ele precisa enquanto roda, o que o compilador não pode saber.

A aba Compilação do Mokxi imprime as mesmas linhas, sob a mesma regra. O circuito acima lê um potenciômetro e o imprime; abra, mude qualquer linha e aperte Rodar, e a aba Compilação mostra as duas linhas dele. Cada número abaixo veio de um sketch compilado com o compilador do editor para um Uno. O compilador e o core do Mokxi não são os do IDE do Arduino, então o IDE dá números um pouco diferentes para o mesmo sketch, e a página diz onde a diferença importa.

O que as duas linhas significam

O flash, "program storage space", guarda o próprio programa e tudo marcado para ficar lá. A RAM, "dynamic memory", guarda todas as variáveis globais e estáticas, o texto que o seu sketch imprime a menos que você o mova e, enquanto o sketch roda, a pilha: as variáveis locais e o endereço de retorno de cada chamada de função. Um Uno tem 2.048 bytes de RAM. Não é muito: um buffer de 1600 bytes já é a maior parte.

Um sketch de blink compilado para um Uno no Mokxi informa "Sketch uses 1,652 bytes (5%) of program storage space. Maximum is 32,768 bytes." e "Global variables use 142 bytes (7%) of dynamic memory, leaving 1,906 bytes for local variables. Maximum is 2,048 bytes." O IDE diz 32.256 para o flash de um Uno, porque o bootloader reserva os últimos 512 bytes; o Mokxi conta o chip inteiro. Um Mega tem mais espaço: o Mokxi informa um máximo de 262.144 bytes de flash e 8.192 bytes de RAM para ele.

Quando o aviso aparece

Compilamos um sketch com um buffer global char buffer[] de tamanhos diferentes. Com 1200 bytes a compilação informou "Global variables use 1,370 bytes (67%) of dynamic memory, leaving 678 bytes for local variables" e nenhum aviso. Com 1400 bytes informou 1.570 bytes (77%), "leaving 478 bytes for local variables", e então "Low memory available, stability problems may occur." Com 2000 bytes não compilou: as globais não cabem mais, e a compilação diz global variables do not fit in the 2 KB SRAM.

O aviso é uma regra prática. O IDE o imprime acima de três quartos da RAM, e o Mokxi faz o mesmo, e também quando o que sobra é menor que o espaço que o runtime dele reserva para a pilha. Um sketch a 80% com funções rasas pode rodar por anos; um sketch a 70% com uma recursão profunda ou um array local grande pode travar na hora.

Como são os "stability problems"

A pilha cresce do topo da RAM para baixo, na direção das globais, e nada a impede quando chega lá. Ela escreve por cima das variáveis que estiverem no caminho e o sketch continua com o estrago. Nenhum erro é impresso e nada reinicia. É por isso que os problemas parecem aleatórios: um valor muda sozinho, uma string ganha lixo no fim, ou a placa reinicia quando uma função raramente usada é chamada.

Este sketch preenche um buffer global de 1734 bytes com a letra A, chama uma função que mantém 64 bytes de variáveis locais e se chama de novo, depois conta quanto do buffer deixou de ser A. A compilação informou 1.946 bytes (95%), "leaving 102 bytes for local variables", e o aviso. Com a função chamada três níveis abaixo, 48 bytes do buffer tinham mudado. Cinco níveis abaixo, 188 bytes tinham. Um ou dois níveis abaixo, nada tinha mudado, e o sketch rodou normalmente de todas as formas, imprimindo seus resultados sem sinal de problema.

A pilha encontrando uma global, contada
char buffer[1734];

int depth(int n) {
  char local[64];
  memset(local, n, sizeof(local));
  if (n == 0) return local[0];
  return depth(n - 1) + local[63];
}

void setup() {
  Serial.begin(9600);
  memset(buffer, 'A', sizeof(buffer));
  Serial.println(depth(5));
  int changed = 0;
  for (int i = 0; i < (int)sizeof(buffer); i++) {
    if (buffer[i] != 'A') changed++;
  }
  Serial.print("bytes of buffer changed: ");
  Serial.println(changed);
}

void loop() {
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

"Sketch too big": o flash está cheio

A flash também tem um limite rígido. A IDE do Arduino para com "Sketch too big" quando o programa não cabe, e antes não há nenhum aviso. No Mokxi, um sketch com uma tabela de 40.000 bytes na flash falha com firmware não cabe na flash de 32 KB, e a aba de compilação adiciona uma frase simples: o programa é maior do que os 32 KB de flash que esta placa tem, o mesmo limite de uma placa real.

As soluções são as de sempre: remover bibliotecas e código que o sketch não usa mais, diminuir tabelas grandes, ou escolher uma placa com mais espaço. Uma biblioteca incluída por causa de uma única função pode custar vários quilobytes, então verifique o que cada #include traz.

Soluções que liberam RAM

Make buffers the size you need, not the size you might need. Then move tables that never change into flash with PROGMEM, and read them back with pgm_read_byte(). A 1600-byte const byte table built for an Uno took 1,786 bytes (87%) of RAM and brought the warning; the same table declared PROGMEM took 186 bytes (9%), for 6 more bytes of flash, and printed the same values.

O texto que você imprime é o outro grande consumidor. Na IDE do Arduino, Serial.println(F("...")) mantém o texto na flash e economiza sua RAM, e em um sketch com muitas mensagens isso costuma resolver tudo. O F() do Mokxi faz o mesmo nas placas AVR: vinte linhas longas ocuparam 1.800 bytes (88%) de RAM impressas como estão e 170 bytes (8%) envolvidas em F(), ao custo de 52 bytes a mais de flash, e imprimiram o mesmo texto.

Por último, a classe String cria e libera cópias no heap, que fica entre as globais e a pilha, e com o passar das horas isso pode deixar a RAM livre em pedaços pequenos demais para usar. Em uma placa com 2 KB, arrays de char de tamanho fixo são a escolha mais segura para qualquer coisa que rode por muito tempo. Se o sketch ainda não couber, uma Mega, com quatro vezes a RAM, ou um ESP32 é a solução honesta.

Abra este circuito no editor. Arduino Uno: um potenciômetro em A0, impresso, ligado como no exemplo no topo desta página. Troque um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

"Low memory available, stability problems may occur" é um erro?

Não. É um aviso de que as variáveis globais usam mais do que cerca de três quartos da RAM. O sketch compila e o upload é feito. Ele pode funcionar bem, ou pode se comportar mal quando a pilha precisar de mais espaço do que sobrou.

Quanta memória um Arduino Uno tem?

32 KB de flash para o programa, dos quais a IDE do Arduino oferece 32.256 bytes porque o bootloader reserva 512, e 2.048 bytes de RAM para variáveis e a pilha.

O que significa "Sketch too big"?

O programa não cabe na flash da placa. Remova bibliotecas e código não usados, encolha tabelas grandes, ou use uma placa com mais flash, como uma Mega.

Como reduzir o uso de RAM em um Arduino?

Encolha buffers, coloque tabelas constantes em PROGMEM, envolva o texto impresso em F() em uma placa real, evite String em sketches de execução longa e mantenha arrays grandes fora de funções que chamam a si mesmas.

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.