Основы · 9 мин чтения

Массивы в Arduino: объявление, цикл for и практические примеры

Массивы в Arduino шаг за шагом: объявление, индексы, обход циклом for, двумерные массивы, пины светодиодов, усреднение показаний датчика (скользящее среднее) и мелодии.

Массивы в Arduino — базовый навык программирования: они позволяют собрать много значений одного типа под одним именем и обращаться к каждому по номеру (индексу). Вместо того чтобы записывать номера пинов шести светодиодов, последние десять показаний датчика или ноты песни в отдельные переменные вроде led1, led2, led3, ты хранишь их в одном массиве и обрабатываешь все сразу в несколько строк с помощью цикла for. Код становится короче, ошибок меньше, а чтобы добавить в схему ещё один светодиод, достаточно дописать одно число в список.

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

Светодиоды, используемые в примере с массивом Arduino
Управлять шестью светодиодами не по одному, а через один массив пинов — классический пример использования массивов.

Что такое массив и как он работает?

Массив — это блок элементов одного типа данных, которые лежат в памяти друг за другом. Представь шкаф с пронумерованными ящиками: у шкафа одно имя, а у каждого ящика свой номер. В языке Arduino, основанном на C и C++, нумерация начинается с 0: у массива из 5 элементов индексы 0, 1, 2, 3 и 4, то есть последний индекс всегда на единицу меньше числа элементов. Компилятор знает начальный адрес массива; когда ты пишешь array[3], он прибавляет к начальному адресу 3 × размер элемента и сразу переходит к нужной ячейке. Поэтому доступ к массиву очень быстрый, но по той же причине компилятор не проверяет, не вышел ли ты за его границы. Объём памяти, который занимает массив, равен числу элементов, умноженному на размер одного элемента:

Тип данныхРазмер элемента (Uno)Размер элемента (ESP32 / Pico, C++)Массив из 100 элементов (Uno)
byte / uint8_t1 байт1 байт100 байт
char1 байт1 байт100 байт
int2 байта4 байта200 байт
unsigned int2 байта4 байта200 байт
long4 байта4 байта400 байт
float4 байта4 байта400 байт

Если учесть, что у Arduino Uno всего 2 КБ (2048 байт) ОЗУ, массив int из 1000 элементов в одиночку съест почти всю память. Поэтому полезная привычка — использовать byte для значений от 0 до 255 (номера пинов, яркость ШИМ, день или час), int для результатов analogRead и long для больших сумм. Правильно выбранный тип — это вдвое больше данных в том же объёме памяти.

Как объявить массив в Arduino?

При объявлении массива сначала пишется тип данных, затем имя массива, а в квадратных скобках — число элементов. Значения можно сразу задать в фигурных скобках или оставить размер пустым и доверить подсчёт компилятору. Программа ниже показывает самые частые формы вместе и выводит результаты в монитор порта:

C++ (Arduino IDE)
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}; (константа)Константный массив, который нельзя изменить в программе
Индекс начинается с 0. В массиве int a[5] из 5 элементов нет элемента a[5]; последний элемент — a[4]. Компилятор обычно эту ошибку не ловит: при записи в a[5] ты затираешь другую переменную, которая лежит в памяти сразу за массивом. Результат — не сообщение об ошибке, а бессмысленные значения, Arduino, которая сама перезагружается, или загадочная неисправность, которую ищешь часами.

Обход массива циклом 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 (количество): если сделать его «меньше или равно», цикл выполнится на один раз больше и прочитает память за пределами массива.

C++ (Arduino IDE)
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 UnoESP32Raspberry Pi Pico
Светодиод 1 (ledPins[0])D2GPIO 13GP14
Светодиод 2 (ledPins[1])D3GPIO 14GP13
Светодиод 3 (ledPins[2])D4GPIO 27GP12
Светодиод 4 (ledPins[3])D5GPIO 26GP11
Светодиод 5 (ledPins[4])D6GPIO 25GP10
Светодиод 6 (ledPins[5])D7GPIO 33GP9
Катод (короткая ножка)GND через 220 ΩGND через 220 ΩGND через 220 Ω
  1. Установи светодиоды на макетную плату по порядку; короткие ножки (катоды) подключи к шине GND через резисторы 220 Ω.
  2. Длинные ножки подключи к пинам 2–7 Arduino в порядке, указанном в таблице.
  3. Запиши номера пинов в массив ledPins в том порядке, в каком светодиоды стоят физически; порядок в массиве задаёт направление бега огня.
  4. В setup() одним циклом for переведи все пины в режим OUTPUT.
  5. В loop() создай эффект Knight Rider двумя циклами — сначала вперёд, потом назад — и загрузи код в плату.
C++ (Arduino IDE)
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):

C++ (Arduino IDE)
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}
На Uno переменная int вмещает максимум 32 767. Сумма 64 аналоговых показаний до 1023 составляет 65 472, и переменная int переполнится и превратится в отрицательное число. В расчётах суммы и среднего всегда используй long. Чем больше окно, тем глаже выход, но тем медленнее он реагирует на изменения; 10 показаний с интервалом 50 мс, то есть окно в полсекунды, — хорошая отправная точка для большинства датчиков. Более продвинутые методы — в статье фильтрация данных датчиков.

Пример 3: хранение нот мелодии в массиве

Мелодия на самом деле состоит из двух списков: какую ноту играть (частота) и сколько она длится. Эти два вида данных хранятся в двух параллельных массивах одинаковой длины: melody[i] и durations[i] всегда относятся к одной и той же ноте. Подключи плюсовую ножку пассивного зуммера к пину 8, а минусовую — к GND. Код ниже играет первые две строки песни «Twinkle Twinkle Little Star» и разделяет звуки паузой в треть длительности каждой ноты. Чтобы добавить новую песню, достаточно заполнить два массива; цикл воспроизведения не меняется. Если в двух массивах разное число элементов, цикл выйдет за конец более короткого, поэтому одинаковое количество элементов в каждой строке защищает от ошибки. Если длинные мелодии начинают заполнять ОЗУ Uno, массивы можно перенести во флеш-память с помощью PROGMEM. Если разница между активным и пассивным зуммером непонятна, прочитай статью что такое зуммер.

C++ (Arduino IDE)
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() остаётся прежним. Такой подход, отделяющий логику программы от данных, пригодится и позже, когда дойдёт дело до конечного автомата.

C++ (Arduino IDE)
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 прямо в список, код становится намного проще:

MicroPython
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
Неизменяемые таблицы (ноты мелодий, узоры символов, калибровочные значения) на Uno при запуске копируются в ОЗУ, даже если написать const. Перенеси большие константные массивы во флеш-память с помощью ключевого слова PROGMEM и читай их функциями вроде pgm_read_word(); так используются 32 КБ флеша, а 2 КБ ОЗУ остаются свободными. На ESP32 и Pico константные массивы и так остаются во флеше. Если есть подозрение, что память заканчивается, загляни в статью Arduino: не хватает памяти.

Идеи проектов с массивами

  • Набор световых эффектов: храни узоры в двумерном массиве и проигрывай каждую строку как кадр анимации; управляй эффектами 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 тоже приведёт к переполнению.

Все проекты
Светофор
AR-3Новичок

Светофор

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

4.8(136)
439
Бегущие огни на светодиодах
AR-5Средний

Бегущие огни на светодиодах

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

4.6(87)
217
Светодиодный эффект Knight Rider
AR-6Средний

Светодиодный эффект Knight Rider

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

4.8(107)
213
Бегущие огни с регулируемой скоростью
AR-7Средний

Бегущие огни с регулируемой скоростью

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

4.6(72)
148
Светодиодный эффект Knight Rider с регулируемой скоростью
AR-8Средний

Светодиодный эффект Knight Rider с регулируемой скоростью

Свет бежит от одного края шести светодиодов к другому, разворачивается и бежит обратно.

4.5(60)
124
Гимн Турции на зуммере
AR-15Средний

Гимн Турции на зуммере

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

4.8(114)
234
Светодиоды Knight Rider на ESP32
ES-6Новичок

Светодиоды Knight Rider на ESP32

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

4.5(19)
33
Бегущие огни на Pico (6 светодиодов)
PI-7Новичок

Бегущие огни на Pico (6 светодиодов)

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

5.0(1)
9