ref_node.s51

zigbee location examples

        CFI DPH0 Frame(CFA_SP, 5)
        CFI CFA_SP SP+-5
        ; Saved register size: 2
        ; Auto size: 0
//  258    INT_SETFLAG(INUM_ST, INT_CLR);
        CLR	0xc0.7
//  259 
//  260    switch (refNodeState){
        MOV	DPTR,#refNodeState
        MOVX	A,@DPTR
        LCALL	?UC_SWITCH_DENSE
`?<Jumptable for ST_IRQ_RefNode>_0`:
        DB        0
        DB        2
        DW        ??ST_IRQ_RefNode_0
        DW        ??ST_IRQ_RefNode_1
        DW        ??ST_IRQ_RefNode_0
        DW        ??ST_IRQ_RefNode_2
//  261    case AWAKE_STATE:
//  262       refNodeState = SLEEP_STATE;
??ST_IRQ_RefNode_1:
        MOV	A,#0x1
        MOV	DPTR,#refNodeState
        MOVX	@DPTR,A
//  263       AddToSleepTimer(REF_NODE_SLEEP_TIME);
        ; Setup parameters for call to function AddToSleepTimer
        MOV	R2,#-0x12
        MOV	R3,#0x2
??ST_IRQ_RefNode_3:
        MOV	DPTR,#(AddToSleepTimer & 0xffff)
        MOV	A,#((AddToSleepTimer >> 16) & 0xff)
        LCALL	?BCALL               ; Banked call to: DPTR()
        SJMP	??ST_IRQ_RefNode_4
//  264       break;
//  265    case SLEEP_STATE:
//  266       refNodeState = AWAKE_STATE;
??ST_IRQ_RefNode_0:
        CLR	A
        MOV	DPTR,#refNodeState
        MOVX	@DPTR,A
//  267       AddToSleepTimer(REF_NODE_POWER_UP_TIME);
        ; Setup parameters for call to function AddToSleepTimer
        MOV	R2,#-0x6
        MOV	R3,A
        SJMP	??ST_IRQ_RefNode_3
//  268       break;
//  269    case BLINK_LED_STATE:
//  270       LED1 ^= 1;
??ST_IRQ_RefNode_2:
        XRL	0x90,#0x1
        MOV	A,0x90
//  271       ledBlinkCounter++;
        MOV	DPTR,#ledBlinkCounter
        MOVX	A,@DPTR
        INC	A
        MOVX	@DPTR,A
//  272       AddToSleepTimer(LED_BLINK_TIME);
        ; Setup parameters for call to function AddToSleepTimer
        MOV	R2,#0x64
        MOV	R3,#0x0
        MOV	DPTR,#(AddToSleepTimer & 0xffff)
        MOV	A,#((AddToSleepTimer >> 16) & 0xff)
        LCALL	?BCALL               ; Banked call to: DPTR()
//  273       if(ledBlinkCounter > NBR_OF_LED_BLINK * 2){
        MOV	DPTR,#ledBlinkCounter
        MOVX	A,@DPTR
        CLR	C
        SUBB	A,#0x15
        JC	??ST_IRQ_RefNode_4
//  274          refNodeState = AWAKE_STATE;
        CLR	A
        MOV	DPTR,#refNodeState
        MOVX	@DPTR,A
//  275          LED1 = LED_OFF;
        SETB	0x90.0
//  276       }
//  277       break;
//  278    default:
//  279       refNodeState = AWAKE_STATE;
//  280       AddToSleepTimer(REF_NODE_POWER_UP_TIME);
//  281       break;
//  282    }
//  283 }
??ST_IRQ_RefNode_4:
        POP	DPH
        CFI DPH0 SameValue
        CFI CFA_SP SP+-4
        POP	DPL
        CFI DPL0 SameValue
        CFI CFA_SP SP+-3
        LJMP	?BRET
        CFI EndBlock cfiBlock3
//  284 
//  285 /******************************************************************************
//  286 *
//  287 * Function which sets up an DMA transfer to the FLASH writing interface
//  288 ******************************************************************************/

        RSEG NEAR_CODE:CODE:NOROOT(0)
//  289 __near_func void setUpDmaToFlash(void){
setUpDmaToFlash:
        CFI Block cfiBlock4 Using cfiCommon0
        CFI Function setUpDmaToFlash
        PUSH	DPL
        CFI DPL0 Frame(CFA_SP, 3)
        CFI CFA_SP SP+-3
        PUSH	DPH
        CFI DPH0 Frame(CFA_SP, 4)
        CFI CFA_SP SP+-4
        ; Saved register size: 2
        ; Auto size: 0
//  290    SET_WORD(dmaChannel.SRCADDRH, dmaChannel.SRCADDRL, flashEntries); // The start address of the segment
        MOV	A,#((flashEntries >> 8) & 0xff)
        MOV	DPTR,#dmaChannel
        MOVX	@DPTR,A
        MOV	A,#(flashEntries & 0xff)
        MOV	DPTR,#(dmaChannel + 1)
        MOVX	@DPTR,A
//  291    SET_WORD(dmaChannel.DESTADDRH, dmaChannel.DESTADDRL, &X_FWDATA);  // Input of the AES module
        MOV	A,#-0x21
        MOV	DPTR,#(dmaChannel + 2)
        MOVX	@DPTR,A
        MOV	A,#-0x51
        MOV	DPTR,#(dmaChannel + 3)
        MOVX	@DPTR,A
//  292    SET_WORD(dmaChannel.LENH, dmaChannel.LENL, 16);                   // Setting the length of the transfer (bytes)
        MOV	DPTR,#(dmaChannel + 4)
        MOVX	A,@DPTR
        ANL	A,#0xe0
        MOVX	@DPTR,A
        MOV	DPTR,#(dmaChannel + 5)
        MOVX	A,@DPTR
        MOV	A,#0x10
        MOVX	@DPTR,A
//  293    dmaChannel.VLEN      = VLEN_USE_LEN;      // Using the length field
        MOV	DPTR,#(dmaChannel + 4)
        MOVX	A,@DPTR
        ANL	A,#0x1f
        MOVX	@DPTR,A
//  294    dmaChannel.PRIORITY  = PRI_HIGH;          // High priority
        MOV	DPTR,#(dmaChannel + 7)
        MOVX	A,@DPTR
        ANL	A,#0xfc
        ORL	A,#0x2
        MOVX	@DPTR,A
//  295    dmaChannel.M8        = M8_USE_8_BITS;     // Transferring all 8 bits in each byte.
        MOVX	A,@DPTR
        CLR	0xE0 /* A   */.2
        MOVX	@DPTR,A
//  296    dmaChannel.IRQMASK   = FALSE;             // The DMA complete interrupt flag is set at completion.
        MOVX	A,@DPTR
        CLR	0xE0 /* A   */.3
        MOVX	@DPTR,A
//  297    dmaChannel.DESTINC   = DESTINC_0;         // The destination address is constant
        MOVX	A,@DPTR
        ANL	A,#0xcf
        MOVX	@DPTR,A
//  298    dmaChannel.SRCINC    = SRCINC_1;          // The address for data fetch is inremented by 1 byte
        MOVX	A,@DPTR
        ANL	A,#0x3f
        ORL	A,#0x40
        MOVX	@DPTR,A
//  299    dmaChannel.TRIG      = DMATRIG_FLASH;     // Setting the FLASH module to generate the DMA trigger
        MOV	DPTR,#(dmaChannel + 6)
        MOVX	A,@DPTR
        ANL	A,#0xe0
        ORL	A,#0x12
        MOVX	@DPTR,A
//  300    dmaChannel.TMODE     = TMODE_SINGLE;      // A single byte is transferred each time.
        MOVX	A,@DPTR
        ANL	A,#0x9f
        MOVX	@DPTR,A
//  301    dmaChannel.WORDSIZE  = WORDSIZE_BYTE;     // Set to count bytes.
        MOVX	A,@DPTR
        CLR	0xE0 /* A   */.7
        MOVX	@DPTR,A
//  302 
//  303    DMA_SET_ADDR_DESC0(&dmaChannel);
        MOV	A,#((dmaChannel >> 8) & 0xff)
        MOV	0xd5,A
        MOV	0xd4,#(dmaChannel & 0xff)
//  304    DMA_ABORT_CHANNEL(0);
        MOV	0xd6,#-0x7f
        CFI EndBlock cfiBlock4
//  305 }
        REQUIRE ?Subroutine0
        ; // Fall through to label ?Subroutine0

        RSEG NEAR_CODE:CODE:NOROOT(0)
?Subroutine0:
        CFI Block cfiBlock5 Using cfiCommon0
        CFI NoFunction
        CFI CFA_SP SP+-4
        CFI DPL0 Frame(CFA_SP, 3)
        CFI DPH0 Frame(CFA_SP, 4)
        POP	DPH
        CFI CFA_SP SP+-3
        CFI DPH0 SameValue
        POP	DPL
        CFI CFA_SP SP+-2
        CFI DPL0 SameValue
        RET
        CFI EndBlock cfiBlock5
//  306 
//  307 
//  308 
//  309 /******************************************************************************
//  310 *
//  311 * Function that performs the actual flash writing
//  312 ******************************************************************************/

        RSEG NEAR_CODE:CODE:NOROOT(0)
//  313 __near_func writeToFlash(void){
writeToFlash:
        CFI Block cfiBlock6 Using cfiCommon0
        CFI Function writeToFlash
        MOV	A,#-0x9
        LCALL	?FUNC_ENTER_XDATA
        CFI DPH0 load(1, XDATA, add(CFA_XSP16, literal(-1)))
        CFI DPL0 load(1, XDATA, add(CFA_XSP16, literal(-2)))
        CFI ?RET_HIGH load(1, XDATA, add(CFA_XSP16, literal(-3)))
        CFI ?RET_LOW load(1, XDATA, add(CFA_XSP16, literal(-4)))
        CFI R7 load(1, XDATA, add(CFA_XSP16, literal(-5)))
        CFI V1 load(1, XDATA, add(CFA_XSP16, literal(-6)))
        CFI V0 load(1, XDATA, add(CFA_XSP16, literal(-7)))
        CFI VB load(1, XDATA, add(CFA_XSP16, literal(-8)))
        CFI R6 load(1, XDATA, add(CFA_XSP16, literal(-9)))
        CFI CFA_SP SP+0
        CFI CFA_XSP16 add(XSP16, 9)
        ; Saved register size: 9
        ; Auto size: 0
//  314    //store data in flash
//  315    SET_WORD(FADDRH, FADDRL, ((UINT16)pFlashEntry >> 2) | 0x4000 );
        MOV	DPTR,#pFlashEntry
        MOVX	A,@DPTR
        MOV	?V0 + 0,A
        INC	DPTR
        MOVX	A,@DPTR
        MOV	?V0 + 1,A
        MOV	A,#0x2
        MOV	R0,#?V0 + 0
        LCALL	?US_SHR
        MOV	R1,?V0 + 1
        MOV	A,#0x40
        ORL	A,R1
        MOV	R3,A
        CLR	A
        XCH	A,R3
        MOV	R2,A
        MOV	0xad,A
        MOV	A,?V0 + 0
        MOV	0xac,A
//  316 
//  317    // Storing old settings and setting up the DMA.
//  318    // Clearing all DMA complete flags and arming the channel.
//  319    DMAIRQ &= ~DMA_CHANNEL_0;
        ANL	0xd1,#0xfe
//  320    DMA_ARM_CHANNEL(0);
        MOV	0xd6,#0x1
//  321 
//  322    FLASH_CONFIG(WRITE);
        MOV	A,#0x7
        ANL	A,0xc6
        MOV	R0,A
        MOV	A,#0x2a
        CJNE	R0,#0x0,??writeToFlash_0
        SJMP	??writeToFlash_1
??writeToFlash_0:
        MOV	C,0xE0 /* A   */.7
        RRC	A
        DJNZ	R0,??writeToFlash_0
??writeToFlash_1:
        MOV	0xab,A
        MOV	0xae,#0x2
//  323    asm("NOP");
        NOP
//  324 
//  325    // Waiting for the DMA to finish.
//  326    while(!(DMAIRQ & DMA_CHANNEL_0));
??writeToFlash_2:
        MOV	A,0xd1
        MOV	C,0xE0 /* A   */.0
        JNC	??writeToFlash_2
//  327    DMAIRQ &= ~DMA_CHANNEL_0;
        ANL	0xd1,#0xfe
//  328 }
        MOV	R7,#0x2
        LJMP	?FUNC_LEAVE_XDATA
        CFI EndBlock cfiBlock6
//  329 
//  330 
//  331 
//  332 /******************************************************************************
//  333 *
//  334 * Function which finds the newest entry in the flash
//  335 * the pFlashEntry pointer is set.
//  336 ******************************************************************************/

        RSEG NEAR_CODE:CODE:NOROOT(0)
//  337 __near_func BOOL findNewestEntry(void){
findNewestEntry:
        CFI Block cfiBlock7 Using cfiCommon0
        CFI Function findNewestEntry
        PUSH	DPL
        CFI DPL0 Frame(CFA_SP, 3)
        CFI CFA_SP SP+-3
        PUSH	DPH
        CFI DPH0 Frame(CFA_SP, 4)
        CFI CFA_SP SP+-4
        ; Saved register size: 2
        ; Auto size: 0
//  338    WORD index = 0;
        MOV	R0,#0x0
        MOV	R1,#0x0
//  339    // setting correct start location
//  340    SET_MEMORY_BANK(XYZ_BANK);
        ORL	0xc7,#0x30
        MOV	A,0xc7
//  341    pFlashEntry = (FLASH_ENTRY __code*) XYZ_FLASH_ADDRESS;
        MOV	DPTR,#pFlashEntry
        CLR	A
        MOVX	@DPTR,A
        INC	DPTR
        MOV	A,#-0x10
        MOVX	@DPTR,A
//  342 
//  343    //start to search
//  344    while(pFlashEntry->status[0] == 0x00)
??findNewestEntry_0:
        MOV	DPTR,#pFlashEntry
        MOVX	A,@DPTR
        MOV	R2,A
        INC	DPTR
        MOVX	A,@DPTR
        MOV	DPH,A
        MOV	DPL,R2
        CLR	A
        MOVC	A,@A+DPTR
        JNZ	??findNewestEntry_1
//  345    {
//  346       // the length pointer is incremented with the number of bytes in the structure that is pointed to
//  347       pFlashEntry++;
        MOV	DPTR,#pFlashEntry
        MOVX	A,@DPTR
        ADD	A,#0x8
        MOV	R2,A
        INC	DPTR
        MOVX	A,@DPTR
        ADDC	A,#0x0
        MOV	R3,A
        MOV	DPTR,#pFlashEntry
        MOV	A,R2
        MOVX	@DPTR,A
        INC	DPTR
        MOV	A,R3
        MOVX	@DPTR,A
//  348       index++;
        MOV	A,R0
        ADD	A,#0x1
        INC	R0
        MOV	A,R1
        ADDC	A,#0x0
        MOV	R1,A
//  349       if(index == NUMBER_OF_FLASH_ENTRIES - 1){
        MOV	A,#-0x1
        XRL	A,R0
        JNZ	??findNewestEntry_2
        MOV	A,R1
??findNewestEntry_2:
        JNZ	??findNewestEntry_0
//  350          return FALSE;
        MOV	R1,#0x0
        SJMP	??findNewestEntry_3
//  351       }
//  352    }
//  353    return TRUE;
??findNewestEntry_1:
        MOV	R1,#0x1
??findNewestEntry_3:
        LJMP	?Subroutine0
        CFI EndBlock cfiBlock7
//  354 }
//  355 
//  356 /******************************************************************************
//  357 *
//  358 * Sets the node coordinates according to the coordinates in flash
//  359 ******************************************************************************/

        RSEG NEAR_CODE:CODE:NOROOT(0)
//  360 __near_func BOOL getCoordinates() {
getCoordinates:
        CFI Block cfiBlock8 Using cfiCommon0
        CFI Function getCoordinates
        FUNCALL getCoordinates, findNewestEntry
        LOCFRAME XSTACK, 8, STACK
        ARGFRAME XSTACK, 8, STACK
        MOV	A,#-0x8
        LCALL	?FUNC_ENTER_XDATA
        CFI DPH0 load(1, XDATA, add(CFA_XSP16, literal(-1)))
        CFI DPL0 load(1, XDATA, add(CFA_XSP16, literal(-2)))
        CFI ?RET_HIGH load(1, XDATA, add(CFA_XSP16, literal(-3)))
        CFI ?RET_LOW load(1, XDATA, add(CFA_XSP16, literal(-4)))
        CFI R7 load(1, XDATA, add(CFA_XSP16, literal(-5)))