Память Arduino: что значит «Глобальные переменные используют … байт»

Две строки после сборки, которые все пролистывают

Нажмите «Проверить» — и после компиляции в консоли появится отчёт о памяти. В Arduino IDE это две фразы по-русски, в Trema IDE — две строки с полосками. Говорят они об одном и том же, только разными словами:

Первая строка — про Flash, память программ. «Скетч использует 1556 байт памяти устройства» значит: прошивка, которую сейчас запишут в плату, весит 1556 байт. «Всего доступно 32256 байт» — предел для этой платы. Проценты среда округляет вниз, поэтому 4,8 % показаны как 4 %.

Вторая строка — про SRAM, оперативную память. «Глобальные переменные используют 270 байт динамической памяти» — столько занято ещё до того, как выполнится первая команда setup(). «Оставляя 1778 байт для локальных переменных» — столько остаётся на саму работу программы. «Максимум: 2048 байт» — весь объём оперативной памяти Uno.

Trema IDE пишет то же самое короче: RAM: used 270 bytes from 2048 и Flash: used 1556 bytes from 32256, а полоска [=         ] показывает заполненность десятками процентов — по ней видно проблему, не читая цифр.

Три памяти в одной плате: Flash, SRAM и EEPROM

У микроконтроллера Arduino не одна память, а три, и у каждой своя работа. Путаница начинается, когда «32 КБ памяти» из характеристик платы принимают за место под переменные — а это Flash, и к переменным она отношения не имеет.

Проще всего представить это как рабочее место. Flash — инструкция на стене: написана один раз, при загрузке прошивки, и читается всё время работы. SRAM — стол: на нём лежит всё, с чем программа работает прямо сейчас, и стол этот у Uno совсем маленький — 2048 байт, в шестнадцать раз меньше Flash. EEPROM — ящик стола, куда убирают то, что должно сохраниться до завтра: настройки, счётчик включений, калибровку.

Отчёт сборки говорит только про первые две. Про EEPROM среда молчит, потому что её никто не «занимает» при компиляции — только ваша программа во время работы, командами EEPROM.put() и EEPROM.get().

«Скетч использует N байт памяти устройства» — это Flash

Во Flash попадает всё, что не меняется: машинный код вашего скетча, ядро Arduino (запуск платы, millis(), работа с пинами), код библиотек и константы, которые вы явно попросили оставить во Flash — через PROGMEM или макрос F().

Отсюда два частых вопроса. Почему у Uno «32 КБ», а доступно 32 256 байт? Потому что 512 байт занимает загрузчик — маленькая программа, которая принимает прошивку по USB и стирается только программатором. У Nano с загрузчиком старого образца под него уходит 2 КБ, поэтому там доступно 30 720 байт; у Leonardo и Pro Micro — 4 КБ, остаётся 28 672. Почему пустой скетч весит 444 байта? Это ядро: таблица прерываний, настройка таймера для millis() и delay(), инициализация портов. Меньше не бывает.

Flash расходуется предсказуемо: чем больше кода и библиотек, тем больше. Неожиданно дорого стоят только вещи, которые тянут за собой целые куски математики. Одна строчка Serial.println(t) с переменной float вместо int прибавляет к прошивке около 1,1 КБ — компилятор подключает библиотеку операций с плавающей точкой и перевода дробей в текст.

«Глобальные переменные используют N байт динамической памяти» — это SRAM

Слово «динамической» здесь сбивает с толку: имеется в виду просто оперативная память, а не «динамическое выделение». Число, которое показывает среда, — это статическая часть SRAM: то, что занято с первой миллисекунды и не освобождается никогда.

Что туда входит:

• Глобальные и статические переменные — всё, что объявлено вне функций: int counter;, массивы, структуры.
• Объекты библиотек, объявленные глобально: LiquidCrystal lcd(...), Servo motor, Adafruit_SSD1306 display(...). Последний держит буфер экрана 128×64 точки — 1024 байта, половину всей памяти Uno.
• Serial: один вызов Serial.begin() приносит с собой два буфера по 64 байта и сам объект — 175 байт сверху пустого скетча.
• Тексты в кавычках. Каждый Serial.print("...") и lcd.print("...") без F() копируется из Flash в SRAM при старте, по байту на символ, а кириллица — по два.

Сколько занимает переменная, зависит от типа. На восьмибитных платах (Uno, Nano, Mega) размеры такие:

«…оставляя N байт для локальных переменных» — самое важное число

Всё, что не занято статически, делят между собой два соседа: стек и куча. Стек растёт сверху вниз при каждом вызове функции — там лежат локальные переменные, аргументы, адреса возврата, данные прерываний. Куча растёт снизу вверх, когда программа просит память на ходу: String, new, malloc(). Между ними — то самое «оставляя 1778 байт».

Опасность в том, что никакой защиты между ними нет. Когда стек и куча встречаются, микроконтроллер не выдаёт ошибку — он просто начинает работать с чужими данными. Снаружи это выглядит как мистика: программа зависает через десять минут, плата перезагружается сама, в мониторе порта появляется мусор, экран показывает случайные символы, а после добавления одной безобидной строчки всё ломается. Если такое происходит, первым делом смотрите на строку про глобальные переменные.

Arduino IDE предупреждает заранее: когда глобальные переменные заняли больше 75 % SRAM, под отчётом появляется оранжевая строка «Мало доступной памяти, могут возникнуть проблемы со стабильностью». Прошивка при этом загрузится и даже, возможно, поработает — до первого глубокого вызова функции или длинной строки. Практическое правило для Uno и Nano: держите свободными хотя бы 400–500 байт, а если в программе есть String — больше.

«Скетч использует 0 байт памяти» — откуда ноль

Ноль здесь — не размер прошивки, а сбой измерения. Как мы выяснили, даже пустой скетч для Uno занимает 444 байта, поэтому «0 байт» означает, что среда не смогла посчитать: утилита размера не запустилась, отчиталась не в том формате или в пакете платы её вовсе нет. Обычные причины — повреждённая или неполная установка поддержки платы, сторонние ядра со своими настройками сборки, редко — антивирус, который заблокировал одну из утилит.

Прошивка при этом, как правило, собрана и загрузится. Но пользоваться средой, которая не видит размер программы, неудобно: вы не узнаете о приближении к пределу. Переустановите поддержку платы через менеджер плат или соберите тот же проект в Trema IDE — для Uno, Nano и Mega размеры считает движок сборки, и строки RAM: и Flash: появляются всегда.

Программа не помещается в память платы: «Sketch too big», «region overflowed», «Недостаточно памяти»

Когда прошивка не влезает, сообщения выглядят по-разному в зависимости от среды и платы, но их всегда можно свести к вопросу «какая память кончилась»:

Строки об ошибке Trema IDE переводит: над консолью появляется русская карточка, а исходное сообщение остаётся ниже.

Одна тонкость, про которую стоит знать. На Uno, Nano и Mega движок сборки считает переполнение оперативной памяти предупреждением, а не ошибкой: строка Warning! The data size … is greater than maximum allowed печатается, а сборка помечается успешной. Прошивка при этом работать не будет. Если плата после загрузки ведёт себя странно, посмотрите на строку RAM: — там будет больше 100 %.

Как освободить память: приёмы по убыванию пользы

Порядок не случайный: первые два приёма дают больше всего и почти ничего не стоят, последние — на случай, когда всё остальное уже сделано.

1. Тексты — во Flash макросом F()

Самая частая утечка оперативной памяти — обычные строки в кавычках. Оберните их в F(), и текст останется во Flash, откуда будет читаться по мере печати:

// Было: текст лежит в оперативной памяти — 270 байт SRAM.
Serial.println("Датчик температуры запущен, ждём показаний...");

// Стало: текст остался во Flash — 188 байт SRAM. Экономия 82 байта на одной строке.
Serial.println(F("Датчик температуры запущен, ждём показаний..."));

// F() работает везде, где печатают текст: lcd.print, display.print, client.print.
lcd.print(F("Температура:"));

В проекте с меню на экране и десятком отладочных сообщений это легко возвращает 300–500 байт — четверть всей памяти Uno.

2. Правильные типы вместо int по привычке

int    ledPin = 13;      // 2 байта, а хватило бы одного
byte   ledPin = 13;      // 1 байт: значения 0–255 — пины, яркость, проценты
int    values[100];      // 200 байт SRAM
byte   values[100];      // 100 байт SRAM — если хватает 0–255
long   counter = 0;      // 4 байта; если счёт до 32 767 — берите int
float  t = 23.5;         // 4 байта и ~1 КБ Flash на математику с плавающей точкой
int    t10 = 235;        // «десятые доли» в целом числе: 23,5 → 235

Замена int на byte в массиве из ста элементов — минус 100 байт (мы измерили: 388 против 288). Отказ от float экономит не столько SRAM, сколько Flash — около килобайта на первом же вычислении.

3. Не String, а массив char

String удобен, но на плате с 2 КБ памяти опасен: каждое сложение строк выделяет новый кусок кучи, старый освобождается — и между ними остаются дыры, в которые потом ничего не помещается. Отчёт сборки этого не покажет: он видит только 6 байт самого объекта. Программа со String в loop() может исправно работать час, а потом зависнуть.

// Дорого: String собирает строку в куче, кусочки остаются дырами.
String line = "T=" + String(analogRead(A0)) + " C";
Serial.println(line);

// Дёшево: буфер фиксированного размера на стеке, без кучи.
char line[16];
snprintf(line, sizeof(line), "T=%d C", analogRead(A0));
Serial.println(line);

// Дробное число в текст без float-версии printf (её на AVR нет):
char text[10];
dtostrf(23.5, 4, 1, text);   // "23.5"

4. Таблицы, шрифты и картинки — в PROGMEM

Всё, что не меняется во время работы — мелодии, таблицы значений, знакогенераторы, картинки для дисплея, — можно оставить во Flash целиком:

#include <avr/pgmspace.h>

// Таблица лежит во Flash и не занимает ни байта оперативной памяти.
const byte melody[] PROGMEM = { 60, 62, 64, 65, 67, 69, 71, 72 };

// Читать из Flash нужно специальной функцией — обычное melody[i] не сработает.
byte note = pgm_read_byte(&melody[i]);

// Для строк — pgm_read_word и strcpy_P, для чисел покрупнее — pgm_read_word / pgm_read_dword.

5. Массивы по размеру, а не «с запасом»

char buffer[200] «на всякий случай» — это десятая часть памяти Uno под одну переменную. Посчитайте реальную длину: строка для экрана 1602 — 17 байт, команда из монитора порта — редко больше 32.

6. Не заводить лишние объекты

Каждый объект библиотеки, объявленный глобально, занимает место, даже если вы вызвали его один раз. Два экземпляра SoftwareSerial, забытый Servo из прошлого варианта, дисплей с буфером кадра — всё это статика. И Serial.begin() в готовом устройстве без отладки можно убрать: это вернёт 175 байт.

7. Уменьшить Flash: без float, без printf, без лишних библиотек

Когда не помещается прошивка, а не переменные, работают другие приёмы: целочисленная математика вместо float, Serial.print вместо sprintf, одна библиотека для дисплея вместо двух, и — честно — удалить код, который уже не используется. Библиотеки Adafruit для экранов на Uno занимают 10–15 КБ; лёгкие альтернативы вроде U8x8 из U8g2 или текстовых режимов заметно меньше.

8. Взять плату с большей памятью

Иногда проще признать, что проект перерос Uno. Arduino Mega 2560 даёт 8 КБ SRAM и 256 КБ Flash при том же коде и напряжении; ESP32 — 520 КБ оперативной, мегабайты Flash, Wi-Fi и Bluetooth в придачу. Обе ставятся в Trema IDE без ручной настройки: Mega встроена, ESP32 приходит пакетом с зеркала packages.trema.ru.

Как узнать свободную память прямо во время работы

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

// Сколько оперативной памяти свободно прямо сейчас (Uno, Nano, Mega).
int freeRam() {
  extern int __heap_start, *__brkval;
  int v;
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.print(F("Свободно: "));
  Serial.println(freeRam());   // печатает, например, 1791
  delay(1000);
}

// ESP32 и ESP8266:  Serial.println(ESP.getFreeHeap());
// Raspberry Pi Pico: Serial.println(rp2040.getFreeHeap());

Если число уменьшается от вызова к вызову и не восстанавливается — у вас утечка (чаще всего это String). Если проваливается ниже 200 — вы на грани. Функция сама почти ничего не стоит: 8 байт SRAM и полторы сотни байт Flash.

Сколько памяти у разных плат Arduino

Цифры из спецификаций микроконтроллеров. Столбец «доступно» во Flash — за вычетом загрузчика, именно это число среда показывает как «всего доступно». Для плат ESP оперативная память делится между вашей программой и радиочастью, поэтому программе достаётся меньше, чем написано на чипе.

У плат на ESP32, ESP8266, RP2040 и STM32 отчёт выглядит иначе: для них Trema IDE использует движок Arduino CLI, и строки приходят в оригинале — «Sketch uses … bytes of program storage space» и «Global variables use … bytes of dynamic memory». Смысл тот же, что описан выше; проценты для ESP считаются от статической части, а куча там на порядок больше, чем у Uno.

EEPROM: память, которая переживает выключение

Третья память — для настроек. Если пользователь крутит энкодером порог срабатывания, а после отключения питания порог сбрасывается — вам сюда. У Uno и Nano это 1024 байта, у Mega — 4096, у Leonardo — 1024. Пишут в неё командами EEPROM.put() и читают EEPROM.get() — они работают с любыми типами и структурами:

#include <EEPROM.h>

int threshold = 500;   // порог, который настраивают кнопками

void saveSettings() {
  EEPROM.put(0, threshold);   // запишет 2 байта по адресу 0 (только если изменились)
}

void loadSettings() {
  EEPROM.get(0, threshold);   // прочитает обратно при следующем включении
}

Два правила. Не писать в EEPROM из loop() каждый проход: ресурс ячейки — около 100 000 записей, а loop() выполняется тысячи раз в секунду; сохраняйте только когда значение действительно изменилось (put() и update() сами пропускают запись, если байт тот же). Не полагаться на EEPROM у ESP: у ESP32 и ESP8266 настоящей EEPROM нет, библиотека эмулирует её во Flash и требует EEPROM.begin(size) перед работой и EEPROM.commit() после записи; на ESP32 удобнее библиотека Preferences.

Как это выглядит в Trema IDE

Trema IDE — это Arduino-совместимая среда по-русски, и с памятью она обращается так, чтобы проблему было видно раньше, чем она случится. После каждой сборки в консоли стоят строки RAM: и Flash: с полосками заполненности — они не тонут в логе: служебную болтовню инструментов программа сворачивает под кнопку «Подробности сборки», а размер прошивки оставляет на виду. Когда прошивка не помещается, вместо английской строки компоновщика над консолью появляется карточка «Программа не помещается в память платы» с советом, что сокращать. Ошибки компиляции тоже объясняются по-русски — их разбор есть в статье про ошибки компиляции.

Платы Uno, Nano и Mega собираются встроенным движком без установки чего-либо ещё; ESP32, ESP8266, UNO R4, Raspberry Pi Pico и STM32 ставятся из менеджера плат с зеркала packages.trema.ru, которое работает из России без обходных путей. Библиотеки для датчиков и экранов ищутся по имени файла из строки #include — об этом статья про библиотеки. Для дома программа бесплатна.