Eventos de botão com tratamento de rebote

Um botão não muda de nível de forma ideal

Na montagem já conhecida, o botão fica entre D2 e GND e o pino usa INPUT_PULLUP. Portanto:

• solto → leitura HIGH;
• pressionado → leitura LOW.

Ao apertar uma vez, esperamos uma única mudança de HIGH para LOW. Porém, os contatos mecânicos podem encostar, separar e encostar novamente por um breve instante. O pino então pode fornecer várias leituras alternadas antes de se firmar em LOW.

Esse efeito também pode ocorrer ao soltar o botão, antes de a leitura se firmar em HIGH.

Rebote não são vários apertos

Imagine que o programa leia, em passagens consecutivas pelo loop(), esta sequência durante um único pressionamento:

HIGH → LOW → HIGH → LOW → LOW → LOW

Os primeiros níveis alternados são o rebote: mudanças elétricas rápidas causadas pelos contatos. Só a parte final, que permanece em LOW, representa uma condição que parece estável.

Se cada mudança para LOW fosse tratada imediatamente como um comando, o mesmo apertar poderia produzir mais de uma ação. A solução será confirmar que uma mudança deixou de oscilar antes de aceitá-la como válida.

Em cada passagem por loop(), digitalRead(BOTAO_PIN) fornece uma leitura instantânea: a amostra elétrica disponível naquele momento. Com INPUT_PULLUP, HIGH significa botão solto e LOW significa botão pressionado.

Durante o rebote, essa leitura pode mudar várias vezes, embora a intenção mecânica seja uma só. Por isso, a aplicação não deve tratar toda leitura instantânea como um estado já aceito.

Para tratar o botão, mantenha informações com papéis diferentes. Elas podem coincidir em um instante, mas não significam a mesma coisa:

• Leitura instantânea: o valor obtido agora com digitalRead().
• Último nível observado: a memória da amostra anterior, usada para perceber que a leitura mudou.
• Estado estável: o nível que a aplicação já aceitou como confiável.
• Marca da última mudança observada: o instante, em unsigned long, registrado quando a leitura observada mudou.

Enquanto o contato oscila, a leitura e o último nível observado podem mudar; o estado estável pode continuar com o valor anterior.

No início do programa, leia o botão uma vez e use essa leitura para inicializar as duas memórias de nível. Essa é a condição de partida: não representa um novo pressionamento nem uma nova soltura.

A marca de tempo também precisa começar com um valor persistente. Aqui, millis() registra o instante inicial. A confirmação temporal será acrescentada no próximo passo.

Declarações e inicialização após configurar o pino do botão como INPUT_PULLUP.

Associe cada informação à sua função principal.

Em cada passagem por loop(), compare a leitura instantânea com ultimoNivelObservado antes de avaliar o tempo. Se forem diferentes, uma mudança acabou de ser observada: atualize essa memória e registre agora em instanteUltimaMudanca.

Toda nova mudança reinicia a janela. Portanto, se o sinal oscilar durante o pressionamento ou durante a soltura, ainda não há estabilidade suficiente para aceitar o novo nível em estadoEstavel.

Junto das declarações persistentes do step anterior, acrescente a constante abaixo. Depois, substitua integralmente o loop() provisório daquele step por este loop(). Assim, haverá apenas uma definição de loop() no sketch.

Um novo nível é aceito somente quando as duas condições são verdadeiras:

1. leituraAtual é diferente de estadoEstavel; há uma mudança ainda não aceita.
2. O tempo desde instanteUltimaMudanca alcançou INTERVALO_ESTAVEL; a leitura permaneceu sem mudança durante a janela.

Neste exemplo, 30 ms é um valor inicial de ensaio, não uma duração universal de rebote. Não há delay() nem laço de espera: enquanto o intervalo não termina, a condição temporal é falsa e o loop() continua executando suas demais tarefas.

Complete as condições que reiniciam a janela e que permitem confirmar a leitura. As variáveis mostradas já existem no sketch.

O estado estável atual é HIGH, e INTERVALO_ESTAVEL vale 30 ms. Considere estas consultas:

• 10 ms: LOW
• 18 ms: HIGH
• 25 ms: LOW
• 40 ms: LOW
• 54 ms: LOW
• 55 ms: LOW

Em qual consulta o programa pode aceitar LOW como novo estado estável?

Um estado estável informa a condição aceita neste momento: enquanto o botão fica pressionado, ele continua em LOW.

Um evento informa que algo acabou de acontecer nesta passagem por loop(). Assim, pressionou deve ser true somente quando o estado estável muda de HIGH para LOW.

Com INPUT_PULLUP:

• HIGH → LOW: pressionamento confirmado;
• LOW → HIGH: soltura confirmada.

A permanência em LOW não cria novos pressionamentos. Ela apenas mantém o estado estável como pressionado.

No início de toda passagem por loop(), zere os indicadores de evento. Isso impede que um evento confirmado em uma passagem continue verdadeiro na próxima.

A atualização segue esta ordem:

1. obter a leitura atual;
2. atualizar ultimoNivelObservado e reiniciar a janela se a leitura mudou;
3. confirmar um novo estadoEstavel quando a janela terminou;
4. guardar o estado estável anterior e comparar a direção da transição;
5. ativar pressionou ou soltou;
6. disponibilizar esses eventos para a aplicação nesta mesma passagem.

A confirmação temporal é a mesma do passo anterior. Agora, a transição confirmada ganha um significado pontual: pressionar ou soltar.

Acrescente este conteúdo ao loop() do step anterior, substituindo o loop() provisório inteiro. Ele reutiliza exatamente BOTAO_PIN, ultimoNivelObservado, estadoEstavel, instanteUltimaMudanca e INTERVALO_ESTAVEL já declarados.

pressionou e soltou são variáveis locais: elas começam como false em cada passagem. Já as memórias do tratamento de rebote continuam persistentes, como antes.

Substitua integralmente o loop() do step anterior por este código. As declarações globais e o setup() permanecem os mesmos.

Complete as condições que reconhecem as duas transições confirmadas. Considere a ligação com INPUT_PULLUP: pressionado corresponde a LOW.

As duas variáveis comparadas representam estados estáveis, não leituras momentâneas.

O tratamento anterior produz pressionou e soltou somente na passagem atual por loop(). Agora, o comando da saída precisa de outra memória, persistente:

• estadoEstavel descreve o botão aceito pelo programa.
• pressionou e soltou descrevem transições confirmadas nesta passagem.
• ledIntegradoLigado registra o estado que o LED deve manter até surgir outro pressionamento confirmado.

O LED não deve usar o nível do botão como sua memória. Ele muda quando consome o evento pressionou.

Acrescente a variável global junto das demais declarações persistentes. No setup() já existente, acrescente a configuração e o comando inicial do LED. Por fim, coloque o último bloco dentro do loop() do step anterior, depois do código que pode definir pressionou e soltou.

A condição é avaliada muitas vezes, mas pressionou só vale true na passagem que confirmou a transição para LOW. Nas passagens seguintes, mesmo com o botão mantido pressionado, ele volta a false; portanto, não há outra inversão.

Não use if (estadoEstavel == LOW) para alternar. Enquanto o botão estiver pressionado, essa condição continuará verdadeira em todas as passagens pelo loop() e inverteria o LED repetidamente.

Complete a condição que consome o evento correto. O LED deve alternar ao confirmar o pressionamento, não durante a manutenção do botão nem na soltura.

Partindo com ledIntegradoLigado = false, considere que cada transição abaixo já foi confirmada pelo intervalo de estabilidade. Qual comportamento o LED integrado terá ao pressionar, manter pressionado, soltar e pressionar novamente?

Com a alimentação desconectada, mantenha o botão entre D2 e GND; o sketch usará INPUT_PULLUP. Para a segunda tarefa, monte o LED externo: D7 → resistor de 1 kΩ → ânodo do LED vermelho. Ligue o cátodo do LED ao GND.

Confira a polaridade e os jumpers antes de alimentar. Use somente uma alimentação USB compatível no Uno R3. Não conecte fonte externa a VIN nem ao pino 5V durante esta prática.

Crie um novo sketch na IDE Arduino local e copie primeiro estas declarações. Elas mantêm as memórias do botão já usadas nos steps anteriores e acrescentam uma marca de tempo e um estado próprios para o LED externo.

Em seguida, copie o setup(). A leitura inicial é adotada como condição de partida: ela inicializa as memórias do botão, mas não cria um evento de pressionamento.

Complete o sketch com este loop(), grave-o no Uno R3 e observe a montagem. As duas verificações temporais usam referências diferentes: uma é reiniciada por mudança observada no botão; a outra somente quando o LED externo alterna.

Não há delay() nem laço de espera. Em toda passagem pelo loop(), o programa lê o botão, verifica se ele ficou estável, eventualmente consome o evento e também verifica se já é hora de alternar D7. Uma tarefa não precisa esperar a outra terminar.

Complete cada referência de tempo com a variável que pertence à tarefa indicada. As duas condições são avaliadas repetidamente no mesmo loop().

O intervalo de estabilidade não é uma duração universal de rebote. Ele é um parâmetro do seu ensaio: deve ser grande o bastante para não aceitar oscilações do botão como comandos e pequeno o bastante para a resposta continuar adequada.

Uma janela curta pode confirmar uma oscilação indesejada. Uma janela longa aumenta a demora entre pressionar e gerar o evento — e pode rejeitar uma pressão muito breve. O programa continua atendendo o restante do loop() nos dois casos; o que muda é o critério para aceitar a transição.

Faça ensaios no seu Uno R3 com a mesma sequência: dê alguns toques breves, faça uma pressão mantida por cerca de um segundo, solte e pressione novamente. Altere somente o intervalo de estabilidade usado no sketch; experimente, por exemplo, 10 ms, 30 ms e 60 ms.

Observe o LED integrado, que muda pelo evento de pressionamento, e o LED externo periódico. Eles servem para verificar o comportamento funcional. Não permitem medir com precisão o rebote nem provar que toda falha possível seria detectada.

O fluxo que você vai validar

Em cada passagem por loop(), o programa:

1. lê o botão;
2. reinicia a janela de estabilidade se a leitura mudou;
3. aceita um novo estado estável somente após o intervalo configurado;
4. emite um evento apenas na transição estável de HIGH para LOW;
5. alterna o LED integrado ao consumir esse evento.

A leitura pode oscilar durante o rebote, mas o evento só existe em uma passagem pelo loop(). Por isso, manter o botão pressionado não cria novas alternâncias.

Faça os ensaios na sua montagem do Uno R3 com o sketch integrado do step anterior. Observe o LED integrado, controlado pelo evento de pressionamento, e o LED externo em D7, que deve continuar alternando aproximadamente a cada 500 ms.

Anote o valor de INTERVALO_ESTAVEL que está no sketch antes de começar. Não acrescente delay() para testar o botão.

Complete as condições do mesmo algoritmo usado no sketch integrado. A janela deve reiniciar diante de uma leitura diferente; o LED só pode receber o evento quando a transição estável confirmada for de HIGH para LOW.