mt_mac.c

Zigbee2006入门源代码,包括了Zigbee的入门介绍,和源代码

      /* Security Information */
      MT_MacSpi2Sec( &mtMac.disassocReq.Sec, pData );

      /* Call corresponding ZMAC function */
      ret = ZMacDisassociateReq( &mtMac.disassocReq );

      len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_MAC_DEFAULT;
      MT_SendSPIRespMsg( (byte)ret, SPI_CMD_MAC_DISASSOCIATE_REQ, len, SPI_RESP_LEN_MAC_DEFAULT);
      break;

    case SPI_CMD_MAC_GET_REQ:
      attr = *pData;
      len = SPI_0DATA_MSG_LEN + ZTEST_DEFAULT_PARAM_LEN;

      msg_ptr = osal_mem_alloc( len );
      if ( msg_ptr )
      {
        /* initialize the buffer */
        osal_memset( msg_ptr, 0, len );

        /* Call mac_get_req with attr and pointer to first data position*/
        ret = ZMacGetReq( attr, msg_ptr + DATA_BEGIN );

        /*
           Build SPI message here instead of redundantly calling MT_BuildSPIMsg
           because we have copied data already in the allocated message
        */

        *msg_ptr = SOP_VALUE;
        msg_ptr[CMD_FIELD_HI] =
          (byte)(HI_UINT16( ( uint16 )( SPI_RESPONSE_BIT | SPI_CMD_MAC_GET_REQ )));

        msg_ptr[CMD_FIELD_LO] =
          (byte)(LO_UINT16( ( SPI_RESPONSE_BIT | SPI_CMD_MAC_GET_REQ )));

        msg_ptr[DATALEN_FIELD] = len - SPI_0DATA_MSG_LEN;

        /*
          FCS goes to the last byte in the message and is calculated
          over all the bytes except FCS and SOP
        */
        msg_ptr[len - 1] = SPIMgr_CalcFCS( msg_ptr + 1, (byte)(len-2) );

#if (defined SPI_MGR_DEFAULT_PORT)
        HalUARTWrite ( SPI_MGR_DEFAULT_PORT, msg_ptr, len );
#endif
        osal_mem_free( msg_ptr );
      }
      break;

    case SPI_CMD_MAC_SET_REQ:
      /*
        In the data field of 'msg', the first byte is the attribute and remainder
        is the attribute value. So the pointer 'pData' points directly to the attribute.
        The value of the attribute is from the next byte position
      */
      attr = *pData;

      /* special case for beacon payload */
      if ( attr == ZMacBeaconMSDU )
      {
        osal_memcpy( mtMacBeaconPayload, pData + 1, MT_MAC_BEACON_PAYLOAD_MAX );
        ret = ZMacSetReq( (ZMacAttributes_t)attr ,  (byte *) &mtMacBeaconPayload );
      }
      else
      {
        ret = ZMacSetReq( (ZMacAttributes_t)attr , pData + 1 );
      }
      len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_MAC_DEFAULT;
      MT_SendSPIRespMsg( (byte)ret, SPI_CMD_MAC_SET_REQ, len, SPI_RESP_LEN_MAC_DEFAULT );
      break;

    case SPI_CMD_MAC_RESET_REQ:

      /*
        The only data byte in the message has a value of 0/1 indicating
        to set the PIB attributes to default values or to leave as is, after reset.
      */

      ret = ZMacReset( *pData );

      len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_MAC_DEFAULT;
      MT_SendSPIRespMsg( (byte)ret, SPI_CMD_MAC_RESET_REQ, len, SPI_RESP_LEN_MAC_DEFAULT);
      break;

    case SPI_CMD_MAC_GTS_REQ:
      /* Not supported */
      break;

    case SPI_CMD_MAC_ORPHAN_RSP:

#if defined( USING_FFDCMAC )
      /* Extended address of the device sending the notification */
      MT_MacRevExtCpy( mtMac.orphanRsp.OrphanAddress, pData );
      pData += Z_EXTADDR_LEN;

      /* Short address of the orphan device */
      mtMac.orphanRsp.ShortAddress = BUILD_UINT16( pData[1] , pData[0] );
      pData += 2;

      /* Associated member */
      mtMac.orphanRsp.AssociatedMember = *pData++;

      /* Security Information */
      MT_MacSpi2Sec( &mtMac.orphanRsp.Sec, pData );

      /* Call corresponding ZMAC function */
      ret = ZMacOrphanRsp( &mtMac.orphanRsp );
#else
      ret = ZMacUnsupportedAttribute;
#endif // USING_FFDCMAC

      len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_MAC_DEFAULT;
      MT_SendSPIRespMsg( (byte)ret, SPI_CMD_MAC_ORPHAN_RSP, len, SPI_RESP_LEN_MAC_DEFAULT);
      break;

    case SPI_CMD_MAC_RX_ENABLE_REQ:

      /* First byte - DeferPermit*/
      mtMac.rxEnableReq.DeferPermit = *pData++;

      /* RxOnTime */
      mtMac.rxEnableReq.RxOnTime = BUILD_UINT32 (pData[3], pData[2], pData[1], pData[0]);
      pData += 4;

      /* RxOnDuration */
      mtMac.rxEnableReq.RxOnDuration = BUILD_UINT32 (pData[3], pData[2], pData[1], pData[0]);

      /* Call corresponding ZMAC function */
      ret = ZMacRxEnableReq ( &mtMac.rxEnableReq );

      len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_MAC_DEFAULT;
      MT_SendSPIRespMsg( (byte)ret, SPI_CMD_MAC_RX_ENABLE_REQ, len, SPI_RESP_LEN_MAC_DEFAULT);
      break;

    case SPI_CMD_MAC_SYNC_REQ:

      /* LogicalChannel */
      mtMac.syncReq.LogicalChannel = *pData++;

      /* ChannelPage */
      mtMac.syncReq.ChannelPage = *pData++;

      /* TrackBeacon */
      mtMac.syncReq.TrackBeacon    = *pData;

      /* Call corresponding ZMAC function */
      ret = ZMacSyncReq( &mtMac.syncReq );

      len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_MAC_DEFAULT;
      MT_SendSPIRespMsg( (byte)ret, SPI_CMD_MAC_SYNC_REQ, len, SPI_RESP_LEN_MAC_DEFAULT);
      break;

    case SPI_CMD_MAC_POLL_REQ:

      /* Coordinator address mode */
      mtMac.pollReq.CoordAddress.addrMode = *pData++;

      /* Coordinator address - Device address mode have to be set to use this function */
      MT_MacSpi2Addr( &mtMac.pollReq.CoordAddress, pData);
      pData += Z_EXTADDR_LEN;

      /* Coordinator Pan ID */
      mtMac.pollReq.CoordPanId = BUILD_UINT16( pData[1] , pData[0] );
      pData += 2;

      /* Security Information */
      MT_MacSpi2Sec( &mtMac.pollReq.Sec, pData );

      /* Call corresponding ZMAC function */
      ret = ZMacPollReq( &mtMac.pollReq );

      len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_MAC_DEFAULT;
      MT_SendSPIRespMsg( (byte)ret, SPI_CMD_MAC_POLL_REQ, len, SPI_RESP_LEN_MAC_DEFAULT);
      break;

    case SPI_CMD_MAC_PURGE_REQ:
      /* First and only byte - MsduHandle */
      ret = ZMacPurgeReq (*pData);

      len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_MAC_DEFAULT;
      MT_SendSPIRespMsg( (byte)ret, SPI_CMD_MAC_PURGE_REQ, len, SPI_RESP_LEN_MAC_DEFAULT);
      break;
  }
}

#if defined ( MT_MAC_CB_FUNC )
/*********************************************************************
 * @fn          nwk_MTCallbackSubNwkStartCnf
 *
 * @brief       Process the callback subscription for nwk_start_cnf
 *
 * @param       byte Status
 *
 * @return      None
 */
void nwk_MTCallbackSubNwkStartCnf( byte Status )
{
  mtOSALSerialData_t  *msgPtr;
  byte                *msg;

  msgPtr = MT_MacMsgAllocate( SPI_CB_NWK_START_CNF, SPI_RESP_LEN_MAC_DEFAULT );
  if ( msgPtr )
  {
    msg = msgPtr->msg + DATA_BEGIN;

    /* Status */
    *msg = Status;

    osal_msg_send( MT_TaskID, (byte *) msgPtr );
  }
}

/*********************************************************************
 * @fn          nwk_MTCallbackSubNwkDataCnf
 *
 * @brief       Process the callback subscription for nwk_data_cnf
 *
 * @param       pointer of type macnwk_data_cnf_t
 *
 * @return      SUCCESS if message sent succesfully , else N_FAIL
 */
byte nwk_MTCallbackSubNwkDataCnf( ZMacDataCnf_t *param )
{
  mtOSALSerialData_t  *msgPtr;
  byte                *msg;

  msgPtr = MT_MacMsgAllocate( SPI_CB_NWK_DATA_CNF, SPI_LEN_NWK_DATA_CNF );
  if ( msgPtr )
  {
    msg = msgPtr->msg + DATA_BEGIN;

    /* Status */
    *msg++ = param->hdr.Status;

    /* Handle */
    *msg++ = param->msduHandle;

    /* Timestamp */
    *msg++ = BREAK_UINT32( param->Timestamp, 3 );
    *msg++ = BREAK_UINT32( param->Timestamp, 2 );
    *msg++ = BREAK_UINT32( param->Timestamp, 1 );
    *msg++ = BREAK_UINT32( param->Timestamp, 0 );

    /* Timestamp2 */
    *msg++ = HI_UINT16( param->Timestamp2);
    *msg = LO_UINT16( param->Timestamp2);

    if ( osal_msg_send( MT_TaskID, (byte *) msgPtr ) == ZSUCCESS )
      return ZMacSuccess;
    else
      return INVALID_TASK;
  }
  else
    return INVALID_TASK;
}

/*********************************************************************
 * @fn          nwk_MTCallbackSubNwkDataInd
 *
 * @brief       Process the callback subscription for nwk_data_ind
 *
 * @param       pointer of type macnwk_data_ind_t
 *
 * @return      SUCCESS if message sent succesfully , else N_FAIL
 */
byte nwk_MTCallbackSubNwkDataInd( ZMacDataInd_t *param )
{
  mtOSALSerialData_t  *msgPtr;
  byte                *msg;
  byte                len;

  msgPtr = MT_MacMsgAllocate( SPI_CB_NWK_DATA_IND, SPI_LEN_NWK_DATA_IND + ZTEST_DEFAULT_DATA_LEN );

  if ( msgPtr )
  {
    msg = msgPtr->msg + DATA_BEGIN;

    /* Src address mode */
    *msg++ = param->SrcAddr.addrMode;

    /* Src Address */
    MT_MacAddr2Spi( msg, &param->SrcAddr );
    msg += Z_EXTADDR_LEN;

    /* Dst address mode */
    *msg++ = param->DstAddr.addrMode;

    /* Dst address */
    MT_MacAddr2Spi( msg, &param->DstAddr );
    msg += Z_EXTADDR_LEN;

       /* Timestamp */
    *msg++ = BREAK_UINT32( param->Timestamp, 3 );
    *msg++ = BREAK_UINT32( param->Timestamp, 2 );
    *msg++ = BREAK_UINT32( param->Timestamp, 1 );
    *msg++ = BREAK_UINT32( param->Timestamp, 0 );

    /* Timestamp2 */
    *msg++ = HI_UINT16( param->Timestamp2);
    *msg++ = LO_UINT16( param->Timestamp2);

    /* Src Pan Id */
    *msg++ = HI_UINT16( param->SrcPANId );
    *msg++ = LO_UINT16( param->SrcPANId );

    /* Dst Pan Id */
    *msg++ = HI_UINT16( param->DstPANId );
    *msg++ = LO_UINT16( param->DstPANId );

    /* mpdu Link Quality */
    *msg++ = param->mpduLinkQuality;

    /* LQI */
    *msg++ = param->Correlation;

    /* RSSI */
    *msg++ = param->Rssi;

    /* DSN */
    *msg++ = param->Dsn;

    /* Security */
    MT_MacSpi2Sec ((ZMacSec_t *)msg, (uint8 *)&param->Sec);
    msg += ZTEST_DEFAULT_SEC_LEN;

    /* Copy the data portion - For now, the data must be a fixed length */
    if ( param->msduLength < ZTEST_DEFAULT_DATA_LEN )
      len = param->msduLength;
    else
      len = ZTEST_DEFAULT_DATA_LEN;

    *msg++ = len;
    osal_memset( msg, 0, ZTEST_DEFAULT_DATA_LEN );
    osal_memcpy( msg, param->msdu, len );

    if ( osal_msg_send( MT_TaskID, (byte *) msgPtr ) == ZSUCCESS )
      return ZMacSuccess;
    else
      return INVALID_TASK;
  }
  else
    return INVALID_TASK;
}

/*********************************************************************
 * @fn          nwk_MTCallbackSubNwkAssociateCnf
 *
 * @brief       Process the callback subscription for nwk_associate_cnf
 *
 * @param       pointer of type macnwk_associate_cnf_t
 *
 * @return      SUCCESS if message sent succesfully , else N_FAIL
 */
byte nwk_MTCallbackSubNwkAssociateCnf( ZMacAssociateCnf_t *param )
{
  mtOSALSerialData_t  *msgPtr;
  byte                *msg;

  msgPtr = MT_MacMsgAllocate( SPI_CB_NWK_ASSOCIATE_CNF, SPI_LEN_NWK_ASSOCIATE_CNF );

  if ( msgPtr )
  {
    msg = msgPtr->msg + DATA_BEGIN;

    /* Status */
    *msg++ = param->hdr.Status;

    /* Short address */
    *msg++ = HI_UINT16( param->AssocShortAddress );
    *msg++ = LO_UINT16( param->AssocShortAddress );

    /* Security */
    MT_MacSpi2Sec ((ZMacSec_t *)msg, (uint8 *)&param->Sec);

    if ( osal_msg_send( MT_TaskID, (byte *) msgPtr ) == ZSUCCESS )
      return ZMacSuccess;
    else
      return INVALID_TASK;
  }
  else
    return INVALID_TASK;
}


/*********************************************************************
 * @fn          nwk_MTCallbackSubNwkAssociateInd
 *
 * @brief       Process the callback subscription for nwk_associate_ind
 *
 * @param       pointer of type macnwk_associate_ind_t
 *
 * @return      SUCCESS if message sent succesfully , else N_FAIL
 *********************************************************************/
byte nwk_MTCallbackSubNwkAssociateInd( ZMacAssociateInd_t *param )
{
  mtOSALSerialData_t  *msgPtr;
  byte                *msg;

  msgPtr = MT_MacMsgAllocate( SPI_CB_NWK_ASSOCIATE_IND, SPI_LEN_NWK_ASSOCIATE_IND );

  if ( msgPtr )
  {
    msg = msgPtr->msg + DATA_BEGIN;

    /* Extended address */
    MT_MacRevExtCpy( msg, param->DeviceAddress );
    msg += Z_EXTADDR_LEN;

    /* Capability Information */
    *msg++ = param->CapabilityInformation;

    /* Security */
    MT_MacSpi2Sec ((ZMacSec_t *)msg, (uint8 *)&param->Sec);

    if ( osal_msg_send( MT_TaskID, (byte *) msgPtr ) == ZSUCCESS )
      return ZMacSuccess;
    else
      return INVALID_TASK;
  }
  else
    return INVALID_TASK;
}



/*********************************************************************
 * @fn          nwk_MTCallbackSubNwkDisassociateInd
 *
 * @brief       Process the callback subscription for nwk_disassociate_ind
 *
 * @param       pointer of type macnwk_disassociate_ind_t
 *
 * @return      SUCCESS if message sent succesfully , else N_FAIL
 *********************************************************************/
byte nwk_MTCallbackSubNwkDisassociateInd( ZMacDisassociateInd_t *param )
{
  mtOSALSerialData_t  *msgPtr;
  byte                *msg;

  msgPtr = MT_MacMsgAllocate( SPI_CB_NWK_DISASSOCIATE_IND, SPI_LEN_NWK_DISASSOCIATE_IND );

  if ( msgPtr )
  {
    msg = msgPtr->msg + DATA_BEGIN;

    /* Extended address */
    MT_MacRevExtCpy( msg, param->DeviceAddress );
    msg += Z_EXTADDR_LEN;

    /* Disassociate Reason */