Um contador de botões com Arduino que conta cada aperto uma única vez
Intermediário
- 526componentes na bancada
- 46placas rodando agora
- 1.00xtempo real, em todas as placas
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.
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.
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.
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.
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.
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 circuitoPerguntas
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.
Continuar
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.