Aprender

Un contador de botones en Arduino que cuenta cada pulsación una sola vez

Intermedio

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: un marcador que cuenta pulsaciones de botonesen vivo0.000 s 0.00x
Presiona Ejecutar y luego presiona el botón de local o visita
Presiona local o visita para un punto; mantén uno presionado un segundo para quitar un punto.

Para contar pulsaciones de botón, cuenta el momento en que el botón baja, no cada vez que loop() lo encuentra abajo. Guarda cómo estaba el botón la vez anterior; si ahora está abajo y antes estaba arriba, eso es una pulsación. Luego espera los pocos milisegundos de rebote del contacto antes de creer un cambio, o una pulsación contará como varias.

El circuito de arriba es un marcador en un Uno: un display MAX7219 de ocho dígitos, con el marcador de local a la izquierda, un reloj de juego en medio y el de visita a la derecha. Presiona Ejecutar, luego el botón de local o visita, y ese marcador sube en uno. Mantén un botón presionado un segundo y el marcador baja en uno, para un punto dado por error. El tercer botón inicia y detiene el reloj.

Abajo está el contador construido a partir del error que todos cometen primero, con las cuentas que dio cada versión para las mismas dos pulsaciones en un Uno, una pulsación larga que limpia la cuenta, y dos botones que cuentan hacia arriba y hacia abajo.

Contar mientras está presionado

El primer intento suma uno cada vez que el pin lee LOW. loop() corre decenas de miles de veces por segundo, así que una pulsación contó 22976 en los primeros 200 ms que estuvo presionada, y la siguiente lectura fue -30754: un int no puede pasar de 32767, así que dio la vuelta a los números negativos. El botón va conectado del pin 2 a GND, con INPUT_PULLUP, así que presionado es LOW.

Cuenta cada vuelta, no cada pulsación
int count = 0;

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

void loop() {
  if (digitalRead(2) == LOW) {
    count++;
  }
  static unsigned long last = 0;
  if (millis() - last >= 500) {
    last = millis();
    Serial.println(count);
  }
}

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

Detección de cambio de estado

Guarda la lectura de la vez anterior y cuenta solo el cambio de arriba a abajo. Eso es detección de cambio de estado, o detección de flanco. Dos pulsaciones ahora contaron 10, no decenas de miles, pero todavía no 2.

Los otros 8 son rebote. Los contactos metálicos de un botón se separan y vuelven a tocarse varias veces en los primeros milisegundos de una pulsación y de una liberación, y el sketch es lo bastante rápido para ver cada toque como una pulsación nueva. El botón de Mokxi rebota como uno real, por eso aparece aquí.

Cuenta cada cambio, también los rebotes
const int BUTTON = 2;
int count = 0;
bool wasDown = false;

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

void loop() {
  bool down = digitalRead(BUTTON) == LOW;
  if (down && !wasDown) {
    count++;
    Serial.print("presses: ");
    Serial.println(count);
  }
  wasDown = down;
}

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

Con antirrebote: una pulsación, una cuenta

Cree en el botón solo cuando haya leído lo mismo por un rato. El sketch de abajo anota cuándo cambió la lectura por última vez y acepta el nuevo estado solo tras 20 ms sin cambios. Las mismas dos pulsaciones imprimieron "presses: 1" y "presses: 2". No se necesita delay(), así que el resto de loop() sigue corriendo.

Un contador de pulsaciones con antirrebote de 20 ms
const int BUTTON = 2;
int count = 0;
bool stable = false;
bool lastRead = false;
unsigned long changedAt = 0;

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

void loop() {
  bool reading = digitalRead(BUTTON) == LOW;
  if (reading != lastRead) {
    changedAt = millis();
    lastRead = reading;
  }
  if (millis() - changedAt > 20 && reading != stable) {
    stable = reading;
    if (stable) {
      count++;
      Serial.print("presses: ");
      Serial.println(count);
    }
  }
}

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 larga que limpia la cuenta

Para distinguir una pulsación de una mantenida, anota cuándo bajó el botón y cuenta al subir. Si se mantuvo un segundo, haz la tarea de la pulsación mantenida y salta la cuenta. Con dos pulsaciones cortas y luego una larga, una versión del sketch de arriba hecha así imprimió "presses: 1", "presses: 2" y "held: back to 0".

El marcador que corre arriba hace exactamente esto en su función check(): una liberación después de al menos 20 ms es una pulsación, y una pulsación mantenida de 1000 ms quita un punto.

firmware/uno/examples/scoreboard (pulsar o mantener, del sketch que corre arriba)
uint8_t check(Button &b) {
  bool down = digitalRead(b.pin) == LOW;
  unsigned long now = millis();
  uint8_t event = 0;
  if (down && !b.down) {
    b.since = now;
    b.held = false;
  } else if (down && !b.held && now - b.since >= 1000) {
    b.held = true;
    event = 2;
  } else if (!down && b.down && !b.held && now - b.since >= 20) {
    event = 1;
  }
  b.down = down;
  return event;
}

¿Por qué no contar con una interrupción?

attachInterrupt() en el pin 2 ejecuta una función en el instante en que el pin cambia, lo cual suena hecho para contar. Para un botón es la herramienta equivocada: la interrupción ve también cada rebote, así que cuenta de más igual que el sketch de cambio de estado, y hacer antirrebote dentro de un controlador de interrupción significa medir tiempo con millis() ahí, que es engorroso. Una interrupción se gana su lugar para pulsos demasiado rápidos o cortos para que loop() los atrape, como un sensor de flujo o un encoder de rueda, y la página de interrupciones tiene un contador para esos.

Una pulsación dura como mínimo unas decenas de milisegundos y loop() pasa miles de veces en ese lapso, así que leer el pin en loop() nunca deja pasar una, siempre que nada en loop() se bloquee por mucho tiempo. Un delay(1000) en otra parte del sketch es lo que hace que un contador pierda pulsaciones.

Conservar el conteo después de un reinicio

Una variable vuelve a empezar desde 0 cada vez que la placa se reinicia o pierde energía. Para conservar un conteo, guárdalo con EEPROM.put(0, count) cuando cambie y léelo de vuelta con EEPROM.get(0, count) en setup(). La EEPROM se desgasta después de unas 100,000 escrituras en una misma dirección, así que para un contador que cambia seguido, guárdalo cada cierto número de pulsaciones o cuando un botón lo indique, no en cada pulsación.

Subir y bajar con dos botones

Dos botones, dos estados recordados. El sketch de abajo cuenta hacia arriba en el pin 2 y hacia abajo en el pin 3 y mantiene el conteo entre 0 y 99 con constrain(). Una pulsación hacia abajo, dos hacia arriba y una hacia abajo imprimieron 0, 1, 2 y 1: la primera pulsación no pudo bajar de 0. Un delay(20) corto al final de loop() es el antirrebote más simple cuando el sketch no tiene nada más que hacer.

Desde aquí, muestra el conteo en una pantalla: las páginas del siete segmentos, el TM1637 y el LCD imprimen un número cada una. En un Uno, un int cuenta hasta 32767; usa un unsigned long para más.

Contar hacia arriba y hacia abajo
const int UP = 2;
const int DOWN = 3;
int count = 0;
bool upWas = false;
bool downWas = false;

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

void loop() {
  bool up = digitalRead(UP) == LOW;
  bool down = digitalRead(DOWN) == LOW;
  if (up && !upWas) count++;
  if (down && !downWas) count--;
  if ((up && !upWas) || (down && !downWas)) {
    count = constrain(count, 0, 99);
    Serial.println(count);
  }
  upWas = up;
  downWas = down;
  delay(20);
}

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

Abre este circuito en el editor. Arduino Uno: un marcador que cuenta pulsaciones de botón, cableado como se ejecuta arriba en esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Abrir el circuito

Preguntas

¿Cómo cuento pulsaciones de botón en un Arduino?

Recuerda el estado del botón de la última pasada por loop() y suma uno solo cuando cambia de suelto a presionado. Aplícale antirrebote, o una sola pulsación contará varias veces.

¿Por qué mi contador de botón cuenta más de una vez por pulsación?

Rebote de contacto: el botón hace y rompe el contacto varias veces en los primeros milisegundos. Acepta un cambio solo después de que la lectura se haya mantenido unos 20 ms.

¿Por qué mi contador de Arduino se va a negativos?

Está contando cada pasada de loop() mientras el botón está presionado, y un int pasa de 32767 a -32768. Cuenta el cambio de suelto a presionado.

¿Cómo detecto una pulsación larga en un botón de Arduino?

Guarda millis() cuando el botón se presione. Si sigue presionado un segundo después, es una pulsación larga; si se suelta antes, fue una corta.

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.