Массивы в Arduino: объявление, цикл for и практические примеры
Массивы в Arduino шаг за шагом: объявление, индексы, обход циклом for, двумерные массивы, пины светодиодов, усреднение показаний датчика (скользящее среднее) и мелодии.
Массивы в Arduino — базовый навык программирования: они позволяют собрать много значений одного типа под одним именем и обращаться к каждому по номеру (индексу). Вместо того чтобы записывать номера пинов шести светодиодов, последние десять показаний датчика или ноты песни в отдельные переменные вроде led1, led2, led3, ты хранишь их в одном массиве и обрабатываешь все сразу в несколько строк с помощью цикла for. Код становится короче, ошибок меньше, а чтобы добавить в схему ещё один светодиод, достаточно дописать одно число в список.
В этом руководстве ты узнаешь, как массив располагается в памяти, как его объявить, почему индекс начинается с нуля и как посчитать число элементов с помощью sizeof. Затем сделаем три реальных примера: эффект Knight Rider на светодиодах, скользящее среднее, которое сглаживает шумные данные датчика, и проигрывание мелодии на зуммере. В конце построим таблицу состояний светофора на двумерных массивах, разберём отличия на ESP32 и Raspberry Pi Pico и посмотрим, как ловить ошибки переполнения, которые незаметно ломают программу. Если тема совсем новая, сначала загляни в статью основы программирования Arduino.

Что такое массив и как он работает?
Массив — это блок элементов одного типа данных, которые лежат в памяти друг за другом. Представь шкаф с пронумерованными ящиками: у шкафа одно имя, а у каждого ящика свой номер. В языке Arduino, основанном на C и C++, нумерация начинается с 0: у массива из 5 элементов индексы 0, 1, 2, 3 и 4, то есть последний индекс всегда на единицу меньше числа элементов. Компилятор знает начальный адрес массива; когда ты пишешь array[3], он прибавляет к начальному адресу 3 × размер элемента и сразу переходит к нужной ячейке. Поэтому доступ к массиву очень быстрый, но по той же причине компилятор не проверяет, не вышел ли ты за его границы. Объём памяти, который занимает массив, равен числу элементов, умноженному на размер одного элемента:
| Тип данных | Размер элемента (Uno) | Размер элемента (ESP32 / Pico, C++) | Массив из 100 элементов (Uno) |
|---|---|---|---|
| byte / uint8_t | 1 байт | 1 байт | 100 байт |
| char | 1 байт | 1 байт | 100 байт |
| int | 2 байта | 4 байта | 200 байт |
| unsigned int | 2 байта | 4 байта | 200 байт |
| long | 4 байта | 4 байта | 400 байт |
| float | 4 байта | 4 байта | 400 байт |
Если учесть, что у Arduino Uno всего 2 КБ (2048 байт) ОЗУ, массив int из 1000 элементов в одиночку съест почти всю память. Поэтому полезная привычка — использовать byte для значений от 0 до 255 (номера пинов, яркость ШИМ, день или час), int для результатов analogRead и long для больших сумм. Правильно выбранный тип — это вдвое больше данных в том же объёме памяти.
Как объявить массив в Arduino?
При объявлении массива сначала пишется тип данных, затем имя массива, а в квадратных скобках — число элементов. Значения можно сразу задать в фигурных скобках или оставить размер пустым и доверить подсчёт компилятору. Программа ниже показывает самые частые формы вместе и выводит результаты в монитор порта:
1int notlar[5] = {90, 75, 60, 85, 100}; // boyut ve değerler / size and values
2int pinler[] = {2, 3, 4, 5, 6, 7}; // boyutu derleyici sayar / compiler counts the size
3float olcumler[10] = {1.5, 2.0}; // kalan 8 eleman 0.0 / remaining 8 are 0.0
4int bos[5]; // global dizi: hepsi 0 / global array: all zeros
5char isim[] = "Arduino"; // 7 harf + '\0' = 8 bayt / 7 letters + '\0' = 8 bytes
6
7void setup() {
8 Serial.begin(9600);
9 Serial.println(notlar[0]); // ilk eleman: 90 / first element: 90
10 Serial.println(notlar[4]); // son eleman: 100 / last element: 100
11 notlar[2] = 65; // üçüncü elemanı değiştir / change the third element
12 Serial.println(notlar[2]); // 65
13 Serial.println(olcumler[5]); // 0.00
14 Serial.println(bos[3]); // 0
15 Serial.println(sizeof(isim)); // 8
16 Serial.println(sizeof(pinler) / sizeof(pinler[0])); // eleman sayısı: 6 / element count: 6
17}
18
19void loop() {
20}| Объявление | Что означает |
|---|---|
| int a[5]; (без значений) | Массив из 5 элементов; если он глобальный, все элементы равны 0, если внутри функции — начальные значения случайные |
| int a[5] = {1, 2, 3, 4, 5}; (размер и значения) | Размер и все значения задаются вместе |
| int a[] = {2, 3, 4}; (без размера) | Размер считает компилятор (здесь 3) |
| float a[10] = {1.5, 2.0}; (часть значений) | Элементы без заданного значения становятся равны 0 |
| int a[5] = {0}; (обнуление) | Короткий способ обнулить все элементы |
| char s[] = "Arduino"; (строка) | Массив символов (текст); в конце есть невидимый символ '\0' (всего 8 байт) |
| const byte a[] = {2, 3, 4}; (константа) | Константный массив, который нельзя изменить в программе |
Обход массива циклом for
Настоящая сила массивов проявляется в связке с циклом for. Переменная цикла i начинается с 0 и растёт до числа элементов минус один, и на каждом проходе ты получаешь следующий элемент через array[i]. Вместо того чтобы вписывать число элементов вручную, надёжнее всего вычислять его так: sizeof(array) / sizeof(array[0]). sizeof(array) даёт общий размер массива в байтах, а sizeof(array[0]) — размер одного элемента. Например, на Uno массив int из 7 элементов занимает 14 байт, и 14 / 2 = 7. Если добавить элемент в массив, формула сама обновит количество. Код ниже находит среднее, минимум и максимум температуры за неделю. Сумма показаний — 161, среднее — 23,0 градуса, минимум — 19, максимум — 27. Обрати внимание, что условие цикла — i < ADET (количество): если сделать его «меньше или равно», цикл выполнится на один раз больше и прочитает память за пределами массива.
1int sicakliklar[] = {22, 24, 19, 27, 25, 21, 23}; // bir haftalık ölçüm / one week of readings
2const int ADET = sizeof(sicakliklar) / sizeof(sicakliklar[0]); // 7
3
4void setup() {
5 Serial.begin(9600);
6 long toplam = 0; // taşmasın diye long / long to avoid overflow
7 int enKucuk = sicakliklar[0];
8 int enBuyuk = sicakliklar[0];
9
10 for (int i = 0; i < ADET; i++) { // 0'dan 6'ya / from 0 to 6
11 toplam += sicakliklar[i];
12 if (sicakliklar[i] < enKucuk) enKucuk = sicakliklar[i];
13 if (sicakliklar[i] > enBuyuk) enBuyuk = sicakliklar[i];
14 }
15
16 Serial.print("Ortalama / Average: ");
17 Serial.println((float)toplam / ADET); // 23.00
18 Serial.print("En dusuk / Min: ");
19 Serial.println(enKucuk); // 19
20 Serial.print("En yuksek / Max: ");
21 Serial.println(enBuyuk); // 27
22}
23
24void loop() {
25}Пример 1: управление пинами светодиодов через массив
Классическое применение массивов в Arduino — управление несколькими светодиодами. Без массива для шести светодиодов пришлось бы писать шесть отдельных строк pinMode и отдельные строки digitalWrite для каждого шага; с массивом хватает одного цикла. Подключи длинную ножку (анод) каждого светодиода к цифровому пину, а короткую — к GND через резистор 220 Ω. Если хочешь рассчитать номинал резистора, воспользуйся утилитой калькулятор резистора для светодиода.
| Светодиод (индекс в массиве) | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Светодиод 1 (ledPins[0]) | D2 | GPIO 13 | GP14 |
| Светодиод 2 (ledPins[1]) | D3 | GPIO 14 | GP13 |
| Светодиод 3 (ledPins[2]) | D4 | GPIO 27 | GP12 |
| Светодиод 4 (ledPins[3]) | D5 | GPIO 26 | GP11 |
| Светодиод 5 (ledPins[4]) | D6 | GPIO 25 | GP10 |
| Светодиод 6 (ledPins[5]) | D7 | GPIO 33 | GP9 |
| Катод (короткая ножка) | GND через 220 Ω | GND через 220 Ω | GND через 220 Ω |
- Установи светодиоды на макетную плату по порядку; короткие ножки (катоды) подключи к шине GND через резисторы 220 Ω.
- Длинные ножки подключи к пинам 2–7 Arduino в порядке, указанном в таблице.
- Запиши номера пинов в массив ledPins в том порядке, в каком светодиоды стоят физически; порядок в массиве задаёт направление бега огня.
- В setup() одним циклом for переведи все пины в режим OUTPUT.
- В loop() создай эффект Knight Rider двумя циклами — сначала вперёд, потом назад — и загрузи код в плату.
1const byte ledPinleri[] = {2, 3, 4, 5, 6, 7}; // LED'lerin fiziksel sırası / physical order of LEDs
2const byte LED_SAYISI = sizeof(ledPinleri) / sizeof(ledPinleri[0]); // 6
3const int BEKLEME = 100; // adım süresi ms / step time in ms
4
5void setup() {
6 for (byte i = 0; i < LED_SAYISI; i++) {
7 pinMode(ledPinleri[i], OUTPUT); // tüm pinler çıkış / all pins as output
8 }
9}
10
11void loop() {
12 // ileri: 0'dan 5'e / forward: 0 to 5
13 for (byte i = 0; i < LED_SAYISI; i++) {
14 digitalWrite(ledPinleri[i], HIGH);
15 delay(BEKLEME);
16 digitalWrite(ledPinleri[i], LOW);
17 }
18 // geri: 4'ten 1'e, uçlar tekrar yanmaz / backward: 4 to 1, ends are not repeated
19 for (int i = LED_SAYISI - 2; i > 0; i--) {
20 digitalWrite(ledPinleri[i], HIGH);
21 delay(BEKLEME);
22 digitalWrite(ledPinleri[i], LOW);
23 }
24}Цикл вперёд по очереди зажигает и гасит каждый светодиод с 0 по 5 на 100 мс. Цикл назад начинается с 4 и останавливается на 1; поскольку крайние светодиоды он второй раз не зажигает, огонь плавно разворачивается без задержки на концах. В цикле назад мы использовали счётчик int, потому что byte беззнаковый и не может опуститься ниже 0: если в цикле, где счётчик должен стать меньше 0, взять byte, после 0 он перескочит на 255, и цикл никогда не закончится. Чтобы изменить порядок эффекта, достаточно переставить числа в массиве, не трогая остальной код. Другие эффекты на той же логике — в статье эффект Knight Rider и бегущие огни.
Пример 2: усреднение показаний датчика через массив (скользящее среднее)
Показания аналоговых датчиков — потенциометра, фоторезистора (LDR) или датчика влажности почвы — постоянно дрожат на несколько единиц. Проще всего уменьшить этот шум, усредняя последние N показаний. Ты хранишь последние 10 показаний в массиве и при каждом новом измерении вычитаешь из суммы самое старое значение и прибавляешь новое. Поскольку по достижении конца массива индекс возвращается к 0, такая структура называется кольцевым буфером (ring buffer). Обновление суммы методом «вычесть и прибавить» вместо пересчёта с нуля каждый раз сохраняет скорость, даже если окно вырастет до 100 элементов. Во время первых 10 показаний массив ещё не заполнен, поэтому среднее поднимается от нуля и примерно через полсекунды выходит на реальное значение. Подключи сигнальный вывод датчика к A0 (например, среднюю ножку потенциометра) и смотри результат двумя линиями в «Плоттере по последовательному соединению» (Serial Plotter):
1const byte PENCERE = 10; // ortalama alınacak okuma sayısı / number of readings to average
2int okumalar[PENCERE]; // global dizi sıfırla başlar / global array starts at zero
3byte indeks = 0; // sıradaki hücre / next slot
4long toplam = 0; // taşmasın diye long / long to avoid overflow
5
6void setup() {
7 Serial.begin(9600);
8}
9
10void loop() {
11 int yeni = analogRead(A0);
12 toplam -= okumalar[indeks]; // en eski okumayı çıkar / remove the oldest reading
13 okumalar[indeks] = yeni; // yerine yenisini yaz / store the new one
14 toplam += yeni; // toplama ekle / add to the total
15 indeks++;
16 if (indeks >= PENCERE) { // sona gelince başa dön / wrap around at the end
17 indeks = 0;
18 }
19 int ortalama = toplam / PENCERE;
20 Serial.print(yeni); // ham değer / raw value
21 Serial.print(" ");
22 Serial.println(ortalama); // yumuşatılmış değer / smoothed value
23 delay(50);
24}Пример 3: хранение нот мелодии в массиве
Мелодия на самом деле состоит из двух списков: какую ноту играть (частота) и сколько она длится. Эти два вида данных хранятся в двух параллельных массивах одинаковой длины: melody[i] и durations[i] всегда относятся к одной и той же ноте. Подключи плюсовую ножку пассивного зуммера к пину 8, а минусовую — к GND. Код ниже играет первые две строки песни «Twinkle Twinkle Little Star» и разделяет звуки паузой в треть длительности каждой ноты. Чтобы добавить новую песню, достаточно заполнить два массива; цикл воспроизведения не меняется. Если в двух массивах разное число элементов, цикл выйдет за конец более короткого, поэтому одинаковое количество элементов в каждой строке защищает от ошибки. Если длинные мелодии начинают заполнять ОЗУ Uno, массивы можно перенести во флеш-память с помощью PROGMEM. Если разница между активным и пассивным зуммером непонятна, прочитай статью что такое зуммер.
1#define NOTA_DO 262 // Hz
2#define NOTA_RE 294
3#define NOTA_MI 330
4#define NOTA_FA 349
5#define NOTA_SOL 392
6#define NOTA_LA 440
7
8const byte BUZZER_PIN = 8; // pasif buzzer / passive buzzer
9
10// notalar ve süreler aynı sırada / notes and durations in the same order
11const int melodi[] = {NOTA_DO, NOTA_DO, NOTA_SOL, NOTA_SOL, NOTA_LA, NOTA_LA, NOTA_SOL,
12 NOTA_FA, NOTA_FA, NOTA_MI, NOTA_MI, NOTA_RE, NOTA_RE, NOTA_DO};
13const int sureler[] = {400, 400, 400, 400, 400, 400, 800,
14 400, 400, 400, 400, 400, 400, 800};
15const int NOTA_SAYISI = sizeof(melodi) / sizeof(melodi[0]); // 14
16
17void setup() {
18 for (int i = 0; i < NOTA_SAYISI; i++) {
19 tone(BUZZER_PIN, melodi[i], sureler[i]); // notayı çal / play the note
20 delay(sureler[i] + sureler[i] / 3); // nota + kısa boşluk / note + short gap
21 }
22 noTone(BUZZER_PIN);
23}
24
25void loop() {
26}Многомерные массивы: хранение табличных данных
Двумерный массив — это таблица из строк и столбцов. int table[4][3] — массив из 12 элементов: 4 строки и 3 столбца; к элементу обращаются через table[строка][столбец], и оба индекса начинаются с 0. В памяти строки идут одна за другой, поэтому на Uno такая таблица занимает 4 × 3 × 2 = 24 байта. Узоры для светодиодной матрицы 8x8, раскладки матричной клавиатуры и таблицы состояний — типичные применения двумерных массивов. В примере ниже каждое состояние светофора записано в одну строку: первые три столбца хранят, горят ли красный, жёлтый и зелёный светодиоды, а четвёртый — сколько миллисекунд длится это состояние. Светодиоды можно подключить к первым трём пинам из таблицы пинов (D2 — красный, D3 — жёлтый, D4 — зелёный). Число строк мы вычислили через sizeof(states) / sizeof(states[0]); здесь sizeof(states[0]) даёт размер целой строки. Чтобы добавить светофору новое состояние, достаточно дописать строку в таблицу — код внутри loop() остаётся прежним. Такой подход, отделяющий логику программы от данных, пригодится и позже, когда дойдёт дело до конечного автомата.
1const byte trafikPinleri[3] = {2, 3, 4}; // kırmızı, sarı, yeşil / red, yellow, green
2
3// her satır bir durum: {kırmızı, sarı, yeşil, süre ms} / each row: {red, yellow, green, time ms}
4const unsigned int durumlar[4][4] = {
5 {1, 0, 0, 5000}, // kırmızı / red
6 {1, 1, 0, 1500}, // kırmızı + sarı / red + yellow
7 {0, 0, 1, 5000}, // yeşil / green
8 {0, 1, 0, 1500} // sarı / yellow
9};
10const byte DURUM_SAYISI = sizeof(durumlar) / sizeof(durumlar[0]); // 4 satır / 4 rows
11
12void setup() {
13 for (byte i = 0; i < 3; i++) {
14 pinMode(trafikPinleri[i], OUTPUT);
15 }
16}
17
18void loop() {
19 for (byte d = 0; d < DURUM_SAYISI; d++) { // satırları gez / walk the rows
20 for (byte led = 0; led < 3; led++) { // sütunları gez / walk the columns
21 digitalWrite(trafikPinleri[led], durumlar[d][led] ? HIGH : LOW);
22 }
23 delay(durumlar[d][3]); // durumun süresi / duration of the state
24 }
25}Массивы на ESP32 и Raspberry Pi Pico
На ESP32 массивы пишутся тем же синтаксисом C++, что и на Arduino Uno, и примеры выше компилируются без изменений; нужно лишь подобрать номера пинов. В примере со светодиодами достаточно заменить строку массива на {13, 14, 27, 26, 25, 33}; пины 6–11 заняты встроенной флеш-памятью, поэтому не вписывай их в массив. На ESP32 int занимает 4 байта, а программам доступно более 300 КБ ОЗУ; массив измерений из 10 000 элементов, который не поместился бы в Uno, здесь умещается спокойно. Поскольку аналоговые показания ESP32 лежат в диапазоне 0–4095, в примере со скользящим средним числа получаются больше, но логика та же. Если Raspberry Pi Pico используется с MicroPython, вместо массива применяется список: его размер не фиксирован, элементы добавляются через append(), а длина узнаётся через len(). В списке допустимы и отрицательные индексы: leds[-1] возвращает последний элемент. Если класть объекты Pin прямо в список, код становится намного проще:
1from machine import Pin
2import time
3
4led_pinleri = [14, 13, 12, 11, 10, 9] # GP14 -> GP9 sırası / order
5ledler = [Pin(p, Pin.OUT) for p in led_pinleri] # Pin nesnelerinden liste / list of Pin objects
6print("LED sayisi / LED count:", len(ledler))
7
8while True:
9 for led in ledler: # ileri / forward
10 led.on()
11 time.sleep_ms(100)
12 led.off()
13 for i in range(len(ledler) - 2, 0, -1): # geri, uçlar hariç / backward, ends skipped
14 ledler[i].on()
15 time.sleep_ms(100)
16 ledler[i].off()Ошибки переполнения и частые ошибки с массивами
| Ошибка | Признак | Решение |
|---|---|---|
| Условие «меньше или равно» в цикле | На последнем проходе чтение или запись за пределами массива; бессмысленные значения, перезагрузки | Сделай условие i < COUNT |
| Индекс начинается с 1 | Первый элемент пропускается, на последнем проходе переполнение | Индексы идут от 0 до N-1 |
| Результат sizeof(array) принимают за число элементов | Для массива int цикл выполняется вдвое больше раз на Uno и вчетверо больше на ESP32 | Используй sizeof(array) / sizeof(array[0]) |
| sizeof внутри функции | Массив передаётся в функцию как адрес; sizeof возвращает 2 или 4 | Передавай число элементов отдельным параметром |
| Сумма хранится в переменной int | Отрицательное среднее на Uno после превышения 32 767 | Используй long для суммы |
| Массив внутри функции без начальных значений | Случайные начальные значения в локальном массиве | Обнули его так: int a[10] = {0}; |
| Присваивание массива массиву через = | Ошибка компиляции invalid array assignment (недопустимое присваивание массива) | Копируй циклом for или через memcpy |
| Слишком большой массив на Uno | Предупреждение о нехватке памяти, зависания и перезагрузки | Используй byte, а константные таблицы перенеси в PROGMEM |
Идеи проектов с массивами
- Набор световых эффектов: храни узоры в двумерном массиве и проигрывай каждую строку как кадр анимации; управляй эффектами Knight Rider и бегущих огней одним циклом.
- Игра на память «Саймон»: храни случайно сгенерированную последовательность цветов в массиве и сравнивай её с кнопками, которые нажимает игрок; похожие идеи — в статье игровые проекты на Arduino.
- Кодовый замок: храни правильный пароль в массиве char, записывай клавиши, введённые на матричной клавиатуре, во второй массив и сравнивай их поэлементно.
- Анимации на светодиодной матрице: храни узоры 8x8 в массивах byte и показывай их на светодиодной матрице MAX7219.
- Суточный регистратор данных: храни почасовую температуру в массиве из 24 элементов и вычисляй минимум, максимум и среднее за день; в качестве датчика подойдёт DHT11.
- Музыкальная шкатулка: храни несколько песен в отдельных массивах и переключайся между ними кнопкой.
Массивы — базовый строительный блок, который вступает в игру, как только в программе Arduino появляется больше нескольких переменных: списки пинов, история измерений, мелодии и узоры — всё это управляется массивами. Для работы с текстом продолжи статьёй использование String в Arduino, чтобы разобраться в разнице между массивами char и классом String. В приложении BlueGrays можно пошагово пройти проекты «Бегущие огни на светодиодах», «Светодиодный эффект Knight Rider», «Светофор» и «Гимн Турции на зуммере» с готовым кодом на массивах и схемами подключения.
Частые вопросы
Как узнать число элементов массива в Arduino?
Встроенной функции length() для массивов в Arduino нет. Число элементов находят по формуле sizeof(array) / sizeof(array[0]): первое даёт общий размер массива в байтах, второе — размер одного элемента. Формула работает правильно только там, где массив объявлен; для массива, переданного в функцию, она даёт размер указателя.
Индекс массива в Arduino начинается с 0 или с 1?
В языке Arduino, основанном на C и C++, индекс массива всегда начинается с 0. В массиве из 10 элементов первый элемент — array[0], последний — array[9]. Обращение к array[10] не вызывает ошибки компиляции, но портит память за пределами массива.
Можно ли потом изменить размер массива в Arduino?
Нет, размер обычного массива задаётся при компиляции и не может увеличиваться во время работы программы. Практичное решение — объявить массив максимального нужного размера и хранить число заполненных элементов в отдельной переменной-счётчике. Выделить динамическую память через malloc или new можно, но на Uno с 2 КБ ОЗУ это не рекомендуется, потому что память фрагментируется.
Как объявить массив строк в Arduino?
Чтобы хранить несколько текстов, используют массив указателей вида const char* colors[] = {"Red", "Yellow", "Green"}; и получают «Yellow» через colors[1]. Один текст — это массив символов вида char name[] = "Arduino"; с невидимым символом '\0' в конце. Можно писать и массивы объектов String, но на Uno они быстрее расходуют ОЗУ.
Сколько элементов может вместить массив на Arduino Uno?
Предел задаёт ОЗУ: у Uno всего 2048 байт ОЗУ, и часть из них занимают Serial и другие переменные. На практике массив примерно в 1500 байт, то есть 1500 элементов byte или 750 int, уже близок к пределу. Если перенести константные таблицы во флеш через PROGMEM, можно хранить гораздо больше данных; у ESP32 и Pico сотни КБ ОЗУ.
Как скопировать один массив в другой в Arduino?
В C++ нельзя скопировать массив, написав target = source; — компилятор выдаст ошибку. Элементы можно скопировать по одному циклом for или воспользоваться memcpy(target, source, sizeof(source));. Убедись, что оба массива одного типа и размера: если целевой массив меньше, memcpy тоже приведёт к переполнению.
Что собрать после прочтения
Все проекты
Светофор
Крошечная копия светофора, который ты каждый день видишь на дороге. Красный горит две секунды, жёлтый мигает на мгновение, зелёный горит две секунды, затем через жёлтый снова возвращается красный, и…

Бегущие огни на светодиодах
Огни, которые загораются друг за другом, будто бегут. Arduino зажигает шесть светодиодов по одному; каждый светится короткое мгновение и гаснет, так что свет проходит от начала до конца и начинает…

Светодиодный эффект Knight Rider
Классический бегущий огонь-сканер: светящаяся точка скользит от одного края шести светодиодов к другому и возвращается обратно.

Бегущие огни с регулируемой скоростью
Шесть светодиодов загораются друг за другом, и кажется, что свет бежит от одного края к другому.

Светодиодный эффект Knight Rider с регулируемой скоростью
Свет бежит от одного края шести светодиодов к другому, разворачивается и бежит обратно.

Гимн Турции на зуммере
Нажми кнопку, и маленький зуммер начнёт нота за нотой играть Государственный гимн Турции.

Светодиоды Knight Rider на ESP32
6 светодиодов по очереди бегают слева направо и справа налево (в стиле Knight Rider). Базовый пример использования циклов for и массивов. Учит логике смены направления.

Бегущие огни на Pico (6 светодиодов)
Классическая анимация «бегущие огни» на Pico — версия на 6 светодиодов! 6 светодиодов загораются по очереди слева направо — будто свет идёт по ряду. Изучи список Python, генератор списка ([Pin(p, Pin.OUT) for p in LED_PINS]), цикл for с управлением пинами и enumerate(). 6 светодиодов на GP9–GP14, у каждого токоограничивающий резистор 220Ω. Очень чистый код: вместо объявления 6 светодиодов по одному используется список, и можно добавлять светодиоды по числу свободных пинов GPIO.
Другие статьи
Приложение BlueGrays
Собери эту схему шаг за шагом в телефоне
Схема подключения, код и список деталей на одном экране. 500+ проектов на Arduino, ESP32 и Pico готовы к сборке.
Наведи камеру телефона
Наведи камеру на код — откроется магазин приложений на телефоне.
или открыть магазин

