Aprender

Arduino digitalRead(), en un botón y un LED

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: un botón en el pin 2 enciende el LED del pin 13en vivo0.000 s 0.00x
Presiona Ejecutar y luego mantén presionado el botón
INPUT_PULLUP mantiene el pin 2 en 5 V; el botón lo lleva a tierra y digitalRead ve LOW.

digitalRead(pin) observa el voltaje en un pin y devuelve HIGH (1) o LOW (0). Configura primero el pin con pinMode(pin, INPUT_PULLUP) y conecta un botón del pin a tierra, y leerá HIGH hasta que presiones el botón y LOW mientras lo mantengas. Eso es todo lo que hay que hacer para leer un botón.

El circuito de arriba es exactamente eso: un botón en el pin 2 y un LED en el pin 13 de un Uno. Presiona Ejecutar y luego mantén presionado el botón. El pin 2 queda en 5 V hasta que el botón lo baja a 0 V, digitalRead() ve LOW y el LED se enciende. Suéltalo y se apaga.

Abajo encontrarás por qué importa el pull-up, qué lee un pin al que no hay nada conectado, el voltaje en el que LOW se convierte en HIGH y por qué una sola presión puede leerse miles de veces, cada cosa probada en un Uno en Mokxi con lo que imprimió.

¿Quieres la versión paso a paso? La lección "Leer un pin y el pull-up" recorre esto con puntos de control.

Abrir la lección

El sketch: pinMode y luego digitalRead

Este es el sketch que corre arriba. pinMode(BUTTON_PIN, INPUT_PULLUP) hace del pin 2 una entrada y enciende una resistencia dentro del chip que lo sube a 5 V. En loop(), digitalRead(BUTTON_PIN) == LOW es verdadero mientras se mantiene el botón, y el LED lo sigue.

Por eso presionado se lee como LOW, lo que sorprende a todos la primera vez. El botón conecta el pin a tierra; el pull-up es lo que hace que lea HIGH el resto del tiempo. Si prefieres pensarlo como "presionado es verdadero", escribe bool pressed = digitalRead(2) == LOW; una vez y usa pressed a partir de entonces.

firmware/uno/examples/button (el sketch que corre arriba)
const int BUTTON_PIN = 2;

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  bool pressed = digitalRead(BUTTON_PIN) == LOW;
  digitalWrite(LED_BUILTIN, pressed ? HIGH : LOW);
  delay(5);
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Un pin sin nada conectado lee ruido

Con un simple pinMode(2, INPUT) y nada que jale el pin hacia un lado u otro, queda flotando, y la carga errante que haya cerca decide qué lee. Veinte lecturas, a diez milisegundos de distancia, imprimieron 00111111010100110100. Una placa real hace lo mismo, y un botón conectado sin ninguna resistencia se comporta así siempre que no está presionado: presiones aleatorias que nadie hizo.

Enciende el pull-up y las mismas veinte lecturas imprimieron 11111111111111111111. Usa INPUT_PULLUP con el botón a tierra, como arriba, o INPUT con tu propia resistencia, 10 k del pin a 5 V o a tierra. La página de la resistencia pull-up dibuja ambas.

Flotando y luego con pull-up
void setup() {
  Serial.begin(9600);
  pinMode(2, INPUT);
  for (int i = 0; i < 20; i++) {
    Serial.print(digitalRead(2));
    delay(10);
  }
  Serial.println();
  pinMode(2, INPUT_PULLUP);
  for (int i = 0; i < 20; i++) {
    Serial.print(digitalRead(2));
    delay(10);
  }
  Serial.println();
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Qué cuenta como HIGH

Un pin digital responde sí o no, pero el voltaje en él puede ser cualquier cosa entre 0 y 5 V. La hoja de datos del ATmega328P promete LOW por debajo de 1.5 V y HIGH por encima de 3 V en un Uno de 5 V, y deja el espacio intermedio a criterio del chip. Pusimos un potenciómetro en el pin 2 y en A0 y lo giramos lentamente hacia abajo y de vuelta hacia arriba. Al bajar, el pin pasó a LOW en 2184 mV; al volver a subir solo volvió a HIGH en 2619 mV.

Ese hueco es a propósito. Un pin que cambiara en un solo voltaje exacto oscilaría de un lado a otro con una señal que cambia despacio; con un hueco, cambia de opinión una sola vez. También te dice que el HIGH de un sensor de 3.3 V, bien por encima de 3 V, se lee como HIGH en un Uno de 5 V, y que una señal débil de 2 V es una moneda al aire. Para cualquier valor intermedio, léelo con analogRead().

Dónde cambia de opinión el pin
void setup() {
  Serial.begin(9600);
  pinMode(2, INPUT);
}

void loop() {
  static int last = -1;
  int v = digitalRead(2);
  if (v != last) {
    last = v;
    long mv = analogRead(A0) * 5000L / 1023;
    Serial.print(mv);
    Serial.print(" mV -> ");
    Serial.println(v);
  }
  delay(2);
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Una pulsación, leída miles de veces

loop() corre mucho más rápido que un dedo. Mantuvimos presionado el botón medio segundo y contamos: unas 47,800 pasadas de loop() lo vieron en LOW. Un sketch que suma puntos cada vez que el pin está en LOW suma unas 47,800 puntos por una sola pulsación. Para contar pulsaciones, recuerda la última lectura y actúa solo cuando cambia de HIGH a LOW.

Aun así contó 4 pulsaciones por una sola. Los contactos de un botón rebotan unos milisegundos al abrirse y cerrarse, y el botón de Mokxi rebota como uno real, así que el sketch vio el pin pasar a LOW cuatro veces distintas. La página de antirrebote del botón muestra cómo esperar el rebote con millis().

Niveles frente a pulsaciones
const int BUTTON = 2;
long held = 0;
int presses = 0;
int last = HIGH;

void setup() {
  Serial.begin(9600);
  pinMode(BUTTON, INPUT_PULLUP);
}

void loop() {
  int now = digitalRead(BUTTON);
  if (now == LOW) held++;
  if (now == LOW && last == HIGH) presses++;
  last = now;
  if (millis() >= 1500) {
    Serial.print("loops that saw LOW: ");
    Serial.println(held);
    Serial.print("presses: ");
    Serial.println(presses);
    while (true) {
    }
  }
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Pines de salida, pines analógicos y un = equivocado

digitalRead() funciona en cualquier pin. En un pin configurado como OUTPUT, devuelve lo último que escribiste: tras digitalWrite(13, HIGH) imprimió 1, y tras LOW imprimió 0. Es una forma rápida de alternar un pin: digitalWrite(13, !digitalRead(13));. Los pines analógicos de un Uno también son pines digitales: A0 conectado a 5 V imprimió 1 y A1 conectado a tierra imprimió 0.

HIGH y LOW son simplemente 1 y 0, y Serial.println(digitalRead(2)) imprime el número. Compara con dos signos de igual. if (digitalRead(2) = HIGH) detiene la compilación: el clang de Mokxi dice expression is not assignable, y el GCC del IDE de Arduino dice lvalue required as left operand of assignment.

Abre este circuito en el editor. Arduino Uno: un botón en el pin 2 enciende el LED del pin 13, cableado como se ejecuta arriba en esta página. Cambia un componente o un valor y vuelve a ejecutarlo.

Preguntas

¿Por qué digitalRead devuelve LOW cuando el botón está presionado?

Porque el botón conecta el pin a tierra, y INPUT_PULLUP lo mantiene en 5 V el resto del tiempo. Presionado es LOW, suelto es HIGH. Compara con LOW, o escribe bool pressed = digitalRead(pin) == LOW;.

¿Por qué mi digitalRead cambia al azar?

El pin está flotando: nada lo mantiene en HIGH o LOW. Usa pinMode(pin, INPUT_PULLUP) con el botón conectado a tierra, o agrega una resistencia de 10 k del pin a 5 V o a tierra.

¿Puedo usar digitalRead en un pin analógico?

Sí. En un Uno, A0 a A5 también son pines digitales, y digitalRead(A0) devuelve HIGH o LOW. (En un Nano, A6 y A7 son solo analógicos.)

¿Qué voltaje ve digitalRead como HIGH?

En un Uno de 5 V, cualquier valor por encima de 3 V es HIGH garantizado y cualquier valor por debajo de 1.5 V es LOW garantizado. En el punto intermedio, el pin mantiene su última respuesta un rato: en nuestra prueba bajó a LOW a unos 2.2 V y volvió a subir a HIGH a unos 2.6 V.

¿Necesito pinMode antes de digitalRead?

Los pines inician como entradas, así que digitalRead funciona sin él, pero el pin queda flotando. Llama a pinMode(pin, INPUT_PULLUP) o pinMode(pin, INPUT) en setup() para que quede claro para qué es el pin y cómo se mantiene.

Fuentes

De dónde vienen los datos de esta página

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.