/********************************************************************* * * @fn hidappHandleKey * * @brief Handle service for keys * * @param keys - key that was pressed (i.e. the scanned row/col index) * state - shifted * * @return void */ static void hidappHandleKeys( uint8 keys, uint8 state ) { // Unused arguments (void) state; if (keys & HAL_KEY_SW_1) { // If bonds exist, erase all of them if ( ( hidappBondCount() > 0 ) && ( hidappBLEState != BLE_STATE_CONNECTED ) ) { if ( hidappBLEState == BLE_STATE_CONNECTING ) { hidappBLEState = BLE_STATE_DISCONNECTING; VOID GAPCentralRole_TerminateLink( GAP_CONNHANDLE_INIT ); } VOID GAPBondMgr_SetParameter( GAPBOND_ERASE_ALLBONDS, 0, NULL ); } } if (keys & HAL_KEY_SW_2) { if ( hidappBLEState == BLE_STATE_CONNECTED ) { hidappBLEState = BLE_STATE_DISCONNECTING; VOID GAPCentralRole_TerminateLink( connHandle ); } else if ( hidappBLEState == BLE_STATE_IDLE ) { #if defined ( NANO_DONGLE ) HalLedSet( HAL_LED_2, HAL_LED_MODE_OFF ); // red led // Notify our task to start initial discovey osal_set_event( hidappTaskId, HIDAPP_EVT_START_DISCOVERY ); #endif // #if defined ( NANO_DONGLE ) } } }
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 glucCollCentral_taskFxn * * @brief Application task entry point for the Glucose collector. * * @param a0, a1 - not used * * @return none */ static void glucCollCentral_taskFxn(UArg a0, UArg a1) { // Initialize application glucCollCentral_Init(); // Application main loop for (;;) { // Waits for a signal to the semaphore associated with the calling thread. // Note that the semaphore associated with a thread is signaled when a // message is queued to the message receive queue of the thread or when // ICall_signal() function is called onto the semaphore. ICall_Errno errno = ICall_wait(ICALL_TIMEOUT_FOREVER); if (errno == ICALL_ERRNO_SUCCESS) { ICall_EntityID dest; ICall_ServiceEnum src; ICall_HciExtEvt *pMsg = NULL; if (ICall_fetchServiceMsg(&src, &dest, (void **)&pMsg) == ICALL_ERRNO_SUCCESS) { if ((src == ICALL_SERVICE_CLASS_BLE) && (dest == selfEntity)) { // Process inter-task message glucCollCentral_processStackMsg((ICall_Hdr *)pMsg); } if (pMsg) { ICall_freeMsg(pMsg); } } // If RTOS queue is not empty, process app message. while (!Queue_empty(appMsgQueue)) { glucCollEvt_t *pMsg = (glucCollEvt_t *)Util_dequeueMsg(appMsgQueue); if (pMsg) { // Process message. glucCollCentral_processAppMsg(pMsg); // Free the space from the message. ICall_free(pMsg); } } if (events) { if (events & GLUCOLL_PROCEDURE_TIMEOUT_EVT) { events &= ~GLUCOLL_PROCEDURE_TIMEOUT_EVT; if (glucCollState == BLE_STATE_CONNECTED) { // disconnect glucCollState = BLE_STATE_DISCONNECTING; GAPCentralRole_TerminateLink(glucCollConnHandle); LCD_WRITE_STRING("Timeout", LCD_PAGE0); LCD_WRITE_STRING("", LCD_PAGE1); LCD_WRITE_STRING("", LCD_PAGE2); } } if (events & GLUCOLL_START_DISCOVERY_EVT) { events &= ~GLUCOLL_START_DISCOVERY_EVT; if (glucCollPairingStarted) { // Postpone discovery until pairing completes glucCollDiscPostponed = TRUE; } else { glucCollCentral_startDiscovery(); } } } } } }
/********************************************************************* * @fn GlucColl_ProcessEvent * * @brief Glucose Collector Application Task event processor. This function * is called to process all events for the task. Events * include timers, messages and any other user defined events. * * @param task_id - The OSAL assigned task ID. * @param events - events to process. This is a bit map and can * contain more than one event. * * @return events not processed */ uint16 GlucColl_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( glucCollTaskId )) != NULL ) { glucCollCentral_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 & PROCEDURE_TIMEOUT_EVT ) { if ( glucCollState == BLE_STATE_CONNECTED ) { // disconnect glucCollState = BLE_STATE_DISCONNECTING; GAPCentralRole_TerminateLink( glucCollConnHandle ); LCD_WRITE_STRING( "Timeout", HAL_LCD_LINE_1 ); LCD_WRITE_STRING( "", HAL_LCD_LINE_2 ); LCD_WRITE_STRING( "", HAL_LCD_LINE_3 ); } // return unprocessed events return ( events ^ PROCEDURE_TIMEOUT_EVT ); } if ( events & START_DEVICE_EVT ) { // Start the Device VOID GAPCentralRole_StartDevice( (gapCentralRoleCB_t *) &glucCollRoleCB ); // Register with bond manager after starting device GAPBondMgr_Register( (gapBondCBs_t *) &glucCollBondCB ); return ( events ^ START_DEVICE_EVT ); } if ( events & START_DISCOVERY_EVT ) { if ( glucCollPairingStarted ) { // Postpone discovery until pairing completes glucCollDiscPostponed = TRUE; } else { glucCollCentralStartDiscovery( ); } return ( events ^ START_DISCOVERY_EVT ); } // Discard unknown events return 0; }
/************************************************************************************************ * @fn simpleBLECentralProcessGATTMsg * * @brief Process GATT messages * * @return none ************************************************************************************************/ void simpleBLECentralProcessGATTMsg( gattMsgEvent_t *pMsg ){ switch(pMsg->method){ case ATT_READ_RSP:{ uint8 valueRead = pMsg->msg.readRsp.value[0]; LCDPrintText("Read rsp:",valueRead,PRINT_VALUE); //GAPCentralRole_TerminateLink( connHandle ); break; } case ATT_WRITE_RSP:{ if(CharSendingFlag ==1){ //to filt out the last rep message! Z_DelayMS(50); ClientWriteValue(); } break; } case ATT_FIND_BY_TYPE_VALUE_RSP:{ if(pMsg->msg.findByTypeValueRsp.numInfo > 0 ){ //LCDPrintText("Found group h",0,PRINT_STRING); HandleRangeStart = pMsg->msg.findByTypeValueRsp.handlesInfo[0].handle; //Found attribute handle HandleRangeEnd = pMsg->msg.findByTypeValueRsp.handlesInfo[0].grpEndHandle; //Group end handle } if(pMsg->hdr.status == bleProcedureComplete) if( HandleRangeEnd != 0 ){ attReadByTypeReq_t req; req.startHandle = HandleRangeStart; req.endHandle = HandleRangeEnd; req.type.len = ATT_BT_UUID_SIZE; req.type.uuid[0] = LO_UINT16(BLEChar.uuid); req.type.uuid[1] = HI_UINT16(BLEChar.uuid); uint8 return_status; //LCDPrintText("seach attrib h",0,PRINT_STRING); if(return_status = GATT_ReadUsingCharUUID(CurrentConnectionInfo.Handle, &req, MasterSlaveSwitchTaskID ))// Discover characteristic LCDPrintText("ReadUsingChar error",return_status,PRINT_VALUE); } else LCDPrintText("Handle range error",1,PRINT_STRING); break; } case ATT_READ_BY_TYPE_RSP:{ if(pMsg->msg.readByTypeRsp.numPairs > 0 ){ uint16 temp_handle = BUILD_UINT16( pMsg->msg.readByTypeRsp.dataList[0], pMsg->msg.readByTypeRsp.dataList[1] ); if((temp_handle == BLEChar.handle) && (BLEChar.handle != 0)) {CharHandleSearchFlag = 0; //HalLcdWriteStringValue("HANDLE SA",temp_handle,10,HAL_LCD_LINE_5); } else {BLEChar.handle= temp_handle; //HalLcdWriteStringValue("HANDLE DE",temp_handle,10,HAL_LCD_LINE_6); } } if(pMsg->hdr.status == bleProcedureComplete) if(BLEChar.handle != 0){ ClientWriteValue(); CharSendingFlag =1; //LCDPrintText("finished attrib h",0,PRINT_STRING); } else LCDPrintText("Handle value error",1,PRINT_STRING); break; } case ATT_HANDLE_VALUE_NOTI:{ //one transfer last 1s the most ,otherwise watchdog will reset the device //WD_KICK(); if(pMsg->msg.handleValueNoti.len != MAC_LEN){ LCDPrintText("error noti lenth:",pMsg->msg.handleValueNoti.len,PRINT_VALUE); break; } osal_memcpy(mac_buffer[Buffer_Top],pMsg->msg.handleValueNoti.value,pMsg->msg.handleValueNoti.len); if(TRUE == osal_memcmp(mac_buffer[Buffer_Top], mac_buffer[Buffer_Top+1] ,MAC_LEN)){ GAPCentralRole_TerminateLink( CurrentConnectionInfo.Handle ); uint32 timeout_value = 50; //osal_start_timerEx(MasterSlaveSwitchTaskID, CHECH_LINK_EVT, timeout_value); break; }//wait for conn timeout if(TRUE == MacBufferSearch(mac_buffer[Buffer_Top])){ //LCDPrintText("valid value:",mac_buffer[Buffer_Top][0],PRINT_VALUE); Buffer_Top++; } else osal_memset(mac_buffer[Buffer_Top], 0, MAC_LEN); break; } case ATT_ERROR_RSP:{ if(pMsg->msg.errorRsp.reqOpcode == ATT_READ_REQ){ uint8 status = pMsg->msg.errorRsp.errCode; LCDPrintText("Read Error",status,PRINT_VALUE); } else if(pMsg->msg.errorRsp.reqOpcode == ATT_WRITE_REQ){ uint8 status = pMsg->msg.errorRsp.errCode; LCDPrintText("Write Error",status,PRINT_VALUE); } else if(pMsg->msg.errorRsp.reqOpcode == ATT_FIND_BY_TYPE_VALUE_REQ) LCDPrintText("service find error",1,PRINT_STRING); else if(pMsg->msg.errorRsp.reqOpcode == ATT_READ_BY_TYPE_REQ) LCDPrintText("charac find error",1,PRINT_STRING); break; } default: LCDPrintText("unknow gatt message",1,PRINT_STRING); break; } }
/********************************************************************* * @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 } }