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.

¿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 dato | Tamaño del elemento (Uno) | Tamaño del elemento (ESP32 / Pico, C++) | Array de 100 elementos (Uno) |
|---|---|---|---|
| byte / uint8_t | 1 byte | 1 byte | 100 bytes |
| char | 1 byte | 1 byte | 100 bytes |
| int | 2 bytes | 4 bytes | 200 bytes |
| unsigned int | 2 bytes | 4 bytes | 200 bytes |
| long | 4 bytes | 4 bytes | 400 bytes |
| float | 4 bytes | 4 bytes | 400 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:
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ón | Significado |
|---|---|
| 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 |
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.
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 Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| LED 1 (ledPinleri[0]) | D2 | GPIO 13 | GP14 |
| LED 2 (ledPinleri[1]) | D3 | GPIO 14 | GP13 |
| LED 3 (ledPinleri[2]) | D4 | GPIO 27 | GP12 |
| LED 4 (ledPinleri[3]) | D5 | GPIO 26 | GP11 |
| LED 5 (ledPinleri[4]) | D6 | GPIO 25 | GP10 |
| LED 6 (ledPinleri[5]) | D7 | GPIO 33 | GP9 |
| Cátodo (pata corta) | GND a través de 220 Ω | GND a través de 220 Ω | GND a través de 220 Ω |
- 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 Ω.
- Conecta las patas largas a los pines 2–7 del Arduino en el orden de la tabla.
- 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.
- En setup(), configura todos los pines como OUTPUT con un solo bucle for.
- En loop(), crea el efecto coche fantástico con dos bucles, uno de ida y otro de vuelta, y sube el código.
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:
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}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.
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.
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:
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
| Error | Síntoma | Solución |
|---|---|---|
| Usar menor o igual en la condición del bucle | En la última vuelta se lee o escribe fuera del array; valores sin sentido, reinicios | Pon la condición i < ADET |
| Empezar el índice en 1 | Se salta el primer elemento y en la última vuelta hay desbordamiento | Los índices van de 0 a N-1 |
| Creer que sizeof(array) es el número de elementos | En un array int el bucle da el doble de vueltas en Uno y el cuádruple en ESP32 | Usa sizeof(array) / sizeof(array[0]) |
| Usar sizeof dentro de una función | El array llega a la función como dirección; sizeof devuelve 2 o 4 | Envía el número de elementos como un parámetro aparte |
| Guardar la suma en una variable int | En el Uno, al superar 32 767 sale un promedio negativo | Usa long para la suma |
| No dar valor inicial a un array dentro de una función | Un array local tiene valores iniciales aleatorios | Ponlo a cero con int a[10] = {0}; |
| Asignar un array a otro con = | Error de compilación: invalid array assignment | Copia con un bucle for o con memcpy |
| Definir un array muy grande en el Uno | Aviso de poca memoria, bloqueos y reinicios | Usa byte y mueve las tablas constantes a PROGMEM |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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…

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…

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.

Luz secuencial LED con velocidad regulable
Seis LED se encienden uno tras otro y la luz parece correr de un extremo al otro.

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…

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.

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.

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Ω.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

