Оптимизация кода Arduino


С ростом навыков и созданием всё более глобальных проектов вы столкнётесь с тем, что “Ардуина” перестанет справляться с тем объёмом вычислений, который вы хотите от неё получить. Может банально не хватать быстродействия в расчётах, обновлении информации на дисплеях, отправки данных и прочих ресурсозатратных действий, а ещё может просто закончиться память! Самое страшное, когда заканчивается оперативная память: она может это сделать абсолютно незаметно, и устройство начнёт вести себя неадекватно, перезагрузится или попросту зависнет. Как этого избежать? Нужно оптимизировать свой код! Информации по этому поводу в Интернете очень мало, поэтому я опишу всё, с чем сталкивался лично.

Оптимизация скорости


Прежде чем приступать к оптимизации вычислений, нужно понять, почему оно вообще тормозит: есть такое понятие, как процессорное время, т.е. время, которое вычислительный процессор тратит на различные действия. Например, вы хотите производить какие-то вычисления, и сразу выводить их на дисплей. Если вычислений будет слишком много, выполняться они будут дольше желаемого, данные будут выводиться медленно. На самом деле такой ситуации добиться весьма непросто, всё таки процессор у нас выполняет операции на частоте 16 МГц, но один раз я таки нащупал этот “порог”. Проект назывался LED кубик, в нём рассчитывалось поведение нескольких десятков частиц на плоскости. Рассчитывалось не абы как – а по математической модели, с трением, углами наклона, отскоками от края плоскости и всё такое, результат выводился на светодиодную матрицу. При увеличении количества частиц я столкнулся с тем, что они начинают откровенно тормозить, т.е. частота обновления матрицы сильно упала. Видео про этот проект можно посмотреть на моём канале, а мы переходим к оптимизации вычислений.

Важный момент: во время компиляции происходит автоматическая оптимизация, во время которой компилятор сам считает всё, что можно посчитать (константы и цифры).

Хочу поделиться инструментом для замера времени выполнения кода – это прошивка, которая выполняет указанный код несколько тысяч раз (для точности), а затем выводит время выполнения в “тиках” процессора и микросекундах, а также частоту выполнения. Работает на таймере 1. Скачать можно с FTP сайта по прямой ссылке (нажать правой кнопкой – сохранить файл). также код находится ниже под спойлером.

// Тест скорости выполнения команд Arduino
// Просто помести свой код внутри test() и загрузи прошивку!

inline __attribute__((always_inline))
void test(void) {
  // тестируемая команда 
  
}
void lol(){}

// =========================================
void setup() {
  analogRead(0);
  Serial.begin(9600);
  TCCR1A = 0x00;            // выключаем
  TCCR1B = 0x00;            // выключаем
  TCNT1 = 0x00;             // сброс счётчика

  TCCR1B = 0x01;            // запустить таймер
  test();                   // тест
  TCCR1B = 0x00;            // остановить таймер

  uint32_t count = TCNT1 - 2; // минус два такта на действия

  Serial.print("ticks: ");
  Serial.println(count);
  Serial.print("time (us): ");
  Serial.println(count * (float)(1000000.0f / F_CPU), 4);
}

void loop() {}

Использовать переменные соответствующих типов


Тип переменной/константы не только влияет на занимаемый ей объём памяти, но и на скорость вычислений! Привожу таблицу для простейших не оптимизированных компилятором вычислений. В реальном коде время может быть меньше. Примечание: время приведено для кварца 16 МГц.

Тип данных Время выполнения, мкс
Сложение и вычитание Умножение Деление, остаток
int8_t 0.44 0.625 14.25
uint8_t 0.44 0.625 5.38
       
int16_t 0.89 1.375 14.25
uint16_t 0.89 1.375 13.12
int32_t 1.75 6.06 38.3

uint32_t 1.75 6.06 37.5
       
float 8.125 10 31.5

Как вы можете заметить, время вычислений отличается в разы даже для целочисленных типов данных, так что всегда нужно прикидывать, какая максимальная величина будет храниться в переменной, и выбирать соответствующий тип данных. Стараться не использовать 32-битные числа там, где они не нужны, а также по возможности не использовать float.

Отказаться от float


Из таблицы выше вы также можете узнать, что на действия с числами с плавающей точкой микроконтроллер тратит в несколько раз больше времени по сравнению с целочисленными типами. Дело в том, что у большинства микроконтроллеров AVR (что стоят на Ардуинах) нет “хардверной” поддержки вычислений float чисел, и эти вычисления производятся не очень оптимальными программными методами. На взрослых микроконтроллерах ARM такая поддержка, к слову, имеется. Что же делать? Просто избегайте использования float там, где задачу можно решить целочисленными типами.

Если нужно перемножить-переделить кучу float‘ов, то можно перевести их в целочисленный тип, умножив на 10-100-1000, смотря какая нужна точность, вычислить, а затем результат снова перевести в float. В большинстве случаев это получается быстрее, чем вычислять float напрямую.

Существует также такая штука как fixed point – числа с фиксированной точкой. С точки зрения пользователя они являются обычными десятичными дробями, но по факту являются целочисленными типами и вычисляются соответственно быстрее. Нативной поддержки fixed point в Arduino нет, но можно работать с ними при помощи самописных функций, макросов или библиотек, под спойлером найдёте мой рабочий пример, который можно использовать на практике:

// макросы для работы с fixed point
#define FIX_BITS        8
#define FLOAT2FIX(a)    (int32_t)((a*(1 << FIX_BITS)))      // перевод из float в fixed
#define INT2FIX(a)      (int32_t)((a) << FIX_BITS)          // перевод из int в fixed
#define FIX2FLOAT(a)    (((float)(a)/(1 << FIX_BITS)))      // перевод из fixed в float
#define FIX2INT(a)      ((a) >> FIX_BITS)                   // перевод из fixed в int
#define FIX_MUL(a, b)   (((int32_t)(a) * (b)) >> FIX_BITS)  // перемножение двух fixed

void setup() {
  Serial.begin(9600);
  float x = 8.3;
  float y = 2.34;
  float z = 0;

  // сначала переводим в fixed
  int32_t a = FLOAT2FIX(x);
  int32_t b = FLOAT2FIX(y);
  int32_t c = 0;

  z = x + y;    // складываем float
  c = a + b;    // складываем fixed

  // переводим fixed обратно в float
  float cFloat = FIX2FLOAT(c);

  // выводим для сравнения результата
  Serial.println(z);
  Serial.println(cFloat);
}

/*
   Тесты скорости выполнения:
   x = 8.3;             // 0.75 us  - присваивание float
   a = FLOAT2FIX(8.3);  // 0.75 us  - конвертация float числа в fixed
   a = FLOAT2FIX(x);    // 14.9 us  - конвертация float переменной в fixed

   z = x + y;           // 8.25 us  - сложение float
   c = a + b;           // 2.0 us   - сложение fixed

   z = x * y;           // 10.3 us  - умножение float
   c = FIX_MUL(a, b);   // 6.68 us  - умножение fixed

   z = FIX2FLOAT(c);    // 13.37 us - конвертация fixed в float
*/

void loop() {}

Заменить деление умножением


Опять же по таблице выше можно увидеть, что деление для всех типов данных выполняется гораздо дольше умножения, поэтому иногда бывает выгоднее заменить деление на целое число умножением на float. И да, пытаться усидеть на двух стульях, пытаясь не использовать float и использовать его вместо деления…

keka = keka / 10;		// выполняется 14.54 мкс
keka = (float)keka * 0.1;	// выполняется 10.58 мкс

Заменить возведение в степень умножением


Для возведения в степень у нас есть удобная функция pow(a, b), но в серьёзных расчётах лучше ей не пользоваться: она выполняется гораздо дольше ручного перемножения, потому что считает всё в float, даже если скормить ей целое:

keka = pow(keka, 5);                             // выполняется 20.33 us
keka = (long)keka * keka * keka * keka * keka;   // выполняется 4.47 us

Предварительно вычислять то, что можно вычислить


Некоторые сложные вычисления требуют выполнения одних и тех же действий несколько раз. Гораздо быстрее будет создать локальную переменную, в неё “посчитать”, и использовать её в дальнейших расчётах.

Ещё хороший пример: расчёт величин, которые ведут себя предсказуемо, например гармонические функции sin() и cos(). На их вычисление уходит довольно-таки много времени – 119.46 мкс!!! На практике синусы/косинусы практически никогда не вычисляют средствами микроконтроллера, их вычисляют заранее и сохраняют в виде массива. Да, опять два стула: тратить время на вычисление, или занимать память уже посчитанными данными.

Также не забываем, что компилятор сам оптимизирует вычисления, и делает это весьма неплохо.

Не использовать delay и подобные задержки


Вполне очевидный совет: не используйте delay() там, где можно обойтись без него. А это 99.99% случаев. Используйте таймер на millis(), как мы изучали в уроке

Заменить Ардуино-функции их быстрыми аналогами


Если в проекте очень часто используется периферия микроконтроллера (АЦП, цифровые входы/выходы, генерация ШИМ…), то нужно знать одну вещь: Ардуино (на самом деле Wiring) функции написаны так, чтобы защитить пользователя от возможных ошибок, внутри этих функций находится куча различных проверок и защит “от дурака”, поэтому они выполняются гораздо дольше, чем могли бы. Также некоторая периферия микроконтроллера настроена так, что работает очень медленно. Пример: digitalWrite и digitalRead выполняются около 3.5 мкс, когда прямая работа с портом микроконтроллера занимает 0.5 мкс, что почти на порядок быстрее. analogRead выполняется 112 мкс, хотя если его настроить чуть по-другому, он будет выполняться почти в 10 раз быстрее, не особо потеряв в точности. О таком “разгоне” Ардуино мы поговорим в отдельном уроке, сейчас могу предложить вам описание библиотек GyverHacks и CyberLib, в них есть куча всего интересного, включая быстрые аналоги стандартным функциям. Примечание: автор открытой библиотеки Cyberlib не любит, когда ей пользуются в своих проектах, так что аккуратнее.

Также обратите внимание на переписанное мной стандартное ядро для плат на базе ATmega168/328 – GyverCore. Это ядро является аналогом стандартному, но основные функции полностью переписаны и выполняются в разы быстрее и занимают меньше места в памяти!

Использовать switch вместо else if


В ветвящихся конструкциях со множественным выбором по значению целочисленной переменной стоит отдавать предпочтение конструкции switch-case, она работает быстрее else if (изучали в уроках про условия и выбор). Но помните, что switch работает только с целочисленными! Под спойлером найдёте результаты синтетического (не оптимизированного компилятором) теста.

// тест SWITCH
// keka равна 10
// время выполнения: 0.3 мкс (5 тактов)
switch (keka) {
  case 10: break;  // выбираем это
  case 20: break;
  case 30: break;
  case 40: break;
  case 50: break;
  case 60: break;
  case 70: break;
  case 80: break;
  case 90: break;
  case 100: break;
}

// keka равна 100
// время выполнения: 0.3 мкс (5 тактов)
switch (keka) {
  case 10: break;
  case 20: break;
  case 30: break;
  case 40: break;
  case 50: break;
  case 60: break;
  case 70: break;
  case 80: break;
  case 90: break;
  case 100: break;  // выбираем это
}

// тест ELSE IF
// keka равна 10
// время выполнения: 0.50 мкс (8 тактов)
if (keka == 10) {   // выбираем это
} else if (keka == 20) {
} else if (keka == 30) {
} else if (keka == 40) {
} else if (keka == 50) {
} else if (keka == 60) {
} else if (keka == 70) {
} else if (keka == 80) {
} else if (keka == 90) {
} else if (keka == 100) {
}

// keka равна 100
// время выполнения: 2.56 мкс (41 такт)
if (keka == 10) {
} else if (keka == 20) {
} else if (keka == 30) {
} else if (keka == 40) {
} else if (keka == 50) {
} else if (keka == 60) {
} else if (keka == 70) {
} else if (keka == 80) {
} else if (keka == 90) {
} else if (keka == 100) {   // выбираем это
}

Использовать битовые операции


Используйте битовые трюки и вообще битовые операции, часто они помогают ускорить код. Читайте в отдельном уроке.

Использовать указатели и ссылки


Вместо передачи “объекта” в качестве аргумента функции, передавать его по ссылке или по указателю: процессор не будет выделять память под копию аргумента (и создавать эту копию в качестве формальной переменной) – это сэкономит время! Подробнее про указатели и ссылки читайте в отдельном уроке.

Использовать макро и встроенные функции


Каждая созданная функция имеет свой адрес в памяти, и для её вызова процессор обращается по этому адресу, что занимает время. Время очень малое, но иногда даже оно бывает критичным, поэтому такие критичные ко времени вызовы можно заменить на макро-функции или на встроенные функции, подробнее читайте в уроке про функции.

Использовать константы


Константы (const или define) “работают” гораздо быстрее переменных при передаче их в качестве аргументов в функции. Делайте константами всё, что не будет меняться в процессе работы программы! Пример:

byte pin = 3;    // частота будет 128 кГц (GyverCore)
//const byte pin = 3; // частота будет 994 кГц (GyverCore)

void setup() {
  pinMode(pin, OUTPUT);
}
void loop() {
  for (;;) {
    digitalWrite(pin, 1);
    digitalWrite(pin, 0);
  }
}

Почему это происходит? Компилятор оптимизирует код, и с константными аргументами он может выбросить из функции почти весь лишний код (если там есть, например, блоки if-else), и она будет работать быстрее.

Миновать loop


Функция loop является вложенной в цикл с некоторыми дополнительными проверками, если вам очень важно минимальное время между итерациями loop – просто работайте в своём цикле for(;;), например вот так:

void loop() {
  for (;;) {
  // ваш код
  }
}

Оптимизация памяти


Чаще всего мы сталкиваемся с нехваткой памяти: постоянной Flash или оперативной SRAM. После компиляции кода мы получаем сообщение о занимаемом объёме Flash/SRAM, это ценная информация. Flash память можно забивать на 99%, её объём не изменяется в процессе работы устройства, чего не скажешь о SRAM. Допустим на момент запуска программы у нас занято 80% оперативной памяти, но в процессе работы могут появляться и исчезать локальные переменные, которые добьют занимаемый объём до 100% и устройство скорее всего перезагрузится или зависнет. Опасность ещё в том, что “раздел” оперативной памяти начинает фрагментироваться, т.е. появляются маленькие пустые места, которые микроконтроллер не может занять новыми появляющимися данными. Да, всё как на компьютере, только кнопки “дефрагментировать” у нас нет. Поэтому нужно или учиться вручную заниматься менеджментом памяти, или стараться оставлять побольше свободной SRAM.

Примечание. Во время компиляции также производится оптимизация по памяти: объявленные, но не использованные в коде функции и переменные не идут в финальный код, который загружается в МК, т.е. не занимают в нём место, как и неиспользованный код из подключенных файлов.

Также прилагаю скетч-пример с функцией, которая выводит объём свободной SRAM. Скачать с FTP сайта (нажать правой кнопкой – сохранить файл).

/*
   Функция, возвращающая количество свободной оперативной памяти (SRAM)
*/
void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.println(memoryFree()); // печать количества свободной SRAM
  delay(1000);
}

extern int __bss_end;
extern void *__brkval;
// Функция, возвращающая количество свободного ОЗУ
int memoryFree() {
  int freeValue;
  if ((int)__brkval == 0)
    freeValue = ((int)&freeValue) - ((int)&__bss_end);
  else
    freeValue = ((int)&freeValue) - ((int)__brkval);
  return freeValue;
}

Использовать переменные соответствующих типов


Как вы помните из урока о типах данных, каждый тип имеет ограничение на максимально хранимое значение, от чего прямо зависит вес этого типа в памяти. Вот они все:

Название Вес Диапазон
boolean 1 байт 0 или 1, true или false
char (int8_t) 1 байт -128… 127
byte (uint8_t) 1 байт 0… 255
int (int16_t) 2 байта -32 768… 32 767
unsigned int (uint16_t) 2 байта 0… 65 535
long (int32_t) 4 байта -2 147 483 648…    2 147 483 647
unsigned long (uint32_t) 4 байта 0… 4 294 967 295
float (double) 4 байта -3.4028235E+38… 3.4028235E+38

Просто не используйте переменные более тяжёлых типов там, где это не нужно.

Использовать define


Для хранения констант в стиле номеров пинов, каких-то настроек и постоянных значений используйте не глобальные переменные, а #define. Таким образом константа будет храниться в коде, во Flash памяти, которой много.

#define MOTOR_PIN 10
#define MOTOR_SPEED 120

Использовать директивы препроцессора


Если у вас какой-то комплексный проект, где перед прошивкой включаются/выключаются некоторые куски кода или библиотеки – используйте условную компиляцию при помощи директив #if, #elif, #ifdef и прочие, о которых мы говорили в уроке про условия

Использовать progmem


Для хранения больших объемов постоянных данных (массив битмапов для вывода на дисплеи, строки с текстом, “таблицы” синуса или других корректирующих значений) используйте PROGMEM – возможность хранить и читать данные во Flash памяти микроконтроллера, которой гораздо больше, чем оперативной. Особенность состоит в том, что данные во Flash пишутся во время прошивки, и изменить их потом будет нельзя, можно только прочитать и использовать.

// сохраняем несколько целых чисел
const uint16_t ints[] PROGMEM = {65000, 32796, 16843, 10, 11234};

// сохраняем несколько десятичных дробей
const float floats[] PROGMEM = {0.5, 120.25, 0.9214};

// сохраняем несколько символов
const char message[] PROGMEM = {"Hello! Lolkek"};

void setup() {
  Serial.begin(9600);
  Serial.println(pgm_read_word(&(ints[2])));      // выведет 16843
  Serial.println(pgm_read_float(&(floats[1])));   // выведет 120.25

  for (byte i = 0; i < 13; i++)
    Serial.print((char)pgm_read_byte(&(message[i]))); 
    // выведет Hello! Lolkek
}

Основная функция чтения из progmem – pgm_read_<type>. Мы можем использовать вот эти 4:

  • pgm_read_byte(data); – для 1-го байта (char, byte, int8_t, uint8_t)
  • pgm_read_word(data); – для 2-х байт (int, word, unsigned int, int16_t, int16_t)
  • pgm_read_dword(data); – для 4-х байт (long, unsigned long, int32_t, int32_t)
  • pgm_read_float(data); – для чисел с плавающей точкой

Внимание! При чтении отрицательных (signed) чисел, нужно привести тип данных. Пример:

// сохраняем несколько целых с разными знаками
const int16_t ints[] PROGMEM = {65000, 32796, -16843};

// setup
Serial.println((int)pgm_read_word(&(ints[2])));   // выведет -16843

Также есть более удобный способ записывать и читать данные, реализован в библиотеках. Смотреть тут

Использовать F() макро


Если в проекте используется вывод в COM порт текстовых данных, то каждый символ будет занимать один байт оперативной памяти, также это относится к строковым данным и выводам на дисплей. У нас есть на вооружении встроенный инструмент, который позволяет хранить строки во Flash памяти, использовать его очень просто удобно, гораздо удобнее того же PROGMEM.

Так называемая “F() macro” позволяет хранить строки во Flash памяти, не занимая место в SRAM. Работает очень просто и эффективно, позволяя делать девайс с расширенным общением/отладкой через Serial порт и не думать о забитой оперативке:

// данный вывод (строка, текст) занимает в оперативной памяти 18 байт
Serial.println("Hello <username>!");

// данный вывод ничего не занимает в оперативной памяти, благодаря F()
Serial.println(F("Type /help to help"));

Ограничить использование библиотек


Допустим вы используете библиотеку, в которой есть “куча всего”, из которой вам нужна пара функций. При компиляции кода у нас отсекаются неиспользуемые функции и переменные, но иногда этого бывает недостаточно, зависит от библиотеки. Имеет смысл “вытащить” из библиотеки нужный код и просто встроить его в свой код, сэкономив тем самым немного места.

Не использовать float


Как мы обсуждали в уроке про типы данных, поддержка вычислений с float является программной (для AVR), то есть грубо говоря для вычислений подключается библиотека. Однократно использовав в коде все арифметические действия с float, вы подключите около 1000 байт кода во Flash память для поддержки этих вычислений.

Не использовать объекты классов Serial и String


Пожалуй самые “жирные” по занимаемой памяти библиотеки – это стандартные объекты Serial и String. Если в коде появляется Serial, он сразу же забирает себе минимум 998 байт Flash (3% для ATmega328) и 175 байт SRAM (8% для ATmega328). Как только начинаем использовать строки String – прощаемся с 1178 байтами Flash (4% для ATmega328).

Если Serial всё таки нужен – попробуйте использовать сильно облегчённый аналог стандартной библиотеки – GyverUART. Я написал эту библиотеку под ATmega168/328 (платы UNO, Nano, Mini). Библиотека предлагает почти все возможности стандартной Serial, но занимает в разы меньше памяти.

Использовать однобитные флаги


Вы должны быть в курсе, что логический тип данных boolean занимает в памяти Arduino не 1 бит, как должен занимать, а целых 8, т.е. 1 байт. Это вселенская несправедливость, ведь по сути мы можем сохранить в одной байте 8 флагов true/false, а на деле храним только один. С чем это связано я не знаю, возможно с компилятором или архитектурой процессора. Но выход есть: паковать биты вручную в байт, для чего нужно добавить несколько макросов. Пользоваться этим не очень удобно, но в критической ситуации, когда важен каждый байт, можно и заморочиться. Смотрите пример.

// храним флаги как 1 бит

// макросы
#define B_TRUE(bp,bb)    bp |= bb
#define B_FALSE(bp,bb)   bp &= ~(bb)
#define B_READ(bp,bb)    bool(bp & bb)

// вот так храним наши флаги, значения обязательно как степени двойки!
#define B_FLAG_1        1
#define B_FLAG_2        2
#define B_LED_STATE     4
#define B_BUTTON_STATE  8
#define B_BUTTON_FLAG   16
#define B_SUCCESS       32
#define B_END_FLAG      64
#define B_START_FLAG    128

// этот байт будет хранить 8 бит
byte boolPack1 = 0;

void setup() {
  // суть такая: макрос функциями мы ставим/читаем бит в байте boolPack1

  // записать true во флаг B_BUTTON_STATE
  B_TRUE(boolPack1, B_BUTTON_STATE);

  // записать false во флаг B_FLAG_1
  B_FALSE(boolPack1, B_FLAG_1);

  // прочитать флаг B_SUCCESS (для примера читаем в булин переменную)
  boolean successFlag = B_READ(boolPack1, B_SUCCESS);

  // либо используем в условии
  if (B_READ(boolPack1, B_SUCCESS)) {
    // выполнить при выполнении условия
  }
}

void loop() { }

// пример упаковки битовых флагов в байт
// при помощи ардуино-функций

byte myFlags = 0; // все флаги в false

// можно задефайнить названия
// цифры по порядку 0-7
#define FLAG1 0
#define FLAG2 1
#define FLAG3 2
#define FLAG4 3
#define FLAG5 4
#define FLAG6 5
#define FLAG7 6
#define FLAG8 7

void setup() {
  // установить FLAG5 в true
  bitSet(myFlags, FLAG5);
  // установить FLAG1 в true
  bitSet(myFlags, FLAG1);

  // установить FLAG1 в false
  bitClear(myFlags, FLAG1);

  // считать FLAG5
  bitRead(myFlags, FLAG5);

  // условие с флагом 7
  if (bitRead(myFlags, FLAG7)) {
    // если FLAG7 == true
  }
}

void loop() {}

 

Выбор загрузчика


В одном из первых уроков я рассказывал, что во Flash памяти микроконтроллера живёт bootloader – загрузчик, который загружает прошивку по UART. Загрузчик это не три строчки кода, а гораздо больше: стандартный загрузчик занимает почти 2 кБ Flash памяти! Для Нано/Уно это целых 6%. Варианта два: прошить более современный загрузчик, который занимает в 4 раза меньше места (512 байт). Загрузчик называется optiBoot, основная информация по нему есть на его же GitHub. Процесс перепрошивки загрузчика мы разберём позже, в отдельном уроке. Пока что можете прикупить себе AVR-ISP программатор, хотя загрузчик можно прошить и просто другой Ардуиной.

Второй вариант ещё лучше: загружать прошивку напрямую в микроконтроллер, без загрузчика, используя программатор. Тогда вы получите в своё распоряжение полный заявленный объём Flash памяти.

Отказаться от стандартной инициализации


Стандартные функции setup() и loop() являются обязательными не просто так: они входят в самую главную функцию всей программы – main(). Реализация данной функции лежит в ядре в файле main.cpp и выглядит вот так:

int main(void)
{
 init();

 initVariant();

#if defined(USBCON)
 USBDevice.attach();
#endif
 
 setup();
    
 for (;;) {
  loop();
  if (serialEventRun) serialEventRun();
 }
        
 return 0;
}

Именно здесь, в инициализациях, кроется пара сотен байт занимаемой Flash памяти! А после loop() есть проверка условия (именно избегание его даёт прирост в скорости, я писал об этом в конце раздела “оптимизация скорости”). В функциях инициализации настраивается периферия микроконтроллера: АЦП, интерфейсы, таймер 0 (который даёт нам корректный millis()), и некоторые другие вещи. Если можете самостоятельно инициализировать только нужную периферию – это позволит сэкономить несколько сотен байт флэша, всё что нужно сделать – это нагло ввести в скетч свою функцию main(), и написать инициализацию только того, что нужно. Для сравнения: стандартный набор инициализации (функции setup() и loop() в скетче) дают 444 байта занимаемой Flash (Arduino IDE v. 1.8.9). Если отказаться от этого кода и перехватить управление main() – пустой скетч будет занимать 134 байта, что почти на 300 байт меньше! Это, конечно, крохоборство, но на дороге не валяется. Как это сделать:

#include <arduino.h>

int main() {
  // наш личный "setup"
  for (;;) {
    // наш личный "loop"
  }
  return 0;
}

Функции setup() и loop() в данном скетче уже не нужны, т.к. они не используются в main().

Попробовать GyverCore


Также обратите внимание на переписанное мной стандартное ядро для плат на базе ATmega328 – GyverCore. Это ядро является аналогом стандартному, но основные функции полностью переписаны и выполняются в разы быстрее и занимают гораздо меньше места в памяти микроконтроллера.

Купить Arduino Mega


Слегка шуточный, но дельный совет: если вам стало не хватать Уно/Нано и все возможные оптимизации уже сделаны – у вас остался только один вариант – купить Ардуино Мега, у неё в 8 раз больше Flash памяти, и в 4 раза больше SRAM.

Важные страницы


  • Каталог ссылок на дешёвые Ардуины, датчики, модули и прочие железки с AliExpress у проверенных продавцов
  • Подборка библиотек для Arduino, самых интересных и полезных, официальных и не очень
  • Полная документация по языку Ардуино, все встроенные функции и макро, все доступные типы данных
  • Сборник полезных алгоритмов для написания скетчей: структура кода, таймеры, фильтры, парсинг данных
  • Видео уроки по программированию Arduino с канала “Заметки Ардуинщика” – одни из самых подробных в рунете
Последнее обновление Ноябрь 21, 2019