PIC Microcontroler based Keyboards

The hardware consists of a PIC 16C84 or PIC 16F84, a 16 key xy matrix keypad, a 4.00 Mhz resonator with built-in caps, a red and a green LED, 2 330 ohm resistors, 1 4.7K resistor, 1 10K resistor, a printed circuit board, 10 pin header, one general purpose NPN transistor such as MPSA05, and one 5 V PCB DPDT Relay.

keypad.dwg - AutoCad schematic

keypad.dxf - dxf format of AutoCad drawing

;			KEYPAD.ASM
;                       written by
;                    Fr. Thomas McGahee
;             Don Bosco Technical High School
;                      202 Union Ave.
;                   Paterson, NJ  07502
;                tom_mcgahee@sigmais.com
;
;                       March, 1997


;                Microchip MPASM format
;           Specifically designed for PIC16C84
;              but will also run on 16F84
;                   with minor changes
;
; note: written in all lower case so case sensitivity doesn't matter.
; however: set assembler to case-insensitive, except within strings using /c- option
;


;
; directives
;
; search for ### to locate items that need to be changed if using the 16f84
; instead of the 16c84




		list		p=16c84		;this directive must come first
						;### p=16f84 if using 16f84




; instead of using the [ include <16c84.inc> ] directive, we have placed the 
; contents of the microchip-supplied include file below for documentation purposes.
;
; this section defines configurations, registers, and other useful bits of
; information for the pic16c84 microcontroller.  these names are taken to match 
; the latest data sheets as closely as possible.  


; note that the processor must be selected before this file is 
; included.  the processor may be selected the following ways:


;       1. command line switch:
;               c:\ mpasm myfile.asm /pic16c84
;       2. list directive in the source file	;(this is the method chosen here)
;               list   p=pic16c84		;### 16c84.
;       3. processor type entry in the mpasm full-screen interface


;==========================================================================
;
;       revision history
;
;==========================================================================


;rev:   date:    reason:


;1.00   10/31/95 initial release


;==========================================================================
;
;       verify processor
;
;==========================================================================


        ifndef __16c84	;### 16c84. change to ifndef __16f84 if using 16f84
           messg "processor-header file mismatch.  verify selected processor."
        endif


;==========================================================================
;
;       register definitions
;
;==========================================================================


w                            equ     h'0000'
f                            equ     h'0001'


;----- register files------------------------------------------------------


indf                         equ     h'0000'
tmr0                         equ     h'0001'
pcl                          equ     h'0002'
status                       equ     h'0003'
fsr                          equ     h'0004'
porta                        equ     h'0005'
portb                        equ     h'0006'
eedata                       equ     h'0008'
eeadr                        equ     h'0009'
pclath                       equ     h'000a'
intcon                       equ     h'000b'


option_reg                   equ     h'0081'
trisa                        equ     h'0085'
trisb                        equ     h'0086'
eecon1                       equ     h'0088'
eecon2                       equ     h'0089'


;----- status bits --------------------------------------------------------


irp                          equ     h'0007'
rp1                          equ     h'0006'
rp0                          equ     h'0005'
not_to                       equ     h'0004'
not_pd                       equ     h'0003'
z                            equ     h'0002'
dc                           equ     h'0001'
c                            equ     h'0000'


;----- intcon bits --------------------------------------------------------


gie                          equ     h'0007'
eeie                         equ     h'0006'
t0ie                         equ     h'0005'
inte                         equ     h'0004'
rbie                         equ     h'0003'
t0if                         equ     h'0002'
intf                         equ     h'0001'
rbif                         equ     h'0000'


;----- option bits --------------------------------------------------------


not_rbpu                     equ     h'0007'
intedg                       equ     h'0006'
t0cs                         equ     h'0005'
t0se                         equ     h'0004'
psa                          equ     h'0003'
ps2                          equ     h'0002'
ps1                          equ     h'0001'
ps0                          equ     h'0000'


;----- eecon1 bits --------------------------------------------------------


eeif                         equ     h'0004'
wrerr                        equ     h'0003'
wren                         equ     h'0002'
wr                           equ     h'0001'
rd                           equ     h'0000'


;==========================================================================
;
;       ram definition
;
;==========================================================================


        __maxram h'af'
        __badram h'07', h'30'-h'7f', h'87' ;### 16c84.
;(__badram h'07', h'50'-h'7f', h'87' ;use *this* one if using 16f84)


;==========================================================================
;
;       configuration bits
;
;==========================================================================


_cp_on                       equ     h'3fef'
_cp_off                      equ     h'3fff'
_pwrte_on                    equ     h'3fff'
_pwrte_off                   equ     h'3ff7'
_wdt_on                      equ     h'3fff'
_wdt_off                     equ     h'3ffb'
_lp_osc                      equ     h'3ffc'
_xt_osc                      equ     h'3ffd'
_hs_osc                      equ     h'3ffe'
_rc_osc                      equ     h'3fff'


;end of <include> file stuff




;==============================================================================
; set configuration bits
;==============================================================================


;we have to set the configuration bits
;	__config a & b & c 
;       _rc_osc, _xt_osc, _hs_osc, _lp_osc oscillator type
;       _wdt_on, _wdt_off watchdog timer
;       _cp_on, _cp_off code protect
;       _pwrte_on, _pwrte_off power up timer enable


		__config 	_xt_osc & _wdt_off & _pwrte_on & _cp_off




;==============================================================================
; some constant equates
;==============================================================================


; note use of 4.00 mhz xtal. this will affect timing loops


xtal_freq	=		d'4000000'	;crystal frequency
clock		=		xtal_freq/4	;base operating frequency






;==============================================================================
; pic16c84 pinouts and hardware details
;==============================================================================




;               pic16c84 pinouts
;
;       ra2     <1>     <18>    ra1
;       ra3     <2>     <17>    ra0
;  (oc) ra4/tmr0<3>     <16>    osc1/clkin	
;       !mclr!  <4>     <15>    osc2/clkout
;       gnd     <5>     <14>    +2 to +6 volts
;       rb0/int <6>     <13>    rb7
;       rb1     <7>     <12>    rb6
;       rb2     <8>     <11>    rb5
;       rb3     <9>     <10>    rb4
;
;osc1 & osc2 using 4.00 mhz ceramic resonator or xtal with 20 pf caps on each lead.
;
;!mclr! tied high via 10K. use a switch to force it low for manual reset.


;porta assignments


;ra4 and ra3 are not used in this design.


;ra0 is connected to cathode of green led with 330 ohm to +5.
;ra1 is connected to cathode of red led with 330 ohm to +5.
;ra2 is connected to 1K to base of npn. npn drives 5v relay.
;coil of relay is shunted with diode. cathode to v+, anode to npn collector.
;common and normally open contacts of relay are used to control door opener.


;==============================================================================
; porta *bit* assignments
;==============================================================================


n_red		equ	0	;low on ra0 turns red led on
n_green		equ	1	;low on ra1 turns green led on
relay		equ	2	;high on ra2 turns relay on
ra3		equ	3	;**not used**
ra4		equ	4	;**not used**


;==============================================================================
; portb *bit* assignments
;==============================================================================


;rb7-rb0 are ttl. weak pullups are programmed using option_reg<7>=0
;rb7-rb4 assigned as *inputs*
;rb7-rb4 will generate an interrupt. set intcon<3> rbie=1. intcon<0> rbif is flag. software reset.
;
;rb3-rb0 are assigned as *outputs*. low is output to "scan" the inputs of the keypad.


;==============================================================================
; keypad details
;==============================================================================


;keypad layout (grayhill 8622 with additional marking 8637. 8 pins)
;pin numbers of keypad shown in <> brackets
;
;		<5>	<6>	<7>	<8>
;	<1>	7	8	9	(up)
;	<2>	4	5	6	(down)
;	<3>	1	2	3	(run)
;	<4>	(load)	0	(clr)	(ent)


; *top view* of keypad pins: 1,2,3,4,5,6,7,8
; pin 1 is marked with the letter M on my units.
; interconnect was done using a 20 pin idc cable, with the #1
; pin of the connector going to keypad #1 and pcb header #1.
; being cheap, i used a ten pin header strip on the pcb.
; pcb header pins 9 and 10 are on pc board, but not used.


; inputs will be rb4,5,6,7  outputs will be rb0,1,2,3
; so we can take advantage of interrupt on rb 4-7 going low.
; this leads us to the following coding/decoding scheme
; based on keeping the interface wiring straight forward.
; *keypad pin* 1=rb0 2=rb1 3=rb2 4=rb3 5=rb4 6=rb5 7=rb6 8=rb7
; x refers to the original code, and y to the decoded value,
; which has been chosen to be a *character* type e.g. '1' instead of 1.


; note that the method used to allow a variable length code
; requires a dummy filler code to pad out unused digits.
; h'00' has been chosen as the filler code, as it is very easy to test for.




;==============================================================================
; decoding of keypad *scancodes* to stored *character* codes:
;==============================================================================


xload	=	b'11100111'
yload	=	'l'		;load character 'l' (el), *not* a <'1'>
x0	=	b'11010111'
y0	=	'0'		;0
xclr	=	b'10110111'
yclr	=	'c'		;clear
xent	=	b'01110111'
yent	=	'e'		;enter
x1	=	b'11101011'
y1	=	'1'		;1 (one)
x2	=	b'11011011'
y2	=	'2'		;2
x3	=	b'10111011'
y3	=	'3'		;3
xrun	=	b'01111011'
yrun	=	'r'		;run
x4	=	b'11101101'
y4	=	'4'		;4
x5	=	b'11011101'
y5	=	'5'		;5
x6	=	b'10111101'
y6	=	'6'		;6
xdown	=	b'01111101'
ydown	=	'd'		;down
x7	=	b'11101110'
y7	=	'7'		;7
x8	=	b'11011110'
y8	=	'8'		;8
x9	=	b'10111110'
y9	=	'9'		;9
xup	=	b'01111110'
yup	=	'u'		;up


xx	=	b'00000000'	;filler code. allows simple z test for end.


;==============================================================================
; eeprom data area    64x8 bytes of eeprom starting at h'2100'
;==============================================================================


	org	h'2100'		;set data eeprom origin


;user codes can be from 1 to 8 digits in length
;and may also contain <load> <up> and <down>.
;the special codes <clr> <ent> and <run> may not appear in a user code


;since codes are stored decoded, use y0-y9 and yup, ydown, and yload to specify code set.
;xx indicates blank filler code


usercode0       de  xx, xx, xx, xx, xx, xx, xx, xx     	;user 1
usercode1       de  xx, xx, xx, xx, xx, xx, xx, xx     	;user 2
usercode2       de  xx, xx, xx, xx, xx, xx, xx, xx     	;user 3
usercode3       de  xx, xx, xx, xx, xx, xx, xx, xx     	;user 4
usercode4       de  xx, xx, xx, xx, xx, xx, xx, xx     	;user 5
usercode5       de  xx, xx, xx, xx, xx, xx, xx, xx	;user 6
umastercode	de  y1, y2, y3, y4, y5, y6, y7, y8     	;user mastercode.
							; 1-8 digits
							; *can* be changed.
mastercode      de  y1, y0, y2, y8, y1, y9, y4, y6      ;factory mastercode.
							; 8 digits
							; can *not* be changed.


;==============================================================================
; explanation of how data entry occurs
;==============================================================================


;normal codes: hit <clr>, enter code, hit <ent>. relay will close for 10 sec.
;you may terminate relay closure early by hitting *any* key.


;hitting <clr> will always re-synchronize system.


;in addition to allowing regular relay closure, the mastercodes can be used
;to do special things. the factory master code is never changed, but the user
;may enter their own easy-to-remember personal mastercode, and up to 6
;regular user codes.


;hit <clr>, enter one of the mastercodes, hit <run>, hit set # <0-6>, hit <load>,
;enter 1-8 digits, and terminate with <ent>. if no digits are entered, then set is
;cleared. This allows you to remove any of the existing codes, except the factory
;supplied mastercode.


;user set #0 is actually the user-selectable mastercode. It may be used just
;like the regular factory-set mastercode. it is suggested that this be an
;8 digit code.


;remember that <load>, <up>, and <down> are all valid keys and can be used
;the same as if they were digits. <clr>, <ent>, and <run> may *not* be used
;as part of the user code, since they are used to direct program flow and select
;what type of entry is in progress.




;==============================================================================
; file register ram useage h'oc' to h'2f'. 36 bytes available
;==============================================================================


;(### if using 16f84 sram begins at h'0c' and ends at h'4f'. room for 68 bytes.)


;note that the assembler can *not* use db or similar codes to load the contents.


;the use of the cblock/endc directives allow us to assign ram storage
;without having to use equate statements. this allows the programmer
;to add/remove/move variable assignments without having to worry about fixing
;up the actual assigned *value*. makes life simpler for the programmer!


		cblock	h'0c'


keycode		;storage for undecoded/decoded keycode
savew		;for inthandler
savestatus	;for inthandler
savefsr		;for inthandler
eeadr1		;storage for eeadr 
xmillisec	;outer loop counter for milliseconds
ymillisec	;inner loop counter for milliseconds
keycounter1	;outer loop counter
keycounter2	;inner loop counter
ok		;non-zero means ok
blinks		;number of blinks to perform (green)
exitkey		;holds value of key used to terminate entry
usercounter1	;multiple uses involving user key entry
user0		;user input is stored here.
user1		; user0-user7 hold the code entered
user2		; via the keypad both for normal entry,          	
user3		; master code entry, and the entry of         	               
user4		; *new* user code         	
user5
user6
user7


		endc


;==============================================================================
; program space  1kx14 (h'400') can only be changed via programmer.
;==============================================================================


;because we stay within a 1K bank, no need to worry about bank selection.
		
	org	h'0000'	;set code origin within rom space


start
	goto	setup	;must get past interrupt vector at h'0004'


;==============================================================================
; interrupt handler:	handles all keypad input and decoding.
;			*decoded* value is placed in <keycode>.
;
;			main program looks for non-zero value while in loop.
;			after being used, main program must clrf keycode!
;==============================================================================


;               there is a single interrupt location at 004
;		in our case there is only 1 source of interrupt,
;		so we don't have to worry about that.


;		see <setup> section for interrupt assignment stuff.


	org	h'0004'	;interrupt vector at h'0004'


;interrupt occurs when any key is hit.
;this routine handles debounce and returns the key code in keycode.
;on any error it returns 0 in keycode. debounce is executed at
;beginning and end of keypress. Only the first key detected will
;be captured if there are multiple simultaneous keys pressed.
;keypress can be of any duration.


inthandler
				;global interrupts automatically
				;disabled on entry!
	movwf	savew		;save w register!
	swapf	status,w	;(twisted)
				; swapf used so as not to disturb
				; the contents of the status register
	movwf	savestatus	;save status register!
	movf	fsr,w		;save fsr!
	movwf	savefsr
						
;instead of doing a regular delay on entry for debounce, we 'waste' the time
;doing something useful: we search for the scancode. We do this 65K times
;before assuming there was no key hit.


	clrf	keycode		;clear keycode.
	clrf	keycounter1	;initialize outer counter


loop256x256
	decfsz	keycounter1,f	;256 outer loops...
	goto	more256x256
	goto	nogood		;65K tries & it was no good!


more256x256
	clrf	keycounter2	;initialize inner counter


loopinner256
	decfsz	keycounter2,f	;256 inner loops per outer loop...
	goto	innertest
	goto	loop256x256


innertest
	comf	portb,w
	andlw	b'11110000'	;test for *any* key hit first...
	btfsc	status,z
	goto	loopinner256
				;if we got here, we might have a hit.
		
scankey0
	movlw	b'11111110'	;load bitmask
	movwf	portb		;twiddle one bit at a time
	nop			;give signal a chance to settle down
	movf	portb,w		;read current value into keycode
	movwf	keycode		;now we can play with it.
	comf	keycode,w	;get complemented form
	andlw	b'11110000'	;look only at high bits
	btfss	status,z	;no hit sets z flag
	goto	decode		;if hit, decode & debounce...
					;if no hit, check next key set
scankey1
	movlw	b'11111101'	;load bitmask
	movwf	portb		;twiddle one bit at a time
	nop			;give signal a chance to settle down
	movf	portb,w		;read current value into keycode
	movwf	keycode		;now we can play with it.
	comf	keycode,w	;get complemented form
	andlw	b'11110000'	;look only at high bits
	btfss	status,z	;no hit sets z flag
	goto	decode		;if hit, decode & debounce...
					;if no hit, check next key set
scankey2
	movlw	b'11111011'	;load bitmask
	movwf	portb		;twiddle one bit at a time
	nop			;give signal a chance to settle down
	movf	portb,w		;read current value into keycode
	movwf	keycode		;now we can play with it.
	comf	keycode,w	;get complemented form
	andlw	b'11110000'	;look only at high bits
	btfss	status,z	;no hit sets z flag
	goto	decode		;if hit, decode & debounce...
				;if no hit, check next key set
scankey3
	movlw	b'11110111'	;load bitmask
	movwf	portb		;twiddle one bit at a time
	nop			;give signal a chance to settle down
	movf	portb,w		;read current value into keycode
	movwf	keycode		;now we can play with it.
	comf	keycode,w	;get complemented form
	andlw	b'11110000'	;look only at high bits
	btfss	status,z	;no hit sets z flag
	goto	decode		;if hit, decode & debounce...
	goto	loopinner256	;if there were no hits at all!


nogood
	clrf	keycode		;reset keycode to 0 (indicates no hit)


;the following decodes the scan code value into a ycode character.
;due to the nature of the scancodes, we can not use a decode table efficiently,
;so we will use a skip method instead.


decode
	movf	keycode,w	;copy to w and set flags
	btfsc	status,z
	goto	fillercode	;if keycode=0 convert to filler


decode0
	movf	keycode,w	;reload keycode to convert		
	sublw	x0		;compare with xcode definition
	btfss	status,z
	goto	decode1		;if no match, check next
	movlw	y0		;if match, load ycode into w
	goto	savecode	;save converted code.


decode1
	movf	keycode,w	;reload keycode to convert		
	sublw	x1		;compare with xcode definition
	btfss	status,z
	goto	decode2		;if no match, check next
	movlw	y1		;if match, load ycode into w
	goto	savecode	;save converted code.


decode2
	movf	keycode,w	;reload keycode to convert		
	sublw	x2		;compare with xcode definition
	btfss	status,z
	goto	decode3		;if no match, check next
	movlw	y2		;if match, load ycode into w
	goto	savecode	;save converted code.


decode3
	movf	keycode,w	;reload keycode to convert		
	sublw	x3		;compare with xcode definition
	btfss	status,z
	goto	decode4		;if no match, check next
	movlw	y3		;if match, load ycode into w
	goto	savecode	;save converted code.


decode4
	movf	keycode,w	;reload keycode to convert		
	sublw	x4		;compare with xcode definition
	btfss	status,z
	goto	decode5		;if no match, check next
	movlw	y4		;if match, load ycode into w
	goto	savecode	;save converted code.


decode5
	movf	keycode,w	;reload keycode to convert		
	sublw	x5		;compare with xcode definition
	btfss	status,z
	goto	decode6		;if no match, check next
	movlw	y5		;if match, load ycode into w
	goto	savecode	;save converted code.


decode6
	movf	keycode,w	;reload keycode to convert		
	sublw	x6		;compare with xcode definition
	btfss	status,z
	goto	decode7		;if no match, check next
	movlw	y6		;if match, load ycode into w
	goto	savecode	;save converted code.


decode7
	movf	keycode,w	;reload keycode to convert		
	sublw	x7		;compare with xcode definition
	btfss	status,z
	goto	decode8		;if no match, check next
	movlw	y7		;if match, load ycode into w
	goto	savecode	;save converted code.


decode8
	movf	keycode,w	;reload keycode to convert		
	sublw	x8		;compare with xcode definition
	btfss	status,z
	goto	decode9		;if no match, check next
	movlw	y8		;if match, load ycode into w
	goto	savecode	;save converted code.


decode9	
	movf	keycode,w	;reload keycode to convert		
	sublw	x9		;compare with xcode definition
	btfss	status,z
	goto	decodeload	;if no match, check next
	movlw	y9		;if match, load ycode into w
	goto	savecode	;save converted code.


decodeload
	movf	keycode,w	;reload keycode to convert		
	sublw	xload		;compare with xcode definition
	btfss	status,z
	goto	decodeclr	;if no match, check next
	movlw	yload		;if match, load ycode into w
	goto	savecode	;save converted code.


decodeclr
	movf	keycode,w	;reload keycode to convert		
	sublw	xclr		;compare with xcode definition
	btfss	status,z
	goto	decodeent	;if no match, check next
	movlw	yclr		;if match, load ycode into w
	goto	savecode	;save converted code.


decodeent
	movf	keycode,w	;reload keycode to convert		
	sublw	xent		;compare with xcode definition
	btfss	status,z
	goto	decoderun	;if no match, check next
	movlw	yent		;if match, load ycode into w
	goto	savecode	;save converted code.


decoderun
	movf	keycode,w	;reload keycode to convert		
	sublw	xrun		;compare with xcode definition
	btfss	status,z
	goto	decodedown	;if no match, check next
	movlw	yrun		;if match, load ycode into w
	goto	savecode	;save converted code.


decodedown
	movf	keycode,w	;reload keycode to convert		
	sublw	xdown		;compare with xcode definition
	btfss	status,z
	goto	decodeup	;if no match, check next
	movlw	ydown		;if match, load ycode into w
	goto	savecode	;save converted code.


decodeup
	movf	keycode,w	;reload keycode to convert		
	sublw	xup		;compare with xcode definition
	btfss	status,z
	goto	fillercode	;if no match, use fillercode
	movlw	yup		;if match, load ycode into w
	goto	savecode	;save converted code.
		
fillercode
	clrf	keycode		;set up filler code
	goto	intreturn	;skip delay since it is empty
		
savecode
	movwf	keycode		;store converted keycode in keycode!
	bsf	porta,n_red 	;turn off red led until key is
				;released. used as a visual
				;indicator that we got it.
	movlw	b'11110000'	;allow any key hit to be detected
	movwf	portb		;make it so
	nop			;wait to stabilize.
		
release
	comf	portb,w		;wait for all keys to be released...
	andlw	b'11110000'	;only have to check upper 4 bits.
	btfss	status,z
	goto	release		;if any key is down, wait...
	movlw	d'25'		;set debounce delay to 25 ms.
	call	wmillisec	;wait after last key is released.
		
				;clean up and get ready to return.
					
	comf	portb,w		;check for *really* bad bounce!
	andlw	b'11110000'	;only have to check upper 4 bits.
	btfss	status,z
	goto	release		;if key is still down, wait...
	movlw	d'25'		;set debounce delay to 25 ms
	call	wmillisec	;wait after last key is released
		
				;clean up and get ready to return.
		
intreturn
	movlw	b'11110000'	;set up default keyscan (all)
	movwf	portb		;so new key presses can be detected.
	bcf	porta,n_red	;turn red back on after keypress
		
	bcf     intcon,rbif	;clear appropriate interrupt flag!
				;(in this example we used rbif)
				
				;restore stuff we saved.
				
	movf	savefsr,w	;restore fsr!
	movwf	fsr
	swapf	savestatus,w	;untwist twisted saved status
	movwf	status		;restore normalized status!
	swapf	savew,f		;restore w! first twist nibbles
	swapf	savew,w		;then twist again and place 
				;result in w.
				;we had to use swapf to ensure that
				;status register was not clobbered
				;while recovering w.


	retfie			;return from interrupt!
		
	;gie is auto-re-enabled.
	;keycode contains character code if OK
	;else keycode is 00000000.


;==============================================================================
; setup is the initialization code for ports and registers
;==============================================================================


;page 1 stuff includes option_reg, trisa, trisb, eecon1, eecon2


setup
	bsf     status,rp0	;allow access to page 1 stuff!


	movlw	b'00000000'	;set porta direction for i/o pins
	movwf	trisa		;0=output  1=input


	movlw	b'11110000'	;set portb direction for i/o pins
	movwf	trisb		;0=output  1=input
		
	;although we could use a simple movlw/movwf option_reg
	;instruction to setup all option_reg bits at once, it is 
	;preferable to use individual bit twiddling during 
	;development, so changes can be easily made and commented.


	bcf     option_reg,not_rbpu ;!rbpu! rb_pullup 
				; 0=enabled 1=disabled
				; enables only portb inputs.
				;(enable weak pullups on portb inputs)
						
	bcf     option_reg,intedg ;intedg 
				; 0=int on falling 1=int on rising
				; note: intedg and t0se use
				; opposite definitions!
				;(interrupt on falling edge of portb)
				
	bcf     option_reg,t0cs	;t0cs timer0clocksource 
				; 0=internal clkout 1=ra4/int 
				;(enable internal clkout)


	bcf     option_reg,t0se	;t0se timer0signaledge 
				; 0=inc on rising 1=inc on falling
				; note: intedg and t0se use 
				; opposite definition!
				;(inc on rising edge of clock)


	bcf     option_reg,psa	;psa pre scaler assignment
				; 0=tmr0 1=wdt
				;ps2-ps0 determine prescalerrate, 
				; which is dependent also on whether 
				; tmr0 or wdt is selected:
				;wdt from 0-7 is 
				; div by 1 2 4 8 16 32 64 128
				;tmr0 from 0-7 is 
				; div by 2 4 8 16 32 64 128 256


				;we have chosen tmr0 prescaler of 2.
				;we will not be using tmr0 or the wdt,
				;but we will state and set
				;bits as if we might use tmr0
				;since we do *not* want to use wdt.
				
	bcf     option_reg,ps2	;ps2 of psa
	bcf     option_reg,ps1	;ps1 of psa
	bcf     option_reg,ps0	;ps0 of psa


	bcf     status,rp0	;allow access to page 0 stuff again.
				; back to normal!


;==============================================================================
; enable interrupt related stuff
;==============================================================================


;intcon register: 


;enables... 1=enable 0=disable
;<7>=gie=global_int_enable
;<6>=eeie=eeprom_int_enable
;<5>=t0ie=tmr0_int_enable (enables <2> t0if)
;<4>=inte=int_enable (rb0/int) (enables <1> intf)
;<3>=rbie=rb_int_enable (enables <0> rbif)


;flags. software reset. 0=reset 1=flagged
;<2>=t0if=tmr0_int_flag
;<1>=intf=int_flag (rb0/int)
;<0>=rbif=rb_int_flag (rb7-rb4)


;upon power up and !mclr!, intcon will contain 0000 000x
;this means that initially all interrupts are disabled.


;note: option_reg register is used to program use of tmr0 and wdt




	clrf	tmr0		;reset tmr0 (not used)
	clrf	intcon          ;clear any pending interrupt requests
	bsf     intcon,gie	;set global interrupt enable
	bsf     intcon,rbie	;enable interrupt on portb change
				;pins 7,6,5,4


	clrf	keycode		;clear any existing keycode.
	bcf	porta,relay	;turn relay off.
		


;==============================================================================
; main program
;==============================================================================


;main program is state-driven.
;entry begins with the user hitting the clr key.
;this is indicated with a quick blink of the green led.
;the red led is usually on. it goes off while any key is depressed.
;key input is handled by an interrupt driven routine based on 
;int on portb<7:4>.


;extensive debouncing ensures accurate entry of keys.
;keys are decoded from row/column form into simple ascii character form
;by interrupt handler. 
;ascii character code representations used are:
; '0'-'9' and 'c' clr, 'e' ent, 'r' run, 'u' up, 'd' down, 'l' load.


;the clr key will always cause synchronization of the system, and
;*all* valid entry begins with a clr. 


;green led is blinked on clr release.
;digits are then entered. valid codes can be from 1 to 8 digits long.
;while any digit is being entered, the red led will go off.
;this provides a visual feedback of proper data entry.


;normal entry mode: if a set of key entries ends with ent, 
;then all 8 code sets (including the master codes) are compared 
;with the user entries. entry of more than 8 digits will be detected 
;as a 'no-match'.


;if entry was 1-8 digits, these are compared and if any set matches,
;then the green and red leds will alternate on and off for ten
;seconds while the relay is closed for ten seconds. at the end
;of ten seconds the relay will re-open and the system will be waiting
;for user input. user may terminate the relay on condition
;by hitting any key.


;run mode: if the run key is used to terminate a set of digits, then
;the system goes into a special mode that allows the user to change
;any of 7 sets of user entry codes. the ** master code ** that must be
;entered (followed by run) *must* be 8 digits. since there must
;be some means to indicate which set is to be changed, the following
;sequence is followed:
		
;1) clr followed by 8 digit master code followed by run
;2) flashing red led comes on to indicate you have entered run mode.
;   green led comes on steady
;3) next entry *must* be a digit from 0-6 to indicate which *set*.
;   (0 indicates entry of new user-mastercode)
;   as soon as this digit has been entered the red led goes steady,
;   and the green led will stay on to indicate run normal mode.
;4) the next entry *must* be the load key, or input is terminated.
;5) up to 8 digits may now be entered.
;   a) if *no* digits are entered, set is invalid (never matches).
;      this is useful in *removing* a code without entering a new one.
;   b) if more than 8 digits are entered, then entry is ignored.
;6) entry of valid set is complete when terminating ent key is hit.
;7) the set # entered is now available.


mainprog
	movlw	b'11110000'	;scan all 4 lines at once.
	movwf	portb		;initialize keyboard scanning
	bcf	porta,relay	;turn off relay
	bcf	porta,n_red	;turn red led on while waiting for keypress.
				;interrupt handler will turn red led off
				;during keypress and back on when 
				;key is released.
	bsf	porta,n_green	;turn green led off.
	
	movf	keycode,w	;check for yclr (may have occurred in subroutine)
	sublw	yclr
	btfsc	status,z
	goto	gotyclr		;yclr is handled special.
	
	bsf	porta,n_green	;turn green led off. when green is on
				;it indicates special master code mode.	
	clrf	keycode		;clear keycode to allow new keycode.


mainloop
	movf	keycode,w	;see if keycode is present
	btfsc	status,z
	goto	mainloop	;loop while empty...
				;eventually inthandler loads keycode
	sublw	yclr		;was it yclr?
	btfsc	status,z
	goto	gotyclr		;if so,continue...
	goto	mainloop	;else keep looking for yclr




gotyclr
	bcf	porta,n_green 	;blink green led *once* to indicate yclr
	movlw	d'20'
	call	wmillisec
	bsf	porta,n_green 	;turn green led off.
	clrf	keycode		;clear keycode & wait for next key
	
gotyclr1
	movf	keycode,w	;check keycode
	btfsc	status,z
	goto	gotyclr1	;loop while empty...
				;eventually inthandler loads keycode
	movf	keycode,w	;it might be another yclr!
	sublw	yclr
	btfsc	status,z
	goto	gotyclr		;if so, handle it properly.


	call	getuser		;get a set of inputs. (have 1 already)


	movf	exitkey,w	;check for exitmode.
	sublw	0		;was it error?
	btfsc	status,z
	goto	mainprog	;on error or yclr start all over.
	movf	exitkey,w
	sublw	yent		;check for yent
	btfsc	status,z
	goto	wasent		;handle elsewhere if yent.
	movf	exitkey,w
	sublw	yrun		;check for yrun
	btfsc	status,z
	goto	wasrun		;handle elsewhere if yrun.
	goto	mainprog	;anything else was an error.
				;(yclr is handled by mainprog)
		
wasent
				;compare user set with all eight
				;code sets. If ANY set matches,
				;then open door. wait, then goto mainprog
		
	movlw	0*8		;8 checks are very similar...
	movwf	eeadr		;set up eeadr for proper set.
	call	compare8	;do generic compare of user/eeprom sets
	movf	ok,w		;if ok is not zero then we have a match.
	btfss	status,z	;0-5 are 6 user sets, and 
	goto	entok		;6 and 7 are mastercode sets.


	movlw	1*8		;if there was no match, then program
	movwf	eeadr		;checks *next* set of codes in eeprom
	call	compare8
	movf	ok,w
	btfss	status,z
	goto	entok
		
	movlw	2*8		;etc.
	movwf	eeadr
	call	compare8
	movf	ok,w
	btfss	status,z
	goto	entok
		
	movlw	3*8		;etc.
	movwf	eeadr
	call	compare8
	movf	ok,w
	btfss	status,z
	goto	entok
		
	movlw	4*8		;etc.
	movwf	eeadr
	call	compare8
	movf	ok,w
	btfss	status,z
	goto	entok
		
		
	movlw	5*8		;etc
	movwf	eeadr
	call	compare8
	movf	ok,w
	btfss	status,z
	goto	entok


	movlw	6*8		;include user mastercode check.
	movwf	eeadr
	call	compare8
	movf	ok,w
	btfss	status,z
	goto	entok
		
	movlw	7*8		;include factory mastercode check.
	movwf	eeadr
	call	compare8
	movf	ok,w
	btfss	status,z
	goto	entok
	goto	mainprog	;if no sets matched
				;then incorrect codes were entered.


;if we got this far, then it was a complete match!


entok
	bsf	porta,relay	;turn relay on
	movlw	d'100'		;for 100*100 msec=1 sec
	movwf	usercounter1
	clrf	keycode		;clear keycode to allow new key
ldelay	
	movf	keycode,w	;any key hit will terminate.
	btfss	status,z
	goto	mainprog
	
	bcf	porta,n_red	;turn red led on.
	bsf	porta,n_green	;and green led off.
	movlw	d'50'
	call	wmillisec	;delay 50 msec
	
	bsf	porta,n_red	;turn red led off.
	bcf	porta,n_green	;and green led on.
	movlw	d'50'
	call	wmillisec	;delay 50 msec
	
	decfsz	usercounter1,f	;update counter
	goto	ldelay
	goto	mainprog


;run mode: if the run key is used to terminate a set of digits, then
;the system goes into a special mode that allows the user to change
;any of 7 sets of user entry codes. the *** master code *** that must be
;entered (followed by run) *must* be 8 digits. since there must
;be some means to indicate which set is to be changed, the following
;sequence is followed:
		
;1) clr followed by 8 digit master code followed by run
;2) flashing red led comes on to indicate you have entered run set mode.
;   green led comes on steady
;3) next entry *must* be a digit from 0-6 to indicate which *set*.
;   (0 indicates entry of new user-mastercode)
;   as soon as this digit has been entered the red led goes steady,
;   and the green led will stay on to indicate run normal mode.
;4) the next entry *must* be the load key, or input is terminated.
;5) up to 8 digits may now be entered.
;   a) if *no* digits are entered, then set is made invalid (never matches)
;      this is useful in *removing* a code without entering a new one.
;   b) if more than 8 digits are entered, then entry is ignored.
;6) entry of valid set is complete when terminating ent key is hit.
;7) the set # entered is now available.




wasrun			;compare user set with mastercode.
			;and also with user-mastercode!
			;if ok, then allow new entry set
			;turn on green led.
			;1st key is pointer, next 8 max
			;get entered at pointer in eeprom
			;then goto mainprog
		
	movlw	6*8		;compare user with user-mastercode
	movwf	eeadr
	call	compare8
	movf	ok,w
	btfss	status,z
	goto	runok
		
	movlw	7*8		;compare user with factory-mastercode
	movwf	eeadr
	call	compare8
	movf	ok,w
	btfss	status,z
	goto	runok
	goto	mainprog 	;if no match, begin again.
		
runok	
	clrf	keycode		;clear out any old key data.
	bcf	porta,n_green 	;turn green led on.
	
runloop1
	bcf	porta,n_red 	;turn red led on.
	movlw	d'35'
	call	wmillisec	;delay 35 msec
	
	bsf	porta,n_red	;then turn red led off.
	movlw	d'35'
	call	wmillisec	;delay 35 msec
	
	movf	keycode,w	;interrupt will load it!
	btfsc	status,z
	goto	runloop1	;wait for key.
	
				;once a key is found
	bcf	porta,n_red	;turn red led on.
	bcf	porta,n_green	;turn green led on.
	
	sublw	yclr
	btfsc	status,z
	goto	mainprog	;handle yclr special.
	
	movf	keycode,w	;look at code again
	sublw	'6'		;allow only stuff <= '6'
	btfss	status,c	;if w<='6', c is set
	goto	mainprog	;if w>'6', c is cleared, so ignore.
	
	movf	keycode,w	;look at code again
	andlw	b'00000111'	;convert from ascii to binary
				; 0-6 max!
	movwf	eeadr1		;save it
	decf	eeadr1,f	;reduce address by 1
	btfss	eeadr1,7	;0-1 would give us 11111111
	goto	rollem		;if msb=0 handle normal.
	
	movlw	b'0000110'	;convert 0 to 6
	movwf	eeadr1		;so it is now user mastercode
				;then save it in eeadr1.
	
rollem	
	bcf	status,c	;initial carry in must be 0!
	rlf	eeadr1,f	;*2
	rlf	eeadr1,f	;*4
	rlf	eeadr1,f	;*8
		
	;we now have proper ee address set in eeadr1
	
eeadrok	
	clrf	keycode		;get ready for next key.
	
loadloop
	movf	keycode,w	;interrupt will load it!
	btfsc	status,z
	goto	loadloop	;wait for key.
	sublw	yload		;it *must* be the load key
	btfss	status,z
	goto	mainprog	;if not, forget it!
	clrf	keycode
	call	getuser		;get user input(s)


	movf	exitkey,w	;check for exitmode.
	sublw	yent		;was it ent?
	btfss	status,z
	goto	mainprog	;on error or yclr start all over.
		
ent2stuff
	movlw	d'8'		;eight digits to be moved
	movwf	usercounter1	;use this as a counter
	movf	eeadr1,w	;recover starting address
	movwf	eeadr		;set up ee address
	movlw	user0		;point to user set in ram.
	movwf	fsr		;make it indirect pointer.
	
nextent2
	movf	indf,w		;use indirect pointer
	movwf	eedata		;copy ram to eedata
			
	call	writeeedata	;use subroutine to do that.


	decfsz	usercounter1,f	;update loop
	goto	next1ent2
	goto	mainprog	;when done, start all over.
	
next1ent2
	incf	eeadr,f		;update ee address
	incf	fsr,f		;update indirect pointer
	goto	nextent2	;do all 8 digits...
		


;==============================================================================
; getuser: (subroutine) : gets up to 8 digits and a terminator
; returns exitkey with value of terminator, or 0 if error
; such as too many digits entered or clr hit during entry.
;==============================================================================
		
getuser
	clrf	exitkey		;get ready for next key...
	movf	keycode,w	;always check for yclr!
	sublw	yclr		;was it yclr?
	btfss	status,z
	goto	get8keys	;if not, do usual
	
handleyclr
	movlw	h'00'
	movwf	exitkey		;tell 'em via exitkey
	goto	checkret	;handle yclr special


get8keys
	clrf	user0		;clear all key holders
	clrf	user1
	clrf	user2
	clrf	user3
	clrf	user4
	clrf	user5
	clrf	user6
	clrf	user7
		
	movlw	user0
	movwf	fsr		;allow indirect addressing.
	clrf	usercounter1	;we handle 8 keys, 1-8
	
get8wait
	movf	keycode,w	;updated via interrupt!
	btfsc	status,z
	goto	get8wait	;if empty, keep looking...
	sublw	yclr		;always check for yclr
	btfsc	status,z
	goto	handleyclr	;yclear always synchronizes things!
		
				;now check for yent and yrun *early*.
					
ent
	movf	keycode,w	;get current key input into w
	sublw	yent		;yent means terminate entry
	btfsc	status,z
	goto	checkent	;handle yent elsewhere...
	movf	keycode,w	;check for yrun
	sublw	yrun
	btfsc	status,z
	goto	checkrun	;if yrun, handle special...
	
	;if you got here, then last key was not special
		
	movf	keycode,w
	movwf	indf		;indirect keycode to user elements
	clrf	keycode		;reset keycode to allow next key entry.
	incf	fsr,f		;update indirect pointer
	incf	usercounter1,f	;update counter
	movf	usercounter1,w
	sublw	9		;only 8 digits allowed max (1-8)
	btfss	status,z
	goto	get8wait	;if not '8' yet, get next entry...


	;if you got here, then 9th key was not special
	;which means it *must* be an error!
	
	goto	checkret	;return with exitkey=0
				;to indicate error.
		
checkent
	movlw	yent
	movwf	exitkey
	goto	checkret	;return with yent in exitkey.
		
checkrun
	movlw	yrun
	movwf	exitkey
	
checkret
	return			;return with yrun in exitkey.
					
compare8
	clrf	ok		;assume not ok at first.
	movf	user0,w		;look at first key entry
	btfsc	status,z
	goto	compareret	;return with error set if null set
				;(this prevents null set from being ok)


				;compare user set with eeadr set.
				;returns with ok non-zero if matched.
				
	movlw	1		;set ok for now.
	movwf	ok
	movlw	8
	movwf	usercounter1	;initialize counter to 8
	movlw	user0
	movwf	fsr		;allow indirect addressing
	
compareloop
	movf	indf,w		;recover user data
	bsf     status,rp0	;we do this stuff on page 1
	bsf	eecon1,rd	;set up read
	bcf     status,rp0	;we do usual stuff on page 0
	subwf	eedata,w	;compare with eeprom data
	btfss	status,z
	goto	compareerror	;if different, error!
	incf	eeadr,f		;get ready for next... direct
	incf	fsr,f		;and indirect
	decfsz	usercounter1,f	;update counter
	goto	compareloop	;if not all 8 done, do more.
	goto	compareret	;if all 8 matched, all done!
	
compareerror
	clrf	ok		;on error, say so.
	
compareret
	return


;==============================================================================
; eeprom stuff
;==============================================================================


;eecon1 register:
;<7,6,5> unused. rest are r/w.
;<4> eeif. eeprom_int_flag. see intcon eeie. can be software polled / reset.
;<3> wrerr. write_error flag (mclr or wdt). software reset.
;<2> wren. write_enable. 1=enable. software set/reset.
;<1> wr. write. set=1 to initiate write. cleared automatically by hardware.
;<0> rd. read. set=1 to initiate read. cleared automatically by hardware.
;
;reading/writing eeprom data area on-the-fly:
;
;accessed via eedata and eeadr. eedata is accessed for r/w data, and
;eeadr is used to hold the address of the desired data.
;eecon1 and eecon2 are eeprom_control registers to make sure that there
;can never be an accidental write to the eeprom.
;
;to read: 
;load eeadr with the desired address.
;set eecon1<0> rd=1. (it is automatically cleared by hardware)
;read eedata. data remains in eedata until next read/write.
;
;to write: follow example below exactly!




;==============================================================================
; writeeedata: (subroutine) : enter with eedata and eeadr loaded
;==============================================================================




writeeedata
	bsf     status,rp0	;we do this stuff on page 1
	bcf     eecon1,eeif	;we have to clear this sucker!
	bsf	eecon1,wren	;enable writes!
	bcf	intcon,gie	;disable interrupts!


	movlw	h'55'		; note: code sequence must be
	movwf	eecon2		;*exactly* as shown.
	movlw	h'aa'
	movwf	eecon2
	bsf	eecon1,wr


eewait  
        btfss	eecon1,eeif	;poll eeif.
	goto	eewait
	bcf	eecon1,eeif	;we have to clear this sucker!
	bcf	eecon1,wren	;disable further writes!
	bsf	intcon,gie	;re-enable interrupts!
	bcf	status,rp0	;back to page 0
	return


;==============================================================================
; wblinks: (subroutine) : enter with number of blinks in w. blinks green led.
;==============================================================================
	
wblinks
	movwf	blinks		;save # of blinks
	incf	blinks,f	;adjust for initial decrement
	
wblinksloop
	decfsz	blinks,f	;update
	goto	blinkit		;on/off once
	
	return			;return when all done.
	
blinkit	
	bcf	porta,n_green	;on
	call	xmillisecs	;delay
	bsf	porta,n_green	;off
	call	xmillisecs	;delay
	goto	wblinksloop	;do more blink sets...
		


;==============================================================================
; xmillisecs: (subroutine) : 200 msec delay. flows into wmillisec.
;==============================================================================


xmillisecs
	movlw	d'200'		;delay...


;==============================================================================
; wmillisecs: (subroutine) : delay for w millisecs. tuned for 4.00 mhz xtal.
;==============================================================================


;called subroutine set to generate delays.
;enter with # of milliseconds to delay in W


wmillisec
	movwf	xmillisec	;save # of millisecs in w to delay.


	incf	xmillisec,f	;adjust to account for initial decrement.
				;first (outer) loop.
	
wmloop1
	decfsz	xmillisec,f	;update first (outer) loop
	goto	wmloopa		;if more to do, do it.
	
	return			;done when xmillisec=0.
	
wmloopa	
	clrf	ymillisec	;second (inner) loop
				;256 loops (256+1 becomes 0)
	
wmloopb	
	decfsz	ymillisec,f	;update 256 part of inner loop.
	goto	wmloopb		;3 usec per loop
	
	movlw	d'75'+1
	movwf	ymillisec	;75 loops for third loop
	
wmloopc	
	decfsz	ymillisec,f	;update 75 part of inner loop.
	goto	wmloopc		;3 usec per loop
	
	goto	wmloop1		;continue with next outer loop
				
				;total for inner loop sets is 
				;3*(256+75)=993 usec.
				;this together with the overhead
				;makes the total as close to 1000 usec
				;as we can get it.
				;1000 usec = 1 millisecond


;==============================================================================
; end of program
;==============================================================================


		end

  .