static void controlBLECentral_HandleKeys( uint8 shift, uint8 keys ) { (void)shift; // Intentionally unreferenced parameter uint8 adc; if(keys & KEY_FUN1) { app_write_string("\r\ngot the KEY_FUN1 V:"); adc=halGetVoltageMonitorInput(); app_write_string( uint8_to_string(adc)); HalLedSet( HAL_LED_1 , HAL_LED_MODE_FLASH ); } if(keys & KEY_FUN2) { app_write_string("\r\ngot the KEY_FUN2"); HalLedSet(HAL_LED_2, HAL_LED_MODE_BLINK); } if ( keys & HAL_KEY_UP ) { // Start or stop discovery if ( simpleBLEState != BLE_STATE_CONNECTED ) { if ( !simpleBLEScanning ) { simpleBLEScanning = TRUE; simpleBLEScanRes = 0; LCD_WRITE_STRING( "Discovering...", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( "", HAL_LCD_LINE_2 ); GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE, DEFAULT_DISCOVERY_ACTIVE_SCAN, DEFAULT_DISCOVERY_WHITE_LIST ); } else { GAPCentralRole_CancelDiscovery(); } } else if ( simpleBLEState == BLE_STATE_CONNECTED && simpleBLECharHdl != 0 && simpleBLEProcedureInProgress == FALSE ) { uint8 status; // Do a read or write as long as no other read or write is in progress if ( simpleBLEDoWrite ) { // Do a write attWriteReq_t req; req.handle = simpleBLECharHdl; req.len = 1; req.value[0] = simpleBLECharVal; req.sig = 0; req.cmd = 0; status = GATT_WriteCharValue( simpleBLEConnHandle, &req, simpleBLETaskId ); } else { // Do a read attReadReq_t req; req.handle = simpleBLECharHdl; status = GATT_ReadCharValue( simpleBLEConnHandle, &req, simpleBLETaskId ); } if ( status == SUCCESS ) { simpleBLEProcedureInProgress = TRUE; simpleBLEDoWrite = !simpleBLEDoWrite; } } } if ( keys & HAL_KEY_LEFT ) { // Display discovery results if ( !simpleBLEScanning && simpleBLEScanRes > 0 ) { // Increment index of current result (with wraparound) simpleBLEScanIdx++; if ( simpleBLEScanIdx >= simpleBLEScanRes ) { simpleBLEScanIdx = 0; } LCD_WRITE_STRING_VALUE( "Device", simpleBLEScanIdx + 1, 10, HAL_LCD_LINE_1 ); LCD_WRITE_STRING( bdAddr2Str( simpleBLEDevList[simpleBLEScanIdx].addr ), HAL_LCD_LINE_2 ); } } if ( keys & HAL_KEY_RIGHT ) { // Connection update if ( simpleBLEState == BLE_STATE_CONNECTED ) { GAPCentralRole_UpdateLink( simpleBLEConnHandle, DEFAULT_UPDATE_MIN_CONN_INTERVAL, DEFAULT_UPDATE_MAX_CONN_INTERVAL, DEFAULT_UPDATE_SLAVE_LATENCY, DEFAULT_UPDATE_CONN_TIMEOUT ); } } if ( keys & HAL_KEY_CENTER ) { uint8 addrType; uint8 *peerAddr; // Connect or disconnect if ( simpleBLEState == BLE_STATE_IDLE ) { // if there is a scan result if ( simpleBLEScanRes > 0 ) { // connect to current device in scan result peerAddr = simpleBLEDevList[simpleBLEScanIdx].addr; addrType = simpleBLEDevList[simpleBLEScanIdx].addrType; simpleBLEState = BLE_STATE_CONNECTING; GAPCentralRole_EstablishLink( DEFAULT_LINK_HIGH_DUTY_CYCLE, DEFAULT_LINK_WHITE_LIST, addrType, peerAddr ); LCD_WRITE_STRING( "Connecting", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( bdAddr2Str( peerAddr ), HAL_LCD_LINE_2 ); } } else if ( simpleBLEState == BLE_STATE_CONNECTING || simpleBLEState == BLE_STATE_CONNECTED ) { // disconnect simpleBLEState = BLE_STATE_DISCONNECTING; gStatus = GAPCentralRole_TerminateLink( simpleBLEConnHandle ); LCD_WRITE_STRING( "Disconnecting", HAL_LCD_LINE_1 ); } } if ( keys & HAL_KEY_DOWN ) { // Start or cancel RSSI polling if ( simpleBLEState == BLE_STATE_CONNECTED ) { if ( !simpleBLERssi ) { simpleBLERssi = TRUE; GAPCentralRole_StartRssi( simpleBLEConnHandle, DEFAULT_RSSI_PERIOD ); } else { simpleBLERssi = FALSE; GAPCentralRole_CancelRssi( simpleBLEConnHandle ); LCD_WRITE_STRING( "RSSI Cancelled", HAL_LCD_LINE_1 ); } } } }
/********************************************************************* * @fn glucCollCentral_handleKeys * * @brief Handles all key events for this device. * * @param shift - true if in shift/alt. * @param keys - bit field for key events. * * @return none */ static void glucCollCentral_handleKeys(uint8_t shift, uint8_t keys) { (void)shift; // Intentionally unreferenced parameter if (keys & KEY_UP) { // Start or stop discovery if (glucCollState != BLE_STATE_CONNECTED) { if (!glucCollScanning) { glucCollScanning = TRUE; glucCollScanRes = 0; LCD_WRITE_STRING("Discovering...", LCD_PAGE0); LCD_WRITE_STRING("", LCD_PAGE1); LCD_WRITE_STRING("", LCD_PAGE2); GAPCentralRole_StartDiscovery(DEFAULT_DISCOVERY_MODE, DEFAULT_DISCOVERY_ACTIVE_SCAN, DEFAULT_DISCOVERY_WHITE_LIST); } else { GAPCentralRole_CancelDiscovery(); } } else if (glucCollState == BLE_STATE_CONNECTED && glucCollCharHdls == true && glucCollWritePending == false) { uint8_t status; #if GLUCOSE_FILTER_ENABLED // Request number of records status = glucoseCtlPntWriteFilter(CTL_PNT_OP_GET_NUM, CTL_PNT_OPER_RANGE, DEFAULT_FILTER_TYPE, pFilter1, pFilter2); #else // Request number of records status = glucoseCtlPntWrite(CTL_PNT_OP_GET_NUM, CTL_PNT_OPER_ALL); #endif if(status == 0) { glucCollWritePending = true; } } return; } if (keys & KEY_LEFT) { // Display discovery results if (glucCollState != BLE_STATE_CONNECTED && !glucCollScanning && glucCollScanRes > 0) { // Increment index of current result (with wraparound) glucCollScanIdx++; if (glucCollScanIdx >= glucCollScanRes) { glucCollScanIdx = 0; } LCD_WRITE_STRING_VALUE("Device", glucCollScanIdx + 1, 10, LCD_PAGE0); LCD_WRITE_STRING(Util_convertBdAddr2Str(glucCollDevList[glucCollScanIdx].addr), LCD_PAGE1); LCD_WRITE_STRING("", LCD_PAGE2); } else if (glucCollState == BLE_STATE_CONNECTED) { if(glucoseCtlPntWrite(CTL_PNT_OP_ABORT, CTL_PNT_OPER_NULL) == 0) { glucCollWritePending = false; } } return; } if (keys & KEY_RIGHT) { // Request all records if (glucCollState == BLE_STATE_CONNECTED && glucCollCharHdls == true && glucCollWritePending == false) { uint8_t status; #if GLUCOSE_FILTER_ENABLED status = glucoseCtlPntWriteFilter(CTL_PNT_OP_REQ, CTL_PNT_OPER_RANGE, DEFAULT_FILTER_TYPE, pFilter1, pFilter2); #else status = glucoseCtlPntWrite(CTL_PNT_OP_REQ, CTL_PNT_OPER_ALL); #endif if(status == SUCCESS) { glucCollWritePending = true; } } return; } if (keys & KEY_SELECT) { uint8_t addrType; uint8_t *peerAddr; // Connect or disconnect if (glucCollState == BLE_STATE_IDLE) { // if there is a scan result if (glucCollScanRes > 0) { // connect to current device in scan result peerAddr = glucCollDevList[glucCollScanIdx].addr; addrType = glucCollDevList[glucCollScanIdx].addrType; glucCollState = BLE_STATE_CONNECTING; GAPCentralRole_EstablishLink(DEFAULT_LINK_HIGH_DUTY_CYCLE, DEFAULT_LINK_WHITE_LIST, addrType, peerAddr); LCD_WRITE_STRING("Connecting", LCD_PAGE0); LCD_WRITE_STRING(Util_convertBdAddr2Str(peerAddr), LCD_PAGE1); LCD_WRITE_STRING("", LCD_PAGE2); } } else if (glucCollState == BLE_STATE_CONNECTING || glucCollState == BLE_STATE_CONNECTED) { // disconnect glucCollState = BLE_STATE_DISCONNECTING; GAPCentralRole_TerminateLink(glucCollConnHandle); LCD_WRITE_STRING("Disconnecting", LCD_PAGE0); LCD_WRITE_STRING("", LCD_PAGE1); LCD_WRITE_STRING("", LCD_PAGE2); } return; } if (keys & KEY_DOWN) { // Clear stored records if (glucCollState == BLE_STATE_CONNECTED && glucCollCharHdls == true && glucCollWritePending == false) { uint8_t status; #if GLUCOSE_FILTER_ENABLED status = glucoseCtlPntWriteFilter(CTL_PNT_OP_CLR, CTL_PNT_OPER_RANGE, DEFAULT_FILTER_TYPE, pFilter1, pFilter2); #else status = glucoseCtlPntWrite(CTL_PNT_OP_CLR, CTL_PNT_OPER_ALL); #endif if(status == 0) { glucCollWritePending = true; glucCollClearPending = true; } } else if (glucCollState != BLE_STATE_CONNECTED) { // erase all bonds GAPBondMgr_SetParameter(GAPBOND_ERASE_ALLBONDS, 0, NULL); LCD_WRITE_STRING("Erasing bonds", LCD_PAGE0); LCD_WRITE_STRING("", LCD_PAGE1); LCD_WRITE_STRING("", LCD_PAGE2); // initiate service discovery again glucCollCharHdls = false; } } }
/********************************************************************* * @fn hidappCentralEventCB * * @brief Notification from the profile of a state change. * * @param pEvent - new role event * * @return none */ static void hidappCentralEventCB( gapCentralRoleEvent_t *pEvent ) { static uint8 addrType; static uint8 peerDeviceFound = FALSE; switch( pEvent->gap.opcode ) { case GAP_DEVICE_INIT_DONE_EVENT: { gapDeviceInitDoneEvent_t *pEvt = (gapDeviceInitDoneEvent_t *)pEvent; // See if device has a valid BD Address if ( osal_isbufset( pEvt->devAddr, 0xFF, B_ADDR_LEN ) == FALSE ) { #if defined ( NANO_DONGLE ) if ( hidappBondCount() > 0 ) { // Initiate connection hidappEstablishLink( TRUE, addrType, remoteAddr ); } else { // Sit idle till ask to scan hidappSetIdle(); } #endif // #if defined ( NANO_DONGLE ) } else { uint8 ownBDaddr[] = OWN_ADDR; // An old CC2540 USB Dongle has all 0xFF's for its BD Address so // just use the hard-coded address in that case. HCI_EXT_SetBDADDRCmd( ownBDaddr ); // Re-initialize the device with the new address osal_set_event( hidappTaskId, HIDAPP_EVT_START ); } } break; case GAP_DEVICE_INFO_EVENT: // Goes here before entering GAP_DEVICE_DISCOVERY_EVENT // Read advertising/scan response data // if it contains HID remote, end service discovery if ( hidappFindSvcUuid( HID_SERVICE_UUID, pEvent->deviceInfo.pEvtData, pEvent->deviceInfo.dataLen ) ) { // Record peer devices address data addrType = pEvent->deviceInfo.addrType; osal_memcpy( remoteAddr, pEvent->deviceInfo.addr, B_ADDR_LEN ); peerDeviceFound = TRUE; } if ( ( peerDeviceFound == TRUE ) && ( pEvent->deviceInfo.eventType == GAP_ADTYPE_SCAN_RSP_IND ) && hidappFindHIDRemote( pEvent->deviceInfo.pEvtData, pEvent->deviceInfo.dataLen ) ) { // End device discovery VOID GAPCentralRole_CancelDiscovery(); } break; case GAP_DEVICE_DISCOVERY_EVENT: // If we have found a connectable device, establish a connection if ( peerDeviceFound == TRUE ) { hidappEstablishLink( FALSE, addrType, remoteAddr ); peerDeviceFound = FALSE; numScans = 0; } else if ( numScans > 0 ) { numScans--; // Scan again hidappDiscoverDevices(); } else { // Go idle hidappSetIdle(); } break; case GAP_LINK_ESTABLISHED_EVENT: // Cancel initiate connection timer VOID osal_stop_timerEx( hidappTaskId, HIDAPP_EVT_INIT_CONNECT ); if ( pEvent->gap.hdr.status == SUCCESS ) { hidappBLEState = BLE_STATE_CONNECTED; HalLedSet( HAL_LED_1, HAL_LED_MODE_ON ); // green led connHandle = ((gapEstLinkReqEvent_t*)pEvent)->connectionHandle; } else if ( hidappBondCount() > 0 ) { // Re-initiate connection hidappEstablishLink( TRUE, addrType, remoteAddr ); } else { // Go idle hidappSetIdle(); } break; case GAP_LINK_TERMINATED_EVENT: // Cancel initiate connection timer VOID osal_stop_timerEx( hidappTaskId, HIDAPP_EVT_INIT_CONNECT ); HalLedSet( HAL_LED_1, HAL_LED_MODE_OFF ); // green led hidappBLEState = BLE_STATE_IDLE; gapBondMgrState = UNPAIRED_STATE; connHandle = INVALID_CONNHANDLE; if ( serviceDiscComplete == TRUE ) { // Remember the address of the last connected remote osal_memcpy( remoteHandles.lastRemoteAddr, remoteAddr, B_ADDR_LEN ); // Save handle information hidappSaveHandles(); } // Invalidate service discovery variables. serviceDiscComplete = FALSE; mouseCharHandle = GATT_INVALID_HANDLE; keyCharHandle = GATT_INVALID_HANDLE; consumerCtrlCharHandle = GATT_INVALID_HANDLE; mouseCCCHandle = GATT_INVALID_HANDLE; keyCCCHandle = GATT_INVALID_HANDLE; consumerCtrlCCCHandle = GATT_INVALID_HANDLE; serviceChangeHandle = GATT_INVALID_HANDLE; serviceToDiscover = GATT_INVALID_HANDLE; enableCCCDs = TRUE; if ( hidappBondCount() > 0 ) { // Re-initiate connection hidappEstablishLink( TRUE, addrType, remoteAddr ); } else { // Go idle hidappSetIdle(); } break; default: break; } }
/********************************************************************* * @fn simpleBLECentralEventCB * * @brief Central event callback function. * * @param pEvent - pointer to event structure * * @return none */ static void simpleBLECentralEventCB( gapCentralRoleEvent_t *pEvent ) { switch ( pEvent->gap.opcode ) { case GAP_DEVICE_INIT_DONE_EVENT: { LCD_WRITE_STRING( "BLE Central", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( bdAddr2Str( pEvent->initDone.devAddr ), HAL_LCD_LINE_2 ); #if 1 // Start or stop discovery if ( simpleBLEState != BLE_STATE_CONNECTED ) { if ( !simpleBLEScanning ) { simpleBLEScanning = TRUE; simpleBLEScanRes = 0; LCD_WRITE_STRING( "Discovering...", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( "", HAL_LCD_LINE_2 ); //HCI_EXT_SetRxGainCmd(HCI_EXT_RX_GAIN_HIGH); //HCI_EXT_SetTxPowerCmd(HCI_EXT_TX_POWER_0_DBM); GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE, DEFAULT_DISCOVERY_ACTIVE_SCAN, DEFAULT_DISCOVERY_WHITE_LIST ); HalLedSet(HAL_LED_1,HAL_LED_MODE_ON); } else { HalLedSet(HAL_LED_1,HAL_LED_MODE_OFF); GAPCentralRole_CancelDiscovery(); } } #endif } break; case GAP_DEVICE_INFO_EVENT: { // if filtering device discovery results based on service UUID //HalLedSet(HAL_LED_1,HAL_LED_MODE_OFF); if ( DEFAULT_DEV_DISC_BY_SVC_UUID == TRUE ) { if ( simpleBLEFindSvcUuid( SIMPLEPROFILE_SERV_UUID, pEvent->deviceInfo.pEvtData, pEvent->deviceInfo.dataLen ) ) { //HalLedSet(HAL_LED_1,HAL_LED_MODE_OFF); simpleBLEAddDeviceInfo( pEvent->deviceInfo.addr, pEvent->deviceInfo.addrType ); } } } break; case GAP_DEVICE_DISCOVERY_EVENT: { // discovery complete simpleBLEScanning = FALSE; // if not filtering device discovery results based on service UUID if ( DEFAULT_DEV_DISC_BY_SVC_UUID == FALSE ) { // Copy results simpleBLEScanRes = pEvent->discCmpl.numDevs; osal_memcpy( simpleBLEDevList, pEvent->discCmpl.pDevList, (sizeof( gapDevRec_t ) * pEvent->discCmpl.numDevs) ); //HalLedSet(HAL_LED_2,HAL_LED_MODE_ON); } LCD_WRITE_STRING_VALUE( "Devices Found", simpleBLEScanRes, 10, HAL_LCD_LINE_1 ); if ( simpleBLEScanRes > 0 ) { LCD_WRITE_STRING( "<- To Select", HAL_LCD_LINE_2 ); //HalLedSet(HAL_LED_2,HAL_LED_MODE_OFF); } // initialize scan index to last device simpleBLEScanIdx = simpleBLEScanRes; #if 1 // Display discovery results if ( !simpleBLEScanning && simpleBLEScanRes > 0 ) { // Increment index of current result (with wraparound) simpleBLEScanIdx++; if ( simpleBLEScanIdx >= simpleBLEScanRes ) { simpleBLEScanIdx = 0; } LCD_WRITE_STRING_VALUE( "Device", simpleBLEScanIdx + 1, 10, HAL_LCD_LINE_1 ); LCD_WRITE_STRING( bdAddr2Str( simpleBLEDevList[simpleBLEScanIdx].addr ), HAL_LCD_LINE_2 ); } uint8 addrType; uint8 *peerAddr; // Connect or disconnect if ( simpleBLEState == BLE_STATE_IDLE ) { // if there is a scan result if ( simpleBLEScanRes > 0 ) { // connect to current device in scan result peerAddr = simpleBLEDevList[simpleBLEScanIdx].addr; addrType = simpleBLEDevList[simpleBLEScanIdx].addrType; simpleBLEState = BLE_STATE_CONNECTING; GAPCentralRole_EstablishLink( DEFAULT_LINK_HIGH_DUTY_CYCLE, DEFAULT_LINK_WHITE_LIST, addrType, peerAddr ); LCD_WRITE_STRING( "Connecting", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( bdAddr2Str( peerAddr ), HAL_LCD_LINE_2 ); } else { #if 1 // Start or stop discovery if ( simpleBLEState != BLE_STATE_CONNECTED ) { if ( !simpleBLEScanning ) { simpleBLEScanning = TRUE; simpleBLEScanRes = 0; LCD_WRITE_STRING( "Discovering...", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( "", HAL_LCD_LINE_2 ); //HCI_EXT_SetRxGainCmd(HCI_EXT_RX_GAIN_HIGH); //HCI_EXT_SetTxPowerCmd(HCI_EXT_TX_POWER_0_DBM); GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE, DEFAULT_DISCOVERY_ACTIVE_SCAN, DEFAULT_DISCOVERY_WHITE_LIST ); //HalLedSet(HAL_LED_1,HAL_LED_MODE_ON); } else { HalLedSet(HAL_LED_1,HAL_LED_MODE_OFF); GAPCentralRole_CancelDiscovery(); } } #endif } } #endif } break; case GAP_LINK_ESTABLISHED_EVENT: { if ( pEvent->gap.hdr.status == SUCCESS ) { simpleBLEState = BLE_STATE_CONNECTED; simpleBLEConnHandle = pEvent->linkCmpl.connectionHandle; simpleBLEProcedureInProgress = TRUE; // If service discovery not performed initiate service discovery if ( simpleBLECharHdl == 0 ) { osal_start_timerEx( simpleBLETaskId, START_DISCOVERY_EVT, DEFAULT_SVC_DISCOVERY_DELAY ); } LCD_WRITE_STRING( "Connected", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( bdAddr2Str( pEvent->linkCmpl.devAddr ), HAL_LCD_LINE_2 ); HalLedSet(HAL_LED_2,HAL_LED_MODE_ON); } else { simpleBLEState = BLE_STATE_IDLE; simpleBLEConnHandle = GAP_CONNHANDLE_INIT; simpleBLERssi = FALSE; simpleBLEDiscState = BLE_DISC_STATE_IDLE; LCD_WRITE_STRING( "Connect Failed", HAL_LCD_LINE_1 ); LCD_WRITE_STRING_VALUE( "Reason:", pEvent->gap.hdr.status, 10, HAL_LCD_LINE_2 ); } } break; case GAP_LINK_TERMINATED_EVENT: { simpleBLEState = BLE_STATE_IDLE; simpleBLEConnHandle = GAP_CONNHANDLE_INIT; simpleBLERssi = FALSE; simpleBLEDiscState = BLE_DISC_STATE_IDLE; simpleBLECharHdl = 0; simpleBLEProcedureInProgress = FALSE; LCD_WRITE_STRING( "Disconnected", HAL_LCD_LINE_1 ); LCD_WRITE_STRING_VALUE( "Reason:", pEvent->linkTerminate.reason, 10, HAL_LCD_LINE_2 ); HalLedSet(HAL_LED_2,HAL_LED_MODE_OFF); } break; case GAP_LINK_PARAM_UPDATE_EVENT: { LCD_WRITE_STRING( "Param Update", HAL_LCD_LINE_1 ); } break; default: break; } }
/********************************************************************************************* * @fn simpleBLECentralEventCB * * @brief Central event callback function. * * @param pEvent - pointer to event structure * * @return none **********************************************************************************************/ static void simpleBLECentralEventCB( gapCentralRoleEvent_t *pEvent ){ switch ( pEvent->gap.opcode ){ case GAP_DEVICE_INIT_DONE_EVENT:{ //LCDPrintText("Central Initialized",0,PRINT_STRING); osal_memcpy(mac_buffer[0],pEvent->initDone.devAddr, MAC_LEN); HalLcdWriteString(bdAddr2Str( mac_buffer[0]), HAL_LCD_LINE_1); uint32 random_scan_duration =500;//to avoid normal scan be discarded by the timer,so its lasting-time should be short GAP_SetParamValue( TGAP_GEN_DISC_SCAN, random_scan_duration ); //random scan duration //LCDPrintText("discovering",0,PRINT_STRING); uint32 timeout_value = 200; // timeout_value - in milliseconds. osal_start_timerEx(MasterSlaveSwitchTaskID, PERIOD_DETECH_EVT, timeout_value); uint8 return_status; if(return_status = GAPCentralRole_StartDiscovery(DISCOVERY_MODE, ACTIVE_SCAN, DISCOVERY_WHITE_LIST )) LCDPrintText("discovery error:",return_status,PRINT_VALUE); break; } case GAP_DEVICE_INFO_EVENT:{ //find a new device // filtering device discovery results based on service UUID //LCDPrintText("find new device",0,PRINT_STRING); if(simpleBLEScanRes >= MAX_SCAN_RES){ GAPCentralRole_CancelDiscovery(); break; } if ( simpleBLEFindSvcUuid(WANTED_SERVICE_UUID, pEvent->deviceInfo.pEvtData, pEvent->deviceInfo.dataLen) ){ simpleBLEAddDeviceInfo( pEvent->deviceInfo.addr, pEvent->deviceInfo.addrType ); //GAPCentralRole_CancelDiscovery(); //stop discoverying } break; } case GAP_DEVICE_DISCOVERY_EVENT:{ //discaovery has completed osal_stop_timerEx(MasterSlaveSwitchTaskID,PERIOD_DETECH_EVT); //LCDPrintText("disca completed ",0,PRINT_STRING); if ( simpleBLEScanRes > 0 ){ // connect to current device in scan result uint8 random_select = random_num%simpleBLEScanRes; //LCDPrintText("random_select ",random_select,PRINT_STRING); CurrentConnectionInfo.MacType= simpleBLEDevList[random_select].addrType; CurrentConnectionInfo.MacAddr= simpleBLEDevList[random_select].addr; uint8 return_status; if(return_status = GAPCentralRole_EstablishLink( LINK_HIGH_DUTY_CYCLE, LINK_WHITE_LIST, CurrentConnectionInfo.MacType, CurrentConnectionInfo.MacAddr)){ LCDPrintText("Link Error",return_status,PRINT_VALUE); osal_set_event(MasterSlaveSwitchTaskID, MSS_CHANGE_ROLE_EVT); } } else{ //LCDPrintText("no device found",0,PRINT_STRING); osal_set_event(MasterSlaveSwitchTaskID, MSS_CHANGE_ROLE_EVT); //switch to periperal } break; } case GAP_LINK_ESTABLISHED_EVENT:{ if ( pEvent->gap.hdr.status == SUCCESS ){ //LCDPrintText("Connected",0,PRINT_STRING); CurrentConnectionInfo.Handle= pEvent->linkCmpl.connectionHandle; if(CharHandleSearchFlag == 1) simpleBLECentralStartDiscovery(); else{ ClientWriteValue(); CharSendingFlag =1; //LCDPrintText("NO NEED TO",0,PRINT_STRING); } } else{ LCDPrintText("Connect Failed ",pEvent->gap.hdr.status,PRINT_VALUE); osal_set_event(MasterSlaveSwitchTaskID, MSS_CHANGE_ROLE_EVT); } break; } case GAP_LINK_TERMINATED_EVENT:{ osal_set_event(MasterSlaveSwitchTaskID, MSS_CHANGE_ROLE_EVT); break; } case GAP_LINK_PARAM_UPDATE_EVENT: break; default: break; } }
/********************************************************************* * @fn simpleBLECentralEventCB * * @brief Central event callback function. * * @param pEvent - pointer to event structure * * @return none */ static void simpleBLECentralEventCB( gapCentralRoleEvent_t *pEvent ) { switch ( pEvent->gap.opcode ) { case GAP_DEVICE_INIT_DONE_EVENT: { LCD_WRITE_STRING( "BLE Central", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( bdAddr2Str( pEvent->initDone.devAddr ), HAL_LCD_LINE_2 ); } break; case GAP_DEVICE_INFO_EVENT: { var1= pEvent->deviceInfo.pEvtData; dataToPrint = var1[5]; //LCD_WRITE_STRING( bdAddr2Str(var1), HAL_LCD_LINE_3 ); if(dataToPrint == 0xA1) { LCD_WRITE_STRING_VALUE( "Value",var1[6], 16, HAL_LCD_LINE_3); } // if filtering device discovery results based on service UUID if ( DEFAULT_DEV_DISC_BY_SVC_UUID == TRUE ) { if ( simpleBLEFindSvcUuid( SIMPLEPROFILE_SERV_UUID, pEvent->deviceInfo.pEvtData, pEvent->deviceInfo.dataLen ) ) { simpleBLEAddDeviceInfo( pEvent->deviceInfo.addr, pEvent->deviceInfo.addrType ); } } } break; case GAP_DEVICE_DISCOVERY_EVENT: { // discovery complete simpleBLEScanning = FALSE; // if not filtering device discovery results based on service UUID if ( DEFAULT_DEV_DISC_BY_SVC_UUID == FALSE ) { // Copy results simpleBLEScanRes = pEvent->discCmpl.numDevs; osal_memcpy( simpleBLEDevList, pEvent->discCmpl.pDevList, (sizeof( gapDevRec_t ) * pEvent->discCmpl.numDevs) ); } LCD_WRITE_STRING_VALUE( "Devices Found", simpleBLEScanRes, 10, HAL_LCD_LINE_1 ); if ( simpleBLEScanRes > 0 ) { LCD_WRITE_STRING( "<- To Select", HAL_LCD_LINE_2 ); simpleBLEState = BLE_STATE_IDLE; simpleBLEConnHandle = GAP_CONNHANDLE_INIT; simpleBLERssi = FALSE; simpleBLEDiscState = BLE_DISC_STATE_IDLE; } if ( simpleBLEState != BLE_STATE_CONNECTED ) { if ( !simpleBLEScanning ) { uint8 adc7 = HalAdcRead (HAL_ADC_CHANNEL_7, HAL_ADC_RESOLUTION_8); LCD_WRITE_STRING_VALUE( "Value",adc7, 16, HAL_LCD_LINE_2); advertData[6]= var1[6]; advertData[8]= 0xA9; if(adc7>0x7E) advertData[9]= 0x01; else advertData[9]= 0x02; advertData[10]= 0xB9; GAP_UpdateAdvertisingData( GAPROLE_ADVERT_ENABLED,TRUE, sizeof(advertData),advertData); simpleBLEScanning = TRUE; simpleBLEScanRes = 0; LCD_WRITE_STRING( "Discovering...", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( "", HAL_LCD_LINE_2 ); GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE, DEFAULT_DISCOVERY_ACTIVE_SCAN, DEFAULT_DISCOVERY_WHITE_LIST ); } else { GAPCentralRole_CancelDiscovery(); } } // initialize scan index to last device simpleBLEScanIdx = simpleBLEScanRes; } break; case GAP_LINK_ESTABLISHED_EVENT: { if ( pEvent->gap.hdr.status == SUCCESS ) { simpleBLEState = BLE_STATE_CONNECTED; simpleBLEConnHandle = pEvent->linkCmpl.connectionHandle; simpleBLEProcedureInProgress = TRUE; // If service discovery not performed initiate service discovery if ( simpleBLECharHdl == 0 ) { osal_start_timerEx( simpleBLETaskId, START_DISCOVERY_EVT, DEFAULT_SVC_DISCOVERY_DELAY ); } LCD_WRITE_STRING( bdAddr2Str(var1), HAL_LCD_LINE_3 ); LCD_WRITE_STRING( "Connected", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( bdAddr2Str( pEvent->linkCmpl.devAddr ), HAL_LCD_LINE_2 ); } else { simpleBLEState = BLE_STATE_IDLE; simpleBLEConnHandle = GAP_CONNHANDLE_INIT; simpleBLERssi = FALSE; simpleBLEDiscState = BLE_DISC_STATE_IDLE; LCD_WRITE_STRING( "Connect Failed", HAL_LCD_LINE_1 ); LCD_WRITE_STRING_VALUE( "Reason:", pEvent->gap.hdr.status, 10, HAL_LCD_LINE_2 ); } } break; case GAP_LINK_TERMINATED_EVENT: { simpleBLEState = BLE_STATE_IDLE; simpleBLEConnHandle = GAP_CONNHANDLE_INIT; simpleBLERssi = FALSE; simpleBLEDiscState = BLE_DISC_STATE_IDLE; simpleBLECharHdl = 0; simpleBLEProcedureInProgress = FALSE; LCD_WRITE_STRING( "Disconnected", HAL_LCD_LINE_1 ); LCD_WRITE_STRING_VALUE( "Reason:", pEvent->linkTerminate.reason, 10, HAL_LCD_LINE_2 ); } break; case GAP_LINK_PARAM_UPDATE_EVENT: { LCD_WRITE_STRING( "Connected Update", HAL_LCD_LINE_1 ); } break; default: break; } }
static void simpleBLECentral_HandleKeys( uint8 shift, uint8 keys ) { (void)shift; // Intentionally unreferenced parameter if ( keys & HAL_KEY_UP ) { // Start or stop discovery if ( simpleBLEState != BLE_STATE_CONNECTED ) { if ( !simpleBLEScanning ) { uint8 adc7 = HalAdcRead (HAL_ADC_CHANNEL_7, HAL_ADC_RESOLUTION_8); LCD_WRITE_STRING_VALUE( "Value",adc7, 16, HAL_LCD_LINE_2); advertData[6]= var1[6]; advertData[8]= 0xA9; if(adc7>0x7E) advertData[9]= 0x01; else advertData[9]= 0x02; advertData[10]= 0xB9; GAP_UpdateAdvertisingData( GAPROLE_ADVERT_ENABLED,TRUE, sizeof(advertData),advertData); simpleBLEScanning = TRUE; simpleBLEScanRes = 0; LCD_WRITE_STRING( "Discovering...", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( "", HAL_LCD_LINE_2 ); GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE, DEFAULT_DISCOVERY_ACTIVE_SCAN, DEFAULT_DISCOVERY_WHITE_LIST ); } else { GAPCentralRole_CancelDiscovery(); } } else if ( simpleBLEState == BLE_STATE_CONNECTED && simpleBLECharHdl != 0 && simpleBLEProcedureInProgress == FALSE ) { uint8 status; // Do a read or write as long as no other read or write is in progress if ( simpleBLEDoWrite ) { // Do a write attWriteReq_t req; req.handle = simpleBLECharHdl; req.len = 1; req.value[0] = simpleBLECharVal; req.sig = 0; req.cmd = 0; status = GATT_WriteCharValue( simpleBLEConnHandle, &req, simpleBLETaskId ); } else { // Do a read attReadReq_t req; req.handle = simpleBLECharHdl; status = GATT_ReadCharValue( simpleBLEConnHandle, &req, simpleBLETaskId ); } if ( status == SUCCESS ) { simpleBLEProcedureInProgress = TRUE; simpleBLEDoWrite = !simpleBLEDoWrite; } } } if ( keys & HAL_KEY_LEFT ) { // Display discovery results if ( !simpleBLEScanning && simpleBLEScanRes > 0 ) { // Increment index of current result (with wraparound) simpleBLEScanIdx++; if ( simpleBLEScanIdx >= simpleBLEScanRes ) { simpleBLEScanIdx = 0; } LCD_WRITE_STRING_VALUE( "Device", simpleBLEScanIdx + 1, 10, HAL_LCD_LINE_1 ); LCD_WRITE_STRING( bdAddr2Str( simpleBLEDevList[simpleBLEScanIdx].addr ), HAL_LCD_LINE_2 ); } } //////////////////////////////////////////////////////////////////////////////// // Advertising if ( keys & HAL_KEY_RIGHT ) { // ressing the right key should toggle advertising on and off uint8 current_adv_enabled_status; uint8 new_adv_enabled_status; uint8 adc7 = HalAdcRead (HAL_ADC_CHANNEL_7, HAL_ADC_RESOLUTION_8); LCD_WRITE_STRING_VALUE( "Value",adc7, 16, HAL_LCD_LINE_2); advertData[6]= var1[6]; advertData[8]= 0xA9; if(adc7>0x7E) advertData[9]= 0x01; else advertData[9]= 0x02; advertData[10]= 0xB9; GAP_UpdateAdvertisingData( GAPROLE_ADVERT_ENABLED,TRUE, sizeof(advertData),advertData); //Find the current GAP advertisement status if( current_adv_enabled_status == FALSE ) { new_adv_enabled_status = TRUE; } else { new_adv_enabled_status = FALSE; } // if(var1[2] == 0x53) { //scanRspData[18] =0xAA; //scanRspData[19] =(uint8) var1[2]; //bStatus_t stat; //stat = GAP_UpdateAdvertisingData( 0, TRUE, 1, scanRspData); //} //change the GAP advertisement status to opposite of current status GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &new_adv_enabled_status ); } //////////////////////////////////////////////////////////////////////////////// /*if ( keys & HAL_KEY_CENTER ) { uint8 addrType; uint8 *peerAddr; // Connect or disconnect if ( simpleBLEState == BLE_STATE_IDLE ) { // if there is a scan result if ( simpleBLEScanRes > 0 ) { // connect to current device in scan result peerAddr = simpleBLEDevList[simpleBLEScanIdx].addr; addrType = simpleBLEDevList[simpleBLEScanIdx].addrType; simpleBLEState = BLE_STATE_CONNECTING; GAPCentralRole_EstablishLink( DEFAULT_LINK_HIGH_DUTY_CYCLE, DEFAULT_LINK_WHITE_LIST, addrType, peerAddr ); LCD_WRITE_STRING( "Connecting", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( bdAddr2Str( peerAddr ), HAL_LCD_LINE_2 ); } } else if ( simpleBLEState == BLE_STATE_CONNECTING || simpleBLEState == BLE_STATE_CONNECTED ) { // disconnect simpleBLEState = BLE_STATE_DISCONNECTING; gStatus = GAPCentralRole_TerminateLink( simpleBLEConnHandle ); LCD_WRITE_STRING( "Disconnecting", HAL_LCD_LINE_1 ); } }*/ if ( keys & HAL_KEY_DOWN ) { // Start or cancel RSSI polling if ( simpleBLEState == BLE_STATE_CONNECTED ) { if ( !simpleBLERssi ) { simpleBLERssi = TRUE; GAPCentralRole_StartRssi( simpleBLEConnHandle, DEFAULT_RSSI_PERIOD ); } else { simpleBLERssi = FALSE; GAPCentralRole_CancelRssi( simpleBLEConnHandle ); LCD_WRITE_STRING( "RSSI Cancelled", HAL_LCD_LINE_1 ); } } } }
/********************************************************************* * @fn oadManager_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_2 * HAL_KEY_SW_1 * * @return none */ static void oadManager_HandleKeys( uint8 shift, uint8 keys ) { (void)shift; // Intentionally unreferenced parameter if ( keys & HAL_KEY_UP ) // Start or stop discovery { if ( oadManagerState != BLE_STATE_CONNECTED ) { if ( !oadManagerScanning ) { (void)osal_set_event(oadManagerTaskId, DEV_DISCOVERY_EVT); } else { GAPCentralRole_CancelDiscovery(); } } } if ( keys & HAL_KEY_LEFT ) { // Display discovery results if ( !oadManagerScanning && oadManagerScanRes > 0 ) { // Increment index of current result (with wraparound) oadManagerScanIdx++; if ( oadManagerScanIdx >= oadManagerScanRes ) { oadManagerScanIdx = 0; } #if (defined HAL_LCD) && (HAL_LCD == TRUE) LCD_WRITE_STRING_VALUE( "Device", oadManagerScanIdx + 1, 10, HAL_LCD_LINE_1 ); LCD_WRITE_STRING( bdAddr2Str( oadManagerDevList[oadManagerScanIdx].addr ), HAL_LCD_LINE_2 ); #endif } } if ( keys & HAL_KEY_RIGHT ) { } if ( keys & HAL_KEY_CENTER ) { uint8 addrType; uint8 *peerAddr; // Connect or disconnect if ( oadManagerState == BLE_STATE_IDLE ) { // if there is a scan result if ( oadManagerScanRes > 0 ) { if ( oadManagerScanIdx < oadManagerScanRes ) { // connect to current device in scan result peerAddr = oadManagerDevList[oadManagerScanIdx].addr; addrType = oadManagerDevList[oadManagerScanIdx].addrType; oadManagerState = BLE_STATE_CONNECTING; GAPCentralRole_EstablishLink( DEFAULT_LINK_HIGH_DUTY_CYCLE, DEFAULT_LINK_WHITE_LIST, addrType, peerAddr ); #if (defined HAL_LCD) && (HAL_LCD == TRUE) LCD_WRITE_STRING( "Connecting", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( bdAddr2Str( peerAddr ), HAL_LCD_LINE_2 ); } else { LCD_WRITE_STRING( "Select device", HAL_LCD_LINE_3 ); #endif } } } else if ( oadManagerState == BLE_STATE_CONNECTING || oadManagerState == BLE_STATE_CONNECTED ) { // disconnect oadManagerState = BLE_STATE_DISCONNECTING; VOID GAPCentralRole_TerminateLink( oadManagerConnHandle ); #if (defined HAL_LCD) && (HAL_LCD == TRUE) LCD_WRITE_STRING( "Disconnecting", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( "", HAL_LCD_LINE_2 ); LCD_WRITE_STRING( "", HAL_LCD_LINE_3 ); #endif } } if ( keys & HAL_KEY_DOWN ) { #if (defined HAL_LCD) && (HAL_LCD == TRUE) LCD_WRITE_STRING("SBL Mode...", HAL_LCD_LINE_3); #endif EA = 0; sblRun(); EA = 1; #if (defined HAL_LCD) && (HAL_LCD == TRUE) LCD_WRITE_STRING("SBL Done.", HAL_LCD_LINE_3); #endif } }