/**
* @brief Maneja los eventos de teclas, generados cuando ocurre un pulsación
* en el joystick de la placa.
* @param shift true si shift/alt está presionado.
* @param keys Mascara de bits para los eventos de teclado. Válidos:
* EVAL_SW4, EVAL_SW3, EVAL_SW2, EVAL_SW1.
*/
void zb_HandleKeys(uint8 shift, uint8 keys)
{
static uint8 allowJoin = TRUE;
uint8 logicalType;
if (keys & HAL_KEY_CENTER)
{
if (appState == APP_INIT)
{
// configura el dispositivo como coordinador
logicalType = ZG_DEVICETYPE_COORDINATOR;
zb_WriteConfiguration(ZCD_NV_LOGICAL_TYPE, sizeof(uint8), &logicalType);
zb_SystemReset();
}
}
if (keys & HAL_KEY_UP)
{
// configura condición de máxima carga (I RMS) en pasos de 0.1 A, hasta 2 A
if (alarm_max_irms > 2)
alarm_max_irms = 0.1;
else
alarm_max_irms += 0.1;
HalLcdWriteString("MAX I RMS (mA)", HAL_LCD_LINE_1);
HalLcdWriteStringValue("", (int)(alarm_max_irms*1000), 10, 2);
}
if (keys & HAL_KEY_DOWN) // joystick abajo
{
// configura condicion de máximo consumo (E) en pasos de 50 Ws, hasta 400 Ws
if (alarm_max_energy > 400)
alarm_max_energy = 50;
else
alarm_max_energy += 50;
HalLcdWriteString("MAX ENERGIA (Ws)", HAL_LCD_LINE_1);
HalLcdWriteStringValue("", alarm_max_energy, 10, 2);
}
if (keys & HAL_KEY_RIGHT) // joystick derecha
{
// inicia evento para pruebas
msgReport.sequence = 0;
osal_start_timerEx(sapi_TaskID, MY_TEST_EVT, 5000);
}
if (keys & HAL_KEY_LEFT) // joystick izquierda
{
// controla si el dispositivo acepta join requests
// refleja este estado en el LED 3
allowJoin ^= 1;
if (allowJoin)
{
NLME_PermitJoiningRequest(0xFF);
HalLedSet(HAL_LED_3, HAL_LED_MODE_ON);
}
else
{
NLME_PermitJoiningRequest(0);
HalLedSet(HAL_LED_3, HAL_LED_MODE_OFF);
}
}
}
/***************************************************************************************************
* @fn MT_NlmePermitJoiningRequest
*
* @brief Permit Joining Request
*
* @param pBuf - pointer to the received buffer
*
* @return void
***************************************************************************************************/
void MT_NlmePermitJoiningRequest(uint8 *pBuf)
{
uint8 retValue = ZFailure;
uint8 cmdId;
/* parse header */
cmdId = pBuf[MT_RPC_POS_CMD1];
pBuf += MT_RPC_FRAME_HDR_SZ;
if (ZSTACK_ROUTER_BUILD)
{
retValue = NLME_PermitJoiningRequest(*pBuf);
}
else
{
retValue = ZUnsupportedMode;
}
/* Build and send back the response */
MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_NWK), cmdId, 1, &retValue);
}
/*********************************************************************
* @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 zcl_EZModeAction
*
* @brief Called when the application needs to inform EZ-Mode of some action
* (now on the network, identify mode query, etc...)
*
* @param action - which action has taken place
* pData - the data unique to the action
*
* @return none
*/
void zcl_EZModeAction(zclEzMode_Action_t action, zclEZMode_ActionData_t *pData)
{
ZDO_MatchDescRsp_t *pMatchDescRsp;
zAddrType_t dstAddr;
// not in the EZ-Mode state machine, so do nothing
if( zclEZModeState == EZMODE_STATE_READY )
return;
switch ( action )
{
case EZMODE_ACTION_PROCESS:
zcl_ProcessEZMode(); // process next state
break;
case EZMODE_ACTION_NETWORK_STARTED:
// once on the network, time to go on to the identify state
if( zclEZModeState == EZMODE_STATE_JOINER )
{
// set local permit joining on locally only for joiners (openers turn it on across the network)
NLME_PermitJoiningRequest( (byte)(EZMODE_TIME / 1000) ); // in seconds
zcl_SetEZModeState( EZMODE_STATE_IDENTIFYING );
}
break;
// received identify query
case EZMODE_ACTION_IDENTIFY_QUERY:
// targets just go to autoclose once they have been identified
if ( !zclEZModeInvokeData.initiator )
{
zcl_SetEZModeState( EZMODE_STATE_AUTOCLOSE );
}
break;
// received identify query response
case EZMODE_ACTION_IDENTIFY_QUERY_RSP:
// remember the node we found via identify query
zclEZModeQueryRspNwkAddr = pData->pIdentifyQueryRsp->srcAddr->addr.shortAddr;
zclEZModeQueryRspEP = pData->pIdentifyQueryRsp->srcAddr->endPoint;
// initiate match descriptor request on the remote node
dstAddr.addrMode = Addr16Bit;
dstAddr.addr.shortAddr = zclEZModeQueryRspNwkAddr;
ZDP_MatchDescReq( &dstAddr, zclEZModeQueryRspNwkAddr,
ZCL_HA_PROFILE_ID,
zclEZModeInvokeData.numActiveOutClusters, zclEZModeInvokeData.pActiveOutClusterIDs,
zclEZModeInvokeData.numActiveInClusters, zclEZModeInvokeData.pActiveInClusterIDs,
FALSE );
zcl_SetEZModeState( EZMODE_STATE_WAITING_MATCHDESCRSP );
break;
// received match descriptor response, see if active clusters match
case EZMODE_ACTION_MATCH_DESC_RSP:
pMatchDescRsp = pData->pMatchDescRsp;
if ( ( pMatchDescRsp && pMatchDescRsp->status == ZSuccess ) && ( pMatchDescRsp->cnt>0 ) )
{
zclEZModeMatched = TRUE;
// BindingEntry_t *bindAddEntry( byte srcEpInt, zAddrType_t *dstAddr, byte dstEpInt, byte numClusterIds, uint16 *clusterIds )
dstAddr.addr.shortAddr = zclEZModeQueryRspNwkAddr;
dstAddr.addrMode = Addr16Bit;
// bind each matching input cluster
if ( zclEZModeInvokeData.numActiveInClusters )
{
bindAddEntry( zclEZModeInvokeData.endpoint, &dstAddr, zclEZModeQueryRspEP,
zclEZModeInvokeData.numActiveInClusters, zclEZModeInvokeData.pActiveInClusterIDs );
}
// bind each matching output cluster
if ( zclEZModeInvokeData.numActiveOutClusters )
{
bindAddEntry( zclEZModeInvokeData.endpoint, &dstAddr, zclEZModeQueryRspEP,
zclEZModeInvokeData.numActiveOutClusters, zclEZModeInvokeData.pActiveOutClusterIDs );
}
}
// time to close (wait a bit before finishing, to allow for multiple initiators)
zcl_SetEZModeState( EZMODE_STATE_AUTOCLOSE );
break;
// timed out of EZ-Mode
case EZMODE_ACTION_TIMED_OUT:
// timed out
if(zclEZModeState != EZMODE_STATE_READY)
{
zcl_SetEZModeError( EZMODE_ERR_TIMEDOUT );
zcl_SetEZModeState( EZMODE_STATE_FINISH );
}
break;
} // switch ( action )
}
/***************************************************************************************************
* @fn MT_AppMsg
*
* @brief Process APP_MSG command
*
* @param pBuf - pointer to the received buffer
*
* @return void
***************************************************************************************************/
static void MT_AppUserCmd(uint8 *pBuf)
{
uint8 retValue, cmdId;
#if defined (APP_TGEN) || defined (NWK_TEST) || defined (APP_TP) || defined (APP_TP2) || defined (OSAL_TOTAL_MEM) || defined (APP_DEBUG)
uint16 app_cmd;
uint8 srcEp;
uint16 param1;
uint16 param2;
#endif
#if defined (OSAL_TOTAL_MEM)
uint8 pData[2];
#endif
/* parse header */
cmdId = pBuf[MT_RPC_POS_CMD1];
pBuf += MT_RPC_FRAME_HDR_SZ;
retValue = INVALID_TASK; //should be changed later
#if defined (APP_TGEN) || defined (NWK_TEST) || defined (APP_TP) || defined (APP_TP2) || defined (OSAL_TOTAL_MEM) || defined (APP_DEBUG)
srcEp = *pBuf++;
app_cmd = osal_build_uint16( pBuf );
pBuf = pBuf + sizeof( uint16 );
param1 = osal_build_uint16( pBuf );
pBuf = pBuf + sizeof( uint16 );
param2 = osal_build_uint16( pBuf );
switch ( app_cmd )
{
#if defined (APP_TGEN)
case TGEN_START:
TrafficGenApp_SendCmdMSG( param1, param2, TRAFFICGENAPP_CMD_START );
retValue = ZSUCCESS;
break;
case TGEN_STOP:
TrafficGenApp_SendCmdMSG( param1, param2, TRAFFICGENAPP_CMD_STOP );
retValue = ZSUCCESS;
break;
case TGEN_COUNT:
retValue = TrafficGenApp_CountPkt( param1, param2 );
return;
break;
#endif
#if defined (NWK_TEST)
case HW_TEST:
HwApp_Start( HI_UINT16(param1), LO_UINT16(param1), HI_UINT16(param2),
1000, LO_UINT16(param2), 3, 0 );
break;
case HW_DISPLAY_RESULT:
HwApp_TestInfo();
break;
case HW_SEND_STATUS:
HwApp_SendStats();
break;
#endif
#if defined( APP_TP ) || defined ( APP_TP2 )
#if defined( APP_TP )
case TP_SEND_NODATA:
retValue = TestProfileApp_SendNoData( srcEp, (byte)param1 );
break;
#endif // APP_TP
case TP_SEND_BUFFERTEST:
retValue = TestProfileApp_SendBufferReq( srcEp, (uint8)param1, (uint8)param2 );
break;
#if defined( APP_TP )
case TP_SEND_UINT8:
retValue = TestProfileApp_SendUint8( srcEp, (byte)param1 );
break;
case TP_SEND_INT8:
retValue = TestProfileApp_SendInt8( srcEp, (byte)param1 );
break;
case TP_SEND_UINT16:
retValue = TestProfileApp_SendUint16( srcEp, (byte)param1 );
break;
case TP_SEND_INT16:
retValue = TestProfileApp_SendInt16( srcEp, (byte)param1 );
break;
case TP_SEND_SEMIPREC:
retValue = TestProfileApp_SendSemiPrec( srcEp, (byte)param1 );
break;
case TP_SEND_FREEFORM:
retValue = TestProfileApp_SendFreeFormReq( srcEp, (byte)param1 );
break;
#else // APP_TP
case TP_SEND_FREEFORM:
retValue = TestProfileApp_SendFreeFormReq(srcEp, (byte)param1, (byte)param2);
break;
#endif
#if defined( APP_TP )
case TP_SEND_ABS_TIME:
retValue = TestProfileApp_SendAbsTime( srcEp, (byte)param1 );
break;
case TP_SEND_REL_TIME:
retValue = TestProfileApp_SendRelativeTime( srcEp, (byte)param1 );
break;
case TP_SEND_CHAR_STRING:
retValue = TestProfileApp_SendCharString( srcEp, (byte)param1 );
break;
case TP_SEND_OCTET_STRING:
retValue = TestProfileApp_SendOctetString( srcEp, (byte)param1 );
break;
#endif // APP_TP
case TP_SET_DSTADDRESS:
retValue = TestProfileApp_SetDestAddress(HI_UINT16(param1), LO_UINT16(param1), param2);
break;
#if defined( APP_TP2 )
case TP_SEND_BUFFER_GROUP:
retValue = TestProfileApp_SendBufferGroup( srcEp, (byte)param1 );
break;
#endif // APP_TP
case TP_SEND_BUFFER:
retValue = TestProfileApp_SendBuffer( srcEp, (byte)param1 );
break;
#if defined( APP_TP )
case TP_SEND_MULT_KVP_8BIT:
TestProfileApp_SendMultiKVP_8bit( srcEp, (byte)param1 );
retValue = ZSuccess;
break;
case TP_SEND_MULT_KVP_16BIT:
TestProfileApp_SendMultiKVP_16bit( srcEp, (byte)param1 );
retValue = ZSuccess;
break;
case TP_SEND_MULT_KVP_TIME:
TestProfileApp_SendMultiKVP_Time( srcEp, (byte)param1 );
retValue = ZSuccess;
break;
case TP_SEND_MULT_KVP_STRING:
TestProfileApp_SendMultiKVP_String( srcEp, (byte)param1 );
retValue = ZSuccess;
break;
case TP_SEND_MULTI_KVP_STR_TIME:
retValue = ZSuccess;
TestProfileApp_SendMultiKVP_String_Time( srcEp, (byte)param1 );
break;
#endif // APP_TP
case TP_SEND_COUNTED_PKTS:
TestProfileApp_SendCountedPktsReq(HI_UINT16(param1), LO_UINT16(param1), param2);
retValue = ZSuccess;
break;
case TP_SEND_RESET_COUNTER:
TestProfileApp_CountedPakts_ResetCounterReq( (byte)param1 );
retValue = ZSuccess;
break;
case TP_SEND_GET_COUNTER:
TestProfileApp_CountedPakts_GetCounterReq( srcEp, (byte)param1 );
retValue = ZSuccess;
break;
case TP_SET_PERMIT_JOIN:
if ( ZG_BUILD_RTR_TYPE && ZG_DEVICE_RTR_TYPE )
{
NLME_PermitJoiningRequest( (byte)param1 );
retValue = ZSuccess;
}
else
{
retValue = ZFailure;
}
break;
#if defined ( APP_TP2 )
case TP_ADD_GROUP:
retValue = TestProfileApp_SetGroup( srcEp, param1 );
break;
case TP_REMOVE_GROUP:
retValue = TestProfileApp_RemoveGroup( srcEp, param1 );
break;
case TP_SEND_UPDATE_KEY:
retValue = TestProfileApp_UpdateKey( srcEp, (uint8)param1, param2 );
break;
case TP_SEND_SWITCH_KEY:
retValue = TestProfileApp_SwitchKey( srcEp, (uint8)param1, param2 );
break;
case TP_SEND_BUFFERTEST_GROUP:
retValue = TestProfileApp_SendBufferGroupReq( srcEp, (byte)param1, (byte)param2 );
break;
case TP_SEND_ROUTE_DISC_REQ:
retValue = TestProfileApp_SendRouteDiscReq( srcEp, param1,
HI_UINT16( param2 ), LO_UINT16( param2 ) );
break;
case TP_SEND_ROUTE_DISCOVERY:
if ( ZG_BUILD_RTR_TYPE && ZG_DEVICE_RTR_TYPE )
{
retValue = TestProfileApp_SendRouteDiscovery( param1,
HI_UINT16( param2 ), LO_UINT16( param2 ) );
}
break;
case TP_SEND_NEW_ADDR:
retValue = TestProfileApp_ChangeShortAddr( param1, LO_UINT16(param2) );
break;
case TP_SEND_NWK_UPDATE:
/* Send out a Network Update command. */
retValue = NLME_SendNetworkUpdate( NWK_BROADCAST_SHORTADDR, NWKUPDATE_PANID_UPDATE,
_NIB.extendedPANID, _NIB.nwkUpdateId+1, param1 );
break;
case TP_NWK_ADDR_CONFLICT:
retValue = NLME_SendNetworkStatus( NWK_BROADCAST_SHORTADDR_DEVZCZR, param1,
NWKSTAT_ADDRESS_CONFLICT, FALSE );
break;
#if (ZG_BUILD_JOINING_TYPE)
case TP_AK_SETUP_PARTNER:
retValue = TestProfileApp_AppKeySetupPartner( srcEp, param1, param2 );
break;
case TP_AK_REQ_KEY:
retValue = TestProfileApp_AppKeyRequest( srcEp, param1, param2 );
break;
case TP_AK_PARTNER_NWKADDR:
retValue = TestProfileApp_SetPartnerNwkAddr( srcEp, param1, param2 );
break;
case TP_AK_PARTNER_EXTADDR7654:
retValue = TestProfileApp_SetPartnerExtAddr7654( srcEp, param1, param2 );
break;
case TP_AK_PARTNER_EXTADDR3210:
retValue = TestProfileApp_SetPartnerExtAddr3210( srcEp, param1, param2 );
break;
case TP_AK_PARTNER_SET:
retValue = TestProfileApp_SetPartner( srcEp, param1, param2 );
break;
#endif /* ZG_BUILD_JOINING_TYPE */
#if (ZG_BUILD_COORDINATOR_TYPE)
case TP_AK_TYPE_SET:
retValue = TestProfileApp_AppKeyTypeSet( srcEp, param1, param2 );
break;
#endif /* ZG_BUILD_COORDINATOR_TYPE */
#if defined ( ZIGBEE_FRAGMENTATION )
case TP_FRAG_SKIP_BLOCK:
retValue = TestProfileApp_FragSkipBlock( (uint8)param1 );
break;
#endif
case TP_APS_REMOVE:
retValue = TestProfileApp_APSRemove( param1, param2 );
break;
#if defined ( APP_TP2_TEST_MODE )
case TP_GU_SET_TX_APS_SEC:
retValue = TestProfileApp_GuSetTxApsSecurity( LO_UINT16(param1), param2 );
break;
case TP_GU_SET_RX_APS_SEC:
retValue = TestProfileApp_GuSetRxApsSecurity( LO_UINT16(param1), param2 );
break;
#endif
case TP_SET_LEAVE_REQ_ALLOWED:
retValue = TestProfileApp_SetLeaveReqAllowed( LO_UINT16(param1) );
break;
case TP_SEND_REJOIN_REQ_SECURE:
retValue = TestProfileApp_SendRejoinReqSecurity( param1, param2 );
break;
#endif // APP_TP2
#endif // APP_TP || APP_TP2
#if defined ( OSAL_TOTAL_MEM )
case OSAL_MEM_STACK_HIGH_WATER:
case OSAL_MEM_HEAP_HIGH_WATER:
if ( app_cmd == OSAL_MEM_STACK_HIGH_WATER)
{
param1 = osal_stack_used();
}
else
{
param1 = osal_heap_high_water();
}
pData[0] = LO_UINT16( param1 );
pData[1] = HI_UINT16( param1 );
MT_BuildAndSendZToolResponse((MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_APP), cmdId, 2, pData);
return;
#endif
#if defined ( APP_DEBUG )
case DEBUG_GET:
DebugApp_SendQuery( param1 );
retValue = ZSUCCESS;
break;
#endif
#if defined ( APP_TP2 )
case TP_SEND_BCAST_RSP:
retValue = TestProfileApp_SendBcastRsp( srcEp, (byte)param1 );
break;
#endif
default:
break;
}
#endif // (APP_TGEN) || (NWK_TEST) || (APP_TP) || (APP_TP2) || (OSAL_TOTAL_MEM) || (APP_DEBUG)
/* Build and send back the response */
MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_APP), cmdId, 1, &retValue);
}
/*********************************************************************
* @fn zclSampleTemperatureSensor_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_3
* HAL_KEY_SW_2
* HAL_KEY_SW_1
*
* @return none
*/
static void zclSampleTemperatureSensor_HandleKeys( byte shift, byte keys )
{
if ( keys & HAL_KEY_SW_1 )
{
// increase temperature
giTemperatureSensorScreenMode = TEMPSENSE_MAINMODE;
if ( zclSampleTemperatureSensor_MeasuredValue < zclSampleTemperatureSensor_MaxMeasuredValue )
{
zclSampleTemperatureSensor_MeasuredValue = zclSampleTemperatureSensor_MeasuredValue + 100; // considering using whole number value
}
else if ( zclSampleTemperatureSensor_MeasuredValue >= zclSampleTemperatureSensor_MaxMeasuredValue )
{
zclSampleTemperatureSensor_MeasuredValue = zclSampleTemperatureSensor_MaxMeasuredValue;
}
// Send temperature information
zclSampleTemperatureSensor_SendTemp();
}
if ( keys & HAL_KEY_SW_2 )
{
if ( ( giTemperatureSensorScreenMode == TEMPSENSE_MAINMODE ) ||
( giTemperatureSensorScreenMode == TEMPSENSE_HELPMODE ) )
{
giTemperatureSensorScreenMode = TEMPSENSE_MAINMODE;
#ifdef ZCL_EZMODE
zclEZMode_InvokeData_t ezModeData;
static uint16 clusterIDs[] = { ZCL_CLUSTER_ID_MS_TEMPERATURE_MEASUREMENT }; // only bind on the Temperature Measurement cluster
// Invoke EZ-Mode
ezModeData.endpoint = SAMPLETEMPERATURESENSOR_ENDPOINT; // endpoint on which to invoke EZ-Mode
if ( ( zclSampleTemperatureSensor_NwkState == DEV_ZB_COORD ) ||
( zclSampleTemperatureSensor_NwkState == DEV_ROUTER ) ||
( zclSampleTemperatureSensor_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; // Temperature Sensor is an initiator
ezModeData.numActiveInClusters = 1;
ezModeData.pActiveInClusterIDs = clusterIDs;
ezModeData.numActiveOutClusters = 0; // active output cluster
ezModeData.pActiveOutClusterIDs = NULL;
zcl_InvokeEZMode( &ezModeData );
#ifdef LCD_SUPPORTED
HalLcdWriteString( "EZMode", HAL_LCD_LINE_2 );
#endif
// NOT ZCL_EZMODE, Use EndDeviceBind
#else
{
zAddrType_t dstAddr;
dstAddr.addrMode = Addr16Bit;
dstAddr.addr.shortAddr = 0; // Coordinator makes the EDB match
// Initiate an End Device Bind Request, this bind request will
// only use a cluster list that is important to binding.
HalLedSet ( HAL_LED_4, HAL_LED_MODE_OFF );
ZDP_EndDeviceBindReq( &dstAddr, NLME_GetShortAddr(),
SAMPLETEMPERATURESENSOR_ENDPOINT,
ZCL_HA_PROFILE_ID,
0, NULL,
ZCLSAMPLETEMPERATURESENSOR_BINDINGLIST, bindingOutClusters,
FALSE );
}
#endif // ZCL_EZMODE
}
}
if ( keys & HAL_KEY_SW_3 )
{
giTemperatureSensorScreenMode = TEMPSENSE_MAINMODE;
// decrease the temperature
if ( zclSampleTemperatureSensor_MeasuredValue > zclSampleTemperatureSensor_MinMeasuredValue )
{
zclSampleTemperatureSensor_MeasuredValue = zclSampleTemperatureSensor_MeasuredValue - 100; // considering using whole number value
}
else if ( zclSampleTemperatureSensor_MeasuredValue >= zclSampleTemperatureSensor_MinMeasuredValue )
{
zclSampleTemperatureSensor_MeasuredValue = zclSampleTemperatureSensor_MinMeasuredValue;
}
// Send temperature information
zclSampleTemperatureSensor_SendTemp();
}
if ( keys & HAL_KEY_SW_4 )
{
giTemperatureSensorScreenMode = TEMPSENSE_MAINMODE;
if ( ( zclSampleTemperatureSensor_NwkState == DEV_ZB_COORD ) ||
( zclSampleTemperatureSensor_NwkState == DEV_ROUTER ) )
{
// toggle permit join
gPermitDuration = gPermitDuration ? 0 : 0xff;
NLME_PermitJoiningRequest( gPermitDuration );
}
}
if ( shift && ( keys & HAL_KEY_SW_5 ) )
{
zclSampleTemperatureSensor_BasicResetCB();
}
else if ( keys & HAL_KEY_SW_5 )
{
if ( giTemperatureSensorScreenMode == TEMPSENSE_MAINMODE )
{
giTemperatureSensorScreenMode = TEMPSENSE_HELPMODE;
}
else if ( giTemperatureSensorScreenMode == TEMPSENSE_HELPMODE )
{
#ifdef LCD_SUPPORTED
HalLcdWriteString( (char *)sClearLine, HAL_LCD_LINE_2 );
#endif
giTemperatureSensorScreenMode = TEMPSENSE_MAINMODE;
}
}
// update display
zclSampleTemperatureSensor_LcdDisplayUpdate();
}
/******************************************************************************
* @fn zb_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:
* EVAL_SW4
* EVAL_SW3
* EVAL_SW2
* EVAL_SW1
*
* @return none
*/
void zb_HandleKeys( uint8 shift, uint8 keys )
{
static uint8 allowBind=FALSE;
static uint8 allowJoin=TRUE;
uint8 logicalType;
// Shift is used to make each button/switch dual purpose.
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 ( appState == APP_INIT )
{
// Key 1 starts device as a coordinator
logicalType = ZG_DEVICETYPE_COORDINATOR;
zb_WriteConfiguration(ZCD_NV_LOGICAL_TYPE, sizeof(uint8), &logicalType);
// Reset the device with new configuration
zb_SystemReset();
}
}
if ( keys & HAL_KEY_SW_2 )
{
allowBind ^= 1;
if (allowBind)
{
// Turn ON Allow Bind mode infinitly
zb_AllowBind( 0xFF );
HalLedSet( HAL_LED_2, HAL_LED_MODE_ON );
//This node is the gateway node
isGateWay = TRUE;
// Update the display
#if defined ( LCD_SUPPORTED )
HalLcdWriteString( "Gateway Mode", HAL_LCD_LINE_2 );
#endif
}
else
{
// Turn OFF Allow Bind mode infinitly
zb_AllowBind( 0x00 );
HalLedSet( HAL_LED_2, HAL_LED_MODE_OFF );
isGateWay = FALSE;
// Update the display
#if defined ( LCD_SUPPORTED )
HalLcdWriteString( "Collector", HAL_LCD_LINE_2 );
#endif
}
}
if ( keys & HAL_KEY_SW_3 )
{
// Start reporting
osal_set_event( sapi_TaskID, MY_REPORT_EVT );
}
if ( keys & HAL_KEY_SW_4 )
{
// Key 4 is used to control which routers
// that can accept join requests
allowJoin ^= 1;
if(allowJoin)
{
NLME_PermitJoiningRequest(0xFF);
}
else {
NLME_PermitJoiningRequest(0);
}
}
#if 0
if( keys & HAL_KEY_SW_6 )
{
if( onoff )
{
st( P0_5 = !1; );
onoff = 0;
}
else
{
st(P0_5 = !!1; );
onoff = 1;
}
/*********************************************************************
* @fn MT_NwkCommandProcessing
*
* @brief
*
* Process all the NWK 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_NwkCommandProcessing( uint16 cmd_id , byte len , byte *pData )
{
byte ret;
#if defined ( MT_NWK_FUNC )
uint8 dummyExPANID[Z_EXTADDR_LEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
uint16 dstAddr;
#endif
#if defined ( MT_NWK_FUNC ) //NWK commands
byte attr;
byte index;
byte dataLen;
byte *dataPtr;
uint32 channelList;
byte databuf[SPI_RESP_LEN_NWK_DEFAULT + NWK_DEFAULT_GET_RESPONSE_LEN];
#if defined( ZDO_COORDINATOR )
uint16 panId;
#else
byte i,j;
#endif
#endif // MT_NWK_FUNC
len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_NWK_DEFAULT;
ret = (byte)ZSuccess;
switch (cmd_id)
{
#if defined( RTR_NWK )
case SPI_CMD_NLME_PERMIT_JOINING_REQ:
//The only information is PermitDuration
ret = (byte)NLME_PermitJoiningRequest( *pData );
break;
#endif
#if defined ( MT_NWK_FUNC ) //NWK commands
case SPI_CMD_NWK_INIT:
nwk_init( NWK_TaskID );
break;
case SPI_CMD_NLDE_DATA_REQ:
//First read the DstAddr
dstAddr = BUILD_UINT16( pData[1], pData[0] );
pData += sizeof( dstAddr );
//Get the NSDU details
dataLen = *pData++;
dataPtr = pData;
/* For now, skip a length of ZTEST_DEFAULT_DATA_LEN, instead of dataLen.
In future ZTOOL releases the data buffer will be only as long as dataLen */
//pData += dataLen;
pData += ZTEST_DEFAULT_DATA_LEN;
/* pData[0] = NSDUHandlde
pData[1] = NSDUHandleOptions
pData[3] = SecurityEnable
pData[4] = DiscoverRoute
pData[5] = RadiusCounter */
ret = (byte)MT_Nwk_DataRequest( dstAddr, dataLen, dataPtr, pData[0],
BUILD_UINT16( pData[2], pData[1] ),
pData[3], pData[4], pData[5]);
break;
#if defined( ZDO_COORDINATOR )
case SPI_CMD_NLME_INIT_COORD_REQ:
panId = BUILD_UINT16( pData[1], pData[0] );
MT_ReverseBytes( &pData[2], 4 );
channelList = osal_build_uint32( &pData[2], 4 );
ret = (byte)NLME_NetworkFormationRequest( panId, channelList, pData[6], pData[7],
pData[8], pData[9] );
break;
#endif // ZDO
#if defined( RTR_NWK )
case SPI_CMD_NLME_START_ROUTER_REQ:
// NOTE: first two parameters are not used, see NLMEDE.h for details
ret = (byte)NLME_StartRouterRequest( pData[0], pData[1], pData[2] );
break;
#endif // RTR
case SPI_CMD_NLME_JOIN_REQ:
ret = (byte)NLME_JoinRequest( dummyExPANID, BUILD_UINT16( pData[1], pData[0] ), pData[2], pData[3] );
if ( pData[3] & CAPINFO_RCVR_ON_IDLE )
{
// The receiver is on, turn network layer polling off.
NLME_SetPollRate( 0 );
NLME_SetQueuedPollRate( 0 );
NLME_SetResponseRate( 0 );
}
break;
case SPI_CMD_NLME_LEAVE_REQ:
{
NLME_LeaveReq_t req;
// if extAddr is all zeros, it means null pointer..
for( index = 0; ( ( index < Z_EXTADDR_LEN ) &&
( pData[index] == 0 ) ) ; index++ );
if ( index == Z_EXTADDR_LEN )
{
req.extAddr = NULL;
}
else
{
MT_ReverseBytes( pData, Z_EXTADDR_LEN );
req.extAddr = pData;
}
pData += Z_EXTADDR_LEN;
req.removeChildren = FALSE;
req.rejoin = FALSE;
req.silent = FALSE;
ret = (byte)NLME_LeaveReq( &req );
}
break;
case SPI_CMD_NLME_RESET_REQ:
//Its a direct call to reset NWK
ret = (byte)NLME_ResetRequest();
break;
case SPI_CMD_NLME_GET_REQ:
attr = *pData++;
index = *pData;
databuf[0] = (byte)NLME_GetRequest( (ZNwkAttributes_t )attr, index, &databuf[1] );
len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_NWK_DEFAULT + NWK_DEFAULT_GET_RESPONSE_LEN;
MT_BuildAndSendZToolResponse( len, (SPI_RESPONSE_BIT | SPI_CMD_NLME_GET_REQ),
(SPI_RESP_LEN_NWK_DEFAULT + NWK_DEFAULT_GET_RESPONSE_LEN), databuf );
return; // Don't return to this function
case SPI_CMD_NLME_SET_REQ:
ret = (byte)NLME_SetRequest( (ZNwkAttributes_t)pData[0], pData[1], &pData[2] );
osal_start_timerEx( ZDAppTaskID, ZDO_NWK_UPDATE_NV, 1000 );
break;
case SPI_CMD_NLME_NWK_DISC_REQ:
MT_ReverseBytes( pData, 4 );
ret = (byte)NLME_NetworkDiscoveryRequest( osal_build_uint32( pData, 4 ), pData[4] );
break;
#if !defined( ZDO_COORDINATOR )
case SPI_CMD_NLME_ORPHAN_JOIN_REQ:
// Channel list bit mask
MT_ReverseBytes( pData, 4 );
channelList = osal_build_uint32( pData, 4 );
// Count number of channels
j = attr = 0;
for ( i = 0; i < ED_SCAN_MAXCHANNELS; i++ )
{
if ( channelList & (1 << i) )
{
j++;
attr = i;
}
}
// If only one channel specified...
if ( j == 1 )
{
_NIB.scanDuration = pData[4];
_NIB.nwkLogicalChannel = attr;
_NIB.channelList = channelList;
if ( !_NIB.CapabilityInfo )
_NIB.CapabilityInfo = ZDO_Config_Node_Descriptor.CapabilityFlags;
devState = DEV_NWK_ORPHAN;
ret = (byte)NLME_OrphanJoinRequest( channelList, pData[4] );
}
else
ret = ZNwkInvalidParam;
break;
#endif // !ZDO
#if defined (RTR_NWK)
case SPI_CMD_NLME_ROUTE_DISC_REQ:
ret = (byte)NLME_RouteDiscoveryRequest( BUILD_UINT16( pData[1], pData[0] ), pData[2] );
break;
case SPI_CMD_NLME_DIRECT_JOIN_REQ:
MT_ReverseBytes( pData, 8 );
ret = (byte)NLME_DirectJoinRequest( pData, pData[8] );
break;
#endif // RTR
#endif // MT_NWK_FUNC
default:
ret = (byte)ZUnsupportedMode;
break;
}
#if defined ( MT_NWK_FUNC )
MT_SendSPIRespMsg( ret, cmd_id, len, SPI_RESP_LEN_NWK_DEFAULT );
#endif
(void)len;
(void)ret;
}
