Fundamentos · 12 min de lectura

Arrays en Arduino: definir, recorrer con for y ejemplos

Arrays en Arduino paso a paso: cómo definir un array, índices, recorrerlo con for, arrays 2D, pines de LED, promedio de sensores y melodías con buzzer.

Usar arrays en Arduino es una habilidad básica de programación que te permite reunir muchos valores del mismo tipo bajo un solo nombre y acceder a cada uno por su número (índice). En lugar de escribir los pines de seis LED, las últimas diez lecturas de un sensor o las notas de una canción en variables separadas como led1, led2, led3, los guardas en un único array y los recorres todos con un bucle for en pocas líneas. Así tu código es más corto, tienes menos probabilidad de cometer errores y, para añadir un LED nuevo al circuito, basta con añadir un número a la lista del array.

En esta guía verás cómo se guarda un array en la memoria, cómo se define, por qué el índice empieza en cero y cómo calcular el número de elementos con sizeof. Después haremos tres ejemplos reales: el efecto coche fantástico con LED, un promedio móvil que suaviza datos de sensor con ruido y una melodía con buzzer. Por último, montaremos una tabla de estados de semáforo con arrays bidimensionales, veremos las diferencias en ESP32 y Raspberry Pi Pico y aprenderás a detectar los errores de desbordamiento que rompen el programa sin avisar. Si el tema te resulta totalmente nuevo, antes puedes echar un vistazo a los fundamentos de programación con Arduino.

LED usados en el ejemplo de arrays en Arduino
Gestionar seis LED con un único array de pines, y no uno por uno, es el uso más clásico de los arrays.

¿Qué es un array y cómo funciona?

Un array es un bloque de elementos que están uno junto a otro en la memoria y que son todos del mismo tipo de dato. Piensa en un armario con cajones numerados: el armario tiene un solo nombre y cada cajón tiene un número. En el lenguaje de Arduino, basado en C y C++, esta numeración empieza en 0; los índices de un array de 5 elementos son 0, 1, 2, 3 y 4, es decir, el último índice siempre es el número de elementos menos uno. El compilador conoce la dirección de inicio del array; cuando escribes array[3], suma a esa dirección 3 × el tamaño del elemento y va directamente a esa celda. Por eso acceder a un array es muy rápido, pero por la misma razón el compilador no comprueba si te sales de los límites. La memoria que ocupa un array es el número de elementos multiplicado por el tamaño de un elemento:

Tipo de datoTamaño del elemento (Uno)Tamaño del elemento (ESP32 / Pico, C++)Array de 100 elementos (Uno)
byte / uint8_t1 byte1 byte100 bytes
char1 byte1 byte100 bytes
int2 bytes4 bytes200 bytes
unsigned int2 bytes4 bytes200 bytes
long4 bytes4 bytes400 bytes
float4 bytes4 bytes400 bytes

Si tienes en cuenta que el Arduino Uno solo tiene 2 KB (2048 bytes) de RAM, verás que un array de 1000 enteros int se comería casi toda la memoria él solo. Por eso es buena costumbre usar byte para valores entre 0 y 255 (números de pin, brillo PWM, día u hora), int para resultados de analogRead y long para sumas grandes. Elegir el tipo correcto significa poder meter el doble de datos en la misma memoria.

¿Cómo se define un array en Arduino?

Al definir un array escribes primero el tipo de dato, después el nombre y, entre corchetes, el número de elementos. Puedes dar los valores enseguida entre llaves o dejar el tamaño vacío y dejar que el compilador cuente. El siguiente programa muestra las formas más habituales juntas y escribe los resultados en el Monitor Serie:

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}
DefiniciónSignificado
int a[5];Array de 5 elementos; si es global todos valen 0, y si está dentro de una función los valores iniciales son aleatorios
int a[5] = {1, 2, 3, 4, 5};Se indican el tamaño y todos los valores a la vez
int a[] = {2, 3, 4};El compilador cuenta el tamaño (aquí 3)
float a[10] = {1.5, 2.0};Los elementos sin valor quedan en 0
int a[5] = {0};Forma corta de poner todos los elementos a cero
char s[] = "Arduino";Cadena de texto; al final hay un carácter invisible '\0' (8 bytes en total)
const byte a[] = {2, 3, 4};Array constante que no se puede modificar dentro del programa
El índice empieza en 0. En un array int a[5] de 5 elementos no existe ningún elemento a[5]; el último es a[4]. El compilador casi nunca detecta este error: si escribes en a[5], sobrescribes otra variable que esté justo detrás del array en la memoria. El resultado no es un mensaje de error, sino valores sin sentido, un Arduino que se reinicia solo o una avería misteriosa que tardas horas en encontrar.

Recorrer un array con un bucle for

La verdadera fuerza de los arrays aparece cuando los combinas con un bucle for. La variable del bucle i empieza en 0 y sube hasta el número de elementos menos uno, y en cada vuelta accedes al elemento siguiente con array[i]. En lugar de escribir a mano el número de elementos, lo más seguro es calcularlo con la fórmula sizeof(array) / sizeof(array[0]): sizeof(array) da el total de bytes del array y sizeof(array[0]) el tamaño de un solo elemento. Por ejemplo, en el Uno un array de 7 int ocupa 14 bytes y 14 / 2 = 7. Cuando añades un elemento al array, esta fórmula actualiza la cantidad automáticamente. El siguiente código calcula el promedio de las temperaturas de una semana y encuentra el valor más bajo y el más alto. La suma de las mediciones es 161, el promedio 23,0 grados; el valor mínimo es 19 y el máximo 27. Fíjate en que la condición del bucle es i < ADET: si la cambias por menor o igual, el bucle da una vuelta de más y lee la memoria fuera del array.

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}

Ejemplo 1: gestionar los pines de LED con un array

El uso más clásico de los arrays en Arduino es gestionar varios LED. Para controlar seis LED sin array tendrías que escribir seis pinMode distintos y líneas digitalWrite separadas para cada paso; con un array basta un solo bucle. Conecta la pata larga (ánodo) de cada LED a un pin digital y la pata corta a GND mediante una resistencia de 220 Ω. Si quieres calcular tú mismo el valor de la resistencia, puedes usar la calculadora de resistencia para LED.

LED (índice del array)Arduino UnoESP32Raspberry Pi Pico
LED 1 (ledPinleri[0])D2GPIO 13GP14
LED 2 (ledPinleri[1])D3GPIO 14GP13
LED 3 (ledPinleri[2])D4GPIO 27GP12
LED 4 (ledPinleri[3])D5GPIO 26GP11
LED 5 (ledPinleri[4])D6GPIO 25GP10
LED 6 (ledPinleri[5])D7GPIO 33GP9
Cátodo (pata corta)GND a través de 220 ΩGND a través de 220 ΩGND a través de 220 Ω
  1. Coloca los LED en la protoboard en orden; conecta las patas cortas (cátodo) a la línea de GND a través de resistencias de 220 Ω.
  2. Conecta las patas largas a los pines 2–7 del Arduino en el orden de la tabla.
  3. Escribe los números de pin en el array ledPinleri en el orden físico de los LED; el orden del array determina el sentido en que fluye la luz.
  4. En setup(), configura todos los pines como OUTPUT con un solo bucle for.
  5. En loop(), crea el efecto coche fantástico con dos bucles, uno de ida y otro de vuelta, y sube el código.
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}

El bucle de ida enciende y apaga cada LED durante 100 ms, del 0 al 5. El bucle de vuelta empieza en 4 y se detiene en 1; como no vuelve a encender los LED de los extremos, la luz regresa con fluidez sin detenerse en ellos. En el bucle de vuelta usamos int como contador porque byte no tiene signo y no puede bajar de 0; si usas byte en un bucle que espera que el contador sea menor que 0, después de 0 salta a 255 y el bucle no termina nunca. Para cambiar el orden del efecto solo tienes que cambiar de sitio los números del array, sin tocar el resto del código. Para ver otros efectos escritos con la misma lógica, consulta coche fantástico y LED en secuencia.

Ejemplo 2: promedio de un sensor con un array (promedio móvil)

Los valores leídos de sensores analógicos como un potenciómetro, una LDR o un sensor de humedad del suelo fluctúan continuamente unas pocas unidades. La forma más fácil de reducir ese ruido es hacer el promedio de las últimas N lecturas. Guardas las últimas 10 lecturas en un array y, con cada medición nueva, restas el valor más antiguo de la suma y añades el nuevo. Como al llegar al final del array volvemos a poner el índice en 0, esta estructura se llama búfer circular (ring buffer). Actualizar la suma restando y sumando, en lugar de recalcularla desde cero cada vez, mantiene la operación rápida aunque la ventana crezca a 100 elementos. En las primeras 10 lecturas el array aún no está lleno, así que el promedio sube desde cero y se asienta en el valor real tras aproximadamente medio segundo. Conecta el pin de señal del sensor a A0 (por ejemplo, la pata central del potenciómetro) y observa el resultado como dos líneas en el 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}
En el Uno, un int solo puede guardar como máximo 32 767. La suma de 64 lecturas analógicas que llegan hasta 1023 es 65 472, y una variable int se desborda y pasa a un número negativo. En los cálculos de sumas y promedios usa siempre long. Cuanto más grande es la ventana, más suave es la salida, pero más tarda en reaccionar a los cambios; 10 lecturas con 50 ms de intervalo, es decir, una ventana de medio segundo, es un buen punto de partida para la mayoría de los sensores. Para métodos más avanzados, echa un vistazo a filtrado de datos de sensores.

Ejemplo 3: guardar las notas de una melodía en un array

Una melodía en realidad consta de dos listas: qué nota se toca (frecuencia) y cuánto dura. Guardas esas dos informaciones en dos arrays paralelos de la misma longitud: melodi[i] y sureler[i] siempre pertenecen a la misma nota. Conecta la pata positiva de un buzzer pasivo al pin 8 y la negativa a GND. El siguiente código toca las dos primeras frases de 'Twinkle Twinkle Little Star' y separa los sonidos dejando entre las notas un silencio de un tercio de su duración. Para añadir una canción nueva solo tienes que rellenar los dos arrays; el bucle de reproducción no cambia. Si los dos arrays tienen un número distinto de elementos, el bucle se sale del array más corto, así que escribir la misma cantidad de elementos en cada línea evita el error. Si las melodías largas empiezan a llenar la RAM del Uno, puedes mover los arrays a la memoria flash con PROGMEM. Si no conoces la diferencia entre buzzer activo y pasivo, lee qué es un buzzer.

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}

Arrays multidimensionales: guardar datos como una tabla

Un array bidimensional es una tabla formada por filas y columnas. int tabla[4][3] es un array de 12 elementos con 4 filas y 3 columnas; accedes a un elemento con tabla[fila][columna] y ambos índices empiezan en 0. En la memoria las filas se colocan una detrás de otra, es decir, esta tabla ocupa en el Uno 4 × 3 × 2 = 24 bytes. Los patrones de matrices LED 8x8, los mapas de teclas de un keypad y las tablas de estados son usos típicos de los arrays bidimensionales. En el siguiente ejemplo escribimos cada estado del semáforo en una fila: las tres primeras columnas indican si se enciende el LED rojo, el amarillo y el verde, y la cuarta guarda cuántos milisegundos dura ese estado. Puedes conectar los LED a los tres primeros pines de la tabla de pines (D2 rojo, D3 amarillo, D4 verde). El número de filas lo calculamos con sizeof(durumlar) / sizeof(durumlar[0]); aquí sizeof(durumlar[0]) da el tamaño de una fila entera. Para añadir un estado nuevo al semáforo basta con escribir una fila en la tabla, y el código de loop() queda igual. Este enfoque, que separa la lógica del programa de los datos, también te servirá más adelante al montar una máquina de estados.

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}

Arrays en ESP32 y Raspberry Pi Pico

En el ESP32 los arrays se escriben con la misma sintaxis de C++ que en el Arduino Uno y los ejemplos anteriores compilan sin cambios; solo tienes que adaptar los números de pin. En el ejemplo de los LED basta con poner en el array la línea {13, 14, 27, 26, 25, 33}; no escribas en el array los pines 6–11, porque están reservados para la memoria flash interna. En el ESP32 un int ocupa 4 bytes y hay más de 300 KB de RAM disponibles para tus programas; un array de medición de 10 000 elementos, que no cabe en el Uno, cabe aquí sin problema. Como las lecturas analógicas del ESP32 van de 0 a 4095, en el ejemplo del promedio móvil los números salen más grandes, pero la lógica es la misma. Si usas la Raspberry Pi Pico con MicroPython, en lugar de arrays usas listas: el tamaño no es fijo, puedes añadir elementos con append() y saber la longitud con len(). En las listas también son válidos los índices negativos; ledler[-1] devuelve el último elemento. Meter directamente objetos Pin dentro de la lista simplifica mucho el código:

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()

Errores de desbordamiento y fallos habituales con arrays

ErrorSíntomaSolución
Usar menor o igual en la condición del bucleEn la última vuelta se lee o escribe fuera del array; valores sin sentido, reiniciosPon la condición i < ADET
Empezar el índice en 1Se salta el primer elemento y en la última vuelta hay desbordamientoLos índices van de 0 a N-1
Creer que sizeof(array) es el número de elementosEn un array int el bucle da el doble de vueltas en Uno y el cuádruple en ESP32Usa sizeof(array) / sizeof(array[0])
Usar sizeof dentro de una funciónEl array llega a la función como dirección; sizeof devuelve 2 o 4Envía el número de elementos como un parámetro aparte
Guardar la suma en una variable intEn el Uno, al superar 32 767 sale un promedio negativoUsa long para la suma
No dar valor inicial a un array dentro de una funciónUn array local tiene valores iniciales aleatoriosPonlo a cero con int a[10] = {0};
Asignar un array a otro con =Error de compilación: invalid array assignmentCopia con un bucle for o con memcpy
Definir un array muy grande en el UnoAviso de poca memoria, bloqueos y reiniciosUsa byte y mueve las tablas constantes a PROGMEM
Las tablas que no cambian (notas de melodías, patrones de caracteres, valores de calibración) se copian a la RAM al arrancar en el Uno aunque las declares const. Mueve los arrays constantes grandes a la memoria flash con la palabra clave PROGMEM y léelos con funciones como pgm_read_word(); así usas los 32 KB de flash y proteges los 2 KB de RAM. En ESP32 y Pico los arrays const ya se quedan en la flash. Si sospechas que la memoria se ha llenado, consulta memoria insuficiente en Arduino.

Ideas de proyectos que puedes hacer con arrays

  • Pack de efectos LED: guarda los patrones en un array bidimensional y reproduce cada fila como un fotograma de animación; gestiona los efectos de coche fantástico y LED en secuencia con un solo bucle.
  • Juego de memoria Simon: guarda en un array la secuencia de colores generada al azar y compárala con los botones que pulsa el jugador; para ideas parecidas, mira proyectos de juegos con Arduino.
  • Cerradura con contraseña: guarda la contraseña correcta en un array char, escribe las teclas introducidas con un keypad en un segundo array y compáralos elemento a elemento.
  • Animaciones en matriz LED: guarda patrones de 8x8 en arrays de bytes y muéstralos en una matriz LED MAX7219.
  • Registrador de datos diario: guarda las temperaturas de cada hora en un array de 24 elementos y calcula el valor mínimo, máximo y promedio del día; como sensor puedes usar un DHT11.
  • Caja de melodías: guarda varias canciones en arrays separados y cambia entre ellas con un botón.

Los arrays son el ladrillo básico que entra en juego en cuanto trabajas con más de unas pocas variables en la programación de Arduino: las listas de pines, el historial de mediciones, las melodías y los patrones se gestionan con arrays. Para aprender la diferencia entre los arrays char y la clase String al trabajar con texto, puedes seguir con el artículo uso de String en Arduino. En la aplicación BlueGrays puedes explorar paso a paso los proyectos de LED en secuencia, coche fantástico, semáforo y buzzer con himno, con código listo escrito con arrays y esquemas de circuito.

Preguntas frecuentes

¿Cómo se obtiene el número de elementos de un array en Arduino?

En Arduino los arrays no tienen una función length() ya hecha. El número de elementos se obtiene con la fórmula sizeof(array) / sizeof(array[0]): la primera parte da el total de bytes del array y la segunda el tamaño de un solo elemento. Esta fórmula solo funciona bien donde se define el array; en un array enviado a una función da el tamaño del puntero.

¿El índice de un array en Arduino empieza en 0 o en 1?

En el lenguaje de Arduino, basado en C y C++, el índice de un array siempre empieza en 0. En un array de 10 elementos, el primero es array[0] y el último array[9]. Acceder a array[10] no da error de compilación, pero corrompe la memoria que hay fuera del array.

¿Se puede cambiar el tamaño de un array en Arduino después de definirlo?

No, el tamaño de un array normal se fija en la compilación y no se puede ampliar mientras el programa se ejecuta. La solución práctica es definir un array del tamaño máximo que puedas necesitar y llevar en una variable contador aparte cuántos elementos están ocupados. Reservar memoria dinámica con malloc o new es posible, pero no se recomienda en el Uno con 2 KB de RAM porque provoca fragmentación de la memoria.

¿Cómo se define un array de textos (strings) en Arduino?

Para guardar varios textos se usa un array de punteros como const char* colores[] = {"Rojo", "Amarillo", "Verde"}; y con colores[1] accedes al texto "Amarillo". Un único texto es un array de caracteres como char nombre[] = "Arduino"; y al final lleva un carácter invisible '\0'. También se pueden escribir arrays de objetos String, pero en el Uno consumen la RAM más rápido.

¿Cuántos elementos puede tener como máximo un array en el Arduino Uno?

El límite lo marca la RAM: el Uno tiene 2048 bytes de RAM en total y parte de ella la usan Serial y las demás variables. En la práctica, un array de unos 1500 bytes, es decir, 1500 byte o 750 int, está cerca del límite. Si mueves las tablas constantes a la memoria flash con PROGMEM, puedes guardar muchos más datos; en ESP32 y Pico hay cientos de KB de RAM.

¿Cómo se copia un array a otro en Arduino?

En C++ no se puede copiar un array escribiendo destino = origen; el compilador da error. Puedes copiar los elementos uno por uno con un bucle for o usar la instrucción memcpy(destino, origen, sizeof(origen));. Asegúrate de que los dos arrays sean del mismo tipo y tamaño; si el destino es más pequeño, memcpy también provoca un desbordamiento.

Ver todos los proyectos
Semáforo
AR-3Principiante

Semáforo

Una copia en miniatura del semáforo que ves cada día en la calle. El rojo se queda dos segundos, el amarillo brilla un instante, el verde se queda dos segundos y luego vuelve al rojo pasando otra vez…

4.8(137)
440
Luz secuencial LED
AR-5Intermedio

Luz secuencial LED

Luces que se encienden una tras otra, como si corrieran. El Arduino enciende seis LED de uno en uno; cada uno brilla un instante y se apaga, así que la luz recorre la fila de principio a fin y vuelve…

4.6(87)
218
Efecto coche fantástico con LED
AR-6Intermedio

Efecto coche fantástico con LED

La clásica luz que va y viene: un punto de luz recorre seis LED de un extremo al otro y luego regresa.

4.8(107)
214
Luz secuencial LED con velocidad regulable
AR-7Intermedio

Luz secuencial LED con velocidad regulable

Seis LED se encienden uno tras otro y la luz parece correr de un extremo al otro.

4.6(72)
148
Efecto coche fantástico con velocidad regulable
AR-8Intermedio

Efecto coche fantástico con velocidad regulable

Una luz recorre seis LED de un extremo a otro, da la vuelta y vuelve a correr. Girando el mando del potenciómetro cambias al instante la velocidad de esa carrera: con el mando a un lado la luz casi…

4.5(60)
124
Himno nacional turco con zumbador
AR-15Intermedio

Himno nacional turco con zumbador

Pulsas el botón y un pequeño zumbador empieza a tocar el himno nacional de Turquía, nota a nota.

4.8(114)
235
LED Secuencial ESP32 (Knight Rider)
ES-6Principiante

LED Secuencial ESP32 (Knight Rider)

6 LEDs moviéndose secuencialmente de izquierda a derecha y de derecha a izquierda (estilo Knight Rider). Ejemplo básico del uso del bucle for y arrays. Enseña la lógica del cambio de dirección.

4.5(19)
33
Raspberry Pi Pico LED Secuencial (6 LEDs)
PI-7Principiante

Raspberry Pi Pico LED Secuencial (6 LEDs)

¡La clásica animación de "LED que camina" con la Pico, en versión de 6 LED! Seis LED se encienden uno tras otro de izquierda a derecha, como si la luz recorriera la fila. Aprenderás listas de Python (LED_PINS = [14, 13, 12, 11, 10, 9]), list comprehension, el control de pines con un bucle for y enumerate(). Seis LED van en los pines GP9-GP14, cada uno con una resistencia limitadora de 220Ω.

5.0(1)
9