/***************************************************************************************************
* @fn MT_UtilzclGeneral_KeyEstablish_InitiateKeyEstablishment
*
* @brief Proxy the zclGeneral_KeyEstablish_InitiateKeyEstablishment() function.
*
* @param pBuf - pointer to the received buffer
*
* @return void
***************************************************************************************************/
static void MT_UtilzclGeneral_KeyEstablish_InitiateKeyEstablishment(uint8 *pBuf)
{
afAddrType_t partnerAddr;
uint8 cmdId = pBuf[MT_RPC_POS_CMD1];
pBuf += MT_RPC_FRAME_HDR_SZ;
partnerAddr.panId = 0; // Not an inter-pan message.
partnerAddr.endPoint = pBuf[2];
partnerAddr.addrMode = (afAddrMode_t)pBuf[3];
if (afAddr64Bit == partnerAddr.addrMode)
{
(void)osal_memcpy(partnerAddr.addr.extAddr, pBuf+4, Z_EXTADDR_LEN);
}
else
{
partnerAddr.addr.shortAddr = BUILD_UINT16(pBuf[4], pBuf[5]);
}
zcl_key_establish_task_id = pBuf[0];
*pBuf = zclGeneral_KeyEstablish_InitiateKeyEstablishment(MT_TaskID, &partnerAddr, pBuf[1]);
MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_UTIL), cmdId, 1, pBuf);
}
/*********************************************************************
* @fn loadcontrol_event_loop
*
* @brief Event Loop Processor for loadcontrol.
*
* @param uint8 task id - load control task id
* @param uint16 events - event bitmask
*
* @return none
*/
uint16 loadcontrol_event_loop( uint8 task_id, uint16 events )
{
afIncomingMSGPacket_t *MSGpkt;
if ( events & SYS_EVENT_MSG )
{
while ( (MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( loadControlTaskID )) )
{
switch ( MSGpkt->hdr.event )
{
case ZCL_INCOMING_MSG:
// Incoming ZCL foundation command/response messages
loadcontrol_ProcessZCLMsg( (zclIncomingMsg_t *)MSGpkt );
break;
case KEY_CHANGE:
loadcontrol_HandleKeys( ((keyChange_t *)MSGpkt)->state, ((keyChange_t *)MSGpkt)->keys );
break;
case ZDO_STATE_CHANGE:
if (DEV_ROUTER == (devStates_t)(MSGpkt->hdr.status))
{
#if SECURE
{
// check to see if link key had already been established
linkKeyStatus = loadcontrol_KeyEstablish_ReturnLinkKey(ESPAddr.addr.shortAddr);
if (linkKeyStatus != ZSuccess)
{
// send out key establishment request
osal_set_event( loadControlTaskID, LOADCONTROL_KEY_ESTABLISHMENT_REQUEST_EVT);
}
}
#endif
}
break;
default:
break;
}
// Release the memory
osal_msg_deallocate( (uint8 *)MSGpkt );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
// event to intiate key establishment request
if ( events & LOADCONTROL_KEY_ESTABLISHMENT_REQUEST_EVT )
{
zclGeneral_KeyEstablish_InitiateKeyEstablishment(loadControlTaskID, &ESPAddr, loadControlTransID);
return ( events ^ LOADCONTROL_KEY_ESTABLISHMENT_REQUEST_EVT );
}
// handle processing of identify timeout event triggered by an identify command
if ( events & LOADCONTROL_IDENTIFY_TIMEOUT_EVT )
{
if ( loadControlIdentifyTime > 0 )
{
loadControlIdentifyTime--;
}
loadcontrol_ProcessIdentifyTimeChange();
return ( events ^ LOADCONTROL_IDENTIFY_TIMEOUT_EVT );
}
// event to get current time
if ( events & LOADCONTROL_UPDATE_TIME_EVT )
{
loadControlTime = osal_getClock();
osal_start_timerEx( loadControlTaskID, LOADCONTROL_UPDATE_TIME_EVT, LOADCONTROL_UPDATE_TIME_PERIOD );
return ( events ^ LOADCONTROL_UPDATE_TIME_EVT );
}
// event to handle load control complete event
if ( events & LOADCONTROL_LOAD_CTRL_EVT )
{
// load control evt completed
// Send response back
// DisableDefaultResponse is set to false - it is recommended to turn on
// default response since Report Event Status Command does not have
// a response.
rsp.eventStatus = EVENT_STATUS_LOAD_CONTROL_EVENT_COMPLETED;
zclSE_LoadControl_Send_ReportEventStatus( LOADCONTROL_ENDPOINT, &ESPAddr,
&rsp, false, loadControlTransID );
HalLcdWriteString("Load Evt Complete", HAL_LCD_LINE_3);
HalLedSet(HAL_LED_4, HAL_LED_MODE_OFF);
return ( events ^ LOADCONTROL_LOAD_CTRL_EVT );
}
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn rangeext_event_loop
*
* @brief Event Loop Processor for rangeext.
*
* @param uint8 task_id - the osal task id
* @param uint16 events - the event bitmask
*
* @return none
*/
uint16 rangeext_event_loop( uint8 task_id, uint16 events )
{
afIncomingMSGPacket_t *MSGpkt;
if ( events & SYS_EVENT_MSG )
{
while ( (MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( rangeExtTaskID )) )
{
switch ( MSGpkt->hdr.event )
{
case ZDO_CB_MSG:
rangeext_ProcessZDOMsgs( (zdoIncomingMsg_t *)MSGpkt );
break;
case ZCL_INCOMING_MSG:
// Incoming ZCL foundation command/response messages
rangeext_ProcessZCLMsg( (zclIncomingMsg_t *)MSGpkt );
break;
case KEY_CHANGE:
rangeext_HandleKeys( ((keyChange_t *)MSGpkt)->state, ((keyChange_t *)MSGpkt)->keys );
break;
case ZDO_STATE_CHANGE:
if (DEV_ROUTER == (devStates_t)(MSGpkt->hdr.status))
{
#if SECURE
{
// check to see if link key had already been established
linkKeyStatus = rangeext_KeyEstablish_ReturnLinkKey(ESPAddr.addr.shortAddr);
if (linkKeyStatus != ZSuccess)
{
cId_t cbkeCluster = ZCL_CLUSTER_ID_GEN_KEY_ESTABLISHMENT;
zAddrType_t dstAddr;
// Send out a match for the key establishment
dstAddr.addrMode = AddrBroadcast;
dstAddr.addr.shortAddr = NWK_BROADCAST_SHORTADDR;
ZDP_MatchDescReq( &dstAddr, NWK_BROADCAST_SHORTADDR, ZCL_SE_PROFILE_ID,
1, &cbkeCluster, 0, NULL, FALSE );
}
}
#endif
}
break;
#if defined( ZCL_KEY_ESTABLISH )
case ZCL_KEY_ESTABLISH_IND:
if ((MSGpkt->hdr.status) == TermKeyStatus_Success)
{
ESPAddr.endPoint = RANGEEXT_ENDPOINT; // set destination endpoint back to application endpoint
}
break;
#endif
default:
break;
}
// Release the memory
osal_msg_deallocate( (uint8 *)MSGpkt );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
// event to intiate key establishment request
if ( events & RANGEEXT_KEY_ESTABLISHMENT_REQUEST_EVT )
{
zclGeneral_KeyEstablish_InitiateKeyEstablishment(rangeExtTaskID, &ESPAddr, rangeExtTransID);
return ( events ^ RANGEEXT_KEY_ESTABLISHMENT_REQUEST_EVT );
}
// handle processing of identify timeout event triggered by an identify command
if ( events & RANGEEXT_IDENTIFY_TIMEOUT_EVT )
{
if ( rangeExtIdentifyTime > 0 )
{
rangeExtIdentifyTime--;
}
rangeext_ProcessIdentifyTimeChange();
return ( events ^ RANGEEXT_IDENTIFY_TIMEOUT_EVT );
}
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn loadcontrol_event_loop
*
* @brief Event Loop Processor for loadcontrol.
*
* @param uint8 task id - load control task id
* @param uint16 events - event bitmask
*
* @return none
*/
uint16 loadcontrol_event_loop( uint8 task_id, uint16 events )
{
afIncomingMSGPacket_t *MSGpkt;
if ( events & SYS_EVENT_MSG )
{
while ( (MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( loadControlTaskID )) )
{
switch ( MSGpkt->hdr.event )
{
case ZDO_CB_MSG:
loadcontrol_ProcessZDOMsgs( (zdoIncomingMsg_t *)MSGpkt );
break;
case ZCL_INCOMING_MSG:
// Incoming ZCL foundation command/response messages
loadcontrol_ProcessZCLMsg( (zclIncomingMsg_t *)MSGpkt );
break;
case KEY_CHANGE:
loadcontrol_HandleKeys( ((keyChange_t *)MSGpkt)->state, ((keyChange_t *)MSGpkt)->keys );
break;
case ZDO_STATE_CHANGE:
if (DEV_ROUTER == (devStates_t)(MSGpkt->hdr.status))
{
#if SECURE
{
// check to see if link key had already been established
linkKeyStatus = loadcontrol_KeyEstablish_ReturnLinkKey(ESPAddr.addr.shortAddr);
if (linkKeyStatus != ZSuccess)
{
cId_t cbkeCluster = ZCL_CLUSTER_ID_GEN_KEY_ESTABLISHMENT;
zAddrType_t dstAddr;
// Send out a match for the key establishment
dstAddr.addrMode = AddrBroadcast;
dstAddr.addr.shortAddr = NWK_BROADCAST_SHORTADDR;
ZDP_MatchDescReq( &dstAddr, NWK_BROADCAST_SHORTADDR, ZCL_SE_PROFILE_ID,
1, &cbkeCluster, 0, NULL, FALSE );
}
}
#endif
}
break;
#if defined( ZCL_KEY_ESTABLISH )
case ZCL_KEY_ESTABLISH_IND:
if ((MSGpkt->hdr.status) == TermKeyStatus_Success)
{
ESPAddr.endPoint = LOADCONTROL_ENDPOINT; // set destination endpoint back to application endpoint
}
break;
#endif
default:
break;
}
// Release the memory
osal_msg_deallocate( (uint8 *)MSGpkt );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
// event to intiate key establishment request
if ( events & LOADCONTROL_KEY_ESTABLISHMENT_REQUEST_EVT )
{
zclGeneral_KeyEstablish_InitiateKeyEstablishment(loadControlTaskID, &ESPAddr, loadControlTransID);
return ( events ^ LOADCONTROL_KEY_ESTABLISHMENT_REQUEST_EVT );
}
// handle processing of identify timeout event triggered by an identify command
if ( events & LOADCONTROL_IDENTIFY_TIMEOUT_EVT )
{
if ( loadControlIdentifyTime > 0 )
{
loadControlIdentifyTime--;
}
loadcontrol_ProcessIdentifyTimeChange();
return ( events ^ LOADCONTROL_IDENTIFY_TIMEOUT_EVT );
}
// event to get current time
if ( events & LOADCONTROL_UPDATE_TIME_EVT )
{
loadControlTime = osal_getClock();
osal_start_timerEx( loadControlTaskID, LOADCONTROL_UPDATE_TIME_EVT, LOADCONTROL_UPDATE_TIME_PERIOD );
return ( events ^ LOADCONTROL_UPDATE_TIME_EVT );
}
// event to handle load control complete event
if ( events & LOADCONTROL_LOAD_CTRL_EVT )
{
// load control evt completed
// Send response back
// DisableDefaultResponse is set to FALSE - it is recommended to turn on
// default response since Report Event Status Command does not have
// a response.
rsp.eventStatus = EVENT_STATUS_LOAD_CONTROL_EVENT_COMPLETED;
zclSE_LoadControl_Send_ReportEventStatus( LOADCONTROL_ENDPOINT, &ESPAddr,
&rsp, FALSE, loadControlTransID );
HalLcdWriteString("Load Evt Complete", HAL_LCD_LINE_3);
HalLedSet(HAL_LED_4, HAL_LED_MODE_OFF);
return ( events ^ LOADCONTROL_LOAD_CTRL_EVT );
}
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn ipd_event_loop
*
* @brief Event Loop Processor for ipd.
*
* @param uint8 task_id - ipd task id
* @param uint16 events - event bitmask
*
* @return none
*/
uint16 ipd_event_loop( uint8 task_id, uint16 events )
{
afIncomingMSGPacket_t *MSGpkt;
if ( events & SYS_EVENT_MSG )
{
while ( (MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( ipdTaskID )) )
{
switch ( MSGpkt->hdr.event )
{
case ZCL_INCOMING_MSG:
// Incoming ZCL foundation command/response messages
ipd_ProcessZCLMsg( (zclIncomingMsg_t *)MSGpkt );
break;
case KEY_CHANGE:
ipd_HandleKeys( ((keyChange_t *)MSGpkt)->state, ((keyChange_t *)MSGpkt)->keys );
break;
case ZDO_STATE_CHANGE:
if (DEV_END_DEVICE == (devStates_t)(MSGpkt->hdr.status))
{
#if SECURE
{
// check to see if link key had already been established
linkKeyStatus = ipd_KeyEstablish_ReturnLinkKey(ESPAddr.addr.shortAddr);
if (linkKeyStatus != ZSuccess)
{
// send out key establishment request
osal_set_event( ipdTaskID, IPD_KEY_ESTABLISHMENT_REQUEST_EVT);
}
else
{
// link key already established, resume sending reports
osal_start_timerEx( ipdTaskID, IPD_GET_PRICING_INFO_EVT, IPD_GET_PRICING_INFO_PERIOD );
}
}
#else
{
osal_start_timerEx( ipdTaskID, IPD_GET_PRICING_INFO_EVT, IPD_GET_PRICING_INFO_PERIOD );
}
#endif
// Per smart energy spec end device polling requirement of not to poll < 7.5 seconds.
NLME_SetPollRate ( SE_DEVICE_POLL_RATE );
}
break;
#if defined( ZCL_KEY_ESTABLISH )
case ZCL_KEY_ESTABLISH_IND:
if ((MSGpkt->hdr.status) == TermKeyStatus_Success)
{
osal_start_timerEx( ipdTaskID, IPD_GET_PRICING_INFO_EVT, IPD_GET_PRICING_INFO_PERIOD );
}
break;
#endif
default:
break;
}
// Release the memory
osal_msg_deallocate( (uint8 *)MSGpkt );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
// event to intiate key establishment request
if ( events & IPD_KEY_ESTABLISHMENT_REQUEST_EVT )
{
zclGeneral_KeyEstablish_InitiateKeyEstablishment(ipdTaskID, &ESPAddr, ipdTransID);
return ( events ^ IPD_KEY_ESTABLISHMENT_REQUEST_EVT );
}
// event to get current price
if ( events & IPD_GET_PRICING_INFO_EVT )
{
zclSE_Pricing_Send_GetCurrentPrice( IPD_ENDPOINT, &ESPAddr, option, TRUE, 0 );
osal_start_timerEx( ipdTaskID, IPD_GET_PRICING_INFO_EVT, IPD_GET_PRICING_INFO_PERIOD );
return ( events ^ IPD_GET_PRICING_INFO_EVT );
}
// handle processing of identify timeout event triggered by an identify command
if ( events & IPD_IDENTIFY_TIMEOUT_EVT )
{
if ( ipdIdentifyTime > 0 )
{
ipdIdentifyTime--;
}
ipd_ProcessIdentifyTimeChange();
return ( events ^ IPD_IDENTIFY_TIMEOUT_EVT );
}
// event to get current time
if ( events & IPD_UPDATE_TIME_EVT )
{
ipdTime = osal_getClock();
osal_start_timerEx( ipdTaskID, IPD_UPDATE_TIME_EVT, IPD_UPDATE_TIME_PERIOD );
return ( events ^ IPD_UPDATE_TIME_EVT );
}
// Discard unknown events
return 0;
}