AVR Button Interfacing

Debouncing is something you must be familiar with when using buttons. When a contact closes, it does not just close, but bounces back a few times until it finally settles in its closed position.

Depending on how fast your sampling code is, the code can count many button presses, although you only moved your finger once. There are a number of debouncing strategies around. Search www.avrfreaks.net for debouncing and you will find plenty of posts. Most of the recent threads contain a link to some pretty good old examples/strategies which you can use.

This might not be the only problem with your code - but we can only know that when we've seen the code. Post it here or on avrfreaks and we might be able to help you.

Are you enabling internall pullup resistors for your inputs or using external pullups?

Connect your button this way:

MCU pin PB0 -> button -> GND

The something like this should work:

DDRB &= ~_BV(PB0); //set PB0 to input PORTB |= _BV(PB0); //enable pullup on input while(1) { if(!(PINB & _BV(PB0))) { //PINB will have PB0 set to 0 on button press //do whatever you like _delay_ms(150);//wait a bit while the button is bouncing while(!(PINB & _BV(PB0))); //do nothing while the button is still pressed } } 

Please note, this is not a good proper way to do it, it's just the most simple foolproof way to get you started. After you get thru this, lookup numerous proper button debouncing techniques and ask more specific questions here.

To start, a button would typically connect to ground when it is pushed. The microcontroller pin should be set as an input with the internal pull up resistor enabled. There is no need to use external components here. If the pin reads LO, then the button was pushed. I usually use small tactile buttons in my designs, and I have never had them bound for more than a few milliseconds. With that in mind, it is also easy to know how long a button has been pressed so you can actually have different actions for a short press or a long press. For a simple example, in the following code, the state of a set of pins is continuously polled in MAIN. When a button is pressed, the program will delay for a specified amount of time before rechecking the buttons and doing something useful.

#define MS_DEBOUNCE 10 // Time in ms to debounce button DDRC = 0x00; // Set All as Inputs PORTC = 0xFF; // Inputs: Pulls Ups Enabled if(!(PINC & BUTTON){ // If Some Button is pressed... delay_ms(MS_DEBOUNCE); // Delay to debounce button if(!PINC & BUTTON){ // If Button is Still Pressed... //... Do Something useful here ... } } while(!(PINC & BUTTON)); // This will loop until the button has been released. 

This is a very simple example that has always worked well for me. To actually count the press duration, I would set a global flag before a final while loop to alert a routine in a timer ISR. This ISR would then count up until the button has been released. After so long, a different action can take place. For example (in MAIN, in place of the above while loop):

stat_flag |= BUTTON_PRESS; // Set Bit to enter loop duration_cnt = MS_HOLD; // Preset duration counter while(stat_flag & BUTTON_PRESS); // Loop until button released 

Then, in a 1ms timer ISR, I would do something like the following. If will count down from the specified "MS_HOLD" time. If after such time, the button is still pressed, then take an additional "long press" action. This could be done in place of the short press, or could be repeated indefinitely as long as the button is still held, such as holding a volume button, the volume will increase every so many ms.

if(duration_cnt){ // Button was pressed if(--duration_cnt == 0){ // Counter has expired if(PINC != DEFAULT_PINS){ // Some button is still pressed //... Do something useful for long press } else{ // No Buttons being pressed stat_flag &= ~BUTTON_PRESS; // Reset flag to exit delay loop } } }