Aprender

Um contador de botões com Arduino que conta cada aperto uma única vez

Intermediário

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: um placar que conta apertos de botãoao vivo0.000 s 0.00x
Aperte Rodar, depois aperte o botão de casa ou de visitante
Aperte casa ou visitante para marcar um ponto; segure um por um segundo para tirar um ponto de volta.

Para contar apertos de botão, conte o momento em que o botão desce, e não toda vez que loop() o encontra pressionado. Guarde como o botão estava na última volta; se ele está pressionado agora e estava solto antes, isso é um aperto. Depois espere os poucos milissegundos de bounce do contato antes de acreditar em uma mudança, ou um aperto vale por vários.

O circuito acima é um placar em um Uno: um display MAX7219 de oito dígitos, com o placar de casa à esquerda, um relógio de jogo no meio e o placar de visitante à direita. Aperte Rodar, depois o botão de casa ou de visitante, e aquele placar sobe um. Segure um botão por um segundo e o placar volta um ponto, para um ponto dado por engano. O terceiro botão liga e desliga o relógio.

Abaixo está o contador construído a partir do erro que todo mundo comete primeiro, com as contagens que cada versão deu para os mesmos dois apertos em um Uno, um aperto longo que zera a contagem, e dois botões que contam para cima e para baixo.

Contando enquanto está pressionado

A primeira tentativa soma um sempre que o pino lê LOW. loop() roda dezenas de milhares de vezes por segundo, então um aperto contou 22976 nos primeiros 200 ms em que ficou pressionado, e a próxima leitura foi -30754: um int não passa de 32767, então deu a volta para os números negativos. O botão está ligado do pino 2 ao GND, com INPUT_PULLUP, então pressionado é LOW.

Conta cada passada do loop, não cada aperto
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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Detecção de mudança de estado

Guarde a leitura da última vez e conte apenas a mudança de solto para pressionado. Isso é detecção de mudança de estado, ou detecção de borda. Dois apertos agora contaram 10, e não dezenas de milhares, mas ainda não 2.

Os outros 8 são bounce. Os contatos metálicos de um botão se afastam e se tocam de novo várias vezes nos primeiros milissegundos de um aperto e de uma soltada, e o sketch é rápido o bastante para enxergar cada toque como um novo aperto. O botão do Mokxi sofre bounce como um de verdade, e é por isso que isso aparece aqui.

Conta cada mudança, bounces também
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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Com debounce: um aperto, uma contagem

Só acredite no botão depois que ele ler o mesmo por um tempo. O sketch abaixo anota quando a leitura mudou pela última vez e aceita o novo estado só depois de 20 ms sem mudança. Os mesmos dois apertos imprimiram "presses: 1" e "presses: 2". Não é preciso delay(), então o resto de loop() continua rodando.

Um contador de apertos com debounce 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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Um aperto longo que zera a contagem

Para distinguir um aperto de um aperto longo, anote quando o botão desceu e conte na hora de soltar. Se ficou pressionado por um segundo, faça a ação do aperto longo e pule a contagem. Com dois apertos curtos e depois um longo, uma versão do sketch acima feita assim imprimiu "presses: 1", "presses: 2" e "held: back to 0".

O placar rodando acima faz exatamente isso na sua função check(): um soltar depois de pelo menos 20 ms é um aperto, e uma pressão mantida de 1000 ms é uma pressão longa, que tira um ponto de volta.

firmware/uno/examples/scoreboard (apertar ou segurar, a partir do sketch rodando acima)
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 que não contar com uma interrupção?

attachInterrupt() no pino 2 roda uma função no instante em que o pino muda, o que parece feito para contar. Para um botão é a ferramenta errada: a interrupção vê cada bounce também, então conta demais igual ao sketch de mudança de estado, e fazer debounce dentro de um handler de interrupção significa medir tempo com millis() ali, o que é trabalhoso. Uma interrupção vale a pena para pulsos rápidos ou curtos demais para loop() pegar, como um sensor de fluxo ou um encoder de roda, e a página de interrupções tem um contador para esses.

No tempo mais curto, um aperto de botão dura dezenas de milissegundos, e loop() passa milhares de vezes nesse intervalo, então ler o pino em loop() nunca perde um aperto, desde que nada em loop() bloqueie por muito tempo. Um delay(1000) em outro lugar do sketch é o que faz um contador perder apertos de botão.

Manter a contagem após um reset

Uma variável volta a 0 toda vez que a placa é reiniciada ou perde energia. Para manter uma contagem, salve-a com EEPROM.put(0, count) quando ela mudar e leia de volta com EEPROM.get(0, count) no setup(). A EEPROM se desgasta depois de cerca de 100.000 gravações no mesmo endereço, então, para um contador que muda com frequência, salve a cada certo número de apertos ou quando um botão indicar, e não a cada aperto.

Subir e descer com dois botões

Dois botões, dois estados lembrados. O sketch abaixo conta para cima no pino 2 e para baixo no pino 3 e mantém a contagem entre 0 e 99 com constrain(). Um aperto para baixo, dois para cima e um para baixo imprimiram 0, 1, 2 e 1: o primeiro aperto não podia ir abaixo de 0. Um delay(20) curto no final do loop() é o debounce mais simples quando o sketch não tem mais nada para fazer.

A partir daqui, mostre a contagem em um display: as páginas de display de sete segmentos, TM1637 e LCD cada uma imprimem um número. Em um Uno, um int conta até 32767; use um unsigned long para mais.

Contar para cima e para baixo
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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Abra este circuito no editor. Arduino Uno: um placar que conta apertos de botão, ligado como aparece rodando no topo desta página. Mude um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

Como faço para contar apertos de botão em um Arduino?

Lembre o estado do botão da última passada por loop() e some um apenas quando ele mudar de solto para pressionado. Faça o debounce, ou um aperto conta várias vezes.

Por que meu contador de botões conta mais de uma vez por aperto?

Bounce de contato: o botão faz e desfaz o contato várias vezes nos primeiros milissegundos. Aceite uma mudança só depois de a leitura se manter estável por cerca de 20 ms.

Por que meu contador do Arduino fica negativo?

Ele está contando a cada passada de loop() enquanto o botão está pressionado, e um int dá a volta de 32767 para -32768. Conte a mudança de solto para pressionado em vez disso.

Como detecto um aperto longo em um botão do Arduino?

Salve millis() quando o botão for pressionado. Se ele ainda estiver pressionado um segundo depois, é um aperto longo; se soltar antes, foi um curto.

Fontes

De onde vêm as informações desta página

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.