/****************************************************************************** ##Function Name: CyBle_GattsWriteEventHandler ******************************************************************************* Summary: Handles the Write Request Event for GATT service. Parameters: *eventParam: The pointer to the data structure specified by the event. Return: * CYBLE_GATT_ERR_CODE_T: An API result returns one of the following status values * CYBLE_GATT_ERR_NONE - Write is successful. ******************************************************************************/ CYBLE_GATT_ERR_CODE_T CyBle_GattsWriteEventHandler(CYBLE_GATTS_WRITE_REQ_PARAM_T *eventParam) { CYBLE_GATT_ERR_CODE_T gattErr = CYBLE_GATT_ERR_NONE; /* Client Characteristic Configuration descriptor write request */ if(eventParam->handleValPair.attrHandle == cyBle_gatts.cccdHandle) { /* Store value to database */ gattErr = CyBle_GattsWriteAttributeValue(&eventParam->handleValPair, 0u, &eventParam->connHandle, CYBLE_GATT_DB_PEER_INITIATED); if(CYBLE_GATT_ERR_NONE == gattErr) { if(CYBLE_IS_INDICATION_ENABLED_IN_PTR(eventParam->handleValPair.value.val)) { CyBle_ApplCallback((uint32)CYBLE_EVT_GATTS_INDICATION_ENABLED, eventParam); } else { CyBle_ApplCallback((uint32)CYBLE_EVT_GATTS_INDICATION_DISABLED, eventParam); } } cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK; } return (gattErr); }
/****************************************************************************** ##Function Name: CyBle_BcscDiscoverCharDescriptorsEventHandler ******************************************************************************* Summary: This function is called on receiving a CYBLE_EVT_GATTC_FIND_INFO_RSP event. Based on the descriptor UUID, an appropriate data structure is populated using the data received as part of the callback. Parameters: *discDescrInfo: The pointer to a descriptor information structure. Return: None. ******************************************************************************/ void CyBle_BcscDiscoverCharDescriptorsEventHandler(CYBLE_DISC_DESCR_INFO_T *discDescrInfo) { CYBLE_BCS_DESCR_INDEX_T locDescIndex; switch(discDescrInfo->uuid.uuid16) { case CYBLE_UUID_CHAR_CLIENT_CONFIG: locDescIndex = CYBLE_BCS_CCCD; break; default: /* Not supported descriptor */ locDescIndex = CYBLE_BCS_DESCR_COUNT; break; } if(locDescIndex < CYBLE_BCS_DESCR_COUNT) { if(cyBle_bcsc.bodyCompositionMeasurementCccdHandle == CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE) { cyBle_bcsc.bodyCompositionMeasurementCccdHandle = discDescrInfo->descrHandle; } else /* Duplication of descriptor */ { CyBle_ApplCallback(CYBLE_EVT_GATTC_DESCR_DUPLICATION, &discDescrInfo->uuid); } } }
/****************************************************************************** ##Function Name: CyBle_HrscDiscoverCharacteristicsEventHandler ******************************************************************************* Summary: This function is called on receiving a CYBLE_EVT_GATTC_READ_BY_TYPE_RSP event. Based on the service UUID, an appropriate data structure is populated using the data received as part of the callback. Parameters: *discCharInfo: The pointer to a characteristic information structure. Return: None ******************************************************************************/ void CyBle_HrscDiscoverCharacteristicsEventHandler(CYBLE_DISC_CHAR_INFO_T *discCharInfo) { /* Heart Rate Service characteristics UUIDs */ static const CYBLE_UUID16 cyBle_hrscCharUuid[CYBLE_HRS_CHAR_COUNT] = { CYBLE_UUID_CHAR_HR_MSRMT, CYBLE_UUID_CHAR_BODY_SENSOR_LOC, CYBLE_UUID_CHAR_HR_CNTRL_POINT }; uint8 i; for(i = 0u; i < (uint8) CYBLE_HRS_CHAR_COUNT; i++) { if(cyBle_hrscCharUuid[i] == discCharInfo->uuid.uuid16) { if(cyBle_hrsc.charInfo[i].valueHandle == CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE) { cyBle_hrsc.charInfo[i].valueHandle = discCharInfo->valueHandle; cyBle_hrsc.charInfo[i].properties = discCharInfo->properties; } else { CyBle_ApplCallback(CYBLE_EVT_GATTC_CHAR_DUPLICATION, &discCharInfo->uuid); } } } }
/****************************************************************************** ##Function Name: CyBle_HtscDiscoverCharDescriptorsEventHandler ******************************************************************************* Summary: This function is called on receiving a CYBLE_EVT_GATTC_FIND_INFO_RSP event. Based on the descriptor UUID, an appropriate data structure is populated using the data received as part of the callback. Parameters: discoveryCharIndex: The characteristic index which is discovered. *discDescrInfo: The pointer to a descriptor information structure. Return: None ******************************************************************************/ void CyBle_HtscDiscoverCharDescriptorsEventHandler(CYBLE_HTS_CHAR_INDEX_T discoveryCharIndex, CYBLE_DISC_DESCR_INFO_T *discDescrInfo) { CYBLE_HTS_DESCR_INDEX_T locDescIndex; if(CYBLE_UUID_CHAR_CLIENT_CONFIG == discDescrInfo->uuid.uuid16) { locDescIndex = CYBLE_HTS_CCCD; } else if(CYBLE_UUID_CHAR_VALID_RANGE == discDescrInfo->uuid.uuid16) { locDescIndex = CYBLE_HTS_VRD; } else /* Not supported descriptor */ { locDescIndex = CYBLE_HTS_DESCR_COUNT; } if(locDescIndex < CYBLE_HTS_DESCR_COUNT) { if(cyBle_htsc.charInfo[discoveryCharIndex].descrHandle[locDescIndex] == CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE) { cyBle_htsc.charInfo[discoveryCharIndex].descrHandle[locDescIndex] = discDescrInfo->descrHandle; } else /* Duplication of descriptor */ { CyBle_ApplCallback(CYBLE_EVT_GATTC_DESCR_DUPLICATION, &discDescrInfo->uuid); } } }
/****************************************************************************** ##Function Name: CyBle_GattcIndicationEventHandler ******************************************************************************* Summary: Handles the Indication Event. Parameters: *eventParam: The pointer to the data structure specified by the event. Return: None. ******************************************************************************/ void CyBle_GattcIndicationEventHandler(CYBLE_GATTC_HANDLE_VALUE_IND_PARAM_T *eventParam) { if(cyBle_gattc.serviceChanged.valueHandle == eventParam->handleValPair.attrHandle) { CyBle_ApplCallback((uint32)CYBLE_EVT_GATTC_INDICATION, eventParam); cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK; } }
/****************************************************************************** ##Function Name: CyBle_HrscDiscoverCharDescriptorsEventHandler ******************************************************************************* Summary: This function is called on receiving a CYBLE_EVT_GATTC_READ_BY_TYPE_RSP event. Based on the service UUID, an appropriate data structure is populated using the data received as part of the callback. Parameters: *discCharInfo: The pointer to a characteristic information structure. Return: None ******************************************************************************/ void CyBle_HrscDiscoverCharDescriptorsEventHandler(CYBLE_DISC_DESCR_INFO_T * discDescrInfo) { if(CYBLE_UUID_CHAR_CLIENT_CONFIG == discDescrInfo->uuid.uuid16) { if(cyBle_hrsc.hrmCccdHandle == CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE) { cyBle_hrsc.hrmCccdHandle = discDescrInfo->descrHandle; } else /* Duplication of descriptor */ { CyBle_ApplCallback(CYBLE_EVT_GATTC_DESCR_DUPLICATION, &discDescrInfo->uuid); } } }
/****************************************************************************** ##Function Name: CyBle_BlscDiscoverCharDescriptorsEventHandler ******************************************************************************* Summary: This function is called on receiving a "CYBLE_EVT_GATTC_READ_BY_TYPE_RSP" event. Based on the service UUID, an appropriate data structure is populated using the data received as part of the callback. Parameters: *discCharInfo: the pointer to a characteristic information structure. Return: None ******************************************************************************/ void CyBle_BlscDiscoverCharDescriptorsEventHandler(CYBLE_DISC_DESCR_INFO_T * discDescrInfo) { if(CYBLE_UUID_CHAR_CLIENT_CONFIG == discDescrInfo->uuid.uuid16) { uint8 descrIdx = cyBle_disCount - CYBLE_SCDI_BLS_BPM; if(cyBle_blsc.charInfo[descrIdx].cccdHandle == CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE) { cyBle_blsc.charInfo[descrIdx].cccdHandle = discDescrInfo->descrHandle; } else /* Duplication of descriptor */ { CyBle_ApplCallback(CYBLE_EVT_GATTC_DESCR_DUPLICATION, &discDescrInfo->uuid); } } }
/****************************************************************************** ##Function Name: CyBle_GlscDiscoverCharacteristicsEventHandler ******************************************************************************* Summary: This function is called on receiving a CYBLE_EVT_GATTC_READ_BY_TYPE_RSP event. Based on the service UUID, an appropriate data structure is populated using the data received as part of the callback. Parameters: *discCharInfo: The pointer to a characteristic information structure. Return: None ******************************************************************************/ void CyBle_GlscDiscoverCharacteristicsEventHandler(CYBLE_DISC_CHAR_INFO_T *discCharInfo) { /* Glucose Service characteristics UUIDs */ static const CYBLE_UUID16 cyBle_glscCharUuid[CYBLE_GLS_CHAR_COUNT] = { CYBLE_UUID_CHAR_GLUCOSE_MSRMNT, CYBLE_UUID_CHAR_GL_MSRMT_CTX, CYBLE_UUID_CHAR_GL_FEATURE, CYBLE_UUID_CHAR_RACP }; static CYBLE_GATT_DB_ATTR_HANDLE_T *glsLastEndHandle = NULL; uint8 i; /* Update last characteristic endHandle to declaration handle of this characteristic */ if(glsLastEndHandle != NULL) { *glsLastEndHandle = discCharInfo->charDeclHandle - 1u; glsLastEndHandle = NULL; } for(i = 0u; i < (uint8) CYBLE_GLS_CHAR_COUNT; i++) { if(cyBle_glscCharUuid[i] == discCharInfo->uuid.uuid16) { if(cyBle_glsc.charInfo[i].valueHandle == CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE) { cyBle_glsc.charInfo[i].valueHandle = discCharInfo->valueHandle; cyBle_glsc.charInfo[i].properties = discCharInfo->properties; glsLastEndHandle = &cyBle_glsc.charInfo[i].endHandle; } else { CyBle_ApplCallback(CYBLE_EVT_GATTC_CHAR_DUPLICATION, &discCharInfo->uuid); } } } /* Init characteristic endHandle to Service endHandle. Characteristic endHandle will be updated to the declaration Handler of the following characteristic, in the following characteristic discovery procedure. */ if(glsLastEndHandle != NULL) { *glsLastEndHandle = cyBle_serverInfo[CYBLE_SRVI_GLS].range.endHandle; } }
/****************************************************************************** * Function Name: CyBle_AnsDiscoverCharDescriptorsEventHandler ***************************************************************************//** * * This function is called on receiving a CYBLE_EVT_GATTC_FIND_INFO_RSP event. * This event is generated when a server successfully sends the data for * CYBLE_EVT_GATTC_FIND_INFO_REQ. Based on the service UUID, an appropriate data * structure is populated to the service with a service callback. * * \param CYBLE_DISC_DESCR_INFO_T * discCharInfo: The pointer to a characteristic * information structure. * ******************************************************************************/ void CyBle_AnscDiscoverCharDescriptorsEventHandler(CYBLE_DISC_DESCR_INFO_T * discDescrInfo) { if(discDescrInfo->uuid.uuid16 == CYBLE_UUID_CHAR_CLIENT_CONFIG) { if(cyBle_ansc.characteristics[CYBLE_ANS_NEW_ALERT].descriptors[CYBLE_ANS_CCCD] == CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE) { cyBle_ansc.characteristics[CYBLE_ANS_NEW_ALERT].descriptors[CYBLE_ANS_CCCD] = discDescrInfo->descrHandle; } else if(cyBle_ansc.characteristics[CYBLE_ANS_UNREAD_ALERT_STATUS].descriptors[CYBLE_ANS_CCCD] == CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE) { cyBle_ansc.characteristics[CYBLE_ANS_UNREAD_ALERT_STATUS].descriptors[CYBLE_ANS_CCCD] = discDescrInfo->descrHandle; } else /* Duplication of descriptor */ { CyBle_ApplCallback((uint32)CYBLE_EVT_GATTC_DESCR_DUPLICATION, &discDescrInfo->uuid); } } }
/****************************************************************************** ##Function Name: CyBle_HrssWriteEventHandler ******************************************************************************* Summary: Handles the Heart Rate Measurement Client Configuration Characteristic Descriptor Write Event or Control Point Characteristic Write Event. Parameters: void *eventParam: The pointer to the data structure specified by the event. Return: None ******************************************************************************/ CYBLE_GATT_ERR_CODE_T CyBle_HrssWriteEventHandler(CYBLE_GATTS_WRITE_REQ_PARAM_T *eventParam) { uint32 eventCode = 0u; CYBLE_GATT_ERR_CODE_T gattErr = CYBLE_GATT_ERR_NONE; CYBLE_HRS_CHAR_VALUE_T locCharIndex; locCharIndex.connHandle = eventParam->connHandle; locCharIndex.value = NULL; if(eventParam->handleValPair.attrHandle == cyBle_hrss.hrmCccdHandle) { locCharIndex.charIndex = CYBLE_HRS_HRM; /* Heart Rate Measurement characteristic descriptor write request */ if(CYBLE_IS_NOTIFICATION_ENABLED_IN_PTR(eventParam->handleValPair.value.val)) { eventCode = (uint32)CYBLE_EVT_HRSS_NOTIFICATION_ENABLED; } else { eventCode = (uint32)CYBLE_EVT_HRSS_NOTIFICATION_DISABLED; } #if((CYBLE_GAP_ROLE_PERIPHERAL || CYBLE_GAP_ROLE_CENTRAL) && (CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES)) /* Set flag to store bonding data to flash */ cyBle_pendingFlashWrite |= CYBLE_PENDING_CCCD_FLASH_WRITE_BIT; #endif /* (CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES) */ cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK; } else if(eventParam->handleValPair.attrHandle == cyBle_hrss.charHandle[CYBLE_HRS_CPT]) { locCharIndex.charIndex = CYBLE_HRS_CPT; /* Heart Rate Control Point characteristic write request */ if(CYBLE_HRS_RESET_ENERGY_EXPENDED == eventParam->handleValPair.value.val[0u]) { eventCode = (uint32)CYBLE_EVT_HRSS_ENERGY_EXPENDED_RESET; } else { gattErr = CYBLE_GATT_ERR_HEART_RATE_CONTROL_POINT_NOT_SUPPORTED; } cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK; } else { /* Heart Rate Service doesn't support any other write requests */ } if(0u != eventCode) { gattErr = CyBle_GattsWriteAttributeValue(&eventParam->handleValPair, 0u, &eventParam->connHandle, CYBLE_GATT_DB_PEER_INITIATED); if(CYBLE_GATT_ERR_NONE == gattErr) { if(NULL != CyBle_HrsApplCallback) { CyBle_HrsApplCallback(eventCode, &locCharIndex); } else { CyBle_ApplCallback(CYBLE_EVT_GATTS_WRITE_REQ, eventParam); } } } return (gattErr); }