AVRFreaks.net

char debouncePA1(void)
{
  char ones=0, zeroes=0, i;
  for(i=0;i<9;i++){
    if(PINA&0x01){ // read pin == 1
      ones++;
    } else { // read pin == 0
      zeroes++;
    }
  _delay_ms(10);
  }
  return ones>zeroes;
}

/*

THE ULTIMATE SOFTWARE DEBOUNCER         

Program: debounce.asm
Version: 1.0
Date:    5/5/2005
Author:  Elio Mazzocca
E-mail:  jnz9876@adam.co.uk

micro used: ATmega8 with internal 4 MHz oscillator
assembled with: AVR Studio 4.0
Timer0 interrupt period: 4 mSEC

Description: This is a 1st order recursive digital filter
   with Schmitt trigger output that filters noisy
   digital inputs to ATmega8 microcontroller.
   The formula employed for the recursive filter:

   ynew = 1/4 xnew + 3/4 yold

   Formula for an inverting Schmitt trigger:

   if(ynew>hi) and (flag=0) then flag=1; vout=1;
   if(ynew<lo) and (flag=1) then flag=0; vout=0;

Use:      The code is placed in Timer0 interrupt routine
   with a 4 mSEC period. The output of the trigger
   is continuously checked in the main program loop
   The interrupt routine checks the PORT bit and
   applies either 0 (keypress) or $3F to the digital
   filter, the output value is then applied to a
   Schmitt trigger with thresholds of 15, 240 for
   an effective "time constant" of 11 interrupts.
   Program requires 11 ints, 19/18 machine cycles,
  6 ints if schmitt threshold is $3C instead of $0F

;
.NOLIST
.INCLUDE "AvrAssembler2\appnotes\m8def.inc"
.LIST

; Register defines

.DEF   yold = R17         ; old/new filter output value, share same reg
.DEF   tmp  = R18         ; new input to filter value/threshold reg
.DEF    flag = R19
.DEF    VOUT = R20

.CSEG
.ORG $0000
   rjmp    Reset   

.ORG OVF0addr
   rjmp   tim0_ovf      ; Timer0 overflow handler

Reset:   
   ldi   R16,   LOW(RAMEND)    ; Initiate Stackpointer
   out   SPL,   R16       ; for use by interrupts
   ldi   R16,   HIGH(RAMEND)
   out   SPH,   R16
                        
   ldi   R16,   (1<<CS01)|(1<<CS00)  ; Fosc = 4 MHz
   out   TCCR0,   R16       ; set Timer/Counter0 Prescaler=64, int = 16x256 uSEC

   ldi   R16,   (1<<TOIE0)    ; set timer0 interrupt enable
   out   TIMSK,   R16       ; in the Timer Interrupt Mask Register
   ldi     R16,    (1<<TOV0)      ; clr pending interrupts
    out     TIFR,   R16      

   ser   tmp
   out   DDRB,   tmp      ; set PORTB = output
   clr   tmp
   out     DDRD,   tmp      ; set PORTD = input
   ser     tmp
   out     PORTD,  tmp      ; turn on PORTD pull-ups
 
   ldi   yold,   $FF      ;optional
   sei            ; enable interrupts
loop:               ; main program loop
   sbrs    VOUT,   0      ; if schmitt out = 1
   rjmp   a1
   sbi     PORTB,  0      ; then set PORTB, bit 0 - LED on
   rjmp    loop
a1:
   cbi     PORTB,  0      ; else clear PORTB, bit 0 - LED off
       rjmp    loop
;------------------------------------------------------------------------
tim0_ovf:
    mov     tmp,    yold      
   lsr     tmp
   lsr     tmp         ; tmp = 1/4 yold
   sub     yold,   tmp      ; 3/4 yold is in left in reg yold
   ldi     tmp,    $3F      ; re-use tmp register for xnew
   sbis    PIND,   0      ; if PIND bit 0 = 0, then input = 1/4 xnew
   clr     tmp
   add   yold,   tmp      ; yold same as ynew, saves 1 instruction/register !

.UNDEF tmp             ; re-use tmp register as threshold reg.
.DEF   thresh = R18   
               ; now apply filter output to schmitt trigger
   ldi     thresh, $0F      ; load lo thresh into threshold register
   sbrc   flag,   0         ; test bit 0 of flag register
   rjmp    s1               
   cp      yold,   thresh
   brsh    s1
   sbr     flag,   (1<<0)      ; set bit 0 of register flag
   sbr     VOUT,   (1<<0)      
s1:
    swap    thresh         ; to test hi thresh, swap nibbles
   cp      yold,   thresh
   brlo    s2
   cbr     flag,   (1<<0)
   cbr     VOUT,   (1<<0)      ; clear bit 0 of register VOUT
s2:
   reti            ; 19/18 (nokeypress/keypress) machine cycles
;------------------------------------------------------------------------
.EXIT

// ---------- In header file ----------
#define KEY_UP         6
#define KEY_DN         7

// Pins
#define KEY_PINS       PIND

// Macros
#define KEY_DN_PRESS   (~(KEY_PINS) & (1<<KEY_DN))
#define KEY_UP_PRESS   (~(KEY_PINS) & (1<<KEY_UP))

// ---------- In main file ----------
int8_t read_keys(void) {
   if(KEY_UP_PRESS) {
      _delay_ms(10);
      while(KEY_UP_PRESS);      // Wait for key to be released
      _delay_ms(10);
      return 1;
   }
   if(KEY_DN_PRESS) {
      _delay_ms(10);
      while(KEY_DN_PRESS);
      _delay_ms(10);
      return -1;
   }
   else return 0;
}

/************************************************************************
;*                                                                      *
;*              Testing Read and debounce up to 8 keys                  *
;*              Bulletproof: 4 equal samples needed                     *
;*                                                                      *
;*              Author: P. Dannegger                                    *
;*                                                                      *
;***********************************************************************/
#include <io.h>
#include <interrupt.h>
#include <signal.h>

#define KEY_INPUT       PINC
#define LED_OUTPUT      PORTB
#define LED_DIR         DDRB

char key_state;                         // debounced and inverted key state:
                                        // bit = 1: key pressed
char key_press;                         // key press detect


SIGNAL (SIG_OVERFLOW0)
{
  static char ct0, ct1;
  char i;

  i = key_state ^ ~KEY_INPUT;           // key changed ?
  ct0 = ~( ct0 & i );                   // reset or count ct0
  ct1 = ct0 ^ (ct1 & i);                // reset or count ct1
  i &= ct0 & ct1;                       // count until roll over ?
  key_state ^= i;                       // then toggle debounced state
                                        // now debouncing finished
  key_press |= key_state & i;           // 0->1: key press detect
}


char get_key_press( char key_mask )
{
  cli();
  key_mask &= key_press;                // read key(s)
  key_press ^= key_mask;                // clear key(s)
  sei();
  return key_mask;
}


int main( void )
{
  key_state = 0;
  key_press = 0;

  TCCR0 = 1<<CS02;                      //divide by 256 * 256
  TIMSK = 1<<TOIE0;                     //enable timer interrupt

  LED_DIR = 0xFF;
  LED_OUTPUT = 0xFF;
  sei();
  for(;;)                                       // main loop
    LED_OUTPUT ^= get_key_press( 0xFF );        // toggle LEDs on key press
}

;*************************************************************************
;*                                                                       *
;*              Testing Read and debounce up to 8 keys                   *
;*              Bulletproof: 4 equal samples needed                      *
;*                                                                       *
;*              Author: P. Dannegger                                     *
;*                                                                       *
;*************************************************************************
.nolist
.include "c:\avr\inc\1200def.inc"
.list
.def    save_sreg       = r0
.def    iwr0            = r1

.def    key_ct0         = r2
.def    key_ct1         = r3
.def    key_state       = r4
.def    key_press       = r5

.def    leds            = r16
.def    wr0             = r17

.equ    key_port        = pind
.equ    led_port        = portb

        rjmp    init
        .org    OVF0addr                ;timer interrupt 6ms
        in      save_sreg, SREG
get8key:
        in      iwr0, key_port
        com     iwr0
        eor     iwr0, key_state
        and     key_ct0, iwr0
        and     key_ct1, iwr0
        com     key_ct0
        eor     key_ct1, key_ct0
        and     iwr0, key_ct0
        and     iwr0, key_ct1
        eor     key_state, iwr0
        and     iwr0, key_state
        or      key_press, iwr0
;
;                       insert other timer functions here
;
        out     SREG, save_sreg
        reti
;-------------------------------------------------------------------------
init:
        ldi     wr0, 0xFF
        out     ddrb, wr0
        ldi     wr0, 1<<CS02^1<<CS00            ;divide by 256 * 256
        out     TCCR0, wr0
        ldi     wr0, 1<<TOIE0           ;enable timer interrupt
        out     TIMSK, wr0

        clr     key_state
        clr     key_press
        ldi     wr0, 0xFF
        mov     key_ct0, wr0
        mov     key_ct1, wr0
        ldi     leds, 0xFF
main:   cli
        eor     leds, key_press         ;toggle LEDs
        clr     key_press               ;clear, if key press action done
        sei
        out     led_port, leds
        rjmp    main
;-------------------------------------------------------------------------

#include <avr/io.h>
#include <avr/interrupt.h>

#define LED1OFF          PORTC |= (1<<5)
#define LED1ON           PORTC &= ~(1<<5)

//Functions
void init_hardware(void);
unsigned char DebounceSwitch(void);
unsigned char RawKeyPressed(void);

//Global variables
unsigned char on_btn;
unsigned char ButtonStatus;
unsigned char LedStatus;

int main (void)
{
   on_btn = 0;
   ButtonStatus = 0;

   init_hardware();
   LED1OFF;
   sei(); //  Enable global interrupts

   for (;;)
   {
    if (ButtonStatus)
   {
    if (LedStatus)
     {
        LED1OFF;
       LedStatus=0;
      }
      else
      {
      LED1ON;
      LedStatus=1;
      }
    }
   }
}

// Timer1 Compare match A interrupt
ISR(TIMER1_COMPA_vect)
{
 ButtonStatus = DebounceSwitch();
}

unsigned char RawKeyPressed(void)
{
 on_btn = ~PINC & (1<<3);
 return on_btn;
}

void init_hardware(void)
{
// PB3 As Output pin
    DDRB |= 1<<DDB3;

 // PC4,5 As Output pin
   DDRC |= 1<<DDC4;
   DDRC |= 1<<DDC5;

 // PC2,3 As Input pin
    DDRC &= ~(1<<2);
   DDRC &= ~(1<<3);

 // PC2,3 Activate internal pullUp resistor
    PORTC |= 1<<DDC2;
    PORTC |= 1<<DDC3;

// Timer setup

 // Configure timer 1 for CTC mode
    TCCR1B |= (1 << WGM12);

// Enable CTC interrupt
    TIMSK |= (1 << OCIE1A);

// Set CTC compare value to 5ms at 1MHz AVR clock, with a prescaler of 8
    OCR1A   = 625;

// Start timer at Fcpu/8
   TCCR1B |= ((1 << CS10));

}

// Service routine called by a timer interrupt
unsigned char DebounceSwitch(void)
 
{
 static uint16_t State = 0; // Current debounce status
 State=(State<<1) | !RawKeyPressed() | 0xe000;
 if(State==0xf000)return 1;
 return 0;
}
 

volatile char state;
....
ISR code
state<<=1;
if (PINC & (1<<2))  /we'll assume portc.2 as the input
   {
    State |= 1;
   }

 if (State ==0xff)
    {
    //switch is pressed - has been active for the last 8 ticks (40ms)
    }

if(get_key_press(1 << SW0))
      {
         OUTPUT_PORT ^= (1 << OUT0);       //Turn OUT0 On
      }

#define F_CPU 8000000UL   //Define CPU Clock Speed 8MHz

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <util/atomic.h>   // need "--std=c99"

typedef unsigned char   u8;
typedef signed short   s16;

#define INPUT_PIN    PIND
#define INPUT_PORT   PORTD
#define INPUT_DDR    DDRD

#define SWO   PD0
#define SW1   PD1
#define SW2   PD2
#define SW3   PD3
#define SW4   PD4
#define SW5   PD5
#define SW6   PD6
#define SW7   PD7
      
#define OUTPUT_DDR    DDRB
#define OUTPUT_PORT   PORTB

#define OUT0   PB0
#define OUT1   PB1
#define OUT2   PB2
#define OUT3   PB3
#define OUT4   PB4
#define OUT5   PB5
#define OUT6   PB6
#define OUT7   PB7

u8 input_state;      //Debounced and inverted key state:
                     //Bit = 1: key pressed
u8 input_press;      //Key Press Detected


ISR(TIMER1_COMPA_vect)            //every 10ms
{
   static u8 ct0 = 0xFF, ct1 = 0xFF;  // 8 * 2bit counters
   u8 i;

   i = ~INPUT_PIN;              // read keys (low active)
   i ^= input_state;            // key changed ?
   ct0 = ~(ct0 & i);            // reset or count ct0
   ct1 = ct0 ^ (ct1 & i);       // reset or count ct1
   i &= ct0 & ct1;              // count until roll over ?
   input_state ^= i;            // then toggle debounced state
   input_press |= input_state & i;   // 0->1: key press detect
}


u8 get_key_press(u8 input_mask)
{
   ATOMIC_BLOCK(ATOMIC_FORCEON)   // read and clear atomic!
   {
   input_mask &= input_press;         // read key(s)
   input_press ^= input_mask;         // clear key(s)
   }
   return input_mask;
}


int main(void)
{
   TCCR1B |=   (1 << WGM12);         //Timer1 Mode 2: CTC
   TCCR1B |=   (1 << CS12);          //Divide by 256
   OCR1A    =   F_CPU / 256 * 10e-3; //Set CTC compare value to 10ms at 8MHz AVR clock, with a prescaler of 256
   TIMSK1 =   (1 << OCIE1A);         //Enable T1 interrupt

   INPUT_DDR  = 0x00;                //Sets INPUT_DDR to be input
   INPUT_PORT = 0xFF;                //Enables pull up resistors on INPUT_PORT
   
   OUTPUT_DDR    = 0xFF;             //Sets OUTPUT_DDR to be output
   
   input_state    = ~INPUT_PIN;      //no action on keypress during reset
   
   sei();

   while(1)
   {
      if(get_key_press(1 << SW0))
      {
         OUTPUT_PORT |= (1 << OUT0);       //Turn OUT0 On
      }
      else if(get_key_press(1 << SW1))
      {
         OUTPUT_PORT |= (1 << OUT1);       //Turn OUT1 On
      }
      else if(get_key_press(1 << SW2))
      {
         OUTPUT_PORT |= (1 << OUT2);       //Turn OUT2 On
      }
      else if(get_key_press(1 << SW3))
      {
         OUTPUT_PORT |= (1 << OUT3);       //Turn OUT3 On
      }
      else if(get_key_press(1 << SW4))
      {
         OUTPUT_PORT |= (1 << OUT4);       //Turn OUT4 On
      }
      else if(get_key_press(1 << SW5))
      {
         OUTPUT_PORT |= (1 << OUT5);       //Turn OUT5 On
      }
      else if(get_key_press(1 << SW6))
      {
         OUTPUT_PORT |= (1 << OUT6);       //Turn OUT6 On
      }
      else if(get_key_press(1 << SW7))
      {
         OUTPUT_PORT |= (1 << OUT7);       //Turn OUT7 On
      }
      else
      {
         OUTPUT_PORT &= ~(1 << OUT0);      //Turn OUT0 Off
         OUTPUT_PORT &= ~(1 << OUT1);      //Turn OUT1 Off
         OUTPUT_PORT &= ~(1 << OUT2);      //Turn OUT2 Off
         OUTPUT_PORT &= ~(1 << OUT3);      //Turn OUT3 Off
         OUTPUT_PORT &= ~(1 << OUT4);      //Turn OUT4 Off
         OUTPUT_PORT &= ~(1 << OUT5);      //Turn OUT5 Off
         OUTPUT_PORT &= ~(1 << OUT6);      //Turn OUT6 Off
         OUTPUT_PORT &= ~(1 << OUT7);      //Turn OUT7 Off
      }
   }
}

ISR(TIMER1_COMPA_vect)            //every 10ms
{
   static u8 ct0 = 0xFF, ct1 = 0xFF;  // 8 * 2bit counters
   u8 i;

   i = ~INPUT_PIN;              // read keys (low active)
   i ^= input_state;            // key changed ?
   ct0 = ~(ct0 & i);            // reset or count ct0
   ct1 = ct0 ^ (ct1 & i);       // reset or count ct1
   i &= ct0 & ct1;              // count until roll over ?
   input_state ^= i;            // then toggle debounced state
   input_press |= input_state & i;   // 0->1: key press detect
}


u8 get_key_press(u8 input_mask)
{
   ATOMIC_BLOCK(ATOMIC_FORCEON)   // read and clear atomic!
   {
   input_mask &= input_press;         // read key(s)
   input_press ^= input_mask;         // clear key(s)
   }
   return input_mask;
}