Циклы и переменные в блочном коде: цикл for и массивы на Arduino

Циклы и переменные в блочном коде — два кирпичика, которые превращают программу из «сделай это один раз» в «делай это постоянно, и делай с умом». Цикл снова и снова выполняет одни и те же блоки, а переменная запоминает число, пока идут эти повторения. В блоках BlueGrays они выглядят как «повторять всегда», «считать с i», «глобальные переменные (в начале)» и «установить … в …»; в коде Arduino, который загружается в плату, им соответствуют loop(), цикл for, переменная int и строка присваивания.

В этой части мы прочитаем блоки четырёх бесплатных проектов рядом с их настоящим кодом на C++: «Бегущий огонь», который по очереди зажигает шесть светодиодов; «Бегущий огонь с регулировкой скорости», который берёт скорость от потенциометра; «Огни Knight Rider», где свет бежит от одного края к другому и обратно; и его версию с потенциометром — «Огни Knight Rider с регулировкой скорости». Во всех четырёх одна и та же схема: шесть светодиодов на пинах D2–D7 и потенциометр на A0. В конце ты напишешь собственный пример со счётчиком и разберёшь три ошибки, которые новички делают чаще всего: счёт на один больше или на один меньше, выход за конец массива и долгие паузы, из-за которых кнопки «слепнут».

Блок «повторять всегда» и loop(): почему плата никогда не останавливается?

Программа на компьютере закрывается, когда её работа сделана; программа на Arduino — нет. У платы нет операционной системы, и процессору больше нечем заняться. Поэтому у каждого блочного проекта один и тот же скелет: всё, что стоит внутри «настройка (один раз)», выполняется один раз при подаче питания на плату или нажатии кнопки сброса, а всё, что стоит внутри «повторять всегда», без остановки повторяется сверху вниз. В C++ это функции setup() и loop(). Как только выполнена последняя строка loop(), плата сразу возвращается к первой строке; короткий loop() без пауз может выполняться десятки тысяч раз в секунду. Остановить плату можно только двумя способами: отключить питание или загрузить новую программу. Это бесконечное повторение — не недостаток, а сам замысел: чтение кнопки, наблюдение за датчиком и мигание светодиодом выполняются заново на каждом проходе, поэтому плата постоянно реагирует на изменения вокруг.

Переменные в блочном коде: глобальные переменные и блок «объявить»

Переменная — это маленькая коробка, в которую ты кладёшь число и к которой обращаешься по имени. В блоках переменные создаются внутри фиолетового блока «глобальные переменные (в начале)». Блок «объявить целое (int) potValue = 0» внутри него превращается в коде в строку int potValue: int — это тип, potValue — имя, а 0 — начальное значение. Слова «в начале» важны: эти строки стоят в самом верху файла, вне setup() и loop(). Объявленная так глобальная переменная видна из любого места программы и не теряет значение каждый раз, когда loop() начинается заново. На Arduino Uno int занимает 2 байта и хранит целые числа от -32768 до 32767 — этого с запасом хватает и для диапазона 0–1023 у analogRead(), и для номеров пинов. Можно заметить, что в блоках проекта «Бегущий огонь с регулировкой скорости» написано potValue = 0, а в его коде — просто int potValue;. Результат одинаковый: в C++ глобальная переменная без начального значения начинается с нуля.

Блок, который потом меняет переменную, — «установить … в …». Блок «установить potValue в аналоговое чтение A0» превращается в коде в potValue = analogRead(A0);. Знак = здесь — не равенство, как в математике; он означает «вычисли значение справа и положи его в коробку слева». Сравнение, которое проверяет, равны ли два значения, в C++ пишется через ==; мы видели это на блоке «если» в предыдущей части серии. Когда выполняется блок «установить», старое значение в коробке стирается и записывается новое. Каждый блок, который читает переменную, теперь использует это новое значение: «ждать potValue мс» ждёт столько миллисекунд, сколько хранится в potValue в этот момент.

Цикл со счётом: блок «считать с i» и цикл for в Arduino

Чтобы повторить что-то заданное число раз, используется зелёный блок «считать с i от 0 до 5 через 1». Он создаёт счётчик с именем i, присваивает ему 0, выполняет блоки внутри, затем прибавляет к i единицу и снова выполняет их — и так до тех пор, пока i не станет больше 5. Его соответствие в Arduino — строка for (int i = 0; i < 6; i++). В скобках три части, разделённые точкой с запятой: начало (int i = 0), условие продолжения (i < 6) и шаг после каждого прохода (i++, то есть прибавить к i единицу). Самое важное, на что стоит обратить внимание: конечное значение в блоке входит в диапазон. «От 0 до 5» означает 0, 1, 2, 3, 4 и 5, поэтому цикл выполняется 6 раз, а не 5, и каждому из шести светодиодов достаётся по одному проходу. Вот почему в коде написано i < 6, что означает то же самое, что i <= 5. Шаблон «начни с нуля и продолжай, пока меньше числа элементов» очень распространён в коде Arduino, потому что число 6 сразу говорит, сколько светодиодов.

Блок массива: «массив 2 3 4 5 6 7» и ledPins[i]

Вместо того чтобы объявлять шесть отдельных переменных для шести светодиодов, можно держать их все в одном списке. Когда фиолетовый блок «массив 2 3 4 5 6 7» вставляют в «объявить целое (int) ledPins = …», в коде он становится строкой int ledPins[] = {2, 3, 4, 5, 6, 7};. Квадратные скобки говорят, что это массив, а в фигурных скобках лежат его значения. К элементу обращаются по номеру позиции — индексу, и в C++ индекс начинается с 0: первый элемент — ledPins[0], последний — ledPins[5]. В блоках это делает блок «элемент i из ledPins», который превращается в ledPins[i]. Поскольку цикл со счётом тоже начинается с 0, они идеально подходят друг к другу: на каждом проходе i даёт следующий индекс, а ledPins[i] — номер пина, который там хранится. Ещё одно удобство массивов: чтобы поменять порядок светодиодов, достаточно переставить числа в списке, не трогая цикл. Подробнее о массивах — в статье Массивы в Arduino.

Бегущий огонь: блоки и C++ строка за строкой

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri, yanma sırasıyla / LED pins in lighting order
2
3void setup() {
4  // Tüm LED pinlerini çıkış yap / Set all LED pins as outputs
5  for(int i = 0; i < 6; i++) {
6    pinMode(ledPins[i], OUTPUT);
7  }
8}
9
10void loop() {
11  // Her LED'i sırayla 150 ms yak / Light each LED in turn for 150 ms
12  for(int i = 0; i < 6; i++) {
13    digitalWrite(ledPins[i], HIGH);
14    delay(150);
15    digitalWrite(ledPins[i], LOW);
16  }
17}

Представь программу как временную шкалу. Когда плата запускается, цикл в настройке по очереди, от 0 до 5, делает шесть пинов выходами, и больше это никогда не повторяется. Затем начинается «повторять всегда»: цикл со счётом внутри зажигает светодиод на D2, ждёт 150 мс, гасит его, потом делает то же для D3, D4, D5, D6 и D7. Один круг занимает 6 × 150 = 900 мс. Когда гаснет последний светодиод, loop() заканчивается, плата сразу возвращается в начало, и свет снова стартует с D2; поскольку между кругами нет паузы, кажется, что свет течёт без остановки. Чтобы изменить скорость, достаточно поменять одно число — 150: напиши 50, и свет побежит в три раза быстрее, напиши 500 — и он будет неспешно прогуливаться. Как сделать эту постоянную скорость регулируемой с помощью ручки, покажет следующий проект.

Бегущий огонь с регулировкой скорости: значение потенциометра становится временем ожидания

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri, yanma sırasıyla / LED pins in lighting order
2int potValue;                         // Pot değeri = bekleme (ms) / Pot value = delay (ms)
3
4void setup() {
5  // Tüm LED pinlerini çıkış yap / Set all LED pins as outputs
6  for(int i = 0; i < 6; i++) {
7    pinMode(ledPins[i], OUTPUT);
8  }
9}
10
11void loop() {
12  for(int i = 0; i < 6; i++) {
13    potValue = analogRead(A0);        // Hızı oku (0-1023) / Read the speed (0-1023)
14    digitalWrite(ledPins[i], HIGH);
15    delay(potValue);                  // Pot değeri kadar ms bekle / Wait as many ms as the pot value
16    digitalWrite(ledPins[i], LOW);
17  }
18}

От бегущего огня этот проект отличается только двумя новыми блоками. В глобальные переменные добавлен блок «объявить целое (int) potValue = 0», а цикл со счётом начинается с блока «установить potValue в аналоговое чтение A0». analogRead(A0) превращает напряжение на среднем выводе потенциометра в число от 0 до 1023; это число сразу идёт в «ждать potValue мс», то есть в строку delay(potValue). Поверни ручку в один край, и каждый светодиод будет гореть около секунды (1023 мс), так что круг займёт примерно 6 секунд; поверни в другой край, и ожидание упадёт до 0, а светодиоды будут переключаться так быстро, что покажется, будто все они тускло светятся одновременно. Чтение потенциометра внутри цикла, перед каждым светодиодом, — осознанный выбор: следующий светодиод использует новую скорость, как только ты поворачиваешь ручку, и ждать окончания круга не нужно. Как работает потенциометр, рассказано в статье что такое потенциометр.

Огни Knight Rider: два цикла, которые считают вперёд и назад

В эффекте Knight Rider свет бежит от одного края к другому и возвращается. В блоках проекта «Огни Knight Rider» внутри «повторять всегда» друг под другом стоят два цикла со счётом. Первый — знакомый «считать с i от 0 до 5 через 1» — ведёт свет от D2 к D7. Второй — «считать с i от 4 до 1 через 1»: поскольку начало больше конца, блок считает в обратную сторону, и i по очереди принимает значения 4, 3, 2, 1. В коде это строка for(int i = 4; i > 0; i--); i-- вычитает из i единицу. Почему от 4 до 1, а не от 5 до 0? Потому что ledPins[5] (D7) уже горит в конце прохода вперёд, а ledPins[0] (D2) — в начале следующего. Если на обратном пути пропустить крайние светодиоды, они не загораются дважды подряд, и отскок выглядит плавным. Путь туда и обратно — это 6 + 4 = 10 шагов по 100 мс, всего 1 секунда. В проекте «Огни Knight Rider с регулировкой скорости» те же два цикла; в начало обоих лишь добавлен блок «установить potValue в аналоговое чтение A0», а вместо 100 мс стоит «ждать potValue мс». Больше узоров — в статье Огни Knight Rider и бегущий огонь на Arduino.

Свой пример со счётчиком: счётчик кругов и последовательный порт

Теперь напишем небольшой пример, который объединяет всё сразу: каждый раз, когда бегущий огонь заканчивает круг, счётчик увеличивается, а плата выводит на компьютер и значения i, и число кругов. С блоками из иллюстраций это собирается так: в глобальные переменные под массивом ledPins добавляется «объявить целое (int) rounds = 0». В настройку ставится блок «запустить порт на 9600 бод». Внутри цикла со счётом, до включения светодиода, блоки «вывести в порт» печатают текст «i = », затем i, затем текст « pin = » с вариантом «без переноса» и, наконец, «элемент i из ledPins» с вариантом «новая строка». После цикла со счётом, всё ещё внутри «повторять всегда», блок «установить rounds в …» получает сумму rounds + 1, а число кругов выводится через «вывести в порт … новая строка».

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri / LED pins
2int rounds = 0;                       // tamamlanan tur sayısı / number of finished rounds
3
4void setup() {
5  Serial.begin(9600);                 // seri port 9600 baud / serial port at 9600 baud
6  for (int i = 0; i < 6; i++) {
7    pinMode(ledPins[i], OUTPUT);
8  }
9}
10
11void loop() {
12  for (int i = 0; i < 6; i++) {
13    Serial.print("i = ");             // aynı satırda kal / stay on the same line
14    Serial.print(i);
15    Serial.print("  pin = ");
16    Serial.println(ledPins[i]);       // alt satıra geç / new line
17    digitalWrite(ledPins[i], HIGH);
18    delay(300);
19    digitalWrite(ledPins[i], LOW);
20  }
21  rounds = rounds + 1;                // sayacı bir artır / add one to the counter
22  Serial.print("Tur / Round: ");
23  Serial.println(rounds);
24}

После загрузки открой «Монитор порта» (Serial Monitor) в Arduino IDE и выставь скорость 9600 бод. На каждом круге ты увидишь шесть строк, от «i = 0 pin = 2» до «i = 5 pin = 7», а за ними строку «Tur / Round», которая считает 1, 2, 3. Этот вывод — самое наглядное доказательство того, что конечное значение блока «считать» входит в диапазон: «от 0 до 5» даёт ровно шесть значений. Обрати внимание и на то, что rounds объявлена в глобальных переменных: она не сбрасывается каждый раз, когда начинается loop(), и переносит своё значение от круга к кругу. Один круг занимает 6 × 300 = 1,8 секунды, так что предел int в 32767 достигается примерно через 16 часов; если нужно считать дольше, сделай переменную unsigned long. Подробнее о мониторе порта — в статье Монитор порта Arduino.

Схема: 6 светодиодов, резисторы 220 Ω и потенциометр

Резистор 220 Ω пропускает через красный светодиод с питанием от 5 V примерно (5 − 2) / 220 ≈ 14 mA — это безопасно и для светодиода, и для пина Arduino. Если светодиоды другого цвета, проверь резистор в калькуляторе резистора для светодиода. Собери все катоды на шине GND макетной платы и соедини эту шину с пином GND Arduino. Если поменять местами крайние выводы потенциометра, ничего не сломается; просто ручка будет работать в обратную сторону. Проекты «Бегущий огонь» и «Огни Knight Rider» потенциометр не используют, и если он останется подключённым, это не навредит, так что все четыре проекта можно по очереди попробовать на одной схеме.

Частые ошибки с циклами и переменными

Циклы и блоки переменных в приложении BlueGrays

Четыре проекта из этой статьи и те, что перечислены ниже, в приложении BlueGrays полностью бесплатны — и блоки, и код. В разделе кода проекта включи переключатель Показать блоками, и вместо кода появятся блоки той же программы; нажми на изображение, чтобы открыть его на весь экран и спокойно увеличить длинные циклы со счётом. Вкладка Разбор блоков проводит по программе шаг за шагом и показывает только блоки текущего шага и то, что они делают. Другие бесплатные проекты, которые стоит посмотреть блоками: «Полицейская мигалка», которая работает на переменной delayTime и двух циклах со счётом; «Светофор», который по очереди проходит четыре состояния внутри «повторять всегда»; «Измерение освещённости с LDR», где показание хранится в переменной и выводится в последовательный порт; и «Переключение светодиода кнопкой (вкл/выкл)», где состояние светодиода запоминается в переменной. Каждый пример для Arduino в Справочнике по коду тоже показан блоками, а Вопросы дня помогают закрепить изученное: 5 вопросов в день уровней от A1 до C2. Полный список блочных проектов — на странице «Блочный код». Блоки не загружаются в плату напрямую; в плату всегда попадает настоящий код проекта, поэтому программу, понятую через блоки, ты копируешь в Arduino IDE и отправляешь в свою плату.

Теперь, когда циклы и переменные тебе знакомы, следующий шаг — брать эти числа из реального мира: в 5-й части серии мы разберём чтение датчиков с помощью блоков, последовательный порт и переход на MicroPython на Pico. А пока в приложении BlueGrays можно посмотреть бегущий огонь, огни Knight Rider и их версии с регулировкой скорости вместе со схемами подключения и кодом, переключиться на блоки через Показать блоками, а на пошаговое объяснение — через Разбор блоков, и самостоятельно проследить, какой строке кода соответствует каждый цикл со счётом.