uint8 zb_PermitJoiningRequest ( uint16 destination, uint8 timeout )
{
#if defined( ZDO_MGMT_PERMIT_JOIN_REQUEST )
zAddrType_t dstAddr;
dstAddr.addrMode = Addr16Bit;
dstAddr.addr.shortAddr = destination;
return( (uint8) ZDP_MgmtPermitJoinReq( &dstAddr, timeout, 0, 0 ) );
#else
return ZUnsupportedMode;
#endif
}
/*********************************************************************
* @fn zclSampleSw_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:
* HAL_KEY_SW_5
* HAL_KEY_SW_4
* HAL_KEY_SW_2
* HAL_KEY_SW_1
*
* @return none
*/
static void zclSampleSw_HandleKeys( byte shift, byte keys )
{
// toggle remote light
if ( keys & HAL_KEY_SW_1 )
{
giSwScreenMode = SW_MAINMODE; // remove help screen if there
// Using this as the "Light Switch"
#ifdef ZCL_ON_OFF
zclGeneral_SendOnOff_CmdToggle( SAMPLESW_ENDPOINT, &zclSampleSw_DstAddr, FALSE, 0 );
#endif
#ifdef LCD_SUPPORTED
HalLcdWriteString( (char *)sCmdSent, HAL_LCD_LINE_2 );
// clear message on screen after 3 seconds
osal_start_timerEx( zclSampleSw_TaskID, SAMPLESW_MAIN_SCREEN_EVT, 3000 );
#endif
}
// invoke EZ-Mode
if ( keys & HAL_KEY_SW_2 )
{
giSwScreenMode = SW_MAINMODE; // remove help screen if there
#ifdef ZCL_EZMODE
{
zclEZMode_InvokeData_t ezModeData;
static uint16 clusterIDs[] = { ZCL_CLUSTER_ID_GEN_ON_OFF }; // only bind on the on/off cluster
// Invoke EZ-Mode
ezModeData.endpoint = SAMPLESW_ENDPOINT; // endpoint on which to invoke EZ-Mode
if ( (zclSampleSw_NwkState == DEV_ZB_COORD) ||
(zclSampleSw_NwkState == DEV_ROUTER) ||
(zclSampleSw_NwkState == DEV_END_DEVICE) )
{
ezModeData.onNetwork = TRUE; // node is already on the network
}
else
{
ezModeData.onNetwork = FALSE; // node is not yet on the network
}
ezModeData.initiator = TRUE; // OnOffSwitch is an initiator
ezModeData.numActiveOutClusters = 1; // active output cluster
ezModeData.pActiveOutClusterIDs = clusterIDs;
ezModeData.numActiveInClusters = 0; // no active input clusters
ezModeData.pActiveInClusterIDs = NULL;
zcl_InvokeEZMode( &ezModeData );
#ifdef LCD_SUPPORTED
HalLcdWriteString( "EZMode", HAL_LCD_LINE_2 );
#endif
}
#else // NOT ZCL_EZMODE
// bind to remote light
zAddrType_t dstAddr;
HalLedSet ( HAL_LED_4, HAL_LED_MODE_OFF );
// Initiate an End Device Bind Request, this bind request will
// only use a cluster list that is important to binding.
dstAddr.addrMode = afAddr16Bit;
dstAddr.addr.shortAddr = 0; // Coordinator makes the match
ZDP_EndDeviceBindReq( &dstAddr, NLME_GetShortAddr(),
SAMPLESW_ENDPOINT,
ZCL_HA_PROFILE_ID,
0, NULL, // No incoming clusters to bind
ZCLSAMPLESW_BINDINGLIST, bindingOutClusters,
TRUE );
#endif // ZCL_EZMODE
}
// toggle permit join
if ( keys & HAL_KEY_SW_4 )
{
giSwScreenMode = SW_MAINMODE; // remove help screen if there
if ( ( zclSampleSw_NwkState == DEV_ZB_COORD ) ||
( zclSampleSw_NwkState == DEV_ROUTER ) )
{
zAddrType_t tmpAddr;
tmpAddr.addrMode = Addr16Bit;
tmpAddr.addr.shortAddr = NLME_GetShortAddr();
// toggle permit join
gPermitDuration = gPermitDuration ? 0 : 0xff;
// Trust Center significance is always true
ZDP_MgmtPermitJoinReq( &tmpAddr, gPermitDuration, TRUE, FALSE );
}
}
if ( shift && ( keys & HAL_KEY_SW_5 ) )
{
zclSampleSw_BasicResetCB();
}
else if ( keys & HAL_KEY_SW_5 )
{
giSwScreenMode = giSwScreenMode ? SW_MAINMODE : SW_HELPMODE;
#ifdef LCD_SUPPORTED
HalLcdWriteString( (char *)sClearLine, HAL_LCD_LINE_2 );
#endif
}
// update the display
zclSampleSw_LcdDisplayUpdate();
}
/*********************************************************************
* @fn zcl_ProcessEZMode
*
* @brief Called when EZ-Mode changes state. See EZMODE_STATE_xxxx in zcl_ezmode.h
*
* @param none
*
* @return status
*/
static void zcl_ProcessEZMode( void )
{
zAddrType_t dstAddr;
afAddrType_t afDstAddr;
zclEZMode_CBData_t cbData;
dstAddr.addr.shortAddr = 0xfffc; // all routers (for PermitJoin) devices
dstAddr.addrMode = AddrBroadcast;
afDstAddr.addr.shortAddr = 0xffff; // all devices (for IdentifyQuery)
afDstAddr.addrMode = afAddrBroadcast;
afDstAddr.endPoint = 0xff;
switch(zclEZModeState)
{
// openers will broadcast permit joining
case EZMODE_STATE_OPENER:
zclEZModeOpener = 1;
// enable joining both locally and over-the-air
NLME_PermitJoiningRequest( (byte)(EZMODE_TIME / 1000) );
ZDP_MgmtPermitJoinReq( &dstAddr, (byte)(EZMODE_TIME / 1000), TRUE, FALSE);
// then go to identifying state
zcl_SetEZModeState(EZMODE_STATE_IDENTIFYING);
break;
// joiners will try to join the network, and if success will go to identifying state
case EZMODE_STATE_JOINER:
zclEZModeOpener = 0;
ZDOInitDevice(0); // see ZDO_STATE_CHANGE in zclSampleSw_event_loop()
break;
// go into identify state
case EZMODE_STATE_IDENTIFYING:
// tell app to go into identify mode
if ( zclEZModeRegisterData.pfnNotifyCB )
{
(*zclEZModeRegisterData.pfnNotifyCB)( zclEZModeState, NULL );
}
// initiators start looking for other nodes in identify mode
if ( zclEZModeInvokeData.initiator )
{
zcl_SetEZModeState ( EZMODE_STATE_WAITING_IDENTIFYQUERYRSP );
}
break;
// timeout out with no query response, send another
case EZMODE_STATE_WAITING_IDENTIFYQUERYRSP:
// ZStatus_t zclGeneral_SendIdentifyQuery( uint8 srcEP, afAddrType_t *dstAddr, uint8 disableDefaultRsp, uint8 seqNum );
// NOTE: Ensure that Identify Cluster is enabled to use this function for EZ-Mode
zclGeneral_SendIdentifyQuery( zclEZModeInvokeData.endpoint, &afDstAddr, TRUE, (*zclEZModeRegisterData.pZclSeqNum)++ );
// wait some time before sending out the next IdentifyQuery, will stop when we get a response
osal_start_timerEx( *zclEZModeRegisterData.pTaskID, zclEZModeRegisterData.processEvt, EZMODE_IDQUERYTIME );
break;
// waiting for simple descriptor response
case EZMODE_STATE_WAITING_MATCHDESCRSP:
break;
// if waiting on autoclose, then we're done. Go to success.
case EZMODE_STATE_AUTOCLOSE:
// special case: if 2 initators, we only fail if no match from either side
if( zclEZModeInvokeData.initiator && !zclEZModeMatched )
{
zcl_SetEZModeError ( EZMODE_ERR_NOMATCH );
}
// if user specified callback, call on AutoClose
if ( zclEZModeRegisterData.pfnNotifyCB )
{
cbData.sAutoClose.err = zclEZModeErr;
(*zclEZModeRegisterData.pfnNotifyCB)( zclEZModeState, &cbData );
}
// no longer will timeout, since cannot fail
osal_stop_timerEx( *zclEZModeRegisterData.pTaskID, zclEZModeRegisterData.timeoutEvt );
// wait a little to turn off identify mode, to give time for the other side to discover
// in case of complex devices (both target/initiator)
osal_start_timerEx( *zclEZModeRegisterData.pTaskID, zclEZModeRegisterData.processEvt, EZMODE_AUTOCLOSETIME );
// go to finish state after autoclose. Don't use zcl_SetEZModeState() because we don't want it to happen immediately
zclEZModeState = EZMODE_STATE_FINISH;
break;
case EZMODE_STATE_FINISH:
// no longer will timeout, since we're done
osal_stop_timerEx( *zclEZModeRegisterData.pTaskID, zclEZModeRegisterData.timeoutEvt );
// if we opened the network, close it now (turn off joining)
if ( zclEZModeOpener )
{
ZDP_MgmtPermitJoinReq( &dstAddr, 0, TRUE, FALSE);
}
// if user callback, inform them of the finish, which will also turn off identify
if ( zclEZModeRegisterData.pfnNotifyCB )
{
cbData.sFinish.err = zclEZModeErr;
cbData.sFinish.ep = zclEZModeQueryRspEP;
cbData.sFinish.nwkaddr = zclEZModeQueryRspNwkAddr;
(*zclEZModeRegisterData.pfnNotifyCB)( zclEZModeState, &cbData );
}
// done, back to ready state
zclEZModeState = EZMODE_STATE_READY;
break;
}
}
/*********************************************************************
* @fn MT_ZdoCommandProcessing
*
* @brief
*
* Process all the ZDO commands that are issued by test tool
*
* @param cmd_id - Command ID
* @param len - Length of received SPI data message
* @param pData - pointer to received SPI data message
*
* @return void
*/
void MT_ZdoCommandProcessing( uint16 cmd_id , byte len , byte *pData )
{
byte i;
byte x;
byte ret;
byte attr;
byte attr1;
uint16 cID;
uint16 shortAddr;
uint16 uAttr;
byte *ptr;
byte *ptr1;
zAddrType_t devAddr;
zAddrType_t dstAddr;
byte respLen;
#if defined ( ZDO_MGMT_NWKDISC_REQUEST )
uint32 scanChans;
#endif
#if defined ( ZDO_USERDESCSET_REQUEST )
UserDescriptorFormat_t userDesc;
#endif
ret = UNSUPPORTED_COMMAND;
len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_ZDO_DEFAULT;
respLen = SPI_RESP_LEN_ZDO_DEFAULT;
switch (cmd_id)
{
case SPI_CMD_ZDO_AUTO_ENDDEVICEBIND_REQ:
i = *pData; // Get the endpoint/interface
ZDApp_SendEndDeviceBindReq( i );
//Since function type is void, report a succesful operation to the test tool
ret = ZSUCCESS;
break;
case SPI_CMD_ZDO_AUTO_FIND_DESTINATION_REQ:
i = *pData; // Get the endpoint/interface
ZDApp_AutoFindDestination( i );
//Since function type is void, report a succesful operation to the test tool
ret = ZSUCCESS;
break;
#if defined ( ZDO_NWKADDR_REQUEST )
case SPI_CMD_ZDO_NWK_ADDR_REQ:
// Copy and flip incoming 64-bit address
pData = zdo_MT_MakeExtAddr( &devAddr, pData );
ptr = (byte*)&devAddr.addr.extAddr;
attr = *pData++; // RequestType
attr1 = *pData++; // StartIndex
x = *pData;
ret = (byte)ZDP_NwkAddrReq( ptr, attr, attr1, x );
break;
#endif
#if defined ( ZDO_IEEEADDR_REQUEST )
case SPI_CMD_ZDO_IEEE_ADDR_REQ:
shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += sizeof( shortAddr );
attr = *pData++; // RequestType
attr1 = *pData++; // StartIndex
x = *pData; // SecuritySuite
ret = (byte)ZDP_IEEEAddrReq( shortAddr, attr, attr1, x );
break;
#endif
#if defined ( ZDO_NODEDESC_REQUEST )
case SPI_CMD_ZDO_NODE_DESC_REQ:
// destination address
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
// Network address of interest
shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
attr = *pData;
ret = (byte)ZDP_NodeDescReq( &devAddr, shortAddr, attr );
break;
#endif
#if defined ( ZDO_POWERDESC_REQUEST )
case SPI_CMD_ZDO_POWER_DESC_REQ:
// destination address
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
// Network address of interest
shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
attr = *pData;
ret = (byte)ZDP_PowerDescReq( &devAddr, shortAddr, attr );
break;
#endif
#if defined ( ZDO_SIMPLEDESC_REQUEST )
case SPI_CMD_ZDO_SIMPLE_DESC_REQ:
// destination address
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
// Network address of interest
shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
attr = *pData++; // endpoint/interface
attr1 = *pData; // SecuritySuite
ret = (byte)ZDP_SimpleDescReq( &devAddr, shortAddr, attr, attr1 );
break;
#endif
#if defined ( ZDO_ACTIVEEP_REQUEST )
case SPI_CMD_ZDO_ACTIVE_EPINT_REQ:
// destination address
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
// Network address of interest
shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
attr = *pData; // SecuritySuite
ret = (byte)ZDP_ActiveEPReq( &devAddr, shortAddr, attr );
break;
#endif
#if defined ( ZDO_MATCH_REQUEST )
case SPI_CMD_ZDO_MATCH_DESC_REQ:
{
uint16 inC[16], outC[16];
// destination address
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
// Network address of interest
shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
uAttr = BUILD_UINT16( pData[1], pData[0] ); // Profile ID
pData += 2;
attr = *pData++; // NumInClusters
for (i=0; i<16; ++i) {
inC[i] = BUILD_UINT16(pData[1], pData[0]);
pData += 2;
}
attr1 = *pData++; // NumOutClusters
for (i=0; i<16; ++i) {
outC[i] = BUILD_UINT16(pData[1], pData[0]);
pData += 2;
}
i = *pData; // SecuritySuite
ret = (byte)ZDP_MatchDescReq( &devAddr, shortAddr, uAttr,
attr, inC, attr1, outC, i );
}
break;
#endif
#if defined ( ZDO_COMPLEXDESC_REQUEST )
case SPI_CMD_ZDO_COMPLEX_DESC_REQ:
// destination address
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
// Network address of interest
shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
attr = *pData; // SecuritySuite
ret = (byte)ZDP_ComplexDescReq( &devAddr, shortAddr, attr );
break;
#endif
#if defined ( ZDO_USERDESC_REQUEST )
case SPI_CMD_ZDO_USER_DESC_REQ:
// destination address
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
// Network address of interest
shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
attr = *pData; // SecuritySuite
ret = (byte)ZDP_UserDescReq( &devAddr, shortAddr, attr );
break;
#endif
#if defined ( ZDO_ENDDEVICEBIND_REQUEST )
case SPI_CMD_ZDO_END_DEV_BIND_REQ:
//TODO: When ZTool supports 16 bits the code below will need to take it into account
{
uint16 inC[16], outC[16];
// destination address
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
// Network address of interest
shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
x = *pData++; // EPInt
uAttr = BUILD_UINT16( pData[1], pData[0] ); // Profile ID
pData += 2;
attr = *pData++; // NumInClusters
for (i=0; i<16; ++i) {
inC[i] = BUILD_UINT16(pData[1], pData[0]);
pData += 2;
}
attr1 = *pData++; // NumOutClusters
for (i=0; i<16; ++i) {
outC[i] = BUILD_UINT16(pData[1], pData[0]);
pData += 2;
}
i = *pData; // SecuritySuite
ret = (byte)ZDP_EndDeviceBindReq( &devAddr, shortAddr, x, uAttr,
attr, inC, attr1, outC, i );
}
break;
#endif
#if defined ( ZDO_BIND_UNBIND_REQUEST )
case SPI_CMD_ZDO_BIND_REQ:
// destination address
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
MT_ReverseBytes( pData, Z_EXTADDR_LEN );
ptr = pData; // SrcAddress
pData += Z_EXTADDR_LEN;
attr = *pData++; // SrcEPInt
cID = BUILD_UINT16( pData[1], pData[0]); // ClusterID
pData += 2;
dstAddr.addrMode = *pData++;
if ( NLME_GetProtocolVersion() == ZB_PROT_V1_0 )
dstAddr.addrMode = Addr64Bit;
MT_ReverseBytes( pData, Z_EXTADDR_LEN );
if ( dstAddr.addrMode == Addr64Bit )
{
ptr1 = pData; // DstAddress
osal_cpyExtAddr( dstAddr.addr.extAddr, ptr1 );
}
else
{
dstAddr.addr.shortAddr = BUILD_UINT16( pData[0], pData[1] );
}
// The short address occupies lsb two bytes
pData += Z_EXTADDR_LEN;
attr1 = *pData++; // DstEPInt
x = *pData; // SecuritySuite
#if defined ( REFLECTOR )
if ( devAddr.addr.shortAddr == _NIB.nwkDevAddress )
{
ZDApp_BindReqCB( 0, &devAddr, ptr, attr, cID, &dstAddr, attr1, x );
ret = ZSuccess;
}
else
#endif
ret = (byte)ZDP_BindReq( &devAddr, ptr, attr, cID, &dstAddr, attr1, x );
break;
#endif
#if defined ( ZDO_BIND_UNBIND_REQUEST )
case SPI_CMD_ZDO_UNBIND_REQ:
// destination address
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
MT_ReverseBytes( pData, Z_EXTADDR_LEN );
ptr = pData; // SrcAddress
pData += Z_EXTADDR_LEN;
attr = *pData++; // SrcEPInt
cID = BUILD_UINT16( pData[1], pData[0]); // ClusterID
pData += 2;
dstAddr.addrMode = *pData++;
if ( NLME_GetProtocolVersion() == ZB_PROT_V1_0 )
dstAddr.addrMode = Addr64Bit;
MT_ReverseBytes( pData, Z_EXTADDR_LEN );
if ( dstAddr.addrMode == Addr64Bit )
{
ptr1 = pData; // DstAddress
osal_cpyExtAddr( dstAddr.addr.extAddr, ptr1 );
}
else
{
dstAddr.addr.shortAddr = BUILD_UINT16( pData[0], pData[1] );
}
pData += Z_EXTADDR_LEN;
attr1 = *pData++; // DstEPInt
x = *pData; // SecuritySuite
#if defined ( REFLECTOR )
if ( devAddr.addr.shortAddr == _NIB.nwkDevAddress )
{
ZDApp_UnbindReqCB( 0, &devAddr, ptr, attr, cID, &dstAddr, attr1, x );
ret = ZSuccess;
}
else
#endif
{
ret = (byte)ZDP_UnbindReq( &devAddr, ptr, attr, cID, &dstAddr, attr1, x );
}
break;
#endif
#if defined ( ZDO_MGMT_NWKDISC_REQUEST )
case SPI_CMD_ZDO_MGMT_NWKDISC_REQ:
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
scanChans = BUILD_UINT32( pData[3], pData[2], pData[1], pData[0] );
ret = (byte)ZDP_MgmtNwkDiscReq( &devAddr, scanChans, pData[4], pData[5], false );
break;
#endif
#if defined ( ZDO_MGMT_LQI_REQUEST )
case SPI_CMD_ZDO_MGMT_LQI_REQ:
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
ret = (byte)ZDP_MgmtLqiReq( &devAddr, pData[2], false );
break;
#endif
#if defined ( ZDO_MGMT_RTG_REQUEST )
case SPI_CMD_ZDO_MGMT_RTG_REQ:
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
ret = (byte)ZDP_MgmtRtgReq( &devAddr, pData[2], false );
break;
#endif
#if defined ( ZDO_MGMT_BIND_REQUEST )
case SPI_CMD_ZDO_MGMT_BIND_REQ:
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
ret = (byte)ZDP_MgmtBindReq( &devAddr, pData[2], false );
break;
#endif
#if defined ( ZDO_MGMT_JOINDIRECT_REQUEST )
case SPI_CMD_ZDO_MGMT_DIRECT_JOIN_REQ:
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
MT_ReverseBytes( &pData[2], Z_EXTADDR_LEN );
ret = (byte)ZDP_MgmtDirectJoinReq( &devAddr,
&pData[2],
pData[2 + Z_EXTADDR_LEN],
false );
break;
#endif
#if defined ( ZDO_MGMT_LEAVE_REQUEST )
case SPI_CMD_ZDO_MGMT_LEAVE_REQ:
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
MT_ReverseBytes( &pData[2], Z_EXTADDR_LEN );
ret = (byte)ZDP_MgmtLeaveReq( &devAddr, &pData[2], false );
break;
#endif
#if defined ( ZDO_MGMT_PERMIT_JOIN_REQUEST )
case SPI_CMD_ZDO_MGMT_PERMIT_JOIN_REQ:
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
ret = (byte)ZDP_MgmtPermitJoinReq( &devAddr, pData[2], pData[3], false );
break;
#endif
#if defined ( ZDO_USERDESCSET_REQUEST )
case SPI_CMD_ZDO_USER_DESC_SET:
// destination address
devAddr.addrMode = Addr16Bit;
devAddr.addr.shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
// Network address of interest
shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
// User descriptor
userDesc.len = *pData++;
osal_memcpy( userDesc.desc, pData, userDesc.len );
pData += 16; // len of user desc
ret =(byte)ZDP_UserDescSet( &devAddr, shortAddr, &userDesc, pData[0] );
break;
#endif
#if defined ( ZDO_ENDDEVICE_ANNCE_REQUEST )
case SPI_CMD_ZDO_END_DEV_ANNCE:
// network address
shortAddr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
// extended address
ptr = pData;
MT_ReverseBytes( ptr, Z_EXTADDR_LEN );
pData += Z_EXTADDR_LEN;
// security
attr = *pData++;
ret = (byte)ZDP_EndDeviceAnnce( shortAddr, ptr, *pData, attr );
break;
#endif
#if defined (ZDO_SERVERDISC_REQUEST )
case SPI_CMD_ZDO_SERVERDISC_REQ:
// Service Mask
uAttr = BUILD_UINT16( pData[1], pData[0] );
pData += 2;
attr = *pData++; // Security suite
ret = (byte) ZDP_ServerDiscReq( uAttr, attr );
break;
#endif
#if defined (ZDO_NETWORKSTART_REQUEST )
case SPI_CMD_ZDO_NETWORK_START_REQ:
ret = ZDApp_StartUpFromApp( ZDAPP_STARTUP_AUTO );
break;
#endif
default:
break;
}
MT_SendSPIRespMsg( ret, cmd_id, len, respLen );
}
