Структура программы на языке C++ для Arduino
Рассмотрим пример минимально возможной программы на C++ для Arduino, которая ничего не делает:
void setup() { } void loop() { }
Разберёмся что здесь написано и почему это обязательно: почему нельзя обойтись просто пустым файлом.
Из чего состоит программа
Для начала стоит понять, что программу нельзя читать и писать как книгу:
от корки до корки, сверху вниз, строку за строкой. Любая программа состоит
из отдельных блоков. Начало блока кода в C/C++ обозначается левой фигурной
скобкой {, его конец — правой фигурной скобкой }.
Блоки бывают разных видов и какой из них когда будет исполняться зависит от внешних условий. В примере минимальной программы вы можете видеть 2 блока. В этом примере блоки называются определением функции. Функция — это просто блок кода с заданным именем, которым кто-то затем может пользоваться из-вне.
В данном случае у нас 2 функции с именами setup и loop. Их присутствие обязательно
в любой программе на C++ для Arduino. Они могут ничего и не делать, как в нашем случае,
но должны быть написаны. Иначе на стадии компиляции вы получите ошибку.
Классика жанра: мигающий светодиод
Давайте теперь дополним нашу программу так, чтобы происходило хоть что-то. На Arduino, к 13-му пину подключён светодиод. Им можно управлять, чем мы и займёмся.
void setup() { pinMode(13, OUTPUT); } void loop() { digitalWrite(13, HIGH); delay(100); digitalWrite(13, LOW); delay(900); }
Скомпилируйте, загрузите программу. Вы увидите, что каждую секунду светодиод на плате помигивает. Разберёмся почему этот код приводит к ежесекундному миганию.
В наши ранее пустые функции мы добавили несколько выражений. Они были размещены между
фигурными скобками функций setup и loop. В setup появилось одно выражение, а в
loop сразу 4.
Каждое выражение — это приказ процессору сделать нечто. Выражения в рамках одного блока исполняются одно за другим, строго по порядку без всяких пауз и переключений. То есть, если мы говорим об одном конкретном блоке кода, его можно читать сверху вниз, чтобы понять что делается.
Теперь давайте поймём в каком порядке исполняются сами блоки, т.е. функции setup и loop.
Не задумывайтесь пока что значат конкретные выражения, просто понаблюдайте за порядком.
- Как только Arduino включается, перепрошивается или нажимается кнопка
RESET, «нечто» вызывает функциюsetup. То есть заставляет исполняться выражения в ней. - Как только работа
setupзавершается, сразу же «нечто» вызывает функциюloop. - Как только работа
loopзавершается, сразу же «нечто» вызывает функциюloopещё раз и так до бесконечности.
Если пронумеровать выражения по порядку, как они исполняются, получится:
void setup() { pinMode(13, OUTPUT); ❶ } void loop() { digitalWrite(13, HIGH); ❷ ❻ ❿ delay(100); ❸ ❼ … digitalWrite(13, LOW); ❹ ❽ delay(900); ❺ ❾ }
Ещё раз напомним, что не стоит пытаться воспринимать всю программу, читая сверху вниз.
Сверху вниз читается только содержимое блоков. Мы вообще можем поменять порядок объявлений
setup и loop.
void loop() { digitalWrite(13, HIGH); ❷ ❻ ❿ delay(100); ❸ ❼ … digitalWrite(13, LOW); ❹ ❽ delay(900); ❺ ❾ } void setup() { pinMode(13, OUTPUT); ❶ }
Результат от этого не изменится ни на йоту: после компиляции вы получите абсолютно эквивалентный бинарный файл.
Что делают выражения
Теперь давайте попробуем понять почему написанная программа приводит в итоге к миганию светодиода.
Как известно, пины Arduino могут работать и как выходы и как входы. Когда мы хотим чем-то управлять, то есть выдавать сигнал, нам нужно перевести управляющий пин в состояние работы на выход. В нашем примере мы управляем светодиодом на 13-м пине, поэтому 13-й пин перед использованием нужно сделать выходом.
Это делается выражением в функции setup:
pinMode(13, OUTPUT);
Выражения бывают разными: арифметическими, декларациями, определениями, условными и т.д. В данном
случае мы в выражении осуществляем вызов функции. Помните? У нас есть свои функции setup и
loop, которые вызываются чем-то, что мы назвали «нечто». Так вот теперь мы вызываем функции,
которые уже написаны где-то.
Конкретно в нашем setup мы вызываем функцию с именем pinMode. Она устанавливает заданный по номеру пин
в заданный режим: вход или выход. О каком пине и о каком режиме идёт речь указывается нами в круглых
скобках, через запятую, сразу после имени функции. В нашем случае мы хотим, чтобы 13-й пин работал
как выход. OUTPUT означает выход, INPUT — вход.
Уточняющие значения, такие как 13 и OUTPUT называются аргументами функции. Совершенно не обязательно,
что у всех функций должно быть по 2 аргумента. Сколько у функции аргументов зависит от сути функции,
от того как её написал автор. Могут быть функции с одним аргументом, тремя, двадцатью; функции могут
быть без аргументов вовсе. Тогда для их вызова круглые скобка открывается и тут же закрывается:
noInterrupts();
На самом деле, вы могли заметить, наши функции setup и loop также не принимают никакие аргументы.
И загадочное «нечто» точно так же вызывает их с пустыми скобками в нужный момент.
Вернёмся к нашему коду. Итак, поскольку мы планируем вечно мигать светодиодом, управляющий пин должен
один раз быть сделан выходом и затем мы не хотим вспоминать об этом. Для этого идеологически и
предназначена функция setup: настроить плату как нужно, чтобы затем с ней работать.
Перейдём к функции loop:
void loop() { digitalWrite(13, HIGH); delay(100); digitalWrite(13, LOW); delay(900); }
Она, как говорилось, вызывается сразу после setup. И вызывается снова и снова как только сама заканчивается.
Функция loop называется основным циклом программы и идеологически предназначена для выполнения полезной
работы. В нашем случае полезная работа — мигание светодиодом.
Пройдёмся по выражениям по порядку. Итак, первое выражение — это вызов встроенной функции digitalWrite.
Она предназначена для подачи на заданный пин логического нуля (LOW, 0 вольт) или логической единицы (HIGH, 5 вольт)
В функцию digitalWrite передаётся 2 аргумента: номер пина и логическое значение. В итоге, первым делом
мы зажигаем светодиод на 13-м пине, подавая на него 5 вольт.
Как только это сделано процессор моментально приступает к следующему выражению. У нас это вызов функции delay.
Функция delay — это, опять же, встроенная функция, которая заставляет процессор уснуть на определённое время.
Она принимает всего один аргумент: время в миллисекундах, которое следует спать. В нашем случае это 100 мс.
Пока мы спим всё остаётся как есть, т.е. светодиод продолжает гореть. Как только 100 мс истекают, процессор
просыпается и тут же переходит к следующему выражению. В нашем примере это снова вызов знакомой нам встроенной
функции digitalWrite. Правда на этот раз вторым аргументом мы передаём значение LOW. То есть устанавливаем
на 13-м пине логический ноль, то есть подаём 0 вольт, то есть гасим светодиод.
После того, как светодиод погашен мы приступаем к следующему выражению. И снова это вызов функции delay.
На этот раз мы засыпаем на 900 мс.
Как только сон окончен, функция loop завершается. По факту завершения «нечто» тут же вызывает её ещё раз
и всё происходит снова: светодиод поджигается, горит, гаснет, ждёт и т.д.
Если перевести написанное на русский, получится следующий алгоритм:
- Поджигаем светодиод
- Спим 100 миллисекунд
- Гасим светодиод
- Спим 900 миллисекунд
- Переходим к пункту 1
Таким образом мы получили Arduino с маячком, мигающим каждые 100 + 900 мс = 1000 мс = 1 сек.
Что можно изменить
Давайте пользуясь только полученными знаниями сделаем несколько вариаций программы, чтобы лучше понять принцип.
Вы можете подключить внешний светодиод или другое устройство, которым нужно «мигать» на другой пин. Например, на 5-й. Как в этом случае должна измениться программа? Мы должны всюду, где обращались к 13-му пину заменить номер на 5-й:
void setup() { pinMode(5, OUTPUT); } void loop() { digitalWrite(5, HIGH); delay(100); digitalWrite(5, LOW); delay(900); }
Компилируйте, загружайте, проверяйте.
Что нужно сделать, чтобы светодиод мигал 2 раза в секунду? Уменьшить время сна так, чтобы в сумме получилось 500 мс:
void setup() { pinMode(5, OUTPUT); } void loop() { digitalWrite(5, HIGH); delay(50); digitalWrite(5, LOW); delay(450); }
Как сделать так, чтобы светодиод при каждом «подмигивании» мерцал дважды? Нужно поджигать его дважды с небольшой паузой между включениями:
void setup() { pinMode(5, OUTPUT); } void loop() { digitalWrite(5, HIGH); delay(50); digitalWrite(5, LOW); delay(50); digitalWrite(5, HIGH); delay(50); digitalWrite(5, LOW); delay(350); }
Как сделать так, чтобы в устройстве были 2 светодиода, которые мигали бы каждую секунду поочерёдно? Нужно
общаться с двумя пинами и работать в loop то с одним, то с другим:
void setup() { pinMode(5, OUTPUT); pinMode(6, OUTPUT); } void loop() { digitalWrite(5, HIGH); delay(100); digitalWrite(5, LOW); delay(900); digitalWrite(6, HIGH); delay(100); digitalWrite(6, LOW); delay(900); }
Как сделать так, чтобы в устройстве были 2 светодиода, которые переключались бы на манер железнодорожного светофора: горел бы то один то другой? Нужно просто не выключать горящий светодиод тут же, а дожидаться момента переключения:
void setup() { pinMode(5, OUTPUT); pinMode(6, OUTPUT); } void loop() { digitalWrite(5, HIGH); digitalWrite(6, LOW); delay(1000); digitalWrite(5, LOW); digitalWrite(6, HIGH); delay(1000); }
Можете проверить другие идеи самостоятельно. Как видите, всё просто!
О пустом месте и красивом коде
В языке C++ пробелы, переносы строк, символы табуляции не имеют большого значения для компилятора. Там где стоит пробел, может быть перенос строки и наоборот. На самом деле 10 пробелов подряд, 2 переноса строки и ещё 5 пробелов — это всё эквивалент одного пробела.
Пустое пространство — это инструмент программиста, с помощью которого можно или сделать программу понятной и наглядной, или изуродовать до неузнаваемости. Например, вспомним программу для мигания светодиодом:
void setup() { pinMode(5, OUTPUT); } void loop() { digitalWrite(5, HIGH); delay(100); digitalWrite(5, LOW); delay(900); }
Мы можем изменить её так:
void setup( ) { pinMode(5, OUTPUT); } void loop () { digitalWrite(5,HIGH); delay(100 ) ; digitalWrite(5,LOW); delay(900); }
Всё, что мы сделали — немного «поработали» с пустым пространством. Теперь можно наглядно видеть разницу между стройным кодом и нечитаемым.
Чтобы следовать негласному закону оформления программ, который уважается на форумах, при чтении другими людьми, легко воспринимается вами же, следуйте нескольким простым правилам:
1. Всегда, при начале нового блока между { и } увеличивайте отступ. Обычно используют 2 или 4
пробела. Выберите одно из значений и придерживайтесь его всюду.
Плохо:
void loop() { digitalWrite(5, HIGH); delay(100); digitalWrite(5, LOW); delay(900); }
Хорошо:
void loop() { digitalWrite(5, HIGH); delay(100); digitalWrite(5, LOW); delay(900); }
2. Как и в естественном языке: ставьте пробел после запятых и не ставьте до.
Плохо:
digitalWrite(5,HIGH); digitalWrite(5 , HIGH); digitalWrite(5 ,HIGH);
Хорошо:
digitalWrite(5, HIGH);
3. Размещайте символ начала блока { на новой строке на текущем уровне отступа или в конце предыдущей.
А символ конца блока } на отдельной строке на текущем уровне отступа:
Плохо:
void setup() { pinMode(5, OUTPUT); } void setup() { pinMode(5, OUTPUT); } void setup() { pinMode(5, OUTPUT); }
Хорошо:
void setup() { pinMode(5, OUTPUT); } void setup() { pinMode(5, OUTPUT); }
4. Используйте пустые строки для разделения смысловых блоков:
Хорошо:
void loop() { digitalWrite(5, HIGH); delay(100); digitalWrite(5, LOW); delay(900); digitalWrite(6, HIGH); delay(100); digitalWrite(6, LOW); delay(900); }
Ещё лучше:
void loop() { digitalWrite(5, HIGH); delay(100); digitalWrite(5, LOW); delay(900); digitalWrite(6, HIGH); delay(100); digitalWrite(6, LOW); delay(900); }
О точках с запятыми
Вы могли заинтересоваться: зачем в конце каждого выражения ставится точка с запятой? Таковы правила C++.
Подобные правила называются синтаксисом языка. По символу ; компилятор понимает где заканчивается
выражение.
Как уже говорилось, переносы строк для него — пустой звук, поэтому ориентируется он на этот знак препинания. Это позволяет записывать сразу несколько выражений в одной строке:
void loop() { digitalWrite(5, HIGH); delay(100); digitalWrite(5, LOW); delay(900); }
Программа корректна и эквивалентна тому, что мы уже видели. Однако писать так — это дурной тон. Код гораздо сложнее читается. Поэтому если у вас нет 100% веских причин писать в одной строке несколько выражений, не делайте этого.
О комментариях
Одно из правил качественного программирования: «пишите код так, чтобы он был настолько понятным, что не нуждался бы в пояснениях». Это возможно, но не всегда. Для того, чтобы пояснить какие-то не очевидные моменты в коде его читателям: вашим коллегам или вам самому через месяц, существуют так называемые комментарии.
Это конструкции в программном коде, которые полностью игнорируются компилятором и имеют значение только для читателя. Комментарии могут быть многострочными или однострочными:
/* Функция setup вызывается самой первой, при подаче питания на Arduino А это многострочный комментарий */ void setup() { // устанавливаем 13-й пин в режим вывода pinMode(13, OUTPUT); } void loop() { digitalWrite(13, HIGH); delay(100); // спим 100 мс digitalWrite(13, LOW); delay(900); }
Как видите, между символами /* и */ можно писать сколько угодно строк комментариев.
А после последовательности // комментарием считается всё, что следует до конца строки.
Итак, надеемся самые основные принципы составления написания программ стали понятны. Полученные знания позволяют программно управлять подачей питания на пины Arduino по определённым временны́м схемам. Это не так уж много, но всё же достаточно для первых экспериментов.