/******************************************************************************* * Function Name: AppCallBack() ******************************************************************************** * * Summary: * This is an event callback function to receive events from the BLE Component. * * Parameters: * event - the event code * *eventParam - the event parameters * *******************************************************************************/ void AppCallBack(uint32 event, void* eventParam) { #ifdef DEBUG_OUT DebugOut(event, eventParam); #endif switch(event) { case CYBLE_EVT_GAP_DEVICE_DISCONNECTED: Disconnect_LED_Write(LED_ON); mainTimer = 0; case CYBLE_EVT_STACK_ON: heartRateSimulation = DISABLED; /* Put the device into discoverable mode so that remote can search it. */ StartAdvertisement(ADV_STATE_GENERAL); Advertising_LED_Write(LED_ON); advState = ADV_STATE_GENERAL; break; case CYBLE_EVT_GAPP_ADVERTISEMENT_START_STOP: if(CyBle_GetState() == CYBLE_STATE_DISCONNECTED) /* ADV timed out */ { if(advState == ADV_STATE_GENERAL) { Advertising_LED_Write(LED_OFF); CyDelay(100); StartAdvertisement(ADV_STATE_WHITELIST); Advertising_LED_Write(LED_ON); advState = ADV_STATE_WHITELIST; } else { /* No connectionestablished, shut down ADV */ Advertising_LED_Write(LED_OFF); } } break; case CYBLE_EVT_GAP_DEVICE_CONNECTED: Disconnect_LED_Write(LED_OFF); Advertising_LED_Write(LED_OFF); break; default: break; } }
/****************************************************************************** Function Name: main ******************************************************************************* Summary: Main routine of this firmware. Initializes the components once and hanles the BLE events and UART data in a loop forever. Parameters: None. Return: None. ******************************************************************************/ int main() { /* This start-up delay is for the Android app to open when the locator * device is plugged into the phone's USB port so that the first printf * message will not be missed. */ CyDelay(3000); CyGlobalIntEnable; UART_DEB_Start(); /* Start communication component */ printf("PSoC: BLE Find Me Locator is Connected\r\n"); Disconnect_LED_Write(LED_OFF); apiResult = CyBle_Start(AppCallBack); if(apiResult != CYBLE_ERROR_OK) { printf("PSoC: CyBle_Start API Error: 0x%x \r\n", apiResult); } while(1) { /******************************************************************* * Processes all pending BLE events in the stack *******************************************************************/ CyBle_ProcessEvents(); /* Process the received UART data */ ProcessUartData(); } }
void AppCallBack(uint32 event, void* eventParam) { #ifdef DEBUG_OUT DebugOut(event, eventParam); #endif switch(event) { case CYBLE_EVT_GAP_DEVICE_DISCONNECTED: Disconnect_LED_Write(LED_ON); case CYBLE_EVT_STACK_ON: StartScan(CYBLE_UUID_HEART_RATE_SERVICE); break; case CYBLE_EVT_GAP_DEVICE_CONNECTED: /* Send authorization request. */ apiResult = CyBle_GapAuthReq(cyBle_connHandle.bdHandle, &cyBle_authInfo); if(CYBLE_ERROR_OK != apiResult) { printf("CyBle_GapAuthReq API Error: %x \r\n", apiResult); } else { printf("Authentification request is sent \r\n"); } Disconnect_LED_Write(LED_OFF); Scanning_LED_Write(LED_OFF); break; case CYBLE_EVT_GAP_AUTH_COMPLETE: hrsConnHandle.bdHandle = cyBle_connHandle.bdHandle; StartDiscovery(); break; case CYBLE_EVT_GATTC_DISCOVERY_COMPLETE: /* Send request to read the body sensor location char. */ apiResult = HrscReadBodySensorLocation(); if(apiResult != CYBLE_ERROR_OK) { printf("HrscReadBodySensorLocation API Error: %x \r\n", apiResult); } else { printf("Body Sensor Location Read Request is sent \r\n"); } break; case CYBLE_EVT_L2CAP_CONN_PARAM_UPDATE_REQ: printf("CYBLE_EVT_L2CAP_CONN_PARAM_UPDATE_REQ: %x, %x, %x, %x \r\n", ((CYBLE_GAP_CONN_UPDATE_PARAM_T *)eventParam)->connIntvMax, ((CYBLE_GAP_CONN_UPDATE_PARAM_T *)eventParam)->connIntvMin, ((CYBLE_GAP_CONN_UPDATE_PARAM_T *)eventParam)->connLatency, ((CYBLE_GAP_CONN_UPDATE_PARAM_T *)eventParam)->supervisionTO ); /* Accepted = 0x0000, Rejected = 0x0001 */ CyBle_L2capLeConnectionParamUpdateResponse(cyBle_connHandle.bdHandle, 0u); break; default: break; } }
int main() { CYBLE_LP_MODE_T lpMode; CYBLE_BLESS_STATE_T blessState; CYBLE_STACK_LIB_VERSION_T stackVersion; CyGlobalIntEnable; UART_DEB_Start(); /* Start communication component */ printf("BLE Heart Rate Collector Example Project \r\n"); Disconnect_LED_Write(LED_OFF); Scanning_LED_Write(LED_OFF); Notification_LED_Write(LED_OFF); apiResult = CyBle_Start(AppCallBack); if(apiResult != CYBLE_ERROR_OK) { printf("CyBle_Start API Error: 0x%x \r\n", apiResult); } apiResult = CyBle_GetStackLibraryVersion(&stackVersion); if(apiResult != CYBLE_ERROR_OK) { printf("CyBle_GetStackLibraryVersion API Error: 0x%x \r\n", apiResult); } else { printf("Stack Version: %d.%d.%d.%d \r\n", stackVersion.majorVersion, stackVersion.minorVersion, stackVersion.patch, stackVersion.buildNumber); } CyBle_BasRegisterAttrCallback(BasCallBack); HrsInit(); while(1) { if(CyBle_GetState() != CYBLE_STATE_INITIALIZING) { /* Enter DeepSleep mode between connection intervals */ lpMode = CyBle_EnterLPM(CYBLE_BLESS_DEEPSLEEP); CyGlobalIntDisable; blessState = CyBle_GetBleSsState(); if(lpMode == CYBLE_BLESS_DEEPSLEEP) { if(blessState == CYBLE_BLESS_STATE_ECO_ON || blessState == CYBLE_BLESS_STATE_DEEPSLEEP) { /* Put the device into the DeepSleep mode only when all debug information has been sent */ if((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) == 0u) { CySysPmDeepSleep(); } else { CySysPmSleep(); } } } else { if(blessState != CYBLE_BLESS_STATE_EVENT_CLOSE) { CySysPmSleep(); } } CyGlobalIntEnable; /* Handle advertising led blinking */ HandleLeds(); } /* Store bonding data to flash only when all debug information has been sent */ if((cyBle_pendingFlashWrite != 0u) && ((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) == 0u)) { apiResult = CyBle_StoreBondingData(0u); printf("Store bonding data, status: %x \r\n", apiResult); } /******************************************************************* * Processes all pending BLE events in the stack *******************************************************************/ CyBle_ProcessEvents(); } }
void DebugOut(uint32 event, void* eventParam) { switch(event) { case CYBLE_EVT_STACK_ON: printf("EVT_STACK_ON \r\n"); break; case CYBLE_EVT_TIMEOUT: /* 0x01 -> GAP limited discoverable mode timeout. */ /* 0x02 -> GAP pairing process timeout. */ /* 0x03 -> GATT response timeout. */ printf("EVT_TIMEOUT: %d \r\n", *(uint8 *)eventParam); break; case CYBLE_EVT_HARDWARE_ERROR: /* This event indicates that some internal HW error has occurred. */ printf("EVT_HARDWARE_ERROR \r\n"); break; case CYBLE_EVT_HCI_STATUS: printf("EVT_HCI_STATUS \r\n"); break; /********************************************************** * GAP Events ***********************************************************/ case CYBLE_EVT_GAP_AUTH_REQ: printf("EVT_GAP_AUTH_REQ"); break; case CYBLE_EVT_GAP_PASSKEY_ENTRY_REQUEST: printf("EVT_GAP_PASSKEY_ENTRY_REQUEST"); break; case CYBLE_EVT_GAP_PASSKEY_DISPLAY_REQUEST: printf("EVT_GAP_PASSKEY_DISPLAY_REQUEST: %d \r\n", (int) (*(CYBLE_GAP_PASSKEY_DISP_INFO_T *)eventParam).passkey); break; case CYBLE_EVT_GAP_AUTH_FAILED: printf("EVT_GAP_AUTH_FAILED: %x \r\n", *(uint8 *)eventParam); break; case CYBLE_EVT_GAP_DEVICE_CONNECTED: printf("EVT_GAP_DEVICE_CONNECTED: %x \r\n", cyBle_connHandle.bdHandle); break; case CYBLE_EVT_GAPC_CONNECTION_UPDATE_COMPLETE: printf("EVT_GAPC_CONNECTION_UPDATE_COMPLETE \r\n"); break; case CYBLE_EVT_GAP_DEVICE_DISCONNECTED: printf("EVT_GAP_DEVICE_DISCONNECTED \r\n"); Disconnect_LED_Write(LED_ON); break; case CYBLE_EVT_GAP_AUTH_COMPLETE: printf("EVT_GAP_AUTH_COMPLETE: security:%x, bonding:%x, ekeySize:%x, authErr %x \r\n", ((CYBLE_GAP_AUTH_INFO_T *)eventParam)->security, ((CYBLE_GAP_AUTH_INFO_T *)eventParam)->bonding, ((CYBLE_GAP_AUTH_INFO_T *)eventParam)->ekeySize, ((CYBLE_GAP_AUTH_INFO_T *)eventParam)->authErr); break; case CYBLE_EVT_GAP_ENCRYPT_CHANGE: printf("EVT_GAP_ENCRYPT_CHANGE: %d \r\n", *(uint8 *)eventParam); break; #if 0 case CYBLE_EVT_GAP_RESOLVE_PVT_ADDR_VERIFY_CNF: printf("EVT_GAP_RESOLVE_PVT_ADDR_VERIFY_CNF \r\n"); break; #endif /********************************************************** * GATT Events ***********************************************************/ case CYBLE_EVT_GATTC_ERROR_RSP: printf("EVT_GATTC_ERROR_RSP: opcode: "); switch(((CYBLE_GATTC_ERR_RSP_PARAM_T *)eventParam)->opCode) { case CYBLE_GATT_FIND_INFO_REQ: printf("FIND_INFO_REQ"); break; case CYBLE_GATT_READ_BY_TYPE_REQ: printf("READ_BY_TYPE_REQ"); break; case CYBLE_GATT_READ_BY_GROUP_REQ: printf("READ_BY_GROUP_REQ"); break; default: printf("%x", ((CYBLE_GATTC_ERR_RSP_PARAM_T *)eventParam)->opCode); break; } printf(", handle: %x, ", ((CYBLE_GATTC_ERR_RSP_PARAM_T *)eventParam)->attrHandle); printf("errorcode: "); switch(((CYBLE_GATTC_ERR_RSP_PARAM_T *)eventParam)->errorCode) { case CYBLE_GATT_ERR_ATTRIBUTE_NOT_FOUND: printf("ATTRIBUTE_NOT_FOUND"); break; default: printf("%x", ((CYBLE_GATTC_ERR_RSP_PARAM_T *)eventParam)->errorCode); break; } printf("\r\n"); break; case CYBLE_EVT_GATT_CONNECT_IND: printf("EVT_GATT_CONNECT_IND: attId %x, bdHandle %x \r\n", ((CYBLE_CONN_HANDLE_T *)eventParam)->attId, ((CYBLE_CONN_HANDLE_T *)eventParam)->bdHandle); break; case CYBLE_EVT_GATT_DISCONNECT_IND: printf("EVT_GATT_DISCONNECT_IND \r\n"); break; /********************************************************** * L2CAP Events ***********************************************************/ case CYBLE_EVT_L2CAP_CONN_PARAM_UPDATE_REQ: printf("EVT_L2CAP_CONN_PARAM_UPDATE_REQ \r\n"); break; /********************************************************** * Debug Events ***********************************************************/ case CYBLE_DEBUG_EVT_BLESS_INT: break; default: #if(CYBLE_GATT_ROLE_SERVER) ServerDebugOut(event, eventParam); #endif /* (CYBLE_GATT_ROLE_SERVER) */ #if(CYBLE_GATT_ROLE_CLIENT) ClientDebugOut(event, eventParam); #endif /* (CYBLE_GATT_ROLE_SERVER) */ break; } }
/******************************************************************************* * Function Name: AppCallBack() ******************************************************************************** * * Summary: * This is an event callback function to receive events from the BLE Component. * * Parameters: * event - the event code * *eventParam - the event parameters * *******************************************************************************/ void AppCallback(uint32 event, void* eventParam) { CYBLE_API_RESULT_T apiResult; CYBLE_GAP_BD_ADDR_T localAddr; CYBLE_GAP_AUTH_INFO_T *authInfo; uint8 i; switch (event) { /********************************************************** * General Events ***********************************************************/ case CYBLE_EVT_STACK_ON: /* This event received when component is Started */ /* Enter into discoverable mode so that remote can search it. */ apiResult = CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST); if(apiResult != CYBLE_ERROR_OK) { DBG_PRINTF("StartAdvertisement API Error: %d \r\n", apiResult); } DBG_PRINTF("Bluetooth On, StartAdvertisement with addr: "); localAddr.type = 0u; CyBle_GetDeviceAddress(&localAddr); for(i = CYBLE_GAP_BD_ADDR_SIZE; i > 0u; i--) { DBG_PRINTF("%2.2x", localAddr.bdAddr[i-1]); } DBG_PRINTF("\r\n"); break; case CYBLE_EVT_TIMEOUT: DBG_PRINTF("CYBLE_EVT_TIMEOUT: %x \r\n", *(CYBLE_TO_REASON_CODE_T *)eventParam); break; case CYBLE_EVT_HARDWARE_ERROR: /* This event indicates that some internal HW error has occurred. */ DBG_PRINTF("Hardware Error \r\n"); break; case CYBLE_EVT_HCI_STATUS: DBG_PRINTF("CYBLE_EVT_HCI_STATUS: %x \r\n", *(uint8 *)eventParam); break; /********************************************************** * GAP Events ***********************************************************/ case CYBLE_EVT_GAP_AUTH_REQ: DBG_PRINTF("CYBLE_EVT_AUTH_REQ: security=%x, bonding=%x, ekeySize=%x, err=%x \r\n", (*(CYBLE_GAP_AUTH_INFO_T *)eventParam).security, (*(CYBLE_GAP_AUTH_INFO_T *)eventParam).bonding, (*(CYBLE_GAP_AUTH_INFO_T *)eventParam).ekeySize, (*(CYBLE_GAP_AUTH_INFO_T *)eventParam).authErr); break; case CYBLE_EVT_GAP_PASSKEY_ENTRY_REQUEST: DBG_PRINTF("CYBLE_EVT_PASSKEY_ENTRY_REQUEST \r\n"); break; case CYBLE_EVT_GAP_PASSKEY_DISPLAY_REQUEST: DBG_PRINTF("CYBLE_EVT_PASSKEY_DISPLAY_REQUEST %6.6ld \r\n", *(uint32 *)eventParam); break; case CYBLE_EVT_GAP_AUTH_COMPLETE: authInfo = (CYBLE_GAP_AUTH_INFO_T *)eventParam; (void)authInfo; DBG_PRINTF("AUTH_COMPLETE: security:%x, bonding:%x, ekeySize:%x, authErr %x \r\n", authInfo->security, authInfo->bonding, authInfo->ekeySize, authInfo->authErr); break; case CYBLE_EVT_GAP_AUTH_FAILED: DBG_PRINTF("CYBLE_EVT_AUTH_FAILED: %x \r\n", *(uint8 *)eventParam); break; case CYBLE_EVT_GAPP_ADVERTISEMENT_START_STOP: DBG_PRINTF("CYBLE_EVT_GAPP_ADVERTISEMENT_START_STOP, state: %x\r\n", CyBle_GetState()); if(CYBLE_STATE_DISCONNECTED == CyBle_GetState()) { /* Fast and slow advertising period complete, go to low power * mode (Hibernate mode) and wait for an external * user event to wake up the device again */ DBG_PRINTF("Hibernate \r\n"); Advertising_LED_Write(LED_OFF); Disconnect_LED_Write(LED_ON); #if (DEBUG_UART_ENABLED == ENABLED) while((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) != 0); #endif /* (DEBUG_UART_ENABLED == ENABLED) */ SW2_ClearInterrupt(); Wakeup_Interrupt_ClearPending(); Wakeup_Interrupt_Start(); CySysPmHibernate(); } break; case CYBLE_EVT_GAP_DEVICE_CONNECTED: DBG_PRINTF("CYBLE_EVT_GAP_DEVICE_CONNECTED: %x \r\n", *(uint8 *)eventParam); Advertising_LED_Write(LED_OFF); break; case CYBLE_EVT_GAP_DEVICE_DISCONNECTED: DBG_PRINTF("CYBLE_EVT_GAP_DEVICE_DISCONNECTED\r\n"); /* Put the device to discoverable mode so that remote can search it. */ apiResult = CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST); if(apiResult != CYBLE_ERROR_OK) { DBG_PRINTF("StartAdvertisement API Error: %x \r\n", apiResult); } break; case CYBLE_EVT_GAP_ENCRYPT_CHANGE: DBG_PRINTF("ENCRYPT_CHANGE: %x \r\n", *(uint8 *)eventParam); break; case CYBLE_EVT_GAPC_CONNECTION_UPDATE_COMPLETE: DBG_PRINTF("CYBLE_EVT_CONNECTION_UPDATE_COMPLETE: %x \r\n", *(uint8 *)eventParam); break; case CYBLE_EVT_GAP_KEYINFO_EXCHNGE_CMPLT: DBG_PRINTF("CYBLE_EVT_GAP_KEYINFO_EXCHNGE_CMPLT \r\n"); break; /********************************************************** * GATT Events ***********************************************************/ case CYBLE_EVT_GATT_CONNECT_IND: DBG_PRINTF("CYBLE_EVT_GATT_CONNECT_IND: %x, %x \r\n", cyBle_connHandle.attId, cyBle_connHandle.bdHandle); break; case CYBLE_EVT_GATT_DISCONNECT_IND: DBG_PRINTF("CYBLE_EVT_GATT_DISCONNECT_IND \r\n"); break; case CYBLE_EVT_GATTS_WRITE_REQ: DBG_PRINTF("CYBLE_EVT_GATT_WRITE_REQ: %x = ",((CYBLE_GATTS_WRITE_REQ_PARAM_T *)eventParam)->handleValPair.attrHandle); ShowValue(&((CYBLE_GATTS_WRITE_REQ_PARAM_T *)eventParam)->handleValPair.value); (void)CyBle_GattsWriteRsp(((CYBLE_GATTS_WRITE_REQ_PARAM_T *)eventParam)->connHandle); break; case CYBLE_EVT_GATTS_INDICATION_ENABLED: DBG_PRINTF("CYBLE_EVT_GATTS_INDICATION_ENABLED \r\n"); break; case CYBLE_EVT_GATTS_INDICATION_DISABLED: DBG_PRINTF("CYBLE_EVT_GATTS_INDICATION_DISABLED \r\n"); break; case CYBLE_EVT_GATTS_READ_CHAR_VAL_ACCESS_REQ: /* Triggered on server side when client sends read request and when * characteristic has CYBLE_GATT_DB_ATTR_CHAR_VAL_RD_EVENT property set. * This event could be ignored by application unless it need to response * by error response which needs to be set in gattErrorCode field of * event parameter. */ DBG_PRINTF("CYBLE_EVT_GATTS_READ_CHAR_VAL_ACCESS_REQ: handle: %x \r\n", ((CYBLE_GATTS_CHAR_VAL_READ_REQ_T *)eventParam)->attrHandle); break; /********************************************************** * Other Events ***********************************************************/ case CYBLE_EVT_PENDING_FLASH_WRITE: /* Inform application that flash write is pending. Stack internal data * structures are modified and require to be stored in Flash using * CyBle_StoreBondingData() */ DBG_PRINTF("CYBLE_EVT_PENDING_FLASH_WRITE\r\n"); break; default: DBG_PRINTF("OTHER event: %lx \r\n", event); break; } }
/******************************************************************************* * Function Name: main() ******************************************************************************** * Summary: * Main function for the project. * * Parameters: * None * * Return: * None * * Theory: * The function starts BLE and UART components. * This function process all BLE events and also implements the low power * functionality. * *******************************************************************************/ int main() { CyGlobalIntEnable; #if (DEBUG_UART_ENABLED == ENABLED) UART_DEB_Start(); #endif /* (DEBUG_UART_ENABLED == ENABLED) */ DBG_PRINTF("BLE Cycling Sensor Example Project \r\n"); Disconnect_LED_Write(LED_OFF); Advertising_LED_Write(LED_OFF); CyBle_Start(AppCallback); /* Start CYBLE component and register generic event handler */ CyBle_Start(AppCallback); /* Register service specific callback functions */ CscsInit(); CpsInit(); WDT_Start(); /*************************************************************************** * Main polling loop ***************************************************************************/ while(1) { /* CyBle_ProcessEvents() allows BLE stack to process pending events */ CyBle_ProcessEvents(); /* To achieve low power in the device */ LowPowerImplementation(); /*********************************************************************** * Wait for connection established with Central device ***********************************************************************/ if(CyBle_GetState() == CYBLE_STATE_CONNECTED) { /******************************************************************* * Periodically simulate Cycling characteristics and send * results to the Client *******************************************************************/ if(mainTimer != 0u) { mainTimer = 0u; SimulateCyclingPower(); CyBle_ProcessEvents(); SimulateCyclingSpeed(); } /* Store bounding data to flash only when all debug information has been sent */ #if (DEBUG_UART_ENABLED == ENABLED) if((cyBle_pendingFlashWrite != 0u) && ((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) == 0u)) #else if(cyBle_pendingFlashWrite != 0u) #endif /* (DEBUG_UART_ENABLED == ENABLED) */ { CYBLE_API_RESULT_T apiResult; apiResult = CyBle_StoreBondingData(0u); (void)apiResult; DBG_PRINTF("Store bonding data, status: %x \r\n", apiResult); } } } }
/****************************************************************************** Function Name: AppCallBack ******************************************************************************* Summary: Handles the events from the BLE stack Parameters: eventCode: the event code *eventParam: the event parameters Return: None. ******************************************************************************/ void AppCallBack(uint32 event, void* eventParam) { int i; switch(event) { case CYBLE_EVT_STACK_ON: case CYBLE_EVT_GAP_DEVICE_DISCONNECTED: Disconnect_LED_Write(LED_ON); break; case CYBLE_EVT_GAP_DEVICE_CONNECTED: /* Indicate to stack that the OOB data is available. OOB data needs * to be set before initiating the auth (pair) request. */ if(CyBle_GapSetOobData(cyBle_connHandle.bdHandle, CYBLE_GAP_OOB_ENABLE, securityKey, NULL, NULL) != CYBLE_ERROR_OK) { printf("PSoC: Error in Setting OOB Data \r\n"); } else { printf("PSoC: OOB Data is set with key:"); for(i = 0; i < 16; i++) { printf("%2.2x", securityKey[i]); } printf("\r\n"); } /* Send authorization request. */ apiResult = CyBle_GapAuthReq(cyBle_connHandle.bdHandle, &cyBle_authInfo); if(CYBLE_ERROR_OK != apiResult) { printf("PSoC: CyBle_GapAuthReq API Error: %x \r\n", apiResult); } else { printf("PSoC: Pairing is initiated \r\n"); Disconnect_LED_Write(LED_OFF); } break; case CYBLE_EVT_GAP_AUTH_COMPLETE: printf("PSoC: ***** Pairing is Successful! ***** \r\n"); break; case CYBLE_EVT_GAP_AUTH_FAILED: printf("PSoC: EVT_GAP_AUTH_FAILED, reason: "); switch(*(CYBLE_GAP_AUTH_FAILED_REASON_T *)eventParam) { case CYBLE_GAP_AUTH_ERROR_CONFIRM_VALUE_NOT_MATCH: printf("CONFIRM_VALUE_NOT_MATCH\r\n"); break; case CYBLE_GAP_AUTH_ERROR_INSUFFICIENT_ENCRYPTION_KEY_SIZE: printf("INSUFFICIENT_ENCRYPTION_KEY_SIZE\r\n"); break; case CYBLE_GAP_AUTH_ERROR_UNSPECIFIED_REASON: printf("UNSPECIFIED_REASON\r\n"); break; case CYBLE_GAP_AUTH_ERROR_AUTHENTICATION_TIMEOUT: printf("AUTHENTICATION_TIMEOUT\r\n"); break; default: printf("0x%x \r\n", *(CYBLE_GAP_AUTH_FAILED_REASON_T *)eventParam); break; } break; case CYBLE_EVT_L2CAP_CONN_PARAM_UPDATE_REQ: /* Accepted = 0x0000, Rejected = 0x0001 */ CyBle_L2capLeConnectionParamUpdateResponse(cyBle_connHandle.bdHandle, 0u); break; default: break; } }
*******************************************************************************/int main() { CyGlobalIntEnable; #if (DEBUG_UART_ENABLED == ENABLED) UART_DEB_Start(); #endif /* (DEBUG_UART_ENABLED == ENABLED) */ DBG_PRINTF("BLE HID Keyboard Example Project \r\n"); Disconnect_LED_Write(LED_OFF); Advertising_LED_Write(LED_OFF); CapsLock_LED_Write(LED_OFF); /* Start CYBLE component and register generic event handler */ CyBle_Start(AppCallBack); WDT_Start(); #if (BAS_MEASURE_ENABLE != 0) ADC_Start(); #endif /* BAS_MEASURE_ENABLE != 0 */ while(1) { /* CyBle_ProcessEvents() allows BLE stack to process pending events */ CyBle_ProcessEvents(); /* To achieve low power in the device */ LowPowerImplementation(); if((CyBle_GetState() == CYBLE_STATE_CONNECTED) && (suspend != CYBLE_HIDS_CP_SUSPEND)) { if(mainTimer != 0u) { mainTimer = 0u; #if (BAS_SIMULATE_ENABLE != 0) SimulateBattery(); CyBle_ProcessEvents(); #endif /* BAS_SIMULATE_ENABLE != 0 */ #if (BAS_MEASURE_ENABLE != 0) MeasureBattery(); CyBle_ProcessEvents(); #endif /* BAS_MEASURE_ENABLE != 0 */ if(keyboardSimulation == ENABLED) { SimulateKeyboard(); } } /* Store bonding data to flash only when all debug information has been sent */ #if(CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES) #if (DEBUG_UART_ENABLED == ENABLED) if((cyBle_pendingFlashWrite != 0u) && ((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) == 0u)) #else if(cyBle_pendingFlashWrite != 0u) #endif /* (DEBUG_UART_ENABLED == ENABLED) */ { CYBLE_API_RESULT_T apiResult; apiResult = CyBle_StoreBondingData(0u); (void)apiResult; DBG_PRINTF("Store bonding data, status: %x \r\n", apiResult); } #endif /* CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES */ } } }
int main() { CYBLE_STACK_LIB_VERSION_T stackVersion; CyGlobalIntEnable; UART_DEB_Start(); /* Start communication component */ printf("BLE Heart Rate Sensor Example Project \r\n"); Disconnect_LED_Write(LED_OFF); Advertising_LED_Write(LED_OFF); /* Start CYBLE component and register generic event handler */ apiResult = CyBle_Start(AppCallBack); if(apiResult != CYBLE_ERROR_OK) { printf("CyBle_Start API Error: %x \r\n", apiResult); } apiResult = CyBle_GetStackLibraryVersion(&stackVersion); if(apiResult != CYBLE_ERROR_OK) { printf("CyBle_GetStackLibraryVersion API Error: 0x%x \r\n", apiResult); } else { printf("Stack Version: %d.%d.%d.%d \r\n", stackVersion.majorVersion, stackVersion.minorVersion, stackVersion.patch, stackVersion.buildNumber); } /* Services initialization */ HrsInit(); WDT_Start(); /*************************************************************************** * Main polling loop ***************************************************************************/ while(1) { /*********************************************************************** * Wait for connection established with Central device ***********************************************************************/ if(CyBle_GetState() == CYBLE_STATE_CONNECTED) { /******************************************************************* * Periodically simulate heart rate and measure a battery level * and send results to the Client *******************************************************************/ if(mainTimer != 0u) { mainTimer = 0u; if(heartRateSimulation == ENABLED) { SimulateHeartRate(); } } } /******************************************************************* * Process all pending BLE events in the stack *******************************************************************/ CyBle_ProcessEvents(); } }
int main() { CYBLE_LP_MODE_T lpMode; CYBLE_BLESS_STATE_T blessState; CyGlobalIntEnable; UART_DEB_Start(); /* Start communication component */ printf("BLE Secure Connection Example Project \r\n"); Disconnect_LED_Write(LED_OFF); Advertising_LED_Write(LED_OFF); /* Start CYBLE component and register generic event handler */ apiResult = CyBle_Start(AppCallBack); if(apiResult != CYBLE_ERROR_OK) { printf("CyBle_Start API Error: %x \r\n", apiResult); } /* Services initialization */ HrsInit(); /*************************************************************************** * Main polling loop ***************************************************************************/ while(1) { if(CyBle_GetState() != CYBLE_STATE_INITIALIZING) { /* Enter DeepSleep mode between connection intervals */ lpMode = CyBle_EnterLPM(CYBLE_BLESS_DEEPSLEEP); CyGlobalIntDisable; blessState = CyBle_GetBleSsState(); if(lpMode == CYBLE_BLESS_DEEPSLEEP) { if(blessState == CYBLE_BLESS_STATE_ECO_ON || blessState == CYBLE_BLESS_STATE_DEEPSLEEP) { /* Put the device into the Deep Sleep mode only when all debug information has been sent */ if((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) == 0u) { CySysPmDeepSleep(); } else { CySysPmSleep(); } } } else { if(blessState != CYBLE_BLESS_STATE_EVENT_CLOSE) { CySysPmSleep(); } } CyGlobalIntEnable; } /*********************************************************************** * Wait for connection established with Central device ***********************************************************************/ if(CyBle_GetState() == CYBLE_STATE_CONNECTED) { /******************************************************************* * Periodically simulates heart beat and sends the results to the Client *******************************************************************/ mainTimer++; if(mainTimer == MAIN_LOOP_SIMULATION_THRESHOLD) { mainTimer = 0u; if(heartRateSimulation == ENABLED) { SimulateHeartRate(); CyBle_ProcessEvents(); } } else if((cyBle_pendingFlashWrite != 0u) && ((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) == 0u)) { apiResult = CyBle_StoreBondingData(0u); printf("Store bonding data, status: %x \r\n", apiResult); } else { /* nothing else */ } } /******************************************************************* * Process all pending BLE events in the stack *******************************************************************/ CyBle_ProcessEvents(); } }