Controlar un LED usando dos pulsadores con Arduino

¡Hola equipo! Bienvenidos a otra lección de Ingtelecto Pro. Hoy vamos a dar un salto fundamental en nuestros proyectos con Arduino. Ya sabemos cómo enviar señales hacia afuera (como encender un LED), pero ahora vamos a aprender a recibir señales del mundo exterior. Vamos a controlar un LED usando dos pulsadores (o push buttons).

Este proyecto es la base de casi cualquier dispositivo interactivo. Piensa en el botón de "Start" de una máquina, los botones de un control de videojuegos, o un menú en una pantalla LCD. Todos se basan en el principio que aprenderemos hoy: leer una entrada digital.

Pero no lo haremos de cualquier manera. Te enseñaré el truco "Pro" que nos ahorra componentes, simplifica el cableado y es la forma más robusta de hacerlo: usaremos la resistecia pull-up interna del Arduino. 💡

¡Vamos a darle! Prepárate, que este proyecto incluye diagramas, el código completo explicado línea por línea y, por supuesto, nuestro video tutorial para que no te pierdas ningún detalle.

Materiales Necesarios

Para este proyecto, necesitarás los siguientes componentes. Son muy básicos y vienen en cualquier kit de inicio de Arduino.

Conceptos Clave del Proyecto

Antes de conectar un solo cable, es VITAL entender qué estamos haciendo y, sobre todo, por qué lo estamos haciendo de esta manera.

1. ¿Qué es un Pulsador (Push Button)?

Un pulsador es un interruptor momentáneo. Esto significa que solo cierra el circuito (deja pasar la corriente) mientras lo mantienes presionado. En cuanto lo sueltas, un resorte interno lo devuelve a su posición original, abriendo el circuito.

El Misterio de las 4 Patillas:

Seguramente ves que tu pulsador tiene 4 patillas. Esto confunde a muchísimos principiantes. ¡No te preocupes! Es muy sencillo:

• Las patillas están conectadas internamente por pares.
• Imagina que el botón tiene dos lados (A/B y D/C). Las dos patillas de un lado (A y B) están siempre conectadas entre sí. Las dos del otro lado (D y C) también.
• Al presionar el botón, lo que haces es conectar los dos lados (conectas el par A/B con el par D/C).

Por eso, la forma correcta de usarlo en la protoboard es "a horcajadas" sobre el canal central. Así te aseguras de que las patillas de la izquierda están en filas diferentes a las de la derecha. Para este tutorial, solo usaremos una patilla de cada lado (una para la señal de Arduino y otra para GND).

Entradas Digitales: El Problema del "Pin Flotante"

Un pin de Arduino configurado como INPUT es como un oído. Está "escuchando" el voltaje que le llega.

• Si "escucha" 5V (o cerca), lo interpreta como HIGH (un 1 lógico).
• Si "escucha" 0V (GND o tierra), lo interpreta como LOW (un 0 lógico).

Pero, ¿qué pasa si el pin no está conectado ni a 5V ni a GND? ¿Qué pasa si está "al aire"?

Respuesta: Se vuelve loco. El pin se convierte en una pequeña antena, captando ruido electromagnético del ambiente (de tu WiFi, de la radio, de la propia placa). Su valor saltará aleatoriamente entre HIGH y LOW sin control. A esto se le llama "estado flotante" (floating state).

La Solución Mágica: ¡INPUT_PULLUP! 🚀

Para evitar el estado flotante, siempre debemos asegurarnos de que el pin esté conectado a un voltaje definido (HIGH o LOW).

• Solución Clásica (Pull-Down): Podríamos conectar una resistencia de 10k$\Omega$ desde el pin a GND. Así, el pin estaría en LOW por defecto. Luego, conectaríamos el botón para que, al pulsarlo, envíe 5V al pin. Esto funciona, pero requiere una resistencia extra por cada botón.
• Solución Pro (Pull-Up Interna): ¡Arduino tiene un as bajo la manga! Dentro de su microcontrolador, ya existen unas resistencias (de 20k$\Omega$ a 50k$\Omega$) que podemos activar por software. Estas resistencias conectan el pin a 5V internamente.

Cuando en nuestro código escribimos pinMode(pin, INPUT_PULLUP);, le estamos diciendo al Arduino:

1. Quiero que este pin sea una ENTRADA (INPUT).
2. Por favor, activa tu resistencia interna para conectarlo a 5V (PULLUP).

La Lógica Invertida (¡Importante!)

Este método es genial, pero implica un pequeño cambio de mentalidad.

• Como el pin está conectado internamente* a 5V, su estado normal (botón sin pulsar) será HIGH.
• Para nuestro circuito, conectaremos la otra pata del botón a GND (Tierra).
• Cuando presionamos el botón, cerramos el circuito y conectamos el pin directamente a GND. La corriente prefiere el camino fácil (a GND) que pasar por la resistencia interna, por lo que el voltaje del pin cae a 0V.
• ¡El pin leerá LOW!

Resumen de la Lógica Invertida:

• Botón NO presionado = HIGH
• Botón PRESIONADO = LOW

Sabiendo esto, ¡el código tendrá todo el sentido del mundo!

Conexiones y Diagramas

Ahora sí, ¡manos a la obra! Vamos a construir el circuito paso a paso.

Tabla de Conexiones

Esta tabla es tu guía rápida para conectar todo, basada en el diagrama esquemático, sin embargo vemos los cables utilizados que entran en nuestra placa de pruebas o Arduino.

Diagramas del Circuito

Usa estas imágenes como referencia visual para asegurarte de que todas tus conexiones son correctas.

Esquemático de conexiones

Explicación Detallada del Montaje ⚙️

Sigue estos pasos en orden para construir tu circuito.

1. Alimentar la Protoboard: Conecta un cable jumper desde un pin GND del Arduino al riel (la línea larga) de color azul de tu protoboard. Este será nuestro bus de tierra común.
2. Colocar el LED: Inserta el LED en la protoboard. Recuerda que tiene polaridad. La pata más larga (Ánodo) es la positiva y la más corta (Cátodo) es la negativa. Coloca el Cátodo (pata corta) en una fila que esté conectada al riel GND que acabas de alimentar.
3. Añadir la Resistencia: Inserta la resistencia de 220$\Omega$. Conecta una de sus patas en la misma fila donde está el Ánodo (pata larga) del LED. La otra pata de la resistencia colócala en una fila vacía. ¡Esta resistencia es crucial para proteger tu LED y el pin del Arduino!
4. Señal del LED: Conecta un cable jumper desde el pin digital 5 del Arduino a la fila donde conectaste la segunda pata de la resistencia. Así, el Arduino controlará el LED a través de la resistencia.
5. Colocar los Pulsadores: Inserta los dos pulsadores en la protoboard. La forma correcta es "a horcajadas" sobre el canal central. Esto separa físicamente los pares de pines.
6. Conectar Pulsador A (ON):
   • Toma el primer pulsador (B1). Conecta un cable jumper desde el pin digital 9 del Arduino a una de las patas (por ejemplo, la superior izquierda).
   • Conecta otro cable jumper desde la pata del *otro lado* (en este caso, la inferior izquierda) al riel de GND (la línea azul).
7. Conectar Pulsador B (OFF):
   • Toma el segundo pulsador (B2). Conecta un cable jumper desde el pin digital 8 del Arduino a una de sus patas (superior izquierda).
   • Conecta otro cable desde la pata del *otro lado* (inferior izquierda) al mismo riel de GND.

¡Y listo! Fíjate bien: gracias a INPUT_PULLUP, no hemos necesitado resistencias para los botones. Nuestro circuito es más limpio y rápido de montar.

El Código (Sketch)

// TUTORIAL INGTELECTO PRO

// Lección 3: Controlar un LED con dos pulsadores (INPUT_PULLUP)

// Listo para cualquier placa de desarrollo STEREN, ARDUINO, REX QUALIS, ETC.
// --- 1. Variables Globales ---

// Definimos los pines que vamos a utilizar.

// Usar variables hace el código más legible y fácil de modificar.

int ledPin = 5; // El pin donde está conectado el LED

int botonA = 9; // El pin para el botón de ENCENDIDO (ON)

int botonB = 8; // El pin para el botón de APAGADO (OFF)
// --- 2. Configuración (Setup) ---

// Esta función se ejecuta UNA SOLA VEZ al encender o resetear el Arduino.

void setup() {

// Configuramos el pin del LED como SALIDA (OUTPUT)

// Le diremos al Arduino que ENVIARÁ voltaje por este pin.

pinMode(ledPin, OUTPUT);
// Configuramos los pines de los botones como ENTRADA PULL-UP (INPUT_PULLUP)

// 1. INPUT: Le decimos que LEERÁ voltaje de este pin.

// 2. PULLUP: Activamos la resistencia interna a 5V.

// Esto significa que el pin leerá HIGH por defecto,

// y leerá LOW solo cuando se presione el botón (lógica invertida).

pinMode(botonA, INPUT_PULLUP);

pinMode(botonB, INPUT_PULLUP);

}
// --- 3. Bucle Principal (Loop) ---

// Esta función se repite continuamente, miles de veces por segundo.

void loop() {
// --- Lógica del Botón A (Encender) ---
// Preguntamos: "¿El estado del botón A es LOW (Bajo)?"

// Recordamos que LOW significa que el botón ESTÁ PRESIONADO.

if (digitalRead(botonA) == LOW) {

// Si SÍ está presionado, encendemos el LED enviando un estado ALTO (HIGH / 5V)

digitalWrite(ledPin, HIGH);

}
// --- Lógica del Botón B (Apagar) ---
// Preguntamos: "¿El estado del botón B es LOW (Bajo)?"

// (Botón B presionado)

if (digitalRead(botonB) == LOW) {

// Si SÍ está presionado, apagamos el LED enviando un estado BAJO (LOW / 0V)

digitalWrite(ledPin, LOW);

}
// El LED mantendrá su último estado hasta que se presione el otro botón.

}

Explicación Detallada del Código

Desglosemos el código para entender perfectamente cada parte.

• Variables Globales:
  • int ledPin = 5;: Creamos una variable llamada ledPin y le asignamos el valor 5. Ahora, en lugar de escribir 5 por todo el código, usamos ledPin. Si un día queremos mover el LED al pin 6, solo cambiamos esta línea.
  • int botonA = 9;: Lo mismo para el botón A (ON) en el pin 9.
  • int botonB = 8;: Y para el botón B (OFF) en el pin 8.
• Función setup():
  • pinMode(ledPin, OUTPUT);: Configuramos el pin del LED como una SALIDA. Lógico, ¿verdad? Queremos enviar energía hacia el LED.
  • pinMode(botonA, INPUT_PULLUP);: Aquí está la estrella del show. Como explicamos en los conceptos clave, esto configura el pin 9 como una ENTRADA y activa la resistencia PULLUP interna. El pin estará a 5V (HIGH) hasta que pulsemos el botón y lo conectemos a GND (LOW).
  • pinMode(botonB, INPUT_PULLUP);: Hacemos exactamente lo mismo para el segundo botón en el pin 8.
• Función loop():
  • El loop es el cerebro que toma las decisiones. Se ejecuta miles de veces por segundo.
  • if (digitalRead(buttonApin) == LOW) { ... }: Esta es la primera decisión.
    • digitalRead(buttonApin): "Arduino, lee el voltaje en el pin 9".
    • == LOW: "...y comprueba si es igual a LOW (0V)".
    • Recordamos: ¡LOW significa que el botón A está presionado!
  • digitalWrite(ledPin, HIGH);: Si la condición anterior es verdadera (botón A presionado), entonces "escribe un estado HIGH (5V) en el pin del LED". Esto enciende el LED.
  • if (digitalRead(buttonBpin) == LOW) { ... }: Esta es la segunda decisión.
    • Comprueba si el botón B (pin 8) está presionado (leyendo LOW).
  • digitalWrite(ledPin, LOW);: Si la condición es verdadera (botón B presionado), entonces "escribe un estado LOW (0V) en el pin del LED". Esto apaga el LED.

¿Por qué el LED se queda encendido/apagado?

La función digitalWrite() es "persistente". Cuando tú le dices digitalWrite(ledPin, HIGH), el pin 5 se queda en 5V hasta que le des una orden contraria.

Por eso, cuando pulsas y sueltas el botón A, el LED se enciende. Y aunque sueltes el botón y el loop siga ejecutándose, ninguna otra parte del código le dice que se apague. Se quedará encendido hasta que, finalmente, presiones el botón B, lo cual activa la segunda condición if y ejecuta la orden digitalWrite(ledPin, LOW).

Resultado Esperado

¡Es hora de la verdad! Sube el código a tu placa Arduino y prueba el circuito:

1. Al principio, el LED debe estar apagado.
2. Presiona (y suelta) el botón conectado al pin 9 (Botón A).
3. El LED rojo se encenderá y se quedará encendido.
4. Presiona (y suelta) el botón conectado al pin 8 (Botón B).
5. El LED se apagará y se quedará apagado.

¡Felicidades! Acabas de crear un circuito digital de control ON/OFF (también conocido como Latch SR, pero con software).

Solución de Problemas Comunes

Conclusión y Próximos Pasos