ir_philips.asm

.ifnz I2C_SUPPORT ************************************************************** Function : fPro

.if IR_PHILIPS
        lda     IR_PORT
        and     #IR_IN
        cmp     rIrBitStatus
        bne     lIrBitChange
        inc     rIrBitKeepLen   ;;increase len
        lda     rIrBitKeepLen
        cmp     #IR1_MAX_PULSE_LEN
        bcs     lIrChkLastBit   ;;if len count > max -> from head
        jmp     lIrqIrExit

lIrChkLastBit:

        ;;inc     rIrBitKeepLenH
        ;;lda     rIrBitKeepLenH
        ;;cmp     #IR1_MAX_TWO_DATA_LEN
        ;;bcs     lIrDetectFromHeadTmp    ;;exceed max IR receiver time
        ;;bcs     LastBitTimeout
        ;;jmp     lClearLenExit

        ;;if last data is 1 (0,1)
        ;;  -> program can't detect the last signal "1"
LastBitTimeout:        
        lda     rRolCnt
        cmp     #12
        bne     lIrDetectFromHeadTmp1
        ;;that's last bit 1st pattern
        lda     rHasBitBefore
        beq     lIrDetectFromHeadTmp1   ;;must has 1 bit pattern
        lda     rIrBitStatus
        and     #IR_IN
        beq     lIrDetectFromHeadTmp1   ;;status is on high

        ;;clear the High count
        stz     rIrBitKeepLenH
        sec
        jmp     lIrMakeData

lIrDetectFromHeadTmp:                   ;;for split code

        ;;time out, reset the repeat
        stz     rRepValid
        stz     rIrBitKeepLenH
lIrDetectFromHeadTmp1:
        jmp     lIrDetectFromHead

lIrBitChange:
        ;;RI bit is change
        sta     rIrBitStatus    ;;keep now status

        ;;clear the High count
        stz     rIrBitKeepLenH

        jmp     lProcessIrState

;;-----------------------------------------------
SRAM_PG1:       .section        ;;PAGE1 start
;;-----------------------------------------------
lProcessIrState

        ;;detect start bit
        lda     rStartBit
        bne     lAlreadyStart

        lda     rIrBitStatus
        and     #IR_IN
        bne     lChkNextState
lIrDetectFromHead0:
        jmp     lIrDetectFromHead

lChkNextState:

        ;;before is low
        ;; check the puse width
        lda     rIrBitKeepLen
        cmp     #IR1_PULSE_LEN_MAX+10
        bcs     lIrDetectFromHead0      ;;>= max
        cmp     #IR1_PULSE_LEN_MIN
        bcc     lIrDetectFromHead0      ;;<min
        cmp		#IR1_PULSE_LEN
        bcc     lStartBitNoData     
        lda     #1
        sta		rHasBitBefore
lStartBitNoData:
        lda     #1
        sta     rStartBit
        jmp     lClearLenExit

lAlreadyStart:


        ;;check 1 or 2 bit follow the time lenght
        lda     rIrBitKeepLen
        cmp     #IR1_PULSE_LEN_MIN
        bcc     lIrDetectFromHead       ;;<min
        cmp     #IR1_PULSE_LEN
        bcc     lHas1Bit

        ;;is 2 bit length, so before should be has data
        lda     rHasBitBefore
        beq     lIrDetectFromHead

        ;;To make Logic data
        jmp     lToMakeCurLogic

lHas1Bit:

        lda     rHasBitBefore
        bne     lToMakeCurLogicFrom1Bit


        ;;has 1 bit keep
        lda     #1
        sta     rHasBitBefore
        jmp     lClearLenExit

lToMakeCurLogicFrom1Bit:
        ;;before bit is using, so clear flag
        stz     rHasBitBefore

lToMakeCurLogic:

        inc     rRolCnt

        lda     rIrBitStatus
        and     #IR_IN
        bne     lIrLogicIsLow           ;;before bit=0 => 1,0 is low
        sec
        bcs     lIrMakeData             ;;jmp
lIrLogicIsLow:
        clc

lIrMakeData:

        rol     rIrReceiver
        rol     rIrReceiver+1
        bcc     lClearLenExit

        ;;data receiver complete, check data correct
        ;;lda		rIrReceiver+1           ;;check bit12=1
        ;;and		#%00010000
        ;;bne		lIrDetectFromHead
        ;;bbs		4,rIrReceiver+1,lIrDetectFromHead
        
        
        ;;save address code
        lda     rIrReceiver+1
        sta		IOP_DATA6_H
        lda     rIrReceiver
        sta		IOP_DATA6_L
        
        lda     IOP_DATA5_L
        sta     rIrCodePerv             ;;keep old

        lda     rIrReceiver
        and		#$3f					;;keep 6bit data
        sta     IOP_DATA5_L             ;;save code

.if 0	;;standby mode code
		;;check power key
		lda		bCheckIRPower
		beq		lNotEqualIR
		lda		IOP_DATA5_L
		cmp		IRPowerCode
		bne		lNotEqualIR	
		jmp		lResetAll

lNotEqualIR:
.endif

        cmp     rIrCodePerv
        bne     lIrKeyNotSame

        ;;some Ir key before
        lda     rRepValid
        beq     lIrKeyNotSame           ;;has timeout before
                                        ;; so must keep this key
        ;;check repeat count
        lda     rIrRepeateRate
        beq     lIrKeyRepeat
        dec     rIrRepeateRate
        jmp     lIrDetectFromHead       ;;skip this key
lIrKeyRepeat:
        lda     IOP_DATA5_H
        ora     #IR_REPEAT
        bne     lSetRepFlagOk
lIrKeyNotSame:
        lda     IOP_DATA5_H
        and     #!IR_REPEAT
lSetRepFlagOk:

        ;;check has old key be cover
        bit     IOP_DATA5_H
        bpl     lNotCoverKey
        ora     #IR_REPLACE
        bne     lSetFlagOk
lNotCoverKey:
        and     #!IR_REPLACE
lSetFlagOk:
        ora     #IR_READY
        sta     IOP_DATA5_H             ;;save to IOP_DATA5_H
        sta     rRepValid               ;;can accept repeat

        ;;re-load repeat count
        and     #$0f
        sta     rIrRepeateRate

        ;;detect from head
;;**************************************************************
lIrDetectFromHead:

        lda     #%00001111      ;;detect bit 13
        sta     rIrReceiver
        stz     rIrReceiver+1
        stz     rHasBitBefore
        stz     rStartBit
        stz     rRolCnt

lClearLenExit:
        lda     #1
        sta     rIrBitKeepLen
.endif