8 bit parallel debounce routine

Here is a debounce routine that just works. It will process up to 8 inputs in parallel. It works using something called vertical counters. I would try to explain them, but will fail so I suggest googling them as there is some really good information out there. I did not write this myself, I found the ASM version over on the Piclist - link in the code header.

The nuts and bolts are just some tricky boolean math. The usage goes like this:

Inputs to be de-bounced are placed in a variable called SWKEYS.
Using your favorite timebase technique, call DB8 every 1mSec (not real critical)
Upon return all de-bounced states will be in SLATCH.

So in your program, check the bits of SLATCH to decide if an input has changed. At 1mSec timbase, it will take 24mSec to get a valid input. If this is too fast for your switches, just adjust the timebase.

You can paste all the code into your program, or just include it.

Code:

---

;######################################################
; The purpose of this code is to debounce up to 8 switch
;inputs in parallel. It could be called from you main with either
;an ISR or or my favorite is to set up a counter for 1 mSec and poll
;it's int flag.
; It will take 24 iterations of this code to call a switch debounced. So
;if your timer is 1mSec, it will be a 24mSec debounce + any short elapsed
;time from the timer overflow and the call to here.
; To use this, just "include" the file, then assign up to 8 switches to
;SWKEYS. When the program returns, you will have the debounced switches in
;SLATCH. If you poll a PIF to call this, don't forget to clear the flag
;upon return. Suggested code:
; IF PIF then
;    gosub DB8
;    PIF = 0
; ENDIF
; This compiles to ~50 words so not much space taken.
; This program is a direct conversion from this:
;  http://www.piclist.com/techref/micro...toggleK8HL.htm
; There is lots of good info there and even better if one googles
;            Vertical Counters
 
SWKEYS var byte  ;Actual switch data
SLATCH var byte  ;This is the debounced switch states
VCBIT0 var byte  ;Vertical counter bit 0
VCBIT1 var byte  ;Vertical counter bit 1
COLPOS var byte  ;This is a shift reg. 1 is shifted at each loop
VCMASK var byte  ;Vertical counter mask
TEMP  VAR BYTE  ;Just a temp needed for the counting
 
DB8:             
        TEMP = SWKEYS ^ SLATCH 
        VCBIT0 = TEMP & VCBIT0
        VCBIT1 = TEMP & VCBIT1
        VCMASK = TEMP & COLPOS ; 8-msec 'column' prescaler   
                              ;seed "cumulative AND" mask   
        VCBIT0 = VCBIT0 ^ VCMASK ; b0 ^= vcmask                 
        TEMP = TEMP ^ VCBIT0    ; restore b0' in W             
        VCMASK = VCMASK & TEMP  ; vcmask &= b0'                 
 
        VCBIT1 = VCBIT1 ^ VCMASK ; b1 ^= vcmask                 
        TEMP = VCBIT1 ^ TEMP    ; restore b1' in W             
        TEMP = TEMP & VCMASK    ; vcmask &= b1'                 
 
        SLATCH = SLATCH ^ TEMP  ; update debounced state latch 
 
;#################################################################
;  advance ring counter prescaler
;  for the next interrupt cycle
        COLPOS = COLPOS<<1      ; advance column ring counter   
        IF COLPOS = 0 THEN COLPOS = 1
;#################################################################       
Return

---

And here is a quick snippet to test it with:

Code:

---

####################
insert device setup stuff here
####################
 
goto myinit
 
include "debounce8.pbp"
 
myinit:
mainloop:
    pause 1
    swkeys = portb
    gosub DB8
    porta = slatch
 
goto mainloop

---

Of course the above assumes you will save the de-bounce program as debounce8.pbp