Por definição, quando apertamos um botão, o qual possui um contato mecânico, é gerada uma série de ruidos aleatórios chamados de spikes. Ou seja, a tensão instantânea sobre o botão pode ser qualquer valor, entre os valores que seriam obtidos com o botão em repouso e com o botão ligado após um tempo longo.
A duração desses spikes é pequena, geralmente na ordem de milisegundos, mas o efeito prático é o de que durante esses poucos milissegundos, uma leitura efetuada nesse botão pode interpretar que ele está ligado ou desligado, devido aos ruidos aleatórios que são gerados pelo contato mecânico.
Porém, para um microprocessador, alguns milissegundos são uma eternidade, ou seja, por exemplo, após detectar que o botão foi acionado, mediante UMA ÚNICA LEITURA DO BOTÃO, nosso programa pode executar as funções correspondentes e voltar ao mesmo ponto anterior da leitura do botão, EM MENOS DE 1 milissegundo !!!!
Assim, o efeito que temos é que em vez de o nosso programa interpretar que apertamos o botão APENAS 1 VEZ, ele pode acabar interpretando que apertamos o botão mais de 20 vezes em seguida !!!!!
Claro que dependendo do programa, o resultado pode ser catastrófico !
Na verdade, o termo "DEBOUNCING" significa uma técnica que nos dê certeza de que o botão apertado apenas uma vez seja interpretado corretamente como apenas UM aperto de botão.
Por outro lado, se apertarmos o mesmo botão por 5 vezes seguidas em um segundo, o nosso programa tem de conseguir ler corretamente 5 apertos de botão !
Quando trabalhando com Interrupções, não devemos colocar delay nas rotinas de tratamento das interrupções. Então como podemos nos adequar a esta situação?
Fazendo o "debouncing" de Hardware;
Antes:
Depois:
com R em KO
C em uF
e T em segundos(s)
Assim, quando pressionado o botão, o sinal leva alguns milisegundos para estabilizar em um valor lógico e aí o processador pode identificar corretamente se o botão foi apertado ou não......
Porém temos o problema de delay, o tempo para o circuito reconhecer o sinal.
R = 10KO
C = 10uF
T = .1s
O circuito ao lado Simplismente gera uma onda quadrada na saída, não dependendo de tempo de pressionamento do botão.
Ideal para usar com microprocessadores rápidos.
Quando não temos problemas com Interrupções ou delay, podemos usar o "Debouncing" por software (ou simplesmente os dois em conjunto).
Abaixo um exemplo de código para este "Debouncing".
int switchPin = 2;
int ledPin = 13;
boolean lastButton = LOW; //variável representando o último estado do botão
boolean ledOn = false; //variável representando o estado do LED
void setup()
{
pinMode(switchPin, INPUT);
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
}
void loop()
{
Serial.println(digitalRead(switchPin));
if (digitalRead(switchPin) == HIGH && lastButton == LOW)
{ //se último estado do botão éra "baixo" e a leitura atual do botão indica "alto"
ledOn = !ledOn; //inverte estado do LED
lastButton = HIGH; //coloca último estado do botão como "alto"
}
else //caso contrário:
{
//lastButton = LOW; //coloca último estado do botão como "baixo"
lastButton = digitalRead(switchPin); //coloca o valor atual do botão na variável de último estado do botão
}
digitalWrite(ledPin, ledOn); //escreve o valor de estado do LED no pino referente
}
Um programinha simples mas muito eficaz.
Visite: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1244509204/6 para informações sobre como fazer o "Debouncing" de um reed Switch.
E http://www.arduino.cc/playground/Code/Bounce para informações sobre a biblioteca "Debounce"
Bom espero que este pequeno tutorial, possa ajudar com o problema de "Bounce" referente ao tratamento de informações provenientes de botões .
Até o próximo Post!
Nenhum comentário:
Postar um comentário