/** * @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; }