Z-Stack建立绑定关系之二------终端绑定请求方式

   ZDO终端设备绑定请求:设备能告诉协调器他们想建立绑定表格报告。该协调器将使协调并在这两个设备上创建绑定表格条目。在这里是以SerialApp例子为例。
void SerialApp_HandleKeys( uint8 shift, uint8 keys )

{

   zAddrType_t dstAddr;

 

  if ( shift )

  {

    if ( keys & HAL_KEY_SW_1 )

    {

    }

    if ( keys & HAL_KEY_SW_2 )

    {

    }

    if ( keys & HAL_KEY_SW_3 )

    {

    }

    if ( keys & HAL_KEY_SW_4 )

    {

    }

  }

  else

  {

    if ( keys & HAL_KEY_SW_1 )

    {

    }

    if ( keys & HAL_KEY_SW_2 )

    {

     HalLedSet ( HAL_LED_4, HAL_LED_MODE_OFF );

      //终端设备绑定请求

      // Initiate an End Device Bind Request for the mandatory endpoint

      dstAddr.addrMode = Addr16Bit;

      dstAddr.addr.shortAddr = 0x0000; // Coordinator

      ZDP_EndDeviceBindReq( &dstAddr, NLME_GetShortAddr(),

                            SerialApp_epDesc.endPoint,

                            SERIALAPP_PROFID,

                            SERIALAPP_MAX_CLUSTERS,

                           (cId_t *)SerialApp_ClusterList,

                            SERIALAPP_MAX_CLUSTERS,

                           (cId_t *)SerialApp_ClusterList,

                            FALSE );

    }

    if ( keys & HAL_KEY_SW_3 )

    {

    }

    if ( keys & HAL_KEY_SW_4 )

    {

      HalLedSet ( HAL_LED_4, HAL_LED_MODE_OFF );

      //描述符匹配请求 这也是两不同匹配方式，使用的按键不同

      // Initiate a Match Description Request (Service Discovery)

      dstAddr.addrMode = AddrBroadcast; //广播地址

      dstAddr.addr.shortAddr = NWK_BROADCAST_SHORTADDR;

      ZDP_MatchDescReq( &dstAddr, NWK_BROADCAST_SHORTADDR,

                        SERIALAPP_PROFID,

                        SERIALAPP_MAX_CLUSTERS,

                       (cId_t *)SerialApp_ClusterList,

                        SERIALAPP_MAX_CLUSTERS,

                       (cId_t *)SerialApp_ClusterList,

                        FALSE );

    }

  }

}

    说明：从上面可以看到，SW2是发送终端设备绑定请求方式，SW4是发送描述符匹配请求方式。如果按下SW1的话，使用终端设备绑定请求方式，这里是要通过终端告诉协调器他们想要建立绑定表格，协调器将协调这两个请求的设备，在两个设备上建立绑定表格条目。

(1)终端设备向协调器发送终端设备绑定请求

  调用ZDP_EndDeviceBindReq()函数发送绑定请求。

   ZDP_EndDeviceBindReq( &dstAddr, //目的地址设为0x0000；

                        NLME_GetShortAddr(),

                        SerialApp_epDesc.endPoint, //EP号

                        SERIALAPP_PROFID,//Profile ID

                     SERIALAPP_MAX_CLUSTERS,  //输入簇的数目

                (cId_t *)SerialApp_ClusterList, //输入簇列表

                    SERIALAPP_MAX_CLUSTERS, //输出簇数目

                 (cId_t *)SerialApp_ClusterList,//输出簇列表

                            FALSE );

    该函数实际调用无线发送函数将绑定请求发送给协调器节点：默认clusterID为End_Device_Bind_req，最后通过AF_DataRequest()发送出去.

fillAndSend( &ZDP_TransID, dstAddr, End_Device_Bind_req, len );

最后通过AF_DataRequest()发送出去.

AF_DataRequest( &afAddr, &ZDApp_epDesc, clusterID,

               (uint16)(len+1), (uint8*)(ZDP_TmpBuf-1),

            transSeq, ZDP_TxOptions,  AF_DEFAULT_RADIUS );

(2) 协调器收到终端设备绑定请求End_Device_Bind_req

这个信息会传送到ZDO层，在ZDO层的事件处理函数中，调用ZDApp_ProcessOSALMsg( (osal_event_hdr_t *)msg_ptr );

UINT16 ZDApp_event_loop( byte task_id, UINT16 events )

{

  uint8 *msg_ptr;

  if ( events & SYS_EVENT_MSG )

  {

    while ( (msg_ptr = osal_msg_receive( ZDAppTaskID )) )

    {

      ZDApp_ProcessOSALMsg( (osal_event_hdr_t *)msg_ptr );

      // Release the memory

      osal_msg_deallocate( msg_ptr );

    }

    // Return unprocessed events

return (events ^ SYS_EVENT_MSG);

．．．．．．．．．．．．．．．．．．．．．

  }

void ZDApp_ProcessOSALMsg( osal_event_hdr_t *msgPtr )

{

  // Data Confirmation message fields

  byte sentEP;       // This should always be 0

  byte sentStatus;

  afDataConfirm_t *afDataConfirm;

  switch ( msgPtr->event )

  {

    // Incoming ZDO Message

    case AF_INCOMING_MSG_CMD:

      ZDP_IncomingData( (afIncomingMSGPacket_t *)msgPtr );

      break;

．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．

}

   在ZDP_IncomingData( (afIncomingMSGPacket_t *)msgPtr );函数中

void ZDP_IncomingData( afIncomingMSGPacket_t *pData )

{

  uint8 x = 0;

  uint8 handled;

  zdoIncomingMsg_t inMsg;

  inMsg.srcAddr.addrMode = Addr16Bit;

  inMsg.srcAddr.addr.shortAddr = pData->srcAddr.addr.shortAddr;

  inMsg.wasBroadcast = pData->wasBroadcast;

  inMsg.clusterID = pData->clusterId;

  inMsg.SecurityUse = pData->SecurityUse;

 

  inMsg.asduLen = pData->cmd.DataLength-1;

  inMsg.asdu = pData->cmd.Data+1;

  inMsg.TransSeq = pData->cmd.Data[0];

  handled = ZDO_SendMsgCBs( &inMsg );

 

#if defined( MT_ZDO_FUNC )

  MT_ZdoRsp( &inMsg );

#endif

 

  while ( zdpMsgProcs[x].clusterID != 0xFFFF )

  {

    if ( zdpMsgProcs[x].clusterID == inMsg.clusterID )

    {

      zdpMsgProcs[x].pFn( &inMsg );

      return;

    }

    x++;

  }

 

  // Handle unhandled messages

  if ( !handled )

    ZDApp_InMsgCB( &inMsg );

}

    因为ZDO信息处理表zdpMsgProcs[ ]没有对应的End_Device_Bind_req簇,因此没有调用ZDO信息处理表中的处理函数,但是前面的ZDO_SendMsgCBs()会把这个终端设备绑定请求发送到登记过这个ZDO信息的任务中去。那这个登记注册的程序在哪里呢？

   对于协调器来说，由于在void ZDApp_Init( byte task_id )函数中调用了ZDApp_RegisterCBs();面的函数。进行注册了终端绑定请求信息。

void ZDApp_RegisterCBs( void )

{

#if defined ( ZDO_IEEEADDR_REQUEST ) || defined ( REFLECTOR )

  ZDO_RegisterForZDOMsg( ZDAppTaskID, IEEE_addr_rsp );

#endif

#if defined ( ZDO_NWKADDR_REQUEST ) || defined ( REFLECTOR )

  ZDO_RegisterForZDOMsg( ZDAppTaskID, NWK_addr_rsp );

#endif 

#if defined ( ZDO_COORDINATOR )

  ZDO_RegisterForZDOMsg( ZDAppTaskID, Bind_rsp );

  ZDO_RegisterForZDOMsg( ZDAppTaskID, Unbind_rsp );

  ZDO_RegisterForZDOMsg( ZDAppTaskID, End_Device_Bind_req );

#endif

#if defined ( REFLECTOR )

  ZDO_RegisterForZDOMsg( ZDAppTaskID, Bind_req );

  ZDO_RegisterForZDOMsg( ZDAppTaskID, Unbind_req );

#endif 

}

    因此，协调器节点的 ZDApp 接收到外界输入的数据后，由于注册了 ZDO 反馈消息，即ZDO_CB_MSG，ZDApp 层任务事件处理函数将进行处理：也就是调用下面的程序。

UINT16 ZDApp_event_loop( byte task_id, UINT16 events )

{

  uint8 *msg_ptr;

  if ( events & SYS_EVENT_MSG )

  {

    while ( (msg_ptr = osal_msg_receive( ZDAppTaskID )) )

    {

      ZDApp_ProcessOSALMsg( (osal_event_hdr_t *)msg_ptr );

      // Release the memory

      osal_msg_deallocate( msg_ptr );

    }

    // Return unprocessed events

return (events ^ SYS_EVENT_MSG);

．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．

  }

     在这里调用函数ZDApp_ProcessOSALMsg( (osal_event_hdr_t *)msg_ptr );在这个函数中我们可以看到对ZDO_CB_MSG事件的处理

void ZDApp_ProcessOSALMsg( osal_event_hdr_t *msgPtr )

{

  // Data Confirmation message fields

  byte sentEP;       // This should always be 0

  byte sentStatus;

  afDataConfirm_t *afDataConfirm;

  switch ( msgPtr->event )

  {

    // Incoming ZDO Message

    case AF_INCOMING_MSG_CMD:

      ZDP_IncomingData( (afIncomingMSGPacket_t *)msgPtr );

      break;

    case ZDO_CB_MSG:

      ZDApp_ProcessMsgCBs( (zdoIncomingMsg_t *)msgPtr );

      break;

．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．

}

    调用ZDApp_ProcessMsgCBs（）函数。在这个函数中根据ClusterID（这里是 End_Device_Bind_req）选择相对应的匹配描述符处理函数，

void ZDApp_ProcessMsgCBs( zdoIncomingMsg_t *inMsg )

{

  switch ( inMsg->clusterID )

  {

#if defined ( ZDO_NWKADDR_REQUEST ) || defined ( ZDO_IEEEADDR_REQUEST ) || defined ( REFLECTOR )

    case NWK_addr_rsp:

    case IEEE_addr_rsp:

      {

        ZDO_NwkIEEEAddrResp_t *pAddrRsp;

        pAddrRsp = ZDO_ParseAddrRsp( inMsg );

        if ( pAddrRsp )

        {

          if ( pAddrRsp->status == ZSuccess )

          {

            ZDO_UpdateAddrManager( pAddrRsp->nwkAddr, pAddrRsp->extAddr );

          }

          osal_mem_free( pAddrRsp );

        }

      }

      break;

#endif

     

#if defined ( REFLECTOR )

    case Bind_req:

    case Unbind_req:

      {

        ZDO_BindUnbindReq_t bindReq;

        ZDO_ParseBindUnbindReq( inMsg, &bindReq );

        ZDO_ProcessBindUnbindReq( inMsg, &bindReq );

      }

      break;

#endif     

     

#if defined ( ZDO_COORDINATOR )

    case Bind_rsp:

    case Unbind_rsp:

      if ( matchED )

      {

        ZDMatchSendState(

             (uint8)((inMsg->clusterID == Bind_rsp) ? ZDMATCH_REASON_BIND_RSP : ZDMATCH_REASON_UNBIND_RSP),

             ZDO_ParseBindRsp(inMsg), inMsg->TransSeq );

      }

      break;

     

    case End_Device_Bind_req:

      {

        ZDEndDeviceBind_t bindReq;

        ZDO_ParseEndDeviceBindReq( inMsg, &bindReq );//解析绑定请求信息

      //然后向发送绑定请求的节点发送绑定响应消息：

        ZDO_MatchEndDeviceBind( &bindReq );     

        // Freeing the cluster lists - if allocated.

        if ( bindReq.numInClusters )

          osal_mem_free( bindReq.inClusters );

        if ( bindReq.numOutClusters )

          osal_mem_free( bindReq.outClusters );

      }

      break;

#endif     

  }

}

下面是ZDO_MatchEndDeviceBind（）函数的源代码

void ZDO_MatchEndDeviceBind( ZDEndDeviceBind_t *bindReq )

{

  zAddrType_t dstAddr;

  uint8 sendRsp = FALSE;

  uint8 status;

  // Is this the first request? 接收到的是第一个绑定请求

  if ( matchED == NULL )

  {

    // Create match info structure 创建匹配信息结构体

    matchED = (ZDMatchEndDeviceBind_t *)osal_mem_alloc( sizeof ( ZDMatchEndDeviceBind_t ) ); //分配空间

    if ( matchED )

    {

      // Clear the structure 先进行清除操作

      osal_memset( (uint8 *)matchED, 0, sizeof ( ZDMatchEndDeviceBind_t ) );

      // Copy the first request's information 复制第一个请求信息

    if ( !ZDO_CopyMatchInfo( &(matchED->ed1), bindReq ) ) //复制不成功后

      {

        status = ZDP_NO_ENTRY;

        sendRsp = TRUE;

      }

    }

    else //分配空间不成功

    {

      status = ZDP_NO_ENTRY;

      sendRsp = TRUE;

    }

 

    if ( !sendRsp ) //分配空间成功 ，复制数据结构成功

    {

      // Set into the correct state 设置正确的设备状态

      matchED->state = ZDMATCH_WAIT_REQ;

      // Setup the timeout     设置计时时间APS_SetEndDeviceBindTimeout(AIB_MaxBindingTime,

                        ZDO_EndDeviceBindMatchTimeoutCB );

    }

  }

  else //接收到的不是第一个绑定请求

  {

      matchED->state = ZDMATCH_SENDING_BINDS; //状态为绑定中

  // Copy the 2nd request's information 拷贝第2个请求信息结构

      if ( !ZDO_CopyMatchInfo( &(matchED->ed2), bindReq ) ) //拷贝不成功

      {

        status = ZDP_NO_ENTRY;

        sendRsp = TRUE;

      }

      // Make a source match for ed1

    //对ed1的输出簇ID与ed2的输入簇ID进行比较，如果有符合的则会返回，相匹配的簇的数目

      matchED->ed1numMatched = ZDO_CompareClusterLists(

                  matchED->ed1.numOutClusters, matchED->ed1.outClusters,

                  matchED->ed2.numInClusters, matchED->ed2.inClusters,  ZDOBuildBuf );

      if ( matchED->ed1numMatched ) //如果有返回ed1相匹配的簇

      {

        // Save the match list 申请空间保存相匹配的簇列表

        matchED->ed1Matched= osal_mem_alloc( (short)(matchED->ed1numMatched * sizeof ( uint16 )) );

        if ( matchED->ed1Matched ) //分配成功

        {

//保存相匹配的簇列表

          osal_memcpy(matchED->ed1Matched,ZDOBuildBuf, (matchED->ed1numMatched * sizeof ( uint16 )) );

        }

        else //内存空间分配不成功

        {

          // Allocation error, stop

          status = ZDP_NO_ENTRY;

          sendRsp = TRUE;

        }

      }

      // Make a source match for ed2 以ed2为源

    //对ed2的终端匹配请求和ed1的簇列表相比较，返回相相匹配的簇的数目

      matchED->ed2numMatched = ZDO_CompareClusterLists(

                  matchED->ed2.numOutClusters, matchED->ed2.outClusters,

                  matchED->ed1.numInClusters, matchED->ed1.inClusters, ZDOBuildBuf );

      if ( matchED->ed2numMatched )//如果匹配成功

      {

        // Save the match list 保存匹配的簇列表

        matchED->ed2Matched = osal_mem_alloc( (short)(matchED->ed2numMatched * sizeof ( uint16 )) );

        if ( matchED->ed2Matched )

        {

          osal_memcpy( matchED->ed2Matched, ZDOBuildBuf, (matchED->ed2numMatched * sizeof ( uint16 )) );

        }

        else

        {

          // Allocation error, stop

          status = ZDP_NO_ENTRY;

          sendRsp = TRUE;

        }

      }

  //如果两个相请求的终端设备，有相匹配的簇，并且保存成功

      if ( (sendRsp == FALSE) && (matchED->ed1numMatched || matchED->ed2numMatched) )

      {

        // Do the first unbind/bind state 发送响应信息给两个设备

        ZDMatchSendState( ZDMATCH_REASON_START, ZDP_SUCCESS, 0 );

      }

      else

      {

        status = ZDP_NO_MATCH;

        sendRsp = TRUE;

      }

  }

  if ( sendRsp ) //如果没有相匹配的或匹配不成功

  {

    // send response to this requester 发送匹配请求响应

    dstAddr.addrMode = Addr16Bit; //设置目的地址是16位的短地址

dstAddr.addr.shortAddr = bindReq->srcAddr;

//发送绑定终端响应函数status = ZDP_NO_MATCH;

    ZDP_EndDeviceBindRsp( bindReq->TransSeq, &dstAddr, status, bindReq->SecurityUse );

    if ( matchED->state == ZDMATCH_SENDING_BINDS )

    {

      // send response to first requester

      dstAddr.addrMode = Addr16Bit;

      dstAddr.addr.shortAddr = matchED->ed1.srcAddr;

      ZDP_EndDeviceBindRsp( matchED->ed1.TransSeq, &dstAddr, status, matchED->ed1.SecurityUse );

    }

    // Process ended - release memory used

    ZDO_RemoveMatchMemory();

  }

}

      ZDO_MatchEndDeviceBind()函数,如果协调器接收到接收到第一个绑定请求，则分配内存空间进行保存并计时，如果不是第一个绑定请求，则分别以第一个和第二个绑定请求为源绑定，进行比较匹配，如果比较匹配成功则发送匹配成功的信息End_Device_Bind_rsp给两个请求终端。因为在ZDMatchSendState()函数中也是调用了ZDP_EndDeviceBindRsp()函数，对匹配请求响应进行了发送。如果匹配不成功则发送匹配失败的信息给两个终端。

uint8 ZDMatchSendState( uint8 reason, uint8 status, uint8 TransSeq )

{

．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．

else

  {

    // Send the response messages to requesting devices

    // send response to first requester 发送响应信息给第一个请求终端，

    dstAddr.addr.shortAddr = matchED->ed1.srcAddr;

    ZDP_EndDeviceBindRsp( matchED->ed1.TransSeq, &dstAddr, rspStatus, matchED->ed1.SecurityUse );

    // send response to second requester 发送响应信息给第二请求终端

    if ( matchED->state == ZDMATCH_SENDING_BINDS )

    {

      dstAddr.addr.shortAddr = matchED->ed2.srcAddr;

      ZDP_EndDeviceBindRsp( matchED->ed2.TransSeq, &dstAddr, rspStatus, matchED->ed2.SecurityUse );

    }

    // Process ended - release memory used

    ZDO_RemoveMatchMemory();

  }

  return ( TRUE );

}

（3）终端结点的响应

     由于终端节点在 SerialApp.c 中层注册过 End_Device_Bind_rsp 消息，因此当接收到协调器节点发来的绑定响应消息将交由 SerialApp 任务事件处理函数处理：

UINT16 SerialApp_ProcessEvent( uint8 task_id, UINT16 events )

{

  if ( events & SYS_EVENT_MSG )

  {

    afIncomingMSGPacket_t *MSGpkt;

    while ( (MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive(

                                            SerialApp_TaskID )) )

    {

      switch ( MSGpkt->hdr.event )

      {

        case ZDO_CB_MSG:

          SerialApp_ProcessZDOMsgs( (zdoIncomingMsg_t *)MSGpkt );

          break;

 ．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．

}

然后，调用 SerialApp_ProcessZDOMsgs（）函数。进行事件处理。

static void SerialApp_ProcessZDOMsgs( zdoIncomingMsg_t *inMsg )

{

  switch ( inMsg->clusterID )

  {

    case End_Device_Bind_rsp:

      if ( ZDO_ParseBindRsp( inMsg ) == ZSuccess )

      {

        // Light LED

        HalLedSet( HAL_LED_4, HAL_LED_MODE_ON );

      }

#if defined(BLINK_LEDS)

      else

      {

        // Flash LED to show failure

        HalLedSet ( HAL_LED_4, HAL_LED_MODE_FLASH );

      }

#endif

      break;

．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．

}

    至此，整个的终端绑定就完成了，从中我们也可以看到其和描述符匹配请求的绑定方式有很大的不同，在描述符匹配请求中，我们知道其实两个设备之间的绑定是不需要经过协调器的，而这种绑定是必须要和协调器发生联系后，才能在两个终端设备中，建立绑定关系。也就是下面的这种方式。
 

“终端设备绑定请求”这一命名有误导的嫌疑。这一请求不仅仅适用于终端设备，而且适用于对希望在协调器上绑定的两个设备中匹配的簇实施绑定。一旦这个函数被调用，将假设REFLECTOR这一编译选项在所有希望使用这一服务的节点中都已经打开。具体操作如下：

（1）       (Bind Req) Device 1 --> Coordinator <--- Device 2 (Bind Req)

协调器首先找出包含在绑定请求中的簇，然后对比每一设备的IEEE地址，如果簇可以匹配，而且这几个设备没有已经存在的绑定表，那他将发送一个绑定应答给每一个设备。

（2）       Device 1 <--- NWK Addr Req ------ Coordinator ------- NWK addr Req ----> Device 2

（3）       Device 1 ----> NWK Addr Rsp ---> Coordinator <---- NWK addr Rsp <--- Device 2

（4）       Device 1 <----- Bind Rsp <----- Coordinator -----> Bind Rsp ----> Device 2

在《Z-Stack编程指南--绑定》一章中有下面的一段对终端绑定请求的描述。

该绑定机制在一个选定的设备上使用一个按键动作或类似动作在一个定制的超时周期内进行的绑定

行为。在定制的超时周期内在协调器上收集该终端设备绑定请求信息，基于配置文件标识符与簇标识
符的一致性将产生一个绑定表条目。
      在用户指南[SRC  与 SLC]中的应用范例是一些终端设备绑定执行的例子。（按每个设备上 SW2 开关） 。  你将注意到所有的应用范例都有一个处理按键事件的函数（如，在 TransmitApp.c 中的
TransmitApp_HandleKeys( )  ） 。这个函数调用 ZDApp_SendEndDeviceBindReq( )[在 ZDApp.c 文件中],
它可以收集所有应用端点的信息，并且调用 ZDP_EndDeviceBindReq( ) [在 ZDProfile.c 文件中]来发送
信息到协调器中。
      协调器将接收[ZDP_IncomingData( ),在 ZDProfile.c 中]和分析[ZDO_ProcessEndDeviceBindReq( ),在
ZDObject.c 中]这个信息，并且调用 ZDApp_EndDeviceBindReqCB( )[在 ZDApp.c 中]来调用
ZDO_DoEndDeviceBind( )[在 ZDObject.c]来处理该请求。
      当协调器接收到两个匹配终端设备绑定请求时，将通过调用 nwk_AddBindEntry( )函数来创建一个绑定
记录。如果已存在这两个匹配终端设备请求的绑定记录，则协调器将调用 nwk_RemoveBindingEntry( )
从绑定表中移除该条目。然后，一条响应信息将发送到这两个“终端设备” 。