endpoint1114.c

此程式庫有許多的zigbee程式源碼

#ifdef UART0_DEBUG
    vDebug("Sy ");
#endif

    /* Set the coordinator source address before syncing to avoid PAN conflict
       indication */
    s_psMacPib->u16CoordShortAddr = DEMO_COORD_ADDR;

    /* Create sync request on channel selected during scan */
    sMlmeReqRsp.u8Type = MAC_MLME_REQ_SYNC;
    sMlmeReqRsp.u8ParamLength = sizeof(MAC_MlmeReqSync_s);
    sMlmeReqRsp.uParam.sReqSync.u8Channel = sDemoData.sSystem.u8Channel;
    sMlmeReqRsp.uParam.sReqSync.u8TrackBeacon = TRUE;

    /* Put in sync request. There is no deferred confirm for this, we just get
       a SYNC-LOSS later if it didn't work */
    vAppApiMlmeRequest(&sMlmeReqRsp, &sMlmeSyncCfm);
}

/****************************************************************************
 *
 * NAME: vStartAssociate
 *
 * DESCRIPTION:
 * Sends an MLME request to the 802.15.4 to request an association with the
 * coordinator found during a previous scan. If the  returned confirmation is
 * not 'deferred', a fatal error is assumed.
 *
 * RETURNS:
 * void
 *
 ****************************************************************************/
PRIVATE void vStartAssociate(void)
{
    MAC_MlmeReqRsp_s  sMlmeReqRsp;
    MAC_MlmeSyncCfm_s sMlmeSyncCfm;

    sDemoData.sSystem.eState = E_STATE_ASSOCIATING;

#ifdef UART0_DEBUG
    vDebug("As ");
#endif

    /* Create associate request. We know short address and PAN ID of
       coordinator as this is preset and we have checked that received
       beacon matched this */
    sMlmeReqRsp.u8Type = MAC_MLME_REQ_ASSOCIATE;
    sMlmeReqRsp.u8ParamLength = sizeof(MAC_MlmeReqAssociate_s);
    sMlmeReqRsp.uParam.sReqAssociate.u8LogicalChan = sDemoData.sSystem.u8Channel;
    sMlmeReqRsp.uParam.sReqAssociate.u8Capability = 0x80; /* We want short address, other features off */
    sMlmeReqRsp.uParam.sReqAssociate.u8SecurityEnable = FALSE;
    sMlmeReqRsp.uParam.sReqAssociate.sCoord.u8AddrMode = 2;
    sMlmeReqRsp.uParam.sReqAssociate.sCoord.u16PanId = DEMO_PAN_ID;
    sMlmeReqRsp.uParam.sReqAssociate.sCoord.uAddr.u16Short = DEMO_COORD_ADDR;

    /* Put in associate request and check immediate confirm. Should be
       deferred, in which case response is handled by event handler */
    vAppApiMlmeRequest(&sMlmeReqRsp, &sMlmeSyncCfm);
    if (sMlmeSyncCfm.u8Status != MAC_MLME_CFM_DEFERRED)
    {
        /* Unexpected result */
        vDisplayError("Associate request returned error",
                      ((uint32)sMlmeSyncCfm.u8Status) << 8
                      | (uint32)sMlmeSyncCfm.uParam.sCfmAssociate.u8Status);
    }
}

/****************************************************************************
 *
 * NAME: vProcessInterrupts
 *
 * DESCRIPTION:
 * Loops around checking for upward events from the Application Queue API.
 * To save power, the CPU is set to doze at the start of the loop. If an event
 * is generated, the CPU is woken up and processes it, then the code here is
 * allowed to continue.
 *
 * For each type of event, the queue is checked and, if there is something to
 * process, the appropriate handler is called. The buffer is then returned to
 * the Application Queue API. This continues until all events have been
 * processed. If the hardware event handler detects that a 'reset' button
 * press sequence has happened, the loop is exited.
 *
 * Note that the buttons are configured to generate interrupts when they are
 * pressed.
 *
 * RETURNS:
 * void when a 'reset' button press sequence is detected.
 *
 ****************************************************************************/
PRIVATE void vProcessInterrupts(void)
{
    MAC_MlmeDcfmInd_s *psMlmeInd;
    MAC_McpsDcfmInd_s *psMcpsInd;
    AppQApiHwInd_s    *psAHI_Ind;
    bool_t             bDone;

    /* Wait for events */
    bDone = FALSE;
    do
    {

        /* Doze CPU: it will wake when interrupt occurs, then process
           interrupts, then this code will be able to process queue */
        vAHI_CpuDoze();

        /* Check for anything on the MCPS upward queue */
        do
        {
            psMcpsInd = psAppQApiReadMcpsInd();
            if (psMcpsInd != NULL)
            {
               #ifdef UART0_DEBUG
                        //    vDebug("vProcessIncomingMcps ");
#endif
                vProcessIncomingMcps(psMcpsInd);
                vAppQApiReturnMcpsIndBuffer(psMcpsInd);
            }
        } while (psMcpsInd != NULL);

        /* Check for anything on the MLME upward queue */
        do
        {
            psMlmeInd = psAppQApiReadMlmeInd();
            if (psMlmeInd != NULL)
            {
               #ifdef UART0_DEBUG
                       //     vDebug("vProcessIncomingMlme ");
#endif
                vProcessIncomingMlme(psMlmeInd);
                vAppQApiReturnMlmeIndBuffer(psMlmeInd);
            }
        } while (psMlmeInd != NULL);

        /* Check for anything on the AHI upward queue */
        do
        {
            psAHI_Ind = psAppQApiReadHwInd();
            if (psAHI_Ind != NULL)
            {
                /* We don't bother to pass the queue data as we are only
                   expecting key press interrupts and, if we get anything else,
                   reading the keys won't have any unfortunate side effects */
                if (bProcessKeyPress() == TRUE)
                {
                   #ifdef UART0_DEBUG
                            vDebug("bProcessKeyPress ");
#endif
                    bDone = TRUE;
                }
				   #ifdef UART0_DEBUG
                            vDebug("vAppQApiReturnHwIndBuffer ");
#endif
                vAppQApiReturnHwIndBuffer(psAHI_Ind);
            }
        } while (psAHI_Ind != NULL);

    } while (bDone == FALSE);
}

/****************************************************************************
 *
 * NAME: vProcessIncomingMcps
 *
 * DESCRIPTION:
 * Deals with any incoming MCPS data events. Only deferred confirmations of
 * frame transmission requests are specifically handled, to move the state
 * machine forward.
 *
 * PARAMETERS: Name        RW  Usage
 *             psMcpsInd   R   Pointer to structure containing MCPS event
 *
 * RETURNS:
 * void
 *
 ****************************************************************************/
PRIVATE void vProcessIncomingMcps(MAC_McpsDcfmInd_s *psMcpsInd)
{
    /* Process MCPS indication by checking if it is a confirmation of our
           outgoing frame */
              #ifdef UART0_DEBUG
                           // vDebug("vProcessIncomingMcps ");
#endif
    if ((psMcpsInd->u8Type == MAC_MCPS_DCFM_DATA)
        && (sDemoData.sSystem.eState == E_STATE_TX_DATA))
    {
        if (psMcpsInd->uParam.sDcfmData.u8Handle == sDemoData.sTransceiver.u8CurrentTxHandle)
        {
            /* Increment handle for next time. Increment failures */
            sDemoData.sTransceiver.u8CurrentTxHandle++;

            /* Start to read sensors. This takes a while but rather than
               wait for an interrupt we just poll and, once finished, move back
               to the running state to wait for the next beacon. Not a power
               saving solution! */
            sDemoData.sSystem.eState = E_STATE_READ_SENSORS;
			   #ifdef UART0_DEBUG
                            //vDebug("vProcessRead ");
#endif
            vProcessRead();
            sDemoData.sSystem.eState = E_STATE_RUNNING;
        }
    }
}

/****************************************************************************
 *
 * NAME: vProcessIncomingMlme
 *
 * DESCRIPTION:
 * Deals with any incoming MCPS events. There are 4 events that are handled:
 *
 * 1. Scan deferred confirmation
 *    If the scan saw a beacon from the expected coordinator, the stack is
 *    asked to start synchronisation. Otherwise, it tries to scan again.
 *
 * 2. Associate deferred confirmation
 *    If the association was successful, the short address is stored and the
 *    device enters the 'running' state, in which it will respond to beacons
 *    by sending back a frame of sensor information. If the association was
 *    not successful, it is attempted again.
 *
 * 3. Becon notify indication
 *    If synchronising, this is used to indicate that synchronisation is
 *    complete and association is atempted. If in 'running' state, it is
 *    used to trigger the sending of a frame containing sensor information
 *    to the coordinator.
 *
 * 4. Sync loss indication
 *    Device starts another scan.
 *
 * PARAMETERS: Name        RW  Usage
 *             psMlmeInd   R   Pointer to structure containing MLME event
 *
 * RETURNS:
 * void
 *
 ****************************************************************************/
PRIVATE void vProcessIncomingMlme(MAC_MlmeDcfmInd_s *psMlmeInd)
{
    MAC_PanDescr_s *psPanDesc;
    int i;

    /* We respond to several MLME indications and confirmations, depending
       on mode */
    switch (psMlmeInd->u8Type)
    {
    case MAC_MLME_DCFM_SCAN:
#ifdef UART0_DEBUG
        vDebug("MSc ");
#endif
        /* Only respond to this if scanning */
        if (sDemoData.sSystem.eState == E_STATE_SCANNING)
        {
#ifdef UART0_DEBUG
            vDebug("MScSt ");
#endif
            /* Make sure it is what we're after */
            switch (psMlmeInd->uParam.sDcfmScan.u8Status)
            {
            case MAC_ENUM_SUCCESS:
                if (psMlmeInd->uParam.sDcfmScan.u8ScanType == MAC_MLME_SCAN_TYPE_ACTIVE)
                {
#ifdef UART0_DEBUG
                    vDebug("MScOk ");
#endif
                    /* Determine which, if any, network contains demo coordinator.
                       Algorithm for determining which network to connect to is
                       beyond the scope of 802.15.4, and we use a simple approach
                       of matching the required PAN ID and short address, both of
                       which we already know */
                    i = 0;
                    while (i < psMlmeInd->uParam.sDcfmScan.u8ResultListSize)
                    {
                        psPanDesc = &psMlmeInd->uParam.sDcfmScan.uList.asPanDescr[i];
#ifdef UART0_DEBUG
                        vDisplayHex(psPanDesc->u8LogicalChan, 2);
                        vDebug(":");
                        vDisplayHex(psPanDesc->sCoord.u16PanId, 4);
                        vDebug(":");
                        vDisplayHex(psPanDesc->sCoord.uAddr.u16Short, 4);
                        vDebug(" ");
#endif
                        if ((psPanDesc->sCoord.u16PanId == DEMO_PAN_ID)
                            && (psPanDesc->sCoord.u8AddrMode == 2)
                            && (psPanDesc->sCoord.uAddr.u16Short == DEMO_COORD_ADDR))
                        {
#ifdef UART0_DEBUG
                            vDebug("MScUs ");
#endif
                            /* Matched so start to synchronise and associate */
                            sDemoData.sSystem.u8Channel = psPanDesc->u8LogicalChan;
                            vStartSync();
                            return;
                        }
                        i++;
                    }

                    /* Failed to find coordinator: keep trying */
                    vStartScan();
                }
                break;

            case MAC_ENUM_NO_BEACON:
                /* Failed to find coordinator: keep trying */
                vStartScan();
                break;

            default:
                break;
            }
        }
        break;


    case MAC_MLME_DCFM_ASSOCIATE:
        /* Only respond if in associating mode */
        switch (sDemoData.sSystem.eState)
        {
        case E_STATE_ASSOCIATING:
            if (psMlmeInd->uParam.sDcfmAssociate.u8Status == MAC_ENUM_SUCCESS)
            {
                /* Store short address */
                sDemoData.sSystem.u16ShortAddr = psMlmeInd->uParam.sDcfmAssociate.u16AssocShortAddr;

                /* Node is a value between 0 and the number of endpoints - 1.
                   It is determined by the short address */
                sDemoData.sSystem.u8ThisNode = sDemoData.sSystem.u16ShortAddr - DEMO_ENDPOINT_ADDR_BASE;

                /* We are now in the running state */
                sDemoData.sSystem.eState = E_STATE_RUNNING;
            }
            else
            {
                /* Try, try again */
                vStartAssociate();
            }
            break;

        case E_STATE_ASSOC_TO_SCAN:
            vStartScan();
            break;

        default:
            break;
        }
        break;

    case MAC_MLME_IND_BEACON_NOTIFY:
        /* Beacon has arrived. If in sync'ing mode, should only see this
           once synchronisation has been achieved. If running, use this
           to time reading of sensors. In other states, ignore it */
        switch (sDemoData.sSystem.eState)
        {
        case E_STATE_SYNCING:
            /* Can now associate */
            vStartAssociate();
            break;

        case E_STATE_RUNNING:
            /* Process received data in beacon payload */
            vProcessRxBeacon(psMlmeInd);
            break;

        default:
            break;
        }
        break;

    case MAC_MLME_IND_SYNC_LOSS:
        /* Lost sync with coordinator so try to find coordinator again */
        if (sDemoData.sSystem.eState != E_STATE_ASSOCIATING)
        {
            vStartScan();
        }
        else
        {
            sDemoData.sSystem.eState = E_STATE_ASSOC_TO_SCAN;
        }
        break;

    default:
        break;
    }
}

/****************************************************************************
 *
 * NAME: bProcessKeyPress
 *
 * DESCRIPTION:
 * Porcesses buttons, to turn on or off the remote switch or to detect a
 * reset request.
 *
 * RETURNS:
 * TRUE if reset combination detected.
 *
 ****************************************************************************/
PRIVATE bool_t bProcessKeyPress(void)    /*肚癳data