mac_tx_engine.c

zigbee location examples

//-------------------------------------------------------------------------------------------------------
//
//
//-------------------------------------------------------------------------------------------------------
void mtxStartTransmission(MAC_TASK_INFO   *pTask) {
    MAC_TX_PACKET   *pPacket;

    pPacket = (MAC_TX_PACKET   *) pTask->taskData;

    switch (pTask->state) {
    case MTX_STATE_PREPARE_PACKET:
        ISFLUSHTX;
        DISABLE_GLOBAL_INT();
        halWriteTxFifo((BYTE  *) &pPacket->length, 1);
        halWriteTxFifo(pPacket->pHeader, pPacket->headerLength);
        halWriteTxFifo(pPacket->pPayload, pPacket->length - pPacket->headerLength);
        if ((RXFIFOCNT == 1) && !SFD_IS_ACTIVE()){
          ISFLUSHRX;
          ISFLUSHRX;
        }
        ENABLE_GLOBAL_INT();
        pTask->state = MTX_STATE_START_TRANSMISSION;
        break;

    case MTX_STATE_START_TRANSMISSION:
        msupSetTransmitPower();
        LoadAndStartStrobe (pPacket->txMode, pPacket->slotted, mtxInfo.be, mtxInfo.nb, mtxInfo.randomBackoff, mtxInfo.cspTimeout);
        mschRemoveTask(pTask->priority, MSCH_KEEP_TASK_RESERVED_BM | MSCH_KEEP_TASK_IN_PROGRESS_BM);
        break;
    }
} // mtxStartTransmission

//-------------------------------------------------------------------------------------------------------
//
//
//-------------------------------------------------------------------------------------------------------
ROOT void mtxTxDone(void) {

    // Beacons
    if (mtxInfo.beaconTransmissionInProgress) {
        mtxInfo.beaconTransmissionInProgress = FALSE;
        mschAddTask(mschReserveTask(), MAC_TASK_PRI_HIGH, mtxResumeAfterBeaconTask, NULL);
        mrxDecrOnCounter();

    // Data / MAC command
    } else if (mtxInfo.status == MTX_STATUS_TRANSMISSION_STARTED) {

        // Acked packet
        if (mtxInfo.pPacket->txOptions & TX_OPT_ACK_REQ) {
            mtxInfo.status = MTX_STATUS_WAITING_FOR_ACK;
            mtimSetCallback(mtxAckTimeout, (INT32)MAC_WAIT_FOR_ACK_TIMEOUT);

        // No ack -> done
        } else {
            mtxInfo.status = MTX_STATUS_TX_FINISHED;
            mrxDecrOnCounter();
        }

    // Ack
    } else {
        mrxDecrOnCounter();
    }
} // mtxTxDone

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------




//-------------------------------------------------------------------------------------------------------
//
//
//-------------------------------------------------------------------------------------------------------
static ROOT void HandleOutgoingClearText (MAC_TX_PACKET    *macTxPacket,
                                     FRAME            *frame)
{
    BYTE payloadLength;

    frame->byte[FRAME_LENGTH_OFFSET] = macTxPacket->length;
    DmaMemcpy (&(frame->byte[FRAME_FCF_LOW_BYTE_OFFSET]),
               macTxPacket->pHeader,
               macTxPacket->headerLength);
    payloadLength = macTxPacket->length - macTxPacket->headerLength;
    DmaMemcpy (&frame->byte[macTxPacket->headerLength + FRAME_LENGTH_SIZE],
               macTxPacket->pPayload,
               payloadLength);
}

//-------------------------------------------------------------------------------------------------------
//
//
//-------------------------------------------------------------------------------------------------------
static ROOT void HandleOutgoingFrame (MAC_TX_PACKET        *macTxPacket,
                                 FRAME                *frame,
                                 SECURITY_STATUS      *securityStatus)
{
    *securityStatus = SECURITY_STATUS_OK;
    if (macTxPacket->securitySuite == MAC_SECURITY_NONE)
        HandleOutgoingClearText (macTxPacket, frame);
    else
        HandleOutgoingSecurity (macTxPacket,
                                frame,
                                securityStatus);
}

//-------------------------------------------------------------------------------------------------------
//
//
//-------------------------------------------------------------------------------------------------------
static ROOT void HandleOutgoingSecurity (MAC_TX_PACKET        *macTxPacket,
                                    FRAME                *frame,
                                    SECURITY_STATUS      *securityStatus)
{
   BYTE temp;

   temp = macTxPacket ->length;
   temp += frame->byte[0];

   if (temp != 0)
       *securityStatus = SECURITY_STATUS_NOK;
}





//-------------------------------------------------------------------------------------------------------
//
// Strobe Programs
//
//-------------------------------------------------------------------------------------------------------
BYTE pCspProgramCsmacaSlotted[] = {
    0xBA,  // LABEL
    0xBB,  //     WAITX              Delay for random backoffs
    0x22,  //     SKIP 2, C2         Turn on RX?
    0xC2,  //         SRXON          Yes, RX on
    0x81,  //         WAIT 1         Wait for RX to be stable
    0x58,  //     SKIP 5, !C0        Is CCA = TRUE?
    0xB8,  //         WEVENT         CCA = TRUE, CW = CW - 1
    0x38,  //         SKIP 3, !C0    Is CCA = TRUE?
    0xC3,  //             STXON      Turn on TX
    0xB9,  //             MANINT     Yes, signal success to MCU
    0xDF,  //             STOP       TX started, stop processing
    0x12,  //     SKIP 1, C2         Turn off RX to preserve power?
    0xC5,  //         SRFOFF         Yes, RX off
    0xB5,  //     INCMAXY 5          BE = min(BE+1, aMaxBE)
    0xBC,  //     RANDXY             Next delay random unit backoffperiods
    0xBF,  //     DECZ               NB = NB - 1
    0xAE,  // RPT ! C6               Continue until NB = 0 (NB > macMaxCSMABackoffs)
    CSP_PROGRAM_TERMINATOR
};


BYTE pCspProgramCsmacaUnslotted[] = {
    0xba,  // LABEL
    0xbb,  //     WAITX              Delay for random backoffs
    0x32,  //     SKIP 3, C2         Turn on RX?
    0xc2,  //         SRXON          Yes, RX on
    0x81,  //         WAIT 1         Wait for RX to be stable
    0xB8,  //         SNOP           BUGFIX
    0x48,  //     SKIP 4, !C0        Is CCA = TRUE?
    0xc3,  //         STXON          Turn on TX
    0xb9,  //         MANINT         Yes, signal success to MCU
    0xdf,  //         STOP           TX started, stop processing
    0xB8,  //         SNOP           BUGFIX
    0x22,  //     SKIP 2, C2         Turn off RX to preserve power?
    0xc5,  //         SRFOFF         Yes, RX off
    0xB8,  //         SNOP           BUGFIX
    0xb5,  //     INCMAXY 5          BE = min(BE+1, aMaxBE)
    0xbc,  //     RANDXY             Next delay random unit backoffperiods
    0xbf,  //     DECZ               NB = NB - 1
    0xae,  // RPT ! C6               Continue until NB = 0 (NB > macMaxCSMABackoffs)
    CSP_PROGRAM_TERMINATOR
};


BYTE pCspProgramDirectSlotted[] = {
    0xb8,  // WEVENT                 Wait for boundary
    0xc3,  // STXON                  Turn on TX
    0xb9,  // MANINT                 Signal success to MCU
    CSP_PROGRAM_TERMINATOR
};


BYTE pCspProgramDirectUnslotted[] = {
    0xc3,  // STXON                  Turn on TX
    0xb9,  // MANINT                 Signal success to MCU
    CSP_PROGRAM_TERMINATOR
};

static ROOT void mtxEnterCspProgram(BYTE *pProgram) {
    while (*pProgram != CSP_PROGRAM_TERMINATOR) {
        RFST = *pProgram;
        pProgram++;
    }
}

//-------------------------------------------------------------------------------------------------------
//
//
//-------------------------------------------------------------------------------------------------------
static ROOT void LoadAndStartStrobe (BYTE txMode, BOOL slotted, BYTE be, BYTE nb, BYTE randomBackoff, BYTE noOfBackoffsLeft) {
    if (txMode & MTX_MODE_USE_CSMACA_BM) {
        if (slotted) {
            mtxEnterCspProgram(pCspProgramCsmacaSlotted);
        } else {
            mtxEnterCspProgram(pCspProgramCsmacaUnslotted);
        }
    } else {
        if (slotted) {
            mtxEnterCspProgram(pCspProgramDirectSlotted);
        } else {
            mtxEnterCspProgram(pCspProgramDirectUnslotted);
        }
    }
    CSPY = be;
    CSPZ = nb;
    CSPX = randomBackoff;
    CSPT = noOfBackoffsLeft;
    ISSTART;
}

//-------------------------------------------------------------------------------------------------------
//
//
//-------------------------------------------------------------------------------------------------------
ROOT void PrepareFrameAndWriteToRf (MAC_TX_PACKET   *macTxPacket,
                                    SECURITY_STATUS   *securityStatus)
{
    FRAME     *frame;

    FetchTxFrame (&frame);
    ISFLUSHTX;
    HandleOutgoingFrame (macTxPacket,
                         frame,
                         securityStatus);

    if (*securityStatus == SECURITY_STATUS_OK)
        DmaWriteFrameToTxFifo(frame);
}

//-------------------------------------------------------------------------------------------------------
//
//
//-------------------------------------------------------------------------------------------------------
static ROOT void ReadCsmaParams (BYTE   *be,
                                 BYTE   *nb,
				                         BYTE   *randomBackoff)
{
	*be = CSPY;
	*nb = CSPZ;
	*randomBackoff = CSPX;
}

//-------------------------------------------------------------------------------------------------------
//
//
//-------------------------------------------------------------------------------------------------------
ROOT void WriteCsmaParams (BYTE be, BYTE nb, BYTE randomBackoff, BYTE noOfBackoffsLeft) {
    CSPY = be;
    CSPZ = nb;
    CSPX = randomBackoff;
    CSPT = noOfBackoffsLeft;
}