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: Flash, SRAM и EEPROM
В микроконтроллере Arduino есть три вида памяти с совершенно разными задачами. Flash (память программ) хранит скомпилированный код; данные сохраняются без питания, а запись происходит только при загрузке. SRAM (оперативная память) хранит переменные, данные вызовов функций и временные данные; она быстрая, но очищается при отключении платы. EEPROM — небольшая область для данных, которые нужно сохранять, но которые редко меняются: например, настроек и калибровочных значений. На AVR-платах, таких как Uno, эти три вида памяти находятся в отдельных адресных пространствах (гарвардская архитектура). Эта особенность объясняет, зачем нужны F() и PROGMEM, которые мы рассмотрим ниже.
| Память | Объём на Uno | Что хранится? | При отключении питания | Ресурс записи |
|---|---|---|---|---|
| Flash | 32 КБ (0,5 КБ отведено загрузчику, доступно 32 256 байт) | Код программы, данные PROGMEM | Сохраняется | Около 10 000 циклов стирания/записи |
| SRAM | 2 КБ (2 048 байт) | Переменные, массивы, стек и куча | Теряется | Не ограничен |
| EEPROM | 1 КБ (1 024 байта) | Настройки, счётчики, калибровка | Сохраняется | Около 100 000 записей в каждую ячейку |
Использовать EEPROM вместо ОЗУ — не решение: она медленная, а число записей в каждую ячейку ограничено. Если на каждом проходе цикла записывать в EEPROM быстро меняющуюся переменную, ячейка может износиться за несколько дней. Правильные способы работы с EEPROM описаны в руководстве по EEPROM Arduino.
Объём памяти разных плат
| Плата | Flash (программы) | SRAM | EEPROM |
|---|---|---|---|
| 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 2560 | 256 КБ (доступно 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 (недостаточно памяти; секция данных превышает доступный объём памяти платы) | Когда глобальные переменные превышают объём ОЗУ | Код нельзя загрузить; нужно уменьшить расход ОЗУ |
Устройство 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() | 444 | 9 |
| Serial.begin(9600) | 1 438 | 184 |
| + Serial.println("a 44-character text") (добавлена строка, выводящая текст из 44 символов) | 1 518 | 232 |
| Тот же текст с F() | 1 530 | 188 |
| analogRead + Serial.println(int) | 1 892 | 188 |
| Вычисление с float + Serial.println(float) | 3 380 | 200 |
| Объединение String: "A0=" + String(analogRead(A0)) | 3 316 | 202 |
| Та же задача с snprintf и массивом char | 3 232 | 194 |
| Одна запись через Wire (I2C) | 2 476 | 225 |
| SD-карта: begin, open, println, close | 10 496 | 837 |
| Массив int veri[700] | 1 780 | 1 588 (77%, предупреждение Low memory) |
| Массив int veri[950] | 1 780 | 2 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() может вернуть несколько сотен байт ОЗУ. Код ниже показывает разницу и измеряет свободное ОЗУ во время работы:
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 переносит всё это во флеш-память.
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}| Функция / макрос | Что делает? |
|---|---|
| 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 | Определяет длину строки во флеш-памяти, копирует блок из флеш-памяти |
Используй массивы char вместо String
Класс String в Arduino удобен, но каждое объединение (+) запрашивает в куче новый блок и освобождает старый. Тысячи повторений в крошечной куче Uno оставляют память с множеством свободных промежутков. Программа часами работает нормально, а затем внезапно зависает, и найти ошибку очень трудно. Решение — массивы char заранее известного размера: память выделяется один раз, никогда не фрагментируется, а занятые байты видны в выводе сборки. Код ниже читает команды из монитора порта без String и форматирует результат измерения в одну строку:
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 |
| int | 2 байта | 4 байта | От -32 768 до 32 767 |
| unsigned int, uint16_t | 2 байта | uint16_t — 2, unsigned int — 4 байта | 0–65 535 |
| long, unsigned long (4-байтовые целые типы) | 4 байта | 4 байта | unsigned long: 0–4 294 967 295 |
| float | 4 байта | 4 байта | Около 6–7 значащих цифр |
| double | 4 байта (как 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 / FastLED | 3 байта на светодиод (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 МБ и больше) выполнят его с небольшими изменениями.
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?.
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 (не удалось выделить память). Объединение строк в цикле, создание больших списков и один очень длинный файл кода — самые частые причины этой ошибки.
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?

| Ситуация | Рекомендация |
|---|---|
| После 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 |
| Хочется работать на MicroPython | Raspberry 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 failed | begin() не может выделить буфер на 1 КБ | Оборачивай строки в F(), перейди на постраничный режим U8g2 |
| Плата случайным образом перезагружается, хотя с памятью всё выглядит нормально | Возможно, проблема в питании, а не в памяти | Подай отдельное питание на моторы и реле, добавь конденсатор |
| Элементы массива содержат бессмысленные значения | Запись за границы массива | Проверь индекс; определяй границы цикла через sizeof |
| Stack canary watchpoint triggered на ESP32 | Переполнение стека задачи | Сделай большие локальные массивы глобальными или увеличь стек задачи |
Обычно нехватку памяти 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 полностью устраняют эту проблему.
Что собрать после прочтения
Все проекты
Гимн Турции на зуммере
Нажми кнопку, и маленький зуммер начнёт нота за нотой играть Государственный гимн Турции.

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

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

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

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

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

Кодовый замок с клавиатурой 4x4 и LCD
Маленький электронный дверной замок, который не пускает тех, кто не знает кода. Ты нажимаешь клавишу решётки и вводишь код на клавиатуре; если он верный, экран сообщает, что доступ разрешён…
Другие статьи
Приложение BlueGrays
Собери эту схему шаг за шагом в телефоне
Схема подключения, код и список деталей на одном экране. 500+ проектов на Arduino, ESP32 и Pico готовы к сборке.
Наведи камеру телефона
Наведи камеру на код — откроется магазин приложений на телефоне.
или открыть магазин

