Руководства · 13 мин чтения

Arduino: не хватает памяти — ошибки Sketch too big и Low memory

Не хватает памяти Arduino? Разбираем Flash, SRAM и EEPROM, F() и PROGMEM, массивы char вместо String, измерение свободного ОЗУ и переход на Mega или ESP32.

Предупреждение о нехватке памяти Arduino означает, что программа или переменные не помещаются в память платы. Обычно это проявляется одним из двух способов: код не загружается, потому что сборка останавливается с сообщением Sketch too big (скетч слишком большой), либо код загружается после предупреждения Low memory available, stability problems may occur (мало свободной памяти, возможны проблемы со стабильностью), а затем плата случайным образом перезагружается, выводит мусорные символы в монитор порта или зависает. У Arduino Uno всего 32 КБ памяти программ и 2 КБ ОЗУ, поэтому проблема особенно часто возникает в проектах с дисплеем, SD-картой и несколькими датчиками.

В этом руководстве ты сначала узнаешь, чем отличаются Flash, SRAM и EEPROM и как читать две строки в конце сборки. Затем на примере результатов реальных сборок для Uno разберёшься, какая строка сколько памяти занимает, как убрать постоянные данные из ОЗУ с помощью макроса F() и PROGMEM, как использовать массивы char вместо String, сколько памяти незаметно расходуют библиотеки и как измерять свободное ОЗУ во время работы. В последней части рассмотрим контроль памяти на ESP32 и Raspberry Pi Pico и ситуации, когда стоит перейти на Mega или ESP32.

Плата Arduino Uno и её микроконтроллер ATmega328P
ATmega328P в основе Arduino Uno: 32 КБ флеш-памяти, 2 КБ SRAM и 1 КБ EEPROM. Большинство проблем с памятью возникает именно в этих 2 КБ ОЗУ.

Три вида памяти Arduino: Flash, SRAM и EEPROM

В микроконтроллере Arduino есть три вида памяти с совершенно разными задачами. Flash (память программ) хранит скомпилированный код; данные сохраняются без питания, а запись происходит только при загрузке. SRAM (оперативная память) хранит переменные, данные вызовов функций и временные данные; она быстрая, но очищается при отключении платы. EEPROM — небольшая область для данных, которые нужно сохранять, но которые редко меняются: например, настроек и калибровочных значений. На AVR-платах, таких как Uno, эти три вида памяти находятся в отдельных адресных пространствах (гарвардская архитектура). Эта особенность объясняет, зачем нужны F() и PROGMEM, которые мы рассмотрим ниже.

ПамятьОбъём на UnoЧто хранится?При отключении питанияРесурс записи
Flash32 КБ (0,5 КБ отведено загрузчику, доступно 32 256 байт)Код программы, данные PROGMEMСохраняетсяОколо 10 000 циклов стирания/записи
SRAM2 КБ (2 048 байт)Переменные, массивы, стек и кучаТеряетсяНе ограничен
EEPROM1 КБ (1 024 байта)Настройки, счётчики, калибровкаСохраняетсяОколо 100 000 записей в каждую ячейку

Использовать EEPROM вместо ОЗУ — не решение: она медленная, а число записей в каждую ячейку ограничено. Если на каждом проходе цикла записывать в EEPROM быстро меняющуюся переменную, ячейка может износиться за несколько дней. Правильные способы работы с EEPROM описаны в руководстве по EEPROM Arduino.

Объём памяти разных плат

ПлатаFlash (программы)SRAMEEPROM
Arduino Uno R3 / Nano (ATmega328P)32 КБ (доступно: Uno — 32 256, Nano — 30 720 байт)2 КБ1 КБ
Arduino Leonardo / Pro Micro (ATmega32U4)32 КБ (доступно 28 672 байта)2,5 КБ1 КБ
Arduino Mega 2560256 КБ (доступно 253 952 байта)8 КБ4 КБ
Arduino Uno R4 (RA4M1)256 КБ32 КБ8 КБ (флеш-память данных)
ESP32 (WROOM)Микросхема флеш-памяти на 4 МБ (раздел приложения по умолчанию — 1,25 МБ)520 КБ (программе остаётся около 300 КБ кучи)Нет; Preferences хранит данные во флеш-памяти
Raspberry Pi Pico (RP2040)Микросхема флеш-памяти на 2 МБ264 КБНет; эмулируется во флеш-памяти

Разница огромна: у ESP32 в 260 раз больше ОЗУ, чем у Uno, а у Pico — примерно в 130 раз. Поэтому экономия памяти, требующая серьёзных усилий на Uno, на ESP32 часто не нужна. И всё же Uno, Nano и Pro Mini остаются самыми распространёнными платами благодаря низкой цене и простоте, так что умение обходиться 2 КБ полезно каждому, кто работает с Arduino.

Читаем вывод сборки: Sketch uses и Global variables use

В конце каждой успешной сборки Arduino IDE выводит две строки. Скомпилируй для Uno скетч с пустыми setup() и loop(), и ты увидишь Sketch uses 444 bytes (1%) of program storage space (скетч занимает 444 байта, или 1% памяти программ) и Global variables use 9 bytes (0%) of dynamic memory, leaving 2039 bytes for local variables (глобальные переменные занимают 9 байт, или 0% динамической памяти; для локальных переменных остаётся 2 039 байт). Первая строка показывает, сколько флеш-памяти занимает программа, вторая — сколько ОЗУ занимают глобальные и статические переменные. Главное: вторая строка учитывает только переменные, размер которых известен при компиляции. Локальные переменные функций (стек) и память, выделяемая во время работы через String или malloc (куча), не учитываются. Оставшееся место «для локальных переменных» им приходится делить между собой.

СообщениеКогда появляется?Что означает?
Sketch uses ... bytes (x%) of program storage space (скетч занимает указанную часть памяти программ)При каждой сборкеМесто, которое код занимает во флеш-памяти
Global variables use ... bytes (x%) of dynamic memory (глобальные переменные занимают указанную часть динамической памяти)При каждой сборкеДоля ОЗУ, занятая глобальными и статическими переменными
«Low memory available, stability problems may occur» (мало свободной памяти, возможны сбои в работе)Когда глобальные переменные занимают больше примерно 75% ОЗУКод загружается, но для стека и кучи остаётся мало места
Sketch too big и text section exceeds available space in board (скетч слишком большой; секция кода превышает доступный объём памяти платы)Когда программа не помещается во флеш-памятьКод нельзя загрузить; нужно уменьшить расход флеш-памяти
Not enough memory и data section exceeds available space in board (недостаточно памяти; секция данных превышает доступный объём памяти платы)Когда глобальные переменные превышают объём ОЗУКод нельзя загрузить; нужно уменьшить расход ОЗУ
Предупреждение «Low memory» — не ошибка, и код загружается без возражений; именно в этом и опасность. Например, скетч с int veri[700]; использует на Uno 1 588 байт (77%) под глобальные переменные и оставляет стеку и куче лишь 460 байт. Когда несколько вложенных вызовов функций, объединение String или буфер, выделяемый библиотекой в begin(), занимают это место, программа аварийно завершает работу. Признаки — случайные перезагрузки, повреждённые переменные и зависания; чтобы отличить их от проблем с питанием, прочитай также статью Arduino постоянно перезагружается.

Устройство SRAM: глобальные переменные, куча и стек

2 048 байт ОЗУ Uno разделены на четыре области. Внизу находятся глобальные переменные с начальным значением (.data), выше — глобальные переменные, изначально равные нулю (.bss); сумму этих двух областей компилятор показывает в строке «Global variables use». Далее идёт куча, которая растёт вверх: здесь находятся объекты String и память, выделенная через new и malloc. С самого верха ОЗУ вниз растёт стек: каждый вызов функции помещает сюда адрес возврата и локальные переменные, а при прерывании здесь сохраняются регистры. Если куча и стек встречаются в свободном пространстве между ними, они перезаписывают друг друга и программа начинает работать непредсказуемо.

ОбластьСодержимоеНаправление ростаВидна в выводе сборки?
.dataИнициализированные глобальные и статические переменные, строки без F()Фиксированный размерДа
.bssНеинициализированные (нулевые) глобальные и статические переменные, буферы библиотекФиксированный размерДа
КучаString, new, malloc, буферы, выделяемые некоторыми библиотеками в begin()ВверхНет
СтекЛокальные переменные, адреса возврата функций, регистры, сохраняемые при прерыванияхВнизНет

У такого устройства есть два важных следствия. Во-первых, каждая строка без F() копируется в .data, потому что AVR-процессор не может читать данные во флеш-памяти как обычную переменную. Во-вторых, куча фрагментируется: при создании и удалении объектов String разного размера остаются небольшие промежутки, и даже если общий объём свободной памяти кажется достаточным, выделить большой блок не удаётся. Поэтому в программах, которые долго работают на Uno, безопаснее по возможности обходиться без кучи.

Сначала измерь: какая строка сколько памяти занимает?

Первый шаг к решению проблемы с памятью — измерение, а не догадки. Каждая строка таблицы ниже — реальный результат сборки небольшого скетча, отдельно скомпилированного для Arduino Uno с ядром Arduino AVR 1.8.6. В зависимости от версий библиотек и ядра значения могут отличаться на несколько байт, но соотношения всегда остаются теми же.

Что есть в скетче?Флеш-память (байт)ОЗУ глобальных переменных (байт)
Пустые setup() и loop()4449
Serial.begin(9600)1 438184
+ Serial.println("a 44-character text") (добавлена строка, выводящая текст из 44 символов)1 518232
Тот же текст с F()1 530188
analogRead + Serial.println(int)1 892188
Вычисление с float + Serial.println(float)3 380200
Объединение String: "A0=" + String(analogRead(A0))3 316202
Та же задача с snprintf и массивом char3 232194
Одна запись через Wire (I2C)2 476225
SD-карта: begin, open, println, close10 496837
Массив int veri[700]1 7801 588 (77%, предупреждение Low memory)
Массив int veri[950]1 7802 088 (101%, не компилируется)

Выводы очевидны. Одна лишь Serial.begin() занимает 175 байт ОЗУ, потому что последовательный порт выделяет буфер приёма на 64 байта и буфер передачи на 64 байта. Одна строка из 44 символов расходует 44 байта ОЗУ; если использовать F(), эта память освобождается. Использование float добавляет во флеш-память около 1,5 КБ кода для операций с плавающей точкой. Одна библиотека SD расходует 10 КБ флеш-памяти и около 830 байт ОЗУ; на один файл журнала уходит 40% ОЗУ Uno. В примере со String расход ОЗУ глобальными переменными кажется небольшим, но реальные затраты появляются в куче во время работы и никогда не видны в выводе сборки.

Макрос F(): убираем постоянные строки из ОЗУ

На Uno любая строка в кавычках, например «Temperature: », находится во флеш-памяти, но при запуске программы копируется в ОЗУ и постоянно занимает там место. Макрос F() предотвращает копирование: строка остаётся во флеш-памяти, а функции вроде Serial.print читают её посимвольно прямо оттуда. F() работает со всеми объектами, производными от класса Print, включая Serial, LiquidCrystal, LiquidCrystal_I2C, Adafruit SSD1306 и файлы SD. В проекте с меню, сообщениями об ошибках и справочным текстом простое добавление F() может вернуть несколько сотен байт ОЗУ. Код ниже показывает разницу и измеряет свободное ОЗУ во время работы:

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}

Функция bosRam() вычисляет расстояние между текущей вершиной стека и концом кучи, то есть число байт, оставшихся до их встречи. Вызывай её в loop() сразу после обновления дисплея или записи на SD-карту, чтобы поймать момент наибольшего расхода памяти. Практическое правило: не допускай, чтобы свободное ОЗУ Uno во время работы опускалось ниже 200–300 байт. F() не работает с функциями, ожидающими char* (strcmp, strcpy); для них нужны версии _P и макрос PSTR(), показанные ниже.

PROGMEM: храним большие таблицы во флеш-памяти

F() подходит только для строк. Для больших массивов, которые никогда не меняются, например массивов нот, значков дисплея (битовых изображений), таблиц символов, калибровочных кривых или списков сообщений, используют ключевое слово PROGMEM. Объявленный с PROGMEM массив никогда не копируется в ОЗУ; для чтения вместо обычного доступа к массиву нужны специальные функции, такие как pgm_read_byte и pgm_read_word. Например, мелодия из 100 нот с таблицами частот и длительностей занимает 400 байт — пятую часть ОЗУ Uno, и PROGMEM переносит всё это во флеш-память.

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}
Функция / макросЧто делает?
pgm_read_byte(&array[i])Читает 1 байт из флеш-памяти (массивы byte, char, uint8_t, битовые изображения)
pgm_read_word(&array[i])Читает 2 байта из флеш-памяти (int, uint16_t; таблицы нот и чисел на Uno)
pgm_read_dword / pgm_read_floatЧитает 4-байтовые значения long и float
pgm_read_ptr(&table[i])Читает указатель, хранящийся во флеш-памяти (таблицы строк)
strcpy_P(dest, src)Копирует строку из флеш-памяти в буфер ОЗУ
strcmp_P(ram_text, PSTR("..."))Сравнивает строку в ОЗУ со строкой во флеш-памяти
strlen_P / memcpy_PОпределяет длину строки во флеш-памяти, копирует блок из флеш-памяти
На ESP32 и Pico массивы, объявленные как const, уже остаются во флеш-памяти; PROGMEM там не действует, но и не вызывает ошибок, а функции pgm_read_* определены. Поэтому код с PROGMEM компилируется на всех трёх платах. Одно исключение: при чтении таблицы указателей pgm_read_word работает на Uno, но обрезает указатель на 32-битных платах; для переносимого кода используй pgm_read_ptr.

Используй массивы char вместо String

Класс String в Arduino удобен, но каждое объединение (+) запрашивает в куче новый блок и освобождает старый. Тысячи повторений в крошечной куче Uno оставляют память с множеством свободных промежутков. Программа часами работает нормально, а затем внезапно зависает, и найти ошибку очень трудно. Решение — массивы char заранее известного размера: память выделяется один раз, никогда не фрагментируется, а занятые байты видны в выводе сборки. Код ниже читает команды из монитора порта без String и форматирует результат измерения в одну строку:

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}

В коде стоит обратить внимание на три детали. snprintf знает размер буфера, поэтому даже длинный текст не переполняет массив; sprintf такой защиты не даёт. Поскольку семейство printf на AVR по умолчанию не поддерживает формат %f, значение float сначала преобразуется в текст через dtostrf. А ограничение буфера команд (konum < sizeof(komut) - 1) не даёт длинной строке перезаписать другую часть памяти. Если без String не обойтись (некоторые библиотеки возвращают такой объект), хотя бы заранее зарезервируй место в setup() через text.reserve(64) и сделай String глобальным; это значительно уменьшит фрагментацию.

Правильный тип данных и локальные переменные

ТипUno (AVR)ESP32 / PicoДиапазон значений (Uno)
bool, char, byte (однобайтовые типы)1 байт1 байтbyte: 0–255
int2 байта4 байтаОт -32 768 до 32 767
unsigned int, uint16_t2 байтаuint16_t — 2, unsigned int — 4 байта0–65 535
long, unsigned long (4-байтовые целые типы)4 байта4 байтаunsigned long: 0–4 294 967 295
float4 байта4 байтаОколо 6–7 значащих цифр
double4 байта (как float)8 байтНа Uno не отличается от float
  • byte для небольших чисел: Использование byte вместо int для номеров пинов, счётчиков и процентов от 0 до 255 экономит 1 байт на переменную и 200 байт в массиве из 200 элементов.
  • const для номеров пинов: Компилятор встраивает константы вида const byte LED_PIN = 13; прямо в код и не резервирует для них ОЗУ.
  • Флаги вкл/выкл в битах: Восемь переменных bool занимают 8 байт; сохрани те же сведения в битах одного байта через bitRead и bitWrite, и хватит 1 байта.
  • Следи за большими локальными массивами: Объявление char buffer[300]; внутри функции не видно в выводе сборки, но при каждом вызове функции оно занимает 300 байт стека. Делай большие буферы глобальными, чтобы их размер был виден.
  • Избегай рекурсии: Каждый вызов функцией самой себя создаёт новый уровень стека; на Uno даже несколько десятков уровней могут занять всё ОЗУ.
  • Передавай большие структуры по ссылке: Передача struct в функцию по значению помещает копию в стек; передача по ссылке в виде const Settings& s обходится без копирования.

Скрытый расход памяти библиотеками

Когда проекту внезапно перестаёт хватать памяти, причина часто кроется не в твоём коде, а в добавленной библиотеке. Одни библиотеки резервируют ОЗУ при компиляции (как глобальный буфер), другие берут память из кучи при вызове begin(); во втором случае вывод сборки не вызывает подозрений, но память заканчивается уже во время работы платы. Часть значений ниже взята из таблицы измерений выше, остальные — из размеров буферов библиотек:

Библиотека / возможностьРасход ОЗУ (Uno)Когда выделяется?Более экономный вариант
SerialОколо 175 байт (буферы 64 + 64 байта)При компиляции (глобально)Полностью убери Serial, если он не нужен
Wire (I2C)Около 215 байтПри компиляции (глобально)Неизбежно даже с одним устройством I2C; ищи экономию в другом месте
SoftwareSerialОколо 120 байт (буфер приёма на 64 байта)При компиляции (глобально)По возможности аппаратный последовательный порт или дополнительные порты Mega
SDОколо 830 байт и ещё около 10 КБ флеш-памятиПри компиляции (глобально)Поручи ведение журнала ESP32 или Mega
Adafruit SSD1306 128x64Буфер кадра на 1 024 байтаИз кучи внутри begin()Постраничный режим U8g2 (128 байт) или U8x8 только для текста
Adafruit NeoPixel / FastLED3 байта на светодиод (60 светодиодов = 180 байт)При запускеОграничь число светодиодов реальной длиной ленты

Эта таблица объясняет, почему одновременно использовать OLED-дисплей, SD-карту и модуль Wi-Fi на Uno почти невозможно: один лишь буфер SSD1306 вместе с библиотекой SD занимают 1,8 КБ, почти ничего не оставляя программе из 2 КБ ОЗУ. Ошибка SSD1306 allocation failed (не удалось выделить память для SSD1306) при работе с OLED-дисплеем означает именно сбой выделения памяти в куче; способы исправления есть и в статье OLED-дисплей SSD1306.

Sketch too big: как уменьшить расход флеш-памяти

  • Отключи отладочный вывод: Строки Serial.print, добавленные при разработке, расходуют и флеш-память, и ОЗУ. Макрос DEBUG ниже позволяет исключить их все из сборки изменением одной строки.
  • Избегай float и sprintf: Как показывают измерения, float добавляет около 1,5 КБ, а snprintf — больше 1 КБ кода. В большинстве проектов достаточно умножить температуру на 10 и хранить её как int (235 вместо 23,5 °C).
  • Замени повторяющийся код функциями и массивами: Хранение номеров пинов в массиве и обработка в цикле вместо отдельного блока из десяти строк для каждого светодиода заметно сокращают код.
  • Выбери меньшую библиотеку: Если графика не нужна, U8x8 или LiquidCrystal_I2C занимают намного меньше места, чем библиотеки на основе Adafruit GFX. Вместо подключения целой библиотеки ради одной функции подумай о самостоятельном написании этой части.
  • Проверь выбор платы: Arduino IDE рассчитывает предел по выбранной плате: 32 256 байт для Uno, 30 720 для Nano (со старым или новым загрузчиком) и 28 672 для Leonardo. Если выбрана неверная плата, неверными будут и предел, и определения пинов.
  • Перейди на более мощную плату: Если после всех изменений код всё равно не помещается, Mega (256 КБ) или ESP32 (1,25 МБ и больше) выполнят его с небольшими изменениями.
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}

При DEBUG 1 этот скетч занимает на Uno 2 292 байта флеш-памяти и 188 байт ОЗУ; установи DEBUG 0, и код Serial полностью исчезнет из сборки, а расход снизится до 934 байт флеш-памяти и 9 байт ОЗУ. Разницы в 1,3 КБ флеш-памяти и 179 байт ОЗУ часто хватает, чтобы добавить новую возможность в готовый проект.

Измерение памяти на ESP32

У ESP32 много памяти, но её объём не бесконечен. Включение Wi-Fi выделяет десятки КБ ОЗУ, а вместе с Bluetooth расход может приблизиться к 100 КБ; веб-серверы, документы JSON и буферы изображений тоже быстро заполняют память. У некоторых модулей, например ESP32-CAM, есть дополнительная PSRAM (обычно 4 МБ), где размещаются большие буферы. Что касается флеш-памяти, если приложение не помещается в стандартный раздел на 1,25 МБ, его можно увеличить до 3 МБ, выбрав «Huge APP» в настройке Partition Scheme меню «Инструменты» (Tools). Общие возможности ESP32 описаны в статье Что такое 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}

Два самых полезных показателя здесь — getMinFreeHeap и getMaxAllocHeap. Первый показывает минимальный объём свободной кучи с момента запуска программы, второй — наибольший блок, который можно выделить целиком. Если свободно 100 КБ кучи, но самый большой блок меньше 10 КБ, куча фрагментирована и выделить память под большой String или документ JSON может не получиться. На ESP32 функция loop() выполняется в собственной задаче со стеком на 8 КБ; uxTaskGetStackHighWaterMark показывает часть этого стека, которая ещё ни разу не использовалась. Если значение опускается ниже нескольких сотен байт, может возникнуть ошибка «Stack canary watchpoint triggered» (сработала защита стека).

Память Raspberry Pi Pico и MicroPython

264 КБ ОЗУ Pico — огромный объём по сравнению с Uno, но часть занимает интерпретатор MicroPython; программе обычно остаётся около 190 КБ кучи. В MicroPython памятью управляет сборщик мусора: неиспользуемые объекты удаляются при вызове gc.collect() или когда память подходит к концу. Когда она действительно заканчивается, возникает MemoryError: memory allocation failed (не удалось выделить память). Объединение строк в цикле, создание больших списков и один очень длинный файл кода — самые частые причины этой ошибки.

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]))

Чтобы экономить память в MicroPython, заранее выделяй буферы через bytearray и повторно используй их в цикле, объявляй постоянные числа через const(), преобразуй большие модули в предварительно скомпилированные файлы .mpy с помощью mpy-cross и вызывай gc.collect() перед длительными операциями. Основные команды MicroPython на Pico описаны в статье Основы MicroPython, а общие возможности платы — в статье Что такое Raspberry Pi Pico?.

Когда стоит перейти на Mega или ESP32?

Плата Arduino Mega 2560
Arduino Mega 2560: 256 КБ флеш-памяти, 8 КБ SRAM и 4 КБ EEPROM. Код для Uno часто работает на ней без изменений.
СитуацияРекомендация
После F(), PROGMEM и массивов char остаётся больше 300 байт свободного ОЗУОставайся на Uno; проблема решена
Несколько датчиков и меню с OLED-дисплеем или SD-картой, а ОЗУ всё ещё не хватаетArduino Mega 2560: в 4 раза больше ОЗУ, те же пины на 5 V и библиотеки
Программа превышает 32 КБ, но ОЗУ достаточноMega или Uno R4: 256 КБ флеш-памяти
Нужны Wi-Fi, веб-сервер, большие буферы или обработка изображенийESP32: 520 КБ ОЗУ, 4 МБ флеш-памяти, Wi-Fi и Bluetooth
Хочется работать на MicroPythonRaspberry Pi Pico или Pico W
Небольшой узел с датчиком, который должен месяцами работать от батареекОптимизируй код на Uno или используй Pro Mini; более мощная плата потребляет больше тока

При переходе на Mega большая часть кода остаётся прежней; просто помни, что пины I2C — 20 (SDA) и 21 (SCL), а пины SPI — 50–53. Переход на ESP32 связан с отличиями: логический уровень 3,3 V, другие номера пинов и 12-битный результат analogRead (0–4 095). Чтобы выбрать подходящую плату, прочитай сравнение Arduino или ESP32, а о варианте с поддержкой 5 V и гораздо большим объёмом памяти — статью Arduino Uno R4.

Частые ошибки и их решения

ПризнакВероятная причинаРешение
Sketch too big, код не загружаетсяПрограмма не помещается во флеш-памятьОтключи отладочный вывод, сократи использование float и sprintf, выбери меньшие библиотеки, при необходимости перейди на Mega
Код загружается, но через несколько минут зависаетОбъединения String фрагментируют кучуИспользуй массивы char и snprintf вместо String; измерь свободное ОЗУ
Мусорные символы в мониторе порта, значения переменных меняются сами по себеСтек перезаписывает кучуСнизь расход ОЗУ глобальными переменными до уровня ниже 75%, убери большие локальные массивы
SSD1306 allocation failedbegin() не может выделить буфер на 1 КБОборачивай строки в F(), перейди на постраничный режим U8g2
Плата случайным образом перезагружается, хотя с памятью всё выглядит нормальноВозможно, проблема в питании, а не в памятиПодай отдельное питание на моторы и реле, добавь конденсатор
Элементы массива содержат бессмысленные значенияЗапись за границы массиваПроверь индекс; определяй границы цикла через sizeof
Stack canary watchpoint triggered на ESP32Переполнение стека задачиСделай большие локальные массивы глобальными или увеличь стек задачи
Чтобы предупредить проблемы с памятью с самого начала, записывай оба процентных показателя из вывода сборки при каждом добавлении нового модуля в проект. Начинай применять F() и PROGMEM, когда расход ОЗУ глобальными переменными превышает 60%; ожидание предупреждения на 75% означает откладывание проблемы до момента, когда решить её будет труднее всего.

Обычно нехватку памяти Arduino можно устранить без замены платы: перенос постоянных строк во флеш-память с F(), больших таблиц — в PROGMEM, использование массивов char вместо String и отказ от ненужных библиотек позволяют удивительно много уместить в 2 КБ ОЗУ. В приложении BlueGrays ты можешь изучить требовательные к памяти проекты — игры на OLED, мелодии на зуммере и анимации на светодиодной матрице — с пошаговыми схемами и кодом, написанным с применением этих приёмов.

Частые вопросы

Что означает Low memory available на Arduino?

Это означает, что глобальные переменные занимают около 75% ОЗУ, а стеку и куче остаётся мало места. Код загружается, но во время работы возможны случайные перезагрузки, зависания и повреждение переменных. Оборачивание постоянных строк в F() и перенос больших массивов в PROGMEM обычно устраняют предупреждение.

Как исправить ошибку Sketch too big?

Эта ошибка означает, что программа не помещается во флеш-память. Отключи вывод Serial, добавленный для отладки, сократи использование float и sprintf, вынеси повторяющийся код в функции и выбери меньшие библиотеки. Если код всё равно не помещается, перейди на плату с большим объёмом флеш-памяти, например Arduino Mega или ESP32.

Сколько памяти у Arduino Uno?

У ATmega328P на Arduino Uno есть 32 КБ флеш-памяти (0,5 КБ отведено загрузчику), 2 КБ SRAM и 1 КБ EEPROM. Программа хранится во флеш-памяти, переменные — в SRAM, постоянные настройки — в EEPROM. Большинство проблем возникает именно в этих 2 КБ SRAM.

Что делает макрос F()?

F() предотвращает копирование постоянных строк, передаваемых функциям вроде Serial.print, в ОЗУ и оставляет их во флеш-памяти. На Uno каждый символ экономит один байт ОЗУ, что в проектах с множеством сообщений даёт сотни байт. На ESP32 и Pico он тоже компилируется, но не оказывает действия.

Как измерить свободное ОЗУ на Arduino?

На Uno, Nano и Mega используют небольшую функцию, которая вычисляет расстояние между стеком и кучей через переменные __heap_start и __brkval. На ESP32 те же сведения дают ESP.getFreeHeap() и ESP.getMinFreeHeap(), а в MicroPython — gc.mem_free(). Важно измерять в момент пикового расхода памяти.

Почему использование String на Arduino вызывает проблемы?

При каждом объединении объекты String запрашивают новую память в куче и освобождают старый блок, поэтому небольшая куча Uno со временем фрагментируется. Даже если общего объёма свободной памяти кажется достаточно, выделить новый блок не удаётся, и программа зависает. Массивы char фиксированного размера и snprintf полностью устраняют эту проблему.

Все проекты
Гимн Турции на зуммере
AR-15Средний

Гимн Турции на зуммере

Нажми кнопку, и маленький зуммер начнёт нота за нотой играть Государственный гимн Турции.

4.8(114)
235
Температура и влажность с DHT11
AR-55Средний

Температура и влажность с DHT11

Насколько тепло в твоей комнате и влажный ли воздух или сухой? Датчик DHT11 измеряет температуру и влажность, а Arduino выводит значения на двухстрочный LCD-экран и обновляет их каждые пару секунд.

4.7(47)
83
Игра в пинг-понг — SSD1306
AR-86Средний
Premium

Игра в пинг-понг — SSD1306

Мяч, две ракетки и ты: на маленьком OLED-экране ты играешь в настольный теннис — одну из самых первых видеоигр.

4.5(47)
65
OLED T-Rex Run: игра с динозавром на Arduino
AR-87Продвинутый
Premium

OLED T-Rex Run: игра с динозавром на Arduino

Игра с динозавром, которая появляется, когда пропадает интернет, теперь у тебя на столе: динозавр бежит по маленькому OLED-экрану, навстречу едут кактусы, а прыгаешь ты одной кнопкой.

4.7(33)
53
Пиксельная змейка на матрице 8x8
AR-88Продвинутый
Premium

Пиксельная змейка на матрице 8x8

Собери классическую игру «Змейка» своими руками и сыграй в неё. На цветной светодиодной матрице 8x8 ты джойстиком управляешь зелёной змейкой и ешь красные яблоки; с каждым яблоком змейка растёт…

4.7(39)
57
Игра на память на Arduino (4 светодиода + 4 кнопки + зуммер)
AR-93Продвинутый
Premium

Игра на память на Arduino (4 светодиода + 4 кнопки + зуммер)

Доверяешь своей памяти? Четыре цветных светодиода загораются в определённой последовательности, каждый со своей нотой, а ты повторяешь тот же порядок кнопками.

4.8(46)
69
Кодовый замок с клавиатурой 4x4 и LCD
AR-64Продвинутый
Premium

Кодовый замок с клавиатурой 4x4 и LCD

Маленький электронный дверной замок, который не пускает тех, кто не знает кода. Ты нажимаешь клавишу решётки и вводишь код на клавиатуре; если он верный, экран сообщает, что доступ разрешён…

4.8(59)
75