Ардуино функции – Функции | Аппаратная платформа Arduino

Все математические функции Arduino | AlexGyver Technologies

Функция	Описание
cos (double x)	Косинус (радианы)
sin (double x)	Синус (радианы)
tan (double x)	Тангенс (радианы)
fabs (double x)	Модуль для float чисел
fmod (double x, double y)	Остаток деления x на у для float
modf (double x, double *iptr)	Возвращает дробную часть, целую хранит по адресу iptr http://cppstudio.com/post/1137/
modff (float x, float *iptr)	То же самое, но для float
sqrt (double x)	Корень квадратный
sqrtf (float)	Корень квадратный для float чисел
cbrt (double x)	Кубический корень
hypot (double x, double y)	Гипотенуза ( корень(x*x + y*y) )
square (double x)	Квадрат ( x*x )
floor (double x)	Округление до целого вниз
ceil (double x)	Округление до целого вверх
frexp (double x, int *pexp)	http://cppstudio.com/post/1121/
ldexp (double x, int exp)	x*2^exp http://cppstudio.com/post/1125/
exp (double x)	Экспонента (e^x)
cosh (double x)	Косинус гиперболический (радианы)
sinh (double x)	Синус гиперболический (радианы)
tanh (double x)	Тангенс гиперболический (радианы)
acos (double x)	Арккосинус (радианы)
asin (double x)	Арксинус (радианы)
atan (double x)	Арктангенс (радианы)
atan2 (double y, double x)	Арктангенс (y / x) (позволяет найти квадрант, в котором находится точка)
log (double x)	Натуральный логарифм х ( ln(x) )
log10 (double x)	Десятичный логарифм x ( log_10 x)
pow (double x, double y)	Степень ( x^y )
isnan (double x)	Проверка на nan (1 да, 0 нет)
isinf (double x)	Возвр. 1 если x +бесконечность, 0 если нет
isfinite (double x)	Возвращает ненулевое значение только в том случае, если аргумент имеет конечное значение

alexgyver.ru

Программирование Arduino: справочник разработчика программиста

Главная

Программирование Ардуино – это задание определённых алгоритмов, переведённых на компьютерный язык, с целью выполнения машиной конкретной задачи, поставленной пользователем.

Мы предлагаем вам самый полный и дополняемый справочник программиста Arduino. Справочник постоянно дополняется и обновляется.

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

Давайте же составим краткое описание программирования Arduino и уточним моменты, на которые стоит обратить внимание, если вы впервые занимаетесь подобным.

Основы Arduino

Прежде чем приступать к решению конкретной задачи на Ардуино, лучше всего иметь базис в сфере программирования. Поэтому давайте рассмотрим, что вообще обозначает этот термин. Абсолютно любой проект построен на поэтапной блок-модели, в которой описывается, что необходимо сделать вашему микроконтроллеру и как это сделать.

Для упрощения работы пользователей в Ардуино созданы готовые библиотеки функций, вам достаточно лишь вводить команды из них, чтобы добиться какой-то цели. Естественно, таким образом вы многого не добьётесь, но для создания собственных библиотек потребуется знание языка С++ на котором и построена прошивка чипа.

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

Все функции строятся из простейших операнд, которые характерны для С++. Этими операндами являются переменные различных типов и способы их применения. Поэтому любая функция, используемая в микроконтроллере для получения сведений или отправки сигнала, – это набор простейших операций, который записан в главной библиотеке. И вы будете ограничены до тех пор, пока не получите достаточно опыта и практики, чтобы понимать, какую библиотеку и для какой цели вам стоит написать.

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

Также, учитывайте, что язык написания библиотек системы – низкоуровневый, а соответственно, состоит из простейших команд, в отличие от высокоуровневых python или pascal, удобных для пользователей. С другой стороны, он также является мультипарадигмальным, поэтому подходит для решения любой задачи с помощью удобной вам парадигмы программирования.

Чаще всего применяется ООП. Сам С++ имеет ядро из многочисленных библиотек и дополнительных функций или методов, поэтому, если вы собираетесь разобраться во всём кардинально, стоит начинать с освоения языка с нуля.

Особенности Arduino программирования

Именно язык, на котором базируется система, и является главной особенностью Ардуино программирования. Ведь при том, что сама плата и работа с ней достаточно просты, с низким порогом вхождения, чтобы освоить низкоуровневый язык программирования и в совершенстве владеть им, потребуется несколько лет.

У программирования на Ардуино имеются как свои достоинства, так и недостатки, и вам стоит изучить обе стороны вопроса, чтобы понимать, с чем вы имеете дело и чего ожидать от микроконтроллера в принципе, во время работы с ним. Среди достоинств Ардуино, пользователи отмечают:

1. Низкий порог вхождения. Этот пункт будет и в недостатках, так как из-за простоты системы и отсутствия требований к базису по программированию в сети гуляет множество библиотек, написанных ужасным образом. На то, чтобы разобраться, как они работают, уйдёт больше времени, чем на создание своей собственной. А стандартных функций от разработчиков не хватает для серьёзных задач.
2. Обширное комьюнити. Это главное достоинство Ардуино перед его конкурентами, ведь вы найдёте пользователей, занимающихся созданием проектов на нём, как русскоязычных, так и англоязычных. Но если вы хотите получать действительно ценные советы и погрузиться в работу комьюнити, следует всё же изучить английский язык. Так как большая часть проблем, что вам встретятся, уже давно решены в Гугле, но, зачастую, ответы на английском.
3. Большое количество библиотек, под разные случаи. Но, как уже описано чуть выше, у этого есть и свои недостатки.

Имеется у программирования на Ардуино и ряд весомых минусов:

1. Низкая планка для вхождения превращает большую часть библиотек, коими наполнена сеть, в полностью бесполезный мусор. Ведь какие-то из них работают просто медленно и написаны без каких-либо знаний основ алгоритмизации, а часть – вовсе не работает, и непонятно, зачем авторы их создавали. Чтобы найти подспорье под конкретный проект, необходимо перелопатить несколько англоязычных форумов или же самостоятельно создать функции с нуля.
2. Сложности программирования на С++. На деле – это один из сложнейших языков мультипарадигмального программирования, для создания прошивок и низкоуровневых задач. Однако, если вы имели опыт работы с ним и знаете хотя бы основные алгоритмы, а также работали хоть с одним другим мультипарадигмальным ЯП, тем более используя объектно-ориентированное программирование, вам будет значительно проще освоиться.
3. Низкая скорость отклика самих чипов и их слабые характеристики. Да, микроконтроллеры Ардуино можно подстраивать под конкретную задачу, докупать компоненты и датчики, но это играет с ними злую шутку. Так как разработчики не знают, для чего будут использовать их детище, они усредняют все показатели, чтобы значительно уменьшить стоимость конечного продукта. В результате люди, создающие простейшие поделки, переплачивают за ненужную мощность, а тем, кто занимается робототехникой или автоматизацией каких-то процессов, приходится докупать и паять множество дополнительных плат.

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

Как начать правильно пользоваться Arduino

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

Но куда лучше начать с основ и посвятить хотя бы неделю освоению алгоритмизации и научиться разбивать свои проекты на блоки, а те – уже на конкретные шаги. Подобное построение блок-схем вам не раз пригодится в будущем. Когда вы изучите весь базис, можно переходить к практике и самообучению на С++, подойдут любые простейшие проекты или заготовленные в интернете задачи. На этом этапе вашей целью станет понять основные парадигмы и научиться их использовать, а также изучить возможности языка, чтобы вы чётко знали, что он может, и могли здраво оценить реализуемость ваших проектов.

Программирование микроконтроллеров

Само программирование Ардуино делится на три этапа:

1. Создание или скачивание готовой библиотеки функций.
2. Загрузка этих библиотек в постоянную память чипа. Это ещё называют прошивкой.
3. Ввод этих функций в командную строку, например, АТ, чтобы плата выполнила те или иные действия.

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

Самые простые проекты с использованием Arduino

Примеров простых проектов с Ардуино множество, например, вы можете:

1. Создать датчик освещённости, который будет подстраивать специальные LED лампы под ту яркость, которая необходима в комнате.
2. Автоматизация любых вещей в вашем доме. Например, включения-выключения света, открытия дверей и прочее.
3. Автоматизация оранжереи.

Хотя это и звучит достаточно страшно, на большую часть этих проектов, благодаря обилию информации по ним в интернете, вы не потратите много времени и сил.

arduinoplus.ru

Arduino:Основы/Функции — Онлайн справочник

Перевод: Максим Кузьмин (Cubewriter) Перевел 3377 статей для сайта.

Контакты:

Проверка/Оформление/Редактирование: Мякишев Е.А.

Сегментирование кода по функциям позволяет программисту создавать модульные кусочки кода, выполняющие установленные задачи и возвращающие полученные результат в ту область кода, из которого эта функция была «вызвана». Типичная причина для использования функции – если программисту нужно выполнить в скетче одно и то же действие несколько раз.

Если вы из числа программистов, привыкших к BASIC, то функции в языке Arduino имеют функционал для использования «подпрограмм» (GOSUB в BASIC).

Сегментирование фрагментов кода в функции имеет следующие преимущества:

• Функции помогают программисту быть организованнее, что способствует более широкому пониманию создаваемого скетча
• Функция помещает одно действие в одном месте, поэтому работы по созданию и отладке функции нужно провести всего раз
• Это также снижает шансы ошибок при модификации (если код по какой-то причине нужно изменить)
• Благодаря функциям код, написанный в одном скетче, можно без особого труда использовать в другом, что делает такие скетчи более модульными. Кроме того, это имеет интересный побочный эффект – использование функций делает код более читаемым

Скетчу Arduino нужно как минимум две функции (их часто называют «блоками») – setup() и loop(). Прочие функции вписываются вне скобочек, обрамляющих две эти функции. К примеру, давайте создадим простую функцию, умножающую два числа.

Пример

Чтобы вызвать эту умножающую функцию, мы передаем ей параметры. Эти параметры должны иметь тип данных, совместимый с этой функцией.

1. void loop(){

2. int i = 2;

3. int j = 3;

4. int k;

5.  

6. k = myMultiplyFunction(i, j); // переменная k теперь хранит «6»

7. }

Нашу функцию нужно объявить вне других функций, имеющихся в скетче. Таким образом, функцию myMultiplyFunction() можно поставить выше или ниже блока-функции loop().

В итоге скетч будет выглядеть следующим образом:

1. void setup(){

2.   Serial.begin(9600);

3. }

4.  

5. void loop() {

6.   int i = 2;

7.   int j = 3;

8.   int k;

9.  

10.   k = myMultiplyFunction(i, j); // переменная k теперь хранит «6»

11.   Serial.println(k);

12.   delay(500);

13. }

14.  

15. int myMultiplyFunction(int x, int y){

16.   int result;

17.   result = x * y;

18.   return result;

19. }

Еще пример

Эта функция пять раз считывает значения с датчика при помощи функции analogRead(), а затем высчитывает среднее из этих пяти значений. Далее она подгоняет данные к 8-битному формату (т.е. к диапазону от «0» до «255»), инвертирует их и возвращает инвертированный результат.

1. int ReadSens_and_Condition(){

2.   int i;

3.   int sval = 0;

4.  

5.   for (i = 0; i < 5; i++){

6.     sval = sval + analogRead(0);    // датчик на аналоговом контакте 0

7.   }

8.  

9.   sval = sval / 5;    // среднее

10.   sval = sval / 4;    // подгонка под 8 бит (0 — 255)

11.   sval = 255 — sval;  // инвертирование

12.   return sval;

13. }

Чтобы вызвать эту функцию, мы просто присваиваем ее переменной.

1. int sens;

2.  

3. sens = ReadSens_and_Condition();

1. ↑ www.arduino.cc — Functions

wikihandbk.com

Структура программы на языке 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 завершается. По факту завершения «нечто» тут же вызывает её ещё раз и всё происходит снова: светодиод поджигается, горит, гаснет, ждёт и т.д.

Если перевести написанное на русский, получится следующий алгоритм:

1. Поджигаем светодиод

2. Спим 100 миллисекунд

3. Гасим светодиод

4. Спим 900 миллисекунд

5. Переходим к пункту 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 по определённым временны́м схемам. Это не так уж много, но всё же достаточно для первых экспериментов.

wiki.amperka.ru