/********************************************************************* * @fn zclHomelink_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: * * @return none */ static void zclHomelink_HandleKeys( byte shift, byte keys ) { if ((keys & (HAL_KEY_SW_2 | HAL_KEY_SW_3 | HAL_KEY_SW_4)) == (HAL_KEY_SW_2 | HAL_KEY_SW_3 | HAL_KEY_SW_4)) // Press all three for one second to reset device { // Check if keys still pressed after 500 ms debounce delay (in hal_key.c) if ((HalKeyRead() & (HAL_KEY_SW_2 | HAL_KEY_SW_3 | HAL_KEY_SW_4)) == (HAL_KEY_SW_2 | HAL_KEY_SW_3 | HAL_KEY_SW_4)) { zclHomelink_zigbeeReset(); } return; } osal_stop_timerEx(zclHomelink_TaskID, HOMELINK_RESET_EVT); // Check if any keys still pressed after 800 ms debounce delay (in hal_key.c) if (HalKeyRead() & (HAL_KEY_SW_2 | HAL_KEY_SW_3 | HAL_KEY_SW_4)) { // If so do nothing, probably programming mode } else if (keys & HAL_KEY_SW_2) { if (osal_get_timeoutEx(zclHomelink_TaskID, HOMELINK_SW2_EVT) == 0) { zclHomelink_SendCmdToggle(ENDPOINT); } osal_start_timerEx( zclHomelink_TaskID, HOMELINK_SW2_EVT, HOMELINK_SW_BLANKING ); } else if (keys & HAL_KEY_SW_3) { if (osal_get_timeoutEx(zclHomelink_TaskID, HOMELINK_SW3_EVT) == 0) { zclHomelink_SendCmdToggle(ENDPOINT+1); } osal_start_timerEx( zclHomelink_TaskID, HOMELINK_SW3_EVT, HOMELINK_SW_BLANKING ); } else if (keys & HAL_KEY_SW_4) { if (osal_get_timeoutEx(zclHomelink_TaskID, HOMELINK_SW4_EVT) == 0) { zclHomelink_SendCmdToggle(ENDPOINT+2); } osal_start_timerEx( zclHomelink_TaskID, HOMELINK_SW4_EVT, HOMELINK_SW_BLANKING ); } }
/********************************************************************* * @fn oadManager_ProcessOSALMsg * * @brief Process an incoming task message. * * @param pMsg - message to process * * @return none */ static void oadManager_ProcessOSALMsg( osal_event_hdr_t *pMsg ) { switch ( pMsg->event ) { #if (defined HAL_KEY) && (HAL_KEY == TRUE) case KEY_CHANGE: // Make sure the OAD download timer is not running if ( osal_get_timeoutEx( oadManagerTaskId, OAD_DOWNLOAD_EVT ) == 0 ) { oadManager_HandleKeys( ((keyChange_t *)pMsg)->state, ((keyChange_t *)pMsg)->keys ); } break; #endif case GATT_MSG_EVENT: oadManagerProcessGATTMsg( (gattMsgEvent_t *) pMsg ); break; } }
/********************************************************************* * @brief Task Event Processor function. * * Internal function defined in peripheral.h. */ uint16 GAPRole_ProcessEvent( uint8 task_id, uint16 events ) { VOID task_id; // OSAL required parameter that isn't used in this function if ( events & SYS_EVENT_MSG ) { uint8 *pMsg; if ( (pMsg = osal_msg_receive( gapRole_TaskID )) != NULL ) { gapRole_ProcessOSALMsg( (osal_event_hdr_t *)pMsg ); // Release the OSAL message VOID osal_msg_deallocate( pMsg ); } // return unprocessed events return (events ^ SYS_EVENT_MSG); } if ( events & GAP_EVENT_SIGN_COUNTER_CHANGED ) { // Sign counter changed, save it to NV VOID osal_snv_write( BLE_NVID_SIGNCOUNTER, sizeof( uint32 ), &gapRole_signCounter ); return ( events ^ GAP_EVENT_SIGN_COUNTER_CHANGED ); } if ( events & START_ADVERTISING_EVT ) { if ( gapRole_AdvEnabled ) { gapAdvertisingParams_t params; // Setup advertisement parameters if ( gapRole_state == GAPROLE_CONNECTED ) { // While in a connection, we can only advertise non-connectable undirected. params.eventType = GAP_ADTYPE_ADV_NONCONN_IND; } else { params.eventType = gapRole_AdvEventType; params.initiatorAddrType = gapRole_AdvDirectType; VOID osal_memcpy( params.initiatorAddr, gapRole_AdvDirectAddr, B_ADDR_LEN ); } params.channelMap = gapRole_AdvChanMap; params.filterPolicy = gapRole_AdvFilterPolicy; if ( GAP_MakeDiscoverable( gapRole_TaskID, ¶ms ) != SUCCESS ) { gapRole_state = GAPROLE_ERROR; if ( pGapRoles_AppCGs && pGapRoles_AppCGs->pfnStateChange ) { pGapRoles_AppCGs->pfnStateChange( gapRole_state ); } } } return ( events ^ START_ADVERTISING_EVT ); } if ( events & RSSI_READ_EVT ) { // Only get RSSI when in a connection if ( (gapRole_state == GAPROLE_CONNECTED) || (gapRole_state == GAPROLE_CONNECTED_ADV) ) { // Ask for RSSI VOID HCI_ReadRssiCmd( gapRole_ConnectionHandle ); // Setup next event if ( gapRole_RSSIReadRate ) { VOID osal_start_timerEx( gapRole_TaskID, RSSI_READ_EVT, gapRole_RSSIReadRate ); } } return ( events ^ RSSI_READ_EVT ); } if ( events & UPDATE_PARAMS_TIMEOUT_EVT ) { // Clear an existing timeout if ( osal_get_timeoutEx( gapRole_TaskID, UPDATE_PARAMS_TIMEOUT_EVT ) ) { VOID osal_stop_timerEx( gapRole_TaskID, UPDATE_PARAMS_TIMEOUT_EVT ); } // The Update Parameters Timeout occurred - Terminate connection VOID GAP_TerminateLinkReq( gapRole_TaskID, gapRole_ConnectionHandle, HCI_DISCONNECT_REMOTE_USER_TERM ); return ( events ^ UPDATE_PARAMS_TIMEOUT_EVT ); } // Discard unknown events return 0; }
/********************************************************************* * @fn gapRole_ProcessGAPMsg * * @brief Process an incoming task message. * * @param pMsg - message to process * * @return none */ static void gapRole_ProcessGAPMsg( gapEventHdr_t *pMsg ) { uint8 notify = FALSE; // State changed notify the app? (default no) switch ( pMsg->opcode ) { case GAP_DEVICE_INIT_DONE_EVENT: { gapDeviceInitDoneEvent_t *pPkt = (gapDeviceInitDoneEvent_t *)pMsg; bStatus_t stat = pPkt->hdr.status; if ( stat == SUCCESS ) { // Save off the generated keys VOID osal_snv_write( BLE_NVID_IRK, KEYLEN, gapRole_IRK ); VOID osal_snv_write( BLE_NVID_CSRK, KEYLEN, gapRole_SRK ); // Save off the information VOID osal_memcpy( gapRole_bdAddr, pPkt->devAddr, B_ADDR_LEN ); gapRole_state = GAPROLE_STARTED; // Update the advertising data stat = GAP_UpdateAdvertisingData( gapRole_TaskID, TRUE, gapRole_AdvertDataLen, gapRole_AdvertData ); } if ( stat != SUCCESS ) { gapRole_state = GAPROLE_ERROR; } notify = TRUE; } break; case GAP_ADV_DATA_UPDATE_DONE_EVENT: { gapAdvDataUpdateEvent_t *pPkt = (gapAdvDataUpdateEvent_t *)pMsg; if ( pPkt->hdr.status == SUCCESS ) { if ( pPkt->adType ) { // Setup the Response Data pPkt->hdr.status = GAP_UpdateAdvertisingData( gapRole_TaskID, FALSE, gapRole_ScanRspDataLen, gapRole_ScanRspData ); } else { // Start advertising VOID osal_set_event( gapRole_TaskID, START_ADVERTISING_EVT ); } } if ( pPkt->hdr.status != SUCCESS ) { // Set into Error state gapRole_state = GAPROLE_ERROR; notify = TRUE; } } break; case GAP_MAKE_DISCOVERABLE_DONE_EVENT: case GAP_END_DISCOVERABLE_DONE_EVENT: { gapMakeDiscoverableRspEvent_t *pPkt = (gapMakeDiscoverableRspEvent_t *)pMsg; if ( pPkt->hdr.status == SUCCESS ) { if ( pMsg->opcode == GAP_MAKE_DISCOVERABLE_DONE_EVENT ) { gapRole_state = GAPROLE_ADVERTISING; } else // GAP_END_DISCOVERABLE_DONE_EVENT { if ( gapRole_AdvertOffTime != 0 ) { if ( ( gapRole_AdvEnabled ) ) { VOID osal_start_timerEx( gapRole_TaskID, START_ADVERTISING_EVT, gapRole_AdvertOffTime ); } } else { // Since gapRole_AdvertOffTime is set to 0, the device should not // automatically become discoverable again after a period of time. // Set enabler to FALSE; device will become discoverable again when // this value gets set to TRUE gapRole_AdvEnabled = FALSE; } // In the Advertising Off period gapRole_state = GAPROLE_WAITING; } } else { gapRole_state = GAPROLE_ERROR; } notify = TRUE; } break; case GAP_LINK_ESTABLISHED_EVENT: { gapEstLinkReqEvent_t *pPkt = (gapEstLinkReqEvent_t *)pMsg; if ( pPkt->hdr.status == SUCCESS ) { VOID osal_memcpy( gapRole_ConnectedDevAddr, pPkt->devAddr, B_ADDR_LEN ); gapRole_ConnectionHandle = pPkt->connectionHandle; gapRole_state = GAPROLE_CONNECTED; if ( gapRole_RSSIReadRate ) { // Start the RSSI Reads VOID osal_start_timerEx( gapRole_TaskID, RSSI_READ_EVT, gapRole_RSSIReadRate ); } // Store connection information gapRole_ConnInterval = pPkt->connInterval; gapRole_ConnSlaveLatency = pPkt->connLatency; gapRole_ConnTimeout = pPkt->connTimeout; // Check whether update parameter request is enabled if ( gapRole_ParamUpdateEnable == TRUE ) { // Get the minimum time upon connection establishment before the // peripheral can start a connection update procedure. uint16 timeout = GAP_GetParamValue( TGAP_CONN_PAUSE_PERIPHERAL ); osal_start_timerEx( gapRole_TaskID, START_CONN_UPDATE_EVT, timeout*1000 ); } // Notify the Bond Manager to the connection VOID GAPBondMgr_LinkEst( pPkt->devAddrType, pPkt->devAddr, pPkt->connectionHandle, GAP_PROFILE_PERIPHERAL ); } else if ( pPkt->hdr.status == bleGAPConnNotAcceptable ) { // Set enabler to FALSE; device will become discoverable again when // this value gets set to TRUE gapRole_AdvEnabled = FALSE; // Go to WAITING state, and then start advertising gapRole_state = GAPROLE_WAITING; } else { gapRole_state = GAPROLE_ERROR; } notify = TRUE; } break; case GAP_LINK_TERMINATED_EVENT: { gapTerminateLinkEvent_t *pPkt = (gapTerminateLinkEvent_t *)pMsg; GAPBondMgr_ProcessGAPMsg( (gapEventHdr_t *)pMsg ); osal_memset( gapRole_ConnectedDevAddr, 0, B_ADDR_LEN ); // Erase connection information gapRole_ConnInterval = 0; gapRole_ConnSlaveLatency = 0; gapRole_ConnTimeout = 0; // Cancel all connection parameter update timers (if any active) VOID osal_stop_timerEx( gapRole_TaskID, START_CONN_UPDATE_EVT ); VOID osal_stop_timerEx( gapRole_TaskID, CONN_PARAM_TIMEOUT_EVT ); // Go to WAITING state, and then start advertising if( pPkt->reason == LL_SUPERVISION_TIMEOUT_TERM ) { gapRole_state = GAPROLE_WAITING_AFTER_TIMEOUT; } else { gapRole_state = GAPROLE_WAITING; } notify = TRUE; VOID osal_set_event( gapRole_TaskID, START_ADVERTISING_EVT ); gapRole_ConnectionHandle = INVALID_CONNHANDLE; } break; case GAP_LINK_PARAM_UPDATE_EVENT: { gapLinkUpdateEvent_t *pPkt = (gapLinkUpdateEvent_t *)pMsg; // Cancel connection param update timeout timer (if active) VOID osal_stop_timerEx( gapRole_TaskID, CONN_PARAM_TIMEOUT_EVT ); if ( pPkt->hdr.status == SUCCESS ) { // Store new connection parameters gapRole_ConnInterval = pPkt->connInterval; gapRole_ConnSlaveLatency = pPkt->connLatency; gapRole_ConnTimeout = pPkt->connTimeout; // Make sure there's no pending connection update procedure if ( osal_get_timeoutEx( gapRole_TaskID, START_CONN_UPDATE_EVT ) == 0 ) { // Notify the application with the new connection parameters if ( pGapRoles_ParamUpdateCB != NULL ) { (*pGapRoles_ParamUpdateCB)( gapRole_ConnInterval, gapRole_ConnSlaveLatency, gapRole_ConnTimeout ); } } } } break; default: break; } if ( notify == TRUE ) { // Notify the application with the new state change if ( pGapRoles_AppCGs && pGapRoles_AppCGs->pfnStateChange ) { pGapRoles_AppCGs->pfnStateChange( gapRole_state ); } } }
/********************************************************************* * @brief Set a GAP Role parameter. * * Public function defined in peripheral.h. */ bStatus_t GAPRole_SetParameter( uint16 param, uint8 len, void *pValue ) { bStatus_t ret = SUCCESS; switch ( param ) { case GAPROLE_IRK: if ( len == KEYLEN ) { VOID osal_memcpy( gapRole_IRK, pValue, KEYLEN ) ; } else { ret = bleInvalidRange; } break; case GAPROLE_SRK: if ( len == KEYLEN ) { VOID osal_memcpy( gapRole_SRK, pValue, KEYLEN ) ; } else { ret = bleInvalidRange; } break; case GAPROLE_SIGNCOUNTER: if ( len == sizeof ( uint32 ) ) { gapRole_signCounter = *((uint32*)pValue); } else { ret = bleInvalidRange; } break; case GAPROLE_ADVERT_ENABLED: if ( len == sizeof( uint8 ) ) { uint8 oldAdvEnabled = gapRole_AdvEnabled; gapRole_AdvEnabled = *((uint8*)pValue); if ( (oldAdvEnabled) && (gapRole_AdvEnabled == FALSE) ) { // Turn off Advertising if ( gapRole_state == GAPROLE_ADVERTISING ) { VOID GAP_EndDiscoverable( gapRole_TaskID ); } } else if ( (oldAdvEnabled == FALSE) && (gapRole_AdvEnabled) ) { // Turn on Advertising if ( (gapRole_state == GAPROLE_STARTED) || (gapRole_state == GAPROLE_WAITING) || (gapRole_state == GAPROLE_WAITING_AFTER_TIMEOUT) ) { VOID osal_set_event( gapRole_TaskID, START_ADVERTISING_EVT ); } } } else { ret = bleInvalidRange; } break; case GAPROLE_ADVERT_OFF_TIME: if ( len == sizeof ( uint16 ) ) { gapRole_AdvertOffTime = *((uint16*)pValue); } else { ret = bleInvalidRange; } break; case GAPROLE_ADVERT_DATA: if ( len <= B_MAX_ADV_LEN ) { VOID osal_memset( gapRole_AdvertData, 0, B_MAX_ADV_LEN ); VOID osal_memcpy( gapRole_AdvertData, pValue, len ); gapRole_AdvertDataLen = len; } else { ret = bleInvalidRange; } break; case GAPROLE_SCAN_RSP_DATA: if ( len <= B_MAX_ADV_LEN ) { VOID osal_memset( gapRole_ScanRspData, 0, B_MAX_ADV_LEN ); VOID osal_memcpy( gapRole_ScanRspData, pValue, len ); gapRole_ScanRspDataLen = len; } else { ret = bleInvalidRange; } break; case GAPROLE_ADV_EVENT_TYPE: if ( (len == sizeof ( uint8 )) && (*((uint8*)pValue) <= GAP_ADTYPE_ADV_NONCONN_IND) ) { gapRole_AdvEventType = *((uint8*)pValue); } else { ret = bleInvalidRange; } break; case GAPROLE_ADV_DIRECT_TYPE: if ( (len == sizeof ( uint8 )) && (*((uint8*)pValue) <= ADDRTYPE_PRIVATE_RESOLVE) ) { gapRole_AdvDirectType = *((uint8*)pValue); } else { ret = bleInvalidRange; } break; case GAPROLE_ADV_DIRECT_ADDR: if ( len == B_ADDR_LEN ) { VOID osal_memcpy( gapRole_AdvDirectAddr, pValue, B_ADDR_LEN ) ; } else { ret = bleInvalidRange; } break; case GAPROLE_ADV_CHANNEL_MAP: if ( (len == sizeof ( uint8 )) && (*((uint8*)pValue) <= 0x07) ) { gapRole_AdvChanMap = *((uint8*)pValue); } else { ret = bleInvalidRange; } break; case GAPROLE_ADV_FILTER_POLICY: if ( (len == sizeof ( uint8 )) && (*((uint8*)pValue) <= GAP_FILTER_POLICY_WHITE) ) { gapRole_AdvFilterPolicy = *((uint8*)pValue); } else { ret = bleInvalidRange; } break; case GAPROLE_RSSI_READ_RATE: if ( len == sizeof ( uint16 ) ) { gapRole_RSSIReadRate = *((uint16*)pValue); if ( (gapRole_RSSIReadRate) && (gapRole_state == GAPROLE_CONNECTED) ) { // Start the RSSI Reads VOID osal_start_timerEx( gapRole_TaskID, RSSI_READ_EVT, gapRole_RSSIReadRate ); } } else { ret = bleInvalidRange; } break; case GAPROLE_PARAM_UPDATE_ENABLE: if ( (len == sizeof ( uint8 )) && (*((uint8*)pValue) <= TRUE) ) { gapRole_ParamUpdateEnable = *((uint8*)pValue); } else { ret = bleInvalidRange; } break; case GAPROLE_MIN_CONN_INTERVAL: { uint16 newInterval = *((uint16*)pValue); if ( len == sizeof ( uint16 ) && ( newInterval >= MIN_CONN_INTERVAL ) && ( newInterval <= MAX_CONN_INTERVAL ) ) { gapRole_MinConnInterval = newInterval; } else { ret = bleInvalidRange; } } break; case GAPROLE_MAX_CONN_INTERVAL: { uint16 newInterval = *((uint16*)pValue); if ( len == sizeof ( uint16 ) && ( newInterval >= MIN_CONN_INTERVAL) && ( newInterval <= MAX_CONN_INTERVAL) ) { gapRole_MaxConnInterval = newInterval; } else { ret = bleInvalidRange; } } break; case GAPROLE_SLAVE_LATENCY: { uint16 latency = *((uint16*)pValue); if ( len == sizeof ( uint16 ) && (latency < MAX_SLAVE_LATENCY) ) { gapRole_SlaveLatency = latency; } else { ret = bleInvalidRange; } } break; case GAPROLE_TIMEOUT_MULTIPLIER: { uint16 newTimeout = *((uint16*)pValue); if ( len == sizeof ( uint16 ) && (newTimeout >= MIN_TIMEOUT_MULTIPLIER) && (newTimeout <= MAX_TIMEOUT_MULTIPLIER) ) { gapRole_TimeoutMultiplier = newTimeout; } else { ret = bleInvalidRange; } } break; case GAPROLE_PARAM_UPDATE_REQ: { uint8 req = *((uint8*)pValue); if ( len == sizeof ( uint8 ) && (req == TRUE) ) { // Make sure we don't send an L2CAP Connection Parameter Update Request // command within TGAP(conn_param_timeout) of an L2CAP Connection Parameter // Update Response being received. if ( osal_get_timeoutEx( gapRole_TaskID, CONN_PARAM_TIMEOUT_EVT ) == 0 ) { // Start connection update procedure gapRole_startConnUpdate( GAPROLE_NO_ACTION ); // Connection update requested by app, cancel such pending procedure (if active) VOID osal_stop_timerEx( gapRole_TaskID, START_CONN_UPDATE_EVT ); } else { ret = blePending; } } else { ret = bleInvalidRange; } } break; default: // The param value isn't part of this profile, try the GAP. if ( (param < TGAP_PARAMID_MAX) && (len == sizeof ( uint16 )) ) { ret = GAP_SetParamValue( param, *((uint16*)pValue) ); } else { ret = INVALIDPARAMETER; } break; } return ( ret ); }