Guías · 14 min de lectura

Proyectos Arduino para vacaciones de invierno: plan de 14 días

Proyectos Arduino para vacaciones de invierno: plan de 14 días con un proyecto diario, tres rutas (Uno, ESP32, Pico), lista de materiales y proyecto final.

La mejor forma de aprovechar unas vacaciones de invierno con proyectos Arduino no es probar cosas al azar, sino dedicar dos semanas a pequeños proyectos que se apoyan uno en otro. En esta guía encontrarás un plan listo para avanzar en 14 días, con un kit de iniciación y 1–2 horas diarias: desde encender un LED hasta leer sensores, escribir en una pantalla y mover un motor. Cada día incluye el proyecto, el material necesario y el enlace al artículo que explica el tema a fondo; al terminar tendrás un proyecto final que reúne todo lo aprendido.

El plan se adapta a tres rutas: Arduino Uno si no tienes experiencia, ESP32 si ya sabes lo básico y quieres conectar tu proyecto a internet, y Raspberry Pi Pico si quieres aprender Python. Los temas de cada día son los mismos en las tres; solo cambian la placa, los números de pin y el lenguaje. Si todavía no tienes placa, haz los primeros días en el simulador Wokwi o Tinkercad y pasa al circuito real cuando te llegue el material.

Antes de empezar: ¿qué material necesitas?

Casi todo lo de la lista siguiente viene en los kits de iniciación estándar. Si a tu kit le falta alguna pieza, solo tienes que cambiar el orden de los días; por ejemplo, si no tienes servo, puedes sustituir el día 13 por un proyecto de melodía con zumbador. Si dudas sobre qué kit elegir, el artículo kit de iniciación Arduino compara su contenido al detalle.

MaterialCantidadDías en que se usa
Arduino Uno, ESP32 o Raspberry Pi Pico + cable USB1Todos los días
Protoboard y cables jumper macho-macho1 + 30Todos los días
LED (rojo, amarillo, verde)6–81, 2, 3, 6, 7, 9, 11
Resistencia de 220 Ω81, 2, 3, 6, 7, 11
Resistencia de 10 kΩ27
Resistencia de 1 kΩ (divisor de tensión para ESP32 y Pico)310, 11
Pulsador24, 7, 9
Potenciómetro de 10 kΩ15, 13
LED RGB16
LDR17
Zumbador pasivo18, 11
Sensor de distancia HC-SR04110, 11
Sensor de temperatura y humedad DHT11112
Pantalla LCD 16x2 I2C112, 14
Servomotor SG90113, 14
Dedica la primera tarde de las vacaciones a la instalación: sigue la guía de instalación del Arduino IDE, conecta tu placa y carga el ejemplo Archivo > Ejemplos > 01.Basics > Blink. Si el LED de la placa parpadea cada segundo, la placa, el cable y el controlador funcionan bien, y el día 1 podrás empezar directamente a montar circuitos.

¿Qué ruta elegir: Uno, ESP32 o Pico?

Las tres placas pueden hacer todo el plan, pero cada una ofrece una experiencia de aprendizaje distinta. El Uno funciona a 5 V, así que se conecta directamente a todos los módulos del kit y la mayoría de los ejemplos de internet están escritos para él; si es tu primer contacto con la electrónica, es el camino donde es más fácil depurar errores. El ESP32 se programa con el mismo lenguaje Arduino, pero su procesador de doble núcleo a 240 MHz, el Wi-Fi y el Bluetooth permiten ver tu proyecto final desde el móvil; a cambio, debes recordar que sus pines son de 3,3 V. La Pico te deja programar en MicroPython y ver el resultado en cuanto guardas el código; si ya ves Python en clase, llevas ese conocimiento directamente al hardware. Si dudas, echa un vistazo a la comparación Arduino o ESP32.

Ruta¿Para quién?Lenguaje y editorPunto fuerteTen en cuenta
Arduino UnoQuien empieza en la electrónicaC++ de Arduino, Arduino IDEPines de 5 V, compatible con todos los módulos del kit, más código de ejemploSin Wi-Fi, solo 2 KB de RAM
ESP32Quien conoce lo básico y quiere conectarse a internetC++ de Arduino, Arduino IDE (paquete de placas ESP32)Wi-Fi y Bluetooth, doble núcleo a 240 MHz, ADC de 12 bitsPines de 3,3 V; con sensores de señal de 5 V hace falta un divisor de tensión
Raspberry Pi PicoQuien quiere aprender PythonMicroPython, ThonnyEjecución inmediata sin compilar, doble núcleo a 133 MHz, precio bajoPines de 3,3 V; la Pico clásica no tiene conexión inalámbrica (la Pico W sí)

Rutina diaria: la regla de 1–2 horas

  • Primeros 15 minutos de lectura: lee el artículo del día y dibuja en papel el esquema del circuito y la tabla de pines.
  • 30–45 minutos de montaje y código: monta el circuito con el cable USB desconectado, revisa las conexiones una vez más y después carga el código.
  • 20 minutos de modificación: cuando el código funcione, cambia al menos una cosa tú mismo: el tiempo, el pin, el valor umbral o el número de LED. Aquí es donde de verdad aprendes.
  • 10 minutos de notas: apunta en un cuaderno qué hiciste, dónde te atascaste y cómo lo resolviste; esas notas te ahorrarán mucho tiempo en el proyecto final.
  • Días flexibles: si te pones enfermo o un proyecto se alarga, puedes usar los días 7 y 14 para ponerte al día.

Semana 1: lo básico (días 1–7)

El objetivo de la primera semana es aprender con las manos cuatro conceptos básicos: salida digital, entrada digital, lectura analógica y PWM. Cada día se añade más o menos un comando nuevo y una pieza nueva; al final del día 7 manejarás con soltura pinMode, digitalWrite, digitalRead, analogRead, analogWrite y Serial.println.

  1. Día 1 – Encender un LED: ejecuta Blink con el LED integrado de la placa, luego conecta un LED externo con una resistencia de 220 Ω al pin D13 en la protoboard y cambia el tiempo de parpadeo. Material: placa, protoboard, 1 LED, 1 resistencia de 220 Ω. Lee: Cómo usar una protoboard, Calcular la resistencia de un LED.
  2. Día 2 – Semáforo: conecta los LED rojo, amarillo y verde a D10, D9 y D8 e imita con delay la secuencia de luces de un cruce real. Material: 3 LED, 3 resistencias de 220 Ω. Lee: Semáforo con Arduino.
  3. Día 3 – LED en secuencia y coche fantástico: aprende a usar un bucle for y un array de pines mientras enciendes 6 LED uno tras otro. Material: 6 LED, 6 resistencias de 220 Ω. Lee: Coche fantástico y LED en secuencia, Arrays en Arduino.
  4. Día 4 – LED con pulsador: haz primero un LED que se enciende mientras mantienes pulsado y luego otro que cambia de estado (toggle) en cada pulsación; aquí aprenderás INPUT_PULLUP y el antirrebote. Material: 1 pulsador, 1 LED, 1 resistencia de 220 Ω. Lee: Cómo conectar un pulsador a Arduino, Resistencias pull-up y pull-down.
  5. Día 5 – Potenciómetro y Monitor Serie: lee valores de 0 a 1023 con analogRead, obsérvalos en el Monitor Serie y conviértelos con map en la velocidad de parpadeo de un LED. Material: potenciómetro de 10 kΩ, 1 LED. Lee: Qué es un potenciómetro, Uso del Monitor Serie, La función map.
  6. Día 6 – PWM y LED RGB: con analogWrite enciende y apaga un LED poco a poco (efecto respiración) y luego mezcla los tres canales de un LED RGB para crear tu propio color. Material: 1 LED RGB, 3 resistencias de 220 Ω. Lee: Qué es el PWM, Uso del LED RGB.
  7. Día 7 – Luz nocturna con LDR y repaso semanal: conecta el LDR con una resistencia de 10 kΩ como divisor de tensión y enciende el LED cuando oscurezca. En la segunda mitad del día monta el semáforo con pulsador para peatones que aparece más abajo. Material: LDR, resistencia de 10 kΩ, 3 LED, pulsador. Lee: Sensor de luz LDR, Divisor de tensión.

El proyecto de cierre de la semana 1 combina lo que aprendiste en los días 2, 4 y 5 en un solo circuito: un semáforo con luz verde permanente para los coches que, al pulsar el botón de peatones, pasa a amarillo, luego a rojo y, tras cinco segundos, vuelve a verde. El pulsador se conecta entre D2 y GND; gracias a la resistencia pull-up interna no hace falta ninguna resistencia externa, y al pulsar el pin se lee como LOW.

C++ (Arduino IDE)
1// Yaya butonlu trafik lambası / Pedestrian button traffic light
2const int RED_PIN = 10;      // kırmızı LED / red LED
3const int YELLOW_PIN = 9;    // sarı LED / yellow LED
4const int GREEN_PIN = 8;     // yeşil LED / green LED
5const int BUTTON_PIN = 2;    // buton, diğer ucu GND / button, other leg to GND
6
7void setup() {
8  pinMode(RED_PIN, OUTPUT);
9  pinMode(YELLOW_PIN, OUTPUT);
10  pinMode(GREEN_PIN, OUTPUT);
11  pinMode(BUTTON_PIN, INPUT_PULLUP);   // basılınca LOW okunur / reads LOW when pressed
12  digitalWrite(GREEN_PIN, HIGH);       // araçlara yeşil / green for cars
13  Serial.begin(9600);
14}
15
16void loop() {
17  if (digitalRead(BUTTON_PIN) == LOW) {
18    Serial.println("Yaya istegi / Pedestrian request");
19    delay(1000);
20    digitalWrite(GREEN_PIN, LOW);
21    digitalWrite(YELLOW_PIN, HIGH);    // sarı: yavaşla / yellow: slow down
22    delay(2000);
23    digitalWrite(YELLOW_PIN, LOW);
24    digitalWrite(RED_PIN, HIGH);       // araçlar durur, yaya geçer / cars stop, pedestrians cross
25    delay(5000);
26    digitalWrite(YELLOW_PIN, HIGH);    // kırmızı + sarı: hazırlan / red + yellow: get ready
27    delay(1500);
28    digitalWrite(RED_PIN, LOW);
29    digitalWrite(YELLOW_PIN, LOW);
30    digitalWrite(GREEN_PIN, HIGH);
31    delay(3000);                       // art arda basmayı engelle / ignore repeated presses
32  }
33}

El último delay(3000) del código evita que el semáforo vuelva enseguida a rojo si un peatón pulsa el botón varias veces seguidas; los semáforos reales también usan un tiempo de espera parecido. Como cambio propio, prueba a ajustar el tiempo de rojo con un potenciómetro o a hacer que el zumbador emita pitidos cortos mientras está en rojo. El punto débil de este código es que, mientras dura el delay, la placa no puede hacer nada más; ese problema lo resolverás con millis el día 9.

Conectar un LED sin resistencia sobrecarga tanto el LED como el pin del Arduino. Para un LED rojo alimentado a 5 V con una caída de tensión de unos 2 V, la resistencia necesaria con 15 mA es (5 − 2) / 0,015 = 200 Ω; por eso el valor estándar más cercano, 220 Ω, es la resistencia más usada. Para otros colores puedes usar la herramienta calculadora de resistencia para LED.

Semana 2: sonido, temporización, sensores y pantalla (días 8–14)

En la segunda semana la placa empieza a medir el mundo exterior y a mostrar los resultados. Estos días instalarás tu primera librería, medirás tiempos con precisión de microsegundos y escribirás texto en una pantalla. Como los proyectos son algo más largos, no dudes en repartir un día en dos si hace falta; el plan no es una carrera, sino un método para crear un hábito.

  1. Día 8 – Zumbador y melodía: toca notas con el comando tone(pin, frecuencia, duración); 262 Hz es do, 294 Hz re y 330 Hz mi. El zumbador activo emite un único sonido fijo; para melodías necesitas uno pasivo. Material: zumbador pasivo. Lee: Qué es un zumbador.
  2. Día 9 – millis en lugar de delay: consigue que un LED parpadee cada segundo mientras lees el pulsador a la vez. Esta es la base del proyecto final; cualquier proyecto que haga varias cosas al mismo tiempo usa millis o una máquina de estados. Material: 2 LED, pulsador. Lee: Diferencia entre millis y delay, Máquina de estados en Arduino.
  3. Día 10 – Medir distancia con el HC-SR04: mide el tiempo que tarda la onda de sonido en ir y volver; como el sonido viaja por el aire a unos 343 m/s, dividir el tiempo en microsegundos entre 58 da la distancia en centímetros. Material: HC-SR04. Lee: Sensor de distancia HC-SR04.
  4. Día 11 – Sensor de aparcamiento: une los días 8 y 10: cuanto más se acerque el obstáculo, más corto es el intervalo entre pitidos del zumbador y el LED parpadea con cada pitido. Material: HC-SR04, zumbador pasivo, LED, resistencia de 220 Ω. Lee: Sistema de aparcamiento con Arduino.
  5. Día 12 – DHT11 y LCD I2C: instala tu primera librería y escribe la temperatura y la humedad en una pantalla LCD 16x2. Gracias al I2C, la pantalla se conecta con solo 4 cables; la dirección de la mayoría de los módulos es 0x27 o 0x3F. Material: DHT11, LCD 16x2 I2C. Lee: Cómo añadir librerías en Arduino, Sensor DHT11, Pantalla LCD I2C.
  6. Día 13 – Servomotor y plan final: con la librería Servo gira el SG90 de 0 a 180 grados y controla el ángulo con el potenciómetro. En la segunda mitad del día elige tu proyecto final y plásmalo en papel siguiendo los pasos de más abajo. Material: servo SG90, potenciómetro. Lee: Qué es un servomotor, Problema de vibración del servo.
  7. Día 14 – Proyecto final y presentación: une los códigos de los días anteriores, coloca el circuito en una caja o una maqueta de cartón, graba un vídeo corto y presenta tu proyecto a tu familia o a tu clase. Material: lista de piezas del proyecto final. Lee: Presentación de proyectos en una feria de ciencias.

El código siguiente es el sensor de aparcamiento del día 11 y reutiliza dentro de una función el método de medición de distancia que aprendiste el día 10. El timeout de 30 000 microsegundos de pulseIn corresponde a unos 5 metros; si el sensor no recibe eco, el código devuelve -1 en lugar de esperar para siempre. La función map convierte el rango de 0–50 cm en una pausa de 50–500 ms, de modo que los pitidos se aceleran a medida que se acerca el obstáculo.

C++ (Arduino IDE)
1// Park sensörü: HC-SR04 + buzzer + LED / Parking sensor: HC-SR04 + buzzer + LED
2const int TRIG_PIN = 7;
3const int ECHO_PIN = 6;
4const int BUZZER_PIN = 5;    // pasif buzzer / passive buzzer
5const int LED_PIN = 4;       // 220 ohm dirençle / with a 220 ohm resistor
6
7long readDistanceCm() {
8  digitalWrite(TRIG_PIN, LOW);
9  delayMicroseconds(2);
10  digitalWrite(TRIG_PIN, HIGH);     // 10 mikrosaniye tetik darbesi / 10 microsecond trigger pulse
11  delayMicroseconds(10);
12  digitalWrite(TRIG_PIN, LOW);
13  unsigned long duration = pulseIn(ECHO_PIN, HIGH, 30000UL);  // 30 ms zaman aşımı / 30 ms timeout
14  if (duration == 0) return -1;     // yankı yok / no echo
15  return duration / 58;             // mikrosaniye -> cm / microseconds -> cm
16}
17
18void setup() {
19  pinMode(TRIG_PIN, OUTPUT);
20  pinMode(ECHO_PIN, INPUT);
21  pinMode(BUZZER_PIN, OUTPUT);
22  pinMode(LED_PIN, OUTPUT);
23  Serial.begin(9600);
24}
25
26void loop() {
27  long cm = readDistanceCm();
28  Serial.print("Mesafe / Distance: ");
29  Serial.print(cm);
30  Serial.println(" cm");
31
32  if (cm > 0 && cm < 50) {
33    int pause = map(cm, 0, 50, 50, 500);   // yaklaştıkça kısalır / shorter when closer
34    tone(BUZZER_PIN, 2000, 50);            // 2 kHz, 50 ms bip / 2 kHz, 50 ms beep
35    digitalWrite(LED_PIN, HIGH);
36    delay(50);
37    digitalWrite(LED_PIN, LOW);
38    delay(pause);
39  } else {
40    noTone(BUZZER_PIN);
41    digitalWrite(LED_PIN, LOW);
42    delay(200);
43  }
44}
ConexiónArduino UnoESP32Raspberry Pi Pico
HC-SR04 VCC5VVIN / 5VVBUS (5 V)
HC-SR04 GNDGNDGNDGND
HC-SR04 TRIGD7GPIO 5GP14
HC-SR04 ECHOD6GPIO 18 (con divisor de tensión)GP15 (con divisor de tensión)
Zumbador (+)D5GPIO 19GP13
LED (con 220 Ω)D4GPIO 23GP12
El HC-SR04 se alimenta a 5 V y envía una señal de 5 V por el pin ECHO. Los pines del ESP32 y de la Pico son de 3,3 V; conectar la línea ECHO directamente puede dañar el pin con el tiempo. Pon en medio un divisor de tensión con resistencias de 1 kΩ y 2 kΩ: 5 × 2 / (1 + 2) ≈ 3,3 V. Si no tienes la de 2 kΩ, puedes poner dos de 1 kΩ en serie. Comprueba los valores con la calculadora de divisor de tensión.

Ruta ESP32: el mismo plan, con Wi-Fi añadido

Si avanzas con el ESP32, harás los días 1–13 con casi los mismos códigos; solo cambias los números de pin. Hay dos diferencias que debes tener en cuenta: analogRead devuelve valores de 0 a 4095 en el ESP32 (12 bits) y para lecturas analógicas conviene usar los pines ADC1 (GPIO 32–39), porque los pines ADC2 no se pueden usar con el Wi-Fi activo. Además, después del día 9 dedica una tarde al Wi-Fi: el código siguiente muestra la distancia medida por el sensor de aparcamiento en una página web de tu red local, la página se actualiza cada segundo y el LED se enciende cuando la distancia baja de 30 cm. Si dejas el zumbador conectado al GPIO 19 como en la tabla, añadir un aviso sonoro al proyecto final será más fácil. Para configurar la placa consulta el artículo Qué es el ESP32.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_SSID = "AgAdi";      // kendi ağ adın / your network name
5const char* WIFI_PASS = "Sifre123";   // kendi şifren / your password
6
7const int TRIG_PIN = 5;
8const int ECHO_PIN = 18;   // gerilim bölücüyle / through a voltage divider
9const int LED_PIN = 23;
10
11WebServer server(80);
12
13long readDistanceCm() {
14  digitalWrite(TRIG_PIN, LOW);
15  delayMicroseconds(2);
16  digitalWrite(TRIG_PIN, HIGH);
17  delayMicroseconds(10);
18  digitalWrite(TRIG_PIN, LOW);
19  unsigned long duration = pulseIn(ECHO_PIN, HIGH, 30000UL);  // 30 ms zaman aşımı / 30 ms timeout
20  if (duration == 0) return -1;
21  return duration / 58;
22}
23
24void handleRoot() {
25  long cm = readDistanceCm();
26  digitalWrite(LED_PIN, (cm > 0 && cm < 30) ? HIGH : LOW);   // 30 cm altında uyarı / warn below 30 cm
27  String html = "<html><head><meta charset='utf-8'><meta http-equiv='refresh' content='1'></head><body>";
28  html += "<h1>Mesafe: " + String(cm) + " cm</h1></body></html>";
29  server.send(200, "text/html", html);
30}
31
32void setup() {
33  Serial.begin(115200);
34  pinMode(TRIG_PIN, OUTPUT);
35  pinMode(ECHO_PIN, INPUT);
36  pinMode(LED_PIN, OUTPUT);
37  WiFi.mode(WIFI_STA);
38  WiFi.begin(WIFI_SSID, WIFI_PASS);
39  while (WiFi.status() != WL_CONNECTED) {   // bağlanana kadar bekle / wait until connected
40    delay(500);
41    Serial.print(".");
42  }
43  Serial.println();
44  Serial.print("IP: ");
45  Serial.println(WiFi.localIP());            // bu adresi tarayıcıya yaz / type this address in a browser
46  server.on("/", handleRoot);
47  server.begin();
48}
49
50void loop() {
51  server.handleClient();
52}

Después de cargar el código, abre el Monitor Serie a 115200 baudios; cuando se establezca la conexión, escribe en el navegador de tu móvil la dirección IP que aparece. Tu teléfono y el ESP32 deben estar en la misma red Wi-Fi. El ESP32 solo se conecta a redes de 2,4 GHz; si no se conecta, sigue la lista de comprobación del artículo ESP32 no se conecta al Wi-Fi. Añadir a esta página los datos del DHT11 y un enlace para encender y apagar un LED sería un buen objetivo para el siguiente paso en tu proyecto final.

Ruta Raspberry Pi Pico: los mismos días con MicroPython

En la ruta Pico usas el editor Thonny en lugar del Arduino IDE; una vez instalado MicroPython en la Pico, el código llega a la placa en cuanto lo guardas y lo ejecutas. El LED integrado está en GP25 en la Pico clásica (en la Pico W se accede con Pin("LED")), para PWM se usa machine.PWM, para lectura analógica machine.ADC, y read_u16 devuelve valores en el rango 0–65535. Si la sintaxis de Python te resulta nueva, échale un vistazo al artículo Fundamentos de MicroPython antes del día 1; para conocer la placa tienes la guía Qué es la Raspberry Pi Pico. El código siguiente es el equivalente en MicroPython del sensor de aparcamiento del día 11 y usa la columna Pico de la tabla de pines.

MicroPython
1from machine import Pin, PWM, time_pulse_us
2import time
3
4trig = Pin(14, Pin.OUT)
5echo = Pin(15, Pin.IN)          # gerilim bölücüyle / through a voltage divider
6buzzer = PWM(Pin(13))           # pasif buzzer / passive buzzer
7led = Pin(12, Pin.OUT)
8
9def mesafe_cm():
10    trig.value(0)
11    time.sleep_us(2)
12    trig.value(1)
13    time.sleep_us(10)            # 10 mikrosaniye tetik / 10 microsecond trigger
14    trig.value(0)
15    sure = time_pulse_us(echo, 1, 30000)   # 30 ms zaman aşımı / 30 ms timeout
16    if sure < 0:
17        return -1                # yankı yok / no echo
18    return sure / 58
19
20while True:
21    cm = mesafe_cm()
22    print("Mesafe / Distance:", cm, "cm")
23    if 0 < cm < 50:
24        bekle = int(50 + cm * 9)         # yaklaştıkça kısalır / shorter when closer
25        buzzer.freq(2000)
26        buzzer.duty_u16(32768)           # yüzde 50 doluluk / 50 percent duty
27        led.value(1)
28        time.sleep_ms(50)
29        buzzer.duty_u16(0)
30        led.value(0)
31        time.sleep_ms(bekle)
32    else:
33        buzzer.duty_u16(0)
34        led.value(0)
35        time.sleep_ms(200)

Proyecto final: ¿qué terminarás al acabar las vacaciones?

El proyecto final reúne en un solo dispositivo útil las piezas que aprendiste en las dos semanas. Un buen proyecto final debe tener al menos una entrada (sensor o pulsador), un proceso (código que toma decisiones) y una salida (LED, sonido, pantalla o motor). Ninguna de las opciones siguientes requiere piezas caras fuera del kit; elige la que se ajuste a tu nivel y trabaja en ella desde el día 13. Para más ideas, consulta la lista de ideas de proyectos Arduino.

Nivel / rutaProyecto finalDías que combinaMaterial extra
Uno – iniciaciónAsistente de aparcamiento inteligente: pitidos que se aceleran según la distancia, centímetros en el LCD, barrera con servo que baja a 10 cm4, 9, 10, 11, 12, 13Ninguno, el kit basta
Uno – alternativaMini estación meteorológica: datos del DHT11 en el LCD, cambio de página con un pulsador, la luz de la pantalla se apaga en la oscuridad4, 7, 9, 12Ninguno, el kit basta
ESP32Estación de habitación vigilada desde el móvil: temperatura, humedad y distancia en una página web, LED que se enciende y apaga desde el navegador6, 9, 10, 12 + Wi-FiNinguno, la placa ESP32 basta
PicoJuego de reacción: gana quien pulse más rápido cuando se encienda un LED en un momento aleatorio, el tiempo aparece en la consola de Thonny y el ganador se celebra con una melodía del zumbador4, 8, 9Un segundo pulsador
  1. Defínelo en una frase: escribe con claridad qué hará el dispositivo, por ejemplo: "cuanto más se acerca el coche al garaje, más rápido pita, y a 10 cm baja la barrera".
  2. Dibuja un esquema entrada-proceso-salida: dibuja en papel con cajas qué sensor dará los datos, qué decidirá el código y qué pieza reaccionará.
  3. Haz un plan de pines: anota en una tabla a qué pin se conectará cada pieza. Las salidas que necesitan PWM, como el brillo de un LED, asígnalas a pines marcados con ~; en el Uno, recuerda que la librería Servo deshabilita el PWM en D9 y D10. La herramienta diagrama de pines te facilita el mapa de pines de tu placa.
  4. Pruébalo por partes: haz funcionar cada módulo solo, con su propio código pequeño; no pases a combinarlos hasta que todos funcionen por separado.
  5. Únelo y elimina los delay: reúne los códigos en un solo archivo y sustituye los delay largos por la estructura con millis que aprendiste el día 9, para que la lectura del sensor, el sonido y la pantalla no se esperen unos a otros.
  6. Ponlo en una caja y preséntalo: coloca el circuito en una caja de cartón o plástico, fija los cables con cinta y graba un vídeo de presentación de 30–60 segundos. Si quieres hacer el circuito permanente, soldar en una placa perforada puede ser tu siguiente paso.

Dónde te atascarás con más frecuencia y cómo resolverlo

ProblemaCausa probableSolución
El código no se carga, no aparece el puertoPlaca o puerto mal seleccionados, falta el controlador CH340 o usas un cable que solo cargaElige la placa y el puerto en el menú Herramientas, usa un cable USB con datos e instala el controlador
El LED no se enciende nuncaLED al revés o patillas que no quedan en la misma fila de la protoboardLa patilla larga (ánodo) va al lado del pin y la corta (cátodo) al lado de GND; prueba a mover la conexión una fila
El pulsador se activa sin pulsarloPin flotante (floating), sin resistencia pull-upUsa pinMode(pin, INPUT_PULLUP) y conecta el otro extremo del pulsador a GND
El HC-SR04 marca siempre 0 o -1TRIG y ECHO intercambiados o el sensor no recibe 5 VRevisa la tabla de pines, conecta VCC a 5 V y apunta el sensor a una superficie plana a más de 2 cm
La luz de fondo del LCD se enciende pero no hay textoContraste o dirección I2C incorrectosGira el potenciómetro azul de la parte trasera del módulo y prueba las direcciones 0x27 y 0x3F
La placa se reinicia cuando se mueve el servoEl servo consume más corriente de la que puede dar el USBAlimenta el servo con una fuente externa de 5 V y une el GND de la fuente al GND de la placa
Error "Failed to connect" al cargar en el ESP32La placa no entra en modo de descargaMantén pulsado el botón BOOT al empezar la carga y suéltalo cuando aparezca "Connecting..."
Cuando te atasques, recurre primero al Monitor Serie: añade Serial.println en los puntos importantes del código para ver el valor de las variables y hasta dónde llega el programa. Si el problema continúa, los artículos Arduino no carga el código, GND común y ESP32 Failed to connect resuelven paso a paso los problemas más habituales.

Al final de las dos semanas no solo tendrás un proyecto final funcionando, sino también un método para aprender por tu cuenta cualquier sensor o módulo nuevo: lee, dibuja, monta, prueba, cambia. Si mantienes este hábito con un proyecto por semana cuando empiecen las clases, para el verano estarás listo para un trabajo de nivel feria de ciencias o concurso escolar; para la fase de ideas, el artículo ideas de proyectos Arduino para concursos científicos es un buen punto de partida. En la app de BlueGrays encontrarás paso a paso, para Uno, ESP32 y Pico, los esquemas y códigos de los proyectos del plan (LED, semáforo, pulsador, luz nocturna con LDR, medición de distancia y DHT11) y podrás seguir cada día desde la aplicación.

Preguntas frecuentes

¿Se puede aprender Arduino en las vacaciones de invierno?

Sí, con 1–2 horas diarias de trabajo constante, en dos semanas es posible aprender entradas y salidas digitales y analógicas, lectura de sensores, pantallas y control de motores. Lo importante es terminar cada día un proyecto pequeño pero completo y modificar el código tú mismo. Al acabar las vacaciones estarás en condiciones de hacer un proyecto que combine varios módulos.

¿Qué kit hay que comprar para empezar con Arduino?

Un kit de iniciación con Arduino Uno, protoboard, cables jumper, LED, resistencias, pulsador, potenciómetro, LDR, zumbador, HC-SR04, DHT11, servo y LCD I2C es suficiente para todo este plan. Los clones del Uno ejecutan el mismo código que la placa original; lo único es que quizá tengas que instalar el controlador CH340.

¿Con qué empezar: Arduino, ESP32 o Raspberry Pi Pico?

Si no tienes experiencia, el Arduino Uno es el comienzo más fácil; funciona a 5 V y la mayoría de los ejemplos están escritos para él. Si quieres conectar tus proyectos a internet, el ESP32 es mejor opción, y si quieres aprender Python, la Raspberry Pi Pico con MicroPython. Los conceptos básicos que aprendes son los mismos en las tres placas.

¿Puedo aprender Arduino si no tengo placa?

Sí. Simuladores que funcionan en el navegador, como Wokwi y Tinkercad, te permiten conectar virtualmente piezas como LED, pulsador, potenciómetro, HC-SR04, servo y LCD y ejecutar el código. Puedes hacer toda la primera semana de este plan en simulación y, cuando llegue tu placa, probar el mismo código en el circuito real.

¿Cuál es el proyecto más fácil que se puede hacer con Arduino?

El proyecto más fácil es conectar un LED con una resistencia de 220 Ω y hacerlo parpadear (Blink). Después vienen el semáforo, el control de un LED con pulsador y la luz nocturna con LDR. Estos cuatro proyectos enseñan las bases de Arduino: salida digital, entrada digital y lectura analógica.

¿Hace falta saber programar para aprender Arduino?

No necesitas saber programar de antemano; el lenguaje de Arduino se basa en C++, pero en los proyectos de iniciación avanzas con unos pocos comandos y estructuras sencillas como if y for. La forma más rápida de aprender es ejecutar códigos de ejemplo y modificarlos línea a línea. Si sabes Python, puedes hacer los mismos proyectos con la Raspberry Pi Pico y MicroPython.

Ver todos los proyectos
Parpadeo de LED
AR-1Principiante

Parpadeo de LED

El primer hola de la electrónica: encender y apagar un solo LED. El Arduino enciende y apaga el LED a intervalos cortos, así que la luz parpadea rápido.

4.6(200)
1246
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
Encender un LED con pulsador (Push)
AR-9Principiante

Encender un LED con pulsador (Push)

Como un timbre: la luz se enciende mientras pulsas y se apaga cuando sueltas. El Arduino escucha el botón todo el rato; mientras está pulsado enciende el LED, y en cuanto levantas el dedo lo apaga.

4.8(114)
253
Luz nocturna con LDR
AR-12Principiante

Luz nocturna con LDR

Una pequeña lamparita que se enciende sola cuando oscurece y se apaga cuando llega la mañana.

4.7(105)
224
HC-SR04 Medición de distancia (pantalla en serie)
AR-27Principiante

HC-SR04 Medición de distancia (pantalla en serie)

El sensor HC-SR04 funciona igual que un murciélago que se orienta en la oscuridad: emite un sonido que no puedes oír, escucha el eco y mide a qué distancia está el objeto que tiene delante.

4.6(50)
82
Temperatura y humedad con DHT11
AR-55Intermedio

Temperatura y humedad con DHT11

¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

4.7(47)
83
LED Parpadeante con ESP32
ES-1Principiante

LED Parpadeante con ESP32

Enseña el uso básico de la salida GPIO con ESP32. Conseguimos un efecto de parpadeo encendiendo y apagando un LED desde el pin digital. Versión para ESP32 del clásico proyecto blink en Arduino UNO; los comandos básicos de blink en el entorno Arduino son los mismos, pero la distribución de pines y los niveles GPIO de 3,3 V del ESP32 difieren de los del Arduino UNO.

4.7(37)
108
Simulador de Semáforo Raspberry Pi Pico (3 LEDs Secuenciales)
PI-4Principiante

Simulador de Semáforo Raspberry Pi Pico (3 LEDs Secuenciales)

Simulamos un semáforo real con LEDs rojo, amarillo y verde. Verde 4 seg "pase", amarillo 1,5 seg "prepárese", rojo 3 seg "detenga" y rojo+amarillo 1 seg "arranque" (patrón europeo). Aprende definición de función, lógica de máquina de estados y sincronización multi-GPIO. Circuito simple: 3 LEDs en GP11/GP12/GP13.

4.0(1)
12