¿Cómo leer sensores y entradas digitales con Arduino?

Leer sensores y entradas digitales con Arduino significa usar la función digitalRead() para detectar si un pin recibe señal HIGH (5V) o LOW (0V) desde un botón, sensor o interruptor.

La señal digital de entrada

Una entrada digital solo puede tener dos estados: encendida o apagada. En Arduino, eso se traduce a HIGH (5V) o LOW (0V). Tu placa puede leer ese estado en cualquier pin configurado como entrada.

Esto te permite reaccionar al mundo físico: detectar si alguien presiona un botón, si una puerta está abierta o si un sensor detecta movimiento.

Sintaxis de digitalRead()

La función tiene esta estructura:

int estado = digitalRead(numeroDePIN);

• numeroDePIN: el número del pin digital que quieres leer (del 2 al 13 en la mayoría de placas).
• Valor de retorno: HIGH (1) o LOW (0).

Antes de leer, debes configurar ese pin como entrada dentro de setup():

pinMode(numeroDePIN, INPUT);

Sin pinMode(), el pin queda en un estado indefinido y tu lectura será poco confiable.

Resistencia pull-up y pull-down

Cuando un pin de entrada no está conectado a nada, "flota". Un pin flotante puede leer valores aleatorios entre HIGH y LOW. Para evitar eso, usas una resistencia de jalón (pull).

Pull-down (10 kΩ a GND): El pin lee LOW cuando el botón no está presionado y HIGH cuando sí lo está.

Pull-up interno: Arduino tiene resistencias pull-up integradas de ~20 kΩ. Las activas con INPUT_PULLUP. Con esta opción, el pin lee HIGH en reposo y LOW cuando el botón cierra el circuito a tierra (GND).

pinMode(pin, INPUT_PULLUP);

Usar INPUT_PULLUP es la forma más sencilla y no requiere resistencia externa.

Conexión de un botón con resistencia pull-down

Este es el circuito clásico de entrada digital:

1. Conecta un extremo del botón al pin digital 2 de Arduino.
2. Conecta el otro extremo al pin de 5V.
3. Conecta una resistencia de 10 kΩ entre el pin 2 y GND.

Con este circuito:

• Botón sin presionar → pin 2 lee LOW (jalado a tierra por la resistencia).
• Botón presionado → pin 2 lee HIGH (recibe 5V directamente).

Ejemplo 1: Encender un LED al presionar un botón

Este es el ejemplo más básico. Conecta un LED con su resistencia de 220 Ω al pin 13, y un botón al pin 2 con resistencia pull-down de 10 kΩ.

const int pinBoton = 2;
const int pinLED = 13;

void setup() {
  pinMode(pinBoton, INPUT);
  pinMode(pinLED, OUTPUT);
}

void loop() {
  int estado = digitalRead(pinBoton);

  if (estado == HIGH) {
    digitalWrite(pinLED, HIGH);
  } else {
    digitalWrite(pinLED, LOW);
  }
}

¿Qué hace este código? Cada vez que loop() corre, lee el estado del pin 2. Si detecta HIGH, enciende el LED. Si no, lo apaga. El LED sigue exactamente el estado del botón.

Ejemplo 2: Usar INPUT_PULLUP sin resistencia externa

Aquí simplificamos el circuito usando la resistencia interna de Arduino. Solo conecta un extremo del botón al pin 4 y el otro extremo a GND. No necesitas resistencia externa.

const int pinBoton = 4;
const int pinLED = 13;

void setup() {
  pinMode(pinBoton, INPUT_PULLUP);
  pinMode(pinLED, OUTPUT);
}

void loop() {
  int estado = digitalRead(pinBoton);

  if (estado == LOW) {
    digitalWrite(pinLED, HIGH);
  } else {
    digitalWrite(pinLED, LOW);
  }
}

Nota importante: Con INPUT_PULLUP, la lógica se invierte. El pin lee LOW cuando el botón está presionado y HIGH cuando está suelto. Por eso el if verifica LOW.

Ejemplo 3: Contador de pulsaciones con comunicación serial

Este ejemplo más avanzado cuenta cuántas veces presionas el botón y envía el resultado al monitor serial. Es útil para depurar y entender el comportamiento del sensor.

const int pinBoton = 2;
int contador = 0;
int estadoAnterior = LOW;

void setup() {
  pinMode(pinBoton, INPUT);
  Serial.begin(9600);
  Serial.println("Esperando pulsaciones...");
}

void loop() {
  int estadoActual = digitalRead(pinBoton);

  if (estadoActual == HIGH && estadoAnterior == LOW) {
    contador++;
    Serial.print("Pulsaciones: ");
    Serial.println(contador);
    delay(50);
  }

  estadoAnterior = estadoActual;
}

¿Qué hace este código? Guarda el estado anterior del botón. Solo suma al contador cuando detecta el cambio de LOW a HIGH, es decir, el momento exacto en que alguien presiona. El delay(50) elimina el rebote mecánico del botón.

En el monitor serial verías algo así:

Esperando pulsaciones...
Pulsaciones: 1
Pulsaciones: 2
Pulsaciones: 3

Sensores digitales: más allá del botón

Cualquier dispositivo que entregue señal HIGH o LOW es una entrada digital. Algunos ejemplos comunes:

Todos se leen con digitalRead(). Lo único que cambia es la lógica de tu if.

Aplicación práctica: Imagina que montas un sistema de seguridad para un almacén de FEMSA. Un sensor magnético en la puerta te indica si está abierta o cerrada. Con digitalRead() puedes activar una alarma si la puerta se abre fuera de horario.

Errores comunes

1. Olvidar pinMode() antes de leer. Si no declaras el pin como INPUT o INPUT_PULLUP, la lectura es impredecible. Siempre configura el pin en setup().

2. Confundir la lógica de INPUT_PULLUP. Muchos principiantes esperan leer HIGH cuando presionan el botón con INPUT_PULLUP. En realidad es al revés: el pin lee LOW al presionar. Si tu LED no responde como esperas, revisa esta lógica primero.

3. No manejar el rebote (bounce) del botón. Los botones mecánicos "rebotan" al presionarse: hacen contacto y lo cortan varias veces en milisegundos. Esto puede generar múltiples lecturas HIGH por una sola pulsación. Agrega un delay(50) después de detectar el cambio, o usa la librería Bounce2 para soluciones más robustas.

4. Dejar el pin flotante. Si conectas el botón a 5V pero no pones resistencia pull-down ni usas INPUT_PULLUP, el pin flota cuando el botón no está presionado. Leerás valores aleatorios y tu programa se comportará de forma errática.

5. Usar el pin 0 o el pin 1 para entradas. Los pines 0 (RX) y 1 (TX) están reservados para la comunicación serial con la computadora. Si los usas para botones, interfieren con la carga de programas. Usa pines del 2 al 13.

Referencia rápida

Puntos clave

• Configura siempre el pin como entrada con pinMode(pin, INPUT) o pinMode(pin, INPUT_PULLUP) dentro de setup().
• digitalRead() devuelve HIGH (1) o LOW (0); usa esos valores en tus condiciones if.
• INPUT_PULLUP invierte la lógica: el pin lee LOW cuando el botón está presionado.
• Un pin sin resistencia pull-down ni pull-up interno queda "flotante" y genera lecturas aleatorias.
• Agrega un pequeño delay(50) después de detectar una pulsación para evitar el rebote mecánico del botón.