Использование оператора for в ардуино. Arduino циклы

Description

The for statement is used to repeat a block of statements enclosed in curly braces. An increment counter is usually used to increment and terminate the loop. The for statement is useful for any repetitive operation, and is often used in combination with arrays to operate on collections of data/pins.

Syntax

For (initialization; condition; increment) { // statement(s); }

Parameters

initialization: happens first and exactly once.
condition: each time through the loop, condition is tested; if it’s true , the statement block, and the increment is executed, then the condition is tested again. When the condition becomes false , the loop ends.
increment: executed each time through the loop when contition is true.

Example Code

// Dim an LED using a PWM pin int PWMpin = 10; // LED in series with 470 ohm resistor on pin 10 void setup() { // no setup needed } void loop() { for (int i = 0; i <= 255; i++) { analogWrite(PWMpin, i); delay(10); } }

Notes and Warnings

The C `for` loop is much more flexible than `for` loops found in some other computer languages, including BASIC. Any or all of the three header elements may be omitted, although the semicolons are required. Also the statements for initialization, condition, and increment can be any valid C statements with unrelated variables, and use any C++ datatypes including floats. These types of unusual for statements may provide solutions to some rare programming problems.

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

Заголовок цикла for состоит из трех частей:

for (initialization ; condition ; increment ) {операторы выполняющиеся в цикле}

Инициализация (Initialization) выполняется самой первой и один раз. Каждый раз в цикле проверяется условие (condition), если оно верно, выполняется блок операторов и приращение (increment), затем условие проверяется вновь. Когда логическое значение условия становится ложным, цикл завершается.

Пример

Цикл for в Си гораздо более гибкий, чем циклы for в других языках программирования, например, в Бейсике. Любой из трех или все три элемента заголовка могут быть опущены, хотя точки с запятой обязательны. Также операторы для инициализации, условия и приращения цикла могут быть любым допустимым в Си операторами с независимыми переменными, и использовать любой тип данных Си, включая данные с плавающей точкой (floats). Эти необычные для цикла for типы операторов позволяют обеспечить программное решение некоторых нестандартных проблем.

Например, использование умножения в операторе счетчика цикла позволяет создавать логарифмическую прогрессию:

For(int x = 2; x < 100; x = x * 1.5){ println(x); }

Генерируется: 2,3,4,6,9,13,19,28,42,63,94

Другой пример, плавное уменьшение или увеличение уровня сигнала на светодиод с помощью одного цикла for :

Void loop() { int x = 1; for (int i = 0; i > -1; i = i + x){ analogWrite(PWMpin, i); if (i == 255) x = -1; // переключение управления на максимуме delay(10); } }

Этот урок дает минимальные знания, необходимые для программирования систем Ардуино на языке C. Можно только просмотреть его и в дальнейшем использовать как справочную информацию. Тем, кто программировал на C в других системах можно пропустить статью.

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

Структура программы Ардуино.

Структура программы Ардуино достаточно проста и в минимальном варианте состоит из двух частей setup() и loop().

void setup() {

void loop() {

Функция setup() выполняется один раз, при включении питания или сбросе контроллера. Обычно в ней происходят начальные установки переменных, регистров. Функция должна присутствовать в программе, даже если в ней ничего нет.

После завершения setup() управление переходит к функции loop(). Она в бесконечном цикле выполняет команды, записанные в ее теле (между фигурными скобками). Собственно эти команды и совершают все алгоритмические действия контроллера.

Первоначальные правила синтаксиса языка C.

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

z = x + y;
z= x
+ y ;

{ } фигурные скобки определяют блок функции или выражений. Например, в функциях setup() и loop().

/* … */ блок комментария , обязательно закрыть.

/* это блок комментария */

// однострочный комментарий , закрывать не надо, действует до конца строки.

// это одна строка комментария

Переменные и типы данных.

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

Типы данных выбираются исходя из требуемой точности вычислений, форматов данных и т.п. Не стоит, например, для счетчика, считающего до 100, выбирать тип long. Работать будет, но операция займет больше памяти данных и программ, потребует больше времени.

Объявление переменных.

Указывается тип данных, а затем имя переменной.

int x; // объявление переменной с именем x типа int
float widthBox; // объявление переменной с именем widthBox типа float

Все переменные должны быть объявлены до того как будут использоваться.

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

• Переменные, объявленные в начале программы, до функции void setup(), считаются глобальными и доступны в любом месте программы.
• Локальные переменные объявляются внутри функций или таких блоков, как цикл for, и могут использоваться только в объявленных блоках. Возможны несколько переменных с одним именем, но разными областями видимости.

int mode; // переменная доступна всем функциям

void setup() {
// пустой блок, начальные установки не требуются
}

void loop() {

long count; // переменная count доступна только в функции loop()

for (int i=0; i < 10;) // переменная i доступна только внутри цикла
{
i++;
}
}

При объявлении переменной можно задать ее начальное значение (проинициализировать).

int x = 0; // объявляется переменная x с начальным значением 0
char d = ‘a’; // объявляется переменная d с начальным значением равным коду символа ”a”

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

int x; // переменная int
char y; // переменная char
int z; // переменная int

z = x + (int) y; // переменная y явно преобразована в int

Арифметические операции.

Операции отношения.

Логические операции.

Операции над указателями.

Битовые операции.

Операции смешанного присваивания.

Выбор вариантов, управление программой.

Оператор IF проверяет условие в скобках и выполняет последующее выражение или блок в фигурных скобках, если условие истинно.

if (x == 5) // если x=5, то выполняется z=0
z=0;

if (x > 5) // если x >
{ z=0; y=8; }

IF … ELSE позволяет сделать выбор между двух вариантов.

if (x > 5) // если x > 5, то выполняется блок z=0, y=8;
{
z=0;
y=8;
}

{
z=0;
y=0;
}

ELSE IF – позволяет сделать множественный выбор

if (x > 5) // если x > 5, то выполняется блок z=0, y=8;
{
z=0;
y=8;
}

else if (x > 20) // если x > 20, выполняется этот блок
{
}

else // в противном случае выполняется этот блок
{
z=0;
y=0;
}

SWITCH CASE - множественный выбор. Позволяет сравнить переменную (в примере это x) с несколькими константами (в примере 5 и 10) и выполнить блок, в котором переменная равна константе.

switch (x) {

case 5:
// код выполняется если x = 5
break;

case 10:
// код выполняется если x = 10
break;

default:
// код выполняется если не совпало ни одно предыдущее значение
break;
}

Цикл FOR . Конструкция позволяет организовывать циклы с заданным количеством итераций. Синтаксис выглядит так:

for (действие до начала цикла;
условие продолжения цикла;
действие в конце каждой итерации) {

// код тела цикла

Пример цикла из 100 итераций.

for (i=0; i < 100; i++) // начальное значение 0, конечное 99, шаг 1

{
sum = sum + I;
}

Цикл WHILE . Оператор позволяет организовывать циклы с конструкцией:

while (выражение)
{
// код тела цикла
}

Цикл выполняется до тех пор, пока выражение в скобках истинно. Пример цикла на 10 итераций.

x = 0;
while (x < 10)
{
// код тела цикла
x++;
}

DO WHILE – цикл с условием на выходе.

do
{
// код тела цикла
} while (выражение);

Цикл выполняется пока выражение истинно.
BREAK – оператор выхода из цикла. Используется для того, чтобы прервать выполнение циклов for, while, do while.

x = 0;
while (x < 10)
{
if (z > 20) break; // если z > 20, то выйти из цикла
// код тела цикла
x++;
}

GOTO – оператор безусловного перехода.

goto metka1; // переход на metka1
………………
metka1:

CONTINUE - пропуск операторов до конца тела цикла.

x = 0;
while (x < 10)
{
// код тела цикла
if (z > 20) continue; // если z > 20, то вернуться на начало тела цикла
// код тела цикла
x++;
}

Массивы.

Массив это область памяти, где последовательно хранятся несколько переменных.

Объявляется массив так.

int ages; // массив из 10 переменных типа int

float weight; // массив из 100 переменных типа float

При объявлении массивы можно инициализировать:

int ages = { 23, 54, 34, 24, 45, 56, 23, 23, 27, 28};

Обращаются к переменным массивов так:

x = ages; // x присваивается значение из 5 элемента массива.
ages = 32; // 9 элементу массива задается значение 32

Нумерация элементов массивов всегда с нуля.

Функции.

Функции позволяют выполнять одни и те же действия с разными данными. У функции есть:

• имя, по которому ее вызывают;
• аргументы – данные, которые функция использует для вычисления;
• тип данных, возвращаемый функцией.

Описывается пользовательская функция вне функций setup() и loop().

void setup() {
// код выполняется один раз при запуске программы
}

void loop() {
// основной код, выполняется в цикле
}

// объявление пользовательской функции с именем functionName
type functionName(type argument1, type argument1, … , type argument)
{
// тело функции
return();
}

Пример функции, вычисляющей сумму квадратов двух аргументов.

int sumQwadr (int x, int y)
{
return(x* x + y*y);
}

Вызов функции происходит так:

d= 2; b= 3;
z= sumQwadr(d, b); // в z будет сумма квадратов переменных d и b

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

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

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

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

Имена в языке C.

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

Signal, TimeCount

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

», мы узнали, как использовать цикл «for» для организации работы контроллера. Этот тип цикла используется повсеместно и с лихвой перекрывает «потребность в зацикленных операциях». Однако существует еще один тип цикла — «while». ничем не лучше, чем цикл for, просто он использует в работе другие принципы.

В большинстве случаем можно выбирать, какой из двух типов циклов использовать. В мы использовали «while» для приостановки программы, до момента введения пользователем требуемых данных. В этом уроке мы более подробно рассмотрим, как работают этот цикл на примере платформы Arduino.

Продолжим работу со схемой, состоящую из 2-х светодиодов.

Кроме того, мы продолжим работать с кодом, который мы дорабатывали в 14 уроке.

Назад в прошлое: контроллер запрашивает у пользователя данные, ожидает ввода, а затем присваивает полученные значения переменным blinkNumberGreen и blinkNumberRed . Это позволяет пользователю управлять количество миганий каждого из 2-х светодиодов.

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

Давайте разбираться, как это работает:

int z = 1 ; // объявляем переменную и присваиваем ей значение 1

while (z <=10) { //запускаем цикл while

Serial . println (z ); //выводим текущее значение переменной z через последовательный порт

z = z +1 // увеличиваем значение переменной z на 1

} // завершаем цикл

Цикл while будет продолжать выполнять команды до тех пор, пока «условие», описанное в круглых скобках, истинно. В приведенном выше примере, цикл будет продолжать выполнять команды пока z меньше или равно 10. В теле цикла отрабатываются 2 команды:

• Выведение значения переменной через последовательный порт;
• Увеличение значение переменной на 1 (по-научному – инкрементирование).

Благодаря увеличению значения переменной, в конечном итоге, программа выйдет из цикла. Если, представить на секунду, что мы забыли указать эту строку или произойдёт, какой-то сбой, то программа благополучно зациклится (иными словами зависнет).

Цикл начинает свою работу с того, что проверяет истинность условия. Если, z меньше или равно 10, то программа отрабатывает цикл. Затем следует повторная проверка условия и т.д. Когда значение переменной достигнет z = 11 , условие больше не будет истинным. Программа не отработает цикл и перейдёт в следующую строку, идущую сразу после фигурной скобки цикла.

Достаточно теории, переходим к практике. Заменим циклы for в исходном коде, на циклы while.

Мигалка в исполнении цикла FOR:

for (int i = 1; i <= blinkNumberGreen; i++) // запускаем цикл for

{

Serial . print (» Зелёный мигнул «);

Serial.println (i);

digitalWrite (greenLed, HIGH); // включаем зелёный светодиод

delay (timeOnGreenLed); // ждём

digitalWrite (greenLed, LOW); // выключаем зелёный светодиод

delay (timeOffGreenLed); // ждём

}

Мигалка в исполнении цикла WHILE:

int i =1; //объявляем переменную и присваиваем ей значение 1

while (i <= blinkNumberGreen)

{ // запускаем цикл while

Serial.print (» Зелёный мигнул «);

Serial.println(i);

digitalWrite(greenLed,HIGH); // включаем зелёный светодиод

delay(timeOnGreenLed); // ждём

digitalWrite(greenLed,LOW); // выключаем зелёный светодиод

delay(timeOffGreenLed); // ждём

i = i +1 //увеличиваем значение переменной на 1

}

Сохраняем программу и загружаем прошивку в контроллер. Смотрим на результат.

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

Arduino IDE позаимствовал с C/C++ большинство необходимых элементов управления. Их синтаксис идентичен с C. Ниже мы в двух словах опишем их синтаксис.

Оператор if

Оператор if позволяет выполнить определенный фрагмент программы в зависимости от результата проверки определенного условия. Если условие выполняется, то код программы будет выполнен, если же условие не выполняется, то код программы будет пропущен. Синтаксис команды if выглядит следующим образом:

If(условие) { инструкция1; инструкция2; }

Условием может быть любое сравнение переменной или значения, возвращаемое функцией. Основным критерием условия if является то, что ответ всегда должен быть или истина (true) или ложь (false). Примеры условий для оператора if:

If(a!=2) { } if(x<10) { } if(znak==’B’) { }

Внутри скобок, которые прописаны внутри условия, можно выполнить код.

Люди, которые приступают к изучению программирования, часто делают ошибку, приравнивая значение указанной переменной с помощью одного знака «=». Такая запись однозначно указывает на присвоение значения переменно, и, следовательно, условие всегда будет «true», то есть выполняться. Проверка того, что переменная равна определенному значению, всегда обозначается двойным знаком равно (==).

В качестве условия можно использовать состояние функции, например:

If(init()) { Serial.print(«ок»); }

Приведенный выше пример будет выполнен следующим образом: на первом этапе вызывается функция init(). Эта функция возвращает значение, которое будет интерпретировано как «true» или «false». В зависимости от результата сравнения будет отправлен текст «ок» или ничего не будет отправлено.

Оператор if…else

Расширенным оператором if является оператор if….else. Он обеспечивает выполнение одного фрагмента кода, когда условие выполняется (true), и выполнение второй фрагмент кода, если условие не выполняется (false). Синтаксис операторf if….else выглядит следующим образом:

If (условие) { // команда A } else { // команда B }

Команды «A» будут выполняться только в том случае, если условие выполнено, команда «B» будет выполняться, когда условие не выполнено. Одновременное выполнение команды «A» и «B» невозможно. Следующий пример показывает, как использовать синтаксис if…else:

If (init()) { Serial.print(«ок»); } else { Serial.print(«ошибка»); }

Подобным образом можно проверить правильность выполнения функции и информировать об этом пользователя.

Обычной практикой является отрицание условия. Это связано с тем, что функция, которая выполнена правильно возвращает значение 0, а функция, которая отработала неверно по какой-то причине, возвращает ненулевое значение.

Объяснение такого «усложнения жизни» — просто. Если функция выполнена правильно, то это единственная информация, которая нам нужна. В случае же ошибки, стоит иногда понять, что пошло не так, почему функция не выполнена правильно. И здесь на помощь приходят числа, отличающиеся от нуля, т. е. с помощью цифровых кодов мы можем определить тип ошибки. Например, 1 — проблема с чтением какого-то значения, 2 — нет места в памяти или на диске и т. д.

В последнем измененном примере показано, как вызвать функцию, которая возвращает ноль при правильном выполнении:

If (!init()) { Serial.print(«ок»); } else { Serial.print(«ошибка»); }

Оператор switch case

Оператор if позволяет проверить только одно условие. Иногда необходимо выполнить одно из действий в зависимости от возвращаемого или прочитанного значения. Для этого идеально подходит оператор множественного выбора switch. Ниже показан синтаксис команды switch:

Switch (var) { case 1: //инструкция для var=1 break; case 2: // инструкция для var=2 break; default: // инструкция по умолчанию (если var отличается от 1 и 2) }

В зависимости от значения переменной var выполняются инструкции в определенных блоках. Метка case означает начало блока для указанного значения. Например, case 1: означает, что данный блок будет выполнен для значения переменной var, равной один.

Каждый блок должен быть завершен с помощью команды break. Он прерывает дальнейшее выполнение оператора switch. Если команду break пропустить, то инструкции будут выполняться и в последующих блоках до команды break. Метка default не является обязательной, как и else в команде if. Инструкции, расположенные в блоке default выполняются только тогда, когда значение переменной var не подходит ни к одному шаблону.

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

Switch (x) { case 1: //инструкция для x=1 break; case 2: case 3: case 5: // инструкция для x=2 или 3 или 4 break; case 4: // инструкция для x=4 break; case 6: // инструкция для x=6 break; default: // инструкция по умолчанию (если х отличается от 1,2,3,4,5,6) }

В зависимости от значения переменной x будет выполнен соответствующий блок инструкций. Повторение case 2: case 3: case 5: информирует компилятор о том, что если переменная x имеет значение 2 или 3 или 5, то будет выполнен один и тот же фрагмент кода.

Оператор for

Оператор for используется для многократного выполнения одного и того же кода. Часто необходимо выполнить одни и те же инструкции, изменив только значение какой-то переменной. Для этого идеально подходит цикл for. Синтаксис команды выглядит следующим образом:

Int i; for(i=0;i<10;i++) { // инструкции для выполнения в цикле }

Первый параметр, приводимый в инструкции for — начальное значение переменной. Еще один элемент — это проверка условия о продолжении выполнения цикла. Цикл выполняется до тех пор, пока выполняется условие. Последний элемент — это изменение значения переменной. Чаще всего мы увеличиваем или уменьшаем ее значение (по необходимости). В этом примере, инструкции, содержащиеся в цикле будут выполняться при i=0…9.

Часто переменная, используемая в цикле объявляется там же:

For(int i=0;i<10;i++) { // инструкции для выполнения в цикле }

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

For(int i=10;i>0;i—) { Serial.print(i); // отправятся номера 10,9,8,7,6,5,4,3,2,1 }

Оператор while

Цикл for идеально подходит там, где мы хотим выполнить подсчет. В ситуации, когда необходимо выполнить определенные действия в результате какого-то события, которое не обязательно является предсказуемым (например, мы ждем нажатия кнопки), то мы можем использовать оператор while, который выполняет блок оператора до тех пор, пока выполняется условие. Синтаксис оператора while выглядит следующим образом:

While(условие) { // блок инструкций для выполнения }

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

Int x=2; while(x>5) { Serial.print(x); } —————————————- int y=5; while(y>0) { Serial.print(y); }

Первый блок операторов, расположенный внутри while не выполнится никогда. Переменная x имеет значение два и она не станет больше 5. Во втором примере мы имеем дело с бесконечным циклом. Переменная «y» имеет занчение 5, т. е. больше нуля. Внутри цикла не происходит никакого изменения переменной «y», поэтому цикл никогда не будет завершен.

Это распространенная ошибка, когда мы забываем об изменении параметра, вызывающего прекращение цикла. Ниже приведено два правильных примера применения цикла while:

Int x=0; while(x<10) { //блок инструкций x++; } —————————————- while(true) { if(условие) break; // блок инструкций }

В первом примере мы позаботились об изменении значения переменной, которая проверяется в условии. В результате цикл когда-нибудь завершится. Во втором примере был преднамеренно создан бесконечный цикл. Этот цикл эквивалентен функции loop () в Arduino IDE. Кроме того, внутри цикла введена проверка условия, после выполнения которого цикл завершается командой break.

Оператор do…while

Разновидностью цикла while является цикл do…while. Кроме синтаксиса он отличается местом проверки условия. В случае do…while проверка условия производится после выполнения блока инструкций. Это означает, что блок инструкций в теле цикла выполнится хотя бы один раз. Ниже приведен синтаксис команды do…while:

Do { // блок инструкций } while(условие)

Все, что написано об операторе while относится также и к do…while. Ниже приведен пример использования цикла do…while:

Int x=10; do { // блок инструкций x—; } while(x>0); —————————————- do { // блок инструкций if(условие) break; } while(true);

Оператор break

Оператор break позволяет выйти из цикла (do…while, for, while) и выйти из опции switch. В следующем примере рассмотрим выполнение команды break:

For(i=0;i<10;i++) { if(i==5) break; Serial.print(i); }

Цикл должен быть исполнен для чисел от 0 до 9, но для числа 5 выполняется условие, которое запускает оператор break. Это приведет к выходу из цикла. В результате в последовательный порт (Serial.print) будет отправлены только числа 0,1,2,3,4.

Оператор continue

Оператор continue вызывает прекращение выполнения инструкций цикла (do…while, for, while) для текущего значения и переход к выполнению следующего шага цикла. В следующем примере показано, как работает оператор continue:

For(i=0;i<10;i++) { if(i==5) continue; Serial.print(i); }

Как не трудно заметить, цикл будет выполнен для значения от 0 до 9. Для значения 5 исполнится команда continue, в результате чего инструкции, находящиеся после этой команды выполнены не будут. В результате в последовательный порт (Serial.print) будут отправлены числа 0,1,2,3,4,6,7,8,9.

Оператор return

Оператор return завершает выполнение вызываемой функции и возвращает значение определенного типа. В качестве параметра команды можно указать число, символ или переменную определенного типа. Важно, чтобы возвращаемое значение соответствует типу заявленной функции. В следующем примере показано, как использовать оператор return:

Int checkSensor(){ if (analogRead(0) > 400) { // чтение аналогового входа return 1; // Для значений больше 400 возвращается 1 else{ return 0; // для других возвращается 0 } }

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

Void имя_функции() { инструкция1; if(x==0) return; инструкция2; инструкция3; }

В приведенном выше примере инструкция1 будет выполнять всегда, когда вызывается функция. Выполнение же инструкция2 и инструкция3 зависит от результата команды if. Если условие будет выполнено (true), то будет выполнена команда return и функция завершит работу.

В случае, когда условие не выполнено команда return так же не выполняется, а выполняются инструкции инструкция2 и инструкция3, и после этого функция завершает свою работу.

Оператор goto

Из идеологических соображений необходимо пропустить это описание… Оператор goto является командой, которую не следует использовать в обычном программировании. Он вызывает усложнения кода и является плохой привычкой в программировании. Настоятельно рекомендуем не использовать эту команду в своих программах. Из-за того, что goto есть в официальной документации на сайте arduino.cc приведем его краткое описание. Синтаксис команды goto:

…. goto metka; // перейдите на строку с надписью ‘metka’ ….. …. …. metka: // метка, с которой программа продолжит работу …

Команда позволяет переход к обозначенной метке, т. е. к месту в программе.