自学教程：C++ AF_DataRequest函数代码示例

/********************************************************process request funtin of the CLUSDISC command*************************************************************/void AT_AF_Cmd_HA_CIDDISC_req(afIncomingMSGPacket_t *pkt  ){    AT_AF_hdr *req = (AT_AF_hdr *)pkt->cmd.Data;    AT_AF_Cmd_HA_CIDDISC_rsp_t *rsp;    uint8 status=0;    uint16 rspLen=0;    if(AT_is_CMD_EPs(req->ep)){      SimpleDescriptionFormat_t *pDesc;      if(SUCCESS == (status=afFindSimpleDesc(&pDesc, req->ep))){        rspLen = (pDesc->AppNumInClusters+pDesc->AppNumInClusters)*2 +sizeof(AT_AF_Cmd_HA_CIDDISC_rsp_t);        rsp = osal_mem_alloc(rspLen);        if(rsp) {          rsp->status = SUCCESS;          rsp->serverNum = pDesc->AppNumInClusters;          rsp->clientNum = pDesc->AppNumOutClusters;          rsp->hdr.ep = req->ep;          rsp->hdr.cmd = AT_AF_Cmd_rsp;          osal_memcpy(rsp->list,pDesc->pAppInClusterList,rsp->serverNum*2);          osal_memcpy(rsp->list+rsp->serverNum,pDesc->pAppOutClusterList,rsp->clientNum*2);          //sent the found data          AF_DataRequest( & (pkt->srcAddr), & AT_AF_epDesc,                               AT_AF_Cmd_HA_CIDDISC_CLUSTERID,                               rspLen,                               (uint8*)rsp,                               &AT_AF_TransID,                               AF_DISCV_ROUTE,                               AF_DEFAULT_RADIUS );          osal_mem_free(rsp);          return;     //important        }else{          status = AT_AF_MEM_ERROR;        }      }else {        //status = status; //have been done      }    }else{      status = AT_AF_NOTFOUND_ERROR;    }        AT_AF_Cmd_HA_CIDDISC_rsp_t dftRsp;    dftRsp.hdr.cmd = AT_AF_Cmd_rsp;    dftRsp.hdr.ep = req->ep;    dftRsp.status = status;    rsp = &dftRsp;    AF_DataRequest( & (pkt->srcAddr), & AT_AF_epDesc,                         AT_AF_Cmd_HA_CIDDISC_CLUSTERID,                         sizeof(AT_AF_Cmd_HA_CIDDISC_rsp_t),                         (uint8*)rsp,                         &AT_AF_TransID,                         AF_DISCV_ROUTE,                         AF_DEFAULT_RADIUS );}

/************************************************************************************************** * @fn          MHMSDataReq * * @brief       This function is called by MHMSAppEvt() to send a MHMS data report. When it is detected that *              a pulse is found (QS flag is set) this function will start to transfer BPM, IBI, and raw Signal *              data over the air to the coordinator at 20ms intervals. When there is no BPM detected *              this function will stop sending information over the air to the coordinator. * * input parameters * * None. * * output parameters * * None. * * @return      None. ************************************************************************************************** */static void MHMSDataReq(void){  static bool MHMSDataReqFlag;  MHMSDataReqFlag = FALSE;  afAddrType_t addr;                    //AF address stucture defined for info on the destination Endpoint object that data will be sent to    osal_stop_timerEx(MHMSTaskId, MHMS_EVT_CHECKIN);  //Node is collecting data and sending it to coordinator so turn off check in event  MHMSEvtCheckin_sync = FALSE;      MHMSDat[MHMS_CHECK_IN] = CHECK_IN_INACTIVE;   //Flag is off and will notify coordinator that node is not sending check in data   addr.addr.shortAddr = MHMSAddr;      //loading short address (16-bit) with pulse address  addr.addrMode = afAddr16Bit;          //Set to directly sent to a node  addr.endPoint = MHMS_ENDPOINT;       //Sets the endpoint of the final destination (coordinator?)  if (afStatus_SUCCESS != AF_DataRequest(&addr, (endPointDesc_t *)&MHMS_epDesc, MHMS_CLUSTER_ID,                                          MHMS_DAT_LEN, MHMSDat, &MHMSTSN,                                          AF_DISCV_ROUTE,AF_DEFAULT_RADIUS))   { //if data transfer is unsuccessful place event immediately back into queue to attempt to send again        osal_set_event(MHMSTaskId, MHMS_EVT_REQ);  }    if((QS == TRUE) && (MHMSDataReqFlag == FALSE)){    osal_start_timerEx(MHMSTaskId, MHMS_EVT_REQ, MHMS_DLY_DATAREQ);  //send next Pulse data report in 500ms    MHMSDataReqFlag = TRUE;  //to prevent restarting of timer if existing already running       }}

afStatus_t AF_DataRequestSrcRtg( afAddrType_t *dstAddr, endPointDesc_t *srcEP,                           uint16 cID, uint16 len, uint8 *buf, uint8 *transID,                           uint8 options, uint8 radius, uint8 relayCnt, uint16* pRelayList ){  uint8 status;    /* Add the source route to the source routing table */  status = RTG_AddSrcRtgEntry_Guaranteed( dstAddr->addr.shortAddr, relayCnt,                                          pRelayList );  if( status == RTG_SUCCESS)  {    /* Call AF_DataRequest to send the data */    status = AF_DataRequest( dstAddr, srcEP, cID, len, buf, transID, options, radius );  }  else if( status == RTG_INVALID_PATH )  {    /* The source route relay count is exceeding the network limit */    status = afStatus_INVALID_PARAMETER;  }  else  {    /* The guaranteed adding entry fails due to memory failure */    status = afStatus_MEM_FAIL;  }  return status;}

static void SerialApp_SendData( uint8 *buf, uint8 len ){  afStatus_t stat;  // Pre-pend sequence number to the start of the Rx buffer.  *buf = ++SerialApp_SeqTx;  otaBuf = buf;  otaLen = len+1;    if (buf[1]==0xff)  {    reset();  }  stat = AF_DataRequest( &SerialApp_DstAddr,                         (endPointDesc_t *)&SerialApp_epDesc,                          SERIALAPP_CLUSTERID_CMD,                          otaLen, otaBuf,                          &SerialApp_MsgID, 0, AF_DEFAULT_RADIUS );    HalLedSet(HAL_LED_2,HAL_LED_MODE_OFF);   FREE_OTABUF();}

void AT_AF_Cmd_REPPRINT_req(afIncomingMSGPacket_t *pkt ){  const uint8 AT_CMD_EP_ARRAY[] = AT_CMD_EPs;  uint8 epNum = afNumEndPoints()-1;  byte* epBuf = (byte*)  osal_mem_alloc(epNum);  if(epBuf==NULL) return;  afEndPoints( epBuf, true);  AT_sort_arr(epBuf,epNum);    //the epStatus store the search result  uint8 pbuf_temp[sizeof(AT_CMD_EP_ARRAY)+sizeof(AT_AF_hdr)];  AT_AF_Cmd_REPPRINT_rsp_t* pbuf = (AT_AF_Cmd_REPPRINT_rsp_t*)pbuf_temp;  pbuf->hdr.cmd=AT_AF_Cmd_rsp;  pbuf->hdr.numItem=AT_CMD_EPs_Num;    int i,j;  for(i=0,j=0;j<AT_CMD_EPs_Num;j++){    if(epBuf[i]==AT_CMD_EP_ARRAY[j]){      pbuf->status[j] = AT_AF_enable;      i++;    }    else pbuf->status[j] = AT_AF_disable;  }  osal_mem_free(epBuf);  AF_DataRequest( & (pkt->srcAddr), & AT_AF_epDesc,                       AT_AF_Cmd_REPPRINT_CLUSTERID,                       sizeof(AT_CMD_EP_ARRAY)+sizeof(AT_AF_hdr),                       (uint8*)pbuf,                       &AT_AF_TransID,                       AF_DISCV_ROUTE,                       AF_DEFAULT_RADIUS );  }

/************************************************************************************************** * @fn          MHMSAnnce * * @brief       This function is called by MHMSAppEvt() to send an announce command to start or stop *				the device that is acting as a health monitor from collecting sensor data. * * input parameters * * None. * * output parameters * * None. * * @return      None. ************************************************************************************************** */static void MHMSAnnce(void){  uint8 msg[3];  afAddrType_t addr;    addr.addr.shortAddr = NWK_BROADCAST_SHORTADDR_DEVALL;  addr.addrMode = afAddrBroadcast;  addr.endPoint = MHMS_ENDPOINT;  if (INVALID_NODE_ADDR != MHMSAddr)  {    msg[MHMS_CMD_IDX] = MHMS_CMD_BEG;    if (ZSuccess != osal_start_timerEx(MHMSTaskId, MHMS_EVT_ANN, MHMS_DLY_ANN))    {      (void)osal_set_event(MHMSTaskId, MHMS_EVT_ANN);    }  }  else  {    msg[MHMS_CMD_IDX] = MHMS_CMD_END;  }  msg[MHMS_ADR_LSB] = LO_UINT16(MHMSAddr);  msg[MHMS_ADR_MSB] = HI_UINT16(MHMSAddr);  if (afStatus_SUCCESS != AF_DataRequest(&addr, (endPointDesc_t *)&MHMS_epDesc, MHMS_CLUSTER_ID,                                          3, msg, &MHMSTSN, AF_TX_OPTIONS_NONE, AF_DEFAULT_RADIUS))  {    osal_set_event(MHMSTaskId, MHMS_EVT_ANN);  }  else  {    MHMSCnt++;  }}

//This function send the status of own park to the coordinatorstatic void ParkWay_SendTheMessage( void ){  uint8 pData[6];  pData[0] = 'E';  pData[1] = 'D';  pData[2] = DEVICE_PW_1;  pData[3] = DEVICE_PW_2;  pData[4] = '-';  pData[5] = vaga;  //Send data to the coordinator ADDRESS(0000)  if ( AF_DataRequest( &ParkWay_DstAddr, &ParkWay_epDesc,                       ParkWay_CLUSTERID,                       (byte)osal_strlen( pData ) + 1,                       (byte *)&pData,                       &ParkWay_TransID,                       AF_DISCV_ROUTE, AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )  {    // Successfully requested to be sent.  }  else  {    osal_stop_timerEx( ParkWay_TaskID,                        ParkWay_SEND_MSG_EVT);    osal_start_timerEx( ParkWay_TaskID,                        POLLING_OF_DEV_EVT,                        200);  }}

/* @fn      handleKeys * @brief   Handles all key events for this device. * @param   shift - true if in shift/alt. * @param   keys - bit field for key events. Valid entries: * @return  none*/static void handleKeys( uint8 shift, uint8 keys ) {/* POWER_SAVING key press interrupt uses shift key to awaken from deep sleep, * so it is not available.*/#if !defined( POWER_SAVING )  /* Give the LocationProfile access to 4 keys by sending any Shif-Key   * sequence to the profile as a normal Key.*/  if ( shift ) LocationHandleKeys( keys );  else#endif  {    if(keys & HAL_KEY_SW_1) {}    if(keys & HAL_KEY_SW_2) {}    if(keys & HAL_KEY_SW_3) {}    if(keys & HAL_KEY_SW_4) {}  }#if defined ( LOCATION_BLINDNODE )  {    static uint8 transId;    uint8 actionId = LOCATION_APP_TOGGLE;    afAddrType_t dstAddr;    dstAddr.addrMode = afAddrBroadcast;    dstAddr.addr.shortAddr = NWK_BROADCAST_SHORTADDR_DEVALL;    dstAddr.endPoint = LOCATION_APP_ENDPOINT;    // Control all lights within 1-hop radio range.    AF_DataRequest( &dstAddr, (endPointDesc_t *)&LoacationApp_epDesc,            LOCATION_APP_ON_OFF_ID, 1, &actionId, &transId, AF_SKIP_ROUTING, 1);  }#endif}

/************************************************************************************************** * @fn          TestPayloadTx * * @brief       This function is called by the MHMSAppEvt() function. This function is used to test  *              network loading by sending test payloads that have a packet size and Tx frequency that *              are user defined.  This is operated on a timer and is initiated by SW1. * input parameters * * * output parameters * * None. * * @return      None. ************************************************************************************************** */static void TestPayloadTx(void){  static uint8 SeqNum = 0;              //MHMS Note that there is actually a separate Seq number appended to the over the air msg by the ZNP (ex. msg.nwkSeqNum)  static bool flag = FALSE;  afAddrType_t addr;                    //AF address stucture defined for info on the destination Endpoint object that data will be sent to    // Turn off collecting data and regular Pulse report generation for Payload testing  osal_stop_timerEx(MHMSTaskId, MHMS_EVT_CHECKIN);  osal_stop_timerEx(MHMSTaskId, MHMS_EVT_DAT);  osal_stop_timerEx(MHMSTaskId, MHMS_EVT_REQ);    TestDatTx[11] = SeqNum;  TestDatTx[MHMS_CMD_IDX] = MHMS_CMD_DAT_TEST;  if( flag == FALSE){  SeqNum++;  }  flag = FALSE;  addr.addr.shortAddr = MHMSAddr;      //loading short address (16-bit) with pulse address  addr.addrMode = afAddr16Bit;          //Set to directly sent to a node  addr.endPoint = MHMS_ENDPOINT;       //Sets the endpoint of the final destination (coordinator?)    HalLcdWriteString("TestPayload TX",HAL_LCD_LINE_5);  if (afStatus_SUCCESS != AF_DataRequest(&addr, (endPointDesc_t *)&MHMS_epDesc, MHMS_CLUSTER_ID,                                          MHMS_TEST_PAYLOAD_LEN, TestDatTx, &MHMSTSN, AF_DISCV_ROUTE,AF_DEFAULT_RADIUS))    { //if data transfer is unsuccessful place event immediately back into queue to attempt to send again        osal_set_event(MHMSTaskId, TEST_EVT_PAYLOAD_TX);        flag = TRUE;  }     osal_start_timerEx(MHMSTaskId, TEST_EVT_PAYLOAD_TX, TEST_DLY_PAYLOAD_TX);  //send check in dummy packet every 10 seconds}

/********************************************************************* * @fn      GenericApp_SendTheMessage * * @brief   Send "the" message. * * @param   none * * @return  none */static void GenericApp_SendTheMessage( void ){  byte temp[4];  DHT11();            temp[0] = wendu_shi;  temp[1] = wendu_ge;  temp[2] = shidu_shi;  temp[3] = shidu_ge;    if ( AF_DataRequest( &GenericApp_DstAddr, &GenericApp_epDesc,                       TEMP_HUMI_INFO_CLUSTERID,                       4,                       temp,                       &GenericApp_TransID,                       AF_DISCV_ROUTE, AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )  {    // Successfully requested to be sent.  }  else  {    // Error occurred in request to send.  }}

/***************************************************************************deal with the HA discover request*****************************************************************************/void AT_AF_Cmd_HA_DISC_req(afIncomingMSGPacket_t *pkt  ){  AT_AF_Cmd_HA_DISC_req_t *req = (AT_AF_Cmd_HA_DISC_req_t *)pkt->cmd.Data;  AT_AF_Cmd_HA_DISC_rsp_t *rsp;  uint8 zcl_epCount =0;    uint8 AT_CMD_EP_ARRAY[]=AT_CMD_EPs;  uint8 i;  uint8 buf_temp[sizeof(AT_AF_Cmd_HA_DISC_rsp_t)+sizeof(AT_CMD_EP_ARRAY)*sizeof(AT_AF_Cmd_HA_DISC_item_t)];  rsp = (AT_AF_Cmd_HA_DISC_rsp_t *) buf_temp;    for(i=0;i<sizeof(AT_CMD_EP_ARRAY);i++){    epList_t* epList = AT_af_get_ep(AT_CMD_EP_ARRAY[i]);    SimpleDescriptionFormat_t* simDesc=epList->epDesc->simpleDesc;        //find the CID    bool found=false;    uint8 j;    for(j=0;j<simDesc->AppNumOutClusters;j++){      if(simDesc->pAppOutClusterList[j]==req->CID) {        if(req->option==0){          if(afFindEndPointDesc(AT_CMD_EP_ARRAY[i])) found=true;        }else{          found=true;        }        break;      }    }    if(!found){      for(j=0;j<simDesc->AppNumInClusters;j++){        if(simDesc->pAppInClusterList[j]==req->CID) {          if(req->option==0){            if(afFindEndPointDesc(AT_CMD_EP_ARRAY[i])) found=true;          }else{            found=true;          }          break;        }      }    }        //if found the CID    if(found){      rsp->item[zcl_epCount].ep = AT_CMD_EP_ARRAY[i];      rsp->item[zcl_epCount].status = afFindEndPointDesc(AT_CMD_EP_ARRAY[i]) ? AT_AF_enable : AT_AF_disable;      zcl_epCount++;    }  }  if(zcl_epCount!=0){    rsp->hdr.numItem=zcl_epCount;    rsp->hdr.cmd=AT_AF_Cmd_rsp;    AF_DataRequest( & (pkt->srcAddr), & AT_AF_epDesc,                         AT_AF_Cmd_HA_DISC_CLUSTERID,                         sizeof(AT_AF_Cmd_HA_DISC_rsp_t)+zcl_epCount*sizeof(AT_AF_Cmd_HA_DISC_item_t),                         (uint8*)rsp,                         &AT_AF_TransID,                         AF_DISCV_ROUTE,                         AF_DEFAULT_RADIUS );        }}

/************************************************************************************************** * @fn          MT_AfDataStore * * @brief   Process AF Data Store command to incrementally store the data buffer for very large *          outgoing AF message. * * input parameters * * @param pBuf - pointer to the received buffer * * output parameters * * @param rtrn - AF-Status of the operation. * * @return      None. ************************************************************************************************** */void MT_AfDataStore(uint8 *pBuf){  uint16 idx;  uint8 len, rtrn = afStatus_FAILED;  pBuf += MT_RPC_FRAME_HDR_SZ;  idx = BUILD_UINT16(pBuf[0], pBuf[1]);  len = pBuf[2];  pBuf += 3;  if (pMtAfDataReq == NULL)  {    rtrn = afStatus_MEM_FAIL;  }  else if (len == 0)  // Indication to send the message.  {    rtrn = AF_DataRequest(&(pMtAfDataReq->dstAddr), pMtAfDataReq->epDesc, pMtAfDataReq->cId,                            pMtAfDataReq->dataLen,  pMtAfDataReq->data,                          &(pMtAfDataReq->transId), pMtAfDataReq->txOpts, pMtAfDataReq->radius);    (void)osal_mem_free(pMtAfDataReq);    pMtAfDataReq = NULL;  }  else  {    (void)osal_memcpy(pMtAfDataReq->data+idx, pBuf, len);    rtrn = afStatus_SUCCESS;  }  MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_AF),                                                                MT_AF_DATA_STORE, 1, &rtrn);}

/***********************************************************	LCD send retry***********************************************************/static void LCD_SendRetry(){  // first get the short address  uint16 srcAddr = NLME_GetShortAddr();  // new the frame  byte frame[7] = {0};  // fill the header  frame[0] = 0xFE;  // fill the length  frame[1] = 0;  // fill the command  frame[2] = LO_UINT16(LCD_RETRY_CMD);  frame[3] = HI_UINT16(LCD_RETRY_CMD);  // fill Addr  frame[4] = LO_UINT16(srcAddr);  frame[5] = HI_UINT16(srcAddr);  // fill the fcs  frame[6] = LCD_CalcFCS((byte*)&frame[1], 5);    // Send the data to Coordinator  AF_DataRequest( &LCD_DstAddr, 				  &LCD_epDesc,				  ZIGBEE_COMMON_CLUSTER,				  7,				  (byte *)frame,				  &LCD_TransID,				  AF_DISCV_ROUTE, AF_DEFAULT_RADIUS );}

/**************************************************************		send the ack command to the monitor **************************************************************/static void LCD_SendACK(byte flag){  // new the frame  byte frame[8] = {0};  // fill the header  frame[0] = 0xFE;  // fill the length  frame[1] = 1;  // fill the command  frame[2] = LO_UINT16(LCD_ACK_CMD);  frame[3] = HI_UINT16(LCD_ACK_CMD);  // fill Addr  frame[4] = LO_UINT16(0);  frame[5] = HI_UINT16(0);  // fill the flag  frame[6] = flag;  // fill the fcs  frame[7] = LCD_CalcFCS((byte*)&frame[1], 6);    // Send the data to Coordinator  AF_DataRequest( &LCD_DstAddr, 				  &LCD_epDesc,				  ZIGBEE_COMMON_CLUSTER,				  8,				  (byte *)frame,				  &LCD_TransID,				  AF_DISCV_ROUTE, AF_DEFAULT_RADIUS );}

void SampleApp_SendPointMessage(void){  HalUARTWrite(0, "PointMsg/n", sizeof("PointMsg/n")-1);  uint8 T[5];  Temp_test();  if (temp > 27)    LED1 = !LED1;  T[0] = temp / 10 + 48;  T[1] = temp % 10 + 48;  T[2] = ' ';  T[3] = 'C';  T[4] = '/0';  HalUARTWrite(0, "temp=", 5);  HalUARTWrite(0, T, 2);  HalUARTWrite(0, "/n", 1);  if ( AF_DataRequest( &SampleApp_Point_DstAddr, &SampleApp_epDesc,                       SAMPLEAPP_POINT_CLUSTERID,                       5,                       T,                       &SampleApp_TransID,                       AF_DISCV_ROUTE,                       AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )  {    HalUARTWrite(0, "PointMsg Success/n", sizeof("PointMsg Success/n")-1);  }  else  {    // Error occurred in request to send.    HalUARTWrite(0, "PointMsg Failed/n", sizeof("PointMsg Failed/n")-1);  }  }

static void MHMSNodeCheckIn(void){  static bool Flag;  afAddrType_t addr;                    //AF address stucture defined for info on the destination Endpoint object that data will be sent to    osal_stop_timerEx(MHMSTaskId, MHMS_EVT_REQ); //Stop MHMSDataReq() task since no pulse data is being measured  MHMSEvtReq_sync = FALSE;  Flag = FALSE;  addr.addr.shortAddr = MHMSAddr;      //loading short address (16-bit) with pulse address  addr.addrMode = afAddr16Bit;          //Set to directly sent to a node  addr.endPoint = MHMS_ENDPOINT;       //Sets the endpoint of the final destination (coordinator?)  MHMSDat[MHMS_CHECK_IN] = CHECK_IN_ACTIVE;   //Flag is set and will notify coordinator that node is currently sending check in data  HalLcdWriteString("BPMsensor Inacti",HAL_LCD_LINE_5);  if (afStatus_SUCCESS != AF_DataRequest(&addr, (endPointDesc_t *)&MHMS_epDesc, MHMS_CLUSTER_ID,                                          MHMS_DAT_LEN, MHMSDat, &MHMSTSN, AF_DISCV_ROUTE,AF_DEFAULT_RADIUS))    { //if data transfer is unsuccessful place event immediately back into queue to attempt to send again        osal_set_event(MHMSTaskId, MHMS_EVT_CHECKIN);  }  else  {    MHMSCnt++;  }  if((QS == FALSE) && (Flag == FALSE)){    osal_start_timerEx(MHMSTaskId, MHMS_EVT_CHECKIN, MHMS_DLY_CHECKIN);  //send check in dummy packet every 10 seconds    Flag = TRUE;  //to prevent restarting of timer if existing already running  }  }

/********************************************************************* * @fn      SampleApp_SendPeriodicMessage * @brief   Send the periodic message. * @param   none * @return  none */void SampleApp_SendPeriodicMessage( void ){  uint8 data[10]={178,201,45,56,46,58,77,32,88,19};  if ( AF_DataRequest(  &Point_To_Point_DstAddr, &SampleApp_epDesc,                       SAMPLEAPP_POINT_TO_POINT_CLUSTERID,                       10,                //一共10个数据                       data,              //装载要发送的数据                       &SampleApp_TransID,                       AF_DISCV_ROUTE,                       AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )  {}}

/********************************************************************* * @fn      SampleApp_SendPeriodicMessage * * @brief   Send the periodic message. * * @param   none * * @return  none */void SampleApp_SendPeriodicMessage( void ){   if ( AF_DataRequest ( &SampleApp_Periodic_DstAddr, &SampleApp_epDesc,                       SAMPLEAPP_PERIODIC_CLUSTERID,                       1,                       (uint8*)&SampleAppPeriodicCounter,                       &SampleApp_TransID,                       AF_DISCV_ROUTE, AF_DEFAULT_RADIUS ) == afStatus_SUCCESS     )  { /* Success occurred in request to send*/ }  else  { /* Error occurred in request to send. */ }}

static void AT_AF_Cmd_RSSI_req(afIncomingMSGPacket_t *pkt  ){  AT_AF_Cmd_POWER_SAVING_rssi_t buf;  buf.hdr.cmd =AT_AT_PSE_RSSI_rsp;  buf.rssi = pkt->rssi;  buf.lqi = pkt->LinkQuality;  buf.correlation =pkt->correlation;  AF_DataRequest( & (pkt->srcAddr), & AT_AF_epDesc,                         AT_AF_POWER_SVING_EXP_CLUSTERID,                         sizeof(buf),                         (uint8*)&buf,                         &AT_AF_TransID,                         AF_DISCV_ROUTE,                         AF_DEFAULT_RADIUS );}

afStatus_t AT_AF_Cmd_send_simple_(uint16 nwkAddr,uint16 CID,uint8 len, uint8 *buff){    afAddrType_t dstAddr;  dstAddr.endPoint = AT_AF_ENDPOINT;  dstAddr.addr.shortAddr =nwkAddr;  dstAddr.addrMode = (afAddrMode_t) Addr16Bit;    return AF_DataRequest( &dstAddr, & AT_AF_epDesc,                       CID,                       len,                       buff,                       &AT_AF_TransID,                       AF_DISCV_ROUTE,                       AF_DEFAULT_RADIUS );}

/*****************************************广播，由协调器通过按键或启动时，向全部终端节点发起测试请求******************************************/void SampleApp_SendBroadcastMessage( void ){  uint8 data[]="+REBOT#";  if(AF_DataRequest(&SampleApp_Periodic_DstAddr,                     &SampleApp_epDesc,                     SAMPLEAPP_PERIODIC_CLUSTERID,                     7,                     data,                     &SampleApp_TransID,                     AF_DISCV_ROUTE,                     AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )  {   //SUCCESS!   HalLedBlink( HAL_LED_2, 2,50, 500 );   }}

static void My_SendTheShortAddr( void ){  if ( AF_DataRequest( &GenericApp_DstAddr, &GenericApp_epDesc,                       SHORT_ADDR_INFO_CLUSTERID,                       0,                       NULL,                       &GenericApp_TransID,                       AF_DISCV_ROUTE, AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )  {    // Successfully requested to be sent.  }  else  {    // Error occurred in request to send.  }}

//void SampleApp_SendPeriodicMessage( void )//{//  if ( AF_DataRequest( &SampleApp_Periodic_DstAddr, &SampleApp_epDesc,//                       SAMPLEAPP_PERIODIC_CLUSTERID,//                       1,//                       (uint8*)&SampleAppPeriodicCounter,//                       &SampleApp_TransID,//                       AF_DISCV_ROUTE,//                       AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )//  {//  }//  else//  {//    // Error occurred in request to send.//  }//}void SampleApp_SendPeriodicMessage( void ){  uint8 data[1]={2};//,'3','4','5','6','7','8','9'};  if ( AF_DataRequest( &SampleApp_Periodic_DstAddr, &SampleApp_epDesc,                       SAMPLEAPP_PERIODIC_CLUSTERID,                       1,                       &data[0],//(uint8*)&SampleAppPeriodicCounter,                       &SampleApp_TransID,                       AF_DISCV_ROUTE,//设置路由发现                       AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )  {  }  else  {    // Error occurred in request to send.  }}

/********************************************************************* * @fn      App_SendSample * * @brief    * * @param   buf - pointer for the  field *          len - length of the  field * * @return  none */void App_SendSample(unsigned char *buf, unsigned char len, uint16 option) {  uint8 packetLen=0;  app_msg_t packet;      packet.head = 0xFE;//    packet.nodeid = theNodeID;    SendSeqno++;    if(SendSeqno == 0xFE)    {      SendSeqno = 1;    }    packet.seqno = SendSeqno;     memcpy(packet.IEEEAddr, NLME_GetExtAddr(), 8);//IEEE address 64 bit    myAddr = NLME_GetShortAddr();      packet.myAddr = myAddr;    packet.rssi = 0x00;    packet.cmd = option;    packet.len = len;    memcpy(packet.data, buf, len);    packetLen = sizeof(app_msg_t)-60 + len;//    packet.end = 0xAA;        // AF_SKIP_ROUTING -  will cause the device to skip    // routing and try to send the message directly    if ( AF_DataRequest( &ParkingApp_Periodic_DstAddr, &ParkingApp_epDesc,                        PARKINGAPP_PERIODIC_CLUSTERID,			packetLen,//sizeof(app_msg_t),//22,			(byte*) &packet,//(byte *)tempbuf,                        &ParkingApp_TransID,#if (defined DATABROADCAST && DATABROADCAST == TRUE)                        AF_SKIP_ROUTING, //  AF_DISCV_ROUTE                        ENDDEVICE_BCAST_RADIUS ) == afStatus_SUCCESS ) //AF_DEFAULT_RADIUS#else                        AF_DISCV_ROUTE,                          AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )#endif    {//            P0_0 = 0;    }    else    {      // Error occurred in request to send.    }}

/*************************************************************    deal with the requst from other devices for REPENABLE,     and send a response*************************************************************/void AT_AF_Cmd_REPENABLE_req(afIncomingMSGPacket_t *pkt  ){  AT_AF_Cmd_REPENABLE_rsp_t rsp;    AT_AF_Cmd_REPENABLE_req_t *req = (AT_AF_Cmd_REPENABLE_req_t*)pkt->cmd.Data;  uint8 enable =req->enable;  uint8 ep     =req->ep;    rsp.hdr.cmd=AT_AF_Cmd_rsp;  rsp.item.ep=req->ep;    if(enable){    if( AT_af_get_ep(ep)){      if(AT_af_register_ep(ep)==afStatus_SUCCESS){         //enable the end point in ZCL layer        AT_ZCL_EP_ENABLE( enable,ep);        AT_NV_ZCL_saveEPStatus(AT_NV_ZCL_get_index_(ep),&enable);      }      rsp.item.status=AT_AF_enable;    }else {      rsp.item.status = AT_AF_UNKNOWNEP;    }  }  else{    if(AT_af_get_ep(ep)){      if(AT_af_remove_ep(ep)==afStatus_SUCCESS){        //disable the end point in ZCL layer        AT_ZCL_EP_ENABLE( enable,ep);        //save to NV        AT_NV_ZCL_saveEPStatus(AT_NV_ZCL_get_index_(ep),&enable);      }      rsp.item.status = AT_AF_disable;    }else {      rsp.item.status = AT_AF_UNKNOWNEP;    }  }    AF_DataRequest( & (pkt->srcAddr), & AT_AF_epDesc,                       AT_AF_Cmd_REPENABLE_CLUSTERID,                       sizeof(AT_AF_Cmd_REPENABLE_rsp_t),                       (uint8*)&rsp,                       &AT_AF_TransID,                       AF_DISCV_ROUTE,                       AF_DEFAULT_RADIUS );  }

/********************************************************************* * @fn      TransmitApp_SendTheMessage * * @brief   Send "the" message. * * @param   none * * @return  none */void TransmitApp_SendTheMessage( void ){  uint16 len;  uint8 tmp;  // put the sequence number in the message  tmp = HI_UINT8( TransmitApp_TransID );  tmp += (tmp <= 9) ? ('0') : ('A' - 0x0A);  TransmitApp_Msg[2] = tmp;  tmp = LO_UINT8( TransmitApp_TransID );  tmp += (tmp <= 9) ? ('0') : ('A' - 0x0A);  TransmitApp_Msg[3] = tmp;  len = TransmitApp_MaxDataLength;#if defined ( TRANSMITAPP_RANDOM_LEN )  len = (uint8)(osal_rand() & 0x7F);  if( len > TransmitApp_MaxDataLength || len == 0 )    len = TransmitApp_MaxDataLength;#endif	  do {    tmp = AF_DataRequest( &TransmitApp_DstAddr, &TransmitApp_epDesc,                           TRANSMITAPP_CLUSTERID_TESTMSG,                           len, TransmitApp_Msg,                          &TransmitApp_TransID,                           TRANSMITAPP_TX_OPTIONS,                           AF_DEFAULT_RADIUS );    if ( timesToSend )    {      timesToSend--;    }  } while ( (timesToSend != 0) && (afStatus_SUCCESS == tmp) );  if ( afStatus_SUCCESS == tmp )  {    pktCounter++;  }  else  {    // Error, so wait (10 mSec) and try again.    osal_start_timerEx( TransmitApp_TaskID, TRANSMITAPP_SEND_ERR_EVT, 10 );  }}

/********************************************************************* * @fn      SampleApp_SendPeriodicMessage * * @brief   Send the periodic message. * * @param   none * * @return  none */void SampleApp_SendPeriodicMessage( void ){   LedState = LedState+1 ;  //unsigned char data[15]= "F3332221114444";  SEND_DATA[0] = 0x31;      // ROOM1 SESOR KEY    CNT[2]=CNT[2]+1;     if( CNT[2] == 0x3A)     {         CNT[2] = 0x30;         CNT[1] = CNT[1] + 1 ;       }     if( CNT[1] == 0x3A)      {          CNT[1] = 0x30;          CNT[0] = CNT[0] + 1 ;        }     if( CNT[0] == 0x3A)      {          CNT[0] = 0x30;      }  SEND_DATA[14]=0x41;  SEND_DATA[15]=CNT[0];  SEND_DATA[16]=CNT[1];  SEND_DATA[17]=CNT[2];    if ( AF_DataRequest( &SampleApp_Periodic_DstAddr, &SampleApp_epDesc,                       SAMPLEAPP_PERIODIC_CLUSTERID,                       27,                       SEND_DATA,                       &SampleApp_TransID,                       AF_DISCV_ROUTE,                       AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )  {    if(LedState == 1)      HalLedSet(HAL_LED_3, HAL_LED_MODE_ON);    else if(LedState == 2)    {HalLedSet(HAL_LED_3, HAL_LED_MODE_OFF);     LedState=0;}  }  else  {    // Error occurred in request to send.  }}