mac_timer_isr.s51

zigbee location examples

#include "ioCC2430.h"
#include <iar_check_symbols.h>

; External symbols and constants
#if (__CODE_MODEL__ == __CM_BANKED__)
MAC_CALLBACK_INFO_SIZE  EQU     9
#else
MAC_CALLBACK_INFO_SIZE  EQU     8
#endif
MAC_CALLBACK_PAGE       EQU 	0
MAC_CALLBACK_COUNT      EQU 	12
NO_CALLBACK             EQU     0FFH
T2_VECTOR_ADDR          EQU     0x53
MAC_BANK_MEMCTR         EQU     0x30

                EXTERN  mschDoTask
                EXTERN  firstCallback
                EXTERN  intAlreadyOff
                EXTERN  pMtimCallbacks

#if (__CODE_MODEL__ == __CM_BANKED__)
                EXTERN  ?BCALL
#endif
                EXTERN  ?INTERRUPT_ENTER_XSP
                EXTERN  ?INTERRUPT_LEAVE_XSP

                ; Using AJMP to make sure that the ISR is put in the lower 32 kB of the flash (not bank switched)
                COMMON  INTVEC(1)
                ORG     T2_VECTOR_ADDR
 	            AJMP    mtimTickIsr;

                RSEG    RCODE
fakeReti:	    RETI;
		
                PUBLIC mtimTickIsr;
		        ; Push all necessary registers onto the stack
mtimTickIsr:    PUSH 	ACC;
                MOV     A, #0F2H;
                LCALL   ?INTERRUPT_ENTER_XSP;

                ; Disable interrupts...
         		CLR	    EA;

         		; Clear the compare event and period event flags before running the fake RETI instruction
                ANL	    T2CNF, #3FH;
         		CLR	    T2IF;
         		ACALL	fakeReti;
		
         		; Are there any callbacks? (if not, then skip callback handling)
doCallback: 	MOV 	A, firstCallback;
                JB	    ACC.7, doTask;

                ; We're using PDATA mapping to fetch the callback struct
                MOV 	MPAGE, #MAC_CALLBACK_PAGE + 0E0H;

                ; Let R0 point to the next MAC_CALLBACK_INFO struct
                MOV 	B, #MAC_CALLBACK_INFO_SIZE;
                MUL	    AB;
                MOV 	R0, A;

                ; Fetch the least significant byte (R0 points to it)
                MOVX	A, @R0;

                ; Do we need to borrow from the higher byte(s)?
                JZ	    fullTimeoutDecr;

                ; Decrement and check for timeout if we've reached zero
                DEC 	A;
                MOVX	@R0, A;
                JNZ	    noTimeout;

                ; Check for timeout by getting the more significant bytes
                INC	    R0;
                MOVX	A, @R0;
                JNZ	    noTimeout;
                INC	    R0;
                MOVX	A, @R0;
                JNZ	    noTimeout;

                ; Timeout reached, so here we go...

                ; Move our pointer, R0, past the timeout counter
                INC     R0;
                INC     R0;

                ; Move on the firstCallback flag
anotherCallback:
                MOVX	A, @R0;
                MOV	    firstCallback, A;

                ; Clear the occupied flag
                INC 	R0;
                CLR 	A;
                MOVX	@R0, A;

#if (__CODE_MODEL__ == __CM_BANKED__)
#else
    ; set up return address
                MOV     A, #LOW chkAdditional
                PUSH    A
                MOV     A, #HIGH chkAdditional
                PUSH    A
#endif
                ; Put the function address into DPTR and the bank number into A
                INC	    R0;
                MOVX	A, @R0;
                MOV	    DPL, A;
                INC	    R0;
                MOVX	A, @R0;
                MOV	    DPH, A;
                INC     R0;

#if (__CODE_MODEL__ == __CM_BANKED__)
                ; Make the banked function call
                MOVX    A, @R0;
                LCALL   ?BCALL;
#else
                CLR     A
                JMP     @A+DPTR   ; Call subroutine
#endif
                ; Check for additional callbacks
chkAdditional:  MOV	    A, firstCallback;
                JB	    ACC.7, doTask;

                ; Let R0 point to the next MAC_CALLBACK_INFO struct
                MOV 	B, #MAC_CALLBACK_INFO_SIZE;
                MUL	    AB;
                MOV	    R0, A;

                ; Timeout already now?
                MOVX	A, @R0  ;
                JNZ	    noTimeout;
                INC	    R0;
                MOVX	A, @R0;
                JNZ	    noTimeout;
                INC	    R0;
                MOVX	A, @R0;
                JNZ	    noTimeout;
                INC	    R0;
                INC	    R0;
                SJMP	anotherCallback;

                SJMP	doTask;
			
fullTimeoutDecr:	
                ; Do full decrement with borrow (at this point A = LSB(timeout))
                DEC 	A;
                MOVX	@R0, A;

                ; Middle byte
                INC	    R0;
                MOVX	A, @R0;
                DEC	    A;
                MOVX	@R0, A;
                CJNE    A, #0FFH, noTimeout;

                ; MSB
                INC	    R0;
                MOVX	A, @R0;
                DEC	    A;
                MOVX	@R0, A;

noTimeout:		; Done (there is no timeout since LSB = 0xFF)

doTask:		    LCALL   mschDoTask;

                ; Exit the interrupt service routine
                MOV     R7, #01H
                SETB    EA;
                LJMP    ?INTERRUPT_LEAVE_XSP;
                RET;

                END;