; 3   FOR RCV11
; TOTAL 10 INSTRUCTIONS BETWEEN EDGE AND ENTERING DL1
; THEREFORE SUBTRACT 10/4 = 2.5 => 3 DL1 LOOPS TO COMPENSATE FOR 
;*************************************************************************

DL1
	CLRWDT                          ; [1] RESET WATCHDOG TIMER
	DECFSZ  CNT2,1                  ; [1] [2, IF SKIP]
	GOTO    DL1                     ; [2] CNT0 X 4 us

SAMPLE1
	BTFSS   PORTA,RFIN              ; [2] INPUT HIGH?  FIRST SAMPLE
	GOTO    RMT01                   ; [0] NO--ERROR

	MOVF    CNT0,W                  ; [1] CALIBRATION COUNTER
	MOVWF   CNT2                    ; [1] (NOMINALLY 75 FOR 300 us PULSE)
	DECF    CNT2,1			; [1] SUBTRACT 2 FROM FINAL CALIB COUNTER TO COMPENATE FOR THIS
	GOTO	$+1			; [2]
	NOP				; [1]
					; TOTAL = 8 => 1 LOOP COUNTER
DL2
	CLRWDT                          ; [1] RESET WATCHDOG TIMER
	GOTO	$+1			; [2] WASTE TIME
	GOTO	$+1			; [2] WASTE TIME
	DECFSZ  CNT2,1			; [1]
	GOTO    DL2                     ; [2] CNT0 X 8 us [ CNT0 x Te ]

SAMPLE2
	BCF     FLAGS,BITIN             ; [1]   CLEAR BIT POSITION
	BTFSS   PORTA,RFIN              ; [1.5] LEAVE 0 IF LINE HIGH
	BSF     FLAGS,BITIN             ; [0.5] MAKE 1 IF LINE LOW
					; SUB TOTAL = 3 CYCLES

	CALL    ROT_SHIFT               ; [11]+[2] CSR SHIFT + CALL
	BCF	CSR7,7			; [1]
	BTFSC   FLAGS,BITIN		; [1.5]
	BSF     CSR7,7			; [0.5]
					; SUB TOTAL = 16 CYCLES


	MOVF    CNT0,W                  ; [1] CALIBRATION COUNTER
	MOVWF   CNT2                    ; [1] (NOMINALLY 75 FOR 300 us PULSE)
	MOVLW	3			; [1] SEE CALCULATION BELOW
	SUBWF	CNT2,1			; [1]
	NOP				; [1]
					; SUB TOTAL = 5 CYCLE
					; TOTAL = 24 => 24/8 = 3 LOOP COUNTERS
					 
;*************************************************************************
; TOTAL = 24 INSTRUCTIONS
; SUBTRACT 24/8 = 3 TO COMPESATE FOR UPDATEING CSR AND OTHER PROCESSING 
; AFTER DATA SAMPLE IS TAKEN.
;*************************************************************************

DL3
	GOTO	$+1			; [2] WASTE TIME
	GOTO	$+1			; [2] WASTE TIME
	CLRWDT                          ; [1] RESET WATCHDOG TIMER
	DECFSZ  CNT2,1                  ; [1]
	GOTO    DL3                     ; [2] CNT0 X 8 us [ CNT0 X Te ]

SAMPLE3
	BTFSC   PORTA,RFIN              ; [2] INPUT LOW?  THIRD SAMPLE
	GOTO    RMT0                    ; [0] NO--RECEIVE ERROR

	CALL    TST_RTCC                ; [11] CHECK RTCC

	DECFSZ  CNT1,1                  ; [1] LAST BIT?
	GOTO    RCV8                    ; [2] ... NO, GET NEXT BIT
	GOTO	RMT1		     	; TOTAL = 14 CYCLES


RMT_0
RMT0	
RMT01	BSF	STATUS,C		; INVALID TRANSMISSION
	RETLW	1			; RETURN

RMT1	BSF	PORTA,LED		; VALID TRANSMISSION FORMAT, LED ON
	MOVLW	0FH			; FORCE OPEN BUTTON CODES TO ZERO
	ANDWF	SER_0,1
	CLRC				; VALID SERIAL NUMBER => VALID TX
 	RETLW   0                    	; RETURN 

;------------------------------------------------------------------------------
;
; FUNCTION     	: M_LOOP ()	      			
;
; DESCRIPTION  	: MAIN PROGRAM ROUTINE
;
;------------------------------------------------------------------------------

M_LOOP	BCF	PORTA,LED		 
	BTFSS	PORTA,LRN		
	GOTO	LEARN		 	; TEST & HANDLE LEARN BUTTON
	CALL	TST_RTCC		; UPDATE TIMER 
	CALL	TST_TIMER		; HANDLE TIMER - UPDATE OUTPUTS
	CALL	RECEIVE			; RECEIVE TRANSMISSION 
	BC	M_LOOP			; CHECK IF TRANSMISSION VALID

M_SEARCH
	CLRF	TXNUM			; TEST FIRST POSITION
; ******* COMPARE LOWER WORD OF SERIAL NUMBER ********
M_SERIAL
	CALL	TX_LOOKUP		; GET TX BASE ADDRESS
	BSF	ADDRESS,1		; ADD 2 TO BASE ADDRESS
	CALL	EEREAD			; READ LOWER 16-BITS OF SER# FROM EEPROM
  		    
	MOVFW	TMP1			; COMPARE RX AND EEPROM VALUES
	XORWF	SER_2,W
	BNZ	M_NEXT			; IF NOT EQUAL CHECK NEXT
	MOVFW	TMP2			; COMPARE RX AND EEPROM VALUES
	XORWF	SER_3,W
	BNZ	M_NEXT			; IF NOT EQUAL CHECK NEXT
	
; ******* COMPARE UPPER WORD OF SERIAL NUMBER ********
M_SERIAL2
	INCF	ADDRESS,F		; POINT TO NEXT ENTRY 
	CALL	EEREAD			; READ UPPER 16-BITS OF SER# FROM EEPROM

	MOVFW	TMP1			; COMPARE RX AND EEPROM VALUES
	XORWF	SER_0,W
	BNZ	M_NEXT			; IF NOT EQUAL CHECK NEXT

	MOVFW	TMP2			; COMPARE RX AND EEPROM VALUES
	XORWF	SER_1,W
	BNZ	M_NEXT			; IF NOT EQUAL CHECK NEXT

	BTFSS	FLAGS,LRNF		; LEARN MODE
	GOTO	M_HOP			; FOUND TRANSMITTER - DECRYPT

	BSF	FLAGS,RELEARN		; SET RELEARN FLAG
	GOTO	LEARN_F			; FOUND TRANSMITTER - LEARN
		
; **** SEARCH NEXT POSITION FOR SERIAL NUMBER *****
M_NEXT	INCF	TXNUM,F			; POINT TO NEXT TRANSMITTER POSITION
	MOVLW	MAX_USERS		; TEST FOR LAST POSITION
	SUBWF	TXNUM,W			
	BTFSS	STATUS,C		; NOT FOUND IN MAP
	GOTO	M_SERIAL		; TRY NEXT POSITION
M_NF
	BTFSS	FLAGS,LRNF		; LEARN MODE
	GOTO	M_LOOP			; NO... INVALID SERIAL NUMBER 
	GOTO	LEARN_NF		; NEW TRANSMITTER - USE POINTER FOR LEARN

; ********** DECRYPT HOPCODE *********************
M_HOP	
	CALL	DECRYPT			; DECRYPT HOPCODE 

; ********* TEST DICRIMINATION VALUE *************
M_DIS	MOVFW	SER_3			; SERIAL NUBER LSB MUST BE EQUAL
	XORWF	DISC,W			; TO DISCRIMINATION VALUE
	BNZ	M_LOOP

; *************** CHECK COUNTERS VALID ************
	BCF	FLAGS,SEC_CNT		; CHECK FIRST COUNTER
M_CNT	CALL	TX_LOOKUP		; POINT LOWER 16 BIT COUNTER
	BTFSC	FLAGS,SEC_CNT		; IF SECOND COUNTER IS USED
	INCF	ADDRESS,F		; INCREMENT ADDRESS
	CALL	EEREAD			; READ LOWER 16 BIT COUNTER FROM EEPROM

; ************ CHECK COUNTER WINDOWS ***********
M_SUB
	MOVFW	TMP2			; 16 BIT COUNTER SUBSTRACTION
	SUBWF	CNTR_LW,W
	MOVWF	TMP2			
	SKPC				; SKIP IF NO BORROW
	INCF	TMP1,F			; ... ELSE INCR HI BYTE
	MOVFW	TMP1
	SUBWF	CNTR_HI,W
	MOVWF	TMP1

	BCF	TMP1,0			; MAKE ACCEPTED WINDOW 512

M_CHECK0
	MOVFW	TMP1			; TEST IF IN WINDOW ( UPPER BYTE )
	BTFSC	STATUS,Z
	GOTO	M_CHECK2		; GO AND CHECK LOWER BYTE

	BTFSC	FLAGS,SEC_CNT		; IF SECOND COUNTER
	GOTO	M_LOOP			; ERROR - GOTO MAIN LOOP		

	BSF	FLAGS,SEC_CNT		; SET FLAG FOR SECOND COUNTER CHECK
	GOTO	M_CNT			; AND CHECK IT

M_CHECK2
	MOVFW	TMP2			; CHECK LOWER BYTE
	BZ	M_TZERO			; IF REPEAT - RESET TIMEOUT COUNTER

; ************ UPDATE EEPROM COUNTER ***********
M_UPDATE
	CALL	TX_LOOKUP		; GET CURRENT TX BASE ADDRESS
	CALL	LOAD_CNT_VALS		; LOAD COUNTER VALUES
	CALL	EEWRITE			; UPDATE FIRST COUNTER
	CALL	LOAD_CNT_VALS		; LOAD COUNTER VALUES	
	CALL	EEWRITE			; UPDATE SECOND COUNTER

; ******** UPDATE OUTPUT WITH CURRENT BUTTON CODE ********

M_OUTPUT 
	MOVLW	0F0H			; MASK ONLY BUTTON CODES
	ANDWF	FUNC,1
	SWAPF	FUNC,1			; GET BUTTON CODE FROM FUNC BYTE
	
	BTFSC	FUNC,0			; CHANGE BUTTON TO S-OUTPUT FORMAT
	BSF	FUNC,4			; [ S2 S1 S0 S3 ]
	CLRC				
	RRF	FUNC,W			
	
M_OUTPUT1
	MOVWF	PORTB			; UPDATE PORT WITH FUNCTION CODE

M_TZERO CLRF	CNT_HI			; RESET RTCC CLOCK
	CLRF	CNT_LW			

M_END	
	GOTO	M_LOOP			; WAIT FOR NEXT TRANMISSION

;------------------------------------------------------------------------------
;
; FUNCTION     	: LEARN ()	      			
;
; DESCRIPTION  	: LEARN ROUTINE
;
;------------------------------------------------------------------------------

LEARN
	CLRF	CNT_LW			; RESET TIMER
	CLRF	CNT_HI
	
	
LEARN1	BSF	PORTA,LED		; LED ON
	CALL	TST_RTCC		; UPDATE TIMER
	BTFSC	PORTA,LRN		; TEST FOR BUTTON RELEASE		
	GOTO	LEARN2			; ENTER LEARN MODE
	BTFSS	CNT_HI,0		; TEST FOR ERASE ALL
	GOTO	LEARN1			; LOOP BACK

; ******* EEPROM ERASE ALL ******************

	BCF	PORTA,LED
ERASE_ALL
	CLRWDT				; CLEAR WATCHDOG TIMER
	BTFSS	PORTA,LRN		; WAIT FOR BUTTON RELEASE
	GOTO	ERASE_ALL		; LOOP BACK

  	MOVLW	30H			; ERASE ENABLE COMMAND
	MOVWF   OUTBYT               	
        CALL    SENDC			; SEND COMMAND TO EEPROM
  	MOVLW	20H			; ERASE ALL COMMAND
	MOVWF   OUTBYT               	
        CALL    SENDC			; SEND COMMAND TO EEPROM
	CALL	WAITACK			; WAIT FOR ERASE ACK
	GOTO	RESET			; START OVER
	
LEARN2
	BCF	PORTA,LED		; CLEAR LED
	BSF	FLAGS,LRNF		; SET LEARN FLAG

LEARN3
	CALL	TST_RTCC		; UPDATE TIMER
	CALL	TST_TIMER		; CHECK FOR LEARN TIMEOUT
	CALL	RECEIVE			; RECEIVE TRANSMISSION 
	BC	LEARN3			; CHECK IF TRANSMISSION VALID
 	GOTO	M_SEARCH		; CHECK IF SERIAL NUMBER IS IN MAP

LEARN_NF

; *** IF SERIAL NOT IN MAP READ SELFLEARN POINTER ***

	MOVLW	LRNPTR			; POINT TO LEARN POINTER
	MOVWF	ADDRESS
	CALL	EEREAD			; READ LEARN POINTER FROM EEPROM

	MOVF	TMP2,W			; CHECK LOWER BYTE
	MOVLW	0H			; LOAD 0 DEFAULT
	BTFSC	STATUS,Z		; IF LOWER != 0 LEARN ON 0
	MOVF	TMP1,W			; ELSE LEARN ON TMP1 VALUE
	MOVWF	TXNUM			; LOAD TXNUM

LEARN_F
	CALL	TX_LOOKUP
	BSF	ADDRESS,1		; ADD 2 TO BASE ADDRESS
	MOVFW	SER_2			; GET LOWER 16 BIT OF SERIAL NUMBER
	MOVWF	TMP1
	MOVFW	SER_3
	MOVWF	TMP2
	CALL	EEWRITE			; ... AND WRITE TO EEPROM
	
	MOVFW	SER_0			; GET UPPER 16 BIT OF SERIAL NUMBER
	MOVWF	TMP1
	MOVFW	SER_1
	MOVWF	TMP2
	CALL	EEWRITE			; ... AND WRITE TO EEPROM

; *** DECRYPT HOP CODE ***

LEARN_DEC
	CALL	DECRYPT			; DECRYPTION ROUTINE

; *** CHECK DISCRIMINATION VALUE ***

LEARN_CHK
	MOVFW	SER_3			; CHECK LOWER BYTE OF SERIAL NUMBER
	XORWF	DISC,W			; AGAINST DISCRIMINATION VALUE
	BZ	LEARN_UP		; UPDATE LEARN POINTER
	GOTO	CANCEL_LEARN		; ERROR CANCEL LEARN MODE

; ********* UPDATE LEARN POINTER **********
LEARN_UP
	CALL	TX_LOOKUP		; GET CURRENT TX BASE ADDRESS
	CALL	LOAD_CNT_VALS
	CALL	EEWRITE			; WRITE LSB WORD OF COUNTER TO EEPROM

	BTFSC	FLAGS,RELEARN		; IF RELEARN
	GOTO	BYPASS_POINTER_WRITE	; DONT UPDATE POINTER

	INCF	TXNUM,F			; INCREMENT LEARN POINTER	       
	MOVLW	MAX_USERS     		; ALLOW 0 .. MAX_USERS - 1
	SUBWF	TXNUM,W			
	MOVLW	0H			; IF MAX WRAP TO 0
	BTFSS	STATUS,C
	MOVF	TXNUM,W			; ELSE USE TXNUM
	MOVWF	TMP1			; FOR WRITE OPERATION

	CLRF	TMP2			; CLEAR LOWER BYTE
	
	MOVLW	LRNPTR			; POINT TO LEARN POINTER
	MOVWF	ADDRESS
	CALL	EEWRITE			; UPDATE LEARN POINTER IN EEPROM

BYPASS_POINTER_WRITE

	BSF	PORTA,LED		; LED ON TO INDICATE VALID LEARN

	CLRF	CNT_LW			; CLEAR COUNTER LOW BYTE

SUCCESS
	CALL	TST_RTCC		; INDICATE SUCCESSFUL LEARN
	BTFSS	CNT_LW,4		; LED ON FOR 0.5 SEC
	GOTO	SUCCESS			; LOOP BACK

CANCEL_LEARN
	BCF	FLAGS,LRNF		; CLEAR LEARN FLAG
	BCF	FLAGS,RELEARN		; CLEAR RELEARN FLAG
	GOTO	M_LOOP			; RETURN TO MAIN LOOP - LED OFF

;------------------------------------------------------------------------------
; END OF FILE : SIMDEC10.ASM
;------------------------------------------------------------------------------

	ORG	1FFH
	GOTO	RESET
	END