/******************************************************************************
* Function Name: CyBle_IascSetCharacteristicValue
***************************************************************************//**
*
* Sets a Alert Level characteristic value of the service, which is identified
* by charIndex.
*
* \param connHandle: The connection handle.
* \param charIndex: The index of the Alert Level service characteristic.
* \param attrSize: The size of the Alert Level characteristic value attribute.
* \param attrValue: The pointer to the Alert Level characteristic value data that
* should be sent to the server device.
*
* \return
* Return value is of type CYBLE_API_RESULT_T.
* * CYBLE_ERROR_OK - The request was sent successfully
* * CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed
* * CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed
* * CYBLE_ERROR_INVALID_STATE - Connection with the server is not established
* * CYBLE_ERROR_INVALID_OPERATION - Operation is invalid for this
* characteristic
*
* \events
* In case of successful execution (return value = CYBLE_ERROR_OK)
* the next events can appear: \n
* If the IAS service-specific callback is registered
* (with CyBle_IasRegisterAttrCallback):
* * CYBLE_EVT_IASC_WRITE_CHAR_RESPONSE - in case if the requested attribute is
* successfully wrote on the peer device,
* the details (char index, etc.) are
* provided with event parameter structure
* of type CYBLE_IAS_CHAR_VALUE_T.
* .
* Otherwise (if the IAS service-specific callback is not registered):
* * CYBLE_EVT_GATTC_WRITE_RSP - in case if the requested attribute is
* successfully wrote on the peer device.
* * CYBLE_EVT_GATTC_ERROR_RSP - in case if there some trouble with the
* requested attribute on the peer device,
* the details are provided with event parameters
* structure (CYBLE_GATTC_ERR_RSP_PARAM_T).
*
******************************************************************************/
CYBLE_API_RESULT_T CyBle_IascSetCharacteristicValue(CYBLE_CONN_HANDLE_T connHandle,
CYBLE_IAS_CHAR_INDEX_T charIndex,
uint8 attrSize,
uint8 *attrValue)
{
CYBLE_GATTC_WRITE_CMD_REQ_T wrCmdReq;
CYBLE_API_RESULT_T apiResult = CYBLE_ERROR_INVALID_PARAMETER;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if((NULL != attrValue) && (CYBLE_IAS_ALERT_LEVEL == charIndex) && (CYBLE_IAS_ALERT_LEVEL_SIZE == attrSize) &&
(*attrValue <= CYBLE_HIGH_ALERT) &&
(CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE != cyBle_iasc.alertLevelChar.valueHandle))
{
/* Fill all fields of write command request structure ... */
wrCmdReq.value.val = attrValue;
wrCmdReq.value.len = attrSize;
wrCmdReq.attrHandle = cyBle_iasc.alertLevelChar.valueHandle;
/* Send request to write Alert Level characteristic value */
apiResult = CyBle_GattcWriteWithoutResponse(connHandle, &wrCmdReq);
}
else
{
/* apiResult equals CYBLE_ERROR_INVALID_PARAMETER */
}
/* Return status */
return(apiResult);
}
/******************************************************************************
##Function Name: CyBle_WptscSetCharacteristicValue
*******************************************************************************
Summary:
Sends a request to set a characteristic value of the service, which is a value
identified by charIndex, to the server device.
Parameters:
connHandle: The connection handle.
charIndex: The index of a service characteristic of type
CYBLE_WPTS_CHAR_INDEX_T.
attrSize: The size of the characteristic value attribute.
*attrValue: The pointer to the characteristic value data that
should be send to the server device.
Return:
Return value is of type CYBLE_API_RESULT_T.
* CYBLE_ERROR_OK - The request was sent successfully
* CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed
* CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed
* CYBLE_ERROR_INVALID_STATE - Connection with the server is not established
* CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE - The peer device doesn't have
the particular characteristic
* CYBLE_ERROR_INVALID_OPERATION - Operation is invalid for this
characteristic
******************************************************************************/
CYBLE_API_RESULT_T CyBle_WptscSetCharacteristicValue(CYBLE_CONN_HANDLE_T connHandle, CYBLE_WPTS_CHAR_INDEX_T charIndex,
uint8 attrSize, uint8 * attrValue)
{
CYBLE_API_RESULT_T apiResult;
CYBLE_GATT_HANDLE_VALUE_PAIR_T writeReqParam;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if(charIndex >= CYBLE_WPTS_CHAR_COUNT)
{
apiResult = CYBLE_ERROR_INVALID_PARAMETER;
}
else if(cyBle_wptsc.charInfo[charIndex].valueHandle != CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE)
{
writeReqParam.attrHandle = cyBle_wptsc.charInfo[charIndex].valueHandle;
writeReqParam.value.val = attrValue;
writeReqParam.value.len = attrSize;
apiResult = CyBle_GattcWriteCharacteristicValue(connHandle, &writeReqParam);
/* Save handle to support service specific write response from device */
if(apiResult == CYBLE_ERROR_OK)
{
cyBle_wptscReqHandle = writeReqParam.attrHandle;
}
}
else
{
apiResult = CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE;
}
return (apiResult);
}
/******************************************************************************
##Function Name: CyBle_WptscGetCharacteristicDescriptor
*******************************************************************************
Summary:
Sends a request to get the characteristic descriptor of the specified
characteristic of the service.
Parameters:
connHandle: The connection handle.
charIndex: The index of a service characteristic of type
CYBLE_WPTS_CHAR_INDEX_T.
descrIndex: The index of a service characteristic descriptor of type
CYBLE_WPTS_DESCR_INDEX_T.
Return:
* CYBLE_ERROR_OK - The request was sent successfully.
* CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed.
* CYBLE_ERROR_INVALID_STATE - The state is not valid.
* CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed.
* CYBLE_ERROR_INVALID_OPERATION - This operation is not permitted on
the specified attribute.
******************************************************************************/
CYBLE_API_RESULT_T CyBle_WptscGetCharacteristicDescriptor(CYBLE_CONN_HANDLE_T connHandle,
CYBLE_WPTS_CHAR_INDEX_T charIndex, CYBLE_WPTS_DESCR_INDEX_T descrIndex)
{
CYBLE_API_RESULT_T apiResult;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if((charIndex >= CYBLE_WPTS_CHAR_COUNT) || (descrIndex >= CYBLE_WPTS_DESCR_COUNT))
{
apiResult = CYBLE_ERROR_INVALID_PARAMETER;
}
else
{
apiResult = CyBle_GattcReadCharacteristicDescriptors(connHandle,
cyBle_wptsc.charInfo[charIndex].descrHandle[descrIndex]);
/* Save handle to support service specific read response from device */
if(apiResult == CYBLE_ERROR_OK)
{
cyBle_wptscReqHandle = cyBle_wptsc.charInfo[charIndex].descrHandle[descrIndex];
}
}
return (apiResult);
}
/******************************************************************************
##Function Name: CyBle_WptscSetCharacteristicDescriptor
*******************************************************************************
Summary:
This function is used to write the characteristic descriptor to the server,
which is identified by charIndex and descrIndex.
Parameters:
connHandle: The connection handle.
charIndex: The index of a service characteristic of type
CYBLE_WPTS_CHAR_INDEX_T.
descrIndex: The index of a service characteristic descriptor of type
CYBLE_WPTS_DESCR_INDEX_T.
attrSize: The size of the characteristic value attribute.
*attrValue: The pointer to the characteristic descriptor value data that
should be sent to the server device.
Return:
A return value is of type CYBLE_API_RESULT_T.
* CYBLE_ERROR_OK - The request was sent successfully.
* CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed.
* CYBLE_ERROR_INVALID_STATE - The state is not valid.
* CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed.
* CYBLE_ERROR_INVALID_OPERATION - This operation is not permitted on
the specified attribute.
******************************************************************************/
CYBLE_API_RESULT_T CyBle_WptscSetCharacteristicDescriptor(CYBLE_CONN_HANDLE_T connHandle,
CYBLE_WPTS_CHAR_INDEX_T charIndex, CYBLE_WPTS_DESCR_INDEX_T descrIndex, uint8 attrSize, uint8 *attrValue)
{
CYBLE_API_RESULT_T apiResult;
CYBLE_GATTC_WRITE_REQ_T writeReqParam;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if((charIndex >= CYBLE_WPTS_CHAR_COUNT) || (descrIndex >= CYBLE_WPTS_DESCR_COUNT))
{
apiResult = CYBLE_ERROR_INVALID_PARAMETER;
}
else
{
/* Fill all fields of write request structure ... */
writeReqParam.attrHandle = cyBle_wptsc.charInfo[charIndex].descrHandle[descrIndex];
writeReqParam.value.val = attrValue;
writeReqParam.value.len = attrSize;
/* ... and send request to server's device. */
apiResult = CyBle_GattcWriteCharacteristicDescriptors(connHandle, &writeReqParam);
/* Save handle to support service specific read response from device */
if(apiResult == CYBLE_ERROR_OK)
{
cyBle_wptscReqHandle = writeReqParam.attrHandle;
}
}
return (apiResult);
}
/******************************************************************************
##Function Name: CyBle_BascGetCharacteristicValue
*******************************************************************************
Summary:
This function is used to read the characteristic value from a server which
is identified by charIndex.
This function call can result in generation of the following events based on
the response from the server device.
* CYBLE_EVT_BASC_READ_CHAR_RESPONSE
* CYBLE_EVT_GATTC_ERROR_RSP
Parameters:
connHandle: The BLE peer device connection handle.
serviceIndex: Index of the service instance. e.g. If two Battery Services are
supported in your design, then first service will be identified
by serviceIndex of 0 and the second by serviceIndex of 1.
charIndex: The index of a service characteristic of type CYBLE_BAS_CHAR_INDEX_T.
Return:
Return value is of type CYBLE_API_RESULT_T.
* CYBLE_ERROR_OK - The read request was sent successfully
* CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed
* CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE - The peer device doesn't have
the particular characteristic
* CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed
* CYBLE_ERROR_INVALID_STATE - Connection with the server is not established
* CYBLE_ERROR_INVALID_OPERATION - Operation is invalid for this
characteristic
******************************************************************************/
CYBLE_API_RESULT_T CyBle_BascGetCharacteristicValue(CYBLE_CONN_HANDLE_T connHandle, uint8 serviceIndex,
CYBLE_BAS_CHAR_INDEX_T charIndex)
{
CYBLE_API_RESULT_T apiResult;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if((serviceIndex >= CYBLE_BASC_SERVICE_COUNT) || (charIndex > CYBLE_BAS_BATTERY_LEVEL))
{
apiResult = CYBLE_ERROR_INVALID_PARAMETER;
}
else if(cyBle_basc[serviceIndex].batteryLevel.valueHandle != CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE)
{
apiResult = CyBle_GattcReadCharacteristicValue(connHandle,
cyBle_basc[serviceIndex].batteryLevel.valueHandle);
/* Save handle to support service specific read response from device */
if(apiResult == CYBLE_ERROR_OK)
{
cyBle_bascReqHandle = cyBle_basc[serviceIndex].batteryLevel.valueHandle;
}
}
else
{
apiResult = CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE;
}
return (apiResult);
}
/******************************************************************************
##Function Name: CyBle_HrscGetCharacteristicValue
*******************************************************************************
Summary:
This function is used to read the characteristic Value from a server
which is identified by charIndex.
The Read Response returns the characteristic Value in the Attribute Value
parameter.
The Read Response only contains the characteristic Value that is less than or
equal to (MTU - 1) octets in length. If the characteristic Value is greater
than (MTU - 1) octets in length, the Read Long Characteristic Value procedure
may be used if the rest of the characteristic Value is required.
Parameters:
connHandle: The connection handle.
charIndex: The index of the service characteristic.
Return:
Return value is of type CYBLE_API_RESULT_T.
* CYBLE_ERROR_OK - The read request was sent successfully
* CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed
* CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE - The peer device doesn't have
the particular characteristic
* CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed
* CYBLE_ERROR_INVALID_STATE - Connection with the server is not established
* CYBLE_ERROR_INVALID_OPERATION - Operation is invalid for this
characteristic
******************************************************************************/
CYBLE_API_RESULT_T CyBle_HrscGetCharacteristicValue(CYBLE_CONN_HANDLE_T connHandle, CYBLE_HRS_CHAR_INDEX_T charIndex)
{
CYBLE_API_RESULT_T apiResult;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if(charIndex >= CYBLE_HRS_CHAR_COUNT)
{
apiResult = CYBLE_ERROR_INVALID_PARAMETER;
}
else if(CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE == cyBle_hrsc.charInfo[charIndex].valueHandle)
{
apiResult = CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE;
}
else if(0u == (CYBLE_CHAR_PROP_READ & cyBle_hrsc.charInfo[charIndex].properties))
{
apiResult = CYBLE_ERROR_INVALID_OPERATION;
}
else
{
apiResult = CyBle_GattcReadCharacteristicValue(connHandle, cyBle_hrsc.charInfo[charIndex].valueHandle);
if(apiResult == CYBLE_ERROR_OK)
{
cyBle_hrscReqHandle = cyBle_hrsc.charInfo[charIndex].valueHandle;
}
}
return (apiResult);
}
/******************************************************************************
##Function Name: CyBle_BcscGetCharacteristicDescriptor
*******************************************************************************
Summary:
Sends a request to get the characteristic descriptor of the specified
characteristic of the service.
Parameters:
connHandle: The connection handle.
charIndex: The index of the service characteristic. Starts with zero.
charInstance: The instance of the characteristic specified by "charIndex".
descrIndex: The index of the service characteristic descriptor.
Return:
* CYBLE_ERROR_OK - The request was sent successfully.
* CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed.
* CYBLE_ERROR_INVALID_STATE - The state is not valid.
* CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed.
* CYBLE_ERROR_INVALID_OPERATION - This operation is not permitted on
the specified attribute.
******************************************************************************/
CYBLE_API_RESULT_T CyBle_BcscGetCharacteristicDescriptor(CYBLE_CONN_HANDLE_T connHandle,
CYBLE_BCS_CHAR_INDEX_T charIndex, CYBLE_BCS_DESCR_INDEX_T descrIndex)
{
CYBLE_API_RESULT_T apiResult;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if((charIndex >= CYBLE_BCS_CHAR_COUNT) || (descrIndex >= CYBLE_BCS_DESCR_COUNT))
{
apiResult = CYBLE_ERROR_INVALID_PARAMETER;
}
else if(cyBle_bcsc.bodyCompositionMeasurementCccdHandle = CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE)
{
apiResult = CyBle_GattcReadCharacteristicDescriptors(connHandle, cyBle_bcsc.bodyCompositionMeasurementCccdHandle);
/* Save handle to support service specific read response from device */
if(apiResult == CYBLE_ERROR_OK)
{
cyBle_bcscReqHandle = cyBle_bcsc.bodyCompositionMeasurementCccdHandle;
}
}
else
{
apiResult = CYBLE_ERROR_INVALID_PARAMETER;
}
return (apiResult);
}
/******************************************************************************
* Function Name: CyBle_AnscSetCharacteristicValue
***************************************************************************//**
*
* This function is used to write the characteristic (which is identified by
* charIndex) value attribute in the server. As a result a Write Request is
* sent to the GATT Server and on successful execution of the request on the
* Server side the CYBLE_EVT_ANSS_CHAR_WRITE events is generated.
* On successful request execution on the Server side the Write Response is
* sent to the Client.
*
* \param connHandle: The connection handle.
* \param charIndex: The index of the service characteristic.
* \param attrSize: Size of the Characteristic value attribute.
* \param attrValue: Pointer to the characteristic value data that should be
* sent to the server device.
* \return
* Return value is of type CYBLE_API_RESULT_T.
* * CYBLE_ERROR_OK - The request was sent successfully.
* * CYBLE_ERROR_INVALID_STATE - The component in in invalid state for current
* operation.
* * CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed.
* * CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed.
* * CYBLE_ERROR_INVALID_OPERATION - Operation is invalid for this
* characteristic.
*
* \events
* In case of successful execution (return value = CYBLE_ERROR_OK)
* the next events can appear: \n
* If the ANS service-specific callback is registered
* (with CyBle_AnsRegisterAttrCallback):
* * CYBLE_EVT_ANSC_WRITE_CHAR_RESPONSE - in case if the requested attribute is
* successfully wrote on the peer device,
* the details (char index, etc.) are
* provided with event parameter structure
* of type CYBLE_ANS_CHAR_VALUE_T.
* .
* Otherwise (if the ANS service-specific callback is not registered):
* * CYBLE_EVT_GATTC_WRITE_RSP - in case if the requested attribute is
* successfully wrote on the peer device.
* * CYBLE_EVT_GATTC_ERROR_RSP - in case if there some trouble with the
* requested attribute on the peer device,
* the details are provided with event parameters
* structure (CYBLE_GATTC_ERR_RSP_PARAM_T).
*
******************************************************************************/
CYBLE_API_RESULT_T CyBle_AnscSetCharacteristicValue(CYBLE_CONN_HANDLE_T connHandle, CYBLE_ANS_CHAR_INDEX_T charIndex,
uint8 attrSize, uint8 *attrValue)
{
CYBLE_GATTC_WRITE_CMD_REQ_T writeReqParam;
CYBLE_API_RESULT_T apiResult = CYBLE_ERROR_INVALID_PARAMETER;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if((NULL != attrValue) && (CYBLE_ANS_ALERT_NTF_CONTROL_POINT == charIndex) &&
(CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE !=
cyBle_ansc.characteristics[CYBLE_ANS_ALERT_NTF_CONTROL_POINT].charInfo.valueHandle))
{
/* Fill all fields of write command request structure ... */
writeReqParam.value.val = attrValue;
writeReqParam.value.len = attrSize;
writeReqParam.attrHandle = cyBle_ansc.characteristics[CYBLE_ANS_ALERT_NTF_CONTROL_POINT].charInfo.valueHandle;
/* Send request to write characteristic value */
apiResult = CyBle_GattcWriteCharacteristicValue(connHandle, &writeReqParam);
/* Save handle to support service specific write response from device */
if(apiResult == CYBLE_ERROR_OK)
{
cyBle_anscReqHandle = writeReqParam.attrHandle;
}
}
else
{
/* Validation of the input parameters failed */
}
return(apiResult);
}
/******************************************************************************
##Function Name: CyBle_WptscGetCharacteristicValue
*******************************************************************************
Summary:
This function is used to read a characteristic value, which is a value
identified by charIndex, from the server.
Parameters:
connHandle: The connection handle.
charIndex: The index of a service characteristic of type
CYBLE_WPTS_CHAR_INDEX_T.
Return:
Return value is of type CYBLE_API_RESULT_T.
* CYBLE_ERROR_OK - The read request was sent successfully.
* CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed.
* CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE - The peer device doesn't have
the particular characteristic.
* CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed.
* CYBLE_ERROR_INVALID_STATE - Connection with the server is not established.
* CYBLE_ERROR_INVALID_OPERATION - Operation is invalid for this
characteristic.
******************************************************************************/
CYBLE_API_RESULT_T CyBle_WptscGetCharacteristicValue(CYBLE_CONN_HANDLE_T connHandle, CYBLE_WPTS_CHAR_INDEX_T charIndex)
{
CYBLE_API_RESULT_T apiResult;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if(charIndex >= CYBLE_WPTS_CHAR_COUNT)
{
apiResult = CYBLE_ERROR_INVALID_PARAMETER;
}
else if(cyBle_wptsc.charInfo[charIndex].valueHandle != CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE)
{
apiResult = CyBle_GattcReadCharacteristicValue(connHandle, cyBle_wptsc.charInfo[charIndex].valueHandle);
/* Save handle to support service specific read response from device */
if(apiResult == CYBLE_ERROR_OK)
{
cyBle_wptscReqHandle = cyBle_wptsc.charInfo[charIndex].valueHandle;
}
}
else
{
apiResult = CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE;
}
return (apiResult);
}
/******************************************************************************
##Function Name: CyBle_HrscGetCharacteristicDescriptor
*******************************************************************************
Summary:
Gets a characteristic descriptor of a specified characteristic of the service.
This function call can result in generation of the following events based on
the response from the server device:
* CYBLE_EVT_HRSC_READ_DESCR_RESPONSE
* CYBLE_EVT_GATTC_ERROR_RSP
Parameters:
connHandle: The connection handle.
charIndex: The index of the service characteristic.
descrIndex: The index of the service characteristic descriptor.
Return:
Return value is of type CYBLE_API_RESULT_T.
* CYBLE_ERROR_OK - The request was sent successfully
* CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed
* CYBLE_ERROR_INVALID_STATE - The state is not valid
* CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed
* CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE - The peer device doesn't have
the particular descriptor
* CYBLE_ERROR_INVALID_OPERATION - This operation is not permitted on
the specified attribute
******************************************************************************/
CYBLE_API_RESULT_T CyBle_HrscGetCharacteristicDescriptor(CYBLE_CONN_HANDLE_T connHandle,
CYBLE_HRS_CHAR_INDEX_T charIndex, CYBLE_HRS_DESCR_INDEX_T descrIndex)
{
CYBLE_API_RESULT_T apiResult;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if((charIndex >= CYBLE_HRS_CHAR_COUNT) || (descrIndex >= CYBLE_HRS_DESCR_COUNT))
{
apiResult = CYBLE_ERROR_INVALID_PARAMETER;
}
else if(charIndex != CYBLE_HRS_HRM)
{
apiResult = CYBLE_ERROR_INVALID_OPERATION;
}
else if(CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE == cyBle_hrsc.hrmCccdHandle)
{
apiResult = CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE;
}
else
{
apiResult = CyBle_GattcReadCharacteristicDescriptors(connHandle, cyBle_hrsc.hrmCccdHandle);
if(apiResult == CYBLE_ERROR_OK)
{
cyBle_hrscReqHandle = cyBle_hrsc.hrmCccdHandle;
}
}
return (apiResult);
}
/******************************************************************************
##Function Name: CyBle_GlscGetCharacteristicDescriptor
*******************************************************************************
Summary:
Gets the characteristic descriptor of the specified characteristic.
Parameters:
connHandle: The connection handle.
charIndex: The index of a service characteristic.
descrIndex: The index of the service characteristic descriptor.
Return:
Return value is of type CYBLE_API_RESULT_T.
* CYBLE_ERROR_OK - The request was sent successfully
* CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed
* CYBLE_ERROR_INVALID_STATE - The state is not valid
* CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed
* CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE - The peer device doesn't have
the particular descriptor
* CYBLE_ERROR_INVALID_OPERATION - This operation is not permitted on
the specified attribute
******************************************************************************/
CYBLE_API_RESULT_T CyBle_GlscGetCharacteristicDescriptor(CYBLE_CONN_HANDLE_T connHandle,
CYBLE_GLS_CHAR_INDEX_T charIndex, CYBLE_GLS_DESCR_INDEX_T descrIndex)
{
CYBLE_API_RESULT_T apiResult;
/* Check the parameters */
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if((charIndex >= CYBLE_GLS_CHAR_COUNT) || (descrIndex >= CYBLE_GLS_DESCR_COUNT))
{
apiResult = CYBLE_ERROR_INVALID_PARAMETER;
}
else if(CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE == cyBle_glsc.charInfo[charIndex].cccdHandle)
{
apiResult = CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE;
}
else
{
apiResult = CyBle_GattcReadCharacteristicDescriptors(connHandle, cyBle_glsc.charInfo[charIndex].cccdHandle);
if(CYBLE_ERROR_OK == apiResult)
{
cyBle_glscReqHandle = cyBle_glsc.charInfo[charIndex].cccdHandle;
}
}
return (apiResult);
}
/******************************************************************************
* Function Name: CyBle_GattcStartPartialDiscovery
***************************************************************************//**
*
* Starts the automatic server discovery process as per the range provided
* on a GATT Server to which it is connected. This API could be used for
* partial server discovery after indication received to the Service Changed
* Characteristic Value. Two events may be generated
* after calling this function - CYBLE_EVT_GATTC_DISCOVERY_COMPLETE or
* CYBLE_EVT_GATTC_ERROR_RSP. The CYBLE_EVT_GATTC_DISCOVERY_COMPLETE event is
* generated when the remote device was successfully discovered. The
* CYBLE_EVT_GATTC_ERROR_RSP is generated if the device discovery is failed.
*
* \param connHandle: The handle which consists of the device ID and ATT connection ID.
* \param startHandle: Start of affected attribute handle range.
* \param endHandle: End of affected attribute handle range.
*
* \return
* CYBLE_API_RESULT_T : Return value indicates if the function succeeded or
* failed. Following are the possible error codes.
*
* <table>
* <tr>
* <th>Errors codes</th>
* <th>Description</th>
* </tr>
* <tr>
* <td>CYBLE_ERROR_OK</td>
* <td>On successful operation</td>
* </tr>
* <tr>
* <td>CYBLE_ERROR_INVALID_PARAMETER</td>
* <td>'connHandle' value does not represent any existing entry.</td>
* </tr>
* <tr>
* <td>CYBLE_ERROR_INVALID_OPERATION</td>
* <td>The operation is not permitted</td>
* </tr>
* <tr>
* <td>CYBLE_ERROR_MEMORY_ALLOCATION_FAILED</td>
* <td>Memory allocation failed</td>
* </tr>
* <tr>
* <td>CYBLE_ERROR_INVALID_STATE</td>
* <td>If the function is called in any state except connected or discovered</td>
* </tr>
* </table>
*
******************************************************************************/
CYBLE_API_RESULT_T CyBle_GattcStartPartialDiscovery(CYBLE_CONN_HANDLE_T connHandle,
CYBLE_GATT_DB_ATTR_HANDLE_T startHandle, CYBLE_GATT_DB_ATTR_HANDLE_T endHandle)
{
uint8 j;
CYBLE_API_RESULT_T apiResult;
if((CyBle_GetState() != CYBLE_STATE_CONNECTED) ||
((CyBle_GetClientState() != CYBLE_CLIENT_STATE_CONNECTED) &&
(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)))
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else
{
/* Clean old discovery information of affected attribute range */
for(j = 0u; j < (uint8) CYBLE_SRVI_COUNT; j++)
{
if((cyBle_serverInfo[j].range.startHandle >= startHandle) &&
(cyBle_serverInfo[j].range.startHandle <= endHandle))
{
(void)memset(&cyBle_serverInfo[j].range, 0, sizeof(cyBle_serverInfo[0].range));
}
}
cyBle_connHandle = connHandle;
cyBle_gattcDiscoveryRange.startHandle = startHandle;
cyBle_gattcDiscoveryRange.endHandle = endHandle;
CyBle_ServiceInit();
apiResult = CyBle_GattcDiscoverPrimaryServices(connHandle, &cyBle_gattcDiscoveryRange);
if(CYBLE_ERROR_OK == apiResult)
{
CyBle_SetClientState(CYBLE_CLIENT_STATE_SRVC_DISCOVERING);
cyBle_eventHandlerFlag |= CYBLE_AUTO_DISCOVERY;
}
}
return (apiResult);
}
/******************************************************************************
* Function Name: CyBle_AnscSetCharacteristicDescriptor
***************************************************************************//**
*
* Sends a request to the peer device to set the characteristic descriptor of the
* specified characteristic of Alert Notification Service.
*
* Internally, Write Request is sent to the GATT Server and on successful
* execution of the request on the Server side the following events can be
* generated:
* * CYBLE_EVT_ANSS_NOTIFICATION_ENABLED
* * CYBLE_EVT_ANSS_NOTIFICATION_DISABLED
*
* \param connHandle: The BLE peer device connection handle.
* \param charIndex: The index of the ANS characteristic.
* \param descrIndex: The index of the ANS characteristic descriptor.
* \param attrSize: The size of the characteristic descriptor attribute.
* \param attrValue: Pointer to the characteristic descriptor value data that should be
* sent to the server device.
*
* \return
* Return value is of type CYBLE_API_RESULT_T.
* * CYBLE_ERROR_OK - The request was sent successfully.
* * CYBLE_ERROR_INVALID_STATE - The component in in invalid state for current
* operation.
* * CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed.
* * CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed.
* * CYBLE_ERROR_INVALID_OPERATION - Operation is invalid for this
* characteristic.
*
* \events
* In case of successful execution (return value = CYBLE_ERROR_OK)
* the next events can appear: \n
* If the ANS service-specific callback is registered
* (with CyBle_AnsRegisterAttrCallback):
* * CYBLE_EVT_ANSC_WRITE_DESCR_RESPONSE - in case if the requested attribute is
* successfully wrote on the peer device,
* the details (char index, descr index etc.) are
* provided with event parameter structure
* of type CYBLE_ANS_DESCR_VALUE_T.
* .
* Otherwise (if the ANS service-specific callback is not registered):
* * CYBLE_EVT_GATTC_WRITE_RSP - in case if the requested attribute is
* successfully wrote on the peer device.
* * CYBLE_EVT_GATTC_ERROR_RSP - in case if there some trouble with the
* requested attribute on the peer device,
* the details are provided with event parameters
* structure (CYBLE_GATTC_ERR_RSP_PARAM_T).
*
******************************************************************************/
CYBLE_API_RESULT_T CyBle_AnscSetCharacteristicDescriptor(CYBLE_CONN_HANDLE_T connHandle,
CYBLE_ANS_CHAR_INDEX_T charIndex,
CYBLE_ANS_DESCR_INDEX_T descrIndex,
uint8 attrSize,
uint8 *attrValue)
{
CYBLE_API_RESULT_T apiResult = CYBLE_ERROR_INVALID_PARAMETER;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if((attrValue != NULL) && (descrIndex == CYBLE_ANS_CCCD) && (attrSize == CYBLE_CCCD_LEN))
{
if((charIndex == CYBLE_ANS_NEW_ALERT) || (charIndex == CYBLE_ANS_UNREAD_ALERT_STATUS))
{
CYBLE_GATTC_WRITE_REQ_T writeReqParam;
/* Fill all fields of write request structure ... */
writeReqParam.value.val = attrValue;
writeReqParam.value.len = attrSize;
if(charIndex == CYBLE_ANS_NEW_ALERT)
{
writeReqParam.attrHandle =
cyBle_ansc.characteristics[CYBLE_ANS_NEW_ALERT].descriptors[CYBLE_ANS_CCCD];
}
else
{
writeReqParam.attrHandle =
cyBle_ansc.characteristics[CYBLE_ANS_UNREAD_ALERT_STATUS].descriptors[CYBLE_ANS_CCCD];
}
/* ... and send request to server device. */
apiResult = CyBle_GattcWriteCharacteristicDescriptors(connHandle, &writeReqParam);
if(apiResult == CYBLE_ERROR_OK)
{
cyBle_anscReqHandle = writeReqParam.attrHandle;
}
}
}
else
{
/* Characteristic has not been discovered or has invalid fields */
}
return(apiResult);
}
/******************************************************************************
* Function Name: CyBle_GattcStartDiscovery
***************************************************************************//**
*
* Starts the automatic server discovery process. Two events may be generated
* after calling this function - CYBLE_EVT_GATTC_DISCOVERY_COMPLETE or
* CYBLE_EVT_GATTC_ERROR_RSP. The CYBLE_EVT_GATTC_DISCOVERY_COMPLETE event is
* generated when the remote device was successfully discovered. The
* CYBLE_EVT_GATTC_ERROR_RSP is generated if the device discovery is failed.
*
* \param connHandle: The handle which consists of the device ID and ATT connection ID.
*
* \return
* CYBLE_API_RESULT_T : Return value indicates if the function succeeded or
* failed. Following are the possible error codes.
*
* <table>
* <tr>
* <th>Errors codes</th>
* <th>Description</th>
* </tr>
* <tr>
* <td>CYBLE_ERROR_OK</td>
* <td>On successful operation</td>
* </tr>
* <tr>
* <td>CYBLE_ERROR_INVALID_PARAMETER</td>
* <td>'connHandle' value does not represent any existing entry.</td>
* </tr>
* <tr>
* <td>CYBLE_ERROR_INVALID_OPERATION</td>
* <td>The operation is not permitted</td>
* </tr>
* <tr>
* <td>CYBLE_ERROR_MEMORY_ALLOCATION_FAILED</td>
* <td>Memory allocation failed</td>
* </tr>
* <tr>
* <td>CYBLE_ERROR_INVALID_STATE</td>
* <td>If the function is called in any state except connected or discovered</td>
* </tr>
* </table>
*
******************************************************************************/
CYBLE_API_RESULT_T CyBle_GattcStartDiscovery(CYBLE_CONN_HANDLE_T connHandle)
{
uint8 j;
CYBLE_API_RESULT_T apiResult;
if((CyBle_GetState() != CYBLE_STATE_CONNECTED) ||
((CyBle_GetClientState() != CYBLE_CLIENT_STATE_CONNECTED) &&
(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)))
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else
{
/* Clean old discovery information */
for(j = 0u; j < (uint8) CYBLE_SRVI_COUNT; j++)
{
(void)memset(&cyBle_serverInfo[j].range, 0, sizeof(cyBle_serverInfo[0].range));
}
cyBle_connHandle = connHandle;
cyBle_gattcDiscoveryRange.startHandle = CYBLE_GATT_ATTR_HANDLE_START_RANGE;
cyBle_gattcDiscoveryRange.endHandle = CYBLE_GATT_ATTR_HANDLE_END_RANGE;
CyBle_ServiceInit();
apiResult = CyBle_GattcDiscoverAllPrimaryServices(connHandle);
if(apiResult == CYBLE_ERROR_OK)
{
CyBle_SetClientState(CYBLE_CLIENT_STATE_SRVC_DISCOVERING);
cyBle_eventHandlerFlag |= CYBLE_AUTO_DISCOVERY;
}
}
return (apiResult);
}
/******************************************************************************
##Function Name: CyBle_HrscSetCharacteristicDescriptor
*******************************************************************************
Summary:
This function is used to write the characteristic Value to the server, which
is identified by charIndex.
This function call can result in generation of the following events based on
the response from the server device:
* CYBLE_EVT_HRSC_WRITE_DESCR_RESPONSE
* CYBLE_EVT_GATTC_ERROR_RSP
One of the following events is received by the peer device, on invoking
this function:
* CYBLE_EVT_HRSS_NOTIFICATION_ENABLED
* CYBLE_EVT_HRSS_NOTIFICATION_DISABLED
Parameters:
connHandle: The connection handle.
charIndex: The index of the service characteristic.
descrIndex: The index of the service characteristic descriptor.
attrSize: The size of the characteristic descriptor value attribute.
*attrValue: The pointer to the characteristic descriptor value data that
should be sent to the server device.
Return:
Return value is of type CYBLE_API_RESULT_T.
* CYBLE_ERROR_OK - The request was sent successfully
* CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed
* CYBLE_ERROR_INVALID_STATE - The state is not valid
* CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed
* CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE - The peer device doesn't have
the particular characteristic
* CYBLE_ERROR_INVALID_OPERATION - This operation is not permitted on
the specified attribute
******************************************************************************/
CYBLE_API_RESULT_T CyBle_HrscSetCharacteristicDescriptor(CYBLE_CONN_HANDLE_T connHandle,
CYBLE_HRS_CHAR_INDEX_T charIndex, CYBLE_HRS_DESCR_INDEX_T descrIndex, uint8 attrSize, uint8 * attrValue)
{
CYBLE_API_RESULT_T apiResult;
CYBLE_GATTC_WRITE_REQ_T writeReqParam;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if((charIndex >= CYBLE_HRS_CHAR_COUNT)
|| (descrIndex >= CYBLE_HRS_DESCR_COUNT)
|| (attrSize != CYBLE_CCCD_LEN))
{
apiResult = CYBLE_ERROR_INVALID_PARAMETER;
}
else if(charIndex != CYBLE_HRS_HRM)
{
apiResult = CYBLE_ERROR_INVALID_OPERATION;
}
else if(CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE == cyBle_hrsc.hrmCccdHandle)
{
apiResult = CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE;
}
else
{
/* Fill all fields of write request structure ... */
writeReqParam.attrHandle = cyBle_hrsc.hrmCccdHandle;
writeReqParam.value.val = attrValue;
writeReqParam.value.len = CYBLE_CCCD_LEN;
/* ... and send request to server device. */
apiResult = CyBle_GattcWriteCharacteristicDescriptors(connHandle, &writeReqParam);
/* Save handle to support service specific read response from device */
if(apiResult == CYBLE_ERROR_OK)
{
cyBle_hrscReqHandle = cyBle_hrsc.hrmCccdHandle;
}
}
return (apiResult);
}
/******************************************************************************
##Function Name: CyBle_GlscSetCharacteristicValue
*******************************************************************************
Summary:
This function is used to write the characteristic (which is identified by
charIndex) value attribute to the server.
The Write Response just confirms the operation success.
Parameters:
connHandle: The connection handle.
charIndex: The index of a service characteristic.
attrSize: The size of the characteristic value attribute.
*attrValue: The pointer to the characteristic value data that should be
sent to the server device.
Return:
Return value is of type CYBLE_API_RESULT_T.
* CYBLE_ERROR_OK - The request was sent successfully
* CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed
* CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed
* CYBLE_ERROR_INVALID_STATE - Connection with the server is not established
* CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE - The peer device doesn't have
the particular characteristic
* CYBLE_ERROR_INVALID_OPERATION - Operation is invalid for this
characteristic
******************************************************************************/
CYBLE_API_RESULT_T CyBle_GlscSetCharacteristicValue(CYBLE_CONN_HANDLE_T connHandle,
CYBLE_GLS_CHAR_INDEX_T charIndex,
uint8 attrSize, uint8 * attrValue)
{
CYBLE_API_RESULT_T apiResult;
/* Check the parameters */
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if(charIndex >= CYBLE_GLS_CHAR_COUNT)
{
apiResult = CYBLE_ERROR_INVALID_PARAMETER;
}
else if(CYBLE_GATT_INVALID_ATTR_HANDLE_VALUE == cyBle_glsc.charInfo[charIndex].valueHandle)
{
apiResult = CYBLE_ERROR_GATT_DB_INVALID_ATTR_HANDLE;
}
else if(0u == (CYBLE_CHAR_PROP_WRITE & cyBle_glsc.charInfo[charIndex].properties))
{
apiResult = CYBLE_ERROR_INVALID_OPERATION;
}
else
{
CYBLE_GATTC_WRITE_REQ_T writeReqParam;
writeReqParam.attrHandle = cyBle_glsc.charInfo[charIndex].valueHandle;
writeReqParam.value.val = attrValue;
writeReqParam.value.len = attrSize;
apiResult = CyBle_GattcWriteCharacteristicValue(connHandle, &writeReqParam);
if(CYBLE_ERROR_OK == apiResult)
{
cyBle_glscReqHandle = cyBle_glsc.charInfo[charIndex].valueHandle;
}
}
return (apiResult);
}
/******************************************************************************
* Function Name: CyBle_AnscGetCharacteristicValue
***************************************************************************//**
*
* Sends a request to the peer device to get a characteristic value, as
* identified by its charIndex.
*
* \param connHandle: The connection handle.
* \param charIndex: The index of the service characteristic.
*
* \return
* Return value is of type CYBLE_API_RESULT_T.
* * CYBLE_ERROR_OK - The request was sent successfully;
* * CYBLE_ERROR_INVALID_STATE - The component in in invalid state for current
* operation.
* * CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed.
* * CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed.
* * CYBLE_ERROR_INVALID_OPERATION - Operation is invalid for this
* characteristic.
*
* \events
* In case of successful execution (return value = CYBLE_ERROR_OK)
* the next events can appear: \n
* If the ANS service-specific callback is registered
* (with CyBle_AnsRegisterAttrCallback):
* * CYBLE_EVT_ANSC_READ_CHAR_RESPONSE - in case if the requested attribute is
* successfully wrote on the peer device,
* the details (char index , value, etc.) are
* provided with event parameter structure
* of type CYBLE_ANS_CHAR_VALUE_T.
* .
* Otherwise (if the ANS service-specific callback is not registered):
* * CYBLE_EVT_GATTC_READ_RSP - in case if the requested attribute is
* successfully read on the peer device,
* the details (handle, value, etc.) are
* provided with event parameters
* structure (CYBLE_GATTC_READ_RSP_PARAM_T).
* * CYBLE_EVT_GATTC_ERROR_RSP - in case if there some trouble with the
* requested attribute on the peer device,
* the details are provided with event parameters
* structure (CYBLE_GATTC_ERR_RSP_PARAM_T).
*
******************************************************************************/
CYBLE_API_RESULT_T CyBle_AnscGetCharacteristicValue(CYBLE_CONN_HANDLE_T connHandle, CYBLE_ANS_CHAR_INDEX_T charIndex)
{
CYBLE_GATT_DB_ATTR_HANDLE_T tmpCharHandle;
CYBLE_API_RESULT_T apiResult = CYBLE_ERROR_OK;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else
{
/* Select characteristic */
switch(charIndex)
{
case CYBLE_ANS_SUPPORTED_NEW_ALERT_CAT:
tmpCharHandle = cyBle_ansc.characteristics[CYBLE_ANS_SUPPORTED_NEW_ALERT_CAT].charInfo.valueHandle;
break;
case CYBLE_ANS_SUPPORTED_UNREAD_ALERT_CAT:
tmpCharHandle = cyBle_ansc.characteristics[CYBLE_ANS_SUPPORTED_UNREAD_ALERT_CAT].charInfo.valueHandle;
break;
default:
/* Characteristic wasn't found */
apiResult = CYBLE_ERROR_INVALID_PARAMETER;
break;
}
if(apiResult == CYBLE_ERROR_OK)
{
/* Send request to read characteristic value */
apiResult = CyBle_GattcReadCharacteristicValue(connHandle, tmpCharHandle);
if(apiResult == CYBLE_ERROR_OK)
{
cyBle_anscReqHandle = tmpCharHandle;
}
}
}
return(apiResult);
}
/******************************************************************************
##Function Name: CyBle_BascGetCharacteristicDescriptor
*******************************************************************************
Summary:
Sends a request to get characteristic descriptor of specified Battery Service
characteristic from the server device. This function call can result in
generation of the following events based on the response from the server
device.
* CYBLE_EVT_BASC_READ_DESCR_RESPONSE
* CYBLE_EVT_GATTC_ERROR_RSP
Parameters:
connHandle: The BLE peer device connection handle.
serviceIndex: Index of the service instance. e.g. If two Battery Services are
supported in your design, then first service will be identified
by serviceIndex of 0 and the second by serviceIndex of 1.
charIndex: The index of a Battery service characteristic of type
CYBLE_BAS_CHAR_INDEX_T.
descrIndex: The index of a Battery service characteristic descriptor of type
CYBLE_BAS_DESCR_INDEX_T.
Return:
* CYBLE_ERROR_OK - The request was sent successfully
* CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed
* CYBLE_ERROR_INVALID_STATE - The state is not valid
* CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed
* CYBLE_ERROR_INVALID_OPERATION - This operation is not permitted on
the specified attribute
******************************************************************************/
CYBLE_API_RESULT_T CyBle_BascGetCharacteristicDescriptor(CYBLE_CONN_HANDLE_T connHandle, uint8 serviceIndex,
CYBLE_BAS_CHAR_INDEX_T charIndex, CYBLE_BAS_DESCR_INDEX_T descrIndex)
{
CYBLE_API_RESULT_T apiResult;
CYBLE_GATT_DB_ATTR_HANDLE_T locDescrHandle;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if((serviceIndex >= CYBLE_BASC_SERVICE_COUNT)
|| (charIndex > CYBLE_BAS_BATTERY_LEVEL)
|| (descrIndex >= CYBLE_BAS_DESCR_COUNT))
{
apiResult = CYBLE_ERROR_INVALID_PARAMETER;
}
else
{
if(descrIndex == CYBLE_BAS_BATTERY_LEVEL_CCCD)
{
locDescrHandle = cyBle_basc[serviceIndex].cccdHandle;
}
else /* CYBLE_BAS_BATTERY_LEVEL_CPFD */
{
locDescrHandle = cyBle_basc[serviceIndex].cpfdHandle;
}
apiResult = CyBle_GattcReadCharacteristicDescriptors(connHandle, locDescrHandle);
/* Save handle to support service specific read response from device */
if(apiResult == CYBLE_ERROR_OK)
{
cyBle_bascReqHandle = locDescrHandle;
}
}
return (apiResult);
}
/******************************************************************************
##Function Name: CyBle_LlscGetCharacteristicValue
*******************************************************************************
Summary:
Sends a request to get characteristic value of the Link Loss Service, which
is identified by charIndex.
This function call can result in generation of the following events based on
the response from the server device:
* CYBLE_EVT_LLSC_READ_CHAR_RESPONSE
* CYBLE_EVT_GATTC_ERROR_RSP
Parameters:
connHandle: The connection handle.
charIndex: The index of the Link Loss Service characteristic.
Return:
Return value is of type CYBLE_API_RESULT_T.
* CYBLE_ERROR_OK - The request was sent successfully
* CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed
* CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed.
* CYBLE_ERROR_INVALID_STATE - Connection with the server is not established
* CYBLE_ERROR_INVALID_OPERATION - Operation is invalid for this
characteristic
******************************************************************************/
CYBLE_API_RESULT_T CyBle_LlscGetCharacteristicValue(CYBLE_CONN_HANDLE_T connHandle, CYBLE_LLS_CHAR_INDEX_T charIndex)
{
CYBLE_API_RESULT_T apiResult = CYBLE_ERROR_INVALID_PARAMETER;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if((CYBLE_LLS_ALERT_LEVEL == charIndex))
{
cyBle_llscReqHandle = cyBle_llsc.alertLevelChar.valueHandle;
/* Send request to write Alert Level characteristic value */
apiResult = CyBle_GattcReadCharacteristicValue(connHandle, cyBle_llsc.alertLevelChar.valueHandle);
}
else
{
/* apiResult equals CYBLE_ERROR_INVALID_PARAMETER */
}
/* Return status */
return(apiResult);
}
/******************************************************************************
* Function Name: CyBle_AnscGetCharacteristicDescriptor
***************************************************************************//**
*
* Sends a request to the peer device to get the characteristic descriptor of the
* specified characteristic of Alert Notification Service.
*
* \param connHandle: BLE peer device connection handle.
* \param charIndex: The index of the Service Characteristic.
* \param descrIndex: The index of the Service Characteristic Descriptor.
*
* \return
* Return value is of type CYBLE_API_RESULT_T.
* * CYBLE_ERROR_OK - A request was sent successfully.
* * CYBLE_ERROR_INVALID_PARAMETER - Validation of the input parameters failed.
* * CYBLE_ERROR_INVALID_STATE - The component is in invalid state for current
* operation.
* * CYBLE_ERROR_MEMORY_ALLOCATION_FAILED - Memory allocation failed.
* * CYBLE_ERROR_INVALID_OPERATION - Cannot process a request to send PDU due
* to invalid operation performed by the
* application.
*
* \events
* In case of successful execution (return value = CYBLE_ERROR_OK)
* the next events can appear: \n
* If the ANS service-specific callback is registered
* (with CyBle_AnsRegisterAttrCallback):
* * CYBLE_EVT_ANSC_READ_DESCR_RESPONSE - in case if the requested attribute is
* successfully wrote on the peer device,
* the details (char index, descr index, value, etc.)
* are provided with event parameter structure
* of type CYBLE_ANS_DESCR_VALUE_T.
* .
* Otherwise (if the ANS service-specific callback is not registered):
* * CYBLE_EVT_GATTC_READ_RSP - in case if the requested attribute is
* successfully read on the peer device,
* the details (handle, value, etc.) are
* provided with event parameters
* structure (CYBLE_GATTC_READ_RSP_PARAM_T).
* * CYBLE_EVT_GATTC_ERROR_RSP - in case if there some trouble with the
* requested attribute on the peer device,
* the details are provided with event parameters
* structure (CYBLE_GATTC_ERR_RSP_PARAM_T).
*
******************************************************************************/
CYBLE_API_RESULT_T CyBle_AnscGetCharacteristicDescriptor(CYBLE_CONN_HANDLE_T connHandle,
CYBLE_ANS_CHAR_INDEX_T charIndex,
uint8 descrIndex)
{
CYBLE_GATT_DB_ATTR_HANDLE_T tmpHandle;
CYBLE_API_RESULT_T apiResult = CYBLE_ERROR_INVALID_PARAMETER;
if(CyBle_GetClientState() != CYBLE_CLIENT_STATE_DISCOVERED)
{
apiResult = CYBLE_ERROR_INVALID_STATE;
}
else if(((charIndex == CYBLE_ANS_NEW_ALERT) || (charIndex == CYBLE_ANS_UNREAD_ALERT_STATUS)) &&
(descrIndex == (uint8) CYBLE_ANS_CCCD))
{
if(charIndex == CYBLE_ANS_NEW_ALERT)
{
tmpHandle = cyBle_ansc.characteristics[CYBLE_ANS_NEW_ALERT].descriptors[CYBLE_ANS_CCCD];
}
else
{
tmpHandle = cyBle_ansc.characteristics[CYBLE_ANS_UNREAD_ALERT_STATUS].descriptors[CYBLE_ANS_CCCD];
}
apiResult = CyBle_GattcReadCharacteristicDescriptors(connHandle, tmpHandle);
if(apiResult == CYBLE_ERROR_OK)
{
cyBle_anscReqHandle = tmpHandle;
}
}
else
{
/* Characteristic has not been discovered or had invalid fields */
}
return(apiResult);
}
/*******************************************************************************
* Function Name: BLE_Run
********************************************************************************
*
* Summary:
* BLE interface processing engine. This API should be continuously called by
* the application in its main loop.
*
* Parameters:
* None
*
* Return:
* None
*
*******************************************************************************/
uint8 BLE_Run(void)
{
#if (BLE_GATT_CLIENT_ENABLE)
CYBLE_API_RESULT_T status;
switch(bleStatus)
{
case BLE_CONNECTED:
status = StartTimeServiceDiscovery();
if(CYBLE_ERROR_OK == status)
{
bleStatus = BLE_DISCOVEER_GATT_SERVICES;
}
else
{
bleStatus = BLE_INVALID_OPERATION;
}
#if(CONSOLE_LOG_ENABLED)
printf("BLE connection established \r\n\n");
#endif /* End of #if(CONSOLE_LOG_ENABLED) */
break;
case BLE_READ_TIME:
if(CyBle_GetClientState() == CYBLE_CLIENT_STATE_DISCOVERED)
{
status = SyncTimeFromBleTimeServer();
if(CYBLE_ERROR_OK == status)
{
bleStatus = BLE_IDLE;
}
else
{
bleStatus = BLE_INVALID_OPERATION;
}
}
break;
case BLE_INITIATE_AUTHENTICATION:
CyBle_GapAuthReq(cyBle_connHandle.bdHandle, &cyBle_authInfo);
bleStatus = BLE_AUTHENTICATION_IN_PROGRESS;
break;
default:
break;
}
#endif
CyBle_ProcessEvents();
/* Store bonding data to flash only when all debug information has been sent */
if((cyBle_pendingFlashWrite != 0u)
#if(CONSOLE_LOG_ENABLED)
&&((Debug_Console_SpiUartGetTxBufferSize() + Debug_Console_GET_TX_FIFO_SR_VALID) == 0u)
#endif
)
{
status = CyBle_StoreBondingData(0u);
}
#if DISCONNECT_BLE_AFTER_TIME_SYNC
if(BLE_IsDisconnectionRequestPending())
{
BLE_SendDisconnection();
}
#endif
return bleStatus;
}