mt_zdo.c

Zigbee2006入门（源代码+文档讲解+系统推荐）

    //  SrcAddr + Status + NeighborLqiEntries + StartIndex + NeighborLqiCount
    //     + (maximum entries * size of struct)
 
  msgPtr = osal_mem_alloc( len );

  if ( msgPtr )
  {
    msg = msgPtr;

    //Fill up the data bytes
    
    *msg++ = HI_UINT16( SrcAddr );
    *msg++ = LO_UINT16( SrcAddr );    
    *msg++ = Status;
    *msg++ = NeighborLqiEntries;
    *msg++ = StartIndex;
    *msg++ = NeighborLqiCount;

    osal_memset( msg, 0, (ZDP_NEIGHBORLQI_SIZE * ZDO_MAX_LQI_ITEMS) );

    for ( x = 0; x < ZDO_MAX_LQI_ITEMS; x++ )
    {
      if ( x < NeighborLqiCount )
      {
        if ( proVer == ZB_PROT_V1_0 )
        {
          *msg++ = HI_UINT16( pList->PANId );
          *msg++ = LO_UINT16( pList->PANId );
        }
        else 
        {
          osal_cpyExtAddr(msg, pList->extPANId);
          msg += Z_EXTADDR_LEN;
        }
        *msg++ = HI_UINT16( pList->nwkAddr );
        *msg++ = LO_UINT16( pList->nwkAddr );
        *msg++ = pList->rxLqi;
        *msg++ = pList->txQuality;
        pList++;
      }
    }

    MT_BuildAndSendZToolCB( SPI_CB_ZDO_MGMT_LQI_RSP, len, msgPtr );

    osal_mem_free( msgPtr );
  }
}
#endif // ZDO_MGMT_LQI_REQUEST

#if defined ( ZDO_MGMT_NWKDISC_REQUEST )
/*********************************************************************
 * @fn      zdo_MTCB_MgmtNwkDiscRspCB()
 *
 * @brief
 *
 *   Called to send MT callback response for Management Network
 *   Discover response
 *
 * @param  SrcAddr  - Source address
 * @param  Status - response status
 *
 * @return  none
 */
void zdo_MTCB_MgmtNwkDiscRspCB( uint16 SrcAddr, byte Status,
                        byte NetworkCount, byte StartIndex,
                        byte networkListCount, mgmtNwkDiscItem_t *pList )
{
  byte *msgPtr;
  byte *msg;
  byte len;
  byte x;
  byte proVer = NLME_GetProtocolVersion();  
   

  /*Allocate a message of size equivalent to the corresponding SPI message
  (plus a couple of bytes for MT use)so that the same buffer can be sent by
  MT to the test tool by simply setting the header bytes.*/

  /*In order to allocate the message , we need to know the length and this
  has to be calculated before we allocate the message*/
  if ( proVer == ZB_PROT_V1_0 )
  {
    len = 2 + 1 + 1 + 1 + 1 + (ZDP_NETWORK_DISCRIPTOR_SIZE * ZDO_MAX_NWKDISC_ITEMS);
      //  SrcAddr + Status + NetworkCount + StartIndex + networkListCount
      //     + (maximum entries * size of struct)
  }
  else
  {
    len = 2 + 1 + 1 + 1 + 1 + (ZDP_NETWORK_EXTENDED_DISCRIPTOR_SIZE * ZDO_MAX_NWKDISC_ITEMS);
 
  }

  msgPtr = osal_mem_alloc( len );

  if ( msgPtr )
  {
    msg = msgPtr;

    //Fill up the data bytes
    *msg++ = HI_UINT16( SrcAddr );
    *msg++ = LO_UINT16( SrcAddr );
    *msg++ = Status;
    *msg++ = NetworkCount;
    *msg++ = StartIndex;
    *msg++ = networkListCount;

    osal_memset( msg, 0, (ZDP_NETWORK_DISCRIPTOR_SIZE * ZDO_MAX_NWKDISC_ITEMS) );

    for ( x = 0; x < ZDO_MAX_NWKDISC_ITEMS; x++ )
    {
      if ( x < networkListCount )
      {
        if ( proVer == ZB_PROT_V1_0 )
        {
          *msg++ = HI_UINT16( pList->PANId );
          *msg++ = LO_UINT16( pList->PANId );
        }
        else
        {
          osal_cpyExtAddr( msg, pList->extendedPANID );
          msg += Z_EXTADDR_LEN;
        }
        *msg++ = pList->logicalChannel;
        *msg++ = pList->stackProfile;
        *msg++ = pList->version;
        *msg++ = pList->beaconOrder;
        *msg++ = pList->superFrameOrder;
        *msg++ = pList->permitJoining;
        pList++;
      }
    }

    MT_BuildAndSendZToolCB( SPI_CB_ZDO_MGMT_NWKDISC_RSP, len, msgPtr );

    osal_mem_free( msgPtr );
  }
}
#endif // ZDO_MGMT_NWKDISC_REQUEST

#if defined ( ZDO_MGMT_RTG_REQUEST )
/*********************************************************************
 * @fn      zdo_MTCB_MgmtRtgRspCB()
 *
 * @brief
 *
 *   Called to send MT callback response for Management Network
 *   Discover response
 *
 * @param  SrcAddr  - Source address
 * @param  Status - response status
 *
 * @return  none
 */
void zdo_MTCB_MgmtRtgRspCB( uint16 SrcAddr, byte Status,
                        byte RtgCount, byte StartIndex,
                        byte RtgListCount, rtgItem_t *pList )
{
  byte *msgPtr;
  byte *msg;
  byte len;
  byte x;

  /*Allocate a message of size equivalent to the corresponding SPI message
  (plus a couple of bytes for MT use)so that the same buffer can be sent by
  MT to the test tool by simply setting the header bytes.*/

  /*In order to allocate the message , we need to know the length and this
  has to be calculated before we allocate the message*/

  len = 2 + 1 + 1 + 1 + 1 + (ZDP_RTG_DISCRIPTOR_SIZE * ZDO_MAX_RTG_ITEMS);
      //  SrcAddr + Status + RtgCount + StartIndex + RtgListCount
      //     + (maximum entries * size of struct)

  msgPtr = osal_mem_alloc( len );

  if ( msgPtr )
  {
    msg = msgPtr;

    //Fill up the data bytes
    *msg++ = HI_UINT16( SrcAddr );
    *msg++ = LO_UINT16( SrcAddr );
    *msg++ = Status;
    *msg++ = RtgCount;
    *msg++ = StartIndex;
    *msg++ = RtgListCount;

    osal_memset( msg, 0, (ZDP_RTG_DISCRIPTOR_SIZE * ZDO_MAX_RTG_ITEMS) );

    for ( x = 0; x < ZDO_MAX_RTG_ITEMS; x++ )
    {
      if ( x < RtgListCount )
      {
        *msg++ = HI_UINT16( pList->dstAddress );
        *msg++ = LO_UINT16( pList->dstAddress );
        *msg++ = HI_UINT16( pList->nextHopAddress );
        *msg++ = LO_UINT16( pList->nextHopAddress );
        *msg++ = pList->status;
        pList++;
      }
    }

    MT_BuildAndSendZToolCB( SPI_CB_ZDO_MGMT_RTG_RSP, len, msgPtr );

    osal_mem_free( msgPtr );
  }
}
#endif // ZDO_MGMT_RTG_REQUEST

#if defined ( ZDO_MGMT_BIND_REQUEST )
/*********************************************************************
 * @fn      zdo_MTCB_MgmtBindRspCB()
 *
 * @brief
 *
 *   Called to send MT callback response for Management Network
 *   Discover response
 *
 * @param  SrcAddr  - Source address
 * @param  Status - response status
 *
 * @return  none
 */
void zdo_MTCB_MgmtBindRspCB( uint16 SrcAddr, byte Status,
                        byte BindCount, byte StartIndex,
                        byte BindListCount, apsBindingItem_t *pList )
{
  byte *msgPtr;
  byte *msg;
  byte len;       
  byte x;
  uint8 protoVer = NLME_GetProtocolVersion();
  
  /*Allocate a message of size equivalent to the corresponding SPI message
  (plus a couple of bytes for MT use)so that the same buffer can be sent by
  MT to the test tool by simply setting the header bytes.*/

  /*In order to allocate the message , we need to know the length and this
  has to be calculated before we allocate the message*/
  

  // One more byte for clusterID and DstAddrMode 
  len = 2 + 1 + 1 + 1 + 1 + ( ( ZDP_BIND_DISCRIPTOR_SIZE + 1 + 1 ) * ZDO_MAX_BIND_ITEMS);
      //  SrcAddr + Status + BindCount + StartIndex + BindListCount
      //     + (maximum entries * size of struct)

  msgPtr = osal_mem_alloc( len );

  if ( msgPtr )
  {
    msg = msgPtr;

    //Fill up the data bytes
    *msg++ = HI_UINT16( SrcAddr );
    *msg++ = LO_UINT16( SrcAddr );
    *msg++ = Status;
    *msg++ = BindCount;
    *msg++ = StartIndex;
    *msg++ = BindListCount;

    osal_memset( msg, 0, ( ( ZDP_BIND_DISCRIPTOR_SIZE + 1 + 1)  * ZDO_MAX_BIND_ITEMS) );
    
    
    for ( x = 0; x < ZDO_MAX_BIND_ITEMS; x++ )
    {
      if ( x < BindListCount )
      {
        msg = zdo_MT_CopyRevExtAddr( msg, pList->srcAddr );
        *msg++ = pList->srcEP;
        
        if ( protoVer == ZB_PROT_V1_0 ) 
        {         
          *msg++ = LO_UINT16( pList->clusterID);
          msg = zdo_MT_CopyRevExtAddr( msg, pList->dstAddr.addr.extAddr );    
          *msg++ = pList->dstEP;
        }
        else
        {
          *msg++ = HI_UINT16( pList->clusterID);
          *msg++ = LO_UINT16( pList->clusterID);
          *msg++ = pList->dstAddr.addrMode;
        
          if ( pList->dstAddr.addrMode == Addr64Bit )
          {         
            msg = zdo_MT_CopyRevExtAddr( msg, pList->dstAddr.addr.extAddr );
            *msg++ = pList->dstEP;           
          }
          else
          {
            *msg++ = HI_UINT16( pList->dstAddr.addr.shortAddr );
            *msg++ = LO_UINT16( pList->dstAddr.addr.shortAddr );
            // DstEndpoint will not present if DstAddrMode is not 64-bit extAddr
          }
        }
        
        pList++;
      }
    }

    MT_BuildAndSendZToolCB( SPI_CB_ZDO_MGMT_BIND_RSP, len, msgPtr );

    osal_mem_free( msgPtr );
  }
}
#endif // ZDO_MGMT_RTG_REQUEST

#if defined ( ZDO_MGMT_JOINDIRECT_REQUEST )
/*********************************************************************
 * @fn      zdo_MTCB_MgmtDirectJoinRspCB()
 *
 * @brief
 *
 *   Called to send MT callback response for Management Direct Join
 *   responses
 *
 * @param  SrcAddr  - Source address
 * @param  Status - response status
 *
 * @return  none
 */
void zdo_MTCB_MgmtDirectJoinRspCB( uint16 SrcAddr, byte Status, byte SecurityUse )
{
  byte buf[3];

  buf[0] = HI_UINT16( SrcAddr );
  buf[1] = LO_UINT16( SrcAddr );
  buf[2] = Status;

  MT_BuildAndSendZToolCB( SPI_CB_ZDO_MGMT_DIRECT_JOIN_RSP, 3, buf );
}
#endif // ZDO_MGMT_JOINDIRECT_REQUEST

#if defined ( ZDO_MGMT_LEAVE_REQUEST )
/*********************************************************************
 * @fn      zdo_MTCB_MgmtLeaveRspCB()
 *
 * @brief
 *
 *   Called to send MT callback response for Management Leave
 *   responses
 *
 * @param  SrcAddr  - Source address
 * @param  Status - response status
 *
 * @return  none
 */
void zdo_MTCB_MgmtLeaveRspCB( uint16 SrcAddr, byte Status, byte SecurityUse )
{
  byte buf[3];

  buf[0] = Status;
  buf[1] = HI_UINT16( SrcAddr );
  buf[2] = LO_UINT16( SrcAddr );

  MT_BuildAndSendZToolCB( SPI_CB_ZDO_MGMT_LEAVE_RSP, 3, buf );
}
#endif // ZDO_MGMT_LEAVE_REQUEST

#if defined ( ZDO_MGMT_PERMIT_JOIN_REQUEST )
/*********************************************************************
 * @fn      zdo_MTCB_MgmtPermitJoinRspCB()
 *
 * @brief
 *
 *   Called to send MT callback response for Management Permit Join
 *   responses
 *
 * @param  SrcAddr  - Source address
 * @param  Status - response status
 *
 * @return  none
 */
void zdo_MTCB_MgmtPermitJoinRspCB( uint16 SrcAddr, byte Status, byte SecurityUse )
{
  byte buf[3];

  buf[0] = Status;
  buf[1] = HI_UINT16( SrcAddr );
  buf[2] = LO_UINT16( SrcAddr );

  MT_BuildAndSendZToolCB( SPI_CB_ZDO_MGMT_PERMIT_JOIN_RSP, 3, buf );
}
#endif // ZDO_MGMT_PERMIT_JOIN_REQUEST

#if defined ( ZDO_USERDESC_REQUEST )
#define USER_DESC_CB_LEN  22
/*********************************************************************
 * @fn      zdo_MTCB_UserDescRspCB()
 *
 * @brief
 *
 *   Called to send MT callback response for User Descriptor
 *   responses
 *
 * @param  SrcAddr  - Source address
 * @param  Status - response status
 * @param  nwkAddrOfInterest -
 * @param  userDescLen -
 * @param  userDesc -
 * @param  SecurityUse -
 *
 * @return  none
 */
void zdo_MTCB_UserDescRspCB( uint16 SrcAddr, byte status, uint16 nwkAddrOfInterest,
                          byte userDescLen, byte *userDesc, byte SecurityUse )
{
  byte *msgPtr;
  byte *msg;
  msgPtr = osal_mem_alloc( USER_DESC_CB_LEN );
  osal_memset( msgPtr, 0, USER_DESC_CB_LEN );
  
  msg = msgPtr;
  *msg++ = status;
  *msg++ = HI_UINT16( SrcAddr );
  *msg++ = LO_UINT16( SrcAddr );
  *msg++ = HI_UINT16( nwkAddrOfInterest );
  *msg++ = LO_UINT16( nwkAddrOfInterest );
  *msg++ = userDescLen;
  osal_memcpy( msg, userDesc, userDescLen ); 
  MT_BuildAndSendZToolCB( SPI_CB_ZDO_USER_DESC_RSP, USER_DESC_CB_LEN, msgPtr );
  
  osal_mem_free( msgPtr );
}
#endif // ZDO_USERDESC_REQUEST

#if defined ( ZDO_USERDESCSET_REQUEST )
/*********************************************************************
 * @fn      zdo_MTCB_UserDescConfCB()
 *
 * @brief
 *
 *   Called to send MT callback response for User Descriptor
 *   confirm
 *
 * @param  SrcAddr  - Source address
 * @param  Status - response status
 * @param  SecurityUse -
 *
 * @return  none
 */
void zdo_MTCB_UserDescConfCB( uint16 SrcAddr, byte status, byte SecurityUse )
{
  byte buf[3];

  buf[0] = status;
  buf[1] = HI_UINT16( SrcAddr );
  buf[2] = LO_UINT16( SrcAddr );

  MT_BuildAndSendZToolCB( SPI_CB_ZDO_USER_DESC_CNF, 3, buf );
}
#endif // ZDO_USERDESCSET_REQUEST

#if defined ( ZDO_SERVERDISC_REQUEST )
/*********************************************************************
 * @fn     zdo_MTCB_ServerDiscRspCB()
 *
 * @brief  Called to send MT callback response for Server_Discovery_rsp responses.
 *
 * @param  srcAddr - Source address.
 * @param  status - Response status.
 * @param  aoi - Network Address of Interest.
 * @param  serverMask - Bit mask of services that match request.
 * @param  SecurityUse -
 *
 * @return  none
 */
void zdo_MTCB_ServerDiscRspCB( uint16 srcAddr, byte status, 
                               uint16 serverMask, byte SecurityUse )
{
  byte buf[5];
  byte *pBuf = buf;

  *pBuf++ = status;
  *pBuf++ = HI_UINT16( srcAddr );
  *pBuf++ = LO_UINT16( srcAddr );
  *pBuf++ = HI_UINT16( serverMask );
  *pBuf++ = LO_UINT16( serverMask );

  MT_BuildAndSendZToolCB( SPI_CB_ZDO_SERVERDISC_RSP, 5, buf );
#define CB_ID_ZDO_SERVERDISC_RSP             0x00080000
}
#endif

/*********************************************************************
*********************************************************************/

#endif   /*ZDO Command Processing in MT*/