mac_tx_engine.s51

zigbee location examples

        MOVX	A,@DPTR
        JZ	??mtxCalcCspTimeout_2
//  232                 //        <----------------- The CAP duration -----------------> - <--------- Used CAP ----------> - <---- Overhead ----->
//  233                 bosLeft = (mbcnInfo.beaconDuration + mpib.macBattLifeExtPeriods) - (T2_GET_OVERFLOW_COUNTER() + 1) - (MTX_START_CSP_DELAY);
        MOV	DPTR,#(mbcnInfo + 4)
        MOVX	A,@DPTR
        MOV	R0,A
        MOV	DPTR,#(mpib + 4)
        MOVX	A,@DPTR
        ADD	A,R0
        MOV	?V0 + 4,A
        CLR	A
        ADDC	A,#0x0
        MOV	?V0 + 5,A
        MOV	?V0 + 6,#0x0
        MOV	?V0 + 7,#0x0
        ; Setup parameters for call to function T2_GET_OVERFLOW_COUNTER
        MOV	DPTR,#(T2_GET_OVERFLOW_COUNTER & 0xffff)
        MOV	A,#((T2_GET_OVERFLOW_COUNTER >> 16) & 0xff)
        LCALL	?BCALL               ; Banked call to: DPTR()
        MOV	?V0 + 0,R2
        MOV	?V0 + 1,R3
        MOV	?V0 + 2,R4
        MOV	?V0 + 3,R5
        MOV	R0,#?V0 + 4
        MOV	R1,#?V0 + 0
        LCALL	?L_SUB
        MOV	DPTR,#__Constant_fffffffd
        MOV	R0,#?V0 + 4
        LCALL	?L_ADD_X
        SJMP	??mtxCalcCspTimeout_3
//  234             } else {
//  235                 //        <- The CAP duration > - <--------- Used CAP ----------> - <------------- Overhead + duration -------------> - <-- Beacon margin -->
//  236                 bosLeft = msupCalcCapDuration() - (T2_GET_OVERFLOW_COUNTER() + 1) - (MTX_START_CSP_DELAY + mtxInfo.pPacket->duration) - mbcnGetBeaconMargin();
??mtxCalcCspTimeout_2:
        ; Setup parameters for call to function msupCalcCapDuration
        LCALL	msupCalcCapDuration & 0xFFFF
        MOV	?V0 + 4,R2
        MOV	?V0 + 5,R3
        MOV	?V0 + 6,R4
        MOV	?V0 + 7,R5
        ; Setup parameters for call to function T2_GET_OVERFLOW_COUNTER
        MOV	DPTR,#(T2_GET_OVERFLOW_COUNTER & 0xffff)
        MOV	A,#((T2_GET_OVERFLOW_COUNTER >> 16) & 0xff)
        LCALL	?BCALL               ; Banked call to: DPTR()
        MOV	?V0 + 0,R2
        MOV	?V0 + 1,R3
        MOV	?V0 + 2,R4
        MOV	?V0 + 3,R5
        ; Setup parameters for call to function mbcnGetBeaconMargin
        MOV	DPTR,#(mbcnGetBeaconMargin & 0xffff)
        MOV	A,#((mbcnGetBeaconMargin >> 16) & 0xff)
        LCALL	?BCALL               ; Banked call to: DPTR()
        MOV	A,R1
        MOV	R2,A
        MOV	R0,#?V0 + 4
        MOV	R1,#?V0 + 0
        LCALL	?L_SUB
        MOV	DPTR,#__Constant_ffffffff
        MOV	R0,#?V0 + 4
        LCALL	?L_ADD_X
        MOV	DPTR,#mtxInfo
        MOVX	A,@DPTR
        ADD	A,#-0x7b
        MOV	R0,A
        INC	DPTR
        MOVX	A,@DPTR
        ADDC	A,#0x0
        MOV	R1,A
        MOV	DPL,R0
        MOV	DPH,R1
        MOVX	A,@DPTR
        MOV	R0,A
        MOV	A,#0x2
        ADD	A,R0
        MOV	?V0 + 0,A
        CLR	A
        ADDC	A,#0x0
        MOV	?V0 + 1,A
        MOV	?V0 + 2,#0x0
        MOV	?V0 + 3,#0x0
        MOV	R0,#?V0 + 4
        MOV	R1,#?V0 + 0
        LCALL	?L_SUB
        MOV	?V0 + 0,R2
        MOV	?V0 + 1,#0x0
        MOV	R0,#?V0 + 4
        MOV	R1,#?V0 + 0
        LCALL	?L_SUB
//  237             }
//  238         } else
//  239             bosLeft = 0;
//  240     }
//  241 
//  242     // Calculate the CSP timeout
//  243     if (bosLeft >= CSP_TIMEOUT_RUN_FOREVER) {
??mtxCalcCspTimeout_3:
        MOV	DPTR,#__Constant_ff
        MOV	R0,#?V0 + 0
        LCALL	?L_MOV_X
        MOV	R0,#?V0 + 0
        MOV	R1,#?V0 + 4
        LCALL	?SL_GT
        JC	??mtxCalcCspTimeout_4
//  244         return CSP_TIMEOUT_RUN_FOREVER;
??mtxCalcCspTimeout_0:
        MOV	R1,#-0x1
        SJMP	??mtxCalcCspTimeout_5
//  245     } else if (bosLeft < 1) {
??mtxCalcCspTimeout_4:
        MOV	DPTR,#__Constant_1
        MOV	R0,#?V0 + 0
        LCALL	?L_MOV_X
        MOV	R0,#?V0 + 0
        MOV	R1,#?V0 + 4
        LCALL	?SL_GT
        JNC	??mtxCalcCspTimeout_6
//  246         return CSP_TIMEOUT_STOP;
??mtxCalcCspTimeout_1:
        MOV	R1,#0x0
        SJMP	??mtxCalcCspTimeout_5
//  247     } else {
//  248         return (UINT8) bosLeft;
??mtxCalcCspTimeout_6:
        MOV	R1,?V0 + 4
??mtxCalcCspTimeout_5:
        MOV	R7,#0x8
        LJMP	?BANKED_LEAVE_XDATA
        CFI EndBlock cfiBlock5
//  249     }
//  250 
//  251 } // mtxCalcCspTimeout
//  252 
//  253 
//  254 
//  255 
//  256 //-------------------------------------------------------------------------------------------------------
//  257 //  void mtxResumeAfterBeacon(void)
//  258 //
//  259 //  DESCRIPTION:
//  260 //      Resumes transmission after the beacon has been received, if there is a sufficient number of
//  261 //      backoff slot left in the CAP.
//  262 //-------------------------------------------------------------------------------------------------------
//  263 void mtxResumeAfterBeaconCallback(void) NEAR { mschAddTask(mschReserveTask(), MAC_TASK_PRI_HIGH, mtxResumeAfterBeaconTask, NULL); }
//  264 void mtxResumeAfterBeaconTask(MAC_TASK_INFO   *pTask) NEAR { mtxResumeAfterBeacon(); mschRemoveTask(pTask->priority, MSCH_KEEP_TASK_IN_PROGRESS_BM); }
//  265 void mtxResumeAfterBeacon(void) NEAR {
//  266     if (mtxInfo.waitForBeacon) {
//  267 
//  268         // Cancel beacon search when enabled (the WAIT -> OUT_OF_CAP state will turn it back on if necessary)
//  269         if (mtxInfo.beaconSearchEnabled) {
//  270             mrxDecrOnCounter();
//  271             mtxInfo.beaconSearchEnabled = FALSE;
//  272             mtxInfo.beaconSearchTimeout = FALSE;
//  273             mtimCancelCallback(mtxBeaconSearchTimeout);
//  274         }
//  275 
//  276         // Go ahead if there's sufficient CAP left (otherwise remain in the OUT_OF_CAP state)
//  277         if (T2_IS_CAP_ACTIVE()) {
//  278             mtxInfo.waitForBeacon = FALSE;
//  279             mtxInfo.status = MTX_STATUS_WAITING;
//  280             mtxInfo.cspTimeout = mtxCalcCspTimeout();
//  281 
//  282             if (mtxInfo.cspTimeout) {
//  283                 mtxCreateStartTask();
//  284                 mtxInfo.status = MTX_STATUS_WAITING;
//  285             } else {
//  286                 mtxInfo.status = MTX_STATUS_OUT_OF_CAP;
//  287             }
//  288         }
//  289     }
//  290 } // mtxResumeAfterBeacon
//  291 
//  292 
//  293 
//  294 void mtxResetBosCounter(void) NEAR {
//  295 
//  296     // New CAP begins
//  297     T2_SET_OVERFLOW_COUNTER(0x00000);
//  298     T2_SET_OVERFLOW_COUNTER_COMPARE_VALUE(msupCalcCapDuration());
//  299     T2_SET_CAP_ACTIVE();
//  300 
//  301     // Schedule the next beacon handler
//  302     if (mpib.macBeaconOrder != 15) {
//  303         mtimSetCallback(mbcnTxPeriodicalBeacon, msupCalcBeaconInterval() - MBCN_TX_STARTUP_OVERHEAD - MBCN_TX_PREPARE_TIME);
//  304     }
//  305 }
//  306 
//  307 
//  308 
//  309 
//  310 //-------------------------------------------------------------------------------------------------------
//  311 //  void mtxAckTimeout(void)
//  312 //
//  313 //  DESCRIPTION:
//  314 //-------------------------------------------------------------------------------------------------------
//  315 void mtxAckTimeout(void) NEAR {
//  316     mrxDecrOnCounter();
//  317     FSMTC1 &= ~FSMTC1_ACCEPT_ACKPKT_BM;
//  318     if (mtxInfo.status == MTX_STATUS_WAITING_FOR_ACK) {
//  319         mtxInfo.status = MTX_STATUS_ACK_TIMEOUT;
//  320     }
//  321 } // mtxAckTimeout
//  322 
//  323 
//  324 
//  325 
//  326 //-------------------------------------------------------------------------------------------------------
//  327 //  void mtxScheduleTransmission(MAC_TASK_INFO *pTask)
//  328 //
//  329 //  DESCRIPTION:
//  330 //      This task is created to start a transmission. The task is responsible for setting up the CSMA-CA
//  331 //      mechanism, scheduling the transmission, and handle the result when the packet timeout is trigged.
//  332 //      Note: Periodically transmitted beacons bypass this task and uses mtxStartTransmission directly.
//  333 //-------------------------------------------------------------------------------------------------------
//  334 void mtxScheduleTransmission(MAC_TASK_INFO   *pTask) NEAR {
//  335     MAC_TX_PACKET   *pPacket = (MAC_TX_PACKET   *) pTask->taskData;
//  336 
//  337     switch (pTask->state) {
//  338     case MTX_STATE_INIT_TRANSMISSION:
//  339         // Reschedule this task if we're in scan mode and the "scan related" flag is not set on this packet
//  340         if ((macInfo.state & MAC_STATE_SCAN_BM) && !(pPacket->txMode & MTX_MODE_SCAN_RELATED_BM)) {
//  341             mschRescheduleTask(pTask, MTX_STATE_INIT_TRANSMISSION);
//  342             return;
//  343         }
//  344 
//  345         // Set the TX engine packet pointer
//  346         mtxInfo.pPacket = pPacket;
//  347 
//  348         // No break here!
//  349 
//  350     case MTX_STATE_PROCESS_SECURITY:
//  351         pTask->state = MTX_STATE_PREPARE_STARTUP;
//  352         break;
//  353 
//  354     case MTX_STATE_RETRY_TRANSMISSION:
//  355     case MTX_STATE_PREPARE_STARTUP:
//  356 
//  357         // Bail out if beacon transmission is in progress
//  358 #if MAC_OPT_FFD
//  359         if (mtxInfo.beaconTransmissionInProgress) {
//  360             if ((pPacket->txOptions & TX_OPT_INDIRECT)) {
//  361                 miqSetRequested(pPacket, FALSE);
//  362                 pPacket->transmissionStarted = FALSE;
//  363                 mschRemoveTask(pTask->priority, MSCH_KEEP_TASK_IN_PROGRESS_BM);
//  364             }
//  365             break;
//  366         }
//  367 #endif
//  368 
//  369         // Reset CSMA-CA parameters
//  370         mtxInfo.nb = mpib.macMaxCsmaBackoffs;
//  371         mtxInfo.be = mpib.macMinBE;
//  372         pPacket->slotted = !(BYTE)((mpib.macBeaconOrder == 15) || (pPacket->txMode & MTX_MODE_FORCE_UNSLOTTED_BM));
//  373         if (pPacket->slotted && mpib.macBattLifeExt) {
//  374             mtxInfo.be = (BYTE)(MIN(2, mtxInfo.be));
//  375         }
//  376 
//  377         // No break here!
//  378 
//  379     case MTX_STATE_SWITCHED_TO_UNSLOTTED:
//  380         mtxInfo.randomBackoff = msupGetRandomByte() & (BM(mtxInfo.be) - 1);
//  381 
//  382         mtxInfo.beaconSearchEnabled = FALSE;
//  383 
//  384         // Calculate the CSP timeout constant for slotted/unslotted transmissions, and go ahead if OK
//  385         mtxInfo.cspTimeout = mtxCalcCspTimeout();
//  386         if (mtxInfo.cspTimeout) {
//  387             mtxCreateStartTask();
//  388             mtxInfo.status = MTX_STATUS_WAITING;
//  389         } else
//  390         {
//  391 #if MAC_OPT_FFD
//  392             if ((pPacket->txOptions & TX_OPT_INDIRECT)) {
//  393                 miqSetRequested(pPacket, FALSE);
//  394                 pPacket->transmissionStarted = FALSE;
//  395                 mschRemoveTask(pTask->priority, MSCH_KEEP_TASK_IN_PROGRESS_BM);
//  396             } else {
//  397                 mtxInfo.status = MTX_STATUS_OUT_OF_CAP;
//  398             }
//  399 #else
//  400             mtxInfo.status = MTX_STATUS_OUT_OF_CAP;
//  401 #endif
//  402         }
//  403         pTask->state = MTX_STATE_WAIT;
//  404         break;
//  405 
//  406     case MTX_STATE_WAIT:
//  407 
//  408         switch (mtxInfo.status) {
//  409         case MTX_STATUS_WAITING:
//  410         case MTX_STATUS_WAIT_FOR_NEXT_BEACON:
//  411         case MTX_STATUS_TRANSMISSION_STARTED:
//  412         case MTX_STATUS_WAITING_FOR_ACK:
//  413         case MTX_STATUS_ACK_HANDLER_CREATED:
//  414             // Keep the current status/state
//  415             break;
//  416 
//  417         case MTX_STATUS_CHANNEL_ACCESS_FAILURE:
//  418             // For indirect packets with one or more retries left...
//  419 #if MAC_OPT_FFD
//  420             if ((pPacket->txOptions & TX_OPT_INDIRECT) && pPacket->retriesLeft) {
//  421                 pPacket->retriesLeft--;
//  422                 miqSetRequested(pPacket, FALSE);
//  423                 pPacket->transmissionStarted = FALSE;
//  424                 mschRemoveTask(pTask->priority, MSCH_KEEP_TASK_IN_PROGRESS_BM);
//  425 
//  426             // Otherwise...
//  427             } else {
//  428                 mtxFinishTransmission(CHANNEL_ACCESS_FAILURE, pPacket, pTask);
//  429             }
//  430 #else
//  431             mtxFinishTransmission(CHANNEL_ACCESS_FAILURE, pPacket, pTask);
//  432 #endif
//  433             break;
//  434 
//  435         case MTX_STATUS_ACK_TIMEOUT:
//  436             // Fail because of "no acknowledgment"?
//  437             if (pPacket->retriesLeft == 0) {
//  438                 mtxFinishTransmission(NO_ACK, pPacket, pTask);
//  439 
//  440             // Or retry?
//  441             } else {
//  442                 pPacket->retriesLeft--;
//  443 
//  444                 // Indirect packets don't retry autmatically!
//  445 #if MAC_OPT_FFD
//  446                 if (pPacket->txOptions & TX_OPT_INDIRECT) {
//  447                     miqSetRequested(pPacket, FALSE);
//  448                     pPacket->transmissionStarted = FALSE;
//  449                     mschRemoveTask(pTask->priority, MSCH_KEEP_TASK_IN_PROGRESS_BM);
//  4